mshtml: Use ifaces instead of vtbl pointers in HTMLFrameBase.
[wine] / dlls / windowscodecs / info.c
index c3895da..a90e750 100644 (file)
 #include "wincodecs_private.h"
 
 #include "wine/debug.h"
+#include "wine/unicode.h"
+#include "wine/list.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
 
+static WCHAR const mimetypes_valuename[] = {'M','i','m','e','T','y','p','e','s',0};
+static WCHAR const pixelformats_keyname[] = {'P','i','x','e','l','F','o','r','m','a','t','s',0};
+
+static HRESULT ComponentInfo_GetStringValue(HKEY classkey, LPCWSTR value,
+    UINT buffer_size, WCHAR *buffer, UINT *actual_size)
+{
+    LONG ret;
+    DWORD cbdata=buffer_size * sizeof(WCHAR);
+
+    if (!actual_size)
+        return E_INVALIDARG;
+
+    ret = RegGetValueW(classkey, NULL, value, RRF_RT_REG_SZ|RRF_NOEXPAND, NULL,
+        buffer, &cbdata);
+
+    if (ret == 0 || ret == ERROR_MORE_DATA)
+        *actual_size = cbdata/sizeof(WCHAR);
+
+    if (!buffer && buffer_size != 0)
+        /* Yes, native returns the correct size in this case. */
+        return E_INVALIDARG;
+
+    if (ret == ERROR_MORE_DATA)
+        return WINCODEC_ERR_INSUFFICIENTBUFFER;
+
+    return HRESULT_FROM_WIN32(ret);
+}
+
 typedef struct {
-    const IWICBitmapDecoderInfoVtbl *lpIWICBitmapDecoderInfoVtbl;
+    IWICBitmapDecoderInfo IWICBitmapDecoderInfo_iface;
     LONG ref;
     HKEY classkey;
     CLSID clsid;
 } BitmapDecoderInfo;
 
