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 } 1090