2 * Copyright 2012 Vincent Povirk for CodeWeavers
3 * Copyright 2012 Dmitry Timoshkov
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.
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.
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
20 #define WIN32_NO_STATUS
22 #define COM_NO_WINDOWS_H
30 #define NONAMELESSUNION
36 //#include "wincodec.h"
37 #include <wincodecsdk.h>
39 #include "wincodecs_private.h"
41 #include <wine/debug.h>
43 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs
);
45 typedef struct MetadataHandler
{
46 IWICMetadataWriter IWICMetadataWriter_iface
;
48 IWICPersistStream IWICPersistStream_iface
;
49 const MetadataHandlerVtbl
*vtable
;
52 CRITICAL_SECTION lock
;
55 static inline MetadataHandler
*impl_from_IWICMetadataWriter(IWICMetadataWriter
*iface
)
57 return CONTAINING_RECORD(iface
, MetadataHandler
, IWICMetadataWriter_iface
);
60 static inline MetadataHandler
*impl_from_IWICPersistStream(IWICPersistStream
*iface
)
62 return CONTAINING_RECORD(iface
, MetadataHandler
, IWICPersistStream_iface
);
65 static void MetadataHandler_FreeItems(MetadataHandler
*This
)
69 for (i
=0; i
<This
->item_count
; i
++)
71 PropVariantClear(&This
->items
[i
].schema
);
72 PropVariantClear(&This
->items
[i
].id
);
73 PropVariantClear(&This
->items
[i
].value
);
76 HeapFree(GetProcessHeap(), 0, This
->items
);
79 static HRESULT
MetadataHandlerEnum_Create(MetadataHandler
*parent
, DWORD index
,
80 IWICEnumMetadataItem
**ppIEnumMetadataItem
);
82 static HRESULT WINAPI
MetadataHandler_QueryInterface(IWICMetadataWriter
*iface
, REFIID iid
,
85 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
86 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
88 if (!ppv
) return E_INVALIDARG
;
90 if (IsEqualIID(&IID_IUnknown
, iid
) ||
91 IsEqualIID(&IID_IWICMetadataReader
, iid
) ||
92 (IsEqualIID(&IID_IWICMetadataWriter
, iid
) && This
->vtable
->is_writer
))
94 *ppv
= &This
->IWICMetadataWriter_iface
;
96 else if (IsEqualIID(&IID_IPersist
, iid
) ||
97 IsEqualIID(&IID_IPersistStream
, iid
) ||
98 IsEqualIID(&IID_IWICPersistStream
, iid
))
100 *ppv
= &This
->IWICPersistStream_iface
;
105 return E_NOINTERFACE
;
108 IUnknown_AddRef((IUnknown
*)*ppv
);
112 static ULONG WINAPI
MetadataHandler_AddRef(IWICMetadataWriter
*iface
)
114 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
115 ULONG ref
= InterlockedIncrement(&This
->ref
);
117 TRACE("(%p) refcount=%u\n", iface
, ref
);
122 static ULONG WINAPI
MetadataHandler_Release(IWICMetadataWriter
*iface
)
124 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
125 ULONG ref
= InterlockedDecrement(&This
->ref
);
127 TRACE("(%p) refcount=%u\n", iface
, ref
);
131 MetadataHandler_FreeItems(This
);
132 This
->lock
.DebugInfo
->Spare
[0] = 0;
133 DeleteCriticalSection(&This
->lock
);
134 HeapFree(GetProcessHeap(), 0, This
);
140 static HRESULT WINAPI
MetadataHandler_GetMetadataHandlerInfo(IWICMetadataWriter
*iface
,
141 IWICMetadataHandlerInfo
**ppIHandler
)
144 IWICComponentInfo
*component_info
;
145 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
147 TRACE("%p,%p\n", iface
, ppIHandler
);
149 hr
= CreateComponentInfo(This
->vtable
->clsid
, &component_info
);
150 if (FAILED(hr
)) return hr
;
152 hr
= IWICComponentInfo_QueryInterface(component_info
, &IID_IWICMetadataHandlerInfo
,
153 (void **)ppIHandler
);
155 IWICComponentInfo_Release(component_info
);
159 static HRESULT WINAPI
MetadataHandler_GetMetadataFormat(IWICMetadataWriter
*iface
,
160 GUID
*pguidMetadataFormat
)
163 IWICMetadataHandlerInfo
*metadata_info
;
165 TRACE("%p,%p\n", iface
, pguidMetadataFormat
);
167 if (!pguidMetadataFormat
) return E_INVALIDARG
;
169 hr
= MetadataHandler_GetMetadataHandlerInfo(iface
, &metadata_info
);
170 if (FAILED(hr
)) return hr
;
172 hr
= IWICMetadataHandlerInfo_GetMetadataFormat(metadata_info
, pguidMetadataFormat
);
173 IWICMetadataHandlerInfo_Release(metadata_info
);
178 static HRESULT WINAPI
MetadataHandler_GetCount(IWICMetadataWriter
*iface
,
181 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
183 TRACE("%p,%p\n", iface
, pcCount
);
185 if (!pcCount
) return E_INVALIDARG
;
187 *pcCount
= This
->item_count
;
191 static HRESULT WINAPI
MetadataHandler_GetValueByIndex(IWICMetadataWriter
*iface
,
192 UINT index
, PROPVARIANT
*schema
, PROPVARIANT
*id
, PROPVARIANT
*value
)
195 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
197 TRACE("%p,%u,%p,%p,%p\n", iface
, index
, schema
, id
, value
);
199 EnterCriticalSection(&This
->lock
);
201 if (index
>= This
->item_count
)
203 LeaveCriticalSection(&This
->lock
);
208 hr
= PropVariantCopy(schema
, &This
->items
[index
].schema
);
210 if (SUCCEEDED(hr
) && id
)
211 hr
= PropVariantCopy(id
, &This
->items
[index
].id
);
213 if (SUCCEEDED(hr
) && value
)
214 hr
= PropVariantCopy(value
, &This
->items
[index
].value
);
216 LeaveCriticalSection(&This
->lock
);
220 static BOOL
get_int_value(const PROPVARIANT
*pv
, LONGLONG
*value
)
238 *value
= pv
->u
.uiVal
;
244 *value
= pv
->u
.ulVal
;
248 *value
= pv
->u
.hVal
.QuadPart
;
251 FIXME("not supported variant type %d\n", pv
->vt
);
257 /* FiXME: Use propsys.PropVariantCompareEx once it's implemented */
258 static int propvar_cmp(const PROPVARIANT
*v1
, const PROPVARIANT
*v2
)
260 LONGLONG value1
, value2
;
262 if (v1
->vt
== VT_LPSTR
&& v2
->vt
== VT_LPSTR
)
264 return lstrcmpA(v1
->u
.pszVal
, v2
->u
.pszVal
);
267 if (v1
->vt
== VT_LPWSTR
&& v2
->vt
== VT_LPWSTR
)
269 return lstrcmpiW(v1
->u
.pwszVal
, v2
->u
.pwszVal
);
272 if (!get_int_value(v1
, &value1
)) return -1;
273 if (!get_int_value(v2
, &value2
)) return -1;
276 if (value1
) return value1
< 0 ? -1 : 1;
280 static HRESULT WINAPI
MetadataHandler_GetValue(IWICMetadataWriter
*iface
,
281 const PROPVARIANT
*schema
, const PROPVARIANT
*id
, PROPVARIANT
*value
)
284 HRESULT hr
= WINCODEC_ERR_PROPERTYNOTFOUND
;
285 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
287 TRACE("(%p,%p,%p,%p)\n", iface
, schema
, id
, value
);
289 if (!id
) return E_INVALIDARG
;
291 EnterCriticalSection(&This
->lock
);
293 for (i
= 0; i
< This
->item_count
; i
++)
295 if (schema
&& This
->items
[i
].schema
.vt
!= VT_EMPTY
)
297 if (propvar_cmp(schema
, &This
->items
[i
].schema
) != 0) continue;
300 if (propvar_cmp(id
, &This
->items
[i
].id
) != 0) continue;
302 hr
= value
? PropVariantCopy(value
, &This
->items
[i
].value
) : S_OK
;
306 LeaveCriticalSection(&This
->lock
);
310 static HRESULT WINAPI
MetadataHandler_GetEnumerator(IWICMetadataWriter
*iface
,
311 IWICEnumMetadataItem
**ppIEnumMetadata
)
313 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
314 TRACE("(%p,%p)\n", iface
, ppIEnumMetadata
);
315 return MetadataHandlerEnum_Create(This
, 0, ppIEnumMetadata
);
318 static HRESULT WINAPI
MetadataHandler_SetValue(IWICMetadataWriter
*iface
,
319 const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
, const PROPVARIANT
*pvarValue
)
321 FIXME("(%p,%p,%p,%p): stub\n", iface
, pvarSchema
, pvarId
, pvarValue
);
325 static HRESULT WINAPI
MetadataHandler_SetValueByIndex(IWICMetadataWriter
*iface
,
326 UINT nIndex
, const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
, const PROPVARIANT
*pvarValue
)
328 FIXME("(%p,%u,%p,%p,%p): stub\n", iface
, nIndex
, pvarSchema
, pvarId
, pvarValue
);
332 static HRESULT WINAPI
MetadataHandler_RemoveValue(IWICMetadataWriter
*iface
,
333 const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
)
335 FIXME("(%p,%p,%p): stub\n", iface
, pvarSchema
, pvarId
);
339 static HRESULT WINAPI
MetadataHandler_RemoveValueByIndex(IWICMetadataWriter
*iface
,
342 FIXME("(%p,%u): stub\n", iface
, nIndex
);
346 static const IWICMetadataWriterVtbl MetadataHandler_Vtbl
= {
347 MetadataHandler_QueryInterface
,
348 MetadataHandler_AddRef
,
349 MetadataHandler_Release
,
350 MetadataHandler_GetMetadataFormat
,
351 MetadataHandler_GetMetadataHandlerInfo
,
352 MetadataHandler_GetCount
,
353 MetadataHandler_GetValueByIndex
,
354 MetadataHandler_GetValue
,
355 MetadataHandler_GetEnumerator
,
356 MetadataHandler_SetValue
,
357 MetadataHandler_SetValueByIndex
,
358 MetadataHandler_RemoveValue
,
359 MetadataHandler_RemoveValueByIndex
362 static HRESULT WINAPI
MetadataHandler_PersistStream_QueryInterface(IWICPersistStream
*iface
,
363 REFIID iid
, void **ppv
)
365 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
366 return IWICMetadataWriter_QueryInterface(&This
->IWICMetadataWriter_iface
, iid
, ppv
);
369 static ULONG WINAPI
MetadataHandler_PersistStream_AddRef(IWICPersistStream
*iface
)
371 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
372 return IWICMetadataWriter_AddRef(&This
->IWICMetadataWriter_iface
);
375 static ULONG WINAPI
MetadataHandler_PersistStream_Release(IWICPersistStream
*iface
)
377 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
378 return IWICMetadataWriter_Release(&This
->IWICMetadataWriter_iface
);
381 static HRESULT WINAPI
MetadataHandler_GetClassID(IWICPersistStream
*iface
,
384 FIXME("(%p,%p): stub\n", iface
, pClassID
);
388 static HRESULT WINAPI
MetadataHandler_IsDirty(IWICPersistStream
*iface
)
390 FIXME("(%p): stub\n", iface
);
394 static HRESULT WINAPI
MetadataHandler_Load(IWICPersistStream
*iface
,
397 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
398 TRACE("(%p,%p)\n", iface
, pStm
);
399 return IWICPersistStream_LoadEx(&This
->IWICPersistStream_iface
, pStm
, NULL
, WICPersistOptionsDefault
);
402 static HRESULT WINAPI
MetadataHandler_Save(IWICPersistStream
*iface
,
403 IStream
*pStm
, BOOL fClearDirty
)
405 FIXME("(%p,%p,%i): stub\n", iface
, pStm
, fClearDirty
);
409 static HRESULT WINAPI
MetadataHandler_GetSizeMax(IWICPersistStream
*iface
,
410 ULARGE_INTEGER
*pcbSize
)
412 FIXME("(%p,%p): stub\n", iface
, pcbSize
);
416 static HRESULT WINAPI
MetadataHandler_LoadEx(IWICPersistStream
*iface
,
417 IStream
*pIStream
, const GUID
*pguidPreferredVendor
, DWORD dwPersistOptions
)
419 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
421 MetadataItem
*new_items
=NULL
;
424 TRACE("(%p,%p,%s,%x)\n", iface
, pIStream
, debugstr_guid(pguidPreferredVendor
), dwPersistOptions
);
426 EnterCriticalSection(&This
->lock
);
428 hr
= This
->vtable
->fnLoad(pIStream
, pguidPreferredVendor
, dwPersistOptions
,
429 &new_items
, &item_count
);
433 MetadataHandler_FreeItems(This
);
434 This
->items
= new_items
;
435 This
->item_count
= item_count
;
438 LeaveCriticalSection(&This
->lock
);
443 static HRESULT WINAPI
MetadataHandler_SaveEx(IWICPersistStream
*iface
,
444 IStream
*pIStream
, DWORD dwPersistOptions
, BOOL fClearDirty
)
446 FIXME("(%p,%p,%x,%i): stub\n", iface
, pIStream
, dwPersistOptions
, fClearDirty
);
450 static const IWICPersistStreamVtbl MetadataHandler_PersistStream_Vtbl
= {
451 MetadataHandler_PersistStream_QueryInterface
,
452 MetadataHandler_PersistStream_AddRef
,
453 MetadataHandler_PersistStream_Release
,
454 MetadataHandler_GetClassID
,
455 MetadataHandler_IsDirty
,
456 MetadataHandler_Load
,
457 MetadataHandler_Save
,
458 MetadataHandler_GetSizeMax
,
459 MetadataHandler_LoadEx
,
460 MetadataHandler_SaveEx
463 HRESULT
MetadataReader_Create(const MetadataHandlerVtbl
*vtable
, IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
465 MetadataHandler
*This
;
468 TRACE("%s\n", debugstr_guid(vtable
->clsid
));
472 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
474 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandler
));
475 if (!This
) return E_OUTOFMEMORY
;
477 This
->IWICMetadataWriter_iface
.lpVtbl
= &MetadataHandler_Vtbl
;
478 This
->IWICPersistStream_iface
.lpVtbl
= &MetadataHandler_PersistStream_Vtbl
;
480 This
->vtable
= vtable
;
482 This
->item_count
= 0;
484 InitializeCriticalSection(&This
->lock
);
485 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": MetadataHandler.lock");
487 hr
= IWICMetadataWriter_QueryInterface(&This
->IWICMetadataWriter_iface
, iid
, ppv
);
489 IWICMetadataWriter_Release(&This
->IWICMetadataWriter_iface
);
494 typedef struct MetadataHandlerEnum
{
495 IWICEnumMetadataItem IWICEnumMetadataItem_iface
;
497 MetadataHandler
*parent
;
499 } MetadataHandlerEnum
;
501 static inline MetadataHandlerEnum
*impl_from_IWICEnumMetadataItem(IWICEnumMetadataItem
*iface
)
503 return CONTAINING_RECORD(iface
, MetadataHandlerEnum
, IWICEnumMetadataItem_iface
);
506 static HRESULT WINAPI
MetadataHandlerEnum_QueryInterface(IWICEnumMetadataItem
*iface
, REFIID iid
,
509 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
510 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
512 if (!ppv
) return E_INVALIDARG
;
514 if (IsEqualIID(&IID_IUnknown
, iid
) ||
515 IsEqualIID(&IID_IWICEnumMetadataItem
, iid
))
517 *ppv
= &This
->IWICEnumMetadataItem_iface
;
522 return E_NOINTERFACE
;
525 IUnknown_AddRef((IUnknown
*)*ppv
);
529 static ULONG WINAPI
MetadataHandlerEnum_AddRef(IWICEnumMetadataItem
*iface
)
531 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
532 ULONG ref
= InterlockedIncrement(&This
->ref
);
534 TRACE("(%p) refcount=%u\n", iface
, ref
);
539 static ULONG WINAPI
MetadataHandlerEnum_Release(IWICEnumMetadataItem
*iface
)
541 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
542 ULONG ref
= InterlockedDecrement(&This
->ref
);
544 TRACE("(%p) refcount=%u\n", iface
, ref
);
548 IWICMetadataWriter_Release(&This
->parent
->IWICMetadataWriter_iface
);
549 HeapFree(GetProcessHeap(), 0, This
);
555 static HRESULT WINAPI
MetadataHandlerEnum_Next(IWICEnumMetadataItem
*iface
,
556 ULONG celt
, PROPVARIANT
*rgeltSchema
, PROPVARIANT
*rgeltId
,
557 PROPVARIANT
*rgeltValue
, ULONG
*pceltFetched
)
559 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
564 TRACE("(%p,%i)\n", iface
, celt
);
566 EnterCriticalSection(&This
->parent
->lock
);
568 if (This
->index
>= This
->parent
->item_count
)
571 LeaveCriticalSection(&This
->parent
->lock
);
575 new_index
= min(This
->parent
->item_count
, This
->index
+ celt
);
576 *pceltFetched
= new_index
- This
->index
;
580 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
581 hr
= PropVariantCopy(&rgeltSchema
[i
], &This
->parent
->items
[i
+This
->index
].schema
);
584 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
585 hr
= PropVariantCopy(&rgeltId
[i
], &This
->parent
->items
[i
+This
->index
].id
);
589 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
590 hr
= PropVariantCopy(&rgeltValue
[i
], &This
->parent
->items
[i
+This
->index
].value
);
595 This
->index
= new_index
;
598 LeaveCriticalSection(&This
->parent
->lock
);
603 static HRESULT WINAPI
MetadataHandlerEnum_Skip(IWICEnumMetadataItem
*iface
,
606 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
608 EnterCriticalSection(&This
->parent
->lock
);
612 LeaveCriticalSection(&This
->parent
->lock
);
617 static HRESULT WINAPI
MetadataHandlerEnum_Reset(IWICEnumMetadataItem
*iface
)
619 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
621 EnterCriticalSection(&This
->parent
->lock
);
625 LeaveCriticalSection(&This
->parent
->lock
);
630 static HRESULT WINAPI
MetadataHandlerEnum_Clone(IWICEnumMetadataItem
*iface
,
631 IWICEnumMetadataItem
**ppIEnumMetadataItem
)
633 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
636 EnterCriticalSection(&This
->parent
->lock
);
638 hr
= MetadataHandlerEnum_Create(This
->parent
, This
->index
, ppIEnumMetadataItem
);
640 LeaveCriticalSection(&This
->parent
->lock
);
645 static const IWICEnumMetadataItemVtbl MetadataHandlerEnum_Vtbl
= {
646 MetadataHandlerEnum_QueryInterface
,
647 MetadataHandlerEnum_AddRef
,
648 MetadataHandlerEnum_Release
,
649 MetadataHandlerEnum_Next
,
650 MetadataHandlerEnum_Skip
,
651 MetadataHandlerEnum_Reset
,
652 MetadataHandlerEnum_Clone
655 static HRESULT
MetadataHandlerEnum_Create(MetadataHandler
*parent
, DWORD index
,
656 IWICEnumMetadataItem
**ppIEnumMetadataItem
)
658 MetadataHandlerEnum
*This
;
660 if (!ppIEnumMetadataItem
) return E_INVALIDARG
;
662 *ppIEnumMetadataItem
= NULL
;
664 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandlerEnum
));
665 if (!This
) return E_OUTOFMEMORY
;
667 IWICMetadataWriter_AddRef(&parent
->IWICMetadataWriter_iface
);
669 This
->IWICEnumMetadataItem_iface
.lpVtbl
= &MetadataHandlerEnum_Vtbl
;
671 This
->parent
= parent
;
674 *ppIEnumMetadataItem
= &This
->IWICEnumMetadataItem_iface
;
679 static HRESULT
LoadUnknownMetadata(IStream
*input
, const GUID
*preferred_vendor
,
680 DWORD persist_options
, MetadataItem
**items
, DWORD
*item_count
)
683 MetadataItem
*result
;
690 hr
= IStream_Stat(input
, &stat
, STATFLAG_NONAME
);
694 data
= HeapAlloc(GetProcessHeap(), 0, stat
.cbSize
.QuadPart
);
695 if (!data
) return E_OUTOFMEMORY
;
697 hr
= IStream_Read(input
, data
, stat
.cbSize
.QuadPart
, &bytesread
);
698 if (bytesread
!= stat
.cbSize
.QuadPart
) hr
= E_FAIL
;
701 HeapFree(GetProcessHeap(), 0, data
);
705 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataItem
));
708 HeapFree(GetProcessHeap(), 0, data
);
709 return E_OUTOFMEMORY
;
712 PropVariantInit(&result
[0].schema
);
713 PropVariantInit(&result
[0].id
);
714 PropVariantInit(&result
[0].value
);
716 result
[0].value
.vt
= VT_BLOB
;
717 result
[0].value
.u
.blob
.cbSize
= bytesread
;
718 result
[0].value
.u
.blob
.pBlobData
= data
;
726 static const MetadataHandlerVtbl UnknownMetadataReader_Vtbl
= {
728 &CLSID_WICUnknownMetadataReader
,
732 HRESULT
UnknownMetadataReader_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
734 return MetadataReader_Create(&UnknownMetadataReader_Vtbl
, pUnkOuter
, iid
, ppv
);
737 #define SWAP_USHORT(x) do { if (!native_byte_order) (x) = RtlUshortByteSwap(x); } while(0)
738 #define SWAP_ULONG(x) do { if (!native_byte_order) (x) = RtlUlongByteSwap(x); } while(0)
739 #define SWAP_ULONGLONG(x) do { if (!native_byte_order) (x) = RtlUlonglongByteSwap(x); } while(0)
753 #define IFD_RATIONAL 5
755 #define IFD_UNDEFINED 7
758 #define IFD_SRATIONAL 10
760 #define IFD_DOUBLE 12
763 static int tag_to_vt(SHORT tag
)
765 static const int tag2vt
[] =
768 VT_UI1
, /* IFD_BYTE 1 */
769 VT_LPSTR
, /* IFD_ASCII 2 */
770 VT_UI2
, /* IFD_SHORT 3 */
771 VT_UI4
, /* IFD_LONG 4 */
772 VT_UI8
, /* IFD_RATIONAL 5 */
773 VT_I1
, /* IFD_SBYTE 6 */
774 VT_BLOB
, /* IFD_UNDEFINED 7 */
775 VT_I2
, /* IFD_SSHORT 8 */
776 VT_I4
, /* IFD_SLONG 9 */
777 VT_I8
, /* IFD_SRATIONAL 10 */
778 VT_R4
, /* IFD_FLOAT 11 */
779 VT_R8
, /* IFD_DOUBLE 12 */
780 VT_BLOB
, /* IFD_IFD 13 */
782 return (tag
> 0 && tag
<= 13) ? tag2vt
[tag
] : VT_BLOB
;
785 static HRESULT
load_IFD_entry(IStream
*input
, const struct IFD_entry
*entry
,
786 MetadataItem
*item
, BOOL native_byte_order
)
788 ULONG count
, value
, i
, bytesread
;
793 item
->schema
.vt
= VT_EMPTY
;
794 item
->id
.vt
= VT_UI2
;
795 item
->id
.u
.uiVal
= entry
->id
;
796 SWAP_USHORT(item
->id
.u
.uiVal
);
798 count
= entry
->count
;
802 item
->value
.vt
= tag_to_vt(type
);
803 value
= entry
->value
;
810 if (!count
) count
= 1;
814 const BYTE
*data
= (const BYTE
*)&entry
->value
;
817 item
->value
.u
.bVal
= data
[0];
820 item
->value
.vt
|= VT_VECTOR
;
821 item
->value
.u
.caub
.cElems
= count
;
822 item
->value
.u
.caub
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
);
823 memcpy(item
->value
.u
.caub
.pElems
, data
, count
);
828 item
->value
.vt
|= VT_VECTOR
;
829 item
->value
.u
.caub
.cElems
= count
;
830 item
->value
.u
.caub
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
);
831 if (!item
->value
.u
.caub
.pElems
) return E_OUTOFMEMORY
;
833 pos
.QuadPart
= value
;
834 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
837 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caub
.pElems
);
840 hr
= IStream_Read(input
, item
->value
.u
.caub
.pElems
, count
, &bytesread
);
841 if (bytesread
!= count
) hr
= E_FAIL
;
844 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caub
.pElems
);
850 if (!count
) count
= 1;
854 const SHORT
*data
= (const SHORT
*)&entry
->value
;
858 item
->value
.u
.uiVal
= data
[0];
859 SWAP_USHORT(item
->value
.u
.uiVal
);
863 item
->value
.vt
|= VT_VECTOR
;
864 item
->value
.u
.caui
.cElems
= count
;
865 item
->value
.u
.caui
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 2);
866 memcpy(item
->value
.u
.caui
.pElems
, data
, count
* 2);
867 for (i
= 0; i
< count
; i
++)
868 SWAP_USHORT(item
->value
.u
.caui
.pElems
[i
]);
873 item
->value
.vt
|= VT_VECTOR
;
874 item
->value
.u
.caui
.cElems
= count
;
875 item
->value
.u
.caui
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 2);
876 if (!item
->value
.u
.caui
.pElems
) return E_OUTOFMEMORY
;
878 pos
.QuadPart
= value
;
879 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
882 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caui
.pElems
);
885 hr
= IStream_Read(input
, item
->value
.u
.caui
.pElems
, count
* 2, &bytesread
);
886 if (bytesread
!= count
* 2) hr
= E_FAIL
;
889 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caui
.pElems
);
892 for (i
= 0; i
< count
; i
++)
893 SWAP_USHORT(item
->value
.u
.caui
.pElems
[i
]);
898 if (!count
) count
= 1;
902 item
->value
.u
.ulVal
= value
;
906 item
->value
.vt
|= VT_VECTOR
;
907 item
->value
.u
.caul
.cElems
= count
;
908 item
->value
.u
.caul
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 4);
909 if (!item
->value
.u
.caul
.pElems
) return E_OUTOFMEMORY
;
911 pos
.QuadPart
= value
;
912 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
915 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caul
.pElems
);
918 hr
= IStream_Read(input
, item
->value
.u
.caul
.pElems
, count
* 4, &bytesread
);
919 if (bytesread
!= count
* 4) hr
= E_FAIL
;
922 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caul
.pElems
);
925 for (i
= 0; i
< count
; i
++)
926 SWAP_ULONG(item
->value
.u
.caul
.pElems
[i
]);
933 FIXME("IFD field type %d, count 0\n", type
);
934 item
->value
.vt
= VT_EMPTY
;
942 pos
.QuadPart
= value
;
943 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
944 if (FAILED(hr
)) return hr
;
946 hr
= IStream_Read(input
, &ull
, sizeof(ull
), &bytesread
);
947 if (bytesread
!= sizeof(ull
)) hr
= E_FAIL
;
948 if (hr
!= S_OK
) return hr
;
950 item
->value
.u
.uhVal
.QuadPart
= ull
;
952 if (type
== IFD_DOUBLE
)
953 SWAP_ULONGLONG(item
->value
.u
.uhVal
.QuadPart
);
956 SWAP_ULONG(item
->value
.u
.uhVal
.u
.LowPart
);
957 SWAP_ULONG(item
->value
.u
.uhVal
.u
.HighPart
);
963 item
->value
.vt
|= VT_VECTOR
;
964 item
->value
.u
.cauh
.cElems
= count
;
965 item
->value
.u
.cauh
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 8);
966 if (!item
->value
.u
.cauh
.pElems
) return E_OUTOFMEMORY
;
968 pos
.QuadPart
= value
;
969 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
972 HeapFree(GetProcessHeap(), 0, item
->value
.u
.cauh
.pElems
);
975 hr
= IStream_Read(input
, item
->value
.u
.cauh
.pElems
, count
* 8, &bytesread
);
976 if (bytesread
!= count
* 8) hr
= E_FAIL
;
979 HeapFree(GetProcessHeap(), 0, item
->value
.u
.cauh
.pElems
);
982 for (i
= 0; i
< count
; i
++)
984 if (type
== IFD_DOUBLE
)
985 SWAP_ULONGLONG(item
->value
.u
.cauh
.pElems
[i
].QuadPart
);
988 SWAP_ULONG(item
->value
.u
.cauh
.pElems
[i
].u
.LowPart
);
989 SWAP_ULONG(item
->value
.u
.cauh
.pElems
[i
].u
.HighPart
);
995 item
->value
.u
.pszVal
= HeapAlloc(GetProcessHeap(), 0, count
+ 1);
996 if (!item
->value
.u
.pszVal
) return E_OUTOFMEMORY
;
1000 const char *data
= (const char *)&entry
->value
;
1001 memcpy(item
->value
.u
.pszVal
, data
, count
);
1002 item
->value
.u
.pszVal
[count
] = 0;
1006 pos
.QuadPart
= value
;
1007 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
1010 HeapFree(GetProcessHeap(), 0, item
->value
.u
.pszVal
);
1013 hr
= IStream_Read(input
, item
->value
.u
.pszVal
, count
, &bytesread
);
1014 if (bytesread
!= count
) hr
= E_FAIL
;
1017 HeapFree(GetProcessHeap(), 0, item
->value
.u
.pszVal
);
1020 item
->value
.u
.pszVal
[count
] = 0;
1025 FIXME("IFD field type %d, count 0\n", type
);
1026 item
->value
.vt
= VT_EMPTY
;
1030 item
->value
.u
.blob
.pBlobData
= HeapAlloc(GetProcessHeap(), 0, count
);
1031 if (!item
->value
.u
.blob
.pBlobData
) return E_OUTOFMEMORY
;
1033 item
->value
.u
.blob
.cbSize
= count
;
1037 const char *data
= (const char *)&entry
->value
;
1038 memcpy(item
->value
.u
.blob
.pBlobData
, data
, count
);
1042 pos
.QuadPart
= value
;
1043 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
1046 HeapFree(GetProcessHeap(), 0, item
->value
.u
.blob
.pBlobData
);
1049 hr
= IStream_Read(input
, item
->value
.u
.blob
.pBlobData
, count
, &bytesread
);
1050 if (bytesread
!= count
) hr
= E_FAIL
;
1053 HeapFree(GetProcessHeap(), 0, item
->value
.u
.blob
.pBlobData
);
1058 FIXME("loading field of type %d, count %u is not implemented\n", type
, count
);
1064 static HRESULT
LoadIfdMetadata(IStream
*input
, const GUID
*preferred_vendor
,
1065 DWORD persist_options
, MetadataItem
**items
, DWORD
*item_count
)
1068 MetadataItem
*result
;
1070 struct IFD_entry
*entry
;
1071 BOOL native_byte_order
= TRUE
;
1076 #ifdef WORDS_BIGENDIAN
1077 if (persist_options
& WICPersistOptionsLittleEndian
)
1079 if (persist_options
& WICPersistOptionsBigEndian
)
1081 native_byte_order
= FALSE
;
1083 hr
= IStream_Read(input
, &count
, sizeof(count
), &bytesread
);
1084 if (bytesread
!= sizeof(count
)) hr
= E_FAIL
;
1085 if (hr
!= S_OK
) return hr
;
1089 entry
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(*entry
));
1090 if (!entry
) return E_OUTOFMEMORY
;
1092 hr
= IStream_Read(input
, entry
, count
* sizeof(*entry
), &bytesread
);
1093 if (bytesread
!= count
* sizeof(*entry
)) hr
= E_FAIL
;
1096 HeapFree(GetProcessHeap(), 0, entry
);
1100 /* limit number of IFDs to 4096 to avoid infinite loop */
1101 for (i
= 0; i
< 4096; i
++)
1103 ULONG next_ifd_offset
;
1105 USHORT next_ifd_count
;
1107 hr
= IStream_Read(input
, &next_ifd_offset
, sizeof(next_ifd_offset
), &bytesread
);
1108 if (bytesread
!= sizeof(next_ifd_offset
)) hr
= E_FAIL
;
1109 if (hr
!= S_OK
) break;
1111 SWAP_ULONG(next_ifd_offset
);
1112 if (!next_ifd_offset
) break;
1114 pos
.QuadPart
= next_ifd_offset
;
1115 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
1116 if (FAILED(hr
)) break;
1118 hr
= IStream_Read(input
, &next_ifd_count
, sizeof(next_ifd_count
), &bytesread
);
1119 if (bytesread
!= sizeof(next_ifd_count
)) hr
= E_FAIL
;
1120 if (hr
!= S_OK
) break;
1122 SWAP_USHORT(next_ifd_count
);
1124 pos
.QuadPart
= next_ifd_count
* sizeof(*entry
);
1125 hr
= IStream_Seek(input
, pos
, SEEK_CUR
, NULL
);
1126 if (FAILED(hr
)) break;
1129 if (hr
!= S_OK
|| i
== 4096)
1131 HeapFree(GetProcessHeap(), 0, entry
);
1132 return WINCODEC_ERR_BADMETADATAHEADER
;
1135 result
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(*result
));
1138 HeapFree(GetProcessHeap(), 0, entry
);
1139 return E_OUTOFMEMORY
;
1142 for (i
= 0; i
< count
; i
++)
1144 hr
= load_IFD_entry(input
, &entry
[i
], &result
[i
], native_byte_order
);
1147 HeapFree(GetProcessHeap(), 0, entry
);
1148 HeapFree(GetProcessHeap(), 0, result
);
1153 HeapFree(GetProcessHeap(), 0, entry
);
1156 *item_count
= count
;
1161 static const MetadataHandlerVtbl IfdMetadataReader_Vtbl
= {
1163 &CLSID_WICIfdMetadataReader
,
1167 HRESULT
IfdMetadataReader_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void **ppv
)
1169 return MetadataReader_Create(&IfdMetadataReader_Vtbl
, pUnkOuter
, iid
, ppv
);