9.34

CPP/7zip/Compress/ArjDecoder1.cpp

@@ -260,7 +260,7 @@ HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *ou
 
   UInt32 blockSize = 0;
 
-  while(pos < *outSize)
+  while (pos < *outSize)
   {
     if (blockSize == 0)
     {

CPP/7zip/Compress/ArjDecoder1.h

@@ -55,12 +55,6 @@ class CCoder :
   UInt32 c_table[CTABLESIZE];
   UInt32 pt_table[PTABLESIZE];
   
-  void ReleaseStreams()
-  {
-    m_OutWindowStream.ReleaseStream();
-    m_InBitStream.ReleaseStream();
-  }
-
   class CCoderReleaser
   {
     CCoder *m_Coder;
@@ -71,7 +65,6 @@ class CCoder :
     {
       if (NeedFlush)
         m_Coder->m_OutWindowStream.Flush();
-      m_Coder->ReleaseStreams();
     }
   };
   friend class CCoderReleaser;

CPP/7zip/Compress/ArjDecoder2.cpp

@@ -27,9 +27,10 @@ HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *ou
   m_OutWindowStream.Init(false);
   m_InBitStream.SetStream(inStream);
   m_InBitStream.Init();
+  
   CCoderReleaser coderReleaser(this);
 
-  while(pos < *outSize)
+  while (pos < *outSize)
   {
     const UInt32 kStartWidth = 0;
     const UInt32 kStopWidth = 7;

CPP/7zip/Compress/ArjDecoder2.h

@@ -23,12 +23,6 @@ class CCoder :
   CLzOutWindow m_OutWindowStream;
   NBitm::CDecoder<CInBuffer> m_InBitStream;
   
-  void ReleaseStreams()
-  {
-    m_OutWindowStream.ReleaseStream();
-    m_InBitStream.ReleaseStream();
-  }
-
   class CCoderReleaser
   {
     CCoder *m_Coder;
@@ -39,7 +33,6 @@ class CCoder :
     {
       if (NeedFlush)
         m_Coder->m_OutWindowStream.Flush();
-      m_Coder->ReleaseStreams();
     }
   };
   friend class CCoderReleaser;

CPP/7zip/Compress/BZip2Crc.h

@@ -3,7 +3,7 @@
 #ifndef __BZIP2_CRC_H
 #define __BZIP2_CRC_H
 
-#include "Common/Types.h"
+#include "../../Common/MyTypes.h"
 
 class CBZip2Crc
 {

CPP/7zip/Compress/BZip2Decoder.cpp

@@ -85,41 +85,21 @@ void CState::Free()
   Counters = 0;
 }
 
-UInt32 CDecoder::ReadBits(unsigned numBits) { return m_InStream.ReadBits(numBits); }
-Byte CDecoder::ReadByte() {return (Byte)ReadBits(8); }
-bool CDecoder::ReadBit() { return ReadBits(1) != 0; }
+Byte CDecoder::ReadByte() { return (Byte)Base.ReadBits(8); }
 
-UInt32 CDecoder::ReadCrc()
-{
-  UInt32 crc = 0;
-  for (int i = 0; i < 4; i++)
-  {
-    crc <<= 8;
-    crc |= ReadByte();
-  }
-  return crc;
-}
+UInt32 CBase::ReadBits(unsigned numBits) { return BitDecoder.ReadBits(numBits); }
+unsigned CBase::ReadBit() { return (unsigned)BitDecoder.ReadBits(1); }
 
-static UInt32 NO_INLINE ReadBits(NBitm::CDecoder<CInBuffer> *m_InStream, unsigned num)
+HRESULT CBase::ReadBlock(UInt32 *charCounters, UInt32 blockSizeMax, CBlockProps *props)
 {
-  return m_InStream->ReadBits(num);
-}
+  NumBlocks++;
 
-static UInt32 NO_INLINE ReadBit(NBitm::CDecoder<CInBuffer> *m_InStream)
-{
-  return m_InStream->ReadBits(1);
-}
-
-static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
-    UInt32 *CharCounters, UInt32 blockSizeMax, Byte *m_Selectors, CHuffmanDecoder *m_HuffmanDecoders,
-    UInt32 *blockSizeRes, UInt32 *origPtrRes, bool *randRes)
-{
-  if (randRes)
-    *randRes = ReadBit(m_InStream) ? true : false;
-  *origPtrRes = ReadBits(m_InStream, kNumOrigBits);
+  if (props->randMode)
+    props->randMode = ReadBit() ? true : false;
+  props->origPtr = ReadBits(kNumOrigBits);
   
   // in original code it compares OrigPtr to (UInt32)(10 + blockSizeMax)) : why ?
-  if (*origPtrRes >= blockSizeMax)
+  if (props->origPtr >= blockSizeMax)
     return S_FALSE;
 
   CMtf8Decoder mtf;
@@ -130,11 +110,11 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
     Byte inUse16[16];
     int i;
     for (i = 0; i < 16; i++)
-      inUse16[i] = (Byte)ReadBit(m_InStream);
+      inUse16[i] = (Byte)ReadBit();
     for (i = 0; i < 256; i++)
       if (inUse16[i >> 4])
       {
-        if (ReadBit(m_InStream))
+        if (ReadBit())
           mtf.Add(numInUse++, (Byte)i);
       }
     if (numInUse == 0)
@@ -143,11 +123,11 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
   }
   int alphaSize = numInUse + 2;
 
-  int numTables = ReadBits(m_InStream, kNumTablesBits);
+  int numTables = ReadBits(kNumTablesBits);
   if (numTables < kNumTablesMin || numTables > kNumTablesMax)
     return S_FALSE;
   
-  UInt32 numSelectors = ReadBits(m_InStream, kNumSelectorsBits);
+  UInt32 numSelectors = ReadBits(kNumSelectorsBits);
   if (numSelectors < 1 || numSelectors > kNumSelectorsMax)
     return S_FALSE;
 
@@ -156,12 +136,12 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
     int t = 0;
     do
       mtfPos[t] = (Byte)t;
-    while(++t < numTables);
+    while (++t < numTables);
     UInt32 i = 0;
     do
     {
       int j = 0;
-      while (ReadBit(m_InStream))
+      while (ReadBit())
         if (++j >= numTables)
           return S_FALSE;
       Byte tmp = mtfPos[j];
@@ -169,14 +149,14 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
         mtfPos[j] = mtfPos[j - 1];
       m_Selectors[i] = mtfPos[0] = tmp;
     }
-    while(++i < numSelectors);
+    while (++i < numSelectors);
   }
 
   int t = 0;
   do
   {
     Byte lens[kMaxAlphaSize];
-    int len = (int)ReadBits(m_InStream, kNumLevelsBits);
+    int len = (int)ReadBits(kNumLevelsBits);
     int i;
     for (i = 0; i < alphaSize; i++)
     {
@@ -184,22 +164,22 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
       {
         if (len < 1 || len > kMaxHuffmanLen)
           return S_FALSE;
-        if (!ReadBit(m_InStream))
+        if (!ReadBit())
           break;
-        len += 1 - (int)(ReadBit(m_InStream) << 1);
+        len += 1 - (int)(ReadBit() << 1);
       }
       lens[i] = (Byte)len;
     }
     for (; i < kMaxAlphaSize; i++)
       lens[i] = 0;
-    if(!m_HuffmanDecoders[t].SetCodeLengths(lens))
+    if (!m_HuffmanDecoders[t].SetCodeLengths(lens))
       return S_FALSE;
   }
-  while(++t < numTables);
+  while (++t < numTables);
 
   {
     for (int i = 0; i < 256; i++)
-      CharCounters[i] = 0;
+      charCounters[i] = 0;
   }
   
   UInt32 blockSize = 0;
@@ -221,7 +201,10 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
       }
       groupSize--;
         
-      UInt32 nextSym = huffmanDecoder->DecodeSymbol(m_InStream);
+      if (BitDecoder.ExtraBitsWereRead_Fast())
+        break;
+
+      UInt32 nextSym = huffmanDecoder->DecodeSymbol(&BitDecoder);
       
       if (nextSym < 2)
       {
@@ -233,10 +216,10 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
       if (runCounter != 0)
       {
         UInt32 b = (UInt32)mtf.GetHead();
-        CharCounters[b] += runCounter;
+        charCounters[b] += runCounter;
         do
-          CharCounters[256 + blockSize++] = b;
-        while(--runCounter != 0);
+          charCounters[256 + blockSize++] = b;
+        while (--runCounter != 0);
         runPower = 0;
       }
       if (nextSym <= (UInt32)numInUse)
@@ -244,17 +227,20 @@ static HRESULT NO_INLINE ReadBlock(NBitm::CDecoder<CInBuffer> *m_InStream,
         UInt32 b = (UInt32)mtf.GetAndMove((int)nextSym - 1);
         if (blockSize >= blockSizeMax)
           return S_FALSE;
-        CharCounters[b]++;
-        CharCounters[256 + blockSize++] = b;
+        charCounters[b]++;
+        charCounters[256 + blockSize++] = b;
       }
       else if (nextSym == (UInt32)numInUse + 1)
         break;
       else
         return S_FALSE;
     }
+
+    if (BitDecoder.ExtraBitsWereRead())
+      return S_FALSE;
   }
-  *blockSizeRes = blockSize;
-  return (*origPtrRes < blockSize) ? S_OK : S_FALSE;
+  props->blockSize = blockSize;
+  return (props->origPtr < props->blockSize) ? S_OK : S_FALSE;
 }
 
 static void NO_INLINE DecodeBlock1(UInt32 *charCounters, UInt32 blockSize)
@@ -273,7 +259,7 @@ static void NO_INLINE DecodeBlock1(UInt32 *charCounters, UInt32 blockSize)
   UInt32 i = 0;
   do
     tt[charCounters[tt[i] & 0xFF]++] |= (i << 8);
-  while(++i < blockSize);
+  while (++i < blockSize);
 }
 
 static UInt32 NO_INLINE DecodeBlock2(const UInt32 *tt, UInt32 blockSize, UInt32 OrigPtr, COutBuffer &m_OutStream)
@@ -363,7 +349,7 @@ static UInt32 NO_INLINE DecodeBlock2(const UInt32 *tt, UInt32 blockSize, UInt32
     }
     */
   }
-  while(--blockSize != 0);
+  while (--blockSize != 0);
   return crc.GetDigest();
 }
 
@@ -412,10 +398,17 @@ static UInt32 NO_INLINE DecodeBlock2Rand(const UInt32 *tt, UInt32 blockSize, UIn
     crc.UpdateByte(b);
     m_OutStream.WriteByte((Byte)b);
   }
-  while(--blockSize != 0);
+  while (--blockSize != 0);
   return crc.GetDigest();
 }
 
+static UInt32 NO_INLINE DecodeBlock(const CBlockProps &props, UInt32 *tt, COutBuffer &m_OutStream)
+{
+  if (props.randMode)
+    return DecodeBlock2Rand(tt, props.blockSize, props.origPtr, m_OutStream);
+  else
+    return DecodeBlock2    (tt, props.blockSize, props.origPtr, m_OutStream);
+}
 
 CDecoder::CDecoder()
 {
@@ -434,7 +427,7 @@ CDecoder::~CDecoder()
   Free();
 }
 
-#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 CDecoder::Create()
 {
@@ -489,37 +482,71 @@ void CDecoder::Free()
 
 #endif
 
-HRESULT CDecoder::ReadSignatures(bool &wasFinished, UInt32 &crc)
+bool IsEndSig(const Byte *p) throw()
 {
-  wasFinished = false;
-  Byte s[6];
-  for (int i = 0; i < 6; i++)
+  return
+    p[0] == kFinSig0 &&
+    p[1] == kFinSig1 &&
+    p[2] == kFinSig2 &&
+    p[3] == kFinSig3 &&
+    p[4] == kFinSig4 &&
+    p[5] == kFinSig5;
+}
+
+bool IsBlockSig(const Byte *p) throw()
+{
+  return
+    p[0] == kBlockSig0 &&
+    p[1] == kBlockSig1 &&
+    p[2] == kBlockSig2 &&
+    p[3] == kBlockSig3 &&
+    p[4] == kBlockSig4 &&
+    p[5] == kBlockSig5;
+}
+
+HRESULT CDecoder::ReadSignature(UInt32 &crc)
+{
+  BzWasFinished = false;
+  crc = 0;
+
+  Byte s[10];
+  int i;
+  for (i = 0; i < 10; i++)
     s[i] = ReadByte();
-  crc = ReadCrc();
-  if (s[0] == kFinSig0)
-  {
-    if (s[1] != kFinSig1 ||
-        s[2] != kFinSig2 ||
-        s[3] != kFinSig3 ||
-        s[4] != kFinSig4 ||
-        s[5] != kFinSig5)
-      return S_FALSE;
-    
-    wasFinished = true;
-    return (crc == CombinedCrc.GetDigest()) ? S_OK : S_FALSE;
-  }
-  if (s[0] != kBlockSig0 ||
-      s[1] != kBlockSig1 ||
-      s[2] != kBlockSig2 ||
-      s[3] != kBlockSig3 ||
-      s[4] != kBlockSig4 ||
-      s[5] != kBlockSig5)
+
+  if (Base.BitDecoder.ExtraBitsWereRead())
     return S_FALSE;
-  CombinedCrc.Update(crc);
+
+  UInt32 v = 0;
+  for (i = 0; i < 4; i++)
+  {
+    v <<= 8;
+    v |= s[6 + i];
+  }
+
+  crc = v;
+
+  if (IsBlockSig(s))
+  {
+    IsBz = true;
+    CombinedCrc.Update(crc);
+    return S_OK;
+  }
+
+  if (!IsEndSig(s))
+    return S_FALSE;
+
+  IsBz = true;
+  BzWasFinished = true;
+  if (crc != CombinedCrc.GetDigest())
+  {
+    CrcError = true;
+    return S_FALSE;
+  }
   return S_OK;
 }
 
-HRESULT CDecoder::DecodeFile(bool &isBZ, ICompressProgressInfo *progress)
+HRESULT CDecoder::DecodeFile(ICompressProgressInfo *progress)
 {
   Progress = progress;
   #ifndef _7ZIP_ST
@@ -541,18 +568,27 @@ HRESULT CDecoder::DecodeFile(bool &isBZ, ICompressProgressInfo *progress)
     return E_OUTOFMEMORY;
   #endif
 
-  isBZ = false;
-  Byte s[6];
+  IsBz = false;
+
+  /*
+  if (Base.BitDecoder.ExtraBitsWereRead())
+    return E_FAIL;
+  */
+
+  Byte s[4];
   int i;
   for (i = 0; i < 4; i++)
     s[i] = ReadByte();
+  if (Base.BitDecoder.ExtraBitsWereRead())
+    return S_FALSE;
+
   if (s[0] != kArSig0 ||
       s[1] != kArSig1 ||
       s[2] != kArSig2 ||
       s[3] <= kArSig3 ||
       s[3] > kArSig3 + kBlockSizeMultMax)
-    return S_OK;
-  isBZ = true;
+    return S_FALSE;
+
   UInt32 dicSize = (UInt32)(s[3] - kArSig3) * kBlockSizeStep;
 
   CombinedCrc.Init();
@@ -584,58 +620,59 @@ HRESULT CDecoder::DecodeFile(bool &isBZ, ICompressProgressInfo *progress)
     CState &state = m_States[0];
     for (;;)
     {
-      RINOK(SetRatioProgress(m_InStream.GetProcessedSize()));
-      bool wasFinished;
+      RINOK(SetRatioProgress(Base.BitDecoder.GetProcessedSize()));
       UInt32 crc;
-      RINOK(ReadSignatures(wasFinished, crc));
-      if (wasFinished)
+      RINOK(ReadSignature(crc));
+      if (BzWasFinished)
         return S_OK;
 
-      UInt32 blockSize, origPtr;
-      bool randMode;
-      RINOK(ReadBlock(&m_InStream, state.Counters, dicSize,
-        m_Selectors, m_HuffmanDecoders,
-        &blockSize, &origPtr, &randMode));
-      DecodeBlock1(state.Counters, blockSize);
-      if ((randMode ?
-          DecodeBlock2Rand(state.Counters + 256, blockSize, origPtr, m_OutStream) :
-          DecodeBlock2(state.Counters + 256, blockSize, origPtr, m_OutStream)) != crc)
+      CBlockProps props;
+      props.randMode = true;
+      RINOK(Base.ReadBlock(state.Counters, dicSize, &props));
+      DecodeBlock1(state.Counters, props.blockSize);
+      if (DecodeBlock(props, state.Counters + 256, m_OutStream) != crc)
+      {
+        CrcError = true;
         return S_FALSE;
+      }
     }
   }
-  return SetRatioProgress(m_InStream.GetProcessedSize());
+  return SetRatioProgress(Base.BitDecoder.GetProcessedSize());
 }
 
 HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-    bool &isBZ, ICompressProgressInfo *progress)
+    ICompressProgressInfo *progress)
 {
-  isBZ = false;
+  IsBz = false;
+  BzWasFinished = false;
+  CrcError = false;
+
   try
   {
 
-  if (!m_InStream.Create(kBufferSize))
+  if (!Base.BitDecoder.Create(kBufferSize))
     return E_OUTOFMEMORY;
   if (!m_OutStream.Create(kBufferSize))
     return E_OUTOFMEMORY;
 
   if (inStream)
-    m_InStream.SetStream(inStream);
+    Base.BitDecoder.SetStream(inStream);
 
-  CDecoderFlusher flusher(this, inStream != NULL);
+  CDecoderFlusher flusher(this);
 
   if (_needInStreamInit)
   {
-    m_InStream.Init();
+    Base.BitDecoder.Init();
     _needInStreamInit = false;
   }
-  _inStart = m_InStream.GetProcessedSize();
+  _inStart = Base.BitDecoder.GetProcessedSize();
 
-  m_InStream.AlignToByte();
+  Base.BitDecoder.AlignToByte();
 
   m_OutStream.SetStream(outStream);
   m_OutStream.Init();
 
-  RINOK(DecodeFile(isBZ, progress));
+  RINOK(DecodeFile(progress));
   flusher.NeedFlush = false;
   return Flush();
 
@@ -649,18 +686,26 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
     const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
 {
   _needInStreamInit = true;
-  bool isBZ;
-  RINOK(CodeReal(inStream, outStream, isBZ, progress));
-  return isBZ ? S_OK : S_FALSE;
+  return CodeReal(inStream, outStream, progress);
 }
 
-HRESULT CDecoder::CodeResume(ISequentialOutStream *outStream, bool &isBZ, ICompressProgressInfo *progress)
+HRESULT CDecoder::CodeResume(ISequentialOutStream *outStream, ICompressProgressInfo *progress)
 {
-  return CodeReal(NULL, outStream, isBZ, progress);
+  return CodeReal(NULL, outStream, progress);
 }
 
-STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { m_InStream.SetStream(inStream); return S_OK; }
-STDMETHODIMP CDecoder::ReleaseInStream() { m_InStream.ReleaseStream(); return S_OK; }
+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)
+{
+  Base.InStreamRef = inStream;
+  Base.BitDecoder.SetStream(inStream);
+  return S_OK;
+}
+
+STDMETHODIMP CDecoder::ReleaseInStream()
+{
+  Base.InStreamRef.Release();
+  return S_OK;
+}
 
 #ifndef _7ZIP_ST
 
@@ -709,36 +754,33 @@ void CState::ThreadFunc()
     Decoder->NextBlockIndex = nextBlockIndex;
     UInt32 crc;
     UInt64 packSize = 0;
-    UInt32 blockSize = 0, origPtr = 0;
-    bool randMode = false;
+    CBlockProps props;
 
     try
     {
-      bool wasFinished;
-      res = Decoder->ReadSignatures(wasFinished, crc);
+      res = Decoder->ReadSignature(crc);
       if (res != S_OK)
       {
         Decoder->Result1 = res;
         FinishStream();
         continue;
       }
-      if (wasFinished)
+      if (Decoder->BzWasFinished)
       {
         Decoder->Result1 = res;
         FinishStream();
         continue;
       }
 
-      res = ReadBlock(&Decoder->m_InStream, Counters, Decoder->BlockSizeMax,
-          Decoder->m_Selectors, Decoder->m_HuffmanDecoders,
-          &blockSize, &origPtr, &randMode);
+      props.randMode = true;
+      res = Decoder->Base.ReadBlock(Counters, Decoder->BlockSizeMax, &props);
       if (res != S_OK)
       {
         Decoder->Result1 = res;
         FinishStream();
         continue;
       }
-      packSize = Decoder->m_InStream.GetProcessedSize();
+      packSize = Decoder->Base.BitDecoder.GetProcessedSize();
     }
     catch(const CInBufferException &e) { res = e.ErrorCode;  if (res != S_OK) res = E_FAIL; }
     catch(...) { res = E_FAIL; }
@@ -751,7 +793,7 @@ void CState::ThreadFunc()
 
     Decoder->CS.Leave();
 
-    DecodeBlock1(Counters, blockSize);
+    DecodeBlock1(Counters, props.blockSize);
 
     bool needFinish = true;
     try
@@ -760,9 +802,7 @@ void CState::ThreadFunc()
       needFinish = Decoder->StreamWasFinished2;
       if (!needFinish)
       {
-        if ((randMode ?
-            DecodeBlock2Rand(Counters + 256, blockSize, origPtr, Decoder->m_OutStream) :
-            DecodeBlock2(Counters + 256, blockSize, origPtr, Decoder->m_OutStream)) == crc)
+        if (DecodeBlock(props, Counters + 256, Decoder->m_OutStream) == crc)
           res = Decoder->SetRatioProgress(packSize);
         else
           res = S_FALSE;
@@ -818,8 +858,17 @@ enum
   NSIS_STATE_ERROR
 };
 
-STDMETHODIMP CNsisDecoder::SetInStream(ISequentialInStream *inStream) { m_InStream.SetStream(inStream); return S_OK; }
-STDMETHODIMP CNsisDecoder::ReleaseInStream() { m_InStream.ReleaseStream(); return S_OK; }
+STDMETHODIMP CNsisDecoder::SetInStream(ISequentialInStream *inStream)
+{
+  Base.InStreamRef = inStream;
+  Base.BitDecoder.SetStream(inStream);
+  return S_OK;
+}
+STDMETHODIMP CNsisDecoder::ReleaseInStream()
+{
+  Base.InStreamRef.Release();
+  return S_OK;
+}
 
 STDMETHODIMP CNsisDecoder::SetOutStreamSize(const UInt64 * /* outSize */)
 {
@@ -843,17 +892,17 @@ STDMETHODIMP CNsisDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 
   if (_nsisState == NSIS_STATE_INIT)
   {
-    if (!m_InStream.Create(kBufferSize))
+    if (!Base.BitDecoder.Create(kBufferSize))
       return E_OUTOFMEMORY;
     if (!state.Alloc())
       return E_OUTOFMEMORY;
-    m_InStream.Init();
+    Base.BitDecoder.Init();
     _nsisState = NSIS_STATE_NEW_BLOCK;
   }
 
   if (_nsisState == NSIS_STATE_NEW_BLOCK)
   {
-    Byte b = (Byte)m_InStream.ReadBits(8);
+    Byte b = (Byte)Base.ReadBits(8);
     if (b == kFinSig0)
     {
       _nsisState = NSIS_STATE_FINISHED;
@@ -864,12 +913,13 @@ STDMETHODIMP CNsisDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
       _nsisState = NSIS_STATE_ERROR;
       return S_FALSE;
     }
-    UInt32 origPtr;
-    RINOK(ReadBlock(&m_InStream, state.Counters, 9 * kBlockSizeStep,
-        m_Selectors, m_HuffmanDecoders, &_blockSize, &origPtr, NULL));
-    DecodeBlock1(state.Counters, _blockSize);
+    CBlockProps props;
+    props.randMode = false;
+    RINOK(Base.ReadBlock(state.Counters, 9 * kBlockSizeStep, &props));
+    _blockSize = props.blockSize;
+    DecodeBlock1(state.Counters, props.blockSize);
     const UInt32 *tt = state.Counters + 256;
-    _tPos = tt[tt[origPtr] >> 8];
+    _tPos = tt[tt[props.origPtr] >> 8];
     _prevByte = (unsigned)(_tPos & 0xFF);
     _numReps = 0;
     _repRem = 0;

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,11 @@ public:
   HRESULT Result2;
 
   UInt32 BlockSizeMax;
+
+  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 Create();
   void Free();
@@ -134,15 +169,9 @@ public:
   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;

CPP/7zip/Compress/BZip2Encoder.cpp

@@ -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()
 {
@@ -244,9 +244,8 @@ 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::WriteBits2(UInt32 value, unsigned 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::WriteCrc2(UInt32 v)
 {
@@ -254,9 +253,8 @@ void CThreadInfo::WriteCrc2(UInt32 v)
     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::WriteBits(UInt32 value, unsigned 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::WriteCrc(UInt32 v)
 {
@@ -318,7 +316,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
@@ -374,7 +372,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
   {
     int numTables;
 
-    if(m_OptimizeNumTables)
+    if (m_OptimizeNumTables)
     {
       m_OutStreamCurrent->SetPos(startPos);
       m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
@@ -415,12 +413,12 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         Byte *lens = Lens[t - 1];
         int 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);
     }
     
     
@@ -430,7 +428,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         int t = 0;
         do
           memset(Freqs[t], 0, sizeof(Freqs[t]));
-        while(++t < numTables);
+        while (++t < numTables);
       }
       
       {
@@ -465,7 +463,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
               bestPrice = price;
             }
           }
-          while(++t < numTables);
+          while (++t < numTables);
           UInt32 *freqs = Freqs[m_Selectors[g++]];
           int j = 0;
           do
@@ -483,10 +481,10 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         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);
     }
     
     {
@@ -495,7 +493,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         int t = 0;
         do
           mtfSel[t] = (Byte)t;
-        while(++t < numTables);
+        while (++t < numTables);
       }
       
       UInt32 i = 0;
@@ -510,7 +508,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
           mtfSel[pos] = mtfSel[pos - 1];
         mtfSel[0] = sel;
       }
-      while(++i < numSelectors);
+      while (++i < numSelectors);
     }
     
     {
@@ -542,7 +540,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
         }
         while (++i < alphaSize);
       }
-      while(++t < numTables);
+      while (++t < numTables);
     }
     
     {
@@ -722,7 +720,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));
@@ -770,8 +768,6 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   m_OutStream.SetStream(outStream);
   m_OutStream.Init();
 
