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