+static inline BitmapDecoderInfo *impl_from_IWICBitmapDecoderInfo(IWICBitmapDecoderInfo *iface)
+{
+    return CONTAINING_RECORD(iface, BitmapDecoderInfo, IWICBitmapDecoderInfo_iface);
+}
+
 static HRESULT WINAPI BitmapDecoderInfo_QueryInterface(IWICBitmapDecoderInfo *iface, REFIID iid,
     void **ppv)
 {
-    BitmapDecoderInfo *This = (BitmapDecoderInfo*)iface;
+    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
     if (!ppv) return E_INVALIDARG;
@@ -68,7 +103,7 @@ static HRESULT WINAPI BitmapDecoderInfo_QueryInterface(IWICBitmapDecoderInfo *if
 
 static ULONG WINAPI BitmapDecoderInfo_AddRef(IWICBitmapDecoderInfo *iface)
 {
-    BitmapDecoderInfo *This = (BitmapDecoderInfo*)iface;
+    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
     ULONG ref = InterlockedIncrement(&This->ref);
 
     TRACE("(%p) refcount=%u\n", iface, ref);
@@ -78,7 +113,7 @@ static ULONG WINAPI BitmapDecoderInfo_AddRef(IWICBitmapDecoderInfo *iface)
 
 static ULONG WINAPI BitmapDecoderInfo_Release(IWICBitmapDecoderInfo *iface)
 {
-    BitmapDecoderInfo *This = (BitmapDecoderInfo*)iface;
+    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
     ULONG ref = InterlockedDecrement(&This->ref);
 
     TRACE("(%p) refcount=%u\n", iface, ref);
@@ -102,8 +137,15 @@ static HRESULT WINAPI BitmapDecoderInfo_GetComponentType(IWICBitmapDecoderInfo *
 
 static HRESULT WINAPI BitmapDecoderInfo_GetCLSID(IWICBitmapDecoderInfo *iface, CLSID *pclsid)
 {
-    FIXME("(%p,%p): stub\n", iface, pclsid);
-    return E_NOTIMPL;
+    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
+    TRACE("(%p,%p)\n", iface, pclsid);
+
+    if (!pclsid)
+        return E_INVALIDARG;
+
+    memcpy(pclsid, &This->clsid, sizeof(CLSID));
+
+    return S_OK;
 }
 
 static HRESULT WINAPI BitmapDecoderInfo_GetSigningStatus(IWICBitmapDecoderInfo *iface, DWORD *pStatus)
@@ -184,8 +226,12 @@ static HRESULT WINAPI BitmapDecoderInfo_GetDeviceModels(IWICBitmapDecoderInfo *i
 static HRESULT WINAPI BitmapDecoderInfo_GetMimeTypes(IWICBitmapDecoderInfo *iface,
     UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
 {
-    FIXME("(%p,%u,%p,%p): stub\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
-    return E_NOTIMPL;
+    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
+
+    TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
+
+    return ComponentInfo_GetStringValue(This->classkey, mimetypes_valuename,
+        cchMimeTypes, wzMimeTypes, pcchActual);
 }
 
 static HRESULT WINAPI BitmapDecoderInfo_GetFileExtensions(IWICBitmapDecoderInfo *iface,
@@ -233,22 +279,184 @@ static HRESULT WINAPI BitmapDecoderInfo_MatchesMimeType(IWICBitmapDecoderInfo *i
 static HRESULT WINAPI BitmapDecoderInfo_GetPatterns(IWICBitmapDecoderInfo *iface,
     UINT cbSizePatterns, WICBitmapPattern *pPatterns, UINT *pcPatterns, UINT *pcbPatternsActual)
 {
-    FIXME("(%p,%i,%p,%p,%p): stub\n", iface, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual);
-    return E_NOTIMPL;
+    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
+    UINT pattern_count=0, patterns_size=0;
+    WCHAR subkeyname[11];
+    LONG res;
+    HKEY patternskey, patternkey;
+    static const WCHAR uintformatW[] = {'%','u',0};
+    static const WCHAR patternsW[] = {'P','a','t','t','e','r','n','s',0};
+    static const WCHAR positionW[] = {'P','o','s','i','t','i','o','n',0};
+    static const WCHAR lengthW[] = {'L','e','n','g','t','h',0};
+    static const WCHAR patternW[] = {'P','a','t','t','e','r','n',0};
+    static const WCHAR maskW[] = {'M','a','s','k',0};
+    static const WCHAR endofstreamW[] = {'E','n','d','O','f','S','t','r','e','a','m',0};
+    HRESULT hr=S_OK;
+    UINT i;
+    BYTE *bPatterns=(BYTE*)pPatterns;
+    DWORD length, valuesize;
+
+    TRACE("(%p,%i,%p,%p,%p)\n", iface, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual);
+
+    res = RegOpenKeyExW(This->classkey, patternsW, 0, KEY_READ, &patternskey);
+    if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
+
+    res = RegQueryInfoKeyW(patternskey, NULL, NULL, NULL, &pattern_count, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+    if (res == ERROR_SUCCESS)
+    {
+        patterns_size = pattern_count * sizeof(WICBitmapPattern);
+
+        for (i=0; i<pattern_count; i++)
+        {
+            snprintfW(subkeyname, 11, uintformatW, i);
+            res = RegOpenKeyExW(patternskey, subkeyname, 0, KEY_READ, &patternkey);
+            if (res == ERROR_SUCCESS)
+            {
+                valuesize = sizeof(ULONG);
+                res = RegGetValueW(patternkey, NULL, lengthW, RRF_RT_DWORD, NULL,
+                    &length, &valuesize);
+                patterns_size += length*2;
+
+                if ((cbSizePatterns >= patterns_size) && (res == ERROR_SUCCESS))
+                {
+                    pPatterns[i].Length = length;
+
+                    pPatterns[i].EndOfStream = 0;
+                    valuesize = sizeof(BOOL);
+                    RegGetValueW(patternkey, NULL, endofstreamW, RRF_RT_DWORD, NULL,
+                        &pPatterns[i].EndOfStream, &valuesize);
+
+                    pPatterns[i].Position.QuadPart = 0;
+                    valuesize = sizeof(ULARGE_INTEGER);
+                    res = RegGetValueW(patternkey, NULL, positionW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
+                        &pPatterns[i].Position, &valuesize);
+
+                    if (res == ERROR_SUCCESS)
+                    {
+                        pPatterns[i].Pattern = bPatterns+patterns_size-length*2;
+                        valuesize = length;
+                        res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL,
+                            pPatterns[i].Pattern, &valuesize);
+                    }
+
+                    if (res == ERROR_SUCCESS)
+                    {
+                        pPatterns[i].Mask = bPatterns+patterns_size-length;
+                        valuesize = length;
+                        res = RegGetValueW(patternkey, NULL, maskW, RRF_RT_REG_BINARY, NULL,
+                            pPatterns[i].Mask, &valuesize);
+                    }
+                }
+
+                RegCloseKey(patternkey);
+            }
+            if (res != ERROR_SUCCESS)
+            {
+                hr = HRESULT_FROM_WIN32(res);
+                break;
+            }
+        }
+    }
+    else hr = HRESULT_FROM_WIN32(res);
+
+    RegCloseKey(patternskey);
+
+    if (hr == S_OK)
+    {
+        *pcPatterns = pattern_count;
+        *pcbPatternsActual = patterns_size;
+        if (pPatterns && cbSizePatterns < patterns_size)
+            hr = WINCODEC_ERR_INSUFFICIENTBUFFER;
+    }
+
+    return hr;
 }
 
 static HRESULT WINAPI BitmapDecoderInfo_MatchesPattern(IWICBitmapDecoderInfo *iface,
     IStream *pIStream, BOOL *pfMatches)
 {
-    FIXME("(%p,%p,%p): stub\n", iface, pIStream, pfMatches);
-    return E_NOTIMPL;
+    WICBitmapPattern *patterns;
+    UINT pattern_count=0, patterns_size=0;
+    HRESULT hr;
+    int i, pos;
+    BYTE *data=NULL;
+    ULONG datasize=0;
+    ULONG bytesread;
+    LARGE_INTEGER seekpos;
+
+    TRACE("(%p,%p,%p)\n", iface, pIStream, pfMatches);
+
+    hr = BitmapDecoderInfo_GetPatterns(iface, 0, NULL, &pattern_count, &patterns_size);
+    if (FAILED(hr)) return hr;
+
+    patterns = HeapAlloc(GetProcessHeap(), 0, patterns_size);
+    if (!patterns) return E_OUTOFMEMORY;
+
+    hr = BitmapDecoderInfo_GetPatterns(iface, patterns_size, patterns, &pattern_count, &patterns_size);
+    if (FAILED(hr)) goto end;
+
+    for (i=0; i<pattern_count; i++)
+    {
+        if (datasize < patterns[i].Length)
+        {
+            HeapFree(GetProcessHeap(), 0, data);
+            datasize = patterns[i].Length;
+            data = HeapAlloc(GetProcessHeap(), 0, patterns[i].Length);
+            if (!data)
+            {
+                hr = E_OUTOFMEMORY;
+                break;
+            }
+        }
+
+        if (patterns[i].EndOfStream)
+            seekpos.QuadPart = -patterns[i].Position.QuadPart;
+        else
+            seekpos.QuadPart = patterns[i].Position.QuadPart;
+        hr = IStream_Seek(pIStream, seekpos, patterns[i].EndOfStream ? STREAM_SEEK_END : STREAM_SEEK_SET, NULL);
+        if (hr == STG_E_INVALIDFUNCTION) continue; /* before start of stream */
+        if (FAILED(hr)) break;
+
+        hr = IStream_Read(pIStream, data, patterns[i].Length, &bytesread);
+        if (hr == S_FALSE || (hr == S_OK && bytesread != patterns[i].Length)) /* past end of stream */
+            continue;
+        if (FAILED(hr)) break;
+
+        for (pos=0; pos<patterns[i].Length; pos++)
+        {
+            if ((data[pos] & patterns[i].Mask[pos]) != patterns[i].Pattern[pos])
+                break;
+        }
+        if (pos == patterns[i].Length) /* matches pattern */
+        {
+            hr = S_OK;
+            *pfMatches = TRUE;
+            break;
+        }
+    }
+
+    if (i == pattern_count) /* does not match any pattern */
+    {
+        hr = S_OK;
+        *pfMatches = FALSE;
+    }
+
+end:
+    HeapFree(GetProcessHeap(), 0, patterns);
+    HeapFree(GetProcessHeap(), 0, data);
+
+    return hr;
 }
 
 static HRESULT WINAPI BitmapDecoderInfo_CreateInstance(IWICBitmapDecoderInfo *iface,
     IWICBitmapDecoder **ppIBitmapDecoder)
 {
-    FIXME("(%p,%p): stub\n", iface, ppIBitmapDecoder);
-    return E_NOTIMPL;
+    BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
+
+    TRACE("(%p,%p)\n", iface, ppIBitmapDecoder);
+
+    return CoCreateInstance(&This->clsid, NULL, CLSCTX_INPROC_SERVER,
+        &IID_IWICBitmapDecoder, (void**)ppIBitmapDecoder);
 }
 
 static const IWICBitmapDecoderInfoVtbl BitmapDecoderInfo_Vtbl = {
@@ -291,7 +499,7 @@ static HRESULT BitmapDecoderInfo_Constructor(HKEY classkey, REFCLSID clsid, IWIC
         return E_OUTOFMEMORY;
     }
 
-    This->lpIWICBitmapDecoderInfoVtbl = &BitmapDecoderInfo_Vtbl;
+    This->IWICBitmapDecoderInfo_iface.lpVtbl = &BitmapDecoderInfo_Vtbl;
     This->ref = 1;
     This->classkey = classkey;
     memcpy(&This->clsid, clsid, sizeof(CLSID));
@@ -300,71 +508,918 @@ static HRESULT BitmapDecoderInfo_Constructor(HKEY classkey, REFCLSID clsid, IWIC
     return S_OK;
 }
 
-static WCHAR const clsid_keyname[] = {'C','L','S','I','D',0};
-static WCHAR const instance_keyname[] = {'I','n','s','t','a','n','c','e',0};
-
-struct category {
-    WICComponentType type;
-    const GUID *catid;
-    HRESULT (*constructor)(HKEY,REFCLSID,IWICComponentInfo**);
-};
+typedef struct {
+    IWICBitmapEncoderInfo IWICBitmapEncoderInfo_iface;
+    LONG ref;
+    HKEY classkey;
+    CLSID clsid;
+} BitmapEncoderInfo;
 
-static const struct category categories[] = {
-    {WICDecoder, &CATID_WICBitmapDecoders, BitmapDecoderInfo_Constructor},
-    {0}
-};
+static inline BitmapEncoderInfo *impl_from_IWICBitmapEncoderInfo(IWICBitmapEncoderInfo *iface)
+{
+    return CONTAINING_RECORD(iface, BitmapEncoderInfo, IWICBitmapEncoderInfo_iface);
+}
 
-HRESULT CreateComponentInfo(REFCLSID clsid, IWICComponentInfo **ppIInfo)
+static HRESULT WINAPI BitmapEncoderInfo_QueryInterface(IWICBitmapEncoderInfo *iface, REFIID iid,
+    void **ppv)
 {
-    HKEY clsidkey;
-    HKEY classkey;
-    HKEY catidkey;
-    HKEY instancekey;
-    WCHAR guidstring[39];
-    LONG res;
-    const struct category *category;
-    int found=0;
-    HRESULT hr;
+    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
+    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 
-    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, KEY_READ, &clsidkey);
-    if (res != ERROR_SUCCESS)
-        return HRESULT_FROM_WIN32(res);
+    if (!ppv) return E_INVALIDARG;
 
-    for (category=categories; category->type; category++)
+    if (IsEqualIID(&IID_IUnknown, iid) ||
+        IsEqualIID(&IID_IWICComponentInfo, iid) ||
+        IsEqualIID(&IID_IWICBitmapCodecInfo, iid) ||
+        IsEqualIID(&IID_IWICBitmapEncoderInfo ,iid))
     {
-        StringFromGUID2(category->catid, guidstring, 39);
-        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
-        if (res == ERROR_SUCCESS)
-        {
-            res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
-            if (res == ERROR_SUCCESS)
-            {
-                StringFromGUID2(clsid, guidstring, 39);
-                res = RegOpenKeyExW(instancekey, guidstring, 0, KEY_READ, &classkey);
-                if (res == ERROR_SUCCESS)
-                {
-                    RegCloseKey(classkey);
-                    found = 1;
-                }
-                RegCloseKey(instancekey);
-            }
-            RegCloseKey(catidkey);
-        }
-        if (found) break;
+        *ppv = This;
+    }
+    else
+    {
+        *ppv = NULL;
+        return E_NOINTERFACE;
     }
 
-    if (found)
+    IUnknown_AddRef((IUnknown*)*ppv);
+    return S_OK;
+}
+
+static ULONG WINAPI BitmapEncoderInfo_AddRef(IWICBitmapEncoderInfo *iface)
+{
+    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI BitmapEncoderInfo_Release(IWICBitmapEncoderInfo *iface)
+{
+    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    if (ref == 0)
     {
-        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &classkey);
-        if (res == ERROR_SUCCESS)
-            hr = category->constructor(classkey, clsid, ppIInfo);
-        else
-            hr = HRESULT_FROM_WIN32(res);
+        RegCloseKey(This->classkey);
+        HeapFree(GetProcessHeap(), 0, This);
     }
-    else
-        hr = E_FAIL;
 
-    RegCloseKey(clsidkey);
+    return ref;
+}
 
-    return hr;
+static HRESULT WINAPI BitmapEncoderInfo_GetComponentType(IWICBitmapEncoderInfo *iface,
+    WICComponentType *pType)
+{
+    TRACE("(%p,%p)\n", iface, pType);
+    *pType = WICEncoder;
+    return S_OK;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetCLSID(IWICBitmapEncoderInfo *iface, CLSID *pclsid)
+{
+    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
+    TRACE("(%p,%p)\n", iface, pclsid);
+
+    if (!pclsid)
+        return E_INVALIDARG;
+
+    memcpy(pclsid, &This->clsid, sizeof(CLSID));
+
+    return S_OK;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetSigningStatus(IWICBitmapEncoderInfo *iface, DWORD *pStatus)
+{
+    FIXME("(%p,%p): stub\n", iface, pStatus);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetAuthor(IWICBitmapEncoderInfo *iface, UINT cchAuthor,
+    WCHAR *wzAuthor, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchAuthor, wzAuthor, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetVendorGUID(IWICBitmapEncoderInfo *iface, GUID *pguidVendor)
+{
+    FIXME("(%p,%p): stub\n", iface, pguidVendor);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetVersion(IWICBitmapEncoderInfo *iface, UINT cchVersion,
+    WCHAR *wzVersion, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchVersion, wzVersion, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetSpecVersion(IWICBitmapEncoderInfo *iface, UINT cchSpecVersion,
+    WCHAR *wzSpecVersion, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetFriendlyName(IWICBitmapEncoderInfo *iface, UINT cchFriendlyName,
+    WCHAR *wzFriendlyName, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetContainerFormat(IWICBitmapEncoderInfo *iface,
+    GUID *pguidContainerFormat)
+{
+    FIXME("(%p,%p): stub\n", iface, pguidContainerFormat);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetPixelFormats(IWICBitmapEncoderInfo *iface,
+    UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cFormats, pguidPixelFormats, pcActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetColorManagementVersion(IWICBitmapEncoderInfo *iface,
+    UINT cchColorManagementVersion, WCHAR *wzColorManagementVersion, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchColorManagementVersion, wzColorManagementVersion, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetDeviceManufacturer(IWICBitmapEncoderInfo *iface,
+    UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetDeviceModels(IWICBitmapEncoderInfo *iface,
+    UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceModels, wzDeviceModels, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetMimeTypes(IWICBitmapEncoderInfo *iface,
+    UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
+{
+    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
+
+    TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
+
+    return ComponentInfo_GetStringValue(This->classkey, mimetypes_valuename,
+        cchMimeTypes, wzMimeTypes, pcchActual);
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_GetFileExtensions(IWICBitmapEncoderInfo *iface,
+    UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchFileExtensions, wzFileExtensions, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_DoesSupportAnimation(IWICBitmapEncoderInfo *iface,
+    BOOL *pfSupportAnimation)
+{
+    FIXME("(%p,%p): stub\n", iface, pfSupportAnimation);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_DoesSupportChromaKey(IWICBitmapEncoderInfo *iface,
+    BOOL *pfSupportChromaKey)
+{
+    FIXME("(%p,%p): stub\n", iface, pfSupportChromaKey);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_DoesSupportLossless(IWICBitmapEncoderInfo *iface,
+    BOOL *pfSupportLossless)
+{
+    FIXME("(%p,%p): stub\n", iface, pfSupportLossless);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_DoesSupportMultiframe(IWICBitmapEncoderInfo *iface,
+    BOOL *pfSupportMultiframe)
+{
+    FIXME("(%p,%p): stub\n", iface, pfSupportMultiframe);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_MatchesMimeType(IWICBitmapEncoderInfo *iface,
+    LPCWSTR wzMimeType, BOOL *pfMatches)
+{
+    FIXME("(%p,%s,%p): stub\n", iface, debugstr_w(wzMimeType), pfMatches);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI BitmapEncoderInfo_CreateInstance(IWICBitmapEncoderInfo *iface,
+    IWICBitmapEncoder **ppIBitmapEncoder)
+{
+    BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
+
+    TRACE("(%p,%p)\n", iface, ppIBitmapEncoder);
+
+    return CoCreateInstance(&This->clsid, NULL, CLSCTX_INPROC_SERVER,
+        &IID_IWICBitmapEncoder, (void**)ppIBitmapEncoder);
+}
+
+static const IWICBitmapEncoderInfoVtbl BitmapEncoderInfo_Vtbl = {
+    BitmapEncoderInfo_QueryInterface,
+    BitmapEncoderInfo_AddRef,
+    BitmapEncoderInfo_Release,
+    BitmapEncoderInfo_GetComponentType,
+    BitmapEncoderInfo_GetCLSID,
+    BitmapEncoderInfo_GetSigningStatus,
+    BitmapEncoderInfo_GetAuthor,
+    BitmapEncoderInfo_GetVendorGUID,
+    BitmapEncoderInfo_GetVersion,
+    BitmapEncoderInfo_GetSpecVersion,
+    BitmapEncoderInfo_GetFriendlyName,
+    BitmapEncoderInfo_GetContainerFormat,
+    BitmapEncoderInfo_GetPixelFormats,
+    BitmapEncoderInfo_GetColorManagementVersion,
+    BitmapEncoderInfo_GetDeviceManufacturer,
+    BitmapEncoderInfo_GetDeviceModels,
+    BitmapEncoderInfo_GetMimeTypes,
+    BitmapEncoderInfo_GetFileExtensions,
+    BitmapEncoderInfo_DoesSupportAnimation,
+    BitmapEncoderInfo_DoesSupportChromaKey,
+    BitmapEncoderInfo_DoesSupportLossless,
+    BitmapEncoderInfo_DoesSupportMultiframe,
+    BitmapEncoderInfo_MatchesMimeType,
+    BitmapEncoderInfo_CreateInstance
+};
+
+static HRESULT BitmapEncoderInfo_Constructor(HKEY classkey, REFCLSID clsid, IWICComponentInfo **ppIInfo)
+{
+    BitmapEncoderInfo *This;
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapEncoderInfo));
+    if (!This)
+    {
+        RegCloseKey(classkey);
+        return E_OUTOFMEMORY;
+    }
+
+    This->IWICBitmapEncoderInfo_iface.lpVtbl = &BitmapEncoderInfo_Vtbl;
+    This->ref = 1;
+    This->classkey = classkey;
+    memcpy(&This->clsid, clsid, sizeof(CLSID));
+
+    *ppIInfo = (IWICComponentInfo*)This;
+    return S_OK;
+}
+
+typedef struct {
+    IWICFormatConverterInfo IWICFormatConverterInfo_iface;
+    LONG ref;
+    HKEY classkey;
+    CLSID clsid;
+} FormatConverterInfo;
+
+static inline FormatConverterInfo *impl_from_IWICFormatConverterInfo(IWICFormatConverterInfo *iface)
+{
+    return CONTAINING_RECORD(iface, FormatConverterInfo, IWICFormatConverterInfo_iface);
+}
+
+static HRESULT WINAPI FormatConverterInfo_QueryInterface(IWICFormatConverterInfo *iface, REFIID iid,
+    void **ppv)
+{
+    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
+    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+    if (!ppv) return E_INVALIDARG;
+
+    if (IsEqualIID(&IID_IUnknown, iid) ||
+        IsEqualIID(&IID_IWICComponentInfo, iid) ||
+        IsEqualIID(&IID_IWICFormatConverterInfo ,iid))
+    {
+        *ppv = This;
+    }
+    else
+    {
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown*)*ppv);
+    return S_OK;
+}
+
+static ULONG WINAPI FormatConverterInfo_AddRef(IWICFormatConverterInfo *iface)
+{
+    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI FormatConverterInfo_Release(IWICFormatConverterInfo *iface)
+{
+    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    if (ref == 0)
+    {
+        RegCloseKey(This->classkey);
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetComponentType(IWICFormatConverterInfo *iface,
+    WICComponentType *pType)
+{
+    TRACE("(%p,%p)\n", iface, pType);
+    *pType = WICPixelFormatConverter;
+    return S_OK;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetCLSID(IWICFormatConverterInfo *iface, CLSID *pclsid)
+{
+    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
+    TRACE("(%p,%p)\n", iface, pclsid);
+
+    if (!pclsid)
+        return E_INVALIDARG;
+
+    memcpy(pclsid, &This->clsid, sizeof(CLSID));
+
+    return S_OK;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetSigningStatus(IWICFormatConverterInfo *iface, DWORD *pStatus)
+{
+    FIXME("(%p,%p): stub\n", iface, pStatus);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetAuthor(IWICFormatConverterInfo *iface, UINT cchAuthor,
+    WCHAR *wzAuthor, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchAuthor, wzAuthor, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetVendorGUID(IWICFormatConverterInfo *iface, GUID *pguidVendor)
+{
+    FIXME("(%p,%p): stub\n", iface, pguidVendor);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetVersion(IWICFormatConverterInfo *iface, UINT cchVersion,
+    WCHAR *wzVersion, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchVersion, wzVersion, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetSpecVersion(IWICFormatConverterInfo *iface, UINT cchSpecVersion,
+    WCHAR *wzSpecVersion, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetFriendlyName(IWICFormatConverterInfo *iface, UINT cchFriendlyName,
+    WCHAR *wzFriendlyName, UINT *pcchActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI FormatConverterInfo_GetPixelFormats(IWICFormatConverterInfo *iface,
+    UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
+{
+    FIXME("(%p,%u,%p,%p): stub\n", iface, cFormats, pguidPixelFormats, pcActual);
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI FormatConverterInfo_CreateInstance(IWICFormatConverterInfo *iface,
+    IWICFormatConverter **ppIFormatConverter)
+{
+    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
+
+    TRACE("(%p,%p)\n", iface, ppIFormatConverter);
+
+    return CoCreateInstance(&This->clsid, NULL, CLSCTX_INPROC_SERVER,
+        &IID_IWICFormatConverter, (void**)ppIFormatConverter);
+}
+
+static BOOL ConverterSupportsFormat(IWICFormatConverterInfo *iface, const WCHAR *formatguid)
+{
+    LONG res;
+    FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
+    HKEY formats_key, guid_key;
+
+    /* Avoid testing using IWICFormatConverter_GetPixelFormats because that
+        would be O(n). A registry test should do better. */
+
+    res = RegOpenKeyExW(This->classkey, pixelformats_keyname, 0, KEY_READ, &formats_key);
+    if (res != ERROR_SUCCESS) return FALSE;
+
+    res = RegOpenKeyExW(formats_key, formatguid, 0, KEY_READ, &guid_key);
+    if (res == ERROR_SUCCESS) RegCloseKey(guid_key);
+
+    RegCloseKey(formats_key);
+
+    return (res == ERROR_SUCCESS);
+}
+
+static const IWICFormatConverterInfoVtbl FormatConverterInfo_Vtbl = {
+    FormatConverterInfo_QueryInterface,
+    FormatConverterInfo_AddRef,
+    FormatConverterInfo_Release,
+    FormatConverterInfo_GetComponentType,
+    FormatConverterInfo_GetCLSID,
+    FormatConverterInfo_GetSigningStatus,
+    FormatConverterInfo_GetAuthor,
+    FormatConverterInfo_GetVendorGUID,
+    FormatConverterInfo_GetVersion,
+    FormatConverterInfo_GetSpecVersion,
+    FormatConverterInfo_GetFriendlyName,
+    FormatConverterInfo_GetPixelFormats,
+    FormatConverterInfo_CreateInstance
+};
+
+static HRESULT FormatConverterInfo_Constructor(HKEY classkey, REFCLSID clsid, IWICComponentInfo **ppIInfo)
+{
+    FormatConverterInfo *This;
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof(FormatConverterInfo));
+    if (!This)
+    {
+        RegCloseKey(classkey);
+        return E_OUTOFMEMORY;
+    }
+
+    This->IWICFormatConverterInfo_iface.lpVtbl = &FormatConverterInfo_Vtbl;
+    This->ref = 1;
+    This->classkey = classkey;
+    memcpy(&This->clsid, clsid, sizeof(CLSID));
+
+    *ppIInfo = (IWICComponentInfo*)This;
+    return S_OK;
+}
+
+static WCHAR const clsid_keyname[] = {'C','L','S','I','D',0};
+static WCHAR const instance_keyname[] = {'I','n','s','t','a','n','c','e',0};
+
+struct category {
+    WICComponentType type;
+    const GUID *catid;
+    HRESULT (*constructor)(HKEY,REFCLSID,IWICComponentInfo**);
+};
+
+static const struct category categories[] = {
+    {WICDecoder, &CATID_WICBitmapDecoders, BitmapDecoderInfo_Constructor},
+    {WICEncoder, &CATID_WICBitmapEncoders, BitmapEncoderInfo_Constructor},
+    {WICPixelFormatConverter, &CATID_WICFormatConverters, FormatConverterInfo_Constructor},
+    {0}
+};
+
+HRESULT CreateComponentInfo(REFCLSID clsid, IWICComponentInfo **ppIInfo)
+{
+    HKEY clsidkey;
+    HKEY classkey;
+    HKEY catidkey;
+    HKEY instancekey;
+    WCHAR guidstring[39];
+    LONG res;
+    const struct category *category;
+    int found=0;
+    HRESULT hr;
+
+    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, KEY_READ, &clsidkey);
+    if (res != ERROR_SUCCESS)
+        return HRESULT_FROM_WIN32(res);
+
+    for (category=categories; category->type; category++)
+    {
+        StringFromGUID2(category->catid, guidstring, 39);
+        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
+        if (res == ERROR_SUCCESS)
+        {
+            res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
+            if (res == ERROR_SUCCESS)
+            {
+                StringFromGUID2(clsid, guidstring, 39);
+                res = RegOpenKeyExW(instancekey, guidstring, 0, KEY_READ, &classkey);
+                if (res == ERROR_SUCCESS)
+                {
+                    RegCloseKey(classkey);
+                    found = 1;
+                }
+                RegCloseKey(instancekey);
+            }
+            RegCloseKey(catidkey);
+        }
+        if (found) break;
+    }
+
+    if (found)
+    {
+        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &classkey);
+        if (res == ERROR_SUCCESS)
+            hr = category->constructor(classkey, clsid, ppIInfo);
+        else
+            hr = HRESULT_FROM_WIN32(res);
+    }
+    else
+        hr = E_FAIL;
+
+    RegCloseKey(clsidkey);
+
+    return hr;
+}
+
+typedef struct {
+    IEnumUnknown IEnumUnknown_iface;
+    LONG ref;
+    struct list objects;
+    struct list *cursor;
+    CRITICAL_SECTION lock; /* Must be held when reading or writing cursor */
+} ComponentEnum;
+
+static inline ComponentEnum *impl_from_IEnumUnknown(IEnumUnknown *iface)
+{
+    return CONTAINING_RECORD(iface, ComponentEnum, IEnumUnknown_iface);
+}
+
+typedef struct {
+    struct list entry;
+    IUnknown *unk;
+} ComponentEnumItem;
+
+static const IEnumUnknownVtbl ComponentEnumVtbl;
+
+static HRESULT WINAPI ComponentEnum_QueryInterface(IEnumUnknown *iface, REFIID iid,
+    void **ppv)
+{
+    ComponentEnum *This = impl_from_IEnumUnknown(iface);
+    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+    if (!ppv) return E_INVALIDARG;
+
+    if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IEnumUnknown, iid))
+    {
+        *ppv = This;
+    }
+    else
+    {
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown*)*ppv);
+    return S_OK;
+}
+
+static ULONG WINAPI ComponentEnum_AddRef(IEnumUnknown *iface)
+{
+    ComponentEnum *This = impl_from_IEnumUnknown(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI ComponentEnum_Release(IEnumUnknown *iface)
+{
+    ComponentEnum *This = impl_from_IEnumUnknown(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+    ComponentEnumItem *cursor, *cursor2;
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    if (ref == 0)
+    {
+        LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &This->objects, ComponentEnumItem, entry)
+        {
+            IUnknown_Release(cursor->unk);
+            list_remove(&cursor->entry);
+            HeapFree(GetProcessHeap(), 0, cursor);
+        }
+        This->lock.DebugInfo->Spare[0] = 0;
+        DeleteCriticalSection(&This->lock);
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI ComponentEnum_Next(IEnumUnknown *iface, ULONG celt,
+    IUnknown **rgelt, ULONG *pceltFetched)
+{
+    ComponentEnum *This = impl_from_IEnumUnknown(iface);
+    int num_fetched=0;
+    ComponentEnumItem *item;
+    HRESULT hr=S_OK;
+
+    TRACE("(%p,%u,%p,%p)\n", iface, celt, rgelt, pceltFetched);
+
+    EnterCriticalSection(&This->lock);
+    while (num_fetched<celt)
+    {
+        if (!This->cursor)
+        {
+            hr = S_FALSE;
+            break;
+        }
+        item = LIST_ENTRY(This->cursor, ComponentEnumItem, entry);
+        IUnknown_AddRef(item->unk);
+        rgelt[num_fetched] = item->unk;
+        num_fetched++;
+        This->cursor = list_next(&This->objects, This->cursor);
+    }
+    LeaveCriticalSection(&This->lock);
+    if (pceltFetched)
+        *pceltFetched = num_fetched;
+    return hr;
+}
+
+static HRESULT WINAPI ComponentEnum_Skip(IEnumUnknown *iface, ULONG celt)
+{
+    ComponentEnum *This = impl_from_IEnumUnknown(iface);
+    int i;
+    HRESULT hr=S_OK;
+
+    TRACE("(%p,%u)\n", iface, celt);
+
+    EnterCriticalSection(&This->lock);
+    for (i=0; i<celt; i++)
+    {
+        if (!This->cursor)
+        {
+            hr = S_FALSE;
+            break;
+        }
+        This->cursor = list_next(&This->objects, This->cursor);
+    }
+    LeaveCriticalSection(&This->lock);
+    return hr;
+}
+
+static HRESULT WINAPI ComponentEnum_Reset(IEnumUnknown *iface)
+{
+    ComponentEnum *This = impl_from_IEnumUnknown(iface);
+
+    TRACE("(%p)\n", iface);
+
+    EnterCriticalSection(&This->lock);
+    This->cursor = list_head(&This->objects);
+    LeaveCriticalSection(&This->lock);
+    return S_OK;
+}
+
+static HRESULT WINAPI ComponentEnum_Clone(IEnumUnknown *iface, IEnumUnknown **ppenum)
+{
+    ComponentEnum *This = impl_from_IEnumUnknown(iface);
+    ComponentEnum *new_enum;
+    ComponentEnumItem *old_item, *new_item;
+    HRESULT ret=S_OK;
+    struct list *old_cursor;
+
+    new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
+    if (!new_enum)
+    {
+        *ppenum = NULL;
+        return E_OUTOFMEMORY;
+    }
+
+    new_enum->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
+    new_enum->ref = 1;
+    new_enum->cursor = NULL;
+    list_init(&new_enum->objects);
+    InitializeCriticalSection(&new_enum->lock);
+    new_enum->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
+
+    EnterCriticalSection(&This->lock);
+    old_cursor = This->cursor;
+    LeaveCriticalSection(&This->lock);
+
+    LIST_FOR_EACH_ENTRY(old_item, &This->objects, ComponentEnumItem, entry)
+    {
+        new_item = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnumItem));
+        if (!new_item)
+        {
+            ret = E_OUTOFMEMORY;
+            break;
+        }
+        new_item->unk = old_item->unk;
+        list_add_tail(&new_enum->objects, &new_item->entry);
+        IUnknown_AddRef(new_item->unk);
+        if (&old_item->entry == old_cursor) new_enum->cursor = &new_item->entry;
+    }
+
+    if (FAILED(ret))
+    {
+        IUnknown_Release((IUnknown*)new_enum);
+        *ppenum = NULL;
+    }
+    else
+        *ppenum = (IEnumUnknown*)new_enum;
+
+    return ret;
+}
+
+static const IEnumUnknownVtbl ComponentEnumVtbl = {
+    ComponentEnum_QueryInterface,
+    ComponentEnum_AddRef,
+    ComponentEnum_Release,
+    ComponentEnum_Next,
+    ComponentEnum_Skip,
+    ComponentEnum_Reset,
+    ComponentEnum_Clone
+};
+
+HRESULT CreateComponentEnumerator(DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
+{
+    ComponentEnum *This;
+    ComponentEnumItem *item;
+    const struct category *category;
+    HKEY clsidkey, catidkey, instancekey;
+    WCHAR guidstring[39];
+    LONG res;
+    int i;
+    HRESULT hr=S_OK;
+    CLSID clsid;
+
+    if (options) FIXME("ignoring flags %x\n", options);
+
+    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, KEY_READ, &clsidkey);
+    if (res != ERROR_SUCCESS)
+        return HRESULT_FROM_WIN32(res);
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
+    if (!This)
+    {
+        RegCloseKey(clsidkey);
+        return E_OUTOFMEMORY;
+    }
+
+    This->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
+    This->ref = 1;
+    list_init(&This->objects);
+    InitializeCriticalSection(&This->lock);
+    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
+
+    for (category=categories; category->type && hr == S_OK; category++)
+    {
+        if ((category->type & componentTypes) == 0) continue;
+        StringFromGUID2(category->catid, guidstring, 39);
+        res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
+        if (res == ERROR_SUCCESS)
+        {
+            res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
+            if (res == ERROR_SUCCESS)
+            {
+                i=0;
+                for (;;i++)
+                {
+                    DWORD guidstring_size = 39;
+                    res = RegEnumKeyExW(instancekey, i, guidstring, &guidstring_size, NULL, NULL, NULL, NULL);
+                    if (res != ERROR_SUCCESS) break;
+
+                    item = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnumItem));
+                    if (!item) { hr = E_OUTOFMEMORY; break; }
+
+                    hr = CLSIDFromString(guidstring, &clsid);
+                    if (SUCCEEDED(hr))
+                    {
+                        hr = CreateComponentInfo(&clsid, (IWICComponentInfo**)&item->unk);
+                        if (SUCCEEDED(hr))
+                            list_add_tail(&This->objects, &item->entry);
+                    }
+
+                    if (FAILED(hr))
+                    {
+                        HeapFree(GetProcessHeap(), 0, item);
+                        hr = S_OK;
+                    }
+                }
+                RegCloseKey(instancekey);
+            }
+            RegCloseKey(catidkey);
+        }
+        if (res != ERROR_SUCCESS && res != ERROR_NO_MORE_ITEMS)
+            hr = HRESULT_FROM_WIN32(res);
+    }
+    RegCloseKey(clsidkey);
+
+    if (SUCCEEDED(hr))
+    {
+        IEnumUnknown_Reset((IEnumUnknown*)This);
+        *ppIEnumUnknown = (IEnumUnknown*)This;
+    }
+    else
+    {
+        *ppIEnumUnknown = NULL;
+        IUnknown_Release((IUnknown*)This);
+    }
+
+    return hr;
+}
+
+HRESULT WINAPI WICConvertBitmapSource(REFWICPixelFormatGUID dstFormat, IWICBitmapSource *pISrc, IWICBitmapSource **ppIDst)
+{
+    HRESULT res;
+    IEnumUnknown *enumconverters;
+    IUnknown *unkconverterinfo;
+    IWICFormatConverterInfo *converterinfo=NULL;
+    IWICFormatConverter *converter=NULL;
+    GUID srcFormat;
+    WCHAR srcformatstr[39], dstformatstr[39];
+    BOOL canconvert;
+    ULONG num_fetched;
+
+    res = IWICBitmapSource_GetPixelFormat(pISrc, &srcFormat);
+    if (FAILED(res)) return res;
+
+    if (IsEqualGUID(&srcFormat, dstFormat))
+    {
+        IWICBitmapSource_AddRef(pISrc);
+        *ppIDst = pISrc;
+        return S_OK;
+    }
+
+    StringFromGUID2(&srcFormat, srcformatstr, 39);
+    StringFromGUID2(dstFormat, dstformatstr, 39);
+
+    res = CreateComponentEnumerator(WICPixelFormatConverter, 0, &enumconverters);
+    if (FAILED(res)) return res;
+
+    while (!converter)
+    {
+        res = IEnumUnknown_Next(enumconverters, 1, &unkconverterinfo, &num_fetched);
+
+        if (res == S_OK)
+        {
+            res = IUnknown_QueryInterface(unkconverterinfo, &IID_IWICFormatConverterInfo, (void**)&converterinfo);
+
+            if (SUCCEEDED(res))
+            {
+                canconvert = ConverterSupportsFormat(converterinfo, srcformatstr);
+
+                if (canconvert)
+                    canconvert = ConverterSupportsFormat(converterinfo, dstformatstr);
+
+                if (canconvert)
+                {
+                    res = IWICFormatConverterInfo_CreateInstance(converterinfo, &converter);
+
+                    if (SUCCEEDED(res))
+                        res = IWICFormatConverter_CanConvert(converter, &srcFormat, dstFormat, &canconvert);
+
+                    if (SUCCEEDED(res) && canconvert)
+                        res = IWICFormatConverter_Initialize(converter, pISrc, dstFormat, WICBitmapDitherTypeNone,
+                            NULL, 0.0, WICBitmapPaletteTypeCustom);
+
+                    if (FAILED(res) || !canconvert)
+                    {
+                        if (converter)
+                        {
+                            IWICFormatConverter_Release(converter);
+                            converter = NULL;
+                        }
+                        res = S_OK;
+                    }
+                }
+
+                IWICFormatConverterInfo_Release(converterinfo);
+            }
+
+            IUnknown_Release(unkconverterinfo);
+        }
+        else
+            break;
+    }
+
+    IEnumUnknown_Release(enumconverters);
+
+    if (converter)
+    {
+        *ppIDst = (IWICBitmapSource*)converter;
+        return S_OK;
+    }
+    else
+    {
+        FIXME("cannot convert %s to %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
+        *ppIDst = NULL;
+        return WINCODEC_ERR_COMPONENTNOTFOUND;
+    }
 }