seven-zip 1.4.1 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Compress/BZip2Decoder.h

@@ -23,6 +23,9 @@
 namespace NCompress {
 namespace NBZip2 {
 
+bool IsEndSig(const Byte *p) throw();
+bool IsBlockSig(const Byte *p) throw();
+
 typedef NCompress::NHuffman::CDecoder<kMaxHuffmanLen, kMaxAlphaSize> CHuffmanDecoder;
 
 class CDecoder;
@@ -57,6 +60,40 @@ struct CState
   void Free();
 };
 
+struct CBlockProps
+{
+  UInt32 blockSize;
+  UInt32 origPtr;
+  bool randMode;
+  
+  CBlockProps(): blockSize(0), origPtr(0), randMode(false) {}
+};
+
+struct CBase
+{
+  CMyComPtr<ISequentialInStream> InStreamRef;
+  NBitm::CDecoder<CInBuffer> BitDecoder;
+
+private:
+  Byte m_Selectors[kNumSelectorsMax];
+  CHuffmanDecoder m_HuffmanDecoders[kNumTablesMax];
+
+public:
+  UInt64 NumBlocks;
+
+  CBase(): NumBlocks(0) {}
+  UInt32 ReadBits(unsigned numBits);
+  unsigned ReadBit();
+  void InitNumBlocks() { NumBlocks = 0; }
+
+  /*
+    ReadBlock() props->randMode:
+      in: need read randMode bit,
+      out: randMode status
+  */
+  HRESULT ReadBlock(UInt32 *charCounters, UInt32 blockSizeMax, CBlockProps *props);
+};
+
 class CDecoder :
   public ICompressCoder,
   #ifndef _7ZIP_ST
@@ -67,37 +104,30 @@ class CDecoder :
 public:
   COutBuffer m_OutStream;
   Byte MtPad[1 << 8]; // It's pad for Multi-Threading. Must be >= Cache_Line_Size.
-  NBitm::CDecoder<CInBuffer> m_InStream;
-  Byte m_Selectors[kNumSelectorsMax];
-  CHuffmanDecoder m_HuffmanDecoders[kNumTablesMax];
+
+  CBase Base;
+
   UInt64 _inStart;
 
 private:
 
   bool _needInStreamInit;
 
-  UInt32 ReadBits(unsigned numBits);
   Byte ReadByte();
-  bool ReadBit();
-  UInt32 ReadCrc();
-  HRESULT DecodeFile(bool &isBZ, ICompressProgressInfo *progress);
-  HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-      bool &isBZ, ICompressProgressInfo *progress);
+
+  HRESULT DecodeFile(ICompressProgressInfo *progress);
+  HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+  
   class CDecoderFlusher
   {
     CDecoder *_decoder;
   public:
     bool NeedFlush;
-    bool ReleaseInStream;
-    CDecoderFlusher(CDecoder *decoder, bool releaseInStream):
-      _decoder(decoder),
-      ReleaseInStream(releaseInStream),
-      NeedFlush(true) {}
+    CDecoderFlusher(CDecoder *decoder): _decoder(decoder), NeedFlush(true) {}
     ~CDecoderFlusher()
     {
       if (NeedFlush)
         _decoder->Flush();
-      _decoder->ReleaseStreams(ReleaseInStream);
     }
   };
 
@@ -123,6 +153,7 @@ public:
   HRESULT Result2;
 
   UInt32 BlockSizeMax;
+
   ~CDecoder();
   HRESULT Create();
   void Free();
@@ -131,18 +162,16 @@ public:
   CState m_States[1];
   #endif
 
+  bool IsBz;
+  bool BzWasFinished; // bzip stream was finished with end signature
+  bool CrcError; // it can CRC error of block or CRC error of whole stream.
+
   CDecoder();
 
   HRESULT SetRatioProgress(UInt64 packSize);
-  HRESULT ReadSignatures(bool &wasFinished, UInt32 &crc);
+  HRESULT ReadSignature(UInt32 &crc);
 
   HRESULT Flush() { return m_OutStream.Flush(); }
