projects / reactos.git / blob
? search:


d4b597900db7136fc4cc623392ac6e7264c067ba
[reactos.git] / 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 /* WICBitmapNoCache */
456 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource *)bitmap,
457 WICBitmapNoCache, &bitmap2);
458 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
459 ok(bitmap2 == bitmap, "Unexpected bitmap instance.\n");
460
461 IWICBitmap_Release(bitmap2);
462
463 bitmap2 = (void *)0xdeadbeef;
464 hr = IWICImagingFactory_CreateBitmapFromSource(factory, &bitmapsource, WICBitmapNoCache, &bitmap2);
465 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
466 ok(bitmap2 == (void *)0xdeadbeef, "Unexpected pointer %p.\n", bitmap2);
467
468 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
469 WICBitmapCacheOnLoad, &bitmap2);
470 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
471
472 IWICBitmap_Release(bitmap);
473
474 if (FAILED(hr)) return;
475
476 hr = IWICImagingFactory_CreatePalette(factory, &palette);
477 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
478
479 /* palette isn't copied for non-indexed formats? */
480 hr = IWICBitmap_CopyPalette(bitmap2, palette);
481 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
482
483 IWICPalette_Release(palette);
484
485 hr = IWICBitmap_CopyPixels(bitmap2, NULL, 9, 27, returned_data);
486 ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
487
488 for (i=0; i<27; i++)
489 ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
490
491 hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
492 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
493 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
494
495 hr = IWICBitmap_GetResolution(bitmap2, &dpix, &dpiy);
496 ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
497 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
498 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
499
500 hr = IWICBitmap_GetSize(bitmap2, &width, &height);
501 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
502 ok(width == 3, "got %d, expected 3\n", width);
503 ok(height == 3, "got %d, expected 3\n", height);
504
505 IWICBitmap_Release(bitmap2);
506
507 /* Ensure palette is copied for indexed formats */
508 hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat4bppIndexed,
509 WICBitmapCacheOnLoad, &bitmap);
510 ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
511
512 hr = IWICImagingFactory_CreatePalette(factory, &palette);
513 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
514
515 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
516 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
517
518 hr = IWICBitmap_SetPalette(bitmap, palette);
519 ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
520
521 IWICPalette_Release(palette);
522
523 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
524 WICBitmapCacheOnLoad, &bitmap2);
525 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
526
527 IWICBitmap_Release(bitmap);
528
529 hr = IWICImagingFactory_CreatePalette(factory, &palette);
530 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
531
532 hr = IWICBitmap_CopyPalette(bitmap2, palette);
533 ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
534
535 hr = IWICPalette_GetColorCount(palette, &count);
536 ok(hr == S_OK, "IWICPalette_GetColorCount failed hr=%x\n", hr);
537 ok(count == 256, "unexpected count %d\n", count);
538
539 hr = IWICPalette_GetType(palette, &palette_type);
540 ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
541 ok(palette_type == WICBitmapPaletteTypeFixedGray256, "unexpected palette type %d\n", palette_type);
542
543 IWICPalette_Release(palette);
544
545 hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
546 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
547 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
548
549 hr = IWICBitmap_GetSize(bitmap2, &width, &height);
550 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
551 ok(width == 3, "got %d, expected 3\n", width);
552 ok(height == 3, "got %d, expected 3\n", height);
553
554 /* CreateBitmapFromSourceRect */
555 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 16, 32, &bitmap);
556 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
557 hr = IWICBitmap_GetSize(bitmap, &width, &height);
558 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
559 ok(width == 3, "Unexpected width %u.\n", width);
560 ok(height == 3, "Unexpected height %u.\n", height);
561 IWICBitmap_Release(bitmap);
562
563 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 1, 1, &bitmap);
564 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
565 hr = IWICBitmap_GetSize(bitmap, &width, &height);
566 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
567 ok(width == 1, "Unexpected width %u.\n", width);
568 ok(height == 1, "Unexpected height %u.\n", height);
569 IWICBitmap_Release(bitmap);
570
571 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 2, 1, 16, 32, &bitmap);
572 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
573 hr = IWICBitmap_GetSize(bitmap, &width, &height);
574 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
575 ok(width == 1, "Unexpected width %u.\n", width);
576 ok(height == 2, "Unexpected height %u.\n", height);
577 IWICBitmap_Release(bitmap);
578
579 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 0, 2, &bitmap);
580 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
581
582 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 2, 0, &bitmap);
583 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
584
585 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 1, 3, 16, 32, &bitmap);
586 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
587
588 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 3, 1, 16, 32, &bitmap);
589 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
590
591 IWICBitmap_Release(bitmap2);
592 }
593
594 static void test_CreateBitmapFromMemory(void)
595 {
596 BYTE orig_data3x3[27] = {
597 128,128,255, 128,128,128, 128,255,128,
598 128,128,128, 128,128,128, 255,255,255,
599 255,128,128, 255,255,255, 255,255,255 };
600 BYTE data3x3[27];
601 BYTE data3x2[27] = {
602 128,128,255, 128,128,128, 128,255,128,
603 0,0,0, 0,128,128, 255,255,255,
604 255,128,128, 255,0,0, 0,0,0 };
605 BYTE data[27];
606 HRESULT hr;
607 IWICBitmap *bitmap;
608 UINT width, height, i;
609
610 memcpy(data3x3, orig_data3x3, sizeof(data3x3));
611
612 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
613 0, 0, NULL, &bitmap);
614 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
615
616 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
617 0, sizeof(data3x3), data3x3, &bitmap);
618 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
619
620 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
621 6, sizeof(data3x3), data3x3, &bitmap);
622 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
623
624 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
625 12, sizeof(data3x3), data3x3, &bitmap);
626 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
627
628 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
629 9, sizeof(data3x3) - 1, data3x3, &bitmap);
630 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
631
632 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
633 9, sizeof(data3x3), data3x3, &bitmap);
634 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
635
636 hr = IWICBitmap_GetSize(bitmap, &width, &height);
637 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
638 ok(width == 3, "expected 3, got %u\n", width);
639 ok(height == 3, "expected 3, got %u\n", height);
640
641 data3x3[2] = 192;
642
643 memset(data, 0, sizeof(data));
644 hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, sizeof(data), data);
645 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
646 for (i = 0; i < sizeof(data); i++)
647 ok(data[i] == orig_data3x3[i], "%u: expected %u, got %u\n", i, data[i], data3x3[i]);
648
649 IWICBitmap_Release(bitmap);
650
651 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 2, &GUID_WICPixelFormat24bppBGR,
652 13, sizeof(orig_data3x3), orig_data3x3, &bitmap);
653 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
654
655 hr = IWICBitmap_GetSize(bitmap, &width, &height);
656 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
657 ok(width == 3, "expected 3, got %u\n", width);
658 ok(height == 2, "expected 2, got %u\n", height);
659
660 memset(data, 0, sizeof(data));
661 hr = IWICBitmap_CopyPixels(bitmap, NULL, 13, sizeof(data), data);
662 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
663 for (i = 0; i < sizeof(data); i++)
664 ok(data[i] == data3x2[i], "%u: expected %u, got %u\n", i, data3x2[i], data[i]);
665
666 IWICBitmap_Release(bitmap);
667 }
668
669 static void test_CreateBitmapFromHICON(void)
670 {
671 static const char bits[4096];
672 HICON icon;
673 ICONINFO info;
674 HRESULT hr;
675 IWICBitmap *bitmap;
676 UINT width, height;
677 WICPixelFormatGUID format;
678
679 /* 1 bpp mask */
680 info.fIcon = 1;
681 info.xHotspot = 0;
682 info.yHotspot = 0;
683 info.hbmColor = 0;
684 info.hbmMask = CreateBitmap(16, 32, 1, 1, bits);
685 ok(info.hbmMask != 0, "CreateBitmap failed\n");
686 icon = CreateIconIndirect(&info);
687 ok(icon != 0, "CreateIconIndirect failed\n");
688 DeleteObject(info.hbmMask);
689
690 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, NULL);
691 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
692
693 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, &bitmap);
694 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_CURSOR_HANDLE), "expected ERROR_INVALID_CURSOR_HANDLE, got %#x\n", hr);
695
696 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, NULL);
697 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
698
699 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
700 ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
701 DestroyIcon(icon);
702 if (hr != S_OK) return;
703
704 IWICBitmap_GetPixelFormat(bitmap, &format);
705 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
706 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
707
708 hr = IWICBitmap_GetSize(bitmap, &width, &height);
709 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
710 ok(width == 16, "expected 16, got %u\n", width);
711 ok(height == 16, "expected 16, got %u\n", height);
712
713 IWICBitmap_Release(bitmap);
714
715 /* 24 bpp color, 1 bpp mask */
716 info.fIcon = 1;
717 info.xHotspot = 0;
718 info.yHotspot = 0;
719 info.hbmColor = CreateBitmap(16, 16, 1, 24, bits);
720 ok(info.hbmColor != 0, "CreateBitmap failed\n");
721 info.hbmMask = CreateBitmap(16, 16, 1, 1, bits);
722 ok(info.hbmMask != 0, "CreateBitmap failed\n");
723 icon = CreateIconIndirect(&info);
724 ok(icon != 0, "CreateIconIndirect failed\n");
725 DeleteObject(info.hbmColor);
726 DeleteObject(info.hbmMask);
727
728 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
729 ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
730 DestroyIcon(icon);
731
732 IWICBitmap_GetPixelFormat(bitmap, &format);
733 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
734 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
735
736 hr = IWICBitmap_GetSize(bitmap, &width, &height);
737 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
738 ok(width == 16, "expected 16, got %u\n", width);
739 ok(height == 16, "expected 16, got %u\n", height);
740
741 IWICBitmap_Release(bitmap);
742 }
743
744 static void test_CreateBitmapFromHBITMAP(void)
745 {
746 /* 8 bpp data must be aligned to a DWORD boundary for a DIB */
747 static const BYTE data_8bpp_pal_dib[12] = { 0,1,2,0, 1,2,0,0, 2,1,0,0 };
748 static const BYTE data_8bpp_rgb_dib[12] = { 0xf0,0x0f,0xff,0, 0x0f,0xff,0xf0,0, 0xf0,0x0f,0xff,0 };
749 static const BYTE data_8bpp_pal_wic[12] = { 0xd,0xe,0x10,0, 0xe,0x10,0xd,0, 0x10,0xe,0xd,0 };
750 static const PALETTEENTRY pal_data[3] = { {0xff,0,0,0}, {0,0xff,0,0}, {0,0,0xff,0} };
751 char pal_buf[sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * 255];
752 LOGPALETTE *pal = (LOGPALETTE *)pal_buf;
753 HBITMAP hbmp;
754 HPALETTE hpal;
755 BYTE data[12];
756 HRESULT hr;
757 IWICBitmap *bitmap;
758 UINT width, height, i, count;
759 WICPixelFormatGUID format;
760 IWICPalette *palette;
761 WICBitmapPaletteType type;
762
763 /* 8 bpp without palette */
764 hbmp = create_dib(3, 3, 8, NULL, data_8bpp_rgb_dib);
765 ok(hbmp != 0, "failed to create bitmap\n");
766
767 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, 0, 0, WICBitmapIgnoreAlpha, &bitmap);
768 ok(hr == WINCODEC_ERR_WIN32ERROR || hr == 0x88980003 /*XP*/, "expected WINCODEC_ERR_WIN32ERROR, got %#x\n", hr);
769
770 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, NULL);
771 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
772
773 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, &bitmap);
774 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
775
776 IWICBitmap_GetPixelFormat(bitmap, &format);
777 ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
778 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
779
780 hr = IWICBitmap_GetSize(bitmap, &width, &height);
781 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
782 ok(width == 3, "expected 3, got %u\n", width);
783 ok(height == 3, "expected 3, got %u\n", height);
784
785 memset(data, 0, sizeof(data));
786 hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
787 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
788 for (i = 0; i < sizeof(data); i++)
789 ok(data[i] == data_8bpp_rgb_dib[i], "%u: expected %#x, got %#x\n", i, data_8bpp_rgb_dib[i], data[i]);
790
791 IWICBitmap_Release(bitmap);
792 DeleteObject(hbmp);
793
794 /* 8 bpp with a 3 entries palette */
795 memset(pal_buf, 0, sizeof(pal_buf));
796 pal->palVersion = 0x300;
797 pal->palNumEntries = 3;
798 memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
799 hpal = CreatePalette(pal);
800 ok(hpal != 0, "CreatePalette failed\n");
801
802 hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
803 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
804 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
805
806 IWICBitmap_GetPixelFormat(bitmap, &format);
807 todo_wine
808 ok(IsEqualGUID(&format, &GUID_WICPixelFormat4bppIndexed),
809 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
810
811 hr = IWICBitmap_GetSize(bitmap, &width, &height);
812 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
813 ok(width == 3, "expected 3, got %u\n", width);
814 ok(height == 3, "expected 3, got %u\n", height);
815
816 hr = IWICImagingFactory_CreatePalette(factory, &palette);
817 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
818 hr = IWICBitmap_CopyPalette(bitmap, palette);
819 ok(hr == S_OK, "CopyPalette error %#x\n", hr);
820
821 hr = IWICPalette_GetType(palette, &type);
822 ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
823 ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
824
825 hr = IWICPalette_GetColorCount(palette, &count);
826 ok(hr == S_OK, "GetColorCount error %#x\n", hr);
827 todo_wine
828 ok(count == 16, "expected 16, got %u\n", count);
829
830 IWICPalette_Release(palette);
831
832 IWICBitmap_Release(bitmap);
833 DeleteObject(hbmp);
834 DeleteObject(hpal);
835
836 /* 8 bpp with a 256 entries palette */
837 memset(pal_buf, 0, sizeof(pal_buf));
838 pal->palVersion = 0x300;
839 pal->palNumEntries = 256;
840 memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
841 hpal = CreatePalette(pal);
842 ok(hpal != 0, "CreatePalette failed\n");
843
844 hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
845 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
846 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
847
848 IWICBitmap_GetPixelFormat(bitmap, &format);
849 ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
850 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
851
852 hr = IWICBitmap_GetSize(bitmap, &width, &height);
853 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
854 ok(width == 3, "expected 3, got %u\n", width);
855 ok(height == 3, "expected 3, got %u\n", height);
856
857 hr = IWICImagingFactory_CreatePalette(factory, &palette);
858 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
859 hr = IWICBitmap_CopyPalette(bitmap, palette);
860 ok(hr == S_OK, "CopyPalette error %#x\n", hr);
861
862 hr = IWICPalette_GetType(palette, &type);
863 ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
864 ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
865
866 hr = IWICPalette_GetColorCount(palette, &count);
867 ok(hr == S_OK, "GetColorCount error %#x\n", hr);
868 ok(count == 256, "expected 256, got %u\n", count);
869
870 IWICPalette_Release(palette);
871
872 memset(data, 0, sizeof(data));
873 hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
874 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
875 for (i = 0; i < sizeof(data); i++)
876 todo_wine_if (data[i] != data_8bpp_pal_wic[i])
877 ok(data[i] == data_8bpp_pal_wic[i], "%u: expected %#x, got %#x\n", i, data_8bpp_pal_wic[i], data[i]);
878
879 IWICBitmap_Release(bitmap);
880 DeleteObject(hbmp);
881 DeleteObject(hpal);
882
883 /* 32bpp alpha */
884 hbmp = create_dib(2, 2, 32, NULL, NULL);
885 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUseAlpha, &bitmap);
886 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
887
888 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
889 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
890 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
891 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
892
893 IWICBitmap_Release(bitmap);
894
895 /* 32bpp pre-multiplied alpha */
896 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUsePremultipliedAlpha, &bitmap);
897 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
898
899 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
900 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
901 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppPBGRA),
902 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
903
904 IWICBitmap_Release(bitmap);
905
906 /* 32bpp no alpha */
907 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapIgnoreAlpha, &bitmap);
908 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
909
910 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
911 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
912 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGR),
913 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
914
915 IWICBitmap_Release(bitmap);
916 DeleteObject(hbmp);
917 }
918
919 static void test_clipper(void)
920 {
921 IWICBitmapClipper *clipper;
922 UINT height, width;
923 IWICBitmap *bitmap;
924 BYTE buffer[500];
925 WICRect rect;
926 HRESULT hr;
927
928 hr = IWICImagingFactory_CreateBitmap(factory, 10, 10, &GUID_WICPixelFormat24bppBGR,
929 WICBitmapCacheOnLoad, &bitmap);
930 ok(hr == S_OK, "got 0x%08x\n", hr);
931
932 hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
933 ok(hr == S_OK, "got 0x%08x\n", hr);
934
935 rect.X = rect.Y = 0;
936 rect.Width = rect.Height = 11;
937 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
938 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
939
940 rect.X = rect.Y = 5;
941 rect.Width = rect.Height = 6;
942 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
943 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
944
945 rect.X = rect.Y = 5;
946 rect.Width = rect.Height = 5;
947 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
948 ok(hr == S_OK, "got 0x%08x\n", hr);
949
950 width = height = 0;
951 hr = IWICBitmapClipper_GetSize(clipper, &width, &height);
952 ok(hr == S_OK, "got 0x%08x\n", hr);
953 ok(width == 5, "got %d\n", width);
954 ok(height == 5, "got %d\n", height);
955
956 IWICBitmapClipper_Release(clipper);
957 IWICBitmap_Release(bitmap);
958
959 /* CopyPixels */
960 hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
961 ok(hr == S_OK, "got 0x%08x\n", hr);
962
963 rect.X = rect.Y = 5;
964 rect.Width = rect.Height = 5;
965 hr = IWICBitmapClipper_Initialize(clipper, &bitmapsource, &rect);
966 ok(hr == S_OK, "got 0x%08x\n", hr);
967
968 rect.X = rect.Y = 0;
969 rect.Width = rect.Height = 2;
970
971 /* passed rectangle is relative to clipper rectangle, underlying source gets intersected
972 rectangle */
973 memset(&g_rect, 0, sizeof(g_rect));
974 called_CopyPixels = FALSE;
975 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
976 ok(hr == S_OK, "got 0x%08x\n", hr);
977 ok(called_CopyPixels, "CopyPixels not called\n");
978 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 2 && g_rect.Height == 2,
979 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
980
981 /* whole clipping rectangle */
982 memset(&g_rect, 0, sizeof(g_rect));
983 called_CopyPixels = FALSE;
984
985 rect.X = rect.Y = 0;
986 rect.Width = rect.Height = 5;
987
988 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
989 ok(hr == S_OK, "got 0x%08x\n", hr);
990 ok(called_CopyPixels, "CopyPixels not called\n");
991 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
992 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
993
994 /* larger than clipping rectangle */
995 memset(&g_rect, 0, sizeof(g_rect));
996 called_CopyPixels = FALSE;
997
998 rect.X = rect.Y = 0;
999 rect.Width = rect.Height = 20;
1000
1001 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1002 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1003 ok(!called_CopyPixels, "CopyPixels called\n");
1004
1005 rect.X = rect.Y = 5;
1006 rect.Width = rect.Height = 5;
1007
1008 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1009 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1010 ok(!called_CopyPixels, "CopyPixels called\n");
1011
1012 /* null rectangle */
1013 memset(&g_rect, 0, sizeof(g_rect));
1014 called_CopyPixels = FALSE;
1015
1016 hr = IWICBitmapClipper_CopyPixels(clipper, NULL, 0, sizeof(buffer), buffer);
1017 ok(hr == S_OK, "got 0x%08x\n", hr);
1018 ok(called_CopyPixels, "CopyPixels not called\n");
1019 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
1020 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
1021
1022 IWICBitmapClipper_Release(clipper);
1023 }
1024
1025 static HRESULT (WINAPI *pWICCreateBitmapFromSectionEx)
1026 (UINT, UINT, REFWICPixelFormatGUID, HANDLE, UINT, UINT, WICSectionAccessLevel, IWICBitmap **);
1027
1028 static void test_WICCreateBitmapFromSectionEx(void)
1029 {
1030 SYSTEM_INFO sysinfo;
1031 HANDLE hsection;
1032 BITMAPINFO info;
1033 void *bits;
1034 HBITMAP hdib;
1035 IWICBitmap *bitmap;
1036 HRESULT hr;
1037 pWICCreateBitmapFromSectionEx =
1038 (void *)GetProcAddress(LoadLibraryA("windowscodecs"), "WICCreateBitmapFromSectionEx");
1039
1040 if (!pWICCreateBitmapFromSectionEx)
1041 {
1042 win_skip("WICCreateBitmapFromSectionEx not available\n");
1043 return;
1044 }
1045
1046 GetSystemInfo(&sysinfo);
1047 hsection = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
1048 sysinfo.dwAllocationGranularity * 2, NULL);
1049 ok(hsection != NULL, "CreateFileMapping failed %u\n", GetLastError());
1050
1051 memset(&info, 0, sizeof(info));
1052 info.bmiHeader.biSize = sizeof(info.bmiHeader);
1053 info.bmiHeader.biWidth = 3;
1054 info.bmiHeader.biHeight = -3;
1055 info.bmiHeader.biBitCount = 24;
1056 info.bmiHeader.biPlanes = 1;
1057 info.bmiHeader.biCompression = BI_RGB;
1058
1059 hdib = CreateDIBSection(0, &info, DIB_RGB_COLORS, &bits, hsection, 0);
1060 ok(hdib != NULL, "CreateDIBSection failed\n");
1061
1062 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0,
1063 WICSectionAccessLevelReadWrite, &bitmap);
1064 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1065 IWICBitmap_Release(bitmap);
1066
1067 /* non-zero offset, smaller than allocation granularity */
1068 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0x100,
1069 WICSectionAccessLevelReadWrite, &bitmap);
1070 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1071 IWICBitmap_Release(bitmap);
1072
1073 /* offset larger than allocation granularity */
1074 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0,
1075 sysinfo.dwAllocationGranularity + 1,
1076 WICSectionAccessLevelReadWrite, &bitmap);
1077 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1078 IWICBitmap_Release(bitmap);
1079 DeleteObject(hdib);
1080 CloseHandle(hsection);
1081 }
1082
1083 static void test_bitmap_scaler(void)
1084 {
1085 WICPixelFormatGUID pixel_format;
1086 IWICBitmapScaler *scaler;
1087 IWICPalette *palette;
1088 double res_x, res_y;
1089 IWICBitmap *bitmap;
1090 UINT width, height;
1091 HRESULT hr;
1092
1093 hr = IWICImagingFactory_CreateBitmap(factory, 4, 2, &GUID_WICPixelFormat24bppBGR, WICBitmapCacheOnLoad, &bitmap);
1094 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
1095
1096 hr = IWICBitmap_GetSize(bitmap, &width, &height);
1097 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
1098 ok(width == 4, "Unexpected width %u.\n", width);
1099 ok(height == 2, "Unexpected height %u.\n", height);
1100
1101 hr = IWICBitmap_GetResolution(bitmap, &res_x, &res_y);
1102 ok(hr == S_OK, "Failed to get bitmap resolution, hr %#x.\n", hr);
1103 ok(res_x == 0.0 && res_y == 0.0, "Unexpected resolution %f x %f.\n", res_x, res_y);
1104
1105 hr = IWICImagingFactory_CreateBitmapScaler(factory, &scaler);
1106 ok(hr == S_OK, "Failed to create bitmap scaler, hr %#x.\n", hr);
1107
1108 hr = IWICBitmapScaler_Initialize(scaler, NULL, 0, 0,
1109 WICBitmapInterpolationModeNearestNeighbor);
1110 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1111
1112 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 0,
1113 WICBitmapInterpolationModeNearestNeighbor);
1114 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1115
1116 hr = IWICBitmapScaler_GetSize(scaler, NULL, &height);
1117 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1118
1119 hr = IWICBitmapScaler_GetSize(scaler, &width, NULL);
1120 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1121
1122 hr = IWICBitmapScaler_GetResolution(scaler, NULL, NULL);
1123 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1124
1125 res_x = 0.1;
1126 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, NULL);
1127 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1128 ok(res_x == 0.1, "Unexpected resolution %f.\n", res_x);
1129
1130 hr = IWICBitmapScaler_GetResolution(scaler, NULL, &res_y);
1131 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1132
1133 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, &res_y);
1134 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1135
1136 hr = IWICBitmapScaler_GetPixelFormat(scaler, NULL);
1137 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1138
1139 memset(&pixel_format, 0, sizeof(pixel_format));
1140 hr = IWICBitmapScaler_GetPixelFormat(scaler, &pixel_format);
1141 ok(hr == S_OK, "Failed to get pixel format, hr %#x.\n", hr);
1142 ok(IsEqualGUID(&pixel_format, &GUID_WICPixelFormatDontCare), "Unexpected pixel format %s.\n",
1143 wine_dbgstr_guid(&pixel_format));
1144
1145 width = 123;
1146 height = 321;
1147 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1148 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1149 ok(width == 123, "Unexpected width %u.\n", width);
1150 ok(height == 321, "Unexpected height %u.\n", height);
1151
1152 hr = IWICBitmapScaler_CopyPalette(scaler, NULL);
1153 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1154
1155 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1156 ok(hr == S_OK, "Failed to create a palette, hr %#x.\n", hr);
1157 hr = IWICBitmapScaler_CopyPalette(scaler, palette);
1158 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "Unexpected hr %#x.\n", hr);
1159 IWICPalette_Release(palette);
1160
1161 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 4, 0,
1162 WICBitmapInterpolationModeNearestNeighbor);
1163 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1164
1165 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1166 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1167
1168 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 2,
1169 WICBitmapInterpolationModeNearestNeighbor);
1170 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1171
1172 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1173 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1174
1175 hr = IWICBitmapScaler_Initialize(scaler, NULL, 8, 4,
1176 WICBitmapInterpolationModeNearestNeighbor);
1177 ok(hr == E_INVALIDARG, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1178
1179 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 4,
1180 WICBitmapInterpolationModeNearestNeighbor);
1181 ok(hr == S_OK, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1182
1183 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 4,
1184 WICBitmapInterpolationModeNearestNeighbor);
1185 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1186
1187 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 0,
1188 WICBitmapInterpolationModeNearestNeighbor);
1189 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1190
1191 hr = IWICBitmapScaler_Initialize(scaler, NULL, 8, 4, WICBitmapInterpolationModeNearestNeighbor);
1192 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1193
1194 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 4,
1195 WICBitmapInterpolationModeNearestNeighbor);
1196 ok(hr == WINCODEC_ERR_WRONGSTATE, "Unexpected hr %#x.\n", hr);
1197
1198 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1199 ok(hr == S_OK, "Failed to get scaler size, hr %#x.\n", hr);
1200 ok(width == 8, "Unexpected width %u.\n", width);
1201 ok(height == 4, "Unexpected height %u.\n", height);
1202
1203 hr = IWICBitmapScaler_GetSize(scaler, NULL, &height);
1204 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1205
1206 hr = IWICBitmapScaler_GetSize(scaler, &width, NULL);
1207 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1208
1209 hr = IWICBitmapScaler_GetSize(scaler, NULL, NULL);
1210 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1211
1212 hr = IWICBitmapScaler_GetPixelFormat(scaler, NULL);
1213 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1214
1215 memset(&pixel_format, 0, sizeof(pixel_format));
1216 hr = IWICBitmapScaler_GetPixelFormat(scaler, &pixel_format);
1217 ok(hr == S_OK, "Failed to get pixel format, hr %#x.\n", hr);
1218 ok(IsEqualGUID(&pixel_format, &GUID_WICPixelFormat24bppBGR), "Unexpected pixel format %s.\n",
1219 wine_dbgstr_guid(&pixel_format));
1220
1221 hr = IWICBitmapScaler_GetResolution(scaler, NULL, NULL);
1222 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1223
1224 res_x = 0.1;
1225 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, NULL);
1226 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1227 ok(res_x == 0.1, "Unexpected resolution %f.\n", res_x);
1228
1229 hr = IWICBitmapScaler_GetResolution(scaler, NULL, &res_y);
1230 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1231
1232 res_x = res_y = 1.0;
1233 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, &res_y);
1234 ok(hr == S_OK, "Failed to get scaler resolution, hr %#x.\n", hr);
1235 ok(res_x == 0.0 && res_y == 0.0, "Unexpected resolution %f x %f.\n", res_x, res_y);
1236
1237 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1238 ok(hr == S_OK, "Failed to create a palette, hr %#x.\n", hr);
1239 hr = IWICBitmapScaler_CopyPalette(scaler, palette);
1240 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "Unexpected hr %#x.\n", hr);
1241 IWICPalette_Release(palette);
1242
1243 IWICBitmapScaler_Release(scaler);
1244
1245 IWICBitmap_Release(bitmap);
1246 }
1247
1248 START_TEST(bitmap)
1249 {
1250 HRESULT hr;
1251
1252 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1253
1254 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1255 &IID_IWICImagingFactory, (void**)&factory);
1256 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
1257
1258 test_createbitmap();
1259 test_createbitmapfromsource();
1260 test_CreateBitmapFromMemory();
1261 test_CreateBitmapFromHICON();
1262 test_CreateBitmapFromHBITMAP();
1263 test_clipper();
1264 test_bitmap_scaler();
1265
1266 IWICImagingFactory_Release(factory);
1267
1268 CoUninitialize();
1269
1270 test_WICCreateBitmapFromSectionEx();
1271 }
A free Windows-compatible Operating System