seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/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,9 +49,28 @@ struct CTables: public CLevels
 typedef struct _CSeqInStream
 {
   ISeqInStream SeqInStream;
-  CMyComPtr<ISequentialInStream> RealStream;
+  ISequentialInStream *RealStream;
 } CSeqInStream;
 
+struct CEncProps
+{
+  int Level;
+  int algo;
+  int fb;
+  int btMode;
+  UInt32 mc;
+  UInt32 numPasses;
+
+  CEncProps()
+  {
+    Level = -1;
+    mc = 0;
+    algo = fb = btMode = -1;
+    numPasses = (UInt32)(Int32)-1;
+  }
+  void Normalize();
+};
+
 class CCoder
 {
   CMatchFinder _lzInWindow;
@@ -72,8 +91,8 @@ public:
 
   UInt32 m_Pos;
 
-  int m_NumPasses;
-  int m_NumDivPasses;
+  unsigned m_NumPasses;
+  unsigned m_NumDivPasses;
   bool m_CheckStatic;
   bool m_IsMultiPass;
   UInt32 m_ValueBlockSize;
@@ -87,8 +106,8 @@ public:
   bool m_Deflate64Mode;
 
   Byte m_LevelLevels[kLevelTableSize];
-  int m_NumLitLenLevels;
-  int m_NumDistLevels;
+  unsigned m_NumLitLenLevels;
+  unsigned m_NumDistLevels;
   UInt32 m_NumLevelCodes;
   UInt32 m_ValueIndex;
 
@@ -116,7 +135,6 @@ public:
   COptimal m_Optimum[kNumOpts];
 
   UInt32 m_MatchFinderCycles;
-  // IMatchFinderSetNumPasses *m_SetMfPasses;
 
   void GetMatches();
   void MovePos(UInt32 num);
@@ -124,17 +142,17 @@ public:
   UInt32 GetOptimal(UInt32 &backRes);
   UInt32 GetOptimalFast(UInt32 &backRes);
 
-  void LevelTableDummy(const Byte *levels, int numLevels, UInt32 *freqs);
+  void LevelTableDummy(const Byte *levels, unsigned numLevels, UInt32 *freqs);
 
-  void WriteBits(UInt32 value, int numBits);
-  void LevelTableCode(const Byte *levels, int numLevels, const Byte *lens, const UInt32 *codes);
+  void WriteBits(UInt32 value, unsigned numBits);
+  void LevelTableCode(const Byte *levels, unsigned numLevels, const Byte *lens, const UInt32 *codes);
 
   void MakeTables(unsigned maxHuffLen);
   UInt32 GetLzBlockPrice() const;
   void TryBlock();
-  UInt32 TryDynBlock(int tableIndex, UInt32 numPasses);
+  UInt32 TryDynBlock(unsigned tableIndex, UInt32 numPasses);
 
-  UInt32 TryFixedBlock(int tableIndex);
+  UInt32 TryFixedBlock(unsigned tableIndex);
 
   void SetPrices(const CLevels &levels);
   void WriteBlock();
@@ -147,23 +165,10 @@ 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);
+  UInt32 GetBlockPrice(unsigned tableIndex, unsigned numDivPasses);
+  void CodeBlock(unsigned tableIndex, bool finalBlock);
 
+  void SetProps(const CEncProps *props2);
 public:
   CCoder(bool deflate64Mode = false);
   ~CCoder();
