seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -3,155 +3,242 @@
 #ifndef __LZX_DECODER_H
 #define __LZX_DECODER_H
 
-#include "../ICoder.h"
+#include "../../../C/CpuArch.h"
 
-#include "../Common/InBuffer.h"
+#include "../../Common/MyCom.h"
 
 #include "HuffmanDecoder.h"
-#include "LzOutWindow.h"
 #include "Lzx.h"
-#include "Lzx86Converter.h"
 
 namespace NCompress {
 namespace NLzx {
 
-namespace NBitStream {
-
-const unsigned kNumBigValueBits = 8 * 4;
-const unsigned kNumValueBits = 17;
-const UInt32 kBitDecoderValueMask = (1 << kNumValueBits) - 1;
-
-class CDecoder
+class CBitDecoder
 {
-  CInBuffer m_Stream;
-  UInt32 m_Value;
-  unsigned m_BitPos;
+  unsigned _bitPos;
+  UInt32 _value;
+  const Byte *_buf;
+  const Byte *_bufLim;
+  UInt32 _extraSize;
 public:
-  CDecoder() {}
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-
-  void SetStream(ISequentialInStream *s) { m_Stream.SetStream(s); }
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
 
-  void Init()
+  void Init(const Byte *data, size_t size)
   {
-    m_Stream.Init();
-    m_BitPos = kNumBigValueBits;
+    _buf = data;
+    _bufLim = data + size - 1;
+    _bitPos = 0;
+    _extraSize = 0;
   }
 
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (kNumBigValueBits - m_BitPos) / 8; }
+  size_t GetRem() const { return _bufLim + 1 - _buf; }
+  bool WasExtraReadError_Fast() const { return _extraSize > 4; }
+
+  bool WasFinishedOK() const
+  {
+    if (_buf != _bufLim + 1)
+      return false;
+    if ((_bitPos >> 4) * 2 != _extraSize)
+      return false;
+    unsigned numBits = _bitPos & 15;
+    return (((_value >> (_bitPos - numBits)) & (((UInt32)1 << numBits) - 1)) == 0);
+  }
   
-  unsigned GetBitPosition() const { return m_BitPos & 0xF; }
+  void NormalizeSmall()
+  {
+    if (_bitPos <= 16)
+    {
+      UInt32 val;
+      if (_buf >= _bufLim)
+      {
+        val = 0xFFFF;
+        _extraSize += 2;
+      }
+      else
+      {
+        val = GetUi16(_buf);
+        _buf += 2;
+      }
+      _value = (_value << 16) | val;
+      _bitPos += 16;
+    }
+  }
 
-  void Normalize()
+  void NormalizeBig()
   {
-    for (; m_BitPos >= 16; m_BitPos -= 16)
+    if (_bitPos <= 16)
     {
-      Byte b0 = m_Stream.ReadByte();
-      Byte b1 = m_Stream.ReadByte();
-      m_Value = (m_Value << 8) | b1;
-      m_Value = (m_Value << 8) | b0;
+      {
+        UInt32 val;
+        if (_buf >= _bufLim)
+        {
+          val = 0xFFFF;
+          _extraSize += 2;
+        }
+        else
+        {
+          val = GetUi16(_buf);
+          _buf += 2;
+        }
+        _value = (_value << 16) | val;
+        _bitPos += 16;
+      }
+      if (_bitPos <= 16)
+      {
+        UInt32 val;
+        if (_buf >= _bufLim)
+        {
+          val = 0xFFFF;
+          _extraSize += 2;
+        }
+        else
+        {
+          val = GetUi16(_buf);
+          _buf += 2;
+        }
+        _value = (_value << 16) | val;
+        _bitPos += 16;
+      }
     }
   }
 
   UInt32 GetValue(unsigned numBits) const
   {
-    return ((m_Value >> ((32 - kNumValueBits) - m_BitPos)) & kBitDecoderValueMask) >> (kNumValueBits - numBits);
+    return (_value >> (_bitPos - numBits)) & (((UInt32)1 << numBits) - 1);
   }
   
   void MovePos(unsigned numBits)
   {
-    m_BitPos += numBits;
-    Normalize();
+    _bitPos -= numBits;
+    NormalizeSmall();
   }
 
-  UInt32 ReadBits(unsigned numBits)
+  UInt32 ReadBitsSmall(unsigned numBits)
   {
-    UInt32 res = GetValue(numBits);
-    MovePos(numBits);
-    return res;
+    _bitPos -= numBits;
+    UInt32 val = (_value >> _bitPos) & (((UInt32)1 << numBits) - 1);
+    NormalizeSmall();
+    return val;
   }
 
   UInt32 ReadBitsBig(unsigned numBits)
   {
-    unsigned numBits0 = numBits / 2;
-    unsigned numBits1 = numBits - numBits0;
-    UInt32 res = ReadBits(numBits0) << numBits1;
-    return res + ReadBits(numBits1);
+    _bitPos -= numBits;
+    UInt32 val = (_value >> _bitPos) & (((UInt32)1 << numBits) - 1);
+    NormalizeBig();
+    return val;
   }
 
-  bool ReadUInt32(UInt32 &v)
+  bool PrepareUncompressed()
   {
-    if (m_BitPos != 0)
+    if (_extraSize != 0)
+      return false;
+    unsigned numBits = _bitPos - 16;
+    if (((_value >> 16) & (((UInt32)1 << numBits) - 1)) != 0)
       return false;
-    v = ((m_Value >> 16) & 0xFFFF) | ((m_Value << 16) & 0xFFFF0000);
-    m_BitPos = kNumBigValueBits;
+    _buf -= 2;
+    _bitPos = 0;
     return true;
   }
 
-  Byte DirectReadByte() { return m_Stream.ReadByte(); }
+  UInt32 ReadUInt32()
+  {
+    UInt32 v = GetUi32(_buf);
+    _buf += 4;
+    return v;
+  }
+
+  void CopyTo(Byte *dest, size_t size)
+  {
+    memcpy(dest, _buf, size);
+    _buf += size;
+  }
+
+  bool IsOneDirectByteLeft() const { return _buf == _bufLim && _extraSize == 0; }
 
+  Byte DirectReadByte()
+  {
+    if (_buf > _bufLim)
+    {
+      _extraSize++;
+      return 0xFF;
+    }
+    return *_buf++;
+  }
 };
-}
 
-class CDecoder :
-  public ICompressCoder,
+
+class CDecoder:
+  public IUnknown,
   public CMyUnknownImp
 {
-  NBitStream::CDecoder m_InBitStream;
-  CLzOutWindow m_OutWindowStream;
+  CBitDecoder _bitStream;
+  Byte *_win;
+  UInt32 _pos;
+  UInt32 _winSize;
 
-  UInt32 m_RepDistances[kNumRepDistances];
-  UInt32 m_NumPosLenSlots;
-
-  bool m_IsUncompressedBlock;
-  bool m_AlignIsUsed;
+  bool _overDict;
+  bool _isUncompressedBlock;
+  bool _skipByte;
+  unsigned _numAlignBits;
 
-  NCompress::NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> m_MainDecoder;
-  NCompress::NHuffman::CDecoder<kNumHuffmanBits, kNumLenSymbols> m_LenDecoder;
-  NCompress::NHuffman::CDecoder<kNumHuffmanBits, kAlignTableSize> m_AlignDecoder;
-  NCompress::NHuffman::CDecoder<kNumHuffmanBits, kLevelTableSize> m_LevelDecoder;
+  UInt32 _reps[kNumReps];
+  UInt32 _numPosLenSlots;
+  UInt32 _unpackBlockSize;
 
-  Byte m_LastMainLevels[kMainTableSize];
-  Byte m_LastLenLevels[kNumLenSymbols];
+public:
+  bool KeepHistoryForNext;
+  bool NeedAlloc;
+private:
+  bool _keepHistory;
+  bool _wimMode;
+  unsigned _numDictBits;
+  UInt32 _writePos;
 
-  Cx86ConvertOutStream *m_x86ConvertOutStreamSpec;
-  CMyComPtr<ISequentialOutStream> m_x86ConvertOutStream;
+  Byte *_x86_buf;
+  UInt32 _x86_translationSize;
+  UInt32 _x86_processedSize;
 
-  UInt32 m_UnCompressedBlockSize;
+  Byte *_unpackedData;
+  
+  NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> _mainDecoder;
+  NHuffman::CDecoder<kNumHuffmanBits, kNumLenSymbols> _lenDecoder;
+  NHuffman::CDecoder7b<kAlignTableSize> _alignDecoder;
+  NHuffman::CDecoder<kNumHuffmanBits, kLevelTableSize, 7> _levelDecoder;
 
-  bool _keepHistory;
-  int _remainLen;
-  bool _skipByte;
+  Byte _mainLevels[kMainTableSize];
+  Byte _lenLevels[kNumLenSymbols];
 
-  bool _wimMode;
+  HRESULT Flush();
 
   UInt32 ReadBits(unsigned numBits);
-  bool ReadTable(Byte *lastLevels, Byte *newLevels, UInt32 numSymbols);
+  bool ReadTable(Byte *levels, unsigned numSymbols);
   bool ReadTables();
-  void ClearPrevLevels();
 
   HRESULT CodeSpec(UInt32 size);
-
-  HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  HRESULT SetParams2(unsigned numDictBits);
 public:
   CDecoder(bool wimMode = false);
+  ~CDecoder();
 
   MY_UNKNOWN_IMP
 
-  void ReleaseStreams();
-  STDMETHOD(Flush)();
+  HRESULT SetExternalWindow(Byte *win, unsigned numDictBits)
+  {
+    NeedAlloc = false;
+    _win = win;
+    _winSize = (UInt32)1 << numDictBits;
+    return SetParams2(numDictBits);
+  }
 
-  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  void SetKeepHistory(bool keepHistory) { _keepHistory = keepHistory; }
 
-  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
-  STDMETHOD(ReleaseInStream)();
-  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
+  HRESULT SetParams_and_Alloc(unsigned numDictBits);
 
-  HRESULT SetParams(unsigned numDictBits);
-  void SetKeepHistory(bool keepHistory) {  _keepHistory = keepHistory; }
+  HRESULT Code(const Byte *inData, size_t inSize, UInt32 outSize);
+  
+  bool WasBlockFinished() const { return _unpackBlockSize == 0; }
+  const Byte *GetUnpackData() const { return _unpackedData; }
+  const UInt32 GetUnpackSize() const { return _pos - _writePos; }
 };
 
 }}

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

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

