Source code
Revision control
Copy as Markdown
Other Tools
// 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)) & 0xFF);↩
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;↩
}↩
↩
}↩
}↩