modules/rostests/winetests/windowscodecs/bitmap.c

   1 /*
   2  * Copyright 2012 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 <stdarg.h>
  21 #include <stdio.h>
  22 #include <assert.h>
  23 #include <math.h>
  24
  25 #define COBJMACROS
  26 #define CONST_VTABLE
  27
  28 #include "windef.h"
  29 #include "objbase.h"
  30 #include "wincodec.h"
  31 #include "wine/test.h"
  32
  33 static IWICImagingFactory *factory;
  34
  35 static HRESULT WINAPI bitmapsource_QueryInterface(IWICBitmapSource *iface, REFIID iid, void **ppv)
  36 {
  37     if (IsEqualIID(&IID_IUnknown, iid) ||
  38         IsEqualIID(&IID_IWICBitmapSource, iid))
  39     {
  40         *ppv = iface;
  41     }
  42     else
  43     {
  44         *ppv = NULL;
  45         return E_NOINTERFACE;
  46     }
  47
  48     return S_OK;
  49 }
  50
  51 static ULONG WINAPI bitmapsource_AddRef(IWICBitmapSource *iface)
  52 {
  53     return 2;
  54 }
  55
  56 static ULONG WINAPI bitmapsource_Release(IWICBitmapSource *iface)
  57 {
  58     return 1;
  59 }
  60
  61 static HRESULT WINAPI bitmapsource_GetSize(IWICBitmapSource *iface, UINT *width, UINT *height)
  62 {
  63     *width = *height = 10;
  64     return S_OK;
  65 }
  66
  67 static HRESULT WINAPI bitmapsource_GetPixelFormat(IWICBitmapSource *iface,
  68     WICPixelFormatGUID *format)
  69 {
  70     return E_NOTIMPL;
  71 }
  72
  73 static HRESULT WINAPI bitmapsource_GetResolution(IWICBitmapSource *iface,
  74     double *dpiX, double *dpiY)
  75 {
  76     return E_NOTIMPL;
  77 }
  78
  79 static HRESULT WINAPI bitmapsource_CopyPalette(IWICBitmapSource *iface,
  80     IWICPalette *palette)
  81 {
  82     return E_NOTIMPL;
  83 }
  84
  85 static WICRect g_rect;
  86 static BOOL called_CopyPixels;
  87
  88 static HRESULT WINAPI bitmapsource_CopyPixels(IWICBitmapSource *iface,
  89     const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
  90 {
  91     if (rc) g_rect = *rc;
  92     called_CopyPixels = TRUE;
  93     return S_OK;
  94 }
  95
  96 static const IWICBitmapSourceVtbl sourcevtbl = {
  97     bitmapsource_QueryInterface,
  98     bitmapsource_AddRef,
  99     bitmapsource_Release,
 100     bitmapsource_GetSize,
 101     bitmapsource_GetPixelFormat,
 102     bitmapsource_GetResolution,
 103     bitmapsource_CopyPalette,
 104     bitmapsource_CopyPixels
 105 };
 106
 107 static IWICBitmapSource bitmapsource = { &sourcevtbl };
 108
 109 static HBITMAP create_dib(int width, int height, int bpp, LOGPALETTE *pal, const void *data)
 110 {
 111     char bmibuf[sizeof(BITMAPINFO) + sizeof(RGBQUAD) * 255];
 112     BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
 113     void *bits;
 114     HBITMAP hdib;
 115     BITMAP bm;
 116
 117     memset(bmibuf, 0, sizeof(bmibuf));
 118     bmi->bmiHeader.biSize = sizeof(bmi->bmiHeader);
 119     bmi->bmiHeader.biWidth = width;
 120     bmi->bmiHeader.biHeight = -height;
 121     bmi->bmiHeader.biBitCount = bpp;
 122     bmi->bmiHeader.biPlanes = 1;
 123     bmi->bmiHeader.biCompression = BI_RGB;
 124     if (pal)
 125     {
 126         WORD i;
 127
 128         assert(pal->palNumEntries <= 256);
 129         for (i = 0; i < pal->palNumEntries; i++)
 130         {
 131             bmi->bmiColors[i].rgbRed = pal->palPalEntry[i].peRed;
 132             bmi->bmiColors[i].rgbGreen = pal->palPalEntry[i].peGreen;
 133             bmi->bmiColors[i].rgbBlue = pal->palPalEntry[i].peBlue;
 134             bmi->bmiColors[i].rgbReserved = 0;
 135         }
 136
 137         bmi->bmiHeader.biClrUsed = pal->palNumEntries;
 138         bmi->bmiHeader.biClrImportant = pal->palNumEntries;
 139     }
 140     hdib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, &bits, NULL, 0);
 141     ok(hdib != 0, "CreateDIBSection(%dx%d,%d bpp) failed\n", width, height, bpp);
 142
 143     GetObjectW(hdib, sizeof(bm), &bm);
 144     ok(bm.bmWidth == width, "expected %d, got %d\n", width, bm.bmWidth);
 145     ok(bm.bmHeight == height, "expected %d, got %d\n", height, bm.bmHeight);
 146     ok(bm.bmPlanes == 1, "expected 1, got %d\n", bm.bmPlanes);
 147     ok(bm.bmBitsPixel == bpp, "expected %d, got %d\n", bpp, bm.bmBitsPixel);
 148
 149     if (data) memcpy(bits, data, bm.bmWidthBytes * bm.bmHeight);
 150
 151     return hdib;
 152 }
 153
 154 static void test_createbitmap(void)
 155 {
 156     HRESULT hr;
 157     IWICBitmap *bitmap;
 158     IWICPalette *palette;
 159     IWICBitmapLock *lock, *lock2;
 160     WICBitmapPaletteType palettetype;
 161     int i;
 162     WICRect rc;
 163     const BYTE bitmap_data[27] = {
 164         128,128,255, 128,128,128, 128,255,128,
 165         128,128,128, 128,128,128, 255,255,255,
 166         255,128,128, 255,255,255, 255,255,255};
 167     BYTE returned_data[27] = {0};
 168     BYTE *lock_buffer=NULL, *base_lock_buffer=NULL;
 169     UINT lock_buffer_size=0;
 170     UINT lock_buffer_stride=0;
 171     WICPixelFormatGUID pixelformat = {0};
 172     UINT width=0, height=0;
 173     double dpix=10.0, dpiy=10.0;
 174     int can_lock_null = 1;
 175
 176     hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 177         WICBitmapCacheOnLoad, &bitmap);
 178     ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
 179
 180     if (FAILED(hr))
 181         return;
 182
 183     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 184     ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
 185
 186     /* Palette is unavailable until explicitly set */
 187     hr = IWICBitmap_CopyPalette(bitmap, palette);
 188     ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
 189
 190     hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
 191     ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
 192
 193     hr = IWICBitmap_SetPalette(bitmap, palette);
 194     ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
 195
 196     hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE);
 197     ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
 198
 199     hr = IWICBitmap_CopyPalette(bitmap, palette);
 200     ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
 201
 202     hr = IWICPalette_GetType(palette, &palettetype);
 203     ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
 204     ok(palettetype == WICBitmapPaletteTypeFixedGray256,
 205         "expected WICBitmapPaletteTypeFixedGray256, got %x\n", palettetype);
 206
 207     IWICPalette_Release(palette);
 208
 209     /* pixel data is initially zeroed */
 210     hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
 211     ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
 212
 213     for (i=0; i<27; i++)
 214         ok(returned_data[i] == 0, "returned_data[%i] == %i\n", i, returned_data[i]);
 215
 216     /* Invalid lock rects */
 217     rc.X = rc.Y = 0;
 218     rc.Width = 4;
 219     rc.Height = 3;
 220     hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
 221     ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
 222     if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
 223
 224     rc.Width = 3;
 225     rc.Height = 4;
 226     hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
 227     ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
 228     if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
 229
 230     rc.Height = 3;
 231     rc.X = 4;
 232     hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
 233     ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
 234     if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
 235
 236     rc.X = 0;
 237     rc.Y = 4;
 238     hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
 239     ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
 240     if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
 241
 242     /* NULL lock rect */
 243     hr = IWICBitmap_Lock(bitmap, NULL, WICBitmapLockRead, &lock);
 244     ok(hr == S_OK || broken(hr == E_INVALIDARG) /* winxp */, "IWICBitmap_Lock failed hr=%x\n", hr);
 245
 246     if (SUCCEEDED(hr))
 247     {
 248         /* entire bitmap is locked */
 249         hr = IWICBitmapLock_GetSize(lock, &width, &height);
 250         ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
 251         ok(width == 3, "got %d, expected 3\n", width);
 252         ok(height == 3, "got %d, expected 3\n", height);
 253
 254         IWICBitmapLock_Release(lock);
 255     }
 256     else
 257         can_lock_null = 0;
 258
 259     /* lock with a valid rect */
 260     rc.Y = 0;
 261     hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
 262     ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
 263     if (SUCCEEDED(hr))
 264     {
 265         hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
 266         ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
 267         /* stride is divisible by 4 */
 268         ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
 269
 270         hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
 271         ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
 272         /* buffer size does not include padding from the last row */
 273         ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
 274         ok(lock_buffer != NULL, "got NULL data pointer\n");
 275         base_lock_buffer = lock_buffer;
 276
 277         hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat);
 278         ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr);
 279         ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
 280
 281         hr = IWICBitmapLock_GetSize(lock, &width, &height);
 282         ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
 283         ok(width == 3, "got %d, expected 3\n", width);
 284         ok(height == 3, "got %d, expected 3\n", height);
 285
 286         /* We can have multiple simultaneous read locks */
 287         hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
 288         ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
 289
 290         if (SUCCEEDED(hr))
 291         {
 292             hr = IWICBitmapLock_GetDataPointer(lock2, &lock_buffer_size, &lock_buffer);
 293             ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
 294             ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
 295             ok(lock_buffer == base_lock_buffer, "got %p, expected %p\n", lock_buffer, base_lock_buffer);
 296
 297             IWICBitmapLock_Release(lock2);
 298         }
 299
 300         if (can_lock_null) /* this hangs on xp/vista */
 301         {
 302             /* But not a read and a write lock */
 303             hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
 304             ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
 305         }
 306
 307         /* But we don't need a write lock to write */
 308         if (base_lock_buffer)
 309         {
 310             for (i=0; i<3; i++)
 311                 memcpy(base_lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
 312         }
 313
 314         IWICBitmapLock_Release(lock);
 315     }
 316
 317     /* test that the data we wrote is returned by CopyPixels */
 318     hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
 319     ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
 320
 321     for (i=0; i<27; i++)
 322         ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
 323
 324     /* try a valid partial rect, and write mode */
 325     rc.X = 2;
 326     rc.Y = 0;
 327     rc.Width = 1;
 328     rc.Height = 2;
 329     hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
 330     ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
 331
 332     if (SUCCEEDED(hr))
 333     {
 334         if (can_lock_null) /* this hangs on xp/vista */
 335         {
 336             /* Can't lock again while locked for writing */
 337             hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
 338             ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
 339
 340             hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
 341             ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
 342         }
 343
 344         hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
 345         ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
 346         ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
 347
 348         hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
 349         ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
 350         ok(lock_buffer_size == 15, "got %i, expected 15\n", lock_buffer_size);
 351         ok(lock_buffer == base_lock_buffer+6, "got %p, expected %p+6\n", lock_buffer, base_lock_buffer);
 352
 353         hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat);
 354         ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr);
 355         ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
 356
 357         hr = IWICBitmapLock_GetSize(lock, &width, &height);
 358         ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
 359         ok(width == 1, "got %d, expected 1\n", width);
 360         ok(height == 2, "got %d, expected 2\n", height);
 361
 362         IWICBitmapLock_Release(lock);
 363     }
 364
 365     hr = IWICBitmap_GetPixelFormat(bitmap, &pixelformat);
 366     ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
 367     ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
 368
 369     hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
 370     ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
 371     ok(dpix == 0.0, "got %f, expected 0.0\n", dpix);
 372     ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy);
 373
 374     hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
 375     ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
 376
 377     hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
 378     ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
 379     ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
 380     ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
 381
 382     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 383     ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
 384     ok(width == 3, "got %d, expected 3\n", width);
 385     ok(height == 3, "got %d, expected 3\n", height);
 386
 387     IWICBitmap_Release(bitmap);
 388 }
 389
 390 static void test_createbitmapfromsource(void)
 391 {
 392     HRESULT hr;
 393     IWICBitmap *bitmap, *bitmap2;
 394     IWICPalette *palette;
 395     IWICBitmapLock *lock;
 396     int i;
 397     WICRect rc;
 398     const BYTE bitmap_data[27] = {
 399         128,128,255, 128,128,128, 128,255,128,
 400         128,128,128, 128,128,128, 255,255,255,
 401         255,128,128, 255,255,255, 255,255,255};
 402     BYTE returned_data[27] = {0};
 403     BYTE *lock_buffer=NULL;
 404     UINT lock_buffer_stride=0;
 405     UINT lock_buffer_size=0;
 406     WICPixelFormatGUID pixelformat = {0};
 407     UINT width=0, height=0;
 408     double dpix=10.0, dpiy=10.0;
 409     UINT count;
 410     WICBitmapPaletteType palette_type;
 411
 412     hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 413         WICBitmapCacheOnLoad, &bitmap);
 414     ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
 415
 416     if (FAILED(hr))
 417         return;
 418
 419     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 420     ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
 421
 422     hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
 423     ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
 424
 425     hr = IWICBitmap_SetPalette(bitmap, palette);
 426     ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
 427
 428     IWICPalette_Release(palette);
 429
 430     rc.X = rc.Y = 0;
 431     rc.Width = 3;
 432     rc.Height = 3;
 433     hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
 434     ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
 435     if (SUCCEEDED(hr))
 436     {
 437         hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
 438         ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
 439         ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
 440
 441         hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
 442         ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
 443         ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
 444         ok(lock_buffer != NULL, "got NULL data pointer\n");
 445
 446         for (i=0; i<3; i++)
 447             memcpy(lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
 448
 449         IWICBitmapLock_Release(lock);
 450     }
 451
 452     hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
 453     ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
 454
 455     hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
 456         WICBitmapCacheOnLoad, &bitmap2);
 457     ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
 458
 459     IWICBitmap_Release(bitmap);
 460
 461     if (FAILED(hr)) return;
 462
 463     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 464     ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
 465
 466     /* palette isn't copied for non-indexed formats? */
 467     hr = IWICBitmap_CopyPalette(bitmap2, palette);
 468     ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
 469
 470     IWICPalette_Release(palette);
 471
 472     hr = IWICBitmap_CopyPixels(bitmap2, NULL, 9, 27, returned_data);
 473     ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
 474
 475     for (i=0; i<27; i++)
 476         ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
 477
 478     hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
 479     ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
 480     ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
 481
 482     hr = IWICBitmap_GetResolution(bitmap2, &dpix, &dpiy);
 483     ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
 484     ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
 485     ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
 486
 487     hr = IWICBitmap_GetSize(bitmap2, &width, &height);
 488     ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
 489     ok(width == 3, "got %d, expected 3\n", width);
 490     ok(height == 3, "got %d, expected 3\n", height);
 491
 492     IWICBitmap_Release(bitmap2);
 493
 494     /* Ensure palette is copied for indexed formats */
 495     hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat4bppIndexed,
 496         WICBitmapCacheOnLoad, &bitmap);
 497     ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
 498
 499     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 500     ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
 501
 502     hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
 503     ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
 504
 505     hr = IWICBitmap_SetPalette(bitmap, palette);
 506     ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
 507
 508     IWICPalette_Release(palette);
 509
 510     hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
 511         WICBitmapCacheOnLoad, &bitmap2);
 512     ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
 513
 514     IWICBitmap_Release(bitmap);
 515
 516     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 517     ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
 518
 519     hr = IWICBitmap_CopyPalette(bitmap2, palette);
 520     ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
 521
 522     hr = IWICPalette_GetColorCount(palette, &count);
 523     ok(hr == S_OK, "IWICPalette_GetColorCount failed hr=%x\n", hr);
 524     ok(count == 256, "unexpected count %d\n", count);
 525
 526     hr = IWICPalette_GetType(palette, &palette_type);
 527     ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
 528     ok(palette_type == WICBitmapPaletteTypeFixedGray256, "unexpected palette type %d\n", palette_type);
 529
 530     IWICPalette_Release(palette);
 531
 532     hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
 533     ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
 534     ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
 535
 536     hr = IWICBitmap_GetSize(bitmap2, &width, &height);
 537     ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
 538     ok(width == 3, "got %d, expected 3\n", width);
 539     ok(height == 3, "got %d, expected 3\n", height);
 540
 541     IWICBitmap_Release(bitmap2);
 542 }
 543
 544 static void test_CreateBitmapFromMemory(void)
 545 {
 546     BYTE orig_data3x3[27] = {
 547         128,128,255, 128,128,128, 128,255,128,
 548         128,128,128, 128,128,128, 255,255,255,
 549         255,128,128, 255,255,255, 255,255,255 };
 550     BYTE data3x3[27];
 551     BYTE data3x2[27] = {
 552         128,128,255, 128,128,128, 128,255,128,
 553         0,0,0, 0,128,128, 255,255,255,
 554         255,128,128, 255,0,0, 0,0,0 };
 555     BYTE data[27];
 556     HRESULT hr;
 557     IWICBitmap *bitmap;
 558     UINT width, height, i;
 559
 560     memcpy(data3x3, orig_data3x3, sizeof(data3x3));
 561
 562     hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 563                                                    0, 0, NULL, &bitmap);
 564     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 565
 566     hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 567                                                    0, sizeof(data3x3), data3x3, &bitmap);
 568     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 569
 570     hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 571                                                    6, sizeof(data3x3), data3x3, &bitmap);
 572     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 573
 574     hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 575                                                    12, sizeof(data3x3), data3x3, &bitmap);
 576     ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
 577
 578     hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 579                                                    9, sizeof(data3x3) - 1, data3x3, &bitmap);
 580     ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
 581
 582     hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
 583                                                    9, sizeof(data3x3), data3x3, &bitmap);
 584     ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
 585
 586     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 587     ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
 588     ok(width == 3, "expected 3, got %u\n", width);
 589     ok(height == 3, "expected 3, got %u\n", height);
 590
 591     data3x3[2] = 192;
 592
 593     memset(data, 0, sizeof(data));
 594     hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, sizeof(data), data);
 595     ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
 596     for (i = 0; i < sizeof(data); i++)
 597         ok(data[i] == orig_data3x3[i], "%u: expected %u, got %u\n", i, data[i], data3x3[i]);
 598
 599     IWICBitmap_Release(bitmap);
 600
 601     hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 2, &GUID_WICPixelFormat24bppBGR,
 602                                                    13, sizeof(orig_data3x3), orig_data3x3, &bitmap);
 603     ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
 604
 605     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 606     ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
 607     ok(width == 3, "expected 3, got %u\n", width);
 608     ok(height == 2, "expected 2, got %u\n", height);
 609
 610     memset(data, 0, sizeof(data));
 611     hr = IWICBitmap_CopyPixels(bitmap, NULL, 13, sizeof(data), data);
 612     ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
 613     for (i = 0; i < sizeof(data); i++)
 614         ok(data[i] == data3x2[i], "%u: expected %u, got %u\n", i, data3x2[i], data[i]);
 615
 616     IWICBitmap_Release(bitmap);
 617 }
 618
 619 static void test_CreateBitmapFromHICON(void)
 620 {
 621     static const char bits[4096];
 622     HICON icon;
 623     ICONINFO info;
 624     HRESULT hr;
 625     IWICBitmap *bitmap;
 626     UINT width, height;
 627     WICPixelFormatGUID format;
 628
 629     /* 1 bpp mask */
 630     info.fIcon = 1;
 631     info.xHotspot = 0;
 632     info.yHotspot = 0;
 633     info.hbmColor = 0;
 634     info.hbmMask = CreateBitmap(16, 32, 1, 1, bits);
 635     ok(info.hbmMask != 0, "CreateBitmap failed\n");
 636     icon = CreateIconIndirect(&info);
 637     ok(icon != 0, "CreateIconIndirect failed\n");
 638     DeleteObject(info.hbmMask);
 639
 640     hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, NULL);
 641     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 642
 643     hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, &bitmap);
 644     ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_CURSOR_HANDLE), "expected ERROR_INVALID_CURSOR_HANDLE, got %#x\n", hr);
 645
 646     hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, NULL);
 647     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 648
 649     hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
 650     ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
 651     DestroyIcon(icon);
 652     if (hr != S_OK) return;
 653
 654     IWICBitmap_GetPixelFormat(bitmap, &format);
 655     ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
 656        "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 657
 658     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 659     ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
 660     ok(width == 16, "expected 16, got %u\n", width);
 661     ok(height == 16, "expected 16, got %u\n", height);
 662
 663     IWICBitmap_Release(bitmap);
 664
 665     /* 24 bpp color, 1 bpp mask */
 666     info.fIcon = 1;
 667     info.xHotspot = 0;
 668     info.yHotspot = 0;
 669     info.hbmColor = CreateBitmap(16, 16, 1, 24, bits);
 670     ok(info.hbmColor != 0, "CreateBitmap failed\n");
 671     info.hbmMask = CreateBitmap(16, 16, 1, 1, bits);
 672     ok(info.hbmMask != 0, "CreateBitmap failed\n");
 673     icon = CreateIconIndirect(&info);
 674     ok(icon != 0, "CreateIconIndirect failed\n");
 675     DeleteObject(info.hbmColor);
 676     DeleteObject(info.hbmMask);
 677
 678     hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
 679     ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
 680     DestroyIcon(icon);
 681
 682     IWICBitmap_GetPixelFormat(bitmap, &format);
 683     ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
 684        "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 685
 686     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 687     ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
 688     ok(width == 16, "expected 16, got %u\n", width);
 689     ok(height == 16, "expected 16, got %u\n", height);
 690
 691     IWICBitmap_Release(bitmap);
 692 }
 693
 694 static void test_CreateBitmapFromHBITMAP(void)
 695 {
 696     /* 8 bpp data must be aligned to a DWORD boundary for a DIB */
 697     static const BYTE data_8bpp_pal_dib[12] = { 0,1,2,0, 1,2,0,0, 2,1,0,0 };
 698     static const BYTE data_8bpp_rgb_dib[12] = { 0xf0,0x0f,0xff,0, 0x0f,0xff,0xf0,0, 0xf0,0x0f,0xff,0 };
 699     static const BYTE data_8bpp_pal_wic[12] = { 0xd,0xe,0x10,0, 0xe,0x10,0xd,0, 0x10,0xe,0xd,0 };
 700     static const PALETTEENTRY pal_data[3] = { {0xff,0,0,0}, {0,0xff,0,0}, {0,0,0xff,0} };
 701     char pal_buf[sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * 255];
 702     LOGPALETTE *pal = (LOGPALETTE *)pal_buf;
 703     HBITMAP hbmp;
 704     HPALETTE hpal;
 705     BYTE data[12];
 706     HRESULT hr;
 707     IWICBitmap *bitmap;
 708     UINT width, height, i, count;
 709     WICPixelFormatGUID format;
 710     IWICPalette *palette;
 711     WICBitmapPaletteType type;
 712
 713     /* 8 bpp without palette */
 714     hbmp = create_dib(3, 3, 8, NULL, data_8bpp_rgb_dib);
 715     ok(hbmp != 0, "failed to create bitmap\n");
 716
 717     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, 0, 0, WICBitmapIgnoreAlpha, &bitmap);
 718     ok(hr == WINCODEC_ERR_WIN32ERROR || hr == 0x88980003 /*XP*/, "expected WINCODEC_ERR_WIN32ERROR, got %#x\n", hr);
 719
 720     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, NULL);
 721     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 722
 723     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, &bitmap);
 724     ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
 725
 726     IWICBitmap_GetPixelFormat(bitmap, &format);
 727     ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
 728        "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 729
 730     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 731     ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
 732     ok(width == 3, "expected 3, got %u\n", width);
 733     ok(height == 3, "expected 3, got %u\n", height);
 734
 735     memset(data, 0, sizeof(data));
 736     hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
 737     ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
 738     for (i = 0; i < sizeof(data); i++)
 739         ok(data[i] == data_8bpp_rgb_dib[i], "%u: expected %#x, got %#x\n", i, data_8bpp_rgb_dib[i], data[i]);
 740
 741     IWICBitmap_Release(bitmap);
 742     DeleteObject(hbmp);
 743
 744     /* 8 bpp with a 3 entries palette */
 745     memset(pal_buf, 0, sizeof(pal_buf));
 746     pal->palVersion = 0x300;
 747     pal->palNumEntries = 3;
 748     memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
 749     hpal = CreatePalette(pal);
 750     ok(hpal != 0, "CreatePalette failed\n");
 751
 752     hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
 753     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
 754     ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
 755
 756     IWICBitmap_GetPixelFormat(bitmap, &format);
 757 todo_wine
 758     ok(IsEqualGUID(&format, &GUID_WICPixelFormat4bppIndexed),
 759        "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 760
 761     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 762     ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
 763     ok(width == 3, "expected 3, got %u\n", width);
 764     ok(height == 3, "expected 3, got %u\n", height);
 765
 766     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 767     ok(hr == S_OK, "CreatePalette error %#x\n", hr);
 768     hr = IWICBitmap_CopyPalette(bitmap, palette);
 769     ok(hr == S_OK, "CopyPalette error %#x\n", hr);
 770
 771     hr = IWICPalette_GetType(palette, &type);
 772     ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
 773     ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
 774
 775     hr = IWICPalette_GetColorCount(palette, &count);
 776     ok(hr == S_OK, "GetColorCount error %#x\n", hr);
 777 todo_wine
 778     ok(count == 16, "expected 16, got %u\n", count);
 779
 780     IWICPalette_Release(palette);
 781
 782     IWICBitmap_Release(bitmap);
 783     DeleteObject(hbmp);
 784     DeleteObject(hpal);
 785
 786     /* 8 bpp with a 256 entries palette */
 787     memset(pal_buf, 0, sizeof(pal_buf));
 788     pal->palVersion = 0x300;
 789     pal->palNumEntries = 256;
 790     memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
 791     hpal = CreatePalette(pal);
 792     ok(hpal != 0, "CreatePalette failed\n");
 793
 794     hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
 795     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
 796     ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
 797
 798     IWICBitmap_GetPixelFormat(bitmap, &format);
 799     ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
 800             "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 801
 802     hr = IWICBitmap_GetSize(bitmap, &width, &height);
 803     ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
 804     ok(width == 3, "expected 3, got %u\n", width);
 805     ok(height == 3, "expected 3, got %u\n", height);
 806
 807     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 808     ok(hr == S_OK, "CreatePalette error %#x\n", hr);
 809     hr = IWICBitmap_CopyPalette(bitmap, palette);
 810     ok(hr == S_OK, "CopyPalette error %#x\n", hr);
 811
 812     hr = IWICPalette_GetType(palette, &type);
 813     ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
 814     ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
 815
 816     hr = IWICPalette_GetColorCount(palette, &count);
 817     ok(hr == S_OK, "GetColorCount error %#x\n", hr);
 818     ok(count == 256, "expected 256, got %u\n", count);
 819
 820     IWICPalette_Release(palette);
 821
 822     memset(data, 0, sizeof(data));
 823     hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
 824     ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
 825     for (i = 0; i < sizeof(data); i++)
 826         todo_wine_if (data[i] != data_8bpp_pal_wic[i])
 827             ok(data[i] == data_8bpp_pal_wic[i], "%u: expected %#x, got %#x\n", i, data_8bpp_pal_wic[i], data[i]);
 828
 829     IWICBitmap_Release(bitmap);
 830     DeleteObject(hbmp);
 831     DeleteObject(hpal);
 832
 833     /* 32bpp alpha */
 834     hbmp = create_dib(2, 2, 32, NULL, NULL);
 835     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUseAlpha, &bitmap);
 836     ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
 837
 838     hr = IWICBitmap_GetPixelFormat(bitmap, &format);
 839     ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
 840     ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
 841        "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 842
 843     IWICBitmap_Release(bitmap);
 844
 845     /* 32bpp pre-multiplied alpha */
 846     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUsePremultipliedAlpha, &bitmap);
 847     ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
 848
 849     hr = IWICBitmap_GetPixelFormat(bitmap, &format);
 850     ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
 851     ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppPBGRA),
 852        "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 853
 854     IWICBitmap_Release(bitmap);
 855
 856     /* 32bpp no alpha */
 857     hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapIgnoreAlpha, &bitmap);
 858     ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
 859
 860     hr = IWICBitmap_GetPixelFormat(bitmap, &format);
 861     ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
 862     ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGR),
 863        "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
 864
 865     IWICBitmap_Release(bitmap);
 866     DeleteObject(hbmp);
 867 }
 868
 869 static void test_clipper(void)
 870 {
 871     IWICBitmapClipper *clipper;
 872     UINT height, width;
 873     IWICBitmap *bitmap;
 874     BYTE buffer[500];
 875     WICRect rect;
 876     HRESULT hr;
 877
 878     hr = IWICImagingFactory_CreateBitmap(factory, 10, 10, &GUID_WICPixelFormat24bppBGR,
 879         WICBitmapCacheOnLoad, &bitmap);
 880     ok(hr == S_OK, "got 0x%08x\n", hr);
 881
 882     hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
 883     ok(hr == S_OK, "got 0x%08x\n", hr);
 884
 885     rect.X = rect.Y = 0;
 886     rect.Width = rect.Height = 11;
 887     hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
 888     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 889
 890     rect.X = rect.Y = 5;
 891     rect.Width = rect.Height = 6;
 892     hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
 893     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 894
 895     rect.X = rect.Y = 5;
 896     rect.Width = rect.Height = 5;
 897     hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
 898     ok(hr == S_OK, "got 0x%08x\n", hr);
 899
 900     width = height = 0;
 901     hr = IWICBitmapClipper_GetSize(clipper, &width, &height);
 902     ok(hr == S_OK, "got 0x%08x\n", hr);
 903     ok(width == 5, "got %d\n", width);
 904     ok(height == 5, "got %d\n", height);
 905
 906     IWICBitmapClipper_Release(clipper);
 907     IWICBitmap_Release(bitmap);
 908
 909     /* CopyPixels */
 910     hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
 911     ok(hr == S_OK, "got 0x%08x\n", hr);
 912
 913     rect.X = rect.Y = 5;
 914     rect.Width = rect.Height = 5;
 915     hr = IWICBitmapClipper_Initialize(clipper, &bitmapsource, &rect);
 916     ok(hr == S_OK, "got 0x%08x\n", hr);
 917
 918     rect.X = rect.Y = 0;
 919     rect.Width = rect.Height = 2;
 920
 921     /* passed rectangle is relative to clipper rectangle, underlying source gets intersected
 922        rectangle */
 923     memset(&g_rect, 0, sizeof(g_rect));
 924     called_CopyPixels = FALSE;
 925     hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
 926     ok(hr == S_OK, "got 0x%08x\n", hr);
 927     ok(called_CopyPixels, "CopyPixels not called\n");
 928     ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 2 && g_rect.Height == 2,
 929         "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
 930
 931     /* whole clipping rectangle */
 932     memset(&g_rect, 0, sizeof(g_rect));
 933     called_CopyPixels = FALSE;
 934
 935     rect.X = rect.Y = 0;
 936     rect.Width = rect.Height = 5;
 937
 938     hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
 939     ok(hr == S_OK, "got 0x%08x\n", hr);
 940     ok(called_CopyPixels, "CopyPixels not called\n");
 941     ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
 942         "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
 943
 944     /* larger than clipping rectangle */
 945     memset(&g_rect, 0, sizeof(g_rect));
 946     called_CopyPixels = FALSE;
 947
 948     rect.X = rect.Y = 0;
 949     rect.Width = rect.Height = 20;
 950
 951     hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
 952     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 953     ok(!called_CopyPixels, "CopyPixels called\n");
 954
 955     rect.X = rect.Y = 5;
 956     rect.Width = rect.Height = 5;
 957
 958     hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
 959     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 960     ok(!called_CopyPixels, "CopyPixels called\n");
 961
 962     /* null rectangle */
 963     memset(&g_rect, 0, sizeof(g_rect));
 964     called_CopyPixels = FALSE;
 965
 966     hr = IWICBitmapClipper_CopyPixels(clipper, NULL, 0, sizeof(buffer), buffer);
 967     ok(hr == S_OK, "got 0x%08x\n", hr);
 968     ok(called_CopyPixels, "CopyPixels not called\n");
 969     ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
 970         "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
 971
 972     IWICBitmapClipper_Release(clipper);
 973 }
 974
 975 static HRESULT (WINAPI *pWICCreateBitmapFromSectionEx)
 976     (UINT, UINT, REFWICPixelFormatGUID, HANDLE, UINT, UINT, WICSectionAccessLevel, IWICBitmap **);
 977
 978 static void test_WICCreateBitmapFromSectionEx(void)
 979 {
 980     SYSTEM_INFO sysinfo;
 981     HANDLE hsection;
 982     BITMAPINFO info;
 983     void *bits;
 984     HBITMAP hdib;
 985     IWICBitmap *bitmap;
 986     HRESULT hr;
 987     pWICCreateBitmapFromSectionEx =
 988         (void *)GetProcAddress(LoadLibraryA("windowscodecs"), "WICCreateBitmapFromSectionEx");
 989
 990     if (!pWICCreateBitmapFromSectionEx)
 991     {
 992         win_skip("WICCreateBitmapFromSectionEx not available\n");
 993         return;
 994     }
 995
 996     GetSystemInfo(&sysinfo);
 997     hsection = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
 998                                   sysinfo.dwAllocationGranularity * 2, NULL);
 999     ok(hsection != NULL, "CreateFileMapping failed %u\n", GetLastError());
