dlls/mf/main.c

   1 /*
   2  * Copyright (C) 2015 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
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "mfidl.h"
  27 #include "rpcproxy.h"
  28
  29 #include "mf_private.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/heap.h"
  33 #include "wine/list.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  36
  37 static HINSTANCE mf_instance;
  38 extern const GUID CLSID_FileSchemePlugin;
  39
  40 struct activate_object
  41 {
  42     IMFActivate IMFActivate_iface;
  43     LONG refcount;
  44     IMFAttributes *attributes;
  45     IUnknown *object;
  46     const struct activate_funcs *funcs;
  47     void *context;
  48 };
  49
  50 static struct activate_object *impl_from_IMFActivate(IMFActivate *iface)
  51 {
  52     return CONTAINING_RECORD(iface, struct activate_object, IMFActivate_iface);
  53 }
  54
  55 static HRESULT WINAPI activate_object_QueryInterface(IMFActivate *iface, REFIID riid, void **obj)
  56 {
  57     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  58
  59     if (IsEqualIID(riid, &IID_IMFActivate) ||
  60             IsEqualIID(riid, &IID_IMFAttributes) ||
  61             IsEqualIID(riid, &IID_IUnknown))
  62     {
  63         *obj = iface;
  64         IMFActivate_AddRef(iface);
  65         return S_OK;
  66     }
  67
  68     WARN("Unsupported %s.\n", debugstr_guid(riid));
  69     *obj = NULL;
  70     return E_NOINTERFACE;
  71 }
  72
  73 static ULONG WINAPI activate_object_AddRef(IMFActivate *iface)
  74 {
  75     struct activate_object *activate = impl_from_IMFActivate(iface);
  76     ULONG refcount = InterlockedIncrement(&activate->refcount);
  77
  78     TRACE("%p, refcount %u.\n", iface, refcount);
  79
  80     return refcount;
  81 }
  82
  83 static ULONG WINAPI activate_object_Release(IMFActivate *iface)
  84 {
  85     struct activate_object *activate = impl_from_IMFActivate(iface);
  86     ULONG refcount = InterlockedDecrement(&activate->refcount);
  87
  88     TRACE("%p, refcount %u.\n", iface, refcount);
  89
  90     if (!refcount)
  91     {
  92         if (activate->funcs->free_private)
  93             activate->funcs->free_private(activate->context);
  94         if (activate->object)
  95             IUnknown_Release(activate->object);
  96         IMFAttributes_Release(activate->attributes);
  97         heap_free(activate);
  98     }
  99
 100     return refcount;
 101 }
 102
 103 static HRESULT WINAPI activate_object_GetItem(IMFActivate *iface, REFGUID key, PROPVARIANT *value)
 104 {
 105     struct activate_object *activate = impl_from_IMFActivate(iface);
 106
 107     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 108
 109     return IMFAttributes_GetItem(activate->attributes, key, value);
 110 }
 111
 112 static HRESULT WINAPI activate_object_GetItemType(IMFActivate *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 113 {
 114     struct activate_object *activate = impl_from_IMFActivate(iface);
 115
 116     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
 117
 118     return IMFAttributes_GetItemType(activate->attributes, key, type);
 119 }
 120
 121 static HRESULT WINAPI activate_object_CompareItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 122 {
 123     struct activate_object *activate = impl_from_IMFActivate(iface);
 124
 125     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
 126
 127     return IMFAttributes_CompareItem(activate->attributes, key, value, result);
 128 }
 129
 130 static HRESULT WINAPI activate_object_Compare(IMFActivate *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
 131         BOOL *result)
 132 {
 133     struct activate_object *activate = impl_from_IMFActivate(iface);
 134
 135     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
 136
 137     return IMFAttributes_Compare(activate->attributes, theirs, type, result);
 138 }
 139
 140 static HRESULT WINAPI activate_object_GetUINT32(IMFActivate *iface, REFGUID key, UINT32 *value)
 141 {
 142     struct activate_object *activate = impl_from_IMFActivate(iface);
 143
 144     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 145
 146     return IMFAttributes_GetUINT32(activate->attributes, key, value);
 147 }
 148
 149 static HRESULT WINAPI activate_object_GetUINT64(IMFActivate *iface, REFGUID key, UINT64 *value)
 150 {
 151     struct activate_object *activate = impl_from_IMFActivate(iface);
 152
 153     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 154
 155     return IMFAttributes_GetUINT64(activate->attributes, key, value);
 156 }
 157
 158 static HRESULT WINAPI activate_object_GetDouble(IMFActivate *iface, REFGUID key, double *value)
 159 {
 160     struct activate_object *activate = impl_from_IMFActivate(iface);
 161
 162     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 163
 164     return IMFAttributes_GetDouble(activate->attributes, key, value);
 165 }
 166
 167 static HRESULT WINAPI activate_object_GetGUID(IMFActivate *iface, REFGUID key, GUID *value)
 168 {
 169     struct activate_object *activate = impl_from_IMFActivate(iface);
 170
 171     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 172
 173     return IMFAttributes_GetGUID(activate->attributes, key, value);
 174 }
 175
 176 static HRESULT WINAPI activate_object_GetStringLength(IMFActivate *iface, REFGUID key, UINT32 *length)
 177 {
 178     struct activate_object *activate = impl_from_IMFActivate(iface);
 179
 180     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
 181
 182     return IMFAttributes_GetStringLength(activate->attributes, key, length);
 183 }
 184
 185 static HRESULT WINAPI activate_object_GetString(IMFActivate *iface, REFGUID key, WCHAR *value,
 186         UINT32 size, UINT32 *length)
 187 {
 188     struct activate_object *activate = impl_from_IMFActivate(iface);
 189
 190     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), value, size, length);
 191
 192     return IMFAttributes_GetString(activate->attributes, key, value, size, length);
 193 }
 194
 195 static HRESULT WINAPI activate_object_GetAllocatedString(IMFActivate *iface, REFGUID key,
 196         WCHAR **value, UINT32 *length)
 197 {
 198     struct activate_object *activate = impl_from_IMFActivate(iface);
 199
 200     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
 201
 202     return IMFAttributes_GetAllocatedString(activate->attributes, key, value, length);
 203 }
 204
 205 static HRESULT WINAPI activate_object_GetBlobSize(IMFActivate *iface, REFGUID key, UINT32 *size)
 206 {
 207     struct activate_object *activate = impl_from_IMFActivate(iface);
 208
 209     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
 210
 211     return IMFAttributes_GetBlobSize(activate->attributes, key, size);
 212 }
 213
 214 static HRESULT WINAPI activate_object_GetBlob(IMFActivate *iface, REFGUID key, UINT8 *buf,
 215         UINT32 bufsize, UINT32 *blobsize)
 216 {
 217     struct activate_object *activate = impl_from_IMFActivate(iface);
 218
 219     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
 220
 221     return IMFAttributes_GetBlob(activate->attributes, key, buf, bufsize, blobsize);
 222 }
 223
 224 static HRESULT WINAPI activate_object_GetAllocatedBlob(IMFActivate *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 225 {
 226     struct activate_object *activate = impl_from_IMFActivate(iface);
 227
 228     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
 229
 230     return IMFAttributes_GetAllocatedBlob(activate->attributes, key, buf, size);
 231 }
 232
 233 static HRESULT WINAPI activate_object_GetUnknown(IMFActivate *iface, REFGUID key, REFIID riid, void **ppv)
 234 {
 235     struct activate_object *activate = impl_from_IMFActivate(iface);
 236
 237     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), ppv);
 238
 239     return IMFAttributes_GetUnknown(activate->attributes, key, riid, ppv);
 240 }
 241
 242 static HRESULT WINAPI activate_object_SetItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value)
 243 {
 244     struct activate_object *activate = impl_from_IMFActivate(iface);
 245
 246     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 247
 248     return IMFAttributes_SetItem(activate->attributes, key, value);
 249 }
 250
 251 static HRESULT WINAPI activate_object_DeleteItem(IMFActivate *iface, REFGUID key)
 252 {
 253     struct activate_object *activate = impl_from_IMFActivate(iface);
 254
 255     TRACE("%p, %s.\n", iface, debugstr_guid(key));
 256
 257     return IMFAttributes_DeleteItem(activate->attributes, key);
 258 }
 259
 260 static HRESULT WINAPI activate_object_DeleteAllItems(IMFActivate *iface)
 261 {
 262     struct activate_object *activate = impl_from_IMFActivate(iface);
 263
 264     TRACE("%p.\n", iface);
 265
 266     return IMFAttributes_DeleteAllItems(activate->attributes);
 267 }
 268
 269 static HRESULT WINAPI activate_object_SetUINT32(IMFActivate *iface, REFGUID key, UINT32 value)
 270 {
 271     struct activate_object *activate = impl_from_IMFActivate(iface);
 272
 273     TRACE("%p, %s, %d.\n", iface, debugstr_guid(key), value);
 274
 275     return IMFAttributes_SetUINT32(activate->attributes, key, value);
 276 }
 277
 278 static HRESULT WINAPI activate_object_SetUINT64(IMFActivate *iface, REFGUID key, UINT64 value)
 279 {
 280     struct activate_object *activate = impl_from_IMFActivate(iface);
 281
 282     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
 283
 284     return IMFAttributes_SetUINT64(activate->attributes, key, value);
 285 }
 286
 287 static HRESULT WINAPI activate_object_SetDouble(IMFActivate *iface, REFGUID key, double value)
 288 {
 289     struct activate_object *activate = impl_from_IMFActivate(iface);
 290
 291     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
 292
 293     return IMFAttributes_SetDouble(activate->attributes, key, value);
 294 }
 295
 296 static HRESULT WINAPI activate_object_SetGUID(IMFActivate *iface, REFGUID key, REFGUID value)
 297 {
 298     struct activate_object *activate = impl_from_IMFActivate(iface);
 299
 300     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
 301
 302     return IMFAttributes_SetGUID(activate->attributes, key, value);
 303 }
 304
 305 static HRESULT WINAPI activate_object_SetString(IMFActivate *iface, REFGUID key, const WCHAR *value)
 306 {
 307     struct activate_object *activate = impl_from_IMFActivate(iface);
 308
 309     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
 310
 311     return IMFAttributes_SetString(activate->attributes, key, value);
 312 }
 313
 314 static HRESULT WINAPI activate_object_SetBlob(IMFActivate *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 315 {
 316     struct activate_object *activate = impl_from_IMFActivate(iface);
 317
 318     TRACE("%p, %s, %p, %d.\n", iface, debugstr_guid(key), buf, size);
 319
 320     return IMFAttributes_SetBlob(activate->attributes, key, buf, size);
 321 }
 322
 323 static HRESULT WINAPI activate_object_SetUnknown(IMFActivate *iface, REFGUID key, IUnknown *unknown)
 324 {
 325     struct activate_object *activate = impl_from_IMFActivate(iface);
 326
 327     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(key), unknown);
 328
 329     return IMFAttributes_SetUnknown(activate->attributes, key, unknown);
 330 }
 331
 332 static HRESULT WINAPI activate_object_LockStore(IMFActivate *iface)
 333 {
 334     struct activate_object *activate = impl_from_IMFActivate(iface);
 335
 336     TRACE("%p.\n", iface);
 337
 338     return IMFAttributes_LockStore(activate->attributes);
 339 }
 340
 341 static HRESULT WINAPI activate_object_UnlockStore(IMFActivate *iface)
 342 {
 343     struct activate_object *activate = impl_from_IMFActivate(iface);
 344
 345     TRACE("%p.\n", iface);
 346
 347     return IMFAttributes_UnlockStore(activate->attributes);
 348 }
 349
 350 static HRESULT WINAPI activate_object_GetCount(IMFActivate *iface, UINT32 *count)
 351 {
 352     struct activate_object *activate = impl_from_IMFActivate(iface);
 353
 354     TRACE("%p, %p.\n", iface, count);
 355
 356     return IMFAttributes_GetCount(activate->attributes, count);
 357 }
 358
 359 static HRESULT WINAPI activate_object_GetItemByIndex(IMFActivate *iface, UINT32 index, GUID *key, PROPVARIANT *value)
 360 {
 361     struct activate_object *activate = impl_from_IMFActivate(iface);
 362
 363     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 364
 365     return IMFAttributes_GetItemByIndex(activate->attributes, index, key, value);
 366 }
 367
 368 static HRESULT WINAPI activate_object_CopyAllItems(IMFActivate *iface, IMFAttributes *dest)
 369 {
 370     struct activate_object *activate = impl_from_IMFActivate(iface);
 371
 372     TRACE("%p, %p.\n", iface, dest);
 373
 374     return IMFAttributes_CopyAllItems(activate->attributes, dest);
 375 }
 376
 377 static HRESULT WINAPI activate_object_ActivateObject(IMFActivate *iface, REFIID riid, void **obj)
 378 {
 379     struct activate_object *activate = impl_from_IMFActivate(iface);
 380     IUnknown *object;
 381     HRESULT hr;
 382
 383     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 384
 385     if (!activate->object)
 386     {
 387         if (FAILED(hr = activate->funcs->create_object((IMFAttributes *)iface, activate->context, &object)))
 388             return hr;
 389
 390         if (InterlockedCompareExchangePointer((void **)&activate->object, object, NULL))
 391             IUnknown_Release(object);
 392     }
 393
 394     return IUnknown_QueryInterface(activate->object, riid, obj);
 395 }
 396
 397 static HRESULT WINAPI activate_object_ShutdownObject(IMFActivate *iface)
 398 {
 399     struct activate_object *activate = impl_from_IMFActivate(iface);
 400     IUnknown *object;
 401
 402     TRACE("%p.\n", iface);
 403
 404     if ((object = InterlockedCompareExchangePointer((void **)&activate->object, NULL, activate->object)))
 405     {
 406         activate->funcs->shutdown_object(activate->context, object);
 407         IUnknown_Release(object);
 408     }
 409
 410     return S_OK;
 411 }
 412
 413 static HRESULT WINAPI activate_object_DetachObject(IMFActivate *iface)
 414 {
 415     TRACE("%p.\n", iface);
 416
 417     return E_NOTIMPL;
 418 }
 419
 420 static const IMFActivateVtbl activate_object_vtbl =
 421 {
 422     activate_object_QueryInterface,
 423     activate_object_AddRef,
 424     activate_object_Release,
 425     activate_object_GetItem,
 426     activate_object_GetItemType,
 427     activate_object_CompareItem,
 428     activate_object_Compare,
 429     activate_object_GetUINT32,
 430     activate_object_GetUINT64,
 431     activate_object_GetDouble,
 432     activate_object_GetGUID,
 433     activate_object_GetStringLength,
 434     activate_object_GetString,
 435     activate_object_GetAllocatedString,
 436     activate_object_GetBlobSize,
 437     activate_object_GetBlob,
 438     activate_object_GetAllocatedBlob,
 439     activate_object_GetUnknown,
 440     activate_object_SetItem,
 441     activate_object_DeleteItem,
 442     activate_object_DeleteAllItems,
 443     activate_object_SetUINT32,
 444     activate_object_SetUINT64,
 445     activate_object_SetDouble,
 446     activate_object_SetGUID,
 447     activate_object_SetString,
 448     activate_object_SetBlob,
 449     activate_object_SetUnknown,
 450     activate_object_LockStore,
 451     activate_object_UnlockStore,
 452     activate_object_GetCount,
 453     activate_object_GetItemByIndex,
 454     activate_object_CopyAllItems,
 455     activate_object_ActivateObject,
 456     activate_object_ShutdownObject,
 457     activate_object_DetachObject,
 458 };
 459
 460 HRESULT create_activation_object(void *context, const struct activate_funcs *funcs, IMFActivate **ret)
 461 {
 462     struct activate_object *object;
 463     HRESULT hr;
 464
 465     object = heap_alloc_zero(sizeof(*object));
 466     if (!object)
 467         return E_OUTOFMEMORY;
 468
 469     object->IMFActivate_iface.lpVtbl = &activate_object_vtbl;
 470     object->refcount = 1;
 471     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
 472     {
 473         heap_free(object);
 474         return hr;
 475     }
 476     object->funcs = funcs;
 477     object->context = context;
 478
 479     *ret = &object->IMFActivate_iface;
 480
 481     return S_OK;
 482 }
 483
 484 struct class_factory
 485 {
 486     IClassFactory IClassFactory_iface;
 487     HRESULT (*create_instance)(REFIID riid, void **obj);
 488 };
 489
 490 static inline struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
 491 {
 492     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
 493 }
 494
 495 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
 496 {
 497     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 498
 499     if (IsEqualGUID(riid, &IID_IClassFactory) ||
 500             IsEqualGUID(riid, &IID_IUnknown))
 501     {
 502         *obj = iface;
 503         IClassFactory_AddRef(iface);
 504         return S_OK;
 505     }
 506
 507     WARN("%s is not supported.\n", debugstr_guid(riid));
 508     *obj = NULL;
 509     return E_NOINTERFACE;
 510 }
 511
 512 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
 513 {
 514     return 2;
 515 }
 516
 517 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
 518 {
 519     return 1;
 520 }
 521
 522 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
 523 {
 524     struct class_factory *factory = impl_from_IClassFactory(iface);
 525
 526     TRACE("%p, %p, %s, %p.\n", iface, outer, debugstr_guid(riid), obj);
 527
 528     if (outer)
 529     {
 530         *obj = NULL;
 531         return CLASS_E_NOAGGREGATION;
 532     }
 533
 534     return factory->create_instance(riid, obj);
 535 }
 536
 537 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL dolock)
 538 {
 539     FIXME("%d.\n", dolock);
 540
 541     return S_OK;
 542 }
 543
 544 static const IClassFactoryVtbl class_factory_vtbl =
 545 {
 546     class_factory_QueryInterface,
 547     class_factory_AddRef,
 548     class_factory_Release,
 549     class_factory_CreateInstance,
 550     class_factory_LockServer,
 551 };
 552
 553 struct file_scheme_handler_result
 554 {
 555     struct list entry;
 556     IMFAsyncResult *result;
 557     MF_OBJECT_TYPE obj_type;
 558     IUnknown *object;
 559 };
 560
 561 struct file_scheme_handler
 562 {
 563     IMFSchemeHandler IMFSchemeHandler_iface;
 564     IMFAsyncCallback IMFAsyncCallback_iface;
 565     LONG refcount;
 566     IMFSourceResolver *resolver;
 567     struct list results;
 568     CRITICAL_SECTION cs;
 569 };
 570
 571 static struct file_scheme_handler *impl_from_IMFSchemeHandler(IMFSchemeHandler *iface)
 572 {
 573     return CONTAINING_RECORD(iface, struct file_scheme_handler, IMFSchemeHandler_iface);
 574 }
 575
 576 static struct file_scheme_handler *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface)
 577 {
 578     return CONTAINING_RECORD(iface, struct file_scheme_handler, IMFAsyncCallback_iface);
 579 }
 580
 581 static HRESULT WINAPI file_scheme_handler_QueryInterface(IMFSchemeHandler *iface, REFIID riid, void **obj)
 582 {
 583     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 584
 585     if (IsEqualIID(riid, &IID_IMFSchemeHandler) ||
 586             IsEqualIID(riid, &IID_IUnknown))
 587     {
 588         *obj = iface;
 589         IMFSchemeHandler_AddRef(iface);
 590         return S_OK;
 591     }
 592
 593     WARN("Unsupported %s.\n", debugstr_guid(riid));
 594     *obj = NULL;
 595     return E_NOINTERFACE;
 596 }
 597
 598 static ULONG WINAPI file_scheme_handler_AddRef(IMFSchemeHandler *iface)
 599 {
 600     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 601     ULONG refcount = InterlockedIncrement(&handler->refcount);
 602
 603     TRACE("%p, refcount %u.\n", handler, refcount);
 604
 605     return refcount;
 606 }
 607
 608 static ULONG WINAPI file_scheme_handler_Release(IMFSchemeHandler *iface)
 609 {
 610     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 611     ULONG refcount = InterlockedDecrement(&handler->refcount);
 612     struct file_scheme_handler_result *result, *next;
 613
 614     TRACE("%p, refcount %u.\n", iface, refcount);
 615
 616     if (!refcount)
 617     {
 618         LIST_FOR_EACH_ENTRY_SAFE(result, next, &handler->results, struct file_scheme_handler_result, entry)
 619         {
 620             list_remove(&result->entry);
 621             IMFAsyncResult_Release(result->result);
 622             if (result->object)
 623                 IUnknown_Release(result->object);
 624             heap_free(result);
 625         }
 626         DeleteCriticalSection(&handler->cs);
 627         if (handler->resolver)
 628             IMFSourceResolver_Release(handler->resolver);
 629         heap_free(handler);
 630     }
 631
 632     return refcount;
 633 }
 634
 635 struct create_object_context
 636 {
 637     IUnknown IUnknown_iface;
 638     LONG refcount;
 639
 640     IPropertyStore *props;
 641     WCHAR *url;
 642     DWORD flags;
 643 };
 644
 645 static struct create_object_context *impl_from_IUnknown(IUnknown *iface)
 646 {
 647     return CONTAINING_RECORD(iface, struct create_object_context, IUnknown_iface);
 648 }
 649
 650 static HRESULT WINAPI create_object_context_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 651 {
 652     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 653
 654     if (IsEqualIID(riid, &IID_IUnknown))
 655     {
 656         *obj = iface;
 657         IUnknown_AddRef(iface);
 658         return S_OK;
 659     }
 660
 661     WARN("Unsupported %s.\n", debugstr_guid(riid));
 662     *obj = NULL;
 663     return E_NOINTERFACE;
 664 }
 665
 666 static ULONG WINAPI create_object_context_AddRef(IUnknown *iface)
 667 {
 668     struct create_object_context *context = impl_from_IUnknown(iface);
 669     ULONG refcount = InterlockedIncrement(&context->refcount);
 670
 671     TRACE("%p, refcount %u.\n", iface, refcount);
 672
 673     return refcount;
 674 }
 675
 676 static ULONG WINAPI create_object_context_Release(IUnknown *iface)
 677 {
 678     struct create_object_context *context = impl_from_IUnknown(iface);
 679     ULONG refcount = InterlockedDecrement(&context->refcount);
 680
 681     TRACE("%p, refcount %u.\n", iface, refcount);
 682
 683     if (!refcount)
 684     {
 685         if (context->props)
 686             IPropertyStore_Release(context->props);
 687         heap_free(context->url);
 688         heap_free(context);
 689     }
 690
 691     return refcount;
 692 }
 693
 694 static const IUnknownVtbl create_object_context_vtbl =
 695 {
 696     create_object_context_QueryInterface,
 697     create_object_context_AddRef,
 698     create_object_context_Release,
 699 };
 700
 701 static WCHAR *heap_strdupW(const WCHAR *str)
 702 {
 703     WCHAR *ret = NULL;
 704
 705     if (str)
 706     {
 707         unsigned int size;
 708
 709         size = (lstrlenW(str) + 1) * sizeof(WCHAR);
 710         ret = heap_alloc(size);
 711         if (ret)
 712             memcpy(ret, str, size);
 713     }
 714
 715     return ret;
 716 }
 717
 718 static HRESULT WINAPI file_scheme_handler_BeginCreateObject(IMFSchemeHandler *iface, const WCHAR *url, DWORD flags,
 719         IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *state)
 720 {
 721     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 722     struct create_object_context *context;
 723     IMFAsyncResult *caller, *item;
 724     HRESULT hr;
 725
 726     TRACE("%p, %s, %#x, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state);
 727
 728     if (cancel_cookie)
 729         *cancel_cookie = NULL;
 730
 731     if (FAILED(hr = MFCreateAsyncResult(NULL, callback, state, &caller)))
 732         return hr;
 733
 734     context = heap_alloc(sizeof(*context));
 735     if (!context)
 736     {
 737         IMFAsyncResult_Release(caller);
 738         return E_OUTOFMEMORY;
 739     }
 740
 741     context->IUnknown_iface.lpVtbl = &create_object_context_vtbl;
 742     context->refcount = 1;
 743     context->props = props;
 744     if (context->props)
 745         IPropertyStore_AddRef(context->props);
 746     context->flags = flags;
 747     context->url = heap_strdupW(url);
 748     if (!context->url)
 749     {
 750         IMFAsyncResult_Release(caller);
 751         IUnknown_Release(&context->IUnknown_iface);
 752         return E_OUTOFMEMORY;
 753     }
 754
 755     hr = MFCreateAsyncResult(&context->IUnknown_iface, &handler->IMFAsyncCallback_iface, (IUnknown *)caller, &item);
 756     IUnknown_Release(&context->IUnknown_iface);
 757     if (SUCCEEDED(hr))
 758     {
 759         if (SUCCEEDED(hr = MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_IO, item)))
 760         {
 761             if (cancel_cookie)
 762             {
 763                 *cancel_cookie = (IUnknown *)caller;
 764                 IUnknown_AddRef(*cancel_cookie);
 765             }
 766         }
 767
 768         IMFAsyncResult_Release(item);
 769     }
 770     IMFAsyncResult_Release(caller);
 771
 772     return hr;
 773 }
 774
 775 static HRESULT WINAPI file_scheme_handler_EndCreateObject(IMFSchemeHandler *iface, IMFAsyncResult *result,
 776         MF_OBJECT_TYPE *obj_type, IUnknown **object)
 777 {
 778     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 779     struct file_scheme_handler_result *found = NULL, *cur;
 780     HRESULT hr;
 781
 782     TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
 783
 784     EnterCriticalSection(&handler->cs);
 785
 786     LIST_FOR_EACH_ENTRY(cur, &handler->results, struct file_scheme_handler_result, entry)
 787     {
 788         if (result == cur->result)
 789         {
 790             list_remove(&cur->entry);
 791             found = cur;
 792             break;
 793         }
 794     }
 795
 796     LeaveCriticalSection(&handler->cs);
 797
 798     if (found)
 799     {
 800         *obj_type = found->obj_type;
 801         *object = found->object;
 802         hr = IMFAsyncResult_GetStatus(found->result);
 803         IMFAsyncResult_Release(found->result);
 804         heap_free(found);
 805     }
 806     else
 807     {
 808         *obj_type = MF_OBJECT_INVALID;
 809         *object = NULL;
 810         hr = MF_E_UNEXPECTED;
 811     }
 812
 813     return hr;
 814 }
 815
 816 static HRESULT WINAPI file_scheme_handler_CancelObjectCreation(IMFSchemeHandler *iface, IUnknown *cancel_cookie)
 817 {
 818     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 819     struct file_scheme_handler_result *found = NULL, *cur;
 820
 821     TRACE("%p, %p.\n", iface, cancel_cookie);
 822
 823     EnterCriticalSection(&handler->cs);
 824
 825     LIST_FOR_EACH_ENTRY(cur, &handler->results, struct file_scheme_handler_result, entry)
 826     {
 827         if (cancel_cookie == (IUnknown *)cur->result)
 828         {
 829             list_remove(&cur->entry);
 830             found = cur;
 831             break;
 832         }
 833     }
 834
 835     LeaveCriticalSection(&handler->cs);
 836
 837     if (found)
 838     {
 839         IMFAsyncResult_Release(found->result);
 840         if (found->object)
 841             IUnknown_Release(found->object);
 842         heap_free(found);
 843     }
 844
 845     return found ? S_OK : MF_E_UNEXPECTED;
 846 }
 847
 848 static const IMFSchemeHandlerVtbl file_scheme_handler_vtbl =
 849 {
 850     file_scheme_handler_QueryInterface,
 851     file_scheme_handler_AddRef,
 852     file_scheme_handler_Release,
 853     file_scheme_handler_BeginCreateObject,
 854     file_scheme_handler_EndCreateObject,
 855     file_scheme_handler_CancelObjectCreation,
 856 };
 857
 858 static HRESULT WINAPI file_scheme_handler_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
 859 {
 860     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 861             IsEqualIID(riid, &IID_IUnknown))
 862     {
 863         *obj = iface;
 864         IMFAsyncCallback_AddRef(iface);
 865         return S_OK;
 866     }
 867
 868     WARN("Unsupported %s.\n", debugstr_guid(riid));
 869     *obj = NULL;
 870     return E_NOINTERFACE;
 871 }
 872
 873 static ULONG WINAPI file_scheme_handler_callback_AddRef(IMFAsyncCallback *iface)
 874 {
 875     struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface);
 876     return IMFSchemeHandler_AddRef(&handler->IMFSchemeHandler_iface);
 877 }
 878
 879 static ULONG WINAPI file_scheme_handler_callback_Release(IMFAsyncCallback *iface)
 880 {
 881     struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface);
 882     return IMFSchemeHandler_Release(&handler->IMFSchemeHandler_iface);
 883 }
 884
 885 static HRESULT WINAPI file_scheme_handler_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
 886 {
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT file_scheme_handler_get_resolver(struct file_scheme_handler *handler, IMFSourceResolver **resolver)
 891 {
 892     HRESULT hr;
 893
 894     if (!handler->resolver)
 895     {
 896         IMFSourceResolver *resolver;
 897
 898         if (FAILED(hr = MFCreateSourceResolver(&resolver)))
 899             return hr;
 900
 901         if (InterlockedCompareExchangePointer((void **)&handler->resolver, resolver, NULL))
 902             IMFSourceResolver_Release(resolver);
 903     }
 904
 905     *resolver = handler->resolver;
 906     IMFSourceResolver_AddRef(*resolver);
 907
 908     return S_OK;
 909 }
 910
 911 static HRESULT WINAPI file_scheme_handler_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 912 {
 913     static const WCHAR schemeW[] = {'f','i','l','e',':','/','/'};
 914     struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface);
 915     struct file_scheme_handler_result *handler_result;
 916     MF_OBJECT_TYPE obj_type = MF_OBJECT_INVALID;
 917     IUnknown *object = NULL, *context_object;
 918     struct create_object_context *context;
 919     IMFSourceResolver *resolver;
 920     IMFAsyncResult *caller;
 921     IMFByteStream *stream;
 922     const WCHAR *url;
 923     HRESULT hr;
 924
 925     caller = (IMFAsyncResult *)IMFAsyncResult_GetStateNoAddRef(result);
 926
 927     if (FAILED(hr = IMFAsyncResult_GetObject(result, &context_object)))
 928     {
 929         WARN("Expected context set for callee result.\n");
 930         return hr;
 931     }
 932
 933     context = impl_from_IUnknown(context_object);
 934
 935     /* Strip from scheme, MFCreateFile() won't be expecting it. */
 936     url = context->url;
 937     if (!wcsnicmp(context->url, schemeW, ARRAY_SIZE(schemeW)))
 938         url += ARRAY_SIZE(schemeW);
 939
 940     hr = MFCreateFile(context->flags & MF_RESOLUTION_WRITE ? MF_ACCESSMODE_READWRITE : MF_ACCESSMODE_READ,
 941             MF_OPENMODE_FAIL_IF_NOT_EXIST, MF_FILEFLAGS_NONE, url, &stream);
 942     if (SUCCEEDED(hr))
 943     {
 944         if (context->flags & MF_RESOLUTION_MEDIASOURCE)
 945         {
 946             if (SUCCEEDED(hr = file_scheme_handler_get_resolver(handler, &resolver)))
 947             {
 948                 hr = IMFSourceResolver_CreateObjectFromByteStream(resolver, stream, context->url, context->flags,
 949                         context->props, &obj_type, &object);
 950                 IMFSourceResolver_Release(resolver);
 951                 IMFByteStream_Release(stream);
 952             }
 953         }
 954         else
 955         {
 956             object = (IUnknown *)stream;
 957             obj_type = MF_OBJECT_BYTESTREAM;
 958         }
 959     }
 960
 961     handler_result = heap_alloc(sizeof(*handler_result));
 962     if (handler_result)
 963     {
 964         handler_result->result = caller;
 965         IMFAsyncResult_AddRef(handler_result->result);
 966         handler_result->obj_type = obj_type;
 967         handler_result->object = object;
 968
 969         EnterCriticalSection(&handler->cs);
 970         list_add_tail(&handler->results, &handler_result->entry);
 971         LeaveCriticalSection(&handler->cs);
 972     }
 973     else
 974     {
 975         if (object)
 976             IUnknown_Release(object);
 977         hr = E_OUTOFMEMORY;
 978     }
 979
 980     IUnknown_Release(&context->IUnknown_iface);
 981
 982     IMFAsyncResult_SetStatus(caller, hr);
 983     MFInvokeCallback(caller);
 984
 985     return S_OK;
 986 }
 987
 988 static const IMFAsyncCallbackVtbl file_scheme_handler_callback_vtbl =
 989 {
 990     file_scheme_handler_callback_QueryInterface,
 991     file_scheme_handler_callback_AddRef,
 992     file_scheme_handler_callback_Release,
 993     file_scheme_handler_callback_GetParameters,
 994     file_scheme_handler_callback_Invoke,
 995 };
 996
 997 static HRESULT file_scheme_handler_construct(REFIID riid, void **obj)
 998 {
 999     struct file_scheme_handler *handler;
1000     HRESULT hr;
1001
1002     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
1003
1004     handler = heap_alloc_zero(sizeof(*handler));
1005     if (!handler)
1006         return E_OUTOFMEMORY;
1007
1008     handler->IMFSchemeHandler_iface.lpVtbl = &file_scheme_handler_vtbl;
1009     handler->IMFAsyncCallback_iface.lpVtbl = &file_scheme_handler_callback_vtbl;
1010     handler->refcount = 1;
1011     list_init(&handler->results);
1012     InitializeCriticalSection(&handler->cs);
1013
1014     hr = IMFSchemeHandler_QueryInterface(&handler->IMFSchemeHandler_iface, riid, obj);
1015     IMFSchemeHandler_Release(&handler->IMFSchemeHandler_iface);
1016
1017     return hr;
1018 }
1019
1020 static struct class_factory file_scheme_handler_factory = { { &class_factory_vtbl }, file_scheme_handler_construct };
1021
1022 static const struct class_object
1023 {
1024     const GUID *clsid;
1025     IClassFactory *factory;
1026 }
1027 class_objects[] =
1028 {
1029     { &CLSID_FileSchemePlugin, &file_scheme_handler_factory.IClassFactory_iface },
1030 };
1031
1032 /*******************************************************************************
1033  *      DllGetClassObject (mf.@)
1034  */
1035 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **obj)
1036 {
1037     unsigned int i;
1038
1039     TRACE("%s, %s, %p.\n", debugstr_guid(rclsid), debugstr_guid(riid), obj);
1040
1041     for (i = 0; i < ARRAY_SIZE(class_objects); ++i)
1042     {
1043         if (IsEqualGUID(class_objects[i].clsid, rclsid))
1044             return IClassFactory_QueryInterface(class_objects[i].factory, riid, obj);
1045     }
1046
1047     WARN("%s: class not found.\n", debugstr_guid(rclsid));
1048     return CLASS_E_CLASSNOTAVAILABLE;
1049 }
1050
1051 /******************************************************************
1052  *              DllCanUnloadNow (mf.@)
1053  */
1054 HRESULT WINAPI DllCanUnloadNow(void)
1055 {
1056     return S_FALSE;
1057 }
1058
1059 /***********************************************************************
1060  *          DllRegisterServer (mf.@)
1061  */
1062 HRESULT WINAPI DllRegisterServer(void)
1063 {
1064     return __wine_register_resources( mf_instance );
1065 }
1066
1067 /***********************************************************************
1068  *          DllUnregisterServer (mf.@)
1069  */
1070 HRESULT WINAPI DllUnregisterServer(void)
1071 {
1072     return __wine_unregister_resources( mf_instance );
1073 }
1074
1075 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
1076 {
1077     switch (reason)
1078     {
1079         case DLL_WINE_PREATTACH:
1080             return FALSE;    /* prefer native version */
1081         case DLL_PROCESS_ATTACH:
1082             mf_instance = instance;
1083             DisableThreadLibraryCalls(instance);
1084             break;
1085     }
1086
1087     return TRUE;
1088 }
1089
1090 static HRESULT prop_string_vector_append(PROPVARIANT *vector, unsigned int *capacity, BOOL unique, const WCHAR *str)
1091 {
1092     WCHAR *ptrW;
1093     int len, i;
1094
1095     if (unique)
1096     {
1097         for (i = 0; i < vector->calpwstr.cElems; ++i)
1098         {
1099             if (!lstrcmpW(vector->calpwstr.pElems[i], str))
1100                 return S_OK;
1101         }
1102     }
1103
1104     if (!*capacity || *capacity - 1 < vector->calpwstr.cElems)
1105     {
1106         unsigned int new_count;
1107         WCHAR **ptr;
1108
1109         new_count = *capacity ? *capacity * 2 : 10;
1110         ptr = CoTaskMemRealloc(vector->calpwstr.pElems, new_count * sizeof(*vector->calpwstr.pElems));
1111         if (!ptr)
1112             return E_OUTOFMEMORY;
1113         vector->calpwstr.pElems = ptr;
1114         *capacity = new_count;
1115     }
1116
1117     len = lstrlenW(str);
1118     if (!(vector->calpwstr.pElems[vector->calpwstr.cElems] = ptrW = CoTaskMemAlloc((len + 1) * sizeof(WCHAR))))
1119         return E_OUTOFMEMORY;
1120
1121     lstrcpyW(ptrW, str);
1122     vector->calpwstr.cElems++;
1123
1124     return S_OK;
1125 }
1126
1127 static int __cdecl qsort_string_compare(const void *a, const void *b)
1128 {
1129     const WCHAR *left = *(const WCHAR **)a, *right = *(const WCHAR **)b;
1130     return lstrcmpW(left, right);
1131 }
1132
1133 static HRESULT mf_get_handler_strings(const WCHAR *path, WCHAR filter, unsigned int maxlen, PROPVARIANT *dst)
1134 {
1135     static const HKEY hkey_roots[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
1136     unsigned int capacity = 0, count, size;
1137     HRESULT hr = S_OK;
1138     int i, index;
1139     WCHAR *buffW;
1140
1141     buffW = heap_calloc(maxlen, sizeof(*buffW));
1142     if (!buffW)
1143         return E_OUTOFMEMORY;
1144
1145     memset(dst, 0, sizeof(*dst));
1146     dst->vt = VT_VECTOR | VT_LPWSTR;
1147
1148     for (i = 0; i < ARRAY_SIZE(hkey_roots); ++i)
1149     {
1150         HKEY hkey;
1151
1152         if (RegOpenKeyW(hkey_roots[i], path, &hkey))
1153             continue;
1154
1155         index = 0;
1156         size = maxlen;
1157         count = dst->calpwstr.cElems;
1158         while (!RegEnumKeyExW(hkey, index++, buffW, &size, NULL, NULL, NULL, NULL))
1159         {
1160             if (filter && !wcschr(buffW, filter))
1161                 continue;
1162
1163             if (FAILED(hr = prop_string_vector_append(dst, &capacity, i > 0, buffW)))
1164                 break;
1165             size = maxlen;
1166         }
1167
1168         /* Sort last pass results. */
1169         qsort(&dst->calpwstr.pElems[count], dst->calpwstr.cElems - count, sizeof(*dst->calpwstr.pElems),
1170                 qsort_string_compare);
1171
1172         RegCloseKey(hkey);
1173     }
1174
1175     if (FAILED(hr))
1176         PropVariantClear(dst);
1177
1178     heap_free(buffW);
1179
1180     return hr;
1181 }
1182
1183 /***********************************************************************
1184  *      MFGetSupportedMimeTypes (mf.@)
1185  */
1186 HRESULT WINAPI MFGetSupportedMimeTypes(PROPVARIANT *dst)
1187 {
1188     unsigned int maxlen;
1189
1190     TRACE("%p.\n", dst);
1191
1192     if (!dst)
1193         return E_POINTER;
1194
1195     /* According to RFC4288 it's 127/127 characters. */
1196     maxlen = 127 /* type */ + 1 /* / */ + 127 /* subtype */ + 1;
1197     return mf_get_handler_strings(L"Software\\Microsoft\\Windows Media Foundation\\ByteStreamHandlers", '/',
1198             maxlen,  dst);
1199 }
1200
1201 /***********************************************************************
1202  *      MFGetSupportedSchemes (mf.@)
1203  */
1204 HRESULT WINAPI MFGetSupportedSchemes(PROPVARIANT *dst)
1205 {
1206     TRACE("%p.\n", dst);
1207
1208     if (!dst)
1209         return E_POINTER;
1210
1211     return mf_get_handler_strings(L"Software\\Microsoft\\Windows Media Foundation\\SchemeHandlers", 0, 64, dst);
1212 }
1213
1214 /***********************************************************************
1215  *      MFGetService (mf.@)
1216  */
1217 HRESULT WINAPI MFGetService(IUnknown *object, REFGUID service, REFIID riid, void **obj)
1218 {
1219     IMFGetService *gs;
1220     HRESULT hr;
1221
1222     TRACE("(%p, %s, %s, %p)\n", object, debugstr_guid(service), debugstr_guid(riid), obj);
1223
1224     if (!object)
1225         return E_POINTER;
1226
1227     if (FAILED(hr = IUnknown_QueryInterface(object, &IID_IMFGetService, (void **)&gs)))
1228         return hr;
1229
1230     hr = IMFGetService_GetService(gs, service, riid, obj);
1231     IMFGetService_Release(gs);
1232     return hr;
1233 }
1234
1235 /***********************************************************************
1236  *      MFShutdownObject (mf.@)
1237  */
1238 HRESULT WINAPI MFShutdownObject(IUnknown *object)
1239 {
1240     IMFShutdown *shutdown;
1241
1242     TRACE("%p.\n", object);
1243
1244     if (object && SUCCEEDED(IUnknown_QueryInterface(object, &IID_IMFShutdown, (void **)&shutdown)))
1245     {
1246         IMFShutdown_Shutdown(shutdown);
1247         IMFShutdown_Release(shutdown);
1248     }
1249
1250     return S_OK;
1251 }
1252
1253 /***********************************************************************
1254  *      MFEnumDeviceSources (mf.@)
1255  */
1256 HRESULT WINAPI MFEnumDeviceSources(IMFAttributes *attributes, IMFActivate ***sources, UINT32 *count)
1257 {
1258     FIXME("%p, %p, %p.\n", attributes, sources, count);
1259
1260     if (!attributes || !sources || !count)
1261         return E_INVALIDARG;
1262
1263     *count = 0;
1264
1265     return S_OK;
1266 }
1267
1268 struct simple_type_handler
1269 {
1270     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
1271     LONG refcount;
1272     IMFMediaType *media_type;
1273     CRITICAL_SECTION cs;
1274 };
1275
1276 static struct simple_type_handler *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
1277 {
1278     return CONTAINING_RECORD(iface, struct simple_type_handler, IMFMediaTypeHandler_iface);
1279 }
1280
1281 static HRESULT WINAPI simple_type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid, void **obj)
1282 {
1283     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1284
1285     if (IsEqualIID(riid, &IID_IMFMediaTypeHandler) ||
1286             IsEqualIID(riid, &IID_IUnknown))
1287     {
1288         *obj = iface;
1289         IMFMediaTypeHandler_AddRef(iface);
1290         return S_OK;
1291     }
1292
1293     *obj = NULL;
1294     return E_NOINTERFACE;
1295 }
1296
1297 static ULONG WINAPI simple_type_handler_AddRef(IMFMediaTypeHandler *iface)
1298 {
1299     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1300     ULONG refcount = InterlockedIncrement(&handler->refcount);
1301
1302     TRACE("%p, refcount %u.\n", iface, refcount);
1303
1304     return refcount;
1305 }
1306
1307 static ULONG WINAPI simple_type_handler_Release(IMFMediaTypeHandler *iface)
1308 {
1309     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1310     ULONG refcount = InterlockedDecrement(&handler->refcount);
1311
1312     TRACE("%p, refcount %u.\n", iface, refcount);
1313
1314     if (!refcount)
1315     {
1316         if (handler->media_type)
1317             IMFMediaType_Release(handler->media_type);
1318         DeleteCriticalSection(&handler->cs);
1319         heap_free(handler);
1320     }
1321
1322     return refcount;
1323 }
1324
1325 static HRESULT WINAPI simple_type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface, IMFMediaType *in_type,
1326         IMFMediaType **out_type)
1327 {
1328     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1329     DWORD flags = 0;
1330     HRESULT hr;
1331
1332     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
1333
1334     if (out_type)
1335         *out_type = NULL;
1336
1337     EnterCriticalSection(&handler->cs);
1338     if (!handler->media_type)
1339         hr = MF_E_UNEXPECTED;
1340     else
1341     {
1342         if (SUCCEEDED(hr = IMFMediaType_IsEqual(handler->media_type, in_type, &flags)))
1343             hr = (flags & (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES)) ==
1344                     (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES) ? S_OK : E_FAIL;
1345     }
1346     LeaveCriticalSection(&handler->cs);
1347
1348     return hr;
1349 }
1350
1351 static HRESULT WINAPI simple_type_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
1352 {
1353     TRACE("%p, %p.\n", iface, count);
1354
1355     if (!count)
1356         return E_POINTER;
1357
1358     *count = 1;
1359
1360     return S_OK;
1361 }
1362
1363 static HRESULT WINAPI simple_type_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
1364         IMFMediaType **type)
1365 {
1366     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1367
1368     TRACE("%p, %u, %p.\n", iface, index, type);
1369
1370     if (index > 0)
1371         return MF_E_NO_MORE_TYPES;
1372
1373     EnterCriticalSection(&handler->cs);
1374     *type = handler->media_type;
1375     if (*type)
1376         IMFMediaType_AddRef(*type);
1377     LeaveCriticalSection(&handler->cs);
1378
1379     return S_OK;
1380 }
1381
1382 static HRESULT WINAPI simple_type_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *media_type)
1383 {
1384     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1385
1386     TRACE("%p, %p.\n", iface, media_type);
1387
1388     EnterCriticalSection(&handler->cs);
1389     if (handler->media_type)
1390         IMFMediaType_Release(handler->media_type);
1391     handler->media_type = media_type;
1392     if (handler->media_type)
1393         IMFMediaType_AddRef(handler->media_type);
1394     LeaveCriticalSection(&handler->cs);
1395
1396     return S_OK;
1397 }
1398
1399 static HRESULT WINAPI simple_type_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **media_type)
1400 {
1401     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1402
1403     TRACE("%p, %p.\n", iface, media_type);
1404
1405     if (!media_type)
1406         return E_POINTER;
1407
1408     EnterCriticalSection(&handler->cs);
1409     *media_type = handler->media_type;
1410     if (*media_type)
1411         IMFMediaType_AddRef(*media_type);
1412     LeaveCriticalSection(&handler->cs);
1413
1414     return S_OK;
1415 }
1416
1417 static HRESULT WINAPI simple_type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
1418 {
1419     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1420     HRESULT hr;
1421
1422     TRACE("%p, %p.\n", iface, type);
1423
1424     EnterCriticalSection(&handler->cs);
1425     if (handler->media_type)
1426         hr = IMFMediaType_GetGUID(handler->media_type, &MF_MT_MAJOR_TYPE, type);
1427     else
1428         hr = MF_E_NOT_INITIALIZED;
1429     LeaveCriticalSection(&handler->cs);
1430
1431     return hr;
1432 }
1433
1434 static const IMFMediaTypeHandlerVtbl simple_type_handler_vtbl =
1435 {
1436     simple_type_handler_QueryInterface,
1437     simple_type_handler_AddRef,
1438     simple_type_handler_Release,
1439     simple_type_handler_IsMediaTypeSupported,
1440     simple_type_handler_GetMediaTypeCount,
1441     simple_type_handler_GetMediaTypeByIndex,
1442     simple_type_handler_SetCurrentMediaType,
1443     simple_type_handler_GetCurrentMediaType,
1444     simple_type_handler_GetMajorType,
1445 };
1446
1447 HRESULT WINAPI MFCreateSimpleTypeHandler(IMFMediaTypeHandler **handler)
1448 {
1449     struct simple_type_handler *object;
1450
1451     TRACE("%p.\n", handler);
1452
1453     object = heap_alloc_zero(sizeof(*object));
1454     if (!object)
1455         return E_OUTOFMEMORY;
1456
1457     object->IMFMediaTypeHandler_iface.lpVtbl = &simple_type_handler_vtbl;
1458     object->refcount = 1;
1459     InitializeCriticalSection(&object->cs);
1460
1461     *handler = &object->IMFMediaTypeHandler_iface;
1462
1463     return S_OK;
1464 }
1465
1466 enum sample_copier_flags
1467 {
1468     SAMPLE_COPIER_INPUT_TYPE_SET = 0x1,
1469     SAMPLE_COPIER_OUTPUT_TYPE_SET = 0x2
1470 };
1471
1472 struct sample_copier
1473 {
1474     IMFTransform IMFTransform_iface;
1475     LONG refcount;
1476
1477     IMFAttributes *attributes;
1478     IMFMediaType *buffer_type;
1479     DWORD buffer_size;
1480     IMFSample *sample;
1481     DWORD flags;
1482     CRITICAL_SECTION cs;
1483 };
1484
1485 static struct sample_copier *impl_copier_from_IMFTransform(IMFTransform *iface)
1486 {
1487     return CONTAINING_RECORD(iface, struct sample_copier, IMFTransform_iface);
1488 }
1489
1490 static HRESULT WINAPI sample_copier_transform_QueryInterface(IMFTransform *iface, REFIID riid, void **obj)
1491 {
1492     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1493
1494     if (IsEqualIID(riid, &IID_IMFTransform) ||
1495             IsEqualIID(riid, &IID_IUnknown))
1496     {
1497         *obj = iface;
1498         IMFTransform_AddRef(iface);
1499         return S_OK;
1500     }
1501
1502     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1503     *obj = NULL;
1504     return E_NOINTERFACE;
1505 }
1506
1507 static ULONG WINAPI sample_copier_transform_AddRef(IMFTransform *iface)
1508 {
1509     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1510     ULONG refcount = InterlockedIncrement(&transform->refcount);
1511
1512     TRACE("%p, refcount %u.\n", iface, refcount);
1513
1514     return refcount;
1515 }
1516
1517 static ULONG WINAPI sample_copier_transform_Release(IMFTransform *iface)
1518 {
1519     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1520     ULONG refcount = InterlockedDecrement(&transform->refcount);
1521
1522     TRACE("%p, refcount %u.\n", iface, refcount);
1523
1524     if (!refcount)
1525     {
1526         IMFAttributes_Release(transform->attributes);
1527         if (transform->buffer_type)
1528             IMFMediaType_Release(transform->buffer_type);
1529         DeleteCriticalSection(&transform->cs);
1530         heap_free(transform);
1531     }
1532
1533     return refcount;
1534 }
1535
1536 static HRESULT WINAPI sample_copier_transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum,
1537         DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum)
1538 {
1539     TRACE("%p, %p, %p, %p, %p.\n", iface, input_minimum, input_maximum, output_minimum, output_maximum);
1540
1541     *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
1542
1543     return S_OK;
1544 }
1545
1546 static HRESULT WINAPI sample_copier_transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
1547 {
1548     TRACE("%p, %p, %p.\n", iface, inputs, outputs);
1549
1550     *inputs = 1;
1551     *outputs = 1;
1552
1553     return S_OK;
1554 }
1555
1556 static HRESULT WINAPI sample_copier_transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
1557         DWORD output_size, DWORD *outputs)
1558 {
1559     TRACE("%p, %u, %p, %u, %p.\n", iface, input_size, inputs, output_size, outputs);
1560
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT WINAPI sample_copier_transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
1565 {
1566     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1567
1568     TRACE("%p, %u, %p.\n", iface, id, info);
1569
1570     memset(info, 0, sizeof(*info));
1571
1572     EnterCriticalSection(&transform->cs);
1573     info->cbSize = transform->buffer_size;
1574     LeaveCriticalSection(&transform->cs);
1575
1576     return S_OK;
1577 }
1578
1579 static HRESULT WINAPI sample_copier_transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id,
1580         MFT_OUTPUT_STREAM_INFO *info)
1581 {
1582     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1583
1584     TRACE("%p, %u, %p.\n", iface, id, info);
1585
1586     memset(info, 0, sizeof(*info));
1587
1588     EnterCriticalSection(&transform->cs);
1589     info->cbSize = transform->buffer_size;
1590     LeaveCriticalSection(&transform->cs);
1591
1592     return S_OK;
1593 }
1594
1595 static HRESULT WINAPI sample_copier_transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
1596 {
1597     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1598
1599     TRACE("%p, %p.\n", iface, attributes);
1600
1601     *attributes = transform->attributes;
1602     IMFAttributes_AddRef(*attributes);
1603
1604     return S_OK;
1605 }
1606
1607 static HRESULT WINAPI sample_copier_transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id,
1608         IMFAttributes **attributes)
1609 {
1610     TRACE("%p, %u, %p.\n", iface, id, attributes);
1611
1612     return E_NOTIMPL;
1613 }
1614
1615 static HRESULT WINAPI sample_copier_transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id,
1616         IMFAttributes **attributes)
1617 {
1618     TRACE("%p, %u, %p.\n", iface, id, attributes);
1619
1620     return E_NOTIMPL;
1621 }
1622
1623 static HRESULT WINAPI sample_copier_transform_DeleteInputStream(IMFTransform *iface, DWORD id)
1624 {
1625     TRACE("%p, %u.\n", iface, id);
1626
1627     return E_NOTIMPL;
1628 }
1629
1630 static HRESULT WINAPI sample_copier_transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
1631 {
1632     TRACE("%p, %u, %p.\n", iface, streams, ids);
1633
1634     return E_NOTIMPL;
1635 }
1636
1637 static HRESULT WINAPI sample_copier_transform_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
1638         IMFMediaType **type)
1639 {
1640     static const GUID *types[] = { &MFMediaType_Video, &MFMediaType_Audio };
1641     HRESULT hr;
1642
1643     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
1644
1645     if (id)
1646         return MF_E_INVALIDSTREAMNUMBER;
1647
1648     if (index > ARRAY_SIZE(types) - 1)
1649         return MF_E_NO_MORE_TYPES;
1650
1651     if (SUCCEEDED(hr = MFCreateMediaType(type)))
1652         hr = IMFMediaType_SetGUID(*type, &MF_MT_MAJOR_TYPE, types[index]);
1653
1654     return hr;
1655 }
1656
1657 static HRESULT WINAPI sample_copier_transform_GetOutputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
1658         IMFMediaType **type)
1659 {
1660     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1661     IMFMediaType *cloned_type = NULL;
1662     HRESULT hr = S_OK;
1663
1664     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
1665
1666     EnterCriticalSection(&transform->cs);
1667     if (transform->buffer_type)
1668     {
1669         if (SUCCEEDED(hr = MFCreateMediaType(&cloned_type)))
1670             hr = IMFMediaType_CopyAllItems(transform->buffer_type, (IMFAttributes *)cloned_type);
1671     }
1672     else if (id)
1673         hr = MF_E_INVALIDSTREAMNUMBER;
1674     else
1675         hr = MF_E_NO_MORE_TYPES;
1676     LeaveCriticalSection(&transform->cs);
1677
1678     if (SUCCEEDED(hr))
1679         *type = cloned_type;
1680     else if (cloned_type)
1681         IMFMediaType_Release(cloned_type);
1682
1683     return hr;
1684 }
1685
1686 static HRESULT sample_copier_get_buffer_size(IMFMediaType *type, DWORD *size)
1687 {
1688     GUID major, subtype;
1689     UINT64 frame_size;
1690     HRESULT hr;
1691
1692     *size = 0;
1693
1694     if (FAILED(hr = IMFMediaType_GetMajorType(type, &major)))
1695         return hr;
1696
1697     if (IsEqualGUID(&major, &MFMediaType_Video))
1698     {
1699         if (SUCCEEDED(hr = IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
1700         {
1701             if (SUCCEEDED(hr = IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
1702             {
1703                 if (FAILED(hr = MFCalculateImageSize(&subtype, (UINT32)(frame_size >> 32), (UINT32)frame_size, size)))
1704                     WARN("Failed to get image size for video format %s.\n", debugstr_guid(&subtype));
1705             }
1706         }
1707     }
1708     else if (IsEqualGUID(&major, &MFMediaType_Audio))
1709     {
1710         FIXME("Audio formats are not handled.\n");
1711         hr = E_NOTIMPL;
1712     }
1713
1714     return hr;
1715 }
1716
1717 static HRESULT sample_copier_set_media_type(struct sample_copier *transform, BOOL input, DWORD id, IMFMediaType *type,
1718         DWORD flags)
1719 {
1720     DWORD buffer_size;
1721     HRESULT hr = S_OK;
1722
1723     if (id)
1724         return MF_E_INVALIDSTREAMNUMBER;
1725
1726     EnterCriticalSection(&transform->cs);
1727     if (type)
1728     {
1729         hr = sample_copier_get_buffer_size(type, &buffer_size);
1730         if (!(flags & MFT_SET_TYPE_TEST_ONLY) && SUCCEEDED(hr))
1731         {
1732             if (!transform->buffer_type)
1733                 hr = MFCreateMediaType(&transform->buffer_type);
1734             if (SUCCEEDED(hr))
1735                 hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)transform->buffer_type);
1736             if (SUCCEEDED(hr))
1737                 transform->buffer_size = buffer_size;
1738
1739             if (SUCCEEDED(hr))
1740             {
1741                 if (input)
1742                 {
1743                     transform->flags |= SAMPLE_COPIER_INPUT_TYPE_SET;
1744                     transform->flags &= ~SAMPLE_COPIER_OUTPUT_TYPE_SET;
1745                 }
1746                 else
1747                     transform->flags |= SAMPLE_COPIER_OUTPUT_TYPE_SET;
1748             }
1749         }
1750     }
1751     else if (transform->buffer_type)
1752     {
1753         IMFMediaType_Release(transform->buffer_type);
1754         transform->buffer_type = NULL;
1755     }
1756     LeaveCriticalSection(&transform->cs);
1757
1758     return hr;
1759 }
1760
1761 static HRESULT WINAPI sample_copier_transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
1762 {
1763     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1764
1765     TRACE("%p, %u, %p, %#x.\n", iface, id, type, flags);
1766
1767     return sample_copier_set_media_type(transform, TRUE, id, type, flags);
1768 }
1769
1770 static HRESULT WINAPI sample_copier_transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
1771 {
1772     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1773
1774     TRACE("%p, %u, %p, %#x.\n", iface, id, type, flags);
1775
1776     return sample_copier_set_media_type(transform, FALSE, id, type, flags);
1777 }
1778
1779 static HRESULT sample_copier_get_current_type(struct sample_copier *transform, DWORD id, DWORD flags,
1780         IMFMediaType **ret)
1781 {
1782     IMFMediaType *cloned_type = NULL;
1783     HRESULT hr;
1784
1785     if (id)
1786         return MF_E_INVALIDSTREAMNUMBER;
1787
1788     EnterCriticalSection(&transform->cs);
1789     if (transform->flags & flags)
1790     {
1791         if (SUCCEEDED(hr = MFCreateMediaType(&cloned_type)))
1792             hr = IMFMediaType_CopyAllItems(transform->buffer_type, (IMFAttributes *)cloned_type);
1793     }
1794     else
1795         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1796     LeaveCriticalSection(&transform->cs);
1797
1798     if (SUCCEEDED(hr))
1799         *ret = cloned_type;
1800     else if (cloned_type)
1801         IMFMediaType_Release(cloned_type);
1802
1803     return hr;
1804 }
1805
1806 static HRESULT WINAPI sample_copier_transform_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
1807 {
1808     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1809
1810     TRACE("%p, %u, %p.\n", iface, id, type);
1811
1812     return sample_copier_get_current_type(transform, id, SAMPLE_COPIER_INPUT_TYPE_SET, type);
1813 }
1814
1815 static HRESULT WINAPI sample_copier_transform_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
1816 {
1817     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1818
1819     TRACE("%p, %u, %p.\n", iface, id, type);
1820
1821     return sample_copier_get_current_type(transform, id, SAMPLE_COPIER_OUTPUT_TYPE_SET, type);
1822 }
1823
1824 static HRESULT WINAPI sample_copier_transform_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags)
1825 {
1826     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1827     HRESULT hr = S_OK;
1828
1829     TRACE("%p, %u, %p.\n", iface, id, flags);
1830
1831     if (id)
1832         return MF_E_INVALIDSTREAMNUMBER;
1833
1834     EnterCriticalSection(&transform->cs);
1835     if (!(transform->flags & SAMPLE_COPIER_INPUT_TYPE_SET))
1836         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1837     else
1838         *flags = transform->sample ? 0 : MFT_INPUT_STATUS_ACCEPT_DATA;
1839     LeaveCriticalSection(&transform->cs);
1840
1841     return hr;
1842 }
1843
1844 static HRESULT WINAPI sample_copier_transform_GetOutputStatus(IMFTransform *iface, DWORD *flags)
1845 {
1846     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1847     HRESULT hr = S_OK;
1848
1849     TRACE("%p, %p.\n", iface, flags);
1850
1851     EnterCriticalSection(&transform->cs);
1852     if (!(transform->flags & SAMPLE_COPIER_OUTPUT_TYPE_SET))
1853         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1854     else
1855         *flags = transform->sample ? MFT_OUTPUT_STATUS_SAMPLE_READY : 0;
1856     LeaveCriticalSection(&transform->cs);
1857
1858     return hr;
1859 }
1860
1861 static HRESULT WINAPI sample_copier_transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
1862 {
1863     TRACE("%p, %s, %s.\n", iface, debugstr_time(lower), debugstr_time(upper));
1864
1865     return E_NOTIMPL;
1866 }
1867
1868 static HRESULT WINAPI sample_copier_transform_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event)
1869 {
1870     FIXME("%p, %u, %p.\n", iface, id, event);
1871
1872     return E_NOTIMPL;
1873 }
1874
1875 static HRESULT WINAPI sample_copier_transform_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param)
1876 {
1877     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1878
1879     TRACE("%p, %#x, %p.\n", iface, message, (void *)param);
1880
1881     EnterCriticalSection(&transform->cs);
1882
1883     if (message == MFT_MESSAGE_COMMAND_FLUSH)
1884     {
1885         if (transform->sample)
1886         {
1887             IMFSample_Release(transform->sample);
1888             transform->sample = NULL;
1889         }
1890     }
1891
1892     LeaveCriticalSection(&transform->cs);
1893
1894     return S_OK;
1895 }
1896
1897 static HRESULT WINAPI sample_copier_transform_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags)
1898 {
1899     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1900     HRESULT hr = S_OK;
1901
1902     TRACE("%p, %u, %p, %#x.\n", iface, id, sample, flags);
1903
1904     if (id)
1905         return MF_E_INVALIDSTREAMNUMBER;
1906
1907     EnterCriticalSection(&transform->cs);
1908     if (!transform->buffer_type)
1909         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1910     else if (transform->sample)
1911         hr = MF_E_NOTACCEPTING;
1912     else
1913     {
1914         transform->sample = sample;
1915         IMFSample_AddRef(transform->sample);
1916     }
1917     LeaveCriticalSection(&transform->cs);
1918
1919     return hr;
1920 }
1921
1922 static HRESULT WINAPI sample_copier_transform_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count,
1923         MFT_OUTPUT_DATA_BUFFER *buffers, DWORD *status)
1924 {
1925     struct sample_copier *transform = impl_copier_from_IMFTransform(iface);
1926     IMFMediaBuffer *buffer;
1927     DWORD sample_flags;
1928     HRESULT hr = S_OK;
1929     LONGLONG time;
1930
1931     TRACE("%p, %#x, %u, %p, %p.\n", iface, flags, count, buffers, status);
1932
1933     EnterCriticalSection(&transform->cs);
1934     if (!(transform->flags & SAMPLE_COPIER_OUTPUT_TYPE_SET))
1935         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1936     else if (!transform->sample)
1937         hr = MF_E_TRANSFORM_NEED_MORE_INPUT;
1938     else
1939     {
1940         IMFSample_CopyAllItems(transform->sample, (IMFAttributes *)buffers->pSample);
1941
1942         if (SUCCEEDED(IMFSample_GetSampleDuration(transform->sample, &time)))
1943             IMFSample_SetSampleDuration(buffers->pSample, time);
1944
1945         if (SUCCEEDED(IMFSample_GetSampleTime(transform->sample, &time)))
1946             IMFSample_SetSampleTime(buffers->pSample, time);
1947
1948         if (SUCCEEDED(IMFSample_GetSampleFlags(transform->sample, &sample_flags)))
1949             IMFSample_SetSampleFlags(buffers->pSample, sample_flags);
1950
1951         if (SUCCEEDED(IMFSample_ConvertToContiguousBuffer(transform->sample, NULL)))
1952         {
1953             if (SUCCEEDED(IMFSample_GetBufferByIndex(buffers->pSample, 0, &buffer)))
1954             {
1955                 if (FAILED(IMFSample_CopyToBuffer(transform->sample, buffer)))
1956                     hr = MF_E_UNEXPECTED;
1957                 IMFMediaBuffer_Release(buffer);
1958             }
1959         }
1960
1961         IMFSample_Release(transform->sample);
1962         transform->sample = NULL;
1963     }
1964     LeaveCriticalSection(&transform->cs);
1965
1966     return hr;
1967 }
1968
1969 static const IMFTransformVtbl sample_copier_transform_vtbl =
1970 {
1971     sample_copier_transform_QueryInterface,
1972     sample_copier_transform_AddRef,
1973     sample_copier_transform_Release,
1974     sample_copier_transform_GetStreamLimits,
1975     sample_copier_transform_GetStreamCount,
1976     sample_copier_transform_GetStreamIDs,
1977     sample_copier_transform_GetInputStreamInfo,
1978     sample_copier_transform_GetOutputStreamInfo,
1979     sample_copier_transform_GetAttributes,
1980     sample_copier_transform_GetInputStreamAttributes,
1981     sample_copier_transform_GetOutputStreamAttributes,
1982     sample_copier_transform_DeleteInputStream,
1983     sample_copier_transform_AddInputStreams,
1984     sample_copier_transform_GetInputAvailableType,
1985     sample_copier_transform_GetOutputAvailableType,
1986     sample_copier_transform_SetInputType,
1987     sample_copier_transform_SetOutputType,
1988     sample_copier_transform_GetInputCurrentType,
1989     sample_copier_transform_GetOutputCurrentType,
1990     sample_copier_transform_GetInputStatus,
1991     sample_copier_transform_GetOutputStatus,
1992     sample_copier_transform_SetOutputBounds,
1993     sample_copier_transform_ProcessEvent,
1994     sample_copier_transform_ProcessMessage,
1995     sample_copier_transform_ProcessInput,
1996     sample_copier_transform_ProcessOutput,
1997 };
1998
1999 HRESULT WINAPI MFCreateSampleCopierMFT(IMFTransform **transform)
2000 {
2001     struct sample_copier *object;
2002
2003     TRACE("%p.\n", transform);
2004
2005     object = heap_alloc_zero(sizeof(*object));
2006     if (!object)
2007         return E_OUTOFMEMORY;
2008
2009     object->IMFTransform_iface.lpVtbl = &sample_copier_transform_vtbl;
2010     object->refcount = 1;
2011     MFCreateAttributes(&object->attributes, 0);
2012     InitializeCriticalSection(&object->cs);
2013
2014     *transform = &object->IMFTransform_iface;
2015
2016     return S_OK;
2017 }