Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 344 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/CPP/7zip/Compress/CodecExports.cpp b/other-licenses/7zstub/src/CPP/7zip/Compress/CodecExports.cpp
new file mode 100644
index 0000000000..7be496c243
--- /dev/null
+++ b/other-licenses/7zstub/src/CPP/7zip/Compress/CodecExports.cpp
@@ -0,0 +1,344 @@
+// CodecExports.cpp

+

+#include "StdAfx.h"

+

+#include "../../../C/CpuArch.h"

+

+#include "../../Common/ComTry.h"

+#include "../../Common/MyCom.h"

+

+#include "../../Windows/Defs.h"

+

+#include "../ICoder.h"

+

+#include "../Common/RegisterCodec.h"

+

+extern unsigned g_NumCodecs;

+extern const CCodecInfo *g_Codecs[];

+

+extern unsigned g_NumHashers;

+extern const CHasherInfo *g_Hashers[];

+

+static void SetPropFromAscii(const char *s, PROPVARIANT *prop) throw()

+{

+  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) throw()

+{

+  if ((value->bstrVal = ::SysAllocStringByteLen((const char *)&guid, sizeof(guid))) != NULL)

+    value->vt = VT_BSTR;

+  return S_OK;

+}

+

+static HRESULT MethodToClassID(UInt16 typeId, CMethodId id, PROPVARIANT *value) throw()

+{

+  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, bool isCoder2, bool isFilter, bool &encode, int &index) throw()

+{

+  index = -1;

+  if (clsid->Data1 != k_7zip_GUID_Data1 ||

+      clsid->Data2 != k_7zip_GUID_Data2)

+    return S_OK;

+  

+  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 : !codec.CreateDecoder)

+        || (isFilter ? !codec.IsFilter : codec.IsFilter))

+      continue;

+

+    if (codec.NumStreams == 1 ? isCoder2 : !isCoder2)

+      return E_NOINTERFACE;

+    

+    index = i;

+    return S_OK;

+  }

+  

+  return S_OK;

+}

+

+static HRESULT CreateCoderMain(unsigned index, bool encode, void **coder)

+{

+  COM_TRY_BEGIN

+  

+  const CCodecInfo &codec = *g_Codecs[index];

+  

+  void *c;

+  if (encode)

+    c = codec.CreateEncoder();

+  else

+    c = codec.CreateDecoder();

+  

+  if (c)

+  {

+    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;

+  }

+  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 = NULL;

+

+  bool isFilter = false;

+  bool isCoder2 = false;

+  bool isCoder = (*iid == IID_ICompressCoder) != 0;

+  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);

+  if (res != S_OK)

+    return res;

+  if (codecIndex < 0)

+    return CLASS_E_CLASSNOTAVAILABLE;

+

+  return CreateCoderMain(codecIndex, encode, outObject);

+}

+ 

+STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)

+{

+  ::VariantClear((VARIANTARG *)value);

+  const CCodecInfo &codec = *g_Codecs[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::kDecoder:

+      if (codec.CreateDecoder)

+        return MethodToClassID(k_7zip_GUID_Data3_Decoder, codec.Id, value);

+      break;

+    case NMethodPropID::kEncoder:

+      if (codec.CreateEncoder)

+        return MethodToClassID(k_7zip_GUID_Data3_Encoder, codec.Id, value);

+      break;

+    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.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;

+}

+

+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);

+}