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->u.s2.cPins2 = 0;
 241     rgf2->u.s2.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->u.s2.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->u.s2.cPins2;
 310         continue;
 311
 312         error_cleanup:
 313
 314         RegCloseKey(hkeyPinKey);
 315     }
 316
 317     RegCloseKey(hkeyPins);
 318
 319     if (rgPins && !rgf2->u.s2.cPins2)
 320     {
 321         CoTaskMemFree(rgPins);
 322         rgPins = NULL;
 323     }
 324
 325     rgf2->u.s2.rgPins2 = rgPins;
 326 }
 327
 328 static void free_regfilter2(REGFILTER2 *rgf)
 329 {
 330     if (rgf->u.s2.rgPins2)
 331     {
 332         UINT iPin;
 333
 334         for (iPin = 0; iPin < rgf->u.s2.cPins2; iPin++)
 335         {
 336             if (rgf->u.s2.rgPins2[iPin].lpMediaType)
 337             {
 338                 UINT iType;
 339
 340                 for (iType = 0; iType < rgf->u.s2.rgPins2[iPin].nMediaTypes; iType++)
 341                 {
 342                     CoTaskMemFree((void *)rgf->u.s2.rgPins2[iPin].lpMediaType[iType].clsMajorType);
 343                     CoTaskMemFree((void *)rgf->u.s2.rgPins2[iPin].lpMediaType[iType].clsMinorType);
 344                 }
 345
 346                 CoTaskMemFree((void *)rgf->u.s2.rgPins2[iPin].lpMediaType);
 347             }
 348         }
 349
 350         CoTaskMemFree((void *)rgf->u.s2.rgPins2);
 351     }
 352 }
 353
 354 static void write_filter_data(IPropertyBag *prop_bag, REGFILTER2 *rgf)
 355 {
 356     BYTE *data = NULL, *array;
 357     IAMFilterData *fildata;
 358     SAFEARRAYBOUND sabound;
 359     VARIANT var = {};
 360     ULONG size;
 361     HRESULT hr;
 362
 363     hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC, &IID_IAMFilterData, (void **)&fildata);
 364     if (FAILED(hr)) goto cleanup;
 365
 366     hr = IAMFilterData_CreateFilterData(fildata, rgf, &data, &size);
 367     if (FAILED(hr)) goto cleanup;
 368
 369     V_VT(&var) = VT_ARRAY | VT_UI1;
 370     sabound.lLbound = 0;
 371     sabound.cElements = size;
 372     if (!(V_ARRAY(&var) = SafeArrayCreate(VT_UI1, 1, &sabound)))
 373         goto cleanup;
 374     hr = SafeArrayAccessData(V_ARRAY(&var), (void *)&array);
 375     if (FAILED(hr)) goto cleanup;
 376
 377     memcpy(array, data, size);
 378     hr = SafeArrayUnaccessData(V_ARRAY(&var));
 379     if (FAILED(hr)) goto cleanup;
 380
 381     hr = IPropertyBag_Write(prop_bag, L"FilterData", &var);
 382     if (FAILED(hr)) goto cleanup;
 383
 384 cleanup:
 385     VariantClear(&var);
 386     CoTaskMemFree(data);
 387     IAMFilterData_Release(fildata);
 388 }
 389
 390 static void register_legacy_filters(void)
 391 {
 392     HKEY hkeyFilter = NULL;
 393     DWORD dwFilterSubkeys, i;
 394     LONG lRet;
 395     HRESULT hr;
 396
 397     lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Filter", 0, KEY_READ, &hkeyFilter);
 398     hr = HRESULT_FROM_WIN32(lRet);
 399
 400     if (SUCCEEDED(hr))
 401     {
 402         lRet = RegQueryInfoKeyW(hkeyFilter, NULL, NULL, NULL, &dwFilterSubkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 403         hr = HRESULT_FROM_WIN32(lRet);
 404     }
 405
 406     if (SUCCEEDED(hr))
 407     {
 408         for (i = 0; i < dwFilterSubkeys; i++)
 409         {
 410             WCHAR wszFilterSubkeyName[64];
 411             DWORD cName = ARRAY_SIZE(wszFilterSubkeyName);
 412             IPropertyBag *prop_bag = NULL;
 413             WCHAR wszRegKey[MAX_PATH];
 414             HKEY classkey = NULL;
 415             REGFILTER2 rgf2;
 416             DWORD Type, len;
 417             GUID clsid;
 418
 419             if (RegEnumKeyExW(hkeyFilter, i, wszFilterSubkeyName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 420
 421             TRACE("Registering %s\n", debugstr_w(wszFilterSubkeyName));
 422
 423             hr = CLSIDFromString(wszFilterSubkeyName, &clsid);
 424             if (FAILED(hr))
 425                 continue;
 426
 427             swprintf(wszRegKey, ARRAY_SIZE(wszRegKey), L"CLSID\\%s", wszFilterSubkeyName);
 428             if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszRegKey, 0, KEY_READ, &classkey) != ERROR_SUCCESS)
 429                 continue;
 430
 431             len = 0;
 432             if (!RegQueryValueExW(classkey, NULL, NULL, &Type, NULL, &len))
 433             {
 434                 WCHAR *friendlyname = heap_alloc(len);
 435                 if (!friendlyname)
 436                 {
 437                     RegCloseKey(classkey);
 438                     continue;
 439                 }
 440                 RegQueryValueExW(classkey, NULL, NULL, &Type, (BYTE *)friendlyname, &len);
 441
 442                 hr = register_codec(&CLSID_LegacyAmFilterCategory, wszFilterSubkeyName,
 443                         &clsid, friendlyname, &prop_bag);
 444
 445                 heap_free(friendlyname);
 446             }
 447             else
 448                 hr = register_codec(&CLSID_LegacyAmFilterCategory, wszFilterSubkeyName,
 449                         &clsid, wszFilterSubkeyName, &prop_bag);
 450             if (FAILED(hr))
 451             {
 452                 RegCloseKey(classkey);
 453                 continue;
 454             }
 455
 456             /* write filter data */
 457             rgf2.dwMerit = MERIT_NORMAL;
 458
 459             len = sizeof(rgf2.dwMerit);
 460             RegQueryValueExW(classkey, L"Merit", NULL, &Type, (BYTE *)&rgf2.dwMerit, &len);
 461
 462             DEVENUM_ReadPins(classkey, &rgf2);
 463
 464             write_filter_data(prop_bag, &rgf2);
 465
 466             IPropertyBag_Release(prop_bag);
 467             RegCloseKey(classkey);
 468             free_regfilter2(&rgf2);
 469         }
 470     }
 471
 472     if (hkeyFilter) RegCloseKey(hkeyFilter);
 473 }
 474
 475 static BOOL CALLBACK register_dsound_devices(GUID *guid, const WCHAR *desc, const WCHAR *module, void *context)
 476 {
 477     static const WCHAR defaultW[] = L"Default DirectSound Device";
 478     IPropertyBag *prop_bag = NULL;
 479     REGFILTERPINS2 rgpins = {0};
 480     REGPINTYPES rgtypes = {0};
 481     REGFILTER2 rgf = {0};
 482     WCHAR clsid[CHARS_IN_GUID];
 483     VARIANT var;
 484     HRESULT hr;
 485
 486     if (guid)
 487     {
 488         WCHAR *name = heap_alloc(sizeof(defaultW) + wcslen(desc) * sizeof(WCHAR));
 489         if (!name)
 490             return FALSE;
 491         wcscpy(name, L"DirectSound: ");
 492         wcscat(name, desc);
 493
 494         hr = register_codec(&CLSID_AudioRendererCategory, name,
 495                 &CLSID_DSoundRender, name, &prop_bag);
 496         heap_free(name);
 497     }
 498     else
 499         hr = register_codec(&CLSID_AudioRendererCategory, defaultW,
 500                 &CLSID_DSoundRender, defaultW, &prop_bag);
 501     if (FAILED(hr))
 502         return FALSE;
 503
 504     /* write filter data */
 505     rgf.dwVersion = 2;
 506     rgf.dwMerit = guid ? MERIT_DO_NOT_USE : MERIT_PREFERRED;
 507     rgf.u.s2.cPins2 = 1;
 508     rgf.u.s2.rgPins2 = &rgpins;
 509     rgpins.dwFlags = REG_PINFLAG_B_RENDERER;
 510     /* FIXME: native registers many more formats */
 511     rgpins.nMediaTypes = 1;
 512     rgpins.lpMediaType = &rgtypes;
 513     rgtypes.clsMajorType = &MEDIATYPE_Audio;
 514     rgtypes.clsMinorType = &MEDIASUBTYPE_PCM;
 515
 516     write_filter_data(prop_bag, &rgf);
 517
 518     /* write DSound guid */
 519     V_VT(&var) = VT_BSTR;
 520     StringFromGUID2(guid ? guid : &GUID_NULL, clsid, CHARS_IN_GUID);
 521     if ((V_BSTR(&var) = SysAllocString(clsid)))
 522         hr = IPropertyBag_Write(prop_bag, L"DSGuid", &var);
 523
 524     VariantClear(&var);
 525     IPropertyBag_Release(prop_bag);
 526     return TRUE;
 527 }
 528
 529 static void register_waveout_devices(void)
 530 {
 531     IPropertyBag *prop_bag = NULL;
 532     REGFILTERPINS2 rgpins = {0};
 533     REGPINTYPES rgtypes = {0};
 534     REGFILTER2 rgf = {0};
 535     WAVEOUTCAPSW caps;
 536     const WCHAR *name;
 537     int i, count;
 538     VARIANT var;
 539     HRESULT hr;
 540
 541     count = waveOutGetNumDevs();
 542
 543     for (i = -1; i < count; i++)
 544     {
 545         waveOutGetDevCapsW(i, &caps, sizeof(caps));
 546
 547         name = (i == -1) ? L"Default WaveOut Device" : caps.szPname;
 548
 549         hr = register_codec(&CLSID_AudioRendererCategory, name,
 550                 &CLSID_AudioRender, name, &prop_bag);
 551         if (FAILED(hr))
 552             continue;
 553
 554         /* write filter data */
 555         rgf.dwVersion = 2;
 556         rgf.dwMerit = MERIT_DO_NOT_USE;
 557         rgf.u.s2.cPins2 = 1;
 558         rgf.u.s2.rgPins2 = &rgpins;
 559         rgpins.dwFlags = REG_PINFLAG_B_RENDERER;
 560         rgpins.nMediaTypes = 1;
 561         rgpins.lpMediaType = &rgtypes;
 562         rgtypes.clsMajorType = &MEDIATYPE_Audio;
 563         rgtypes.clsMinorType = &MEDIASUBTYPE_NULL;
 564
 565         write_filter_data(prop_bag, &rgf);
 566
 567         /* write WaveOutId */
 568         V_VT(&var) = VT_I4;
 569         V_I4(&var) = i;
 570         IPropertyBag_Write(prop_bag, L"WaveOutId", &var);
 571
 572         VariantClear(&var);
 573         if (prop_bag) IPropertyBag_Release(prop_bag);
 574     }
 575 }
 576
 577 static void register_wavein_devices(void)
 578 {
 579     IPropertyBag *prop_bag = NULL;
 580     REGFILTER2 rgf = {0};
 581     WAVEINCAPSW caps;
 582     int i, count;
 583     VARIANT var;
 584     HRESULT hr;
 585
 586     count = waveInGetNumDevs();
 587
 588     for (i = 0; i < count; i++)
 589     {
 590         waveInGetDevCapsW(i, &caps, sizeof(caps));
 591
 592         hr = register_codec(&CLSID_AudioInputDeviceCategory, caps.szPname,
 593                 &CLSID_AudioRecord, caps.szPname, &prop_bag);
 594         if (FAILED(hr))
 595             continue;
 596
 597         /* write filter data */
 598         rgf.dwVersion = 2;
 599         rgf.dwMerit = MERIT_DO_NOT_USE;
 600
 601         write_filter_data(prop_bag, &rgf);
 602
 603         /* write WaveInId */
 604         V_VT(&var) = VT_I4;
 605         V_I4(&var) = i;
 606         IPropertyBag_Write(prop_bag, L"WaveInId", &var);
 607
 608         VariantClear(&var);
 609         IPropertyBag_Release(prop_bag);
 610     }
 611 }
 612
 613 static void register_midiout_devices(void)
 614 {
 615     IPropertyBag *prop_bag = NULL;
 616     REGFILTERPINS2 rgpins = {0};
 617     REGPINTYPES rgtypes = {0};
 618     REGFILTER2 rgf = {0};
 619     MIDIOUTCAPSW caps;
 620     const WCHAR *name;
 621     int i, count;
 622     VARIANT var;
 623     HRESULT hr;
 624
 625     count = midiOutGetNumDevs();
 626
 627     for (i = -1; i < count; i++)
 628     {
 629         midiOutGetDevCapsW(i, &caps, sizeof(caps));
 630
 631         name = (i == -1) ? L"Default MidiOut Device" : caps.szPname;
 632
 633         hr = register_codec(&CLSID_MidiRendererCategory, name,
 634                 &CLSID_AVIMIDIRender, name, &prop_bag);
 635         if (FAILED(hr))
 636             continue;
 637
 638         /* write filter data */
 639         rgf.dwVersion = 2;
 640         rgf.dwMerit = (i == -1) ? MERIT_PREFERRED : MERIT_DO_NOT_USE;
 641         rgf.u.s2.cPins2 = 1;
 642         rgf.u.s2.rgPins2 = &rgpins;
 643         rgpins.dwFlags = REG_PINFLAG_B_RENDERER;
 644         rgpins.nMediaTypes = 1;
 645         rgpins.lpMediaType = &rgtypes;
 646         rgtypes.clsMajorType = &MEDIATYPE_Midi;
 647         rgtypes.clsMinorType = &MEDIASUBTYPE_NULL;
 648
 649         write_filter_data(prop_bag, &rgf);
 650
 651         /* write MidiOutId */
 652         V_VT(&var) = VT_I4;
 653         V_I4(&var) = i;
 654         IPropertyBag_Write(prop_bag, L"MidiOutId", &var);
 655
 656         VariantClear(&var);
 657         IPropertyBag_Release(prop_bag);
 658     }
 659 }
 660
 661 static void register_vfw_codecs(void)
 662 {
 663     REGFILTERPINS2 rgpins[2] = {};
 664     IPropertyBag *prop_bag = NULL;
 665     REGPINTYPES rgtypes[2];
 666     REGFILTER2 rgf;
 667     GUID typeguid;
 668     ICINFO info;
 669     VARIANT var;
 670     HRESULT hr;
 671     int i = 0;
 672     HIC hic;
 673
 674     while (ICInfo(ICTYPE_VIDEO, i++, &info))
 675     {
 676         WCHAR name[5] = {LOBYTE(LOWORD(info.fccHandler)), HIBYTE(LOWORD(info.fccHandler)),
 677                          LOBYTE(HIWORD(info.fccHandler)), HIBYTE(HIWORD(info.fccHandler))};
 678
 679         hic = ICOpen(ICTYPE_VIDEO, info.fccHandler, ICMODE_QUERY);
 680         ICGetInfo(hic, &info, sizeof(info));
 681         ICClose(hic);
 682
 683         hr = register_codec(&CLSID_VideoCompressorCategory, name,
 684                 &CLSID_AVICo, info.szDescription, &prop_bag);
 685         if (FAILED(hr))
 686             continue;
 687
 688         /* write filter data */
 689         rgf.dwVersion = 2;
 690         rgf.dwMerit = MERIT_DO_NOT_USE;
 691         rgf.u.s2.cPins2 = 2;
 692         rgf.u.s2.rgPins2 = rgpins;
 693         rgpins[0].dwFlags = 0;
 694         rgpins[0].nMediaTypes = 1;
 695         rgpins[0].lpMediaType = &rgtypes[0];
 696         rgtypes[0].clsMajorType = &MEDIATYPE_Video;
 697         typeguid = MEDIASUBTYPE_PCM;
 698         typeguid.Data1 = info.fccHandler;
 699         rgtypes[0].clsMinorType = &typeguid;
 700         rgpins[1].dwFlags = REG_PINFLAG_B_OUTPUT;
 701         rgpins[1].nMediaTypes = 1;
 702         rgpins[1].lpMediaType = &rgtypes[1];
 703         rgtypes[1].clsMajorType = &MEDIATYPE_Video;
 704         rgtypes[1].clsMinorType = &GUID_NULL;
 705
 706         write_filter_data(prop_bag, &rgf);
 707
 708         /* write WaveInId */
 709         V_VT(&var) = VT_BSTR;
 710         V_BSTR(&var) = SysAllocString(name);
 711         IPropertyBag_Write(prop_bag, L"FccHandler", &var);
 712
 713         VariantClear(&var);
 714         IPropertyBag_Release(prop_bag);
 715     }
 716 }
 717
 718 static void register_avicap_devices(void)
 719 {
 720     WCHAR friendlyname[32], version[32];
 721     IPropertyBag *prop_bag = NULL;
 722     REGFILTERPINS2 rgpins = {0};
 723     REGPINTYPES rgtypes;
 724     REGFILTER2 rgf;
 725     WCHAR name[6];
 726     VARIANT var;
 727     HRESULT hr;
 728     int i = 0;
 729
 730     for (i = 0; i < 10; ++i)
 731     {
 732         if (!capGetDriverDescriptionW(i, friendlyname, ARRAY_SIZE(friendlyname),
 733                 version, ARRAY_SIZE(version)))
 734             continue;
 735
 736         swprintf(name, ARRAY_SIZE(name), L"video%d", i);
 737
 738         hr = register_codec(&CLSID_VideoInputDeviceCategory, name,
 739                 &CLSID_VfwCapture, friendlyname, &prop_bag);
 740         if (FAILED(hr))
 741             continue;
 742
 743         rgf.dwVersion = 2;
 744         rgf.dwMerit = MERIT_DO_NOT_USE;
 745         rgf.u.s2.cPins2 = 1;
 746         rgf.u.s2.rgPins2 = &rgpins;
 747         rgpins.dwFlags = 0;
 748         rgpins.nMediaTypes = 1;
 749         rgpins.lpMediaType = &rgtypes;
 750         rgtypes.clsMajorType = &MEDIATYPE_Video;
 751         rgtypes.clsMinorType = &MEDIASUBTYPE_None;
 752
 753         write_filter_data(prop_bag, &rgf);
 754
 755         /* write VFWIndex */
 756         V_VT(&var) = VT_I4;
 757         V_I4(&var) = i;
 758         IPropertyBag_Write(prop_bag, L"VFWIndex", &var);
 759
 760         VariantClear(&var);
 761         IPropertyBag_Release(prop_bag);
 762     }
 763 }
 764
 765 static HRESULT WINAPI devenum_factory_CreateClassEnumerator(ICreateDevEnum *iface,
 766         REFCLSID class, IEnumMoniker **out, DWORD flags)
 767 {
 768     WCHAR guidstr[CHARS_IN_GUID];
 769     HRESULT hr;
 770     HKEY key;
 771
 772     TRACE("iface %p, class %s, out %p, flags %#x.\n", iface, debugstr_guid(class), out, flags);
 773
 774     if (!out)
 775         return E_POINTER;
 776
 777     *out = NULL;
 778
 779     if (!RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\Microsoft\\ActiveMovie\\devenum", &key))
 780     {
 781         StringFromGUID2(class, guidstr, ARRAY_SIZE(guidstr));
 782         RegDeleteTreeW(key, guidstr);
 783     }
 784
 785     if (IsEqualGUID(class, &CLSID_LegacyAmFilterCategory))
 786         register_legacy_filters();
 787     else if (IsEqualGUID(class, &CLSID_AudioRendererCategory))
 788     {
 789         hr = DirectSoundEnumerateW(&register_dsound_devices, NULL);
 790         if (FAILED(hr)) return hr;
 791         register_waveout_devices();
 792         register_midiout_devices();
 793     }
 794     else if (IsEqualGUID(class, &CLSID_AudioInputDeviceCategory))
 795         register_wavein_devices();
 796     else if (IsEqualGUID(class, &CLSID_VideoCompressorCategory))
 797         register_vfw_codecs();
 798     else if (IsEqualGUID(class, &CLSID_VideoInputDeviceCategory))
 799         register_avicap_devices();
 800
 801     if (SUCCEEDED(hr = enum_moniker_create(class, out)))
 802     {
 803         IMoniker *mon;
 804         hr = IEnumMoniker_Next(*out, 1, &mon, NULL);
 805         if (hr == S_OK)
 806         {
 807             IMoniker_Release(mon);
 808             IEnumMoniker_Reset(*out);
 809         }
 810         else
 811         {
 812             IEnumMoniker_Release(*out);
 813             *out = NULL;
 814         }
 815     }
 816
 817     return hr;
 818 }
 819
 820 /**********************************************************************
 821  * ICreateDevEnum_Vtbl
 822  */
 823 static const ICreateDevEnumVtbl ICreateDevEnum_Vtbl =
 824 {
 825     devenum_factory_QueryInterface,
 826     devenum_factory_AddRef,
 827     devenum_factory_Release,
 828     devenum_factory_CreateClassEnumerator,
 829 };
 830
 831 /**********************************************************************
 832  * static CreateDevEnum instance
 833  */
 834 ICreateDevEnum devenum_factory = { &ICreateDevEnum_Vtbl };