seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -2,110 +2,168 @@
 
 #include "StdAfx.h"
 
+#include "../../../C/CpuArch.h"
+
 #include "../../Common/ComTry.h"
+#include "../../Common/MyCom.h"
 
-#include "../../Windows/PropVariant.h"
+#include "../../Windows/Defs.h"
 
 #include "../ICoder.h"
 
 #include "../Common/RegisterCodec.h"
 
-extern unsigned int g_NumCodecs;
+extern unsigned g_NumCodecs;
 extern const CCodecInfo *g_Codecs[];
 
-static const UInt16 kDecodeId = 0x2790;
-
-DEFINE_GUID(CLSID_CCodec,
-0x23170F69, 0x40C1, kDecodeId, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+extern unsigned g_NumHashers;
+extern const CHasherInfo *g_Hashers[];
 
-static inline HRESULT SetPropString(const char *s, unsigned int size, PROPVARIANT *value)
+static void SetPropFromAscii(const char *s, PROPVARIANT *prop) throw()
 {
-  if ((value->bstrVal = ::SysAllocStringByteLen(s, size)) != 0)
-    value->vt = VT_BSTR;
-  return S_OK;
+  UINT len = (UINT)strlen(s);
+  BSTR dest = ::SysAllocStringLen(NULL, len);
+  if (dest)
+  {
+    for (UINT i = 0; i <= len; i++)
+      dest[i] = (Byte)s[i];
+    prop->bstrVal = dest;
+    prop->vt = VT_BSTR;
+  }
 }
 
-static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value)
+static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value) throw()
 {
-  return SetPropString((const char *)&guid, sizeof(GUID), value);
+  if ((value->bstrVal = ::SysAllocStringByteLen((const char *)&guid, sizeof(guid))) != NULL)
+    value->vt = VT_BSTR;
+  return S_OK;
 }
 
-static HRESULT SetClassID(CMethodId id, bool encode, PROPVARIANT *value)
+static HRESULT MethodToClassID(UInt16 typeId, CMethodId id, PROPVARIANT *value) throw()
 {
-  GUID clsId = CLSID_CCodec;
-  for (int i = 0; i < sizeof(id); i++, id >>= 8)
-    clsId.Data4[i] = (Byte)(id & 0xFF);
-  if (encode)
-    clsId.Data3++;
+  GUID clsId;
+  clsId.Data1 = k_7zip_GUID_Data1;
+  clsId.Data2 = k_7zip_GUID_Data2;
+  clsId.Data3 = typeId;
+  SetUi64(clsId.Data4, id);
   return SetPropGUID(clsId, value);
 }
 
-static HRESULT FindCodecClassId(const GUID *clsID, UInt32 isCoder2, bool isFilter, bool &encode, int &index)
+static HRESULT FindCodecClassId(const GUID *clsid, bool isCoder2, bool isFilter, bool &encode, int &index) throw()
 {
   index = -1;
-  if (clsID->Data1 != CLSID_CCodec.Data1 ||
-      clsID->Data2 != CLSID_CCodec.Data2 ||
-      (clsID->Data3 & ~1) != kDecodeId)
+  if (clsid->Data1 != k_7zip_GUID_Data1 ||
+      clsid->Data2 != k_7zip_GUID_Data2)
     return S_OK;
-  encode = (clsID->Data3 != kDecodeId);
-  UInt64 id = 0;
-  for (int j = 0; j < 8; j++)
-    id |= ((UInt64)clsID->Data4[j]) << (8 * j);
+  
+  encode = true;
+  
+       if (clsid->Data3 == k_7zip_GUID_Data3_Decoder) encode = false;
+  else if (clsid->Data3 != k_7zip_GUID_Data3_Encoder) return S_OK;
+  
+  UInt64 id = GetUi64(clsid->Data4);
+  
   for (unsigned i = 0; i < g_NumCodecs; i++)
   {
     const CCodecInfo &codec = *g_Codecs[i];
-    if (id != codec.Id || encode && !codec.CreateEncoder || !encode && !codec.CreateDecoder)
+    
+    if (id != codec.Id
+        || (encode ? !codec.CreateEncoder : !codec.CreateDecoder)
+        || (isFilter ? !codec.IsFilter : codec.IsFilter))
       continue;
-    if (!isFilter && codec.IsFilter || isFilter && !codec.IsFilter ||
-        codec.NumInStreams != 1 && !isCoder2 || codec.NumInStreams == 1 && isCoder2)
+
+    if (codec.NumStreams == 1 ? isCoder2 : !isCoder2)
       return E_NOINTERFACE;
+    
     index = i;
     return S_OK;
   }
+  
   return S_OK;
 }
 
