seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -3,84 +3,255 @@
 #ifndef __COMPRESS_HUFFMAN_DECODER_H
 #define __COMPRESS_HUFFMAN_DECODER_H
 
-#include "../../Common/Types.h"
+#include "../../Common/MyTypes.h"
 
 namespace NCompress {
 namespace NHuffman {
 
-const int kNumTableBits = 9;
-
-template <int kNumBitsMax, UInt32 m_NumSymbols>
+template <unsigned kNumBitsMax, UInt32 m_NumSymbols, unsigned kNumTableBits = 9>
 class CDecoder
 {
-  UInt32 m_Limits[kNumBitsMax + 1];     // m_Limits[i] = value limit for symbols with length = i
-  UInt32 m_Positions[kNumBitsMax + 1];  // m_Positions[i] = index in m_Symbols[] of first symbol with length = i
-  UInt32 m_Symbols[m_NumSymbols];
-  Byte m_Lengths[1 << kNumTableBits];   // Table oh length for short codes.
-
+  UInt32 _limits[kNumBitsMax + 2];
+  UInt32 _poses[kNumBitsMax + 1];
+  UInt16 _lens[1 << kNumTableBits];
+  UInt16 _symbols[m_NumSymbols];
 public:
-  
-  bool SetCodeLengths(const Byte *codeLengths)
+
+  bool Build(const Byte *lens) throw()
   {
-    int lenCounts[kNumBitsMax + 1];
-    UInt32 tmpPositions[kNumBitsMax + 1];
-    int i;
-    for(i = 1; i <= kNumBitsMax; i++)
+    UInt32 lenCounts[kNumBitsMax + 1];
+    UInt32 tmpPoses[kNumBitsMax + 1];
+    
+    unsigned i;
+    for (i = 0; i <= kNumBitsMax; i++)
       lenCounts[i] = 0;
-    UInt32 symbol;
-    for (symbol = 0; symbol < m_NumSymbols; symbol++)
+    
+    UInt32 sym;
+    
+    for (sym = 0; sym < m_NumSymbols; sym++)
+      lenCounts[lens[sym]]++;
+    
+    lenCounts[0] = 0;
+    _poses[0] = 0;
+    _limits[0] = 0;
+    UInt32 startPos = 0;
+    const UInt32 kMaxValue = (UInt32)1 << kNumBitsMax;
+    
+    for (i = 1; i <= kNumBitsMax; i++)
     {
-      int len = codeLengths[symbol];
-      if (len > kNumBitsMax)
+      startPos += lenCounts[i] << (kNumBitsMax - i);
+      if (startPos > kMaxValue)
         return false;
-      lenCounts[len]++;
-      m_Symbols[symbol] = 0xFFFFFFFF;
+      _limits[i] = startPos;
+      _poses[i] = _poses[i - 1] + lenCounts[i - 1];
+      tmpPoses[i] = _poses[i];
+    }
+
+    _limits[kNumBitsMax + 1] = kMaxValue;
+    
+    for (sym = 0; sym < m_NumSymbols; sym++)
+    {
+      unsigned len = lens[sym];
+      if (len == 0)
+        continue;
+
+      unsigned offset = tmpPoses[len];
+      _symbols[offset] = (UInt16)sym;
+      tmpPoses[len] = offset + 1;
+
+      if (len <= kNumTableBits)
+      {
+        offset -= _poses[len];
+        UInt32 num = (UInt32)1 << (kNumTableBits - len);
+        UInt16 val = (UInt16)((sym << 4) | len);
+        UInt16 *dest = _lens + (_limits[len - 1] >> (kNumBitsMax - kNumTableBits)) + (offset << (kNumTableBits - len));
+        for (UInt32 k = 0; k < num; k++)
+          dest[k] = val;
+      }
     }
+    
+    return true;
+  }
+
+  bool BuildFull(const Byte *lens, UInt32 numSymbols = m_NumSymbols) throw()
+  {
+    UInt32 lenCounts[kNumBitsMax + 1];
+    UInt32 tmpPoses[kNumBitsMax + 1];
+    
+    unsigned i;
+    for (i = 0; i <= kNumBitsMax; i++)
+      lenCounts[i] = 0;
+    
+    UInt32 sym;
+    
+    for (sym = 0; sym < numSymbols; sym++)
+      lenCounts[lens[sym]]++;
+    
     lenCounts[0] = 0;
-    m_Positions[0] = m_Limits[0] = 0;
+    _poses[0] = 0;
+    _limits[0] = 0;
     UInt32 startPos = 0;
-    UInt32 index = 0;
-    const UInt32 kMaxValue = (1 << kNumBitsMax);
+    const UInt32 kMaxValue = (UInt32)1 << kNumBitsMax;
+    
     for (i = 1; i <= kNumBitsMax; i++)
     {
       startPos += lenCounts[i] << (kNumBitsMax - i);
       if (startPos > kMaxValue)
         return false;
-      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)
+      _limits[i] = startPos;
+      _poses[i] = _poses[i - 1] + lenCounts[i - 1];
+      tmpPoses[i] = _poses[i];
+    }
+
+    _limits[kNumBitsMax + 1] = kMaxValue;
+    
+    for (sym = 0; sym < numSymbols; sym++)
+    {
+      unsigned len = lens[sym];
+      if (len == 0)
+        continue;
+
+      unsigned offset = tmpPoses[len];
+      _symbols[offset] = (UInt16)sym;
+      tmpPoses[len] = offset + 1;
+
+      if (len <= kNumTableBits)
       {
-        UInt32 limit = (m_Limits[i] >> (kNumBitsMax - kNumTableBits));
-        for (; index < limit; index++)
-          m_Lengths[index] = (Byte)i;
+        offset -= _poses[len];
+        UInt32 num = (UInt32)1 << (kNumTableBits - len);
+        UInt16 val = (UInt16)((sym << 4) | len);
+        UInt16 *dest = _lens + (_limits[len - 1] >> (kNumBitsMax - kNumTableBits)) + (offset << (kNumTableBits - len));
+        for (UInt32 k = 0; k < num; k++)
+          dest[k] = val;
       }
     }
-    for (symbol = 0; symbol < m_NumSymbols; symbol++)
+    
+    return startPos == kMaxValue;
+  }
+
+  template <class TBitDecoder>
+  UInt32 Decode(TBitDecoder *bitStream) const throw()
+  {
+    UInt32 val = bitStream->GetValue(kNumBitsMax);
+    
+    if (val < _limits[kNumTableBits])
     {
-      int len = codeLengths[symbol];
-      if (len != 0)
-        m_Symbols[tmpPositions[len]++] = symbol;
+      UInt32 pair = _lens[val >> (kNumBitsMax - kNumTableBits)];
+      bitStream->MovePos((unsigned)(pair & 0xF));
+      return pair >> 4;
     }
-    return true;
+
+    unsigned numBits;
+    for (numBits = kNumTableBits + 1; val >= _limits[numBits]; numBits++);
+    
+    if (numBits > kNumBitsMax)
+      return 0xFFFFFFFF;
+
+    bitStream->MovePos(numBits);
+    UInt32 index = _poses[numBits] + ((val - _limits[numBits - 1]) >> (kNumBitsMax - numBits));
+    return _symbols[index];
   }
 
   template <class TBitDecoder>
-  UInt32 DecodeSymbol(TBitDecoder *bitStream)
+  UInt32 DecodeFull(TBitDecoder *bitStream) const throw()
   {
-    int numBits;
-    UInt32 value = bitStream->GetValue(kNumBitsMax);
-    if (value < m_Limits[kNumTableBits])
-      numBits = m_Lengths[value >> (kNumBitsMax - kNumTableBits)];
-    else
-      for (numBits = kNumTableBits + 1; value >= m_Limits[numBits]; numBits++);
+    UInt32 val = bitStream->GetValue(kNumBitsMax);
+    
+    if (val < _limits[kNumTableBits])
+    {
+      UInt32 pair = _lens[val >> (kNumBitsMax - kNumTableBits)];
+      bitStream->MovePos((unsigned)(pair & 0xF));
+      return pair >> 4;
+    }
+
+    unsigned numBits;
+    for (numBits = kNumTableBits + 1; val >= _limits[numBits]; numBits++);
+    
     bitStream->MovePos(numBits);
-    UInt32 index = m_Positions[numBits] +
-      ((value - m_Limits[numBits - 1]) >> (kNumBitsMax - numBits));
-    if (index >= m_NumSymbols)
-      // throw CDecoderException(); // test it
-      return 0xFFFFFFFF;
-    return m_Symbols[index];
+    UInt32 index = _poses[numBits] + ((val - _limits[numBits - 1]) >> (kNumBitsMax - numBits));
+    return _symbols[index];
+  }
+};
+
+
+
+template <UInt32 m_NumSymbols>
+class CDecoder7b
+{
+  Byte _lens[1 << 7];
+public:
+
+  bool Build(const Byte *lens) throw()
+  {
+    const unsigned kNumBitsMax = 7;
+    
+    UInt32 lenCounts[kNumBitsMax + 1];
+    UInt32 tmpPoses[kNumBitsMax + 1];
+    UInt32 _poses[kNumBitsMax + 1];
+    UInt32 _limits[kNumBitsMax + 1];
+      
+    unsigned i;
+    for (i = 0; i <= kNumBitsMax; i++)
+      lenCounts[i] = 0;
+    
+    UInt32 sym;
+    
+    for (sym = 0; sym < m_NumSymbols; sym++)
+      lenCounts[lens[sym]]++;
+    
+    lenCounts[0] = 0;
+    _poses[0] = 0;
+    _limits[0] = 0;
+    UInt32 startPos = 0;
+    const UInt32 kMaxValue = (UInt32)1 << kNumBitsMax;
+    
+    for (i = 1; i <= kNumBitsMax; i++)
+    {
+      startPos += lenCounts[i] << (kNumBitsMax - i);
+      if (startPos > kMaxValue)
+        return false;
+      _limits[i] = startPos;
+      _poses[i] = _poses[i - 1] + lenCounts[i - 1];
+      tmpPoses[i] = _poses[i];
+    }
+
+    for (sym = 0; sym < m_NumSymbols; sym++)
+    {
+      unsigned len = lens[sym];
+      if (len == 0)
+        continue;
+
+      unsigned offset = tmpPoses[len];
+      tmpPoses[len] = offset + 1;
+
+      {
+        offset -= _poses[len];
+        UInt32 num = (UInt32)1 << (kNumBitsMax - len);
+        Byte val = (Byte)((sym << 3) | len);
+        Byte *dest = _lens + (_limits[len - 1]) + (offset << (kNumBitsMax - len));
+        for (UInt32 k = 0; k < num; k++)
+          dest[k] = val;
+      }
+    }
+
+    {
+      UInt32 limit = _limits[kNumBitsMax];
+      UInt32 num = ((UInt32)1 << kNumBitsMax) - limit;
+      Byte *dest = _lens + limit;
+      for (UInt32 k = 0; k < num; k++)
+        dest[k] = (Byte)(0x1F << 3);
+    }
+    
+    return true;
+  }
+
+  template <class TBitDecoder>
+  UInt32 Decode(TBitDecoder *bitStream) const throw()
+  {
+    UInt32 val = bitStream->GetValue(7);
+    UInt32 pair = _lens[val];
+    bitStream->MovePos((unsigned)(pair & 0x7));
+    return pair >> 3;
   }
 };
 

data/ext/p7zip/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++;

data/ext/p7zip/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);
 

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

