SevenZipReduced.Compression.LZMA.Decoder Class Reference

Inheritance diagram for SevenZipReduced.Compression.LZMA.Decoder:

Collaboration diagram for SevenZipReduced.Compression.LZMA.Decoder:

Public Member Functions
void	Code (System.IO.Stream inStream, System.IO.Stream outStream, Int64 inSize, Int64 outSize, ICodeProgress progress)
	Codes streams. More...
void	SetDecoderProperties (byte[] properties)
bool	Train (System.IO.Stream stream)

Detailed Description

Definition at line 9 of file LzmaDecoder.cs.

Member Function Documentation

void SevenZipReduced.Compression.LZMA.Decoder.Code ( System.IO.Stream  inStream, System.IO.Stream  outStream, Int64  inSize, Int64  outSize, ICodeProgress  progress  )

inline

Codes streams.

Parameters

inStream	input Stream.
outStream	output Stream.
inSize	input Size. -1 if unknown.
outSize	output Size. -1 if unknown.
progress	callback progress reference.

Exceptions

SevenZipReduced.DataErrorException

if input stream is not valid

Implements SevenZipReduced.ICoder.

Definition at line 230 of file LzmaDecoder.cs.

                {
                        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();
                }

---

The documentation for this class was generated from the following file:

• C:/Users/nathanael/Documents/resizer/Plugins/SeamCarving/SevenZipReduced/Compress/LZMA/LzmaDecoder.cs