Package SevenZip.Compression.LZMA

Source Code of SevenZip.Compression.LZMA.Decoder$LiteralDecoder$Decoder2

package SevenZip.Compression.LZMA;

import java.io.IOException;

import SevenZip.Compression.LZ.OutWindow;
import SevenZip.Compression.RangeCoder.BitTreeDecoder;

public class Decoder
{
    class LenDecoder
    {
        short[]          m_Choice       = new short[2];
        BitTreeDecoder[] m_LowCoder     = new BitTreeDecoder[Base.kNumPosStatesMax];
        BitTreeDecoder[] m_MidCoder     = new BitTreeDecoder[Base.kNumPosStatesMax];
        BitTreeDecoder   m_HighCoder    = new BitTreeDecoder(
                                                Base.kNumHighLenBits);
        int              m_NumPosStates = 0;
       
        public void Create(int numPosStates)
        {
            for (; m_NumPosStates < numPosStates; m_NumPosStates++)
            {
                m_LowCoder[m_NumPosStates] = new BitTreeDecoder(
                        Base.kNumLowLenBits);
                m_MidCoder[m_NumPosStates] = new BitTreeDecoder(
                        Base.kNumMidLenBits);
            }
        }
       
        public void Init()
        {
            SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_Choice);
            for (int posState = 0; posState < m_NumPosStates; posState++)
            {
                m_LowCoder[posState].Init();
                m_MidCoder[posState].Init();
            }
            m_HighCoder.Init();
        }
       
