[WINDOWSCODECS_WINETEST] Sync with Wine Staging 3.3. CORE-14434
[reactos.git] / modules / rostests / winetests / windowscodecs / tiffformat.c
1 /*
2 * Copyright 2012,2016 Dmitry Timoshkov
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 <math.h>
20 #include <stdarg.h>
21 #include <stdio.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "wincodec.h"
27 #include "wine/test.h"
28
29 #define IFD_BYTE 1
30 #define IFD_ASCII 2
31 #define IFD_SHORT 3
32 #define IFD_LONG 4
33 #define IFD_RATIONAL 5
34 #define IFD_SBYTE 6
35 #define IFD_UNDEFINED 7
36 #define IFD_SSHORT 8
37 #define IFD_SLONG 9
38 #define IFD_SRATIONAL 10
39 #define IFD_FLOAT 11
40 #define IFD_DOUBLE 12
41
42 #include "pshpack2.h"
43 struct IFD_entry
44 {
45 SHORT id;
46 SHORT type;
47 ULONG count;
48 LONG value;
49 };
50
51 struct IFD_rational
52 {
53 LONG numerator;
54 LONG denominator;
55 };
56
57 static const struct tiff_1bpp_data
58 {
59 USHORT byte_order;
60 USHORT version;
61 ULONG dir_offset;
62 USHORT number_of_entries;
63 struct IFD_entry entry[13];
64 ULONG next_IFD;
65 struct IFD_rational res;
66 BYTE pixel_data[4];
67 } tiff_1bpp_data =
68 {
69 #ifdef WORDS_BIGENDIAN
70 'M' | 'M' << 8,
71 #else
72 'I' | 'I' << 8,
73 #endif
74 42,
75 FIELD_OFFSET(struct tiff_1bpp_data, number_of_entries),
76 13,
77 {
78 { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
79 { 0x100, IFD_LONG, 1, 1 }, /* IMAGEWIDTH */
80 { 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
81 { 0x102, IFD_SHORT, 1, 1 }, /* BITSPERSAMPLE */
82 { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
83 { 0x106, IFD_SHORT, 1, 1 }, /* PHOTOMETRIC */
84 { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_1bpp_data, pixel_data) }, /* STRIPOFFSETS */
85 { 0x115, IFD_SHORT, 1, 1 }, /* SAMPLESPERPIXEL */
86 { 0x116, IFD_LONG, 1, 1 }, /* ROWSPERSTRIP */
87 { 0x117, IFD_LONG, 1, 1 }, /* STRIPBYTECOUNT */
88 { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1bpp_data, res) }, /* XRESOLUTION */
89 { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1bpp_data, res) }, /* YRESOLUTION */
90 { 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
91 },
92 0,
93 { 900, 3 },
94 { 0x11, 0x22, 0x33, 0 }
95 };
96
97 static const struct tiff_8bpp_alpha
98 {
99 USHORT byte_order;
100 USHORT version;
101 ULONG dir_offset;
102 USHORT number_of_entries;
103 struct IFD_entry entry[15];
104 ULONG next_IFD;
105 struct IFD_rational res;
106 BYTE pixel_data[8];
107 } tiff_8bpp_alpha =
108 {
109 #ifdef WORDS_BIGENDIAN
110 'M' | 'M' << 8,
111 #else
112 'I' | 'I' << 8,
113 #endif
114 42,
115 FIELD_OFFSET(struct tiff_8bpp_alpha, number_of_entries),
116 15,
117 {
118 { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
119 { 0x100, IFD_LONG, 1, 2 }, /* IMAGEWIDTH */
120 { 0x101, IFD_LONG, 1, 2 }, /* IMAGELENGTH */
121 { 0x102, IFD_SHORT, 2, MAKELONG(8, 8) }, /* BITSPERSAMPLE */
122 { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
123 { 0x106, IFD_SHORT, 1, 1 }, /* PHOTOMETRIC */
124 { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_8bpp_alpha, pixel_data) }, /* STRIPOFFSETS */
125 { 0x115, IFD_SHORT, 1, 2 }, /* SAMPLESPERPIXEL */
126 { 0x116, IFD_LONG, 1, 2 }, /* ROWSPERSTRIP */
127 { 0x117, IFD_LONG, 1, 8 }, /* STRIPBYTECOUNT */
128 { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_8bpp_alpha, res) }, /* XRESOLUTION */
129 { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_8bpp_alpha, res) }, /* YRESOLUTION */
130 { 0x11c, IFD_SHORT, 1, 1 }, /* PLANARCONFIGURATION */
131 { 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
132 { 0x152, IFD_SHORT, 1, 1 } /* EXTRASAMPLES: 1 - Associated alpha with pre-multiplied color */
133 },
134 0,
135 { 96, 1 },
136 { 0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88 }
137 };
138
139 static const struct tiff_8bpp_data
140 {
141 USHORT byte_order;
142 USHORT version;
143 ULONG dir_offset;
144 USHORT number_of_entries;
145 struct IFD_entry entry[14];
146 ULONG next_IFD;
147 struct IFD_rational res;
148 short palette_data[3][256];
149 BYTE pixel_data[4];
150 } tiff_8bpp_data =
151 {
152 #ifdef WORDS_BIGENDIAN
153 'M' | 'M' << 8,
154 #else
155 'I' | 'I' << 8,
156 #endif
157 42,
158 FIELD_OFFSET(struct tiff_8bpp_data, number_of_entries),
159 14,
160 {
161 { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
162 { 0x100, IFD_LONG, 1, 4 }, /* IMAGEWIDTH */
163 { 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
164 { 0x102, IFD_SHORT, 1, 8 }, /* BITSPERSAMPLE: XP doesn't accept IFD_LONG here */
165 { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
166 { 0x106, IFD_SHORT, 1, 3 }, /* PHOTOMETRIC */
167 { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_8bpp_data, pixel_data) }, /* STRIPOFFSETS */
168 { 0x115, IFD_SHORT, 1, 1 }, /* SAMPLESPERPIXEL */
169 { 0x116, IFD_LONG, 1, 1 }, /* ROWSPERSTRIP */
170 { 0x117, IFD_LONG, 1, 1 }, /* STRIPBYTECOUNT */
171 { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_8bpp_data, res) },
172 { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_8bpp_data, res) },
173 { 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
174 { 0x140, IFD_SHORT, 256*3, FIELD_OFFSET(struct tiff_8bpp_data, palette_data) } /* COLORMAP */
175 },
176 0,
177 { 96, 1 },
178 { { 0 } },
179 { 0,1,2,3 }
180 };
181
182 static const struct tiff_resolution_test_data
183 {
184 struct IFD_rational resx;
185 struct IFD_rational resy;
186 LONG resolution_unit;
187 double expected_dpi_x;
188 double expected_dpi_y;
189 /* if != 0: values for different behavior of some Windows versions */
190 double broken_dpi_x;
191 double broken_dpi_y;
192 } tiff_resolution_test_data[] =
193 {
194 { { 100, 1 }, { 50, 1 }, 0, 100.0, 50.0, 0, 0 }, /* invalid resolution unit */
195 { { 50, 1 }, { 100, 1 }, 0, 50.0, 100.0, 0, 0 },
196
197 { { 100, 1 }, { 50, 1 }, 1, 100.0, 50.0, 0, 0 }, /* RESUNIT_NONE */
198 { { 50, 1 }, { 100, 1 }, 1, 50.0, 100.0, 0, 0 },
199
200 { { 49, 1 }, { 49, 1 }, 2, 49.0, 49.0, 0, 0 }, /* same resolution for both X and Y */
201 { { 33, 1 }, { 55, 1 }, 2, 33.0, 55.0, 0, 0 }, /* different resolutions for X and Y */
202 { { 50, 2 }, { 66, 3 }, 2, 25.0, 22.0, 0, 0 }, /* denominator != 1 */
203
204 { { 100, 1 }, { 200, 1 }, 3, 254.0, 508.0, 0, 0 }, /* unit = centimeters */
205
206 /* XP and Server 2003 do not discard both resolution values if only one of them is invalid */
207 { { 0, 1 }, { 29, 1 }, 2, 96.0, 96.0, 0, 29.0 }, /* resolution 0 */
208 { { 58, 1 }, { 29, 0 }, 2, 96.0, 96.0, 58.0, 0 }, /* denominator 0 (division by zero) */
209
210 /* XP and Server 2003 return 96 dots per centimeter (= 243.84 dpi) as fallback value */
211 { { 0, 1 }, { 100, 1 }, 3, 96.0, 96.0, 243.84, 254.0 }, /* resolution 0 and unit = centimeters */
212 { { 50, 1 }, { 72, 0 }, 3, 96.0, 96.0, 127.0, 243.84 } /* denominator 0 and unit = centimeters */
213 };
214
215 static struct tiff_resolution_image_data
216 {
217 USHORT byte_order;
218 USHORT version;
219 ULONG dir_offset;
220 USHORT number_of_entries;
221 struct IFD_entry entry[13];
222 ULONG next_IFD;
223 struct IFD_rational resx;
224 struct IFD_rational resy;
225 BYTE pixel_data[4];
226 } tiff_resolution_image_data =
227 {
228 #ifdef WORDS_BIGENDIAN
229 'M' | 'M' << 8,
230 #else
231 'I' | 'I' << 8,
232 #endif
233 42,
234 FIELD_OFFSET(struct tiff_resolution_image_data, number_of_entries),
235 13,
236 {
237 { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
238 { 0x100, IFD_LONG, 1, 1 }, /* IMAGEWIDTH */
239 { 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
240 { 0x102, IFD_SHORT, 1, 1 }, /* BITSPERSAMPLE */
241 { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
242 { 0x106, IFD_SHORT, 1, 1 }, /* PHOTOMETRIC */
243 { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_resolution_image_data, pixel_data) }, /* STRIPOFFSETS */
244 { 0x115, IFD_SHORT, 1, 1 }, /* SAMPLESPERPIXEL */
245 { 0x116, IFD_LONG, 1, 1 }, /* ROWSPERSTRIP */
246 { 0x117, IFD_LONG, 1, 1 }, /* STRIPBYTECOUNT */
247 { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_resolution_image_data, resx) }, /* XRESOLUTION */
248 { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_resolution_image_data, resy) }, /* YRESOLUTION */
249 { 0x128, IFD_SHORT, 1, 1 }, /* RESOLUTIONUNIT -- value will be filled with test data */
250 },
251 0,
252 { 72, 1 }, /* value will be filled with test data */
253 { 72, 1 }, /* value will be filled with test data */
254 { 0x11, 0x22, 0x33, 0 }
255 };
256 #include "poppack.h"
257
258 static IWICImagingFactory *factory;
259
260 static IStream *create_stream(const void *data, int data_size)
261 {
262 HRESULT hr;
263 IStream *stream;
264 HGLOBAL hdata;
265 void *locked_data;
266
267 hdata = GlobalAlloc(GMEM_MOVEABLE, data_size);
268 ok(hdata != 0, "GlobalAlloc failed\n");
269 if (!hdata) return NULL;
270
271 locked_data = GlobalLock(hdata);
272 memcpy(locked_data, data, data_size);
273 GlobalUnlock(hdata);
274
275 hr = CreateStreamOnHGlobal(hdata, TRUE, &stream);
276 ok(hr == S_OK, "CreateStreamOnHGlobal failed, hr=%x\n", hr);
277
278 return stream;
279 }
280
281 static HRESULT create_decoder(const void *image_data, UINT image_size, IWICBitmapDecoder **decoder)
282 {
283 HGLOBAL hmem;
284 BYTE *data;
285 HRESULT hr;
286 IStream *stream;
287 GUID format;
288 LONG refcount;
289
290 *decoder = NULL;
291
292 hmem = GlobalAlloc(0, image_size);
293 data = GlobalLock(hmem);
294 memcpy(data, image_data, image_size);
295 GlobalUnlock(hmem);
296
297 hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
298 ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
299
300 hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, decoder);
301 if (hr == S_OK)
302 {
303 hr = IWICBitmapDecoder_GetContainerFormat(*decoder, &format);
304 ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
305 ok(IsEqualGUID(&format, &GUID_ContainerFormatTiff),
306 "wrong container format %s\n", wine_dbgstr_guid(&format));
307
308 refcount = IStream_Release(stream);
309 ok(refcount > 0, "expected stream refcount > 0\n");
310 }
311
312 return hr;
313 }
314
315 static HRESULT get_pixelformat_info(const GUID *format, UINT *bpp, UINT *channels, BOOL *trasparency)
316 {
317 HRESULT hr;
318 IWICComponentInfo *info;
319 IWICPixelFormatInfo2 *formatinfo;
320
321 hr = IWICImagingFactory_CreateComponentInfo(factory, format, &info);
322 ok(hr == S_OK, "CreateComponentInfo(%s) error %#x\n", wine_dbgstr_guid(format), hr);
323 if (hr == S_OK)
324 {
325 hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo2, (void **)&formatinfo);
326 if (hr == S_OK)
327 {
328 hr = IWICPixelFormatInfo2_SupportsTransparency(formatinfo, trasparency);
329 ok(hr == S_OK, "SupportsTransparency error %#x\n", hr);
330 IWICPixelFormatInfo2_Release(formatinfo);
331 }
332 hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo, (void **)&formatinfo);
333 if (hr == S_OK)
334 {
335 hr = IWICPixelFormatInfo2_GetBitsPerPixel(formatinfo, bpp);
336 ok(hr == S_OK, "GetBitsPerPixel error %#x\n", hr);
337 hr = IWICPixelFormatInfo2_GetChannelCount(formatinfo, channels);
338 ok(hr == S_OK, "GetChannelCount error %#x\n", hr);
339 IWICPixelFormatInfo2_Release(formatinfo);
340 }
341 IWICComponentInfo_Release(info);
342 }
343 return hr;
344 }
345
346 static void dump_tiff(void *buf)
347 {
348 UINT count, i;
349 struct tiff_1bpp_data *tiff;
350 struct IFD_entry *tag;
351
352 tiff = buf;
353 count = *(short *)((char *)tiff + tiff->dir_offset);
354 tag = (struct IFD_entry *)((char *)tiff + tiff->dir_offset + sizeof(short));
355
356 for (i = 0; i < count; i++)
357 {
358 printf("tag %u: id %04x, type %04x, count %u, value %d",
359 i, tag[i].id, tag[i].type, tag[i].count, tag[i].value);
360 if (tag[i].id == 0x102 && tag[i].count > 2)
361 {
362 short *bps = (short *)((char *)tiff + tag[i].value);
363 printf(" (%d,%d,%d,%d)\n", bps[0], bps[1], bps[2], bps[3]);
364 }
365 else
366 printf("\n");
367 }
368 }
369
370 static void test_tiff_1bpp_palette(void)
371 {
372 HRESULT hr;
373 IWICBitmapDecoder *decoder;
374 IWICBitmapFrameDecode *frame;
375 IWICPalette *palette;
376 GUID format;
377
378 hr = create_decoder(&tiff_1bpp_data, sizeof(tiff_1bpp_data), &decoder);
379 ok(hr == S_OK, "Failed to load TIFF image data %#x\n", hr);
380 if (hr != S_OK) return;
381
382 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
383 ok(hr == S_OK, "GetFrame error %#x\n", hr);
384
385 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
386 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
387 ok(IsEqualGUID(&format, &GUID_WICPixelFormatBlackWhite),
388 "got wrong format %s\n", wine_dbgstr_guid(&format));
389
390 hr = IWICImagingFactory_CreatePalette(factory, &palette);
391 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
392 hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
393 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE,
394 "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %#x\n", hr);
395
396 IWICPalette_Release(palette);
397 IWICBitmapFrameDecode_Release(frame);
398 IWICBitmapDecoder_Release(decoder);
399 }
400
401 static void test_QueryCapability(void)
402 {
403 HRESULT hr;
404 IStream *stream;
405 IWICBitmapDecoder *decoder;
406 IWICBitmapFrameDecode *frame;
407 static const DWORD exp_caps = WICBitmapDecoderCapabilityCanDecodeAllImages |
408 WICBitmapDecoderCapabilityCanDecodeSomeImages |
409 WICBitmapDecoderCapabilityCanEnumerateMetadata;
410 static const DWORD exp_caps_xp = WICBitmapDecoderCapabilityCanDecodeAllImages |
411 WICBitmapDecoderCapabilityCanDecodeSomeImages;
412 DWORD capability;
413 LARGE_INTEGER pos;
414 ULARGE_INTEGER cur_pos;
415 UINT frame_count;
416
417 stream = create_stream(&tiff_1bpp_data, sizeof(tiff_1bpp_data));
418 if (!stream) return;
419
420 hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatTiff, NULL, &decoder);
421 ok(hr == S_OK, "CreateDecoder error %#x\n", hr);
422 if (FAILED(hr)) return;
423
424 frame_count = 0xdeadbeef;
425 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
426 ok(hr == S_OK || broken(hr == E_POINTER) /* XP */, "GetFrameCount error %#x\n", hr);
427 ok(frame_count == 0, "expected 0, got %u\n", frame_count);
428
429 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
430 ok(hr == WINCODEC_ERR_FRAMEMISSING || broken(hr == E_POINTER) /* XP */, "expected WINCODEC_ERR_FRAMEMISSING, got %#x\n", hr);
431
432 pos.QuadPart = 4;
433 hr = IStream_Seek(stream, pos, SEEK_SET, NULL);
434 ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
435
436 capability = 0xdeadbeef;
437 hr = IWICBitmapDecoder_QueryCapability(decoder, stream, &capability);
438 ok(hr == S_OK, "QueryCapability error %#x\n", hr);
439 ok(capability == exp_caps || capability == exp_caps_xp,
440 "expected %#x, got %#x\n", exp_caps, capability);
441
442 frame_count = 0xdeadbeef;
443 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
444 ok(hr == S_OK, "GetFrameCount error %#x\n", hr);
445 ok(frame_count == 1, "expected 1, got %u\n", frame_count);
446
447 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
448 ok(hr == S_OK, "GetFrame error %#x\n", hr);
449 IWICBitmapFrameDecode_Release(frame);
450
451 pos.QuadPart = 0;
452 hr = IStream_Seek(stream, pos, SEEK_CUR, &cur_pos);
453 ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
454 ok(cur_pos.QuadPart > 4 && cur_pos.QuadPart < sizeof(tiff_1bpp_data),
455 "current stream pos is at %x/%x\n", cur_pos.u.LowPart, cur_pos.u.HighPart);
456
457 hr = IWICBitmapDecoder_QueryCapability(decoder, stream, &capability);
458 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
459
460 hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnDemand);
461 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
462
463 IWICBitmapDecoder_Release(decoder);
464
465 hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);
466 todo_wine
467 ok(hr == WINCODEC_ERR_COMPONENTNOTFOUND, "expected WINCODEC_ERR_COMPONENTNOTFOUND, got %#x\n", hr);
468
469 if (SUCCEEDED(hr))
470 IWICBitmapDecoder_Release(decoder);
471
472 pos.QuadPart = 0;
473 hr = IStream_Seek(stream, pos, SEEK_SET, NULL);
474 ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
475
476 hr = IWICImagingFactory_CreateDecoderFromStream(factory, stream, NULL, 0, &decoder);
477 ok(hr == S_OK, "CreateDecoderFromStream error %#x\n", hr);
478
479 frame_count = 0xdeadbeef;
480 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
481 ok(hr == S_OK, "GetFrameCount error %#x\n", hr);
482 ok(frame_count == 1, "expected 1, got %u\n", frame_count);
483
484 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
485 ok(hr == S_OK, "GetFrame error %#x\n", hr);
486 IWICBitmapFrameDecode_Release(frame);
487
488 hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnDemand);
489 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
490
491 hr = IWICBitmapDecoder_QueryCapability(decoder, stream, &capability);
492 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, got %#x\n", hr);
493
494 IWICBitmapDecoder_Release(decoder);
495 IStream_Release(stream);
496 }
497
498 static void test_tiff_8bpp_alpha(void)
499 {
500 HRESULT hr;
501 IWICBitmapDecoder *decoder;
502 IWICBitmapFrameDecode *frame;
503 UINT frame_count, width, height, i;
504 double dpi_x, dpi_y;
505 IWICPalette *palette;
506 GUID format;
507 WICRect rc;
508 BYTE data[16];
509 static const BYTE expected_data[16] = { 0x11,0x11,0x11,0x22,0x33,0x33,0x33,0x44,
510 0x55,0x55,0x55,0x66,0x77,0x77,0x77,0x88 };
511
512 hr = create_decoder(&tiff_8bpp_alpha, sizeof(tiff_8bpp_alpha), &decoder);
513 ok(hr == S_OK, "Failed to load TIFF image data %#x\n", hr);
514 if (hr != S_OK) return;
515
516 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
517 ok(hr == S_OK, "GetFrameCount error %#x\n", hr);
518 ok(frame_count == 1, "expected 1, got %u\n", frame_count);
519
520 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
521 ok(hr == S_OK, "GetFrame error %#x\n", hr);
522
523 hr = IWICBitmapFrameDecode_GetSize(frame, &width, &height);
524 ok(hr == S_OK, "GetSize error %#x\n", hr);
525 ok(width == 2, "expected 2, got %u\n", width);
526 ok(height == 2, "expected 2, got %u\n", height);
527
528 hr = IWICBitmapFrameDecode_GetResolution(frame, &dpi_x, &dpi_y);
529 ok(hr == S_OK, "GetResolution error %#x\n", hr);
530 ok(dpi_x == 96.0, "expected 96.0, got %f\n", dpi_x);
531 ok(dpi_y == 96.0, "expected 96.0, got %f\n", dpi_y);
532
533 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
534 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
535 ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppPBGRA),
536 "got wrong format %s\n", wine_dbgstr_guid(&format));
537
538 hr = IWICImagingFactory_CreatePalette(factory, &palette);
539 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
540 hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
541 ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE,
542 "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %#x\n", hr);
543 IWICPalette_Release(palette);
544
545 rc.X = 0;
546 rc.Y = 0;
547 rc.Width = 2;
548 rc.Height = 2;
549 hr = IWICBitmapFrameDecode_CopyPixels(frame, &rc, 8, sizeof(data), data);
550 ok(hr == S_OK, "CopyPixels error %#x\n", hr);
551
552 for (i = 0; i < sizeof(data); i++)
553 ok(data[i] == expected_data[i], "%u: expected %02x, got %02x\n", i, expected_data[i], data[i]);
554
555 IWICBitmapFrameDecode_Release(frame);
556 IWICBitmapDecoder_Release(decoder);
557 }
558
559 static void generate_tiff_palette(void *buf, unsigned count)
560 {
561 unsigned short *r, *g, *b;
562 unsigned i;
563
564 r = buf;
565 g = r + count;
566 b = g + count;
567
568 r[0] = 0x11 * 257;
569 g[0] = 0x22 * 257;
570 b[0] = 0x33 * 257;
571 r[1] = 0x44 * 257;
572 g[1] = 0x55 * 257;
573 b[1] = 0x66 * 257;
574 r[2] = 0x77 * 257;
575 g[2] = 0x88 * 257;
576 b[2] = 0x99 * 257;
577 r[3] = 0xa1 * 257;
578 g[3] = 0xb5 * 257;
579 b[3] = 0xff * 257;
580
581 for (i = 4; i < count; i++)
582 {
583 r[i] = i * 257;
584 g[i] = (i | 0x40) * 257;
585 b[i] = (i | 0x80) * 257;
586 }
587 }
588
589 static void test_tiff_8bpp_palette(void)
590 {
591 char buf[sizeof(tiff_8bpp_data)];
592 HRESULT hr;
593 IWICBitmapDecoder *decoder;
594 IWICBitmapFrameDecode *frame;
595 IWICPalette *palette;
596 GUID format;
597 UINT count, ret;
598 WICColor color[256];
599
600 memcpy(buf, &tiff_8bpp_data, sizeof(tiff_8bpp_data));
601 generate_tiff_palette(buf + FIELD_OFFSET(struct tiff_8bpp_data, palette_data), 256);
602
603 hr = create_decoder(buf, sizeof(buf), &decoder);
604 ok(hr == S_OK, "Failed to load TIFF image data %#x\n", hr);
605 if (hr != S_OK) return;
606
607 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
608 ok(hr == S_OK, "GetFrame error %#x\n", hr);
609
610 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
611 ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
612 ok(IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed),
613 "expected GUID_WICPixelFormat8bppIndexed, got %s\n", wine_dbgstr_guid(&format));
614
615 hr = IWICImagingFactory_CreatePalette(factory, &palette);
616 ok(hr == S_OK, "CreatePalette error %#x\n", hr);
617 hr = IWICBitmapFrameDecode_CopyPalette(frame, palette);
618 ok(hr == S_OK, "CopyPalette error %#x\n", hr);
619
620 hr = IWICPalette_GetColorCount(palette, &count);
621 ok(hr == S_OK, "GetColorCount error %#x\n", hr);
622 ok(count == 256, "expected 256, got %u\n", count);
623
624 hr = IWICPalette_GetColors(palette, 256, color, &ret);
625 ok(hr == S_OK, "GetColors error %#x\n", hr);
626 ok(ret == count, "expected %u, got %u\n", count, ret);
627 ok(color[0] == 0xff112233, "got %#x\n", color[0]);
628 ok(color[1] == 0xff445566, "got %#x\n", color[1]);
629 ok(color[2] == 0xff778899, "got %#x\n", color[2]);
630 ok(color[3] == 0xffa1b5ff, "got %#x\n", color[3]);
631
632 IWICPalette_Release(palette);
633 IWICBitmapFrameDecode_Release(frame);
634 IWICBitmapDecoder_Release(decoder);
635 }
636
637 static void test_tiff_resolution(void)
638 {
639 HRESULT hr;
640 IWICBitmapDecoder *decoder;
641 IWICBitmapFrameDecode *frame;
642 double dpi_x, dpi_y;
643 int i;
644
645 for (i = 0; i < sizeof(tiff_resolution_test_data)/sizeof(tiff_resolution_test_data[0]); i++)
646 {
647 const struct tiff_resolution_test_data *test_data = &tiff_resolution_test_data[i];
648 tiff_resolution_image_data.resx = test_data->resx;
649 tiff_resolution_image_data.resy = test_data->resy;
650 tiff_resolution_image_data.entry[12].value = test_data->resolution_unit;
651
652 hr = create_decoder(&tiff_resolution_image_data, sizeof(tiff_resolution_image_data), &decoder);
653 ok(hr == S_OK, "Failed to load TIFF image data %#x\n", hr);
654 if (hr != S_OK) return;
655
656 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
657 ok(hr == S_OK, "%d: GetFrame error %#x\n", i, hr);
658
659 hr = IWICBitmapFrameDecode_GetResolution(frame, &dpi_x, &dpi_y);
660 ok(hr == S_OK, "%d: GetResolution error %#x\n", i, hr);
661
662 if (test_data->broken_dpi_x != 0)
663 {
664 ok(fabs(dpi_x - test_data->expected_dpi_x) < 0.01 || broken(fabs(dpi_x - test_data->broken_dpi_x) < 0.01),
665 "%d: x: expected %f or %f, got %f\n", i, test_data->expected_dpi_x, test_data->broken_dpi_x, dpi_x);
666 }
667 else
668 {
669 ok(fabs(dpi_x - test_data->expected_dpi_x) < 0.01,
670 "%d: x: expected %f, got %f\n", i, test_data->expected_dpi_x, dpi_x);
671 }
672
673 if (test_data->broken_dpi_y != 0)
674 {
675 ok(fabs(dpi_y - test_data->expected_dpi_y) < 0.01 || broken(fabs(dpi_y - test_data->broken_dpi_y) < 0.01),
676 "%d: y: expected %f or %f, got %f\n", i, test_data->expected_dpi_y, test_data->broken_dpi_y, dpi_y);
677 }
678 else
679 {
680 ok(fabs(dpi_y - test_data->expected_dpi_y) < 0.01,
681 "%d: y: expected %f, got %f\n", i, test_data->expected_dpi_y, dpi_y);
682 }
683
684 IWICBitmapFrameDecode_Release(frame);
685 IWICBitmapDecoder_Release(decoder);
686 }
687 }
688
689 #include "pshpack2.h"
690 static const struct tiff_1x1_data
691 {
692 USHORT byte_order;
693 USHORT version;
694 ULONG dir_offset;
695 USHORT number_of_entries;
696 struct IFD_entry entry[12];
697 ULONG next_IFD;
698 struct IFD_rational res;
699 short palette_data[3][256];
700 short bps_data[4];
701 BYTE pixel_data[32];
702 } tiff_1x1_data =
703 {
704 #ifdef WORDS_BIGENDIAN
705 'M' | 'M' << 8,
706 #else
707 'I' | 'I' << 8,
708 #endif
709 42,
710 FIELD_OFFSET(struct tiff_1x1_data, number_of_entries),
711 12,
712 {
713 { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
714 { 0x100, IFD_LONG, 1, 1 }, /* IMAGEWIDTH */
715 { 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
716 { 0x102, IFD_SHORT, 3, FIELD_OFFSET(struct tiff_1x1_data, bps_data) }, /* BITSPERSAMPLE */
717 { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
718 { 0x106, IFD_SHORT, 1, 2 }, /* PHOTOMETRIC */
719 { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_1x1_data, pixel_data) }, /* STRIPOFFSETS */
720 { 0x115, IFD_SHORT, 1, 3 }, /* SAMPLESPERPIXEL */
721 { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1x1_data, res) },
722 { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1x1_data, res) },
723 { 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
724 { 0x140, IFD_SHORT, 256*3, FIELD_OFFSET(struct tiff_1x1_data, palette_data) } /* COLORMAP */
725 },
726 0,
727 { 96, 1 },
728 { { 0 } },
729 { 8,8,8,0 },
730 { 1,0,2,3,4,5,6,7,8,9,0,1,2,3,4,5 }
731 };
732 #include "poppack.h"
733
734 static UINT width_bytes(UINT width, UINT bpp)
735 {
736 return (width * bpp + 7) / 8;
737 }
738
739 static void test_color_formats(void)
740 {
741 struct bitmap_data
742 {
743 UINT bpp;
744 UINT width;
745 UINT height;
746 const WICPixelFormatGUID *format;
747 const BYTE *bits;
748 };
749 static const BYTE bits_1bpsBGR[] = { 0,255,0,255,0,255,255,255,0,0,0,255,255,0,0,0,255,255,255,255,255,0,0,0,0,255,0,255,0,255 };
750 static const struct bitmap_data data_1bpsBGR =
751 {
752 24, 10, 2, &GUID_WICPixelFormat24bppBGR, bits_1bpsBGR
753 };
754 static const BYTE bits_4bpsBGR[] = { 204,85,85,136,187,51,0,85,85,85,0,68,0,102,0,136,0,119,0,153,0 };
755 static const struct bitmap_data data_4bpsBGR =
756 {
757 24, 5, 2, &GUID_WICPixelFormat24bppBGR, bits_4bpsBGR
758 };
759 static const BYTE bits_8bpsBGR[] = { 2,0,1,5,4,3,8,7,6 };
760 static const struct bitmap_data data_8bpsBGR =
761 {
762 24, 3, 1, &GUID_WICPixelFormat24bppBGR, bits_8bpsBGR
763 };
764 static const BYTE bits_48bppRGB[] = { 1,0,2,3,4,5,6,7,8,9,0,1 };
765 static const struct bitmap_data data_48bppRGB =
766 {
767 48, 2, 1, &GUID_WICPixelFormat48bppRGB, bits_48bppRGB
768 };
769 static const BYTE bits_1bpsBGRA[] = { 0,255,0,255,0,255,0,255,0,255,255,0,255,0,0,255,255,0,255,255,0,0,255,0,0,255,0,255,0,255,0,255,0,0,0,0,0,255,0,0 };
770 static const struct bitmap_data data_1bpsBGRA =
771 {
772 32, 5, 2, &GUID_WICPixelFormat32bppBGRA, bits_1bpsBGRA
773 };
774 static const BYTE bits_4bpsBGRA[] = { 204,85,85,51,85,136,187,85,0,68,0,85,0,102,0,119,0,136,0,153,0,0,0,17,0,34,0,51 };
775 static const struct bitmap_data data_4bpsBGRA =
776 {
777 32, 5, 2, &GUID_WICPixelFormat32bppBGRA, bits_4bpsBGRA
778 };
779 static const BYTE bits_8bpsBGRA[] = { 2,0,1,3,6,5,4,7,0,9,8,1,4,3,2,5 };
780 static const struct bitmap_data data_8bpsBGRA =
781 {
782 32, 4, 1, &GUID_WICPixelFormat32bppBGRA, bits_8bpsBGRA
783 };
784 static const BYTE bits_64bppRGBA[] = { 1,0,2,3,4,5,6,7,8,9,0,1,2,3,4,5 };
785 static const struct bitmap_data data_64bppRGBA =
786 {
787 64, 2, 1, &GUID_WICPixelFormat64bppRGBA, bits_64bppRGBA
788 };
789 static const BYTE bits_BlackWhite[] = { 85,195,184,85 };
790 static const struct bitmap_data data_BlackWhite =
791 {
792 1, 30, 1, &GUID_WICPixelFormatBlackWhite, bits_BlackWhite
793 };
794 static const BYTE bits_BlackWhite_xp[] = { 85,195,184,84 };
795 static const struct bitmap_data data_BlackWhite_xp =
796 {
797 1, 30, 1, &GUID_WICPixelFormatBlackWhite, bits_BlackWhite_xp
798 };
799 static const BYTE bits_4bppGray[] = { 85,195,184,85 };
800 static const struct bitmap_data data_4bppGray =
801 {
802 4, 7, 1, &GUID_WICPixelFormat4bppGray, bits_4bppGray
803 };
804 static const BYTE bits_4bppGray_xp[] = { 85,195,184,80 };
805 static const struct bitmap_data data_4bppGray_xp =
806 {
807 4, 7, 1, &GUID_WICPixelFormat4bppGray, bits_4bppGray_xp
808 };
809 static const BYTE bits_8bppGray[] = { 1,0,2,3,4,5,6,7,8,9 };
810 static const struct bitmap_data data_8bppGray =
811 {
812 8, 10, 1, &GUID_WICPixelFormat8bppGray, bits_8bppGray
813 };
814 static const BYTE bits_16bppGray[] = { 1,0,2,3,4,5 };
815 static const struct bitmap_data data_16bppGray =
816 {
817 16, 3, 1, &GUID_WICPixelFormat16bppGray, bits_16bppGray
818 };
819 static const BYTE bits_32bppGrayFloat[] = { 1,0,2,3,4,5,6,7,8,9,0,1 };
820 static const struct bitmap_data data_32bppGrayFloat =
821 {
822 32, 3, 1, &GUID_WICPixelFormat32bppGrayFloat, bits_32bppGrayFloat
823 };
824 #if 0 /* FIXME */
825 static const BYTE bits_96bpp3Channels[] = { 0 };
826 static const struct bitmap_data data_96bpp3Channels =
827 {
828 64, 1, 1, &GUID_WICPixelFormat96bpp3Channels, bits_96bpp3Channels
829 };
830 #endif
831 static const BYTE bits_128bppRGBAFloat[] = { 1,0,2,3,4,5,6,7,8,9,0,1,2,3,4,5 };
832 static const struct bitmap_data data_128bppRGBAFloat =
833 {
834 128, 1, 1, &GUID_WICPixelFormat128bppRGBAFloat, bits_128bppRGBAFloat
835 };
836 static const BYTE bits_1bppIndexed[] = { 85,195,184,85 };
837 static const struct bitmap_data data_1bppIndexed =
838 {
839 1, 32, 1, &GUID_WICPixelFormat1bppIndexed, bits_1bppIndexed
840 };
841 static const BYTE bits_4bppIndexed[] = { 85,195,184,85 };
842 static const struct bitmap_data data_4bppIndexed =
843 {
844 4, 7, 1, &GUID_WICPixelFormat4bppIndexed, bits_4bppIndexed
845 };
846 static const BYTE bits_4bppIndexed_xp[] = { 85,195,184,80 };
847 static const struct bitmap_data data_4bppIndexed_xp =
848 {
849 4, 7, 1, &GUID_WICPixelFormat4bppIndexed, bits_4bppIndexed_xp
850 };
851 static const BYTE bits_8bppIndexed[] = { 1,0,2,3,4,5,6,7,8,9 };
852 static const struct bitmap_data data_8bppIndexed =
853 {
854 8, 3, 1, &GUID_WICPixelFormat8bppIndexed, bits_8bppIndexed
855 };
856 static const BYTE bits_32bppCMYK[] = { 1,0,2,3,4,5,6,7,8,9,0,1 };
857 static const struct bitmap_data data_32bppCMYK =
858 {
859 32, 3, 1, &GUID_WICPixelFormat32bppCMYK, bits_32bppCMYK
860 };
861 static const BYTE bits_64bppCMYK[] = { 1,0,2,3,4,5,6,7,8,9,0,1,2,3,4,5 };
862 static const struct bitmap_data data_64bppCMYK =
863 {
864 64, 2, 1, &GUID_WICPixelFormat64bppCMYK, bits_64bppCMYK
865 };
866 static const struct
867 {
868 int photometric; /* PhotometricInterpretation */
869 int samples; /* SamplesPerPixel */
870 int bps; /* BitsPerSample */
871 const struct bitmap_data *data;
872 const struct bitmap_data *alt_data;
873 } td[] =
874 {
875 /* 2 - RGB */
876 { 2, 3, 1, &data_1bpsBGR },
877 { 2, 3, 4, &data_4bpsBGR },
878 { 2, 3, 8, &data_8bpsBGR },
879 { 2, 3, 16, &data_48bppRGB },
880 { 2, 3, 24, NULL },
881 #if 0 /* FIXME */
882 { 2, 3, 32, &data_96bpp3Channels },
883 #endif
884 { 2, 4, 1, &data_1bpsBGRA },
885 { 2, 4, 4, &data_4bpsBGRA },
886 { 2, 4, 8, &data_8bpsBGRA },
887 { 2, 4, 16, &data_64bppRGBA },
888 { 2, 4, 24, NULL },
889 { 2, 4, 32, &data_128bppRGBAFloat },
890 /* 1 - BlackIsZero (Bilevel) */
891 { 1, 1, 1, &data_BlackWhite, &data_BlackWhite_xp },
892 { 1, 1, 4, &data_4bppGray, &data_4bppGray_xp },
893 { 1, 1, 8, &data_8bppGray },
894 { 1, 1, 16, &data_16bppGray },
895 { 1, 1, 24, NULL },
896 { 1, 1, 32, &data_32bppGrayFloat },
897 /* 3 - Palette Color */
898 { 3, 1, 1, &data_1bppIndexed },
899 { 3, 1, 4, &data_4bppIndexed, &data_4bppIndexed_xp },
900 { 3, 1, 8, &data_8bppIndexed },
901 #if 0 /* FIXME: for some reason libtiff replaces photometric 3 by 1 for bps > 8 */
902 { 3, 1, 16, &data_8bppIndexed },
903 { 3, 1, 24, &data_8bppIndexed },
904 { 3, 1, 32, &data_8bppIndexed },
905 #endif
906 /* 5 - Separated */
907 { 5, 4, 1, NULL },
908 { 5, 4, 4, NULL },
909 { 5, 4, 8, &data_32bppCMYK },
910 { 5, 4, 16, &data_64bppCMYK },
911 { 5, 4, 24, NULL },
912 { 5, 4, 32, NULL },
913 };
914 BYTE buf[sizeof(tiff_1x1_data)];
915 BYTE pixels[256];
916 HRESULT hr;
917 IWICBitmapDecoder *decoder;
918 IWICBitmapFrameDecode *frame;
919 GUID format;
920 UINT count, i, bpp, channels, ret;
921 BOOL trasparency;
922 struct IFD_entry *tag, *tag_photo = NULL, *tag_bps = NULL, *tag_samples = NULL, *tag_colormap = NULL;
923 struct IFD_entry *tag_width = NULL, *tag_height = NULL;
924 short *bps;
925
926 memcpy(buf, &tiff_1x1_data, sizeof(tiff_1x1_data));
927 generate_tiff_palette(buf + FIELD_OFFSET(struct tiff_1x1_data, palette_data), 256);
928
929 count = *(short *)(buf + tiff_1x1_data.dir_offset);
930 tag = (struct IFD_entry *)(buf + tiff_1x1_data.dir_offset + sizeof(short));
931
932 /* verify the TIFF structure */
933 for (i = 0; i < count; i++)
934 {
935 if (tag[i].id == 0x100) /* ImageWidth */
936 tag_width = &tag[i];
937 else if (tag[i].id == 0x101) /* ImageLength */
938 tag_height = &tag[i];
939 else if (tag[i].id == 0x102) /* BitsPerSample */
940 tag_bps = &tag[i];
941 else if (tag[i].id == 0x106) /* PhotometricInterpretation */
942 tag_photo = &tag[i];
943 else if (tag[i].id == 0x115) /* SamplesPerPixel */
944 tag_samples = &tag[i];
945 else if (tag[i].id == 0x140) /* ColorMap */
946 tag_colormap = &tag[i];
947 }
948
949 ok(tag_bps && tag_photo && tag_samples && tag_colormap, "tag 0x102,0x106,0x115 or 0x140 is missing\n");
950 if (!tag_bps || !tag_photo || !tag_samples || !tag_colormap) return;
951
952 ok(tag_bps->type == IFD_SHORT, "tag 0x102 should have type IFD_SHORT\n");
953 bps = (short *)(buf + tag_bps->value);
954 ok(bps[0] == 8 && bps[1] == 8 && bps[2] == 8 && bps[3] == 0,
955 "expected bps 8,8,8,0 got %d,%d,%d,%d\n", bps[0], bps[1], bps[2], bps[3]);
956
957 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
958 {
959 if (td[i].data)
960 {
961 bpp = td[i].samples * td[i].bps;
962 if (winetest_debug > 1)
963 trace("samples %u, bps %u, bpp %u, width %u => width_bytes %u\n", td[i].samples, td[i].bps, bpp,
964 td[i].data->width, width_bytes(td[i].data->width, bpp));
965 tag_width->value = td[i].data->width;
966 tag_height->value = td[i].data->height;
967 }
968 else
969 {
970 tag_width->value = 1;
971 tag_height->value = 1;
972 }
973
974 tag_colormap->count = (1 << td[i].bps) * 3;
975
976 if (td[i].bps < 8)
977 {
978 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data)] = 0x55;
979 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data) + 1] = 0xc3;
980 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data) + 2] = 0xb8;
981 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data) + 3] = 0x55;
982 }
983 else
984 {
985 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data)] = 1;
986 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data) + 1] = 0;
987 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data) + 2] = 2;
988 buf[FIELD_OFFSET(struct tiff_1x1_data, pixel_data) + 3] = 3;
989 }
990
991 tag_photo->value = td[i].photometric;
992 tag_bps->count = td[i].samples;
993 tag_samples->value = td[i].samples;
994
995 if (td[i].samples == 1)
996 tag_bps->value = td[i].bps;
997 else if (td[i].samples == 2)
998 tag_bps->value = MAKELONG(td[i].bps, td[i].bps);
999 else if (td[i].samples == 3)
1000 {
1001 tag_bps->value = (BYTE *)bps - buf;
1002 bps[0] = bps[1] = bps[2] = td[i].bps;
1003 }
1004 else if (td[i].samples == 4)
1005 {
1006 tag_bps->value = (BYTE *)bps - buf;
1007 bps[0] = bps[1] = bps[2] = bps[3] = td[i].bps;
1008 }
1009 else
1010 {
1011 ok(0, "%u: unsupported samples count %d\n", i, td[i].samples);
1012 continue;
1013 }
1014
1015 hr = create_decoder(buf, sizeof(buf), &decoder);
1016 if (!td[i].data)
1017 {
1018 ok(hr == WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT || hr == WINCODEC_ERR_COMPONENTNOTFOUND /* win8+ */ || WINCODEC_ERR_BADIMAGE /* XP */,
1019 "%u: (%d,%d,%d) wrong error %#x\n", i, td[i].photometric, td[i].samples, td[i].bps, hr);
1020 if (hr == S_OK)
1021 {
1022 IWICBitmapDecoder_Release(decoder);
1023 dump_tiff(buf);
1024 }
1025 continue;
1026 }
1027 else
1028 ok(hr == S_OK || broken(hr == WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT || hr == WINCODEC_ERR_BADIMAGE) /* XP */,
1029 "%u: failed to load TIFF image data (%d,%d,%d) %#x\n",
1030 i, td[i].photometric, td[i].samples, td[i].bps, hr);
1031 if (hr != S_OK) continue;
1032
1033 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1034 ok(hr == S_OK, "%u: GetFrame error %#x\n", i, hr);
1035
1036 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
1037 ok(hr == S_OK, "%u: GetPixelFormat error %#x\n", i, hr);
1038 ok(IsEqualGUID(&format, td[i].data->format),
1039 "%u (%d,%d,%d): expected %s, got %s\n",
1040 i, td[i].photometric, td[i].samples, td[i].bps,
1041 wine_dbgstr_guid(td[i].data->format), wine_dbgstr_guid(&format));
1042
1043 trasparency = (td[i].photometric == 2 && td[i].samples == 4); /* for XP */
1044 hr = get_pixelformat_info(&format, &bpp, &channels, &trasparency);
1045 ok(hr == S_OK, "%u: get_pixelformat_bpp error %#x\n", i, hr);
1046 ok(bpp == td[i].data->bpp, "%u: expected %u, got %u\n", i, td[i].data->bpp, bpp);
1047 ok(channels == td[i].samples, "%u: expected %u, got %u\n", i, td[i].samples, channels);
1048 ok(trasparency == (td[i].photometric == 2 && td[i].samples == 4), "%u: got %u\n", i, trasparency);
1049
1050 memset(pixels, 0, sizeof(pixels));
1051 hr = IWICBitmapFrameDecode_CopyPixels(frame, NULL, width_bytes(td[i].data->width, bpp), sizeof(pixels), pixels);
1052 ok(hr == S_OK, "%u: CopyPixels error %#x\n", i, hr);
1053 ret = memcmp(pixels, td[i].data->bits, width_bytes(td[i].data->width, bpp));
1054 if (ret && td[i].alt_data)
1055 ret = memcmp(pixels, td[i].alt_data->bits, width_bytes(td[i].data->width, bpp));
1056 ok(ret == 0, "%u: (%d,%d,%d) wrong pixel data\n", i, td[i].photometric, td[i].samples, td[i].bps);
1057 if (ret)
1058 {
1059 UINT j, n = width_bytes(td[i].data->width, bpp);
1060 for (j = 0; j < n; j++)
1061 printf("%u%s", pixels[j], (j + 1) < n ? "," : "\n");
1062 }
1063
1064 IWICBitmapFrameDecode_Release(frame);
1065 IWICBitmapDecoder_Release(decoder);
1066 }
1067 }
1068
1069 START_TEST(tiffformat)
1070 {
1071 HRESULT hr;
1072
1073 CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1074
1075 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1076 &IID_IWICImagingFactory, (void **)&factory);
1077 ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
1078 if (FAILED(hr)) return;
1079
1080 test_color_formats();
1081 test_tiff_1bpp_palette();
1082 test_tiff_8bpp_palette();
1083 test_QueryCapability();
1084 test_tiff_8bpp_alpha();
1085 test_tiff_resolution();
1086
1087 IWICImagingFactory_Release(factory);
1088 CoUninitialize();
1089 }