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