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