dlls/windowscodecs/bitmap.c

   1 /*
   2  * Copyright 2012 Vincent Povirk for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28
  29 #include "wincodecs_private.h"
  30
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  34
  35 /* WARNING: .NET Media Integration Layer (MIL) directly dereferences
  36  * BitmapImpl members and depends on its exact layout.
  37  */
  38 typedef struct BitmapImpl {
  39     IMILUnknown1 IMILUnknown1_iface;
  40     LONG ref;
  41     IMILBitmapSource IMILBitmapSource_iface;
  42     IWICBitmap IWICBitmap_iface;
  43     IMILUnknown2 IMILUnknown2_iface;
  44     IWICPalette *palette;
  45     int palette_set;
  46     LONG lock; /* 0 if not locked, -1 if locked for writing, count if locked for reading */
  47     BYTE *data;
  48     void *view; /* used if data is a section created by an application */
  49     UINT offset; /* offset into view */
  50     UINT width, height;
  51     UINT stride;
  52     UINT bpp;
  53     WICPixelFormatGUID pixelformat;
  54     double dpix, dpiy;
  55     CRITICAL_SECTION cs;
  56 } BitmapImpl;
  57
  58 typedef struct BitmapLockImpl {
  59     IWICBitmapLock IWICBitmapLock_iface;
  60     LONG ref;
  61     BitmapImpl *parent;
  62     UINT width, height;
  63     BYTE *data;
  64 } BitmapLockImpl;
  65
  66 static inline BitmapImpl *impl_from_IWICBitmap(IWICBitmap *iface)
  67 {
  68     return CONTAINING_RECORD(iface, BitmapImpl, IWICBitmap_iface);
  69 }
  70
  71 static inline BitmapImpl *impl_from_IMILBitmapSource(IMILBitmapSource *iface)
  72 {
  73     return CONTAINING_RECORD(iface, BitmapImpl, IMILBitmapSource_iface);
  74 }
  75
  76 static inline BitmapImpl *impl_from_IMILUnknown1(IMILUnknown1 *iface)
  77 {
  78     return CONTAINING_RECORD(iface, BitmapImpl, IMILUnknown1_iface);
  79 }
  80
  81 static inline BitmapImpl *impl_from_IMILUnknown2(IMILUnknown2 *iface)
  82 {
  83     return CONTAINING_RECORD(iface, BitmapImpl, IMILUnknown2_iface);
  84 }
  85
  86 static inline BitmapLockImpl *impl_from_IWICBitmapLock(IWICBitmapLock *iface)
  87 {
  88     return CONTAINING_RECORD(iface, BitmapLockImpl, IWICBitmapLock_iface);
  89 }
  90
  91 static BOOL BitmapImpl_AcquireLock(BitmapImpl *This, int write)
  92 {
  93     if (write)
  94     {
  95         return 0 == InterlockedCompareExchange(&This->lock, -1, 0);
  96     }
  97     else
  98     {
  99         while (1)
 100         {
 101             LONG prev_val = This->lock;
 102             if (prev_val == -1)
 103                 return FALSE;
 104             if (prev_val == InterlockedCompareExchange(&This->lock, prev_val+1, prev_val))
 105                 return TRUE;
 106         }
 107     }
 108 }
 109
 110 static void BitmapImpl_ReleaseLock(BitmapImpl *This)
 111 {
 112     while (1)
 113     {
 114         LONG prev_val = This->lock, new_val;
 115         if (prev_val == -1)
 116             new_val = 0;
 117         else
 118             new_val = prev_val - 1;
 119         if (prev_val == InterlockedCompareExchange(&This->lock, new_val, prev_val))
 120             break;
 121     }
 122 }
 123
 124
 125 static HRESULT WINAPI BitmapLockImpl_QueryInterface(IWICBitmapLock *iface, REFIID iid,
 126     void **ppv)
 127 {
 128     BitmapLockImpl *This = impl_from_IWICBitmapLock(iface);
 129     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 130
 131     if (!ppv) return E_INVALIDARG;
 132
 133     if (IsEqualIID(&IID_IUnknown, iid) ||
 134         IsEqualIID(&IID_IWICBitmapLock, iid))
 135     {
 136         *ppv = &This->IWICBitmapLock_iface;
 137     }
 138     else
 139     {
 140         *ppv = NULL;
 141         return E_NOINTERFACE;
 142     }
 143
 144     IUnknown_AddRef((IUnknown*)*ppv);
 145     return S_OK;
 146 }
 147
 148 static ULONG WINAPI BitmapLockImpl_AddRef(IWICBitmapLock *iface)
 149 {
 150     BitmapLockImpl *This = impl_from_IWICBitmapLock(iface);
 151     ULONG ref = InterlockedIncrement(&This->ref);
 152
 153     TRACE("(%p) refcount=%u\n", iface, ref);
 154
 155     return ref;
 156 }
 157
 158 static ULONG WINAPI BitmapLockImpl_Release(IWICBitmapLock *iface)
 159 {
 160     BitmapLockImpl *This = impl_from_IWICBitmapLock(iface);
 161     ULONG ref = InterlockedDecrement(&This->ref);
 162
 163     TRACE("(%p) refcount=%u\n", iface, ref);
 164
 165     if (ref == 0)
 166     {
 167         BitmapImpl_ReleaseLock(This->parent);
 168         IWICBitmap_Release(&This->parent->IWICBitmap_iface);
 169         HeapFree(GetProcessHeap(), 0, This);
 170     }
 171
 172     return ref;
 173 }
 174
 175 static HRESULT WINAPI BitmapLockImpl_GetSize(IWICBitmapLock *iface,
 176     UINT *puiWidth, UINT *puiHeight)
 177 {
 178     BitmapLockImpl *This = impl_from_IWICBitmapLock(iface);
 179     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 180
 181     if (!puiWidth || !puiHeight)
 182         return E_INVALIDARG;
 183
 184     *puiWidth = This->width;
 185     *puiHeight = This->height;
 186
 187     return S_OK;
 188 }
 189
 190 static HRESULT WINAPI BitmapLockImpl_GetStride(IWICBitmapLock *iface,
 191     UINT *pcbStride)
 192 {
 193     BitmapLockImpl *This = impl_from_IWICBitmapLock(iface);
 194     TRACE("(%p,%p)\n", iface, pcbStride);
 195
 196     if (!pcbStride)
 197         return E_INVALIDARG;
 198
 199     *pcbStride = This->parent->stride;
 200
 201     return S_OK;
 202 }
 203
 204 static HRESULT WINAPI BitmapLockImpl_GetDataPointer(IWICBitmapLock *iface,
 205     UINT *pcbBufferSize, BYTE **ppbData)
 206 {
 207     BitmapLockImpl *This = impl_from_IWICBitmapLock(iface);
 208     TRACE("(%p,%p,%p)\n", iface, pcbBufferSize, ppbData);
 209
 210     if (!pcbBufferSize || !ppbData)
 211         return E_INVALIDARG;
 212
 213     *pcbBufferSize = This->parent->stride * (This->height - 1) +
 214         ((This->parent->bpp * This->width) + 7)/8;
 215     *ppbData = This->data;
 216
 217     return S_OK;
 218 }
 219
 220 static HRESULT WINAPI BitmapLockImpl_GetPixelFormat(IWICBitmapLock *iface,
 221     WICPixelFormatGUID *pPixelFormat)
 222 {
 223     BitmapLockImpl *This = impl_from_IWICBitmapLock(iface);
 224     TRACE("(%p,%p)\n", iface, pPixelFormat);
 225
 226     return IWICBitmap_GetPixelFormat(&This->parent->IWICBitmap_iface, pPixelFormat);
 227 }
 228
 229 static const IWICBitmapLockVtbl BitmapLockImpl_Vtbl = {
 230     BitmapLockImpl_QueryInterface,
 231     BitmapLockImpl_AddRef,
 232     BitmapLockImpl_Release,
 233     BitmapLockImpl_GetSize,
 234     BitmapLockImpl_GetStride,
 235     BitmapLockImpl_GetDataPointer,
 236     BitmapLockImpl_GetPixelFormat
 237 };
 238
 239 static HRESULT WINAPI BitmapImpl_QueryInterface(IWICBitmap *iface, REFIID iid,
 240     void **ppv)
 241 {
 242     BitmapImpl *This = impl_from_IWICBitmap(iface);
 243     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 244
 245     if (!ppv) return E_INVALIDARG;
 246
 247     if (IsEqualIID(&IID_IUnknown, iid) ||
 248         IsEqualIID(&IID_IWICBitmapSource, iid) ||
 249         IsEqualIID(&IID_IWICBitmap, iid))
 250     {
 251         *ppv = &This->IWICBitmap_iface;
 252     }
 253     else if (IsEqualIID(&IID_IMILBitmapSource, iid))
 254     {
 255         *ppv = &This->IMILBitmapSource_iface;
 256     }
 257     else
 258     {
 259         *ppv = NULL;
 260         return E_NOINTERFACE;
 261     }
 262
 263     IUnknown_AddRef((IUnknown*)*ppv);
 264     return S_OK;
 265 }
 266
 267 static ULONG WINAPI BitmapImpl_AddRef(IWICBitmap *iface)
 268 {
 269     BitmapImpl *This = impl_from_IWICBitmap(iface);
 270     ULONG ref = InterlockedIncrement(&This->ref);
 271
 272     TRACE("(%p) refcount=%u\n", iface, ref);
 273
 274     return ref;
 275 }
 276
 277 static ULONG WINAPI BitmapImpl_Release(IWICBitmap *iface)
 278 {
 279     BitmapImpl *This = impl_from_IWICBitmap(iface);
 280     ULONG ref = InterlockedDecrement(&This->ref);
 281
 282     TRACE("(%p) refcount=%u\n", iface, ref);
 283
 284     if (ref == 0)
 285     {
 286         if (This->palette) IWICPalette_Release(This->palette);
 287         This->cs.DebugInfo->Spare[0] = 0;
 288         DeleteCriticalSection(&This->cs);
 289         if (This->view)
 290             UnmapViewOfFile(This->view);
 291         else
 292             HeapFree(GetProcessHeap(), 0, This->data);
 293         HeapFree(GetProcessHeap(), 0, This);
 294     }
 295
 296     return ref;
 297 }
 298
 299 static HRESULT WINAPI BitmapImpl_GetSize(IWICBitmap *iface,
 300     UINT *puiWidth, UINT *puiHeight)
 301 {
 302     BitmapImpl *This = impl_from_IWICBitmap(iface);
 303     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 304
 305     if (!puiWidth || !puiHeight)
 306         return E_INVALIDARG;
 307
 308     *puiWidth = This->width;
 309     *puiHeight = This->height;
 310
 311     return S_OK;
 312 }
 313
 314 static HRESULT WINAPI BitmapImpl_GetPixelFormat(IWICBitmap *iface,
 315     WICPixelFormatGUID *pPixelFormat)
 316 {
 317     BitmapImpl *This = impl_from_IWICBitmap(iface);
 318     TRACE("(%p,%p)\n", iface, pPixelFormat);
 319
 320     if (!pPixelFormat)
 321         return E_INVALIDARG;
 322
 323     memcpy(pPixelFormat, &This->pixelformat, sizeof(GUID));
 324
 325     return S_OK;
 326 }
 327
 328 static HRESULT WINAPI BitmapImpl_GetResolution(IWICBitmap *iface,
 329     double *pDpiX, double *pDpiY)
 330 {
 331     BitmapImpl *This = impl_from_IWICBitmap(iface);
 332     TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
 333
 334     if (!pDpiX || !pDpiY)
 335         return E_INVALIDARG;
 336
 337     EnterCriticalSection(&This->cs);
 338     *pDpiX = This->dpix;
 339     *pDpiY = This->dpiy;
 340     LeaveCriticalSection(&This->cs);
 341
 342     return S_OK;
 343 }
 344
 345 static HRESULT WINAPI BitmapImpl_CopyPalette(IWICBitmap *iface,
 346     IWICPalette *pIPalette)
 347 {
 348     BitmapImpl *This = impl_from_IWICBitmap(iface);
 349     TRACE("(%p,%p)\n", iface, pIPalette);
 350
 351     if (!This->palette_set)
 352         return WINCODEC_ERR_PALETTEUNAVAILABLE;
 353
 354     return IWICPalette_InitializeFromPalette(pIPalette, This->palette);
 355 }
 356
 357 static HRESULT WINAPI BitmapImpl_CopyPixels(IWICBitmap *iface,
 358     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 359 {
 360     BitmapImpl *This = impl_from_IWICBitmap(iface);
 361     TRACE("(%p,%p,%u,%u,%p)\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
 362
 363     return copy_pixels(This->bpp, This->data, This->width, This->height,
 364         This->stride, prc, cbStride, cbBufferSize, pbBuffer);
 365 }
 366
 367 static HRESULT WINAPI BitmapImpl_Lock(IWICBitmap *iface, const WICRect *prcLock,
 368     DWORD flags, IWICBitmapLock **ppILock)
 369 {
 370     BitmapImpl *This = impl_from_IWICBitmap(iface);
 371     BitmapLockImpl *result;
 372     WICRect rc;
 373
 374     TRACE("(%p,%p,%x,%p)\n", iface, prcLock, flags, ppILock);
 375
 376     if (!(flags & (WICBitmapLockRead|WICBitmapLockWrite)) || !ppILock)
 377         return E_INVALIDARG;
 378
 379     if (!prcLock)
 380     {
 381         rc.X = rc.Y = 0;
 382         rc.Width = This->width;
 383         rc.Height = This->height;
 384         prcLock = &rc;
 385     }
 386     else if (prcLock->X >= This->width || prcLock->Y >= This->height ||
 387              prcLock->X + prcLock->Width > This->width ||
 388              prcLock->Y + prcLock->Height > This->height ||
 389              prcLock->Width <= 0 || prcLock->Height <= 0)
 390         return E_INVALIDARG;
 391     else if (((prcLock->X * This->bpp) % 8) != 0)
 392     {
 393         FIXME("Cannot lock at an X coordinate not at a full byte\n");
 394         return E_FAIL;
 395     }
 396
 397     result = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapLockImpl));
 398     if (!result)
 399         return E_OUTOFMEMORY;
 400
 401     if (!BitmapImpl_AcquireLock(This, flags & WICBitmapLockWrite))
 402     {
 403         HeapFree(GetProcessHeap(), 0, result);
 404         return WINCODEC_ERR_ALREADYLOCKED;
 405     }
 406
 407     result->IWICBitmapLock_iface.lpVtbl = &BitmapLockImpl_Vtbl;
 408     result->ref = 1;
 409     result->parent = This;
 410     result->width = prcLock->Width;
 411     result->height = prcLock->Height;
 412     result->data = This->data + This->stride * prcLock->Y +
 413         (This->bpp * prcLock->X)/8;
 414
 415     IWICBitmap_AddRef(&This->IWICBitmap_iface);
 416     *ppILock = &result->IWICBitmapLock_iface;
 417
 418     return S_OK;
 419 }
 420
 421 static HRESULT WINAPI BitmapImpl_SetPalette(IWICBitmap *iface, IWICPalette *pIPalette)
 422 {
 423     BitmapImpl *This = impl_from_IWICBitmap(iface);
 424     HRESULT hr;
 425
 426     TRACE("(%p,%p)\n", iface, pIPalette);
 427
 428     if (!This->palette)
 429     {
 430         IWICPalette *new_palette;
 431         hr = PaletteImpl_Create(&new_palette);
 432
 433         if (FAILED(hr)) return hr;
 434
 435         if (InterlockedCompareExchangePointer((void**)&This->palette, new_palette, NULL))
 436         {
 437             /* someone beat us to it */
 438             IWICPalette_Release(new_palette);
 439         }
 440     }
 441
 442     hr = IWICPalette_InitializeFromPalette(This->palette, pIPalette);
 443
 444     if (SUCCEEDED(hr))
 445         This->palette_set = 1;
 446
 447     return S_OK;
 448 }
 449
 450 static HRESULT WINAPI BitmapImpl_SetResolution(IWICBitmap *iface,
 451     double dpiX, double dpiY)
 452 {
 453     BitmapImpl *This = impl_from_IWICBitmap(iface);
 454     TRACE("(%p,%f,%f)\n", iface, dpiX, dpiY);
 455
 456     EnterCriticalSection(&This->cs);
 457     This->dpix = dpiX;
 458     This->dpiy = dpiY;
 459     LeaveCriticalSection(&This->cs);
 460
 461     return S_OK;
 462 }
 463
 464 static const IWICBitmapVtbl BitmapImpl_Vtbl = {
 465     BitmapImpl_QueryInterface,
 466     BitmapImpl_AddRef,
 467     BitmapImpl_Release,
 468     BitmapImpl_GetSize,
 469     BitmapImpl_GetPixelFormat,
 470     BitmapImpl_GetResolution,
 471     BitmapImpl_CopyPalette,
 472     BitmapImpl_CopyPixels,
 473     BitmapImpl_Lock,
 474     BitmapImpl_SetPalette,
 475     BitmapImpl_SetResolution
 476 };
 477
 478 static HRESULT WINAPI IMILBitmapImpl_QueryInterface(IMILBitmapSource *iface, REFIID iid,
 479     void **ppv)
 480 {
 481     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 482     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 483
 484     if (!ppv) return E_INVALIDARG;
 485
 486     if (IsEqualIID(&IID_IUnknown, iid) ||
 487         IsEqualIID(&IID_IMILBitmapSource, iid))
 488     {
 489         IUnknown_AddRef(&This->IMILBitmapSource_iface);
 490         *ppv = &This->IMILBitmapSource_iface;
 491         return S_OK;
 492     }
 493
 494     *ppv = NULL;
 495     return E_NOINTERFACE;
 496 }
 497
 498 static ULONG WINAPI IMILBitmapImpl_AddRef(IMILBitmapSource *iface)
 499 {
 500     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 501     return IWICBitmap_AddRef(&This->IWICBitmap_iface);
 502 }
 503
 504 static ULONG WINAPI IMILBitmapImpl_Release(IMILBitmapSource *iface)
 505 {
 506     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 507     return IWICBitmap_Release(&This->IWICBitmap_iface);
 508 }
 509
 510 static HRESULT WINAPI IMILBitmapImpl_GetSize(IMILBitmapSource *iface,
 511     UINT *width, UINT *height)
 512 {
 513     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 514     return IWICBitmap_GetSize(&This->IWICBitmap_iface, width, height);
 515 }
 516
 517 static const struct
 518 {
 519     const GUID *WIC_format;
 520     int enum_format;
 521 } pixel_fmt_map[] =
 522 {
 523     { &GUID_WICPixelFormatDontCare, 0 },
 524     { &GUID_WICPixelFormat1bppIndexed, 1 },
 525     { &GUID_WICPixelFormat2bppIndexed, 2 },
 526     { &GUID_WICPixelFormat4bppIndexed, 3 },
 527     { &GUID_WICPixelFormat8bppIndexed, 4 },
 528     { &GUID_WICPixelFormatBlackWhite, 5 },
 529     { &GUID_WICPixelFormat2bppGray, 6 },
 530     { &GUID_WICPixelFormat4bppGray, 7 },
 531     { &GUID_WICPixelFormat8bppGray, 8 },
 532     { &GUID_WICPixelFormat16bppBGR555, 9 },
 533     { &GUID_WICPixelFormat16bppBGR565, 0x0a },
 534     { &GUID_WICPixelFormat16bppGray, 0x0b },
 535     { &GUID_WICPixelFormat24bppBGR, 0x0c },
 536     { &GUID_WICPixelFormat24bppRGB, 0x0d },
 537     { &GUID_WICPixelFormat32bppBGR, 0x0e },
 538     { &GUID_WICPixelFormat32bppBGRA, 0x0f },
 539     { &GUID_WICPixelFormat32bppPBGRA, 0x10 },
 540     { &GUID_WICPixelFormat48bppRGB, 0x15 },
 541     { &GUID_WICPixelFormat64bppRGBA, 0x16 },
 542     { &GUID_WICPixelFormat64bppPRGBA, 0x17 },
 543     { &GUID_WICPixelFormat32bppCMYK, 0x1c }
 544 };
 545
 546 static HRESULT WINAPI IMILBitmapImpl_GetPixelFormat(IMILBitmapSource *iface,
 547     int *format)
 548 {
 549     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 550     int i;
 551
 552     TRACE("(%p,%p)\n", iface, format);
 553
 554     if (!format) return E_INVALIDARG;
 555
 556     *format = 0;
 557
 558     for (i = 0; i < sizeof(pixel_fmt_map)/sizeof(pixel_fmt_map[0]); i++)
 559     {
 560         if (IsEqualGUID(pixel_fmt_map[i].WIC_format, &This->pixelformat))
 561         {
 562             *format = pixel_fmt_map[i].enum_format;
 563             break;
 564         }
 565     }
 566
 567     return S_OK;
 568 }
 569
 570 static HRESULT WINAPI IMILBitmapImpl_GetResolution(IMILBitmapSource *iface,
 571     double *dpix, double *dpiy)
 572 {
 573     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 574     return IWICBitmap_GetResolution(&This->IWICBitmap_iface, dpix, dpiy);
 575 }
 576
 577 static HRESULT WINAPI IMILBitmapImpl_CopyPalette(IMILBitmapSource *iface,
 578     IWICPalette *palette)
 579 {
 580     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 581     return IWICBitmap_CopyPalette(&This->IWICBitmap_iface, palette);
 582 }
 583
 584 static HRESULT WINAPI IMILBitmapImpl_CopyPixels(IMILBitmapSource *iface,
 585     const WICRect *rc, UINT stride, UINT size, BYTE *buffer)
 586 {
 587     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 588     return IWICBitmap_CopyPixels(&This->IWICBitmap_iface, rc, stride, size, buffer);
 589 }
 590
 591 static HRESULT WINAPI IMILBitmapImpl_UnknownMethod1(IMILBitmapSource *iface, void **ppv)
 592 {
 593     BitmapImpl *This = impl_from_IMILBitmapSource(iface);
 594
 595     TRACE("(%p,%p)\n", iface, ppv);
 596
 597     if (!ppv) return E_INVALIDARG;
 598
 599     IUnknown_AddRef(&This->IMILUnknown1_iface);
 600     *ppv = &This->IMILUnknown1_iface;
 601
 602     return S_OK;
 603 }
 604
 605 static const IMILBitmapSourceVtbl IMILBitmapImpl_Vtbl =
 606 {
 607     IMILBitmapImpl_QueryInterface,
 608     IMILBitmapImpl_AddRef,
 609     IMILBitmapImpl_Release,
 610     IMILBitmapImpl_GetSize,
 611     IMILBitmapImpl_GetPixelFormat,
 612     IMILBitmapImpl_GetResolution,
 613     IMILBitmapImpl_CopyPalette,
 614     IMILBitmapImpl_CopyPixels,
 615     IMILBitmapImpl_UnknownMethod1,
 616 };
 617
 618 static HRESULT WINAPI IMILUnknown1Impl_QueryInterface(IMILUnknown1 *iface, REFIID iid,
 619     void **ppv)
 620 {
 621     BitmapImpl *This = impl_from_IMILUnknown1(iface);
 622
 623     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 624
 625     if (!ppv) return E_INVALIDARG;
 626
 627     if (IsEqualIID(&IID_IUnknown, iid))
 628     {
 629         IUnknown_AddRef(&This->IMILUnknown1_iface);
 630         *ppv = iface;
 631         return S_OK;
 632     }
 633
 634     return IWICBitmap_QueryInterface(&This->IWICBitmap_iface, iid, ppv);
 635 }
 636
 637 static ULONG WINAPI IMILUnknown1Impl_AddRef(IMILUnknown1 *iface)
 638 {
 639     BitmapImpl *This = impl_from_IMILUnknown1(iface);
 640     return IWICBitmap_AddRef(&This->IWICBitmap_iface);
 641 }
 642
 643 static ULONG WINAPI IMILUnknown1Impl_Release(IMILUnknown1 *iface)
 644 {
 645     BitmapImpl *This = impl_from_IMILUnknown1(iface);
 646     return IWICBitmap_Release(&This->IWICBitmap_iface);
 647 }
 648
 649 static const IMILUnknown1Vtbl IMILUnknown1Impl_Vtbl =
 650 {
 651     IMILUnknown1Impl_QueryInterface,
 652     IMILUnknown1Impl_AddRef,
 653     IMILUnknown1Impl_Release,
 654 };
 655
 656 static HRESULT WINAPI IMILUnknown2Impl_QueryInterface(IMILUnknown2 *iface, REFIID iid,
 657     void **ppv)
 658 {
 659     BitmapImpl *This = impl_from_IMILUnknown2(iface);
 660
 661     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 662
 663     if (!ppv) return E_INVALIDARG;
 664
 665     if (IsEqualIID(&IID_IUnknown, iid))
 666     {
 667         IUnknown_AddRef(&This->IMILUnknown2_iface);
 668         *ppv = iface;
 669         return S_OK;
 670     }
 671
 672     return IWICBitmap_QueryInterface(&This->IWICBitmap_iface, iid, ppv);
 673 }
 674
 675 static ULONG WINAPI IMILUnknown2Impl_AddRef(IMILUnknown2 *iface)
 676 {
 677     BitmapImpl *This = impl_from_IMILUnknown2(iface);
 678     return IWICBitmap_AddRef(&This->IWICBitmap_iface);
 679 }
 680
 681 static ULONG WINAPI IMILUnknown2Impl_Release(IMILUnknown2 *iface)
 682 {
 683     BitmapImpl *This = impl_from_IMILUnknown2(iface);
 684     return IWICBitmap_Release(&This->IWICBitmap_iface);
 685 }
 686
 687 static HRESULT WINAPI IMILUnknown2Impl_UnknownMethod1(IMILUnknown2 *iface, void *arg1, void *arg2)
 688 {
 689     FIXME("(%p,%p,%p): stub\n", iface, arg1, arg2);
 690     return E_NOTIMPL;
 691 }
 692
 693 static const IMILUnknown2Vtbl IMILUnknown2Impl_Vtbl =
 694 {
 695     IMILUnknown2Impl_QueryInterface,
 696     IMILUnknown2Impl_AddRef,
 697     IMILUnknown2Impl_Release,
 698     IMILUnknown2Impl_UnknownMethod1,
 699 };
 700
 701 HRESULT BitmapImpl_Create(UINT uiWidth, UINT uiHeight, UINT stride, UINT datasize, void *view,
 702     UINT offset, REFWICPixelFormatGUID pixelFormat, WICBitmapCreateCacheOption option,
 703     IWICBitmap **ppIBitmap)
 704 {
 705     HRESULT hr;
 706     BitmapImpl *This;
 707     BYTE *data;
 708     UINT bpp;
 709
 710     hr = get_pixelformat_bpp(pixelFormat, &bpp);
 711     if (FAILED(hr)) return hr;
 712
 713     if (!stride) stride = (((bpp*uiWidth)+31)/32)*4;
 714     if (!datasize) datasize = stride * uiHeight;
 715
 716     if (datasize < stride * uiHeight) return WINCODEC_ERR_INSUFFICIENTBUFFER;
 717     if (stride < ((bpp*uiWidth)+7)/8) return E_INVALIDARG;
 718
 719     This = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapImpl));
 720     if (!This) return E_OUTOFMEMORY;
 721
 722     if (view) data = (BYTE *)view + offset;
 723     else if (!(data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, datasize)))
 724     {
 725         HeapFree(GetProcessHeap(), 0, This);
 726         return E_OUTOFMEMORY;
 727     }
 728
 729     This->IWICBitmap_iface.lpVtbl = &BitmapImpl_Vtbl;
 730     This->IMILBitmapSource_iface.lpVtbl = &IMILBitmapImpl_Vtbl;
 731     This->IMILUnknown1_iface.lpVtbl = &IMILUnknown1Impl_Vtbl;
 732     This->IMILUnknown2_iface.lpVtbl = &IMILUnknown2Impl_Vtbl;
 733     This->ref = 1;
 734     This->palette = NULL;
 735     This->palette_set = 0;
 736     This->lock = 0;
 737     This->data = data;
 738     This->view = view;
 739     This->offset = offset;
 740     This->width = uiWidth;
 741     This->height = uiHeight;
 742     This->stride = stride;
 743     This->bpp = bpp;
 744     memcpy(&This->pixelformat, pixelFormat, sizeof(GUID));
 745     This->dpix = This->dpiy = 0.0;
 746     InitializeCriticalSection(&This->cs);
 747     This->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BitmapImpl.lock");
 748
 749     *ppIBitmap = &This->IWICBitmap_iface;
 750
 751     return S_OK;
 752 }