dlls/windowscodecs/tests/metadata.c

   1 /*
   2  * Copyright 2011 Vincent Povirk for CodeWeavers
   3  * Copyright 2012 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdarg.h>
  22 #include <math.h>
  23 #include <assert.h>
  24
  25 #define COBJMACROS
  26
  27 #include "windef.h"
  28 #include "objbase.h"
  29 #include "wincodec.h"
  30 #include "wincodecsdk.h"
  31 #include "wine/test.h"
  32
  33 #define expect_blob(propvar, data, length) do { \
  34     ok((propvar).vt == VT_BLOB, "unexpected vt: %i\n", (propvar).vt); \
  35     if ((propvar).vt == VT_BLOB) { \
  36         ok(U(propvar).blob.cbSize == (length), "expected size %u, got %u\n", (ULONG)(length), U(propvar).blob.cbSize); \
  37         if (U(propvar).blob.cbSize == (length)) { \
  38             ok(!memcmp(U(propvar).blob.pBlobData, (data), (length)), "unexpected data\n"); \
  39         } \
  40     } \
  41 } while (0)
  42
  43 #define IFD_BYTE 1
  44 #define IFD_ASCII 2
  45 #define IFD_SHORT 3
  46 #define IFD_LONG 4
  47 #define IFD_RATIONAL 5
  48 #define IFD_SBYTE 6
  49 #define IFD_UNDEFINED 7
  50 #define IFD_SSHORT 8
  51 #define IFD_SLONG 9
  52 #define IFD_SRATIONAL 10
  53 #define IFD_FLOAT 11
  54 #define IFD_DOUBLE 12
  55 #define IFD_IFD 13
  56
  57 #include "pshpack2.h"
  58 struct IFD_entry
  59 {
  60     SHORT id;
  61     SHORT type;
  62     ULONG count;
  63     LONG  value;
  64 };
  65
  66 struct IFD_rational
  67 {
  68     LONG numerator;
  69     LONG denominator;
  70 };
  71
  72 static const struct ifd_data
  73 {
  74     USHORT number_of_entries;
  75     struct IFD_entry entry[40];
  76     ULONG next_IFD;
  77     struct IFD_rational xres;
  78     DOUBLE double_val;
  79     struct IFD_rational srational_val;
  80     char string[14];
  81     SHORT short_val[4];
  82     LONG long_val[2];
  83     FLOAT float_val[2];
  84     struct IFD_rational rational[3];
  85 } IFD_data =
  86 {
  87     28,
  88     {
  89         { 0xfe,  IFD_SHORT, 1, 1 }, /* NEWSUBFILETYPE */
  90         { 0x100, IFD_LONG, 1, 222 }, /* IMAGEWIDTH */
  91         { 0x101, IFD_LONG, 1, 333 }, /* IMAGELENGTH */
  92         { 0x102, IFD_SHORT, 1, 24 }, /* BITSPERSAMPLE */
  93         { 0x103, IFD_LONG, 1, 32773 }, /* COMPRESSION: packbits */
  94         { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct ifd_data, xres) },
  95         { 0xf001, IFD_BYTE, 1, 0x11223344 },
  96         { 0xf002, IFD_BYTE, 4, 0x11223344 },
  97         { 0xf003, IFD_SBYTE, 1, 0x11223344 },
  98         { 0xf004, IFD_SSHORT, 1, 0x11223344 },
  99         { 0xf005, IFD_SSHORT, 2, 0x11223344 },
 100         { 0xf006, IFD_SLONG, 1, 0x11223344 },
 101         { 0xf007, IFD_FLOAT, 1, 0x11223344 },
 102         { 0xf008, IFD_DOUBLE, 1, FIELD_OFFSET(struct ifd_data, double_val) },
 103         { 0xf009, IFD_SRATIONAL, 1, FIELD_OFFSET(struct ifd_data, srational_val) },
 104         { 0xf00a, IFD_BYTE, 13, FIELD_OFFSET(struct ifd_data, string) },
 105         { 0xf00b, IFD_SSHORT, 4, FIELD_OFFSET(struct ifd_data, short_val) },
 106         { 0xf00c, IFD_SLONG, 2, FIELD_OFFSET(struct ifd_data, long_val) },
 107         { 0xf00d, IFD_FLOAT, 2, FIELD_OFFSET(struct ifd_data, float_val) },
 108         { 0xf00e, IFD_ASCII, 13, FIELD_OFFSET(struct ifd_data, string) },
 109         { 0xf00f, IFD_ASCII, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
 110         { 0xf010, IFD_UNDEFINED, 13, FIELD_OFFSET(struct ifd_data, string) },
 111         { 0xf011, IFD_UNDEFINED, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
 112         { 0xf012, IFD_BYTE, 0, 0x11223344 },
 113         { 0xf013, IFD_SHORT, 0, 0x11223344 },
 114         { 0xf014, IFD_LONG, 0, 0x11223344 },
 115         { 0xf015, IFD_FLOAT, 0, 0x11223344 },
 116         { 0xf016, IFD_SRATIONAL, 3, FIELD_OFFSET(struct ifd_data, rational) },
 117     },
 118     0,
 119     { 900, 3 },
 120     1234567890.0987654321,
 121     { 0x1a2b3c4d, 0x5a6b7c8d },
 122     "Hello World!",
 123     { 0x0101, 0x0202, 0x0303, 0x0404 },
 124     { 0x11223344, 0x55667788 },
 125     { (FLOAT)1234.5678, (FLOAT)8765.4321 },
 126     { { 0x01020304, 0x05060708 }, { 0x10203040, 0x50607080 }, { 0x11223344, 0x55667788 } },
 127 };
 128 #include "poppack.h"
 129
 130 static const char metadata_unknown[] = "lalala";
 131
 132 static const char metadata_tEXt[] = {
 133     0,0,0,14, /* chunk length */
 134     't','E','X','t', /* chunk type */
 135     'w','i','n','e','t','e','s','t',0, /* keyword */
 136     'v','a','l','u','e', /* text */
 137     0x3f,0x64,0x19,0xf3 /* chunk CRC */
 138 };
 139
 140 static const char pngimage[285] = {
 141 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
 142 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
 143 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
 144 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
 145 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
 146 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
 147 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
 148 };
 149
 150 /* 1x1 pixel gif */
 151 static const char gifimage[35] = {
 152 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
 153 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
 154 0x01,0x00,0x3b
 155 };
 156
 157 /* 1x1 pixel gif, 2 frames; first frame is white, second is black */
 158 static const char gifanimation[72] = {
 159 0x47,0x49,0x46,0x38,0x39,0x61,0x01,0x00,0x01,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
 160 0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x21,0xf9,0x04,0x00,0x0a,0x00,0xff,
 161 0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x4c,0x01,0x00,
 162 0x21,0xf9,0x04,0x01,0x0a,0x00,0x01,0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,
 163 0x00,0x00,0x02,0x02,0x44,0x01,0x00,0x3b
 164 };
 165
 166 static const char *debugstr_guid(REFIID riid)
 167 {
 168     static char buf[50];
 169
 170     if(!riid)
 171         return "(null)";
 172
 173     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 174             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 175             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 176             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 177
 178     return buf;
 179 }
 180
 181 static IStream *create_stream(const char *data, int data_size)
 182 {
 183     HRESULT hr;
 184     IStream *stream;
 185     HGLOBAL hdata;
 186     void *locked_data;
 187
 188     hdata = GlobalAlloc(GMEM_MOVEABLE, data_size);
 189     ok(hdata != 0, "GlobalAlloc failed\n");
 190     if (!hdata) return NULL;
 191
 192     locked_data = GlobalLock(hdata);
 193     memcpy(locked_data, data, data_size);
 194     GlobalUnlock(hdata);
 195
 196     hr = CreateStreamOnHGlobal(hdata, TRUE, &stream);
 197     ok(hr == S_OK, "CreateStreamOnHGlobal failed, hr=%x\n", hr);
 198
 199     return stream;
 200 }
 201
 202 static void load_stream(IUnknown *reader, const char *data, int data_size, DWORD persist_options)
 203 {
 204     HRESULT hr;
 205     IWICPersistStream *persist;
 206     IStream *stream;
 207     LARGE_INTEGER pos;
 208     ULARGE_INTEGER cur_pos;
 209
 210     stream = create_stream(data, data_size);
 211     if (!stream)
 212         return;
 213
 214     hr = IUnknown_QueryInterface(reader, &IID_IWICPersistStream, (void**)&persist);
 215     ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
 216
 217     if (SUCCEEDED(hr))
 218     {
 219         hr = IWICPersistStream_LoadEx(persist, stream, NULL, persist_options);
 220         ok(hr == S_OK, "LoadEx failed, hr=%x\n", hr);
 221
 222         IWICPersistStream_Release(persist);
 223     }
 224
 225     pos.QuadPart = 0;
 226     hr = IStream_Seek(stream, pos, SEEK_CUR, &cur_pos);
 227     ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
 228     /* IFD metadata reader doesn't rewind the stream to the start */
 229     ok(cur_pos.QuadPart == 0 || cur_pos.QuadPart <= data_size,
 230        "current stream pos is at %x/%x, data size %x\n", cur_pos.u.LowPart, cur_pos.u.HighPart, data_size);
 231
 232     IStream_Release(stream);
 233 }
 234
 235 static void test_metadata_unknown(void)
 236 {
 237     HRESULT hr;
 238     IWICMetadataReader *reader;
 239     IWICEnumMetadataItem *enumerator;
 240     IWICMetadataBlockReader *blockreader;
 241     PROPVARIANT schema, id, value;
 242     ULONG items_returned;
 243
 244     hr = CoCreateInstance(&CLSID_WICUnknownMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 245         &IID_IWICMetadataReader, (void**)&reader);
 246     ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 247     if (FAILED(hr)) return;
 248
 249     load_stream((IUnknown*)reader, metadata_unknown, sizeof(metadata_unknown), WICPersistOptionsDefault);
 250
 251     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
 252     ok(hr == S_OK, "GetEnumerator failed, hr=%x\n", hr);
 253
 254     if (SUCCEEDED(hr))
 255     {
 256         PropVariantInit(&schema);
 257         PropVariantInit(&id);
 258         PropVariantInit(&value);
 259
 260         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 261         ok(hr == S_OK, "Next failed, hr=%x\n", hr);
 262         ok(items_returned == 1, "unexpected item count %i\n", items_returned);
 263
 264         if (hr == S_OK && items_returned == 1)
 265         {
 266             ok(schema.vt == VT_EMPTY, "unexpected vt: %i\n", schema.vt);
 267             ok(id.vt == VT_EMPTY, "unexpected vt: %i\n", id.vt);
 268             expect_blob(value, metadata_unknown, sizeof(metadata_unknown));
 269
 270             PropVariantClear(&schema);
 271             PropVariantClear(&id);
 272             PropVariantClear(&value);
 273         }
 274
 275         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 276         ok(hr == S_FALSE, "Next failed, hr=%x\n", hr);
 277         ok(items_returned == 0, "unexpected item count %i\n", items_returned);
 278
 279         IWICEnumMetadataItem_Release(enumerator);
 280     }
 281
 282     hr = IWICMetadataReader_QueryInterface(reader, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 283     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 284
 285     if (SUCCEEDED(hr))
 286         IWICMetadataBlockReader_Release(blockreader);
 287
 288     IWICMetadataReader_Release(reader);
 289 }
 290
 291 static void test_metadata_tEXt(void)
 292 {
 293     HRESULT hr;
 294     IWICMetadataReader *reader;
 295     IWICEnumMetadataItem *enumerator;
 296     PROPVARIANT schema, id, value;
 297     ULONG items_returned, count;
 298     GUID format;
 299
 300     PropVariantInit(&schema);
 301     PropVariantInit(&id);
 302     PropVariantInit(&value);
 303
 304     hr = CoCreateInstance(&CLSID_WICPngTextMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 305         &IID_IWICMetadataReader, (void**)&reader);
 306     todo_wine ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 307     if (FAILED(hr)) return;
 308
 309     hr = IWICMetadataReader_GetCount(reader, NULL);
 310     ok(hr == E_INVALIDARG, "GetCount failed, hr=%x\n", hr);
 311
 312     hr = IWICMetadataReader_GetCount(reader, &count);
 313     ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 314     ok(count == 0, "unexpected count %i\n", count);
 315
 316     load_stream((IUnknown*)reader, metadata_tEXt, sizeof(metadata_tEXt), WICPersistOptionsDefault);
 317
 318     hr = IWICMetadataReader_GetCount(reader, &count);
 319     ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 320     ok(count == 1, "unexpected count %i\n", count);
 321
 322     hr = IWICMetadataReader_GetEnumerator(reader, NULL);
 323     ok(hr == E_INVALIDARG, "GetEnumerator failed, hr=%x\n", hr);
 324
 325     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
 326     ok(hr == S_OK, "GetEnumerator failed, hr=%x\n", hr);
 327
 328     if (SUCCEEDED(hr))
 329     {
 330         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 331         ok(hr == S_OK, "Next failed, hr=%x\n", hr);
 332         ok(items_returned == 1, "unexpected item count %i\n", items_returned);
 333
 334         if (hr == S_OK && items_returned == 1)
 335         {
 336             ok(schema.vt == VT_EMPTY, "unexpected vt: %i\n", schema.vt);
 337             ok(id.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 338             ok(!strcmp(U(id).pszVal, "winetest"), "unexpected id: %s\n", U(id).pszVal);
 339             ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", value.vt);
 340             ok(!strcmp(U(value).pszVal, "value"), "unexpected value: %s\n", U(value).pszVal);
 341
 342             PropVariantClear(&schema);
 343             PropVariantClear(&id);
 344             PropVariantClear(&value);
 345         }
 346
 347         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 348         ok(hr == S_FALSE, "Next failed, hr=%x\n", hr);
 349         ok(items_returned == 0, "unexpected item count %i\n", items_returned);
 350
 351         IWICEnumMetadataItem_Release(enumerator);
 352     }
 353
 354     hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 355     ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
 356     ok(IsEqualGUID(&format, &GUID_MetadataFormatChunktEXt), "unexpected format %s\n", debugstr_guid(&format));
 357
 358     hr = IWICMetadataReader_GetMetadataFormat(reader, NULL);
 359     ok(hr == E_INVALIDARG, "GetMetadataFormat failed, hr=%x\n", hr);
 360
 361     id.vt = VT_LPSTR;
 362     U(id).pszVal = CoTaskMemAlloc(strlen("winetest") + 1);
 363     strcpy(U(id).pszVal, "winetest");
 364
 365     hr = IWICMetadataReader_GetValue(reader, NULL, &id, NULL);
 366     ok(hr == S_OK, "GetValue failed, hr=%x\n", hr);
 367
 368     hr = IWICMetadataReader_GetValue(reader, &schema, NULL, &value);
 369     ok(hr == E_INVALIDARG, "GetValue failed, hr=%x\n", hr);
 370
 371     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 372     ok(hr == S_OK, "GetValue failed, hr=%x\n", hr);
 373     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 374     ok(!strcmp(U(value).pszVal, "value"), "unexpected value: %s\n", U(value).pszVal);
 375     PropVariantClear(&value);
 376
 377     strcpy(U(id).pszVal, "test");
 378
 379     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 380     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "GetValue failed, hr=%x\n", hr);
 381
 382     PropVariantClear(&id);
 383
 384     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, NULL);
 385     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 386
 387     hr = IWICMetadataReader_GetValueByIndex(reader, 0, &schema, NULL, NULL);
 388     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 389     ok(schema.vt == VT_EMPTY, "unexpected vt: %i\n", schema.vt);
 390
 391     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &id, NULL);
 392     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 393     ok(id.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 394     ok(!strcmp(U(id).pszVal, "winetest"), "unexpected id: %s\n", U(id).pszVal);
 395     PropVariantClear(&id);
 396
 397     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, &value);
 398     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 399     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", value.vt);
 400     ok(!strcmp(U(value).pszVal, "value"), "unexpected value: %s\n", U(value).pszVal);
 401     PropVariantClear(&value);
 402
 403     hr = IWICMetadataReader_GetValueByIndex(reader, 1, NULL, NULL, NULL);
 404     ok(hr == E_INVALIDARG, "GetValueByIndex failed, hr=%x\n", hr);
 405
 406     IWICMetadataReader_Release(reader);
 407 }
 408
 409 static inline USHORT ushort_bswap(USHORT s)
 410 {
 411     return (s >> 8) | (s << 8);
 412 }
 413
 414 static inline ULONG ulong_bswap(ULONG l)
 415 {
 416     return ((ULONG)ushort_bswap((USHORT)l) << 16) | ushort_bswap((USHORT)(l >> 16));
 417 }
 418
 419 static inline ULONGLONG ulonglong_bswap(ULONGLONG ll)
 420 {
 421     return ((ULONGLONG)ulong_bswap((ULONG)ll) << 32) | ulong_bswap((ULONG)(ll >> 32));
 422 }
 423
 424 static void byte_swap_ifd_data(char *data)
 425 {
 426     USHORT number_of_entries, i;
 427     struct IFD_entry *entry;
 428     char *data_start = data;
 429
 430     number_of_entries = *(USHORT *)data;
 431     *(USHORT *)data = ushort_bswap(*(USHORT *)data);
 432     data += sizeof(USHORT);
 433
 434     for (i = 0; i < number_of_entries; i++)
 435     {
 436         entry = (struct IFD_entry *)data;
 437
 438         switch (entry->type)
 439         {
 440         case IFD_BYTE:
 441         case IFD_SBYTE:
 442         case IFD_ASCII:
 443         case IFD_UNDEFINED:
 444             if (entry->count > 4)
 445                 entry->value = ulong_bswap(entry->value);
 446             break;
 447
 448         case IFD_SHORT:
 449         case IFD_SSHORT:
 450             if (entry->count > 2)
 451             {
 452                 ULONG j, count = entry->count;
 453                 USHORT *us = (USHORT *)(data_start + entry->value);
 454                 if (!count) count = 1;
 455                 for (j = 0; j < count; j++)
 456                     us[j] = ushort_bswap(us[j]);
 457
 458                 entry->value = ulong_bswap(entry->value);
 459             }
 460             else
 461             {
 462                 ULONG j, count = entry->count;
 463                 USHORT *us = (USHORT *)&entry->value;
 464                 if (!count) count = 1;
 465                 for (j = 0; j < count; j++)
 466                     us[j] = ushort_bswap(us[j]);
 467             }
 468             break;
 469
 470         case IFD_LONG:
 471         case IFD_SLONG:
 472         case IFD_FLOAT:
 473             if (entry->count > 1)
 474             {
 475                 ULONG j, count = entry->count;
 476                 ULONG *ul = (ULONG *)(data_start + entry->value);
 477                 if (!count) count = 1;
 478                 for (j = 0; j < count; j++)
 479                     ul[j] = ulong_bswap(ul[j]);
 480             }
 481             entry->value = ulong_bswap(entry->value);
 482             break;
 483
 484         case IFD_RATIONAL:
 485         case IFD_SRATIONAL:
 486             {
 487                 ULONG j;
 488                 ULONG *ul = (ULONG *)(data_start + entry->value);
 489                 for (j = 0; j < entry->count * 2; j++)
 490                     ul[j] = ulong_bswap(ul[j]);
 491             }
 492             entry->value = ulong_bswap(entry->value);
 493             break;
 494
 495         case IFD_DOUBLE:
 496             {
 497                 ULONG j;
 498                 ULONGLONG *ull = (ULONGLONG *)(data_start + entry->value);
 499                 for (j = 0; j < entry->count; j++)
 500                     ull[j] = ulonglong_bswap(ull[j]);
 501             }
 502             entry->value = ulong_bswap(entry->value);
 503             break;
 504
 505         default:
 506             assert(0);
 507             break;
 508         }
 509
 510         entry->id = ushort_bswap(entry->id);
 511         entry->type = ushort_bswap(entry->type);
 512         entry->count = ulong_bswap(entry->count);
 513         data += sizeof(*entry);
 514     }
 515 }
 516
 517 struct test_data
 518 {
 519     ULONG type, id;
 520     int count; /* if VT_VECTOR */
 521     LONGLONG value[13];
 522     const char *string;
 523     const WCHAR id_string[32];
 524 };
 525
 526 static void compare_metadata(IWICMetadataReader *reader, const struct test_data *td, ULONG count)
 527 {
 528     HRESULT hr;
 529     IWICEnumMetadataItem *enumerator;
 530     PROPVARIANT schema, id, value;
 531     ULONG items_returned, i;
 532
 533     hr = IWICMetadataReader_GetEnumerator(reader, NULL);
 534     ok(hr == E_INVALIDARG, "GetEnumerator error %#x\n", hr);
 535
 536     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
 537     ok(hr == S_OK, "GetEnumerator error %#x\n", hr);
 538
 539     PropVariantInit(&schema);
 540     PropVariantInit(&id);
 541     PropVariantInit(&value);
 542
 543     for (i = 0; i < count; i++)
 544     {
 545         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 546         ok(hr == S_OK, "Next error %#x\n", hr);
 547         ok(items_returned == 1, "unexpected item count %u\n", items_returned);
 548
 549         ok(schema.vt == VT_EMPTY, "%u: unexpected vt: %u\n", i, schema.vt);
 550         ok(id.vt == VT_UI2 || id.vt == VT_LPWSTR, "%u: unexpected vt: %u\n", i, id.vt);
 551         if (id.vt == VT_UI2)
 552             ok(U(id).uiVal == td[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, U(id).uiVal);
 553         else if (id.vt == VT_LPWSTR)
 554             ok(!lstrcmpW(td[i].id_string, U(id).pwszVal),
 555                "%u: expected %s, got %s\n", i, wine_dbgstr_w(td[i].id_string), wine_dbgstr_w(U(id).pwszVal));
 556
 557         ok(value.vt == td[i].type, "%u: expected vt %#x, got %#x\n", i, td[i].type, value.vt);
 558         if (value.vt & VT_VECTOR)
 559         {
 560             ULONG j;
 561             switch (value.vt & ~VT_VECTOR)
 562             {
 563             case VT_I1:
 564             case VT_UI1:
 565                 ok(td[i].count == U(value).caub.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caub.cElems);
 566                 for (j = 0; j < U(value).caub.cElems; j++)
 567                     ok(td[i].value[j] == U(value).caub.pElems[j], "%u: expected value[%d] %#x/%#x, got %#x\n", i, j, (ULONG)td[i].value[j], (ULONG)(td[i].value[j] >> 32), U(value).caub.pElems[j]);
 568                 break;
 569             case VT_I2:
 570             case VT_UI2:
 571                 ok(td[i].count == U(value).caui.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caui.cElems);
 572                 for (j = 0; j < U(value).caui.cElems; j++)
 573                     ok(td[i].value[j] == U(value).caui.pElems[j], "%u: expected value[%d] %#x/%#x, got %#x\n", i, j, (ULONG)td[i].value[j], (ULONG)(td[i].value[j] >> 32), U(value).caui.pElems[j]);
 574                 break;
 575             case VT_I4:
 576             case VT_UI4:
 577             case VT_R4:
 578                 ok(td[i].count == U(value).caul.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caul.cElems);
 579                 for (j = 0; j < U(value).caul.cElems; j++)
 580                     ok(td[i].value[j] == U(value).caul.pElems[j], "%u: expected value[%d] %#x/%#x, got %#x\n", i, j, (ULONG)td[i].value[j], (ULONG)(td[i].value[j] >> 32), U(value).caul.pElems[j]);
 581                 break;
 582             case VT_I8:
 583             case VT_UI8:
 584             case VT_R8:
 585                 ok(td[i].count == U(value).cauh.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).cauh.cElems);
 586                 for (j = 0; j < U(value).cauh.cElems; j++)
 587                     ok(td[i].value[j] == U(value).cauh.pElems[j].QuadPart, "%u: expected value[%d] %08x/%08x, got %08x/%08x\n", i, j, (ULONG)td[i].value[j], (ULONG)(td[i].value[j] >> 32), U(value).cauh.pElems[j].u.LowPart, U(value).cauh.pElems[j].u.HighPart);
 588                 break;
 589             case VT_LPSTR:
 590                 ok(td[i].count == U(value).calpstr.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caub.cElems);
 591                 for (j = 0; j < U(value).calpstr.cElems; j++)
 592                     trace("%u: %s\n", j, U(value).calpstr.pElems[j]);
 593                 /* fall through to not handled message */
 594             default:
 595                 ok(0, "%u: array of type %d is not handled\n", i, value.vt & ~VT_VECTOR);
 596                 break;
 597             }
 598         }
 599         else if (value.vt == VT_LPSTR)
 600         {
 601             ok(td[i].count == strlen(U(value).pszVal) ||
 602                broken(td[i].count == strlen(U(value).pszVal) + 1), /* before Win7 */
 603                "%u: expected count %d, got %d\n", i, td[i].count, lstrlenA(U(value).pszVal));
 604             if (td[i].count == strlen(U(value).pszVal))
 605                 ok(!strcmp(td[i].string, U(value).pszVal),
 606                    "%u: expected %s, got %s\n", i, td[i].string, U(value).pszVal);
 607         }
 608         else if (value.vt == VT_BLOB)
 609         {
 610             ok(td[i].count == U(value).blob.cbSize, "%u: expected count %d, got %d\n", i, td[i].count, U(value).blob.cbSize);
 611             ok(!memcmp(td[i].string, U(value).blob.pBlobData, td[i].count), "%u: expected %s, got %s\n", i, td[i].string, U(value).blob.pBlobData);
 612         }
 613         else
 614             ok(U(value).uhVal.QuadPart == td[i].value[0], "%u: expected value %#x/%#x got %#x/%#x\n",
 615                i, (UINT)td[i].value[0], (UINT)(td[i].value[0] >> 32), U(value).uhVal.u.LowPart, U(value).uhVal.u.HighPart);
 616
 617         PropVariantClear(&schema);
 618         PropVariantClear(&id);
 619         PropVariantClear(&value);
 620     }
 621
 622     hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 623     ok(hr == S_FALSE, "Next should fail\n");
 624     ok(items_returned == 0, "unexpected item count %u\n", items_returned);
 625
 626     IWICEnumMetadataItem_Release(enumerator);
 627 }
 628
 629 static void test_metadata_IFD(void)
 630 {
 631     static const struct test_data td[28] =
 632     {
 633         { VT_UI2, 0xfe, 0, { 1 } },
 634         { VT_UI4, 0x100, 0, { 222 } },
 635         { VT_UI4, 0x101, 0, { 333 } },
 636         { VT_UI2, 0x102, 0, { 24 } },
 637         { VT_UI4, 0x103, 0, { 32773 } },
 638         { VT_UI8, 0x11a, 0, { ((LONGLONG)3 << 32) | 900 } },
 639         { VT_UI1, 0xf001, 0, { 0x44 } },
 640         { VT_UI1|VT_VECTOR, 0xf002, 4, { 0x44, 0x33, 0x22, 0x11 } },
 641         { VT_I1, 0xf003, 0, { 0x44 } },
 642         { VT_I2, 0xf004, 0, { 0x3344 } },
 643         { VT_I2|VT_VECTOR, 0xf005, 2, { 0x3344, 0x1122 } },
 644         { VT_I4, 0xf006, 0, { 0x11223344 } },
 645         { VT_R4, 0xf007, 0, { 0x11223344 } },
 646         { VT_R8, 0xf008, 0, { ((LONGLONG)0x41d26580 << 32) | 0xb486522c } },
 647         { VT_I8, 0xf009, 0, { ((LONGLONG)0x5a6b7c8d << 32) | 0x1a2b3c4d } },
 648         { VT_UI1|VT_VECTOR, 0xf00a, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
 649         { VT_I2|VT_VECTOR, 0xf00b, 4, { 0x0101, 0x0202, 0x0303, 0x0404 } },
 650         { VT_I4|VT_VECTOR, 0xf00c, 2, { 0x11223344, 0x55667788 } },
 651         { VT_R4|VT_VECTOR, 0xf00d, 2, { 0x449a522b, 0x4608f5ba } },
 652         { VT_LPSTR, 0xf00e, 12, { 0 }, "Hello World!" },
 653         { VT_LPSTR, 0xf00f, 4, { 0 }, "abcd" },
 654         { VT_BLOB, 0xf010, 13, { 0 }, "Hello World!" },
 655         { VT_BLOB, 0xf011, 4, { 0 }, "abcd" },
 656         { VT_UI1, 0xf012, 0, { 0x44 } },
 657         { VT_UI2, 0xf013, 0, { 0x3344 } },
 658         { VT_UI4, 0xf014, 0, { 0x11223344 } },
 659         { VT_R4, 0xf015, 0, { 0x11223344 } },
 660         { VT_I8|VT_VECTOR, 0xf016, 3,
 661           { ((LONGLONG)0x05060708 << 32) | 0x01020304,
 662             ((LONGLONG)0x50607080 << 32) | 0x10203040,
 663             ((LONGLONG)0x55667788 << 32) | 0x11223344 } },
 664     };
 665     HRESULT hr;
 666     IWICMetadataReader *reader;
 667     IWICMetadataBlockReader *blockreader;
 668     PROPVARIANT schema, id, value;
 669     ULONG count;
 670     GUID format;
 671     char *IFD_data_swapped;
 672 #ifdef WORDS_BIGENDIAN
 673     DWORD persist_options = WICPersistOptionsBigEndian;
 674 #else
 675     DWORD persist_options = WICPersistOptionsLittleEndian;
 676 #endif
 677
 678     hr = CoCreateInstance(&CLSID_WICIfdMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 679         &IID_IWICMetadataReader, (void**)&reader);
 680     ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
 681
 682     hr = IWICMetadataReader_GetCount(reader, NULL);
 683     ok(hr == E_INVALIDARG, "GetCount error %#x\n", hr);
 684
 685     hr = IWICMetadataReader_GetCount(reader, &count);
 686     ok(hr == S_OK, "GetCount error %#x\n", hr);
 687     ok(count == 0, "unexpected count %u\n", count);
 688
 689     load_stream((IUnknown*)reader, (const char *)&IFD_data, sizeof(IFD_data), persist_options);
 690
 691     hr = IWICMetadataReader_GetCount(reader, &count);
 692     ok(hr == S_OK, "GetCount error %#x\n", hr);
 693     ok(count == sizeof(td)/sizeof(td[0]), "unexpected count %u\n", count);
 694
 695     compare_metadata(reader, td, count);
 696
 697     /* test IFD data with different endianness */
 698     if (persist_options == WICPersistOptionsLittleEndian)
 699         persist_options = WICPersistOptionsBigEndian;
 700     else
 701         persist_options = WICPersistOptionsLittleEndian;
 702
 703     IFD_data_swapped = HeapAlloc(GetProcessHeap(), 0, sizeof(IFD_data));
 704     memcpy(IFD_data_swapped, &IFD_data, sizeof(IFD_data));
 705     byte_swap_ifd_data(IFD_data_swapped);
 706     load_stream((IUnknown *)reader, IFD_data_swapped, sizeof(IFD_data), persist_options);
 707     hr = IWICMetadataReader_GetCount(reader, &count);
 708     ok(hr == S_OK, "GetCount error %#x\n", hr);
 709     ok(count == sizeof(td)/sizeof(td[0]), "unexpected count %u\n", count);
 710     compare_metadata(reader, td, count);
 711     HeapFree(GetProcessHeap(), 0, IFD_data_swapped);
 712
 713     hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 714     ok(hr == S_OK, "GetMetadataFormat error %#x\n", hr);
 715     ok(IsEqualGUID(&format, &GUID_MetadataFormatIfd), "unexpected format %s\n", debugstr_guid(&format));
 716
 717     hr = IWICMetadataReader_GetMetadataFormat(reader, NULL);
 718     ok(hr == E_INVALIDARG, "GetMetadataFormat should fail\n");
 719
 720     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, NULL);
 721     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 722
 723     PropVariantInit(&schema);
 724     PropVariantInit(&id);
 725     PropVariantInit(&value);
 726
 727     hr = IWICMetadataReader_GetValueByIndex(reader, count - 1, NULL, NULL, NULL);
 728     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 729
 730     hr = IWICMetadataReader_GetValueByIndex(reader, 0, &schema, NULL, NULL);
 731     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 732     ok(schema.vt == VT_EMPTY, "unexpected vt: %u\n", schema.vt);
 733
 734     hr = IWICMetadataReader_GetValueByIndex(reader, count - 1, &schema, NULL, NULL);
 735     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 736     ok(schema.vt == VT_EMPTY, "unexpected vt: %u\n", schema.vt);
 737
 738     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &id, NULL);
 739     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 740     ok(id.vt == VT_UI2, "unexpected vt: %u\n", id.vt);
 741     ok(U(id).uiVal == 0xfe, "unexpected id: %#x\n", U(id).uiVal);
 742     PropVariantClear(&id);
 743
 744     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, &value);
 745     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 746     ok(value.vt == VT_UI2, "unexpected vt: %u\n", value.vt);
 747     ok(U(value).uiVal == 1, "unexpected id: %#x\n", U(value).uiVal);
 748     PropVariantClear(&value);
 749
 750     hr = IWICMetadataReader_GetValueByIndex(reader, count, &schema, NULL, NULL);
 751     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 752
 753     PropVariantInit(&schema);
 754     PropVariantInit(&id);
 755     PropVariantInit(&value);
 756
 757     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 758     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "expected WINCODEC_ERR_PROPERTYNOTFOUND, got %#x\n", hr);
 759
 760     hr = IWICMetadataReader_GetValue(reader, NULL, &id, NULL);
 761     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "expected WINCODEC_ERR_PROPERTYNOTFOUND, got %#x\n", hr);
 762
 763     hr = IWICMetadataReader_GetValue(reader, &schema, NULL, NULL);
 764     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 765
 766     hr = IWICMetadataReader_GetValue(reader, &schema, &id, NULL);
 767     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "expected WINCODEC_ERR_PROPERTYNOTFOUND, got %#x\n", hr);
 768
 769     hr = IWICMetadataReader_GetValue(reader, &schema, NULL, &value);
 770     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 771
 772     id.vt = VT_UI2;
 773     U(id).uiVal = 0xf00e;
 774     hr = IWICMetadataReader_GetValue(reader, NULL, &id, NULL);
 775     ok(hr == S_OK, "GetValue error %#x\n", hr);
 776
 777     /* schema is ignored by Ifd metadata reader */
 778     schema.vt = VT_UI4;
 779     U(schema).ulVal = 0xdeadbeef;
 780     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 781     ok(hr == S_OK, "GetValue error %#x\n", hr);
 782     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 783     ok(!strcmp(U(value).pszVal, "Hello World!"), "unexpected value: %s\n", U(value).pszVal);
 784     PropVariantClear(&value);
 785
 786     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
 787     ok(hr == S_OK, "GetValue error %#x\n", hr);
 788     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 789     ok(!strcmp(U(value).pszVal, "Hello World!"), "unexpected value: %s\n", U(value).pszVal);
 790     PropVariantClear(&value);
 791
 792     hr = IWICMetadataReader_QueryInterface(reader, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 793     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 794
 795     if (SUCCEEDED(hr))
 796         IWICMetadataBlockReader_Release(blockreader);
 797
 798     IWICMetadataReader_Release(reader);
 799 }
 800
 801 static void test_metadata_Exif(void)
 802 {
 803     HRESULT hr;
 804     IWICMetadataReader *reader;
 805     IWICMetadataBlockReader *blockreader;
 806     UINT count=0;
 807
 808     hr = CoCreateInstance(&CLSID_WICExifMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 809         &IID_IWICMetadataReader, (void**)&reader);
 810     todo_wine ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
 811     if (FAILED(hr)) return;
 812
 813     hr = IWICMetadataReader_GetCount(reader, NULL);
 814     ok(hr == E_INVALIDARG, "GetCount error %#x\n", hr);
 815
 816     hr = IWICMetadataReader_GetCount(reader, &count);
 817     ok(hr == S_OK, "GetCount error %#x\n", hr);
 818     ok(count == 0, "unexpected count %u\n", count);
 819
 820     hr = IWICMetadataReader_QueryInterface(reader, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 821     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 822
 823     if (SUCCEEDED(hr))
 824         IWICMetadataBlockReader_Release(blockreader);
 825
 826     IWICMetadataReader_Release(reader);
 827 }
 828
 829 static void test_create_reader(void)
 830 {
 831     HRESULT hr;
 832     IWICComponentFactory *factory;
 833     IStream *stream;
 834     IWICMetadataReader *reader;
 835     UINT count=0;
 836     GUID format;
 837
 838     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 839         &IID_IWICComponentFactory, (void**)&factory);
 840     ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 841
 842     stream = create_stream(metadata_tEXt, sizeof(metadata_tEXt));
 843
 844     hr = IWICComponentFactory_CreateMetadataReaderFromContainer(factory,
 845         &GUID_ContainerFormatPng, NULL, WICPersistOptionsDefault,
 846         stream, &reader);
 847 todo_wine
 848     ok(hr == S_OK, "CreateMetadataReaderFromContainer failed, hr=%x\n", hr);
 849     if (FAILED(hr)) return;
 850
 851     if (SUCCEEDED(hr))
 852     {
 853         hr = IWICMetadataReader_GetCount(reader, &count);
 854         ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 855         ok(count == 1, "unexpected count %i\n", count);
 856
 857         hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 858         ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
 859         ok(IsEqualGUID(&format, &GUID_MetadataFormatChunktEXt), "unexpected format %s\n", debugstr_guid(&format));
 860
 861         IWICMetadataReader_Release(reader);
 862     }
 863
 864     hr = IWICComponentFactory_CreateMetadataReaderFromContainer(factory,
 865         &GUID_ContainerFormatWmp, NULL, WICPersistOptionsDefault,
 866         stream, &reader);
 867     ok(hr == S_OK, "CreateMetadataReaderFromContainer failed, hr=%x\n", hr);
 868
 869     if (SUCCEEDED(hr))
 870     {
 871         hr = IWICMetadataReader_GetCount(reader, &count);
 872         ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 873         ok(count == 1, "unexpected count %i\n", count);
 874
 875         hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 876         ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
 877         ok(IsEqualGUID(&format, &GUID_MetadataFormatUnknown), "unexpected format %s\n", debugstr_guid(&format));
 878
 879         IWICMetadataReader_Release(reader);
 880     }
 881
 882     IStream_Release(stream);
 883
 884     IWICComponentFactory_Release(factory);
 885 }
 886
 887 static void test_metadata_png(void)
 888 {
 889     static const struct test_data td[6] =
 890     {
 891         { VT_UI2, 0, 0, { 2005 }, NULL, { 'Y','e','a','r',0 } },
 892         { VT_UI1, 0, 0, { 6 }, NULL, { 'M','o','n','t','h',0 } },
 893         { VT_UI1, 0, 0, { 3 }, NULL, { 'D','a','y',0 } },
 894         { VT_UI1, 0, 0, { 15 }, NULL, { 'H','o','u','r',0 } },
 895         { VT_UI1, 0, 0, { 7 }, NULL, { 'M','i','n','u','t','e',0 } },
 896         { VT_UI1, 0, 0, { 45 }, NULL, { 'S','e','c','o','n','d',0 } }
 897     };
 898     IStream *stream;
 899     IWICBitmapDecoder *decoder;
 900     IWICBitmapFrameDecode *frame;
 901     IWICMetadataBlockReader *blockreader;
 902     IWICMetadataReader *reader;
 903     GUID containerformat;
 904     HRESULT hr;
 905     UINT count;
 906
 907     hr = CoCreateInstance(&CLSID_WICPngDecoder, NULL, CLSCTX_INPROC_SERVER,
 908         &IID_IWICBitmapDecoder, (void**)&decoder);
 909     ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 910
 911     if (FAILED(hr)) return;
 912
 913     stream = create_stream(pngimage, sizeof(pngimage));
 914
 915     hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
 916     ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
 917
 918     hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 919     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 920
 921     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
 922     ok(hr == S_OK, "GetFrame failed, hr=%x\n", hr);
 923
 924     hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 925     ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
 926
 927     if (SUCCEEDED(hr))
 928     {
 929         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, NULL);
 930         ok(hr == E_INVALIDARG, "GetContainerFormat failed, hr=%x\n", hr);
 931
 932         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, &containerformat);
 933         ok(hr == S_OK, "GetContainerFormat failed, hr=%x\n", hr);
 934         ok(IsEqualGUID(&containerformat, &GUID_ContainerFormatPng), "unexpected container format\n");
 935
 936         hr = IWICMetadataBlockReader_GetCount(blockreader, NULL);
 937         todo_wine ok(hr == E_INVALIDARG, "GetCount failed, hr=%x\n", hr);
 938
 939         hr = IWICMetadataBlockReader_GetCount(blockreader, &count);
 940         todo_wine ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 941         todo_wine ok(count == 1, "unexpected count %d\n", count);
 942
 943         if (0)
 944         {
 945             /* Crashes on Windows XP */
 946             hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, NULL);
 947             ok(hr == E_INVALIDARG, "GetReaderByIndex failed, hr=%x\n", hr);
 948         }
 949
 950         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, &reader);
 951         todo_wine ok(hr == S_OK, "GetReaderByIndex failed, hr=%x\n", hr);
 952
 953         if (SUCCEEDED(hr))
 954         {
 955             hr = IWICMetadataReader_GetMetadataFormat(reader, &containerformat);
 956             ok(IsEqualGUID(&containerformat, &GUID_MetadataFormatChunktIME) ||
 957                broken(IsEqualGUID(&containerformat, &GUID_MetadataFormatUnknown)) /* Windows XP */,
 958                "unexpected container format\n");
 959
 960             hr = IWICMetadataReader_GetCount(reader, &count);
 961             ok(hr == S_OK, "GetCount error %#x\n", hr);
 962             ok(count == 6 || broken(count == 1) /* XP */, "expected 6, got %u\n", count);
 963             if (count == 6)
 964                 compare_metadata(reader, td, count);
 965
 966             IWICMetadataReader_Release(reader);
 967         }
 968
 969         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 1, &reader);
 970         todo_wine ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "GetReaderByIndex failed, hr=%x\n", hr);
 971
 972         IWICMetadataBlockReader_Release(blockreader);
 973     }
 974
 975     IWICBitmapFrameDecode_Release(frame);
 976
 977     IWICBitmapDecoder_Release(decoder);
 978
 979     IStream_Release(stream);
 980 }
 981
 982 static void test_metadata_gif(void)
 983 {
 984     static const struct test_data gif_LSD[9] =
 985     {
 986         { VT_UI1|VT_VECTOR, 0, 6, {'G','I','F','8','7','a'}, NULL, { 'S','i','g','n','a','t','u','r','e',0 } },
 987         { VT_UI2, 0, 0, { 1 }, NULL, { 'W','i','d','t','h',0 } },
 988         { VT_UI2, 0, 0, { 1 }, NULL, { 'H','e','i','g','h','t',0 } },
 989         { VT_BOOL, 0, 0, { 1 }, NULL, { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','F','l','a','g',0 } },
 990         { VT_UI1, 0, 0, { 0 }, NULL, { 'C','o','l','o','r','R','e','s','o','l','u','t','i','o','n',0 } },
 991         { VT_BOOL, 0, 0, { 0 }, NULL, { 'S','o','r','t','F','l','a','g',0 } },
 992         { VT_UI1, 0, 0, { 0 }, NULL, { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','S','i','z','e',0 } },
 993         { VT_UI1, 0, 0, { 0 }, NULL, { 'B','a','c','k','g','r','o','u','n','d','C','o','l','o','r','I','n','d','e','x',0 } },
 994         { VT_UI1, 0, 0, { 0 }, NULL, { 'P','i','x','e','l','A','s','p','e','c','t','R','a','t','i','o',0 } }
 995     };
 996     static const struct test_data gif_IMD[8] =
 997     {
 998         { VT_UI2, 0, 0, { 0 }, NULL, { 'L','e','f','t',0 } },
 999         { VT_UI2, 0, 0, { 0 }, NULL, { 'T','o','p',0 } },
1000         { VT_UI2, 0, 0, { 1 }, NULL, { 'W','i','d','t','h',0 } },
1001         { VT_UI2, 0, 0, { 1 }, NULL, { 'H','e','i','g','h','t',0 } },
1002         { VT_BOOL, 0, 0, { 0 }, NULL, { 'L','o','c','a','l','C','o','l','o','r','T','a','b','l','e','F','l','a','g',0 } },
1003         { VT_BOOL, 0, 0, { 0 }, NULL, { 'I','n','t','e','r','l','a','c','e','F','l','a','g',0 } },
1004         { VT_BOOL, 0, 0, { 0 }, NULL, { 'S','o','r','t','F','l','a','g',0 } },
1005         { VT_UI1, 0, 0, { 0 }, NULL, { 'L','o','c','a','l','C','o','l','o','r','T','a','b','l','e','S','i','z','e',0 } }
1006     };
1007     static const struct test_data animated_gif_LSD[9] =
1008     {
1009         { VT_UI1|VT_VECTOR, 0, 6, {'G','I','F','8','9','a'}, NULL, { 'S','i','g','n','a','t','u','r','e',0 } },
1010         { VT_UI2, 0, 0, { 1 }, NULL, { 'W','i','d','t','h',0 } },
1011         { VT_UI2, 0, 0, { 1 }, NULL, { 'H','e','i','g','h','t',0 } },
1012         { VT_BOOL, 0, 0, { 1 }, NULL, { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','F','l','a','g',0 } },
1013         { VT_UI1, 0, 0, { 2 }, NULL, { 'C','o','l','o','r','R','e','s','o','l','u','t','i','o','n',0 } },
1014         { VT_BOOL, 0, 0, { 0 }, NULL, { 'S','o','r','t','F','l','a','g',0 } },
1015         { VT_UI1, 0, 0, { 1 }, NULL, { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','S','i','z','e',0 } },
1016         { VT_UI1, 0, 0, { 0 }, NULL, { 'B','a','c','k','g','r','o','u','n','d','C','o','l','o','r','I','n','d','e','x',0 } },
1017         { VT_UI1, 0, 0, { 0 }, NULL, { 'P','i','x','e','l','A','s','p','e','c','t','R','a','t','i','o',0 } }
1018     };
1019     static const struct test_data animated_gif_GCE[5] =
1020     {
1021         { VT_UI1, 0, 0, { 0 }, NULL, { 'D','i','s','p','o','s','a','l',0 } },
1022         { VT_BOOL, 0, 0, { 0 }, NULL, { 'U','s','e','r','I','n','p','u','t','F','l','a','g',0 } },
1023         { VT_BOOL, 0, 0, { 0 }, NULL, { 'T','r','a','n','s','p','a','r','e','n','c','y','F','l','a','g',0 } },
1024         { VT_UI2, 0, 0, { 10 }, NULL, { 'D','e','l','a','y',0 } },
1025         { VT_UI1, 0, 0, { 255 }, NULL, { 'T','r','a','n','s','p','a','r','e','n','t','C','o','l','o','r','I','n','d','e','x',0 } }
1026     };
1027     IStream *stream;
1028     IWICBitmapDecoder *decoder;
1029     IWICBitmapFrameDecode *frame;
1030     IWICMetadataBlockReader *blockreader;
1031     IWICMetadataReader *reader;
1032     GUID format;
1033     HRESULT hr;
1034     UINT count;
1035
1036     /* 1x1 pixel gif */
1037     stream = create_stream(gifimage, sizeof(gifimage));
1038
1039     hr = CoCreateInstance(&CLSID_WICGifDecoder, NULL, CLSCTX_INPROC_SERVER,
1040                           &IID_IWICBitmapDecoder, (void **)&decoder);
1041     ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
1042     hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
1043     ok(hr == S_OK, "Initialize error %#x\n", hr);
1044
1045     IStream_Release(stream);
1046
1047     /* global metadata block */
1048     hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void **)&blockreader);
1049 todo_wine
1050     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* before Win7 */, "QueryInterface error %#x\n", hr);
1051
1052     if (SUCCEEDED(hr))
1053     {
1054         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, &format);
1055         ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
1056         ok(IsEqualGUID(&format, &GUID_ContainerFormatGif),
1057            "wrong container format %s\n", debugstr_guid(&format));
1058
1059         hr = IWICMetadataBlockReader_GetCount(blockreader, &count);
1060         ok(hr == S_OK, "GetCount error %#x\n", hr);
1061         ok(count == 1, "expected 1, got %u\n", count);
1062
1063         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, &reader);
1064         ok(hr == S_OK, "GetReaderByIndex error %#x\n", hr);
1065
1066         if (SUCCEEDED(hr))
1067         {
1068             hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
1069             ok(IsEqualGUID(&format, &GUID_MetadataFormatLSD), /* Logical Screen Descriptor */
1070                "wrong container format %s\n", debugstr_guid(&format));
1071
1072             hr = IWICMetadataReader_GetCount(reader, &count);
1073             ok(hr == S_OK, "GetCount error %#x\n", hr);
1074             ok(count == sizeof(gif_LSD)/sizeof(gif_LSD[0]), "unexpected count %u\n", count);
1075
1076             compare_metadata(reader, gif_LSD, count);
1077
1078             IWICMetadataReader_Release(reader);
1079         }
1080
1081         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 1, &reader);
1082         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1083
1084         IWICMetadataBlockReader_Release(blockreader);
1085     }
1086
1087     /* frame metadata block */
1088     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1089     ok(hr == S_OK, "GetFrame error %#x\n", hr);
1090
1091     hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&blockreader);
1092 todo_wine
1093     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* before Win7 */, "QueryInterface error %#x\n", hr);
1094
1095     if (SUCCEEDED(hr))
1096     {
1097         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, NULL);
1098         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1099
1100         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, &format);
1101         ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
1102         ok(IsEqualGUID(&format, &GUID_ContainerFormatGif),
1103            "wrong container format %s\n", debugstr_guid(&format));
1104
1105         hr = IWICMetadataBlockReader_GetCount(blockreader, NULL);
1106         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1107
1108         hr = IWICMetadataBlockReader_GetCount(blockreader, &count);
1109         ok(hr == S_OK, "GetCount error %#x\n", hr);
1110         ok(count == 1, "expected 1, got %u\n", count);
1111
1112         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, &reader);
1113         ok(hr == S_OK, "GetReaderByIndex error %#x\n", hr);
1114
1115         if (SUCCEEDED(hr))
1116         {
1117             hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
1118             ok(IsEqualGUID(&format, &GUID_MetadataFormatIMD), /* Image Descriptor */
1119                "wrong container format %s\n", debugstr_guid(&format));
1120
1121             hr = IWICMetadataReader_GetCount(reader, &count);
1122             ok(hr == S_OK, "GetCount error %#x\n", hr);
1123             ok(count == sizeof(gif_IMD)/sizeof(gif_IMD[0]), "unexpected count %u\n", count);
1124
1125             compare_metadata(reader, gif_IMD, count);
1126
1127             IWICMetadataReader_Release(reader);
1128         }
1129
1130         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 1, &reader);
1131         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1132
1133         IWICMetadataBlockReader_Release(blockreader);
1134     }
1135
1136     IWICBitmapFrameDecode_Release(frame);
1137     IWICBitmapDecoder_Release(decoder);
1138
1139     /* 1x1 pixel gif, 2 frames */
1140     stream = create_stream(gifanimation, sizeof(gifanimation));
1141
1142     hr = CoCreateInstance(&CLSID_WICGifDecoder, NULL, CLSCTX_INPROC_SERVER,
1143                           &IID_IWICBitmapDecoder, (void **)&decoder);
1144     ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
1145     hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
1146     ok(hr == S_OK, "Initialize error %#x\n", hr);
1147
1148     IStream_Release(stream);
1149
1150     /* global metadata block */
1151     hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void **)&blockreader);
1152 todo_wine
1153     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* before Win7 */, "QueryInterface error %#x\n", hr);
1154
1155     if (SUCCEEDED(hr))
1156     {
1157         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, &format);
1158         ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
1159         ok(IsEqualGUID(&format, &GUID_ContainerFormatGif),
1160            "wrong container format %s\n", debugstr_guid(&format));
1161
1162         hr = IWICMetadataBlockReader_GetCount(blockreader, &count);
1163         ok(hr == S_OK, "GetCount error %#x\n", hr);
1164         ok(count == 1, "expected 1, got %u\n", count);
1165
1166         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, &reader);
1167         ok(hr == S_OK, "GetReaderByIndex error %#x\n", hr);
1168
1169         if (SUCCEEDED(hr))
1170         {
1171             hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
1172             ok(IsEqualGUID(&format, &GUID_MetadataFormatLSD), /* Logical Screen Descriptor */
1173                "wrong container format %s\n", debugstr_guid(&format));
1174
1175             hr = IWICMetadataReader_GetCount(reader, &count);
1176             ok(hr == S_OK, "GetCount error %#x\n", hr);
1177             ok(count == sizeof(animated_gif_LSD)/sizeof(animated_gif_LSD[0]), "unexpected count %u\n", count);
1178
1179             compare_metadata(reader, animated_gif_LSD, count);
1180
1181             IWICMetadataReader_Release(reader);
1182         }
1183
1184         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 1, &reader);
1185         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1186
1187         IWICMetadataBlockReader_Release(blockreader);
1188     }
1189
1190     /* frame metadata block */
1191     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1192     ok(hr == S_OK, "GetFrame error %#x\n", hr);
1193
1194     hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&blockreader);
1195 todo_wine
1196     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* before Win7 */, "QueryInterface error %#x\n", hr);
1197
1198     if (SUCCEEDED(hr))
1199     {
1200         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, NULL);
1201         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1202
1203         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, &format);
1204         ok(hr == S_OK, "GetContainerFormat error %#x\n", hr);
1205         ok(IsEqualGUID(&format, &GUID_ContainerFormatGif),
1206            "wrong container format %s\n", debugstr_guid(&format));
1207
1208         hr = IWICMetadataBlockReader_GetCount(blockreader, NULL);
1209         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1210
1211         hr = IWICMetadataBlockReader_GetCount(blockreader, &count);
1212         ok(hr == S_OK, "GetCount error %#x\n", hr);
1213         ok(count == 2, "expected 2, got %u\n", count);
1214
1215         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, &reader);
1216         ok(hr == S_OK, "GetReaderByIndex error %#x\n", hr);
1217
1218         if (SUCCEEDED(hr))
1219         {
1220             hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
1221             ok(IsEqualGUID(&format, &GUID_MetadataFormatIMD), /* Image Descriptor */
1222                "wrong container format %s\n", debugstr_guid(&format));
1223
1224             hr = IWICMetadataReader_GetCount(reader, &count);
1225             ok(hr == S_OK, "GetCount error %#x\n", hr);
1226             ok(count == sizeof(gif_IMD)/sizeof(gif_IMD[0]), "unexpected count %u\n", count);
1227
1228             compare_metadata(reader, gif_IMD, count);
1229
1230             IWICMetadataReader_Release(reader);
1231         }
1232
1233         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 1, &reader);
1234         ok(hr == S_OK, "GetReaderByIndex error %#x\n", hr);
1235
1236         if (SUCCEEDED(hr))
1237         {
1238             hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
1239             ok(IsEqualGUID(&format, &GUID_MetadataFormatGCE), /* Graphic Control Extension */
1240                "wrong container format %s\n", debugstr_guid(&format));
1241
1242             hr = IWICMetadataReader_GetCount(reader, &count);
1243             ok(hr == S_OK, "GetCount error %#x\n", hr);
1244             ok(count == sizeof(animated_gif_GCE)/sizeof(animated_gif_GCE[0]), "unexpected count %u\n", count);
1245
1246             compare_metadata(reader, animated_gif_GCE, count);
1247
1248             IWICMetadataReader_Release(reader);
1249         }
1250
1251         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 2, &reader);
1252         ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
1253
1254         IWICMetadataBlockReader_Release(blockreader);
1255     }
1256
1257     IWICBitmapFrameDecode_Release(frame);
1258     IWICBitmapDecoder_Release(decoder);
1259 }
1260
1261 static void test_metadata_LSD(void)
1262 {
1263     static const WCHAR LSD_name[] = {'L','o','g','i','c','a','l',' ','S','c','r','e','e','n',' ','D','e','s','c','r','i','p','t','o','r',' ','R','e','a','d','e','r',0};
1264     static const char LSD_data[] = "hello world!\x1\x2\x3\x4\xab\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf";
1265     static const struct test_data td[9] =
1266     {
1267         { VT_UI1|VT_VECTOR, 0, 6, {'w','o','r','l','d','!'}, NULL, { 'S','i','g','n','a','t','u','r','e',0 } },
1268         { VT_UI2, 0, 0, { 0x201 }, NULL, { 'W','i','d','t','h',0 } },
1269         { VT_UI2, 0, 0, { 0x403 }, NULL, { 'H','e','i','g','h','t',0 } },
1270         { VT_BOOL, 0, 0, { 1 }, NULL, { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','F','l','a','g',0 } },
1271         { VT_UI1, 0, 0, { 2 }, NULL, { 'C','o','l','o','r','R','e','s','o','l','u','t','i','o','n',0 } },
1272         { VT_BOOL, 0, 0, { 1 }, NULL, { 'S','o','r','t','F','l','a','g',0 } },
1273         { VT_UI1, 0, 0, { 3 }, NULL, { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','S','i','z','e',0 } },
1274         { VT_UI1, 0, 0, { 6 }, NULL, { 'B','a','c','k','g','r','o','u','n','d','C','o','l','o','r','I','n','d','e','x',0 } },
1275         { VT_UI1, 0, 0, { 7 }, NULL, { 'P','i','x','e','l','A','s','p','e','c','t','R','a','t','i','o',0 } }
1276     };
1277     LARGE_INTEGER pos;
1278     HRESULT hr;
1279     IStream *stream;
1280     IWICPersistStream *persist;
1281     IWICMetadataReader *reader;
1282     IWICMetadataHandlerInfo *info;
1283     WCHAR name[64];
1284     UINT count, dummy;
1285     GUID format;
1286     CLSID id;
1287
1288     hr = CoCreateInstance(&CLSID_WICLSDMetadataReader, NULL, CLSCTX_INPROC_SERVER,
1289                           &IID_IWICMetadataReader, (void **)&reader);
1290 todo_wine
1291     ok(hr == S_OK || broken(hr == E_NOINTERFACE || hr == REGDB_E_CLASSNOTREG) /* before Win7 */,
1292        "CoCreateInstance error %#x\n", hr);
1293
1294     stream = create_stream(LSD_data, sizeof(LSD_data));
1295
1296     if (SUCCEEDED(hr))
1297     {
1298         pos.QuadPart = 6;
1299         hr = IStream_Seek(stream, pos, SEEK_SET, NULL);
1300         ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
1301
1302         hr = IUnknown_QueryInterface(reader, &IID_IWICPersistStream, (void **)&persist);
1303         ok(hr == S_OK, "QueryInterface error %#x\n", hr);
1304
1305         hr = IWICPersistStream_Load(persist, stream);
1306         ok(hr == S_OK, "Load error %#x\n", hr);
1307
1308         IWICPersistStream_Release(persist);
1309     }
1310
1311     if (SUCCEEDED(hr))
1312     {
1313         hr = IWICMetadataReader_GetCount(reader, &count);
1314         ok(hr == S_OK, "GetCount error %#x\n", hr);
1315         ok(count == sizeof(td)/sizeof(td[0]), "unexpected count %u\n", count);
1316
1317         compare_metadata(reader, td, count);
1318
1319         hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
1320         ok(hr == S_OK, "GetMetadataFormat error %#x\n", hr);
1321         ok(IsEqualGUID(&format, &GUID_MetadataFormatLSD), "wrong format %s\n", debugstr_guid(&format));
1322
1323         hr = IWICMetadataReader_GetMetadataHandlerInfo(reader, &info);
1324         ok(hr == S_OK, "GetMetadataHandlerInfo error %#x\n", hr);
1325
1326         hr = IWICMetadataHandlerInfo_GetCLSID(info, &id);
1327         ok(hr == S_OK, "GetCLSID error %#x\n", hr);
1328         ok(IsEqualGUID(&id, &CLSID_WICLSDMetadataReader), "wrong CLSID %s\n", debugstr_guid(&id));
1329
1330         hr = IWICMetadataHandlerInfo_GetFriendlyName(info, 64, name, &dummy);
1331         ok(hr == S_OK, "GetFriendlyName error %#x\n", hr);
1332         ok(lstrcmpW(name, LSD_name) == 0, "wrong LSD reader name %s\n", wine_dbgstr_w(name));
1333
1334         IWICMetadataHandlerInfo_Release(info);
1335         IWICMetadataReader_Release(reader);
1336     }
1337
1338     IStream_Release(stream);
1339 }
1340
1341 START_TEST(metadata)
1342 {
1343     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1344
1345     test_metadata_unknown();
1346     test_metadata_tEXt();
1347     test_metadata_IFD();
1348     test_metadata_Exif();
1349     test_create_reader();
1350     test_metadata_png();
1351     test_metadata_gif();
1352     test_metadata_LSD();
1353
1354     CoUninitialize();
1355 }