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 #include "wincodecs_private.h"
25 typedef struct MetadataHandler
{
26 IWICMetadataWriter IWICMetadataWriter_iface
;
28 IWICPersistStream IWICPersistStream_iface
;
29 const MetadataHandlerVtbl
*vtable
;
32 CRITICAL_SECTION lock
;
35 static inline MetadataHandler
*impl_from_IWICMetadataWriter(IWICMetadataWriter
*iface
)
37 return CONTAINING_RECORD(iface
, MetadataHandler
, IWICMetadataWriter_iface
);
40 static inline MetadataHandler
*impl_from_IWICPersistStream(IWICPersistStream
*iface
)
42 return CONTAINING_RECORD(iface
, MetadataHandler
, IWICPersistStream_iface
);
45 static void MetadataHandler_FreeItems(MetadataHandler
*This
)
49 for (i
=0; i
<This
->item_count
; i
++)
51 PropVariantClear(&This
->items
[i
].schema
);
52 PropVariantClear(&This
->items
[i
].id
);
53 PropVariantClear(&This
->items
[i
].value
);
56 HeapFree(GetProcessHeap(), 0, This
->items
);
59 static HRESULT
MetadataHandlerEnum_Create(MetadataHandler
*parent
, DWORD index
,
60 IWICEnumMetadataItem
**ppIEnumMetadataItem
);
62 static HRESULT WINAPI
MetadataHandler_QueryInterface(IWICMetadataWriter
*iface
, REFIID iid
,
65 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
66 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
68 if (!ppv
) return E_INVALIDARG
;
70 if (IsEqualIID(&IID_IUnknown
, iid
) ||
71 IsEqualIID(&IID_IWICMetadataReader
, iid
) ||
72 (IsEqualIID(&IID_IWICMetadataWriter
, iid
) && This
->vtable
->is_writer
))
74 *ppv
= &This
->IWICMetadataWriter_iface
;
76 else if (IsEqualIID(&IID_IPersist
, iid
) ||
77 IsEqualIID(&IID_IPersistStream
, iid
) ||
78 IsEqualIID(&IID_IWICPersistStream
, iid
))
80 *ppv
= &This
->IWICPersistStream_iface
;
88 IUnknown_AddRef((IUnknown
*)*ppv
);
92 static ULONG WINAPI
MetadataHandler_AddRef(IWICMetadataWriter
*iface
)
94 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
95 ULONG ref
= InterlockedIncrement(&This
->ref
);
97 TRACE("(%p) refcount=%u\n", iface
, ref
);
102 static ULONG WINAPI
MetadataHandler_Release(IWICMetadataWriter
*iface
)
104 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
105 ULONG ref
= InterlockedDecrement(&This
->ref
);
107 TRACE("(%p) refcount=%u\n", iface
, ref
);
111 MetadataHandler_FreeItems(This
);
112 This
->lock
.DebugInfo
->Spare
[0] = 0;
113 DeleteCriticalSection(&This
->lock
);
114 HeapFree(GetProcessHeap(), 0, This
);
120 static HRESULT WINAPI
MetadataHandler_GetMetadataHandlerInfo(IWICMetadataWriter
*iface
,
121 IWICMetadataHandlerInfo
**ppIHandler
)
124 IWICComponentInfo
*component_info
;
125 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
127 TRACE("%p,%p\n", iface
, ppIHandler
);
129 hr
= CreateComponentInfo(This
->vtable
->clsid
, &component_info
);
130 if (FAILED(hr
)) return hr
;
132 hr
= IWICComponentInfo_QueryInterface(component_info
, &IID_IWICMetadataHandlerInfo
,
133 (void **)ppIHandler
);
135 IWICComponentInfo_Release(component_info
);
139 static HRESULT WINAPI
MetadataHandler_GetMetadataFormat(IWICMetadataWriter
*iface
,
140 GUID
*pguidMetadataFormat
)
143 IWICMetadataHandlerInfo
*metadata_info
;
145 TRACE("%p,%p\n", iface
, pguidMetadataFormat
);
147 if (!pguidMetadataFormat
) return E_INVALIDARG
;
149 hr
= MetadataHandler_GetMetadataHandlerInfo(iface
, &metadata_info
);
150 if (FAILED(hr
)) return hr
;
152 hr
= IWICMetadataHandlerInfo_GetMetadataFormat(metadata_info
, pguidMetadataFormat
);
153 IWICMetadataHandlerInfo_Release(metadata_info
);
158 static HRESULT WINAPI
MetadataHandler_GetCount(IWICMetadataWriter
*iface
,
161 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
163 TRACE("%p,%p\n", iface
, pcCount
);
165 if (!pcCount
) return E_INVALIDARG
;
167 *pcCount
= This
->item_count
;
171 static HRESULT WINAPI
MetadataHandler_GetValueByIndex(IWICMetadataWriter
*iface
,
172 UINT index
, PROPVARIANT
*schema
, PROPVARIANT
*id
, PROPVARIANT
*value
)
175 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
177 TRACE("%p,%u,%p,%p,%p\n", iface
, index
, schema
, id
, value
);
179 EnterCriticalSection(&This
->lock
);
181 if (index
>= This
->item_count
)
183 LeaveCriticalSection(&This
->lock
);
188 hr
= PropVariantCopy(schema
, &This
->items
[index
].schema
);
190 if (SUCCEEDED(hr
) && id
)
191 hr
= PropVariantCopy(id
, &This
->items
[index
].id
);
193 if (SUCCEEDED(hr
) && value
)
194 hr
= PropVariantCopy(value
, &This
->items
[index
].value
);
196 LeaveCriticalSection(&This
->lock
);
200 static BOOL
get_int_value(const PROPVARIANT
*pv
, LONGLONG
*value
)
218 *value
= pv
->u
.uiVal
;
224 *value
= pv
->u
.ulVal
;
228 *value
= pv
->u
.hVal
.QuadPart
;
231 FIXME("not supported variant type %d\n", pv
->vt
);
237 /* FiXME: Use propsys.PropVariantCompareEx once it's implemented */
238 static int propvar_cmp(const PROPVARIANT
*v1
, const PROPVARIANT
*v2
)
240 LONGLONG value1
, value2
;
242 if (v1
->vt
== VT_LPSTR
&& v2
->vt
== VT_LPSTR
)
244 return lstrcmpA(v1
->u
.pszVal
, v2
->u
.pszVal
);
247 if (v1
->vt
== VT_LPWSTR
&& v2
->vt
== VT_LPWSTR
)
249 return lstrcmpiW(v1
->u
.pwszVal
, v2
->u
.pwszVal
);
252 if (!get_int_value(v1
, &value1
)) return -1;
253 if (!get_int_value(v2
, &value2
)) return -1;
256 if (value1
) return value1
< 0 ? -1 : 1;
260 static HRESULT WINAPI
MetadataHandler_GetValue(IWICMetadataWriter
*iface
,
261 const PROPVARIANT
*schema
, const PROPVARIANT
*id
, PROPVARIANT
*value
)
264 HRESULT hr
= WINCODEC_ERR_PROPERTYNOTFOUND
;
265 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
267 TRACE("(%p,%p,%p,%p)\n", iface
, schema
, id
, value
);
269 if (!id
) return E_INVALIDARG
;
271 EnterCriticalSection(&This
->lock
);
273 for (i
= 0; i
< This
->item_count
; i
++)
275 if (schema
&& This
->items
[i
].schema
.vt
!= VT_EMPTY
)
277 if (propvar_cmp(schema
, &This
->items
[i
].schema
) != 0) continue;
280 if (propvar_cmp(id
, &This
->items
[i
].id
) != 0) continue;
282 hr
= value
? PropVariantCopy(value
, &This
->items
[i
].value
) : S_OK
;
286 LeaveCriticalSection(&This
->lock
);
290 static HRESULT WINAPI
MetadataHandler_GetEnumerator(IWICMetadataWriter
*iface
,
291 IWICEnumMetadataItem
**ppIEnumMetadata
)
293 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
294 TRACE("(%p,%p)\n", iface
, ppIEnumMetadata
);
295 return MetadataHandlerEnum_Create(This
, 0, ppIEnumMetadata
);
298 static HRESULT WINAPI
MetadataHandler_SetValue(IWICMetadataWriter
*iface
,
299 const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
, const PROPVARIANT
*pvarValue
)
301 FIXME("(%p,%p,%p,%p): stub\n", iface
, pvarSchema
, pvarId
, pvarValue
);
305 static HRESULT WINAPI
MetadataHandler_SetValueByIndex(IWICMetadataWriter
*iface
,
306 UINT nIndex
, const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
, const PROPVARIANT
*pvarValue
)
308 FIXME("(%p,%u,%p,%p,%p): stub\n", iface
, nIndex
, pvarSchema
, pvarId
, pvarValue
);
312 static HRESULT WINAPI
MetadataHandler_RemoveValue(IWICMetadataWriter
*iface
,
313 const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
)
315 FIXME("(%p,%p,%p): stub\n", iface
, pvarSchema
, pvarId
);
319 static HRESULT WINAPI
MetadataHandler_RemoveValueByIndex(IWICMetadataWriter
*iface
,
322 FIXME("(%p,%u): stub\n", iface
, nIndex
);
326 static const IWICMetadataWriterVtbl MetadataHandler_Vtbl
= {
327 MetadataHandler_QueryInterface
,
328 MetadataHandler_AddRef
,
329 MetadataHandler_Release
,
330 MetadataHandler_GetMetadataFormat
,
331 MetadataHandler_GetMetadataHandlerInfo
,
332 MetadataHandler_GetCount
,
333 MetadataHandler_GetValueByIndex
,
334 MetadataHandler_GetValue
,
335 MetadataHandler_GetEnumerator
,
336 MetadataHandler_SetValue
,
337 MetadataHandler_SetValueByIndex
,
338 MetadataHandler_RemoveValue
,
339 MetadataHandler_RemoveValueByIndex
342 static HRESULT WINAPI
MetadataHandler_PersistStream_QueryInterface(IWICPersistStream
*iface
,
343 REFIID iid
, void **ppv
)
345 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
346 return IWICMetadataWriter_QueryInterface(&This
->IWICMetadataWriter_iface
, iid
, ppv
);
349 static ULONG WINAPI
MetadataHandler_PersistStream_AddRef(IWICPersistStream
*iface
)
351 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
352 return IWICMetadataWriter_AddRef(&This
->IWICMetadataWriter_iface
);
355 static ULONG WINAPI
MetadataHandler_PersistStream_Release(IWICPersistStream
*iface
)
357 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
358 return IWICMetadataWriter_Release(&This
->IWICMetadataWriter_iface
);
361 static HRESULT WINAPI
MetadataHandler_GetClassID(IWICPersistStream
*iface
,
364 FIXME("(%p,%p): stub\n", iface
, pClassID
);
368 static HRESULT WINAPI
MetadataHandler_IsDirty(IWICPersistStream
*iface
)
370 FIXME("(%p): stub\n", iface
);
374 static HRESULT WINAPI
MetadataHandler_Load(IWICPersistStream
*iface
,
377 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
378 TRACE("(%p,%p)\n", iface
, pStm
);
379 return IWICPersistStream_LoadEx(&This
->IWICPersistStream_iface
, pStm
, NULL
, WICPersistOptionsDefault
);
382 static HRESULT WINAPI
MetadataHandler_Save(IWICPersistStream
*iface
,
383 IStream
*pStm
, BOOL fClearDirty
)
385 FIXME("(%p,%p,%i): stub\n", iface
, pStm
, fClearDirty
);
389 static HRESULT WINAPI
MetadataHandler_GetSizeMax(IWICPersistStream
*iface
,
390 ULARGE_INTEGER
*pcbSize
)
392 FIXME("(%p,%p): stub\n", iface
, pcbSize
);
396 static HRESULT WINAPI
MetadataHandler_LoadEx(IWICPersistStream
*iface
,
397 IStream
*pIStream
, const GUID
*pguidPreferredVendor
, DWORD dwPersistOptions
)
399 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
401 MetadataItem
*new_items
=NULL
;
404 TRACE("(%p,%p,%s,%x)\n", iface
, pIStream
, debugstr_guid(pguidPreferredVendor
), dwPersistOptions
);
406 EnterCriticalSection(&This
->lock
);
408 hr
= This
->vtable
->fnLoad(pIStream
, pguidPreferredVendor
, dwPersistOptions
,
409 &new_items
, &item_count
);
413 MetadataHandler_FreeItems(This
);
414 This
->items
= new_items
;
415 This
->item_count
= item_count
;
418 LeaveCriticalSection(&This
->lock
);
423 static HRESULT WINAPI
MetadataHandler_SaveEx(IWICPersistStream
*iface
,
424 IStream
*pIStream
, DWORD dwPersistOptions
, BOOL fClearDirty
)
426 FIXME("(%p,%p,%x,%i): stub\n", iface
, pIStream
, dwPersistOptions
, fClearDirty
);
430 static const IWICPersistStreamVtbl MetadataHandler_PersistStream_Vtbl
= {
431 MetadataHandler_PersistStream_QueryInterface
,
432 MetadataHandler_PersistStream_AddRef
,
433 MetadataHandler_PersistStream_Release
,
434 MetadataHandler_GetClassID
,
435 MetadataHandler_IsDirty
,
436 MetadataHandler_Load
,
437 MetadataHandler_Save
,
438 MetadataHandler_GetSizeMax
,
439 MetadataHandler_LoadEx
,
440 MetadataHandler_SaveEx
443 HRESULT
MetadataReader_Create(const MetadataHandlerVtbl
*vtable
, IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
445 MetadataHandler
*This
;
448 TRACE("%s\n", debugstr_guid(vtable
->clsid
));
452 if (pUnkOuter
) return CLASS_E_NOAGGREGATION
;
454 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandler
));
455 if (!This
) return E_OUTOFMEMORY
;
457 This
->IWICMetadataWriter_iface
.lpVtbl
= &MetadataHandler_Vtbl
;
458 This
->IWICPersistStream_iface
.lpVtbl
= &MetadataHandler_PersistStream_Vtbl
;
460 This
->vtable
= vtable
;
462 This
->item_count
= 0;
464 InitializeCriticalSection(&This
->lock
);
465 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": MetadataHandler.lock");
467 hr
= IWICMetadataWriter_QueryInterface(&This
->IWICMetadataWriter_iface
, iid
, ppv
);
469 IWICMetadataWriter_Release(&This
->IWICMetadataWriter_iface
);
474 typedef struct MetadataHandlerEnum
{
475 IWICEnumMetadataItem IWICEnumMetadataItem_iface
;
477 MetadataHandler
*parent
;
479 } MetadataHandlerEnum
;
481 static inline MetadataHandlerEnum
*impl_from_IWICEnumMetadataItem(IWICEnumMetadataItem
*iface
)
483 return CONTAINING_RECORD(iface
, MetadataHandlerEnum
, IWICEnumMetadataItem_iface
);
486 static HRESULT WINAPI
MetadataHandlerEnum_QueryInterface(IWICEnumMetadataItem
*iface
, REFIID iid
,
489 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
490 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
492 if (!ppv
) return E_INVALIDARG
;
494 if (IsEqualIID(&IID_IUnknown
, iid
) ||
495 IsEqualIID(&IID_IWICEnumMetadataItem
, iid
))
497 *ppv
= &This
->IWICEnumMetadataItem_iface
;
502 return E_NOINTERFACE
;
505 IUnknown_AddRef((IUnknown
*)*ppv
);
509 static ULONG WINAPI
MetadataHandlerEnum_AddRef(IWICEnumMetadataItem
*iface
)
511 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
512 ULONG ref
= InterlockedIncrement(&This
->ref
);
514 TRACE("(%p) refcount=%u\n", iface
, ref
);
519 static ULONG WINAPI
MetadataHandlerEnum_Release(IWICEnumMetadataItem
*iface
)
521 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
522 ULONG ref
= InterlockedDecrement(&This
->ref
);
524 TRACE("(%p) refcount=%u\n", iface
, ref
);
528 IWICMetadataWriter_Release(&This
->parent
->IWICMetadataWriter_iface
);
529 HeapFree(GetProcessHeap(), 0, This
);
535 static HRESULT WINAPI
MetadataHandlerEnum_Next(IWICEnumMetadataItem
*iface
,
536 ULONG celt
, PROPVARIANT
*rgeltSchema
, PROPVARIANT
*rgeltId
,
537 PROPVARIANT
*rgeltValue
, ULONG
*pceltFetched
)
539 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
544 TRACE("(%p,%i)\n", iface
, celt
);
546 EnterCriticalSection(&This
->parent
->lock
);
548 if (This
->index
>= This
->parent
->item_count
)
551 LeaveCriticalSection(&This
->parent
->lock
);
555 new_index
= min(This
->parent
->item_count
, This
->index
+ celt
);
556 *pceltFetched
= new_index
- This
->index
;
560 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
561 hr
= PropVariantCopy(&rgeltSchema
[i
], &This
->parent
->items
[i
+This
->index
].schema
);
564 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
565 hr
= PropVariantCopy(&rgeltId
[i
], &This
->parent
->items
[i
+This
->index
].id
);
569 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
570 hr
= PropVariantCopy(&rgeltValue
[i
], &This
->parent
->items
[i
+This
->index
].value
);
575 This
->index
= new_index
;
578 LeaveCriticalSection(&This
->parent
->lock
);
583 static HRESULT WINAPI
MetadataHandlerEnum_Skip(IWICEnumMetadataItem
*iface
,
586 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
588 EnterCriticalSection(&This
->parent
->lock
);
592 LeaveCriticalSection(&This
->parent
->lock
);
597 static HRESULT WINAPI
MetadataHandlerEnum_Reset(IWICEnumMetadataItem
*iface
)
599 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
601 EnterCriticalSection(&This
->parent
->lock
);
605 LeaveCriticalSection(&This
->parent
->lock
);
610 static HRESULT WINAPI
MetadataHandlerEnum_Clone(IWICEnumMetadataItem
*iface
,
611 IWICEnumMetadataItem
**ppIEnumMetadataItem
)
613 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
616 EnterCriticalSection(&This
->parent
->lock
);
618 hr
= MetadataHandlerEnum_Create(This
->parent
, This
->index
, ppIEnumMetadataItem
);
620 LeaveCriticalSection(&This
->parent
->lock
);
625 static const IWICEnumMetadataItemVtbl MetadataHandlerEnum_Vtbl
= {
626 MetadataHandlerEnum_QueryInterface
,
627 MetadataHandlerEnum_AddRef
,
628 MetadataHandlerEnum_Release
,
629 MetadataHandlerEnum_Next
,
630 MetadataHandlerEnum_Skip
,
631 MetadataHandlerEnum_Reset
,
632 MetadataHandlerEnum_Clone
635 static HRESULT
MetadataHandlerEnum_Create(MetadataHandler
*parent
, DWORD index
,
636 IWICEnumMetadataItem
**ppIEnumMetadataItem
)
638 MetadataHandlerEnum
*This
;
640 if (!ppIEnumMetadataItem
) return E_INVALIDARG
;
642 *ppIEnumMetadataItem
= NULL
;
644 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandlerEnum
));
645 if (!This
) return E_OUTOFMEMORY
;
647 IWICMetadataWriter_AddRef(&parent
->IWICMetadataWriter_iface
);
649 This
->IWICEnumMetadataItem_iface
.lpVtbl
= &MetadataHandlerEnum_Vtbl
;
651 This
->parent
= parent
;
654 *ppIEnumMetadataItem
= &This
->IWICEnumMetadataItem_iface
;
659 static HRESULT
LoadUnknownMetadata(IStream
*input
, const GUID
*preferred_vendor
,
660 DWORD persist_options
, MetadataItem
**items
, DWORD
*item_count
)
663 MetadataItem
*result
;
670 hr
= IStream_Stat(input
, &stat
, STATFLAG_NONAME
);
674 data
= HeapAlloc(GetProcessHeap(), 0, stat
.cbSize
.QuadPart
);
675 if (!data
) return E_OUTOFMEMORY
;
677 hr
= IStream_Read(input
, data
, stat
.cbSize
.QuadPart
, &bytesread
);
678 if (bytesread
!= stat
.cbSize
.QuadPart
) hr
= E_FAIL
;
681 HeapFree(GetProcessHeap(), 0, data
);
685 result
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataItem
));
688 HeapFree(GetProcessHeap(), 0, data
);
689 return E_OUTOFMEMORY
;
692 PropVariantInit(&result
[0].schema
);
693 PropVariantInit(&result
[0].id
);
694 PropVariantInit(&result
[0].value
);
696 result
[0].value
.vt
= VT_BLOB
;
697 result
[0].value
.u
.blob
.cbSize
= bytesread
;
698 result
[0].value
.u
.blob
.pBlobData
= data
;
706 static const MetadataHandlerVtbl UnknownMetadataReader_Vtbl
= {
708 &CLSID_WICUnknownMetadataReader
,
712 HRESULT
UnknownMetadataReader_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void** ppv
)
714 return MetadataReader_Create(&UnknownMetadataReader_Vtbl
, pUnkOuter
, iid
, ppv
);
717 #define SWAP_USHORT(x) do { if (!native_byte_order) (x) = RtlUshortByteSwap(x); } while(0)
718 #define SWAP_ULONG(x) do { if (!native_byte_order) (x) = RtlUlongByteSwap(x); } while(0)
719 #define SWAP_ULONGLONG(x) do { if (!native_byte_order) (x) = RtlUlonglongByteSwap(x); } while(0)
733 #define IFD_RATIONAL 5
735 #define IFD_UNDEFINED 7
738 #define IFD_SRATIONAL 10
740 #define IFD_DOUBLE 12
743 static int tag_to_vt(SHORT tag
)
745 static const int tag2vt
[] =
748 VT_UI1
, /* IFD_BYTE 1 */
749 VT_LPSTR
, /* IFD_ASCII 2 */
750 VT_UI2
, /* IFD_SHORT 3 */
751 VT_UI4
, /* IFD_LONG 4 */
752 VT_UI8
, /* IFD_RATIONAL 5 */
753 VT_I1
, /* IFD_SBYTE 6 */
754 VT_BLOB
, /* IFD_UNDEFINED 7 */
755 VT_I2
, /* IFD_SSHORT 8 */
756 VT_I4
, /* IFD_SLONG 9 */
757 VT_I8
, /* IFD_SRATIONAL 10 */
758 VT_R4
, /* IFD_FLOAT 11 */
759 VT_R8
, /* IFD_DOUBLE 12 */
760 VT_BLOB
, /* IFD_IFD 13 */
762 return (tag
> 0 && tag
<= 13) ? tag2vt
[tag
] : VT_BLOB
;
765 static HRESULT
load_IFD_entry(IStream
*input
, const struct IFD_entry
*entry
,
766 MetadataItem
*item
, BOOL native_byte_order
)
768 ULONG count
, value
, i
, bytesread
;
773 item
->schema
.vt
= VT_EMPTY
;
774 item
->id
.vt
= VT_UI2
;
775 item
->id
.u
.uiVal
= entry
->id
;
776 SWAP_USHORT(item
->id
.u
.uiVal
);
778 count
= entry
->count
;
782 item
->value
.vt
= tag_to_vt(type
);
783 value
= entry
->value
;
790 if (!count
) count
= 1;
794 const BYTE
*data
= (const BYTE
*)&entry
->value
;
797 item
->value
.u
.bVal
= data
[0];
800 item
->value
.vt
|= VT_VECTOR
;
801 item
->value
.u
.caub
.cElems
= count
;
802 item
->value
.u
.caub
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
);
803 memcpy(item
->value
.u
.caub
.pElems
, data
, count
);
808 item
->value
.vt
|= VT_VECTOR
;
809 item
->value
.u
.caub
.cElems
= count
;
810 item
->value
.u
.caub
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
);
811 if (!item
->value
.u
.caub
.pElems
) return E_OUTOFMEMORY
;
813 pos
.QuadPart
= value
;
814 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
817 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caub
.pElems
);
820 hr
= IStream_Read(input
, item
->value
.u
.caub
.pElems
, count
, &bytesread
);
821 if (bytesread
!= count
) hr
= E_FAIL
;
824 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caub
.pElems
);
830 if (!count
) count
= 1;
834 const SHORT
*data
= (const SHORT
*)&entry
->value
;
838 item
->value
.u
.uiVal
= data
[0];
839 SWAP_USHORT(item
->value
.u
.uiVal
);
843 item
->value
.vt
|= VT_VECTOR
;
844 item
->value
.u
.caui
.cElems
= count
;
845 item
->value
.u
.caui
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 2);
846 memcpy(item
->value
.u
.caui
.pElems
, data
, count
* 2);
847 for (i
= 0; i
< count
; i
++)
848 SWAP_USHORT(item
->value
.u
.caui
.pElems
[i
]);
853 item
->value
.vt
|= VT_VECTOR
;
854 item
->value
.u
.caui
.cElems
= count
;
855 item
->value
.u
.caui
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 2);
856 if (!item
->value
.u
.caui
.pElems
) return E_OUTOFMEMORY
;
858 pos
.QuadPart
= value
;
859 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
862 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caui
.pElems
);
865 hr
= IStream_Read(input
, item
->value
.u
.caui
.pElems
, count
* 2, &bytesread
);
866 if (bytesread
!= count
* 2) hr
= E_FAIL
;
869 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caui
.pElems
);
872 for (i
= 0; i
< count
; i
++)
873 SWAP_USHORT(item
->value
.u
.caui
.pElems
[i
]);
878 if (!count
) count
= 1;
882 item
->value
.u
.ulVal
= value
;
886 item
->value
.vt
|= VT_VECTOR
;
887 item
->value
.u
.caul
.cElems
= count
;
888 item
->value
.u
.caul
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 4);
889 if (!item
->value
.u
.caul
.pElems
) return E_OUTOFMEMORY
;
891 pos
.QuadPart
= value
;
892 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
895 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caul
.pElems
);
898 hr
= IStream_Read(input
, item
->value
.u
.caul
.pElems
, count
* 4, &bytesread
);
899 if (bytesread
!= count
* 4) hr
= E_FAIL
;
902 HeapFree(GetProcessHeap(), 0, item
->value
.u
.caul
.pElems
);
905 for (i
= 0; i
< count
; i
++)
906 SWAP_ULONG(item
->value
.u
.caul
.pElems
[i
]);
913 FIXME("IFD field type %d, count 0\n", type
);
914 item
->value
.vt
= VT_EMPTY
;
922 pos
.QuadPart
= value
;
923 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
924 if (FAILED(hr
)) return hr
;
926 hr
= IStream_Read(input
, &ull
, sizeof(ull
), &bytesread
);
927 if (bytesread
!= sizeof(ull
)) hr
= E_FAIL
;
928 if (hr
!= S_OK
) return hr
;
930 item
->value
.u
.uhVal
.QuadPart
= ull
;
932 if (type
== IFD_DOUBLE
)
933 SWAP_ULONGLONG(item
->value
.u
.uhVal
.QuadPart
);
936 SWAP_ULONG(item
->value
.u
.uhVal
.u
.LowPart
);
937 SWAP_ULONG(item
->value
.u
.uhVal
.u
.HighPart
);
943 item
->value
.vt
|= VT_VECTOR
;
944 item
->value
.u
.cauh
.cElems
= count
;
945 item
->value
.u
.cauh
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 8);
946 if (!item
->value
.u
.cauh
.pElems
) return E_OUTOFMEMORY
;
948 pos
.QuadPart
= value
;
949 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
952 HeapFree(GetProcessHeap(), 0, item
->value
.u
.cauh
.pElems
);
955 hr
= IStream_Read(input
, item
->value
.u
.cauh
.pElems
, count
* 8, &bytesread
);
956 if (bytesread
!= count
* 8) hr
= E_FAIL
;
959 HeapFree(GetProcessHeap(), 0, item
->value
.u
.cauh
.pElems
);
962 for (i
= 0; i
< count
; i
++)
964 if (type
== IFD_DOUBLE
)
965 SWAP_ULONGLONG(item
->value
.u
.cauh
.pElems
[i
].QuadPart
);
968 SWAP_ULONG(item
->value
.u
.cauh
.pElems
[i
].u
.LowPart
);
969 SWAP_ULONG(item
->value
.u
.cauh
.pElems
[i
].u
.HighPart
);
975 item
->value
.u
.pszVal
= HeapAlloc(GetProcessHeap(), 0, count
+ 1);
976 if (!item
->value
.u
.pszVal
) return E_OUTOFMEMORY
;
980 const char *data
= (const char *)&entry
->value
;
981 memcpy(item
->value
.u
.pszVal
, data
, count
);
982 item
->value
.u
.pszVal
[count
] = 0;
986 pos
.QuadPart
= value
;
987 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
990 HeapFree(GetProcessHeap(), 0, item
->value
.u
.pszVal
);
993 hr
= IStream_Read(input
, item
->value
.u
.pszVal
, count
, &bytesread
);
994 if (bytesread
!= count
) hr
= E_FAIL
;
997 HeapFree(GetProcessHeap(), 0, item
->value
.u
.pszVal
);
1000 item
->value
.u
.pszVal
[count
] = 0;
1005 FIXME("IFD field type %d, count 0\n", type
);
1006 item
->value
.vt
= VT_EMPTY
;
1010 item
->value
.u
.blob
.pBlobData
= HeapAlloc(GetProcessHeap(), 0, count
);
1011 if (!item
->value
.u
.blob
.pBlobData
) return E_OUTOFMEMORY
;
1013 item
->value
.u
.blob
.cbSize
= count
;
1017 const char *data
= (const char *)&entry
->value
;
1018 memcpy(item
->value
.u
.blob
.pBlobData
, data
, count
);
1022 pos
.QuadPart
= value
;
1023 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
1026 HeapFree(GetProcessHeap(), 0, item
->value
.u
.blob
.pBlobData
);
1029 hr
= IStream_Read(input
, item
->value
.u
.blob
.pBlobData
, count
, &bytesread
);
1030 if (bytesread
!= count
) hr
= E_FAIL
;
1033 HeapFree(GetProcessHeap(), 0, item
->value
.u
.blob
.pBlobData
);
1038 FIXME("loading field of type %d, count %u is not implemented\n", type
, count
);
1044 static HRESULT
LoadIfdMetadata(IStream
*input
, const GUID
*preferred_vendor
,
1045 DWORD persist_options
, MetadataItem
**items
, DWORD
*item_count
)
1048 MetadataItem
*result
;
1050 struct IFD_entry
*entry
;
1051 BOOL native_byte_order
= TRUE
;
1056 #ifdef WORDS_BIGENDIAN
1057 if (persist_options
& WICPersistOptionsLittleEndian
)
1059 if (persist_options
& WICPersistOptionsBigEndian
)
1061 native_byte_order
= FALSE
;
1063 hr
= IStream_Read(input
, &count
, sizeof(count
), &bytesread
);
1064 if (bytesread
!= sizeof(count
)) hr
= E_FAIL
;
1065 if (hr
!= S_OK
) return hr
;
1069 entry
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(*entry
));
1070 if (!entry
) return E_OUTOFMEMORY
;
1072 hr
= IStream_Read(input
, entry
, count
* sizeof(*entry
), &bytesread
);
1073 if (bytesread
!= count
* sizeof(*entry
)) hr
= E_FAIL
;
1076 HeapFree(GetProcessHeap(), 0, entry
);
1080 /* limit number of IFDs to 4096 to avoid infinite loop */
1081 for (i
= 0; i
< 4096; i
++)
1083 ULONG next_ifd_offset
;
1085 USHORT next_ifd_count
;
1087 hr
= IStream_Read(input
, &next_ifd_offset
, sizeof(next_ifd_offset
), &bytesread
);
1088 if (bytesread
!= sizeof(next_ifd_offset
)) hr
= E_FAIL
;
1089 if (hr
!= S_OK
) break;
1091 SWAP_ULONG(next_ifd_offset
);
1092 if (!next_ifd_offset
) break;
1094 pos
.QuadPart
= next_ifd_offset
;
1095 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
1096 if (FAILED(hr
)) break;
1098 hr
= IStream_Read(input
, &next_ifd_count
, sizeof(next_ifd_count
), &bytesread
);
1099 if (bytesread
!= sizeof(next_ifd_count
)) hr
= E_FAIL
;
1100 if (hr
!= S_OK
) break;
1102 SWAP_USHORT(next_ifd_count
);
1104 pos
.QuadPart
= next_ifd_count
* sizeof(*entry
);
1105 hr
= IStream_Seek(input
, pos
, SEEK_CUR
, NULL
);
1106 if (FAILED(hr
)) break;
1109 if (hr
!= S_OK
|| i
== 4096)
1111 HeapFree(GetProcessHeap(), 0, entry
);
1112 return WINCODEC_ERR_BADMETADATAHEADER
;
1115 result
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(*result
));
1118 HeapFree(GetProcessHeap(), 0, entry
);
1119 return E_OUTOFMEMORY
;
1122 for (i
= 0; i
< count
; i
++)
1124 hr
= load_IFD_entry(input
, &entry
[i
], &result
[i
], native_byte_order
);
1127 HeapFree(GetProcessHeap(), 0, entry
);
1128 HeapFree(GetProcessHeap(), 0, result
);
1133 HeapFree(GetProcessHeap(), 0, entry
);
1136 *item_count
= count
;
1141 static const MetadataHandlerVtbl IfdMetadataReader_Vtbl
= {
1143 &CLSID_WICIfdMetadataReader
,
1147 HRESULT
IfdMetadataReader_CreateInstance(IUnknown
*pUnkOuter
, REFIID iid
, void **ppv
)
1149 return MetadataReader_Create(&IfdMetadataReader_Vtbl
, pUnkOuter
, iid
, ppv
);