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 static const char *debugstr_guid(REFIID riid)
 151 {
 152     static char buf[50];
 153
 154     if(!riid)
 155         return "(null)";
 156
 157     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 158             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 159             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 160             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 161
 162     return buf;
 163 }
 164
 165 static IStream *create_stream(const char *data, int data_size)
 166 {
 167     HRESULT hr;
 168     IStream *stream;
 169     HGLOBAL hdata;
 170     void *locked_data;
 171
 172     hdata = GlobalAlloc(GMEM_MOVEABLE, data_size);
 173     ok(hdata != 0, "GlobalAlloc failed\n");
 174     if (!hdata) return NULL;
 175
 176     locked_data = GlobalLock(hdata);
 177     memcpy(locked_data, data, data_size);
 178     GlobalUnlock(hdata);
 179
 180     hr = CreateStreamOnHGlobal(hdata, TRUE, &stream);
 181     ok(hr == S_OK, "CreateStreamOnHGlobal failed, hr=%x\n", hr);
 182
 183     return stream;
 184 }
 185
 186 static void load_stream(IUnknown *reader, const char *data, int data_size, DWORD persist_options)
 187 {
 188     HRESULT hr;
 189     IWICPersistStream *persist;
 190     IStream *stream;
 191     LARGE_INTEGER pos;
 192     ULARGE_INTEGER cur_pos;
 193
 194     stream = create_stream(data, data_size);
 195     if (!stream)
 196         return;
 197
 198     hr = IUnknown_QueryInterface(reader, &IID_IWICPersistStream, (void**)&persist);
 199     ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
 200
 201     if (SUCCEEDED(hr))
 202     {
 203         hr = IWICPersistStream_LoadEx(persist, stream, NULL, persist_options);
 204         ok(hr == S_OK, "LoadEx failed, hr=%x\n", hr);
 205
 206         IWICPersistStream_Release(persist);
 207     }
 208
 209     pos.QuadPart = 0;
 210     hr = IStream_Seek(stream, pos, SEEK_CUR, &cur_pos);
 211     ok(hr == S_OK, "IStream_Seek error %#x\n", hr);
 212     /* IFD metadata reader doesn't rewind the stream to the start */
 213     ok(cur_pos.QuadPart == 0 || cur_pos.QuadPart <= data_size,
 214        "current stream pos is at %x/%x, data size %x\n", cur_pos.u.LowPart, cur_pos.u.HighPart, data_size);
 215
 216     IStream_Release(stream);
 217 }
 218
 219 static void test_metadata_unknown(void)
 220 {
 221     HRESULT hr;
 222     IWICMetadataReader *reader;
 223     IWICEnumMetadataItem *enumerator;
 224     IWICMetadataBlockReader *blockreader;
 225     PROPVARIANT schema, id, value;
 226     ULONG items_returned;
 227
 228     hr = CoCreateInstance(&CLSID_WICUnknownMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 229         &IID_IWICMetadataReader, (void**)&reader);
 230     ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 231     if (FAILED(hr)) return;
 232
 233     load_stream((IUnknown*)reader, metadata_unknown, sizeof(metadata_unknown), WICPersistOptionsDefault);
 234
 235     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
 236     ok(hr == S_OK, "GetEnumerator failed, hr=%x\n", hr);
 237
 238     if (SUCCEEDED(hr))
 239     {
 240         PropVariantInit(&schema);
 241         PropVariantInit(&id);
 242         PropVariantInit(&value);
 243
 244         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 245         ok(hr == S_OK, "Next failed, hr=%x\n", hr);
 246         ok(items_returned == 1, "unexpected item count %i\n", items_returned);
 247
 248         if (hr == S_OK && items_returned == 1)
 249         {
 250             ok(schema.vt == VT_EMPTY, "unexpected vt: %i\n", schema.vt);
 251             ok(id.vt == VT_EMPTY, "unexpected vt: %i\n", id.vt);
 252             expect_blob(value, metadata_unknown, sizeof(metadata_unknown));
 253
 254             PropVariantClear(&schema);
 255             PropVariantClear(&id);
 256             PropVariantClear(&value);
 257         }
 258
 259         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 260         ok(hr == S_FALSE, "Next failed, hr=%x\n", hr);
 261         ok(items_returned == 0, "unexpected item count %i\n", items_returned);
 262
 263         IWICEnumMetadataItem_Release(enumerator);
 264     }
 265
 266     hr = IWICMetadataReader_QueryInterface(reader, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 267     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 268
 269     if (SUCCEEDED(hr))
 270         IWICMetadataBlockReader_Release(blockreader);
 271
 272     IWICMetadataReader_Release(reader);
 273 }
 274
 275 static void test_metadata_tEXt(void)
 276 {
 277     HRESULT hr;
 278     IWICMetadataReader *reader;
 279     IWICEnumMetadataItem *enumerator;
 280     PROPVARIANT schema, id, value;
 281     ULONG items_returned, count;
 282     GUID format;
 283
 284     PropVariantInit(&schema);
 285     PropVariantInit(&id);
 286     PropVariantInit(&value);
 287
 288     hr = CoCreateInstance(&CLSID_WICPngTextMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 289         &IID_IWICMetadataReader, (void**)&reader);
 290     todo_wine ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 291     if (FAILED(hr)) return;
 292
 293     hr = IWICMetadataReader_GetCount(reader, NULL);
 294     ok(hr == E_INVALIDARG, "GetCount failed, hr=%x\n", hr);
 295
 296     hr = IWICMetadataReader_GetCount(reader, &count);
 297     ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 298     ok(count == 0, "unexpected count %i\n", count);
 299
 300     load_stream((IUnknown*)reader, metadata_tEXt, sizeof(metadata_tEXt), WICPersistOptionsDefault);
 301
 302     hr = IWICMetadataReader_GetCount(reader, &count);
 303     ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 304     ok(count == 1, "unexpected count %i\n", count);
 305
 306     hr = IWICMetadataReader_GetEnumerator(reader, NULL);
 307     ok(hr == E_INVALIDARG, "GetEnumerator failed, hr=%x\n", hr);
 308
 309     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
 310     ok(hr == S_OK, "GetEnumerator failed, hr=%x\n", hr);
 311
 312     if (SUCCEEDED(hr))
 313     {
 314         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 315         ok(hr == S_OK, "Next failed, hr=%x\n", hr);
 316         ok(items_returned == 1, "unexpected item count %i\n", items_returned);
 317
 318         if (hr == S_OK && items_returned == 1)
 319         {
 320             ok(schema.vt == VT_EMPTY, "unexpected vt: %i\n", schema.vt);
 321             ok(id.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 322             ok(!strcmp(U(id).pszVal, "winetest"), "unexpected id: %s\n", U(id).pszVal);
 323             ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", value.vt);
 324             ok(!strcmp(U(value).pszVal, "value"), "unexpected value: %s\n", U(value).pszVal);
 325
 326             PropVariantClear(&schema);
 327             PropVariantClear(&id);
 328             PropVariantClear(&value);
 329         }
 330
 331         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 332         ok(hr == S_FALSE, "Next failed, hr=%x\n", hr);
 333         ok(items_returned == 0, "unexpected item count %i\n", items_returned);
 334
 335         IWICEnumMetadataItem_Release(enumerator);
 336     }
 337
 338     hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 339     ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
 340     ok(IsEqualGUID(&format, &GUID_MetadataFormatChunktEXt), "unexpected format %s\n", debugstr_guid(&format));
 341
 342     hr = IWICMetadataReader_GetMetadataFormat(reader, NULL);
 343     ok(hr == E_INVALIDARG, "GetMetadataFormat failed, hr=%x\n", hr);
 344
 345     id.vt = VT_LPSTR;
 346     U(id).pszVal = CoTaskMemAlloc(strlen("winetest") + 1);
 347     strcpy(U(id).pszVal, "winetest");
 348
 349     hr = IWICMetadataReader_GetValue(reader, NULL, &id, NULL);
 350     ok(hr == S_OK, "GetValue failed, hr=%x\n", hr);
 351
 352     hr = IWICMetadataReader_GetValue(reader, &schema, NULL, &value);
 353     ok(hr == E_INVALIDARG, "GetValue failed, hr=%x\n", hr);
 354
 355     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 356     ok(hr == S_OK, "GetValue failed, hr=%x\n", hr);
 357     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 358     ok(!strcmp(U(value).pszVal, "value"), "unexpected value: %s\n", U(value).pszVal);
 359     PropVariantClear(&value);
 360
 361     strcpy(U(id).pszVal, "test");
 362
 363     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 364     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "GetValue failed, hr=%x\n", hr);
 365
 366     PropVariantClear(&id);
 367
 368     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, NULL);
 369     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 370
 371     hr = IWICMetadataReader_GetValueByIndex(reader, 0, &schema, NULL, NULL);
 372     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 373     ok(schema.vt == VT_EMPTY, "unexpected vt: %i\n", schema.vt);
 374
 375     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &id, NULL);
 376     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 377     ok(id.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 378     ok(!strcmp(U(id).pszVal, "winetest"), "unexpected id: %s\n", U(id).pszVal);
 379     PropVariantClear(&id);
 380
 381     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, &value);
 382     ok(hr == S_OK, "GetValueByIndex failed, hr=%x\n", hr);
 383     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", value.vt);
 384     ok(!strcmp(U(value).pszVal, "value"), "unexpected value: %s\n", U(value).pszVal);
 385     PropVariantClear(&value);
 386
 387     hr = IWICMetadataReader_GetValueByIndex(reader, 1, NULL, NULL, NULL);
 388     ok(hr == E_INVALIDARG, "GetValueByIndex failed, hr=%x\n", hr);
 389
 390     IWICMetadataReader_Release(reader);
 391 }
 392
 393 static inline USHORT ushort_bswap(USHORT s)
 394 {
 395     return (s >> 8) | (s << 8);
 396 }
 397
 398 static inline ULONG ulong_bswap(ULONG l)
 399 {
 400     return ((ULONG)ushort_bswap((USHORT)l) << 16) | ushort_bswap((USHORT)(l >> 16));
 401 }
 402
 403 static inline ULONGLONG ulonglong_bswap(ULONGLONG ll)
 404 {
 405     return ((ULONGLONG)ulong_bswap((ULONG)ll) << 32) | ulong_bswap((ULONG)(ll >> 32));
 406 }
 407
 408 static void byte_swap_ifd_data(char *data)
 409 {
 410     USHORT number_of_entries, i;
 411     struct IFD_entry *entry;
 412     char *data_start = data;
 413
 414     number_of_entries = *(USHORT *)data;
 415     *(USHORT *)data = ushort_bswap(*(USHORT *)data);
 416     data += sizeof(USHORT);
 417
 418     for (i = 0; i < number_of_entries; i++)
 419     {
 420         entry = (struct IFD_entry *)data;
 421
 422         switch (entry->type)
 423         {
 424         case IFD_BYTE:
 425         case IFD_SBYTE:
 426         case IFD_ASCII:
 427         case IFD_UNDEFINED:
 428             if (entry->count > 4)
 429                 entry->value = ulong_bswap(entry->value);
 430             break;
 431
 432         case IFD_SHORT:
 433         case IFD_SSHORT:
 434             if (entry->count > 2)
 435             {
 436                 ULONG j, count = entry->count;
 437                 USHORT *us = (USHORT *)(data_start + entry->value);
 438                 if (!count) count = 1;
 439                 for (j = 0; j < count; j++)
 440                     us[j] = ushort_bswap(us[j]);
 441
 442                 entry->value = ulong_bswap(entry->value);
 443             }
 444             else
 445             {
 446                 ULONG j, count = entry->count;
 447                 USHORT *us = (USHORT *)&entry->value;
 448                 if (!count) count = 1;
 449                 for (j = 0; j < count; j++)
 450                     us[j] = ushort_bswap(us[j]);
 451             }
 452             break;
 453
 454         case IFD_LONG:
 455         case IFD_SLONG:
 456         case IFD_FLOAT:
 457             if (entry->count > 1)
 458             {
 459                 ULONG j, count = entry->count;
 460                 ULONG *ul = (ULONG *)(data_start + entry->value);
 461                 if (!count) count = 1;
 462                 for (j = 0; j < count; j++)
 463                     ul[j] = ulong_bswap(ul[j]);
 464             }
 465             entry->value = ulong_bswap(entry->value);
 466             break;
 467
 468         case IFD_RATIONAL:
 469         case IFD_SRATIONAL:
 470             {
 471                 ULONG j;
 472                 ULONG *ul = (ULONG *)(data_start + entry->value);
 473                 for (j = 0; j < entry->count * 2; j++)
 474                     ul[j] = ulong_bswap(ul[j]);
 475             }
 476             entry->value = ulong_bswap(entry->value);
 477             break;
 478
 479         case IFD_DOUBLE:
 480             {
 481                 ULONG j;
 482                 ULONGLONG *ull = (ULONGLONG *)(data_start + entry->value);
 483                 for (j = 0; j < entry->count; j++)
 484                     ull[j] = ulonglong_bswap(ull[j]);
 485             }
 486             entry->value = ulong_bswap(entry->value);
 487             break;
 488
 489         default:
 490             assert(0);
 491             break;
 492         }
 493
 494         entry->id = ushort_bswap(entry->id);
 495         entry->type = ushort_bswap(entry->type);
 496         entry->count = ulong_bswap(entry->count);
 497         data += sizeof(*entry);
 498     }
 499 }
 500
 501 struct test_data
 502 {
 503     ULONG type, id;
 504     int count; /* if VT_VECTOR */
 505     LONGLONG value[13];
 506     const char *string;
 507     const WCHAR id_string[32];
 508 };
 509
 510 static void compare_metadata(IWICMetadataReader *reader, const struct test_data *td, ULONG count)
 511 {
 512     HRESULT hr;
 513     IWICEnumMetadataItem *enumerator;
 514     PROPVARIANT schema, id, value;
 515     ULONG items_returned, i;
 516
 517     hr = IWICMetadataReader_GetEnumerator(reader, NULL);
 518     ok(hr == E_INVALIDARG, "GetEnumerator error %#x\n", hr);
 519
 520     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
 521     ok(hr == S_OK, "GetEnumerator error %#x\n", hr);
 522
 523     PropVariantInit(&schema);
 524     PropVariantInit(&id);
 525     PropVariantInit(&value);
 526
 527     for (i = 0; i < count; i++)
 528     {
 529         hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 530         ok(hr == S_OK, "Next error %#x\n", hr);
 531         ok(items_returned == 1, "unexpected item count %u\n", items_returned);
 532
 533         ok(schema.vt == VT_EMPTY, "%u: unexpected vt: %u\n", i, schema.vt);
 534         ok(id.vt == VT_UI2 || id.vt == VT_LPWSTR, "%u: unexpected vt: %u\n", i, id.vt);
 535         if (id.vt == VT_UI2)
 536             ok(U(id).uiVal == td[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, U(id).uiVal);
 537         else if (id.vt == VT_LPWSTR)
 538             ok(!lstrcmpW(td[i].id_string, U(id).pwszVal),
 539                "%u: expected %s, got %s\n", i, wine_dbgstr_w(td[i].id_string), wine_dbgstr_w(U(id).pwszVal));
 540
 541         ok(value.vt == td[i].type, "%u: expected vt %#x, got %#x\n", i, td[i].type, value.vt);
 542         if (value.vt & VT_VECTOR)
 543         {
 544             ULONG j;
 545             switch (value.vt & ~VT_VECTOR)
 546             {
 547             case VT_I1:
 548             case VT_UI1:
 549                 ok(td[i].count == U(value).caub.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caub.cElems);
 550                 for (j = 0; j < U(value).caub.cElems; j++)
 551                     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]);
 552                 break;
 553             case VT_I2:
 554             case VT_UI2:
 555                 ok(td[i].count == U(value).caui.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caui.cElems);
 556                 for (j = 0; j < U(value).caui.cElems; j++)
 557                     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]);
 558                 break;
 559             case VT_I4:
 560             case VT_UI4:
 561             case VT_R4:
 562                 ok(td[i].count == U(value).caul.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caul.cElems);
 563                 for (j = 0; j < U(value).caul.cElems; j++)
 564                     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]);
 565                 break;
 566             case VT_I8:
 567             case VT_UI8:
 568             case VT_R8:
 569                 ok(td[i].count == U(value).cauh.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).cauh.cElems);
 570                 for (j = 0; j < U(value).cauh.cElems; j++)
 571                     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);
 572                 break;
 573             case VT_LPSTR:
 574                 ok(td[i].count == U(value).calpstr.cElems, "%u: expected cElems %d, got %d\n", i, td[i].count, U(value).caub.cElems);
 575                 for (j = 0; j < U(value).calpstr.cElems; j++)
 576                     trace("%u: %s\n", j, U(value).calpstr.pElems[j]);
 577                 /* fall through to not handled message */
 578             default:
 579                 ok(0, "%u: array of type %d is not handled\n", i, value.vt & ~VT_VECTOR);
 580                 break;
 581             }
 582         }
 583         else if (value.vt == VT_LPSTR)
 584         {
 585             ok(td[i].count == strlen(U(value).pszVal) ||
 586                broken(td[i].count == strlen(U(value).pszVal) + 1), /* before Win7 */
 587                "%u: expected count %d, got %d\n", i, td[i].count, lstrlenA(U(value).pszVal));
 588             if (td[i].count == strlen(U(value).pszVal))
 589                 ok(!strcmp(td[i].string, U(value).pszVal),
 590                    "%u: expected %s, got %s\n", i, td[i].string, U(value).pszVal);
 591         }
 592         else if (value.vt == VT_BLOB)
 593         {
 594             ok(td[i].count == U(value).blob.cbSize, "%u: expected count %d, got %d\n", i, td[i].count, U(value).blob.cbSize);
 595             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);
 596         }
 597         else
 598             ok(U(value).uhVal.QuadPart == td[i].value[0], "%u: expected value %#x/%#x got %#x/%#x\n",
 599                i, (UINT)td[i].value[0], (UINT)(td[i].value[0] >> 32), U(value).uhVal.u.LowPart, U(value).uhVal.u.HighPart);
 600
 601         PropVariantClear(&schema);
 602         PropVariantClear(&id);
 603         PropVariantClear(&value);
 604     }
 605
 606     hr = IWICEnumMetadataItem_Next(enumerator, 1, &schema, &id, &value, &items_returned);
 607     ok(hr == S_FALSE, "Next should fail\n");
 608     ok(items_returned == 0, "unexpected item count %u\n", items_returned);
 609
 610     IWICEnumMetadataItem_Release(enumerator);
 611 }
 612
 613 static void test_metadata_IFD(void)
 614 {
 615     static const struct test_data td[28] =
 616     {
 617         { VT_UI2, 0xfe, 0, { 1 } },
 618         { VT_UI4, 0x100, 0, { 222 } },
 619         { VT_UI4, 0x101, 0, { 333 } },
 620         { VT_UI2, 0x102, 0, { 24 } },
 621         { VT_UI4, 0x103, 0, { 32773 } },
 622         { VT_UI8, 0x11a, 0, { ((LONGLONG)3 << 32) | 900 } },
 623         { VT_UI1, 0xf001, 0, { 0x44 } },
 624         { VT_UI1|VT_VECTOR, 0xf002, 4, { 0x44, 0x33, 0x22, 0x11 } },
 625         { VT_I1, 0xf003, 0, { 0x44 } },
 626         { VT_I2, 0xf004, 0, { 0x3344 } },
 627         { VT_I2|VT_VECTOR, 0xf005, 2, { 0x3344, 0x1122 } },
 628         { VT_I4, 0xf006, 0, { 0x11223344 } },
 629         { VT_R4, 0xf007, 0, { 0x11223344 } },
 630         { VT_R8, 0xf008, 0, { ((LONGLONG)0x41d26580 << 32) | 0xb486522c } },
 631         { VT_I8, 0xf009, 0, { ((LONGLONG)0x5a6b7c8d << 32) | 0x1a2b3c4d } },
 632         { VT_UI1|VT_VECTOR, 0xf00a, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
 633         { VT_I2|VT_VECTOR, 0xf00b, 4, { 0x0101, 0x0202, 0x0303, 0x0404 } },
 634         { VT_I4|VT_VECTOR, 0xf00c, 2, { 0x11223344, 0x55667788 } },
 635         { VT_R4|VT_VECTOR, 0xf00d, 2, { 0x449a522b, 0x4608f5ba } },
 636         { VT_LPSTR, 0xf00e, 12, { 0 }, "Hello World!" },
 637         { VT_LPSTR, 0xf00f, 4, { 0 }, "abcd" },
 638         { VT_BLOB, 0xf010, 13, { 0 }, "Hello World!" },
 639         { VT_BLOB, 0xf011, 4, { 0 }, "abcd" },
 640         { VT_UI1, 0xf012, 0, { 0x44 } },
 641         { VT_UI2, 0xf013, 0, { 0x3344 } },
 642         { VT_UI4, 0xf014, 0, { 0x11223344 } },
 643         { VT_R4, 0xf015, 0, { 0x11223344 } },
 644         { VT_I8|VT_VECTOR, 0xf016, 3,
 645           { ((LONGLONG)0x05060708 << 32) | 0x01020304,
 646             ((LONGLONG)0x50607080 << 32) | 0x10203040,
 647             ((LONGLONG)0x55667788 << 32) | 0x11223344 } },
 648     };
 649     HRESULT hr;
 650     IWICMetadataReader *reader;
 651     IWICMetadataBlockReader *blockreader;
 652     PROPVARIANT schema, id, value;
 653     ULONG count;
 654     GUID format;
 655     char *IFD_data_swapped;
 656 #ifdef WORDS_BIGENDIAN
 657     DWORD persist_options = WICPersistOptionsBigEndian;
 658 #else
 659     DWORD persist_options = WICPersistOptionsLittleEndian;
 660 #endif
 661
 662     hr = CoCreateInstance(&CLSID_WICIfdMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 663         &IID_IWICMetadataReader, (void**)&reader);
 664     ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
 665
 666     hr = IWICMetadataReader_GetCount(reader, NULL);
 667     ok(hr == E_INVALIDARG, "GetCount error %#x\n", hr);
 668
 669     hr = IWICMetadataReader_GetCount(reader, &count);
 670     ok(hr == S_OK, "GetCount error %#x\n", hr);
 671     ok(count == 0, "unexpected count %u\n", count);
 672
 673     load_stream((IUnknown*)reader, (const char *)&IFD_data, sizeof(IFD_data), persist_options);
 674
 675     hr = IWICMetadataReader_GetCount(reader, &count);
 676     ok(hr == S_OK, "GetCount error %#x\n", hr);
 677     ok(count == sizeof(td)/sizeof(td[0]), "unexpected count %u\n", count);
 678
 679     compare_metadata(reader, td, count);
 680
 681     /* test IFD data with different endianness */
 682     if (persist_options == WICPersistOptionsLittleEndian)
 683         persist_options = WICPersistOptionsBigEndian;
 684     else
 685         persist_options = WICPersistOptionsLittleEndian;
 686
 687     IFD_data_swapped = HeapAlloc(GetProcessHeap(), 0, sizeof(IFD_data));
 688     memcpy(IFD_data_swapped, &IFD_data, sizeof(IFD_data));
 689     byte_swap_ifd_data(IFD_data_swapped);
 690     load_stream((IUnknown *)reader, IFD_data_swapped, sizeof(IFD_data), persist_options);
 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     compare_metadata(reader, td, count);
 695     HeapFree(GetProcessHeap(), 0, IFD_data_swapped);
 696
 697     hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 698     ok(hr == S_OK, "GetMetadataFormat error %#x\n", hr);
 699     ok(IsEqualGUID(&format, &GUID_MetadataFormatIfd), "unexpected format %s\n", debugstr_guid(&format));
 700
 701     hr = IWICMetadataReader_GetMetadataFormat(reader, NULL);
 702     ok(hr == E_INVALIDARG, "GetMetadataFormat should fail\n");
 703
 704     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, NULL);
 705     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 706
 707     PropVariantInit(&schema);
 708     PropVariantInit(&id);
 709     PropVariantInit(&value);
 710
 711     hr = IWICMetadataReader_GetValueByIndex(reader, count - 1, NULL, NULL, NULL);
 712     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 713
 714     hr = IWICMetadataReader_GetValueByIndex(reader, 0, &schema, NULL, NULL);
 715     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 716     ok(schema.vt == VT_EMPTY, "unexpected vt: %u\n", schema.vt);
 717
 718     hr = IWICMetadataReader_GetValueByIndex(reader, count - 1, &schema, NULL, NULL);
 719     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 720     ok(schema.vt == VT_EMPTY, "unexpected vt: %u\n", schema.vt);
 721
 722     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &id, NULL);
 723     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 724     ok(id.vt == VT_UI2, "unexpected vt: %u\n", id.vt);
 725     ok(U(id).uiVal == 0xfe, "unexpected id: %#x\n", U(id).uiVal);
 726     PropVariantClear(&id);
 727
 728     hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, NULL, &value);
 729     ok(hr == S_OK, "GetValueByIndex error %#x\n", hr);
 730     ok(value.vt == VT_UI2, "unexpected vt: %u\n", value.vt);
 731     ok(U(value).uiVal == 1, "unexpected id: %#x\n", U(value).uiVal);
 732     PropVariantClear(&value);
 733
 734     hr = IWICMetadataReader_GetValueByIndex(reader, count, &schema, NULL, NULL);
 735     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 736
 737     PropVariantInit(&schema);
 738     PropVariantInit(&id);
 739     PropVariantInit(&value);
 740
 741     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 742     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "expected WINCODEC_ERR_PROPERTYNOTFOUND, got %#x\n", hr);
 743
 744     hr = IWICMetadataReader_GetValue(reader, NULL, &id, NULL);
 745     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "expected WINCODEC_ERR_PROPERTYNOTFOUND, got %#x\n", hr);
 746
 747     hr = IWICMetadataReader_GetValue(reader, &schema, NULL, NULL);
 748     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 749
 750     hr = IWICMetadataReader_GetValue(reader, &schema, &id, NULL);
 751     ok(hr == WINCODEC_ERR_PROPERTYNOTFOUND, "expected WINCODEC_ERR_PROPERTYNOTFOUND, got %#x\n", hr);
 752
 753     hr = IWICMetadataReader_GetValue(reader, &schema, NULL, &value);
 754     ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
 755
 756     id.vt = VT_UI2;
 757     U(id).uiVal = 0xf00e;
 758     hr = IWICMetadataReader_GetValue(reader, NULL, &id, NULL);
 759     ok(hr == S_OK, "GetValue error %#x\n", hr);
 760
 761     /* schema is ignored by Ifd metadata reader */
 762     schema.vt = VT_UI4;
 763     U(schema).ulVal = 0xdeadbeef;
 764     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 765     ok(hr == S_OK, "GetValue error %#x\n", hr);
 766     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 767     ok(!strcmp(U(value).pszVal, "Hello World!"), "unexpected value: %s\n", U(value).pszVal);
 768     PropVariantClear(&value);
 769
 770     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
 771     ok(hr == S_OK, "GetValue error %#x\n", hr);
 772     ok(value.vt == VT_LPSTR, "unexpected vt: %i\n", id.vt);
 773     ok(!strcmp(U(value).pszVal, "Hello World!"), "unexpected value: %s\n", U(value).pszVal);
 774     PropVariantClear(&value);
 775
 776     hr = IWICMetadataReader_QueryInterface(reader, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 777     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 778
 779     if (SUCCEEDED(hr))
 780         IWICMetadataBlockReader_Release(blockreader);
 781
 782     IWICMetadataReader_Release(reader);
 783 }
 784
 785 static void test_metadata_Exif(void)
 786 {
 787     HRESULT hr;
 788     IWICMetadataReader *reader;
 789     IWICMetadataBlockReader *blockreader;
 790     UINT count=0;
 791
 792     hr = CoCreateInstance(&CLSID_WICExifMetadataReader, NULL, CLSCTX_INPROC_SERVER,
 793         &IID_IWICMetadataReader, (void**)&reader);
 794     todo_wine ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
 795     if (FAILED(hr)) return;
 796
 797     hr = IWICMetadataReader_GetCount(reader, NULL);
 798     ok(hr == E_INVALIDARG, "GetCount error %#x\n", hr);
 799
 800     hr = IWICMetadataReader_GetCount(reader, &count);
 801     ok(hr == S_OK, "GetCount error %#x\n", hr);
 802     ok(count == 0, "unexpected count %u\n", count);
 803
 804     hr = IWICMetadataReader_QueryInterface(reader, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 805     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 806
 807     if (SUCCEEDED(hr))
 808         IWICMetadataBlockReader_Release(blockreader);
 809
 810     IWICMetadataReader_Release(reader);
 811 }
 812
 813 static void test_create_reader(void)
 814 {
 815     HRESULT hr;
 816     IWICComponentFactory *factory;
 817     IStream *stream;
 818     IWICMetadataReader *reader;
 819     UINT count=0;
 820     GUID format;
 821
 822     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 823         &IID_IWICComponentFactory, (void**)&factory);
 824     ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 825
 826     stream = create_stream(metadata_tEXt, sizeof(metadata_tEXt));
 827
 828     hr = IWICComponentFactory_CreateMetadataReaderFromContainer(factory,
 829         &GUID_ContainerFormatPng, NULL, WICPersistOptionsDefault,
 830         stream, &reader);
 831 todo_wine
 832     ok(hr == S_OK, "CreateMetadataReaderFromContainer failed, hr=%x\n", hr);
 833     if (FAILED(hr)) return;
 834
 835     if (SUCCEEDED(hr))
 836     {
 837         hr = IWICMetadataReader_GetCount(reader, &count);
 838         ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 839         ok(count == 1, "unexpected count %i\n", count);
 840
 841         hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 842         ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
 843         ok(IsEqualGUID(&format, &GUID_MetadataFormatChunktEXt), "unexpected format %s\n", debugstr_guid(&format));
 844
 845         IWICMetadataReader_Release(reader);
 846     }
 847
 848     hr = IWICComponentFactory_CreateMetadataReaderFromContainer(factory,
 849         &GUID_ContainerFormatWmp, NULL, WICPersistOptionsDefault,
 850         stream, &reader);
 851     ok(hr == S_OK, "CreateMetadataReaderFromContainer failed, hr=%x\n", hr);
 852
 853     if (SUCCEEDED(hr))
 854     {
 855         hr = IWICMetadataReader_GetCount(reader, &count);
 856         ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 857         ok(count == 1, "unexpected count %i\n", count);
 858
 859         hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
 860         ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
 861         ok(IsEqualGUID(&format, &GUID_MetadataFormatUnknown), "unexpected format %s\n", debugstr_guid(&format));
 862
 863         IWICMetadataReader_Release(reader);
 864     }
 865
 866     IStream_Release(stream);
 867
 868     IWICComponentFactory_Release(factory);
 869 }
 870
 871 static void test_metadata_png(void)
 872 {
 873     static const struct test_data td[6] =
 874     {
 875         { VT_UI2, 0, 0, { 2005 }, NULL, { 'Y','e','a','r',0 } },
 876         { VT_UI1, 0, 0, { 6 }, NULL, { 'M','o','n','t','h',0 } },
 877         { VT_UI1, 0, 0, { 3 }, NULL, { 'D','a','y',0 } },
 878         { VT_UI1, 0, 0, { 15 }, NULL, { 'H','o','u','r',0 } },
 879         { VT_UI1, 0, 0, { 7 }, NULL, { 'M','i','n','u','t','e',0 } },
 880         { VT_UI1, 0, 0, { 45 }, NULL, { 'S','e','c','o','n','d',0 } }
 881     };
 882     IStream *stream;
 883     IWICBitmapDecoder *decoder;
 884     IWICBitmapFrameDecode *frame;
 885     IWICMetadataBlockReader *blockreader;
 886     IWICMetadataReader *reader;
 887     GUID containerformat;
 888     HRESULT hr;
 889     UINT count;
 890
 891     hr = CoCreateInstance(&CLSID_WICPngDecoder, NULL, CLSCTX_INPROC_SERVER,
 892         &IID_IWICBitmapDecoder, (void**)&decoder);
 893     ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
 894
 895     if (FAILED(hr)) return;
 896
 897     stream = create_stream(pngimage, sizeof(pngimage));
 898
 899     hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
 900     ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
 901
 902     hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 903     ok(hr == E_NOINTERFACE, "QueryInterface failed, hr=%x\n", hr);
 904
 905     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
 906     ok(hr == S_OK, "GetFrame failed, hr=%x\n", hr);
 907
 908     hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void**)&blockreader);
 909     ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
 910
 911     if (SUCCEEDED(hr))
 912     {
 913         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, NULL);
 914         ok(hr == E_INVALIDARG, "GetContainerFormat failed, hr=%x\n", hr);
 915
 916         hr = IWICMetadataBlockReader_GetContainerFormat(blockreader, &containerformat);
 917         ok(hr == S_OK, "GetContainerFormat failed, hr=%x\n", hr);
 918         ok(IsEqualGUID(&containerformat, &GUID_ContainerFormatPng), "unexpected container format\n");
 919
 920         hr = IWICMetadataBlockReader_GetCount(blockreader, NULL);
 921         todo_wine ok(hr == E_INVALIDARG, "GetCount failed, hr=%x\n", hr);
 922
 923         hr = IWICMetadataBlockReader_GetCount(blockreader, &count);
 924         todo_wine ok(hr == S_OK, "GetCount failed, hr=%x\n", hr);
 925         todo_wine ok(count == 1, "unexpected count %d\n", count);
 926
 927         if (0)
 928         {
 929             /* Crashes on Windows XP */
 930             hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, NULL);
 931             ok(hr == E_INVALIDARG, "GetReaderByIndex failed, hr=%x\n", hr);
 932         }
 933
 934         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 0, &reader);
 935         todo_wine ok(hr == S_OK, "GetReaderByIndex failed, hr=%x\n", hr);
 936
 937         if (SUCCEEDED(hr))
 938         {
 939             hr = IWICMetadataReader_GetMetadataFormat(reader, &containerformat);
 940             ok(IsEqualGUID(&containerformat, &GUID_MetadataFormatChunktIME) ||
 941                broken(IsEqualGUID(&containerformat, &GUID_MetadataFormatUnknown)) /* Windows XP */,
 942                "unexpected container format\n");
 943
 944             hr = IWICMetadataReader_GetCount(reader, &count);
 945             ok(hr == S_OK, "GetCount error %#x\n", hr);
 946             ok(count == 6 || broken(count == 1) /* XP */, "expected 6, got %u\n", count);
 947             if (count == 6)
 948                 compare_metadata(reader, td, count);
 949
 950             IWICMetadataReader_Release(reader);
 951         }
 952
 953         hr = IWICMetadataBlockReader_GetReaderByIndex(blockreader, 1, &reader);
 954         todo_wine ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "GetReaderByIndex failed, hr=%x\n", hr);
 955
 956         IWICMetadataBlockReader_Release(blockreader);
 957     }
 958
 959     IWICBitmapFrameDecode_Release(frame);
 960
 961     IWICBitmapDecoder_Release(decoder);
 962
 963     IStream_Release(stream);
 964 }
 965
 966 START_TEST(metadata)
 967 {
 968     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 969
 970     test_metadata_unknown();
 971     test_metadata_tEXt();
 972     test_metadata_IFD();
 973     test_metadata_Exif();
 974     test_create_reader();
 975     test_metadata_png();
 976
 977     CoUninitialize();
 978 }