dlls/windowscodecs/metadataquery.c

   1 /*
   2  * Copyright 2016 Andrew Eikum for CodeWeavers
   3  * Copyright 2017 Dmitry Timoshkov
   4  *
   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.
   9  *
  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.
  14  *
  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
  18  */
  19
  20 #include <stdarg.h>
  21 #include <wchar.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "objbase.h"
  29 #include "propvarutil.h"
  30
  31 #include "wincodecs_private.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  36
  37 static const WCHAR *map_shortname_to_schema(const GUID *format, const WCHAR *name);
  38
  39 typedef struct {
  40     IWICMetadataQueryReader IWICMetadataQueryReader_iface;
  41     LONG ref;
  42     IWICMetadataBlockReader *block;
  43     WCHAR *root;
  44 } QueryReader;
  45
  46 static inline QueryReader *impl_from_IWICMetadataQueryReader(IWICMetadataQueryReader *iface)
  47 {
  48     return CONTAINING_RECORD(iface, QueryReader, IWICMetadataQueryReader_iface);
  49 }
  50
  51 static HRESULT WINAPI mqr_QueryInterface(IWICMetadataQueryReader *iface, REFIID riid,
  52         void **ppvObject)
  53 {
  54     QueryReader *This = impl_from_IWICMetadataQueryReader(iface);
  55
  56     TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObject);
  57
  58     if (IsEqualGUID(riid, &IID_IUnknown) ||
  59             IsEqualGUID(riid, &IID_IWICMetadataQueryReader))
  60         *ppvObject = &This->IWICMetadataQueryReader_iface;
  61     else
  62         *ppvObject = NULL;
  63
  64     if (*ppvObject)
  65     {
  66         IUnknown_AddRef((IUnknown*)*ppvObject);
  67         return S_OK;
  68     }
  69
  70     return E_NOINTERFACE;
  71 }
  72
  73 static ULONG WINAPI mqr_AddRef(IWICMetadataQueryReader *iface)
  74 {
  75     QueryReader *This = impl_from_IWICMetadataQueryReader(iface);
  76     ULONG ref = InterlockedIncrement(&This->ref);
  77     TRACE("(%p) refcount=%u\n", This, ref);
  78     return ref;
  79 }
  80
  81 static ULONG WINAPI mqr_Release(IWICMetadataQueryReader *iface)
  82 {
  83     QueryReader *This = impl_from_IWICMetadataQueryReader(iface);
  84     ULONG ref = InterlockedDecrement(&This->ref);
  85     TRACE("(%p) refcount=%u\n", This, ref);
  86     if (!ref)
  87     {
  88         IWICMetadataBlockReader_Release(This->block);
  89         HeapFree(GetProcessHeap(), 0, This->root);
  90         HeapFree(GetProcessHeap(), 0, This);
  91     }
  92     return ref;
  93 }
  94
  95 static HRESULT WINAPI mqr_GetContainerFormat(IWICMetadataQueryReader *iface, GUID *format)
  96 {
  97     QueryReader *This = impl_from_IWICMetadataQueryReader(iface);
  98
  99     TRACE("(%p,%p)\n", This, format);
 100
 101     return IWICMetadataBlockReader_GetContainerFormat(This->block, format);
 102 }
 103
 104 static HRESULT WINAPI mqr_GetLocation(IWICMetadataQueryReader *iface, UINT len, WCHAR *location, UINT *ret_len)
 105 {
 106     QueryReader *This = impl_from_IWICMetadataQueryReader(iface);
 107     const WCHAR *root;
 108     UINT actual_len;
 109
 110     TRACE("(%p,%u,%p,%p)\n", This, len, location, ret_len);
 111
 112     if (!ret_len) return E_INVALIDARG;
 113
 114     root = This->root ? This->root : L"/";
 115     actual_len = lstrlenW(root) + 1;
 116
 117     if (location)
 118     {
 119         if (len < actual_len)
 120             return WINCODEC_ERR_INSUFFICIENTBUFFER;
 121
 122         memcpy(location, root, actual_len * sizeof(WCHAR));
 123     }
 124
 125     *ret_len = actual_len;
 126
 127     return S_OK;
 128 }
 129
 130 struct string_t
 131 {
 132     const WCHAR *str;
 133     int len;
 134 };
 135
 136 static const struct
 137 {
 138     int len;
 139     WCHAR str[10];
 140     VARTYPE vt;
 141 } str2vt[] =
 142 {
 143     { 4, {'c','h','a','r'}, VT_I1 },
 144     { 5, {'u','c','h','a','r'}, VT_UI1 },
 145     { 5, {'s','h','o','r','t'}, VT_I2 },
 146     { 6, {'u','s','h','o','r','t'}, VT_UI2 },
 147     { 4, {'l','o','n','g'}, VT_I4 },
 148     { 5, {'u','l','o','n','g'}, VT_UI4 },
 149     { 3, {'i','n','t'}, VT_I4 },
 150     { 4, {'u','i','n','t'}, VT_UI4 },
 151     { 8, {'l','o','n','g','l','o','n','g'}, VT_I8 },
 152     { 9, {'u','l','o','n','g','l','o','n','g'}, VT_UI8 },
 153     { 5, {'f','l','o','a','t'}, VT_R4 },
 154     { 6, {'d','o','u','b','l','e'}, VT_R8 },
 155     { 3, {'s','t','r'}, VT_LPSTR },
 156     { 4, {'w','s','t','r'}, VT_LPWSTR },
 157     { 4, {'g','u','i','d'}, VT_CLSID },
 158     { 4, {'b','o','o','l'}, VT_BOOL }
 159 };
 160
 161 static VARTYPE map_type(struct string_t *str)
 162 {
 163     UINT i;
 164
 165     for (i = 0; i < ARRAY_SIZE(str2vt); i++)
 166     {
 167         if (str2vt[i].len == str->len)
 168         {
 169             if (CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
 170                 str->str, str->len, str2vt[i].str, str2vt[i].len) == CSTR_EQUAL)
 171                 return str2vt[i].vt;
 172         }
 173     }
 174
 175     WARN("type %s is not recognized\n", wine_dbgstr_wn(str->str, str->len));
 176
 177     return VT_ILLEGAL;
 178 }
 179
 180 static HRESULT get_token(struct string_t *elem, PROPVARIANT *id, PROPVARIANT *schema, int *idx)
 181 {
 182     const WCHAR *start, *end, *p;
 183     WCHAR *bstr;
 184     struct string_t next_elem;
 185     HRESULT hr;
 186
 187     TRACE("%s, len %d\n", wine_dbgstr_wn(elem->str, elem->len), elem->len);
 188
 189     PropVariantInit(id);
 190     PropVariantInit(schema);
 191
 192     if (!elem->len) return S_OK;
 193
 194     start = elem->str;
 195
 196     if (*start == '[')
 197     {
 198         WCHAR *idx_end;
 199
 200         if (start[1] < '0' || start[1] > '9') return DISP_E_TYPEMISMATCH;
 201
 202         *idx = wcstol(start + 1, &idx_end, 10);
 203         if (idx_end > elem->str + elem->len) return WINCODEC_ERR_INVALIDQUERYREQUEST;
 204         if (*idx_end != ']') return WINCODEC_ERR_INVALIDQUERYREQUEST;
 205         if (*idx < 0) return WINCODEC_ERR_INVALIDQUERYREQUEST;
 206         end = idx_end + 1;
 207
 208         next_elem.str = end;
 209         next_elem.len = elem->len - (end - start);
 210         hr = get_token(&next_elem, id, schema, idx);
 211         if (hr != S_OK)
 212         {
 213             TRACE("get_token error %#x\n", hr);
 214             return hr;
 215         }
 216         elem->len = (end - start) + next_elem.len;
 217
 218         TRACE("indexed %s [%d]\n", wine_dbgstr_wn(elem->str, elem->len), *idx);
 219         return S_OK;
 220     }
 221     else if (*start == '{')
 222     {
 223         VARTYPE vt;
 224         PROPVARIANT next_token;
 225
 226         end = wmemchr(start + 1, '=', elem->len - 1);
 227         if (!end) return WINCODEC_ERR_INVALIDQUERYREQUEST;
 228         if (end > elem->str + elem->len) return WINCODEC_ERR_INVALIDQUERYREQUEST;
 229
 230         next_elem.str = start + 1;
 231         next_elem.len = end - start - 1;
 232         vt = map_type(&next_elem);
 233         TRACE("type %s => %d\n", wine_dbgstr_wn(next_elem.str, next_elem.len), vt);
 234         if (vt == VT_ILLEGAL) return WINCODEC_ERR_WRONGSTATE;
 235
 236         next_token.vt = VT_BSTR;
 237         next_token.bstrVal = SysAllocStringLen(NULL, elem->len - (end - start) + 1);
 238         if (!next_token.bstrVal) return E_OUTOFMEMORY;
 239
 240         bstr = next_token.bstrVal;
 241
 242         end++;
 243         while (*end && *end != '}' && end - start < elem->len)
 244         {
 245             if (*end == '\\') end++;
 246             *bstr++ = *end++;
 247         }
 248         if (*end != '}')
 249         {
 250             PropVariantClear(&next_token);
 251             return WINCODEC_ERR_INVALIDQUERYREQUEST;
 252         }
 253         *bstr = 0;
 254         TRACE("schema/id %s\n", wine_dbgstr_w(next_token.bstrVal));
 255
 256         if (vt == VT_CLSID)
 257         {
 258             id->vt = VT_CLSID;
 259             id->puuid = CoTaskMemAlloc(sizeof(GUID));
 260             if (!id->puuid)
 261             {
 262                 PropVariantClear(&next_token);
 263                 return E_OUTOFMEMORY;
 264             }
 265
 266             hr = UuidFromStringW(next_token.bstrVal, id->puuid);
 267         }
 268         else
 269             hr = PropVariantChangeType(id, &next_token, 0, vt);
 270         PropVariantClear(&next_token);
 271         if (hr != S_OK)
 272         {
 273             PropVariantClear(id);
 274             PropVariantClear(schema);
 275             return hr;
 276         }
 277
 278         end++;
 279         if (*end == ':')
 280         {
 281             PROPVARIANT next_id, next_schema;
 282             int next_idx = 0;
 283
 284             next_elem.str = end + 1;
 285             next_elem.len = elem->len - (end - start + 1);
 286             hr = get_token(&next_elem, &next_id, &next_schema, &next_idx);
 287             if (hr != S_OK)
 288             {
 289                 TRACE("get_token error %#x\n", hr);
 290                 return hr;
 291             }
 292             elem->len = (end - start + 1) + next_elem.len;
 293
 294             TRACE("id %s [%d]\n", wine_dbgstr_wn(elem->str, elem->len), *idx);
 295
 296             if (next_schema.vt != VT_EMPTY)
 297             {
 298                 PropVariantClear(&next_id);
 299                 PropVariantClear(&next_schema);
 300                 return WINCODEC_ERR_WRONGSTATE;
 301             }
 302
 303             *schema = *id;
 304             *id = next_id;
 305
 306             return S_OK;
 307         }
 308
 309         elem->len = end - start;
 310         return S_OK;
 311     }
 312
 313     end = wmemchr(start, '/', elem->len);
 314     if (!end) end = start + elem->len;
 315
 316     p = wmemchr(start, ':', end - start);
 317     if (p)
 318     {
 319         next_elem.str = p + 1;
 320         next_elem.len = end - p - 1;
 321
 322         elem->len = p - start;
 323     }
 324     else
 325         elem->len = end - start;
 326
 327     id->vt = VT_BSTR;
 328     id->bstrVal = SysAllocStringLen(NULL, elem->len + 1);
 329     if (!id->bstrVal) return E_OUTOFMEMORY;
 330
 331     bstr = id->bstrVal;
 332     p = elem->str;
 333     while (p - elem->str < elem->len)
 334     {
 335         if (*p == '\\') p++;
 336         *bstr++ = *p++;
 337     }
 338     *bstr = 0;
 339     TRACE("%s [%d]\n", wine_dbgstr_variant((VARIANT *)id), *idx);
 340
 341     if (*p == ':')
 342     {
 343         PROPVARIANT next_id, next_schema;
 344         int next_idx = 0;
 345
 346         hr = get_token(&next_elem, &next_id, &next_schema, &next_idx);
 347         if (hr != S_OK)
 348         {
 349             TRACE("get_token error %#x\n", hr);
 350             PropVariantClear(id);
 351             PropVariantClear(schema);
 352             return hr;
 353         }
 354         elem->len += next_elem.len + 1;
 355
 356         TRACE("id %s [%d]\n", wine_dbgstr_wn(elem->str, elem->len), *idx);
 357
 358         if (next_schema.vt != VT_EMPTY)
 359         {
 360             PropVariantClear(&next_id);
 361             PropVariantClear(&next_schema);
 362             PropVariantClear(id);
 363             PropVariantClear(schema);
 364             return WINCODEC_ERR_WRONGSTATE;
 365         }
 366
 367         *schema = *id;
 368         *id = next_id;
 369     }
 370
 371     return S_OK;
 372 }
 373
 374 static HRESULT find_reader_from_block(IWICMetadataBlockReader *block_reader, UINT index,
 375                                       GUID *guid, IWICMetadataReader **reader)
 376 {
 377     HRESULT hr;
 378     GUID format;
 379     IWICMetadataReader *new_reader;
 380     UINT count, i, matched_index;
 381
 382     *reader = NULL;
 383
 384     hr = IWICMetadataBlockReader_GetCount(block_reader, &count);
 385     if (hr != S_OK) return hr;
 386
 387     matched_index = 0;
 388
 389     for (i = 0; i < count; i++)
 390     {
 391         hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &new_reader);
 392         if (hr != S_OK) return hr;
 393
 394         hr = IWICMetadataReader_GetMetadataFormat(new_reader, &format);
 395         if (hr == S_OK)
 396         {
 397             if (IsEqualGUID(&format, guid))
 398             {
 399                 if (matched_index == index)
 400                 {
 401                     *reader = new_reader;
 402                     return S_OK;
 403                 }
 404
 405                 matched_index++;
 406             }
 407         }
 408
 409         IWICMetadataReader_Release(new_reader);
 410         if (hr != S_OK) return hr;
 411     }
 412
 413     return WINCODEC_ERR_PROPERTYNOTFOUND;
 414 }
 415
 416 static HRESULT get_next_reader(IWICMetadataReader *reader, UINT index,
 417                                GUID *guid, IWICMetadataReader **new_reader)
 418 {
 419     HRESULT hr;
 420     PROPVARIANT schema, id, value;
 421
 422     *new_reader = NULL;
 423
 424     PropVariantInit(&schema);
 425     PropVariantInit(&id);
 426     PropVariantInit(&value);
 427
 428     if (index)
 429     {
 430         schema.vt = VT_UI2;
 431         schema.uiVal = index;
 432     }
 433
 434     id.vt = VT_CLSID;
 435     id.puuid = guid;
 436     hr = IWICMetadataReader_GetValue(reader, &schema, &id, &value);
 437     if (hr != S_OK) return hr;
 438
 439     if (value.vt == VT_UNKNOWN)
 440         hr = IUnknown_QueryInterface(value.punkVal, &IID_IWICMetadataReader, (void **)new_reader);
 441     else
 442         hr = WINCODEC_ERR_UNEXPECTEDMETADATATYPE;
 443
 444     PropVariantClear(&value);
 445     return hr;
 446 }
 447
 448 static HRESULT WINAPI mqr_GetMetadataByName(IWICMetadataQueryReader *iface, LPCWSTR query, PROPVARIANT *value)
 449 {
 450     QueryReader *This = impl_from_IWICMetadataQueryReader(iface);
 451     struct string_t elem;
 452     WCHAR *full_query;
 453     const WCHAR *p;
 454     int index, len;
 455     PROPVARIANT tk_id, tk_schema, new_value;
 456     GUID guid;
 457     IWICMetadataReader *reader;
 458     HRESULT hr = S_OK;
 459
 460     TRACE("(%p,%s,%p)\n", This, wine_dbgstr_w(query), value);
 461
 462     len = lstrlenW(query) + 1;
 463     if (This->root) len += lstrlenW(This->root);
 464     full_query = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 465     full_query[0] = 0;
 466     if (This->root)
 467         lstrcpyW(full_query, This->root);
 468     lstrcatW(full_query, query);
 469
 470     PropVariantInit(&tk_id);
 471     PropVariantInit(&tk_schema);
 472     PropVariantInit(&new_value);
 473
 474     reader = NULL;
 475     p = full_query;
 476
 477     while (*p)
 478     {
 479         if (*p != '/')
 480         {
 481             WARN("query should start with '/'\n");
 482             hr = WINCODEC_ERR_PROPERTYNOTSUPPORTED;
 483             break;
 484         }
 485
 486         p++;
 487
 488         index = 0;
 489         elem.str = p;
 490         elem.len = lstrlenW(p);
 491         hr = get_token(&elem, &tk_id, &tk_schema, &index);
 492         if (hr != S_OK)
 493         {
 494             WARN("get_token error %#x\n", hr);
 495             break;
 496         }
 497         TRACE("parsed %d characters: %s, index %d\n", elem.len, wine_dbgstr_wn(elem.str, elem.len), index);
 498         TRACE("id %s, schema %s\n", wine_dbgstr_variant((VARIANT *)&tk_id), wine_dbgstr_variant((VARIANT *)&tk_schema));
 499
 500         if (!elem.len) break;
 501
 502         if (tk_id.vt == VT_CLSID || (tk_id.vt == VT_BSTR && WICMapShortNameToGuid(tk_id.bstrVal, &guid) == S_OK))
 503         {
 504             WCHAR *root;
 505
 506             if (tk_schema.vt != VT_EMPTY)
 507             {
 508                 FIXME("unsupported schema vt %u\n", tk_schema.vt);
 509                 PropVariantClear(&tk_schema);
 510             }
 511
 512             if (tk_id.vt == VT_CLSID) guid = *tk_id.puuid;
 513
 514             if (reader)
 515             {
 516                 IWICMetadataReader *new_reader;
 517
 518                 hr = get_next_reader(reader, index, &guid, &new_reader);
 519                 IWICMetadataReader_Release(reader);
 520                 reader = new_reader;
 521             }
 522             else
 523                 hr = find_reader_from_block(This->block, index, &guid, &reader);
 524
 525             if (hr != S_OK) break;
 526
 527             root = SysAllocStringLen(NULL, elem.str + elem.len - full_query + 2);
 528             if (!root)
 529             {
 530                 hr = E_OUTOFMEMORY;
 531                 break;
 532             }
 533             lstrcpynW(root, full_query, p - full_query + elem.len + 1);
 534
 535             PropVariantClear(&new_value);
 536             new_value.vt = VT_UNKNOWN;
 537             hr = MetadataQueryReader_CreateInstance(This->block, root, (IWICMetadataQueryReader **)&new_value.punkVal);
 538             SysFreeString(root);
 539             if (hr != S_OK) break;
 540         }
 541         else
 542         {
 543             PROPVARIANT schema, id;
 544
 545             if (!reader)
 546             {
 547                 hr = WINCODEC_ERR_INVALIDQUERYREQUEST;
 548                 break;
 549             }
 550
 551             if (tk_schema.vt == VT_BSTR)
 552             {
 553                 hr = IWICMetadataReader_GetMetadataFormat(reader, &guid);
 554                 if (hr != S_OK) break;
 555
 556                 schema.vt = VT_LPWSTR;
 557                 schema.pwszVal = (LPWSTR)map_shortname_to_schema(&guid, tk_schema.bstrVal);
 558                 if (!schema.pwszVal)
 559                     schema.pwszVal = tk_schema.bstrVal;
 560             }
 561             else
 562                 schema = tk_schema;
 563
 564             if (tk_id.vt == VT_BSTR)
 565             {
 566                 id.vt = VT_LPWSTR;
 567                 id.pwszVal = tk_id.bstrVal;
 568             }
 569             else
 570                 id = tk_id;
 571
 572             PropVariantClear(&new_value);
 573             hr = IWICMetadataReader_GetValue(reader, &schema, &id, &new_value);
 574             if (hr != S_OK) break;
 575         }
 576
 577         p += elem.len;
 578
 579         PropVariantClear(&tk_id);
 580         PropVariantClear(&tk_schema);
 581     }
 582
 583     if (reader)
 584         IWICMetadataReader_Release(reader);
 585
 586     PropVariantClear(&tk_id);
 587     PropVariantClear(&tk_schema);
 588
 589     if (hr == S_OK && value)
 590         *value = new_value;
 591     else
 592         PropVariantClear(&new_value);
 593
 594     HeapFree(GetProcessHeap(), 0, full_query);
 595
 596     return hr;
 597 }
 598
 599 static HRESULT WINAPI mqr_GetEnumerator(IWICMetadataQueryReader *iface,
 600         IEnumString **ppIEnumString)
 601 {
 602     QueryReader *This = impl_from_IWICMetadataQueryReader(iface);
 603     FIXME("(%p,%p)\n", This, ppIEnumString);
 604     return E_NOTIMPL;
 605 }
 606
 607 static IWICMetadataQueryReaderVtbl mqr_vtbl = {
 608     mqr_QueryInterface,
 609     mqr_AddRef,
 610     mqr_Release,
 611     mqr_GetContainerFormat,
 612     mqr_GetLocation,
 613     mqr_GetMetadataByName,
 614     mqr_GetEnumerator
 615 };
 616
 617 HRESULT MetadataQueryReader_CreateInstance(IWICMetadataBlockReader *mbr, const WCHAR *root, IWICMetadataQueryReader **out)
 618 {
 619     QueryReader *obj;
 620
 621     obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*obj));
 622     if (!obj)
 623         return E_OUTOFMEMORY;
 624
 625     obj->IWICMetadataQueryReader_iface.lpVtbl = &mqr_vtbl;
 626     obj->ref = 1;
 627
 628     IWICMetadataBlockReader_AddRef(mbr);
 629     obj->block = mbr;
 630
 631     obj->root = root ? heap_strdupW(root) : NULL;
 632
 633     *out = &obj->IWICMetadataQueryReader_iface;
 634
 635     return S_OK;
 636 }
 637
 638 typedef struct
 639 {
 640     IWICMetadataQueryWriter IWICMetadataQueryWriter_iface;
 641     LONG ref;
 642     IWICMetadataBlockWriter *block;
 643     WCHAR *root;
 644 }
 645 QueryWriter;
 646
 647 static inline QueryWriter *impl_from_IWICMetadataQueryWriter(IWICMetadataQueryWriter *iface)
 648 {
 649     return CONTAINING_RECORD(iface, QueryWriter, IWICMetadataQueryWriter_iface);
 650 }
 651
 652 static HRESULT WINAPI mqw_QueryInterface(IWICMetadataQueryWriter *iface, REFIID riid,
 653         void **object)
 654 {
 655     QueryWriter *writer = impl_from_IWICMetadataQueryWriter(iface);
 656
 657     TRACE("writer %p, riid %s, object %p.\n", writer, debugstr_guid(riid), object);
 658
 659     if (IsEqualGUID(riid, &IID_IUnknown)
 660             || IsEqualGUID(riid, &IID_IWICMetadataQueryWriter)
 661             || IsEqualGUID(riid, &IID_IWICMetadataQueryReader))
 662         *object = &writer->IWICMetadataQueryWriter_iface;
 663     else
 664         *object = NULL;
 665
 666     if (*object)
 667     {
 668         IUnknown_AddRef((IUnknown *)*object);
 669         return S_OK;
 670     }
 671
 672     return E_NOINTERFACE;
 673 }
 674
 675 static ULONG WINAPI mqw_AddRef(IWICMetadataQueryWriter *iface)
 676 {
 677     QueryWriter *writer = impl_from_IWICMetadataQueryWriter(iface);
 678     ULONG ref = InterlockedIncrement(&writer->ref);
 679
 680     TRACE("writer %p, refcount=%u\n", writer, ref);
 681
 682     return ref;
 683 }
 684
 685 static ULONG WINAPI mqw_Release(IWICMetadataQueryWriter *iface)
 686 {
 687     QueryWriter *writer = impl_from_IWICMetadataQueryWriter(iface);
 688     ULONG ref = InterlockedDecrement(&writer->ref);
 689
 690     TRACE("writer %p, refcount=%u.\n", writer, ref);
 691
 692     if (!ref)
 693     {
 694         IWICMetadataBlockWriter_Release(writer->block);
 695         HeapFree(GetProcessHeap(), 0, writer->root);
 696         HeapFree(GetProcessHeap(), 0, writer);
 697     }
 698     return ref;
 699 }
 700
 701 static HRESULT WINAPI mqw_GetContainerFormat(IWICMetadataQueryWriter *iface, GUID *container_format)
 702 {
 703     FIXME("iface %p, container_format %p stub.\n", iface, container_format);
 704
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI mqw_GetEnumerator(IWICMetadataQueryWriter *iface, IEnumString **enum_string)
 709 {
 710     FIXME("iface %p, enum_string %p stub.\n", iface, enum_string);
 711
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI mqw_GetLocation(IWICMetadataQueryWriter *iface, UINT max_length, WCHAR *namespace, UINT *actual_length)
 716 {
 717     FIXME("iface %p, max_length %u, namespace %s, actual_length %p stub.\n",
 718             iface, max_length, debugstr_w(namespace), actual_length);
 719
 720     return E_NOTIMPL;
 721 }
 722
 723 static HRESULT WINAPI mqw_GetMetadataByName(IWICMetadataQueryWriter *iface, LPCWSTR name, PROPVARIANT *value)
 724 {
 725     FIXME("name %s, value %p stub.\n", debugstr_w(name), value);
 726
 727     return E_NOTIMPL;
 728 }
 729
 730 static HRESULT WINAPI mqw_SetMetadataByName(IWICMetadataQueryWriter *iface, LPCWSTR name, const PROPVARIANT *value)
 731 {
 732     FIXME("iface %p, name %s, value %p stub.\n", iface, debugstr_w(name), value);
 733
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI mqw_RemoveMetadataByName(IWICMetadataQueryWriter *iface, LPCWSTR name)
 738 {
 739     FIXME("iface %p, name %s stub.\n", iface, debugstr_w(name));
 740
 741     return E_NOTIMPL;
 742 }
 743
 744 static const IWICMetadataQueryWriterVtbl mqw_vtbl =
 745 {
 746     mqw_QueryInterface,
 747     mqw_AddRef,
 748     mqw_Release,
 749     mqw_GetContainerFormat,
 750     mqw_GetLocation,
 751     mqw_GetMetadataByName,
 752     mqw_GetEnumerator,
 753     mqw_SetMetadataByName,
 754     mqw_RemoveMetadataByName,
 755 };
 756
 757 HRESULT MetadataQueryWriter_CreateInstance(IWICMetadataBlockWriter *mbw, const WCHAR *root, IWICMetadataQueryWriter **out)
 758 {
 759     QueryWriter *obj;
 760
 761     obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*obj));
 762     if (!obj)
 763         return E_OUTOFMEMORY;
 764
 765     obj->IWICMetadataQueryWriter_iface.lpVtbl = &mqw_vtbl;
 766     obj->ref = 1;
 767
 768     IWICMetadataBlockWriter_AddRef(mbw);
 769     obj->block = mbw;
 770
 771     obj->root = root ? heap_strdupW(root) : NULL;
 772
 773     *out = &obj->IWICMetadataQueryWriter_iface;
 774
 775     return S_OK;
 776 }
 777
 778 static const struct
 779 {
 780     const GUID *guid;
 781     const WCHAR *name;
 782 } guid2name[] =
 783 {
 784     { &GUID_ContainerFormatBmp, L"bmp" },
 785     { &GUID_ContainerFormatPng, L"png" },
 786     { &GUID_ContainerFormatIco, L"ico" },
 787     { &GUID_ContainerFormatJpeg, L"jpg" },
 788     { &GUID_ContainerFormatTiff, L"tiff" },
 789     { &GUID_ContainerFormatGif, L"gif" },
 790     { &GUID_ContainerFormatWmp, L"wmphoto" },
 791     { &GUID_MetadataFormatUnknown, L"unknown" },
 792     { &GUID_MetadataFormatIfd, L"ifd" },
 793     { &GUID_MetadataFormatSubIfd, L"sub" },
 794     { &GUID_MetadataFormatExif, L"exif" },
 795     { &GUID_MetadataFormatGps, L"gps" },
 796     { &GUID_MetadataFormatInterop, L"interop" },
 797     { &GUID_MetadataFormatApp0, L"app0" },
 798     { &GUID_MetadataFormatApp1, L"app1" },
 799     { &GUID_MetadataFormatApp13, L"app13" },
 800     { &GUID_MetadataFormatIPTC, L"iptc" },
 801     { &GUID_MetadataFormatIRB, L"irb" },
 802     { &GUID_MetadataFormat8BIMIPTC, L"8bimiptc" },
 803     { &GUID_MetadataFormat8BIMResolutionInfo, L"8bimResInfo" },
 804     { &GUID_MetadataFormat8BIMIPTCDigest, L"8bimiptcdigest" },
 805     { &GUID_MetadataFormatXMP, L"xmp" },
 806     { &GUID_MetadataFormatThumbnail, L"thumb" },
 807     { &GUID_MetadataFormatChunktEXt, L"tEXt" },
 808     { &GUID_MetadataFormatXMPStruct, L"xmpstruct" },
 809     { &GUID_MetadataFormatXMPBag, L"xmpbag" },
 810     { &GUID_MetadataFormatXMPSeq, L"xmpseq" },
 811     { &GUID_MetadataFormatXMPAlt, L"xmpalt" },
 812     { &GUID_MetadataFormatLSD, L"logscrdesc" },
 813     { &GUID_MetadataFormatIMD, L"imgdesc" },
 814     { &GUID_MetadataFormatGCE, L"grctlext" },
 815     { &GUID_MetadataFormatAPE, L"appext" },
 816     { &GUID_MetadataFormatJpegChrominance, L"chrominance" },
 817     { &GUID_MetadataFormatJpegLuminance, L"luminance" },
 818     { &GUID_MetadataFormatJpegComment, L"com" },
 819     { &GUID_MetadataFormatGifComment, L"commentext" },
 820     { &GUID_MetadataFormatChunkgAMA, L"gAMA" },
 821     { &GUID_MetadataFormatChunkbKGD, L"bKGD" },
 822     { &GUID_MetadataFormatChunkiTXt, L"iTXt" },
 823     { &GUID_MetadataFormatChunkcHRM, L"cHRM" },
 824     { &GUID_MetadataFormatChunkhIST, L"hIST" },
 825     { &GUID_MetadataFormatChunkiCCP, L"iCCP" },
 826     { &GUID_MetadataFormatChunksRGB, L"sRGB" },
 827     { &GUID_MetadataFormatChunktIME, L"tIME" }
 828 };
 829
 830 HRESULT WINAPI WICMapGuidToShortName(REFGUID guid, UINT len, WCHAR *name, UINT *ret_len)
 831 {
 832     UINT i;
 833
 834     TRACE("%s,%u,%p,%p\n", wine_dbgstr_guid(guid), len, name, ret_len);
 835
 836     if (!guid) return E_INVALIDARG;
 837
 838     for (i = 0; i < ARRAY_SIZE(guid2name); i++)
 839     {
 840         if (IsEqualGUID(guid, guid2name[i].guid))
 841         {
 842             if (name)
 843             {
 844                 if (!len) return E_INVALIDARG;
 845
 846                 len = min(len - 1, lstrlenW(guid2name[i].name));
 847                 memcpy(name, guid2name[i].name, len * sizeof(WCHAR));
 848                 name[len] = 0;
 849
 850                 if (len < lstrlenW(guid2name[i].name))
 851                     return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 852             }
 853             if (ret_len) *ret_len = lstrlenW(guid2name[i].name) + 1;
 854             return S_OK;
 855         }
 856     }
 857
 858     return WINCODEC_ERR_PROPERTYNOTFOUND;
 859 }
 860
 861 HRESULT WINAPI WICMapShortNameToGuid(PCWSTR name, GUID *guid)
 862 {
 863     UINT i;
 864
 865     TRACE("%s,%p\n", debugstr_w(name), guid);
 866
 867     if (!name || !guid) return E_INVALIDARG;
 868
 869     for (i = 0; i < ARRAY_SIZE(guid2name); i++)
 870     {
 871         if (!lstrcmpiW(name, guid2name[i].name))
 872         {
 873             *guid = *guid2name[i].guid;
 874             return S_OK;
 875         }
 876     }
 877
 878     return WINCODEC_ERR_PROPERTYNOTFOUND;
 879 }
 880
 881 static const struct
 882 {
 883     const WCHAR *name;
 884     const WCHAR *schema;
 885 } name2schema[] =
 886 {
 887     { L"rdf", L"http://www.w3.org/1999/02/22-rdf-syntax-ns#" },
 888     { L"dc", L"http://purl.org/dc/elements/1.1/" },
 889     { L"xmp", L"http://ns.adobe.com/xap/1.0/" },
 890     { L"xmpidq", L"http://ns.adobe.com/xmp/Identifier/qual/1.0/" },
 891     { L"xmpRights", L"http://ns.adobe.com/xap/1.0/rights/" },
 892     { L"xmpMM", L"http://ns.adobe.com/xap/1.0/mm/" },
 893     { L"xmpBJ", L"http://ns.adobe.com/xap/1.0/bj/" },
 894     { L"xmpTPg", L"http://ns.adobe.com/xap/1.0/t/pg/" },
 895     { L"pdf", L"http://ns.adobe.com/pdf/1.3/" },
 896     { L"photoshop", L"http://ns.adobe.com/photoshop/1.0/" },
 897     { L"tiff", L"http://ns.adobe.com/tiff/1.0/" },
 898     { L"exif", L"http://ns.adobe.com/exif/1.0/" },
 899     { L"stDim", L"http://ns.adobe.com/xap/1.0/sType/Dimensions#" },
 900     { L"xapGImg", L"http://ns.adobe.com/xap/1.0/g/img/" },
 901     { L"stEvt", L"http://ns.adobe.com/xap/1.0/sType/ResourceEvent#" },
 902     { L"stRef", L"http://ns.adobe.com/xap/1.0/sType/ResourceRef#" },
 903     { L"stVer", L"http://ns.adobe.com/xap/1.0/sType/Version#" },
 904     { L"stJob", L"http://ns.adobe.com/xap/1.0/sType/Job#" },
 905     { L"aux", L"http://ns.adobe.com/exif/1.0/aux/" },
 906     { L"crs", L"http://ns.adobe.com/camera-raw-settings/1.0/" },
 907     { L"xmpDM", L"http://ns.adobe.com/xmp/1.0/DynamicMedia/" },
 908     { L"Iptc4xmpCore", L"http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/" },
 909     { L"MicrosoftPhoto", L"http://ns.microsoft.com/photo/1.0/" },
 910     { L"MP", L"http://ns.microsoft.com/photo/1.2/" },
 911     { L"MPRI", L"http://ns.microsoft.com/photo/1.2/t/RegionInfo#" },
 912     { L"MPReg", L"http://ns.microsoft.com/photo/1.2/t/Region#" }
 913 };
 914
 915 static const WCHAR *map_shortname_to_schema(const GUID *format, const WCHAR *name)
 916 {
 917     UINT i;
 918
 919     /* It appears that the only metadata formats
 920      * that support schemas are xmp and xmpstruct.
 921      */
 922     if (!IsEqualGUID(format, &GUID_MetadataFormatXMP) &&
 923         !IsEqualGUID(format, &GUID_MetadataFormatXMPStruct))
 924         return NULL;
 925
 926     for (i = 0; i < ARRAY_SIZE(name2schema); i++)
 927     {
 928         if (!wcscmp(name2schema[i].name, name))
 929             return name2schema[i].schema;
 930     }
 931
 932     return NULL;
 933 }
 934
 935 HRESULT WINAPI WICMapSchemaToName(REFGUID format, LPWSTR schema, UINT len, WCHAR *name, UINT *ret_len)
 936 {
 937     UINT i;
 938
 939     TRACE("%s,%s,%u,%p,%p\n", wine_dbgstr_guid(format), debugstr_w(schema), len, name, ret_len);
 940
 941     if (!format || !schema || !ret_len)
 942         return E_INVALIDARG;
 943
 944     /* It appears that the only metadata formats
 945      * that support schemas are xmp and xmpstruct.
 946      */
 947     if (!IsEqualGUID(format, &GUID_MetadataFormatXMP) &&
 948         !IsEqualGUID(format, &GUID_MetadataFormatXMPStruct))
 949         return WINCODEC_ERR_PROPERTYNOTFOUND;
 950
 951     for (i = 0; i < ARRAY_SIZE(name2schema); i++)
 952     {
 953         if (!wcscmp(name2schema[i].schema, schema))
 954         {
 955             if (name)
 956             {
 957                 if (!len) return E_INVALIDARG;
 958
 959                 len = min(len - 1, lstrlenW(name2schema[i].name));
 960                 memcpy(name, name2schema[i].name, len * sizeof(WCHAR));
 961                 name[len] = 0;
 962
 963                 if (len < lstrlenW(name2schema[i].name))
 964                     return HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
 965             }
 966
 967             *ret_len = lstrlenW(name2schema[i].name) + 1;
 968             return S_OK;
 969         }
 970     }
 971
 972     return WINCODEC_ERR_PROPERTYNOTFOUND;
 973 }