seven_zip_ruby_am 1.2.5.1

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

@@ -0,0 +1,211 @@
+// DeflateEncoder.h
+
+#ifndef __DEFLATE_ENCODER_H
+#define __DEFLATE_ENCODER_H
+
+#include "../../../C/LzFind.h"
+
+#include "Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "BitlEncoder.h"
+#include "DeflateConst.h"
+
+namespace NCompress {
+namespace NDeflate {
+namespace NEncoder {
+
+struct CCodeValue
+{
+  UInt16 Len;
+  UInt16 Pos;
+  void SetAsLiteral() { Len = (1 << 15); }
+  bool IsLiteral() const { return (Len >= (1 << 15)); }
+};
+
+struct COptimal
+{
+  UInt32 Price;
+  UInt16 PosPrev;
+  UInt16 BackPrev;
+};
+
+const UInt32 kNumOptsBase = 1 << 12;
+const UInt32 kNumOpts = kNumOptsBase + kMatchMaxLen;
+
+class CCoder;
+
+struct CTables: public CLevels
+{
+  bool UseSubBlocks;
+  bool StoreMode;
+  bool StaticMode;
+  UInt32 BlockSizeRes;
+  UInt32 m_Pos;
+  void InitStructures();
+};
+
+typedef struct _CSeqInStream
+{
+  ISeqInStream SeqInStream;
+  CMyComPtr<ISequentialInStream> RealStream;
+} CSeqInStream;
+
+class CCoder
+{
+  CMatchFinder _lzInWindow;
+  CBitlEncoder m_OutStream;
+
+  CSeqInStream _seqInStream;
+
+public:
+  CCodeValue *m_Values;
+
+  UInt16 *m_MatchDistances;
+  UInt32 m_NumFastBytes;
+  bool _fastMode;
+  bool _btMode;
+
+  UInt16 *m_OnePosMatchesMemory;
+  UInt16 *m_DistanceMemory;
+
+  UInt32 m_Pos;
+
+  int m_NumPasses;
+  int m_NumDivPasses;
+  bool m_CheckStatic;
+  bool m_IsMultiPass;
+  UInt32 m_ValueBlockSize;
+
+  UInt32 m_NumLenCombinations;
+  UInt32 m_MatchMaxLen;
+  const Byte *m_LenStart;
+  const Byte *m_LenDirectBits;
+
+  bool m_Created;
+  bool m_Deflate64Mode;
+
+  Byte m_LevelLevels[kLevelTableSize];
+  int m_NumLitLenLevels;
+  int m_NumDistLevels;
+  UInt32 m_NumLevelCodes;
+  UInt32 m_ValueIndex;
+
+  bool m_SecondPass;
+  UInt32 m_AdditionalOffset;
+
+  UInt32 m_OptimumEndIndex;
+  UInt32 m_OptimumCurrentIndex;
+  
+  Byte  m_LiteralPrices[256];
+  Byte  m_LenPrices[kNumLenSymbolsMax];
+  Byte  m_PosPrices[kDistTableSize64];
+
+  CLevels m_NewLevels;
+  UInt32 mainFreqs[kFixedMainTableSize];
+  UInt32 distFreqs[kDistTableSize64];
+  UInt32 mainCodes[kFixedMainTableSize];
+  UInt32 distCodes[kDistTableSize64];
+  UInt32 levelCodes[kLevelTableSize];
+  Byte levelLens[kLevelTableSize];
+
+  UInt32 BlockSizeRes;
+
+  CTables *m_Tables;
+  COptimal m_Optimum[kNumOpts];
+
+  UInt32 m_MatchFinderCycles;
+  // IMatchFinderSetNumPasses *m_SetMfPasses;
+
+  void GetMatches();
+  void MovePos(UInt32 num);
+  UInt32 Backward(UInt32 &backRes, UInt32 cur);
+  UInt32 GetOptimal(UInt32 &backRes);
+  UInt32 GetOptimalFast(UInt32 &backRes);
+
+  void LevelTableDummy(const Byte *levels, int numLevels, UInt32 *freqs);
+
+  void WriteBits(UInt32 value, int numBits);
+  void LevelTableCode(const Byte *levels, int numLevels, const Byte *lens, const UInt32 *codes);
+
+  void MakeTables(unsigned maxHuffLen);
+  UInt32 GetLzBlockPrice() const;
+  void TryBlock();
+  UInt32 TryDynBlock(int tableIndex, UInt32 numPasses);
+
+  UInt32 TryFixedBlock(int tableIndex);
+
+  void SetPrices(const CLevels &levels);
+  void WriteBlock();
+
+  HRESULT Create();
+  void Free();
+
+  void WriteStoreBlock(UInt32 blockSize, UInt32 additionalOffset, bool finalBlock);
+  void WriteTables(bool writeMode, bool finalBlock);
+  
+  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);
+
+public:
+  CCoder(bool deflate64Mode = false);
+  ~CCoder();
+
+  HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+
+  HRESULT BaseCode(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+
+  HRESULT BaseSetEncoderProperties2(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+};
+
+
+class CCOMCoder :
+  public ICompressCoder,
+  public ICompressSetCoderProperties,
+  public CMyUnknownImp,
+  public CCoder
+{
+public:
+  MY_UNKNOWN_IMP1(ICompressSetCoderProperties)
+  CCOMCoder(): CCoder(false) {};
+  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+};
+
+class CCOMCoder64 :
+  public ICompressCoder,
+  public ICompressSetCoderProperties,
+  public CMyUnknownImp,
+  public CCoder
+{
+public:
+  MY_UNKNOWN_IMP1(ICompressSetCoderProperties)
+  CCOMCoder64(): CCoder(true) {};
+  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+};
+
+}}}
+
+#endif

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

@@ -0,0 +1,21 @@
+// DeflateRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "DeflateDecoder.h"
+
+static void *CreateCodecDeflate() { return (void *)(ICompressCoder *)(new NCompress::NDeflate::NDecoder::CCOMCoder); }
+
+#if !defined(EXTRACT_ONLY) && !defined(DEFLATE_EXTRACT_ONLY)
+#include "DeflateEncoder.h"
+static void *CreateCodecOutDeflate() { return (void *)(ICompressCoder *)(new NCompress::NDeflate::NEncoder::CCOMCoder);  }
+#else
+#define CreateCodecOutDeflate 0
+#endif
+
+static CCodecInfo g_CodecInfo =
+  { CreateCodecDeflate,   CreateCodecOutDeflate,   0x040108, L"Deflate", 1, false };
+
+REGISTER_CODEC(Deflate)

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

@@ -0,0 +1,112 @@
+// DeltaFilter.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Delta.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "BranchCoder.h"
+
+struct CDelta
+{
+  unsigned _delta;
+  Byte _state[DELTA_STATE_SIZE];
+  CDelta(): _delta(1) {}
+  void DeltaInit() { Delta_Init(_state); }
+};
+
+class CDeltaEncoder:
+  public ICompressFilter,
+  public ICompressSetCoderProperties,
+  public ICompressWriteCoderProperties,
+  CDelta,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP2(ICompressSetCoderProperties, ICompressWriteCoderProperties)
+  STDMETHOD(Init)();
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
+};
+
+class CDeltaDecoder:
+  public ICompressFilter,
+  public ICompressSetDecoderProperties2,
+  CDelta,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
+  STDMETHOD(Init)();
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
+};
+
+STDMETHODIMP CDeltaEncoder::Init()
+{
+  DeltaInit();
+  return S_OK;
+}
+
+STDMETHODIMP_(UInt32) CDeltaEncoder::Filter(Byte *data, UInt32 size)
+{
+  Delta_Encode(_state, _delta, data, size);
+  return size;
+}
+
+STDMETHODIMP CDeltaEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
+{
+  UInt32 delta = _delta;
+  for (UInt32 i = 0; i < numProps; i++)
+  {
+    const PROPVARIANT &prop = props[i];
+    if (propIDs[i] != NCoderPropID::kDefaultProp || prop.vt != VT_UI4 || prop.ulVal < 1 || prop.ulVal > 256)
+      return E_INVALIDARG;
+    delta = prop.ulVal;
+  }
+  _delta = delta;
+  return S_OK;
+}
+
+STDMETHODIMP CDeltaEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
+{
+  Byte prop = (Byte)(_delta - 1);
+  return outStream->Write(&prop, 1, NULL);
+}
+
+STDMETHODIMP CDeltaDecoder::Init()
+{
+  DeltaInit();
+  return S_OK;
+}
+
+STDMETHODIMP_(UInt32) CDeltaDecoder::Filter(Byte *data, UInt32 size)
+{
+  Delta_Decode(_state, _delta, data, size);
+  return size;
+}
+
+STDMETHODIMP CDeltaDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
+{
+  if (size != 1)
+    return E_INVALIDARG;
+  _delta = (unsigned)props[0] + 1;
+  return S_OK;
+}
+
+#define CREATE_CODEC(x) \
+  static void *CreateCodec ## x() { return (void *)(ICompressFilter *)(new C ## x ## Decoder); } \
+  static void *CreateCodec ## x ## Out() { return (void *)(ICompressFilter *)(new C ## x ## Encoder); }
+
+CREATE_CODEC(Delta)
+
+#define METHOD_ITEM(x, id, name) { CreateCodec ## x, CreateCodec ## x ## Out, id, name, 1, true  }
+
+static CCodecInfo g_CodecsInfo[] =
+{
+  METHOD_ITEM(Delta, 3, L"Delta")
+};
+
+REGISTER_CODECS(Delta)

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

