| // CodecExports.cpp |
| |
| #include "StdAfx.h" |
| |
| #include "../../../C/CpuArch.h" |
| #include "../../../C/7zVersion.h" |
| |
| #include "../../Common/ComTry.h" |
| #include "../../Common/MyCom.h" |
| |
| #include "../../Windows/Defs.h" |
| #include "../../Windows/PropVariant.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() |
| { |
| const 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; |
| |
| const 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 = (int)i; |
| return S_OK; |
| } |
| |
| return S_OK; |
| } |
| |
| /* |
| #ifdef __GNUC__ |
| #ifndef __clang__ |
| #pragma GCC diagnostic ignored "-Wduplicated-branches" |
| #endif |
| #endif |
| */ |
| |
| 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; |
| unk = (IUnknown *)c; |
| /* |
| 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); |
| STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject) |
| { |
| return CreateCoder2(false, index, iid, outObject); |
| } |
| |
| |
| STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **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); |
| STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject) |
| { |
| *outObject = NULL; |
| |
| bool isFilter = false; |
| bool isCoder2 = false; |
| const 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; |
| const HRESULT res = FindCodecClassId(clsid, isCoder2, isFilter, encode, codecIndex); |
| if (res != S_OK) |
| return res; |
| if (codecIndex < 0) |
| return CLASS_E_CLASSNOTAVAILABLE; |
| |
| return CreateCoderMain((unsigned)codecIndex, encode, outObject); |
| } |
| |
| |
| STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value); |
| 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: |
| { |
| 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); |
| 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; |
| const UInt64 id = GetUi64(clsid->Data4); |
| for (unsigned i = 0; i < g_NumCodecs; i++) |
| if (id == g_Hashers[i]->Id) |
| return (int)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); |
| STDAPI CreateHasher(const GUID *clsid, IHasher **outObject) |
| { |
| COM_TRY_BEGIN |
| *outObject = NULL; |
| const int index = FindHasherClassId(clsid); |
| if (index < 0) |
| return CLASS_E_CLASSNOTAVAILABLE; |
| return CreateHasher2((UInt32)(unsigned)index, outObject); |
| COM_TRY_END |
| } |
| |
| STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value); |
| 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; |
| } |
| |
| Z7_CLASS_IMP_COM_1(CHashers, IHashers) }; |
| |
| STDAPI GetHashers(IHashers **hashers); |
| STDAPI GetHashers(IHashers **hashers) |
| { |
| COM_TRY_BEGIN |
| *hashers = new CHashers; |
| if (*hashers) |
| (*hashers)->AddRef(); |
| return S_OK; |
| COM_TRY_END |
| } |
| |
| Z7_COM7F_IMF2(UInt32, CHashers::GetNumHashers()) |
| { |
| return g_NumHashers; |
| } |
| |
| Z7_COM7F_IMF(CHashers::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)) |
| { |
| return ::GetHasherProp(index, propID, value); |
| } |
| |
| Z7_COM7F_IMF(CHashers::CreateHasher(UInt32 index, IHasher **hasher)) |
| { |
| return ::CreateHasher2(index, hasher); |
| } |
| |
| |
| STDAPI GetModuleProp(PROPID propID, PROPVARIANT *value); |
| STDAPI GetModuleProp(PROPID propID, PROPVARIANT *value) |
| { |
| ::VariantClear((VARIANTARG *)value); |
| switch (propID) |
| { |
| case NModulePropID::kInterfaceType: |
| { |
| NWindows::NCOM::PropVarEm_Set_UInt32(value, NModuleInterfaceType::k_IUnknown_VirtDestructor_ThisModule); |
| break; |
| } |
| case NModulePropID::kVersion: |
| { |
| NWindows::NCOM::PropVarEm_Set_UInt32(value, (MY_VER_MAJOR << 16) | MY_VER_MINOR); |
| break; |
| } |
| } |
| return S_OK; |
| } |