-STDAPI CreateCoder2(bool encode, UInt32 index, const GUID *iid, void **outObject)
+static HRESULT CreateCoderMain(unsigned index, bool encode, void **coder)
 {
   COM_TRY_BEGIN
-  *outObject = 0;
-  bool isCoder = (*iid == IID_ICompressCoder) != 0;
-  bool isCoder2 = (*iid == IID_ICompressCoder2) != 0;
-  bool isFilter = (*iid == IID_ICompressFilter) != 0;
+  
   const CCodecInfo &codec = *g_Codecs[index];
-  if (!isFilter && codec.IsFilter || isFilter && !codec.IsFilter ||
-      codec.NumInStreams != 1 && !isCoder2 || codec.NumInStreams == 1 && isCoder2)
-    return E_NOINTERFACE;
+  
+  void *c;
   if (encode)
-  {
-    if (!codec.CreateEncoder)
-      return CLASS_E_CLASSNOTAVAILABLE;
-    *outObject = codec.CreateEncoder();
-  }
+    c = codec.CreateEncoder();
   else
+    c = codec.CreateDecoder();
+  
+  if (c)
   {
-    if (!codec.CreateDecoder)
-      return CLASS_E_CLASSNOTAVAILABLE;
-    *outObject = codec.CreateDecoder();
+    IUnknown *unk;
+    if (codec.IsFilter)
+      unk = (IUnknown *)(ICompressFilter *)c;
+    else if (codec.NumStreams != 1)
+      unk = (IUnknown *)(ICompressCoder2 *)c;
+    else
+      unk = (IUnknown *)(ICompressCoder *)c;
+    unk->AddRef();
+    *coder = c;
   }
-  if (isCoder)
-    ((ICompressCoder *)*outObject)->AddRef();
-  else if (isCoder2)
-    ((ICompressCoder2 *)*outObject)->AddRef();
-  else
-    ((ICompressFilter *)*outObject)->AddRef();
   return S_OK;
+  
   COM_TRY_END
 }
 
+static HRESULT CreateCoder2(bool encode, UInt32 index, const GUID *iid, void **outObject)
+{
+  *outObject = NULL;
+
+  const CCodecInfo &codec = *g_Codecs[index];
+
+  if (encode ? !codec.CreateEncoder : !codec.CreateDecoder)
+    return CLASS_E_CLASSNOTAVAILABLE;
+
+  if (codec.IsFilter)
+  {
+    if (*iid != IID_ICompressFilter) return E_NOINTERFACE;
+  }
+  else if (codec.NumStreams != 1)
+  {
+    if (*iid != IID_ICompressCoder2) return E_NOINTERFACE;
+  }
+  else
+  {
+    if (*iid != IID_ICompressCoder) return E_NOINTERFACE;
+  }
+  
+  return CreateCoderMain(index, encode, outObject);
+}
+
+STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject)
+{
+  return CreateCoder2(false, index, iid, outObject);
+}
+
+STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject)
+{
+  return CreateCoder2(true, index, iid, outObject);
+}
+
 STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
 {
-  *outObject = 0;
+  *outObject = NULL;
+
+  bool isFilter = false;
+  bool isCoder2 = false;
   bool isCoder = (*iid == IID_ICompressCoder) != 0;
-  bool isCoder2 = (*iid == IID_ICompressCoder2) != 0;
-  bool isFilter = (*iid == IID_ICompressFilter) != 0;
-  if (!isCoder && !isCoder2 && !isFilter)
-    return E_NOINTERFACE;
+  if (!isCoder)
+  {
+    isFilter = (*iid == IID_ICompressFilter) != 0;
+    if (!isFilter)
+    {
+      isCoder2 = (*iid == IID_ICompressCoder2) != 0;
+      if (!isCoder2)
+        return E_NOINTERFACE;
+    }
+  }
+  
   bool encode;
   int codecIndex;
   HRESULT res = FindCodecClassId(clsid, isCoder2, isFilter, encode, codecIndex);
@@ -113,42 +171,69 @@ STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
     return res;
   if (codecIndex < 0)
     return CLASS_E_CLASSNOTAVAILABLE;
-  return CreateCoder2(encode, codecIndex, iid, outObject);
-}
 
