git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #define COM_NO_WINDOWS_H
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "winerror.h"
  27 #include "winreg.h"
  28 #include "objbase.h"
  29 #include "dmo.h"
  30
  31 #include "wine/unicode.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(msdmo);
  35
  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 typedef struct
  81 {
  82     IEnumDMOVtbl               *lpVtbl;
  83     DWORD                       ref;
  84     DWORD                       index;
  85     const GUID*                 guidCategory;
  86     DWORD                       dwFlags;
  87     DWORD                       cInTypes;
  88     DMO_PARTIAL_MEDIATYPE       *pInTypes;
  89     DWORD                       cOutTypes;
  90     DMO_PARTIAL_MEDIATYPE       *pOutTypes;
  91     HKEY                        hkey;
  92 } IEnumDMOImpl;
  93
  94 const GUID IID_IEnumDMO = { 0x2c3cd98a, 0x2bfa, 0x4a53,
  95     { 0x9c, 0x27, 0x52, 0x49, 0xba, 0x64, 0xba, 0x0f}};
  96
  97 static struct IEnumDMOVtbl edmovt;
  98
  99 static LPWSTR GUIDToString(LPWSTR lpwstr, REFGUID lpcguid)
 100 {
 101     wsprintfW(lpwstr, szGUIDFmt, lpcguid->Data1, lpcguid->Data2,
 102         lpcguid->Data3, lpcguid->Data4[0], lpcguid->Data4[1],
 103         lpcguid->Data4[2], lpcguid->Data4[3], lpcguid->Data4[4],
 104         lpcguid->Data4[5], lpcguid->Data4[6], lpcguid->Data4[7]);
 105
 106     return lpwstr;
 107 }
 108
 109 static BOOL IsMediaTypeEqual(DMO_PARTIAL_MEDIATYPE* mt1, DMO_PARTIAL_MEDIATYPE* mt2)
 110 {
 111
 112     return (IsEqualCLSID(&mt1->type, &mt2->type) ||
 113             IsEqualCLSID(&mt2->type, &GUID_NULL) ||
 114             IsEqualCLSID(&mt1->type, &GUID_NULL)) &&
 115             (IsEqualCLSID(&mt1->subtype, &mt2->subtype) ||
 116             IsEqualCLSID(&mt2->subtype, &GUID_NULL) ||
 117             IsEqualCLSID(&mt1->subtype, &GUID_NULL));
 118 }
 119
 120 /***************************************************************
 121  * DMORegister
 122  *
 123  * Register a DirectX Media Object.
 124  */
 125 HRESULT WINAPI DMORegister(
 126    LPCWSTR szName,
 127    REFCLSID clsidDMO,
 128    REFGUID guidCategory,
 129    DWORD dwFlags,
 130    DWORD cInTypes,
 131    const DMO_PARTIAL_MEDIATYPE *pInTypes,
 132    DWORD cOutTypes,
 133    const DMO_PARTIAL_MEDIATYPE *pOutTypes
 134 )
 135 {
 136     WCHAR szguid[64];
 137     HRESULT hres;
 138     HKEY hrkey = 0;
 139     HKEY hkey = 0;
 140     HKEY hckey = 0;
 141     HKEY hclskey = 0;
 142
 143     TRACE("%s\n", debugstr_w(szName));
 144
 145     hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &hrkey);
 146     if (ERROR_SUCCESS != hres)
 147         goto lend;
 148
 149     /* Create clsidDMO key under MediaObjects */
 150     hres = RegCreateKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, NULL,
 151         REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
 152     if (ERROR_SUCCESS != hres)
 153         goto lend;
 154
 155     /* Set default Name value */
 156     hres = RegSetValueExW(hkey, NULL, 0, REG_SZ, (const BYTE*) szName,
 157         (strlenW(szName) + 1)) * sizeof(WCHAR);
 158     /* Set InputTypes */
 159     hres = RegSetValueExW(hkey, szDMOInputType, 0, REG_BINARY,
 160         (const BYTE*) pInTypes, cInTypes * sizeof(DMO_PARTIAL_MEDIATYPE));
 161     /* Set OutputTypes */
 162     hres = RegSetValueExW(hkey, szDMOOutputType, 0, REG_BINARY,
 163         (const BYTE*) pOutTypes, cOutTypes * sizeof(DMO_PARTIAL_MEDIATYPE));
 164
 165     if (dwFlags & DMO_REGISTERF_IS_KEYED)
 166     {
 167         /* Create Keyed key */
 168         hres = RegCreateKeyExW(hkey, szDMOKeyed, 0, NULL,
 169             REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
 170         if (ERROR_SUCCESS != hres)
 171             goto lend;
 172         RegCloseKey(hckey);
 173     }
 174
 175     /* Register the category */
 176     hres = RegOpenKeyExW(hrkey, szDMOCategories, 0, KEY_WRITE, &hckey);
 177     if (ERROR_SUCCESS != hres)
 178         goto lend;
 179
 180     RegCloseKey(hkey);
 181
 182     hres = RegOpenKeyExW(hckey, GUIDToString(szguid, guidCategory), 0, KEY_WRITE, &hkey);
 183     if (ERROR_SUCCESS != hres)
 184         goto lend;
 185     hres = RegCreateKeyExW(hkey, GUIDToString(szguid, clsidDMO), 0, NULL,
 186         REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hclskey, NULL);
 187     if (ERROR_SUCCESS != hres)
 188         goto lend;
 189
 190 lend:
 191     if (hkey)
 192         RegCloseKey(hkey);
 193     if (hckey)
 194         RegCloseKey(hckey);
 195     if (hclskey)
 196         RegCloseKey(hclskey);
 197     if (hrkey)
 198         RegCloseKey(hrkey);
 199
 200     TRACE(" hresult=0x%08lx\n", hres);
 201     return hres;
 202 }
 203
 204
 205 /***************************************************************
 206  * DMOUnregister
 207  *
 208  * Unregister a DirectX Media Object.
 209  */
 210 HRESULT WINAPI DMOUnregister(REFCLSID clsidDMO, REFGUID guidCategory)
 211 {
 212     HRESULT hres;
 213     WCHAR szguid[64];
 214     HKEY hrkey = 0;
 215     HKEY hckey = 0;
 216
 217     GUIDToString(szguid, clsidDMO);
 218
 219     TRACE("%s %p\n", debugstr_w(szguid), guidCategory);
 220
 221     hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &hrkey);
 222     if (ERROR_SUCCESS != hres)
 223         goto lend;
 224
 225     hres = RegDeleteKeyW(hrkey, szguid);
 226     if (ERROR_SUCCESS != hres)
 227         goto lend;
 228
 229     hres = RegOpenKeyExW(hrkey, szDMOCategories, 0, KEY_WRITE, &hckey);
 230     if (ERROR_SUCCESS != hres)
 231         goto lend;
 232
 233     hres = RegDeleteKeyW(hckey, szguid);
 234     if (ERROR_SUCCESS != hres)
 235         goto lend;
 236
 237 lend:
 238     if (hckey)
 239         RegCloseKey(hckey);
 240     if (hrkey)
 241         RegCloseKey(hrkey);
 242
 243     return hres;
 244 }
 245
 246
 247 /***************************************************************
 248  * DMOGetName
 249  *
 250  * Get DMP Name from the registry
 251  */
 252 HRESULT WINAPI DMOGetName(REFCLSID clsidDMO, WCHAR* szName)
 253 {
 254     WCHAR szguid[64];
 255     HRESULT hres;
 256     HKEY hrkey = 0;
 257     HKEY hkey = 0;
 258     DWORD count;
 259
 260     TRACE("%s\n", debugstr_guid(clsidDMO));
 261
 262     hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey,
 263         0, KEY_READ, &hrkey);
 264     if (ERROR_SUCCESS != hres)
 265         goto lend;
 266
 267     hres = RegOpenKeyExW(hrkey, GUIDToString(szguid, clsidDMO),
 268         0, KEY_READ, &hkey);
 269     if (ERROR_SUCCESS != hres)
 270         goto lend;
 271
 272     count = 80 * sizeof(WCHAR); /* 80 by API definition */
 273     hres = RegQueryValueExW(hkey, NULL, NULL, NULL,
 274         (LPBYTE) szName, &count);
 275
 276     TRACE(" szName=%s\n", debugstr_w(szName));
 277 lend:
 278     if (hkey)
 279         RegCloseKey(hrkey);
 280     if (hkey)
 281         RegCloseKey(hkey);
 282
 283     return hres;
 284 }
 285
 286
 287 /**************************************************************************
 288 *   IEnumDMO_Destructor
 289 */
 290 static BOOL IEnumDMO_Destructor(IEnumDMO* iface)
 291 {
 292     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 293
 294     TRACE("%p\n", This);
 295
 296     if (This->hkey)
 297         RegCloseKey(This->hkey);
 298
 299     HeapFree(GetProcessHeap(), 0, This->pInTypes);
 300     HeapFree(GetProcessHeap(), 0, This->pOutTypes);
 301
 302     return TRUE;
 303 }
 304
 305
 306 /**************************************************************************
 307  *  IEnumDMO_Constructor
 308  */
 309 IEnumDMO * IEnumDMO_Constructor(
 310     REFGUID guidCategory,
 311     DWORD dwFlags,
 312     DWORD cInTypes,
 313     const DMO_PARTIAL_MEDIATYPE *pInTypes,
 314     DWORD cOutTypes,
 315     const DMO_PARTIAL_MEDIATYPE *pOutTypes)
 316 {
 317     UINT size;
 318     IEnumDMOImpl* lpedmo;
 319     BOOL ret = FALSE;
 320
 321     lpedmo = (IEnumDMOImpl*)HeapAlloc(GetProcessHeap(),
 322         HEAP_ZERO_MEMORY, sizeof(IEnumDMOImpl));
 323
 324     if (lpedmo)
 325     {
 326         lpedmo->ref = 1;
 327         lpedmo->lpVtbl = &edmovt;
 328         lpedmo->index = -1;
 329         lpedmo->guidCategory = guidCategory;
 330         lpedmo->dwFlags = dwFlags;
 331
 332         size = cInTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
 333         lpedmo->pInTypes = HeapAlloc(GetProcessHeap(), 0, size);
 334         if (!lpedmo->pInTypes)
 335             goto lerr;
 336         memcpy(lpedmo->pInTypes, pInTypes, size);
 337         lpedmo->cInTypes = cInTypes;
 338
 339         size = cOutTypes * sizeof(DMO_PARTIAL_MEDIATYPE);
 340         lpedmo->pOutTypes = HeapAlloc(GetProcessHeap(), 0, size);
 341         if (!lpedmo->pOutTypes)
 342             goto lerr;
 343         memcpy(lpedmo->pOutTypes, pOutTypes, size);
 344         lpedmo->cOutTypes = cOutTypes;
 345
 346         /* If not filtering by category enum from media objects root */
 347         if (IsEqualGUID(guidCategory, &GUID_NULL))
 348         {
 349             if (ERROR_SUCCESS == RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey,
 350                 0, KEY_READ, &lpedmo->hkey))
 351                 ret = TRUE;
 352         }
 353         else
 354         {
 355             WCHAR szguid[64];
 356             WCHAR szKey[MAX_PATH];
 357
 358             wsprintfW(szKey, szCat3Fmt, szDMORootKey, szDMOCategories,
 359                 GUIDToString(szguid, guidCategory));
 360             if (ERROR_SUCCESS == RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey,
 361                 0, KEY_READ, &lpedmo->hkey))
 362                 ret = TRUE;
 363         }
 364
 365 lerr:
 366         if(!ret)
 367         {
 368             IEnumDMO_Destructor((IEnumDMO*)lpedmo);
 369             HeapFree(GetProcessHeap(),0,lpedmo);
 370             lpedmo = NULL;
 371         }
 372     }
 373
 374     TRACE("returning %p\n", lpedmo);
 375
 376     return (IEnumDMO*)lpedmo;
 377 }
 378
 379
 380 /******************************************************************************
 381  * IEnumDMO_fnAddRef
 382  */
 383 static ULONG WINAPI IEnumDMO_fnAddRef(IEnumDMO * iface)
 384 {
 385     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 386     return InterlockedIncrement(&This->ref);
 387 }
 388
 389
 390 /**************************************************************************
 391  *  EnumDMO_QueryInterface
 392  */
 393 static HRESULT WINAPI IEnumDMO_fnQueryInterface(
 394     IEnumDMO* iface,
 395     REFIID riid,
 396     LPVOID *ppvObj)
 397 {
 398     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 399
 400     *ppvObj = NULL;
 401
 402     if(IsEqualIID(riid, &IID_IUnknown))
 403         *ppvObj = This;
 404     else if(IsEqualIID(riid, &IID_IEnumDMO))
 405         *ppvObj = (IEnumDMO*)This;
 406
 407     if(*ppvObj)
 408     {
 409         IEnumDMO_fnAddRef((IEnumDMO*)*ppvObj);
 410         return S_OK;
 411     }
 412
 413     return E_NOINTERFACE;
 414 }
 415
 416
 417 /******************************************************************************
 418  * IEnumDMO_fnRelease
 419  */
 420 static ULONG WINAPI IEnumDMO_fnRelease(IEnumDMO * iface)
 421 {
 422     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 423     ULONG refCount = InterlockedDecrement(&This->ref);
 424
 425     if (!refCount)
 426     {
 427         IEnumDMO_Destructor((IEnumDMO*)This);
 428         HeapFree(GetProcessHeap(),0,This);
 429     }
 430     return refCount;
 431 }
 432
 433
 434 /******************************************************************************
 435  * IEnumDMO_fnNext
 436  */
 437 static HRESULT WINAPI IEnumDMO_fnNext(
 438     IEnumDMO * iface,
 439     DWORD cItemsToFetch,
 440     CLSID * pCLSID,
 441     WCHAR ** Names,
 442     DWORD * pcItemsFetched)
 443 {
 444     FILETIME ft;
 445     HKEY hkey;
 446     WCHAR szNextKey[MAX_PATH];
 447     WCHAR szKey[MAX_PATH];
 448     WCHAR szValue[MAX_PATH];
 449     DWORD len;
 450     UINT count = 0;
 451     HRESULT hres = S_OK;
 452
 453     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 454
 455     TRACE("%ld\n", cItemsToFetch);
 456
 457     if (!pCLSID || !Names || !pcItemsFetched)
 458         return E_POINTER;
 459
 460     while (count < cItemsToFetch)
 461     {
 462         This->index++;
 463
 464         hres = RegEnumKeyExW(This->hkey, This->index, szNextKey, &len, NULL, NULL, NULL, &ft);
 465         if (hres != ERROR_SUCCESS)
 466             break;
 467
 468         TRACE("found %s\n", debugstr_w(szNextKey));
 469
 470         if (This->dwFlags & DMO_REGISTERF_IS_KEYED)
 471         {
 472             wsprintfW(szKey, szCat3Fmt, szDMORootKey, szNextKey, szDMOKeyed);
 473             hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
 474             if (ERROR_SUCCESS != hres)
 475                 continue;
 476             RegCloseKey(hkey);
 477         }
 478
 479         wsprintfW(szKey, szCat2Fmt, szDMORootKey, szNextKey);
 480         hres = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
 481
 482         if (This->pInTypes)
 483         {
 484             UINT i, j;
 485             DWORD cInTypes;
 486             DMO_PARTIAL_MEDIATYPE* pInTypes;
 487
 488             len = MAX_PATH * sizeof(WCHAR);
 489             hres = RegQueryValueExW(hkey, szDMOInputType, NULL, NULL, (LPBYTE) szValue, &len);
 490             if (ERROR_SUCCESS != hres)
 491             {
 492                 RegCloseKey(hkey);
 493                 continue;
 494             }
 495
 496             cInTypes = len / sizeof(DMO_PARTIAL_MEDIATYPE);
 497             pInTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
 498
 499             for (i = 0; i < This->cInTypes; i++)
 500             {
 501                 for (j = 0; j < cInTypes; j++)
 502                 {
 503                     if (IsMediaTypeEqual(&pInTypes[j], &This->pInTypes[i]))
 504                         break;
 505                 }
 506
 507                 if (j >= cInTypes)
 508                     break;
 509             }
 510
 511             if (i < This->cInTypes)
 512             {
 513                 RegCloseKey(hkey);
 514                 continue;
 515             }
 516         }
 517
 518         if (This->pOutTypes)
 519         {
 520             UINT i, j;
 521             DWORD cOutTypes;
 522             DMO_PARTIAL_MEDIATYPE* pOutTypes;
 523
 524             len = MAX_PATH * sizeof(WCHAR);
 525             hres = RegQueryValueExW(hkey, szDMOOutputType, NULL, NULL, (LPBYTE) szValue, &len);
 526             if (ERROR_SUCCESS != hres)
 527             {
 528                 RegCloseKey(hkey);
 529                 continue;
 530             }
 531
 532             cOutTypes = len / sizeof(DMO_PARTIAL_MEDIATYPE);
 533             pOutTypes = (DMO_PARTIAL_MEDIATYPE*) szValue;
 534
 535             for (i = 0; i < This->cOutTypes; i++)
 536             {
 537                 for (j = 0; j < cOutTypes; j++)
 538                 {
 539                     if (IsMediaTypeEqual(&pOutTypes[j], &This->pOutTypes[i]))
 540                         break;
 541                 }
 542
 543                 if (j >= cOutTypes)
 544                     break;
 545             }
 546
 547             if (i < This->cOutTypes)
 548             {
 549                 RegCloseKey(hkey);
 550                 continue;
 551             }
 552         }
 553
 554         /* Media object wasn't filtered so add it to return list */
 555         Names[count] = NULL;
 556         len = MAX_PATH * sizeof(WCHAR);
 557         hres = RegQueryValueExW(hkey, NULL, NULL, NULL, (LPBYTE) szValue, &len);
 558         if (ERROR_SUCCESS == hres)
 559         {
 560             Names[count] = HeapAlloc(GetProcessHeap(), 0, strlenW(szValue) + 1);
 561             if (Names[count])
 562                 strcmpW(Names[count], szValue);
 563         }
 564         CLSIDFromString(szNextKey, &pCLSID[count]);
 565
 566         TRACE("found match %s %s\n", debugstr_w(szValue), debugstr_w(szNextKey));
 567         RegCloseKey(hkey);
 568         count++;
 569     }
 570
 571     *pcItemsFetched = count;
 572     if (*pcItemsFetched < cItemsToFetch)
 573         hres = S_FALSE;
 574
 575     return hres;
 576 }
 577
 578
 579 /******************************************************************************
 580  * IEnumDMO_fnSkip
 581  */
 582 static HRESULT WINAPI IEnumDMO_fnSkip(IEnumDMO * iface, DWORD cItemsToSkip)
 583 {
 584     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 585
 586     This->index += cItemsToSkip;
 587
 588     return S_OK;
 589 }
 590
 591
 592 /******************************************************************************
 593  * IEnumDMO_fnReset
 594  */
 595 static HRESULT WINAPI IEnumDMO_fnReset(IEnumDMO * iface)
 596 {
 597     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 598
 599     This->index = -1;
 600
 601     return S_OK;
 602 }
 603
 604
 605 /******************************************************************************
 606  * IEnumDMO_fnClone
 607  */
 608 static HRESULT WINAPI IEnumDMO_fnClone(IEnumDMO * iface, IEnumDMO **ppEnum)
 609 {
 610     IEnumDMOImpl *This = (IEnumDMOImpl *)iface;
 611
 612     FIXME("(%p)->() to (%p)->() E_NOTIMPL\n", This, ppEnum);
 613
 614   return E_NOTIMPL;
 615 }
 616
 617
 618 /***************************************************************
 619  * DMOEnum
 620  *
 621  * Enumerate DirectX Media Objects in the registry.
 622  */
 623 HRESULT WINAPI DMOEnum(
 624     REFGUID guidCategory,
 625     DWORD dwFlags,
 626     DWORD cInTypes,
 627     const DMO_PARTIAL_MEDIATYPE *pInTypes,
 628     DWORD cOutTypes,
 629     const DMO_PARTIAL_MEDIATYPE *pOutTypes,
 630     IEnumDMO **ppEnum)
 631 {
 632     HRESULT hres = E_FAIL;
 633
 634     TRACE("guidCategory=%p dwFlags=0x%08lx cInTypes=%ld cOutTypes=%ld\n",
 635         guidCategory, dwFlags, cInTypes, cOutTypes);
 636
 637     *ppEnum = IEnumDMO_Constructor(guidCategory, dwFlags, cInTypes,
 638         pInTypes, cOutTypes, pOutTypes);
 639     if (*ppEnum)
 640         hres = S_OK;
 641
 642     return hres;
 643 }
 644
 645
 646 static IEnumDMOVtbl edmovt =
 647 {
 648         IEnumDMO_fnQueryInterface,
 649         IEnumDMO_fnAddRef,
 650         IEnumDMO_fnRelease,
 651         IEnumDMO_fnNext,
 652         IEnumDMO_fnSkip,
 653         IEnumDMO_fnReset,
 654         IEnumDMO_fnClone,
 655 };
 656
 657
 658 HRESULT WINAPI DMOGetTypes(REFCLSID a, unsigned long b, unsigned long* c,
 659                            DMO_PARTIAL_MEDIATYPE* d, unsigned long e,
 660                            unsigned long* f, DMO_PARTIAL_MEDIATYPE* g)
 661 {
 662   FIXME("(%p,%lu,%p,%p,%lu,%p,%p),stub!\n",a,b,c,d,e,f,g);
 663
 664   return E_NOTIMPL;
 665 }