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