dll/win32/windowscodecs/info.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  * Copyright 2012 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "wincodecs_private.h"
  21
  22 #include <wine/list.h>
  23
  24 static const WCHAR mimetypes_valuename[] = {'M','i','m','e','T','y','p','e','s',0};
  25 static const WCHAR author_valuename[] = {'A','u','t','h','o','r',0};
  26 static const WCHAR friendlyname_valuename[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
  27 static const WCHAR pixelformats_keyname[] = {'P','i','x','e','l','F','o','r','m','a','t','s',0};
  28 static const WCHAR formats_keyname[] = {'F','o','r','m','a','t','s',0};
  29 static const WCHAR containerformat_valuename[] = {'C','o','n','t','a','i','n','e','r','F','o','r','m','a','t',0};
  30 static const WCHAR metadataformat_valuename[] = {'M','e','t','a','d','a','t','a','F','o','r','m','a','t',0};
  31 static const WCHAR vendor_valuename[] = {'V','e','n','d','o','r',0};
  32 static const WCHAR version_valuename[] = {'V','e','r','s','i','o','n',0};
  33 static const WCHAR specversion_valuename[] = {'S','p','e','c','V','e','r','s','i','o','n',0};
  34 static const WCHAR bitsperpixel_valuename[] = {'B','i','t','L','e','n','g','t','h',0};
  35 static const WCHAR channelcount_valuename[] = {'C','h','a','n','n','e','l','C','o','u','n','t',0};
  36 static const WCHAR channelmasks_keyname[] = {'C','h','a','n','n','e','l','M','a','s','k','s',0};
  37 static const WCHAR numericrepresentation_valuename[] = {'N','u','m','e','r','i','c','R','e','p','r','e','s','e','n','t','a','t','i','o','n',0};
  38 static const WCHAR supportstransparency_valuename[] = {'S','u','p','p','o','r','t','s','T','r','a','n','s','p','a','r','e','n','c','y',0};
  39 static const WCHAR requiresfullstream_valuename[] = {'R','e','q','u','i','r','e','s','F','u','l','l','S','t','r','e','a','m',0};
  40 static const WCHAR supportspadding_valuename[] = {'S','u','p','p','o','r','t','s','P','a','d','d','i','n','g',0};
  41 static const WCHAR fileextensions_valuename[] = {'F','i','l','e','E','x','t','e','n','s','i','o','n','s',0};
  42
  43 static HRESULT ComponentInfo_GetStringValue(HKEY classkey, LPCWSTR value,
  44     UINT buffer_size, WCHAR *buffer, UINT *actual_size)
  45 {
  46     LONG ret;
  47     DWORD cbdata=buffer_size * sizeof(WCHAR);
  48
  49     if (!actual_size)
  50         return E_INVALIDARG;
  51
  52     ret = RegGetValueW(classkey, NULL, value, RRF_RT_REG_SZ|RRF_NOEXPAND, NULL,
  53         buffer, &cbdata);
  54
  55     if (ret == ERROR_FILE_NOT_FOUND)
  56     {
  57         *actual_size = 0;
  58         return S_OK;
  59     }
  60
  61     if (ret == 0 || ret == ERROR_MORE_DATA)
  62         *actual_size = cbdata/sizeof(WCHAR);
  63
  64     if (!buffer && buffer_size != 0)
  65         /* Yes, native returns the correct size in this case. */
  66         return E_INVALIDARG;
  67
  68     if (ret == ERROR_MORE_DATA)
  69         return WINCODEC_ERR_INSUFFICIENTBUFFER;
  70
  71     return HRESULT_FROM_WIN32(ret);
  72 }
  73
  74 static HRESULT ComponentInfo_GetGUIDValue(HKEY classkey, LPCWSTR value,
  75     GUID *result)
  76 {
  77     LONG ret;
  78     WCHAR guid_string[39];
  79     DWORD cbdata = sizeof(guid_string);
  80     HRESULT hr;
  81
  82     if (!result)
  83         return E_INVALIDARG;
  84
  85     ret = RegGetValueW(classkey, NULL, value, RRF_RT_REG_SZ|RRF_NOEXPAND, NULL,
  86         guid_string, &cbdata);
  87
  88     if (ret != ERROR_SUCCESS)
  89         return HRESULT_FROM_WIN32(ret);
  90
  91     if (cbdata < sizeof(guid_string))
  92     {
  93         ERR("incomplete GUID value\n");
  94         return E_FAIL;
  95     }
  96
  97     hr = CLSIDFromString(guid_string, result);
  98
  99     return hr;
 100 }
 101
 102 static HRESULT ComponentInfo_GetDWORDValue(HKEY classkey, LPCWSTR value,
 103     DWORD *result)
 104 {
 105     LONG ret;
 106     DWORD cbdata = sizeof(DWORD);
 107
 108     if (!result)
 109         return E_INVALIDARG;
 110
 111     ret = RegGetValueW(classkey, NULL, value, RRF_RT_DWORD, NULL,
 112         result, &cbdata);
 113
 114     if (ret == ERROR_FILE_NOT_FOUND)
 115     {
 116         *result = 0;
 117         return S_OK;
 118     }
 119
 120     return HRESULT_FROM_WIN32(ret);
 121 }
 122
 123 static HRESULT ComponentInfo_GetGuidList(HKEY classkey, LPCWSTR subkeyname,
 124     UINT buffersize, GUID *buffer, UINT *actual_size)
 125 {
 126     LONG ret;
 127     HKEY subkey;
 128     UINT items_returned;
 129     WCHAR guid_string[39];
 130     DWORD guid_string_size;
 131     HRESULT hr=S_OK;
 132
 133     if (!actual_size)
 134         return E_INVALIDARG;
 135
 136     ret = RegOpenKeyExW(classkey, subkeyname, 0, KEY_READ, &subkey);
 137     if (ret != ERROR_SUCCESS) return HRESULT_FROM_WIN32(ret);
 138
 139     if (buffer)
 140     {
 141         items_returned = 0;
 142         guid_string_size = 39;
 143         while (items_returned < buffersize)
 144         {
 145             ret = RegEnumKeyExW(subkey, items_returned, guid_string,
 146                 &guid_string_size, NULL, NULL, NULL, NULL);
 147
 148             if (ret != ERROR_SUCCESS)
 149             {
 150                 hr = HRESULT_FROM_WIN32(ret);
 151                 break;
 152             }
 153
 154             if (guid_string_size != 38)
 155             {
 156                 hr = E_FAIL;
 157                 break;
 158             }
 159
 160             hr = CLSIDFromString(guid_string, &buffer[items_returned]);
 161             if (FAILED(hr))
 162                 break;
 163
 164             items_returned++;
 165             guid_string_size = 39;
 166         }
 167
 168         if (ret == ERROR_NO_MORE_ITEMS)
 169             hr = S_OK;
 170
 171         *actual_size = items_returned;
 172     }
 173     else
 174     {
 175         ret = RegQueryInfoKeyW(subkey, NULL, NULL, NULL, actual_size, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 176         if (ret != ERROR_SUCCESS)
 177             hr = HRESULT_FROM_WIN32(ret);
 178     }
 179
 180     RegCloseKey(subkey);
 181
 182     return hr;
 183 }
 184
 185 typedef struct {
 186     IWICBitmapDecoderInfo IWICBitmapDecoderInfo_iface;
 187     LONG ref;
 188     HKEY classkey;
 189     CLSID clsid;
 190 } BitmapDecoderInfo;
 191
 192 static inline BitmapDecoderInfo *impl_from_IWICBitmapDecoderInfo(IWICBitmapDecoderInfo *iface)
 193 {
 194     return CONTAINING_RECORD(iface, BitmapDecoderInfo, IWICBitmapDecoderInfo_iface);
 195 }
 196
 197 static HRESULT WINAPI BitmapDecoderInfo_QueryInterface(IWICBitmapDecoderInfo *iface, REFIID iid,
 198     void **ppv)
 199 {
 200     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 201     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 202
 203     if (!ppv) return E_INVALIDARG;
 204
 205     if (IsEqualIID(&IID_IUnknown, iid) ||
 206         IsEqualIID(&IID_IWICComponentInfo, iid) ||
 207         IsEqualIID(&IID_IWICBitmapCodecInfo, iid) ||
 208         IsEqualIID(&IID_IWICBitmapDecoderInfo ,iid))
 209     {
 210         *ppv = This;
 211     }
 212     else
 213     {
 214         *ppv = NULL;
 215         return E_NOINTERFACE;
 216     }
 217
 218     IUnknown_AddRef((IUnknown*)*ppv);
 219     return S_OK;
 220 }
 221
 222 static ULONG WINAPI BitmapDecoderInfo_AddRef(IWICBitmapDecoderInfo *iface)
 223 {
 224     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 225     ULONG ref = InterlockedIncrement(&This->ref);
 226
 227     TRACE("(%p) refcount=%u\n", iface, ref);
 228
 229     return ref;
 230 }
 231
 232 static ULONG WINAPI BitmapDecoderInfo_Release(IWICBitmapDecoderInfo *iface)
 233 {
 234     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 235     ULONG ref = InterlockedDecrement(&This->ref);
 236
 237     TRACE("(%p) refcount=%u\n", iface, ref);
 238
 239     if (ref == 0)
 240     {
 241         RegCloseKey(This->classkey);
 242         HeapFree(GetProcessHeap(), 0, This);
 243     }
 244
 245     return ref;
 246 }
 247
 248 static HRESULT WINAPI BitmapDecoderInfo_GetComponentType(IWICBitmapDecoderInfo *iface,
 249     WICComponentType *pType)
 250 {
 251     TRACE("(%p,%p)\n", iface, pType);
 252     if (!pType) return E_INVALIDARG;
 253     *pType = WICDecoder;
 254     return S_OK;
 255 }
 256
 257 static HRESULT WINAPI BitmapDecoderInfo_GetCLSID(IWICBitmapDecoderInfo *iface, CLSID *pclsid)
 258 {
 259     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 260     TRACE("(%p,%p)\n", iface, pclsid);
 261
 262     if (!pclsid)
 263         return E_INVALIDARG;
 264
 265     memcpy(pclsid, &This->clsid, sizeof(CLSID));
 266
 267     return S_OK;
 268 }
 269
 270 static HRESULT WINAPI BitmapDecoderInfo_GetSigningStatus(IWICBitmapDecoderInfo *iface, DWORD *pStatus)
 271 {
 272     FIXME("(%p,%p): stub\n", iface, pStatus);
 273     return E_NOTIMPL;
 274 }
 275
 276 static HRESULT WINAPI BitmapDecoderInfo_GetAuthor(IWICBitmapDecoderInfo *iface, UINT cchAuthor,
 277     WCHAR *wzAuthor, UINT *pcchActual)
 278 {
 279     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 280
 281     TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
 282
 283     return ComponentInfo_GetStringValue(This->classkey, author_valuename,
 284         cchAuthor, wzAuthor, pcchActual);
 285 }
 286
 287 static HRESULT WINAPI BitmapDecoderInfo_GetVendorGUID(IWICBitmapDecoderInfo *iface, GUID *pguidVendor)
 288 {
 289     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 290
 291     TRACE("(%p,%p)\n", iface, pguidVendor);
 292
 293     return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
 294 }
 295
 296 static HRESULT WINAPI BitmapDecoderInfo_GetVersion(IWICBitmapDecoderInfo *iface, UINT cchVersion,
 297     WCHAR *wzVersion, UINT *pcchActual)
 298 {
 299     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 300
 301     TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
 302
 303     return ComponentInfo_GetStringValue(This->classkey, version_valuename,
 304         cchVersion, wzVersion, pcchActual);
 305 }
 306
 307 static HRESULT WINAPI BitmapDecoderInfo_GetSpecVersion(IWICBitmapDecoderInfo *iface, UINT cchSpecVersion,
 308     WCHAR *wzSpecVersion, UINT *pcchActual)
 309 {
 310     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 311
 312     TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
 313
 314     return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
 315         cchSpecVersion, wzSpecVersion, pcchActual);
 316 }
 317
 318 static HRESULT WINAPI BitmapDecoderInfo_GetFriendlyName(IWICBitmapDecoderInfo *iface, UINT cchFriendlyName,
 319     WCHAR *wzFriendlyName, UINT *pcchActual)
 320 {
 321     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 322
 323     TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
 324
 325     return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
 326         cchFriendlyName, wzFriendlyName, pcchActual);
 327 }
 328
 329 static HRESULT WINAPI BitmapDecoderInfo_GetContainerFormat(IWICBitmapDecoderInfo *iface,
 330     GUID *pguidContainerFormat)
 331 {
 332     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 333     TRACE("(%p,%p)\n", iface, pguidContainerFormat);
 334     return ComponentInfo_GetGUIDValue(This->classkey, containerformat_valuename, pguidContainerFormat);
 335 }
 336
 337 static HRESULT WINAPI BitmapDecoderInfo_GetPixelFormats(IWICBitmapDecoderInfo *iface,
 338     UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
 339 {
 340     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 341     TRACE("(%p,%u,%p,%p)\n", iface, cFormats, pguidPixelFormats, pcActual);
 342     return ComponentInfo_GetGuidList(This->classkey, formats_keyname, cFormats, pguidPixelFormats, pcActual);
 343 }
 344
 345 static HRESULT WINAPI BitmapDecoderInfo_GetColorManagementVersion(IWICBitmapDecoderInfo *iface,
 346     UINT cchColorManagementVersion, WCHAR *wzColorManagementVersion, UINT *pcchActual)
 347 {
 348     FIXME("(%p,%u,%p,%p): stub\n", iface, cchColorManagementVersion, wzColorManagementVersion, pcchActual);
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT WINAPI BitmapDecoderInfo_GetDeviceManufacturer(IWICBitmapDecoderInfo *iface,
 353     UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
 354 {
 355     FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual);
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT WINAPI BitmapDecoderInfo_GetDeviceModels(IWICBitmapDecoderInfo *iface,
 360     UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
 361 {
 362     FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceModels, wzDeviceModels, pcchActual);
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI BitmapDecoderInfo_GetMimeTypes(IWICBitmapDecoderInfo *iface,
 367     UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
 368 {
 369     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 370
 371     TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
 372
 373     return ComponentInfo_GetStringValue(This->classkey, mimetypes_valuename,
 374         cchMimeTypes, wzMimeTypes, pcchActual);
 375 }
 376
 377 static HRESULT WINAPI BitmapDecoderInfo_GetFileExtensions(IWICBitmapDecoderInfo *iface,
 378     UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
 379 {
 380     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 381
 382     TRACE("(%p,%u,%p,%p)\n", iface, cchFileExtensions, wzFileExtensions, pcchActual);
 383
 384     return ComponentInfo_GetStringValue(This->classkey, fileextensions_valuename,
 385         cchFileExtensions, wzFileExtensions, pcchActual);
 386 }
 387
 388 static HRESULT WINAPI BitmapDecoderInfo_DoesSupportAnimation(IWICBitmapDecoderInfo *iface,
 389     BOOL *pfSupportAnimation)
 390 {
 391     FIXME("(%p,%p): stub\n", iface, pfSupportAnimation);
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT WINAPI BitmapDecoderInfo_DoesSupportChromaKey(IWICBitmapDecoderInfo *iface,
 396     BOOL *pfSupportChromaKey)
 397 {
 398     FIXME("(%p,%p): stub\n", iface, pfSupportChromaKey);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI BitmapDecoderInfo_DoesSupportLossless(IWICBitmapDecoderInfo *iface,
 403     BOOL *pfSupportLossless)
 404 {
 405     FIXME("(%p,%p): stub\n", iface, pfSupportLossless);
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI BitmapDecoderInfo_DoesSupportMultiframe(IWICBitmapDecoderInfo *iface,
 410     BOOL *pfSupportMultiframe)
 411 {
 412     FIXME("(%p,%p): stub\n", iface, pfSupportMultiframe);
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI BitmapDecoderInfo_MatchesMimeType(IWICBitmapDecoderInfo *iface,
 417     LPCWSTR wzMimeType, BOOL *pfMatches)
 418 {
 419     FIXME("(%p,%s,%p): stub\n", iface, debugstr_w(wzMimeType), pfMatches);
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI BitmapDecoderInfo_GetPatterns(IWICBitmapDecoderInfo *iface,
 424     UINT cbSizePatterns, WICBitmapPattern *pPatterns, UINT *pcPatterns, UINT *pcbPatternsActual)
 425 {
 426     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 427     UINT pattern_count=0, patterns_size=0;
 428     WCHAR subkeyname[11];
 429     LONG res;
 430     HKEY patternskey, patternkey;
 431     static const WCHAR uintformatW[] = {'%','u',0};
 432     static const WCHAR patternsW[] = {'P','a','t','t','e','r','n','s',0};
 433     static const WCHAR positionW[] = {'P','o','s','i','t','i','o','n',0};
 434     static const WCHAR lengthW[] = {'L','e','n','g','t','h',0};
 435     static const WCHAR patternW[] = {'P','a','t','t','e','r','n',0};
 436     static const WCHAR maskW[] = {'M','a','s','k',0};
 437     static const WCHAR endofstreamW[] = {'E','n','d','O','f','S','t','r','e','a','m',0};
 438     HRESULT hr=S_OK;
 439     UINT i;
 440     BYTE *bPatterns=(BYTE*)pPatterns;
 441     DWORD length, valuesize;
 442
 443     TRACE("(%p,%i,%p,%p,%p)\n", iface, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual);
 444
 445     res = RegOpenKeyExW(This->classkey, patternsW, 0, KEY_READ, &patternskey);
 446     if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res);
 447
 448     res = RegQueryInfoKeyW(patternskey, NULL, NULL, NULL, &pattern_count, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 449     if (res == ERROR_SUCCESS)
 450     {
 451         patterns_size = pattern_count * sizeof(WICBitmapPattern);
 452
 453         for (i=0; i<pattern_count; i++)
 454         {
 455             snprintfW(subkeyname, 11, uintformatW, i);
 456             res = RegOpenKeyExW(patternskey, subkeyname, 0, KEY_READ, &patternkey);
 457             if (res == ERROR_SUCCESS)
 458             {
 459                 valuesize = sizeof(ULONG);
 460                 res = RegGetValueW(patternkey, NULL, lengthW, RRF_RT_DWORD, NULL,
 461                     &length, &valuesize);
 462                 patterns_size += length*2;
 463
 464                 if ((cbSizePatterns >= patterns_size) && (res == ERROR_SUCCESS))
 465                 {
 466                     pPatterns[i].Length = length;
 467
 468                     pPatterns[i].EndOfStream = 0;
 469                     valuesize = sizeof(BOOL);
 470                     RegGetValueW(patternkey, NULL, endofstreamW, RRF_RT_DWORD, NULL,
 471                         &pPatterns[i].EndOfStream, &valuesize);
 472
 473                     pPatterns[i].Position.QuadPart = 0;
 474                     valuesize = sizeof(ULARGE_INTEGER);
 475                     res = RegGetValueW(patternkey, NULL, positionW, RRF_RT_DWORD|RRF_RT_QWORD, NULL,
 476                         &pPatterns[i].Position, &valuesize);
 477
 478                     if (res == ERROR_SUCCESS)
 479                     {
 480                         pPatterns[i].Pattern = bPatterns+patterns_size-length*2;
 481                         valuesize = length;
 482                         res = RegGetValueW(patternkey, NULL, patternW, RRF_RT_REG_BINARY, NULL,
 483                             pPatterns[i].Pattern, &valuesize);
 484                     }
 485
 486                     if (res == ERROR_SUCCESS)
 487                     {
 488                         pPatterns[i].Mask = bPatterns+patterns_size-length;
 489                         valuesize = length;
 490                         res = RegGetValueW(patternkey, NULL, maskW, RRF_RT_REG_BINARY, NULL,
 491                             pPatterns[i].Mask, &valuesize);
 492                     }
 493                 }
 494
 495                 RegCloseKey(patternkey);
 496             }
 497             if (res != ERROR_SUCCESS)
 498             {
 499                 hr = HRESULT_FROM_WIN32(res);
 500                 break;
 501             }
 502         }
 503     }
 504     else hr = HRESULT_FROM_WIN32(res);
 505
 506     RegCloseKey(patternskey);
 507
 508     if (hr == S_OK)
 509     {
 510         *pcPatterns = pattern_count;
 511         *pcbPatternsActual = patterns_size;
 512         if (pPatterns && cbSizePatterns < patterns_size)
 513             hr = WINCODEC_ERR_INSUFFICIENTBUFFER;
 514     }
 515
 516     return hr;
 517 }
 518
 519 static HRESULT WINAPI BitmapDecoderInfo_MatchesPattern(IWICBitmapDecoderInfo *iface,
 520     IStream *pIStream, BOOL *pfMatches)
 521 {
 522     WICBitmapPattern *patterns;
 523     UINT pattern_count=0, patterns_size=0;
 524     HRESULT hr;
 525     UINT i;
 526     ULONG pos;
 527     BYTE *data=NULL;
 528     ULONG datasize=0;
 529     ULONG bytesread;
 530     LARGE_INTEGER seekpos;
 531
 532     TRACE("(%p,%p,%p)\n", iface, pIStream, pfMatches);
 533
 534     hr = BitmapDecoderInfo_GetPatterns(iface, 0, NULL, &pattern_count, &patterns_size);
 535     if (FAILED(hr)) return hr;
 536
 537     patterns = HeapAlloc(GetProcessHeap(), 0, patterns_size);
 538     if (!patterns) return E_OUTOFMEMORY;
 539
 540     hr = BitmapDecoderInfo_GetPatterns(iface, patterns_size, patterns, &pattern_count, &patterns_size);
 541     if (FAILED(hr)) goto end;
 542
 543     for (i=0; i<pattern_count; i++)
 544     {
 545         if (datasize < patterns[i].Length)
 546         {
 547             HeapFree(GetProcessHeap(), 0, data);
 548             datasize = patterns[i].Length;
 549             data = HeapAlloc(GetProcessHeap(), 0, patterns[i].Length);
 550             if (!data)
 551             {
 552                 hr = E_OUTOFMEMORY;
 553                 break;
 554             }
 555         }
 556
 557         if (patterns[i].EndOfStream)
 558             seekpos.QuadPart = -patterns[i].Position.QuadPart;
 559         else
 560             seekpos.QuadPart = patterns[i].Position.QuadPart;
 561         hr = IStream_Seek(pIStream, seekpos, patterns[i].EndOfStream ? STREAM_SEEK_END : STREAM_SEEK_SET, NULL);
 562         if (hr == STG_E_INVALIDFUNCTION) continue; /* before start of stream */
 563         if (FAILED(hr)) break;
 564
 565         hr = IStream_Read(pIStream, data, patterns[i].Length, &bytesread);
 566         if (hr == S_FALSE || (hr == S_OK && bytesread != patterns[i].Length)) /* past end of stream */
 567             continue;
 568         if (FAILED(hr)) break;
 569
 570         for (pos=0; pos<patterns[i].Length; pos++)
 571         {
 572             if ((data[pos] & patterns[i].Mask[pos]) != patterns[i].Pattern[pos])
 573                 break;
 574         }
 575         if (pos == patterns[i].Length) /* matches pattern */
 576         {
 577             hr = S_OK;
 578             *pfMatches = TRUE;
 579             break;
 580         }
 581     }
 582
 583     if (i == pattern_count) /* does not match any pattern */
 584     {
 585         hr = S_OK;
 586         *pfMatches = FALSE;
 587     }
 588
 589 end:
 590     HeapFree(GetProcessHeap(), 0, patterns);
 591     HeapFree(GetProcessHeap(), 0, data);
 592
 593     return hr;
 594 }
 595
 596 static HRESULT WINAPI BitmapDecoderInfo_CreateInstance(IWICBitmapDecoderInfo *iface,
 597     IWICBitmapDecoder **ppIBitmapDecoder)
 598 {
 599     BitmapDecoderInfo *This = impl_from_IWICBitmapDecoderInfo(iface);
 600
 601     TRACE("(%p,%p)\n", iface, ppIBitmapDecoder);
 602
 603     return CoCreateInstance(&This->clsid, NULL, CLSCTX_INPROC_SERVER,
 604         &IID_IWICBitmapDecoder, (void**)ppIBitmapDecoder);
 605 }
 606
 607 static const IWICBitmapDecoderInfoVtbl BitmapDecoderInfo_Vtbl = {
 608     BitmapDecoderInfo_QueryInterface,
 609     BitmapDecoderInfo_AddRef,
 610     BitmapDecoderInfo_Release,
 611     BitmapDecoderInfo_GetComponentType,
 612     BitmapDecoderInfo_GetCLSID,
 613     BitmapDecoderInfo_GetSigningStatus,
 614     BitmapDecoderInfo_GetAuthor,
 615     BitmapDecoderInfo_GetVendorGUID,
 616     BitmapDecoderInfo_GetVersion,
 617     BitmapDecoderInfo_GetSpecVersion,
 618     BitmapDecoderInfo_GetFriendlyName,
 619     BitmapDecoderInfo_GetContainerFormat,
 620     BitmapDecoderInfo_GetPixelFormats,
 621     BitmapDecoderInfo_GetColorManagementVersion,
 622     BitmapDecoderInfo_GetDeviceManufacturer,
 623     BitmapDecoderInfo_GetDeviceModels,
 624     BitmapDecoderInfo_GetMimeTypes,
 625     BitmapDecoderInfo_GetFileExtensions,
 626     BitmapDecoderInfo_DoesSupportAnimation,
 627     BitmapDecoderInfo_DoesSupportChromaKey,
 628     BitmapDecoderInfo_DoesSupportLossless,
 629     BitmapDecoderInfo_DoesSupportMultiframe,
 630     BitmapDecoderInfo_MatchesMimeType,
 631     BitmapDecoderInfo_GetPatterns,
 632     BitmapDecoderInfo_MatchesPattern,
 633     BitmapDecoderInfo_CreateInstance
 634 };
 635
 636 static HRESULT BitmapDecoderInfo_Constructor(HKEY classkey, REFCLSID clsid, IWICComponentInfo **ppIInfo)
 637 {
 638     BitmapDecoderInfo *This;
 639
 640     This = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapDecoderInfo));
 641     if (!This)
 642     {
 643         RegCloseKey(classkey);
 644         return E_OUTOFMEMORY;
 645     }
 646
 647     This->IWICBitmapDecoderInfo_iface.lpVtbl = &BitmapDecoderInfo_Vtbl;
 648     This->ref = 1;
 649     This->classkey = classkey;
 650     memcpy(&This->clsid, clsid, sizeof(CLSID));
 651
 652     *ppIInfo = (IWICComponentInfo*)This;
 653     return S_OK;
 654 }
 655
 656 typedef struct {
 657     IWICBitmapEncoderInfo IWICBitmapEncoderInfo_iface;
 658     LONG ref;
 659     HKEY classkey;
 660     CLSID clsid;
 661 } BitmapEncoderInfo;
 662
 663 static inline BitmapEncoderInfo *impl_from_IWICBitmapEncoderInfo(IWICBitmapEncoderInfo *iface)
 664 {
 665     return CONTAINING_RECORD(iface, BitmapEncoderInfo, IWICBitmapEncoderInfo_iface);
 666 }
 667
 668 static HRESULT WINAPI BitmapEncoderInfo_QueryInterface(IWICBitmapEncoderInfo *iface, REFIID iid,
 669     void **ppv)
 670 {
 671     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 672     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 673
 674     if (!ppv) return E_INVALIDARG;
 675
 676     if (IsEqualIID(&IID_IUnknown, iid) ||
 677         IsEqualIID(&IID_IWICComponentInfo, iid) ||
 678         IsEqualIID(&IID_IWICBitmapCodecInfo, iid) ||
 679         IsEqualIID(&IID_IWICBitmapEncoderInfo ,iid))
 680     {
 681         *ppv = This;
 682     }
 683     else
 684     {
 685         *ppv = NULL;
 686         return E_NOINTERFACE;
 687     }
 688
 689     IUnknown_AddRef((IUnknown*)*ppv);
 690     return S_OK;
 691 }
 692
 693 static ULONG WINAPI BitmapEncoderInfo_AddRef(IWICBitmapEncoderInfo *iface)
 694 {
 695     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 696     ULONG ref = InterlockedIncrement(&This->ref);
 697
 698     TRACE("(%p) refcount=%u\n", iface, ref);
 699
 700     return ref;
 701 }
 702
 703 static ULONG WINAPI BitmapEncoderInfo_Release(IWICBitmapEncoderInfo *iface)
 704 {
 705     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 706     ULONG ref = InterlockedDecrement(&This->ref);
 707
 708     TRACE("(%p) refcount=%u\n", iface, ref);
 709
 710     if (ref == 0)
 711     {
 712         RegCloseKey(This->classkey);
 713         HeapFree(GetProcessHeap(), 0, This);
 714     }
 715
 716     return ref;
 717 }
 718
 719 static HRESULT WINAPI BitmapEncoderInfo_GetComponentType(IWICBitmapEncoderInfo *iface,
 720     WICComponentType *pType)
 721 {
 722     TRACE("(%p,%p)\n", iface, pType);
 723     if (!pType) return E_INVALIDARG;
 724     *pType = WICEncoder;
 725     return S_OK;
 726 }
 727
 728 static HRESULT WINAPI BitmapEncoderInfo_GetCLSID(IWICBitmapEncoderInfo *iface, CLSID *pclsid)
 729 {
 730     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 731     TRACE("(%p,%p)\n", iface, pclsid);
 732
 733     if (!pclsid)
 734         return E_INVALIDARG;
 735
 736     memcpy(pclsid, &This->clsid, sizeof(CLSID));
 737
 738     return S_OK;
 739 }
 740
 741 static HRESULT WINAPI BitmapEncoderInfo_GetSigningStatus(IWICBitmapEncoderInfo *iface, DWORD *pStatus)
 742 {
 743     FIXME("(%p,%p): stub\n", iface, pStatus);
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI BitmapEncoderInfo_GetAuthor(IWICBitmapEncoderInfo *iface, UINT cchAuthor,
 748     WCHAR *wzAuthor, UINT *pcchActual)
 749 {
 750     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 751
 752     TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
 753
 754     return ComponentInfo_GetStringValue(This->classkey, author_valuename,
 755         cchAuthor, wzAuthor, pcchActual);
 756 }
 757
 758 static HRESULT WINAPI BitmapEncoderInfo_GetVendorGUID(IWICBitmapEncoderInfo *iface, GUID *pguidVendor)
 759 {
 760     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 761
 762     TRACE("(%p,%p)\n", iface, pguidVendor);
 763
 764     return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
 765 }
 766
 767 static HRESULT WINAPI BitmapEncoderInfo_GetVersion(IWICBitmapEncoderInfo *iface, UINT cchVersion,
 768     WCHAR *wzVersion, UINT *pcchActual)
 769 {
 770     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 771
 772     TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
 773
 774     return ComponentInfo_GetStringValue(This->classkey, version_valuename,
 775         cchVersion, wzVersion, pcchActual);
 776 }
 777
 778 static HRESULT WINAPI BitmapEncoderInfo_GetSpecVersion(IWICBitmapEncoderInfo *iface, UINT cchSpecVersion,
 779     WCHAR *wzSpecVersion, UINT *pcchActual)
 780 {
 781     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 782
 783     TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
 784
 785     return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
 786         cchSpecVersion, wzSpecVersion, pcchActual);
 787 }
 788
 789 static HRESULT WINAPI BitmapEncoderInfo_GetFriendlyName(IWICBitmapEncoderInfo *iface, UINT cchFriendlyName,
 790     WCHAR *wzFriendlyName, UINT *pcchActual)
 791 {
 792     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 793
 794     TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
 795
 796     return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
 797         cchFriendlyName, wzFriendlyName, pcchActual);
 798 }
 799
 800 static HRESULT WINAPI BitmapEncoderInfo_GetContainerFormat(IWICBitmapEncoderInfo *iface,
 801     GUID *pguidContainerFormat)
 802 {
 803     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 804     TRACE("(%p,%p)\n", iface, pguidContainerFormat);
 805     return ComponentInfo_GetGUIDValue(This->classkey, containerformat_valuename, pguidContainerFormat);
 806 }
 807
 808 static HRESULT WINAPI BitmapEncoderInfo_GetPixelFormats(IWICBitmapEncoderInfo *iface,
 809     UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
 810 {
 811     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 812     TRACE("(%p,%u,%p,%p)\n", iface, cFormats, pguidPixelFormats, pcActual);
 813     return ComponentInfo_GetGuidList(This->classkey, formats_keyname, cFormats, pguidPixelFormats, pcActual);
 814 }
 815
 816 static HRESULT WINAPI BitmapEncoderInfo_GetColorManagementVersion(IWICBitmapEncoderInfo *iface,
 817     UINT cchColorManagementVersion, WCHAR *wzColorManagementVersion, UINT *pcchActual)
 818 {
 819     FIXME("(%p,%u,%p,%p): stub\n", iface, cchColorManagementVersion, wzColorManagementVersion, pcchActual);
 820     return E_NOTIMPL;
 821 }
 822
 823 static HRESULT WINAPI BitmapEncoderInfo_GetDeviceManufacturer(IWICBitmapEncoderInfo *iface,
 824     UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
 825 {
 826     FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual);
 827     return E_NOTIMPL;
 828 }
 829
 830 static HRESULT WINAPI BitmapEncoderInfo_GetDeviceModels(IWICBitmapEncoderInfo *iface,
 831     UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
 832 {
 833     FIXME("(%p,%u,%p,%p): stub\n", iface, cchDeviceModels, wzDeviceModels, pcchActual);
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI BitmapEncoderInfo_GetMimeTypes(IWICBitmapEncoderInfo *iface,
 838     UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
 839 {
 840     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 841
 842     TRACE("(%p,%u,%p,%p)\n", iface, cchMimeTypes, wzMimeTypes, pcchActual);
 843
 844     return ComponentInfo_GetStringValue(This->classkey, mimetypes_valuename,
 845         cchMimeTypes, wzMimeTypes, pcchActual);
 846 }
 847
 848 static HRESULT WINAPI BitmapEncoderInfo_GetFileExtensions(IWICBitmapEncoderInfo *iface,
 849     UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
 850 {
 851     FIXME("(%p,%u,%p,%p): stub\n", iface, cchFileExtensions, wzFileExtensions, pcchActual);
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI BitmapEncoderInfo_DoesSupportAnimation(IWICBitmapEncoderInfo *iface,
 856     BOOL *pfSupportAnimation)
 857 {
 858     FIXME("(%p,%p): stub\n", iface, pfSupportAnimation);
 859     return E_NOTIMPL;
 860 }
 861
 862 static HRESULT WINAPI BitmapEncoderInfo_DoesSupportChromaKey(IWICBitmapEncoderInfo *iface,
 863     BOOL *pfSupportChromaKey)
 864 {
 865     FIXME("(%p,%p): stub\n", iface, pfSupportChromaKey);
 866     return E_NOTIMPL;
 867 }
 868
 869 static HRESULT WINAPI BitmapEncoderInfo_DoesSupportLossless(IWICBitmapEncoderInfo *iface,
 870     BOOL *pfSupportLossless)
 871 {
 872     FIXME("(%p,%p): stub\n", iface, pfSupportLossless);
 873     return E_NOTIMPL;
 874 }
 875
 876 static HRESULT WINAPI BitmapEncoderInfo_DoesSupportMultiframe(IWICBitmapEncoderInfo *iface,
 877     BOOL *pfSupportMultiframe)
 878 {
 879     FIXME("(%p,%p): stub\n", iface, pfSupportMultiframe);
 880     return E_NOTIMPL;
 881 }
 882
 883 static HRESULT WINAPI BitmapEncoderInfo_MatchesMimeType(IWICBitmapEncoderInfo *iface,
 884     LPCWSTR wzMimeType, BOOL *pfMatches)
 885 {
 886     FIXME("(%p,%s,%p): stub\n", iface, debugstr_w(wzMimeType), pfMatches);
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT WINAPI BitmapEncoderInfo_CreateInstance(IWICBitmapEncoderInfo *iface,
 891     IWICBitmapEncoder **ppIBitmapEncoder)
 892 {
 893     BitmapEncoderInfo *This = impl_from_IWICBitmapEncoderInfo(iface);
 894
 895     TRACE("(%p,%p)\n", iface, ppIBitmapEncoder);
 896
 897     return CoCreateInstance(&This->clsid, NULL, CLSCTX_INPROC_SERVER,
 898         &IID_IWICBitmapEncoder, (void**)ppIBitmapEncoder);
 899 }
 900
 901 static const IWICBitmapEncoderInfoVtbl BitmapEncoderInfo_Vtbl = {
 902     BitmapEncoderInfo_QueryInterface,
 903     BitmapEncoderInfo_AddRef,
 904     BitmapEncoderInfo_Release,
 905     BitmapEncoderInfo_GetComponentType,
 906     BitmapEncoderInfo_GetCLSID,
 907     BitmapEncoderInfo_GetSigningStatus,
 908     BitmapEncoderInfo_GetAuthor,
 909     BitmapEncoderInfo_GetVendorGUID,
 910     BitmapEncoderInfo_GetVersion,
 911     BitmapEncoderInfo_GetSpecVersion,
 912     BitmapEncoderInfo_GetFriendlyName,
 913     BitmapEncoderInfo_GetContainerFormat,
 914     BitmapEncoderInfo_GetPixelFormats,
 915     BitmapEncoderInfo_GetColorManagementVersion,
 916     BitmapEncoderInfo_GetDeviceManufacturer,
 917     BitmapEncoderInfo_GetDeviceModels,
 918     BitmapEncoderInfo_GetMimeTypes,
 919     BitmapEncoderInfo_GetFileExtensions,
 920     BitmapEncoderInfo_DoesSupportAnimation,
 921     BitmapEncoderInfo_DoesSupportChromaKey,
 922     BitmapEncoderInfo_DoesSupportLossless,
 923     BitmapEncoderInfo_DoesSupportMultiframe,
 924     BitmapEncoderInfo_MatchesMimeType,
 925     BitmapEncoderInfo_CreateInstance
 926 };
 927
 928 static HRESULT BitmapEncoderInfo_Constructor(HKEY classkey, REFCLSID clsid, IWICComponentInfo **ppIInfo)
 929 {
 930     BitmapEncoderInfo *This;
 931
 932     This = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapEncoderInfo));
 933     if (!This)
 934     {
 935         RegCloseKey(classkey);
 936         return E_OUTOFMEMORY;
 937     }
 938
 939     This->IWICBitmapEncoderInfo_iface.lpVtbl = &BitmapEncoderInfo_Vtbl;
 940     This->ref = 1;
 941     This->classkey = classkey;
 942     memcpy(&This->clsid, clsid, sizeof(CLSID));
 943
 944     *ppIInfo = (IWICComponentInfo*)This;
 945     return S_OK;
 946 }
 947
 948 typedef struct {
 949     IWICFormatConverterInfo IWICFormatConverterInfo_iface;
 950     LONG ref;
 951     HKEY classkey;
 952     CLSID clsid;
 953 } FormatConverterInfo;
 954
 955 static inline FormatConverterInfo *impl_from_IWICFormatConverterInfo(IWICFormatConverterInfo *iface)
 956 {
 957     return CONTAINING_RECORD(iface, FormatConverterInfo, IWICFormatConverterInfo_iface);
 958 }
 959
 960 static HRESULT WINAPI FormatConverterInfo_QueryInterface(IWICFormatConverterInfo *iface, REFIID iid,
 961     void **ppv)
 962 {
 963     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 964     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 965
 966     if (!ppv) return E_INVALIDARG;
 967
 968     if (IsEqualIID(&IID_IUnknown, iid) ||
 969         IsEqualIID(&IID_IWICComponentInfo, iid) ||
 970         IsEqualIID(&IID_IWICFormatConverterInfo ,iid))
 971     {
 972         *ppv = This;
 973     }
 974     else
 975     {
 976         *ppv = NULL;
 977         return E_NOINTERFACE;
 978     }
 979
 980     IUnknown_AddRef((IUnknown*)*ppv);
 981     return S_OK;
 982 }
 983
 984 static ULONG WINAPI FormatConverterInfo_AddRef(IWICFormatConverterInfo *iface)
 985 {
 986     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 987     ULONG ref = InterlockedIncrement(&This->ref);
 988
 989     TRACE("(%p) refcount=%u\n", iface, ref);
 990
 991     return ref;
 992 }
 993
 994 static ULONG WINAPI FormatConverterInfo_Release(IWICFormatConverterInfo *iface)
 995 {
 996     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
 997     ULONG ref = InterlockedDecrement(&This->ref);
 998
 999     TRACE("(%p) refcount=%u\n", iface, ref);
1000
1001     if (ref == 0)
1002     {
1003         RegCloseKey(This->classkey);
1004         HeapFree(GetProcessHeap(), 0, This);
1005     }
1006
1007     return ref;
1008 }
1009
1010 static HRESULT WINAPI FormatConverterInfo_GetComponentType(IWICFormatConverterInfo *iface,
1011     WICComponentType *pType)
1012 {
1013     TRACE("(%p,%p)\n", iface, pType);
1014     if (!pType) return E_INVALIDARG;
1015     *pType = WICPixelFormatConverter;
1016     return S_OK;
1017 }
1018
1019 static HRESULT WINAPI FormatConverterInfo_GetCLSID(IWICFormatConverterInfo *iface, CLSID *pclsid)
1020 {
1021     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1022     TRACE("(%p,%p)\n", iface, pclsid);
1023
1024     if (!pclsid)
1025         return E_INVALIDARG;
1026
1027     memcpy(pclsid, &This->clsid, sizeof(CLSID));
1028
1029     return S_OK;
1030 }
1031
1032 static HRESULT WINAPI FormatConverterInfo_GetSigningStatus(IWICFormatConverterInfo *iface, DWORD *pStatus)
1033 {
1034     FIXME("(%p,%p): stub\n", iface, pStatus);
1035     return E_NOTIMPL;
1036 }
1037
1038 static HRESULT WINAPI FormatConverterInfo_GetAuthor(IWICFormatConverterInfo *iface, UINT cchAuthor,
1039     WCHAR *wzAuthor, UINT *pcchActual)
1040 {
1041     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1042
1043     TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
1044
1045     return ComponentInfo_GetStringValue(This->classkey, author_valuename,
1046         cchAuthor, wzAuthor, pcchActual);
1047 }
1048
1049 static HRESULT WINAPI FormatConverterInfo_GetVendorGUID(IWICFormatConverterInfo *iface, GUID *pguidVendor)
1050 {
1051     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1052
1053     TRACE("(%p,%p)\n", iface, pguidVendor);
1054
1055     return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
1056 }
1057
1058 static HRESULT WINAPI FormatConverterInfo_GetVersion(IWICFormatConverterInfo *iface, UINT cchVersion,
1059     WCHAR *wzVersion, UINT *pcchActual)
1060 {
1061     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1062
1063     TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
1064
1065     return ComponentInfo_GetStringValue(This->classkey, version_valuename,
1066         cchVersion, wzVersion, pcchActual);
1067 }
1068
1069 static HRESULT WINAPI FormatConverterInfo_GetSpecVersion(IWICFormatConverterInfo *iface, UINT cchSpecVersion,
1070     WCHAR *wzSpecVersion, UINT *pcchActual)
1071 {
1072     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1073
1074     TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
1075
1076     return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
1077         cchSpecVersion, wzSpecVersion, pcchActual);
1078 }
1079
1080 static HRESULT WINAPI FormatConverterInfo_GetFriendlyName(IWICFormatConverterInfo *iface, UINT cchFriendlyName,
1081     WCHAR *wzFriendlyName, UINT *pcchActual)
1082 {
1083     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1084
1085     TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
1086
1087     return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
1088         cchFriendlyName, wzFriendlyName, pcchActual);
1089 }
1090
1091 static HRESULT WINAPI FormatConverterInfo_GetPixelFormats(IWICFormatConverterInfo *iface,
1092     UINT cFormats, GUID *pguidPixelFormats, UINT *pcActual)
1093 {
1094     FIXME("(%p,%u,%p,%p): stub\n", iface, cFormats, pguidPixelFormats, pcActual);
1095     return E_NOTIMPL;
1096 }
1097
1098 static HRESULT WINAPI FormatConverterInfo_CreateInstance(IWICFormatConverterInfo *iface,
1099     IWICFormatConverter **ppIFormatConverter)
1100 {
1101     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1102
1103     TRACE("(%p,%p)\n", iface, ppIFormatConverter);
1104
1105     return CoCreateInstance(&This->clsid, NULL, CLSCTX_INPROC_SERVER,
1106         &IID_IWICFormatConverter, (void**)ppIFormatConverter);
1107 }
1108
1109 static BOOL ConverterSupportsFormat(IWICFormatConverterInfo *iface, const WCHAR *formatguid)
1110 {
1111     LONG res;
1112     FormatConverterInfo *This = impl_from_IWICFormatConverterInfo(iface);
1113     HKEY formats_key, guid_key;
1114
1115     /* Avoid testing using IWICFormatConverter_GetPixelFormats because that
1116         would be O(n). A registry test should do better. */
1117
1118     res = RegOpenKeyExW(This->classkey, pixelformats_keyname, 0, KEY_READ, &formats_key);
1119     if (res != ERROR_SUCCESS) return FALSE;
1120
1121     res = RegOpenKeyExW(formats_key, formatguid, 0, KEY_READ, &guid_key);
1122     if (res == ERROR_SUCCESS) RegCloseKey(guid_key);
1123
1124     RegCloseKey(formats_key);
1125
1126     return (res == ERROR_SUCCESS);
1127 }
1128
1129 static const IWICFormatConverterInfoVtbl FormatConverterInfo_Vtbl = {
1130     FormatConverterInfo_QueryInterface,
1131     FormatConverterInfo_AddRef,
1132     FormatConverterInfo_Release,
1133     FormatConverterInfo_GetComponentType,
1134     FormatConverterInfo_GetCLSID,
1135     FormatConverterInfo_GetSigningStatus,
1136     FormatConverterInfo_GetAuthor,
1137     FormatConverterInfo_GetVendorGUID,
1138     FormatConverterInfo_GetVersion,
1139     FormatConverterInfo_GetSpecVersion,
1140     FormatConverterInfo_GetFriendlyName,
1141     FormatConverterInfo_GetPixelFormats,
1142     FormatConverterInfo_CreateInstance
1143 };
1144
1145 static HRESULT FormatConverterInfo_Constructor(HKEY classkey, REFCLSID clsid, IWICComponentInfo **ppIInfo)
1146 {
1147     FormatConverterInfo *This;
1148
1149     This = HeapAlloc(GetProcessHeap(), 0, sizeof(FormatConverterInfo));
1150     if (!This)
1151     {
1152         RegCloseKey(classkey);
1153         return E_OUTOFMEMORY;
1154     }
1155
1156     This->IWICFormatConverterInfo_iface.lpVtbl = &FormatConverterInfo_Vtbl;
1157     This->ref = 1;
1158     This->classkey = classkey;
1159     memcpy(&This->clsid, clsid, sizeof(CLSID));
1160
1161     *ppIInfo = (IWICComponentInfo*)This;
1162     return S_OK;
1163 }
1164
1165 typedef struct {
1166     IWICPixelFormatInfo2 IWICPixelFormatInfo2_iface;
1167     LONG ref;
1168     HKEY classkey;
1169     CLSID clsid;
1170 } PixelFormatInfo;
1171
1172 static inline PixelFormatInfo *impl_from_IWICPixelFormatInfo2(IWICPixelFormatInfo2 *iface)
1173 {
1174     return CONTAINING_RECORD(iface, PixelFormatInfo, IWICPixelFormatInfo2_iface);
1175 }
1176
1177 static HRESULT WINAPI PixelFormatInfo_QueryInterface(IWICPixelFormatInfo2 *iface, REFIID iid,
1178     void **ppv)
1179 {
1180     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1181     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1182
1183     if (!ppv) return E_INVALIDARG;
1184
1185     if (IsEqualIID(&IID_IUnknown, iid) ||
1186         IsEqualIID(&IID_IWICComponentInfo, iid) ||
1187         IsEqualIID(&IID_IWICPixelFormatInfo, iid) ||
1188         IsEqualIID(&IID_IWICPixelFormatInfo2 ,iid))
1189     {
1190         *ppv = This;
1191     }
1192     else
1193     {
1194         *ppv = NULL;
1195         return E_NOINTERFACE;
1196     }
1197
1198     IUnknown_AddRef((IUnknown*)*ppv);
1199     return S_OK;
1200 }
1201
1202 static ULONG WINAPI PixelFormatInfo_AddRef(IWICPixelFormatInfo2 *iface)
1203 {
1204     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1205     ULONG ref = InterlockedIncrement(&This->ref);
1206
1207     TRACE("(%p) refcount=%u\n", iface, ref);
1208
1209     return ref;
1210 }
1211
1212 static ULONG WINAPI PixelFormatInfo_Release(IWICPixelFormatInfo2 *iface)
1213 {
1214     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1215     ULONG ref = InterlockedDecrement(&This->ref);
1216
1217     TRACE("(%p) refcount=%u\n", iface, ref);
1218
1219     if (ref == 0)
1220     {
1221         RegCloseKey(This->classkey);
1222         HeapFree(GetProcessHeap(), 0, This);
1223     }
1224
1225     return ref;
1226 }
1227
1228 static HRESULT WINAPI PixelFormatInfo_GetComponentType(IWICPixelFormatInfo2 *iface,
1229     WICComponentType *pType)
1230 {
1231     TRACE("(%p,%p)\n", iface, pType);
1232     if (!pType) return E_INVALIDARG;
1233     *pType = WICPixelFormat;
1234     return S_OK;
1235 }
1236
1237 static HRESULT WINAPI PixelFormatInfo_GetCLSID(IWICPixelFormatInfo2 *iface, CLSID *pclsid)
1238 {
1239     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1240     TRACE("(%p,%p)\n", iface, pclsid);
1241
1242     if (!pclsid)
1243         return E_INVALIDARG;
1244
1245     memcpy(pclsid, &This->clsid, sizeof(CLSID));
1246
1247     return S_OK;
1248 }
1249
1250 static HRESULT WINAPI PixelFormatInfo_GetSigningStatus(IWICPixelFormatInfo2 *iface, DWORD *pStatus)
1251 {
1252     TRACE("(%p,%p)\n", iface, pStatus);
1253
1254     if (!pStatus)
1255         return E_INVALIDARG;
1256
1257     /* Pixel formats don't require code, so they are considered signed. */
1258     *pStatus = WICComponentSigned;
1259
1260     return S_OK;
1261 }
1262
1263 static HRESULT WINAPI PixelFormatInfo_GetAuthor(IWICPixelFormatInfo2 *iface, UINT cchAuthor,
1264     WCHAR *wzAuthor, UINT *pcchActual)
1265 {
1266     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1267
1268     TRACE("(%p,%u,%p,%p)\n", iface, cchAuthor, wzAuthor, pcchActual);
1269
1270     return ComponentInfo_GetStringValue(This->classkey, author_valuename,
1271         cchAuthor, wzAuthor, pcchActual);
1272 }
1273
1274 static HRESULT WINAPI PixelFormatInfo_GetVendorGUID(IWICPixelFormatInfo2 *iface, GUID *pguidVendor)
1275 {
1276     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1277
1278     TRACE("(%p,%p)\n", iface, pguidVendor);
1279
1280     return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, pguidVendor);
1281 }
1282
1283 static HRESULT WINAPI PixelFormatInfo_GetVersion(IWICPixelFormatInfo2 *iface, UINT cchVersion,
1284     WCHAR *wzVersion, UINT *pcchActual)
1285 {
1286     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1287
1288     TRACE("(%p,%u,%p,%p)\n", iface, cchVersion, wzVersion, pcchActual);
1289
1290     return ComponentInfo_GetStringValue(This->classkey, version_valuename,
1291         cchVersion, wzVersion, pcchActual);
1292 }
1293
1294 static HRESULT WINAPI PixelFormatInfo_GetSpecVersion(IWICPixelFormatInfo2 *iface, UINT cchSpecVersion,
1295     WCHAR *wzSpecVersion, UINT *pcchActual)
1296 {
1297     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1298
1299     TRACE("(%p,%u,%p,%p)\n", iface, cchSpecVersion, wzSpecVersion, pcchActual);
1300
1301     return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
1302         cchSpecVersion, wzSpecVersion, pcchActual);
1303 }
1304
1305 static HRESULT WINAPI PixelFormatInfo_GetFriendlyName(IWICPixelFormatInfo2 *iface, UINT cchFriendlyName,
1306     WCHAR *wzFriendlyName, UINT *pcchActual)
1307 {
1308     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1309
1310     TRACE("(%p,%u,%p,%p)\n", iface, cchFriendlyName, wzFriendlyName, pcchActual);
1311
1312     return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
1313         cchFriendlyName, wzFriendlyName, pcchActual);
1314 }
1315
1316 static HRESULT WINAPI PixelFormatInfo_GetFormatGUID(IWICPixelFormatInfo2 *iface,
1317     GUID *pFormat)
1318 {
1319     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1320     TRACE("(%p,%p)\n", iface, pFormat);
1321
1322     if (!pFormat)
1323         return E_INVALIDARG;
1324
1325     *pFormat = This->clsid;
1326
1327     return S_OK;
1328 }
1329
1330 static HRESULT WINAPI PixelFormatInfo_GetColorContext(IWICPixelFormatInfo2 *iface,
1331     IWICColorContext **ppIColorContext)
1332 {
1333     FIXME("(%p,%p): stub\n", iface, ppIColorContext);
1334     return E_NOTIMPL;
1335 }
1336
1337 static HRESULT WINAPI PixelFormatInfo_GetBitsPerPixel(IWICPixelFormatInfo2 *iface,
1338     UINT *puiBitsPerPixel)
1339 {
1340     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1341
1342     TRACE("(%p,%p)\n", iface, puiBitsPerPixel);
1343
1344     return ComponentInfo_GetDWORDValue(This->classkey, bitsperpixel_valuename, puiBitsPerPixel);
1345 }
1346
1347 static HRESULT WINAPI PixelFormatInfo_GetChannelCount(IWICPixelFormatInfo2 *iface,
1348     UINT *puiChannelCount)
1349 {
1350     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1351
1352     TRACE("(%p,%p)\n", iface, puiChannelCount);
1353
1354     return ComponentInfo_GetDWORDValue(This->classkey, channelcount_valuename, puiChannelCount);
1355 }
1356
1357 static HRESULT WINAPI PixelFormatInfo_GetChannelMask(IWICPixelFormatInfo2 *iface,
1358     UINT uiChannelIndex, UINT cbMaskBuffer, BYTE *pbMaskBuffer, UINT *pcbActual)
1359 {
1360     static const WCHAR uintformatW[] = {'%','u',0};
1361     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1362     UINT channel_count;
1363     HRESULT hr;
1364     LONG ret;
1365     WCHAR valuename[11];
1366     DWORD cbData;
1367
1368     TRACE("(%p,%u,%u,%p,%p)\n", iface, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual);
1369
1370     if (!pcbActual)
1371         return E_INVALIDARG;
1372
1373     hr = PixelFormatInfo_GetChannelCount(iface, &channel_count);
1374
1375     if (SUCCEEDED(hr) && uiChannelIndex >= channel_count)
1376         hr = E_INVALIDARG;
1377
1378     if (SUCCEEDED(hr))
1379     {
1380         snprintfW(valuename, 11, uintformatW, uiChannelIndex);
1381
1382         cbData = cbMaskBuffer;
1383
1384         ret = RegGetValueW(This->classkey, channelmasks_keyname, valuename, RRF_RT_REG_BINARY, NULL, pbMaskBuffer, &cbData);
1385
1386         if (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA)
1387             *pcbActual = cbData;
1388
1389         if (ret == ERROR_MORE_DATA)
1390             hr = E_INVALIDARG;
1391         else
1392             hr = HRESULT_FROM_WIN32(ret);
1393     }
1394
1395     return hr;
1396 }
1397
1398 static HRESULT WINAPI PixelFormatInfo_SupportsTransparency(IWICPixelFormatInfo2 *iface,
1399     BOOL *pfSupportsTransparency)
1400 {
1401     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1402
1403     TRACE("(%p,%p)\n", iface, pfSupportsTransparency);
1404
1405     return ComponentInfo_GetDWORDValue(This->classkey, supportstransparency_valuename, (DWORD*)pfSupportsTransparency);
1406 }
1407
1408 static HRESULT WINAPI PixelFormatInfo_GetNumericRepresentation(IWICPixelFormatInfo2 *iface,
1409     WICPixelFormatNumericRepresentation *pNumericRepresentation)
1410 {
1411     PixelFormatInfo *This = impl_from_IWICPixelFormatInfo2(iface);
1412
1413     TRACE("(%p,%p)\n", iface, pNumericRepresentation);
1414
1415     return ComponentInfo_GetDWORDValue(This->classkey, numericrepresentation_valuename, pNumericRepresentation);
1416 }
1417
1418 static const IWICPixelFormatInfo2Vtbl PixelFormatInfo_Vtbl = {
1419     PixelFormatInfo_QueryInterface,
1420     PixelFormatInfo_AddRef,
1421     PixelFormatInfo_Release,
1422     PixelFormatInfo_GetComponentType,
1423     PixelFormatInfo_GetCLSID,
1424     PixelFormatInfo_GetSigningStatus,
1425     PixelFormatInfo_GetAuthor,
1426     PixelFormatInfo_GetVendorGUID,
1427     PixelFormatInfo_GetVersion,
1428     PixelFormatInfo_GetSpecVersion,
1429     PixelFormatInfo_GetFriendlyName,
1430     PixelFormatInfo_GetFormatGUID,
1431     PixelFormatInfo_GetColorContext,
1432     PixelFormatInfo_GetBitsPerPixel,
1433     PixelFormatInfo_GetChannelCount,
1434     PixelFormatInfo_GetChannelMask,
1435     PixelFormatInfo_SupportsTransparency,
1436     PixelFormatInfo_GetNumericRepresentation
1437 };
1438
1439 static HRESULT PixelFormatInfo_Constructor(HKEY classkey, REFCLSID clsid, IWICComponentInfo **ppIInfo)
1440 {
1441     PixelFormatInfo *This;
1442
1443     This = HeapAlloc(GetProcessHeap(), 0, sizeof(PixelFormatInfo));
1444     if (!This)
1445     {
1446         RegCloseKey(classkey);
1447         return E_OUTOFMEMORY;
1448     }
1449
1450     This->IWICPixelFormatInfo2_iface.lpVtbl = &PixelFormatInfo_Vtbl;
1451     This->ref = 1;
1452     This->classkey = classkey;
1453     memcpy(&This->clsid, clsid, sizeof(CLSID));
1454
1455     *ppIInfo = (IWICComponentInfo*)This;
1456     return S_OK;
1457 }
1458
1459 typedef struct
1460 {
1461     IWICMetadataReaderInfo IWICMetadataReaderInfo_iface;
1462     LONG ref;
1463     HKEY classkey;
1464     CLSID clsid;
1465 } MetadataReaderInfo;
1466
1467 static inline MetadataReaderInfo *impl_from_IWICMetadataReaderInfo(IWICMetadataReaderInfo *iface)
1468 {
1469     return CONTAINING_RECORD(iface, MetadataReaderInfo, IWICMetadataReaderInfo_iface);
1470 }
1471
1472 static HRESULT WINAPI MetadataReaderInfo_QueryInterface(IWICMetadataReaderInfo *iface,
1473     REFIID riid, void **ppv)
1474 {
1475     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1476
1477     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
1478
1479     if (!ppv) return E_INVALIDARG;
1480
1481     if (IsEqualIID(&IID_IUnknown, riid) ||
1482         IsEqualIID(&IID_IWICComponentInfo, riid) ||
1483         IsEqualIID(&IID_IWICMetadataHandlerInfo, riid) ||
1484         IsEqualIID(&IID_IWICMetadataReaderInfo, riid))
1485     {
1486         *ppv = This;
1487     }
1488     else
1489     {
1490         *ppv = NULL;
1491         return E_NOINTERFACE;
1492     }
1493
1494     IUnknown_AddRef((IUnknown *)*ppv);
1495     return S_OK;
1496 }
1497
1498 static ULONG WINAPI MetadataReaderInfo_AddRef(IWICMetadataReaderInfo *iface)
1499 {
1500     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1501     ULONG ref = InterlockedIncrement(&This->ref);
1502
1503     TRACE("(%p) refcount=%u\n", iface, ref);
1504     return ref;
1505 }
1506
1507 static ULONG WINAPI MetadataReaderInfo_Release(IWICMetadataReaderInfo *iface)
1508 {
1509     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1510     ULONG ref = InterlockedDecrement(&This->ref);
1511
1512     TRACE("(%p) refcount=%u\n", iface, ref);
1513
1514     if (!ref)
1515     {
1516         RegCloseKey(This->classkey);
1517         HeapFree(GetProcessHeap(), 0, This);
1518     }
1519     return ref;
1520 }
1521
1522 static HRESULT WINAPI MetadataReaderInfo_GetComponentType(IWICMetadataReaderInfo *iface,
1523     WICComponentType *type)
1524 {
1525     TRACE("(%p,%p)\n", iface, type);
1526
1527     if (!type) return E_INVALIDARG;
1528     *type = WICMetadataReader;
1529     return S_OK;
1530 }
1531
1532 static HRESULT WINAPI MetadataReaderInfo_GetCLSID(IWICMetadataReaderInfo *iface,
1533     CLSID *clsid)
1534 {
1535     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1536
1537     TRACE("(%p,%p)\n", iface, clsid);
1538
1539     if (!clsid) return E_INVALIDARG;
1540     *clsid = This->clsid;
1541     return S_OK;
1542 }
1543
1544 static HRESULT WINAPI MetadataReaderInfo_GetSigningStatus(IWICMetadataReaderInfo *iface,
1545     DWORD *status)
1546 {
1547     FIXME("(%p,%p): stub\n", iface, status);
1548     return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI MetadataReaderInfo_GetAuthor(IWICMetadataReaderInfo *iface,
1552     UINT length, WCHAR *author, UINT *actual_length)
1553 {
1554     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1555
1556     TRACE("(%p,%u,%p,%p)\n", iface, length, author, actual_length);
1557
1558     return ComponentInfo_GetStringValue(This->classkey, author_valuename,
1559                                         length, author, actual_length);
1560 }
1561
1562 static HRESULT WINAPI MetadataReaderInfo_GetVendorGUID(IWICMetadataReaderInfo *iface,
1563     GUID *vendor)
1564 {
1565     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1566
1567     TRACE("(%p,%p)\n", iface, vendor);
1568
1569     return ComponentInfo_GetGUIDValue(This->classkey, vendor_valuename, vendor);
1570 }
1571
1572 static HRESULT WINAPI MetadataReaderInfo_GetVersion(IWICMetadataReaderInfo *iface,
1573     UINT length, WCHAR *version, UINT *actual_length)
1574 {
1575     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1576
1577     TRACE("(%p,%u,%p,%p)\n", iface, length, version, actual_length);
1578
1579     return ComponentInfo_GetStringValue(This->classkey, version_valuename,
1580                                         length, version, actual_length);
1581 }
1582
1583 static HRESULT WINAPI MetadataReaderInfo_GetSpecVersion(IWICMetadataReaderInfo *iface,
1584     UINT length, WCHAR *version, UINT *actual_length)
1585 {
1586     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1587
1588     TRACE("(%p,%u,%p,%p)\n", iface, length, version, actual_length);
1589
1590     return ComponentInfo_GetStringValue(This->classkey, specversion_valuename,
1591                                         length, version, actual_length);
1592 }
1593
1594 static HRESULT WINAPI MetadataReaderInfo_GetFriendlyName(IWICMetadataReaderInfo *iface,
1595     UINT length, WCHAR *name, UINT *actual_length)
1596 {
1597     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1598
1599     TRACE("(%p,%u,%p,%p)\n", iface, length, name, actual_length);
1600
1601     return ComponentInfo_GetStringValue(This->classkey, friendlyname_valuename,
1602                                         length, name, actual_length);
1603 }
1604
1605 static HRESULT WINAPI MetadataReaderInfo_GetMetadataFormat(IWICMetadataReaderInfo *iface,
1606     GUID *format)
1607 {
1608     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1609     TRACE("(%p,%p)\n", iface, format);
1610     return ComponentInfo_GetGUIDValue(This->classkey, metadataformat_valuename, format);
1611 }
1612
1613 static HRESULT WINAPI MetadataReaderInfo_GetContainerFormats(IWICMetadataReaderInfo *iface,
1614     UINT length, GUID *formats, UINT *actual_length)
1615 {
1616     if (!actual_length) return E_INVALIDARG;
1617
1618     FIXME("(%p,%u,%p,%p): stub\n", iface, length, formats, actual_length);
1619     return E_NOTIMPL;
1620 }
1621
1622 static HRESULT WINAPI MetadataReaderInfo_GetDeviceManufacturer(IWICMetadataReaderInfo *iface,
1623     UINT length, WCHAR *manufacturer, UINT *actual_length)
1624 {
1625     FIXME("(%p,%u,%p,%p): stub\n", iface, length, manufacturer, actual_length);
1626     return E_NOTIMPL;
1627 }
1628
1629 static HRESULT WINAPI MetadataReaderInfo_GetDeviceModels(IWICMetadataReaderInfo *iface,
1630     UINT length, WCHAR *models, UINT *actual_length)
1631 {
1632     FIXME("(%p,%u,%p,%p): stub\n", iface, length, models, actual_length);
1633     return E_NOTIMPL;
1634 }
1635
1636 static HRESULT WINAPI MetadataReaderInfo_DoesRequireFullStream(IWICMetadataReaderInfo *iface,
1637     BOOL *param)
1638 {
1639     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1640     TRACE("(%p,%p)\n", iface, param);
1641     return ComponentInfo_GetDWORDValue(This->classkey, requiresfullstream_valuename, (DWORD *)param);
1642 }
1643
1644 static HRESULT WINAPI MetadataReaderInfo_DoesSupportPadding(IWICMetadataReaderInfo *iface,
1645     BOOL *param)
1646 {
1647     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1648     TRACE("(%p,%p)\n", iface, param);
1649     return ComponentInfo_GetDWORDValue(This->classkey, supportspadding_valuename, (DWORD *)param);
1650 }
1651
1652 static HRESULT WINAPI MetadataReaderInfo_DoesRequireFixedSize(IWICMetadataReaderInfo *iface,
1653     BOOL *param)
1654 {
1655     FIXME("(%p,%p): stub\n", iface, param);
1656     return E_NOTIMPL;
1657 }
1658
1659 static HRESULT WINAPI MetadataReaderInfo_GetPatterns(IWICMetadataReaderInfo *iface,
1660     REFGUID container, UINT length, WICMetadataPattern *pattern, UINT *count, UINT *actual_length)
1661 {
1662     if (!actual_length) return E_INVALIDARG;
1663
1664     FIXME("(%p,%s,%u,%p,%p,%p): stub\n", iface, debugstr_guid(container), length, pattern, count, actual_length);
1665     return E_NOTIMPL;
1666 }
1667
1668 static HRESULT WINAPI MetadataReaderInfo_MatchesPattern(IWICMetadataReaderInfo *iface,
1669     REFGUID container, IStream *stream, BOOL *matches)
1670 {
1671     FIXME("(%p,%s,%p,%p): stub\n", iface, debugstr_guid(container), stream, matches);
1672     return E_NOTIMPL;
1673 }
1674
1675 static HRESULT WINAPI MetadataReaderInfo_CreateInstance(IWICMetadataReaderInfo *iface,
1676     IWICMetadataReader **reader)
1677 {
1678     MetadataReaderInfo *This = impl_from_IWICMetadataReaderInfo(iface);
1679
1680     TRACE("(%p,%p)\n", iface, reader);
1681
1682     return CoCreateInstance(&This->clsid, NULL, CLSCTX_INPROC_SERVER,
1683                             &IID_IWICMetadataReader, (void **)reader);
1684 }
1685
1686 static const IWICMetadataReaderInfoVtbl MetadataReaderInfo_Vtbl = {
1687     MetadataReaderInfo_QueryInterface,
1688     MetadataReaderInfo_AddRef,
1689     MetadataReaderInfo_Release,
1690     MetadataReaderInfo_GetComponentType,
1691     MetadataReaderInfo_GetCLSID,
1692     MetadataReaderInfo_GetSigningStatus,
1693     MetadataReaderInfo_GetAuthor,
1694     MetadataReaderInfo_GetVendorGUID,
1695     MetadataReaderInfo_GetVersion,
1696     MetadataReaderInfo_GetSpecVersion,
1697     MetadataReaderInfo_GetFriendlyName,
1698     MetadataReaderInfo_GetMetadataFormat,
1699     MetadataReaderInfo_GetContainerFormats,
1700     MetadataReaderInfo_GetDeviceManufacturer,
1701     MetadataReaderInfo_GetDeviceModels,
1702     MetadataReaderInfo_DoesRequireFullStream,
1703     MetadataReaderInfo_DoesSupportPadding,
1704     MetadataReaderInfo_DoesRequireFixedSize,
1705     MetadataReaderInfo_GetPatterns,
1706     MetadataReaderInfo_MatchesPattern,
1707     MetadataReaderInfo_CreateInstance
1708 };
1709
1710 static HRESULT MetadataReaderInfo_Constructor(HKEY classkey, REFCLSID clsid, IWICComponentInfo **info)
1711 {
1712     MetadataReaderInfo *This;
1713
1714     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1715     if (!This)
1716     {
1717         RegCloseKey(classkey);
1718         return E_OUTOFMEMORY;
1719     }
1720
1721     This->IWICMetadataReaderInfo_iface.lpVtbl = &MetadataReaderInfo_Vtbl;
1722     This->ref = 1;
1723     This->classkey = classkey;
1724     This->clsid = *clsid;
1725
1726     *info = (IWICComponentInfo *)This;
1727     return S_OK;
1728 }
1729
1730 static const WCHAR clsid_keyname[] = {'C','L','S','I','D',0};
1731 static const WCHAR instance_keyname[] = {'I','n','s','t','a','n','c','e',0};
1732
1733 struct category {
1734     WICComponentType type;
1735     const GUID *catid;
1736     HRESULT (*constructor)(HKEY,REFCLSID,IWICComponentInfo**);
1737 };
1738
1739 static const struct category categories[] = {
1740     {WICDecoder, &CATID_WICBitmapDecoders, BitmapDecoderInfo_Constructor},
1741     {WICEncoder, &CATID_WICBitmapEncoders, BitmapEncoderInfo_Constructor},
1742     {WICPixelFormatConverter, &CATID_WICFormatConverters, FormatConverterInfo_Constructor},
1743     {WICPixelFormat, &CATID_WICPixelFormats, PixelFormatInfo_Constructor},
1744     {WICMetadataReader, &CATID_WICMetadataReader, MetadataReaderInfo_Constructor},
1745     {0}
1746 };
1747
1748 HRESULT CreateComponentInfo(REFCLSID clsid, IWICComponentInfo **ppIInfo)
1749 {
1750     HKEY clsidkey;
1751     HKEY classkey;
1752     HKEY catidkey;
1753     HKEY instancekey;
1754     WCHAR guidstring[39];
1755     LONG res;
1756     const struct category *category;
1757     BOOL found = FALSE;
1758     HRESULT hr;
1759
1760     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, KEY_READ, &clsidkey);
1761     if (res != ERROR_SUCCESS)
1762         return HRESULT_FROM_WIN32(res);
1763
1764     for (category=categories; category->type; category++)
1765     {
1766         StringFromGUID2(category->catid, guidstring, 39);
1767         res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
1768         if (res == ERROR_SUCCESS)
1769         {
1770             res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
1771             if (res == ERROR_SUCCESS)
1772             {
1773                 StringFromGUID2(clsid, guidstring, 39);
1774                 res = RegOpenKeyExW(instancekey, guidstring, 0, KEY_READ, &classkey);
1775                 if (res == ERROR_SUCCESS)
1776                 {
1777                     RegCloseKey(classkey);
1778                     found = TRUE;
1779                 }
1780                 RegCloseKey(instancekey);
1781             }
1782             RegCloseKey(catidkey);
1783         }
1784         if (found) break;
1785     }
1786
1787     if (found)
1788     {
1789         res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &classkey);
1790         if (res == ERROR_SUCCESS)
1791             hr = category->constructor(classkey, clsid, ppIInfo);
1792         else
1793             hr = HRESULT_FROM_WIN32(res);
1794     }
1795     else
1796     {
1797         FIXME("%s is not supported\n", wine_dbgstr_guid(clsid));
1798         hr = E_FAIL;
1799     }
1800
1801     RegCloseKey(clsidkey);
1802
1803     return hr;
1804 }
1805
1806 typedef struct {
1807     IEnumUnknown IEnumUnknown_iface;
1808     LONG ref;
1809     struct list objects;
1810     struct list *cursor;
1811     CRITICAL_SECTION lock; /* Must be held when reading or writing cursor */
1812 } ComponentEnum;
1813
1814 static inline ComponentEnum *impl_from_IEnumUnknown(IEnumUnknown *iface)
1815 {
1816     return CONTAINING_RECORD(iface, ComponentEnum, IEnumUnknown_iface);
1817 }
1818
1819 typedef struct {
1820     struct list entry;
1821     IUnknown *unk;
1822 } ComponentEnumItem;
1823
1824 static const IEnumUnknownVtbl ComponentEnumVtbl;
1825
1826 static HRESULT WINAPI ComponentEnum_QueryInterface(IEnumUnknown *iface, REFIID iid,
1827     void **ppv)
1828 {
1829     ComponentEnum *This = impl_from_IEnumUnknown(iface);
1830     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
1831
1832     if (!ppv) return E_INVALIDARG;
1833
1834     if (IsEqualIID(&IID_IUnknown, iid) ||
1835         IsEqualIID(&IID_IEnumUnknown, iid))
1836     {
1837         *ppv = &This->IEnumUnknown_iface;
1838     }
1839     else
1840     {
1841         *ppv = NULL;
1842         return E_NOINTERFACE;
1843     }
1844
1845     IUnknown_AddRef((IUnknown*)*ppv);
1846     return S_OK;
1847 }
1848
1849 static ULONG WINAPI ComponentEnum_AddRef(IEnumUnknown *iface)
1850 {
1851     ComponentEnum *This = impl_from_IEnumUnknown(iface);
1852     ULONG ref = InterlockedIncrement(&This->ref);
1853
1854     TRACE("(%p) refcount=%u\n", iface, ref);
1855
1856     return ref;
1857 }
1858
1859 static ULONG WINAPI ComponentEnum_Release(IEnumUnknown *iface)
1860 {
1861     ComponentEnum *This = impl_from_IEnumUnknown(iface);
1862     ULONG ref = InterlockedDecrement(&This->ref);
1863     ComponentEnumItem *cursor, *cursor2;
1864
1865     TRACE("(%p) refcount=%u\n", iface, ref);
1866
1867     if (ref == 0)
1868     {
1869         LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &This->objects, ComponentEnumItem, entry)
1870         {
1871             IUnknown_Release(cursor->unk);
1872             list_remove(&cursor->entry);
1873             HeapFree(GetProcessHeap(), 0, cursor);
1874         }
1875         This->lock.DebugInfo->Spare[0] = 0;
1876         DeleteCriticalSection(&This->lock);
1877         HeapFree(GetProcessHeap(), 0, This);
1878     }
1879
1880     return ref;
1881 }
1882
1883 static HRESULT WINAPI ComponentEnum_Next(IEnumUnknown *iface, ULONG celt,
1884     IUnknown **rgelt, ULONG *pceltFetched)
1885 {
1886     ComponentEnum *This = impl_from_IEnumUnknown(iface);
1887     ULONG num_fetched=0;
1888     ComponentEnumItem *item;
1889     HRESULT hr=S_OK;
1890
1891     TRACE("(%p,%u,%p,%p)\n", iface, celt, rgelt, pceltFetched);
1892
1893     EnterCriticalSection(&This->lock);
1894     while (num_fetched<celt)
1895     {
1896         if (!This->cursor)
1897         {
1898             hr = S_FALSE;
1899             break;
1900         }
1901         item = LIST_ENTRY(This->cursor, ComponentEnumItem, entry);
1902         IUnknown_AddRef(item->unk);
1903         rgelt[num_fetched] = item->unk;
1904         num_fetched++;
1905         This->cursor = list_next(&This->objects, This->cursor);
1906     }
1907     LeaveCriticalSection(&This->lock);
1908     if (pceltFetched)
1909         *pceltFetched = num_fetched;
1910     return hr;
1911 }
1912
1913 static HRESULT WINAPI ComponentEnum_Skip(IEnumUnknown *iface, ULONG celt)
1914 {
1915     ComponentEnum *This = impl_from_IEnumUnknown(iface);
1916     ULONG i;
1917     HRESULT hr=S_OK;
1918
1919     TRACE("(%p,%u)\n", iface, celt);
1920
1921     EnterCriticalSection(&This->lock);
1922     for (i=0; i<celt; i++)
1923     {
1924         if (!This->cursor)
1925         {
1926             hr = S_FALSE;
1927             break;
1928         }
1929         This->cursor = list_next(&This->objects, This->cursor);
1930     }
1931     LeaveCriticalSection(&This->lock);
1932     return hr;
1933 }
1934
1935 static HRESULT WINAPI ComponentEnum_Reset(IEnumUnknown *iface)
1936 {
1937     ComponentEnum *This = impl_from_IEnumUnknown(iface);
1938
1939     TRACE("(%p)\n", iface);
1940
1941     EnterCriticalSection(&This->lock);
1942     This->cursor = list_head(&This->objects);
1943     LeaveCriticalSection(&This->lock);
1944     return S_OK;
1945 }
1946
1947 static HRESULT WINAPI ComponentEnum_Clone(IEnumUnknown *iface, IEnumUnknown **ppenum)
1948 {
1949     ComponentEnum *This = impl_from_IEnumUnknown(iface);
1950     ComponentEnum *new_enum;
1951     ComponentEnumItem *old_item, *new_item;
1952     HRESULT ret=S_OK;
1953     struct list *old_cursor;
1954
1955     new_enum = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
1956     if (!new_enum)
1957     {
1958         *ppenum = NULL;
1959         return E_OUTOFMEMORY;
1960     }
1961
1962     new_enum->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
1963     new_enum->ref = 1;
1964     new_enum->cursor = NULL;
1965     list_init(&new_enum->objects);
1966     InitializeCriticalSection(&new_enum->lock);
1967     new_enum->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
1968
1969     EnterCriticalSection(&This->lock);
1970     old_cursor = This->cursor;
1971     LeaveCriticalSection(&This->lock);
1972
1973     LIST_FOR_EACH_ENTRY(old_item, &This->objects, ComponentEnumItem, entry)
1974     {
1975         new_item = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnumItem));
1976         if (!new_item)
1977         {
1978             ret = E_OUTOFMEMORY;
1979             break;
1980         }
1981         new_item->unk = old_item->unk;
1982         list_add_tail(&new_enum->objects, &new_item->entry);
1983         IUnknown_AddRef(new_item->unk);
1984         if (&old_item->entry == old_cursor) new_enum->cursor = &new_item->entry;
1985     }
1986
1987     if (FAILED(ret))
1988     {
1989         IEnumUnknown_Release(&new_enum->IEnumUnknown_iface);
1990         *ppenum = NULL;
1991     }
1992     else
1993         *ppenum = &new_enum->IEnumUnknown_iface;
1994
1995     return ret;
1996 }
1997
1998 static const IEnumUnknownVtbl ComponentEnumVtbl = {
1999     ComponentEnum_QueryInterface,
2000     ComponentEnum_AddRef,
2001     ComponentEnum_Release,
2002     ComponentEnum_Next,
2003     ComponentEnum_Skip,
2004     ComponentEnum_Reset,
2005     ComponentEnum_Clone
2006 };
2007
2008 HRESULT CreateComponentEnumerator(DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
2009 {
2010     ComponentEnum *This;
2011     ComponentEnumItem *item;
2012     const struct category *category;
2013     HKEY clsidkey, catidkey, instancekey;
2014     WCHAR guidstring[39];
2015     LONG res;
2016     int i;
2017     HRESULT hr=S_OK;
2018     CLSID clsid;
2019
2020     if (options) FIXME("ignoring flags %x\n", options);
2021
2022     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, KEY_READ, &clsidkey);
2023     if (res != ERROR_SUCCESS)
2024         return HRESULT_FROM_WIN32(res);
2025
2026     This = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnum));
2027     if (!This)
2028     {
2029         RegCloseKey(clsidkey);
2030         return E_OUTOFMEMORY;
2031     }
2032
2033     This->IEnumUnknown_iface.lpVtbl = &ComponentEnumVtbl;
2034     This->ref = 1;
2035     list_init(&This->objects);
2036     InitializeCriticalSection(&This->lock);
2037     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ComponentEnum.lock");
2038
2039     for (category=categories; category->type && hr == S_OK; category++)
2040     {
2041         if ((category->type & componentTypes) == 0) continue;
2042         StringFromGUID2(category->catid, guidstring, 39);
2043         res = RegOpenKeyExW(clsidkey, guidstring, 0, KEY_READ, &catidkey);
2044         if (res == ERROR_SUCCESS)
2045         {
2046             res = RegOpenKeyExW(catidkey, instance_keyname, 0, KEY_READ, &instancekey);
2047             if (res == ERROR_SUCCESS)
2048             {
2049                 i=0;
2050                 for (;;i++)
2051                 {
2052                     DWORD guidstring_size = 39;
2053                     res = RegEnumKeyExW(instancekey, i, guidstring, &guidstring_size, NULL, NULL, NULL, NULL);
2054                     if (res != ERROR_SUCCESS) break;
2055
2056                     item = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentEnumItem));
2057                     if (!item) { hr = E_OUTOFMEMORY; break; }
2058
2059                     hr = CLSIDFromString(guidstring, &clsid);
2060                     if (SUCCEEDED(hr))
2061                     {
2062                         hr = CreateComponentInfo(&clsid, (IWICComponentInfo**)&item->unk);
2063                         if (SUCCEEDED(hr))
2064                             list_add_tail(&This->objects, &item->entry);
2065                     }
2066
2067                     if (FAILED(hr))
2068                     {
2069                         HeapFree(GetProcessHeap(), 0, item);
2070                         hr = S_OK;
2071                     }
2072                 }
2073                 RegCloseKey(instancekey);
2074             }
2075             RegCloseKey(catidkey);
2076         }
2077         if (res != ERROR_SUCCESS && res != ERROR_NO_MORE_ITEMS)
2078             hr = HRESULT_FROM_WIN32(res);
2079     }
2080     RegCloseKey(clsidkey);
2081
2082     if (SUCCEEDED(hr))
2083     {
2084         IEnumUnknown_Reset(&This->IEnumUnknown_iface);
2085         *ppIEnumUnknown = &This->IEnumUnknown_iface;
2086     }
2087     else
2088     {
2089         *ppIEnumUnknown = NULL;
2090         IEnumUnknown_Release(&This->IEnumUnknown_iface);
2091     }
2092
2093     return hr;
2094 }
2095
2096 HRESULT WINAPI WICConvertBitmapSource(REFWICPixelFormatGUID dstFormat, IWICBitmapSource *pISrc, IWICBitmapSource **ppIDst)
2097 {
2098     HRESULT res;
2099     IEnumUnknown *enumconverters;
2100     IUnknown *unkconverterinfo;
2101     IWICFormatConverterInfo *converterinfo=NULL;
2102     IWICFormatConverter *converter=NULL;
2103     GUID srcFormat;
2104     WCHAR srcformatstr[39], dstformatstr[39];
2105     BOOL canconvert;
2106     ULONG num_fetched;
2107
2108     res = IWICBitmapSource_GetPixelFormat(pISrc, &srcFormat);
2109     if (FAILED(res)) return res;
2110
2111     if (IsEqualGUID(&srcFormat, dstFormat))
2112     {
2113         IWICBitmapSource_AddRef(pISrc);
2114         *ppIDst = pISrc;
2115         return S_OK;
2116     }
2117
2118     StringFromGUID2(&srcFormat, srcformatstr, 39);
2119     StringFromGUID2(dstFormat, dstformatstr, 39);
2120
2121     res = CreateComponentEnumerator(WICPixelFormatConverter, 0, &enumconverters);
2122     if (FAILED(res)) return res;
2123
2124     while (!converter)
2125     {
2126         res = IEnumUnknown_Next(enumconverters, 1, &unkconverterinfo, &num_fetched);
2127
2128         if (res == S_OK)
2129         {
2130             res = IUnknown_QueryInterface(unkconverterinfo, &IID_IWICFormatConverterInfo, (void**)&converterinfo);
2131
2132             if (SUCCEEDED(res))
2133             {
2134                 canconvert = ConverterSupportsFormat(converterinfo, srcformatstr);
2135
2136                 if (canconvert)
2137                     canconvert = ConverterSupportsFormat(converterinfo, dstformatstr);
2138
2139                 if (canconvert)
2140                 {
2141                     res = IWICFormatConverterInfo_CreateInstance(converterinfo, &converter);
2142
2143                     if (SUCCEEDED(res))
2144                         res = IWICFormatConverter_CanConvert(converter, &srcFormat, dstFormat, &canconvert);
2145
2146                     if (SUCCEEDED(res) && canconvert)
2147                         res = IWICFormatConverter_Initialize(converter, pISrc, dstFormat, WICBitmapDitherTypeNone,
2148                             NULL, 0.0, WICBitmapPaletteTypeCustom);
2149
2150                     if (FAILED(res) || !canconvert)
2151                     {
2152                         if (converter)
2153                         {
2154                             IWICFormatConverter_Release(converter);
2155                             converter = NULL;
2156                         }
2157                         res = S_OK;
2158                     }
2159                 }
2160
2161                 IWICFormatConverterInfo_Release(converterinfo);
2162             }
2163
2164             IUnknown_Release(unkconverterinfo);
2165         }
2166         else
2167             break;
2168     }
2169
2170     IEnumUnknown_Release(enumconverters);
2171
2172     if (converter)
2173     {
2174         res = IWICFormatConverter_QueryInterface(converter, &IID_IWICBitmapSource, (void **)ppIDst);
2175         IWICFormatConverter_Release(converter);
2176         return res;
2177     }
2178     else
2179     {
2180         FIXME("cannot convert %s to %s\n", debugstr_guid(&srcFormat), debugstr_guid(dstFormat));
2181         *ppIDst = NULL;
2182         return WINCODEC_ERR_COMPONENTNOTFOUND;
2183     }
2184 }