-  CFlusher flusher(this);
-
   CombinedCrc.Init();
   #ifndef _7ZIP_ST
   NextBlockIndex = 0;

CPP/7zip/Compress/BZip2Encoder.h

@@ -25,61 +25,61 @@ namespace NBZip2 {
 
 class CMsbfEncoderTemp
 {
-  UInt32 m_Pos;
-  int m_BitPos;
-  Byte m_CurByte;
-  Byte *Buffer;
+  UInt32 _pos;
+  unsigned _bitPos;
+  Byte _curByte;
+  Byte *_buf;
 public:
-  void SetStream(Byte *buffer) { Buffer = buffer;  }
-  Byte *GetStream() const { return Buffer; }
+  void SetStream(Byte *buf) { _buf = buf;  }
+  Byte *GetStream() const { return _buf; }
 
   void Init()
   {
-    m_Pos = 0;
-    m_BitPos = 8;
-    m_CurByte = 0;
+    _pos = 0;
+    _bitPos = 8;
+    _curByte = 0;
   }
 
   void Flush()
   {
-    if (m_BitPos < 8)
-      WriteBits(0, m_BitPos);
+    if (_bitPos < 8)
+      WriteBits(0, _bitPos);
   }
 
-  void WriteBits(UInt32 value, int numBits)
+  void WriteBits(UInt32 value, unsigned numBits)
   {
     while (numBits > 0)
     {
-      int numNewBits = MyMin(numBits, m_BitPos);
+      unsigned numNewBits = MyMin(numBits, _bitPos);
       numBits -= numNewBits;
       
-      m_CurByte <<= numNewBits;
+      _curByte <<= numNewBits;
       UInt32 newBits = value >> numBits;
-      m_CurByte |= Byte(newBits);
+      _curByte |= Byte(newBits);
       value -= (newBits << numBits);
       
-      m_BitPos -= numNewBits;
+      _bitPos -= numNewBits;
       
-      if (m_BitPos == 0)
+      if (_bitPos == 0)
       {
-       Buffer[m_Pos++] = m_CurByte;
-        m_BitPos = 8;
+       _buf[_pos++] = _curByte;
+        _bitPos = 8;
       }
     }
   }
   
-  UInt32 GetBytePos() const { return m_Pos ; }
-  UInt32 GetPos() const { return m_Pos * 8 + (8 - m_BitPos); }
-  Byte GetCurByte() const { return m_CurByte; }
+  UInt32 GetBytePos() const { return _pos ; }
+  UInt32 GetPos() const { return _pos * 8 + (8 - _bitPos); }
+  Byte GetCurByte() const { return _curByte; }
   void SetPos(UInt32 bitPos)
   {
-    m_Pos = bitPos / 8;
-    m_BitPos = 8 - ((int)bitPos & 7);
+    _pos = bitPos >> 3;
+    _bitPos = 8 - ((unsigned)bitPos & 7);
   }
-  void SetCurState(int bitPos, Byte curByte)
+  void SetCurState(unsigned bitPos, Byte curByte)
   {
-    m_BitPos = 8 - bitPos;
-    m_CurByte = curByte;
+    _bitPos = 8 - bitPos;
+    _curByte = curByte;
   }
 };
 
@@ -109,7 +109,7 @@ private:
 
   UInt32 m_BlockIndex;
 
-  void WriteBits2(UInt32 value, UInt32 numBits);
+  void WriteBits2(UInt32 value, unsigned numBits);
   void WriteByte2(Byte b);
   void WriteBit2(bool v);
   void WriteCrc2(UInt32 v);
@@ -193,10 +193,10 @@ public:
   CThreadInfo ThreadsInfo;
   #endif
 
-  UInt32 ReadRleBlock(Byte *buffer);
+  UInt32 ReadRleBlock(Byte *buf);
   void WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte);
 
-  void WriteBits(UInt32 value, UInt32 numBits);
+  void WriteBits(UInt32 value, unsigned numBits);
   void WriteByte(Byte b);
   void WriteBit(bool v);
   void WriteCrc(UInt32 v);
@@ -214,23 +214,6 @@ public:
 
   HRESULT Flush() { return m_OutStream.Flush(); }
   
-  void ReleaseStreams()
-  {
-    m_InStream.ReleaseStream();
-    m_OutStream.ReleaseStream();
-  }
-
-  class CFlusher
-  {
-    CEncoder *_coder;
-  public:
-    CFlusher(CEncoder *coder): _coder(coder) {}
-    ~CFlusher()
-    {
-      _coder->ReleaseStreams();
-    }
-  };
-
   #ifndef _7ZIP_ST
   MY_UNKNOWN_IMP2(ICompressSetCoderMt, ICompressSetCoderProperties)
   #else

CPP/7zip/Compress/Bcj2Coder.cpp

@@ -15,35 +15,22 @@ inline unsigned GetIndex(Byte b0, Byte b1) { return ((b1 == 0xE8) ? b0 : ((b1 ==
 
 #ifndef EXTRACT_ONLY
 
-static const int kBufferSize = 1 << 17;
+static const unsigned kBufSize = 1 << 17;
+
+#define NUM_BITS 2
+#define SIGN_BIT (1 << NUM_BITS)
+#define MASK_HIGH (0x100 - (1 << (NUM_BITS + 1)))
+
+static const UInt32 kDefaultLimit = (1 << (24 + NUM_BITS));
 
 static bool inline Test86MSByte(Byte b)
 {
-  return (b == 0 || b == 0xFF);
-}
-
-bool CEncoder::Create()
-{
-  if (!_mainStream.Create(1 << 18))
-    return false;
-  if (!_callStream.Create(1 << 18))
-    return false;
-  if (!_jumpStream.Create(1 << 18))
-    return false;
-  if (!_rangeEncoder.Create(1 << 20))
-    return false;
-  if (_buffer == 0)
-  {
-    _buffer = (Byte *)MidAlloc(kBufferSize);
-    if (_buffer == 0)
-      return false;
-  }
-  return true;
+  return (((b) + SIGN_BIT) & MASK_HIGH) == 0;
 }
 
 CEncoder::~CEncoder()
 {
-  ::MidFree(_buffer);
+  ::MidFree(_buf);
 }
 
 HRESULT CEncoder::Flush()
@@ -51,12 +38,10 @@ HRESULT CEncoder::Flush()
   RINOK(_mainStream.Flush());
   RINOK(_callStream.Flush());
   RINOK(_jumpStream.Flush());
-  _rangeEncoder.FlushData();
-  return _rangeEncoder.FlushStream();
+  _rc.FlushData();
+  return _rc.FlushStream();
 }
 
-const UInt32 kDefaultLimit = (1 << 24);
-
 HRESULT CEncoder::CodeReal(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
     ISequentialOutStream **outStreams, const UInt64 ** /* outSizes */, UInt32 numOutStreams,
     ICompressProgressInfo *progress)
@@ -64,32 +49,34 @@ HRESULT CEncoder::CodeReal(ISequentialInStream **inStreams, const UInt64 **inSiz
   if (numInStreams != 1 || numOutStreams != 4)
     return E_INVALIDARG;
 
-  if (!Create())
-    return E_OUTOFMEMORY;
+  if (!_mainStream.Create(1 << 18)) return E_OUTOFMEMORY;
+  if (!_callStream.Create(1 << 18)) return E_OUTOFMEMORY;
+  if (!_jumpStream.Create(1 << 18)) return E_OUTOFMEMORY;
+  if (!_rc.Create(1 << 20)) return E_OUTOFMEMORY;
+  if (_buf == 0)
+  {
+    _buf = (Byte *)MidAlloc(kBufSize);
+    if (_buf == 0)
+      return E_OUTOFMEMORY;
+  }
 
   bool sizeIsDefined = false;
   UInt64 inSize = 0;
-  if (inSizes != NULL)
-    if (inSizes[0] != NULL)
+  if (inSizes)
+    if (inSizes[0])
     {
       inSize = *inSizes[0];
       if (inSize <= kDefaultLimit)
         sizeIsDefined = true;
     }
 
-  CCoderReleaser releaser(this);
-
   ISequentialInStream *inStream = inStreams[0];
 
-  _mainStream.SetStream(outStreams[0]);
-  _mainStream.Init();
-  _callStream.SetStream(outStreams[1]);
-  _callStream.Init();
-  _jumpStream.SetStream(outStreams[2]);
-  _jumpStream.Init();
-  _rangeEncoder.SetStream(outStreams[3]);
-  _rangeEncoder.Init();
-  for (int i = 0; i < 256 + 2; i++)
+  _mainStream.SetStream(outStreams[0]); _mainStream.Init();
+  _callStream.SetStream(outStreams[1]); _callStream.Init();
+  _jumpStream.SetStream(outStreams[2]); _jumpStream.Init();
+  _rc.SetStream(outStreams[3]); _rc.Init();
+  for (unsigned i = 0; i < 256 + 2; i++)
     _statusEncoder[i].Init();
 
   CMyComPtr<ICompressGetSubStreamSize> getSubStreamSize;
@@ -99,12 +86,12 @@ HRESULT CEncoder::CodeReal(ISequentialInStream **inStreams, const UInt64 **inSiz
 
   UInt32 nowPos = 0;
   UInt64 nowPos64 = 0;
-  UInt32 bufferPos = 0;
+  UInt32 bufPos = 0;
 
   Byte prevByte = 0;
 
   UInt64 subStreamIndex = 0;
-  UInt64 subStreamStartPos  = 0;
+  UInt64 subStreamStartPos = 0;
   UInt64 subStreamEndPos = 0;
 
   for (;;)
@@ -112,23 +99,23 @@ HRESULT CEncoder::CodeReal(ISequentialInStream **inStreams, const UInt64 **inSiz
     UInt32 processedSize = 0;
     for (;;)
     {
-      UInt32 size = kBufferSize - (bufferPos + processedSize);
+      UInt32 size = kBufSize - (bufPos + processedSize);
       UInt32 processedSizeLoc;
       if (size == 0)
         break;
-      RINOK(inStream->Read(_buffer + bufferPos + processedSize, size, &processedSizeLoc));
+      RINOK(inStream->Read(_buf + bufPos + processedSize, size, &processedSizeLoc));
       if (processedSizeLoc == 0)
         break;
       processedSize += processedSizeLoc;
     }
-    UInt32 endPos = bufferPos + processedSize;
+    UInt32 endPos = bufPos + processedSize;
     
     if (endPos < 5)
     {
       // change it
-      for (bufferPos = 0; bufferPos < endPos; bufferPos++)
+      for (bufPos = 0; bufPos < endPos; bufPos++)
       {
-        Byte b = _buffer[bufferPos];
+        Byte b = _buf[bufPos];
         _mainStream.WriteByte(b);
         UInt32 index;
         if (b == 0xE8)
@@ -142,37 +129,37 @@ HRESULT CEncoder::CodeReal(ISequentialInStream **inStreams, const UInt64 **inSiz
           prevByte = b;
           continue;
         }
-        _statusEncoder[index].Encode(&_rangeEncoder, 0);
+        _statusEncoder[index].Encode(&_rc, 0);
         prevByte = b;
       }
       return Flush();
     }
 
-    bufferPos = 0;
+    bufPos = 0;
 
     UInt32 limit = endPos - 5;
-    while(bufferPos <= limit)
+    while (bufPos <= limit)
     {
-      Byte b = _buffer[bufferPos];
+      Byte b = _buf[bufPos];
       _mainStream.WriteByte(b);
       if (!IsJ(prevByte, b))
       {
-        bufferPos++;
+        bufPos++;
         prevByte = b;
         continue;
       }
-      Byte nextByte = _buffer[bufferPos + 4];
+      Byte nextByte = _buf[bufPos + 4];
       UInt32 src =
         (UInt32(nextByte) << 24) |
-        (UInt32(_buffer[bufferPos + 3]) << 16) |
-        (UInt32(_buffer[bufferPos + 2]) << 8) |
-        (_buffer[bufferPos + 1]);
-      UInt32 dest = (nowPos + bufferPos + 5) + src;
+        (UInt32(_buf[bufPos + 3]) << 16) |
+        (UInt32(_buf[bufPos + 2]) << 8) |
+        (_buf[bufPos + 1]);
+      UInt32 dest = (nowPos + bufPos + 5) + src;
       // if (Test86MSByte(nextByte))
       bool convert;
-      if (getSubStreamSize != NULL)
+      if (getSubStreamSize)
       {
-        UInt64 currentPos = (nowPos64 + bufferPos);
+        UInt64 currentPos = (nowPos64 + bufPos);
         while (subStreamEndPos < currentPos)
         {
           UInt64 subStreamSize;
@@ -214,8 +201,8 @@ HRESULT CEncoder::CodeReal(ISequentialInStream **inStreams, const UInt64 **inSiz
       unsigned index = GetIndex(prevByte, b);
       if (convert)
       {
-        _statusEncoder[index].Encode(&_rangeEncoder, 1);
-        bufferPos += 5;
+        _statusEncoder[index].Encode(&_rc, 1);
+        bufPos += 5;
         COutBuffer &s = (b == 0xE8) ? _callStream : _jumpStream;
         for (int i = 24; i >= 0; i -= 8)
           s.WriteByte((Byte)(dest >> i));
@@ -223,30 +210,30 @@ HRESULT CEncoder::CodeReal(ISequentialInStream **inStreams, const UInt64 **inSiz
       }
       else
       {
-        _statusEncoder[index].Encode(&_rangeEncoder, 0);
-        bufferPos++;
+        _statusEncoder[index].Encode(&_rc, 0);
+        bufPos++;
         prevByte = b;
       }
     }
-    nowPos += bufferPos;
-    nowPos64 += bufferPos;
+    nowPos += bufPos;
+    nowPos64 += bufPos;
 
-    if (progress != NULL)
+    if (progress)
     {
       /*
       const UInt64 compressedSize =
         _mainStream.GetProcessedSize() +
         _callStream.GetProcessedSize() +
         _jumpStream.GetProcessedSize() +
-        _rangeEncoder.GetProcessedSize();
+        _rc.GetProcessedSize();
       */
       RINOK(progress->SetRatioInfo(&nowPos64, NULL));
     }
  
     UInt32 i = 0;
-    while(bufferPos < endPos)
-      _buffer[i++] = _buffer[bufferPos++];
-    bufferPos = i;
+    while (bufPos < endPos)
+      _buf[i++] = _buf[bufPos++];
+    bufPos = i;
   }
 }
 
@@ -284,46 +271,39 @@ HRESULT CDecoder::CodeReal(ISequentialInStream **inStreams, const UInt64 ** /* i
   if (numInStreams != 4 || numOutStreams != 1)
     return E_INVALIDARG;
 
-  if (!_mainInStream.Create(_inBufSizes[0]))
-    return E_OUTOFMEMORY;
-  if (!_callStream.Create(_inBufSizes[1]))
-    return E_OUTOFMEMORY;
-  if (!_jumpStream.Create(_inBufSizes[2]))
-    return E_OUTOFMEMORY;
-  if (!_rangeDecoder.Create(_inBufSizes[3]))
-    return E_OUTOFMEMORY;
-  if (!_outStream.Create(_outBufSize))
-    return E_OUTOFMEMORY;
+  if (!_mainStream.Create(_inBufSizes[0])) return E_OUTOFMEMORY;
+  if (!_callStream.Create(_inBufSizes[1])) return E_OUTOFMEMORY;
+  if (!_jumpStream.Create(_inBufSizes[2])) return E_OUTOFMEMORY;
+  if (!_rc.Create(_inBufSizes[3])) return E_OUTOFMEMORY;
+  if (!_outStream.Create(_outBufSize)) return E_OUTOFMEMORY;
 
-  CCoderReleaser releaser(this);
-
-  _mainInStream.SetStream(inStreams[0]);
+  _mainStream.SetStream(inStreams[0]);
   _callStream.SetStream(inStreams[1]);
   _jumpStream.SetStream(inStreams[2]);
-  _rangeDecoder.SetStream(inStreams[3]);
+  _rc.SetStream(inStreams[3]);
   _outStream.SetStream(outStreams[0]);
 
-  _mainInStream.Init();
+  _mainStream.Init();
   _callStream.Init();
   _jumpStream.Init();
-  _rangeDecoder.Init();
+  _rc.Init();
   _outStream.Init();
 
-  for (int i = 0; i < 256 + 2; i++)
+  for (unsigned i = 0; i < 256 + 2; i++)
     _statusDecoder[i].Init();
 
   Byte prevByte = 0;
   UInt32 processedBytes = 0;
   for (;;)
   {
-    if (processedBytes >= (1 << 20) && progress != NULL)
+    if (processedBytes >= (1 << 20) && progress)
     {
       /*
       const UInt64 compressedSize =
-        _mainInStream.GetProcessedSize() +
+        _mainStream.GetProcessedSize() +
         _callStream.GetProcessedSize() +
         _jumpStream.GetProcessedSize() +
-        _rangeDecoder.GetProcessedSize();
+        _rc.GetProcessedSize();
       */
       const UInt64 nowPos64 = _outStream.GetProcessedSize();
       RINOK(progress->SetRatioInfo(NULL, &nowPos64));
@@ -334,8 +314,8 @@ HRESULT CDecoder::CodeReal(ISequentialInStream **inStreams, const UInt64 ** /* i
     const UInt32 kBurstSize = (1 << 18);
     for (i = 0; i < kBurstSize; i++)
     {
-      if (!_mainInStream.ReadByte(b))
-        return Flush();
+      if (!_mainStream.ReadByte(b))
+        return _outStream.Flush();
       _outStream.WriteByte(b);
       if (IsJ(prevByte, b))
         break;
@@ -345,14 +325,14 @@ HRESULT CDecoder::CodeReal(ISequentialInStream **inStreams, const UInt64 ** /* i
     if (i == kBurstSize)
       continue;
     unsigned index = GetIndex(prevByte, b);
-    if (_statusDecoder[index].Decode(&_rangeDecoder) == 1)
+    if (_statusDecoder[index].Decode(&_rc) == 1)
     {
       UInt32 src = 0;
       CInBuffer &s = (b == 0xE8) ? _callStream : _jumpStream;
-      for (int i = 0; i < 4; i++)
+      for (unsigned i = 0; i < 4; i++)
       {
         Byte b0;
-        if(!s.ReadByte(b0))
+        if (!s.ReadByte(b0))
           return S_FALSE;
         src <<= 8;
         src |= ((UInt32)b0);

CPP/7zip/Compress/Bcj2Coder.h

@@ -12,7 +12,7 @@
 namespace NCompress {
 namespace NBcj2 {
 
-const int kNumMoveBits = 5;
+const unsigned kNumMoveBits = 5;
 
 #ifndef EXTRACT_ONLY
 
@@ -20,32 +20,15 @@ class CEncoder:
   public ICompressCoder2,
   public CMyUnknownImp
 {
-  Byte *_buffer;
-  bool Create();
+  Byte *_buf;
 
   COutBuffer _mainStream;
   COutBuffer _callStream;
   COutBuffer _jumpStream;
-  NCompress::NRangeCoder::CEncoder _rangeEncoder;
-  NCompress::NRangeCoder::CBitEncoder<kNumMoveBits> _statusEncoder[256 + 2];
+  NRangeCoder::CEncoder _rc;
+  NRangeCoder::CBitEncoder<kNumMoveBits> _statusEncoder[256 + 2];
 
   HRESULT Flush();
-public:
-  void ReleaseStreams()
-  {
-    _mainStream.ReleaseStream();
-    _callStream.ReleaseStream();
-    _jumpStream.ReleaseStream();
-    _rangeEncoder.ReleaseStream();
-  }
-
-  class CCoderReleaser
-  {
-    CEncoder *_coder;
-  public:
-    CCoderReleaser(CEncoder *coder): _coder(coder) {}
-    ~CCoderReleaser() {  _coder->ReleaseStreams(); }
-  };
 
 public:
   MY_UNKNOWN_IMP
@@ -56,7 +39,8 @@ public:
   STDMETHOD(Code)(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
       ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 numOutStreams,
       ICompressProgressInfo *progress);
-  CEncoder(): _buffer(0) {};
+  
+  CEncoder(): _buf(0) {};
   ~CEncoder();
 };
 
@@ -67,37 +51,19 @@ class CDecoder:
   public ICompressSetBufSize,
   public CMyUnknownImp
 {
-  CInBuffer _mainInStream;
+  CInBuffer _mainStream;
   CInBuffer _callStream;
   CInBuffer _jumpStream;
-  NCompress::NRangeCoder::CDecoder _rangeDecoder;
-  NCompress::NRangeCoder::CBitDecoder<kNumMoveBits> _statusDecoder[256 + 2];
+  NRangeCoder::CDecoder _rc;
+  NRangeCoder::CBitDecoder<kNumMoveBits> _statusDecoder[256 + 2];
 
   COutBuffer _outStream;
   UInt32 _inBufSizes[4];
   UInt32 _outBufSize;
 
-public:
-  void ReleaseStreams()
-  {
-    _mainInStream.ReleaseStream();
-    _callStream.ReleaseStream();
-    _jumpStream.ReleaseStream();
-    _rangeDecoder.ReleaseStream();
-    _outStream.ReleaseStream();
-  }
-
-  HRESULT Flush() { return _outStream.Flush(); }
-  class CCoderReleaser
-  {
-    CDecoder *_coder;
-  public:
-    CCoderReleaser(CDecoder *coder): _coder(coder) {}
-    ~CCoderReleaser()  { _coder->ReleaseStreams(); }
-  };
-
 public:
   MY_UNKNOWN_IMP1(ICompressSetBufSize);
+  
   HRESULT CodeReal(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
       ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 numOutStreams,
       ICompressProgressInfo *progress);
@@ -107,6 +73,7 @@ public:
 
   STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
   STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
+
   CDecoder();
 };
 

CPP/7zip/Compress/BitlDecoder.cpp

@@ -12,9 +12,9 @@ struct CInverterTableInitializer
 {
   CInverterTableInitializer()
   {
-    for (int i = 0; i < 256; i++)
+    for (unsigned i = 0; i < 256; i++)
     {
-      int x = ((i & 0x55) << 1) | ((i & 0xAA) >> 1);
+      unsigned x = ((i & 0x55) << 1) | ((i & 0xAA) >> 1);
       x = ((x & 0x33) << 2) | ((x & 0xCC) >> 2);
       kInvertTable[i] = (Byte)(((x & 0x0F) << 4) | ((x & 0xF0) >> 4));
     }

CPP/7zip/Compress/BitlDecoder.h

@@ -9,130 +9,127 @@ namespace NBitl {
 
 const unsigned kNumBigValueBits = 8 * 4;
 const unsigned kNumValueBytes = 3;
-const unsigned kNumValueBits = 8  * kNumValueBytes;
+const unsigned kNumValueBits = 8 * kNumValueBytes;
 
 const UInt32 kMask = (1 << kNumValueBits) - 1;
 
 extern Byte kInvertTable[256];
 
+/* TInByte must support "Extra Bytes" (bytes that can be read after the end of stream
+   TInByte::ReadByte() returns 0xFF after the end of stream
+   TInByte::NumExtraBytes contains the number "Extra Bytes"
+       
+   Bitl decoder can read up to 4 bytes ahead to internal buffer. */
+
 template<class TInByte>
 class CBaseDecoder
 {
 protected:
-  unsigned m_BitPos;
-  UInt32 m_Value;
-  TInByte m_Stream;
+  unsigned _bitPos;
+  UInt32 _value;
+  TInByte _stream;
 public:
-  UInt32 NumExtraBytes;
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialInStream *inStream) { m_Stream.SetStream(inStream); }
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
+  bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+  void SetStream(ISequentialInStream *inStream) { _stream.SetStream(inStream); }
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = kNumBigValueBits;
-    m_Value = 0;
-    NumExtraBytes = 0;
+    _stream.Init();
+    _bitPos = kNumBigValueBits;
+    _value = 0;
   }
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() + NumExtraBytes - (kNumBigValueBits - m_BitPos) / 8; }
+
+  UInt64 GetStreamSize() const { return _stream.GetStreamSize(); }
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() - ((kNumBigValueBits - _bitPos) >> 3); }
+
+  bool ThereAreDataInBitsBuffer() const { return this->_bitPos != kNumBigValueBits; }
 
   void Normalize()
   {
-    for (; m_BitPos >= 8; m_BitPos -= 8)
-    {
-      Byte b = 0;
-      if (!m_Stream.ReadByte(b))
-      {
-        b = 0xFF; // check it
-        NumExtraBytes++;
-      }
-      m_Value = (b << (kNumBigValueBits - m_BitPos)) | m_Value;
-    }
+    for (; _bitPos >= 8; _bitPos -= 8)
+      _value = ((UInt32)_stream.ReadByte() << (kNumBigValueBits - _bitPos)) | _value;
   }
   
   UInt32 ReadBits(unsigned numBits)
   {
     Normalize();
-    UInt32 res = m_Value & ((1 << numBits) - 1);
-    m_BitPos += numBits;
-    m_Value >>= numBits;
+    UInt32 res = _value & ((1 << numBits) - 1);
+    _bitPos += numBits;
+    _value >>= numBits;
     return res;
   }
 
   bool ExtraBitsWereRead() const
   {
-    if (NumExtraBytes == 0)
-      return false;
-    return ((UInt32)(kNumBigValueBits - m_BitPos) < (NumExtraBytes << 3));
+    return (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
   }
+  
+  bool ExtraBitsWereRead_Fast() const
+  {
+    // full version is not inlined in vc6.
+    // return _stream.NumExtraBytes != 0 && (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+    
+    // (_stream.NumExtraBytes > 4) is fast overread detection. It's possible that
+    // it doesn't return true, if small number of extra bits were read.
+    return (_stream.NumExtraBytes > 4);
+  }
+
+  // it must be fixed !!! with extra bits
+  // UInt32 GetNumExtraBytes() const { return _stream.NumExtraBytes; }
 };
 
 template<class TInByte>
 class CDecoder: public CBaseDecoder<TInByte>
 {
-  UInt32 m_NormalValue;
+  UInt32 _normalValue;
 
 public:
   void Init()
   {
     CBaseDecoder<TInByte>::Init();
-    m_NormalValue = 0;
+    _normalValue = 0;
   }
 
   void Normalize()
   {
-    for (; this->m_BitPos >= 8; this->m_BitPos -= 8)
+    for (; this->_bitPos >= 8; this->_bitPos -= 8)
     {
-      Byte b = 0;
-      if (!this->m_Stream.ReadByte(b))
-      {
-        b = 0xFF; // check it
-        this->NumExtraBytes++;
-      }
-      m_NormalValue = (b << (kNumBigValueBits - this->m_BitPos)) | m_NormalValue;
-      this->m_Value = (this->m_Value << 8) | kInvertTable[b];
+      Byte b = this->_stream.ReadByte();
+      _normalValue = ((UInt32)b << (kNumBigValueBits - this->_bitPos)) | _normalValue;
+      this->_value = (this->_value << 8) | kInvertTable[b];
     }
   }
   
   UInt32 GetValue(unsigned numBits)
   {
     Normalize();
-    return ((this->m_Value >> (8 - this->m_BitPos)) & kMask) >> (kNumValueBits - numBits);
+    return ((this->_value >> (8 - this->_bitPos)) & kMask) >> (kNumValueBits - numBits);
   }
 
   void MovePos(unsigned numBits)
   {
-    this->m_BitPos += numBits;
-    m_NormalValue >>= numBits;
+    this->_bitPos += numBits;
+    _normalValue >>= numBits;
   }
   
   UInt32 ReadBits(unsigned numBits)
   {
     Normalize();
-    UInt32 res = m_NormalValue & ((1 << numBits) - 1);
+    UInt32 res = _normalValue & ((1 << numBits) - 1);
     MovePos(numBits);
     return res;
   }
 
-  void AlignToByte() { MovePos((32 - this->m_BitPos) & 7); }
+  void AlignToByte() { MovePos((32 - this->_bitPos) & 7); }
 
-  Byte ReadByte()
+  Byte ReadDirectByte() { return _stream.ReadByte(); }
+
+  Byte ReadAlignedByte()
   {
-    if (this->m_BitPos == kNumBigValueBits)
-    {
-      Byte b = 0;
-      if (!this->m_Stream.ReadByte(b))
-      {
-        b = 0xFF;
-        this->NumExtraBytes++;
-      }
-      return b;
-    }
-    {
-      Byte b = (Byte)(m_NormalValue & 0xFF);
-      MovePos(8);
-      return b;
-    }
+    if (this->_bitPos == kNumBigValueBits)
+      return _stream.ReadByte();
+    Byte b = (Byte)(_normalValue & 0xFF);
+    MovePos(8);
+    return b;
   }
 };
 

CPP/7zip/Compress/BitlEncoder.h

@@ -7,51 +7,50 @@
 
 class CBitlEncoder
 {
-  COutBuffer m_Stream;
-  unsigned m_BitPos;
-  Byte m_CurByte;
+  COutBuffer _stream;
+  unsigned _bitPos;
+  Byte _curByte;
 public:
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialOutStream *outStream) { m_Stream.SetStream(outStream); }
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
-  UInt32 GetBitPosition() const { return (8 - m_BitPos); }
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() + (8 - m_BitPos + 7) /8; }
+  bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+  void SetStream(ISequentialOutStream *outStream) { _stream.SetStream(outStream); }
+  // unsigned GetBitPosition() const { return (8 - _bitPos); }
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() + ((8 - _bitPos + 7) >> 3); }
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = 8;
-    m_CurByte = 0;
+    _stream.Init();
+    _bitPos = 8;
+    _curByte = 0;
   }
   HRESULT Flush()
   {
     FlushByte();
-    return m_Stream.Flush();
+    return _stream.Flush();
   }
   void FlushByte()
   {
-    if (m_BitPos < 8)
-      m_Stream.WriteByte(m_CurByte);
-    m_BitPos = 8;
-    m_CurByte = 0;
+    if (_bitPos < 8)
+      _stream.WriteByte(_curByte);
+    _bitPos = 8;
+    _curByte = 0;
   }
   void WriteBits(UInt32 value, unsigned numBits)
   {
     while (numBits > 0)
     {
-      if (numBits < m_BitPos)
+      if (numBits < _bitPos)
       {
-        m_CurByte |= (value & ((1 << numBits) - 1)) << (8 - m_BitPos);
-        m_BitPos -= numBits;
+        _curByte |= (value & ((1 << numBits) - 1)) << (8 - _bitPos);
+        _bitPos -= numBits;
         return;
       }
-      numBits -= m_BitPos;
-      m_Stream.WriteByte((Byte)(m_CurByte | (value << (8 - m_BitPos))));
-      value >>= m_BitPos;
-      m_BitPos = 8;
-      m_CurByte = 0;
+      numBits -= _bitPos;
+      _stream.WriteByte((Byte)(_curByte | (value << (8 - _bitPos))));
+      value >>= _bitPos;
+      _bitPos = 8;
+      _curByte = 0;
     }
   }
-  void WriteByte(Byte b) { m_Stream.WriteByte(b);}
+  void WriteByte(Byte b) { _stream.WriteByte(b);}
 };
 
 #endif

CPP/7zip/Compress/BitmDecoder.h

@@ -9,45 +9,59 @@ namespace NBitm {
 
 const unsigned kNumBigValueBits = 8 * 4;
 const unsigned kNumValueBytes = 3;
-const unsigned kNumValueBits = 8  * kNumValueBytes;
+const unsigned kNumValueBits = 8 * kNumValueBytes;
 
 const UInt32 kMask = (1 << kNumValueBits) - 1;
 
+// _bitPos - the number of free bits (high bits in _value)
+// (kNumBigValueBits - _bitPos) = (32 - _bitPos) == the number of ready to read bits (low bits of _value)
+
 template<class TInByte>
 class CDecoder
 {
-  unsigned m_BitPos;
-  UInt32 m_Value;
+  unsigned _bitPos;
+  UInt32 _value;
+  TInByte _stream;
 public:
-  TInByte m_Stream;
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialInStream *inStream) { m_Stream.SetStream(inStream);}
-  void ReleaseStream() { m_Stream.ReleaseStream();}
+  bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+  void SetStream(ISequentialInStream *inStream) { _stream.SetStream(inStream);}
 
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = kNumBigValueBits;
+    _stream.Init();
+    _bitPos = kNumBigValueBits;
+    _value = 0;
     Normalize();
   }
   
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (kNumBigValueBits - m_BitPos) / 8; }
-  
+  UInt64 GetStreamSize() const { return _stream.GetStreamSize(); }
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() - ((kNumBigValueBits - _bitPos) >> 3); }
+
+  bool ExtraBitsWereRead() const
+  {
+    return (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+  }
+
+  bool ExtraBitsWereRead_Fast() const
+  {
+    return (_stream.NumExtraBytes > 4);
+  }
+
   void Normalize()
   {
-    for (;m_BitPos >= 8; m_BitPos -= 8)
-      m_Value = (m_Value << 8) | m_Stream.ReadByte();
+    for (; _bitPos >= 8; _bitPos -= 8)
+      _value = (_value << 8) | _stream.ReadByte();
   }
 
   UInt32 GetValue(unsigned numBits) const
   {
-    // return (m_Value << m_BitPos) >> (kNumBigValueBits - numBits);
-    return ((m_Value >> (8 - m_BitPos)) & kMask) >> (kNumValueBits - numBits);
+    // return (_value << _bitPos) >> (kNumBigValueBits - numBits);
+    return ((_value >> (8 - _bitPos)) & kMask) >> (kNumValueBits - numBits);
   }
   
   void MovePos(unsigned numBits)
   {
-    m_BitPos += numBits;
+    _bitPos += numBits;
     Normalize();
   }
   
@@ -58,7 +72,7 @@ public:
     return res;
   }
 
-  void AlignToByte() { MovePos((32 - m_BitPos) & 7); }
+  void AlignToByte() { MovePos((kNumBigValueBits - _bitPos) & 7); }
 };
 
 }

