ReactOS 0.4.16-dev-41-ge8c7597
bitmap.c
Go to the documentation of this file.
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"
34DEFINE_GUID(IID_IMILUnknown,0x0ccd7824,0xdc16,0x4d09,0xbc,0xa8,0x6b,0x09,0xc4,0xef,0x55,0x35);
35DEFINE_GUID(IID_IMILBitmap,0xb1784d3f,0x8115,0x4763,0x13,0xaa,0x32,0xed,0xdb,0x68,0x29,0x4a);
36DEFINE_GUID(IID_IMILBitmapSource,0x7543696a,0xbc8d,0x46b0,0x5f,0x81,0x8d,0x95,0x72,0x89,0x72,0xbe);
37DEFINE_GUID(IID_IMILBitmapLock,0xa67b2b53,0x8fa1,0x4155,0x8f,0x64,0x0c,0x24,0x7a,0x8f,0x84,0xcd);
38DEFINE_GUID(IID_IMILBitmapScaler,0xa767b0f0,0x1c8c,0x4aef,0x56,0x8f,0xad,0xf9,0x6d,0xcf,0xd5,0xcb);
39DEFINE_GUID(IID_IMILFormatConverter,0x7e2a746f,0x25c5,0x4851,0xb3,0xaf,0x44,0x3b,0x79,0x63,0x9e,0xc0);
40DEFINE_GUID(IID_IMILPalette,0xca8e206f,0xf22c,0x4af7,0x6f,0xba,0x7b,0xed,0x5e,0xb1,0xc9,0x2f);
41
42#undef INTERFACE
43#define INTERFACE IMILBitmapSource
44DECLARE_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
59DECLARE_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
81DECLARE_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
98static IWICImagingFactory *factory;
99
100static 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
116static ULONG WINAPI bitmapsource_AddRef(IWICBitmapSource *iface)
117{
118 return 2;
119}
120
121static ULONG WINAPI bitmapsource_Release(IWICBitmapSource *iface)
122{
123 return 1;
124}
125
126static HRESULT WINAPI bitmapsource_GetSize(IWICBitmapSource *iface, UINT *width, UINT *height)
127{
128 *width = *height = 10;
129 return S_OK;
130}
131
132static HRESULT WINAPI bitmapsource_GetPixelFormat(IWICBitmapSource *iface,
133 WICPixelFormatGUID *format)
134{
135 return E_NOTIMPL;
136}
137
138static HRESULT WINAPI bitmapsource_GetResolution(IWICBitmapSource *iface,
139 double *dpiX, double *dpiY)
140{
141 return E_NOTIMPL;
142}
143
144static HRESULT WINAPI bitmapsource_CopyPalette(IWICBitmapSource *iface,
145 IWICPalette *palette)
146{
147 return E_NOTIMPL;
148}
149
150static WICRect g_rect;
151static BOOL called_CopyPixels;
152
153static 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
161static 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
172static IWICBitmapSource bitmapsource = { &sourcevtbl };
173
174static 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
219static 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
455static 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
659static 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
734static 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
809static 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);
872todo_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);
892todo_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
984static 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
1090static HRESULT (WINAPI *pWICCreateBitmapFromSectionEx)
1091 (UINT, UINT, REFWICPixelFormatGUID, HANDLE, UINT, UINT, WICSectionAccessLevel, IWICBitmap **);
1092
1093static 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
1148static 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
1317static LONG obj_refcount(void *obj)
1318{
1319 IUnknown_AddRef((IUnknown *)obj);
1320 return IUnknown_Release((IUnknown *)obj);
1321}
1322
1323static 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
1469START_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}
ok
#define ok(value,...)
Definition: atltest.h:57
broken
#define broken(x)
Definition: atltest.h:178
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
DECLARE_INTERFACE_
#define DECLARE_INTERFACE_(i, b)
Definition: basetyps.h:78
PURE
#define PURE
Definition: basetyps.h:64
THIS_
#define THIS_
Definition: basetyps.h:65
THIS
#define THIS
Definition: basetyps.h:66
STDMETHOD_
#define STDMETHOD_(t, m)
Definition: basetyps.h:63
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
hbmp
HBITMAP hbmp
Definition: buttonvistest.cpp:10
Release
_In_ BOOLEAN Release
Definition: cdrom.h:920
GetSize
DWORD WINAPI GetSize(LPVOID)
Definition: comctl32undoc.c:132
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
E_NOTIMPL
#define E_NOTIMPL
Definition: ddrawi.h:99
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
bpp
DWORD bpp
Definition: surface.c:185
CloseHandle
#define CloseHandle
Definition: compat.h:739
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
CreateFileMappingW
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:744
sysinfo
SYSTEM_INFO sysinfo
Definition: dbghelp.c:76
palette_type
WICBitmapPaletteType palette_type
Definition: image.c:53
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
GetSystemInfo
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:143
CoCreateInstance
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
CoInitializeEx
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
CoUninitialize
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
pixelformat
pixelformat
Definition: converter.c:40
assert
#define assert(x)
Definition: debug.h:53
BI_RGB
#define BI_RGB
Definition: precomp.h:56
RGBQUAD
ULONG RGBQUAD
Definition: precomp.h:59
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
DeleteObject
pKey DeleteObject()
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
height
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
width
GLint GLint GLsizei width
Definition: gl.h:1546
stride
GLsizei stride
Definition: glext.h:5848
buffer
GLuint buffer
Definition: glext.h:5915
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
bits
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
ppv
REFIID LPVOID * ppv
Definition: atlbase.h:39
bits
#define bits
Definition: infblock.c:15
IUnknown::QueryInterface
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
S_OK
#define S_OK
Definition: intsafe.h:52
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
lock_buffer
static void lock_buffer(struct buffer_head *bh)
Definition: module.h:1028
HBITMAP
static HBITMAP
Definition: button.c:44
HICON
static HICON
Definition: imagelist.c:80
QueryInterface
static HRESULT QueryInterface(REFIID, void **)
Definition: events.c:2587
todo_wine_if
#define todo_wine_if(is_todo)
Definition: custom.c:76
todo_wine
#define todo_wine
Definition: custom.c:79
double
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
AddRef
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
palette
static HPALETTE palette
Definition: clipboard.c:1345
bitmap2
static HBITMAP bitmap2
Definition: clipboard.c:1344
g_rect
static WICRect g_rect
Definition: bitmap.c:150
bitmapsource_QueryInterface
static HRESULT WINAPI bitmapsource_QueryInterface(IWICBitmapSource *iface, REFIID iid, void **ppv)
Definition: bitmap.c:100
test_bitmap_scaler
static void test_bitmap_scaler(void)
Definition: bitmap.c:1148
WICSectionAccessLevel
static WICSectionAccessLevel
Definition: bitmap.c:1091
bitmapsource_CopyPalette
static HRESULT WINAPI bitmapsource_CopyPalette(IWICBitmapSource *iface, IWICPalette *palette)
Definition: bitmap.c:144
bitmapsource_GetPixelFormat
static HRESULT WINAPI bitmapsource_GetPixelFormat(IWICBitmapSource *iface, WICPixelFormatGUID *format)
Definition: bitmap.c:132
REFWICPixelFormatGUID
static REFWICPixelFormatGUID
Definition: bitmap.c:1091
HANDLE
static HANDLE
Definition: bitmap.c:1091
test_CreateBitmapFromMemory
static void test_CreateBitmapFromMemory(void)
Definition: bitmap.c:659
test_CreateBitmapFromHICON
static void test_CreateBitmapFromHICON(void)
Definition: bitmap.c:734
bitmapsource_AddRef
static ULONG WINAPI bitmapsource_AddRef(IWICBitmapSource *iface)
Definition: bitmap.c:116
bitmapsource_GetSize
static HRESULT WINAPI bitmapsource_GetSize(IWICBitmapSource *iface, UINT *width, UINT *height)
Definition: bitmap.c:126
bitmapsource_GetResolution
static HRESULT WINAPI bitmapsource_GetResolution(IWICBitmapSource *iface, double *dpiX, double *dpiY)
Definition: bitmap.c:138
factory
static IWICImagingFactory * factory
Definition: bitmap.c:98
bitmapsource
static IWICBitmapSource bitmapsource
Definition: bitmap.c:172
bitmapsource_Release
static ULONG WINAPI bitmapsource_Release(IWICBitmapSource *iface)
Definition: bitmap.c:121
called_CopyPixels
static BOOL called_CopyPixels
Definition: bitmap.c:151
test_CreateBitmapFromHBITMAP
static void test_CreateBitmapFromHBITMAP(void)
Definition: bitmap.c:809
bitmapsource_CopyPixels
static HRESULT WINAPI bitmapsource_CopyPixels(IWICBitmapSource *iface, const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
Definition: bitmap.c:153
test_WICCreateBitmapFromSectionEx
static IWICBitmap **static void test_WICCreateBitmapFromSectionEx(void)
Definition: bitmap.c:1093
test_createbitmap
static void test_createbitmap(void)
Definition: bitmap.c:219
test_IMILBitmap
static void test_IMILBitmap(void)
Definition: bitmap.c:1323
test_clipper
static void test_clipper(void)
Definition: bitmap.c:984
sourcevtbl
static const IWICBitmapSourceVtbl sourcevtbl
Definition: bitmap.c:161
test_createbitmapfromsource
static void test_createbitmapfromsource(void)
Definition: bitmap.c:455
create_dib
static HBITMAP create_dib(int width, int height, int bpp, LOGPALETTE *pal, const void *data)
Definition: bitmap.c:174
obj_refcount
static LONG obj_refcount(void *obj)
Definition: bitmap.c:1317
UINT
static UINT
Definition: bitmap.c:1091
UINT
unsigned int UINT
Definition: ndis.h:50
PAGE_READWRITE
#define PAGE_READWRITE
Definition: nt_native.h:1304
DWORD
#define DWORD
Definition: nt_native.h:44
Unlock
@ Unlock
Definition: ntsecapi.h:294
COINIT_APARTMENTTHREADED
@ COINIT_APARTMENTTHREADED
Definition: objbase.h:278
LONG
long LONG
Definition: pedump.c:60
DEFINE_GUID
#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)
Definition: guiddef.h:68
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
IsEqualIID
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
REFIID
#define REFIID
Definition: guiddef.h:118
wine_dbgstr_guid
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197
win_skip
#define win_skip
Definition: test.h:163
memset
#define memset(x, y, z)
Definition: compat.h:39
hr
HRESULT hr
Definition: shlfolder.c:183
rect
& rect
Definition: startmenu.cpp:1413
WICRect::Height
INT Height
Definition: wincodec.idl:301
WICRect::Width
INT Width
Definition: wincodec.idl:300
_BITMAP
Definition: bl.h:1331
_ICONINFO
Definition: winuser.h:3125
_SYSTEM_INFO
Definition: winbase.h:1165
_SYSTEM_INFO::dwAllocationGranularity
DWORD dwAllocationGranularity
Definition: winbase.h:1179
bitmap_data
Definition: converter.c:35
bitmap
Definition: uimain.c:89
factory
Definition: main.c:439
pixel_format
Definition: swimpl.c:28
tagBITMAPINFOHEADER::biClrImportant
ULONG biClrImportant
Definition: precomp.h:52
tagBITMAPINFOHEADER::biBitCount
USHORT biBitCount
Definition: precomp.h:46
tagBITMAPINFOHEADER::biCompression
ULONG biCompression
Definition: precomp.h:47
tagBITMAPINFO::bmiHeader
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1476
tagBITMAPINFO::bmiColors
RGBQUAD bmiColors[1]
Definition: wingdi.h:1477
tagLOGPALETTE::palNumEntries
WORD palNumEntries
Definition: wingdi.h:1834
tagLOGPALETTE::palVersion
WORD palVersion
Definition: wingdi.h:1833
tagRGBQUAD::rgbReserved
UCHAR rgbReserved
Definition: bootanim.c:106
tagRGBQUAD::rgbBlue
UCHAR rgbBlue
Definition: bootanim.c:103
tagRGBQUAD::rgbRed
UCHAR rgbRed
Definition: bootanim.c:105
tagRGBQUAD::rgbGreen
UCHAR rgbGreen
Definition: bootanim.c:104
buffer_size
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888
lock
rwlock_t lock
Definition: tcpcore.h:0
ULONG
uint32_t ULONG
Definition: typedefs.h:59
Lock
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
CreateDIBSection
HBITMAP WINAPI CreateDIBSection(HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
Definition: bitmap.c:245
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
WICBitmapLockWrite
@ WICBitmapLockWrite
Definition: wincodec.idl:86
WICBitmapLockRead
@ WICBitmapLockRead
Definition: wincodec.idl:85
WICSectionAccessLevelReadWrite
@ WICSectionAccessLevelReadWrite
Definition: wincodec.idl:192
WICBitmapInterpolationMode
WICBitmapInterpolationMode
Definition: wincodec.idl:76
WICBitmapInterpolationModeNearestNeighbor
@ WICBitmapInterpolationModeNearestNeighbor
Definition: wincodec.idl:77
WICBitmapCacheOnDemand
@ WICBitmapCacheOnDemand
Definition: wincodec.idl:35
WICBitmapNoCache
@ WICBitmapNoCache
Definition: wincodec.idl:34
WICBitmapCacheOnLoad
@ WICBitmapCacheOnLoad
Definition: wincodec.idl:36
WICBitmapPaletteType
WICBitmapPaletteType
Definition: wincodec.idl:90
WICBitmapPaletteTypeCustom
@ WICBitmapPaletteTypeCustom
Definition: wincodec.idl:91
WICBitmapPaletteTypeFixedGray256
@ WICBitmapPaletteTypeFixedGray256
Definition: wincodec.idl:104
WICBitmapPaletteTypeFixedGray4
@ WICBitmapPaletteTypeFixedGray4
Definition: wincodec.idl:102
WICBitmapIgnoreAlpha
@ WICBitmapIgnoreAlpha
Definition: wincodec.idl:43
WICBitmapUseAlpha
@ WICBitmapUseAlpha
Definition: wincodec.idl:41
WICBitmapUsePremultipliedAlpha
@ WICBitmapUsePremultipliedAlpha
Definition: wincodec.idl:42
HRESULT
#define HRESULT
Definition: msvc.h:7
WINAPI
#define WINAPI
Definition: msvc.h:6
WINCODEC_ERR_WRONGSTATE
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3281
WINCODEC_ERR_ALREADYLOCKED
#define WINCODEC_ERR_ALREADYLOCKED
Definition: winerror.h:3286
WINCODEC_ERR_WIN32ERROR
#define WINCODEC_ERR_WIN32ERROR
Definition: winerror.h:3319
WINCODEC_ERR_NOTINITIALIZED
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3285
E_NOINTERFACE
#define E_NOINTERFACE
Definition: winerror.h:2364
WINCODEC_ERR_PALETTEUNAVAILABLE
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3292
HRESULT_FROM_WIN32
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
ERROR_INVALID_CURSOR_HANDLE
#define ERROR_INVALID_CURSOR_HANDLE
Definition: winerror.h:883
WINCODEC_ERR_INSUFFICIENTBUFFER
#define WINCODEC_ERR_INSUFFICIENTBUFFER
Definition: winerror.h:3311
GetPixelFormat
int WINAPI GetPixelFormat(_In_ HDC)
DIB_RGB_COLORS
#define DIB_RGB_COLORS
Definition: wingdi.h:367
GetObjectW
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
CreateBitmap
HBITMAP WINAPI CreateBitmap(_In_ INT cx, _In_ INT cy, _In_ UINT cPlanes, _In_ UINT cBitsPerPel, _In_opt_ const VOID *pvBits)
CreatePalette
HPALETTE WINAPI CreatePalette(_In_reads_(_Inexpressible_(2 *sizeof(WORD)+plpal->palNumEntries *sizeof(PALETTEENTRY))) const LOGPALETTE *)
LOGPALETTE
struct tagLOGPALETTE LOGPALETTE
BITMAPINFO
struct tagBITMAPINFO BITMAPINFO
CreateIconIndirect
HICON WINAPI CreateIconIndirect(_In_ PICONINFO)
Definition: cursoricon.c:2625
DestroyIcon
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2097
SetResolution
_In_ BOOLEAN SetResolution
Definition: exfuncs.h:1078
Initialize
static void Initialize()
Definition: xlate.c:212
BYTE
unsigned char BYTE
Definition: xxhash.c:193