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