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