dlls/msdmo/dmoreg.c

   1 /*
   2  * Copyright (C) 2003 Michael Günnewig
   3  * Copyright (C) 2003 CodeWeavers Inc. (Ulrich Czekalla)
   4  *
   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.
   9  *
  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.
  14  *
  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
  18  */
  19
  20 #include <stdarg.h>
  21
  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"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msdmo);
  34
  35 #define MSDMO_MAJOR_VERSION 6
  36
  37 static const WCHAR szDMORootKey[] =
  38 {
  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 };
  42
  43 static const WCHAR szDMOInputType[] =
  44 {
  45     'I','n','p','u','t','T','y','p','e','s',0
  46 };
  47
  48 static const WCHAR szDMOOutputType[] =
  49 {
  50     'O','u','t','p','u','t','T','y','p','e','s',0
  51 };
  52
  53 static const WCHAR szDMOKeyed[] =
  54 {
  55     'K','e','y','e','d',0
  56 };
  57
  58 static const WCHAR szDMOCategories[] =
  59 {
  60     'C','a','t','e','g','o','r','i','e','s',0
  61 };
  62
  63 static const WCHAR szGUIDFmt[] =
  64 {
  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
  68 };
  69
  70 static const WCHAR szCat3Fmt[] =
  71 {
  72     '%','s','\\','%','s','\\','%','s',0
  73 };
  74
  75 static const WCHAR szCat2Fmt[] =
  76 {
  77     '%','s','\\','%','s',0
  78 };
  79
  80 static const WCHAR szToGuidFmt[] =
  81 {
  82     '{','%','s','}',0
  83 };
  84
  85
  86 typedef struct
  87 {
  88     IEnumDMO                    IEnumDMO_iface;
  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;
  99
 100 static inline IEnumDMOImpl *impl_from_IEnumDMO(IEnumDMO *iface)
 101 {
 102     return CONTAINING_RECORD(iface, IEnumDMOImpl, IEnumDMO_iface);
 103 }
 104
 105 static HRESULT read_types(HKEY root, LPCWSTR key, ULONG *supplied, ULONG requested, DMO_PARTIAL_MEDIATYPE* types);
 106
 107 static const IEnumDMOVtbl edmovt;
 108
 109 static LPWSTR GUIDToString(LPWSTR lpwstr, REFGUID lpcguid)
 110 {
 111     wsprintfW(lpwstr, szGUIDFmt, lpcguid->Data1, lpcguid->Data2,
 112         lpcguid->Data3, lpcguid->Data4[0], lpcguid->Data4[1],
 113         lpcguid->Data4[2], lpcguid->Data4[3], lpcguid->Data4[4],
 114         lpcguid->Data4[5], lpcguid->Data4[6], lpcguid->Data4[7]);
 115
 116     return lpwstr;
 117 }
 118
 119 static BOOL IsMediaTypeEqual(const DMO_PARTIAL_MEDIATYPE* mt1, const DMO_PARTIAL_MEDIATYPE* mt2)
 120 {
 121
 122     return (IsEqualCLSID(&mt1->type, &mt2->type) ||
 123             IsEqualCLSID(&mt2->type, &GUID_NULL) ||
 124             IsEqualCLSID(&mt1->type, &GUID_NULL)) &&
 125             (IsEqualCLSID(&mt1->subtype, &mt2->subtype) ||
 126             IsEqualCLSID(&mt2->subtype, &GUID_NULL) ||
 127             IsEqualCLSID(&mt1->subtype, &GUID_NULL));
 128 }
 129
 130 static HRESULT write_types(HKEY hkey, LPCWSTR name, const DMO_PARTIAL_MEDIATYPE* types, DWORD count)
 131 {
 132     LONG ret;
 133
 134     if (MSDMO_MAJOR_VERSION > 5)
 135     {
 136         ret = RegSetValueExW(hkey, name, 0, REG_BINARY, (const BYTE*) types,
 137                           count* sizeof(DMO_PARTIAL_MEDIATYPE));
 138     }
 139     else
 140     {
 141         HKEY skey1,skey2,skey3;
 142         DWORD index = 0;
 143         WCHAR szGuidKey[64];
 144
 145         ret = RegCreateKeyExW(hkey, name, 0, NULL, REG_OPTION_NON_VOLATILE,
 146                                KEY_WRITE, NULL, &skey1, NULL);
 147         if (ret)
 148             return HRESULT_FROM_WIN32(ret);
 149
 150         while (index < count)
 151         {
 152             GUIDToString(szGuidKey,&types[index].type);
 153             ret = RegCreateKeyExW(skey1, szGuidKey, 0, NULL,
 154                         REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey2, NULL);
 155             GUIDToString(szGuidKey,&types[index].subtype);
 156             ret = RegCreateKeyExW(skey2, szGuidKey, 0, NULL,
 157                         REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey3, NULL);
 158             RegCloseKey(skey3);
 159             RegCloseKey(skey2);
 160             index ++;
 161         }
 162         RegCloseKey(skey1);
 163     }
 164
 165     return HRESULT_FROM_WIN32(ret);
 166 }
 167
 168 /***************************************************************
 169  * DMORegister (MSDMO.@)
 170  *
 171  * Register a DirectX Media Object.
 172  */
 173 HRESULT WINAPI DMORegister(
 174    LPCWSTR szName,
 175    REFCLSID clsidDMO,
 176    REFGUID guidCategory,
 177    DWORD dwFlags,
 178    DWORD cInTypes,
 179    const DMO_PARTIAL_MEDIATYPE *pInTypes,
 180    DWORD cOutTypes,
 181    const DMO_PARTIAL_MEDIATYPE *pOutTypes
 182 )
 183 {
 184     WCHAR szguid[64];
 185     HRESULT hres;
 186     HKEY hrkey = 0;
 187     HKEY hkey = 0;
 188     HKEY hckey = 0;
 189     HKEY hclskey = 0;
 190
 191     TRACE("%s %s %s\n", debugstr_w(szName), debugstr_guid(clsidDMO), debugstr_guid(guidCategory));
 192
 193     if (IsEqualGUID(guidCategory, &GUID_NULL))
 194         return E_INVALIDARG;
 195
 196     hres = RegCreateKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, NULL,
 197         REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hrkey, NULL);
 198     if (ERROR_SUCCESS != hres)
 199         goto lend;
 200
 201     /* Create clsidDMO key under MediaObjects */
 202     hres = RegCreateKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, NULL,
 203         REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
 204     if (ERROR_SUCCESS != hres)
 205         goto lend;
 206
 207     /* Set default Name value */
 208     hres = RegSetValueExW(hkey, NULL, 0, REG_SZ, (const BYTE*) szName,
 209         (strlenW(szName) + 1) * sizeof(WCHAR));
 210
 211     /* Set InputTypes */
 212     hres = write_types(hkey, szDMOInputType, pInTypes, cInTypes);
 213
 214     /* Set OutputTypes */
 215     hres = write_types(hkey, szDMOOutputType, pOutTypes, cOutTypes);
 216
 217     if (dwFlags & DMO_REGISTERF_IS_KEYED)
 218     {
 219         /* Create Keyed key */
 220         hres = RegCreateKeyExW(hkey, szDMOKeyed, 0, NULL,
 221             REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
 222         if (ERROR_SUCCESS != hres)
 223             goto lend;
 224         RegCloseKey(hckey);
 225     }
 226
 227     /* Register the category */
 228     hres = RegCreateKeyExW(hrkey, szDMOCategories, 0, NULL,
 229             REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
 230     if (ERROR_SUCCESS != hres)
 231         goto lend;
 232
 233     RegCloseKey(hkey);
 234
 235     hres = RegCreateKeyExW(hckey, GUIDToString(szguid, guidCategory), 0, NULL,
 236             REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
 237     if (ERROR_SUCCESS != hres)
 238         goto lend;
 239     hres = RegCreateKeyExW(hkey, GUIDToString(szguid, clsidDMO), 0, NULL,
 240         REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hclskey, NULL);
 241     if (ERROR_SUCCESS != hres)
 242         goto lend;
 243
 244 lend:
 245     if (hkey)
 246         RegCloseKey(hkey);
 247     if (hckey)
 248         RegCloseKey(hckey);
 249     if (hclskey)
 250         RegCloseKey(hclskey);
 251     if (hrkey)
 252         RegCloseKey(hrkey);
 253
 254     TRACE(" hresult=0x%08x\n", hres);
 255     return hres;
 256 }
 257
 258 static HRESULT unregister_dmo_from_category(const WCHAR *dmoW, const WCHAR *catW, HKEY categories)
 259 {
 260     HKEY catkey;
 261     LONG ret;
 262
 263     ret = RegOpenKeyExW(categories, catW, 0, KEY_WRITE, &catkey);
 264     if (!ret)
 265     {
 266         ret = RegDeleteKeyW(catkey, dmoW);
 267         RegCloseKey(catkey);
 268     }
 269
 270     return !ret ? S_OK : S_FALSE;
 271 }
 272
 273 /***************************************************************
 274  * DMOUnregister (MSDMO.@)
 275  *
 276  * Unregister a DirectX Media Object.
 277  */
 278 HRESULT WINAPI DMOUnregister(REFCLSID dmo, REFGUID category)
 279 {
 280     HKEY rootkey = 0, categorieskey = 0;
 281     WCHAR dmoW[64], catW[64];
 282     HRESULT hr = S_FALSE;
 283     LONG ret;
 284
 285     TRACE("%s %s\n", debugstr_guid(dmo), debugstr_guid(category));
 286
 287     ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &rootkey);
 288     if (ret)
 289         return S_FALSE;
 290
 291     GUIDToString(dmoW, dmo);
 292     RegDeleteKeyW(rootkey, dmoW);
 293
 294     /* open 'Categories' */
 295     ret = RegOpenKeyExW(rootkey, szDMOCategories, 0, KEY_WRITE|KEY_ENUMERATE_SUB_KEYS, &categorieskey);
 296     RegCloseKey(rootkey);
 297     if (ret)
 298     {
 299         hr = HRESULT_FROM_WIN32(ret);
 300         goto lend;
 301     }
 302
 303     /* remove from all categories */
 304     if (IsEqualGUID(category, &GUID_NULL))
 305     {
 306         DWORD index = 0, len = sizeof(catW)/sizeof(WCHAR);
 307
 308         while (!RegEnumKeyExW(categorieskey, index++, catW, &len, NULL, NULL, NULL, NULL))
 309             hr = unregister_dmo_from_category(dmoW, catW, categorieskey);
 310     }
 311     else
 312     {
 313         GUIDToString(catW, category);
 314         hr = unregister_dmo_from_category(dmoW, catW, categorieskey);
 315     }
 316
 317 lend:
 318     if (categorieskey)
 319         RegCloseKey(categorieskey);
 320
 321     return hr;
 322 }
 323
 324
 325 /***************************************************************
 326  * DMOGetName (MSDMO.@)
 327  *
 328  * Get DMP Name from the registry
 329  */
 330 HRESULT WINAPI DMOGetName(REFCLSID clsidDMO, WCHAR szName[])
 331 {
 332     WCHAR szguid[64];
 333     HKEY hrkey = 0;
 334     HKEY hkey = 0;
 335     static const INT max_name_len = 80;
 336     DWORD count;
 337     LONG ret;
 338
 339     TRACE("%s\n", debugstr_guid(clsidDMO));
 340
 341     ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_READ, &hrkey);
 342     if (ERROR_SUCCESS != ret)
 343         goto lend;
 344
 345     ret = RegOpenKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, KEY_READ, &hkey);
 346     if (ERROR_SUCCESS != ret)
 347         goto lend;
 348
 349     count = max_name_len * sizeof(WCHAR);
 350     ret = RegQueryValueExW(hkey, NULL, NULL, NULL, (LPBYTE) szName, &count);
 351
 352     TRACE(" szName=%s\n", debugstr_w(szName));
 353 lend:
 354     if (hkey)
 355         RegCloseKey(hrkey);
 356     if (hkey)
 357         RegCloseKey(hkey);
 358
 359     return HRESULT_FROM_WIN32(ret);
 360 }
 361
 362 /**************************************************************************
 363 *   IEnumDMOImpl_Destructor
 364 */
 365 static BOOL IEnumDMOImpl_Destructor(IEnumDMOImpl* This)
 366 {
 367     TRACE("%p\n", This);
 368
 369     if (This->hkey)
 370         RegCloseKey(This->hkey);
 371
 372     HeapFree(GetProcessHeap(), 0, This->pInTypes);
 373     HeapFree(GetProcessHeap(), 0, This->pOutTypes);
 374
 375     return TRUE;
 376 }
 377
 378
 379 /**************************************************************************
 380  *  IEnumDMO_Constructor
 381  */
 382 static HRESULT IEnumDMO_Constructor(
 383     REFGUID guidCategory,
 384     DWORD dwFlags,
 385     DWORD cInTypes,
 386     const DMO_PARTIAL_MEDIATYPE *pInTypes,
 387     DWORD cOutTypes,
 388     const DMO_PARTIAL_MEDIATYPE *pOutTypes,
 389     IEnumDMO **obj)
 390 {
 391     IEnumDMOImpl* lpedmo;
 392     HRESULT hr = S_OK;
 393     UINT size;
 394     LONG ret;
 395
 396     *obj = NULL;
 397
 398     lpedmo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumDMOImpl));
 399     if (!lpedmo)
 400         return E_OUTOFMEMORY;
 401
 402     lpedmo->IEnumDMO_iface.lpVtbl = &edmovt;
 403     lpedmo->ref = 1;
 404     lpedmo->index = -1;
 405     lpedmo->guidCategory = guidCategory;
 406     lpedmo->dwFlags = dwFlags;
 407
 408     if (cInTypes > 0)
 409     {
 410         size = cInTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
 411         lpedmo->pInTypes = HeapAlloc(GetProcessHeap(), 0, size);
 412         if (!lpedmo->pInTypes)
 413         {
 414             hr = E_OUTOFMEMORY;
 415             goto lerr;
 416         }
 417         memcpy(lpedmo->pInTypes, pInTypes, size);
 418         lpedmo->cInTypes = cInTypes;
 419     }
 420
 421     if (cOutTypes > 0)
 422     {
 423         size = cOutTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
 424         lpedmo->pOutTypes = HeapAlloc(GetProcessHeap(), 0, size);
 425         if (!lpedmo->pOutTypes)
 426         {
 427             hr = E_OUTOFMEMORY;
 428             goto lerr;
 429         }
 430         memcpy(lpedmo->pOutTypes, pOutTypes, size);
 431         lpedmo->cOutTypes = cOutTypes;
 432     }
 433
 434     /* If not filtering by category enum from media objects root */
 435     if (IsEqualGUID(guidCategory, &GUID_NULL))
 436     {
 437         if ((ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_READ, &lpedmo->hkey)))
 438             hr = HRESULT_FROM_WIN32(ret);
 439     }
 440     else
 441     {
 442         WCHAR szguid[64];
 443         WCHAR szKey[MAX_PATH];
 444
 445         wsprintfW(szKey, szCat3Fmt, szDMORootKey, szDMOCategories,
 446             GUIDToString(szguid, guidCategory));
 447         if ((ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &lpedmo->hkey)))
 448             hr = HRESULT_FROM_WIN32(ret);
 449     }
 450
 451 lerr:
 452
 453     if (FAILED(hr))
 454     {
 455         IEnumDMOImpl_Destructor(lpedmo);
 456         HeapFree(GetProcessHeap(), 0, lpedmo);
 457     }
 458     else
 459     {
 460         TRACE("returning %p\n", lpedmo);
 461         *obj = &lpedmo->IEnumDMO_iface;
 462     }
 463
 464     return hr;
 465 }
 466
 467 /******************************************************************************
 468  * IEnumDMO_fnAddRef
 469  */
 470 static ULONG WINAPI IEnumDMO_fnAddRef(IEnumDMO * iface)
 471 {
 472     IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 473     ULONG refCount = InterlockedIncrement(&This->ref);
 474     TRACE("(%p)->(%d)\n", This, refCount);
 475     return refCount;
 476 }
 477
 478 /**************************************************************************
 479  *  EnumDMO_QueryInterface
 480  */
 481 static HRESULT WINAPI IEnumDMO_fnQueryInterface(IEnumDMO* iface, REFIID riid, void **ppvObj)
 482 {
 483     IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 484
 485     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObj);
 486
 487     *ppvObj = NULL;
 488
 489     if (IsEqualIID(riid, &IID_IEnumDMO) ||
 490         IsEqualIID(riid, &IID_IUnknown))
 491     {
 492         *ppvObj = iface;
 493         IEnumDMO_fnAddRef(iface);
 494     }
 495
 496     return *ppvObj ? S_OK : E_NOINTERFACE;
 497 }
 498
 499 /******************************************************************************
 500  * IEnumDMO_fnRelease
 501  */
 502 static ULONG WINAPI IEnumDMO_fnRelease(IEnumDMO * iface)
 503 {
 504     IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 505     ULONG refCount = InterlockedDecrement(&This->ref);
 506
 507     TRACE("(%p)->(%d)\n", This, refCount);
 508
 509     if (!refCount)
 510     {
 511         IEnumDMOImpl_Destructor(This);
 512         HeapFree(GetProcessHeap(),0,This);
 513     }
 514     return refCount;
 515 }
 516
 517
 518 /******************************************************************************
 519  * IEnumDMO_fnNext
 520  */
 521 static HRESULT WINAPI IEnumDMO_fnNext(
 522     IEnumDMO * iface,
 523     DWORD cItemsToFetch,
 524     CLSID * pCLSID,
 525     WCHAR ** Names,
 526     DWORD * pcItemsFetched)
 527 {
 528     FILETIME ft;
 529     HKEY hkey;
 530     WCHAR szNextKey[MAX_PATH];
 531     WCHAR szGuidKey[64];
 532     WCHAR szKey[MAX_PATH];
 533     WCHAR szValue[MAX_PATH];
 534     DWORD len;
 535     UINT count = 0;
 536     HRESULT hres = S_OK;
 537     LONG ret;
 538
 539     IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 540
 541     TRACE("(%p)->(%d %p %p %p)\n", This, cItemsToFetch, pCLSID, Names, pcItemsFetched);
 542
 543     if (!pCLSID || !Names || !pcItemsFetched)
 544         return E_POINTER;
 545
 546     while (count < cItemsToFetch)
 547     {
 548         This->index++;
 549
 550         len = MAX_PATH;
 551         ret = RegEnumKeyExW(This->hkey, This->index, szNextKey, &len, NULL, NULL, NULL, &ft);
 552         if (ret != ERROR_SUCCESS)
 553         {
 554             hres = HRESULT_FROM_WIN32(ret);
 555             break;
 556         }
 557
 558         TRACE("found %s\n", debugstr_w(szNextKey));
 559
 560         if (!(This->dwFlags & DMO_ENUMF_INCLUDE_KEYED))
 561         {
 562             wsprintfW(szKey, szCat3Fmt, szDMORootKey, szNextKey, szDMOKeyed);
 563             ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
 564             if (ERROR_SUCCESS == ret)
 565             {
 566                 RegCloseKey(hkey);
 567                 /* Skip Keyed entries */
 568                 continue;
 569             }
 570         }
 571
 572         wsprintfW(szKey, szCat2Fmt, szDMORootKey, szNextKey);
 573         ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
 574
 575         if (This->pInTypes)
 576         {
 577             UINT i, j;
 578             DWORD cInTypes;
 579             DMO_PARTIAL_MEDIATYPE* pInTypes;
 580
 581             hres = read_types(hkey, szDMOInputType, &cInTypes,
 582                     sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
 583                     (DMO_PARTIAL_MEDIATYPE*)szValue);
 584
 585             if (FAILED(hres))
 586             {
 587                 RegCloseKey(hkey);
 588                 continue;
 589             }
 590
 591             pInTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
 592
 593             for (i = 0; i < This->cInTypes; i++)
 594             {
 595                 for (j = 0; j < cInTypes; j++)
 596                 {
 597                     if (IsMediaTypeEqual(&pInTypes[j], &This->pInTypes[i]))
 598                         break;
 599                 }
 600
 601                 if (j >= cInTypes)
 602                     break;
 603             }
 604
 605             if (i < This->cInTypes)
 606             {
 607                 RegCloseKey(hkey);
 608                 continue;
 609             }
 610         }
 611
 612         if (This->pOutTypes)
 613         {
 614             UINT i, j;
 615             DWORD cOutTypes;
 616             DMO_PARTIAL_MEDIATYPE* pOutTypes;
 617
 618             hres = read_types(hkey, szDMOOutputType, &cOutTypes,
 619                     sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
 620                     (DMO_PARTIAL_MEDIATYPE*)szValue);
 621
 622             if (FAILED(hres))
 623             {
 624                 RegCloseKey(hkey);
 625                 continue;
 626             }
 627
 628             pOutTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
 629
 630             for (i = 0; i < This->cOutTypes; i++)
 631             {
 632                 for (j = 0; j < cOutTypes; j++)
 633                 {
 634                     if (IsMediaTypeEqual(&pOutTypes[j], &This->pOutTypes[i]))
 635                         break;
 636                 }
 637
 638                 if (j >= cOutTypes)
 639                     break;
 640             }
 641
 642             if (i < This->cOutTypes)
 643             {
 644                 RegCloseKey(hkey);
 645                 continue;
 646             }
 647         }
 648
 649         /* Media object wasn't filtered so add it to return list */
 650         Names[count] = NULL;
 651         len = MAX_PATH * sizeof(WCHAR);
 652         ret = RegQueryValueExW(hkey, NULL, NULL, NULL, (LPBYTE)szValue, &len);
 653         if (ERROR_SUCCESS == ret)
 654         {
 655             Names[count] = HeapAlloc(GetProcessHeap(), 0, (strlenW(szValue) + 1) * sizeof(WCHAR));
 656             if (Names[count])
 657                 strcpyW(Names[count], szValue);
 658         }
 659         wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
 660         CLSIDFromString(szGuidKey, &pCLSID[count]);
 661
 662         TRACE("found match %s %s\n", debugstr_w(szValue), debugstr_w(szNextKey));
 663         RegCloseKey(hkey);
 664         count++;
 665     }
 666
 667     *pcItemsFetched = count;
 668     if (*pcItemsFetched < cItemsToFetch)
 669         hres = S_FALSE;
 670
 671     TRACE("<-- %i found\n",count);
 672     return hres;
 673 }
 674
 675
 676 /******************************************************************************
 677  * IEnumDMO_fnSkip
 678  */
 679 static HRESULT WINAPI IEnumDMO_fnSkip(IEnumDMO * iface, DWORD cItemsToSkip)
 680 {
 681     IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 682
 683     TRACE("(%p)->(%d)\n", This, cItemsToSkip);
 684     This->index += cItemsToSkip;
 685
 686     return S_OK;
 687 }
 688
 689
 690 /******************************************************************************
 691  * IEnumDMO_fnReset
 692  */
 693 static HRESULT WINAPI IEnumDMO_fnReset(IEnumDMO * iface)
 694 {
 695     IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 696
 697     TRACE("(%p)\n", This);
 698     This->index = -1;
 699
 700     return S_OK;
 701 }
 702
 703
 704 /******************************************************************************
 705  * IEnumDMO_fnClone
 706  */
 707 static HRESULT WINAPI IEnumDMO_fnClone(IEnumDMO *iface, IEnumDMO **ppEnum)
 708 {
 709     IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 710     TRACE("(%p)->(%p)\n", This, ppEnum);
 711     return IEnumDMO_Constructor(This->guidCategory, This->dwFlags, This->cInTypes, This->pInTypes,
 712         This->cOutTypes, This->pOutTypes, ppEnum);
 713 }
 714
 715
 716 /***************************************************************
 717  * DMOEnum (MSDMO.@)
 718  *
 719  * Enumerate DirectX Media Objects in the registry.
 720  */
 721 HRESULT WINAPI DMOEnum(
 722     REFGUID guidCategory,
 723     DWORD dwFlags,
 724     DWORD cInTypes,
 725     const DMO_PARTIAL_MEDIATYPE *pInTypes,
 726     DWORD cOutTypes,
 727     const DMO_PARTIAL_MEDIATYPE *pOutTypes,
 728     IEnumDMO **ppEnum)
 729 {
 730     TRACE("guidCategory=%p dwFlags=0x%08x cInTypes=%d cOutTypes=%d\n",
 731         guidCategory, dwFlags, cInTypes, cOutTypes);
 732
 733     return IEnumDMO_Constructor(guidCategory, dwFlags, cInTypes,
 734         pInTypes, cOutTypes, pOutTypes, ppEnum);
 735 }
 736
 737
 738 static const IEnumDMOVtbl edmovt =
 739 {
 740         IEnumDMO_fnQueryInterface,
 741         IEnumDMO_fnAddRef,
 742         IEnumDMO_fnRelease,
 743         IEnumDMO_fnNext,
 744         IEnumDMO_fnSkip,
 745         IEnumDMO_fnReset,
 746         IEnumDMO_fnClone,
 747 };
 748
 749
 750 HRESULT read_types(HKEY root, LPCWSTR key, ULONG *supplied, ULONG requested, DMO_PARTIAL_MEDIATYPE* types )
 751 {
 752     HRESULT ret = S_OK;
 753
 754     if (MSDMO_MAJOR_VERSION > 5)
 755     {
 756         DWORD len;
 757         LONG rc;
 758
 759         len = requested * sizeof(DMO_PARTIAL_MEDIATYPE);
 760         rc = RegQueryValueExW(root, key, NULL, NULL, (LPBYTE) types, &len);
 761         ret = HRESULT_FROM_WIN32(rc);
 762
 763         *supplied = len / sizeof(DMO_PARTIAL_MEDIATYPE);
 764     }
 765     else
 766     {
 767         HKEY hkey;
 768         WCHAR szGuidKey[64];
 769
 770         *supplied = 0;
 771         if (ERROR_SUCCESS == RegOpenKeyExW(root, key, 0, KEY_READ, &hkey))
 772         {
 773           int index = 0;
 774           WCHAR szNextKey[MAX_PATH];
 775           DWORD len;
 776           LONG rc = ERROR_SUCCESS;
 777
 778           while (rc == ERROR_SUCCESS)
 779           {
 780             len = MAX_PATH;
 781             rc = RegEnumKeyExW(hkey, index, szNextKey, &len, NULL, NULL, NULL, NULL);
 782             if (rc == ERROR_SUCCESS)
 783             {
 784               HKEY subk;
 785               int sub_index = 0;
 786               LONG rcs = ERROR_SUCCESS;
 787               WCHAR szSubKey[MAX_PATH];
 788
 789               RegOpenKeyExW(hkey, szNextKey, 0, KEY_READ, &subk);
 790               while (rcs == ERROR_SUCCESS)
 791               {
 792                 len = MAX_PATH;
 793                 rcs = RegEnumKeyExW(subk, sub_index, szSubKey, &len, NULL, NULL, NULL, NULL);
 794                 if (rcs == ERROR_SUCCESS)
 795                 {
 796                   if (*supplied >= requested)
 797                   {
 798                     /* Bailing */
 799                     ret = S_FALSE;
 800                     rc = ERROR_MORE_DATA;
 801                     rcs = ERROR_MORE_DATA;
 802                     break;
 803                   }
 804
 805                   wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
 806                   CLSIDFromString(szGuidKey, &types[*supplied].type);
 807                   wsprintfW(szGuidKey,szToGuidFmt,szSubKey);
 808                   CLSIDFromString(szGuidKey, &types[*supplied].subtype);
 809                   TRACE("Adding type %s subtype %s at index %i\n",
 810                     debugstr_guid(&types[*supplied].type),
 811                     debugstr_guid(&types[*supplied].subtype),
 812                     *supplied);
 813                   (*supplied)++;
 814                 }
 815                 sub_index++;
 816               }
 817               index++;
 818             }
 819           }
 820           RegCloseKey(hkey);
 821         }
 822     }
 823     return ret;
 824 }
 825
 826 /***************************************************************
 827  * DMOGetTypes (MSDMO.@)
 828  */
 829 HRESULT WINAPI DMOGetTypes(REFCLSID clsidDMO,
 830                ULONG ulInputTypesRequested,
 831                ULONG* pulInputTypesSupplied,
 832                DMO_PARTIAL_MEDIATYPE* pInputTypes,
 833                ULONG ulOutputTypesRequested,
 834                ULONG* pulOutputTypesSupplied,
 835                DMO_PARTIAL_MEDIATYPE* pOutputTypes)
 836 {
 837   HKEY root,hkey;
 838   HRESULT ret = S_OK;
 839   WCHAR szguid[64];
 840
 841   TRACE ("(%s,%u,%p,%p,%u,%p,%p)\n", debugstr_guid(clsidDMO), ulInputTypesRequested,
 842         pulInputTypesSupplied, pInputTypes, ulOutputTypesRequested, pulOutputTypesSupplied,
 843         pOutputTypes);
 844
 845   if (ERROR_SUCCESS != RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0,
 846                                      KEY_READ, &root))
 847     return E_FAIL;
 848
 849   if (ERROR_SUCCESS != RegOpenKeyExW(root,GUIDToString(szguid,clsidDMO) , 0,
 850                                      KEY_READ, &hkey))
 851   {
 852     RegCloseKey(root);
 853     return E_FAIL;
 854   }
 855
 856   if (ulInputTypesRequested > 0)
 857   {
 858     ret = read_types(hkey, szDMOInputType, pulInputTypesSupplied, ulInputTypesRequested, pInputTypes );
 859   }
 860   else
 861     *pulInputTypesSupplied = 0;
 862
 863   if (ulOutputTypesRequested > 0)
 864   {
 865     HRESULT ret2;
 866     ret2 = read_types(hkey, szDMOOutputType, pulOutputTypesSupplied, ulOutputTypesRequested, pOutputTypes );
 867
 868     if (ret == S_OK)
 869         ret = ret2;
 870   }
 871   else
 872     *pulOutputTypesSupplied = 0;
 873
 874   return ret;
 875 }