Add m-esr52 at 52.6.0

3 files changed, 670 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h
new file mode 100644
index 000000000..d53296ee7
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h
@@ -0,0 +1,82 @@
+// LZMA.h

+

+#ifndef __LZMA_H

+#define __LZMA_H

+

+namespace NCompress {

+namespace NLZMA {

+

+const UInt32 kNumRepDistances = 4;

+

+const int kNumStates = 12;

+

+const Byte kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4,  5,  6,   4, 5};

+const Byte kMatchNextStates[kNumStates]   = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};

+const Byte kRepNextStates[kNumStates]     = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};

+const Byte kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};

+

+class CState

+{

+public:

+  Byte Index;

+  void Init() { Index = 0; }

+  void UpdateChar() { Index = kLiteralNextStates[Index]; }

+  void UpdateMatch() { Index = kMatchNextStates[Index]; }

+  void UpdateRep() { Index = kRepNextStates[Index]; }

+  void UpdateShortRep() { Index = kShortRepNextStates[Index]; }

+  bool IsCharState() const { return Index < 7; }

+};

+

+const int kNumPosSlotBits = 6; 

+const int kDicLogSizeMin = 0; 

+const int kDicLogSizeMax = 32; 

+const int kDistTableSizeMax = kDicLogSizeMax * 2; 

+

+const UInt32 kNumLenToPosStates = 4;

+

+inline UInt32 GetLenToPosState(UInt32 len)

+{

+  len -= 2;

+  if (len < kNumLenToPosStates)

+    return len;

+  return kNumLenToPosStates - 1;

+}

+

+namespace NLength {

+

+const int kNumPosStatesBitsMax = 4;

+const UInt32 kNumPosStatesMax = (1 << kNumPosStatesBitsMax);

+

+const int kNumPosStatesBitsEncodingMax = 4;

+const UInt32 kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);

+

+const int kNumLowBits = 3;

+const int kNumMidBits = 3;

+const int kNumHighBits = 8;

+const UInt32 kNumLowSymbols = 1 << kNumLowBits;

+const UInt32 kNumMidSymbols = 1 << kNumMidBits;

+const UInt32 kNumSymbolsTotal = kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits);

+

+}

+

+const UInt32 kMatchMinLen = 2;

+const UInt32 kMatchMaxLen = kMatchMinLen + NLength::kNumSymbolsTotal - 1;

+

+const int kNumAlignBits = 4;

+const UInt32 kAlignTableSize = 1 << kNumAlignBits;

+const UInt32 kAlignMask = (kAlignTableSize - 1);

+

+const UInt32 kStartPosModelIndex = 4;

+const UInt32 kEndPosModelIndex = 14;

+const UInt32 kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;

+

+const UInt32 kNumFullDistances = 1 << (kEndPosModelIndex / 2);

+

+const int kNumLitPosStatesBitsEncodingMax = 4;

+const int kNumLitContextBitsMax = 8;

+

+const int kNumMoveBits = 5;

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.cpp b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.cpp
new file mode 100644
index 000000000..e5dfb2702
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.cpp
@@ -0,0 +1,337 @@
+// LZMADecoder.cpp

+

+#include "StdAfx.h"

+

+#include "LZMADecoder.h"

+#include "../../../Common/Defs.h"

+

