ReactOS 0.4.15-dev-5858-g16decc6
bmpformat.c
Go to the documentation of this file.
1/*
2 * Copyright 2009 Vincent Povirk for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19#include <stdarg.h>
20#include <math.h>
21
22#define COBJMACROS
23
24#include "windef.h"
25#include "initguid.h"
26#include "objbase.h"
27#include "wincodec.h"
28#include "wincodecsdk.h"
29#include "wine/test.h"
30
31static const char testbmp_24bpp[] = {
32 /* BITMAPFILEHEADER */
33 66,77, /* "BM" */
34 78,0,0,0, /* file size */
35 0,0,0,0, /* reserved */
36 54,0,0,0, /* offset to bits */
37 /* BITMAPINFOHEADER */
38 40,0,0,0, /* header size */
39 2,0,0,0, /* width */
40 3,0,0,0, /* height */
41 1,0, /* planes */
42 24,0, /* bit count */
43 0,0,0,0, /* compression */
44 0,0,0,0, /* image size */
45 0x74,0x12,0,0, /* X pels per meter => 120 dpi */
46 0,0,0,0, /* Y pels per meter */
47 0,0,0,0, /* colors used */
48 0,0,0,0, /* colors important */
49 /* bits */
50 0,0,0, 0,255,0, 0,0,
51 255,0,0, 255,255,0, 0,0,
52 255,0,255, 255,255,255, 0,0
53};
54
55static void test_decode_24bpp(void)
56{
57 IWICBitmapDecoder *decoder, *decoder2;
58 IWICBitmapFrameDecode *framedecode;
59 IWICMetadataQueryReader *queryreader;
60 IWICColorContext *colorcontext;
61 IWICBitmapSource *thumbnail;
62 HRESULT hr;
63 HGLOBAL hbmpdata;
64 char *bmpdata;
65 IStream *bmpstream;
66 DWORD capability=0;
67 GUID guidresult;
68 UINT count=0, width=0, height=0;
69 double dpiX, dpiY;
70 BYTE imagedata[36] = {1};
71 const BYTE expected_imagedata[36] = {
72 255,0,255, 255,255,255,
73 255,0,0, 255,255,0,
74 0,0,0, 0,255,0};
75 WICRect rc;
76
77 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
78 &IID_IWICBitmapDecoder, (void**)&decoder);
79 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
80 if (FAILED(hr)) return;
81
82 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_24bpp));
83 ok(hbmpdata != 0, "GlobalAlloc failed\n");
84 if (hbmpdata)
85 {
86 bmpdata = GlobalLock(hbmpdata);
87 memcpy(bmpdata, testbmp_24bpp, sizeof(testbmp_24bpp));
88 GlobalUnlock(hbmpdata);
89
90 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
91 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
92 if (SUCCEEDED(hr))
93 {
94 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
95 ok(hr == S_OK || broken(hr == WINCODEC_ERR_BADIMAGE) /* XP */, "Initialize failed, hr=%x\n", hr);
96 if (FAILED(hr))
97 {
98 win_skip("BMP decoder failed to initialize\n");
99 GlobalFree(hbmpdata);
100 IWICBitmapDecoder_Release(decoder);
101 return;
102 }
103
104 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
105 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
106 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
107
108 hr = IWICBitmapDecoder_GetMetadataQueryReader(decoder, &queryreader);
109 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
110
111 hr = IWICBitmapDecoder_GetColorContexts(decoder, 1, &colorcontext, &count);
112 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
113
114 hr = IWICBitmapDecoder_GetThumbnail(decoder, &thumbnail);
115 ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %x\n", hr);
116
117 hr = IWICBitmapDecoder_GetPreview(decoder, &thumbnail);
118 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
119
120 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
121 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
122 ok(count == 1, "unexpected count %u\n", count);
123
124 hr = IWICBitmapDecoder_GetFrame(decoder, 1, &framedecode);
125 ok(hr == E_INVALIDARG || hr == WINCODEC_ERR_FRAMEMISSING, "GetFrame returned %x\n", hr);
126
127 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
128 ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
129 if (SUCCEEDED(hr))
130 {
131 IWICImagingFactory *factory;
132 IWICPalette *palette;
133
134 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
135 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
136 ok(width == 2, "expected width=2, got %u\n", width);
137 ok(height == 3, "expected height=2, got %u\n", height);
138
139 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
140 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
141 ok(dpiX == 96.0, "expected dpiX=96.0, got %f\n", dpiX);
142 ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
143
144 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
145 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
146 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
147
148 hr = IWICBitmapFrameDecode_GetMetadataQueryReader(framedecode, &queryreader);
149 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
150
151 hr = IWICBitmapFrameDecode_GetColorContexts(framedecode, 1, &colorcontext, &count);
152 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
153
154 hr = IWICBitmapFrameDecode_GetThumbnail(framedecode, &thumbnail);
155 ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %x\n", hr);
156
157 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
158 &IID_IWICImagingFactory, (void**)&factory);
159 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
160 if (SUCCEEDED(hr))
161 {
162 hr = IWICImagingFactory_CreatePalette(factory, &palette);
163 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
164 if (SUCCEEDED(hr))
165 {
166 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
167 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
168
169 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
170 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
171
172 IWICPalette_Release(palette);
173 }
174
175 IWICImagingFactory_Release(factory);
176 }
177
178 rc.X = 0;
179 rc.Y = 0;
180 rc.Width = 3;
181 rc.Height = 3;
182 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
183 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
184
185 rc.X = -1;
186 rc.Y = 0;
187 rc.Width = 2;
188 rc.Height = 3;
189 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
190 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
191
192 rc.X = 0;
193 rc.Y = 0;
194 rc.Width = 2;
195 rc.Height = 3;
196 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, sizeof(imagedata), imagedata);
197 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
198
199 rc.X = 0;
200 rc.Y = 0;
201 rc.Width = 2;
202 rc.Height = 3;
203 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, 5, imagedata);
204 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
205
206 rc.X = 0;
207 rc.Y = 0;
208 rc.Width = 2;
209 rc.Height = 3;
210 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
211 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
212 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
213
214 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, NULL, 6, sizeof(imagedata), imagedata);
215 ok(SUCCEEDED(hr), "CopyPixels(rect=NULL) failed, hr=%x\n", hr);
216 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
217
218 IWICBitmapFrameDecode_Release(framedecode);
219 }
220
221 /* cannot initialize twice */
222 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
223 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
224
225 /* cannot querycapability after initialize */
226 hr = IWICBitmapDecoder_QueryCapability(decoder, bmpstream, &capability);
227 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
228
229 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
230 &IID_IWICBitmapDecoder, (void**)&decoder2);
231 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
232 if (SUCCEEDED(hr))
233 {
234 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
235 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
236 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
237 "unexpected capabilities: %x\n", capability);
238
239 /* cannot initialize after querycapability */
240 hr = IWICBitmapDecoder_Initialize(decoder2, bmpstream, WICDecodeMetadataCacheOnLoad);
241 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
242
243 /* cannot querycapability twice */
244 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
245 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
246
247 IWICBitmapDecoder_Release(decoder2);
248 }
249
250 IStream_Release(bmpstream);
251 }
252
253 GlobalFree(hbmpdata);
254 }
255
256 IWICBitmapDecoder_Release(decoder);
257}
258
259static const char testbmp_1bpp[] = {
260 /* BITMAPFILEHEADER */
261 66,77, /* "BM" */
262 40,0,0,0, /* file size */
263 0,0,0,0, /* reserved */
264 32,0,0,0, /* offset to bits */
265 /* BITMAPCOREHEADER */
266 12,0,0,0, /* header size */
267 2,0, /* width */
268 2,0, /* height */
269 1,0, /* planes */
270 1,0, /* bit count */
271 /* color table */
272 255,0,0,
273 0,255,0,
274 /* bits */
275 0xc0,0,0,0,
276 0x80,0,0,0
277};
278
279static void test_decode_1bpp(void)
280{
281 IWICBitmapDecoder *decoder, *decoder2;
282 IWICBitmapFrameDecode *framedecode;
283 HRESULT hr;
284 HGLOBAL hbmpdata;
285 char *bmpdata;
286 IStream *bmpstream;
287 DWORD capability=0;
288 GUID guidresult;
289 UINT count=0, width=0, height=0;
290 double dpiX, dpiY;
291 BYTE imagedata[2] = {1};
292 const BYTE expected_imagedata[2] = {0x80,0xc0};
293 WICColor palettedata[2] = {1};
294 const WICColor expected_palettedata[2] = {0xff0000ff,0xff00ff00};
295 WICRect rc;
296
297 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
298 &IID_IWICBitmapDecoder, (void**)&decoder);
299 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
300 if (FAILED(hr)) return;
301
302 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_1bpp));
303 ok(hbmpdata != 0, "GlobalAlloc failed\n");
304 if (hbmpdata)
305 {
306 bmpdata = GlobalLock(hbmpdata);
307 memcpy(bmpdata, testbmp_1bpp, sizeof(testbmp_1bpp));
308 GlobalUnlock(hbmpdata);
309
310 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
311 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
312 if (SUCCEEDED(hr))
313 {
314 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
315 ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
316
317 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
318 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
319 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
320
321 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
322 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
323 ok(count == 1, "unexpected count %u\n", count);
324
325 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
326 ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
327 if (SUCCEEDED(hr))
328 {
329 IWICImagingFactory *factory;
330 IWICPalette *palette;
331
332 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
333 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
334 ok(width == 2, "expected width=2, got %u\n", width);
335 ok(height == 2, "expected height=2, got %u\n", height);
336
337 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
338 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
339 ok(dpiX == 96.0, "expected dpiX=96.0, got %f\n", dpiX);
340 ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
341
342 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
343 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
344 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat1bppIndexed), "unexpected pixel format\n");
345
346 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
347 &IID_IWICImagingFactory, (void**)&factory);
348 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
349 if (SUCCEEDED(hr))
350 {
351 hr = IWICImagingFactory_CreatePalette(factory, &palette);
352 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
353 if (SUCCEEDED(hr))
354 {
355 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
356 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
357
358 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
359 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
360
361 hr = IWICPalette_GetColorCount(palette, &count);
362 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
363 ok(count == 2, "expected count=2, got %u\n", count);
364
365 hr = IWICPalette_GetColors(palette, 2, palettedata, &count);
366 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
367 ok(count == 2, "expected count=2, got %u\n", count);
368 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
369
370 IWICPalette_Release(palette);
371 }
372
373 IWICImagingFactory_Release(factory);
374 }
375
376 rc.X = 0;
377 rc.Y = 0;
378 rc.Width = 2;
379 rc.Height = 2;
380 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 1, sizeof(imagedata), imagedata);
381 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
382 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
383
384 IWICBitmapFrameDecode_Release(framedecode);
385 }
386
387 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
388 &IID_IWICBitmapDecoder, (void**)&decoder2);
389 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
390 if (SUCCEEDED(hr))
391 {
392 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
393 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
394 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
395 "unexpected capabilities: %x\n", capability);
396 IWICBitmapDecoder_Release(decoder2);
397 }
398
399 IStream_Release(bmpstream);
400 }
401
402 GlobalFree(hbmpdata);
403 }
404
405 IWICBitmapDecoder_Release(decoder);
406}
407
408static const char testbmp_4bpp[] = {
409 /* BITMAPFILEHEADER */
410 66,77, /* "BM" */
411 82,0,0,0, /* file size */
412 0,0,0,0, /* reserved */
413 74,0,0,0, /* offset to bits */
414 /* BITMAPINFOHEADER */
415 40,0,0,0, /* header size */
416 2,0,0,0, /* width */
417 254,255,255,255, /* height = -2 */
418 1,0, /* planes */
419 4,0, /* bit count */
420 0,0,0,0, /* compression = BI_RGB */
421 0,0,0,0, /* image size = 0 */
422 16,39,0,0, /* X pixels per meter = 10000 */
423 32,78,0,0, /* Y pixels per meter = 20000 */
424 5,0,0,0, /* colors used */
425 5,0,0,0, /* colors important */
426 /* color table */
427 255,0,0,0,
428 0,255,0,255,
429 0,0,255,23,
430 128,0,128,1,
431 255,255,255,0,
432 /* bits */
433 0x01,0,0,0,
434 0x23,0,0,0,
435};
436
437static void test_decode_4bpp(void)
438{
439 IWICBitmapDecoder *decoder, *decoder2;
440 IWICBitmapFrameDecode *framedecode;
441 HRESULT hr;
442 HGLOBAL hbmpdata;
443 char *bmpdata;
444 IStream *bmpstream;
445 DWORD capability=0;
446 GUID guidresult;
447 UINT count=0, width=0, height=0;
448 double dpiX, dpiY;
449 BYTE imagedata[2] = {1};
450 const BYTE expected_imagedata[2] = {0x01,0x23};
451 WICColor palettedata[5] = {1};
452 const WICColor expected_palettedata[5] =
453 {0xff0000ff,0xff00ff00,0xffff0000,0xff800080,0xffffffff};
454 WICRect rc;
455
456 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
457 &IID_IWICBitmapDecoder, (void**)&decoder);
458 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
459 if (FAILED(hr)) return;
460
461 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_4bpp));
462 ok(hbmpdata != 0, "GlobalAlloc failed\n");
463 if (hbmpdata)
464 {
465 bmpdata = GlobalLock(hbmpdata);
466 memcpy(bmpdata, testbmp_4bpp, sizeof(testbmp_4bpp));
467 GlobalUnlock(hbmpdata);
468
469 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
470 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
471 if (SUCCEEDED(hr))
472 {
473 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
474 ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
475
476 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
477 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
478 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
479
480 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
481 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
482 ok(count == 1, "unexpected count %u\n", count);
483
484 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
485 ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
486 if (SUCCEEDED(hr))
487 {
488 IWICImagingFactory *factory;
489 IWICPalette *palette;
490
491 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
492 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
493 ok(width == 2, "expected width=2, got %u\n", width);
494 ok(height == 2, "expected height=2, got %u\n", height);
495
496 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
497 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
498 ok(fabs(dpiX - 254.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
499 ok(fabs(dpiY - 508.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
500
501 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
502 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
503 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
504
505 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
506 &IID_IWICImagingFactory, (void**)&factory);
507 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
508 if (SUCCEEDED(hr))
509 {
510 hr = IWICImagingFactory_CreatePalette(factory, &palette);
511 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
512 if (SUCCEEDED(hr))
513 {
514 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
515 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
516
517 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
518 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
519
520 hr = IWICPalette_GetColorCount(palette, &count);
521 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
522 ok(count == 5, "expected count=5, got %u\n", count);
523
524 hr = IWICPalette_GetColors(palette, 5, palettedata, &count);
525 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
526 ok(count == 5, "expected count=5, got %u\n", count);
527 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
528
529 IWICPalette_Release(palette);
530 }
531
532 IWICImagingFactory_Release(factory);
533 }
534
535 rc.X = 0;
536 rc.Y = 0;
537 rc.Width = 2;
538 rc.Height = 2;
539 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 1, sizeof(imagedata), imagedata);
540 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
541 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
542
543 IWICBitmapFrameDecode_Release(framedecode);
544 }
545
546 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
547 &IID_IWICBitmapDecoder, (void**)&decoder2);
548 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
549 if (SUCCEEDED(hr))
550 {
551 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
552 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
553 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
554 "unexpected capabilities: %x\n", capability);
555 IWICBitmapDecoder_Release(decoder2);
556 }
557
558 IStream_Release(bmpstream);
559 }
560
561 GlobalFree(hbmpdata);
562 }
563
564 IWICBitmapDecoder_Release(decoder);
565}
566
567static const char testbmp_rle8[] = {
568 /* BITMAPFILEHEADER */
569 66,77, /* "BM" */
570 202,0,0,0, /* file size */
571 0,0,0,0, /* reserved */
572 122,0,0,0, /* offset to bits */
573 /* BITMAPINFOHEADER */
574 40,0,0,0, /* header size */
575 8,0,0,0, /* width */
576 8,0,0,0, /* height */
577 1,0, /* planes */
578 8,0, /* bit count */
579 1,0,0,0, /* compression = BI_RLE8 */
580 80,0,0,0, /* image size */
581 19,11,0,0, /* X pixels per meter */
582 19,11,0,0, /* Y pixels per meter */
583 17,0,0,0, /* colors used */
584 17,0,0,0, /* colors important */
585 /* color table */
586 0,0,0,0,
587 17,17,17,0,
588 255,0,0,0,
589 34,34,34,0,
590 0,0,204,0,
591 0,0,221,0,
592 0,0,238,0,
593 51,51,51,0,
594 0,0,255,0,
595 68,68,68,0,
596 255,0,255,0,
597 85,85,85,0,
598 0,204,0,0,
599 0,221,0,0,
600 0,238,0,0,
601 0,255,0,0,
602 255,255,255,0,
603 /* bits */
604 4,15,0,4,11,9,9,0,0,0,4,14,0,4,3,10,10,7,0,0,4,13,0,4,3,10,10,7,0,0,4,12,0,4,0,1,1,11,0,0,0,4,16,2,16,2,4,4,0,0,0,4,2,16,2,16,4,5,0,0,0,4,16,2,16,2,4,6,0,0,0,4,2,16,2,16,4,8,0,1
605};
606
607static void test_decode_rle8(void)
608{
609 IWICBitmapDecoder *decoder, *decoder2;
610 IWICBitmapFrameDecode *framedecode;
611 HRESULT hr;
612 HGLOBAL hbmpdata;
613 char *bmpdata;
614 IStream *bmpstream;
615 DWORD capability=0;
616 GUID guidresult;
617 UINT count=0, width=0, height=0;
618 double dpiX, dpiY;
619 DWORD imagedata[64] = {1};
620 const DWORD expected_imagedata[64] = {
621 0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
622 0xffffff,0x0000ff,0xffffff,0x0000ff,0xee0000,0xee0000,0xee0000,0xee0000,
623 0x0000ff,0xffffff,0x0000ff,0xffffff,0xdd0000,0xdd0000,0xdd0000,0xdd0000,
624 0xffffff,0x0000ff,0xffffff,0x0000ff,0xcc0000,0xcc0000,0xcc0000,0xcc0000,
625 0x00cc00,0x00cc00,0x00cc00,0x00cc00,0x000000,0x111111,0x111111,0x555555,
626 0x00dd00,0x00dd00,0x00dd00,0x00dd00,0x222222,0xff00ff,0xff00ff,0x333333,
627 0x00ee00,0x00ee00,0x00ee00,0x00ee00,0x222222,0xff00ff,0xff00ff,0x333333,
628 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x555555,0x444444,0x444444,0x000000};
629 WICColor palettedata[17] = {1};
630 const WICColor expected_palettedata[17] = {
631 0xff000000,0xff111111,0xff0000ff,0xff222222,0xffcc0000,0xffdd0000,
632 0xffee0000,0xff333333,0xffff0000,0xff444444,0xffff00ff,0xff555555,
633 0xff00cc00,0xff00dd00,0xff00ee00,0xff00ff00,0xffffffff};
634 WICRect rc;
635
636 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
637 &IID_IWICBitmapDecoder, (void**)&decoder);
638 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
639 if (FAILED(hr)) return;
640
641 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle8));
642 ok(hbmpdata != 0, "GlobalAlloc failed\n");
643 if (hbmpdata)
644 {
645 bmpdata = GlobalLock(hbmpdata);
646 memcpy(bmpdata, testbmp_rle8, sizeof(testbmp_rle8));
647 GlobalUnlock(hbmpdata);
648
649 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
650 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
651 if (SUCCEEDED(hr))
652 {
653 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
654 ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
655
656 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
657 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
658 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
659
660 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
661 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
662 ok(count == 1, "unexpected count %u\n", count);
663
664 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
665 ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
666 if (SUCCEEDED(hr))
667 {
668 IWICImagingFactory *factory;
669 IWICPalette *palette;
670
671 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
672 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
673 ok(width == 8, "expected width=8, got %u\n", width);
674 ok(height == 8, "expected height=8, got %u\n", height);
675
676 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
677 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
678 ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
679 ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
680
681 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
682 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
683 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
684
685 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
686 &IID_IWICImagingFactory, (void**)&factory);
687 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
688 if (SUCCEEDED(hr))
689 {
690 hr = IWICImagingFactory_CreatePalette(factory, &palette);
691 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
692 if (SUCCEEDED(hr))
693 {
694 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
695 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
696
697 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
698 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
699
700 hr = IWICPalette_GetColorCount(palette, &count);
701 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
702 ok(count == 17, "expected count=17, got %u\n", count);
703
704 hr = IWICPalette_GetColors(palette, 17, palettedata, &count);
705 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
706 ok(count == 17, "expected count=17, got %u\n", count);
707 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
708
709 IWICPalette_Release(palette);
710 }
711
712 IWICImagingFactory_Release(factory);
713 }
714
715 rc.X = 0;
716 rc.Y = 0;
717 rc.Width = 8;
718 rc.Height = 8;
719 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
720 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
721 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
722
723 IWICBitmapFrameDecode_Release(framedecode);
724 }
725
726 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
727 &IID_IWICBitmapDecoder, (void**)&decoder2);
728 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
729 if (SUCCEEDED(hr))
730 {
731 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
732 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
733 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
734 "unexpected capabilities: %x\n", capability);
735 IWICBitmapDecoder_Release(decoder2);
736 }
737
738 IStream_Release(bmpstream);
739 }
740
741 GlobalFree(hbmpdata);
742 }
743
744 IWICBitmapDecoder_Release(decoder);
745}
746
747static const char testbmp_rle4[] = {
748 /* BITMAPFILEHEADER */
749 66,77, /* "BM" */
750 142,0,0,0, /* file size */
751 0,0,0,0, /* reserved */
752 78,0,0,0, /* offset to bits */
753 /* BITMAPINFOHEADER */
754 40,0,0,0, /* header size */
755 8,0,0,0, /* width */
756 8,0,0,0, /* height */
757 1,0, /* planes */
758 4,0, /* bit count */
759 2,0,0,0, /* compression = BI_RLE4 */
760 64,0,0,0, /* image size */
761 19,11,0,0, /* X pixels per meter */
762 19,11,0,0, /* Y pixels per meter */
763 6,0,0,0, /* colors used */
764 6,0,0,0, /* colors important */
765 /* color table */
766 0,0,0,0,
767 255,0,0,0,
768 0,0,255,0,
769 255,0,255,0,
770 0,255,0,0,
771 255,255,255,0,
772 /* bits */
773 0,8,68,68,0,0,0,0,0,8,68,68,3,48,0,0,0,8,68,68,3,48,0,0,0,8,68,68,0,0,0,0,0,8,81,81,34,34,0,0,0,8,21,21,34,34,0,0,0,8,81,81,34,34,0,0,0,8,21,21,34,34,0,1
774};
775
776static void test_decode_rle4(void)
777{
778 IWICBitmapDecoder *decoder, *decoder2;
779 IWICBitmapFrameDecode *framedecode;
780 HRESULT hr;
781 HGLOBAL hbmpdata;
782 char *bmpdata;
783 IStream *bmpstream;
784 DWORD capability=0;
785 GUID guidresult;
786 UINT count=0, width=0, height=0;
787 double dpiX, dpiY;
788 DWORD imagedata[64] = {1};
789 const DWORD expected_imagedata[64] = {
790 0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
791 0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
792 0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
793 0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
794 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000,
795 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
796 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
797 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000};
798 WICColor palettedata[6] = {1};
799 const WICColor expected_palettedata[6] = {
800 0xff000000,0xff0000ff,0xffff0000,0xffff00ff,0xff00ff00,0xffffffff};
801 WICRect rc;
802
803 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
804 &IID_IWICBitmapDecoder, (void**)&decoder);
805 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
806 if (FAILED(hr)) return;
807
808 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
809 ok(hbmpdata != 0, "GlobalAlloc failed\n");
810 if (hbmpdata)
811 {
812 bmpdata = GlobalLock(hbmpdata);
813 memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
814 GlobalUnlock(hbmpdata);
815
816 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
817 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
818 if (SUCCEEDED(hr))
819 {
820 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
821 ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
822
823 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
824 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
825 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
826
827 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
828 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
829 ok(count == 1, "unexpected count %u\n", count);
830
831 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
832 ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
833 if (SUCCEEDED(hr))
834 {
835 IWICImagingFactory *factory;
836 IWICPalette *palette;
837
838 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
839 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
840 ok(width == 8, "expected width=8, got %u\n", width);
841 ok(height == 8, "expected height=8, got %u\n", height);
842
843 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
844 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
845 ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
846 ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
847
848 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
849 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
850 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
851
852 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
853 &IID_IWICImagingFactory, (void**)&factory);
854 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
855 if (SUCCEEDED(hr))
856 {
857 hr = IWICImagingFactory_CreatePalette(factory, &palette);
858 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
859 if (SUCCEEDED(hr))
860 {
861 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
862 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
863
864 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
865 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
866
867 hr = IWICPalette_GetColorCount(palette, &count);
868 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
869 ok(count == 6, "expected count=6, got %u\n", count);
870
871 hr = IWICPalette_GetColors(palette, 6, palettedata, &count);
872 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
873 ok(count == 6, "expected count=6, got %u\n", count);
874 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
875
876 IWICPalette_Release(palette);
877 }
878
879 IWICImagingFactory_Release(factory);
880 }
881
882 rc.X = 0;
883 rc.Y = 0;
884 rc.Width = 8;
885 rc.Height = 8;
886 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
887 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
888 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
889
890 IWICBitmapFrameDecode_Release(framedecode);
891 }
892
893 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
894 &IID_IWICBitmapDecoder, (void**)&decoder2);
895 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
896 if (SUCCEEDED(hr))
897 {
898 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
899 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
900 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
901 "unexpected capabilities: %x\n", capability);
902 IWICBitmapDecoder_Release(decoder2);
903 }
904
905 IStream_Release(bmpstream);
906 }
907
908 GlobalFree(hbmpdata);
909 }
910
911 IWICBitmapDecoder_Release(decoder);
912}
913
914static void test_componentinfo(void)
915{
916 IWICImagingFactory *factory;
917 IWICComponentInfo *info;
918 IWICBitmapDecoderInfo *decoderinfo;
919 IWICBitmapDecoder *decoder;
920 HRESULT hr;
921 WICBitmapPattern *patterns;
922 UINT pattern_count, pattern_size;
923 WICComponentType type;
924 GUID guidresult;
925 HGLOBAL hbmpdata;
926 char *bmpdata;
927 IStream *bmpstream;
928 BOOL boolresult;
929
930 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
931 &IID_IWICImagingFactory, (void**)&factory);
932 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
933 if (SUCCEEDED(hr))
934 {
935 hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICBmpDecoder, &info);
936 ok(SUCCEEDED(hr), "CreateComponentInfo failed, hr=%x\n", hr);
937 if (SUCCEEDED(hr))
938 {
939 hr = IWICComponentInfo_GetComponentType(info, &type);
940 ok(SUCCEEDED(hr), "GetComponentType failed, hr=%x\n", hr);
941 ok(type == WICDecoder, "got %i, expected WICDecoder\n", type);
942
943 hr = IWICComponentInfo_QueryInterface(info, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
944 ok(SUCCEEDED(hr), "QueryInterface failed, hr=%x\n", hr);
945 if (SUCCEEDED(hr))
946 {
947 pattern_count = 0;
948 pattern_size = 0;
949 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, 0, NULL, &pattern_count, &pattern_size);
950 ok(SUCCEEDED(hr), "GetPatterns failed, hr=%x\n", hr);
951 ok(pattern_count != 0, "pattern count is 0\n");
952 ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
953
954 patterns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pattern_size);
955 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
956 ok(SUCCEEDED(hr), "GetPatterns failed, hr=%x\n", hr);
957 ok(pattern_count != 0, "pattern count is 0\n");
958 ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
959 ok(patterns[0].Length != 0, "pattern length is 0\n");
960 ok(patterns[0].Pattern != NULL, "pattern is NULL\n");
961 ok(patterns[0].Mask != NULL, "mask is NULL\n");
962
963 pattern_size -= 1;
964 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
965 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "GetPatterns returned %x, expected WINCODEC_ERR_INSUFFICIENTBUFFER\n", hr);
966
967 HeapFree(GetProcessHeap(), 0, patterns);
968
969 hr = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
970 ok(SUCCEEDED(hr), "CreateInstance failed, hr=%x\n", hr);
971 if (SUCCEEDED(hr))
972 {
973 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
974 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
975 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
976
977 IWICBitmapDecoder_Release(decoder);
978 }
979
980 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
981 ok(hbmpdata != 0, "GlobalAlloc failed\n");
982 if (hbmpdata)
983 {
984 bmpdata = GlobalLock(hbmpdata);
985 memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
986 GlobalUnlock(hbmpdata);
987
988 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
989 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
990 if (SUCCEEDED(hr))
991 {
992 boolresult = 0;
993 hr = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, bmpstream, &boolresult);
994 ok(SUCCEEDED(hr), "MatchesPattern failed, hr=%x\n", hr);
995 ok(boolresult, "pattern not matched\n");
996
997 IStream_Release(bmpstream);
998 }
999
1000 GlobalFree(hbmpdata);
1001 }
1002
1003 IWICBitmapDecoderInfo_Release(decoderinfo);
1004 }
1005
1006 IWICComponentInfo_Release(info);
1007 }
1008
1009 IWICImagingFactory_Release(factory);
1010 }
1011}
1012
1013static void test_createfromstream(void)
1014{
1015 IWICBitmapDecoder *decoder;
1016 IWICImagingFactory *factory;
1017 HRESULT hr;
1018 HGLOBAL hbmpdata;
1019 char *bmpdata;
1020 IStream *bmpstream;
1021 GUID guidresult;
1022
1023 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1024 &IID_IWICImagingFactory, (void**)&factory);
1025 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
1026 if (FAILED(hr)) return;
1027
1028 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_1bpp));
1029 ok(hbmpdata != 0, "GlobalAlloc failed\n");
1030 if (hbmpdata)
1031 {
1032 bmpdata = GlobalLock(hbmpdata);
1033 memcpy(bmpdata, testbmp_1bpp, sizeof(testbmp_1bpp));
1034 GlobalUnlock(hbmpdata);
1035
1036 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
1037 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
1038 if (SUCCEEDED(hr))
1039 {
1040 hr = IWICImagingFactory_CreateDecoderFromStream(factory, bmpstream,
1041 NULL, WICDecodeMetadataCacheOnDemand, &decoder);
1042 ok(SUCCEEDED(hr), "CreateDecoderFromStream failed, hr=%x\n", hr);
1043 if (SUCCEEDED(hr))
1044 {
1045 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
1046 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
1047 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
1048
1049 IWICBitmapDecoder_Release(decoder);
1050 }
1051
1052 IStream_Release(bmpstream);
1053 }
1054
1055 GlobalFree(hbmpdata);
1056 }
1057
1058 IWICImagingFactory_Release(factory);
1059}
1060
1061static void test_create_decoder(void)
1062{
1063 IWICBitmapDecoder *decoder;
1064 IWICImagingFactory *factory;
1065 HRESULT hr;
1066
1067 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1068 &IID_IWICImagingFactory, (void **)&factory);
1069 ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
1070
1071 hr = IWICImagingFactory_CreateDecoder(factory, NULL, NULL, NULL);
1072 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1073
1074 hr = IWICImagingFactory_CreateDecoder(factory, NULL, NULL, &decoder);
1075 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1076
1077 hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatBmp, NULL, &decoder);
1078 ok(hr == S_OK, "CreateDecoder error %#x\n", hr);
1079 IWICBitmapDecoder_Release(decoder);
1080
1081 hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatBmp, &GUID_VendorMicrosoft, &decoder);
1082 ok(hr == S_OK, "CreateDecoder error %#x\n", hr);
1083 IWICBitmapDecoder_Release(decoder);
1084
1085 IWICImagingFactory_Release(factory);
1086}
1087
1088START_TEST(bmpformat)
1089{
1090 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1091
1092 test_decode_24bpp();
1093 test_decode_1bpp();
1094 test_decode_4bpp();
1095 test_decode_rle8();
1096 test_decode_rle4();
1097 test_componentinfo();
1098 test_createfromstream();
1099 test_create_decoder();
1100
1101 CoUninitialize();
1102}
broken
#define broken(x)
Definition: _sntprintf.h:21
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ok
#define ok(value,...)
Definition: atltest.h:57
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
test_decode_1bpp
static void test_decode_1bpp(void)
Definition: bmpformat.c:279
test_create_decoder
static void test_create_decoder(void)
Definition: bmpformat.c:1061
test_decode_rle8
static void test_decode_rle8(void)
Definition: bmpformat.c:607
testbmp_1bpp
static const char testbmp_1bpp[]
Definition: bmpformat.c:259
testbmp_4bpp
static const char testbmp_4bpp[]
Definition: bmpformat.c:408
test_decode_24bpp
static void test_decode_24bpp(void)
Definition: bmpformat.c:55
testbmp_24bpp
static const char testbmp_24bpp[]
Definition: bmpformat.c:31
test_componentinfo
static void test_componentinfo(void)
Definition: bmpformat.c:914
testbmp_rle8
static const char testbmp_rle8[]
Definition: bmpformat.c:567
test_decode_rle4
static void test_decode_rle4(void)
Definition: bmpformat.c:776
test_createfromstream
static void test_createfromstream(void)
Definition: bmpformat.c:1013
test_decode_4bpp
static void test_decode_4bpp(void)
Definition: bmpformat.c:437
testbmp_rle4
static const char testbmp_rle4[]
Definition: bmpformat.c:747
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
HEAP_ZERO_MEMORY
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
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
CreateStreamOnHGlobal
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
Definition: hglobalstream.c:623
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
Mask
unsigned int Mask
Definition: fpcontrol.c:82
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
height
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
width
GLint GLint GLsizei width
Definition: gl.h:1546
GlobalLock
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
GlobalFree
HGLOBAL NTAPI GlobalFree(HGLOBAL hMem)
Definition: heapmem.c:611
GlobalUnlock
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
GlobalAlloc
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
fabs
_Check_return_ _CRT_JIT_INTRINSIC double __cdecl fabs(_In_ double x)
Definition: fabs.c:17
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
palette
static HPALETTE palette
Definition: clipboard.c:1345
UINT
unsigned int UINT
Definition: ndis.h:50
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
COINIT_APARTMENTTHREADED
@ COINIT_APARTMENTTHREADED
Definition: objbase.h:278
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
win_skip
#define win_skip
Definition: test.h:160
hr
HRESULT hr
Definition: shlfolder.c:183
WICRect::Height
INT Height
Definition: wincodec.idl:301
WICRect::Width
INT Width
Definition: wincodec.idl:300
factory
Definition: main.c:439
GMEM_MOVEABLE
#define GMEM_MOVEABLE
Definition: winbase.h:294
WICDecodeMetadataCacheOnDemand
@ WICDecodeMetadataCacheOnDemand
Definition: wincodec.idl:28
WICDecodeMetadataCacheOnLoad
@ WICDecodeMetadataCacheOnLoad
Definition: wincodec.idl:29
WICColor
UINT32 WICColor
Definition: wincodec.idl:312
WICComponentType
WICComponentType
Definition: wincodec.idl:124
WICDecoder
@ WICDecoder
Definition: wincodec.idl:125
WICBitmapDecoderCapabilityCanDecodeAllImages
@ WICBitmapDecoderCapabilityCanDecodeAllImages
Definition: wincodec.idl:49
WINCODEC_ERR_WRONGSTATE
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3273
WINCODEC_ERR_UNSUPPORTEDOPERATION
#define WINCODEC_ERR_UNSUPPORTEDOPERATION
Definition: winerror.h:3300
WINCODEC_ERR_BADIMAGE
#define WINCODEC_ERR_BADIMAGE
Definition: winerror.h:3291
WINCODEC_ERR_PALETTEUNAVAILABLE
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3284
WINCODEC_ERR_CODECNOTHUMBNAIL
#define WINCODEC_ERR_CODECNOTHUMBNAIL
Definition: winerror.h:3283
WINCODEC_ERR_FRAMEMISSING
#define WINCODEC_ERR_FRAMEMISSING
Definition: winerror.h:3293
WINCODEC_ERR_INSUFFICIENTBUFFER
#define WINCODEC_ERR_INSUFFICIENTBUFFER
Definition: winerror.h:3303
BYTE
unsigned char BYTE
Definition: xxhash.c:193