git.oblomov.eu Git - wine/blob - dlls/windowscodecs/metadatahandler.c

   1 /*
   2  * Copyright 2012 Vincent Povirk for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "wincodec.h"
  29 #include "wincodecsdk.h"
  30
  31 #include "wincodecs_private.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  36
  37 typedef struct MetadataHandler {
  38     IWICMetadataWriter IWICMetadataWriter_iface;
  39     LONG ref;
  40     IWICPersistStream IWICPersistStream_iface;
  41     const MetadataHandlerVtbl *vtable;
  42     MetadataItem *items;
  43     DWORD item_count;
  44     CRITICAL_SECTION lock;
  45 } MetadataHandler;
  46
  47 static inline MetadataHandler *impl_from_IWICMetadataWriter(IWICMetadataWriter *iface)
  48 {
  49     return CONTAINING_RECORD(iface, MetadataHandler, IWICMetadataWriter_iface);
  50 }
  51
  52 static inline MetadataHandler *impl_from_IWICPersistStream(IWICPersistStream *iface)
  53 {
  54     return CONTAINING_RECORD(iface, MetadataHandler, IWICPersistStream_iface);
  55 }
  56
  57 static void MetadataHandler_FreeItems(MetadataHandler *This)
  58 {
  59     int i;
  60
  61     for (i=0; i<This->item_count; i++)
  62     {
  63         PropVariantClear(&This->items[i].schema);
  64         PropVariantClear(&This->items[i].id);
  65         PropVariantClear(&This->items[i].value);
  66     }
  67
  68     HeapFree(GetProcessHeap(), 0, This->items);
  69 }
  70
  71 static HRESULT MetadataHandlerEnum_Create(MetadataHandler *parent, DWORD index,
  72     IWICEnumMetadataItem **ppIEnumMetadataItem);
  73
  74 static HRESULT WINAPI MetadataHandler_QueryInterface(IWICMetadataWriter *iface, REFIID iid,
  75     void **ppv)
  76 {
  77     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
  78     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  79
  80     if (!ppv) return E_INVALIDARG;
  81
  82     if (IsEqualIID(&IID_IUnknown, iid) ||
  83         IsEqualIID(&IID_IWICMetadataReader, iid) ||
  84         (IsEqualIID(&IID_IWICMetadataWriter, iid) && This->vtable->is_writer))
  85     {
  86         *ppv = &This->IWICMetadataWriter_iface;
  87     }
  88     else if (IsEqualIID(&IID_IPersist, iid) ||
  89              IsEqualIID(&IID_IPersistStream, iid) ||
  90              IsEqualIID(&IID_IWICPersistStream, iid))
  91     {
  92         *ppv = &This->IWICPersistStream_iface;
  93     }
  94     else
  95     {
  96         *ppv = NULL;
  97         return E_NOINTERFACE;
  98     }
  99
 100     IUnknown_AddRef((IUnknown*)*ppv);
 101     return S_OK;
 102 }
 103
 104 static ULONG WINAPI MetadataHandler_AddRef(IWICMetadataWriter *iface)
 105 {
 106     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 107     ULONG ref = InterlockedIncrement(&This->ref);
 108
 109     TRACE("(%p) refcount=%u\n", iface, ref);
 110
 111     return ref;
 112 }
 113
 114 static ULONG WINAPI MetadataHandler_Release(IWICMetadataWriter *iface)
 115 {
 116     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 117     ULONG ref = InterlockedDecrement(&This->ref);
 118
 119     TRACE("(%p) refcount=%u\n", iface, ref);
 120
 121     if (ref == 0)
 122     {
 123         MetadataHandler_FreeItems(This);
 124         This->lock.DebugInfo->Spare[0] = 0;
 125         DeleteCriticalSection(&This->lock);
 126         HeapFree(GetProcessHeap(), 0, This);
 127     }
 128
 129     return ref;
 130 }
 131
 132 static HRESULT WINAPI MetadataHandler_GetMetadataFormat(IWICMetadataWriter *iface,
 133     GUID *pguidMetadataFormat)
 134 {
 135     FIXME("(%p,%s): stub\n", iface, debugstr_guid(pguidMetadataFormat));
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI MetadataHandler_GetMetadataHandlerInfo(IWICMetadataWriter *iface,
 140     IWICMetadataHandlerInfo **ppIHandler)
 141 {
 142     FIXME("(%p,%p): stub\n", iface, ppIHandler);
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI MetadataHandler_GetCount(IWICMetadataWriter *iface,
 147     UINT *pcCount)
 148 {
 149     FIXME("(%p,%p): stub\n", iface, pcCount);
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI MetadataHandler_GetValueByIndex(IWICMetadataWriter *iface,
 154     UINT nIndex, PROPVARIANT *pvarSchema, PROPVARIANT *pvarId, PROPVARIANT *pvarValue)
 155 {
 156     FIXME("(%p,%u,%p,%p,%p): stub\n", iface, nIndex, pvarSchema, pvarId, pvarValue);
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI MetadataHandler_GetValue(IWICMetadataWriter *iface,
 161     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, PROPVARIANT *pvarValue)
 162 {
 163     FIXME("(%p,%p,%p,%p): stub\n", iface, pvarSchema, pvarId, pvarValue);
 164     return E_NOTIMPL;
 165 }
 166
 167 static HRESULT WINAPI MetadataHandler_GetEnumerator(IWICMetadataWriter *iface,
 168     IWICEnumMetadataItem **ppIEnumMetadata)
 169 {
 170     MetadataHandler *This = impl_from_IWICMetadataWriter(iface);
 171     TRACE("(%p,%p)\n", iface, ppIEnumMetadata);
 172     return MetadataHandlerEnum_Create(This, 0, ppIEnumMetadata);
 173 }
 174
 175 static HRESULT WINAPI MetadataHandler_SetValue(IWICMetadataWriter *iface,
 176     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, const PROPVARIANT *pvarValue)
 177 {
 178     FIXME("(%p,%p,%p,%p): stub\n", iface, pvarSchema, pvarId, pvarValue);
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI MetadataHandler_SetValueByIndex(IWICMetadataWriter *iface,
 183     UINT nIndex, const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId, const PROPVARIANT *pvarValue)
 184 {
 185     FIXME("(%p,%u,%p,%p,%p): stub\n", iface, nIndex, pvarSchema, pvarId, pvarValue);
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI MetadataHandler_RemoveValue(IWICMetadataWriter *iface,
 190     const PROPVARIANT *pvarSchema, const PROPVARIANT *pvarId)
 191 {
 192     FIXME("(%p,%p,%p): stub\n", iface, pvarSchema, pvarId);
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI MetadataHandler_RemoveValueByIndex(IWICMetadataWriter *iface,
 197     UINT nIndex)
 198 {
 199     FIXME("(%p,%u): stub\n", iface, nIndex);
 200     return E_NOTIMPL;
 201 }
 202
 203 static const IWICMetadataWriterVtbl MetadataHandler_Vtbl = {
 204     MetadataHandler_QueryInterface,
 205     MetadataHandler_AddRef,
 206     MetadataHandler_Release,
 207     MetadataHandler_GetMetadataFormat,
 208     MetadataHandler_GetMetadataHandlerInfo,
 209     MetadataHandler_GetCount,
 210     MetadataHandler_GetValueByIndex,
 211     MetadataHandler_GetValue,
 212     MetadataHandler_GetEnumerator,
 213     MetadataHandler_SetValue,
 214     MetadataHandler_SetValueByIndex,
 215     MetadataHandler_RemoveValue,
 216     MetadataHandler_RemoveValueByIndex
 217 };
 218
 219 static HRESULT WINAPI MetadataHandler_PersistStream_QueryInterface(IWICPersistStream *iface,
 220     REFIID iid, void **ppv)
 221 {
 222     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 223     return IWICMetadataWriter_QueryInterface(&This->IWICMetadataWriter_iface, iid, ppv);
 224 }
 225
 226 static ULONG WINAPI MetadataHandler_PersistStream_AddRef(IWICPersistStream *iface)
 227 {
 228     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 229     return IWICMetadataWriter_AddRef(&This->IWICMetadataWriter_iface);
 230 }
 231
 232 static ULONG WINAPI MetadataHandler_PersistStream_Release(IWICPersistStream *iface)
 233 {
 234     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 235     return IWICMetadataWriter_Release(&This->IWICMetadataWriter_iface);
 236 }
 237
 238 static HRESULT WINAPI MetadataHandler_GetClassID(IWICPersistStream *iface,
 239     CLSID *pClassID)
 240 {
 241     FIXME("(%p,%p): stub\n", iface, pClassID);
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI MetadataHandler_IsDirty(IWICPersistStream *iface)
 246 {
 247     FIXME("(%p): stub\n", iface);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI MetadataHandler_Load(IWICPersistStream *iface,
 252     IStream *pStm)
 253 {
 254     FIXME("(%p,%p): stub\n", iface, pStm);
 255     return E_NOTIMPL;
 256 }
 257
 258 static HRESULT WINAPI MetadataHandler_Save(IWICPersistStream *iface,
 259     IStream *pStm, BOOL fClearDirty)
 260 {
 261     FIXME("(%p,%p,%i): stub\n", iface, pStm, fClearDirty);
 262     return E_NOTIMPL;
 263 }
 264
 265 static HRESULT WINAPI MetadataHandler_GetSizeMax(IWICPersistStream *iface,
 266     ULARGE_INTEGER *pcbSize)
 267 {
 268     FIXME("(%p,%p): stub\n", iface, pcbSize);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI MetadataHandler_LoadEx(IWICPersistStream *iface,
 273     IStream *pIStream, const GUID *pguidPreferredVendor, DWORD dwPersistOptions)
 274 {
 275     MetadataHandler *This = impl_from_IWICPersistStream(iface);
 276     HRESULT hr;
 277     MetadataItem *new_items=NULL;
 278     DWORD item_count=0;
 279
 280     TRACE("(%p,%p,%s,%x)\n", iface, pIStream, debugstr_guid(pguidPreferredVendor), dwPersistOptions);
 281
 282     EnterCriticalSection(&This->lock);
 283
 284     hr = This->vtable->fnLoad(pIStream, pguidPreferredVendor, dwPersistOptions,
 285         &new_items, &item_count);
 286
 287     if (SUCCEEDED(hr))
 288     {
 289         MetadataHandler_FreeItems(This);
 290         This->items = new_items;
 291         This->item_count = item_count;
 292     }
 293
 294     LeaveCriticalSection(&This->lock);
 295
 296     return hr;
 297 }
 298
 299 static HRESULT WINAPI MetadataHandler_SaveEx(IWICPersistStream *iface,
 300     IStream *pIStream, DWORD dwPersistOptions, BOOL fClearDirty)
 301 {
 302     FIXME("(%p,%p,%x,%i): stub\n", iface, pIStream, dwPersistOptions, fClearDirty);
 303     return E_NOTIMPL;
 304 }
 305
 306 static const IWICPersistStreamVtbl MetadataHandler_PersistStream_Vtbl = {
 307     MetadataHandler_PersistStream_QueryInterface,
 308     MetadataHandler_PersistStream_AddRef,
 309     MetadataHandler_PersistStream_Release,
 310     MetadataHandler_GetClassID,
 311     MetadataHandler_IsDirty,
 312     MetadataHandler_Load,
 313     MetadataHandler_Save,
 314     MetadataHandler_GetSizeMax,
 315     MetadataHandler_LoadEx,
 316     MetadataHandler_SaveEx
 317 };
 318
 319 HRESULT MetadataReader_Create(const MetadataHandlerVtbl *vtable, IUnknown *pUnkOuter, REFIID iid, void** ppv)
 320 {
 321     MetadataHandler *This;
 322     HRESULT hr;
 323
 324     TRACE("%s\n", debugstr_guid(vtable->clsid));
 325
 326     *ppv = NULL;
 327
 328     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 329
 330     This = HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandler));
 331     if (!This) return E_OUTOFMEMORY;
 332
 333     This->IWICMetadataWriter_iface.lpVtbl = &MetadataHandler_Vtbl;
 334     This->IWICPersistStream_iface.lpVtbl = &MetadataHandler_PersistStream_Vtbl;
 335     This->ref = 1;
 336     This->vtable = vtable;
 337     This->items = NULL;
 338     This->item_count = 0;
 339
 340     InitializeCriticalSection(&This->lock);
 341     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MetadataHandler.lock");
 342
 343     hr = IWICMetadataWriter_QueryInterface(&This->IWICMetadataWriter_iface, iid, ppv);
 344
 345     IWICMetadataWriter_Release(&This->IWICMetadataWriter_iface);
 346
 347     return hr;
 348 }
 349
 350 typedef struct MetadataHandlerEnum {
 351     IWICEnumMetadataItem IWICEnumMetadataItem_iface;
 352     LONG ref;
 353     MetadataHandler *parent;
 354     DWORD index;
 355 } MetadataHandlerEnum;
 356
 357 static inline MetadataHandlerEnum *impl_from_IWICEnumMetadataItem(IWICEnumMetadataItem *iface)
 358 {
 359     return CONTAINING_RECORD(iface, MetadataHandlerEnum, IWICEnumMetadataItem_iface);
 360 }
 361
 362 static HRESULT WINAPI MetadataHandlerEnum_QueryInterface(IWICEnumMetadataItem *iface, REFIID iid,
 363     void **ppv)
 364 {
 365     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 366     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 367
 368     if (!ppv) return E_INVALIDARG;
 369
 370     if (IsEqualIID(&IID_IUnknown, iid) ||
 371         IsEqualIID(&IID_IWICEnumMetadataItem, iid))
 372     {
 373         *ppv = &This->IWICEnumMetadataItem_iface;
 374     }
 375     else
 376     {
 377         *ppv = NULL;
 378         return E_NOINTERFACE;
 379     }
 380
 381     IUnknown_AddRef((IUnknown*)*ppv);
 382     return S_OK;
 383 }
 384
 385 static ULONG WINAPI MetadataHandlerEnum_AddRef(IWICEnumMetadataItem *iface)
 386 {
 387     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 388     ULONG ref = InterlockedIncrement(&This->ref);
 389
 390     TRACE("(%p) refcount=%u\n", iface, ref);
 391
 392     return ref;
 393 }
 394
 395 static ULONG WINAPI MetadataHandlerEnum_Release(IWICEnumMetadataItem *iface)
 396 {
 397     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 398     ULONG ref = InterlockedDecrement(&This->ref);
 399
 400     TRACE("(%p) refcount=%u\n", iface, ref);
 401
 402     if (ref == 0)
 403     {
 404         IWICMetadataWriter_Release(&This->parent->IWICMetadataWriter_iface);
 405         HeapFree(GetProcessHeap(), 0, This);
 406     }
 407
 408     return ref;
 409 }
 410
 411 static HRESULT WINAPI MetadataHandlerEnum_Next(IWICEnumMetadataItem *iface,
 412     ULONG celt, PROPVARIANT *rgeltSchema, PROPVARIANT *rgeltId,
 413     PROPVARIANT *rgeltValue, ULONG *pceltFetched)
 414 {
 415     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 416     ULONG new_index;
 417     HRESULT hr=S_FALSE;
 418     int i;
 419
 420     TRACE("(%p,%i)\n", iface, celt);
 421
 422     EnterCriticalSection(&This->parent->lock);
 423
 424     if (This->index >= This->parent->item_count)
 425     {
 426         *pceltFetched = 0;
 427         LeaveCriticalSection(&This->parent->lock);
 428         return S_FALSE;
 429     }
 430
 431     new_index = min(This->parent->item_count, This->index + celt);
 432     *pceltFetched = new_index - This->index;
 433
 434     if (rgeltSchema)
 435     {
 436         for (i=0; SUCCEEDED(hr) && i < *pceltFetched; i++)
 437             hr = PropVariantCopy(&rgeltSchema[i], &This->parent->items[i+This->index].schema);
 438     }
 439
 440     for (i=0; SUCCEEDED(hr) && i < *pceltFetched; i++)
 441         hr = PropVariantCopy(&rgeltId[i], &This->parent->items[i+This->index].id);
 442
 443     if (rgeltValue)
 444     {
 445         for (i=0; SUCCEEDED(hr) && i < *pceltFetched; i++)
 446             hr = PropVariantCopy(&rgeltValue[i], &This->parent->items[i+This->index].value);
 447     }
 448
 449     if (SUCCEEDED(hr))
 450     {
 451         This->index = new_index;
 452     }
 453
 454     LeaveCriticalSection(&This->parent->lock);
 455
 456     return hr;
 457 }
 458
 459 static HRESULT WINAPI MetadataHandlerEnum_Skip(IWICEnumMetadataItem *iface,
 460     ULONG celt)
 461 {
 462     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 463
 464     EnterCriticalSection(&This->parent->lock);
 465
 466     This->index += celt;
 467
 468     LeaveCriticalSection(&This->parent->lock);
 469
 470     return S_OK;
 471 }
 472
 473 static HRESULT WINAPI MetadataHandlerEnum_Reset(IWICEnumMetadataItem *iface)
 474 {
 475     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 476
 477     EnterCriticalSection(&This->parent->lock);
 478
 479     This->index = 0;
 480
 481     LeaveCriticalSection(&This->parent->lock);
 482
 483     return S_OK;
 484 }
 485
 486 static HRESULT WINAPI MetadataHandlerEnum_Clone(IWICEnumMetadataItem *iface,
 487     IWICEnumMetadataItem **ppIEnumMetadataItem)
 488 {
 489     MetadataHandlerEnum *This = impl_from_IWICEnumMetadataItem(iface);
 490     HRESULT hr;
 491
 492     EnterCriticalSection(&This->parent->lock);
 493
 494     hr = MetadataHandlerEnum_Create(This->parent, This->index, ppIEnumMetadataItem);
 495
 496     LeaveCriticalSection(&This->parent->lock);
 497
 498     return hr;
 499 }
 500
 501 static const IWICEnumMetadataItemVtbl MetadataHandlerEnum_Vtbl = {
 502     MetadataHandlerEnum_QueryInterface,
 503     MetadataHandlerEnum_AddRef,
 504     MetadataHandlerEnum_Release,
 505     MetadataHandlerEnum_Next,
 506     MetadataHandlerEnum_Skip,
 507     MetadataHandlerEnum_Reset,
 508     MetadataHandlerEnum_Clone
 509 };
 510
 511 static HRESULT MetadataHandlerEnum_Create(MetadataHandler *parent, DWORD index,
 512     IWICEnumMetadataItem **ppIEnumMetadataItem)
 513 {
 514     MetadataHandlerEnum *This;
 515
 516     *ppIEnumMetadataItem = NULL;
 517
 518     This = HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandlerEnum));
 519     if (!This) return E_OUTOFMEMORY;
 520
 521     IWICMetadataWriter_AddRef(&parent->IWICMetadataWriter_iface);
 522
 523     This->IWICEnumMetadataItem_iface.lpVtbl = &MetadataHandlerEnum_Vtbl;
 524     This->ref = 1;
 525     This->parent = parent;
 526     This->index = index;
 527
 528     *ppIEnumMetadataItem = &This->IWICEnumMetadataItem_iface;
 529
 530     return S_OK;
 531 }
 532
 533 static HRESULT LoadUnknownMetadata(IStream *input, const GUID *preferred_vendor,
 534     DWORD persist_options, MetadataItem **items, DWORD *item_count)
 535 {
 536     HRESULT hr;
 537     MetadataItem *result;
 538     STATSTG stat;
 539     BYTE *data;
 540     ULONG bytesread;
 541
 542     TRACE("\n");
 543
 544     hr = IStream_Stat(input, &stat, STATFLAG_NONAME);
 545     if (FAILED(hr))
 546         return hr;
 547
 548     data = HeapAlloc(GetProcessHeap(), 0, stat.cbSize.QuadPart);
 549     if (!data) return E_OUTOFMEMORY;
 550
 551     hr = IStream_Read(input, data, stat.cbSize.QuadPart, &bytesread);
 552     if (FAILED(hr))
 553     {
 554         HeapFree(GetProcessHeap(), 0, data);
 555         return hr;
 556     }
 557
 558     result = HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataItem));
 559     if (FAILED(hr))
 560     {
 561         HeapFree(GetProcessHeap(), 0, data);
 562         return E_OUTOFMEMORY;
 563     }
 564
 565     PropVariantInit(&result[0].schema);
 566     PropVariantInit(&result[0].id);
 567     PropVariantInit(&result[0].value);
 568
 569     result[0].value.vt = VT_BLOB;
 570     result[0].value.blob.cbSize = bytesread;
 571     result[0].value.blob.pBlobData = data;
 572
 573     *items = result;
 574     *item_count = 1;
 575
 576     return S_OK;
 577 }
 578
 579 static const MetadataHandlerVtbl UnknownMetadataReader_Vtbl = {
 580     0,
 581     &CLSID_WICUnknownMetadataReader,
 582     LoadUnknownMetadata
 583 };
 584
 585 HRESULT UnknownMetadataReader_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
 586 {
 587     return MetadataReader_Create(&UnknownMetadataReader_Vtbl, pUnkOuter, iid, ppv);
 588 }