+  return CreateCoderMain(codecIndex, encode, outObject);
+}
+ 
 STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
 {
   ::VariantClear((VARIANTARG *)value);
   const CCodecInfo &codec = *g_Codecs[codecIndex];
-  switch(propID)
+  switch (propID)
   {
     case NMethodPropID::kID:
-    {
       value->uhVal.QuadPart = (UInt64)codec.Id;
       value->vt = VT_UI8;
       break;
-    }
     case NMethodPropID::kName:
-      if ((value->bstrVal = ::SysAllocString(codec.Name)) != 0)
-        value->vt = VT_BSTR;
+      SetPropFromAscii(codec.Name, value);
       break;
     case NMethodPropID::kDecoder:
       if (codec.CreateDecoder)
-        return SetClassID(codec.Id, false, value);
+        return MethodToClassID(k_7zip_GUID_Data3_Decoder, codec.Id, value);
       break;
     case NMethodPropID::kEncoder:
       if (codec.CreateEncoder)
-        return SetClassID(codec.Id, true, value);
+        return MethodToClassID(k_7zip_GUID_Data3_Encoder, codec.Id, value);
       break;
-    case NMethodPropID::kInStreams:
-    {
-      if (codec.NumInStreams != 1)
+    case NMethodPropID::kDecoderIsAssigned:
+        value->vt = VT_BOOL;
+        value->boolVal = BoolToVARIANT_BOOL(codec.CreateDecoder != NULL);
+      break;
+    case NMethodPropID::kEncoderIsAssigned:
+        value->vt = VT_BOOL;
+        value->boolVal = BoolToVARIANT_BOOL(codec.CreateEncoder != NULL);
+      break;
+    case NMethodPropID::kPackStreams:
+      if (codec.NumStreams != 1)
       {
         value->vt = VT_UI4;
-        value->ulVal = (ULONG)codec.NumInStreams;
+        value->ulVal = (ULONG)codec.NumStreams;
       }
       break;
-    }
+    /*
+    case NMethodPropID::kIsFilter:
+      // if (codec.IsFilter)
+      {
+        value->vt = VT_BOOL;
+        value->boolVal = BoolToVARIANT_BOOL(codec.IsFilter);
+      }
+      break;
+    */
+    /*
+    case NMethodPropID::kDecoderFlags:
+      {
+        value->vt = VT_UI4;
+        value->ulVal = (ULONG)codec.DecoderFlags;
+      }
+      break;
+    case NMethodPropID::kEncoderFlags:
+      {
+        value->vt = VT_UI4;
+        value->ulVal = (ULONG)codec.EncoderFlags;
+      }
+      break;
+    */
   }
   return S_OK;
 }
@@ -158,3 +243,102 @@ STDAPI GetNumberOfMethods(UINT32 *numCodecs)
   *numCodecs = g_NumCodecs;
   return S_OK;
 }
