reactos/dll/directx/wine/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
  32 #include <wine/debug.h>
  33 //#include "wine/unicode.h"
  34 //#include "mmddk.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(devenum);
  37
  38 extern HINSTANCE DEVENUM_hInstance;
  39
  40 const WCHAR wszInstanceKeyName[] ={'I','n','s','t','a','n','c','e',0};
  41
  42 static const WCHAR wszRegSeparator[] =   {'\\', 0 };
  43 static const WCHAR wszActiveMovieKey[] = {'S','o','f','t','w','a','r','e','\\',
  44                                    'M','i','c','r','o','s','o','f','t','\\',
  45                                    'A','c','t','i','v','e','M','o','v','i','e','\\',
  46                                    'd','e','v','e','n','u','m','\\',0};
  47 static const WCHAR wszFilterKeyName[] = {'F','i','l','t','e','r',0};
  48 static const WCHAR wszMeritName[] = {'M','e','r','i','t',0};
  49 static const WCHAR wszPins[] = {'P','i','n','s',0};
  50 static const WCHAR wszAllowedMany[] = {'A','l','l','o','w','e','d','M','a','n','y',0};
  51 static const WCHAR wszAllowedZero[] = {'A','l','l','o','w','e','d','Z','e','r','o',0};
  52 static const WCHAR wszDirection[] = {'D','i','r','e','c','t','i','o','n',0};
  53 static const WCHAR wszIsRendered[] = {'I','s','R','e','n','d','e','r','e','d',0};
  54 static const WCHAR wszTypes[] = {'T','y','p','e','s',0};
  55
  56 static ULONG WINAPI DEVENUM_ICreateDevEnum_AddRef(ICreateDevEnum * iface);
  57 static HRESULT DEVENUM_CreateSpecialCategories(void);
  58
  59 /**********************************************************************
  60  * DEVENUM_ICreateDevEnum_QueryInterface (also IUnknown)
  61  */
  62 static HRESULT WINAPI DEVENUM_ICreateDevEnum_QueryInterface(
  63     ICreateDevEnum * iface,
  64     REFIID riid,
  65     LPVOID *ppvObj)
  66 {
  67     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
  68
  69     if (ppvObj == NULL) return E_POINTER;
  70
  71     if (IsEqualGUID(riid, &IID_IUnknown) ||
  72         IsEqualGUID(riid, &IID_ICreateDevEnum))
  73     {
  74         *ppvObj = iface;
  75         DEVENUM_ICreateDevEnum_AddRef(iface);
  76         return S_OK;
  77     }
  78
  79     FIXME("- no interface IID: %s\n", debugstr_guid(riid));
  80     return E_NOINTERFACE;
  81 }
  82
  83 /**********************************************************************
  84  * DEVENUM_ICreateDevEnum_AddRef (also IUnknown)
  85  */
  86 static ULONG WINAPI DEVENUM_ICreateDevEnum_AddRef(ICreateDevEnum * iface)
  87 {
  88     TRACE("\n");
  89
  90     DEVENUM_LockModule();
  91
  92     return 2; /* non-heap based object */
  93 }
  94
  95 /**********************************************************************
  96  * DEVENUM_ICreateDevEnum_Release (also IUnknown)
  97  */
  98 static ULONG WINAPI DEVENUM_ICreateDevEnum_Release(ICreateDevEnum * iface)
  99 {
 100     TRACE("\n");
 101
 102     DEVENUM_UnlockModule();
 103
 104     return 1; /* non-heap based object */
 105 }
 106
 107 HRESULT DEVENUM_GetCategoryKey(REFCLSID clsidDeviceClass, HKEY *pBaseKey, WCHAR *wszRegKeyName, UINT maxLen)
 108 {
 109     if (IsEqualGUID(clsidDeviceClass, &CLSID_AudioRendererCategory) ||
 110         IsEqualGUID(clsidDeviceClass, &CLSID_AudioInputDeviceCategory) ||
 111         IsEqualGUID(clsidDeviceClass, &CLSID_VideoInputDeviceCategory) ||
 112         IsEqualGUID(clsidDeviceClass, &CLSID_MidiRendererCategory))
 113     {
 114         *pBaseKey = HKEY_CURRENT_USER;
 115         strcpyW(wszRegKeyName, wszActiveMovieKey);
 116
 117         if (!StringFromGUID2(clsidDeviceClass, wszRegKeyName + strlenW(wszRegKeyName), maxLen - strlenW(wszRegKeyName)))
 118             return E_OUTOFMEMORY;
 119     }
 120     else
 121     {
 122         *pBaseKey = HKEY_CLASSES_ROOT;
 123         strcpyW(wszRegKeyName, clsid_keyname);
 124         strcatW(wszRegKeyName, wszRegSeparator);
 125
 126         if (!StringFromGUID2(clsidDeviceClass, wszRegKeyName + CLSID_STR_LEN, maxLen - CLSID_STR_LEN))
 127             return E_OUTOFMEMORY;
 128
 129         strcatW(wszRegKeyName, wszRegSeparator);
 130         strcatW(wszRegKeyName, wszInstanceKeyName);
 131     }
 132
 133     return S_OK;
 134 }
 135
 136 static void DEVENUM_ReadPinTypes(HKEY hkeyPinKey, REGFILTERPINS *rgPin)
 137 {
 138     HKEY hkeyTypes = NULL;
 139     DWORD dwMajorTypes, i;
 140     REGPINTYPES *lpMediaType = NULL;
 141     DWORD dwMediaTypeSize = 0;
 142
 143     if (RegOpenKeyExW(hkeyPinKey, wszTypes, 0, KEY_READ, &hkeyTypes) != ERROR_SUCCESS)
 144         return ;
 145
 146     if (RegQueryInfoKeyW(hkeyTypes, NULL, NULL, NULL, &dwMajorTypes, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 147                 != ERROR_SUCCESS)
 148     {
 149         RegCloseKey(hkeyTypes);
 150         return ;
 151     }
 152
 153     for (i = 0; i < dwMajorTypes; i++)
 154     {
 155         HKEY hkeyMajorType = NULL;
 156         WCHAR wszMajorTypeName[64];
 157         DWORD cName = sizeof(wszMajorTypeName) / sizeof(WCHAR);
 158         DWORD dwMinorTypes, i1;
 159
 160         if (RegEnumKeyExW(hkeyTypes, i, wszMajorTypeName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 161
 162         if (RegOpenKeyExW(hkeyTypes, wszMajorTypeName, 0, KEY_READ, &hkeyMajorType) != ERROR_SUCCESS) continue;
 163
 164         if (RegQueryInfoKeyW(hkeyMajorType, NULL, NULL, NULL, &dwMinorTypes, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
 165                     != ERROR_SUCCESS)
 166         {
 167             RegCloseKey(hkeyMajorType);
 168             continue;
 169         }
 170
 171         for (i1 = 0; i1 < dwMinorTypes; i1++)
 172         {
 173             WCHAR wszMinorTypeName[64];
 174             DWORD cName = sizeof(wszMinorTypeName) / sizeof(WCHAR);
 175             CLSID *clsMajorType = NULL, *clsMinorType = NULL;
 176             HRESULT hr;
 177
 178             if (RegEnumKeyExW(hkeyMajorType, i1, wszMinorTypeName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 179
 180             clsMinorType = CoTaskMemAlloc(sizeof(CLSID));
 181             if (!clsMinorType) continue;
 182
 183             clsMajorType = CoTaskMemAlloc(sizeof(CLSID));
 184             if (!clsMajorType) goto error_cleanup_types;
 185
 186             hr = CLSIDFromString(wszMinorTypeName, clsMinorType);
 187             if (FAILED(hr)) goto error_cleanup_types;
 188
 189             hr = CLSIDFromString(wszMajorTypeName, clsMajorType);
 190             if (FAILED(hr)) goto error_cleanup_types;
 191
 192             if (rgPin->nMediaTypes == dwMediaTypeSize)
 193             {
 194                 DWORD dwNewSize = dwMediaTypeSize + (dwMediaTypeSize < 2 ? 1 : dwMediaTypeSize / 2);
 195                 REGPINTYPES *lpNewMediaType;
 196
 197                 lpNewMediaType = CoTaskMemRealloc(lpMediaType, sizeof(REGPINTYPES) * dwNewSize);
 198                 if (!lpNewMediaType) goto error_cleanup_types;
 199
 200                 lpMediaType = lpNewMediaType;
 201                 dwMediaTypeSize = dwNewSize;
 202              }
 203
 204             lpMediaType[rgPin->nMediaTypes].clsMajorType = clsMajorType;
 205             lpMediaType[rgPin->nMediaTypes].clsMinorType = clsMinorType;
 206             rgPin->nMediaTypes++;
 207             continue;
 208
 209             error_cleanup_types:
 210
 211             if (clsMajorType) CoTaskMemFree(clsMajorType);
 212             if (clsMinorType) CoTaskMemFree(clsMinorType);
 213         }
 214
 215         RegCloseKey(hkeyMajorType);
 216     }
 217
 218     RegCloseKey(hkeyTypes);
 219
 220     if (lpMediaType && !rgPin->nMediaTypes)
 221     {
 222         CoTaskMemFree(lpMediaType);
 223         lpMediaType = NULL;
 224     }
 225
 226     rgPin->lpMediaType = lpMediaType;
 227 }
 228
 229 static void DEVENUM_ReadPins(HKEY hkeyFilterClass, REGFILTER2 *rgf2)
 230 {
 231     HKEY hkeyPins = NULL;
 232     DWORD dwPinsSubkeys, i;
 233     REGFILTERPINS *rgPins = NULL;
 234
 235     if (RegOpenKeyExW(hkeyFilterClass, wszPins, 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(REGFILTERPINS) * 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 = sizeof(wszPinName) / sizeof(WCHAR);
 260         DWORD Type, cbData;
 261         REGFILTERPINS *rgPin = &rgPins[rgf2->u.s1.cPins];
 262         LONG lRet;
 263
 264         rgPin->strName = NULL;
 265         rgPin->clsConnectsToFilter = &GUID_NULL;
 266         rgPin->strConnectsToPin = NULL;
 267         rgPin->nMediaTypes = 0;
 268         rgPin->lpMediaType = NULL;
 269
 270         if (RegEnumKeyExW(hkeyPins, i, wszPinName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 271
 272         if (RegOpenKeyExW(hkeyPins, wszPinName, 0, KEY_READ, &hkeyPinKey) != ERROR_SUCCESS) continue;
 273
 274         rgPin->strName = CoTaskMemAlloc((strlenW(wszPinName) + 1) * sizeof(WCHAR));
 275         if (!rgPin->strName) goto error_cleanup;
 276
 277         strcpyW(rgPin->strName, wszPinName);
 278
 279         cbData = sizeof(rgPin->bMany);
 280         lRet = RegQueryValueExW(hkeyPinKey, wszAllowedMany, NULL, &Type, (LPBYTE)&rgPin->bMany, &cbData);
 281         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 282             goto error_cleanup;
 283
 284         cbData = sizeof(rgPin->bZero);
 285         lRet = RegQueryValueExW(hkeyPinKey, wszAllowedZero, NULL, &Type, (LPBYTE)&rgPin->bZero, &cbData);
 286         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 287             goto error_cleanup;
 288
 289         cbData = sizeof(rgPin->bOutput);
 290         lRet = RegQueryValueExW(hkeyPinKey, wszDirection, NULL, &Type, (LPBYTE)&rgPin->bOutput, &cbData);
 291         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 292             goto error_cleanup;
 293
 294         cbData = sizeof(rgPin->bRendered);
 295         lRet = RegQueryValueExW(hkeyPinKey, wszIsRendered, NULL, &Type, (LPBYTE)&rgPin->bRendered, &cbData);
 296         if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
 297             goto error_cleanup;
 298
 299         DEVENUM_ReadPinTypes(hkeyPinKey, rgPin);
 300
 301         ++rgf2->u.s1.cPins;
 302         continue;
 303
 304         error_cleanup:
 305
 306         RegCloseKey(hkeyPinKey);
 307         if (rgPin->strName) CoTaskMemFree(rgPin->strName);
 308     }
 309
 310     RegCloseKey(hkeyPins);
 311
 312     if (rgPins && !rgf2->u.s1.cPins)
 313     {
 314         CoTaskMemFree(rgPins);
 315         rgPins = NULL;
 316     }
 317
 318     rgf2->u.s1.rgPins = rgPins;
 319 }
 320
 321 static HRESULT DEVENUM_RegisterLegacyAmFilters(void)
 322 {
 323     HKEY hkeyFilter = NULL;
 324     DWORD dwFilterSubkeys, i;
 325     LONG lRet;
 326     IFilterMapper2 *pMapper = NULL;
 327     HRESULT hr;
 328
 329     hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC,
 330                            &IID_IFilterMapper2, (void **) &pMapper);
 331     if (SUCCEEDED(hr))
 332     {
 333         lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszFilterKeyName, 0, KEY_READ, &hkeyFilter);
 334         hr = HRESULT_FROM_WIN32(lRet);
 335     }
 336
 337     if (SUCCEEDED(hr))
 338     {
 339         lRet = RegQueryInfoKeyW(hkeyFilter, NULL, NULL, NULL, &dwFilterSubkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 340         hr = HRESULT_FROM_WIN32(lRet);
 341     }
 342
 343     if (SUCCEEDED(hr))
 344     {
 345         for (i = 0; i < dwFilterSubkeys; i++)
 346         {
 347             WCHAR wszFilterSubkeyName[64];
 348             DWORD cName = sizeof(wszFilterSubkeyName) / sizeof(WCHAR);
 349             HKEY hkeyCategoryBaseKey;
 350             WCHAR wszRegKey[MAX_PATH];
 351             HKEY hkeyInstance = NULL;
 352             HRESULT hr;
 353
 354             if (RegEnumKeyExW(hkeyFilter, i, wszFilterSubkeyName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
 355
 356             hr = DEVENUM_GetCategoryKey(&CLSID_LegacyAmFilterCategory, &hkeyCategoryBaseKey, wszRegKey, MAX_PATH);
 357             if (FAILED(hr)) continue;
 358
 359             strcatW(wszRegKey, wszRegSeparator);
 360             strcatW(wszRegKey, wszFilterSubkeyName);
 361
 362             if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszRegKey, 0, KEY_READ, &hkeyInstance) == ERROR_SUCCESS)
 363             {
 364                 RegCloseKey(hkeyInstance);
 365             }
 366             else
 367             {
 368                 /* Filter is registered the IFilterMapper(1)-way in HKCR\Filter. Needs to be added to
 369                  * legacy am filter category. */
 370                 HKEY hkeyFilterClass = NULL;
 371                 REGFILTER2 rgf2;
 372                 CLSID clsidFilter;
 373                 WCHAR wszFilterName[MAX_PATH];
 374                 DWORD Type;
 375                 DWORD cbData;
 376                 HRESULT res;
 377                 IMoniker *pMoniker = NULL;
 378
 379                 TRACE("Registering %s\n", debugstr_w(wszFilterSubkeyName));
 380
 381                 strcpyW(wszRegKey, clsid_keyname);
 382                 strcatW(wszRegKey, wszRegSeparator);
 383                 strcatW(wszRegKey, wszFilterSubkeyName);
 384
 385                 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszRegKey, 0, KEY_READ, &hkeyFilterClass) != ERROR_SUCCESS)
 386                     continue;
 387
 388                 rgf2.dwVersion = 1;
 389                 rgf2.dwMerit = 0;
 390                 rgf2.u.s1.cPins = 0;
 391                 rgf2.u.s1.rgPins = NULL;
 392
 393                 cbData = sizeof(wszFilterName);
 394                 if (RegQueryValueExW(hkeyFilterClass, NULL, NULL, &Type, (LPBYTE)wszFilterName, &cbData) != ERROR_SUCCESS ||
 395                     Type != REG_SZ)
 396                     goto cleanup;
 397
 398                 cbData = sizeof(rgf2.dwMerit);
 399                 if (RegQueryValueExW(hkeyFilterClass, wszMeritName, NULL, &Type, (LPBYTE)&rgf2.dwMerit, &cbData) != ERROR_SUCCESS ||
 400                     Type != REG_DWORD)
 401                     goto cleanup;
 402
 403                 DEVENUM_ReadPins(hkeyFilterClass, &rgf2);
 404
 405                 res = CLSIDFromString(wszFilterSubkeyName, &clsidFilter);
 406                 if (FAILED(res)) goto cleanup;
 407
 408                 IFilterMapper2_RegisterFilter(pMapper, &clsidFilter, wszFilterName, &pMoniker, NULL, NULL, &rgf2);
 409
 410                 if (pMoniker)
 411                     IMoniker_Release(pMoniker);
 412
 413                 cleanup:
 414
 415                 if (hkeyFilterClass) RegCloseKey(hkeyFilterClass);
 416
 417                 if (rgf2.u.s1.rgPins)
 418                 {
 419                     UINT iPin;
 420
 421                     for (iPin = 0; iPin < rgf2.u.s1.cPins; iPin++)
 422                     {
 423                         CoTaskMemFree(rgf2.u.s1.rgPins[iPin].strName);
 424
 425                         if (rgf2.u.s1.rgPins[iPin].lpMediaType)
 426                         {
 427                             UINT iType;
 428
 429                             for (iType = 0; iType < rgf2.u.s1.rgPins[iPin].nMediaTypes; iType++)
 430                             {
 431                                 CoTaskMemFree((void*)rgf2.u.s1.rgPins[iPin].lpMediaType[iType].clsMajorType);
 432                                 CoTaskMemFree((void*)rgf2.u.s1.rgPins[iPin].lpMediaType[iType].clsMinorType);
 433                             }
 434
 435                             CoTaskMemFree((void*)rgf2.u.s1.rgPins[iPin].lpMediaType);
 436                         }
 437                     }
 438
 439                     CoTaskMemFree((void*)rgf2.u.s1.rgPins);
 440                 }
 441             }
 442         }
 443     }
 444
 445     if (hkeyFilter) RegCloseKey(hkeyFilter);
 446
 447     if (pMapper)
 448         IFilterMapper2_Release(pMapper);
 449
 450     return S_OK;
 451 }
 452
 453 /**********************************************************************
 454  * DEVENUM_ICreateDevEnum_CreateClassEnumerator
 455  */
 456 static HRESULT WINAPI DEVENUM_ICreateDevEnum_CreateClassEnumerator(
 457     ICreateDevEnum * iface,
 458     REFCLSID clsidDeviceClass,
 459     IEnumMoniker **ppEnumMoniker,
 460     DWORD dwFlags)
 461 {
 462     WCHAR wszRegKey[MAX_PATH];
 463     HKEY hkey;
 464     HKEY hbasekey;
 465     HRESULT hr;
 466     CreateDevEnumImpl *This = (CreateDevEnumImpl *)iface;
 467
 468     TRACE("(%p)->(%s, %p, %x)\n\tDeviceClass:\t%s\n", This, debugstr_guid(clsidDeviceClass), ppEnumMoniker, dwFlags, debugstr_guid(clsidDeviceClass));
 469
 470     if (!ppEnumMoniker)
 471         return E_POINTER;
 472
 473     *ppEnumMoniker = NULL;
 474
 475     if (IsEqualGUID(clsidDeviceClass, &CLSID_LegacyAmFilterCategory))
 476     {
 477         DEVENUM_RegisterLegacyAmFilters();
 478     }
 479
 480     hr = DEVENUM_GetCategoryKey(clsidDeviceClass, &hbasekey, wszRegKey, MAX_PATH);
 481     if (FAILED(hr))
 482         return hr;
 483
 484     if (IsEqualGUID(clsidDeviceClass, &CLSID_AudioRendererCategory) ||
 485         IsEqualGUID(clsidDeviceClass, &CLSID_AudioInputDeviceCategory) ||
 486         IsEqualGUID(clsidDeviceClass, &CLSID_VideoInputDeviceCategory) ||
 487         IsEqualGUID(clsidDeviceClass, &CLSID_MidiRendererCategory))
 488     {
 489          hr = DEVENUM_CreateSpecialCategories();
 490          if (FAILED(hr))
 491              return hr;
 492          if (RegOpenKeyW(hbasekey, wszRegKey, &hkey) != ERROR_SUCCESS)
 493          {
 494              ERR("Couldn't open registry key for special device: %s\n",
 495                  debugstr_guid(clsidDeviceClass));
 496              return S_FALSE;
 497          }
 498     }
 499     else if (RegOpenKeyW(hbasekey, wszRegKey, &hkey) != ERROR_SUCCESS)
 500     {
 501         FIXME("Category %s not found\n", debugstr_guid(clsidDeviceClass));
 502         return S_FALSE;
 503     }
 504
 505     return DEVENUM_IEnumMoniker_Construct(hkey, ppEnumMoniker);
 506 }
 507
 508 /**********************************************************************
 509  * ICreateDevEnum_Vtbl
 510  */
 511 static const ICreateDevEnumVtbl ICreateDevEnum_Vtbl =
 512 {
 513     DEVENUM_ICreateDevEnum_QueryInterface,
 514     DEVENUM_ICreateDevEnum_AddRef,
 515     DEVENUM_ICreateDevEnum_Release,
 516     DEVENUM_ICreateDevEnum_CreateClassEnumerator,
 517 };
 518
 519 /**********************************************************************
 520  * static CreateDevEnum instance
 521  */
 522 CreateDevEnumImpl DEVENUM_CreateDevEnum = { &ICreateDevEnum_Vtbl };
 523
 524 /**********************************************************************
 525  * DEVENUM_CreateAMCategoryKey (INTERNAL)
 526  *
 527  * Creates a registry key for a category at HKEY_CURRENT_USER\Software\
 528  * Microsoft\ActiveMovie\devenum\{clsid}
 529  */
 530 static HRESULT DEVENUM_CreateAMCategoryKey(const CLSID * clsidCategory)
 531 {
 532     WCHAR wszRegKey[MAX_PATH];
 533     HRESULT res = S_OK;
 534     HKEY hkeyDummy = NULL;
 535
 536     strcpyW(wszRegKey, wszActiveMovieKey);
 537
 538     if (!StringFromGUID2(clsidCategory, wszRegKey + strlenW(wszRegKey), sizeof(wszRegKey)/sizeof(wszRegKey[0]) - strlenW(wszRegKey)))
 539         res = E_INVALIDARG;
 540
 541     if (SUCCEEDED(res))
 542     {
 543         LONG lRes = RegCreateKeyW(HKEY_CURRENT_USER, wszRegKey, &hkeyDummy);
 544         res = HRESULT_FROM_WIN32(lRes);
 545     }
 546
 547     if (hkeyDummy)
 548         RegCloseKey(hkeyDummy);
 549
 550     if (FAILED(res))
 551         ERR("Failed to create key HKEY_CURRENT_USER\\%s\n", debugstr_w(wszRegKey));
 552
 553     return res;
 554 }
 555
 556 static HANDLE DEVENUM_populate_handle;
 557 static const WCHAR DEVENUM_populate_handle_nameW[] =
 558     {'_','_','W','I','N','E','_',
 559      'D','e','v','e','n','u','m','_',
 560      'P','o','p','u','l','a','t','e',0};
 561
 562 /**********************************************************************
 563  * DEVENUM_CreateSpecialCategories (INTERNAL)
 564  *
 565  * Creates the keys in the registry for the dynamic categories
 566  */
 567 static HRESULT DEVENUM_CreateSpecialCategories(void)
 568 {
 569     HRESULT res;
 570     WCHAR szDSoundNameFormat[MAX_PATH + 1];
 571     WCHAR szDSoundName[MAX_PATH + 1];
 572     DWORD iDefaultDevice = -1;
 573     UINT numDevs;
 574     IFilterMapper2 * pMapper = NULL;
 575     REGFILTER2 rf2;
 576     REGFILTERPINS2 rfp2;
 577     WCHAR path[MAX_PATH];
 578     HKEY basekey;
 579
 580     if (DEVENUM_populate_handle)
 581         return S_OK;
 582     DEVENUM_populate_handle = CreateEventW(NULL, TRUE, FALSE, DEVENUM_populate_handle_nameW);
 583     if (GetLastError() == ERROR_ALREADY_EXISTS)
 584     {
 585         /* Webcams can take some time to scan if the driver is badly written and it enables them,
 586          * so have a 10 s timeout here
 587          */
 588         if (WaitForSingleObject(DEVENUM_populate_handle, 10000) == WAIT_TIMEOUT)
 589             WARN("Waiting for object timed out\n");
 590         TRACE("No need to rescan\n");
 591         return S_OK;
 592     }
 593     TRACE("Scanning for devices\n");
 594
 595     /* Since devices can change between session, for example because you just plugged in a webcam
 596      * or switched from pulseaudio to alsa, delete all old devices first
 597      */
 598     if (SUCCEEDED(DEVENUM_GetCategoryKey(&CLSID_AudioRendererCategory, &basekey, path, MAX_PATH)))
 599         RegDeleteTreeW(basekey, path);
 600     if (SUCCEEDED(DEVENUM_GetCategoryKey(&CLSID_AudioInputDeviceCategory, &basekey, path, MAX_PATH)))
 601         RegDeleteTreeW(basekey, path);
 602     if (SUCCEEDED(DEVENUM_GetCategoryKey(&CLSID_VideoInputDeviceCategory, &basekey, path, MAX_PATH)))
 603         RegDeleteTreeW(basekey, path);
 604     if (SUCCEEDED(DEVENUM_GetCategoryKey(&CLSID_MidiRendererCategory, &basekey, path, MAX_PATH)))
 605         RegDeleteTreeW(basekey, path);
 606
 607     rf2.dwVersion = 2;
 608     rf2.dwMerit = MERIT_PREFERRED;
 609     rf2.u.s2.cPins2 = 1;
 610     rf2.u.s2.rgPins2 = &rfp2;
 611     rfp2.cInstances = 1;
 612     rfp2.nMediums = 0;
 613     rfp2.lpMedium = NULL;
 614     rfp2.clsPinCategory = &IID_NULL;
 615
 616     if (!LoadStringW(DEVENUM_hInstance, IDS_DEVENUM_DS, szDSoundNameFormat, sizeof(szDSoundNameFormat)/sizeof(szDSoundNameFormat[0])-1))
 617     {
 618         ERR("Couldn't get string resource (GetLastError() is %d)\n", GetLastError());
 619         return HRESULT_FROM_WIN32(GetLastError());
 620     }
 621
 622     res = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC,
 623                            &IID_IFilterMapper2, (void **) &pMapper);
 624     /*
 625      * Fill in info for devices
 626      */
 627     if (SUCCEEDED(res))
 628     {
 629         UINT i;
 630         WAVEOUTCAPSW wocaps;
 631         WAVEINCAPSW wicaps;
 632         MIDIOUTCAPSW mocaps;
 633         REGPINTYPES * pTypes;
 634
 635         numDevs = waveOutGetNumDevs();
 636
 637         res = DEVENUM_CreateAMCategoryKey(&CLSID_AudioRendererCategory);
 638         if (FAILED(res)) /* can't register any devices in this category */
 639             numDevs = 0;
 640
 641         rfp2.dwFlags = REG_PINFLAG_B_RENDERER;
 642         for (i = 0; i < numDevs; i++)
 643         {
 644             if (waveOutGetDevCapsW(i, &wocaps, sizeof(WAVEOUTCAPSW))
 645                 == MMSYSERR_NOERROR)
 646             {
 647                 IMoniker * pMoniker = NULL;
 648
 649                 rfp2.nMediaTypes = 1;
 650                 pTypes = CoTaskMemAlloc(rfp2.nMediaTypes * sizeof(REGPINTYPES));
 651                 if (!pTypes)
 652                 {
 653                     IFilterMapper2_Release(pMapper);
 654                     return E_OUTOFMEMORY;
 655                 }
 656                 /* FIXME: Native devenum seems to register a lot more types for
 657                  * DSound than we do. Not sure what purpose they serve */
 658                 pTypes[0].clsMajorType = &MEDIATYPE_Audio;
 659                 pTypes[0].clsMinorType = &MEDIASUBTYPE_PCM;
 660
 661                 rfp2.lpMediaType = pTypes;
 662
 663                 res = IFilterMapper2_RegisterFilter(pMapper,
 664                                               &CLSID_AudioRender,
 665                                               wocaps.szPname,
 666                                               &pMoniker,
 667                                               &CLSID_AudioRendererCategory,
 668                                               wocaps.szPname,
 669                                               &rf2);
 670
 671                 /* FIXME: do additional stuff with IMoniker here, depending on what RegisterFilter does */
 672
 673                 if (pMoniker)
 674                     IMoniker_Release(pMoniker);
 675
 676                 wsprintfW(szDSoundName, szDSoundNameFormat, wocaps.szPname);
 677                 res = IFilterMapper2_RegisterFilter(pMapper,
 678                                               &CLSID_DSoundRender,
 679                                               szDSoundName,
 680                                               &pMoniker,
 681                                               &CLSID_AudioRendererCategory,
 682                                               szDSoundName,
 683                                               &rf2);
 684
 685                 /* FIXME: do additional stuff with IMoniker here, depending on what RegisterFilter does */
 686
 687                 if (pMoniker)
 688                     IMoniker_Release(pMoniker);
 689
 690                 if (i == iDefaultDevice)
 691                 {
 692                     FIXME("Default device\n");
 693                 }
 694
 695                 CoTaskMemFree(pTypes);
 696             }
 697         }
 698
 699         numDevs = waveInGetNumDevs();
 700
 701         res = DEVENUM_CreateAMCategoryKey(&CLSID_AudioInputDeviceCategory);
 702         if (FAILED(res)) /* can't register any devices in this category */
 703             numDevs = 0;
 704
 705         rfp2.dwFlags = REG_PINFLAG_B_OUTPUT;
 706         for (i = 0; i < numDevs; i++)
 707         {
 708             if (waveInGetDevCapsW(i, &wicaps, sizeof(WAVEINCAPSW))
 709                 == MMSYSERR_NOERROR)
 710             {
 711                 IMoniker * pMoniker = NULL;
 712
 713                 rfp2.nMediaTypes = 1;
 714                 pTypes = CoTaskMemAlloc(rfp2.nMediaTypes * sizeof(REGPINTYPES));
 715                 if (!pTypes)
 716                 {
 717                     IFilterMapper2_Release(pMapper);
 718                     return E_OUTOFMEMORY;
 719                 }
 720
 721                 /* FIXME: Not sure if these are correct */
 722                 pTypes[0].clsMajorType = &MEDIATYPE_Audio;
 723                 pTypes[0].clsMinorType = &MEDIASUBTYPE_PCM;
 724
 725                 rfp2.lpMediaType = pTypes;
 726
 727                 res = IFilterMapper2_RegisterFilter(pMapper,
 728                                               &CLSID_AudioRecord,
 729                                               wicaps.szPname,
 730                                               &pMoniker,
 731                                               &CLSID_AudioInputDeviceCategory,
 732                                               wicaps.szPname,
 733                                               &rf2);
 734
 735                 /* FIXME: do additional stuff with IMoniker here, depending on what RegisterFilter does */
 736
 737                 if (pMoniker)
 738                     IMoniker_Release(pMoniker);
 739
 740                 CoTaskMemFree(pTypes);
 741             }
 742         }
 743
 744         numDevs = midiOutGetNumDevs();
 745
 746         res = DEVENUM_CreateAMCategoryKey(&CLSID_MidiRendererCategory);
 747         if (FAILED(res)) /* can't register any devices in this category */
 748             numDevs = 0;
 749
 750         rfp2.dwFlags = REG_PINFLAG_B_RENDERER;
 751         for (i = 0; i < numDevs; i++)
 752         {
 753             if (midiOutGetDevCapsW(i, &mocaps, sizeof(MIDIOUTCAPSW))
 754                 == MMSYSERR_NOERROR)
 755             {
 756                 IMoniker * pMoniker = NULL;
 757
 758                 rfp2.nMediaTypes = 1;
 759                 pTypes = CoTaskMemAlloc(rfp2.nMediaTypes * sizeof(REGPINTYPES));
 760                 if (!pTypes)
 761                 {
 762                     IFilterMapper2_Release(pMapper);
 763                     return E_OUTOFMEMORY;
 764                 }
 765
 766                 /* FIXME: Not sure if these are correct */
 767                 pTypes[0].clsMajorType = &MEDIATYPE_Midi;
 768                 pTypes[0].clsMinorType = &MEDIASUBTYPE_None;
 769
 770                 rfp2.lpMediaType = pTypes;
 771
 772                 res = IFilterMapper2_RegisterFilter(pMapper,
 773                                               &CLSID_AVIMIDIRender,
 774                                               mocaps.szPname,
 775                                               &pMoniker,
 776                                               &CLSID_MidiRendererCategory,
 777                                               mocaps.szPname,
 778                                               &rf2);
 779
 780                 /* FIXME: do additional stuff with IMoniker here, depending on what RegisterFilter does */
 781                 /* Native version sets MidiOutId */
 782
 783                 if (pMoniker)
 784                     IMoniker_Release(pMoniker);
 785
 786                 if (i == iDefaultDevice)
 787                 {
 788                     FIXME("Default device\n");
 789                 }
 790
 791                 CoTaskMemFree(pTypes);
 792             }
 793         }
 794         res = DEVENUM_CreateAMCategoryKey(&CLSID_VideoInputDeviceCategory);
 795         if (SUCCEEDED(res))
 796             for (i = 0; i < 10; i++)
 797             {
 798                 WCHAR szDeviceName[32], szDeviceVersion[32], szDevicePath[10];
 799
 800                 if (capGetDriverDescriptionW ((WORD) i,
 801                                               szDeviceName, sizeof(szDeviceName)/sizeof(WCHAR),
 802                                               szDeviceVersion, sizeof(szDeviceVersion)/sizeof(WCHAR)))
 803                 {
 804                     IMoniker * pMoniker = NULL;
 805                     IPropertyBag * pPropBag = NULL;
 806                     WCHAR dprintf[] = { 'v','i','d','e','o','%','d',0 };
 807                     snprintfW(szDevicePath, sizeof(szDevicePath)/sizeof(WCHAR), dprintf, i);
 808                     /* The above code prevents 1 device with a different ID overwriting another */
 809
 810                     rfp2.nMediaTypes = 1;
 811                     pTypes = CoTaskMemAlloc(rfp2.nMediaTypes * sizeof(REGPINTYPES));
 812                     if (!pTypes) {
 813                         IFilterMapper2_Release(pMapper);
 814                         return E_OUTOFMEMORY;
 815                     }
 816
 817                     pTypes[0].clsMajorType = &MEDIATYPE_Video;
 818                     pTypes[0].clsMinorType = &MEDIASUBTYPE_None;
 819
 820                     rfp2.lpMediaType = pTypes;
 821
 822                     res = IFilterMapper2_RegisterFilter(pMapper,
 823                                                         &CLSID_VfwCapture,
 824                                                         szDeviceName,
 825                                                         &pMoniker,
 826                                                         &CLSID_VideoInputDeviceCategory,
 827                                                         szDevicePath,
 828                                                         &rf2);
 829
 830                     if (pMoniker) {
 831                        OLECHAR wszVfwIndex[] = { 'V','F','W','I','n','d','e','x',0 };
 832                        VARIANT var;
 833                        V_VT(&var) = VT_I4;
 834                        V_UNION(&var, ulVal) = i;
 835                        res = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID)&pPropBag);
 836                        if (SUCCEEDED(res))
 837                           res = IPropertyBag_Write(pPropBag, wszVfwIndex, &var);
 838                        IMoniker_Release(pMoniker);
 839                     }
 840
 841                     if (i == iDefaultDevice) FIXME("Default device\n");
 842                     CoTaskMemFree(pTypes);
 843                 }
 844             }
 845     }
 846
 847     if (pMapper)
 848         IFilterMapper2_Release(pMapper);
 849     SetEvent(DEVENUM_populate_handle);
 850     return res;
 851 }