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