Update the 7z installer stub source to 18.05.

Tag #1022

3 files changed, 0 insertions, 670 deletions

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h
deleted file mode 100644
index d53296ee7..000000000
--- a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// 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
deleted file mode 100644
index e5dfb2702..000000000
--- a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-// 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
deleted file mode 100644
index d6370e250..000000000
--- a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.h
+++ /dev/null
@@ -1,251 +0,0 @@
-// 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