release/src-rt-6.x/linux/linux-2.6/scripts/squashfs/lzma/C/7zip/Compress/LZMA/LZMADecoder.h

   1 // LZMA/Decoder.h
   2
   3 #ifndef __LZMA_DECODER_H
   4 #define __LZMA_DECODER_H
   5
   6 #include "../../../Common/MyCom.h"
   7 #include "../../../Common/Alloc.h"
   8 #include "../../ICoder.h"
   9 #include "../LZ/LZOutWindow.h"
  10 #include "../RangeCoder/RangeCoderBitTree.h"
  11
  12 #include "LZMA.h"
  13
  14 namespace NCompress {
  15 namespace NLZMA {
  16
  17 typedef NRangeCoder::CBitDecoder<kNumMoveBits> CMyBitDecoder;
  18
  19 class CLiteralDecoder2
  20 {
  21   CMyBitDecoder _decoders[0x300];
  22 public:
  23   void Init()
  24   {
  25     for (int i = 0; i < 0x300; i++)
  26       _decoders[i].Init();
  27   }
  28   Byte DecodeNormal(NRangeCoder::CDecoder *rangeDecoder)
  29   {
  30     UInt32 symbol = 1;
  31     RC_INIT_VAR
  32     do
  33     {
  34       // symbol = (symbol << 1) | _decoders[0][symbol].Decode(rangeDecoder);
  35       RC_GETBIT(kNumMoveBits, _decoders[symbol].Prob, symbol)
  36     }
  37     while (symbol < 0x100);
  38     RC_FLUSH_VAR
  39     return (Byte)symbol;
  40   }
  41   Byte DecodeWithMatchByte(NRangeCoder::CDecoder *rangeDecoder, Byte matchByte)
  42   {
  43     UInt32 symbol = 1;
  44     RC_INIT_VAR
  45     do
  46     {
  47       UInt32 matchBit = (matchByte >> 7) & 1;
  48       matchByte <<= 1;
  49       // UInt32 bit = _decoders[1 + matchBit][symbol].Decode(rangeDecoder);
  50       // symbol = (symbol << 1) | bit;
  51       UInt32 bit;
  52       RC_GETBIT2(kNumMoveBits, _decoders[0x100 + (matchBit << 8) + symbol].Prob, symbol,
  53           bit = 0, bit = 1)
  54       if (matchBit != bit)
  55       {
  56         while (symbol < 0x100)
  57         {
  58           // symbol = (symbol << 1) | _decoders[0][symbol].Decode(rangeDecoder);
  59           RC_GETBIT(kNumMoveBits, _decoders[symbol].Prob, symbol)
  60         }
  61         break;
  62       }
  63     }
  64     while (symbol < 0x100);
  65     RC_FLUSH_VAR
  66     return (Byte)symbol;
  67   }
  68 };
  69
  70 class CLiteralDecoder
  71 {
  72   CLiteralDecoder2 *_coders;
  73   int _numPrevBits;
  74   int _numPosBits;
  75   UInt32 _posMask;
  76 public:
  77   CLiteralDecoder(): _coders(0) {}
  78   ~CLiteralDecoder()  { Free(); }
  79   void Free()
  80   {
  81     MyFree(_coders);
  82     _coders = 0;
  83   }
  84   bool Create(int numPosBits, int numPrevBits)
  85   {
  86     if (_coders == 0 || (numPosBits + numPrevBits) !=
  87         (_numPrevBits + _numPosBits) )
  88     {
  89       Free();
  90       UInt32 numStates = 1 << (numPosBits + numPrevBits);
  91       _coders = (CLiteralDecoder2 *)MyAlloc(numStates * sizeof(CLiteralDecoder2));
  92     }
  93     _numPosBits = numPosBits;
  94     _posMask = (1 << numPosBits) - 1;
  95     _numPrevBits = numPrevBits;
  96     return (_coders != 0);
  97   }
  98   void Init()
  99   {
 100     UInt32 numStates = 1 << (_numPrevBits + _numPosBits);
 101     for (UInt32 i = 0; i < numStates; i++)
 102       _coders[i].Init();
 103   }
 104   UInt32 GetState(UInt32 pos, Byte prevByte) const
 105     { return ((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits)); }
 106   Byte DecodeNormal(NRangeCoder::CDecoder *rangeDecoder, UInt32 pos, Byte prevByte)
 107     { return _coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }
 108   Byte DecodeWithMatchByte(NRangeCoder::CDecoder *rangeDecoder, UInt32 pos, Byte prevByte, Byte matchByte)
 109     { return _coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }
 110 };
 111
 112 namespace NLength {
 113
 114 class CDecoder
 115 {
 116   CMyBitDecoder _choice;
 117   CMyBitDecoder _choice2;
 118   NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumLowBits>  _lowCoder[kNumPosStatesMax];
 119   NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumMidBits>  _midCoder[kNumPosStatesMax];
 120   NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumHighBits> _highCoder;
 121 public:
 122   void Init(UInt32 numPosStates)
 123   {
 124     _choice.Init();
 125     _choice2.Init();
 126     for (UInt32 posState = 0; posState < numPosStates; posState++)
 127     {
 128       _lowCoder[posState].Init();
 129       _midCoder[posState].Init();
 130     }
 131     _highCoder.Init();
 132   }
 133   UInt32 Decode(NRangeCoder::CDecoder *rangeDecoder, UInt32 posState)
 134   {
 135     if(_choice.Decode(rangeDecoder) == 0)
 136       return _lowCoder[posState].Decode(rangeDecoder);
 137     if(_choice2.Decode(rangeDecoder) == 0)
 138       return kNumLowSymbols + _midCoder[posState].Decode(rangeDecoder);
 139     return kNumLowSymbols + kNumMidSymbols + _highCoder.Decode(rangeDecoder);
 140   }
 141 };
 142
 143 }
 144
 145 class CDecoder:
 146   public ICompressCoder,
 147   public ICompressSetDecoderProperties2,
 148   #ifdef _ST_MODE
 149   public ICompressSetInStream,
 150   public ICompressSetOutStreamSize,
 151   public ISequentialInStream,
 152   #endif
 153   public CMyUnknownImp
 154 {
 155   CLZOutWindow _outWindowStream;
 156   NRangeCoder::CDecoder _rangeDecoder;
 157
 158   CMyBitDecoder _isMatch[kNumStates][NLength::kNumPosStatesMax];
 159   CMyBitDecoder _isRep[kNumStates];
 160   CMyBitDecoder _isRepG0[kNumStates];
 161   CMyBitDecoder _isRepG1[kNumStates];
 162   CMyBitDecoder _isRepG2[kNumStates];
 163   CMyBitDecoder _isRep0Long[kNumStates][NLength::kNumPosStatesMax];
 164
 165   NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumPosSlotBits> _posSlotDecoder[kNumLenToPosStates];
 166
 167   CMyBitDecoder _posDecoders[kNumFullDistances - kEndPosModelIndex];
 168   NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumAlignBits> _posAlignDecoder;
 169
 170   NLength::CDecoder _lenDecoder;
 171   NLength::CDecoder _repMatchLenDecoder;
 172
 173   CLiteralDecoder _literalDecoder;
 174
 175   UInt32 _posStateMask;
 176
 177   ///////////////////
 178   // State
 179   UInt32 _reps[4];
 180   CState _state;
 181   Int32 _remainLen; // -1 means end of stream. // -2 means need Init
 182   UInt64 _outSize;
 183   bool _outSizeDefined;
 184
 185   void Init();
 186   HRESULT CodeSpec(UInt32 size);
 187 public:
 188
 189   #ifdef _ST_MODE
 190   MY_UNKNOWN_IMP4(
 191       ICompressSetDecoderProperties2,
 192       ICompressSetInStream,
 193       ICompressSetOutStreamSize,
 194       ISequentialInStream)
 195   #else
 196   MY_UNKNOWN_IMP1(
 197       ICompressSetDecoderProperties2)
 198   #endif
 199
 200   void ReleaseStreams()
 201   {
 202     _outWindowStream.ReleaseStream();
 203     ReleaseInStream();
 204   }
 205
 206   class CDecoderFlusher
 207   {
 208     CDecoder *_decoder;
 209   public:
 210     bool NeedFlush;
 211     CDecoderFlusher(CDecoder *decoder): _decoder(decoder), NeedFlush(true) {}
 212     ~CDecoderFlusher()
 213     {
 214       if (NeedFlush)
 215         _decoder->Flush();
 216       _decoder->ReleaseStreams();
 217     }
 218   };
 219
 220   HRESULT Flush() {  return _outWindowStream.Flush(); }
 221
 222   STDMETHOD(CodeReal)(ISequentialInStream *inStream,
 223       ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
 224       ICompressProgressInfo *progress);
 225
 226   STDMETHOD(Code)(ISequentialInStream *inStream,
 227       ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
 228       ICompressProgressInfo *progress);
 229
 230   STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
 231   STDMETHOD(SetDecoderPropertiesRaw)(int lc, int lp, int pb, UInt32 dictionarySize);
 232
 233   STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
 234
 235   STDMETHOD(SetInStream)(ISequentialInStream *inStream);
 236   STDMETHOD(ReleaseInStream)();
 237   STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
 238
 239   #ifdef _ST_MODE
 240   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
 241   #endif
 242
 243   CDecoder(): _outSizeDefined(false) {}
 244   virtual ~CDecoder() {}
 245 };
 246
 247 }}
 248
 249 #endif