@@ -0,0 +1,39 @@
+// DllExports.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyInitGuid.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+static const unsigned int kNumCodecsMax = 32;
+unsigned int g_NumCodecs = 0;
+const CCodecInfo *g_Codecs[kNumCodecsMax];
+void RegisterCodec(const CCodecInfo *codecInfo)
+{
+  if (g_NumCodecs < kNumCodecsMax)
+    g_Codecs[g_NumCodecs++] = codecInfo;
+}
+
+#ifdef _WIN32
+extern "C"
+BOOL WINAPI DllMain(HINSTANCE /* hInstance */, DWORD /* dwReason */, LPVOID /*lpReserved*/)
+{
+  return TRUE;
+}
+#endif
+
+static const UInt16 kDecodeId = 0x2790;
+
+DEFINE_GUID(CLSID_CCodec,
+0x23170F69, 0x40C1, kDecodeId, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+
+STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
+
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
+{
+  return CreateCoder(clsid, iid, outObject);
+}
+

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

@@ -0,0 +1,28 @@
+// DllExports.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyInitGuid.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+extern "C"
+BOOL WINAPI DllMain(HINSTANCE /* hInstance */, DWORD /* dwReason */, LPVOID /*lpReserved*/)
+{
+  return TRUE;
+}
+
+static const UInt16 kDecodeId = 0x2790;
+
+DEFINE_GUID(CLSID_CCodec,
+0x23170F69, 0x40C1, kDecodeId, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+
+STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
+
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
+{
+  return CreateCoder(clsid, iid, outObject);
+}
+

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

@@ -0,0 +1,89 @@
+// Compress/HuffmanDecoder.h
+
+#ifndef __COMPRESS_HUFFMAN_DECODER_H
+#define __COMPRESS_HUFFMAN_DECODER_H
+
+#include "../../Common/Types.h"
+
+namespace NCompress {
+namespace NHuffman {
+
+const int kNumTableBits = 9;
+
+template <int kNumBitsMax, UInt32 m_NumSymbols>
+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.
+
+public:
+  
+  bool SetCodeLengths(const Byte *codeLengths)
+  {
+    int lenCounts[kNumBitsMax + 1];
+    UInt32 tmpPositions[kNumBitsMax + 1];
+    int i;
+    for(i = 1; i <= kNumBitsMax; i++)
+      lenCounts[i] = 0;
+    UInt32 symbol;
+    for (symbol = 0; symbol < m_NumSymbols; symbol++)
+    {
+      int len = codeLengths[symbol];
+      if (len > kNumBitsMax)
+        return false;
+      lenCounts[len]++;
+      m_Symbols[symbol] = 0xFFFFFFFF;
+    }
+    lenCounts[0] = 0;
+    m_Positions[0] = m_Limits[0] = 0;
+    UInt32 startPos = 0;
+    UInt32 index = 0;
+    const UInt32 kMaxValue = (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)
+      {
+        UInt32 limit = (m_Limits[i] >> (kNumBitsMax - kNumTableBits));
+        for (; index < limit; index++)
+          m_Lengths[index] = (Byte)i;
+      }
+    }
+    for (symbol = 0; symbol < m_NumSymbols; symbol++)
+    {
+      int len = codeLengths[symbol];
+      if (len != 0)
+        m_Symbols[tmpPositions[len]++] = symbol;
+    }
+    return true;
+  }
+
+  template <class TBitDecoder>
+  UInt32 DecodeSymbol(TBitDecoder *bitStream)
+  {
+    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++);
+    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];
+  }
+};
+
+}}
+
+#endif