18.03

CPP/7zip/Compress/DeflateEncoder.cpp

@@ -969,6 +969,10 @@ HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *ou
     }
   }
   while (Inline_MatchFinder_GetNumAvailableBytes(&_lzInWindow) != 0);
+  
+  if (_seqInStream.Res != S_OK)
+    return _seqInStream.Res;
+
   if (_lzInWindow.result != SZ_OK)
     return SResToHRESULT(_lzInWindow.result);
   return m_OutStream.Flush();

CPP/7zip/Compress/Lzma2Decoder.cpp

@@ -2,81 +2,48 @@
 
 #include "StdAfx.h"
 
+// #include <stdio.h>
+
 #include "../../../C/Alloc.h"
+// #include "../../../C/CpuTicks.h"
 
 #include "../Common/StreamUtils.h"
 
 #include "Lzma2Decoder.h"
 
-static HRESULT SResToHRESULT(SRes res)
-{
-  switch (res)
-  {
-    case SZ_OK: return S_OK;
-    case SZ_ERROR_MEM: return E_OUTOFMEMORY;
-    case SZ_ERROR_PARAM: return E_INVALIDARG;
-    case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
-    case SZ_ERROR_DATA: return S_FALSE;
-  }
-  return E_FAIL;
-}
-
 namespace NCompress {
 namespace NLzma2 {
 
 CDecoder::CDecoder():
-    _inBuf(NULL),
-    _finishMode(false),
-    _outSizeDefined(false),
-    _outStep(1 << 22),
-    _inBufSize(0),
-    _inBufSizeNew(1 << 20)
-{
-  Lzma2Dec_Construct(&_state);
-}
+      _dec(NULL)
+    , _inProcessed(0)
+    , _prop(0xFF)
+    , _finishMode(false)
+    , _inBufSize(1 << 20)
+    , _outStep(1 << 20)
+    #ifndef _7ZIP_ST
+    , _tryMt(1)
+    , _numThreads(1)
+    , _memUsage((UInt64)(sizeof(size_t)) << 28)
+    #endif
+{}
 
 CDecoder::~CDecoder()
 {
-  Lzma2Dec_Free(&_state, &g_Alloc);
-  MidFree(_inBuf);
+  if (_dec)
+    Lzma2DecMt_Destroy(_dec);
 }
 
-STDMETHODIMP CDecoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSizeNew = size; return S_OK; }
+STDMETHODIMP CDecoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSize = size; return S_OK; }
 STDMETHODIMP CDecoder::SetOutBufSize(UInt32 , UInt32 size) { _outStep = size; return S_OK; }
 
 STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
 {
   if (size != 1)
     return E_NOTIMPL;
-  
-  RINOK(SResToHRESULT(Lzma2Dec_Allocate(&_state, prop[0], &g_Alloc)));
-  
-  if (!_inBuf || _inBufSize != _inBufSizeNew)
-  {
-    MidFree(_inBuf);
-    _inBufSize = 0;
-    _inBuf = (Byte *)MidAlloc(_inBufSizeNew);
-    if (!_inBuf)
-      return E_OUTOFMEMORY;
-    _inBufSize = _inBufSizeNew;
-  }
-
-  return S_OK;
-}
-
-
-STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
-{
-  _outSizeDefined = (outSize != NULL);
-  _outSize = 0;
-  if (_outSizeDefined)
-    _outSize = *outSize;
-  _inPos = _inLim = 0;
-  _inProcessed = 0;
-  _outProcessed = 0;
-
-  Lzma2Dec_Init(&_state);
-
+  if (prop[0] > 40)
+    return E_NOTIMPL;
+  _prop = prop[0];
   return S_OK;
 }
 
@@ -88,6 +55,137 @@ STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
 }
 
 
