Ejemplo n.º 1
0
 public LZMADecoder()
 {
     m_DictionarySize = 0xFFFFFFFF;
     for (int i = 0; i < LZMABase.kNumLenToPosStates; i++)
     {
         m_PosSlotDecoder[i] = new RangeCoderBitTreeDecoder(LZMABase.kNumPosSlotBits);
     }
 }
Ejemplo n.º 2
0
			public void Create(uint numPosStates)
			{
				for (uint posState = m_NumPosStates; posState < numPosStates; posState++)
				{
					m_LowCoder[posState] = new RangeCoderBitTreeDecoder(LZMABase.kNumLowLenBits);
					m_MidCoder[posState] = new RangeCoderBitTreeDecoder(LZMABase.kNumMidLenBits);
				}
				m_NumPosStates = numPosStates;
			}
Ejemplo n.º 3
0
 public void Create(uint numPosStates)
 {
     for (uint posState = m_NumPosStates; posState < numPosStates; posState++)
     {
         m_LowCoder[posState] = new RangeCoderBitTreeDecoder(LZMABase.kNumLowLenBits);
         m_MidCoder[posState] = new RangeCoderBitTreeDecoder(LZMABase.kNumMidLenBits);
     }
     m_NumPosStates = numPosStates;
 }
Ejemplo n.º 4
0
    public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
                     Int64 inSize, Int64 outSize, ICodeProgress progress)
    {
        Init(inStream, outStream);

        LZMABase.State state = new LZMABase.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 << LZMABase.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 << LZMABase.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 << LZMABase.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) + LZMABase.kMatchMinLen;
                        state.UpdateRep();
                    }
                    else
                    {
                        rep3 = rep2;
                        rep2 = rep1;
                        rep1 = rep0;
                        len  = LZMABase.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
                        state.UpdateMatch();
                        uint posSlot = m_PosSlotDecoder[LZMABase.GetLenToPosState(len)].Decode(m_RangeDecoder);
                        if (posSlot >= LZMABase.kStartPosModelIndex)
                        {
                            int numDirectBits = (int)((posSlot >> 1) - 1);
                            rep0 = ((2 | (posSlot & 1)) << numDirectBits);
                            if (posSlot < LZMABase.kEndPosModelIndex)
                            {
                                rep0 += RangeCoderBitTreeDecoder.ReverseDecode(m_PosDecoders,
                                                                               rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
                            }
                            else
                            {
                                rep0 += (m_RangeDecoder.DecodeDirectBits(
                                             numDirectBits - LZMABase.kNumAlignBits) << LZMABase.kNumAlignBits);
                                rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
                            }
                        }
                        else
                        {
                            rep0 = posSlot;
                        }
                    }
                    if (rep0 >= 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();
    }
Ejemplo n.º 5
0
		public LZMADecoder()
		{
			m_DictionarySize = 0xFFFFFFFF;
			for (int i = 0; i < LZMABase.kNumLenToPosStates; i++)
				m_PosSlotDecoder[i] = new RangeCoderBitTreeDecoder(LZMABase.kNumPosSlotBits);
		}