static HRESULT WINAPI ComponentFactory_CreateComponentEnumerator(IWICComponentFactory *iface,
DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
{
TRACE("(%p,%u,%u,%p)\n", iface, componentTypes, options, ppIEnumUnknown);
return CreateComponentEnumerator(componentTypes, options, ppIEnumUnknown);
}
static HRESULT WINAPI ComponentFactory_CreateEncoder(IWICComponentFactory *iface,
REFGUID guidContainerFormat, const GUID *pguidVendor,
IWICBitmapEncoder **ppIEncoder)
{
static int fixme=0;
IEnumUnknown *enumencoders;
IUnknown *unkencoderinfo;
IWICBitmapEncoderInfo *encoderinfo;
IWICBitmapEncoder *encoder=NULL;
HRESULT res=S_OK;
ULONG num_fetched;
GUID actual_containerformat;
TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
debugstr_guid(pguidVendor), ppIEncoder);
if (pguidVendor && !fixme++)
FIXME("ignoring vendor GUID\n");
res = CreateComponentEnumerator(WICEncoder, WICComponentEnumerateDefault, &enumencoders);
if (FAILED(res)) return res;
while (!encoder)
{
res = IEnumUnknown_Next(enumencoders, 1, &unkencoderinfo, &num_fetched);
if (res == S_OK)
{
res = IUnknown_QueryInterface(unkencoderinfo, &IID_IWICBitmapEncoderInfo, (void**)&encoderinfo);
if (SUCCEEDED(res))
{
res = IWICBitmapEncoderInfo_GetContainerFormat(encoderinfo, &actual_containerformat);
if (SUCCEEDED(res) && IsEqualGUID(guidContainerFormat, &actual_containerformat))
{
res = IWICBitmapEncoderInfo_CreateInstance(encoderinfo, &encoder);
if (FAILED(res))
encoder = NULL;
}
IWICBitmapEncoderInfo_Release(encoderinfo);
}
IUnknown_Release(unkencoderinfo);
}
else
break;
}
IEnumUnknown_Release(enumencoders);
if (encoder)
{
*ppIEncoder = encoder;
return S_OK;
}
else
{
WARN("failed to create encoder\n");
*ppIEncoder = NULL;
return WINCODEC_ERR_COMPONENTNOTFOUND;
}
}
static HRESULT WINAPI ComponentFactory_CreateDecoder(IWICComponentFactory *iface,
REFGUID guidContainerFormat, const GUID *pguidVendor,
IWICBitmapDecoder **ppIDecoder)
{
IEnumUnknown *enumdecoders;
IUnknown *unkdecoderinfo;
IWICBitmapDecoderInfo *decoderinfo;
IWICBitmapDecoder *decoder = NULL, *preferred_decoder = NULL;
GUID vendor;
HRESULT res;
ULONG num_fetched;
TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
debugstr_guid(pguidVendor), ppIDecoder);
if (!guidContainerFormat || !ppIDecoder) return E_INVALIDARG;
res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
if (FAILED(res)) return res;
while (!preferred_decoder)
{
res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
if (res != S_OK) break;
res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void **)&decoderinfo);
if (SUCCEEDED(res))
{
GUID container_guid;
res = IWICBitmapDecoderInfo_GetContainerFormat(decoderinfo, &container_guid);
if (SUCCEEDED(res) && IsEqualIID(&container_guid, guidContainerFormat))
{
IWICBitmapDecoder *new_decoder;
res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &new_decoder);
if (SUCCEEDED(res))
{
if (pguidVendor)
{
res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
if (SUCCEEDED(res) && IsEqualIID(&vendor, pguidVendor))
{
preferred_decoder = new_decoder;
new_decoder = NULL;
}
}
if (new_decoder && !decoder)
{
decoder = new_decoder;
new_decoder = NULL;
}
if (new_decoder) IWICBitmapDecoder_Release(new_decoder);
}
}
IWICBitmapDecoderInfo_Release(decoderinfo);
}
IUnknown_Release(unkdecoderinfo);
}
IEnumUnknown_Release(enumdecoders);
if (preferred_decoder)
{
*ppIDecoder = preferred_decoder;
if (decoder) IWICBitmapDecoder_Release(decoder);
return S_OK;
}
if (decoder)
{
*ppIDecoder = decoder;
return S_OK;
}
*ppIDecoder = NULL;
return WINCODEC_ERR_COMPONENTNOTFOUND;
}
static IWICBitmapDecoder *find_decoder(IStream *pIStream, const GUID *pguidVendor,
WICDecodeOptions metadataOptions)
{
IEnumUnknown *enumdecoders;
IUnknown *unkdecoderinfo;
IWICBitmapDecoderInfo *decoderinfo;
IWICBitmapDecoder *decoder = NULL;
GUID vendor;
HRESULT res;
ULONG num_fetched;
BOOL matches;
res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
if (FAILED(res)) return NULL;
while (!decoder)
{
res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
if (res == S_OK)
{
res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
if (SUCCEEDED(res))
{
if (pguidVendor)
{
res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
if (FAILED(res) || !IsEqualIID(&vendor, pguidVendor))
{
IWICBitmapDecoderInfo_Release(decoderinfo);
IUnknown_Release(unkdecoderinfo);
continue;
}
}
res = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, pIStream, &matches);
if (SUCCEEDED(res) && matches)
{
res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
/* FIXME: should use QueryCapability to choose a decoder */
if (SUCCEEDED(res))
{
res = IWICBitmapDecoder_Initialize(decoder, pIStream, metadataOptions);
if (FAILED(res))
{
IWICBitmapDecoder_Release(decoder);
decoder = NULL;
}
}
}
IWICBitmapDecoderInfo_Release(decoderinfo);
}
IUnknown_Release(unkdecoderinfo);
}
else
break;
}
IEnumUnknown_Release(enumdecoders);
return decoder;
}
static HRESULT WINAPI ImagingFactory_CreateDecoderFromStream(
IWICImagingFactory *iface, IStream *pIStream, const GUID *pguidVendor,
WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
{
static int fixme=0;
IEnumUnknown *enumdecoders;
IUnknown *unkdecoderinfo;
IWICBitmapDecoderInfo *decoderinfo;
IWICBitmapDecoder *decoder=NULL;
HRESULT res=S_OK;
ULONG num_fetched;
BOOL matches;
TRACE("(%p,%p,%s,%u,%p)\n", iface, pIStream, debugstr_guid(pguidVendor),
metadataOptions, ppIDecoder);
if (pguidVendor && !fixme++)
FIXME("ignoring vendor GUID\n");
res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
if (FAILED(res)) return res;
while (!decoder)
{
res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
if (res == S_OK)
{
res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
if (SUCCEEDED(res))
{
res = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, pIStream, &matches);
if (SUCCEEDED(res) && matches)
{
res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
/* FIXME: should use QueryCapability to choose a decoder */
if (SUCCEEDED(res))
{
res = IWICBitmapDecoder_Initialize(decoder, pIStream, metadataOptions);
if (FAILED(res))
{
IWICBitmapDecoder_Release(decoder);
decoder = NULL;
}
}
}
IWICBitmapDecoderInfo_Release(decoderinfo);
}
IUnknown_Release(unkdecoderinfo);
}
else
break;
}
IEnumUnknown_Release(enumdecoders);
if (decoder)
{
*ppIDecoder = decoder;
return S_OK;
}
else
{
if (WARN_ON(wincodecs))
{
LARGE_INTEGER seek;
BYTE data[4];
ULONG bytesread;
WARN("failed to load from a stream\n");
seek.QuadPart = 0;
res = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
if (SUCCEEDED(res))
res = IStream_Read(pIStream, data, 4, &bytesread);
if (SUCCEEDED(res))
WARN("first %i bytes of stream=%x %x %x %x\n", bytesread, data[0], data[1], data[2], data[3]);
}
*ppIDecoder = NULL;
return WINCODEC_ERR_COMPONENTNOTFOUND;
}
}
static HRESULT WINAPI ComponentFactory_CreateMetadataReaderFromContainer(IWICComponentFactory *iface,
REFGUID format, const GUID *vendor, DWORD options, IStream *stream, IWICMetadataReader **reader)
{
HRESULT hr;
IEnumUnknown *enumreaders;
IUnknown *unkreaderinfo;
IWICMetadataReaderInfo *readerinfo;
IWICPersistStream *wicpersiststream;
ULONG num_fetched;
GUID decoder_vendor;
BOOL matches;
LARGE_INTEGER zero;
TRACE("%p,%s,%s,%x,%p,%p\n", iface, debugstr_guid(format), debugstr_guid(vendor),
options, stream, reader);
if (!format || !stream || !reader)
return E_INVALIDARG;
zero.QuadPart = 0;
hr = CreateComponentEnumerator(WICMetadataReader, WICComponentEnumerateDefault, &enumreaders);
if (FAILED(hr)) return hr;
*reader = NULL;
start:
while (!*reader)
{
hr = IEnumUnknown_Next(enumreaders, 1, &unkreaderinfo, &num_fetched);
if (hr == S_OK)
{
hr = IUnknown_QueryInterface(unkreaderinfo, &IID_IWICMetadataReaderInfo, (void**)&readerinfo);
if (SUCCEEDED(hr))
{
if (vendor)
{
hr = IWICMetadataReaderInfo_GetVendorGUID(readerinfo, &decoder_vendor);
if (FAILED(hr) || !IsEqualIID(vendor, &decoder_vendor))
{
IWICMetadataReaderInfo_Release(readerinfo);
IUnknown_Release(unkreaderinfo);
continue;
}
}
hr = IWICMetadataReaderInfo_MatchesPattern(readerinfo, format, stream, &matches);
if (SUCCEEDED(hr) && matches)
{
hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
if (SUCCEEDED(hr))
hr = IWICMetadataReaderInfo_CreateInstance(readerinfo, reader);
if (SUCCEEDED(hr))
{
hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
if (SUCCEEDED(hr))
{
hr = IWICPersistStream_LoadEx(wicpersiststream,
stream, vendor, options & WICPersistOptionMask);
IWICPersistStream_Release(wicpersiststream);
}
if (FAILED(hr))
{
IWICMetadataReader_Release(*reader);
*reader = NULL;
}
}
}
IUnknown_Release(readerinfo);
}
IUnknown_Release(unkreaderinfo);
}
else
break;
}
if (!*reader && vendor)
{
vendor = NULL;
IEnumUnknown_Reset(enumreaders);
goto start;
}
IEnumUnknown_Release(enumreaders);
if (!*reader && !(options & WICMetadataCreationFailUnknown))
{
hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
if (SUCCEEDED(hr))
hr = UnknownMetadataReader_CreateInstance(&IID_IWICMetadataReader, (void**)reader);
if (SUCCEEDED(hr))
{
hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
if (SUCCEEDED(hr))
{
hr = IWICPersistStream_LoadEx(wicpersiststream, stream, NULL, options & WICPersistOptionMask);
IWICPersistStream_Release(wicpersiststream);
}
if (FAILED(hr))
{
IWICMetadataReader_Release(*reader);
*reader = NULL;
}
}
}
if (*reader)
return S_OK;
else
return WINCODEC_ERR_COMPONENTNOTFOUND;
}
