dlls/mf/main.c

   1 /*
   2  * Copyright (C) 2015 Austin English
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "mfidl.h"
  27 #include "rpcproxy.h"
  28
  29 #include "mf_private.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/list.h"
  33 #include "wine/mfinternal.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  36
  37 extern const GUID CLSID_FileSchemePlugin;
  38
  39 struct activate_object
  40 {
  41     IMFActivate IMFActivate_iface;
  42     LONG refcount;
  43     IMFAttributes *attributes;
  44     IUnknown *object;
  45     const struct activate_funcs *funcs;
  46     void *context;
  47 };
  48
  49 static struct activate_object *impl_from_IMFActivate(IMFActivate *iface)
  50 {
  51     return CONTAINING_RECORD(iface, struct activate_object, IMFActivate_iface);
  52 }
  53
  54 static HRESULT WINAPI activate_object_QueryInterface(IMFActivate *iface, REFIID riid, void **obj)
  55 {
  56     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  57
  58     if (IsEqualIID(riid, &IID_IMFActivate) ||
  59             IsEqualIID(riid, &IID_IMFAttributes) ||
  60             IsEqualIID(riid, &IID_IUnknown))
  61     {
  62         *obj = iface;
  63         IMFActivate_AddRef(iface);
  64         return S_OK;
  65     }
  66
  67     WARN("Unsupported %s.\n", debugstr_guid(riid));
  68     *obj = NULL;
  69     return E_NOINTERFACE;
  70 }
  71
  72 static ULONG WINAPI activate_object_AddRef(IMFActivate *iface)
  73 {
  74     struct activate_object *activate = impl_from_IMFActivate(iface);
  75     ULONG refcount = InterlockedIncrement(&activate->refcount);
  76
  77     TRACE("%p, refcount %lu.\n", iface, refcount);
  78
  79     return refcount;
  80 }
  81
  82 static ULONG WINAPI activate_object_Release(IMFActivate *iface)
  83 {
  84     struct activate_object *activate = impl_from_IMFActivate(iface);
  85     ULONG refcount = InterlockedDecrement(&activate->refcount);
  86
  87     TRACE("%p, refcount %lu.\n", iface, refcount);
  88
  89     if (!refcount)
  90     {
  91         if (activate->funcs->free_private)
  92             activate->funcs->free_private(activate->context);
  93         if (activate->object)
  94             IUnknown_Release(activate->object);
  95         IMFAttributes_Release(activate->attributes);
  96         free(activate);
  97     }
  98
  99     return refcount;
 100 }
 101
 102 static HRESULT WINAPI activate_object_GetItem(IMFActivate *iface, REFGUID key, PROPVARIANT *value)
 103 {
 104     struct activate_object *activate = impl_from_IMFActivate(iface);
 105
 106     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 107
 108     return IMFAttributes_GetItem(activate->attributes, key, value);
 109 }
 110
 111 static HRESULT WINAPI activate_object_GetItemType(IMFActivate *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 112 {
 113     struct activate_object *activate = impl_from_IMFActivate(iface);
 114
 115     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
 116
 117     return IMFAttributes_GetItemType(activate->attributes, key, type);
 118 }
 119
 120 static HRESULT WINAPI activate_object_CompareItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 121 {
 122     struct activate_object *activate = impl_from_IMFActivate(iface);
 123
 124     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
 125
 126     return IMFAttributes_CompareItem(activate->attributes, key, value, result);
 127 }
 128
 129 static HRESULT WINAPI activate_object_Compare(IMFActivate *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
 130         BOOL *result)
 131 {
 132     struct activate_object *activate = impl_from_IMFActivate(iface);
 133
 134     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
 135
 136     return IMFAttributes_Compare(activate->attributes, theirs, type, result);
 137 }
 138
 139 static HRESULT WINAPI activate_object_GetUINT32(IMFActivate *iface, REFGUID key, UINT32 *value)
 140 {
 141     struct activate_object *activate = impl_from_IMFActivate(iface);
 142
 143     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 144
 145     return IMFAttributes_GetUINT32(activate->attributes, key, value);
 146 }
 147
 148 static HRESULT WINAPI activate_object_GetUINT64(IMFActivate *iface, REFGUID key, UINT64 *value)
 149 {
 150     struct activate_object *activate = impl_from_IMFActivate(iface);
 151
 152     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 153
 154     return IMFAttributes_GetUINT64(activate->attributes, key, value);
 155 }
 156
 157 static HRESULT WINAPI activate_object_GetDouble(IMFActivate *iface, REFGUID key, double *value)
 158 {
 159     struct activate_object *activate = impl_from_IMFActivate(iface);
 160
 161     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 162
 163     return IMFAttributes_GetDouble(activate->attributes, key, value);
 164 }
 165
 166 static HRESULT WINAPI activate_object_GetGUID(IMFActivate *iface, REFGUID key, GUID *value)
 167 {
 168     struct activate_object *activate = impl_from_IMFActivate(iface);
 169
 170     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 171
 172     return IMFAttributes_GetGUID(activate->attributes, key, value);
 173 }
 174
 175 static HRESULT WINAPI activate_object_GetStringLength(IMFActivate *iface, REFGUID key, UINT32 *length)
 176 {
 177     struct activate_object *activate = impl_from_IMFActivate(iface);
 178
 179     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
 180
 181     return IMFAttributes_GetStringLength(activate->attributes, key, length);
 182 }
 183
 184 static HRESULT WINAPI activate_object_GetString(IMFActivate *iface, REFGUID key, WCHAR *value,
 185         UINT32 size, UINT32 *length)
 186 {
 187     struct activate_object *activate = impl_from_IMFActivate(iface);
 188
 189     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), value, size, length);
 190
 191     return IMFAttributes_GetString(activate->attributes, key, value, size, length);
 192 }
 193
 194 static HRESULT WINAPI activate_object_GetAllocatedString(IMFActivate *iface, REFGUID key,
 195         WCHAR **value, UINT32 *length)
 196 {
 197     struct activate_object *activate = impl_from_IMFActivate(iface);
 198
 199     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
 200
 201     return IMFAttributes_GetAllocatedString(activate->attributes, key, value, length);
 202 }
 203
 204 static HRESULT WINAPI activate_object_GetBlobSize(IMFActivate *iface, REFGUID key, UINT32 *size)
 205 {
 206     struct activate_object *activate = impl_from_IMFActivate(iface);
 207
 208     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
 209
 210     return IMFAttributes_GetBlobSize(activate->attributes, key, size);
 211 }
 212
 213 static HRESULT WINAPI activate_object_GetBlob(IMFActivate *iface, REFGUID key, UINT8 *buf,
 214         UINT32 bufsize, UINT32 *blobsize)
 215 {
 216     struct activate_object *activate = impl_from_IMFActivate(iface);
 217
 218     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
 219
 220     return IMFAttributes_GetBlob(activate->attributes, key, buf, bufsize, blobsize);
 221 }
 222
 223 static HRESULT WINAPI activate_object_GetAllocatedBlob(IMFActivate *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 224 {
 225     struct activate_object *activate = impl_from_IMFActivate(iface);
 226
 227     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
 228
 229     return IMFAttributes_GetAllocatedBlob(activate->attributes, key, buf, size);
 230 }
 231
 232 static HRESULT WINAPI activate_object_GetUnknown(IMFActivate *iface, REFGUID key, REFIID riid, void **ppv)
 233 {
 234     struct activate_object *activate = impl_from_IMFActivate(iface);
 235
 236     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), ppv);
 237
 238     return IMFAttributes_GetUnknown(activate->attributes, key, riid, ppv);
 239 }
 240
 241 static HRESULT WINAPI activate_object_SetItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value)
 242 {
 243     struct activate_object *activate = impl_from_IMFActivate(iface);
 244
 245     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 246
 247     return IMFAttributes_SetItem(activate->attributes, key, value);
 248 }
 249
 250 static HRESULT WINAPI activate_object_DeleteItem(IMFActivate *iface, REFGUID key)
 251 {
 252     struct activate_object *activate = impl_from_IMFActivate(iface);
 253
 254     TRACE("%p, %s.\n", iface, debugstr_guid(key));
 255
 256     return IMFAttributes_DeleteItem(activate->attributes, key);
 257 }
 258
 259 static HRESULT WINAPI activate_object_DeleteAllItems(IMFActivate *iface)
 260 {
 261     struct activate_object *activate = impl_from_IMFActivate(iface);
 262
 263     TRACE("%p.\n", iface);
 264
 265     return IMFAttributes_DeleteAllItems(activate->attributes);
 266 }
 267
 268 static HRESULT WINAPI activate_object_SetUINT32(IMFActivate *iface, REFGUID key, UINT32 value)
 269 {
 270     struct activate_object *activate = impl_from_IMFActivate(iface);
 271
 272     TRACE("%p, %s, %d.\n", iface, debugstr_guid(key), value);
 273
 274     return IMFAttributes_SetUINT32(activate->attributes, key, value);
 275 }
 276
 277 static HRESULT WINAPI activate_object_SetUINT64(IMFActivate *iface, REFGUID key, UINT64 value)
 278 {
 279     struct activate_object *activate = impl_from_IMFActivate(iface);
 280
 281     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
 282
 283     return IMFAttributes_SetUINT64(activate->attributes, key, value);
 284 }
 285
 286 static HRESULT WINAPI activate_object_SetDouble(IMFActivate *iface, REFGUID key, double value)
 287 {
 288     struct activate_object *activate = impl_from_IMFActivate(iface);
 289
 290     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
 291
 292     return IMFAttributes_SetDouble(activate->attributes, key, value);
 293 }
 294
 295 static HRESULT WINAPI activate_object_SetGUID(IMFActivate *iface, REFGUID key, REFGUID value)
 296 {
 297     struct activate_object *activate = impl_from_IMFActivate(iface);
 298
 299     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
 300
 301     return IMFAttributes_SetGUID(activate->attributes, key, value);
 302 }
 303
 304 static HRESULT WINAPI activate_object_SetString(IMFActivate *iface, REFGUID key, const WCHAR *value)
 305 {
 306     struct activate_object *activate = impl_from_IMFActivate(iface);
 307
 308     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
 309
 310     return IMFAttributes_SetString(activate->attributes, key, value);
 311 }
 312
 313 static HRESULT WINAPI activate_object_SetBlob(IMFActivate *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 314 {
 315     struct activate_object *activate = impl_from_IMFActivate(iface);
 316
 317     TRACE("%p, %s, %p, %d.\n", iface, debugstr_guid(key), buf, size);
 318
 319     return IMFAttributes_SetBlob(activate->attributes, key, buf, size);
 320 }
 321
 322 static HRESULT WINAPI activate_object_SetUnknown(IMFActivate *iface, REFGUID key, IUnknown *unknown)
 323 {
 324     struct activate_object *activate = impl_from_IMFActivate(iface);
 325
 326     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(key), unknown);
 327
 328     return IMFAttributes_SetUnknown(activate->attributes, key, unknown);
 329 }
 330
 331 static HRESULT WINAPI activate_object_LockStore(IMFActivate *iface)
 332 {
 333     struct activate_object *activate = impl_from_IMFActivate(iface);
 334
 335     TRACE("%p.\n", iface);
 336
 337     return IMFAttributes_LockStore(activate->attributes);
 338 }
 339
 340 static HRESULT WINAPI activate_object_UnlockStore(IMFActivate *iface)
 341 {
 342     struct activate_object *activate = impl_from_IMFActivate(iface);
 343
 344     TRACE("%p.\n", iface);
 345
 346     return IMFAttributes_UnlockStore(activate->attributes);
 347 }
 348
 349 static HRESULT WINAPI activate_object_GetCount(IMFActivate *iface, UINT32 *count)
 350 {
 351     struct activate_object *activate = impl_from_IMFActivate(iface);
 352
 353     TRACE("%p, %p.\n", iface, count);
 354
 355     return IMFAttributes_GetCount(activate->attributes, count);
 356 }
 357
 358 static HRESULT WINAPI activate_object_GetItemByIndex(IMFActivate *iface, UINT32 index, GUID *key, PROPVARIANT *value)
 359 {
 360     struct activate_object *activate = impl_from_IMFActivate(iface);
 361
 362     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 363
 364     return IMFAttributes_GetItemByIndex(activate->attributes, index, key, value);
 365 }
 366
 367 static HRESULT WINAPI activate_object_CopyAllItems(IMFActivate *iface, IMFAttributes *dest)
 368 {
 369     struct activate_object *activate = impl_from_IMFActivate(iface);
 370
 371     TRACE("%p, %p.\n", iface, dest);
 372
 373     return IMFAttributes_CopyAllItems(activate->attributes, dest);
 374 }
 375
 376 static HRESULT WINAPI activate_object_ActivateObject(IMFActivate *iface, REFIID riid, void **obj)
 377 {
 378     struct activate_object *activate = impl_from_IMFActivate(iface);
 379     IUnknown *object;
 380     HRESULT hr;
 381
 382     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 383
 384     if (!activate->object)
 385     {
 386         if (FAILED(hr = activate->funcs->create_object((IMFAttributes *)iface, activate->context, &object)))
 387             return hr;
 388
 389         if (InterlockedCompareExchangePointer((void **)&activate->object, object, NULL))
 390             IUnknown_Release(object);
 391     }
 392
 393     return IUnknown_QueryInterface(activate->object, riid, obj);
 394 }
 395
 396 static HRESULT WINAPI activate_object_ShutdownObject(IMFActivate *iface)
 397 {
 398     struct activate_object *activate = impl_from_IMFActivate(iface);
 399     IUnknown *object;
 400
 401     TRACE("%p.\n", iface);
 402
 403     if ((object = InterlockedCompareExchangePointer((void **)&activate->object, NULL, activate->object)))
 404     {
 405         activate->funcs->shutdown_object(activate->context, object);
 406         IUnknown_Release(object);
 407     }
 408
 409     return S_OK;
 410 }
 411
 412 static HRESULT WINAPI activate_object_DetachObject(IMFActivate *iface)
 413 {
 414     TRACE("%p.\n", iface);
 415
 416     return E_NOTIMPL;
 417 }
 418
 419 static const IMFActivateVtbl activate_object_vtbl =
 420 {
 421     activate_object_QueryInterface,
 422     activate_object_AddRef,
 423     activate_object_Release,
 424     activate_object_GetItem,
 425     activate_object_GetItemType,
 426     activate_object_CompareItem,
 427     activate_object_Compare,
 428     activate_object_GetUINT32,
 429     activate_object_GetUINT64,
 430     activate_object_GetDouble,
 431     activate_object_GetGUID,
 432     activate_object_GetStringLength,
 433     activate_object_GetString,
 434     activate_object_GetAllocatedString,
 435     activate_object_GetBlobSize,
 436     activate_object_GetBlob,
 437     activate_object_GetAllocatedBlob,
 438     activate_object_GetUnknown,
 439     activate_object_SetItem,
 440     activate_object_DeleteItem,
 441     activate_object_DeleteAllItems,
 442     activate_object_SetUINT32,
 443     activate_object_SetUINT64,
 444     activate_object_SetDouble,
 445     activate_object_SetGUID,
 446     activate_object_SetString,
 447     activate_object_SetBlob,
 448     activate_object_SetUnknown,
 449     activate_object_LockStore,
 450     activate_object_UnlockStore,
 451     activate_object_GetCount,
 452     activate_object_GetItemByIndex,
 453     activate_object_CopyAllItems,
 454     activate_object_ActivateObject,
 455     activate_object_ShutdownObject,
 456     activate_object_DetachObject,
 457 };
 458
 459 HRESULT create_activation_object(void *context, const struct activate_funcs *funcs, IMFActivate **ret)
 460 {
 461     struct activate_object *object;
 462     HRESULT hr;
 463
 464     if (!(object = calloc(1, sizeof(*object))))
 465         return E_OUTOFMEMORY;
 466
 467     object->IMFActivate_iface.lpVtbl = &activate_object_vtbl;
 468     object->refcount = 1;
 469     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
 470     {
 471         free(object);
 472         return hr;
 473     }
 474     object->funcs = funcs;
 475     object->context = context;
 476
 477     *ret = &object->IMFActivate_iface;
 478
 479     return S_OK;
 480 }
 481
 482 struct class_factory
 483 {
 484     IClassFactory IClassFactory_iface;
 485     HRESULT (*create_instance)(REFIID riid, void **obj);
 486 };
 487
 488 static inline struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
 489 {
 490     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
 491 }
 492
 493 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
 494 {
 495     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 496
 497     if (IsEqualGUID(riid, &IID_IClassFactory) ||
 498             IsEqualGUID(riid, &IID_IUnknown))
 499     {
 500         *obj = iface;
 501         IClassFactory_AddRef(iface);
 502         return S_OK;
 503     }
 504
 505     WARN("%s is not supported.\n", debugstr_guid(riid));
 506     *obj = NULL;
 507     return E_NOINTERFACE;
 508 }
 509
 510 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
 511 {
 512     return 2;
 513 }
 514
 515 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
 516 {
 517     return 1;
 518 }
 519
 520 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
 521 {
 522     struct class_factory *factory = impl_from_IClassFactory(iface);
 523
 524     TRACE("%p, %p, %s, %p.\n", iface, outer, debugstr_guid(riid), obj);
 525
 526     if (outer)
 527     {
 528         *obj = NULL;
 529         return CLASS_E_NOAGGREGATION;
 530     }
 531
 532     return factory->create_instance(riid, obj);
 533 }
 534
 535 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL dolock)
 536 {
 537     FIXME("%d.\n", dolock);
 538
 539     return S_OK;
 540 }
 541
 542 static const IClassFactoryVtbl class_factory_vtbl =
 543 {
 544     class_factory_QueryInterface,
 545     class_factory_AddRef,
 546     class_factory_Release,
 547     class_factory_CreateInstance,
 548     class_factory_LockServer,
 549 };
 550
 551 struct file_scheme_handler_result
 552 {
 553     struct list entry;
 554     IMFAsyncResult *result;
 555     MF_OBJECT_TYPE obj_type;
 556     IUnknown *object;
 557 };
 558
 559 struct file_scheme_handler
 560 {
 561     IMFSchemeHandler IMFSchemeHandler_iface;
 562     IMFAsyncCallback IMFAsyncCallback_iface;
 563     LONG refcount;
 564     IMFSourceResolver *resolver;
 565     struct list results;
 566     CRITICAL_SECTION cs;
 567 };
 568
 569 static struct file_scheme_handler *impl_from_IMFSchemeHandler(IMFSchemeHandler *iface)
 570 {
 571     return CONTAINING_RECORD(iface, struct file_scheme_handler, IMFSchemeHandler_iface);
 572 }
 573
 574 static struct file_scheme_handler *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface)
 575 {
 576     return CONTAINING_RECORD(iface, struct file_scheme_handler, IMFAsyncCallback_iface);
 577 }
 578
 579 static HRESULT WINAPI file_scheme_handler_QueryInterface(IMFSchemeHandler *iface, REFIID riid, void **obj)
 580 {
 581     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 582
 583     if (IsEqualIID(riid, &IID_IMFSchemeHandler) ||
 584             IsEqualIID(riid, &IID_IUnknown))
 585     {
 586         *obj = iface;
 587         IMFSchemeHandler_AddRef(iface);
 588         return S_OK;
 589     }
 590
 591     WARN("Unsupported %s.\n", debugstr_guid(riid));
 592     *obj = NULL;
 593     return E_NOINTERFACE;
 594 }
 595
 596 static ULONG WINAPI file_scheme_handler_AddRef(IMFSchemeHandler *iface)
 597 {
 598     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 599     ULONG refcount = InterlockedIncrement(&handler->refcount);
 600
 601     TRACE("%p, refcount %lu.\n", handler, refcount);
 602
 603     return refcount;
 604 }
 605
 606 static ULONG WINAPI file_scheme_handler_Release(IMFSchemeHandler *iface)
 607 {
 608     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 609     ULONG refcount = InterlockedDecrement(&handler->refcount);
 610     struct file_scheme_handler_result *result, *next;
 611
 612     TRACE("%p, refcount %lu.\n", iface, refcount);
 613
 614     if (!refcount)
 615     {
 616         LIST_FOR_EACH_ENTRY_SAFE(result, next, &handler->results, struct file_scheme_handler_result, entry)
 617         {
 618             list_remove(&result->entry);
 619             IMFAsyncResult_Release(result->result);
 620             if (result->object)
 621                 IUnknown_Release(result->object);
 622             free(result);
 623         }
 624         DeleteCriticalSection(&handler->cs);
 625         if (handler->resolver)
 626             IMFSourceResolver_Release(handler->resolver);
 627         free(handler);
 628     }
 629
 630     return refcount;
 631 }
 632
 633 struct create_object_context
 634 {
 635     IUnknown IUnknown_iface;
 636     LONG refcount;
 637
 638     IPropertyStore *props;
 639     WCHAR *url;
 640     DWORD flags;
 641 };
 642
 643 static struct create_object_context *impl_from_IUnknown(IUnknown *iface)
 644 {
 645     return CONTAINING_RECORD(iface, struct create_object_context, IUnknown_iface);
 646 }
 647
 648 static HRESULT WINAPI create_object_context_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 649 {
 650     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 651
 652     if (IsEqualIID(riid, &IID_IUnknown))
 653     {
 654         *obj = iface;
 655         IUnknown_AddRef(iface);
 656         return S_OK;
 657     }
 658
 659     WARN("Unsupported %s.\n", debugstr_guid(riid));
 660     *obj = NULL;
 661     return E_NOINTERFACE;
 662 }
 663
 664 static ULONG WINAPI create_object_context_AddRef(IUnknown *iface)
 665 {
 666     struct create_object_context *context = impl_from_IUnknown(iface);
 667     ULONG refcount = InterlockedIncrement(&context->refcount);
 668
 669     TRACE("%p, refcount %lu.\n", iface, refcount);
 670
 671     return refcount;
 672 }
 673
 674 static ULONG WINAPI create_object_context_Release(IUnknown *iface)
 675 {
 676     struct create_object_context *context = impl_from_IUnknown(iface);
 677     ULONG refcount = InterlockedDecrement(&context->refcount);
 678
 679     TRACE("%p, refcount %lu.\n", iface, refcount);
 680
 681     if (!refcount)
 682     {
 683         if (context->props)
 684             IPropertyStore_Release(context->props);
 685         free(context->url);
 686         free(context);
 687     }
 688
 689     return refcount;
 690 }
 691
 692 static const IUnknownVtbl create_object_context_vtbl =
 693 {
 694     create_object_context_QueryInterface,
 695     create_object_context_AddRef,
 696     create_object_context_Release,
 697 };
 698
 699 static HRESULT WINAPI file_scheme_handler_BeginCreateObject(IMFSchemeHandler *iface, const WCHAR *url, DWORD flags,
 700         IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *state)
 701 {
 702     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 703     struct create_object_context *context;
 704     IMFAsyncResult *caller, *item;
 705     HRESULT hr;
 706
 707     TRACE("%p, %s, %#lx, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state);
 708
 709     if (cancel_cookie)
 710         *cancel_cookie = NULL;
 711
 712     if (FAILED(hr = MFCreateAsyncResult(NULL, callback, state, &caller)))
 713         return hr;
 714
 715     if (!(context = malloc(sizeof(*context))))
 716     {
 717         IMFAsyncResult_Release(caller);
 718         return E_OUTOFMEMORY;
 719     }
 720
 721     context->IUnknown_iface.lpVtbl = &create_object_context_vtbl;
 722     context->refcount = 1;
 723     context->props = props;
 724     if (context->props)
 725         IPropertyStore_AddRef(context->props);
 726     context->flags = flags;
 727     context->url = wcsdup(url);
 728     if (!context->url)
 729     {
 730         IMFAsyncResult_Release(caller);
 731         IUnknown_Release(&context->IUnknown_iface);
 732         return E_OUTOFMEMORY;
 733     }
 734
 735     hr = MFCreateAsyncResult(&context->IUnknown_iface, &handler->IMFAsyncCallback_iface, (IUnknown *)caller, &item);
 736     IUnknown_Release(&context->IUnknown_iface);
 737     if (SUCCEEDED(hr))
 738     {
 739         if (SUCCEEDED(hr = MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_IO, item)))
 740         {
 741             if (cancel_cookie)
 742             {
 743                 *cancel_cookie = (IUnknown *)caller;
 744                 IUnknown_AddRef(*cancel_cookie);
 745             }
 746         }
 747
 748         IMFAsyncResult_Release(item);
 749     }
 750     IMFAsyncResult_Release(caller);
 751
 752     return hr;
 753 }
 754
 755 static HRESULT WINAPI file_scheme_handler_EndCreateObject(IMFSchemeHandler *iface, IMFAsyncResult *result,
 756         MF_OBJECT_TYPE *obj_type, IUnknown **object)
 757 {
 758     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 759     struct file_scheme_handler_result *found = NULL, *cur;
 760     HRESULT hr;
 761
 762     TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object);
 763
 764     EnterCriticalSection(&handler->cs);
 765
 766     LIST_FOR_EACH_ENTRY(cur, &handler->results, struct file_scheme_handler_result, entry)
 767     {
 768         if (result == cur->result)
 769         {
 770             list_remove(&cur->entry);
 771             found = cur;
 772             break;
 773         }
 774     }
 775
 776     LeaveCriticalSection(&handler->cs);
 777
 778     if (found)
 779     {
 780         *obj_type = found->obj_type;
 781         *object = found->object;
 782         hr = IMFAsyncResult_GetStatus(found->result);
 783         IMFAsyncResult_Release(found->result);
 784         free(found);
 785     }
 786     else
 787     {
 788         *obj_type = MF_OBJECT_INVALID;
 789         *object = NULL;
 790         hr = MF_E_UNEXPECTED;
 791     }
 792
 793     return hr;
 794 }
 795
 796 static HRESULT WINAPI file_scheme_handler_CancelObjectCreation(IMFSchemeHandler *iface, IUnknown *cancel_cookie)
 797 {
 798     struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface);
 799     struct file_scheme_handler_result *found = NULL, *cur;
 800
 801     TRACE("%p, %p.\n", iface, cancel_cookie);
 802
 803     EnterCriticalSection(&handler->cs);
 804
 805     LIST_FOR_EACH_ENTRY(cur, &handler->results, struct file_scheme_handler_result, entry)
 806     {
 807         if (cancel_cookie == (IUnknown *)cur->result)
 808         {
 809             list_remove(&cur->entry);
 810             found = cur;
 811             break;
 812         }
 813     }
 814
 815     LeaveCriticalSection(&handler->cs);
 816
 817     if (found)
 818     {
 819         IMFAsyncResult_Release(found->result);
 820         if (found->object)
 821             IUnknown_Release(found->object);
 822         free(found);
 823     }
 824
 825     return found ? S_OK : MF_E_UNEXPECTED;
 826 }
 827
 828 static const IMFSchemeHandlerVtbl file_scheme_handler_vtbl =
 829 {
 830     file_scheme_handler_QueryInterface,
 831     file_scheme_handler_AddRef,
 832     file_scheme_handler_Release,
 833     file_scheme_handler_BeginCreateObject,
 834     file_scheme_handler_EndCreateObject,
 835     file_scheme_handler_CancelObjectCreation,
 836 };
 837
 838 static HRESULT WINAPI file_scheme_handler_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
 839 {
 840     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 841             IsEqualIID(riid, &IID_IUnknown))
 842     {
 843         *obj = iface;
 844         IMFAsyncCallback_AddRef(iface);
 845         return S_OK;
 846     }
 847
 848     WARN("Unsupported %s.\n", debugstr_guid(riid));
 849     *obj = NULL;
 850     return E_NOINTERFACE;
 851 }
 852
 853 static ULONG WINAPI file_scheme_handler_callback_AddRef(IMFAsyncCallback *iface)
 854 {
 855     struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface);
 856     return IMFSchemeHandler_AddRef(&handler->IMFSchemeHandler_iface);
 857 }
 858
 859 static ULONG WINAPI file_scheme_handler_callback_Release(IMFAsyncCallback *iface)
 860 {
 861     struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface);
 862     return IMFSchemeHandler_Release(&handler->IMFSchemeHandler_iface);
 863 }
 864
 865 static HRESULT WINAPI file_scheme_handler_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
 866 {
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT file_scheme_handler_get_resolver(struct file_scheme_handler *handler, IMFSourceResolver **resolver)
 871 {
 872     HRESULT hr;
 873
 874     if (!handler->resolver)
 875     {
 876         IMFSourceResolver *resolver;
 877
 878         if (FAILED(hr = MFCreateSourceResolver(&resolver)))
 879             return hr;
 880
 881         if (InterlockedCompareExchangePointer((void **)&handler->resolver, resolver, NULL))
 882             IMFSourceResolver_Release(resolver);
 883     }
 884
 885     *resolver = handler->resolver;
 886     IMFSourceResolver_AddRef(*resolver);
 887
 888     return S_OK;
 889 }
 890
 891 static HRESULT WINAPI file_scheme_handler_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 892 {
 893     static const WCHAR schemeW[] = {'f','i','l','e',':','/','/'};
 894     struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface);
 895     struct file_scheme_handler_result *handler_result;
 896     MF_OBJECT_TYPE obj_type = MF_OBJECT_INVALID;
 897     IUnknown *object = NULL, *context_object;
 898     struct create_object_context *context;
 899     IMFSourceResolver *resolver;
 900     IMFAsyncResult *caller;
 901     IMFByteStream *stream;
 902     const WCHAR *url;
 903     HRESULT hr;
 904
 905     caller = (IMFAsyncResult *)IMFAsyncResult_GetStateNoAddRef(result);
 906
 907     if (FAILED(hr = IMFAsyncResult_GetObject(result, &context_object)))
 908     {
 909         WARN("Expected context set for callee result.\n");
 910         return hr;
 911     }
 912
 913     context = impl_from_IUnknown(context_object);
 914
 915     /* Strip from scheme, MFCreateFile() won't be expecting it. */
 916     url = context->url;
 917     if (!wcsnicmp(context->url, schemeW, ARRAY_SIZE(schemeW)))
 918         url += ARRAY_SIZE(schemeW);
 919
 920     hr = MFCreateFile(context->flags & MF_RESOLUTION_WRITE ? MF_ACCESSMODE_READWRITE : MF_ACCESSMODE_READ,
 921             MF_OPENMODE_FAIL_IF_NOT_EXIST, MF_FILEFLAGS_NONE, url, &stream);
 922     if (SUCCEEDED(hr))
 923     {
 924         if (context->flags & MF_RESOLUTION_MEDIASOURCE)
 925         {
 926             if (SUCCEEDED(hr = file_scheme_handler_get_resolver(handler, &resolver)))
 927             {
 928                 hr = IMFSourceResolver_CreateObjectFromByteStream(resolver, stream, context->url, context->flags,
 929                         context->props, &obj_type, &object);
 930                 IMFSourceResolver_Release(resolver);
 931                 IMFByteStream_Release(stream);
 932             }
 933         }
 934         else
 935         {
 936             object = (IUnknown *)stream;
 937             obj_type = MF_OBJECT_BYTESTREAM;
 938         }
 939     }
 940
 941     handler_result = malloc(sizeof(*handler_result));
 942     if (handler_result)
 943     {
 944         handler_result->result = caller;
 945         IMFAsyncResult_AddRef(handler_result->result);
 946         handler_result->obj_type = obj_type;
 947         handler_result->object = object;
 948
 949         EnterCriticalSection(&handler->cs);
 950         list_add_tail(&handler->results, &handler_result->entry);
 951         LeaveCriticalSection(&handler->cs);
 952     }
 953     else
 954     {
 955         if (object)
 956             IUnknown_Release(object);
 957         hr = E_OUTOFMEMORY;
 958     }
 959
 960     IUnknown_Release(&context->IUnknown_iface);
 961
 962     IMFAsyncResult_SetStatus(caller, hr);
 963     MFInvokeCallback(caller);
 964
 965     return S_OK;
 966 }
 967
 968 static const IMFAsyncCallbackVtbl file_scheme_handler_callback_vtbl =
 969 {
 970     file_scheme_handler_callback_QueryInterface,
 971     file_scheme_handler_callback_AddRef,
 972     file_scheme_handler_callback_Release,
 973     file_scheme_handler_callback_GetParameters,
 974     file_scheme_handler_callback_Invoke,
 975 };
 976
 977 static HRESULT file_scheme_handler_construct(REFIID riid, void **obj)
 978 {
 979     struct file_scheme_handler *handler;
 980     HRESULT hr;
 981
 982     TRACE("%s, %p.\n", debugstr_guid(riid), obj);
 983
 984     if (!(handler = calloc(1, sizeof(*handler))))
 985         return E_OUTOFMEMORY;
 986
 987     handler->IMFSchemeHandler_iface.lpVtbl = &file_scheme_handler_vtbl;
 988     handler->IMFAsyncCallback_iface.lpVtbl = &file_scheme_handler_callback_vtbl;
 989     handler->refcount = 1;
 990     list_init(&handler->results);
 991     InitializeCriticalSection(&handler->cs);
 992
 993     hr = IMFSchemeHandler_QueryInterface(&handler->IMFSchemeHandler_iface, riid, obj);
 994     IMFSchemeHandler_Release(&handler->IMFSchemeHandler_iface);
 995
 996     return hr;
 997 }
 998
 999 static struct class_factory file_scheme_handler_factory = { { &class_factory_vtbl }, file_scheme_handler_construct };