+
+
+// ---------- Hashers ----------
+
+static int FindHasherClassId(const GUID *clsid) throw()
+{
+  if (clsid->Data1 != k_7zip_GUID_Data1 ||
+      clsid->Data2 != k_7zip_GUID_Data2 ||
+      clsid->Data3 != k_7zip_GUID_Data3_Hasher)
+    return -1;
+  UInt64 id = GetUi64(clsid->Data4);
+  for (unsigned i = 0; i < g_NumCodecs; i++)
+    if (id == g_Hashers[i]->Id)
+      return i;
+  return -1;
+}
+
+static HRESULT CreateHasher2(UInt32 index, IHasher **hasher)
+{
+  COM_TRY_BEGIN
+  *hasher = g_Hashers[index]->CreateHasher();
+  if (*hasher)
+    (*hasher)->AddRef();
+  return S_OK;
+  COM_TRY_END
+}
+
+STDAPI CreateHasher(const GUID *clsid, IHasher **outObject)
+{
+  COM_TRY_BEGIN
+  *outObject = 0;
+  int index = FindHasherClassId(clsid);
+  if (index < 0)
+    return CLASS_E_CLASSNOTAVAILABLE;
+  return CreateHasher2(index, outObject);
+  COM_TRY_END
+}
+
+STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
+{
+  ::VariantClear((VARIANTARG *)value);
+  const CHasherInfo &codec = *g_Hashers[codecIndex];
+  switch (propID)
+  {
+    case NMethodPropID::kID:
+      value->uhVal.QuadPart = (UInt64)codec.Id;
+      value->vt = VT_UI8;
+      break;
+    case NMethodPropID::kName:
+      SetPropFromAscii(codec.Name, value);
+      break;
+    case NMethodPropID::kEncoder:
+      if (codec.CreateHasher)
+        return MethodToClassID(k_7zip_GUID_Data3_Hasher, codec.Id, value);
+      break;
+    case NMethodPropID::kDigestSize:
+      value->ulVal = (ULONG)codec.DigestSize;
+      value->vt = VT_UI4;
+      break;
+  }
+  return S_OK;
+}
+
+class CHashers:
+  public IHashers,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1(IHashers)
+
+  STDMETHOD_(UInt32, GetNumHashers)();
+  STDMETHOD(GetHasherProp)(UInt32 index, PROPID propID, PROPVARIANT *value);
+  STDMETHOD(CreateHasher)(UInt32 index, IHasher **hasher);
+};
+
+STDAPI GetHashers(IHashers **hashers)
+{
+  COM_TRY_BEGIN
+  *hashers = new CHashers;
+  if (*hashers)
+    (*hashers)->AddRef();
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP_(UInt32) CHashers::GetNumHashers()
+{
+  return g_NumHashers;
+}
+
+STDMETHODIMP CHashers::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  return ::GetHasherProp(index, propID, value);
+}
+
+STDMETHODIMP CHashers::CreateHasher(UInt32 index, IHasher **hasher)
+{
+  return ::CreateHasher2(index, hasher);
+}

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

@@ -4,17 +4,15 @@
 
 #include "../../../C/Alloc.h"
 
-#include "../Common/StreamUtils.h"
-
 #include "CopyCoder.h"
 
 namespace NCompress {
 
-static const UInt32 kBufferSize = 1 << 17;
+static const UInt32 kBufSize = 1 << 17;
 
 CCopyCoder::~CCopyCoder()
 {
-  ::MidFree(_buffer);
+  ::MidFree(_buf);
 }
 
 STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,
@@ -22,36 +20,78 @@ STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,
     const UInt64 * /* inSize */, const UInt64 *outSize,
     ICompressProgressInfo *progress)
 {
-  if (_buffer == 0)
+  if (!_buf)
   {
-    _buffer = (Byte *)::MidAlloc(kBufferSize);
-    if (_buffer == 0)
+    _buf = (Byte *)::MidAlloc(kBufSize);
+    if (!_buf)
       return E_OUTOFMEMORY;
   }
 
   TotalSize = 0;
+  
   for (;;)
   {
-    UInt32 size = kBufferSize;
-    if (outSize != 0)
-      if (size > *outSize - TotalSize)
-        size = (UInt32)(*outSize - TotalSize);
-    RINOK(inStream->Read(_buffer, size, &size));
+    UInt32 size = kBufSize;
+    if (outSize && size > *outSize - TotalSize)
+      size = (UInt32)(*outSize - TotalSize);
+    if (size == 0)
+      return S_OK;
+    
+    HRESULT readRes = inStream->Read(_buf, size, &size);
+
     if (size == 0)
-      break;
+      return readRes;
+
     if (outStream)
     {
-      RINOK(WriteStream(outStream, _buffer, size));
+      UInt32 pos = 0;
+      do
+      {
+        UInt32 curSize = size - pos;
+        HRESULT res = outStream->Write(_buf + pos, curSize, &curSize);
+        pos += curSize;
+        TotalSize += curSize;
+        RINOK(res);
+        if (curSize == 0)
+          return E_FAIL;
+      }
+      while (pos < size);
     }
-    TotalSize += size;
-    if (progress != NULL)
+    else
+      TotalSize += size;
+
+    RINOK(readRes);
+
+    if (progress)
     {
       RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize));
     }
   }
+}
+
+STDMETHODIMP CCopyCoder::SetInStream(ISequentialInStream *inStream)
+{
+  _inStream = inStream;
+  TotalSize = 0;
   return S_OK;
 }
 