-  void ReleaseStreams(bool releaseInStream)
-  {
-    if (releaseInStream)
-      m_InStream.ReleaseStream();
-    m_OutStream.ReleaseStream();
-  }
 
   MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
   #ifndef _7ZIP_ST
@@ -159,8 +188,13 @@ public:
   STDMETHOD(SetInStream)(ISequentialInStream *inStream);
   STDMETHOD(ReleaseInStream)();
 
-  HRESULT CodeResume(ISequentialOutStream *outStream, bool &isBZ, ICompressProgressInfo *progress);
-  UInt64 GetInputProcessedSize() const { return m_InStream.GetProcessedSize(); }
+  HRESULT CodeResume(ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+
+  UInt64 GetStreamSize() const { return Base.BitDecoder.GetStreamSize(); }
+  UInt64 GetInputProcessedSize() const { return Base.BitDecoder.GetProcessedSize(); }
+
+  void InitNumBlocks() { Base.InitNumBlocks(); }
+  UInt64 GetNumBlocks() const { return Base.NumBlocks; }
   
   #ifndef _7ZIP_ST
   STDMETHOD(SetNumberOfThreads)(UInt32 numThreads);
@@ -174,9 +208,8 @@ class CNsisDecoder :
   public ICompressSetOutStreamSize,
   public CMyUnknownImp
 {
-  NBitm::CDecoder<CInBuffer> m_InStream;
-  Byte m_Selectors[kNumSelectorsMax];
-  CHuffmanDecoder m_HuffmanDecoders[kNumTablesMax];
+  CBase Base;
+
   CState m_State;
   
   int _nsisState;

data/ext/p7zip/CPP/7zip/Compress/BZip2Encoder.cpp

@@ -13,10 +13,10 @@
 namespace NCompress {
 namespace NBZip2 {
 
-const int kMaxHuffmanLenForEncoding = 16; // it must be < kMaxHuffmanLen = 20
+const unsigned kMaxHuffmanLenForEncoding = 16; // it must be < kMaxHuffmanLen = 20
 
 static const UInt32 kBufferSize = (1 << 17);
-static const int kNumHuffPasses = 4;
+static const unsigned kNumHuffPasses = 4;
 
 bool CThreadInfo::Alloc()
 {
@@ -53,7 +53,7 @@ static THREAD_FUNC_DECL MFThread(void *threadCoderInfo)
   return ((CThreadInfo *)threadCoderInfo)->ThreadFunc();
 }
 
-#define RINOK_THREAD(x) { WRes __result_ = (x); if(__result_ != 0) return __result_; }
+#define RINOK_THREAD(x) { WRes __result_ = (x); if (__result_ != 0) return __result_; }
 
 HRESULT CThreadInfo::Create()
 {
@@ -122,11 +122,26 @@ DWORD CThreadInfo::ThreadFunc()
 
 #endif
 
-CEncoder::CEncoder():
-  NumPasses(1),
-  m_OptimizeNumTables(false),
-  m_BlockSizeMult(kBlockSizeMultMax)
+void CEncProps::Normalize(int level)
 {
+  if (level < 0) level = 5;
+  if (level > 9) level = 9;
+  
+  if (NumPasses == (UInt32)(Int32)-1)
+    NumPasses = (level >= 9 ? 7 : (level >= 7 ? 2 : 1));
+  if (NumPasses < 1) NumPasses = 1;
+  if (NumPasses > kNumPassesMax) NumPasses = kNumPassesMax;
+  
+  if (BlockSizeMult == (UInt32)(Int32)-1)
+    BlockSizeMult = (level >= 5 ? 9 : (level >= 1 ? level * 2 - 1: 1));
+  if (BlockSizeMult < kBlockSizeMultMin) BlockSizeMult = kBlockSizeMultMin;
+  if (BlockSizeMult > kBlockSizeMultMax) BlockSizeMult = kBlockSizeMultMax;
+}
+
+CEncoder::CEncoder()
+{
+  _props.Normalize(-1);
+
   #ifndef _7ZIP_ST
   ThreadsInfo = 0;
   m_NumThreadsPrev = 0;
@@ -198,8 +213,8 @@ UInt32 CEncoder::ReadRleBlock(Byte *buffer)
   Byte prevByte;
   if (m_InStream.ReadByte(prevByte))
   {
-    UInt32 blockSize = m_BlockSizeMult * kBlockSizeStep - 1;
-    int numReps = 1;
+    UInt32 blockSize = _props.BlockSizeMult * kBlockSizeStep - 1;
+    unsigned numReps = 1;
     buffer[i++] = prevByte;
     while (i < blockSize) // "- 1" to support RLE
     {
@@ -231,23 +246,21 @@ UInt32 CEncoder::ReadRleBlock(Byte *buffer)
   return i;
 }
 
-void CThreadInfo::WriteBits2(UInt32 value, UInt32 numBits)
-  { m_OutStreamCurrent->WriteBits(value, numBits); }
-void CThreadInfo::WriteByte2(Byte b) { WriteBits2(b , 8); }
-void CThreadInfo::WriteBit2(bool v) { WriteBits2((v ? 1 : 0), 1); }
+void CThreadInfo::WriteBits2(UInt32 value, unsigned numBits) { m_OutStreamCurrent->WriteBits(value, numBits); }
+void CThreadInfo::WriteByte2(Byte b) { WriteBits2(b, 8); }
+void CThreadInfo::WriteBit2(Byte v) { WriteBits2(v, 1); }
 void CThreadInfo::WriteCrc2(UInt32 v)
 {
-  for (int i = 0; i < 4; i++)
+  for (unsigned i = 0; i < 4; i++)
     WriteByte2(((Byte)(v >> (24 - i * 8))));
 }
 
-void CEncoder::WriteBits(UInt32 value, UInt32 numBits)
-  { m_OutStream.WriteBits(value, numBits); }
-void CEncoder::WriteByte(Byte b) { WriteBits(b , 8); }
-void CEncoder::WriteBit(bool v) { WriteBits((v ? 1 : 0), 1); }
+void CEncoder::WriteBits(UInt32 value, unsigned numBits) { m_OutStream.WriteBits(value, numBits); }
+void CEncoder::WriteByte(Byte b) { WriteBits(b, 8); }
+// void CEncoder::WriteBit(Byte v) { WriteBits(v, 1); }
 void CEncoder::WriteCrc(UInt32 v)
 {
-  for (int i = 0; i < 4; i++)
+  for (unsigned i = 0; i < 4; i++)
     WriteByte(((Byte)(v >> (24 - i * 8))));
 }
 
@@ -255,7 +268,7 @@ void CEncoder::WriteCrc(UInt32 v)
 // blockSize > 0
 void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
 {
-  WriteBit2(false); // Randomised = false
+  WriteBit2(0); // Randomised = false
   
   {
     UInt32 origPtr = BlockSort(m_BlockSorterIndex, block, blockSize);
@@ -265,21 +278,21 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
   }
 
   CMtf8Encoder mtf;
-  int numInUse = 0;
+  unsigned numInUse = 0;
   {
-    bool inUse[256];
-    bool inUse16[16];
+    Byte inUse[256];
+    Byte inUse16[16];
     UInt32 i;
     for (i = 0; i < 256; i++)
-      inUse[i] = false;
+      inUse[i] = 0;
     for (i = 0; i < 16; i++)
-      inUse16[i] = false;
+      inUse16[i] = 0;
     for (i = 0; i < blockSize; i++)
-      inUse[block[i]] = true;
+      inUse[block[i]] = 1;
     for (i = 0; i < 256; i++)
       if (inUse[i])
       {
-        inUse16[i >> 4] = true;
+        inUse16[i >> 4] = 1;
         mtf.Buf[numInUse++] = (Byte)i;
       }
     for (i = 0; i < 16; i++)
@@ -288,13 +301,13 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
       if (inUse16[i >> 4])
         WriteBit2(inUse[i]);
   }
-  int alphaSize = numInUse + 2;
+  unsigned alphaSize = numInUse + 2;
 
   Byte *mtfs = m_MtfArray;
   UInt32 mtfArraySize = 0;
   UInt32 symbolCounts[kMaxAlphaSize];
   {
-    for (int i = 0; i < kMaxAlphaSize; i++)
+    for (unsigned i = 0; i < kMaxAlphaSize; i++)
       symbolCounts[i] = 0;
   }
 
@@ -305,7 +318,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
     block--;
     do
     {
-      int pos = mtf.FindAndMove(block[bsIndex[i]]);
+      unsigned pos = mtf.FindAndMove(block[bsIndex[i]]);
       if (pos == 0)
         rleSize++;
       else
@@ -349,19 +362,19 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
 
   UInt32 numSymbols = 0;
   {
-    for (int i = 0; i < kMaxAlphaSize; i++)
+    for (unsigned i = 0; i < kMaxAlphaSize; i++)
       numSymbols += symbolCounts[i];
   }
 
-  int bestNumTables = kNumTablesMin;
+  unsigned bestNumTables = kNumTablesMin;
   UInt32 bestPrice = 0xFFFFFFFF;
   UInt32 startPos = m_OutStreamCurrent->GetPos();
   Byte startCurByte = m_OutStreamCurrent->GetCurByte();
-  for (int nt = kNumTablesMin; nt <= kNumTablesMax + 1; nt++)
+  for (unsigned nt = kNumTablesMin; nt <= kNumTablesMax + 1; nt++)
   {
-    int numTables;
+    unsigned numTables;
 
-    if(m_OptimizeNumTables)
+    if (m_OptimizeNumTables)
     {
       m_OutStreamCurrent->SetPos(startPos);
       m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
@@ -386,38 +399,38 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
     
     {
       UInt32 remFreq = numSymbols;
-      int gs = 0;
-      int t = numTables;
+      unsigned gs = 0;
+      unsigned t = numTables;
       do
       {
         UInt32 tFreq = remFreq / t;
-        int ge = gs;
+        unsigned ge = gs;
         UInt32 aFreq = 0;
         while (aFreq < tFreq) //  && ge < alphaSize)
           aFreq += symbolCounts[ge++];
         
-        if (ge - 1 > gs && t != numTables && t != 1 && (((numTables - t) & 1) == 1))
+        if (ge > gs + 1 && t != numTables && t != 1 && (((numTables - t) & 1) == 1))
           aFreq -= symbolCounts[--ge];
         
         Byte *lens = Lens[t - 1];
-        int i = 0;
+        unsigned i = 0;
         do
-          lens[i] = (i >= gs && i < ge) ? 0 : 1;
+          lens[i] = (Byte)((i >= gs && i < ge) ? 0 : 1);
         while (++i < alphaSize);
         gs = ge;
         remFreq -= aFreq;
       }
-      while(--t != 0);
+      while (--t != 0);
     }
     
     
-    for (int pass = 0; pass < kNumHuffPasses; pass++)
+    for (unsigned pass = 0; pass < kNumHuffPasses; pass++)
     {
       {
-        int t = 0;
+        unsigned t = 0;
         do
           memset(Freqs[t], 0, sizeof(Freqs[t]));
-        while(++t < numTables);
+        while (++t < numTables);
       }
       
       {
@@ -426,7 +439,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         do
         {
           UInt32 symbols[kGroupSize];
-          int i = 0;
+          unsigned i = 0;
           do
           {
             UInt32 symbol = mtfs[mtfPos++];
@@ -436,25 +449,25 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
           }
           while (++i < kGroupSize && mtfPos < mtfArraySize);
           
-          UInt32 bestPrice = 0xFFFFFFFF;
-          int t = 0;
+          UInt32 bestPrice2 = 0xFFFFFFFF;
+          unsigned t = 0;
           do
           {
             const Byte *lens = Lens[t];
             UInt32 price = 0;
-            int j = 0;
+            unsigned j = 0;
             do
               price += lens[symbols[j]];
             while (++j < i);
-            if (price < bestPrice)
+            if (price < bestPrice2)
             {
               m_Selectors[g] = (Byte)t;
-              bestPrice = price;
+              bestPrice2 = price;
             }
           }
-          while(++t < numTables);
+          while (++t < numTables);
           UInt32 *freqs = Freqs[m_Selectors[g++]];
-          int j = 0;
+          unsigned j = 0;
           do
             freqs[symbols[j]]++;
           while (++j < i);
@@ -462,74 +475,74 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         while (mtfPos < mtfArraySize);
       }
       
-      int t = 0;
+      unsigned t = 0;
       do
       {
         UInt32 *freqs = Freqs[t];
-        int i = 0;
+        unsigned i = 0;
         do
           if (freqs[i] == 0)
             freqs[i] = 1;
-        while(++i < alphaSize);
+        while (++i < alphaSize);
         Huffman_Generate(freqs, Codes[t], Lens[t], kMaxAlphaSize, kMaxHuffmanLenForEncoding);
       }
-      while(++t < numTables);
+      while (++t < numTables);
     }
     
     {
       Byte mtfSel[kNumTablesMax];
       {
-        int t = 0;
+        unsigned t = 0;
         do
           mtfSel[t] = (Byte)t;
-        while(++t < numTables);
+        while (++t < numTables);
       }
       
       UInt32 i = 0;
       do
       {
         Byte sel = m_Selectors[i];
-        int pos;
+        unsigned pos;
         for (pos = 0; mtfSel[pos] != sel; pos++)
-          WriteBit2(true);
-        WriteBit2(false);
+          WriteBit2(1);
+        WriteBit2(0);
         for (; pos > 0; pos--)
           mtfSel[pos] = mtfSel[pos - 1];
         mtfSel[0] = sel;
       }
-      while(++i < numSelectors);
+      while (++i < numSelectors);
     }
     
     {
-      int t = 0;
+      unsigned t = 0;
       do
       {
         const Byte *lens = Lens[t];
         UInt32 len = lens[0];
         WriteBits2(len, kNumLevelsBits);
-        int i = 0;
+        unsigned i = 0;
         do
         {
           UInt32 level = lens[i];
           while (len != level)
           {
-            WriteBit2(true);
+            WriteBit2(1);
             if (len < level)
             {
-              WriteBit2(false);
+              WriteBit2(0);
               len++;
             }
             else
             {
-              WriteBit2(true);
+              WriteBit2(1);
               len--;
             }
           }
-          WriteBit2(false);
+          WriteBit2(0);
         }
         while (++i < alphaSize);
       }
-      while(++t < numTables);
+      while (++t < numTables);
     }
     
     {
@@ -546,7 +559,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         if (groupSize == 0)
         {
           groupSize = kGroupSize;
-          int t = m_Selectors[groupIndex++];
+          unsigned t = m_Selectors[groupIndex++];
           lens = Lens[t];
           codes = Codes[t];
         }
@@ -580,7 +593,7 @@ UInt32 CThreadInfo::EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize)
   WriteByte2(kBlockSig5);
 
   CBZip2Crc crc;
-  int numReps = 0;
+  unsigned numReps = 0;
   Byte prevByte = block[0];
   UInt32 i = 0;
   do
@@ -678,7 +691,7 @@ HRESULT CThreadInfo::EncodeBlock3(UInt32 blockSize)
 
   m_NumCrcs = 0;
 
-  EncodeBlock2(m_Block, blockSize, Encoder->NumPasses);
+  EncodeBlock2(m_Block, blockSize, Encoder->_props.NumPasses);
 
   #ifndef _7ZIP_ST
   if (Encoder->MtMode)
@@ -709,7 +722,7 @@ HRESULT CThreadInfo::EncodeBlock3(UInt32 blockSize)
 
 void CEncoder::WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte)
 {
-  UInt32 bytesSize = (sizeInBits / 8);
+  UInt32 bytesSize = (sizeInBits >> 3);
   for (UInt32 i = 0; i < bytesSize; i++)
     m_OutStream.WriteBits(data[i], 8);
   WriteBits(lastByte, (sizeInBits & 7));
@@ -738,7 +751,7 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     ti.Encoder = this;
     #endif
 
-    ti.m_OptimizeNumTables = m_OptimizeNumTables;
+    ti.m_OptimizeNumTables = _props.DoOptimizeNumTables();
 
     if (!ti.Alloc())
       return E_OUTOFMEMORY;
@@ -757,8 +770,6 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   m_OutStream.SetStream(outStream);
   m_OutStream.Init();
 
-  CFlusher flusher(this);
-
   CombinedCrc.Init();
   #ifndef _7ZIP_ST
   NextBlockIndex = 0;
@@ -770,7 +781,7 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   WriteByte(kArSig0);
   WriteByte(kArSig1);
   WriteByte(kArSig2);
-  WriteByte((Byte)(kArSig3 + m_BlockSizeMult));
+  WriteByte((Byte)(kArSig3 + _props.BlockSizeMult));
 
   #ifndef _7ZIP_ST
 
@@ -832,62 +843,46 @@ STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   catch(...) { return S_FALSE; }
 }
 
-HRESULT CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
+HRESULT CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
 {
-  for(UInt32 i = 0; i < numProps; i++)
+  int level = -1;
+  CEncProps props;
+  for (UInt32 i = 0; i < numProps; i++)
   {
-    const PROPVARIANT &prop = props[i];
-    switch(propIDs[i])
+    const PROPVARIANT &prop = coderProps[i];
+    PROPID propID = propIDs[i];
+    if (propID >= NCoderPropID::kReduceSize)
+      continue;
+    if (prop.vt != VT_UI4)
+      return E_INVALIDARG;
+    UInt32 v = (UInt32)prop.ulVal;
+    switch (propID)
     {
-      case NCoderPropID::kNumPasses:
-      {
-        if (prop.vt != VT_UI4)
-          return E_INVALIDARG;
-        UInt32 numPasses = prop.ulVal;
-        if (numPasses == 0)
-          numPasses = 1;
-        if (numPasses > kNumPassesMax)
-          numPasses = kNumPassesMax;
-        NumPasses = numPasses;
-        m_OptimizeNumTables = (NumPasses > 1);
-        break;
-      }
-      case NCoderPropID::kDictionarySize:
-      {
-        if (prop.vt != VT_UI4)
-          return E_INVALIDARG;
-        UInt32 dictionary = prop.ulVal / kBlockSizeStep;
-        if (dictionary < kBlockSizeMultMin)
-          dictionary = kBlockSizeMultMin;
-        else if (dictionary > kBlockSizeMultMax)
-          dictionary = kBlockSizeMultMax;
-        m_BlockSizeMult = dictionary;
-        break;
-      }
+      case NCoderPropID::kNumPasses: props.NumPasses = v; break;
+      case NCoderPropID::kDictionarySize: props.BlockSizeMult = v / kBlockSizeStep; break;
+      case NCoderPropID::kLevel: level = v; break;
       case NCoderPropID::kNumThreads:
       {
         #ifndef _7ZIP_ST
-        if (prop.vt != VT_UI4)
-          return E_INVALIDARG;
-        NumThreads = prop.ulVal;
-        if (NumThreads < 1)
-          NumThreads = 1;
+        SetNumberOfThreads(v);
         #endif
         break;
       }
-      default:
-        return E_INVALIDARG;
+      default: return E_INVALIDARG;
     }
   }
+  props.Normalize(level);
+  _props = props;
   return S_OK;
 }
 
 #ifndef _7ZIP_ST
 STDMETHODIMP CEncoder::SetNumberOfThreads(UInt32 numThreads)
 {
+  const UInt32 kNumThreadsMax = 64;
+  if (numThreads < 1) numThreads = 1;
+  if (numThreads > kNumThreadsMax) numThreads = kNumThreadsMax;
   NumThreads = numThreads;
-  if (NumThreads < 1)
-    NumThreads = 1;
   return S_OK;
 }
 #endif