// LzmaDecoder.cs

using System;

namespace SevenZip.Compression.LZMA

{

using RangeCoder;

public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream

{

class LenDecoder

{

BitDecoder m_Choice = new BitDecoder();

BitDecoder m_Choice2 = new BitDecoder();

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

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

BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);

uint m_NumPosStates = 0;

public void Create(uint numPosStates)

{

for (uint posState = m_NumPosStates; posState < numPosStates; posState++)

{

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

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

}

m_NumPosStates = numPosStates;

}

public void Init()

{

m_Choice.Init();

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

{

m_LowCoder[posState].Init();

m_MidCoder[posState].Init();

}

m_Choice2.Init();

m_HighCoder.Init();

}

public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)

{

if (m_Choice.Decode(rangeDecoder) == 0)

return m_LowCoder[posState].Decode(rangeDecoder);

else

{

uint symbol = Base.kNumLowLenSymbols;

if (m_Choice2.Decode(rangeDecoder) == 0)

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

else

{

symbol += Base.kNumMidLenSymbols;

symbol += m_HighCoder.Decode(rangeDecoder);

}

return symbol;

}

}

}

class LiteralDecoder

{

struct Decoder2

{

BitDecoder[] m_Decoders;

public void Create() { m_Decoders = new BitDecoder[0x300]; }

public void Init() { for (int i = 0; i < 0x300; i++) m_Decoders[i].Init(); }

public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)

{

uint symbol = 1;

do

symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);

while (symbol < 0x100);

return (byte)symbol;

}

public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)

{

uint symbol = 1;

do

{

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

matchByte <<= 1;

uint bit = m_Decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);

symbol = (symbol << 1) | bit;

if (matchBit != bit)

{

while (symbol < 0x100)

symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);

break;

}

}

while (symbol < 0x100);

return (byte)symbol;

}

}

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

}

uint GetState(uint pos, byte prevByte)

{ return ((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits)); }

public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)

{ return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }

public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)

{ return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }

};

LZ.OutWindow m_OutWindow = new LZ.OutWindow();

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

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

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

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

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

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

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

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

BitDecoder[] m_PosDecoders = new BitDecoder[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();

uint m_DictionarySize;

uint m_DictionarySizeCheck;

uint m_PosStateMask;

public Decoder()

{

m_DictionarySize = 0xFFFFFFFF;

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

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

}

void SetDictionarySize(uint dictionarySize)

{

if (m_DictionarySize != dictionarySize)

{

m_DictionarySize = dictionarySize;

m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1);

uint blockSize = Math.Max(m_DictionarySizeCheck, (1 << 12));

m_OutWindow.Create(blockSize);

}

}

void SetLiteralProperties(int lp, int lc)

{

if (lp > 8)

throw new InvalidParamException();

if (lc > 8)

throw new InvalidParamException();

m_LiteralDecoder.Create(lp, lc);

}

void SetPosBitsProperties(int pb)

{

if (pb > Base.kNumPosStatesBitsMax)

throw new InvalidParamException();

uint numPosStates = (uint)1 << pb;

m_LenDecoder.Create(numPosStates);

m_RepLenDecoder.Create(numPosStates);

m_PosStateMask = numPosStates - 1;

}

bool _solid = false;

void Init(System.IO.Stream inStream, System.IO.Stream outStream)

{

m_RangeDecoder.Init(inStream);

m_OutWindow.Init(outStream, _solid);

uint i;

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

{

for (uint j = 0; j <= m_PosStateMask; j++)

{

uint index = (i << Base.kNumPosStatesBitsMax) + j;

m_IsMatchDecoders[index].Init();

m_IsRep0LongDecoders[index].Init();

}

m_IsRepDecoders[i].Init();

m_IsRepG0Decoders[i].Init();

m_IsRepG1Decoders[i].Init();

m_IsRepG2Decoders[i].Init();

}

m_LiteralDecoder.Init();

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

m_PosSlotDecoder[i].Init();

// m_PosSpecDecoder.Init();

for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)

m_PosDecoders[i].Init();

m_LenDecoder.Init();

m_RepLenDecoder.Init();

m_PosAlignDecoder.Init();

}

public void Code(System.IO.Stream inStream, System.IO.Stream outStream,

Int64 inSize, Int64 outSize, ICodeProgress progress)

{

Init(inStream, outStream);

Base.State state = new Base.State();

state.Init();

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

UInt64 nowPos64 = 0;

UInt64 outSize64 = (UInt64)outSize;

if (nowPos64 < outSize64)

{

if (m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)

throw new DataErrorException();

state.UpdateChar();

byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);

m_OutWindow.PutByte(b);

nowPos64++;

}

while (nowPos64 < outSize64)

{

// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);

// while(nowPos64 < next)

{

uint posState = (uint)nowPos64 & m_PosStateMask;

if (m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)

{

byte b;

byte prevByte = m_OutWindow.GetByte(0);

if (!state.IsCharState())

b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,

(uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));

else

b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);

m_OutWindow.PutByte(b);

state.UpdateChar();

nowPos64++;

}

else

{

uint len;

if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)

{

if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)

{

if (m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)

{

state.UpdateShortRep();

m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));

nowPos64++;

continue;

}

}

else

{

UInt32 distance;

if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)

{

distance = rep1;

}

else

{

if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)

distance = rep2;

else

{

distance = rep3;

rep3 = rep2;

}

rep2 = rep1;

}

rep1 = rep0;

rep0 = distance;

}

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

state.UpdateRep();

}

else

{

rep3 = rep2;

rep2 = rep1;

rep1 = rep0;

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

state.UpdateMatch();

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

if (posSlot >= Base.kStartPosModelIndex)

{

int numDirectBits = (int)((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);

}

}

else

rep0 = posSlot;

}

if (rep0 >= m_OutWindow.TrainSize + nowPos64 || rep0 >= m_DictionarySizeCheck)

{

if (rep0 == 0xFFFFFFFF)

break;

throw new DataErrorException();

}

m_OutWindow.CopyBlock(rep0, len);

nowPos64 += len;

}

}

}

m_OutWindow.Flush();

m_OutWindow.ReleaseStream();

m_RangeDecoder.ReleaseStream();

}

public void SetDecoderProperties(byte[] properties)

{

if (properties.Length < 5)

throw new InvalidParamException();

int lc = properties[0] % 9;

int remainder = properties[0] / 9;

int lp = remainder % 5;

int pb = remainder / 5;

if (pb > Base.kNumPosStatesBitsMax)

throw new InvalidParamException();

UInt32 dictionarySize = 0;

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

dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);

SetDictionarySize(dictionarySize);

SetLiteralProperties(lp, lc);

SetPosBitsProperties(pb);

}

public bool Train(System.IO.Stream stream)

{

_solid = true;

return m_OutWindow.Train(stream);

}

/*

public override bool CanRead { get { return true; }}

public override bool CanWrite { get { return true; }}

public override bool CanSeek { get { return true; }}

public override long Length { get { return 0; }}

public override long Position

{

get { return 0; }

set { }

}

public override void Flush() { }

public override int Read(byte[] buffer, int offset, int count)

{

return 0;

}

public override void Write(byte[] buffer, int offset, int count)

{

}

public override long Seek(long offset, System.IO.SeekOrigin origin)

{

return 0;

}

public override void SetLength(long value) {}

*/

}

}