push 9bfdf186dc6a237cd7f58f0ee2ef677e81617b1d
[wine/hacks.git] / dlls / msdmo / dmoreg.c
blob97388c9fc1cc055f576aa3eef32f71e1055963d6
1 /*
2 * Copyright (C) 2003 Michael Günnewig
3 * Copyright (C) 2003 CodeWeavers Inc. (Ulrich Czekalla)
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 #include <stdarg.h>
22 #include "windef.h"
23 #include "winbase.h"
24 #include "winuser.h"
25 #include "winerror.h"
26 #include "winreg.h"
27 #include "objbase.h"
28 #include "wine/unicode.h"
29 #include "wine/debug.h"
30 #include "initguid.h"
31 #include "dmo.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(msdmo);
35 #define MSDMO_MAJOR_VERSION 6
37 static const WCHAR szDMORootKey[] =
39 'D','i','r','e','c','t','S','h','o','w','\\',
40 'M','e','d','i','a','O','b','j','e','c','t','s',0
41 };
43 static const WCHAR szDMOInputType[] =
45 'I','n','p','u','t','T','y','p','e','s',0
48 static const WCHAR szDMOOutputType[] =
50 'O','u','t','p','u','t','T','y','p','e','s',0
53 static const WCHAR szDMOKeyed[] =
55 'K','e','y','e','d',0
58 static const WCHAR szDMOCategories[] =
60 'C','a','t','e','g','o','r','i','e','s',0
63 static const WCHAR szGUIDFmt[] =
65 '%','0','8','X','-','%','0','4','X','-','%','0','4','X','-','%','0',
66 '2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2',
67 'X','%','0','2','X','%','0','2','X','%','0','2','X',0
70 static const WCHAR szCat3Fmt[] =
72 '%','s','\\','%','s','\\','%','s',0
75 static const WCHAR szCat2Fmt[] =
77 '%','s','\\','%','s',0
80 static const WCHAR szToGuidFmt[] =
82 '{','%','s','}',0
86 typedef struct
88 const IEnumDMOVtbl *lpVtbl;
89 LONG ref;
90 DWORD index;
91 const GUID* guidCategory;
92 DWORD dwFlags;
93 DWORD cInTypes;
94 DMO_PARTIAL_MEDIATYPE *pInTypes;
95 DWORD cOutTypes;
96 DMO_PARTIAL_MEDIATYPE *pOutTypes;
97 HKEY hkey;
98 } IEnumDMOImpl;
100 static HRESULT read_types(HKEY root, LPCWSTR key, ULONG *supplied, ULONG requested, DMO_PARTIAL_MEDIATYPE* types);
102 static const IEnumDMOVtbl edmovt;
104 static LPWSTR GUIDToString(LPWSTR lpwstr, REFGUID lpcguid)
106 wsprintfW(lpwstr, szGUIDFmt, lpcguid->Data1, lpcguid->Data2,
107 lpcguid->Data3, lpcguid->Data4[0], lpcguid->Data4[1],
108 lpcguid->Data4[2], lpcguid->Data4[3], lpcguid->Data4[4],
109 lpcguid->Data4[5], lpcguid->Data4[6], lpcguid->Data4[7]);
111 return lpwstr;
114 static BOOL IsMediaTypeEqual(const DMO_PARTIAL_MEDIATYPE* mt1, const DMO_PARTIAL_MEDIATYPE* mt2)
117 return (IsEqualCLSID(&mt1->type, &mt2->type) ||
118 IsEqualCLSID(&mt2->type, &GUID_NULL) ||
119 IsEqualCLSID(&mt1->type, &GUID_NULL)) &&
120 (IsEqualCLSID(&mt1->subtype, &mt2->subtype) ||
121 IsEqualCLSID(&mt2->subtype, &GUID_NULL) ||
122 IsEqualCLSID(&mt1->subtype, &GUID_NULL));
125 static HRESULT write_types(HKEY hkey, LPCWSTR name, const DMO_PARTIAL_MEDIATYPE* types, DWORD count)
127 HRESULT hres = S_OK;
128 if (MSDMO_MAJOR_VERSION > 5)
130 hres = RegSetValueExW(hkey, name, 0, REG_BINARY, (const BYTE*) types,
131 count* sizeof(DMO_PARTIAL_MEDIATYPE));
133 else
135 HKEY skey1,skey2,skey3;
136 DWORD index = 0;
137 WCHAR szGuidKey[64];
139 hres = RegCreateKeyExW(hkey, name, 0, NULL, REG_OPTION_NON_VOLATILE,
140 KEY_WRITE, NULL, &skey1, NULL);
141 while (index < count)
143 GUIDToString(szGuidKey,&types[index].type);
144 hres = RegCreateKeyExW(skey1, szGuidKey, 0, NULL,
145 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey2, NULL);
146 GUIDToString(szGuidKey,&types[index].subtype);
147 hres = RegCreateKeyExW(skey2, szGuidKey, 0, NULL,
148 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey3, NULL);
149 RegCloseKey(skey3);
150 RegCloseKey(skey2);
151 index ++;
153 RegCloseKey(skey1);
156 return hres;
159 /***************************************************************
160 * DMORegister (MSDMO.@)
162 * Register a DirectX Media Object.
164 HRESULT WINAPI DMORegister(
165 LPCWSTR szName,
166 REFCLSID clsidDMO,
167 REFGUID guidCategory,
168 DWORD dwFlags,
169 DWORD cInTypes,
170 const DMO_PARTIAL_MEDIATYPE *pInTypes,
171 DWORD cOutTypes,
172 const DMO_PARTIAL_MEDIATYPE *pOutTypes
175 WCHAR szguid[64];
176 HRESULT hres;
177 HKEY hrkey = 0;
178 HKEY hkey = 0;
179 HKEY hckey = 0;
180 HKEY hclskey = 0;
182 TRACE("%s\n", debugstr_w(szName));
184 hres = RegCreateKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, NULL,
185 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hrkey, NULL);
186 if (ERROR_SUCCESS != hres)
187 goto lend;
189 /* Create clsidDMO key under MediaObjects */
190 hres = RegCreateKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, NULL,
191 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
192 if (ERROR_SUCCESS != hres)
193 goto lend;
195 /* Set default Name value */
196 hres = RegSetValueExW(hkey, NULL, 0, REG_SZ, (const BYTE*) szName,
197 (strlenW(szName) + 1) * sizeof(WCHAR));
199 /* Set InputTypes */
200 hres = write_types(hkey, szDMOInputType, pInTypes, cInTypes);
202 /* Set OutputTypes */
203 hres = write_types(hkey, szDMOOutputType, pOutTypes, cOutTypes);
205 if (dwFlags & DMO_REGISTERF_IS_KEYED)
207 /* Create Keyed key */
208 hres = RegCreateKeyExW(hkey, szDMOKeyed, 0, NULL,
209 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
210 if (ERROR_SUCCESS != hres)
211 goto lend;
212 RegCloseKey(hckey);
215 /* Register the category */
216 hres = RegCreateKeyExW(hrkey, szDMOCategories, 0, NULL,
217 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
218 if (ERROR_SUCCESS != hres)
219 goto lend;
221 RegCloseKey(hkey);
223 hres = RegCreateKeyExW(hckey, GUIDToString(szguid, guidCategory), 0, NULL,
224 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
225 if (ERROR_SUCCESS != hres)
226 goto lend;
227 hres = RegCreateKeyExW(hkey, GUIDToString(szguid, clsidDMO), 0, NULL,
228 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hclskey, NULL);
229 if (ERROR_SUCCESS != hres)
230 goto lend;
232 lend:
233 if (hkey)
234 RegCloseKey(hkey);
235 if (hckey)
236 RegCloseKey(hckey);
237 if (hclskey)
238 RegCloseKey(hclskey);
239 if (hrkey)
240 RegCloseKey(hrkey);
242 TRACE(" hresult=0x%08x\n", hres);
243 return hres;
247 /***************************************************************
248 * DMOUnregister (MSDMO.@)
250 * Unregister a DirectX Media Object.
252 HRESULT WINAPI DMOUnregister(REFCLSID clsidDMO, REFGUID guidCategory)
254 HRESULT hres;
255 WCHAR szguid[64];
256 HKEY hrkey = 0;
257 HKEY hckey = 0;
259 GUIDToString(szguid, clsidDMO);
261 TRACE("%s %p\n", debugstr_w(szguid), guidCategory);
263 hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &hrkey);
264 if (ERROR_SUCCESS != hres)
265 goto lend;
267 hres = RegDeleteKeyW(hrkey, szguid);
268 if (ERROR_SUCCESS != hres)
269 goto lend;
271 hres = RegOpenKeyExW(hrkey, szDMOCategories, 0, KEY_WRITE, &hckey);
272 if (ERROR_SUCCESS != hres)
273 goto lend;
275 hres = RegDeleteKeyW(hckey, szguid);
276 if (ERROR_SUCCESS != hres)
277 goto lend;
279 lend:
280 if (hckey)
281 RegCloseKey(hckey);
282 if (hrkey)
283 RegCloseKey(hrkey);
285 return hres;
289 /***************************************************************
290 * DMOGetName (MSDMO.@)
292 * Get DMP Name from the registry
294 HRESULT WINAPI DMOGetName(REFCLSID clsidDMO, WCHAR szName[])
296 WCHAR szguid[64];
297 HRESULT hres;
298 HKEY hrkey = 0;
299 HKEY hkey = 0;
300 static const INT max_name_len = 80;
301 DWORD count;
303 TRACE("%s\n", debugstr_guid(clsidDMO));
305 hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey,
306 0, KEY_READ, &hrkey);
307 if (ERROR_SUCCESS != hres)
308 goto lend;
310 hres = RegOpenKeyExW(hrkey, GUIDToString(szguid, clsidDMO),
311 0, KEY_READ, &hkey);
312 if (ERROR_SUCCESS != hres)
313 goto lend;
315 count = max_name_len * sizeof(WCHAR);
316 hres = RegQueryValueExW(hkey, NULL, NULL, NULL,
317 (LPBYTE) szName, &count);
319 TRACE(" szName=%s\n", debugstr_w(szName));
320 lend:
321 if (hkey)
322 RegCloseKey(hrkey);
323 if (hkey)
324 RegCloseKey(hkey);
326 return hres;
330 /**************************************************************************
331 * IEnumDMO_Destructor
333 static BOOL IEnumDMO_Destructor(IEnumDMO* iface)
335 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
337 TRACE("%p\n", This);
339 if (This->hkey)
340 RegCloseKey(This->hkey);
342 HeapFree(GetProcessHeap(), 0, This->pInTypes);
343 HeapFree(GetProcessHeap(), 0, This->pOutTypes);
345 return TRUE;
349 /**************************************************************************
350 * IEnumDMO_Constructor
352 static IEnumDMO * IEnumDMO_Constructor(
353 REFGUID guidCategory,
354 DWORD dwFlags,
355 DWORD cInTypes,
356 const DMO_PARTIAL_MEDIATYPE *pInTypes,
357 DWORD cOutTypes,
358 const DMO_PARTIAL_MEDIATYPE *pOutTypes)
360 UINT size;
361 IEnumDMOImpl* lpedmo;
362 BOOL ret = FALSE;
364 lpedmo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumDMOImpl));
366 if (lpedmo)
368 lpedmo->ref = 1;
369 lpedmo->lpVtbl = &edmovt;
370 lpedmo->index = -1;
371 lpedmo->guidCategory = guidCategory;
372 lpedmo->dwFlags = dwFlags;
374 if (cInTypes > 0)
376 size = cInTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
377 lpedmo->pInTypes = HeapAlloc(GetProcessHeap(), 0, size);
378 if (!lpedmo->pInTypes)
379 goto lerr;
380 memcpy(lpedmo->pInTypes, pInTypes, size);
381 lpedmo->cInTypes = cInTypes;
384 if (cOutTypes > 0)
386 size = cOutTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
387 lpedmo->pOutTypes = HeapAlloc(GetProcessHeap(), 0, size);
388 if (!lpedmo->pOutTypes)
389 goto lerr;
390 memcpy(lpedmo->pOutTypes, pOutTypes, size);
391 lpedmo->cOutTypes = cOutTypes;
394 /* If not filtering by category enum from media objects root */
395 if (IsEqualGUID(guidCategory, &GUID_NULL))
397 if (ERROR_SUCCESS == RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey,
398 0, KEY_READ, &lpedmo->hkey))
399 ret = TRUE;
401 else
403 WCHAR szguid[64];
404 WCHAR szKey[MAX_PATH];
406 wsprintfW(szKey, szCat3Fmt, szDMORootKey, szDMOCategories,
407 GUIDToString(szguid, guidCategory));
408 if (ERROR_SUCCESS == RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey,
409 0, KEY_READ, &lpedmo->hkey))
410 ret = TRUE;
413 lerr:
414 if(!ret)
416 IEnumDMO_Destructor((IEnumDMO*)lpedmo);
417 HeapFree(GetProcessHeap(),0,lpedmo);
418 lpedmo = NULL;
422 TRACE("returning %p\n", lpedmo);
424 return (IEnumDMO*)lpedmo;
428 /******************************************************************************
429 * IEnumDMO_fnAddRef
431 static ULONG WINAPI IEnumDMO_fnAddRef(IEnumDMO * iface)
433 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
434 return InterlockedIncrement(&This->ref);
438 /**************************************************************************
439 * EnumDMO_QueryInterface
441 static HRESULT WINAPI IEnumDMO_fnQueryInterface(
442 IEnumDMO* iface,
443 REFIID riid,
444 LPVOID *ppvObj)
446 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
448 *ppvObj = NULL;
450 if(IsEqualIID(riid, &IID_IUnknown))
451 *ppvObj = This;
452 else if(IsEqualIID(riid, &IID_IEnumDMO))
453 *ppvObj = (IEnumDMO*)This;
455 if(*ppvObj)
457 IEnumDMO_fnAddRef((IEnumDMO*)*ppvObj);
458 return S_OK;
461 return E_NOINTERFACE;
465 /******************************************************************************
466 * IEnumDMO_fnRelease
468 static ULONG WINAPI IEnumDMO_fnRelease(IEnumDMO * iface)
470 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
471 ULONG refCount = InterlockedDecrement(&This->ref);
473 if (!refCount)
475 IEnumDMO_Destructor((IEnumDMO*)This);
476 HeapFree(GetProcessHeap(),0,This);
478 return refCount;
482 /******************************************************************************
483 * IEnumDMO_fnNext
485 static HRESULT WINAPI IEnumDMO_fnNext(
486 IEnumDMO * iface,
487 DWORD cItemsToFetch,
488 CLSID * pCLSID,
489 WCHAR ** Names,
490 DWORD * pcItemsFetched)
492 FILETIME ft;
493 HKEY hkey;
494 WCHAR szNextKey[MAX_PATH];
495 WCHAR szGuidKey[64];
496 WCHAR szKey[MAX_PATH];
497 WCHAR szValue[MAX_PATH];
498 DWORD len;
499 UINT count = 0;
500 HRESULT hres = S_OK;
502 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
504 TRACE("--> (%p) %d %p %p %p\n", iface, cItemsToFetch, pCLSID, Names, pcItemsFetched);
506 if (!pCLSID || !Names || !pcItemsFetched)
507 return E_POINTER;
509 while (count < cItemsToFetch)
511 This->index++;
513 len = MAX_PATH;
514 hres = RegEnumKeyExW(This->hkey, This->index, szNextKey, &len, NULL, NULL, NULL, &ft);
515 if (hres != ERROR_SUCCESS)
516 break;
518 TRACE("found %s\n", debugstr_w(szNextKey));
520 if (!(This->dwFlags & DMO_ENUMF_INCLUDE_KEYED))
522 wsprintfW(szKey, szCat3Fmt, szDMORootKey, szNextKey, szDMOKeyed);
523 hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
524 if (ERROR_SUCCESS == hres)
526 RegCloseKey(hkey);
527 /* Skip Keyed entries */
528 continue;
532 wsprintfW(szKey, szCat2Fmt, szDMORootKey, szNextKey);
533 hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
535 if (This->pInTypes)
537 UINT i, j;
538 DWORD cInTypes;
539 DMO_PARTIAL_MEDIATYPE* pInTypes;
541 hres = read_types(hkey, szDMOInputType, &cInTypes,
542 sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
543 (DMO_PARTIAL_MEDIATYPE*)szValue);
545 if (ERROR_SUCCESS != hres)
547 RegCloseKey(hkey);
548 continue;
551 pInTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
553 for (i = 0; i < This->cInTypes; i++)
555 for (j = 0; j < cInTypes; j++)
557 if (IsMediaTypeEqual(&pInTypes[j], &This->pInTypes[i]))
558 break;
561 if (j >= cInTypes)
562 break;
565 if (i < This->cInTypes)
567 RegCloseKey(hkey);
568 continue;
572 if (This->pOutTypes)
574 UINT i, j;
575 DWORD cOutTypes;
576 DMO_PARTIAL_MEDIATYPE* pOutTypes;
578 hres = read_types(hkey, szDMOOutputType, &cOutTypes,
579 sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
580 (DMO_PARTIAL_MEDIATYPE*)szValue);
582 if (ERROR_SUCCESS != hres)
584 RegCloseKey(hkey);
585 continue;
588 pOutTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
590 for (i = 0; i < This->cOutTypes; i++)
592 for (j = 0; j < cOutTypes; j++)
594 if (IsMediaTypeEqual(&pOutTypes[j], &This->pOutTypes[i]))
595 break;
598 if (j >= cOutTypes)
599 break;
602 if (i < This->cOutTypes)
604 RegCloseKey(hkey);
605 continue;
609 /* Media object wasn't filtered so add it to return list */
610 Names[count] = NULL;
611 len = MAX_PATH * sizeof(WCHAR);
612 hres = RegQueryValueExW(hkey, NULL, NULL, NULL, (LPBYTE) szValue, &len);
613 if (ERROR_SUCCESS == hres)
615 Names[count] = HeapAlloc(GetProcessHeap(), 0, strlenW(szValue) + 1);
616 if (Names[count])
617 strcmpW(Names[count], szValue);
619 wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
620 CLSIDFromString(szGuidKey, &pCLSID[count]);
622 TRACE("found match %s %s\n", debugstr_w(szValue), debugstr_w(szNextKey));
623 RegCloseKey(hkey);
624 count++;
627 *pcItemsFetched = count;
628 if (*pcItemsFetched < cItemsToFetch)
629 hres = S_FALSE;
631 TRACE("<-- %i found\n",count);
632 return hres;
636 /******************************************************************************
637 * IEnumDMO_fnSkip
639 static HRESULT WINAPI IEnumDMO_fnSkip(IEnumDMO * iface, DWORD cItemsToSkip)
641 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
643 This->index += cItemsToSkip;
645 return S_OK;
649 /******************************************************************************
650 * IEnumDMO_fnReset
652 static HRESULT WINAPI IEnumDMO_fnReset(IEnumDMO * iface)
654 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
656 This->index = -1;
658 return S_OK;
662 /******************************************************************************
663 * IEnumDMO_fnClone
665 static HRESULT WINAPI IEnumDMO_fnClone(IEnumDMO * iface, IEnumDMO **ppEnum)
667 IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
669 FIXME("(%p)->() to (%p)->() E_NOTIMPL\n", This, ppEnum);
671 return E_NOTIMPL;
675 /***************************************************************
676 * DMOEnum (MSDMO.@)
678 * Enumerate DirectX Media Objects in the registry.
680 HRESULT WINAPI DMOEnum(
681 REFGUID guidCategory,
682 DWORD dwFlags,
683 DWORD cInTypes,
684 const DMO_PARTIAL_MEDIATYPE *pInTypes,
685 DWORD cOutTypes,
686 const DMO_PARTIAL_MEDIATYPE *pOutTypes,
687 IEnumDMO **ppEnum)
689 HRESULT hres = E_FAIL;
691 TRACE("guidCategory=%p dwFlags=0x%08x cInTypes=%d cOutTypes=%d\n",
692 guidCategory, dwFlags, cInTypes, cOutTypes);
694 *ppEnum = IEnumDMO_Constructor(guidCategory, dwFlags, cInTypes,
695 pInTypes, cOutTypes, pOutTypes);
696 if (*ppEnum)
697 hres = S_OK;
699 return hres;
703 static const IEnumDMOVtbl edmovt =
705 IEnumDMO_fnQueryInterface,
706 IEnumDMO_fnAddRef,
707 IEnumDMO_fnRelease,
708 IEnumDMO_fnNext,
709 IEnumDMO_fnSkip,
710 IEnumDMO_fnReset,
711 IEnumDMO_fnClone,
715 HRESULT read_types(HKEY root, LPCWSTR key, ULONG *supplied, ULONG requested, DMO_PARTIAL_MEDIATYPE* types )
717 HRESULT ret = S_OK;
718 if (MSDMO_MAJOR_VERSION > 5)
720 DWORD len;
721 len = requested * sizeof(DMO_PARTIAL_MEDIATYPE);
722 ret = RegQueryValueExW(root, key, NULL, NULL, (LPBYTE) types, &len);
723 *supplied = len / sizeof(DMO_PARTIAL_MEDIATYPE);
725 else
727 HKEY hkey;
728 WCHAR szGuidKey[64];
730 *supplied = 0;
731 if (ERROR_SUCCESS == RegOpenKeyExW(root, key, 0, KEY_READ, &hkey))
733 int index = 0;
734 WCHAR szNextKey[MAX_PATH];
735 DWORD len;
736 LONG rc = ERROR_SUCCESS;
738 while (rc == ERROR_SUCCESS)
740 len = MAX_PATH;
741 rc = RegEnumKeyExW(hkey, index, szNextKey, &len, NULL, NULL, NULL, NULL);
742 if (rc == ERROR_SUCCESS)
744 HKEY subk;
745 int sub_index = 0;
746 LONG rcs = ERROR_SUCCESS;
747 WCHAR szSubKey[MAX_PATH];
749 RegOpenKeyExW(hkey, szNextKey, 0, KEY_READ, &subk);
750 while (rcs == ERROR_SUCCESS)
752 len = MAX_PATH;
753 rcs = RegEnumKeyExW(subk, sub_index, szSubKey, &len, NULL, NULL, NULL, NULL);
754 if (rcs == ERROR_SUCCESS)
756 if (*supplied >= requested)
758 /* Bailing */
759 ret = S_FALSE;
760 rc = ERROR_MORE_DATA;
761 rcs = ERROR_MORE_DATA;
762 break;
765 wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
766 CLSIDFromString(szGuidKey, &types[*supplied].type);
767 wsprintfW(szGuidKey,szToGuidFmt,szSubKey);
768 CLSIDFromString(szGuidKey, &types[*supplied].subtype);
769 TRACE("Adding type %s subtype %s at index %i\n",
770 debugstr_guid(&types[*supplied].type),
771 debugstr_guid(&types[*supplied].subtype),
772 *supplied);
773 (*supplied)++;
775 sub_index++;
777 index++;
780 RegCloseKey(hkey);
783 return ret;
786 /***************************************************************
787 * DMOGetTypes (MSDMO.@)
789 HRESULT WINAPI DMOGetTypes(REFCLSID clsidDMO,
790 ULONG ulInputTypesRequested,
791 ULONG* pulInputTypesSupplied,
792 DMO_PARTIAL_MEDIATYPE* pInputTypes,
793 ULONG ulOutputTypesRequested,
794 ULONG* pulOutputTypesSupplied,
795 DMO_PARTIAL_MEDIATYPE* pOutputTypes)
797 HKEY root,hkey;
798 HRESULT ret = S_OK;
799 WCHAR szguid[64];
801 TRACE ("(%s,%u,%p,%p,%u,%p,%p),stub!\n", debugstr_guid(clsidDMO),
802 ulInputTypesRequested, pulInputTypesSupplied, pInputTypes,
803 ulOutputTypesRequested, pulOutputTypesSupplied, pOutputTypes);
805 if (ERROR_SUCCESS != RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0,
806 KEY_READ, &root))
807 return E_FAIL;
809 if (ERROR_SUCCESS != RegOpenKeyExW(root,GUIDToString(szguid,clsidDMO) , 0,
810 KEY_READ, &hkey))
812 RegCloseKey(root);
813 return E_FAIL;
816 if (ulInputTypesRequested > 0)
818 ret = read_types(hkey, szDMOInputType, pulInputTypesSupplied, ulInputTypesRequested, pInputTypes );
820 else
821 *pulInputTypesSupplied = 0;
823 if (ulOutputTypesRequested > 0)
825 HRESULT ret2;
826 ret2 = read_types(hkey, szDMOOutputType, pulOutputTypesSupplied, ulOutputTypesRequested, pOutputTypes );
828 if (ret == S_OK)
829 ret = ret2;
831 else
832 *pulOutputTypesSupplied = 0;
834 return ret;