1000
1001     memset(&info, 0, sizeof(info));
1002     info.bmiHeader.biSize        = sizeof(info.bmiHeader);
1003     info.bmiHeader.biWidth       = 3;
1004     info.bmiHeader.biHeight      = -3;
1005     info.bmiHeader.biBitCount    = 24;
1006     info.bmiHeader.biPlanes      = 1;
1007     info.bmiHeader.biCompression = BI_RGB;
1008
1009     hdib = CreateDIBSection(0, &info, DIB_RGB_COLORS, &bits, hsection, 0);
1010     ok(hdib != NULL, "CreateDIBSection failed\n");
1011
1012     hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0,
1013                                        WICSectionAccessLevelReadWrite, &bitmap);
1014     ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1015     IWICBitmap_Release(bitmap);
1016
1017     /* non-zero offset, smaller than allocation granularity */
1018     hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0x100,
1019                                        WICSectionAccessLevelReadWrite, &bitmap);
1020     ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1021     IWICBitmap_Release(bitmap);
1022
1023     /* offset larger than allocation granularity */
1024     hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0,
1025                                        sysinfo.dwAllocationGranularity + 1,
1026                                        WICSectionAccessLevelReadWrite, &bitmap);
1027     ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1028     IWICBitmap_Release(bitmap);
1029     DeleteObject(hdib);
1030     CloseHandle(hsection);
1031 }
1032
1033 START_TEST(bitmap)
1034 {
1035     HRESULT hr;
1036
1037     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1038
1039     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1040         &IID_IWICImagingFactory, (void**)&factory);
1041     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
1042
1043     test_createbitmap();
1044     test_createbitmapfromsource();
1045     test_CreateBitmapFromMemory();
1046     test_CreateBitmapFromHICON();
1047     test_CreateBitmapFromHBITMAP();
1048     test_clipper();
1049
1050     IWICImagingFactory_Release(factory);
1051
1052     CoUninitialize();
1053
1054     test_WICCreateBitmapFromSectionEx();
1055 }