ReactOS 0.4.16-dev-980-g00983aa
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 "objbase.h"
26#include "wincodec.h"
27#include "wincodecsdk.h"
28#include "wine/test.h"
29
30static const char testbmp_24bpp[] = {
31 /* BITMAPFILEHEADER */
32 66,77, /* "BM" */
33 78,0,0,0, /* file size */
34 0,0,0,0, /* reserved */
35 54,0,0,0, /* offset to bits */
36 /* BITMAPINFOHEADER */
37 40,0,0,0, /* header size */
38 2,0,0,0, /* width */
39 3,0,0,0, /* height */
40 1,0, /* planes */
41 24,0, /* bit count */
42 0,0,0,0, /* compression */
43 0,0,0,0, /* image size */
44 0x74,0x12,0,0, /* X pels per meter => 120 dpi */
45 0,0,0,0, /* Y pels per meter */
46 0,0,0,0, /* colors used */
47 0,0,0,0, /* colors important */
48 /* bits */
49 0,0,0, 0,255,0, 0,0,
50 255,0,0, 255,255,0, 0,0,
51 255,0,255, 255,255,255, 0,0
52};
53
54static void test_decode_24bpp(void)
55{
56 IWICBitmapDecoder *decoder, *decoder2;
57 IWICBitmapFrameDecode *framedecode;
58 IWICMetadataQueryReader *queryreader;
59 IWICColorContext *colorcontext;
60 IWICBitmapSource *thumbnail;
61 HRESULT hr;
62 HGLOBAL hbmpdata;
63 char *bmpdata;
64 IStream *bmpstream;
65 DWORD capability=0;
66 GUID guidresult;
67 UINT count=0, width=0, height=0;
68 double dpiX, dpiY;
69 BYTE imagedata[36] = {1};
70 const BYTE expected_imagedata[36] = {
71 255,0,255, 255,255,255,
72 255,0,0, 255,255,0,
73 0,0,0, 0,255,0};
74 WICRect rc;
75
76 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
77 &IID_IWICBitmapDecoder, (void**)&decoder);
78 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
79 if (FAILED(hr)) return;
80
81 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_24bpp));
82 ok(hbmpdata != 0, "GlobalAlloc failed\n");
83 if (hbmpdata)
84 {
85 bmpdata = GlobalLock(hbmpdata);
86 memcpy(bmpdata, testbmp_24bpp, sizeof(testbmp_24bpp));
87 GlobalUnlock(hbmpdata);
88
89 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
90 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
91 if (SUCCEEDED(hr))
92 {
93 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
94 ok(hr == S_OK || broken(hr == WINCODEC_ERR_BADIMAGE) /* XP */, "Initialize failed, hr=%lx\n", hr);
95 if (FAILED(hr))
96 {
97 win_skip("BMP decoder failed to initialize\n");
98 GlobalFree(hbmpdata);
99 IWICBitmapDecoder_Release(decoder);
100 return;
101 }
102
103 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
104 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
105 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
106
107 hr = IWICBitmapDecoder_GetMetadataQueryReader(decoder, &queryreader);
108 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %lx\n", hr);
109
110 hr = IWICBitmapDecoder_GetColorContexts(decoder, 1, &colorcontext, &count);
111 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %lx\n", hr);
112
113 hr = IWICBitmapDecoder_GetThumbnail(decoder, &thumbnail);
114 ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %lx\n", hr);
115
116 hr = IWICBitmapDecoder_GetPreview(decoder, &thumbnail);
117 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %lx\n", hr);
118
119 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
120 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%lx\n", hr);
121 ok(count == 1, "unexpected count %u\n", count);
122
123 hr = IWICBitmapDecoder_GetFrame(decoder, 1, &framedecode);
124 ok(hr == E_INVALIDARG || hr == WINCODEC_ERR_FRAMEMISSING, "GetFrame returned %lx\n", hr);
125
126 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
127 ok(SUCCEEDED(hr), "GetFrame failed, hr=%lx\n", hr);
128 if (SUCCEEDED(hr))
129 {
130 IWICImagingFactory *factory;
131 IWICPalette *palette;
132
133 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
134 ok(SUCCEEDED(hr), "GetSize failed, hr=%lx\n", hr);
135 ok(width == 2, "expected width=2, got %u\n", width);
136 ok(height == 3, "expected height=2, got %u\n", height);
137
138 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
139 ok(SUCCEEDED(hr), "GetResolution failed, hr=%lx\n", hr);
140 ok(dpiX == 96.0, "expected dpiX=96.0, got %f\n", dpiX);
141 ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
142
143 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
144 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%lx\n", hr);
145 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
146
147 hr = IWICBitmapFrameDecode_GetMetadataQueryReader(framedecode, &queryreader);
148 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %lx\n", hr);
149
150 hr = IWICBitmapFrameDecode_GetColorContexts(framedecode, 1, &colorcontext, &count);
151 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %lx\n", hr);
152
153 hr = IWICBitmapFrameDecode_GetThumbnail(framedecode, &thumbnail);
154 ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %lx\n", hr);
155
156 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
157 &IID_IWICImagingFactory, (void**)&factory);
158 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
159 if (SUCCEEDED(hr))
160 {
161 hr = IWICImagingFactory_CreatePalette(factory, &palette);
162 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%lx\n", hr);
163 if (SUCCEEDED(hr))
164 {
165 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
166 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
167
168 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
169 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
170
171 IWICPalette_Release(palette);
172 }
173
174 IWICImagingFactory_Release(factory);
175 }
176
177 rc.X = 0;
178 rc.Y = 0;
179 rc.Width = 3;
180 rc.Height = 3;
181 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
182 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %lx\n", hr);
183
184 rc.X = -1;
185 rc.Y = 0;
186 rc.Width = 2;
187 rc.Height = 3;
188 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
189 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %lx\n", hr);
190
191 rc.X = 0;
192 rc.Y = 0;
193 rc.Width = 2;
194 rc.Height = 3;
195 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, sizeof(imagedata), imagedata);
196 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %lx\n", hr);
197
198 rc.X = 0;
199 rc.Y = 0;
200 rc.Width = 2;
201 rc.Height = 3;
202 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, 5, imagedata);
203 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %lx\n", hr);
204
205 rc.X = 0;
206 rc.Y = 0;
207 rc.Width = 2;
208 rc.Height = 3;
209 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
210 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%lx\n", hr);
211 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
212
213 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, NULL, 6, sizeof(imagedata), imagedata);
214 ok(SUCCEEDED(hr), "CopyPixels(rect=NULL) failed, hr=%lx\n", hr);
215 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
216
217 IWICBitmapFrameDecode_Release(framedecode);
218 }
219
220 /* cannot initialize twice */
221 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
222 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%lx\n", hr);
223
224 /* cannot querycapability after initialize */
225 hr = IWICBitmapDecoder_QueryCapability(decoder, bmpstream, &capability);
226 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%lx\n", hr);
227
228 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
229 &IID_IWICBitmapDecoder, (void**)&decoder2);
230 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
231 if (SUCCEEDED(hr))
232 {
233 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
234 ok(hr == S_OK, "QueryCapability failed, hr=%lx\n", hr);
235 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
236 "unexpected capabilities: %lx\n", capability);
237
238 /* cannot initialize after querycapability */
239 hr = IWICBitmapDecoder_Initialize(decoder2, bmpstream, WICDecodeMetadataCacheOnLoad);
240 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%lx\n", hr);
241
242 /* cannot querycapability twice */
243 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
244 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%lx\n", hr);
245
246 IWICBitmapDecoder_Release(decoder2);
247 }
248
249 IStream_Release(bmpstream);
250 }
251
252 GlobalFree(hbmpdata);
253 }
254
255 IWICBitmapDecoder_Release(decoder);
256}
257
258static const char testbmp_1bpp[] = {
259 /* BITMAPFILEHEADER */
260 66,77, /* "BM" */
261 40,0,0,0, /* file size */
262 0,0,0,0, /* reserved */
263 32,0,0,0, /* offset to bits */
264 /* BITMAPCOREHEADER */
265 12,0,0,0, /* header size */
266 2,0, /* width */
267 2,0, /* height */
268 1,0, /* planes */
269 1,0, /* bit count */
270 /* color table */
271 255,0,0,
272 0,255,0,
273 /* bits */
274 0xc0,0,0,0,
275 0x80,0,0,0
276};
277
278static void test_decode_1bpp(void)
279{
280 IWICBitmapDecoder *decoder, *decoder2;
281 IWICBitmapFrameDecode *framedecode;
282 HRESULT hr;
283 HGLOBAL hbmpdata;
284 char *bmpdata;
285 IStream *bmpstream;
286 DWORD capability=0;
287 GUID guidresult;
288 UINT count=0, width=0, height=0;
289 double dpiX, dpiY;
290 BYTE imagedata[2] = {1};
291 const BYTE expected_imagedata[2] = {0x80,0xc0};
292 WICColor palettedata[2] = {1};
293 const WICColor expected_palettedata[2] = {0xff0000ff,0xff00ff00};
294 WICRect rc;
295
296 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
297 &IID_IWICBitmapDecoder, (void**)&decoder);
298 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
299 if (FAILED(hr)) return;
300
301 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_1bpp));
302 ok(hbmpdata != 0, "GlobalAlloc failed\n");
303 if (hbmpdata)
304 {
305 bmpdata = GlobalLock(hbmpdata);
306 memcpy(bmpdata, testbmp_1bpp, sizeof(testbmp_1bpp));
307 GlobalUnlock(hbmpdata);
308
309 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
310 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
311 if (SUCCEEDED(hr))
312 {
313 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
314 ok(hr == S_OK, "Initialize failed, hr=%lx\n", hr);
315
316 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
317 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
318 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
319
320 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
321 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%lx\n", hr);
322 ok(count == 1, "unexpected count %u\n", count);
323
324 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
325 ok(SUCCEEDED(hr), "GetFrame failed, hr=%lx\n", hr);
326 if (SUCCEEDED(hr))
327 {
328 IWICImagingFactory *factory;
329 IWICPalette *palette;
330
331 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
332 ok(SUCCEEDED(hr), "GetSize failed, hr=%lx\n", hr);
333 ok(width == 2, "expected width=2, got %u\n", width);
334 ok(height == 2, "expected height=2, got %u\n", height);
335
336 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
337 ok(SUCCEEDED(hr), "GetResolution failed, hr=%lx\n", hr);
338 ok(dpiX == 96.0, "expected dpiX=96.0, got %f\n", dpiX);
339 ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
340
341 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
342 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%lx\n", hr);
343 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat1bppIndexed), "unexpected pixel format\n");
344
345 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
346 &IID_IWICImagingFactory, (void**)&factory);
347 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
348 if (SUCCEEDED(hr))
349 {
350 hr = IWICImagingFactory_CreatePalette(factory, &palette);
351 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%lx\n", hr);
352 if (SUCCEEDED(hr))
353 {
354 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
355 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
356
357 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
358 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%lx\n", hr);
359
360 hr = IWICPalette_GetColorCount(palette, &count);
361 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
362 ok(count == 2, "expected count=2, got %u\n", count);
363
364 hr = IWICPalette_GetColors(palette, 2, palettedata, &count);
365 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
366 ok(count == 2, "expected count=2, got %u\n", count);
367 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
368
369 IWICPalette_Release(palette);
370 }
371
372 IWICImagingFactory_Release(factory);
373 }
374
375 rc.X = 0;
376 rc.Y = 0;
377 rc.Width = 2;
378 rc.Height = 2;
379 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 1, sizeof(imagedata), imagedata);
380 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%lx\n", hr);
381 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
382
383 IWICBitmapFrameDecode_Release(framedecode);
384 }
385
386 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
387 &IID_IWICBitmapDecoder, (void**)&decoder2);
388 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
389 if (SUCCEEDED(hr))
390 {
391 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
392 ok(hr == S_OK, "QueryCapability failed, hr=%lx\n", hr);
393 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
394 "unexpected capabilities: %lx\n", capability);
395 IWICBitmapDecoder_Release(decoder2);
396 }
397
398 IStream_Release(bmpstream);
399 }
400
401 GlobalFree(hbmpdata);
402 }
403
404 IWICBitmapDecoder_Release(decoder);
405}
406
407static const char testbmp_4bpp[] = {
408 /* BITMAPFILEHEADER */
409 66,77, /* "BM" */
410 82,0,0,0, /* file size */
411 0,0,0,0, /* reserved */
412 74,0,0,0, /* offset to bits */
413 /* BITMAPINFOHEADER */
414 40,0,0,0, /* header size */
415 2,0,0,0, /* width */
416 254,255,255,255, /* height = -2 */
417 1,0, /* planes */
418 4,0, /* bit count */
419 0,0,0,0, /* compression = BI_RGB */
420 0,0,0,0, /* image size = 0 */
421 16,39,0,0, /* X pixels per meter = 10000 */
422 32,78,0,0, /* Y pixels per meter = 20000 */
423 5,0,0,0, /* colors used */
424 5,0,0,0, /* colors important */
425 /* color table */
426 255,0,0,0,
427 0,255,0,255,
428 0,0,255,23,
429 128,0,128,1,
430 255,255,255,0,
431 /* bits */
432 0x01,0,0,0,
433 0x23,0,0,0,
434};
435
436static void test_decode_4bpp(void)
437{
438 IWICBitmapDecoder *decoder, *decoder2;
439 IWICBitmapFrameDecode *framedecode;
440 HRESULT hr;
441 HGLOBAL hbmpdata;
442 char *bmpdata;
443 IStream *bmpstream;
444 DWORD capability=0;
445 GUID guidresult;
446 UINT count=0, width=0, height=0;
447 double dpiX, dpiY;
448 BYTE imagedata[2] = {1};
449 const BYTE expected_imagedata[2] = {0x01,0x23};
450 WICColor palettedata[5] = {1};
451 const WICColor expected_palettedata[5] =
452 {0xff0000ff,0xff00ff00,0xffff0000,0xff800080,0xffffffff};
453 WICRect rc;
454
455 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
456 &IID_IWICBitmapDecoder, (void**)&decoder);
457 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
458 if (FAILED(hr)) return;
459
460 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_4bpp));
461 ok(hbmpdata != 0, "GlobalAlloc failed\n");
462 if (hbmpdata)
463 {
464 bmpdata = GlobalLock(hbmpdata);
465 memcpy(bmpdata, testbmp_4bpp, sizeof(testbmp_4bpp));
466 GlobalUnlock(hbmpdata);
467
468 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
469 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
470 if (SUCCEEDED(hr))
471 {
472 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
473 ok(hr == S_OK, "Initialize failed, hr=%lx\n", hr);
474
475 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
476 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
477 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
478
479 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
480 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%lx\n", hr);
481 ok(count == 1, "unexpected count %u\n", count);
482
483 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
484 ok(SUCCEEDED(hr), "GetFrame failed, hr=%lx\n", hr);
485 if (SUCCEEDED(hr))
486 {
487 IWICImagingFactory *factory;
488 IWICPalette *palette;
489
490 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
491 ok(SUCCEEDED(hr), "GetSize failed, hr=%lx\n", hr);
492 ok(width == 2, "expected width=2, got %u\n", width);
493 ok(height == 2, "expected height=2, got %u\n", height);
494
495 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
496 ok(SUCCEEDED(hr), "GetResolution failed, hr=%lx\n", hr);
497 ok(fabs(dpiX - 254.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
498 ok(fabs(dpiY - 508.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
499
500 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
501 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%lx\n", hr);
502 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
503
504 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
505 &IID_IWICImagingFactory, (void**)&factory);
506 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
507 if (SUCCEEDED(hr))
508 {
509 hr = IWICImagingFactory_CreatePalette(factory, &palette);
510 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%lx\n", hr);
511 if (SUCCEEDED(hr))
512 {
513 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
514 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
515
516 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
517 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%lx\n", hr);
518
519 hr = IWICPalette_GetColorCount(palette, &count);
520 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
521 ok(count == 5, "expected count=5, got %u\n", count);
522
523 hr = IWICPalette_GetColors(palette, 5, palettedata, &count);
524 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
525 ok(count == 5, "expected count=5, got %u\n", count);
526 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
527
528 IWICPalette_Release(palette);
529 }
530
531 IWICImagingFactory_Release(factory);
532 }
533
534 rc.X = 0;
535 rc.Y = 0;
536 rc.Width = 2;
537 rc.Height = 2;
538 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 1, sizeof(imagedata), imagedata);
539 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%lx\n", hr);
540 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
541
542 IWICBitmapFrameDecode_Release(framedecode);
543 }
544
545 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
546 &IID_IWICBitmapDecoder, (void**)&decoder2);
547 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
548 if (SUCCEEDED(hr))
549 {
550 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
551 ok(hr == S_OK, "QueryCapability failed, hr=%lx\n", hr);
552 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
553 "unexpected capabilities: %lx\n", capability);
554 IWICBitmapDecoder_Release(decoder2);
555 }
556
557 IStream_Release(bmpstream);
558 }
559
560 GlobalFree(hbmpdata);
561 }
562
563 IWICBitmapDecoder_Release(decoder);
564}
565
566static const char testbmp_rle8[] = {
567 /* BITMAPFILEHEADER */
568 66,77, /* "BM" */
569 202,0,0,0, /* file size */
570 0,0,0,0, /* reserved */
571 122,0,0,0, /* offset to bits */
572 /* BITMAPINFOHEADER */
573 40,0,0,0, /* header size */
574 8,0,0,0, /* width */
575 8,0,0,0, /* height */
576 1,0, /* planes */
577 8,0, /* bit count */
578 1,0,0,0, /* compression = BI_RLE8 */
579 80,0,0,0, /* image size */
580 19,11,0,0, /* X pixels per meter */
581 19,11,0,0, /* Y pixels per meter */
582 17,0,0,0, /* colors used */
583 17,0,0,0, /* colors important */
584 /* color table */
585 0,0,0,0,
586 17,17,17,0,
587 255,0,0,0,
588 34,34,34,0,
589 0,0,204,0,
590 0,0,221,0,
591 0,0,238,0,
592 51,51,51,0,
593 0,0,255,0,
594 68,68,68,0,
595 255,0,255,0,
596 85,85,85,0,
597 0,204,0,0,
598 0,221,0,0,
599 0,238,0,0,
600 0,255,0,0,
601 255,255,255,0,
602 /* bits */
603 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
604};
605
606static void test_decode_rle8(void)
607{
608 IWICBitmapDecoder *decoder, *decoder2;
609 IWICBitmapFrameDecode *framedecode;
610 HRESULT hr;
611 HGLOBAL hbmpdata;
612 char *bmpdata;
613 IStream *bmpstream;
614 DWORD capability=0;
615 GUID guidresult;
616 UINT count=0, width=0, height=0;
617 double dpiX, dpiY;
618 DWORD imagedata[64] = {1};
619 const DWORD expected_imagedata[64] = {
620 0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
621 0xffffff,0x0000ff,0xffffff,0x0000ff,0xee0000,0xee0000,0xee0000,0xee0000,
622 0x0000ff,0xffffff,0x0000ff,0xffffff,0xdd0000,0xdd0000,0xdd0000,0xdd0000,
623 0xffffff,0x0000ff,0xffffff,0x0000ff,0xcc0000,0xcc0000,0xcc0000,0xcc0000,
624 0x00cc00,0x00cc00,0x00cc00,0x00cc00,0x000000,0x111111,0x111111,0x555555,
625 0x00dd00,0x00dd00,0x00dd00,0x00dd00,0x222222,0xff00ff,0xff00ff,0x333333,
626 0x00ee00,0x00ee00,0x00ee00,0x00ee00,0x222222,0xff00ff,0xff00ff,0x333333,
627 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x555555,0x444444,0x444444,0x000000};
628 WICColor palettedata[17] = {1};
629 const WICColor expected_palettedata[17] = {
630 0xff000000,0xff111111,0xff0000ff,0xff222222,0xffcc0000,0xffdd0000,
631 0xffee0000,0xff333333,0xffff0000,0xff444444,0xffff00ff,0xff555555,
632 0xff00cc00,0xff00dd00,0xff00ee00,0xff00ff00,0xffffffff};
633 WICRect rc;
634
635 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
636 &IID_IWICBitmapDecoder, (void**)&decoder);
637 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
638 if (FAILED(hr)) return;
639
640 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle8));
641 ok(hbmpdata != 0, "GlobalAlloc failed\n");
642 if (hbmpdata)
643 {
644 bmpdata = GlobalLock(hbmpdata);
645 memcpy(bmpdata, testbmp_rle8, sizeof(testbmp_rle8));
646 GlobalUnlock(hbmpdata);
647
648 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
649 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
650 if (SUCCEEDED(hr))
651 {
652 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
653 ok(hr == S_OK, "Initialize failed, hr=%lx\n", hr);
654
655 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
656 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
657 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
658
659 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
660 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%lx\n", hr);
661 ok(count == 1, "unexpected count %u\n", count);
662
663 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
664 ok(SUCCEEDED(hr), "GetFrame failed, hr=%lx\n", hr);
665 if (SUCCEEDED(hr))
666 {
667 IWICImagingFactory *factory;
668 IWICPalette *palette;
669
670 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
671 ok(SUCCEEDED(hr), "GetSize failed, hr=%lx\n", hr);
672 ok(width == 8, "expected width=8, got %u\n", width);
673 ok(height == 8, "expected height=8, got %u\n", height);
674
675 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
676 ok(SUCCEEDED(hr), "GetResolution failed, hr=%lx\n", hr);
677 ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
678 ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
679
680 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
681 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%lx\n", hr);
682 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
683
684 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
685 &IID_IWICImagingFactory, (void**)&factory);
686 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
687 if (SUCCEEDED(hr))
688 {
689 hr = IWICImagingFactory_CreatePalette(factory, &palette);
690 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%lx\n", hr);
691 if (SUCCEEDED(hr))
692 {
693 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
694 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
695
696 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
697 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%lx\n", hr);
698
699 hr = IWICPalette_GetColorCount(palette, &count);
700 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
701 ok(count == 17, "expected count=17, got %u\n", count);
702
703 hr = IWICPalette_GetColors(palette, 17, palettedata, &count);
704 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
705 ok(count == 17, "expected count=17, got %u\n", count);
706 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
707
708 IWICPalette_Release(palette);
709 }
710
711 IWICImagingFactory_Release(factory);
712 }
713
714 rc.X = 0;
715 rc.Y = 0;
716 rc.Width = 8;
717 rc.Height = 8;
718 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
719 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%lx\n", hr);
720 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
721
722 IWICBitmapFrameDecode_Release(framedecode);
723 }
724
725 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
726 &IID_IWICBitmapDecoder, (void**)&decoder2);
727 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
728 if (SUCCEEDED(hr))
729 {
730 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
731 ok(hr == S_OK, "QueryCapability failed, hr=%lx\n", hr);
732 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
733 "unexpected capabilities: %lx\n", capability);
734 IWICBitmapDecoder_Release(decoder2);
735 }
736
737 IStream_Release(bmpstream);
738 }
739
740 GlobalFree(hbmpdata);
741 }
742
743 IWICBitmapDecoder_Release(decoder);
744}
745
746static const char testbmp_rle4[] = {
747 /* BITMAPFILEHEADER */
748 66,77, /* "BM" */
749 142,0,0,0, /* file size */
750 0,0,0,0, /* reserved */
751 78,0,0,0, /* offset to bits */
752 /* BITMAPINFOHEADER */
753 40,0,0,0, /* header size */
754 8,0,0,0, /* width */
755 8,0,0,0, /* height */
756 1,0, /* planes */
757 4,0, /* bit count */
758 2,0,0,0, /* compression = BI_RLE4 */
759 64,0,0,0, /* image size */
760 19,11,0,0, /* X pixels per meter */
761 19,11,0,0, /* Y pixels per meter */
762 6,0,0,0, /* colors used */
763 6,0,0,0, /* colors important */
764 /* color table */
765 0,0,0,0,
766 255,0,0,0,
767 0,0,255,0,
768 255,0,255,0,
769 0,255,0,0,
770 255,255,255,0,
771 /* bits */
772 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
773};
774
775static void test_decode_rle4(void)
776{
777 IWICBitmapDecoder *decoder, *decoder2;
778 IWICBitmapFrameDecode *framedecode;
779 HRESULT hr;
780 HGLOBAL hbmpdata;
781 char *bmpdata;
782 IStream *bmpstream;
783 DWORD capability=0;
784 GUID guidresult;
785 UINT count=0, width=0, height=0;
786 double dpiX, dpiY;
787 DWORD imagedata[64] = {1};
788 const DWORD expected_imagedata[64] = {
789 0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
790 0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
791 0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
792 0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
793 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000,
794 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
795 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
796 0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000};
797 WICColor palettedata[6] = {1};
798 const WICColor expected_palettedata[6] = {
799 0xff000000,0xff0000ff,0xffff0000,0xffff00ff,0xff00ff00,0xffffffff};
800 WICRect rc;
801
802 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
803 &IID_IWICBitmapDecoder, (void**)&decoder);
804 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
805 if (FAILED(hr)) return;
806
807 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
808 ok(hbmpdata != 0, "GlobalAlloc failed\n");
809 if (hbmpdata)
810 {
811 bmpdata = GlobalLock(hbmpdata);
812 memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
813 GlobalUnlock(hbmpdata);
814
815 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
816 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
817 if (SUCCEEDED(hr))
818 {
819 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
820 ok(hr == S_OK, "Initialize failed, hr=%lx\n", hr);
821
822 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
823 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
824 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
825
826 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
827 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%lx\n", hr);
828 ok(count == 1, "unexpected count %u\n", count);
829
830 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
831 ok(SUCCEEDED(hr), "GetFrame failed, hr=%lx\n", hr);
832 if (SUCCEEDED(hr))
833 {
834 IWICImagingFactory *factory;
835 IWICPalette *palette;
836
837 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
838 ok(SUCCEEDED(hr), "GetSize failed, hr=%lx\n", hr);
839 ok(width == 8, "expected width=8, got %u\n", width);
840 ok(height == 8, "expected height=8, got %u\n", height);
841
842 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
843 ok(SUCCEEDED(hr), "GetResolution failed, hr=%lx\n", hr);
844 ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
845 ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
846
847 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
848 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%lx\n", hr);
849 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
850
851 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
852 &IID_IWICImagingFactory, (void**)&factory);
853 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
854 if (SUCCEEDED(hr))
855 {
856 hr = IWICImagingFactory_CreatePalette(factory, &palette);
857 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%lx\n", hr);
858 if (SUCCEEDED(hr))
859 {
860 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
861 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
862
863 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
864 ok(SUCCEEDED(hr), "CopyPalette failed, hr=%lx\n", hr);
865
866 hr = IWICPalette_GetColorCount(palette, &count);
867 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
868 ok(count == 6, "expected count=6, got %u\n", count);
869
870 hr = IWICPalette_GetColors(palette, 6, palettedata, &count);
871 ok(SUCCEEDED(hr), "GetColorCount failed, hr=%lx\n", hr);
872 ok(count == 6, "expected count=6, got %u\n", count);
873 ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
874
875 IWICPalette_Release(palette);
876 }
877
878 IWICImagingFactory_Release(factory);
879 }
880
881 rc.X = 0;
882 rc.Y = 0;
883 rc.Width = 8;
884 rc.Height = 8;
885 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
886 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%lx\n", hr);
887 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
888
889 IWICBitmapFrameDecode_Release(framedecode);
890 }
891
892 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
893 &IID_IWICBitmapDecoder, (void**)&decoder2);
894 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
895 if (SUCCEEDED(hr))
896 {
897 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
898 ok(hr == S_OK, "QueryCapability failed, hr=%lx\n", hr);
899 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
900 "unexpected capabilities: %lx\n", capability);
901 IWICBitmapDecoder_Release(decoder2);
902 }
903
904 IStream_Release(bmpstream);
905 }
906
907 GlobalFree(hbmpdata);
908 }
909
910 IWICBitmapDecoder_Release(decoder);
911}
912
913static const char testbmp_bitfields_abgr[] = {
914 /* BITMAPFILEHEADER */
915 'B','M', /* "BM" */
916 sizeof(BITMAPFILEHEADER)+sizeof(BITMAPV5HEADER)+8,0,0,0, /* file size */
917 0,0,0,0, /* reserved */
918 sizeof(BITMAPFILEHEADER)+sizeof(BITMAPV5HEADER),0,0,0, /* offset to bits */
919 /* BITMAPV5HEADER */
920 sizeof(BITMAPV5HEADER),0,0,0, /* size */
921 2,0,0,0, /* width */
922 1,0,0,0, /* height */
923 1,0, /* planes */
924 32,0, /* bit count */
925 BI_BITFIELDS,0,0,0, /* compression */
926 8,0,0,0, /* image size */
927 19,11,0,0, /* X pixels per meter */
928 19,11,0,0, /* Y pixels per meter */
929 0,0,0,0, /* colors used */
930 0,0,0,0, /* colors important */
931 0,0,0,255, /* red mask */
932 0,0,255,0, /* green mask */
933 0,255,0,0, /* blue mask */
934 255,0,0,0, /* alpha mask */
935 'B','G','R','s', /* color space */
936 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
937 0,0,0,0,0,0,0,0,0,0,0,0, /* gamma */
938 LCS_GM_GRAPHICS,0,0,0, /* intent */
939 0,0,0,0,0,0,0,0,0,0,0,0,
940 /* bits */
941 0,255,0,0,255,0,255,0
942};
943
944static void test_decode_bitfields(void)
945{
946 IWICBitmapDecoder *decoder;
947 IWICBitmapFrameDecode *framedecode;
948 HRESULT hr;
949 HGLOBAL hbmpdata;
950 char *bmpdata;
951 IStream *bmpstream;
952 GUID guidresult;
953 UINT count=0, width=0, height=0;
954 double dpiX, dpiY;
955 DWORD imagedata[2] = {1};
956 const DWORD expected_imagedata[2] = { 0xff, 0xff00 };
957 WICRect rc;
958
959 hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
960 &IID_IWICBitmapDecoder, (void**)&decoder);
961 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
962 if (FAILED(hr)) return;
963
964 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_bitfields_abgr));
965 ok(hbmpdata != 0, "GlobalAlloc failed\n");
966 if (hbmpdata)
967 {
968 bmpdata = GlobalLock(hbmpdata);
969 memcpy(bmpdata, testbmp_bitfields_abgr, sizeof(testbmp_bitfields_abgr));
970 GlobalUnlock(hbmpdata);
971
972 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
973 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
974 if (SUCCEEDED(hr))
975 {
976 hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
977 ok(hr == S_OK, "Initialize failed, hr=%lx\n", hr);
978
979 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
980 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
981 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
982
983 hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
984 ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%lx\n", hr);
985 ok(count == 1, "unexpected count %u\n", count);
986
987 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
988 ok(SUCCEEDED(hr), "GetFrame failed, hr=%lx\n", hr);
989 if (SUCCEEDED(hr))
990 {
991 IWICImagingFactory *factory;
992 IWICPalette *palette;
993
994 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
995 ok(SUCCEEDED(hr), "GetSize failed, hr=%lx\n", hr);
996 ok(width == 2, "expected width=2, got %u\n", width);
997 ok(height == 1, "expected height=1, got %u\n", height);
998
999 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
1000 ok(SUCCEEDED(hr), "GetResolution failed, hr=%lx\n", hr);
1001 ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=72.0, got %f\n", dpiX);
1002 ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=72.0, got %f\n", dpiY);
1003
1004 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
1005 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%lx\n", hr);
1006 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
1007
1008 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1009 &IID_IWICImagingFactory, (void**)&factory);
1010 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
1011 if (SUCCEEDED(hr))
1012 {
1013 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1014 ok(SUCCEEDED(hr), "CreatePalette failed, hr=%lx\n", hr);
1015 if (SUCCEEDED(hr))
1016 {
1017 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
1018 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
1019
1020 hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
1021 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %lx\n", hr);
1022
1023 IWICPalette_Release(palette);
1024 }
1025
1026 IWICImagingFactory_Release(factory);
1027 }
1028
1029 rc.X = 0;
1030 rc.Y = 0;
1031 rc.Width = 2;
1032 rc.Height = 1;
1033 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
1034 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%lx\n", hr);
1035 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
1036
1037 IWICBitmapFrameDecode_Release(framedecode);
1038 }
1039
1040 IStream_Release(bmpstream);
1041 }
1042
1043 GlobalFree(hbmpdata);
1044 }
1045
1046 IWICBitmapDecoder_Release(decoder);
1047}
1048
1049static void test_componentinfo(void)
1050{
1051 IWICImagingFactory *factory;
1052 IWICComponentInfo *info;
1053 IWICBitmapDecoderInfo *decoderinfo;
1054 IWICBitmapDecoder *decoder;
1055 HRESULT hr;
1056 WICBitmapPattern *patterns;
1057 UINT pattern_count, pattern_size;
1058 WICComponentType type;
1059 GUID guidresult;
1060 HGLOBAL hbmpdata;
1061 char *bmpdata;
1062 IStream *bmpstream;
1063 BOOL boolresult;
1064
1065 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1066 &IID_IWICImagingFactory, (void**)&factory);
1067 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
1068 if (SUCCEEDED(hr))
1069 {
1070 hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICBmpDecoder, &info);
1071 ok(SUCCEEDED(hr), "CreateComponentInfo failed, hr=%lx\n", hr);
1072 if (SUCCEEDED(hr))
1073 {
1074 hr = IWICComponentInfo_GetComponentType(info, &type);
1075 ok(SUCCEEDED(hr), "GetComponentType failed, hr=%lx\n", hr);
1076 ok(type == WICDecoder, "got %i, expected WICDecoder\n", type);
1077
1078 hr = IWICComponentInfo_QueryInterface(info, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
1079 ok(SUCCEEDED(hr), "QueryInterface failed, hr=%lx\n", hr);
1080 if (SUCCEEDED(hr))
1081 {
1082 pattern_count = 0;
1083 pattern_size = 0;
1084 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, 0, NULL, &pattern_count, &pattern_size);
1085 ok(SUCCEEDED(hr), "GetPatterns failed, hr=%lx\n", hr);
1086 ok(pattern_count != 0, "pattern count is 0\n");
1087 ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
1088
1089 patterns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pattern_size);
1090 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
1091 ok(SUCCEEDED(hr), "GetPatterns failed, hr=%lx\n", hr);
1092 ok(pattern_count != 0, "pattern count is 0\n");
1093 ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
1094 ok(patterns[0].Length != 0, "pattern length is 0\n");
1095 ok(patterns[0].Pattern != NULL, "pattern is NULL\n");
1096 ok(patterns[0].Mask != NULL, "mask is NULL\n");
1097
1098 pattern_size -= 1;
1099 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
1100 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "GetPatterns returned %lx, expected WINCODEC_ERR_INSUFFICIENTBUFFER\n", hr);
1101
1102 HeapFree(GetProcessHeap(), 0, patterns);
1103
1104 hr = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
1105 ok(SUCCEEDED(hr), "CreateInstance failed, hr=%lx\n", hr);
1106 if (SUCCEEDED(hr))
1107 {
1108 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
1109 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
1110 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
1111
1112 IWICBitmapDecoder_Release(decoder);
1113 }
1114
1115 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
1116 ok(hbmpdata != 0, "GlobalAlloc failed\n");
1117 if (hbmpdata)
1118 {
1119 bmpdata = GlobalLock(hbmpdata);
1120 memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
1121 GlobalUnlock(hbmpdata);
1122
1123 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
1124 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
1125 if (SUCCEEDED(hr))
1126 {
1127 boolresult = 0;
1128 hr = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, bmpstream, &boolresult);
1129 ok(SUCCEEDED(hr), "MatchesPattern failed, hr=%lx\n", hr);
1130 ok(boolresult, "pattern not matched\n");
1131
1132 IStream_Release(bmpstream);
1133 }
1134
1135 GlobalFree(hbmpdata);
1136 }
1137
1138 IWICBitmapDecoderInfo_Release(decoderinfo);
1139 }
1140
1141 IWICComponentInfo_Release(info);
1142 }
1143
1144 IWICImagingFactory_Release(factory);
1145 }
1146}
1147
1148static void test_createfromstream(void)
1149{
1150 IWICBitmapDecoder *decoder;
1151 IWICImagingFactory *factory;
1152 HRESULT hr;
1153 HGLOBAL hbmpdata;
1154 char *bmpdata;
1155 IStream *bmpstream;
1156 GUID guidresult;
1157
1158 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1159 &IID_IWICImagingFactory, (void**)&factory);
1160 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%lx\n", hr);
1161 if (FAILED(hr)) return;
1162
1163 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_1bpp));
1164 ok(hbmpdata != 0, "GlobalAlloc failed\n");
1165 if (hbmpdata)
1166 {
1167 bmpdata = GlobalLock(hbmpdata);
1168 memcpy(bmpdata, testbmp_1bpp, sizeof(testbmp_1bpp));
1169 GlobalUnlock(hbmpdata);
1170
1171 hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
1172 ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%lx\n", hr);
1173 if (SUCCEEDED(hr))
1174 {
1175 hr = IWICImagingFactory_CreateDecoderFromStream(factory, bmpstream,
1176 NULL, WICDecodeMetadataCacheOnDemand, &decoder);
1177 ok(SUCCEEDED(hr), "CreateDecoderFromStream failed, hr=%lx\n", hr);
1178 if (SUCCEEDED(hr))
1179 {
1180 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
1181 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%lx\n", hr);
1182 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
1183
1184 IWICBitmapDecoder_Release(decoder);
1185 }
1186
1187 IStream_Release(bmpstream);
1188 }
1189
1190 GlobalFree(hbmpdata);
1191 }
1192
1193 IWICImagingFactory_Release(factory);
1194}
1195
1196static void test_create_decoder(void)
1197{
1198 IWICBitmapDecoder *decoder;
1199 IWICImagingFactory *factory;
1200 HRESULT hr;
1201
1202 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1203 &IID_IWICImagingFactory, (void **)&factory);
1204 ok(hr == S_OK, "CoCreateInstance error %#lx\n", hr);
1205
1206 hr = IWICImagingFactory_CreateDecoder(factory, NULL, NULL, NULL);
1207 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
1208
1209 hr = IWICImagingFactory_CreateDecoder(factory, NULL, NULL, &decoder);
1210 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#lx\n", hr);
1211
1212 hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatBmp, NULL, &decoder);
1213 ok(hr == S_OK, "CreateDecoder error %#lx\n", hr);
1214 IWICBitmapDecoder_Release(decoder);
1215
1216 hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatBmp, &GUID_VendorMicrosoft, &decoder);
1217 ok(hr == S_OK, "CreateDecoder error %#lx\n", hr);
1218 IWICBitmapDecoder_Release(decoder);
1219
1220 IWICImagingFactory_Release(factory);
1221}
1222
1223static void test_writesource_palette(void)
1224{
1225 IWICImagingFactory *factory;
1226 HRESULT hr;
1227 WICColor encode_palette[2] = {0xff111111, 0xffcccccc};
1228 WICColor source_palette[2] = {0xff555555, 0xffaaaaaa};
1229 WICColor result_palette[2];
1230 UINT result_colors;
1231 IWICBitmap *bitmap;
1232 IWICPalette *palette;
1233 IStream *stream;
1234 IWICBitmapEncoder *encoder;
1235 IWICBitmapFrameEncode *frame_encode;
1236 IPropertyBag2 *encode_options;
1237 GUID pixelformat;
1238 IWICBitmapDecoder *decoder;
1239 IWICBitmapFrameDecode *frame_decode;
1240
1241 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1242 &IID_IWICImagingFactory, (void **)&factory);
1243 ok(hr == S_OK, "CoCreateInstance error %#lx\n", hr);
1244
1245 /* Encoder with palette set */
1246 hr = IWICImagingFactory_CreateBitmap(factory, 1, 1, &GUID_WICPixelFormat1bppIndexed,
1247 WICBitmapCacheOnDemand, &bitmap);
1248 ok(hr == S_OK, "CreateBitmap error %#lx\n", hr);
1249
1250 hr = IWICImagingFactory_CreatePalette(factory, &palette);
1251 ok(hr == S_OK, "CreatePalette error %#lx\n", hr);
1252
1253 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1254 ok(hr == S_OK, "CreateStream error %#lx\n", hr);
1255
1256 hr = IWICImagingFactory_CreateEncoder(factory, &GUID_ContainerFormatBmp, &GUID_VendorMicrosoft, &encoder);
1257 ok(hr == S_OK, "CreateDecoder error %#lx\n", hr);
1258
1259 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
1260 ok(hr == S_OK, "IWICBitmapEncoder_Initialize error %#lx\n", hr);
1261
1262 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frame_encode, &encode_options);
1263 ok(hr == S_OK, "CreateNewFrame error %#lx\n", hr);
1264
1265 hr = IWICBitmapFrameEncode_Initialize(frame_encode, encode_options);
1266 ok(hr == S_OK, "IWICBitmapFrameEncode_Initialize error %#lx\n", hr);
1267
1268 IPropertyBag2_Release(encode_options);
1269
1270 hr = IWICBitmapFrameEncode_SetSize(frame_encode, 1, 1);
1271 ok(hr == S_OK, "SetSize error %#lx\n", hr);
1272
1273 pixelformat = GUID_WICPixelFormat1bppIndexed;
1274 hr = IWICBitmapFrameEncode_SetPixelFormat(frame_encode, &pixelformat);
1275 ok(hr == S_OK, "SetPixelFormat error %#lx\n", hr);
1276 ok(!memcmp(&pixelformat, &GUID_WICPixelFormat1bppIndexed, sizeof(pixelformat)), "pixel format changed\n");
1277
1278 hr = IWICPalette_InitializeCustom(palette, encode_palette, 2);
1279 ok(hr == S_OK, "InitializeCustom error %#lx\n", hr);
1280
1281 hr = IWICBitmapFrameEncode_SetPalette(frame_encode, palette);
1282 ok(hr == S_OK, "SetPalette error %#lx\n", hr);
1283
1284 hr = IWICPalette_InitializeCustom(palette, source_palette, 2);
1285 ok(hr == S_OK, "InitializeCustom error %#lx\n", hr);
1286
1287 hr = IWICBitmap_SetPalette(bitmap, palette);
1288 ok(hr == S_OK, "SetPalette error %#lx\n", hr);
1289
1290 hr = IWICBitmapFrameEncode_WriteSource(frame_encode, (IWICBitmapSource*)bitmap, NULL);
1291 ok(hr == S_OK, "WriteSource error %#lx\n", hr);
1292
1293 hr = IWICBitmapFrameEncode_Commit(frame_encode);
1294 ok(hr == S_OK, "Commit error %#lx\n", hr);
1295
1296 IWICBitmapFrameEncode_Release(frame_encode);
1297
1298 hr = IWICBitmapEncoder_Commit(encoder);
1299 ok(hr == S_OK, "Commit error %#lx\n", hr);
1300
1301 IWICBitmapEncoder_Release(encoder);
1302
1303 hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, WICDecodeMetadataCacheOnLoad, &decoder);
1304 ok(hr == S_OK, "CreateDecoderFromStream error %#lx\n", hr);
1305
1306 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame_decode);
1307 ok(hr == S_OK, "GetFrame error %#lx\n", hr);
1308
1309 hr = IWICBitmapFrameDecode_CopyPalette(frame_decode, palette);
1310 ok(hr == S_OK, "CopyPalette error %#lx\n", hr);
1311
1312 hr = IWICPalette_GetColors(palette, 2, result_palette, &result_colors);
1313 ok(hr == S_OK, "GetColors error %#lx\n", hr);
1314 ok(result_colors == 2, "Got %i colors\n", result_colors);
1315 ok(result_palette[0] == encode_palette[0], "Unexpected palette entry: %x\n", result_palette[0]);
1316 ok(result_palette[1] == encode_palette[1], "Unexpected palette entry: %x\n", result_palette[0]);
1317
1318 IWICBitmapFrameDecode_Release(frame_decode);
1319 IWICBitmapDecoder_Release(decoder);
1320 IStream_Release(stream);
1321
1322 /* Encoder with no palette set */
1323 hr = IWICImagingFactory_CreateEncoder(factory, &GUID_ContainerFormatBmp, &GUID_VendorMicrosoft, &encoder);
1324 ok(hr == S_OK, "CreateDecoder error %#lx\n", hr);
1325
1326 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1327 ok(hr == S_OK, "CreateStream error %#lx\n", hr);
1328
1329 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
1330 ok(hr == S_OK, "IWICBitmapEncoder_Initialize error %#lx\n", hr);
1331
1332 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frame_encode, &encode_options);
1333 ok(hr == S_OK, "CreateNewFrame error %#lx\n", hr);
1334
1335 hr = IWICBitmapFrameEncode_Initialize(frame_encode, encode_options);
1336 ok(hr == S_OK, "IWICBitmapFrameEncode_Initialize error %#lx\n", hr);
1337
1338 IPropertyBag2_Release(encode_options);
1339
1340 hr = IWICBitmapFrameEncode_SetSize(frame_encode, 1, 1);
1341 ok(hr == S_OK, "SetSize error %#lx\n", hr);
1342
1343 pixelformat = GUID_WICPixelFormat1bppIndexed;
1344 hr = IWICBitmapFrameEncode_SetPixelFormat(frame_encode, &pixelformat);
1345 ok(hr == S_OK, "SetPixelFormat error %#lx\n", hr);
1346 ok(!memcmp(&pixelformat, &GUID_WICPixelFormat1bppIndexed, sizeof(pixelformat)), "pixel format changed\n");
1347
1348 hr = IWICPalette_InitializeCustom(palette, source_palette, 2);
1349 ok(hr == S_OK, "InitializeCustom error %#lx\n", hr);
1350
1351 hr = IWICBitmap_SetPalette(bitmap, palette);
1352 ok(hr == S_OK, "SetPalette error %#lx\n", hr);
1353
1354 hr = IWICBitmapFrameEncode_WriteSource(frame_encode, (IWICBitmapSource*)bitmap, NULL);
1355 if (hr == WINCODEC_ERR_PALETTEUNAVAILABLE)
1356 {
1357 win_skip("old WriteSource palette behavior\n"); /* winxp */
1358 IWICBitmapFrameEncode_Release(frame_encode);
1359 IWICBitmapEncoder_Release(encoder);
1360 IStream_Release(stream);
1361 IWICPalette_Release(palette);
1362 IWICBitmap_Release(bitmap);
1363 IWICImagingFactory_Release(factory);
1364 return;
1365 }
1366 ok(hr == S_OK, "WriteSource error %#lx\n", hr);
1367
1368 hr = IWICBitmapFrameEncode_Commit(frame_encode);
1369 ok(hr == S_OK, "Commit error %#lx\n", hr);
1370
1371 IWICBitmapFrameEncode_Release(frame_encode);
1372
1373 hr = IWICBitmapEncoder_Commit(encoder);
1374 ok(hr == S_OK, "Commit error %#lx\n", hr);
1375
1376 IWICBitmapEncoder_Release(encoder);
1377
1378 hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, WICDecodeMetadataCacheOnLoad, &decoder);
1379 ok(hr == S_OK, "CreateDecoderFromStream error %#lx\n", hr);
1380
1381 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame_decode);
1382 ok(hr == S_OK, "GetFrame error %#lx\n", hr);
1383
1384 hr = IWICBitmapFrameDecode_CopyPalette(frame_decode, palette);
1385 ok(hr == S_OK, "CopyPalette error %#lx\n", hr);
1386
1387 hr = IWICPalette_GetColors(palette, 2, result_palette, &result_colors);
1388 ok(hr == S_OK, "GetColors error %#lx\n", hr);
1389 ok(result_colors == 2, "Got %i colors\n", result_colors);
1390 ok(result_palette[0] == source_palette[0], "Unexpected palette entry: %x\n", result_palette[0]);
1391 ok(result_palette[1] == source_palette[1], "Unexpected palette entry: %x\n", result_palette[0]);
1392
1393 IWICBitmapFrameDecode_Release(frame_decode);
1394 IWICBitmapDecoder_Release(decoder);
1395 IStream_Release(stream);
1396
1397 IWICPalette_Release(palette);
1398 IWICBitmap_Release(bitmap);
1399 IWICImagingFactory_Release(factory);
1400}
1401
1402static void test_encoder_formats(void)
1403{
1404 static const struct
1405 {
1406 const GUID *format;
1407 BOOL supported;
1408 const char *name;
1409 }
1410 tests[] =
1411 {
1412 {&GUID_WICPixelFormat24bppBGR, TRUE, "WICPixelFormat24bppBGR"},
1413 {&GUID_WICPixelFormatBlackWhite, FALSE, "WICPixelFormatBlackWhite"},
1414 {&GUID_WICPixelFormat1bppIndexed, TRUE, "WICPixelFormat1bppIndexed"},
1415 {&GUID_WICPixelFormat2bppIndexed, FALSE, "WICPixelFormat2bppIndexed"},
1416 {&GUID_WICPixelFormat4bppIndexed, TRUE, "WICPixelFormat4bppIndexed"},
1417 {&GUID_WICPixelFormat8bppIndexed, TRUE, "WICPixelFormat8bppIndexed"},
1418 {&GUID_WICPixelFormat16bppBGR555, TRUE, "WICPixelFormat16bppBGR555"},
1419 {&GUID_WICPixelFormat16bppBGR565, TRUE, "WICPixelFormat16bppBGR565"},
1420 {&GUID_WICPixelFormat32bppBGR, TRUE, "WICPixelFormat32bppBGR"},
1421 {&GUID_WICPixelFormat32bppBGRA, TRUE, "WICPixelFormat32bppBGRA"},
1422 {&GUID_WICPixelFormat8bppGray, FALSE, "WICPixelFormat8bppGray"},
1423 };
1424
1425 IWICImagingFactory *factory;
1426 HRESULT hr;
1427 IStream *stream;
1428 IWICBitmapEncoder *encoder;
1429 IWICBitmapFrameEncode *frame_encode;
1430 GUID pixelformat;
1431 LONG refcount;
1432 unsigned int i;
1433 BOOL supported;
1434
1435 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1436 &IID_IWICImagingFactory, (void **)&factory);
1437 ok(hr == S_OK, "got %#lx.\n", hr);
1438
1439 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1440 ok(hr == S_OK, "got %#lx.\n", hr);
1441
1442 hr = IWICImagingFactory_CreateEncoder(factory, &GUID_ContainerFormatBmp, &GUID_VendorMicrosoft, &encoder);
1443 ok(hr == S_OK, "got %#lx.\n", hr);
1444
1445 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
1446 ok(hr == S_OK, "got %#lx.\n", hr);
1447 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frame_encode, NULL);
1448 ok(hr == S_OK, "got %#lx.\n", hr);
1449 hr = IWICBitmapFrameEncode_Initialize(frame_encode, NULL);
1450 ok(hr == S_OK, "got %#lx.\n", hr);
1451
1452 for (i = 0; i < ARRAY_SIZE(tests); ++i)
1453 {
1454 winetest_push_context("%s", tests[i].name);
1455 pixelformat = *tests[i].format;
1456 hr = IWICBitmapFrameEncode_SetPixelFormat(frame_encode, &pixelformat);
1457 ok(hr == S_OK, "got %#lx.\n", hr);
1458 supported = !memcmp(&pixelformat, tests[i].format, sizeof(pixelformat));
1459 ok(supported == tests[i].supported, "got %d.\n", supported);
1460 winetest_pop_context();
1461 }
1462
1463 IWICBitmapFrameEncode_Release(frame_encode);
1464 refcount = IWICBitmapEncoder_Release(encoder);
1465 ok(!refcount, "got %ld.\n", refcount);
1466 IStream_Release(stream);
1467 IWICImagingFactory_Release(factory);
1468}
1469
1470START_TEST(bmpformat)
1471{
1472 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1473
1474 test_decode_24bpp();
1475 test_decode_1bpp();
1476 test_decode_4bpp();
1477 test_decode_rle8();
1478 test_decode_rle4();
1479 test_decode_bitfields();
1480 test_componentinfo();
1481 test_createfromstream();
1482 test_create_decoder();
1483 test_writesource_palette();
1484 test_encoder_formats();
1485
1486 CoUninitialize();
1487}
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ok
#define ok(value,...)
Definition: atltest.h:57
broken
#define broken(x)
Definition: atltest.h:178
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
test_decode_1bpp
static void test_decode_1bpp(void)
Definition: bmpformat.c:278
test_create_decoder
static void test_create_decoder(void)
Definition: bmpformat.c:1196
test_decode_rle8
static void test_decode_rle8(void)
Definition: bmpformat.c:606
testbmp_1bpp
static const char testbmp_1bpp[]
Definition: bmpformat.c:258
testbmp_bitfields_abgr
static const char testbmp_bitfields_abgr[]
Definition: bmpformat.c:913
testbmp_4bpp
static const char testbmp_4bpp[]
Definition: bmpformat.c:407
test_writesource_palette
static void test_writesource_palette(void)
Definition: bmpformat.c:1223
test_encoder_formats
static void test_encoder_formats(void)
Definition: bmpformat.c:1402
test_decode_24bpp
static void test_decode_24bpp(void)
Definition: bmpformat.c:54
testbmp_24bpp
static const char testbmp_24bpp[]
Definition: bmpformat.c:30
test_componentinfo
static void test_componentinfo(void)
Definition: bmpformat.c:1049
testbmp_rle8
static const char testbmp_rle8[]
Definition: bmpformat.c:566
test_decode_rle4
static void test_decode_rle4(void)
Definition: bmpformat.c:775
test_decode_bitfields
static void test_decode_bitfields(void)
Definition: bmpformat.c:944
test_createfromstream
static void test_createfromstream(void)
Definition: bmpformat.c:1148
test_decode_4bpp
static void test_decode_4bpp(void)
Definition: bmpformat.c:436
testbmp_rle4
static const char testbmp_rle4[]
Definition: bmpformat.c:746
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
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
pixelformat
pixelformat
Definition: converter.c:37
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
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
height
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
width
GLint GLint GLsizei width
Definition: gl.h:1546
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
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
BI_BITFIELDS
#define BI_BITFIELDS
Definition: mmreg.h:507
tests
static struct test_info tests[]
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
LONG
long LONG
Definition: pedump.c:60
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
winetest_push_context
void __winetest_cdecl winetest_push_context(const char *fmt,...)
win_skip
#define win_skip
Definition: test.h:164
winetest_pop_context
void winetest_pop_context(void)
hr
HRESULT hr
Definition: shlfolder.c:183
WICRect::Height
INT Height
Definition: wincodec.idl:335
WICRect::Width
INT Width
Definition: wincodec.idl:334
bitmap
Definition: uimain.c:89
factory
Definition: main.c:439
format
Definition: format.c:58
name
Definition: name.c:39
stream
Definition: parse.h:23
GMEM_MOVEABLE
#define GMEM_MOVEABLE
Definition: winbase.h:320
WICBitmapEncoderNoCache
@ WICBitmapEncoderNoCache
Definition: wincodec.idl:73
WICDecodeMetadataCacheOnDemand
@ WICDecodeMetadataCacheOnDemand
Definition: wincodec.idl:29
WICDecodeMetadataCacheOnLoad
@ WICDecodeMetadataCacheOnLoad
Definition: wincodec.idl:30
WICBitmapCacheOnDemand
@ WICBitmapCacheOnDemand
Definition: wincodec.idl:36
WICColor
UINT32 WICColor
Definition: wincodec.idl:364
WICComponentType
WICComponentType
Definition: wincodec.idl:125
WICDecoder
@ WICDecoder
Definition: wincodec.idl:126
WICBitmapDecoderCapabilityCanDecodeAllImages
@ WICBitmapDecoderCapabilityCanDecodeAllImages
Definition: wincodec.idl:50
WINCODEC_ERR_WRONGSTATE
#define WINCODEC_ERR_WRONGSTATE
Definition: winerror.h:3281
WINCODEC_ERR_UNSUPPORTEDOPERATION
#define WINCODEC_ERR_UNSUPPORTEDOPERATION
Definition: winerror.h:3308
WINCODEC_ERR_BADIMAGE
#define WINCODEC_ERR_BADIMAGE
Definition: winerror.h:3299
WINCODEC_ERR_PALETTEUNAVAILABLE
#define WINCODEC_ERR_PALETTEUNAVAILABLE
Definition: winerror.h:3292
WINCODEC_ERR_CODECNOTHUMBNAIL
#define WINCODEC_ERR_CODECNOTHUMBNAIL
Definition: winerror.h:3291
WINCODEC_ERR_FRAMEMISSING
#define WINCODEC_ERR_FRAMEMISSING
Definition: winerror.h:3301
WINCODEC_ERR_INSUFFICIENTBUFFER
#define WINCODEC_ERR_INSUFFICIENTBUFFER
Definition: winerror.h:3311
BITMAPFILEHEADER
struct tagBITMAPFILEHEADER BITMAPFILEHEADER
LCS_GM_GRAPHICS
#define LCS_GM_GRAPHICS
Definition: wingdi.h:1101
BYTE
unsigned char BYTE
Definition: xxhash.c:193