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
24 #define NONAMELESSUNION
30 #include "propvarutil.h"
32 #include "wincodecs_private.h"
34 #include "wine/debug.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs
);
38 typedef struct MetadataHandler
{
39 IWICMetadataWriter IWICMetadataWriter_iface
;
41 IWICPersistStream IWICPersistStream_iface
;
42 const MetadataHandlerVtbl
*vtable
;
45 CRITICAL_SECTION lock
;
48 static inline MetadataHandler
*impl_from_IWICMetadataWriter(IWICMetadataWriter
*iface
)
50 return CONTAINING_RECORD(iface
, MetadataHandler
, IWICMetadataWriter_iface
);
53 static inline MetadataHandler
*impl_from_IWICPersistStream(IWICPersistStream
*iface
)
55 return CONTAINING_RECORD(iface
, MetadataHandler
, IWICPersistStream_iface
);
58 static void MetadataHandler_FreeItems(MetadataHandler
*This
)
62 for (i
=0; i
<This
->item_count
; i
++)
64 PropVariantClear(&This
->items
[i
].schema
);
65 PropVariantClear(&This
->items
[i
].id
);
66 PropVariantClear(&This
->items
[i
].value
);
69 HeapFree(GetProcessHeap(), 0, This
->items
);
72 static HRESULT
MetadataHandlerEnum_Create(MetadataHandler
*parent
, DWORD index
,
73 IWICEnumMetadataItem
**ppIEnumMetadataItem
);
75 static HRESULT WINAPI
MetadataHandler_QueryInterface(IWICMetadataWriter
*iface
, REFIID iid
,
78 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
79 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
81 if (!ppv
) return E_INVALIDARG
;
83 if (IsEqualIID(&IID_IUnknown
, iid
) ||
84 IsEqualIID(&IID_IWICMetadataReader
, iid
) ||
85 (IsEqualIID(&IID_IWICMetadataWriter
, iid
) && This
->vtable
->is_writer
))
87 *ppv
= &This
->IWICMetadataWriter_iface
;
89 else if (IsEqualIID(&IID_IPersist
, iid
) ||
90 IsEqualIID(&IID_IPersistStream
, iid
) ||
91 IsEqualIID(&IID_IWICPersistStream
, iid
))
93 *ppv
= &This
->IWICPersistStream_iface
;
101 IUnknown_AddRef((IUnknown
*)*ppv
);
105 static ULONG WINAPI
MetadataHandler_AddRef(IWICMetadataWriter
*iface
)
107 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
108 ULONG ref
= InterlockedIncrement(&This
->ref
);
110 TRACE("(%p) refcount=%lu\n", iface
, ref
);
115 static ULONG WINAPI
MetadataHandler_Release(IWICMetadataWriter
*iface
)
117 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
118 ULONG ref
= InterlockedDecrement(&This
->ref
);
120 TRACE("(%p) refcount=%lu\n", iface
, ref
);
124 MetadataHandler_FreeItems(This
);
125 This
->lock
.DebugInfo
->Spare
[0] = 0;
126 DeleteCriticalSection(&This
->lock
);
127 HeapFree(GetProcessHeap(), 0, This
);
133 static HRESULT WINAPI
MetadataHandler_GetMetadataHandlerInfo(IWICMetadataWriter
*iface
,
134 IWICMetadataHandlerInfo
**ppIHandler
)
137 IWICComponentInfo
*component_info
;
138 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
140 TRACE("%p,%p\n", iface
, ppIHandler
);
142 hr
= CreateComponentInfo(This
->vtable
->clsid
, &component_info
);
143 if (FAILED(hr
)) return hr
;
145 hr
= IWICComponentInfo_QueryInterface(component_info
, &IID_IWICMetadataHandlerInfo
,
146 (void **)ppIHandler
);
148 IWICComponentInfo_Release(component_info
);
152 static HRESULT WINAPI
MetadataHandler_GetMetadataFormat(IWICMetadataWriter
*iface
,
153 GUID
*pguidMetadataFormat
)
156 IWICMetadataHandlerInfo
*metadata_info
;
158 TRACE("%p,%p\n", iface
, pguidMetadataFormat
);
160 if (!pguidMetadataFormat
) return E_INVALIDARG
;
162 hr
= MetadataHandler_GetMetadataHandlerInfo(iface
, &metadata_info
);
163 if (FAILED(hr
)) return hr
;
165 hr
= IWICMetadataHandlerInfo_GetMetadataFormat(metadata_info
, pguidMetadataFormat
);
166 IWICMetadataHandlerInfo_Release(metadata_info
);
171 static HRESULT WINAPI
MetadataHandler_GetCount(IWICMetadataWriter
*iface
,
174 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
176 TRACE("%p,%p\n", iface
, pcCount
);
178 if (!pcCount
) return E_INVALIDARG
;
180 *pcCount
= This
->item_count
;
184 static HRESULT WINAPI
MetadataHandler_GetValueByIndex(IWICMetadataWriter
*iface
,
185 UINT index
, PROPVARIANT
*schema
, PROPVARIANT
*id
, PROPVARIANT
*value
)
188 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
190 TRACE("%p,%u,%p,%p,%p\n", iface
, index
, schema
, id
, value
);
192 EnterCriticalSection(&This
->lock
);
194 if (index
>= This
->item_count
)
196 LeaveCriticalSection(&This
->lock
);
201 hr
= PropVariantCopy(schema
, &This
->items
[index
].schema
);
203 if (SUCCEEDED(hr
) && id
)
204 hr
= PropVariantCopy(id
, &This
->items
[index
].id
);
206 if (SUCCEEDED(hr
) && value
)
207 hr
= PropVariantCopy(value
, &This
->items
[index
].value
);
209 LeaveCriticalSection(&This
->lock
);
213 static HRESULT WINAPI
MetadataHandler_GetValue(IWICMetadataWriter
*iface
,
214 const PROPVARIANT
*schema
, const PROPVARIANT
*id
, PROPVARIANT
*value
)
217 HRESULT hr
= WINCODEC_ERR_PROPERTYNOTFOUND
;
218 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
220 TRACE("(%p,%s,%s,%p)\n", iface
, wine_dbgstr_variant((const VARIANT
*)schema
), wine_dbgstr_variant((const VARIANT
*)id
), value
);
222 if (!id
) return E_INVALIDARG
;
224 EnterCriticalSection(&This
->lock
);
226 for (i
= 0; i
< This
->item_count
; i
++)
228 if (schema
&& This
->items
[i
].schema
.vt
!= VT_EMPTY
)
230 if (PropVariantCompareEx(schema
, &This
->items
[i
].schema
, 0, PVCF_USESTRCMPI
) != 0) continue;
233 if (PropVariantCompareEx(id
, &This
->items
[i
].id
, 0, PVCF_USESTRCMPI
) != 0) continue;
235 hr
= value
? PropVariantCopy(value
, &This
->items
[i
].value
) : S_OK
;
239 LeaveCriticalSection(&This
->lock
);
243 static HRESULT WINAPI
MetadataHandler_GetEnumerator(IWICMetadataWriter
*iface
,
244 IWICEnumMetadataItem
**ppIEnumMetadata
)
246 MetadataHandler
*This
= impl_from_IWICMetadataWriter(iface
);
247 TRACE("(%p,%p)\n", iface
, ppIEnumMetadata
);
248 return MetadataHandlerEnum_Create(This
, 0, ppIEnumMetadata
);
251 static HRESULT WINAPI
MetadataHandler_SetValue(IWICMetadataWriter
*iface
,
252 const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
, const PROPVARIANT
*pvarValue
)
254 FIXME("(%p,%p,%p,%p): stub\n", iface
, pvarSchema
, pvarId
, pvarValue
);
258 static HRESULT WINAPI
MetadataHandler_SetValueByIndex(IWICMetadataWriter
*iface
,
259 UINT nIndex
, const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
, const PROPVARIANT
*pvarValue
)
261 FIXME("(%p,%u,%p,%p,%p): stub\n", iface
, nIndex
, pvarSchema
, pvarId
, pvarValue
);
265 static HRESULT WINAPI
MetadataHandler_RemoveValue(IWICMetadataWriter
*iface
,
266 const PROPVARIANT
*pvarSchema
, const PROPVARIANT
*pvarId
)
268 FIXME("(%p,%p,%p): stub\n", iface
, pvarSchema
, pvarId
);
272 static HRESULT WINAPI
MetadataHandler_RemoveValueByIndex(IWICMetadataWriter
*iface
,
275 FIXME("(%p,%u): stub\n", iface
, nIndex
);
279 static const IWICMetadataWriterVtbl MetadataHandler_Vtbl
= {
280 MetadataHandler_QueryInterface
,
281 MetadataHandler_AddRef
,
282 MetadataHandler_Release
,
283 MetadataHandler_GetMetadataFormat
,
284 MetadataHandler_GetMetadataHandlerInfo
,
285 MetadataHandler_GetCount
,
286 MetadataHandler_GetValueByIndex
,
287 MetadataHandler_GetValue
,
288 MetadataHandler_GetEnumerator
,
289 MetadataHandler_SetValue
,
290 MetadataHandler_SetValueByIndex
,
291 MetadataHandler_RemoveValue
,
292 MetadataHandler_RemoveValueByIndex
295 static HRESULT WINAPI
MetadataHandler_PersistStream_QueryInterface(IWICPersistStream
*iface
,
296 REFIID iid
, void **ppv
)
298 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
299 return IWICMetadataWriter_QueryInterface(&This
->IWICMetadataWriter_iface
, iid
, ppv
);
302 static ULONG WINAPI
MetadataHandler_PersistStream_AddRef(IWICPersistStream
*iface
)
304 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
305 return IWICMetadataWriter_AddRef(&This
->IWICMetadataWriter_iface
);
308 static ULONG WINAPI
MetadataHandler_PersistStream_Release(IWICPersistStream
*iface
)
310 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
311 return IWICMetadataWriter_Release(&This
->IWICMetadataWriter_iface
);
314 static HRESULT WINAPI
MetadataHandler_GetClassID(IWICPersistStream
*iface
,
317 FIXME("(%p,%p): stub\n", iface
, pClassID
);
321 static HRESULT WINAPI
MetadataHandler_IsDirty(IWICPersistStream
*iface
)
323 FIXME("(%p): stub\n", iface
);
327 static HRESULT WINAPI
MetadataHandler_Load(IWICPersistStream
*iface
,
330 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
331 TRACE("(%p,%p)\n", iface
, pStm
);
332 return IWICPersistStream_LoadEx(&This
->IWICPersistStream_iface
, pStm
, NULL
, WICPersistOptionDefault
);
335 static HRESULT WINAPI
MetadataHandler_Save(IWICPersistStream
*iface
,
336 IStream
*pStm
, BOOL fClearDirty
)
338 FIXME("(%p,%p,%i): stub\n", iface
, pStm
, fClearDirty
);
342 static HRESULT WINAPI
MetadataHandler_GetSizeMax(IWICPersistStream
*iface
,
343 ULARGE_INTEGER
*pcbSize
)
345 FIXME("(%p,%p): stub\n", iface
, pcbSize
);
349 static HRESULT WINAPI
MetadataHandler_LoadEx(IWICPersistStream
*iface
,
350 IStream
*pIStream
, const GUID
*pguidPreferredVendor
, DWORD dwPersistOptions
)
352 MetadataHandler
*This
= impl_from_IWICPersistStream(iface
);
354 MetadataItem
*new_items
=NULL
;
357 TRACE("(%p,%p,%s,%lx)\n", iface
, pIStream
, debugstr_guid(pguidPreferredVendor
), dwPersistOptions
);
359 EnterCriticalSection(&This
->lock
);
361 hr
= This
->vtable
->fnLoad(pIStream
, pguidPreferredVendor
, dwPersistOptions
,
362 &new_items
, &item_count
);
366 MetadataHandler_FreeItems(This
);
367 This
->items
= new_items
;
368 This
->item_count
= item_count
;
371 LeaveCriticalSection(&This
->lock
);
376 static HRESULT WINAPI
MetadataHandler_SaveEx(IWICPersistStream
*iface
,
377 IStream
*pIStream
, DWORD dwPersistOptions
, BOOL fClearDirty
)
379 FIXME("(%p,%p,%lx,%i): stub\n", iface
, pIStream
, dwPersistOptions
, fClearDirty
);
383 static const IWICPersistStreamVtbl MetadataHandler_PersistStream_Vtbl
= {
384 MetadataHandler_PersistStream_QueryInterface
,
385 MetadataHandler_PersistStream_AddRef
,
386 MetadataHandler_PersistStream_Release
,
387 MetadataHandler_GetClassID
,
388 MetadataHandler_IsDirty
,
389 MetadataHandler_Load
,
390 MetadataHandler_Save
,
391 MetadataHandler_GetSizeMax
,
392 MetadataHandler_LoadEx
,
393 MetadataHandler_SaveEx
396 HRESULT
MetadataReader_Create(const MetadataHandlerVtbl
*vtable
, REFIID iid
, void** ppv
)
398 MetadataHandler
*This
;
401 TRACE("%s\n", debugstr_guid(vtable
->clsid
));
405 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandler
));
406 if (!This
) return E_OUTOFMEMORY
;
408 This
->IWICMetadataWriter_iface
.lpVtbl
= &MetadataHandler_Vtbl
;
409 This
->IWICPersistStream_iface
.lpVtbl
= &MetadataHandler_PersistStream_Vtbl
;
411 This
->vtable
= vtable
;
413 This
->item_count
= 0;
415 InitializeCriticalSection(&This
->lock
);
416 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": MetadataHandler.lock");
418 hr
= IWICMetadataWriter_QueryInterface(&This
->IWICMetadataWriter_iface
, iid
, ppv
);
420 IWICMetadataWriter_Release(&This
->IWICMetadataWriter_iface
);
425 typedef struct MetadataHandlerEnum
{
426 IWICEnumMetadataItem IWICEnumMetadataItem_iface
;
428 MetadataHandler
*parent
;
430 } MetadataHandlerEnum
;
432 static inline MetadataHandlerEnum
*impl_from_IWICEnumMetadataItem(IWICEnumMetadataItem
*iface
)
434 return CONTAINING_RECORD(iface
, MetadataHandlerEnum
, IWICEnumMetadataItem_iface
);
437 static HRESULT WINAPI
MetadataHandlerEnum_QueryInterface(IWICEnumMetadataItem
*iface
, REFIID iid
,
440 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
441 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(iid
), ppv
);
443 if (!ppv
) return E_INVALIDARG
;
445 if (IsEqualIID(&IID_IUnknown
, iid
) ||
446 IsEqualIID(&IID_IWICEnumMetadataItem
, iid
))
448 *ppv
= &This
->IWICEnumMetadataItem_iface
;
453 return E_NOINTERFACE
;
456 IUnknown_AddRef((IUnknown
*)*ppv
);
460 static ULONG WINAPI
MetadataHandlerEnum_AddRef(IWICEnumMetadataItem
*iface
)
462 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
463 ULONG ref
= InterlockedIncrement(&This
->ref
);
465 TRACE("(%p) refcount=%lu\n", iface
, ref
);
470 static ULONG WINAPI
MetadataHandlerEnum_Release(IWICEnumMetadataItem
*iface
)
472 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
473 ULONG ref
= InterlockedDecrement(&This
->ref
);
475 TRACE("(%p) refcount=%lu\n", iface
, ref
);
479 IWICMetadataWriter_Release(&This
->parent
->IWICMetadataWriter_iface
);
480 HeapFree(GetProcessHeap(), 0, This
);
486 static HRESULT WINAPI
MetadataHandlerEnum_Next(IWICEnumMetadataItem
*iface
,
487 ULONG celt
, PROPVARIANT
*rgeltSchema
, PROPVARIANT
*rgeltId
,
488 PROPVARIANT
*rgeltValue
, ULONG
*pceltFetched
)
490 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
496 TRACE("(%p,%li)\n", iface
, celt
);
499 pceltFetched
= &fetched
;
501 EnterCriticalSection(&This
->parent
->lock
);
503 if (This
->index
>= This
->parent
->item_count
)
506 LeaveCriticalSection(&This
->parent
->lock
);
510 new_index
= min(This
->parent
->item_count
, This
->index
+ celt
);
511 *pceltFetched
= new_index
- This
->index
;
515 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
516 hr
= PropVariantCopy(&rgeltSchema
[i
], &This
->parent
->items
[i
+This
->index
].schema
);
519 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
520 hr
= PropVariantCopy(&rgeltId
[i
], &This
->parent
->items
[i
+This
->index
].id
);
524 for (i
=0; SUCCEEDED(hr
) && i
< *pceltFetched
; i
++)
525 hr
= PropVariantCopy(&rgeltValue
[i
], &This
->parent
->items
[i
+This
->index
].value
);
530 This
->index
= new_index
;
533 LeaveCriticalSection(&This
->parent
->lock
);
538 static HRESULT WINAPI
MetadataHandlerEnum_Skip(IWICEnumMetadataItem
*iface
,
541 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
543 EnterCriticalSection(&This
->parent
->lock
);
547 LeaveCriticalSection(&This
->parent
->lock
);
552 static HRESULT WINAPI
MetadataHandlerEnum_Reset(IWICEnumMetadataItem
*iface
)
554 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
556 EnterCriticalSection(&This
->parent
->lock
);
560 LeaveCriticalSection(&This
->parent
->lock
);
565 static HRESULT WINAPI
MetadataHandlerEnum_Clone(IWICEnumMetadataItem
*iface
,
566 IWICEnumMetadataItem
**ppIEnumMetadataItem
)
568 MetadataHandlerEnum
*This
= impl_from_IWICEnumMetadataItem(iface
);
571 EnterCriticalSection(&This
->parent
->lock
);
573 hr
= MetadataHandlerEnum_Create(This
->parent
, This
->index
, ppIEnumMetadataItem
);
575 LeaveCriticalSection(&This
->parent
->lock
);
580 static const IWICEnumMetadataItemVtbl MetadataHandlerEnum_Vtbl
= {
581 MetadataHandlerEnum_QueryInterface
,
582 MetadataHandlerEnum_AddRef
,
583 MetadataHandlerEnum_Release
,
584 MetadataHandlerEnum_Next
,
585 MetadataHandlerEnum_Skip
,
586 MetadataHandlerEnum_Reset
,
587 MetadataHandlerEnum_Clone
590 static HRESULT
MetadataHandlerEnum_Create(MetadataHandler
*parent
, DWORD index
,
591 IWICEnumMetadataItem
**ppIEnumMetadataItem
)
593 MetadataHandlerEnum
*This
;
595 if (!ppIEnumMetadataItem
) return E_INVALIDARG
;
597 *ppIEnumMetadataItem
= NULL
;
599 This
= HeapAlloc(GetProcessHeap(), 0, sizeof(MetadataHandlerEnum
));
600 if (!This
) return E_OUTOFMEMORY
;
602 IWICMetadataWriter_AddRef(&parent
->IWICMetadataWriter_iface
);
604 This
->IWICEnumMetadataItem_iface
.lpVtbl
= &MetadataHandlerEnum_Vtbl
;
606 This
->parent
= parent
;
609 *ppIEnumMetadataItem
= &This
->IWICEnumMetadataItem_iface
;
614 static HRESULT
LoadUnknownMetadata(IStream
*input
, const GUID
*preferred_vendor
,
615 DWORD persist_options
, MetadataItem
**items
, DWORD
*item_count
)
618 MetadataItem
*result
;
625 hr
= IStream_Stat(input
, &stat
, STATFLAG_NONAME
);
629 data
= HeapAlloc(GetProcessHeap(), 0, stat
.cbSize
.QuadPart
);
630 if (!data
) return E_OUTOFMEMORY
;
632 hr
= IStream_Read(input
, data
, stat
.cbSize
.QuadPart
, &bytesread
);
633 if (bytesread
!= stat
.cbSize
.QuadPart
) hr
= E_FAIL
;
636 HeapFree(GetProcessHeap(), 0, data
);
640 result
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(MetadataItem
));
643 HeapFree(GetProcessHeap(), 0, data
);
644 return E_OUTOFMEMORY
;
647 PropVariantInit(&result
[0].schema
);
648 PropVariantInit(&result
[0].id
);
649 PropVariantInit(&result
[0].value
);
651 result
[0].value
.vt
= VT_BLOB
;
652 result
[0].value
.blob
.cbSize
= bytesread
;
653 result
[0].value
.blob
.pBlobData
= data
;
661 static const MetadataHandlerVtbl UnknownMetadataReader_Vtbl
= {
663 &CLSID_WICUnknownMetadataReader
,
667 HRESULT
UnknownMetadataReader_CreateInstance(REFIID iid
, void** ppv
)
669 return MetadataReader_Create(&UnknownMetadataReader_Vtbl
, iid
, ppv
);
672 #define SWAP_USHORT(x) do { if (!native_byte_order) (x) = RtlUshortByteSwap(x); } while(0)
673 #define SWAP_ULONG(x) do { if (!native_byte_order) (x) = RtlUlongByteSwap(x); } while(0)
674 #define SWAP_ULONGLONG(x) do { if (!native_byte_order) (x) = RtlUlonglongByteSwap(x); } while(0)
688 #define IFD_RATIONAL 5
690 #define IFD_UNDEFINED 7
693 #define IFD_SRATIONAL 10
695 #define IFD_DOUBLE 12
698 static int tag_to_vt(SHORT tag
)
700 static const int tag2vt
[] =
703 VT_UI1
, /* IFD_BYTE 1 */
704 VT_LPSTR
, /* IFD_ASCII 2 */
705 VT_UI2
, /* IFD_SHORT 3 */
706 VT_UI4
, /* IFD_LONG 4 */
707 VT_UI8
, /* IFD_RATIONAL 5 */
708 VT_I1
, /* IFD_SBYTE 6 */
709 VT_BLOB
, /* IFD_UNDEFINED 7 */
710 VT_I2
, /* IFD_SSHORT 8 */
711 VT_I4
, /* IFD_SLONG 9 */
712 VT_I8
, /* IFD_SRATIONAL 10 */
713 VT_R4
, /* IFD_FLOAT 11 */
714 VT_R8
, /* IFD_DOUBLE 12 */
715 VT_BLOB
, /* IFD_IFD 13 */
717 return (tag
> 0 && tag
<= 13) ? tag2vt
[tag
] : VT_BLOB
;
720 static HRESULT
load_IFD_entry(IStream
*input
, const struct IFD_entry
*entry
,
721 MetadataItem
*item
, BOOL native_byte_order
)
723 ULONG count
, value
, i
, bytesread
;
728 item
->schema
.vt
= VT_EMPTY
;
729 item
->id
.vt
= VT_UI2
;
730 item
->id
.uiVal
= entry
->id
;
731 SWAP_USHORT(item
->id
.uiVal
);
733 count
= entry
->count
;
737 item
->value
.vt
= tag_to_vt(type
);
738 value
= entry
->value
;
745 if (!count
) count
= 1;
749 const BYTE
*data
= (const BYTE
*)&entry
->value
;
752 item
->value
.bVal
= data
[0];
755 item
->value
.vt
|= VT_VECTOR
;
756 item
->value
.caub
.cElems
= count
;
757 item
->value
.caub
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
);
758 memcpy(item
->value
.caub
.pElems
, data
, count
);
763 item
->value
.vt
|= VT_VECTOR
;
764 item
->value
.caub
.cElems
= count
;
765 item
->value
.caub
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
);
766 if (!item
->value
.caub
.pElems
) return E_OUTOFMEMORY
;
768 pos
.QuadPart
= value
;
769 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
772 HeapFree(GetProcessHeap(), 0, item
->value
.caub
.pElems
);
775 hr
= IStream_Read(input
, item
->value
.caub
.pElems
, count
, &bytesread
);
776 if (bytesread
!= count
) hr
= E_FAIL
;
779 HeapFree(GetProcessHeap(), 0, item
->value
.caub
.pElems
);
785 if (!count
) count
= 1;
789 const SHORT
*data
= (const SHORT
*)&entry
->value
;
793 item
->value
.uiVal
= data
[0];
794 SWAP_USHORT(item
->value
.uiVal
);
798 item
->value
.vt
|= VT_VECTOR
;
799 item
->value
.caui
.cElems
= count
;
800 item
->value
.caui
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 2);
801 memcpy(item
->value
.caui
.pElems
, data
, count
* 2);
802 for (i
= 0; i
< count
; i
++)
803 SWAP_USHORT(item
->value
.caui
.pElems
[i
]);
808 item
->value
.vt
|= VT_VECTOR
;
809 item
->value
.caui
.cElems
= count
;
810 item
->value
.caui
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 2);
811 if (!item
->value
.caui
.pElems
) return E_OUTOFMEMORY
;
813 pos
.QuadPart
= value
;
814 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
817 HeapFree(GetProcessHeap(), 0, item
->value
.caui
.pElems
);
820 hr
= IStream_Read(input
, item
->value
.caui
.pElems
, count
* 2, &bytesread
);
821 if (bytesread
!= count
* 2) hr
= E_FAIL
;
824 HeapFree(GetProcessHeap(), 0, item
->value
.caui
.pElems
);
827 for (i
= 0; i
< count
; i
++)
828 SWAP_USHORT(item
->value
.caui
.pElems
[i
]);
833 if (!count
) count
= 1;
837 item
->value
.ulVal
= value
;
841 item
->value
.vt
|= VT_VECTOR
;
842 item
->value
.caul
.cElems
= count
;
843 item
->value
.caul
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 4);
844 if (!item
->value
.caul
.pElems
) return E_OUTOFMEMORY
;
846 pos
.QuadPart
= value
;
847 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
850 HeapFree(GetProcessHeap(), 0, item
->value
.caul
.pElems
);
853 hr
= IStream_Read(input
, item
->value
.caul
.pElems
, count
* 4, &bytesread
);
854 if (bytesread
!= count
* 4) hr
= E_FAIL
;
857 HeapFree(GetProcessHeap(), 0, item
->value
.caul
.pElems
);
860 for (i
= 0; i
< count
; i
++)
861 SWAP_ULONG(item
->value
.caul
.pElems
[i
]);
868 FIXME("IFD field type %d, count 0\n", type
);
869 item
->value
.vt
= VT_EMPTY
;
877 pos
.QuadPart
= value
;
878 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
879 if (FAILED(hr
)) return hr
;
881 hr
= IStream_Read(input
, &ull
, sizeof(ull
), &bytesread
);
882 if (bytesread
!= sizeof(ull
)) hr
= E_FAIL
;
883 if (hr
!= S_OK
) return hr
;
885 item
->value
.uhVal
.QuadPart
= ull
;
887 if (type
== IFD_DOUBLE
)
888 SWAP_ULONGLONG(item
->value
.uhVal
.QuadPart
);
891 SWAP_ULONG(item
->value
.uhVal
.LowPart
);
892 SWAP_ULONG(item
->value
.uhVal
.HighPart
);
898 item
->value
.vt
|= VT_VECTOR
;
899 item
->value
.cauh
.cElems
= count
;
900 item
->value
.cauh
.pElems
= HeapAlloc(GetProcessHeap(), 0, count
* 8);
901 if (!item
->value
.cauh
.pElems
) return E_OUTOFMEMORY
;
903 pos
.QuadPart
= value
;
904 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
907 HeapFree(GetProcessHeap(), 0, item
->value
.cauh
.pElems
);
910 hr
= IStream_Read(input
, item
->value
.cauh
.pElems
, count
* 8, &bytesread
);
911 if (bytesread
!= count
* 8) hr
= E_FAIL
;
914 HeapFree(GetProcessHeap(), 0, item
->value
.cauh
.pElems
);
917 for (i
= 0; i
< count
; i
++)
919 if (type
== IFD_DOUBLE
)
920 SWAP_ULONGLONG(item
->value
.cauh
.pElems
[i
].QuadPart
);
923 SWAP_ULONG(item
->value
.cauh
.pElems
[i
].LowPart
);
924 SWAP_ULONG(item
->value
.cauh
.pElems
[i
].HighPart
);
930 item
->value
.pszVal
= HeapAlloc(GetProcessHeap(), 0, count
+ 1);
931 if (!item
->value
.pszVal
) return E_OUTOFMEMORY
;
935 const char *data
= (const char *)&entry
->value
;
936 memcpy(item
->value
.pszVal
, data
, count
);
937 item
->value
.pszVal
[count
] = 0;
941 pos
.QuadPart
= value
;
942 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
945 HeapFree(GetProcessHeap(), 0, item
->value
.pszVal
);
948 hr
= IStream_Read(input
, item
->value
.pszVal
, count
, &bytesread
);
949 if (bytesread
!= count
) hr
= E_FAIL
;
952 HeapFree(GetProcessHeap(), 0, item
->value
.pszVal
);
955 item
->value
.pszVal
[count
] = 0;
960 FIXME("IFD field type %d, count 0\n", type
);
961 item
->value
.vt
= VT_EMPTY
;
965 item
->value
.blob
.pBlobData
= HeapAlloc(GetProcessHeap(), 0, count
);
966 if (!item
->value
.blob
.pBlobData
) return E_OUTOFMEMORY
;
968 item
->value
.blob
.cbSize
= count
;
972 const char *data
= (const char *)&entry
->value
;
973 memcpy(item
->value
.blob
.pBlobData
, data
, count
);
977 pos
.QuadPart
= value
;
978 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
981 HeapFree(GetProcessHeap(), 0, item
->value
.blob
.pBlobData
);
984 hr
= IStream_Read(input
, item
->value
.blob
.pBlobData
, count
, &bytesread
);
985 if (bytesread
!= count
) hr
= E_FAIL
;
988 HeapFree(GetProcessHeap(), 0, item
->value
.blob
.pBlobData
);
993 FIXME("loading field of type %d, count %lu is not implemented\n", type
, count
);
999 static HRESULT
LoadIfdMetadata(IStream
*input
, const GUID
*preferred_vendor
,
1000 DWORD persist_options
, MetadataItem
**items
, DWORD
*item_count
)
1003 MetadataItem
*result
;
1005 struct IFD_entry
*entry
;
1006 BOOL native_byte_order
= TRUE
;
1011 #ifdef WORDS_BIGENDIAN
1012 if (persist_options
& WICPersistOptionLittleEndian
)
1014 if (persist_options
& WICPersistOptionBigEndian
)
1016 native_byte_order
= FALSE
;
1018 hr
= IStream_Read(input
, &count
, sizeof(count
), &bytesread
);
1019 if (bytesread
!= sizeof(count
)) hr
= E_FAIL
;
1020 if (hr
!= S_OK
) return hr
;
1024 entry
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(*entry
));
1025 if (!entry
) return E_OUTOFMEMORY
;
1027 hr
= IStream_Read(input
, entry
, count
* sizeof(*entry
), &bytesread
);
1028 if (bytesread
!= count
* sizeof(*entry
)) hr
= E_FAIL
;
1031 HeapFree(GetProcessHeap(), 0, entry
);
1035 /* limit number of IFDs to 4096 to avoid infinite loop */
1036 for (i
= 0; i
< 4096; i
++)
1038 ULONG next_ifd_offset
;
1040 USHORT next_ifd_count
;
1042 hr
= IStream_Read(input
, &next_ifd_offset
, sizeof(next_ifd_offset
), &bytesread
);
1043 if (bytesread
!= sizeof(next_ifd_offset
)) hr
= E_FAIL
;
1044 if (hr
!= S_OK
) break;
1046 SWAP_ULONG(next_ifd_offset
);
1047 if (!next_ifd_offset
) break;
1049 pos
.QuadPart
= next_ifd_offset
;
1050 hr
= IStream_Seek(input
, pos
, SEEK_SET
, NULL
);
1051 if (FAILED(hr
)) break;
1053 hr
= IStream_Read(input
, &next_ifd_count
, sizeof(next_ifd_count
), &bytesread
);
1054 if (bytesread
!= sizeof(next_ifd_count
)) hr
= E_FAIL
;
1055 if (hr
!= S_OK
) break;
1057 SWAP_USHORT(next_ifd_count
);
1059 pos
.QuadPart
= next_ifd_count
* sizeof(*entry
);
1060 hr
= IStream_Seek(input
, pos
, SEEK_CUR
, NULL
);
1061 if (FAILED(hr
)) break;
1064 if (hr
!= S_OK
|| i
== 4096)
1066 HeapFree(GetProcessHeap(), 0, entry
);
1067 return WINCODEC_ERR_BADMETADATAHEADER
;
1070 result
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, count
* sizeof(*result
));
1073 HeapFree(GetProcessHeap(), 0, entry
);
1074 return E_OUTOFMEMORY
;
1077 for (i
= 0; i
< count
; i
++)
1079 hr
= load_IFD_entry(input
, &entry
[i
], &result
[i
], native_byte_order
);
1082 HeapFree(GetProcessHeap(), 0, entry
);
1083 HeapFree(GetProcessHeap(), 0, result
);
1088 HeapFree(GetProcessHeap(), 0, entry
);
1091 *item_count
= count
;
1096 static const MetadataHandlerVtbl IfdMetadataReader_Vtbl
= {
1098 &CLSID_WICIfdMetadataReader
,
1102 HRESULT
IfdMetadataReader_CreateInstance(REFIID iid
, void **ppv
)
1104 return MetadataReader_Create(&IfdMetadataReader_Vtbl
, iid
, ppv
);