dlls/windowscodecs/metadatahandler.c

   1 /*
   2  * Copyright 2012 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 <stdarg.h>
  21 #include <stdio.h>
  22
  23 #define COBJMACROS
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winternl.h"
  27 #include "objbase.h"
  28 #include "propvarutil.h"
  29
  30 #include "wincodecs_private.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  35
  36 typedef struct MetadataHandler {
  37     IWICMetadataWriter IWICMetadataWriter_iface;
  38     LONG ref;
  39     IWICPersistStream IWICPersistStream_iface;
  40     const MetadataHandlerVtbl *vtable;
  41     MetadataItem *items;
  42     DWORD item_count;
  43     CRITICAL_SECTION lock;
  44 } MetadataHandler;
  45
  46 static inline MetadataHandler *impl_from_IWICMetadataWriter(IWICMetadataWriter *iface)
  47 {
  48     return CONTAINING_RECORD(iface, MetadataHandler, IWICMetadataWriter_iface);
  49 }
  50
  51 static inline MetadataHandler *impl_from_IWICPersistStream(IWICPersistStream *iface)
  52 {
  53     return CONTAINING_RECORD(iface, MetadataHandler, IWICPersistStream_iface);
  54 }
  55
  56 static void MetadataHandler_FreeItems(MetadataHandler *This)
  57 {
  58     DWORD i;
  59
  60     for (i=0; i<This->item_count; i++)
  61     {
  62         PropVariantClear(&This->items[i].schema);
  63         PropVariantClear(&This->items[i].id);
  64         PropVariantClear(&This->items[i].value);
  65     }
  66
  67     free(This->items);
  68 }
  69
  70 static HRESULT MetadataHandlerEnum_Create(MetadataHandler *parent, DWORD index,
  71     IWICEnumMetadataItem **ppIEnumMetadataItem);
  72
  73 static HRESULT WINAPI MetadataHandler_QueryInterface(IWICMetadataWriter *iface, REFIID iid,
  74     void **ppv)
  75 {
  76     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
  77     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  78
  79     if (!ppv) return E_INVALIDARG;
  80
  81     if (IsEqualIID(&IID_IUnknown, iid) ||
  82         IsEqualIID(&IID_IWICMetadataReader, iid) ||
  83         (IsEqualIID(&IID_IWICMetadataWriter, iid) && This->vtable->is_writer))
  84     {
  85         *ppv = &This->IWICMetadataWriter_iface;
  86     }
  87     else if (IsEqualIID(&IID_IPersist, iid) ||
  88              IsEqualIID(&IID_IPersistStream, iid) ||
  89              IsEqualIID(&IID_IWICPersistStream, iid))
  90     {
  91         *ppv = &This->IWICPersistStream_iface;
  92     }
  93     else
  94     {
  95         *ppv = NULL;
  96         return E_NOINTERFACE;
  97     }
  98
  99     IUnknown_AddRef((IUnknown*)*ppv);
 100     return S_OK;
 101 }
 102
 103 static ULONG WINAPI MetadataHandler_AddRef(IWICMetadataWriter *iface)
 104 {
 105     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 106     ULONG ref = InterlockedIncrement(&This->ref);
 107
 108     TRACE("(%p) refcount=%lu\n", iface, ref);
 109
 110     return ref;
 111 }
 112
 113 static ULONG WINAPI MetadataHandler_Release(IWICMetadataWriter *iface)
 114 {
 115     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 116     ULONG ref = InterlockedDecrement(&This->ref);
 117
 118     TRACE("(%p) refcount=%lu\n", iface, ref);
 119
 120     if (ref == 0)
 121     {
 122         MetadataHandler_FreeItems(This);
 123         This->lock.DebugInfo->Spare[0] = 0;
 124         DeleteCriticalSection(&This->lock);
 125         free(This);
 126     }
 127
 128     return ref;
 129 }
 130
 131 static HRESULT WINAPI MetadataHandler_GetMetadataHandlerInfo(IWICMetadataWriter *iface,
 132     IWICMetadataHandlerInfo **ppIHandler)
 133 {
 134     HRESULT hr;
 135     IWICComponentInfo *component_info;
 136     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 137
 138     TRACE("%p,%p\n", iface, ppIHandler);
 139
 140     hr = CreateComponentInfo(This->vtable->clsid, &component_info);
 141     if (FAILED(hr)) return hr;
 142
 143     hr = IWICComponentInfo_QueryInterface(component_info, &IID_IWICMetadataHandlerInfo,
 144         (void **)ppIHandler);
 145
 146     IWICComponentInfo_Release(component_info);
 147     return hr;
 148 }
 149
 150 static HRESULT WINAPI MetadataHandler_GetMetadataFormat(IWICMetadataWriter *iface,
 151     GUID *pguidMetadataFormat)
 152 {
 153     HRESULT hr;
 154     IWICMetadataHandlerInfo *metadata_info;
 155
 156     TRACE("%p,%p\n", iface, pguidMetadataFormat);
 157
 158     if (!pguidMetadataFormat) return E_INVALIDARG;
 159
 160     hr = MetadataHandler_GetMetadataHandlerInfo(iface, &metadata_info);
 161     if (FAILED(hr)) return hr;
 162
 163     hr = IWICMetadataHandlerInfo_GetMetadataFormat(metadata_info, pguidMetadataFormat);
 164     IWICMetadataHandlerInfo_Release(metadata_info);
 165
 166     return hr;
 167 }
 168
 169 static HRESULT WINAPI MetadataHandler_GetCount(IWICMetadataWriter *iface,
 170     UINT *pcCount)
 171 {
 172     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 173
 174     TRACE("%p,%p\n", iface, pcCount);
 175
 176     if (!pcCount) return E_INVALIDARG;
 177
 178     *pcCount = This->item_count;
 179     return S_OK;
 180 }
 181
 182 static HRESULT WINAPI MetadataHandler_GetValueByIndex(IWICMetadataWriter *iface,
 183     UINT index, PROPVARIANT *schema, PROPVARIANT *id, PROPVARIANT *value)
 184 {
 185     HRESULT hr = S_OK;
 186     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 187
 188     TRACE("%p,%u,%p,%p,%p\n", iface, index, schema, id, value);
 189
 190     EnterCriticalSection(&This->lock);
 191
 192     if (index >= This->item_count)
 193     {
 194         LeaveCriticalSection(&This->lock);
 195         return E_INVALIDARG;
 196     }
 197
 198     if (schema)
 199         hr = PropVariantCopy(schema, &This->items[index].schema);
 200
 201     if (SUCCEEDED(hr) && id)
 202         hr = PropVariantCopy(id, &This->items[index].id);
 203
 204     if (SUCCEEDED(hr) && value)
 205         hr = PropVariantCopy(value, &This->items[index].value);
 206
 207     LeaveCriticalSection(&This->lock);
 208     return hr;
 209 }
 210
 211 static HRESULT WINAPI MetadataHandler_GetValue(IWICMetadataWriter *iface,
 212     const PROPVARIANT *schema, const PROPVARIANT *id, PROPVARIANT *value)
 213 {
 214     UINT i;
 215     HRESULT hr = WINCODEC_ERR_PROPERTYNOTFOUND;
 216     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 217
 218     TRACE("(%p,%s,%s,%p)\n", iface, wine_dbgstr_variant((const VARIANT *)schema), wine_dbgstr_variant((const VARIANT *)id), value);
 219
 220     if (!id) return E_INVALIDARG;
 221
 222     EnterCriticalSection(&This->lock);
 223
 224     for (i = 0; i < This->item_count; i++)
 225     {
 226         if (schema && This->items[i].schema.vt != VT_EMPTY)
 227         {
 228             if (PropVariantCompareEx(schema, &This->items[i].schema, 0, PVCF_USESTRCMPI) != 0) continue;
 229         }
 230
 231         if (PropVariantCompareEx(id, &This->items[i].id, 0, PVCF_USESTRCMPI) != 0) continue;
 232
 233         hr = value ? PropVariantCopy(value, &This->items[i].value) : S_OK;
 234         break;
 235     }
 236
 237     LeaveCriticalSection(&This->lock);
 238     return hr;
 239 }
 240
 241 static HRESULT WINAPI MetadataHandler_GetEnumerator(IWICMetadataWriter *iface,
 242     IWICEnumMetadataItem **ppIEnumMetadata)
 243 {
 244     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 245     TRACE("(%p,%p)\n", iface, ppIEnumMetadata);
 246     return MetadataHandlerEnum_Create(This, 0, ppIEnumMetadata);
 247 }
 248
 249 static HRESULT WINAPI MetadataHandler_SetValue(IWICMetadataWriter *iface,
 250     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, const PROPVARIANT *pvarValue)
 251 {
 252     FIXME("(%p,%p,%p,%p): stub\n", iface, pvarSchema, pvarId, pvarValue);
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI MetadataHandler_SetValueByIndex(IWICMetadataWriter *iface,
 257     UINT nIndex, const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, const PROPVARIANT *pvarValue)
 258 {
 259     FIXME("(%p,%u,%p,%p,%p): stub\n", iface, nIndex, pvarSchema, pvarId, pvarValue);
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI MetadataHandler_RemoveValue(IWICMetadataWriter *iface,
 264     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId)
 265 {
 266     FIXME("(%p,%p,%p): stub\n", iface, pvarSchema, pvarId);
 267     return E_NOTIMPL;
 268 }
 269
 270 static HRESULT WINAPI MetadataHandler_RemoveValueByIndex(IWICMetadataWriter *iface,
 271     UINT nIndex)
 272 {
 273     FIXME("(%p,%u): stub\n", iface, nIndex);
 274     return E_NOTIMPL;
 275 }
 276
 277 static const IWICMetadataWriterVtbl MetadataHandler_Vtbl = {
 278     MetadataHandler_QueryInterface,
 279     MetadataHandler_AddRef,
 280     MetadataHandler_Release,
 281     MetadataHandler_GetMetadataFormat,
 282     MetadataHandler_GetMetadataHandlerInfo,
 283     MetadataHandler_GetCount,
 284     MetadataHandler_GetValueByIndex,
 285     MetadataHandler_GetValue,
 286     MetadataHandler_GetEnumerator,
 287     MetadataHandler_SetValue,
 288     MetadataHandler_SetValueByIndex,
 289     MetadataHandler_RemoveValue,
 290     MetadataHandler_RemoveValueByIndex
 291 };
 292
 293 static HRESULT WINAPI MetadataHandler_PersistStream_QueryInterface(IWICPersistStream *iface,
 294     REFIID iid, void **ppv)
 295 {
 296     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 297     return IWICMetadataWriter_QueryInterface(&This->IWICMetadataWriter_iface, iid, ppv);
 298 }
 299
 300 static ULONG WINAPI MetadataHandler_PersistStream_AddRef(IWICPersistStream *iface)
 301 {
 302     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 303     return IWICMetadataWriter_AddRef(&This->IWICMetadataWriter_iface);
 304 }
 305
 306 static ULONG WINAPI MetadataHandler_PersistStream_Release(IWICPersistStream *iface)
 307 {
 308     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 309     return IWICMetadataWriter_Release(&This->IWICMetadataWriter_iface);
 310 }
 311
 312 static HRESULT WINAPI MetadataHandler_GetClassID(IWICPersistStream *iface,
 313     CLSID *pClassID)
 314 {
 315     FIXME("(%p,%p): stub\n", iface, pClassID);
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI MetadataHandler_IsDirty(IWICPersistStream *iface)
 320 {
 321     FIXME("(%p): stub\n", iface);
 322     return E_NOTIMPL;
 323 }
 324
 325 static HRESULT WINAPI MetadataHandler_Load(IWICPersistStream *iface,
 326     IStream *pStm)
 327 {
 328     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 329     TRACE("(%p,%p)\n", iface, pStm);
 330     return IWICPersistStream_LoadEx(&This->IWICPersistStream_iface, pStm, NULL, WICPersistOptionDefault);
 331 }
 332
 333 static HRESULT WINAPI MetadataHandler_Save(IWICPersistStream *iface,
 334     IStream *pStm, BOOL fClearDirty)
 335 {
 336     FIXME("(%p,%p,%i): stub\n", iface, pStm, fClearDirty);
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI MetadataHandler_GetSizeMax(IWICPersistStream *iface,
 341     ULARGE_INTEGER *pcbSize)
 342 {
 343     FIXME("(%p,%p): stub\n", iface, pcbSize);
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI MetadataHandler_LoadEx(IWICPersistStream *iface,
 348     IStream *pIStream, const GUID *pguidPreferredVendor, DWORD dwPersistOptions)
 349 {
 350     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 351     HRESULT hr;
 352     MetadataItem *new_items=NULL;
 353     DWORD item_count=0;
 354
 355     TRACE("(%p,%p,%s,%lx)\n", iface, pIStream, debugstr_guid(pguidPreferredVendor), dwPersistOptions);
 356
 357     EnterCriticalSection(&This->lock);
 358
 359     hr = This->vtable->fnLoad(pIStream, pguidPreferredVendor, dwPersistOptions,
 360         &new_items, &item_count);
 361
 362     if (SUCCEEDED(hr))
 363     {
 364         MetadataHandler_FreeItems(This);
 365         This->items = new_items;
 366         This->item_count = item_count;
 367     }
 368
 369     LeaveCriticalSection(&This->lock);
 370
 371     return hr;
 372 }
 373
 374 static HRESULT WINAPI MetadataHandler_SaveEx(IWICPersistStream *iface,
 375     IStream *pIStream, DWORD dwPersistOptions, BOOL fClearDirty)
 376 {
 377     FIXME("(%p,%p,%lx,%i): stub\n", iface, pIStream, dwPersistOptions, fClearDirty);
 378     return E_NOTIMPL;
 379 }
 380
 381 static const IWICPersistStreamVtbl MetadataHandler_PersistStream_Vtbl = {
 382     MetadataHandler_PersistStream_QueryInterface,
 383     MetadataHandler_PersistStream_AddRef,
 384     MetadataHandler_PersistStream_Release,
 385     MetadataHandler_GetClassID,
 386     MetadataHandler_IsDirty,
 387     MetadataHandler_Load,
 388     MetadataHandler_Save,
 389     MetadataHandler_GetSizeMax,
 390     MetadataHandler_LoadEx,
 391     MetadataHandler_SaveEx
 392 };
 393
 394 HRESULT MetadataReader_Create(const MetadataHandlerVtbl *vtable, REFIID iid, void** ppv)
 395 {
 396     MetadataHandler *This;
 397     HRESULT hr;
 398
 399     TRACE("%s\n", debugstr_guid(vtable->clsid));
 400
 401     *ppv = NULL;
 402
 403     This = malloc(sizeof(MetadataHandler));
 404     if (!This) return E_OUTOFMEMORY;
 405
 406     This->IWICMetadataWriter_iface.lpVtbl = &MetadataHandler_Vtbl;
 407     This->IWICPersistStream_iface.lpVtbl = &MetadataHandler_PersistStream_Vtbl;
 408     This->ref = 1;
 409     This->vtable = vtable;
 410     This->items = NULL;
 411     This->item_count = 0;
 412
 413     InitializeCriticalSectionEx(&This->lock, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
 414     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MetadataHandler.lock");
 415
 416     hr = IWICMetadataWriter_QueryInterface(&This->IWICMetadataWriter_iface, iid, ppv);
 417
 418     IWICMetadataWriter_Release(&This->IWICMetadataWriter_iface);
 419
 420     return hr;
 421 }
 422
 423 typedef struct MetadataHandlerEnum {
 424     IWICEnumMetadataItem IWICEnumMetadataItem_iface;
 425     LONG ref;
 426     MetadataHandler *parent;
 427     DWORD index;
 428 } MetadataHandlerEnum;
 429
 430 static inline MetadataHandlerEnum *impl_from_IWICEnumMetadataItem(IWICEnumMetadataItem *iface)
 431 {
 432     return CONTAINING_RECORD(iface, MetadataHandlerEnum, IWICEnumMetadataItem_iface);
 433 }
 434
 435 static HRESULT WINAPI MetadataHandlerEnum_QueryInterface(IWICEnumMetadataItem *iface, REFIID iid,
 436     void **ppv)
 437 {
 438     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 439     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 440
 441     if (!ppv) return E_INVALIDARG;
 442
 443     if (IsEqualIID(&IID_IUnknown, iid) ||
 444         IsEqualIID(&IID_IWICEnumMetadataItem, iid))
 445     {
 446         *ppv = &This->IWICEnumMetadataItem_iface;
 447     }
 448     else
 449     {
 450         *ppv = NULL;
 451         return E_NOINTERFACE;
 452     }
 453
 454     IUnknown_AddRef((IUnknown*)*ppv);
 455     return S_OK;
 456 }
 457
 458 static ULONG WINAPI MetadataHandlerEnum_AddRef(IWICEnumMetadataItem *iface)
 459 {
 460     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 461     ULONG ref = InterlockedIncrement(&This->ref);
 462
 463     TRACE("(%p) refcount=%lu\n", iface, ref);
 464
 465     return ref;
 466 }
 467
 468 static ULONG WINAPI MetadataHandlerEnum_Release(IWICEnumMetadataItem *iface)
 469 {
 470     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 471     ULONG ref = InterlockedDecrement(&This->ref);
 472
 473     TRACE("(%p) refcount=%lu\n", iface, ref);
 474
 475     if (ref == 0)
 476     {
 477         IWICMetadataWriter_Release(&This->parent->IWICMetadataWriter_iface);
 478         free(This);
 479     }
 480
 481     return ref;
 482 }
 483
 484 static HRESULT WINAPI MetadataHandlerEnum_Next(IWICEnumMetadataItem *iface,
 485     ULONG celt, PROPVARIANT *rgeltSchema, PROPVARIANT *rgeltId,
 486     PROPVARIANT *rgeltValue, ULONG *pceltFetched)
 487 {
 488     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 489     ULONG new_index;
 490     HRESULT hr=S_FALSE;
 491     ULONG i;
 492     ULONG fetched;
 493
 494     TRACE("(%p,%li)\n", iface, celt);
 495
 496     if (!pceltFetched)
 497         pceltFetched = &fetched;
 498
 499     EnterCriticalSection(&This->parent->lock);
 500
 501     if (This->index >= This->parent->item_count)
 502     {
 503         *pceltFetched = 0;
 504         LeaveCriticalSection(&This->parent->lock);
 505         return S_FALSE;
 506     }
 507
 508     new_index = min(This->parent->item_count, This->index + celt);
 509     *pceltFetched = new_index - This->index;
 510
 511     if (rgeltSchema)
 512     {
 513         for (i=0; SUCCEEDED(hr) && i < *pceltFetched; i++)
 514             hr = PropVariantCopy(&rgeltSchema[i], &This->parent->items[i+This->index].schema);
 515     }
 516
 517     for (i=0; SUCCEEDED(hr) && i < *pceltFetched; i++)
 518         hr = PropVariantCopy(&rgeltId[i], &This->parent->items[i+This->index].id);
 519
 520     if (rgeltValue)
 521     {
 522         for (i=0; SUCCEEDED(hr) && i < *pceltFetched; i++)
 523             hr = PropVariantCopy(&rgeltValue[i], &This->parent->items[i+This->index].value);
 524     }
 525
 526     if (SUCCEEDED(hr))
 527     {
 528         This->index = new_index;
 529     }
 530
 531     LeaveCriticalSection(&This->parent->lock);
 532
 533     return hr;
 534 }
 535
 536 static HRESULT WINAPI MetadataHandlerEnum_Skip(IWICEnumMetadataItem *iface,
 537     ULONG celt)
 538 {
 539     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 540
 541     EnterCriticalSection(&This->parent->lock);
 542
 543     This->index += celt;
 544
 545     LeaveCriticalSection(&This->parent->lock);
 546
 547     return S_OK;
 548 }
 549
 550 static HRESULT WINAPI MetadataHandlerEnum_Reset(IWICEnumMetadataItem *iface)
 551 {
 552     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 553
 554     EnterCriticalSection(&This->parent->lock);
 555
 556     This->index = 0;
 557
 558     LeaveCriticalSection(&This->parent->lock);
 559
 560     return S_OK;
 561 }
 562
 563 static HRESULT WINAPI MetadataHandlerEnum_Clone(IWICEnumMetadataItem *iface,
 564     IWICEnumMetadataItem **ppIEnumMetadataItem)
 565 {
 566     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 567     HRESULT hr;
 568
 569     EnterCriticalSection(&This->parent->lock);
 570
 571     hr = MetadataHandlerEnum_Create(This->parent, This->index, ppIEnumMetadataItem);
 572
 573     LeaveCriticalSection(&This->parent->lock);
 574
 575     return hr;
 576 }
 577
 578 static const IWICEnumMetadataItemVtbl MetadataHandlerEnum_Vtbl = {
 579     MetadataHandlerEnum_QueryInterface,
 580     MetadataHandlerEnum_AddRef,
 581     MetadataHandlerEnum_Release,
 582     MetadataHandlerEnum_Next,
 583     MetadataHandlerEnum_Skip,
 584     MetadataHandlerEnum_Reset,
 585     MetadataHandlerEnum_Clone
 586 };
 587
 588 static HRESULT MetadataHandlerEnum_Create(MetadataHandler *parent, DWORD index,
 589     IWICEnumMetadataItem **ppIEnumMetadataItem)
 590 {
 591     MetadataHandlerEnum *This;
 592
 593     if (!ppIEnumMetadataItem) return E_INVALIDARG;
 594
 595     *ppIEnumMetadataItem = NULL;
 596
 597     This = malloc(sizeof(MetadataHandlerEnum));
 598     if (!This) return E_OUTOFMEMORY;
 599
 600     IWICMetadataWriter_AddRef(&parent->IWICMetadataWriter_iface);
 601
 602     This->IWICEnumMetadataItem_iface.lpVtbl = &MetadataHandlerEnum_Vtbl;
 603     This->ref = 1;
 604     This->parent = parent;
 605     This->index = index;
 606
 607     *ppIEnumMetadataItem = &This->IWICEnumMetadataItem_iface;
 608
 609     return S_OK;
 610 }
 611
 612 static HRESULT LoadUnknownMetadata(IStream *input, const GUID *preferred_vendor,
 613     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 614 {
 615     HRESULT hr;
 616     MetadataItem *result;
 617     STATSTG stat;
 618     BYTE *data;
 619     ULONG bytesread;
 620
 621     TRACE("\n");
 622
 623     hr = IStream_Stat(input, &stat, STATFLAG_NONAME);
 624     if (FAILED(hr))
 625         return hr;
 626
 627     data = CoTaskMemAlloc(stat.cbSize.QuadPart);
 628     if (!data) return E_OUTOFMEMORY;
 629
 630     hr = IStream_Read(input, data, stat.cbSize.QuadPart, &bytesread);
 631     if (bytesread != stat.cbSize.QuadPart) hr = E_FAIL;
 632     if (hr != S_OK)
 633     {
 634         CoTaskMemFree(data);
 635         return hr;
 636     }
 637
 638     result = calloc(1, sizeof(MetadataItem));
 639     if (!result)
 640     {
 641         CoTaskMemFree(data);
 642         return E_OUTOFMEMORY;
 643     }
 644
 645     PropVariantInit(&result[0].schema);
 646     PropVariantInit(&result[0].id);
 647     PropVariantInit(&result[0].value);
 648
 649     result[0].value.vt = VT_BLOB;
 650     result[0].value.blob.cbSize = bytesread;
 651     result[0].value.blob.pBlobData = data;
 652
 653     *items = result;
 654     *item_count = 1;
 655
 656     return S_OK;
 657 }
 658
 659 static const MetadataHandlerVtbl UnknownMetadataReader_Vtbl = {
 660     0,
 661     &CLSID_WICUnknownMetadataReader,
 662     LoadUnknownMetadata
 663 };
 664
 665 HRESULT UnknownMetadataReader_CreateInstance(REFIID iid, void** ppv)
 666 {
 667     return MetadataReader_Create(&UnknownMetadataReader_Vtbl, iid, ppv);
 668 }
 669
 670 #define SWAP_USHORT(x) do { if (!native_byte_order) (x) = RtlUshortByteSwap(x); } while(0)
 671 #define SWAP_ULONG(x) do { if (!native_byte_order) (x) = RtlUlongByteSwap(x); } while(0)
 672 #define SWAP_ULONGLONG(x) do { if (!native_byte_order) (x) = RtlUlonglongByteSwap(x); } while(0)
 673
 674 struct IFD_entry
 675 {
 676     SHORT id;
 677     SHORT type;
 678     ULONG count;
 679     LONG  value;
 680 };
 681
 682 #define IFD_BYTE 1
 683 #define IFD_ASCII 2
 684 #define IFD_SHORT 3
 685 #define IFD_LONG 4
 686 #define IFD_RATIONAL 5
 687 #define IFD_SBYTE 6
 688 #define IFD_UNDEFINED 7
 689 #define IFD_SSHORT 8
 690 #define IFD_SLONG 9
 691 #define IFD_SRATIONAL 10
 692 #define IFD_FLOAT 11
 693 #define IFD_DOUBLE 12
 694 #define IFD_IFD 13
 695
 696 static int tag_to_vt(SHORT tag)
 697 {
 698     static const int tag2vt[] =
 699     {
 700         VT_EMPTY, /* 0 */
 701         VT_UI1,   /* IFD_BYTE 1 */
 702         VT_LPSTR, /* IFD_ASCII 2 */
 703         VT_UI2,   /* IFD_SHORT 3 */
 704         VT_UI4,   /* IFD_LONG 4 */
 705         VT_UI8,   /* IFD_RATIONAL 5 */
 706         VT_I1,    /* IFD_SBYTE 6 */
 707         VT_BLOB,  /* IFD_UNDEFINED 7 */
 708         VT_I2,    /* IFD_SSHORT 8 */
 709         VT_I4,    /* IFD_SLONG 9 */
 710         VT_I8,    /* IFD_SRATIONAL 10 */
 711         VT_R4,    /* IFD_FLOAT 11 */
 712         VT_R8,    /* IFD_DOUBLE 12 */
 713         VT_BLOB,  /* IFD_IFD 13 */
 714     };
 715     return (tag > 0 && tag <= 13) ? tag2vt[tag] : VT_BLOB;
 716 }
 717
 718 static HRESULT load_IFD_entry(IStream *input, const struct IFD_entry *entry,
 719                               MetadataItem *item, BOOL native_byte_order)
 720 {
 721     ULONG count, value, i, bytesread;
 722     SHORT type;
 723     LARGE_INTEGER pos;
 724     HRESULT hr;
 725
 726     item->schema.vt = VT_EMPTY;
 727     item->id.vt = VT_UI2;
 728     item->id.uiVal = entry->id;
 729     SWAP_USHORT(item->id.uiVal);
 730
 731     count = entry->count;
 732     SWAP_ULONG(count);
 733     type = entry->type;
 734     SWAP_USHORT(type);
 735     item->value.vt = tag_to_vt(type);
 736     value = entry->value;
 737     SWAP_ULONG(value);
 738
 739     switch (type)
 740     {
 741      case IFD_BYTE:
 742      case IFD_SBYTE:
 743         if (!count) count = 1;
 744
 745         if (count <= 4)
 746         {
 747             const BYTE *data = (const BYTE *)&entry->value;
 748
 749             if (count == 1)
 750                 item->value.bVal = data[0];
 751             else
 752             {
 753                 item->value.vt |= VT_VECTOR;
 754                 item->value.caub.cElems = count;
 755                 item->value.caub.pElems = CoTaskMemAlloc(count);
 756                 memcpy(item->value.caub.pElems, data, count);
 757             }
 758             break;
 759         }
 760
 761         item->value.vt |= VT_VECTOR;
 762         item->value.caub.cElems = count;
 763         item->value.caub.pElems = CoTaskMemAlloc(count);
 764         if (!item->value.caub.pElems) return E_OUTOFMEMORY;
 765
 766         pos.QuadPart = value;
 767         hr = IStream_Seek(input, pos, SEEK_SET, NULL);
 768         if (FAILED(hr))
 769         {
 770             CoTaskMemFree(item->value.caub.pElems);
 771             return hr;
 772         }
 773         hr = IStream_Read(input, item->value.caub.pElems, count, &bytesread);
 774         if (bytesread != count) hr = E_FAIL;
 775         if (hr != S_OK)
 776         {
 777             CoTaskMemFree(item->value.caub.pElems);
 778             return hr;
 779         }
 780         break;
 781     case IFD_SHORT:
 782     case IFD_SSHORT:
 783         if (!count) count = 1;
 784
 785         if (count <= 2)
 786         {
 787             const SHORT *data = (const SHORT *)&entry->value;
 788
 789             if (count == 1)
 790             {
 791                 item->value.uiVal = data[0];
 792                 SWAP_USHORT(item->value.uiVal);
 793             }
 794             else
 795             {
 796                 item->value.vt |= VT_VECTOR;
 797                 item->value.caui.cElems = count;
 798                 item->value.caui.pElems = CoTaskMemAlloc(count * 2);
 799                 memcpy(item->value.caui.pElems, data, count * 2);
 800                 for (i = 0; i < count; i++)
 801                     SWAP_USHORT(item->value.caui.pElems[i]);
 802             }
 803             break;
 804         }
 805
 806         item->value.vt |= VT_VECTOR;
 807         item->value.caui.cElems = count;
 808         item->value.caui.pElems = CoTaskMemAlloc(count * 2);
 809         if (!item->value.caui.pElems) return E_OUTOFMEMORY;
 810
 811         pos.QuadPart = value;
 812         hr = IStream_Seek(input, pos, SEEK_SET, NULL);
 813         if (FAILED(hr))
 814         {
 815             CoTaskMemFree(item->value.caui.pElems);
 816             return hr;
 817         }
 818         hr = IStream_Read(input, item->value.caui.pElems, count * 2, &bytesread);
 819         if (bytesread != count * 2) hr = E_FAIL;
 820         if (hr != S_OK)
 821         {
 822             CoTaskMemFree(item->value.caui.pElems);
 823             return hr;
 824         }
 825         for (i = 0; i < count; i++)
 826             SWAP_USHORT(item->value.caui.pElems[i]);
 827         break;
 828     case IFD_LONG:
 829     case IFD_SLONG:
 830     case IFD_FLOAT:
 831         if (!count) count = 1;
 832
 833         if (count == 1)
 834         {
 835             item->value.ulVal = value;
 836             break;
 837         }
 838
 839         item->value.vt |= VT_VECTOR;
 840         item->value.caul.cElems = count;
 841         item->value.caul.pElems = CoTaskMemAlloc(count * 4);
 842         if (!item->value.caul.pElems) return E_OUTOFMEMORY;
 843
 844         pos.QuadPart = value;
 845         hr = IStream_Seek(input, pos, SEEK_SET, NULL);
 846         if (FAILED(hr))
 847         {
 848             CoTaskMemFree(item->value.caul.pElems);
 849             return hr;
 850         }
 851         hr = IStream_Read(input, item->value.caul.pElems, count * 4, &bytesread);
 852         if (bytesread != count * 4) hr = E_FAIL;
 853         if (hr != S_OK)
 854         {
 855             CoTaskMemFree(item->value.caul.pElems);
 856             return hr;
 857         }
 858         for (i = 0; i < count; i++)
 859             SWAP_ULONG(item->value.caul.pElems[i]);
 860         break;
 861     case IFD_RATIONAL:
 862     case IFD_SRATIONAL:
 863     case IFD_DOUBLE:
 864         if (!count)
 865         {
 866             FIXME("IFD field type %d, count 0\n", type);
 867             item->value.vt = VT_EMPTY;
 868             break;
 869         }
 870
 871         if (count == 1)
 872         {
 873             ULONGLONG ull;
 874
 875             pos.QuadPart = value;
 876             hr = IStream_Seek(input, pos, SEEK_SET, NULL);
 877             if (FAILED(hr)) return hr;
 878
 879             hr = IStream_Read(input, &ull, sizeof(ull), &bytesread);
 880             if (bytesread != sizeof(ull)) hr = E_FAIL;
 881             if (hr != S_OK) return hr;
 882
 883             item->value.uhVal.QuadPart = ull;
 884
 885             if (type == IFD_DOUBLE)
 886                 SWAP_ULONGLONG(item->value.uhVal.QuadPart);
 887             else
 888             {
 889                 SWAP_ULONG(item->value.uhVal.LowPart);
 890                 SWAP_ULONG(item->value.uhVal.HighPart);
 891             }
 892             break;
 893         }
 894         else
 895         {
 896             item->value.vt |= VT_VECTOR;
 897             item->value.cauh.cElems = count;
 898             item->value.cauh.pElems = CoTaskMemAlloc(count * 8);
 899             if (!item->value.cauh.pElems) return E_OUTOFMEMORY;
 900
 901             pos.QuadPart = value;
 902             hr = IStream_Seek(input, pos, SEEK_SET, NULL);
 903             if (FAILED(hr))
 904             {
 905                 CoTaskMemFree(item->value.cauh.pElems);
 906                 return hr;
 907             }
 908             hr = IStream_Read(input, item->value.cauh.pElems, count * 8, &bytesread);
 909             if (bytesread != count * 8) hr = E_FAIL;
 910             if (hr != S_OK)
 911             {
 912                 CoTaskMemFree(item->value.cauh.pElems);
 913                 return hr;
 914             }
 915             for (i = 0; i < count; i++)
 916             {
 917                 if (type == IFD_DOUBLE)
 918                     SWAP_ULONGLONG(item->value.cauh.pElems[i].QuadPart);
 919                 else
 920                 {
 921                     SWAP_ULONG(item->value.cauh.pElems[i].LowPart);
 922                     SWAP_ULONG(item->value.cauh.pElems[i].HighPart);
 923                 }
 924             }
 925         }
 926         break;
 927     case IFD_ASCII:
 928         item->value.pszVal = CoTaskMemAlloc(count + 1);
 929         if (!item->value.pszVal) return E_OUTOFMEMORY;
 930
 931         if (count <= 4)
 932         {
 933             const char *data = (const char *)&entry->value;
 934             memcpy(item->value.pszVal, data, count);
 935             item->value.pszVal[count] = 0;
 936             break;
 937         }
 938
 939         pos.QuadPart = value;
 940         hr = IStream_Seek(input, pos, SEEK_SET, NULL);
 941         if (FAILED(hr))
 942         {
 943             CoTaskMemFree(item->value.pszVal);
 944             return hr;
 945         }
 946         hr = IStream_Read(input, item->value.pszVal, count, &bytesread);
 947         if (bytesread != count) hr = E_FAIL;
 948         if (hr != S_OK)
 949         {
 950             CoTaskMemFree(item->value.pszVal);
 951             return hr;
 952         }
 953         item->value.pszVal[count] = 0;
 954         break;
 955     case IFD_UNDEFINED:
 956         if (!count)
 957         {
 958             FIXME("IFD field type %d, count 0\n", type);
 959             item->value.vt = VT_EMPTY;
 960             break;
 961         }
 962
 963         item->value.blob.pBlobData = CoTaskMemAlloc(count);
 964         if (!item->value.blob.pBlobData) return E_OUTOFMEMORY;
 965
 966         item->value.blob.cbSize = count;
 967
 968         if (count <= 4)
 969         {
 970             const char *data = (const char *)&entry->value;
 971             memcpy(item->value.blob.pBlobData, data, count);
 972             break;
 973         }
 974
 975         pos.QuadPart = value;
 976         hr = IStream_Seek(input, pos, SEEK_SET, NULL);
 977         if (FAILED(hr))
 978         {
 979             CoTaskMemFree(item->value.blob.pBlobData);
 980             return hr;
 981         }
 982         hr = IStream_Read(input, item->value.blob.pBlobData, count, &bytesread);
 983         if (bytesread != count) hr = E_FAIL;
 984         if (hr != S_OK)
 985         {
 986             CoTaskMemFree(item->value.blob.pBlobData);
 987             return hr;
 988         }
 989         break;
 990     default:
 991         FIXME("loading field of type %d, count %lu is not implemented\n", type, count);
 992         break;
 993     }
 994     return S_OK;
 995 }
 996
 997 static HRESULT LoadIfdMetadata(IStream *input, const GUID *preferred_vendor,
 998     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 999 {
1000     HRESULT hr;
1001     MetadataItem *result;
1002     USHORT count, i;
1003     struct IFD_entry *entry;
1004     BOOL native_byte_order = TRUE;
1005     ULONG bytesread;
1006
1007     TRACE("\n");
1008
1009 #ifdef WORDS_BIGENDIAN
1010     if (persist_options & WICPersistOptionLittleEndian)
1011 #else
1012     if (persist_options & WICPersistOptionBigEndian)
1013 #endif
1014         native_byte_order = FALSE;
1015
1016     hr = IStream_Read(input, &count, sizeof(count), &bytesread);
1017     if (bytesread != sizeof(count)) hr = E_FAIL;
1018     if (hr != S_OK) return hr;
1019
1020     SWAP_USHORT(count);
1021
1022     entry = malloc(count * sizeof(*entry));
1023     if (!entry) return E_OUTOFMEMORY;
1024
1025     hr = IStream_Read(input, entry, count * sizeof(*entry), &bytesread);
1026     if (bytesread != count * sizeof(*entry)) hr = E_FAIL;
1027     if (hr != S_OK)
1028     {
1029         free(entry);
1030         return hr;
1031     }
1032
1033     /* limit number of IFDs to 4096 to avoid infinite loop */
1034     for (i = 0; i < 4096; i++)
1035     {
1036         ULONG next_ifd_offset;
1037         LARGE_INTEGER pos;
1038         USHORT next_ifd_count;
1039
1040         hr = IStream_Read(input, &next_ifd_offset, sizeof(next_ifd_offset), &bytesread);
1041         if (bytesread != sizeof(next_ifd_offset)) hr = E_FAIL;
1042         if (hr != S_OK) break;
1043
1044         SWAP_ULONG(next_ifd_offset);
1045         if (!next_ifd_offset) break;
1046
1047         pos.QuadPart = next_ifd_offset;
1048         hr = IStream_Seek(input, pos, SEEK_SET, NULL);
1049         if (FAILED(hr)) break;
1050
1051         hr = IStream_Read(input, &next_ifd_count, sizeof(next_ifd_count), &bytesread);
1052         if (bytesread != sizeof(next_ifd_count)) hr = E_FAIL;
1053         if (hr != S_OK) break;
1054
1055         SWAP_USHORT(next_ifd_count);
1056
1057         pos.QuadPart = next_ifd_count * sizeof(*entry);
1058         hr = IStream_Seek(input, pos, SEEK_CUR, NULL);
1059         if (FAILED(hr)) break;
1060     }
1061
1062     if (hr != S_OK || i == 4096)
1063     {
1064         free(entry);
1065         return WINCODEC_ERR_BADMETADATAHEADER;
1066     }
1067
1068     result = calloc(count, sizeof(*result));
1069     if (!result)
1070     {
1071         free(entry);
1072         return E_OUTOFMEMORY;
1073     }
1074
1075     for (i = 0; i < count; i++)
1076     {
1077         hr = load_IFD_entry(input, &entry[i], &result[i], native_byte_order);
1078         if (FAILED(hr))
1079         {
1080             free(entry);
1081             free(result);
1082             return hr;
1083         }
1084     }
1085
1086     free(entry);
1087
1088     *items = result;
1089     *item_count = count;
1090
1091     return S_OK;
1092 }
1093
1094 static const MetadataHandlerVtbl IfdMetadataReader_Vtbl = {
1095     0,
1096     &CLSID_WICIfdMetadataReader,
1097     LoadIfdMetadata
1098 };
1099
1100 HRESULT IfdMetadataReader_CreateInstance(REFIID iid, void **ppv)
1101 {
1102     return MetadataReader_Create(&IfdMetadataReader_Vtbl, iid, ppv);
1103 }