+namespace NCompress {

+namespace NLZMA {

+

+const int kLenIdFinished = -1;

+const int kLenIdNeedInit = -2;

+

+void CDecoder::Init()

+{

+  { 

+    for(int i = 0; i < kNumStates; i++)

+    {

+      for (UInt32 j = 0; j <= _posStateMask; j++)

+      {

+        _isMatch[i][j].Init();

+        _isRep0Long[i][j].Init();

+      }

+      _isRep[i].Init();

+      _isRepG0[i].Init();

+      _isRepG1[i].Init();

+      _isRepG2[i].Init();

+    }

+  }

+  { 

+    for (UInt32 i = 0; i < kNumLenToPosStates; i++)

+    _posSlotDecoder[i].Init();

+  }

+  { 

+    for(UInt32 i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)

+      _posDecoders[i].Init();

+  }

+  _posAlignDecoder.Init();

+  _lenDecoder.Init(_posStateMask + 1);

+  _repMatchLenDecoder.Init(_posStateMask + 1);

+  _literalDecoder.Init();

+

+  _state.Init();

+  _reps[0] = _reps[1] = _reps[2] = _reps[3] = 0;

+}

+

+HRESULT CDecoder::CodeSpec(UInt32 curSize)

+{

+  if (_outSizeDefined)

+  {

+    const UInt64 rem = _outSize - _outWindowStream.GetProcessedSize();

+    if (curSize > rem)

+      curSize = (UInt32)rem;

+  }

+

+  if (_remainLen == kLenIdFinished)

+    return S_OK;

+  if (_remainLen == kLenIdNeedInit)

+  {

+    _rangeDecoder.Init();

+    Init();

+    _remainLen = 0;

+  }

+  if (curSize == 0)

+    return S_OK;

+

+  UInt32 rep0 = _reps[0];

+  UInt32 rep1 = _reps[1];

+  UInt32 rep2 = _reps[2];

+  UInt32 rep3 = _reps[3];

+  CState state = _state;

+  Byte previousByte;

+

+  while(_remainLen > 0 && curSize > 0)

+  {

+    previousByte = _outWindowStream.GetByte(rep0);

+    _outWindowStream.PutByte(previousByte);

+    _remainLen--;

+    curSize--;

+  }

+  UInt64 nowPos64 = _outWindowStream.GetProcessedSize();

+  if (nowPos64 == 0)

+    previousByte = 0;

+  else

+    previousByte = _outWindowStream.GetByte(0);

+

+  while(curSize > 0)

+  {

+    {

+      #ifdef _NO_EXCEPTIONS

+      if (_rangeDecoder.Stream.ErrorCode != S_OK)

+        return _rangeDecoder.Stream.ErrorCode;

+      #endif

+      if (_rangeDecoder.Stream.WasFinished())

+        return S_FALSE;

+      UInt32 posState = UInt32(nowPos64) & _posStateMask;

+      if (_isMatch[state.Index][posState].Decode(&_rangeDecoder) == 0)

+      {

+        if(!state.IsCharState())

+          previousByte = _literalDecoder.DecodeWithMatchByte(&_rangeDecoder, 

+              (UInt32)nowPos64, previousByte, _outWindowStream.GetByte(rep0));

+        else

+          previousByte = _literalDecoder.DecodeNormal(&_rangeDecoder, 

+              (UInt32)nowPos64, previousByte);

+        _outWindowStream.PutByte(previousByte);

+        state.UpdateChar();

+        curSize--;

+        nowPos64++;

+      }

+      else             

+      {

+        UInt32 len;

+        if(_isRep[state.Index].Decode(&_rangeDecoder) == 1)

+        {

+          len = 0;

+          if(_isRepG0[state.Index].Decode(&_rangeDecoder) == 0)

+          {

+            if(_isRep0Long[state.Index][posState].Decode(&_rangeDecoder) == 0)

+            {

+              state.UpdateShortRep();

+              len = 1;

+            }

+          }

+          else

+          {

+            UInt32 distance;

+            if(_isRepG1[state.Index].Decode(&_rangeDecoder) == 0)

+              distance = rep1;

+            else 

+            {

+              if (_isRepG2[state.Index].Decode(&_rangeDecoder) == 0)

+                distance = rep2;

+              else

+              {

+                distance = rep3;

+                rep3 = rep2;

+              }

+              rep2 = rep1;

+            }

+            rep1 = rep0;

+            rep0 = distance;

+          }

+          if (len == 0)

+          {

+            len = _repMatchLenDecoder.Decode(&_rangeDecoder, posState) + kMatchMinLen;

+            state.UpdateRep();

+          }

+        }

+        else

+        {

+          rep3 = rep2;

+          rep2 = rep1;

+          rep1 = rep0;

+          len = kMatchMinLen + _lenDecoder.Decode(&_rangeDecoder, posState);

+          state.UpdateMatch();

+          UInt32 posSlot = _posSlotDecoder[GetLenToPosState(len)].Decode(&_rangeDecoder);

+          if (posSlot >= kStartPosModelIndex)

+          {

+            UInt32 numDirectBits = (posSlot >> 1) - 1;

+            rep0 = ((2 | (posSlot & 1)) << numDirectBits);

+

+            if (posSlot < kEndPosModelIndex)

+              rep0 += NRangeCoder::ReverseBitTreeDecode(_posDecoders + 

+                  rep0 - posSlot - 1, &_rangeDecoder, numDirectBits);

+            else

+            {

+              rep0 += (_rangeDecoder.DecodeDirectBits(

+                  numDirectBits - kNumAlignBits) << kNumAlignBits);

+              rep0 += _posAlignDecoder.ReverseDecode(&_rangeDecoder);

+              if (rep0 == 0xFFFFFFFF)

+              {

+                _remainLen = kLenIdFinished;

+                return S_OK;

+              }

+            }

+          }

+          else

+            rep0 = posSlot;

+        }

+        UInt32 locLen = len;

+        if (len > curSize)

+          locLen = (UInt32)curSize;

+        if (!_outWindowStream.CopyBlock(rep0, locLen))

+          return S_FALSE;

+        previousByte = _outWindowStream.GetByte(0);

+        curSize -= locLen;

+        nowPos64 += locLen;

+        len -= locLen;

+        if (len != 0)

+        {

+          _remainLen = (Int32)len;

+          break;

+        }

+

+        #ifdef _NO_EXCEPTIONS

+        if (_outWindowStream.ErrorCode != S_OK)

+          return _outWindowStream.ErrorCode;

+        #endif

+      }

+    }

+  }

+  if (_rangeDecoder.Stream.WasFinished())

+    return S_FALSE;

+  _reps[0] = rep0;

+  _reps[1] = rep1;

+  _reps[2] = rep2;

+  _reps[3] = rep3;

+  _state = state;

+

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::CodeReal(ISequentialInStream *inStream,

+    ISequentialOutStream *outStream, 

+    const UInt64 *, const UInt64 *outSize,

+    ICompressProgressInfo *progress)

+{

+  SetInStream(inStream);

+  _outWindowStream.SetStream(outStream);

+  SetOutStreamSize(outSize);

+  CDecoderFlusher flusher(this);

+

+  while (true)

+  {

+    UInt32 curSize = 1 << 18;

+    RINOK(CodeSpec(curSize));

+    if (_remainLen == kLenIdFinished)

+      break;

+    if (progress != NULL)

+    {

+      UInt64 inSize = _rangeDecoder.GetProcessedSize();

+      UInt64 nowPos64 = _outWindowStream.GetProcessedSize();

+      RINOK(progress->SetRatioInfo(&inSize, &nowPos64));

+    }

+    if (_outSizeDefined)

+      if (_outWindowStream.GetProcessedSize() >= _outSize)

+        break;

+  } 

+  flusher.NeedFlush = false;

+  return Flush();

+}

+

+

+#ifdef _NO_EXCEPTIONS

+

+#define LZMA_TRY_BEGIN

+#define LZMA_TRY_END

+

+#else

+

+#define LZMA_TRY_BEGIN try { 

+#define LZMA_TRY_END } \

+  catch(const CInBufferException &e)  { return e.ErrorCode; } \

+  catch(const CLZOutWindowException &e)  { return e.ErrorCode; } \

+  catch(...) { return S_FALSE; }

+

+#endif

+

+

+STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress)

+{

+  LZMA_TRY_BEGIN

+  return CodeReal(inStream, outStream, inSize, outSize, progress); 

+  LZMA_TRY_END

+}

+

+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *properties, UInt32 size)

+{

+  if (size < 5)

+    return E_INVALIDARG;

+  int lc = properties[0] % 9;

+  Byte remainder = (Byte)(properties[0] / 9);

+  int lp = remainder % 5;

+  int pb = remainder / 5;

+  if (pb > NLength::kNumPosStatesBitsMax)

+    return E_INVALIDARG;

+  _posStateMask = (1 << pb) - 1;

+  UInt32 dictionarySize = 0;

+  for (int i = 0; i < 4; i++)

+    dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);

+  if (!_outWindowStream.Create(dictionarySize))

+    return E_OUTOFMEMORY;

+  if (!_literalDecoder.Create(lp, lc))

+    return E_OUTOFMEMORY;

+  if (!_rangeDecoder.Create(1 << 20))

+    return E_OUTOFMEMORY;

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)

