package SevenZip.Compression.LZMA;

import SevenZip.Compression.RangeCoder.BitTreeDecoder;

import SevenZip.Compression.LZMA.Base;

import SevenZip.Compression.LZ.OutWindow;

import java.io.IOException;

public class Decoder

{

class LenDecoder

{

short[] m_Choice = new short[2];

BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];

BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];

BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);

int m_NumPosStates = 0;

public void Create(int numPosStates)

{

for (; m_NumPosStates < numPosStates; m_NumPosStates++)

{

m_LowCoder[m_NumPosStates] = new BitTreeDecoder(Base.kNumLowLenBits);

m_MidCoder[m_NumPosStates] = new BitTreeDecoder(Base.kNumMidLenBits);

}

}

public void Init()

{

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_Choice);

for (int posState = 0; posState < m_NumPosStates; posState++)

{

m_LowCoder[posState].Init();

m_MidCoder[posState].Init();

}

m_HighCoder.Init();

}

public int Decode(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, int posState) throws IOException

{

if (rangeDecoder.DecodeBit(m_Choice, 0) == 0)

return m_LowCoder[posState].Decode(rangeDecoder);

int symbol = Base.kNumLowLenSymbols;

if (rangeDecoder.DecodeBit(m_Choice, 1) == 0)

symbol += m_MidCoder[posState].Decode(rangeDecoder);

else

symbol += Base.kNumMidLenSymbols + m_HighCoder.Decode(rangeDecoder);

return symbol;

}

}

class LiteralDecoder

{

class Decoder2

{

short[] m_Decoders = new short[0x300];

public void Init()

{

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_Decoders);

}

public byte DecodeNormal(SevenZip.Compression.RangeCoder.Decoder rangeDecoder) throws IOException

{

int symbol = 1;

do

symbol = (symbol << 1) | rangeDecoder.DecodeBit(m_Decoders, symbol);

while (symbol < 0x100);

return (byte)symbol;

}

public byte DecodeWithMatchByte(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, byte matchByte) throws IOException

{

int symbol = 1;

do

{

int matchBit = (matchByte >> 7) & 1;

matchByte <<= 1;

int bit = rangeDecoder.DecodeBit(m_Decoders, ((1 + matchBit) << 8) + symbol);

symbol = (symbol << 1) | bit;

if (matchBit != bit)

{

while (symbol < 0x100)

symbol = (symbol << 1) | rangeDecoder.DecodeBit(m_Decoders, symbol);

break;

}

}

while (symbol < 0x100);

return (byte)symbol;

}

}

Decoder2[] 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 Decoder2[numStates];

for (int i = 0; i < numStates; i++)

m_Coders[i] = new Decoder2();

}

public void Init()

{

int numStates = 1 << (m_NumPrevBits + m_NumPosBits);

for (int i = 0; i < numStates; i++)

m_Coders[i].Init();

}

Decoder2 GetDecoder(int pos, byte prevByte)

{

return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + ((prevByte & 0xFF) >>> (8 - m_NumPrevBits))];

}

}

OutWindow m_OutWindow = new OutWindow();

SevenZip.Compression.RangeCoder.Decoder m_RangeDecoder = new SevenZip.Compression.RangeCoder.Decoder();

short[] m_IsMatchDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];

short[] m_IsRepDecoders = new short[Base.kNumStates];

short[] m_IsRepG0Decoders = new short[Base.kNumStates];

short[] m_IsRepG1Decoders = new short[Base.kNumStates];

short[] m_IsRepG2Decoders = new short[Base.kNumStates];

short[] m_IsRep0LongDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];

BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];

short[] m_PosDecoders = new short[Base.kNumFullDistances - Base.kEndPosModelIndex];

BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);

LenDecoder m_LenDecoder = new LenDecoder();

LenDecoder m_RepLenDecoder = new LenDecoder();

LiteralDecoder m_LiteralDecoder = new LiteralDecoder();

int m_DictionarySize = -1;

int m_DictionarySizeCheck = -1;

int m_PosStateMask;

public Decoder()

{

for (int i = 0; i < Base.kNumLenToPosStates; i++)

m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);

}

boolean SetDictionarySize(int dictionarySize)

{

if (dictionarySize < 0)

return false;

if (m_DictionarySize != dictionarySize)

{

m_DictionarySize = dictionarySize;

m_DictionarySizeCheck = Math.max(m_DictionarySize, 1);

m_OutWindow.Create(Math.max(m_DictionarySizeCheck, (1 << 12)));

}

return true;

}

boolean SetLcLpPb(int lc, int lp, int pb)

