| /* | |
| * Copyright 2016 Andrew Eikum for CodeWeavers | |
| * Copyright 2017 Dmitry Timoshkov | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #include "config.h" | |
| #include <stdarg.h> | |
| #define COBJMACROS | |
| #define NONAMELESSUNION | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "objbase.h" | |
| #include "propvarutil.h" | |
| #include "wincodecs_private.h" | |
| #include "wine/debug.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(wincodecs); | |
| static const WCHAR *map_shortname_to_schema(const GUID *format, const WCHAR *name); | |
| typedef struct { | |
| IWICMetadataQueryReader IWICMetadataQueryReader_iface; | |
| LONG ref; | |
| IWICMetadataBlockReader *block; | |
| WCHAR *root; | |
| } QueryReader; | |
| static inline QueryReader *impl_from_IWICMetadataQueryReader(IWICMetadataQueryReader *iface) | |
| { | |
| return CONTAINING_RECORD(iface, QueryReader, IWICMetadataQueryReader_iface); | |
| } | |
| static HRESULT WINAPI mqr_QueryInterface(IWICMetadataQueryReader *iface, REFIID riid, | |
| void **ppvObject) | |
| { | |
| QueryReader *This = impl_from_IWICMetadataQueryReader(iface); | |
| TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObject); | |
| if (IsEqualGUID(riid, &IID_IUnknown) || | |
| IsEqualGUID(riid, &IID_IWICMetadataQueryReader)) | |
| *ppvObject = &This->IWICMetadataQueryReader_iface; | |
| else | |
| *ppvObject = NULL; | |
| if (*ppvObject) | |
| { | |
| IUnknown_AddRef((IUnknown*)*ppvObject); | |
| return S_OK; | |
| } | |
| return E_NOINTERFACE; | |
| } | |
| static ULONG WINAPI mqr_AddRef(IWICMetadataQueryReader *iface) | |
| { | |
| QueryReader *This = impl_from_IWICMetadataQueryReader(iface); | |
| ULONG ref = InterlockedIncrement(&This->ref); | |
| TRACE("(%p) refcount=%u\n", This, ref); | |
| return ref; | |
| } | |
| static ULONG WINAPI mqr_Release(IWICMetadataQueryReader *iface) | |
| { | |
| QueryReader *This = impl_from_IWICMetadataQueryReader(iface); | |
| ULONG ref = InterlockedDecrement(&This->ref); | |
| TRACE("(%p) refcount=%u\n", This, ref); | |
| if (!ref) | |
| { | |
| IWICMetadataBlockReader_Release(This->block); | |
| HeapFree(GetProcessHeap(), 0, This->root); | |
| HeapFree(GetProcessHeap(), 0, This); | |
| } | |
| return ref; | |
| } | |
| static HRESULT WINAPI mqr_GetContainerFormat(IWICMetadataQueryReader *iface, GUID *format) | |
| { | |
| QueryReader *This = impl_from_IWICMetadataQueryReader(iface); | |
| TRACE("(%p,%p)\n", This, format); | |
| return IWICMetadataBlockReader_GetContainerFormat(This->block, format); | |
| } | |
| static HRESULT WINAPI mqr_GetLocation(IWICMetadataQueryReader *iface, UINT len, WCHAR *location, UINT *ret_len) | |
| { | |
| static const WCHAR rootW[] = { '/',0 }; | |
| QueryReader *This = impl_from_IWICMetadataQueryReader(iface); | |
| const WCHAR *root; | |
| UINT actual_len; | |
| TRACE("(%p,%u,%p,%p)\n", This, len, location, ret_len); | |
| if (!ret_len) return E_INVALIDARG; | |
| root = This->root ? This->root : rootW; | |
| actual_len = lstrlenW(root) + 1; | |
| if (location) | |
| { | |
| if (len < actual_len) | |
| return WINCODEC_ERR_INSUFFICIENTBUFFER; | |
| memcpy(location, root, actual_len * sizeof(WCHAR)); | |
| } | |
| *ret_len = actual_len; | |
| return S_OK; | |
| } | |
| struct string_t | |
| { | |
| const WCHAR *str; | |
| int len; | |
| }; | |
| static const struct | |
| { | |
| int len; | |
| WCHAR str[10]; | |
| VARTYPE vt; | |
| } str2vt[] = | |
| { | |
| { 4, {'c','h','a','r'}, VT_I1 }, | |
| { 5, {'u','c','h','a','r'}, VT_UI1 }, | |
| { 5, {'s','h','o','r','t'}, VT_I2 }, | |
| { 6, {'u','s','h','o','r','t'}, VT_UI2 }, | |
| { 4, {'l','o','n','g'}, VT_I4 }, | |
| { 5, {'u','l','o','n','g'}, VT_UI4 }, | |
| { 3, {'i','n','t'}, VT_I4 }, | |
| { 4, {'u','i','n','t'}, VT_UI4 }, | |
| { 8, {'l','o','n','g','l','o','n','g'}, VT_I8 }, | |
| { 9, {'u','l','o','n','g','l','o','n','g'}, VT_UI8 }, | |
| { 5, {'f','l','o','a','t'}, VT_R4 }, | |
| { 6, {'d','o','u','b','l','e'}, VT_R8 }, | |
| { 3, {'s','t','r'}, VT_LPSTR }, | |
| { 4, {'w','s','t','r'}, VT_LPWSTR }, | |
| { 4, {'g','u','i','d'}, VT_CLSID }, | |
| { 4, {'b','o','o','l'}, VT_BOOL } | |
| }; | |
| static VARTYPE map_type(struct string_t *str) | |
| { | |
| UINT i; | |
| for (i = 0; i < sizeof(str2vt)/sizeof(str2vt[0]); i++) | |
| { | |
| if (str2vt[i].len == str->len) | |
| { | |
| if (CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, | |
| str->str, str->len, str2vt[i].str, str2vt[i].len) == CSTR_EQUAL) | |
| return str2vt[i].vt; | |
| } | |
| } | |
| WARN("type %s is not recognized\n", wine_dbgstr_wn(str->str, str->len)); | |
| return VT_ILLEGAL; | |
| } | |
| static HRESULT get_token(struct string_t *elem, PROPVARIANT *id, PROPVARIANT *schema, int *idx) | |
| { | |
| const WCHAR *start, *end, *p; | |
| WCHAR *bstr; | |
| struct string_t next_elem; | |
| HRESULT hr; | |
| TRACE("%s, len %d\n", wine_dbgstr_wn(elem->str, elem->len), elem->len); | |
| PropVariantInit(id); | |
| PropVariantInit(schema); | |
| if (!elem->len) return S_OK; | |
| start = elem->str; | |
| if (*start == '[') | |
| { | |
| WCHAR *idx_end; | |
| if (start[1] < '0' || start[1] > '9') return DISP_E_TYPEMISMATCH; | |
| *idx = strtolW(start + 1, &idx_end, 10); | |
| if (idx_end > elem->str + elem->len) return WINCODEC_ERR_INVALIDQUERYREQUEST; | |
| if (*idx_end != ']') return WINCODEC_ERR_INVALIDQUERYREQUEST; | |
| if (*idx < 0) return WINCODEC_ERR_INVALIDQUERYREQUEST; | |
| end = idx_end + 1; | |
| next_elem.str = end; | |
| next_elem.len = elem->len - (end - start); | |
| hr = get_token(&next_elem, id, schema, idx); | |
| if (hr != S_OK) | |
| { | |
| TRACE("get_token error %#x\n", hr); | |
| return hr; | |
| } | |
| elem->len = (end - start) + next_elem.len; | |
| TRACE("indexed %s [%d]\n", wine_dbgstr_wn(elem->str, elem->len), *idx); | |
| return S_OK; | |
| } | |
| else if (*start == '{') | |
| { | |
| VARTYPE vt; | |
| PROPVARIANT next_token; | |
| end = memchrW(start + 1, '=', elem->len - 1); | |
| if (!end) return WINCODEC_ERR_INVALIDQUERYREQUEST; | |
| if (end > elem->str + elem->len) return WINCODEC_ERR_INVALIDQUERYREQUEST; | |
| next_elem.str = start + 1; | |
| next_elem.len = end - start - 1; | |
| vt = map_type(&next_elem); | |
| TRACE("type %s => %d\n", wine_dbgstr_wn(next_elem.str, next_elem.len), vt); | |
| if (vt == VT_ILLEGAL) return WINCODEC_ERR_WRONGSTATE; | |
| next_token.vt = VT_BSTR; | |
| next_token.u.bstrVal = SysAllocStringLen(NULL, elem->len - (end - start) + 1); | |
| if (!next_token.u.bstrVal) return E_OUTOFMEMORY; | |
| bstr = next_token.u.bstrVal; | |
| end++; | |
| p = end; | |
| while (*end && *end != '}' && end - start < elem->len) | |
| { | |
| if (*end == '\\') end++; | |
| *bstr++ = *end++; | |
| } | |
| if (*end != '}') | |
| { | |
| PropVariantClear(&next_token); | |
| return WINCODEC_ERR_INVALIDQUERYREQUEST; | |
| } | |
| *bstr = 0; | |
| TRACE("schema/id %s\n", wine_dbgstr_w(next_token.u.bstrVal)); | |
| if (vt == VT_CLSID) | |
| { | |
| id->vt = VT_CLSID; | |
| id->u.puuid = CoTaskMemAlloc(sizeof(GUID)); | |
| if (!id->u.puuid) | |
| { | |
| PropVariantClear(&next_token); | |
| return E_OUTOFMEMORY; | |
| } | |
| hr = UuidFromStringW(next_token.u.bstrVal, id->u.puuid); | |
| } | |
| else | |
| hr = PropVariantChangeType(id, &next_token, 0, vt); | |
| PropVariantClear(&next_token); | |
| if (hr != S_OK) | |
| { | |
| PropVariantClear(id); | |
| PropVariantClear(schema); | |
| return hr; | |
| } | |
| end++; | |
| if (*end == ':') | |
| { | |
| PROPVARIANT next_id, next_schema; | |
| int next_idx = 0; | |
| next_elem.str = end + 1; | |
| next_elem.len = elem->len - (end - start + 1); | |
| hr = get_token(&next_elem, &next_id, &next_schema, &next_idx); | |
| if (hr != S_OK) | |
| { | |
| TRACE("get_token error %#x\n", hr); | |
| return hr; | |
| } | |
| elem->len = (end - start + 1) + next_elem.len; | |
| TRACE("id %s [%d]\n", wine_dbgstr_wn(elem->str, elem->len), *idx); | |
| if (next_schema.vt != VT_EMPTY) | |
| { | |
| PropVariantClear(&next_id); | |
| PropVariantClear(&next_schema); | |
| return WINCODEC_ERR_WRONGSTATE; | |
| } | |
| *schema = *id; | |
| *id = next_id; | |
| return S_OK; | |
| } | |
| elem->len = end - start; | |
| return S_OK; | |
| } | |
| end = memchrW(start, '/', elem->len); | |
| if (!end) end = start + elem->len; | |
| p = memchrW(start, ':', end - start); | |
| if (p) | |
| { | |
| next_elem.str = p + 1; | |
| next_elem.len = end - p - 1; | |
| elem->len = p - start; | |
| } | |
| else | |
| elem->len = end - start; | |
| id->vt = VT_BSTR; | |
| id->u.bstrVal = SysAllocStringLen(NULL, elem->len + 1); | |
| if (!id->u.bstrVal) return E_OUTOFMEMORY; | |
| bstr = id->u.bstrVal; | |
| p = elem->str; | |
| while (p - elem->str < elem->len) | |
| { | |
| if (*p == '\\') p++; | |
| *bstr++ = *p++; | |
| } | |
| *bstr = 0; | |
| TRACE("%s [%d]\n", wine_dbgstr_variant((VARIANT *)id), *idx); | |
| if (*p == ':') | |
| { | |
| PROPVARIANT next_id, next_schema; | |
| int next_idx = 0; | |
| hr = get_token(&next_elem, &next_id, &next_schema, &next_idx); | |
| if (hr != S_OK) | |
| { | |
| TRACE("get_token error %#x\n", hr); | |
| PropVariantClear(id); | |
| PropVariantClear(schema); | |
| return hr; | |
| } | |
| elem->len += next_elem.len + 1; | |
| TRACE("id %s [%d]\n", wine_dbgstr_wn(elem->str, elem->len), *idx); | |
| if (next_schema.vt != VT_EMPTY) | |
| { | |
| PropVariantClear(&next_id); | |
| PropVariantClear(&next_schema); | |
| PropVariantClear(id); | |
| PropVariantClear(schema); | |
| return WINCODEC_ERR_WRONGSTATE; | |
| } | |
| *schema = *id; | |
| *id = next_id; | |
| } | |
| return S_OK; | |
| } | |
| static HRESULT find_reader_from_block(IWICMetadataBlockReader *block_reader, UINT index, | |
| GUID *guid, IWICMetadataReader **reader) | |
| { | |
| HRESULT hr; | |
| GUID format; | |
| IWICMetadataReader *new_reader; | |
| UINT count, i, matched_index; | |
| *reader = NULL; | |
| hr = IWICMetadataBlockReader_GetCount(block_reader, &count); | |
| if (hr != S_OK) return hr; | |
| matched_index = 0; | |
| for (i = 0; i < count; i++) | |
| { | |
| hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &new_reader); | |
| if (hr != S_OK) return hr; | |
| hr = IWICMetadataReader_GetMetadataFormat(new_reader, &format); | |
| if (hr == S_OK) | |
| { | |
| if (IsEqualGUID(&format, guid)) | |
| { | |
| if (matched_index == index) | |
| { | |
| *reader = new_reader; | |
| return S_OK; | |
| } | |
| matched_index++; | |
| } | |
| } | |
| IWICMetadataReader_Release(new_reader); | |
| if (hr != S_OK) return hr; | |
| } | |
| return WINCODEC_ERR_PROPERTYNOTFOUND; | |
| } | |
| static HRESULT get_next_reader(IWICMetadataReader *reader, UINT index, | |
| GUID *guid, IWICMetadataReader **new_reader) | |
| { | |
| HRESULT hr; | |
| PROPVARIANT schema, id, value; | |
| *new_reader = NULL; | |
| PropVariantInit(&schema); | |
| PropVariantInit(&id); | |
| PropVariantInit(&value); | |
| if (index) | |
| { | |
| schema.vt = VT_UI2; | |
| schema.u.uiVal = index; | |
| } | |
| id.vt = VT_CLSID; | |
| id.u.puuid = guid; | |
| hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value); | |
| if (hr != S_OK) return hr; | |
| if (value.vt == VT_UNKNOWN) | |
| hr = IUnknown_QueryInterface(value.u.punkVal, &IID_IWICMetadataReader, (void **)new_reader); | |
| else | |
| hr = WINCODEC_ERR_UNEXPECTEDMETADATATYPE; | |
| PropVariantClear(&value); | |
| return hr; | |
| } | |
| static HRESULT WINAPI mqr_GetMetadataByName(IWICMetadataQueryReader *iface, LPCWSTR query, PROPVARIANT *value) | |
| { | |
| QueryReader *This = impl_from_IWICMetadataQueryReader(iface); | |
| struct string_t elem; | |
| WCHAR *full_query; | |
| const WCHAR *p; | |
| int index, len; | |
| PROPVARIANT tk_id, tk_schema, new_value; | |
| GUID guid; | |
| IWICMetadataReader *reader; | |
| HRESULT hr = S_OK; | |
| TRACE("(%p,%s,%p)\n", This, wine_dbgstr_w(query), value); | |
| len = lstrlenW(query) + 1; | |
| if (This->root) len += lstrlenW(This->root); | |
| full_query = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); | |
| full_query[0] = 0; | |
| if (This->root) | |
| lstrcpyW(full_query, This->root); | |
| lstrcatW(full_query, query); | |
| PropVariantInit(&tk_id); | |
| PropVariantInit(&tk_schema); | |
| PropVariantInit(&new_value); | |
| reader = NULL; | |
| p = full_query; | |
| while (*p) | |
| { | |
| if (*p != '/') | |
| { | |
| WARN("query should start with '/'\n"); | |
| hr = WINCODEC_ERR_PROPERTYNOTSUPPORTED; | |
| break; | |
| } | |
| p++; | |
| index = 0; | |
| elem.str = p; | |
| elem.len = lstrlenW(p); | |
| hr = get_token(&elem, &tk_id, &tk_schema, &index); | |
| if (hr != S_OK) | |
| { | |
| WARN("get_token error %#x\n", hr); | |
| break; | |
| } | |
| TRACE("parsed %d characters: %s, index %d\n", elem.len, wine_dbgstr_wn(elem.str, elem.len), index); | |
| TRACE("id %s, schema %s\n", wine_dbgstr_variant((VARIANT *)&tk_id), wine_dbgstr_variant((VARIANT *)&tk_schema)); | |
| if (!elem.len) break; | |
| if (tk_id.vt == VT_CLSID || (tk_id.vt == VT_BSTR && WICMapShortNameToGuid(tk_id.u.bstrVal, &guid) == S_OK)) | |
| { | |
| WCHAR *root; | |
| if (tk_schema.vt != VT_EMPTY) | |
| { | |
| FIXME("unsupported schema vt %u\n", tk_schema.vt); | |
| PropVariantClear(&tk_schema); | |
| } | |
| if (tk_id.vt == VT_CLSID) guid = *tk_id.u.puuid; | |
| if (reader) | |
| { | |
| IWICMetadataReader *new_reader; | |
| hr = get_next_reader(reader, index, &guid, &new_reader); | |
| IWICMetadataReader_Release(reader); | |
| reader = new_reader; | |
| } | |
| else | |
| hr = find_reader_from_block(This->block, index, &guid, &reader); | |
| if (hr != S_OK) break; | |
| root = SysAllocStringLen(NULL, elem.str + elem.len - full_query + 2); | |
| if (!root) | |
| { | |
| hr = E_OUTOFMEMORY; | |
| break; | |
| } | |
| lstrcpynW(root, full_query, p - full_query + elem.len + 1); | |
| PropVariantClear(&new_value); | |
| new_value.vt = VT_UNKNOWN; | |
| hr = MetadataQueryReader_CreateInstance(This->block, root, (IWICMetadataQueryReader **)&new_value.u.punkVal); | |
| SysFreeString(root); | |
| if (hr != S_OK) break; | |
| } | |
| else | |
| { | |
| PROPVARIANT schema, id; | |
| if (!reader) | |
| { | |
| hr = WINCODEC_ERR_INVALIDQUERYREQUEST; | |
| break; | |
| } | |
| if (tk_schema.vt == VT_BSTR) | |
| { | |
| hr = IWICMetadataReader_GetMetadataFormat(reader, &guid); | |
| if (hr != S_OK) break; | |
| schema.vt = VT_LPWSTR; | |
| schema.u.pwszVal = (LPWSTR)map_shortname_to_schema(&guid, tk_schema.u.bstrVal); | |
| if (!schema.u.pwszVal) | |
| schema.u.pwszVal = tk_schema.u.bstrVal; | |
| } | |
| else | |
| schema = tk_schema; | |
| if (tk_id.vt == VT_BSTR) | |
| { | |
| id.vt = VT_LPWSTR; | |
| id.u.pwszVal = tk_id.u.bstrVal; | |
| } | |
| else | |
| id = tk_id; | |
| PropVariantClear(&new_value); | |
| hr = IWICMetadataReader_GetValue(reader, &schema, &id, &new_value); | |
| if (hr != S_OK) break; | |
| } | |
| p += elem.len; | |
| PropVariantClear(&tk_id); | |
| PropVariantClear(&tk_schema); | |
| } | |
| if (reader) | |
| IWICMetadataReader_Release(reader); | |
| PropVariantClear(&tk_id); | |
| PropVariantClear(&tk_schema); | |
| if (hr == S_OK) | |
| *value = new_value; | |
| else | |
| PropVariantClear(&new_value); | |
| HeapFree(GetProcessHeap(), 0, full_query); | |
| return hr; | |
| } | |
| static HRESULT WINAPI mqr_GetEnumerator(IWICMetadataQueryReader *iface, | |
| IEnumString **ppIEnumString) | |
| { | |
| QueryReader *This = impl_from_IWICMetadataQueryReader(iface); | |
| FIXME("(%p,%p)\n", This, ppIEnumString); | |
| return E_NOTIMPL; | |
| } | |
| static IWICMetadataQueryReaderVtbl mqr_vtbl = { | |
| mqr_QueryInterface, | |
| mqr_AddRef, | |
| mqr_Release, | |
| mqr_GetContainerFormat, | |
| mqr_GetLocation, | |
| mqr_GetMetadataByName, | |
| mqr_GetEnumerator | |
| }; | |
| HRESULT MetadataQueryReader_CreateInstance(IWICMetadataBlockReader *mbr, const WCHAR *root, IWICMetadataQueryReader **out) | |
| { | |
| QueryReader *obj; | |
| obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*obj)); | |
| if (!obj) | |
| return E_OUTOFMEMORY; | |
| obj->IWICMetadataQueryReader_iface.lpVtbl = &mqr_vtbl; | |
| obj->ref = 1; | |
| IWICMetadataBlockReader_AddRef(mbr); | |
| obj->block = mbr; | |
| obj->root = root ? heap_strdupW(root) : NULL; | |
| *out = &obj->IWICMetadataQueryReader_iface; | |
| return S_OK; | |
| } | |
| static const WCHAR bmpW[] = { 'b','m','p',0 }; | |
| static const WCHAR pngW[] = { 'p','n','g',0 }; | |
| static const WCHAR icoW[] = { 'i','c','o',0 }; | |
| static const WCHAR jpgW[] = { 'j','p','g',0 }; | |
| static const WCHAR tiffW[] = { 't','i','f','f',0 }; | |
| static const WCHAR gifW[] = { 'g','i','f',0 }; | |
| static const WCHAR wmphotoW[] = { 'w','m','p','h','o','t','o',0 }; | |
| static const WCHAR unknownW[] = { 'u','n','k','n','o','w','n',0 }; | |
| static const WCHAR ifdW[] = { 'i','f','d',0 }; | |
| static const WCHAR subW[] = { 's','u','b',0 }; | |
| static const WCHAR exifW[] = { 'e','x','i','f',0 }; | |
| static const WCHAR gpsW[] = { 'g','p','s',0 }; | |
| static const WCHAR interopW[] = { 'i','n','t','e','r','o','p',0 }; | |
| static const WCHAR app0W[] = { 'a','p','p','0',0 }; | |
| static const WCHAR app1W[] = { 'a','p','p','1',0 }; | |
| static const WCHAR app13W[] = { 'a','p','p','1','3',0 }; | |
| static const WCHAR iptcW[] = { 'i','p','t','c',0 }; | |
| static const WCHAR irbW[] = { 'i','r','b',0 }; | |
| static const WCHAR _8bimiptcW[] = { '8','b','i','m','i','p','t','c',0 }; | |
| static const WCHAR _8bimResInfoW[] = { '8','b','i','m','R','e','s','I','n','f','o',0 }; | |
| static const WCHAR _8bimiptcdigestW[] = { '8','b','i','m','i','p','t','c','d','i','g','e','s','t',0 }; | |
| static const WCHAR xmpW[] = { 'x','m','p',0 }; | |
| static const WCHAR thumbW[] = { 't','h','u','m','b',0 }; | |
| static const WCHAR tEXtW[] = { 't','E','X','t',0 }; | |
| static const WCHAR xmpstructW[] = { 'x','m','p','s','t','r','u','c','t',0 }; | |
| static const WCHAR xmpbagW[] = { 'x','m','p','b','a','g',0 }; | |
| static const WCHAR xmpseqW[] = { 'x','m','p','s','e','q',0 }; | |
| static const WCHAR xmpaltW[] = { 'x','m','p','a','l','t',0 }; | |
| static const WCHAR logscrdescW[] = { 'l','o','g','s','c','r','d','e','s','c',0 }; | |
| static const WCHAR imgdescW[] = { 'i','m','g','d','e','s','c',0 }; | |
| static const WCHAR grctlextW[] = { 'g','r','c','t','l','e','x','t',0 }; | |
| static const WCHAR appextW[] = { 'a','p','p','e','x','t',0 }; | |
| static const WCHAR chrominanceW[] = { 'c','h','r','o','m','i','n','a','n','c','e',0 }; | |
| static const WCHAR luminanceW[] = { 'l','u','m','i','n','a','n','c','e',0 }; | |
| static const WCHAR comW[] = { 'c','o','m',0 }; | |
| static const WCHAR commentextW[] = { 'c','o','m','m','e','n','t','e','x','t',0 }; | |
| static const WCHAR gAMAW[] = { 'g','A','M','A',0 }; | |
| static const WCHAR bKGDW[] = { 'b','K','G','D',0 }; | |
| static const WCHAR iTXtW[] = { 'i','T','X','t',0 }; | |
| static const WCHAR cHRMW[] = { 'c','H','R','M',0 }; | |
| static const WCHAR hISTW[] = { 'h','I','S','T',0 }; | |
| static const WCHAR iCCPW[] = { 'i','C','C','P',0 }; | |
| static const WCHAR sRGBW[] = { 's','R','G','B',0 }; | |
| static const WCHAR tIMEW[] = { 't','I','M','E',0 }; | |
| static const struct | |
| { | |
| const GUID *guid; | |
| const WCHAR *name; | |
| } guid2name[] = | |
| { | |
| { &GUID_ContainerFormatBmp, bmpW }, | |
| { &GUID_ContainerFormatPng, pngW }, | |
| { &GUID_ContainerFormatIco, icoW }, | |
| { &GUID_ContainerFormatJpeg, jpgW }, | |
| { &GUID_ContainerFormatTiff, tiffW }, | |
| { &GUID_ContainerFormatGif, gifW }, | |
| { &GUID_ContainerFormatWmp, wmphotoW }, | |
| { &GUID_MetadataFormatUnknown, unknownW }, | |
| { &GUID_MetadataFormatIfd, ifdW }, | |
| { &GUID_MetadataFormatSubIfd, subW }, | |
| { &GUID_MetadataFormatExif, exifW }, | |
| { &GUID_MetadataFormatGps, gpsW }, | |
| { &GUID_MetadataFormatInterop, interopW }, | |
| { &GUID_MetadataFormatApp0, app0W }, | |
| { &GUID_MetadataFormatApp1, app1W }, | |
| { &GUID_MetadataFormatApp13, app13W }, | |
| { &GUID_MetadataFormatIPTC, iptcW }, | |
| { &GUID_MetadataFormatIRB, irbW }, | |
| { &GUID_MetadataFormat8BIMIPTC, _8bimiptcW }, | |
| { &GUID_MetadataFormat8BIMResolutionInfo, _8bimResInfoW }, | |
| { &GUID_MetadataFormat8BIMIPTCDigest, _8bimiptcdigestW }, | |
| { &GUID_MetadataFormatXMP, xmpW }, | |
| { &GUID_MetadataFormatThumbnail, thumbW }, | |
| { &GUID_MetadataFormatChunktEXt, tEXtW }, | |
| { &GUID_MetadataFormatXMPStruct, xmpstructW }, | |
| { &GUID_MetadataFormatXMPBag, xmpbagW }, | |
| { &GUID_MetadataFormatXMPSeq, xmpseqW }, | |
| { &GUID_MetadataFormatXMPAlt, xmpaltW }, | |
| { &GUID_MetadataFormatLSD, logscrdescW }, | |
| { &GUID_MetadataFormatIMD, imgdescW }, | |
| { &GUID_MetadataFormatGCE, grctlextW }, | |
| { &GUID_MetadataFormatAPE, appextW }, | |
| { &GUID_MetadataFormatJpegChrominance, chrominanceW }, | |
| { &GUID_MetadataFormatJpegLuminance, luminanceW }, | |
| { &GUID_MetadataFormatJpegComment, comW }, | |
| { &GUID_MetadataFormatGifComment, commentextW }, | |
| { &GUID_MetadataFormatChunkgAMA, gAMAW }, | |
| { &GUID_MetadataFormatChunkbKGD, bKGDW }, | |
| { &GUID_MetadataFormatChunkiTXt, iTXtW }, | |
| { &GUID_MetadataFormatChunkcHRM, cHRMW }, | |
| { &GUID_MetadataFormatChunkhIST, hISTW }, | |
| { &GUID_MetadataFormatChunkiCCP, iCCPW }, | |
| { &GUID_MetadataFormatChunksRGB, sRGBW }, | |
| { &GUID_MetadataFormatChunktIME, tIMEW } | |
| }; | |
| HRESULT WINAPI WICMapGuidToShortName(REFGUID guid, UINT len, WCHAR *name, UINT *ret_len) | |
| { | |
| UINT i; | |
| TRACE("%s,%u,%p,%p\n", wine_dbgstr_guid(guid), len, name, ret_len); | |
| if (!guid) return E_INVALIDARG; | |
| for (i = 0; i < sizeof(guid2name)/sizeof(guid2name[0]); i++) | |
| { | |
| if (IsEqualGUID(guid, guid2name[i].guid)) | |
| { | |
| if (name) | |
| { | |
| if (!len) return E_INVALIDARG; | |
| len = min(len - 1, lstrlenW(guid2name[i].name)); | |
| memcpy(name, guid2name[i].name, len * sizeof(WCHAR)); | |
| name[len] = 0; | |
| if (len < lstrlenW(guid2name[i].name)) | |
| return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); | |
| } | |
| if (ret_len) *ret_len = lstrlenW(guid2name[i].name) + 1; | |
| return S_OK; | |
| } | |
| } | |
| return WINCODEC_ERR_PROPERTYNOTFOUND; | |
| } | |
| HRESULT WINAPI WICMapShortNameToGuid(PCWSTR name, GUID *guid) | |
| { | |
| UINT i; | |
| TRACE("%s,%p\n", debugstr_w(name), guid); | |
| if (!name || !guid) return E_INVALIDARG; | |
| for (i = 0; i < sizeof(guid2name)/sizeof(guid2name[0]); i++) | |
| { | |
| if (!lstrcmpiW(name, guid2name[i].name)) | |
| { | |
| *guid = *guid2name[i].guid; | |
| return S_OK; | |
| } | |
| } | |
| return WINCODEC_ERR_PROPERTYNOTFOUND; | |
| } | |
| static const WCHAR rdf[] = { 'r','d','f',0 }; | |
| static const WCHAR rdf_scheme[] = { 'h','t','t','p',':','/','/','w','w','w','.','w','3','.','o','r','g','/','1','9','9','9','/','0','2','/','2','2','-','r','d','f','-','s','y','n','t','a','x','-','n','s','#',0 }; | |
| static const WCHAR dc[] = { 'd','c',0 }; | |
| static const WCHAR dc_scheme[] = { 'h','t','t','p',':','/','/','p','u','r','l','.','o','r','g','/','d','c','/','e','l','e','m','e','n','t','s','/','1','.','1','/',0 }; | |
| static const WCHAR xmp[] = { 'x','m','p',0 }; | |
| static const WCHAR xmp_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/',0 }; | |
| static const WCHAR xmpidq[] = { 'x','m','p','i','d','q',0 }; | |
| static const WCHAR xmpidq_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','m','p','/','I','d','e','n','t','i','f','i','e','r','/','q','u','a','l','/','1','.','0','/',0 }; | |
| static const WCHAR xmpRights[] = { 'x','m','p','R','i','g','h','t','s',0 }; | |
| static const WCHAR xmpRights_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','r','i','g','h','t','s','/',0 }; | |
| static const WCHAR xmpMM[] = { 'x','m','p','M','M',0 }; | |
| static const WCHAR xmpMM_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','m','m','/',0 }; | |
| static const WCHAR xmpBJ[] = { 'x','m','p','B','J',0 }; | |
| static const WCHAR xmpBJ_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','b','j','/',0 }; | |
| static const WCHAR xmpTPg[] = { 'x','m','p','T','P','g',0 }; | |
| static const WCHAR xmpTPg_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','t','/','p','g','/',0 }; | |
| static const WCHAR pdf[] = { 'p','d','f',0 }; | |
| static const WCHAR pdf_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','p','d','f','/','1','.','3','/',0 }; | |
| static const WCHAR photoshop[] = { 'p','h','o','t','o','s','h','o','p',0 }; | |
| static const WCHAR photoshop_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','p','h','o','t','o','s','h','o','p','/','1','.','0','/',0 }; | |
| static const WCHAR tiff[] = { 't','i','f','f',0 }; | |
| static const WCHAR tiff_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','t','i','f','f','/','1','.','0','/',0 }; | |
| static const WCHAR exif[] = { 'e','x','i','f',0 }; | |
| static const WCHAR exif_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','e','x','i','f','/','1','.','0','/',0 }; | |
| static const WCHAR stDim[] = { 's','t','D','i','m',0 }; | |
| static const WCHAR stDim_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','s','T','y','p','e','/','D','i','m','e','n','s','i','o','n','s','#',0 }; | |
| static const WCHAR xapGImg[] = { 'x','a','p','G','I','m','g',0 }; | |
| static const WCHAR xapGImg_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','g','/','i','m','g','/',0 }; | |
| static const WCHAR stEvt[] = { 's','t','E','v','t',0 }; | |
| static const WCHAR stEvt_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','s','T','y','p','e','/','R','e','s','o','u','r','c','e','E','v','e','n','t','#',0 }; | |
| static const WCHAR stRef[] = { 's','t','R','e','f',0 }; | |
| static const WCHAR stRef_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','s','T','y','p','e','/','R','e','s','o','u','r','c','e','R','e','f','#',0 }; | |
| static const WCHAR stVer[] = { 's','t','V','e','r',0 }; | |
| static const WCHAR stVer_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','s','T','y','p','e','/','V','e','r','s','i','o','n','#',0 }; | |
| static const WCHAR stJob[] = { 's','t','J','o','b',0 }; | |
| static const WCHAR stJob_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','a','p','/','1','.','0','/','s','T','y','p','e','/','J','o','b','#',0 }; | |
| static const WCHAR aux[] = { 'a','u','x',0 }; | |
| static const WCHAR aux_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','e','x','i','f','/','1','.','0','/','a','u','x','/',0 }; | |
| static const WCHAR crs[] = { 'c','r','s',0 }; | |
| static const WCHAR crs_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','c','a','m','e','r','a','-','r','a','w','-','s','e','t','t','i','n','g','s','/','1','.','0','/',0 }; | |
| static const WCHAR xmpDM[] = { 'x','m','p','D','M',0 }; | |
| static const WCHAR xmpDM_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','a','d','o','b','e','.','c','o','m','/','x','m','p','/','1','.','0','/','D','y','n','a','m','i','c','M','e','d','i','a','/',0 }; | |
| static const WCHAR Iptc4xmpCore[] = { 'I','p','t','c','4','x','m','p','C','o','r','e',0 }; | |
| static const WCHAR Iptc4xmpCore_scheme[] = { 'h','t','t','p',':','/','/','i','p','t','c','.','o','r','g','/','s','t','d','/','I','p','t','c','4','x','m','p','C','o','r','e','/','1','.','0','/','x','m','l','n','s','/',0 }; | |
| static const WCHAR MicrosoftPhoto[] = { 'M','i','c','r','o','s','o','f','t','P','h','o','t','o',0 }; | |
| static const WCHAR MicrosoftPhoto_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','m','i','c','r','o','s','o','f','t','.','c','o','m','/','p','h','o','t','o','/','1','.','0','/',0 }; | |
| static const WCHAR MP[] = { 'M','P',0 }; | |
| static const WCHAR MP_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','m','i','c','r','o','s','o','f','t','.','c','o','m','/','p','h','o','t','o','/','1','.','2','/',0 }; | |
| static const WCHAR MPRI[] = { 'M','P','R','I',0 }; | |
| static const WCHAR MPRI_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','m','i','c','r','o','s','o','f','t','.','c','o','m','/','p','h','o','t','o','/','1','.','2','/','t','/','R','e','g','i','o','n','I','n','f','o','#',0 }; | |
| static const WCHAR MPReg[] = { 'M','P','R','e','g',0 }; | |
| static const WCHAR MPReg_scheme[] = { 'h','t','t','p',':','/','/','n','s','.','m','i','c','r','o','s','o','f','t','.','c','o','m','/','p','h','o','t','o','/','1','.','2','/','t','/','R','e','g','i','o','n','#',0 }; | |
| static const struct | |
| { | |
| const WCHAR *name; | |
| const WCHAR *schema; | |
| } name2schema[] = | |
| { | |
| { rdf, rdf_scheme }, | |
| { dc, dc_scheme }, | |
| { xmp, xmp_scheme }, | |
| { xmpidq, xmpidq_scheme }, | |
| { xmpRights, xmpRights_scheme }, | |
| { xmpMM, xmpMM_scheme }, | |
| { xmpBJ, xmpBJ_scheme }, | |
| { xmpTPg, xmpTPg_scheme }, | |
| { pdf, pdf_scheme }, | |
| { photoshop, photoshop_scheme }, | |
| { tiff, tiff_scheme }, | |
| { exif, exif_scheme }, | |
| { stDim, stDim_scheme }, | |
| { xapGImg, xapGImg_scheme }, | |
| { stEvt, stEvt_scheme }, | |
| { stRef, stRef_scheme }, | |
| { stVer, stVer_scheme }, | |
| { stJob, stJob_scheme }, | |
| { aux, aux_scheme }, | |
| { crs, crs_scheme }, | |
| { xmpDM, xmpDM_scheme }, | |
| { Iptc4xmpCore, Iptc4xmpCore_scheme }, | |
| { MicrosoftPhoto, MicrosoftPhoto_scheme }, | |
| { MP, MP_scheme }, | |
| { MPRI, MPRI_scheme }, | |
| { MPReg, MPReg_scheme } | |
| }; | |
| static const WCHAR *map_shortname_to_schema(const GUID *format, const WCHAR *name) | |
| { | |
| UINT i; | |
| /* It appears that the only metadata formats | |
| * that support schemas are xmp and xmpstruct. | |
| */ | |
| if (!IsEqualGUID(format, &GUID_MetadataFormatXMP) && | |
| !IsEqualGUID(format, &GUID_MetadataFormatXMPStruct)) | |
| return NULL; | |
| for (i = 0; i < sizeof(name2schema)/sizeof(name2schema[0]); i++) | |
| { | |
| if (!lstrcmpW(name2schema[i].name, name)) | |
| return name2schema[i].schema; | |
| } | |
| return NULL; | |
| } | |
| HRESULT WINAPI WICMapSchemaToName(REFGUID format, LPWSTR schema, UINT len, WCHAR *name, UINT *ret_len) | |
| { | |
| UINT i; | |
| TRACE("%s,%s,%u,%p,%p\n", wine_dbgstr_guid(format), debugstr_w(schema), len, name, ret_len); | |
| if (!format || !schema || !ret_len) | |
| return E_INVALIDARG; | |
| /* It appears that the only metadata formats | |
| * that support schemas are xmp and xmpstruct. | |
| */ | |
| if (!IsEqualGUID(format, &GUID_MetadataFormatXMP) && | |
| !IsEqualGUID(format, &GUID_MetadataFormatXMPStruct)) | |
| return WINCODEC_ERR_PROPERTYNOTFOUND; | |
| for (i = 0; i < sizeof(name2schema)/sizeof(name2schema[0]); i++) | |
| { | |
| if (!lstrcmpW(name2schema[i].schema, schema)) | |
| { | |
| if (name) | |
| { | |
| if (!len) return E_INVALIDARG; | |
| len = min(len - 1, lstrlenW(name2schema[i].name)); | |
| memcpy(name, name2schema[i].name, len * sizeof(WCHAR)); | |
| name[len] = 0; | |
| if (len < lstrlenW(name2schema[i].name)) | |
| return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); | |
| } | |
| if (ret_len) *ret_len = lstrlenW(name2schema[i].name) + 1; | |
| return S_OK; | |
| } | |
| } | |
| return WINCODEC_ERR_PROPERTYNOTFOUND; | |
| } |