seven_zip_ruby_am 1.2.5.1

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

@@ -0,0 +1,46 @@
+// Lzx86Converter.h
+
+#ifndef __LZX_86_CONVERTER_H
+#define __LZX_86_CONVERTER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../IStream.h"
+
+namespace NCompress {
+namespace NLzx {
+
+const int kUncompressedBlockSize = 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];
+
+  void MakeTranslation();
+public:
+  void SetStream(ISequentialOutStream *outStream) { m_Stream = outStream; }
+  void ReleaseStream() { m_Stream.Release(); }
+  void Init(bool translationMode, UInt32 translationSize)
+  {
+    m_TranslationMode = translationMode;
+    m_TranslationSize = translationSize;
+    m_ProcessedSize = 0;
+    m_Pos = 0;
+  }
+  HRESULT Flush();
+
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+}}
+
+#endif

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

@@ -0,0 +1,387 @@
+// LzxDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/Defs.h"
+
+#include "LzxDecoder.h"
+
+namespace NCompress {
+namespace NLzx {
+
+const int kLenIdNeedInit = -2;
+
+CDecoder::CDecoder(bool wimMode):
+  _keepHistory(false),
+  _skipByte(false),
+  _wimMode(wimMode)
+{
+  m_x86ConvertOutStreamSpec = new Cx86ConvertOutStream;
+  m_x86ConvertOutStream = m_x86ConvertOutStreamSpec;
+}
+
+void CDecoder::ReleaseStreams()
+{
+  m_OutWindowStream.ReleaseStream();
+  m_InBitStream.ReleaseStream();
+  m_x86ConvertOutStreamSpec->ReleaseStream();
+}
+
+STDMETHODIMP CDecoder::Flush()
+{
+  RINOK(m_OutWindowStream.Flush());
+  return m_x86ConvertOutStreamSpec->Flush();
+}
+
+UInt32 CDecoder::ReadBits(unsigned numBits) { return m_InBitStream.ReadBits(numBits); }
+
+#define RIF(x) { if (!(x)) return false; }
+
+bool CDecoder::ReadTable(Byte *lastLevels, Byte *newLevels, UInt32 numSymbols)
+{
+  Byte levelLevels[kLevelTableSize];
+  UInt32 i;
+  for (i = 0; i < kLevelTableSize; i++)
+    levelLevels[i] = (Byte)ReadBits(kNumBitsForPreTreeLevel);
+  RIF(m_LevelDecoder.SetCodeLengths(levelLevels));
+  unsigned num = 0;
+  Byte symbol = 0;
+  for (i = 0; i < numSymbols;)
+  {
+    if (num != 0)
+    {
+      lastLevels[i] = newLevels[i] = symbol;
+      i++;
+      num--;
+      continue;
+    }
+    UInt32 number = m_LevelDecoder.DecodeSymbol(&m_InBitStream);
+    if (number == kLevelSymbolZeros)
+    {
+      num = kLevelSymbolZerosStartValue + (unsigned)ReadBits(kLevelSymbolZerosNumBits);
+      symbol = 0;
+    }
+    else if (number == kLevelSymbolZerosBig)
+    {
+      num = kLevelSymbolZerosBigStartValue + (unsigned)ReadBits(kLevelSymbolZerosBigNumBits);
+      symbol = 0;
+    }
+    else if (number == kLevelSymbolSame || number <= kNumHuffmanBits)
+    {
+      if (number <= kNumHuffmanBits)
+        num = 1;
+      else
+      {
+        num = kLevelSymbolSameStartValue + (unsigned)ReadBits(kLevelSymbolSameNumBits);
+        number = m_LevelDecoder.DecodeSymbol(&m_InBitStream);
+        if (number > kNumHuffmanBits)
+          return false;
+      }
+      symbol = Byte((17 + lastLevels[i] - number) % (kNumHuffmanBits + 1));
+    }
+    else
+      return false;
+  }
+  return true;
+}
+
+bool CDecoder::ReadTables(void)
+{
+  Byte newLevels[kMaxTableSize];
+  {
+    if (_skipByte)
+      m_InBitStream.DirectReadByte();
+    m_InBitStream.Normalize();
+
+    unsigned blockType = (unsigned)ReadBits(kNumBlockTypeBits);
+    if (blockType > kBlockTypeUncompressed)
+      return false;
+    if (_wimMode)
+      if (ReadBits(1) == 1)
+        m_UnCompressedBlockSize = (1 << 15);
+      else
+        m_UnCompressedBlockSize = ReadBits(16);
+    else
+      m_UnCompressedBlockSize = m_InBitStream.ReadBitsBig(kUncompressedBlockSizeNumBits);
+
+    m_IsUncompressedBlock = (blockType == kBlockTypeUncompressed);
+
+    _skipByte = (m_IsUncompressedBlock && ((m_UnCompressedBlockSize & 1) != 0));
+
+    if (m_IsUncompressedBlock)
+    {
+      ReadBits(16 - m_InBitStream.GetBitPosition());
+      if (!m_InBitStream.ReadUInt32(m_RepDistances[0]))
+        return false;
+      m_RepDistances[0]--;
+      for (unsigned i = 1; i < kNumRepDistances; i++)
+      {
+        UInt32 rep = 0;
+        for (unsigned j = 0; j < 4; j++)
+          rep |= (UInt32)m_InBitStream.DirectReadByte() << (8 * j);
+        m_RepDistances[i] = rep - 1;
+      }
+      return true;
+    }
+    m_AlignIsUsed = (blockType == kBlockTypeAligned);
+    if (m_AlignIsUsed)
+    {
+      for (unsigned i = 0; i < kAlignTableSize; i++)
+        newLevels[i] = (Byte)ReadBits(kNumBitsForAlignLevel);
+      RIF(m_AlignDecoder.SetCodeLengths(newLevels));
+    }
+  }
+
+  RIF(ReadTable(m_LastMainLevels, newLevels, 256));
+  RIF(ReadTable(m_LastMainLevels + 256, newLevels + 256, m_NumPosLenSlots));
+  for (UInt32 i = 256 + m_NumPosLenSlots; i < kMainTableSize; i++)
+    newLevels[i] = 0;
+  RIF(m_MainDecoder.SetCodeLengths(newLevels));
+
+  RIF(ReadTable(m_LastLenLevels, newLevels, kNumLenSymbols));
+  return m_LenDecoder.SetCodeLengths(newLevels);
+}
+
+class CDecoderFlusher
+{
+  CDecoder *m_Decoder;
+public:
+  bool NeedFlush;
+  CDecoderFlusher(CDecoder *decoder): m_Decoder(decoder), NeedFlush(true) {}
+  ~CDecoderFlusher()
+  {
+    if (NeedFlush)
+      m_Decoder->Flush();
+    m_Decoder->ReleaseStreams();
+  }
+};
+
+
+void CDecoder::ClearPrevLevels()
+{
+  unsigned i;
+  for (i = 0; i < kMainTableSize; i++)
+    m_LastMainLevels[i] = 0;
+  for (i = 0; i < kNumLenSymbols; i++)
+    m_LastLenLevels[i] = 0;
+}
+
+
+HRESULT CDecoder::CodeSpec(UInt32 curSize)
+{
+  if (_remainLen == kLenIdNeedInit)
+  {
+    _remainLen = 0;
+    m_InBitStream.Init();
+    if (!_keepHistory || !m_IsUncompressedBlock)
+      m_InBitStream.Normalize();
+    if (!_keepHistory)
+    {
+      _skipByte = false;
+      m_UnCompressedBlockSize = 0;
+      ClearPrevLevels();
+      UInt32 i86TranslationSize = 12000000;
+      bool translationMode = true;
+      if (!_wimMode)
+      {
+        translationMode = (ReadBits(1) != 0);
+        if (translationMode)
+        {
+          i86TranslationSize = ReadBits(16) << 16;
+          i86TranslationSize |= ReadBits(16);
+        }
+      }
+      m_x86ConvertOutStreamSpec->Init(translationMode, i86TranslationSize);
+      
+      for (unsigned i = 0 ; i < kNumRepDistances; i++)
+        m_RepDistances[i] = 0;
+    }
+  }
+
+  while (_remainLen > 0 && curSize > 0)
+  {
+    m_OutWindowStream.PutByte(m_OutWindowStream.GetByte(m_RepDistances[0]));
+    _remainLen--;
+    curSize--;
+  }
+
+  while (curSize > 0)
+  {
+    if (m_UnCompressedBlockSize == 0)
+      if (!ReadTables())
+        return S_FALSE;
+    UInt32 next = (Int32)MyMin(m_UnCompressedBlockSize, curSize);
+    curSize -= next;
+    m_UnCompressedBlockSize -= next;
+    if (m_IsUncompressedBlock)
+    {
+      while (next > 0)
+      {
+        m_OutWindowStream.PutByte(m_InBitStream.DirectReadByte());
+        next--;
+      }
+    }
+    else while (next > 0)
+    {
+      UInt32 number = m_MainDecoder.DecodeSymbol(&m_InBitStream);
+      if (number < 256)
+      {
+        m_OutWindowStream.PutByte((Byte)number);
+        next--;
+      }
+      else
+      {
+        UInt32 posLenSlot = number - 256;
+        if (posLenSlot >= m_NumPosLenSlots)
+          return S_FALSE;
+        UInt32 posSlot = posLenSlot / kNumLenSlots;
+        UInt32 lenSlot = posLenSlot % kNumLenSlots;
+        UInt32 len = kMatchMinLen + lenSlot;
+        if (lenSlot == kNumLenSlots - 1)
+        {
+          UInt32 lenTemp = m_LenDecoder.DecodeSymbol(&m_InBitStream);
+          if (lenTemp >= kNumLenSymbols)
+            return S_FALSE;
+          len += lenTemp;
+        }
+        
+        if (posSlot < kNumRepDistances)
+        {
+          UInt32 distance = m_RepDistances[posSlot];
+          m_RepDistances[posSlot] = m_RepDistances[0];
+          m_RepDistances[0] = distance;
+        }
+        else
+        {
+          UInt32 distance;
+          unsigned numDirectBits;
+          if (posSlot < kNumPowerPosSlots)
+          {
+            numDirectBits = (unsigned)(posSlot >> 1) - 1;
+            distance = ((2 | (posSlot & 1)) << numDirectBits);
+          }
+          else
+          {
+            numDirectBits = kNumLinearPosSlotBits;
+            distance = ((posSlot - 0x22) << kNumLinearPosSlotBits);
+          }
+
+          if (m_AlignIsUsed && numDirectBits >= kNumAlignBits)
+          {
+            distance += (m_InBitStream.ReadBits(numDirectBits - kNumAlignBits) << kNumAlignBits);
+            UInt32 alignTemp = m_AlignDecoder.DecodeSymbol(&m_InBitStream);
+            if (alignTemp >= kAlignTableSize)
+              return S_FALSE;
+            distance += alignTemp;
+          }
+          else
+            distance += m_InBitStream.ReadBits(numDirectBits);
+          m_RepDistances[2] = m_RepDistances[1];
+          m_RepDistances[1] = m_RepDistances[0];
+          m_RepDistances[0] = distance - kNumRepDistances;
+        }
+
+        UInt32 locLen = len;
+        if (locLen > next)
+          locLen = next;
+
+        if (!m_OutWindowStream.CopyBlock(m_RepDistances[0], locLen))
+          return S_FALSE;
+
+        len -= locLen;
+        next -= locLen;
+        if (len != 0)
+        {
+          _remainLen = (int)len;
+          return S_OK;
+        }
+      }
+    }
+  }
+  return S_OK;
+}
+
+HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 *, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+  if (outSize == NULL)
+    return E_INVALIDARG;
+  UInt64 size = *outSize;
+
+  RINOK(SetInStream(inStream));
+  m_x86ConvertOutStreamSpec->SetStream(outStream);
+  m_OutWindowStream.SetStream(m_x86ConvertOutStream);
+  RINOK(SetOutStreamSize(outSize));
+
+  CDecoderFlusher flusher(this);
+
+  const UInt64 start = m_OutWindowStream.GetProcessedSize();
+  for (;;)
+  {
+    UInt32 curSize = 1 << 18;
+    UInt64 rem = size - (m_OutWindowStream.GetProcessedSize() - start);
+    if (curSize > rem)
+      curSize = (UInt32)rem;
+    if (curSize == 0)
+      break;
+    RINOK(CodeSpec(curSize));
+    if (progress != NULL)
+    {
+      UInt64 inSize = m_InBitStream.GetProcessedSize();
+      UInt64 nowPos64 = m_OutWindowStream.GetProcessedSize() - start;
+      RINOK(progress->SetRatioInfo(&inSize, &nowPos64));
+    }
+  }
+  flusher.NeedFlush = false;
+  return Flush();
+}
+
+HRESULT CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+  try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+  catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+  catch(...) { return S_FALSE; }
+}
+
+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)
+{
+  m_InBitStream.SetStream(inStream);
+  return S_OK;
+}
+
+STDMETHODIMP CDecoder::ReleaseInStream()
+{
+  m_InBitStream.ReleaseStream();
+  return S_OK;
+}
+
+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
+{
+  if (outSize == NULL)
+    return E_FAIL;
+  _remainLen = kLenIdNeedInit;
+  m_OutWindowStream.Init(_keepHistory);
+  return S_OK;
+}
+
+HRESULT CDecoder::SetParams(unsigned numDictBits)
+{
+  if (numDictBits < kNumDictionaryBitsMin || numDictBits > kNumDictionaryBitsMax)
+    return E_INVALIDARG;
+  UInt32 numPosSlots;
+  if (numDictBits < 20)
+    numPosSlots = 30 + (numDictBits - 15) * 2;
+  else if (numDictBits == 20)
+    numPosSlots = 42;
+  else
+    numPosSlots = 50;
+  m_NumPosLenSlots = numPosSlots * kNumLenSlots;
+  if (!m_OutWindowStream.Create(kDictionarySizeMax))
+    return E_OUTOFMEMORY;
+  if (!m_InBitStream.Create(1 << 16))
+    return E_OUTOFMEMORY;
+  return S_OK;
+}
+
+}}

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