CPP/7zip/Compress/BitmEncoder.h

@@ -8,41 +8,40 @@
 template<class TOutByte>
 class CBitmEncoder
 {
-  TOutByte m_Stream;
-  unsigned m_BitPos;
-  Byte m_CurByte;
+  unsigned _bitPos;
+  Byte _curByte;
+  TOutByte _stream;
 public:
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialOutStream *outStream) { m_Stream.SetStream(outStream);}
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() + (8 - m_BitPos + 7) / 8; }
+  bool Create(UInt32 bufferSize) { return _stream.Create(bufferSize); }
+  void SetStream(ISequentialOutStream *outStream) { _stream.SetStream(outStream);}
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() + ((8 - _bitPos + 7) >> 3); }
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = 8;
-    m_CurByte = 0;
+    _stream.Init();
+    _bitPos = 8;
+    _curByte = 0;
   }
   HRESULT Flush()
   {
-    if (m_BitPos < 8)
-      WriteBits(0, m_BitPos);
-    return m_Stream.Flush();
+    if (_bitPos < 8)
+      WriteBits(0, _bitPos);
+    return _stream.Flush();
   }
   void WriteBits(UInt32 value, unsigned numBits)
   {
     while (numBits > 0)
     {
-      if (numBits < m_BitPos)
+      if (numBits < _bitPos)
       {
-        m_CurByte |= ((Byte)value << (m_BitPos -= numBits));
+        _curByte |= ((Byte)value << (_bitPos -= numBits));
         return;
       }
-      numBits -= m_BitPos;
+      numBits -= _bitPos;
       UInt32 newBits = (value >> numBits);
       value -= (newBits << numBits);
-      m_Stream.WriteByte((Byte)(m_CurByte | newBits));
-      m_BitPos = 8;
-      m_CurByte = 0;
+      _stream.WriteByte((Byte)(_curByte | newBits));
+      _bitPos = 8;
+      _curByte = 0;
     }
   }
 };

CPP/7zip/Compress/BranchMisc.cpp

@@ -6,32 +6,16 @@
 
 #include "BranchMisc.h"
 
-UInt32 CBC_ARM_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARM_Convert(data, size, _bufferPos, 1); }
+#define SUB_FILTER_IMP2(name, coderStr, coderNum) \
+  UInt32 CBC_ ## name ## coderStr::SubFilter(Byte *data, UInt32 size) \
+  { return (UInt32)::name ## Convert(data, size, _bufferPos, coderNum); }
 
-UInt32 CBC_ARM_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARM_Convert(data, size, _bufferPos, 0); }
+#define SUB_FILTER_IMP(name) \
+  SUB_FILTER_IMP2(name, Encoder, 1) \
+  SUB_FILTER_IMP2(name, Decoder, 0) \
 
-UInt32 CBC_ARMT_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARMT_Convert(data, size, _bufferPos, 1); }
-
-UInt32 CBC_ARMT_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARMT_Convert(data, size, _bufferPos, 0); }
-
-UInt32 CBC_PPC_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::PPC_Convert(data, size, _bufferPos, 1); }
-
-UInt32 CBC_PPC_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::PPC_Convert(data, size, _bufferPos, 0); }
-
-UInt32 CBC_SPARC_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::SPARC_Convert(data, size, _bufferPos, 1); }
-
-UInt32 CBC_SPARC_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::SPARC_Convert(data, size, _bufferPos, 0); }
-
-UInt32 CBC_IA64_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::IA64_Convert(data, size, _bufferPos, 1); }
-
-UInt32 CBC_IA64_Decoder::SubFilter(Byte *data, UInt32 size)
-  {  return (UInt32)::IA64_Convert(data, size, _bufferPos, 0); }
+SUB_FILTER_IMP(ARM_)
+SUB_FILTER_IMP(ARMT_)
+SUB_FILTER_IMP(PPC_)
+SUB_FILTER_IMP(SPARC_)
+SUB_FILTER_IMP(IA64_)

CPP/7zip/Compress/CodecExports.cpp

@@ -2,7 +2,10 @@
 
 #include "StdAfx.h"
 
+#include "../../../C/CpuArch.h"
+
 #include "../../Common/ComTry.h"
+#include "../../Common/MyCom.h"
 
 #include "../../Windows/PropVariant.h"
 
@@ -13,10 +16,15 @@
 extern unsigned int g_NumCodecs;
 extern const CCodecInfo *g_Codecs[];
 
+extern unsigned int g_NumHashers;
+extern const CHasherInfo *g_Hashers[];
+
 static const UInt16 kDecodeId = 0x2790;
+static const UInt16 kEncodeId = 0x2791;
+static const UInt16 kHasherId = 0x2792;
 
 DEFINE_GUID(CLSID_CCodec,
-0x23170F69, 0x40C1, kDecodeId, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+0x23170F69, 0x40C1, kDecodeId, 0, 0, 0, 0, 0, 0, 0, 0);
 
 static inline HRESULT SetPropString(const char *s, unsigned int size, PROPVARIANT *value)
 {
@@ -30,13 +38,13 @@ static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value)
   return SetPropString((const char *)&guid, sizeof(GUID), value);
 }
 
-static HRESULT SetClassID(CMethodId id, bool encode, PROPVARIANT *value)
+static HRESULT SetClassID(CMethodId id, UInt16 typeId, PROPVARIANT *value)
 {
-  GUID clsId = CLSID_CCodec;
-  for (int i = 0; i < sizeof(id); i++, id >>= 8)
-    clsId.Data4[i] = (Byte)(id & 0xFF);
-  if (encode)
-    clsId.Data3++;
+  GUID clsId;
+  clsId.Data1 = CLSID_CCodec.Data1;
+  clsId.Data2 = CLSID_CCodec.Data2;
+  clsId.Data3 = typeId;
+  SetUi64(clsId.Data4, id);
   return SetPropGUID(clsId, value);
 }
 
@@ -44,13 +52,14 @@ static HRESULT FindCodecClassId(const GUID *clsID, UInt32 isCoder2, bool isFilte
 {
   index = -1;
   if (clsID->Data1 != CLSID_CCodec.Data1 ||
-      clsID->Data2 != CLSID_CCodec.Data2 ||
-      (clsID->Data3 & ~1) != kDecodeId)
+      clsID->Data2 != CLSID_CCodec.Data2)
     return S_OK;
-  encode = (clsID->Data3 != kDecodeId);
-  UInt64 id = 0;
-  for (int j = 0; j < 8; j++)
-    id |= ((UInt64)clsID->Data4[j]) << (8 * j);
+  encode = true;
+  if (clsID->Data3 == kDecodeId)
+    encode = false;
+  else if (clsID->Data3 != kEncodeId)
+    return S_OK;
+  UInt64 id = GetUi64(clsID->Data4);
   for (unsigned i = 0; i < g_NumCodecs; i++)
   {
     const CCodecInfo &codec = *g_Codecs[i];
@@ -65,7 +74,7 @@ static HRESULT FindCodecClassId(const GUID *clsID, UInt32 isCoder2, bool isFilte
   return S_OK;
 }
 
-STDAPI CreateCoder2(bool encode, UInt32 index, const GUID *iid, void **outObject)
+STDAPI CreateCoder2(bool encode, int index, const GUID *iid, void **outObject)
 {
   COM_TRY_BEGIN
   *outObject = 0;
@@ -88,18 +97,22 @@ STDAPI CreateCoder2(bool encode, UInt32 index, const GUID *iid, void **outObject
       return CLASS_E_CLASSNOTAVAILABLE;
     *outObject = codec.CreateDecoder();
   }
-  if (isCoder)
-    ((ICompressCoder *)*outObject)->AddRef();
-  else if (isCoder2)
-    ((ICompressCoder2 *)*outObject)->AddRef();
-  else
-    ((ICompressFilter *)*outObject)->AddRef();
+  if (*outObject)
+  {
+    if (isCoder)
+      ((ICompressCoder *)*outObject)->AddRef();
+    else if (isCoder2)
+      ((ICompressCoder2 *)*outObject)->AddRef();
+    else
+      ((ICompressFilter *)*outObject)->AddRef();
+  }
   return S_OK;
   COM_TRY_END
 }
 
 STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
 {
+  COM_TRY_BEGIN
   *outObject = 0;
   bool isCoder = (*iid == IID_ICompressCoder) != 0;
   bool isCoder2 = (*iid == IID_ICompressCoder2) != 0;
@@ -113,42 +126,54 @@ STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
     return res;
   if (codecIndex < 0)
     return CLASS_E_CLASSNOTAVAILABLE;
-  return CreateCoder2(encode, codecIndex, iid, outObject);
+
+  const CCodecInfo &codec = *g_Codecs[codecIndex];
+  if (encode)
+    *outObject = codec.CreateEncoder();
+  else
+    *outObject = codec.CreateDecoder();
+  if (*outObject)
+  {
+    if (isCoder)
+      ((ICompressCoder *)*outObject)->AddRef();
+    else if (isCoder2)
+      ((ICompressCoder2 *)*outObject)->AddRef();
+    else
+      ((ICompressFilter *)*outObject)->AddRef();
+  }
+  return S_OK;
+  COM_TRY_END
 }
 
 STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
 {
   ::VariantClear((VARIANTARG *)value);
   const CCodecInfo &codec = *g_Codecs[codecIndex];
-  switch(propID)
+  switch (propID)
   {
     case NMethodPropID::kID:
-    {
       value->uhVal.QuadPart = (UInt64)codec.Id;
       value->vt = VT_UI8;
       break;
-    }
     case NMethodPropID::kName:
       if ((value->bstrVal = ::SysAllocString(codec.Name)) != 0)
         value->vt = VT_BSTR;
       break;
     case NMethodPropID::kDecoder:
       if (codec.CreateDecoder)
-        return SetClassID(codec.Id, false, value);
+        return SetClassID(codec.Id, kDecodeId, value);
       break;
     case NMethodPropID::kEncoder:
       if (codec.CreateEncoder)
-        return SetClassID(codec.Id, true, value);
+        return SetClassID(codec.Id, kEncodeId, value);
       break;
     case NMethodPropID::kInStreams:
-    {
       if (codec.NumInStreams != 1)
       {
         value->vt = VT_UI4;
         value->ulVal = (ULONG)codec.NumInStreams;
       }
       break;
-    }
   }
   return S_OK;
 }
@@ -158,3 +183,101 @@ STDAPI GetNumberOfMethods(UINT32 *numCodecs)
   *numCodecs = g_NumCodecs;
   return S_OK;
 }
+
+
+static int FindHasherClassId(const GUID *clsID)
+{
+  if (clsID->Data1 != CLSID_CCodec.Data1 ||
+      clsID->Data2 != CLSID_CCodec.Data2 ||
+      clsID->Data3 != kHasherId)
+    return -1;
+  UInt64 id = GetUi64(clsID->Data4);
+  for (unsigned i = 0; i < g_NumCodecs; i++)
+    if (id == g_Hashers[i]->Id)
+      return i;
+  return -1;
+}
+
+static HRESULT CreateHasher2(UInt32 index, IHasher **hasher)
+{
+  COM_TRY_BEGIN
+  *hasher = g_Hashers[index]->CreateHasher();
+  if (*hasher)
+    (*hasher)->AddRef();
+  return S_OK;
+  COM_TRY_END
+}
+
+STDAPI CreateHasher(const GUID *clsid, IHasher **outObject)
+{
+  COM_TRY_BEGIN
+  *outObject = 0;
+  int index = FindHasherClassId(clsid);
+  if (index < 0)
+    return CLASS_E_CLASSNOTAVAILABLE;
+  return CreateHasher2(index, outObject);
+  COM_TRY_END
+}
+
+STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
+{
+  ::VariantClear((VARIANTARG *)value);
+  const CHasherInfo &codec = *g_Hashers[codecIndex];
+  switch (propID)
+  {
+    case NMethodPropID::kID:
+      value->uhVal.QuadPart = (UInt64)codec.Id;
+      value->vt = VT_UI8;
+      break;
+    case NMethodPropID::kName:
+      if ((value->bstrVal = ::SysAllocString(codec.Name)) != 0)
+        value->vt = VT_BSTR;
+      break;
+    case NMethodPropID::kEncoder:
+      if (codec.CreateHasher)
+        return SetClassID(codec.Id, kHasherId, value);
+      break;
+    case NMethodPropID::kDigestSize:
+      value->ulVal = (ULONG)codec.DigestSize;
+      value->vt = VT_UI4;
+      break;
+  }
+  return S_OK;
+}
+
+class CHashers:
+  public IHashers,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1(IHashers)
+
+  STDMETHOD_(UInt32, GetNumHashers)();
+  STDMETHOD(GetHasherProp)(UInt32 index, PROPID propID, PROPVARIANT *value);
+  STDMETHOD(CreateHasher)(UInt32 index, IHasher **hasher);
+};
+
+STDAPI GetHashers(IHashers **hashers)
+{
+  COM_TRY_BEGIN
+  *hashers = new CHashers;
+  if (*hashers)
+    (*hashers)->AddRef();
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP_(UInt32) CHashers::GetNumHashers()
+{
+  return g_NumHashers;
+}
+
+STDMETHODIMP CHashers::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  return ::GetHasherProp(index, propID, value);
+}
+
+STDMETHODIMP CHashers::CreateHasher(UInt32 index, IHasher **hasher)
+{
+  return ::CreateHasher2(index, hasher);
+}

CPP/7zip/Compress/CopyCoder.cpp

@@ -22,10 +22,10 @@ STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,
     const UInt64 * /* inSize */, const UInt64 *outSize,
     ICompressProgressInfo *progress)
 {
-  if (_buffer == 0)
+  if (!_buffer)
   {
     _buffer = (Byte *)::MidAlloc(kBufferSize);
-    if (_buffer == 0)
+    if (!_buffer)
       return E_OUTOFMEMORY;
   }
 
@@ -33,9 +33,8 @@ STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,
   for (;;)
   {
     UInt32 size = kBufferSize;
-    if (outSize != 0)
-      if (size > *outSize - TotalSize)
-        size = (UInt32)(*outSize - TotalSize);
+    if (outSize && size > *outSize - TotalSize)
+      size = (UInt32)(*outSize - TotalSize);
     RINOK(inStream->Read(_buffer, size, &size));
     if (size == 0)
       break;
@@ -44,7 +43,7 @@ STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,
       RINOK(WriteStream(outStream, _buffer, size));
     }
     TotalSize += size;
-    if (progress != NULL)
+    if (progress)
     {
       RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize));
     }
@@ -60,8 +59,16 @@ STDMETHODIMP CCopyCoder::GetInStreamProcessedSize(UInt64 *value)
 
 HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress)
 {
-  CMyComPtr<ICompressCoder> copyCoder = new NCompress::CCopyCoder;
+  CMyComPtr<ICompressCoder> copyCoder = new CCopyCoder;
   return copyCoder->Code(inStream, outStream, NULL, NULL, progress);
 }
 
+HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress)
+{
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+  RINOK(copyCoder->Code(inStream, outStream, NULL, &size, progress));
+  return copyCoderSpec->TotalSize == size ? S_OK : E_FAIL;
+}
+
 }

CPP/7zip/Compress/CopyCoder.h

@@ -28,6 +28,7 @@ public:
 };
 
 HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress);
 
 }
 

CPP/7zip/Compress/DeflateConst.h

