dlls/mfreadwrite/main.c

   1 /*
   2  *
   3  * Copyright 2014 Austin English
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "rpcproxy.h"
  30
  31 #undef INITGUID
  32 #include <guiddef.h>
  33 #include "mfapi.h"
  34 #include "mferror.h"
  35 #include "mfidl.h"
  36 #include "mfreadwrite.h"
  37
  38 #include "wine/debug.h"
  39 #include "wine/heap.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  42
  43 static HINSTANCE mfinstance;
  44
  45 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
  46 {
  47     switch (reason)
  48     {
  49         case DLL_WINE_PREATTACH:
  50             return FALSE;    /* prefer native version */
  51         case DLL_PROCESS_ATTACH:
  52             mfinstance = instance;
  53             DisableThreadLibraryCalls(instance);
  54             break;
  55     }
  56
  57     return TRUE;
  58 }
  59
  60 HRESULT WINAPI DllCanUnloadNow(void)
  61 {
  62     return S_FALSE;
  63 }
  64
  65 HRESULT WINAPI DllRegisterServer(void)
  66 {
  67     return __wine_register_resources( mfinstance );
  68 }
  69
  70 HRESULT WINAPI DllUnregisterServer(void)
  71 {
  72     return __wine_unregister_resources( mfinstance );
  73 }
  74
  75 struct media_stream
  76 {
  77     IMFMediaStream *stream;
  78     IMFMediaType *current;
  79     DWORD id;
  80 };
  81
  82 typedef struct source_reader
  83 {
  84     IMFSourceReader IMFSourceReader_iface;
  85     IMFAsyncCallback source_events_callback;
  86     IMFAsyncCallback stream_events_callback;
  87     LONG refcount;
  88     IMFMediaSource *source;
  89     IMFPresentationDescriptor *descriptor;
  90     DWORD first_audio_stream_index;
  91     DWORD first_video_stream_index;
  92     IMFSourceReaderCallback *async_callback;
  93     BOOL shutdown_on_release;
  94     struct media_stream *streams;
  95     DWORD stream_count;
  96     CRITICAL_SECTION cs;
  97 } srcreader;
  98
  99 struct sink_writer
 100 {
 101     IMFSinkWriter IMFSinkWriter_iface;
 102     LONG refcount;
 103 };
 104
 105 static inline srcreader *impl_from_IMFSourceReader(IMFSourceReader *iface)
 106 {
 107     return CONTAINING_RECORD(iface, srcreader, IMFSourceReader_iface);
 108 }
 109
 110 static struct source_reader *impl_from_source_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 111 {
 112     return CONTAINING_RECORD(iface, struct source_reader, source_events_callback);
 113 }
 114
 115 static struct source_reader *impl_from_stream_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 116 {
 117     return CONTAINING_RECORD(iface, struct source_reader, stream_events_callback);
 118 }
 119
 120 static inline struct sink_writer *impl_from_IMFSinkWriter(IMFSinkWriter *iface)
 121 {
 122     return CONTAINING_RECORD(iface, struct sink_writer, IMFSinkWriter_iface);
 123 }
 124
 125 static HRESULT WINAPI source_reader_source_events_callback_QueryInterface(IMFAsyncCallback *iface,
 126         REFIID riid, void **obj)
 127 {
 128     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 129
 130     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 131             IsEqualIID(riid, &IID_IUnknown))
 132     {
 133         *obj = iface;
 134         IMFAsyncCallback_AddRef(iface);
 135         return S_OK;
 136     }
 137
 138     WARN("Unsupported %s.\n", debugstr_guid(riid));
 139     *obj = NULL;
 140     return E_NOINTERFACE;
 141 }
 142
 143 static ULONG WINAPI source_reader_source_events_callback_AddRef(IMFAsyncCallback *iface)
 144 {
 145     struct source_reader *reader = impl_from_source_callback_IMFAsyncCallback(iface);
 146     return IMFSourceReader_AddRef(&reader->IMFSourceReader_iface);
 147 }
 148
 149 static ULONG WINAPI source_reader_source_events_callback_Release(IMFAsyncCallback *iface)
 150 {
 151     struct source_reader *reader = impl_from_source_callback_IMFAsyncCallback(iface);
 152     return IMFSourceReader_Release(&reader->IMFSourceReader_iface);
 153 }
 154
 155 static HRESULT WINAPI source_reader_source_events_callback_GetParameters(IMFAsyncCallback *iface,
 156         DWORD *flags, DWORD *queue)
 157 {
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT source_reader_new_stream_handler(struct source_reader *reader, IMFMediaEvent *event)
 162 {
 163     IMFStreamDescriptor *sd;
 164     IMFMediaStream *stream;
 165     PROPVARIANT value;
 166     unsigned int i;
 167     DWORD id = 0;
 168     HRESULT hr;
 169
 170     PropVariantInit(&value);
 171     if (FAILED(hr = IMFMediaEvent_GetValue(event, &value)))
 172     {
 173         WARN("Failed to get event value, hr %#x.\n", hr);
 174         return hr;
 175     }
 176
 177     if (value.vt != VT_UNKNOWN || !value.u.punkVal)
 178     {
 179         WARN("Unexpected value type %d.\n", value.vt);
 180         PropVariantClear(&value);
 181         return E_UNEXPECTED;
 182     }
 183
 184     hr = IUnknown_QueryInterface(value.u.punkVal, &IID_IMFMediaStream, (void **)&stream);
 185     PropVariantClear(&value);
 186     if (FAILED(hr))
 187     {
 188         WARN("Unexpected object type.\n");
 189         return hr;
 190     }
 191
 192     TRACE("Got new stream %p.\n", stream);
 193
 194     if (SUCCEEDED(hr = IMFMediaStream_GetStreamDescriptor(stream, &sd)))
 195     {
 196         hr = IMFStreamDescriptor_GetStreamIdentifier(sd, &id);
 197         IMFStreamDescriptor_Release(sd);
 198     }
 199
 200     if (FAILED(hr))
 201     {
 202         WARN("Unidentified stream %p, hr %#x.\n", stream, hr);
 203         IMFMediaStream_Release(stream);
 204         return hr;
 205     }
 206
 207     for (i = 0; i < reader->stream_count; ++i)
 208     {
 209         if (id == reader->streams[i].id)
 210         {
 211             if (!InterlockedCompareExchangePointer((void **)&reader->streams[i].stream, stream, NULL))
 212             {
 213                 IMFMediaStream_AddRef(reader->streams[i].stream);
 214                 if (FAILED(hr = IMFMediaStream_BeginGetEvent(stream, &reader->stream_events_callback,
 215                         (IUnknown *)stream)))
 216                 {
 217                     WARN("Failed to subscribe to stream events, hr %#x.\n", hr);
 218                 }
 219             }
 220             break;
 221         }
 222     }
 223
 224     if (i == reader->stream_count)
 225         WARN("Stream with id %#x was not present in presentation descriptor.\n", id);
 226
 227     IMFMediaStream_Release(stream);
 228
 229     return hr;
 230 }
 231
 232 static HRESULT WINAPI source_reader_source_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 233 {
 234     struct source_reader *reader = impl_from_source_callback_IMFAsyncCallback(iface);
 235     MediaEventType event_type;
 236     IMFMediaSource *source;
 237     IMFMediaEvent *event;
 238     HRESULT hr;
 239
 240     TRACE("%p, %p.\n", iface, result);
 241
 242     source = (IMFMediaSource *)IMFAsyncResult_GetStateNoAddRef(result);
 243
 244     if (FAILED(hr = IMFMediaSource_EndGetEvent(source, result, &event)))
 245         return hr;
 246
 247     IMFMediaEvent_GetType(event, &event_type);
 248
 249     TRACE("Got event %u.\n", event_type);
 250
 251     switch (event_type)
 252     {
 253         case MENewStream:
 254             hr = source_reader_new_stream_handler(reader, event);
 255             break;
 256         default:
 257             ;
 258     }
 259
 260     if (FAILED(hr))
 261         WARN("Failed while handling %d event, hr %#x.\n", event_type, hr);
 262
 263     IMFMediaEvent_Release(event);
 264
 265     IMFMediaSource_BeginGetEvent(source, iface, (IUnknown *)source);
 266
 267     return S_OK;
 268 }
 269
 270 static const IMFAsyncCallbackVtbl source_events_callback_vtbl =
 271 {
 272     source_reader_source_events_callback_QueryInterface,
 273     source_reader_source_events_callback_AddRef,
 274     source_reader_source_events_callback_Release,
 275     source_reader_source_events_callback_GetParameters,
 276     source_reader_source_events_callback_Invoke,
 277 };
 278
 279 static ULONG WINAPI source_reader_stream_events_callback_AddRef(IMFAsyncCallback *iface)
 280 {
 281     struct source_reader *reader = impl_from_stream_callback_IMFAsyncCallback(iface);
 282     return IMFSourceReader_AddRef(&reader->IMFSourceReader_iface);
 283 }
 284
 285 static ULONG WINAPI source_reader_stream_events_callback_Release(IMFAsyncCallback *iface)
 286 {
 287     struct source_reader *reader = impl_from_stream_callback_IMFAsyncCallback(iface);
 288     return IMFSourceReader_Release(&reader->IMFSourceReader_iface);
 289 }
 290
 291 static HRESULT WINAPI source_reader_stream_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 292 {
 293     MediaEventType event_type;
 294     IMFMediaStream *stream;
 295     IMFMediaEvent *event;
 296     HRESULT hr;
 297
 298     TRACE("%p, %p.\n", iface, result);
 299
 300     stream = (IMFMediaStream *)IMFAsyncResult_GetStateNoAddRef(result);
 301
 302     if (FAILED(hr = IMFMediaStream_EndGetEvent(stream, result, &event)))
 303         return hr;
 304
 305     IMFMediaEvent_GetType(event, &event_type);
 306
 307     TRACE("Got event %u.\n", event_type);
 308
 309     IMFMediaEvent_Release(event);
 310
 311     IMFMediaStream_BeginGetEvent(stream, iface, (IUnknown *)stream);
 312
 313     return S_OK;
 314 }
 315
 316 static const IMFAsyncCallbackVtbl stream_events_callback_vtbl =
 317 {
 318     source_reader_source_events_callback_QueryInterface,
 319     source_reader_stream_events_callback_AddRef,
 320     source_reader_stream_events_callback_Release,
 321     source_reader_source_events_callback_GetParameters,
 322     source_reader_stream_events_callback_Invoke,
 323 };
 324
 325 static HRESULT WINAPI src_reader_QueryInterface(IMFSourceReader *iface, REFIID riid, void **out)
 326 {
 327     srcreader *This = impl_from_IMFSourceReader(iface);
 328
 329     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), out);
 330
 331     if(IsEqualGUID(riid, &IID_IUnknown) ||
 332        IsEqualGUID(riid, &IID_IMFSourceReader))
 333     {
 334         *out = &This->IMFSourceReader_iface;
 335     }
 336     else
 337     {
 338         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 339         *out = NULL;
 340         return E_NOINTERFACE;
 341     }
 342
 343     IUnknown_AddRef((IUnknown*)*out);
 344     return S_OK;
 345 }
 346
 347 static ULONG WINAPI src_reader_AddRef(IMFSourceReader *iface)
 348 {
 349     srcreader *This = impl_from_IMFSourceReader(iface);
 350     ULONG ref = InterlockedIncrement(&This->refcount);
 351
 352     TRACE("(%p) ref=%u\n", This, ref);
 353
 354     return ref;
 355 }
 356
 357 static ULONG WINAPI src_reader_Release(IMFSourceReader *iface)
 358 {
 359     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 360     ULONG refcount = InterlockedDecrement(&reader->refcount);
 361     unsigned int i;
 362
 363     TRACE("%p, refcount %d.\n", iface, refcount);
 364
 365     if (!refcount)
 366     {
 367         if (reader->async_callback)
 368             IMFSourceReaderCallback_Release(reader->async_callback);
 369         if (reader->shutdown_on_release)
 370             IMFMediaSource_Shutdown(reader->source);
 371         if (reader->descriptor)
 372             IMFPresentationDescriptor_Release(reader->descriptor);
 373         IMFMediaSource_Release(reader->source);
 374
 375         for (i = 0; i < reader->stream_count; ++i)
 376         {
 377             if (reader->streams[i].stream)
 378                 IMFMediaStream_Release(reader->streams[i].stream);
 379             if (reader->streams[i].current)
 380                 IMFMediaType_Release(reader->streams[i].current);
 381         }
 382         heap_free(reader->streams);
 383         DeleteCriticalSection(&reader->cs);
 384         heap_free(reader);
 385     }
 386
 387     return refcount;
 388 }
 389
 390 static HRESULT WINAPI src_reader_GetStreamSelection(IMFSourceReader *iface, DWORD index, BOOL *selected)
 391 {
 392     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 393     IMFStreamDescriptor *sd;
 394
 395     TRACE("%p, %#x, %p.\n", iface, index, selected);
 396
 397     switch (index)
 398     {
 399         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
 400             index = reader->first_video_stream_index;
 401             break;
 402         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
 403             index = reader->first_audio_stream_index;
 404             break;
 405         default:
 406             ;
 407     }
 408
 409     if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(reader->descriptor, index, selected, &sd)))
 410         return MF_E_INVALIDSTREAMNUMBER;
 411     IMFStreamDescriptor_Release(sd);
 412
 413     return S_OK;
 414 }
 415
 416 static HRESULT WINAPI src_reader_SetStreamSelection(IMFSourceReader *iface, DWORD index, BOOL selected)
 417 {
 418     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 419     unsigned int count;
 420     HRESULT hr;
 421
 422     TRACE("%p, %#x, %d.\n", iface, index, selected);
 423
 424     switch (index)
 425     {
 426         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
 427             index = reader->first_video_stream_index;
 428             break;
 429         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
 430             index = reader->first_audio_stream_index;
 431             break;
 432         case MF_SOURCE_READER_ALL_STREAMS:
 433             if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorCount(reader->descriptor, &count)))
 434                 return hr;
 435
 436             for (index = 0; index < count; ++index)
 437             {
 438                 if (selected)
 439                     IMFPresentationDescriptor_SelectStream(reader->descriptor, index);
 440                 else
 441                     IMFPresentationDescriptor_DeselectStream(reader->descriptor, index);
 442             }
 443
 444             return S_OK;
 445         default:
 446             ;
 447     }
 448
 449     if (selected)
 450         hr = IMFPresentationDescriptor_SelectStream(reader->descriptor, index);
 451     else
 452         hr = IMFPresentationDescriptor_DeselectStream(reader->descriptor, index);
 453
 454     if (FAILED(hr))
 455         return MF_E_INVALIDSTREAMNUMBER;
 456
 457     return S_OK;
 458 }
 459
 460 static HRESULT WINAPI src_reader_GetNativeMediaType(IMFSourceReader *iface, DWORD index, DWORD type_index,
 461             IMFMediaType **type)
 462 {
 463     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 464     IMFMediaTypeHandler *handler;
 465     IMFStreamDescriptor *sd;
 466     BOOL selected;
 467     HRESULT hr;
 468
 469     TRACE("%p, %#x, %#x, %p.\n", iface, index, type_index, type);
 470
 471     switch (index)
 472     {
 473         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
 474             index = reader->first_video_stream_index;
 475             break;
 476         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
 477             index = reader->first_audio_stream_index;
 478             break;
 479         default:
 480             ;
 481     }
 482
 483     if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(reader->descriptor, index, &selected, &sd)))
 484         return MF_E_INVALIDSTREAMNUMBER;
 485
 486     hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler);
 487     IMFStreamDescriptor_Release(sd);
 488     if (FAILED(hr))
 489         return hr;
 490
 491     if (type_index == MF_SOURCE_READER_CURRENT_TYPE_INDEX)
 492         hr = IMFMediaTypeHandler_GetCurrentMediaType(handler, type);
 493     else
 494         hr = IMFMediaTypeHandler_GetMediaTypeByIndex(handler, type_index, type);
 495     IMFMediaTypeHandler_Release(handler);
 496
 497     return hr;
 498 }
 499
 500 static HRESULT WINAPI src_reader_GetCurrentMediaType(IMFSourceReader *iface, DWORD index, IMFMediaType **type)
 501 {
 502     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 503     HRESULT hr;
 504
 505     TRACE("%p, %#x, %p.\n", iface, index, type);
 506
 507     switch (index)
 508     {
 509         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
 510             index = reader->first_video_stream_index;
 511             break;
 512         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
 513             index = reader->first_audio_stream_index;
 514             break;
 515         default:
 516             ;
 517     }
 518
 519     if (index >= reader->stream_count)
 520         return MF_E_INVALIDSTREAMNUMBER;
 521
 522     if (FAILED(hr = MFCreateMediaType(type)))
 523         return hr;
 524
 525     EnterCriticalSection(&reader->cs);
 526
 527     hr = IMFMediaType_CopyAllItems(reader->streams[index].current, (IMFAttributes *)*type);
 528
 529     LeaveCriticalSection(&reader->cs);
 530
 531     return hr;
 532 }
 533
 534 static HRESULT WINAPI src_reader_SetCurrentMediaType(IMFSourceReader *iface, DWORD index, DWORD *reserved,
 535         IMFMediaType *type)
 536 {
 537     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 538     HRESULT hr;
 539
 540     TRACE("%p, %#x, %p, %p.\n", iface, index, reserved, type);
 541
 542     switch (index)
 543     {
 544         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
 545             index = reader->first_video_stream_index;
 546             break;
 547         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
 548             index = reader->first_audio_stream_index;
 549             break;
 550         default:
 551             ;
 552     }
 553
 554     if (index >= reader->stream_count)
 555         return MF_E_INVALIDSTREAMNUMBER;
 556
 557     /* FIXME: validate passed type and current presentation state. */
 558
 559     EnterCriticalSection(&reader->cs);
 560
 561     hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)reader->streams[index].current);
 562
 563     LeaveCriticalSection(&reader->cs);
 564
 565     return hr;
 566 }
 567
 568 static HRESULT WINAPI src_reader_SetCurrentPosition(IMFSourceReader *iface, REFGUID format, REFPROPVARIANT position)
 569 {
 570     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 571     DWORD flags;
 572     HRESULT hr;
 573
 574     TRACE("%p, %s, %p.\n", iface, debugstr_guid(format), position);
 575
 576     /* FIXME: fail if we got pending samples. */
 577
 578     if (FAILED(hr = IMFMediaSource_GetCharacteristics(reader->source, &flags)))
 579         return hr;
 580
 581     if (!(flags & MFMEDIASOURCE_CAN_SEEK))
 582         return MF_E_INVALIDREQUEST;
 583
 584     return IMFMediaSource_Start(reader->source, reader->descriptor, format, position);
 585 }
 586
 587 static HRESULT WINAPI src_reader_ReadSample(IMFSourceReader *iface, DWORD index,
 588         DWORD flags, DWORD *actualindex, DWORD *sampleflags, LONGLONG *timestamp,
 589         IMFSample **sample)
 590 {
 591     srcreader *This = impl_from_IMFSourceReader(iface);
 592     FIXME("%p, 0x%08x, 0x%08x, %p, %p, %p, %p\n", This, index, flags, actualindex,
 593           sampleflags, timestamp, sample);
 594     return E_NOTIMPL;
 595 }
 596
 597 static HRESULT WINAPI src_reader_Flush(IMFSourceReader *iface, DWORD index)
 598 {
 599     srcreader *This = impl_from_IMFSourceReader(iface);
 600     FIXME("%p, 0x%08x\n", This, index);
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI src_reader_GetServiceForStream(IMFSourceReader *iface, DWORD index, REFGUID service,
 605         REFIID riid, void **object)
 606 {
 607     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 608     IUnknown *obj = NULL;
 609     HRESULT hr;
 610
 611     TRACE("%p, %#x, %s, %s, %p\n", iface, index, debugstr_guid(service), debugstr_guid(riid), object);
 612
 613     switch (index)
 614     {
 615         case MF_SOURCE_READER_MEDIASOURCE:
 616             obj = (IUnknown *)reader->source;
 617             break;
 618         default:
 619             FIXME("Unsupported index %#x.\n", index);
 620             return E_NOTIMPL;
 621     }
 622
 623     if (IsEqualGUID(service, &GUID_NULL))
 624     {
 625         hr = IUnknown_QueryInterface(obj, riid, object);
 626     }
 627     else
 628     {
 629         IMFGetService *gs;
 630
 631         hr = IUnknown_QueryInterface(obj, &IID_IMFGetService, (void **)&gs);
 632         if (SUCCEEDED(hr))
 633         {
 634             hr = IMFGetService_GetService(gs, service, riid, object);
 635             IMFGetService_Release(gs);
 636         }
 637     }
 638
 639     return hr;
 640 }
 641
 642 static HRESULT WINAPI src_reader_GetPresentationAttribute(IMFSourceReader *iface, DWORD index,
 643         REFGUID guid, PROPVARIANT *value)
 644 {
 645     struct source_reader *reader = impl_from_IMFSourceReader(iface);
 646     IMFStreamDescriptor *sd;
 647     BOOL selected;
 648     HRESULT hr;
 649
 650     TRACE("%p, %#x, %s, %p.\n", iface, index, debugstr_guid(guid), value);
 651
 652     switch (index)
 653     {
 654         case MF_SOURCE_READER_MEDIASOURCE:
 655             if (IsEqualGUID(guid, &MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS))
 656             {
 657                 DWORD flags;
 658
 659                 if (FAILED(hr = IMFMediaSource_GetCharacteristics(reader->source, &flags)))
 660                     return hr;
 661
 662                 value->vt = VT_UI4;
 663                 value->u.ulVal = flags;
 664                 return S_OK;
 665             }
 666             else
 667             {
 668                 return IMFPresentationDescriptor_GetItem(reader->descriptor, guid, value);
 669             }
 670             break;
 671         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
 672             index = reader->first_video_stream_index;
 673             break;
 674         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
 675             index = reader->first_audio_stream_index;
 676             break;
 677         default:
 678             ;
 679     }
 680
 681     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(reader->descriptor, index, &selected, &sd)))
 682         return hr;
 683
 684     hr = IMFStreamDescriptor_GetItem(sd, guid, value);
 685     IMFStreamDescriptor_Release(sd);
 686
 687     return hr;
 688 }
 689
 690 struct IMFSourceReaderVtbl srcreader_vtbl =
 691 {
 692     src_reader_QueryInterface,
 693     src_reader_AddRef,
 694     src_reader_Release,
 695     src_reader_GetStreamSelection,
 696     src_reader_SetStreamSelection,
 697     src_reader_GetNativeMediaType,
 698     src_reader_GetCurrentMediaType,
 699     src_reader_SetCurrentMediaType,
 700     src_reader_SetCurrentPosition,
 701     src_reader_ReadSample,
 702     src_reader_Flush,
 703     src_reader_GetServiceForStream,
 704     src_reader_GetPresentationAttribute
 705 };
 706
 707 static DWORD reader_get_first_stream_index(IMFPresentationDescriptor *descriptor, const GUID *major)
 708 {
 709     unsigned int count, i;
 710     BOOL selected;
 711     HRESULT hr;
 712     GUID guid;
 713
 714     if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorCount(descriptor, &count)))
 715         return MF_SOURCE_READER_INVALID_STREAM_INDEX;
 716
 717     for (i = 0; i < count; ++i)
 718     {
 719         IMFMediaTypeHandler *handler;
 720         IMFStreamDescriptor *sd;
 721
 722         if (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(descriptor, i, &selected, &sd)))
 723         {
 724             hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler);
 725             IMFStreamDescriptor_Release(sd);
 726             if (SUCCEEDED(hr))
 727             {
 728                 hr = IMFMediaTypeHandler_GetMajorType(handler, &guid);
 729                 IMFMediaTypeHandler_Release(handler);
 730                 if (SUCCEEDED(hr) && IsEqualGUID(&guid, major))
 731                 {
 732                     return i;
 733                 }
 734             }
 735         }
 736     }
 737
 738     return MF_SOURCE_READER_INVALID_STREAM_INDEX;
 739 }
 740
 741 static HRESULT create_source_reader_from_source(IMFMediaSource *source, IMFAttributes *attributes,
 742         BOOL shutdown_on_release, REFIID riid, void **out)
 743 {
 744     struct source_reader *object;
 745     unsigned int i;
 746     HRESULT hr;
 747
 748     object = heap_alloc_zero(sizeof(*object));
 749     if (!object)
 750         return E_OUTOFMEMORY;
 751
 752     object->IMFSourceReader_iface.lpVtbl = &srcreader_vtbl;
 753     object->source_events_callback.lpVtbl = &source_events_callback_vtbl;
 754     object->stream_events_callback.lpVtbl = &stream_events_callback_vtbl;
 755     object->refcount = 1;
 756     object->source = source;
 757     IMFMediaSource_AddRef(object->source);
 758     InitializeCriticalSection(&object->cs);
 759
 760     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(object->source, &object->descriptor)))
 761         goto failed;
 762
 763     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorCount(object->descriptor, &object->stream_count)))
 764         goto failed;
 765
 766     if (!(object->streams = heap_alloc_zero(object->stream_count * sizeof(*object->streams))))
 767     {
 768         hr = E_OUTOFMEMORY;
 769         goto failed;
 770     }
 771
 772     /* Set initial current media types. */
 773     for (i = 0; i < object->stream_count; ++i)
 774     {
 775         IMFMediaTypeHandler *handler;
 776         IMFStreamDescriptor *sd;
 777         IMFMediaType *src_type;
 778         BOOL selected;
 779
 780         if (FAILED(hr = MFCreateMediaType(&object->streams[i].current)))
 781             break;
 782
 783         if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(object->descriptor, i, &selected, &sd)))
 784             break;
 785
 786         if (FAILED(hr = IMFStreamDescriptor_GetStreamIdentifier(sd, &object->streams[i].id)))
 787             WARN("Failed to get stream identifier, hr %#x.\n", hr);
 788
 789         hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler);
 790         IMFStreamDescriptor_Release(sd);
 791         if (FAILED(hr))
 792             break;
 793
 794         hr = IMFMediaTypeHandler_GetMediaTypeByIndex(handler, 0, &src_type);
 795         IMFMediaTypeHandler_Release(handler);
 796         if (FAILED(hr))
 797             break;
 798
 799         hr = IMFMediaType_CopyAllItems(src_type, (IMFAttributes *)object->streams[i].current);
 800         IMFMediaType_Release(src_type);
 801         if (FAILED(hr))
 802             break;
 803     }
 804
 805     if (FAILED(hr))
 806         goto failed;
 807
 808     /* At least one major type has to be set. */
 809     object->first_audio_stream_index = reader_get_first_stream_index(object->descriptor, &MFMediaType_Audio);
 810     object->first_video_stream_index = reader_get_first_stream_index(object->descriptor, &MFMediaType_Video);
 811
 812     if (object->first_audio_stream_index == MF_SOURCE_READER_INVALID_STREAM_INDEX &&
 813             object->first_video_stream_index == MF_SOURCE_READER_INVALID_STREAM_INDEX)
 814     {
 815         hr = MF_E_ATTRIBUTENOTFOUND;
 816     }
 817
 818     if (FAILED(hr = IMFMediaSource_BeginGetEvent(object->source, &object->source_events_callback,
 819             (IUnknown *)object->source)))
 820     {
 821         goto failed;
 822     }
 823
 824     if (attributes)
 825     {
 826         IMFAttributes_GetUnknown(attributes, &MF_SOURCE_READER_ASYNC_CALLBACK, &IID_IMFSourceReaderCallback,
 827                 (void **)&object->async_callback);
 828         if (object->async_callback)
 829             TRACE("Using async callback %p.\n", object->async_callback);
 830     }
 831
 832     hr = IMFSourceReader_QueryInterface(&object->IMFSourceReader_iface, riid, out);
 833
 834 failed:
 835     IMFSourceReader_Release(&object->IMFSourceReader_iface);
 836     return hr;
 837 }
 838
 839 static HRESULT bytestream_get_url_hint(IMFByteStream *stream, WCHAR const **url)
 840 {
 841     static const UINT8 asfmagic[] = {0x30,0x26,0xb2,0x75,0x8e,0x66,0xcf,0x11,0xa6,0xd9,0x00,0xaa,0x00,0x62,0xce,0x6c};
 842     static const UINT8 wavmagic[] = { 'R', 'I', 'F', 'F',0x00,0x00,0x00,0x00, 'W', 'A', 'V', 'E', 'f', 'm', 't', ' '};
 843     static const UINT8 wavmask[]  = {0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
 844     static const WCHAR asfW[] = {'.','a','s','f',0};
 845     static const WCHAR wavW[] = {'.','w','a','v',0};
 846     static const struct stream_content_url_hint
 847     {
 848         const UINT8 *magic;
 849         UINT32 magic_len;
 850         const WCHAR *url;
 851         const UINT8 *mask;
 852     }
 853     url_hints[] =
 854     {
 855         { asfmagic, sizeof(asfmagic), asfW },
 856         { wavmagic, sizeof(wavmagic), wavW, wavmask },
 857     };
 858     UINT8 buffer[4 * sizeof(unsigned int)];
 859     IMFAttributes *attributes;
 860     UINT32 length = 0;
 861     unsigned int i, j;
 862     DWORD caps = 0;
 863     QWORD position;
 864     HRESULT hr;
 865
 866     *url = NULL;
 867
 868     if (SUCCEEDED(IMFByteStream_QueryInterface(stream, &IID_IMFAttributes, (void **)&attributes)))
 869     {
 870         IMFAttributes_GetStringLength(attributes, &MF_BYTESTREAM_CONTENT_TYPE, &length);
 871         IMFAttributes_Release(attributes);
 872     }
 873
 874     if (length)
 875         return S_OK;
 876
 877     if (FAILED(hr = IMFByteStream_GetCapabilities(stream, &caps)))
 878         return hr;
 879
 880     if (!(caps & MFBYTESTREAM_IS_SEEKABLE))
 881         return S_OK;
 882
 883     if (FAILED(hr = IMFByteStream_GetCurrentPosition(stream, &position)))
 884         return hr;
 885
 886     hr = IMFByteStream_Read(stream, buffer, sizeof(buffer), &length);
 887     IMFByteStream_SetCurrentPosition(stream, position);
 888     if (FAILED(hr))
 889         return hr;
 890
 891     if (length < sizeof(buffer))
 892         return S_OK;
 893
 894     for (i = 0; i < ARRAY_SIZE(url_hints); ++i)
 895     {
 896         if (url_hints[i].mask)
 897         {
 898             unsigned int *mask = (unsigned int *)url_hints[i].mask;
 899             unsigned int *data = (unsigned int *)buffer;
 900
 901             for (j = 0; j < sizeof(buffer) / sizeof(unsigned int); ++j)
 902                 data[j] &= mask[j];
 903
 904         }
 905         if (!memcmp(buffer, url_hints[i].magic, min(url_hints[i].magic_len, length)))
 906         {
 907             *url = url_hints[i].url;
 908             break;
 909         }
 910     }
 911
 912     if (!*url)
 913         WARN("Unrecognized content type %s.\n", debugstr_an((char *)buffer, length));
 914
 915     return S_OK;
 916 }
 917
 918 static HRESULT create_source_reader_from_stream(IMFByteStream *stream, IMFAttributes *attributes,
 919         REFIID riid, void **out)
 920 {
 921     IPropertyStore *props = NULL;
 922     IMFSourceResolver *resolver;
 923     MF_OBJECT_TYPE obj_type;
 924     IMFMediaSource *source;
 925     const WCHAR *url;
 926     HRESULT hr;
 927
 928     /* If stream does not have content type set, try to guess from starting byte sequence. */
 929     if (FAILED(hr = bytestream_get_url_hint(stream, &url)))
 930         return hr;
 931
 932     if (FAILED(hr = MFCreateSourceResolver(&resolver)))
 933         return hr;
 934
 935     if (attributes)
 936         IMFAttributes_GetUnknown(attributes, &MF_SOURCE_READER_MEDIASOURCE_CONFIG, &IID_IPropertyStore,
 937                 (void **)&props);
 938
 939     hr = IMFSourceResolver_CreateObjectFromByteStream(resolver, stream, url, MF_RESOLUTION_MEDIASOURCE, props,
 940             &obj_type, (IUnknown **)&source);
 941     IMFSourceResolver_Release(resolver);
 942     if (props)
 943         IPropertyStore_Release(props);
 944     if (FAILED(hr))
 945         return hr;
 946
 947     hr = create_source_reader_from_source(source, attributes, TRUE, riid, out);
 948     IMFMediaSource_Release(source);
 949     return hr;
 950 }
 951
 952 static HRESULT create_source_reader_from_url(const WCHAR *url, IMFAttributes *attributes, REFIID riid, void **out)
 953 {
 954     IPropertyStore *props = NULL;
 955     IMFSourceResolver *resolver;
 956     IUnknown *object = NULL;
 957     MF_OBJECT_TYPE obj_type;
 958     IMFMediaSource *source;
 959     HRESULT hr;
 960
 961     if (FAILED(hr = MFCreateSourceResolver(&resolver)))
 962         return hr;
 963
 964     if (attributes)
 965         IMFAttributes_GetUnknown(attributes, &MF_SOURCE_READER_MEDIASOURCE_CONFIG, &IID_IPropertyStore,
 966                 (void **)&props);
 967
 968     hr = IMFSourceResolver_CreateObjectFromURL(resolver, url, MF_RESOLUTION_MEDIASOURCE, props, &obj_type,
 969             &object);
 970     if (SUCCEEDED(hr))
 971     {
 972         switch (obj_type)
 973         {
 974             case MF_OBJECT_BYTESTREAM:
 975                 hr = IMFSourceResolver_CreateObjectFromByteStream(resolver, (IMFByteStream *)object, NULL,
 976                         MF_RESOLUTION_MEDIASOURCE, props, &obj_type, (IUnknown **)&source);
 977                 break;
 978             case MF_OBJECT_MEDIASOURCE:
 979                 source = (IMFMediaSource *)object;
 980                 IMFMediaSource_AddRef(source);
 981                 break;
 982             default:
 983                 WARN("Unknown object type %d.\n", obj_type);
 984                 hr = E_UNEXPECTED;
 985         }
 986         IUnknown_Release(object);
 987     }
 988
 989     IMFSourceResolver_Release(resolver);
 990     if (props)
 991         IPropertyStore_Release(props);
 992     if (FAILED(hr))
 993         return hr;
 994
 995     hr = create_source_reader_from_source(source, attributes, TRUE, riid, out);
 996     IMFMediaSource_Release(source);
 997     return hr;
 998 }
 999
1000 static HRESULT WINAPI sink_writer_QueryInterface(IMFSinkWriter *iface, REFIID riid, void **out)
1001 {
1002     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
1003
1004     if (IsEqualIID(riid, &IID_IMFSinkWriter) ||
1005             IsEqualIID(riid, &IID_IUnknown))
1006     {
1007         *out = iface;
1008         IMFSinkWriter_AddRef(iface);
1009         return S_OK;
1010     }
1011
1012     WARN("Unsupported %s.\n", debugstr_guid(riid));
1013     *out = NULL;
1014     return E_NOINTERFACE;
1015 }
1016
1017 static ULONG WINAPI sink_writer_AddRef(IMFSinkWriter *iface)
1018 {
1019     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
1020     ULONG refcount = InterlockedIncrement(&writer->refcount);
1021
1022     TRACE("%p, %u.\n", iface, refcount);
1023
1024     return refcount;
1025 }
1026
1027 static ULONG WINAPI sink_writer_Release(IMFSinkWriter *iface)
1028 {
1029     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
1030     ULONG refcount = InterlockedDecrement(&writer->refcount);
1031
1032     TRACE("%p, %u.\n", iface, refcount);
1033
1034     if (!refcount)
1035     {
1036         heap_free(writer);
1037     }
1038
1039     return refcount;
1040 }
1041
1042 static HRESULT WINAPI sink_writer_AddStream(IMFSinkWriter *iface, IMFMediaType *type, DWORD *index)
1043 {
1044     FIXME("%p, %p, %p.\n", iface, type, index);
1045
1046     return E_NOTIMPL;
1047 }
1048
1049 static HRESULT WINAPI sink_writer_SetInputMediaType(IMFSinkWriter *iface, DWORD index, IMFMediaType *type,
1050         IMFAttributes *parameters)
1051 {
1052     FIXME("%p, %u, %p, %p.\n", iface, index, type, parameters);
1053
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI sink_writer_BeginWriting(IMFSinkWriter *iface)
1058 {
1059     FIXME("%p.\n", iface);
1060
1061     return E_NOTIMPL;
1062 }
1063
1064 static HRESULT WINAPI sink_writer_WriteSample(IMFSinkWriter *iface, DWORD index, IMFSample *sample)
1065 {
1066     FIXME("%p, %u, %p.\n", iface, index, sample);
1067
1068     return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI sink_writer_SendStreamTick(IMFSinkWriter *iface, DWORD index, LONGLONG timestamp)
1072 {
1073     FIXME("%p, %u, %s.\n", iface, index, wine_dbgstr_longlong(timestamp));
1074
1075     return E_NOTIMPL;
1076 }
1077
1078 static HRESULT WINAPI sink_writer_PlaceMarker(IMFSinkWriter *iface, DWORD index, void *context)
1079 {
1080     FIXME("%p, %u, %p.\n", iface, index, context);
1081
1082     return E_NOTIMPL;
1083 }
1084
1085 static HRESULT WINAPI sink_writer_NotifyEndOfSegment(IMFSinkWriter *iface, DWORD index)
1086 {
1087     FIXME("%p, %u.\n", iface, index);
1088
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI sink_writer_Flush(IMFSinkWriter *iface, DWORD index)
1093 {
1094     FIXME("%p, %u.\n", iface, index);
1095
1096     return E_NOTIMPL;
1097 }
1098
1099 static HRESULT WINAPI sink_writer_Finalize(IMFSinkWriter *iface)
1100 {
1101     FIXME("%p.\n", iface);
1102
1103     return E_NOTIMPL;
1104 }
1105
1106 static HRESULT WINAPI sink_writer_GetServiceForStream(IMFSinkWriter *iface, DWORD index, REFGUID service,
1107         REFIID riid, void **object)
1108 {
1109     FIXME("%p, %u, %s, %s, %p.\n", iface, index, debugstr_guid(service), debugstr_guid(riid), object);
1110
1111     return E_NOTIMPL;
1112 }
1113
1114 static HRESULT WINAPI sink_writer_GetStatistics(IMFSinkWriter *iface, DWORD index, MF_SINK_WRITER_STATISTICS *stats)
1115 {
1116     FIXME("%p, %u, %p.\n", iface, index, stats);
1117
1118     return E_NOTIMPL;
1119 }
1120
1121 static const IMFSinkWriterVtbl sink_writer_vtbl =
1122 {
1123     sink_writer_QueryInterface,
1124     sink_writer_AddRef,
1125     sink_writer_Release,
1126     sink_writer_AddStream,
1127     sink_writer_SetInputMediaType,
1128     sink_writer_BeginWriting,
1129     sink_writer_WriteSample,
1130     sink_writer_SendStreamTick,
1131     sink_writer_PlaceMarker,
1132     sink_writer_NotifyEndOfSegment,
1133     sink_writer_Flush,
1134     sink_writer_Finalize,
1135     sink_writer_GetServiceForStream,
1136     sink_writer_GetStatistics,
1137 };
1138
1139 static HRESULT create_sink_writer_from_sink(IMFMediaSink *sink, IMFAttributes *attributes,
1140         REFIID riid, void **out)
1141 {
1142     struct sink_writer *object;
1143     HRESULT hr;
1144
1145     object = heap_alloc(sizeof(*object));
1146     if (!object)
1147         return E_OUTOFMEMORY;
1148
1149     object->IMFSinkWriter_iface.lpVtbl = &sink_writer_vtbl;
1150     object->refcount = 1;
1151
1152     hr = IMFSinkWriter_QueryInterface(&object->IMFSinkWriter_iface, riid, out);
1153     IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
1154     return hr;
1155 }
1156
1157 static HRESULT create_sink_writer_from_stream(IMFByteStream *stream, IMFAttributes *attributes,
1158         REFIID riid, void **out)
1159 {
1160     struct sink_writer *object;
1161     HRESULT hr;
1162
1163     object = heap_alloc(sizeof(*object));
1164     if (!object)
1165         return E_OUTOFMEMORY;
1166
1167     object->IMFSinkWriter_iface.lpVtbl = &sink_writer_vtbl;
1168     object->refcount = 1;
1169
1170     hr = IMFSinkWriter_QueryInterface(&object->IMFSinkWriter_iface, riid, out);
1171     IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
1172     return hr;
1173 }
1174
1175 /***********************************************************************
1176  *      MFCreateSinkWriterFromMediaSink (mfreadwrite.@)
1177  */
1178 HRESULT WINAPI MFCreateSinkWriterFromMediaSink(IMFMediaSink *sink, IMFAttributes *attributes, IMFSinkWriter **writer)
1179 {
1180     TRACE("%p, %p, %p.\n", sink, attributes, writer);
1181
1182     return create_sink_writer_from_sink(sink, attributes, &IID_IMFSinkWriter, (void **)writer);
1183 }
1184
1185 static HRESULT create_source_reader_from_object(IUnknown *unk, IMFAttributes *attributes, REFIID riid, void **out)
1186 {
1187     IMFMediaSource *source = NULL;
1188     IMFByteStream *stream = NULL;
1189     HRESULT hr;
1190
1191     hr = IUnknown_QueryInterface(unk, &IID_IMFMediaSource, (void **)&source);
1192     if (FAILED(hr))
1193         hr = IUnknown_QueryInterface(unk, &IID_IMFByteStream, (void **)&stream);
1194
1195     if (source)
1196     {
1197         UINT32 disconnect = 0;
1198
1199         if (attributes)
1200             IMFAttributes_GetUINT32(attributes, &MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN, &disconnect);
1201         hr = create_source_reader_from_source(source, attributes, !disconnect, riid, out);
1202     }
1203     else if (stream)
1204         hr = create_source_reader_from_stream(stream, attributes, riid, out);
1205
1206     if (source)
1207         IMFMediaSource_Release(source);
1208     if (stream)
1209         IMFByteStream_Release(stream);
1210
1211     return hr;
1212 }
1213
1214 /***********************************************************************
1215  *      MFCreateSourceReaderFromByteStream (mfreadwrite.@)
1216  */
1217 HRESULT WINAPI MFCreateSourceReaderFromByteStream(IMFByteStream *stream, IMFAttributes *attributes,
1218         IMFSourceReader **reader)
1219 {
1220     TRACE("%p, %p, %p.\n", stream, attributes, reader);
1221
1222     return create_source_reader_from_object((IUnknown *)stream, attributes, &IID_IMFSourceReader, (void **)reader);
1223 }
1224
1225 /***********************************************************************
1226  *      MFCreateSourceReaderFromMediaSource (mfreadwrite.@)
1227  */
1228 HRESULT WINAPI MFCreateSourceReaderFromMediaSource(IMFMediaSource *source, IMFAttributes *attributes,
1229         IMFSourceReader **reader)
1230 {
1231     TRACE("%p, %p, %p.\n", source, attributes, reader);
1232
1233     return create_source_reader_from_object((IUnknown *)source, attributes, &IID_IMFSourceReader, (void **)reader);
1234 }
1235
1236 /***********************************************************************
1237  *      MFCreateSourceReaderFromURL (mfreadwrite.@)
1238  */
1239 HRESULT WINAPI MFCreateSourceReaderFromURL(const WCHAR *url, IMFAttributes *attributes, IMFSourceReader **reader)
1240 {
1241     TRACE("%s, %p, %p.\n", debugstr_w(url), attributes, reader);
1242
1243     return create_source_reader_from_url(url, attributes, &IID_IMFSourceReader, (void **)reader);
1244 }
1245
1246 static HRESULT WINAPI readwrite_factory_QueryInterface(IMFReadWriteClassFactory *iface, REFIID riid, void **out)
1247 {
1248     if (IsEqualIID(riid, &IID_IMFReadWriteClassFactory) ||
1249             IsEqualIID(riid, &IID_IUnknown))
1250     {
1251         *out = iface;
1252         IMFReadWriteClassFactory_AddRef(iface);
1253         return S_OK;
1254     }
1255
1256     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1257     *out = NULL;
1258     return E_NOINTERFACE;
1259 }
1260
1261 static ULONG WINAPI readwrite_factory_AddRef(IMFReadWriteClassFactory *iface)
1262 {
1263     return 2;
1264 }
1265
1266 static ULONG WINAPI readwrite_factory_Release(IMFReadWriteClassFactory *iface)
1267 {
1268     return 1;
1269 }
1270
1271 static HRESULT WINAPI readwrite_factory_CreateInstanceFromURL(IMFReadWriteClassFactory *iface, REFCLSID clsid,
1272         const WCHAR *url, IMFAttributes *attributes, REFIID riid, void **out)
1273 {
1274     TRACE("%s, %s, %p, %s, %p.\n", debugstr_guid(clsid), debugstr_w(url), attributes, debugstr_guid(riid), out);
1275
1276     if (IsEqualGUID(clsid, &CLSID_MFSourceReader))
1277     {
1278         return create_source_reader_from_url(url, attributes, &IID_IMFSourceReader, out);
1279     }
1280
1281     FIXME("Unsupported %s.\n", debugstr_guid(clsid));
1282
1283     return E_NOTIMPL;
1284 }
1285
1286 static HRESULT WINAPI readwrite_factory_CreateInstanceFromObject(IMFReadWriteClassFactory *iface, REFCLSID clsid,
1287         IUnknown *unk, IMFAttributes *attributes, REFIID riid, void **out)
1288 {
1289     HRESULT hr;
1290
1291     TRACE("%s, %p, %p, %s, %p.\n", debugstr_guid(clsid), unk, attributes, debugstr_guid(riid), out);
1292
1293     if (IsEqualGUID(clsid, &CLSID_MFSourceReader))
1294     {
1295         return create_source_reader_from_object(unk, attributes, riid, out);
1296     }
1297     else if (IsEqualGUID(clsid, &CLSID_MFSinkWriter))
1298     {
1299         IMFByteStream *stream = NULL;
1300         IMFMediaSink *sink = NULL;
1301
1302         hr = IUnknown_QueryInterface(unk, &IID_IMFByteStream, (void **)&stream);
1303         if (FAILED(hr))
1304             hr = IUnknown_QueryInterface(unk, &IID_IMFMediaSink, (void **)&sink);
1305
1306         if (stream)
1307             hr = create_sink_writer_from_stream(stream, attributes, riid, out);
1308         else if (sink)
1309             hr = create_sink_writer_from_sink(sink, attributes, riid, out);
1310
1311         if (sink)
1312             IMFMediaSink_Release(sink);
1313         if (stream)
1314             IMFByteStream_Release(stream);
1315
1316         return hr;
1317     }
1318     else
1319     {
1320         WARN("Unsupported class %s.\n", debugstr_guid(clsid));
1321         *out = NULL;
1322         return E_FAIL;
1323     }
1324 }
1325
1326 static const IMFReadWriteClassFactoryVtbl readwrite_factory_vtbl =
1327 {
1328     readwrite_factory_QueryInterface,
1329     readwrite_factory_AddRef,
1330     readwrite_factory_Release,
1331     readwrite_factory_CreateInstanceFromURL,
1332     readwrite_factory_CreateInstanceFromObject,
1333 };
1334
1335 static IMFReadWriteClassFactory readwrite_factory = { &readwrite_factory_vtbl };
1336
1337 static HRESULT WINAPI classfactory_QueryInterface(IClassFactory *iface, REFIID riid, void **out)
1338 {
1339     TRACE("%s, %p.\n", debugstr_guid(riid), out);
1340
1341     if (IsEqualGUID(riid, &IID_IClassFactory) ||
1342             IsEqualGUID(riid, &IID_IUnknown))
1343     {
1344         IClassFactory_AddRef(iface);
1345         *out = iface;
1346         return S_OK;
1347     }
1348
1349     WARN("interface %s not implemented\n", debugstr_guid(riid));
1350     *out = NULL;
1351     return E_NOINTERFACE;
1352 }
1353
1354 static ULONG WINAPI classfactory_AddRef(IClassFactory *iface)
1355 {
1356     return 2;
1357 }
1358
1359 static ULONG WINAPI classfactory_Release(IClassFactory *iface)
1360 {
1361     return 1;
1362 }
1363
1364 static HRESULT WINAPI classfactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **out)
1365 {
1366     TRACE("%p, %s, %p.\n", outer, debugstr_guid(riid), out);
1367
1368     *out = NULL;
1369
1370     if (outer)
1371         return CLASS_E_NOAGGREGATION;
1372
1373     return IMFReadWriteClassFactory_QueryInterface(&readwrite_factory, riid, out);
1374 }
1375
1376 static HRESULT WINAPI classfactory_LockServer(IClassFactory *iface, BOOL dolock)
1377 {
1378     FIXME("%d.\n", dolock);
1379     return S_OK;
1380 }
1381
1382 static const struct IClassFactoryVtbl classfactoryvtbl =
1383 {
1384     classfactory_QueryInterface,
1385     classfactory_AddRef,
1386     classfactory_Release,
1387     classfactory_CreateInstance,
1388     classfactory_LockServer,
1389 };
1390
1391 static IClassFactory classfactory = { &classfactoryvtbl };
1392
1393 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **out)
1394 {
1395     TRACE("%s, %s, %p.\n", debugstr_guid(clsid), debugstr_guid(riid), out);
1396
1397     if (IsEqualGUID(clsid, &CLSID_MFReadWriteClassFactory))
1398         return IClassFactory_QueryInterface(&classfactory, riid, out);
1399
1400     WARN("Unsupported class %s.\n", debugstr_guid(clsid));
1401     *out = NULL;
1402     return CLASS_E_CLASSNOTAVAILABLE;
1403 }