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