@@ -48,7 +48,7 @@ const Byte kLenDirectBits32[kFixedLenTableSize] =
 const Byte kLenDirectBits64[kFixedLenTableSize] =
   {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5, 16, 0, 0};
 
-const UInt32 kDistStart[kDistTableSize64]  =
+const UInt32 kDistStart[kDistTableSize64] =
   {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,
   1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768,49152};
 const Byte kDistDirectBits[kDistTableSize64] =
@@ -106,24 +106,21 @@ struct CLevels
   void SubClear()
   {
     UInt32 i;
-    for(i = kNumLitLenCodesMin; i < kFixedMainTableSize; i++)
+    for (i = kNumLitLenCodesMin; i < kFixedMainTableSize; i++)
       litLenLevels[i] = 0;
-    for(i = 0; i < kFixedDistTableSize; i++)
+    for (i = 0; i < kFixedDistTableSize; i++)
       distLevels[i] = 0;
   }
 
   void SetFixedLevels()
   {
-    int i;
+    int i = 0;
+    
+    for (; i < 144; i++) litLenLevels[i] = 8;
+    for (; i < 256; i++) litLenLevels[i] = 9;
+    for (; i < 280; i++) litLenLevels[i] = 7;
+    for (; i < 288; i++) litLenLevels[i] = 8;
     
-    for (i = 0; i < 144; i++)
-      litLenLevels[i] = 8;
-    for (; i < 256; i++)
-      litLenLevels[i] = 9;
-    for (; i < 280; i++)
-      litLenLevels[i] = 7;
-    for (; i < 288; i++)
-      litLenLevels[i] = 8;
     for (i = 0; i < kFixedDistTableSize; i++)  // test it: InfoZip only uses kDistTableSize
       distLevels[i] = 5;
   }

CPP/7zip/Compress/DeflateDecoder.cpp