+STDMETHODIMP CCopyCoder::ReleaseInStream()
+{
+  _inStream.Release();
+  return S_OK;
+}
+
+STDMETHODIMP CCopyCoder::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 realProcessedSize = 0;
+  HRESULT res = _inStream->Read(data, size, &realProcessedSize);
+  TotalSize += realProcessedSize;
+  if (processedSize)
+    *processedSize = realProcessedSize;
+  return res;
+}
+
 STDMETHODIMP CCopyCoder::GetInStreamProcessedSize(UInt64 *value)
 {
   *value = TotalSize;
@@ -60,8 +100,16 @@ STDMETHODIMP CCopyCoder::GetInStreamProcessedSize(UInt64 *value)
 
 HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress)
 {
-  CMyComPtr<ICompressCoder> copyCoder = new NCompress::CCopyCoder;
+  CMyComPtr<ICompressCoder> copyCoder = new CCopyCoder;
   return copyCoder->Code(inStream, outStream, NULL, NULL, progress);
 }
 
+HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress)
+{
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+  RINOK(copyCoder->Code(inStream, outStream, NULL, &size, progress));
+  return copyCoderSpec->TotalSize == size ? S_OK : E_FAIL;
+}
+
 }

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

@@ -11,23 +11,35 @@ namespace NCompress {
 
 class CCopyCoder:
   public ICompressCoder,
+  public ICompressSetInStream,
+  public ISequentialInStream,
   public ICompressGetInStreamProcessedSize,
   public CMyUnknownImp
 {
-  Byte *_buffer;
+  Byte *_buf;
+  CMyComPtr<ISequentialInStream> _inStream;
 public:
   UInt64 TotalSize;
-  CCopyCoder(): TotalSize(0), _buffer(0) {};
+  
+  CCopyCoder(): _buf(0), TotalSize(0) {};
   ~CCopyCoder();
 
-  MY_UNKNOWN_IMP1(ICompressGetInStreamProcessedSize)
+  MY_UNKNOWN_IMP4(
+      ICompressCoder,
+      ICompressSetInStream,
+      ISequentialInStream,
+      ICompressGetInStreamProcessedSize)
 
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
   STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
 };
 
 HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress);
 
 }
 

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

@@ -6,9 +6,10 @@
 
 #include "CopyCoder.h"
 
-static void *CreateCodec() { return (void *)(ICompressCoder *)(new NCompress::CCopyCoder); }
+namespace NCompress {
 
-static CCodecInfo g_CodecInfo =
-{ CreateCodec, CreateCodec, 0x00, L"Copy", 1, false };
+REGISTER_CODEC_CREATE(CreateCodec, CCopyCoder())
 
-REGISTER_CODEC(Copy)
+REGISTER_CODEC_2(Copy, CreateCodec, CreateCodec, 0, "Copy")
+
+}

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

@@ -6,15 +6,21 @@
 
 #include "DeflateDecoder.h"
 
-static void *CreateCodecDeflate64() { return (void *)(ICompressCoder *)(new NCompress::NDeflate::NDecoder::CCOMCoder64); }
 #if !defined(EXTRACT_ONLY) && !defined(DEFLATE_EXTRACT_ONLY)
 #include "DeflateEncoder.h"
-static void *CreateCodecOutDeflate64() { return (void *)(ICompressCoder *)(new NCompress::NDeflate::NEncoder::CCOMCoder64);  }
+#endif
+
+namespace NCompress {
+namespace NDeflate {
+
+REGISTER_CODEC_CREATE(CreateDec, NDecoder::CCOMCoder64())
+
+#if !defined(EXTRACT_ONLY) && !defined(DEFLATE_EXTRACT_ONLY)
+REGISTER_CODEC_CREATE(CreateEnc, NEncoder::CCOMCoder64())
 #else
-#define CreateCodecOutDeflate64 0
+#define CreateEnc NULL
 #endif
 
-static CCodecInfo g_CodecInfo =
-  { CreateCodecDeflate64, CreateCodecOutDeflate64, 0x040109, L"Deflate64", 1, false };
+REGISTER_CODEC_2(Deflate64, CreateDec, CreateEnc, 0x40109, "Deflate64")
 
-REGISTER_CODEC(Deflate64)
+}}