dlls/devenum/createdevenum.c

   1 /*
   2  *      ICreateDevEnum 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 ICreateDevEnum interface which creates an IEnumMoniker
  22  *   implementation
  23  * - Also creates the special registry keys created at run-time
  24  */
  25
  26 #define NONAMELESSSTRUCT
  27 #define NONAMELESSUNION
  28
  29 #include "devenum_private.h"
  30 #include "vfw.h"
  31 #include "aviriff.h"
  32 #include "dsound.h"
  33
  34 #include "wine/debug.h"
  35 #include "wine/heap.h"
  36 #include "mmddk.h"
  37
  38 #include "initguid.h"
  39 #include "wine/fil_data.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(devenum);
  42
  43 static HRESULT WINAPI devenum_factory_QueryInterface(ICreateDevEnum *iface, REFIID riid, void **ppv)
  44 {
  45     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
  46
  47     if (!ppv)
  48         return E_POINTER;
  49
  50     if (IsEqualGUID(riid, &IID_IUnknown) ||
  51         IsEqualGUID(riid, &IID_ICreateDevEnum))
  52     {
  53         *ppv = iface;
  54         ICreateDevEnum_AddRef(iface);
  55         return S_OK;
  56     }
  57
  58     FIXME("- no interface IID: %s\n", debugstr_guid(riid));
  59     *ppv = NULL;
  60     return E_NOINTERFACE;
  61 }
  62
  63 static ULONG WINAPI devenum_factory_AddRef(ICreateDevEnum *iface)
  64 {
  65     TRACE("\n");
  66
  67     DEVENUM_LockModule();
  68
  69     return 2; /* non-heap based object */
  70 }
  71
  72 static ULONG WINAPI devenum_factory_Release(ICreateDevEnum *iface)
  73 {
  74     TRACE("\n");
  75
  76     DEVENUM_UnlockModule();
  77
  78     return 1; /* non-heap based object */
  79 }
  80
  81 static HRESULT register_codec(const GUID *class, const WCHAR *name,
  82         const GUID *clsid, const WCHAR *friendly_name, IPropertyBag **ret)
  83 {
  84     WCHAR guidstr[CHARS_IN_GUID];
  85     IParseDisplayName *parser;
  86     IPropertyBag *propbag;
  87     IMoniker *mon;
  88     WCHAR *buffer;
  89     VARIANT var;
  90     ULONG eaten;
  91     HRESULT hr;
  92
  93     hr = CoCreateInstance(&CLSID_CDeviceMoniker, NULL, CLSCTX_INPROC, &IID_IParseDisplayName, (void **)&parser);
  94     if (FAILED(hr))
  95         return hr;
  96
  97     if (!(buffer = heap_alloc((wcslen(L"@device:cm:") + CHARS_IN_GUID + wcslen(name) + 1) * sizeof(WCHAR))))
  98     {
  99         IParseDisplayName_Release(parser);
 100         return E_OUTOFMEMORY;
 101     }
 102
 103     wcscpy(buffer, L"@device:cm:");
 104     StringFromGUID2(class, buffer + wcslen(buffer), CHARS_IN_GUID);
 105     wcscat(buffer, L"\\");
 106     wcscat(buffer, name);
 107
 108     IParseDisplayName_ParseDisplayName(parser, NULL, buffer, &eaten, &mon);
 109     IParseDisplayName_Release(parser);
 110     heap_free(buffer);
 111
 112     IMoniker_BindToStorage(mon, NULL, NULL, &IID_IPropertyBag, (void **)&propbag);
 113     IMoniker_Release(mon);
 114
 115     V_VT(&var) = VT_BSTR;
 116     V_BSTR(&var) = SysAllocString(friendly_name);
 117     hr = IPropertyBag_Write(propbag, L"FriendlyName", &var);
 118     VariantClear(&var);
 119     if (FAILED(hr))
 120     {
 121         IPropertyBag_Release(propbag);
 122         return hr;
 123     }
 124
 125     V_VT(&var) = VT_BSTR;
 126     StringFromGUID2(clsid, guidstr, ARRAY_SIZE(guidstr));
 127     V_BSTR(&var) = SysAllocString(guidstr);
 128     hr = IPropertyBag_Write(propbag, L"CLSID", &var);
 129     VariantClear(&var);
 130     if (FAILED(hr))
 131     {
 132         IPropertyBag_Release(propbag);
 133         return hr;
 134     }
 135
 136     *ret = propbag;
 137     return S_OK;
 138 }
 139
 140 static void DEVENUM_ReadPinTypes(HKEY hkeyPinKey, REGFILTERPINS2 *rgPin)
 141 {
 142     HKEY hkeyTypes = NULL;
 143     DWORD dwMajorTypes, i;
 144     REGPINTYPES *lpMediaType = NULL;
 145     DWORD dwMediaTypeSize = 0;
 146
 147     if (RegOpenKeyExW(hkeyPinKey, L"Types", 0, KEY_READ, &hkeyTypes) != ERROR_SUCCESS)
 148         return ;
 149
 150     if (RegQueryInfoKeyW(hkeyTypes, NULL, NULL, NULL, &dwMajorTypes, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 151                 != ERROR_SUCCESS)
 152     {
 153         RegCloseKey(hkeyTypes);
 154         return ;
 155     }
 156
 157     for (i = 0; i < dwMajorTypes; i++)
 158     {
 159         HKEY hkeyMajorType = NULL;
 160         WCHAR wszMajorTypeName[64];
 161         DWORD cName = ARRAY_SIZE(wszMajorTypeName);
 162         DWORD dwMinorTypes, i1;
 163
 164         if (RegEnumKeyExW(hkeyTypes, i, wszMajorTypeName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 165
 166         if (RegOpenKeyExW(hkeyTypes, wszMajorTypeName, 0, KEY_READ, &hkeyMajorType) != ERROR_SUCCESS) continue;
 167
 168         if (RegQueryInfoKeyW(hkeyMajorType, NULL, NULL, NULL, &dwMinorTypes, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 169                     != ERROR_SUCCESS)
 170         {
 171             RegCloseKey(hkeyMajorType);
 172             continue;
 173         }
 174
 175         for (i1 = 0; i1 < dwMinorTypes; i1++)
 176         {
 177             WCHAR wszMinorTypeName[64];
 178             CLSID *clsMajorType = NULL, *clsMinorType = NULL;
 179             HRESULT hr;
 180
 181             cName = ARRAY_SIZE(wszMinorTypeName);
 182             if (RegEnumKeyExW(hkeyMajorType, i1, wszMinorTypeName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 183
 184             clsMinorType = CoTaskMemAlloc(sizeof(CLSID));
 185             if (!clsMinorType) continue;
 186
 187             clsMajorType = CoTaskMemAlloc(sizeof(CLSID));
 188             if (!clsMajorType) goto error_cleanup_types;
 189
 190             hr = CLSIDFromString(wszMinorTypeName, clsMinorType);
 191             if (FAILED(hr)) goto error_cleanup_types;
 192
 193             hr = CLSIDFromString(wszMajorTypeName, clsMajorType);
 194             if (FAILED(hr)) goto error_cleanup_types;
 195
 196             if (rgPin->nMediaTypes == dwMediaTypeSize)
 197             {
 198                 DWORD dwNewSize = dwMediaTypeSize + (dwMediaTypeSize < 2 ? 1 : dwMediaTypeSize / 2);
 199                 REGPINTYPES *lpNewMediaType;
 200
 201                 lpNewMediaType = CoTaskMemRealloc(lpMediaType, sizeof(REGPINTYPES) * dwNewSize);
 202                 if (!lpNewMediaType) goto error_cleanup_types;
 203
 204                 lpMediaType = lpNewMediaType;
 205                 dwMediaTypeSize = dwNewSize;
 206              }
 207
 208             lpMediaType[rgPin->nMediaTypes].clsMajorType = clsMajorType;
 209             lpMediaType[rgPin->nMediaTypes].clsMinorType = clsMinorType;
 210             rgPin->nMediaTypes++;
 211             continue;
 212
 213             error_cleanup_types:
 214
 215             CoTaskMemFree(clsMajorType);
 216             CoTaskMemFree(clsMinorType);
 217         }
 218
 219         RegCloseKey(hkeyMajorType);
 220     }
 221
 222     RegCloseKey(hkeyTypes);
 223
 224     if (lpMediaType && !rgPin->nMediaTypes)
 225     {
 226         CoTaskMemFree(lpMediaType);
 227         lpMediaType = NULL;
 228     }
 229
 230     rgPin->lpMediaType = lpMediaType;
 231 }
 232
 233 static void DEVENUM_ReadPins(HKEY hkeyFilterClass, REGFILTER2 *rgf2)
 234 {
 235     HKEY hkeyPins = NULL;
 236     DWORD dwPinsSubkeys, i;
 237     REGFILTERPINS2 *rgPins = NULL;
 238
 239     rgf2->dwVersion = 2;
 240     rgf2->cPins2 = 0;
 241     rgf2->rgPins2 = NULL;
 242
 243     if (RegOpenKeyExW(hkeyFilterClass, L"Pins", 0, KEY_READ, &hkeyPins) != ERROR_SUCCESS)
 244         return ;
 245
 246     if (RegQueryInfoKeyW(hkeyPins, NULL, NULL, NULL, &dwPinsSubkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 247                 != ERROR_SUCCESS)
 248     {
 249         RegCloseKey(hkeyPins);
 250         return ;
 251     }
 252
 253     if (dwPinsSubkeys)
 254     {
 255         rgPins = CoTaskMemAlloc(sizeof(REGFILTERPINS2) * dwPinsSubkeys);
 256         if (!rgPins)
 257         {
 258             RegCloseKey(hkeyPins);
 259             return ;
 260         }
 261     }
 262
 263     for (i = 0; i < dwPinsSubkeys; i++)
 264     {
 265         HKEY hkeyPinKey = NULL;
 266         WCHAR wszPinName[MAX_PATH];
 267         DWORD cName = ARRAY_SIZE(wszPinName);
 268         REGFILTERPINS2 *rgPin = &rgPins[rgf2->cPins2];
 269         DWORD value, size, Type;
 270         LONG lRet;
 271
 272         memset(rgPin, 0, sizeof(*rgPin));
 273
 274         if (RegEnumKeyExW(hkeyPins, i, wszPinName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 275
 276         if (RegOpenKeyExW(hkeyPins, wszPinName, 0, KEY_READ, &hkeyPinKey) != ERROR_SUCCESS) continue;
 277
 278         size = sizeof(DWORD);
 279         lRet = RegQueryValueExW(hkeyPinKey, L"AllowedMany", NULL, &Type, (BYTE *)&value, &size);
 280         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 281             goto error_cleanup;
 282         if (value)
 283             rgPin->dwFlags |= REG_PINFLAG_B_MANY;
 284
 285         size = sizeof(DWORD);
 286         lRet = RegQueryValueExW(hkeyPinKey, L"AllowedZero", NULL, &Type, (BYTE *)&value, &size);
 287         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 288             goto error_cleanup;
 289         if (value)
 290             rgPin->dwFlags |= REG_PINFLAG_B_ZERO;
 291
 292         size = sizeof(DWORD);
 293         lRet = RegQueryValueExW(hkeyPinKey, L"Direction", NULL, &Type, (BYTE *)&value, &size);
 294         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 295             goto error_cleanup;
 296         if (value)
 297             rgPin->dwFlags |= REG_PINFLAG_B_OUTPUT;
 298
 299
 300         size = sizeof(DWORD);
 301         lRet = RegQueryValueExW(hkeyPinKey, L"IsRendered", NULL, &Type, (BYTE *)&value, &size);
 302         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 303             goto error_cleanup;
 304         if (value)
 305             rgPin->dwFlags |= REG_PINFLAG_B_RENDERER;
 306
 307         DEVENUM_ReadPinTypes(hkeyPinKey, rgPin);
 308
 309         ++rgf2->cPins2;
 310         continue;
 311
 312         error_cleanup:
 313
 314         RegCloseKey(hkeyPinKey);
 315     }
 316
 317     RegCloseKey(hkeyPins);
 318
 319     if (rgPins && !rgf2->cPins2)
 320     {
 321         CoTaskMemFree(rgPins);
 322         rgPins = NULL;
 323     }
 324
 325     rgf2->rgPins2 = rgPins;
 326 }
 327
 328 static void free_regfilter2(REGFILTER2 *rgf)
 329 {
 330     if (rgf->rgPins2)
 331     {
 332         UINT iPin;
 333
 334         for (iPin = 0; iPin < rgf->cPins2; iPin++)
 335         {
 336             if (rgf->rgPins2[iPin].lpMediaType)
 337             {
 338                 UINT iType;
 339
 340                 for (iType = 0; iType < rgf->rgPins2[iPin].nMediaTypes; iType++)
 341                 {
 342                     CoTaskMemFree((void *)rgf->rgPins2[iPin].lpMediaType[iType].clsMajorType);
 343                     CoTaskMemFree((void *)rgf->rgPins2[iPin].lpMediaType[iType].clsMinorType);
 344                 }
 345
 346                 CoTaskMemFree((void *)rgf->rgPins2[iPin].lpMediaType);
 347             }
 348         }
 349
 350         CoTaskMemFree((void *)rgf->rgPins2);
 351     }
 352 }
 353
 354 HRESULT create_filter_data(VARIANT *var, REGFILTER2 *rgf)
 355 {
 356     IAMFilterData *fildata;
 357     BYTE *data = NULL;
 358     ULONG size;
 359     HRESULT hr;
 360
 361     hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC, &IID_IAMFilterData, (void **)&fildata);
 362     if (FAILED(hr))
 363         return hr;
 364
 365     hr = IAMFilterData_CreateFilterData(fildata, rgf, &data, &size);
 366     IAMFilterData_Release(fildata);
 367     if (FAILED(hr))
 368         return hr;
 369
 370     V_VT(var) = VT_ARRAY | VT_UI1;
 371     if (!(V_ARRAY(var) = SafeArrayCreateVector(VT_UI1, 1, size)))
 372     {
 373         VariantClear(var);
 374         CoTaskMemFree(data);
 375         return E_OUTOFMEMORY;
 376     }
 377
 378     memcpy(V_ARRAY(var)->pvData, data, size);
 379     CoTaskMemFree(data);
 380     return S_OK;
 381 }
 382
 383 static void write_filter_data(IPropertyBag *prop_bag, REGFILTER2 *rgf)
 384 {
 385     VARIANT var;
 386
 387     if (SUCCEEDED(create_filter_data(&var, rgf)))
 388     {
 389         IPropertyBag_Write(prop_bag, L"FilterData", &var);
 390         VariantClear(&var);
 391     }
 392 }
 393
 394 static void register_legacy_filters(void)
 395 {
 396     HKEY hkeyFilter = NULL;
 397     DWORD dwFilterSubkeys, i;
 398     LONG lRet;
 399     HRESULT hr;
 400
 401     lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Filter", 0, KEY_READ, &hkeyFilter);
 402     hr = HRESULT_FROM_WIN32(lRet);
 403
 404     if (SUCCEEDED(hr))
 405     {
 406         lRet = RegQueryInfoKeyW(hkeyFilter, NULL, NULL, NULL, &dwFilterSubkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 407         hr = HRESULT_FROM_WIN32(lRet);
 408     }
 409
 410     if (SUCCEEDED(hr))
 411     {
 412         for (i = 0; i < dwFilterSubkeys; i++)
 413         {
 414             WCHAR wszFilterSubkeyName[64];
 415             DWORD cName = ARRAY_SIZE(wszFilterSubkeyName);
 416             IPropertyBag *prop_bag = NULL;
 417             WCHAR wszRegKey[MAX_PATH];
 418             HKEY classkey = NULL;
 419             REGFILTER2 rgf2;
 420             DWORD Type, len;
 421             GUID clsid;
 422
 423             if (RegEnumKeyExW(hkeyFilter, i, wszFilterSubkeyName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 424
 425             TRACE("Registering %s\n", debugstr_w(wszFilterSubkeyName));
 426
 427             hr = CLSIDFromString(wszFilterSubkeyName, &clsid);
 428             if (FAILED(hr))
 429                 continue;
 430
 431             swprintf(wszRegKey, ARRAY_SIZE(wszRegKey), L"CLSID\\%s", wszFilterSubkeyName);
 432             if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszRegKey, 0, KEY_READ, &classkey) != ERROR_SUCCESS)
 433                 continue;
 434
 435             len = 0;
 436             if (!RegQueryValueExW(classkey, NULL, NULL, &Type, NULL, &len))
 437             {
 438                 WCHAR *friendlyname = heap_alloc(len);
 439                 if (!friendlyname)
 440                 {
 441                     RegCloseKey(classkey);
 442                     continue;
 443                 }
 444                 RegQueryValueExW(classkey, NULL, NULL, &Type, (BYTE *)friendlyname, &len);
 445
 446                 hr = register_codec(&CLSID_LegacyAmFilterCategory, wszFilterSubkeyName,
 447                         &clsid, friendlyname, &prop_bag);
 448
 449                 heap_free(friendlyname);
 450             }
 451             else
 452                 hr = register_codec(&CLSID_LegacyAmFilterCategory, wszFilterSubkeyName,
 453                         &clsid, wszFilterSubkeyName, &prop_bag);
 454             if (FAILED(hr))
 455             {
 456                 RegCloseKey(classkey);
 457                 continue;
 458             }
 459
 460             /* write filter data */
 461             rgf2.dwMerit = MERIT_NORMAL;
 462
 463             len = sizeof(rgf2.dwMerit);
 464             RegQueryValueExW(classkey, L"Merit", NULL, &Type, (BYTE *)&rgf2.dwMerit, &len);
 465
 466             DEVENUM_ReadPins(classkey, &rgf2);
 467
 468             write_filter_data(prop_bag, &rgf2);
 469
 470             IPropertyBag_Release(prop_bag);
 471             RegCloseKey(classkey);
 472             free_regfilter2(&rgf2);
 473         }
 474     }
 475
 476     if (hkeyFilter) RegCloseKey(hkeyFilter);
 477 }
 478
 479 static BOOL CALLBACK register_dsound_devices(GUID *guid, const WCHAR *desc, const WCHAR *module, void *context)
 480 {
 481     static const WCHAR defaultW[] = L"Default DirectSound Device";
 482     IPropertyBag *prop_bag = NULL;
 483     REGFILTERPINS2 rgpins = {0};
 484     REGPINTYPES rgtypes = {0};
 485     REGFILTER2 rgf = {0};
 486     WCHAR clsid[CHARS_IN_GUID];
 487     VARIANT var;
 488     HRESULT hr;
 489
 490     if (guid)
 491     {
 492         WCHAR *name = heap_alloc(sizeof(defaultW) + wcslen(desc) * sizeof(WCHAR));
 493         if (!name)
 494             return FALSE;
 495         wcscpy(name, L"DirectSound: ");
 496         wcscat(name, desc);
 497
 498         hr = register_codec(&CLSID_AudioRendererCategory, name,
 499                 &CLSID_DSoundRender, name, &prop_bag);
 500         heap_free(name);
 501     }
 502     else
 503         hr = register_codec(&CLSID_AudioRendererCategory, defaultW,
 504                 &CLSID_DSoundRender, defaultW, &prop_bag);
 505     if (FAILED(hr))
 506         return FALSE;
 507
 508     /* write filter data */
 509     rgf.dwVersion = 2;
 510     rgf.dwMerit = guid ? MERIT_DO_NOT_USE : MERIT_PREFERRED;
 511     rgf.cPins2 = 1;
 512     rgf.rgPins2 = &rgpins;
 513     rgpins.dwFlags = REG_PINFLAG_B_RENDERER;
 514     /* FIXME: native registers many more formats */
 515     rgpins.nMediaTypes = 1;
 516     rgpins.lpMediaType = &rgtypes;
 517     rgtypes.clsMajorType = &MEDIATYPE_Audio;
 518     rgtypes.clsMinorType = &MEDIASUBTYPE_PCM;
 519
 520     write_filter_data(prop_bag, &rgf);
 521
 522     /* write DSound guid */
 523     V_VT(&var) = VT_BSTR;
 524     StringFromGUID2(guid ? guid : &GUID_NULL, clsid, CHARS_IN_GUID);
 525     if ((V_BSTR(&var) = SysAllocString(clsid)))
 526         hr = IPropertyBag_Write(prop_bag, L"DSGuid", &var);
 527
 528     VariantClear(&var);
 529     IPropertyBag_Release(prop_bag);
 530     return TRUE;
 531 }
 532
 533 static void register_waveout_devices(void)
 534 {
 535     IPropertyBag *prop_bag = NULL;
 536     REGFILTERPINS2 rgpins = {0};
 537     REGPINTYPES rgtypes = {0};
 538     REGFILTER2 rgf = {0};
 539     WAVEOUTCAPSW caps;
 540     const WCHAR *name;
 541     int i, count;
 542     VARIANT var;
 543     HRESULT hr;
 544
 545     count = waveOutGetNumDevs();
 546
 547     for (i = -1; i < count; i++)
 548     {
 549         waveOutGetDevCapsW(i, &caps, sizeof(caps));
 550
 551         name = (i == -1) ? L"Default WaveOut Device" : caps.szPname;
 552
 553         hr = register_codec(&CLSID_AudioRendererCategory, name,
 554                 &CLSID_AudioRender, name, &prop_bag);
 555         if (FAILED(hr))
 556             continue;
 557
 558         /* write filter data */
 559         rgf.dwVersion = 2;
 560         rgf.dwMerit = MERIT_DO_NOT_USE;
 561         rgf.cPins2 = 1;
 562         rgf.rgPins2 = &rgpins;
 563         rgpins.dwFlags = REG_PINFLAG_B_RENDERER;
 564         rgpins.nMediaTypes = 1;
 565         rgpins.lpMediaType = &rgtypes;
 566         rgtypes.clsMajorType = &MEDIATYPE_Audio;
 567         rgtypes.clsMinorType = &MEDIASUBTYPE_NULL;
 568
 569         write_filter_data(prop_bag, &rgf);
 570
 571         /* write WaveOutId */
 572         V_VT(&var) = VT_I4;
 573         V_I4(&var) = i;
 574         IPropertyBag_Write(prop_bag, L"WaveOutId", &var);
 575
 576         VariantClear(&var);
 577         if (prop_bag) IPropertyBag_Release(prop_bag);
 578     }
 579 }
 580
 581 static void register_wavein_devices(void)
 582 {
 583     IPropertyBag *prop_bag = NULL;
 584     REGFILTER2 rgf = {0};
 585     WAVEINCAPSW caps;
 586     int i, count;
 587     VARIANT var;
 588     HRESULT hr;
 589
 590     count = waveInGetNumDevs();
 591
 592     for (i = 0; i < count; i++)
 593     {
 594         waveInGetDevCapsW(i, &caps, sizeof(caps));
 595
 596         hr = register_codec(&CLSID_AudioInputDeviceCategory, caps.szPname,
 597                 &CLSID_AudioRecord, caps.szPname, &prop_bag);
 598         if (FAILED(hr))
 599             continue;
 600
 601         /* write filter data */
 602         rgf.dwVersion = 2;
 603         rgf.dwMerit = MERIT_DO_NOT_USE;
 604
 605         write_filter_data(prop_bag, &rgf);
 606
 607         /* write WaveInId */
 608         V_VT(&var) = VT_I4;
 609         V_I4(&var) = i;
 610         IPropertyBag_Write(prop_bag, L"WaveInId", &var);
 611
 612         VariantClear(&var);
 613         IPropertyBag_Release(prop_bag);
 614     }
 615 }
 616
 617 static void register_midiout_devices(void)
 618 {
 619     IPropertyBag *prop_bag = NULL;
 620     REGFILTERPINS2 rgpins = {0};
 621     REGPINTYPES rgtypes = {0};
 622     REGFILTER2 rgf = {0};
 623     MIDIOUTCAPSW caps;
 624     const WCHAR *name;
 625     int i, count;
 626     VARIANT var;
 627     HRESULT hr;
 628
 629     count = midiOutGetNumDevs();
 630
 631     for (i = -1; i < count; i++)
 632     {
 633         midiOutGetDevCapsW(i, &caps, sizeof(caps));
 634
 635         name = (i == -1) ? L"Default MidiOut Device" : caps.szPname;
 636
 637         hr = register_codec(&CLSID_MidiRendererCategory, name,
 638                 &CLSID_AVIMIDIRender, name, &prop_bag);
 639         if (FAILED(hr))
 640             continue;
 641
 642         /* write filter data */
 643         rgf.dwVersion = 2;
 644         rgf.dwMerit = (i == -1) ? MERIT_PREFERRED : MERIT_DO_NOT_USE;
 645         rgf.cPins2 = 1;
 646         rgf.rgPins2 = &rgpins;
 647         rgpins.dwFlags = REG_PINFLAG_B_RENDERER;
 648         rgpins.nMediaTypes = 1;
 649         rgpins.lpMediaType = &rgtypes;
 650         rgtypes.clsMajorType = &MEDIATYPE_Midi;
 651         rgtypes.clsMinorType = &MEDIASUBTYPE_NULL;
 652
 653         write_filter_data(prop_bag, &rgf);
 654
 655         /* write MidiOutId */
 656         V_VT(&var) = VT_I4;
 657         V_I4(&var) = i;
 658         IPropertyBag_Write(prop_bag, L"MidiOutId", &var);
 659
 660         VariantClear(&var);
 661         IPropertyBag_Release(prop_bag);
 662     }
 663 }
 664
 665 static void register_vfw_codecs(void)
 666 {
 667     REGFILTERPINS2 rgpins[2] = {};
 668     IPropertyBag *prop_bag = NULL;
 669     REGPINTYPES rgtypes[2];
 670     REGFILTER2 rgf;
 671     GUID typeguid;
 672     ICINFO info;
 673     VARIANT var;
 674     HRESULT hr;
 675     int i = 0;
 676     HIC hic;
 677
 678     while (ICInfo(ICTYPE_VIDEO, i++, &info))
 679     {
 680         WCHAR name[5] = {LOBYTE(LOWORD(info.fccHandler)), HIBYTE(LOWORD(info.fccHandler)),
 681                          LOBYTE(HIWORD(info.fccHandler)), HIBYTE(HIWORD(info.fccHandler))};
 682
 683         hic = ICOpen(ICTYPE_VIDEO, info.fccHandler, ICMODE_QUERY);
 684         ICGetInfo(hic, &info, sizeof(info));
 685         ICClose(hic);
 686
 687         hr = register_codec(&CLSID_VideoCompressorCategory, name,
 688                 &CLSID_AVICo, info.szDescription, &prop_bag);
 689         if (FAILED(hr))
 690             continue;
 691
 692         /* write filter data */
 693         rgf.dwVersion = 2;
 694         rgf.dwMerit = MERIT_DO_NOT_USE;
 695         rgf.cPins2 = 2;
 696         rgf.rgPins2 = rgpins;
 697         rgpins[0].dwFlags = 0;
 698         rgpins[0].nMediaTypes = 1;
 699         rgpins[0].lpMediaType = &rgtypes[0];
 700         rgtypes[0].clsMajorType = &MEDIATYPE_Video;
 701         typeguid = MEDIASUBTYPE_PCM;
 702         typeguid.Data1 = info.fccHandler;
 703         rgtypes[0].clsMinorType = &typeguid;
 704         rgpins[1].dwFlags = REG_PINFLAG_B_OUTPUT;
 705         rgpins[1].nMediaTypes = 1;
 706         rgpins[1].lpMediaType = &rgtypes[1];
 707         rgtypes[1].clsMajorType = &MEDIATYPE_Video;
 708         rgtypes[1].clsMinorType = &GUID_NULL;
 709
 710         write_filter_data(prop_bag, &rgf);
 711
 712         /* write WaveInId */
 713         V_VT(&var) = VT_BSTR;
 714         V_BSTR(&var) = SysAllocString(name);
 715         IPropertyBag_Write(prop_bag, L"FccHandler", &var);
 716
 717         VariantClear(&var);
 718         IPropertyBag_Release(prop_bag);
 719     }
 720 }
 721
 722 static void register_avicap_devices(void)
 723 {
 724     WCHAR friendlyname[32], version[32];
 725     IPropertyBag *prop_bag = NULL;
 726     REGFILTERPINS2 rgpins = {0};
 727     REGPINTYPES rgtypes;
 728     REGFILTER2 rgf;
 729     WCHAR name[7];
 730     VARIANT var;
 731     HRESULT hr;
 732     int i = 0;
 733
 734     for (i = 0; i < 10; ++i)
 735     {
 736         if (!capGetDriverDescriptionW(i, friendlyname, ARRAY_SIZE(friendlyname),
 737                 version, ARRAY_SIZE(version)))
 738             continue;
 739
 740         swprintf(name, ARRAY_SIZE(name), L"video%d", i);
 741
 742         hr = register_codec(&CLSID_VideoInputDeviceCategory, name,
 743                 &CLSID_VfwCapture, friendlyname, &prop_bag);
 744         if (FAILED(hr))
 745             continue;
 746
 747         rgf.dwVersion = 2;
 748         rgf.dwMerit = MERIT_DO_NOT_USE;
 749         rgf.cPins2 = 1;
 750         rgf.rgPins2 = &rgpins;
 751         rgpins.dwFlags = 0;
 752         rgpins.nMediaTypes = 1;
 753         rgpins.lpMediaType = &rgtypes;
 754         rgtypes.clsMajorType = &MEDIATYPE_Video;
 755         rgtypes.clsMinorType = &MEDIASUBTYPE_None;
 756
 757         write_filter_data(prop_bag, &rgf);
 758
 759         /* write VFWIndex */
 760         V_VT(&var) = VT_I4;
 761         V_I4(&var) = i;
 762         IPropertyBag_Write(prop_bag, L"VFWIndex", &var);
 763
 764         VariantClear(&var);
 765         IPropertyBag_Release(prop_bag);
 766     }
 767 }
 768
 769 static HRESULT WINAPI devenum_factory_CreateClassEnumerator(ICreateDevEnum *iface,
 770         REFCLSID class, IEnumMoniker **out, DWORD flags)
 771 {
 772     WCHAR guidstr[CHARS_IN_GUID];
 773     HRESULT hr;
 774     HKEY key;
 775
 776     TRACE("iface %p, class %s, out %p, flags %#x.\n", iface, debugstr_guid(class), out, flags);
 777
 778     if (!out)
 779         return E_POINTER;
 780
 781     *out = NULL;
 782
 783     if (!RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\Microsoft\\ActiveMovie\\devenum", &key))
 784     {
 785         StringFromGUID2(class, guidstr, ARRAY_SIZE(guidstr));
 786         RegDeleteTreeW(key, guidstr);
 787     }
 788
 789     if (IsEqualGUID(class, &CLSID_LegacyAmFilterCategory))
 790         register_legacy_filters();
 791     else if (IsEqualGUID(class, &CLSID_AudioRendererCategory))
 792     {
 793         hr = DirectSoundEnumerateW(&register_dsound_devices, NULL);
 794         if (FAILED(hr)) return hr;
 795         register_waveout_devices();
 796         register_midiout_devices();
 797     }
 798     else if (IsEqualGUID(class, &CLSID_AudioInputDeviceCategory))
 799         register_wavein_devices();
 800     else if (IsEqualGUID(class, &CLSID_VideoCompressorCategory))
 801         register_vfw_codecs();
 802     else if (IsEqualGUID(class, &CLSID_VideoInputDeviceCategory))
 803         register_avicap_devices();
 804
 805     if (SUCCEEDED(hr = enum_moniker_create(class, out)))
 806     {
 807         IMoniker *mon;
 808         hr = IEnumMoniker_Next(*out, 1, &mon, NULL);
 809         if (hr == S_OK)
 810         {
 811             IMoniker_Release(mon);
 812             IEnumMoniker_Reset(*out);
 813         }
 814         else
 815         {
 816             IEnumMoniker_Release(*out);
 817             *out = NULL;
 818         }
 819     }
 820
 821     return hr;
 822 }
 823
 824 /**********************************************************************
 825  * ICreateDevEnum_Vtbl
 826  */
 827 static const ICreateDevEnumVtbl ICreateDevEnum_Vtbl =
 828 {
 829     devenum_factory_QueryInterface,
 830     devenum_factory_AddRef,
 831     devenum_factory_Release,
 832     devenum_factory_CreateClassEnumerator,
 833 };
 834
 835 /**********************************************************************
 836  * static CreateDevEnum instance
 837  */
 838 ICreateDevEnum devenum_factory = { &ICreateDevEnum_Vtbl };