UpdateMatch() публичный Метод

public UpdateMatch ( ) : void
Результат void
Пример #1
0
        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();
        }
Пример #2
0
		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();
		}
Пример #3
0
        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)
            {
                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();
        }
Пример #4
0
        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();
        }
Пример #5
0
        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();
        }
Пример #6
0
        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);
        }
Пример #7
0
        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();
        }