@@ -8,24 +8,27 @@ namespace NCompress {
 namespace NDeflate {
 namespace NDecoder {
 
-static const int kLenIdFinished = -1;
-static const int kLenIdNeedInit = -2;
-
 CCoder::CCoder(bool deflate64Mode, bool deflateNSIS):
     _deflate64Mode(deflate64Mode),
     _deflateNSIS(deflateNSIS),
     _keepHistory(false),
+    _needFinishInput(false),
     _needInitInStream(true),
     ZlibMode(false) {}
 
-UInt32 CCoder::ReadBits(int numBits)
+UInt32 CCoder::ReadBits(unsigned numBits)
 {
   return m_InBitStream.ReadBits(numBits);
 }
 
-bool CCoder::DeCodeLevelTable(Byte *values, int numSymbols)
+Byte CCoder::ReadAlignedByte()
 {
-  int i = 0;
+  return m_InBitStream.ReadAlignedByte();
+}
+
+bool CCoder::DeCodeLevelTable(Byte *values, unsigned numSymbols)
+{
+  unsigned i = 0;
   do
   {
     UInt32 number = m_LevelDecoder.DecodeSymbol(&m_InBitStream);
@@ -37,25 +40,25 @@ bool CCoder::DeCodeLevelTable(Byte *values, int numSymbols)
       {
         if (i == 0)
           return false;
-        int num = ReadBits(2) + 3;
+        unsigned num = ReadBits(2) + 3;
         for (; num > 0 && i < numSymbols; num--, i++)
           values[i] = values[i - 1];
       }
       else
       {
-        int num;
+        unsigned num;
         if (number == kTableLevel0Number)
           num = ReadBits(3) + 3;
         else
           num = ReadBits(7) + 11;
-        for (;num > 0 && i < numSymbols; num--)
+        for (; num > 0 && i < numSymbols; num--)
           values[i++] = 0;
       }
     }
     else
       return false;
   }
-  while(i < numSymbols);
+  while (i < numSymbols);
   return true;
 }
 
@@ -64,18 +67,22 @@ bool CCoder::DeCodeLevelTable(Byte *values, int numSymbols)
 bool CCoder::ReadTables(void)
 {
   m_FinalBlock = (ReadBits(kFinalBlockFieldSize) == NFinalBlockField::kFinalBlock);
+  if (m_InBitStream.ExtraBitsWereRead())
+    return false;
   UInt32 blockType = ReadBits(kBlockTypeFieldSize);
   if (blockType > NBlockType::kDynamicHuffman)
     return false;
+  if (m_InBitStream.ExtraBitsWereRead())
+    return false;
 
   if (blockType == NBlockType::kStored)
   {
     m_StoredMode = true;
     m_InBitStream.AlignToByte();
-    m_StoredBlockSize = ReadBits(kStoredBlockLengthFieldSize);
+    m_StoredBlockSize = ReadAligned_UInt16(); // ReadBits(kStoredBlockLengthFieldSize)
     if (_deflateNSIS)
       return true;
-    return (m_StoredBlockSize == (UInt16)~ReadBits(kStoredBlockLengthFieldSize));
+    return (m_StoredBlockSize == (UInt16)~ReadAligned_UInt16());
   }
 
   m_StoredMode = false;
@@ -88,29 +95,35 @@ bool CCoder::ReadTables(void)
   }
   else
   {
-    int numLitLenLevels = ReadBits(kNumLenCodesFieldSize) + kNumLitLenCodesMin;
+    unsigned numLitLenLevels = ReadBits(kNumLenCodesFieldSize) + kNumLitLenCodesMin;
     _numDistLevels = ReadBits(kNumDistCodesFieldSize) + kNumDistCodesMin;
-    int numLevelCodes = ReadBits(kNumLevelCodesFieldSize) + kNumLevelCodesMin;
+    unsigned numLevelCodes = ReadBits(kNumLevelCodesFieldSize) + kNumLevelCodesMin;
 
     if (!_deflate64Mode)
       if (_numDistLevels > kDistTableSize32)
         return false;
     
     Byte levelLevels[kLevelTableSize];
-    for (int i = 0; i < kLevelTableSize; i++)
+    for (unsigned i = 0; i < kLevelTableSize; i++)
     {
       int position = kCodeLengthAlphabetOrder[i];
-      if(i < numLevelCodes)
+      if (i < numLevelCodes)
         levelLevels[position] = (Byte)ReadBits(kLevelFieldSize);
       else
         levelLevels[position] = 0;
     }
     
+    if (m_InBitStream.ExtraBitsWereRead())
+      return false;
+
     RIF(m_LevelDecoder.SetCodeLengths(levelLevels));
     
     Byte tmpLevels[kFixedMainTableSize + kFixedDistTableSize];
     if (!DeCodeLevelTable(tmpLevels, numLitLenLevels + _numDistLevels))
       return false;
+    
+    if (m_InBitStream.ExtraBitsWereRead())
+      return false;
 
     levels.SubClear();
     memcpy(levels.litLenLevels, tmpLevels, numLitLenLevels);
@@ -120,7 +133,7 @@ bool CCoder::ReadTables(void)
   return m_DistDecoder.SetCodeLengths(levels.distLevels);
 }
 
-HRESULT CCoder::CodeSpec(UInt32 curSize)
+HRESULT CCoder::CodeSpec(UInt32 curSize, bool finishInputStream)
 {
   if (_remainLen == kLenIdFinished)
     return S_OK;
@@ -136,10 +149,7 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
     _needReadTable = true;
   }
 
-  if (curSize == 0)
-    return S_OK;
-
-  while(_remainLen > 0 && curSize > 0)
+  while (_remainLen > 0 && curSize > 0)
   {
     _remainLen--;
     Byte b = m_OutWindowStream.GetByte(_rep0);
@@ -147,8 +157,10 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
     curSize--;
   }
 
-  while(curSize > 0)
+  while (curSize > 0 || finishInputStream)
   {
+    if (m_InBitStream.ExtraBitsWereRead())
+      return S_FALSE;
     if (_needReadTable)
     {
       if (m_FinalBlock)
@@ -158,19 +170,28 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
       }
       if (!ReadTables())
         return S_FALSE;
+      if (m_InBitStream.ExtraBitsWereRead())
+        return S_FALSE;
       _needReadTable = false;
     }
 
-    if(m_StoredMode)
+    if (m_StoredMode)
     {
+      if (finishInputStream && curSize == 0 && m_StoredBlockSize != 0)
+        return S_FALSE;
+      /* NSIS version contains some bits in bitl bits buffer.
+         So we must read some first bytes via ReadAlignedByte */
+      for (; m_StoredBlockSize > 0 && curSize > 0 && m_InBitStream.ThereAreDataInBitsBuffer(); m_StoredBlockSize--, curSize--)
+        m_OutWindowStream.PutByte(ReadAlignedByte());
       for (; m_StoredBlockSize > 0 && curSize > 0; m_StoredBlockSize--, curSize--)
-        m_OutWindowStream.PutByte(m_InBitStream.ReadByte());
+        m_OutWindowStream.PutByte(m_InBitStream.ReadDirectByte());
       _needReadTable = (m_StoredBlockSize == 0);
       continue;
     }
-    while(curSize > 0)
+    
+    while (curSize > 0)
     {
-      if (m_InBitStream.NumExtraBytes > 4)
+      if (m_InBitStream.ExtraBitsWereRead_Fast())
         return S_FALSE;
 
       UInt32 number = m_MainDecoder.DecodeSymbol(&m_InBitStream);
@@ -190,7 +211,7 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
         number -= kSymbolMatch;
         UInt32 len;
         {
-          int numBits;
+          unsigned numBits;
           if (_deflate64Mode)
           {
             len = kLenStart64[number];
@@ -224,28 +245,40 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
       else
         return S_FALSE;
     }
+    
+    if (finishInputStream && curSize == 0)
+    {
+      if (m_MainDecoder.DecodeSymbol(&m_InBitStream) != kSymbolEndOfBlock)
+        return S_FALSE;
+      _needReadTable = true;
+    }
   }
+
+  if (m_InBitStream.ExtraBitsWereRead())
+    return S_FALSE;
+
   return S_OK;
 }
 
 #ifdef _NO_EXCEPTIONS
 
 #define DEFLATE_TRY_BEGIN
-#define DEFLATE_TRY_END
+#define DEFLATE_TRY_END(res)
 
 #else
 
 #define DEFLATE_TRY_BEGIN try {
-#define DEFLATE_TRY_END } \
-  catch(const CInBufferException &e)  { return e.ErrorCode; } \
-  catch(const CLzOutWindowException &e)  { return e.ErrorCode; } \
-  catch(...) { return S_FALSE; }
+#define DEFLATE_TRY_END(res) } \
+  catch(const CInBufferException &e)  { res = e.ErrorCode; } \
+  catch(const CLzOutWindowException &e)  { res = e.ErrorCode; } \
+  catch(...) { res = S_FALSE; }
 
 #endif
 
 HRESULT CCoder::CodeReal(ISequentialOutStream *outStream,
       const UInt64 *outSize, ICompressProgressInfo *progress)
 {
+  HRESULT res;
   DEFLATE_TRY_BEGIN
   m_OutWindowStream.SetStream(outStream);
   CCoderReleaser flusher(this);
@@ -255,18 +288,23 @@ HRESULT CCoder::CodeReal(ISequentialOutStream *outStream,
   for (;;)
   {
     UInt32 curSize = 1 << 18;
-    if (outSize != 0)
+    bool finishInputStream = false;
+    if (outSize)
     {
       const UInt64 rem = *outSize - (m_OutWindowStream.GetProcessedSize() - start);
-      if (curSize > rem)
+      if (curSize >= rem)
+      {
         curSize = (UInt32)rem;
+        if (ZlibMode || _needFinishInput)
+          finishInputStream = true;
+      }
     }
     if (curSize == 0)
       break;
-    RINOK(CodeSpec(curSize));
+    RINOK(CodeSpec(curSize, finishInputStream));
     if (_remainLen == kLenIdFinished)
       break;
-    if (progress != NULL)
+    if (progress)
     {
       const UInt64 inSize = m_InBitStream.GetProcessedSize() - inStart;
       const UInt64 nowPos64 = m_OutWindowStream.GetProcessedSize() - start;
@@ -277,14 +315,14 @@ HRESULT CCoder::CodeReal(ISequentialOutStream *outStream,
   {
     m_InBitStream.AlignToByte();
     for (int i = 0; i < 4; i++)
-      ZlibFooter[i] = m_InBitStream.ReadByte();
+      ZlibFooter[i] = ReadAlignedByte();
   }
   flusher.NeedFlush = false;
-  HRESULT res = Flush();
+  res = Flush();
   if (res == S_OK && InputEofError())
     return S_FALSE;
+  DEFLATE_TRY_END(res)
   return res;
-  DEFLATE_TRY_END
 }
 
 HRESULT CCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
@@ -307,13 +345,14 @@ STDMETHODIMP CCoder::GetInStreamProcessedSize(UInt64 *value)
 
 STDMETHODIMP CCoder::SetInStream(ISequentialInStream *inStream)
 {
+  m_InStreamRef = inStream;
   m_InBitStream.SetStream(inStream);
   return S_OK;
 }
 
 STDMETHODIMP CCoder::ReleaseInStream()
 {
-  m_InBitStream.ReleaseStream();
+  m_InStreamRef.Release();
   return S_OK;
 }
 
@@ -329,16 +368,22 @@ STDMETHODIMP CCoder::SetOutStreamSize(const UInt64 * /* outSize */)
 
 STDMETHODIMP CCoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
+  HRESULT res;
   DEFLATE_TRY_BEGIN
   if (processedSize)
     *processedSize = 0;
   const UInt64 startPos = m_OutWindowStream.GetProcessedSize();
   m_OutWindowStream.SetMemStream((Byte *)data);
-  RINOK(CodeSpec(size));
-  if (processedSize)
-    *processedSize = (UInt32)(m_OutWindowStream.GetProcessedSize() - startPos);
-  return Flush();
-  DEFLATE_TRY_END
+  res = CodeSpec(size, false);
+  if (res == S_OK)
+  {
+    res = Flush();
+    if (processedSize)
+      *processedSize = (UInt32)(m_OutWindowStream.GetProcessedSize() - startPos);
+  }
+  DEFLATE_TRY_END(res)
+  m_OutWindowStream.SetMemStream(NULL);
+  return res;
 }
 
 #endif

CPP/7zip/Compress/DeflateDecoder.h

@@ -18,6 +18,9 @@ namespace NCompress {
 namespace NDeflate {
 namespace NDecoder {
 
+const int kLenIdFinished = -1;
+const int kLenIdNeedInit = -2;
+
 class CCoder:
   public ICompressCoder,
   public ICompressGetInStreamProcessedSize,
@@ -29,6 +32,7 @@ class CCoder:
   public CMyUnknownImp
 {
   CLzOutWindow m_OutWindowStream;
+  CMyComPtr<ISequentialInStream> m_InStreamRef;
   NBitl::CDecoder<CInBuffer> m_InBitStream;
   NCompress::NHuffman::CDecoder<kNumHuffmanBits, kFixedMainTableSize> m_MainDecoder;
   NCompress::NHuffman::CDecoder<kNumHuffmanBits, kFixedDistTableSize> m_DistDecoder;
@@ -36,22 +40,23 @@ class CCoder:
 
   UInt32 m_StoredBlockSize;
 
+  UInt32 _numDistLevels;
   bool m_FinalBlock;
   bool m_StoredMode;
-  UInt32 _numDistLevels;
-
 
   bool _deflateNSIS;
   bool _deflate64Mode;
   bool _keepHistory;
+  bool _needFinishInput;
+  
   bool _needInitInStream;
+  bool _needReadTable;
   Int32 _remainLen;
   UInt32 _rep0;
-  bool _needReadTable;
 
-  UInt32 ReadBits(int numBits);
+  UInt32 ReadBits(unsigned numBits);
 
-  bool DeCodeLevelTable(Byte *values, int numSymbols);
+  bool DeCodeLevelTable(Byte *values, unsigned numSymbols);
   bool ReadTables();
   
   HRESULT Flush() { return m_OutWindowStream.Flush(); }
@@ -65,12 +70,11 @@ class CCoder:
     {
       if (NeedFlush)
         _coder->Flush();
-      _coder->ReleaseOutStream();
     }
   };
   friend class CCoderReleaser;
 
-  HRESULT CodeSpec(UInt32 curSize);
+  HRESULT CodeSpec(UInt32 curSize, bool finishInputStream);
 public:
   bool ZlibMode;
   Byte ZlibFooter[4];
@@ -78,12 +82,11 @@ public:
   CCoder(bool deflate64Mode, bool deflateNSIS = false);
   virtual ~CCoder() {};
 
-  void SetKeepHistory(bool keepHistory) { _keepHistory = keepHistory; }
+  void Set_KeepHistory(bool keepHistory) { _keepHistory = keepHistory; }
+  void Set_NeedFinishInput(bool needFinishInput) { _needFinishInput = needFinishInput; }
 
-  void ReleaseOutStream()
-  {
-    m_OutWindowStream.ReleaseStream();
-  }
+  bool IsFinished() const { return _remainLen == kLenIdFinished;; }
+  bool IsFinalBlock() const { return m_FinalBlock; }
 
   HRESULT CodeReal(ISequentialOutStream *outStream,
       const UInt64 *outSize, ICompressProgressInfo *progress);
@@ -126,31 +129,24 @@ public:
   }
 
   void AlignToByte() { m_InBitStream.AlignToByte(); }
-  Byte ReadByte() { return (Byte)m_InBitStream.ReadBits(8); }
+  Byte ReadAlignedByte();
+  UInt32 ReadAligned_UInt16() // aligned for Byte range
+  {
+    UInt32 v = m_InBitStream.ReadAlignedByte();
+    return v | ((UInt32)m_InBitStream.ReadAlignedByte() << 8);
+  }
   bool InputEofError() const { return m_InBitStream.ExtraBitsWereRead(); }
+
+  UInt64 GetStreamSize() const { return m_InBitStream.GetStreamSize(); }
   UInt64 GetInputProcessedSize() const { return m_InBitStream.GetProcessedSize(); }
 
   // IGetInStreamProcessedSize
   STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
 };
 
-class CCOMCoder : public CCoder
-{
-public:
-  CCOMCoder(): CCoder(false) {}
-};
-
-class CNsisCOMCoder : public CCoder
-{
-public:
-  CNsisCOMCoder(): CCoder(false, true) {}
-};
-
-class CCOMCoder64 : public CCoder
-{
-public:
-  CCOMCoder64(): CCoder(true) {}
-};
+class CCOMCoder     : public CCoder { public: CCOMCoder(): CCoder(false) {} };
+class CNsisCOMCoder : public CCoder { public: CNsisCOMCoder(): CCoder(false, true) {} };
+class CCOMCoder64   : public CCoder { public: CCOMCoder64(): CCoder(true) {} };
 
 }}}
 

CPP/7zip/Compress/DeflateEncoder.cpp

@@ -5,7 +5,7 @@
 #include "../../../C/Alloc.h"
 #include "../../../C/HuffEnc.h"
 
-#include "Common/ComTry.h"
+#include "../../Common/ComTry.h"
 
 #include "DeflateEncoder.h"
 
@@ -50,11 +50,11 @@ public:
   CFastPosInit()
   {
     int i;
-    for(i = 0; i < kNumLenSlots; i++)
+    for (i = 0; i < kNumLenSlots; i++)
     {
       int c = kLenStart32[i];
       int j = 1 << kLenDirectBits32[i];
-      for(int k = 0; k < j; k++, c++)
+      for (int k = 0; k < j; k++, c++)
         g_LenSlots[c] = (Byte)i;
     }
     
@@ -147,7 +147,7 @@ CCoder::CCoder(bool deflate64Mode):
 
 HRESULT CCoder::Create()
 {
-  COM_TRY_BEGIN
+  // COM_TRY_BEGIN
   if (m_Values == 0)
   {
     m_Values = (CCodeValue *)MyAlloc((kMaxUncompressedBlockSize) * sizeof(CCodeValue));
@@ -197,7 +197,7 @@ HRESULT CCoder::Create()
     _lzInWindow.cutValue = m_MatchFinderCycles;
   m_Created = true;
   return S_OK;
-  COM_TRY_END
+  // COM_TRY_END
 }
 
 HRESULT CCoder::BaseSetEncoderProperties2(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
@@ -264,7 +264,7 @@ NO_INLINE void CCoder::GetMatches()
   if (numPairs > 0)
   {
     UInt32 i;
-    for(i = 0; i < numPairs; i += 2)
+    for (i = 0; i < numPairs; i += 2)
     {
       m_MatchDistances[i + 1] = (UInt16)distanceTmp[i];
       m_MatchDistances[i + 2] = (UInt16)distanceTmp[i + 1];
@@ -316,7 +316,7 @@ NO_INLINE UInt32 CCoder::Backward(UInt32 &backRes, UInt32 cur)
     m_Optimum[posPrev].PosPrev = (UInt16)cur;
     cur = posPrev;
   }
-  while(cur > 0);
+  while (cur > 0);
   backRes = m_Optimum[0].BackPrev;
   m_OptimumCurrentIndex = m_Optimum[0].PosPrev;
   return m_OptimumCurrentIndex;
@@ -324,7 +324,7 @@ NO_INLINE UInt32 CCoder::Backward(UInt32 &backRes, UInt32 cur)
 
 NO_INLINE UInt32 CCoder::GetOptimal(UInt32 &backRes)
 {
-  if(m_OptimumEndIndex != m_OptimumCurrentIndex)
+  if (m_OptimumEndIndex != m_OptimumCurrentIndex)
   {
     UInt32 len = m_Optimum[m_OptimumCurrentIndex].PosPrev - m_OptimumCurrentIndex;
     backRes = m_Optimum[m_OptimumCurrentIndex].BackPrev;
@@ -336,13 +336,13 @@ NO_INLINE UInt32 CCoder::GetOptimal(UInt32 &backRes)
   GetMatches();
 
   UInt32 numDistancePairs = m_MatchDistances[0];
-  if(numDistancePairs == 0)
+  if (numDistancePairs == 0)
     return 1;
 
   const UInt16 *matchDistances = m_MatchDistances + 1;
   UInt32 lenMain = matchDistances[numDistancePairs - 2];
 
-  if(lenMain > m_NumFastBytes)
+  if (lenMain > m_NumFastBytes)
   {
     backRes = matchDistances[numDistancePairs - 1];
     MovePos(lenMain - 1);
@@ -356,7 +356,7 @@ NO_INLINE UInt32 CCoder::GetOptimal(UInt32 &backRes)
 
 
   UInt32 offs = 0;
-  for(UInt32 i = kMatchMinLen; i <= lenMain; i++)
+  for (UInt32 i = kMatchMinLen; i <= lenMain; i++)
   {
     UInt32 distance = matchDistances[offs + 1];
     m_Optimum[i].PosPrev = 0;
@@ -371,17 +371,17 @@ NO_INLINE UInt32 CCoder::GetOptimal(UInt32 &backRes)
   for (;;)
   {
     ++cur;
-    if(cur == lenEnd || cur == kNumOptsBase || m_Pos >= kMatchArrayLimit)
+    if (cur == lenEnd || cur == kNumOptsBase || m_Pos >= kMatchArrayLimit)
       return Backward(backRes, cur);
     GetMatches();
     matchDistances = m_MatchDistances + 1;
 
     UInt32 numDistancePairs = m_MatchDistances[0];
     UInt32 newLen = 0;
-    if(numDistancePairs != 0)
+    if (numDistancePairs != 0)
     {
       newLen = matchDistances[numDistancePairs - 2];
-      if(newLen > m_NumFastBytes)
+      if (newLen > m_NumFastBytes)
       {
         UInt32 len = Backward(backRes, cur);
         m_Optimum[cur].BackPrev = matchDistances[numDistancePairs - 1];
@@ -399,14 +399,14 @@ NO_INLINE UInt32 CCoder::GetOptimal(UInt32 &backRes)
       optimum.Price = curAnd1Price;
       optimum.PosPrev = (UInt16)cur;
     }
-    if(numDistancePairs == 0)
+    if (numDistancePairs == 0)
       continue;
-    while(lenEnd < cur + newLen)
+    while (lenEnd < cur + newLen)
       m_Optimum[++lenEnd].Price = kIfinityPrice;
     offs = 0;
     UInt32 distance = matchDistances[offs + 1];
     curPrice += m_PosPrices[GetPosSlot(distance)];
-    for(UInt32 lenTest = kMatchMinLen; ; lenTest++)
+    for (UInt32 lenTest = kMatchMinLen; ; lenTest++)
     {
       UInt32 curAndLenPrice = curPrice + m_LenPrices[lenTest - kMatchMinLen];
       COptimal &optimum = m_Optimum[cur + lenTest];
@@ -444,12 +444,12 @@ UInt32 CCoder::GetOptimalFast(UInt32 &backRes)
 void CTables::InitStructures()
 {
   UInt32 i;
-  for(i = 0; i < 256; i++)
+  for (i = 0; i < 256; i++)
     litLenLevels[i] = 8;
   litLenLevels[i++] = 13;
-  for(;i < kFixedMainTableSize; i++)
+  for (;i < kFixedMainTableSize; i++)
     litLenLevels[i] = 5;
-  for(i = 0; i < kFixedDistTableSize; i++)
+  for (i = 0; i < kFixedDistTableSize; i++)
     distLevels[i] = 5;
 }
 
@@ -539,7 +539,7 @@ NO_INLINE void CCoder::LevelTableCode(const Byte *levels, int numLevels, const B
       continue;
     
     if (count < minCount)
-      for(int i = 0; i < count; i++)
+      for (int i = 0; i < count; i++)
         WRITE_HF(curLen);
     else if (curLen != 0)
     {
@@ -662,20 +662,20 @@ NO_INLINE void CCoder::SetPrices(const CLevels &levels)
   if (_fastMode)
     return;
   UInt32 i;
-  for(i = 0; i < 256; i++)
+  for (i = 0; i < 256; i++)
   {
     Byte price = levels.litLenLevels[i];
     m_LiteralPrices[i] = ((price != 0) ? price : kNoLiteralStatPrice);
   }
   
-  for(i = 0; i < m_NumLenCombinations; i++)
+  for (i = 0; i < m_NumLenCombinations; i++)
   {
     UInt32 slot = g_LenSlots[i];
     Byte price = levels.litLenLevels[kSymbolMatch + slot];
     m_LenPrices[i] = (Byte)(((price != 0) ? price : kNoLenStatPrice) + m_LenDirectBits[slot]);
   }
   
-  for(i = 0; i < kDistTableSize64; i++)
+  for (i = 0; i < kDistTableSize64; i++)
   {
     Byte price = levels.distLevels[i];
     m_PosPrices[i] = (Byte)(((price != 0) ? price: kNoPosStatPrice) + kDistDirectBits[i]);
@@ -731,7 +731,7 @@ static UInt32 GetStorePrice(UInt32 blockSize, int bitPosition)
     bitPosition = 0;
     blockSize -= curBlockSize;
   }
-  while(blockSize != 0);
+  while (blockSize != 0);
   return price;
 }
 
@@ -747,11 +747,11 @@ void CCoder::WriteStoreBlock(UInt32 blockSize, UInt32 additionalOffset, bool fin
     WriteBits((UInt16)curBlockSize, kStoredBlockLengthFieldSize);
     WriteBits((UInt16)~curBlockSize, kStoredBlockLengthFieldSize);
     const Byte *data = Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow)- additionalOffset;
-    for(UInt32 i = 0; i < curBlockSize; i++)
+    for (UInt32 i = 0; i < curBlockSize; i++)
       m_OutStream.WriteByte(data[i]);
     additionalOffset -= curBlockSize;
   }
-  while(blockSize != 0);
+  while (blockSize != 0);
 }
 
 NO_INLINE UInt32 CCoder::TryDynBlock(int tableIndex, UInt32 numPasses)
@@ -776,11 +776,11 @@ NO_INLINE UInt32 CCoder::TryDynBlock(int tableIndex, UInt32 numPasses)
   (CLevels &)t = m_NewLevels;
 
   m_NumLitLenLevels = kMainTableSize;
-  while(m_NumLitLenLevels > kNumLitLenCodesMin && m_NewLevels.litLenLevels[m_NumLitLenLevels - 1] == 0)
+  while (m_NumLitLenLevels > kNumLitLenCodesMin && m_NewLevels.litLenLevels[m_NumLitLenLevels - 1] == 0)
     m_NumLitLenLevels--;
   
   m_NumDistLevels = kDistTableSize64;
-  while(m_NumDistLevels > kNumDistCodesMin && m_NewLevels.distLevels[m_NumDistLevels - 1] == 0)
+  while (m_NumDistLevels > kNumDistCodesMin && m_NewLevels.distLevels[m_NumDistLevels - 1] == 0)
     m_NumDistLevels--;
   
   UInt32 levelFreqs[kLevelTableSize];
@@ -947,8 +947,6 @@ HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *ou
   m_OutStream.SetStream(outStream);
   m_OutStream.Init();
 
-  CCoderReleaser coderReleaser(this);
-
   m_OptimumEndIndex = m_OptimumCurrentIndex = 0;
 
   CTables &t = m_Tables[1];

CPP/7zip/Compress/DeflateEncoder.h

@@ -5,7 +5,7 @@
 
 #include "../../../C/LzFind.h"
 
-#include "Common/MyCom.h"
+#include "../../Common/MyCom.h"
 
 #include "../ICoder.h"
 
@@ -49,7 +49,7 @@ struct CTables: public CLevels
 typedef struct _CSeqInStream
 {
   ISeqInStream SeqInStream;
-  CMyComPtr<ISequentialInStream> RealStream;
+  ISequentialInStream *RealStream;
 } CSeqInStream;
 
 struct CEncProps
@@ -165,20 +165,6 @@ public:
   
   void WriteBlockData(bool writeMode, bool finalBlock);
 
-  void ReleaseStreams()
-  {
-    _seqInStream.RealStream.Release();
-    m_OutStream.ReleaseStream();
-  }
-  class CCoderReleaser
-  {
-    CCoder *m_Coder;
-  public:
-    CCoderReleaser(CCoder *coder): m_Coder(coder) {}
-    ~CCoderReleaser() { m_Coder->ReleaseStreams(); }
-  };
-  friend class CCoderReleaser;
-
   UInt32 GetBlockPrice(int tableIndex, int numDivPasses);
   void CodeBlock(int tableIndex, bool finalBlock);
 

CPP/7zip/Compress/DllExportsCompress.cpp

@@ -1,4 +1,4 @@
-// DllExports.cpp
+// DllExportsCompress.cpp
 
 #include "StdAfx.h"
 
@@ -8,8 +8,8 @@
 
 #include "../Common/RegisterCodec.h"
 
-static const unsigned int kNumCodecsMax = 32;
-unsigned int g_NumCodecs = 0;
+static const unsigned kNumCodecsMax = 48;
+unsigned g_NumCodecs = 0;
 const CCodecInfo *g_Codecs[kNumCodecsMax];
 void RegisterCodec(const CCodecInfo *codecInfo)
 {
@@ -17,6 +17,15 @@ void RegisterCodec(const CCodecInfo *codecInfo)
     g_Codecs[g_NumCodecs++] = codecInfo;
 }
 
+static const unsigned kNumHashersMax = 16;
+unsigned g_NumHashers = 0;
+const CHasherInfo *g_Hashers[kNumHashersMax];
+void RegisterHasher(const CHasherInfo *hashInfo) throw()
+{
+  if (g_NumHashers < kNumHashersMax)
+    g_Hashers[g_NumHashers++] = hashInfo;
+}
+
 #ifdef _WIN32
 extern "C"
 BOOL WINAPI DllMain(
@@ -42,4 +51,3 @@ STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
 {
   return CreateCoder(clsid, iid, outObject);
 }
-

CPP/7zip/Compress/HuffmanDecoder.h

@@ -3,7 +3,7 @@
 #ifndef __COMPRESS_HUFFMAN_DECODER_H
 #define __COMPRESS_HUFFMAN_DECODER_H
 
-#include "../../Common/Types.h"
+#include "../../Common/MyTypes.h"
 
 namespace NCompress {
 namespace NHuffman {
@@ -25,7 +25,7 @@ public:
     int lenCounts[kNumBitsMax + 1];
     UInt32 tmpPositions[kNumBitsMax + 1];
     int i;
-    for(i = 1; i <= kNumBitsMax; i++)
+    for (i = 1; i <= kNumBitsMax; i++)
       lenCounts[i] = 0;
     UInt32 symbol;
     for (symbol = 0; symbol < m_NumSymbols; symbol++)
@@ -49,7 +49,7 @@ public:
       m_Limits[i] = (i == kNumBitsMax) ? kMaxValue : startPos;
       m_Positions[i] = m_Positions[i - 1] + lenCounts[i - 1];
       tmpPositions[i] = m_Positions[i];
-      if(i <= kNumTableBits)
+      if (i <= kNumTableBits)
       {
         UInt32 limit = (m_Limits[i] >> (kNumBitsMax - kNumTableBits));
         for (; index < limit; index++)

CPP/7zip/Compress/ImplodeDecoder.cpp

@@ -1,9 +1,10 @@
-// Implode/Decoder.cpp
+// ImplodeDecoder.cpp
 
 #include "StdAfx.h"
 
+#include "../../Common/Defs.h"
+
 #include "ImplodeDecoder.h"
-#include "Common/Defs.h"
 
 namespace NCompress {
 namespace NImplode {
@@ -67,11 +68,13 @@ CCoder::CCoder():
 {
 }
 
+/*
 void CCoder::ReleaseStreams()
 {
   m_OutWindowStream.ReleaseStream();
   m_InBitStream.ReleaseStream();
 }
+*/
 
 bool CCoder::ReadLevelItems(NImplode::NHuffman::CDecoder &decoder,
     Byte *levels, int numLevelItems)
@@ -79,7 +82,7 @@ bool CCoder::ReadLevelItems(NImplode::NHuffman::CDecoder &decoder,
   int numCodedStructures = m_InBitStream.ReadBits(kNumBitsInByte) +
       kLevelStructuresNumberAdditionalValue;
   int currentIndex = 0;
-  for(int i = 0; i < numCodedStructures; i++)
+  for (int i = 0; i < numCodedStructures; i++)
   {
     int level = m_InBitStream.ReadBits(kNumLevelStructureLevelBits) +
       kLevelStructureLevelAdditionalValue;
@@ -87,7 +90,7 @@ bool CCoder::ReadLevelItems(NImplode::NHuffman::CDecoder &decoder,
       kLevelStructureRepNumberAdditionalValue;
     if (currentIndex + rep > numLevelItems)
       throw CException(CException::kData);
-    for(int j = 0; j < rep; j++)
+    for (int j = 0; j < rep; j++)
       levels[currentIndex++] = (Byte)level;
   }
   if (currentIndex != numLevelItems)
@@ -113,6 +116,7 @@ bool CCoder::ReadTables(void)
   return ReadLevelItems(m_DistanceDecoder, distanceLevels, kDistanceTableSize);
 }
 
+/*
 class CCoderReleaser
 {
   CCoder *m_Coder;
@@ -120,6 +124,7 @@ public:
   CCoderReleaser(CCoder *coder): m_Coder(coder) {}
   ~CCoderReleaser() { m_Coder->ReleaseStreams(); }
 };
+*/
 
 HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
     const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
@@ -136,19 +141,19 @@ HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *ou
   m_OutWindowStream.Init(false);
   m_InBitStream.SetStream(inStream);
   m_InBitStream.Init();
-  CCoderReleaser coderReleaser(this);
+  // CCoderReleaser coderReleaser(this);
 
   if (!ReadTables())
     return S_FALSE;
   
-  while(pos < unPackSize)
+  while (pos < unPackSize)
   {
     if (progress != NULL && pos % (1 << 16) == 0)
     {
       UInt64 packSize = m_InBitStream.GetProcessedSize();
       RINOK(progress->SetRatioInfo(&packSize, &pos));
     }
-    if(m_InBitStream.ReadBits(1) == kMatchId) // match
+    if (m_InBitStream.ReadBits(1) == kMatchId) // match
     {
       UInt32 lowDistBits = m_InBitStream.ReadBits(m_NumDistanceLowDirectBits);
       UInt32 distance = m_DistanceDecoder.DecodeSymbol(&m_InBitStream);
@@ -159,9 +164,9 @@ HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *ou
       if (lengthSymbol >= kLengthTableSize)
         return S_FALSE;
       UInt32 length = lengthSymbol + m_MinMatchLength;
-      if (lengthSymbol == kLengthTableSize - 1) // special symbol  = 63
+      if (lengthSymbol == kLengthTableSize - 1) // special symbol = 63
         length += m_InBitStream.ReadBits(kNumAdditionalLengthBits);
-      while(distance >= pos && length > 0)
+      while (distance >= pos && length > 0)
       {
         m_OutWindowStream.PutByte(0);
         pos++;

CPP/7zip/Compress/ImplodeDecoder.h

@@ -40,9 +40,8 @@ public:
 
   MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
 
-  void ReleaseStreams();
-  HRESULT Flush() { return m_OutWindowStream.Flush(); }
-
+  // void ReleaseStreams();
+  
   HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
 

CPP/7zip/Compress/ImplodeHuffmanDecoder.cpp

@@ -24,7 +24,7 @@ bool CDecoder::SetCodeLengths(const Byte *codeLengths)
   // int lenCounts[kNumBitsInLongestCode + 1], tmpPositions[kNumBitsInLongestCode + 1];
   int lenCounts[kNumBitsInLongestCode + 2], tmpPositions[kNumBitsInLongestCode + 1];
   int i;
-  for(i = 0; i <= kNumBitsInLongestCode; i++)
+  for (i = 0; i <= kNumBitsInLongestCode; i++)
     lenCounts[i] = 0;
   UInt32 symbolIndex;
   for (symbolIndex = 0; symbolIndex < m_NumSymbols; symbolIndex++)
@@ -34,7 +34,7 @@ bool CDecoder::SetCodeLengths(const Byte *codeLengths)
   // tmpPositions[0] = m_Positions[0] = m_Limitits[0] = 0;
   m_Limitits[kNumBitsInLongestCode + 1] = 0;
   m_Positions[kNumBitsInLongestCode + 1] = 0;
-  lenCounts[kNumBitsInLongestCode + 1] =  0;
+  lenCounts[kNumBitsInLongestCode + 1] = 0;
 
 
   UInt32 startPos = 0;
@@ -68,7 +68,7 @@ UInt32 CDecoder::DecodeSymbol(CInBit *inStream)
   UInt32 numBits = 0;
   UInt32 value = inStream->GetValue(kNumBitsInLongestCode);
   int i;
-  for(i = kNumBitsInLongestCode; i > 0; i--)
+  for (i = kNumBitsInLongestCode; i > 0; i--)
   {
     if (value < m_Limitits[i])
     {

CPP/7zip/Compress/LzOutWindow.h

@@ -3,8 +3,6 @@
 #ifndef __LZ_OUT_WINDOW_H
 #define __LZ_OUT_WINDOW_H
 
-#include "../IStream.h"
-
 #include "../Common/OutBuffer.h"
 
 #ifndef _NO_EXCEPTIONS
@@ -14,7 +12,7 @@ typedef COutBufferException CLzOutWindowException;
 class CLzOutWindow: public COutBuffer
 {
 public:
-  void Init(bool solid = false);
+  void Init(bool solid = false) throw();
   
   // distance >= 0, len > 0,
   bool CopyBlock(UInt32 distance, UInt32 len)
@@ -22,34 +20,34 @@ public:
     UInt32 pos = _pos - distance - 1;
     if (distance >= _pos)
     {
-      if (!_overDict || distance >= _bufferSize)
+      if (!_overDict || distance >= _bufSize)
         return false;
-      pos += _bufferSize;
+      pos += _bufSize;
     }
-    if (_limitPos - _pos > len && _bufferSize - pos > len)
+    if (_limitPos - _pos > len && _bufSize - pos > len)
     {
-      const Byte *src = _buffer + pos;
-      Byte *dest = _buffer + _pos;
+      const Byte *src = _buf + pos;
+      Byte *dest = _buf + _pos;
       _pos += len;
       do
         *dest++ = *src++;
-      while(--len != 0);
+      while (--len != 0);
     }
     else do
     {
-      if (pos == _bufferSize)
+      if (pos == _bufSize)
         pos = 0;
-      _buffer[_pos++] = _buffer[pos++];
+      _buf[_pos++] = _buf[pos++];
       if (_pos == _limitPos)
         FlushWithCheck();
     }
-    while(--len != 0);
+    while (--len != 0);
     return true;
   }
   
   void PutByte(Byte b)
   {
-    _buffer[_pos++] = b;
+    _buf[_pos++] = b;
     if (_pos == _limitPos)
       FlushWithCheck();
   }
@@ -57,9 +55,9 @@ public:
   Byte GetByte(UInt32 distance) const
   {
     UInt32 pos = _pos - distance - 1;
-    if (pos >= _bufferSize)
-      pos += _bufferSize;
-    return _buffer[pos];
+    if (pos >= _bufSize)
+      pos += _bufSize;
+    return _buf[pos];
   }
 };
 

CPP/7zip/Compress/LzhDecoder.cpp

@@ -4,8 +4,6 @@
 
 #include "LzhDecoder.h"
 
-#include "Windows/Defs.h"
-
 namespace NCompress{
 namespace NLzh {
 namespace NDecoder {
@@ -16,7 +14,7 @@ static const int kBlockSizeBits = 16;
 static const int kNumCBits = 9;
 static const int kNumLevelBits = 5; // smallest integer such that (1 << kNumLevelBits) > kNumLevelSymbols/
 
-UInt32 CCoder::ReadBits(int numBits) {  return m_InBitStream.ReadBits(numBits); }
+UInt32 CCoder::ReadBits(int numBits) { return m_InBitStream.ReadBits(numBits); }
 
 HRESULT CCoder::ReadLevelTable()
 {
@@ -163,7 +161,7 @@ STDMETHODIMP CCoder::CodeReal(ISequentialInStream *inStream,
 
   UInt32 blockSize = 0;
 
-  while(pos < *outSize)
+  while (pos < *outSize)
   {
     // for (i = 0; i < dictSize; i++) dtext[i] = 0x20;
     
@@ -191,7 +189,7 @@ STDMETHODIMP CCoder::CodeReal(ISequentialInStream *inStream,
     else
     {
       // offset = (interface->method == LARC_METHOD_NUM) ? 0x100 - 2 : 0x100 - 3;
-      UInt32 len  = c - 256 + kMinMatch;
+      UInt32 len = c - 256 + kMinMatch;
       UInt32 distance = m_PHuffmanDecoder.Decode(&m_InBitStream);
       if (distance != 0)
         distance = (1 << (distance - 1)) + ReadBits(distance - 1);

CPP/7zip/Compress/LzhDecoder.h

@@ -56,11 +56,12 @@ class CCoder :
   CHuffmanDecoder<kNumDistanceSymbols> m_PHuffmanDecoder;
   CHuffmanDecoder<kNumCSymbols> m_CHuffmanDecoder;
 
+  /*
   void ReleaseStreams()
   {
     m_OutWindowStream.ReleaseStream();
-    m_InBitStream.ReleaseStream();
   }
+  */
 
   class CCoderReleaser
   {
@@ -72,7 +73,7 @@ class CCoder :
     {
       if (NeedFlush)
         m_Coder->m_OutWindowStream.Flush();
-      m_Coder->ReleaseStreams();
+      // m_Coder->ReleaseStreams();
     }
   };
   friend class CCoderReleaser;

CPP/7zip/Compress/LzmaDecoder.cpp

@@ -27,7 +27,8 @@ namespace NLzma {
 CDecoder::CDecoder(): _inBuf(0), _propsWereSet(false), _outSizeDefined(false),
   _inBufSize(1 << 20),
   _outBufSize(1 << 22),
-  FinishStream(false)
+  FinishStream(false),
+  NeedMoreInput(false)
 {
   _inSizeProcessed = 0;
   _inPos = _inSize = 0;
@@ -81,6 +82,7 @@ STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
 {
   _inSizeProcessed = 0;
   _inPos = _inSize = 0;
+  NeedMoreInput = false;
   SetOutStreamSizeResume(outSize);
   return S_OK;
 }
@@ -144,9 +146,21 @@ HRESULT CDecoder::CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *
         return S_FALSE;
       RINOK(res2);
       if (stopDecoding)
+      {
+        if (status == LZMA_STATUS_NEEDS_MORE_INPUT)
+          NeedMoreInput = true;
+        if (FinishStream &&
+              status != LZMA_STATUS_FINISHED_WITH_MARK &&
+              status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+          return S_FALSE;
         return S_OK;
+      }
       if (finished)
+      {
+        if (status == LZMA_STATUS_NEEDS_MORE_INPUT)
+          NeedMoreInput = true;
         return (status == LZMA_STATUS_FINISHED_WITH_MARK ? S_OK : S_FALSE);
+      }
     }
     if (progress)
     {

CPP/7zip/Compress/LzmaDecoder.h

@@ -73,10 +73,14 @@ public:
 
   #endif
 
-  bool FinishStream;
+  bool FinishStream; // set it before decoding, if you need to decode full LZMA stream
+  
+  bool NeedMoreInput; // it's set by decoder, if it needs more input data to decode stream
 
   CDecoder();
   virtual ~CDecoder();
+
+  UInt64 GetOutputProcessedSize() const { return _outSizeProcessed; }
 };
 
 }}

CPP/7zip/Compress/LzmaEncoder.cpp

@@ -87,8 +87,8 @@ HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep)
     return S_OK;
   if (propID == NCoderPropID::kReduceSize)
   {
-    if (prop.vt == VT_UI8 && prop.uhVal.QuadPart < (UInt32)(Int32)-1)
-      ep.reduceSize = (UInt32)prop.uhVal.QuadPart;
+    if (prop.vt == VT_UI8)
+      ep.reduceSize = prop.uhVal.QuadPart;
     return S_OK;
   }
   if (prop.vt != VT_UI4)
@@ -124,7 +124,7 @@ STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs,
     switch (propID)
     {
       case NCoderPropID::kEndMarker:
-        if (prop.vt != VT_BOOL) return E_INVALIDARG; props.writeEndMark = (prop.boolVal == VARIANT_TRUE); break;
+        if (prop.vt != VT_BOOL) return E_INVALIDARG; props.writeEndMark = (prop.boolVal != VARIANT_FALSE); break;
       default:
         RINOK(SetLzmaProp(propID, prop, props));
     }
@@ -148,6 +148,7 @@ STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   CCompressProgressWrap progressWrap(progress);
 
   SRes res = LzmaEnc_Encode(_encoder, &outWrap.p, &inWrap.p, progress ? &progressWrap.p : NULL, &g_Alloc, &g_BigAlloc);
+  _inputProcessed = inWrap.Processed;
   if (res == SZ_ERROR_READ && inWrap.Res != S_OK)
     return inWrap.Res;
   if (res == SZ_ERROR_WRITE && outWrap.Res != S_OK)
@@ -156,5 +157,5 @@ STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream
     return progressWrap.Res;
   return SResToHRESULT(res);
 }
-  
+
 }}

CPP/7zip/Compress/LzmaEncoder.h

@@ -19,6 +19,7 @@ class CEncoder:
   public CMyUnknownImp
 {
   CLzmaEncHandle _encoder;
+  UInt64 _inputProcessed;
 public:
   MY_UNKNOWN_IMP2(ICompressSetCoderProperties, ICompressWriteCoderProperties)
     
@@ -29,6 +30,7 @@ public:
 
   CEncoder();
   virtual ~CEncoder();
+  UInt64 GetInputProcessedSize() const { return _inputProcessed; }
 };
 
 }}

CPP/7zip/Compress/Lzx86Converter.cpp

@@ -9,31 +9,31 @@
 namespace NCompress {
 namespace NLzx {
 
-static const int kResidue = 6 + 4;
+static const UInt32 kResidue = 6 + 4;
 
 void Cx86ConvertOutStream::MakeTranslation()
 {
-  if (m_Pos <= kResidue)
+  if (_pos <= kResidue)
     return;
-  UInt32 numBytes = m_Pos - kResidue;
-  Byte *buffer = m_Buffer;
+  UInt32 numBytes = _pos - kResidue;
+  Byte *buf = _buf;
   for (UInt32 i = 0; i < numBytes;)
   {
-    if (buffer[i++] == 0xE8)
+    if (buf[i++] == 0xE8)
     {
       Int32 absValue = 0;
-      int j;
-      for(j = 0; j < 4; j++)
-        absValue += (UInt32)buffer[i + j] << (j * 8);
-      Int32 pos = (Int32)(m_ProcessedSize + i - 1);
-      if (absValue >= -pos && absValue < (Int32)m_TranslationSize)
+      unsigned j;
+      for (j = 0; j < 4; j++)
+        absValue += (UInt32)buf[i + j] << (j * 8);
+      Int32 pos = (Int32)(_processedSize + i - 1);
+      if (absValue >= -pos && absValue < (Int32)_translationSize)
       {
         UInt32 offset = (absValue >= 0) ?
             absValue - pos :
-            absValue + m_TranslationSize;
-        for(j = 0; j < 4; j++)
+            absValue + _translationSize;
+        for (j = 0; j < 4; j++)
         {
-          buffer[i + j] = (Byte)(offset & 0xFF);
+          buf[i + j] = (Byte)(offset & 0xFF);
           offset >>= 8;
         }
       }
@@ -44,46 +44,46 @@ void Cx86ConvertOutStream::MakeTranslation()
 
 STDMETHODIMP Cx86ConvertOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
-  if (!m_TranslationMode)
-    return m_Stream->Write(data, size, processedSize);
+  if (!_translationMode)
+    return _stream->Write(data, size, processedSize);
   UInt32 realProcessedSize = 0;
   while (realProcessedSize < size)
   {
-    UInt32 writeSize = MyMin(size - realProcessedSize, kUncompressedBlockSize - m_Pos);
-    memmove(m_Buffer + m_Pos, (const Byte *)data + realProcessedSize, writeSize);
-    m_Pos += writeSize;
+    UInt32 writeSize = MyMin(size - realProcessedSize, kUncompressedBlockSize - _pos);
+    memcpy(_buf + _pos, (const Byte *)data + realProcessedSize, writeSize);
+    _pos += writeSize;
     realProcessedSize += writeSize;
-    if (m_Pos == kUncompressedBlockSize)
+    if (_pos == kUncompressedBlockSize)
     {
       RINOK(Flush());
     }
   }
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = realProcessedSize;
   return S_OK;
 }
 
 HRESULT Cx86ConvertOutStream::Flush()
 {
-  if (m_Pos == 0)
+  if (_pos == 0)
     return S_OK;
-  if (m_TranslationMode)
+  if (_translationMode)
     MakeTranslation();
   UInt32 pos = 0;
   do
   {
     UInt32 processed;
-    RINOK(m_Stream->Write(m_Buffer + pos, m_Pos - pos, &processed));
+    RINOK(_stream->Write(_buf + pos, _pos - pos, &processed));
     if (processed == 0)
       return E_FAIL;
     pos += processed;
   }
-  while(pos < m_Pos);
-  m_ProcessedSize += m_Pos;
-  m_Pos = 0;
-  m_TranslationMode = (m_TranslationMode && (m_ProcessedSize < (1 << 30)));
+  while (pos < _pos);
+  _processedSize += _pos;
+  _pos = 0;
+  _translationMode = (_translationMode && (_processedSize < ((UInt32)1 << 30)));
   return S_OK;
 }
 

CPP/7zip/Compress/Lzx86Converter.h

@@ -10,29 +10,28 @@
 namespace NCompress {
 namespace NLzx {
 
-const int kUncompressedBlockSize = 1 << 15;
+const unsigned kUncompressedBlockSize = (unsigned)1 << 15;
 
 class Cx86ConvertOutStream:
   public ISequentialOutStream,
   public CMyUnknownImp
 {
-  CMyComPtr<ISequentialOutStream> m_Stream;
-  UInt32 m_ProcessedSize;
-  UInt32 m_Pos;
-  UInt32 m_TranslationSize;
-  bool m_TranslationMode;
-  Byte m_Buffer[kUncompressedBlockSize];
+  ISequentialOutStream *_stream;
+  UInt32 _processedSize;
+  UInt32 _pos;
+  UInt32 _translationSize;
+  bool _translationMode;
+  Byte _buf[kUncompressedBlockSize];
 
   void MakeTranslation();
 public:
-  void SetStream(ISequentialOutStream *outStream) { m_Stream = outStream; }
-  void ReleaseStream() { m_Stream.Release(); }
+  void SetStream(ISequentialOutStream *outStream) { _stream = outStream; }
   void Init(bool translationMode, UInt32 translationSize)
   {
-    m_TranslationMode = translationMode;
-    m_TranslationSize = translationSize;
-    m_ProcessedSize = 0;
-    m_Pos = 0;
+    _translationMode = translationMode;
+    _translationSize = translationSize;
+    _processedSize = 0;
+    _pos = 0;
   }
   HRESULT Flush();
 

CPP/7zip/Compress/LzxDecoder.cpp

@@ -20,12 +20,14 @@ CDecoder::CDecoder(bool wimMode):
   m_x86ConvertOutStream = m_x86ConvertOutStreamSpec;
 }
 
+/*
 void CDecoder::ReleaseStreams()
 {
   m_OutWindowStream.ReleaseStream();
   m_InBitStream.ReleaseStream();
   m_x86ConvertOutStreamSpec->ReleaseStream();
 }
+*/
 
 STDMETHODIMP CDecoder::Flush()
 {
@@ -152,7 +154,7 @@ public:
   {
     if (NeedFlush)
       m_Decoder->Flush();
-    m_Decoder->ReleaseStreams();
+    // m_Decoder->ReleaseStreams();
   }
 };
 
@@ -308,7 +310,8 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     return E_INVALIDARG;
   UInt64 size = *outSize;
 
-  RINOK(SetInStream(inStream));
+  // RINOK(SetInStream(inStream));
+  m_InBitStream.SetStream(inStream);
   m_x86ConvertOutStreamSpec->SetStream(outStream);
   m_OutWindowStream.SetStream(m_x86ConvertOutStream);
   RINOK(SetOutStreamSize(outSize));
@@ -344,17 +347,20 @@ HRESULT CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outS
   catch(...) { return S_FALSE; }
 }
 
+/*
 STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)
 {
+  m_InStreamRef = inStream;
   m_InBitStream.SetStream(inStream);
   return S_OK;
 }
 
 STDMETHODIMP CDecoder::ReleaseInStream()
 {
-  m_InBitStream.ReleaseStream();
+  m_InStreamRef.Release();
   return S_OK;
 }
+*/
 
 STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
 {

CPP/7zip/Compress/LzxDecoder.h

@@ -23,45 +23,44 @@ const UInt32 kBitDecoderValueMask = (1 << kNumValueBits) - 1;
 
 class CDecoder
 {
-  CInBuffer m_Stream;
-  UInt32 m_Value;
-  unsigned m_BitPos;
+  CInBuffer _stream;
+  UInt32 _value;
+  unsigned _bitPos;
 public:
   CDecoder() {}
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
+  bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
 
-  void SetStream(ISequentialInStream *s) { m_Stream.SetStream(s); }
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
+  void SetStream(ISequentialInStream *s) { _stream.SetStream(s); }
 
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = kNumBigValueBits;
+    _stream.Init();
+    _bitPos = kNumBigValueBits;
   }
 
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (kNumBigValueBits - m_BitPos) / 8; }
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() - ((kNumBigValueBits - _bitPos) >> 3); }
   
-  unsigned GetBitPosition() const { return m_BitPos & 0xF; }
+  unsigned GetBitPosition() const { return _bitPos & 0xF; }
 
   void Normalize()
   {
-    for (; m_BitPos >= 16; m_BitPos -= 16)
+    for (; _bitPos >= 16; _bitPos -= 16)
     {
-      Byte b0 = m_Stream.ReadByte();
-      Byte b1 = m_Stream.ReadByte();
-      m_Value = (m_Value << 8) | b1;
-      m_Value = (m_Value << 8) | b0;
+      Byte b0 = _stream.ReadByte();
+      Byte b1 = _stream.ReadByte();
+      _value = (_value << 8) | b1;
+      _value = (_value << 8) | b0;
     }
   }
 
   UInt32 GetValue(unsigned numBits) const
   {
-    return ((m_Value >> ((32 - kNumValueBits) - m_BitPos)) & kBitDecoderValueMask) >> (kNumValueBits - numBits);
+    return ((_value >> ((32 - kNumValueBits) - _bitPos)) & kBitDecoderValueMask) >> (kNumValueBits - numBits);
   }
   
   void MovePos(unsigned numBits)
   {
-    m_BitPos += numBits;
+    _bitPos += numBits;
     Normalize();
   }
 
@@ -82,14 +81,14 @@ public:
 
   bool ReadUInt32(UInt32 &v)
   {
-    if (m_BitPos != 0)
+    if (_bitPos != 0)
       return false;
-    v = ((m_Value >> 16) & 0xFFFF) | ((m_Value << 16) & 0xFFFF0000);
-    m_BitPos = kNumBigValueBits;
+    v = ((_value >> 16) & 0xFFFF) | ((_value << 16) & 0xFFFF0000);
+    _bitPos = kNumBigValueBits;
     return true;
   }
 
-  Byte DirectReadByte() { return m_Stream.ReadByte(); }
+  Byte DirectReadByte() { return _stream.ReadByte(); }
 
 };
 }
@@ -98,6 +97,7 @@ class CDecoder :
   public ICompressCoder,
   public CMyUnknownImp
 {
+  // CMyComPtr<ISequentialInStream> m_InStreamRef;
   NBitStream::CDecoder m_InBitStream;
   CLzOutWindow m_OutWindowStream;
 
@@ -140,14 +140,14 @@ public:
 
   MY_UNKNOWN_IMP
 
-  void ReleaseStreams();
+  // void ReleaseStreams();
   STDMETHOD(Flush)();
 
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
 
-  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
-  STDMETHOD(ReleaseInStream)();
+  // STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  // STDMETHOD(ReleaseInStream)();
   STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
 
   HRESULT SetParams(unsigned numDictBits);

CPP/7zip/Compress/Mtf8.h

@@ -5,19 +5,17 @@
 
 #include "../../../C/CpuArch.h"
 
-#include "../../Common/Types.h"
-
 namespace NCompress {
 
 struct CMtf8Encoder
 {
   Byte Buf[256];
 
-  int FindAndMove(Byte v)
+  unsigned FindAndMove(Byte v)
   {
-    int pos;
+    unsigned pos;
     for (pos = 0; Buf[pos] != v; pos++);
-    int resPos = pos;
+    unsigned resPos = pos;
     for (; pos >= 8; pos -= 8)
     {
       Buf[pos] = Buf[pos - 1];
@@ -29,7 +27,7 @@ struct CMtf8Encoder
       Buf[pos - 6] = Buf[pos - 7];
       Buf[pos - 7] = Buf[pos - 8];
     }
-    for (; pos > 0; pos--)
+    for (; pos != 0; pos--)
       Buf[pos] = Buf[pos - 1];
     Buf[0] = v;
     return resPos;
@@ -81,9 +79,9 @@ struct CMtf8Decoder
   CMtfVar Buf[256 >> MTF_MOVS];
 
   void StartInit() { memset(Buf, 0, sizeof(Buf)); }
-  void Add(unsigned int pos, Byte val) { Buf[pos >> MTF_MOVS] |= ((CMtfVar)val << ((pos & MTF_MASK) << 3));  }
+  void Add(unsigned pos, Byte val) { Buf[pos >> MTF_MOVS] |= ((CMtfVar)val << ((pos & MTF_MASK) << 3));  }
   Byte GetHead() const { return (Byte)Buf[0]; }
-  Byte GetAndMove(unsigned int pos)
+  Byte GetAndMove(unsigned pos)
   {
     UInt32 lim = ((UInt32)pos >> MTF_MOVS);
     pos = (pos & MTF_MASK) << 3;
@@ -164,7 +162,7 @@ public:
         for (int t = Counts[g] - 1; t >= 0; t--, i--)
           Buf[i] = Buf[offset + t];
       }
-      while(g != 0);
+      while (g != 0);
       
       for (i = kSmallSize - 1; i >= 0; i--)
         Buf[i] = SmallBuffer[i];

CPP/7zip/Compress/QuantumDecoder.cpp

@@ -70,7 +70,7 @@ HRESULT CDecoder::CodeSpec(UInt32 curSize)
         {
           lenSlot -= 2;
           int numDirectBits = (int)(lenSlot >> 2);
-          len +=  ((4 | (lenSlot & 3)) << numDirectBits) - 2;
+          len += ((4 | (lenSlot & 3)) << numDirectBits) - 2;
           if (numDirectBits < 6)
             len += _rangeDecoder.Stream.ReadBits(numDirectBits);
         }
@@ -108,7 +108,9 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     return E_INVALIDARG;
   UInt64 size = *outSize;
 
-  SetInStream(inStream);
+  // SetInStream(inStream);
+  _rangeDecoder.SetStream(inStream);
+
   _outWindowStream.SetStream(outStream);
   SetOutStreamSize(outSize);
   CDecoderFlusher flusher(this);
@@ -143,17 +145,20 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   catch(...) { return S_FALSE; }
 }
 
+/*
 STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)
 {
+  m_InStreamRef = inStream;
   _rangeDecoder.SetStream(inStream);
   return S_OK;
 }
 
 STDMETHODIMP CDecoder::ReleaseInStream()
 {
-  _rangeDecoder.ReleaseStream();
+  m_InStreamRef.Release();
   return S_OK;
 }
+*/
 
 STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
 {

CPP/7zip/Compress/QuantumDecoder.h

@@ -21,7 +21,7 @@ class CStreamBitDecoder
 public:
   bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }
   void SetStream(ISequentialInStream *stream) { Stream.SetStream(stream); }
-  void ReleaseStream() { Stream.ReleaseStream(); }
+  // void ReleaseStream() { Stream.ReleaseStream(); }
 
   void Finish() { Value = 0x10000; }
 
@@ -71,7 +71,7 @@ public:
   CStreamBitDecoder Stream;
   bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }
   void SetStream(ISequentialInStream *stream) { Stream.SetStream(stream); }
-  void ReleaseStream() { Stream.ReleaseStream(); }
+  // void ReleaseStream() { Stream.ReleaseStream(); }
 
   void Init()
   {
@@ -196,11 +196,12 @@ public:
 
 class CDecoder:
   public ICompressCoder,
-  public ICompressSetInStream,
-  public ICompressSetOutStreamSize,
+  // public ICompressSetInStream,
+  // public ICompressSetOutStreamSize,
   public CMyUnknownImp
 {
   CLzOutWindow _outWindowStream;
+  // CMyComPtr<ISequentialInStream> m_InStreamRef;
   NRangeCoder::CDecoder _rangeDecoder;
 
   UInt64 _outSize;
@@ -217,15 +218,19 @@ class CDecoder:
   void Init();
   HRESULT CodeSpec(UInt32 size);
 public:
+
+  MY_UNKNOWN_IMP
+
+  /*
   MY_UNKNOWN_IMP2(
       ICompressSetInStream,
       ICompressSetOutStreamSize)
-
   void ReleaseStreams()
   {
     _outWindowStream.ReleaseStream();
     ReleaseInStream();
   }
+  */
 
   class CDecoderFlusher
   {
@@ -237,11 +242,11 @@ public:
     {
       if (NeedFlush)
         _decoder->Flush();
-      _decoder->ReleaseStreams();
+      // _decoder->ReleaseStreams();
     }
   };
 
-  HRESULT Flush() {  return _outWindowStream.Flush(); }
+  HRESULT Flush() { return _outWindowStream.Flush(); }
 
   HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
@@ -249,8 +254,8 @@ public:
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
 
-  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
-  STDMETHOD(ReleaseInStream)();
+  // STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  // STDMETHOD(ReleaseInStream)();
   STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
 
   HRESULT SetParams(int numDictBits);

CPP/7zip/Compress/RangeCoder.h

@@ -1,5 +1,5 @@
 // Compress/RangeCoder.h
-// 2009-05-30 : Igor Pavlov : Public domain
+// 2013-01-10 : Igor Pavlov : Public domain
 
 #ifndef __COMPRESS_RANGE_CODER_H
 #define __COMPRESS_RANGE_CODER_H
@@ -10,7 +10,7 @@
 namespace NCompress {
 namespace NRangeCoder {
 
-const int kNumTopBits = 24;
+const unsigned kNumTopBits = 24;
 const UInt32 kTopValue = (1 << kNumTopBits);
 
 class CEncoder
@@ -21,7 +21,7 @@ public:
   UInt64 Low;
   UInt32 Range;
   COutBuffer Stream;
-  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }
+  bool Create(UInt32 bufSize) { return Stream.Create(bufSize); }
 
   void SetStream(ISequentialOutStream *stream) { Stream.SetStream(stream); }
   void Init()
@@ -36,14 +36,12 @@ public:
   void FlushData()
   {
     // Low += 1;
-    for(int i = 0; i < 5; i++)
+    for (int i = 0; i < 5; i++)
       ShiftLow();
   }
 
   HRESULT FlushStream() { return Stream.Flush();  }
 
-  void ReleaseStream() { Stream.ReleaseStream(); }
-
   void Encode(UInt32 start, UInt32 size, UInt32 total)
   {
     Low += start * (Range /= total);
@@ -57,7 +55,7 @@ public:
 
   void ShiftLow()
   {
-    if ((UInt32)Low < (UInt32)0xFF000000 || (int)(Low >> 32) != 0)
+    if ((UInt32)Low < (UInt32)0xFF000000 || (unsigned)(Low >> 32) != 0)
     {
       Byte temp = _cache;
       do
@@ -65,7 +63,7 @@ public:
         Stream.WriteByte((Byte)(temp + (Byte)(Low >> 32)));
         temp = 0xFF;
       }
-      while(--_cacheSize != 0);
+      while (--_cacheSize != 0);
       _cache = (Byte)((UInt32)Low >> 24);
     }
     _cacheSize++;
@@ -103,7 +101,7 @@ public:
     }
   }
 
-  UInt64 GetProcessedSize() {  return Stream.GetProcessedSize() + _cacheSize + 4; }
+  UInt64 GetProcessedSize() { return Stream.GetProcessedSize() + _cacheSize + 4; }
 };
 
 class CDecoder
@@ -112,7 +110,7 @@ public:
   CInBuffer Stream;
   UInt32 Range;
   UInt32 Code;
-  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }
+  bool Create(UInt32 bufSize) { return Stream.Create(bufSize); }
 
   void Normalize()
   {
@@ -129,15 +127,13 @@ public:
     Stream.Init();
     Code = 0;
     Range = 0xFFFFFFFF;
-    for(int i = 0; i < 5; i++)
+    for (int i = 0; i < 5; i++)
       Code = (Code << 8) | Stream.ReadByte();
   }
 
-  void ReleaseStream() { Stream.ReleaseStream(); }
-
   UInt32 GetThreshold(UInt32 total)
   {
-    return (Code) / ( Range /= total);
+    return (Code) / (Range /= total);
   }
 
   void Decode(UInt32 start, UInt32 size)
@@ -197,7 +193,7 @@ public:
     return symbol;
   }
 
-  UInt64 GetProcessedSize() {return Stream.GetProcessedSize(); }
+  UInt64 GetProcessedSize() { return Stream.GetProcessedSize(); }
 };
 
 }}

CPP/7zip/Compress/RangeCoderBit.h

@@ -1,5 +1,5 @@
 // Compress/RangeCoderBit.h
-// 2009-05-30 : Igor Pavlov : Public domain
+// 2013-01-10 : Igor Pavlov : Public domain
 
 #ifndef __COMPRESS_RANGE_CODER_BIT_H
 #define __COMPRESS_RANGE_CODER_BIT_H
@@ -9,17 +9,17 @@
 namespace NCompress {
 namespace NRangeCoder {
 
-const int kNumBitModelTotalBits  = 11;
+const unsigned kNumBitModelTotalBits = 11;
 const UInt32 kBitModelTotal = (1 << kNumBitModelTotalBits);
 
-const int kNumMoveReducingBits = 4;
+const unsigned kNumMoveReducingBits = 4;
 
-const int kNumBitPriceShiftBits = 4;
+const unsigned kNumBitPriceShiftBits = 4;
 const UInt32 kBitPrice = 1 << kNumBitPriceShiftBits;
 
 extern UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];
 
-template <int numMoveBits>
+template <unsigned numMoveBits>
 class CBitModel
 {
 public:
@@ -39,7 +39,7 @@ public:
   void Init() { Prob = kBitModelTotal / 2; }
 };
 
-template <int numMoveBits>
+template <unsigned numMoveBits>
 class CBitEncoder: public CBitModel<numMoveBits>
 {
 public:
@@ -69,14 +69,14 @@ public:
   }
   UInt32 GetPrice(UInt32 symbol) const
   {
-    return ProbPrices[(this->Prob ^ ((-(int)symbol)) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];
+    return ProbPrices[(this->Prob ^ ((-(int)(Int32)symbol)) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];
   }
   UInt32 GetPrice0() const { return ProbPrices[this->Prob >> kNumMoveReducingBits]; }
   UInt32 GetPrice1() const { return ProbPrices[(this->Prob ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]; }
 };
 
 
-template <int numMoveBits>
+template <unsigned numMoveBits>
 class CBitDecoder: public CBitModel<numMoveBits>
 {
 public:

CPP/7zip/Compress/Rar1Decoder.cpp

@@ -19,6 +19,7 @@ static UInt32 PosHf4[]={0,0,0,0,0,0,0,0,0,255, 257,0,0};
 
 static const UInt32 kHistorySize = (1 << 16);
 
+/*
 class CCoderReleaser
 {
   CDecoder *m_Coder;
@@ -26,12 +27,13 @@ public:
   CCoderReleaser(CDecoder *coder): m_Coder(coder) {}
   ~CCoderReleaser() { m_Coder->ReleaseStreams(); }
 };
+*/
 
 CDecoder::CDecoder(): m_IsSolid(false) { }
 
 void CDecoder::InitStructures()
 {
-  for(int i = 0; i < kNumRepDists; i++)
+  for (int i = 0; i < kNumRepDists; i++)
     m_RepDists[i] = 0;
   m_RepDistPtr = 0;
   LastLength = 0;
@@ -65,9 +67,9 @@ UInt32 CDecoder::DecodeNum(const UInt32 *posTab)
   return((num >> (12 - startPos)) + posTab[startPos]);
 }
 
-static Byte kShortLen1[]  = {1,3,4,4,5,6,7,8,8,4,4,5,6,6 };
+static Byte kShortLen1 [] = {1,3,4,4,5,6,7,8,8,4,4,5,6,6 };
 static Byte kShortLen1a[] = {1,4,4,4,5,6,7,8,8,4,4,5,6,6,4 };
-static Byte kShortLen2[]  = {2,3,3,3,4,4,5,6,6,4,4,5,6,6 };
+static Byte kShortLen2 [] = {2,3,3,3,4,4,5,6,6,4,4,5,6,6 };
 static Byte kShortLen2a[] = {2,3,3,4,4,4,5,6,6,4,4,5,6,6,4 };
 static UInt32 kShortXor1[] = {0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0xc0,0x80,0x90,0x98,0x9c,0xb0};
 static UInt32 kShortXor2[] = {0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xc0,0x80,0x90,0x98,0x9c,0xb0};
@@ -389,7 +391,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   m_InBitStream.SetStream(inStream);
   m_InBitStream.Init();
 
-  CCoderReleaser coderReleaser(this);
+  // CCoderReleaser coderReleaser(this);
   InitData();
   if (!m_IsSolid)
   {

CPP/7zip/Compress/Rar1Decoder.h

@@ -70,11 +70,13 @@ public:
 
   MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
 
+  /*
   void ReleaseStreams()
   {
     m_OutWindowStream.ReleaseStream();
     m_InBitStream.ReleaseStream();
   }
+  */
 
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);

CPP/7zip/Compress/Rar2Decoder.cpp

@@ -85,7 +85,7 @@ CDecoder::CDecoder():
 void CDecoder::InitStructures()
 {
   m_MmFilter.Init();
-  for(int i = 0; i < kNumRepDists; i++)
+  for (int i = 0; i < kNumRepDists; i++)
     m_RepDists[i] = 0;
   m_RepDistPtr = 0;
   m_LastLength = 0;
@@ -191,6 +191,7 @@ bool CDecoder::ReadLastTables()
   return true;
 }
 
+/*
 class CCoderReleaser
 {
   CDecoder *m_Coder;
@@ -201,6 +202,7 @@ public:
     m_Coder->ReleaseStreams();
   }
 };
+*/
 
 bool CDecoder::DecodeMm(UInt32 pos)
 {
@@ -319,7 +321,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   m_InBitStream.SetStream(inStream);
   m_InBitStream.Init();
 
-  CCoderReleaser coderReleaser(this);
+  // CCoderReleaser coderReleaser(this);
   if (!m_IsSolid)
   {
     InitStructures();
@@ -335,7 +337,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   }
 
   UInt64 startPos = m_OutWindowStream.GetProcessedSize();
-  while(pos < unPackSize)
+  while (pos < unPackSize)
   {
     UInt32 blockSize = 1 << 20;
     if (blockSize > unPackSize - pos)

CPP/7zip/Compress/Rar2Decoder.h

@@ -53,10 +53,10 @@ const UInt32 kLen2NumNumbers = 8;
 const UInt32 kReadTableNumber = kLen2Number + kLen2NumNumbers;
 const UInt32 kMatchNumber = kReadTableNumber + 1;
 
-const Byte kLenStart[kLenTableSize]      = {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224};
+const Byte kLenStart     [kLenTableSize] = {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224};
 const Byte kLenDirectBits[kLenTableSize] = {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5};
 
-const UInt32 kDistStart[kDistTableSize]     = {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768U,49152U,65536,98304,131072,196608,262144,327680,393216,458752,524288,589824,655360,720896,786432,851968,917504,983040};
+const UInt32 kDistStart   [kDistTableSize] = {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768U,49152U,65536,98304,131072,196608,262144,327680,393216,458752,524288,589824,655360,720896,786432,851968,917504,983040};
 const Byte kDistDirectBits[kDistTableSize] = {0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5,  6,  6,  7,  7,  8,  8,   9,   9,  10,  10,  11,  11,  12,   12,   13,   13,    14,    14,   15,   15,    16,    16,    16,    16,    16,    16,    16,    16,    16,    16,    16,    16,    16,    16};
 
 const Byte kLevelDirectBits[kLevelTableSize] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7};
@@ -156,11 +156,13 @@ public:
 
   MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
 
+  /*
   void ReleaseStreams()
   {
     m_OutWindowStream.ReleaseStream();
     m_InBitStream.ReleaseStream();
   }
+  */
 
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);

CPP/7zip/Compress/Rar3Decoder.cpp

@@ -25,7 +25,7 @@ static const UInt32 kSymbolReadTable = 256;
 static const UInt32 kSymbolRep = 259;
 static const UInt32 kSymbolLen2 = kSymbolRep + kNumReps;
 
-static const Byte kLenStart[kLenTableSize]      = {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224};
+static const Byte kLenStart     [kLenTableSize] = {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224};
 static const Byte kLenDirectBits[kLenTableSize] = {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5};
 
 static const Byte kDistDirectBits[kDistTableSize] =
@@ -153,7 +153,7 @@ HRESULT CDecoder::WriteBuf()
 {
   UInt32 writtenBorder = _wrPtr;
   UInt32 writeSize = (_winPos - writtenBorder) & kWindowMask;
-  for (int i = 0; i < _tempFilters.Size(); i++)
+  FOR_VECTOR (i, _tempFilters)
   {
     CTempFilter *filter = _tempFilters[i];
     if (filter == NULL)
@@ -202,7 +202,7 @@ HRESULT CDecoder::WriteBuf()
       }
       else
       {
-        for (int j = i; j < _tempFilters.Size(); j++)
+        for (unsigned j = i; j < _tempFilters.Size(); j++)
         {
           CTempFilter *filter = _tempFilters[j];
           if (filter != NULL && filter->NextWindow)
@@ -221,7 +221,7 @@ HRESULT CDecoder::WriteBuf()
 void CDecoder::InitFilters()
 {
   _lastFilter = 0;
-  int i;
+  unsigned i;
   for (i = 0; i < _tempFilters.Size(); i++)
     delete _tempFilters[i];
   _tempFilters.Clear();
@@ -238,7 +238,7 @@ bool CDecoder::AddVmCode(UInt32 firstByte, UInt32 codeSize)
   UInt32 filterIndex;
   if (firstByte & 0x80)
   {
-    filterIndex = NVm::ReadEncodedUInt32(inp);
+    filterIndex = inp.ReadEncodedUInt32();
     if (filterIndex == 0)
       InitFilters();
     else
@@ -267,7 +267,7 @@ bool CDecoder::AddVmCode(UInt32 firstByte, UInt32 codeSize)
   }
 
   int numEmptyItems = 0;
-  int i;
+  unsigned i;
   for (i = 0; i < _tempFilters.Size(); i++)
   {
     _tempFilters[i - numEmptyItems] = _tempFilters[i];
@@ -284,62 +284,56 @@ bool CDecoder::AddVmCode(UInt32 firstByte, UInt32 codeSize)
   CTempFilter *tempFilter = new CTempFilter;
   _tempFilters[_tempFilters.Size() - numEmptyItems] = tempFilter;
   tempFilter->FilterIndex = filterIndex;
-  tempFilter->ExecCount = filter->ExecCount;
  
-  UInt32 blockStart = NVm::ReadEncodedUInt32(inp);
+  UInt32 blockStart = inp.ReadEncodedUInt32();
   if (firstByte & 0x40)
     blockStart += 258;
   tempFilter->BlockStart = (blockStart + _winPos) & kWindowMask;
   if (firstByte & 0x20)
-    filter->BlockSize = NVm::ReadEncodedUInt32(inp);
+    filter->BlockSize = inp.ReadEncodedUInt32();
   tempFilter->BlockSize = filter->BlockSize;
   tempFilter->NextWindow = _wrPtr != _winPos && ((_wrPtr - _winPos) & kWindowMask) <= blockStart;
 
   memset(tempFilter->InitR, 0, sizeof(tempFilter->InitR));
   tempFilter->InitR[3] = NVm::kGlobalOffset;
   tempFilter->InitR[4] = tempFilter->BlockSize;
-  tempFilter->InitR[5] = tempFilter->ExecCount;
+  tempFilter->InitR[5] = filter->ExecCount;
   if (firstByte & 0x10)
   {
     UInt32 initMask = inp.ReadBits(NVm::kNumGpRegs);
     for (int i = 0; i < NVm::kNumGpRegs; i++)
       if (initMask & (1 << i))
-        tempFilter->InitR[i] = NVm::ReadEncodedUInt32(inp);
+        tempFilter->InitR[i] = inp.ReadEncodedUInt32();
   }
   if (newFilter)
   {
-    UInt32 vmCodeSize = NVm::ReadEncodedUInt32(inp);
+    UInt32 vmCodeSize = inp.ReadEncodedUInt32();
     if (vmCodeSize >= kVmCodeSizeMax || vmCodeSize == 0)
       return false;
     for (UInt32 i = 0; i < vmCodeSize; i++)
       _vmCode[i] = (Byte)inp.ReadBits(8);
-    _vm.PrepareProgram(_vmCode, vmCodeSize, filter);
+    filter->PrepareProgram(_vmCode, vmCodeSize);
   }
 
-  tempFilter->AllocateEmptyFixedGlobal();
-
   Byte *globalData = &tempFilter->GlobalData[0];
   for (i = 0; i < NVm::kNumGpRegs; i++)
     NVm::SetValue32(&globalData[i * 4], tempFilter->InitR[i]);
   NVm::SetValue32(&globalData[NVm::NGlobalOffset::kBlockSize], tempFilter->BlockSize);
   NVm::SetValue32(&globalData[NVm::NGlobalOffset::kBlockPos], 0); // It was commented. why?
-  NVm::SetValue32(&globalData[NVm::NGlobalOffset::kExecCount], tempFilter->ExecCount);
+  NVm::SetValue32(&globalData[NVm::NGlobalOffset::kExecCount], filter->ExecCount);
 
   if (firstByte & 8)
   {
-    UInt32 dataSize = NVm::ReadEncodedUInt32(inp);
+    UInt32 dataSize = inp.ReadEncodedUInt32();
     if (dataSize > NVm::kGlobalSize - NVm::kFixedGlobalSize)
       return false;
     CRecordVector<Byte> &globalData = tempFilter->GlobalData;
-    int requredSize = (int)(dataSize + NVm::kFixedGlobalSize);
-    if (globalData.Size() < requredSize)
-    {
-      globalData.Reserve(requredSize);
-      for (; globalData.Size() < requredSize; i++)
-        globalData.Add(0);
-    }
+    unsigned requiredSize = (unsigned)(dataSize + NVm::kFixedGlobalSize);
+    if (globalData.Size() < requiredSize)
+      globalData.ChangeSize_KeepData(requiredSize);
+    Byte *dest = &globalData[NVm::kFixedGlobalSize];
     for (UInt32 i = 0; i < dataSize; i++)
-      globalData[NVm::kFixedGlobalSize + i] = (Byte)inp.ReadBits(8);
+      dest[i] = (Byte)inp.ReadBits(8);
   }
   return true;
 }
@@ -384,6 +378,8 @@ bool CDecoder::ReadVmCodePPM()
   }
   if (length > kVmDataSizeMax)
     return false;
+  if (InputEofError_Fast())
+    return false;
   for (UInt32 i = 0; i < length; i++)
   {
     int b = DecodePpmSymbol();
@@ -396,14 +392,13 @@ bool CDecoder::ReadVmCodePPM()
 
 #define RIF(x) { if (!(x)) return S_FALSE; }
 
-UInt32 CDecoder::ReadBits(int numBits) { return m_InBitStream.bitDecoder.ReadBits(numBits); }
+UInt32 CDecoder::ReadBits(int numBits) { return m_InBitStream.BitDecoder.ReadBits(numBits); }
 
-/////////////////////////////////////////////////
-// PPM
+// ---------- PPM ----------
 
 HRESULT CDecoder::InitPPM()
 {
-  Byte maxOrder = (Byte)ReadBits(7);
+  unsigned maxOrder = (unsigned)ReadBits(7);
 
   bool reset = ((maxOrder & 0x20) != 0);
   int maxMB = 0;
@@ -458,6 +453,8 @@ HRESULT CDecoder::DecodePPM(Int32 num, bool &keepDecompressing)
         return S_OK;
       }
     }
+    if (InputEofError_Fast())
+      return false;
     int c = DecodePpmSymbol();
     if (c < 0)
     {
@@ -526,13 +523,12 @@ HRESULT CDecoder::DecodePPM(Int32 num, bool &keepDecompressing)
   return S_OK;
 }
 
-/////////////////////////////////////////////////
-// LZ
+// ---------- LZ ----------
 
 HRESULT CDecoder::ReadTables(bool &keepDecompressing)
 {
   keepDecompressing = true;
-  ReadBits((8 - m_InBitStream.bitDecoder.GetBitPosition()) & 7);
+  m_InBitStream.BitDecoder.AlignToByte();
   if (ReadBits(1) != 0)
   {
     _lzMode = false;
@@ -571,7 +567,7 @@ HRESULT CDecoder::ReadTables(bool &keepDecompressing)
   i = 0;
   while (i < kTablesSizesSum)
   {
-    UInt32 number = m_LevelDecoder.DecodeSymbol(&m_InBitStream.bitDecoder);
+    UInt32 number = m_LevelDecoder.DecodeSymbol(&m_InBitStream.BitDecoder);
     if (number < 16)
     {
       newLevels[i] = Byte((number + m_LastLevels[i]) & 15);
@@ -620,6 +616,7 @@ HRESULT CDecoder::ReadTables(bool &keepDecompressing)
   return S_OK;
 }
 
+/*
 class CCoderReleaser
 {
   CDecoder *m_Coder;
@@ -630,6 +627,7 @@ public:
     m_Coder->ReleaseStreams();
   }
 };
+*/
 
 HRESULT CDecoder::ReadEndOfBlock(bool &keepDecompressing)
 {
@@ -680,7 +678,11 @@ HRESULT CDecoder::DecodeLZ(bool &keepDecompressing)
         return S_OK;
       }
     }
-    UInt32 number = m_MainDecoder.DecodeSymbol(&m_InBitStream.bitDecoder);
+    
+    if (InputEofError_Fast())
+      return S_FALSE;
+
+    UInt32 number = m_MainDecoder.DecodeSymbol(&m_InBitStream.BitDecoder);
     if (number < 256)
     {
       PutByte((Byte)number);
@@ -724,10 +726,10 @@ HRESULT CDecoder::DecodeLZ(bool &keepDecompressing)
         rep0 = distance;
       }
 
-      UInt32 number = m_LenDecoder.DecodeSymbol(&m_InBitStream.bitDecoder);
+      UInt32 number = m_LenDecoder.DecodeSymbol(&m_InBitStream.BitDecoder);
       if (number >= kLenTableSize)
         return S_FALSE;
-      length = 2 + kLenStart[number] + m_InBitStream.bitDecoder.ReadBits(kLenDirectBits[number]);
+      length = 2 + kLenStart[number] + m_InBitStream.BitDecoder.ReadBits(kLenDirectBits[number]);
     }
     else
     {
@@ -737,14 +739,14 @@ HRESULT CDecoder::DecodeLZ(bool &keepDecompressing)
       if (number < 271)
       {
         number -= 263;
-        rep0 = kLen2DistStarts[number] + m_InBitStream.bitDecoder.ReadBits(kLen2DistDirectBits[number]);
+        rep0 = kLen2DistStarts[number] + m_InBitStream.BitDecoder.ReadBits(kLen2DistDirectBits[number]);
         length = 2;
       }
       else if (number < 299)
       {
         number -= 271;
-        length = kNormalMatchMinLen + (UInt32)kLenStart[number] + m_InBitStream.bitDecoder.ReadBits(kLenDirectBits[number]);
-        UInt32 number = m_DistDecoder.DecodeSymbol(&m_InBitStream.bitDecoder);
+        length = kNormalMatchMinLen + (UInt32)kLenStart[number] + m_InBitStream.BitDecoder.ReadBits(kLenDirectBits[number]);
+        UInt32 number = m_DistDecoder.DecodeSymbol(&m_InBitStream.BitDecoder);
         if (number >= kDistTableSize)
           return S_FALSE;
         rep0 = kDistStart[number];
@@ -752,7 +754,7 @@ HRESULT CDecoder::DecodeLZ(bool &keepDecompressing)
         if (number >= (kNumAlignBits * 2) + 2)
         {
           if (numBits > kNumAlignBits)
-            rep0 += (m_InBitStream.bitDecoder.ReadBits(numBits - kNumAlignBits) << kNumAlignBits);
+            rep0 += (m_InBitStream.BitDecoder.ReadBits(numBits - kNumAlignBits) << kNumAlignBits);
           if (PrevAlignCount > 0)
           {
             PrevAlignCount--;
@@ -760,13 +762,13 @@ HRESULT CDecoder::DecodeLZ(bool &keepDecompressing)
           }
           else
           {
-            UInt32 number = m_AlignDecoder.DecodeSymbol(&m_InBitStream.bitDecoder);
+            UInt32 number = m_AlignDecoder.DecodeSymbol(&m_InBitStream.BitDecoder);
             if (number < (1 << kNumAlignBits))
             {
               rep0 += number;
               PrevAlignBits = number;
             }
-            else if (number  == (1 << kNumAlignBits))
+            else if (number == (1 << kNumAlignBits))
             {
               PrevAlignCount = kNumAlignReps;
               rep0 += PrevAlignBits;
@@ -776,7 +778,7 @@ HRESULT CDecoder::DecodeLZ(bool &keepDecompressing)
           }
         }
         else
-          rep0 += m_InBitStream.bitDecoder.ReadBits(numBits);
+          rep0 += m_InBitStream.BitDecoder.ReadBits(numBits);
         length += ((kDistLimit4 - rep0) >> 31) + ((kDistLimit3 - rep0) >> 31);
       }
       else
@@ -831,13 +833,17 @@ HRESULT CDecoder::CodeReal(ICompressProgressInfo *progress)
     {
       RINOK(DecodePPM(1 << 18, keepDecompressing))
     }
-    UInt64 packSize = m_InBitStream.bitDecoder.GetProcessedSize();
+
+    if (InputEofError())
+      return S_FALSE;
+
+    UInt64 packSize = m_InBitStream.BitDecoder.GetProcessedSize();
     RINOK(progress->SetRatioInfo(&packSize, &_writtenFileSize));
     if (!keepDecompressing)
       break;
   }
   RINOK(WriteBuf());
-  UInt64 packSize = m_InBitStream.bitDecoder.GetProcessedSize();
+  UInt64 packSize = m_InBitStream.BitDecoder.GetProcessedSize();
   RINOK(progress->SetRatioInfo(&packSize, &_writtenFileSize));
   if (_writtenFileSize < _unpackSize)
     return S_FALSE;
@@ -866,17 +872,17 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
       if (_window == 0)
         return E_OUTOFMEMORY;
     }
-    if (!m_InBitStream.bitDecoder.Create(1 << 20))
+    if (!m_InBitStream.BitDecoder.Create(1 << 20))
       return E_OUTOFMEMORY;
     if (!_vm.Create())
       return E_OUTOFMEMORY;
 
     
-    m_InBitStream.bitDecoder.SetStream(inStream);
-    m_InBitStream.bitDecoder.Init();
+    m_InBitStream.BitDecoder.SetStream(inStream);
+    m_InBitStream.BitDecoder.Init();
     _outStream = outStream;
    
-    CCoderReleaser coderReleaser(this);
+    // CCoderReleaser coderReleaser(this);
     _unpackSize = *outSize;
     return CodeReal(progress);
   }

CPP/7zip/Compress/Rar3Decoder.h

@@ -40,43 +40,53 @@ const UInt32 kTablesSizesSum = kMainTableSize + kDistTableSize + kAlignTableSize
 
 class CBitDecoder
 {
-  UInt32 m_Value;
-  unsigned m_BitPos;
+  UInt32 _value;
+  unsigned _bitPos;
 public:
-  CInBuffer m_Stream;
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialInStream *inStream) { m_Stream.SetStream(inStream);}
-  void ReleaseStream() { m_Stream.ReleaseStream();}
+  CInBuffer Stream;
+
+  bool Create(UInt32 bufSize) { return Stream.Create(bufSize); }
+  void SetStream(ISequentialInStream *inStream) { Stream.SetStream(inStream);}
 
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = 0;
-    m_Value = 0;
+    Stream.Init();
+    _bitPos = 0;
+    _value = 0;
   }
   
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (m_BitPos) / 8; }
-  UInt32 GetBitPosition() const { return ((8 - m_BitPos) & 7); }
+  bool ExtraBitsWereRead() const
+  {
+    return (Stream.NumExtraBytes > 4 || _bitPos < (Stream.NumExtraBytes << 3));
+  }
+
+  UInt64 GetProcessedSize() const { return Stream.GetProcessedSize() - (_bitPos >> 3); }
+
+  void AlignToByte()
+  {
+    _bitPos &= ~(unsigned)7;
+    _value = _value & ((1 << _bitPos) - 1);
+  }
   
   UInt32 GetValue(unsigned numBits)
   {
-    if (m_BitPos < numBits)
+    if (_bitPos < numBits)
     {
-      m_BitPos += 8;
-      m_Value = (m_Value << 8) | m_Stream.ReadByte();
-      if (m_BitPos < numBits)
+      _bitPos += 8;
+      _value = (_value << 8) | Stream.ReadByte();
+      if (_bitPos < numBits)
       {
-        m_BitPos += 8;
-        m_Value = (m_Value << 8) | m_Stream.ReadByte();
+        _bitPos += 8;
+        _value = (_value << 8) | Stream.ReadByte();
       }
     }
-    return m_Value >> (m_BitPos - numBits);
+    return _value >> (_bitPos - numBits);
   }
   
   void MovePos(unsigned numBits)
   {
-    m_BitPos -= numBits;
-    m_Value = m_Value & ((1 << m_BitPos) - 1);
+    _bitPos -= numBits;
+    _value = _value & ((1 << _bitPos) - 1);
   }
   
   UInt32 ReadBits(unsigned numBits)
@@ -96,7 +106,7 @@ struct CRangeDecoder
   UInt32 Range;
   UInt32 Code;
   UInt32 Low;
-  CBitDecoder bitDecoder;
+  CBitDecoder BitDecoder;
   SRes Res;
 
 public:
@@ -106,7 +116,7 @@ public:
     Low = 0;
     Range = 0xFFFFFFFF;
     for (int i = 0; i < 4; i++)
-      Code = (Code << 8) | bitDecoder.ReadBits(8);
+      Code = (Code << 8) | BitDecoder.ReadBits(8);
   }
 
   void Normalize()
@@ -114,7 +124,7 @@ public:
     while ((Low ^ (Low + Range)) < kTopValue ||
        Range < kBot && ((Range = (0 - Low) & (kBot - 1)), 1))
     {
-      Code = (Code << 8) | bitDecoder.m_Stream.ReadByte();
+      Code = (Code << 8) | BitDecoder.Stream.ReadByte();
       Range <<= 8;
       Low <<= 8;
     }
@@ -129,6 +139,7 @@ struct CFilter: public NVm::CProgram
   UInt32 BlockStart;
   UInt32 BlockSize;
   UInt32 ExecCount;
+  
   CFilter(): BlockStart(0), BlockSize(0), ExecCount(0) {}
 };
 
@@ -136,10 +147,15 @@ struct CTempFilter: public NVm::CProgramInitState
 {
   UInt32 BlockStart;
   UInt32 BlockSize;
-  UInt32 ExecCount;
   bool NextWindow;
   
   UInt32 FilterIndex;
+
+  CTempFilter()
+  {
+    // all filters must contain at least FixedGlobal block
+    AllocateEmptyFixedGlobal();
+  }
 };
 
 const int kNumHuffmanBits = 15;
@@ -156,7 +172,7 @@ class CDecoder:
   UInt64 _lzSize;
   UInt64 _unpackSize;
   UInt64 _writtenFileSize; // if it's > _unpackSize, then _unpackSize only written
-  CMyComPtr<ISequentialOutStream> _outStream;
+  ISequentialOutStream *_outStream;
   NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> m_MainDecoder;
   NHuffman::CDecoder<kNumHuffmanBits, kDistTableSize> m_DistDecoder;
   NHuffman::CDecoder<kNumHuffmanBits, kAlignTableSize> m_AlignDecoder;
@@ -209,18 +225,16 @@ class CDecoder:
   HRESULT ReadEndOfBlock(bool &keepDecompressing);
   HRESULT DecodeLZ(bool &keepDecompressing);
   HRESULT CodeReal(ICompressProgressInfo *progress);
+  
+  bool InputEofError() const { return m_InBitStream.BitDecoder.ExtraBitsWereRead(); }
+  bool InputEofError_Fast() const { return (m_InBitStream.BitDecoder.Stream.NumExtraBytes > 2); }
+
 public:
   CDecoder();
   ~CDecoder();
 
   MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
 
-  void ReleaseStreams()
-  {
-    _outStream.Release();
-    m_InBitStream.bitDecoder.ReleaseStream();
-  }
-
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
 

CPP/7zip/Compress/Rar3Vm.cpp

@@ -15,18 +15,20 @@ Note:
 #include "../../../C/7zCrc.h"
 #include "../../../C/Alloc.h"
 
+#include "../../Common/Defs.h"
+
 #include "Rar3Vm.h"
 
 namespace NCompress {
 namespace NRar3 {
 
-UInt32 CMemBitDecoder::ReadBits(int numBits)
+UInt32 CMemBitDecoder::ReadBits(unsigned numBits)
 {
   UInt32 res = 0;
   for (;;)
   {
-    Byte b = _bitPos < _bitSize ? _data[_bitPos >> 3] : 0;
-    int avail = (int)(8 - (_bitPos & 7));
+    unsigned b = _bitPos < _bitSize ? (unsigned)_data[_bitPos >> 3] : 0;
+    unsigned avail = (unsigned)(8 - (_bitPos & 7));
     if (numBits <= avail)
     {
       _bitPos += numBits;
@@ -40,6 +42,15 @@ UInt32 CMemBitDecoder::ReadBits(int numBits)
 
 UInt32 CMemBitDecoder::ReadBit() { return ReadBits(1); }
 
+UInt32 CMemBitDecoder::ReadEncodedUInt32()
+{
+  unsigned v = (unsigned)ReadBits(2);
+  UInt32 res = ReadBits(4 << v);
+  if (v == 1 && res < 16)
+    res = 0xFFFFFF00 | (res << 4) | ReadBits(4);
+  return res;
+}
+
 namespace NVm {
 
 static const UInt32 kStackRegIndex = kNumRegs - 1;
@@ -58,7 +69,7 @@ static const Byte CF_PROC = 16;
 static const Byte CF_USEFLAGS = 32;
 static const Byte CF_CHFLAGS = 64;
 
-static Byte kCmdFlags[]=
+static const Byte kCmdFlags[]=
 {
   /* CMD_MOV   */ CF_OP2 | CF_BYTEMODE,
   /* CMD_CMP   */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
@@ -142,7 +153,11 @@ bool CVm::Execute(CProgram *prg, const CProgramInitState *initState,
   {
     res = ExecuteCode(prg);
     if (!res)
-      prg->Commands[0].OpCode = CMD_RET;
+    {
+      prg->Commands.Clear();
+      prg->Commands.Add(CCommand());
+      prg->Commands.Back().OpCode = CMD_RET;
+    }
   }
   UInt32 newBlockPos = GetFixedGlobalValue32(NGlobalOffset::kBlockPos) & kSpaceMask;
   UInt32 newBlockSize = GetFixedGlobalValue32(NGlobalOffset::kBlockSize) & kSpaceMask;
@@ -157,9 +172,8 @@ bool CVm::Execute(CProgram *prg, const CProgramInitState *initState,
   if (dataSize != 0)
   {
     dataSize += kFixedGlobalSize;
-    outGlobalData.Reserve(dataSize);
-    for (UInt32 i = 0; i < dataSize; i++)
-      outGlobalData.Add(Mem[kGlobalOffset + i]);
+    outGlobalData.ClearAndSetSize(dataSize);
+    memcpy(&outGlobalData[0], Mem + kGlobalOffset, dataSize);
   }
   return res;
 }
@@ -234,6 +248,9 @@ bool CVm::ExecuteCode(const CProgram *prg)
   const CCommand *commands = &prg->Commands[0];
   const CCommand *cmd = commands;
   UInt32 numCommands = prg->Commands.Size();
+  if (numCommands == 0)
+    return false;
+
   for (;;)
   {
     switch(cmd->OpCode)
@@ -256,8 +273,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
       case CMD_CMPB:
         {
           Byte v1 = GetOperand8(&cmd->Op1);
-          Byte res = v1 - GetOperand8(&cmd->Op2);
-          res &= 0xFF;
+          Byte res = (Byte)((v1 - GetOperand8(&cmd->Op2)) & 0xFF);
           Flags = res == 0 ? FLAG_Z : (res > v1) | GET_FLAG_S_B(res);
         }
         break;
@@ -272,8 +288,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
       case CMD_ADDB:
         {
           Byte v1 = GetOperand8(&cmd->Op1);
-          Byte res = v1 + GetOperand8(&cmd->Op2);
-          res &= 0xFF;
+          Byte res = (Byte)((v1 + GetOperand8(&cmd->Op2)) & 0xFF);
           SetOperand8(&cmd->Op1, (Byte)res);
           Flags = (res < v1) | (res == 0 ? FLAG_Z : GET_FLAG_S_B(res));
         }
@@ -326,7 +341,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
         break;
       case CMD_INCB:
         {
-          Byte res = GetOperand8(&cmd->Op1) + 1;
+          Byte res = (Byte)(GetOperand8(&cmd->Op1) + 1);
           SetOperand8(&cmd->Op1, res);;
           FLAGS_UPDATE_SZ_B;
         }
@@ -340,7 +355,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
         break;
       case CMD_DECB:
         {
-          Byte res = GetOperand8(&cmd->Op1) - 1;
+          Byte res = (Byte)(GetOperand8(&cmd->Op1) - 1);
           SetOperand8(&cmd->Op1, res);;
           FLAGS_UPDATE_SZ_B;
         }
@@ -354,7 +369,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
         break;
       case CMD_XORB:
         {
-          Byte res = GetOperand8(&cmd->Op1) ^ GetOperand8(&cmd->Op2);
+          Byte res = (Byte)(GetOperand8(&cmd->Op1) ^ GetOperand8(&cmd->Op2));
           SetOperand8(&cmd->Op1, res);
           FLAGS_UPDATE_SZ_B;
         }
@@ -368,7 +383,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
         break;
       case CMD_ANDB:
         {
-          Byte res = GetOperand8(&cmd->Op1) & GetOperand8(&cmd->Op2);
+          Byte res = (Byte)(GetOperand8(&cmd->Op1) & GetOperand8(&cmd->Op2));
           SetOperand8(&cmd->Op1, res);
           FLAGS_UPDATE_SZ_B;
         }
@@ -382,7 +397,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
         break;
       case CMD_ORB:
         {
-          Byte res = GetOperand8(&cmd->Op1) | GetOperand8(&cmd->Op2);
+          Byte res = (Byte)(GetOperand8(&cmd->Op1) | GetOperand8(&cmd->Op2));
           SetOperand8(&cmd->Op1, res);
           FLAGS_UPDATE_SZ_B;
         }
@@ -395,7 +410,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
         break;
       case CMD_TESTB:
         {
-          Byte res = GetOperand8(&cmd->Op1) & GetOperand8(&cmd->Op2);
+          Byte res = (Byte)(GetOperand8(&cmd->Op1) & GetOperand8(&cmd->Op2));
           FLAGS_UPDATE_SZ_B;
         }
         break;
@@ -589,7 +604,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
         break;
       case CMD_MULB:
         {
-          Byte res = GetOperand8(&cmd->Op1) * GetOperand8(&cmd->Op2);
+          Byte res = (Byte)(GetOperand8(&cmd->Op1) * GetOperand8(&cmd->Op2));
           SetOperand8(&cmd->Op1, res);
         }
         break;
@@ -627,28 +642,7 @@ bool CVm::ExecuteCode(const CProgram *prg)
 //////////////////////////////////////////////////////
 // Read program
 
-UInt32 ReadEncodedUInt32(CMemBitDecoder &inp)
-{
-  switch(inp.ReadBits(2))
-  {
-    case 0:
-      return inp.ReadBits(4);
-    case 1:
-    {
-      UInt32 v = inp.ReadBits(4);
-      if (v == 0)
-        return 0xFFFFFF00 | inp.ReadBits(8);
-      else
-        return (v << 4) | inp.ReadBits(4);
-    }
-    case 2:
-      return inp.ReadBits(16);
-    default:
-      return inp.ReadBits(32);
-  }
-}
-
-void CVm::DecodeArg(CMemBitDecoder &inp, COperand &op, bool byteMode)
+static void DecodeArg(CMemBitDecoder &inp, COperand &op, bool byteMode)
 {
   if (inp.ReadBit())
   {
@@ -661,7 +655,7 @@ void CVm::DecodeArg(CMemBitDecoder &inp, COperand &op, bool byteMode)
     if (byteMode)
       op.Data = inp.ReadBits(8);
     else
-      op.Data = ReadEncodedUInt32(inp);
+      op.Data = inp.ReadEncodedUInt32();
   }
   else
   {
@@ -677,27 +671,27 @@ void CVm::DecodeArg(CMemBitDecoder &inp, COperand &op, bool byteMode)
         op.Data = inp.ReadBits(kNumRegBits);
       else
         op.Data = kNumRegs;
-      op.Base = ReadEncodedUInt32(inp);
+      op.Base = inp.ReadEncodedUInt32();
     }
   }
 }
 
-void CVm::ReadVmProgram(const Byte *code, UInt32 codeSize, CProgram *prg)
+void CProgram::ReadProgram(const Byte *code, UInt32 codeSize)
 {
   CMemBitDecoder inp;
   inp.Init(code, codeSize);
 
-  prg->StaticData.Clear();
+  StaticData.Clear();
   if (inp.ReadBit())
   {
-    UInt32 dataSize = ReadEncodedUInt32(inp) + 1;
+    UInt32 dataSize = inp.ReadEncodedUInt32() + 1;
     for (UInt32 i = 0; inp.Avail() && i < dataSize; i++)
-      prg->StaticData.Add((Byte)inp.ReadBits(8));
+      StaticData.Add((Byte)inp.ReadBits(8));
   }
   while (inp.Avail())
   {
-    prg->Commands.Add(CCommand());
-    CCommand *cmd = &prg->Commands.Back();
+    Commands.Add(CCommand());
+    CCommand *cmd = &Commands.Back();
     if (inp.ReadBit() == 0)
       cmd->OpCode = (ECommand)inp.ReadBits(3);
     else
@@ -716,20 +710,20 @@ void CVm::ReadVmProgram(const Byte *code, UInt32 codeSize, CProgram *prg)
       {
         if (cmd->Op1.Type == OP_TYPE_INT && (kCmdFlags[cmd->OpCode] & (CF_JUMP | CF_PROC)))
         {
-          int Distance = cmd->Op1.Data;
-          if (Distance >= 256)
-            Distance -= 256;
+          int dist = cmd->Op1.Data;
+          if (dist >= 256)
+            dist -= 256;
           else
           {
-            if (Distance >= 136)
-              Distance -= 264;
-            else if (Distance >= 16)
-              Distance -= 8;
-            else if (Distance >= 8)
-              Distance -= 16;
-            Distance += prg->Commands.Size() - 1;
+            if (dist >= 136)
+              dist -= 264;
+            else if (dist >= 16)
+              dist -= 8;
+            else if (dist >= 8)
+              dist -= 16;
+            dist += Commands.Size() - 1;
           }
-          cmd->Op1.Data = Distance;
+          cmd->Op1.Data = dist;
         }
       }
     }
@@ -770,7 +764,7 @@ enum EStandardFilter
   SF_UPCASE
 };
 
-struct StandardFilterSignature
+static const struct CStandardFilterSignature
 {
   UInt32 Length;
   UInt32 CRC;
@@ -792,7 +786,7 @@ static int FindStandardFilter(const Byte *code, UInt32 codeSize)
   UInt32 crc = CrcCalc(code, codeSize);
   for (int i = 0; i < sizeof(kStdFilters) / sizeof(kStdFilters[0]); i++)
   {
-    StandardFilterSignature &sfs = kStdFilters[i];
+    const CStandardFilterSignature &sfs = kStdFilters[i];
     if (sfs.CRC == crc && sfs.Length == codeSize)
       return i;
   }
@@ -801,30 +795,28 @@ static int FindStandardFilter(const Byte *code, UInt32 codeSize)
 
 #endif
 
-void CVm::PrepareProgram(const Byte *code, UInt32 codeSize, CProgram *prg)
+void CProgram::PrepareProgram(const Byte *code, UInt32 codeSize)
 {
   Byte xorSum = 0;
   for (UInt32 i = 1; i < codeSize; i++)
     xorSum ^= code[i];
 
-  prg->Commands.Clear();
+  Commands.Clear();
   #ifdef RARVM_STANDARD_FILTERS
-  prg->StandardFilterIndex = -1;
+  StandardFilterIndex = -1;
   #endif
 
   if (xorSum == code[0] && codeSize > 0)
   {
     #ifdef RARVM_STANDARD_FILTERS
-    prg->StandardFilterIndex = FindStandardFilter(code, codeSize);
-    if (prg->StandardFilterIndex >= 0)
+    StandardFilterIndex = FindStandardFilter(code, codeSize);
+    if (StandardFilterIndex >= 0)
       return;
     #endif
-    // 1 byte for checksum
-    ReadVmProgram(code + 1, codeSize - 1, prg);
+    ReadProgram(code + 1, codeSize - 1);
   }
-  prg->Commands.Add(CCommand());
-  CCommand *cmd = &prg->Commands.Back();
-  cmd->OpCode = CMD_RET;
+  Commands.Add(CCommand());
+  Commands.Back().OpCode = CMD_RET;
 }
 
 void CVm::SetMemory(UInt32 pos, const Byte *data, UInt32 dataSize)
@@ -841,7 +833,7 @@ static void E8E9Decode(Byte *data, UInt32 dataSize, UInt32 fileOffset, bool e9)
     return;
   dataSize -= 4;
   const UInt32 kFileSize = 0x1000000;
-  Byte cmpByte2 = (e9 ? 0xE9 : 0xE8);
+  Byte cmpByte2 = (Byte)(e9 ? 0xE9 : 0xE8);
   for (UInt32 curPos = 0; curPos < dataSize;)
   {
     Byte curByte = *(data++);
@@ -886,7 +878,7 @@ static void ItaniumDecode(Byte *data, UInt32 dataSize, UInt32 fileOffset)
             {
               const UInt32 kMask = 0xFFFFF;
               Byte *p = data + ((unsigned int)startPos >> 3);
-              UInt32 bitField =  ((UInt32)p[0]) | ((UInt32)p[1] <<  8) | ((UInt32)p[2] << 16);
+              UInt32 bitField = ((UInt32)p[0]) | ((UInt32)p[1] <<  8) | ((UInt32)p[2] << 16);
               int inBit = (startPos & 7);
               UInt32 offset = (bitField >> inBit) & kMask;
               UInt32 andMask = ~(kMask << inBit);
@@ -915,7 +907,7 @@ static void DeltaDecode(Byte *data, UInt32 dataSize, UInt32 numChannels)
   {
     Byte prevByte = 0;
     for (UInt32 destPos = dataSize + curChannel; destPos < border; destPos += numChannels)
-      data[destPos] = (prevByte = prevByte - data[srcPos++]);
+      data[destPos] = (prevByte = (Byte)(prevByte - data[srcPos++]));
   }
 }
 
@@ -956,8 +948,8 @@ static void RgbDecode(Byte *srcData, UInt32 dataSize, UInt32 width, UInt32 posR)
   for (UInt32 i = posR, border = dataSize - 2; i < border; i += 3)
   {
     Byte g = destData[i + 1];
-    destData[i] = destData[i] + g;
-    destData[i + 2] = destData[i + 2] + g;
+    destData[i    ] = (Byte)(destData[i    ] + g);
+    destData[i + 2] = (Byte)(destData[i + 2] + g);
   }
 }
 

CPP/7zip/Compress/Rar3Vm.h

@@ -7,8 +7,8 @@
 
 #include "../../../C/CpuArch.h"
 
-#include "Common/MyVector.h"
-#include "Common/Types.h"
+#include "../../Common/MyTypes.h"
+#include "../../Common/MyVector.h"
 
 #define RARVM_STANDARD_FILTERS
 
@@ -27,9 +27,11 @@ public:
     _bitSize = (byteSize << 3);
     _bitPos = 0;
   }
-  UInt32 ReadBits(int numBits);
+  UInt32 ReadBits(unsigned numBits);
   UInt32 ReadBit();
   bool Avail() const { return (_bitPos < _bitSize); }
+
+  UInt32 ReadEncodedUInt32();
 };
 
 namespace NVm {
@@ -37,8 +39,6 @@ namespace NVm {
 inline UInt32 GetValue32(const void *addr) { return GetUi32(addr); }
 inline void SetValue32(void *addr, UInt32 value) { SetUi32(addr, value); }
 
-UInt32 ReadEncodedUInt32(CMemBitDecoder &inp);
-
 const int kNumRegBits = 3;
 const UInt32 kNumRegs = 1 << kNumRegBits;
 const UInt32 kNumGpRegs = kNumRegs - 1;
@@ -95,13 +95,19 @@ struct CBlockRef
   UInt32 Size;
 };
 
-struct CProgram
+class CProgram
 {
+public:
   CRecordVector<CCommand> Commands;
   #ifdef RARVM_STANDARD_FILTERS
   int StandardFilterIndex;
   #endif
   CRecordVector<Byte> StaticData;
+
+private:
+  void ReadProgram(const Byte *code, UInt32 codeSize);
+public:
+  void PrepareProgram(const Byte *code, UInt32 codeSize);
 };
 
 struct CProgramInitState
@@ -111,10 +117,8 @@ struct CProgramInitState
 
   void AllocateEmptyFixedGlobal()
   {
-    GlobalData.Clear();
-    GlobalData.Reserve(NVm::kFixedGlobalSize);
-    for (UInt32 i = 0; i < NVm::kFixedGlobalSize; i++)
-      GlobalData.Add(0);
+    GlobalData.ClearAndSetSize(NVm::kFixedGlobalSize);
+    memset(&GlobalData[0], 0, NVm::kFixedGlobalSize);
   }
 };
 
@@ -150,8 +154,6 @@ private:
   UInt32 GetOperand(bool byteMode, const COperand *op) const;
   void SetOperand(bool byteMode, const COperand *op, UInt32 val);
 
-  void DecodeArg(CMemBitDecoder &inp, COperand &op, bool byteMode);
-  
   bool ExecuteCode(const CProgram *prg);
   
   #ifdef RARVM_STANDARD_FILTERS
@@ -161,12 +163,10 @@ private:
   Byte *Mem;
   UInt32 R[kNumRegs + 1]; // R[kNumRegs] = 0 always (speed optimization)
   UInt32 Flags;
-  void ReadVmProgram(const Byte *code, UInt32 codeSize, CProgram *prg);
 public:
   CVm();
   ~CVm();
   bool Create();
-  void PrepareProgram(const Byte *code, UInt32 codeSize, CProgram *prg);
   void SetMemory(UInt32 pos, const Byte *data, UInt32 dataSize);
   bool Execute(CProgram *prg, const CProgramInitState *initState,
       CBlockRef &outBlockRef, CRecordVector<Byte> &outGlobalData);

CPP/7zip/Compress/StdAfx.h

@@ -3,6 +3,6 @@
 #ifndef __STDAFX_H
 #define __STDAFX_H
 
-#include "../../Common/MyWindows.h"
+#include "../../Common/Common.h"
 
 #endif

CPP/7zip/Compress/ZDecoder.cpp

@@ -2,6 +2,8 @@
 
 #include "StdAfx.h"
 
+// #include <stdio.h>
+
 #include "../../../C/Alloc.h"
 
 #include "../Common/InBuffer.h"
@@ -15,8 +17,8 @@ namespace NZ {
 static const UInt32 kBufferSize = (1 << 20);
 static const Byte kNumBitsMask = 0x1F;
 static const Byte kBlockModeMask = 0x80;
-static const int kNumMinBits = 9;
-static const int kNumMaxBits = 16;
+static const unsigned kNumMinBits = 9;
+static const unsigned kNumMaxBits = 16;
 
 void CDecoder::Free()
 {
@@ -33,6 +35,8 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   CInBuffer inBuffer;
   COutBuffer outBuffer;
 
+  PackSize = 0;
+  
   if (!inBuffer.Create(kBufferSize))
     return E_OUTOFMEMORY;
   inBuffer.SetStream(inStream);
@@ -43,11 +47,22 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   outBuffer.SetStream(outStream);
   outBuffer.Init();
 
-  int maxbits = _properties & kNumBitsMask;
+  Byte buf[kNumMaxBits + 4];
+  {
+    if (inBuffer.ReadBytes(buf, 3) < 3)
+      return S_FALSE;
+    if (buf[0] != 0x1F || buf[1] != 0x9D)
+      return S_FALSE;;
+  }
+  Byte prop = buf[2];
+
+  if ((prop & 0x60) != 0)
+    return S_FALSE;
+  unsigned maxbits = prop & kNumBitsMask;
   if (maxbits < kNumMinBits || maxbits > kNumMaxBits)
     return S_FALSE;
   UInt32 numItems = 1 << maxbits;
-  bool blockMode = ((_properties & kBlockModeMask) != 0);
+  // Speed optimization: blockSymbol can contain unused velue.
 
   if (maxbits != _numMaxBits || _parents == 0 || _suffixes == 0 || _stack == 0)
   {
@@ -59,18 +74,16 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   }
 
   UInt64 prevPos = 0;
-  int numBits = kNumMinBits;
-  UInt32 head = blockMode ? 257 : 256;
-
+  UInt32 blockSymbol = ((prop & kBlockModeMask) != 0) ? 256 : ((UInt32)1 << kNumMaxBits);
+  unsigned numBits = kNumMinBits;
+  UInt32 head = (blockSymbol == 256) ? 257 : 256;
   bool needPrev = false;
-
   unsigned bitPos = 0;
   unsigned numBufBits = 0;
 
-  Byte buf[kNumMaxBits + 4];
-
   _parents[256] = 0; // virus protection
   _suffixes[256] = 0;
+  HRESULT res = S_OK;
 
   for (;;)
   {
@@ -79,7 +92,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
       numBufBits = (unsigned)inBuffer.ReadBytes(buf, numBits) * 8;
       bitPos = 0;
       UInt64 nowPos = outBuffer.GetProcessedSize();
-      if (progress != NULL && nowPos - prevPos >= (1 << 18))
+      if (progress && nowPos - prevPos >= (1 << 13))
       {
         prevPos = nowPos;
         UInt64 packSize = inBuffer.GetProcessedSize();
@@ -94,8 +107,11 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     if (bitPos > numBufBits)
       break;
     if (symbol >= head)
-      return S_FALSE;
-    if (blockMode && symbol == 256)
+    {
+      res = S_FALSE;
+      break;
+    }
+    if (symbol == blockSymbol)
     {
       numBufBits = bitPos = 0;
       numBits = kNumMinBits;
@@ -104,7 +120,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
       continue;
     }
     UInt32 cur = symbol;
-    int i = 0;
+    unsigned i = 0;
     while (cur >= 256)
     {
       _stack[i++] = _suffixes[cur];
@@ -136,7 +152,9 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     else
       needPrev = false;
   }
-  return outBuffer.Flush();
+  PackSize = inBuffer.GetProcessedSize();
+  HRESULT res2 = outBuffer.Flush();
+  return (res == S_OK) ? res2 : res;
 }
 
 STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
@@ -148,12 +166,72 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   catch(...) { return S_FALSE; }
 }
 
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
+bool CheckStream(const Byte *data, size_t size)
 {
-  if (size < 1)
-    return E_INVALIDARG;
-  _properties = data[0];
-  return S_OK;
+  if (size < 3)
+    return false;
+  if (data[0] != 0x1F || data[1] != 0x9D)
+    return false;
+  Byte prop = data[2];
+  if ((prop & 0x60) != 0)
+    return false;
+  unsigned maxbits = prop & kNumBitsMask;
+  if (maxbits < kNumMinBits || maxbits > kNumMaxBits)
+    return false;
+  UInt32 numItems = 1 << maxbits;
+  UInt32 blockSymbol = ((prop & kBlockModeMask) != 0) ? 256 : ((UInt32)1 << kNumMaxBits);
+  unsigned numBits = kNumMinBits;
+  UInt32 head = (blockSymbol == 256) ? 257 : 256;
+  unsigned bitPos = 0;
+  unsigned numBufBits = 0;
+  Byte buf[kNumMaxBits + 4];
+  data += 3;
+  size -= 3;
+  // printf("\n\n");
+  for (;;)
+  {
+    if (numBufBits == bitPos)
+    {
+      unsigned num = (numBits < size) ? numBits : (unsigned)size;
+      memcpy(buf, data, num);
+      data += num;
+      size -= num;
+      numBufBits = num * 8;
+      bitPos = 0;
+    }
+    unsigned bytePos = bitPos >> 3;
+    UInt32 symbol = buf[bytePos] | ((UInt32)buf[bytePos + 1] << 8) | ((UInt32)buf[bytePos + 2] << 16);
+    symbol >>= (bitPos & 7);
+    symbol &= (1 << numBits) - 1;
+    bitPos += numBits;
+    if (bitPos > numBufBits)
+    {
+      // printf("  OK", symbol);
+      return true;
+    }
+    // printf("%3X ", symbol);
+    if (symbol >= head)
+      return false;
+    if (symbol == blockSymbol)
+    {
+      numBufBits = bitPos = 0;
+      numBits = kNumMinBits;
+      head = 257;
+      continue;
+    }
+    if (head < numItems)
+    {
+      head++;
+      if (head > ((UInt32)1 << numBits))
+      {
+        if (numBits < maxbits)
+        {
+          numBufBits = bitPos = 0;
+          numBits++;
+        }
+      }
+    }
+  }
 }
 
 }}

CPP/7zip/Compress/ZDecoder.h

@@ -10,33 +10,45 @@
 namespace NCompress {
 namespace NZ {
 
+// Z decoder decodes Z data stream, including 3 bytes of header.
+  
 class CDecoder:
   public ICompressCoder,
-  public ICompressSetDecoderProperties2,
   public CMyUnknownImp
 {
   UInt16 *_parents;
   Byte *_suffixes;
   Byte *_stack;
-  Byte _properties;
-  int _numMaxBits;
+  unsigned _numMaxBits;
 
 public:
-  CDecoder(): _parents(0), _suffixes(0), _stack(0), _properties(0), _numMaxBits(0) {};
+  CDecoder(): _parents(0), _suffixes(0), _stack(0), /* _prop(0), */ _numMaxBits(0) {};
   ~CDecoder();
   void Free();
+  UInt64 PackSize;
 
-  MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
+  MY_UNKNOWN_IMP1(ICompressCoder)
 
   HRESULT 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);
 };
 
+/*
+  There is no end_of_payload_marker in Z stream.
+  Z decoder stops decoding, if it reaches end of input stream.
+   
+  CheckStream function:
+    (size) must be at least 3 bytes (size of Z header).
+    if (size) is larger than size of real Z stream in (data), CheckStream can return false.
+*/
+
+const unsigned kRecommendedCheckSize = 64;
+
+bool CheckStream(const Byte *data, size_t size);
+
 }}
 
 #endif

CPP/7zip/Compress/ZlibDecoder.cpp

@@ -38,9 +38,12 @@ UInt32 Adler32_Update(UInt32 adler, const Byte *buf, size_t size)
 
 STDMETHODIMP COutStreamWithAdler::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
-  HRESULT result = _stream->Write(data, size, &size);
+  HRESULT result = S_OK;
+  if (_stream)
+    result = _stream->Write(data, size, &size);
   _adler = Adler32_Update(_adler, (const Byte *)data, size);
-  if (processedSize != NULL)
+  _size += size;
+  if (processedSize)
     *processedSize = size;
   return result;
 }
@@ -58,21 +61,21 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
     DeflateDecoder = DeflateDecoderSpec;
   }
 
+  if (inSize && *inSize < 2)
+    return S_FALSE;
   Byte buf[2];
   RINOK(ReadStream_FALSE(inStream, buf, 2));
-  int method = buf[0] & 0xF;
-  if (method != 8)
+  if (!IsZlib(buf))
     return S_FALSE;
-  // int dicSize = buf[0] >> 4;
-  if ((((UInt32)buf[0] << 8) + buf[1]) % 31 != 0)
-    return S_FALSE;
-  if ((buf[1] & 0x20) != 0) // dictPresent
-    return S_FALSE;
-  // int level = (buf[1] >> 6);
 
   AdlerSpec->SetStream(outStream);
   AdlerSpec->Init();
-  HRESULT res = DeflateDecoder->Code(inStream, AdlerStream, inSize, outSize, progress);
+  
+  UInt64 inSize2 = 0;
+  if (inSize)
+    inSize2 = *inSize - 2;
+
+  HRESULT res = DeflateDecoder->Code(inStream, AdlerStream, inSize ? &inSize2 : NULL, outSize, progress);
   AdlerSpec->ReleaseStream();
 
   if (res == S_OK)

CPP/7zip/Compress/ZlibDecoder.h

@@ -16,13 +16,15 @@ class COutStreamWithAdler:
 {
   CMyComPtr<ISequentialOutStream> _stream;
   UInt32 _adler;
+  UInt64 _size;
 public:
   MY_UNKNOWN_IMP
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   void SetStream(ISequentialOutStream *stream) { _stream = stream; }
   void ReleaseStream() { _stream.Release(); }
-  void Init() { _adler = ADLER_INIT_VAL; }
+  void Init() { _adler = ADLER_INIT_VAL; _size = 0; }
   UInt32 GetAdler() const { return _adler; }
+  UInt64 GetSize() const { return _size; }
 };
 
 class CDecoder:
@@ -39,10 +41,39 @@ public:
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
 
   UInt64 GetInputProcessedSize() const { return DeflateDecoderSpec->GetInputProcessedSize() + 2; }
+  UInt64 GetOutputProcessedSize() const { return AdlerSpec->GetSize(); }
 
   MY_UNKNOWN_IMP
 };
 
+static bool inline IsZlib(const Byte *p)
+{
+  if ((p[0] & 0xF) != 8) // method
+    return false;
+  if (((unsigned)p[0] >> 4) > 7) // logar_window_size minus 8.
+    return false;
+  if ((p[1] & 0x20) != 0) // dictPresent
+    return false;
+  if ((((UInt32)p[0] << 8) + p[1]) % 31 != 0)
+    return false;
+  return true;
+}
+
+// IsZlib_3bytes checks 2 bytes of zlib header and starting byte of Deflate stream
+
+static bool inline IsZlib_3bytes(const Byte *p)
+{
+  if (!IsZlib(p))
+    return false;
+  unsigned val = p[2];
+  unsigned blockType = (val >> 1) & 0x3;
+  if (blockType == 3) // unsupported block type for deflate
+    return false;
+  if (blockType == NCompress::NDeflate::NBlockType::kStored && (val >> 3) != 0)
+    return false;
+  return true;
+}
+
 }}
 
 #endif