{

if (lc > Base.kNumLitContextBitsMax || lp > 4 || pb > Base.kNumPosStatesBitsMax)

return false;

m_LiteralDecoder.Create(lp, lc);

int numPosStates = 1 << pb;

m_LenDecoder.Create(numPosStates);

m_RepLenDecoder.Create(numPosStates);

m_PosStateMask = numPosStates - 1;

return true;

}

void Init() throws IOException

{

m_OutWindow.Init(false);

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsMatchDecoders);

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRep0LongDecoders);

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepDecoders);

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG0Decoders);

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG1Decoders);

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG2Decoders);

SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_PosDecoders);

m_LiteralDecoder.Init();

int i;

for (i = 0; i < Base.kNumLenToPosStates; i++)

m_PosSlotDecoder[i].Init();

m_LenDecoder.Init();

m_RepLenDecoder.Init();

m_PosAlignDecoder.Init();

m_RangeDecoder.Init();

}

public boolean Code(java.io.InputStream inStream, java.io.OutputStream outStream,

long outSize) throws IOException

{

m_RangeDecoder.SetStream(inStream);

m_OutWindow.SetStream(outStream);

Init();

int state = Base.StateInit();

int rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;

long nowPos64 = 0;

byte prevByte = 0;

while (outSize < 0 || nowPos64 < outSize)

{

int posState = (int)nowPos64 & m_PosStateMask;

if (m_RangeDecoder.DecodeBit(m_IsMatchDecoders, (state << Base.kNumPosStatesBitsMax) + posState) == 0)

{

LiteralDecoder.Decoder2 decoder2 = m_LiteralDecoder.GetDecoder((int)nowPos64, prevByte);

if (!Base.StateIsCharState(state))

prevByte = decoder2.DecodeWithMatchByte(m_RangeDecoder, m_OutWindow.GetByte(rep0));

else

prevByte = decoder2.DecodeNormal(m_RangeDecoder);

m_OutWindow.PutByte(prevByte);

state = Base.StateUpdateChar(state);

nowPos64++;

}

else

{

int len;

if (m_RangeDecoder.DecodeBit(m_IsRepDecoders, state) == 1)

{

len = 0;

if (m_RangeDecoder.DecodeBit(m_IsRepG0Decoders, state) == 0)

{

if (m_RangeDecoder.DecodeBit(m_IsRep0LongDecoders, (state << Base.kNumPosStatesBitsMax) + posState) == 0)

{

state = Base.StateUpdateShortRep(state);

len = 1;

}

}

else

{

int distance;

if (m_RangeDecoder.DecodeBit(m_IsRepG1Decoders, state) == 0)

distance = rep1;

else

{

if (m_RangeDecoder.DecodeBit(m_IsRepG2Decoders, state) == 0)

distance = rep2;

else

{

distance = rep3;

rep3 = rep2;

}

rep2 = rep1;

}

rep1 = rep0;

rep0 = distance;

}

if (len == 0)

{

len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;

state = Base.StateUpdateRep(state);

}

}

else

{

rep3 = rep2;

rep2 = rep1;

rep1 = rep0;

len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);

state = Base.StateUpdateMatch(state);

int posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);

if (posSlot >= Base.kStartPosModelIndex)

{

int numDirectBits = (posSlot >> 1) - 1;

rep0 = ((2 | (posSlot & 1)) << numDirectBits);

if (posSlot < Base.kEndPosModelIndex)

rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,

rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);

else

{

rep0 += (m_RangeDecoder.DecodeDirectBits(

numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);

rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);

if (rep0 < 0)

{

if (rep0 == -1)

break;

return false;

}

}

}

else

rep0 = posSlot;

}

if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck)

{

// m_OutWindow.Flush();

return false;

}

m_OutWindow.CopyBlock(rep0, len);

nowPos64 += len;

prevByte = m_OutWindow.GetByte(0);

}

}

m_OutWindow.Flush();

m_OutWindow.ReleaseStream();

m_RangeDecoder.ReleaseStream();

return true;

}

public boolean SetDecoderProperties(byte[] properties)

{

if (properties.length < 5)

return false;

int val = properties[0] & 0xFF;

int lc = val % 9;

int remainder = val / 9;

int lp = remainder % 5;

int pb = remainder / 5;

int dictionarySize = 0;

for (int i = 0; i < 4; i++)

dictionarySize += ((int)(properties[1 + i]) & 0xFF) << (i * 8);

if (!SetLcLpPb(lc, lp, pb))

return false;

return SetDictionarySize(dictionarySize);

}

}