ReactOS  0.4.15-dev-1197-g8081ba9
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"
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
44 DECLARE_INTERFACE_(IMILBitmapSource,IUnknown)
45 {
49  /*** IWICBitmapSource methods ***/
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
59 DECLARE_INTERFACE_(IMILBitmap,IMILBitmapSource)
60 {
64  /*** IWICBitmapSource methods ***/
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;
74  STDMETHOD_(HRESULT,SetPalette)(THIS_ IWICPalette *) PURE;
76  STDMETHOD_(HRESULT,AddDirtyRect)(THIS_ const WICRect *) PURE;
77 };
78 
79 #undef INTERFACE
80 #define INTERFACE IMILBitmapScaler
81 DECLARE_INTERFACE_(IMILBitmapScaler,IMILBitmapSource)
82 {
83  /*** IUnknown methods ***/
87  /*** IWICBitmapSource methods ***/
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;
96 };
97 
99 
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 
117 {
118  return 2;
119 }
120 
122 {
123  return 1;
124 }
125 
127 {
128  *width = *height = 10;
129  return S_OK;
130 }
131 
134 {
135  return E_NOTIMPL;
136 }
137 
139  double *dpiX, double *dpiY)
140 {
141  return E_NOTIMPL;
142 }
143 
146 {
147  return E_NOTIMPL;
148 }
149 
152 
154  const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
155 {
156  if (rc) g_rect = *rc;
158  return S_OK;
159 }
160 
161 static const IWICBitmapSourceVtbl sourcevtbl = {
170 };
171 
173 
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;
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;
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 
219 static void test_createbitmap(void)
220 {
221  HRESULT hr;
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;
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,
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 
456 {
457  HRESULT hr;
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};
469  UINT lock_buffer_stride=0;
470  UINT lock_buffer_size=0;
472  UINT width=0, height=0;
473  double dpix=10.0, dpiy=10.0;
474  UINT count;
476 
477  hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
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,
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,
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,
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,
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 
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;
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 
734 static void test_CreateBitmapFromHICON(void)
735 {
736  static const char bits[4096];
737  HICON icon;
738  ICONINFO info;
739  HRESULT hr;
741  UINT width, height;
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 
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;
823  UINT width, height, i, count;
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);
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);
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);
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);
982 }
983 
984 static void test_clipper(void)
985 {
986  IWICBitmapClipper *clipper;
987  UINT height, width;
989  BYTE buffer[500];
990  WICRect rect;
991  HRESULT hr;
992 
993  hr = IWICImagingFactory_CreateBitmap(factory, 10, 10, &GUID_WICPixelFormat24bppBGR,
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));
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));
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));
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));
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)
1092 
1094 {
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 
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,
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,
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,
1142  ok(hr == S_OK, "WICCreateBitmapFromSectionEx returned %#x\n", hr);
1143  IWICBitmap_Release(bitmap);
1144  DeleteObject(hdib);
1145  CloseHandle(hsection);
1146 }
1147 
1148 static void test_bitmap_scaler(void)
1149 {
1151  IWICBitmapScaler *scaler;
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,
1176  ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1177 
1178  hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 0,
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",
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,
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,
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,
1246  ok(hr == E_INVALIDARG, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1247 
1248  hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 4,
1250  ok(hr == S_OK, "Failed to initialize bitmap scaler, hr %#x.\n", hr);
1251 
1252  hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 0, 4,
1254  ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
1255 
1256  hr = IWICBitmapScaler_Initialize(scaler, (IWICBitmapSource *)bitmap, 8, 0,
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,
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",
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 
1317 static LONG obj_refcount(void *obj)
1318 {
1319  IUnknown_AddRef((IUnknown *)obj);
1320  return IUnknown_Release((IUnknown *)obj);
1321 }
1322 
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;
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,
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 
1470 {
1471  HRESULT hr;
1472 
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();
1485  test_clipper();
1487 
1488  IWICImagingFactory_Release(factory);
1489 
1490  CoUninitialize();
1491 
1493 }
GLint GLint GLsizei width
Definition: gl.h:1546
#define ERROR_INVALID_CURSOR_HANDLE
Definition: winerror.h:883
static HICON
Definition: imagelist.c:84
static HRESULT WINAPI bitmapsource_GetSize(IWICBitmapSource *iface, UINT *width, UINT *height)
Definition: bitmap.c:126
static void test_createbitmap(void)
Definition: bitmap.c:219
#define REFIID
Definition: guiddef.h:118
#define CloseHandle
Definition: compat.h:487
#define E_NOINTERFACE
Definition: winerror.h:2364
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
BITMAPINFOHEADER bmiHeader
Definition: wingdi.h:1475
#define THIS_
Definition: basetyps.h:65
rwlock_t lock
Definition: tcpcore.h:1163
HRESULT hr
Definition: shlfolder.c:183
static DWORD(WINAPI *pSetLayout)(HDC hdc
DWORD biClrImportant
Definition: amvideo.idl:40
int WINAPI GetPixelFormat(_In_ HDC)
DWORD dwAllocationGranularity
Definition: winbase.h:1145
static void test_CreateBitmapFromHICON(void)
Definition: bitmap.c:734
#define THIS
Definition: basetyps.h:66
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
BOOL WINAPI DestroyIcon(_In_ HICON)
Definition: cursoricon.c:2022
#define TRUE
Definition: types.h:120
static ULONG WINAPI bitmapsource_AddRef(IWICBitmapSource *iface)
Definition: bitmap.c:116
static HRESULT WINAPI bitmapsource_CopyPixels(IWICBitmapSource *iface, const WICRect *rc, UINT stride, UINT buffer_size, BYTE *buffer)
Definition: bitmap.c:153
HBITMAP WINAPI CreateBitmap(INT Width, INT Height, UINT Planes, UINT BitsPixel, CONST VOID *pUnsafeBits)
Definition: bitmap.c:252
GLuint GLuint GLsizei count
Definition: gl.h:1545
static HRESULT WINAPI bitmapsource_QueryInterface(IWICBitmapSource *iface, REFIID iid, void **ppv)
Definition: bitmap.c:100
static HRESULT QueryInterface(REFIID, void **)
Definition: events.c:2587
static IWICBitmapSource bitmapsource
Definition: bitmap.c:172
static void test_CreateBitmapFromMemory(void)
Definition: bitmap.c:659
REFIID LPVOID * ppv
Definition: atlbase.h:39
static void test_bitmap_scaler(void)
Definition: bitmap.c:1148
START_TEST(bitmap)
Definition: bitmap.c:5941
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define WINCODEC_ERR_WIN32ERROR
Definition: winerror.h:3311
const char * wine_dbgstr_guid(const GUID *guid)
#define INVALID_HANDLE_VALUE
Definition: compat.h:479
#define assert(x)
Definition: debug.h:53
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
GLuint buffer
Definition: glext.h:5915
static WICSectionAccessLevel
Definition: bitmap.c:1091
#define WINCODEC_ERR_NOTINITIALIZED
Definition: winerror.h:3277
static REFWICPixelFormatGUID
Definition: bitmap.c:1091
static IWICImagingFactory * factory
Definition: bitmap.c:96
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
& rect
Definition: startmenu.cpp:1413
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
static BOOL called_CopyPixels
Definition: bitmap.c:151
struct _test_info info[]
Definition: SetCursorPos.c:19
WORD palVersion
Definition: wingdi.h:1832
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
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
Definition: main.c:438
static void test_CreateBitmapFromHBITMAP(void)
Definition: bitmap.c:809
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
DWORD biCompression
Definition: amvideo.idl:35
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
#define E_INVALIDARG
Definition: ddrawi.h:101
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3284
smooth NULL
Definition: ftsmooth.c:416
pixelformat
Definition: converter.c:40
INT Height
Definition: wincodec.idl:239
HBITMAP hbmp
static HRESULT WINAPI bitmapsource_GetPixelFormat(IWICBitmapSource *iface, WICPixelFormatGUID *format)
Definition: bitmap.c:132
#define todo_wine_if(is_todo)
Definition: test.h:163
Definition: uimain.c:88
static const IWICBitmapSourceVtbl sourcevtbl
Definition: bitmap.c:161
static ULONG WINAPI bitmapsource_Release(IWICBitmapSource *iface)
Definition: bitmap.c:121
static void test_createbitmapfromsource(void)
Definition: bitmap.c:455
GLsizei stride
Definition: glext.h:5848
DWORD WINAPI GetSize(LPVOID)
ULONG RGBQUAD
Definition: precomp.h:50
WICBitmapPaletteType
Definition: wincodec.idl:90
RGBQUAD bmiColors[1]
Definition: wingdi.h:1476
LONG HRESULT
Definition: typedefs.h:79
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:492
static UINT
Definition: bitmap.c:1091
HPALETTE WINAPI CreatePalette(_In_reads_(_Inexpressible_(2 *sizeof(WORD)+plpal->palNumEntries *sizeof(PALETTEENTRY))) const LOGPALETTE *)
const GUID IID_IUnknown
SYSTEM_INFO sysinfo
Definition: dbghelp.c:76
HICON WINAPI CreateIconIndirect(_In_ PICONINFO)
Definition: cursoricon.c:2546
#define WINAPI
Definition: msvc.h:6
unsigned short WORD
Definition: ntddk_ex.h:93
nsrefcnt Release()
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static WICRect g_rect
Definition: bitmap.c:150
WICBitmapInterpolationMode
Definition: wincodec.idl:76
#define WINCODEC_ERR_ALREADYLOCKED
Definition: winerror.h:3278
#define todo_wine
Definition: test.h:162
static HBITMAP create_dib(int width, int height, int bpp, LOGPALETTE *pal, const void *data)
Definition: bitmap.c:174
static void test_clipper(void)
Definition: bitmap.c:984
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
IN OUT PLONG IN OUT PLONG Addend IN OUT PLONG IN LONG IN OUT PLONG IN LONG Increment IN PNDIS_RW_LOCK Lock
Definition: CrNtStubs.h:75
unsigned char BYTE
Definition: xxhash.c:193
static void test_IMILBitmap(void)
Definition: bitmap.c:1323
static HPALETTE palette
Definition: clipboard.c:1345
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define broken(x)
Definition: _sntprintf.h:21
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3273
#define S_OK
Definition: intsafe.h:51
_In_ BOOLEAN SetResolution
Definition: exfuncs.h:1078
WICBitmapPaletteType palette_type
Definition: image.c:53
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
static void lock_buffer(struct buffer_head *bh)
Definition: module.h:1018
static HRESULT(WINAPI *pWICCreateBitmapFromSectionEx)(UINT
HBITMAP WINAPI CreateDIBSection(HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
Definition: bitmap.c:197
#define ok(value,...)
Definition: atltest.h:57
Definition: bl.h:1331
#define E_NOTIMPL
Definition: ddrawi.h:99
BOOL Initialize(HINSTANCE hInstance)
Definition: msconfig.c:341
static HRESULT WINAPI bitmapsource_GetResolution(IWICBitmapSource *iface, double *dpiX, double *dpiY)
Definition: bitmap.c:138
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:142
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
static HANDLE
Definition: bitmap.c:1091
struct tagLOGPALETTE LOGPALETTE
#define PURE
Definition: basetyps.h:64
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
static IWICBitmap **static void test_WICCreateBitmapFromSectionEx(void)
Definition: bitmap.c:1093
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
DEFINE_GUID(IID_IMILUnknown, 0x0ccd7824, 0xdc16, 0x4d09, 0xbc, 0xa8, 0x6b, 0x09, 0xc4, 0xef, 0x55, 0x35)
static HRESULT WINAPI bitmapsource_CopyPalette(IWICBitmapSource *iface, IWICPalette *palette)
Definition: bitmap.c:144
INT Width
Definition: wincodec.idl:238
unsigned int ULONG
Definition: retypes.h:1
static LONG obj_refcount(void *obj)
Definition: bitmap.c:1317
#define GetProcAddress(x, y)
Definition: compat.h:501
DWORD bpp
Definition: surface.c:182
static HBITMAP bitmap
Definition: clipboard.c:1344
WORD palNumEntries
Definition: wingdi.h:1833
static HBITMAP
Definition: button.c:44
#define WINCODEC_ERR_INSUFFICIENTBUFFER
Definition: winerror.h:3303
_In_ BOOLEAN Release
Definition: cdrom.h:920
#define DIB_RGB_COLORS
Definition: wingdi.h:366
#define STDMETHOD_(t, m)
Definition: basetyps.h:63
nsresult QueryInterface(nsIIDRef riid, void **result)
static HBITMAP bitmap2
Definition: clipboard.c:1344
#define memset(x, y, z)
Definition: compat.h:39
#define win_skip
Definition: test.h:149
DECLARE_INTERFACE_(IMILBitmapSource, IUnknown)
Definition: bitmap.c:44
#define BI_RGB
Definition: precomp.h:47
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define SUCCEEDED(hr)
Definition: intsafe.h:49
struct tagBITMAPINFO BITMAPINFO
#define PAGE_READWRITE
Definition: nt_native.h:1304