public void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress) { Init(inStream, outStream); var state = new Base.State(); state.Init(); uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0; ulong nowPos64 = 0; var outSize64 = (ulong)outSize; if (nowPos64 < outSize64) { if (_mIsMatchDecoders[state.Index << Base.KNumPosStatesBitsMax].Decode(_mRangeDecoder) != 0) { throw new DataErrorException(); } state.UpdateChar(); var b = _mLiteralDecoder.DecodeNormal(_mRangeDecoder, 0, 0); _mOutWindow.PutByte(b); nowPos64++; } while (nowPos64 < outSize64) // UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64); // while(nowPos64 < next) { var posState = (uint)nowPos64 & _mPosStateMask; if (_mIsMatchDecoders[(state.Index << Base.KNumPosStatesBitsMax) + posState].Decode(_mRangeDecoder) == 0) { byte b; var prevByte = _mOutWindow.GetByte(0); if (!state.IsCharState()) { b = _mLiteralDecoder.DecodeWithMatchByte(_mRangeDecoder, (uint)nowPos64, prevByte, _mOutWindow.GetByte(rep0)); } else { b = _mLiteralDecoder.DecodeNormal(_mRangeDecoder, (uint)nowPos64, prevByte); } _mOutWindow.PutByte(b); state.UpdateChar(); nowPos64++; } else { uint len; if (_mIsRepDecoders[state.Index].Decode(_mRangeDecoder) == 1) { if (_mIsRepG0Decoders[state.Index].Decode(_mRangeDecoder) == 0) { if ( _mIsRep0LongDecoders[(state.Index << Base.KNumPosStatesBitsMax) + posState].Decode( _mRangeDecoder) == 0) { state.UpdateShortRep(); _mOutWindow.PutByte(_mOutWindow.GetByte(rep0)); nowPos64++; continue; } } else { uint distance; if (_mIsRepG1Decoders[state.Index].Decode(_mRangeDecoder) == 0) { distance = rep1; } else { if (_mIsRepG2Decoders[state.Index].Decode(_mRangeDecoder) == 0) { distance = rep2; } else { distance = rep3; rep3 = rep2; } rep2 = rep1; } rep1 = rep0; rep0 = distance; } len = _mRepLenDecoder.Decode(_mRangeDecoder, posState) + Base.KMatchMinLen; state.UpdateRep(); } else { rep3 = rep2; rep2 = rep1; rep1 = rep0; len = Base.KMatchMinLen + _mLenDecoder.Decode(_mRangeDecoder, posState); state.UpdateMatch(); var posSlot = _mPosSlotDecoder[Base.GetLenToPosState(len)].Decode(_mRangeDecoder); if (posSlot >= Base.KStartPosModelIndex) { var numDirectBits = (int)((posSlot >> 1) - 1); rep0 = ((2 | (posSlot & 1)) << numDirectBits); if (posSlot < Base.KEndPosModelIndex) { rep0 += BitTreeDecoder.ReverseDecode(_mPosDecoders, rep0 - posSlot - 1, _mRangeDecoder, numDirectBits); } else { rep0 += (_mRangeDecoder.DecodeDirectBits( numDirectBits - Base.KNumAlignBits) << Base.KNumAlignBits); rep0 += _mPosAlignDecoder.ReverseDecode(_mRangeDecoder); } } else { rep0 = posSlot; } } if (rep0 >= _mOutWindow.TrainSize + nowPos64 || rep0 >= _mDictionarySizeCheck) { if (rep0 == 0xFFFFFFFF) { break; } throw new DataErrorException(); } _mOutWindow.CopyBlock(rep0, len); nowPos64 += len; } } _mOutWindow.Flush(); _mOutWindow.ReleaseStream(); _mRangeDecoder.ReleaseStream(); }
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; } if (progress != null) { progress.SetProgress((long)nowPos64, (long)inSize); } } } m_OutWindow.Flush(); m_OutWindow.ReleaseStream(); 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); }
internal bool Code(int dictionarySize, LZ.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); }
// Token: 0x06002204 RID: 8708 RVA: 0x00404830 File Offset: 0x00402A30 public IEnumerator Decode(Stream inStream, Stream outStream, long inSize, long outSize, uint roundSize, ICodeProgress progress) { this.Init(inStream, outStream); Base.State state = default(Base.State); state.Init(); uint rep0 = 0u; uint rep = 0u; uint rep2 = 0u; uint rep3 = 0u; uint runs = 0u; ulong nowPos64 = 0UL; if (nowPos64 < (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); nowPos64 += 1UL; } while (nowPos64 < (ulong)outSize) { runs += 1u; uint posState = (uint)nowPos64 & this.m_PosStateMask; if (this.m_IsMatchDecoders[(int)((UIntPtr)((state.Index << 4) + posState))].Decode(this.m_RangeDecoder) == 0u) { byte prevByte = this.m_OutWindow.GetByte(0u); byte b2; if (!state.IsCharState()) { b2 = this.m_LiteralDecoder.DecodeWithMatchByte(this.m_RangeDecoder, (uint)nowPos64, prevByte, this.m_OutWindow.GetByte(rep0)); } else { b2 = this.m_LiteralDecoder.DecodeNormal(this.m_RangeDecoder, (uint)nowPos64, prevByte); } this.m_OutWindow.PutByte(b2); state.UpdateChar(); nowPos64 += 1UL; } else { uint len; 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) + posState))].Decode(this.m_RangeDecoder) == 0u) { state.UpdateShortRep(); this.m_OutWindow.PutByte(this.m_OutWindow.GetByte(rep0)); nowPos64 += 1UL; continue; } } else { uint distance; if (this.m_IsRepG1Decoders[(int)((UIntPtr)state.Index)].Decode(this.m_RangeDecoder) == 0u) { distance = rep; } else { if (this.m_IsRepG2Decoders[(int)((UIntPtr)state.Index)].Decode(this.m_RangeDecoder) == 0u) { distance = rep2; } else { distance = rep3; rep3 = rep2; } rep2 = rep; } rep = rep0; rep0 = distance; } len = this.m_RepLenDecoder.Decode(this.m_RangeDecoder, posState) + 2u; state.UpdateRep(); } else { rep3 = rep2; rep2 = rep; rep = rep0; len = 2u + this.m_LenDecoder.Decode(this.m_RangeDecoder, posState); state.UpdateMatch(); uint posSlot = this.m_PosSlotDecoder[(int)((UIntPtr)Base.GetLenToPosState(len))].Decode(this.m_RangeDecoder); if (posSlot >= 4u) { int numDirectBits = (int)((posSlot >> 1) - 1u); rep0 = (2u | (posSlot & 1u)) << numDirectBits; if (posSlot < 14u) { rep0 += BitTreeDecoder.ReverseDecode(this.m_PosDecoders, rep0 - posSlot - 1u, this.m_RangeDecoder, numDirectBits); } else { rep0 += this.m_RangeDecoder.DecodeDirectBits(numDirectBits - 4) << 4; rep0 += this.m_PosAlignDecoder.ReverseDecode(this.m_RangeDecoder); } } else { rep0 = posSlot; } } if ((ulong)rep0 >= (ulong)this.m_OutWindow.TrainSize + nowPos64 || rep0 >= this.m_DictionarySizeCheck) { if (rep0 == 4294967295u) { break; } throw new DataErrorException(); } else { this.m_OutWindow.CopyBlock(rep0, len); nowPos64 += (ulong)len; } } if (runs > roundSize) { if (progress != null) { progress.SetProgress((long)nowPos64, outSize); } runs = 0u; yield return(null); } } this.m_OutWindow.Flush(); this.m_OutWindow.ReleaseStream(); this.m_RangeDecoder.ReleaseStream(); yield break; }
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(); }
/// <summary> /// Codes a stream with LZMA algorithm to an output stream /// </summary> /// <param name="inStream">The input stream</param> /// <param name="inSize">The input size</param> /// <param name="outSize">The output size</param> /// <param name="outStream">The output stream</param> /// <param name="progress">Progress interface</param> public void Code(Stream inStream, Stream outStream, Int64 inSize, Int64 outSize, ICodeProgress progress) { Init(inStream, outStream); var state = new Base.State(); state.Init(); uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0; //Outsize == Int64.MaxValue means this is a streamed LZMA file and we don't know how much we have do. When rep0 is 0xFFFFFFFF we are done decoding. UInt64 nowPos64 = 0; var outSize64 = (UInt64)outSize; if (nowPos64 < outSize64 && outSize != -1) { 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 || outSize == -1) { // 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) { var 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) //End of file marker { HasFoundEndOfStream = true; break; } throw new DataErrorException(); } m_OutWindow.CopyBlock(rep0, len); nowPos64 += len; } } } m_OutWindow.Flush(); m_OutWindow.ReleaseStream(); 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); }
public void Code(Stream inStream, Stream outStream, Int64 inSize, Int64 outSize) { this.Init(inStream, outStream); var state = new State(); state.Init(); uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0; UInt64 nowPos64 = 0; ulong outSize64 = (UInt64)outSize; if (nowPos64 < outSize64) { this.m_IsMatchDecoders[state.Index << kNumPosStatesBitsMax].Decode(this.m_RangeDecoder); 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 << 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 << kNumPosStatesBitsMax) + posState].Decode(this.m_RangeDecoder) == 0) { state.UpdateShortRep(); this.m_OutWindow.PutByte(this.m_OutWindow.GetByte(rep0)); nowPos64++; continue; } } else { UInt32 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) + kMatchMinLen; state.UpdateRep(); } else { rep3 = rep2; rep2 = rep1; rep1 = rep0; len = kMatchMinLen + this.m_LenDecoder.Decode(this.m_RangeDecoder, posState); state.UpdateMatch(); uint posSlot = this.m_PosSlotDecoder[GetLenToPosState(len)].Decode(this.m_RangeDecoder); if (posSlot >= kStartPosModelIndex) { int numDirectBits = (int)((posSlot >> 1) - 1); rep0 = ((2 | (posSlot & 1)) << numDirectBits); if (posSlot < kEndPosModelIndex) { rep0 += BitTreeDecoder.ReverseDecode(this.m_PosDecoders, rep0 - posSlot - 1, this.m_RangeDecoder, numDirectBits); } else { rep0 += (this.m_RangeDecoder.DecodeDirectBits( numDirectBits - kNumAlignBits) << kNumAlignBits); rep0 += this.m_PosAlignDecoder.ReverseDecode(this.m_RangeDecoder); } } else { rep0 = posSlot; } } if (rep0 >= nowPos64 || rep0 >= this.m_DictionarySizeCheck) { if (rep0 == 0xFFFFFFFF) { break; } } this.m_OutWindow.CopyBlock(rep0, len); nowPos64 += len; } } } this.m_OutWindow.Flush(); this.m_OutWindow.ReleaseStream(); this.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(); }
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); }
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(); }