dlls/mfplat/main.c

   1 /*
   2  *
   3  * Copyright 2014 Austin English
   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 #include <string.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "winreg.h"
  29
  30 #include "initguid.h"
  31 #include "mfapi.h"
  32 #include "mfidl.h"
  33 #include "mferror.h"
  34
  35 #include "wine/debug.h"
  36 #include "wine/unicode.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  39
  40 static const WCHAR transform_keyW[] = {'M','e','d','i','a','F','o','u','n','d','a','t','i','o','n','\\',
  41                                  'T','r','a','n','s','f','o','r','m','s',0};
  42 static const WCHAR categories_keyW[] = {'M','e','d','i','a','F','o','u','n','d','a','t','i','o','n','\\',
  43                                  'T','r','a','n','s','f','o','r','m','s','\\',
  44                                  'C','a','t','e','g','o','r','i','e','s',0};
  45 static const WCHAR inputtypesW[]  = {'I','n','p','u','t','T','y','p','e','s',0};
  46 static const WCHAR outputtypesW[] = {'O','u','t','p','u','t','T','y','p','e','s',0};
  47 static const WCHAR szGUIDFmt[] =
  48 {
  49     '%','0','8','x','-','%','0','4','x','-','%','0','4','x','-','%','0',
  50     '2','x','%','0','2','x','-','%','0','2','x','%','0','2','x','%','0','2',
  51     'x','%','0','2','x','%','0','2','x','%','0','2','x',0
  52 };
  53
  54 static const BYTE guid_conv_table[256] =
  55 {
  56     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
  57     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
  58     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
  59     0,   1,   2,   3,   4,   5,   6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
  60     0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
  61     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
  62     0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf                             /* 0x60 */
  63 };
  64
  65 static WCHAR* GUIDToString(WCHAR *str, REFGUID guid)
  66 {
  67     sprintfW(str, szGUIDFmt, guid->Data1, guid->Data2,
  68         guid->Data3, guid->Data4[0], guid->Data4[1],
  69         guid->Data4[2], guid->Data4[3], guid->Data4[4],
  70         guid->Data4[5], guid->Data4[6], guid->Data4[7]);
  71
  72     return str;
  73 }
  74
  75 static inline BOOL is_valid_hex(WCHAR c)
  76 {
  77     if (!(((c >= '0') && (c <= '9'))  ||
  78           ((c >= 'a') && (c <= 'f'))  ||
  79           ((c >= 'A') && (c <= 'F'))))
  80         return FALSE;
  81     return TRUE;
  82 }
  83
  84 static BOOL GUIDFromString(LPCWSTR s, GUID *id)
  85 {
  86     int i;
  87
  88     /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
  89
  90     id->Data1 = 0;
  91     for (i = 0; i < 8; i++)
  92     {
  93         if (!is_valid_hex(s[i])) return FALSE;
  94         id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
  95     }
  96     if (s[8]!='-') return FALSE;
  97
  98     id->Data2 = 0;
  99     for (i = 9; i < 13; i++)
 100     {
 101         if (!is_valid_hex(s[i])) return FALSE;
 102         id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
 103     }
 104     if (s[13]!='-') return FALSE;
 105
 106     id->Data3 = 0;
 107     for (i = 14; i < 18; i++)
 108     {
 109         if (!is_valid_hex(s[i])) return FALSE;
 110         id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
 111     }
 112     if (s[18]!='-') return FALSE;
 113
 114     for (i = 19; i < 36; i+=2)
 115     {
 116         if (i == 23)
 117         {
 118             if (s[i]!='-') return FALSE;
 119             i++;
 120         }
 121         if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
 122         id->Data4[(i-19)/2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
 123     }
 124
 125     if (!s[37]) return TRUE;
 126     return FALSE;
 127 }
 128
 129 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
 130 {
 131     switch (reason)
 132     {
 133         case DLL_WINE_PREATTACH:
 134             return FALSE;    /* prefer native version */
 135         case DLL_PROCESS_ATTACH:
 136             DisableThreadLibraryCalls(instance);
 137             break;
 138     }
 139
 140     return TRUE;
 141 }
 142
 143 static HRESULT register_transform(CLSID *clsid, WCHAR *name,
 144                                   UINT32 cinput, MFT_REGISTER_TYPE_INFO *input_types,
 145                                   UINT32 coutput, MFT_REGISTER_TYPE_INFO *output_types)
 146 {
 147     static const WCHAR reg_format[] = {'%','s','\\','%','s',0};
 148     HKEY hclsid = 0;
 149     WCHAR buffer[64];
 150     DWORD size;
 151     WCHAR str[250];
 152
 153     GUIDToString(buffer, clsid);
 154     sprintfW(str, reg_format, transform_keyW, buffer);
 155
 156     if (RegCreateKeyW(HKEY_CLASSES_ROOT, str, &hclsid))
 157         return E_FAIL;
 158
 159     size = (strlenW(name) + 1) * sizeof(WCHAR);
 160     if (RegSetValueExW(hclsid, NULL, 0, REG_SZ, (BYTE *)name, size))
 161         goto err;
 162
 163     if (cinput && input_types)
 164     {
 165         size = cinput * sizeof(MFT_REGISTER_TYPE_INFO);
 166         if (RegSetValueExW(hclsid, inputtypesW, 0, REG_BINARY, (BYTE *)input_types, size))
 167             goto err;
 168     }
 169
 170     if (coutput && output_types)
 171     {
 172         size = coutput * sizeof(MFT_REGISTER_TYPE_INFO);
 173         if (RegSetValueExW(hclsid, outputtypesW, 0, REG_BINARY, (BYTE *)output_types, size))
 174             goto err;
 175     }
 176
 177     RegCloseKey(hclsid);
 178     return S_OK;
 179
 180 err:
 181     RegCloseKey(hclsid);
 182     return E_FAIL;
 183 }
 184
 185 static HRESULT register_category(CLSID *clsid, GUID *category)
 186 {
 187     static const WCHAR reg_format[] = {'%','s','\\','%','s','\\','%','s',0};
 188     HKEY htmp1;
 189     WCHAR guid1[64], guid2[64];
 190     WCHAR str[350];
 191
 192     GUIDToString(guid1, category);
 193     GUIDToString(guid2, clsid);
 194
 195     sprintfW(str, reg_format, categories_keyW, guid1, guid2);
 196
 197     if (RegCreateKeyW(HKEY_CLASSES_ROOT, str, &htmp1))
 198         return E_FAIL;
 199
 200     RegCloseKey(htmp1);
 201     return S_OK;
 202 }
 203
 204 /***********************************************************************
 205  *      MFTRegister (mfplat.@)
 206  */
 207 HRESULT WINAPI MFTRegister(CLSID clsid, GUID category, LPWSTR name, UINT32 flags, UINT32 cinput,
 208                            MFT_REGISTER_TYPE_INFO *input_types, UINT32 coutput,
 209                            MFT_REGISTER_TYPE_INFO *output_types, IMFAttributes *attributes)
 210 {
 211     HRESULT hr;
 212
 213     TRACE("(%s, %s, %s, %x, %u, %p, %u, %p, %p)\n", debugstr_guid(&clsid), debugstr_guid(&category),
 214                                                     debugstr_w(name), flags, cinput, input_types,
 215                                                     coutput, output_types, attributes);
 216
 217     if (attributes)
 218         FIXME("attributes not yet supported.\n");
 219
 220     if (flags)
 221         FIXME("flags not yet supported.\n");
 222
 223     hr = register_transform(&clsid, name, cinput, input_types, coutput, output_types);
 224     if(FAILED(hr))
 225         ERR("Failed to write register transform\n");
 226
 227     if (SUCCEEDED(hr))
 228         hr = register_category(&clsid, &category);
 229
 230     return hr;
 231 }
 232
 233 static BOOL match_type(const WCHAR *clsid_str, const WCHAR *type_str, MFT_REGISTER_TYPE_INFO *type)
 234 {
 235     HKEY htransform, hfilter;
 236     DWORD reg_type, size;
 237     LONG ret = FALSE;
 238     MFT_REGISTER_TYPE_INFO *info = NULL;
 239     int i;
 240
 241     if (RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
 242         return FALSE;
 243
 244     if (RegOpenKeyW(htransform, clsid_str, &hfilter))
 245     {
 246         RegCloseKey(htransform);
 247         return FALSE;
 248     }
 249
 250     if (RegQueryValueExW(hfilter, type_str, NULL, &reg_type, NULL, &size) != ERROR_SUCCESS)
 251         goto out;
 252
 253     if (reg_type != REG_BINARY)
 254         goto out;
 255
 256     if (!size || size % (sizeof(MFT_REGISTER_TYPE_INFO)) != 0)
 257         goto out;
 258
 259     info = HeapAlloc(GetProcessHeap(), 0, size);
 260     if (!info)
 261         goto out;
 262
 263     if (RegQueryValueExW(hfilter, type_str, NULL, &reg_type, (LPBYTE)info, &size) != ERROR_SUCCESS)
 264         goto out;
 265
 266     for (i = 0; i < size / sizeof(MFT_REGISTER_TYPE_INFO); i++)
 267     {
 268         if (IsEqualGUID(&info[i].guidMajorType, &type->guidMajorType) &&
 269             IsEqualGUID(&info[i].guidSubtype,   &type->guidSubtype))
 270         {
 271             ret = TRUE;
 272             break;
 273         }
 274     }
 275
 276 out:
 277     HeapFree(GetProcessHeap(), 0, info);
 278     RegCloseKey(hfilter);
 279     RegCloseKey(htransform);
 280     return ret;
 281 }
 282
 283 /***********************************************************************
 284  *      MFTEnum (mfplat.@)
 285  */
 286 HRESULT WINAPI MFTEnum(GUID category, UINT32 flags, MFT_REGISTER_TYPE_INFO *input_type,
 287                        MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes,
 288                        CLSID **pclsids, UINT32 *pcount)
 289 {
 290     WCHAR buffer[64], clsid_str[MAX_PATH] = {0};
 291     HKEY hcategory, hlist;
 292     DWORD index = 0;
 293     DWORD size = MAX_PATH;
 294     CLSID *clsids = NULL;
 295     UINT32 count = 0;
 296     LONG ret;
 297
 298     TRACE("(%s, %x, %p, %p, %p, %p, %p)\n", debugstr_guid(&category), flags, input_type,
 299                                             output_type, attributes, pclsids, pcount);
 300
 301     if (!pclsids || !pcount)
 302         return E_INVALIDARG;
 303
 304     if (RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
 305         return E_FAIL;
 306
 307     GUIDToString(buffer, &category);
 308
 309     ret = RegOpenKeyW(hcategory, buffer, &hlist);
 310     RegCloseKey(hcategory);
 311     if (ret) return E_FAIL;
 312
 313     while (RegEnumKeyExW(hlist, index, clsid_str, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
 314     {
 315         GUID clsid;
 316         void *tmp;
 317
 318         if (!GUIDFromString(clsid_str, &clsid))
 319             goto next;
 320
 321         if (output_type && !match_type(clsid_str, outputtypesW, output_type))
 322             goto next;
 323
 324         if (input_type && !match_type(clsid_str, inputtypesW, input_type))
 325             goto next;
 326
 327         tmp = CoTaskMemRealloc(clsids, (count + 1) * sizeof(GUID));
 328         if (!tmp)
 329         {
 330             CoTaskMemFree(clsids);
 331             RegCloseKey(hlist);
 332             return E_OUTOFMEMORY;
 333         }
 334
 335         clsids = tmp;
 336         clsids[count++] = clsid;
 337
 338     next:
 339         size = MAX_PATH;
 340         index++;
 341     }
 342
 343     *pclsids = clsids;
 344     *pcount = count;
 345
 346     RegCloseKey(hlist);
 347     return S_OK;
 348 }
 349
 350 /***********************************************************************
 351  *      MFTEnumEx (mfplat.@)
 352  */
 353 HRESULT WINAPI MFTEnumEx(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
 354                          const MFT_REGISTER_TYPE_INFO *output_type, IMFActivate ***activate,
 355                          UINT32 *pcount)
 356 {
 357     FIXME("(%s, %x, %p, %p, %p, %p): stub\n", debugstr_guid(&category), flags, input_type,
 358                                               output_type, activate, pcount);
 359
 360     *pcount = 0;
 361     return S_OK;
 362 }
 363
 364 /***********************************************************************
 365  *      MFTUnregister (mfplat.@)
 366  */
 367 HRESULT WINAPI MFTUnregister(CLSID clsid)
 368 {
 369     WCHAR buffer[64], category[MAX_PATH];
 370     HKEY htransform, hcategory, htmp;
 371     DWORD size = MAX_PATH;
 372     DWORD index = 0;
 373
 374     TRACE("(%s)\n", debugstr_guid(&clsid));
 375
 376     GUIDToString(buffer, &clsid);
 377
 378     if (!RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
 379     {
 380         RegDeleteKeyW(htransform, buffer);
 381         RegCloseKey(htransform);
 382     }
 383
 384     if (!RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
 385     {
 386         while (RegEnumKeyExW(hcategory, index, category, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
 387         {
 388             if (!RegOpenKeyW(hcategory, category, &htmp))
 389             {
 390                 RegDeleteKeyW(htmp, buffer);
 391                 RegCloseKey(htmp);
 392             }
 393             size = MAX_PATH;
 394             index++;
 395         }
 396         RegCloseKey(hcategory);
 397     }
 398
 399     return S_OK;
 400 }
 401
 402 /***********************************************************************
 403  *      MFStartup (mfplat.@)
 404  */
 405 HRESULT WINAPI MFStartup(ULONG version, DWORD flags)
 406 {
 407     FIXME("(%u, %u): stub\n", version, flags);
 408     return MF_E_BAD_STARTUP_VERSION;
 409 }
 410
 411 /***********************************************************************
 412  *      MFShutdown (mfplat.@)
 413  */
 414 HRESULT WINAPI MFShutdown(void)
 415 {
 416     FIXME("(): stub\n");
 417     return S_OK;
 418 }
 419
 420 static HRESULT WINAPI MFPluginControl_QueryInterface(IMFPluginControl *iface, REFIID riid, void **ppv)
 421 {
 422     if(IsEqualGUID(riid, &IID_IUnknown)) {
 423         TRACE("(IID_IUnknown %p)\n", ppv);
 424         *ppv = iface;
 425     }else if(IsEqualGUID(riid, &IID_IMFPluginControl)) {
 426         TRACE("(IID_IMFPluginControl %p)\n", ppv);
 427         *ppv = iface;
 428     }else {
 429         FIXME("(%s %p)\n", debugstr_guid(riid), ppv);
 430         *ppv = NULL;
 431         return E_NOINTERFACE;
 432     }
 433
 434     IUnknown_AddRef((IUnknown*)*ppv);
 435     return S_OK;
 436 }
 437
 438 static ULONG WINAPI MFPluginControl_AddRef(IMFPluginControl *iface)
 439 {
 440     TRACE("\n");
 441     return 2;
 442 }
 443
 444 static ULONG WINAPI MFPluginControl_Release(IMFPluginControl *iface)
 445 {
 446     TRACE("\n");
 447     return 1;
 448 }
 449
 450 static HRESULT WINAPI MFPluginControl_GetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
 451         const WCHAR *selector, CLSID *clsid)
 452 {
 453     FIXME("(%d %s %p)\n", plugin_type, debugstr_w(selector), clsid);
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI MFPluginControl_GetPreferredClsidByIndex(IMFPluginControl *iface, DWORD plugin_type,
 458         DWORD index, WCHAR **selector, CLSID *clsid)
 459 {
 460     FIXME("(%d %d %p %p)\n", plugin_type, index, selector, clsid);
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI MFPluginControl_SetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
 465         const WCHAR *selector, const CLSID *clsid)
 466 {
 467     FIXME("(%d %s %s)\n", plugin_type, debugstr_w(selector), debugstr_guid(clsid));
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI MFPluginControl_IsDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid)
 472 {
 473     FIXME("(%d %s)\n", plugin_type, debugstr_guid(clsid));
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT WINAPI MFPluginControl_GetDisabledByIndex(IMFPluginControl *iface, DWORD plugin_type, DWORD index, CLSID *clsid)
 478 {
 479     FIXME("(%d %d %p)\n", plugin_type, index, clsid);
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI MFPluginControl_SetDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid, BOOL disabled)
 484 {
 485     FIXME("(%d %s %x)\n", plugin_type, debugstr_guid(clsid), disabled);
 486     return E_NOTIMPL;
 487 }
 488
 489 static const IMFPluginControlVtbl MFPluginControlVtbl = {
 490     MFPluginControl_QueryInterface,
 491     MFPluginControl_AddRef,
 492     MFPluginControl_Release,
 493     MFPluginControl_GetPreferredClsid,
 494     MFPluginControl_GetPreferredClsidByIndex,
 495     MFPluginControl_SetPreferredClsid,
 496     MFPluginControl_IsDisabled,
 497     MFPluginControl_GetDisabledByIndex,
 498     MFPluginControl_SetDisabled
 499 };
 500
 501 static IMFPluginControl plugin_control = { &MFPluginControlVtbl };
 502
 503 /***********************************************************************
 504  *      MFGetPluginControl (mfplat.@)
 505  */
 506 HRESULT WINAPI MFGetPluginControl(IMFPluginControl **ret)
 507 {
 508     TRACE("(%p)\n", ret);
 509
 510     *ret = &plugin_control;
 511     return S_OK;
 512 }
 513
 514 typedef struct _mfattributes
 515 {
 516     IMFAttributes IMFAttributes_iface;
 517     LONG ref;
 518 } mfattributes;
 519
 520 static inline mfattributes *impl_from_IMFAttributes(IMFAttributes *iface)
 521 {
 522     return CONTAINING_RECORD(iface, mfattributes, IMFAttributes_iface);
 523 }
 524
 525 static HRESULT WINAPI mfattributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **out)
 526 {
 527     mfattributes *This = impl_from_IMFAttributes(iface);
 528
 529     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
 530
 531     if(IsEqualGUID(riid, &IID_IUnknown) ||
 532        IsEqualGUID(riid, &IID_IMFAttributes))
 533     {
 534         *out = &This->IMFAttributes_iface;
 535     }
 536     else
 537     {
 538         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 539         *out = NULL;
 540         return E_NOINTERFACE;
 541     }
 542
 543     IUnknown_AddRef((IUnknown*)*out);
 544     return S_OK;
 545 }
 546
 547 static ULONG WINAPI mfattributes_AddRef(IMFAttributes *iface)
 548 {
 549     mfattributes *This = impl_from_IMFAttributes(iface);
 550     ULONG ref = InterlockedIncrement(&This->ref);
 551
 552     TRACE("(%p) ref=%u\n", This, ref);
 553
 554     return ref;
 555 }
 556
 557 static ULONG WINAPI mfattributes_Release(IMFAttributes *iface)
 558 {
 559     mfattributes *This = impl_from_IMFAttributes(iface);
 560     ULONG ref = InterlockedDecrement(&This->ref);
 561
 562     TRACE("(%p) ref=%u\n", This, ref);
 563
 564     if (!ref)
 565     {
 566         HeapFree(GetProcessHeap(), 0, This);
 567     }
 568
 569     return ref;
 570 }
 571
 572 static HRESULT WINAPI mfattributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
 573 {
 574     mfattributes *This = impl_from_IMFAttributes(iface);
 575
 576     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
 577
 578     return E_NOTIMPL;
 579 }
 580
 581 static HRESULT WINAPI mfattributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 582 {
 583     mfattributes *This = impl_from_IMFAttributes(iface);
 584
 585     FIXME("%p, %s, %p\n", This, debugstr_guid(key), type);
 586
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI mfattributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 591 {
 592     mfattributes *This = impl_from_IMFAttributes(iface);
 593
 594     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, result);
 595
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI mfattributes_Compare(IMFAttributes *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
 600                 BOOL *result)
 601 {
 602     mfattributes *This = impl_from_IMFAttributes(iface);
 603
 604     FIXME("%p, %p, %d, %p\n", This, theirs, type, result);
 605
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI mfattributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
 610 {
 611     mfattributes *This = impl_from_IMFAttributes(iface);
 612
 613     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
 614
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT WINAPI mfattributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
 619 {
 620     mfattributes *This = impl_from_IMFAttributes(iface);
 621
 622     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
 623
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT WINAPI mfattributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
 628 {
 629     mfattributes *This = impl_from_IMFAttributes(iface);
 630
 631     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
 632
 633     return E_NOTIMPL;
 634 }
 635
 636 static HRESULT WINAPI mfattributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
 637 {
 638     mfattributes *This = impl_from_IMFAttributes(iface);
 639
 640     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
 641
 642     return E_NOTIMPL;
 643 }
 644
 645 static HRESULT WINAPI mfattributes_GetStringLength(IMFAttributes *iface, REFGUID key, UINT32 *length)
 646 {
 647     mfattributes *This = impl_from_IMFAttributes(iface);
 648
 649     FIXME("%p, %s, %p\n", This, debugstr_guid(key), length);
 650
 651     return E_NOTIMPL;
 652 }
 653
 654 static HRESULT WINAPI mfattributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
 655                 UINT32 size, UINT32 *length)
 656 {
 657     mfattributes *This = impl_from_IMFAttributes(iface);
 658
 659     FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), value, size, length);
 660
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI mfattributes_GetAllocatedString(IMFAttributes *iface, REFGUID key,
 665                                       WCHAR **value, UINT32 *length)
 666 {
 667     mfattributes *This = impl_from_IMFAttributes(iface);
 668
 669     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, length);
 670
 671     return E_NOTIMPL;
 672 }
 673
 674 static HRESULT WINAPI mfattributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
 675 {
 676     mfattributes *This = impl_from_IMFAttributes(iface);
 677
 678     FIXME("%p, %s, %p\n", This, debugstr_guid(key), size);
 679
 680     return E_NOTIMPL;
 681 }
 682
 683 static HRESULT WINAPI mfattributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
 684                 UINT32 bufsize, UINT32 *blobsize)
 685 {
 686     mfattributes *This = impl_from_IMFAttributes(iface);
 687
 688     FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), buf, bufsize, blobsize);
 689
 690     return E_NOTIMPL;
 691 }
 692
 693 static HRESULT WINAPI mfattributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 694 {
 695     mfattributes *This = impl_from_IMFAttributes(iface);
 696
 697     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), buf, size);
 698
 699     return E_NOTIMPL;
 700 }
 701
 702 static HRESULT WINAPI mfattributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **ppv)
 703 {
 704     mfattributes *This = impl_from_IMFAttributes(iface);
 705
 706     FIXME("%p, %s, %s, %p\n", This, debugstr_guid(key), debugstr_guid(riid), ppv);
 707
 708     return E_NOTIMPL;
 709 }
 710
 711 static HRESULT WINAPI mfattributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT Value)
 712 {
 713     mfattributes *This = impl_from_IMFAttributes(iface);
 714
 715     FIXME("%p, %s, %p\n", This, debugstr_guid(key), Value);
 716
 717     return E_NOTIMPL;
 718 }
 719
 720 static HRESULT WINAPI mfattributes_DeleteItem(IMFAttributes *iface, REFGUID key)
 721 {
 722     mfattributes *This = impl_from_IMFAttributes(iface);
 723
 724     FIXME("%p, %s\n", This, debugstr_guid(key));
 725
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI mfattributes_DeleteAllItems(IMFAttributes *iface)
 730 {
 731     mfattributes *This = impl_from_IMFAttributes(iface);
 732
 733     FIXME("%p\n", This);
 734
 735     return E_NOTIMPL;
 736 }
 737
 738 static HRESULT WINAPI mfattributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
 739 {
 740     mfattributes *This = impl_from_IMFAttributes(iface);
 741
 742     FIXME("%p, %s, %d\n", This, debugstr_guid(key), value);
 743
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI mfattributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
 748 {
 749     mfattributes *This = impl_from_IMFAttributes(iface);
 750
 751     FIXME("%p, %s, %s\n", This, debugstr_guid(key), wine_dbgstr_longlong(value));
 752
 753     return E_NOTIMPL;
 754 }
 755
 756 static HRESULT WINAPI mfattributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
 757 {
 758     mfattributes *This = impl_from_IMFAttributes(iface);
 759
 760     FIXME("%p, %s, %f\n", This, debugstr_guid(key), value);
 761
 762     return E_NOTIMPL;
 763 }
 764
 765 static HRESULT WINAPI mfattributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
 766 {
 767     mfattributes *This = impl_from_IMFAttributes(iface);
 768
 769     FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_guid(value));
 770
 771     return E_NOTIMPL;
 772 }
 773
 774 static HRESULT WINAPI mfattributes_SetString(IMFAttributes *iface, REFGUID key, const WCHAR *value)
 775 {
 776     mfattributes *This = impl_from_IMFAttributes(iface);
 777
 778     FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_w(value));
 779
 780     return E_NOTIMPL;
 781 }
 782
 783 static HRESULT WINAPI mfattributes_SetBlob(IMFAttributes *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 784 {
 785     mfattributes *This = impl_from_IMFAttributes(iface);
 786
 787     FIXME("%p, %s, %p, %d\n", This, debugstr_guid(key), buf, size);
 788
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI mfattributes_SetUnknown(IMFAttributes *iface, REFGUID key, IUnknown *unknown)
 793 {
 794     mfattributes *This = impl_from_IMFAttributes(iface);
 795
 796     FIXME("%p, %s, %p\n", This, debugstr_guid(key), unknown);
 797
 798     return E_NOTIMPL;
 799 }
 800
 801 static HRESULT WINAPI mfattributes_LockStore(IMFAttributes *iface)
 802 {
 803     mfattributes *This = impl_from_IMFAttributes(iface);
 804
 805     FIXME("%p\n", This);
 806
 807     return E_NOTIMPL;
 808 }
 809
 810 static HRESULT WINAPI mfattributes_UnlockStore(IMFAttributes *iface)
 811 {
 812     mfattributes *This = impl_from_IMFAttributes(iface);
 813
 814     FIXME("%p\n", This);
 815
 816     return E_NOTIMPL;
 817 }
 818
 819 static HRESULT WINAPI mfattributes_GetCount(IMFAttributes *iface, UINT32 *items)
 820 {
 821     mfattributes *This = impl_from_IMFAttributes(iface);
 822
 823     FIXME("%p, %p\n", This, items);
 824
 825     if(items)
 826         *items = 0;
 827
 828     return E_NOTIMPL;
 829 }
 830
 831 static HRESULT WINAPI mfattributes_GetItemByIndex(IMFAttributes *iface, UINT32 index, GUID *key, PROPVARIANT *value)
 832 {
 833     mfattributes *This = impl_from_IMFAttributes(iface);
 834
 835     FIXME("%p, %d, %p, %p\n", This, index, key, value);
 836
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI mfattributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
 841 {
 842     mfattributes *This = impl_from_IMFAttributes(iface);
 843
 844     FIXME("%p, %p\n", This, dest);
 845
 846     return E_NOTIMPL;
 847 }
 848
 849 static const IMFAttributesVtbl mfattributes_vtbl =
 850 {
 851     mfattributes_QueryInterface,
 852     mfattributes_AddRef,
 853     mfattributes_Release,
 854     mfattributes_GetItem,
 855     mfattributes_GetItemType,
 856     mfattributes_CompareItem,
 857     mfattributes_Compare,
 858     mfattributes_GetUINT32,
 859     mfattributes_GetUINT64,
 860     mfattributes_GetDouble,
 861     mfattributes_GetGUID,
 862     mfattributes_GetStringLength,
 863     mfattributes_GetString,
 864     mfattributes_GetAllocatedString,
 865     mfattributes_GetBlobSize,
 866     mfattributes_GetBlob,
 867     mfattributes_GetAllocatedBlob,
 868     mfattributes_GetUnknown,
 869     mfattributes_SetItem,
 870     mfattributes_DeleteItem,
 871     mfattributes_DeleteAllItems,
 872     mfattributes_SetUINT32,
 873     mfattributes_SetUINT64,
 874     mfattributes_SetDouble,
 875     mfattributes_SetGUID,
 876     mfattributes_SetString,
 877     mfattributes_SetBlob,
 878     mfattributes_SetUnknown,
 879     mfattributes_LockStore,
 880     mfattributes_UnlockStore,
 881     mfattributes_GetCount,
 882     mfattributes_GetItemByIndex,
 883     mfattributes_CopyAllItems
 884 };
 885
 886 /***********************************************************************
 887  *      MFCreateAttributes (mfplat.@)
 888  */
 889 HRESULT WINAPI MFCreateAttributes(IMFAttributes **attributes, UINT32 size)
 890 {
 891     mfattributes *object;
 892
 893     TRACE("%p, %d\n", attributes, size);
 894
 895     object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
 896     if(!object)
 897         return E_OUTOFMEMORY;
 898
 899     object->ref = 1;
 900     object->IMFAttributes_iface.lpVtbl = &mfattributes_vtbl;
 901
 902     *attributes = &object->IMFAttributes_iface;
 903     return S_OK;
 904 }
 905
 906 typedef struct _mfsourceresolver
 907 {
 908     IMFSourceResolver IMFSourceResolver_iface;
 909     LONG ref;
 910 } mfsourceresolver;
 911
 912 static inline mfsourceresolver *impl_from_IMFSourceResolver(IMFSourceResolver *iface)
 913 {
 914     return CONTAINING_RECORD(iface, mfsourceresolver, IMFSourceResolver_iface);
 915 }
 916
 917 static HRESULT WINAPI mfsourceresolver_QueryInterface(IMFSourceResolver *iface, REFIID riid, void **obj)
 918 {
 919     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
 920
 921     TRACE("(%p->(%s, %p)\n", This, debugstr_guid(riid), obj);
 922
 923     if (IsEqualIID(riid, &IID_IMFSourceResolver) ||
 924             IsEqualIID(riid, &IID_IUnknown))
 925     {
 926         *obj = &This->IMFSourceResolver_iface;
 927     }
 928     else
 929     {
 930         *obj = NULL;
 931         FIXME("unsupported interface %s\n", debugstr_guid(riid));
 932         return E_NOINTERFACE;
 933     }
 934
 935     IUnknown_AddRef((IUnknown *)*obj);
 936     return S_OK;
 937 }
 938
 939 static ULONG WINAPI mfsourceresolver_AddRef(IMFSourceResolver *iface)
 940 {
 941     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
 942     ULONG ref = InterlockedIncrement(&This->ref);
 943
 944     TRACE("(%p)->(%u)\n", This, ref);
 945
 946     return ref;
 947 }
 948
 949 static ULONG WINAPI mfsourceresolver_Release(IMFSourceResolver *iface)
 950 {
 951     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
 952     ULONG ref = InterlockedDecrement(&This->ref);
 953
 954     TRACE("(%p)->(%u)\n", This, ref);
 955
 956     if (!ref)
 957         HeapFree(GetProcessHeap(), 0, This);
 958
 959     return ref;
 960 }
 961
 962 static HRESULT WINAPI mfsourceresolver_CreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
 963     DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
 964 {
 965     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
 966
 967     FIXME("(%p)->(%s, %#x, %p, %p, %p): stub\n", This, debugstr_w(url), flags, props, obj_type, object);
 968
 969     return E_NOTIMPL;
 970 }
 971
 972 static HRESULT WINAPI mfsourceresolver_CreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
 973     const WCHAR *url, DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
 974 {
 975     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
 976
 977     FIXME("(%p)->(%p, %s, %#x, %p, %p, %p): stub\n", This, stream, debugstr_w(url), flags, props, obj_type, object);
 978
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT WINAPI mfsourceresolver_BeginCreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
 983     DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *unk_state)
 984 {
 985     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
 986
 987     FIXME("(%p)->(%s, %#x, %p, %p, %p, %p): stub\n", This, debugstr_w(url), flags, props, cancel_cookie,
 988         callback, unk_state);
 989
 990     return E_NOTIMPL;
 991 }
 992
 993 static HRESULT WINAPI mfsourceresolver_EndCreateObjectFromURL(IMFSourceResolver *iface, IMFAsyncResult *result,
 994     MF_OBJECT_TYPE *obj_type, IUnknown **object)
 995 {
 996     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
 997
 998     FIXME("(%p)->(%p, %p, %p): stub\n", This, result, obj_type, object);
 999
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI mfsourceresolver_BeginCreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
1004     const WCHAR *url, DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback,
1005     IUnknown *unk_state)
1006 {
1007     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1008
1009     FIXME("(%p)->(%p, %s, %#x, %p, %p, %p, %p): stub\n", This, stream, debugstr_w(url), flags, props, cancel_cookie,
1010         callback, unk_state);
1011
1012     return E_NOTIMPL;
1013 }
1014
1015 static HRESULT WINAPI mfsourceresolver_EndCreateObjectFromByteStream(IMFSourceResolver *iface, IMFAsyncResult *result,
1016     MF_OBJECT_TYPE *obj_type, IUnknown **object)
1017 {
1018     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1019
1020     FIXME("(%p)->(%p, %p, %p): stub\n", This, result, obj_type, object);
1021
1022     return E_NOTIMPL;
1023 }
1024
1025 static HRESULT WINAPI mfsourceresolver_CancelObjectCreation(IMFSourceResolver *iface, IUnknown *cancel_cookie)
1026 {
1027     mfsourceresolver *This = impl_from_IMFSourceResolver(iface);
1028
1029     FIXME("(%p)->(%p): stub\n", This, cancel_cookie);
1030
1031     return E_NOTIMPL;
1032 }
1033
1034 static const IMFSourceResolverVtbl mfsourceresolvervtbl =
1035 {
1036    mfsourceresolver_QueryInterface,
1037    mfsourceresolver_AddRef,
1038    mfsourceresolver_Release,
1039    mfsourceresolver_CreateObjectFromURL,
1040    mfsourceresolver_CreateObjectFromByteStream,
1041    mfsourceresolver_BeginCreateObjectFromURL,
1042    mfsourceresolver_EndCreateObjectFromURL,
1043    mfsourceresolver_BeginCreateObjectFromByteStream,
1044    mfsourceresolver_EndCreateObjectFromByteStream,
1045    mfsourceresolver_CancelObjectCreation,
1046 };
1047
1048 /***********************************************************************
1049  *      MFCreateSourceResolver (mfplat.@)
1050  */
1051 HRESULT WINAPI MFCreateSourceResolver(IMFSourceResolver **resolver)
1052 {
1053     mfsourceresolver *object;
1054
1055     TRACE("%p\n", resolver);
1056
1057     if (!resolver)
1058         return E_POINTER;
1059
1060     object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
1061     if (!object)
1062         return E_OUTOFMEMORY;
1063
1064     object->IMFSourceResolver_iface.lpVtbl = &mfsourceresolvervtbl;
1065     object->ref = 1;
1066
1067     *resolver = &object->IMFSourceResolver_iface;
1068     return S_OK;
1069 }
1070
1071 typedef struct _mfmediatype
1072 {
1073     IMFMediaType IMFMediaType_iface;
1074     LONG ref;
1075 } mfmediatype;
1076
1077 static inline mfmediatype *impl_from_IMFMediaType(IMFMediaType *iface)
1078 {
1079     return CONTAINING_RECORD(iface, mfmediatype, IMFMediaType_iface);
1080 }
1081
1082 static HRESULT WINAPI mediatype_QueryInterface(IMFMediaType *iface, REFIID riid, void **object)
1083 {
1084     mfmediatype *This = impl_from_IMFMediaType(iface);
1085
1086     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), object);
1087
1088     if(IsEqualGUID(riid, &IID_IUnknown) ||
1089        IsEqualGUID(riid, &IID_IMFAttributes) ||
1090        IsEqualGUID(riid, &IID_IMFMediaType))
1091     {
1092         *object = &This->IMFMediaType_iface;
1093     }
1094     else
1095     {
1096         FIXME("(%s, %p)\n", debugstr_guid(riid), object);
1097         *object = NULL;
1098         return E_NOINTERFACE;
1099     }
1100
1101     IUnknown_AddRef((IUnknown*)*object);
1102     return S_OK;
1103 }
1104
1105 static ULONG WINAPI mediatype_AddRef(IMFMediaType *iface)
1106 {
1107     mfmediatype *This = impl_from_IMFMediaType(iface);
1108     ULONG ref = InterlockedIncrement(&This->ref);
1109
1110     TRACE("(%p) ref=%u\n", This, ref);
1111
1112     return ref;
1113 }
1114
1115 static ULONG WINAPI mediatype_Release(IMFMediaType *iface)
1116 {
1117     mfmediatype *This = impl_from_IMFMediaType(iface);
1118     ULONG ref = InterlockedDecrement(&This->ref);
1119
1120     TRACE("(%p) ref=%u\n", This, ref);
1121
1122     if (!ref)
1123     {
1124         HeapFree(GetProcessHeap(), 0, This);
1125     }
1126
1127     return ref;
1128 }
1129
1130 static HRESULT WINAPI mediatype_GetItem(IMFMediaType *iface, REFGUID key, PROPVARIANT *value)
1131 {
1132     mfmediatype *This = impl_from_IMFMediaType(iface);
1133
1134     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1135
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI mediatype_GetItemType(IMFMediaType *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1140 {
1141     mfmediatype *This = impl_from_IMFMediaType(iface);
1142
1143     FIXME("%p, %s, %p\n", This, debugstr_guid(key), type);
1144
1145     return E_NOTIMPL;
1146 }
1147
1148 static HRESULT WINAPI mediatype_CompareItem(IMFMediaType *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
1149 {
1150     mfmediatype *This = impl_from_IMFMediaType(iface);
1151
1152     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, result);
1153
1154     return E_NOTIMPL;
1155 }
1156
1157 static HRESULT WINAPI mediatype_Compare(IMFMediaType *iface, IMFAttributes *attrs, MF_ATTRIBUTES_MATCH_TYPE type,
1158                 BOOL *result)
1159 {
1160     mfmediatype *This = impl_from_IMFMediaType(iface);
1161
1162     FIXME("%p, %p, %d, %p\n", This, attrs, type, result);
1163
1164     return E_NOTIMPL;
1165 }
1166
1167 static HRESULT WINAPI mediatype_GetUINT32(IMFMediaType *iface, REFGUID key, UINT32 *value)
1168 {
1169     mfmediatype *This = impl_from_IMFMediaType(iface);
1170
1171     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1172
1173     return E_NOTIMPL;
1174 }
1175
1176 static HRESULT WINAPI mediatype_GetUINT64(IMFMediaType *iface, REFGUID key, UINT64 *value)
1177 {
1178     mfmediatype *This = impl_from_IMFMediaType(iface);
1179
1180     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1181
1182     return E_NOTIMPL;
1183 }
1184
1185 static HRESULT WINAPI mediatype_GetDouble(IMFMediaType *iface, REFGUID key, double *value)
1186 {
1187     mfmediatype *This = impl_from_IMFMediaType(iface);
1188
1189     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1190
1191     return E_NOTIMPL;
1192 }
1193
1194 static HRESULT WINAPI mediatype_GetGUID(IMFMediaType *iface, REFGUID key, GUID *value)
1195 {
1196     mfmediatype *This = impl_from_IMFMediaType(iface);
1197
1198     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1199
1200     return E_NOTIMPL;
1201 }
1202
1203 static HRESULT WINAPI mediatype_GetStringLength(IMFMediaType *iface, REFGUID key, UINT32 *length)
1204 {
1205     mfmediatype *This = impl_from_IMFMediaType(iface);
1206
1207     FIXME("%p, %s, %p\n", This, debugstr_guid(key), length);
1208
1209     return E_NOTIMPL;
1210 }
1211
1212 static HRESULT WINAPI mediatype_GetString(IMFMediaType *iface, REFGUID key, WCHAR *value,
1213                 UINT32 size, UINT32 *length)
1214 {
1215     mfmediatype *This = impl_from_IMFMediaType(iface);
1216
1217     FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), value, size, length);
1218
1219     return E_NOTIMPL;
1220 }
1221
1222 static HRESULT WINAPI mediatype_GetAllocatedString(IMFMediaType *iface, REFGUID key,
1223                 WCHAR **value, UINT32 *length)
1224 {
1225     mfmediatype *This = impl_from_IMFMediaType(iface);
1226
1227     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, length);
1228
1229     return E_NOTIMPL;
1230 }
1231
1232 static HRESULT WINAPI mediatype_GetBlobSize(IMFMediaType *iface, REFGUID key, UINT32 *size)
1233 {
1234     mfmediatype *This = impl_from_IMFMediaType(iface);
1235
1236     FIXME("%p, %s, %p\n", This, debugstr_guid(key), size);
1237
1238     return E_NOTIMPL;
1239 }
1240
1241 static HRESULT WINAPI mediatype_GetBlob(IMFMediaType *iface, REFGUID key, UINT8 *buf,
1242                 UINT32 bufsize, UINT32 *blobsize)
1243 {
1244     mfmediatype *This = impl_from_IMFMediaType(iface);
1245
1246     FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), buf, bufsize, blobsize);
1247
1248     return E_NOTIMPL;
1249 }
1250
1251 static HRESULT WINAPI mediatype_GetAllocatedBlob(IMFMediaType *iface, REFGUID key, UINT8 **buf, UINT32 *size)
1252 {
1253     mfmediatype *This = impl_from_IMFMediaType(iface);
1254
1255     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), buf, size);
1256
1257     return E_NOTIMPL;
1258 }
1259
1260 static HRESULT WINAPI mediatype_GetUnknown(IMFMediaType *iface, REFGUID key, REFIID riid, void **ppv)
1261 {
1262     mfmediatype *This = impl_from_IMFMediaType(iface);
1263
1264     FIXME("%p, %s, %s, %p\n", This, debugstr_guid(key), debugstr_guid(riid), ppv);
1265
1266     return E_NOTIMPL;
1267 }
1268
1269 static HRESULT WINAPI mediatype_SetItem(IMFMediaType *iface, REFGUID key, REFPROPVARIANT value)
1270 {
1271     mfmediatype *This = impl_from_IMFMediaType(iface);
1272
1273     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1274
1275     return E_NOTIMPL;
1276 }
1277
1278 static HRESULT WINAPI mediatype_DeleteItem(IMFMediaType *iface, REFGUID key)
1279 {
1280     mfmediatype *This = impl_from_IMFMediaType(iface);
1281
1282     FIXME("%p, %s\n", This, debugstr_guid(key));
1283
1284     return E_NOTIMPL;
1285 }
1286
1287 static HRESULT WINAPI mediatype_DeleteAllItems(IMFMediaType *iface)
1288 {
1289     mfmediatype *This = impl_from_IMFMediaType(iface);
1290
1291     FIXME("%p\n", This);
1292
1293     return E_NOTIMPL;
1294 }
1295
1296 static HRESULT WINAPI mediatype_SetUINT32(IMFMediaType *iface, REFGUID key, UINT32 value)
1297 {
1298     mfmediatype *This = impl_from_IMFMediaType(iface);
1299
1300     FIXME("%p, %s, %d\n", This, debugstr_guid(key), value);
1301
1302     return E_NOTIMPL;
1303 }
1304
1305 static HRESULT WINAPI mediatype_SetUINT64(IMFMediaType *iface, REFGUID key, UINT64 value)
1306 {
1307     mfmediatype *This = impl_from_IMFMediaType(iface);
1308
1309     FIXME("%p, %s, %s\n", This, debugstr_guid(key), wine_dbgstr_longlong(value));
1310
1311     return E_NOTIMPL;
1312 }
1313
1314 static HRESULT WINAPI mediatype_SetDouble(IMFMediaType *iface, REFGUID key, double value)
1315 {
1316     mfmediatype *This = impl_from_IMFMediaType(iface);
1317
1318     FIXME("%p, %s, %f\n", This, debugstr_guid(key), value);
1319
1320     return E_NOTIMPL;
1321 }
1322
1323 static HRESULT WINAPI mediatype_SetGUID(IMFMediaType *iface, REFGUID key, REFGUID value)
1324 {
1325     mfmediatype *This = impl_from_IMFMediaType(iface);
1326
1327     FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_guid(value));
1328
1329     return E_NOTIMPL;
1330 }
1331
1332 static HRESULT WINAPI mediatype_SetString(IMFMediaType *iface, REFGUID key, const WCHAR *value)
1333 {
1334     mfmediatype *This = impl_from_IMFMediaType(iface);
1335
1336     FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_w(value));
1337
1338     return E_NOTIMPL;
1339 }
1340
1341 static HRESULT WINAPI mediatype_SetBlob(IMFMediaType *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1342 {
1343     mfmediatype *This = impl_from_IMFMediaType(iface);
1344
1345     FIXME("%p, %s, %p, %d\n", This, debugstr_guid(key), buf, size);
1346
1347     return E_NOTIMPL;
1348 }
1349
1350 static HRESULT WINAPI mediatype_SetUnknown(IMFMediaType *iface, REFGUID key, IUnknown *unknown)
1351 {
1352     mfmediatype *This = impl_from_IMFMediaType(iface);
1353
1354     FIXME("%p, %s, %p\n", This, debugstr_guid(key), unknown);
1355
1356     return E_NOTIMPL;
1357 }
1358
1359 static HRESULT WINAPI mediatype_LockStore(IMFMediaType *iface)
1360 {
1361     mfmediatype *This = impl_from_IMFMediaType(iface);
1362
1363     FIXME("%p\n", This);
1364
1365     return E_NOTIMPL;
1366 }
1367
1368 static HRESULT WINAPI mediatype_UnlockStore(IMFMediaType *iface)
1369 {
1370     mfmediatype *This = impl_from_IMFMediaType(iface);
1371
1372     FIXME("%p\n", This);
1373
1374     return E_NOTIMPL;
1375 }
1376
1377 static HRESULT WINAPI mediatype_GetCount(IMFMediaType *iface, UINT32 *items)
1378 {
1379     mfmediatype *This = impl_from_IMFMediaType(iface);
1380
1381     FIXME("%p, %p\n", This, items);
1382
1383     if(items)
1384         *items = 0;
1385
1386     return E_NOTIMPL;
1387 }
1388
1389 static HRESULT WINAPI mediatype_GetItemByIndex(IMFMediaType *iface, UINT32 index, GUID *key, PROPVARIANT *value)
1390 {
1391     mfmediatype *This = impl_from_IMFMediaType(iface);
1392
1393     FIXME("%p, %d, %p, %p\n", This, index, key, value);
1394
1395     return E_NOTIMPL;
1396 }
1397
1398 static HRESULT WINAPI mediatype_CopyAllItems(IMFMediaType *iface, IMFAttributes *dest)
1399 {
1400     mfmediatype *This = impl_from_IMFMediaType(iface);
1401
1402     FIXME("%p, %p\n", This, dest);
1403
1404     return E_NOTIMPL;
1405 }
1406
1407 static HRESULT WINAPI mediatype_GetMajorType(IMFMediaType *iface, GUID *guid)
1408 {
1409     mfmediatype *This = impl_from_IMFMediaType(iface);
1410
1411     FIXME("%p, %p\n", This, guid);
1412
1413     return E_NOTIMPL;
1414 }
1415
1416 static HRESULT WINAPI mediatype_IsCompressedFormat(IMFMediaType *iface, BOOL *compressed)
1417 {
1418     mfmediatype *This = impl_from_IMFMediaType(iface);
1419
1420     FIXME("%p, %p\n", This, compressed);
1421
1422     return E_NOTIMPL;
1423 }
1424
1425 static HRESULT WINAPI mediatype_IsEqual(IMFMediaType *iface, IMFMediaType *type, DWORD *flags)
1426 {
1427     mfmediatype *This = impl_from_IMFMediaType(iface);
1428
1429     FIXME("%p, %p, %p\n", This, type, flags);
1430
1431     return E_NOTIMPL;
1432 }
1433
1434 static HRESULT WINAPI mediatype_GetRepresentation(IMFMediaType *iface, GUID guid, void **representation)
1435 {
1436     mfmediatype *This = impl_from_IMFMediaType(iface);
1437
1438     FIXME("%p, %s, %p\n", This, debugstr_guid(&guid), representation);
1439
1440     return E_NOTIMPL;
1441 }
1442
1443 static HRESULT WINAPI mediatype_FreeRepresentation(IMFMediaType *iface, GUID guid, void *representation)
1444 {
1445     mfmediatype *This = impl_from_IMFMediaType(iface);
1446
1447     FIXME("%p, %s, %p\n", This, debugstr_guid(&guid), representation);
1448
1449     return E_NOTIMPL;
1450 }
1451
1452 static const IMFMediaTypeVtbl mediatype_vtbl =
1453 {
1454     mediatype_QueryInterface,
1455     mediatype_AddRef,
1456     mediatype_Release,
1457     mediatype_GetItem,
1458     mediatype_GetItemType,
1459     mediatype_CompareItem,
1460     mediatype_Compare,
1461     mediatype_GetUINT32,
1462     mediatype_GetUINT64,
1463     mediatype_GetDouble,
1464     mediatype_GetGUID,
1465     mediatype_GetStringLength,
1466     mediatype_GetString,
1467     mediatype_GetAllocatedString,
1468     mediatype_GetBlobSize,
1469     mediatype_GetBlob,
1470     mediatype_GetAllocatedBlob,
1471     mediatype_GetUnknown,
1472     mediatype_SetItem,
1473     mediatype_DeleteItem,
1474     mediatype_DeleteAllItems,
1475     mediatype_SetUINT32,
1476     mediatype_SetUINT64,
1477     mediatype_SetDouble,
1478     mediatype_SetGUID,
1479     mediatype_SetString,
1480     mediatype_SetBlob,
1481     mediatype_SetUnknown,
1482     mediatype_LockStore,
1483     mediatype_UnlockStore,
1484     mediatype_GetCount,
1485     mediatype_GetItemByIndex,
1486     mediatype_CopyAllItems,
1487     mediatype_GetMajorType,
1488     mediatype_IsCompressedFormat,
1489     mediatype_IsEqual,
1490     mediatype_GetRepresentation,
1491     mediatype_FreeRepresentation
1492 };
1493
1494 /***********************************************************************
1495  *      MFCreateMediaType (mfplat.@)
1496  */
1497 HRESULT WINAPI MFCreateMediaType(IMFMediaType **type)
1498 {
1499     mfmediatype *object;
1500
1501     TRACE("%p\n", type);
1502
1503     if(!type)
1504         return E_INVALIDARG;
1505
1506     object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
1507     if(!object)
1508         return E_OUTOFMEMORY;
1509
1510     object->ref = 1;
1511     object->IMFMediaType_iface.lpVtbl = &mediatype_vtbl;
1512
1513     *type = &object->IMFMediaType_iface;
1514     return S_OK;
1515 }
1516
1517 typedef struct _mfeventqueue
1518 {
1519     IMFMediaEventQueue IMFMediaEventQueue_iface;
1520     LONG ref;
1521 } mfeventqueue;
1522
1523 static inline mfeventqueue *impl_from_IMFMediaEventQueue(IMFMediaEventQueue *iface)
1524 {
1525     return CONTAINING_RECORD(iface, mfeventqueue, IMFMediaEventQueue_iface);
1526 }
1527
1528 static HRESULT WINAPI mfeventqueue_QueryInterface(IMFMediaEventQueue *iface, REFIID riid, void **out)
1529 {
1530     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1531
1532     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
1533
1534     if(IsEqualGUID(riid, &IID_IUnknown)      ||
1535        IsEqualGUID(riid, &IID_IMFMediaEventQueue))
1536     {
1537         *out = &This->IMFMediaEventQueue_iface;
1538     }
1539     else
1540     {
1541         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
1542         *out = NULL;
1543         return E_NOINTERFACE;
1544     }
1545
1546     IUnknown_AddRef((IUnknown*)*out);
1547     return S_OK;
1548 }
1549
1550 static ULONG WINAPI mfeventqueue_AddRef(IMFMediaEventQueue *iface)
1551 {
1552     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1553     ULONG ref = InterlockedIncrement(&This->ref);
1554
1555     TRACE("(%p) ref=%u\n", This, ref);
1556
1557     return ref;
1558 }
1559
1560 static ULONG WINAPI mfeventqueue_Release(IMFMediaEventQueue *iface)
1561 {
1562     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1563     ULONG ref = InterlockedDecrement(&This->ref);
1564
1565     TRACE("(%p) ref=%u\n", This, ref);
1566
1567     if (!ref)
1568     {
1569         HeapFree(GetProcessHeap(), 0, This);
1570     }
1571
1572     return ref;
1573 }
1574
1575 static HRESULT WINAPI mfeventqueue_GetEvent(IMFMediaEventQueue *iface, DWORD flags, IMFMediaEvent **event)
1576 {
1577     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1578
1579     FIXME("%p, %p\n", This, event);
1580
1581     return E_NOTIMPL;
1582 }
1583
1584 static HRESULT WINAPI mfeventqueue_BeginGetEvent(IMFMediaEventQueue *iface, IMFAsyncCallback *callback, IUnknown *state)
1585 {
1586     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1587
1588     FIXME("%p, %p, %p\n", This, callback, state);
1589
1590     return E_NOTIMPL;
1591 }
1592
1593 static HRESULT WINAPI mfeventqueue_EndGetEvent(IMFMediaEventQueue *iface, IMFAsyncResult *result, IMFMediaEvent **event)
1594 {
1595     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1596
1597     FIXME("%p, %p, %p\n", This, result, event);
1598
1599     return E_NOTIMPL;
1600 }
1601
1602 static HRESULT WINAPI mfeventqueue_QueueEvent(IMFMediaEventQueue *iface, IMFMediaEvent *event)
1603 {
1604     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1605
1606     FIXME("%p, %p\n", This, event);
1607
1608     return E_NOTIMPL;
1609 }
1610
1611 static HRESULT WINAPI mfeventqueue_QueueEventParamVar(IMFMediaEventQueue *iface, MediaEventType met,
1612         REFGUID type, HRESULT status, const PROPVARIANT *value)
1613 {
1614     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1615
1616     FIXME("%p, %d, %s, 0x%08x, %p\n", This, met, debugstr_guid(type), status, value);
1617
1618     return E_NOTIMPL;
1619 }
1620
1621 static HRESULT WINAPI mfeventqueue_QueueEventParamUnk(IMFMediaEventQueue *iface, MediaEventType met, REFGUID type,
1622         HRESULT status, IUnknown *unk)
1623 {
1624     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1625
1626     FIXME("%p, %d, %s, 0x%08x, %p\n", This, met, debugstr_guid(type), status, unk);
1627
1628     return E_NOTIMPL;
1629 }
1630
1631 static HRESULT WINAPI mfeventqueue_Shutdown(IMFMediaEventQueue *iface)
1632 {
1633     mfeventqueue *This = impl_from_IMFMediaEventQueue(iface);
1634
1635     FIXME("%p\n", This);
1636
1637     return E_NOTIMPL;
1638 }
1639
1640 static const IMFMediaEventQueueVtbl mfeventqueue_vtbl =
1641 {
1642     mfeventqueue_QueryInterface,
1643     mfeventqueue_AddRef,
1644     mfeventqueue_Release,
1645     mfeventqueue_GetEvent,
1646     mfeventqueue_BeginGetEvent,
1647     mfeventqueue_EndGetEvent,
1648     mfeventqueue_QueueEvent,
1649     mfeventqueue_QueueEventParamVar,
1650     mfeventqueue_QueueEventParamUnk,
1651     mfeventqueue_Shutdown
1652 };
1653
1654 /***********************************************************************
1655  *      MFCreateEventQueue (mfplat.@)
1656  */
1657 HRESULT WINAPI MFCreateEventQueue(IMFMediaEventQueue **queue)
1658 {
1659     mfeventqueue *object;
1660
1661     TRACE("%p\n", queue);
1662
1663     object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
1664     if(!object)
1665         return E_OUTOFMEMORY;
1666
1667     object->ref = 1;
1668     object->IMFMediaEventQueue_iface.lpVtbl = &mfeventqueue_vtbl;
1669
1670     *queue = &object->IMFMediaEventQueue_iface;
1671
1672     return S_OK;
1673 }
1674
1675 typedef struct _mfdescriptor
1676 {
1677     IMFStreamDescriptor IMFStreamDescriptor_iface;
1678     LONG ref;
1679 } mfdescriptor;
1680
1681 static inline mfdescriptor *impl_from_IMFStreamDescriptor(IMFStreamDescriptor *iface)
1682 {
1683     return CONTAINING_RECORD(iface, mfdescriptor, IMFStreamDescriptor_iface);
1684 }
1685
1686 static HRESULT WINAPI mfdescriptor_QueryInterface(IMFStreamDescriptor *iface, REFIID riid, void **out)
1687 {
1688     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1689
1690     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
1691
1692     if(IsEqualGUID(riid, &IID_IUnknown)      ||
1693        IsEqualGUID(riid, &IID_IMFAttributes) ||
1694        IsEqualGUID(riid, &IID_IMFStreamDescriptor))
1695     {
1696         *out = &This->IMFStreamDescriptor_iface;
1697     }
1698     else
1699     {
1700         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
1701         *out = NULL;
1702         return E_NOINTERFACE;
1703     }
1704
1705     IUnknown_AddRef((IUnknown*)*out);
1706     return S_OK;
1707 }
1708
1709 static ULONG WINAPI mfdescriptor_AddRef(IMFStreamDescriptor *iface)
1710 {
1711     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1712     ULONG ref = InterlockedIncrement(&This->ref);
1713
1714     TRACE("(%p) ref=%u\n", This, ref);
1715
1716     return ref;
1717 }
1718
1719 static ULONG WINAPI mfdescriptor_Release(IMFStreamDescriptor *iface)
1720 {
1721     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1722     ULONG ref = InterlockedDecrement(&This->ref);
1723
1724     TRACE("(%p) ref=%u\n", This, ref);
1725
1726     if (!ref)
1727     {
1728         HeapFree(GetProcessHeap(), 0, This);
1729     }
1730
1731     return ref;
1732 }
1733
1734 static HRESULT WINAPI mfdescriptor_GetItem(IMFStreamDescriptor *iface, REFGUID key, PROPVARIANT *value)
1735 {
1736     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1737
1738     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1739
1740     return E_NOTIMPL;
1741 }
1742
1743 static HRESULT WINAPI mfdescriptor_GetItemType(IMFStreamDescriptor *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
1744 {
1745     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1746
1747     FIXME("%p, %s, %p\n", This, debugstr_guid(key), type);
1748
1749     return E_NOTIMPL;
1750 }
1751
1752 static HRESULT WINAPI mfdescriptor_CompareItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
1753 {
1754     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1755
1756     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, result);
1757
1758     return E_NOTIMPL;
1759 }
1760
1761 static HRESULT WINAPI mfdescriptor_Compare(IMFStreamDescriptor *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
1762                 BOOL *result)
1763 {
1764     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1765
1766     FIXME("%p, %p, %d, %p\n", This, theirs, type, result);
1767
1768     return E_NOTIMPL;
1769 }
1770
1771 static HRESULT WINAPI mfdescriptor_GetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 *value)
1772 {
1773     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1774
1775     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1776
1777     return E_NOTIMPL;
1778 }
1779
1780 static HRESULT WINAPI mfdescriptor_GetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 *value)
1781 {
1782     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1783
1784     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1785
1786     return E_NOTIMPL;
1787 }
1788
1789 static HRESULT WINAPI mfdescriptor_GetDouble(IMFStreamDescriptor *iface, REFGUID key, double *value)
1790 {
1791     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1792
1793     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1794
1795     return E_NOTIMPL;
1796 }
1797
1798 static HRESULT WINAPI mfdescriptor_GetGUID(IMFStreamDescriptor *iface, REFGUID key, GUID *value)
1799 {
1800     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1801
1802     FIXME("%p, %s, %p\n", This, debugstr_guid(key), value);
1803
1804     return E_NOTIMPL;
1805 }
1806
1807 static HRESULT WINAPI mfdescriptor_GetStringLength(IMFStreamDescriptor *iface, REFGUID key, UINT32 *length)
1808 {
1809     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1810
1811     FIXME("%p, %s, %p\n", This, debugstr_guid(key), length);
1812
1813     return E_NOTIMPL;
1814 }
1815
1816 static HRESULT WINAPI mfdescriptor_GetString(IMFStreamDescriptor *iface, REFGUID key, WCHAR *value,
1817                 UINT32 size, UINT32 *length)
1818 {
1819     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1820
1821     FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), value, size, length);
1822
1823     return E_NOTIMPL;
1824 }
1825
1826 static HRESULT WINAPI mfdescriptor_GetAllocatedString(IMFStreamDescriptor *iface, REFGUID key,
1827                                       WCHAR **value, UINT32 *length)
1828 {
1829     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1830
1831     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), value, length);
1832
1833     return E_NOTIMPL;
1834 }
1835
1836 static HRESULT WINAPI mfdescriptor_GetBlobSize(IMFStreamDescriptor *iface, REFGUID key, UINT32 *size)
1837 {
1838     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1839
1840     FIXME("%p, %s, %p\n", This, debugstr_guid(key), size);
1841
1842     return E_NOTIMPL;
1843 }
1844
1845 static HRESULT WINAPI mfdescriptor_GetBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 *buf,
1846                 UINT32 bufsize, UINT32 *blobsize)
1847 {
1848     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1849
1850     FIXME("%p, %s, %p, %d, %p\n", This, debugstr_guid(key), buf, bufsize, blobsize);
1851
1852     return E_NOTIMPL;
1853 }
1854
1855 static HRESULT WINAPI mfdescriptor_GetAllocatedBlob(IMFStreamDescriptor *iface, REFGUID key, UINT8 **buf, UINT32 *size)
1856 {
1857     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1858
1859     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(key), buf, size);
1860
1861     return E_NOTIMPL;
1862 }
1863
1864 static HRESULT WINAPI mfdescriptor_GetUnknown(IMFStreamDescriptor *iface, REFGUID key, REFIID riid, void **ppv)
1865 {
1866     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1867
1868     FIXME("%p, %s, %s, %p\n", This, debugstr_guid(key), debugstr_guid(riid), ppv);
1869
1870     return E_NOTIMPL;
1871 }
1872
1873 static HRESULT WINAPI mfdescriptor_SetItem(IMFStreamDescriptor *iface, REFGUID key, REFPROPVARIANT Value)
1874 {
1875     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1876
1877     FIXME("%p, %s, %p\n", This, debugstr_guid(key), Value);
1878
1879     return E_NOTIMPL;
1880 }
1881
1882 static HRESULT WINAPI mfdescriptor_DeleteItem(IMFStreamDescriptor *iface, REFGUID key)
1883 {
1884     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1885
1886     FIXME("%p, %s\n", This, debugstr_guid(key));
1887
1888     return E_NOTIMPL;
1889 }
1890
1891 static HRESULT WINAPI mfdescriptor_DeleteAllItems(IMFStreamDescriptor *iface)
1892 {
1893     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1894
1895     FIXME("%p\n", This);
1896
1897     return E_NOTIMPL;
1898 }
1899
1900 static HRESULT WINAPI mfdescriptor_SetUINT32(IMFStreamDescriptor *iface, REFGUID key, UINT32 value)
1901 {
1902     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1903
1904     FIXME("%p, %s, %d\n", This, debugstr_guid(key), value);
1905
1906     return E_NOTIMPL;
1907 }
1908
1909 static HRESULT WINAPI mfdescriptor_SetUINT64(IMFStreamDescriptor *iface, REFGUID key, UINT64 value)
1910 {
1911     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1912
1913     FIXME("%p, %s, %s\n", This, debugstr_guid(key), wine_dbgstr_longlong(value));
1914
1915     return E_NOTIMPL;
1916 }
1917
1918 static HRESULT WINAPI mfdescriptor_SetDouble(IMFStreamDescriptor *iface, REFGUID key, double value)
1919 {
1920     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1921
1922     FIXME("%p, %s, %f\n", This, debugstr_guid(key), value);
1923
1924     return E_NOTIMPL;
1925 }
1926
1927 static HRESULT WINAPI mfdescriptor_SetGUID(IMFStreamDescriptor *iface, REFGUID key, REFGUID value)
1928 {
1929     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1930
1931     FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_guid(value));
1932
1933     return E_NOTIMPL;
1934 }
1935
1936 static HRESULT WINAPI mfdescriptor_SetString(IMFStreamDescriptor *iface, REFGUID key, const WCHAR *value)
1937 {
1938     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1939
1940     FIXME("%p, %s, %s\n", This, debugstr_guid(key), debugstr_w(value));
1941
1942     return E_NOTIMPL;
1943 }
1944
1945 static HRESULT WINAPI mfdescriptor_SetBlob(IMFStreamDescriptor *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1946 {
1947     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1948
1949     FIXME("%p, %s, %p, %d\n", This, debugstr_guid(key), buf, size);
1950
1951     return E_NOTIMPL;
1952 }
1953
1954 static HRESULT WINAPI mfdescriptor_SetUnknown(IMFStreamDescriptor *iface, REFGUID key, IUnknown *unknown)
1955 {
1956     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1957
1958     FIXME("%p, %s, %p\n", This, debugstr_guid(key), unknown);
1959
1960     return E_NOTIMPL;
1961 }
1962
1963 static HRESULT WINAPI mfdescriptor_LockStore(IMFStreamDescriptor *iface)
1964 {
1965     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1966
1967     FIXME("%p\n", This);
1968
1969     return E_NOTIMPL;
1970 }
1971
1972 static HRESULT WINAPI mfdescriptor_UnlockStore(IMFStreamDescriptor *iface)
1973 {
1974     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1975
1976     FIXME("%p\n", This);
1977
1978     return E_NOTIMPL;
1979 }
1980
1981 static HRESULT WINAPI mfdescriptor_GetCount(IMFStreamDescriptor *iface, UINT32 *items)
1982 {
1983     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1984
1985     FIXME("%p, %p\n", This, items);
1986
1987     if(items)
1988         *items = 0;
1989
1990     return E_NOTIMPL;
1991 }
1992
1993 static HRESULT WINAPI mfdescriptor_GetItemByIndex(IMFStreamDescriptor *iface, UINT32 index, GUID *key, PROPVARIANT *value)
1994 {
1995     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
1996
1997     FIXME("%p, %d, %p, %p\n", This, index, key, value);
1998
1999     return E_NOTIMPL;
2000 }
2001
2002 static HRESULT WINAPI mfdescriptor_CopyAllItems(IMFStreamDescriptor *iface, IMFAttributes *dest)
2003 {
2004     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2005
2006     FIXME("%p, %p\n", This, dest);
2007
2008     return E_NOTIMPL;
2009 }
2010
2011 static HRESULT WINAPI mfdescriptor_GetStreamIdentifier(IMFStreamDescriptor *iface, DWORD *identifier)
2012 {
2013     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2014
2015     FIXME("%p, %p\n", This, identifier);
2016
2017     return E_NOTIMPL;
2018 }
2019
2020 static HRESULT WINAPI mfdescriptor_GetMediaTypeHandler(IMFStreamDescriptor *iface, IMFMediaTypeHandler **handler)
2021 {
2022     mfdescriptor *This = impl_from_IMFStreamDescriptor(iface);
2023
2024     FIXME("%p, %p\n", This, handler);
2025
2026     return E_NOTIMPL;
2027 }
2028
2029 static const IMFStreamDescriptorVtbl mfdescriptor_vtbl =
2030 {
2031     mfdescriptor_QueryInterface,
2032     mfdescriptor_AddRef,
2033     mfdescriptor_Release,
2034     mfdescriptor_GetItem,
2035     mfdescriptor_GetItemType,
2036     mfdescriptor_CompareItem,
2037     mfdescriptor_Compare,
2038     mfdescriptor_GetUINT32,
2039     mfdescriptor_GetUINT64,
2040     mfdescriptor_GetDouble,
2041     mfdescriptor_GetGUID,
2042     mfdescriptor_GetStringLength,
2043     mfdescriptor_GetString,
2044     mfdescriptor_GetAllocatedString,
2045     mfdescriptor_GetBlobSize,
2046     mfdescriptor_GetBlob,
2047     mfdescriptor_GetAllocatedBlob,
2048     mfdescriptor_GetUnknown,
2049     mfdescriptor_SetItem,
2050     mfdescriptor_DeleteItem,
2051     mfdescriptor_DeleteAllItems,
2052     mfdescriptor_SetUINT32,
2053     mfdescriptor_SetUINT64,
2054     mfdescriptor_SetDouble,
2055     mfdescriptor_SetGUID,
2056     mfdescriptor_SetString,
2057     mfdescriptor_SetBlob,
2058     mfdescriptor_SetUnknown,
2059     mfdescriptor_LockStore,
2060     mfdescriptor_UnlockStore,
2061     mfdescriptor_GetCount,
2062     mfdescriptor_GetItemByIndex,
2063     mfdescriptor_CopyAllItems,
2064     mfdescriptor_GetStreamIdentifier,
2065     mfdescriptor_GetMediaTypeHandler
2066 };
2067
2068 HRESULT WINAPI MFCreateStreamDescriptor(DWORD identifier, DWORD count,
2069         IMFMediaType **types, IMFStreamDescriptor **descriptor)
2070 {
2071     mfdescriptor *object;
2072
2073     TRACE("%d, %d, %p, %p\n", identifier, count, types, descriptor);
2074
2075     object = HeapAlloc( GetProcessHeap(), 0, sizeof(*object) );
2076     if(!object)
2077         return E_OUTOFMEMORY;
2078
2079     object->ref = 1;
2080     object->IMFStreamDescriptor_iface.lpVtbl = &mfdescriptor_vtbl;
2081
2082     *descriptor = &object->IMFStreamDescriptor_iface;
2083     return S_OK;
2084 }