@@ -21,10 +21,10 @@ CDecoder::~CDecoder()
 
 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++)
+  // unsigned lenCounts[kNumBitsInLongestCode + 1], tmpPositions[kNumBitsInLongestCode + 1];
+  unsigned lenCounts[kNumBitsInLongestCode + 2], tmpPositions[kNumBitsInLongestCode + 1];
+  unsigned 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;
@@ -67,8 +67,8 @@ UInt32 CDecoder::DecodeSymbol(CInBit *inStream)
 {
   UInt32 numBits = 0;
   UInt32 value = inStream->GetValue(kNumBitsInLongestCode);
-  int i;
-  for(i = kNumBitsInLongestCode; i > 0; i--)
+  unsigned i;
+  for (i = kNumBitsInLongestCode; i > 0; i--)
   {
     if (value < m_Limitits[i])
     {

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

@@ -11,7 +11,7 @@ namespace NCompress {
 namespace NImplode {
 namespace NHuffman {
 
-const int kNumBitsInLongestCode = 16;
+const unsigned kNumBitsInLongestCode = 16;
 
 typedef NBitl::CDecoder<CInBuffer> CInBit;
 

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

@@ -4,7 +4,7 @@
 
 #include "LzOutWindow.h"
 
-void CLzOutWindow::Init(bool solid)
+void CLzOutWindow::Init(bool solid) throw()
 {
   if (!solid)
     COutBuffer::Init();

data/ext/p7zip/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,44 +20,49 @@ 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)
+      UInt32 pos2;
+      if (pos == _bufSize)
         pos = 0;
-      _buffer[_pos++] = _buffer[pos++];
-      if (_pos == _limitPos)
+      pos2 = _pos;
+      _buf[pos2++] = _buf[pos++];
+      _pos = pos2;
+      if (pos2 == _limitPos)
         FlushWithCheck();
     }
-    while(--len != 0);
+    while (--len != 0);
     return true;
   }
   
   void PutByte(Byte b)
   {
-    _buffer[_pos++] = b;
-    if (_pos == _limitPos)
+    UInt32 pos = _pos;
+    _buf[pos++] = b;
+    _pos = pos;
+    if (pos == _limitPos)
       FlushWithCheck();
   }
   
   Byte GetByte(UInt32 distance) const
   {
     UInt32 pos = _pos - distance - 1;
-    if (pos >= _bufferSize)
-      pos += _bufferSize;
-    return _buffer[pos];
+    if (distance >= _pos)
+      pos += _bufSize;
+    return _buf[pos];
   }
 };