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