/* LzmaEnc.c -- LZMA Encoder\r
-2018-04-29 : Igor Pavlov : Public domain */\r
+2019-01-10: Igor Pavlov : Public domain */\r
\r
#include "Precomp.h"\r
\r
#define kNumBitPriceShiftBits 4\r
#define kBitPrice (1 << kNumBitPriceShiftBits)\r
\r
+#define REP_LEN_COUNT 64\r
+\r
void LzmaEncProps_Init(CLzmaEncProps *p)\r
{\r
p->level = 5;\r
int level = p->level;\r
if (level < 0) level = 5;\r
p->level = level;\r
- \r
+\r
if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level <= 7 ? (1 << 25) : (1 << 26)));\r
if (p->dictSize > p->reduceSize)\r
{\r
if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);\r
if (p->numHashBytes < 0) p->numHashBytes = 4;\r
if (p->mc == 0) p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);\r
- \r
+\r
if (p->numThreads < 0)\r
p->numThreads =\r
#ifndef _7ZIP_ST\r
g_FastPos[0] = 0;\r
g_FastPos[1] = 1;\r
g_FastPos += 2;\r
- \r
+\r
for (slot = 2; slot < kNumLogBits * 2; slot++)\r
{\r
size_t k = ((size_t)1 << ((slot >> 1) - 1));\r
} COptimal;\r
\r
\r
-#define kNumOpts (1 << 12)\r
-#define kPackReserve (1 + kNumOpts * 2)\r
+// 18.06\r
+#define kNumOpts (1 << 11)\r
+#define kPackReserve (kNumOpts * 8)\r
+// #define kNumOpts (1 << 12)\r
+// #define kPackReserve (1 + kNumOpts * 2)\r
\r
#define kNumLenToPosStates 4\r
#define kNumPosSlotBits 6\r
typedef struct\r
{\r
unsigned tableSize;\r
- unsigned counters[LZMA_NUM_PB_STATES_MAX];\r
UInt32 prices[LZMA_NUM_PB_STATES_MAX][kLenNumSymbolsTotal];\r
+ // UInt32 prices1[LZMA_NUM_PB_STATES_MAX][kLenNumLowSymbols * 2];\r
+ // UInt32 prices2[kLenNumSymbolsTotal];\r
} CLenPriceEnc;\r
\r
+#define GET_PRICE_LEN(p, posState, len) \\r
+ ((p)->prices[posState][(size_t)(len) - LZMA_MATCH_LEN_MIN])\r
+\r
+/*\r
+#define GET_PRICE_LEN(p, posState, len) \\r
+ ((p)->prices2[(size_t)(len) - 2] + ((p)->prices1[posState][((len) - 2) & (kLenNumLowSymbols * 2 - 1)] & (((len) - 2 - kLenNumLowSymbols * 2) >> 9)))\r
+*/\r
\r
typedef struct\r
{\r
\r
CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];\r
CLzmaProb posEncoders[kNumFullDistances];\r
- \r
+\r
CLenEnc lenProbs;\r
CLenEnc repLenProbs;\r
\r
unsigned lc, lp, pb;\r
unsigned lclp;\r
\r
- Bool fastMode;\r
- Bool writeEndMark;\r
- Bool finished;\r
- Bool multiThread;\r
- Bool needInit;\r
+ BoolInt fastMode;\r
+ BoolInt writeEndMark;\r
+ BoolInt finished;\r
+ BoolInt multiThread;\r
+ BoolInt needInit;\r
+ // BoolInt _maxMode;\r
\r
UInt64 nowPos64;\r
- \r
+\r
unsigned matchPriceCount;\r
- unsigned alignPriceCount;\r
+ // unsigned alignPriceCount;\r
+ int repLenEncCounter;\r
\r
unsigned distTableSize;\r
\r
SRes result;\r
\r
#ifndef _7ZIP_ST\r
- Bool mtMode;\r
+ BoolInt mtMode;\r
// begin of CMatchFinderMt is used in LZ thread\r
CMatchFinderMt matchFinderMt;\r
// end of CMatchFinderMt is used in BT and HASH threads\r
#ifndef _7ZIP_ST\r
Byte pad[128];\r
#endif\r
- \r
+\r
// LZ thread\r
CProbPrice ProbPrices[kBitModelTotal >> kNumMoveReducingBits];\r
\r
CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];\r
CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];\r
CLzmaProb posEncoders[kNumFullDistances];\r
- \r
+\r
CLenEnc lenProbs;\r
CLenEnc repLenProbs;\r
\r
{\r
CLzmaEnc *p = (CLzmaEnc *)pp;\r
CSaveState *dest = &p->saveState;\r
- \r
+\r
dest->state = p->state;\r
- \r
+\r
dest->lenProbs = p->lenProbs;\r
dest->repLenProbs = p->repLenProbs;\r
\r
\r
dest->lenProbs = p->lenProbs;\r
dest->repLenProbs = p->repLenProbs;\r
- \r
+\r
COPY_ARR(dest, p, reps);\r
- \r
+\r
COPY_ARR(dest, p, posAlignEncoder);\r
COPY_ARR(dest, p, isRep);\r
COPY_ARR(dest, p, isRepG0);\r
p->lp = props.lp;\r
p->pb = props.pb;\r
p->fastMode = (props.algo == 0);\r
+ // p->_maxMode = True;\r
p->matchFinderBase.btMode = (Byte)(props.btMode ? 1 : 0);\r
{\r
unsigned numHashBytes = 4;\r
\r
#ifdef _LZMA_ENC_USE_BRANCH\r
\r
-#define RC_BIT(p, prob, symbol) { \\r
+#define RC_BIT(p, prob, bit) { \\r
RC_BIT_PRE(p, prob) \\r
- if (symbol == 0) { range = newBound; ttt += (kBitModelTotal - ttt) >> kNumMoveBits; } \\r
+ if (bit == 0) { range = newBound; ttt += (kBitModelTotal - ttt) >> kNumMoveBits; } \\r
else { (p)->low += newBound; range -= newBound; ttt -= ttt >> kNumMoveBits; } \\r
*(prob) = (CLzmaProb)ttt; \\r
RC_NORM(p) \\r
\r
#else\r
\r
-#define RC_BIT(p, prob, symbol) { \\r
+#define RC_BIT(p, prob, bit) { \\r
UInt32 mask; \\r
RC_BIT_PRE(p, prob) \\r
- mask = 0 - (UInt32)symbol; \\r
+ mask = 0 - (UInt32)bit; \\r
range &= mask; \\r
mask &= newBound; \\r
range -= mask; \\r
(p)->low += mask; \\r
- mask = (UInt32)symbol - 1; \\r
+ mask = (UInt32)bit - 1; \\r
range += newBound & mask; \\r
mask &= (kBitModelTotal - ((1 << kNumMoveBits) - 1)); \\r
mask += ((1 << kNumMoveBits) - 1); \\r
p->range = range;\r
}\r
\r
-static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 symbol)\r
+static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 sym)\r
{\r
UInt32 range = p->range;\r
- symbol |= 0x100;\r
+ sym |= 0x100;\r
do\r
{\r
UInt32 ttt, newBound;\r
- // RangeEnc_EncodeBit(p, probs + (symbol >> 8), (symbol >> 7) & 1);\r
- CLzmaProb *prob = probs + (symbol >> 8);\r
- UInt32 bit = (symbol >> 7) & 1;\r
- symbol <<= 1;\r
+ // RangeEnc_EncodeBit(p, probs + (sym >> 8), (sym >> 7) & 1);\r
+ CLzmaProb *prob = probs + (sym >> 8);\r
+ UInt32 bit = (sym >> 7) & 1;\r
+ sym <<= 1;\r
RC_BIT(p, prob, bit);\r
}\r
- while (symbol < 0x10000);\r
+ while (sym < 0x10000);\r
p->range = range;\r
}\r
\r
-static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 symbol, UInt32 matchByte)\r
+static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 sym, UInt32 matchByte)\r
{\r
UInt32 range = p->range;\r
UInt32 offs = 0x100;\r
- symbol |= 0x100;\r
+ sym |= 0x100;\r
do\r
{\r
UInt32 ttt, newBound;\r
CLzmaProb *prob;\r
UInt32 bit;\r
matchByte <<= 1;\r
- // RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (symbol >> 8)), (symbol >> 7) & 1);\r
- prob = probs + (offs + (matchByte & offs) + (symbol >> 8));\r
- bit = (symbol >> 7) & 1;\r
- symbol <<= 1;\r
- offs &= ~(matchByte ^ symbol);\r
+ // RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (sym >> 8)), (sym >> 7) & 1);\r
+ prob = probs + (offs + (matchByte & offs) + (sym >> 8));\r
+ bit = (sym >> 7) & 1;\r
+ sym <<= 1;\r
+ offs &= ~(matchByte ^ sym);\r
RC_BIT(p, prob, bit);\r
}\r
- while (symbol < 0x10000);\r
+ while (sym < 0x10000);\r
p->range = range;\r
}\r
\r
}\r
\r
\r
-#define GET_PRICE(prob, symbol) \\r
- p->ProbPrices[((prob) ^ (unsigned)(((-(int)(symbol))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];\r
+#define GET_PRICE(prob, bit) \\r
+ p->ProbPrices[((prob) ^ (unsigned)(((-(int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];\r
\r
-#define GET_PRICEa(prob, symbol) \\r
- ProbPrices[((prob) ^ (unsigned)((-((int)(symbol))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];\r
+#define GET_PRICEa(prob, bit) \\r
+ ProbPrices[((prob) ^ (unsigned)((-((int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];\r
\r
#define GET_PRICE_0(prob) p->ProbPrices[(prob) >> kNumMoveReducingBits]\r
#define GET_PRICE_1(prob) p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]\r
#define GET_PRICEa_1(prob) ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]\r
\r
\r
-static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 symbol, const CProbPrice *ProbPrices)\r
+static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 sym, const CProbPrice *ProbPrices)\r
{\r
UInt32 price = 0;\r
- symbol |= 0x100;\r
+ sym |= 0x100;\r
do\r
{\r
- unsigned bit = symbol & 1;\r
- symbol >>= 1;\r
- price += GET_PRICEa(probs[symbol], bit);\r
+ unsigned bit = sym & 1;\r
+ sym >>= 1;\r
+ price += GET_PRICEa(probs[sym], bit);\r
}\r
- while (symbol >= 2);\r
+ while (sym >= 2);\r
return price;\r
}\r
\r
\r
-static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 symbol, UInt32 matchByte, const CProbPrice *ProbPrices)\r
+static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 sym, UInt32 matchByte, const CProbPrice *ProbPrices)\r
{\r
UInt32 price = 0;\r
UInt32 offs = 0x100;\r
- symbol |= 0x100;\r
+ sym |= 0x100;\r
do\r
{\r
matchByte <<= 1;\r
- price += GET_PRICEa(probs[offs + (matchByte & offs) + (symbol >> 8)], (symbol >> 7) & 1);\r
- symbol <<= 1;\r
- offs &= ~(matchByte ^ symbol);\r
+ price += GET_PRICEa(probs[offs + (matchByte & offs) + (sym >> 8)], (sym >> 7) & 1);\r
+ sym <<= 1;\r
+ offs &= ~(matchByte ^ sym);\r
}\r
- while (symbol < 0x10000);\r
+ while (sym < 0x10000);\r
return price;\r
}\r
\r
\r
-static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, unsigned numBits, UInt32 symbol)\r
+static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, unsigned numBits, unsigned sym)\r
{\r
UInt32 range = rc->range;\r
unsigned m = 1;\r
do\r
{\r
UInt32 ttt, newBound;\r
- unsigned bit = symbol & 1;\r
+ unsigned bit = sym & 1;\r
// RangeEnc_EncodeBit(rc, probs + m, bit);\r
- symbol >>= 1;\r
+ sym >>= 1;\r
RC_BIT(rc, probs + m, bit);\r
m = (m << 1) | bit;\r
}\r
p->high[i] = kProbInitValue;\r
}\r
\r
-static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned symbol, unsigned posState)\r
+static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned sym, unsigned posState)\r
{\r
UInt32 range, ttt, newBound;\r
CLzmaProb *probs = p->low;\r
range = rc->range;\r
RC_BIT_PRE(rc, probs);\r
- if (symbol >= kLenNumLowSymbols)\r
+ if (sym >= kLenNumLowSymbols)\r
{\r
RC_BIT_1(rc, probs);\r
probs += kLenNumLowSymbols;\r
RC_BIT_PRE(rc, probs);\r
- if (symbol >= kLenNumLowSymbols * 2)\r
+ if (sym >= kLenNumLowSymbols * 2)\r
{\r
RC_BIT_1(rc, probs);\r
rc->range = range;\r
- // RcTree_Encode(rc, p->high, kLenNumHighBits, symbol - kLenNumLowSymbols * 2);\r
- LitEnc_Encode(rc, p->high, symbol - kLenNumLowSymbols * 2);\r
+ // RcTree_Encode(rc, p->high, kLenNumHighBits, sym - kLenNumLowSymbols * 2);\r
+ LitEnc_Encode(rc, p->high, sym - kLenNumLowSymbols * 2);\r
return;\r
}\r
- symbol -= kLenNumLowSymbols;\r
+ sym -= kLenNumLowSymbols;\r
}\r
\r
- // RcTree_Encode(rc, probs + (posState << kLenNumLowBits), kLenNumLowBits, symbol);\r
+ // RcTree_Encode(rc, probs + (posState << kLenNumLowBits), kLenNumLowBits, sym);\r
{\r
unsigned m;\r
unsigned bit;\r
RC_BIT_0(rc, probs);\r
probs += (posState << (1 + kLenNumLowBits));\r
- bit = (symbol >> 2) ; RC_BIT(rc, probs + 1, bit); m = (1 << 1) + bit;\r
- bit = (symbol >> 1) & 1; RC_BIT(rc, probs + m, bit); m = (m << 1) + bit;\r
- bit = symbol & 1; RC_BIT(rc, probs + m, bit);\r
+ bit = (sym >> 2) ; RC_BIT(rc, probs + 1, bit); m = (1 << 1) + bit;\r
+ bit = (sym >> 1) & 1; RC_BIT(rc, probs + m, bit); m = (m << 1) + bit;\r
+ bit = sym & 1; RC_BIT(rc, probs + m, bit);\r
rc->range = range;\r
}\r
}\r
}\r
\r
\r
-MY_NO_INLINE static void MY_FAST_CALL LenPriceEnc_UpdateTable(\r
- CLenPriceEnc *p, unsigned posState,\r
+MY_NO_INLINE static void MY_FAST_CALL LenPriceEnc_UpdateTables(\r
+ CLenPriceEnc *p,\r
+ unsigned numPosStates,\r
const CLenEnc *enc,\r
const CProbPrice *ProbPrices)\r
{\r
- // int y; for (y = 0; y < 100; y++) {\r
- UInt32 a;\r
- unsigned i, numSymbols;\r
+ UInt32 b;\r
+\r
+ {\r
+ unsigned prob = enc->low[0];\r
+ UInt32 a, c;\r
+ unsigned posState;\r
+ b = GET_PRICEa_1(prob);\r
+ a = GET_PRICEa_0(prob);\r
+ c = b + GET_PRICEa_0(enc->low[kLenNumLowSymbols]);\r
+ for (posState = 0; posState < numPosStates; posState++)\r
+ {\r
+ UInt32 *prices = p->prices[posState];\r
+ const CLzmaProb *probs = enc->low + (posState << (1 + kLenNumLowBits));\r
+ SetPrices_3(probs, a, prices, ProbPrices);\r
+ SetPrices_3(probs + kLenNumLowSymbols, c, prices + kLenNumLowSymbols, ProbPrices);\r
+ }\r
+ }\r
\r
- UInt32 *prices = p->prices[posState];\r
+ /*\r
{\r
- const CLzmaProb *probs = enc->low + (posState << (1 + kLenNumLowBits));\r
- SetPrices_3(probs, GET_PRICEa_0(enc->low[0]), prices, ProbPrices);\r
+ unsigned i;\r
+ UInt32 b;\r
+ a = GET_PRICEa_0(enc->low[0]);\r
+ for (i = 0; i < kLenNumLowSymbols; i++)\r
+ p->prices2[i] = a;\r
a = GET_PRICEa_1(enc->low[0]);\r
- SetPrices_3(probs + kLenNumLowSymbols, a + GET_PRICEa_0(enc->low[kLenNumLowSymbols]), prices + kLenNumLowSymbols, ProbPrices);\r
+ b = a + GET_PRICEa_0(enc->low[kLenNumLowSymbols]);\r
+ for (i = kLenNumLowSymbols; i < kLenNumLowSymbols * 2; i++)\r
+ p->prices2[i] = b;\r
a += GET_PRICEa_1(enc->low[kLenNumLowSymbols]);\r
}\r
- numSymbols = p->tableSize;\r
- p->counters[posState] = numSymbols;\r
- for (i = kLenNumLowSymbols * 2; i < numSymbols; i += 1)\r
+ */\r
+\r
+ // p->counter = numSymbols;\r
+ // p->counter = 64;\r
+\r
{\r
- prices[i] = a +\r
- // RcTree_GetPrice(enc->high, kLenNumHighBits, i - kLenNumLowSymbols * 2, ProbPrices);\r
- LitEnc_GetPrice(enc->high, i - kLenNumLowSymbols * 2, ProbPrices);\r
- /*\r
- unsigned sym = (i - kLenNumLowSymbols * 2) >> 1;\r
- UInt32 price = a + RcTree_GetPrice(enc->high, kLenNumHighBits - 1, sym, ProbPrices);\r
- UInt32 prob = enc->high[(1 << 7) + sym];\r
- prices[i ] = price + GET_PRICEa_0(prob);\r
- prices[i + 1] = price + GET_PRICEa_1(prob);\r
- */\r
- }\r
- // }\r
-}\r
+ unsigned i = p->tableSize;\r
\r
-static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned numPosStates,\r
- const CLenEnc *enc,\r
- const CProbPrice *ProbPrices)\r
-{\r
- unsigned posState;\r
- for (posState = 0; posState < numPosStates; posState++)\r
- LenPriceEnc_UpdateTable(p, posState, enc, ProbPrices);\r
-}\r
+ if (i > kLenNumLowSymbols * 2)\r
+ {\r
+ const CLzmaProb *probs = enc->high;\r
+ UInt32 *prices = p->prices[0] + kLenNumLowSymbols * 2;\r
+ i -= kLenNumLowSymbols * 2 - 1;\r
+ i >>= 1;\r
+ b += GET_PRICEa_1(enc->low[kLenNumLowSymbols]);\r
+ do\r
+ {\r
+ /*\r
+ p->prices2[i] = a +\r
+ // RcTree_GetPrice(enc->high, kLenNumHighBits, i - kLenNumLowSymbols * 2, ProbPrices);\r
+ LitEnc_GetPrice(probs, i - kLenNumLowSymbols * 2, ProbPrices);\r
+ */\r
+ // UInt32 price = a + RcTree_GetPrice(probs, kLenNumHighBits - 1, sym, ProbPrices);\r
+ unsigned sym = --i + (1 << (kLenNumHighBits - 1));\r
+ UInt32 price = b;\r
+ do\r
+ {\r
+ unsigned bit = sym & 1;\r
+ sym >>= 1;\r
+ price += GET_PRICEa(probs[sym], bit);\r
+ }\r
+ while (sym >= 2);\r
+\r
+ {\r
+ unsigned prob = probs[(size_t)i + (1 << (kLenNumHighBits - 1))];\r
+ prices[(size_t)i * 2 ] = price + GET_PRICEa_0(prob);\r
+ prices[(size_t)i * 2 + 1] = price + GET_PRICEa_1(prob);\r
+ }\r
+ }\r
+ while (i);\r
\r
+ {\r
+ unsigned posState;\r
+ size_t num = (p->tableSize - kLenNumLowSymbols * 2) * sizeof(p->prices[0][0]);\r
+ for (posState = 1; posState < numPosStates; posState++)\r
+ memcpy(p->prices[posState] + kLenNumLowSymbols * 2, p->prices[0] + kLenNumLowSymbols * 2, num);\r
+ }\r
+ }\r
+ }\r
+}\r
\r
/*\r
#ifdef SHOW_STAT\r
printf("\n MovePos %u", num);\r
#endif\r
*/\r
- \r
+\r
#define MOVE_POS(p, num) { \\r
p->additionalOffset += (num); \\r
- p->matchFinder.Skip(p->matchFinderObj, (num)); }\r
+ p->matchFinder.Skip(p->matchFinderObj, (UInt32)(num)); }\r
\r
\r
static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)\r
{\r
unsigned numPairs;\r
- \r
+\r
p->additionalOffset++;\r
p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);\r
numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);\r
*numPairsRes = numPairs;\r
- \r
+\r
#ifdef SHOW_STAT\r
printf("\n i = %u numPairs = %u ", g_STAT_OFFSET, numPairs / 2);\r
g_STAT_OFFSET++;\r
printf("%2u %6u | ", p->matches[i], p->matches[i + 1]);\r
}\r
#endif\r
- \r
+\r
if (numPairs == 0)\r
return 0;\r
{\r
const Byte *p2 = p1 + len;\r
ptrdiff_t dif = (ptrdiff_t)-1 - p->matches[(size_t)numPairs - 1];\r
const Byte *lim = p1 + numAvail;\r
- for (; p2 != lim && *p2 == p2[dif]; p2++);\r
+ for (; p2 != lim && *p2 == p2[dif]; p2++)\r
+ {}\r
return (unsigned)(p2 - p1);\r
}\r
}\r
+ GET_PRICE_1(p->isRep0Long[state][posState])) \\r
+ GET_PRICE_1(p->isRep[state]) \\r
+ GET_PRICE_0(p->isRepG0[state])\r
- \r
\r
+MY_FORCE_INLINE\r
static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, size_t state, size_t posState)\r
{\r
UInt32 price;\r
for (;;)\r
{\r
UInt32 dist = p->opt[cur].dist;\r
- UInt32 len = p->opt[cur].len;\r
- UInt32 extra = p->opt[cur].extra;\r
+ unsigned len = (unsigned)p->opt[cur].len;\r
+ unsigned extra = (unsigned)p->opt[cur].extra;\r
cur -= len;\r
\r
if (extra)\r
{\r
wr--;\r
- p->opt[wr].len = len;\r
+ p->opt[wr].len = (UInt32)len;\r
cur -= extra;\r
len = extra;\r
if (extra == 1)\r
p->optCur = wr;\r
return len;\r
}\r
- \r
+\r
wr--;\r
p->opt[wr].dist = dist;\r
- p->opt[wr].len = len;\r
+ p->opt[wr].len = (UInt32)len;\r
}\r
}\r
\r
UInt32 matchPrice, repMatchPrice;\r
const Byte *data;\r
Byte curByte, matchByte;\r
- \r
+\r
p->optCur = p->optEnd = 0;\r
- \r
+\r
if (p->additionalOffset == 0)\r
mainLen = ReadMatchDistances(p, &numPairs);\r
else\r
mainLen = p->longestMatchLen;\r
numPairs = p->numPairs;\r
}\r
- \r
+\r
numAvail = p->numAvail;\r
if (numAvail < 2)\r
{\r
}\r
if (numAvail > LZMA_MATCH_LEN_MAX)\r
numAvail = LZMA_MATCH_LEN_MAX;\r
- \r
+\r
data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;\r
repMaxIndex = 0;\r
- \r
+\r
for (i = 0; i < LZMA_NUM_REPS; i++)\r
{\r
unsigned len;\r
repLens[i] = 0;\r
continue;\r
}\r
- for (len = 2; len < numAvail && data[len] == data2[len]; len++);\r
+ for (len = 2; len < numAvail && data[len] == data2[len]; len++)\r
+ {}\r
repLens[i] = len;\r
if (len > repLens[repMaxIndex])\r
repMaxIndex = i;\r
}\r
- \r
+\r
if (repLens[repMaxIndex] >= p->numFastBytes)\r
{\r
unsigned len;\r
- p->backRes = repMaxIndex;\r
+ p->backRes = (UInt32)repMaxIndex;\r
len = repLens[repMaxIndex];\r
MOVE_POS(p, len - 1)\r
return len;\r
}\r
- \r
+\r
matches = p->matches;\r
- \r
+\r
if (mainLen >= p->numFastBytes)\r
{\r
p->backRes = matches[(size_t)numPairs - 1] + LZMA_NUM_REPS;\r
MOVE_POS(p, mainLen - 1)\r
return mainLen;\r
}\r
- \r
+\r
curByte = *data;\r
matchByte = *(data - reps[0]);\r
- \r
- if (mainLen < 2 && curByte != matchByte && repLens[repMaxIndex] < 2)\r
+\r
+ last = repLens[repMaxIndex];\r
+ if (last <= mainLen)\r
+ last = mainLen;\r
+\r
+ if (last < 2 && curByte != matchByte)\r
{\r
p->backRes = MARK_LIT;\r
return 1;\r
}\r
- \r
+\r
p->opt[0].state = (CState)p->state;\r
- \r
+\r
posState = (position & p->pbMask);\r
- \r
+\r
{\r
const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));\r
p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +\r
LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :\r
LitEnc_GetPrice(probs, curByte, p->ProbPrices));\r
}\r
- \r
+\r
MakeAs_Lit(&p->opt[1]);\r
- \r
+\r
matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]);\r
repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]);\r
- \r
- if (matchByte == curByte)\r
+\r
+ // 18.06\r
+ if (matchByte == curByte && repLens[0] == 0)\r
{\r
UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, p->state, posState);\r
if (shortRepPrice < p->opt[1].price)\r
p->opt[1].price = shortRepPrice;\r
MakeAs_ShortRep(&p->opt[1]);\r
}\r
+ if (last < 2)\r
+ {\r
+ p->backRes = p->opt[1].dist;\r
+ return 1;\r
+ }\r
}\r
- \r
- last = (mainLen >= repLens[repMaxIndex] ? mainLen : repLens[repMaxIndex]);\r
- \r
- if (last < 2)\r
- {\r
- p->backRes = p->opt[1].dist;\r
- return 1;\r
- }\r
- \r
+\r
p->opt[1].len = 1;\r
- \r
+\r
p->opt[0].reps[0] = reps[0];\r
p->opt[0].reps[1] = reps[1];\r
p->opt[0].reps[2] = reps[2];\r
p->opt[0].reps[3] = reps[3];\r
- \r
- {\r
- unsigned len = last;\r
- do\r
- p->opt[len--].price = kInfinityPrice;\r
- while (len >= 2);\r
- }\r
\r
// ---------- REP ----------\r
- \r
+\r
for (i = 0; i < LZMA_NUM_REPS; i++)\r
{\r
unsigned repLen = repLens[i];\r
price = repMatchPrice + GetPrice_PureRep(p, i, p->state, posState);\r
do\r
{\r
- UInt32 price2 = price + p->repLenEnc.prices[posState][(size_t)repLen - 2];\r
+ UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, repLen);\r
COptimal *opt = &p->opt[repLen];\r
if (price2 < opt->price)\r
{\r
opt->price = price2;\r
- opt->len = repLen;\r
- opt->dist = i;\r
+ opt->len = (UInt32)repLen;\r
+ opt->dist = (UInt32)i;\r
opt->extra = 0;\r
}\r
}\r
while (--repLen >= 2);\r
}\r
- \r
- \r
+\r
+\r
// ---------- MATCH ----------\r
{\r
- unsigned len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);\r
+ unsigned len = repLens[0] + 1;\r
if (len <= mainLen)\r
{\r
unsigned offs = 0;\r
UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[p->state]);\r
\r
- while (len > matches[offs])\r
- offs += 2;\r
- \r
+ if (len < 2)\r
+ len = 2;\r
+ else\r
+ while (len > matches[offs])\r
+ offs += 2;\r
+\r
for (; ; len++)\r
{\r
COptimal *opt;\r
UInt32 dist = matches[(size_t)offs + 1];\r
- UInt32 price2 = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN];\r
+ UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);\r
unsigned lenToPosState = GetLenToPosState(len);\r
- \r
+\r
if (dist < kNumFullDistances)\r
- price2 += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];\r
+ price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];\r
else\r
{\r
unsigned slot;\r
GetPosSlot2(dist, slot);\r
- price2 += p->alignPrices[dist & kAlignMask];\r
- price2 += p->posSlotPrices[lenToPosState][slot];\r
+ price += p->alignPrices[dist & kAlignMask];\r
+ price += p->posSlotPrices[lenToPosState][slot];\r
}\r
- \r
+\r
opt = &p->opt[len];\r
- \r
- if (price2 < opt->price)\r
+\r
+ if (price < opt->price)\r
{\r
- opt->price = price2;\r
- opt->len = len;\r
+ opt->price = price;\r
+ opt->len = (UInt32)len;\r
opt->dist = dist + LZMA_NUM_REPS;\r
opt->extra = 0;\r
}\r
- \r
+\r
if (len == matches[offs])\r
{\r
offs += 2;\r
}\r
}\r
}\r
- \r
+\r
\r
cur = 0;\r
\r
}\r
\r
\r
- \r
+\r
// ---------- Optimal Parsing ----------\r
\r
for (;;)\r
{\r
- UInt32 numAvail, numAvailFull;\r
+ unsigned numAvail;\r
+ UInt32 numAvailFull;\r
unsigned newLen, numPairs, prev, state, posState, startLen;\r
- UInt32 curPrice, litPrice, matchPrice, repMatchPrice;\r
- Bool nextIsLit;\r
+ UInt32 litPrice, matchPrice, repMatchPrice;\r
+ BoolInt nextIsLit;\r
Byte curByte, matchByte;\r
const Byte *data;\r
COptimal *curOpt, *nextOpt;\r
\r
if (++cur == last)\r
- return Backward(p, cur);\r
+ break;\r
+\r
+ // 18.06\r
+ if (cur >= kNumOpts - 64)\r
+ {\r
+ unsigned j, best;\r
+ UInt32 price = p->opt[cur].price;\r
+ best = cur;\r
+ for (j = cur + 1; j <= last; j++)\r
+ {\r
+ UInt32 price2 = p->opt[j].price;\r
+ if (price >= price2)\r
+ {\r
+ price = price2;\r
+ best = j;\r
+ }\r
+ }\r
+ {\r
+ unsigned delta = best - cur;\r
+ if (delta != 0)\r
+ {\r
+ MOVE_POS(p, delta);\r
+ }\r
+ }\r
+ cur = best;\r
+ break;\r
+ }\r
\r
newLen = ReadMatchDistances(p, &numPairs);\r
- \r
+\r
if (newLen >= p->numFastBytes)\r
{\r
p->numPairs = numPairs;\r
p->longestMatchLen = newLen;\r
- return Backward(p, cur);\r
+ break;\r
}\r
- \r
+\r
curOpt = &p->opt[cur];\r
+\r
+ position++;\r
+\r
+ // we need that check here, if skip_items in p->opt are possible\r
+ /*\r
+ if (curOpt->price >= kInfinityPrice)\r
+ continue;\r
+ */\r
+\r
prev = cur - curOpt->len;\r
- \r
+\r
if (curOpt->len == 1)\r
{\r
- state = p->opt[prev].state;\r
+ state = (unsigned)p->opt[prev].state;\r
if (IsShortRep(curOpt))\r
state = kShortRepNextStates[state];\r
else\r
\r
if (curOpt->extra)\r
{\r
- prev -= curOpt->extra;\r
+ prev -= (unsigned)curOpt->extra;\r
state = kState_RepAfterLit;\r
if (curOpt->extra == 1)\r
- state = (dist < LZMA_NUM_REPS) ? kState_RepAfterLit : kState_MatchAfterLit;\r
+ state = (dist < LZMA_NUM_REPS ? kState_RepAfterLit : kState_MatchAfterLit);\r
}\r
else\r
{\r
- state = p->opt[prev].state;\r
+ state = (unsigned)p->opt[prev].state;\r
if (dist < LZMA_NUM_REPS)\r
state = kRepNextStates[state];\r
else\r
reps[3] = prevOpt->reps[2];\r
}\r
}\r
- \r
+\r
curOpt->state = (CState)state;\r
curOpt->reps[0] = reps[0];\r
curOpt->reps[1] = reps[1];\r
curByte = *data;\r
matchByte = *(data - reps[0]);\r
\r
- position++;\r
posState = (position & p->pbMask);\r
\r
/*\r
< MATCH [ : LIT : REP_0 ]\r
*/\r
\r
- curPrice = curOpt->price;\r
- litPrice = curPrice + GET_PRICE_0(p->isMatch[state][posState]);\r
+ {\r
+ UInt32 curPrice = curOpt->price;\r
+ unsigned prob = p->isMatch[state][posState];\r
+ matchPrice = curPrice + GET_PRICE_1(prob);\r
+ litPrice = curPrice + GET_PRICE_0(prob);\r
+ }\r
\r
nextOpt = &p->opt[(size_t)cur + 1];\r
nextIsLit = False;\r
\r
- // if (litPrice >= nextOpt->price) litPrice = 0; else // 18.new\r
+ // here we can allow skip_items in p->opt, if we don't check (nextOpt->price < kInfinityPrice)\r
+ // 18.new.06\r
+ if ((nextOpt->price < kInfinityPrice\r
+ // && !IsLitState(state)\r
+ && matchByte == curByte)\r
+ || litPrice > nextOpt->price\r
+ )\r
+ litPrice = 0;\r
+ else\r
{\r
const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));\r
litPrice += (!IsLitState(state) ?\r
LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :\r
LitEnc_GetPrice(probs, curByte, p->ProbPrices));\r
- \r
+\r
if (litPrice < nextOpt->price)\r
{\r
nextOpt->price = litPrice;\r
}\r
}\r
\r
- matchPrice = curPrice + GET_PRICE_1(p->isMatch[state][posState]);\r
repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]);\r
- \r
+\r
+ numAvailFull = p->numAvail;\r
+ {\r
+ unsigned temp = kNumOpts - 1 - cur;\r
+ if (numAvailFull > temp)\r
+ numAvailFull = (UInt32)temp;\r
+ }\r
+\r
+ // 18.06\r
// ---------- SHORT_REP ----------\r
- // if (IsLitState(state)) // 18.new\r
+ if (IsLitState(state)) // 18.new\r
if (matchByte == curByte)\r
- // if (repMatchPrice < nextOpt->price) // 18.new\r
- if (nextOpt->len < 2\r
+ if (repMatchPrice < nextOpt->price) // 18.new\r
+ // if (numAvailFull < 2 || data[1] != *(data - reps[0] + 1))\r
+ if (\r
+ // nextOpt->price >= kInfinityPrice ||\r
+ nextOpt->len < 2 // we can check nextOpt->len, if skip items are not allowed in p->opt\r
|| (nextOpt->dist != 0\r
- && nextOpt->extra <= 1 // 17.old\r
- ))\r
+ // && nextOpt->extra <= 1 // 17.old\r
+ )\r
+ )\r
{\r
UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, state, posState);\r
- if (shortRepPrice <= nextOpt->price) // 17.old\r
- // if (shortRepPrice < nextOpt->price) // 18.new\r
+ // if (shortRepPrice <= nextOpt->price) // 17.old\r
+ if (shortRepPrice < nextOpt->price) // 18.new\r
{\r
nextOpt->price = shortRepPrice;\r
nextOpt->len = 1;\r
nextIsLit = False;\r
}\r
}\r
- \r
- numAvailFull = p->numAvail;\r
- {\r
- UInt32 temp = kNumOpts - 1 - cur;\r
- if (numAvailFull > temp)\r
- numAvailFull = temp;\r
- }\r
\r
if (numAvailFull < 2)\r
continue;\r
\r
// ---------- LIT : REP_0 ----------\r
\r
- if (\r
- // litPrice != 0 && // 18.new\r
- !nextIsLit\r
+ if (!nextIsLit\r
+ && litPrice != 0 // 18.new\r
&& matchByte != curByte\r
&& numAvailFull > 2)\r
{\r
if (limit > numAvailFull)\r
limit = numAvailFull;\r
for (len = 3; len < limit && data[len] == data2[len]; len++)\r
- {\r
- }\r
- \r
+ {}\r
+\r
{\r
unsigned state2 = kLiteralNextStates[state];\r
unsigned posState2 = (position + 1) & p->pbMask;\r
UInt32 price = litPrice + GetPrice_Rep_0(p, state2, posState2);\r
{\r
unsigned offset = cur + len;\r
- while (last < offset)\r
- p->opt[++last].price = kInfinityPrice;\r
- \r
+\r
+ if (last < offset)\r
+ last = offset;\r
+\r
// do\r
{\r
UInt32 price2;\r
COptimal *opt;\r
len--;\r
// price2 = price + GetPrice_Len_Rep_0(p, len, state2, posState2);\r
- price2 = price + p->repLenEnc.prices[posState2][len - LZMA_MATCH_LEN_MIN];\r
+ price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len);\r
\r
opt = &p->opt[offset];\r
// offset--;\r
if (price2 < opt->price)\r
{\r
opt->price = price2;\r
- opt->len = len;\r
+ opt->len = (UInt32)len;\r
opt->dist = 0;\r
opt->extra = 1;\r
}\r
}\r
}\r
}\r
- \r
+\r
startLen = 2; /* speed optimization */\r
+\r
{\r
// ---------- REP ----------\r
unsigned repIndex = 0; // 17.old\r
const Byte *data2 = data - reps[repIndex];\r
if (data[0] != data2[0] || data[1] != data2[1])\r
continue;\r
- \r
- for (len = 2; len < numAvail && data[len] == data2[len]; len++);\r
- \r
+\r
+ for (len = 2; len < numAvail && data[len] == data2[len]; len++)\r
+ {}\r
+\r
// if (len < startLen) continue; // 18.new: speed optimization\r
\r
- while (last < cur + len)\r
- p->opt[++last].price = kInfinityPrice;\r
+ {\r
+ unsigned offset = cur + len;\r
+ if (last < offset)\r
+ last = offset;\r
+ }\r
{\r
unsigned len2 = len;\r
price = repMatchPrice + GetPrice_PureRep(p, repIndex, state, posState);\r
do\r
{\r
- UInt32 price2 = price + p->repLenEnc.prices[posState][(size_t)len2 - 2];\r
+ UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, len2);\r
COptimal *opt = &p->opt[cur + len2];\r
if (price2 < opt->price)\r
{\r
opt->price = price2;\r
- opt->len = len2;\r
- opt->dist = repIndex;\r
+ opt->len = (UInt32)len2;\r
+ opt->dist = (UInt32)repIndex;\r
opt->extra = 0;\r
}\r
}\r
while (--len2 >= 2);\r
}\r
- \r
+\r
if (repIndex == 0) startLen = len + 1; // 17.old\r
// startLen = len + 1; // 18.new\r
\r
unsigned limit = len2 + p->numFastBytes;\r
if (limit > numAvailFull)\r
limit = numAvailFull;\r
- \r
- for (; len2 < limit && data[len2] == data2[len2]; len2++);\r
- \r
- len2 -= len;\r
- if (len2 >= 3)\r
+\r
+ len2 += 2;\r
+ if (len2 <= limit)\r
+ if (data[len2 - 2] == data2[len2 - 2])\r
+ if (data[len2 - 1] == data2[len2 - 1])\r
{\r
unsigned state2 = kRepNextStates[state];\r
unsigned posState2 = (position + len) & p->pbMask;\r
- price +=\r
- p->repLenEnc.prices[posState][(size_t)len - 2]\r
+ price += GET_PRICE_LEN(&p->repLenEnc, posState, len)\r
+ GET_PRICE_0(p->isMatch[state2][posState2])\r
+ LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),\r
data[len], data2[len], p->ProbPrices);\r
- \r
+\r
// state2 = kLiteralNextStates[state2];\r
state2 = kState_LitAfterRep;\r
posState2 = (posState2 + 1) & p->pbMask;\r
\r
\r
price += GetPrice_Rep_0(p, state2, posState2);\r
+\r
+ for (; len2 < limit && data[len2] == data2[len2]; len2++)\r
+ {}\r
+\r
+ len2 -= len;\r
+ // if (len2 >= 3)\r
+ {\r
{\r
unsigned offset = cur + len + len2;\r
- while (last < offset)\r
- p->opt[++last].price = kInfinityPrice;\r
+\r
+ if (last < offset)\r
+ last = offset;\r
// do\r
{\r
- unsigned price2;\r
+ UInt32 price2;\r
COptimal *opt;\r
len2--;\r
// price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);\r
- price2 = price + p->repLenEnc.prices[posState2][len2 - LZMA_MATCH_LEN_MIN];\r
+ price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);\r
\r
opt = &p->opt[offset];\r
// offset--;\r
if (price2 < opt->price)\r
{\r
opt->price = price2;\r
- opt->len = len2;\r
+ opt->len = (UInt32)len2;\r
opt->extra = (CExtra)(len + 1);\r
- opt->dist = repIndex;\r
+ opt->dist = (UInt32)repIndex;\r
}\r
}\r
// while (len2 >= 3);\r
}\r
}\r
+ }\r
}\r
}\r
}\r
{\r
newLen = numAvail;\r
for (numPairs = 0; newLen > matches[numPairs]; numPairs += 2);\r
- matches[numPairs] = newLen;\r
+ matches[numPairs] = (UInt32)newLen;\r
numPairs += 2;\r
}\r
- \r
+\r
+ // startLen = 2; /* speed optimization */\r
+\r
if (newLen >= startLen)\r
{\r
UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);\r
UInt32 dist;\r
unsigned offs, posSlot, len;\r
- while (last < cur + newLen)\r
- p->opt[++last].price = kInfinityPrice;\r
+\r
+ {\r
+ unsigned offset = cur + newLen;\r
+ if (last < offset)\r
+ last = offset;\r
+ }\r
\r
offs = 0;\r
while (startLen > matches[offs])\r
offs += 2;\r
dist = matches[(size_t)offs + 1];\r
- \r
+\r
// if (dist >= kNumFullDistances)\r
GetPosSlot2(dist, posSlot);\r
- \r
+\r
for (len = /*2*/ startLen; ; len++)\r
{\r
- UInt32 price = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN];\r
+ UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);\r
{\r
COptimal *opt;\r
- unsigned lenToPosState = len - 2; lenToPosState = GetLenToPosState2(lenToPosState);\r
+ unsigned lenNorm = len - 2;\r
+ lenNorm = GetLenToPosState2(lenNorm);\r
if (dist < kNumFullDistances)\r
- price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];\r
+ price += p->distancesPrices[lenNorm][dist & (kNumFullDistances - 1)];\r
else\r
- price += p->posSlotPrices[lenToPosState][posSlot] + p->alignPrices[dist & kAlignMask];\r
- \r
+ price += p->posSlotPrices[lenNorm][posSlot] + p->alignPrices[dist & kAlignMask];\r
+\r
opt = &p->opt[cur + len];\r
if (price < opt->price)\r
{\r
opt->price = price;\r
- opt->len = len;\r
+ opt->len = (UInt32)len;\r
opt->dist = dist + LZMA_NUM_REPS;\r
opt->extra = 0;\r
}\r
}\r
\r
- if (/*_maxMode && */ len == matches[offs])\r
+ if (len == matches[offs])\r
{\r
+ // if (p->_maxMode) {\r
// MATCH : LIT : REP_0\r
\r
const Byte *data2 = data - dist - 1;\r
unsigned limit = len2 + p->numFastBytes;\r
if (limit > numAvailFull)\r
limit = numAvailFull;\r
- \r
- for (; len2 < limit && data[len2] == data2[len2]; len2++);\r
- \r
+\r
+ len2 += 2;\r
+ if (len2 <= limit)\r
+ if (data[len2 - 2] == data2[len2 - 2])\r
+ if (data[len2 - 1] == data2[len2 - 1])\r
+ {\r
+ for (; len2 < limit && data[len2] == data2[len2]; len2++)\r
+ {}\r
+\r
len2 -= len;\r
- \r
- if (len2 >= 3)\r
+\r
+ // if (len2 >= 3)\r
{\r
unsigned state2 = kMatchNextStates[state];\r
unsigned posState2 = (position + len) & p->pbMask;\r
price += GetPrice_Rep_0(p, state2, posState2);\r
\r
offset = cur + len + len2;\r
- while (last < offset)\r
- p->opt[++last].price = kInfinityPrice;\r
+\r
+ if (last < offset)\r
+ last = offset;\r
// do\r
{\r
UInt32 price2;\r
COptimal *opt;\r
len2--;\r
// price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);\r
- price2 = price + p->repLenEnc.prices[posState2][len2 - LZMA_MATCH_LEN_MIN];\r
+ price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);\r
opt = &p->opt[offset];\r
// offset--;\r
if (price2 < opt->price)\r
{\r
opt->price = price2;\r
- opt->len = len2;\r
+ opt->len = (UInt32)len2;\r
opt->extra = (CExtra)(len + 1);\r
opt->dist = dist + LZMA_NUM_REPS;\r
}\r
}\r
// while (len2 >= 3);\r
}\r
- \r
+\r
+ }\r
+\r
offs += 2;\r
if (offs == numPairs)\r
break;\r
}\r
}\r
}\r
+\r
+ do\r
+ p->opt[last].price = kInfinityPrice;\r
+ while (--last);\r
+\r
+ return Backward(p, cur);\r
}\r
\r
\r
p->backRes = MARK_LIT;\r
if (numAvail < 2)\r
return 1;\r
+ // if (mainLen < 2 && p->state == 0) return 1; // 18.06.notused\r
if (numAvail > LZMA_MATCH_LEN_MAX)\r
numAvail = LZMA_MATCH_LEN_MAX;\r
data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;\r
repLen = repIndex = 0;\r
- \r
+\r
for (i = 0; i < LZMA_NUM_REPS; i++)\r
{\r
unsigned len;\r
const Byte *data2 = data - p->reps[i];\r
if (data[0] != data2[0] || data[1] != data2[1])\r
continue;\r
- for (len = 2; len < numAvail && data[len] == data2[len]; len++);\r
+ for (len = 2; len < numAvail && data[len] == data2[len]; len++)\r
+ {}\r
if (len >= p->numFastBytes)\r
{\r
- p->backRes = i;\r
+ p->backRes = (UInt32)i;\r
MOVE_POS(p, len - 1)\r
return len;\r
}\r
}\r
\r
mainDist = 0; /* for GCC */\r
- \r
+\r
if (mainLen >= 2)\r
{\r
mainDist = p->matches[(size_t)numPairs - 1];\r
|| (repLen + 2 >= mainLen && mainDist >= (1 << 9))\r
|| (repLen + 3 >= mainLen && mainDist >= (1 << 15)))\r
{\r
- p->backRes = repIndex;\r
+ p->backRes = (UInt32)repIndex;\r
MOVE_POS(p, repLen - 1)\r
return repLen;\r
}\r
- \r
+\r
if (mainLen < 2 || numAvail <= 2)\r
return 1;\r
\r
{\r
unsigned len1 = ReadMatchDistances(p, &p->numPairs);\r
p->longestMatchLen = len1;\r
- \r
+\r
if (len1 >= 2)\r
{\r
UInt32 newDist = p->matches[(size_t)p->numPairs - 1];\r
return 1;\r
}\r
}\r
- \r
+\r
data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;\r
- \r
+\r
for (i = 0; i < LZMA_NUM_REPS; i++)\r
{\r
unsigned len, limit;\r
break;\r
}\r
}\r
- \r
+\r
p->backRes = mainDist + LZMA_NUM_REPS;\r
if (mainLen != 2)\r
{\r
RC_BIT_0(&p->rc, prob)\r
}\r
p->state = kMatchNextStates[p->state];\r
- \r
+\r
p->rc.range = range;\r
LenEnc_Encode(&p->lenProbs, &p->rc, 0, posState);\r
range = p->rc.range;\r
}\r
while (--numBits);\r
}\r
- \r
+\r
{\r
// RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask);\r
CLzmaProb *probs = p->posAlignEncoder;\r
}\r
\r
\r
-\r
-static void FillAlignPrices(CLzmaEnc *p)\r
+MY_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)\r
{\r
unsigned i;\r
const CProbPrice *ProbPrices = p->ProbPrices;\r
const CLzmaProb *probs = p->posAlignEncoder;\r
- p->alignPriceCount = 0;\r
+ // p->alignPriceCount = 0;\r
for (i = 0; i < kAlignTableSize / 2; i++)\r
{\r
UInt32 price = 0;\r
- unsigned symbol = i;\r
+ unsigned sym = i;\r
unsigned m = 1;\r
unsigned bit;\r
UInt32 prob;\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;\r
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;\r
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;\r
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;\r
prob = probs[m];\r
p->alignPrices[i ] = price + GET_PRICEa_0(prob);\r
p->alignPrices[i + 8] = price + GET_PRICEa_1(prob);\r
}\r
\r
\r
-static void FillDistancesPrices(CLzmaEnc *p)\r
+MY_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p)\r
{\r
+ // int y; for (y = 0; y < 100; y++) {\r
+\r
UInt32 tempPrices[kNumFullDistances];\r
- unsigned i, lenToPosState;\r
+ unsigned i, lps;\r
\r
const CProbPrice *ProbPrices = p->ProbPrices;\r
p->matchPriceCount = 0;\r
\r
- for (i = kStartPosModelIndex; i < kNumFullDistances; i++)\r
+ for (i = kStartPosModelIndex / 2; i < kNumFullDistances / 2; i++)\r
{\r
unsigned posSlot = GetPosSlot1(i);\r
- unsigned footerBits = ((posSlot >> 1) - 1);\r
+ unsigned footerBits = (posSlot >> 1) - 1;\r
unsigned base = ((2 | (posSlot & 1)) << footerBits);\r
+ const CLzmaProb *probs = p->posEncoders + (size_t)base * 2;\r
// tempPrices[i] = RcTree_ReverseGetPrice(p->posEncoders + base, footerBits, i - base, p->ProbPrices);\r
-\r
- const CLzmaProb *probs = p->posEncoders + base;\r
UInt32 price = 0;\r
unsigned m = 1;\r
- unsigned symbol = i - base;\r
+ unsigned sym = i;\r
+ unsigned offset = (unsigned)1 << footerBits;\r
+ base += i;\r
+\r
+ if (footerBits)\r
do\r
{\r
- unsigned bit = symbol & 1;\r
- symbol >>= 1;\r
+ unsigned bit = sym & 1;\r
+ sym >>= 1;\r
price += GET_PRICEa(probs[m], bit);\r
m = (m << 1) + bit;\r
}\r
while (--footerBits);\r
- tempPrices[i] = price;\r
+\r
+ {\r
+ unsigned prob = probs[m];\r
+ tempPrices[base ] = price + GET_PRICEa_0(prob);\r
+ tempPrices[base + offset] = price + GET_PRICEa_1(prob);\r
+ }\r
}\r
\r
- for (lenToPosState = 0; lenToPosState < kNumLenToPosStates; lenToPosState++)\r
+ for (lps = 0; lps < kNumLenToPosStates; lps++)\r
{\r
- unsigned posSlot;\r
- const CLzmaProb *encoder = p->posSlotEncoder[lenToPosState];\r
- UInt32 *posSlotPrices = p->posSlotPrices[lenToPosState];\r
- unsigned distTableSize = p->distTableSize;\r
- const CLzmaProb *probs = encoder;\r
- for (posSlot = 0; posSlot < distTableSize; posSlot += 2)\r
+ unsigned slot;\r
+ unsigned distTableSize2 = (p->distTableSize + 1) >> 1;\r
+ UInt32 *posSlotPrices = p->posSlotPrices[lps];\r
+ const CLzmaProb *probs = p->posSlotEncoder[lps];\r
+\r
+ for (slot = 0; slot < distTableSize2; slot++)\r
{\r
- // posSlotPrices[posSlot] = RcTree_GetPrice(encoder, kNumPosSlotBits, posSlot, p->ProbPrices);\r
- UInt32 price = 0;\r
+ // posSlotPrices[slot] = RcTree_GetPrice(encoder, kNumPosSlotBits, slot, p->ProbPrices);\r
+ UInt32 price;\r
unsigned bit;\r
- unsigned symbol = (posSlot >> 1) + (1 << (kNumPosSlotBits - 1));\r
- UInt32 prob;\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], bit);\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], bit);\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], bit);\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], bit);\r
- bit = symbol & 1; symbol >>= 1; price += GET_PRICEa(probs[symbol], bit);\r
- prob = probs[(posSlot >> 1) + (1 << (kNumPosSlotBits - 1))];\r
- posSlotPrices[posSlot ] = price + GET_PRICEa_0(prob);\r
- posSlotPrices[posSlot + 1] = price + GET_PRICEa_1(prob);\r
+ unsigned sym = slot + (1 << (kNumPosSlotBits - 1));\r
+ unsigned prob;\r
+ bit = sym & 1; sym >>= 1; price = GET_PRICEa(probs[sym], bit);\r
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);\r
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);\r
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);\r
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);\r
+ prob = probs[(size_t)slot + (1 << (kNumPosSlotBits - 1))];\r
+ posSlotPrices[(size_t)slot * 2 ] = price + GET_PRICEa_0(prob);\r
+ posSlotPrices[(size_t)slot * 2 + 1] = price + GET_PRICEa_1(prob);\r
}\r
- for (posSlot = kEndPosModelIndex; posSlot < distTableSize; posSlot++)\r
- posSlotPrices[posSlot] += ((UInt32)(((posSlot >> 1) - 1) - kNumAlignBits) << kNumBitPriceShiftBits);\r
\r
{\r
- UInt32 *distancesPrices = p->distancesPrices[lenToPosState];\r
+ UInt32 delta = ((UInt32)((kEndPosModelIndex / 2 - 1) - kNumAlignBits) << kNumBitPriceShiftBits);\r
+ for (slot = kEndPosModelIndex / 2; slot < distTableSize2; slot++)\r
{\r
- distancesPrices[0] = posSlotPrices[0];\r
- distancesPrices[1] = posSlotPrices[1];\r
- distancesPrices[2] = posSlotPrices[2];\r
- distancesPrices[3] = posSlotPrices[3];\r
+ posSlotPrices[(size_t)slot * 2 ] += delta;\r
+ posSlotPrices[(size_t)slot * 2 + 1] += delta;\r
+ delta += ((UInt32)1 << kNumBitPriceShiftBits);\r
}\r
+ }\r
+\r
+ {\r
+ UInt32 *dp = p->distancesPrices[lps];\r
+\r
+ dp[0] = posSlotPrices[0];\r
+ dp[1] = posSlotPrices[1];\r
+ dp[2] = posSlotPrices[2];\r
+ dp[3] = posSlotPrices[3];\r
+\r
for (i = 4; i < kNumFullDistances; i += 2)\r
{\r
UInt32 slotPrice = posSlotPrices[GetPosSlot1(i)];\r
- distancesPrices[i ] = slotPrice + tempPrices[i];\r
- distancesPrices[i + 1] = slotPrice + tempPrices[i + 1];\r
+ dp[i ] = slotPrice + tempPrices[i];\r
+ dp[i + 1] = slotPrice + tempPrices[i + 1];\r
}\r
}\r
}\r
+ // }\r
}\r
\r
\r
{\r
RangeEnc_Construct(&p->rc);\r
MatchFinder_Construct(&p->matchFinderBase);\r
- \r
+\r
#ifndef _7ZIP_ST\r
MatchFinderMt_Construct(&p->matchFinderMt);\r
p->matchFinderMt.MatchFinder = &p->matchFinderBase;\r
#ifndef _7ZIP_ST\r
MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);\r
#endif\r
- \r
+\r
MatchFinder_Free(&p->matchFinderBase, allocBig);\r
LzmaEnc_FreeLits(p, alloc);\r
RangeEnc_Free(&p->rc, alloc);\r
}\r
\r
if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0)\r
- \r
+\r
for (;;)\r
{\r
UInt32 dist;\r
unsigned len, posState;\r
UInt32 range, ttt, newBound;\r
CLzmaProb *probs;\r
- \r
+\r
if (p->fastMode)\r
len = GetOptimumFast(p);\r
else\r
posState = (unsigned)nowPos32 & p->pbMask;\r
range = p->rc.range;\r
probs = &p->isMatch[p->state][posState];\r
- \r
+\r
RC_BIT_PRE(&p->rc, probs)\r
- \r
+\r
dist = p->backRes;\r
\r
#ifdef SHOW_STAT2\r
RC_BIT_1(&p->rc, probs);\r
probs = &p->isRep[p->state];\r
RC_BIT_PRE(&p->rc, probs)\r
- \r
+\r
if (dist < LZMA_NUM_REPS)\r
{\r
RC_BIT_1(&p->rc, probs);\r
if (len != 1)\r
{\r
LenEnc_Encode(&p->repLenProbs, &p->rc, len - LZMA_MATCH_LEN_MIN, posState);\r
- if (!p->fastMode)\r
- if (--p->repLenEnc.counters[posState] == 0)\r
- LenPriceEnc_UpdateTable(&p->repLenEnc, posState, &p->repLenProbs, p->ProbPrices);\r
-\r
+ --p->repLenEncCounter;\r
p->state = kRepNextStates[p->state];\r
}\r
}\r
p->state = kMatchNextStates[p->state];\r
\r
LenEnc_Encode(&p->lenProbs, &p->rc, len - LZMA_MATCH_LEN_MIN, posState);\r
- if (!p->fastMode)\r
- if (--p->lenEnc.counters[posState] == 0)\r
- LenPriceEnc_UpdateTable(&p->lenEnc, posState, &p->lenProbs, p->ProbPrices);\r
+ // --p->lenEnc.counter;\r
\r
dist -= LZMA_NUM_REPS;\r
p->reps[3] = p->reps[2];\r
p->reps[2] = p->reps[1];\r
p->reps[1] = p->reps[0];\r
p->reps[0] = dist + 1;\r
- \r
+\r
p->matchPriceCount++;\r
GetPosSlot(dist, posSlot);\r
// RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], posSlot);\r
{\r
- UInt32 symbol = posSlot + (1 << kNumPosSlotBits);\r
+ UInt32 sym = (UInt32)posSlot + (1 << kNumPosSlotBits);\r
range = p->rc.range;\r
probs = p->posSlotEncoder[GetLenToPosState(len)];\r
do\r
{\r
- CLzmaProb *prob = probs + (symbol >> kNumPosSlotBits);\r
- UInt32 bit = (symbol >> (kNumPosSlotBits - 1)) & 1;\r
- symbol <<= 1;\r
+ CLzmaProb *prob = probs + (sym >> kNumPosSlotBits);\r
+ UInt32 bit = (sym >> (kNumPosSlotBits - 1)) & 1;\r
+ sym <<= 1;\r
RC_BIT(&p->rc, prob, bit);\r
}\r
- while (symbol < (1 << kNumPosSlotBits * 2));\r
+ while (sym < (1 << kNumPosSlotBits * 2));\r
p->rc.range = range;\r
}\r
- \r
+\r
if (dist >= kStartPosModelIndex)\r
{\r
unsigned footerBits = ((posSlot >> 1) - 1);\r
if (dist < kNumFullDistances)\r
{\r
unsigned base = ((2 | (posSlot & 1)) << footerBits);\r
- RcTree_ReverseEncode(&p->rc, p->posEncoders + base, footerBits, dist - base);\r
+ RcTree_ReverseEncode(&p->rc, p->posEncoders + base, footerBits, (unsigned)(dist /* - base */));\r
}\r
else\r
{\r
bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;\r
bit = dist & 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit);\r
p->rc.range = range;\r
- p->alignPriceCount++;\r
+ // p->alignPriceCount++;\r
}\r
}\r
}\r
}\r
}\r
\r
- nowPos32 += len;\r
+ nowPos32 += (UInt32)len;\r
p->additionalOffset -= len;\r
- \r
+\r
if (p->additionalOffset == 0)\r
{\r
UInt32 processed;\r
\r
if (!p->fastMode)\r
{\r
- if (p->matchPriceCount >= (1 << 7))\r
+ /*\r
+ if (p->alignPriceCount >= 16) // kAlignTableSize\r
+ FillAlignPrices(p);\r
+ if (p->matchPriceCount >= 128)\r
FillDistancesPrices(p);\r
- if (p->alignPriceCount >= kAlignTableSize)\r
+ if (p->lenEnc.counter <= 0)\r
+ LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);\r
+ */\r
+ if (p->matchPriceCount >= 64)\r
+ {\r
FillAlignPrices(p);\r
+ // { int y; for (y = 0; y < 100; y++) {\r
+ FillDistancesPrices(p);\r
+ // }}\r
+ LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);\r
+ }\r
+ if (p->repLenEncCounter <= 0)\r
+ {\r
+ p->repLenEncCounter = REP_LEN_COUNT;\r
+ LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, &p->repLenProbs, p->ProbPrices);\r
+ }\r
}\r
- \r
+\r
if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)\r
break;\r
processed = nowPos32 - startPos32;\r
- \r
+\r
if (maxPackSize)\r
{\r
if (processed + kNumOpts + 300 >= maxUnpackSize\r
p->matchFinderObj = &p->matchFinderBase;\r
MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder);\r
}\r
- \r
+\r
return SZ_OK;\r
}\r
\r
\r
p->optEnd = 0;\r
p->optCur = 0;\r
+\r
+ {\r
+ for (i = 0; i < kNumOpts; i++)\r
+ p->opt[i].price = kInfinityPrice;\r
+ }\r
+\r
p->additionalOffset = 0;\r
\r
p->pbMask = (1 << p->pb) - 1;\r
p->lpMask = ((UInt32)0x100 << p->lp) - ((unsigned)0x100 >> p->lc);\r
}\r
\r
+\r
void LzmaEnc_InitPrices(CLzmaEnc *p)\r
{\r
if (!p->fastMode)\r
p->lenEnc.tableSize =\r
p->repLenEnc.tableSize =\r
p->numFastBytes + 1 - LZMA_MATCH_LEN_MIN;\r
+\r
+ p->repLenEncCounter = REP_LEN_COUNT;\r
+\r
LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);\r
LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, &p->repLenProbs, p->ProbPrices);\r
}\r
ISeqOutStream vt;\r
Byte *data;\r
SizeT rem;\r
- Bool overflow;\r
+ BoolInt overflow;\r
} CLzmaEnc_SeqOutStreamBuf;\r
\r
static size_t SeqOutStreamBuf_Write(const ISeqOutStream *pp, const void *data, size_t size)\r
}\r
\r
\r
-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,\r
+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,\r
Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)\r
{\r
CLzmaEnc *p = (CLzmaEnc *)pp;\r
return SZ_ERROR_OUTPUT_EOF;\r
\r
res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize);\r
- \r
+\r
*unpackSize = (UInt32)(p->nowPos64 - nowPos64);\r
*destLen -= outStream.rem;\r
if (outStream.overflow)\r
}\r
}\r
}\r
- \r
+\r
LzmaEnc_Finish(p);\r
\r
/*\r
p->rc.outStream = &outStream.vt;\r
\r
res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);\r
- \r
+\r
if (res == SZ_OK)\r
{\r
res = LzmaEnc_Encode2(p, progress);\r
projects / mirror_edk2.git / blobdiff