1000
1001 static const struct class_object
1002 {
1003     const GUID *clsid;
1004     IClassFactory *factory;
1005 }
1006 class_objects[] =
1007 {
1008     { &CLSID_FileSchemePlugin, &file_scheme_handler_factory.IClassFactory_iface },
1009 };
1010
1011 /*******************************************************************************
1012  *      DllGetClassObject (mf.@)
1013  */
1014 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **obj)
1015 {
1016     unsigned int i;
1017
1018     TRACE("%s, %s, %p.\n", debugstr_guid(rclsid), debugstr_guid(riid), obj);
1019
1020     for (i = 0; i < ARRAY_SIZE(class_objects); ++i)
1021     {
1022         if (IsEqualGUID(class_objects[i].clsid, rclsid))
1023             return IClassFactory_QueryInterface(class_objects[i].factory, riid, obj);
1024     }
1025
1026     WARN("%s: class not found.\n", debugstr_guid(rclsid));
1027     return CLASS_E_CLASSNOTAVAILABLE;
1028 }
1029
1030 static HRESULT prop_string_vector_append(PROPVARIANT *vector, unsigned int *capacity, BOOL unique, const WCHAR *str)
1031 {
1032     WCHAR *ptrW;
1033     int len, i;
1034
1035     if (unique)
1036     {
1037         for (i = 0; i < vector->calpwstr.cElems; ++i)
1038         {
1039             if (!lstrcmpW(vector->calpwstr.pElems[i], str))
1040                 return S_OK;
1041         }
1042     }
1043
1044     if (!*capacity || *capacity - 1 < vector->calpwstr.cElems)
1045     {
1046         unsigned int new_count;
1047         WCHAR **ptr;
1048
1049         new_count = *capacity ? *capacity * 2 : 10;
1050         ptr = CoTaskMemRealloc(vector->calpwstr.pElems, new_count * sizeof(*vector->calpwstr.pElems));
1051         if (!ptr)
1052             return E_OUTOFMEMORY;
1053         vector->calpwstr.pElems = ptr;
1054         *capacity = new_count;
1055     }
1056
1057     len = lstrlenW(str);
1058     if (!(vector->calpwstr.pElems[vector->calpwstr.cElems] = ptrW = CoTaskMemAlloc((len + 1) * sizeof(WCHAR))))
1059         return E_OUTOFMEMORY;
1060
1061     lstrcpyW(ptrW, str);
1062     vector->calpwstr.cElems++;
1063
1064     return S_OK;
1065 }
1066
1067 static int __cdecl qsort_string_compare(const void *a, const void *b)
1068 {
1069     const WCHAR *left = *(const WCHAR **)a, *right = *(const WCHAR **)b;
1070     return lstrcmpW(left, right);
1071 }
1072
1073 static HRESULT mf_get_handler_strings(const WCHAR *path, WCHAR filter, unsigned int maxlen, PROPVARIANT *dst)
1074 {
1075     static const HKEY hkey_roots[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
1076     unsigned int capacity = 0, count;
1077     HRESULT hr = S_OK;
1078     int i, index;
1079     WCHAR *buffW;
1080     DWORD size;
1081
1082     if (!(buffW = calloc(maxlen, sizeof(*buffW))))
1083         return E_OUTOFMEMORY;
1084
1085     memset(dst, 0, sizeof(*dst));
1086     dst->vt = VT_VECTOR | VT_LPWSTR;
1087
1088     for (i = 0; i < ARRAY_SIZE(hkey_roots); ++i)
1089     {
1090         HKEY hkey;
1091
1092         if (RegOpenKeyW(hkey_roots[i], path, &hkey))
1093             continue;
1094
1095         index = 0;
1096         size = maxlen;
1097         count = dst->calpwstr.cElems;
1098         while (!RegEnumKeyExW(hkey, index++, buffW, &size, NULL, NULL, NULL, NULL))
1099         {
1100             if (filter && !wcschr(buffW, filter))
1101                 continue;
1102
1103             if (FAILED(hr = prop_string_vector_append(dst, &capacity, i > 0, buffW)))
1104                 break;
1105             size = maxlen;
1106         }
1107
1108         /* Sort last pass results. */
1109         qsort(&dst->calpwstr.pElems[count], dst->calpwstr.cElems - count, sizeof(*dst->calpwstr.pElems),
1110                 qsort_string_compare);
1111
1112         RegCloseKey(hkey);
1113     }
1114
1115     if (FAILED(hr))
1116         PropVariantClear(dst);
1117
1118     free(buffW);
1119
1120     return hr;
1121 }
1122
1123 /***********************************************************************
1124  *      MFGetSupportedMimeTypes (mf.@)
1125  */
1126 HRESULT WINAPI MFGetSupportedMimeTypes(PROPVARIANT *dst)
1127 {
1128     unsigned int maxlen;
1129
1130     TRACE("%p.\n", dst);
1131
1132     if (!dst)
1133         return E_POINTER;
1134
1135     /* According to RFC4288 it's 127/127 characters. */
1136     maxlen = 127 /* type */ + 1 /* / */ + 127 /* subtype */ + 1;
1137     return mf_get_handler_strings(L"Software\\Microsoft\\Windows Media Foundation\\ByteStreamHandlers", '/',
1138             maxlen,  dst);
1139 }
1140
1141 /***********************************************************************
1142  *      MFGetSupportedSchemes (mf.@)
1143  */
1144 HRESULT WINAPI MFGetSupportedSchemes(PROPVARIANT *dst)
1145 {
1146     TRACE("%p.\n", dst);
1147
1148     if (!dst)
1149         return E_POINTER;
1150
1151     return mf_get_handler_strings(L"Software\\Microsoft\\Windows Media Foundation\\SchemeHandlers", 0, 64, dst);
1152 }
1153
1154 /***********************************************************************
1155  *      MFGetService (mf.@)
1156  */
1157 HRESULT WINAPI MFGetService(IUnknown *object, REFGUID service, REFIID riid, void **obj)
1158 {
1159     IMFGetService *gs;
1160     HRESULT hr;
1161
1162     TRACE("(%p, %s, %s, %p)\n", object, debugstr_guid(service), debugstr_guid(riid), obj);
1163
1164     if (!object)
1165         return E_POINTER;
1166
1167     if (FAILED(hr = IUnknown_QueryInterface(object, &IID_IMFGetService, (void **)&gs)))
1168         return hr;
1169
1170     hr = IMFGetService_GetService(gs, service, riid, obj);
1171     IMFGetService_Release(gs);
1172     return hr;
1173 }
1174
1175 /***********************************************************************
1176  *      MFShutdownObject (mf.@)
1177  */
1178 HRESULT WINAPI MFShutdownObject(IUnknown *object)
1179 {
1180     IMFShutdown *shutdown;
1181
1182     TRACE("%p.\n", object);
1183
1184     if (object && SUCCEEDED(IUnknown_QueryInterface(object, &IID_IMFShutdown, (void **)&shutdown)))
1185     {
1186         IMFShutdown_Shutdown(shutdown);
1187         IMFShutdown_Release(shutdown);
1188     }
1189
1190     return S_OK;
1191 }
1192
1193 /***********************************************************************
1194  *      MFEnumDeviceSources (mf.@)
1195  */
1196 HRESULT WINAPI MFEnumDeviceSources(IMFAttributes *attributes, IMFActivate ***sources, UINT32 *count)
1197 {
1198     FIXME("%p, %p, %p.\n", attributes, sources, count);
1199
1200     if (!attributes || !sources || !count)
1201         return E_INVALIDARG;
1202
1203     *count = 0;
1204
1205     return S_OK;
1206 }
1207
1208 struct simple_type_handler
1209 {
1210     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
1211     LONG refcount;
1212     IMFMediaType *media_type;
1213     CRITICAL_SECTION cs;
1214 };
1215
1216 static struct simple_type_handler *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
1217 {
1218     return CONTAINING_RECORD(iface, struct simple_type_handler, IMFMediaTypeHandler_iface);
1219 }
1220
1221 static HRESULT WINAPI simple_type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid, void **obj)
1222 {
1223     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1224
1225     if (IsEqualIID(riid, &IID_IMFMediaTypeHandler) ||
1226             IsEqualIID(riid, &IID_IUnknown))
1227     {
1228         *obj = iface;
1229         IMFMediaTypeHandler_AddRef(iface);
1230         return S_OK;
1231     }
1232
1233     *obj = NULL;
1234     return E_NOINTERFACE;
1235 }
1236
1237 static ULONG WINAPI simple_type_handler_AddRef(IMFMediaTypeHandler *iface)
1238 {
1239     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1240     ULONG refcount = InterlockedIncrement(&handler->refcount);
1241
1242     TRACE("%p, refcount %lu.\n", iface, refcount);
1243
1244     return refcount;
1245 }
1246
1247 static ULONG WINAPI simple_type_handler_Release(IMFMediaTypeHandler *iface)
1248 {
1249     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1250     ULONG refcount = InterlockedDecrement(&handler->refcount);
1251
1252     TRACE("%p, refcount %lu.\n", iface, refcount);
1253
1254     if (!refcount)
1255     {
1256         if (handler->media_type)
1257             IMFMediaType_Release(handler->media_type);
1258         DeleteCriticalSection(&handler->cs);
1259         free(handler);
1260     }
1261
1262     return refcount;
1263 }
1264
1265 static HRESULT WINAPI simple_type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface, IMFMediaType *in_type,
1266         IMFMediaType **out_type)
1267 {
1268     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1269     DWORD flags = 0;
1270     HRESULT hr;
1271
1272     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
1273
1274     if (out_type)
1275         *out_type = NULL;
1276
1277     EnterCriticalSection(&handler->cs);
1278     if (!handler->media_type)
1279         hr = MF_E_UNEXPECTED;
1280     else
1281     {
1282         if (SUCCEEDED(hr = IMFMediaType_IsEqual(handler->media_type, in_type, &flags)))
1283             hr = (flags & (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES)) ==
1284                     (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES) ? S_OK : E_FAIL;
1285     }
1286     LeaveCriticalSection(&handler->cs);
1287
1288     return hr;
1289 }
1290
1291 static HRESULT WINAPI simple_type_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
1292 {
1293     TRACE("%p, %p.\n", iface, count);
1294
1295     if (!count)
1296         return E_POINTER;
1297
1298     *count = 1;
1299
1300     return S_OK;
1301 }
1302
1303 static HRESULT WINAPI simple_type_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
1304         IMFMediaType **type)
1305 {
1306     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1307
1308     TRACE("%p, %lu, %p.\n", iface, index, type);
1309
1310     if (index > 0)
1311         return MF_E_NO_MORE_TYPES;
1312
1313     EnterCriticalSection(&handler->cs);
1314     *type = handler->media_type;
1315     if (*type)
1316         IMFMediaType_AddRef(*type);
1317     LeaveCriticalSection(&handler->cs);
1318
1319     return S_OK;
1320 }
1321
1322 static HRESULT WINAPI simple_type_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *media_type)
1323 {
1324     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1325
1326     TRACE("%p, %p.\n", iface, media_type);
1327
1328     EnterCriticalSection(&handler->cs);
1329     if (handler->media_type)
1330         IMFMediaType_Release(handler->media_type);
1331     handler->media_type = media_type;
1332     if (handler->media_type)
1333         IMFMediaType_AddRef(handler->media_type);
1334     LeaveCriticalSection(&handler->cs);
1335
1336     return S_OK;
1337 }
1338
1339 static HRESULT WINAPI simple_type_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **media_type)
1340 {
1341     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1342
1343     TRACE("%p, %p.\n", iface, media_type);
1344
1345     if (!media_type)
1346         return E_POINTER;
1347
1348     EnterCriticalSection(&handler->cs);
1349     *media_type = handler->media_type;
1350     if (*media_type)
1351         IMFMediaType_AddRef(*media_type);
1352     LeaveCriticalSection(&handler->cs);
1353
1354     return S_OK;
1355 }
1356
1357 static HRESULT WINAPI simple_type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
1358 {
1359     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1360     HRESULT hr;
1361
1362     TRACE("%p, %p.\n", iface, type);
1363
1364     EnterCriticalSection(&handler->cs);
1365     if (handler->media_type)
1366         hr = IMFMediaType_GetGUID(handler->media_type, &MF_MT_MAJOR_TYPE, type);
1367     else
1368         hr = MF_E_NOT_INITIALIZED;
1369     LeaveCriticalSection(&handler->cs);
1370
1371     return hr;
1372 }
1373
1374 static const IMFMediaTypeHandlerVtbl simple_type_handler_vtbl =
1375 {
1376     simple_type_handler_QueryInterface,
1377     simple_type_handler_AddRef,
1378     simple_type_handler_Release,
1379     simple_type_handler_IsMediaTypeSupported,
1380     simple_type_handler_GetMediaTypeCount,
1381     simple_type_handler_GetMediaTypeByIndex,
1382     simple_type_handler_SetCurrentMediaType,
1383     simple_type_handler_GetCurrentMediaType,
1384     simple_type_handler_GetMajorType,
1385 };
1386
1387 /*******************************************************************************
1388  *      MFCreateSimpleTypeHandler (mf.@)
1389  */
1390 HRESULT WINAPI MFCreateSimpleTypeHandler(IMFMediaTypeHandler **handler)
1391 {
1392     struct simple_type_handler *object;
1393
1394     TRACE("%p.\n", handler);
1395
1396     if (!(object = calloc(1, sizeof(*object))))
1397         return E_OUTOFMEMORY;
1398
1399     object->IMFMediaTypeHandler_iface.lpVtbl = &simple_type_handler_vtbl;
1400     object->refcount = 1;
1401     InitializeCriticalSection(&object->cs);
1402
1403     *handler = &object->IMFMediaTypeHandler_iface;
1404
1405     return S_OK;
1406 }
1407
1408 /*******************************************************************************
1409  *      MFRequireProtectedEnvironment (mf.@)
1410  */
1411 HRESULT WINAPI MFRequireProtectedEnvironment(IMFPresentationDescriptor *pd)
1412 {
1413     BOOL selected, protected = FALSE;
1414     unsigned int i = 0, value;
1415     IMFStreamDescriptor *sd;
1416
1417     TRACE("%p.\n", pd);
1418
1419     while (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, i++, &selected, &sd)))
1420     {
1421         value = 0;
1422         protected = SUCCEEDED(IMFStreamDescriptor_GetUINT32(sd, &MF_SD_PROTECTED, &value)) && value;
1423         IMFStreamDescriptor_Release(sd);
1424         if (protected) break;
1425     }
1426
1427     return protected ? S_OK : S_FALSE;
1428 }
1429
1430 static HRESULT create_media_sink(const CLSID *clsid, IMFByteStream *stream, IMFMediaType *video_type,
1431         IMFMediaType *audio_type, IMFMediaSink **sink)
1432 {
1433     IMFSinkClassFactory *factory;
1434     HRESULT hr;
1435
1436     if (FAILED(hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFSinkClassFactory, (void **)&factory)))
1437         return hr;
1438
1439     hr = IMFSinkClassFactory_CreateMediaSink(factory, stream, video_type, audio_type, sink);
1440     IMFSinkClassFactory_Release(factory);
1441
1442     return hr;
1443 }
1444
1445 /*******************************************************************************
1446  *      MFCreate3GPMediaSink (mf.@)
1447  */
1448 HRESULT WINAPI MFCreate3GPMediaSink(IMFByteStream *stream, IMFMediaType *video_type,
1449          IMFMediaType *audio_type, IMFMediaSink **sink)
1450 {
1451     TRACE("%p, %p, %p, %p.\n", stream, video_type, audio_type, sink);
1452
1453     return create_media_sink(&CLSID_MF3GPSinkClassFactory, stream, video_type, audio_type, sink);
1454 }
1455
1456 /*******************************************************************************
1457  *      MFCreateAC3MediaSink (mf.@)
1458  */
1459 HRESULT WINAPI MFCreateAC3MediaSink(IMFByteStream *stream, IMFMediaType *audio_type, IMFMediaSink **sink)
1460 {
1461     TRACE("%p, %p, %p.\n", stream, audio_type, sink);
1462
1463     return create_media_sink(&CLSID_MFAC3SinkClassFactory, stream, NULL, audio_type, sink);
1464 }
1465
1466 /*******************************************************************************
1467  *      MFCreateADTSMediaSink (mf.@)
1468  */
1469 HRESULT WINAPI MFCreateADTSMediaSink(IMFByteStream *stream, IMFMediaType *audio_type, IMFMediaSink **sink)
1470 {
1471     TRACE("%p, %p, %p.\n", stream, audio_type, sink);
1472
1473     return create_media_sink(&CLSID_MFADTSSinkClassFactory, stream, NULL, audio_type, sink);
1474 }
1475
1476 /*******************************************************************************
1477  *      MFCreateMP3MediaSink (mf.@)
1478  */
1479 HRESULT WINAPI MFCreateMP3MediaSink(IMFByteStream *stream, IMFMediaSink **sink)
1480 {
1481     TRACE("%p, %p.\n", stream, sink);
1482
1483     return create_media_sink(&CLSID_MFMP3SinkClassFactory, stream, NULL, NULL, sink);
1484 }
1485
1486 /*******************************************************************************
1487  *      MFCreateMPEG4MediaSink (mf.@)
1488  */
1489 HRESULT WINAPI MFCreateMPEG4MediaSink(IMFByteStream *stream, IMFMediaType *video_type,
1490          IMFMediaType *audio_type, IMFMediaSink **sink)
1491 {
1492     TRACE("%p, %p, %p, %p.\n", stream, video_type, audio_type, sink);
1493
1494     return create_media_sink(&CLSID_MFMPEG4SinkClassFactory, stream, video_type, audio_type, sink);
1495 }
1496
1497 /*******************************************************************************
1498  *      MFCreateFMPEG4MediaSink (mf.@)
1499  */
1500 HRESULT WINAPI MFCreateFMPEG4MediaSink(IMFByteStream *stream, IMFMediaType *video_type,
1501          IMFMediaType *audio_type, IMFMediaSink **sink)
1502 {
1503     TRACE("%p, %p, %p, %p.\n", stream, video_type, audio_type, sink);
1504
1505     return create_media_sink(&CLSID_MFFMPEG4SinkClassFactory, stream, video_type, audio_type, sink);
1506 }