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 Decoder()
{
m_DictionarySize = 0xFFFFFFFF;
for (int i = 0; i < Base.kNumLenToPosStates; i++)
m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
}
public void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress)
{
Init(inStream, outStream);
Base.State state = default(Base.State);
state.Init();
uint num = 0u;
uint num2 = 0u;
uint num3 = 0u;
uint num4 = 0u;
ulong num5 = 0uL;
if (num5 < (ulong)outSize)
{
if (m_IsMatchDecoders[state.Index << 4].Decode(m_RangeDecoder) != 0)
{
throw new DataErrorException();
}
state.UpdateChar();
byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0u, 0);
m_OutWindow.PutByte(b);
num5++;
}
while (num5 < (ulong)outSize)
{
uint num6 = (uint)((int)num5 & (int)m_PosStateMask);
if (m_IsMatchDecoders[(state.Index << 4) + num6].Decode(m_RangeDecoder) == 0)
{
byte @byte = m_OutWindow.GetByte(0u);
byte b2 = state.IsCharState()
? m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)num5, @byte)
: m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder, (uint)num5, @byte,
m_OutWindow.GetByte(num));
m_OutWindow.PutByte(b2);
state.UpdateChar();
num5++;
continue;
}
uint num8;
if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
{
if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
if (m_IsRep0LongDecoders[(state.Index << 4) + num6].Decode(m_RangeDecoder) == 0)
{
state.UpdateShortRep();
m_OutWindow.PutByte(m_OutWindow.GetByte(num));
num5++;
continue;
}
}
else
{
uint num7;
if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
num7 = num2;
}
else
{
if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
num7 = num3;
}
else
{
num7 = num4;
num4 = num3;
}
num3 = num2;
}
num2 = num;
num = num7;
}
num8 = m_RepLenDecoder.Decode(m_RangeDecoder, num6) + 2;
state.UpdateRep();
}
else
{
num4 = num3;
num3 = num2;
num2 = num;
num8 = 2 + m_LenDecoder.Decode(m_RangeDecoder, num6);
state.UpdateMatch();
uint num9 = m_PosSlotDecoder[Base.GetLenToPosState(num8)].Decode(m_RangeDecoder);
if (num9 >= 4)
{
int num10 = (int)((num9 >> 1) - 1);
num = (2 | (num9 & 1)) << num10;
if (num9 < 14)
{
num += BitTreeDecoder.ReverseDecode(m_PosDecoders, num - num9 - 1, m_RangeDecoder, num10);
}
else
{
num += m_RangeDecoder.DecodeDirectBits(num10 - 4) << 4;
num += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
}
}
else
{
num = num9;
}
}
if (num >= m_OutWindow.TrainSize + num5 || num >= m_DictionarySizeCheck)
{
if (num == uint.MaxValue)
{
break;
}
throw new DataErrorException();
}
m_OutWindow.CopyBlock(num, num8);
num5 += num8;
}
m_OutWindow.Flush();
m_OutWindow.ReleaseStream();
m_RangeDecoder.ReleaseStream();
}
public void Code(Stream inStream, Stream outStream,
long inSize, long outSize, ICodeProgress progress)
{
this.Init(inStream, outStream);
Base.State state = new Base.State();
state.Init();
uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
ulong nowPos64 = 0;
ulong outSize64 = (ulong)outSize;
if (nowPos64 < outSize64)
{
if (this.m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax].Decode(this.m_RangeDecoder) != 0)
{
throw new DataErrorException();
}
state.UpdateChar();
byte b = this.m_LiteralDecoder.DecodeNormal(this.m_RangeDecoder, 0, 0);
this.m_OutWindow.PutByte(b);
nowPos64++;
}
while (nowPos64 < outSize64)
{
// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
// while(nowPos64 < next)
{
uint posState = (uint)nowPos64 & this.m_PosStateMask;
if (this.m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(this.m_RangeDecoder) == 0)
{
byte b;
byte prevByte = this.m_OutWindow.GetByte(0);
if (!state.IsCharState())
{
b = this.m_LiteralDecoder.DecodeWithMatchByte(this.m_RangeDecoder,
(uint)nowPos64, prevByte, this.m_OutWindow.GetByte(rep0));
}
else
{
b = this.m_LiteralDecoder.DecodeNormal(this.m_RangeDecoder, (uint)nowPos64, prevByte);
}
this.m_OutWindow.PutByte(b);
state.UpdateChar();
nowPos64++;
}
else
{
uint len;
if (this.m_IsRepDecoders[state.Index].Decode(this.m_RangeDecoder) == 1)
{
if (this.m_IsRepG0Decoders[state.Index].Decode(this.m_RangeDecoder) == 0)
{
if (this.m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(this.m_RangeDecoder) == 0)
{
state.UpdateShortRep();
this.m_OutWindow.PutByte(this.m_OutWindow.GetByte(rep0));
nowPos64++;
continue;
}
}
else
{
uint distance;
if (this.m_IsRepG1Decoders[state.Index].Decode(this.m_RangeDecoder) == 0)
{
distance = rep1;
}
else
{
if (this.m_IsRepG2Decoders[state.Index].Decode(this.m_RangeDecoder) == 0)
{
distance = rep2;
}
else
{
distance = rep3;
rep3 = rep2;
}
rep2 = rep1;
}
rep1 = rep0;
rep0 = distance;
}
len = this.m_RepLenDecoder.Decode(this.m_RangeDecoder, posState) + Base.kMatchMinLen;
state.UpdateRep();
}
else
{
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
len = Base.kMatchMinLen + this.m_LenDecoder.Decode(this.m_RangeDecoder, posState);
state.UpdateMatch();
uint posSlot = this.m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(this.m_RangeDecoder);
if (posSlot >= Base.kStartPosModelIndex)
{
int numDirectBits = (int)((posSlot >> 1) - 1);
rep0 = (2 | (posSlot & 1)) << numDirectBits;
if (posSlot < Base.kEndPosModelIndex)
{
rep0 += BitTreeDecoder.ReverseDecode(this.m_PosDecoders,
rep0 - posSlot - 1, this.m_RangeDecoder, numDirectBits);
}
else
{
rep0 += this.m_RangeDecoder.DecodeDirectBits(
numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits;
rep0 += this.m_PosAlignDecoder.ReverseDecode(this.m_RangeDecoder);
}
}
else
{
rep0 = posSlot;
}
}
if (rep0 >= this.m_OutWindow.TrainSize + nowPos64 || rep0 >= this.m_DictionarySizeCheck)
{
if (rep0 == 0xFFFFFFFF)
{
break;
}
throw new DataErrorException();
}
this.m_OutWindow.CopyBlock(rep0, len);
nowPos64 += len;
}
}
}
this.m_OutWindow.Flush();
this.m_OutWindow.ReleaseStream();
this.m_RangeDecoder.ReleaseStream();
}
internal bool Code(int dictionarySize, OutWindow outWindow, Decoder rangeDecoder)
{
int num = Math.Max(dictionarySize, 1);
outWindow.CopyPending();
while (outWindow.HasSpace)
{
uint num5;
uint posState = ((uint)outWindow.Total) & this.m_PosStateMask;
if (this.m_IsMatchDecoders[(this.state.Index << 4) + posState].Decode(rangeDecoder) == 0)
{
byte @byte = outWindow.GetByte(0);
byte b = this.state.IsCharState() ? this.m_LiteralDecoder.DecodeNormal(rangeDecoder, (uint)outWindow.Total, @byte) : this.m_LiteralDecoder.DecodeWithMatchByte(rangeDecoder, (uint)outWindow.Total, @byte, outWindow.GetByte((int)this.rep0));
outWindow.PutByte(b);
this.state.UpdateChar();
continue;
}
if (this.m_IsRepDecoders[this.state.Index].Decode(rangeDecoder) != 1)
{
this.rep3 = this.rep2;
this.rep2 = this.rep1;
this.rep1 = this.rep0;
num5 = 2 + this.m_LenDecoder.Decode(rangeDecoder, posState);
this.state.UpdateMatch();
uint num7 = this.m_PosSlotDecoder[Base.GetLenToPosState(num5)].Decode(rangeDecoder);
if (num7 < 4)
{
this.rep0 = num7;
}
else
{
int numBitLevels = ((int)(num7 >> 1)) - 1;
this.rep0 = (uint)((2 | (num7 & 1)) << (numBitLevels & 0x1f));
if (num7 < 14)
{
this.rep0 += BitTreeDecoder.ReverseDecode(this.m_PosDecoders, (this.rep0 - num7) - 1, rangeDecoder, numBitLevels);
}
else
{
this.rep0 += rangeDecoder.DecodeDirectBits(numBitLevels - 4) << 4;
this.rep0 += this.m_PosAlignDecoder.ReverseDecode(rangeDecoder);
}
}
}
else
{
if (this.m_IsRepG0Decoders[this.state.Index].Decode(rangeDecoder) == 0)
{
if (this.m_IsRep0LongDecoders[(this.state.Index << 4) + posState].Decode(rangeDecoder) == 0)
{
this.state.UpdateShortRep();
outWindow.PutByte(outWindow.GetByte((int)this.rep0));
continue;
}
}
else
{
uint num6;
if (this.m_IsRepG1Decoders[this.state.Index].Decode(rangeDecoder) == 0)
{
num6 = this.rep1;
}
else
{
if (this.m_IsRepG2Decoders[this.state.Index].Decode(rangeDecoder) == 0)
{
num6 = this.rep2;
}
else
{
num6 = this.rep3;
this.rep3 = this.rep2;
}
this.rep2 = this.rep1;
}
this.rep1 = this.rep0;
this.rep0 = num6;
}
num5 = this.m_RepLenDecoder.Decode(rangeDecoder, posState) + 2;
this.state.UpdateRep();
}
if ((this.rep0 >= outWindow.Total) || (this.rep0 >= num))
{
if (this.rep0 != uint.MaxValue)
{
throw new DataErrorException();
}
return(true);
}
outWindow.CopyBlock((int)this.rep0, (int)num5);
}
return(false);
}
internal bool Code(int dictionarySize, OutWindow outWindow, RangeCoder.Decoder rangeDecoder)
{
int dictionarySizeCheck = Math.Max(dictionarySize, 1);
outWindow.CopyPending();
while (outWindow.HasSpace)
{
uint posState = (uint)outWindow.Total & m_PosStateMask;
if (m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(rangeDecoder) == 0)
{
byte b;
byte prevByte = outWindow.GetByte(0);
if (!state.IsCharState())
{
b = m_LiteralDecoder.DecodeWithMatchByte(rangeDecoder,
(uint)outWindow.Total, prevByte,
outWindow.GetByte((int)rep0));
}
else
{
b = m_LiteralDecoder.DecodeNormal(rangeDecoder, (uint)outWindow.Total, prevByte);
}
outWindow.PutByte(b);
state.UpdateChar();
}
else
{
uint len;
if (m_IsRepDecoders[state.Index].Decode(rangeDecoder) == 1)
{
if (m_IsRepG0Decoders[state.Index].Decode(rangeDecoder) == 0)
{
if (
m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(
rangeDecoder) == 0)
{
state.UpdateShortRep();
outWindow.PutByte(outWindow.GetByte((int)rep0));
continue;
}
}
else
{
UInt32 distance;
if (m_IsRepG1Decoders[state.Index].Decode(rangeDecoder) == 0)
{
distance = rep1;
}
else
{
if (m_IsRepG2Decoders[state.Index].Decode(rangeDecoder) == 0)
{
distance = rep2;
}
else
{
distance = rep3;
rep3 = rep2;
}
rep2 = rep1;
}
rep1 = rep0;
rep0 = distance;
}
len = m_RepLenDecoder.Decode(rangeDecoder, posState) + Base.kMatchMinLen;
state.UpdateRep();
}
else
{
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
len = Base.kMatchMinLen + m_LenDecoder.Decode(rangeDecoder, posState);
state.UpdateMatch();
uint posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(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, rangeDecoder, numDirectBits);
}
else
{
rep0 += (rangeDecoder.DecodeDirectBits(
numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);
rep0 += m_PosAlignDecoder.ReverseDecode(rangeDecoder);
}
}
else
{
rep0 = posSlot;
}
}
if (rep0 >= outWindow.Total || rep0 >= dictionarySizeCheck)
{
if (rep0 == 0xFFFFFFFF)
{
return(true);
}
throw new DataErrorException();
}
outWindow.CopyBlock((int)rep0, (int)len);
}
}
return(false);
}
internal void Decode(Stream InputStream, Stream OutputStream, uint UncompressedSize)
{
RangeDecoder.Initialize(InputStream);
Window.Initialize(OutputStream);
LengthDecoder.Initialize();
RepLengthDecoder.Initialize();
LiteralDecoder.Initialize();
for (uint Iterator = 0U; Iterator < 12U; Iterator++)
{
RepG2Decoders[Iterator].Prob = RepG1Decoders[Iterator].Prob = RepG0Decoders[Iterator].Prob = RepDecoders[Iterator].Prob = 1024U;
for (uint Iterator1 = 0U; Iterator1 <= PositionStateMask; Iterator1++)
{
uint Index = (Iterator << 4) + Iterator1;
Rep0LongDecoders[Index].Prob = MatchDecoders[Index].Prob = 1024U;
}
}
for (int Iterator = 0; Iterator < 114; Iterator++)
{
PositionDecoders[Iterator].Prob = 1024U;
}
PositionAlignDecoder.Initialize();
foreach (RangeBitTreeDecoder BitTreeDecoder in PositionSlotDecoder)
{
BitTreeDecoder.Initialize();
}
uint Rep0 = 0U, Rep1 = 0U, Rep2 = 0U, Rep3 = 0U;
State State = new State();
if (MatchDecoders[0].Decode(RangeDecoder) != 0U)
{
throw new ValidatorException("Failed to decompress chunk");
}
State.UpdateChar();
Window.PutByte(LiteralDecoder.Decode(RangeDecoder, 0U, 0));
for (uint Position = 1U; Position < UncompressedSize;)
{
uint PositionState = Position & PositionStateMask;
if (MatchDecoders[(State.Index << 4) + PositionState].Decode(RangeDecoder) == 0U)
{
byte PreviousByte = Window.GetByte(0U);
Window.PutByte(State.IsCharState ? LiteralDecoder.Decode(RangeDecoder, Position, PreviousByte) : LiteralDecoder.Decode(RangeDecoder, Position, PreviousByte, Window.GetByte(Rep0)));
State.UpdateChar();
Position++;
}
else
{
uint Length;
if (RepDecoders[State.Index].Decode(RangeDecoder) == 1U)
{
if (RepG0Decoders[State.Index].Decode(RangeDecoder) == 0U)
{
if (Rep0LongDecoders[(State.Index << 4) + PositionState].Decode(RangeDecoder) == 0U)
{
State.UpdateShortRep();
Window.PutByte(Window.GetByte(Rep0));
Position++;
continue;
}
}
else
{
uint Distance;
if (RepG1Decoders[State.Index].Decode(RangeDecoder) == 0U)
{
Distance = Rep1;
}
else
{
if (RepG2Decoders[State.Index].Decode(RangeDecoder) == 0U)
{
Distance = Rep2;
}
else
{
Distance = Rep3;
Rep3 = Rep2;
}
Rep2 = Rep1;
}
Rep1 = Rep0;
Rep0 = Distance;
}
Length = RepLengthDecoder.Decode(RangeDecoder, PositionState) + 2U;
State.UpdateRep();
}
else
{
Rep3 = Rep2;
Rep2 = Rep1;
Rep1 = Rep0;
Length = LengthDecoder.Decode(RangeDecoder, PositionState) + 2U;
State.UpdateMatch();
uint PositionSlot = PositionSlotDecoder[Length - 2U < 4U ? Length - 2U : 3U].Decode(RangeDecoder);
if (PositionSlot > 3U)
{
int DirectBitsCount = (int)((PositionSlot >> 1) - 1U);
Rep0 = (2U | (PositionSlot & 1U)) << DirectBitsCount;
Rep0 += (PositionSlot < 14U) ? RangeBitTreeDecoder.ReverseDecode(PositionDecoders, Rep0 - PositionSlot - 1U, DirectBitsCount, RangeDecoder) : ((RangeDecoder.Decode(DirectBitsCount - 4) << 4) + PositionAlignDecoder.ReverseDecode(RangeDecoder));
}
else
{
Rep0 = PositionSlot;
}
}
if (Rep0 >= Position || Rep0 >= DictionarySizeCheck)
{
if (Rep0 == uint.MaxValue)
{
break;
}
else
{
throw new ValidatorException("Failed to decompress chunk");
}
}
Window.CopyBlock(Rep0, Length);
Position += Length;
}
}
Window.Flush();
}
public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
Int64 inSize, Int64 outSize)
{
Init(inStream, outStream);
State state = new 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 << kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)
{
throw new Exception();
}
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 << 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 << 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) + kMatchMinLen;
state.UpdateRep();
}
else
{
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
len = kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
state.UpdateMatch();
uint posSlot = m_PosSlotDecoder[GetLenToPosState(len)].Decode(m_RangeDecoder);
if (posSlot >= kStartPosModelIndex)
{
int numDirectBits = (int)((posSlot >> 1) - 1);
rep0 = ((2 | (posSlot & 1)) << numDirectBits);
if (posSlot < kEndPosModelIndex)
{
rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
}
else
{
rep0 += (m_RangeDecoder.DecodeDirectBits(
numDirectBits - kNumAlignBits) << kNumAlignBits);
rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
}
}
else
{
rep0 = posSlot;
}
}
if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck)
{
if (rep0 == 0xFFFFFFFF)
{
break;
}
}
m_OutWindow.CopyBlock(rep0, len);
nowPos64 += len;
}
}
}
m_OutWindow.Flush();
m_OutWindow.ReleaseStream();
m_RangeDecoder.ReleaseStream();
}
public void Code(
Stream inStream,
Stream outStream,
long inSize,
long outSize,
ICodeProgress progress)
{
this.Init(inStream, outStream);
Base.State state = new Base.State();
state.Init();
uint distance = 0;
uint num1 = 0;
uint num2 = 0;
uint num3 = 0;
ulong num4 = 0;
ulong num5 = (ulong)outSize;
if (num4 < num5)
{
if (this.m_IsMatchDecoders[(int)state.Index << 4].Decode(this.m_RangeDecoder) != 0U)
{
throw new DataErrorException();
}
state.UpdateChar();
this.m_OutWindow.PutByte(this.m_LiteralDecoder.DecodeNormal(this.m_RangeDecoder, 0U, (byte)0));
++num4;
}
while (num4 < num5)
{
uint posState = (uint)num4 & this.m_PosStateMask;
if (this.m_IsMatchDecoders[((int)state.Index << 4) + (int)posState].Decode(this.m_RangeDecoder) == 0U)
{
byte prevByte = this.m_OutWindow.GetByte(0U);
this.m_OutWindow.PutByte(state.IsCharState() ? this.m_LiteralDecoder.DecodeNormal(this.m_RangeDecoder, (uint)num4, prevByte) : this.m_LiteralDecoder.DecodeWithMatchByte(this.m_RangeDecoder, (uint)num4, prevByte, this.m_OutWindow.GetByte(distance)));
state.UpdateChar();
++num4;
}
else
{
uint len;
if (this.m_IsRepDecoders[(int)state.Index].Decode(this.m_RangeDecoder) == 1U)
{
if (this.m_IsRepG0Decoders[(int)state.Index].Decode(this.m_RangeDecoder) == 0U)
{
if (this.m_IsRep0LongDecoders[((int)state.Index << 4) + (int)posState].Decode(this.m_RangeDecoder) == 0U)
{
state.UpdateShortRep();
this.m_OutWindow.PutByte(this.m_OutWindow.GetByte(distance));
++num4;
continue;
}
}
else
{
uint num6;
if (this.m_IsRepG1Decoders[(int)state.Index].Decode(this.m_RangeDecoder) == 0U)
{
num6 = num1;
}
else
{
if (this.m_IsRepG2Decoders[(int)state.Index].Decode(this.m_RangeDecoder) == 0U)
{
num6 = num2;
}
else
{
num6 = num3;
num3 = num2;
}
num2 = num1;
}
num1 = distance;
distance = num6;
}
len = this.m_RepLenDecoder.Decode(this.m_RangeDecoder, posState) + 2U;
state.UpdateRep();
}
else
{
num3 = num2;
num2 = num1;
num1 = distance;
len = 2U + this.m_LenDecoder.Decode(this.m_RangeDecoder, posState);
state.UpdateMatch();
uint num6 = this.m_PosSlotDecoder[(int)Base.GetLenToPosState(len)].Decode(this.m_RangeDecoder);
if (num6 >= 4U)
{
int NumBitLevels = (int)(num6 >> 1) - 1;
uint num7 = (uint)((2 | (int)num6 & 1) << NumBitLevels);
distance = num6 >= 14U ? num7 + (this.m_RangeDecoder.DecodeDirectBits(NumBitLevels - 4) << 4) + this.m_PosAlignDecoder.ReverseDecode(this.m_RangeDecoder) : num7 + BitTreeDecoder.ReverseDecode(this.m_PosDecoders, (uint)((int)num7 - (int)num6 - 1), this.m_RangeDecoder, NumBitLevels);
}
else
{
distance = num6;
}
}
if ((ulong)distance >= (ulong)this.m_OutWindow.TrainSize + num4 || distance >= this.m_DictionarySizeCheck)
{
if (distance != uint.MaxValue)
{
throw new DataErrorException();
}
break;
}
this.m_OutWindow.CopyBlock(distance, len);
num4 += (ulong)len;
}
}
this.m_OutWindow.Flush();
this.m_OutWindow.ReleaseStream();
this.m_RangeDecoder.ReleaseStream();
}
internal bool Code(int dictionarySize, OutWindow outWindow, RangeCoder.Decoder rangeDecoder)
{
int dictionarySizeCheck = Math.Max(dictionarySize, 1);
outWindow.CopyPending();
while (outWindow.HasSpace)
{
uint posState = (uint)outWindow._total & _posStateMask;
if (_isMatchDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].Decode(rangeDecoder) == 0)
{
byte b;
byte prevByte = outWindow.GetByte(0);
if (!_state.IsCharState())
{
b = _literalDecoder.DecodeWithMatchByte(rangeDecoder,
(uint)outWindow._total, prevByte,
outWindow.GetByte((int)_rep0));
}
else
{
b = _literalDecoder.DecodeNormal(rangeDecoder, (uint)outWindow._total, prevByte);
}
outWindow.PutByte(b);
_state.UpdateChar();
}
else
{
uint len;
if (_isRepDecoders[_state._index].Decode(rangeDecoder) == 1)
{
if (_isRepG0Decoders[_state._index].Decode(rangeDecoder) == 0)
{
if (
_isRep0LongDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].Decode(
rangeDecoder) == 0)
{
_state.UpdateShortRep();
outWindow.PutByte(outWindow.GetByte((int)_rep0));
continue;
}
}
else
{
UInt32 distance;
if (_isRepG1Decoders[_state._index].Decode(rangeDecoder) == 0)
{
distance = _rep1;
}
else
{
if (_isRepG2Decoders[_state._index].Decode(rangeDecoder) == 0)
{
distance = _rep2;
}
else
{
distance = _rep3;
_rep3 = _rep2;
}
_rep2 = _rep1;
}
_rep1 = _rep0;
_rep0 = distance;
}
len = _repLenDecoder.Decode(rangeDecoder, posState) + Base.K_MATCH_MIN_LEN;
_state.UpdateRep();
}
else
{
_rep3 = _rep2;
_rep2 = _rep1;
_rep1 = _rep0;
len = Base.K_MATCH_MIN_LEN + _lenDecoder.Decode(rangeDecoder, posState);
_state.UpdateMatch();
uint posSlot = _posSlotDecoder[Base.GetLenToPosState(len)].Decode(rangeDecoder);
if (posSlot >= Base.K_START_POS_MODEL_INDEX)
{
int numDirectBits = (int)((posSlot >> 1) - 1);
_rep0 = ((2 | (posSlot & 1)) << numDirectBits);
if (posSlot < Base.K_END_POS_MODEL_INDEX)
{
_rep0 += BitTreeDecoder.ReverseDecode(_posDecoders,
_rep0 - posSlot - 1, rangeDecoder, numDirectBits);
}
else
{
_rep0 += (rangeDecoder.DecodeDirectBits(
numDirectBits - Base.K_NUM_ALIGN_BITS) << Base.K_NUM_ALIGN_BITS);
_rep0 += _posAlignDecoder.ReverseDecode(rangeDecoder);
}
}
else
{
_rep0 = posSlot;
}
}
if (_rep0 >= outWindow._total || _rep0 >= dictionarySizeCheck)
{
if (_rep0 == 0xFFFFFFFF)
{
return(true);
}
throw new DataErrorException();
}
outWindow.CopyBlock((int)_rep0, (int)len);
}
}
return(false);
}
public bool CodeNext(ref CodeState codestate, UInt64 step)
{
uint rep0 = codestate.rep0,
rep1 = codestate.rep1,
rep2 = codestate.rep2,
rep3 = codestate.rep3;
UInt64 nowPos64 = codestate.nowpos;
UInt64 outSize64 = codestate.outsize;
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;
}
}
if (nowPos64 - codestate.nowpos >= step)
{
break;
}
}
codestate.rep0 = rep0;
codestate.rep1 = rep1;
codestate.rep2 = rep2;
codestate.rep3 = rep3;
codestate.nowpos = nowPos64;
codestate.outsize = outSize64;
if (nowPos64 >= outSize64)
{
m_OutWindow.Flush();
m_OutWindow.ReleaseStream();
m_RangeDecoder.ReleaseStream();
return(true);
}
return(false);
}
/// <summary>
/// Initializes the Lzma Decoder class.
/// </summary>
public Decoder()
{
m_DictionarySize = 0xFFFFFFFF;
for (int i = 0; i < Base.kNumLenToPosStates; i++)
m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
}
public void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress)
{
this.Init(inStream, outStream);
Base.State state = default(Base.State);
state.Init();
uint num = 0u;
uint num2 = 0u;
uint num3 = 0u;
uint num4 = 0u;
ulong num5 = 0uL;
if (num5 < (ulong)outSize)
{
if (this.m_IsMatchDecoders[(int)((UIntPtr)(state.Index << 4))].Decode(this.m_RangeDecoder) != 0u)
{
throw new DataErrorException();
}
state.UpdateChar();
byte b = this.m_LiteralDecoder.DecodeNormal(this.m_RangeDecoder, 0u, 0);
this.m_OutWindow.PutByte(b);
num5 += 1uL;
}
while (num5 < (ulong)outSize)
{
uint num6 = (uint)num5 & this.m_PosStateMask;
if (this.m_IsMatchDecoders[(int)((UIntPtr)((state.Index << 4) + num6))].Decode(this.m_RangeDecoder) == 0u)
{
byte @byte = this.m_OutWindow.GetByte(0u);
byte b2;
if (!state.IsCharState())
{
b2 = this.m_LiteralDecoder.DecodeWithMatchByte(this.m_RangeDecoder, (uint)num5, @byte, this.m_OutWindow.GetByte(num));
}
else
{
b2 = this.m_LiteralDecoder.DecodeNormal(this.m_RangeDecoder, (uint)num5, @byte);
}
this.m_OutWindow.PutByte(b2);
state.UpdateChar();
num5 += 1uL;
}
else
{
uint num8;
if (this.m_IsRepDecoders[(int)((UIntPtr)state.Index)].Decode(this.m_RangeDecoder) == 1u)
{
if (this.m_IsRepG0Decoders[(int)((UIntPtr)state.Index)].Decode(this.m_RangeDecoder) == 0u)
{
if (this.m_IsRep0LongDecoders[(int)((UIntPtr)((state.Index << 4) + num6))].Decode(this.m_RangeDecoder) == 0u)
{
state.UpdateShortRep();
this.m_OutWindow.PutByte(this.m_OutWindow.GetByte(num));
num5 += 1uL;
continue;
}
}
else
{
uint num7;
if (this.m_IsRepG1Decoders[(int)((UIntPtr)state.Index)].Decode(this.m_RangeDecoder) == 0u)
{
num7 = num2;
}
else
{
if (this.m_IsRepG2Decoders[(int)((UIntPtr)state.Index)].Decode(this.m_RangeDecoder) == 0u)
{
num7 = num3;
}
else
{
num7 = num4;
num4 = num3;
}
num3 = num2;
}
num2 = num;
num = num7;
}
num8 = this.m_RepLenDecoder.Decode(this.m_RangeDecoder, num6) + 2u;
state.UpdateRep();
}
else
{
num4 = num3;
num3 = num2;
num2 = num;
num8 = 2u + this.m_LenDecoder.Decode(this.m_RangeDecoder, num6);
state.UpdateMatch();
uint num9 = this.m_PosSlotDecoder[(int)((UIntPtr)Base.GetLenToPosState(num8))].Decode(this.m_RangeDecoder);
if (num9 >= 4u)
{
int num10 = (int)((num9 >> 1) - 1u);
num = (2u | (num9 & 1u)) << num10;
if (num9 < 14u)
{
num += BitTreeDecoder.ReverseDecode(this.m_PosDecoders, num - num9 - 1u, this.m_RangeDecoder, num10);
}
else
{
num += this.m_RangeDecoder.DecodeDirectBits(num10 - 4) << 4;
num += this.m_PosAlignDecoder.ReverseDecode(this.m_RangeDecoder);
}
}
else
{
num = num9;
}
}
if ((ulong)num >= (ulong)this.m_OutWindow.TrainSize + num5 || num >= this.m_DictionarySizeCheck)
{
if (num == 4294967295u)
{
break;
}
throw new DataErrorException();
}
else
{
this.m_OutWindow.CopyBlock(num, num8);
num5 += (ulong)num8;
}
}
}
this.m_OutWindow.Flush();
this.m_OutWindow.ReleaseStream();
this.m_RangeDecoder.ReleaseStream();
}
