dlls/windowscodecs/imgfactory.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 "config.h"
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24
  25 #define COBJMACROS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winreg.h"
  30 #include "objbase.h"
  31 #include "shellapi.h"
  32
  33 #include "wincodecs_private.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  38
  39 typedef struct {
  40     IWICImagingFactory2 IWICImagingFactory2_iface;
  41     IWICComponentFactory IWICComponentFactory_iface;
  42     LONG ref;
  43 } ImagingFactory;
  44
  45 static inline ImagingFactory *impl_from_IWICComponentFactory(IWICComponentFactory *iface)
  46 {
  47     return CONTAINING_RECORD(iface, ImagingFactory, IWICComponentFactory_iface);
  48 }
  49
  50 static inline ImagingFactory *impl_from_IWICImagingFactory2(IWICImagingFactory2 *iface)
  51 {
  52     return CONTAINING_RECORD(iface, ImagingFactory, IWICImagingFactory2_iface);
  53 }
  54
  55 static HRESULT WINAPI ImagingFactory_QueryInterface(IWICImagingFactory2 *iface, REFIID iid,
  56     void **ppv)
  57 {
  58     ImagingFactory *This = impl_from_IWICImagingFactory2(iface);
  59     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  60
  61     if (!ppv) return E_INVALIDARG;
  62
  63     if (IsEqualIID(&IID_IUnknown, iid) ||
  64         IsEqualIID(&IID_IWICImagingFactory, iid) ||
  65         IsEqualIID(&IID_IWICComponentFactory, iid))
  66     {
  67         *ppv = &This->IWICComponentFactory_iface;
  68     }
  69     else if (IsEqualIID(&IID_IWICImagingFactory2, iid))
  70     {
  71         *ppv = &This->IWICImagingFactory2_iface;
  72     }
  73     else
  74     {
  75         *ppv = NULL;
  76         return E_NOINTERFACE;
  77     }
  78
  79     IUnknown_AddRef((IUnknown*)*ppv);
  80     return S_OK;
  81 }
  82
  83 static ULONG WINAPI ImagingFactory_AddRef(IWICImagingFactory2 *iface)
  84 {
  85     ImagingFactory *This = impl_from_IWICImagingFactory2(iface);
  86     ULONG ref = InterlockedIncrement(&This->ref);
  87
  88     TRACE("(%p) refcount=%u\n", iface, ref);
  89
  90     return ref;
  91 }
  92
  93 static ULONG WINAPI ImagingFactory_Release(IWICImagingFactory2 *iface)
  94 {
  95     ImagingFactory *This = impl_from_IWICImagingFactory2(iface);
  96     ULONG ref = InterlockedDecrement(&This->ref);
  97
  98     TRACE("(%p) refcount=%u\n", iface, ref);
  99
 100     if (ref == 0)
 101         HeapFree(GetProcessHeap(), 0, This);
 102
 103     return ref;
 104 }
 105
 106 static HRESULT WINAPI ImagingFactory_CreateDecoderFromFilename(
 107     IWICImagingFactory2 *iface, LPCWSTR wzFilename, const GUID *pguidVendor,
 108     DWORD dwDesiredAccess, WICDecodeOptions metadataOptions,
 109     IWICBitmapDecoder **ppIDecoder)
 110 {
 111     IWICStream *stream;
 112     HRESULT hr;
 113
 114     TRACE("(%p,%s,%s,%u,%u,%p)\n", iface, debugstr_w(wzFilename),
 115         debugstr_guid(pguidVendor), dwDesiredAccess, metadataOptions, ppIDecoder);
 116
 117     hr = StreamImpl_Create(&stream);
 118     if (SUCCEEDED(hr))
 119     {
 120         hr = IWICStream_InitializeFromFilename(stream, wzFilename, dwDesiredAccess);
 121
 122         if (SUCCEEDED(hr))
 123         {
 124             hr = IWICImagingFactory2_CreateDecoderFromStream(iface, (IStream*)stream,
 125                 pguidVendor, metadataOptions, ppIDecoder);
 126         }
 127
 128         IWICStream_Release(stream);
 129     }
 130
 131     return hr;
 132 }
 133
 134 static HRESULT find_decoder(IStream *pIStream, const GUID *pguidVendor,
 135                             WICDecodeOptions metadataOptions, IWICBitmapDecoder **decoder)
 136 {
 137     IEnumUnknown *enumdecoders = NULL;
 138     IUnknown *unkdecoderinfo = NULL;
 139     GUID vendor;
 140     HRESULT res, res_wine;
 141     ULONG num_fetched;
 142     BOOL matches, found;
 143
 144     *decoder = NULL;
 145
 146     res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
 147     if (FAILED(res)) return res;
 148
 149     found = FALSE;
 150     while (IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched) == S_OK)
 151     {
 152         IWICBitmapDecoderInfo *decoderinfo = NULL;
 153         IWICWineDecoder *wine_decoder = NULL;
 154
 155         res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
 156         if (FAILED(res)) goto next;
 157
 158         if (pguidVendor)
 159         {
 160             res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
 161             if (FAILED(res) || !IsEqualIID(&vendor, pguidVendor)) goto next;
 162         }
 163
 164         res = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, pIStream, &matches);
 165         if (FAILED(res) || !matches) goto next;
 166
 167         res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, decoder);
 168         if (FAILED(res)) goto next;
 169
 170         /* FIXME: should use QueryCapability to choose a decoder */
 171
 172         found = TRUE;
 173         res = IWICBitmapDecoder_Initialize(*decoder, pIStream, metadataOptions);
 174         if (FAILED(res))
 175         {
 176             res_wine = IWICBitmapDecoder_QueryInterface(*decoder, &IID_IWICWineDecoder, (void **)&wine_decoder);
 177             if (FAILED(res_wine))
 178             {
 179                 IWICBitmapDecoder_Release(*decoder);
 180                 *decoder = NULL;
 181                 goto next;
 182             }
 183
 184             res_wine = IWICWineDecoder_Initialize(wine_decoder, pIStream, metadataOptions);
 185             if (FAILED(res_wine))
 186             {
 187                 IWICBitmapDecoder_Release(*decoder);
 188                 *decoder = NULL;
 189                 goto next;
 190             }
 191
 192             res = res_wine;
 193         }
 194
 195     next:
 196         if (wine_decoder) IWICWineDecoder_Release(wine_decoder);
 197         if (decoderinfo) IWICBitmapDecoderInfo_Release(decoderinfo);
 198         IUnknown_Release(unkdecoderinfo);
 199         if (found) break;
 200     }
 201
 202     IEnumUnknown_Release(enumdecoders);
 203     if (!found) res = WINCODEC_ERR_COMPONENTNOTFOUND;
 204     return res;
 205 }
 206
 207 static HRESULT WINAPI ImagingFactory_CreateDecoderFromStream(
 208     IWICImagingFactory2 *iface, IStream *pIStream, const GUID *pguidVendor,
 209     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 210 {
 211     HRESULT res;
 212     IWICBitmapDecoder *decoder = NULL;
 213
 214     TRACE("(%p,%p,%s,%u,%p)\n", iface, pIStream, debugstr_guid(pguidVendor),
 215         metadataOptions, ppIDecoder);
 216
 217     if (pguidVendor)
 218         res = find_decoder(pIStream, pguidVendor, metadataOptions, &decoder);
 219     if (!decoder)
 220         res = find_decoder(pIStream, NULL, metadataOptions, &decoder);
 221
 222     if (decoder)
 223     {
 224         *ppIDecoder = decoder;
 225         return S_OK;
 226     }
 227     else
 228     {
 229         if (WARN_ON(wincodecs))
 230         {
 231             LARGE_INTEGER seek;
 232             BYTE data[4];
 233             ULONG bytesread;
 234
 235             WARN("failed to load from a stream %#x\n", res);
 236
 237             seek.QuadPart = 0;
 238             if (IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL) == S_OK)
 239             {
 240                 if (IStream_Read(pIStream, data, 4, &bytesread) == S_OK)
 241                     WARN("first %i bytes of stream=%x %x %x %x\n", bytesread, data[0], data[1], data[2], data[3]);
 242             }
 243         }
 244         *ppIDecoder = NULL;
 245         return res;
 246     }
 247 }
 248
 249 static HRESULT WINAPI ImagingFactory_CreateDecoderFromFileHandle(
 250     IWICImagingFactory2 *iface, ULONG_PTR hFile, const GUID *pguidVendor,
 251     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 252 {
 253     IWICStream *stream;
 254     HRESULT hr;
 255
 256     TRACE("(%p,%lx,%s,%u,%p)\n", iface, hFile, debugstr_guid(pguidVendor),
 257         metadataOptions, ppIDecoder);
 258
 259     hr = StreamImpl_Create(&stream);
 260     if (SUCCEEDED(hr))
 261     {
 262         hr = stream_initialize_from_filehandle(stream, (HANDLE)hFile);
 263         if (SUCCEEDED(hr))
 264         {
 265             hr = IWICImagingFactory2_CreateDecoderFromStream(iface, (IStream*)stream,
 266                 pguidVendor, metadataOptions, ppIDecoder);
 267         }
 268         IWICStream_Release(stream);
 269     }
 270     return hr;
 271 }
 272
 273 static HRESULT WINAPI ImagingFactory_CreateComponentInfo(IWICImagingFactory2 *iface,
 274     REFCLSID clsidComponent, IWICComponentInfo **ppIInfo)
 275 {
 276     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(clsidComponent), ppIInfo);
 277     return CreateComponentInfo(clsidComponent, ppIInfo);
 278 }
 279
 280 static HRESULT WINAPI ImagingFactory_CreateDecoder(IWICImagingFactory2 *iface,
 281     REFGUID guidContainerFormat, const GUID *pguidVendor,
 282     IWICBitmapDecoder **ppIDecoder)
 283 {
 284     IEnumUnknown *enumdecoders;
 285     IUnknown *unkdecoderinfo;
 286     IWICBitmapDecoderInfo *decoderinfo;
 287     IWICBitmapDecoder *decoder = NULL, *preferred_decoder = NULL;
 288     GUID vendor;
 289     HRESULT res;
 290     ULONG num_fetched;
 291
 292     TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
 293         debugstr_guid(pguidVendor), ppIDecoder);
 294
 295     if (!guidContainerFormat || !ppIDecoder) return E_INVALIDARG;
 296
 297     res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
 298     if (FAILED(res)) return res;
 299
 300     while (!preferred_decoder)
 301     {
 302         res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
 303         if (res != S_OK) break;
 304
 305         res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void **)&decoderinfo);
 306         if (SUCCEEDED(res))
 307         {
 308             GUID container_guid;
 309
 310             res = IWICBitmapDecoderInfo_GetContainerFormat(decoderinfo, &container_guid);
 311             if (SUCCEEDED(res) && IsEqualIID(&container_guid, guidContainerFormat))
 312             {
 313                 IWICBitmapDecoder *new_decoder;
 314
 315                 res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &new_decoder);
 316                 if (SUCCEEDED(res))
 317                 {
 318                     if (pguidVendor)
 319                     {
 320                         res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
 321                         if (SUCCEEDED(res) && IsEqualIID(&vendor, pguidVendor))
 322                         {
 323                             preferred_decoder = new_decoder;
 324                             new_decoder = NULL;
 325                         }
 326                     }
 327
 328                     if (new_decoder && !decoder)
 329                     {
 330                         decoder = new_decoder;
 331                         new_decoder = NULL;
 332                     }
 333
 334                     if (new_decoder) IWICBitmapDecoder_Release(new_decoder);
 335                 }
 336             }
 337
 338             IWICBitmapDecoderInfo_Release(decoderinfo);
 339         }
 340
 341         IUnknown_Release(unkdecoderinfo);
 342     }
 343
 344     IEnumUnknown_Release(enumdecoders);
 345
 346     if (preferred_decoder)
 347     {
 348         *ppIDecoder = preferred_decoder;
 349         if (decoder) IWICBitmapDecoder_Release(decoder);
 350         return S_OK;
 351     }
 352
 353     if (decoder)
 354     {
 355         *ppIDecoder = decoder;
 356         return S_OK;
 357     }
 358
 359     *ppIDecoder = NULL;
 360     return WINCODEC_ERR_COMPONENTNOTFOUND;
 361 }
 362
 363 static HRESULT WINAPI ImagingFactory_CreateEncoder(IWICImagingFactory2 *iface,
 364     REFGUID guidContainerFormat, const GUID *pguidVendor,
 365     IWICBitmapEncoder **ppIEncoder)
 366 {
 367     static int fixme=0;
 368     IEnumUnknown *enumencoders;
 369     IUnknown *unkencoderinfo;
 370     IWICBitmapEncoderInfo *encoderinfo;
 371     IWICBitmapEncoder *encoder=NULL;
 372     HRESULT res=S_OK;
 373     ULONG num_fetched;
 374     GUID actual_containerformat;
 375
 376     TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
 377         debugstr_guid(pguidVendor), ppIEncoder);
 378
 379     if (pguidVendor && !fixme++)
 380         FIXME("ignoring vendor GUID\n");
 381
 382     res = CreateComponentEnumerator(WICEncoder, WICComponentEnumerateDefault, &enumencoders);
 383     if (FAILED(res)) return res;
 384
 385     while (!encoder)
 386     {
 387         res = IEnumUnknown_Next(enumencoders, 1, &unkencoderinfo, &num_fetched);
 388
 389         if (res == S_OK)
 390         {
 391             res = IUnknown_QueryInterface(unkencoderinfo, &IID_IWICBitmapEncoderInfo, (void**)&encoderinfo);
 392
 393             if (SUCCEEDED(res))
 394             {
 395                 res = IWICBitmapEncoderInfo_GetContainerFormat(encoderinfo, &actual_containerformat);
 396
 397                 if (SUCCEEDED(res) && IsEqualGUID(guidContainerFormat, &actual_containerformat))
 398                 {
 399                     res = IWICBitmapEncoderInfo_CreateInstance(encoderinfo, &encoder);
 400                     if (FAILED(res))
 401                         encoder = NULL;
 402                 }
 403
 404                 IWICBitmapEncoderInfo_Release(encoderinfo);
 405             }
 406
 407             IUnknown_Release(unkencoderinfo);
 408         }
 409         else
 410             break;
 411     }
 412
 413     IEnumUnknown_Release(enumencoders);
 414
 415     if (encoder)
 416     {
 417         *ppIEncoder = encoder;
 418         return S_OK;
 419     }
 420     else
 421     {
 422         WARN("failed to create encoder\n");
 423         *ppIEncoder = NULL;
 424         return WINCODEC_ERR_COMPONENTNOTFOUND;
 425     }
 426 }
 427
 428 static HRESULT WINAPI ImagingFactory_CreatePalette(IWICImagingFactory2 *iface,
 429     IWICPalette **ppIPalette)
 430 {
 431     TRACE("(%p,%p)\n", iface, ppIPalette);
 432     return PaletteImpl_Create(ppIPalette);
 433 }
 434
 435 static HRESULT WINAPI ImagingFactory_CreateFormatConverter(IWICImagingFactory2 *iface,
 436     IWICFormatConverter **ppIFormatConverter)
 437 {
 438     return FormatConverter_CreateInstance(&IID_IWICFormatConverter, (void**)ppIFormatConverter);
 439 }
 440
 441 static HRESULT WINAPI ImagingFactory_CreateBitmapScaler(IWICImagingFactory2 *iface,
 442     IWICBitmapScaler **ppIBitmapScaler)
 443 {
 444     TRACE("(%p,%p)\n", iface, ppIBitmapScaler);
 445
 446     return BitmapScaler_Create(ppIBitmapScaler);
 447 }
 448
 449 static HRESULT WINAPI ImagingFactory_CreateBitmapClipper(IWICImagingFactory2 *iface,
 450     IWICBitmapClipper **ppIBitmapClipper)
 451 {
 452     TRACE("(%p,%p)\n", iface, ppIBitmapClipper);
 453     return BitmapClipper_Create(ppIBitmapClipper);
 454 }
 455
 456 static HRESULT WINAPI ImagingFactory_CreateBitmapFlipRotator(IWICImagingFactory2 *iface,
 457     IWICBitmapFlipRotator **ppIBitmapFlipRotator)
 458 {
 459     TRACE("(%p,%p)\n", iface, ppIBitmapFlipRotator);
 460     return FlipRotator_Create(ppIBitmapFlipRotator);
 461 }
 462
 463 static HRESULT WINAPI ImagingFactory_CreateStream(IWICImagingFactory2 *iface,
 464     IWICStream **ppIWICStream)
 465 {
 466     TRACE("(%p,%p)\n", iface, ppIWICStream);
 467     return StreamImpl_Create(ppIWICStream);
 468 }
 469
 470 static HRESULT WINAPI ImagingFactory_CreateColorContext(IWICImagingFactory2 *iface,
 471     IWICColorContext **ppIColorContext)
 472 {
 473     TRACE("(%p,%p)\n", iface, ppIColorContext);
 474     return ColorContext_Create(ppIColorContext);
 475 }
 476
 477 static HRESULT WINAPI ImagingFactory_CreateColorTransformer(IWICImagingFactory2 *iface,
 478     IWICColorTransform **ppIColorTransform)
 479 {
 480     TRACE("(%p,%p)\n", iface, ppIColorTransform);
 481     return ColorTransform_Create(ppIColorTransform);
 482 }
 483
 484 static HRESULT WINAPI ImagingFactory_CreateBitmap(IWICImagingFactory2 *iface,
 485     UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat,
 486     WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)
 487 {
 488     TRACE("(%p,%u,%u,%s,%u,%p)\n", iface, uiWidth, uiHeight,
 489         debugstr_guid(pixelFormat), option, ppIBitmap);
 490     return BitmapImpl_Create(uiWidth, uiHeight, 0, 0, NULL, 0, pixelFormat, option, ppIBitmap);
 491 }
 492
 493 static HRESULT create_bitmap_from_source_rect(IWICBitmapSource *piBitmapSource, const WICRect *rect,
 494     WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)
 495 {
 496     IWICBitmap *result;
 497     IWICBitmapLock *lock;
 498     IWICPalette *palette;
 499     UINT width, height;
 500     WICPixelFormatGUID pixelformat = {0};
 501     HRESULT hr;
 502     WICRect rc;
 503     double dpix, dpiy;
 504     IWICComponentInfo *info;
 505     IWICPixelFormatInfo2 *formatinfo;
 506     WICPixelFormatNumericRepresentation format_type;
 507
 508     assert(!rect || option == WICBitmapCacheOnLoad);
 509
 510     if (!piBitmapSource || !ppIBitmap)
 511         return E_INVALIDARG;
 512
 513     if (option == WICBitmapNoCache && SUCCEEDED(IWICBitmapSource_QueryInterface(piBitmapSource,
 514             &IID_IWICBitmap, (void **)&result)))
 515     {
 516         *ppIBitmap = result;
 517         return S_OK;
 518     }
 519
 520     hr = IWICBitmapSource_GetSize(piBitmapSource, &width, &height);
 521
 522     if (SUCCEEDED(hr) && rect)
 523     {
 524         if (rect->X >= width || rect->Y >= height || rect->Width == 0 || rect->Height == 0)
 525             return E_INVALIDARG;
 526
 527         width = min(width - rect->X, rect->Width);
 528         height = min(height - rect->Y, rect->Height);
 529     }
 530
 531     if (SUCCEEDED(hr))
 532         hr = IWICBitmapSource_GetPixelFormat(piBitmapSource, &pixelformat);
 533
 534     if (SUCCEEDED(hr))
 535         hr = CreateComponentInfo(&pixelformat, &info);
 536
 537     if (SUCCEEDED(hr))
 538     {
 539         hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo2, (void**)&formatinfo);
 540
 541         if (SUCCEEDED(hr))
 542         {
 543             hr = IWICPixelFormatInfo2_GetNumericRepresentation(formatinfo, &format_type);
 544
 545             IWICPixelFormatInfo2_Release(formatinfo);
 546         }
 547
 548         IWICComponentInfo_Release(info);
 549     }
 550
 551     if (SUCCEEDED(hr))
 552         hr = BitmapImpl_Create(width, height, 0, 0, NULL, 0, &pixelformat, option, &result);
 553
 554     if (SUCCEEDED(hr))
 555     {
 556         hr = IWICBitmap_Lock(result, NULL, WICBitmapLockWrite, &lock);
 557         if (SUCCEEDED(hr))
 558         {
 559             UINT stride, buffersize;
 560             BYTE *buffer;
 561
 562             if (rect)
 563             {
 564                 rc.X = rect->X;
 565                 rc.Y = rect->Y;
 566             }
 567             else
 568                 rc.X = rc.Y = 0;
 569             rc.Width = width;
 570             rc.Height = height;
 571
 572             hr = IWICBitmapLock_GetStride(lock, &stride);
 573
 574             if (SUCCEEDED(hr))
 575                 hr = IWICBitmapLock_GetDataPointer(lock, &buffersize, &buffer);
 576
 577             if (SUCCEEDED(hr))
 578                 hr = IWICBitmapSource_CopyPixels(piBitmapSource, &rc, stride,
 579                     buffersize, buffer);
 580
 581             IWICBitmapLock_Release(lock);
 582         }
 583
 584         if (SUCCEEDED(hr) && (format_type == WICPixelFormatNumericRepresentationUnspecified ||
 585                               format_type == WICPixelFormatNumericRepresentationIndexed))
 586         {
 587             hr = PaletteImpl_Create(&palette);
 588
 589             if (SUCCEEDED(hr))
 590             {
 591                 hr = IWICBitmapSource_CopyPalette(piBitmapSource, palette);
 592
 593                 if (SUCCEEDED(hr))
 594                     hr = IWICBitmap_SetPalette(result, palette);
 595                 else
 596                     hr = S_OK;
 597
 598                 IWICPalette_Release(palette);
 599             }
 600         }
 601
 602         if (SUCCEEDED(hr))
 603         {
 604             hr = IWICBitmapSource_GetResolution(piBitmapSource, &dpix, &dpiy);
 605
 606             if (SUCCEEDED(hr))
 607                 hr = IWICBitmap_SetResolution(result, dpix, dpiy);
 608             else
 609                 hr = S_OK;
 610         }
 611
 612         if (SUCCEEDED(hr))
 613             *ppIBitmap = result;
 614         else
 615             IWICBitmap_Release(result);
 616     }
 617
 618     return hr;
 619 }
 620
 621 static HRESULT WINAPI ImagingFactory_CreateBitmapFromSource(IWICImagingFactory2 *iface,
 622     IWICBitmapSource *piBitmapSource, WICBitmapCreateCacheOption option,
 623     IWICBitmap **ppIBitmap)
 624 {
 625     TRACE("(%p,%p,%u,%p)\n", iface, piBitmapSource, option, ppIBitmap);
 626
 627     return create_bitmap_from_source_rect(piBitmapSource, NULL, option, ppIBitmap);
 628 }
 629
 630 static HRESULT WINAPI ImagingFactory_CreateBitmapFromSourceRect(IWICImagingFactory2 *iface,
 631     IWICBitmapSource *piBitmapSource, UINT x, UINT y, UINT width, UINT height,
 632     IWICBitmap **ppIBitmap)
 633 {
 634     WICRect rect;
 635
 636     TRACE("(%p,%p,%u,%u,%u,%u,%p)\n", iface, piBitmapSource, x, y, width,
 637         height, ppIBitmap);
 638
 639     rect.X = x;
 640     rect.Y = y;
 641     rect.Width = width;
 642     rect.Height = height;
 643
 644     return create_bitmap_from_source_rect(piBitmapSource, &rect, WICBitmapCacheOnLoad, ppIBitmap);
 645 }
 646
 647 static HRESULT WINAPI ImagingFactory_CreateBitmapFromMemory(IWICImagingFactory2 *iface,
 648     UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride,
 649     UINT size, BYTE *buffer, IWICBitmap **bitmap)
 650 {
 651     HRESULT hr;
 652
 653     TRACE("(%p,%u,%u,%s,%u,%u,%p,%p\n", iface, width, height,
 654         debugstr_guid(format), stride, size, buffer, bitmap);
 655
 656     if (!stride || !size || !buffer || !bitmap) return E_INVALIDARG;
 657
 658     hr = BitmapImpl_Create(width, height, stride, size, NULL, 0, format, WICBitmapCacheOnLoad, bitmap);
 659     if (SUCCEEDED(hr))
 660     {
 661         IWICBitmapLock *lock;
 662
 663         hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
 664         if (SUCCEEDED(hr))
 665         {
 666             UINT buffersize;
 667             BYTE *data;
 668
 669             IWICBitmapLock_GetDataPointer(lock, &buffersize, &data);
 670             memcpy(data, buffer, buffersize);
 671
 672             IWICBitmapLock_Release(lock);
 673         }
 674         else
 675         {
 676             IWICBitmap_Release(*bitmap);
 677             *bitmap = NULL;
 678         }
 679     }
 680     return hr;
 681 }
 682
 683 static BOOL get_16bpp_format(HBITMAP hbm, WICPixelFormatGUID *format)
 684 {
 685     BOOL ret = TRUE;
 686     BITMAPV4HEADER bmh;
 687     HDC hdc;
 688
 689     hdc = CreateCompatibleDC(0);
 690
 691     memset(&bmh, 0, sizeof(bmh));
 692     bmh.bV4Size = sizeof(bmh);
 693     bmh.bV4Width = 1;
 694     bmh.bV4Height = 1;
 695     bmh.bV4V4Compression = BI_BITFIELDS;
 696     bmh.bV4BitCount = 16;
 697
 698     GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO *)&bmh, DIB_RGB_COLORS);
 699
 700     if (bmh.bV4RedMask == 0x7c00 &&
 701         bmh.bV4GreenMask == 0x3e0 &&
 702         bmh.bV4BlueMask == 0x1f)
 703     {
 704         *format = GUID_WICPixelFormat16bppBGR555;
 705     }
 706     else if (bmh.bV4RedMask == 0xf800 &&
 707         bmh.bV4GreenMask == 0x7e0 &&
 708         bmh.bV4BlueMask == 0x1f)
 709     {
 710         *format = GUID_WICPixelFormat16bppBGR565;
 711     }
 712     else
 713     {
 714         FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
 715             bmh.bV4GreenMask, bmh.bV4BlueMask);
 716         ret = FALSE;
 717     }
 718
 719     DeleteDC(hdc);
 720     return ret;
 721 }
 722
 723 static HRESULT WINAPI ImagingFactory_CreateBitmapFromHBITMAP(IWICImagingFactory2 *iface,
 724     HBITMAP hbm, HPALETTE hpal, WICBitmapAlphaChannelOption option, IWICBitmap **bitmap)
 725 {
 726     BITMAP bm;
 727     HRESULT hr;
 728     WICPixelFormatGUID format;
 729     IWICBitmapLock *lock;
 730     UINT size, num_palette_entries = 0;
 731     PALETTEENTRY entry[256];
 732
 733     TRACE("(%p,%p,%p,%u,%p)\n", iface, hbm, hpal, option, bitmap);
 734
 735     if (!bitmap) return E_INVALIDARG;
 736
 737     if (GetObjectW(hbm, sizeof(bm), &bm) != sizeof(bm))
 738         return WINCODEC_ERR_WIN32ERROR;
 739
 740     if (hpal)
 741     {
 742         num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
 743         if (!num_palette_entries)
 744             return WINCODEC_ERR_WIN32ERROR;
 745     }
 746
 747     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
 748     switch(bm.bmBitsPixel)
 749     {
 750     case 1:
 751         format = GUID_WICPixelFormat1bppIndexed;
 752         break;
 753     case 4:
 754         format = GUID_WICPixelFormat4bppIndexed;
 755         break;
 756     case 8:
 757         format = GUID_WICPixelFormat8bppIndexed;
 758         break;
 759     case 16:
 760         if (!get_16bpp_format(hbm, &format))
 761             return E_INVALIDARG;
 762         break;
 763     case 24:
 764         format = GUID_WICPixelFormat24bppBGR;
 765         break;
 766     case 32:
 767         switch (option)
 768         {
 769         case WICBitmapUseAlpha:
 770             format = GUID_WICPixelFormat32bppBGRA;
 771             break;
 772         case WICBitmapUsePremultipliedAlpha:
 773             format = GUID_WICPixelFormat32bppPBGRA;
 774             break;
 775         case WICBitmapIgnoreAlpha:
 776             format = GUID_WICPixelFormat32bppBGR;
 777             break;
 778         default:
 779             return E_INVALIDARG;
 780         }
 781         break;
 782     case 48:
 783         format = GUID_WICPixelFormat48bppRGB;
 784         break;
 785     default:
 786         FIXME("unsupported %d bpp\n", bm.bmBitsPixel);
 787         return E_INVALIDARG;
 788     }
 789
 790     hr = BitmapImpl_Create(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, 0, NULL, 0, &format,
 791                            WICBitmapCacheOnLoad, bitmap);
 792     if (hr != S_OK) return hr;
 793
 794     hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
 795     if (hr == S_OK)
 796     {
 797         BYTE *buffer;
 798         HDC hdc;
 799         char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
 800         BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
 801
 802         IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
 803
 804         hdc = CreateCompatibleDC(0);
 805
 806         bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 807         bmi->bmiHeader.biBitCount = 0;
 808         GetDIBits(hdc, hbm, 0, 0, NULL, bmi, DIB_RGB_COLORS);
 809         bmi->bmiHeader.biHeight = -bm.bmHeight;
 810         GetDIBits(hdc, hbm, 0, bm.bmHeight, buffer, bmi, DIB_RGB_COLORS);
 811
 812         DeleteDC(hdc);
 813         IWICBitmapLock_Release(lock);
 814
 815         if (num_palette_entries)
 816         {
 817             IWICPalette *palette;
 818             WICColor colors[256];
 819             UINT i;
 820
 821             hr = PaletteImpl_Create(&palette);
 822             if (hr == S_OK)
 823             {
 824                 for (i = 0; i < num_palette_entries; i++)
 825                     colors[i] = 0xff000000 | entry[i].peRed << 16 |
 826                                 entry[i].peGreen << 8 | entry[i].peBlue;
 827
 828                 hr = IWICPalette_InitializeCustom(palette, colors, num_palette_entries);
 829                 if (hr == S_OK)
 830                     hr = IWICBitmap_SetPalette(*bitmap, palette);
 831
 832                 IWICPalette_Release(palette);
 833             }
 834         }
 835     }
 836
 837     if (hr != S_OK)
 838     {
 839         IWICBitmap_Release(*bitmap);
 840         *bitmap = NULL;
 841     }
 842
 843     return hr;
 844 }
 845
 846 static HRESULT WINAPI ImagingFactory_CreateBitmapFromHICON(IWICImagingFactory2 *iface,
 847     HICON hicon, IWICBitmap **bitmap)
 848 {
 849     IWICBitmapLock *lock;
 850     ICONINFO info;
 851     BITMAP bm;
 852     int width, height, x, y;
 853     UINT stride, size;
 854     BYTE *buffer;
 855     DWORD *bits;
 856     BITMAPINFO bi;
 857     HDC hdc;
 858     BOOL has_alpha;
 859     HRESULT hr;
 860
 861     TRACE("(%p,%p,%p)\n", iface, hicon, bitmap);
 862
 863     if (!bitmap) return E_INVALIDARG;
 864
 865     if (!GetIconInfo(hicon, &info))
 866         return HRESULT_FROM_WIN32(GetLastError());
 867
 868     GetObjectW(info.hbmColor ? info.hbmColor : info.hbmMask, sizeof(bm), &bm);
 869
 870     width = bm.bmWidth;
 871     height = info.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
 872     stride = width * 4;
 873     size = stride * height;
 874
 875     hr = BitmapImpl_Create(width, height, stride, size, NULL, 0,
 876                            &GUID_WICPixelFormat32bppBGRA, WICBitmapCacheOnLoad, bitmap);
 877     if (hr != S_OK) goto failed;
 878
 879     hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
 880     if (hr != S_OK)
 881     {
 882         IWICBitmap_Release(*bitmap);
 883         goto failed;
 884     }
 885     IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
 886
 887     hdc = CreateCompatibleDC(0);
 888
 889     memset(&bi, 0, sizeof(bi));
 890     bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
 891     bi.bmiHeader.biWidth = width;
 892     bi.bmiHeader.biHeight = info.hbmColor ? -height: -height * 2;
 893     bi.bmiHeader.biPlanes = 1;
 894     bi.bmiHeader.biBitCount = 32;
 895     bi.bmiHeader.biCompression = BI_RGB;
 896
 897     has_alpha = FALSE;
 898
 899     if (info.hbmColor)
 900     {
 901         GetDIBits(hdc, info.hbmColor, 0, height, buffer, &bi, DIB_RGB_COLORS);
 902
 903         if (bm.bmBitsPixel == 32)
 904         {
 905             /* If any pixel has a non-zero alpha, ignore hbmMask */
 906             bits = (DWORD *)buffer;
 907             for (x = 0; x < width && !has_alpha; x++, bits++)
 908             {
 909                 for (y = 0; y < height; y++)
 910                 {
 911                     if (*bits & 0xff000000)
 912                     {
 913                         has_alpha = TRUE;
 914                         break;
 915                     }
 916                 }
 917             }
 918         }
 919     }
 920     else
 921         GetDIBits(hdc, info.hbmMask, 0, height, buffer, &bi, DIB_RGB_COLORS);
 922
 923     if (!has_alpha)
 924     {
 925         DWORD *rgba;
 926
 927         if (info.hbmMask)
 928         {
 929             BYTE *mask;
 930
 931             mask = HeapAlloc(GetProcessHeap(), 0, size);
 932             if (!mask)
 933             {
 934                 IWICBitmapLock_Release(lock);
 935                 IWICBitmap_Release(*bitmap);
 936                 DeleteDC(hdc);
 937                 hr = E_OUTOFMEMORY;
 938                 goto failed;
 939             }
 940
 941             /* read alpha data from the mask */
 942             GetDIBits(hdc, info.hbmMask, info.hbmColor ? 0 : height, height, mask, &bi, DIB_RGB_COLORS);
 943
 944             for (y = 0; y < height; y++)
 945             {
 946                 rgba = (DWORD *)(buffer + y * stride);
 947                 bits = (DWORD *)(mask + y * stride);
 948
 949                 for (x = 0; x < width; x++, rgba++, bits++)
 950                 {
 951                     if (*bits)
 952                         *rgba = 0;
 953                     else
 954                         *rgba |= 0xff000000;
 955                 }
 956             }
 957
 958             HeapFree(GetProcessHeap(), 0, mask);
 959         }
 960         else
 961         {
 962             /* set constant alpha of 255 */
 963             for (y = 0; y < height; y++)
 964             {
 965                 rgba = (DWORD *)(buffer + y * stride);
 966                 for (x = 0; x < width; x++, rgba++)
 967                     *rgba |= 0xff000000;
 968             }
 969         }
 970
 971     }
 972
 973     IWICBitmapLock_Release(lock);
 974     DeleteDC(hdc);
 975
 976 failed:
 977     DeleteObject(info.hbmColor);
 978     DeleteObject(info.hbmMask);
 979
 980     return hr;
 981 }
 982
 983 static HRESULT WINAPI ImagingFactory_CreateComponentEnumerator(IWICImagingFactory2 *iface,
 984     DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
 985 {
 986     TRACE("(%p,%u,%u,%p)\n", iface, componentTypes, options, ppIEnumUnknown);
 987     return CreateComponentEnumerator(componentTypes, options, ppIEnumUnknown);
 988 }
 989
 990 static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromDecoder(
 991     IWICImagingFactory2 *iface, IWICBitmapDecoder *pIDecoder,
 992     IWICFastMetadataEncoder **ppIFastEncoder)
 993 {
 994     FIXME("(%p,%p,%p): stub\n", iface, pIDecoder, ppIFastEncoder);
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromFrameDecode(
 999     IWICImagingFactory2 *iface, IWICBitmapFrameDecode *pIFrameDecoder,
1000     IWICFastMetadataEncoder **ppIFastEncoder)
1001 {
1002     FIXME("(%p,%p,%p): stub\n", iface, pIFrameDecoder, ppIFastEncoder);
1003     return E_NOTIMPL;
1004 }
1005
1006 static HRESULT WINAPI ImagingFactory_CreateQueryWriter(IWICImagingFactory2 *iface,
1007     REFGUID guidMetadataFormat, const GUID *pguidVendor,
1008     IWICMetadataQueryWriter **ppIQueryWriter)
1009 {
1010     FIXME("(%p,%s,%s,%p): stub\n", iface, debugstr_guid(guidMetadataFormat),
1011         debugstr_guid(pguidVendor), ppIQueryWriter);
1012     return E_NOTIMPL;
1013 }
1014
1015 static HRESULT WINAPI ImagingFactory_CreateQueryWriterFromReader(IWICImagingFactory2 *iface,
1016     IWICMetadataQueryReader *pIQueryReader, const GUID *pguidVendor,
1017     IWICMetadataQueryWriter **ppIQueryWriter)
1018 {
1019     FIXME("(%p,%p,%s,%p): stub\n", iface, pIQueryReader, debugstr_guid(pguidVendor),
1020         ppIQueryWriter);
1021     return E_NOTIMPL;
1022 }
1023
1024 static HRESULT WINAPI ImagingFactory_CreateImageEncoder(IWICImagingFactory2 *iface, ID2D1Device *device, IWICImageEncoder **encoder)
1025 {
1026     FIXME("%p,%p,%p stub.\n", iface, device, encoder);
1027     return E_NOTIMPL;
1028 }
1029
1030 static const IWICImagingFactory2Vtbl ImagingFactory_Vtbl = {
1031     ImagingFactory_QueryInterface,
1032     ImagingFactory_AddRef,
1033     ImagingFactory_Release,
1034     ImagingFactory_CreateDecoderFromFilename,
1035     ImagingFactory_CreateDecoderFromStream,
1036     ImagingFactory_CreateDecoderFromFileHandle,
1037     ImagingFactory_CreateComponentInfo,
1038     ImagingFactory_CreateDecoder,
1039     ImagingFactory_CreateEncoder,
1040     ImagingFactory_CreatePalette,
1041     ImagingFactory_CreateFormatConverter,
1042     ImagingFactory_CreateBitmapScaler,
1043     ImagingFactory_CreateBitmapClipper,
1044     ImagingFactory_CreateBitmapFlipRotator,
1045     ImagingFactory_CreateStream,
1046     ImagingFactory_CreateColorContext,
1047     ImagingFactory_CreateColorTransformer,
1048     ImagingFactory_CreateBitmap,
1049     ImagingFactory_CreateBitmapFromSource,
1050     ImagingFactory_CreateBitmapFromSourceRect,
1051     ImagingFactory_CreateBitmapFromMemory,
1052     ImagingFactory_CreateBitmapFromHBITMAP,
1053     ImagingFactory_CreateBitmapFromHICON,
1054     ImagingFactory_CreateComponentEnumerator,
1055     ImagingFactory_CreateFastMetadataEncoderFromDecoder,
1056     ImagingFactory_CreateFastMetadataEncoderFromFrameDecode,
1057     ImagingFactory_CreateQueryWriter,
1058     ImagingFactory_CreateQueryWriterFromReader,
1059     ImagingFactory_CreateImageEncoder,
1060 };
1061
1062 static HRESULT WINAPI ComponentFactory_QueryInterface(IWICComponentFactory *iface, REFIID iid, void **ppv)
1063 {
1064     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1065     return IWICImagingFactory2_QueryInterface(&This->IWICImagingFactory2_iface, iid, ppv);
1066 }
1067
1068 static ULONG WINAPI ComponentFactory_AddRef(IWICComponentFactory *iface)
1069 {
1070     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1071     return IWICImagingFactory2_AddRef(&This->IWICImagingFactory2_iface);
1072 }
1073
1074 static ULONG WINAPI ComponentFactory_Release(IWICComponentFactory *iface)
1075 {
1076     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1077     return IWICImagingFactory2_Release(&This->IWICImagingFactory2_iface);
1078 }
1079
1080 static HRESULT WINAPI ComponentFactory_CreateDecoderFromFilename(IWICComponentFactory *iface, LPCWSTR filename,
1081     const GUID *vendor, DWORD desired_access, WICDecodeOptions options, IWICBitmapDecoder **decoder)
1082 {
1083     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1084     return IWICImagingFactory2_CreateDecoderFromFilename(&This->IWICImagingFactory2_iface, filename, vendor,
1085         desired_access, options, decoder);
1086 }
1087
1088 static HRESULT WINAPI ComponentFactory_CreateDecoderFromStream(IWICComponentFactory *iface, IStream *stream,
1089     const GUID *vendor, WICDecodeOptions options, IWICBitmapDecoder **decoder)
1090 {
1091     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1092     return IWICImagingFactory2_CreateDecoderFromStream(&This->IWICImagingFactory2_iface, stream, vendor,
1093         options, decoder);
1094 }
1095
1096 static HRESULT WINAPI ComponentFactory_CreateDecoderFromFileHandle(IWICComponentFactory *iface, ULONG_PTR hFile,
1097     const GUID *vendor, WICDecodeOptions options, IWICBitmapDecoder **decoder)
1098 {
1099     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1100     return IWICImagingFactory2_CreateDecoderFromFileHandle(&This->IWICImagingFactory2_iface, hFile, vendor,
1101         options, decoder);
1102 }
1103
1104 static HRESULT WINAPI ComponentFactory_CreateComponentInfo(IWICComponentFactory *iface, REFCLSID component,
1105     IWICComponentInfo **info)
1106 {
1107     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1108     return IWICImagingFactory2_CreateComponentInfo(&This->IWICImagingFactory2_iface, component, info);
1109 }
1110
1111 static HRESULT WINAPI ComponentFactory_CreateDecoder(IWICComponentFactory *iface, REFGUID format, const GUID *vendor,
1112     IWICBitmapDecoder **decoder)
1113 {
1114     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1115     return IWICImagingFactory2_CreateDecoder(&This->IWICImagingFactory2_iface, format, vendor, decoder);
1116 }
1117
1118 static HRESULT WINAPI ComponentFactory_CreateEncoder(IWICComponentFactory *iface, REFGUID format, const GUID *vendor,
1119     IWICBitmapEncoder **encoder)
1120 {
1121     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1122     return IWICImagingFactory2_CreateEncoder(&This->IWICImagingFactory2_iface, format, vendor, encoder);
1123 }
1124
1125 static HRESULT WINAPI ComponentFactory_CreatePalette(IWICComponentFactory *iface, IWICPalette **palette)
1126 {
1127     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1128     return IWICImagingFactory2_CreatePalette(&This->IWICImagingFactory2_iface, palette);
1129 }
1130
1131 static HRESULT WINAPI ComponentFactory_CreateFormatConverter(IWICComponentFactory *iface, IWICFormatConverter **converter)
1132 {
1133     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1134     return IWICImagingFactory2_CreateFormatConverter(&This->IWICImagingFactory2_iface, converter);
1135 }
1136
1137 static HRESULT WINAPI ComponentFactory_CreateBitmapScaler(IWICComponentFactory *iface, IWICBitmapScaler **scaler)
1138 {
1139     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1140     return IWICImagingFactory2_CreateBitmapScaler(&This->IWICImagingFactory2_iface, scaler);
1141 }
1142
1143 static HRESULT WINAPI ComponentFactory_CreateBitmapClipper(IWICComponentFactory *iface, IWICBitmapClipper **clipper)
1144 {
1145     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1146     return IWICImagingFactory2_CreateBitmapClipper(&This->IWICImagingFactory2_iface, clipper);
1147 }
1148
1149 static HRESULT WINAPI ComponentFactory_CreateBitmapFlipRotator(IWICComponentFactory *iface, IWICBitmapFlipRotator **fliprotator)
1150 {
1151     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1152     return IWICImagingFactory2_CreateBitmapFlipRotator(&This->IWICImagingFactory2_iface, fliprotator);
1153 }
1154
1155 static HRESULT WINAPI ComponentFactory_CreateStream(IWICComponentFactory *iface, IWICStream **stream)
1156 {
1157     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1158     return IWICImagingFactory2_CreateStream(&This->IWICImagingFactory2_iface, stream);
1159 }
1160
1161 static HRESULT WINAPI ComponentFactory_CreateColorContext(IWICComponentFactory *iface, IWICColorContext **context)
1162 {
1163     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1164     return IWICImagingFactory2_CreateColorContext(&This->IWICImagingFactory2_iface, context);
1165 }
1166
1167 static HRESULT WINAPI ComponentFactory_CreateColorTransformer(IWICComponentFactory *iface, IWICColorTransform **transformer)
1168 {
1169     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1170     return IWICImagingFactory2_CreateColorTransformer(&This->IWICImagingFactory2_iface, transformer);
1171 }
1172
1173 static HRESULT WINAPI ComponentFactory_CreateBitmap(IWICComponentFactory *iface, UINT width, UINT height, REFWICPixelFormatGUID pixel_format,
1174     WICBitmapCreateCacheOption option, IWICBitmap **bitmap)
1175 {
1176     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1177     return IWICImagingFactory2_CreateBitmap(&This->IWICImagingFactory2_iface, width, height, pixel_format, option, bitmap);
1178 }
1179
1180 static HRESULT WINAPI ComponentFactory_CreateBitmapFromSource(IWICComponentFactory *iface, IWICBitmapSource *source,
1181     WICBitmapCreateCacheOption option, IWICBitmap **bitmap)
1182 {
1183     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1184     return IWICImagingFactory2_CreateBitmapFromSource(&This->IWICImagingFactory2_iface, source, option, bitmap);
1185 }
1186
1187 static HRESULT WINAPI ComponentFactory_CreateBitmapFromSourceRect(IWICComponentFactory *iface, IWICBitmapSource *source,
1188     UINT x, UINT y, UINT width, UINT height, IWICBitmap **bitmap)
1189 {
1190     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1191     return IWICImagingFactory2_CreateBitmapFromSourceRect(&This->IWICImagingFactory2_iface, source, x, y, width, height, bitmap);
1192 }
1193
1194 static HRESULT WINAPI ComponentFactory_CreateBitmapFromMemory(IWICComponentFactory *iface, UINT width, UINT height,
1195     REFWICPixelFormatGUID format, UINT stride, UINT size, BYTE *buffer, IWICBitmap **bitmap)
1196 {
1197     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1198     return IWICImagingFactory2_CreateBitmapFromMemory(&This->IWICImagingFactory2_iface, width, height, format, stride,
1199         size, buffer, bitmap);
1200 }
1201
1202 static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP(IWICComponentFactory *iface, HBITMAP hbm, HPALETTE hpal,
1203     WICBitmapAlphaChannelOption option, IWICBitmap **bitmap)
1204 {
1205     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1206     return IWICImagingFactory2_CreateBitmapFromHBITMAP(&This->IWICImagingFactory2_iface, hbm, hpal, option, bitmap);
1207 }
1208
1209 static HRESULT WINAPI ComponentFactory_CreateBitmapFromHICON(IWICComponentFactory *iface, HICON hicon, IWICBitmap **bitmap)
1210 {
1211     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1212     return IWICImagingFactory2_CreateBitmapFromHICON(&This->IWICImagingFactory2_iface, hicon, bitmap);
1213 }
1214
1215 static HRESULT WINAPI ComponentFactory_CreateComponentEnumerator(IWICComponentFactory *iface, DWORD component_types,
1216     DWORD options, IEnumUnknown **enumerator)
1217 {
1218     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1219     return IWICImagingFactory2_CreateComponentEnumerator(&This->IWICImagingFactory2_iface, component_types,
1220         options, enumerator);
1221 }
1222
1223 static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromDecoder(IWICComponentFactory *iface, IWICBitmapDecoder *decoder,
1224     IWICFastMetadataEncoder **encoder)
1225 {
1226     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1227     return IWICImagingFactory2_CreateFastMetadataEncoderFromDecoder(&This->IWICImagingFactory2_iface, decoder, encoder);
1228 }
1229
1230 static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromFrameDecode(IWICComponentFactory *iface,
1231     IWICBitmapFrameDecode *frame_decode, IWICFastMetadataEncoder **encoder)
1232 {
1233     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1234     return IWICImagingFactory2_CreateFastMetadataEncoderFromFrameDecode(&This->IWICImagingFactory2_iface, frame_decode, encoder);
1235 }
1236
1237 static HRESULT WINAPI ComponentFactory_CreateQueryWriter(IWICComponentFactory *iface, REFGUID format, const GUID *vendor,
1238     IWICMetadataQueryWriter **writer)
1239 {
1240     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1241     return IWICImagingFactory2_CreateQueryWriter(&This->IWICImagingFactory2_iface, format, vendor, writer);
1242 }
1243
1244 static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromReader(IWICComponentFactory *iface, IWICMetadataQueryReader *reader,
1245     const GUID *vendor, IWICMetadataQueryWriter **writer)
1246 {
1247     ImagingFactory *This = impl_from_IWICComponentFactory(iface);
1248     return IWICImagingFactory2_CreateQueryWriterFromReader(&This->IWICImagingFactory2_iface, reader, vendor, writer);
1249 }
1250
1251 static HRESULT WINAPI ComponentFactory_CreateMetadataReader(IWICComponentFactory *iface,
1252         REFGUID format, const GUID *vendor, DWORD options, IStream *stream, IWICMetadataReader **reader)
1253 {
1254     FIXME("%p,%s,%s,%x,%p,%p: stub\n", iface, debugstr_guid(format), debugstr_guid(vendor),
1255         options, stream, reader);
1256     return E_NOTIMPL;
1257 }
1258
1259 static HRESULT WINAPI ComponentFactory_CreateMetadataReaderFromContainer(IWICComponentFactory *iface,
1260         REFGUID format, const GUID *vendor, DWORD options, IStream *stream, IWICMetadataReader **reader)
1261 {
1262     HRESULT hr;
1263     IEnumUnknown *enumreaders;
1264     IUnknown *unkreaderinfo;
1265     IWICMetadataReaderInfo *readerinfo;
1266     IWICPersistStream *wicpersiststream;
1267     ULONG num_fetched;
1268     GUID decoder_vendor;
1269     BOOL matches;
1270     LARGE_INTEGER zero;
1271
1272     TRACE("%p,%s,%s,%x,%p,%p\n", iface, debugstr_guid(format), debugstr_guid(vendor),
1273         options, stream, reader);
1274
1275     if (!format || !stream || !reader)
1276         return E_INVALIDARG;
1277
1278     zero.QuadPart = 0;
1279
1280     hr = CreateComponentEnumerator(WICMetadataReader, WICComponentEnumerateDefault, &enumreaders);
1281     if (FAILED(hr)) return hr;
1282
1283     *reader = NULL;
1284
1285 start:
1286     while (!*reader)
1287     {
1288         hr = IEnumUnknown_Next(enumreaders, 1, &unkreaderinfo, &num_fetched);
1289
1290         if (hr == S_OK)
1291         {
1292             hr = IUnknown_QueryInterface(unkreaderinfo, &IID_IWICMetadataReaderInfo, (void**)&readerinfo);
1293
1294             if (SUCCEEDED(hr))
1295             {
1296                 if (vendor)
1297                 {
1298                     hr = IWICMetadataReaderInfo_GetVendorGUID(readerinfo, &decoder_vendor);
1299
1300                     if (FAILED(hr) || !IsEqualIID(vendor, &decoder_vendor))
1301                     {
1302                         IWICMetadataReaderInfo_Release(readerinfo);
1303                         IUnknown_Release(unkreaderinfo);
1304                         continue;
1305                     }
1306                 }
1307
1308                 hr = IWICMetadataReaderInfo_MatchesPattern(readerinfo, format, stream, &matches);
1309
1310                 if (SUCCEEDED(hr) && matches)
1311                 {
1312                     hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1313
1314                     if (SUCCEEDED(hr))
1315                         hr = IWICMetadataReaderInfo_CreateInstance(readerinfo, reader);
1316
1317                     if (SUCCEEDED(hr))
1318                     {
1319                         hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
1320
1321                         if (SUCCEEDED(hr))
1322                         {
1323                             hr = IWICPersistStream_LoadEx(wicpersiststream,
1324                                 stream, vendor, options & WICPersistOptionMask);
1325
1326                             IWICPersistStream_Release(wicpersiststream);
1327                         }
1328
1329                         if (FAILED(hr))
1330                         {
1331                             IWICMetadataReader_Release(*reader);
1332                             *reader = NULL;
1333                         }
1334                     }
1335                 }
1336
1337                 IUnknown_Release(readerinfo);
1338             }
1339
1340             IUnknown_Release(unkreaderinfo);
1341         }
1342         else
1343             break;
1344     }
1345
1346     if (!*reader && vendor)
1347     {
1348         vendor = NULL;
1349         IEnumUnknown_Reset(enumreaders);
1350         goto start;
1351     }
1352
1353     IEnumUnknown_Release(enumreaders);
1354
1355     if (!*reader && !(options & WICMetadataCreationFailUnknown))
1356     {
1357         hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1358
1359         if (SUCCEEDED(hr))
1360             hr = UnknownMetadataReader_CreateInstance(&IID_IWICMetadataReader, (void**)reader);
1361
1362         if (SUCCEEDED(hr))
1363         {
1364             hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
1365
1366             if (SUCCEEDED(hr))
1367             {
1368                 hr = IWICPersistStream_LoadEx(wicpersiststream, stream, NULL, options & WICPersistOptionMask);
1369
1370                 IWICPersistStream_Release(wicpersiststream);
1371             }
1372
1373             if (FAILED(hr))
1374             {
1375                 IWICMetadataReader_Release(*reader);
1376                 *reader = NULL;
1377             }
1378         }
1379     }
1380
1381     if (*reader)
1382         return S_OK;
1383     else
1384         return WINCODEC_ERR_COMPONENTNOTFOUND;
1385 }
1386
1387 static HRESULT WINAPI ComponentFactory_CreateMetadataWriter(IWICComponentFactory *iface,
1388         REFGUID format, const GUID *vendor, DWORD options, IWICMetadataWriter **writer)
1389 {
1390     FIXME("%p,%s,%s,%x,%p: stub\n", iface, debugstr_guid(format), debugstr_guid(vendor), options, writer);
1391     return E_NOTIMPL;
1392 }
1393
1394 static HRESULT WINAPI ComponentFactory_CreateMetadataWriterFromReader(IWICComponentFactory *iface,
1395         IWICMetadataReader *reader, const GUID *vendor, IWICMetadataWriter **writer)
1396 {
1397     FIXME("%p,%p,%s,%p: stub\n", iface, reader, debugstr_guid(vendor), writer);
1398     return E_NOTIMPL;
1399 }
1400
1401 static HRESULT WINAPI ComponentFactory_CreateQueryReaderFromBlockReader(IWICComponentFactory *iface,
1402         IWICMetadataBlockReader *block_reader, IWICMetadataQueryReader **query_reader)
1403 {
1404     TRACE("%p,%p,%p\n", iface, block_reader, query_reader);
1405
1406     if (!block_reader || !query_reader)
1407         return E_INVALIDARG;
1408
1409     return MetadataQueryReader_CreateInstance(block_reader, NULL, query_reader);
1410 }
1411
1412 static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromBlockWriter(IWICComponentFactory *iface,
1413         IWICMetadataBlockWriter *block_writer, IWICMetadataQueryWriter **query_writer)
1414 {
1415     FIXME("%p,%p,%p: stub\n", iface, block_writer, query_writer);
1416     return E_NOTIMPL;
1417 }
1418
1419 static HRESULT WINAPI ComponentFactory_CreateEncoderPropertyBag(IWICComponentFactory *iface,
1420         PROPBAG2 *options, UINT count, IPropertyBag2 **property)
1421 {
1422     TRACE("(%p,%p,%u,%p)\n", iface, options, count, property);
1423     return CreatePropertyBag2(options, count, property);
1424 }
1425
1426 static const IWICComponentFactoryVtbl ComponentFactory_Vtbl = {
1427     ComponentFactory_QueryInterface,
1428     ComponentFactory_AddRef,
1429     ComponentFactory_Release,
1430     ComponentFactory_CreateDecoderFromFilename,
1431     ComponentFactory_CreateDecoderFromStream,
1432     ComponentFactory_CreateDecoderFromFileHandle,
1433     ComponentFactory_CreateComponentInfo,
1434     ComponentFactory_CreateDecoder,
1435     ComponentFactory_CreateEncoder,
1436     ComponentFactory_CreatePalette,
1437     ComponentFactory_CreateFormatConverter,
1438     ComponentFactory_CreateBitmapScaler,
1439     ComponentFactory_CreateBitmapClipper,
1440     ComponentFactory_CreateBitmapFlipRotator,
1441     ComponentFactory_CreateStream,
1442     ComponentFactory_CreateColorContext,
1443     ComponentFactory_CreateColorTransformer,
1444     ComponentFactory_CreateBitmap,
1445     ComponentFactory_CreateBitmapFromSource,
1446     ComponentFactory_CreateBitmapFromSourceRect,
1447     ComponentFactory_CreateBitmapFromMemory,
1448     ComponentFactory_CreateBitmapFromHBITMAP,
1449     ComponentFactory_CreateBitmapFromHICON,
1450     ComponentFactory_CreateComponentEnumerator,
1451     ComponentFactory_CreateFastMetadataEncoderFromDecoder,
1452     ComponentFactory_CreateFastMetadataEncoderFromFrameDecode,
1453     ComponentFactory_CreateQueryWriter,
1454     ComponentFactory_CreateQueryWriterFromReader,
1455     ComponentFactory_CreateMetadataReader,
1456     ComponentFactory_CreateMetadataReaderFromContainer,
1457     ComponentFactory_CreateMetadataWriter,
1458     ComponentFactory_CreateMetadataWriterFromReader,
1459     ComponentFactory_CreateQueryReaderFromBlockReader,
1460     ComponentFactory_CreateQueryWriterFromBlockWriter,
1461     ComponentFactory_CreateEncoderPropertyBag
1462 };
1463
1464 HRESULT ImagingFactory_CreateInstance(REFIID iid, void** ppv)
1465 {
1466     ImagingFactory *This;
1467     HRESULT ret;
1468
1469     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1470
1471     *ppv = NULL;
1472
1473     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1474     if (!This) return E_OUTOFMEMORY;
1475
1476     This->IWICImagingFactory2_iface.lpVtbl = &ImagingFactory_Vtbl;
1477     This->IWICComponentFactory_iface.lpVtbl = &ComponentFactory_Vtbl;
1478     This->ref = 1;
1479
1480     ret = IWICImagingFactory2_QueryInterface(&This->IWICImagingFactory2_iface, iid, ppv);
1481     IWICImagingFactory2_Release(&This->IWICImagingFactory2_iface);
1482
1483     return ret;
1484 }
1485
1486 HRESULT WINAPI WICCreateBitmapFromSectionEx(UINT width, UINT height,
1487         REFWICPixelFormatGUID format, HANDLE section, UINT stride,
1488         UINT offset, WICSectionAccessLevel wicaccess, IWICBitmap **bitmap)
1489 {
1490     SYSTEM_INFO sysinfo;
1491     UINT bpp, access, size, view_offset, view_size;
1492     void *view;
1493     HRESULT hr;
1494
1495     TRACE("%u,%u,%s,%p,%u,%u,%#x,%p\n", width, height, debugstr_guid(format),
1496           section, stride, offset, wicaccess, bitmap);
1497
1498     if (!width || !height || !section || !bitmap) return E_INVALIDARG;
1499
1500     hr = get_pixelformat_bpp(format, &bpp);
1501     if (FAILED(hr)) return hr;
1502
1503     switch (wicaccess)
1504     {
1505     case WICSectionAccessLevelReadWrite:
1506         access = FILE_MAP_READ | FILE_MAP_WRITE;
1507         break;
1508
1509     case WICSectionAccessLevelRead:
1510         access = FILE_MAP_READ;
1511         break;
1512
1513     default:
1514         FIXME("unsupported access %#x\n", wicaccess);
1515         return E_INVALIDARG;
1516     }
1517
1518     if (!stride) stride = (((bpp * width) + 31) / 32) * 4;
1519     size = stride * height;
1520     if (size / height != stride) return E_INVALIDARG;
1521
1522     GetSystemInfo(&sysinfo);
1523     view_offset = offset - (offset % sysinfo.dwAllocationGranularity);
1524     view_size = size + (offset - view_offset);
1525
1526     view = MapViewOfFile(section, access, 0, view_offset, view_size);
1527     if (!view) return HRESULT_FROM_WIN32(GetLastError());
1528
1529     offset -= view_offset;
1530     hr = BitmapImpl_Create(width, height, stride, 0, view, offset, format, WICBitmapCacheOnLoad, bitmap);
1531     if (FAILED(hr)) UnmapViewOfFile(view);
1532     return hr;
1533 }
1534
1535 HRESULT WINAPI WICCreateBitmapFromSection(UINT width, UINT height,
1536         REFWICPixelFormatGUID format, HANDLE section,
1537         UINT stride, UINT offset, IWICBitmap **bitmap)
1538 {
1539     TRACE("%u,%u,%s,%p,%u,%u,%p\n", width, height, debugstr_guid(format),
1540         section, stride, offset, bitmap);
1541
1542     return WICCreateBitmapFromSectionEx(width, height, format, section,
1543         stride, offset, WICSectionAccessLevelRead, bitmap);
1544 }