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 static struct class_factory file_scheme_handler_factory = { { &class_factory_vtbl }, file_scheme_handler_construct };
 552 static struct class_factory urlmon_scheme_handler_factory = { { &class_factory_vtbl }, urlmon_scheme_handler_construct };
 553
 554 static const struct class_object
 555 {
 556     const GUID *clsid;
 557     IClassFactory *factory;
 558 }
 559 class_objects[] =
 560 {
 561     { &CLSID_FileSchemePlugin, &file_scheme_handler_factory.IClassFactory_iface },
 562     { &CLSID_UrlmonSchemePlugin, &urlmon_scheme_handler_factory.IClassFactory_iface },
 563 };
 564
 565 /*******************************************************************************
 566  *      DllGetClassObject (mf.@)
 567  */
 568 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **obj)
 569 {
 570     unsigned int i;
 571
 572     TRACE("%s, %s, %p.\n", debugstr_guid(rclsid), debugstr_guid(riid), obj);
 573
 574     for (i = 0; i < ARRAY_SIZE(class_objects); ++i)
 575     {
 576         if (IsEqualGUID(class_objects[i].clsid, rclsid))
 577             return IClassFactory_QueryInterface(class_objects[i].factory, riid, obj);
 578     }
 579
 580     WARN("%s: class not found.\n", debugstr_guid(rclsid));
 581     return CLASS_E_CLASSNOTAVAILABLE;
 582 }
 583
 584 static HRESULT prop_string_vector_append(PROPVARIANT *vector, unsigned int *capacity, BOOL unique, const WCHAR *str)
 585 {
 586     WCHAR *ptrW;
 587     int len, i;
 588
 589     if (unique)
 590     {
 591         for (i = 0; i < vector->calpwstr.cElems; ++i)
 592         {
 593             if (!lstrcmpW(vector->calpwstr.pElems[i], str))
 594                 return S_OK;
 595         }
 596     }
 597
 598     if (!*capacity || *capacity - 1 < vector->calpwstr.cElems)
 599     {
 600         unsigned int new_count;
 601         WCHAR **ptr;
 602
 603         new_count = *capacity ? *capacity * 2 : 10;
 604         ptr = CoTaskMemRealloc(vector->calpwstr.pElems, new_count * sizeof(*vector->calpwstr.pElems));
 605         if (!ptr)
 606             return E_OUTOFMEMORY;
 607         vector->calpwstr.pElems = ptr;
 608         *capacity = new_count;
 609     }
 610
 611     len = lstrlenW(str);
 612     if (!(vector->calpwstr.pElems[vector->calpwstr.cElems] = ptrW = CoTaskMemAlloc((len + 1) * sizeof(WCHAR))))
 613         return E_OUTOFMEMORY;
 614
 615     lstrcpyW(ptrW, str);
 616     vector->calpwstr.cElems++;
 617
 618     return S_OK;
 619 }
 620
 621 static int __cdecl qsort_string_compare(const void *a, const void *b)
 622 {
 623     const WCHAR *left = *(const WCHAR **)a, *right = *(const WCHAR **)b;
 624     return lstrcmpW(left, right);
 625 }
 626
 627 static HRESULT mf_get_handler_strings(const WCHAR *path, WCHAR filter, unsigned int maxlen, PROPVARIANT *dst)
 628 {
 629     static const HKEY hkey_roots[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
 630     unsigned int capacity = 0, count;
 631     HRESULT hr = S_OK;
 632     int i, index;
 633     WCHAR *buffW;
 634     DWORD size;
 635
 636     if (!(buffW = calloc(maxlen, sizeof(*buffW))))
 637         return E_OUTOFMEMORY;
 638
 639     memset(dst, 0, sizeof(*dst));
 640     dst->vt = VT_VECTOR | VT_LPWSTR;
 641
 642     for (i = 0; i < ARRAY_SIZE(hkey_roots); ++i)
 643     {
 644         HKEY hkey;
 645
 646         if (RegOpenKeyW(hkey_roots[i], path, &hkey))
 647             continue;
 648
 649         index = 0;
 650         size = maxlen;
 651         count = dst->calpwstr.cElems;
 652         while (!RegEnumKeyExW(hkey, index++, buffW, &size, NULL, NULL, NULL, NULL))
 653         {
 654             if (filter && !wcschr(buffW, filter))
 655                 continue;
 656
 657             if (FAILED(hr = prop_string_vector_append(dst, &capacity, i > 0, buffW)))
 658                 break;
 659             size = maxlen;
 660         }
 661
 662         /* Sort last pass results. */
 663         qsort(&dst->calpwstr.pElems[count], dst->calpwstr.cElems - count, sizeof(*dst->calpwstr.pElems),
 664                 qsort_string_compare);
 665
 666         RegCloseKey(hkey);
 667     }
 668
 669     if (FAILED(hr))
 670         PropVariantClear(dst);
 671
 672     free(buffW);
 673
 674     return hr;
 675 }
 676
 677 /***********************************************************************
 678  *      MFGetSupportedMimeTypes (mf.@)
 679  */
 680 HRESULT WINAPI MFGetSupportedMimeTypes(PROPVARIANT *dst)
 681 {
 682     unsigned int maxlen;
 683
 684     TRACE("%p.\n", dst);
 685
 686     if (!dst)
 687         return E_POINTER;
 688
 689     /* According to RFC4288 it's 127/127 characters. */
 690     maxlen = 127 /* type */ + 1 /* / */ + 127 /* subtype */ + 1;
 691     return mf_get_handler_strings(L"Software\\Microsoft\\Windows Media Foundation\\ByteStreamHandlers", '/',
 692             maxlen,  dst);
 693 }
 694
 695 /***********************************************************************
 696  *      MFGetSupportedSchemes (mf.@)
 697  */
 698 HRESULT WINAPI MFGetSupportedSchemes(PROPVARIANT *dst)
 699 {
 700     TRACE("%p.\n", dst);
 701
 702     if (!dst)
 703         return E_POINTER;
 704
 705     return mf_get_handler_strings(L"Software\\Microsoft\\Windows Media Foundation\\SchemeHandlers", 0, 64, dst);
 706 }
 707
 708 /***********************************************************************
 709  *      MFGetService (mf.@)
 710  */
 711 HRESULT WINAPI MFGetService(IUnknown *object, REFGUID service, REFIID riid, void **obj)
 712 {
 713     IMFGetService *gs;
 714     HRESULT hr;
 715
 716     TRACE("(%p, %s, %s, %p)\n", object, debugstr_guid(service), debugstr_guid(riid), obj);
 717
 718     if (!object)
 719         return E_POINTER;
 720
 721     if (FAILED(hr = IUnknown_QueryInterface(object, &IID_IMFGetService, (void **)&gs)))
 722         return hr;
 723
 724     hr = IMFGetService_GetService(gs, service, riid, obj);
 725     IMFGetService_Release(gs);
 726     return hr;
 727 }
 728
 729 /***********************************************************************
 730  *      MFShutdownObject (mf.@)
 731  */
 732 HRESULT WINAPI MFShutdownObject(IUnknown *object)
 733 {
 734     IMFShutdown *shutdown;
 735
 736     TRACE("%p.\n", object);
 737
 738     if (object && SUCCEEDED(IUnknown_QueryInterface(object, &IID_IMFShutdown, (void **)&shutdown)))
 739     {
 740         IMFShutdown_Shutdown(shutdown);
 741         IMFShutdown_Release(shutdown);
 742     }
 743
 744     return S_OK;
 745 }
 746
 747 /***********************************************************************
 748  *      MFEnumDeviceSources (mf.@)
 749  */
 750 HRESULT WINAPI MFEnumDeviceSources(IMFAttributes *attributes, IMFActivate ***sources, UINT32 *count)
 751 {
 752     FIXME("%p, %p, %p.\n", attributes, sources, count);
 753
 754     if (!attributes || !sources || !count)
 755         return E_INVALIDARG;
 756
 757     *count = 0;
 758
 759     return S_OK;
 760 }
 761
 762 struct simple_type_handler
 763 {
 764     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
 765     LONG refcount;
 766     IMFMediaType *media_type;
 767     CRITICAL_SECTION cs;
 768 };
 769
 770 static struct simple_type_handler *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
 771 {
 772     return CONTAINING_RECORD(iface, struct simple_type_handler, IMFMediaTypeHandler_iface);
 773 }
 774
 775 static HRESULT WINAPI simple_type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid, void **obj)
 776 {
 777     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 778
 779     if (IsEqualIID(riid, &IID_IMFMediaTypeHandler) ||
 780             IsEqualIID(riid, &IID_IUnknown))
 781     {
 782         *obj = iface;
 783         IMFMediaTypeHandler_AddRef(iface);
 784         return S_OK;
 785     }
 786
 787     *obj = NULL;
 788     return E_NOINTERFACE;
 789 }
 790
 791 static ULONG WINAPI simple_type_handler_AddRef(IMFMediaTypeHandler *iface)
 792 {
 793     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
 794     ULONG refcount = InterlockedIncrement(&handler->refcount);
 795
 796     TRACE("%p, refcount %lu.\n", iface, refcount);
 797
 798     return refcount;
 799 }
 800
 801 static ULONG WINAPI simple_type_handler_Release(IMFMediaTypeHandler *iface)
 802 {
 803     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
 804     ULONG refcount = InterlockedDecrement(&handler->refcount);
 805
 806     TRACE("%p, refcount %lu.\n", iface, refcount);
 807
 808     if (!refcount)
 809     {
 810         if (handler->media_type)
 811             IMFMediaType_Release(handler->media_type);
 812         DeleteCriticalSection(&handler->cs);
 813         free(handler);
 814     }
 815
 816     return refcount;
 817 }
 818
 819 static HRESULT WINAPI simple_type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface, IMFMediaType *in_type,
 820         IMFMediaType **out_type)
 821 {
 822     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
 823     DWORD flags = 0;
 824     HRESULT hr;
 825
 826     TRACE("%p, %p, %p.\n", iface, in_type, out_type);
 827
 828     if (out_type)
 829         *out_type = NULL;
 830
 831     EnterCriticalSection(&handler->cs);
 832     if (!handler->media_type)
 833         hr = MF_E_UNEXPECTED;
 834     else
 835     {
 836         if (SUCCEEDED(hr = IMFMediaType_IsEqual(handler->media_type, in_type, &flags)))
 837             hr = (flags & (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES)) ==
 838                     (MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES) ? S_OK : E_FAIL;
 839     }
 840     LeaveCriticalSection(&handler->cs);
 841
 842     return hr;
 843 }
 844
 845 static HRESULT WINAPI simple_type_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
 846 {
 847     TRACE("%p, %p.\n", iface, count);
 848
 849     if (!count)
 850         return E_POINTER;
 851
 852     *count = 1;
 853
 854     return S_OK;
 855 }
 856
 857 static HRESULT WINAPI simple_type_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
 858         IMFMediaType **type)
 859 {
 860     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
 861
 862     TRACE("%p, %lu, %p.\n", iface, index, type);
 863
 864     if (index > 0)
 865         return MF_E_NO_MORE_TYPES;
 866
 867     EnterCriticalSection(&handler->cs);
 868     *type = handler->media_type;
 869     if (*type)
 870         IMFMediaType_AddRef(*type);
 871     LeaveCriticalSection(&handler->cs);
 872
 873     return S_OK;
 874 }
 875
 876 static HRESULT WINAPI simple_type_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *media_type)
 877 {
 878     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
 879
 880     TRACE("%p, %p.\n", iface, media_type);
 881
 882     EnterCriticalSection(&handler->cs);
 883     if (handler->media_type)
 884         IMFMediaType_Release(handler->media_type);
 885     handler->media_type = media_type;
 886     if (handler->media_type)
 887         IMFMediaType_AddRef(handler->media_type);
 888     LeaveCriticalSection(&handler->cs);
 889
 890     return S_OK;
 891 }
 892
 893 static HRESULT WINAPI simple_type_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **media_type)
 894 {
 895     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
 896
 897     TRACE("%p, %p.\n", iface, media_type);
 898
 899     if (!media_type)
 900         return E_POINTER;
 901
 902     EnterCriticalSection(&handler->cs);
 903     *media_type = handler->media_type;
 904     if (*media_type)
 905         IMFMediaType_AddRef(*media_type);
 906     LeaveCriticalSection(&handler->cs);
 907
 908     return S_OK;
 909 }
 910
 911 static HRESULT WINAPI simple_type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
 912 {
 913     struct simple_type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
 914     HRESULT hr;
 915
 916     TRACE("%p, %p.\n", iface, type);
 917
 918     EnterCriticalSection(&handler->cs);
 919     if (handler->media_type)
 920         hr = IMFMediaType_GetGUID(handler->media_type, &MF_MT_MAJOR_TYPE, type);
 921     else
 922         hr = MF_E_NOT_INITIALIZED;
 923     LeaveCriticalSection(&handler->cs);
 924
 925     return hr;
 926 }
 927
 928 static const IMFMediaTypeHandlerVtbl simple_type_handler_vtbl =
 929 {
 930     simple_type_handler_QueryInterface,
 931     simple_type_handler_AddRef,
 932     simple_type_handler_Release,
 933     simple_type_handler_IsMediaTypeSupported,
 934     simple_type_handler_GetMediaTypeCount,
 935     simple_type_handler_GetMediaTypeByIndex,
 936     simple_type_handler_SetCurrentMediaType,
 937     simple_type_handler_GetCurrentMediaType,
 938     simple_type_handler_GetMajorType,
 939 };
 940
 941 /*******************************************************************************
 942  *      MFCreateSimpleTypeHandler (mf.@)
 943  */
 944 HRESULT WINAPI MFCreateSimpleTypeHandler(IMFMediaTypeHandler **handler)
 945 {
 946     struct simple_type_handler *object;
 947
 948     TRACE("%p.\n", handler);
 949
 950     if (!(object = calloc(1, sizeof(*object))))
 951         return E_OUTOFMEMORY;
 952
 953     object->IMFMediaTypeHandler_iface.lpVtbl = &simple_type_handler_vtbl;
 954     object->refcount = 1;
 955     InitializeCriticalSection(&object->cs);
 956
 957     *handler = &object->IMFMediaTypeHandler_iface;
 958
 959     return S_OK;
 960 }
 961
 962 /*******************************************************************************
 963  *      MFRequireProtectedEnvironment (mf.@)
 964  */
 965 HRESULT WINAPI MFRequireProtectedEnvironment(IMFPresentationDescriptor *pd)
 966 {
 967     BOOL selected, protected = FALSE;
 968     unsigned int i = 0, value;
 969     IMFStreamDescriptor *sd;
 970
 971     TRACE("%p.\n", pd);
 972
 973     while (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, i++, &selected, &sd)))
 974     {
 975         value = 0;
 976         protected = SUCCEEDED(IMFStreamDescriptor_GetUINT32(sd, &MF_SD_PROTECTED, &value)) && value;
 977         IMFStreamDescriptor_Release(sd);
 978         if (protected) break;
 979     }
 980
 981     return protected ? S_OK : S_FALSE;
 982 }
 983
 984 static HRESULT create_media_sink(const CLSID *clsid, IMFByteStream *stream, IMFMediaType *video_type,
 985         IMFMediaType *audio_type, IMFMediaSink **sink)
 986 {
 987     IMFSinkClassFactory *factory;
 988     HRESULT hr;
 989
 990     if (FAILED(hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFSinkClassFactory, (void **)&factory)))
 991         return hr;
 992
 993     hr = IMFSinkClassFactory_CreateMediaSink(factory, stream, video_type, audio_type, sink);
 994     IMFSinkClassFactory_Release(factory);
 995
 996     return hr;
 997 }
 998
 999 /*******************************************************************************
1000  *      MFCreate3GPMediaSink (mf.@)
1001  */
1002 HRESULT WINAPI MFCreate3GPMediaSink(IMFByteStream *stream, IMFMediaType *video_type,
1003          IMFMediaType *audio_type, IMFMediaSink **sink)
1004 {
1005     TRACE("%p, %p, %p, %p.\n", stream, video_type, audio_type, sink);
1006
1007     return create_media_sink(&CLSID_MF3GPSinkClassFactory, stream, video_type, audio_type, sink);
1008 }
1009
1010 /*******************************************************************************
1011  *      MFCreateAC3MediaSink (mf.@)
1012  */
1013 HRESULT WINAPI MFCreateAC3MediaSink(IMFByteStream *stream, IMFMediaType *audio_type, IMFMediaSink **sink)
1014 {
1015     TRACE("%p, %p, %p.\n", stream, audio_type, sink);
1016
1017     return create_media_sink(&CLSID_MFAC3SinkClassFactory, stream, NULL, audio_type, sink);
1018 }
1019
1020 /*******************************************************************************
1021  *      MFCreateADTSMediaSink (mf.@)
1022  */
1023 HRESULT WINAPI MFCreateADTSMediaSink(IMFByteStream *stream, IMFMediaType *audio_type, IMFMediaSink **sink)
1024 {
1025     TRACE("%p, %p, %p.\n", stream, audio_type, sink);
1026
1027     return create_media_sink(&CLSID_MFADTSSinkClassFactory, stream, NULL, audio_type, sink);
1028 }
1029
1030 /*******************************************************************************
1031  *      MFCreateMP3MediaSink (mf.@)
1032  */
1033 HRESULT WINAPI MFCreateMP3MediaSink(IMFByteStream *stream, IMFMediaSink **sink)
1034 {
1035     TRACE("%p, %p.\n", stream, sink);
1036
1037     return create_media_sink(&CLSID_MFMP3SinkClassFactory, stream, NULL, NULL, sink);
1038 }
1039
1040 /*******************************************************************************
1041  *      MFCreateMPEG4MediaSink (mf.@)
1042  */
1043 HRESULT WINAPI MFCreateMPEG4MediaSink(IMFByteStream *stream, IMFMediaType *video_type,
1044          IMFMediaType *audio_type, IMFMediaSink **sink)
1045 {
1046     TRACE("%p, %p, %p, %p.\n", stream, video_type, audio_type, sink);
1047
1048     return create_media_sink(&CLSID_MFMPEG4SinkClassFactory, stream, video_type, audio_type, sink);
1049 }
1050
1051 /*******************************************************************************
1052  *      MFCreateFMPEG4MediaSink (mf.@)
1053  */
1054 HRESULT WINAPI MFCreateFMPEG4MediaSink(IMFByteStream *stream, IMFMediaType *video_type,
1055          IMFMediaType *audio_type, IMFMediaSink **sink)
1056 {
1057     TRACE("%p, %p, %p, %p.\n", stream, video_type, audio_type, sink);
1058
1059     return create_media_sink(&CLSID_MFFMPEG4SinkClassFactory, stream, video_type, audio_type, sink);
1060 }