@@ -0,0 +1,159 @@
+// LzxDecoder.h
+
+#ifndef __LZX_DECODER_H
+#define __LZX_DECODER_H
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.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
+{
+  CInBuffer m_Stream;
+  UInt32 m_Value;
+  unsigned m_BitPos;
+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()
+  {
+    m_Stream.Init();
+    m_BitPos = kNumBigValueBits;
+  }
+
+  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (kNumBigValueBits - m_BitPos) / 8; }
+  
+  unsigned GetBitPosition() const { return m_BitPos & 0xF; }
+
+  void Normalize()
+  {
+    for (; m_BitPos >= 16; m_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 GetValue(unsigned numBits) const
+  {
+    return ((m_Value >> ((32 - kNumValueBits) - m_BitPos)) & kBitDecoderValueMask) >> (kNumValueBits - numBits);
+  }
+  
+  void MovePos(unsigned numBits)
+  {
+    m_BitPos += numBits;
+    Normalize();
+  }
+
+  UInt32 ReadBits(unsigned numBits)
+  {
+    UInt32 res = GetValue(numBits);
+    MovePos(numBits);
+    return res;
+  }
+
+  UInt32 ReadBitsBig(unsigned numBits)
+  {
+    unsigned numBits0 = numBits / 2;
+    unsigned numBits1 = numBits - numBits0;
+    UInt32 res = ReadBits(numBits0) << numBits1;
+    return res + ReadBits(numBits1);
+  }
+
+  bool ReadUInt32(UInt32 &v)
+  {
+    if (m_BitPos != 0)
+      return false;
+    v = ((m_Value >> 16) & 0xFFFF) | ((m_Value << 16) & 0xFFFF0000);
+    m_BitPos = kNumBigValueBits;
+    return true;
+  }
+
+  Byte DirectReadByte() { return m_Stream.ReadByte(); }
+
+};
+}
+
+class CDecoder :
+  public ICompressCoder,
+  public CMyUnknownImp
+{
+  NBitStream::CDecoder m_InBitStream;
+  CLzOutWindow m_OutWindowStream;
+
+  UInt32 m_RepDistances[kNumRepDistances];
+  UInt32 m_NumPosLenSlots;
+
+  bool m_IsUncompressedBlock;
+  bool m_AlignIsUsed;
+
+  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;
+
+  Byte m_LastMainLevels[kMainTableSize];
+  Byte m_LastLenLevels[kNumLenSymbols];
+
+  Cx86ConvertOutStream *m_x86ConvertOutStreamSpec;
+  CMyComPtr<ISequentialOutStream> m_x86ConvertOutStream;
+
+  UInt32 m_UnCompressedBlockSize;
+
+  bool _keepHistory;
+  int _remainLen;
+  bool _skipByte;
+
+  bool _wimMode;
+
+  UInt32 ReadBits(unsigned numBits);
+  bool ReadTable(Byte *lastLevels, Byte *newLevels, UInt32 numSymbols);
+  bool ReadTables();
+  void ClearPrevLevels();
+
+  HRESULT CodeSpec(UInt32 size);
+
+  HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+public:
+  CDecoder(bool wimMode = false);
+
+  MY_UNKNOWN_IMP
+
+  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(SetOutStreamSize)(const UInt64 *outSize);
+
+  HRESULT SetParams(unsigned numDictBits);
+  void SetKeepHistory(bool keepHistory) {  _keepHistory = keepHistory; }
+};
+
+}}
+
+#endif