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 #include "initguid.h"
34 DEFINE_GUID(IID_IMILUnknown,0x0ccd7824,0xdc16,0x4d09,0xbc,0xa8,0x6b,0x09,0xc4,0xef,0x55,0x35);
35 DEFINE_GUID(IID_IMILBitmap,0xb1784d3f,0x8115,0x4763,0x13,0xaa,0x32,0xed,0xdb,0x68,0x29,0x4a);
36 DEFINE_GUID(IID_IMILBitmapSource,0x7543696a,0xbc8d,0x46b0,0x5f,0x81,0x8d,0x95,0x72,0x89,0x72,0xbe);
37 DEFINE_GUID(IID_IMILBitmapLock,0xa67b2b53,0x8fa1,0x4155,0x8f,0x64,0x0c,0x24,0x7a,0x8f,0x84,0xcd);
38 DEFINE_GUID(IID_IMILBitmapScaler,0xa767b0f0,0x1c8c,0x4aef,0x56,0x8f,0xad,0xf9,0x6d,0xcf,0xd5,0xcb);
39 DEFINE_GUID(IID_IMILFormatConverter,0x7e2a746f,0x25c5,0x4851,0xb3,0xaf,0x44,0x3b,0x79,0x63,0x9e,0xc0);
40 DEFINE_GUID(IID_IMILPalette,0xca8e206f,0xf22c,0x4af7,0x6f,0xba,0x7b,0xed,0x5e,0xb1,0xc9,0x2f);
41
42 #undef INTERFACE
43 #define INTERFACE IMILBitmapSource
DECLARE_INTERFACE_(IMILBitmapSource,IUnknown)44 DECLARE_INTERFACE_(IMILBitmapSource,IUnknown)
45 {
46 STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
47 STDMETHOD_(ULONG,AddRef)(THIS) PURE;
48 STDMETHOD_(ULONG,Release)(THIS) PURE;
49 /*** IWICBitmapSource methods ***/
50 STDMETHOD_(HRESULT,GetSize)(THIS_ UINT *,UINT *) PURE;
51 STDMETHOD_(HRESULT,GetPixelFormat)(THIS_ int *) PURE;
52 STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *) PURE;
53 STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *) PURE;
54 STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *) PURE;
55 };
56
57 #undef INTERFACE
58 #define INTERFACE IMILBitmap
DECLARE_INTERFACE_(IMILBitmap,IMILBitmapSource)59 DECLARE_INTERFACE_(IMILBitmap,IMILBitmapSource)
60 {
61 STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
62 STDMETHOD_(ULONG,AddRef)(THIS) PURE;
63 STDMETHOD_(ULONG,Release)(THIS) PURE;
64 /*** IWICBitmapSource methods ***/
65 STDMETHOD_(HRESULT,GetSize)(THIS_ UINT *,UINT *) PURE;
66 STDMETHOD_(HRESULT,GetPixelFormat)(THIS_ int *) PURE;
67 STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *) PURE;
68 STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *) PURE;
69 STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *) PURE;
70 /*** IMILBitmap methods ***/
71 STDMETHOD_(HRESULT,unknown1)(THIS_ void **) PURE;
72 STDMETHOD_(HRESULT,Lock)(THIS_ const WICRect *,DWORD,IWICBitmapLock **) PURE;
73 STDMETHOD_(HRESULT,Unlock)(THIS_ IWICBitmapLock *) PURE;
74 STDMETHOD_(HRESULT,SetPalette)(THIS_ IWICPalette *) PURE;
75 STDMETHOD_(HRESULT,SetResolution)(THIS_ double,double) PURE;
76 STDMETHOD_(HRESULT,AddDirtyRect)(THIS_ const WICRect *) PURE;
77 };
78
79 #undef INTERFACE
80 #define INTERFACE IMILBitmapScaler
DECLARE_INTERFACE_(IMILBitmapScaler,IMILBitmapSource)81 DECLARE_INTERFACE_(IMILBitmapScaler,IMILBitmapSource)
82 {
83 /*** IUnknown methods ***/
84 STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
85 STDMETHOD_(ULONG,AddRef)(THIS) PURE;
86 STDMETHOD_(ULONG,Release)(THIS) PURE;
87 /*** IWICBitmapSource methods ***/
88 STDMETHOD_(HRESULT,GetSize)(THIS_ UINT *,UINT *) PURE;
89 STDMETHOD_(HRESULT,GetPixelFormat)(THIS_ int *) PURE;
90 STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *) PURE;
91 STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *) PURE;
92 STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *) PURE;
93 /*** IMILBitmapScaler methods ***/
94 STDMETHOD_(HRESULT,unknown1)(THIS_ void **) PURE;
95 STDMETHOD_(HRESULT,Initialize)(THIS_ IMILBitmapSource *,UINT,UINT,WICBitmapInterpolationMode);
96 };
97
98 static IWICImagingFactory *factory;
99
bitmapsource_QueryInterface(IWICBitmapSource * iface,REFIID iid,void ** ppv)100 static HRESULT WINAPI bitmapsource_QueryInterface(IWICBitmapSource *iface, REFIID iid, void **ppv)
101 {
102 if (IsEqualIID(&IID_IUnknown, iid) ||
103 IsEqualIID(&IID_IWICBitmapSource, iid))
104 {
105 *ppv = iface;
106 }
107 else
108 {
109 *ppv = NULL;
110 return E_NOINTERFACE;
111 }
112
113 return S_OK;
114 }
115
bitmapsource_AddRef(IWICBitmapSource * iface)116 static ULONG WINAPI bitmapsource_AddRef(IWICBitmapSource *iface)
117 {
118 return 2;
119 }
120
bitmapsource_Release(IWICBitmapSource * iface)121 static ULONG WINAPI bitmapsource_Release(IWICBitmapSource *iface)
122 {
123 return 1;
124 }
125
bitmapsource_GetSize(IWICBitmapSource * iface,UINT * width,UINT * height)126 static HRESULT WINAPI bitmapsource_GetSize(IWICBitmapSource *iface, UINT *width, UINT *height)
127 {
128 *width = *height = 10;
129 return S_OK;
130 }
131
bitmapsource_GetPixelFormat(IWICBitmapSource * iface,WICPixelFormatGUID * format)132 static HRESULT WINAPI bitmapsource_GetPixelFormat(IWICBitmapSource *iface,
133 WICPixelFormatGUID *format)
134 {
135 return E_NOTIMPL;
136 }
137
bitmapsource_GetResolution(IWICBitmapSource * iface,double * dpiX,double * dpiY)138 static HRESULT WINAPI bitmapsource_GetResolution(IWICBitmapSource *iface,
139 double *dpiX, double *dpiY)
140 {
141 return E_NOTIMPL;
142 }
143
bitmapsource_CopyPalette(IWICBitmapSource * iface,IWICPalette * palette)144 static HRESULT WINAPI bitmapsource_CopyPalette(IWICBitmapSource *iface,
145 IWICPalette *palette)
146 {
147 return E_NOTIMPL;
148 }
149
150 static WICRect g_rect;
151 static BOOL called_CopyPixels;
152
bitmapsource_CopyPixels(IWICBitmapSource * iface,const WICRect * rc,UINT stride,UINT buffer_size,BYTE * buffer)153 static HRESULT WINAPI bitmapsource_CopyPixels(IWICBitmapSource *iface,
154 const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
155 {
156 if (rc) g_rect = *rc;
157 called_CopyPixels = TRUE;
158 return S_OK;
159 }
160
161 static const IWICBitmapSourceVtbl sourcevtbl = {
162 bitmapsource_QueryInterface,
163 bitmapsource_AddRef,
164 bitmapsource_Release,
165 bitmapsource_GetSize,
166 bitmapsource_GetPixelFormat,
167 bitmapsource_GetResolution,
168 bitmapsource_CopyPalette,
169 bitmapsource_CopyPixels
170 };
171
172 static IWICBitmapSource bitmapsource = { &sourcevtbl };
173
create_dib(int width,int height,int bpp,LOGPALETTE * pal,const void * data)174 static HBITMAP create_dib(int width, int height, int bpp, LOGPALETTE *pal, const void *data)
175 {
176 char bmibuf[sizeof(BITMAPINFO) + sizeof(RGBQUAD) * 255];
177 BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
178 void *bits;
179 HBITMAP hdib;
180 BITMAP bm;
181
182 memset(bmibuf, 0, sizeof(bmibuf));
183 bmi->bmiHeader.biSize = sizeof(bmi->bmiHeader);
184 bmi->bmiHeader.biWidth = width;
185 bmi->bmiHeader.biHeight = -height;
186 bmi->bmiHeader.biBitCount = bpp;
187 bmi->bmiHeader.biPlanes = 1;
188 bmi->bmiHeader.biCompression = BI_RGB;
189 if (pal)
190 {
191 WORD i;
192
193 assert(pal->palNumEntries <= 256);
194 for (i = 0; i < pal->palNumEntries; i++)
195 {
196 bmi->bmiColors[i].rgbRed = pal->palPalEntry[i].peRed;
197 bmi->bmiColors[i].rgbGreen = pal->palPalEntry[i].peGreen;
198 bmi->bmiColors[i].rgbBlue = pal->palPalEntry[i].peBlue;
199 bmi->bmiColors[i].rgbReserved = 0;
200 }
201
202 bmi->bmiHeader.biClrUsed = pal->palNumEntries;
203 bmi->bmiHeader.biClrImportant = pal->palNumEntries;
204 }
205 hdib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, &bits, NULL, 0);
206 ok(hdib != 0, "CreateDIBSection(%dx%d,%d bpp) failed\n", width, height, bpp);
207
208 GetObjectW(hdib, sizeof(bm), &bm);
209 ok(bm.bmWidth == width, "expected %d, got %d\n", width, bm.bmWidth);
210 ok(bm.bmHeight == height, "expected %d, got %d\n", height, bm.bmHeight);
211 ok(bm.bmPlanes == 1, "expected 1, got %d\n", bm.bmPlanes);
212 ok(bm.bmBitsPixel == bpp, "expected %d, got %d\n", bpp, bm.bmBitsPixel);
213
214 if (data) memcpy(bits, data, bm.bmWidthBytes * bm.bmHeight);
215
216 return hdib;
217 }
218
test_createbitmap(void)219 static void test_createbitmap(void)
220 {
221 HRESULT hr;
222 IWICBitmap *bitmap;
223 IWICPalette *palette;
224 IWICBitmapLock *lock, *lock2;
225 WICBitmapPaletteType palettetype;
226 int i;
227 WICRect rc;
228 const BYTE bitmap_data[27] = {
229 128,128,255, 128,128,128, 128,255,128,
230 128,128,128, 128,128,128, 255,255,255,
231 255,128,128, 255,255,255, 255,255,255};
232 BYTE returned_data[27] = {0};
233 BYTE *lock_buffer=NULL, *base_lock_buffer=NULL;
234 UINT lock_buffer_size=0;
235 UINT lock_buffer_stride=0;
236 WICPixelFormatGUID pixelformat = {0};
237 UINT width=0, height=0;
238 double dpix=10.0, dpiy=10.0;
239 int can_lock_null = 1;
240
241 hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
242 WICBitmapCacheOnLoad, &bitmap);
243 ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
244
245 if (FAILED(hr))
246 return;
247
248 hr = IWICImagingFactory_CreatePalette(factory, &palette);
249 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
250
251 /* Palette is unavailable until explicitly set */
252 hr = IWICBitmap_CopyPalette(bitmap, palette);
253 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
254
255 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
256 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
257
258 hr = IWICBitmap_SetPalette(bitmap, palette);
259 ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
260
261 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE);
262 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
263
264 hr = IWICBitmap_CopyPalette(bitmap, palette);
265 ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
266
267 hr = IWICPalette_GetType(palette, &palettetype);
268 ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
269 ok(palettetype == WICBitmapPaletteTypeFixedGray256,
270 "expected WICBitmapPaletteTypeFixedGray256, got %x\n", palettetype);
271
272 IWICPalette_Release(palette);
273
274 /* pixel data is initially zeroed */
275 hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
276 ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
277
278 for (i=0; i<27; i++)
279 ok(returned_data[i] == 0, "returned_data[%i] == %i\n", i, returned_data[i]);
280
281 /* Invalid lock rects */
282 rc.X = rc.Y = 0;
283 rc.Width = 4;
284 rc.Height = 3;
285 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
286 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
287 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
288
289 rc.Width = 3;
290 rc.Height = 4;
291 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
292 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
293 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
294
295 rc.Height = 3;
296 rc.X = 4;
297 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
298 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
299 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
300
301 rc.X = 0;
302 rc.Y = 4;
303 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
304 ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr);
305 if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock);
306
307 /* NULL lock rect */
308 hr = IWICBitmap_Lock(bitmap, NULL, WICBitmapLockRead, &lock);
309 ok(hr == S_OK || broken(hr == E_INVALIDARG) /* winxp */, "IWICBitmap_Lock failed hr=%x\n", hr);
310
311 if (SUCCEEDED(hr))
312 {
313 /* entire bitmap is locked */
314 hr = IWICBitmapLock_GetSize(lock, &width, &height);
315 ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
316 ok(width == 3, "got %d, expected 3\n", width);
317 ok(height == 3, "got %d, expected 3\n", height);
318
319 IWICBitmapLock_Release(lock);
320 }
321 else
322 can_lock_null = 0;
323
324 /* lock with a valid rect */
325 rc.Y = 0;
326 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock);
327 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
328 if (SUCCEEDED(hr))
329 {
330 hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
331 ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
332 /* stride is divisible by 4 */
333 ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
334
335 hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
336 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
337 /* buffer size does not include padding from the last row */
338 ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
339 ok(lock_buffer != NULL, "got NULL data pointer\n");
340 base_lock_buffer = 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 == 3, "got %d, expected 3\n", width);
349 ok(height == 3, "got %d, expected 3\n", height);
350
351 /* We can have multiple simultaneous read locks */
352 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
353 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
354
355 if (SUCCEEDED(hr))
356 {
357 hr = IWICBitmapLock_GetDataPointer(lock2, &lock_buffer_size, &lock_buffer);
358 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
359 ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
360 ok(lock_buffer == base_lock_buffer, "got %p, expected %p\n", lock_buffer, base_lock_buffer);
361
362 IWICBitmapLock_Release(lock2);
363 }
364
365 if (can_lock_null) /* this hangs on xp/vista */
366 {
367 /* But not a read and a write lock */
368 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
369 ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
370 }
371
372 /* But we don't need a write lock to write */
373 if (base_lock_buffer)
374 {
375 for (i=0; i<3; i++)
376 memcpy(base_lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
377 }
378
379 IWICBitmapLock_Release(lock);
380 }
381
382 /* test that the data we wrote is returned by CopyPixels */
383 hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data);
384 ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
385
386 for (i=0; i<27; i++)
387 ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
388
389 /* try a valid partial rect, and write mode */
390 rc.X = 2;
391 rc.Y = 0;
392 rc.Width = 1;
393 rc.Height = 2;
394 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
395 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
396
397 if (SUCCEEDED(hr))
398 {
399 if (can_lock_null) /* this hangs on xp/vista */
400 {
401 /* Can't lock again while locked for writing */
402 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2);
403 ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
404
405 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2);
406 ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr);
407 }
408
409 hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
410 ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
411 ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
412
413 hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
414 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
415 ok(lock_buffer_size == 15, "got %i, expected 15\n", lock_buffer_size);
416 ok(lock_buffer == base_lock_buffer+6, "got %p, expected %p+6\n", lock_buffer, base_lock_buffer);
417
418 hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat);
419 ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr);
420 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
421
422 hr = IWICBitmapLock_GetSize(lock, &width, &height);
423 ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr);
424 ok(width == 1, "got %d, expected 1\n", width);
425 ok(height == 2, "got %d, expected 2\n", height);
426
427 IWICBitmapLock_Release(lock);
428 }
429
430 hr = IWICBitmap_GetPixelFormat(bitmap, &pixelformat);
431 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
432 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
433
434 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
435 ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
436 ok(dpix == 0.0, "got %f, expected 0.0\n", dpix);
437 ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy);
438
439 hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
440 ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
441
442 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
443 ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
444 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
445 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
446
447 hr = IWICBitmap_GetSize(bitmap, &width, &height);
448 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
449 ok(width == 3, "got %d, expected 3\n", width);
450 ok(height == 3, "got %d, expected 3\n", height);
451
452 IWICBitmap_Release(bitmap);
453 }
454
test_createbitmapfromsource(void)455 static void test_createbitmapfromsource(void)
456 {
457 HRESULT hr;
458 IWICBitmap *bitmap, *bitmap2;
459 IWICPalette *palette;
460 IWICBitmapLock *lock;
461 int i;
462 WICRect rc;
463 const BYTE bitmap_data[27] = {
464 128,128,255, 128,128,128, 128,255,128,
465 128,128,128, 128,128,128, 255,255,255,
466 255,128,128, 255,255,255, 255,255,255};
467 BYTE returned_data[27] = {0};
468 BYTE *lock_buffer=NULL;
469 UINT lock_buffer_stride=0;
470 UINT lock_buffer_size=0;
471 WICPixelFormatGUID pixelformat = {0};
472 UINT width=0, height=0;
473 double dpix=10.0, dpiy=10.0;
474 UINT count;
475 WICBitmapPaletteType palette_type;
476
477 hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
478 WICBitmapCacheOnLoad, &bitmap);
479 ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
480
481 if (FAILED(hr))
482 return;
483
484 hr = IWICImagingFactory_CreatePalette(factory, &palette);
485 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
486
487 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
488 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
489
490 hr = IWICBitmap_SetPalette(bitmap, palette);
491 ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
492
493 IWICPalette_Release(palette);
494
495 rc.X = rc.Y = 0;
496 rc.Width = 3;
497 rc.Height = 3;
498 hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock);
499 ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr);
500 if (SUCCEEDED(hr))
501 {
502 hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride);
503 ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr);
504 ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride);
505
506 hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer);
507 ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr);
508 ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size);
509 ok(lock_buffer != NULL, "got NULL data pointer\n");
510
511 for (i=0; i<3; i++)
512 memcpy(lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9);
513
514 IWICBitmapLock_Release(lock);
515 }
516
517 hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
518 ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr);
519
520 /* WICBitmapNoCache */
521 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource *)bitmap,
522 WICBitmapNoCache, &bitmap2);
523 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
524 ok(bitmap2 == bitmap, "Unexpected bitmap instance.\n");
525
526 IWICBitmap_Release(bitmap2);
527
528 bitmap2 = (void *)0xdeadbeef;
529 hr = IWICImagingFactory_CreateBitmapFromSource(factory, &bitmapsource, WICBitmapNoCache, &bitmap2);
530 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
531 ok(bitmap2 == (void *)0xdeadbeef, "Unexpected pointer %p.\n", bitmap2);
532
533 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
534 WICBitmapCacheOnLoad, &bitmap2);
535 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
536
537 IWICBitmap_Release(bitmap);
538
539 if (FAILED(hr)) return;
540
541 hr = IWICImagingFactory_CreatePalette(factory, &palette);
542 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
543
544 /* palette isn't copied for non-indexed formats? */
545 hr = IWICBitmap_CopyPalette(bitmap2, palette);
546 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
547
548 IWICPalette_Release(palette);
549
550 hr = IWICBitmap_CopyPixels(bitmap2, NULL, 9, 27, returned_data);
551 ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr);
552
553 for (i=0; i<27; i++)
554 ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]);
555
556 hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
557 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
558 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
559
560 hr = IWICBitmap_GetResolution(bitmap2, &dpix, &dpiy);
561 ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr);
562 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
563 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
564
565 hr = IWICBitmap_GetSize(bitmap2, &width, &height);
566 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
567 ok(width == 3, "got %d, expected 3\n", width);
568 ok(height == 3, "got %d, expected 3\n", height);
569
570 IWICBitmap_Release(bitmap2);
571
572 /* Ensure palette is copied for indexed formats */
573 hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat4bppIndexed,
574 WICBitmapCacheOnLoad, &bitmap);
575 ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr);
576
577 hr = IWICImagingFactory_CreatePalette(factory, &palette);
578 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
579
580 hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE);
581 ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr);
582
583 hr = IWICBitmap_SetPalette(bitmap, palette);
584 ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr);
585
586 IWICPalette_Release(palette);
587
588 hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap,
589 WICBitmapCacheOnLoad, &bitmap2);
590 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr);
591
592 IWICBitmap_Release(bitmap);
593
594 hr = IWICImagingFactory_CreatePalette(factory, &palette);
595 ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr);
596
597 hr = IWICBitmap_CopyPalette(bitmap2, palette);
598 ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr);
599
600 hr = IWICPalette_GetColorCount(palette, &count);
601 ok(hr == S_OK, "IWICPalette_GetColorCount failed hr=%x\n", hr);
602 ok(count == 256, "unexpected count %d\n", count);
603
604 hr = IWICPalette_GetType(palette, &palette_type);
605 ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr);
606 ok(palette_type == WICBitmapPaletteTypeFixedGray256, "unexpected palette type %d\n", palette_type);
607
608 IWICPalette_Release(palette);
609
610 hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat);
611 ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr);
612 ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
613
614 hr = IWICBitmap_GetSize(bitmap2, &width, &height);
615 ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr);
616 ok(width == 3, "got %d, expected 3\n", width);
617 ok(height == 3, "got %d, expected 3\n", height);
618
619 /* CreateBitmapFromSourceRect */
620 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 16, 32, &bitmap);
621 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
622 hr = IWICBitmap_GetSize(bitmap, &width, &height);
623 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
624 ok(width == 3, "Unexpected width %u.\n", width);
625 ok(height == 3, "Unexpected height %u.\n", height);
626 IWICBitmap_Release(bitmap);
627
628 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 1, 1, &bitmap);
629 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
630 hr = IWICBitmap_GetSize(bitmap, &width, &height);
631 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
632 ok(width == 1, "Unexpected width %u.\n", width);
633 ok(height == 1, "Unexpected height %u.\n", height);
634 IWICBitmap_Release(bitmap);
635
636 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 2, 1, 16, 32, &bitmap);
637 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
638 hr = IWICBitmap_GetSize(bitmap, &width, &height);
639 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
640 ok(width == 1, "Unexpected width %u.\n", width);
641 ok(height == 2, "Unexpected height %u.\n", height);
642 IWICBitmap_Release(bitmap);
643
644 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 0, 2, &bitmap);
645 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
646
647 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 0, 0, 2, 0, &bitmap);
648 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
649
650 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 1, 3, 16, 32, &bitmap);
651 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
652
653 hr = IWICImagingFactory_CreateBitmapFromSourceRect(factory, (IWICBitmapSource *)bitmap2, 3, 1, 16, 32, &bitmap);
654 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
655
656 IWICBitmap_Release(bitmap2);
657 }
658
test_CreateBitmapFromMemory(void)659 static void test_CreateBitmapFromMemory(void)
660 {
661 BYTE orig_data3x3[27] = {
662 128,128,255, 128,128,128, 128,255,128,
663 128,128,128, 128,128,128, 255,255,255,
664 255,128,128, 255,255,255, 255,255,255 };
665 BYTE data3x3[27];
666 BYTE data3x2[27] = {
667 128,128,255, 128,128,128, 128,255,128,
668 0,0,0, 0,128,128, 255,255,255,
669 255,128,128, 255,0,0, 0,0,0 };
670 BYTE data[27];
671 HRESULT hr;
672 IWICBitmap *bitmap;
673 UINT width, height, i;
674
675 memcpy(data3x3, orig_data3x3, sizeof(data3x3));
676
677 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
678 0, 0, NULL, &bitmap);
679 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
680
681 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
682 0, sizeof(data3x3), data3x3, &bitmap);
683 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
684
685 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
686 6, sizeof(data3x3), data3x3, &bitmap);
687 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
688
689 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
690 12, sizeof(data3x3), data3x3, &bitmap);
691 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
692
693 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
694 9, sizeof(data3x3) - 1, data3x3, &bitmap);
695 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "expected WINCODEC_ERR_INSUFFICIENTBUFFER, got %#x\n", hr);
696
697 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
698 9, sizeof(data3x3), data3x3, &bitmap);
699 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
700
701 hr = IWICBitmap_GetSize(bitmap, &width, &height);
702 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
703 ok(width == 3, "expected 3, got %u\n", width);
704 ok(height == 3, "expected 3, got %u\n", height);
705
706 data3x3[2] = 192;
707
708 memset(data, 0, sizeof(data));
709 hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, sizeof(data), data);
710 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
711 for (i = 0; i < sizeof(data); i++)
712 ok(data[i] == orig_data3x3[i], "%u: expected %u, got %u\n", i, data[i], data3x3[i]);
713
714 IWICBitmap_Release(bitmap);
715
716 hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 2, &GUID_WICPixelFormat24bppBGR,
717 13, sizeof(orig_data3x3), orig_data3x3, &bitmap);
718 ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
719
720 hr = IWICBitmap_GetSize(bitmap, &width, &height);
721 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
722 ok(width == 3, "expected 3, got %u\n", width);
723 ok(height == 2, "expected 2, got %u\n", height);
724
725 memset(data, 0, sizeof(data));
726 hr = IWICBitmap_CopyPixels(bitmap, NULL, 13, sizeof(data), data);
727 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
728 for (i = 0; i < sizeof(data); i++)
729 ok(data[i] == data3x2[i], "%u: expected %u, got %u\n", i, data3x2[i], data[i]);
730
731 IWICBitmap_Release(bitmap);
732 }
733
test_CreateBitmapFromHICON(void)734 static void test_CreateBitmapFromHICON(void)
735 {
736 static const char bits[4096];
737 HICON icon;
738 ICONINFO info;
739 HRESULT hr;
740 IWICBitmap *bitmap;
741 UINT width, height;
742 WICPixelFormatGUID format;
743
744 /* 1 bpp mask */
745 info.fIcon = 1;
746 info.xHotspot = 0;
747 info.yHotspot = 0;
748 info.hbmColor = 0;
749 info.hbmMask = CreateBitmap(16, 32, 1, 1, bits);
750 ok(info.hbmMask != 0, "CreateBitmap failed\n");
751 icon = CreateIconIndirect(&info);
752 ok(icon != 0, "CreateIconIndirect failed\n");
753 DeleteObject(info.hbmMask);
754
755 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, NULL);
756 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
757
758 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, 0, &bitmap);
759 ok(hr == HRESULT_FROM_WIN32(ERROR_INVALID_CURSOR_HANDLE), "expected ERROR_INVALID_CURSOR_HANDLE, got %#x\n", hr);
760
761 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, NULL);
762 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
763
764 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
765 ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
766 DestroyIcon(icon);
767 if (hr != S_OK) return;
768
769 IWICBitmap_GetPixelFormat(bitmap, &format);
770 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
771 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
772
773 hr = IWICBitmap_GetSize(bitmap, &width, &height);
774 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
775 ok(width == 16, "expected 16, got %u\n", width);
776 ok(height == 16, "expected 16, got %u\n", height);
777
778 IWICBitmap_Release(bitmap);
779
780 /* 24 bpp color, 1 bpp mask */
781 info.fIcon = 1;
782 info.xHotspot = 0;
783 info.yHotspot = 0;
784 info.hbmColor = CreateBitmap(16, 16, 1, 24, bits);
785 ok(info.hbmColor != 0, "CreateBitmap failed\n");
786 info.hbmMask = CreateBitmap(16, 16, 1, 1, bits);
787 ok(info.hbmMask != 0, "CreateBitmap failed\n");
788 icon = CreateIconIndirect(&info);
789 ok(icon != 0, "CreateIconIndirect failed\n");
790 DeleteObject(info.hbmColor);
791 DeleteObject(info.hbmMask);
792
793 hr = IWICImagingFactory_CreateBitmapFromHICON(factory, icon, &bitmap);
794 ok(hr == S_OK, "CreateBitmapFromHICON error %#x\n", hr);
795 DestroyIcon(icon);
796
797 IWICBitmap_GetPixelFormat(bitmap, &format);
798 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
799 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
800
801 hr = IWICBitmap_GetSize(bitmap, &width, &height);
802 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
803 ok(width == 16, "expected 16, got %u\n", width);
804 ok(height == 16, "expected 16, got %u\n", height);
805
806 IWICBitmap_Release(bitmap);
807 }
808
test_CreateBitmapFromHBITMAP(void)809 static void test_CreateBitmapFromHBITMAP(void)
810 {
811 /* 8 bpp data must be aligned to a DWORD boundary for a DIB */
812 static const BYTE data_8bpp_pal_dib[12] = { 0,1,2,0, 1,2,0,0, 2,1,0,0 };
813 static const BYTE data_8bpp_rgb_dib[12] = { 0xf0,0x0f,0xff,0, 0x0f,0xff,0xf0,0, 0xf0,0x0f,0xff,0 };
814 static const BYTE data_8bpp_pal_wic[12] = { 0xd,0xe,0x10,0, 0xe,0x10,0xd,0, 0x10,0xe,0xd,0 };
815 static const PALETTEENTRY pal_data[3] = { {0xff,0,0,0}, {0,0xff,0,0}, {0,0,0xff,0} };
816 char pal_buf[sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * 255];
817 LOGPALETTE *pal = (LOGPALETTE *)pal_buf;
818 HBITMAP hbmp;
819 HPALETTE hpal;
820 BYTE data[12];
821 HRESULT hr;
822 IWICBitmap *bitmap;
823 UINT width, height, i, count;
824 WICPixelFormatGUID format;
825 IWICPalette *palette;
826 WICBitmapPaletteType type;
827
828 /* 8 bpp without palette */
829 hbmp = create_dib(3, 3, 8, NULL, data_8bpp_rgb_dib);
830 ok(hbmp != 0, "failed to create bitmap\n");
831
832 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, 0, 0, WICBitmapIgnoreAlpha, &bitmap);
833 ok(hr == WINCODEC_ERR_WIN32ERROR || hr == 0x88980003 /*XP*/, "expected WINCODEC_ERR_WIN32ERROR, got %#x\n", hr);
834
835 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, NULL);
836 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
837
838 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, 0, WICBitmapIgnoreAlpha, &bitmap);
839 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
840
841 IWICBitmap_GetPixelFormat(bitmap, &format);
842 ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
843 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
844
845 hr = IWICBitmap_GetSize(bitmap, &width, &height);
846 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
847 ok(width == 3, "expected 3, got %u\n", width);
848 ok(height == 3, "expected 3, got %u\n", height);
849
850 memset(data, 0, sizeof(data));
851 hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
852 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
853 for (i = 0; i < sizeof(data); i++)
854 ok(data[i] == data_8bpp_rgb_dib[i], "%u: expected %#x, got %#x\n", i, data_8bpp_rgb_dib[i], data[i]);
855
856 IWICBitmap_Release(bitmap);
857 DeleteObject(hbmp);
858
859 /* 8 bpp with a 3 entries palette */
860 memset(pal_buf, 0, sizeof(pal_buf));
861 pal->palVersion = 0x300;
862 pal->palNumEntries = 3;
863 memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
864 hpal = CreatePalette(pal);
865 ok(hpal != 0, "CreatePalette failed\n");
866
867 hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
868 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
869 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
870
871 IWICBitmap_GetPixelFormat(bitmap, &format);
872 todo_wine
873 ok(IsEqualGUID(&format, &GUID_WICPixelFormat4bppIndexed),
874 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
875
876 hr = IWICBitmap_GetSize(bitmap, &width, &height);
877 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
878 ok(width == 3, "expected 3, got %u\n", width);
879 ok(height == 3, "expected 3, got %u\n", height);
880
881 hr = IWICImagingFactory_CreatePalette(factory, &palette);
882 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
883 hr = IWICBitmap_CopyPalette(bitmap, palette);
884 ok(hr == S_OK, "CopyPalette error %#x\n", hr);
885
886 hr = IWICPalette_GetType(palette, &type);
887 ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
888 ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
889
890 hr = IWICPalette_GetColorCount(palette, &count);
891 ok(hr == S_OK, "GetColorCount error %#x\n", hr);
892 todo_wine
893 ok(count == 16, "expected 16, got %u\n", count);
894
895 IWICPalette_Release(palette);
896
897 IWICBitmap_Release(bitmap);
898 DeleteObject(hbmp);
899 DeleteObject(hpal);
900
901 /* 8 bpp with a 256 entries palette */
902 memset(pal_buf, 0, sizeof(pal_buf));
903 pal->palVersion = 0x300;
904 pal->palNumEntries = 256;
905 memcpy(pal->palPalEntry, pal_data, sizeof(pal_data));
906 hpal = CreatePalette(pal);
907 ok(hpal != 0, "CreatePalette failed\n");
908
909 hbmp = create_dib(3, 3, 8, pal, data_8bpp_pal_dib);
910 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, hpal, WICBitmapIgnoreAlpha, &bitmap);
911 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
912
913 IWICBitmap_GetPixelFormat(bitmap, &format);
914 ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
915 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
916
917 hr = IWICBitmap_GetSize(bitmap, &width, &height);
918 ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
919 ok(width == 3, "expected 3, got %u\n", width);
920 ok(height == 3, "expected 3, got %u\n", height);
921
922 hr = IWICImagingFactory_CreatePalette(factory, &palette);
923 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
924 hr = IWICBitmap_CopyPalette(bitmap, palette);
925 ok(hr == S_OK, "CopyPalette error %#x\n", hr);
926
927 hr = IWICPalette_GetType(palette, &type);
928 ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
929 ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %#x\n", type);
930
931 hr = IWICPalette_GetColorCount(palette, &count);
932 ok(hr == S_OK, "GetColorCount error %#x\n", hr);
933 ok(count == 256, "expected 256, got %u\n", count);
934
935 IWICPalette_Release(palette);
936
937 memset(data, 0, sizeof(data));
938 hr = IWICBitmap_CopyPixels(bitmap, NULL, 4, sizeof(data), data);
939 ok(hr == S_OK, "IWICBitmap_CopyPixels error %#x\n", hr);
940 for (i = 0; i < sizeof(data); i++)
941 todo_wine_if (data[i] != data_8bpp_pal_wic[i])
942 ok(data[i] == data_8bpp_pal_wic[i], "%u: expected %#x, got %#x\n", i, data_8bpp_pal_wic[i], data[i]);
943
944 IWICBitmap_Release(bitmap);
945 DeleteObject(hbmp);
946 DeleteObject(hpal);
947
948 /* 32bpp alpha */
949 hbmp = create_dib(2, 2, 32, NULL, NULL);
950 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUseAlpha, &bitmap);
951 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
952
953 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
954 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
955 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA),
956 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
957
958 IWICBitmap_Release(bitmap);
959
960 /* 32bpp pre-multiplied alpha */
961 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapUsePremultipliedAlpha, &bitmap);
962 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
963
964 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
965 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
966 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppPBGRA),
967 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
968
969 IWICBitmap_Release(bitmap);
970
971 /* 32bpp no alpha */
972 hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, hbmp, NULL, WICBitmapIgnoreAlpha, &bitmap);
973 ok(hr == S_OK, "CreateBitmapFromHBITMAP error %#x\n", hr);
974
975 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
976 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
977 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGR),
978 "unexpected pixel format %s\n", wine_dbgstr_guid(&format));
979
980 IWICBitmap_Release(bitmap);
981 DeleteObject(hbmp);
982 }
983
test_clipper(void)984 static void test_clipper(void)
985 {
986 IWICBitmapClipper *clipper;
987 UINT height, width;
988 IWICBitmap *bitmap;
989 BYTE buffer[500];
990 WICRect rect;
991 HRESULT hr;
992
993 hr = IWICImagingFactory_CreateBitmap(factory, 10, 10, &GUID_WICPixelFormat24bppBGR,
994 WICBitmapCacheOnLoad, &bitmap);
995 ok(hr == S_OK, "got 0x%08x\n", hr);
996
997 hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
998 ok(hr == S_OK, "got 0x%08x\n", hr);
999
1000 rect.X = rect.Y = 0;
1001 rect.Width = rect.Height = 11;
1002 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
1003 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1004
1005 rect.X = rect.Y = 5;
1006 rect.Width = rect.Height = 6;
1007 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
1008 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1009
1010 rect.X = rect.Y = 5;
1011 rect.Width = rect.Height = 5;
1012 hr = IWICBitmapClipper_Initialize(clipper, (IWICBitmapSource*)bitmap, &rect);
1013 ok(hr == S_OK, "got 0x%08x\n", hr);
1014
1015 width = height = 0;
1016 hr = IWICBitmapClipper_GetSize(clipper, &width, &height);
1017 ok(hr == S_OK, "got 0x%08x\n", hr);
1018 ok(width == 5, "got %d\n", width);
1019 ok(height == 5, "got %d\n", height);
1020
1021 IWICBitmapClipper_Release(clipper);
1022 IWICBitmap_Release(bitmap);
1023
1024 /* CopyPixels */
1025 hr = IWICImagingFactory_CreateBitmapClipper(factory, &clipper);
1026 ok(hr == S_OK, "got 0x%08x\n", hr);
1027
1028 rect.X = rect.Y = 5;
1029 rect.Width = rect.Height = 5;
1030 hr = IWICBitmapClipper_Initialize(clipper, &bitmapsource, &rect);
1031 ok(hr == S_OK, "got 0x%08x\n", hr);
1032
1033 rect.X = rect.Y = 0;
1034 rect.Width = rect.Height = 2;
1035
1036 /* passed rectangle is relative to clipper rectangle, underlying source gets intersected
1037 rectangle */
1038 memset(&g_rect, 0, sizeof(g_rect));
1039 called_CopyPixels = FALSE;
1040 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1041 ok(hr == S_OK, "got 0x%08x\n", hr);
1042 ok(called_CopyPixels, "CopyPixels not called\n");
1043 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 2 && g_rect.Height == 2,
1044 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
1045
1046 /* whole clipping rectangle */
1047 memset(&g_rect, 0, sizeof(g_rect));
1048 called_CopyPixels = FALSE;
1049
1050 rect.X = rect.Y = 0;
1051 rect.Width = rect.Height = 5;
1052
1053 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1054 ok(hr == S_OK, "got 0x%08x\n", hr);
1055 ok(called_CopyPixels, "CopyPixels not called\n");
1056 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
1057 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
1058
1059 /* larger than clipping rectangle */
1060 memset(&g_rect, 0, sizeof(g_rect));
1061 called_CopyPixels = FALSE;
1062
1063 rect.X = rect.Y = 0;
1064 rect.Width = rect.Height = 20;
1065
1066 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1067 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1068 ok(!called_CopyPixels, "CopyPixels called\n");
1069
1070 rect.X = rect.Y = 5;
1071 rect.Width = rect.Height = 5;
1072
1073 hr = IWICBitmapClipper_CopyPixels(clipper, &rect, 0, sizeof(buffer), buffer);
1074 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1075 ok(!called_CopyPixels, "CopyPixels called\n");
1076
1077 /* null rectangle */
1078 memset(&g_rect, 0, sizeof(g_rect));
1079 called_CopyPixels = FALSE;
1080
1081 hr = IWICBitmapClipper_CopyPixels(clipper, NULL, 0, sizeof(buffer), buffer);
1082 ok(hr == S_OK, "got 0x%08x\n", hr);
1083 ok(called_CopyPixels, "CopyPixels not called\n");
1084 ok(g_rect.X == 5 && g_rect.Y == 5 && g_rect.Width == 5 && g_rect.Height == 5,
1085 "got wrong rectangle (%d,%d)-(%d,%d)\n", g_rect.X, g_rect.Y, g_rect.Width, g_rect.Height);
1086
1087 IWICBitmapClipper_Release(clipper);
1088 }
1089
1090 static HRESULT (WINAPI *pWICCreateBitmapFromSectionEx)
1091 (UINT, UINT, REFWICPixelFormatGUID, HANDLE, UINT, UINT, WICSectionAccessLevel, IWICBitmap **);
1092
test_WICCreateBitmapFromSectionEx(void)1093 static void test_WICCreateBitmapFromSectionEx(void)
1094 {
1095 SYSTEM_INFO sysinfo;
1096 HANDLE hsection;
1097 BITMAPINFO info;
1098 void *bits;
1099 HBITMAP hdib;
1100 IWICBitmap *bitmap;
1101 HRESULT hr;
1102 pWICCreateBitmapFromSectionEx =
1103 (void *)GetProcAddress(LoadLibraryA("windowscodecs"), "WICCreateBitmapFromSectionEx");
1104
1105 if (!pWICCreateBitmapFromSectionEx)
1106 {
1107 win_skip("WICCreateBitmapFromSectionEx not available\n");
1108 return;
1109 }
1110
1111 GetSystemInfo(&sysinfo);
1112 hsection = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
1113 sysinfo.dwAllocationGranularity * 2, NULL);
1114 ok(hsection != NULL, "CreateFileMapping failed %u\n", GetLastError());
1115
1116 memset(&info, 0, sizeof(info));
1117 info.bmiHeader.biSize = sizeof(info.bmiHeader);
1118 info.bmiHeader.biWidth = 3;
1119 info.bmiHeader.biHeight = -3;
1120 info.bmiHeader.biBitCount = 24;
1121 info.bmiHeader.biPlanes = 1;
1122 info.bmiHeader.biCompression = BI_RGB;
1123
1124 hdib = CreateDIBSection(0, &info, DIB_RGB_COLORS, &bits, hsection, 0);
1125 ok(hdib != NULL, "CreateDIBSection failed\n");
1126
1127 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0,
1128 WICSectionAccessLevelReadWrite, &bitmap);
1129 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1130 IWICBitmap_Release(bitmap);
1131
1132 /* non-zero offset, smaller than allocation granularity */
1133 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0, 0x100,
1134 WICSectionAccessLevelReadWrite, &bitmap);
1135 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1136 IWICBitmap_Release(bitmap);
1137
1138 /* offset larger than allocation granularity */
1139 hr = pWICCreateBitmapFromSectionEx(3, 3, &GUID_WICPixelFormat24bppBGR, hsection, 0,
1140 sysinfo.dwAllocationGranularity + 1,
1141 WICSectionAccessLevelReadWrite, &bitmap);
1142 ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1143 IWICBitmap_Release(bitmap);
1144 DeleteObject(hdib);
1145 CloseHandle(hsection);
1146 }
1147
test_bitmap_scaler(void)1148 static void test_bitmap_scaler(void)
1149 {
1150 WICPixelFormatGUID pixel_format;
1151 IWICBitmapScaler *scaler;
1152 IWICPalette *palette;
1153 double res_x, res_y;
1154 IWICBitmap *bitmap;
1155 UINT width, height;
1156 BYTE buf[16];
1157 HRESULT hr;
1158
1159 hr = IWICImagingFactory_CreateBitmap(factory, 4, 2, &GUID_WICPixelFormat24bppBGR, WICBitmapCacheOnLoad, &bitmap);
1160 ok(hr == S_OK, "Failed to create a bitmap, hr %#x.\n", hr);
1161
1162 hr = IWICBitmap_GetSize(bitmap, &width, &height);
1163 ok(hr == S_OK, "Failed to get bitmap size, hr %#x.\n", hr);
1164 ok(width == 4, "Unexpected width %u.\n", width);
1165 ok(height == 2, "Unexpected height %u.\n", height);
1166
1167 hr = IWICBitmap_GetResolution(bitmap, &res_x, &res_y);
1168 ok(hr == S_OK, "Failed to get bitmap resolution, hr %#x.\n", hr);
1169 ok(res_x == 0.0 && res_y == 0.0, "Unexpected resolution %f x %f.\n", res_x, res_y);
1170
1171 hr = IWICImagingFactory_CreateBitmapScaler(factory, &scaler);
1172 ok(hr == S_OK, "Failed to create bitmap scaler, hr %#x.\n", hr);
1173
1174 hr = IWICBitmapScaler_Initialize(scaler, NULL, 0, 0,
1175 WICBitmapInterpolationModeNearestNeighbor);
1176 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1177
1178 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 0,
1179 WICBitmapInterpolationModeNearestNeighbor);
1180 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1181
1182 hr = IWICBitmapScaler_GetSize(scaler, NULL, &height);
1183 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1184
1185 hr = IWICBitmapScaler_GetSize(scaler, &width, NULL);
1186 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1187
1188 hr = IWICBitmapScaler_GetResolution(scaler, NULL, NULL);
1189 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1190
1191 res_x = 0.1;
1192 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, NULL);
1193 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1194 ok(res_x == 0.1, "Unexpected resolution %f.\n", res_x);
1195
1196 hr = IWICBitmapScaler_GetResolution(scaler, NULL, &res_y);
1197 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1198
1199 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, &res_y);
1200 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1201
1202 hr = IWICBitmapScaler_GetPixelFormat(scaler, NULL);
1203 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1204
1205 memset(&pixel_format, 0, sizeof(pixel_format));
1206 hr = IWICBitmapScaler_GetPixelFormat(scaler, &pixel_format);
1207 ok(hr == S_OK, "Failed to get pixel format, hr %#x.\n", hr);
1208 ok(IsEqualGUID(&pixel_format, &GUID_WICPixelFormatDontCare), "Unexpected pixel format %s.\n",
1209 wine_dbgstr_guid(&pixel_format));
1210
1211 width = 123;
1212 height = 321;
1213 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1214 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1215 ok(width == 123, "Unexpected width %u.\n", width);
1216 ok(height == 321, "Unexpected height %u.\n", height);
1217
1218 hr = IWICBitmapScaler_CopyPalette(scaler, NULL);
1219 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1220
1221 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1222 ok(hr == S_OK, "Failed to create a palette, hr %#x.\n", hr);
1223 hr = IWICBitmapScaler_CopyPalette(scaler, palette);
1224 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "Unexpected hr %#x.\n", hr);
1225 IWICPalette_Release(palette);
1226
1227 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 4, 0,
1228 WICBitmapInterpolationModeNearestNeighbor);
1229 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1230
1231 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1232 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1233
1234 hr = IWICBitmapScaler_CopyPixels(scaler, NULL, 1, sizeof(buf), buf);
1235 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1236
1237 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 2,
1238 WICBitmapInterpolationModeNearestNeighbor);
1239 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1240
1241 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1242 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "Unexpected hr %#x.\n", hr);
1243
1244 hr = IWICBitmapScaler_Initialize(scaler, NULL, 8, 4,
1245 WICBitmapInterpolationModeNearestNeighbor);
1246 ok(hr == E_INVALIDARG, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1247
1248 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 4,
1249 WICBitmapInterpolationModeNearestNeighbor);
1250 ok(hr == S_OK, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1251
1252 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 4,
1253 WICBitmapInterpolationModeNearestNeighbor);
1254 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1255
1256 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 0,
1257 WICBitmapInterpolationModeNearestNeighbor);
1258 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1259
1260 hr = IWICBitmapScaler_Initialize(scaler, NULL, 8, 4, WICBitmapInterpolationModeNearestNeighbor);
1261 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1262
1263 hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 4,
1264 WICBitmapInterpolationModeNearestNeighbor);
1265 ok(hr == WINCODEC_ERR_WRONGSTATE, "Unexpected hr %#x.\n", hr);
1266
1267 hr = IWICBitmapScaler_GetSize(scaler, &width, &height);
1268 ok(hr == S_OK, "Failed to get scaler size, hr %#x.\n", hr);
1269 ok(width == 8, "Unexpected width %u.\n", width);
1270 ok(height == 4, "Unexpected height %u.\n", height);
1271
1272 hr = IWICBitmapScaler_GetSize(scaler, NULL, &height);
1273 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1274
1275 hr = IWICBitmapScaler_GetSize(scaler, &width, NULL);
1276 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1277
1278 hr = IWICBitmapScaler_GetSize(scaler, NULL, NULL);
1279 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1280
1281 hr = IWICBitmapScaler_GetPixelFormat(scaler, NULL);
1282 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1283
1284 memset(&pixel_format, 0, sizeof(pixel_format));
1285 hr = IWICBitmapScaler_GetPixelFormat(scaler, &pixel_format);
1286 ok(hr == S_OK, "Failed to get pixel format, hr %#x.\n", hr);
1287 ok(IsEqualGUID(&pixel_format, &GUID_WICPixelFormat24bppBGR), "Unexpected pixel format %s.\n",
1288 wine_dbgstr_guid(&pixel_format));
1289
1290 hr = IWICBitmapScaler_GetResolution(scaler, NULL, NULL);
1291 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1292
1293 res_x = 0.1;
1294 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, NULL);
1295 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1296 ok(res_x == 0.1, "Unexpected resolution %f.\n", res_x);
1297
1298 hr = IWICBitmapScaler_GetResolution(scaler, NULL, &res_y);
1299 ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1300
1301 res_x = res_y = 1.0;
1302 hr = IWICBitmapScaler_GetResolution(scaler, &res_x, &res_y);
1303 ok(hr == S_OK, "Failed to get scaler resolution, hr %#x.\n", hr);
1304 ok(res_x == 0.0 && res_y == 0.0, "Unexpected resolution %f x %f.\n", res_x, res_y);
1305
1306 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1307 ok(hr == S_OK, "Failed to create a palette, hr %#x.\n", hr);
1308 hr = IWICBitmapScaler_CopyPalette(scaler, palette);
1309 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "Unexpected hr %#x.\n", hr);
1310 IWICPalette_Release(palette);
1311
1312 IWICBitmapScaler_Release(scaler);
1313
1314 IWICBitmap_Release(bitmap);
1315 }
1316
obj_refcount(void * obj)1317 static LONG obj_refcount(void *obj)
1318 {
1319 IUnknown_AddRef((IUnknown *)obj);
1320 return IUnknown_Release((IUnknown *)obj);
1321 }
1322
test_IMILBitmap(void)1323 static void test_IMILBitmap(void)
1324 {
1325 HRESULT hr;
1326 IWICBitmap *bitmap;
1327 IWICBitmapScaler *scaler;
1328 IMILBitmap *mil_bitmap;
1329 IMILBitmapSource *mil_source;
1330 IMILBitmapScaler *mil_scaler;
1331 IUnknown *wic_unknown, *mil_unknown;
1332 WICPixelFormatGUID format;
1333 int MIL_format;
1334 UINT width, height;
1335 double dpix, dpiy;
1336 BYTE buf[256];
1337
1338 /* Bitmap */
1339 hr = IWICImagingFactory_CreateBitmap(factory, 1, 1, &GUID_WICPixelFormat24bppBGR,
1340 WICBitmapCacheOnDemand, &bitmap);
1341 ok(hr == S_OK, "CreateBitmap error %#x\n", hr);
1342
1343 ok(obj_refcount(bitmap) == 1, "ref count %d\n", obj_refcount(bitmap));
1344
1345 hr = IWICBitmap_GetPixelFormat(bitmap, &format);
1346 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
1347 ok(IsEqualGUID(&format, &GUID_WICPixelFormat24bppBGR), "wrong format %s\n", wine_dbgstr_guid(&format));
1348
1349 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
1350 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1351 ok(dpix == 0.0, "got %f, expected 0.0\n", dpix);
1352 ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy);
1353
1354 hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
1355 ok(hr == S_OK, "SetResolution error %#x\n", hr);
1356
1357 hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
1358 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1359 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
1360 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
1361
1362 hr = IWICBitmap_GetSize(bitmap, &width, &height);
1363 ok(hr == S_OK, "GetSize error %#x\n", hr);
1364 ok(width == 1, "got %u, expected 1\n", width);
1365 ok(height == 1, "got %u, expected 1\n", height);
1366
1367 hr = IWICBitmap_QueryInterface(bitmap, &IID_IMILBitmap, (void **)&mil_bitmap);
1368 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1369
1370 ok(obj_refcount(bitmap) == 2, "ref count %d\n", obj_refcount(bitmap));
1371 ok(obj_refcount(mil_bitmap) == 2, "ref count %d\n", obj_refcount(mil_bitmap));
1372
1373 hr = IWICBitmap_QueryInterface(bitmap, &IID_IUnknown, (void **)&wic_unknown);
1374 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1375
1376 hr = mil_bitmap->lpVtbl->QueryInterface(mil_bitmap, &IID_IUnknown, (void **)&mil_unknown);
1377 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1378 ok((void *)wic_unknown->lpVtbl == (void *)mil_unknown->lpVtbl, "wrong lpVtbl ptrs %p != %p\n", wic_unknown->lpVtbl, mil_unknown->lpVtbl);
1379
1380 IUnknown_Release(wic_unknown);
1381 IUnknown_Release(mil_unknown);
1382
1383 hr = IWICBitmap_QueryInterface(bitmap, &IID_IMILBitmapSource, (void **)&mil_source);
1384 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1385 ok((void *)mil_source->lpVtbl == (void *)mil_bitmap->lpVtbl, "IMILBitmap->lpVtbl should be equal to IMILBitmapSource->lpVtbl\n");
1386
1387 ok(obj_refcount(bitmap) == 3, "ref count %d\n", obj_refcount(bitmap));
1388 ok(obj_refcount(mil_bitmap) == 3, "ref count %d\n", obj_refcount(mil_bitmap));
1389 ok(obj_refcount(mil_source) == 3, "ref count %d\n", obj_refcount(mil_source));
1390
1391 hr = mil_source->lpVtbl->GetPixelFormat(mil_source, &MIL_format);
1392 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
1393 ok(MIL_format == 0x0c, "wrong format %d\n", MIL_format);
1394
1395 hr = mil_source->lpVtbl->GetResolution(mil_source, &dpix, &dpiy);
1396 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1397 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
1398 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
1399
1400 hr = mil_source->lpVtbl->GetSize(mil_source, &width, &height);
1401 ok(hr == S_OK, "GetSize error %#x\n", hr);
1402 ok(width == 1, "got %u, expected 1\n", width);
1403 ok(height == 1, "got %u, expected 1\n", height);
1404
1405 /* Scaler */
1406 hr = IWICImagingFactory_CreateBitmapScaler(factory, &scaler);
1407 ok(hr == S_OK, "CreateBitmapScaler error %#x\n", hr);
1408
1409 ok(obj_refcount(scaler) == 1, "ref count %d\n", obj_refcount(scaler));
1410
1411 hr = IWICBitmapScaler_QueryInterface(scaler, &IID_IMILBitmapScaler, (void **)&mil_scaler);
1412 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1413
1414 ok(obj_refcount(scaler) == 2, "ref count %d\n", obj_refcount(scaler));
1415 ok(obj_refcount(mil_scaler) == 2, "ref count %d\n", obj_refcount(mil_scaler));
1416
1417 hr = IWICBitmapScaler_QueryInterface(scaler, &IID_IUnknown, (void **)&wic_unknown);
1418 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1419
1420 hr = mil_scaler->lpVtbl->QueryInterface(mil_scaler, &IID_IUnknown, (void **)&mil_unknown);
1421 ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1422 ok((void *)wic_unknown->lpVtbl == (void *)mil_unknown->lpVtbl, "wrong lpVtbl ptrs %p != %p\n", wic_unknown->lpVtbl, mil_unknown->lpVtbl);
1423
1424 IUnknown_Release(wic_unknown);
1425 IUnknown_Release(mil_unknown);
1426
1427 hr = mil_scaler->lpVtbl->GetPixelFormat(mil_scaler, &MIL_format);
1428 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetPixelFormat error %#x\n", hr);
1429
1430 hr = mil_scaler->lpVtbl->GetResolution(mil_scaler, &dpix, &dpiy);
1431 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetResolution error %#x\n", hr);
1432
1433 hr = mil_scaler->lpVtbl->GetSize(mil_scaler, &width, &height);
1434 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "GetSize error %#x\n", hr);
1435
1436 memset(buf, 0xde, sizeof(buf));
1437 hr = mil_scaler->lpVtbl->CopyPixels(mil_scaler, NULL, 3, sizeof(buf), buf);
1438 ok(hr == WINCODEC_ERR_NOTINITIALIZED, "CopyPixels error %#x\n", hr);
1439
1440 hr = mil_scaler->lpVtbl->Initialize(mil_scaler, mil_source, 1, 1, 1);
1441 ok(hr == S_OK, "Initialize error %#x\n", hr);
1442
1443 hr = mil_scaler->lpVtbl->GetPixelFormat(mil_scaler, &MIL_format);
1444 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
1445 ok(MIL_format == 0x0c, "wrong format %d\n", MIL_format);
1446
1447 hr = mil_scaler->lpVtbl->GetResolution(mil_scaler, &dpix, &dpiy);
1448 ok(hr == S_OK, "GetResolution error %#x\n", hr);
1449 ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
1450 ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
1451
1452 hr = mil_scaler->lpVtbl->GetSize(mil_scaler, &width, &height);
1453 ok(hr == S_OK, "GetSize error %#x\n", hr);
1454 ok(width == 1, "got %u, expected 1\n", width);
1455 ok(height == 1, "got %u, expected 1\n", height);
1456
1457 memset(buf, 0xde, sizeof(buf));
1458 hr = mil_scaler->lpVtbl->CopyPixels(mil_scaler, NULL, 3, sizeof(buf), buf);
1459 ok(hr == S_OK, "CopyPixels error %#x\n", hr);
1460 ok(buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] == 0xde,"wrong data: %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);
1461
1462 mil_scaler->lpVtbl->Release(mil_scaler);
1463 IWICBitmapScaler_Release(scaler);
1464 mil_source->lpVtbl->Release(mil_source);
1465 mil_bitmap->lpVtbl->Release(mil_bitmap);
1466 IWICBitmap_Release(bitmap);
1467 }
1468
START_TEST(bitmap)1469 START_TEST(bitmap)
1470 {
1471 HRESULT hr;
1472
1473 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1474
1475 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1476 &IID_IWICImagingFactory, (void**)&factory);
1477 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
1478
1479 test_IMILBitmap();
1480 test_createbitmap();
1481 test_createbitmapfromsource();
1482 test_CreateBitmapFromMemory();
1483 test_CreateBitmapFromHICON();
1484 test_CreateBitmapFromHBITMAP();
1485 test_clipper();
1486 test_bitmap_scaler();
1487
1488 IWICImagingFactory_Release(factory);
1489
1490 CoUninitialize();
1491
1492 test_WICCreateBitmapFromSectionEx();
1493 }
1494