dlls/mfplat/main.c

   1 /*
   2  * Copyright 2014 Austin English
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <string.h>
  21 #include <math.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winreg.h"
  30
  31 #include "initguid.h"
  32 #include "rtworkq.h"
  33 #include "ole2.h"
  34 #include "propsys.h"
  35 #include "dxgi.h"
  36
  37 #include "wine/debug.h"
  38 #include "wine/list.h"
  39
  40 #include "mfplat_private.h"
  41 #include "mfreadwrite.h"
  42 #include "propvarutil.h"
  43 #include "strsafe.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  46
  47 static HRESULT heap_strdupW(const WCHAR *str, WCHAR **dest)
  48 {
  49     HRESULT hr = S_OK;
  50
  51     if (str)
  52     {
  53         unsigned int size;
  54
  55         size = (lstrlenW(str) + 1) * sizeof(WCHAR);
  56         *dest = heap_alloc(size);
  57         if (*dest)
  58             memcpy(*dest, str, size);
  59         else
  60             hr = E_OUTOFMEMORY;
  61     }
  62     else
  63         *dest = NULL;
  64
  65     return hr;
  66 }
  67
  68 struct local_handler
  69 {
  70     struct list entry;
  71     union
  72     {
  73         WCHAR *scheme;
  74         struct
  75         {
  76             WCHAR *extension;
  77             WCHAR *mime;
  78         } bytestream;
  79     } u;
  80     IMFActivate *activate;
  81 };
  82
  83 static CRITICAL_SECTION local_handlers_section = { NULL, -1, 0, 0, 0, 0 };
  84
  85 static struct list local_scheme_handlers = LIST_INIT(local_scheme_handlers);
  86 static struct list local_bytestream_handlers = LIST_INIT(local_bytestream_handlers);
  87
  88 struct mft_registration
  89 {
  90     struct list entry;
  91     IClassFactory *factory;
  92     CLSID clsid;
  93     GUID category;
  94     WCHAR *name;
  95     DWORD flags;
  96     MFT_REGISTER_TYPE_INFO *input_types;
  97     UINT32 input_types_count;
  98     MFT_REGISTER_TYPE_INFO *output_types;
  99     UINT32 output_types_count;
 100     BOOL local;
 101 };
 102
 103 static CRITICAL_SECTION local_mfts_section = { NULL, -1, 0, 0, 0, 0 };
 104
 105 static struct list local_mfts = LIST_INIT(local_mfts);
 106
 107 struct transform_activate
 108 {
 109     struct attributes attributes;
 110     IMFActivate IMFActivate_iface;
 111     IClassFactory *factory;
 112     IMFTransform *transform;
 113 };
 114
 115 struct system_clock
 116 {
 117     IMFClock IMFClock_iface;
 118     LONG refcount;
 119 };
 120
 121 struct system_time_source
 122 {
 123     IMFPresentationTimeSource IMFPresentationTimeSource_iface;
 124     IMFClockStateSink IMFClockStateSink_iface;
 125     LONG refcount;
 126     MFCLOCK_STATE state;
 127     IMFClock *clock;
 128     LONGLONG start_offset;
 129     float rate;
 130     int i_rate;
 131     CRITICAL_SECTION cs;
 132 };
 133
 134 static void system_time_source_apply_rate(const struct system_time_source *source, LONGLONG *value)
 135 {
 136     if (source->i_rate)
 137         *value *= source->i_rate;
 138     else
 139         *value *= source->rate;
 140 }
 141
 142 static struct system_time_source *impl_from_IMFPresentationTimeSource(IMFPresentationTimeSource *iface)
 143 {
 144     return CONTAINING_RECORD(iface, struct system_time_source, IMFPresentationTimeSource_iface);
 145 }
 146
 147 static struct system_time_source *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
 148 {
 149     return CONTAINING_RECORD(iface, struct system_time_source, IMFClockStateSink_iface);
 150 }
 151
 152 static struct system_clock *impl_from_IMFClock(IMFClock *iface)
 153 {
 154     return CONTAINING_RECORD(iface, struct system_clock, IMFClock_iface);
 155 }
 156
 157 static struct transform_activate *impl_from_IMFActivate(IMFActivate *iface)
 158 {
 159     return CONTAINING_RECORD(iface, struct transform_activate, IMFActivate_iface);
 160 }
 161
 162 static HRESULT WINAPI transform_activate_QueryInterface(IMFActivate *iface, REFIID riid, void **out)
 163 {
 164     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 165
 166     if (IsEqualIID(riid, &IID_IMFActivate) ||
 167             IsEqualIID(riid, &IID_IMFAttributes) ||
 168             IsEqualIID(riid, &IID_IUnknown))
 169     {
 170         *out = iface;
 171         IMFActivate_AddRef(iface);
 172         return S_OK;
 173     }
 174
 175     WARN("Unsupported %s.\n", debugstr_guid(riid));
 176     *out = NULL;
 177     return E_NOINTERFACE;
 178 }
 179
 180 static ULONG WINAPI transform_activate_AddRef(IMFActivate *iface)
 181 {
 182     struct transform_activate *activate = impl_from_IMFActivate(iface);
 183     ULONG refcount = InterlockedIncrement(&activate->attributes.ref);
 184
 185     TRACE("%p, refcount %u.\n", iface, refcount);
 186
 187     return refcount;
 188 }
 189
 190 static ULONG WINAPI transform_activate_Release(IMFActivate *iface)
 191 {
 192     struct transform_activate *activate = impl_from_IMFActivate(iface);
 193     ULONG refcount = InterlockedDecrement(&activate->attributes.ref);
 194
 195     TRACE("%p, refcount %u.\n", iface, refcount);
 196
 197     if (!refcount)
 198     {
 199         clear_attributes_object(&activate->attributes);
 200         if (activate->factory)
 201             IClassFactory_Release(activate->factory);
 202         if (activate->transform)
 203             IMFTransform_Release(activate->transform);
 204         heap_free(activate);
 205     }
 206
 207     return refcount;
 208 }
 209
 210 static HRESULT WINAPI transform_activate_GetItem(IMFActivate *iface, REFGUID key, PROPVARIANT *value)
 211 {
 212     struct transform_activate *activate = impl_from_IMFActivate(iface);
 213
 214     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 215
 216     return attributes_GetItem(&activate->attributes, key, value);
 217 }
 218
 219 static HRESULT WINAPI transform_activate_GetItemType(IMFActivate *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 220 {
 221     struct transform_activate *activate = impl_from_IMFActivate(iface);
 222
 223     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
 224
 225     return attributes_GetItemType(&activate->attributes, key, type);
 226 }
 227
 228 static HRESULT WINAPI transform_activate_CompareItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value,
 229         BOOL *result)
 230 {
 231     struct transform_activate *activate = impl_from_IMFActivate(iface);
 232
 233     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
 234
 235     return attributes_CompareItem(&activate->attributes, key, value, result);
 236 }
 237
 238 static HRESULT WINAPI transform_activate_Compare(IMFActivate *iface, IMFAttributes *theirs,
 239         MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
 240 {
 241     struct transform_activate *activate = impl_from_IMFActivate(iface);
 242
 243     TRACE("%p, %p, %d, %p.\n", iface, theirs, match_type, ret);
 244
 245     return attributes_Compare(&activate->attributes, theirs, match_type, ret);
 246 }
 247
 248 static HRESULT WINAPI transform_activate_GetUINT32(IMFActivate *iface, REFGUID key, UINT32 *value)
 249 {
 250     struct transform_activate *activate = impl_from_IMFActivate(iface);
 251
 252     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 253
 254     return attributes_GetUINT32(&activate->attributes, key, value);
 255 }
 256
 257 static HRESULT WINAPI transform_activate_GetUINT64(IMFActivate *iface, REFGUID key, UINT64 *value)
 258 {
 259     struct transform_activate *activate = impl_from_IMFActivate(iface);
 260
 261     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 262
 263     return attributes_GetUINT64(&activate->attributes, key, value);
 264 }
 265
 266 static HRESULT WINAPI transform_activate_GetDouble(IMFActivate *iface, REFGUID key, double *value)
 267 {
 268     struct transform_activate *activate = impl_from_IMFActivate(iface);
 269
 270     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 271
 272     return attributes_GetDouble(&activate->attributes, key, value);
 273 }
 274
 275 static HRESULT WINAPI transform_activate_GetGUID(IMFActivate *iface, REFGUID key, GUID *value)
 276 {
 277     struct transform_activate *activate = impl_from_IMFActivate(iface);
 278
 279     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
 280
 281     return attributes_GetGUID(&activate->attributes, key, value);
 282 }
 283
 284 static HRESULT WINAPI transform_activate_GetStringLength(IMFActivate *iface, REFGUID key, UINT32 *length)
 285 {
 286     struct transform_activate *activate = impl_from_IMFActivate(iface);
 287
 288     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
 289
 290     return attributes_GetStringLength(&activate->attributes, key, length);
 291 }
 292
 293 static HRESULT WINAPI transform_activate_GetString(IMFActivate *iface, REFGUID key, WCHAR *value,
 294         UINT32 size, UINT32 *length)
 295 {
 296     struct transform_activate *activate = impl_from_IMFActivate(iface);
 297
 298     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), value, size, length);
 299
 300     return attributes_GetString(&activate->attributes, key, value, size, length);
 301 }
 302
 303 static HRESULT WINAPI transform_activate_GetAllocatedString(IMFActivate *iface, REFGUID key, WCHAR **value,
 304         UINT32 *length)
 305 {
 306     struct transform_activate *activate = impl_from_IMFActivate(iface);
 307
 308     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
 309
 310     return attributes_GetAllocatedString(&activate->attributes, key, value, length);
 311 }
 312
 313 static HRESULT WINAPI transform_activate_GetBlobSize(IMFActivate *iface, REFGUID key, UINT32 *size)
 314 {
 315     struct transform_activate *activate = impl_from_IMFActivate(iface);
 316
 317     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
 318
 319     return attributes_GetBlobSize(&activate->attributes, key, size);
 320 }
 321
 322 static HRESULT WINAPI transform_activate_GetBlob(IMFActivate *iface, REFGUID key, UINT8 *buf, UINT32 bufsize,
 323         UINT32 *blobsize)
 324 {
 325     struct transform_activate *activate = impl_from_IMFActivate(iface);
 326
 327     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
 328
 329     return attributes_GetBlob(&activate->attributes, key, buf, bufsize, blobsize);
 330 }
 331
 332 static HRESULT WINAPI transform_activate_GetAllocatedBlob(IMFActivate *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 333 {
 334     struct transform_activate *activate = impl_from_IMFActivate(iface);
 335
 336     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
 337
 338     return attributes_GetAllocatedBlob(&activate->attributes, key, buf, size);
 339 }
 340
 341 static HRESULT WINAPI transform_activate_GetUnknown(IMFActivate *iface, REFGUID key, REFIID riid, void **out)
 342 {
 343     struct transform_activate *activate = impl_from_IMFActivate(iface);
 344
 345     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
 346
 347     return attributes_GetUnknown(&activate->attributes, key, riid, out);
 348 }
 349
 350 static HRESULT WINAPI transform_activate_SetItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value)
 351 {
 352     struct transform_activate *activate = impl_from_IMFActivate(iface);
 353
 354     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
 355
 356     return attributes_SetItem(&activate->attributes, key, value);
 357 }
 358
 359 static HRESULT WINAPI transform_activate_DeleteItem(IMFActivate *iface, REFGUID key)
 360 {
 361     struct transform_activate *activate = impl_from_IMFActivate(iface);
 362
 363     TRACE("%p, %s.\n", iface, debugstr_attr(key));
 364
 365     return attributes_DeleteItem(&activate->attributes, key);
 366 }
 367
 368 static HRESULT WINAPI transform_activate_DeleteAllItems(IMFActivate *iface)
 369 {
 370     struct transform_activate *activate = impl_from_IMFActivate(iface);
 371
 372     TRACE("%p.\n", iface);
 373
 374     return attributes_DeleteAllItems(&activate->attributes);
 375 }
 376
 377 static HRESULT WINAPI transform_activate_SetUINT32(IMFActivate *iface, REFGUID key, UINT32 value)
 378 {
 379     struct transform_activate *activate = impl_from_IMFActivate(iface);
 380
 381     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
 382
 383     return attributes_SetUINT32(&activate->attributes, key, value);
 384 }
 385
 386 static HRESULT WINAPI transform_activate_SetUINT64(IMFActivate *iface, REFGUID key, UINT64 value)
 387 {
 388     struct transform_activate *activate = impl_from_IMFActivate(iface);
 389
 390     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
 391
 392     return attributes_SetUINT64(&activate->attributes, key, value);
 393 }
 394
 395 static HRESULT WINAPI transform_activate_SetDouble(IMFActivate *iface, REFGUID key, double value)
 396 {
 397     struct transform_activate *activate = impl_from_IMFActivate(iface);
 398
 399     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
 400
 401     return attributes_SetDouble(&activate->attributes, key, value);
 402 }
 403
 404 static HRESULT WINAPI transform_activate_SetGUID(IMFActivate *iface, REFGUID key, REFGUID value)
 405 {
 406     struct transform_activate *activate = impl_from_IMFActivate(iface);
 407
 408     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
 409
 410     return attributes_SetGUID(&activate->attributes, key, value);
 411 }
 412
 413 static HRESULT WINAPI transform_activate_SetString(IMFActivate *iface, REFGUID key, const WCHAR *value)
 414 {
 415     struct transform_activate *activate = impl_from_IMFActivate(iface);
 416
 417     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
 418
 419     return attributes_SetString(&activate->attributes, key, value);
 420 }
 421
 422 static HRESULT WINAPI transform_activate_SetBlob(IMFActivate *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 423 {
 424     struct transform_activate *activate = impl_from_IMFActivate(iface);
 425
 426     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
 427
 428     return attributes_SetBlob(&activate->attributes, key, buf, size);
 429 }
 430
 431 static HRESULT WINAPI transform_activate_SetUnknown(IMFActivate *iface, REFGUID key, IUnknown *unknown)
 432 {
 433     struct transform_activate *activate = impl_from_IMFActivate(iface);
 434
 435     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
 436
 437     return attributes_SetUnknown(&activate->attributes, key, unknown);
 438 }
 439
 440 static HRESULT WINAPI transform_activate_LockStore(IMFActivate *iface)
 441 {
 442     struct transform_activate *activate = impl_from_IMFActivate(iface);
 443
 444     TRACE("%p.\n", iface);
 445
 446     return attributes_LockStore(&activate->attributes);
 447 }
 448
 449 static HRESULT WINAPI transform_activate_UnlockStore(IMFActivate *iface)
 450 {
 451     struct transform_activate *activate = impl_from_IMFActivate(iface);
 452
 453     TRACE("%p.\n", iface);
 454
 455     return attributes_UnlockStore(&activate->attributes);
 456 }
 457
 458 static HRESULT WINAPI transform_activate_GetCount(IMFActivate *iface, UINT32 *count)
 459 {
 460     struct transform_activate *activate = impl_from_IMFActivate(iface);
 461
 462     TRACE("%p, %p.\n", iface, count);
 463
 464     return attributes_GetCount(&activate->attributes, count);
 465 }
 466
 467 static HRESULT WINAPI transform_activate_GetItemByIndex(IMFActivate *iface, UINT32 index, GUID *key,
 468         PROPVARIANT *value)
 469 {
 470     struct transform_activate *activate = impl_from_IMFActivate(iface);
 471
 472     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 473
 474     return attributes_GetItemByIndex(&activate->attributes, index, key, value);
 475 }
 476
 477 static HRESULT WINAPI transform_activate_CopyAllItems(IMFActivate *iface, IMFAttributes *dest)
 478 {
 479     struct transform_activate *activate = impl_from_IMFActivate(iface);
 480
 481     TRACE("%p, %p.\n", iface, dest);
 482
 483     return attributes_CopyAllItems(&activate->attributes, dest);
 484 }
 485
 486 static HRESULT WINAPI transform_activate_ActivateObject(IMFActivate *iface, REFIID riid, void **obj)
 487 {
 488     struct transform_activate *activate = impl_from_IMFActivate(iface);
 489     CLSID clsid;
 490     HRESULT hr;
 491
 492     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 493
 494     EnterCriticalSection(&activate->attributes.cs);
 495
 496     if (!activate->transform)
 497     {
 498         if (activate->factory)
 499         {
 500             if (FAILED(hr = IClassFactory_CreateInstance(activate->factory, NULL, &IID_IMFTransform,
 501                     (void **)&activate->transform)))
 502             {
 503                 hr = MF_E_INVALIDREQUEST;
 504             }
 505         }
 506         else
 507         {
 508             if (SUCCEEDED(hr = attributes_GetGUID(&activate->attributes, &MFT_TRANSFORM_CLSID_Attribute, &clsid)))
 509             {
 510                 if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform,
 511                         (void **)&activate->transform)))
 512                 {
 513                     hr = MF_E_INVALIDREQUEST;
 514                 }
 515             }
 516         }
 517     }
 518
 519     if (activate->transform)
 520         hr = IMFTransform_QueryInterface(activate->transform, riid, obj);
 521
 522     LeaveCriticalSection(&activate->attributes.cs);
 523
 524     return hr;
 525 }
 526
 527 static HRESULT WINAPI transform_activate_ShutdownObject(IMFActivate *iface)
 528 {
 529     struct transform_activate *activate = impl_from_IMFActivate(iface);
 530
 531     TRACE("%p.\n", iface);
 532
 533     EnterCriticalSection(&activate->attributes.cs);
 534
 535     if (activate->transform)
 536     {
 537         IMFTransform_Release(activate->transform);
 538         activate->transform = NULL;
 539     }
 540
 541     LeaveCriticalSection(&activate->attributes.cs);
 542
 543     return S_OK;
 544 }
 545
 546 static HRESULT WINAPI transform_activate_DetachObject(IMFActivate *iface)
 547 {
 548     TRACE("%p.\n", iface);
 549
 550     return E_NOTIMPL;
 551 }
 552
 553 static const IMFActivateVtbl transform_activate_vtbl =
 554 {
 555     transform_activate_QueryInterface,
 556     transform_activate_AddRef,
 557     transform_activate_Release,
 558     transform_activate_GetItem,
 559     transform_activate_GetItemType,
 560     transform_activate_CompareItem,
 561     transform_activate_Compare,
 562     transform_activate_GetUINT32,
 563     transform_activate_GetUINT64,
 564     transform_activate_GetDouble,
 565     transform_activate_GetGUID,
 566     transform_activate_GetStringLength,
 567     transform_activate_GetString,
 568     transform_activate_GetAllocatedString,
 569     transform_activate_GetBlobSize,
 570     transform_activate_GetBlob,
 571     transform_activate_GetAllocatedBlob,
 572     transform_activate_GetUnknown,
 573     transform_activate_SetItem,
 574     transform_activate_DeleteItem,
 575     transform_activate_DeleteAllItems,
 576     transform_activate_SetUINT32,
 577     transform_activate_SetUINT64,
 578     transform_activate_SetDouble,
 579     transform_activate_SetGUID,
 580     transform_activate_SetString,
 581     transform_activate_SetBlob,
 582     transform_activate_SetUnknown,
 583     transform_activate_LockStore,
 584     transform_activate_UnlockStore,
 585     transform_activate_GetCount,
 586     transform_activate_GetItemByIndex,
 587     transform_activate_CopyAllItems,
 588     transform_activate_ActivateObject,
 589     transform_activate_ShutdownObject,
 590     transform_activate_DetachObject,
 591 };
 592
 593 static HRESULT create_transform_activate(IClassFactory *factory, IMFActivate **activate)
 594 {
 595     struct transform_activate *object;
 596     HRESULT hr;
 597
 598     object = heap_alloc_zero(sizeof(*object));
 599     if (!object)
 600         return E_OUTOFMEMORY;
 601
 602     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
 603     {
 604         heap_free(object);
 605         return hr;
 606     }
 607
 608     object->IMFActivate_iface.lpVtbl = &transform_activate_vtbl;
 609     object->factory = factory;
 610     if (object->factory)
 611         IClassFactory_AddRef(object->factory);
 612
 613     *activate = &object->IMFActivate_iface;
 614
 615     return S_OK;
 616 }
 617
 618 HRESULT WINAPI MFCreateTransformActivate(IMFActivate **activate)
 619 {
 620     TRACE("%p.\n", activate);
 621
 622     return create_transform_activate(NULL, activate);
 623 }
 624
 625 static const WCHAR transform_keyW[] = {'M','e','d','i','a','F','o','u','n','d','a','t','i','o','n','\\',
 626                                  'T','r','a','n','s','f','o','r','m','s',0};
 627 static const WCHAR categories_keyW[] = {'M','e','d','i','a','F','o','u','n','d','a','t','i','o','n','\\',
 628                                  'T','r','a','n','s','f','o','r','m','s','\\',
 629                                  'C','a','t','e','g','o','r','i','e','s',0};
 630 static const WCHAR inputtypesW[]  = {'I','n','p','u','t','T','y','p','e','s',0};
 631 static const WCHAR outputtypesW[] = {'O','u','t','p','u','t','T','y','p','e','s',0};
 632 static const WCHAR attributesW[] = {'A','t','t','r','i','b','u','t','e','s',0};
 633 static const WCHAR mftflagsW[] = {'M','F','T','F','l','a','g','s',0};
 634 static const WCHAR szGUIDFmt[] =
 635 {
 636     '%','0','8','x','-','%','0','4','x','-','%','0','4','x','-','%','0',
 637     '2','x','%','0','2','x','-','%','0','2','x','%','0','2','x','%','0','2',
 638     'x','%','0','2','x','%','0','2','x','%','0','2','x',0
 639 };
 640
 641 static const BYTE guid_conv_table[256] =
 642 {
 643     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
 644     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
 645     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
 646     0,   1,   2,   3,   4,   5,   6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
 647     0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
 648     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
 649     0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf                             /* 0x60 */
 650 };
 651
 652 static WCHAR* GUIDToString(WCHAR *str, REFGUID guid)
 653 {
 654     swprintf(str, 39, szGUIDFmt, guid->Data1, guid->Data2,
 655         guid->Data3, guid->Data4[0], guid->Data4[1],
 656         guid->Data4[2], guid->Data4[3], guid->Data4[4],
 657         guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 658
 659     return str;
 660 }
 661
 662 static inline BOOL is_valid_hex(WCHAR c)
 663 {
 664     if (!(((c >= '0') && (c <= '9'))  ||
 665           ((c >= 'a') && (c <= 'f'))  ||
 666           ((c >= 'A') && (c <= 'F'))))
 667         return FALSE;
 668     return TRUE;
 669 }
 670
 671 static BOOL GUIDFromString(LPCWSTR s, GUID *id)
 672 {
 673     int i;
 674
 675     /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
 676
 677     id->Data1 = 0;
 678     for (i = 0; i < 8; i++)
 679     {
 680         if (!is_valid_hex(s[i])) return FALSE;
 681         id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
 682     }
 683     if (s[8]!='-') return FALSE;
 684
 685     id->Data2 = 0;
 686     for (i = 9; i < 13; i++)
 687     {
 688         if (!is_valid_hex(s[i])) return FALSE;
 689         id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
 690     }
 691     if (s[13]!='-') return FALSE;
 692
 693     id->Data3 = 0;
 694     for (i = 14; i < 18; i++)
 695     {
 696         if (!is_valid_hex(s[i])) return FALSE;
 697         id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
 698     }
 699     if (s[18]!='-') return FALSE;
 700
 701     for (i = 19; i < 36; i+=2)
 702     {
 703         if (i == 23)
 704         {
 705             if (s[i]!='-') return FALSE;
 706             i++;
 707         }
 708         if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
 709         id->Data4[(i-19)/2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
 710     }
 711
 712     if (!s[36]) return TRUE;
 713     return FALSE;
 714 }
 715
 716 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
 717 {
 718     switch (reason)
 719     {
 720         case DLL_WINE_PREATTACH:
 721             return FALSE;    /* prefer native version */
 722         case DLL_PROCESS_ATTACH:
 723             DisableThreadLibraryCalls(instance);
 724             break;
 725     }
 726
 727     return TRUE;
 728 }
 729
 730 static HRESULT register_transform(const CLSID *clsid, const WCHAR *name, UINT32 flags,
 731         UINT32 cinput, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 coutput,
 732         const MFT_REGISTER_TYPE_INFO *output_types, IMFAttributes *attributes)
 733 {
 734     static const WCHAR reg_format[] = {'%','s','\\','%','s',0};
 735     HRESULT hr = S_OK;
 736     HKEY hclsid = 0;
 737     WCHAR buffer[64];
 738     DWORD size, ret;
 739     WCHAR str[250];
 740     UINT8 *blob;
 741
 742     GUIDToString(buffer, clsid);
 743     swprintf(str, ARRAY_SIZE(str), reg_format, transform_keyW, buffer);
 744
 745     if ((ret = RegCreateKeyW(HKEY_CLASSES_ROOT, str, &hclsid)))
 746         hr = HRESULT_FROM_WIN32(ret);
 747
 748     if (SUCCEEDED(hr))
 749     {
 750         size = (lstrlenW(name) + 1) * sizeof(WCHAR);
 751         if ((ret = RegSetValueExW(hclsid, NULL, 0, REG_SZ, (BYTE *)name, size)))
 752             hr = HRESULT_FROM_WIN32(ret);
 753     }
 754
 755     if (SUCCEEDED(hr) && cinput && input_types)
 756     {
 757         size = cinput * sizeof(MFT_REGISTER_TYPE_INFO);
 758         if ((ret = RegSetValueExW(hclsid, inputtypesW, 0, REG_BINARY, (BYTE *)input_types, size)))
 759             hr = HRESULT_FROM_WIN32(ret);
 760     }
 761
 762     if (SUCCEEDED(hr) && coutput && output_types)
 763     {
 764         size = coutput * sizeof(MFT_REGISTER_TYPE_INFO);
 765         if ((ret = RegSetValueExW(hclsid, outputtypesW, 0, REG_BINARY, (BYTE *)output_types, size)))
 766             hr = HRESULT_FROM_WIN32(ret);
 767     }
 768
 769     if (SUCCEEDED(hr) && attributes)
 770     {
 771         if (SUCCEEDED(hr = MFGetAttributesAsBlobSize(attributes, &size)))
 772         {
 773             if ((blob = heap_alloc(size)))
 774             {
 775                 if (SUCCEEDED(hr = MFGetAttributesAsBlob(attributes, blob, size)))
 776                 {
 777                     if ((ret = RegSetValueExW(hclsid, attributesW, 0, REG_BINARY, blob, size)))
 778                         hr = HRESULT_FROM_WIN32(ret);
 779                 }
 780                 heap_free(blob);
 781             }
 782             else
 783                 hr = E_OUTOFMEMORY;
 784         }
 785     }
 786
 787     if (SUCCEEDED(hr) && flags)
 788     {
 789         if ((ret = RegSetValueExW(hclsid, mftflagsW, 0, REG_DWORD, (BYTE *)&flags, sizeof(flags))))
 790             hr = HRESULT_FROM_WIN32(ret);
 791     }
 792
 793     RegCloseKey(hclsid);
 794     return hr;
 795 }
 796
 797 static HRESULT register_category(CLSID *clsid, GUID *category)
 798 {
 799     static const WCHAR reg_format[] = {'%','s','\\','%','s','\\','%','s',0};
 800     HKEY htmp1;
 801     WCHAR guid1[64], guid2[64];
 802     WCHAR str[350];
 803
 804     GUIDToString(guid1, category);
 805     GUIDToString(guid2, clsid);
 806
 807     swprintf(str, ARRAY_SIZE(str), reg_format, categories_keyW, guid1, guid2);
 808
 809     if (RegCreateKeyW(HKEY_CLASSES_ROOT, str, &htmp1))
 810         return E_FAIL;
 811
 812     RegCloseKey(htmp1);
 813     return S_OK;
 814 }
 815
 816 /***********************************************************************
 817  *      MFTRegister (mfplat.@)
 818  */
 819 HRESULT WINAPI MFTRegister(CLSID clsid, GUID category, LPWSTR name, UINT32 flags, UINT32 cinput,
 820                            MFT_REGISTER_TYPE_INFO *input_types, UINT32 coutput,
 821                            MFT_REGISTER_TYPE_INFO *output_types, IMFAttributes *attributes)
 822 {
 823     HRESULT hr;
 824
 825     TRACE("%s, %s, %s, %#x, %u, %p, %u, %p, %p.\n", debugstr_guid(&clsid), debugstr_guid(&category),
 826             debugstr_w(name), flags, cinput, input_types, coutput, output_types, attributes);
 827
 828     hr = register_transform(&clsid, name, flags, cinput, input_types, coutput, output_types, attributes);
 829     if(FAILED(hr))
 830         ERR("Failed to write register transform\n");
 831
 832     if (SUCCEEDED(hr))
 833         hr = register_category(&clsid, &category);
 834
 835     return hr;
 836 }
 837
 838 static void release_mft_registration(struct mft_registration *mft)
 839 {
 840     if (mft->factory)
 841         IClassFactory_Release(mft->factory);
 842     heap_free(mft->name);
 843     heap_free(mft->input_types);
 844     heap_free(mft->output_types);
 845     heap_free(mft);
 846 }
 847
 848 static HRESULT mft_register_local(IClassFactory *factory, REFCLSID clsid, REFGUID category, LPCWSTR name, UINT32 flags,
 849         UINT32 input_count, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 output_count,
 850         const MFT_REGISTER_TYPE_INFO *output_types)
 851 {
 852     struct mft_registration *mft, *cur, *unreg_mft = NULL;
 853     HRESULT hr;
 854
 855     if (!factory && !clsid)
 856     {
 857         WARN("Can't register without factory or CLSID.\n");
 858         return E_FAIL;
 859     }
 860
 861     mft = heap_alloc_zero(sizeof(*mft));
 862     if (!mft)
 863         return E_OUTOFMEMORY;
 864
 865     mft->factory = factory;
 866     if (mft->factory)
 867         IClassFactory_AddRef(mft->factory);
 868     if (clsid)
 869         mft->clsid = *clsid;
 870     mft->category = *category;
 871     if (!(flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE)))
 872         flags |= MFT_ENUM_FLAG_SYNCMFT;
 873     mft->flags = flags;
 874     mft->local = TRUE;
 875     if (FAILED(hr = heap_strdupW(name, &mft->name)))
 876         goto failed;
 877
 878     if (input_count && input_types)
 879     {
 880         mft->input_types_count = input_count;
 881         if (!(mft->input_types = heap_calloc(mft->input_types_count, sizeof(*input_types))))
 882         {
 883             hr = E_OUTOFMEMORY;
 884             goto failed;
 885         }
 886         memcpy(mft->input_types, input_types, mft->input_types_count * sizeof(*input_types));
 887     }
 888
 889     if (output_count && output_types)
 890     {
 891         mft->output_types_count = output_count;
 892         if (!(mft->output_types = heap_calloc(mft->output_types_count, sizeof(*output_types))))
 893         {
 894             hr = E_OUTOFMEMORY;
 895             goto failed;
 896         }
 897         memcpy(mft->output_types, output_types, mft->output_types_count * sizeof(*output_types));
 898     }
 899
 900     EnterCriticalSection(&local_mfts_section);
 901
 902     LIST_FOR_EACH_ENTRY(cur, &local_mfts, struct mft_registration, entry)
 903     {
 904         if (cur->factory == factory)
 905         {
 906             unreg_mft = cur;
 907             list_remove(&cur->entry);
 908             break;
 909         }
 910     }
 911     list_add_tail(&local_mfts, &mft->entry);
 912
 913     LeaveCriticalSection(&local_mfts_section);
 914
 915     if (unreg_mft)
 916         release_mft_registration(unreg_mft);
 917
 918 failed:
 919     if (FAILED(hr))
 920         release_mft_registration(mft);
 921
 922     return hr;
 923 }
 924
 925 HRESULT WINAPI MFTRegisterLocal(IClassFactory *factory, REFGUID category, LPCWSTR name, UINT32 flags,
 926         UINT32 input_count, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 output_count,
 927         const MFT_REGISTER_TYPE_INFO *output_types)
 928 {
 929     TRACE("%p, %s, %s, %#x, %u, %p, %u, %p.\n", factory, debugstr_guid(category), debugstr_w(name), flags, input_count,
 930             input_types, output_count, output_types);
 931
 932     return mft_register_local(factory, NULL, category, name, flags, input_count, input_types, output_count, output_types);
 933 }
 934
 935 HRESULT WINAPI MFTRegisterLocalByCLSID(REFCLSID clsid, REFGUID category, LPCWSTR name, UINT32 flags,
 936         UINT32 input_count, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 output_count,
 937         const MFT_REGISTER_TYPE_INFO *output_types)
 938 {
 939     TRACE("%s, %s, %s, %#x, %u, %p, %u, %p.\n", debugstr_guid(clsid), debugstr_guid(category), debugstr_w(name), flags,
 940             input_count, input_types, output_count, output_types);
 941
 942     return mft_register_local(NULL, clsid, category, name, flags, input_count, input_types, output_count, output_types);
 943 }
 944
 945 static HRESULT mft_unregister_local(IClassFactory *factory, REFCLSID clsid)
 946 {
 947     struct mft_registration *cur, *cur2;
 948     BOOL unregister_all = !factory && !clsid;
 949     struct list unreg;
 950
 951     list_init(&unreg);
 952
 953     EnterCriticalSection(&local_mfts_section);
 954
 955     LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &local_mfts, struct mft_registration, entry)
 956     {
 957         if (!unregister_all)
 958         {
 959             if ((factory && cur->factory == factory) || IsEqualCLSID(&cur->clsid, clsid))
 960             {
 961                 list_remove(&cur->entry);
 962                 list_add_tail(&unreg, &cur->entry);
 963                 break;
 964             }
 965         }
 966         else
 967         {
 968             list_remove(&cur->entry);
 969             list_add_tail(&unreg, &cur->entry);
 970         }
 971     }
 972
 973     LeaveCriticalSection(&local_mfts_section);
 974
 975     if (!unregister_all && list_empty(&unreg))
 976         return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 977
 978     LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &unreg, struct mft_registration, entry)
 979     {
 980         list_remove(&cur->entry);
 981         release_mft_registration(cur);
 982     }
 983
 984     return S_OK;
 985 }
 986
 987 HRESULT WINAPI MFTUnregisterLocalByCLSID(CLSID clsid)
 988 {
 989     TRACE("%s.\n", debugstr_guid(&clsid));
 990
 991     return mft_unregister_local(NULL, &clsid);
 992 }
 993
 994 HRESULT WINAPI MFTUnregisterLocal(IClassFactory *factory)
 995 {
 996     TRACE("%p.\n", factory);
 997
 998     return mft_unregister_local(factory, NULL);
 999 }
1000
1001 MFTIME WINAPI MFGetSystemTime(void)
1002 {
1003     MFTIME mf;
1004
1005     TRACE("()\n");
1006
1007     GetSystemTimeAsFileTime( (FILETIME*)&mf );
1008
1009     return mf;
1010 }
1011
1012 static BOOL mft_is_type_info_match(struct mft_registration *mft, const GUID *category, UINT32 flags,
1013         IMFPluginControl *plugin_control, const MFT_REGISTER_TYPE_INFO *input_type,
1014         const MFT_REGISTER_TYPE_INFO *output_type)
1015 {
1016     BOOL matching = TRUE;
1017     DWORD model;
1018     int i;
1019
1020     if (!IsEqualGUID(category, &mft->category))
1021         return FALSE;
1022
1023     /* Default model is synchronous. */
1024     model = mft->flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE);
1025     if (!model)
1026         model = MFT_ENUM_FLAG_SYNCMFT;
1027     if (!(model & flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE)))
1028         return FALSE;
1029
1030     /* These flags should be explicitly enabled. */
1031     if (mft->flags & ~flags & (MFT_ENUM_FLAG_FIELDOFUSE | MFT_ENUM_FLAG_TRANSCODE_ONLY))
1032         return FALSE;
1033
1034     if (flags & MFT_ENUM_FLAG_SORTANDFILTER && !mft->factory && plugin_control
1035             && IMFPluginControl_IsDisabled(plugin_control, MF_Plugin_Type_MFT, &mft->clsid) == S_OK)
1036     {
1037         return FALSE;
1038     }
1039
1040     if (input_type)
1041     {
1042         for (i = 0, matching = FALSE; input_type && i < mft->input_types_count; ++i)
1043         {
1044             if (!memcmp(&mft->input_types[i], input_type, sizeof(*input_type)))
1045             {
1046                 matching = TRUE;
1047                 break;
1048             }
1049         }
1050     }
1051
1052     if (output_type && matching)
1053     {
1054         for (i = 0, matching = FALSE; i < mft->output_types_count; ++i)
1055         {
1056             if (!memcmp(&mft->output_types[i], output_type, sizeof(*output_type)))
1057             {
1058                 matching = TRUE;
1059                 break;
1060             }
1061         }
1062     }
1063
1064     return matching;
1065 }
1066
1067 static void mft_get_reg_type_info(const WCHAR *clsidW, const WCHAR *typeW, MFT_REGISTER_TYPE_INFO **type,
1068         UINT32 *count)
1069 {
1070     HKEY htransform, hfilter;
1071     DWORD reg_type, size;
1072
1073     *type = NULL;
1074     *count = 0;
1075
1076     if (RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
1077         return;
1078
1079     if (RegOpenKeyW(htransform, clsidW, &hfilter))
1080     {
1081         RegCloseKey(htransform);
1082         return;
1083     }
1084
1085     if (RegQueryValueExW(hfilter, typeW, NULL, &reg_type, NULL, &size))
1086         goto out;
1087
1088     if (reg_type != REG_BINARY)
1089         goto out;
1090
1091     if (!size || size % sizeof(**type))
1092         goto out;
1093
1094     if (!(*type = heap_alloc(size)))
1095         goto out;
1096
1097     *count = size / sizeof(**type);
1098
1099     if (RegQueryValueExW(hfilter, typeW, NULL, &reg_type, (BYTE *)*type, &size))
1100     {
1101         heap_free(*type);
1102         *type = NULL;
1103         *count = 0;
1104     }
1105
1106 out:
1107     RegCloseKey(hfilter);
1108     RegCloseKey(htransform);
1109 }
1110
1111 static void mft_get_reg_flags(const WCHAR *clsidW, const WCHAR *nameW, DWORD *flags)
1112 {
1113     DWORD ret, reg_type, size;
1114     HKEY hroot, hmft;
1115
1116     *flags = 0;
1117
1118     if (RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &hroot))
1119         return;
1120
1121     ret = RegOpenKeyW(hroot, clsidW, &hmft);
1122     RegCloseKey(hroot);
1123     if (ret)
1124         return;
1125
1126     reg_type = 0;
1127     if (!RegQueryValueExW(hmft, nameW, NULL, &reg_type, NULL, &size) && reg_type == REG_DWORD)
1128         RegQueryValueExW(hmft, nameW, NULL, &reg_type, (BYTE *)flags, &size);
1129
1130     RegCloseKey(hmft);
1131 }
1132
1133 static HRESULT mft_collect_machine_reg(struct list *mfts, const GUID *category, UINT32 flags,
1134         IMFPluginControl *plugin_control, const MFT_REGISTER_TYPE_INFO *input_type,
1135         const MFT_REGISTER_TYPE_INFO *output_type)
1136 {
1137     struct mft_registration mft, *cur;
1138     HKEY hcategory, hlist;
1139     WCHAR clsidW[64];
1140     DWORD ret, size;
1141     int index = 0;
1142
1143     if (RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
1144         return E_FAIL;
1145
1146     GUIDToString(clsidW, category);
1147     ret = RegOpenKeyW(hcategory, clsidW, &hlist);
1148     RegCloseKey(hcategory);
1149     if (ret)
1150         return E_FAIL;
1151
1152     size = ARRAY_SIZE(clsidW);
1153     while (!RegEnumKeyExW(hlist, index, clsidW, &size, NULL, NULL, NULL, NULL))
1154     {
1155         memset(&mft, 0, sizeof(mft));
1156         mft.category = *category;
1157         if (!GUIDFromString(clsidW, &mft.clsid))
1158             goto next;
1159
1160         mft_get_reg_flags(clsidW, mftflagsW, &mft.flags);
1161
1162         if (output_type)
1163             mft_get_reg_type_info(clsidW, outputtypesW, &mft.output_types, &mft.output_types_count);
1164
1165         if (input_type)
1166             mft_get_reg_type_info(clsidW, inputtypesW, &mft.input_types, &mft.input_types_count);
1167
1168         if (!mft_is_type_info_match(&mft, category, flags, plugin_control, input_type, output_type))
1169         {
1170             heap_free(mft.input_types);
1171             heap_free(mft.output_types);
1172             goto next;
1173         }
1174
1175         cur = heap_alloc(sizeof(*cur));
1176         /* Reuse allocated type arrays. */
1177         *cur = mft;
1178         list_add_tail(mfts, &cur->entry);
1179
1180     next:
1181         size = ARRAY_SIZE(clsidW);
1182         index++;
1183     }
1184
1185     return S_OK;
1186 }
1187
1188 static BOOL mft_is_preferred(IMFPluginControl *plugin_control, const CLSID *clsid)
1189 {
1190     CLSID preferred;
1191     WCHAR *selector;
1192     int index = 0;
1193
1194     while (SUCCEEDED(IMFPluginControl_GetPreferredClsidByIndex(plugin_control, MF_Plugin_Type_MFT, index++, &selector,
1195             &preferred)))
1196     {
1197         CoTaskMemFree(selector);
1198
1199         if (IsEqualGUID(&preferred, clsid))
1200             return TRUE;
1201     }
1202
1203     return FALSE;
1204 }
1205
1206 static HRESULT mft_enum(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
1207         const MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes, IMFActivate ***activate, UINT32 *count)
1208 {
1209     IMFPluginControl *plugin_control = NULL;
1210     struct list mfts, mfts_sorted, *result = &mfts;
1211     struct mft_registration *mft, *mft2;
1212     unsigned int obj_count;
1213     HRESULT hr;
1214
1215     *count = 0;
1216     *activate = NULL;
1217
1218     if (!flags)
1219         flags = MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_LOCALMFT | MFT_ENUM_FLAG_SORTANDFILTER;
1220
1221     /* Synchronous processing is default. */
1222     if (!(flags & (MFT_ENUM_FLAG_SYNCMFT | MFT_ENUM_FLAG_ASYNCMFT | MFT_ENUM_FLAG_HARDWARE)))
1223         flags |= MFT_ENUM_FLAG_SYNCMFT;
1224
1225     if (FAILED(hr = MFGetPluginControl(&plugin_control)))
1226     {
1227         WARN("Failed to get plugin control instance, hr %#x.\n", hr);
1228         return hr;
1229     }
1230
1231     list_init(&mfts);
1232
1233     /* Collect from registry */
1234     mft_collect_machine_reg(&mfts, &category, flags, plugin_control, input_type, output_type);
1235
1236     /* Collect locally registered ones. */
1237     if (flags & MFT_ENUM_FLAG_LOCALMFT)
1238     {
1239         struct mft_registration *local;
1240
1241         EnterCriticalSection(&local_mfts_section);
1242
1243         LIST_FOR_EACH_ENTRY(local, &local_mfts, struct mft_registration, entry)
1244         {
1245             if (mft_is_type_info_match(local, &category, flags, plugin_control, input_type, output_type))
1246             {
1247                 mft = heap_alloc_zero(sizeof(*mft));
1248
1249                 mft->clsid = local->clsid;
1250                 mft->factory = local->factory;
1251                 if (mft->factory)
1252                     IClassFactory_AddRef(mft->factory);
1253                 mft->flags = local->flags;
1254                 mft->local = local->local;
1255
1256                 list_add_tail(&mfts, &mft->entry);
1257             }
1258         }
1259
1260         LeaveCriticalSection(&local_mfts_section);
1261     }
1262
1263     list_init(&mfts_sorted);
1264
1265     if (flags & MFT_ENUM_FLAG_SORTANDFILTER)
1266     {
1267         /* Local registrations. */
1268         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1269         {
1270             if (mft->local)
1271             {
1272                 list_remove(&mft->entry);
1273                 list_add_tail(&mfts_sorted, &mft->entry);
1274             }
1275         }
1276
1277         /* FIXME: Sort by merit value, for the ones that got it. Currently not handled. */
1278
1279         /* Preferred transforms. */
1280         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1281         {
1282             if (!mft->factory && mft_is_preferred(plugin_control, &mft->clsid))
1283             {
1284                 list_remove(&mft->entry);
1285                 list_add_tail(&mfts_sorted, &mft->entry);
1286             }
1287         }
1288
1289         /* Append the rest. */
1290         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1291         {
1292             list_remove(&mft->entry);
1293             list_add_tail(&mfts_sorted, &mft->entry);
1294         }
1295
1296         result = &mfts_sorted;
1297     }
1298
1299     IMFPluginControl_Release(plugin_control);
1300
1301     /* Create activation objects from CLSID/IClassFactory. */
1302
1303     obj_count = list_count(result);
1304
1305     if (obj_count)
1306     {
1307         if (!(*activate = CoTaskMemAlloc(obj_count * sizeof(**activate))))
1308             hr = E_OUTOFMEMORY;
1309
1310         obj_count = 0;
1311
1312         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, result, struct mft_registration, entry)
1313         {
1314             IMFActivate *mft_activate;
1315
1316             if (*activate)
1317             {
1318                 if (SUCCEEDED(create_transform_activate(mft->factory, &mft_activate)))
1319                 {
1320                     (*activate)[obj_count] = mft_activate;
1321
1322                     if (mft->local)
1323                     {
1324                         IMFActivate_SetUINT32(mft_activate, &MFT_PROCESS_LOCAL_Attribute, 1);
1325                     }
1326                     else
1327                     {
1328                         if (mft->name)
1329                             IMFActivate_SetString(mft_activate, &MFT_FRIENDLY_NAME_Attribute, mft->name);
1330                         if (mft->input_types)
1331                             IMFActivate_SetBlob(mft_activate, &MFT_INPUT_TYPES_Attributes, (const UINT8 *)mft->input_types,
1332                                     sizeof(*mft->input_types) * mft->input_types_count);
1333                         if (mft->output_types)
1334                             IMFActivate_SetBlob(mft_activate, &MFT_OUTPUT_TYPES_Attributes, (const UINT8 *)mft->output_types,
1335                                     sizeof(*mft->output_types) * mft->output_types_count);
1336                     }
1337
1338                     if (!mft->factory)
1339                         IMFActivate_SetGUID(mft_activate, &MFT_TRANSFORM_CLSID_Attribute, &mft->clsid);
1340
1341                     IMFActivate_SetUINT32(mft_activate, &MF_TRANSFORM_FLAGS_Attribute, mft->flags);
1342                     IMFActivate_SetGUID(mft_activate, &MF_TRANSFORM_CATEGORY_Attribute, &mft->category);
1343
1344                     obj_count++;
1345                 }
1346             }
1347
1348             list_remove(&mft->entry);
1349             release_mft_registration(mft);
1350         }
1351     }
1352
1353     if (!obj_count)
1354     {
1355         CoTaskMemFree(*activate);
1356         *activate = NULL;
1357     }
1358     *count = obj_count;
1359
1360     return hr;
1361 }
1362
1363 /***********************************************************************
1364  *      MFTEnum (mfplat.@)
1365  */
1366 HRESULT WINAPI MFTEnum(GUID category, UINT32 flags, MFT_REGISTER_TYPE_INFO *input_type,
1367         MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes, CLSID **clsids, UINT32 *count)
1368 {
1369     struct mft_registration *mft, *mft2;
1370     unsigned int mft_count;
1371     struct list mfts;
1372     HRESULT hr;
1373
1374     TRACE("%s, %#x, %p, %p, %p, %p, %p.\n", debugstr_guid(&category), flags, input_type, output_type, attributes,
1375             clsids, count);
1376
1377     if (!clsids || !count)
1378         return E_INVALIDARG;
1379
1380     *count = 0;
1381
1382     list_init(&mfts);
1383
1384     if (FAILED(hr = mft_collect_machine_reg(&mfts, &category, MFT_ENUM_FLAG_SYNCMFT, NULL, input_type, output_type)))
1385         return hr;
1386
1387     mft_count = list_count(&mfts);
1388
1389     if (mft_count)
1390     {
1391         if (!(*clsids = CoTaskMemAlloc(mft_count * sizeof(**clsids))))
1392             hr = E_OUTOFMEMORY;
1393
1394         mft_count = 0;
1395         LIST_FOR_EACH_ENTRY_SAFE(mft, mft2, &mfts, struct mft_registration, entry)
1396         {
1397             if (*clsids)
1398                 (*clsids)[mft_count++] = mft->clsid;
1399             list_remove(&mft->entry);
1400             release_mft_registration(mft);
1401         }
1402     }
1403
1404     if (!mft_count)
1405     {
1406         CoTaskMemFree(*clsids);
1407         *clsids = NULL;
1408     }
1409     *count = mft_count;
1410
1411     return hr;
1412 }
1413
1414 /***********************************************************************
1415  *      MFTEnumEx (mfplat.@)
1416  */
1417 HRESULT WINAPI MFTEnumEx(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
1418         const MFT_REGISTER_TYPE_INFO *output_type, IMFActivate ***activate, UINT32 *count)
1419 {
1420     TRACE("%s, %#x, %p, %p, %p, %p.\n", debugstr_guid(&category), flags, input_type, output_type, activate, count);
1421
1422     return mft_enum(category, flags, input_type, output_type, NULL, activate, count);
1423 }
1424
1425 /***********************************************************************
1426  *      MFTEnum2 (mfplat.@)
1427  */
1428 HRESULT WINAPI MFTEnum2(GUID category, UINT32 flags, const MFT_REGISTER_TYPE_INFO *input_type,
1429         const MFT_REGISTER_TYPE_INFO *output_type, IMFAttributes *attributes, IMFActivate ***activate, UINT32 *count)
1430 {
1431     TRACE("%s, %#x, %p, %p, %p, %p, %p.\n", debugstr_guid(&category), flags, input_type, output_type, attributes,
1432             activate, count);
1433
1434     if (attributes)
1435         FIXME("Ignoring attributes.\n");
1436
1437     return mft_enum(category, flags, input_type, output_type, attributes, activate, count);
1438 }
1439
1440 /***********************************************************************
1441  *      MFTUnregister (mfplat.@)
1442  */
1443 HRESULT WINAPI MFTUnregister(CLSID clsid)
1444 {
1445     WCHAR buffer[64], category[MAX_PATH];
1446     HKEY htransform, hcategory, htmp;
1447     DWORD size = MAX_PATH;
1448     DWORD index = 0;
1449
1450     TRACE("(%s)\n", debugstr_guid(&clsid));
1451
1452     GUIDToString(buffer, &clsid);
1453
1454     if (!RegOpenKeyW(HKEY_CLASSES_ROOT, transform_keyW, &htransform))
1455     {
1456         RegDeleteKeyW(htransform, buffer);
1457         RegCloseKey(htransform);
1458     }
1459
1460     if (!RegOpenKeyW(HKEY_CLASSES_ROOT, categories_keyW, &hcategory))
1461     {
1462         while (RegEnumKeyExW(hcategory, index, category, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
1463         {
1464             if (!RegOpenKeyW(hcategory, category, &htmp))
1465             {
1466                 RegDeleteKeyW(htmp, buffer);
1467                 RegCloseKey(htmp);
1468             }
1469             size = MAX_PATH;
1470             index++;
1471         }
1472         RegCloseKey(hcategory);
1473     }
1474
1475     return S_OK;
1476 }
1477
1478 /***********************************************************************
1479  *      MFStartup (mfplat.@)
1480  */
1481 HRESULT WINAPI MFStartup(ULONG version, DWORD flags)
1482 {
1483 #define MF_VERSION_XP   MAKELONG( MF_API_VERSION, 1 )
1484 #define MF_VERSION_WIN7 MAKELONG( MF_API_VERSION, 2 )
1485
1486     TRACE("%#x, %#x.\n", version, flags);
1487
1488     if (version != MF_VERSION_XP && version != MF_VERSION_WIN7)
1489         return MF_E_BAD_STARTUP_VERSION;
1490
1491     RtwqStartup();
1492
1493     return S_OK;
1494 }
1495
1496 /***********************************************************************
1497  *      MFShutdown (mfplat.@)
1498  */
1499 HRESULT WINAPI MFShutdown(void)
1500 {
1501     TRACE("\n");
1502
1503     RtwqShutdown();
1504
1505     return S_OK;
1506 }
1507
1508 /***********************************************************************
1509  *      MFCopyImage (mfplat.@)
1510  */
1511 HRESULT WINAPI MFCopyImage(BYTE *dest, LONG deststride, const BYTE *src, LONG srcstride, DWORD width, DWORD lines)
1512 {
1513     TRACE("(%p, %d, %p, %d, %u, %u)\n", dest, deststride, src, srcstride, width, lines);
1514
1515     while (lines--)
1516     {
1517         memcpy(dest, src, width);
1518         dest += deststride;
1519         src += srcstride;
1520     }
1521
1522     return S_OK;
1523 }
1524
1525 struct guid_def
1526 {
1527     const GUID *guid;
1528     const char *name;
1529 };
1530
1531 static int __cdecl debug_compare_guid(const void *a, const void *b)
1532 {
1533     const GUID *guid = a;
1534     const struct guid_def *guid_def = b;
1535     return memcmp(guid, guid_def->guid, sizeof(*guid));
1536 }
1537
1538 const char *debugstr_attr(const GUID *guid)
1539 {
1540     static const struct guid_def guid_defs[] =
1541     {
1542 #define X(g) { &(g), #g }
1543         X(MF_READWRITE_MMCSS_CLASS),
1544         X(MF_TOPONODE_MARKIN_HERE),
1545         X(MF_TOPONODE_MARKOUT_HERE),
1546         X(MF_TOPONODE_DECODER),
1547         X(MF_TOPOLOGY_PROJECTSTART),
1548         X(MF_TOPOLOGY_PROJECTSTOP),
1549         X(MF_SINK_WRITER_ENCODER_CONFIG),
1550         X(MF_TOPOLOGY_NO_MARKIN_MARKOUT),
1551         X(MF_SOURCE_READER_ENABLE_TRANSCODE_ONLY_TRANSFORMS),
1552         X(MFT_PREFERRED_ENCODER_PROFILE),
1553         X(MF_TOPOLOGY_DYNAMIC_CHANGE_NOT_ALLOWED),
1554         X(MF_MT_ALPHA_MODE),
1555         X(MF_PMP_SERVER_CONTEXT),
1556         X(MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE),
1557         X(MFT_CODEC_MERIT_Attribute),
1558         X(MF_TOPOLOGY_PLAYBACK_MAX_DIMS),
1559         X(MF_LOW_LATENCY),
1560         X(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS),
1561         X(MF_MT_PIXEL_ASPECT_RATIO),
1562         X(MF_TOPOLOGY_ENABLE_XVP_FOR_PLAYBACK),
1563         X(MFT_CONNECTED_STREAM_ATTRIBUTE),
1564         X(MF_MT_WRAPPED_TYPE),
1565         X(MF_MT_AVG_BITRATE),
1566         X(MFT_CONNECTED_TO_HW_STREAM),
1567         X(MF_SA_D3D_AWARE),
1568         X(MFT_TRANSFORM_CLSID_Attribute),
1569         X(MFT_TRANSFORM_CLSID_Attribute),
1570         X(MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING),
1571         X(MF_SESSION_APPROX_EVENT_OCCURRENCE_TIME),
1572         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_MAX_BUFFERS),
1573         X(MF_MT_AUDIO_BLOCK_ALIGNMENT),
1574         X(MF_PD_PMPHOST_CONTEXT),
1575         X(MF_PD_APP_CONTEXT),
1576         X(MF_PD_DURATION),
1577         X(MF_PD_TOTAL_FILE_SIZE),
1578         X(MF_PD_AUDIO_ENCODING_BITRATE),
1579         X(MF_PD_VIDEO_ENCODING_BITRATE),
1580         X(MFSampleExtension_TargetGlobalLuminance),
1581         X(MF_PD_MIME_TYPE),
1582         X(MF_PD_LAST_MODIFIED_TIME),
1583         X(MF_PD_PLAYBACK_ELEMENT_ID),
1584         X(MF_MT_ALL_SAMPLES_INDEPENDENT),
1585         X(MF_PD_PREFERRED_LANGUAGE),
1586         X(MF_PD_PLAYBACK_BOUNDARY_TIME),
1587         X(MF_ACTIVATE_MFT_LOCKED),
1588         X(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING),
1589         X(MF_MT_FRAME_SIZE),
1590         X(MF_SINK_WRITER_ASYNC_CALLBACK),
1591         X(MF_TOPOLOGY_START_TIME_ON_PRESENTATION_SWITCH),
1592         X(MFT_DECODER_EXPOSE_OUTPUT_TYPES_IN_NATIVE_ORDER),
1593         X(MF_TOPONODE_WORKQUEUE_MMCSS_PRIORITY),
1594         X(MF_MT_FRAME_RATE_RANGE_MAX),
1595         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_PROVIDER_DEVICE_ID),
1596         X(MF_TOPOLOGY_STATIC_PLAYBACK_OPTIMIZATIONS),
1597         X(MF_TRANSFORM_CATEGORY_Attribute),
1598         X(MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND),
1599         X(MFSampleExtension_ForwardedDecodeUnits),
1600         X(MF_EVENT_SOURCE_TOPOLOGY_CANCELED),
1601         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID),
1602         X(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME),
1603         X(MF_MT_VIDEO_ROTATION),
1604         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_SYMBOLIC_LINK),
1605         X(MF_MT_USER_DATA),
1606         X(MF_EVENT_STREAM_METADATA_SYSTEMID),
1607         X(MF_MT_AUDIO_CHANNEL_MASK),
1608         X(MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN),
1609         X(MF_READWRITE_DISABLE_CONVERTERS),
1610         X(MFSampleExtension_Token),
1611         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY),
1612         X(MF_MT_AUDIO_VALID_BITS_PER_SAMPLE),
1613         X(MF_TRANSFORM_ASYNC_UNLOCK),
1614         X(MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES),
1615         X(MF_MT_VIDEO_NO_FRAME_ORDERING),
1616         X(MFSampleExtension_3DVideo_SampleFormat),
1617         X(MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET),
1618         X(MF_MT_SAMPLE_SIZE),
1619         X(MF_MT_AAC_PAYLOAD_TYPE),
1620         X(MF_TOPOLOGY_PLAYBACK_FRAMERATE),
1621         X(MF_SOURCE_READER_D3D11_BIND_FLAGS),
1622         X(MF_MT_AUDIO_FOLDDOWN_MATRIX),
1623         X(MF_MT_AUDIO_WMADRC_PEAKREF),
1624         X(MF_MT_AUDIO_WMADRC_PEAKTARGET),
1625         X(MF_TRANSFORM_FLAGS_Attribute),
1626         X(MF_PD_SAMI_STYLELIST),
1627         X(MF_MT_AUDIO_WMADRC_AVGREF),
1628         X(MF_MT_AUDIO_BITS_PER_SAMPLE),
1629         X(MF_SD_LANGUAGE),
1630         X(MF_MT_AUDIO_WMADRC_AVGTARGET),
1631         X(MF_SD_PROTECTED),
1632         X(MF_SESSION_TOPOLOADER),
1633         X(MF_SESSION_GLOBAL_TIME),
1634         X(MF_SESSION_QUALITY_MANAGER),
1635         X(MF_SESSION_CONTENT_PROTECTION_MANAGER),
1636         X(MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT),
1637         X(MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT),
1638         X(MF_READWRITE_MMCSS_PRIORITY_AUDIO),
1639         X(MF_BYTESTREAM_ORIGIN_NAME),
1640         X(MF_BYTESTREAM_CONTENT_TYPE),
1641         X(MF_MT_DEPTH_MEASUREMENT),
1642         X(MF_MT_VIDEO_3D_NUM_VIEWS),
1643         X(MF_BYTESTREAM_DURATION),
1644         X(MF_SD_SAMI_LANGUAGE),
1645         X(MF_EVENT_OUTPUT_NODE),
1646         X(MF_BYTESTREAM_LAST_MODIFIED_TIME),
1647         X(MFT_ENUM_ADAPTER_LUID),
1648         X(MF_MT_FRAME_RATE_RANGE_MIN),
1649         X(MF_BYTESTREAM_IFO_FILE_URI),
1650         X(MF_EVENT_TOPOLOGY_STATUS),
1651         X(MF_BYTESTREAM_DLNA_PROFILE_ID),
1652         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ROLE),
1653         X(MF_MT_MAJOR_TYPE),
1654         X(MF_EVENT_SOURCE_CHARACTERISTICS),
1655         X(MF_EVENT_SOURCE_CHARACTERISTICS_OLD),
1656         X(MF_SESSION_SERVER_CONTEXT),
1657         X(MF_MT_VIDEO_3D_FIRST_IS_LEFT),
1658         X(MFT_DECODER_FINAL_VIDEO_RESOLUTION_HINT),
1659         X(MF_PD_ADAPTIVE_STREAMING),
1660         X(MFT_PREFERRED_OUTPUTTYPE_Attribute),
1661         X(MFSampleExtension_Timestamp),
1662         X(MF_TOPONODE_PRIMARYOUTPUT),
1663         X(MF_MT_SUBTYPE),
1664         X(MF_TRANSFORM_ASYNC),
1665         X(MF_TOPONODE_STREAMID),
1666         X(MF_TOPONODE_NOSHUTDOWN_ON_REMOVE),
1667         X(MF_SD_MUTUALLY_EXCLUSIVE),
1668         X(MF_SD_STREAM_NAME),
1669         X(MF_TOPONODE_RATELESS),
1670         X(MF_EVENT_STREAM_METADATA_CONTENT_KEYIDS),
1671         X(MF_TOPONODE_DISABLE_PREROLL),
1672         X(MF_MT_VIDEO_3D_FORMAT),
1673         X(MF_EVENT_STREAM_METADATA_KEYDATA),
1674         X(MF_SOURCE_READER_D3D_MANAGER),
1675         X(MF_SINK_WRITER_D3D_MANAGER),
1676         X(MFSampleExtension_3DVideo),
1677         X(MF_EVENT_SOURCE_FAKE_START),
1678         X(MF_EVENT_SOURCE_PROJECTSTART),
1679         X(MF_EVENT_SOURCE_ACTUAL_START),
1680         X(MF_MT_AUDIO_SAMPLES_PER_BLOCK),
1681         X(MFT_ENUM_HARDWARE_URL_Attribute),
1682         X(MF_SOURCE_READER_ASYNC_CALLBACK),
1683         X(MFT_ENCODER_SUPPORTS_CONFIG_EVENT),
1684         X(MF_MT_AUDIO_FLAC_MAX_BLOCK_SIZE),
1685         X(MFT_FRIENDLY_NAME_Attribute),
1686         X(MF_MT_FIXED_SIZE_SAMPLES),
1687         X(MFT_SUPPORT_3DVIDEO),
1688         X(MFT_SUPPORT_3DVIDEO),
1689         X(MFT_INPUT_TYPES_Attributes),
1690         X(MF_EVENT_SCRUBSAMPLE_TIME),
1691         X(MF_MT_INTERLACE_MODE),
1692         X(MF_MT_VIDEO_RENDERER_EXTENSION_PROFILE),
1693         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_HW_SOURCE),
1694         X(MF_MT_AUDIO_PREFER_WAVEFORMATEX),
1695         X(MF_TOPONODE_WORKQUEUE_ITEM_PRIORITY),
1696         X(MF_SAMPLEGRABBERSINK_IGNORE_CLOCK),
1697         X(MFSampleExtension_ForwardedDecodeUnitType),
1698         X(MF_MT_AUDIO_AVG_BYTES_PER_SECOND),
1699         X(MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS),
1700         X(MF_TOPONODE_TRANSFORM_OBJECTID),
1701         X(MF_DEVSOURCE_ATTRIBUTE_MEDIA_TYPE),
1702         X(MF_EVENT_MFT_INPUT_STREAM_ID),
1703         X(MFT_ENUM_HARDWARE_VENDOR_ID_Attribute),
1704         X(MFT_ENUM_TRANSCODE_ONLY_ATTRIBUTE),
1705         X(MF_READWRITE_MMCSS_PRIORITY),
1706         X(MF_MT_VIDEO_3D),
1707         X(MF_EVENT_START_PRESENTATION_TIME),
1708         X(MF_EVENT_SESSIONCAPS),
1709         X(MF_EVENT_PRESENTATION_TIME_OFFSET),
1710         X(MF_EVENT_SESSIONCAPS_DELTA),
1711         X(MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT),
1712         X(MFSampleExtension_DecodeTimestamp),
1713         X(MF_MT_VIDEO_H264_NO_FMOASO),
1714         X(MF_SINK_WRITER_DISABLE_THROTTLING),
1715         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK),
1716         X(MF_READWRITE_D3D_OPTIONAL),
1717         X(MF_READWRITE_MMCSS_CLASS_AUDIO),
1718         X(MF_SOURCE_READER_DISABLE_CAMERA_PLUGINS),
1719         X(MF_TOPOLOGY_RESOLUTION_STATUS),
1720         X(MF_PD_AUDIO_ISVARIABLEBITRATE),
1721         X(MFT_PROCESS_LOCAL_Attribute),
1722         X(MFT_PROCESS_LOCAL_Attribute),
1723         X(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION),
1724         X(MF_MT_AUDIO_SAMPLES_PER_SECOND),
1725         X(MF_MT_FRAME_RATE),
1726         X(MF_TOPONODE_FLUSH),
1727         X(MF_TOPONODE_DRAIN),
1728         X(MF_TOPONODE_MEDIASTART),
1729         X(MF_TOPONODE_MEDIASTOP),
1730         X(MF_SOURCE_READER_MEDIASOURCE_CONFIG),
1731         X(MF_TOPONODE_SOURCE),
1732         X(MF_TOPONODE_PRESENTATION_DESCRIPTOR),
1733         X(MF_TOPONODE_D3DAWARE),
1734         X(MF_MT_COMPRESSED),
1735         X(MF_TOPONODE_STREAM_DESCRIPTOR),
1736         X(MF_TOPONODE_ERRORCODE),
1737         X(MF_TOPONODE_SEQUENCE_ELEMENTID),
1738         X(MF_EVENT_MFT_CONTEXT),
1739         X(MF_MT_FORWARD_CUSTOM_SEI),
1740         X(MF_TOPONODE_CONNECT_METHOD),
1741         X(MFT_OUTPUT_TYPES_Attributes),
1742         X(MF_SESSION_REMOTE_SOURCE_MODE),
1743         X(MF_MT_DEPTH_VALUE_UNIT),
1744         X(MF_MT_AUDIO_NUM_CHANNELS),
1745         X(MF_TOPOLOGY_DXVA_MODE),
1746         X(MF_TOPONODE_LOCKED),
1747         X(MF_TOPONODE_WORKQUEUE_ID),
1748         X(MF_TOPONODE_WORKQUEUE_MMCSS_CLASS),
1749         X(MF_TOPONODE_DECRYPTOR),
1750         X(MF_EVENT_DO_THINNING),
1751         X(MF_TOPONODE_DISCARDABLE),
1752         X(MF_TOPOLOGY_HARDWARE_MODE),
1753         X(MF_SOURCE_READER_DISABLE_DXVA),
1754         X(MF_MT_FORWARD_CUSTOM_NALU),
1755         X(MF_TOPONODE_ERROR_MAJORTYPE),
1756         X(MF_MT_SECURE),
1757         X(MFT_FIELDOFUSE_UNLOCK_Attribute),
1758         X(MF_TOPONODE_ERROR_SUBTYPE),
1759         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE),
1760         X(MF_MT_VIDEO_3D_LEFT_IS_BASE),
1761         X(MF_TOPONODE_WORKQUEUE_MMCSS_TASKID),
1762 #undef X
1763     };
1764     struct guid_def *ret = NULL;
1765
1766     if (guid)
1767         ret = bsearch(guid, guid_defs, ARRAY_SIZE(guid_defs), sizeof(*guid_defs), debug_compare_guid);
1768
1769     return ret ? wine_dbg_sprintf("%s", ret->name) : wine_dbgstr_guid(guid);
1770 }
1771
1772 const char *debugstr_mf_guid(const GUID *guid)
1773 {
1774     static const struct guid_def guid_defs[] =
1775     {
1776 #define X(g) { &(g), #g }
1777         X(MFAudioFormat_ADTS),
1778         X(MFAudioFormat_PCM),
1779         X(MFAudioFormat_PCM_HDCP),
1780         X(MFAudioFormat_Float),
1781         X(MFAudioFormat_DTS),
1782         X(MFAudioFormat_DRM),
1783         X(MFAudioFormat_MSP1),
1784         X(MFAudioFormat_Vorbis),
1785         X(MFAudioFormat_AAC),
1786         X(MFVideoFormat_RGB24),
1787         X(MFVideoFormat_ARGB32),
1788         X(MFVideoFormat_RGB32),
1789         X(MFVideoFormat_RGB565),
1790         X(MFVideoFormat_RGB555),
1791         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID),
1792         X(MFVideoFormat_A2R10G10B10),
1793         X(MFMediaType_Script),
1794         X(MFMediaType_Image),
1795         X(MFMediaType_HTML),
1796         X(MFMediaType_Binary),
1797         X(MFVideoFormat_MPEG2),
1798         X(MFMediaType_FileTransfer),
1799         X(MFVideoFormat_RGB8),
1800         X(MFAudioFormat_Dolby_AC3),
1801         X(MFVideoFormat_L8),
1802         X(MFAudioFormat_LPCM),
1803         X(MFVideoFormat_420O),
1804         X(MFVideoFormat_AI44),
1805         X(MFVideoFormat_AV1),
1806         X(MFVideoFormat_AYUV),
1807         X(MFVideoFormat_H263),
1808         X(MFVideoFormat_H264),
1809         X(MFVideoFormat_H265),
1810         X(MFVideoFormat_HEVC),
1811         X(MFVideoFormat_HEVC_ES),
1812         X(MFVideoFormat_I420),
1813         X(MFVideoFormat_IYUV),
1814         X(MFVideoFormat_M4S2),
1815         X(MFVideoFormat_MJPG),
1816         X(MFVideoFormat_MP43),
1817         X(MFVideoFormat_MP4S),
1818         X(MFVideoFormat_MP4V),
1819         X(MFVideoFormat_MPG1),
1820         X(MFVideoFormat_MSS1),
1821         X(MFVideoFormat_MSS2),
1822         X(MFVideoFormat_NV11),
1823         X(MFVideoFormat_NV12),
1824         X(MFVideoFormat_ORAW),
1825         X(MFAudioFormat_Opus),
1826         X(MFVideoFormat_D16),
1827         X(MFAudioFormat_MPEG),
1828         X(MFVideoFormat_P010),
1829         X(MFVideoFormat_P016),
1830         X(MFVideoFormat_P210),
1831         X(MFVideoFormat_P216),
1832         X(MFVideoFormat_L16),
1833         X(MFAudioFormat_MP3),
1834         X(MFVideoFormat_UYVY),
1835         X(MFVideoFormat_VP10),
1836         X(MFVideoFormat_VP80),
1837         X(MFVideoFormat_VP90),
1838         X(MFVideoFormat_WMV1),
1839         X(MFVideoFormat_WMV2),
1840         X(MFVideoFormat_WMV3),
1841         X(MFVideoFormat_WVC1),
1842         X(MFVideoFormat_Y210),
1843         X(MFVideoFormat_Y216),
1844         X(MFVideoFormat_Y410),
1845         X(MFVideoFormat_Y416),
1846         X(MFVideoFormat_Y41P),
1847         X(MFVideoFormat_Y41T),
1848         X(MFVideoFormat_Y42T),
1849         X(MFVideoFormat_YUY2),
1850         X(MFVideoFormat_YV12),
1851         X(MFVideoFormat_YVU9),
1852         X(MFVideoFormat_YVYU),
1853         X(MFAudioFormat_WMAudioV8),
1854         X(MFAudioFormat_ALAC),
1855         X(MFAudioFormat_AMR_NB),
1856         X(MFMediaType_Audio),
1857         X(MFAudioFormat_WMAudioV9),
1858         X(MFAudioFormat_AMR_WB),
1859         X(MFAudioFormat_WMAudio_Lossless),
1860         X(MFAudioFormat_AMR_WP),
1861         X(MFAudioFormat_WMASPDIF),
1862         X(MFVideoFormat_DV25),
1863         X(MFVideoFormat_DV50),
1864         X(MFVideoFormat_DVC),
1865         X(MFVideoFormat_DVH1),
1866         X(MFVideoFormat_DVHD),
1867         X(MFVideoFormat_DVSD),
1868         X(MFVideoFormat_DVSL),
1869         X(MFVideoFormat_A16B16G16R16F),
1870         X(MFVideoFormat_v210),
1871         X(MFVideoFormat_v216),
1872         X(MFVideoFormat_v410),
1873         X(MFMediaType_Video),
1874         X(MFAudioFormat_AAC_HDCP),
1875         X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID),
1876         X(MFAudioFormat_Dolby_AC3_HDCP),
1877         X(MFMediaType_Subtitle),
1878         X(MFMediaType_Stream),
1879         X(MFAudioFormat_Dolby_AC3_SPDIF),
1880         X(MFAudioFormat_Float_SpatialObjects),
1881         X(MFMediaType_SAMI),
1882         X(MFAudioFormat_ADTS_HDCP),
1883         X(MFAudioFormat_FLAC),
1884         X(MFAudioFormat_Dolby_DDPlus),
1885         X(MFMediaType_MultiplexedFrames),
1886         X(MFAudioFormat_Base_HDCP),
1887         X(MFVideoFormat_Base_HDCP),
1888         X(MFVideoFormat_H264_HDCP),
1889         X(MFVideoFormat_HEVC_HDCP),
1890         X(MFMediaType_Default),
1891         X(MFMediaType_Protected),
1892         X(MFVideoFormat_H264_ES),
1893         X(MFMediaType_Perception),
1894 #undef X
1895     };
1896     struct guid_def *ret = NULL;
1897
1898     if (guid)
1899         ret = bsearch(guid, guid_defs, ARRAY_SIZE(guid_defs), sizeof(*guid_defs), debug_compare_guid);
1900
1901     return ret ? wine_dbg_sprintf("%s", ret->name) : wine_dbgstr_guid(guid);
1902 }
1903
1904 struct event_id
1905 {
1906     DWORD id;
1907     const char *name;
1908 };
1909
1910 static int __cdecl debug_event_id(const void *a, const void *b)
1911 {
1912     const DWORD *id = a;
1913     const struct event_id *event_id = b;
1914     return *id - event_id->id;
1915 }
1916
1917 static const char *debugstr_eventid(DWORD event)
1918 {
1919     static const struct event_id
1920     {
1921         DWORD id;
1922         const char *name;
1923     }
1924     event_ids[] =
1925     {
1926 #define X(e) { e, #e }
1927         X(MEUnknown),
1928         X(MEError),
1929         X(MEExtendedType),
1930         X(MENonFatalError),
1931         X(MESessionUnknown),
1932         X(MESessionTopologySet),
1933         X(MESessionTopologiesCleared),
1934         X(MESessionStarted),
1935         X(MESessionPaused),
1936         X(MESessionStopped),
1937         X(MESessionClosed),
1938         X(MESessionEnded),
1939         X(MESessionRateChanged),
1940         X(MESessionScrubSampleComplete),
1941         X(MESessionCapabilitiesChanged),
1942         X(MESessionTopologyStatus),
1943         X(MESessionNotifyPresentationTime),
1944         X(MENewPresentation),
1945         X(MELicenseAcquisitionStart),
1946         X(MELicenseAcquisitionCompleted),
1947         X(MEIndividualizationStart),
1948         X(MEIndividualizationCompleted),
1949         X(MEEnablerProgress),
1950         X(MEEnablerCompleted),
1951         X(MEPolicyError),
1952         X(MEPolicyReport),
1953         X(MEBufferingStarted),
1954         X(MEBufferingStopped),
1955         X(MEConnectStart),
1956         X(MEConnectEnd),
1957         X(MEReconnectStart),
1958         X(MEReconnectEnd),
1959         X(MERendererEvent),
1960         X(MESessionStreamSinkFormatChanged),
1961         X(MESourceUnknown),
1962         X(MESourceStarted),
1963         X(MEStreamStarted),
1964         X(MESourceSeeked),
1965         X(MEStreamSeeked),
1966         X(MENewStream),
1967         X(MEUpdatedStream),
1968         X(MESourceStopped),
1969         X(MEStreamStopped),
1970         X(MESourcePaused),
1971         X(MEStreamPaused),
1972         X(MEEndOfPresentation),
1973         X(MEEndOfStream),
1974         X(MEMediaSample),
1975         X(MEStreamTick),
1976         X(MEStreamThinMode),
1977         X(MEStreamFormatChanged),
1978         X(MESourceRateChanged),
1979         X(MEEndOfPresentationSegment),
1980         X(MESourceCharacteristicsChanged),
1981         X(MESourceRateChangeRequested),
1982         X(MESourceMetadataChanged),
1983         X(MESequencerSourceTopologyUpdated),
1984         X(MESinkUnknown),
1985         X(MEStreamSinkStarted),
1986         X(MEStreamSinkStopped),
1987         X(MEStreamSinkPaused),
1988         X(MEStreamSinkRateChanged),
1989         X(MEStreamSinkRequestSample),
1990         X(MEStreamSinkMarker),
1991         X(MEStreamSinkPrerolled),
1992         X(MEStreamSinkScrubSampleComplete),
1993         X(MEStreamSinkFormatChanged),
1994         X(MEStreamSinkDeviceChanged),
1995         X(MEQualityNotify),
1996         X(MESinkInvalidated),
1997         X(MEAudioSessionNameChanged),
1998         X(MEAudioSessionVolumeChanged),
1999         X(MEAudioSessionDeviceRemoved),
2000         X(MEAudioSessionServerShutdown),
2001         X(MEAudioSessionGroupingParamChanged),
2002         X(MEAudioSessionIconChanged),
2003         X(MEAudioSessionFormatChanged),
2004         X(MEAudioSessionDisconnected),
2005         X(MEAudioSessionExclusiveModeOverride),
2006         X(METrustUnknown),
2007         X(MEPolicyChanged),
2008         X(MEContentProtectionMessage),
2009         X(MEPolicySet),
2010         X(MEWMDRMLicenseBackupCompleted),
2011         X(MEWMDRMLicenseBackupProgress),
2012         X(MEWMDRMLicenseRestoreCompleted),
2013         X(MEWMDRMLicenseRestoreProgress),
2014         X(MEWMDRMLicenseAcquisitionCompleted),
2015         X(MEWMDRMIndividualizationCompleted),
2016         X(MEWMDRMIndividualizationProgress),
2017         X(MEWMDRMProximityCompleted),
2018         X(MEWMDRMLicenseStoreCleaned),
2019         X(MEWMDRMRevocationDownloadCompleted),
2020 #undef X
2021     };
2022
2023     struct event_id *ret = bsearch(&event, event_ids, ARRAY_SIZE(event_ids), sizeof(*event_ids), debug_event_id);
2024     return ret ? wine_dbg_sprintf("%s", ret->name) : wine_dbg_sprintf("%u", event);
2025 }
2026
2027 static inline struct attributes *impl_from_IMFAttributes(IMFAttributes *iface)
2028 {
2029     return CONTAINING_RECORD(iface, struct attributes, IMFAttributes_iface);
2030 }
2031
2032 static HRESULT WINAPI mfattributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **out)
2033 {
2034     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
2035
2036     if (IsEqualIID(riid, &IID_IMFAttributes) ||
2037             IsEqualGUID(riid, &IID_IUnknown))
2038     {
2039         *out = iface;
2040         IMFAttributes_AddRef(iface);
2041         return S_OK;
2042     }
2043
2044     WARN("Unsupported %s.\n", debugstr_guid(riid));
2045     *out = NULL;
2046     return E_NOINTERFACE;
2047 }
2048
2049 static ULONG WINAPI mfattributes_AddRef(IMFAttributes *iface)
2050 {
2051     struct attributes *attributes = impl_from_IMFAttributes(iface);
2052     ULONG refcount = InterlockedIncrement(&attributes->ref);
2053
2054     TRACE("%p, refcount %d.\n", iface, refcount);
2055
2056     return refcount;
2057 }
2058
2059 static ULONG WINAPI mfattributes_Release(IMFAttributes *iface)
2060 {
2061     struct attributes *attributes = impl_from_IMFAttributes(iface);
2062     ULONG refcount = InterlockedDecrement(&attributes->ref);
2063
2064     TRACE("%p, refcount %d.\n", iface, refcount);
2065
2066     if (!refcount)
2067     {
2068         clear_attributes_object(attributes);
2069         heap_free(attributes);
2070     }
2071
2072     return refcount;
2073 }
2074
2075 static struct attribute *attributes_find_item(struct attributes *attributes, REFGUID key, size_t *index)
2076 {
2077     size_t i;
2078
2079     for (i = 0; i < attributes->count; ++i)
2080     {
2081         if (IsEqualGUID(key, &attributes->attributes[i].key))
2082         {
2083             if (index)
2084                 *index = i;
2085             return &attributes->attributes[i];
2086         }
2087     }
2088
2089     return NULL;
2090 }
2091
2092 static HRESULT attributes_get_item(struct attributes *attributes, const GUID *key, PROPVARIANT *value)
2093 {
2094     struct attribute *attribute;
2095     HRESULT hr;
2096
2097     EnterCriticalSection(&attributes->cs);
2098
2099     attribute = attributes_find_item(attributes, key, NULL);
2100     if (attribute)
2101     {
2102         if (attribute->value.vt == value->vt && !(value->vt == VT_UNKNOWN && !attribute->value.u.punkVal))
2103             hr = PropVariantCopy(value, &attribute->value);
2104         else
2105             hr = MF_E_INVALIDTYPE;
2106     }
2107     else
2108         hr = MF_E_ATTRIBUTENOTFOUND;
2109
2110     LeaveCriticalSection(&attributes->cs);
2111
2112     return hr;
2113 }
2114
2115 HRESULT attributes_GetItem(struct attributes *attributes, REFGUID key, PROPVARIANT *value)
2116 {
2117     struct attribute *attribute;
2118     HRESULT hr;
2119
2120     EnterCriticalSection(&attributes->cs);
2121
2122     if ((attribute = attributes_find_item(attributes, key, NULL)))
2123         hr = value ? PropVariantCopy(value, &attribute->value) : S_OK;
2124     else
2125         hr = MF_E_ATTRIBUTENOTFOUND;
2126
2127     LeaveCriticalSection(&attributes->cs);
2128
2129     return hr;
2130 }
2131
2132 HRESULT attributes_GetItemType(struct attributes *attributes, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2133 {
2134     struct attribute *attribute;
2135     HRESULT hr = S_OK;
2136
2137     EnterCriticalSection(&attributes->cs);
2138
2139     if ((attribute = attributes_find_item(attributes, key, NULL)))
2140     {
2141         *type = attribute->value.vt;
2142     }
2143     else
2144         hr = MF_E_ATTRIBUTENOTFOUND;
2145
2146     LeaveCriticalSection(&attributes->cs);
2147
2148     return hr;
2149 }
2150
2151 HRESULT attributes_CompareItem(struct attributes *attributes, REFGUID key, REFPROPVARIANT value, BOOL *result)
2152 {
2153     struct attribute *attribute;
2154
2155     *result = FALSE;
2156
2157     EnterCriticalSection(&attributes->cs);
2158
2159     if ((attribute = attributes_find_item(attributes, key, NULL)))
2160     {
2161         *result = attribute->value.vt == value->vt &&
2162                 !PropVariantCompareEx(&attribute->value, value, PVCU_DEFAULT, PVCF_DEFAULT);
2163     }
2164
2165     LeaveCriticalSection(&attributes->cs);
2166
2167     return S_OK;
2168 }
2169
2170 HRESULT attributes_Compare(struct attributes *attributes, IMFAttributes *theirs,
2171         MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
2172 {
2173     IMFAttributes *smaller, *other;
2174     MF_ATTRIBUTE_TYPE type;
2175     HRESULT hr = S_OK;
2176     UINT32 count;
2177     BOOL result;
2178     size_t i;
2179
2180     if (FAILED(hr = IMFAttributes_GetCount(theirs, &count)))
2181         return hr;
2182
2183     EnterCriticalSection(&attributes->cs);
2184
2185     result = TRUE;
2186
2187     switch (match_type)
2188     {
2189         case MF_ATTRIBUTES_MATCH_OUR_ITEMS:
2190             for (i = 0; i < attributes->count; ++i)
2191             {
2192                 if (FAILED(hr = IMFAttributes_CompareItem(theirs, &attributes->attributes[i].key,
2193                         &attributes->attributes[i].value, &result)))
2194                     break;
2195                 if (!result)
2196                     break;
2197             }
2198             break;
2199         case MF_ATTRIBUTES_MATCH_THEIR_ITEMS:
2200             hr = IMFAttributes_Compare(theirs, &attributes->IMFAttributes_iface, MF_ATTRIBUTES_MATCH_OUR_ITEMS, &result);
2201             break;
2202         case MF_ATTRIBUTES_MATCH_ALL_ITEMS:
2203             if (count != attributes->count)
2204             {
2205                 result = FALSE;
2206                 break;
2207             }
2208             for (i = 0; i < count; ++i)
2209             {
2210                 if (FAILED(hr = IMFAttributes_CompareItem(theirs, &attributes->attributes[i].key,
2211                         &attributes->attributes[i].value, &result)))
2212                     break;
2213                 if (!result)
2214                     break;
2215             }
2216             break;
2217         case MF_ATTRIBUTES_MATCH_INTERSECTION:
2218             for (i = 0; i < attributes->count; ++i)
2219             {
2220                 if (FAILED(IMFAttributes_GetItemType(theirs, &attributes->attributes[i].key, &type)))
2221                     continue;
2222
2223                 if (FAILED(hr = IMFAttributes_CompareItem(theirs, &attributes->attributes[i].key,
2224                         &attributes->attributes[i].value, &result)))
2225                     break;
2226
2227                 if (!result)
2228                     break;
2229             }
2230             break;
2231         case MF_ATTRIBUTES_MATCH_SMALLER:
2232             smaller = attributes->count > count ? theirs : &attributes->IMFAttributes_iface;
2233             other = attributes->count > count ? &attributes->IMFAttributes_iface : theirs;
2234             hr = IMFAttributes_Compare(smaller, other, MF_ATTRIBUTES_MATCH_OUR_ITEMS, &result);
2235             break;
2236         default:
2237             WARN("Unknown match type %d.\n", match_type);
2238             hr = E_INVALIDARG;
2239     }
2240
2241     LeaveCriticalSection(&attributes->cs);
2242
2243     if (SUCCEEDED(hr))
2244         *ret = result;
2245
2246     return hr;
2247 }
2248
2249 HRESULT attributes_GetUINT32(struct attributes *attributes, REFGUID key, UINT32 *value)
2250 {
2251     PROPVARIANT attrval;
2252     HRESULT hr;
2253
2254     PropVariantInit(&attrval);
2255     attrval.vt = VT_UI4;
2256     hr = attributes_get_item(attributes, key, &attrval);
2257     if (SUCCEEDED(hr))
2258         *value = attrval.u.ulVal;
2259
2260     return hr;
2261 }
2262
2263 HRESULT attributes_GetUINT64(struct attributes *attributes, REFGUID key, UINT64 *value)
2264 {
2265     PROPVARIANT attrval;
2266     HRESULT hr;
2267
2268     PropVariantInit(&attrval);
2269     attrval.vt = VT_UI8;
2270     hr = attributes_get_item(attributes, key, &attrval);
2271     if (SUCCEEDED(hr))
2272         *value = attrval.u.uhVal.QuadPart;
2273
2274     return hr;
2275 }
2276
2277 HRESULT attributes_GetDouble(struct attributes *attributes, REFGUID key, double *value)
2278 {
2279     PROPVARIANT attrval;
2280     HRESULT hr;
2281
2282     PropVariantInit(&attrval);
2283     attrval.vt = VT_R8;
2284     hr = attributes_get_item(attributes, key, &attrval);
2285     if (SUCCEEDED(hr))
2286         *value = attrval.u.dblVal;
2287
2288     return hr;
2289 }
2290
2291 HRESULT attributes_GetGUID(struct attributes *attributes, REFGUID key, GUID *value)
2292 {
2293     struct attribute *attribute;
2294     HRESULT hr = S_OK;
2295
2296     EnterCriticalSection(&attributes->cs);
2297
2298     attribute = attributes_find_item(attributes, key, NULL);
2299     if (attribute)
2300     {
2301         if (attribute->value.vt == MF_ATTRIBUTE_GUID)
2302             *value = *attribute->value.u.puuid;
2303         else
2304             hr = MF_E_INVALIDTYPE;
2305     }
2306     else
2307         hr = MF_E_ATTRIBUTENOTFOUND;
2308
2309     LeaveCriticalSection(&attributes->cs);
2310
2311     return hr;
2312 }
2313
2314 HRESULT attributes_GetStringLength(struct attributes *attributes, REFGUID key, UINT32 *length)
2315 {
2316     struct attribute *attribute;
2317     HRESULT hr = S_OK;
2318
2319     EnterCriticalSection(&attributes->cs);
2320
2321     attribute = attributes_find_item(attributes, key, NULL);
2322     if (attribute)
2323     {
2324         if (attribute->value.vt == MF_ATTRIBUTE_STRING)
2325             *length = lstrlenW(attribute->value.u.pwszVal);
2326         else
2327             hr = MF_E_INVALIDTYPE;
2328     }
2329     else
2330         hr = MF_E_ATTRIBUTENOTFOUND;
2331
2332     LeaveCriticalSection(&attributes->cs);
2333
2334     return hr;
2335 }
2336
2337 HRESULT attributes_GetString(struct attributes *attributes, REFGUID key, WCHAR *value,
2338         UINT32 size, UINT32 *length)
2339 {
2340     struct attribute *attribute;
2341     HRESULT hr = S_OK;
2342
2343     EnterCriticalSection(&attributes->cs);
2344
2345     attribute = attributes_find_item(attributes, key, NULL);
2346     if (attribute)
2347     {
2348         if (attribute->value.vt == MF_ATTRIBUTE_STRING)
2349         {
2350             int len = lstrlenW(attribute->value.u.pwszVal);
2351
2352             if (length)
2353                 *length = len;
2354
2355             if (size <= len)
2356                 hr = STRSAFE_E_INSUFFICIENT_BUFFER;
2357             else
2358                 memcpy(value, attribute->value.u.pwszVal, (len + 1) * sizeof(WCHAR));
2359         }
2360         else
2361             hr = MF_E_INVALIDTYPE;
2362     }
2363     else
2364         hr = MF_E_ATTRIBUTENOTFOUND;
2365
2366     LeaveCriticalSection(&attributes->cs);
2367
2368     return hr;
2369 }
2370
2371 HRESULT attributes_GetAllocatedString(struct attributes *attributes, REFGUID key, WCHAR **value, UINT32 *length)
2372 {
2373     PROPVARIANT attrval;
2374     HRESULT hr;
2375
2376     PropVariantInit(&attrval);
2377     attrval.vt = VT_LPWSTR;
2378     hr = attributes_get_item(attributes, key, &attrval);
2379     if (SUCCEEDED(hr))
2380     {
2381         *value = attrval.u.pwszVal;
2382         *length = lstrlenW(*value);
2383     }
2384
2385     return hr;
2386 }
2387
2388 HRESULT attributes_GetBlobSize(struct attributes *attributes, REFGUID key, UINT32 *size)
2389 {
2390     struct attribute *attribute;
2391     HRESULT hr = S_OK;
2392
2393     EnterCriticalSection(&attributes->cs);
2394
2395     attribute = attributes_find_item(attributes, key, NULL);
2396     if (attribute)
2397     {
2398         if (attribute->value.vt == MF_ATTRIBUTE_BLOB)
2399             *size = attribute->value.u.caub.cElems;
2400         else
2401             hr = MF_E_INVALIDTYPE;
2402     }
2403     else
2404         hr = MF_E_ATTRIBUTENOTFOUND;
2405
2406     LeaveCriticalSection(&attributes->cs);
2407
2408     return hr;
2409 }
2410
2411 HRESULT attributes_GetBlob(struct attributes *attributes, REFGUID key, UINT8 *buf, UINT32 bufsize, UINT32 *blobsize)
2412 {
2413     struct attribute *attribute;
2414     HRESULT hr;
2415
2416     EnterCriticalSection(&attributes->cs);
2417
2418     attribute = attributes_find_item(attributes, key, NULL);
2419     if (attribute)
2420     {
2421         if (attribute->value.vt == MF_ATTRIBUTE_BLOB)
2422         {
2423             UINT32 size = attribute->value.u.caub.cElems;
2424
2425             if (bufsize >= size)
2426                 hr = PropVariantToBuffer(&attribute->value, buf, size);
2427             else
2428                 hr = E_NOT_SUFFICIENT_BUFFER;
2429
2430             if (blobsize)
2431                 *blobsize = size;
2432         }
2433         else
2434             hr = MF_E_INVALIDTYPE;
2435     }
2436     else
2437         hr = MF_E_ATTRIBUTENOTFOUND;
2438
2439     LeaveCriticalSection(&attributes->cs);
2440
2441     return hr;
2442 }
2443
2444 HRESULT attributes_GetAllocatedBlob(struct attributes *attributes, REFGUID key, UINT8 **buf, UINT32 *size)
2445 {
2446     PROPVARIANT attrval;
2447     HRESULT hr;
2448
2449     attrval.vt = VT_VECTOR | VT_UI1;
2450     hr = attributes_get_item(attributes, key, &attrval);
2451     if (SUCCEEDED(hr))
2452     {
2453         *buf = attrval.u.caub.pElems;
2454         *size = attrval.u.caub.cElems;
2455     }
2456
2457     return hr;
2458 }
2459
2460 HRESULT attributes_GetUnknown(struct attributes *attributes, REFGUID key, REFIID riid, void **out)
2461 {
2462     PROPVARIANT attrval;
2463     HRESULT hr;
2464
2465     PropVariantInit(&attrval);
2466     attrval.vt = VT_UNKNOWN;
2467     hr = attributes_get_item(attributes, key, &attrval);
2468     if (SUCCEEDED(hr))
2469         hr = IUnknown_QueryInterface(attrval.u.punkVal, riid, out);
2470     PropVariantClear(&attrval);
2471     return hr;
2472 }
2473
2474 static HRESULT attributes_set_item(struct attributes *attributes, REFGUID key, REFPROPVARIANT value)
2475 {
2476     struct attribute *attribute;
2477
2478     EnterCriticalSection(&attributes->cs);
2479
2480     attribute = attributes_find_item(attributes, key, NULL);
2481     if (!attribute)
2482     {
2483         if (!mf_array_reserve((void **)&attributes->attributes, &attributes->capacity, attributes->count + 1,
2484                 sizeof(*attributes->attributes)))
2485         {
2486             LeaveCriticalSection(&attributes->cs);
2487             return E_OUTOFMEMORY;
2488         }
2489         attributes->attributes[attributes->count].key = *key;
2490         attribute = &attributes->attributes[attributes->count++];
2491     }
2492     else
2493         PropVariantClear(&attribute->value);
2494
2495     PropVariantCopy(&attribute->value, value);
2496
2497     LeaveCriticalSection(&attributes->cs);
2498
2499     return S_OK;
2500 }
2501
2502 HRESULT attributes_SetItem(struct attributes *attributes, REFGUID key, REFPROPVARIANT value)
2503 {
2504     PROPVARIANT empty;
2505
2506     switch (value->vt)
2507     {
2508         case MF_ATTRIBUTE_UINT32:
2509         case MF_ATTRIBUTE_UINT64:
2510         case MF_ATTRIBUTE_DOUBLE:
2511         case MF_ATTRIBUTE_GUID:
2512         case MF_ATTRIBUTE_STRING:
2513         case MF_ATTRIBUTE_BLOB:
2514         case MF_ATTRIBUTE_IUNKNOWN:
2515             return attributes_set_item(attributes, key, value);
2516         default:
2517             PropVariantInit(&empty);
2518             attributes_set_item(attributes, key, &empty);
2519             return MF_E_INVALIDTYPE;
2520     }
2521 }
2522
2523 HRESULT attributes_DeleteItem(struct attributes *attributes, REFGUID key)
2524 {
2525     struct attribute *attribute;
2526     size_t index = 0;
2527
2528     EnterCriticalSection(&attributes->cs);
2529
2530     if ((attribute = attributes_find_item(attributes, key, &index)))
2531     {
2532         size_t count;
2533
2534         PropVariantClear(&attribute->value);
2535
2536         attributes->count--;
2537         count = attributes->count - index;
2538         if (count)
2539             memmove(&attributes->attributes[index], &attributes->attributes[index + 1], count * sizeof(*attributes->attributes));
2540     }
2541
2542     LeaveCriticalSection(&attributes->cs);
2543
2544     return S_OK;
2545 }
2546
2547 HRESULT attributes_DeleteAllItems(struct attributes *attributes)
2548 {
2549     EnterCriticalSection(&attributes->cs);
2550
2551     while (attributes->count)
2552     {
2553         PropVariantClear(&attributes->attributes[--attributes->count].value);
2554     }
2555     heap_free(attributes->attributes);
2556     attributes->attributes = NULL;
2557     attributes->capacity = 0;
2558
2559     LeaveCriticalSection(&attributes->cs);
2560
2561     return S_OK;
2562 }
2563
2564 HRESULT attributes_SetUINT32(struct attributes *attributes, REFGUID key, UINT32 value)
2565 {
2566     PROPVARIANT attrval;
2567
2568     attrval.vt = VT_UI4;
2569     attrval.u.ulVal = value;
2570     return attributes_set_item(attributes, key, &attrval);
2571 }
2572
2573 HRESULT attributes_SetUINT64(struct attributes *attributes, REFGUID key, UINT64 value)
2574 {
2575     PROPVARIANT attrval;
2576
2577     attrval.vt = VT_UI8;
2578     attrval.u.uhVal.QuadPart = value;
2579     return attributes_set_item(attributes, key, &attrval);
2580 }
2581
2582 HRESULT attributes_SetDouble(struct attributes *attributes, REFGUID key, double value)
2583 {
2584     PROPVARIANT attrval;
2585
2586     attrval.vt = VT_R8;
2587     attrval.u.dblVal = value;
2588     return attributes_set_item(attributes, key, &attrval);
2589 }
2590
2591 HRESULT attributes_SetGUID(struct attributes *attributes, REFGUID key, REFGUID value)
2592 {
2593     PROPVARIANT attrval;
2594
2595     attrval.vt = VT_CLSID;
2596     attrval.u.puuid = (CLSID *)value;
2597     return attributes_set_item(attributes, key, &attrval);
2598 }
2599
2600 HRESULT attributes_SetString(struct attributes *attributes, REFGUID key, const WCHAR *value)
2601 {
2602     PROPVARIANT attrval;
2603
2604     attrval.vt = VT_LPWSTR;
2605     attrval.u.pwszVal = (WCHAR *)value;
2606     return attributes_set_item(attributes, key, &attrval);
2607 }
2608
2609 HRESULT attributes_SetBlob(struct attributes *attributes, REFGUID key, const UINT8 *buf, UINT32 size)
2610 {
2611     PROPVARIANT attrval;
2612
2613     attrval.vt = VT_VECTOR | VT_UI1;
2614     attrval.u.caub.cElems = size;
2615     attrval.u.caub.pElems = (UINT8 *)buf;
2616     return attributes_set_item(attributes, key, &attrval);
2617 }
2618
2619 HRESULT attributes_SetUnknown(struct attributes *attributes, REFGUID key, IUnknown *unknown)
2620 {
2621     PROPVARIANT attrval;
2622
2623     attrval.vt = VT_UNKNOWN;
2624     attrval.u.punkVal = unknown;
2625     return attributes_set_item(attributes, key, &attrval);
2626 }
2627
2628 HRESULT attributes_LockStore(struct attributes *attributes)
2629 {
2630     EnterCriticalSection(&attributes->cs);
2631
2632     return S_OK;
2633 }
2634
2635 HRESULT attributes_UnlockStore(struct attributes *attributes)
2636 {
2637     LeaveCriticalSection(&attributes->cs);
2638
2639     return S_OK;
2640 }
2641
2642 HRESULT attributes_GetCount(struct attributes *attributes, UINT32 *count)
2643 {
2644     EnterCriticalSection(&attributes->cs);
2645     *count = attributes->count;
2646     LeaveCriticalSection(&attributes->cs);
2647
2648     return S_OK;
2649 }
2650
2651 HRESULT attributes_GetItemByIndex(struct attributes *attributes, UINT32 index, GUID *key, PROPVARIANT *value)
2652 {
2653     HRESULT hr = S_OK;
2654
2655     EnterCriticalSection(&attributes->cs);
2656
2657     if (index < attributes->count)
2658     {
2659         *key = attributes->attributes[index].key;
2660         if (value)
2661             PropVariantCopy(value, &attributes->attributes[index].value);
2662     }
2663     else
2664         hr = E_INVALIDARG;
2665
2666     LeaveCriticalSection(&attributes->cs);
2667
2668     return hr;
2669 }
2670
2671 HRESULT attributes_CopyAllItems(struct attributes *attributes, IMFAttributes *dest)
2672 {
2673     HRESULT hr = S_OK;
2674     size_t i;
2675
2676     EnterCriticalSection(&attributes->cs);
2677
2678     IMFAttributes_LockStore(dest);
2679
2680     IMFAttributes_DeleteAllItems(dest);
2681
2682     for (i = 0; i < attributes->count; ++i)
2683     {
2684         hr = IMFAttributes_SetItem(dest, &attributes->attributes[i].key, &attributes->attributes[i].value);
2685         if (FAILED(hr))
2686             break;
2687     }
2688
2689     IMFAttributes_UnlockStore(dest);
2690
2691     LeaveCriticalSection(&attributes->cs);
2692
2693     return hr;
2694 }
2695
2696 static HRESULT WINAPI mfattributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
2697 {
2698     struct attributes *attributes = impl_from_IMFAttributes(iface);
2699
2700     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2701
2702     return attributes_GetItem(attributes, key, value);
2703 }
2704
2705 static HRESULT WINAPI mfattributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
2706 {
2707     struct attributes *attributes = impl_from_IMFAttributes(iface);
2708
2709     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
2710
2711     return attributes_GetItemType(attributes, key, type);
2712 }
2713
2714 static HRESULT WINAPI mfattributes_CompareItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
2715 {
2716     struct attributes *attributes = impl_from_IMFAttributes(iface);
2717
2718     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
2719
2720     return attributes_CompareItem(attributes, key, value, result);
2721 }
2722
2723 static HRESULT WINAPI mfattributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
2724         MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
2725 {
2726     struct attributes *attributes = impl_from_IMFAttributes(iface);
2727
2728     TRACE("%p, %p, %d, %p.\n", iface, theirs, match_type, ret);
2729
2730     return attributes_Compare(attributes, theirs, match_type, ret);
2731 }
2732
2733 static HRESULT WINAPI mfattributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
2734 {
2735     struct attributes *attributes = impl_from_IMFAttributes(iface);
2736
2737     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2738
2739     return attributes_GetUINT32(attributes, key, value);
2740 }
2741
2742 static HRESULT WINAPI mfattributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
2743 {
2744     struct attributes *attributes = impl_from_IMFAttributes(iface);
2745
2746     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2747
2748     return attributes_GetUINT64(attributes, key, value);
2749 }
2750
2751 static HRESULT WINAPI mfattributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
2752 {
2753     struct attributes *attributes = impl_from_IMFAttributes(iface);
2754
2755     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2756
2757     return attributes_GetDouble(attributes, key, value);
2758 }
2759
2760 static HRESULT WINAPI mfattributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
2761 {
2762     struct attributes *attributes = impl_from_IMFAttributes(iface);
2763
2764     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
2765
2766     return attributes_GetGUID(attributes, key, value);
2767 }
2768
2769 static HRESULT WINAPI mfattributes_GetStringLength(IMFAttributes *iface, REFGUID key, UINT32 *length)
2770 {
2771     struct attributes *attributes = impl_from_IMFAttributes(iface);
2772
2773     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
2774
2775     return attributes_GetStringLength(attributes, key, length);
2776 }
2777
2778 static HRESULT WINAPI mfattributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
2779         UINT32 size, UINT32 *length)
2780 {
2781     struct attributes *attributes = impl_from_IMFAttributes(iface);
2782
2783     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), value, size, length);
2784
2785     return attributes_GetString(attributes, key, value, size, length);
2786 }
2787
2788 static HRESULT WINAPI mfattributes_GetAllocatedString(IMFAttributes *iface, REFGUID key, WCHAR **value, UINT32 *length)
2789 {
2790     struct attributes *attributes = impl_from_IMFAttributes(iface);
2791
2792     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
2793
2794     return attributes_GetAllocatedString(attributes, key, value, length);
2795 }
2796
2797 static HRESULT WINAPI mfattributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
2798 {
2799     struct attributes *attributes = impl_from_IMFAttributes(iface);
2800
2801     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
2802
2803     return attributes_GetBlobSize(attributes, key, size);
2804 }
2805
2806 static HRESULT WINAPI mfattributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
2807                 UINT32 bufsize, UINT32 *blobsize)
2808 {
2809     struct attributes *attributes = impl_from_IMFAttributes(iface);
2810
2811     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
2812
2813     return attributes_GetBlob(attributes, key, buf, bufsize, blobsize);
2814 }
2815
2816 static HRESULT WINAPI mfattributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key, UINT8 **buf, UINT32 *size)
2817 {
2818     struct attributes *attributes = impl_from_IMFAttributes(iface);
2819
2820     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
2821
2822     return attributes_GetAllocatedBlob(attributes, key, buf, size);
2823 }
2824
2825 static HRESULT WINAPI mfattributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **out)
2826 {
2827     struct attributes *attributes = impl_from_IMFAttributes(iface);
2828
2829     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
2830
2831     return attributes_GetUnknown(attributes, key, riid, out);
2832 }
2833
2834 static HRESULT WINAPI mfattributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
2835 {
2836     struct attributes *attributes = impl_from_IMFAttributes(iface);
2837
2838     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
2839
2840     return attributes_SetItem(attributes, key, value);
2841 }
2842
2843 static HRESULT WINAPI mfattributes_DeleteItem(IMFAttributes *iface, REFGUID key)
2844 {
2845     struct attributes *attributes = impl_from_IMFAttributes(iface);
2846
2847     TRACE("%p, %s.\n", iface, debugstr_attr(key));
2848
2849     return attributes_DeleteItem(attributes, key);
2850 }
2851
2852 static HRESULT WINAPI mfattributes_DeleteAllItems(IMFAttributes *iface)
2853 {
2854     struct attributes *attributes = impl_from_IMFAttributes(iface);
2855
2856     TRACE("%p.\n", iface);
2857
2858     return attributes_DeleteAllItems(attributes);
2859 }
2860
2861 static HRESULT WINAPI mfattributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
2862 {
2863     struct attributes *attributes = impl_from_IMFAttributes(iface);
2864
2865     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
2866
2867     return attributes_SetUINT32(attributes, key, value);
2868 }
2869
2870 static HRESULT WINAPI mfattributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
2871 {
2872     struct attributes *attributes = impl_from_IMFAttributes(iface);
2873
2874     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
2875
2876     return attributes_SetUINT64(attributes, key, value);
2877 }
2878
2879 static HRESULT WINAPI mfattributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
2880 {
2881     struct attributes *attributes = impl_from_IMFAttributes(iface);
2882
2883     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
2884
2885     return attributes_SetDouble(attributes, key, value);
2886 }
2887
2888 static HRESULT WINAPI mfattributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
2889 {
2890     struct attributes *attributes = impl_from_IMFAttributes(iface);
2891
2892     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
2893
2894     return attributes_SetGUID(attributes, key, value);
2895 }
2896
2897 static HRESULT WINAPI mfattributes_SetString(IMFAttributes *iface, REFGUID key, const WCHAR *value)
2898 {
2899     struct attributes *attributes = impl_from_IMFAttributes(iface);
2900
2901     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
2902
2903     return attributes_SetString(attributes, key, value);
2904 }
2905
2906 static HRESULT WINAPI mfattributes_SetBlob(IMFAttributes *iface, REFGUID key, const UINT8 *buf, UINT32 size)
2907 {
2908     struct attributes *attributes = impl_from_IMFAttributes(iface);
2909
2910     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
2911
2912     return attributes_SetBlob(attributes, key, buf, size);
2913 }
2914
2915 static HRESULT WINAPI mfattributes_SetUnknown(IMFAttributes *iface, REFGUID key, IUnknown *unknown)
2916 {
2917     struct attributes *attributes = impl_from_IMFAttributes(iface);
2918
2919     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
2920
2921     return attributes_SetUnknown(attributes, key, unknown);
2922 }
2923
2924 static HRESULT WINAPI mfattributes_LockStore(IMFAttributes *iface)
2925 {
2926     struct attributes *attributes = impl_from_IMFAttributes(iface);
2927
2928     TRACE("%p.\n", iface);
2929
2930     return attributes_LockStore(attributes);
2931 }
2932
2933 static HRESULT WINAPI mfattributes_UnlockStore(IMFAttributes *iface)
2934 {
2935     struct attributes *attributes = impl_from_IMFAttributes(iface);
2936
2937     TRACE("%p.\n", iface);
2938
2939     return attributes_UnlockStore(attributes);
2940 }
2941
2942 static HRESULT WINAPI mfattributes_GetCount(IMFAttributes *iface, UINT32 *count)
2943 {
2944     struct attributes *attributes = impl_from_IMFAttributes(iface);
2945
2946     TRACE("%p, %p.\n", iface, count);
2947
2948     return attributes_GetCount(attributes, count);
2949 }
2950
2951 static HRESULT WINAPI mfattributes_GetItemByIndex(IMFAttributes *iface, UINT32 index, GUID *key, PROPVARIANT *value)
2952 {
2953     struct attributes *attributes = impl_from_IMFAttributes(iface);
2954
2955     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
2956
2957     return attributes_GetItemByIndex(attributes, index, key, value);
2958 }
2959
2960 static HRESULT WINAPI mfattributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
2961 {
2962     struct attributes *attributes = impl_from_IMFAttributes(iface);
2963
2964     TRACE("%p, %p.\n", iface, dest);
2965
2966     return attributes_CopyAllItems(attributes, dest);
2967 }
2968
2969 static const IMFAttributesVtbl mfattributes_vtbl =
2970 {
2971     mfattributes_QueryInterface,
2972     mfattributes_AddRef,
2973     mfattributes_Release,
2974     mfattributes_GetItem,
2975     mfattributes_GetItemType,
2976     mfattributes_CompareItem,
2977     mfattributes_Compare,
2978     mfattributes_GetUINT32,
2979     mfattributes_GetUINT64,
2980     mfattributes_GetDouble,
2981     mfattributes_GetGUID,
2982     mfattributes_GetStringLength,
2983     mfattributes_GetString,
2984     mfattributes_GetAllocatedString,
2985     mfattributes_GetBlobSize,
2986     mfattributes_GetBlob,
2987     mfattributes_GetAllocatedBlob,
2988     mfattributes_GetUnknown,
2989     mfattributes_SetItem,
2990     mfattributes_DeleteItem,
2991     mfattributes_DeleteAllItems,
2992     mfattributes_SetUINT32,
2993     mfattributes_SetUINT64,
2994     mfattributes_SetDouble,
2995     mfattributes_SetGUID,
2996     mfattributes_SetString,
2997     mfattributes_SetBlob,
2998     mfattributes_SetUnknown,
2999     mfattributes_LockStore,
3000     mfattributes_UnlockStore,
3001     mfattributes_GetCount,
3002     mfattributes_GetItemByIndex,
3003     mfattributes_CopyAllItems
3004 };
3005
3006 HRESULT init_attributes_object(struct attributes *object, UINT32 size)
3007 {
3008     object->IMFAttributes_iface.lpVtbl = &mfattributes_vtbl;
3009     object->ref = 1;
3010     InitializeCriticalSection(&object->cs);
3011
3012     object->attributes = NULL;
3013     object->count = 0;
3014     object->capacity = 0;
3015     if (!mf_array_reserve((void **)&object->attributes, &object->capacity, size,
3016                           sizeof(*object->attributes)))
3017     {
3018         DeleteCriticalSection(&object->cs);
3019         return E_OUTOFMEMORY;
3020     }
3021
3022     return S_OK;
3023 }
3024
3025 void clear_attributes_object(struct attributes *object)
3026 {
3027     size_t i;
3028
3029     for (i = 0; i < object->count; i++)
3030         PropVariantClear(&object->attributes[i].value);
3031     heap_free(object->attributes);
3032
3033     DeleteCriticalSection(&object->cs);
3034 }
3035
3036 /***********************************************************************
3037  *      MFCreateAttributes (mfplat.@)
3038  */
3039 HRESULT WINAPI MFCreateAttributes(IMFAttributes **attributes, UINT32 size)
3040 {
3041     struct attributes *object;
3042     HRESULT hr;
3043
3044     TRACE("%p, %d\n", attributes, size);
3045
3046     object = heap_alloc_zero(sizeof(*object));
3047     if (!object)
3048         return E_OUTOFMEMORY;
3049
3050     if (FAILED(hr = init_attributes_object(object, size)))
3051     {
3052         heap_free(object);
3053         return hr;
3054     }
3055     *attributes = &object->IMFAttributes_iface;
3056
3057     return S_OK;
3058 }
3059
3060 #define ATTRIBUTES_STORE_MAGIC 0x494d4641 /* IMFA */
3061
3062 struct attributes_store_header
3063 {
3064     DWORD magic;
3065     UINT32 count;
3066 };
3067
3068 struct attributes_store_item
3069 {
3070     GUID key;
3071     QWORD type;
3072     union
3073     {
3074         double f;
3075         UINT32 i32;
3076         UINT64 i64;
3077         struct
3078         {
3079             DWORD size;
3080             DWORD offset;
3081         } subheader;
3082     } u;
3083 };
3084
3085 /***********************************************************************
3086  *      MFGetAttributesAsBlobSize (mfplat.@)
3087  */
3088 HRESULT WINAPI MFGetAttributesAsBlobSize(IMFAttributes *attributes, UINT32 *size)
3089 {
3090     unsigned int i, count, length;
3091     HRESULT hr;
3092     GUID key;
3093
3094     TRACE("%p, %p.\n", attributes, size);
3095
3096     IMFAttributes_LockStore(attributes);
3097
3098     hr = IMFAttributes_GetCount(attributes, &count);
3099
3100     *size = sizeof(struct attributes_store_header);
3101
3102     for (i = 0; i < count; ++i)
3103     {
3104         MF_ATTRIBUTE_TYPE type;
3105
3106         hr = IMFAttributes_GetItemByIndex(attributes, i, &key, NULL);
3107         if (FAILED(hr))
3108             break;
3109
3110         *size += sizeof(struct attributes_store_item);
3111
3112         IMFAttributes_GetItemType(attributes, &key, &type);
3113
3114         switch (type)
3115         {
3116             case MF_ATTRIBUTE_GUID:
3117                 *size += sizeof(GUID);
3118                 break;
3119             case MF_ATTRIBUTE_STRING:
3120                 IMFAttributes_GetStringLength(attributes, &key, &length);
3121                 *size += (length + 1) * sizeof(WCHAR);
3122                 break;
3123             case MF_ATTRIBUTE_BLOB:
3124                 IMFAttributes_GetBlobSize(attributes, &key, &length);
3125                 *size += length;
3126                 break;
3127             case MF_ATTRIBUTE_UINT32:
3128             case MF_ATTRIBUTE_UINT64:
3129             case MF_ATTRIBUTE_DOUBLE:
3130             case MF_ATTRIBUTE_IUNKNOWN:
3131             default:
3132                 ;
3133         }
3134     }
3135
3136     IMFAttributes_UnlockStore(attributes);
3137
3138     return hr;
3139 }
3140
3141 struct attr_serialize_context
3142 {
3143     UINT8 *buffer;
3144     UINT8 *ptr;
3145     UINT32 size;
3146 };
3147
3148 static void attributes_serialize_write(struct attr_serialize_context *context, const void *value, unsigned int size)
3149 {
3150     memcpy(context->ptr, value, size);
3151     context->ptr += size;
3152 }
3153
3154 static BOOL attributes_serialize_write_item(struct attr_serialize_context *context, struct attributes_store_item *item,
3155         const void *value)
3156 {
3157     switch (item->type)
3158     {
3159         case MF_ATTRIBUTE_UINT32:
3160         case MF_ATTRIBUTE_UINT64:
3161         case MF_ATTRIBUTE_DOUBLE:
3162             attributes_serialize_write(context, item, sizeof(*item));
3163             break;
3164         case MF_ATTRIBUTE_GUID:
3165         case MF_ATTRIBUTE_STRING:
3166         case MF_ATTRIBUTE_BLOB:
3167             item->u.subheader.offset = context->size - item->u.subheader.size;
3168             attributes_serialize_write(context, item, sizeof(*item));
3169             memcpy(context->buffer + item->u.subheader.offset, value, item->u.subheader.size);
3170             context->size -= item->u.subheader.size;
3171             break;
3172         default:
3173             return FALSE;
3174     }
3175
3176     return TRUE;
3177 }
3178
3179 /***********************************************************************
3180  *      MFGetAttributesAsBlob (mfplat.@)
3181  */
3182 HRESULT WINAPI MFGetAttributesAsBlob(IMFAttributes *attributes, UINT8 *buffer, UINT size)
3183 {
3184     struct attributes_store_header header;
3185     struct attr_serialize_context context;
3186     unsigned int required_size, i;
3187     PROPVARIANT value;
3188     UINT32 count;
3189     HRESULT hr;
3190
3191     TRACE("%p, %p, %u.\n", attributes, buffer, size);
3192
3193     if (FAILED(hr = MFGetAttributesAsBlobSize(attributes, &required_size)))
3194         return hr;
3195
3196     if (required_size > size)
3197         return MF_E_BUFFERTOOSMALL;
3198
3199     context.buffer = buffer;
3200     context.ptr = buffer;
3201     context.size = required_size;
3202
3203     IMFAttributes_LockStore(attributes);
3204
3205     header.magic = ATTRIBUTES_STORE_MAGIC;
3206     header.count = 0; /* Will be updated later */
3207     IMFAttributes_GetCount(attributes, &count);
3208
3209     attributes_serialize_write(&context, &header, sizeof(header));
3210
3211     for (i = 0; i < count; ++i)
3212     {
3213         struct attributes_store_item item;
3214         const void *data = NULL;
3215
3216         hr = IMFAttributes_GetItemByIndex(attributes, i, &item.key, &value);
3217         if (FAILED(hr))
3218             break;
3219
3220         item.type = value.vt;
3221
3222         switch (value.vt)
3223         {
3224             case MF_ATTRIBUTE_UINT32:
3225             case MF_ATTRIBUTE_UINT64:
3226                 item.u.i64 = value.u.uhVal.QuadPart;
3227                 break;
3228             case MF_ATTRIBUTE_DOUBLE:
3229                 item.u.f = value.u.dblVal;
3230                 break;
3231             case MF_ATTRIBUTE_GUID:
3232                 item.u.subheader.size = sizeof(*value.u.puuid);
3233                 data = value.u.puuid;
3234                 break;
3235             case MF_ATTRIBUTE_STRING:
3236                 item.u.subheader.size = (lstrlenW(value.u.pwszVal) + 1) * sizeof(WCHAR);
3237                 data = value.u.pwszVal;
3238                 break;
3239             case MF_ATTRIBUTE_BLOB:
3240                 item.u.subheader.size = value.u.caub.cElems;
3241                 data = value.u.caub.pElems;
3242                 break;
3243             case MF_ATTRIBUTE_IUNKNOWN:
3244                 break;
3245             default:
3246                 WARN("Unknown attribute type %#x.\n", value.vt);
3247         }
3248
3249         if (attributes_serialize_write_item(&context, &item, data))
3250             header.count++;
3251
3252         PropVariantClear(&value);
3253     }
3254
3255     memcpy(context.buffer, &header, sizeof(header));
3256
3257     IMFAttributes_UnlockStore(attributes);
3258
3259     return S_OK;
3260 }
3261
3262 static HRESULT attributes_deserialize_read(struct attr_serialize_context *context, void *value, unsigned int size)
3263 {
3264     if (context->size < (context->ptr - context->buffer) + size)
3265         return E_INVALIDARG;
3266
3267     memcpy(value, context->ptr, size);
3268     context->ptr += size;
3269
3270     return S_OK;
3271 }
3272
3273 /***********************************************************************
3274  *      MFInitAttributesFromBlob (mfplat.@)
3275  */
3276 HRESULT WINAPI MFInitAttributesFromBlob(IMFAttributes *dest, const UINT8 *buffer, UINT size)
3277 {
3278     struct attr_serialize_context context;
3279     struct attributes_store_header header;
3280     struct attributes_store_item item;
3281     IMFAttributes *attributes;
3282     unsigned int i;
3283     HRESULT hr;
3284
3285     TRACE("%p, %p, %u.\n", dest, buffer, size);
3286
3287     context.buffer = (UINT8 *)buffer;
3288     context.ptr = (UINT8 *)buffer;
3289     context.size = size;
3290
3291     /* Validate buffer structure. */
3292     if (FAILED(hr = attributes_deserialize_read(&context, &header, sizeof(header))))
3293         return hr;
3294
3295     if (header.magic != ATTRIBUTES_STORE_MAGIC)
3296         return E_UNEXPECTED;
3297
3298     if (FAILED(hr = MFCreateAttributes(&attributes, header.count)))
3299         return hr;
3300
3301     for (i = 0; i < header.count; ++i)
3302     {
3303         if (FAILED(hr = attributes_deserialize_read(&context, &item, sizeof(item))))
3304             break;
3305
3306         hr = E_UNEXPECTED;
3307
3308         switch (item.type)
3309         {
3310             case MF_ATTRIBUTE_UINT32:
3311                 hr = IMFAttributes_SetUINT32(attributes, &item.key, item.u.i32);
3312                 break;
3313             case MF_ATTRIBUTE_UINT64:
3314                 hr = IMFAttributes_SetUINT64(attributes, &item.key, item.u.i64);
3315                 break;
3316             case MF_ATTRIBUTE_DOUBLE:
3317                 hr = IMFAttributes_SetDouble(attributes, &item.key, item.u.f);
3318                 break;
3319             case MF_ATTRIBUTE_GUID:
3320                 if (item.u.subheader.size == sizeof(GUID) &&
3321                         item.u.subheader.offset + item.u.subheader.size <= context.size)
3322                 {
3323                     hr = IMFAttributes_SetGUID(attributes, &item.key,
3324                             (const GUID *)(context.buffer + item.u.subheader.offset));
3325                 }
3326                 break;
3327             case MF_ATTRIBUTE_STRING:
3328                 if (item.u.subheader.size >= sizeof(WCHAR) &&
3329                         item.u.subheader.offset + item.u.subheader.size <= context.size)
3330                 {
3331                     hr = IMFAttributes_SetString(attributes, &item.key,
3332                             (const WCHAR *)(context.buffer + item.u.subheader.offset));
3333                 }
3334                 break;
3335             case MF_ATTRIBUTE_BLOB:
3336                 if (item.u.subheader.size > 0 && item.u.subheader.offset + item.u.subheader.size <= context.size)
3337                 {
3338                     hr = IMFAttributes_SetBlob(attributes, &item.key, context.buffer + item.u.subheader.offset,
3339                             item.u.subheader.size);
3340                 }
3341                 break;
3342             default:
3343                 ;
3344         }
3345
3346         if (FAILED(hr))
3347             break;
3348     }
3349
3350     if (SUCCEEDED(hr))
3351     {
3352         IMFAttributes_DeleteAllItems(dest);
3353         hr = IMFAttributes_CopyAllItems(attributes, dest);
3354     }
3355
3356     IMFAttributes_Release(attributes);
3357
3358     return hr;
3359 }
3360
3361 typedef struct bytestream
3362 {
3363     struct attributes attributes;
3364     IMFByteStream IMFByteStream_iface;
3365     IMFGetService IMFGetService_iface;
3366     IRtwqAsyncCallback read_callback;
3367     IRtwqAsyncCallback write_callback;
3368     IStream *stream;
3369     HANDLE hfile;
3370     QWORD position;
3371     DWORD capabilities;
3372     struct list pending;
3373     CRITICAL_SECTION cs;
3374 } mfbytestream;
3375
3376 static inline mfbytestream *impl_from_IMFByteStream(IMFByteStream *iface)
3377 {
3378     return CONTAINING_RECORD(iface, mfbytestream, IMFByteStream_iface);
3379 }
3380
3381 static struct bytestream *impl_bytestream_from_IMFGetService(IMFGetService *iface)
3382 {
3383     return CONTAINING_RECORD(iface, struct bytestream, IMFGetService_iface);
3384 }
3385
3386 static struct bytestream *impl_from_read_callback_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
3387 {
3388     return CONTAINING_RECORD(iface, struct bytestream, read_callback);
3389 }
3390
3391 static struct bytestream *impl_from_write_callback_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
3392 {
3393     return CONTAINING_RECORD(iface, struct bytestream, write_callback);
3394 }
3395
3396 enum async_stream_op_type
3397 {
3398     ASYNC_STREAM_OP_READ,
3399     ASYNC_STREAM_OP_WRITE,
3400 };
3401
3402 struct async_stream_op
3403 {
3404     IUnknown IUnknown_iface;
3405     LONG refcount;
3406     union
3407     {
3408         const BYTE *src;
3409         BYTE *dest;
3410     } u;
3411     QWORD position;
3412     ULONG requested_length;
3413     ULONG actual_length;
3414     IMFAsyncResult *caller;
3415     struct list entry;
3416     enum async_stream_op_type type;
3417 };
3418
3419 static struct async_stream_op *impl_async_stream_op_from_IUnknown(IUnknown *iface)
3420 {
3421     return CONTAINING_RECORD(iface, struct async_stream_op, IUnknown_iface);
3422 }
3423
3424 static HRESULT WINAPI async_stream_op_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
3425 {
3426     if (IsEqualIID(riid, &IID_IUnknown))
3427     {
3428         *obj = iface;
3429         IUnknown_AddRef(iface);
3430         return S_OK;
3431     }
3432
3433     WARN("Unsupported %s.\n", debugstr_guid(riid));
3434     *obj = NULL;
3435     return E_NOINTERFACE;
3436 }
3437
3438 static ULONG WINAPI async_stream_op_AddRef(IUnknown *iface)
3439 {
3440     struct async_stream_op *op = impl_async_stream_op_from_IUnknown(iface);
3441     ULONG refcount = InterlockedIncrement(&op->refcount);
3442
3443     TRACE("%p, refcount %d.\n", iface, refcount);
3444
3445     return refcount;
3446 }
3447
3448 static ULONG WINAPI async_stream_op_Release(IUnknown *iface)
3449 {
3450     struct async_stream_op *op = impl_async_stream_op_from_IUnknown(iface);
3451     ULONG refcount = InterlockedDecrement(&op->refcount);
3452
3453     TRACE("%p, refcount %d.\n", iface, refcount);
3454
3455     if (!refcount)
3456     {
3457         if (op->caller)
3458             IMFAsyncResult_Release(op->caller);
3459         heap_free(op);
3460     }
3461
3462     return refcount;
3463 }
3464
3465 static const IUnknownVtbl async_stream_op_vtbl =
3466 {
3467     async_stream_op_QueryInterface,
3468     async_stream_op_AddRef,
3469     async_stream_op_Release,
3470 };
3471
3472 static HRESULT bytestream_create_io_request(struct bytestream *stream, enum async_stream_op_type type,
3473         const BYTE *data, ULONG size, IMFAsyncCallback *callback, IUnknown *state)
3474 {
3475     struct async_stream_op *op;
3476     IRtwqAsyncResult *request;
3477     HRESULT hr;
3478
3479     op = heap_alloc(sizeof(*op));
3480     if (!op)
3481         return E_OUTOFMEMORY;
3482
3483     op->IUnknown_iface.lpVtbl = &async_stream_op_vtbl;
3484     op->refcount = 1;
3485     op->u.src = data;
3486     op->position = stream->position;
3487     op->requested_length = size;
3488     op->type = type;
3489     if (FAILED(hr = RtwqCreateAsyncResult((IUnknown *)&stream->IMFByteStream_iface, (IRtwqAsyncCallback *)callback, state,
3490             (IRtwqAsyncResult **)&op->caller)))
3491     {
3492         goto failed;
3493     }
3494
3495     if (FAILED(hr = RtwqCreateAsyncResult(&op->IUnknown_iface, type == ASYNC_STREAM_OP_READ ? &stream->read_callback :
3496             &stream->write_callback, NULL, &request)))
3497         goto failed;
3498
3499     RtwqPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, 0, request);
3500     IRtwqAsyncResult_Release(request);
3501
3502 failed:
3503     IUnknown_Release(&op->IUnknown_iface);
3504     return hr;
3505 }
3506
3507 static HRESULT bytestream_complete_io_request(struct bytestream *stream, enum async_stream_op_type type,
3508         IMFAsyncResult *result, ULONG *actual_length)
3509 {
3510     struct async_stream_op *op = NULL, *cur;
3511     HRESULT hr;
3512
3513     EnterCriticalSection(&stream->cs);
3514     LIST_FOR_EACH_ENTRY(cur, &stream->pending, struct async_stream_op, entry)
3515     {
3516         if (cur->caller == result && cur->type == type)
3517         {
3518             op = cur;
3519             list_remove(&cur->entry);
3520             break;
3521         }
3522     }
3523     LeaveCriticalSection(&stream->cs);
3524
3525     if (!op)
3526         return E_INVALIDARG;
3527
3528     if (SUCCEEDED(hr = IMFAsyncResult_GetStatus(result)))
3529         *actual_length = op->actual_length;
3530
3531     IUnknown_Release(&op->IUnknown_iface);
3532
3533     return hr;
3534 }
3535
3536 static HRESULT WINAPI bytestream_callback_QueryInterface(IRtwqAsyncCallback *iface, REFIID riid, void **obj)
3537 {
3538     if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
3539             IsEqualIID(riid, &IID_IUnknown))
3540     {
3541         *obj = iface;
3542         IRtwqAsyncCallback_AddRef(iface);
3543         return S_OK;
3544     }
3545
3546     WARN("Unsupported %s.\n", debugstr_guid(riid));
3547     *obj = NULL;
3548     return E_NOINTERFACE;
3549 }
3550
3551 static ULONG WINAPI bytestream_read_callback_AddRef(IRtwqAsyncCallback *iface)
3552 {
3553     struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
3554     return IMFByteStream_AddRef(&stream->IMFByteStream_iface);
3555 }
3556
3557 static ULONG WINAPI bytestream_read_callback_Release(IRtwqAsyncCallback *iface)
3558 {
3559     struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
3560     return IMFByteStream_Release(&stream->IMFByteStream_iface);
3561 }
3562
3563 static HRESULT WINAPI bytestream_callback_GetParameters(IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue)
3564 {
3565     return E_NOTIMPL;
3566 }
3567
3568 static ULONG WINAPI bytestream_write_callback_AddRef(IRtwqAsyncCallback *iface)
3569 {
3570     struct bytestream *stream = impl_from_write_callback_IRtwqAsyncCallback(iface);
3571     return IMFByteStream_AddRef(&stream->IMFByteStream_iface);
3572 }
3573
3574 static ULONG WINAPI bytestream_write_callback_Release(IRtwqAsyncCallback *iface)
3575 {
3576     struct bytestream *stream = impl_from_write_callback_IRtwqAsyncCallback(iface);
3577     return IMFByteStream_Release(&stream->IMFByteStream_iface);
3578 }
3579
3580 static HRESULT WINAPI bytestream_QueryInterface(IMFByteStream *iface, REFIID riid, void **out)
3581 {
3582     struct bytestream *stream = impl_from_IMFByteStream(iface);
3583
3584     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
3585
3586     if (IsEqualIID(riid, &IID_IMFByteStream) ||
3587             IsEqualIID(riid, &IID_IUnknown))
3588     {
3589         *out = &stream->IMFByteStream_iface;
3590     }
3591     else if (IsEqualIID(riid, &IID_IMFAttributes))
3592     {
3593         *out = &stream->attributes.IMFAttributes_iface;
3594     }
3595     else if (stream->IMFGetService_iface.lpVtbl && IsEqualIID(riid, &IID_IMFGetService))
3596     {
3597         *out = &stream->IMFGetService_iface;
3598     }
3599     else
3600     {
3601         WARN("Unsupported %s.\n", debugstr_guid(riid));
3602         *out = NULL;
3603         return E_NOINTERFACE;
3604     }
3605
3606     IUnknown_AddRef((IUnknown*)*out);
3607     return S_OK;
3608 }
3609
3610 static ULONG WINAPI bytestream_AddRef(IMFByteStream *iface)
3611 {
3612     struct bytestream *stream = impl_from_IMFByteStream(iface);
3613     ULONG refcount = InterlockedIncrement(&stream->attributes.ref);
3614
3615     TRACE("%p, refcount %d.\n", iface, refcount);
3616
3617     return refcount;
3618 }
3619
3620 static ULONG WINAPI bytestream_Release(IMFByteStream *iface)
3621 {
3622     struct bytestream *stream = impl_from_IMFByteStream(iface);
3623     ULONG refcount = InterlockedDecrement(&stream->attributes.ref);
3624     struct async_stream_op *cur, *cur2;
3625
3626     TRACE("%p, refcount %d.\n", iface, refcount);
3627
3628     if (!refcount)
3629     {
3630         clear_attributes_object(&stream->attributes);
3631         LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &stream->pending, struct async_stream_op, entry)
3632         {
3633             list_remove(&cur->entry);
3634             IUnknown_Release(&cur->IUnknown_iface);
3635         }
3636         DeleteCriticalSection(&stream->cs);
3637         if (stream->stream)
3638             IStream_Release(stream->stream);
3639         if (stream->hfile)
3640             CloseHandle(stream->hfile);
3641         heap_free(stream);
3642     }
3643
3644     return refcount;
3645 }
3646
3647 static HRESULT WINAPI bytestream_stream_GetCapabilities(IMFByteStream *iface, DWORD *capabilities)
3648 {
3649     struct bytestream *stream = impl_from_IMFByteStream(iface);
3650     STATSTG stat;
3651     HRESULT hr;
3652
3653     TRACE("%p, %p.\n", iface, capabilities);
3654
3655     if (FAILED(hr = IStream_Stat(stream->stream, &stat, STATFLAG_NONAME)))
3656         return hr;
3657
3658     *capabilities = MFBYTESTREAM_IS_READABLE | MFBYTESTREAM_IS_SEEKABLE;
3659     if (stat.grfMode & (STGM_WRITE | STGM_READWRITE))
3660         *capabilities |= MFBYTESTREAM_IS_WRITABLE;
3661
3662     return S_OK;
3663 }
3664
3665 static HRESULT WINAPI bytestream_GetCapabilities(IMFByteStream *iface, DWORD *capabilities)
3666 {
3667     struct bytestream *stream = impl_from_IMFByteStream(iface);
3668
3669     TRACE("%p, %p.\n", iface, capabilities);
3670
3671     *capabilities = stream->capabilities;
3672
3673     return S_OK;
3674 }
3675
3676 static HRESULT WINAPI mfbytestream_SetLength(IMFByteStream *iface, QWORD length)
3677 {
3678     mfbytestream *This = impl_from_IMFByteStream(iface);
3679
3680     FIXME("%p, %s\n", This, wine_dbgstr_longlong(length));
3681
3682     return E_NOTIMPL;
3683 }
3684
3685 static HRESULT WINAPI bytestream_file_GetCurrentPosition(IMFByteStream *iface, QWORD *position)
3686 {
3687     struct bytestream *stream = impl_from_IMFByteStream(iface);
3688
3689     TRACE("%p, %p.\n", iface, position);
3690
3691     if (!position)
3692         return E_INVALIDARG;
3693
3694     *position = stream->position;
3695
3696     return S_OK;
3697 }
3698
3699 static HRESULT WINAPI bytestream_file_GetLength(IMFByteStream *iface, QWORD *length)
3700 {
3701     struct bytestream *stream = impl_from_IMFByteStream(iface);
3702     LARGE_INTEGER li;
3703
3704     TRACE("%p, %p.\n", iface, length);
3705
3706     if (!length)
3707         return E_INVALIDARG;
3708
3709     if (GetFileSizeEx(stream->hfile, &li))
3710         *length = li.QuadPart;
3711     else
3712         return HRESULT_FROM_WIN32(GetLastError());
3713
3714     return S_OK;
3715 }
3716
3717 static HRESULT WINAPI bytestream_file_IsEndOfStream(IMFByteStream *iface, BOOL *ret)
3718 {
3719     struct bytestream *stream = impl_from_IMFByteStream(iface);
3720     LARGE_INTEGER position, length;
3721     HRESULT hr = S_OK;
3722
3723     TRACE("%p, %p.\n", iface, ret);
3724
3725     EnterCriticalSection(&stream->cs);
3726
3727     position.QuadPart = 0;
3728     if (SetFilePointerEx(stream->hfile, position, &length, FILE_END))
3729         *ret = stream->position >= length.QuadPart;
3730     else
3731         hr = HRESULT_FROM_WIN32(GetLastError());
3732
3733     LeaveCriticalSection(&stream->cs);
3734
3735     return hr;
3736 }
3737
3738 static HRESULT WINAPI bytestream_file_Read(IMFByteStream *iface, BYTE *buffer, ULONG size, ULONG *read_len)
3739 {
3740     struct bytestream *stream = impl_from_IMFByteStream(iface);
3741     LARGE_INTEGER position;
3742     HRESULT hr = S_OK;
3743     BOOL ret;
3744
3745     TRACE("%p, %p, %u, %p.\n", iface, buffer, size, read_len);
3746
3747     EnterCriticalSection(&stream->cs);
3748
3749     position.QuadPart = stream->position;
3750     if ((ret = SetFilePointerEx(stream->hfile, position, NULL, FILE_BEGIN)))
3751     {
3752         if ((ret = ReadFile(stream->hfile, buffer, size, read_len, NULL)))
3753             stream->position += *read_len;
3754     }
3755
3756     if (!ret)
3757         hr = HRESULT_FROM_WIN32(GetLastError());
3758
3759     LeaveCriticalSection(&stream->cs);
3760
3761     return hr;
3762 }
3763
3764 static HRESULT WINAPI bytestream_BeginRead(IMFByteStream *iface, BYTE *data, ULONG size, IMFAsyncCallback *callback,
3765         IUnknown *state)
3766 {
3767     struct bytestream *stream = impl_from_IMFByteStream(iface);
3768
3769     TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
3770
3771     return bytestream_create_io_request(stream, ASYNC_STREAM_OP_READ, data, size, callback, state);
3772 }
3773
3774 static HRESULT WINAPI bytestream_EndRead(IMFByteStream *iface, IMFAsyncResult *result, ULONG *byte_read)
3775 {
3776     struct bytestream *stream = impl_from_IMFByteStream(iface);
3777
3778     TRACE("%p, %p, %p.\n", iface, result, byte_read);
3779
3780     return bytestream_complete_io_request(stream, ASYNC_STREAM_OP_READ, result, byte_read);
3781 }
3782
3783 static HRESULT WINAPI mfbytestream_Write(IMFByteStream *iface, const BYTE *data, ULONG count, ULONG *written)
3784 {
3785     mfbytestream *This = impl_from_IMFByteStream(iface);
3786
3787     FIXME("%p, %p, %u, %p\n", This, data, count, written);
3788
3789     return E_NOTIMPL;
3790 }
3791
3792 static HRESULT WINAPI bytestream_BeginWrite(IMFByteStream *iface, const BYTE *data, ULONG size,
3793         IMFAsyncCallback *callback, IUnknown *state)
3794 {
3795     struct bytestream *stream = impl_from_IMFByteStream(iface);
3796
3797     TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
3798
3799     return bytestream_create_io_request(stream, ASYNC_STREAM_OP_WRITE, data, size, callback, state);
3800 }
3801
3802 static HRESULT WINAPI bytestream_EndWrite(IMFByteStream *iface, IMFAsyncResult *result, ULONG *written)
3803 {
3804     struct bytestream *stream = impl_from_IMFByteStream(iface);
3805
3806     TRACE("%p, %p, %p.\n", iface, result, written);
3807
3808     return bytestream_complete_io_request(stream, ASYNC_STREAM_OP_WRITE, result, written);
3809 }
3810
3811 static HRESULT WINAPI mfbytestream_Seek(IMFByteStream *iface, MFBYTESTREAM_SEEK_ORIGIN seek, LONGLONG offset,
3812                         DWORD flags, QWORD *current)
3813 {
3814     mfbytestream *This = impl_from_IMFByteStream(iface);
3815
3816     FIXME("%p, %u, %s, 0x%08x, %p\n", This, seek, wine_dbgstr_longlong(offset), flags, current);
3817
3818     return E_NOTIMPL;
3819 }
3820
3821 static HRESULT WINAPI mfbytestream_Flush(IMFByteStream *iface)
3822 {
3823     mfbytestream *This = impl_from_IMFByteStream(iface);
3824
3825     FIXME("%p\n", This);
3826
3827     return E_NOTIMPL;
3828 }
3829
3830 static HRESULT WINAPI mfbytestream_Close(IMFByteStream *iface)
3831 {
3832     mfbytestream *This = impl_from_IMFByteStream(iface);
3833
3834     FIXME("%p\n", This);
3835
3836     return E_NOTIMPL;
3837 }
3838
3839 static HRESULT WINAPI bytestream_SetCurrentPosition(IMFByteStream *iface, QWORD position)
3840 {
3841     struct bytestream *stream = impl_from_IMFByteStream(iface);
3842
3843     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(position));
3844
3845     EnterCriticalSection(&stream->cs);
3846     stream->position = position;
3847     LeaveCriticalSection(&stream->cs);
3848
3849     return S_OK;
3850 }
3851
3852 static const IMFByteStreamVtbl bytestream_file_vtbl =
3853 {
3854     bytestream_QueryInterface,
3855     bytestream_AddRef,
3856     bytestream_Release,
3857     bytestream_GetCapabilities,
3858     bytestream_file_GetLength,
3859     mfbytestream_SetLength,
3860     bytestream_file_GetCurrentPosition,
3861     bytestream_SetCurrentPosition,
3862     bytestream_file_IsEndOfStream,
3863     bytestream_file_Read,
3864     bytestream_BeginRead,
3865     bytestream_EndRead,
3866     mfbytestream_Write,
3867     bytestream_BeginWrite,
3868     bytestream_EndWrite,
3869     mfbytestream_Seek,
3870     mfbytestream_Flush,
3871     mfbytestream_Close
3872 };
3873
3874 static HRESULT WINAPI bytestream_stream_GetLength(IMFByteStream *iface, QWORD *length)
3875 {
3876     struct bytestream *stream = impl_from_IMFByteStream(iface);
3877     STATSTG statstg;
3878     HRESULT hr;
3879
3880     TRACE("%p, %p.\n", iface, length);
3881
3882     if (FAILED(hr = IStream_Stat(stream->stream, &statstg, STATFLAG_NONAME)))
3883         return hr;
3884
3885     *length = statstg.cbSize.QuadPart;
3886
3887     return S_OK;
3888 }
3889
3890 static HRESULT WINAPI bytestream_stream_SetLength(IMFByteStream *iface, QWORD length)
3891 {
3892     struct bytestream *stream = impl_from_IMFByteStream(iface);
3893     ULARGE_INTEGER size;
3894     HRESULT hr;
3895
3896     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(length));
3897
3898     EnterCriticalSection(&stream->cs);
3899
3900     size.QuadPart = length;
3901     hr = IStream_SetSize(stream->stream, size);
3902
3903     LeaveCriticalSection(&stream->cs);
3904
3905     return hr;
3906 }
3907
3908 static HRESULT WINAPI bytestream_stream_GetCurrentPosition(IMFByteStream *iface, QWORD *position)
3909 {
3910     struct bytestream *stream = impl_from_IMFByteStream(iface);
3911
3912     TRACE("%p, %p.\n", iface, position);
3913
3914     *position = stream->position;
3915
3916     return S_OK;
3917 }
3918
3919 static HRESULT WINAPI bytestream_stream_IsEndOfStream(IMFByteStream *iface, BOOL *ret)
3920 {
3921     struct bytestream *stream = impl_from_IMFByteStream(iface);
3922     STATSTG statstg;
3923     HRESULT hr;
3924
3925     TRACE("%p, %p.\n", iface, ret);
3926
3927     EnterCriticalSection(&stream->cs);
3928
3929     if (SUCCEEDED(hr = IStream_Stat(stream->stream, &statstg, STATFLAG_NONAME)))
3930         *ret = stream->position >= statstg.cbSize.QuadPart;
3931
3932     LeaveCriticalSection(&stream->cs);
3933
3934     return hr;
3935 }
3936
3937 static HRESULT WINAPI bytestream_stream_Read(IMFByteStream *iface, BYTE *buffer, ULONG size, ULONG *read_len)
3938 {
3939     struct bytestream *stream = impl_from_IMFByteStream(iface);
3940     LARGE_INTEGER position;
3941     HRESULT hr;
3942
3943     TRACE("%p, %p, %u, %p.\n", iface, buffer, size, read_len);
3944
3945     EnterCriticalSection(&stream->cs);
3946
3947     position.QuadPart = stream->position;
3948     if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
3949     {
3950         if (SUCCEEDED(hr = IStream_Read(stream->stream, buffer, size, read_len)))
3951             stream->position += *read_len;
3952     }
3953
3954     LeaveCriticalSection(&stream->cs);
3955
3956     return hr;
3957 }
3958
3959 static HRESULT WINAPI bytestream_stream_Write(IMFByteStream *iface, const BYTE *buffer, ULONG size, ULONG *written)
3960 {
3961     struct bytestream *stream = impl_from_IMFByteStream(iface);
3962     LARGE_INTEGER position;
3963     HRESULT hr;
3964
3965     TRACE("%p, %p, %u, %p.\n", iface, buffer, size, written);
3966
3967     EnterCriticalSection(&stream->cs);
3968
3969     position.QuadPart = stream->position;
3970     if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
3971     {
3972         if (SUCCEEDED(hr = IStream_Write(stream->stream, buffer, size, written)))
3973             stream->position += *written;
3974     }
3975
3976     LeaveCriticalSection(&stream->cs);
3977
3978     return hr;
3979 }
3980
3981 static HRESULT WINAPI bytestream_stream_Seek(IMFByteStream *iface, MFBYTESTREAM_SEEK_ORIGIN origin, LONGLONG offset,
3982         DWORD flags, QWORD *current)
3983 {
3984     struct bytestream *stream = impl_from_IMFByteStream(iface);
3985     HRESULT hr = S_OK;
3986
3987     TRACE("%p, %u, %s, %#x, %p.\n", iface, origin, wine_dbgstr_longlong(offset), flags, current);
3988
3989     EnterCriticalSection(&stream->cs);
3990
3991     switch (origin)
3992     {
3993         case msoBegin:
3994             stream->position = offset;
3995             break;
3996         case msoCurrent:
3997             stream->position += offset;
3998             break;
3999         default:
4000             WARN("Unknown origin mode %d.\n", origin);
4001             hr = E_INVALIDARG;
4002     }
4003
4004     *current = stream->position;
4005
4006     LeaveCriticalSection(&stream->cs);
4007
4008     return hr;
4009 }
4010
4011 static HRESULT WINAPI bytestream_stream_Flush(IMFByteStream *iface)
4012 {
4013     struct bytestream *stream = impl_from_IMFByteStream(iface);
4014
4015     TRACE("%p.\n", iface);
4016
4017     return IStream_Commit(stream->stream, STGC_DEFAULT);
4018 }
4019
4020 static HRESULT WINAPI bytestream_stream_Close(IMFByteStream *iface)
4021 {
4022     TRACE("%p.\n", iface);
4023
4024     return S_OK;
4025 }
4026
4027 static const IMFByteStreamVtbl bytestream_stream_vtbl =
4028 {
4029     bytestream_QueryInterface,
4030     bytestream_AddRef,
4031     bytestream_Release,
4032     bytestream_stream_GetCapabilities,
4033     bytestream_stream_GetLength,
4034     bytestream_stream_SetLength,
4035     bytestream_stream_GetCurrentPosition,
4036     bytestream_SetCurrentPosition,
4037     bytestream_stream_IsEndOfStream,
4038     bytestream_stream_Read,
4039     bytestream_BeginRead,
4040     bytestream_EndRead,
4041     bytestream_stream_Write,
4042     bytestream_BeginWrite,
4043     bytestream_EndWrite,
4044     bytestream_stream_Seek,
4045     bytestream_stream_Flush,
4046     bytestream_stream_Close,
4047 };
4048
4049 static inline mfbytestream *impl_from_IMFByteStream_IMFAttributes(IMFAttributes *iface)
4050 {
4051     return CONTAINING_RECORD(iface, mfbytestream, attributes.IMFAttributes_iface);
4052 }
4053
4054 static HRESULT WINAPI mfbytestream_attributes_QueryInterface(
4055     IMFAttributes *iface, REFIID riid, void **out)
4056 {
4057     mfbytestream *This = impl_from_IMFByteStream_IMFAttributes(iface);
4058     return IMFByteStream_QueryInterface(&This->IMFByteStream_iface, riid, out);
4059 }
4060
4061 static ULONG WINAPI mfbytestream_attributes_AddRef(IMFAttributes *iface)
4062 {
4063     mfbytestream *This = impl_from_IMFByteStream_IMFAttributes(iface);
4064     return IMFByteStream_AddRef(&This->IMFByteStream_iface);
4065 }
4066
4067 static ULONG WINAPI mfbytestream_attributes_Release(IMFAttributes *iface)
4068 {
4069     mfbytestream *This = impl_from_IMFByteStream_IMFAttributes(iface);
4070     return IMFByteStream_Release(&This->IMFByteStream_iface);
4071 }
4072
4073 static const IMFAttributesVtbl mfbytestream_attributes_vtbl =
4074 {
4075     mfbytestream_attributes_QueryInterface,
4076     mfbytestream_attributes_AddRef,
4077     mfbytestream_attributes_Release,
4078     mfattributes_GetItem,
4079     mfattributes_GetItemType,
4080     mfattributes_CompareItem,
4081     mfattributes_Compare,
4082     mfattributes_GetUINT32,
4083     mfattributes_GetUINT64,
4084     mfattributes_GetDouble,
4085     mfattributes_GetGUID,
4086     mfattributes_GetStringLength,
4087     mfattributes_GetString,
4088     mfattributes_GetAllocatedString,
4089     mfattributes_GetBlobSize,
4090     mfattributes_GetBlob,
4091     mfattributes_GetAllocatedBlob,
4092     mfattributes_GetUnknown,
4093     mfattributes_SetItem,
4094     mfattributes_DeleteItem,
4095     mfattributes_DeleteAllItems,
4096     mfattributes_SetUINT32,
4097     mfattributes_SetUINT64,
4098     mfattributes_SetDouble,
4099     mfattributes_SetGUID,
4100     mfattributes_SetString,
4101     mfattributes_SetBlob,
4102     mfattributes_SetUnknown,
4103     mfattributes_LockStore,
4104     mfattributes_UnlockStore,
4105     mfattributes_GetCount,
4106     mfattributes_GetItemByIndex,
4107     mfattributes_CopyAllItems
4108 };
4109
4110 static HRESULT WINAPI bytestream_stream_read_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4111 {
4112     struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
4113     struct async_stream_op *op;
4114     LARGE_INTEGER position;
4115     IUnknown *object;
4116     HRESULT hr;
4117
4118     if (FAILED(hr = IRtwqAsyncResult_GetObject(result, &object)))
4119         return hr;
4120
4121     op = impl_async_stream_op_from_IUnknown(object);
4122
4123     EnterCriticalSection(&stream->cs);
4124
4125     position.QuadPart = op->position;
4126     if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
4127     {
4128         if (SUCCEEDED(hr = IStream_Read(stream->stream, op->u.dest, op->requested_length, &op->actual_length)))
4129             stream->position += op->actual_length;
4130     }
4131
4132     IMFAsyncResult_SetStatus(op->caller, hr);
4133     list_add_tail(&stream->pending, &op->entry);
4134
4135     LeaveCriticalSection(&stream->cs);
4136
4137     MFInvokeCallback(op->caller);
4138
4139     return S_OK;
4140 }
4141
4142 static HRESULT WINAPI bytestream_stream_write_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4143 {
4144     struct bytestream *stream = impl_from_read_callback_IRtwqAsyncCallback(iface);
4145     struct async_stream_op *op;
4146     LARGE_INTEGER position;
4147     IUnknown *object;
4148     HRESULT hr;
4149
4150     if (FAILED(hr = IRtwqAsyncResult_GetObject(result, &object)))
4151         return hr;
4152
4153     op = impl_async_stream_op_from_IUnknown(object);
4154
4155     EnterCriticalSection(&stream->cs);
4156
4157     position.QuadPart = op->position;
4158     if (SUCCEEDED(hr = IStream_Seek(stream->stream, position, STREAM_SEEK_SET, NULL)))
4159     {
4160         if (SUCCEEDED(hr = IStream_Write(stream->stream, op->u.src, op->requested_length, &op->actual_length)))
4161             stream->position += op->actual_length;
4162     }
4163
4164     IMFAsyncResult_SetStatus(op->caller, hr);
4165     list_add_tail(&stream->pending, &op->entry);
4166
4167     LeaveCriticalSection(&stream->cs);
4168
4169     MFInvokeCallback(op->caller);
4170
4171     return S_OK;
4172 }
4173
4174 static const IRtwqAsyncCallbackVtbl bytestream_stream_read_callback_vtbl =
4175 {
4176     bytestream_callback_QueryInterface,
4177     bytestream_read_callback_AddRef,
4178     bytestream_read_callback_Release,
4179     bytestream_callback_GetParameters,
4180     bytestream_stream_read_callback_Invoke,
4181 };
4182
4183 static const IRtwqAsyncCallbackVtbl bytestream_stream_write_callback_vtbl =
4184 {
4185     bytestream_callback_QueryInterface,
4186     bytestream_write_callback_AddRef,
4187     bytestream_write_callback_Release,
4188     bytestream_callback_GetParameters,
4189     bytestream_stream_write_callback_Invoke,
4190 };
4191
4192 /***********************************************************************
4193  *      MFCreateMFByteStreamOnStream (mfplat.@)
4194  */
4195 HRESULT WINAPI MFCreateMFByteStreamOnStream(IStream *stream, IMFByteStream **bytestream)
4196 {
4197     struct bytestream *object;
4198     LARGE_INTEGER position;
4199     STATSTG stat;
4200     HRESULT hr;
4201
4202     TRACE("%p, %p.\n", stream, bytestream);
4203
4204     object = heap_alloc_zero(sizeof(*object));
4205     if (!object)
4206         return E_OUTOFMEMORY;
4207
4208     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
4209     {
4210         heap_free(object);
4211         return hr;
4212     }
4213
4214     object->IMFByteStream_iface.lpVtbl = &bytestream_stream_vtbl;
4215     object->attributes.IMFAttributes_iface.lpVtbl = &mfbytestream_attributes_vtbl;
4216     object->read_callback.lpVtbl = &bytestream_stream_read_callback_vtbl;
4217     object->write_callback.lpVtbl = &bytestream_stream_write_callback_vtbl;
4218     InitializeCriticalSection(&object->cs);
4219     list_init(&object->pending);
4220
4221     object->stream = stream;
4222     IStream_AddRef(object->stream);
4223     position.QuadPart = 0;
4224     IStream_Seek(object->stream, position, STREAM_SEEK_SET, NULL);
4225
4226     if (SUCCEEDED(IStream_Stat(object->stream, &stat, 0)))
4227     {
4228         if (stat.pwcsName)
4229         {
4230             IMFAttributes_SetString(&object->attributes.IMFAttributes_iface, &MF_BYTESTREAM_ORIGIN_NAME,
4231                     stat.pwcsName);
4232             CoTaskMemFree(stat.pwcsName);
4233         }
4234     }
4235
4236     *bytestream = &object->IMFByteStream_iface;
4237
4238     return S_OK;
4239 }
4240
4241 static HRESULT WINAPI bytestream_file_read_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4242 {
4243     FIXME("%p, %p.\n", iface, result);
4244
4245     return E_NOTIMPL;
4246 }
4247
4248 static HRESULT WINAPI bytestream_file_write_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
4249 {
4250     FIXME("%p, %p.\n", iface, result);
4251
4252     return E_NOTIMPL;
4253 }
4254
4255 static const IRtwqAsyncCallbackVtbl bytestream_file_read_callback_vtbl =
4256 {
4257     bytestream_callback_QueryInterface,
4258     bytestream_read_callback_AddRef,
4259     bytestream_read_callback_Release,
4260     bytestream_callback_GetParameters,
4261     bytestream_file_read_callback_Invoke,
4262 };
4263
4264 static const IRtwqAsyncCallbackVtbl bytestream_file_write_callback_vtbl =
4265 {
4266     bytestream_callback_QueryInterface,
4267     bytestream_write_callback_AddRef,
4268     bytestream_write_callback_Release,
4269     bytestream_callback_GetParameters,
4270     bytestream_file_write_callback_Invoke,
4271 };
4272
4273 static HRESULT WINAPI bytestream_file_getservice_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
4274 {
4275     struct bytestream *stream = impl_bytestream_from_IMFGetService(iface);
4276     return IMFByteStream_QueryInterface(&stream->IMFByteStream_iface, riid, obj);
4277 }
4278
4279 static ULONG WINAPI bytestream_file_getservice_AddRef(IMFGetService *iface)
4280 {
4281     struct bytestream *stream = impl_bytestream_from_IMFGetService(iface);
4282     return IMFByteStream_AddRef(&stream->IMFByteStream_iface);
4283 }
4284
4285 static ULONG WINAPI bytestream_file_getservice_Release(IMFGetService *iface)
4286 {
4287     struct bytestream *stream = impl_bytestream_from_IMFGetService(iface);
4288     return IMFByteStream_Release(&stream->IMFByteStream_iface);
4289 }
4290
4291 static HRESULT WINAPI bytestream_file_getservice_GetService(IMFGetService *iface, REFGUID service,
4292         REFIID riid, void **obj)
4293 {
4294     FIXME("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
4295
4296     return E_NOTIMPL;
4297 }
4298
4299 static const IMFGetServiceVtbl bytestream_file_getservice_vtbl =
4300 {
4301     bytestream_file_getservice_QueryInterface,
4302     bytestream_file_getservice_AddRef,
4303     bytestream_file_getservice_Release,
4304     bytestream_file_getservice_GetService,
4305 };
4306
4307 /***********************************************************************
4308  *      MFCreateFile (mfplat.@)
4309  */
4310 HRESULT WINAPI MFCreateFile(MF_FILE_ACCESSMODE accessmode, MF_FILE_OPENMODE openmode, MF_FILE_FLAGS flags,
4311                             LPCWSTR url, IMFByteStream **bytestream)
4312 {
4313     DWORD capabilities = MFBYTESTREAM_IS_SEEKABLE | MFBYTESTREAM_DOES_NOT_USE_NETWORK;
4314     DWORD filecreation_disposition = 0, fileaccessmode = 0, fileattributes = 0;
4315     DWORD filesharemode = FILE_SHARE_READ;
4316     struct bytestream *object;
4317     FILETIME writetime;
4318     HANDLE file;
4319     HRESULT hr;
4320
4321     TRACE("%d, %d, %#x, %s, %p.\n", accessmode, openmode, flags, debugstr_w(url), bytestream);
4322
4323     switch (accessmode)
4324     {
4325         case MF_ACCESSMODE_READ:
4326             fileaccessmode = GENERIC_READ;
4327             capabilities |= MFBYTESTREAM_IS_READABLE;
4328             break;
4329         case MF_ACCESSMODE_WRITE:
4330             fileaccessmode = GENERIC_WRITE;
4331             capabilities |= MFBYTESTREAM_IS_WRITABLE;
4332             break;
4333         case MF_ACCESSMODE_READWRITE:
4334             fileaccessmode = GENERIC_READ | GENERIC_WRITE;
4335             capabilities |= (MFBYTESTREAM_IS_READABLE | MFBYTESTREAM_IS_WRITABLE);
4336             break;
4337     }
4338
4339     switch (openmode)
4340     {
4341         case MF_OPENMODE_FAIL_IF_NOT_EXIST:
4342             filecreation_disposition = OPEN_EXISTING;
4343             break;
4344         case MF_OPENMODE_FAIL_IF_EXIST:
4345             filecreation_disposition = CREATE_NEW;
4346             break;
4347         case MF_OPENMODE_RESET_IF_EXIST:
4348             filecreation_disposition = TRUNCATE_EXISTING;
4349             break;
4350         case MF_OPENMODE_APPEND_IF_EXIST:
4351             filecreation_disposition = OPEN_ALWAYS;
4352             fileaccessmode |= FILE_APPEND_DATA;
4353             break;
4354         case MF_OPENMODE_DELETE_IF_EXIST:
4355             filecreation_disposition = CREATE_ALWAYS;
4356             break;
4357     }
4358
4359     if (flags & MF_FILEFLAGS_NOBUFFERING)
4360         fileattributes |= FILE_FLAG_NO_BUFFERING;
4361
4362     /* Open HANDLE to file */
4363     file = CreateFileW(url, fileaccessmode, filesharemode, NULL,
4364                        filecreation_disposition, fileattributes, 0);
4365
4366     if(file == INVALID_HANDLE_VALUE)
4367         return HRESULT_FROM_WIN32(GetLastError());
4368
4369     object = heap_alloc_zero(sizeof(*object));
4370     if (!object)
4371     {
4372         CloseHandle(file);
4373         return E_OUTOFMEMORY;
4374     }
4375
4376     if (FAILED(hr = init_attributes_object(&object->attributes, 2)))
4377     {
4378         CloseHandle(file);
4379         heap_free(object);
4380         return hr;
4381     }
4382     object->IMFByteStream_iface.lpVtbl = &bytestream_file_vtbl;
4383     object->attributes.IMFAttributes_iface.lpVtbl = &mfbytestream_attributes_vtbl;
4384     object->IMFGetService_iface.lpVtbl = &bytestream_file_getservice_vtbl;
4385     object->read_callback.lpVtbl = &bytestream_file_read_callback_vtbl;
4386     object->write_callback.lpVtbl = &bytestream_file_write_callback_vtbl;
4387     InitializeCriticalSection(&object->cs);
4388     list_init(&object->pending);
4389     object->capabilities = capabilities;
4390     object->hfile = file;
4391
4392     if (GetFileTime(file, NULL, NULL, &writetime))
4393     {
4394         IMFAttributes_SetBlob(&object->attributes.IMFAttributes_iface, &MF_BYTESTREAM_LAST_MODIFIED_TIME,
4395                 (const UINT8 *)&writetime, sizeof(writetime));
4396     }
4397
4398     IMFAttributes_SetString(&object->attributes.IMFAttributes_iface, &MF_BYTESTREAM_ORIGIN_NAME, url);
4399
4400     *bytestream = &object->IMFByteStream_iface;
4401
4402     return S_OK;
4403 }
4404
4405 struct bytestream_wrapper
4406 {
4407     IMFByteStreamCacheControl IMFByteStreamCacheControl_iface;
4408     IMFByteStreamBuffering IMFByteStreamBuffering_iface;
4409     IMFMediaEventGenerator IMFMediaEventGenerator_iface;
4410     IMFByteStreamTimeSeek IMFByteStreamTimeSeek_iface;
4411     IMFSampleOutputStream IMFSampleOutputStream_iface;
4412     IPropertyStore IPropertyStore_iface;
4413     IMFByteStream IMFByteStream_iface;
4414     IMFAttributes IMFAttributes_iface;
4415     LONG refcount;
4416
4417     IMFByteStreamCacheControl *cache_control;
4418     IMFByteStreamBuffering *stream_buffering;
4419     IMFMediaEventGenerator *event_generator;
4420     IMFByteStreamTimeSeek *time_seek;
4421     IMFSampleOutputStream *sample_output;
4422     IPropertyStore *propstore;
4423     IMFByteStream *stream;
4424     IMFAttributes *attributes;
4425     BOOL is_closed;
4426 };
4427
4428 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStream(IMFByteStream *iface)
4429 {
4430     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStream_iface);
4431 }
4432
4433 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStreamCacheControl(IMFByteStreamCacheControl *iface)
4434 {
4435     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStreamCacheControl_iface);
4436 }
4437
4438 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStreamBuffering(IMFByteStreamBuffering *iface)
4439 {
4440     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStreamBuffering_iface);
4441 }
4442
4443 static struct bytestream_wrapper *impl_wrapper_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
4444 {
4445     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFMediaEventGenerator_iface);
4446 }
4447
4448 static struct bytestream_wrapper *impl_wrapper_from_IMFByteStreamTimeSeek(IMFByteStreamTimeSeek *iface)
4449 {
4450     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFByteStreamTimeSeek_iface);
4451 }
4452
4453 static struct bytestream_wrapper *impl_wrapper_from_IMFSampleOutputStream(IMFSampleOutputStream *iface)
4454 {
4455     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFSampleOutputStream_iface);
4456 }
4457
4458 static struct bytestream_wrapper *impl_wrapper_from_IPropertyStore(IPropertyStore *iface)
4459 {
4460     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IPropertyStore_iface);
4461 }
4462
4463 static struct bytestream_wrapper *impl_wrapper_from_IMFAttributes(IMFAttributes *iface)
4464 {
4465     return CONTAINING_RECORD(iface, struct bytestream_wrapper, IMFAttributes_iface);
4466 }
4467
4468 static HRESULT WINAPI bytestream_wrapper_QueryInterface(IMFByteStream *iface, REFIID riid, void **out)
4469 {
4470     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4471
4472     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
4473
4474     if (IsEqualIID(riid, &IID_IMFByteStream) ||
4475             IsEqualIID(riid, &IID_IUnknown))
4476     {
4477         *out = &wrapper->IMFByteStream_iface;
4478     }
4479     else if (wrapper->cache_control && IsEqualIID(riid, &IID_IMFByteStreamCacheControl))
4480     {
4481         *out = &wrapper->IMFByteStreamCacheControl_iface;
4482     }
4483     else if (wrapper->stream_buffering && IsEqualIID(riid, &IID_IMFByteStreamBuffering))
4484     {
4485         *out = &wrapper->IMFByteStreamBuffering_iface;
4486     }
4487     else if (wrapper->event_generator && IsEqualIID(riid, &IID_IMFMediaEventGenerator))
4488     {
4489         *out = &wrapper->IMFMediaEventGenerator_iface;
4490     }
4491     else if (wrapper->time_seek && IsEqualIID(riid, &IID_IMFByteStreamTimeSeek))
4492     {
4493         *out = &wrapper->IMFByteStreamTimeSeek_iface;
4494     }
4495     else if (wrapper->sample_output && IsEqualIID(riid, &IID_IMFSampleOutputStream))
4496     {
4497         *out = &wrapper->IMFSampleOutputStream_iface;
4498     }
4499     else if (wrapper->propstore && IsEqualIID(riid, &IID_IPropertyStore))
4500     {
4501         *out = &wrapper->IPropertyStore_iface;
4502     }
4503     else if (wrapper->attributes && IsEqualIID(riid, &IID_IMFAttributes))
4504     {
4505         *out = &wrapper->IMFAttributes_iface;
4506     }
4507     else
4508     {
4509         WARN("Unsupported %s.\n", debugstr_guid(riid));
4510         *out = NULL;
4511         return E_NOINTERFACE;
4512     }
4513
4514     IUnknown_AddRef((IUnknown *)*out);
4515     return S_OK;
4516 }
4517
4518 static ULONG WINAPI bytestream_wrapper_AddRef(IMFByteStream *iface)
4519 {
4520     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4521     ULONG refcount = InterlockedIncrement(&wrapper->refcount);
4522
4523     TRACE("%p, refcount %d.\n", iface, refcount);
4524
4525     return refcount;
4526 }
4527
4528 static ULONG WINAPI bytestream_wrapper_Release(IMFByteStream *iface)
4529 {
4530     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4531     ULONG refcount = InterlockedDecrement(&wrapper->refcount);
4532
4533     TRACE("%p, refcount %d.\n", iface, refcount);
4534
4535     if (!refcount)
4536     {
4537         if (wrapper->cache_control)
4538             IMFByteStreamCacheControl_Release(wrapper->cache_control);
4539         if (wrapper->stream_buffering)
4540             IMFByteStreamBuffering_Release(wrapper->stream_buffering);
4541         if (wrapper->event_generator)
4542             IMFMediaEventGenerator_Release(wrapper->event_generator);
4543         if (wrapper->time_seek)
4544             IMFByteStreamTimeSeek_Release(wrapper->time_seek);
4545         if (wrapper->sample_output)
4546             IMFSampleOutputStream_Release(wrapper->sample_output);
4547         if (wrapper->propstore)
4548             IPropertyStore_Release(wrapper->propstore);
4549         if (wrapper->attributes)
4550             IMFAttributes_Release(wrapper->attributes);
4551         IMFByteStream_Release(wrapper->stream);
4552         heap_free(wrapper);
4553     }
4554
4555     return refcount;
4556 }
4557
4558 static HRESULT WINAPI bytestream_wrapper_GetCapabilities(IMFByteStream *iface, DWORD *capabilities)
4559 {
4560     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4561
4562     TRACE("%p, %p.\n", iface, capabilities);
4563
4564     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4565             IMFByteStream_GetCapabilities(wrapper->stream, capabilities);
4566 }
4567
4568 static HRESULT WINAPI bytestream_wrapper_GetLength(IMFByteStream *iface, QWORD *length)
4569 {
4570     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4571
4572     TRACE("%p, %p.\n", iface, length);
4573
4574     if (wrapper->is_closed)
4575         return MF_E_INVALIDREQUEST;
4576
4577     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4578             IMFByteStream_GetLength(wrapper->stream, length);
4579 }
4580
4581 static HRESULT WINAPI bytestream_wrapper_SetLength(IMFByteStream *iface, QWORD length)
4582 {
4583     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4584
4585     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(length));
4586
4587     if (wrapper->is_closed)
4588         return MF_E_INVALIDREQUEST;
4589
4590     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4591             IMFByteStream_SetLength(wrapper->stream, length);
4592 }
4593
4594 static HRESULT WINAPI bytestream_wrapper_GetCurrentPosition(IMFByteStream *iface, QWORD *position)
4595 {
4596     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4597
4598     TRACE("%p, %p.\n", iface, position);
4599
4600     if (wrapper->is_closed)
4601         return MF_E_INVALIDREQUEST;
4602
4603     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4604             IMFByteStream_GetCurrentPosition(wrapper->stream, position);
4605 }
4606
4607 static HRESULT WINAPI bytestream_wrapper_SetCurrentPosition(IMFByteStream *iface, QWORD position)
4608 {
4609     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4610
4611     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(position));
4612
4613     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4614             IMFByteStream_SetCurrentPosition(wrapper->stream, position);
4615 }
4616
4617 static HRESULT WINAPI bytestream_wrapper_IsEndOfStream(IMFByteStream *iface, BOOL *eos)
4618 {
4619     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4620
4621     TRACE("%p, %p.\n", iface, eos);
4622
4623     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4624             IMFByteStream_IsEndOfStream(wrapper->stream, eos);
4625 }
4626
4627 static HRESULT WINAPI bytestream_wrapper_Read(IMFByteStream *iface, BYTE *data, ULONG count, ULONG *byte_read)
4628 {
4629     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4630
4631     TRACE("%p, %p, %u, %p.\n", iface, data, count, byte_read);
4632
4633     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4634             IMFByteStream_Read(wrapper->stream, data, count, byte_read);
4635 }
4636
4637 static HRESULT WINAPI bytestream_wrapper_BeginRead(IMFByteStream *iface, BYTE *data, ULONG size,
4638         IMFAsyncCallback *callback, IUnknown *state)
4639 {
4640     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4641
4642     TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
4643
4644     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4645             IMFByteStream_BeginRead(wrapper->stream, data, size, callback, state);
4646 }
4647
4648 static HRESULT WINAPI bytestream_wrapper_EndRead(IMFByteStream *iface, IMFAsyncResult *result, ULONG *byte_read)
4649 {
4650     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4651
4652     TRACE("%p, %p, %p.\n", iface, result, byte_read);
4653
4654     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4655             IMFByteStream_EndRead(wrapper->stream, result, byte_read);
4656 }
4657
4658 static HRESULT WINAPI bytestream_wrapper_Write(IMFByteStream *iface, const BYTE *data, ULONG count, ULONG *written)
4659 {
4660     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4661
4662     TRACE("%p, %p, %u, %p.\n", iface, data, count, written);
4663
4664     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4665             IMFByteStream_Write(wrapper->stream, data, count, written);
4666 }
4667
4668 static HRESULT WINAPI bytestream_wrapper_BeginWrite(IMFByteStream *iface, const BYTE *data, ULONG size,
4669         IMFAsyncCallback *callback, IUnknown *state)
4670 {
4671     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4672
4673     TRACE("%p, %p, %u, %p, %p.\n", iface, data, size, callback, state);
4674
4675     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4676             IMFByteStream_BeginWrite(wrapper->stream, data, size, callback, state);
4677 }
4678
4679 static HRESULT WINAPI bytestream_wrapper_EndWrite(IMFByteStream *iface, IMFAsyncResult *result, ULONG *written)
4680 {
4681     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4682
4683     TRACE("%p, %p, %p.\n", iface, result, written);
4684
4685     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4686             IMFByteStream_EndWrite(wrapper->stream, result, written);
4687 }
4688
4689 static HRESULT WINAPI bytestream_wrapper_Seek(IMFByteStream *iface, MFBYTESTREAM_SEEK_ORIGIN seek, LONGLONG offset,
4690         DWORD flags, QWORD *current)
4691 {
4692     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4693
4694     TRACE("%p, %u, %s, %#x, %p.\n", iface, seek, wine_dbgstr_longlong(offset), flags, current);
4695
4696     return wrapper->is_closed ? MF_E_INVALIDREQUEST :
4697             IMFByteStream_Seek(wrapper->stream, seek, offset, flags, current);
4698 }
4699
4700 static HRESULT WINAPI bytestream_wrapper_Flush(IMFByteStream *iface)
4701 {
4702     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4703
4704     TRACE("%p\n", iface);
4705
4706     return wrapper->is_closed ? MF_E_INVALIDREQUEST : IMFByteStream_Flush(wrapper->stream);
4707 }
4708
4709 static HRESULT WINAPI bytestream_wrapper_Close(IMFByteStream *iface)
4710 {
4711     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStream(iface);
4712
4713     TRACE("%p\n", iface);
4714
4715     wrapper->is_closed = TRUE;
4716
4717     return S_OK;
4718 }
4719
4720 static const IMFByteStreamVtbl bytestream_wrapper_vtbl =
4721 {
4722     bytestream_wrapper_QueryInterface,
4723     bytestream_wrapper_AddRef,
4724     bytestream_wrapper_Release,
4725     bytestream_wrapper_GetCapabilities,
4726     bytestream_wrapper_GetLength,
4727     bytestream_wrapper_SetLength,
4728     bytestream_wrapper_GetCurrentPosition,
4729     bytestream_wrapper_SetCurrentPosition,
4730     bytestream_wrapper_IsEndOfStream,
4731     bytestream_wrapper_Read,
4732     bytestream_wrapper_BeginRead,
4733     bytestream_wrapper_EndRead,
4734     bytestream_wrapper_Write,
4735     bytestream_wrapper_BeginWrite,
4736     bytestream_wrapper_EndWrite,
4737     bytestream_wrapper_Seek,
4738     bytestream_wrapper_Flush,
4739     bytestream_wrapper_Close,
4740 };
4741
4742 static HRESULT WINAPI bytestream_wrapper_cache_control_QueryInterface(IMFByteStreamCacheControl *iface,
4743         REFIID riid, void **obj)
4744 {
4745     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4746     return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4747 }
4748
4749 static ULONG WINAPI bytestream_wrapper_cache_control_AddRef(IMFByteStreamCacheControl *iface)
4750 {
4751     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4752     return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4753 }
4754
4755 static ULONG WINAPI bytestream_wrapper_cache_control_Release(IMFByteStreamCacheControl *iface)
4756 {
4757     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4758     return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4759 }
4760
4761 static HRESULT WINAPI bytestream_wrapper_cache_control_StopBackgroundTransfer(IMFByteStreamCacheControl *iface)
4762 {
4763     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamCacheControl(iface);
4764
4765     TRACE("%p.\n", iface);
4766
4767     return IMFByteStreamCacheControl_StopBackgroundTransfer(wrapper->cache_control);
4768 }
4769
4770 static const IMFByteStreamCacheControlVtbl bytestream_wrapper_cache_control_vtbl =
4771 {
4772     bytestream_wrapper_cache_control_QueryInterface,
4773     bytestream_wrapper_cache_control_AddRef,
4774     bytestream_wrapper_cache_control_Release,
4775     bytestream_wrapper_cache_control_StopBackgroundTransfer,
4776 };
4777
4778 static HRESULT WINAPI bytestream_wrapper_buffering_QueryInterface(IMFByteStreamBuffering *iface,
4779         REFIID riid, void **obj)
4780 {
4781     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4782     return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4783 }
4784
4785 static ULONG WINAPI bytestream_wrapper_buffering_AddRef(IMFByteStreamBuffering *iface)
4786 {
4787     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4788     return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4789 }
4790
4791 static ULONG WINAPI bytestream_wrapper_buffering_Release(IMFByteStreamBuffering *iface)
4792 {
4793     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4794     return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4795 }
4796
4797 static HRESULT WINAPI bytestream_wrapper_buffering_SetBufferingParams(IMFByteStreamBuffering *iface,
4798         MFBYTESTREAM_BUFFERING_PARAMS *params)
4799 {
4800     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4801
4802     TRACE("%p, %p.\n", iface, params);
4803
4804     return IMFByteStreamBuffering_SetBufferingParams(wrapper->stream_buffering, params);
4805 }
4806
4807 static HRESULT WINAPI bytestream_wrapper_buffering_EnableBuffering(IMFByteStreamBuffering *iface,
4808         BOOL enable)
4809 {
4810     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4811
4812     TRACE("%p, %d.\n", iface, enable);
4813
4814     return IMFByteStreamBuffering_EnableBuffering(wrapper->stream_buffering, enable);
4815 }
4816
4817 static HRESULT WINAPI bytestream_wrapper_buffering_StopBuffering(IMFByteStreamBuffering *iface)
4818 {
4819     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamBuffering(iface);
4820
4821     TRACE("%p.\n", iface);
4822
4823     return IMFByteStreamBuffering_StopBuffering(wrapper->stream_buffering);
4824 }
4825
4826 static const IMFByteStreamBufferingVtbl bytestream_wrapper_buffering_vtbl =
4827 {
4828     bytestream_wrapper_buffering_QueryInterface,
4829     bytestream_wrapper_buffering_AddRef,
4830     bytestream_wrapper_buffering_Release,
4831     bytestream_wrapper_buffering_SetBufferingParams,
4832     bytestream_wrapper_buffering_EnableBuffering,
4833     bytestream_wrapper_buffering_StopBuffering,
4834 };
4835
4836 static HRESULT WINAPI bytestream_wrapper_timeseek_QueryInterface(IMFByteStreamTimeSeek *iface,
4837         REFIID riid, void **obj)
4838 {
4839     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4840     return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4841 }
4842
4843 static ULONG WINAPI bytestream_wrapper_timeseek_AddRef(IMFByteStreamTimeSeek *iface)
4844 {
4845     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4846     return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4847 }
4848
4849 static ULONG WINAPI bytestream_wrapper_timeseek_Release(IMFByteStreamTimeSeek *iface)
4850 {
4851     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4852     return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4853 }
4854
4855 static HRESULT WINAPI bytestream_wrapper_timeseek_IsTimeSeekSupported(IMFByteStreamTimeSeek *iface, BOOL *result)
4856 {
4857     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4858
4859     TRACE("%p, %p.\n", iface, result);
4860
4861     return IMFByteStreamTimeSeek_IsTimeSeekSupported(wrapper->time_seek, result);
4862 }
4863
4864 static HRESULT WINAPI bytestream_wrapper_timeseek_TimeSeek(IMFByteStreamTimeSeek *iface, QWORD position)
4865 {
4866     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4867
4868     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(position));
4869
4870     return IMFByteStreamTimeSeek_TimeSeek(wrapper->time_seek, position);
4871 }
4872
4873 static HRESULT WINAPI bytestream_wrapper_timeseek_GetTimeSeekResult(IMFByteStreamTimeSeek *iface, QWORD *start_time,
4874         QWORD *stop_time, QWORD *duration)
4875 {
4876     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFByteStreamTimeSeek(iface);
4877
4878     TRACE("%p, %p, %p, %p.\n", iface, start_time, stop_time, duration);
4879
4880     return IMFByteStreamTimeSeek_GetTimeSeekResult(wrapper->time_seek, start_time, stop_time, duration);
4881 }
4882
4883 static const IMFByteStreamTimeSeekVtbl bytestream_wrapper_timeseek_vtbl =
4884 {
4885     bytestream_wrapper_timeseek_QueryInterface,
4886     bytestream_wrapper_timeseek_AddRef,
4887     bytestream_wrapper_timeseek_Release,
4888     bytestream_wrapper_timeseek_IsTimeSeekSupported,
4889     bytestream_wrapper_timeseek_TimeSeek,
4890     bytestream_wrapper_timeseek_GetTimeSeekResult,
4891 };
4892
4893 static HRESULT WINAPI bytestream_wrapper_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
4894 {
4895     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4896     return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4897 }
4898
4899 static ULONG WINAPI bytestream_wrapper_events_AddRef(IMFMediaEventGenerator *iface)
4900 {
4901     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4902     return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4903 }
4904
4905 static ULONG WINAPI bytestream_wrapper_events_Release(IMFMediaEventGenerator *iface)
4906 {
4907     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4908     return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4909 }
4910
4911 static HRESULT WINAPI bytestream_wrapper_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
4912 {
4913     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4914
4915     TRACE("%p, %#x, %p.\n", iface, flags, event);
4916
4917     return IMFMediaEventGenerator_GetEvent(wrapper->event_generator, flags, event);
4918 }
4919
4920 static HRESULT WINAPI bytestream_wrapper_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback, IUnknown *state)
4921 {
4922     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4923
4924     TRACE("%p, %p, %p.\n", iface, callback, state);
4925
4926     return IMFMediaEventGenerator_BeginGetEvent(wrapper->event_generator, callback, state);
4927 }
4928
4929 static HRESULT WINAPI bytestream_wrapper_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result, IMFMediaEvent **event)
4930 {
4931     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4932
4933     TRACE("%p, %p, %p.\n", iface, result, event);
4934
4935     return IMFMediaEventGenerator_EndGetEvent(wrapper->event_generator, result, event);
4936 }
4937
4938 static HRESULT WINAPI bytestream_wrapper_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType type,
4939         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
4940 {
4941     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFMediaEventGenerator(iface);
4942
4943     TRACE("%p, %d, %s, %#x, %s.\n", iface, type, debugstr_guid(ext_type), hr, debugstr_propvar(value));
4944
4945     return IMFMediaEventGenerator_QueueEvent(wrapper->event_generator, type, ext_type, hr, value);
4946 }
4947
4948 static const IMFMediaEventGeneratorVtbl bytestream_wrapper_events_vtbl =
4949 {
4950     bytestream_wrapper_events_QueryInterface,
4951     bytestream_wrapper_events_AddRef,
4952     bytestream_wrapper_events_Release,
4953     bytestream_wrapper_events_GetEvent,
4954     bytestream_wrapper_events_BeginGetEvent,
4955     bytestream_wrapper_events_EndGetEvent,
4956     bytestream_wrapper_events_QueueEvent,
4957 };
4958
4959 static HRESULT WINAPI bytestream_wrapper_sample_output_QueryInterface(IMFSampleOutputStream *iface, REFIID riid, void **obj)
4960 {
4961     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
4962     return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
4963 }
4964
4965 static ULONG WINAPI bytestream_wrapper_sample_output_AddRef(IMFSampleOutputStream *iface)
4966 {
4967     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
4968     return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
4969 }
4970
4971 static ULONG WINAPI bytestream_wrapper_sample_output_Release(IMFSampleOutputStream *iface)
4972 {
4973     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
4974     return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
4975 }
4976
4977 static HRESULT WINAPI bytestream_wrapper_sample_output_BeginWriteSample(IMFSampleOutputStream *iface, IMFSample *sample,
4978         IMFAsyncCallback *callback, IUnknown *state)
4979 {
4980     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
4981
4982     TRACE("%p, %p, %p, %p.\n", iface, sample, callback, state);
4983
4984     return IMFSampleOutputStream_BeginWriteSample(wrapper->sample_output, sample, callback, state);
4985 }
4986
4987 static HRESULT WINAPI bytestream_wrapper_sample_output_EndWriteSample(IMFSampleOutputStream *iface, IMFAsyncResult *result)
4988 {
4989     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
4990
4991     TRACE("%p, %p.\n", iface, result);
4992
4993     return IMFSampleOutputStream_EndWriteSample(wrapper->sample_output, result);
4994 }
4995
4996 static HRESULT WINAPI bytestream_wrapper_sample_output_Close(IMFSampleOutputStream *iface)
4997 {
4998     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFSampleOutputStream(iface);
4999
5000     TRACE("%p.\n", iface);
5001
5002     return IMFSampleOutputStream_Close(wrapper->sample_output);
5003 }
5004
5005 static const IMFSampleOutputStreamVtbl bytestream_wrapper_sample_output_vtbl =
5006 {
5007     bytestream_wrapper_sample_output_QueryInterface,
5008     bytestream_wrapper_sample_output_AddRef,
5009     bytestream_wrapper_sample_output_Release,
5010     bytestream_wrapper_sample_output_BeginWriteSample,
5011     bytestream_wrapper_sample_output_EndWriteSample,
5012     bytestream_wrapper_sample_output_Close,
5013 };
5014
5015 static HRESULT WINAPI bytestream_wrapper_propstore_QueryInterface(IPropertyStore *iface, REFIID riid, void **obj)
5016 {
5017     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5018     return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
5019 }
5020
5021 static ULONG WINAPI bytestream_wrapper_propstore_AddRef(IPropertyStore *iface)
5022 {
5023     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5024     return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
5025 }
5026
5027 static ULONG WINAPI bytestream_wrapper_propstore_Release(IPropertyStore *iface)
5028 {
5029     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5030     return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
5031 }
5032
5033 static HRESULT WINAPI bytestream_wrapper_propstore_GetCount(IPropertyStore *iface, DWORD *count)
5034 {
5035     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5036
5037     TRACE("%p, %p.\n", iface, count);
5038
5039     return IPropertyStore_GetCount(wrapper->propstore, count);
5040 }
5041
5042 static HRESULT WINAPI bytestream_wrapper_propstore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
5043 {
5044     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5045
5046     TRACE("%p, %u, %p.\n", iface, prop, key);
5047
5048     return IPropertyStore_GetAt(wrapper->propstore, prop, key);
5049 }
5050
5051 static HRESULT WINAPI bytestream_wrapper_propstore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
5052 {
5053     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5054
5055     TRACE("%p, %p, %p.\n", iface, key, value);
5056
5057     return IPropertyStore_GetValue(wrapper->propstore, key, value);
5058 }
5059
5060 static HRESULT WINAPI bytestream_wrapper_propstore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key,
5061         const PROPVARIANT *value)
5062 {
5063     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5064
5065     TRACE("%p, %p, %s.\n", iface, key, debugstr_propvar(value));
5066
5067     return IPropertyStore_SetValue(wrapper->propstore, key, value);
5068 }
5069
5070 static HRESULT WINAPI bytestream_wrapper_propstore_Commit(IPropertyStore *iface)
5071 {
5072     struct bytestream_wrapper *wrapper = impl_wrapper_from_IPropertyStore(iface);
5073
5074     TRACE("%p.\n", iface);
5075
5076     return IPropertyStore_Commit(wrapper->propstore);
5077 }
5078
5079 static const IPropertyStoreVtbl bytestream_wrapper_propstore_vtbl =
5080 {
5081     bytestream_wrapper_propstore_QueryInterface,
5082     bytestream_wrapper_propstore_AddRef,
5083     bytestream_wrapper_propstore_Release,
5084     bytestream_wrapper_propstore_GetCount,
5085     bytestream_wrapper_propstore_GetAt,
5086     bytestream_wrapper_propstore_GetValue,
5087     bytestream_wrapper_propstore_SetValue,
5088     bytestream_wrapper_propstore_Commit,
5089 };
5090
5091 static HRESULT WINAPI bytestream_wrapper_attributes_QueryInterface(IMFAttributes *iface, REFIID riid, void **obj)
5092 {
5093     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5094     return IMFByteStream_QueryInterface(&wrapper->IMFByteStream_iface, riid, obj);
5095 }
5096
5097 static ULONG WINAPI bytestream_wrapper_attributes_AddRef(IMFAttributes *iface)
5098 {
5099     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5100     return IMFByteStream_AddRef(&wrapper->IMFByteStream_iface);
5101 }
5102
5103 static ULONG WINAPI bytestream_wrapper_attributes_Release(IMFAttributes *iface)
5104 {
5105     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5106     return IMFByteStream_Release(&wrapper->IMFByteStream_iface);
5107 }
5108
5109 static HRESULT WINAPI bytestream_wrapper_attributes_GetItem(IMFAttributes *iface, REFGUID key, PROPVARIANT *value)
5110 {
5111     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5112
5113     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5114
5115     return IMFAttributes_GetItem(wrapper->attributes, key, value);
5116 }
5117
5118 static HRESULT WINAPI bytestream_wrapper_attributes_GetItemType(IMFAttributes *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
5119 {
5120     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5121
5122     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
5123
5124     return IMFAttributes_GetItemType(wrapper->attributes, key, type);
5125 }
5126
5127 static HRESULT WINAPI bytestream_wrapper_attributes_CompareItem(IMFAttributes *iface, REFGUID key,
5128         REFPROPVARIANT value, BOOL *result)
5129 {
5130     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5131
5132     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
5133
5134     return IMFAttributes_CompareItem(wrapper->attributes, key, value, result);
5135 }
5136
5137 static HRESULT WINAPI bytestream_wrapper_attributes_Compare(IMFAttributes *iface, IMFAttributes *theirs,
5138         MF_ATTRIBUTES_MATCH_TYPE match_type, BOOL *ret)
5139 {
5140     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5141
5142     TRACE("%p, %p, %d, %p.\n", iface, theirs, match_type, ret);
5143
5144     return IMFAttributes_Compare(wrapper->attributes, theirs, match_type, ret);
5145 }
5146
5147 static HRESULT WINAPI bytestream_wrapper_attributes_GetUINT32(IMFAttributes *iface, REFGUID key, UINT32 *value)
5148 {
5149     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5150
5151     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5152
5153     return IMFAttributes_GetUINT32(wrapper->attributes, key, value);
5154 }
5155
5156 static HRESULT WINAPI bytestream_wrapper_attributes_GetUINT64(IMFAttributes *iface, REFGUID key, UINT64 *value)
5157 {
5158     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5159
5160     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5161
5162     return IMFAttributes_GetUINT64(wrapper->attributes, key, value);
5163 }
5164
5165 static HRESULT WINAPI bytestream_wrapper_attributes_GetDouble(IMFAttributes *iface, REFGUID key, double *value)
5166 {
5167     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5168
5169     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5170
5171     return IMFAttributes_GetDouble(wrapper->attributes, key, value);
5172 }
5173
5174 static HRESULT WINAPI bytestream_wrapper_attributes_GetGUID(IMFAttributes *iface, REFGUID key, GUID *value)
5175 {
5176     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5177
5178     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
5179
5180     return IMFAttributes_GetGUID(wrapper->attributes, key, value);
5181 }
5182
5183 static HRESULT WINAPI bytestream_wrapper_attributes_GetStringLength(IMFAttributes *iface, REFGUID key, UINT32 *length)
5184 {
5185     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5186
5187     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
5188
5189     return IMFAttributes_GetStringLength(wrapper->attributes, key, length);
5190 }
5191
5192 static HRESULT WINAPI bytestream_wrapper_attributes_GetString(IMFAttributes *iface, REFGUID key, WCHAR *value,
5193         UINT32 size, UINT32 *length)
5194 {
5195     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5196
5197     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), value, size, length);
5198
5199     return IMFAttributes_GetString(wrapper->attributes, key, value, size, length);
5200 }
5201
5202 static HRESULT WINAPI bytestream_wrapper_attributes_GetAllocatedString(IMFAttributes *iface, REFGUID key, WCHAR **value, UINT32 *length)
5203 {
5204     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5205
5206     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
5207
5208     return IMFAttributes_GetAllocatedString(wrapper->attributes, key, value, length);
5209 }
5210
5211 static HRESULT WINAPI bytestream_wrapper_attributes_GetBlobSize(IMFAttributes *iface, REFGUID key, UINT32 *size)
5212 {
5213     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5214
5215     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
5216
5217     return IMFAttributes_GetBlobSize(wrapper->attributes, key, size);
5218 }
5219
5220 static HRESULT WINAPI bytestream_wrapper_attributes_GetBlob(IMFAttributes *iface, REFGUID key, UINT8 *buf,
5221                 UINT32 bufsize, UINT32 *blobsize)
5222 {
5223     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5224
5225     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
5226
5227     return IMFAttributes_GetBlob(wrapper->attributes, key, buf, bufsize, blobsize);
5228 }
5229
5230 static HRESULT WINAPI bytestream_wrapper_attributes_GetAllocatedBlob(IMFAttributes *iface, REFGUID key, UINT8 **buf, UINT32 *size)
5231 {
5232     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5233
5234     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
5235
5236     return IMFAttributes_GetAllocatedBlob(wrapper->attributes, key, buf, size);
5237 }
5238
5239 static HRESULT WINAPI bytestream_wrapper_attributes_GetUnknown(IMFAttributes *iface, REFGUID key, REFIID riid, void **obj)
5240 {
5241     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5242
5243     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), obj);
5244
5245     return IMFAttributes_GetUnknown(wrapper->attributes, key, riid, obj);
5246 }
5247
5248 static HRESULT WINAPI bytestream_wrapper_attributes_SetItem(IMFAttributes *iface, REFGUID key, REFPROPVARIANT value)
5249 {
5250     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5251
5252     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
5253
5254     return IMFAttributes_SetItem(wrapper->attributes, key, value);
5255 }
5256
5257 static HRESULT WINAPI bytestream_wrapper_attributes_DeleteItem(IMFAttributes *iface, REFGUID key)
5258 {
5259     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5260
5261     TRACE("%p, %s.\n", iface, debugstr_attr(key));
5262
5263     return IMFAttributes_DeleteItem(wrapper->attributes, key);
5264 }
5265
5266 static HRESULT WINAPI bytestream_wrapper_attributes_DeleteAllItems(IMFAttributes *iface)
5267 {
5268     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5269
5270     TRACE("%p.\n", iface);
5271
5272     return IMFAttributes_DeleteAllItems(wrapper->attributes);
5273 }
5274
5275 static HRESULT WINAPI bytestream_wrapper_attributes_SetUINT32(IMFAttributes *iface, REFGUID key, UINT32 value)
5276 {
5277     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5278
5279     TRACE("%p, %s, %d.\n", iface, debugstr_attr(key), value);
5280
5281     return IMFAttributes_SetUINT32(wrapper->attributes, key, value);
5282 }
5283
5284 static HRESULT WINAPI bytestream_wrapper_attributes_SetUINT64(IMFAttributes *iface, REFGUID key, UINT64 value)
5285 {
5286     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5287
5288     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
5289
5290     return IMFAttributes_SetUINT64(wrapper->attributes, key, value);
5291 }
5292
5293 static HRESULT WINAPI bytestream_wrapper_attributes_SetDouble(IMFAttributes *iface, REFGUID key, double value)
5294 {
5295     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5296
5297     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
5298
5299     return IMFAttributes_SetDouble(wrapper->attributes, key, value);
5300 }
5301
5302 static HRESULT WINAPI bytestream_wrapper_attributes_SetGUID(IMFAttributes *iface, REFGUID key, REFGUID value)
5303 {
5304     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5305
5306     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
5307
5308     return IMFAttributes_SetGUID(wrapper->attributes, key, value);
5309 }
5310
5311 static HRESULT WINAPI bytestream_wrapper_attributes_SetString(IMFAttributes *iface, REFGUID key, const WCHAR *value)
5312 {
5313     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5314
5315     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
5316
5317     return IMFAttributes_SetString(wrapper->attributes, key, value);
5318 }
5319
5320 static HRESULT WINAPI bytestream_wrapper_attributes_SetBlob(IMFAttributes *iface, REFGUID key, const UINT8 *buf, UINT32 size)
5321 {
5322     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5323
5324     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
5325
5326     return IMFAttributes_SetBlob(wrapper->attributes, key, buf, size);
5327 }
5328
5329 static HRESULT WINAPI bytestream_wrapper_attributes_SetUnknown(IMFAttributes *iface, REFGUID key, IUnknown *unknown)
5330 {
5331     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5332
5333     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
5334
5335     return IMFAttributes_SetUnknown(wrapper->attributes, key, unknown);
5336 }
5337
5338 static HRESULT WINAPI bytestream_wrapper_attributes_LockStore(IMFAttributes *iface)
5339 {
5340     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5341
5342     TRACE("%p.\n", iface);
5343
5344     return IMFAttributes_LockStore(wrapper->attributes);
5345 }
5346
5347 static HRESULT WINAPI bytestream_wrapper_attributes_UnlockStore(IMFAttributes *iface)
5348 {
5349     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5350
5351     TRACE("%p.\n", iface);
5352
5353     return IMFAttributes_UnlockStore(wrapper->attributes);
5354 }
5355
5356 static HRESULT WINAPI bytestream_wrapper_attributes_GetCount(IMFAttributes *iface, UINT32 *count)
5357 {
5358     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5359
5360     TRACE("%p, %p.\n", iface, count);
5361
5362     return IMFAttributes_GetCount(wrapper->attributes, count);
5363 }
5364
5365 static HRESULT WINAPI bytestream_wrapper_attributes_GetItemByIndex(IMFAttributes *iface, UINT32 index, GUID *key, PROPVARIANT *value)
5366 {
5367     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5368
5369     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
5370
5371     return IMFAttributes_GetItemByIndex(wrapper->attributes, index, key, value);
5372 }
5373
5374 static HRESULT WINAPI bytestream_wrapper_attributes_CopyAllItems(IMFAttributes *iface, IMFAttributes *dest)
5375 {
5376     struct bytestream_wrapper *wrapper = impl_wrapper_from_IMFAttributes(iface);
5377
5378     TRACE("%p, %p.\n", iface, dest);
5379
5380     return IMFAttributes_CopyAllItems(wrapper->attributes, dest);
5381 }
5382
5383 static const IMFAttributesVtbl bytestream_wrapper_attributes_vtbl =
5384 {
5385     bytestream_wrapper_attributes_QueryInterface,
5386     bytestream_wrapper_attributes_AddRef,
5387     bytestream_wrapper_attributes_Release,
5388     bytestream_wrapper_attributes_GetItem,
5389     bytestream_wrapper_attributes_GetItemType,
5390     bytestream_wrapper_attributes_CompareItem,
5391     bytestream_wrapper_attributes_Compare,
5392     bytestream_wrapper_attributes_GetUINT32,
5393     bytestream_wrapper_attributes_GetUINT64,
5394     bytestream_wrapper_attributes_GetDouble,
5395     bytestream_wrapper_attributes_GetGUID,
5396     bytestream_wrapper_attributes_GetStringLength,
5397     bytestream_wrapper_attributes_GetString,
5398     bytestream_wrapper_attributes_GetAllocatedString,
5399     bytestream_wrapper_attributes_GetBlobSize,
5400     bytestream_wrapper_attributes_GetBlob,
5401     bytestream_wrapper_attributes_GetAllocatedBlob,
5402     bytestream_wrapper_attributes_GetUnknown,
5403     bytestream_wrapper_attributes_SetItem,
5404     bytestream_wrapper_attributes_DeleteItem,
5405     bytestream_wrapper_attributes_DeleteAllItems,
5406     bytestream_wrapper_attributes_SetUINT32,
5407     bytestream_wrapper_attributes_SetUINT64,
5408     bytestream_wrapper_attributes_SetDouble,
5409     bytestream_wrapper_attributes_SetGUID,
5410     bytestream_wrapper_attributes_SetString,
5411     bytestream_wrapper_attributes_SetBlob,
5412     bytestream_wrapper_attributes_SetUnknown,
5413     bytestream_wrapper_attributes_LockStore,
5414     bytestream_wrapper_attributes_UnlockStore,
5415     bytestream_wrapper_attributes_GetCount,
5416     bytestream_wrapper_attributes_GetItemByIndex,
5417     bytestream_wrapper_attributes_CopyAllItems
5418 };
5419
5420 /***********************************************************************
5421  *      MFCreateMFByteStreamWrapper (mfplat.@)
5422  */
5423 HRESULT WINAPI MFCreateMFByteStreamWrapper(IMFByteStream *stream, IMFByteStream **wrapper)
5424 {
5425     struct bytestream_wrapper *object;
5426
5427     TRACE("%p, %p.\n", stream, wrapper);
5428
5429     object = heap_alloc_zero(sizeof(*object));
5430     if (!object)
5431         return E_OUTOFMEMORY;
5432
5433     object->IMFByteStreamCacheControl_iface.lpVtbl = &bytestream_wrapper_cache_control_vtbl;
5434     object->IMFByteStreamBuffering_iface.lpVtbl = &bytestream_wrapper_buffering_vtbl;
5435     object->IMFMediaEventGenerator_iface.lpVtbl = &bytestream_wrapper_events_vtbl;
5436     object->IMFByteStreamTimeSeek_iface.lpVtbl = &bytestream_wrapper_timeseek_vtbl;
5437     object->IMFSampleOutputStream_iface.lpVtbl = &bytestream_wrapper_sample_output_vtbl;
5438     object->IMFByteStream_iface.lpVtbl = &bytestream_wrapper_vtbl;
5439     object->IPropertyStore_iface.lpVtbl = &bytestream_wrapper_propstore_vtbl;
5440     object->IMFAttributes_iface.lpVtbl = &bytestream_wrapper_attributes_vtbl;
5441
5442     IMFByteStream_QueryInterface(stream, &IID_IMFByteStreamCacheControl, (void **)&object->cache_control);
5443     IMFByteStream_QueryInterface(stream, &IID_IMFByteStreamBuffering, (void **)&object->stream_buffering);
5444     IMFByteStream_QueryInterface(stream, &IID_IMFMediaEventGenerator, (void **)&object->event_generator);
5445     IMFByteStream_QueryInterface(stream, &IID_IMFByteStreamTimeSeek, (void **)&object->time_seek);
5446     IMFByteStream_QueryInterface(stream, &IID_IMFSampleOutputStream, (void **)&object->sample_output);
5447     IMFByteStream_QueryInterface(stream, &IID_IPropertyStore, (void **)&object->propstore);
5448     IMFByteStream_QueryInterface(stream, &IID_IMFAttributes, (void **)&object->attributes);
5449
5450     object->stream = stream;
5451     IMFByteStream_AddRef(object->stream);
5452
5453     object->refcount = 1;
5454
5455     *wrapper = &object->IMFByteStream_iface;
5456
5457     return S_OK;
5458 }
5459
5460 static HRESULT WINAPI MFPluginControl_QueryInterface(IMFPluginControl *iface, REFIID riid, void **ppv)
5461 {
5462     if(IsEqualGUID(riid, &IID_IUnknown)) {
5463         TRACE("(IID_IUnknown %p)\n", ppv);
5464         *ppv = iface;
5465     }else if(IsEqualGUID(riid, &IID_IMFPluginControl)) {
5466         TRACE("(IID_IMFPluginControl %p)\n", ppv);
5467         *ppv = iface;
5468     }else {
5469         FIXME("(%s %p)\n", debugstr_guid(riid), ppv);
5470         *ppv = NULL;
5471         return E_NOINTERFACE;
5472     }
5473
5474     IUnknown_AddRef((IUnknown*)*ppv);
5475     return S_OK;
5476 }
5477
5478 static ULONG WINAPI MFPluginControl_AddRef(IMFPluginControl *iface)
5479 {
5480     TRACE("\n");
5481     return 2;
5482 }
5483
5484 static ULONG WINAPI MFPluginControl_Release(IMFPluginControl *iface)
5485 {
5486     TRACE("\n");
5487     return 1;
5488 }
5489
5490 static HRESULT WINAPI MFPluginControl_GetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
5491         const WCHAR *selector, CLSID *clsid)
5492 {
5493     FIXME("(%d %s %p)\n", plugin_type, debugstr_w(selector), clsid);
5494     return E_NOTIMPL;
5495 }
5496
5497 static HRESULT WINAPI MFPluginControl_GetPreferredClsidByIndex(IMFPluginControl *iface, DWORD plugin_type,
5498         DWORD index, WCHAR **selector, CLSID *clsid)
5499 {
5500     FIXME("(%d %d %p %p)\n", plugin_type, index, selector, clsid);
5501     return E_NOTIMPL;
5502 }
5503
5504 static HRESULT WINAPI MFPluginControl_SetPreferredClsid(IMFPluginControl *iface, DWORD plugin_type,
5505         const WCHAR *selector, const CLSID *clsid)
5506 {
5507     FIXME("(%d %s %s)\n", plugin_type, debugstr_w(selector), debugstr_guid(clsid));
5508     return E_NOTIMPL;
5509 }
5510
5511 static HRESULT WINAPI MFPluginControl_IsDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid)
5512 {
5513     FIXME("(%d %s)\n", plugin_type, debugstr_guid(clsid));
5514     return E_NOTIMPL;
5515 }
5516
5517 static HRESULT WINAPI MFPluginControl_GetDisabledByIndex(IMFPluginControl *iface, DWORD plugin_type, DWORD index, CLSID *clsid)
5518 {
5519     FIXME("(%d %d %p)\n", plugin_type, index, clsid);
5520     return E_NOTIMPL;
5521 }
5522
5523 static HRESULT WINAPI MFPluginControl_SetDisabled(IMFPluginControl *iface, DWORD plugin_type, REFCLSID clsid, BOOL disabled)
5524 {
5525     FIXME("(%d %s %x)\n", plugin_type, debugstr_guid(clsid), disabled);
5526     return E_NOTIMPL;
5527 }
5528
5529 static const IMFPluginControlVtbl MFPluginControlVtbl = {
5530     MFPluginControl_QueryInterface,
5531     MFPluginControl_AddRef,
5532     MFPluginControl_Release,
5533     MFPluginControl_GetPreferredClsid,
5534     MFPluginControl_GetPreferredClsidByIndex,
5535     MFPluginControl_SetPreferredClsid,
5536     MFPluginControl_IsDisabled,
5537     MFPluginControl_GetDisabledByIndex,
5538     MFPluginControl_SetDisabled
5539 };
5540
5541 static IMFPluginControl plugin_control = { &MFPluginControlVtbl };
5542
5543 /***********************************************************************
5544  *      MFGetPluginControl (mfplat.@)
5545  */
5546 HRESULT WINAPI MFGetPluginControl(IMFPluginControl **ret)
5547 {
5548     TRACE("(%p)\n", ret);
5549
5550     *ret = &plugin_control;
5551     return S_OK;
5552 }
5553
5554 typedef struct _mfsource
5555 {
5556     IMFMediaSource IMFMediaSource_iface;
5557     LONG ref;
5558 } mfsource;
5559
5560 static inline mfsource *impl_from_IMFMediaSource(IMFMediaSource *iface)
5561 {
5562     return CONTAINING_RECORD(iface, mfsource, IMFMediaSource_iface);
5563 }
5564
5565 static HRESULT WINAPI mfsource_QueryInterface(IMFMediaSource *iface, REFIID riid, void **out)
5566 {
5567     mfsource *This = impl_from_IMFMediaSource(iface);
5568
5569     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
5570
5571     if (IsEqualIID(riid, &IID_IMFMediaSource) ||
5572         IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
5573         IsEqualIID(riid, &IID_IUnknown))
5574     {
5575         *out = &This->IMFMediaSource_iface;
5576     }
5577     else
5578     {
5579         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
5580         *out = NULL;
5581         return E_NOINTERFACE;
5582     }
5583
5584     IUnknown_AddRef((IUnknown*)*out);
5585     return S_OK;
5586 }
5587
5588 static ULONG WINAPI mfsource_AddRef(IMFMediaSource *iface)
5589 {
5590     mfsource *This = impl_from_IMFMediaSource(iface);
5591     ULONG ref = InterlockedIncrement(&This->ref);
5592
5593     TRACE("(%p) ref=%u\n", This, ref);
5594
5595     return ref;
5596 }
5597
5598 static ULONG WINAPI mfsource_Release(IMFMediaSource *iface)
5599 {
5600     mfsource *This = impl_from_IMFMediaSource(iface);
5601     ULONG ref = InterlockedDecrement(&This->ref);
5602
5603     TRACE("(%p) ref=%u\n", This, ref);
5604
5605     if (!ref)
5606     {
5607         HeapFree(GetProcessHeap(), 0, This);
5608     }
5609
5610     return ref;
5611 }
5612
5613 static HRESULT WINAPI mfsource_GetEvent(IMFMediaSource *iface, DWORD flags, IMFMediaEvent **event)
5614 {
5615     mfsource *This = impl_from_IMFMediaSource(iface);
5616
5617     FIXME("(%p)->(%#x, %p)\n", This, flags, event);
5618
5619     return E_NOTIMPL;
5620 }
5621
5622 static HRESULT WINAPI mfsource_BeginGetEvent(IMFMediaSource *iface, IMFAsyncCallback *callback, IUnknown *state)
5623 {
5624     mfsource *This = impl_from_IMFMediaSource(iface);
5625
5626     FIXME("(%p)->(%p, %p)\n", This, callback, state);
5627
5628     return E_NOTIMPL;
5629 }
5630
5631 static HRESULT WINAPI mfsource_EndGetEvent(IMFMediaSource *iface, IMFAsyncResult *result, IMFMediaEvent **event)
5632 {
5633     mfsource *This = impl_from_IMFMediaSource(iface);
5634
5635     FIXME("(%p)->(%p, %p)\n", This, result, event);
5636
5637     return E_NOTIMPL;
5638 }
5639
5640 static HRESULT WINAPI mfsource_QueueEvent(IMFMediaSource *iface, MediaEventType event_type, REFGUID ext_type,
5641         HRESULT hr, const PROPVARIANT *value)
5642 {
5643     mfsource *This = impl_from_IMFMediaSource(iface);
5644
5645     FIXME("(%p)->(%d, %s, %#x, %p)\n", This, event_type, debugstr_guid(ext_type), hr, value);
5646
5647     return E_NOTIMPL;
5648 }
5649
5650 static HRESULT WINAPI mfsource_GetCharacteristics(IMFMediaSource *iface, DWORD *characteristics)
5651 {
5652     mfsource *This = impl_from_IMFMediaSource(iface);
5653
5654     FIXME("(%p)->(%p): stub\n", This, characteristics);
5655
5656     return E_NOTIMPL;
5657 }
5658
5659 static HRESULT WINAPI mfsource_CreatePresentationDescriptor(IMFMediaSource *iface, IMFPresentationDescriptor **descriptor)
5660 {
5661     mfsource *This = impl_from_IMFMediaSource(iface);
5662     IMFStreamDescriptor *sd;
5663     IMFMediaType *mediatype;
5664     HRESULT hr;
5665
5666     FIXME("(%p)->(%p): stub\n", This, descriptor);
5667
5668     if (FAILED(hr = MFCreateMediaType(&mediatype)))
5669         return hr;
5670
5671     hr = MFCreateStreamDescriptor(0, 1, &mediatype, &sd);
5672     IMFMediaType_Release(mediatype);
5673     if (FAILED(hr))
5674         return hr;
5675
5676     hr = MFCreatePresentationDescriptor(1, &sd, descriptor);
5677     IMFStreamDescriptor_Release(sd);
5678
5679     return hr;
5680 }
5681
5682 static HRESULT WINAPI mfsource_Start(IMFMediaSource *iface, IMFPresentationDescriptor *descriptor,
5683                                      const GUID *time_format, const PROPVARIANT *start_position)
5684 {
5685     mfsource *This = impl_from_IMFMediaSource(iface);
5686
5687     FIXME("(%p)->(%p, %p, %p): stub\n", This, descriptor, time_format, start_position);
5688
5689     return E_NOTIMPL;
5690 }
5691
5692 static HRESULT WINAPI mfsource_Stop(IMFMediaSource *iface)
5693 {
5694     mfsource *This = impl_from_IMFMediaSource(iface);
5695
5696     FIXME("(%p): stub\n", This);
5697
5698     return E_NOTIMPL;
5699 }
5700
5701 static HRESULT WINAPI mfsource_Pause(IMFMediaSource *iface)
5702 {
5703     mfsource *This = impl_from_IMFMediaSource(iface);
5704
5705     FIXME("(%p): stub\n", This);
5706
5707     return E_NOTIMPL;
5708 }
5709
5710 static HRESULT WINAPI mfsource_Shutdown(IMFMediaSource *iface)
5711 {
5712     mfsource *This = impl_from_IMFMediaSource(iface);
5713
5714     FIXME("(%p): stub\n", This);
5715
5716     return S_OK;
5717 }
5718
5719 static const IMFMediaSourceVtbl mfsourcevtbl =
5720 {
5721     mfsource_QueryInterface,
5722     mfsource_AddRef,
5723     mfsource_Release,
5724     mfsource_GetEvent,
5725     mfsource_BeginGetEvent,
5726     mfsource_EndGetEvent,
5727     mfsource_QueueEvent,
5728     mfsource_GetCharacteristics,
5729     mfsource_CreatePresentationDescriptor,
5730     mfsource_Start,
5731     mfsource_Stop,
5732     mfsource_Pause,
5733     mfsource_Shutdown,
5734 };
5735
5736 enum resolved_object_origin
5737 {
5738     OBJECT_FROM_BYTESTREAM,
5739     OBJECT_FROM_URL,
5740 };
5741
5742 struct resolver_queued_result
5743 {
5744     struct list entry;
5745     IUnknown *object;
5746     MF_OBJECT_TYPE obj_type;
5747     HRESULT hr;
5748     IRtwqAsyncResult *inner_result;
5749     enum resolved_object_origin origin;
5750 };
5751
5752 struct resolver_cancel_object
5753 {
5754     IUnknown IUnknown_iface;
5755     LONG refcount;
5756     union
5757     {
5758         IUnknown *handler;
5759         IMFByteStreamHandler *stream_handler;
5760         IMFSchemeHandler *scheme_handler;
5761     } u;
5762     IUnknown *cancel_cookie;
5763     enum resolved_object_origin origin;
5764 };
5765
5766 struct source_resolver
5767 {
5768     IMFSourceResolver IMFSourceResolver_iface;
5769     LONG refcount;
5770     IRtwqAsyncCallback stream_callback;
5771     IRtwqAsyncCallback url_callback;
5772     CRITICAL_SECTION cs;
5773     struct list pending;
5774 };
5775
5776 static struct source_resolver *impl_from_IMFSourceResolver(IMFSourceResolver *iface)
5777 {
5778     return CONTAINING_RECORD(iface, struct source_resolver, IMFSourceResolver_iface);
5779 }
5780
5781 static struct source_resolver *impl_from_stream_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
5782 {
5783     return CONTAINING_RECORD(iface, struct source_resolver, stream_callback);
5784 }
5785
5786 static struct source_resolver *impl_from_url_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
5787 {
5788     return CONTAINING_RECORD(iface, struct source_resolver, url_callback);
5789 }
5790
5791 static HRESULT resolver_handler_end_create(struct source_resolver *resolver, enum resolved_object_origin origin,
5792         IRtwqAsyncResult *result)
5793 {
5794     IRtwqAsyncResult *inner_result = (IRtwqAsyncResult *)IRtwqAsyncResult_GetStateNoAddRef(result);
5795     struct resolver_queued_result *queued_result;
5796     union
5797     {
5798         IUnknown *handler;
5799         IMFByteStreamHandler *stream_handler;
5800         IMFSchemeHandler *scheme_handler;
5801     } handler;
5802
5803     queued_result = heap_alloc_zero(sizeof(*queued_result));
5804
5805     IRtwqAsyncResult_GetObject(inner_result, &handler.handler);
5806
5807     switch (origin)
5808     {
5809         case OBJECT_FROM_BYTESTREAM:
5810             queued_result->hr = IMFByteStreamHandler_EndCreateObject(handler.stream_handler, (IMFAsyncResult *)result,
5811                     &queued_result->obj_type, &queued_result->object);
5812             break;
5813         case OBJECT_FROM_URL:
5814             queued_result->hr = IMFSchemeHandler_EndCreateObject(handler.scheme_handler, (IMFAsyncResult *)result,
5815                     &queued_result->obj_type, &queued_result->object);
5816             break;
5817         default:
5818             queued_result->hr = E_FAIL;
5819     }
5820
5821     IUnknown_Release(handler.handler);
5822
5823     if (SUCCEEDED(queued_result->hr))
5824     {
5825         RTWQASYNCRESULT *data = (RTWQASYNCRESULT *)inner_result;
5826
5827         if (data->hEvent)
5828         {
5829             queued_result->inner_result = inner_result;
5830             IRtwqAsyncResult_AddRef(queued_result->inner_result);
5831         }
5832
5833         /* Push resolved object type and created object, so we don't have to guess on End*() call. */
5834         EnterCriticalSection(&resolver->cs);
5835         list_add_tail(&resolver->pending, &queued_result->entry);
5836         LeaveCriticalSection(&resolver->cs);
5837
5838         if (data->hEvent)
5839             SetEvent(data->hEvent);
5840         else
5841         {
5842             IUnknown *caller_state = IRtwqAsyncResult_GetStateNoAddRef(inner_result);
5843             IRtwqAsyncResult *caller_result;
5844
5845             if (SUCCEEDED(RtwqCreateAsyncResult(queued_result->object, data->pCallback, caller_state, &caller_result)))
5846             {
5847                 RtwqInvokeCallback(caller_result);
5848                 IRtwqAsyncResult_Release(caller_result);
5849             }
5850         }
5851     }
5852     else
5853         heap_free(queued_result);
5854
5855     return S_OK;
5856 }
5857
5858 static struct resolver_cancel_object *impl_cancel_obj_from_IUnknown(IUnknown *iface)
5859 {
5860     return CONTAINING_RECORD(iface, struct resolver_cancel_object, IUnknown_iface);
5861 }
5862
5863 static HRESULT WINAPI resolver_cancel_object_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
5864 {
5865     if (IsEqualIID(riid, &IID_IUnknown))
5866     {
5867         *obj = iface;
5868         IUnknown_AddRef(iface);
5869         return S_OK;
5870     }
5871
5872     *obj = NULL;
5873     return E_NOINTERFACE;
5874 }
5875
5876 static ULONG WINAPI resolver_cancel_object_AddRef(IUnknown *iface)
5877 {
5878     struct resolver_cancel_object *object = impl_cancel_obj_from_IUnknown(iface);
5879     return InterlockedIncrement(&object->refcount);
5880 }
5881
5882 static ULONG WINAPI resolver_cancel_object_Release(IUnknown *iface)
5883 {
5884     struct resolver_cancel_object *object = impl_cancel_obj_from_IUnknown(iface);
5885     ULONG refcount = InterlockedDecrement(&object->refcount);
5886
5887     if (!refcount)
5888     {
5889         if (object->cancel_cookie)
5890             IUnknown_Release(object->cancel_cookie);
5891         IUnknown_Release(object->u.handler);
5892         heap_free(object);
5893     }
5894
5895     return refcount;
5896 }
5897
5898 static const IUnknownVtbl resolver_cancel_object_vtbl =
5899 {
5900     resolver_cancel_object_QueryInterface,
5901     resolver_cancel_object_AddRef,
5902     resolver_cancel_object_Release,
5903 };
5904
5905 static struct resolver_cancel_object *unsafe_impl_cancel_obj_from_IUnknown(IUnknown *iface)
5906 {
5907     if (!iface)
5908         return NULL;
5909
5910     return (iface->lpVtbl == &resolver_cancel_object_vtbl) ?
5911             CONTAINING_RECORD(iface, struct resolver_cancel_object, IUnknown_iface) : NULL;
5912 }
5913
5914 static HRESULT resolver_create_cancel_object(IUnknown *handler, enum resolved_object_origin origin,
5915         IUnknown *cancel_cookie, IUnknown **cancel_object)
5916 {
5917     struct resolver_cancel_object *object;
5918
5919     object = heap_alloc_zero(sizeof(*object));
5920     if (!object)
5921         return E_OUTOFMEMORY;
5922
5923     object->IUnknown_iface.lpVtbl = &resolver_cancel_object_vtbl;
5924     object->refcount = 1;
5925     object->u.handler = handler;
5926     IUnknown_AddRef(object->u.handler);
5927     object->cancel_cookie = cancel_cookie;
5928     IUnknown_AddRef(object->cancel_cookie);
5929     object->origin = origin;
5930
5931     *cancel_object = &object->IUnknown_iface;
5932
5933     return S_OK;
5934 }
5935
5936 static HRESULT WINAPI source_resolver_callback_QueryInterface(IRtwqAsyncCallback *iface, REFIID riid, void **obj)
5937 {
5938     if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
5939             IsEqualIID(riid, &IID_IUnknown))
5940     {
5941         *obj = iface;
5942         IRtwqAsyncCallback_AddRef(iface);
5943         return S_OK;
5944     }
5945
5946     *obj = NULL;
5947     return E_NOINTERFACE;
5948 }
5949
5950 static ULONG WINAPI source_resolver_callback_stream_AddRef(IRtwqAsyncCallback *iface)
5951 {
5952     struct source_resolver *resolver = impl_from_stream_IRtwqAsyncCallback(iface);
5953     return IMFSourceResolver_AddRef(&resolver->IMFSourceResolver_iface);
5954 }
5955
5956 static ULONG WINAPI source_resolver_callback_stream_Release(IRtwqAsyncCallback *iface)
5957 {
5958     struct source_resolver *resolver = impl_from_stream_IRtwqAsyncCallback(iface);
5959     return IMFSourceResolver_Release(&resolver->IMFSourceResolver_iface);
5960 }
5961
5962 static HRESULT WINAPI source_resolver_callback_GetParameters(IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue)
5963 {
5964     return E_NOTIMPL;
5965 }
5966
5967 static HRESULT WINAPI source_resolver_callback_stream_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
5968 {
5969     struct source_resolver *resolver = impl_from_stream_IRtwqAsyncCallback(iface);
5970
5971     return resolver_handler_end_create(resolver, OBJECT_FROM_BYTESTREAM, result);
5972 }
5973
5974 static const IRtwqAsyncCallbackVtbl source_resolver_callback_stream_vtbl =
5975 {
5976     source_resolver_callback_QueryInterface,
5977     source_resolver_callback_stream_AddRef,
5978     source_resolver_callback_stream_Release,
5979     source_resolver_callback_GetParameters,
5980     source_resolver_callback_stream_Invoke,
5981 };
5982
5983 static ULONG WINAPI source_resolver_callback_url_AddRef(IRtwqAsyncCallback *iface)
5984 {
5985     struct source_resolver *resolver = impl_from_url_IRtwqAsyncCallback(iface);
5986     return IMFSourceResolver_AddRef(&resolver->IMFSourceResolver_iface);
5987 }
5988
5989 static ULONG WINAPI source_resolver_callback_url_Release(IRtwqAsyncCallback *iface)
5990 {
5991     struct source_resolver *resolver = impl_from_url_IRtwqAsyncCallback(iface);
5992     return IMFSourceResolver_Release(&resolver->IMFSourceResolver_iface);
5993 }
5994
5995 static HRESULT WINAPI source_resolver_callback_url_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
5996 {
5997     struct source_resolver *resolver = impl_from_url_IRtwqAsyncCallback(iface);
5998
5999     return resolver_handler_end_create(resolver, OBJECT_FROM_URL, result);
6000 }
6001
6002 static const IRtwqAsyncCallbackVtbl source_resolver_callback_url_vtbl =
6003 {
6004     source_resolver_callback_QueryInterface,
6005     source_resolver_callback_url_AddRef,
6006     source_resolver_callback_url_Release,
6007     source_resolver_callback_GetParameters,
6008     source_resolver_callback_url_Invoke,
6009 };
6010
6011 static HRESULT resolver_create_registered_handler(HKEY hkey, REFIID riid, void **handler)
6012 {
6013     unsigned int j = 0, name_length, type;
6014     HRESULT hr = E_FAIL;
6015     WCHAR clsidW[39];
6016     CLSID clsid;
6017
6018     name_length = ARRAY_SIZE(clsidW);
6019     while (!RegEnumValueW(hkey, j++, clsidW, &name_length, NULL, &type, NULL, NULL))
6020     {
6021         if (type == REG_SZ)
6022         {
6023             if (SUCCEEDED(CLSIDFromString(clsidW, &clsid)))
6024             {
6025                 hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, riid, handler);
6026                 if (SUCCEEDED(hr))
6027                     break;
6028             }
6029         }
6030
6031         name_length = ARRAY_SIZE(clsidW);
6032     }
6033
6034     return hr;
6035 }
6036
6037 static HRESULT resolver_get_bytestream_handler(IMFByteStream *stream, const WCHAR *url, DWORD flags,
6038         IMFByteStreamHandler **handler)
6039 {
6040     static const char streamhandlerspath[] = "Software\\Microsoft\\Windows Media Foundation\\ByteStreamHandlers";
6041     static const HKEY hkey_roots[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
6042     IMFAttributes *attributes;
6043     const WCHAR *url_ext;
6044     WCHAR *mimeW = NULL;
6045     HRESULT hr = E_FAIL;
6046     unsigned int i, j;
6047     UINT32 length;
6048
6049     *handler = NULL;
6050
6051     /* MIME type */
6052     if (SUCCEEDED(IMFByteStream_QueryInterface(stream, &IID_IMFAttributes, (void **)&attributes)))
6053     {
6054         IMFAttributes_GetAllocatedString(attributes, &MF_BYTESTREAM_CONTENT_TYPE, &mimeW, &length);
6055         IMFAttributes_Release(attributes);
6056     }
6057
6058     /* Extension */
6059     url_ext = url ? wcsrchr(url, '.') : NULL;
6060
6061     if (!url_ext && !mimeW)
6062     {
6063         CoTaskMemFree(mimeW);
6064         return MF_E_UNSUPPORTED_BYTESTREAM_TYPE;
6065     }
6066
6067     if (!(flags & MF_RESOLUTION_DISABLE_LOCAL_PLUGINS))
6068     {
6069         struct local_handler *local_handler;
6070
6071         EnterCriticalSection(&local_handlers_section);
6072
6073         LIST_FOR_EACH_ENTRY(local_handler, &local_bytestream_handlers, struct local_handler, entry)
6074         {
6075             if ((mimeW && !lstrcmpiW(mimeW, local_handler->u.bytestream.mime))
6076                     || (url_ext && !lstrcmpiW(url_ext, local_handler->u.bytestream.extension)))
6077             {
6078                 if (SUCCEEDED(hr = IMFActivate_ActivateObject(local_handler->activate, &IID_IMFByteStreamHandler,
6079                         (void **)handler)))
6080                     break;
6081             }
6082         }
6083
6084         LeaveCriticalSection(&local_handlers_section);
6085
6086         if (*handler)
6087             return hr;
6088     }
6089
6090     for (i = 0, hr = E_FAIL; i < ARRAY_SIZE(hkey_roots); ++i)
6091     {
6092         const WCHAR *namesW[2] = { mimeW, url_ext };
6093         HKEY hkey, hkey_handler;
6094
6095         if (RegOpenKeyA(hkey_roots[i], streamhandlerspath, &hkey))
6096             continue;
6097
6098         for (j = 0; j < ARRAY_SIZE(namesW); ++j)
6099         {
6100             if (!namesW[j])
6101                 continue;
6102
6103             if (!RegOpenKeyW(hkey, namesW[j], &hkey_handler))
6104             {
6105                 hr = resolver_create_registered_handler(hkey_handler, &IID_IMFByteStreamHandler, (void **)handler);
6106                 RegCloseKey(hkey_handler);
6107             }
6108
6109             if (SUCCEEDED(hr))
6110                 break;
6111         }
6112
6113         RegCloseKey(hkey);
6114
6115         if (SUCCEEDED(hr))
6116             break;
6117     }
6118
6119     CoTaskMemFree(mimeW);
6120     return hr;
6121 }
6122
6123 static HRESULT resolver_create_scheme_handler(const WCHAR *scheme, DWORD flags, IMFSchemeHandler **handler)
6124 {
6125     static const char schemehandlerspath[] = "Software\\Microsoft\\Windows Media Foundation\\SchemeHandlers";
6126     static const HKEY hkey_roots[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
6127     HRESULT hr = MF_E_UNSUPPORTED_SCHEME;
6128     unsigned int i;
6129
6130     TRACE("%s, %#x, %p.\n", debugstr_w(scheme), flags, handler);
6131
6132     *handler = NULL;
6133
6134     if (!(flags & MF_RESOLUTION_DISABLE_LOCAL_PLUGINS))
6135     {
6136         struct local_handler *local_handler;
6137
6138         EnterCriticalSection(&local_handlers_section);
6139
6140         LIST_FOR_EACH_ENTRY(local_handler, &local_scheme_handlers, struct local_handler, entry)
6141         {
6142             if (!lstrcmpiW(scheme, local_handler->u.scheme))
6143             {
6144                 if (SUCCEEDED(hr = IMFActivate_ActivateObject(local_handler->activate, &IID_IMFSchemeHandler,
6145                         (void **)handler)))
6146                     break;
6147             }
6148         }
6149
6150         LeaveCriticalSection(&local_handlers_section);
6151
6152         if (*handler)
6153             return hr;
6154     }
6155
6156     for (i = 0; i < ARRAY_SIZE(hkey_roots); ++i)
6157     {
6158         HKEY hkey, hkey_handler;
6159
6160         hr = MF_E_UNSUPPORTED_SCHEME;
6161
6162         if (RegOpenKeyA(hkey_roots[i], schemehandlerspath, &hkey))
6163             continue;
6164
6165         if (!RegOpenKeyW(hkey, scheme, &hkey_handler))
6166         {
6167             hr = resolver_create_registered_handler(hkey_handler, &IID_IMFSchemeHandler, (void **)handler);
6168             RegCloseKey(hkey_handler);
6169         }
6170
6171         RegCloseKey(hkey);
6172
6173         if (SUCCEEDED(hr))
6174             break;
6175     }
6176
6177     return hr;
6178 }
6179
6180 static HRESULT resolver_get_scheme_handler(const WCHAR *url, DWORD flags, IMFSchemeHandler **handler)
6181 {
6182     static const WCHAR fileschemeW[] = {'f','i','l','e',':',0};
6183     const WCHAR *ptr = url;
6184     unsigned int len;
6185     WCHAR *scheme;
6186     HRESULT hr;
6187
6188     /* RFC 3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
6189     while (*ptr)
6190     {
6191         WCHAR ch = towlower(*ptr);
6192
6193         if (*ptr == '*' && ptr == url)
6194         {
6195              ptr++;
6196              break;
6197         }
6198         else if (!(*ptr >= '0' && *ptr <= '9') &&
6199                 !(ch >= 'a' && ch <= 'z') &&
6200                 *ptr != '+' && *ptr != '-' && *ptr != '.')
6201         {
6202             break;
6203         }
6204
6205         ptr++;
6206     }
6207
6208     /* Schemes must end with a ':', if not found try "file:" */
6209     if (ptr == url || *ptr != ':')
6210     {
6211         url = fileschemeW;
6212         ptr = fileschemeW + ARRAY_SIZE(fileschemeW) - 1;
6213     }
6214
6215     len = ptr - url;
6216     scheme = heap_alloc((len + 1) * sizeof(WCHAR));
6217     if (!scheme)
6218         return E_OUTOFMEMORY;
6219
6220     memcpy(scheme, url, len * sizeof(WCHAR));
6221     scheme[len] = 0;
6222
6223     hr = resolver_create_scheme_handler(scheme, flags, handler);
6224     if (FAILED(hr) && url != fileschemeW)
6225         hr = resolver_create_scheme_handler(fileschemeW, flags, handler);
6226
6227     heap_free(scheme);
6228
6229     return hr;
6230 }
6231
6232 static HRESULT resolver_end_create_object(struct source_resolver *resolver, enum resolved_object_origin origin,
6233         IRtwqAsyncResult *result, MF_OBJECT_TYPE *obj_type, IUnknown **out)
6234 {
6235     struct resolver_queued_result *queued_result = NULL, *iter;
6236     IUnknown *object;
6237     HRESULT hr;
6238
6239     if (FAILED(hr = IRtwqAsyncResult_GetObject(result, &object)))
6240         return hr;
6241
6242     EnterCriticalSection(&resolver->cs);
6243
6244     LIST_FOR_EACH_ENTRY(iter, &resolver->pending, struct resolver_queued_result, entry)
6245     {
6246         if (iter->inner_result == result || (iter->object == object && iter->origin == origin))
6247         {
6248             list_remove(&iter->entry);
6249             queued_result = iter;
6250             break;
6251         }
6252     }
6253
6254     LeaveCriticalSection(&resolver->cs);
6255
6256     IUnknown_Release(object);
6257
6258     if (queued_result)
6259     {
6260         *out = queued_result->object;
6261         *obj_type = queued_result->obj_type;
6262         hr = queued_result->hr;
6263         if (queued_result->inner_result)
6264             IRtwqAsyncResult_Release(queued_result->inner_result);
6265         heap_free(queued_result);
6266     }
6267     else
6268         hr = E_UNEXPECTED;
6269
6270     return hr;
6271 }
6272
6273 static HRESULT WINAPI source_resolver_QueryInterface(IMFSourceResolver *iface, REFIID riid, void **obj)
6274 {
6275     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6276
6277     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
6278
6279     if (IsEqualIID(riid, &IID_IMFSourceResolver) ||
6280             IsEqualIID(riid, &IID_IUnknown))
6281     {
6282         *obj = &resolver->IMFSourceResolver_iface;
6283     }
6284     else
6285     {
6286         *obj = NULL;
6287         FIXME("unsupported interface %s\n", debugstr_guid(riid));
6288         return E_NOINTERFACE;
6289     }
6290
6291     IUnknown_AddRef((IUnknown *)*obj);
6292     return S_OK;
6293 }
6294
6295 static ULONG WINAPI source_resolver_AddRef(IMFSourceResolver *iface)
6296 {
6297     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6298     ULONG refcount = InterlockedIncrement(&resolver->refcount);
6299
6300     TRACE("%p, refcount %d.\n", iface, refcount);
6301
6302     return refcount;
6303 }
6304
6305 static ULONG WINAPI source_resolver_Release(IMFSourceResolver *iface)
6306 {
6307     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6308     ULONG refcount = InterlockedDecrement(&resolver->refcount);
6309     struct resolver_queued_result *result, *result2;
6310
6311     TRACE("%p, refcount %d.\n", iface, refcount);
6312
6313     if (!refcount)
6314     {
6315         LIST_FOR_EACH_ENTRY_SAFE(result, result2, &resolver->pending, struct resolver_queued_result, entry)
6316         {
6317             if (result->object)
6318                 IUnknown_Release(result->object);
6319             list_remove(&result->entry);
6320             heap_free(result);
6321         }
6322         DeleteCriticalSection(&resolver->cs);
6323         heap_free(resolver);
6324     }
6325
6326     return refcount;
6327 }
6328
6329 static HRESULT WINAPI source_resolver_CreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
6330         DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
6331 {
6332     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6333     IMFSchemeHandler *handler;
6334     IRtwqAsyncResult *result;
6335     RTWQASYNCRESULT *data;
6336     HRESULT hr;
6337
6338     TRACE("%p, %s, %#x, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, obj_type, object);
6339
6340     if (!url || !obj_type || !object)
6341         return E_POINTER;
6342
6343     if (FAILED(hr = resolver_get_scheme_handler(url, flags, &handler)))
6344         return hr;
6345
6346     hr = RtwqCreateAsyncResult((IUnknown *)handler, NULL, NULL, &result);
6347     IMFSchemeHandler_Release(handler);
6348     if (FAILED(hr))
6349         return hr;
6350
6351     data = (RTWQASYNCRESULT *)result;
6352     data->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
6353
6354     hr = IMFSchemeHandler_BeginCreateObject(handler, url, flags, props, NULL, (IMFAsyncCallback *)&resolver->url_callback,
6355             (IUnknown *)result);
6356     if (FAILED(hr))
6357     {
6358         IRtwqAsyncResult_Release(result);
6359         return hr;
6360     }
6361
6362     WaitForSingleObject(data->hEvent, INFINITE);
6363
6364     hr = resolver_end_create_object(resolver, OBJECT_FROM_URL, result, obj_type, object);
6365     IRtwqAsyncResult_Release(result);
6366
6367     return hr;
6368 }
6369
6370 static HRESULT WINAPI source_resolver_CreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
6371     const WCHAR *url, DWORD flags, IPropertyStore *props, MF_OBJECT_TYPE *obj_type, IUnknown **object)
6372 {
6373     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6374     IMFByteStreamHandler *handler;
6375     IRtwqAsyncResult *result;
6376     RTWQASYNCRESULT *data;
6377     HRESULT hr;
6378
6379     TRACE("%p, %p, %s, %#x, %p, %p, %p.\n", iface, stream, debugstr_w(url), flags, props, obj_type, object);
6380
6381     if (!stream || !obj_type || !object)
6382         return E_POINTER;
6383
6384     if (FAILED(hr = resolver_get_bytestream_handler(stream, url, flags, &handler)))
6385         goto fallback;
6386
6387     hr = RtwqCreateAsyncResult((IUnknown *)handler, NULL, NULL, &result);
6388     IMFByteStreamHandler_Release(handler);
6389     if (FAILED(hr))
6390         return hr;
6391
6392     data = (RTWQASYNCRESULT *)result;
6393     data->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
6394
6395     hr = IMFByteStreamHandler_BeginCreateObject(handler, stream, url, flags, props, NULL,
6396             (IMFAsyncCallback *)&resolver->stream_callback, (IUnknown *)result);
6397     if (FAILED(hr))
6398     {
6399         IRtwqAsyncResult_Release(result);
6400         return hr;
6401     }
6402
6403     WaitForSingleObject(data->hEvent, INFINITE);
6404
6405     hr = resolver_end_create_object(resolver, OBJECT_FROM_BYTESTREAM, result, obj_type, object);
6406     IRtwqAsyncResult_Release(result);
6407
6408     /* TODO: following stub is left intentionally until real source plugins are implemented.  */
6409     if (SUCCEEDED(hr))
6410         return hr;
6411
6412 fallback:
6413     if (flags & MF_RESOLUTION_MEDIASOURCE)
6414     {
6415         mfsource *new_object;
6416
6417         new_object = HeapAlloc( GetProcessHeap(), 0, sizeof(*new_object) );
6418         if (!new_object)
6419             return E_OUTOFMEMORY;
6420
6421         new_object->IMFMediaSource_iface.lpVtbl = &mfsourcevtbl;
6422         new_object->ref = 1;
6423
6424         *object = (IUnknown *)&new_object->IMFMediaSource_iface;
6425         *obj_type = MF_OBJECT_MEDIASOURCE;
6426         return S_OK;
6427     }
6428
6429     return E_NOTIMPL;
6430 }
6431
6432 static HRESULT WINAPI source_resolver_BeginCreateObjectFromURL(IMFSourceResolver *iface, const WCHAR *url,
6433         DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *state)
6434 {
6435     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6436     IMFSchemeHandler *handler;
6437     IUnknown *inner_cookie = NULL;
6438     IRtwqAsyncResult *result;
6439     HRESULT hr;
6440
6441     TRACE("%p, %s, %#x, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state);
6442
6443     if (FAILED(hr = resolver_get_scheme_handler(url, flags, &handler)))
6444         return hr;
6445
6446     if (cancel_cookie)
6447         *cancel_cookie = NULL;
6448
6449     hr = RtwqCreateAsyncResult((IUnknown *)handler, (IRtwqAsyncCallback *)callback, state, &result);
6450     IMFSchemeHandler_Release(handler);
6451     if (FAILED(hr))
6452         return hr;
6453
6454     hr = IMFSchemeHandler_BeginCreateObject(handler, url, flags, props, cancel_cookie ? &inner_cookie : NULL,
6455             (IMFAsyncCallback *)&resolver->url_callback, (IUnknown *)result);
6456
6457     if (SUCCEEDED(hr) && inner_cookie)
6458         resolver_create_cancel_object((IUnknown *)handler, OBJECT_FROM_URL, inner_cookie, cancel_cookie);
6459
6460     IRtwqAsyncResult_Release(result);
6461
6462     return hr;
6463 }
6464
6465 static HRESULT WINAPI source_resolver_EndCreateObjectFromURL(IMFSourceResolver *iface, IMFAsyncResult *result,
6466         MF_OBJECT_TYPE *obj_type, IUnknown **object)
6467 {
6468     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6469
6470     TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
6471
6472     return resolver_end_create_object(resolver, OBJECT_FROM_URL, (IRtwqAsyncResult *)result, obj_type, object);
6473 }
6474
6475 static HRESULT WINAPI source_resolver_BeginCreateObjectFromByteStream(IMFSourceResolver *iface, IMFByteStream *stream,
6476         const WCHAR *url, DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback,
6477         IUnknown *state)
6478 {
6479     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6480     IMFByteStreamHandler *handler;
6481     IUnknown *inner_cookie = NULL;
6482     IRtwqAsyncResult *result;
6483     HRESULT hr;
6484
6485     TRACE("%p, %p, %s, %#x, %p, %p, %p, %p.\n", iface, stream, debugstr_w(url), flags, props, cancel_cookie,
6486             callback, state);
6487
6488     if (FAILED(hr = resolver_get_bytestream_handler(stream, url, flags, &handler)))
6489         return hr;
6490
6491     if (cancel_cookie)
6492         *cancel_cookie = NULL;
6493
6494     hr = RtwqCreateAsyncResult((IUnknown *)handler, (IRtwqAsyncCallback *)callback, state, &result);
6495     IMFByteStreamHandler_Release(handler);
6496     if (FAILED(hr))
6497         return hr;
6498
6499     hr = IMFByteStreamHandler_BeginCreateObject(handler, stream, url, flags, props,
6500             cancel_cookie ? &inner_cookie : NULL, (IMFAsyncCallback *)&resolver->stream_callback, (IUnknown *)result);
6501
6502     /* Cancel object wraps underlying handler cancel cookie with context necessary to call CancelObjectCreate(). */
6503     if (SUCCEEDED(hr) && inner_cookie)
6504         resolver_create_cancel_object((IUnknown *)handler, OBJECT_FROM_BYTESTREAM, inner_cookie, cancel_cookie);
6505
6506     IRtwqAsyncResult_Release(result);
6507
6508     return hr;
6509 }
6510
6511 static HRESULT WINAPI source_resolver_EndCreateObjectFromByteStream(IMFSourceResolver *iface, IMFAsyncResult *result,
6512         MF_OBJECT_TYPE *obj_type, IUnknown **object)
6513 {
6514     struct source_resolver *resolver = impl_from_IMFSourceResolver(iface);
6515
6516     TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
6517
6518     return resolver_end_create_object(resolver, OBJECT_FROM_BYTESTREAM, (IRtwqAsyncResult *)result, obj_type, object);
6519 }
6520
6521 static HRESULT WINAPI source_resolver_CancelObjectCreation(IMFSourceResolver *iface, IUnknown *cancel_cookie)
6522 {
6523     struct resolver_cancel_object *object;
6524     HRESULT hr;
6525
6526     TRACE("%p, %p.\n", iface, cancel_cookie);
6527
6528     if (!(object = unsafe_impl_cancel_obj_from_IUnknown(cancel_cookie)))
6529         return E_UNEXPECTED;
6530
6531     switch (object->origin)
6532     {
6533         case OBJECT_FROM_BYTESTREAM:
6534             hr = IMFByteStreamHandler_CancelObjectCreation(object->u.stream_handler, object->cancel_cookie);
6535             break;
6536         case OBJECT_FROM_URL:
6537             hr = IMFSchemeHandler_CancelObjectCreation(object->u.scheme_handler, object->cancel_cookie);
6538             break;
6539         default:
6540             hr = E_UNEXPECTED;
6541     }
6542
6543     return hr;
6544 }
6545
6546 static const IMFSourceResolverVtbl mfsourceresolvervtbl =
6547 {
6548     source_resolver_QueryInterface,
6549     source_resolver_AddRef,
6550     source_resolver_Release,
6551     source_resolver_CreateObjectFromURL,
6552     source_resolver_CreateObjectFromByteStream,
6553     source_resolver_BeginCreateObjectFromURL,
6554     source_resolver_EndCreateObjectFromURL,
6555     source_resolver_BeginCreateObjectFromByteStream,
6556     source_resolver_EndCreateObjectFromByteStream,
6557     source_resolver_CancelObjectCreation,
6558 };
6559
6560 /***********************************************************************
6561  *      MFCreateSourceResolver (mfplat.@)
6562  */
6563 HRESULT WINAPI MFCreateSourceResolver(IMFSourceResolver **resolver)
6564 {
6565     struct source_resolver *object;
6566
6567     TRACE("%p\n", resolver);
6568
6569     if (!resolver)
6570         return E_POINTER;
6571
6572     object = heap_alloc_zero(sizeof(*object));
6573     if (!object)
6574         return E_OUTOFMEMORY;
6575
6576     object->IMFSourceResolver_iface.lpVtbl = &mfsourceresolvervtbl;
6577     object->stream_callback.lpVtbl = &source_resolver_callback_stream_vtbl;
6578     object->url_callback.lpVtbl = &source_resolver_callback_url_vtbl;
6579     object->refcount = 1;
6580     list_init(&object->pending);
6581     InitializeCriticalSection(&object->cs);
6582
6583     *resolver = &object->IMFSourceResolver_iface;
6584
6585     return S_OK;
6586 }
6587
6588 struct media_event
6589 {
6590     struct attributes attributes;
6591     IMFMediaEvent IMFMediaEvent_iface;
6592
6593     MediaEventType type;
6594     GUID extended_type;
6595     HRESULT status;
6596     PROPVARIANT value;
6597 };
6598
6599 static inline struct media_event *impl_from_IMFMediaEvent(IMFMediaEvent *iface)
6600 {
6601     return CONTAINING_RECORD(iface, struct media_event, IMFMediaEvent_iface);
6602 }
6603
6604 static HRESULT WINAPI mfmediaevent_QueryInterface(IMFMediaEvent *iface, REFIID riid, void **out)
6605 {
6606     struct media_event *event = impl_from_IMFMediaEvent(iface);
6607
6608     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
6609
6610     if(IsEqualGUID(riid, &IID_IUnknown) ||
6611        IsEqualGUID(riid, &IID_IMFAttributes) ||
6612        IsEqualGUID(riid, &IID_IMFMediaEvent))
6613     {
6614         *out = &event->IMFMediaEvent_iface;
6615     }
6616     else
6617     {
6618         FIXME("%s, %p.\n", debugstr_guid(riid), out);
6619         *out = NULL;
6620         return E_NOINTERFACE;
6621     }
6622
6623     IUnknown_AddRef((IUnknown*)*out);
6624     return S_OK;
6625 }
6626
6627 static ULONG WINAPI mfmediaevent_AddRef(IMFMediaEvent *iface)
6628 {
6629     struct media_event *event = impl_from_IMFMediaEvent(iface);
6630     ULONG refcount = InterlockedIncrement(&event->attributes.ref);
6631
6632     TRACE("%p, refcount %u.\n", iface, refcount);
6633
6634     return refcount;
6635 }
6636
6637 static ULONG WINAPI mfmediaevent_Release(IMFMediaEvent *iface)
6638 {
6639     struct media_event *event = impl_from_IMFMediaEvent(iface);
6640     ULONG refcount = InterlockedDecrement(&event->attributes.ref);
6641
6642     TRACE("%p, refcount %u.\n", iface, refcount);
6643
6644     if (!refcount)
6645     {
6646         clear_attributes_object(&event->attributes);
6647         PropVariantClear(&event->value);
6648         heap_free(event);
6649     }
6650
6651     return refcount;
6652 }
6653
6654 static HRESULT WINAPI mfmediaevent_GetItem(IMFMediaEvent *iface, REFGUID key, PROPVARIANT *value)
6655 {
6656     struct media_event *event = impl_from_IMFMediaEvent(iface);
6657
6658     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6659
6660     return attributes_GetItem(&event->attributes, key, value);
6661 }
6662
6663 static HRESULT WINAPI mfmediaevent_GetItemType(IMFMediaEvent *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
6664 {
6665     struct media_event *event = impl_from_IMFMediaEvent(iface);
6666
6667     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), type);
6668
6669     return attributes_GetItemType(&event->attributes, key, type);
6670 }
6671
6672 static HRESULT WINAPI mfmediaevent_CompareItem(IMFMediaEvent *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
6673 {
6674     struct media_event *event = impl_from_IMFMediaEvent(iface);
6675
6676     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_propvar(value), result);
6677
6678     return attributes_CompareItem(&event->attributes, key, value, result);
6679 }
6680
6681 static HRESULT WINAPI mfmediaevent_Compare(IMFMediaEvent *iface, IMFAttributes *attrs, MF_ATTRIBUTES_MATCH_TYPE type,
6682         BOOL *result)
6683 {
6684     struct media_event *event = impl_from_IMFMediaEvent(iface);
6685
6686     TRACE("%p, %p, %d, %p.\n", iface, attrs, type, result);
6687
6688     return attributes_Compare(&event->attributes, attrs, type, result);
6689 }
6690
6691 static HRESULT WINAPI mfmediaevent_GetUINT32(IMFMediaEvent *iface, REFGUID key, UINT32 *value)
6692 {
6693     struct media_event *event = impl_from_IMFMediaEvent(iface);
6694
6695     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6696
6697     return attributes_GetUINT32(&event->attributes, key, value);
6698 }
6699
6700 static HRESULT WINAPI mfmediaevent_GetUINT64(IMFMediaEvent *iface, REFGUID key, UINT64 *value)
6701 {
6702     struct media_event *event = impl_from_IMFMediaEvent(iface);
6703
6704     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6705
6706     return attributes_GetUINT64(&event->attributes, key, value);
6707 }
6708
6709 static HRESULT WINAPI mfmediaevent_GetDouble(IMFMediaEvent *iface, REFGUID key, double *value)
6710 {
6711     struct media_event *event = impl_from_IMFMediaEvent(iface);
6712
6713     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6714
6715     return attributes_GetDouble(&event->attributes, key, value);
6716 }
6717
6718 static HRESULT WINAPI mfmediaevent_GetGUID(IMFMediaEvent *iface, REFGUID key, GUID *value)
6719 {
6720     struct media_event *event = impl_from_IMFMediaEvent(iface);
6721
6722     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), value);
6723
6724     return attributes_GetGUID(&event->attributes, key, value);
6725 }
6726
6727 static HRESULT WINAPI mfmediaevent_GetStringLength(IMFMediaEvent *iface, REFGUID key, UINT32 *length)
6728 {
6729     struct media_event *event = impl_from_IMFMediaEvent(iface);
6730
6731     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), length);
6732
6733     return attributes_GetStringLength(&event->attributes, key, length);
6734 }
6735
6736 static HRESULT WINAPI mfmediaevent_GetString(IMFMediaEvent *iface, REFGUID key, WCHAR *value,
6737         UINT32 size, UINT32 *length)
6738 {
6739     struct media_event *event = impl_from_IMFMediaEvent(iface);
6740
6741     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), value, size, length);
6742
6743     return attributes_GetString(&event->attributes, key, value, size, length);
6744 }
6745
6746 static HRESULT WINAPI mfmediaevent_GetAllocatedString(IMFMediaEvent *iface, REFGUID key,
6747         WCHAR **value, UINT32 *length)
6748 {
6749     struct media_event *event = impl_from_IMFMediaEvent(iface);
6750
6751     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), value, length);
6752
6753     return attributes_GetAllocatedString(&event->attributes, key, value, length);
6754 }
6755
6756 static HRESULT WINAPI mfmediaevent_GetBlobSize(IMFMediaEvent *iface, REFGUID key, UINT32 *size)
6757 {
6758     struct media_event *event = impl_from_IMFMediaEvent(iface);
6759
6760     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), size);
6761
6762     return attributes_GetBlobSize(&event->attributes, key, size);
6763 }
6764
6765 static HRESULT WINAPI mfmediaevent_GetBlob(IMFMediaEvent *iface, REFGUID key, UINT8 *buf,
6766         UINT32 bufsize, UINT32 *blobsize)
6767 {
6768     struct media_event *event = impl_from_IMFMediaEvent(iface);
6769
6770     TRACE("%p, %s, %p, %u, %p.\n", iface, debugstr_attr(key), buf, bufsize, blobsize);
6771
6772     return attributes_GetBlob(&event->attributes, key, buf, bufsize, blobsize);
6773 }
6774
6775 static HRESULT WINAPI mfmediaevent_GetAllocatedBlob(IMFMediaEvent *iface, REFGUID key, UINT8 **buf, UINT32 *size)
6776 {
6777     struct media_event *event = impl_from_IMFMediaEvent(iface);
6778
6779     TRACE("%p, %s, %p, %p.\n", iface, debugstr_attr(key), buf, size);
6780
6781     return attributes_GetAllocatedBlob(&event->attributes, key, buf, size);
6782 }
6783
6784 static HRESULT WINAPI mfmediaevent_GetUnknown(IMFMediaEvent *iface, REFGUID key, REFIID riid, void **out)
6785 {
6786     struct media_event *event = impl_from_IMFMediaEvent(iface);
6787
6788     TRACE("%p, %s, %s, %p.\n", iface, debugstr_attr(key), debugstr_guid(riid), out);
6789
6790     return attributes_GetUnknown(&event->attributes, key, riid, out);
6791 }
6792
6793 static HRESULT WINAPI mfmediaevent_SetItem(IMFMediaEvent *iface, REFGUID key, REFPROPVARIANT value)
6794 {
6795     struct media_event *event = impl_from_IMFMediaEvent(iface);
6796
6797     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_propvar(value));
6798
6799     return attributes_SetItem(&event->attributes, key, value);
6800 }
6801
6802 static HRESULT WINAPI mfmediaevent_DeleteItem(IMFMediaEvent *iface, REFGUID key)
6803 {
6804     struct media_event *event = impl_from_IMFMediaEvent(iface);
6805
6806     TRACE("%p, %s.\n", iface, debugstr_attr(key));
6807
6808     return attributes_DeleteItem(&event->attributes, key);
6809 }
6810
6811 static HRESULT WINAPI mfmediaevent_DeleteAllItems(IMFMediaEvent *iface)
6812 {
6813     struct media_event *event = impl_from_IMFMediaEvent(iface);
6814
6815     TRACE("%p.\n", iface);
6816
6817     return attributes_DeleteAllItems(&event->attributes);
6818 }
6819
6820 static HRESULT WINAPI mfmediaevent_SetUINT32(IMFMediaEvent *iface, REFGUID key, UINT32 value)
6821 {
6822     struct media_event *event = impl_from_IMFMediaEvent(iface);
6823
6824     TRACE("%p, %s, %u.\n", iface, debugstr_attr(key), value);
6825
6826     return attributes_SetUINT32(&event->attributes, key, value);
6827 }
6828
6829 static HRESULT WINAPI mfmediaevent_SetUINT64(IMFMediaEvent *iface, REFGUID key, UINT64 value)
6830 {
6831     struct media_event *event = impl_from_IMFMediaEvent(iface);
6832
6833     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), wine_dbgstr_longlong(value));
6834
6835     return attributes_SetUINT64(&event->attributes, key, value);
6836 }
6837
6838 static HRESULT WINAPI mfmediaevent_SetDouble(IMFMediaEvent *iface, REFGUID key, double value)
6839 {
6840     struct media_event *event = impl_from_IMFMediaEvent(iface);
6841
6842     TRACE("%p, %s, %f.\n", iface, debugstr_attr(key), value);
6843
6844     return attributes_SetDouble(&event->attributes, key, value);
6845 }
6846
6847 static HRESULT WINAPI mfmediaevent_SetGUID(IMFMediaEvent *iface, REFGUID key, REFGUID value)
6848 {
6849     struct media_event *event = impl_from_IMFMediaEvent(iface);
6850
6851     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_mf_guid(value));
6852
6853     return attributes_SetGUID(&event->attributes, key, value);
6854 }
6855
6856 static HRESULT WINAPI mfmediaevent_SetString(IMFMediaEvent *iface, REFGUID key, const WCHAR *value)
6857 {
6858     struct media_event *event = impl_from_IMFMediaEvent(iface);
6859
6860     TRACE("%p, %s, %s.\n", iface, debugstr_attr(key), debugstr_w(value));
6861
6862     return attributes_SetString(&event->attributes, key, value);
6863 }
6864
6865 static HRESULT WINAPI mfmediaevent_SetBlob(IMFMediaEvent *iface, REFGUID key, const UINT8 *buf, UINT32 size)
6866 {
6867     struct media_event *event = impl_from_IMFMediaEvent(iface);
6868
6869     TRACE("%p, %s, %p, %u.\n", iface, debugstr_attr(key), buf, size);
6870
6871     return attributes_SetBlob(&event->attributes, key, buf, size);
6872 }
6873
6874 static HRESULT WINAPI mfmediaevent_SetUnknown(IMFMediaEvent *iface, REFGUID key, IUnknown *unknown)
6875 {
6876     struct media_event *event = impl_from_IMFMediaEvent(iface);
6877
6878     TRACE("%p, %s, %p.\n", iface, debugstr_attr(key), unknown);
6879
6880     return attributes_SetUnknown(&event->attributes, key, unknown);
6881 }
6882
6883 static HRESULT WINAPI mfmediaevent_LockStore(IMFMediaEvent *iface)
6884 {
6885     struct media_event *event = impl_from_IMFMediaEvent(iface);
6886
6887     TRACE("%p.\n", iface);
6888
6889     return attributes_LockStore(&event->attributes);
6890 }
6891
6892 static HRESULT WINAPI mfmediaevent_UnlockStore(IMFMediaEvent *iface)
6893 {
6894     struct media_event *event = impl_from_IMFMediaEvent(iface);
6895
6896     TRACE("%p.\n", iface);
6897
6898     return attributes_UnlockStore(&event->attributes);
6899 }
6900
6901 static HRESULT WINAPI mfmediaevent_GetCount(IMFMediaEvent *iface, UINT32 *count)
6902 {
6903     struct media_event *event = impl_from_IMFMediaEvent(iface);
6904
6905     TRACE("%p, %p.\n", iface, count);
6906
6907     return attributes_GetCount(&event->attributes, count);
6908 }
6909
6910 static HRESULT WINAPI mfmediaevent_GetItemByIndex(IMFMediaEvent *iface, UINT32 index, GUID *key, PROPVARIANT *value)
6911 {
6912     struct media_event *event = impl_from_IMFMediaEvent(iface);
6913
6914     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
6915
6916     return attributes_GetItemByIndex(&event->attributes, index, key, value);
6917 }
6918
6919 static HRESULT WINAPI mfmediaevent_CopyAllItems(IMFMediaEvent *iface, IMFAttributes *dest)
6920 {
6921     struct media_event *event = impl_from_IMFMediaEvent(iface);
6922
6923     TRACE("%p, %p.\n", iface, dest);
6924
6925     return attributes_CopyAllItems(&event->attributes, dest);
6926 }
6927
6928 static HRESULT WINAPI mfmediaevent_GetType(IMFMediaEvent *iface, MediaEventType *type)
6929 {
6930     struct media_event *event = impl_from_IMFMediaEvent(iface);
6931
6932     TRACE("%p, %p.\n", iface, type);
6933
6934     *type = event->type;
6935
6936     return S_OK;
6937 }
6938
6939 static HRESULT WINAPI mfmediaevent_GetExtendedType(IMFMediaEvent *iface, GUID *extended_type)
6940 {
6941     struct media_event *event = impl_from_IMFMediaEvent(iface);
6942
6943     TRACE("%p, %p.\n", iface, extended_type);
6944
6945     *extended_type = event->extended_type;
6946
6947     return S_OK;
6948 }
6949
6950 static HRESULT WINAPI mfmediaevent_GetStatus(IMFMediaEvent *iface, HRESULT *status)
6951 {
6952     struct media_event *event = impl_from_IMFMediaEvent(iface);
6953
6954     TRACE("%p, %p.\n", iface, status);
6955
6956     *status = event->status;
6957
6958     return S_OK;
6959 }
6960
6961 static HRESULT WINAPI mfmediaevent_GetValue(IMFMediaEvent *iface, PROPVARIANT *value)
6962 {
6963     struct media_event *event = impl_from_IMFMediaEvent(iface);
6964
6965     TRACE("%p, %p.\n", iface, value);
6966
6967     PropVariantCopy(value, &event->value);
6968
6969     return S_OK;
6970 }
6971
6972 static const IMFMediaEventVtbl mfmediaevent_vtbl =
6973 {
6974     mfmediaevent_QueryInterface,
6975     mfmediaevent_AddRef,
6976     mfmediaevent_Release,
6977     mfmediaevent_GetItem,
6978     mfmediaevent_GetItemType,
6979     mfmediaevent_CompareItem,
6980     mfmediaevent_Compare,
6981     mfmediaevent_GetUINT32,
6982     mfmediaevent_GetUINT64,
6983     mfmediaevent_GetDouble,
6984     mfmediaevent_GetGUID,
6985     mfmediaevent_GetStringLength,
6986     mfmediaevent_GetString,
6987     mfmediaevent_GetAllocatedString,
6988     mfmediaevent_GetBlobSize,
6989     mfmediaevent_GetBlob,
6990     mfmediaevent_GetAllocatedBlob,
6991     mfmediaevent_GetUnknown,
6992     mfmediaevent_SetItem,
6993     mfmediaevent_DeleteItem,
6994     mfmediaevent_DeleteAllItems,
6995     mfmediaevent_SetUINT32,
6996     mfmediaevent_SetUINT64,
6997     mfmediaevent_SetDouble,
6998     mfmediaevent_SetGUID,
6999     mfmediaevent_SetString,
7000     mfmediaevent_SetBlob,
7001     mfmediaevent_SetUnknown,
7002     mfmediaevent_LockStore,
7003     mfmediaevent_UnlockStore,
7004     mfmediaevent_GetCount,
7005     mfmediaevent_GetItemByIndex,
7006     mfmediaevent_CopyAllItems,
7007     mfmediaevent_GetType,
7008     mfmediaevent_GetExtendedType,
7009     mfmediaevent_GetStatus,
7010     mfmediaevent_GetValue,
7011 };
7012
7013 /***********************************************************************
7014  *      MFCreateMediaEvent (mfplat.@)
7015  */
7016 HRESULT WINAPI MFCreateMediaEvent(MediaEventType type, REFGUID extended_type, HRESULT status, const PROPVARIANT *value,
7017         IMFMediaEvent **event)
7018 {
7019     struct media_event *object;
7020     HRESULT hr;
7021
7022     TRACE("%s, %s, %#x, %s, %p.\n", debugstr_eventid(type), debugstr_guid(extended_type), status,
7023             debugstr_propvar(value), event);
7024
7025     object = heap_alloc(sizeof(*object));
7026     if (!object)
7027         return E_OUTOFMEMORY;
7028
7029     if (FAILED(hr = init_attributes_object(&object->attributes, 0)))
7030     {
7031         heap_free(object);
7032         return hr;
7033     }
7034     object->IMFMediaEvent_iface.lpVtbl = &mfmediaevent_vtbl;
7035
7036     object->type = type;
7037     object->extended_type = *extended_type;
7038     object->status = status;
7039
7040     PropVariantInit(&object->value);
7041     if (value)
7042         PropVariantCopy(&object->value, value);
7043
7044     *event = &object->IMFMediaEvent_iface;
7045
7046     TRACE("Created event %p.\n", *event);
7047
7048     return S_OK;
7049 }
7050
7051 struct event_queue
7052 {
7053     IMFMediaEventQueue IMFMediaEventQueue_iface;
7054     LONG refcount;
7055
7056     CRITICAL_SECTION cs;
7057     CONDITION_VARIABLE update_event;
7058     struct list events;
7059     BOOL is_shut_down;
7060     BOOL notified;
7061     IRtwqAsyncResult *subscriber;
7062 };
7063
7064 struct queued_event
7065 {
7066     struct list entry;
7067     IMFMediaEvent *event;
7068 };
7069
7070 static inline struct event_queue *impl_from_IMFMediaEventQueue(IMFMediaEventQueue *iface)
7071 {
7072     return CONTAINING_RECORD(iface, struct event_queue, IMFMediaEventQueue_iface);
7073 }
7074
7075 static IMFMediaEvent *queue_pop_event(struct event_queue *queue)
7076 {
7077     struct list *head = list_head(&queue->events);
7078     struct queued_event *queued_event;
7079     IMFMediaEvent *event;
7080
7081     if (!head)
7082         return NULL;
7083
7084     queued_event = LIST_ENTRY(head, struct queued_event, entry);
7085     event = queued_event->event;
7086     list_remove(&queued_event->entry);
7087     heap_free(queued_event);
7088     return event;
7089 }
7090
7091 static void event_queue_cleanup(struct event_queue *queue)
7092 {
7093     IMFMediaEvent *event;
7094
7095     while ((event = queue_pop_event(queue)))
7096         IMFMediaEvent_Release(event);
7097 }
7098
7099 static HRESULT WINAPI eventqueue_QueryInterface(IMFMediaEventQueue *iface, REFIID riid, void **out)
7100 {
7101     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7102
7103     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
7104
7105     if (IsEqualIID(riid, &IID_IMFMediaEventQueue) ||
7106             IsEqualIID(riid, &IID_IUnknown))
7107     {
7108         *out = &queue->IMFMediaEventQueue_iface;
7109         IMFMediaEventQueue_AddRef(iface);
7110         return S_OK;
7111     }
7112
7113     WARN("Unsupported %s.\n", debugstr_guid(riid));
7114     *out = NULL;
7115     return E_NOINTERFACE;
7116 }
7117
7118 static ULONG WINAPI eventqueue_AddRef(IMFMediaEventQueue *iface)
7119 {
7120     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7121     ULONG refcount = InterlockedIncrement(&queue->refcount);
7122
7123     TRACE("%p, refcount %u.\n", iface, refcount);
7124
7125     return refcount;
7126 }
7127
7128 static ULONG WINAPI eventqueue_Release(IMFMediaEventQueue *iface)
7129 {
7130     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7131     ULONG refcount = InterlockedDecrement(&queue->refcount);
7132
7133     TRACE("%p, refcount %u.\n", queue, refcount);
7134
7135     if (!refcount)
7136     {
7137         event_queue_cleanup(queue);
7138         DeleteCriticalSection(&queue->cs);
7139         heap_free(queue);
7140     }
7141
7142     return refcount;
7143 }
7144
7145 static HRESULT WINAPI eventqueue_GetEvent(IMFMediaEventQueue *iface, DWORD flags, IMFMediaEvent **event)
7146 {
7147     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7148     HRESULT hr = S_OK;
7149
7150     TRACE("%p, %p.\n", iface, event);
7151
7152     EnterCriticalSection(&queue->cs);
7153
7154     if (queue->is_shut_down)
7155         hr = MF_E_SHUTDOWN;
7156     else if (queue->subscriber)
7157         hr = MF_E_MULTIPLE_SUBSCRIBERS;
7158     else
7159     {
7160         if (flags & MF_EVENT_FLAG_NO_WAIT)
7161         {
7162             if (!(*event = queue_pop_event(queue)))
7163                 hr = MF_E_NO_EVENTS_AVAILABLE;
7164         }
7165         else
7166         {
7167             while (list_empty(&queue->events) && !queue->is_shut_down)
7168             {
7169                 SleepConditionVariableCS(&queue->update_event, &queue->cs, INFINITE);
7170             }
7171             *event = queue_pop_event(queue);
7172             if (queue->is_shut_down)
7173                 hr = MF_E_SHUTDOWN;
7174         }
7175     }
7176
7177     LeaveCriticalSection(&queue->cs);
7178
7179     return hr;
7180 }
7181
7182 static void queue_notify_subscriber(struct event_queue *queue)
7183 {
7184     if (list_empty(&queue->events) || !queue->subscriber || queue->notified)
7185         return;
7186
7187     queue->notified = TRUE;
7188     RtwqPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, 0, queue->subscriber);
7189 }
7190
7191 static HRESULT WINAPI eventqueue_BeginGetEvent(IMFMediaEventQueue *iface, IMFAsyncCallback *callback, IUnknown *state)
7192 {
7193     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7194     MFASYNCRESULT *result_data = (MFASYNCRESULT *)queue->subscriber;
7195     HRESULT hr;
7196
7197     TRACE("%p, %p, %p.\n", iface, callback, state);
7198
7199     if (!callback)
7200         return E_INVALIDARG;
7201
7202     EnterCriticalSection(&queue->cs);
7203
7204     if (queue->is_shut_down)
7205         hr = MF_E_SHUTDOWN;
7206     else if (result_data)
7207     {
7208         if (result_data->pCallback == callback)
7209             hr = IRtwqAsyncResult_GetStateNoAddRef(queue->subscriber) == state ?
7210                     MF_S_MULTIPLE_BEGIN : MF_E_MULTIPLE_BEGIN;
7211         else
7212             hr = MF_E_MULTIPLE_SUBSCRIBERS;
7213     }
7214     else
7215     {
7216         hr = RtwqCreateAsyncResult(NULL, (IRtwqAsyncCallback *)callback, state, &queue->subscriber);
7217         if (SUCCEEDED(hr))
7218             queue_notify_subscriber(queue);
7219     }
7220
7221     LeaveCriticalSection(&queue->cs);
7222
7223     return hr;
7224 }
7225
7226 static HRESULT WINAPI eventqueue_EndGetEvent(IMFMediaEventQueue *iface, IMFAsyncResult *result, IMFMediaEvent **event)
7227 {
7228     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7229     HRESULT hr = E_FAIL;
7230
7231     TRACE("%p, %p, %p.\n", iface, result, event);
7232
7233     EnterCriticalSection(&queue->cs);
7234
7235     if (queue->is_shut_down)
7236         hr = MF_E_SHUTDOWN;
7237     else if (queue->subscriber == (IRtwqAsyncResult *)result)
7238     {
7239         *event = queue_pop_event(queue);
7240         if (queue->subscriber)
7241             IRtwqAsyncResult_Release(queue->subscriber);
7242         queue->subscriber = NULL;
7243         queue->notified = FALSE;
7244         hr = *event ? S_OK : E_FAIL;
7245     }
7246
7247     LeaveCriticalSection(&queue->cs);
7248
7249     return hr;
7250 }
7251
7252 static HRESULT eventqueue_queue_event(struct event_queue *queue, IMFMediaEvent *event)
7253 {
7254     struct queued_event *queued_event;
7255     HRESULT hr = S_OK;
7256
7257     queued_event = heap_alloc(sizeof(*queued_event));
7258     if (!queued_event)
7259         return E_OUTOFMEMORY;
7260
7261     queued_event->event = event;
7262
7263     EnterCriticalSection(&queue->cs);
7264
7265     if (queue->is_shut_down)
7266         hr = MF_E_SHUTDOWN;
7267     else
7268     {
7269         IMFMediaEvent_AddRef(queued_event->event);
7270         list_add_tail(&queue->events, &queued_event->entry);
7271         queue_notify_subscriber(queue);
7272     }
7273
7274     LeaveCriticalSection(&queue->cs);
7275
7276     if (FAILED(hr))
7277         heap_free(queued_event);
7278
7279     WakeAllConditionVariable(&queue->update_event);
7280
7281     return hr;
7282 }
7283
7284 static HRESULT WINAPI eventqueue_QueueEvent(IMFMediaEventQueue *iface, IMFMediaEvent *event)
7285 {
7286     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7287
7288     TRACE("%p, %p.\n", iface, event);
7289
7290     return eventqueue_queue_event(queue, event);
7291 }
7292
7293 static HRESULT WINAPI eventqueue_QueueEventParamVar(IMFMediaEventQueue *iface, MediaEventType event_type,
7294         REFGUID extended_type, HRESULT status, const PROPVARIANT *value)
7295 {
7296     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7297     IMFMediaEvent *event;
7298     HRESULT hr;
7299
7300     TRACE("%p, %s, %s, %#x, %s\n", iface, debugstr_eventid(event_type), debugstr_guid(extended_type), status,
7301             debugstr_propvar(value));
7302
7303     if (FAILED(hr = MFCreateMediaEvent(event_type, extended_type, status, value, &event)))
7304         return hr;
7305
7306     hr = eventqueue_queue_event(queue, event);
7307     IMFMediaEvent_Release(event);
7308     return hr;
7309 }
7310
7311 static HRESULT WINAPI eventqueue_QueueEventParamUnk(IMFMediaEventQueue *iface, MediaEventType event_type,
7312         REFGUID extended_type, HRESULT status, IUnknown *unk)
7313 {
7314     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7315     IMFMediaEvent *event;
7316     PROPVARIANT value;
7317     HRESULT hr;
7318
7319     TRACE("%p, %s, %s, %#x, %p.\n", iface, debugstr_eventid(event_type), debugstr_guid(extended_type), status, unk);
7320
7321     value.vt = VT_UNKNOWN;
7322     value.u.punkVal = unk;
7323
7324     if (FAILED(hr = MFCreateMediaEvent(event_type, extended_type, status, &value, &event)))
7325         return hr;
7326
7327     hr = eventqueue_queue_event(queue, event);
7328     IMFMediaEvent_Release(event);
7329     return hr;
7330 }
7331
7332 static HRESULT WINAPI eventqueue_Shutdown(IMFMediaEventQueue *iface)
7333 {
7334     struct event_queue *queue = impl_from_IMFMediaEventQueue(iface);
7335
7336     TRACE("%p\n", queue);
7337
7338     EnterCriticalSection(&queue->cs);
7339
7340     if (!queue->is_shut_down)
7341     {
7342         event_queue_cleanup(queue);
7343         queue->is_shut_down = TRUE;
7344     }
7345
7346     LeaveCriticalSection(&queue->cs);
7347
7348     WakeAllConditionVariable(&queue->update_event);
7349
7350     return S_OK;
7351 }
7352
7353 static const IMFMediaEventQueueVtbl eventqueuevtbl =
7354 {
7355     eventqueue_QueryInterface,
7356     eventqueue_AddRef,
7357     eventqueue_Release,
7358     eventqueue_GetEvent,
7359     eventqueue_BeginGetEvent,
7360     eventqueue_EndGetEvent,
7361     eventqueue_QueueEvent,
7362     eventqueue_QueueEventParamVar,
7363     eventqueue_QueueEventParamUnk,
7364     eventqueue_Shutdown
7365 };
7366
7367 /***********************************************************************
7368  *      MFCreateEventQueue (mfplat.@)
7369  */
7370 HRESULT WINAPI MFCreateEventQueue(IMFMediaEventQueue **queue)
7371 {
7372     struct event_queue *object;
7373
7374     TRACE("%p\n", queue);
7375
7376     object = heap_alloc_zero(sizeof(*object));
7377     if (!object)
7378         return E_OUTOFMEMORY;
7379
7380     object->IMFMediaEventQueue_iface.lpVtbl = &eventqueuevtbl;
7381     object->refcount = 1;
7382     list_init(&object->events);
7383     InitializeCriticalSection(&object->cs);
7384     InitializeConditionVariable(&object->update_event);
7385
7386     *queue = &object->IMFMediaEventQueue_iface;
7387
7388     return S_OK;
7389 }
7390
7391 struct collection
7392 {
7393     IMFCollection IMFCollection_iface;
7394     LONG refcount;
7395     IUnknown **elements;
7396     size_t capacity;
7397     size_t count;
7398 };
7399
7400 static struct collection *impl_from_IMFCollection(IMFCollection *iface)
7401 {
7402     return CONTAINING_RECORD(iface, struct collection, IMFCollection_iface);
7403 }
7404
7405 static void collection_clear(struct collection *collection)
7406 {
7407     size_t i;
7408
7409     for (i = 0; i < collection->count; ++i)
7410     {
7411         if (collection->elements[i])
7412             IUnknown_Release(collection->elements[i]);
7413     }
7414
7415     heap_free(collection->elements);
7416     collection->elements = NULL;
7417     collection->count = 0;
7418     collection->capacity = 0;
7419 }
7420
7421 static HRESULT WINAPI collection_QueryInterface(IMFCollection *iface, REFIID riid, void **out)
7422 {
7423     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
7424
7425     if (IsEqualIID(riid, &IID_IMFCollection) ||
7426             IsEqualIID(riid, &IID_IUnknown))
7427     {
7428         *out = iface;
7429         IMFCollection_AddRef(iface);
7430         return S_OK;
7431     }
7432
7433     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
7434     *out = NULL;
7435     return E_NOINTERFACE;
7436 }
7437
7438 static ULONG WINAPI collection_AddRef(IMFCollection *iface)
7439 {
7440     struct collection *collection = impl_from_IMFCollection(iface);
7441     ULONG refcount = InterlockedIncrement(&collection->refcount);
7442
7443     TRACE("%p, %d.\n", collection, refcount);
7444
7445     return refcount;
7446 }
7447
7448 static ULONG WINAPI collection_Release(IMFCollection *iface)
7449 {
7450     struct collection *collection = impl_from_IMFCollection(iface);
7451     ULONG refcount = InterlockedDecrement(&collection->refcount);
7452
7453     TRACE("%p, %d.\n", collection, refcount);
7454
7455     if (!refcount)
7456     {
7457         collection_clear(collection);
7458         heap_free(collection->elements);
7459         heap_free(collection);
7460     }
7461
7462     return refcount;
7463 }
7464
7465 static HRESULT WINAPI collection_GetElementCount(IMFCollection *iface, DWORD *count)
7466 {
7467     struct collection *collection = impl_from_IMFCollection(iface);
7468
7469     TRACE("%p, %p.\n", iface, count);
7470
7471     if (!count)
7472         return E_POINTER;
7473
7474     *count = collection->count;
7475
7476     return S_OK;
7477 }
7478
7479 static HRESULT WINAPI collection_GetElement(IMFCollection *iface, DWORD idx, IUnknown **element)
7480 {
7481     struct collection *collection = impl_from_IMFCollection(iface);
7482
7483     TRACE("%p, %u, %p.\n", iface, idx, element);
7484
7485     if (!element)
7486         return E_POINTER;
7487
7488     if (idx >= collection->count)
7489         return E_INVALIDARG;
7490
7491     *element = collection->elements[idx];
7492     if (*element)
7493         IUnknown_AddRef(*element);
7494
7495     return *element ? S_OK : E_UNEXPECTED;
7496 }
7497
7498 static HRESULT WINAPI collection_AddElement(IMFCollection *iface, IUnknown *element)
7499 {
7500     struct collection *collection = impl_from_IMFCollection(iface);
7501
7502     TRACE("%p, %p.\n", iface, element);
7503
7504     if (!mf_array_reserve((void **)&collection->elements, &collection->capacity, collection->count + 1,
7505             sizeof(*collection->elements)))
7506         return E_OUTOFMEMORY;
7507
7508     collection->elements[collection->count++] = element;
7509     if (element)
7510         IUnknown_AddRef(element);
7511
7512     return S_OK;
7513 }
7514
7515 static HRESULT WINAPI collection_RemoveElement(IMFCollection *iface, DWORD idx, IUnknown **element)
7516 {
7517     struct collection *collection = impl_from_IMFCollection(iface);
7518     size_t count;
7519
7520     TRACE("%p, %u, %p.\n", iface, idx, element);
7521
7522     if (!element)
7523         return E_POINTER;
7524
7525     if (idx >= collection->count)
7526         return E_INVALIDARG;
7527
7528     *element = collection->elements[idx];
7529
7530     count = collection->count - idx - 1;
7531     if (count)
7532         memmove(&collection->elements[idx], &collection->elements[idx + 1], count * sizeof(*collection->elements));
7533     collection->count--;
7534
7535     return S_OK;
7536 }
7537
7538 static HRESULT WINAPI collection_InsertElementAt(IMFCollection *iface, DWORD idx, IUnknown *element)
7539 {
7540     struct collection *collection = impl_from_IMFCollection(iface);
7541     size_t i;
7542
7543     TRACE("%p, %u, %p.\n", iface, idx, element);
7544
7545     if (!mf_array_reserve((void **)&collection->elements, &collection->capacity, idx + 1,
7546             sizeof(*collection->elements)))
7547         return E_OUTOFMEMORY;
7548
7549     if (idx < collection->count)
7550     {
7551         memmove(&collection->elements[idx + 1], &collection->elements[idx],
7552             (collection->count - idx) * sizeof(*collection->elements));
7553         collection->count++;
7554     }
7555     else
7556     {
7557         for (i = collection->count; i < idx; ++i)
7558             collection->elements[i] = NULL;
7559         collection->count = idx + 1;
7560     }
7561
7562     collection->elements[idx] = element;
7563     if (collection->elements[idx])
7564         IUnknown_AddRef(collection->elements[idx]);
7565
7566     return S_OK;
7567 }
7568
7569 static HRESULT WINAPI collection_RemoveAllElements(IMFCollection *iface)
7570 {
7571     struct collection *collection = impl_from_IMFCollection(iface);
7572
7573     TRACE("%p.\n", iface);
7574
7575     collection_clear(collection);
7576
7577     return S_OK;
7578 }
7579
7580 static const IMFCollectionVtbl mfcollectionvtbl =
7581 {
7582     collection_QueryInterface,
7583     collection_AddRef,
7584     collection_Release,
7585     collection_GetElementCount,
7586     collection_GetElement,
7587     collection_AddElement,
7588     collection_RemoveElement,
7589     collection_InsertElementAt,
7590     collection_RemoveAllElements,
7591 };
7592
7593 /***********************************************************************
7594  *      MFCreateCollection (mfplat.@)
7595  */
7596 HRESULT WINAPI MFCreateCollection(IMFCollection **collection)
7597 {
7598     struct collection *object;
7599
7600     TRACE("%p\n", collection);
7601
7602     if (!collection)
7603         return E_POINTER;
7604
7605     object = heap_alloc_zero(sizeof(*object));
7606     if (!object)
7607         return E_OUTOFMEMORY;
7608
7609     object->IMFCollection_iface.lpVtbl = &mfcollectionvtbl;
7610     object->refcount = 1;
7611
7612     *collection = &object->IMFCollection_iface;
7613
7614     return S_OK;
7615 }
7616
7617 /***********************************************************************
7618  *      MFHeapAlloc (mfplat.@)
7619  */
7620 void *WINAPI MFHeapAlloc(SIZE_T size, ULONG flags, char *file, int line, EAllocationType type)
7621 {
7622     TRACE("%lu, %#x, %s, %d, %#x.\n", size, flags, debugstr_a(file), line, type);
7623     return HeapAlloc(GetProcessHeap(), flags, size);
7624 }
7625
7626 /***********************************************************************
7627  *      MFHeapFree (mfplat.@)
7628  */
7629 void WINAPI MFHeapFree(void *p)
7630 {
7631     TRACE("%p\n", p);
7632     HeapFree(GetProcessHeap(), 0, p);
7633 }
7634
7635 /***********************************************************************
7636  *      MFCreateMFByteStreamOnStreamEx (mfplat.@)
7637  */
7638 HRESULT WINAPI MFCreateMFByteStreamOnStreamEx(IUnknown *stream, IMFByteStream **bytestream)
7639 {
7640     FIXME("(%p, %p): stub\n", stream, bytestream);
7641
7642     return E_NOTIMPL;
7643 }
7644
7645 static HRESULT WINAPI system_clock_QueryInterface(IMFClock *iface, REFIID riid, void **obj)
7646 {
7647     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
7648
7649     if (IsEqualIID(riid, &IID_IMFClock) ||
7650             IsEqualIID(riid, &IID_IUnknown))
7651     {
7652         *obj = iface;
7653         IMFClock_AddRef(iface);
7654         return S_OK;
7655     }
7656
7657     WARN("Unsupported %s.\n", debugstr_guid(riid));
7658     *obj = NULL;
7659     return E_NOINTERFACE;
7660 }
7661
7662 static ULONG WINAPI system_clock_AddRef(IMFClock *iface)
7663 {
7664     struct system_clock *clock = impl_from_IMFClock(iface);
7665     ULONG refcount = InterlockedIncrement(&clock->refcount);
7666
7667     TRACE("%p, refcount %u.\n", iface, refcount);
7668
7669     return refcount;
7670 }
7671
7672 static ULONG WINAPI system_clock_Release(IMFClock *iface)
7673 {
7674     struct system_clock *clock = impl_from_IMFClock(iface);
7675     ULONG refcount = InterlockedDecrement(&clock->refcount);
7676
7677     TRACE("%p, refcount %u.\n", iface, refcount);
7678
7679     if (!refcount)
7680         heap_free(clock);
7681
7682     return refcount;
7683 }
7684
7685 static HRESULT WINAPI system_clock_GetClockCharacteristics(IMFClock *iface, DWORD *flags)
7686 {
7687     TRACE("%p, %p.\n", iface, flags);
7688
7689     *flags = MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ | MFCLOCK_CHARACTERISTICS_FLAG_ALWAYS_RUNNING |
7690             MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK;
7691
7692     return S_OK;
7693 }
7694
7695 static HRESULT WINAPI system_clock_GetCorrelatedTime(IMFClock *iface, DWORD reserved, LONGLONG *clock_time,
7696         MFTIME *system_time)
7697 {
7698     TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time);
7699
7700     *clock_time = *system_time = MFGetSystemTime();
7701
7702     return S_OK;
7703 }
7704
7705 static HRESULT WINAPI system_clock_GetContinuityKey(IMFClock *iface, DWORD *key)
7706 {
7707     TRACE("%p, %p.\n", iface, key);
7708
7709     *key = 0;
7710
7711     return S_OK;
7712 }
7713
7714 static HRESULT WINAPI system_clock_GetState(IMFClock *iface, DWORD reserved, MFCLOCK_STATE *state)
7715 {
7716     TRACE("%p, %#x, %p.\n", iface, reserved, state);
7717
7718     *state = MFCLOCK_STATE_RUNNING;
7719
7720     return S_OK;
7721 }
7722
7723 static HRESULT WINAPI system_clock_GetProperties(IMFClock *iface, MFCLOCK_PROPERTIES *props)
7724 {
7725     TRACE("%p, %p.\n", iface, props);
7726
7727     if (!props)
7728         return E_POINTER;
7729
7730     memset(props, 0, sizeof(*props));
7731     props->qwClockFrequency = MFCLOCK_FREQUENCY_HNS;
7732     props->dwClockTolerance = MFCLOCK_TOLERANCE_UNKNOWN;
7733     props->dwClockJitter = 1;
7734
7735     return S_OK;
7736 }
7737
7738 static const IMFClockVtbl system_clock_vtbl =
7739 {
7740     system_clock_QueryInterface,
7741     system_clock_AddRef,
7742     system_clock_Release,
7743     system_clock_GetClockCharacteristics,
7744     system_clock_GetCorrelatedTime,
7745     system_clock_GetContinuityKey,
7746     system_clock_GetState,
7747     system_clock_GetProperties,
7748 };
7749
7750 static HRESULT create_system_clock(IMFClock **clock)
7751 {
7752     struct system_clock *object;
7753
7754     if (!(object = heap_alloc(sizeof(*object))))
7755         return E_OUTOFMEMORY;
7756
7757     object->IMFClock_iface.lpVtbl = &system_clock_vtbl;
7758     object->refcount = 1;
7759
7760     *clock = &object->IMFClock_iface;
7761
7762     return S_OK;
7763 }
7764
7765 static HRESULT WINAPI system_time_source_QueryInterface(IMFPresentationTimeSource *iface, REFIID riid, void **obj)
7766 {
7767     struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7768
7769     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
7770
7771     if (IsEqualIID(riid, &IID_IMFPresentationTimeSource) ||
7772             IsEqualIID(riid, &IID_IUnknown))
7773     {
7774         *obj = &source->IMFPresentationTimeSource_iface;
7775     }
7776     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
7777     {
7778         *obj = &source->IMFClockStateSink_iface;
7779     }
7780     else
7781     {
7782         WARN("Unsupported %s.\n", debugstr_guid(riid));
7783         *obj = NULL;
7784         return E_NOINTERFACE;
7785     }
7786
7787     IUnknown_AddRef((IUnknown *)*obj);
7788     return S_OK;
7789 }
7790
7791 static ULONG WINAPI system_time_source_AddRef(IMFPresentationTimeSource *iface)
7792 {
7793     struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7794     ULONG refcount = InterlockedIncrement(&source->refcount);
7795
7796     TRACE("%p, refcount %u.\n", iface, refcount);
7797
7798     return refcount;
7799 }
7800
7801 static ULONG WINAPI system_time_source_Release(IMFPresentationTimeSource *iface)
7802 {
7803     struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7804     ULONG refcount = InterlockedDecrement(&source->refcount);
7805
7806     TRACE("%p, refcount %u.\n", iface, refcount);
7807
7808     if (!refcount)
7809     {
7810         if (source->clock)
7811             IMFClock_Release(source->clock);
7812         DeleteCriticalSection(&source->cs);
7813         heap_free(source);
7814     }
7815
7816     return refcount;
7817 }
7818
7819 static HRESULT WINAPI system_time_source_GetClockCharacteristics(IMFPresentationTimeSource *iface, DWORD *flags)
7820 {
7821     TRACE("%p, %p.\n", iface, flags);
7822
7823     *flags = MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ | MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK;
7824
7825     return S_OK;
7826 }
7827
7828 static HRESULT WINAPI system_time_source_GetCorrelatedTime(IMFPresentationTimeSource *iface, DWORD reserved,
7829         LONGLONG *clock_time, MFTIME *system_time)
7830 {
7831     struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7832     HRESULT hr;
7833
7834     TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time);
7835
7836     EnterCriticalSection(&source->cs);
7837     if (SUCCEEDED(hr = IMFClock_GetCorrelatedTime(source->clock, 0, clock_time, system_time)))
7838     {
7839         if (source->state == MFCLOCK_STATE_RUNNING)
7840         {
7841             system_time_source_apply_rate(source, clock_time);
7842             *clock_time += source->start_offset;
7843         }
7844         else
7845             *clock_time = source->start_offset;
7846     }
7847     LeaveCriticalSection(&source->cs);
7848
7849     return hr;
7850 }
7851
7852 static HRESULT WINAPI system_time_source_GetContinuityKey(IMFPresentationTimeSource *iface, DWORD *key)
7853 {
7854     TRACE("%p, %p.\n", iface, key);
7855
7856     *key = 0;
7857
7858     return S_OK;
7859 }
7860
7861 static HRESULT WINAPI system_time_source_GetState(IMFPresentationTimeSource *iface, DWORD reserved,
7862         MFCLOCK_STATE *state)
7863 {
7864     struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7865
7866     TRACE("%p, %#x, %p.\n", iface, reserved, state);
7867
7868     EnterCriticalSection(&source->cs);
7869     *state = source->state;
7870     LeaveCriticalSection(&source->cs);
7871
7872     return S_OK;
7873 }
7874
7875 static HRESULT WINAPI system_time_source_GetProperties(IMFPresentationTimeSource *iface, MFCLOCK_PROPERTIES *props)
7876 {
7877     TRACE("%p, %p.\n", iface, props);
7878
7879     if (!props)
7880         return E_POINTER;
7881
7882     memset(props, 0, sizeof(*props));
7883     props->qwClockFrequency = MFCLOCK_FREQUENCY_HNS;
7884     props->dwClockTolerance = MFCLOCK_TOLERANCE_UNKNOWN;
7885     props->dwClockJitter = 1;
7886
7887     return S_OK;
7888 }
7889
7890 static HRESULT WINAPI system_time_source_GetUnderlyingClock(IMFPresentationTimeSource *iface, IMFClock **clock)
7891 {
7892     struct system_time_source *source = impl_from_IMFPresentationTimeSource(iface);
7893
7894     TRACE("%p, %p.\n", iface, clock);
7895
7896     *clock = source->clock;
7897     IMFClock_AddRef(*clock);
7898
7899     return S_OK;
7900 }
7901
7902 static const IMFPresentationTimeSourceVtbl systemtimesourcevtbl =
7903 {
7904     system_time_source_QueryInterface,
7905     system_time_source_AddRef,
7906     system_time_source_Release,
7907     system_time_source_GetClockCharacteristics,
7908     system_time_source_GetCorrelatedTime,
7909     system_time_source_GetContinuityKey,
7910     system_time_source_GetState,
7911     system_time_source_GetProperties,
7912     system_time_source_GetUnderlyingClock,
7913 };
7914
7915 static HRESULT WINAPI system_time_source_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **out)
7916 {
7917     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7918     return IMFPresentationTimeSource_QueryInterface(&source->IMFPresentationTimeSource_iface, riid, out);
7919 }
7920
7921 static ULONG WINAPI system_time_source_sink_AddRef(IMFClockStateSink *iface)
7922 {
7923     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7924     return IMFPresentationTimeSource_AddRef(&source->IMFPresentationTimeSource_iface);
7925 }
7926
7927 static ULONG WINAPI system_time_source_sink_Release(IMFClockStateSink *iface)
7928 {
7929     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7930     return IMFPresentationTimeSource_Release(&source->IMFPresentationTimeSource_iface);
7931 }
7932
7933 enum clock_command
7934 {
7935     CLOCK_CMD_START = 0,
7936     CLOCK_CMD_STOP,
7937     CLOCK_CMD_PAUSE,
7938     CLOCK_CMD_RESTART,
7939     CLOCK_CMD_MAX,
7940 };
7941
7942 static HRESULT system_time_source_change_state(struct system_time_source *source, enum clock_command command)
7943 {
7944     static const BYTE state_change_is_allowed[MFCLOCK_STATE_PAUSED+1][CLOCK_CMD_MAX] =
7945     {   /*              S  S* P  R */
7946         /* INVALID */ { 1, 0, 1, 0 },
7947         /* RUNNING */ { 1, 1, 1, 0 },
7948         /* STOPPED */ { 1, 1, 0, 0 },
7949         /* PAUSED  */ { 1, 1, 0, 1 },
7950     };
7951     static const MFCLOCK_STATE states[CLOCK_CMD_MAX] =
7952     {
7953         /* CLOCK_CMD_START   */ MFCLOCK_STATE_RUNNING,
7954         /* CLOCK_CMD_STOP    */ MFCLOCK_STATE_STOPPED,
7955         /* CLOCK_CMD_PAUSE   */ MFCLOCK_STATE_PAUSED,
7956         /* CLOCK_CMD_RESTART */ MFCLOCK_STATE_RUNNING,
7957     };
7958
7959     /* Special case that go against usual state change vs return value behavior. */
7960     if (source->state == MFCLOCK_STATE_INVALID && command == CLOCK_CMD_STOP)
7961         return S_OK;
7962
7963     if (!state_change_is_allowed[source->state][command])
7964         return MF_E_INVALIDREQUEST;
7965
7966     source->state = states[command];
7967
7968     return S_OK;
7969 }
7970
7971 static HRESULT WINAPI system_time_source_sink_OnClockStart(IMFClockStateSink *iface, MFTIME system_time,
7972         LONGLONG start_offset)
7973 {
7974     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7975     HRESULT hr;
7976
7977     TRACE("%p, %s, %s.\n", iface, wine_dbgstr_longlong(system_time), wine_dbgstr_longlong(start_offset));
7978
7979     EnterCriticalSection(&source->cs);
7980     if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_START)))
7981     {
7982         system_time_source_apply_rate(source, &system_time);
7983         source->start_offset = -system_time + start_offset;
7984     }
7985     LeaveCriticalSection(&source->cs);
7986
7987     return hr;
7988 }
7989
7990 static HRESULT WINAPI system_time_source_sink_OnClockStop(IMFClockStateSink *iface, MFTIME system_time)
7991 {
7992     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
7993     HRESULT hr;
7994
7995     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(system_time));
7996
7997     EnterCriticalSection(&source->cs);
7998     if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_STOP)))
7999         source->start_offset = 0;
8000     LeaveCriticalSection(&source->cs);
8001
8002     return hr;
8003 }
8004
8005 static HRESULT WINAPI system_time_source_sink_OnClockPause(IMFClockStateSink *iface, MFTIME system_time)
8006 {
8007     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
8008     HRESULT hr;
8009
8010     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(system_time));
8011
8012     EnterCriticalSection(&source->cs);
8013     if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_PAUSE)))
8014     {
8015         system_time_source_apply_rate(source, &system_time);
8016         source->start_offset += system_time;
8017     }
8018     LeaveCriticalSection(&source->cs);
8019
8020     return hr;
8021 }
8022
8023 static HRESULT WINAPI system_time_source_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME system_time)
8024 {
8025     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
8026     HRESULT hr;
8027
8028     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(system_time));
8029
8030     EnterCriticalSection(&source->cs);
8031     if (SUCCEEDED(hr = system_time_source_change_state(source, CLOCK_CMD_RESTART)))
8032     {
8033         system_time_source_apply_rate(source, &system_time);
8034         source->start_offset -= system_time;
8035     }
8036     LeaveCriticalSection(&source->cs);
8037
8038     return hr;
8039 }
8040
8041 static HRESULT WINAPI system_time_source_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME system_time, float rate)
8042 {
8043     struct system_time_source *source = impl_from_IMFClockStateSink(iface);
8044     double intpart;
8045
8046     TRACE("%p, %s, %f.\n", iface, wine_dbgstr_longlong(system_time), rate);
8047
8048     if (rate == 0.0f)
8049         return MF_E_UNSUPPORTED_RATE;
8050
8051     modf(rate, &intpart);
8052
8053     EnterCriticalSection(&source->cs);
8054     source->rate = rate;
8055     source->i_rate = rate == intpart ? rate : 0;
8056     LeaveCriticalSection(&source->cs);
8057
8058     return S_OK;
8059 }
8060
8061 static const IMFClockStateSinkVtbl systemtimesourcesinkvtbl =
8062 {
8063     system_time_source_sink_QueryInterface,
8064     system_time_source_sink_AddRef,
8065     system_time_source_sink_Release,
8066     system_time_source_sink_OnClockStart,
8067     system_time_source_sink_OnClockStop,
8068     system_time_source_sink_OnClockPause,
8069     system_time_source_sink_OnClockRestart,
8070     system_time_source_sink_OnClockSetRate,
8071 };
8072
8073 /***********************************************************************
8074  *      MFCreateSystemTimeSource (mfplat.@)
8075  */
8076 HRESULT WINAPI MFCreateSystemTimeSource(IMFPresentationTimeSource **time_source)
8077 {
8078     struct system_time_source *object;
8079     HRESULT hr;
8080
8081     TRACE("%p.\n", time_source);
8082
8083     object = heap_alloc_zero(sizeof(*object));
8084     if (!object)
8085         return E_OUTOFMEMORY;
8086
8087     object->IMFPresentationTimeSource_iface.lpVtbl = &systemtimesourcevtbl;
8088     object->IMFClockStateSink_iface.lpVtbl = &systemtimesourcesinkvtbl;
8089     object->refcount = 1;
8090     object->rate = 1.0f;
8091     object->i_rate = 1;
8092     InitializeCriticalSection(&object->cs);
8093
8094     if (FAILED(hr = create_system_clock(&object->clock)))
8095     {
8096         IMFPresentationTimeSource_Release(&object->IMFPresentationTimeSource_iface);
8097         return hr;
8098     }
8099
8100     *time_source = &object->IMFPresentationTimeSource_iface;
8101
8102     return S_OK;
8103 }
8104
8105 struct async_create_file
8106 {
8107     IRtwqAsyncCallback IRtwqAsyncCallback_iface;
8108     LONG refcount;
8109     MF_FILE_ACCESSMODE access_mode;
8110     MF_FILE_OPENMODE open_mode;
8111     MF_FILE_FLAGS flags;
8112     WCHAR *path;
8113 };
8114
8115 struct async_create_file_result
8116 {
8117     struct list entry;
8118     IRtwqAsyncResult *result;
8119     IMFByteStream *stream;
8120 };
8121
8122 static struct list async_create_file_results = LIST_INIT(async_create_file_results);
8123 static CRITICAL_SECTION async_create_file_cs = { NULL, -1, 0, 0, 0, 0 };
8124
8125 static struct async_create_file *impl_from_create_file_IRtwqAsyncCallback(IRtwqAsyncCallback *iface)
8126 {
8127     return CONTAINING_RECORD(iface, struct async_create_file, IRtwqAsyncCallback_iface);
8128 }
8129
8130 static HRESULT WINAPI async_create_file_callback_QueryInterface(IRtwqAsyncCallback *iface, REFIID riid, void **obj)
8131 {
8132     if (IsEqualIID(riid, &IID_IRtwqAsyncCallback) ||
8133             IsEqualIID(riid, &IID_IUnknown))
8134     {
8135         *obj = iface;
8136         IRtwqAsyncCallback_AddRef(iface);
8137         return S_OK;
8138     }
8139
8140     *obj = NULL;
8141     return E_NOINTERFACE;
8142 }
8143
8144 static ULONG WINAPI async_create_file_callback_AddRef(IRtwqAsyncCallback *iface)
8145 {
8146     struct async_create_file *async = impl_from_create_file_IRtwqAsyncCallback(iface);
8147     ULONG refcount = InterlockedIncrement(&async->refcount);
8148
8149     TRACE("%p, refcount %u.\n", iface, refcount);
8150
8151     return refcount;
8152 }
8153
8154 static ULONG WINAPI async_create_file_callback_Release(IRtwqAsyncCallback *iface)
8155 {
8156     struct async_create_file *async = impl_from_create_file_IRtwqAsyncCallback(iface);
8157     ULONG refcount = InterlockedDecrement(&async->refcount);
8158
8159     TRACE("%p, refcount %u.\n", iface, refcount);
8160
8161     if (!refcount)
8162     {
8163         heap_free(async->path);
8164         heap_free(async);
8165     }
8166
8167     return refcount;
8168 }
8169
8170 static HRESULT WINAPI async_create_file_callback_GetParameters(IRtwqAsyncCallback *iface, DWORD *flags, DWORD *queue)
8171 {
8172     return E_NOTIMPL;
8173 }
8174
8175 static HRESULT WINAPI async_create_file_callback_Invoke(IRtwqAsyncCallback *iface, IRtwqAsyncResult *result)
8176 {
8177     struct async_create_file *async = impl_from_create_file_IRtwqAsyncCallback(iface);
8178     IRtwqAsyncResult *caller;
8179     IMFByteStream *stream;
8180     HRESULT hr;
8181
8182     caller = (IRtwqAsyncResult *)IRtwqAsyncResult_GetStateNoAddRef(result);
8183
8184     hr = MFCreateFile(async->access_mode, async->open_mode, async->flags, async->path, &stream);
8185     if (SUCCEEDED(hr))
8186     {
8187         struct async_create_file_result *result_item;
8188
8189         result_item = heap_alloc(sizeof(*result_item));
8190         if (result_item)
8191         {
8192             result_item->result = caller;
8193             IRtwqAsyncResult_AddRef(caller);
8194             result_item->stream = stream;
8195             IMFByteStream_AddRef(stream);
8196
8197             EnterCriticalSection(&async_create_file_cs);
8198             list_add_tail(&async_create_file_results, &result_item->entry);
8199             LeaveCriticalSection(&async_create_file_cs);
8200         }
8201
8202         IMFByteStream_Release(stream);
8203     }
8204     else
8205         IRtwqAsyncResult_SetStatus(caller, hr);
8206
8207     RtwqInvokeCallback(caller);
8208
8209     return S_OK;
8210 }
8211
8212 static const IRtwqAsyncCallbackVtbl async_create_file_callback_vtbl =
8213 {
8214     async_create_file_callback_QueryInterface,
8215     async_create_file_callback_AddRef,
8216     async_create_file_callback_Release,
8217     async_create_file_callback_GetParameters,
8218     async_create_file_callback_Invoke,
8219 };
8220
8221 /***********************************************************************
8222  *      MFBeginCreateFile (mfplat.@)
8223  */
8224 HRESULT WINAPI MFBeginCreateFile(MF_FILE_ACCESSMODE access_mode, MF_FILE_OPENMODE open_mode, MF_FILE_FLAGS flags,
8225         const WCHAR *path, IMFAsyncCallback *callback, IUnknown *state, IUnknown **cancel_cookie)
8226 {
8227     struct async_create_file *async = NULL;
8228     IRtwqAsyncResult *caller, *item = NULL;
8229     HRESULT hr;
8230
8231     TRACE("%#x, %#x, %#x, %s, %p, %p, %p.\n", access_mode, open_mode, flags, debugstr_w(path), callback, state,
8232             cancel_cookie);
8233
8234     if (cancel_cookie)
8235         *cancel_cookie = NULL;
8236
8237     if (FAILED(hr = RtwqCreateAsyncResult(NULL, (IRtwqAsyncCallback *)callback, state, &caller)))
8238         return hr;
8239
8240     async = heap_alloc(sizeof(*async));
8241     if (!async)
8242     {
8243         hr = E_OUTOFMEMORY;
8244         goto failed;
8245     }
8246
8247     async->IRtwqAsyncCallback_iface.lpVtbl = &async_create_file_callback_vtbl;
8248     async->refcount = 1;
8249     async->access_mode = access_mode;
8250     async->open_mode = open_mode;
8251     async->flags = flags;
8252     if (FAILED(hr = heap_strdupW(path, &async->path)))
8253         goto failed;
8254
8255     hr = RtwqCreateAsyncResult(NULL, &async->IRtwqAsyncCallback_iface, (IUnknown *)caller, &item);
8256     if (FAILED(hr))
8257         goto failed;
8258
8259     if (cancel_cookie)
8260     {
8261         *cancel_cookie = (IUnknown *)caller;
8262         IUnknown_AddRef(*cancel_cookie);
8263     }
8264
8265     hr = RtwqInvokeCallback(item);
8266
8267 failed:
8268     if (async)
8269         IRtwqAsyncCallback_Release(&async->IRtwqAsyncCallback_iface);
8270     if (item)
8271         IRtwqAsyncResult_Release(item);
8272     if (caller)
8273         IRtwqAsyncResult_Release(caller);
8274
8275     return hr;
8276 }
8277
8278 static HRESULT async_create_file_pull_result(IUnknown *unk, IMFByteStream **stream)
8279 {
8280     struct async_create_file_result *item;
8281     HRESULT hr = MF_E_UNEXPECTED;
8282     IRtwqAsyncResult *result;
8283
8284     *stream = NULL;
8285
8286     if (FAILED(IUnknown_QueryInterface(unk, &IID_IRtwqAsyncResult, (void **)&result)))
8287         return hr;
8288
8289     EnterCriticalSection(&async_create_file_cs);
8290
8291     LIST_FOR_EACH_ENTRY(item, &async_create_file_results, struct async_create_file_result, entry)
8292     {
8293         if (result == item->result)
8294         {
8295             *stream = item->stream;
8296             IRtwqAsyncResult_Release(item->result);
8297             list_remove(&item->entry);
8298             heap_free(item);
8299             break;
8300         }
8301     }
8302
8303     LeaveCriticalSection(&async_create_file_cs);
8304
8305     if (*stream)
8306         hr = IRtwqAsyncResult_GetStatus(result);
8307
8308     IRtwqAsyncResult_Release(result);
8309
8310     return hr;
8311 }
8312
8313 /***********************************************************************
8314  *      MFEndCreateFile (mfplat.@)
8315  */
8316 HRESULT WINAPI MFEndCreateFile(IMFAsyncResult *result, IMFByteStream **stream)
8317 {
8318     TRACE("%p, %p.\n", result, stream);
8319
8320     return async_create_file_pull_result((IUnknown *)result, stream);
8321 }
8322
8323 /***********************************************************************
8324  *      MFCancelCreateFile (mfplat.@)
8325  */
8326 HRESULT WINAPI MFCancelCreateFile(IUnknown *cancel_cookie)
8327 {
8328     IMFByteStream *stream = NULL;
8329     HRESULT hr;
8330
8331     TRACE("%p.\n", cancel_cookie);
8332
8333     hr = async_create_file_pull_result(cancel_cookie, &stream);
8334
8335     if (stream)
8336         IMFByteStream_Release(stream);
8337
8338     return hr;
8339 }
8340
8341 /***********************************************************************
8342  *      MFRegisterLocalSchemeHandler (mfplat.@)
8343  */
8344 HRESULT WINAPI MFRegisterLocalSchemeHandler(const WCHAR *scheme, IMFActivate *activate)
8345 {
8346     struct local_handler *handler;
8347     HRESULT hr;
8348
8349     TRACE("%s, %p.\n", debugstr_w(scheme), activate);
8350
8351     if (!scheme || !activate)
8352         return E_INVALIDARG;
8353
8354     if (!(handler = heap_alloc(sizeof(*handler))))
8355         return E_OUTOFMEMORY;
8356
8357     if (FAILED(hr = heap_strdupW(scheme, &handler->u.scheme)))
8358     {
8359         heap_free(handler);
8360         return hr;
8361     }
8362     handler->activate = activate;
8363     IMFActivate_AddRef(handler->activate);
8364
8365     EnterCriticalSection(&local_handlers_section);
8366     list_add_head(&local_scheme_handlers, &handler->entry);
8367     LeaveCriticalSection(&local_handlers_section);
8368
8369     return S_OK;
8370 }
8371
8372 /***********************************************************************
8373  *      MFRegisterLocalByteStreamHandler (mfplat.@)
8374  */
8375 HRESULT WINAPI MFRegisterLocalByteStreamHandler(const WCHAR *extension, const WCHAR *mime, IMFActivate *activate)
8376 {
8377     struct local_handler *handler;
8378     HRESULT hr;
8379
8380     TRACE("%s, %s, %p.\n", debugstr_w(extension), debugstr_w(mime), activate);
8381
8382     if ((!extension && !mime) || !activate)
8383         return E_INVALIDARG;
8384
8385     if (!(handler = heap_alloc_zero(sizeof(*handler))))
8386         return E_OUTOFMEMORY;
8387
8388     hr = heap_strdupW(extension, &handler->u.bytestream.extension);
8389     if (SUCCEEDED(hr))
8390         hr = heap_strdupW(mime, &handler->u.bytestream.mime);
8391
8392     if (FAILED(hr))
8393         goto failed;
8394
8395     EnterCriticalSection(&local_handlers_section);
8396     list_add_head(&local_bytestream_handlers, &handler->entry);
8397     LeaveCriticalSection(&local_handlers_section);
8398
8399     return hr;
8400
8401 failed:
8402     heap_free(handler->u.bytestream.extension);
8403     heap_free(handler->u.bytestream.mime);
8404     heap_free(handler);
8405
8406     return hr;
8407 }
8408
8409 struct property_store
8410 {
8411     IPropertyStore IPropertyStore_iface;
8412     LONG refcount;
8413     CRITICAL_SECTION cs;
8414     size_t count, capacity;
8415     struct
8416     {
8417         PROPERTYKEY key;
8418         PROPVARIANT value;
8419     } *values;
8420 };
8421
8422 static struct property_store *impl_from_IPropertyStore(IPropertyStore *iface)
8423 {
8424     return CONTAINING_RECORD(iface, struct property_store, IPropertyStore_iface);
8425 }
8426
8427 static HRESULT WINAPI property_store_QueryInterface(IPropertyStore *iface, REFIID riid, void **obj)
8428 {
8429     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
8430
8431     if (IsEqualIID(riid, &IID_IPropertyStore) || IsEqualIID(riid, &IID_IUnknown))
8432     {
8433         *obj = iface;
8434         IPropertyStore_AddRef(iface);
8435         return S_OK;
8436     }
8437
8438     *obj = NULL;
8439     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
8440     return E_NOINTERFACE;
8441 }
8442
8443 static ULONG WINAPI property_store_AddRef(IPropertyStore *iface)
8444 {
8445     struct property_store *store = impl_from_IPropertyStore(iface);
8446     ULONG refcount = InterlockedIncrement(&store->refcount);
8447
8448     TRACE("%p, refcount %d.\n", iface, refcount);
8449
8450     return refcount;
8451 }
8452
8453 static ULONG WINAPI property_store_Release(IPropertyStore *iface)
8454 {
8455     struct property_store *store = impl_from_IPropertyStore(iface);
8456     ULONG refcount = InterlockedDecrement(&store->refcount);
8457
8458     TRACE("%p, refcount %d.\n", iface, refcount);
8459
8460     if (!refcount)
8461     {
8462         DeleteCriticalSection(&store->cs);
8463         heap_free(store->values);
8464         heap_free(store);
8465     }
8466
8467     return refcount;
8468 }
8469
8470 static HRESULT WINAPI property_store_GetCount(IPropertyStore *iface, DWORD *count)
8471 {
8472     struct property_store *store = impl_from_IPropertyStore(iface);
8473
8474     TRACE("%p, %p.\n", iface, count);
8475
8476     if (!count)
8477         return E_INVALIDARG;
8478
8479     EnterCriticalSection(&store->cs);
8480     *count = store->count;
8481     LeaveCriticalSection(&store->cs);
8482     return S_OK;
8483 }
8484
8485 static HRESULT WINAPI property_store_GetAt(IPropertyStore *iface, DWORD index, PROPERTYKEY *key)
8486 {
8487     struct property_store *store = impl_from_IPropertyStore(iface);
8488
8489     TRACE("%p, %u, %p.\n", iface, index, key);
8490
8491     EnterCriticalSection(&store->cs);
8492
8493     if (index >= store->count)
8494     {
8495         LeaveCriticalSection(&store->cs);
8496         return E_INVALIDARG;
8497     }
8498
8499     *key = store->values[index].key;
8500
8501     LeaveCriticalSection(&store->cs);
8502     return S_OK;
8503 }
8504
8505 static HRESULT WINAPI property_store_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
8506 {
8507     struct property_store *store = impl_from_IPropertyStore(iface);
8508     unsigned int i;
8509
8510     TRACE("%p, %p, %p.\n", iface, key, value);
8511
8512     if (!value)
8513         return E_INVALIDARG;
8514
8515     if (!key)
8516         return S_FALSE;
8517
8518     EnterCriticalSection(&store->cs);
8519
8520     for (i = 0; i < store->count; ++i)
8521     {
8522         if (!memcmp(key, &store->values[i].key, sizeof(PROPERTYKEY)))
8523         {
8524             PropVariantCopy(value, &store->values[i].value);
8525             LeaveCriticalSection(&store->cs);
8526             return S_OK;
8527         }
8528     }
8529
8530     LeaveCriticalSection(&store->cs);
8531     return S_FALSE;
8532 }
8533
8534 static HRESULT WINAPI property_store_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
8535 {
8536     struct property_store *store = impl_from_IPropertyStore(iface);
8537     unsigned int i;
8538
8539     TRACE("%p, %p, %p.\n", iface, key, value);
8540
8541     EnterCriticalSection(&store->cs);
8542
8543     for (i = 0; i < store->count; ++i)
8544     {
8545         if (!memcmp(key, &store->values[i].key, sizeof(PROPERTYKEY)))
8546         {
8547             PropVariantCopy(&store->values[i].value, value);
8548             LeaveCriticalSection(&store->cs);
8549             return S_OK;
8550         }
8551     }
8552
8553     if (!mf_array_reserve((void **)&store->values, &store->capacity, store->count + 1, sizeof(*store->values)))
8554     {
8555         LeaveCriticalSection(&store->cs);
8556         return E_OUTOFMEMORY;
8557     }
8558
8559     store->values[store->count].key = *key;
8560     PropVariantCopy(&store->values[store->count].value, value);
8561     ++store->count;
8562
8563     LeaveCriticalSection(&store->cs);
8564     return S_OK;
8565 }
8566
8567 static HRESULT WINAPI property_store_Commit(IPropertyStore *iface)
8568 {
8569     TRACE("%p.\n", iface);
8570
8571     return E_NOTIMPL;
8572 }
8573
8574 static const IPropertyStoreVtbl property_store_vtbl =
8575 {
8576     property_store_QueryInterface,
8577     property_store_AddRef,
8578     property_store_Release,
8579     property_store_GetCount,
8580     property_store_GetAt,
8581     property_store_GetValue,
8582     property_store_SetValue,
8583     property_store_Commit,
8584 };
8585
8586 /***********************************************************************
8587  *      CreatePropertyStore (mfplat.@)
8588  */
8589 HRESULT WINAPI CreatePropertyStore(IPropertyStore **store)
8590 {
8591     struct property_store *object;
8592
8593     TRACE("%p.\n", store);
8594
8595     if (!store)
8596         return E_INVALIDARG;
8597
8598     if (!(object = heap_alloc_zero(sizeof(*object))))
8599         return E_OUTOFMEMORY;
8600
8601     object->IPropertyStore_iface.lpVtbl = &property_store_vtbl;
8602     object->refcount = 1;
8603     InitializeCriticalSection(&object->cs);
8604
8605     TRACE("Created store %p.\n", object);
8606     *store = &object->IPropertyStore_iface;
8607
8608     return S_OK;
8609 }
8610
8611 struct dxgi_device_manager
8612 {
8613     IMFDXGIDeviceManager IMFDXGIDeviceManager_iface;
8614     LONG refcount;
8615     UINT token;
8616     IDXGIDevice *device;
8617 };
8618
8619 static struct dxgi_device_manager *impl_from_IMFDXGIDeviceManager(IMFDXGIDeviceManager *iface)
8620 {
8621     return CONTAINING_RECORD(iface, struct dxgi_device_manager, IMFDXGIDeviceManager_iface);
8622 }
8623
8624 static HRESULT WINAPI dxgi_device_manager_QueryInterface(IMFDXGIDeviceManager *iface, REFIID riid, void **obj)
8625 {
8626     TRACE("(%p, %s, %p).\n", iface, debugstr_guid(riid), obj);
8627
8628     if (IsEqualIID(riid, &IID_IMFDXGIDeviceManager) ||
8629         IsEqualGUID(riid, &IID_IUnknown))
8630     {
8631         *obj = iface;
8632         IMFDXGIDeviceManager_AddRef(iface);
8633         return S_OK;
8634     }
8635
8636     WARN("Unsupported %s.\n", debugstr_guid(riid));
8637     *obj = NULL;
8638     return E_NOINTERFACE;
8639 }
8640
8641 static ULONG WINAPI dxgi_device_manager_AddRef(IMFDXGIDeviceManager *iface)
8642 {
8643     struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8644     ULONG refcount = InterlockedIncrement(&manager->refcount);
8645
8646     TRACE("(%p) ref=%u.\n", iface, refcount);
8647
8648     return refcount;
8649 }
8650
8651 static ULONG WINAPI dxgi_device_manager_Release(IMFDXGIDeviceManager *iface)
8652 {
8653     struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8654     ULONG refcount = InterlockedDecrement(&manager->refcount);
8655
8656     TRACE("(%p) ref=%u.\n", iface, refcount);
8657
8658     if (!refcount)
8659     {
8660         if (manager->device)
8661             IDXGIDevice_Release(manager->device);
8662         heap_free(manager);
8663     }
8664
8665     return refcount;
8666 }
8667
8668 static HRESULT WINAPI dxgi_device_manager_CloseDeviceHandle(IMFDXGIDeviceManager *iface, HANDLE device)
8669 {
8670     FIXME("(%p, %p): stub.\n", iface, device);
8671
8672     return E_NOTIMPL;
8673 }
8674
8675 static HRESULT WINAPI dxgi_device_manager_GetVideoService(IMFDXGIDeviceManager *iface, HANDLE device,
8676                                                           REFIID riid, void **service)
8677 {
8678     FIXME("(%p, %p, %s, %p): stub.\n", iface, device, debugstr_guid(riid), service);
8679
8680     return E_NOTIMPL;
8681 }
8682
8683 static HRESULT WINAPI dxgi_device_manager_LockDevice(IMFDXGIDeviceManager *iface, HANDLE device,
8684                                                      REFIID riid, void **ppv, BOOL block)
8685 {
8686     FIXME("(%p, %p, %s, %p, %d): stub.\n", iface, device, wine_dbgstr_guid(riid), ppv, block);
8687
8688     return E_NOTIMPL;
8689 }
8690
8691 static HRESULT WINAPI dxgi_device_manager_OpenDeviceHandle(IMFDXGIDeviceManager *iface, HANDLE *device)
8692 {
8693     FIXME("(%p, %p): stub.\n", iface, device);
8694
8695     return E_NOTIMPL;
8696 }
8697
8698 static HRESULT WINAPI dxgi_device_manager_ResetDevice(IMFDXGIDeviceManager *iface, IUnknown *device, UINT token)
8699 {
8700     struct dxgi_device_manager *manager = impl_from_IMFDXGIDeviceManager(iface);
8701     IDXGIDevice *dxgi_device;
8702     HRESULT hr;
8703
8704     TRACE("(%p, %p, %u).\n", iface, device, token);
8705
8706     if (!device || token != manager->token)
8707         return E_INVALIDARG;
8708
8709     hr = IUnknown_QueryInterface(device, &IID_IDXGIDevice, (void **)&dxgi_device);
8710     if (SUCCEEDED(hr))
8711     {
8712         if (manager->device)
8713             IDXGIDevice_Release(manager->device);
8714         manager->device = dxgi_device;
8715     }
8716     else
8717         hr = E_INVALIDARG;
8718
8719     return hr;
8720 }
8721
8722 static HRESULT WINAPI dxgi_device_manager_TestDevice(IMFDXGIDeviceManager *iface, HANDLE device)
8723 {
8724     FIXME("(%p, %p): stub.\n", iface, device);
8725
8726     return E_NOTIMPL;
8727 }
8728
8729 static HRESULT WINAPI dxgi_device_manager_UnlockDevice(IMFDXGIDeviceManager *iface, HANDLE device, BOOL state)
8730 {
8731     FIXME("(%p, %p, %d): stub.\n", iface, device, state);
8732
8733     return E_NOTIMPL;
8734 }
8735
8736 static const IMFDXGIDeviceManagerVtbl dxgi_device_manager_vtbl =
8737 {
8738     dxgi_device_manager_QueryInterface,
8739     dxgi_device_manager_AddRef,
8740     dxgi_device_manager_Release,
8741     dxgi_device_manager_CloseDeviceHandle,
8742     dxgi_device_manager_GetVideoService,
8743     dxgi_device_manager_LockDevice,
8744     dxgi_device_manager_OpenDeviceHandle,
8745     dxgi_device_manager_ResetDevice,
8746     dxgi_device_manager_TestDevice,
8747     dxgi_device_manager_UnlockDevice,
8748 };
8749
8750 HRESULT WINAPI MFCreateDXGIDeviceManager(UINT *token, IMFDXGIDeviceManager **manager)
8751 {
8752     struct dxgi_device_manager *object;
8753
8754     TRACE("(%p, %p).\n", token, manager);
8755
8756     if (!token || !manager)
8757         return E_POINTER;
8758
8759     object = heap_alloc(sizeof(*object));
8760     if (!object)
8761         return E_OUTOFMEMORY;
8762
8763     object->IMFDXGIDeviceManager_iface.lpVtbl = &dxgi_device_manager_vtbl;
8764     object->refcount = 1;
8765     object->token = GetTickCount();
8766     object->device = NULL;
8767
8768     TRACE("Created device manager: %p, token: %u.\n", object, object->token);
8769
8770     *token = object->token;
8771     *manager = &object->IMFDXGIDeviceManager_iface;
8772
8773     return S_OK;
8774 }