+
+#ifndef _7ZIP_ST
+
+static UInt64 Get_ExpectedBlockSize_From_Dict(UInt32 dictSize)
+{
+  const UInt32 kMinSize = (UInt32)1 << 20;
+  const UInt32 kMaxSize = (UInt32)1 << 28;
+  UInt64 blockSize = (UInt64)dictSize << 2;
+  if (blockSize < kMinSize) blockSize = kMinSize;
+  if (blockSize > kMaxSize) blockSize = kMaxSize;
+  if (blockSize < dictSize) blockSize = dictSize;
+  blockSize += (kMinSize - 1);
+  blockSize &= ~(UInt64)(kMinSize - 1);
+  return blockSize;
+}
+
+#define LZMA2_DIC_SIZE_FROM_PROP_FULL(p) ((p) == 40 ? 0xFFFFFFFF : (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11)))
+
+#endif
+
+#define RET_IF_WRAP_ERROR_CONFIRMED(wrapRes, sRes, sResErrorCode) \
+  if (wrapRes != S_OK && sRes == sResErrorCode) return wrapRes;
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+  if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+  _inProcessed = 0;
+
+  if (!_dec)
+  {
+    _dec = Lzma2DecMt_Create(
+      // &g_AlignedAlloc,
+      &g_Alloc,
+      &g_MidAlloc);
+    if (!_dec)
+      return E_OUTOFMEMORY;
+  }
+
+  CLzma2DecMtProps props;
+  Lzma2DecMtProps_Init(&props);
+
+  props.inBufSize_ST = _inBufSize;
+  props.outStep_ST = _outStep;
+
+  #ifndef _7ZIP_ST
+  {
+    props.numThreads = 1;
+    UInt32 numThreads = _numThreads;
+
+    if (_tryMt && numThreads >= 1)
+    {
+      UInt64 useLimit = _memUsage;
+      UInt32 dictSize = LZMA2_DIC_SIZE_FROM_PROP_FULL(_prop);
+      UInt64 expectedBlockSize64 = Get_ExpectedBlockSize_From_Dict(dictSize);
+      size_t expectedBlockSize = (size_t)expectedBlockSize64;
+      size_t inBlockMax = expectedBlockSize + expectedBlockSize / 16;
+      if (expectedBlockSize == expectedBlockSize64 && inBlockMax >= expectedBlockSize)
+      {
+        props.outBlockMax = expectedBlockSize;
+        props.inBlockMax = inBlockMax;
+        const size_t kOverheadSize = props.inBufSize_MT + (1 << 16);
+        UInt64 okThreads = useLimit / (props.outBlockMax + props.inBlockMax + kOverheadSize);
+        if (numThreads > okThreads)
+          numThreads = (UInt32)okThreads;
+        if (numThreads == 0)
+          numThreads = 1;
+        props.numThreads = numThreads;
+      }
+    }
+  }
+  #endif
+
+  CSeqInStreamWrap inWrap;
+  CSeqOutStreamWrap outWrap;
+  CCompressProgressWrap progressWrap;
+
+  inWrap.Init(inStream);
+  outWrap.Init(outStream);
+  progressWrap.Init(progress);
+
+  SRes res;
+
+  UInt64 inProcessed = 0;
+  int isMT = False;
+
+  #ifndef _7ZIP_ST
+  isMT = _tryMt;
+  #endif
+
+  // UInt64 cpuTicks = GetCpuTicks();
+
+  res = Lzma2DecMt_Decode(_dec, _prop, &props,
+      &outWrap.vt, outSize, _finishMode,
+      &inWrap.vt,
+      &inProcessed,
+      &isMT,
+      progress ? &progressWrap.vt : NULL);
+
+  /*
+  cpuTicks = GetCpuTicks() - cpuTicks;
+  printf("\n             ticks = %10I64u\n", cpuTicks / 1000000);
+  */
+
+
+  #ifndef _7ZIP_ST
+  /* we reset _tryMt, only if p->props.numThreads was changed */
+  if (props.numThreads > 1)
+    _tryMt = isMT;
+  #endif
+
+  _inProcessed = inProcessed;
+
+  RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+  RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+  RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
+
+  if (res == SZ_OK && _finishMode)
+  {
+    if (inSize && *inSize != inProcessed)
+      res = SZ_ERROR_DATA;
+    if (outSize && *outSize != outWrap.Processed)
+      res = SZ_ERROR_DATA;
+  }
+
+  return SResToHRESULT(res);
+}
+
+
 STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
 {
   *value = _inProcessed;
@@ -95,109 +193,51 @@ STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
 }
 
 
-STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+#ifndef _7ZIP_ST
+
+STDMETHODIMP CDecoder::SetNumberOfThreads(UInt32 numThreads)
 {
-  if (!_inBuf)
-    return S_FALSE;
-
-  SetOutStreamSize(outSize);
-
-  SizeT wrPos = _state.decoder.dicPos;
-  HRESULT readRes = S_OK;
-
-  for (;;)
-  {
-    if (_inPos == _inLim && readRes == S_OK)
-    {
-      _inPos = _inLim = 0;
-      readRes = inStream->Read(_inBuf, _inBufSize, &_inLim);
-    }
-
-    const SizeT dicPos = _state.decoder.dicPos;
-    SizeT size;
-    {
-      SizeT next = _state.decoder.dicBufSize;
-      if (next - wrPos > _outStep)
-        next = wrPos + _outStep;
-      size = next - dicPos;
-    }
-
-    ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
-    if (_outSizeDefined)
-    {
-      const UInt64 rem = _outSize - _outProcessed;
-      if (size >= rem)
-      {
-        size = (SizeT)rem;
-        if (_finishMode)
-          finishMode = LZMA_FINISH_END;
-      }
-    }
-
-    SizeT inProcessed = _inLim - _inPos;
-    ELzmaStatus status;
-    
-    SRes res = Lzma2Dec_DecodeToDic(&_state, dicPos + size, _inBuf + _inPos, &inProcessed, finishMode, &status);
-
-    
-    _inPos += (UInt32)inProcessed;
-    _inProcessed += inProcessed;
-    const SizeT outProcessed = _state.decoder.dicPos - dicPos;
-    _outProcessed += outProcessed;
-
-    
-    bool outFinished = (_outSizeDefined && _outProcessed >= _outSize);
-
-    bool needStop = (res != 0
-        || (inProcessed == 0 && outProcessed == 0)
-        || status == LZMA_STATUS_FINISHED_WITH_MARK
-        || (!_finishMode && outFinished));
-
-    if (needStop || outProcessed >= size)
-    {
-      HRESULT res2 = WriteStream(outStream, _state.decoder.dic + wrPos, _state.decoder.dicPos - wrPos);
-
-      if (_state.decoder.dicPos == _state.decoder.dicBufSize)
-        _state.decoder.dicPos = 0;
-      wrPos = _state.decoder.dicPos;
-
-      RINOK(res2);
-
-      if (needStop)
-      {
-        if (res != 0)
-          return S_FALSE;
-
-        if (status == LZMA_STATUS_FINISHED_WITH_MARK)
-        {
-          if (_finishMode)
-          {
-            if (inSize && *inSize != _inProcessed)
-              return S_FALSE;
-            if (_outSizeDefined && _outSize != _outProcessed)
-              return S_FALSE;
-          }
-          return readRes;
-        }
-
-        if (!_finishMode && outFinished)
-          return readRes;
-   
-        return S_FALSE;
-      }
-    }
-    
-    if (progress)
-    {
-      RINOK(progress->SetRatioInfo(&_inProcessed, &_outProcessed));
-    }
-  }
+  _numThreads = numThreads;
+  return S_OK;
 }
 
+STDMETHODIMP CDecoder::SetMemLimit(UInt64 memUsage)
+{
+  _memUsage = memUsage;
+  return S_OK;
+}
+
+#endif
+
 
 #ifndef NO_READ_FROM_CODER
 
+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
+{
+  CLzma2DecMtProps props;
+  Lzma2DecMtProps_Init(&props);
+  props.inBufSize_ST = _inBufSize;
+  props.outStep_ST = _outStep;
+
+  _inProcessed = 0;
+
+  if (!_dec)
+  {
+    _dec = Lzma2DecMt_Create(&g_AlignedAlloc, &g_MidAlloc);
+    if (!_dec)
+      return E_OUTOFMEMORY;
+  }
+
+  _inWrap.Init(_inStream);
+
+  SRes res = Lzma2DecMt_Init(_dec, _prop, &props, outSize, _finishMode, &_inWrap.vt);
+
+  if (res != SZ_OK)
+    return SResToHRESULT(res);
+  return S_OK;
+}
+
+
 STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { _inStream = inStream; return S_OK; }
 STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
   
@@ -207,62 +247,17 @@ STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
   if (processedSize)
     *processedSize = 0;
 
-  ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
-  if (_outSizeDefined)
-  {
-    const UInt64 rem = _outSize - _outProcessed;
-    if (size >= rem)
-    {
-      size = (UInt32)rem;
-      if (_finishMode)
-        finishMode = LZMA_FINISH_END;
-    }
-  }
+  size_t size2 = size;
+  UInt64 inProcessed = 0;
 
