dlls/windowscodecs/bitmap.c

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