@@ -23,10 +23,6 @@ enum
   kStatus_Error
 };
 
-static void *SzBigAlloc(void *, size_t size) { return BigAlloc(size); }
-static void SzBigFree(void *, void *address) { BigFree(address); }
-static ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
-
 CDecoder::~CDecoder()
 {
   ::MidFree(_outBuf);
@@ -53,7 +49,7 @@ STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
 
 HRESULT CDecoder::CodeSpec(Byte *memStream, UInt32 size)
 {
-  switch(_status)
+  switch (_status)
   {
     case kStatus_Finished: return S_OK;
     case kStatus_Error: return S_FALSE;

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

@@ -1,5 +1,4 @@
 // PpmdEncoder.cpp
-// 2009-03-11 : Igor Pavlov : Public domain
 
 #include "StdAfx.h"
 
@@ -15,15 +14,35 @@ namespace NPpmd {
 
 static const UInt32 kBufSize = (1 << 20);
 
-static void *SzBigAlloc(void *, size_t size) { return BigAlloc(size); }
-static void SzBigFree(void *, void *address) { BigFree(address); }
-static ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
+static const Byte kOrders[10] = { 3, 4, 4, 5, 5, 6, 8, 16, 24, 32 };
+
+void CEncProps::Normalize(int level)
+{
+  if (level < 0) level = 5;
+  if (level > 9) level = 9;
+  if (MemSize == (UInt32)(Int32)-1)
+    MemSize = level >= 9 ? ((UInt32)192 << 20) : ((UInt32)1 << (level + 19));
+  const unsigned kMult = 16;
+  if (MemSize / kMult > ReduceSize)
+  {
+    for (unsigned i = 16; i <= 31; i++)
+    {
+      UInt32 m = (UInt32)1 << i;
+      if (ReduceSize <= m / kMult)
+      {
+        if (MemSize > m)
+          MemSize = m;
+        break;
+      }
+    }
+  }
+  if (Order == -1) Order = kOrders[(unsigned)level];
+}
 
 CEncoder::CEncoder():
-  _inBuf(NULL),
-  _usedMemSize(1 << 24),
-  _order(6)
+  _inBuf(NULL)
 {
+  _props.Normalize(-1);
   _rangeEnc.Stream = &_outStream.p;
   Ppmd7_Construct(&_ppmd);
 }
@@ -34,30 +53,44 @@ CEncoder::~CEncoder()
   Ppmd7_Free(&_ppmd, &g_BigAlloc);
 }
 
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
+STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
 {
+  int level = -1;
+  CEncProps props;
   for (UInt32 i = 0; i < numProps; i++)
   {
-    const PROPVARIANT &prop = props[i];
+    const PROPVARIANT &prop = coderProps[i];
+    PROPID propID = propIDs[i];
+    if (propID > NCoderPropID::kReduceSize)
+      continue;
+    if (propID == NCoderPropID::kReduceSize)
+    {
+      if (prop.vt == VT_UI8 && prop.uhVal.QuadPart < (UInt32)(Int32)-1)
+        props.ReduceSize = (UInt32)prop.uhVal.QuadPart;
+      continue;
+    }
     if (prop.vt != VT_UI4)
       return E_INVALIDARG;
     UInt32 v = (UInt32)prop.ulVal;
-    switch(propIDs[i])
+    switch (propID)
     {
       case NCoderPropID::kUsedMemorySize:
         if (v < (1 << 16) || v > PPMD7_MAX_MEM_SIZE || (v & 3) != 0)
           return E_INVALIDARG;
-        _usedMemSize = v;
+        props.MemSize = v;
         break;
       case NCoderPropID::kOrder:
         if (v < 2 || v > 32)
           return E_INVALIDARG;
-        _order = (Byte)v;
+        props.Order = (Byte)v;
         break;
-      default:
-        return E_INVALIDARG;
+      case NCoderPropID::kNumThreads: break;
+      case NCoderPropID::kLevel: level = (int)v; break;
+      default: return E_INVALIDARG;
     }
   }
+  props.Normalize(level);
+  _props = props;
   return S_OK;
 }
 
@@ -65,8 +98,8 @@ STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
 {
   const UInt32 kPropSize = 5;
   Byte props[kPropSize];
-  props[0] = _order;
-  SetUi32(props + 1, _usedMemSize);
+  props[0] = (Byte)_props.Order;
+  SetUi32(props + 1, _props.MemSize);
   return WriteStream(outStream, props, kPropSize);
 }
 
@@ -81,14 +114,14 @@ HRESULT CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outS
   }
   if (!_outStream.Alloc(1 << 20))
     return E_OUTOFMEMORY;
-  if (!Ppmd7_Alloc(&_ppmd, _usedMemSize, &g_BigAlloc))
+  if (!Ppmd7_Alloc(&_ppmd, _props.MemSize, &g_BigAlloc))
     return E_OUTOFMEMORY;
 
   _outStream.Stream = outStream;
   _outStream.Init();
 
   Ppmd7z_RangeEnc_Init(&_rangeEnc);
-  Ppmd7_Init(&_ppmd, _order);
+  Ppmd7_Init(&_ppmd, _props.Order);
 
   UInt64 processed = 0;
   for (;;)

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

@@ -1,5 +1,4 @@
 // PpmdEncoder.h
-// 2009-03-11 : Igor Pavlov : Public domain
 
 #ifndef __COMPRESS_PPMD_ENCODER_H
 #define __COMPRESS_PPMD_ENCODER_H
@@ -15,6 +14,21 @@
 namespace NCompress {
 namespace NPpmd {
 
+struct CEncProps
+{
+  UInt32 MemSize;
+  UInt32 ReduceSize;
+  int Order;
+  
+  CEncProps()
+  {
+    MemSize = (UInt32)(Int32)-1;
+    ReduceSize = (UInt32)(Int32)-1;
+    Order = -1;
+  }
+  void Normalize(int level);
+};
+
 class CEncoder :
   public ICompressCoder,
   public ICompressSetCoderProperties,
@@ -25,20 +39,16 @@ class CEncoder :
   CByteOutBufWrap _outStream;
   CPpmd7z_RangeEnc _rangeEnc;
   CPpmd7 _ppmd;
-
-  UInt32 _usedMemSize;
-  Byte _order;
-
+  CEncProps _props;
 public:
-  MY_UNKNOWN_IMP2(
+  MY_UNKNOWN_IMP3(
+      ICompressCoder,
       ICompressSetCoderProperties,
       ICompressWriteCoderProperties)
-
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
   STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
   STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
-
   CEncoder();
   ~CEncoder();
 };

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

@@ -1,5 +1,4 @@
 // PpmdRegister.cpp
-// 2009-05-30 : Igor Pavlov : Public domain
 
 #include "StdAfx.h"
 
@@ -7,15 +6,17 @@
 
 #include "PpmdDecoder.h"
 
-static void *CreateCodec() { return (void *)(ICompressCoder *)(new NCompress::NPpmd::CDecoder); }
 #ifndef EXTRACT_ONLY
 #include "PpmdEncoder.h"
-static void *CreateCodecOut() { return (void *)(ICompressCoder *)(new NCompress::NPpmd::CEncoder);  }
-#else
-#define CreateCodecOut 0
 #endif
 
-static CCodecInfo g_CodecInfo =
-  { CreateCodec, CreateCodecOut, 0x030401, L"PPMD", 1, false };
+namespace NCompress {
+namespace NPpmd {
 
-REGISTER_CODEC(PPMD)
+REGISTER_CODEC_E(PPMD,
+    CDecoder(),
+    CEncoder(),
+    0x30401,
+    "PPMD")
+
+}}