-  HRESULT readRes = S_OK;
+  SRes res = Lzma2DecMt_Read(_dec, (Byte *)data, &size2, &inProcessed);
 
-  for (;;)
-  {
-    if (_inPos == _inLim && readRes == S_OK)
-    {
-      _inPos = _inLim = 0;
-      readRes = _inStream->Read(_inBuf, _inBufSize, &_inLim);
-    }
-    
-    SizeT inProcessed = _inLim - _inPos;
-    SizeT outProcessed = size;
-    ELzmaStatus status;
-
-    SRes res = Lzma2Dec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
-        _inBuf + _inPos, &inProcessed, finishMode, &status);
-    
-    
-    _inPos += (UInt32)inProcessed;
-    _inProcessed += inProcessed;
-    _outProcessed += outProcessed;
-    size -= (UInt32)outProcessed;
-    data = (Byte *)data + outProcessed;
-    if (processedSize)
-      *processedSize += (UInt32)outProcessed;
-    
-    if (res != 0)
-      return S_FALSE;
-    
-    /*
-    if (status == LZMA_STATUS_FINISHED_WITH_MARK)
-      return readRes;
-
-    if (size == 0 && status != LZMA_STATUS_NEEDS_MORE_INPUT)
-    {
-      if (_finishMode && _outSizeDefined && _outProcessed >= _outSize)
-        return S_FALSE;
-      return readRes;
-    }
-    */
-
-    if (inProcessed == 0 && outProcessed == 0)
-      return readRes;
-  }
+  _inProcessed += inProcessed;
+  if (processedSize)
+    *processedSize = (UInt32)size2;
+  if (res != SZ_OK)
+    return SResToHRESULT(res);
+  return S_OK;
 }
 
 #endif

CPP/7zip/Compress/Lzma2Decoder.h

@@ -3,10 +3,9 @@
 #ifndef __LZMA2_DECODER_H
 #define __LZMA2_DECODER_H
 
-#include "../../../C/Lzma2Dec.h"
+#include "../../../C/Lzma2DecMt.h"
 
-#include "../../Common/MyCom.h"
-#include "../ICoder.h"
+#include "../Common/CWrappers.h"
 
 namespace NCompress {
 namespace NLzma2 {
@@ -17,28 +16,26 @@ class CDecoder:
   public ICompressSetFinishMode,
   public ICompressGetInStreamProcessedSize,
   public ICompressSetBufSize,
+
   #ifndef NO_READ_FROM_CODER
   public ICompressSetInStream,
   public ICompressSetOutStreamSize,
   public ISequentialInStream,
   #endif
+
+  #ifndef _7ZIP_ST
+  public ICompressSetCoderMt,
+  public ICompressSetMemLimit,
+  #endif
+
   public CMyUnknownImp
 {
-  Byte *_inBuf;
-  UInt32 _inPos;
-  UInt32 _inLim;
-
-  bool _finishMode;
-  bool _outSizeDefined;
-  UInt64 _outSize;
+  CLzma2DecMtHandle _dec;
   UInt64 _inProcessed;
-  UInt64 _outProcessed;
-  
-  UInt32 _outStep;
+  Byte _prop;
+  int _finishMode;
   UInt32 _inBufSize;
-  UInt32 _inBufSizeNew;
-
-  CLzma2Dec _state;
+  UInt32 _outStep;
 
 public:
   MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
@@ -46,11 +43,18 @@ public:
   MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
   MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
   MY_QUERYINTERFACE_ENTRY(ICompressSetBufSize)
+  
   #ifndef NO_READ_FROM_CODER
   MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
   MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
   MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
   #endif
+  
+  #ifndef _7ZIP_ST
+  MY_QUERYINTERFACE_ENTRY(ICompressSetCoderMt)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetMemLimit)
+  #endif
+  
   MY_QUERYINTERFACE_END
   MY_ADDREF_RELEASE
 
@@ -59,20 +63,28 @@ public:
   STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
   STDMETHOD(SetFinishMode)(UInt32 finishMode);
   STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
-  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
   STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
   STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
 
-  #ifndef NO_READ_FROM_CODER
+  #ifndef _7ZIP_ST
+private:
+  int _tryMt;
+  UInt32 _numThreads;
+  UInt64 _memUsage;
+public:
+  STDMETHOD(SetNumberOfThreads)(UInt32 numThreads);
+  STDMETHOD(SetMemLimit)(UInt64 memUsage);
+  #endif
 
+  #ifndef NO_READ_FROM_CODER
 private:
   CMyComPtr<ISequentialInStream> _inStream;
+  CSeqInStreamWrap _inWrap;
 public:
-
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
   STDMETHOD(SetInStream)(ISequentialInStream *inStream);
   STDMETHOD(ReleaseInStream)();
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-
   #endif
 
   CDecoder();

CPP/7zip/Compress/LzmaDecoder.cpp

@@ -30,19 +30,24 @@ CDecoder::CDecoder():
     FinishStream(false),
     _propsWereSet(false),
     _outSizeDefined(false),
-    _outStep(1 << 22),
+    _outStep(1 << 20),
     _inBufSize(0),
     _inBufSizeNew(1 << 20)
 {
   _inProcessed = 0;
   _inPos = _inLim = 0;
 
+  /*
+  AlignOffsetAlloc_CreateVTable(&_alloc);
+  _alloc.numAlignBits = 7;
+  _alloc.offset = 0;
+  */
   LzmaDec_Construct(&_state);
 }
 
 CDecoder::~CDecoder()
 {
-  LzmaDec_Free(&_state, &g_Alloc);
+  LzmaDec_Free(&_state, &g_AlignedAlloc); // &_alloc.vt
   MyFree(_inBuf);
 }
 
@@ -66,7 +71,7 @@ HRESULT CDecoder::CreateInputBuffer()
 
 STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
 {
-  RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_Alloc)));
+  RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_AlignedAlloc))) // &_alloc.vt
   _propsWereSet = true;
   return CreateInputBuffer();
 }

