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