forked from KolibriOS/kolibrios
1079 lines
32 KiB
C
1079 lines
32 KiB
C
|
#include "LZMAEncoder.h"
|
|||
|
|
#include "MatchFinder.h"
|
|||
|
|
|
|||
|
|
const byte kLiteralNextStates[kNumStates] = {0,0,0,0,1,2,3,4,5,6,4,5};
|
|||
|
|
const byte kMatchNextStates[kNumStates] = {7,7,7,7,7,7,7,10,10,10,10,10};
|
|||
|
|
const byte kRepNextStates[kNumStates] = {8,8,8,8,8,8,8,11,11,11,11,11};
|
|||
|
|
const byte kShortRepNextStates[kNumStates] = {9,9,9,9,9,9,9,11,11,11,11,11};
|
|||
|
|
|
|||
|
|
static CState _state;
|
|||
|
|
static byte _previousByte;
|
|||
|
|
static unsigned _repDistances[kNumRepDistances];
|
|||
|
|
|
|||
|
|
static COptimal _optimum[kNumOpts];
|
|||
|
|
static CMyBitEncoder _isMatch[kNumStates][kNumPosStatesEncodingMax];
|
|||
|
|
static CMyBitEncoder _isRep[kNumStates];
|
|||
|
|
static CMyBitEncoder _isRepG0[kNumStates];
|
|||
|
|
static CMyBitEncoder _isRepG1[kNumStates];
|
|||
|
|
static CMyBitEncoder _isRepG2[kNumStates];
|
|||
|
|
static CMyBitEncoder _isRep0Long[kNumStates][kNumPosStatesEncodingMax];
|
|||
|
|
static NRangeCoder_CBitTreeEncoder _posSlotEncoder[kNumLenToPosStates];
|
|||
|
|
static CMyBitEncoder _posEncoders[kNumFullDistances - kEndPosModelIndex];
|
|||
|
|
static NRangeCoder_CBitTreeEncoder _posAlignEncoder;
|
|||
|
|
static NLength_CPriceTableEncoder _lenEncoder;
|
|||
|
|
static NLength_CPriceTableEncoder _repMatchLenEncoder;
|
|||
|
|
static CLiteralEncoder _literalEncoder;
|
|||
|
|
static unsigned _matchDistances[kMatchMaxLen+1];
|
|||
|
|
static unsigned _numFastBytes;
|
|||
|
|
static unsigned _longestMatchLength;
|
|||
|
|
static unsigned _additionalOffset;
|
|||
|
|
static unsigned _optimumEndIndex;
|
|||
|
|
static unsigned _optimumCurrentIndex;
|
|||
|
|
static bool _longestMatchWasFound;
|
|||
|
|
static unsigned _posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
|
|||
|
|
static unsigned _distancesPrices[kNumLenToPosStates][kNumFullDistances];
|
|||
|
|
static unsigned _alignPrices[kAlignTableSize];
|
|||
|
|
static unsigned _alignPriceCount;
|
|||
|
|
static unsigned _distTableSize;
|
|||
|
|
static unsigned _posStateBits;
|
|||
|
|
static unsigned _posStateMask;
|
|||
|
|
static unsigned _numLiteralPosStateBits;
|
|||
|
|
static unsigned _numLiteralContextBits;
|
|||
|
|
static unsigned _dictionarySize;
|
|||
|
|
static uint64 lastPosSlotFillingPos;
|
|||
|
|
static uint64 nowPos64;
|
|||
|
|
static bool _finished;
|
|||
|
|
static bool _writeEndMark;
|
|||
|
|
|
|||
|
|
static byte g_FastPos[1024];
|
|||
|
|
|
|||
|
|
// must be called before work
|
|||
|
|
static void FastPosInit(void)
|
|||
|
|
{
|
|||
|
|
int c = 2;
|
|||
|
|
int slotFast;
|
|||
|
|
unsigned j,k;
|
|||
|
|
g_FastPos[0] = 0;
|
|||
|
|
g_FastPos[1] = 1;
|
|||
|
|
for (slotFast = 2; slotFast < 20; slotFast++)
|
|||
|
|
{
|
|||
|
|
k = (1 << ((slotFast >> 1) - 1));
|
|||
|
|
for (j=0;j<k;j++) g_FastPos[c++] = slotFast;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
static unsigned GetPosSlot(unsigned pos)
|
|||
|
|
{
|
|||
|
|
if (pos < (1<<10))
|
|||
|
|
return g_FastPos[pos];
|
|||
|
|
if (pos < (1<<19))
|
|||
|
|
return g_FastPos[pos>>9]+18;
|
|||
|
|
return g_FastPos[pos>>18]+36;
|
|||
|
|
}
|
|||
|
|
static unsigned GetPosSlot2(unsigned pos)
|
|||
|
|
{
|
|||
|
|
if (pos < (1<<16))
|
|||
|
|
return g_FastPos[pos>>6]+12;
|
|||
|
|
if (pos < (1<<25))
|
|||
|
|
return g_FastPos[pos>>15]+30;
|
|||
|
|
return g_FastPos[pos>>24]+48;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
unsigned pack_length;
|
|||
|
|
unsigned pack_pos;
|
|||
|
|
const byte* curin;
|
|||
|
|
byte* curout;
|
|||
|
|
|
|||
|
|
static void NLength_CEncoder_Init(NLength_CEncoder*e, unsigned numPosStates)
|
|||
|
|
{
|
|||
|
|
unsigned posState;
|
|||
|
|
CMyBitEncoder_Init(e->_choice);
|
|||
|
|
CMyBitEncoder_Init(e->_choice2);
|
|||
|
|
for (posState=0;posState<numPosStates;posState++)
|
|||
|
|
{
|
|||
|
|
CBitTreeEncoder_Init(&e->_lowCoder[posState],kNumLowBits);
|
|||
|
|
CBitTreeEncoder_Init(&e->_midCoder[posState],kNumMidBits);
|
|||
|
|
}
|
|||
|
|
CBitTreeEncoder_Init(&e->_highCoder,kNumHighBits);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void NLength_CEncoder_Encode(NLength_CEncoder*e, unsigned symbol, unsigned posState)
|
|||
|
|
{
|
|||
|
|
if (symbol < kNumLowSymbols)
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&e->_choice,0);
|
|||
|
|
CBitTreeEncoder_Encode(&e->_lowCoder[posState],symbol);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&e->_choice,1);
|
|||
|
|
if (symbol < kNumLowSymbols + kNumMidSymbols)
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&e->_choice2,0);
|
|||
|
|
CBitTreeEncoder_Encode(&e->_midCoder[posState],symbol-kNumLowSymbols);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&e->_choice2,1);
|
|||
|
|
CBitTreeEncoder_Encode(&e->_highCoder,symbol-kNumLowSymbols-kNumMidSymbols);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static unsigned NLength_CEncoder_GetPrice(NLength_CEncoder*e, unsigned symbol, unsigned posState)
|
|||
|
|
{
|
|||
|
|
unsigned price;
|
|||
|
|
if (symbol < kNumLowSymbols)
|
|||
|
|
return CMyBitEncoder_GetPrice0(&e->_choice) +
|
|||
|
|
CBitTreeEncoder_GetPrice(&e->_lowCoder[posState],symbol);
|
|||
|
|
price = CMyBitEncoder_GetPrice1(&e->_choice);
|
|||
|
|
if (symbol < kNumLowSymbols + kNumMidSymbols)
|
|||
|
|
{
|
|||
|
|
price += CMyBitEncoder_GetPrice0(&e->_choice2);
|
|||
|
|
price += CBitTreeEncoder_GetPrice(&e->_midCoder[posState],symbol-kNumLowSymbols);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
price += CMyBitEncoder_GetPrice1(&e->_choice2);
|
|||
|
|
price += CBitTreeEncoder_GetPrice(&e->_highCoder,symbol-kNumLowSymbols-kNumMidSymbols);
|
|||
|
|
}
|
|||
|
|
return price;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CPriceTableEncoder_SetTableSize(NLength_CPriceTableEncoder*pte,unsigned tableSize)
|
|||
|
|
{pte->_tableSize = tableSize;}
|
|||
|
|
static unsigned CPriceTableEncoder_GetPrice(NLength_CPriceTableEncoder*pte,unsigned symbol,unsigned posState)
|
|||
|
|
{return pte->_prices[symbol][posState];}
|
|||
|
|
static void CPriceTableEncoder_UpdateTable(NLength_CPriceTableEncoder*pte,unsigned posState)
|
|||
|
|
{
|
|||
|
|
unsigned len;
|
|||
|
|
for (len=0;len<pte->_tableSize;len++)
|
|||
|
|
pte->_prices[len][posState] = NLength_CEncoder_GetPrice(&pte->base,len,posState);
|
|||
|
|
pte->_counters[posState] = pte->_tableSize;
|
|||
|
|
}
|
|||
|
|
static void CPriceTableEncoder_UpdateTables(NLength_CPriceTableEncoder*pte,unsigned numPosStates)
|
|||
|
|
{
|
|||
|
|
unsigned posState;
|
|||
|
|
for (posState=0;posState<numPosStates;posState++)
|
|||
|
|
CPriceTableEncoder_UpdateTable(pte,posState);
|
|||
|
|
}
|
|||
|
|
static void CPriceTableEncoder_Encode(NLength_CPriceTableEncoder*pte, unsigned symbol, unsigned posState)
|
|||
|
|
{
|
|||
|
|
NLength_CEncoder_Encode(&pte->base,symbol,posState);
|
|||
|
|
if (--pte->_counters[posState] == 0)
|
|||
|
|
CPriceTableEncoder_UpdateTable(pte,posState);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CBaseState_Init(void)
|
|||
|
|
{
|
|||
|
|
unsigned i;
|
|||
|
|
CState_Init(_state);
|
|||
|
|
_previousByte = 0;
|
|||
|
|
for (i=0;i<kNumRepDistances;i++)
|
|||
|
|
_repDistances[i] = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CLiteralEncoder2_Init(CLiteralEncoder2 le)
|
|||
|
|
{
|
|||
|
|
int i;
|
|||
|
|
for (i=0;i<0x300;i++)
|
|||
|
|
CMyBitEncoder_Init(le[i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CLiteralEncoder2_Encode(CLiteralEncoder2 le, byte symbol)
|
|||
|
|
{
|
|||
|
|
unsigned context = 1;
|
|||
|
|
int i;
|
|||
|
|
unsigned bit;
|
|||
|
|
for (i=8;i--;)
|
|||
|
|
{
|
|||
|
|
bit = (symbol >> i) & 1;
|
|||
|
|
CMyBitEncoder_Encode(&le[context],bit);
|
|||
|
|
context = (context << 1) | bit;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CLiteralEncoder2_EncodeMatched(CLiteralEncoder2 le, byte matchByte, byte symbol)
|
|||
|
|
{
|
|||
|
|
unsigned context = 1;
|
|||
|
|
int i;
|
|||
|
|
unsigned bit,matchBit;
|
|||
|
|
for (i=8;i--;)
|
|||
|
|
{
|
|||
|
|
bit = (symbol >> i) & 1;
|
|||
|
|
matchBit = (matchByte >> i) & 1;
|
|||
|
|
CMyBitEncoder_Encode(&le[0x100 + (matchBit<<8) + context],bit);
|
|||
|
|
context = (context << 1) | bit;
|
|||
|
|
if (matchBit != bit)
|
|||
|
|
{
|
|||
|
|
while (i--)
|
|||
|
|
{
|
|||
|
|
bit = (symbol >> i) & 1;
|
|||
|
|
CMyBitEncoder_Encode(&le[context],bit);
|
|||
|
|
context = (context << 1) | bit;
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static unsigned CLiteralEncoder2_GetPrice(CLiteralEncoder2 le, bool matchMode, byte matchByte, byte symbol)
|
|||
|
|
{
|
|||
|
|
unsigned price = 0;
|
|||
|
|
unsigned context = 1;
|
|||
|
|
unsigned bit,matchBit;
|
|||
|
|
int i = 8;
|
|||
|
|
if (matchMode)
|
|||
|
|
{
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
i--;
|
|||
|
|
matchBit = (matchByte >> i) & 1;
|
|||
|
|
bit = (symbol >> i) & 1;
|
|||
|
|
price += CMyBitEncoder_GetPrice(&le[0x100 + (matchBit<<8) + context],bit);
|
|||
|
|
context = (context << 1) | bit;
|
|||
|
|
if (matchBit != bit)
|
|||
|
|
break;
|
|||
|
|
} while (i);
|
|||
|
|
}
|
|||
|
|
while (i--)
|
|||
|
|
{
|
|||
|
|
bit = (symbol >> i) & 1;
|
|||
|
|
price += CMyBitEncoder_GetPrice(&le[context],bit);
|
|||
|
|
context = (context << 1) | bit;
|
|||
|
|
}
|
|||
|
|
return price;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void WriteEndMarker(unsigned posState)
|
|||
|
|
{
|
|||
|
|
unsigned posSlot;
|
|||
|
|
if (!_writeEndMark)
|
|||
|
|
return;
|
|||
|
|
CMyBitEncoder_Encode(&_isMatch[_state][posState],1);
|
|||
|
|
CMyBitEncoder_Encode(&_isRep[_state],0);
|
|||
|
|
CState_UpdateMatch(_state);
|
|||
|
|
CPriceTableEncoder_Encode(&_lenEncoder,0,posState);
|
|||
|
|
posSlot = (1<<kNumPosSlotBits) - 1;
|
|||
|
|
CBitTreeEncoder_Encode(&_posSlotEncoder[GetLenToPosState(kMatchMinLen)],posSlot);
|
|||
|
|
RangeEncoder_EncodeDirectBits(((1<<30)-1)>>kNumAlignBits,30-kNumAlignBits);
|
|||
|
|
CBitTreeEncoder_ReverseEncode(&_posAlignEncoder,((1<<30)-1) & kAlignMask);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CEncoder_Flush(void)
|
|||
|
|
{
|
|||
|
|
WriteEndMarker((unsigned)nowPos64 & _posStateMask);
|
|||
|
|
RangeEncoder_FlushData();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CLiteralEncoder_Create(CLiteralEncoder*le, byte** memory, int numPosBits, int numPrevBits)
|
|||
|
|
{
|
|||
|
|
unsigned numStates;
|
|||
|
|
le->_coders = (CLiteralEncoder2*)*memory;
|
|||
|
|
numStates = 1 << (numPosBits+numPrevBits);
|
|||
|
|
*memory = (byte*)(le->_coders + numStates);
|
|||
|
|
le->_numPosBits = numPosBits;
|
|||
|
|
le->_posMask = (1<<numPosBits) - 1;
|
|||
|
|
le->_numPrevBits = numPrevBits;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CLiteralEncoder_Init(CLiteralEncoder*le)
|
|||
|
|
{
|
|||
|
|
unsigned numStates,i;
|
|||
|
|
numStates = 1 << (le->_numPosBits + le->_numPrevBits);
|
|||
|
|
for (i=0;i<numStates;i++)
|
|||
|
|
CLiteralEncoder2_Init(le->_coders[i]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static unsigned CLiteralEncoder_GetState(CLiteralEncoder*le,unsigned pos,byte prevByte)
|
|||
|
|
{return ((pos&le->_posMask)<<le->_numPrevBits)+(prevByte>>(8-le->_numPrevBits));}
|
|||
|
|
static CLiteralEncoder2* CLiteralEncoder_GetSubCoder(CLiteralEncoder*le,unsigned pos,byte prevByte)
|
|||
|
|
{return &le->_coders[CLiteralEncoder_GetState(le,pos,prevByte)];}
|
|||
|
|
|
|||
|
|
static unsigned CLiteralEncoder_GetPrice(CLiteralEncoder*le,unsigned pos,byte prevByte,
|
|||
|
|
bool matchMode, byte matchByte, byte symbol)
|
|||
|
|
{
|
|||
|
|
return CLiteralEncoder2_GetPrice(le->_coders[CLiteralEncoder_GetState(le,pos,prevByte)],
|
|||
|
|
matchMode, matchByte, symbol);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CEncoder_Create(void*workmem)
|
|||
|
|
{
|
|||
|
|
byte* workpos = (byte*)workmem;
|
|||
|
|
/* align on dword boundary */
|
|||
|
|
unsigned a;
|
|||
|
|
a = (unsigned)workpos & 3;
|
|||
|
|
if (a) workpos += 4-a;
|
|||
|
|
/* sizeof(CLiteralEncoder2) * (1<<(numPosBits+numPrevBits)) for literal encoders */
|
|||
|
|
/* = 0xC00 * 8 = 0x6000 with current settings */
|
|||
|
|
CLiteralEncoder_Create(&_literalEncoder,&workpos,_numLiteralPosStateBits,_numLiteralContextBits);
|
|||
|
|
/* (dictsize+0x1223)*1.5+256 for LZ input window */
|
|||
|
|
/* (0x140400 + (dictsize+1)*2) * 4 for match finder hash */
|
|||
|
|
MatchFinder_Create(_dictionarySize,kNumOpts,_numFastBytes,
|
|||
|
|
kMatchMaxLen*2+1-_numFastBytes,&workpos);
|
|||
|
|
/* total 0x508C3C + dictsize*9.5 */
|
|||
|
|
/* plus max 6 bytes for alignment */
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void CEncoder_Init(void)
|
|||
|
|
{
|
|||
|
|
int i;
|
|||
|
|
unsigned j;
|
|||
|
|
CBaseState_Init();
|
|||
|
|
RangeEncoder_Init();
|
|||
|
|
for (i=0;i<kNumStates;i++)
|
|||
|
|
{
|
|||
|
|
for (j=0;j<=_posStateMask;j++)
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Init(_isMatch[i][j]);
|
|||
|
|
CMyBitEncoder_Init(_isRep0Long[i][j]);
|
|||
|
|
}
|
|||
|
|
CMyBitEncoder_Init(_isRep[i]);
|
|||
|
|
CMyBitEncoder_Init(_isRepG0[i]);
|
|||
|
|
CMyBitEncoder_Init(_isRepG1[i]);
|
|||
|
|
CMyBitEncoder_Init(_isRepG2[i]);
|
|||
|
|
}
|
|||
|
|
CLiteralEncoder_Init(&_literalEncoder);
|
|||
|
|
for (i=0;i<kNumLenToPosStates;i++)
|
|||
|
|
CBitTreeEncoder_Init(_posSlotEncoder+i,kNumPosSlotBits);
|
|||
|
|
for (i=0;i<kNumFullDistances-kEndPosModelIndex;i++)
|
|||
|
|
CMyBitEncoder_Init(_posEncoders[i]);
|
|||
|
|
CPriceTableEncoder_Init(_lenEncoder, 1<<_posStateBits);
|
|||
|
|
CPriceTableEncoder_Init(_repMatchLenEncoder,1<<_posStateBits);
|
|||
|
|
CBitTreeEncoder_Init(&_posAlignEncoder,kNumAlignBits);
|
|||
|
|
_longestMatchWasFound = false;
|
|||
|
|
_optimumEndIndex = 0;
|
|||
|
|
_optimumCurrentIndex = 0;
|
|||
|
|
_additionalOffset = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void MovePos(unsigned num)
|
|||
|
|
{
|
|||
|
|
for (;num--;)
|
|||
|
|
{
|
|||
|
|
DummyLongestMatch();
|
|||
|
|
MatchFinder_MovePos();
|
|||
|
|
_additionalOffset++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static unsigned Backward(unsigned* backRes, unsigned cur)
|
|||
|
|
{
|
|||
|
|
unsigned posMem,backMem;
|
|||
|
|
unsigned posPrev,backCur;
|
|||
|
|
_optimumEndIndex = cur;
|
|||
|
|
posMem = _optimum[cur].PosPrev;
|
|||
|
|
backMem = _optimum[cur].BackPrev;
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
if (_optimum[cur].Prev1IsChar)
|
|||
|
|
{
|
|||
|
|
COptimal_MakeAsChar(&_optimum[posMem]);
|
|||
|
|
_optimum[posMem].PosPrev = posMem-1;
|
|||
|
|
if (_optimum[cur].Prev2)
|
|||
|
|
{
|
|||
|
|
_optimum[posMem-1].Prev1IsChar = false;
|
|||
|
|
_optimum[posMem-1].PosPrev = _optimum[cur].PosPrev2;
|
|||
|
|
_optimum[posMem-1].BackPrev = _optimum[cur].BackPrev2;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
posPrev = posMem;
|
|||
|
|
backCur = backMem;
|
|||
|
|
backMem = _optimum[posPrev].BackPrev;
|
|||
|
|
posMem = _optimum[posPrev].PosPrev;
|
|||
|
|
_optimum[posPrev].BackPrev = backCur;
|
|||
|
|
_optimum[posPrev].PosPrev = cur;
|
|||
|
|
cur = posPrev;
|
|||
|
|
} while (cur);
|
|||
|
|
*backRes = _optimum[0].BackPrev;
|
|||
|
|
_optimumCurrentIndex = _optimum[0].PosPrev;
|
|||
|
|
return _optimumCurrentIndex;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static unsigned ReadMatchDistances(void)
|
|||
|
|
{
|
|||
|
|
unsigned res;
|
|||
|
|
res = GetLongestMatch(_matchDistances);
|
|||
|
|
if (res == _numFastBytes)
|
|||
|
|
res += GetMatchLen(res,_matchDistances[res],kMatchMaxLen-res);
|
|||
|
|
_additionalOffset++;
|
|||
|
|
MatchFinder_MovePos();
|
|||
|
|
return res;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void FillPosSlotPrices(void)
|
|||
|
|
{
|
|||
|
|
unsigned lenToPosState,posSlot;
|
|||
|
|
for (lenToPosState=0;lenToPosState<kNumLenToPosStates;lenToPosState++)
|
|||
|
|
{
|
|||
|
|
for (posSlot=0;posSlot<kEndPosModelIndex && posSlot<_distTableSize;posSlot++)
|
|||
|
|
_posSlotPrices[lenToPosState][posSlot] = CBitTreeEncoder_GetPrice(&_posSlotEncoder[lenToPosState],posSlot);
|
|||
|
|
for (;posSlot<_distTableSize;posSlot++)
|
|||
|
|
_posSlotPrices[lenToPosState][posSlot] = CBitTreeEncoder_GetPrice(&_posSlotEncoder[lenToPosState],posSlot) +
|
|||
|
|
(((posSlot>>1)-1-kNumAlignBits)<<kNumBitPriceShiftBits);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void FillDistancesPrices(void)
|
|||
|
|
{
|
|||
|
|
unsigned lenToPosState,i;
|
|||
|
|
unsigned posSlot,footerBits,base;
|
|||
|
|
for (lenToPosState=0;lenToPosState<kNumLenToPosStates;lenToPosState++)
|
|||
|
|
{
|
|||
|
|
for (i=0;i<kStartPosModelIndex;i++)
|
|||
|
|
_distancesPrices[lenToPosState][i] = _posSlotPrices[lenToPosState][i];
|
|||
|
|
for (;i<kNumFullDistances;i++)
|
|||
|
|
{
|
|||
|
|
posSlot = GetPosSlot(i);
|
|||
|
|
footerBits = ((posSlot>>1)-1);
|
|||
|
|
base = (2|(posSlot&1))<<footerBits;
|
|||
|
|
_distancesPrices[lenToPosState][i] = _posSlotPrices[lenToPosState][posSlot] +
|
|||
|
|
ReverseBitTreeGetPrice(_posEncoders+base-posSlot-1,footerBits,i-base);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void FillAlignPrices(void)
|
|||
|
|
{
|
|||
|
|
unsigned i;
|
|||
|
|
for (i=0;i<kAlignTableSize;i++)
|
|||
|
|
_alignPrices[i] = CBitTreeEncoder_ReverseGetPrice(&_posAlignEncoder,i);
|
|||
|
|
_alignPriceCount = kAlignTableSize;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static unsigned GetRepLen1Price(CState state, unsigned posState)
|
|||
|
|
{
|
|||
|
|
return CMyBitEncoder_GetPrice0(&_isRepG0[state]) +
|
|||
|
|
CMyBitEncoder_GetPrice0(&_isRep0Long[state][posState]);
|
|||
|
|
}
|
|||
|
|
static unsigned GetRepPrice(unsigned repIndex, unsigned len, CState state, unsigned posState)
|
|||
|
|
{
|
|||
|
|
unsigned price;
|
|||
|
|
price = CPriceTableEncoder_GetPrice(&_repMatchLenEncoder,len-kMatchMinLen,posState);
|
|||
|
|
if (!repIndex)
|
|||
|
|
{
|
|||
|
|
price += CMyBitEncoder_GetPrice0(&_isRepG0[state]);
|
|||
|
|
price += CMyBitEncoder_GetPrice1(&_isRep0Long[state][posState]);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
price += CMyBitEncoder_GetPrice1(&_isRepG0[state]);
|
|||
|
|
if (repIndex == 1)
|
|||
|
|
price += CMyBitEncoder_GetPrice0(&_isRepG1[state]);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
price += CMyBitEncoder_GetPrice1(&_isRepG1[state]);
|
|||
|
|
price += CMyBitEncoder_GetPrice(&_isRepG2[state],repIndex-2);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return price;
|
|||
|
|
}
|
|||
|
|
static unsigned GetPosLenPrice(unsigned pos, unsigned len, unsigned posState)
|
|||
|
|
{
|
|||
|
|
unsigned price,lenToPosState;
|
|||
|
|
if (len==2 && pos>=0x80)
|
|||
|
|
return kIfinityPrice;
|
|||
|
|
lenToPosState = GetLenToPosState(len);
|
|||
|
|
if (pos < kNumFullDistances)
|
|||
|
|
price = _distancesPrices[lenToPosState][pos];
|
|||
|
|
else
|
|||
|
|
price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] +
|
|||
|
|
_alignPrices[pos & kAlignMask];
|
|||
|
|
return price + CPriceTableEncoder_GetPrice(&_lenEncoder,len-kMatchMinLen,posState);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void GetOptimum(unsigned position,unsigned*backRes,unsigned*lenRes)
|
|||
|
|
{
|
|||
|
|
int lenMain,lenEnd;
|
|||
|
|
COptimal* opt,*prevOpt;
|
|||
|
|
int reps[kNumRepDistances];
|
|||
|
|
int repLens[kNumRepDistances];
|
|||
|
|
int repIndex,repMaxIndex;
|
|||
|
|
int i,len,repLen,lenTest,newLen,lenTestTemp,lenTest2;
|
|||
|
|
int posState,posStateNext;
|
|||
|
|
byte currentByte,matchByte;
|
|||
|
|
unsigned matchPrice,repMatchPrice,shortRepPrice,normalMatchPrice,curAndLenPrice,curPrice,curAnd1Price,curAndLenCharPrice;
|
|||
|
|
unsigned nextMatchPrice,nextRepMatchPrice;
|
|||
|
|
int cur,posPrev,pos;
|
|||
|
|
CState state,state2;
|
|||
|
|
const byte* data;
|
|||
|
|
bool nextIsChar;
|
|||
|
|
int numAvailableBytesFull,numAvailableBytes;
|
|||
|
|
int backOffset,offset;
|
|||
|
|
int limit;
|
|||
|
|
if (_optimumEndIndex != _optimumCurrentIndex)
|
|||
|
|
{
|
|||
|
|
opt = &_optimum[_optimumCurrentIndex];
|
|||
|
|
*lenRes = opt->PosPrev - _optimumCurrentIndex;
|
|||
|
|
*backRes = opt->BackPrev;
|
|||
|
|
_optimumCurrentIndex = opt->PosPrev;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
_optimumCurrentIndex = _optimumEndIndex = 0;
|
|||
|
|
if (!_longestMatchWasFound)
|
|||
|
|
lenMain = ReadMatchDistances();
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
lenMain = _longestMatchLength;
|
|||
|
|
_longestMatchWasFound = false;
|
|||
|
|
}
|
|||
|
|
for (i=0;i<kNumRepDistances;i++)
|
|||
|
|
{
|
|||
|
|
reps[i] = _repDistances[i];
|
|||
|
|
repLens[i] = GetMatchLen(0-1,reps[i],kMatchMaxLen);
|
|||
|
|
if (i==0 || repLens[i] > repLens[repMaxIndex])
|
|||
|
|
repMaxIndex = i;
|
|||
|
|
}
|
|||
|
|
if (repLens[repMaxIndex] >= _numFastBytes)
|
|||
|
|
{
|
|||
|
|
*backRes = repMaxIndex;
|
|||
|
|
*lenRes = repLens[repMaxIndex];
|
|||
|
|
MovePos(*lenRes-1);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (lenMain >= _numFastBytes)
|
|||
|
|
{
|
|||
|
|
*backRes = _matchDistances[_numFastBytes]+kNumRepDistances;
|
|||
|
|
*lenRes = lenMain;
|
|||
|
|
MovePos(lenMain-1);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
currentByte = GetIndexByte(0-1);
|
|||
|
|
_optimum[0].State = _state;
|
|||
|
|
matchByte = GetIndexByte(0-_repDistances[0]-2);
|
|||
|
|
posState = position & _posStateMask;
|
|||
|
|
_optimum[1].Price = CMyBitEncoder_GetPrice0(&_isMatch[_state][posState]) +
|
|||
|
|
CLiteralEncoder_GetPrice(&_literalEncoder,position,_previousByte,
|
|||
|
|
(bool)!CState_IsCharState(_state),matchByte,currentByte);
|
|||
|
|
COptimal_MakeAsChar(&_optimum[1]);
|
|||
|
|
_optimum[1].PosPrev = 0;
|
|||
|
|
for (i=0;i<kNumRepDistances;i++)
|
|||
|
|
_optimum[0].Backs[i] = reps[i];
|
|||
|
|
matchPrice = CMyBitEncoder_GetPrice1(&_isMatch[_state][posState]);
|
|||
|
|
repMatchPrice = matchPrice + CMyBitEncoder_GetPrice1(&_isRep[_state]);
|
|||
|
|
if (matchByte == currentByte)
|
|||
|
|
{
|
|||
|
|
shortRepPrice = repMatchPrice + GetRepLen1Price(_state,posState);
|
|||
|
|
if (shortRepPrice < _optimum[1].Price)
|
|||
|
|
{
|
|||
|
|
_optimum[1].Price = shortRepPrice;
|
|||
|
|
COptimal_MakeAsShortRep(&_optimum[1]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (lenMain < 2)
|
|||
|
|
{
|
|||
|
|
*backRes = _optimum[1].BackPrev;
|
|||
|
|
*lenRes = 1;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
normalMatchPrice = matchPrice + CMyBitEncoder_GetPrice0(&_isRep[_state]);
|
|||
|
|
if (lenMain <= repLens[repMaxIndex])
|
|||
|
|
lenMain = 0;
|
|||
|
|
for (len=2;len<=lenMain;len++)
|
|||
|
|
{
|
|||
|
|
_optimum[len].PosPrev = 0;
|
|||
|
|
_optimum[len].BackPrev = _matchDistances[len] + kNumRepDistances;
|
|||
|
|
_optimum[len].Price = normalMatchPrice + GetPosLenPrice(_matchDistances[len],len,posState);
|
|||
|
|
_optimum[len].Prev1IsChar = false;
|
|||
|
|
}
|
|||
|
|
if (lenMain < repLens[repMaxIndex])
|
|||
|
|
lenMain = repLens[repMaxIndex];
|
|||
|
|
for (;len<=lenMain;len++)
|
|||
|
|
_optimum[len].Price = kIfinityPrice;
|
|||
|
|
for (i=0;i<kNumRepDistances;i++)
|
|||
|
|
{
|
|||
|
|
repLen = repLens[i];
|
|||
|
|
for (lenTest=2;lenTest<=repLen;lenTest++)
|
|||
|
|
{
|
|||
|
|
curAndLenPrice = repMatchPrice + GetRepPrice(i,lenTest,_state,posState);
|
|||
|
|
opt = &_optimum[lenTest];
|
|||
|
|
if (curAndLenPrice < opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = curAndLenPrice;
|
|||
|
|
opt->PosPrev = 0;
|
|||
|
|
opt->BackPrev = i;
|
|||
|
|
opt->Prev1IsChar = false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
cur=0;
|
|||
|
|
lenEnd = lenMain;
|
|||
|
|
while (1)
|
|||
|
|
{
|
|||
|
|
cur++;
|
|||
|
|
if (cur==lenEnd)
|
|||
|
|
{
|
|||
|
|
*lenRes = Backward(backRes,cur);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
position++;
|
|||
|
|
opt = &_optimum[cur];
|
|||
|
|
posPrev = opt->PosPrev;
|
|||
|
|
if (opt->Prev1IsChar)
|
|||
|
|
{
|
|||
|
|
posPrev--;
|
|||
|
|
if (opt->Prev2)
|
|||
|
|
{
|
|||
|
|
state = _optimum[opt->PosPrev2].State;
|
|||
|
|
if (opt->BackPrev2 < kNumRepDistances)
|
|||
|
|
CState_UpdateRep(state);
|
|||
|
|
else
|
|||
|
|
CState_UpdateMatch(state);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
state = _optimum[posPrev].State;
|
|||
|
|
CState_UpdateChar(state);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
state = _optimum[posPrev].State;
|
|||
|
|
if (posPrev == cur-1)
|
|||
|
|
{
|
|||
|
|
if (COptimal_IsShortRep(opt))
|
|||
|
|
CState_UpdateShortRep(state);
|
|||
|
|
else
|
|||
|
|
CState_UpdateChar(state);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (opt->Prev1IsChar && opt->Prev2)
|
|||
|
|
{
|
|||
|
|
posPrev = opt->PosPrev2;
|
|||
|
|
pos = opt->BackPrev2;
|
|||
|
|
CState_UpdateRep(state);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
pos = opt->BackPrev;
|
|||
|
|
if (pos < kNumRepDistances)
|
|||
|
|
CState_UpdateRep(state);
|
|||
|
|
else
|
|||
|
|
CState_UpdateMatch(state);
|
|||
|
|
}
|
|||
|
|
prevOpt = &_optimum[posPrev];
|
|||
|
|
if (pos < kNumRepDistances)
|
|||
|
|
{
|
|||
|
|
reps[0] = prevOpt->Backs[pos];
|
|||
|
|
for (i=1;i<=pos;i++)
|
|||
|
|
reps[i] = prevOpt->Backs[i-1];
|
|||
|
|
for (;i<kNumRepDistances;i++)
|
|||
|
|
reps[i] = prevOpt->Backs[i];
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
reps[0] = pos-kNumRepDistances;
|
|||
|
|
for (i=1;i<kNumRepDistances;i++)
|
|||
|
|
reps[i] = prevOpt->Backs[i-1];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
opt->State = state;
|
|||
|
|
for (i=0;i<kNumRepDistances;i++)
|
|||
|
|
opt->Backs[i] = reps[i];
|
|||
|
|
newLen = ReadMatchDistances();
|
|||
|
|
if (newLen >= _numFastBytes)
|
|||
|
|
{
|
|||
|
|
_longestMatchLength = newLen;
|
|||
|
|
_longestMatchWasFound = true;
|
|||
|
|
*lenRes = Backward(backRes,cur);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
curPrice = opt->Price;
|
|||
|
|
data = GetPointerToCurrentPos()-1;
|
|||
|
|
currentByte = *data;
|
|||
|
|
matchByte = data[-1-reps[0]];
|
|||
|
|
posState = position & _posStateMask;
|
|||
|
|
curAnd1Price = curPrice + CMyBitEncoder_GetPrice0(&_isMatch[state][posState]) +
|
|||
|
|
CLiteralEncoder_GetPrice(&_literalEncoder,position,data[-1],(bool)!CState_IsCharState(state),matchByte,currentByte);
|
|||
|
|
opt = &_optimum[cur+1];
|
|||
|
|
nextIsChar = false;
|
|||
|
|
if (curAnd1Price < opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = curAnd1Price;
|
|||
|
|
opt->PosPrev = cur;
|
|||
|
|
COptimal_MakeAsChar(opt);
|
|||
|
|
nextIsChar = true;
|
|||
|
|
}
|
|||
|
|
matchPrice = curPrice + CMyBitEncoder_GetPrice1(&_isMatch[state][posState]);
|
|||
|
|
repMatchPrice = matchPrice + CMyBitEncoder_GetPrice1(&_isRep[state]);
|
|||
|
|
if (matchByte == currentByte && !(opt->PosPrev<cur && !opt->BackPrev))
|
|||
|
|
{
|
|||
|
|
shortRepPrice = repMatchPrice + GetRepLen1Price(state,posState);
|
|||
|
|
if (shortRepPrice <= opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = shortRepPrice;
|
|||
|
|
opt->PosPrev = cur;
|
|||
|
|
COptimal_MakeAsShortRep(opt);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
numAvailableBytesFull = GetNumAvailableBytes()+1;
|
|||
|
|
if (numAvailableBytesFull > kNumOpts-1-cur)
|
|||
|
|
numAvailableBytesFull = kNumOpts-1-cur;
|
|||
|
|
numAvailableBytes = numAvailableBytesFull;
|
|||
|
|
if (numAvailableBytes < 2)
|
|||
|
|
continue;
|
|||
|
|
if (numAvailableBytes > _numFastBytes)
|
|||
|
|
numAvailableBytes = _numFastBytes;
|
|||
|
|
if (numAvailableBytes >= 3 && !nextIsChar)
|
|||
|
|
{
|
|||
|
|
// try Literal + rep0
|
|||
|
|
int temp;
|
|||
|
|
backOffset = reps[0]+1;
|
|||
|
|
for (temp=1;temp<numAvailableBytes;temp++)
|
|||
|
|
if (data[temp]!=data[temp-backOffset])
|
|||
|
|
break;
|
|||
|
|
lenTest = temp-1;
|
|||
|
|
if (lenTest>=2)
|
|||
|
|
{
|
|||
|
|
int posStateNext;
|
|||
|
|
unsigned nextRepMatchPrice;
|
|||
|
|
state2 = state;
|
|||
|
|
CState_UpdateChar(state2);
|
|||
|
|
posStateNext = (position+1) & _posStateMask;
|
|||
|
|
nextRepMatchPrice = curAnd1Price +
|
|||
|
|
CMyBitEncoder_GetPrice1(&_isMatch[state2][posStateNext]) +
|
|||
|
|
CMyBitEncoder_GetPrice1(&_isRep[state2]);
|
|||
|
|
while (lenEnd < cur+1+lenTest)
|
|||
|
|
_optimum[++lenEnd].Price = kIfinityPrice;
|
|||
|
|
curAndLenPrice = nextRepMatchPrice + GetRepPrice(0,lenTest,state2,posStateNext);
|
|||
|
|
opt = &_optimum[cur+1+lenTest];
|
|||
|
|
if (curAndLenPrice < opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = curAndLenPrice;
|
|||
|
|
opt->PosPrev = cur+1;
|
|||
|
|
opt->BackPrev = 0;
|
|||
|
|
opt->Prev1IsChar = true;
|
|||
|
|
opt->Prev2 = false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
for (repIndex=0;repIndex<kNumRepDistances;repIndex++)
|
|||
|
|
{
|
|||
|
|
backOffset = reps[repIndex]+1;
|
|||
|
|
if (data[0] != data[0-backOffset] ||
|
|||
|
|
data[1] != data[1-backOffset])
|
|||
|
|
continue;
|
|||
|
|
for (lenTest=2;lenTest<numAvailableBytes;lenTest++)
|
|||
|
|
if (data[lenTest]!=data[lenTest-backOffset])
|
|||
|
|
break;
|
|||
|
|
lenTestTemp = lenTest;
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
while (lenEnd < cur+lenTest)
|
|||
|
|
_optimum[++lenEnd].Price = kIfinityPrice;
|
|||
|
|
curAndLenPrice = repMatchPrice + GetRepPrice(repIndex,lenTest,state,posState);
|
|||
|
|
opt = &_optimum[cur+lenTest];
|
|||
|
|
if (curAndLenPrice < opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = curAndLenPrice;
|
|||
|
|
opt->PosPrev = cur;
|
|||
|
|
opt->BackPrev = repIndex;
|
|||
|
|
opt->Prev1IsChar = false;
|
|||
|
|
}
|
|||
|
|
} while (--lenTest>=2);
|
|||
|
|
lenTest = lenTestTemp;
|
|||
|
|
lenTest2 = lenTest+1;
|
|||
|
|
limit = lenTest2 + _numFastBytes;
|
|||
|
|
if (limit > numAvailableBytesFull)
|
|||
|
|
limit = numAvailableBytesFull;
|
|||
|
|
for (;lenTest2<limit;lenTest2++)
|
|||
|
|
if (data[lenTest2] != data[lenTest2-backOffset])
|
|||
|
|
break;
|
|||
|
|
lenTest2 -= lenTest+1;
|
|||
|
|
if (lenTest2 >= 2)
|
|||
|
|
{
|
|||
|
|
unsigned nextMatchPrice,nextRepMatchPrice;
|
|||
|
|
int offset;
|
|||
|
|
state2 = state;
|
|||
|
|
CState_UpdateRep(state2);
|
|||
|
|
posStateNext = (position+lenTest)&_posStateMask;
|
|||
|
|
curAndLenCharPrice = repMatchPrice + GetRepPrice(repIndex,lenTest,state,posState) +
|
|||
|
|
CMyBitEncoder_GetPrice0(&_isMatch[state2][posStateNext]) +
|
|||
|
|
CLiteralEncoder_GetPrice(&_literalEncoder,position+lenTest,data[lenTest-1],true,data[lenTest-backOffset],data[lenTest]);
|
|||
|
|
CState_UpdateChar(state2);
|
|||
|
|
posStateNext = (position+lenTest+1)&_posStateMask;
|
|||
|
|
nextMatchPrice = curAndLenCharPrice + CMyBitEncoder_GetPrice1(&_isMatch[state2][posStateNext]);
|
|||
|
|
nextRepMatchPrice = nextMatchPrice + CMyBitEncoder_GetPrice1(&_isRep[state2]);
|
|||
|
|
offset = lenTest+1+lenTest2;
|
|||
|
|
while (lenEnd<cur+offset)
|
|||
|
|
_optimum[++lenEnd].Price = kIfinityPrice;
|
|||
|
|
curAndLenPrice = nextRepMatchPrice + GetRepPrice(0,lenTest2,state2,posStateNext);
|
|||
|
|
opt = &_optimum[cur+offset];
|
|||
|
|
if (curAndLenPrice < opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = curAndLenPrice;
|
|||
|
|
opt->PosPrev = cur+lenTest+1;
|
|||
|
|
opt->BackPrev = 0;
|
|||
|
|
opt->Prev1IsChar = true;
|
|||
|
|
opt->Prev2 = true;
|
|||
|
|
opt->PosPrev2 = cur;
|
|||
|
|
opt->BackPrev2 = repIndex;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (newLen > numAvailableBytes)
|
|||
|
|
newLen = numAvailableBytes;
|
|||
|
|
if (newLen >= 2)
|
|||
|
|
{
|
|||
|
|
if (newLen==2 && _matchDistances[2] >= 0x80)
|
|||
|
|
continue;
|
|||
|
|
normalMatchPrice = matchPrice + CMyBitEncoder_GetPrice0(&_isRep[state]);
|
|||
|
|
while (lenEnd < cur+newLen)
|
|||
|
|
_optimum[++lenEnd].Price = kIfinityPrice;
|
|||
|
|
for (lenTest=newLen;lenTest>=2;lenTest--)
|
|||
|
|
{
|
|||
|
|
backOffset = _matchDistances[lenTest];
|
|||
|
|
curAndLenPrice = normalMatchPrice + GetPosLenPrice(backOffset,lenTest,posState);
|
|||
|
|
opt = &_optimum[cur+lenTest];
|
|||
|
|
if (curAndLenPrice < opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = curAndLenPrice;
|
|||
|
|
opt->PosPrev = cur;
|
|||
|
|
opt->BackPrev = backOffset+kNumRepDistances;
|
|||
|
|
opt->Prev1IsChar = false;
|
|||
|
|
}
|
|||
|
|
if (lenTest==newLen || backOffset!=_matchDistances[lenTest+1])
|
|||
|
|
{
|
|||
|
|
// Try Match + Literal + Rep0
|
|||
|
|
backOffset++;
|
|||
|
|
lenTest2 = lenTest+1;
|
|||
|
|
limit = lenTest2+_numFastBytes;
|
|||
|
|
if (limit > numAvailableBytesFull)
|
|||
|
|
limit = numAvailableBytesFull;
|
|||
|
|
for (;lenTest2<limit;lenTest2++)
|
|||
|
|
if (data[lenTest2]!=data[lenTest2-backOffset])
|
|||
|
|
break;
|
|||
|
|
lenTest2 -= lenTest+1;
|
|||
|
|
if (lenTest2 >= 2)
|
|||
|
|
{
|
|||
|
|
state2 = state;
|
|||
|
|
CState_UpdateMatch(state2);
|
|||
|
|
posStateNext = (position+lenTest)&_posStateMask;
|
|||
|
|
curAndLenCharPrice = curAndLenPrice + CMyBitEncoder_GetPrice0(&_isMatch[state2][posStateNext]) +
|
|||
|
|
CLiteralEncoder_GetPrice(&_literalEncoder,position+lenTest,data[lenTest-1],true,data[lenTest-backOffset],data[lenTest]);
|
|||
|
|
CState_UpdateChar(state2);
|
|||
|
|
posStateNext = (position+lenTest+1)&_posStateMask;
|
|||
|
|
nextMatchPrice = curAndLenCharPrice + CMyBitEncoder_GetPrice1(&_isMatch[state2][posStateNext]);
|
|||
|
|
nextRepMatchPrice = nextMatchPrice + CMyBitEncoder_GetPrice1(&_isRep[state2]);
|
|||
|
|
offset = lenTest+1+lenTest2;
|
|||
|
|
while (lenEnd<cur+offset)
|
|||
|
|
_optimum[++lenEnd].Price = kIfinityPrice;
|
|||
|
|
curAndLenPrice = nextRepMatchPrice + GetRepPrice(0,lenTest2,state2,posStateNext);
|
|||
|
|
opt = &_optimum[cur+offset];
|
|||
|
|
if (curAndLenPrice < opt->Price)
|
|||
|
|
{
|
|||
|
|
opt->Price = curAndLenPrice;
|
|||
|
|
opt->PosPrev = cur+lenTest+1;
|
|||
|
|
opt->BackPrev = 0;
|
|||
|
|
opt->Prev1IsChar = true;
|
|||
|
|
opt->Prev2 = true;
|
|||
|
|
opt->PosPrev2 = cur;
|
|||
|
|
opt->BackPrev2 = backOffset - 1 + kNumRepDistances;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static bool CodeOneBlock(void)
|
|||
|
|
{
|
|||
|
|
unsigned posState;
|
|||
|
|
byte curByte,matchByte;
|
|||
|
|
unsigned pos,len,distance,i;
|
|||
|
|
unsigned posSlot,lenToPosState;
|
|||
|
|
CLiteralEncoder2* subCoder;
|
|||
|
|
uint64 progressPosValuePrev;
|
|||
|
|
|
|||
|
|
if (_finished)
|
|||
|
|
return false;
|
|||
|
|
_finished = true;
|
|||
|
|
progressPosValuePrev = nowPos64;
|
|||
|
|
if (nowPos64 == 0)
|
|||
|
|
{
|
|||
|
|
if (GetNumAvailableBytes() == 0)
|
|||
|
|
{
|
|||
|
|
CEncoder_Flush();
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
ReadMatchDistances();
|
|||
|
|
posState = (unsigned)nowPos64 & _posStateMask;
|
|||
|
|
CMyBitEncoder_Encode(&_isMatch[_state][posState],0);
|
|||
|
|
CState_UpdateChar(_state);
|
|||
|
|
curByte = GetIndexByte(0 - _additionalOffset);
|
|||
|
|
CLiteralEncoder2_Encode(
|
|||
|
|
*CLiteralEncoder_GetSubCoder(&_literalEncoder,(unsigned)nowPos64,_previousByte),
|
|||
|
|
curByte);
|
|||
|
|
_previousByte = curByte;
|
|||
|
|
_additionalOffset--;
|
|||
|
|
nowPos64++;
|
|||
|
|
}
|
|||
|
|
if (GetNumAvailableBytes() == 0)
|
|||
|
|
{
|
|||
|
|
CEncoder_Flush();
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
for (;;)
|
|||
|
|
{
|
|||
|
|
posState = (unsigned)nowPos64 & _posStateMask;
|
|||
|
|
GetOptimum((unsigned)nowPos64,&pos,&len);
|
|||
|
|
if (len==1 && pos==0xFFFFFFFF)
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&_isMatch[_state][posState],0);
|
|||
|
|
curByte = GetIndexByte(0-_additionalOffset);
|
|||
|
|
subCoder = CLiteralEncoder_GetSubCoder(&_literalEncoder,(unsigned)nowPos64,
|
|||
|
|
_previousByte);
|
|||
|
|
if (!CState_IsCharState(_state))
|
|||
|
|
{
|
|||
|
|
matchByte = GetIndexByte(0-_repDistances[0]-1-_additionalOffset);
|
|||
|
|
CLiteralEncoder2_EncodeMatched(*subCoder,matchByte,curByte);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
CLiteralEncoder2_Encode(*subCoder,curByte);
|
|||
|
|
CState_UpdateChar(_state);
|
|||
|
|
_previousByte = curByte;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&_isMatch[_state][posState],1);
|
|||
|
|
if (pos < kNumRepDistances)
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&_isRep[_state],1);
|
|||
|
|
if (pos==0)
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&_isRepG0[_state],0);
|
|||
|
|
CMyBitEncoder_Encode(&_isRep0Long[_state][posState],
|
|||
|
|
(len==1) ? 0 : 1);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&_isRepG0[_state],1);
|
|||
|
|
if (pos==1)
|
|||
|
|
CMyBitEncoder_Encode(&_isRepG1[_state],0);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&_isRepG1[_state],1);
|
|||
|
|
CMyBitEncoder_Encode(&_isRepG2[_state],pos-2);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (len==1)
|
|||
|
|
CState_UpdateShortRep(_state);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
CPriceTableEncoder_Encode(&_repMatchLenEncoder,len-kMatchMinLen,posState);
|
|||
|
|
CState_UpdateRep(_state);
|
|||
|
|
}
|
|||
|
|
distance = _repDistances[pos];
|
|||
|
|
if (pos)
|
|||
|
|
{
|
|||
|
|
for (i=pos;i;i--)
|
|||
|
|
_repDistances[i] = _repDistances[i-1];
|
|||
|
|
_repDistances[0] = distance;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
CMyBitEncoder_Encode(&_isRep[_state],0);
|
|||
|
|
CState_UpdateMatch(_state);
|
|||
|
|
CPriceTableEncoder_Encode(&_lenEncoder,len-kMatchMinLen,posState);
|
|||
|
|
pos -= kNumRepDistances;
|
|||
|
|
posSlot = GetPosSlot(pos);
|
|||
|
|
lenToPosState = GetLenToPosState(len);
|
|||
|
|
CBitTreeEncoder_Encode(&_posSlotEncoder[lenToPosState],posSlot);
|
|||
|
|
if (posSlot >= kStartPosModelIndex)
|
|||
|
|
{
|
|||
|
|
unsigned footerBits;
|
|||
|
|
unsigned base,posReduced;
|
|||
|
|
footerBits = (posSlot>>1)-1;
|
|||
|
|
base = (2 | (posSlot&1)) << footerBits;
|
|||
|
|
posReduced = pos-base;
|
|||
|
|
if (posSlot < kEndPosModelIndex)
|
|||
|
|
ReverseBitTreeEncode(_posEncoders+base-posSlot-1,
|
|||
|
|
footerBits,posReduced);
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
RangeEncoder_EncodeDirectBits(posReduced>>kNumAlignBits,footerBits-kNumAlignBits);
|
|||
|
|
CBitTreeEncoder_ReverseEncode(&_posAlignEncoder,posReduced&kAlignMask);
|
|||
|
|
if (--_alignPriceCount == 0)
|
|||
|
|
FillAlignPrices();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
distance = pos;
|
|||
|
|
for (i=kNumRepDistances-1;i;i--)
|
|||
|
|
_repDistances[i] = _repDistances[i-1];
|
|||
|
|
_repDistances[0] = distance;
|
|||
|
|
}
|
|||
|
|
_previousByte = GetIndexByte(len-1-_additionalOffset);
|
|||
|
|
}
|
|||
|
|
_additionalOffset -= len;
|
|||
|
|
nowPos64 += len;
|
|||
|
|
if (nowPos64 - lastPosSlotFillingPos >= (1<<9))
|
|||
|
|
{
|
|||
|
|
FillPosSlotPrices();
|
|||
|
|
FillDistancesPrices();
|
|||
|
|
lastPosSlotFillingPos = nowPos64;
|
|||
|
|
}
|
|||
|
|
if (!_additionalOffset)
|
|||
|
|
{
|
|||
|
|
if (GetNumAvailableBytes() == 0)
|
|||
|
|
{
|
|||
|
|
CEncoder_Flush();
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
if (nowPos64 - progressPosValuePrev >= (1<<12))
|
|||
|
|
{
|
|||
|
|
_finished = false;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
extern void __stdcall lzma_set_dict_size(
|
|||
|
|
unsigned logdictsize)
|
|||
|
|
{
|
|||
|
|
_dictionarySize = 1 << logdictsize;
|
|||
|
|
_distTableSize = logdictsize*2;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
extern unsigned __stdcall lzma_compress(
|
|||
|
|
const void* source,
|
|||
|
|
void* destination,
|
|||
|
|
unsigned length,
|
|||
|
|
void* workmem)
|
|||
|
|
{
|
|||
|
|
FastPosInit();
|
|||
|
|
//memset(&encoder,0,sizeof(encoder));
|
|||
|
|
//memset(&rangeEncoder,0,sizeof(rangeEncoder));
|
|||
|
|
// CEncoder::CEncoder, CEncoder::SetCoderProperties
|
|||
|
|
_numFastBytes = 128;
|
|||
|
|
#ifdef FOR_KERPACK
|
|||
|
|
_posStateBits = 0;
|
|||
|
|
_posStateMask = 0;
|
|||
|
|
#else
|
|||
|
|
_posStateBits = 2;
|
|||
|
|
_posStateMask = 3;
|
|||
|
|
#endif
|
|||
|
|
_numLiteralContextBits = 3;
|
|||
|
|
_numLiteralPosStateBits = 0;
|
|||
|
|
_writeEndMark = false;
|
|||
|
|
// CEncoder::Code - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>!
|
|||
|
|
_finished = false;
|
|||
|
|
CEncoder_Create(workmem);
|
|||
|
|
CEncoder_Init();
|
|||
|
|
FillPosSlotPrices();
|
|||
|
|
FillDistancesPrices();
|
|||
|
|
FillAlignPrices();
|
|||
|
|
CPriceTableEncoder_SetTableSize(&_lenEncoder,_numFastBytes+1-kMatchMinLen);
|
|||
|
|
CPriceTableEncoder_UpdateTables(&_lenEncoder,1<<_posStateBits);
|
|||
|
|
CPriceTableEncoder_SetTableSize(&_repMatchLenEncoder,_numFastBytes+1-kMatchMinLen);
|
|||
|
|
CPriceTableEncoder_UpdateTables(&_repMatchLenEncoder,1<<_posStateBits);
|
|||
|
|
lastPosSlotFillingPos = 0;
|
|||
|
|
nowPos64 = 0;
|
|||
|
|
pack_length = length;
|
|||
|
|
pack_pos = 0;
|
|||
|
|
curin = (const byte*)source;
|
|||
|
|
curout = (byte*)destination;
|
|||
|
|
MatchFinder_Init();
|
|||
|
|
while (CodeOneBlock()) ;
|
|||
|
|
return curout - (byte*)destination;
|
|||
|
|
}
|