        public int Decode(SevenZip.Compression.RangeCoder.Decoder rangeDecoder,
                int posState) throws IOException
        {
            if (rangeDecoder.DecodeBit(m_Choice, 0) == 0)
            {
                return m_LowCoder[posState].Decode(rangeDecoder);
            }
            int symbol = Base.kNumLowLenSymbols;
            if (rangeDecoder.DecodeBit(m_Choice, 1) == 0)
            {
                symbol += m_MidCoder[posState].Decode(rangeDecoder);
            }
            else
            {
                symbol += Base.kNumMidLenSymbols
                        + m_HighCoder.Decode(rangeDecoder);
            }
            return symbol;
        }
    }
   
    class LiteralDecoder
    {
        class Decoder2
        {
            short[] m_Decoders = new short[0x300];
           
            public void Init()
            {
                SevenZip.Compression.RangeCoder.Decoder
                        .InitBitModels(m_Decoders);
            }
           
            public byte DecodeNormal(
                    SevenZip.Compression.RangeCoder.Decoder rangeDecoder)
                    throws IOException
            {
                int symbol = 1;
                do
                {
                    symbol = symbol << 1
                            | rangeDecoder.DecodeBit(m_Decoders, symbol);
                } while (symbol < 0x100);
                return (byte) symbol;
            }
           
            public byte DecodeWithMatchByte(
                    SevenZip.Compression.RangeCoder.Decoder rangeDecoder,
                    byte matchByte) throws IOException
            {
                int symbol = 1;
                do
                {
                    final int matchBit = matchByte >> 7 & 1;
                    matchByte <<= 1;
                    final int bit = rangeDecoder.DecodeBit(m_Decoders,
                            (1 + matchBit << 8) + symbol);
                    symbol = symbol << 1 | bit;
                    if (matchBit != bit)
                    {
                        while (symbol < 0x100)
                        {
                            symbol = symbol << 1
                                    | rangeDecoder
                                            .DecodeBit(m_Decoders, symbol);
                        }
                        break;
                    }
                } while (symbol < 0x100);
                return (byte) symbol;
            }
        }
       
        Decoder2[] m_Coders;
        int        m_NumPrevBits;
        int        m_NumPosBits;
        int        m_PosMask;
       
        public void Create(int numPosBits, int numPrevBits)
        {
            if (m_Coders != null && m_NumPrevBits == numPrevBits
                    && m_NumPosBits == numPosBits)
            {
                return;
            }
            m_NumPosBits = numPosBits;
            m_PosMask = (1 << numPosBits) - 1;
            m_NumPrevBits = numPrevBits;
            final int numStates = 1 << m_NumPrevBits + m_NumPosBits;
            m_Coders = new Decoder2[numStates];
            for (int i = 0; i < numStates; i++)
            {
                m_Coders[i] = new Decoder2();
            }
        }
       
        public void Init()
        {
            final int numStates = 1 << m_NumPrevBits + m_NumPosBits;
            for (int i = 0; i < numStates; i++)
            {
                m_Coders[i].Init();
            }
        }
       
        Decoder2 GetDecoder(int pos, byte prevByte)
        {
            return m_Coders[((pos & m_PosMask) << m_NumPrevBits)
                    + ((prevByte & 0xFF) >>> 8 - m_NumPrevBits)];
        }
    }
   
    OutWindow                               m_OutWindow           = new OutWindow();
    SevenZip.Compression.RangeCoder.Decoder m_RangeDecoder        = new SevenZip.Compression.RangeCoder.Decoder();
   
    short[]                                 m_IsMatchDecoders     = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
    short[]                                 m_IsRepDecoders       = new short[Base.kNumStates];
    short[]                                 m_IsRepG0Decoders     = new short[Base.kNumStates];
    short[]                                 m_IsRepG1Decoders     = new short[Base.kNumStates];
    short[]                                 m_IsRepG2Decoders     = new short[Base.kNumStates];
    short[]                                 m_IsRep0LongDecoders  = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
   
    BitTreeDecoder[]                        m_PosSlotDecoder      = new BitTreeDecoder[Base.kNumLenToPosStates];
    short[]                                 m_PosDecoders         = new short[Base.kNumFullDistances
                                                                          - Base.kEndPosModelIndex];
   
    BitTreeDecoder                          m_PosAlignDecoder     = new BitTreeDecoder(
                                                                          Base.kNumAlignBits);
   
    LenDecoder                              m_LenDecoder          = new LenDecoder();
    LenDecoder                              m_RepLenDecoder       = new LenDecoder();
   
    LiteralDecoder                          m_LiteralDecoder      = new LiteralDecoder();
   
    int                                     m_DictionarySize      = -1;
    int                                     m_DictionarySizeCheck = -1;
   
    int                                     m_PosStateMask;
   
    public Decoder()
    {
        for (int i = 0; i < Base.kNumLenToPosStates; i++)
        {
            m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
        }
    }
   
    boolean SetDictionarySize(int dictionarySize)
    {
        if (dictionarySize < 0)
        {
            return false;
        }
        if (m_DictionarySize != dictionarySize)
        {
            m_DictionarySize = dictionarySize;
            m_DictionarySizeCheck = Math.max(m_DictionarySize, 1);
            m_OutWindow.Create(Math.max(m_DictionarySizeCheck, 1 << 12));
        }
        return true;
    }
   
    boolean SetLcLpPb(int lc, int lp, int pb)
    {
        if (lc > Base.kNumLitContextBitsMax || lp > 4
                || pb > Base.kNumPosStatesBitsMax)
        {
            return false;
        }
        m_LiteralDecoder.Create(lp, lc);
        final int numPosStates = 1 << pb;
        m_LenDecoder.Create(numPosStates);
        m_RepLenDecoder.Create(numPosStates);
        m_PosStateMask = numPosStates - 1;
        return true;
    }
   
    void Init() throws IOException
    {
        m_OutWindow.Init(false);
       
        SevenZip.Compression.RangeCoder.Decoder
                .InitBitModels(m_IsMatchDecoders);
        SevenZip.Compression.RangeCoder.Decoder
                .InitBitModels(m_IsRep0LongDecoders);
        SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepDecoders);
        SevenZip.Compression.RangeCoder.Decoder
                .InitBitModels(m_IsRepG0Decoders);
        SevenZip.Compression.RangeCoder.Decoder
                .InitBitModels(m_IsRepG1Decoders);
        SevenZip.Compression.RangeCoder.Decoder
                .InitBitModels(m_IsRepG2Decoders);
        SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_PosDecoders);
       
        m_LiteralDecoder.Init();
        int i;
        for (i = 0; i < Base.kNumLenToPosStates; i++)
        {
            m_PosSlotDecoder[i].Init();
        }
        m_LenDecoder.Init();
        m_RepLenDecoder.Init();
        m_PosAlignDecoder.Init();
        m_RangeDecoder.Init();
    }
   
    public boolean Code(java.io.InputStream inStream,
            java.io.OutputStream outStream, long outSize) throws IOException
    {
        m_RangeDecoder.SetStream(inStream);
        m_OutWindow.SetStream(outStream);
        Init();
       
        int state = Base.StateInit();
        int rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
       
        long nowPos64 = 0;
        byte prevByte = 0;
        while (outSize < 0 || nowPos64 < outSize)
        {
            final int posState = (int) nowPos64 & m_PosStateMask;
            if (m_RangeDecoder.DecodeBit(m_IsMatchDecoders,
                    (state << Base.kNumPosStatesBitsMax) + posState) == 0)
            {
                final LiteralDecoder.Decoder2 decoder2 = m_LiteralDecoder
                        .GetDecoder((int) nowPos64, prevByte);
                if (!Base.StateIsCharState(state))
                {
                    prevByte = decoder2.DecodeWithMatchByte(m_RangeDecoder,
                            m_OutWindow.GetByte(rep0));
                }
                else
                {
                    prevByte = decoder2.DecodeNormal(m_RangeDecoder);
                }
                m_OutWindow.PutByte(prevByte);
                state = Base.StateUpdateChar(state);
                nowPos64++;
            }
            else
            {
                int len;
                if (m_RangeDecoder.DecodeBit(m_IsRepDecoders, state) == 1)
                {
                    len = 0;
                    if (m_RangeDecoder.DecodeBit(m_IsRepG0Decoders, state) == 0)
                    {
                        if (m_RangeDecoder
                                .DecodeBit(m_IsRep0LongDecoders,
                                        (state << Base.kNumPosStatesBitsMax)
                                                + posState) == 0)
                        {
                            state = Base.StateUpdateShortRep(state);
                            len = 1;
                        }
                    }
                    else
                    {
                        int distance;
                        if (m_RangeDecoder.DecodeBit(m_IsRepG1Decoders, state) == 0)
                        {
                            distance = rep1;
                        }
                        else
                        {
                            if (m_RangeDecoder.DecodeBit(m_IsRepG2Decoders,
                                    state) == 0)
                            {
                                distance = rep2;
                            }
                            else
                            {
                                distance = rep3;
                                rep3 = rep2;
                            }
                            rep2 = rep1;
                        }
                        rep1 = rep0;
                        rep0 = distance;
                    }
                    if (len == 0)
                    {
                        len = m_RepLenDecoder.Decode(m_RangeDecoder, posState)
                                + Base.kMatchMinLen;
                        state = Base.StateUpdateRep(state);
                    }
                }
                else
                {
                    rep3 = rep2;
                    rep2 = rep1;
                    rep1 = rep0;
                    len = Base.kMatchMinLen
                            + m_LenDecoder.Decode(m_RangeDecoder, posState);
                    state = Base.StateUpdateMatch(state);
                    final int posSlot = m_PosSlotDecoder[Base
                            .GetLenToPosState(len)].Decode(m_RangeDecoder);
                    if (posSlot >= Base.kStartPosModelIndex)
                    {
                        final int numDirectBits = (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);
                            if (rep0 < 0)
                            {
                                if (rep0 == -1)
                                {
                                    break;
                                }
                                return false;
                            }
                        }
                    }
                    else
                    {
                        rep0 = posSlot;
                    }
                }
                if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck)
                {
                    // m_OutWindow.Flush();
                    return false;
                }
                m_OutWindow.CopyBlock(rep0, len);
                nowPos64 += len;
                prevByte = m_OutWindow.GetByte(0);
            }
        }
        m_OutWindow.Flush();
        m_OutWindow.ReleaseStream();
        m_RangeDecoder.ReleaseStream();
        return true;
    }
   
    public boolean SetDecoderProperties(byte[] properties)
    {
        if (properties.length < 5)
        {
            return false;
        }
        final int val = properties[0] & 0xFF;
        final int lc = val % 9;
        final int remainder = val / 9;
        final int lp = remainder % 5;
        final int pb = remainder / 5;
        int dictionarySize = 0;
        for (int i = 0; i < 4; i++)
        {
            dictionarySize += (properties[1 + i] & 0xFF) << i * 8;
        }
        if (!SetLcLpPb(lc, lp, pb))
        {
            return false;
        }
        return SetDictionarySize(dictionarySize);
    }
}
TOP

Related Classes of SevenZip.Compression.LZMA.Decoder$LiteralDecoder$Decoder2

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.