Index: third_party/lzma/v4_65/files/CS/7zip/Compress/LZMA/LzmaEncoder.cs |
diff --git a/third_party/lzma/v4_65/files/CS/7zip/Compress/LZMA/LzmaEncoder.cs b/third_party/lzma/v4_65/files/CS/7zip/Compress/LZMA/LzmaEncoder.cs |
deleted file mode 100644 |
index a8d67230bf49c024ef163ab22d7e31ada63dc47e..0000000000000000000000000000000000000000 |
--- a/third_party/lzma/v4_65/files/CS/7zip/Compress/LZMA/LzmaEncoder.cs |
+++ /dev/null |
@@ -1,1480 +0,0 @@ |
-// LzmaEncoder.cs |
- |
-using System; |
- |
-namespace SevenZip.Compression.LZMA |
-{ |
- using RangeCoder; |
- |
- public class Encoder : ICoder, ISetCoderProperties, IWriteCoderProperties |
- { |
- enum EMatchFinderType |
- { |
- BT2, |
- BT4, |
- }; |
- |
- const UInt32 kIfinityPrice = 0xFFFFFFF; |
- |
- static Byte[] g_FastPos = new Byte[1 << 11]; |
- |
- static Encoder() |
- { |
- const Byte kFastSlots = 22; |
- int c = 2; |
- g_FastPos[0] = 0; |
- g_FastPos[1] = 1; |
- for (Byte slotFast = 2; slotFast < kFastSlots; slotFast++) |
- { |
- UInt32 k = ((UInt32)1 << ((slotFast >> 1) - 1)); |
- for (UInt32 j = 0; j < k; j++, c++) |
- g_FastPos[c] = slotFast; |
- } |
- } |
- |
- static UInt32 GetPosSlot(UInt32 pos) |
- { |
- if (pos < (1 << 11)) |
- return g_FastPos[pos]; |
- if (pos < (1 << 21)) |
- return (UInt32)(g_FastPos[pos >> 10] + 20); |
- return (UInt32)(g_FastPos[pos >> 20] + 40); |
- } |
- |
- static UInt32 GetPosSlot2(UInt32 pos) |
- { |
- if (pos < (1 << 17)) |
- return (UInt32)(g_FastPos[pos >> 6] + 12); |
- if (pos < (1 << 27)) |
- return (UInt32)(g_FastPos[pos >> 16] + 32); |
- return (UInt32)(g_FastPos[pos >> 26] + 52); |
- } |
- |
- Base.State _state = new Base.State(); |
- Byte _previousByte; |
- UInt32[] _repDistances = new UInt32[Base.kNumRepDistances]; |
- |
- void BaseInit() |
- { |
- _state.Init(); |
- _previousByte = 0; |
- for (UInt32 i = 0; i < Base.kNumRepDistances; i++) |
- _repDistances[i] = 0; |
- } |
- |
- const int kDefaultDictionaryLogSize = 22; |
- const UInt32 kNumFastBytesDefault = 0x20; |
- |
- class LiteralEncoder |
- { |
- public struct Encoder2 |
- { |
- BitEncoder[] m_Encoders; |
- |
- public void Create() { m_Encoders = new BitEncoder[0x300]; } |
- |
- public void Init() { for (int i = 0; i < 0x300; i++) m_Encoders[i].Init(); } |
- |
- public void Encode(RangeCoder.Encoder rangeEncoder, byte symbol) |
- { |
- uint context = 1; |
- for (int i = 7; i >= 0; i--) |
- { |
- uint bit = (uint)((symbol >> i) & 1); |
- m_Encoders[context].Encode(rangeEncoder, bit); |
- context = (context << 1) | bit; |
- } |
- } |
- |
- public void EncodeMatched(RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol) |
- { |
- uint context = 1; |
- bool same = true; |
- for (int i = 7; i >= 0; i--) |
- { |
- uint bit = (uint)((symbol >> i) & 1); |
- uint state = context; |
- if (same) |
- { |
- uint matchBit = (uint)((matchByte >> i) & 1); |
- state += ((1 + matchBit) << 8); |
- same = (matchBit == bit); |
- } |
- m_Encoders[state].Encode(rangeEncoder, bit); |
- context = (context << 1) | bit; |
- } |
- } |
- |
- public uint GetPrice(bool matchMode, byte matchByte, byte symbol) |
- { |
- uint price = 0; |
- uint context = 1; |
- int i = 7; |
- if (matchMode) |
- { |
- for (; i >= 0; i--) |
- { |
- uint matchBit = (uint)(matchByte >> i) & 1; |
- uint bit = (uint)(symbol >> i) & 1; |
- price += m_Encoders[((1 + matchBit) << 8) + context].GetPrice(bit); |
- context = (context << 1) | bit; |
- if (matchBit != bit) |
- { |
- i--; |
- break; |
- } |
- } |
- } |
- for (; i >= 0; i--) |
- { |
- uint bit = (uint)(symbol >> i) & 1; |
- price += m_Encoders[context].GetPrice(bit); |
- context = (context << 1) | bit; |
- } |
- return price; |
- } |
- } |
- |
- Encoder2[] m_Coders; |
- int m_NumPrevBits; |
- int m_NumPosBits; |
- uint m_PosMask; |
- |
- public void Create(int numPosBits, int numPrevBits) |
- { |
- if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits) |
- return; |
- m_NumPosBits = numPosBits; |
- m_PosMask = ((uint)1 << numPosBits) - 1; |
- m_NumPrevBits = numPrevBits; |
- uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits); |
- m_Coders = new Encoder2[numStates]; |
- for (uint i = 0; i < numStates; i++) |
- m_Coders[i].Create(); |
- } |
- |
- public void Init() |
- { |
- uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits); |
- for (uint i = 0; i < numStates; i++) |
- m_Coders[i].Init(); |
- } |
- |
- public Encoder2 GetSubCoder(UInt32 pos, Byte prevByte) |
- { return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits))]; } |
- } |
- |
- class LenEncoder |
- { |
- RangeCoder.BitEncoder _choice = new RangeCoder.BitEncoder(); |
- RangeCoder.BitEncoder _choice2 = new RangeCoder.BitEncoder(); |
- RangeCoder.BitTreeEncoder[] _lowCoder = new RangeCoder.BitTreeEncoder[Base.kNumPosStatesEncodingMax]; |
- RangeCoder.BitTreeEncoder[] _midCoder = new RangeCoder.BitTreeEncoder[Base.kNumPosStatesEncodingMax]; |
- RangeCoder.BitTreeEncoder _highCoder = new RangeCoder.BitTreeEncoder(Base.kNumHighLenBits); |
- |
- public LenEncoder() |
- { |
- for (UInt32 posState = 0; posState < Base.kNumPosStatesEncodingMax; posState++) |
- { |
- _lowCoder[posState] = new RangeCoder.BitTreeEncoder(Base.kNumLowLenBits); |
- _midCoder[posState] = new RangeCoder.BitTreeEncoder(Base.kNumMidLenBits); |
- } |
- } |
- |
- public void Init(UInt32 numPosStates) |
- { |
- _choice.Init(); |
- _choice2.Init(); |
- for (UInt32 posState = 0; posState < numPosStates; posState++) |
- { |
- _lowCoder[posState].Init(); |
- _midCoder[posState].Init(); |
- } |
- _highCoder.Init(); |
- } |
- |
- public void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState) |
- { |
- if (symbol < Base.kNumLowLenSymbols) |
- { |
- _choice.Encode(rangeEncoder, 0); |
- _lowCoder[posState].Encode(rangeEncoder, symbol); |
- } |
- else |
- { |
- symbol -= Base.kNumLowLenSymbols; |
- _choice.Encode(rangeEncoder, 1); |
- if (symbol < Base.kNumMidLenSymbols) |
- { |
- _choice2.Encode(rangeEncoder, 0); |
- _midCoder[posState].Encode(rangeEncoder, symbol); |
- } |
- else |
- { |
- _choice2.Encode(rangeEncoder, 1); |
- _highCoder.Encode(rangeEncoder, symbol - Base.kNumMidLenSymbols); |
- } |
- } |
- } |
- |
- public void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32[] prices, UInt32 st) |
- { |
- UInt32 a0 = _choice.GetPrice0(); |
- UInt32 a1 = _choice.GetPrice1(); |
- UInt32 b0 = a1 + _choice2.GetPrice0(); |
- UInt32 b1 = a1 + _choice2.GetPrice1(); |
- UInt32 i = 0; |
- for (i = 0; i < Base.kNumLowLenSymbols; i++) |
- { |
- if (i >= numSymbols) |
- return; |
- prices[st + i] = a0 + _lowCoder[posState].GetPrice(i); |
- } |
- for (; i < Base.kNumLowLenSymbols + Base.kNumMidLenSymbols; i++) |
- { |
- if (i >= numSymbols) |
- return; |
- prices[st + i] = b0 + _midCoder[posState].GetPrice(i - Base.kNumLowLenSymbols); |
- } |
- for (; i < numSymbols; i++) |
- prices[st + i] = b1 + _highCoder.GetPrice(i - Base.kNumLowLenSymbols - Base.kNumMidLenSymbols); |
- } |
- }; |
- |
- const UInt32 kNumLenSpecSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols; |
- |
- class LenPriceTableEncoder : LenEncoder |
- { |
- UInt32[] _prices = new UInt32[Base.kNumLenSymbols << Base.kNumPosStatesBitsEncodingMax]; |
- UInt32 _tableSize; |
- UInt32[] _counters = new UInt32[Base.kNumPosStatesEncodingMax]; |
- |
- public void SetTableSize(UInt32 tableSize) { _tableSize = tableSize; } |
- |
- public UInt32 GetPrice(UInt32 symbol, UInt32 posState) |
- { |
- return _prices[posState * Base.kNumLenSymbols + symbol]; |
- } |
- |
- void UpdateTable(UInt32 posState) |
- { |
- SetPrices(posState, _tableSize, _prices, posState * Base.kNumLenSymbols); |
- _counters[posState] = _tableSize; |
- } |
- |
- public void UpdateTables(UInt32 numPosStates) |
- { |
- for (UInt32 posState = 0; posState < numPosStates; posState++) |
- UpdateTable(posState); |
- } |
- |
- public new void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState) |
- { |
- base.Encode(rangeEncoder, symbol, posState); |
- if (--_counters[posState] == 0) |
- UpdateTable(posState); |
- } |
- } |
- |
- const UInt32 kNumOpts = 1 << 12; |
- class Optimal |
- { |
- public Base.State State; |
- |
- public bool Prev1IsChar; |
- public bool Prev2; |
- |
- public UInt32 PosPrev2; |
- public UInt32 BackPrev2; |
- |
- public UInt32 Price; |
- public UInt32 PosPrev; |
- public UInt32 BackPrev; |
- |
- public UInt32 Backs0; |
- public UInt32 Backs1; |
- public UInt32 Backs2; |
- public UInt32 Backs3; |
- |
- public void MakeAsChar() { BackPrev = 0xFFFFFFFF; Prev1IsChar = false; } |
- public void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; } |
- public bool IsShortRep() { return (BackPrev == 0); } |
- }; |
- Optimal[] _optimum = new Optimal[kNumOpts]; |
- LZ.IMatchFinder _matchFinder = null; |
- RangeCoder.Encoder _rangeEncoder = new RangeCoder.Encoder(); |
- |
- RangeCoder.BitEncoder[] _isMatch = new RangeCoder.BitEncoder[Base.kNumStates << Base.kNumPosStatesBitsMax]; |
- RangeCoder.BitEncoder[] _isRep = new RangeCoder.BitEncoder[Base.kNumStates]; |
- RangeCoder.BitEncoder[] _isRepG0 = new RangeCoder.BitEncoder[Base.kNumStates]; |
- RangeCoder.BitEncoder[] _isRepG1 = new RangeCoder.BitEncoder[Base.kNumStates]; |
- RangeCoder.BitEncoder[] _isRepG2 = new RangeCoder.BitEncoder[Base.kNumStates]; |
- RangeCoder.BitEncoder[] _isRep0Long = new RangeCoder.BitEncoder[Base.kNumStates << Base.kNumPosStatesBitsMax]; |
- |
- RangeCoder.BitTreeEncoder[] _posSlotEncoder = new RangeCoder.BitTreeEncoder[Base.kNumLenToPosStates]; |
- |
- RangeCoder.BitEncoder[] _posEncoders = new RangeCoder.BitEncoder[Base.kNumFullDistances - Base.kEndPosModelIndex]; |
- RangeCoder.BitTreeEncoder _posAlignEncoder = new RangeCoder.BitTreeEncoder(Base.kNumAlignBits); |
- |
- LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder(); |
- LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder(); |
- |
- LiteralEncoder _literalEncoder = new LiteralEncoder(); |
- |
- UInt32[] _matchDistances = new UInt32[Base.kMatchMaxLen * 2 + 2]; |
- |
- UInt32 _numFastBytes = kNumFastBytesDefault; |
- UInt32 _longestMatchLength; |
- UInt32 _numDistancePairs; |
- |
- UInt32 _additionalOffset; |
- |
- UInt32 _optimumEndIndex; |
- UInt32 _optimumCurrentIndex; |
- |
- bool _longestMatchWasFound; |
- |
- UInt32[] _posSlotPrices = new UInt32[1 << (Base.kNumPosSlotBits + Base.kNumLenToPosStatesBits)]; |
- UInt32[] _distancesPrices = new UInt32[Base.kNumFullDistances << Base.kNumLenToPosStatesBits]; |
- UInt32[] _alignPrices = new UInt32[Base.kAlignTableSize]; |
- UInt32 _alignPriceCount; |
- |
- UInt32 _distTableSize = (kDefaultDictionaryLogSize * 2); |
- |
- int _posStateBits = 2; |
- UInt32 _posStateMask = (4 - 1); |
- int _numLiteralPosStateBits = 0; |
- int _numLiteralContextBits = 3; |
- |
- UInt32 _dictionarySize = (1 << kDefaultDictionaryLogSize); |
- UInt32 _dictionarySizePrev = 0xFFFFFFFF; |
- UInt32 _numFastBytesPrev = 0xFFFFFFFF; |
- |
- Int64 nowPos64; |
- bool _finished; |
- System.IO.Stream _inStream; |
- |
- EMatchFinderType _matchFinderType = EMatchFinderType.BT4; |
- bool _writeEndMark = false; |
- |
- bool _needReleaseMFStream; |
- |
- void Create() |
- { |
- if (_matchFinder == null) |
- { |
- LZ.BinTree bt = new LZ.BinTree(); |
- int numHashBytes = 4; |
- if (_matchFinderType == EMatchFinderType.BT2) |
- numHashBytes = 2; |
- bt.SetType(numHashBytes); |
- _matchFinder = bt; |
- } |
- _literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits); |
- |
- if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes) |
- return; |
- _matchFinder.Create(_dictionarySize, kNumOpts, _numFastBytes, Base.kMatchMaxLen + 1); |
- _dictionarySizePrev = _dictionarySize; |
- _numFastBytesPrev = _numFastBytes; |
- } |
- |
- public Encoder() |
- { |
- for (int i = 0; i < kNumOpts; i++) |
- _optimum[i] = new Optimal(); |
- for (int i = 0; i < Base.kNumLenToPosStates; i++) |
- _posSlotEncoder[i] = new RangeCoder.BitTreeEncoder(Base.kNumPosSlotBits); |
- } |
- |
- void SetWriteEndMarkerMode(bool writeEndMarker) |
- { |
- _writeEndMark = writeEndMarker; |
- } |
- |
- void Init() |
- { |
- BaseInit(); |
- _rangeEncoder.Init(); |
- |
- uint i; |
- for (i = 0; i < Base.kNumStates; i++) |
- { |
- for (uint j = 0; j <= _posStateMask; j++) |
- { |
- uint complexState = (i << Base.kNumPosStatesBitsMax) + j; |
- _isMatch[complexState].Init(); |
- _isRep0Long[complexState].Init(); |
- } |
- _isRep[i].Init(); |
- _isRepG0[i].Init(); |
- _isRepG1[i].Init(); |
- _isRepG2[i].Init(); |
- } |
- _literalEncoder.Init(); |
- for (i = 0; i < Base.kNumLenToPosStates; i++) |
- _posSlotEncoder[i].Init(); |
- for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++) |
- _posEncoders[i].Init(); |
- |
- _lenEncoder.Init((UInt32)1 << _posStateBits); |
- _repMatchLenEncoder.Init((UInt32)1 << _posStateBits); |
- |
- _posAlignEncoder.Init(); |
- |
- _longestMatchWasFound = false; |
- _optimumEndIndex = 0; |
- _optimumCurrentIndex = 0; |
- _additionalOffset = 0; |
- } |
- |
- void ReadMatchDistances(out UInt32 lenRes, out UInt32 numDistancePairs) |
- { |
- lenRes = 0; |
- numDistancePairs = _matchFinder.GetMatches(_matchDistances); |
- if (numDistancePairs > 0) |
- { |
- lenRes = _matchDistances[numDistancePairs - 2]; |
- if (lenRes == _numFastBytes) |
- lenRes += _matchFinder.GetMatchLen((int)lenRes - 1, _matchDistances[numDistancePairs - 1], |
- Base.kMatchMaxLen - lenRes); |
- } |
- _additionalOffset++; |
- } |
- |
- |
- void MovePos(UInt32 num) |
- { |
- if (num > 0) |
- { |
- _matchFinder.Skip(num); |
- _additionalOffset += num; |
- } |
- } |
- |
- UInt32 GetRepLen1Price(Base.State state, UInt32 posState) |
- { |
- return _isRepG0[state.Index].GetPrice0() + |
- _isRep0Long[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0(); |
- } |
- |
- UInt32 GetPureRepPrice(UInt32 repIndex, Base.State state, UInt32 posState) |
- { |
- UInt32 price; |
- if (repIndex == 0) |
- { |
- price = _isRepG0[state.Index].GetPrice0(); |
- price += _isRep0Long[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1(); |
- } |
- else |
- { |
- price = _isRepG0[state.Index].GetPrice1(); |
- if (repIndex == 1) |
- price += _isRepG1[state.Index].GetPrice0(); |
- else |
- { |
- price += _isRepG1[state.Index].GetPrice1(); |
- price += _isRepG2[state.Index].GetPrice(repIndex - 2); |
- } |
- } |
- return price; |
- } |
- |
- UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, Base.State state, UInt32 posState) |
- { |
- UInt32 price = _repMatchLenEncoder.GetPrice(len - Base.kMatchMinLen, posState); |
- return price + GetPureRepPrice(repIndex, state, posState); |
- } |
- |
- UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState) |
- { |
- UInt32 price; |
- UInt32 lenToPosState = Base.GetLenToPosState(len); |
- if (pos < Base.kNumFullDistances) |
- price = _distancesPrices[(lenToPosState * Base.kNumFullDistances) + pos]; |
- else |
- price = _posSlotPrices[(lenToPosState << Base.kNumPosSlotBits) + GetPosSlot2(pos)] + |
- _alignPrices[pos & Base.kAlignMask]; |
- return price + _lenEncoder.GetPrice(len - Base.kMatchMinLen, posState); |
- } |
- |
- UInt32 Backward(out UInt32 backRes, UInt32 cur) |
- { |
- _optimumEndIndex = cur; |
- UInt32 posMem = _optimum[cur].PosPrev; |
- UInt32 backMem = _optimum[cur].BackPrev; |
- do |
- { |
- if (_optimum[cur].Prev1IsChar) |
- { |
- _optimum[posMem].MakeAsChar(); |
- _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; |
- } |
- } |
- UInt32 posPrev = posMem; |
- UInt32 backCur = backMem; |
- |
- backMem = _optimum[posPrev].BackPrev; |
- posMem = _optimum[posPrev].PosPrev; |
- |
- _optimum[posPrev].BackPrev = backCur; |
- _optimum[posPrev].PosPrev = cur; |
- cur = posPrev; |
- } |
- while (cur > 0); |
- backRes = _optimum[0].BackPrev; |
- _optimumCurrentIndex = _optimum[0].PosPrev; |
- return _optimumCurrentIndex; |
- } |
- |
- UInt32[] reps = new UInt32[Base.kNumRepDistances]; |
- UInt32[] repLens = new UInt32[Base.kNumRepDistances]; |
- |
- |
- UInt32 GetOptimum(UInt32 position, out UInt32 backRes) |
- { |
- if (_optimumEndIndex != _optimumCurrentIndex) |
- { |
- UInt32 lenRes = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex; |
- backRes = _optimum[_optimumCurrentIndex].BackPrev; |
- _optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev; |
- return lenRes; |
- } |
- _optimumCurrentIndex = _optimumEndIndex = 0; |
- |
- UInt32 lenMain, numDistancePairs; |
- if (!_longestMatchWasFound) |
- { |
- ReadMatchDistances(out lenMain, out numDistancePairs); |
- } |
- else |
- { |
- lenMain = _longestMatchLength; |
- numDistancePairs = _numDistancePairs; |
- _longestMatchWasFound = false; |
- } |
- |
- UInt32 numAvailableBytes = _matchFinder.GetNumAvailableBytes() + 1; |
- if (numAvailableBytes < 2) |
- { |
- backRes = 0xFFFFFFFF; |
- return 1; |
- } |
- if (numAvailableBytes > Base.kMatchMaxLen) |
- numAvailableBytes = Base.kMatchMaxLen; |
- |
- UInt32 repMaxIndex = 0; |
- UInt32 i; |
- for (i = 0; i < Base.kNumRepDistances; i++) |
- { |
- reps[i] = _repDistances[i]; |
- repLens[i] = _matchFinder.GetMatchLen(0 - 1, reps[i], Base.kMatchMaxLen); |
- if (repLens[i] > repLens[repMaxIndex]) |
- repMaxIndex = i; |
- } |
- if (repLens[repMaxIndex] >= _numFastBytes) |
- { |
- backRes = repMaxIndex; |
- UInt32 lenRes = repLens[repMaxIndex]; |
- MovePos(lenRes - 1); |
- return lenRes; |
- } |
- |
- if (lenMain >= _numFastBytes) |
- { |
- backRes = _matchDistances[numDistancePairs - 1] + Base.kNumRepDistances; |
- MovePos(lenMain - 1); |
- return lenMain; |
- } |
- |
- Byte currentByte = _matchFinder.GetIndexByte(0 - 1); |
- Byte matchByte = _matchFinder.GetIndexByte((Int32)(0 - _repDistances[0] - 1 - 1)); |
- |
- if (lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2) |
- { |
- backRes = (UInt32)0xFFFFFFFF; |
- return 1; |
- } |
- |
- _optimum[0].State = _state; |
- |
- UInt32 posState = (position & _posStateMask); |
- |
- _optimum[1].Price = _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0() + |
- _literalEncoder.GetSubCoder(position, _previousByte).GetPrice(!_state.IsCharState(), matchByte, currentByte); |
- _optimum[1].MakeAsChar(); |
- |
- UInt32 matchPrice = _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1(); |
- UInt32 repMatchPrice = matchPrice + _isRep[_state.Index].GetPrice1(); |
- |
- if (matchByte == currentByte) |
- { |
- UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState); |
- if (shortRepPrice < _optimum[1].Price) |
- { |
- _optimum[1].Price = shortRepPrice; |
- _optimum[1].MakeAsShortRep(); |
- } |
- } |
- |
- UInt32 lenEnd = ((lenMain >= repLens[repMaxIndex]) ? lenMain : repLens[repMaxIndex]); |
- |
- if(lenEnd < 2) |
- { |
- backRes = _optimum[1].BackPrev; |
- return 1; |
- } |
- |
- _optimum[1].PosPrev = 0; |
- |
- _optimum[0].Backs0 = reps[0]; |
- _optimum[0].Backs1 = reps[1]; |
- _optimum[0].Backs2 = reps[2]; |
- _optimum[0].Backs3 = reps[3]; |
- |
- UInt32 len = lenEnd; |
- do |
- _optimum[len--].Price = kIfinityPrice; |
- while (len >= 2); |
- |
- for (i = 0; i < Base.kNumRepDistances; i++) |
- { |
- UInt32 repLen = repLens[i]; |
- if (repLen < 2) |
- continue; |
- UInt32 price = repMatchPrice + GetPureRepPrice(i, _state, posState); |
- do |
- { |
- UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(repLen - 2, posState); |
- Optimal optimum = _optimum[repLen]; |
- if (curAndLenPrice < optimum.Price) |
- { |
- optimum.Price = curAndLenPrice; |
- optimum.PosPrev = 0; |
- optimum.BackPrev = i; |
- optimum.Prev1IsChar = false; |
- } |
- } |
- while (--repLen >= 2); |
- } |
- |
- UInt32 normalMatchPrice = matchPrice + _isRep[_state.Index].GetPrice0(); |
- |
- len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2); |
- if (len <= lenMain) |
- { |
- UInt32 offs = 0; |
- while (len > _matchDistances[offs]) |
- offs += 2; |
- for (; ; len++) |
- { |
- UInt32 distance = _matchDistances[offs + 1]; |
- UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(distance, len, posState); |
- Optimal optimum = _optimum[len]; |
- if (curAndLenPrice < optimum.Price) |
- { |
- optimum.Price = curAndLenPrice; |
- optimum.PosPrev = 0; |
- optimum.BackPrev = distance + Base.kNumRepDistances; |
- optimum.Prev1IsChar = false; |
- } |
- if (len == _matchDistances[offs]) |
- { |
- offs += 2; |
- if (offs == numDistancePairs) |
- break; |
- } |
- } |
- } |
- |
- UInt32 cur = 0; |
- |
- while (true) |
- { |
- cur++; |
- if (cur == lenEnd) |
- return Backward(out backRes, cur); |
- UInt32 newLen; |
- ReadMatchDistances(out newLen, out numDistancePairs); |
- if (newLen >= _numFastBytes) |
- { |
- _numDistancePairs = numDistancePairs; |
- _longestMatchLength = newLen; |
- _longestMatchWasFound = true; |
- return Backward(out backRes, cur); |
- } |
- position++; |
- UInt32 posPrev = _optimum[cur].PosPrev; |
- Base.State state; |
- if (_optimum[cur].Prev1IsChar) |
- { |
- posPrev--; |
- if (_optimum[cur].Prev2) |
- { |
- state = _optimum[_optimum[cur].PosPrev2].State; |
- if (_optimum[cur].BackPrev2 < Base.kNumRepDistances) |
- state.UpdateRep(); |
- else |
- state.UpdateMatch(); |
- } |
- else |
- state = _optimum[posPrev].State; |
- state.UpdateChar(); |
- } |
- else |
- state = _optimum[posPrev].State; |
- if (posPrev == cur - 1) |
- { |
- if (_optimum[cur].IsShortRep()) |
- state.UpdateShortRep(); |
- else |
- state.UpdateChar(); |
- } |
- else |
- { |
- UInt32 pos; |
- if (_optimum[cur].Prev1IsChar && _optimum[cur].Prev2) |
- { |
- posPrev = _optimum[cur].PosPrev2; |
- pos = _optimum[cur].BackPrev2; |
- state.UpdateRep(); |
- } |
- else |
- { |
- pos = _optimum[cur].BackPrev; |
- if (pos < Base.kNumRepDistances) |
- state.UpdateRep(); |
- else |
- state.UpdateMatch(); |
- } |
- Optimal opt = _optimum[posPrev]; |
- if (pos < Base.kNumRepDistances) |
- { |
- if (pos == 0) |
- { |
- reps[0] = opt.Backs0; |
- reps[1] = opt.Backs1; |
- reps[2] = opt.Backs2; |
- reps[3] = opt.Backs3; |
- } |
- else if (pos == 1) |
- { |
- reps[0] = opt.Backs1; |
- reps[1] = opt.Backs0; |
- reps[2] = opt.Backs2; |
- reps[3] = opt.Backs3; |
- } |
- else if (pos == 2) |
- { |
- reps[0] = opt.Backs2; |
- reps[1] = opt.Backs0; |
- reps[2] = opt.Backs1; |
- reps[3] = opt.Backs3; |
- } |
- else |
- { |
- reps[0] = opt.Backs3; |
- reps[1] = opt.Backs0; |
- reps[2] = opt.Backs1; |
- reps[3] = opt.Backs2; |
- } |
- } |
- else |
- { |
- reps[0] = (pos - Base.kNumRepDistances); |
- reps[1] = opt.Backs0; |
- reps[2] = opt.Backs1; |
- reps[3] = opt.Backs2; |
- } |
- } |
- _optimum[cur].State = state; |
- _optimum[cur].Backs0 = reps[0]; |
- _optimum[cur].Backs1 = reps[1]; |
- _optimum[cur].Backs2 = reps[2]; |
- _optimum[cur].Backs3 = reps[3]; |
- UInt32 curPrice = _optimum[cur].Price; |
- |
- currentByte = _matchFinder.GetIndexByte(0 - 1); |
- matchByte = _matchFinder.GetIndexByte((Int32)(0 - reps[0] - 1 - 1)); |
- |
- posState = (position & _posStateMask); |
- |
- UInt32 curAnd1Price = curPrice + |
- _isMatch[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0() + |
- _literalEncoder.GetSubCoder(position, _matchFinder.GetIndexByte(0 - 2)). |
- GetPrice(!state.IsCharState(), matchByte, currentByte); |
- |
- Optimal nextOptimum = _optimum[cur + 1]; |
- |
- bool nextIsChar = false; |
- if (curAnd1Price < nextOptimum.Price) |
- { |
- nextOptimum.Price = curAnd1Price; |
- nextOptimum.PosPrev = cur; |
- nextOptimum.MakeAsChar(); |
- nextIsChar = true; |
- } |
- |
- matchPrice = curPrice + _isMatch[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1(); |
- repMatchPrice = matchPrice + _isRep[state.Index].GetPrice1(); |
- |
- if (matchByte == currentByte && |
- !(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0)) |
- { |
- UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState); |
- if (shortRepPrice <= nextOptimum.Price) |
- { |
- nextOptimum.Price = shortRepPrice; |
- nextOptimum.PosPrev = cur; |
- nextOptimum.MakeAsShortRep(); |
- nextIsChar = true; |
- } |
- } |
- |
- UInt32 numAvailableBytesFull = _matchFinder.GetNumAvailableBytes() + 1; |
- numAvailableBytesFull = Math.Min(kNumOpts - 1 - cur, numAvailableBytesFull); |
- numAvailableBytes = numAvailableBytesFull; |
- |
- if (numAvailableBytes < 2) |
- continue; |
- if (numAvailableBytes > _numFastBytes) |
- numAvailableBytes = _numFastBytes; |
- if (!nextIsChar && matchByte != currentByte) |
- { |
- // try Literal + rep0 |
- UInt32 t = Math.Min(numAvailableBytesFull - 1, _numFastBytes); |
- UInt32 lenTest2 = _matchFinder.GetMatchLen(0, reps[0], t); |
- if (lenTest2 >= 2) |
- { |
- Base.State state2 = state; |
- state2.UpdateChar(); |
- UInt32 posStateNext = (position + 1) & _posStateMask; |
- UInt32 nextRepMatchPrice = curAnd1Price + |
- _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1() + |
- _isRep[state2.Index].GetPrice1(); |
- { |
- UInt32 offset = cur + 1 + lenTest2; |
- while (lenEnd < offset) |
- _optimum[++lenEnd].Price = kIfinityPrice; |
- UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice( |
- 0, lenTest2, state2, posStateNext); |
- Optimal optimum = _optimum[offset]; |
- if (curAndLenPrice < optimum.Price) |
- { |
- optimum.Price = curAndLenPrice; |
- optimum.PosPrev = cur + 1; |
- optimum.BackPrev = 0; |
- optimum.Prev1IsChar = true; |
- optimum.Prev2 = false; |
- } |
- } |
- } |
- } |
- |
- UInt32 startLen = 2; // speed optimization |
- |
- for (UInt32 repIndex = 0; repIndex < Base.kNumRepDistances; repIndex++) |
- { |
- UInt32 lenTest = _matchFinder.GetMatchLen(0 - 1, reps[repIndex], numAvailableBytes); |
- if (lenTest < 2) |
- continue; |
- UInt32 lenTestTemp = lenTest; |
- do |
- { |
- while (lenEnd < cur + lenTest) |
- _optimum[++lenEnd].Price = kIfinityPrice; |
- UInt32 curAndLenPrice = repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState); |
- Optimal optimum = _optimum[cur + lenTest]; |
- if (curAndLenPrice < optimum.Price) |
- { |
- optimum.Price = curAndLenPrice; |
- optimum.PosPrev = cur; |
- optimum.BackPrev = repIndex; |
- optimum.Prev1IsChar = false; |
- } |
- } |
- while(--lenTest >= 2); |
- lenTest = lenTestTemp; |
- |
- if (repIndex == 0) |
- startLen = lenTest + 1; |
- |
- // if (_maxMode) |
- if (lenTest < numAvailableBytesFull) |
- { |
- UInt32 t = Math.Min(numAvailableBytesFull - 1 - lenTest, _numFastBytes); |
- UInt32 lenTest2 = _matchFinder.GetMatchLen((Int32)lenTest, reps[repIndex], t); |
- if (lenTest2 >= 2) |
- { |
- Base.State state2 = state; |
- state2.UpdateRep(); |
- UInt32 posStateNext = (position + lenTest) & _posStateMask; |
- UInt32 curAndLenCharPrice = |
- repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState) + |
- _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice0() + |
- _literalEncoder.GetSubCoder(position + lenTest, |
- _matchFinder.GetIndexByte((Int32)lenTest - 1 - 1)).GetPrice(true, |
- _matchFinder.GetIndexByte((Int32)((Int32)lenTest - 1 - (Int32)(reps[repIndex] + 1))), |
- _matchFinder.GetIndexByte((Int32)lenTest - 1)); |
- state2.UpdateChar(); |
- posStateNext = (position + lenTest + 1) & _posStateMask; |
- UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1(); |
- UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1(); |
- |
- // for(; lenTest2 >= 2; lenTest2--) |
- { |
- UInt32 offset = lenTest + 1 + lenTest2; |
- while(lenEnd < cur + offset) |
- _optimum[++lenEnd].Price = kIfinityPrice; |
- UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext); |
- Optimal optimum = _optimum[cur + offset]; |
- if (curAndLenPrice < optimum.Price) |
- { |
- optimum.Price = curAndLenPrice; |
- optimum.PosPrev = cur + lenTest + 1; |
- optimum.BackPrev = 0; |
- optimum.Prev1IsChar = true; |
- optimum.Prev2 = true; |
- optimum.PosPrev2 = cur; |
- optimum.BackPrev2 = repIndex; |
- } |
- } |
- } |
- } |
- } |
- |
- if (newLen > numAvailableBytes) |
- { |
- newLen = numAvailableBytes; |
- for (numDistancePairs = 0; newLen > _matchDistances[numDistancePairs]; numDistancePairs += 2) ; |
- _matchDistances[numDistancePairs] = newLen; |
- numDistancePairs += 2; |
- } |
- if (newLen >= startLen) |
- { |
- normalMatchPrice = matchPrice + _isRep[state.Index].GetPrice0(); |
- while (lenEnd < cur + newLen) |
- _optimum[++lenEnd].Price = kIfinityPrice; |
- |
- UInt32 offs = 0; |
- while (startLen > _matchDistances[offs]) |
- offs += 2; |
- |
- for (UInt32 lenTest = startLen; ; lenTest++) |
- { |
- UInt32 curBack = _matchDistances[offs + 1]; |
- UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(curBack, lenTest, posState); |
- Optimal optimum = _optimum[cur + lenTest]; |
- if (curAndLenPrice < optimum.Price) |
- { |
- optimum.Price = curAndLenPrice; |
- optimum.PosPrev = cur; |
- optimum.BackPrev = curBack + Base.kNumRepDistances; |
- optimum.Prev1IsChar = false; |
- } |
- |
- if (lenTest == _matchDistances[offs]) |
- { |
- if (lenTest < numAvailableBytesFull) |
- { |
- UInt32 t = Math.Min(numAvailableBytesFull - 1 - lenTest, _numFastBytes); |
- UInt32 lenTest2 = _matchFinder.GetMatchLen((Int32)lenTest, curBack, t); |
- if (lenTest2 >= 2) |
- { |
- Base.State state2 = state; |
- state2.UpdateMatch(); |
- UInt32 posStateNext = (position + lenTest) & _posStateMask; |
- UInt32 curAndLenCharPrice = curAndLenPrice + |
- _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice0() + |
- _literalEncoder.GetSubCoder(position + lenTest, |
- _matchFinder.GetIndexByte((Int32)lenTest - 1 - 1)). |
- GetPrice(true, |
- _matchFinder.GetIndexByte((Int32)lenTest - (Int32)(curBack + 1) - 1), |
- _matchFinder.GetIndexByte((Int32)lenTest - 1)); |
- state2.UpdateChar(); |
- posStateNext = (position + lenTest + 1) & _posStateMask; |
- UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1(); |
- UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1(); |
- |
- UInt32 offset = lenTest + 1 + lenTest2; |
- while (lenEnd < cur + offset) |
- _optimum[++lenEnd].Price = kIfinityPrice; |
- curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext); |
- optimum = _optimum[cur + offset]; |
- if (curAndLenPrice < optimum.Price) |
- { |
- optimum.Price = curAndLenPrice; |
- optimum.PosPrev = cur + lenTest + 1; |
- optimum.BackPrev = 0; |
- optimum.Prev1IsChar = true; |
- optimum.Prev2 = true; |
- optimum.PosPrev2 = cur; |
- optimum.BackPrev2 = curBack + Base.kNumRepDistances; |
- } |
- } |
- } |
- offs += 2; |
- if (offs == numDistancePairs) |
- break; |
- } |
- } |
- } |
- } |
- } |
- |
- bool ChangePair(UInt32 smallDist, UInt32 bigDist) |
- { |
- const int kDif = 7; |
- return (smallDist < ((UInt32)(1) << (32 - kDif)) && bigDist >= (smallDist << kDif)); |
- } |
- |
- void WriteEndMarker(UInt32 posState) |
- { |
- if (!_writeEndMark) |
- return; |
- |
- _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].Encode(_rangeEncoder, 1); |
- _isRep[_state.Index].Encode(_rangeEncoder, 0); |
- _state.UpdateMatch(); |
- UInt32 len = Base.kMatchMinLen; |
- _lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState); |
- UInt32 posSlot = (1 << Base.kNumPosSlotBits) - 1; |
- UInt32 lenToPosState = Base.GetLenToPosState(len); |
- _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot); |
- int footerBits = 30; |
- UInt32 posReduced = (((UInt32)1) << footerBits) - 1; |
- _rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits); |
- _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask); |
- } |
- |
- void Flush(UInt32 nowPos) |
- { |
- ReleaseMFStream(); |
- WriteEndMarker(nowPos & _posStateMask); |
- _rangeEncoder.FlushData(); |
- _rangeEncoder.FlushStream(); |
- } |
- |
- public void CodeOneBlock(out Int64 inSize, out Int64 outSize, out bool finished) |
- { |
- inSize = 0; |
- outSize = 0; |
- finished = true; |
- |
- if (_inStream != null) |
- { |
- _matchFinder.SetStream(_inStream); |
- _matchFinder.Init(); |
- _needReleaseMFStream = true; |
- _inStream = null; |
- if (_trainSize > 0) |
- _matchFinder.Skip(_trainSize); |
- } |
- |
- if (_finished) |
- return; |
- _finished = true; |
- |
- |
- Int64 progressPosValuePrev = nowPos64; |
- if (nowPos64 == 0) |
- { |
- if (_matchFinder.GetNumAvailableBytes() == 0) |
- { |
- Flush((UInt32)nowPos64); |
- return; |
- } |
- UInt32 len, numDistancePairs; // it's not used |
- ReadMatchDistances(out len, out numDistancePairs); |
- UInt32 posState = (UInt32)(nowPos64) & _posStateMask; |
- _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].Encode(_rangeEncoder, 0); |
- _state.UpdateChar(); |
- Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset)); |
- _literalEncoder.GetSubCoder((UInt32)(nowPos64), _previousByte).Encode(_rangeEncoder, curByte); |
- _previousByte = curByte; |
- _additionalOffset--; |
- nowPos64++; |
- } |
- if (_matchFinder.GetNumAvailableBytes() == 0) |
- { |
- Flush((UInt32)nowPos64); |
- return; |
- } |
- while (true) |
- { |
- UInt32 pos; |
- UInt32 len = GetOptimum((UInt32)nowPos64, out pos); |
- |
- UInt32 posState = ((UInt32)nowPos64) & _posStateMask; |
- UInt32 complexState = (_state.Index << Base.kNumPosStatesBitsMax) + posState; |
- if (len == 1 && pos == 0xFFFFFFFF) |
- { |
- _isMatch[complexState].Encode(_rangeEncoder, 0); |
- Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset)); |
- LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((UInt32)nowPos64, _previousByte); |
- if (!_state.IsCharState()) |
- { |
- Byte matchByte = _matchFinder.GetIndexByte((Int32)(0 - _repDistances[0] - 1 - _additionalOffset)); |
- subCoder.EncodeMatched(_rangeEncoder, matchByte, curByte); |
- } |
- else |
- subCoder.Encode(_rangeEncoder, curByte); |
- _previousByte = curByte; |
- _state.UpdateChar(); |
- } |
- else |
- { |
- _isMatch[complexState].Encode(_rangeEncoder, 1); |
- if (pos < Base.kNumRepDistances) |
- { |
- _isRep[_state.Index].Encode(_rangeEncoder, 1); |
- if (pos == 0) |
- { |
- _isRepG0[_state.Index].Encode(_rangeEncoder, 0); |
- if (len == 1) |
- _isRep0Long[complexState].Encode(_rangeEncoder, 0); |
- else |
- _isRep0Long[complexState].Encode(_rangeEncoder, 1); |
- } |
- else |
- { |
- _isRepG0[_state.Index].Encode(_rangeEncoder, 1); |
- if (pos == 1) |
- _isRepG1[_state.Index].Encode(_rangeEncoder, 0); |
- else |
- { |
- _isRepG1[_state.Index].Encode(_rangeEncoder, 1); |
- _isRepG2[_state.Index].Encode(_rangeEncoder, pos - 2); |
- } |
- } |
- if (len == 1) |
- _state.UpdateShortRep(); |
- else |
- { |
- _repMatchLenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState); |
- _state.UpdateRep(); |
- } |
- UInt32 distance = _repDistances[pos]; |
- if (pos != 0) |
- { |
- for (UInt32 i = pos; i >= 1; i--) |
- _repDistances[i] = _repDistances[i - 1]; |
- _repDistances[0] = distance; |
- } |
- } |
- else |
- { |
- _isRep[_state.Index].Encode(_rangeEncoder, 0); |
- _state.UpdateMatch(); |
- _lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState); |
- pos -= Base.kNumRepDistances; |
- UInt32 posSlot = GetPosSlot(pos); |
- UInt32 lenToPosState = Base.GetLenToPosState(len); |
- _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot); |
- |
- if (posSlot >= Base.kStartPosModelIndex) |
- { |
- int footerBits = (int)((posSlot >> 1) - 1); |
- UInt32 baseVal = ((2 | (posSlot & 1)) << footerBits); |
- UInt32 posReduced = pos - baseVal; |
- |
- if (posSlot < Base.kEndPosModelIndex) |
- RangeCoder.BitTreeEncoder.ReverseEncode(_posEncoders, |
- baseVal - posSlot - 1, _rangeEncoder, footerBits, posReduced); |
- else |
- { |
- _rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits); |
- _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask); |
- _alignPriceCount++; |
- } |
- } |
- UInt32 distance = pos; |
- for (UInt32 i = Base.kNumRepDistances - 1; i >= 1; i--) |
- _repDistances[i] = _repDistances[i - 1]; |
- _repDistances[0] = distance; |
- _matchPriceCount++; |
- } |
- _previousByte = _matchFinder.GetIndexByte((Int32)(len - 1 - _additionalOffset)); |
- } |
- _additionalOffset -= len; |
- nowPos64 += len; |
- if (_additionalOffset == 0) |
- { |
- // if (!_fastMode) |
- if (_matchPriceCount >= (1 << 7)) |
- FillDistancesPrices(); |
- if (_alignPriceCount >= Base.kAlignTableSize) |
- FillAlignPrices(); |
- inSize = nowPos64; |
- outSize = _rangeEncoder.GetProcessedSizeAdd(); |
- if (_matchFinder.GetNumAvailableBytes() == 0) |
- { |
- Flush((UInt32)nowPos64); |
- return; |
- } |
- |
- if (nowPos64 - progressPosValuePrev >= (1 << 12)) |
- { |
- _finished = false; |
- finished = false; |
- return; |
- } |
- } |
- } |
- } |
- |
- void ReleaseMFStream() |
- { |
- if (_matchFinder != null && _needReleaseMFStream) |
- { |
- _matchFinder.ReleaseStream(); |
- _needReleaseMFStream = false; |
- } |
- } |
- |
- void SetOutStream(System.IO.Stream outStream) { _rangeEncoder.SetStream(outStream); } |
- void ReleaseOutStream() { _rangeEncoder.ReleaseStream(); } |
- |
- void ReleaseStreams() |
- { |
- ReleaseMFStream(); |
- ReleaseOutStream(); |
- } |
- |
- void SetStreams(System.IO.Stream inStream, System.IO.Stream outStream, |
- Int64 inSize, Int64 outSize) |
- { |
- _inStream = inStream; |
- _finished = false; |
- Create(); |
- SetOutStream(outStream); |
- Init(); |
- |
- // if (!_fastMode) |
- { |
- FillDistancesPrices(); |
- FillAlignPrices(); |
- } |
- |
- _lenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen); |
- _lenEncoder.UpdateTables((UInt32)1 << _posStateBits); |
- _repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen); |
- _repMatchLenEncoder.UpdateTables((UInt32)1 << _posStateBits); |
- |
- nowPos64 = 0; |
- } |
- |
- |
- public void Code(System.IO.Stream inStream, System.IO.Stream outStream, |
- Int64 inSize, Int64 outSize, ICodeProgress progress) |
- { |
- _needReleaseMFStream = false; |
- try |
- { |
- SetStreams(inStream, outStream, inSize, outSize); |
- while (true) |
- { |
- Int64 processedInSize; |
- Int64 processedOutSize; |
- bool finished; |
- CodeOneBlock(out processedInSize, out processedOutSize, out finished); |
- if (finished) |
- return; |
- if (progress != null) |
- { |
- progress.SetProgress(processedInSize, processedOutSize); |
- } |
- } |
- } |
- finally |
- { |
- ReleaseStreams(); |
- } |
- } |
- |
- const int kPropSize = 5; |
- Byte[] properties = new Byte[kPropSize]; |
- |
- public void WriteCoderProperties(System.IO.Stream outStream) |
- { |
- properties[0] = (Byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits); |
- for (int i = 0; i < 4; i++) |
- properties[1 + i] = (Byte)(_dictionarySize >> (8 * i)); |
- outStream.Write(properties, 0, kPropSize); |
- } |
- |
- UInt32[] tempPrices = new UInt32[Base.kNumFullDistances]; |
- UInt32 _matchPriceCount; |
- |
- void FillDistancesPrices() |
- { |
- for (UInt32 i = Base.kStartPosModelIndex; i < Base.kNumFullDistances; i++) |
- { |
- UInt32 posSlot = GetPosSlot(i); |
- int footerBits = (int)((posSlot >> 1) - 1); |
- UInt32 baseVal = ((2 | (posSlot & 1)) << footerBits); |
- tempPrices[i] = BitTreeEncoder.ReverseGetPrice(_posEncoders, |
- baseVal - posSlot - 1, footerBits, i - baseVal); |
- } |
- |
- for (UInt32 lenToPosState = 0; lenToPosState < Base.kNumLenToPosStates; lenToPosState++) |
- { |
- UInt32 posSlot; |
- RangeCoder.BitTreeEncoder encoder = _posSlotEncoder[lenToPosState]; |
- |
- UInt32 st = (lenToPosState << Base.kNumPosSlotBits); |
- for (posSlot = 0; posSlot < _distTableSize; posSlot++) |
- _posSlotPrices[st + posSlot] = encoder.GetPrice(posSlot); |
- for (posSlot = Base.kEndPosModelIndex; posSlot < _distTableSize; posSlot++) |
- _posSlotPrices[st + posSlot] += ((((posSlot >> 1) - 1) - Base.kNumAlignBits) << RangeCoder.BitEncoder.kNumBitPriceShiftBits); |
- |
- UInt32 st2 = lenToPosState * Base.kNumFullDistances; |
- UInt32 i; |
- for (i = 0; i < Base.kStartPosModelIndex; i++) |
- _distancesPrices[st2 + i] = _posSlotPrices[st + i]; |
- for (; i < Base.kNumFullDistances; i++) |
- _distancesPrices[st2 + i] = _posSlotPrices[st + GetPosSlot(i)] + tempPrices[i]; |
- } |
- _matchPriceCount = 0; |
- } |
- |
- void FillAlignPrices() |
- { |
- for (UInt32 i = 0; i < Base.kAlignTableSize; i++) |
- _alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i); |
- _alignPriceCount = 0; |
- } |
- |
- |
- static string[] kMatchFinderIDs = |
- { |
- "BT2", |
- "BT4", |
- }; |
- |
- static int FindMatchFinder(string s) |
- { |
- for (int m = 0; m < kMatchFinderIDs.Length; m++) |
- if (s == kMatchFinderIDs[m]) |
- return m; |
- return -1; |
- } |
- |
- public void SetCoderProperties(CoderPropID[] propIDs, object[] properties) |
- { |
- for (UInt32 i = 0; i < properties.Length; i++) |
- { |
- object prop = properties[i]; |
- switch (propIDs[i]) |
- { |
- case CoderPropID.NumFastBytes: |
- { |
- if (!(prop is Int32)) |
- throw new InvalidParamException(); |
- Int32 numFastBytes = (Int32)prop; |
- if (numFastBytes < 5 || numFastBytes > Base.kMatchMaxLen) |
- throw new InvalidParamException(); |
- _numFastBytes = (UInt32)numFastBytes; |
- break; |
- } |
- case CoderPropID.Algorithm: |
- { |
- /* |
- if (!(prop is Int32)) |
- throw new InvalidParamException(); |
- Int32 maximize = (Int32)prop; |
- _fastMode = (maximize == 0); |
- _maxMode = (maximize >= 2); |
- */ |
- break; |
- } |
- case CoderPropID.MatchFinder: |
- { |
- if (!(prop is String)) |
- throw new InvalidParamException(); |
- EMatchFinderType matchFinderIndexPrev = _matchFinderType; |
- int m = FindMatchFinder(((string)prop).ToUpper()); |
- if (m < 0) |
- throw new InvalidParamException(); |
- _matchFinderType = (EMatchFinderType)m; |
- if (_matchFinder != null && matchFinderIndexPrev != _matchFinderType) |
- { |
- _dictionarySizePrev = 0xFFFFFFFF; |
- _matchFinder = null; |
- } |
- break; |
- } |
- case CoderPropID.DictionarySize: |
- { |
- const int kDicLogSizeMaxCompress = 30; |
- if (!(prop is Int32)) |
- throw new InvalidParamException(); ; |
- Int32 dictionarySize = (Int32)prop; |
- if (dictionarySize < (UInt32)(1 << Base.kDicLogSizeMin) || |
- dictionarySize > (UInt32)(1 << kDicLogSizeMaxCompress)) |
- throw new InvalidParamException(); |
- _dictionarySize = (UInt32)dictionarySize; |
- int dicLogSize; |
- for (dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++) |
- if (dictionarySize <= ((UInt32)(1) << dicLogSize)) |
- break; |
- _distTableSize = (UInt32)dicLogSize * 2; |
- break; |
- } |
- case CoderPropID.PosStateBits: |
- { |
- if (!(prop is Int32)) |
- throw new InvalidParamException(); |
- Int32 v = (Int32)prop; |
- if (v < 0 || v > (UInt32)Base.kNumPosStatesBitsEncodingMax) |
- throw new InvalidParamException(); |
- _posStateBits = (int)v; |
- _posStateMask = (((UInt32)1) << (int)_posStateBits) - 1; |
- break; |
- } |
- case CoderPropID.LitPosBits: |
- { |
- if (!(prop is Int32)) |
- throw new InvalidParamException(); |
- Int32 v = (Int32)prop; |
- if (v < 0 || v > (UInt32)Base.kNumLitPosStatesBitsEncodingMax) |
- throw new InvalidParamException(); |
- _numLiteralPosStateBits = (int)v; |
- break; |
- } |
- case CoderPropID.LitContextBits: |
- { |
- if (!(prop is Int32)) |
- throw new InvalidParamException(); |
- Int32 v = (Int32)prop; |
- if (v < 0 || v > (UInt32)Base.kNumLitContextBitsMax) |
- throw new InvalidParamException(); ; |
- _numLiteralContextBits = (int)v; |
- break; |
- } |
- case CoderPropID.EndMarker: |
- { |
- if (!(prop is Boolean)) |
- throw new InvalidParamException(); |
- SetWriteEndMarkerMode((Boolean)prop); |
- break; |
- } |
- default: |
- throw new InvalidParamException(); |
- } |
- } |
- } |
- |
- uint _trainSize = 0; |
- public void SetTrainSize(uint trainSize) |
- { |
- _trainSize = trainSize; |
- } |
- |
- } |
-} |