+{

+  *value = _rangeDecoder.GetProcessedSize();

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)

+{

+  _rangeDecoder.SetStream(inStream);

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::ReleaseInStream()

+{

+  _rangeDecoder.ReleaseStream();

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)

+{

+  if (_outSizeDefined = (outSize != NULL))

+    _outSize = *outSize;

+  _remainLen = kLenIdNeedInit;

+  _outWindowStream.Init();

+  return S_OK;

+}

+

+#ifdef _ST_MODE

+

+STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)

+{

+  LZMA_TRY_BEGIN

+  if (processedSize)

+    *processedSize = 0;

+  const UInt64 startPos = _outWindowStream.GetProcessedSize();

+  _outWindowStream.SetMemStream((Byte *)data);

+  RINOK(CodeSpec(size));

+  if (processedSize)

+    *processedSize = (UInt32)(_outWindowStream.GetProcessedSize() - startPos);

+  return Flush();

+  LZMA_TRY_END

+}

+

+#endif

+

+}}

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.h b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.h
new file mode 100644
index 000000000..d6370e250
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.h
@@ -0,0 +1,251 @@
+// LZMA/Decoder.h

+

+#ifndef __LZMA_DECODER_H

+#define __LZMA_DECODER_H

+

+#include "../../../Common/MyCom.h"

