wined3d: Separate AMD Radeon HD2300 from other HD2xxx/HD3xxx GPUs since it is D3D9...
[wine] / 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
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.s.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.s.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.s.cPins)
313     {
314         CoTaskMemFree(rgPins);
315         rgPins = NULL;
316     }
317
318     rgf2->u.s.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.s.cPins = 0;
391                 rgf2.u.s.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.s.rgPins)
418                 {
419                     UINT iPin;
420
421                     for (iPin = 0; iPin < rgf2.u.s.cPins; iPin++)
422                     {
423                         CoTaskMemFree(rgf2.u.s.rgPins[iPin].strName);
424
425                         if (rgf2.u.s.rgPins[iPin].lpMediaType)
426                         {
427                             UINT iType;
428
429                             for (iType = 0; iType < rgf2.u.s.rgPins[iPin].nMediaTypes; iType++)
430                             {
431                                 CoTaskMemFree((void*)rgf2.u.s.rgPins[iPin].lpMediaType[iType].clsMajorType);
432                                 CoTaskMemFree((void*)rgf2.u.s.rgPins[iPin].lpMediaType[iType].clsMinorType);
433                             }
434
435                             CoTaskMemFree((void*)rgf2.u.s.rgPins[iPin].lpMediaType);
436                         }
437                     }
438
439                     CoTaskMemFree((void*)rgf2.u.s.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.s1.cPins2 = 1;
610     rf2.u.s1.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 }