dlls/devenum/mediacatenum.c

   1 /*
   2  *      IEnumMoniker implementation for DEVENUM.dll
   3  *
   4  * Copyright (C) 2002 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * NOTES ON THIS FILE:
  21  * - Implements IEnumMoniker interface which enumerates through moniker
  22  *   objects created from HKEY_CLASSES/CLSID/{DEVICE_CLSID}/Instance
  23  */
  24
  25 #include "devenum_private.h"
  26
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(devenum);
  30
  31 BOOL array_reserve(void **elements, unsigned int *capacity, unsigned int count, unsigned int size)
  32 {
  33     unsigned int max_capacity, new_capacity;
  34     void *new_elements;
  35
  36     if (count <= *capacity)
  37         return TRUE;
  38
  39     max_capacity = ~0u / size;
  40     if (count > max_capacity)
  41         return FALSE;
  42
  43     new_capacity = max(8, *capacity);
  44     while (new_capacity < count && new_capacity <= max_capacity / 2)
  45         new_capacity *= 2;
  46     if (new_capacity < count)
  47         new_capacity = count;
  48
  49     if (!(new_elements = realloc(*elements, new_capacity * size)))
  50     {
  51         ERR("Failed to allocate memory.\n");
  52         return FALSE;
  53     }
  54
  55     *elements = new_elements;
  56     *capacity = new_capacity;
  57     return TRUE;
  58 }
  59
  60 typedef struct
  61 {
  62     IEnumMoniker IEnumMoniker_iface;
  63     CLSID class;
  64     LONG ref;
  65     IEnumDMO *dmo_enum, *dmo_enum2;
  66     HKEY sw_key;
  67     DWORD sw_index;
  68     HKEY cm_key;
  69     DWORD cm_index;
  70 } EnumMonikerImpl;
  71
  72 static inline struct moniker *impl_from_IPropertyBag(IPropertyBag *iface)
  73 {
  74     return CONTAINING_RECORD(iface, struct moniker, IPropertyBag_iface);
  75 }
  76
  77 static HRESULT WINAPI property_bag_QueryInterface(IPropertyBag *iface, REFIID iid, void **out)
  78 {
  79     struct moniker *moniker = impl_from_IPropertyBag(iface);
  80
  81     TRACE("moniker %p, iid %s, out %p.\n", moniker, debugstr_guid(iid), out);
  82
  83     if (!out)
  84         return E_POINTER;
  85
  86     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IPropertyBag))
  87     {
  88         *out = iface;
  89         IPropertyBag_AddRef(iface);
  90         return S_OK;
  91     }
  92
  93     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  94     *out = NULL;
  95     return E_NOINTERFACE;
  96 }
  97
  98 static ULONG WINAPI property_bag_AddRef(IPropertyBag *iface)
  99 {
 100     struct moniker *moniker = impl_from_IPropertyBag(iface);
 101     return IMoniker_AddRef(&moniker->IMoniker_iface);
 102 }
 103
 104 static ULONG WINAPI property_bag_Release(IPropertyBag *iface)
 105 {
 106     struct moniker *moniker = impl_from_IPropertyBag(iface);
 107     return IMoniker_Release(&moniker->IMoniker_iface);
 108 }
 109
 110 static HRESULT WINAPI property_bag_Read(IPropertyBag *iface,
 111         const WCHAR *name, VARIANT *var, IErrorLog *errorlog)
 112 {
 113     struct moniker *moniker = impl_from_IPropertyBag(iface);
 114     WCHAR dmo_name[80];
 115     DWORD size, type;
 116     HKEY parent, key;
 117     WCHAR path[78];
 118     void *data;
 119     HRESULT hr;
 120     LONG ret;
 121
 122     TRACE("moniker %p, name %s, var %p, errorlog %p.\n", moniker, debugstr_w(name), var, errorlog);
 123
 124     if (!name || !var)
 125         return E_POINTER;
 126
 127     if (moniker->type == DEVICE_DMO)
 128     {
 129         if (!wcscmp(name, L"FriendlyName"))
 130         {
 131             if (SUCCEEDED(hr = DMOGetName(&moniker->clsid, dmo_name)))
 132             {
 133                 V_VT(var) = VT_BSTR;
 134                 V_BSTR(var) = SysAllocString(dmo_name);
 135             }
 136             return hr;
 137         }
 138         else if (!wcscmp(name, L"FilterData"))
 139         {
 140             unsigned int count = 1, input_count, output_count, i;
 141             DMO_PARTIAL_MEDIATYPE *types = NULL, *new_array;
 142             REGFILTERPINS2 reg_pins[2] = {{0}};
 143             REGFILTER2 reg_filter = {0};
 144             REGPINTYPES *reg_types;
 145             HRESULT hr;
 146
 147             do
 148             {
 149                 count *= 2;
 150                 if (!(new_array = realloc(types, 2 * count * sizeof(*types))))
 151                 {
 152                     free(types);
 153                     return E_OUTOFMEMORY;
 154                 }
 155                 types = new_array;
 156
 157                 if (FAILED(hr = DMOGetTypes(&moniker->clsid, count, &input_count, types,
 158                         count, &output_count, types + count)))
 159                 {
 160                     free(types);
 161                     return hr;
 162                 }
 163             } while (input_count == count || output_count == count);
 164
 165             if (!(reg_types = malloc(2 * count * sizeof(*reg_types))))
 166             {
 167                 free(types);
 168                 return hr;
 169             }
 170
 171             for (i = 0; i < input_count; ++i)
 172             {
 173                 reg_types[i].clsMajorType = &types[i].type;
 174                 reg_types[i].clsMinorType = &types[i].subtype;
 175             }
 176             for (i = 0; i < output_count; ++i)
 177             {
 178                 reg_types[count + i].clsMajorType = &types[count + i].type;
 179                 reg_types[count + i].clsMinorType = &types[count + i].subtype;
 180             }
 181             reg_pins[0].cInstances = 1;
 182             reg_pins[0].nMediaTypes = input_count;
 183             reg_pins[0].lpMediaType = reg_types;
 184             reg_pins[1].dwFlags = REG_PINFLAG_B_OUTPUT;
 185             reg_pins[1].cInstances = 1;
 186             reg_pins[1].nMediaTypes = output_count;
 187             reg_pins[1].lpMediaType = reg_types + count;
 188             reg_filter.dwVersion = 2;
 189             reg_filter.dwMerit = MERIT_NORMAL + 0x800,
 190             reg_filter.cPins2 = 2;
 191             reg_filter.rgPins2 = reg_pins;
 192
 193             hr = create_filter_data(var, &reg_filter);
 194             free(reg_types);
 195             free(types);
 196             return hr;
 197         }
 198         return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 199     }
 200
 201     if (moniker->type == DEVICE_FILTER)
 202     {
 203         wcscpy(path, L"CLSID\\");
 204         if (moniker->has_class)
 205         {
 206             StringFromGUID2(&moniker->class, path + wcslen(path), CHARS_IN_GUID);
 207             wcscat(path, L"\\Instance");
 208         }
 209         if ((ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, 0, &parent)))
 210             return HRESULT_FROM_WIN32(ret);
 211     }
 212     else if (moniker->type == DEVICE_CODEC)
 213     {
 214         wcscpy(path, L"Software\\Microsoft\\ActiveMovie\\devenum\\");
 215         if (moniker->has_class)
 216             StringFromGUID2(&moniker->class, path + wcslen(path), CHARS_IN_GUID);
 217         if ((ret = RegOpenKeyExW(HKEY_CURRENT_USER, path, 0, 0, &parent)))
 218             return HRESULT_FROM_WIN32(ret);
 219     }
 220     ret = RegOpenKeyExW(parent, moniker->name, 0, KEY_READ, &key);
 221     RegCloseKey(parent);
 222     if (ret)
 223         return HRESULT_FROM_WIN32(ret);
 224
 225     if ((ret = RegQueryValueExW(key, name, NULL, NULL, NULL, &size)))
 226     {
 227         RegCloseKey(key);
 228         return HRESULT_FROM_WIN32(ret);
 229     }
 230
 231     data = malloc(size);
 232     if ((ret = RegQueryValueExW(key, name, NULL, &type, data, &size)))
 233     {
 234         RegCloseKey(key);
 235         free(data);
 236         return HRESULT_FROM_WIN32(ret);
 237     }
 238     RegCloseKey(key);
 239
 240     switch (type)
 241     {
 242     case REG_SZ:
 243         if (V_VT(var) == VT_EMPTY)
 244             V_VT(var) = VT_BSTR;
 245         if (V_VT(var) != VT_BSTR)
 246         {
 247             WARN("Invalid type %s.\n", debugstr_vt(V_VT(var)));
 248             return E_INVALIDARG;
 249         }
 250         V_BSTR(var) = SysAllocStringLen(data, size / sizeof(WCHAR) - 1);
 251         free(data);
 252         return S_OK;
 253     case REG_DWORD:
 254         if (V_VT(var) == VT_EMPTY)
 255             V_VT(var) = VT_I4;
 256         if (V_VT(var) != VT_I4)
 257         {
 258             WARN("Invalid type %s.\n", debugstr_vt(V_VT(var)));
 259             return E_INVALIDARG;
 260         }
 261         V_I4(var) = *(DWORD *)data;
 262         free(data);
 263         return S_OK;
 264     case REG_BINARY:
 265     {
 266         SAFEARRAYBOUND bound = {.cElements = size};
 267         void *array_data;
 268
 269         if (V_VT(var) == VT_EMPTY)
 270             V_VT(var) = VT_ARRAY | VT_UI1;
 271         if (V_VT(var) != (VT_ARRAY | VT_UI1))
 272         {
 273             WARN("Invalid type %s.\n", debugstr_vt(V_VT(var)));
 274             return E_INVALIDARG;
 275         }
 276
 277         if (!(V_ARRAY(var) = SafeArrayCreate(VT_UI1, 1, &bound)))
 278         {
 279             free(data);
 280             return E_OUTOFMEMORY;
 281         }
 282
 283         SafeArrayAccessData(V_ARRAY(var), &array_data);
 284         memcpy(array_data, data, size);
 285         SafeArrayUnaccessData(V_ARRAY(var));
 286         free(data);
 287         return S_OK;
 288     }
 289     default:
 290         FIXME("Unhandled type %#x.\n", type);
 291         free(data);
 292         return E_NOTIMPL;
 293     }
 294 }
 295
 296 static HRESULT WINAPI property_bag_Write(IPropertyBag *iface, const WCHAR *name, VARIANT *var)
 297 {
 298     struct moniker *moniker = impl_from_IPropertyBag(iface);
 299     HKEY parent, key;
 300     WCHAR path[78];
 301     LONG ret;
 302
 303     TRACE("moniker %p, name %s, var %s.\n", moniker, debugstr_w(name), debugstr_variant(var));
 304
 305     if (moniker->type == DEVICE_DMO)
 306         return E_ACCESSDENIED;
 307
 308     if (moniker->type == DEVICE_FILTER)
 309     {
 310         wcscpy(path, L"CLSID\\");
 311         if (moniker->has_class)
 312         {
 313             StringFromGUID2(&moniker->class, path + wcslen(path), CHARS_IN_GUID);
 314             wcscat(path, L"\\Instance");
 315         }
 316         if ((ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, path, 0, NULL, 0, 0, NULL, &parent, NULL)))
 317             return HRESULT_FROM_WIN32(ret);
 318     }
 319     else if (moniker->type == DEVICE_CODEC)
 320     {
 321         wcscpy(path, L"Software\\Microsoft\\ActiveMovie\\devenum\\");
 322         if (moniker->has_class)
 323             StringFromGUID2(&moniker->class, path + wcslen(path), CHARS_IN_GUID);
 324         if ((ret = RegCreateKeyExW(HKEY_CURRENT_USER, path, 0, NULL, 0, 0, NULL, &parent, NULL)))
 325             return HRESULT_FROM_WIN32(ret);
 326     }
 327     ret = RegCreateKeyExW(parent, moniker->name, 0, NULL, 0, KEY_WRITE, NULL, &key, NULL);
 328     RegCloseKey(parent);
 329     if (ret)
 330         return HRESULT_FROM_WIN32(ret);
 331
 332     switch (V_VT(var))
 333     {
 334     case VT_BSTR:
 335         ret = RegSetValueExW(key, name, 0, REG_SZ, (BYTE *)V_BSTR(var),
 336                 (wcslen(V_BSTR(var)) + 1) * sizeof(WCHAR));
 337         break;
 338     case VT_I4:
 339         ret = RegSetValueExW(key, name, 0, REG_DWORD, (BYTE *)&V_I4(var), sizeof(DWORD));
 340         break;
 341     case VT_ARRAY | VT_UI1:
 342     {
 343         LONG lbound, ubound;
 344         void *array_data;
 345         SafeArrayGetLBound(V_ARRAY(var), 1, &lbound);
 346         SafeArrayGetUBound(V_ARRAY(var), 1, &ubound);
 347         SafeArrayAccessData(V_ARRAY(var), &array_data);
 348         ret = RegSetValueExW(key, name, 0, REG_BINARY, array_data, ubound - lbound + 1);
 349         SafeArrayUnaccessData(V_ARRAY(var));
 350         break;
 351     }
 352     default:
 353         WARN("Unhandled type %s.\n", debugstr_vt(V_VT(var)));
 354         return E_INVALIDARG;
 355     }
 356
 357     RegCloseKey(key);
 358     return S_OK;
 359 }
 360
 361 static const IPropertyBagVtbl IPropertyBag_Vtbl =
 362 {
 363     property_bag_QueryInterface,
 364     property_bag_AddRef,
 365     property_bag_Release,
 366     property_bag_Read,
 367     property_bag_Write,
 368 };
 369
 370 static inline struct moniker *impl_from_IMoniker(IMoniker *iface)
 371 {
 372     return CONTAINING_RECORD(iface, struct moniker, IMoniker_iface);
 373 }
 374
 375 static HRESULT WINAPI moniker_QueryInterface(IMoniker *iface, REFIID riid, void **ppv)
 376 {
 377     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
 378
 379     if (!ppv)
 380         return E_POINTER;
 381
 382     if (IsEqualGUID(riid, &IID_IUnknown) ||
 383         IsEqualGUID(riid, &IID_IPersist) ||
 384         IsEqualGUID(riid, &IID_IPersistStream) ||
 385         IsEqualGUID(riid, &IID_IMoniker))
 386     {
 387         *ppv = iface;
 388         IMoniker_AddRef(iface);
 389         return S_OK;
 390     }
 391
 392     FIXME("- no interface IID: %s\n", debugstr_guid(riid));
 393     *ppv = NULL;
 394     return E_NOINTERFACE;
 395 }
 396
 397 static ULONG WINAPI moniker_AddRef(IMoniker *iface)
 398 {
 399     struct moniker *This = impl_from_IMoniker(iface);
 400     ULONG ref = InterlockedIncrement(&This->ref);
 401
 402     TRACE("(%p) ref=%d\n", This, ref);
 403
 404     return ref;
 405 }
 406
 407 static ULONG WINAPI moniker_Release(IMoniker *iface)
 408 {
 409     struct moniker *This = impl_from_IMoniker(iface);
 410     ULONG ref = InterlockedDecrement(&This->ref);
 411
 412     TRACE("(%p) ref=%d\n", This, ref);
 413
 414     if (ref == 0) {
 415         free(This->name);
 416         free(This);
 417         DEVENUM_UnlockModule();
 418     }
 419     return ref;
 420 }
 421
 422 static HRESULT WINAPI moniker_GetClassID(IMoniker *iface, CLSID *pClassID)
 423 {
 424     struct moniker *This = impl_from_IMoniker(iface);
 425
 426     TRACE("(%p)->(%p)\n", This, pClassID);
 427
 428     if (pClassID == NULL)
 429         return E_INVALIDARG;
 430
 431     *pClassID = CLSID_CDeviceMoniker;
 432
 433     return S_OK;
 434 }
 435
 436 static HRESULT WINAPI moniker_IsDirty(IMoniker *iface)
 437 {
 438     FIXME("(%p)->(): stub\n", iface);
 439
 440     return S_FALSE;
 441 }
 442
 443 static HRESULT WINAPI moniker_Load(IMoniker *iface, IStream *pStm)
 444 {
 445     FIXME("(%p)->(%p): stub\n", iface, pStm);
 446
 447     return E_NOTIMPL;
 448 }
 449
 450 static HRESULT WINAPI moniker_Save(IMoniker *iface, IStream *pStm, BOOL fClearDirty)
 451 {
 452     FIXME("(%p)->(%p, %s): stub\n", iface, pStm, fClearDirty ? "true" : "false");
 453
 454     return STG_E_CANTSAVE;
 455 }
 456
 457 static HRESULT WINAPI moniker_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *pcbSize)
 458 {
 459     FIXME("(%p)->(%p): stub\n", iface, pcbSize);
 460
 461     ZeroMemory(pcbSize, sizeof(*pcbSize));
 462
 463     return S_OK;
 464 }
 465
 466 static HRESULT WINAPI moniker_BindToObject(IMoniker *iface, IBindCtx *bind_ctx,
 467         IMoniker *left, REFIID iid, void **out)
 468 {
 469     struct moniker *moniker = impl_from_IMoniker(iface);
 470     IPersistPropertyBag *persist_bag;
 471     IUnknown *unk;
 472     CLSID clsid;
 473     VARIANT var;
 474     HRESULT hr;
 475
 476     TRACE("moniker %p, bind_ctx %p, left %p, iid %s, out %p.\n",
 477             moniker, bind_ctx, left, debugstr_guid(iid), out);
 478
 479     if (!out)
 480         return E_POINTER;
 481
 482     *out = NULL;
 483
 484     if (moniker->type == DEVICE_DMO)
 485     {
 486         IDMOWrapperFilter *wrapper;
 487
 488         if (FAILED(hr = CoCreateInstance(&CLSID_DMOWrapperFilter, NULL,
 489                 CLSCTX_INPROC_SERVER, &IID_IDMOWrapperFilter, (void **)&wrapper)))
 490             return hr;
 491
 492         if (SUCCEEDED(hr = IDMOWrapperFilter_Init(wrapper, &moniker->clsid, &moniker->class)))
 493         {
 494             hr = IDMOWrapperFilter_QueryInterface(wrapper, iid, out);
 495         }
 496         IDMOWrapperFilter_Release(wrapper);
 497         return hr;
 498     }
 499
 500     VariantInit(&var);
 501     V_VT(&var) = VT_BSTR;
 502     if (FAILED(hr = IPropertyBag_Read(&moniker->IPropertyBag_iface, L"CLSID", &var, NULL)))
 503         return hr;
 504
 505     hr = CLSIDFromString(V_BSTR(&var), &clsid);
 506     VariantClear(&var);
 507     if (FAILED(hr))
 508         return hr;
 509
 510     if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_ALL, &IID_IUnknown, (void **)&unk)))
 511         return hr;
 512
 513     if (SUCCEEDED(IUnknown_QueryInterface(unk, &IID_IPersistPropertyBag, (void **)&persist_bag)))
 514     {
 515         hr = IPersistPropertyBag_Load(persist_bag, &moniker->IPropertyBag_iface, NULL);
 516         IPersistPropertyBag_Release(persist_bag);
 517     }
 518
 519     if (SUCCEEDED(hr))
 520         hr = IUnknown_QueryInterface(unk, iid, out);
 521
 522     IUnknown_Release(unk);
 523
 524     return hr;
 525 }
 526
 527 static HRESULT WINAPI moniker_BindToStorage(IMoniker *iface, IBindCtx *pbc,
 528         IMoniker *pmkToLeft, REFIID riid, void **out)
 529 {
 530     struct moniker *moniker = impl_from_IMoniker(iface);
 531
 532     TRACE("moniker %p, left %p, iid %s, out %p.\n", moniker, pmkToLeft, debugstr_guid(riid), out);
 533
 534     *out = NULL;
 535
 536     if (pmkToLeft)
 537         return MK_E_NOSTORAGE;
 538
 539     if (pbc != NULL)
 540     {
 541         static DWORD reported;
 542         if (!reported)
 543         {
 544             FIXME("ignoring IBindCtx %p\n", pbc);
 545             reported++;
 546         }
 547     }
 548
 549     if (IsEqualGUID(riid, &IID_IPropertyBag))
 550     {
 551         *out = &moniker->IPropertyBag_iface;
 552         IPropertyBag_AddRef(&moniker->IPropertyBag_iface);
 553         return S_OK;
 554     }
 555
 556     return MK_E_NOSTORAGE;
 557 }
 558
 559 static HRESULT WINAPI moniker_Reduce(IMoniker *iface, IBindCtx *pbc,
 560         DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
 561 {
 562     TRACE("(%p)->(%p, %d, %p, %p)\n", iface, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
 563
 564     if (ppmkToLeft)
 565         *ppmkToLeft = NULL;
 566     *ppmkReduced = iface;
 567
 568     return MK_S_REDUCED_TO_SELF;
 569 }
 570
 571 static HRESULT WINAPI moniker_ComposeWith(IMoniker *iface, IMoniker *pmkRight,
 572         BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
 573 {
 574     FIXME("(%p)->(%p, %s, %p): stub\n", iface, pmkRight, fOnlyIfNotGeneric ? "true" : "false", ppmkComposite);
 575
 576     /* FIXME: use CreateGenericComposite? */
 577     *ppmkComposite = NULL;
 578
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI moniker_Enum(IMoniker *iface, BOOL fForward,
 583         IEnumMoniker **ppenumMoniker)
 584 {
 585     FIXME("(%p)->(%s, %p): stub\n", iface, fForward ? "true" : "false", ppenumMoniker);
 586
 587     *ppenumMoniker = NULL;
 588
 589     return S_OK;
 590 }
 591
 592 static HRESULT WINAPI moniker_IsEqual(IMoniker *iface, IMoniker *pmkOtherMoniker)
 593 {
 594     CLSID clsid;
 595     LPOLESTR this_name, other_name;
 596     IBindCtx *bind;
 597     HRESULT res;
 598
 599     TRACE("(%p)->(%p)\n", iface, pmkOtherMoniker);
 600
 601     if (!pmkOtherMoniker)
 602         return E_INVALIDARG;
 603
 604     IMoniker_GetClassID(pmkOtherMoniker, &clsid);
 605     if (!IsEqualCLSID(&clsid, &CLSID_CDeviceMoniker))
 606         return S_FALSE;
 607
 608     res = CreateBindCtx(0, &bind);
 609     if (FAILED(res))
 610        return res;
 611
 612     res = S_FALSE;
 613     if (SUCCEEDED(IMoniker_GetDisplayName(iface, bind, NULL, &this_name)) &&
 614         SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker, bind, NULL, &other_name)))
 615     {
 616         int result = wcsicmp(this_name, other_name);
 617         CoTaskMemFree(this_name);
 618         CoTaskMemFree(other_name);
 619         if (!result)
 620             res = S_OK;
 621     }
 622     IBindCtx_Release(bind);
 623     return res;
 624 }
 625
 626 static HRESULT WINAPI moniker_Hash(IMoniker *iface, DWORD *pdwHash)
 627 {
 628     TRACE("(%p)->(%p)\n", iface, pdwHash);
 629
 630     *pdwHash = 0;
 631
 632     return S_OK;
 633 }
 634
 635 static HRESULT WINAPI moniker_IsRunning(IMoniker *iface, IBindCtx *pbc,
 636         IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
 637 {
 638     FIXME("(%p)->(%p, %p, %p): stub\n", iface, pbc, pmkToLeft, pmkNewlyRunning);
 639
 640     return S_FALSE;
 641 }
 642
 643 static HRESULT WINAPI moniker_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc,
 644         IMoniker *pmkToLeft, FILETIME *pFileTime)
 645 {
 646     TRACE("(%p)->(%p, %p, %p)\n", iface, pbc, pmkToLeft, pFileTime);
 647
 648     pFileTime->dwLowDateTime = 0xFFFFFFFF;
 649     pFileTime->dwHighDateTime = 0x7FFFFFFF;
 650
 651     return MK_E_UNAVAILABLE;
 652 }
 653
 654 static HRESULT WINAPI moniker_Inverse(IMoniker *iface, IMoniker **ppmk)
 655 {
 656     TRACE("(%p)->(%p)\n", iface, ppmk);
 657
 658     *ppmk = NULL;
 659
 660     return MK_E_NOINVERSE;
 661 }
 662
 663 static HRESULT WINAPI moniker_CommonPrefixWith(IMoniker *iface,
 664         IMoniker *pmkOtherMoniker, IMoniker **ppmkPrefix)
 665 {
 666     TRACE("(%p)->(%p, %p)\n", iface, pmkOtherMoniker, ppmkPrefix);
 667
 668     *ppmkPrefix = NULL;
 669
 670     return MK_E_NOPREFIX;
 671 }
 672
 673 static HRESULT WINAPI moniker_RelativePathTo(IMoniker *iface, IMoniker *pmkOther,
 674         IMoniker **ppmkRelPath)
 675 {
 676     TRACE("(%p)->(%p, %p)\n", iface, pmkOther, ppmkRelPath);
 677
 678     *ppmkRelPath = pmkOther;
 679
 680     return MK_S_HIM;
 681 }
 682
 683 static HRESULT WINAPI moniker_GetDisplayName(IMoniker *iface, IBindCtx *pbc,
 684         IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
 685 {
 686     struct moniker *This = impl_from_IMoniker(iface);
 687     WCHAR *buffer;
 688
 689     TRACE("(%p)->(%p, %p, %p)\n", iface, pbc, pmkToLeft, ppszDisplayName);
 690
 691     *ppszDisplayName = NULL;
 692
 693     if (This->type == DEVICE_DMO)
 694     {
 695         buffer = CoTaskMemAlloc((12 + 2 * CHARS_IN_GUID + 1) * sizeof(WCHAR));
 696         if (!buffer) return E_OUTOFMEMORY;
 697
 698         wcscpy(buffer, L"@device:dmo:");
 699         StringFromGUID2(&This->clsid, buffer + wcslen(buffer), CHARS_IN_GUID);
 700         StringFromGUID2(&This->class, buffer + wcslen(buffer), CHARS_IN_GUID);
 701     }
 702     else
 703     {
 704         buffer = CoTaskMemAlloc((11 + (This->has_class ? CHARS_IN_GUID : 0)
 705                 + wcslen(This->name) + 1) * sizeof(WCHAR));
 706         if (!buffer) return E_OUTOFMEMORY;
 707
 708         if (This->type == DEVICE_FILTER)
 709             wcscpy(buffer, L"@device:sw:");
 710         else if (This->type == DEVICE_CODEC)
 711             wcscpy(buffer, L"@device:cm:");
 712
 713         if (This->has_class)
 714         {
 715             StringFromGUID2(&This->class, buffer + wcslen(buffer), CHARS_IN_GUID);
 716             wcscat(buffer, L"\\");
 717         }
 718         wcscat(buffer, This->name);
 719     }
 720
 721     *ppszDisplayName = buffer;
 722     return S_OK;
 723 }
 724
 725 static HRESULT WINAPI moniker_ParseDisplayName(IMoniker *iface, IBindCtx *pbc,
 726         IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
 727 {
 728     FIXME("(%p)->(%p, %p, %s, %p, %p)\n", iface, pbc, pmkToLeft, debugstr_w(pszDisplayName), pchEaten, ppmkOut);
 729
 730     *pchEaten = 0;
 731     *ppmkOut = NULL;
 732
 733     return MK_E_SYNTAX;
 734 }
 735
 736 static HRESULT WINAPI moniker_IsSystemMoniker(IMoniker *iface, DWORD *pdwMksys)
 737 {
 738     TRACE("(%p)->(%p)\n", iface, pdwMksys);
 739
 740     return S_FALSE;
 741 }
 742
 743 static const IMonikerVtbl IMoniker_Vtbl =
 744 {
 745     moniker_QueryInterface,
 746     moniker_AddRef,
 747     moniker_Release,
 748     moniker_GetClassID,
 749     moniker_IsDirty,
 750     moniker_Load,
 751     moniker_Save,
 752     moniker_GetSizeMax,
 753     moniker_BindToObject,
 754     moniker_BindToStorage,
 755     moniker_Reduce,
 756     moniker_ComposeWith,
 757     moniker_Enum,
 758     moniker_IsEqual,
 759     moniker_Hash,
 760     moniker_IsRunning,
 761     moniker_GetTimeOfLastChange,
 762     moniker_Inverse,
 763     moniker_CommonPrefixWith,
 764     moniker_RelativePathTo,
 765     moniker_GetDisplayName,
 766     moniker_ParseDisplayName,
 767     moniker_IsSystemMoniker,
 768 };
 769
 770 struct moniker *filter_moniker_create(const GUID *class, const WCHAR *name)
 771 {
 772     struct moniker *object;
 773
 774     if (!(object = calloc(1, sizeof(*object))))
 775         return NULL;
 776
 777     object->IMoniker_iface.lpVtbl = &IMoniker_Vtbl;
 778     object->IPropertyBag_iface.lpVtbl = &IPropertyBag_Vtbl;
 779     object->ref = 1;
 780     object->type = DEVICE_FILTER;
 781     if (class)
 782         object->class = *class;
 783     object->has_class = !!class;
 784     object->name = wcsdup(name);
 785
 786     DEVENUM_LockModule();
 787
 788     return object;
 789 }
 790
 791 struct moniker *codec_moniker_create(const GUID *class, const WCHAR *name)
 792 {
 793     struct moniker *object;
 794
 795     if (!(object = calloc(1, sizeof(*object))))
 796         return NULL;
 797
 798     object->IMoniker_iface.lpVtbl = &IMoniker_Vtbl;
 799     object->IPropertyBag_iface.lpVtbl = &IPropertyBag_Vtbl;
 800     object->ref = 1;
 801     object->type = DEVICE_CODEC;
 802     if (class)
 803         object->class = *class;
 804     object->has_class = !!class;
 805     object->name = wcsdup(name);
 806
 807     DEVENUM_LockModule();
 808
 809     return object;
 810 }
 811
 812 struct moniker *dmo_moniker_create(const GUID class, const GUID clsid)
 813 {
 814     struct moniker *object;
 815
 816     if (!(object = calloc(1, sizeof(*object))))
 817         return NULL;
 818
 819     object->IMoniker_iface.lpVtbl = &IMoniker_Vtbl;
 820     object->IPropertyBag_iface.lpVtbl = &IPropertyBag_Vtbl;
 821     object->ref = 1;
 822     object->type = DEVICE_DMO;
 823     object->class = class;
 824     object->clsid = clsid;
 825
 826     DEVENUM_LockModule();
 827
 828     return object;
 829 }
 830
 831 static inline EnumMonikerImpl *impl_from_IEnumMoniker(IEnumMoniker *iface)
 832 {
 833     return CONTAINING_RECORD(iface, EnumMonikerImpl, IEnumMoniker_iface);
 834 }
 835
 836 static HRESULT WINAPI enum_moniker_QueryInterface(IEnumMoniker *iface, REFIID riid, void **ppv)
 837 {
 838     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 839
 840     if (!ppv)
 841         return E_POINTER;
 842
 843     if (IsEqualGUID(riid, &IID_IUnknown) ||
 844         IsEqualGUID(riid, &IID_IEnumMoniker))
 845     {
 846         *ppv = iface;
 847         IEnumMoniker_AddRef(iface);
 848         return S_OK;
 849     }
 850
 851     FIXME("- no interface IID: %s\n", debugstr_guid(riid));
 852     *ppv = NULL;
 853     return E_NOINTERFACE;
 854 }
 855
 856 static ULONG WINAPI enum_moniker_AddRef(IEnumMoniker *iface)
 857 {
 858     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 859     ULONG ref = InterlockedIncrement(&This->ref);
 860
 861     TRACE("(%p) ref=%d\n", This, ref);
 862
 863     return ref;
 864 }
 865
 866 static ULONG WINAPI enum_moniker_Release(IEnumMoniker *iface)
 867 {
 868     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 869     ULONG ref = InterlockedDecrement(&This->ref);
 870
 871     TRACE("(%p) ref=%d\n", This, ref);
 872
 873     if (!ref)
 874     {
 875         if (This->dmo_enum)
 876             IEnumDMO_Release(This->dmo_enum);
 877         if (This->dmo_enum2)
 878             IEnumDMO_Release(This->dmo_enum2);
 879         RegCloseKey(This->sw_key);
 880         RegCloseKey(This->cm_key);
 881         free(This);
 882         DEVENUM_UnlockModule();
 883         return 0;
 884     }
 885     return ref;
 886 }
 887
 888 static struct moniker *get_dmo_moniker(EnumMonikerImpl *enum_moniker)
 889 {
 890     GUID clsid;
 891
 892     if (IsEqualGUID(&enum_moniker->class, &CLSID_LegacyAmFilterCategory))
 893     {
 894         if (enum_moniker->dmo_enum && IEnumDMO_Next(enum_moniker->dmo_enum, 1, &clsid, NULL, NULL) == S_OK)
 895             return dmo_moniker_create(DMOCATEGORY_AUDIO_DECODER, clsid);
 896         if (enum_moniker->dmo_enum2 && IEnumDMO_Next(enum_moniker->dmo_enum2, 1, &clsid, NULL, NULL) == S_OK)
 897             return dmo_moniker_create(DMOCATEGORY_VIDEO_DECODER, clsid);
 898     }
 899     else
 900     {
 901         if (enum_moniker->dmo_enum && IEnumDMO_Next(enum_moniker->dmo_enum, 1, &clsid, NULL, NULL) == S_OK)
 902             return dmo_moniker_create(enum_moniker->class, clsid);
 903     }
 904
 905     return NULL;
 906 }
 907
 908 static HRESULT WINAPI enum_moniker_Next(IEnumMoniker *iface, ULONG celt, IMoniker **rgelt,
 909         ULONG *pceltFetched)
 910 {
 911     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 912     WCHAR buffer[MAX_PATH + 1];
 913     struct moniker *moniker;
 914     LONG res;
 915     ULONG fetched = 0;
 916     HKEY hkey;
 917
 918     TRACE("(%p)->(%d, %p, %p)\n", iface, celt, rgelt, pceltFetched);
 919
 920     while (fetched < celt)
 921     {
 922         /* FIXME: try PNP devices first */
 923
 924         /* try DMOs */
 925         if ((moniker = get_dmo_moniker(This)))
 926             ;
 927         /* try DirectShow filters */
 928         else if (!(res = RegEnumKeyW(This->sw_key, This->sw_index, buffer, ARRAY_SIZE(buffer))))
 929         {
 930             This->sw_index++;
 931             if ((res = RegOpenKeyExW(This->sw_key, buffer, 0, KEY_QUERY_VALUE, &hkey)))
 932                 break;
 933
 934             moniker = filter_moniker_create(&This->class, buffer);
 935         }
 936         /* then try codecs */
 937         else if (!(res = RegEnumKeyW(This->cm_key, This->cm_index, buffer, ARRAY_SIZE(buffer))))
 938         {
 939             This->cm_index++;
 940
 941             if ((res = RegOpenKeyExW(This->cm_key, buffer, 0, KEY_QUERY_VALUE, &hkey)))
 942                 break;
 943
 944             moniker = codec_moniker_create(&This->class, buffer);
 945         }
 946         else
 947             break;
 948
 949         if (!moniker)
 950             return E_OUTOFMEMORY;
 951
 952         rgelt[fetched++] = &moniker->IMoniker_iface;
 953     }
 954
 955     TRACE("-- fetched %d\n", fetched);
 956
 957     if (pceltFetched)
 958         *pceltFetched = fetched;
 959
 960     if (fetched != celt)
 961         return S_FALSE;
 962     else
 963         return S_OK;
 964 }
 965
 966 static HRESULT WINAPI enum_moniker_Skip(IEnumMoniker *iface, ULONG celt)
 967 {
 968     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
 969
 970     TRACE("(%p)->(%d)\n", iface, celt);
 971
 972     while (celt--)
 973     {
 974         /* FIXME: try PNP devices first */
 975
 976         /* try DMOs */
 977         if (This->dmo_enum && IEnumDMO_Skip(This->dmo_enum, 1) == S_OK)
 978             ;
 979         else if (This->dmo_enum2 && IEnumDMO_Skip(This->dmo_enum2, 1) == S_OK)
 980             ;
 981         /* try DirectShow filters */
 982         else if (RegEnumKeyW(This->sw_key, This->sw_index, NULL, 0) != ERROR_NO_MORE_ITEMS)
 983         {
 984             This->sw_index++;
 985         }
 986         /* then try codecs */
 987         else if (RegEnumKeyW(This->cm_key, This->cm_index, NULL, 0) != ERROR_NO_MORE_ITEMS)
 988         {
 989             This->cm_index++;
 990         }
 991         else
 992             return S_FALSE;
 993     }
 994
 995     return S_OK;
 996 }
 997
 998 static HRESULT WINAPI enum_moniker_Reset(IEnumMoniker *iface)
 999 {
1000     EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
1001
1002     TRACE("(%p)->()\n", iface);
1003
1004     if (This->dmo_enum)
1005         IEnumDMO_Reset(This->dmo_enum);
1006     if (This->dmo_enum2)
1007         IEnumDMO_Reset(This->dmo_enum2);
1008     This->sw_index = 0;
1009     This->cm_index = 0;
1010
1011     return S_OK;
1012 }
1013
1014 static HRESULT WINAPI enum_moniker_Clone(IEnumMoniker *iface, IEnumMoniker **ppenum)
1015 {
1016     FIXME("(%p)->(%p): stub\n", iface, ppenum);
1017
1018     return E_NOTIMPL;
1019 }
1020
1021 /**********************************************************************
1022  * IEnumMoniker_Vtbl
1023  */
1024 static const IEnumMonikerVtbl IEnumMoniker_Vtbl =
1025 {
1026     enum_moniker_QueryInterface,
1027     enum_moniker_AddRef,
1028     enum_moniker_Release,
1029     enum_moniker_Next,
1030     enum_moniker_Skip,
1031     enum_moniker_Reset,
1032     enum_moniker_Clone,
1033 };
1034
1035 HRESULT enum_moniker_create(REFCLSID class, IEnumMoniker **out)
1036 {
1037     EnumMonikerImpl *object;
1038     WCHAR buffer[78];
1039
1040     if (!(object = calloc(1, sizeof(*object))))
1041         return E_OUTOFMEMORY;
1042
1043     object->IEnumMoniker_iface.lpVtbl = &IEnumMoniker_Vtbl;
1044     object->ref = 1;
1045     object->class = *class;
1046
1047     wcscpy(buffer, L"CLSID\\");
1048     StringFromGUID2(class, buffer + wcslen(buffer), CHARS_IN_GUID);
1049     wcscat(buffer, L"\\Instance");
1050     if (RegOpenKeyExW(HKEY_CLASSES_ROOT, buffer, 0, KEY_ENUMERATE_SUB_KEYS, &object->sw_key))
1051         object->sw_key = NULL;
1052
1053     wcscpy(buffer, L"Software\\Microsoft\\ActiveMovie\\devenum\\");
1054     StringFromGUID2(class, buffer + wcslen(buffer), CHARS_IN_GUID);
1055     if (RegOpenKeyExW(HKEY_CURRENT_USER, buffer, 0, KEY_ENUMERATE_SUB_KEYS, &object->cm_key))
1056         object->cm_key = NULL;
1057
1058     if (IsEqualGUID(class, &CLSID_LegacyAmFilterCategory))
1059     {
1060         if (FAILED(DMOEnum(&DMOCATEGORY_AUDIO_DECODER, 0, 0, NULL, 0, NULL, &object->dmo_enum)))
1061             object->dmo_enum = NULL;
1062         if (FAILED(DMOEnum(&DMOCATEGORY_VIDEO_DECODER, 0, 0, NULL, 0, NULL, &object->dmo_enum2)))
1063             object->dmo_enum2 = NULL;
1064     }
1065     else
1066     {
1067         if (FAILED(DMOEnum(class, 0, 0, NULL, 0, NULL, &object->dmo_enum)))
1068             object->dmo_enum = NULL;
1069     }
1070
1071     *out = &object->IEnumMoniker_iface;
1072
1073     DEVENUM_LockModule();
1074
1075     return S_OK;
1076 }