public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
            Int64 inSize, Int64 outSize, ICodeProgress progress)
        {
            if (m_OutWindow == null)
                CreateDictionary();
            m_OutWindow.Init(outStream);
            if (outSize > 0)
                m_OutWindow.SetLimit(outSize);
            else
                m_OutWindow.SetLimit(Int64.MaxValue - m_OutWindow.Total);

            RangeCoder.Decoder rangeDecoder = new RangeCoder.Decoder();
            rangeDecoder.Init(inStream);

            Code(m_DictionarySize, m_OutWindow, rangeDecoder);

            m_OutWindow.ReleaseStream();
            rangeDecoder.ReleaseStream();

            if (!rangeDecoder.IsFinished || (inSize > 0 && rangeDecoder.Total != inSize))
                throw new DataErrorException();
            if (m_OutWindow.HasPending)
                throw new DataErrorException();
            m_OutWindow = null;
        }
Пример #2
0
 public void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress)
 {
     if (this.m_OutWindow == null)
     {
         this.CreateDictionary();
     }
     this.m_OutWindow.Init(outStream);
     if (outSize > 0L)
     {
         this.m_OutWindow.SetLimit(outSize);
     }
     else
     {
         this.m_OutWindow.SetLimit(0x7fffffffffffffffL - this.m_OutWindow.Total);
     }
     SharpCompress.Compressor.LZMA.RangeCoder.Decoder rangeDecoder = new SharpCompress.Compressor.LZMA.RangeCoder.Decoder();
     rangeDecoder.Init(inStream);
     this.Code(this.m_DictionarySize, this.m_OutWindow, rangeDecoder);
     this.m_OutWindow.ReleaseStream();
     rangeDecoder.ReleaseStream();
     if (!(rangeDecoder.IsFinished && ((inSize <= 0L) || (rangeDecoder.Total == inSize))))
     {
         throw new DataErrorException();
     }
     if (this.m_OutWindow.HasPending)
     {
         throw new DataErrorException();
     }
     this.m_OutWindow = null;
 }
Пример #3
0
        public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
                         Int64 inSize, Int64 outSize, ICodeProgress progress)
        {
            if (m_OutWindow == null)
            {
                CreateDictionary();
            }
            m_OutWindow.Init(outStream);
            if (outSize > 0)
            {
                m_OutWindow.SetLimit(outSize);
            }
            else
            {
                m_OutWindow.SetLimit(Int64.MaxValue - m_OutWindow.Total);
            }

            RangeCoder.Decoder rangeDecoder = new RangeCoder.Decoder();
            rangeDecoder.Init(inStream);

            Code(m_DictionarySize, m_OutWindow, rangeDecoder);

            m_OutWindow.ReleaseStream();
            rangeDecoder.ReleaseStream();

            if (!rangeDecoder.IsFinished || (inSize > 0 && rangeDecoder.Total != inSize))
            {
                throw new DataErrorException();
            }
            if (m_OutWindow.HasPending)
            {
                throw new DataErrorException();
            }
            m_OutWindow = null;
        }
Пример #4
0
 public LzmaStream(LzmaEncoderProperties properties, bool isLZMA2, Stream presetDictionary, Stream outputStream)
 {
     this.outWindow = new OutWindow();
     this.rangeDecoder = new SharpCompress.Compressor.LZMA.RangeCoder.Decoder();
     this.position = 0L;
     this.endReached = false;
     this.inputPosition = 0L;
     this.uncompressedChunk = false;
     this.needDictReset = true;
     this.needProps = true;
     this.props = new byte[5];
     this.isLZMA2 = isLZMA2;
     this.availableBytes = 0L;
     this.endReached = true;
     if (isLZMA2)
     {
         throw new NotImplementedException();
     }
     this.encoder = new SharpCompress.Compressor.LZMA.Encoder();
     this.encoder.SetCoderProperties(properties.propIDs, properties.properties);
     MemoryStream outStream = new MemoryStream(5);
     this.encoder.WriteCoderProperties(outStream);
     this.props = outStream.ToArray();
     this.encoder.SetStreams(null, outputStream, -1L, -1L);
     if (presetDictionary != null)
     {
         this.encoder.Train(presetDictionary);
     }
 }