CPP/7zip/Compress/LzmaDecoder.h

@@ -3,6 +3,7 @@
 #ifndef __LZMA_DECODER_H
 #define __LZMA_DECODER_H
 
+// #include "../../../C/Alloc.h"
 #include "../../../C/LzmaDec.h"
 
 #include "../../Common/MyCom.h"
@@ -28,7 +29,6 @@ class CDecoder:
   UInt32 _inPos;
   UInt32 _inLim;
  
-  CLzmaDec _state;
   ELzmaStatus _lzmaStatus;
 
 public:
@@ -45,6 +45,10 @@ private:
   UInt32 _inBufSize;
   UInt32 _inBufSizeNew;
 
+  // CAlignOffsetAlloc _alloc;
+
+  CLzmaDec _state;
+
   HRESULT CreateInputBuffer();
   HRESULT CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
   void SetOutStreamSizeResume(const UInt64 *outSize);

CPP/7zip/Compress/XzDecoder.cpp

@@ -4,248 +4,119 @@
 
 #include "../../../C/Alloc.h"
 
-#include "../Common/StreamUtils.h"
-
-#include "../Archive/IArchive.h"
+#include "../Common/CWrappers.h"
 
 #include "XzDecoder.h"
 
-using namespace NArchive;
-
 namespace NCompress {
 namespace NXz {
 
+#define RET_IF_WRAP_ERROR_CONFIRMED(wrapRes, sRes, sResErrorCode) \
+  if (wrapRes != S_OK && sRes == sResErrorCode) return wrapRes;
 
-CXzUnpackerCPP::CXzUnpackerCPP(): InBuf(NULL), OutBuf(NULL)
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+  if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+static HRESULT SResToHRESULT_Code(SRes res) throw()
 {
-  XzUnpacker_Construct(&p, &g_Alloc);
-}
-
-CXzUnpackerCPP::~CXzUnpackerCPP()
-{
-  XzUnpacker_Free(&p);
-  MidFree(InBuf);
-  MidFree(OutBuf);
-}
-
-
-void CStatInfo::Clear()
-{
-  InSize = 0;
-  OutSize = 0;
-  PhySize = 0;
-  
-  NumStreams = 0;
-  NumBlocks = 0;
-  
-  UnpackSize_Defined = false;
-  
-  NumStreams_Defined = false;
-  NumBlocks_Defined = false;
-  
-  IsArc = false;
-  UnexpectedEnd = false;
-  DataAfterEnd = false;
-  Unsupported = false;
-  HeadersError = false;
-  DataError = false;
-  CrcError = false;
+  if (res < 0)
+    return res;
+  switch (res)
+  {
+    case SZ_OK: return S_OK;
+    case SZ_ERROR_MEM: return E_OUTOFMEMORY;
+    case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
+  }
+  return S_FALSE;
 }
 
 
 HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
     const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *progress)
 {
-  const size_t kInBufSize = (size_t)1 << 20;
-  const size_t kOutBufSize = (size_t)1 << 21;
+  MainDecodeSRes = S_OK;
+  MainDecodeSRes_wasUsed = false;
+  XzStatInfo_Clear(&Stat);
 
-  Clear();
-  DecodeRes = SZ_OK;
-
-  XzUnpacker_Init(&xzu.p);
-
-  if (!xzu.InBuf)
+  if (!xz)
   {
-    xzu.InBuf = (Byte *)MidAlloc(kInBufSize);
-    if (!xzu.InBuf)
+    xz = XzDecMt_Create(&g_Alloc, &g_MidAlloc);
+    if (!xz)
       return E_OUTOFMEMORY;
   }
-  if (!xzu.OutBuf)
-  {
-    xzu.OutBuf = (Byte *)MidAlloc(kOutBufSize);
-    if (!xzu.OutBuf)
-      return E_OUTOFMEMORY;
-  }
-  
-  UInt32 inSize = 0;
-  UInt32 inPos = 0;
-  SizeT outPos = 0;
 
-  HRESULT readRes = S_OK;
+  CXzDecMtProps props;
+  XzDecMtProps_Init(&props);
 
-  for (;;)
+  int isMT = False;
+
+  #ifndef _7ZIP_ST
   {
-    if (inPos == inSize && readRes == S_OK)
+    props.numThreads = 1;
+    UInt32 numThreads = _numThreads;
+
+    if (_tryMt && numThreads > 1)
     {
-      inPos = inSize = 0;
-      readRes = seqInStream->Read(xzu.InBuf, kInBufSize, &inSize);
+      size_t memUsage = (size_t)_memUsage;
+      if (memUsage != _memUsage)
+        memUsage = (size_t)0 - 1;
+      props.memUseMax = memUsage;
+      isMT = (numThreads > 1);
     }
 
-    SizeT inLen = inSize - inPos;
-    SizeT outLen = kOutBufSize - outPos;
-    ECoderFinishMode finishMode = CODER_FINISH_ANY;
+    props.numThreads = numThreads;
+  }
+  #endif
 
+  CSeqInStreamWrap inWrap;
+  CSeqOutStreamWrap outWrap;
+  CCompressProgressWrap progressWrap;
+
+  inWrap.Init(seqInStream);
+  outWrap.Init(outStream);
+  progressWrap.Init(progress);
+
+  SRes res = XzDecMt_Decode(xz,
+      &props,
+      outSizeLimit, finishStream,
+      &outWrap.vt,
+      &inWrap.vt,
+      &Stat,
+      &isMT,
+      progress ? &progressWrap.vt : NULL);
+
+  MainDecodeSRes = res;
+
+  #ifndef _7ZIP_ST
+  // _tryMt = isMT;
+  #endif
+
+  RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+  RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+  RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
+
+  // return E_OUTOFMEMORY;
+
+  MainDecodeSRes_wasUsed = true;
+
+  if (res == SZ_OK && finishStream)
+  {
     /*
-    // 17.01 : the code was disabled:
-    if (inSize == 0)
-      finishMode = CODER_FINISH_END;
+    if (inSize && *inSize != Stat.PhySize)
+      res = SZ_ERROR_DATA;
     */
-
-    if (outSizeLimit)
-    {
-      const UInt64 rem = *outSizeLimit - OutSize;
-      if (outLen >= rem)
-      {
-        outLen = (SizeT)rem;
-        if (finishStream)
-          finishMode = CODER_FINISH_END;
-      }
-    }
-    
-    ECoderStatus status;
-
-    const SizeT outLenRequested = outLen;
-
-    SRes res = XzUnpacker_Code(&xzu.p,
-        xzu.OutBuf + outPos, &outLen,
-        xzu.InBuf + inPos, &inLen,
-        finishMode, &status);
-
-    DecodeRes = res;
-
-    inPos += (UInt32)inLen;
-    outPos += outLen;
-
-    InSize += inLen;
-    OutSize += outLen;
-
-    bool finished = ((inLen == 0 && outLen == 0) || res != SZ_OK);
-
-    if (outLen >= outLenRequested || finished)
-    {
-      if (outStream && outPos != 0)
-      {
-        RINOK(WriteStream(outStream, xzu.OutBuf, outPos));
-      }
-      outPos = 0;
-    }
-    
-    if (progress)
-    {
-      RINOK(progress->SetRatioInfo(&InSize, &OutSize));
-    }
-    
-    if (!finished)
-      continue;
-
-    {
-      PhySize = InSize;
-      NumStreams = xzu.p.numStartedStreams;
-      if (NumStreams > 0)
-        IsArc = true;
-      NumBlocks = xzu.p.numTotalBlocks;
-
-      UnpackSize_Defined = true;
-      NumStreams_Defined = true;
-      NumBlocks_Defined = true;
-
-      UInt64 extraSize = XzUnpacker_GetExtraSize(&xzu.p);
-
-      if (res == SZ_OK)
-      {
-        if (status == CODER_STATUS_NEEDS_MORE_INPUT)
-        {
-          extraSize = 0;
-          if (!XzUnpacker_IsStreamWasFinished(&xzu.p))
-          {
-            // finished at padding bytes, but padding is not aligned for 4
-            UnexpectedEnd = true;
-            res = SZ_ERROR_DATA;
-          }
-        }
-        else // status == CODER_STATUS_NOT_FINISHED
-          res = SZ_ERROR_DATA;
-      }
-      else if (res == SZ_ERROR_NO_ARCHIVE)
-      {
-        if (InSize == extraSize)
-          IsArc = false;
-        else
-        {
-          if (extraSize != 0 || inPos != inSize)
-          {
-            DataAfterEnd = true;
-            res = SZ_OK;
-          }
-        }
-      }
-
-      DecodeRes = res;
-      PhySize -= extraSize;
-
-      switch (res)
-      {
-        case SZ_OK: break;
-        case SZ_ERROR_NO_ARCHIVE: IsArc = false; break;
-        case SZ_ERROR_ARCHIVE: HeadersError = true; break;
-        case SZ_ERROR_UNSUPPORTED: Unsupported = true; break;
-        case SZ_ERROR_CRC: CrcError = true; break;
-        case SZ_ERROR_DATA: DataError = true; break;
-        default: DataError = true; break;
-      }
-
-      return readRes;
-    }
+    if (outSizeLimit && *outSizeLimit != outWrap.Processed)
+      res = SZ_ERROR_DATA;
   }
+
+  return SResToHRESULT_Code(res);
 }
 
 
-Int32 CDecoder::Get_Extract_OperationResult() const
-{
-  Int32 opRes;
-  if (!IsArc)
-    opRes = NExtract::NOperationResult::kIsNotArc;
-  else if (UnexpectedEnd)
-    opRes = NExtract::NOperationResult::kUnexpectedEnd;
-  else if (DataAfterEnd)
-    opRes = NExtract::NOperationResult::kDataAfterEnd;
-  else if (CrcError)
-    opRes = NExtract::NOperationResult::kCRCError;
-  else if (Unsupported)
-    opRes = NExtract::NOperationResult::kUnsupportedMethod;
-  else if (HeadersError)
-    opRes = NExtract::NOperationResult::kDataError;
-  else if (DataError)
-    opRes = NExtract::NOperationResult::kDataError;
-  else if (DecodeRes != SZ_OK)
-    opRes = NExtract::NOperationResult::kDataError;
-  else
-    opRes = NExtract::NOperationResult::kOK;
-  return opRes;
-}
-
-
-
 HRESULT CComDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
     const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
 {
-  RINOK(_decoder.Decode(inStream, outStream, outSize, _finishStream, progress));
-  Int32 opRes = _decoder.Get_Extract_OperationResult();
-  if (opRes == NArchive::NExtract::NOperationResult::kUnsupportedMethod)
-    return E_NOTIMPL;
-  if (opRes != NArchive::NExtract::NOperationResult::kOK)
-    return S_FALSE;
-  return S_OK;
+  return Decode(inStream, outStream, outSize, _finishStream, progress);
 }
 
 STDMETHODIMP CComDecoder::SetFinishMode(UInt32 finishMode)
@@ -256,8 +127,24 @@ STDMETHODIMP CComDecoder::SetFinishMode(UInt32 finishMode)
 
 STDMETHODIMP CComDecoder::GetInStreamProcessedSize(UInt64 *value)
 {
-  *value = _decoder.InSize;
+  *value = Stat.InSize;
   return S_OK;
 }
 
+#ifndef _7ZIP_ST
+
+STDMETHODIMP CComDecoder::SetNumberOfThreads(UInt32 numThreads)
+{
+  _numThreads = numThreads;
+  return S_OK;
+}
+
+STDMETHODIMP CComDecoder::SetMemLimit(UInt64 memUsage)
+{
+  _memUsage = memUsage;
+  return S_OK;
+}
+
+#endif
+
 }}