+#include "../../../Common/Alloc.h"

+#include "../../ICoder.h"

+#include "../LZ/LZOutWindow.h"

+#include "../RangeCoder/RangeCoderBitTree.h"

+

+#include "LZMA.h"

+

+namespace NCompress {

+namespace NLZMA {

+

+typedef NRangeCoder::CBitDecoder<kNumMoveBits> CMyBitDecoder;

+

+class CLiteralDecoder2

+{

+  CMyBitDecoder _decoders[0x300];

+public:

+  void Init()

+  {

+    for (int i = 0; i < 0x300; i++)

+      _decoders[i].Init();

+  }

+  Byte DecodeNormal(NRangeCoder::CDecoder *rangeDecoder)

+  {

+    UInt32 symbol = 1;

+    RC_INIT_VAR

+    do

+    {

+      // symbol = (symbol << 1) | _decoders[0][symbol].Decode(rangeDecoder);

+      RC_GETBIT(kNumMoveBits, _decoders[symbol].Prob, symbol)

+    }

+    while (symbol < 0x100);

+    RC_FLUSH_VAR

+    return (Byte)symbol;

+  }

+  Byte DecodeWithMatchByte(NRangeCoder::CDecoder *rangeDecoder, Byte matchByte)

+  {

+    UInt32 symbol = 1;

+    RC_INIT_VAR

+    do

+    {

+      UInt32 matchBit = (matchByte >> 7) & 1;

+      matchByte <<= 1;

+      // UInt32 bit = _decoders[1 + matchBit][symbol].Decode(rangeDecoder);

+      // symbol = (symbol << 1) | bit;

+      UInt32 bit;

+      RC_GETBIT2(kNumMoveBits, _decoders[0x100 + (matchBit << 8) + symbol].Prob, symbol, 

+          bit = 0, bit = 1)

+      if (matchBit != bit)

+      {

+        while (symbol < 0x100)

+        {

+          // symbol = (symbol << 1) | _decoders[0][symbol].Decode(rangeDecoder);

+          RC_GETBIT(kNumMoveBits, _decoders[symbol].Prob, symbol)

+        }

+        break;

+      }

+    }

+    while (symbol < 0x100);

+    RC_FLUSH_VAR

+    return (Byte)symbol;

+  }

+};

+

+class CLiteralDecoder

+{

+  CLiteralDecoder2 *_coders;

+  int _numPrevBits;

+  int _numPosBits;

+  UInt32 _posMask;

+public:

+  CLiteralDecoder(): _coders(0) {}

+  ~CLiteralDecoder()  { Free(); }

+  void Free()

+  { 

+    MyFree(_coders);

+    _coders = 0;

+  }

+  bool Create(int numPosBits, int numPrevBits)

+  {

+    if (_coders == 0 || (numPosBits + numPrevBits) != 

+        (_numPrevBits + _numPosBits) )

+    {

+      Free();

+      UInt32 numStates = 1 << (numPosBits + numPrevBits);

+      _coders = (CLiteralDecoder2 *)MyAlloc(numStates * sizeof(CLiteralDecoder2));

+    }

+    _numPosBits = numPosBits;

+    _posMask = (1 << numPosBits) - 1;

+    _numPrevBits = numPrevBits;

+    return (_coders != 0);

+  }

+  void Init()

+  {

+    UInt32 numStates = 1 << (_numPrevBits + _numPosBits);

+    for (UInt32 i = 0; i < numStates; i++)

+      _coders[i].Init();

+  }

+  UInt32 GetState(UInt32 pos, Byte prevByte) const

+    { return ((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits)); }

+  Byte DecodeNormal(NRangeCoder::CDecoder *rangeDecoder, UInt32 pos, Byte prevByte)

+    { return _coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }

+  Byte DecodeWithMatchByte(NRangeCoder::CDecoder *rangeDecoder, UInt32 pos, Byte prevByte, Byte matchByte)

+    { return _coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }

+};

+

+namespace NLength {

+

+class CDecoder

+{

+  CMyBitDecoder _choice;

+  CMyBitDecoder _choice2;

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumLowBits>  _lowCoder[kNumPosStatesMax];

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumMidBits>  _midCoder[kNumPosStatesMax];

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumHighBits> _highCoder; 

+public:

+  void Init(UInt32 numPosStates)

+  {

+    _choice.Init();

+    _choice2.Init();

+    for (UInt32 posState = 0; posState < numPosStates; posState++)

+    {

+      _lowCoder[posState].Init();

+      _midCoder[posState].Init();

+    }

+    _highCoder.Init();

+  }

+  UInt32 Decode(NRangeCoder::CDecoder *rangeDecoder, UInt32 posState)

+  {

+    if(_choice.Decode(rangeDecoder) == 0)

+      return _lowCoder[posState].Decode(rangeDecoder);

+    if(_choice2.Decode(rangeDecoder) == 0)

+      return kNumLowSymbols + _midCoder[posState].Decode(rangeDecoder);

+    return kNumLowSymbols + kNumMidSymbols + _highCoder.Decode(rangeDecoder);

+  }

+};

+

+}

+

+class CDecoder: 

+  public ICompressCoder,

+  public ICompressSetDecoderProperties2,

+  public ICompressGetInStreamProcessedSize,

+  #ifdef _ST_MODE

+  public ICompressSetInStream,

+  public ICompressSetOutStreamSize,

+  public ISequentialInStream,

+  #endif

+  public CMyUnknownImp

+{

+  CLZOutWindow _outWindowStream;

+  NRangeCoder::CDecoder _rangeDecoder;

+

+  CMyBitDecoder _isMatch[kNumStates][NLength::kNumPosStatesMax];

+  CMyBitDecoder _isRep[kNumStates];

+  CMyBitDecoder _isRepG0[kNumStates];

+  CMyBitDecoder _isRepG1[kNumStates];

+  CMyBitDecoder _isRepG2[kNumStates];

+  CMyBitDecoder _isRep0Long[kNumStates][NLength::kNumPosStatesMax];

+

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumPosSlotBits> _posSlotDecoder[kNumLenToPosStates];

+

+  CMyBitDecoder _posDecoders[kNumFullDistances - kEndPosModelIndex];

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumAlignBits> _posAlignDecoder;

+  

+  NLength::CDecoder _lenDecoder;

+  NLength::CDecoder _repMatchLenDecoder;

+

+  CLiteralDecoder _literalDecoder;

+

+  UInt32 _posStateMask;

+

+  ///////////////////

+  // State

+  UInt32 _reps[4];

+  CState _state;

+  Int32 _remainLen; // -1 means end of stream. // -2 means need Init

+  UInt64 _outSize;

+  bool _outSizeDefined;

+

+  void Init();

+  HRESULT CodeSpec(UInt32 size);

+public:

+

+  #ifdef _ST_MODE

+  MY_UNKNOWN_IMP5(

+      ICompressSetDecoderProperties2, 

+      ICompressGetInStreamProcessedSize,

+      ICompressSetInStream, 

+      ICompressSetOutStreamSize, 

+      ISequentialInStream)

+  #else

+  MY_UNKNOWN_IMP2(

+      ICompressSetDecoderProperties2,

+      ICompressGetInStreamProcessedSize)

+  #endif

+

+  void ReleaseStreams()

+  {

+    _outWindowStream.ReleaseStream();

+    ReleaseInStream();

+  }

+

+  class CDecoderFlusher

+  {

+    CDecoder *_decoder;

+  public:

+    bool NeedFlush;

+    CDecoderFlusher(CDecoder *decoder): _decoder(decoder), NeedFlush(true) {}

+    ~CDecoderFlusher() 

+    { 

+      if (NeedFlush)

+        _decoder->Flush();

+      _decoder->ReleaseStreams(); 

+    }

+  };

+

+  HRESULT Flush() {  return _outWindowStream.Flush(); }  

+

+  STDMETHOD(CodeReal)(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress);

+  

+  STDMETHOD(Code)(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress);

+

+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);

+

+  STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);

+

+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);

+  STDMETHOD(ReleaseInStream)();

+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);

+

+  #ifdef _ST_MODE

+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);

+  #endif

+

+  CDecoder(): _outSizeDefined(false) {}

+  virtual ~CDecoder() {}

+};

+

+}}

+

+#endif