Пример #5
0
        void CreateDictionary()
        {
            if (m_DictionarySize < 0)
            {
                throw new InvalidParamException();
            }
            m_OutWindow = new LZ.OutWindow();
            int blockSize = Math.Max(m_DictionarySize, (1 << 12));

            m_OutWindow.Create(blockSize);
        }
 void CreateDictionary()
 {
     if (m_DictionarySize < 0)
         throw new InvalidParamException();
     m_OutWindow = new LZ.OutWindow();
     int blockSize = Math.Max(m_DictionarySize, (1 << 12));
     m_OutWindow.Create(blockSize);
 }
Пример #7
0
 private void CreateDictionary()
 {
     if (this.m_DictionarySize < 0)
     {
         throw new InvalidParamException();
     }
     this.m_OutWindow = new OutWindow();
     int windowSize = Math.Max(this.m_DictionarySize, 0x1000);
     this.m_OutWindow.Create(windowSize);
 }
Пример #8
0
 internal bool Code(int dictionarySize, OutWindow outWindow, SharpCompress.Compressor.LZMA.RangeCoder.Decoder rangeDecoder)
 {
     int num = Math.Max(dictionarySize, 1);
     outWindow.CopyPending();
     while (outWindow.HasSpace)
     {
         uint posState = ((uint) outWindow.Total) & this.m_PosStateMask;
         if (this.m_IsMatchDecoders[(this.state.Index << 4) + posState].Decode(rangeDecoder) == 0)
         {
             byte num3;
             byte @byte = outWindow.GetByte(0);
             if (!this.state.IsCharState())
             {
                 num3 = this.m_LiteralDecoder.DecodeWithMatchByte(rangeDecoder, (uint) outWindow.Total, @byte, outWindow.GetByte((int) this.rep0));
             }
             else
             {
                 num3 = this.m_LiteralDecoder.DecodeNormal(rangeDecoder, (uint) outWindow.Total, @byte);
             }
             outWindow.PutByte(num3);
             this.state.UpdateChar();
         }
         else
         {
             uint num5;
             if (this.m_IsRepDecoders[this.state.Index].Decode(rangeDecoder) == 1)
             {
                 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();
             }
             else
             {
                 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)
                 {
                     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
                 {
                     this.rep0 = num7;
                 }
             }
             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;
 }
Пример #9
0
        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);
        }
Пример #10
0
 public LzmaStream(byte[] properties, Stream inputStream, long inputSize, long outputSize, Stream presetDictionary, bool isLZMA2)
 {
     this.outWindow = new OutWindow();
     this.rangeDecoder = new SharpCompress.Compressor.LZMA.RangeCoder.Decoder();
     this.position = 0L;
     this.endReached = false;
     this.inputPosition = 0L;
     this.uncompressedChunk = false;
     this.needDictReset = true;
     this.needProps = true;
     this.props = new byte[5];
     this.inputStream = inputStream;
     this.inputSize = inputSize;
     this.outputSize = outputSize;
     this.isLZMA2 = isLZMA2;
     if (!isLZMA2)
     {
         this.dictionarySize = BitConverter.ToInt32(properties, 1);
         this.outWindow.Create(this.dictionarySize);
         if (presetDictionary != null)
         {
             this.outWindow.Train(presetDictionary);
         }
         this.rangeDecoder.Init(inputStream);
         this.decoder = new SharpCompress.Compressor.LZMA.Decoder();
         this.decoder.SetDecoderProperties(properties);
         this.props = properties;
         this.availableBytes = (outputSize < 0L) ? 0x7fffffffffffffffL : outputSize;
         this.rangeDecoderLimit = inputSize;
     }
     else
     {
         this.dictionarySize = 2 | (properties[0] & 1);
         this.dictionarySize = this.dictionarySize << ((properties[0] >> 1) + 11);
         this.outWindow.Create(this.dictionarySize);
         if (presetDictionary != null)
         {
             this.outWindow.Train(presetDictionary);
             this.needDictReset = false;
         }
         this.props = new byte[1];
         this.availableBytes = 0L;
     }
 }