package SevenZip.Compression.LZMA; | |
import SevenZip.Compression.RangeCoder.BitTreeEncoder; | |
import SevenZip.Compression.LZMA.Base; | |
import SevenZip.Compression.LZ.BinTree; | |
import SevenZip.ICodeProgress; | |
import java.io.IOException; | |
public class Encoder | |
{ | |
public static final int EMatchFinderTypeBT2 = 0; | |
public static final int EMatchFinderTypeBT4 = 1; | |
static final int kIfinityPrice = 0xFFFFFFF; | |
static byte[] g_FastPos = new byte[1 << 11]; | |
static | |
{ | |
int kFastSlots = 22; | |
int c = 2; | |
g_FastPos[0] = 0; | |
g_FastPos[1] = 1; | |
for (int slotFast = 2; slotFast < kFastSlots; slotFast++) | |
{ | |
int k = (1 << ((slotFast >> 1) - 1)); | |
for (int j = 0; j < k; j++, c++) | |
g_FastPos[c] = (byte)slotFast; | |
} | |
} | |
static int GetPosSlot(int pos) | |
{ | |
if (pos < (1 << 11)) | |
return g_FastPos[pos]; | |
if (pos < (1 << 21)) | |
return (g_FastPos[pos >> 10] + 20); | |
return (g_FastPos[pos >> 20] + 40); | |
} | |
static int GetPosSlot2(int pos) | |
{ | |
if (pos < (1 << 17)) | |
return (g_FastPos[pos >> 6] + 12); | |
if (pos < (1 << 27)) | |
return (g_FastPos[pos >> 16] + 32); | |
return (g_FastPos[pos >> 26] + 52); | |
} | |
int _state = Base.StateInit(); | |
byte _previousByte; | |
int[] _repDistances = new int[Base.kNumRepDistances]; | |
void BaseInit() | |
{ | |
_state = Base.StateInit(); | |
_previousByte = 0; | |
for (int i = 0; i < Base.kNumRepDistances; i++) | |
_repDistances[i] = 0; | |
} | |
static final int kDefaultDictionaryLogSize = 22; | |
static final int kNumFastBytesDefault = 0x20; | |
class LiteralEncoder | |
{ | |
class Encoder2 | |
{ | |
short[] m_Encoders = new short[0x300]; | |
public void Init() { SevenZip.Compression.RangeCoder.Encoder.InitBitModels(m_Encoders); } | |
public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte symbol) throws IOException | |
{ | |
int context = 1; | |
for (int i = 7; i >= 0; i--) | |
{ | |
int bit = ((symbol >> i) & 1); | |
rangeEncoder.Encode(m_Encoders, context, bit); | |
context = (context << 1) | bit; | |
} | |
} | |
public void EncodeMatched(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol) throws IOException | |
{ | |
int context = 1; | |
boolean same = true; | |
for (int i = 7; i >= 0; i--) | |
{ | |
int bit = ((symbol >> i) & 1); | |
int state = context; | |
if (same) | |
{ | |
int matchBit = ((matchByte >> i) & 1); | |
state += ((1 + matchBit) << 8); | |
same = (matchBit == bit); | |
} | |
rangeEncoder.Encode(m_Encoders, state, bit); | |
context = (context << 1) | bit; | |
} | |
} | |
public int GetPrice(boolean matchMode, byte matchByte, byte symbol) | |
{ | |
int price = 0; | |
int context = 1; | |
int i = 7; | |
if (matchMode) | |
{ | |
for (; i >= 0; i--) | |
{ | |
int matchBit = (matchByte >> i) & 1; | |
int bit = (symbol >> i) & 1; | |
price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(m_Encoders[((1 + matchBit) << 8) + context], bit); | |
context = (context << 1) | bit; | |
if (matchBit != bit) | |
{ | |
i--; | |
break; | |
} | |
} | |
} | |
for (; i >= 0; i--) | |
{ | |
int bit = (symbol >> i) & 1; | |
price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(m_Encoders[context], bit); | |
context = (context << 1) | bit; | |
} | |
return price; | |
} | |
} | |
Encoder2[] m_Coders; | |
int m_NumPrevBits; | |
int m_NumPosBits; | |
int 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 = (1 << numPosBits) - 1; | |
m_NumPrevBits = numPrevBits; | |
int numStates = 1 << (m_NumPrevBits + m_NumPosBits); | |
m_Coders = new Encoder2[numStates]; | |
for (int i = 0; i < numStates; i++) | |
m_Coders[i] = new Encoder2(); | |
} | |
public void Init() | |
{ | |
int numStates = 1 << (m_NumPrevBits + m_NumPosBits); | |
for (int i = 0; i < numStates; i++) | |
m_Coders[i].Init(); | |
} | |
public Encoder2 GetSubCoder(int pos, byte prevByte) | |
{ return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + ((prevByte & 0xFF) >>> (8 - m_NumPrevBits))]; } | |
} | |
class LenEncoder | |
{ | |
short[] _choice = new short[2]; | |
BitTreeEncoder[] _lowCoder = new BitTreeEncoder[Base.kNumPosStatesEncodingMax]; | |
BitTreeEncoder[] _midCoder = new BitTreeEncoder[Base.kNumPosStatesEncodingMax]; | |
BitTreeEncoder _highCoder = new BitTreeEncoder(Base.kNumHighLenBits); | |
public LenEncoder() | |
{ | |
for (int posState = 0; posState < Base.kNumPosStatesEncodingMax; posState++) | |
{ | |
_lowCoder[posState] = new BitTreeEncoder(Base.kNumLowLenBits); | |
_midCoder[posState] = new BitTreeEncoder(Base.kNumMidLenBits); | |
} | |
} | |
public void Init(int numPosStates) | |
{ | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_choice); | |
for (int posState = 0; posState < numPosStates; posState++) | |
{ | |
_lowCoder[posState].Init(); | |
_midCoder[posState].Init(); | |
} | |
_highCoder.Init(); | |
} | |
public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, int symbol, int posState) throws IOException | |
{ | |
if (symbol < Base.kNumLowLenSymbols) | |
{ | |
rangeEncoder.Encode(_choice, 0, 0); | |
_lowCoder[posState].Encode(rangeEncoder, symbol); | |
} | |
else | |
{ | |
symbol -= Base.kNumLowLenSymbols; | |
rangeEncoder.Encode(_choice, 0, 1); | |
if (symbol < Base.kNumMidLenSymbols) | |
{ | |
rangeEncoder.Encode(_choice, 1, 0); | |
_midCoder[posState].Encode(rangeEncoder, symbol); | |
} | |
else | |
{ | |
rangeEncoder.Encode(_choice, 1, 1); | |
_highCoder.Encode(rangeEncoder, symbol - Base.kNumMidLenSymbols); | |
} | |
} | |
} | |
public void SetPrices(int posState, int numSymbols, int[] prices, int st) | |
{ | |
int a0 = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_choice[0]); | |
int a1 = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_choice[0]); | |
int b0 = a1 + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_choice[1]); | |
int b1 = a1 + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_choice[1]); | |
int 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); | |
} | |
}; | |
public static final int kNumLenSpecSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols; | |
class LenPriceTableEncoder extends LenEncoder | |
{ | |
int[] _prices = new int[Base.kNumLenSymbols<<Base.kNumPosStatesBitsEncodingMax]; | |
int _tableSize; | |
int[] _counters = new int[Base.kNumPosStatesEncodingMax]; | |
public void SetTableSize(int tableSize) { _tableSize = tableSize; } | |
public int GetPrice(int symbol, int posState) | |
{ | |
return _prices[posState * Base.kNumLenSymbols + symbol]; | |
} | |
void UpdateTable(int posState) | |
{ | |
SetPrices(posState, _tableSize, _prices, posState * Base.kNumLenSymbols); | |
_counters[posState] = _tableSize; | |
} | |
public void UpdateTables(int numPosStates) | |
{ | |
for (int posState = 0; posState < numPosStates; posState++) | |
UpdateTable(posState); | |
} | |
public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, int symbol, int posState) throws IOException | |
{ | |
super.Encode(rangeEncoder, symbol, posState); | |
if (--_counters[posState] == 0) | |
UpdateTable(posState); | |
} | |
} | |
static final int kNumOpts = 1 << 12; | |
class Optimal | |
{ | |
public int State; | |
public boolean Prev1IsChar; | |
public boolean Prev2; | |
public int PosPrev2; | |
public int BackPrev2; | |
public int Price; | |
public int PosPrev; | |
public int BackPrev; | |
public int Backs0; | |
public int Backs1; | |
public int Backs2; | |
public int Backs3; | |
public void MakeAsChar() { BackPrev = -1; Prev1IsChar = false; } | |
public void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; } | |
public boolean IsShortRep() { return (BackPrev == 0); } | |
}; | |
Optimal[] _optimum = new Optimal[kNumOpts]; | |
SevenZip.Compression.LZ.BinTree _matchFinder = null; | |
SevenZip.Compression.RangeCoder.Encoder _rangeEncoder = new SevenZip.Compression.RangeCoder.Encoder(); | |
short[] _isMatch = new short[Base.kNumStates<<Base.kNumPosStatesBitsMax]; | |
short[] _isRep = new short[Base.kNumStates]; | |
short[] _isRepG0 = new short[Base.kNumStates]; | |
short[] _isRepG1 = new short[Base.kNumStates]; | |
short[] _isRepG2 = new short[Base.kNumStates]; | |
short[] _isRep0Long = new short[Base.kNumStates<<Base.kNumPosStatesBitsMax]; | |
BitTreeEncoder[] _posSlotEncoder = new BitTreeEncoder[Base.kNumLenToPosStates]; // kNumPosSlotBits | |
short[] _posEncoders = new short[Base.kNumFullDistances-Base.kEndPosModelIndex]; | |
BitTreeEncoder _posAlignEncoder = new BitTreeEncoder(Base.kNumAlignBits); | |
LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder(); | |
LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder(); | |
LiteralEncoder _literalEncoder = new LiteralEncoder(); | |
int[] _matchDistances = new int[Base.kMatchMaxLen*2+2]; | |
int _numFastBytes = kNumFastBytesDefault; | |
int _longestMatchLength; | |
int _numDistancePairs; | |
int _additionalOffset; | |
int _optimumEndIndex; | |
int _optimumCurrentIndex; | |
boolean _longestMatchWasFound; | |
int[] _posSlotPrices = new int[1<<(Base.kNumPosSlotBits+Base.kNumLenToPosStatesBits)]; | |
int[] _distancesPrices = new int[Base.kNumFullDistances<<Base.kNumLenToPosStatesBits]; | |
int[] _alignPrices = new int[Base.kAlignTableSize]; | |
int _alignPriceCount; | |
int _distTableSize = (kDefaultDictionaryLogSize * 2); | |
int _posStateBits = 2; | |
int _posStateMask = (4 - 1); | |
int _numLiteralPosStateBits = 0; | |
int _numLiteralContextBits = 3; | |
int _dictionarySize = (1 << kDefaultDictionaryLogSize); | |
int _dictionarySizePrev = -1; | |
int _numFastBytesPrev = -1; | |
long nowPos64; | |
boolean _finished; | |
java.io.InputStream _inStream; | |
int _matchFinderType = EMatchFinderTypeBT4; | |
boolean _writeEndMark = false; | |
boolean _needReleaseMFStream = false; | |
void Create() | |
{ | |
if (_matchFinder == null) | |
{ | |
SevenZip.Compression.LZ.BinTree bt = new SevenZip.Compression.LZ.BinTree(); | |
int numHashBytes = 4; | |
if (_matchFinderType == EMatchFinderTypeBT2) | |
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 BitTreeEncoder(Base.kNumPosSlotBits); | |
} | |
void SetWriteEndMarkerMode(boolean writeEndMarker) | |
{ | |
_writeEndMark = writeEndMarker; | |
} | |
void Init() | |
{ | |
BaseInit(); | |
_rangeEncoder.Init(); | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isMatch); | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRep0Long); | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRep); | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG0); | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG1); | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG2); | |
SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_posEncoders); | |
_literalEncoder.Init(); | |
for (int i = 0; i < Base.kNumLenToPosStates; i++) | |
_posSlotEncoder[i].Init(); | |
_lenEncoder.Init(1 << _posStateBits); | |
_repMatchLenEncoder.Init(1 << _posStateBits); | |
_posAlignEncoder.Init(); | |
_longestMatchWasFound = false; | |
_optimumEndIndex = 0; | |
_optimumCurrentIndex = 0; | |
_additionalOffset = 0; | |
} | |
int ReadMatchDistances() throws java.io.IOException | |
{ | |
int 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++; | |
return lenRes; | |
} | |
void MovePos(int num) throws java.io.IOException | |
{ | |
if (num > 0) | |
{ | |
_matchFinder.Skip(num); | |
_additionalOffset += num; | |
} | |
} | |
int GetRepLen1Price(int state, int posState) | |
{ | |
return SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG0[state]) + | |
SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep0Long[(state << Base.kNumPosStatesBitsMax) + posState]); | |
} | |
int GetPureRepPrice(int repIndex, int state, int posState) | |
{ | |
int price; | |
if (repIndex == 0) | |
{ | |
price = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG0[state]); | |
price += SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep0Long[(state << Base.kNumPosStatesBitsMax) + posState]); | |
} | |
else | |
{ | |
price = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRepG0[state]); | |
if (repIndex == 1) | |
price += SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG1[state]); | |
else | |
{ | |
price += SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRepG1[state]); | |
price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(_isRepG2[state], repIndex - 2); | |
} | |
} | |
return price; | |
} | |
int GetRepPrice(int repIndex, int len, int state, int posState) | |
{ | |
int price = _repMatchLenEncoder.GetPrice(len - Base.kMatchMinLen, posState); | |
return price + GetPureRepPrice(repIndex, state, posState); | |
} | |
int GetPosLenPrice(int pos, int len, int posState) | |
{ | |
int price; | |
int 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); | |
} | |
int Backward(int cur) | |
{ | |
_optimumEndIndex = cur; | |
int posMem = _optimum[cur].PosPrev; | |
int 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; | |
} | |
} | |
int posPrev = posMem; | |
int 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; | |
} | |
int[] reps = new int[Base.kNumRepDistances]; | |
int[] repLens = new int[Base.kNumRepDistances]; | |
int backRes; | |
int GetOptimum(int position) throws IOException | |
{ | |
if (_optimumEndIndex != _optimumCurrentIndex) | |
{ | |
int lenRes = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex; | |
backRes = _optimum[_optimumCurrentIndex].BackPrev; | |
_optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev; | |
return lenRes; | |
} | |
_optimumCurrentIndex = _optimumEndIndex = 0; | |
int lenMain, numDistancePairs; | |
if (!_longestMatchWasFound) | |
{ | |
lenMain = ReadMatchDistances(); | |
} | |
else | |
{ | |
lenMain = _longestMatchLength; | |
_longestMatchWasFound = false; | |
} | |
numDistancePairs = _numDistancePairs; | |
int numAvailableBytes = _matchFinder.GetNumAvailableBytes() + 1; | |
if (numAvailableBytes < 2) | |
{ | |
backRes = -1; | |
return 1; | |
} | |
if (numAvailableBytes > Base.kMatchMaxLen) | |
numAvailableBytes = Base.kMatchMaxLen; | |
int repMaxIndex = 0; | |
int 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; | |
int 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(0 - _repDistances[0] - 1 - 1); | |
if (lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2) | |
{ | |
backRes = -1; | |
return 1; | |
} | |
_optimum[0].State = _state; | |
int posState = (position & _posStateMask); | |
_optimum[1].Price = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(_state << Base.kNumPosStatesBitsMax) + posState]) + | |
_literalEncoder.GetSubCoder(position, _previousByte).GetPrice(!Base.StateIsCharState(_state), matchByte, currentByte); | |
_optimum[1].MakeAsChar(); | |
int matchPrice = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(_state << Base.kNumPosStatesBitsMax) + posState]); | |
int repMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[_state]); | |
if (matchByte == currentByte) | |
{ | |
int shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState); | |
if (shortRepPrice < _optimum[1].Price) | |
{ | |
_optimum[1].Price = shortRepPrice; | |
_optimum[1].MakeAsShortRep(); | |
} | |
} | |
int 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]; | |
int len = lenEnd; | |
do | |
_optimum[len--].Price = kIfinityPrice; | |
while (len >= 2); | |
for (i = 0; i < Base.kNumRepDistances; i++) | |
{ | |
int repLen = repLens[i]; | |
if (repLen < 2) | |
continue; | |
int price = repMatchPrice + GetPureRepPrice(i, _state, posState); | |
do | |
{ | |
int 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); | |
} | |
int normalMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep[_state]); | |
len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2); | |
if (len <= lenMain) | |
{ | |
int offs = 0; | |
while (len > _matchDistances[offs]) | |
offs += 2; | |
for (; ; len++) | |
{ | |
int distance = _matchDistances[offs + 1]; | |
int 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; | |
} | |
} | |
} | |
int cur = 0; | |
while (true) | |
{ | |
cur++; | |
if (cur == lenEnd) | |
return Backward(cur); | |
int newLen = ReadMatchDistances(); | |
numDistancePairs = _numDistancePairs; | |
if (newLen >= _numFastBytes) | |
{ | |
_longestMatchLength = newLen; | |
_longestMatchWasFound = true; | |
return Backward(cur); | |
} | |
position++; | |
int posPrev = _optimum[cur].PosPrev; | |
int state; | |
if (_optimum[cur].Prev1IsChar) | |
{ | |
posPrev--; | |
if (_optimum[cur].Prev2) | |
{ | |
state = _optimum[_optimum[cur].PosPrev2].State; | |
if (_optimum[cur].BackPrev2 < Base.kNumRepDistances) | |
state = Base.StateUpdateRep(state); | |
else | |
state = Base.StateUpdateMatch(state); | |
} | |
else | |
state = _optimum[posPrev].State; | |
state = Base.StateUpdateChar(state); | |
} | |
else | |
state = _optimum[posPrev].State; | |
if (posPrev == cur - 1) | |
{ | |
if (_optimum[cur].IsShortRep()) | |
state = Base.StateUpdateShortRep(state); | |
else | |
state = Base.StateUpdateChar(state); | |
} | |
else | |
{ | |
int pos; | |
if (_optimum[cur].Prev1IsChar && _optimum[cur].Prev2) | |
{ | |
posPrev = _optimum[cur].PosPrev2; | |
pos = _optimum[cur].BackPrev2; | |
state = Base.StateUpdateRep(state); | |
} | |
else | |
{ | |
pos = _optimum[cur].BackPrev; | |
if (pos < Base.kNumRepDistances) | |
state = Base.StateUpdateRep(state); | |
else | |
state = Base.StateUpdateMatch(state); | |
} | |
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]; | |
int curPrice = _optimum[cur].Price; | |
currentByte = _matchFinder.GetIndexByte(0 - 1); | |
matchByte = _matchFinder.GetIndexByte(0 - reps[0] - 1 - 1); | |
posState = (position & _posStateMask); | |
int curAnd1Price = curPrice + | |
SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state << Base.kNumPosStatesBitsMax) + posState]) + | |
_literalEncoder.GetSubCoder(position, _matchFinder.GetIndexByte(0 - 2)). | |
GetPrice(!Base.StateIsCharState(state), matchByte, currentByte); | |
Optimal nextOptimum = _optimum[cur + 1]; | |
boolean nextIsChar = false; | |
if (curAnd1Price < nextOptimum.Price) | |
{ | |
nextOptimum.Price = curAnd1Price; | |
nextOptimum.PosPrev = cur; | |
nextOptimum.MakeAsChar(); | |
nextIsChar = true; | |
} | |
matchPrice = curPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state << Base.kNumPosStatesBitsMax) + posState]); | |
repMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state]); | |
if (matchByte == currentByte && | |
!(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0)) | |
{ | |
int shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState); | |
if (shortRepPrice <= nextOptimum.Price) | |
{ | |
nextOptimum.Price = shortRepPrice; | |
nextOptimum.PosPrev = cur; | |
nextOptimum.MakeAsShortRep(); | |
nextIsChar = true; | |
} | |
} | |
int 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 | |
int t = Math.min(numAvailableBytesFull - 1, _numFastBytes); | |
int lenTest2 = _matchFinder.GetMatchLen(0, reps[0], t); | |
if (lenTest2 >= 2) | |
{ | |
int state2 = Base.StateUpdateChar(state); | |
int posStateNext = (position + 1) & _posStateMask; | |
int nextRepMatchPrice = curAnd1Price + | |
SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) + | |
SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]); | |
{ | |
int offset = cur + 1 + lenTest2; | |
while (lenEnd < offset) | |
_optimum[++lenEnd].Price = kIfinityPrice; | |
int 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; | |
} | |
} | |
} | |
} | |
int startLen = 2; // speed optimization | |
for (int repIndex = 0; repIndex < Base.kNumRepDistances; repIndex++) | |
{ | |
int lenTest = _matchFinder.GetMatchLen(0 - 1, reps[repIndex], numAvailableBytes); | |
if (lenTest < 2) | |
continue; | |
int lenTestTemp = lenTest; | |
do | |
{ | |
while (lenEnd < cur + lenTest) | |
_optimum[++lenEnd].Price = kIfinityPrice; | |
int 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) | |
{ | |
int t = Math.min(numAvailableBytesFull - 1 - lenTest, _numFastBytes); | |
int lenTest2 = _matchFinder.GetMatchLen(lenTest, reps[repIndex], t); | |
if (lenTest2 >= 2) | |
{ | |
int state2 = Base.StateUpdateRep(state); | |
int posStateNext = (position + lenTest) & _posStateMask; | |
int curAndLenCharPrice = | |
repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState) + | |
SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) + | |
_literalEncoder.GetSubCoder(position + lenTest, | |
_matchFinder.GetIndexByte(lenTest - 1 - 1)).GetPrice(true, | |
_matchFinder.GetIndexByte(lenTest - 1 - (reps[repIndex] + 1)), | |
_matchFinder.GetIndexByte(lenTest - 1)); | |
state2 = Base.StateUpdateChar(state2); | |
posStateNext = (position + lenTest + 1) & _posStateMask; | |
int nextMatchPrice = curAndLenCharPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]); | |
int nextRepMatchPrice = nextMatchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]); | |
// for(; lenTest2 >= 2; lenTest2--) | |
{ | |
int offset = lenTest + 1 + lenTest2; | |
while (lenEnd < cur + offset) | |
_optimum[++lenEnd].Price = kIfinityPrice; | |
int 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 + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep[state]); | |
while (lenEnd < cur + newLen) | |
_optimum[++lenEnd].Price = kIfinityPrice; | |
int offs = 0; | |
while (startLen > _matchDistances[offs]) | |
offs += 2; | |
for (int lenTest = startLen; ; lenTest++) | |
{ | |
int curBack = _matchDistances[offs + 1]; | |
int 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) | |
{ | |
int t = Math.min(numAvailableBytesFull - 1 - lenTest, _numFastBytes); | |
int lenTest2 = _matchFinder.GetMatchLen(lenTest, curBack, t); | |
if (lenTest2 >= 2) | |
{ | |
int state2 = Base.StateUpdateMatch(state); | |
int posStateNext = (position + lenTest) & _posStateMask; | |
int curAndLenCharPrice = curAndLenPrice + | |
SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) + | |
_literalEncoder.GetSubCoder(position + lenTest, | |
_matchFinder.GetIndexByte(lenTest - 1 - 1)). | |
GetPrice(true, | |
_matchFinder.GetIndexByte(lenTest - (curBack + 1) - 1), | |
_matchFinder.GetIndexByte(lenTest - 1)); | |
state2 = Base.StateUpdateChar(state2); | |
posStateNext = (position + lenTest + 1) & _posStateMask; | |
int nextMatchPrice = curAndLenCharPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]); | |
int nextRepMatchPrice = nextMatchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]); | |
int 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; | |
} | |
} | |
} | |
} | |
} | |
boolean ChangePair(int smallDist, int bigDist) | |
{ | |
int kDif = 7; | |
return (smallDist < (1 << (32 - kDif)) && bigDist >= (smallDist << kDif)); | |
} | |
void WriteEndMarker(int posState) throws IOException | |
{ | |
if (!_writeEndMark) | |
return; | |
_rangeEncoder.Encode(_isMatch, (_state << Base.kNumPosStatesBitsMax) + posState, 1); | |
_rangeEncoder.Encode(_isRep, _state, 0); | |
_state = Base.StateUpdateMatch(_state); | |
int len = Base.kMatchMinLen; | |
_lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState); | |
int posSlot = (1 << Base.kNumPosSlotBits) - 1; | |
int lenToPosState = Base.GetLenToPosState(len); | |
_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot); | |
int footerBits = 30; | |
int posReduced = (1 << footerBits) - 1; | |
_rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits); | |
_posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask); | |
} | |
void Flush(int nowPos) throws IOException | |
{ | |
ReleaseMFStream(); | |
WriteEndMarker(nowPos & _posStateMask); | |
_rangeEncoder.FlushData(); | |
_rangeEncoder.FlushStream(); | |
} | |
public void CodeOneBlock(long[] inSize, long[] outSize, boolean[] finished) throws IOException | |
{ | |
inSize[0] = 0; | |
outSize[0] = 0; | |
finished[0] = true; | |
if (_inStream != null) | |
{ | |
_matchFinder.SetStream(_inStream); | |
_matchFinder.Init(); | |
_needReleaseMFStream = true; | |
_inStream = null; | |
} | |
if (_finished) | |
return; | |
_finished = true; | |
long progressPosValuePrev = nowPos64; | |
if (nowPos64 == 0) | |
{ | |
if (_matchFinder.GetNumAvailableBytes() == 0) | |
{ | |
Flush((int)nowPos64); | |
return; | |
} | |
ReadMatchDistances(); | |
int posState = (int)(nowPos64) & _posStateMask; | |
_rangeEncoder.Encode(_isMatch, (_state << Base.kNumPosStatesBitsMax) + posState, 0); | |
_state = Base.StateUpdateChar(_state); | |
byte curByte = _matchFinder.GetIndexByte(0 - _additionalOffset); | |
_literalEncoder.GetSubCoder((int)(nowPos64), _previousByte).Encode(_rangeEncoder, curByte); | |
_previousByte = curByte; | |
_additionalOffset--; | |
nowPos64++; | |
} | |
if (_matchFinder.GetNumAvailableBytes() == 0) | |
{ | |
Flush((int)nowPos64); | |
return; | |
} | |
while (true) | |
{ | |
int len = GetOptimum((int)nowPos64); | |
int pos = backRes; | |
int posState = ((int)nowPos64) & _posStateMask; | |
int complexState = (_state << Base.kNumPosStatesBitsMax) + posState; | |
if (len == 1 && pos == -1) | |
{ | |
_rangeEncoder.Encode(_isMatch, complexState, 0); | |
byte curByte = _matchFinder.GetIndexByte((int)(0 - _additionalOffset)); | |
LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((int)nowPos64, _previousByte); | |
if (!Base.StateIsCharState(_state)) | |
{ | |
byte matchByte = _matchFinder.GetIndexByte((int)(0 - _repDistances[0] - 1 - _additionalOffset)); | |
subCoder.EncodeMatched(_rangeEncoder, matchByte, curByte); | |
} | |
else | |
subCoder.Encode(_rangeEncoder, curByte); | |
_previousByte = curByte; | |
_state = Base.StateUpdateChar(_state); | |
} | |
else | |
{ | |
_rangeEncoder.Encode(_isMatch, complexState, 1); | |
if (pos < Base.kNumRepDistances) | |
{ | |
_rangeEncoder.Encode(_isRep, _state, 1); | |
if (pos == 0) | |
{ | |
_rangeEncoder.Encode(_isRepG0, _state, 0); | |
if (len == 1) | |
_rangeEncoder.Encode(_isRep0Long, complexState, 0); | |
else | |
_rangeEncoder.Encode(_isRep0Long, complexState, 1); | |
} | |
else | |
{ | |
_rangeEncoder.Encode(_isRepG0, _state, 1); | |
if (pos == 1) | |
_rangeEncoder.Encode(_isRepG1, _state, 0); | |
else | |
{ | |
_rangeEncoder.Encode(_isRepG1, _state, 1); | |
_rangeEncoder.Encode(_isRepG2, _state, pos - 2); | |
} | |
} | |
if (len == 1) | |
_state = Base.StateUpdateShortRep(_state); | |
else | |
{ | |
_repMatchLenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState); | |
_state = Base.StateUpdateRep(_state); | |
} | |
int distance = _repDistances[pos]; | |
if (pos != 0) | |
{ | |
for (int i = pos; i >= 1; i--) | |
_repDistances[i] = _repDistances[i - 1]; | |
_repDistances[0] = distance; | |
} | |
} | |
else | |
{ | |
_rangeEncoder.Encode(_isRep, _state, 0); | |
_state = Base.StateUpdateMatch(_state); | |
_lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState); | |
pos -= Base.kNumRepDistances; | |
int posSlot = GetPosSlot(pos); | |
int lenToPosState = Base.GetLenToPosState(len); | |
_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot); | |
if (posSlot >= Base.kStartPosModelIndex) | |
{ | |
int footerBits = (int)((posSlot >> 1) - 1); | |
int baseVal = ((2 | (posSlot & 1)) << footerBits); | |
int posReduced = pos - baseVal; | |
if (posSlot < Base.kEndPosModelIndex) | |
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++; | |
} | |
} | |
int distance = pos; | |
for (int i = Base.kNumRepDistances - 1; i >= 1; i--) | |
_repDistances[i] = _repDistances[i - 1]; | |
_repDistances[0] = distance; | |
_matchPriceCount++; | |
} | |
_previousByte = _matchFinder.GetIndexByte(len - 1 - _additionalOffset); | |
} | |
_additionalOffset -= len; | |
nowPos64 += len; | |
if (_additionalOffset == 0) | |
{ | |
// if (!_fastMode) | |
if (_matchPriceCount >= (1 << 7)) | |
FillDistancesPrices(); | |
if (_alignPriceCount >= Base.kAlignTableSize) | |
FillAlignPrices(); | |
inSize[0] = nowPos64; | |
outSize[0] = _rangeEncoder.GetProcessedSizeAdd(); | |
if (_matchFinder.GetNumAvailableBytes() == 0) | |
{ | |
Flush((int)nowPos64); | |
return; | |
} | |
if (nowPos64 - progressPosValuePrev >= (1 << 12)) | |
{ | |
_finished = false; | |
finished[0] = false; | |
return; | |
} | |
} | |
} | |
} | |
void ReleaseMFStream() | |
{ | |
if (_matchFinder != null && _needReleaseMFStream) | |
{ | |
_matchFinder.ReleaseStream(); | |
_needReleaseMFStream = false; | |
} | |
} | |
void SetOutStream(java.io.OutputStream outStream) | |
{ _rangeEncoder.SetStream(outStream); } | |
void ReleaseOutStream() | |
{ _rangeEncoder.ReleaseStream(); } | |
void ReleaseStreams() | |
{ | |
ReleaseMFStream(); | |
ReleaseOutStream(); | |
} | |
void SetStreams(java.io.InputStream inStream, java.io.OutputStream outStream, | |
long inSize, long outSize) | |
{ | |
_inStream = inStream; | |
_finished = false; | |
Create(); | |
SetOutStream(outStream); | |
Init(); | |
// if (!_fastMode) | |
{ | |
FillDistancesPrices(); | |
FillAlignPrices(); | |
} | |
_lenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen); | |
_lenEncoder.UpdateTables(1 << _posStateBits); | |
_repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen); | |
_repMatchLenEncoder.UpdateTables(1 << _posStateBits); | |
nowPos64 = 0; | |
} | |
long[] processedInSize = new long[1]; long[] processedOutSize = new long[1]; boolean[] finished = new boolean[1]; | |
public void Code(java.io.InputStream inStream, java.io.OutputStream outStream, | |
long inSize, long outSize, ICodeProgress progress) throws IOException | |
{ | |
_needReleaseMFStream = false; | |
try | |
{ | |
SetStreams(inStream, outStream, inSize, outSize); | |
while (true) | |
{ | |
CodeOneBlock(processedInSize, processedOutSize, finished); | |
if (finished[0]) | |
return; | |
if (progress != null) | |
{ | |
progress.SetProgress(processedInSize[0], processedOutSize[0]); | |
} | |
} | |
} | |
finally | |
{ | |
ReleaseStreams(); | |
} | |
} | |
public static final int kPropSize = 5; | |
byte[] properties = new byte[kPropSize]; | |
public void WriteCoderProperties(java.io.OutputStream outStream) throws IOException | |
{ | |
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); | |
} | |
int[] tempPrices = new int[Base.kNumFullDistances]; | |
int _matchPriceCount; | |
void FillDistancesPrices() | |
{ | |
for (int i = Base.kStartPosModelIndex; i < Base.kNumFullDistances; i++) | |
{ | |
int posSlot = GetPosSlot(i); | |
int footerBits = (int)((posSlot >> 1) - 1); | |
int baseVal = ((2 | (posSlot & 1)) << footerBits); | |
tempPrices[i] = BitTreeEncoder.ReverseGetPrice(_posEncoders, | |
baseVal - posSlot - 1, footerBits, i - baseVal); | |
} | |
for (int lenToPosState = 0; lenToPosState < Base.kNumLenToPosStates; lenToPosState++) | |
{ | |
int posSlot; | |
BitTreeEncoder encoder = _posSlotEncoder[lenToPosState]; | |
int 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) << SevenZip.Compression.RangeCoder.Encoder.kNumBitPriceShiftBits); | |
int st2 = lenToPosState * Base.kNumFullDistances; | |
int 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 (int i = 0; i < Base.kAlignTableSize; i++) | |
_alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i); | |
_alignPriceCount = 0; | |
} | |
public boolean SetAlgorithm(int algorithm) | |
{ | |
/* | |
_fastMode = (algorithm == 0); | |
_maxMode = (algorithm >= 2); | |
*/ | |
return true; | |
} | |
public boolean SetDictionarySize(int dictionarySize) | |
{ | |
int kDicLogSizeMaxCompress = 29; | |
if (dictionarySize < (1 << Base.kDicLogSizeMin) || dictionarySize > (1 << kDicLogSizeMaxCompress)) | |
return false; | |
_dictionarySize = dictionarySize; | |
int dicLogSize; | |
for (dicLogSize = 0; dictionarySize > (1 << dicLogSize); dicLogSize++) ; | |
_distTableSize = dicLogSize * 2; | |
return true; | |
} | |
public boolean SetNumFastBytes(int numFastBytes) | |
{ | |
if (numFastBytes < 5 || numFastBytes > Base.kMatchMaxLen) | |
return false; | |
_numFastBytes = numFastBytes; | |
return true; | |
} | |
public boolean SetMatchFinder(int matchFinderIndex) | |
{ | |
if (matchFinderIndex < 0 || matchFinderIndex > 2) | |
return false; | |
int matchFinderIndexPrev = _matchFinderType; | |
_matchFinderType = matchFinderIndex; | |
if (_matchFinder != null && matchFinderIndexPrev != _matchFinderType) | |
{ | |
_dictionarySizePrev = -1; | |
_matchFinder = null; | |
} | |
return true; | |
} | |
public boolean SetLcLpPb(int lc, int lp, int pb) | |
{ | |
if ( | |
lp < 0 || lp > Base.kNumLitPosStatesBitsEncodingMax || | |
lc < 0 || lc > Base.kNumLitContextBitsMax || | |
pb < 0 || pb > Base.kNumPosStatesBitsEncodingMax) | |
return false; | |
_numLiteralPosStateBits = lp; | |
_numLiteralContextBits = lc; | |
_posStateBits = pb; | |
_posStateMask = ((1) << _posStateBits) - 1; | |
return true; | |
} | |
public void SetEndMarkerMode(boolean endMarkerMode) | |
{ | |
_writeEndMark = endMarkerMode; | |
} | |
} | |