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