CPP/7zip/Compress/XzDecoder.h

@@ -12,57 +12,36 @@
 namespace NCompress {
 namespace NXz {
 
-struct CXzUnpackerCPP
+struct CDecoder
 {
-  Byte *InBuf;
-  Byte *OutBuf;
-  CXzUnpacker p;
+  CXzDecMtHandle xz;
+  int _tryMt;
+  UInt32 _numThreads;
+  UInt64 _memUsage;
+
+  SRes MainDecodeSRes; // it's not HRESULT
+  bool MainDecodeSRes_wasUsed;
+  CXzStatInfo Stat;
+
+  CDecoder():
+      xz(NULL),
+      _tryMt(True),
+      _numThreads(1),
+      _memUsage((UInt64)(sizeof(size_t)) << 28),
+      MainDecodeSRes(SZ_OK),
+      MainDecodeSRes_wasUsed(false)
+    {}
   
-  CXzUnpackerCPP();
-  ~CXzUnpackerCPP();
-};
-
-
-struct CStatInfo
-{
-  UInt64 InSize;
-  UInt64 OutSize;
-  UInt64 PhySize;
-
-  UInt64 NumStreams;
-  UInt64 NumBlocks;
-
-  bool UnpackSize_Defined;
-
-  bool NumStreams_Defined;
-  bool NumBlocks_Defined;
-
-  bool IsArc;
-  bool UnexpectedEnd;
-  bool DataAfterEnd;
-  bool Unsupported;
-  bool HeadersError;
-  bool DataError;
-  bool CrcError;
-
-  CStatInfo() { Clear(); }
-
-  void Clear();
-};
-
-
-struct CDecoder: public CStatInfo
-{
-  CXzUnpackerCPP xzu;
-  SRes DecodeRes; // it's not HRESULT
-
-  CDecoder(): DecodeRes(SZ_OK) {}
+  ~CDecoder()
+  {
+    if (xz)
+      XzDecMt_Destroy(xz);
+  }
 
   /* Decode() can return ERROR code only if there is progress or stream error.
      Decode() returns S_OK in case of xz decoding error, but DecodeRes and CStatInfo contain error information */
   HRESULT Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
       const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *compressProgress);
-  Int32 Get_Extract_OperationResult() const;
 };
 
 
@@ -70,21 +49,41 @@ class CComDecoder:
   public ICompressCoder,
   public ICompressSetFinishMode,
   public ICompressGetInStreamProcessedSize,
-  public CMyUnknownImp
+
+  #ifndef _7ZIP_ST
+  public ICompressSetCoderMt,
+  public ICompressSetMemLimit,
+  #endif
+
+  public CMyUnknownImp,
+  public CDecoder
 {
-  CDecoder _decoder;
   bool _finishStream;
 
 public:
-  MY_UNKNOWN_IMP2(
-      ICompressSetFinishMode,
-      ICompressGetInStreamProcessedSize)
+  MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
+
+  MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
+  MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
+
+  #ifndef _7ZIP_ST
+  MY_QUERYINTERFACE_ENTRY(ICompressSetCoderMt)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetMemLimit)
+  #endif
   
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
+
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
   STDMETHOD(SetFinishMode)(UInt32 finishMode);
   STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
 
+  #ifndef _7ZIP_ST
+  STDMETHOD(SetNumberOfThreads)(UInt32 numThreads);
+  STDMETHOD(SetMemLimit)(UInt64 memUsage);
+  #endif
+
   CComDecoder(): _finishStream(false) {}
 };