@@ -185,7 +190,7 @@ class CCOMCoder :
   public CCoder
 {
 public:
-  MY_UNKNOWN_IMP1(ICompressSetCoderProperties)
+  MY_UNKNOWN_IMP2(ICompressCoder, ICompressSetCoderProperties)
   CCOMCoder(): CCoder(false) {};
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
@@ -199,7 +204,7 @@ class CCOMCoder64 :
   public CCoder
 {
 public:
-  MY_UNKNOWN_IMP1(ICompressSetCoderProperties)
+  MY_UNKNOWN_IMP2(ICompressCoder, ICompressSetCoderProperties)
   CCOMCoder64(): CCoder(true) {};
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);

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

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

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

@@ -4,19 +4,28 @@
 
 #include "../../../C/Delta.h"
 
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
 #include "../Common/RegisterCodec.h"
 
-#include "BranchCoder.h"
+namespace NCompress {
+namespace NDelta {
 
 struct CDelta
 {
   unsigned _delta;
   Byte _state[DELTA_STATE_SIZE];
+
   CDelta(): _delta(1) {}
   void DeltaInit() { Delta_Init(_state); }
 };
 
-class CDeltaEncoder:
+
+#ifndef EXTRACT_ONLY
+
+class CEncoder:
   public ICompressFilter,
   public ICompressSetCoderProperties,
   public ICompressWriteCoderProperties,
@@ -24,71 +33,85 @@ class CDeltaEncoder:
   public CMyUnknownImp
 {
 public:
-  MY_UNKNOWN_IMP2(ICompressSetCoderProperties, ICompressWriteCoderProperties)
-  STDMETHOD(Init)();
-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  MY_UNKNOWN_IMP3(ICompressFilter, ICompressSetCoderProperties, ICompressWriteCoderProperties)
+  INTERFACE_ICompressFilter(;)
   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()
+STDMETHODIMP CEncoder::Init()
 {
   DeltaInit();
   return S_OK;
 }
 
-STDMETHODIMP_(UInt32) CDeltaEncoder::Filter(Byte *data, UInt32 size)
+STDMETHODIMP_(UInt32) CEncoder::Filter(Byte *data, UInt32 size)
 {
   Delta_Encode(_state, _delta, data, size);
   return size;
 }
 
-STDMETHODIMP CDeltaEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
+STDMETHODIMP CEncoder::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)
+    PROPID propID = propIDs[i];
+    if (propID >= NCoderPropID::kReduceSize)
+      continue;
+    if (prop.vt != VT_UI4)
       return E_INVALIDARG;
-    delta = prop.ulVal;
+    switch (propID)
+    {
+      case NCoderPropID::kDefaultProp:
+        delta = (UInt32)prop.ulVal;
+        if (delta < 1 || delta > 256)
+          return E_INVALIDARG;
+        break;
+      case NCoderPropID::kNumThreads: break;
+      case NCoderPropID::kLevel: break;
+      default: return E_INVALIDARG;
+    }
   }
   _delta = delta;
   return S_OK;
 }
 
-STDMETHODIMP CDeltaEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
+STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
 {
   Byte prop = (Byte)(_delta - 1);
   return outStream->Write(&prop, 1, NULL);
 }
 
-STDMETHODIMP CDeltaDecoder::Init()
+#endif
+
+
+class CDecoder:
+  public ICompressFilter,
+  public ICompressSetDecoderProperties2,
+  CDelta,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP2(ICompressFilter, ICompressSetDecoderProperties2)
+  INTERFACE_ICompressFilter(;)
+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
+};
+
+STDMETHODIMP CDecoder::Init()
 {
   DeltaInit();
   return S_OK;
 }
 
-STDMETHODIMP_(UInt32) CDeltaDecoder::Filter(Byte *data, UInt32 size)
+STDMETHODIMP_(UInt32) CDecoder::Filter(Byte *data, UInt32 size)
 {
   Delta_Decode(_state, _delta, data, size);
   return size;
 }
 
-STDMETHODIMP CDeltaDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
 {
   if (size != 1)
     return E_INVALIDARG;
@@ -96,17 +119,10 @@ STDMETHODIMP CDeltaDecoder::SetDecoderProperties2(const Byte *props, UInt32 size
   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_FILTER_E(Delta,
+    CDecoder(),
+    CEncoder(),
+    3, "Delta")
 
-REGISTER_CODECS(Delta)
+}}

data/ext/p7zip/CPP/7zip/Compress/{DllExports2.cpp → DllExports2Compress.cpp}

@@ -1,4 +1,4 @@
-// DllExports.cpp
+// DllExports2Compress.cpp
 
 #include "StdAfx.h"
 
@@ -9,20 +9,20 @@
 #include "../Common/RegisterCodec.h"
 
 extern "C"
-BOOL WINAPI DllMain(HINSTANCE /* hInstance */, DWORD /* dwReason */, LPVOID /*lpReserved*/)
+BOOL WINAPI DllMain(
+  #ifdef UNDER_CE
+  HANDLE
+  #else
+  HINSTANCE
+  #endif
+  /* 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/DllExportsCompress.cpp

@@ -0,0 +1,48 @@
+// DllExportsCompress.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyInitGuid.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+static const unsigned kNumCodecsMax = 48;
+unsigned g_NumCodecs = 0;
+const CCodecInfo *g_Codecs[kNumCodecsMax];
+void RegisterCodec(const CCodecInfo *codecInfo) throw()
+{
+  if (g_NumCodecs < kNumCodecsMax)
+    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(
+  #ifdef UNDER_CE
+  HANDLE
+  #else
+  HINSTANCE
+  #endif
+  , DWORD /* dwReason */, LPVOID /*lpReserved*/)
+{
+  return TRUE;
+}
+#endif
+
+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);
+}