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 <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "objbase.h"
  30 #include "shellapi.h"
  31 #include "wincodec.h"
  32 #include "wincodecsdk.h"
  33
  34 #include "wincodecs_private.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  39
  40 typedef struct {
  41     IWICComponentFactory IWICComponentFactory_iface;
  42     LONG ref;
  43 } ComponentFactory;
  44
  45 static inline ComponentFactory *impl_from_IWICComponentFactory(IWICComponentFactory *iface)
  46 {
  47     return CONTAINING_RECORD(iface, ComponentFactory, IWICComponentFactory_iface);
  48 }
  49
  50 static HRESULT WINAPI ComponentFactory_QueryInterface(IWICComponentFactory *iface, REFIID iid,
  51     void **ppv)
  52 {
  53     ComponentFactory *This = impl_from_IWICComponentFactory(iface);
  54     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  55
  56     if (!ppv) return E_INVALIDARG;
  57
  58     if (IsEqualIID(&IID_IUnknown, iid) ||
  59         IsEqualIID(&IID_IWICImagingFactory, iid) ||
  60         IsEqualIID(&IID_IWICComponentFactory, iid))
  61     {
  62         *ppv = &This->IWICComponentFactory_iface;
  63     }
  64     else
  65     {
  66         *ppv = NULL;
  67         return E_NOINTERFACE;
  68     }
  69
  70     IUnknown_AddRef((IUnknown*)*ppv);
  71     return S_OK;
  72 }
  73
  74 static ULONG WINAPI ComponentFactory_AddRef(IWICComponentFactory *iface)
  75 {
  76     ComponentFactory *This = impl_from_IWICComponentFactory(iface);
  77     ULONG ref = InterlockedIncrement(&This->ref);
  78
  79     TRACE("(%p) refcount=%u\n", iface, ref);
  80
  81     return ref;
  82 }
  83
  84 static ULONG WINAPI ComponentFactory_Release(IWICComponentFactory *iface)
  85 {
  86     ComponentFactory *This = impl_from_IWICComponentFactory(iface);
  87     ULONG ref = InterlockedDecrement(&This->ref);
  88
  89     TRACE("(%p) refcount=%u\n", iface, ref);
  90
  91     if (ref == 0)
  92         HeapFree(GetProcessHeap(), 0, This);
  93
  94     return ref;
  95 }
  96
  97 static HRESULT WINAPI ComponentFactory_CreateDecoderFromFilename(
  98     IWICComponentFactory *iface, LPCWSTR wzFilename, const GUID *pguidVendor,
  99     DWORD dwDesiredAccess, WICDecodeOptions metadataOptions,
 100     IWICBitmapDecoder **ppIDecoder)
 101 {
 102     IWICStream *stream;
 103     HRESULT hr;
 104
 105     TRACE("(%p,%s,%s,%u,%u,%p)\n", iface, debugstr_w(wzFilename),
 106         debugstr_guid(pguidVendor), dwDesiredAccess, metadataOptions, ppIDecoder);
 107
 108     hr = StreamImpl_Create(&stream);
 109     if (SUCCEEDED(hr))
 110     {
 111         hr = IWICStream_InitializeFromFilename(stream, wzFilename, dwDesiredAccess);
 112
 113         if (SUCCEEDED(hr))
 114         {
 115             hr = IWICComponentFactory_CreateDecoderFromStream(iface, (IStream*)stream,
 116                 pguidVendor, metadataOptions, ppIDecoder);
 117         }
 118
 119         IWICStream_Release(stream);
 120     }
 121
 122     return hr;
 123 }
 124
 125 static IWICBitmapDecoder *find_decoder(IStream *pIStream, const GUID *pguidVendor,
 126                                        WICDecodeOptions metadataOptions)
 127 {
 128     IEnumUnknown *enumdecoders;
 129     IUnknown *unkdecoderinfo;
 130     IWICBitmapDecoderInfo *decoderinfo;
 131     IWICBitmapDecoder *decoder = NULL;
 132     GUID vendor;
 133     HRESULT res;
 134     ULONG num_fetched;
 135     BOOL matches;
 136
 137     res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
 138     if (FAILED(res)) return NULL;
 139
 140     while (!decoder)
 141     {
 142         res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
 143
 144         if (res == S_OK)
 145         {
 146             res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
 147
 148             if (SUCCEEDED(res))
 149             {
 150                 if (pguidVendor)
 151                 {
 152                     res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
 153                     if (FAILED(res) || !IsEqualIID(&vendor, pguidVendor))
 154                     {
 155                         IWICBitmapDecoderInfo_Release(decoderinfo);
 156                         IUnknown_Release(unkdecoderinfo);
 157                         continue;
 158                     }
 159                 }
 160
 161                 res = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, pIStream, &matches);
 162
 163                 if (SUCCEEDED(res) && matches)
 164                 {
 165                     res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
 166
 167                     /* FIXME: should use QueryCapability to choose a decoder */
 168
 169                     if (SUCCEEDED(res))
 170                     {
 171                         res = IWICBitmapDecoder_Initialize(decoder, pIStream, metadataOptions);
 172
 173                         if (FAILED(res))
 174                         {
 175                             IWICBitmapDecoder_Release(decoder);
 176                             decoder = NULL;
 177                         }
 178                     }
 179                 }
 180
 181                 IWICBitmapDecoderInfo_Release(decoderinfo);
 182             }
 183
 184             IUnknown_Release(unkdecoderinfo);
 185         }
 186         else
 187             break;
 188     }
 189
 190     IEnumUnknown_Release(enumdecoders);
 191
 192     return decoder;
 193 }
 194
 195 static HRESULT WINAPI ComponentFactory_CreateDecoderFromStream(
 196     IWICComponentFactory *iface, IStream *pIStream, const GUID *pguidVendor,
 197     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 198 {
 199     HRESULT res;
 200     IWICBitmapDecoder *decoder = NULL;
 201
 202     TRACE("(%p,%p,%s,%u,%p)\n", iface, pIStream, debugstr_guid(pguidVendor),
 203         metadataOptions, ppIDecoder);
 204
 205     if (pguidVendor)
 206         decoder = find_decoder(pIStream, pguidVendor, metadataOptions);
 207     if (!decoder)
 208         decoder = find_decoder(pIStream, NULL, metadataOptions);
 209
 210     if (decoder)
 211     {
 212         *ppIDecoder = decoder;
 213         return S_OK;
 214     }
 215     else
 216     {
 217         if (WARN_ON(wincodecs))
 218         {
 219             LARGE_INTEGER seek;
 220             BYTE data[4];
 221             ULONG bytesread;
 222
 223             WARN("failed to load from a stream\n");
 224
 225             seek.QuadPart = 0;
 226             res = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
 227             if (SUCCEEDED(res))
 228                 res = IStream_Read(pIStream, data, 4, &bytesread);
 229             if (SUCCEEDED(res))
 230                 WARN("first %i bytes of stream=%x %x %x %x\n", bytesread, data[0], data[1], data[2], data[3]);
 231         }
 232         *ppIDecoder = NULL;
 233         return WINCODEC_ERR_COMPONENTNOTFOUND;
 234     }
 235 }
 236
 237 static HRESULT WINAPI ComponentFactory_CreateDecoderFromFileHandle(
 238     IWICComponentFactory *iface, ULONG_PTR hFile, const GUID *pguidVendor,
 239     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 240 {
 241     IWICStream *stream;
 242     HRESULT hr;
 243
 244     TRACE("(%p,%lx,%s,%u,%p)\n", iface, hFile, debugstr_guid(pguidVendor),
 245         metadataOptions, ppIDecoder);
 246
 247     hr = StreamImpl_Create(&stream);
 248     if (SUCCEEDED(hr))
 249     {
 250         hr = stream_initialize_from_filehandle(stream, (HANDLE)hFile);
 251         if (SUCCEEDED(hr))
 252         {
 253             hr = IWICComponentFactory_CreateDecoderFromStream(iface, (IStream*)stream,
 254                 pguidVendor, metadataOptions, ppIDecoder);
 255         }
 256         IWICStream_Release(stream);
 257     }
 258     return hr;
 259 }
 260
 261 static HRESULT WINAPI ComponentFactory_CreateComponentInfo(IWICComponentFactory *iface,
 262     REFCLSID clsidComponent, IWICComponentInfo **ppIInfo)
 263 {
 264     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(clsidComponent), ppIInfo);
 265     return CreateComponentInfo(clsidComponent, ppIInfo);
 266 }
 267
 268 static HRESULT WINAPI ComponentFactory_CreateDecoder(IWICComponentFactory *iface,
 269     REFGUID guidContainerFormat, const GUID *pguidVendor,
 270     IWICBitmapDecoder **ppIDecoder)
 271 {
 272     IEnumUnknown *enumdecoders;
 273     IUnknown *unkdecoderinfo;
 274     IWICBitmapDecoderInfo *decoderinfo;
 275     IWICBitmapDecoder *decoder = NULL, *preferred_decoder = NULL;
 276     GUID vendor;
 277     HRESULT res;
 278     ULONG num_fetched;
 279
 280     TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
 281         debugstr_guid(pguidVendor), ppIDecoder);
 282
 283     if (!guidContainerFormat || !ppIDecoder) return E_INVALIDARG;
 284
 285     res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
 286     if (FAILED(res)) return res;
 287
 288     while (!preferred_decoder)
 289     {
 290         res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
 291         if (res != S_OK) break;
 292
 293         res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void **)&decoderinfo);
 294         if (SUCCEEDED(res))
 295         {
 296             GUID container_guid;
 297
 298             res = IWICBitmapDecoderInfo_GetContainerFormat(decoderinfo, &container_guid);
 299             if (SUCCEEDED(res) && IsEqualIID(&container_guid, guidContainerFormat))
 300             {
 301                 IWICBitmapDecoder *new_decoder;
 302
 303                 res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &new_decoder);
 304                 if (SUCCEEDED(res))
 305                 {
 306                     if (pguidVendor)
 307                     {
 308                         res = IWICBitmapDecoderInfo_GetVendorGUID(decoderinfo, &vendor);
 309                         if (SUCCEEDED(res) && IsEqualIID(&vendor, pguidVendor))
 310                         {
 311                             preferred_decoder = new_decoder;
 312                             new_decoder = NULL;
 313                         }
 314                     }
 315
 316                     if (new_decoder && !decoder)
 317                     {
 318                         decoder = new_decoder;
 319                         new_decoder = NULL;
 320                     }
 321
 322                     if (new_decoder) IWICBitmapDecoder_Release(new_decoder);
 323                 }
 324             }
 325
 326             IWICBitmapDecoderInfo_Release(decoderinfo);
 327         }
 328
 329         IUnknown_Release(unkdecoderinfo);
 330     }
 331
 332     IEnumUnknown_Release(enumdecoders);
 333
 334     if (preferred_decoder)
 335     {
 336         *ppIDecoder = preferred_decoder;
 337         if (decoder) IWICBitmapDecoder_Release(decoder);
 338         return S_OK;
 339     }
 340
 341     if (decoder)
 342     {
 343         *ppIDecoder = decoder;
 344         return S_OK;
 345     }
 346
 347     *ppIDecoder = NULL;
 348     return WINCODEC_ERR_COMPONENTNOTFOUND;
 349 }
 350
 351 static HRESULT WINAPI ComponentFactory_CreateEncoder(IWICComponentFactory *iface,
 352     REFGUID guidContainerFormat, const GUID *pguidVendor,
 353     IWICBitmapEncoder **ppIEncoder)
 354 {
 355     static int fixme=0;
 356     IEnumUnknown *enumencoders;
 357     IUnknown *unkencoderinfo;
 358     IWICBitmapEncoderInfo *encoderinfo;
 359     IWICBitmapEncoder *encoder=NULL;
 360     HRESULT res=S_OK;
 361     ULONG num_fetched;
 362     GUID actual_containerformat;
 363
 364     TRACE("(%p,%s,%s,%p)\n", iface, debugstr_guid(guidContainerFormat),
 365         debugstr_guid(pguidVendor), ppIEncoder);
 366
 367     if (pguidVendor && !fixme++)
 368         FIXME("ignoring vendor GUID\n");
 369
 370     res = CreateComponentEnumerator(WICEncoder, WICComponentEnumerateDefault, &enumencoders);
 371     if (FAILED(res)) return res;
 372
 373     while (!encoder)
 374     {
 375         res = IEnumUnknown_Next(enumencoders, 1, &unkencoderinfo, &num_fetched);
 376
 377         if (res == S_OK)
 378         {
 379             res = IUnknown_QueryInterface(unkencoderinfo, &IID_IWICBitmapEncoderInfo, (void**)&encoderinfo);
 380
 381             if (SUCCEEDED(res))
 382             {
 383                 res = IWICBitmapEncoderInfo_GetContainerFormat(encoderinfo, &actual_containerformat);
 384
 385                 if (SUCCEEDED(res) && IsEqualGUID(guidContainerFormat, &actual_containerformat))
 386                 {
 387                     res = IWICBitmapEncoderInfo_CreateInstance(encoderinfo, &encoder);
 388                     if (FAILED(res))
 389                         encoder = NULL;
 390                 }
 391
 392                 IWICBitmapEncoderInfo_Release(encoderinfo);
 393             }
 394
 395             IUnknown_Release(unkencoderinfo);
 396         }
 397         else
 398             break;
 399     }
 400
 401     IEnumUnknown_Release(enumencoders);
 402
 403     if (encoder)
 404     {
 405         *ppIEncoder = encoder;
 406         return S_OK;
 407     }
 408     else
 409     {
 410         WARN("failed to create encoder\n");
 411         *ppIEncoder = NULL;
 412         return WINCODEC_ERR_COMPONENTNOTFOUND;
 413     }
 414 }
 415
 416 static HRESULT WINAPI ComponentFactory_CreatePalette(IWICComponentFactory *iface,
 417     IWICPalette **ppIPalette)
 418 {
 419     TRACE("(%p,%p)\n", iface, ppIPalette);
 420     return PaletteImpl_Create(ppIPalette);
 421 }
 422
 423 static HRESULT WINAPI ComponentFactory_CreateFormatConverter(IWICComponentFactory *iface,
 424     IWICFormatConverter **ppIFormatConverter)
 425 {
 426     return FormatConverter_CreateInstance(&IID_IWICFormatConverter, (void**)ppIFormatConverter);
 427 }
 428
 429 static HRESULT WINAPI ComponentFactory_CreateBitmapScaler(IWICComponentFactory *iface,
 430     IWICBitmapScaler **ppIBitmapScaler)
 431 {
 432     TRACE("(%p,%p)\n", iface, ppIBitmapScaler);
 433
 434     return BitmapScaler_Create(ppIBitmapScaler);
 435 }
 436
 437 static HRESULT WINAPI ComponentFactory_CreateBitmapClipper(IWICComponentFactory *iface,
 438     IWICBitmapClipper **ppIBitmapClipper)
 439 {
 440     TRACE("(%p,%p)\n", iface, ppIBitmapClipper);
 441     return BitmapClipper_Create(ppIBitmapClipper);
 442 }
 443
 444 static HRESULT WINAPI ComponentFactory_CreateBitmapFlipRotator(IWICComponentFactory *iface,
 445     IWICBitmapFlipRotator **ppIBitmapFlipRotator)
 446 {
 447     TRACE("(%p,%p)\n", iface, ppIBitmapFlipRotator);
 448     return FlipRotator_Create(ppIBitmapFlipRotator);
 449 }
 450
 451 static HRESULT WINAPI ComponentFactory_CreateStream(IWICComponentFactory *iface,
 452     IWICStream **ppIWICStream)
 453 {
 454     TRACE("(%p,%p)\n", iface, ppIWICStream);
 455     return StreamImpl_Create(ppIWICStream);
 456 }
 457
 458 static HRESULT WINAPI ComponentFactory_CreateColorContext(IWICComponentFactory *iface,
 459     IWICColorContext **ppIColorContext)
 460 {
 461     TRACE("(%p,%p)\n", iface, ppIColorContext);
 462     return ColorContext_Create(ppIColorContext);
 463 }
 464
 465 static HRESULT WINAPI ComponentFactory_CreateColorTransformer(IWICComponentFactory *iface,
 466     IWICColorTransform **ppIColorTransform)
 467 {
 468     TRACE("(%p,%p)\n", iface, ppIColorTransform);
 469     return ColorTransform_Create(ppIColorTransform);
 470 }
 471
 472 static HRESULT WINAPI ComponentFactory_CreateBitmap(IWICComponentFactory *iface,
 473     UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat,
 474     WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)
 475 {
 476     TRACE("(%p,%u,%u,%s,%u,%p)\n", iface, uiWidth, uiHeight,
 477         debugstr_guid(pixelFormat), option, ppIBitmap);
 478     return BitmapImpl_Create(uiWidth, uiHeight, 0, 0, NULL, pixelFormat, option, ppIBitmap);
 479 }
 480
 481 static HRESULT WINAPI ComponentFactory_CreateBitmapFromSource(IWICComponentFactory *iface,
 482     IWICBitmapSource *piBitmapSource, WICBitmapCreateCacheOption option,
 483     IWICBitmap **ppIBitmap)
 484 {
 485     IWICBitmap *result;
 486     IWICBitmapLock *lock;
 487     IWICPalette *palette;
 488     UINT width, height;
 489     WICPixelFormatGUID pixelformat = {0};
 490     HRESULT hr;
 491     WICRect rc;
 492     double dpix, dpiy;
 493     IWICComponentInfo *info;
 494     IWICPixelFormatInfo2 *formatinfo;
 495     WICPixelFormatNumericRepresentation format_type;
 496
 497     TRACE("(%p,%p,%u,%p)\n", iface, piBitmapSource, option, ppIBitmap);
 498
 499     if (!piBitmapSource || !ppIBitmap)
 500         return E_INVALIDARG;
 501
 502     hr = IWICBitmapSource_GetSize(piBitmapSource, &width, &height);
 503
 504     if (SUCCEEDED(hr))
 505         hr = IWICBitmapSource_GetPixelFormat(piBitmapSource, &pixelformat);
 506
 507     if (SUCCEEDED(hr))
 508         hr = CreateComponentInfo(&pixelformat, &info);
 509
 510     if (SUCCEEDED(hr))
 511     {
 512         hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo2, (void**)&formatinfo);
 513
 514         if (SUCCEEDED(hr))
 515         {
 516             hr = IWICPixelFormatInfo2_GetNumericRepresentation(formatinfo, &format_type);
 517
 518             IWICPixelFormatInfo2_Release(formatinfo);
 519         }
 520
 521         IWICComponentInfo_Release(info);
 522     }
 523
 524     if (SUCCEEDED(hr))
 525         hr = BitmapImpl_Create(width, height, 0, 0, NULL, &pixelformat, option, &result);
 526
 527     if (SUCCEEDED(hr))
 528     {
 529         hr = IWICBitmap_Lock(result, NULL, WICBitmapLockWrite, &lock);
 530         if (SUCCEEDED(hr))
 531         {
 532             UINT stride, buffersize;
 533             BYTE *buffer;
 534             rc.X = rc.Y = 0;
 535             rc.Width = width;
 536             rc.Height = height;
 537
 538             hr = IWICBitmapLock_GetStride(lock, &stride);
 539
 540             if (SUCCEEDED(hr))
 541                 hr = IWICBitmapLock_GetDataPointer(lock, &buffersize, &buffer);
 542
 543             if (SUCCEEDED(hr))
 544                 hr = IWICBitmapSource_CopyPixels(piBitmapSource, &rc, stride,
 545                     buffersize, buffer);
 546
 547             IWICBitmapLock_Release(lock);
 548         }
 549
 550         if (SUCCEEDED(hr) && (format_type == WICPixelFormatNumericRepresentationUnspecified ||
 551                               format_type == WICPixelFormatNumericRepresentationIndexed))
 552         {
 553             hr = PaletteImpl_Create(&palette);
 554
 555             if (SUCCEEDED(hr))
 556             {
 557                 hr = IWICBitmapSource_CopyPalette(piBitmapSource, palette);
 558
 559                 if (SUCCEEDED(hr))
 560                     hr = IWICBitmap_SetPalette(result, palette);
 561                 else
 562                     hr = S_OK;
 563
 564                 IWICPalette_Release(palette);
 565             }
 566         }
 567
 568         if (SUCCEEDED(hr))
 569         {
 570             hr = IWICBitmapSource_GetResolution(piBitmapSource, &dpix, &dpiy);
 571
 572             if (SUCCEEDED(hr))
 573                 hr = IWICBitmap_SetResolution(result, dpix, dpiy);
 574             else
 575                 hr = S_OK;
 576         }
 577
 578         if (SUCCEEDED(hr))
 579             *ppIBitmap = result;
 580         else
 581             IWICBitmap_Release(result);
 582     }
 583
 584     return hr;
 585 }
 586
 587 static HRESULT WINAPI ComponentFactory_CreateBitmapFromSourceRect(IWICComponentFactory *iface,
 588     IWICBitmapSource *piBitmapSource, UINT x, UINT y, UINT width, UINT height,
 589     IWICBitmap **ppIBitmap)
 590 {
 591     FIXME("(%p,%p,%u,%u,%u,%u,%p): stub\n", iface, piBitmapSource, x, y, width,
 592         height, ppIBitmap);
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI ComponentFactory_CreateBitmapFromMemory(IWICComponentFactory *iface,
 597     UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride,
 598     UINT size, BYTE *buffer, IWICBitmap **bitmap)
 599 {
 600     TRACE("(%p,%u,%u,%s,%u,%u,%p,%p\n", iface, width, height,
 601         debugstr_guid(format), stride, size, buffer, bitmap);
 602
 603     if (!stride || !size || !buffer || !bitmap) return E_INVALIDARG;
 604
 605     return BitmapImpl_Create(width, height, stride, size, buffer, format, WICBitmapCacheOnLoad, bitmap);
 606 }
 607
 608 static BOOL get_16bpp_format(HBITMAP hbm, WICPixelFormatGUID *format)
 609 {
 610     BOOL ret = TRUE;
 611     BITMAPV4HEADER bmh;
 612     HDC hdc;
 613
 614     hdc = CreateCompatibleDC(0);
 615
 616     memset(&bmh, 0, sizeof(bmh));
 617     bmh.bV4Size = sizeof(bmh);
 618     bmh.bV4Width = 1;
 619     bmh.bV4Height = 1;
 620     bmh.bV4V4Compression = BI_BITFIELDS;
 621     bmh.bV4BitCount = 16;
 622
 623     GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO *)&bmh, DIB_RGB_COLORS);
 624
 625     if (bmh.bV4RedMask == 0x7c00 &&
 626         bmh.bV4GreenMask == 0x3e0 &&
 627         bmh.bV4BlueMask == 0x1f)
 628     {
 629         *format = GUID_WICPixelFormat16bppBGR555;
 630     }
 631     else if (bmh.bV4RedMask == 0xf800 &&
 632         bmh.bV4GreenMask == 0x7e0 &&
 633         bmh.bV4BlueMask == 0x1f)
 634     {
 635         *format = GUID_WICPixelFormat16bppBGR565;
 636     }
 637     else
 638     {
 639         FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
 640             bmh.bV4GreenMask, bmh.bV4BlueMask);
 641         ret = FALSE;
 642     }
 643
 644     DeleteDC(hdc);
 645     return ret;
 646 }
 647
 648 static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP(IWICComponentFactory *iface,
 649     HBITMAP hbm, HPALETTE hpal, WICBitmapAlphaChannelOption option, IWICBitmap **bitmap)
 650 {
 651     BITMAP bm;
 652     HRESULT hr;
 653     WICPixelFormatGUID format;
 654     IWICBitmapLock *lock;
 655     UINT size, num_palette_entries = 0;
 656     PALETTEENTRY entry[256];
 657
 658     TRACE("(%p,%p,%p,%u,%p)\n", iface, hbm, hpal, option, bitmap);
 659
 660     if (!bitmap) return E_INVALIDARG;
 661
 662     if (GetObjectW(hbm, sizeof(bm), &bm) != sizeof(bm))
 663         return WINCODEC_ERR_WIN32ERROR;
 664
 665     if (hpal)
 666     {
 667         num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
 668         if (!num_palette_entries)
 669             return WINCODEC_ERR_WIN32ERROR;
 670     }
 671
 672     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
 673     switch(bm.bmBitsPixel)
 674     {
 675     case 1:
 676         format = GUID_WICPixelFormat1bppIndexed;
 677         break;
 678     case 4:
 679         format = GUID_WICPixelFormat4bppIndexed;
 680         break;
 681     case 8:
 682         format = GUID_WICPixelFormat8bppIndexed;
 683         break;
 684     case 16:
 685         if (!get_16bpp_format(hbm, &format))
 686             return E_INVALIDARG;
 687         break;
 688     case 24:
 689         format = GUID_WICPixelFormat24bppBGR;
 690         break;
 691     case 32:
 692         switch (option)
 693         {
 694         case WICBitmapUseAlpha:
 695             format = GUID_WICPixelFormat32bppBGRA;
 696             break;
 697         case WICBitmapUsePremultipliedAlpha:
 698             format = GUID_WICPixelFormat32bppPBGRA;
 699             break;
 700         case WICBitmapIgnoreAlpha:
 701             format = GUID_WICPixelFormat32bppBGR;
 702             break;
 703         default:
 704             return E_INVALIDARG;
 705         }
 706         break;
 707     case 48:
 708         format = GUID_WICPixelFormat48bppRGB;
 709         break;
 710     default:
 711         FIXME("unsupported %d bpp\n", bm.bmBitsPixel);
 712         return E_INVALIDARG;
 713     }
 714
 715     hr = BitmapImpl_Create(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, 0, NULL, &format, WICBitmapCacheOnLoad, bitmap);
 716     if (hr != S_OK) return hr;
 717
 718     hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
 719     if (hr == S_OK)
 720     {
 721         BYTE *buffer;
 722         HDC hdc;
 723         char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
 724         BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
 725
 726         IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
 727
 728         hdc = CreateCompatibleDC(0);
 729
 730         bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 731         bmi->bmiHeader.biBitCount = 0;
 732         GetDIBits(hdc, hbm, 0, 0, NULL, bmi, DIB_RGB_COLORS);
 733         bmi->bmiHeader.biHeight = -bm.bmHeight;
 734         GetDIBits(hdc, hbm, 0, bm.bmHeight, buffer, bmi, DIB_RGB_COLORS);
 735
 736         DeleteDC(hdc);
 737         IWICBitmapLock_Release(lock);
 738
 739         if (num_palette_entries)
 740         {
 741             IWICPalette *palette;
 742             WICColor colors[256];
 743             UINT i;
 744
 745             hr = PaletteImpl_Create(&palette);
 746             if (hr == S_OK)
 747             {
 748                 for (i = 0; i < num_palette_entries; i++)
 749                     colors[i] = 0xff000000 | entry[i].peRed << 16 |
 750                                 entry[i].peGreen << 8 | entry[i].peBlue;
 751
 752                 hr = IWICPalette_InitializeCustom(palette, colors, num_palette_entries);
 753                 if (hr == S_OK)
 754                     hr = IWICBitmap_SetPalette(*bitmap, palette);
 755
 756                 IWICPalette_Release(palette);
 757             }
 758         }
 759     }
 760
 761     if (hr != S_OK)
 762     {
 763         IWICBitmap_Release(*bitmap);
 764         *bitmap = NULL;
 765     }
 766
 767     return hr;
 768 }
 769
 770 static HRESULT WINAPI ComponentFactory_CreateBitmapFromHICON(IWICComponentFactory *iface,
 771     HICON hicon, IWICBitmap **bitmap)
 772 {
 773     IWICBitmapLock *lock;
 774     ICONINFO info;
 775     BITMAP bm;
 776     int width, height, x, y;
 777     UINT stride, size;
 778     BYTE *buffer;
 779     DWORD *bits;
 780     BITMAPINFO bi;
 781     HDC hdc;
 782     BOOL has_alpha;
 783     HRESULT hr;
 784
 785     TRACE("(%p,%p,%p)\n", iface, hicon, bitmap);
 786
 787     if (!bitmap) return E_INVALIDARG;
 788
 789     if (!GetIconInfo(hicon, &info))
 790         return HRESULT_FROM_WIN32(GetLastError());
 791
 792     GetObjectW(info.hbmColor ? info.hbmColor : info.hbmMask, sizeof(bm), &bm);
 793
 794     width = bm.bmWidth;
 795     height = info.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
 796     stride = width * 4;
 797     size = stride * height;
 798
 799     hr = BitmapImpl_Create(width, height, stride, size, NULL,
 800                            &GUID_WICPixelFormat32bppBGRA, WICBitmapCacheOnLoad, bitmap);
 801     if (hr != S_OK) goto failed;
 802
 803     hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
 804     if (hr != S_OK)
 805     {
 806         IWICBitmap_Release(*bitmap);
 807         goto failed;
 808     }
 809     IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
 810
 811     hdc = CreateCompatibleDC(0);
 812
 813     memset(&bi, 0, sizeof(bi));
 814     bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
 815     bi.bmiHeader.biWidth = width;
 816     bi.bmiHeader.biHeight = info.hbmColor ? -height: -height * 2;
 817     bi.bmiHeader.biPlanes = 1;
 818     bi.bmiHeader.biBitCount = 32;
 819     bi.bmiHeader.biCompression = BI_RGB;
 820
 821     has_alpha = FALSE;
 822
 823     if (info.hbmColor)
 824     {
 825         GetDIBits(hdc, info.hbmColor, 0, height, buffer, &bi, DIB_RGB_COLORS);
 826
 827         if (bm.bmBitsPixel == 32)
 828         {
 829             /* If any pixel has a non-zero alpha, ignore hbmMask */
 830             bits = (DWORD *)buffer;
 831             for (x = 0; x < width && !has_alpha; x++, bits++)
 832             {
 833                 for (y = 0; y < height; y++)
 834                 {
 835                     if (*bits & 0xff000000)
 836                     {
 837                         has_alpha = TRUE;
 838                         break;
 839                     }
 840                 }
 841             }
 842         }
 843     }
 844     else
 845         GetDIBits(hdc, info.hbmMask, 0, height, buffer, &bi, DIB_RGB_COLORS);
 846
 847     if (!has_alpha)
 848     {
 849         DWORD *rgba;
 850
 851         if (info.hbmMask)
 852         {
 853             BYTE *mask;
 854
 855             mask = HeapAlloc(GetProcessHeap(), 0, size);
 856             if (!mask)
 857             {
 858                 IWICBitmapLock_Release(lock);
 859                 IWICBitmap_Release(*bitmap);
 860                 DeleteDC(hdc);
 861                 hr = E_OUTOFMEMORY;
 862                 goto failed;
 863             }
 864
 865             /* read alpha data from the mask */
 866             GetDIBits(hdc, info.hbmMask, info.hbmColor ? 0 : height, height, mask, &bi, DIB_RGB_COLORS);
 867
 868             for (y = 0; y < height; y++)
 869             {
 870                 rgba = (DWORD *)(buffer + y * stride);
 871                 bits = (DWORD *)(mask + y * stride);
 872
 873                 for (x = 0; x < width; x++, rgba++, bits++)
 874                 {
 875                     if (*bits)
 876                         *rgba = 0;
 877                     else
 878                         *rgba |= 0xff000000;
 879                 }
 880             }
 881
 882             HeapFree(GetProcessHeap(), 0, mask);
 883         }
 884         else
 885         {
 886             /* set constant alpha of 255 */
 887             for (y = 0; y < height; y++)
 888             {
 889                 rgba = (DWORD *)(buffer + y * stride);
 890                 for (x = 0; x < width; x++, rgba++)
 891                     *rgba |= 0xff000000;
 892             }
 893         }
 894
 895     }
 896
 897     IWICBitmapLock_Release(lock);
 898     DeleteDC(hdc);
 899
 900 failed:
 901     DeleteObject(info.hbmColor);
 902     DeleteObject(info.hbmMask);
 903
 904     return hr;
 905 }
 906
 907 static HRESULT WINAPI ComponentFactory_CreateComponentEnumerator(IWICComponentFactory *iface,
 908     DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
 909 {
 910     TRACE("(%p,%u,%u,%p)\n", iface, componentTypes, options, ppIEnumUnknown);
 911     return CreateComponentEnumerator(componentTypes, options, ppIEnumUnknown);
 912 }
 913
 914 static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromDecoder(
 915     IWICComponentFactory *iface, IWICBitmapDecoder *pIDecoder,
 916     IWICFastMetadataEncoder **ppIFastEncoder)
 917 {
 918     FIXME("(%p,%p,%p): stub\n", iface, pIDecoder, ppIFastEncoder);
 919     return E_NOTIMPL;
 920 }
 921
 922 static HRESULT WINAPI ComponentFactory_CreateFastMetadataEncoderFromFrameDecode(
 923     IWICComponentFactory *iface, IWICBitmapFrameDecode *pIFrameDecoder,
 924     IWICFastMetadataEncoder **ppIFastEncoder)
 925 {
 926     FIXME("(%p,%p,%p): stub\n", iface, pIFrameDecoder, ppIFastEncoder);
 927     return E_NOTIMPL;
 928 }
 929
 930 static HRESULT WINAPI ComponentFactory_CreateQueryWriter(IWICComponentFactory *iface,
 931     REFGUID guidMetadataFormat, const GUID *pguidVendor,
 932     IWICMetadataQueryWriter **ppIQueryWriter)
 933 {
 934     FIXME("(%p,%s,%s,%p): stub\n", iface, debugstr_guid(guidMetadataFormat),
 935         debugstr_guid(pguidVendor), ppIQueryWriter);
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromReader(IWICComponentFactory *iface,
 940     IWICMetadataQueryReader *pIQueryReader, const GUID *pguidVendor,
 941     IWICMetadataQueryWriter **ppIQueryWriter)
 942 {
 943     FIXME("(%p,%p,%s,%p): stub\n", iface, pIQueryReader, debugstr_guid(pguidVendor),
 944         ppIQueryWriter);
 945     return E_NOTIMPL;
 946 }
 947
 948 static HRESULT WINAPI ComponentFactory_CreateMetadataReader(IWICComponentFactory *iface,
 949         REFGUID format, const GUID *vendor, DWORD options, IStream *stream, IWICMetadataReader **reader)
 950 {
 951     FIXME("%p,%s,%s,%x,%p,%p: stub\n", iface, debugstr_guid(format), debugstr_guid(vendor),
 952         options, stream, reader);
 953     return E_NOTIMPL;
 954 }
 955
 956 static HRESULT WINAPI ComponentFactory_CreateMetadataReaderFromContainer(IWICComponentFactory *iface,
 957         REFGUID format, const GUID *vendor, DWORD options, IStream *stream, IWICMetadataReader **reader)
 958 {
 959     HRESULT hr;
 960     IEnumUnknown *enumreaders;
 961     IUnknown *unkreaderinfo;
 962     IWICMetadataReaderInfo *readerinfo;
 963     IWICPersistStream *wicpersiststream;
 964     ULONG num_fetched;
 965     GUID decoder_vendor;
 966     BOOL matches;
 967     LARGE_INTEGER zero;
 968
 969     TRACE("%p,%s,%s,%x,%p,%p\n", iface, debugstr_guid(format), debugstr_guid(vendor),
 970         options, stream, reader);
 971
 972     if (!format || !stream || !reader)
 973         return E_INVALIDARG;
 974
 975     zero.QuadPart = 0;
 976
 977     hr = CreateComponentEnumerator(WICMetadataReader, WICComponentEnumerateDefault, &enumreaders);
 978     if (FAILED(hr)) return hr;
 979
 980     *reader = NULL;
 981
 982 start:
 983     while (!*reader)
 984     {
 985         hr = IEnumUnknown_Next(enumreaders, 1, &unkreaderinfo, &num_fetched);
 986
 987         if (hr == S_OK)
 988         {
 989             hr = IUnknown_QueryInterface(unkreaderinfo, &IID_IWICMetadataReaderInfo, (void**)&readerinfo);
 990
 991             if (SUCCEEDED(hr))
 992             {
 993                 if (vendor)
 994                 {
 995                     hr = IWICMetadataReaderInfo_GetVendorGUID(readerinfo, &decoder_vendor);
 996
 997                     if (FAILED(hr) || !IsEqualIID(vendor, &decoder_vendor))
 998                     {
 999                         IWICMetadataReaderInfo_Release(readerinfo);
1000                         IUnknown_Release(unkreaderinfo);
1001                         continue;
1002                     }
1003                 }
1004
1005                 hr = IWICMetadataReaderInfo_MatchesPattern(readerinfo, format, stream, &matches);
1006
1007                 if (SUCCEEDED(hr) && matches)
1008                 {
1009                     hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1010
1011                     if (SUCCEEDED(hr))
1012                         hr = IWICMetadataReaderInfo_CreateInstance(readerinfo, reader);
1013
1014                     if (SUCCEEDED(hr))
1015                     {
1016                         hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
1017
1018                         if (SUCCEEDED(hr))
1019                         {
1020                             hr = IWICPersistStream_LoadEx(wicpersiststream,
1021                                 stream, vendor, options & WICPersistOptionsMask);
1022
1023                             IWICPersistStream_Release(wicpersiststream);
1024                         }
1025
1026                         if (FAILED(hr))
1027                         {
1028                             IWICMetadataReader_Release(*reader);
1029                             *reader = NULL;
1030                         }
1031                     }
1032                 }
1033
1034                 IUnknown_Release(readerinfo);
1035             }
1036
1037             IUnknown_Release(unkreaderinfo);
1038         }
1039         else
1040             break;
1041     }
1042
1043     if (!*reader && vendor)
1044     {
1045         vendor = NULL;
1046         IEnumUnknown_Reset(enumreaders);
1047         goto start;
1048     }
1049
1050     IEnumUnknown_Release(enumreaders);
1051
1052     if (!*reader && !(options & WICMetadataCreationFailUnknown))
1053     {
1054         hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
1055
1056         if (SUCCEEDED(hr))
1057             hr = UnknownMetadataReader_CreateInstance(&IID_IWICMetadataReader, (void**)reader);
1058
1059         if (SUCCEEDED(hr))
1060         {
1061             hr = IWICMetadataReader_QueryInterface(*reader, &IID_IWICPersistStream, (void**)&wicpersiststream);
1062
1063             if (SUCCEEDED(hr))
1064             {
1065                 hr = IWICPersistStream_LoadEx(wicpersiststream, stream, NULL, options & WICPersistOptionsMask);
1066
1067                 IWICPersistStream_Release(wicpersiststream);
1068             }
1069
1070             if (FAILED(hr))
1071             {
1072                 IWICMetadataReader_Release(*reader);
1073                 *reader = NULL;
1074             }
1075         }
1076     }
1077
1078     if (*reader)
1079         return S_OK;
1080     else
1081         return WINCODEC_ERR_COMPONENTNOTFOUND;
1082 }
1083
1084 static HRESULT WINAPI ComponentFactory_CreateMetadataWriter(IWICComponentFactory *iface,
1085         REFGUID format, const GUID *vendor, DWORD options, IWICMetadataWriter **writer)
1086 {
1087     FIXME("%p,%s,%s,%x,%p: stub\n", iface, debugstr_guid(format), debugstr_guid(vendor), options, writer);
1088     return E_NOTIMPL;
1089 }
1090
1091 static HRESULT WINAPI ComponentFactory_CreateMetadataWriterFromReader(IWICComponentFactory *iface,
1092         IWICMetadataReader *reader, const GUID *vendor, IWICMetadataWriter **writer)
1093 {
1094     FIXME("%p,%p,%s,%p: stub\n", iface, reader, debugstr_guid(vendor), writer);
1095     return E_NOTIMPL;
1096 }
1097
1098 static HRESULT WINAPI ComponentFactory_CreateQueryReaderFromBlockReader(IWICComponentFactory *iface,
1099         IWICMetadataBlockReader *block_reader, IWICMetadataQueryReader **query_reader)
1100 {
1101     FIXME("%p,%p,%p: stub\n", iface, block_reader, query_reader);
1102     return E_NOTIMPL;
1103 }
1104
1105 static HRESULT WINAPI ComponentFactory_CreateQueryWriterFromBlockWriter(IWICComponentFactory *iface,
1106         IWICMetadataBlockWriter *block_writer, IWICMetadataQueryWriter **query_writer)
1107 {
1108     FIXME("%p,%p,%p: stub\n", iface, block_writer, query_writer);
1109     return E_NOTIMPL;
1110 }
1111
1112 static HRESULT WINAPI ComponentFactory_CreateEncoderPropertyBag(IWICComponentFactory *iface,
1113         PROPBAG2 *options, UINT count, IPropertyBag2 **property)
1114 {
1115     TRACE("(%p,%p,%u,%p)\n", iface, options, count, property);
1116     return CreatePropertyBag2(options, count, property);
1117 }
1118
1119 static const IWICComponentFactoryVtbl ComponentFactory_Vtbl = {
1120     ComponentFactory_QueryInterface,
1121     ComponentFactory_AddRef,
1122     ComponentFactory_Release,
1123     ComponentFactory_CreateDecoderFromFilename,
1124     ComponentFactory_CreateDecoderFromStream,
1125     ComponentFactory_CreateDecoderFromFileHandle,
1126     ComponentFactory_CreateComponentInfo,
1127     ComponentFactory_CreateDecoder,
1128     ComponentFactory_CreateEncoder,
1129     ComponentFactory_CreatePalette,
1130     ComponentFactory_CreateFormatConverter,
1131     ComponentFactory_CreateBitmapScaler,
1132     ComponentFactory_CreateBitmapClipper,
1133     ComponentFactory_CreateBitmapFlipRotator,
1134     ComponentFactory_CreateStream,
1135     ComponentFactory_CreateColorContext,
1136     ComponentFactory_CreateColorTransformer,
1137     ComponentFactory_CreateBitmap,
1138     ComponentFactory_CreateBitmapFromSource,
1139     ComponentFactory_CreateBitmapFromSourceRect,
1140     ComponentFactory_CreateBitmapFromMemory,
1141     ComponentFactory_CreateBitmapFromHBITMAP,
1142     ComponentFactory_CreateBitmapFromHICON,
1143     ComponentFactory_CreateComponentEnumerator,
1144     ComponentFactory_CreateFastMetadataEncoderFromDecoder,
1145     ComponentFactory_CreateFastMetadataEncoderFromFrameDecode,
1146     ComponentFactory_CreateQueryWriter,
1147     ComponentFactory_CreateQueryWriterFromReader,
1148     ComponentFactory_CreateMetadataReader,
1149     ComponentFactory_CreateMetadataReaderFromContainer,
1150     ComponentFactory_CreateMetadataWriter,
1151     ComponentFactory_CreateMetadataWriterFromReader,
1152     ComponentFactory_CreateQueryReaderFromBlockReader,
1153     ComponentFactory_CreateQueryWriterFromBlockWriter,
1154     ComponentFactory_CreateEncoderPropertyBag
1155 };
1156
1157 HRESULT ComponentFactory_CreateInstance(REFIID iid, void** ppv)
1158 {
1159     ComponentFactory *This;
1160     HRESULT ret;
1161
1162     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
1163
1164     *ppv = NULL;
1165
1166     This = HeapAlloc(GetProcessHeap(), 0, sizeof(ComponentFactory));
1167     if (!This) return E_OUTOFMEMORY;
1168
1169     This->IWICComponentFactory_iface.lpVtbl = &ComponentFactory_Vtbl;
1170     This->ref = 1;
1171
1172     ret = IWICComponentFactory_QueryInterface(&This->IWICComponentFactory_iface, iid, ppv);
1173     IWICComponentFactory_Release(&This->IWICComponentFactory_iface);
1174
1175     return ret;
1176 }