dlls/mfreadwrite/reader.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
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "ole2.h"
  28 #include "rpcproxy.h"
  29
  30 #undef INITGUID
  31 #include <guiddef.h>
  32 #include "mfapi.h"
  33 #include "mferror.h"
  34 #include "mfidl.h"
  35 #include "mfreadwrite.h"
  36 #include "d3d9.h"
  37 #include "initguid.h"
  38 #include "dxva2api.h"
  39
  40 #include "wine/debug.h"
  41 #include "wine/heap.h"
  42 #include "wine/list.h"
  43
  44 #include "mf_private.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  47
  48 static HINSTANCE mfinstance;
  49
  50 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
  51 {
  52     switch (reason)
  53     {
  54         case DLL_PROCESS_ATTACH:
  55             mfinstance = instance;
  56             DisableThreadLibraryCalls(instance);
  57             break;
  58     }
  59
  60     return TRUE;
  61 }
  62
  63 HRESULT WINAPI DllCanUnloadNow(void)
  64 {
  65     return S_FALSE;
  66 }
  67
  68 HRESULT WINAPI DllRegisterServer(void)
  69 {
  70     return __wine_register_resources( mfinstance );
  71 }
  72
  73 HRESULT WINAPI DllUnregisterServer(void)
  74 {
  75     return __wine_unregister_resources( mfinstance );
  76 }
  77
  78 struct stream_response
  79 {
  80     struct list entry;
  81     HRESULT status;
  82     DWORD stream_index;
  83     DWORD stream_flags;
  84     LONGLONG timestamp;
  85     IMFSample *sample;
  86     unsigned int sa_pending : 1;
  87 };
  88
  89 enum media_stream_state
  90 {
  91     STREAM_STATE_READY = 0,
  92     STREAM_STATE_EOS,
  93 };
  94
  95 enum media_source_state
  96 {
  97     SOURCE_STATE_STOPPED = 0,
  98     SOURCE_STATE_STARTED,
  99 };
 100
 101 enum media_stream_flags
 102 {
 103     STREAM_FLAG_SAMPLE_REQUESTED = 0x1, /* Protects from making multiple sample requests. */
 104     STREAM_FLAG_SELECTED = 0x2,         /* Mirrors descriptor, used to simplify tests when starting the source. */
 105     STREAM_FLAG_PRESENTED = 0x4,        /* Set if stream was selected last time Start() was called. */
 106 };
 107
 108 struct stream_transform
 109 {
 110     IMFTransform *transform;
 111     unsigned int min_buffer_size;
 112 };
 113
 114 struct media_stream
 115 {
 116     IMFMediaStream *stream;
 117     IMFMediaType *current;
 118     struct stream_transform decoder;
 119     IMFVideoSampleAllocatorEx *allocator;
 120     IMFVideoSampleAllocatorNotify notify_cb;
 121     unsigned int id;
 122     unsigned int index;
 123     enum media_stream_state state;
 124     unsigned int flags;
 125     unsigned int requests;
 126     unsigned int responses;
 127     struct source_reader *reader;
 128 };
 129
 130 enum source_reader_async_op
 131 {
 132     SOURCE_READER_ASYNC_READ,
 133     SOURCE_READER_ASYNC_SEEK,
 134     SOURCE_READER_ASYNC_FLUSH,
 135     SOURCE_READER_ASYNC_SAMPLE_READY,
 136     SOURCE_READER_ASYNC_SA_READY,
 137 };
 138
 139 struct source_reader_async_command
 140 {
 141     IUnknown IUnknown_iface;
 142     LONG refcount;
 143     enum source_reader_async_op op;
 144     union
 145     {
 146         struct
 147         {
 148             unsigned int flags;
 149             unsigned int stream_index;
 150         } read;
 151         struct
 152         {
 153             GUID format;
 154             PROPVARIANT position;
 155         } seek;
 156         struct
 157         {
 158             unsigned int stream_index;
 159         } flush;
 160         struct
 161         {
 162             unsigned int stream_index;
 163         } sample;
 164         struct
 165         {
 166             unsigned int stream_index;
 167         } sa;
 168     } u;
 169 };
 170
 171 enum source_reader_flags
 172 {
 173     SOURCE_READER_FLUSHING = 0x1,
 174     SOURCE_READER_SEEKING = 0x2,
 175     SOURCE_READER_SHUTDOWN_ON_RELEASE = 0x4,
 176     SOURCE_READER_D3D9_DEVICE_MANAGER = 0x8,
 177     SOURCE_READER_DXGI_DEVICE_MANAGER = 0x10,
 178     SOURCE_READER_HAS_DEVICE_MANAGER = SOURCE_READER_D3D9_DEVICE_MANAGER | SOURCE_READER_DXGI_DEVICE_MANAGER,
 179 };
 180
 181 struct source_reader
 182 {
 183     IMFSourceReader IMFSourceReader_iface;
 184     IMFAsyncCallback source_events_callback;
 185     IMFAsyncCallback stream_events_callback;
 186     IMFAsyncCallback async_commands_callback;
 187     LONG refcount;
 188     IMFMediaSource *source;
 189     IMFPresentationDescriptor *descriptor;
 190     IMFSourceReaderCallback *async_callback;
 191     IMFAttributes *attributes;
 192     IUnknown *device_manager;
 193     unsigned int first_audio_stream_index;
 194     unsigned int first_video_stream_index;
 195     unsigned int last_read_index;
 196     unsigned int stream_count;
 197     unsigned int flags;
 198     unsigned int queue;
 199     enum media_source_state source_state;
 200     struct media_stream *streams;
 201     struct list responses;
 202     CRITICAL_SECTION cs;
 203     CONDITION_VARIABLE sample_event;
 204     CONDITION_VARIABLE state_event;
 205 };
 206
 207 static inline struct source_reader *impl_from_IMFSourceReader(IMFSourceReader *iface)
 208 {
 209     return CONTAINING_RECORD(iface, struct source_reader, IMFSourceReader_iface);
 210 }
 211
 212 static struct source_reader *impl_from_source_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 213 {
 214     return CONTAINING_RECORD(iface, struct source_reader, source_events_callback);
 215 }
 216
 217 static struct source_reader *impl_from_stream_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 218 {
 219     return CONTAINING_RECORD(iface, struct source_reader, stream_events_callback);
 220 }
 221
 222 static struct source_reader *impl_from_async_commands_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 223 {
 224     return CONTAINING_RECORD(iface, struct source_reader, async_commands_callback);
 225 }
 226
 227 static struct source_reader_async_command *impl_from_async_command_IUnknown(IUnknown *iface)
 228 {
 229     return CONTAINING_RECORD(iface, struct source_reader_async_command, IUnknown_iface);
 230 }
 231
 232 static struct media_stream *impl_stream_from_IMFVideoSampleAllocatorNotify(IMFVideoSampleAllocatorNotify *iface)
 233 {
 234     return CONTAINING_RECORD(iface, struct media_stream, notify_cb);
 235 }
 236
 237 static HRESULT WINAPI source_reader_async_command_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 238 {
 239     if (IsEqualIID(riid, &IID_IUnknown))
 240     {
 241         *obj = iface;
 242         IUnknown_AddRef(iface);
 243         return S_OK;
 244     }
 245
 246     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 247     *obj = NULL;
 248     return E_NOINTERFACE;
 249 }
 250
 251 static ULONG WINAPI source_reader_async_command_AddRef(IUnknown *iface)
 252 {
 253     struct source_reader_async_command *command = impl_from_async_command_IUnknown(iface);
 254     return InterlockedIncrement(&command->refcount);
 255 }
 256
 257 static ULONG WINAPI source_reader_async_command_Release(IUnknown *iface)
 258 {
 259     struct source_reader_async_command *command = impl_from_async_command_IUnknown(iface);
 260     ULONG refcount = InterlockedIncrement(&command->refcount);
 261
 262     if (!refcount)
 263     {
 264         if (command->op == SOURCE_READER_ASYNC_SEEK)
 265             PropVariantClear(&command->u.seek.position);
 266         heap_free(command);
 267     }
 268
 269     return refcount;
 270 }
 271
 272 static const IUnknownVtbl source_reader_async_command_vtbl =
 273 {
 274     source_reader_async_command_QueryInterface,
 275     source_reader_async_command_AddRef,
 276     source_reader_async_command_Release,
 277 };
 278
 279 static HRESULT source_reader_create_async_op(enum source_reader_async_op op, struct source_reader_async_command **ret)
 280 {
 281     struct source_reader_async_command *command;
 282
 283     if (!(command = heap_alloc_zero(sizeof(*command))))
 284         return E_OUTOFMEMORY;
 285
 286     command->IUnknown_iface.lpVtbl = &source_reader_async_command_vtbl;
 287     command->op = op;
 288
 289     *ret = command;
 290
 291     return S_OK;
 292 }
 293
 294 static HRESULT media_event_get_object(IMFMediaEvent *event, REFIID riid, void **obj)
 295 {
 296     PROPVARIANT value;
 297     HRESULT hr;
 298
 299     PropVariantInit(&value);
 300     if (FAILED(hr = IMFMediaEvent_GetValue(event, &value)))
 301     {
 302         WARN("Failed to get event value, hr %#x.\n", hr);
 303         return hr;
 304     }
 305
 306     if (value.vt != VT_UNKNOWN || !value.punkVal)
 307     {
 308         WARN("Unexpected value type %d.\n", value.vt);
 309         PropVariantClear(&value);
 310         return E_UNEXPECTED;
 311     }
 312
 313     hr = IUnknown_QueryInterface(value.punkVal, riid, obj);
 314     PropVariantClear(&value);
 315     if (FAILED(hr))
 316     {
 317         WARN("Unexpected object type.\n");
 318         return hr;
 319     }
 320
 321     return hr;
 322 }
 323
 324 static HRESULT media_stream_get_id(IMFMediaStream *stream, DWORD *id)
 325 {
 326     IMFStreamDescriptor *sd;
 327     HRESULT hr;
 328
 329     if (SUCCEEDED(hr = IMFMediaStream_GetStreamDescriptor(stream, &sd)))
 330     {
 331         hr = IMFStreamDescriptor_GetStreamIdentifier(sd, id);
 332         IMFStreamDescriptor_Release(sd);
 333     }
 334
 335     return hr;
 336 }
 337
 338 static HRESULT WINAPI source_reader_callback_QueryInterface(IMFAsyncCallback *iface,
 339         REFIID riid, void **obj)
 340 {
 341     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 342
 343     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 344             IsEqualIID(riid, &IID_IUnknown))
 345     {
 346         *obj = iface;
 347         IMFAsyncCallback_AddRef(iface);
 348         return S_OK;
 349     }
 350
 351     WARN("Unsupported %s.\n", debugstr_guid(riid));
 352     *obj = NULL;
 353     return E_NOINTERFACE;
 354 }
 355
 356 static ULONG WINAPI source_reader_source_events_callback_AddRef(IMFAsyncCallback *iface)
 357 {
 358     struct source_reader *reader = impl_from_source_callback_IMFAsyncCallback(iface);
 359     return IMFSourceReader_AddRef(&reader->IMFSourceReader_iface);
 360 }
 361
 362 static ULONG WINAPI source_reader_source_events_callback_Release(IMFAsyncCallback *iface)
 363 {
 364     struct source_reader *reader = impl_from_source_callback_IMFAsyncCallback(iface);
 365     return IMFSourceReader_Release(&reader->IMFSourceReader_iface);
 366 }
 367
 368 static HRESULT WINAPI source_reader_callback_GetParameters(IMFAsyncCallback *iface,
 369         DWORD *flags, DWORD *queue)
 370 {
 371     return E_NOTIMPL;
 372 }
 373
 374 static void source_reader_response_ready(struct source_reader *reader, struct stream_response *response)
 375 {
 376     struct source_reader_async_command *command;
 377     struct media_stream *stream = &reader->streams[response->stream_index];
 378     HRESULT hr;
 379
 380     if (!stream->requests || response->sa_pending)
 381         return;
 382
 383     if (reader->async_callback)
 384     {
 385         if (SUCCEEDED(source_reader_create_async_op(SOURCE_READER_ASYNC_SAMPLE_READY, &command)))
 386         {
 387             command->u.sample.stream_index = stream->index;
 388             if (FAILED(hr = MFPutWorkItem(reader->queue, &reader->async_commands_callback, &command->IUnknown_iface)))
 389                 WARN("Failed to submit async result, hr %#x.\n", hr);
 390             IUnknown_Release(&command->IUnknown_iface);
 391         }
 392     }
 393     else
 394         WakeAllConditionVariable(&reader->sample_event);
 395
 396     stream->requests--;
 397 }
 398
 399 static void source_reader_copy_sample_buffer(IMFSample *src, IMFSample *dst)
 400 {
 401     IMFMediaBuffer *buffer;
 402     unsigned int flags;
 403     LONGLONG time;
 404     HRESULT hr;
 405
 406     IMFSample_CopyAllItems(src, (IMFAttributes *)dst);
 407
 408     IMFSample_SetSampleDuration(dst, 0);
 409     IMFSample_SetSampleTime(dst, 0);
 410     IMFSample_SetSampleFlags(dst, 0);
 411
 412     if (SUCCEEDED(IMFSample_GetSampleDuration(src, &time)))
 413         IMFSample_SetSampleDuration(dst, time);
 414
 415     if (SUCCEEDED(IMFSample_GetSampleTime(src, &time)))
 416         IMFSample_SetSampleTime(dst, time);
 417
 418     if (SUCCEEDED(IMFSample_GetSampleFlags(src, &flags)))
 419         IMFSample_SetSampleFlags(dst, flags);
 420
 421     if (SUCCEEDED(IMFSample_ConvertToContiguousBuffer(src, NULL)))
 422     {
 423         if (SUCCEEDED(IMFSample_GetBufferByIndex(dst, 0, &buffer)))
 424         {
 425             if (FAILED(hr = IMFSample_CopyToBuffer(src, buffer)))
 426                 WARN("Failed to copy a buffer, hr %#x.\n", hr);
 427             IMFMediaBuffer_Release(buffer);
 428         }
 429     }
 430 }
 431
 432 static void source_reader_set_sa_response(struct source_reader *reader, struct stream_response *response)
 433 {
 434     struct media_stream *stream = &reader->streams[response->stream_index];
 435     IMFSample *sample;
 436
 437     if (SUCCEEDED(IMFVideoSampleAllocatorEx_AllocateSample(stream->allocator, &sample)))
 438     {
 439         source_reader_copy_sample_buffer(response->sample, sample);
 440         response->sa_pending = 0;
 441         IMFSample_Release(response->sample);
 442         response->sample = sample;
 443     }
 444 }
 445
 446 static void source_reader_queue_response(struct source_reader *reader, struct media_stream *stream, HRESULT status,
 447         DWORD stream_flags, LONGLONG timestamp, IMFSample *sample)
 448 {
 449     struct stream_response *response;
 450
 451     response = heap_alloc_zero(sizeof(*response));
 452     response->status = status;
 453     response->stream_index = stream->index;
 454     response->stream_flags = stream_flags;
 455     response->timestamp = timestamp;
 456     response->sample = sample;
 457     if (response->sample)
 458         IMFSample_AddRef(response->sample);
 459
 460     if (response->sample && stream->allocator)
 461     {
 462         response->sa_pending = 1;
 463         source_reader_set_sa_response(reader, response);
 464     }
 465
 466     list_add_tail(&reader->responses, &response->entry);
 467     stream->responses++;
 468
 469     source_reader_response_ready(reader, response);
 470 }
 471
 472 static HRESULT source_reader_request_sample(struct source_reader *reader, struct media_stream *stream)
 473 {
 474     HRESULT hr = S_OK;
 475
 476     if (stream->stream && !(stream->flags & STREAM_FLAG_SAMPLE_REQUESTED))
 477     {
 478         if (FAILED(hr = IMFMediaStream_RequestSample(stream->stream, NULL)))
 479             WARN("Sample request failed, hr %#x.\n", hr);
 480         else
 481         {
 482             stream->flags |= STREAM_FLAG_SAMPLE_REQUESTED;
 483         }
 484     }
 485
 486     return hr;
 487 }
 488
 489 static HRESULT source_reader_new_stream_handler(struct source_reader *reader, IMFMediaEvent *event)
 490 {
 491     IMFMediaStream *stream;
 492     unsigned int i;
 493     DWORD id = 0;
 494     HRESULT hr;
 495
 496     if (FAILED(hr = media_event_get_object(event, &IID_IMFMediaStream, (void **)&stream)))
 497     {
 498         WARN("Failed to get stream object, hr %#x.\n", hr);
 499         return hr;
 500     }
 501
 502     TRACE("Got new stream %p.\n", stream);
 503
 504     if (FAILED(hr = media_stream_get_id(stream, &id)))
 505     {
 506         WARN("Unidentified stream %p, hr %#x.\n", stream, hr);
 507         IMFMediaStream_Release(stream);
 508         return hr;
 509     }
 510
 511     EnterCriticalSection(&reader->cs);
 512
 513     for (i = 0; i < reader->stream_count; ++i)
 514     {
 515         if (id == reader->streams[i].id)
 516         {
 517             if (!reader->streams[i].stream)
 518             {
 519                 reader->streams[i].stream = stream;
 520                 IMFMediaStream_AddRef(reader->streams[i].stream);
 521                 if (FAILED(hr = IMFMediaStream_BeginGetEvent(stream, &reader->stream_events_callback,
 522                         (IUnknown *)stream)))
 523                 {
 524                     WARN("Failed to subscribe to stream events, hr %#x.\n", hr);
 525                 }
 526
 527                 if (reader->streams[i].requests)
 528                     if (FAILED(source_reader_request_sample(reader, &reader->streams[i])))
 529                         WakeAllConditionVariable(&reader->sample_event);
 530             }
 531             break;
 532         }
 533     }
 534
 535     if (i == reader->stream_count)
 536         WARN("Stream with id %#x was not present in presentation descriptor.\n", id);
 537
 538     LeaveCriticalSection(&reader->cs);
 539
 540     IMFMediaStream_Release(stream);
 541
 542     return hr;
 543 }
 544
 545 static HRESULT source_reader_source_state_handler(struct source_reader *reader, MediaEventType event_type)
 546 {
 547     EnterCriticalSection(&reader->cs);
 548
 549     switch (event_type)
 550     {
 551         case MESourceStarted:
 552             reader->source_state = SOURCE_STATE_STARTED;
 553             reader->flags &= ~SOURCE_READER_SEEKING;
 554             break;
 555         case MESourceStopped:
 556             reader->source_state = SOURCE_STATE_STOPPED;
 557             reader->flags &= ~SOURCE_READER_SEEKING;
 558             break;
 559         case MESourceSeeked:
 560             reader->flags &= ~SOURCE_READER_SEEKING;
 561             break;
 562         default:
 563             WARN("Unhandled event %d.\n", event_type);
 564     }
 565
 566     LeaveCriticalSection(&reader->cs);
 567
 568     WakeAllConditionVariable(&reader->state_event);
 569
 570     return S_OK;
 571 }
 572
 573 static HRESULT WINAPI source_reader_source_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 574 {
 575     struct source_reader *reader = impl_from_source_callback_IMFAsyncCallback(iface);
 576     MediaEventType event_type;
 577     IMFMediaSource *source;
 578     IMFMediaEvent *event;
 579     HRESULT hr;
 580
 581     TRACE("%p, %p.\n", iface, result);
 582
 583     source = (IMFMediaSource *)IMFAsyncResult_GetStateNoAddRef(result);
 584
 585     if (FAILED(hr = IMFMediaSource_EndGetEvent(source, result, &event)))
 586         return hr;
 587
 588     IMFMediaEvent_GetType(event, &event_type);
 589
 590     TRACE("Got event %u.\n", event_type);
 591
 592     switch (event_type)
 593     {
 594         case MENewStream:
 595             hr = source_reader_new_stream_handler(reader, event);
 596             break;
 597         case MESourceStarted:
 598         case MESourcePaused:
 599         case MESourceStopped:
 600         case MESourceSeeked:
 601             hr = source_reader_source_state_handler(reader, event_type);
 602             break;
 603         case MEBufferingStarted:
 604         case MEBufferingStopped:
 605         case MEConnectStart:
 606         case MEConnectEnd:
 607         case MEExtendedType:
 608         case MESourceCharacteristicsChanged:
 609         case MESourceMetadataChanged:
 610         case MEContentProtectionMetadata:
 611         case MEDeviceThermalStateChanged:
 612             if (reader->async_callback)
 613                 IMFSourceReaderCallback_OnEvent(reader->async_callback, MF_SOURCE_READER_MEDIASOURCE, event);
 614             break;
 615         default:
 616             ;
 617     }
 618
 619     if (FAILED(hr))
 620         WARN("Failed while handling %d event, hr %#x.\n", event_type, hr);
 621
 622     IMFMediaEvent_Release(event);
 623
 624     IMFMediaSource_BeginGetEvent(source, iface, (IUnknown *)source);
 625
 626     return S_OK;
 627 }
 628
 629 static const IMFAsyncCallbackVtbl source_events_callback_vtbl =
 630 {
 631     source_reader_callback_QueryInterface,
 632     source_reader_source_events_callback_AddRef,
 633     source_reader_source_events_callback_Release,
 634     source_reader_callback_GetParameters,
 635     source_reader_source_events_callback_Invoke,
 636 };
 637
 638 static ULONG WINAPI source_reader_stream_events_callback_AddRef(IMFAsyncCallback *iface)
 639 {
 640     struct source_reader *reader = impl_from_stream_callback_IMFAsyncCallback(iface);
 641     return IMFSourceReader_AddRef(&reader->IMFSourceReader_iface);
 642 }
 643
 644 static ULONG WINAPI source_reader_stream_events_callback_Release(IMFAsyncCallback *iface)
 645 {
 646     struct source_reader *reader = impl_from_stream_callback_IMFAsyncCallback(iface);
 647     return IMFSourceReader_Release(&reader->IMFSourceReader_iface);
 648 }
 649
 650 static HRESULT source_reader_pull_stream_samples(struct source_reader *reader, struct media_stream *stream)
 651 {
 652     MFT_OUTPUT_STREAM_INFO stream_info = { 0 };
 653     MFT_OUTPUT_DATA_BUFFER out_buffer;
 654     unsigned int buffer_size;
 655     IMFMediaBuffer *buffer;
 656     LONGLONG timestamp;
 657     DWORD status;
 658     HRESULT hr;
 659
 660     if (FAILED(hr = IMFTransform_GetOutputStreamInfo(stream->decoder.transform, 0, &stream_info)))
 661     {
 662         WARN("Failed to get output stream info, hr %#x.\n", hr);
 663         return hr;
 664     }
 665
 666     for (;;)
 667     {
 668         memset(&out_buffer, 0, sizeof(out_buffer));
 669
 670         if (!(stream_info.dwFlags & MFT_OUTPUT_STREAM_PROVIDES_SAMPLES))
 671         {
 672             if (FAILED(hr = MFCreateSample(&out_buffer.pSample)))
 673                 break;
 674
 675             buffer_size = max(stream_info.cbSize, stream->decoder.min_buffer_size);
 676
 677             if (FAILED(hr = MFCreateAlignedMemoryBuffer(buffer_size, stream_info.cbAlignment, &buffer)))
 678             {
 679                 IMFSample_Release(out_buffer.pSample);
 680                 break;
 681             }
 682
 683             IMFSample_AddBuffer(out_buffer.pSample, buffer);
 684             IMFMediaBuffer_Release(buffer);
 685         }
 686
 687         if (FAILED(hr = IMFTransform_ProcessOutput(stream->decoder.transform, 0, 1, &out_buffer, &status)))
 688         {
 689             if (out_buffer.pSample)
 690                 IMFSample_Release(out_buffer.pSample);
 691             break;
 692         }
 693
 694         timestamp = 0;
 695         if (FAILED(IMFSample_GetSampleTime(out_buffer.pSample, &timestamp)))
 696             WARN("Sample time wasn't set.\n");
 697
 698         source_reader_queue_response(reader, stream, S_OK /* FIXME */, 0, timestamp, out_buffer.pSample);
 699         if (out_buffer.pSample)
 700             IMFSample_Release(out_buffer.pSample);
 701         if (out_buffer.pEvents)
 702             IMFCollection_Release(out_buffer.pEvents);
 703     }
 704
 705     return hr;
 706 }
 707
 708 static HRESULT source_reader_process_sample(struct source_reader *reader, struct media_stream *stream,
 709         IMFSample *sample)
 710 {
 711     LONGLONG timestamp;
 712     HRESULT hr;
 713
 714     if (!stream->decoder.transform)
 715     {
 716         timestamp = 0;
 717         if (FAILED(IMFSample_GetSampleTime(sample, &timestamp)))
 718             WARN("Sample time wasn't set.\n");
 719
 720         source_reader_queue_response(reader, stream, S_OK, 0, timestamp, sample);
 721         return S_OK;
 722     }
 723
 724     /* It's assumed that decoder has 1 input and 1 output, both id's are 0. */
 725
 726     hr = source_reader_pull_stream_samples(reader, stream);
 727     if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
 728     {
 729         if (FAILED(hr = IMFTransform_ProcessInput(stream->decoder.transform, 0, sample, 0)))
 730         {
 731             WARN("Transform failed to process input, hr %#x.\n", hr);
 732             return hr;
 733         }
 734
 735         if ((hr = source_reader_pull_stream_samples(reader, stream)) == MF_E_TRANSFORM_NEED_MORE_INPUT)
 736             return S_OK;
 737     }
 738     else
 739         WARN("Transform failed to process output, hr %#x.\n", hr);
 740
 741     return hr;
 742 }
 743
 744 static HRESULT source_reader_media_sample_handler(struct source_reader *reader, IMFMediaStream *stream,
 745         IMFMediaEvent *event)
 746 {
 747     IMFSample *sample;
 748     unsigned int i;
 749     DWORD id = 0;
 750     HRESULT hr;
 751
 752     TRACE("Got new sample for stream %p.\n", stream);
 753
 754     if (FAILED(hr = media_event_get_object(event, &IID_IMFSample, (void **)&sample)))
 755     {
 756         WARN("Failed to get sample object, hr %#x.\n", hr);
 757         return hr;
 758     }
 759
 760     if (FAILED(hr = media_stream_get_id(stream, &id)))
 761     {
 762         WARN("Unidentified stream %p, hr %#x.\n", stream, hr);
 763         IMFSample_Release(sample);
 764         return hr;
 765     }
 766
 767     EnterCriticalSection(&reader->cs);
 768
 769     for (i = 0; i < reader->stream_count; ++i)
 770     {
 771         if (id == reader->streams[i].id)
 772         {
 773             /* FIXME: propagate processing errors? */
 774
 775             reader->streams[i].flags &= ~STREAM_FLAG_SAMPLE_REQUESTED;
 776             hr = source_reader_process_sample(reader, &reader->streams[i], sample);
 777             if (reader->streams[i].requests)
 778                 source_reader_request_sample(reader, &reader->streams[i]);
 779
 780             break;
 781         }
 782     }
 783
 784     if (i == reader->stream_count)
 785         WARN("Stream with id %#x was not present in presentation descriptor.\n", id);
 786
 787     LeaveCriticalSection(&reader->cs);
 788
 789     IMFSample_Release(sample);
 790
 791     return hr;
 792 }
 793
 794 static HRESULT source_reader_media_stream_state_handler(struct source_reader *reader, IMFMediaStream *stream,
 795         IMFMediaEvent *event)
 796 {
 797     MediaEventType event_type;
 798     LONGLONG timestamp;
 799     PROPVARIANT value;
 800     unsigned int i;
 801     HRESULT hr;
 802     DWORD id;
 803
 804     IMFMediaEvent_GetType(event, &event_type);
 805
 806     if (FAILED(hr = media_stream_get_id(stream, &id)))
 807     {
 808         WARN("Unidentified stream %p, hr %#x.\n", stream, hr);
 809         return hr;
 810     }
 811
 812     EnterCriticalSection(&reader->cs);
 813
 814     for (i = 0; i < reader->stream_count; ++i)
 815     {
 816         struct media_stream *stream = &reader->streams[i];
 817
 818         if (id == stream->id)
 819         {
 820             switch (event_type)
 821             {
 822                 case MEEndOfStream:
 823                     stream->state = STREAM_STATE_EOS;
 824                     stream->flags &= ~STREAM_FLAG_SAMPLE_REQUESTED;
 825
 826                     if (stream->decoder.transform && SUCCEEDED(IMFTransform_ProcessMessage(stream->decoder.transform,
 827                             MFT_MESSAGE_COMMAND_DRAIN, 0)))
 828                     {
 829                         if ((hr = source_reader_pull_stream_samples(reader, stream)) != MF_E_TRANSFORM_NEED_MORE_INPUT)
 830                             WARN("Failed to pull pending samples, hr %#x.\n", hr);
 831                     }
 832
 833                     while (stream->requests)
 834                         source_reader_queue_response(reader, stream, S_OK, MF_SOURCE_READERF_ENDOFSTREAM, 0, NULL);
 835
 836                     break;
 837                 case MEStreamSeeked:
 838                 case MEStreamStarted:
 839                     stream->state = STREAM_STATE_READY;
 840                     break;
 841                 case MEStreamTick:
 842                     value.vt = VT_EMPTY;
 843                     hr = SUCCEEDED(IMFMediaEvent_GetValue(event, &value)) && value.vt == VT_I8 ? S_OK : E_UNEXPECTED;
 844                     timestamp = SUCCEEDED(hr) ? value.hVal.QuadPart : 0;
 845                     PropVariantClear(&value);
 846
 847                     source_reader_queue_response(reader, stream, hr, MF_SOURCE_READERF_STREAMTICK, timestamp, NULL);
 848
 849                     break;
 850                 default:
 851                     ;
 852             }
 853
 854             break;
 855         }
 856     }
 857
 858     LeaveCriticalSection(&reader->cs);
 859
 860     return S_OK;
 861 }
 862
 863 static HRESULT WINAPI source_reader_stream_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 864 {
 865     struct source_reader *reader = impl_from_stream_callback_IMFAsyncCallback(iface);
 866     MediaEventType event_type;
 867     IMFMediaStream *stream;
 868     IMFMediaEvent *event;
 869     HRESULT hr;
 870
 871     TRACE("%p, %p.\n", iface, result);
 872
 873     stream = (IMFMediaStream *)IMFAsyncResult_GetStateNoAddRef(result);
 874
 875     if (FAILED(hr = IMFMediaStream_EndGetEvent(stream, result, &event)))
 876         return hr;
 877
 878     IMFMediaEvent_GetType(event, &event_type);
 879
 880     TRACE("Got event %u.\n", event_type);
 881
 882     switch (event_type)
 883     {
 884         case MEMediaSample:
 885             hr = source_reader_media_sample_handler(reader, stream, event);
 886             break;
 887         case MEStreamSeeked:
 888         case MEStreamStarted:
 889         case MEStreamTick:
 890         case MEEndOfStream:
 891             hr = source_reader_media_stream_state_handler(reader, stream, event);
 892             break;
 893         default:
 894             ;
 895     }
 896
 897     if (FAILED(hr))
 898         WARN("Failed while handling %d event, hr %#x.\n", event_type, hr);
 899
 900     IMFMediaEvent_Release(event);
 901
 902     IMFMediaStream_BeginGetEvent(stream, iface, (IUnknown *)stream);
 903
 904     return S_OK;
 905 }
 906
 907 static const IMFAsyncCallbackVtbl stream_events_callback_vtbl =
 908 {
 909     source_reader_callback_QueryInterface,
 910     source_reader_stream_events_callback_AddRef,
 911     source_reader_stream_events_callback_Release,
 912     source_reader_callback_GetParameters,
 913     source_reader_stream_events_callback_Invoke,
 914 };
 915
 916 static ULONG WINAPI source_reader_async_commands_callback_AddRef(IMFAsyncCallback *iface)
 917 {
 918     struct source_reader *reader = impl_from_async_commands_callback_IMFAsyncCallback(iface);
 919     return IMFSourceReader_AddRef(&reader->IMFSourceReader_iface);
 920 }
 921
 922 static ULONG WINAPI source_reader_async_commands_callback_Release(IMFAsyncCallback *iface)
 923 {
 924     struct source_reader *reader = impl_from_async_commands_callback_IMFAsyncCallback(iface);
 925     return IMFSourceReader_Release(&reader->IMFSourceReader_iface);
 926 }
 927
 928 static struct stream_response * media_stream_detach_response(struct source_reader *reader, struct stream_response *response)
 929 {
 930     struct media_stream *stream;
 931
 932     list_remove(&response->entry);
 933
 934     if (response->stream_index < reader->stream_count)
 935     {
 936         stream = &reader->streams[response->stream_index];
 937         if (stream->responses)
 938             --stream->responses;
 939     }
 940
 941     return response;
 942 }
 943
 944 static struct stream_response *media_stream_pop_response(struct source_reader *reader, struct media_stream *stream)
 945 {
 946     struct stream_response *response;
 947
 948     LIST_FOR_EACH_ENTRY(response, &reader->responses, struct stream_response, entry)
 949     {
 950         if ((stream && response->stream_index != stream->index) || response->sa_pending)
 951             continue;
 952
 953         return media_stream_detach_response(reader, response);
 954     }
 955
 956     return NULL;
 957 }
 958
 959 static struct stream_response *media_stream_pick_pending_response(struct source_reader *reader, unsigned int stream)
 960 {
 961     struct stream_response *response;
 962
 963     LIST_FOR_EACH_ENTRY(response, &reader->responses, struct stream_response, entry)
 964     {
 965         if (response->stream_index == stream && response->sa_pending)
 966             return response;
 967     }
 968
 969     return NULL;
 970 }
 971
 972 static void source_reader_release_response(struct stream_response *response)
 973 {
 974     if (response->sample)
 975         IMFSample_Release(response->sample);
 976     heap_free(response);
 977 }
 978
 979 static HRESULT source_reader_get_stream_selection(const struct source_reader *reader, DWORD index, BOOL *selected)
 980 {
 981     IMFStreamDescriptor *sd;
 982
 983     if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(reader->descriptor, index, selected, &sd)))
 984         return MF_E_INVALIDSTREAMNUMBER;
 985     IMFStreamDescriptor_Release(sd);
 986
 987     return S_OK;
 988 }
 989
 990 static HRESULT source_reader_start_source(struct source_reader *reader)
 991 {
 992     BOOL selected, selection_changed = FALSE;
 993     PROPVARIANT position;
 994     HRESULT hr = S_OK;
 995     unsigned int i;
 996
 997     for (i = 0; i < reader->stream_count; ++i)
 998     {
 999         source_reader_get_stream_selection(reader, i, &selected);
1000         if (selected)
1001             reader->streams[i].flags |= STREAM_FLAG_SELECTED;
1002         else
1003             reader->streams[i].flags &= ~STREAM_FLAG_SELECTED;
1004     }
1005
1006     if (reader->source_state == SOURCE_STATE_STARTED)
1007     {
1008         for (i = 0; i < reader->stream_count; ++i)
1009         {
1010             selection_changed = !!(reader->streams[i].flags & STREAM_FLAG_SELECTED) ^
1011                     !!(reader->streams[i].flags & STREAM_FLAG_PRESENTED);
1012             if (selection_changed)
1013                 break;
1014         }
1015     }
1016
1017     position.hVal.QuadPart = 0;
1018     if (reader->source_state != SOURCE_STATE_STARTED || selection_changed)
1019     {
1020         position.vt = reader->source_state == SOURCE_STATE_STARTED ? VT_EMPTY : VT_I8;
1021
1022         /* Update cached stream selection if descriptor was accepted. */
1023         if (SUCCEEDED(hr = IMFMediaSource_Start(reader->source, reader->descriptor, &GUID_NULL, &position)))
1024         {
1025             for (i = 0; i < reader->stream_count; ++i)
1026             {
1027                 if (reader->streams[i].flags & STREAM_FLAG_SELECTED)
1028                     reader->streams[i].flags |= STREAM_FLAG_PRESENTED;
1029             }
1030         }
1031     }
1032
1033     return hr;
1034 }
1035
1036 static BOOL source_reader_got_response_for_stream(struct source_reader *reader, struct media_stream *stream)
1037 {
1038     struct stream_response *response;
1039
1040     LIST_FOR_EACH_ENTRY(response, &reader->responses, struct stream_response, entry)
1041     {
1042         if (response->stream_index == stream->index && !response->sa_pending)
1043             return TRUE;
1044     }
1045
1046     return FALSE;
1047 }
1048
1049 static BOOL source_reader_get_read_result(struct source_reader *reader, struct media_stream *stream, DWORD flags,
1050         HRESULT *status, DWORD *stream_index, DWORD *stream_flags, LONGLONG *timestamp, IMFSample **sample)
1051 {
1052     struct stream_response *response = NULL;
1053     BOOL request_sample = FALSE;
1054
1055     if ((response = media_stream_pop_response(reader, stream)))
1056     {
1057         *status = response->status;
1058         *stream_index = stream->index;
1059         *stream_flags = response->stream_flags;
1060         *timestamp = response->timestamp;
1061         *sample = response->sample;
1062         if (*sample)
1063             IMFSample_AddRef(*sample);
1064
1065         source_reader_release_response(response);
1066     }
1067     else
1068     {
1069         *status = S_OK;
1070         *stream_index = stream->index;
1071         *timestamp = 0;
1072         *sample = NULL;
1073
1074         if (stream->state == STREAM_STATE_EOS)
1075         {
1076             *stream_flags = MF_SOURCE_READERF_ENDOFSTREAM;
1077         }
1078         else
1079         {
1080             request_sample = !(flags & MF_SOURCE_READER_CONTROLF_DRAIN);
1081             *stream_flags = 0;
1082         }
1083     }
1084
1085     return !request_sample;
1086 }
1087
1088 static HRESULT source_reader_get_next_selected_stream(struct source_reader *reader, unsigned int *stream_index)
1089 {
1090     unsigned int i, first_selected = ~0u, requests = ~0u;
1091     BOOL selected, stream_drained;
1092
1093     for (i = (reader->last_read_index + 1) % reader->stream_count; ; i = (i + 1) % reader->stream_count)
1094     {
1095         stream_drained = reader->streams[i].state == STREAM_STATE_EOS && !reader->streams[i].responses;
1096         selected = SUCCEEDED(source_reader_get_stream_selection(reader, i, &selected)) && selected;
1097
1098         if (selected)
1099         {
1100             if (first_selected == ~0u)
1101                 first_selected = i;
1102
1103             /* Try to balance pending reads. */
1104             if (!stream_drained && reader->streams[i].requests < requests)
1105             {
1106                 requests = reader->streams[i].requests;
1107                 *stream_index = i;
1108             }
1109         }
1110
1111         if (i == reader->last_read_index)
1112             break;
1113     }
1114
1115     /* If all selected streams reached EOS, use first selected. */
1116     if (first_selected != ~0u)
1117     {
1118         if (requests == ~0u)
1119             *stream_index = first_selected;
1120         reader->last_read_index = *stream_index;
1121     }
1122
1123     return first_selected == ~0u ? MF_E_MEDIA_SOURCE_NO_STREAMS_SELECTED : S_OK;
1124 }
1125
1126 static HRESULT source_reader_get_stream_read_index(struct source_reader *reader, unsigned int index, unsigned int *stream_index)
1127 {
1128     BOOL selected;
1129     HRESULT hr;
1130
1131     switch (index)
1132     {
1133         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
1134             *stream_index = reader->first_video_stream_index;
1135             break;
1136         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
1137             *stream_index = reader->first_audio_stream_index;
1138             break;
1139         case MF_SOURCE_READER_ANY_STREAM:
1140             return source_reader_get_next_selected_stream(reader, stream_index);
1141         default:
1142             *stream_index = index;
1143     }
1144
1145     /* Can't read from deselected streams. */
1146     if (SUCCEEDED(hr = source_reader_get_stream_selection(reader, *stream_index, &selected)) && !selected)
1147         hr = MF_E_INVALIDREQUEST;
1148
1149     return hr;
1150 }
1151
1152 static void source_reader_release_responses(struct source_reader *reader, struct media_stream *stream)
1153 {
1154     struct stream_response *ptr, *next;
1155
1156     LIST_FOR_EACH_ENTRY_SAFE(ptr, next, &reader->responses, struct stream_response, entry)
1157     {
1158         if (stream && stream->index != ptr->stream_index &&
1159                 ptr->stream_index != MF_SOURCE_READER_FIRST_VIDEO_STREAM &&
1160                 ptr->stream_index != MF_SOURCE_READER_FIRST_AUDIO_STREAM &&
1161                 ptr->stream_index != MF_SOURCE_READER_ANY_STREAM)
1162         {
1163             continue;
1164         }
1165         media_stream_detach_response(reader, ptr);
1166         source_reader_release_response(ptr);
1167     }
1168 }
1169
1170 static void source_reader_flush_stream(struct source_reader *reader, DWORD stream_index)
1171 {
1172     struct media_stream *stream = &reader->streams[stream_index];
1173
1174     source_reader_release_responses(reader, stream);
1175     if (stream->decoder.transform)
1176         IMFTransform_ProcessMessage(stream->decoder.transform, MFT_MESSAGE_COMMAND_FLUSH, 0);
1177     stream->requests = 0;
1178 }
1179
1180 static HRESULT source_reader_flush(struct source_reader *reader, unsigned int index)
1181 {
1182     unsigned int stream_index;
1183     HRESULT hr = S_OK;
1184
1185     if (index == MF_SOURCE_READER_ALL_STREAMS)
1186     {
1187         for (stream_index = 0; stream_index < reader->stream_count; ++stream_index)
1188             source_reader_flush_stream(reader, stream_index);
1189     }
1190     else
1191     {
1192         switch (index)
1193         {
1194             case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
1195                 stream_index = reader->first_video_stream_index;
1196                 break;
1197             case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
1198                 stream_index = reader->first_audio_stream_index;
1199                 break;
1200             default:
1201                 stream_index = index;
1202         }
1203
1204         if (stream_index < reader->stream_count)
1205             source_reader_flush_stream(reader, stream_index);
1206         else
1207             hr = MF_E_INVALIDSTREAMNUMBER;
1208     }
1209
1210     return hr;
1211 }
1212
1213 static HRESULT WINAPI source_reader_async_commands_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1214 {
1215     struct source_reader *reader = impl_from_async_commands_callback_IMFAsyncCallback(iface);
1216     struct media_stream *stream, stub_stream = { .requests = 1 };
1217     struct source_reader_async_command *command;
1218     struct stream_response *response;
1219     DWORD stream_index, stream_flags;
1220     BOOL report_sample = FALSE;
1221     IMFSample *sample = NULL;
1222     LONGLONG timestamp = 0;
1223     HRESULT hr, status;
1224     IUnknown *state;
1225
1226     if (FAILED(hr = IMFAsyncResult_GetState(result, &state)))
1227         return hr;
1228
1229     command = impl_from_async_command_IUnknown(state);
1230
1231     switch (command->op)
1232     {
1233         case SOURCE_READER_ASYNC_READ:
1234             EnterCriticalSection(&reader->cs);
1235
1236             if (SUCCEEDED(hr = source_reader_start_source(reader)))
1237             {
1238                 if (SUCCEEDED(hr = source_reader_get_stream_read_index(reader, command->u.read.stream_index, &stream_index)))
1239                 {
1240                     stream = &reader->streams[stream_index];
1241
1242                     if (!(report_sample = source_reader_get_read_result(reader, stream, command->u.read.flags, &status,
1243                             &stream_index, &stream_flags, &timestamp, &sample)))
1244                     {
1245                         stream->requests++;
1246                         source_reader_request_sample(reader, stream);
1247                         /* FIXME: set error stream/reader state on request failure */
1248                     }
1249                 }
1250                 else
1251                 {
1252                     stub_stream.index = command->u.read.stream_index;
1253                     source_reader_queue_response(reader, &stub_stream, hr, MF_SOURCE_READERF_ERROR, 0, NULL);
1254                 }
1255             }
1256
1257             LeaveCriticalSection(&reader->cs);
1258
1259             if (report_sample)
1260                 IMFSourceReaderCallback_OnReadSample(reader->async_callback, status, stream_index, stream_flags,
1261                         timestamp, sample);
1262
1263             if (sample)
1264                 IMFSample_Release(sample);
1265
1266             break;
1267
1268         case SOURCE_READER_ASYNC_SEEK:
1269
1270             EnterCriticalSection(&reader->cs);
1271             if (SUCCEEDED(IMFMediaSource_Start(reader->source, reader->descriptor, &command->u.seek.format,
1272                     &command->u.seek.position)))
1273             {
1274                 reader->flags |= SOURCE_READER_SEEKING;
1275             }
1276             LeaveCriticalSection(&reader->cs);
1277
1278             break;
1279
1280         case SOURCE_READER_ASYNC_SA_READY:
1281
1282             EnterCriticalSection(&reader->cs);
1283             if ((response = media_stream_pick_pending_response(reader, command->u.sa.stream_index)))
1284             {
1285                 source_reader_set_sa_response(reader, response);
1286                 source_reader_response_ready(reader, response);
1287             }
1288             LeaveCriticalSection(&reader->cs);
1289
1290             break;
1291
1292         case SOURCE_READER_ASYNC_SAMPLE_READY:
1293
1294             EnterCriticalSection(&reader->cs);
1295             response = media_stream_pop_response(reader, NULL);
1296             LeaveCriticalSection(&reader->cs);
1297
1298             if (response)
1299             {
1300                 IMFSourceReaderCallback_OnReadSample(reader->async_callback, response->status, response->stream_index,
1301                         response->stream_flags, response->timestamp, response->sample);
1302                 source_reader_release_response(response);
1303             }
1304
1305             break;
1306         case SOURCE_READER_ASYNC_FLUSH:
1307             EnterCriticalSection(&reader->cs);
1308             source_reader_flush(reader, command->u.flush.stream_index);
1309             reader->flags &= ~SOURCE_READER_FLUSHING;
1310             LeaveCriticalSection(&reader->cs);
1311
1312             IMFSourceReaderCallback_OnFlush(reader->async_callback, command->u.flush.stream_index);
1313             break;
1314         default:
1315             ;
1316     }
1317
1318     IUnknown_Release(state);
1319
1320     return S_OK;
1321 }
1322
1323 static const IMFAsyncCallbackVtbl async_commands_callback_vtbl =
1324 {
1325     source_reader_callback_QueryInterface,
1326     source_reader_async_commands_callback_AddRef,
1327     source_reader_async_commands_callback_Release,
1328     source_reader_callback_GetParameters,
1329     source_reader_async_commands_callback_Invoke,
1330 };
1331
1332 static HRESULT WINAPI src_reader_QueryInterface(IMFSourceReader *iface, REFIID riid, void **out)
1333 {
1334     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1335
1336     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
1337
1338     if(IsEqualGUID(riid, &IID_IUnknown) ||
1339        IsEqualGUID(riid, &IID_IMFSourceReader))
1340     {
1341         *out = &reader->IMFSourceReader_iface;
1342     }
1343     else
1344     {
1345         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
1346         *out = NULL;
1347         return E_NOINTERFACE;
1348     }
1349
1350     IUnknown_AddRef((IUnknown*)*out);
1351     return S_OK;
1352 }
1353
1354 static ULONG WINAPI src_reader_AddRef(IMFSourceReader *iface)
1355 {
1356     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1357     ULONG refcount = InterlockedIncrement(&reader->refcount);
1358
1359     TRACE("%p, refcount %u.\n", iface, refcount);
1360
1361     return refcount;
1362 }
1363
1364 static ULONG WINAPI src_reader_Release(IMFSourceReader *iface)
1365 {
1366     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1367     ULONG refcount = InterlockedDecrement(&reader->refcount);
1368     unsigned int i;
1369
1370     TRACE("%p, refcount %u.\n", iface, refcount);
1371
1372     if (!refcount)
1373     {
1374         if (reader->async_callback)
1375             IMFSourceReaderCallback_Release(reader->async_callback);
1376         if (reader->flags & SOURCE_READER_SHUTDOWN_ON_RELEASE)
1377             IMFMediaSource_Shutdown(reader->source);
1378         if (reader->descriptor)
1379             IMFPresentationDescriptor_Release(reader->descriptor);
1380         if (reader->attributes)
1381             IMFAttributes_Release(reader->attributes);
1382         IMFMediaSource_Release(reader->source);
1383
1384         for (i = 0; i < reader->stream_count; ++i)
1385         {
1386             struct media_stream *stream = &reader->streams[i];
1387
1388             if (stream->stream)
1389                 IMFMediaStream_Release(stream->stream);
1390             if (stream->current)
1391                 IMFMediaType_Release(stream->current);
1392             if (stream->decoder.transform)
1393                 IMFTransform_Release(stream->decoder.transform);
1394             if (stream->allocator)
1395                 IMFVideoSampleAllocatorEx_Release(stream->allocator);
1396         }
1397         source_reader_release_responses(reader, NULL);
1398         heap_free(reader->streams);
1399         MFUnlockWorkQueue(reader->queue);
1400         DeleteCriticalSection(&reader->cs);
1401         heap_free(reader);
1402     }
1403
1404     return refcount;
1405 }
1406
1407 static HRESULT WINAPI src_reader_GetStreamSelection(IMFSourceReader *iface, DWORD index, BOOL *selected)
1408 {
1409     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1410
1411     TRACE("%p, %#x, %p.\n", iface, index, selected);
1412
1413     switch (index)
1414     {
1415         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
1416             index = reader->first_video_stream_index;
1417             break;
1418         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
1419             index = reader->first_audio_stream_index;
1420             break;
1421         default:
1422             ;
1423     }
1424
1425     return source_reader_get_stream_selection(reader, index, selected);
1426 }
1427
1428 static HRESULT WINAPI src_reader_SetStreamSelection(IMFSourceReader *iface, DWORD index, BOOL selection)
1429 {
1430     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1431     HRESULT hr = S_OK;
1432     BOOL selection_changed = FALSE, selected;
1433     unsigned int i;
1434
1435     TRACE("%p, %#x, %d.\n", iface, index, selection);
1436
1437     selection = !!selection;
1438
1439     EnterCriticalSection(&reader->cs);
1440
1441     if (index == MF_SOURCE_READER_ALL_STREAMS)
1442     {
1443         for (i = 0; i < reader->stream_count; ++i)
1444         {
1445             if (!selection_changed)
1446             {
1447                 source_reader_get_stream_selection(reader, i, &selected);
1448                 selection_changed = !!(selected ^ selection);
1449             }
1450
1451             if (selection)
1452                 IMFPresentationDescriptor_SelectStream(reader->descriptor, i);
1453             else
1454                 IMFPresentationDescriptor_DeselectStream(reader->descriptor, i);
1455         }
1456     }
1457     else
1458     {
1459         switch (index)
1460         {
1461             case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
1462                 index = reader->first_video_stream_index;
1463                 break;
1464             case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
1465                 index = reader->first_audio_stream_index;
1466                 break;
1467             default:
1468                 ;
1469         }
1470
1471         source_reader_get_stream_selection(reader, index, &selected);
1472         selection_changed = !!(selected ^ selection);
1473
1474         if (selection)
1475             hr = IMFPresentationDescriptor_SelectStream(reader->descriptor, index);
1476         else
1477             hr = IMFPresentationDescriptor_DeselectStream(reader->descriptor, index);
1478     }
1479
1480     if (selection_changed)
1481         reader->last_read_index = reader->stream_count - 1;
1482
1483     LeaveCriticalSection(&reader->cs);
1484
1485     return SUCCEEDED(hr) ? S_OK : MF_E_INVALIDSTREAMNUMBER;
1486 }
1487
1488 static HRESULT source_reader_get_native_media_type(struct source_reader *reader, DWORD index, DWORD type_index,
1489         IMFMediaType **type)
1490 {
1491     IMFMediaTypeHandler *handler;
1492     IMFStreamDescriptor *sd;
1493     IMFMediaType *src_type;
1494     BOOL selected;
1495     HRESULT hr;
1496
1497     switch (index)
1498     {
1499         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
1500             index = reader->first_video_stream_index;
1501             break;
1502         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
1503             index = reader->first_audio_stream_index;
1504             break;
1505         default:
1506             ;
1507     }
1508
1509     if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(reader->descriptor, index, &selected, &sd)))
1510         return MF_E_INVALIDSTREAMNUMBER;
1511
1512     hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler);
1513     IMFStreamDescriptor_Release(sd);
1514     if (FAILED(hr))
1515         return hr;
1516
1517     if (type_index == MF_SOURCE_READER_CURRENT_TYPE_INDEX)
1518         hr = IMFMediaTypeHandler_GetCurrentMediaType(handler, &src_type);
1519     else
1520         hr = IMFMediaTypeHandler_GetMediaTypeByIndex(handler, type_index, &src_type);
1521     IMFMediaTypeHandler_Release(handler);
1522
1523     if (SUCCEEDED(hr))
1524     {
1525         if (SUCCEEDED(hr = MFCreateMediaType(type)))
1526             hr = IMFMediaType_CopyAllItems(src_type, (IMFAttributes *)*type);
1527         IMFMediaType_Release(src_type);
1528     }
1529
1530     return hr;
1531 }
1532
1533 static HRESULT WINAPI src_reader_GetNativeMediaType(IMFSourceReader *iface, DWORD index, DWORD type_index,
1534             IMFMediaType **type)
1535 {
1536     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1537
1538     TRACE("%p, %#x, %#x, %p.\n", iface, index, type_index, type);
1539
1540     return source_reader_get_native_media_type(reader, index, type_index, type);
1541 }
1542
1543 static HRESULT WINAPI src_reader_GetCurrentMediaType(IMFSourceReader *iface, DWORD index, IMFMediaType **type)
1544 {
1545     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1546     HRESULT hr;
1547
1548     TRACE("%p, %#x, %p.\n", iface, index, type);
1549
1550     switch (index)
1551     {
1552         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
1553             index = reader->first_video_stream_index;
1554             break;
1555         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
1556             index = reader->first_audio_stream_index;
1557             break;
1558         default:
1559             ;
1560     }
1561
1562     if (index >= reader->stream_count)
1563         return MF_E_INVALIDSTREAMNUMBER;
1564
1565     if (FAILED(hr = MFCreateMediaType(type)))
1566         return hr;
1567
1568     EnterCriticalSection(&reader->cs);
1569
1570     hr = IMFMediaType_CopyAllItems(reader->streams[index].current, (IMFAttributes *)*type);
1571
1572     LeaveCriticalSection(&reader->cs);
1573
1574     return hr;
1575 }
1576
1577 static HRESULT source_reader_get_source_type_handler(struct source_reader *reader, DWORD index,
1578         IMFMediaTypeHandler **handler)
1579 {
1580     IMFStreamDescriptor *sd;
1581     BOOL selected;
1582     HRESULT hr;
1583
1584     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(reader->descriptor, index, &selected, &sd)))
1585         return hr;
1586
1587     hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, handler);
1588     IMFStreamDescriptor_Release(sd);
1589
1590     return hr;
1591 }
1592
1593 static HRESULT source_reader_set_compatible_media_type(struct source_reader *reader, DWORD index, IMFMediaType *type)
1594 {
1595     IMFMediaTypeHandler *type_handler;
1596     IMFMediaType *native_type;
1597     BOOL type_set = FALSE;
1598     unsigned int i = 0;
1599     DWORD flags;
1600     HRESULT hr;
1601
1602     if (FAILED(hr = IMFMediaType_IsEqual(type, reader->streams[index].current, &flags)))
1603         return hr;
1604
1605     if (!(flags & MF_MEDIATYPE_EQUAL_MAJOR_TYPES))
1606         return MF_E_INVALIDMEDIATYPE;
1607
1608     /* No need for a decoder or type change. */
1609     if (flags & MF_MEDIATYPE_EQUAL_FORMAT_TYPES)
1610         return S_OK;
1611
1612     if (FAILED(hr = source_reader_get_source_type_handler(reader, index, &type_handler)))
1613         return hr;
1614
1615     while (!type_set && IMFMediaTypeHandler_GetMediaTypeByIndex(type_handler, i++, &native_type) == S_OK)
1616     {
1617         static const DWORD compare_flags = MF_MEDIATYPE_EQUAL_MAJOR_TYPES | MF_MEDIATYPE_EQUAL_FORMAT_TYPES;
1618
1619         if (SUCCEEDED(IMFMediaType_IsEqual(native_type, type, &flags)) && (flags & compare_flags) == compare_flags)
1620         {
1621             if ((type_set = SUCCEEDED(IMFMediaTypeHandler_SetCurrentMediaType(type_handler, native_type))))
1622                 IMFMediaType_CopyAllItems(native_type, (IMFAttributes *)reader->streams[index].current);
1623         }
1624
1625         IMFMediaType_Release(native_type);
1626     }
1627
1628     IMFMediaTypeHandler_Release(type_handler);
1629
1630     return type_set ? S_OK : S_FALSE;
1631 }
1632
1633 static HRESULT source_reader_setup_sample_allocator(struct source_reader *reader, unsigned int index)
1634 {
1635     struct media_stream *stream = &reader->streams[index];
1636     IMFVideoSampleAllocatorCallback *callback;
1637     GUID major = { 0 };
1638     HRESULT hr;
1639
1640     IMFMediaType_GetMajorType(stream->current, &major);
1641     if (!IsEqualGUID(&major, &MFMediaType_Video))
1642         return S_OK;
1643
1644     if (!(reader->flags & SOURCE_READER_HAS_DEVICE_MANAGER))
1645         return S_OK;
1646
1647     if (!stream->allocator)
1648     {
1649         if (FAILED(hr = MFCreateVideoSampleAllocatorEx(&IID_IMFVideoSampleAllocatorEx, (void **)&stream->allocator)))
1650         {
1651             WARN("Failed to create sample allocator, hr %#x.\n", hr);
1652             return hr;
1653         }
1654     }
1655
1656     IMFVideoSampleAllocatorEx_UninitializeSampleAllocator(stream->allocator);
1657     if (FAILED(hr = IMFVideoSampleAllocatorEx_SetDirectXManager(stream->allocator, reader->device_manager)))
1658     {
1659         WARN("Failed to set device manager, hr %#x.\n", hr);
1660         return hr;
1661     }
1662
1663     if (FAILED(hr = IMFVideoSampleAllocatorEx_InitializeSampleAllocatorEx(stream->allocator, 2, 8, NULL, stream->current)))
1664         WARN("Failed to initialize sample allocator, hr %#x.\n", hr);
1665
1666     if (SUCCEEDED(IMFVideoSampleAllocatorEx_QueryInterface(stream->allocator, &IID_IMFVideoSampleAllocatorCallback, (void **)&callback)))
1667     {
1668         if (FAILED(hr = IMFVideoSampleAllocatorCallback_SetCallback(callback, &stream->notify_cb)))
1669             WARN("Failed to set allocator callback, hr %#x.\n", hr);
1670         IMFVideoSampleAllocatorCallback_Release(callback);
1671     }
1672
1673     return hr;
1674 }
1675
1676 static HRESULT source_reader_configure_decoder(struct source_reader *reader, DWORD index, const CLSID *clsid,
1677         IMFMediaType *input_type, IMFMediaType *output_type)
1678 {
1679     IMFMediaTypeHandler *type_handler;
1680     unsigned int block_alignment = 0;
1681     IMFTransform *transform = NULL;
1682     IMFMediaType *type = NULL;
1683     GUID major = { 0 };
1684     DWORD flags;
1685     HRESULT hr;
1686     int i = 0;
1687
1688     if (FAILED(hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform, (void **)&transform)))
1689     {
1690         WARN("Failed to create transform object, hr %#x.\n", hr);
1691         return hr;
1692     }
1693
1694     if (FAILED(hr = IMFTransform_SetInputType(transform, 0, input_type, 0)))
1695     {
1696         WARN("Failed to set decoder input type, hr %#x.\n", hr);
1697         IMFTransform_Release(transform);
1698         return hr;
1699     }
1700
1701     /* Find the relevant output type. */
1702     while (IMFTransform_GetOutputAvailableType(transform, 0, i++, &type) == S_OK)
1703     {
1704         flags = 0;
1705
1706         if (SUCCEEDED(IMFMediaType_IsEqual(type, output_type, &flags)))
1707         {
1708             if (flags & MF_MEDIATYPE_EQUAL_FORMAT_TYPES)
1709             {
1710                 if (SUCCEEDED(IMFTransform_SetOutputType(transform, 0, type, 0)))
1711                 {
1712                     if (SUCCEEDED(source_reader_get_source_type_handler(reader, index, &type_handler)))
1713                     {
1714                         IMFMediaTypeHandler_SetCurrentMediaType(type_handler, input_type);
1715                         IMFMediaTypeHandler_Release(type_handler);
1716                     }
1717
1718                     if (FAILED(hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)reader->streams[index].current)))
1719                         WARN("Failed to copy attributes, hr %#x.\n", hr);
1720                     if (SUCCEEDED(IMFMediaType_GetMajorType(type, &major)) && IsEqualGUID(&major, &MFMediaType_Audio))
1721                         IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment);
1722                     IMFMediaType_Release(type);
1723
1724                     if (reader->streams[index].decoder.transform)
1725                         IMFTransform_Release(reader->streams[index].decoder.transform);
1726
1727                     reader->streams[index].decoder.transform = transform;
1728                     reader->streams[index].decoder.min_buffer_size = block_alignment;
1729
1730                     return S_OK;
1731                 }
1732             }
1733         }
1734
1735         IMFMediaType_Release(type);
1736     }
1737
1738     WARN("Failed to find suitable decoder output type.\n");
1739
1740     IMFTransform_Release(transform);
1741
1742     return MF_E_TOPO_CODEC_NOT_FOUND;
1743 }
1744
1745 static HRESULT source_reader_create_decoder_for_stream(struct source_reader *reader, DWORD index, IMFMediaType *output_type)
1746 {
1747     MFT_REGISTER_TYPE_INFO in_type, out_type;
1748     CLSID *clsids, mft_clsid, category;
1749     unsigned int i = 0, count;
1750     IMFMediaType *input_type;
1751     HRESULT hr;
1752
1753     /* TODO: should we check if the source type is compressed? */
1754
1755     if (FAILED(hr = IMFMediaType_GetMajorType(output_type, &out_type.guidMajorType)))
1756         return hr;
1757
1758     if (IsEqualGUID(&out_type.guidMajorType, &MFMediaType_Video))
1759     {
1760         category = MFT_CATEGORY_VIDEO_DECODER;
1761     }
1762     else if (IsEqualGUID(&out_type.guidMajorType, &MFMediaType_Audio))
1763     {
1764         category = MFT_CATEGORY_AUDIO_DECODER;
1765     }
1766     else
1767     {
1768         WARN("Unhandled major type %s.\n", debugstr_guid(&out_type.guidMajorType));
1769         return MF_E_TOPO_CODEC_NOT_FOUND;
1770     }
1771
1772     if (FAILED(hr = IMFMediaType_GetGUID(output_type, &MF_MT_SUBTYPE, &out_type.guidSubtype)))
1773         return hr;
1774
1775     in_type.guidMajorType = out_type.guidMajorType;
1776
1777     while (source_reader_get_native_media_type(reader, index, i++, &input_type) == S_OK)
1778     {
1779         if (SUCCEEDED(IMFMediaType_GetGUID(input_type, &MF_MT_SUBTYPE, &in_type.guidSubtype)))
1780         {
1781             count = 0;
1782             if (SUCCEEDED(hr = MFTEnum(category, 0, &in_type, &out_type, NULL, &clsids, &count)) && count)
1783             {
1784                 mft_clsid = clsids[0];
1785                 CoTaskMemFree(clsids);
1786
1787                 /* TODO: Should we iterate over all of them? */
1788                 if (SUCCEEDED(source_reader_configure_decoder(reader, index, &mft_clsid, input_type, output_type)))
1789                 {
1790                     IMFMediaType_Release(input_type);
1791                     return S_OK;
1792                 }
1793
1794             }
1795         }
1796
1797         IMFMediaType_Release(input_type);
1798     }
1799
1800     return MF_E_TOPO_CODEC_NOT_FOUND;
1801 }
1802
1803 static HRESULT WINAPI src_reader_SetCurrentMediaType(IMFSourceReader *iface, DWORD index, DWORD *reserved,
1804         IMFMediaType *type)
1805 {
1806     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1807     HRESULT hr;
1808
1809     TRACE("%p, %#x, %p, %p.\n", iface, index, reserved, type);
1810
1811     switch (index)
1812     {
1813         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
1814             index = reader->first_video_stream_index;
1815             break;
1816         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
1817             index = reader->first_audio_stream_index;
1818             break;
1819         default:
1820             ;
1821     }
1822
1823     if (index >= reader->stream_count)
1824         return MF_E_INVALIDSTREAMNUMBER;
1825
1826     /* FIXME: setting the output type while streaming should trigger a flush */
1827
1828     EnterCriticalSection(&reader->cs);
1829
1830     hr = source_reader_set_compatible_media_type(reader, index, type);
1831     if (hr == S_FALSE)
1832         hr = source_reader_create_decoder_for_stream(reader, index, type);
1833     if (SUCCEEDED(hr))
1834         hr = source_reader_setup_sample_allocator(reader, index);
1835
1836     LeaveCriticalSection(&reader->cs);
1837
1838     return hr;
1839 }
1840
1841 static HRESULT WINAPI src_reader_SetCurrentPosition(IMFSourceReader *iface, REFGUID format, REFPROPVARIANT position)
1842 {
1843     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1844     struct source_reader_async_command *command;
1845     unsigned int i, flags;
1846     HRESULT hr;
1847
1848     TRACE("%p, %s, %p.\n", iface, debugstr_guid(format), position);
1849
1850     if (FAILED(hr = IMFMediaSource_GetCharacteristics(reader->source, &flags)))
1851         return hr;
1852
1853     if (!(flags & MFMEDIASOURCE_CAN_SEEK))
1854         return MF_E_INVALIDREQUEST;
1855
1856     EnterCriticalSection(&reader->cs);
1857
1858     /* Check if we got pending requests. */
1859     for (i = 0; i < reader->stream_count; ++i)
1860     {
1861         if (reader->streams[i].requests)
1862         {
1863             hr = MF_E_INVALIDREQUEST;
1864             break;
1865         }
1866     }
1867
1868     if (SUCCEEDED(hr))
1869     {
1870         if (reader->async_callback)
1871         {
1872             if (SUCCEEDED(hr = source_reader_create_async_op(SOURCE_READER_ASYNC_SEEK, &command)))
1873             {
1874                 command->u.seek.format = *format;
1875                 PropVariantCopy(&command->u.seek.position, position);
1876
1877                 hr = MFPutWorkItem(reader->queue, &reader->async_commands_callback, &command->IUnknown_iface);
1878                 IUnknown_Release(&command->IUnknown_iface);
1879             }
1880         }
1881         else
1882         {
1883             if (SUCCEEDED(IMFMediaSource_Start(reader->source, reader->descriptor, format, position)))
1884             {
1885                 reader->flags |= SOURCE_READER_SEEKING;
1886                 while (reader->flags & SOURCE_READER_SEEKING)
1887                 {
1888                     SleepConditionVariableCS(&reader->state_event, &reader->cs, INFINITE);
1889                 }
1890             }
1891         }
1892     }
1893
1894     LeaveCriticalSection(&reader->cs);
1895
1896     return hr;
1897 }
1898
1899 static HRESULT source_reader_read_sample(struct source_reader *reader, DWORD index, DWORD flags, DWORD *actual_index,
1900         DWORD *stream_flags, LONGLONG *timestamp, IMFSample **sample)
1901 {
1902     unsigned int actual_index_tmp;
1903     struct media_stream *stream;
1904     LONGLONG timestamp_tmp;
1905     DWORD stream_index;
1906     HRESULT hr = S_OK;
1907
1908     if (!stream_flags || !sample)
1909         return E_POINTER;
1910
1911     *sample = NULL;
1912
1913     if (!timestamp)
1914         timestamp = &timestamp_tmp;
1915
1916     if (!actual_index)
1917         actual_index = &actual_index_tmp;
1918
1919     if (SUCCEEDED(hr = source_reader_start_source(reader)))
1920     {
1921         if (SUCCEEDED(hr = source_reader_get_stream_read_index(reader, index, &stream_index)))
1922         {
1923             *actual_index = stream_index;
1924
1925             stream = &reader->streams[stream_index];
1926
1927             if (!source_reader_get_read_result(reader, stream, flags, &hr, actual_index, stream_flags,
1928                    timestamp, sample))
1929             {
1930                 while (!source_reader_got_response_for_stream(reader, stream) && stream->state != STREAM_STATE_EOS)
1931                 {
1932                     stream->requests++;
1933                     if (FAILED(hr = source_reader_request_sample(reader, stream)))
1934                         WARN("Failed to request a sample, hr %#x.\n", hr);
1935                     if (stream->stream && !(stream->flags & STREAM_FLAG_SAMPLE_REQUESTED))
1936                     {
1937                         *stream_flags = MF_SOURCE_READERF_ERROR;
1938                         *timestamp = 0;
1939                         break;
1940                     }
1941                     SleepConditionVariableCS(&reader->sample_event, &reader->cs, INFINITE);
1942                 }
1943                 if (SUCCEEDED(hr))
1944                     source_reader_get_read_result(reader, stream, flags, &hr, actual_index, stream_flags,
1945                        timestamp, sample);
1946             }
1947         }
1948         else
1949         {
1950             *actual_index = index;
1951             *stream_flags = MF_SOURCE_READERF_ERROR;
1952             *timestamp = 0;
1953         }
1954     }
1955
1956     TRACE("Stream %u, got sample %p, flags %#x.\n", *actual_index, *sample, *stream_flags);
1957
1958     return hr;
1959 }
1960
1961 static HRESULT source_reader_read_sample_async(struct source_reader *reader, unsigned int index, unsigned int flags,
1962         unsigned int *actual_index, unsigned int *stream_flags, LONGLONG *timestamp, IMFSample **sample)
1963 {
1964     struct source_reader_async_command *command;
1965     HRESULT hr;
1966
1967     if (actual_index || stream_flags || timestamp || sample)
1968         return E_INVALIDARG;
1969
1970     if (reader->flags & SOURCE_READER_FLUSHING)
1971         hr = MF_E_NOTACCEPTING;
1972     else
1973     {
1974         if (SUCCEEDED(hr = source_reader_create_async_op(SOURCE_READER_ASYNC_READ, &command)))
1975         {
1976             command->u.read.stream_index = index;
1977             command->u.read.flags = flags;
1978
1979             hr = MFPutWorkItem(reader->queue, &reader->async_commands_callback, &command->IUnknown_iface);
1980             IUnknown_Release(&command->IUnknown_iface);
1981         }
1982     }
1983
1984     return hr;
1985 }
1986
1987 static HRESULT WINAPI src_reader_ReadSample(IMFSourceReader *iface, DWORD index, DWORD flags, DWORD *actual_index,
1988         DWORD *stream_flags, LONGLONG *timestamp, IMFSample **sample)
1989 {
1990     struct source_reader *reader = impl_from_IMFSourceReader(iface);
1991     HRESULT hr;
1992
1993     TRACE("%p, %#x, %#x, %p, %p, %p, %p\n", iface, index, flags, actual_index, stream_flags, timestamp, sample);
1994
1995     EnterCriticalSection(&reader->cs);
1996
1997     while (reader->flags & SOURCE_READER_SEEKING)
1998     {
1999         SleepConditionVariableCS(&reader->state_event, &reader->cs, INFINITE);
2000     }
2001
2002     if (reader->async_callback)
2003         hr = source_reader_read_sample_async(reader, index, flags, actual_index, stream_flags, timestamp, sample);
2004     else
2005         hr = source_reader_read_sample(reader, index, flags, actual_index, stream_flags, timestamp, sample);
2006
2007     LeaveCriticalSection(&reader->cs);
2008
2009     return hr;
2010 }
2011
2012 static HRESULT source_reader_flush_async(struct source_reader *reader, unsigned int index)
2013 {
2014     struct source_reader_async_command *command;
2015     unsigned int stream_index;
2016     HRESULT hr;
2017
2018     if (reader->flags & SOURCE_READER_FLUSHING)
2019         return MF_E_INVALIDREQUEST;
2020
2021     switch (index)
2022     {
2023         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
2024             stream_index = reader->first_video_stream_index;
2025             break;
2026         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
2027             stream_index = reader->first_audio_stream_index;
2028             break;
2029         default:
2030             stream_index = index;
2031     }
2032
2033     reader->flags |= SOURCE_READER_FLUSHING;
2034
2035     if (stream_index != MF_SOURCE_READER_ALL_STREAMS && stream_index >= reader->stream_count)
2036         return MF_E_INVALIDSTREAMNUMBER;
2037
2038     if (FAILED(hr = source_reader_create_async_op(SOURCE_READER_ASYNC_FLUSH, &command)))
2039         return hr;
2040
2041     command->u.flush.stream_index = stream_index;
2042
2043     hr = MFPutWorkItem(reader->queue, &reader->async_commands_callback, &command->IUnknown_iface);
2044     IUnknown_Release(&command->IUnknown_iface);
2045
2046     return hr;
2047 }
2048
2049 static HRESULT WINAPI src_reader_Flush(IMFSourceReader *iface, DWORD index)
2050 {
2051     struct source_reader *reader = impl_from_IMFSourceReader(iface);
2052     HRESULT hr;
2053
2054     TRACE("%p, %#x.\n", iface, index);
2055
2056     EnterCriticalSection(&reader->cs);
2057
2058     if (reader->async_callback)
2059         hr = source_reader_flush_async(reader, index);
2060     else
2061         hr = source_reader_flush(reader, index);
2062
2063     LeaveCriticalSection(&reader->cs);
2064
2065     return hr;
2066 }
2067
2068 static HRESULT WINAPI src_reader_GetServiceForStream(IMFSourceReader *iface, DWORD index, REFGUID service,
2069         REFIID riid, void **object)
2070 {
2071     struct source_reader *reader = impl_from_IMFSourceReader(iface);
2072     IUnknown *obj = NULL;
2073     HRESULT hr = S_OK;
2074
2075     TRACE("%p, %#x, %s, %s, %p\n", iface, index, debugstr_guid(service), debugstr_guid(riid), object);
2076
2077     EnterCriticalSection(&reader->cs);
2078
2079     switch (index)
2080     {
2081         case MF_SOURCE_READER_MEDIASOURCE:
2082             obj = (IUnknown *)reader->source;
2083             break;
2084         default:
2085             if (index == MF_SOURCE_READER_FIRST_VIDEO_STREAM)
2086                 index = reader->first_video_stream_index;
2087             else if (index == MF_SOURCE_READER_FIRST_AUDIO_STREAM)
2088                 index = reader->first_audio_stream_index;
2089
2090             if (index >= reader->stream_count)
2091                 hr = MF_E_INVALIDSTREAMNUMBER;
2092             else
2093             {
2094                 obj = (IUnknown *)reader->streams[index].decoder.transform;
2095                 if (!obj) hr = E_NOINTERFACE;
2096             }
2097             break;
2098     }
2099
2100     if (obj)
2101         IUnknown_AddRef(obj);
2102
2103     LeaveCriticalSection(&reader->cs);
2104
2105     if (obj)
2106     {
2107         if (IsEqualGUID(service, &GUID_NULL))
2108         {
2109             hr = IUnknown_QueryInterface(obj, riid, object);
2110         }
2111         else
2112         {
2113             IMFGetService *gs;
2114
2115             hr = IUnknown_QueryInterface(obj, &IID_IMFGetService, (void **)&gs);
2116             if (SUCCEEDED(hr))
2117             {
2118                 hr = IMFGetService_GetService(gs, service, riid, object);
2119                 IMFGetService_Release(gs);
2120             }
2121         }
2122     }
2123
2124     if (obj)
2125         IUnknown_Release(obj);
2126
2127     return hr;
2128 }
2129
2130 static HRESULT WINAPI src_reader_GetPresentationAttribute(IMFSourceReader *iface, DWORD index,
2131         REFGUID guid, PROPVARIANT *value)
2132 {
2133     struct source_reader *reader = impl_from_IMFSourceReader(iface);
2134     IMFStreamDescriptor *sd;
2135     BOOL selected;
2136     HRESULT hr;
2137
2138     TRACE("%p, %#x, %s, %p.\n", iface, index, debugstr_guid(guid), value);
2139
2140     switch (index)
2141     {
2142         case MF_SOURCE_READER_MEDIASOURCE:
2143             if (IsEqualGUID(guid, &MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS))
2144             {
2145                 DWORD flags;
2146
2147                 if (FAILED(hr = IMFMediaSource_GetCharacteristics(reader->source, &flags)))
2148                     return hr;
2149
2150                 value->vt = VT_UI4;
2151                 value->ulVal = flags;
2152                 return S_OK;
2153             }
2154             else
2155             {
2156                 return IMFPresentationDescriptor_GetItem(reader->descriptor, guid, value);
2157             }
2158             break;
2159         case MF_SOURCE_READER_FIRST_VIDEO_STREAM:
2160             index = reader->first_video_stream_index;
2161             break;
2162         case MF_SOURCE_READER_FIRST_AUDIO_STREAM:
2163             index = reader->first_audio_stream_index;
2164             break;
2165         default:
2166             ;
2167     }
2168
2169     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(reader->descriptor, index, &selected, &sd)))
2170         return hr;
2171
2172     hr = IMFStreamDescriptor_GetItem(sd, guid, value);
2173     IMFStreamDescriptor_Release(sd);
2174
2175     return hr;
2176 }
2177
2178 static const IMFSourceReaderVtbl srcreader_vtbl =
2179 {
2180     src_reader_QueryInterface,
2181     src_reader_AddRef,
2182     src_reader_Release,
2183     src_reader_GetStreamSelection,
2184     src_reader_SetStreamSelection,
2185     src_reader_GetNativeMediaType,
2186     src_reader_GetCurrentMediaType,
2187     src_reader_SetCurrentMediaType,
2188     src_reader_SetCurrentPosition,
2189     src_reader_ReadSample,
2190     src_reader_Flush,
2191     src_reader_GetServiceForStream,
2192     src_reader_GetPresentationAttribute
2193 };
2194
2195 static DWORD reader_get_first_stream_index(IMFPresentationDescriptor *descriptor, const GUID *major)
2196 {
2197     unsigned int count, i;
2198     BOOL selected;
2199     HRESULT hr;
2200     GUID guid;
2201
2202     if (FAILED(IMFPresentationDescriptor_GetStreamDescriptorCount(descriptor, &count)))
2203         return MF_SOURCE_READER_INVALID_STREAM_INDEX;
2204
2205     for (i = 0; i < count; ++i)
2206     {
2207         IMFMediaTypeHandler *handler;
2208         IMFStreamDescriptor *sd;
2209
2210         if (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(descriptor, i, &selected, &sd)))
2211         {
2212             hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler);
2213             IMFStreamDescriptor_Release(sd);
2214             if (SUCCEEDED(hr))
2215             {
2216                 hr = IMFMediaTypeHandler_GetMajorType(handler, &guid);
2217                 IMFMediaTypeHandler_Release(handler);
2218                 if (FAILED(hr))
2219                 {
2220                     WARN("Failed to get stream major type, hr %#x.\n", hr);
2221                     continue;
2222                 }
2223
2224                 if (IsEqualGUID(&guid, major))
2225                 {
2226                     return i;
2227                 }
2228             }
2229         }
2230     }
2231
2232     return MF_SOURCE_READER_INVALID_STREAM_INDEX;
2233 }
2234
2235 static HRESULT WINAPI stream_sample_allocator_cb_QueryInterface(IMFVideoSampleAllocatorNotify *iface,
2236         REFIID riid, void **obj)
2237 {
2238     if (IsEqualIID(riid, &IID_IMFVideoSampleAllocatorNotify) ||
2239             IsEqualIID(riid, &IID_IUnknown))
2240     {
2241         *obj = iface;
2242         IMFVideoSampleAllocatorNotify_AddRef(iface);
2243         return S_OK;
2244     }
2245
2246     *obj = NULL;
2247     return E_NOINTERFACE;
2248 }
2249
2250 static ULONG WINAPI stream_sample_allocator_cb_AddRef(IMFVideoSampleAllocatorNotify *iface)
2251 {
2252     return 2;
2253 }
2254
2255 static ULONG WINAPI stream_sample_allocator_cb_Release(IMFVideoSampleAllocatorNotify *iface)
2256 {
2257     return 1;
2258 }
2259
2260 static HRESULT WINAPI stream_sample_allocator_cb_NotifyRelease(IMFVideoSampleAllocatorNotify *iface)
2261 {
2262     struct media_stream *stream = impl_stream_from_IMFVideoSampleAllocatorNotify(iface);
2263     struct source_reader_async_command *command;
2264
2265     if (SUCCEEDED(source_reader_create_async_op(SOURCE_READER_ASYNC_SA_READY, &command)))
2266     {
2267         command->u.sa.stream_index = stream->index;
2268         MFPutWorkItem(stream->reader->queue, &stream->reader->async_commands_callback, &command->IUnknown_iface);
2269         IUnknown_Release(&command->IUnknown_iface);
2270     }
2271
2272     return S_OK;
2273 }
2274
2275 static const IMFVideoSampleAllocatorNotifyVtbl stream_sample_allocator_cb_vtbl =
2276 {
2277     stream_sample_allocator_cb_QueryInterface,
2278     stream_sample_allocator_cb_AddRef,
2279     stream_sample_allocator_cb_Release,
2280     stream_sample_allocator_cb_NotifyRelease,
2281 };
2282
2283 static HRESULT create_source_reader_from_source(IMFMediaSource *source, IMFAttributes *attributes,
2284         BOOL shutdown_on_release, REFIID riid, void **out)
2285 {
2286     struct source_reader *object;
2287     unsigned int i;
2288     HRESULT hr;
2289
2290     object = heap_alloc_zero(sizeof(*object));
2291     if (!object)
2292         return E_OUTOFMEMORY;
2293
2294     object->IMFSourceReader_iface.lpVtbl = &srcreader_vtbl;
2295     object->source_events_callback.lpVtbl = &source_events_callback_vtbl;
2296     object->stream_events_callback.lpVtbl = &stream_events_callback_vtbl;
2297     object->async_commands_callback.lpVtbl = &async_commands_callback_vtbl;
2298     object->refcount = 1;
2299     list_init(&object->responses);
2300     if (shutdown_on_release)
2301         object->flags |= SOURCE_READER_SHUTDOWN_ON_RELEASE;
2302     object->source = source;
2303     IMFMediaSource_AddRef(object->source);
2304     InitializeCriticalSection(&object->cs);
2305     InitializeConditionVariable(&object->sample_event);
2306     InitializeConditionVariable(&object->state_event);
2307
2308     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(object->source, &object->descriptor)))
2309         goto failed;
2310
2311     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorCount(object->descriptor, &object->stream_count)))
2312         goto failed;
2313
2314     if (!(object->streams = heap_alloc_zero(object->stream_count * sizeof(*object->streams))))
2315     {
2316         hr = E_OUTOFMEMORY;
2317         goto failed;
2318     }
2319
2320     /* Set initial current media types. */
2321     for (i = 0; i < object->stream_count; ++i)
2322     {
2323         IMFMediaTypeHandler *handler;
2324         IMFStreamDescriptor *sd;
2325         IMFMediaType *src_type;
2326         BOOL selected;
2327
2328         if (FAILED(hr = MFCreateMediaType(&object->streams[i].current)))
2329             break;
2330
2331         if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(object->descriptor, i, &selected, &sd)))
2332             break;
2333
2334         if (FAILED(hr = IMFStreamDescriptor_GetStreamIdentifier(sd, &object->streams[i].id)))
2335             WARN("Failed to get stream identifier, hr %#x.\n", hr);
2336
2337         hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler);
2338         IMFStreamDescriptor_Release(sd);
2339         if (FAILED(hr))
2340             break;
2341
2342         hr = IMFMediaTypeHandler_GetMediaTypeByIndex(handler, 0, &src_type);
2343         IMFMediaTypeHandler_Release(handler);
2344         if (FAILED(hr))
2345             break;
2346
2347         hr = IMFMediaType_CopyAllItems(src_type, (IMFAttributes *)object->streams[i].current);
2348         IMFMediaType_Release(src_type);
2349         if (FAILED(hr))
2350             break;
2351
2352         object->streams[i].notify_cb.lpVtbl = &stream_sample_allocator_cb_vtbl;
2353         object->streams[i].reader = object;
2354         object->streams[i].index = i;
2355     }
2356
2357     if (FAILED(hr))
2358         goto failed;
2359
2360     /* At least one major type has to be set. */
2361     object->first_audio_stream_index = reader_get_first_stream_index(object->descriptor, &MFMediaType_Audio);
2362     object->first_video_stream_index = reader_get_first_stream_index(object->descriptor, &MFMediaType_Video);
2363     object->last_read_index = object->stream_count - 1;
2364
2365     if (object->first_audio_stream_index == MF_SOURCE_READER_INVALID_STREAM_INDEX &&
2366             object->first_video_stream_index == MF_SOURCE_READER_INVALID_STREAM_INDEX)
2367     {
2368         hr = MF_E_ATTRIBUTENOTFOUND;
2369     }
2370
2371     if (FAILED(hr = IMFMediaSource_BeginGetEvent(object->source, &object->source_events_callback,
2372             (IUnknown *)object->source)))
2373     {
2374         goto failed;
2375     }
2376
2377     if (attributes)
2378     {
2379         object->attributes = attributes;
2380         IMFAttributes_AddRef(object->attributes);
2381
2382         IMFAttributes_GetUnknown(attributes, &MF_SOURCE_READER_ASYNC_CALLBACK, &IID_IMFSourceReaderCallback,
2383                 (void **)&object->async_callback);
2384         if (object->async_callback)
2385             TRACE("Using async callback %p.\n", object->async_callback);
2386
2387         IMFAttributes_GetUnknown(attributes, &MF_SOURCE_READER_D3D_MANAGER, &IID_IUnknown, (void **)&object->device_manager);
2388         if (object->device_manager)
2389         {
2390             IUnknown *unk = NULL;
2391
2392             if (SUCCEEDED(IUnknown_QueryInterface(object->device_manager, &IID_IMFDXGIDeviceManager, (void **)&unk)))
2393                 object->flags |= SOURCE_READER_DXGI_DEVICE_MANAGER;
2394             else if (SUCCEEDED(IUnknown_QueryInterface(object->device_manager, &IID_IDirect3DDeviceManager9, (void **)&unk)))
2395                 object->flags |= SOURCE_READER_D3D9_DEVICE_MANAGER;
2396
2397             if (!(object->flags & (SOURCE_READER_HAS_DEVICE_MANAGER)))
2398             {
2399                 WARN("Unknown device manager.\n");
2400                 IUnknown_Release(object->device_manager);
2401                 object->device_manager = NULL;
2402             }
2403
2404             if (unk)
2405                 IUnknown_Release(unk);
2406         }
2407     }
2408
2409     if (FAILED(hr = MFLockSharedWorkQueue(L"", 0, NULL, &object->queue)))
2410         WARN("Failed to acquired shared queue, hr %#x.\n", hr);
2411
2412     if (SUCCEEDED(hr))
2413         hr = IMFSourceReader_QueryInterface(&object->IMFSourceReader_iface, riid, out);
2414
2415 failed:
2416     IMFSourceReader_Release(&object->IMFSourceReader_iface);
2417     return hr;
2418 }
2419
2420 static HRESULT bytestream_get_url_hint(IMFByteStream *stream, WCHAR const **url)
2421 {
2422     static const unsigned char asfmagic[]  = {0x30,0x26,0xb2,0x75,0x8e,0x66,0xcf,0x11,0xa6,0xd9,0x00,0xaa,0x00,0x62,0xce,0x6c};
2423     static const unsigned char wavmagic[]  = { 'R', 'I', 'F', 'F',0x00,0x00,0x00,0x00, 'W', 'A', 'V', 'E', 'f', 'm', 't', ' '};
2424     static const unsigned char wavmask[]   = {0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
2425     static const unsigned char isommagic[] = {0x00,0x00,0x00,0x00, 'f', 't', 'y', 'p', 'i', 's', 'o', 'm',0x00,0x00,0x00,0x00};
2426     static const unsigned char mp42magic[] = {0x00,0x00,0x00,0x00, 'f', 't', 'y', 'p', 'm', 'p', '4', '2',0x00,0x00,0x00,0x00};
2427     static const unsigned char mp4mask[]   = {0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00};
2428     static const struct stream_content_url_hint
2429     {
2430         const unsigned char *magic;
2431         const WCHAR *url;
2432         const unsigned char *mask;
2433     }
2434     url_hints[] =
2435     {
2436         { asfmagic,  L".asf" },
2437         { wavmagic,  L".wav", wavmask },
2438         { isommagic, L".mp4", mp4mask },
2439         { mp42magic, L".mp4", mp4mask },
2440     };
2441     unsigned char buffer[4 * sizeof(unsigned int)], pattern[4 * sizeof(unsigned int)];
2442     unsigned int i, j, length = 0, caps = 0;
2443     IMFAttributes *attributes;
2444     QWORD position;
2445     HRESULT hr;
2446
2447     *url = NULL;
2448
2449     if (SUCCEEDED(IMFByteStream_QueryInterface(stream, &IID_IMFAttributes, (void **)&attributes)))
2450     {
2451         IMFAttributes_GetStringLength(attributes, &MF_BYTESTREAM_CONTENT_TYPE, &length);
2452         IMFAttributes_Release(attributes);
2453     }
2454
2455     if (length)
2456         return S_OK;
2457
2458     if (FAILED(hr = IMFByteStream_GetCapabilities(stream, &caps)))
2459         return hr;
2460
2461     if (!(caps & MFBYTESTREAM_IS_SEEKABLE))
2462         return S_OK;
2463
2464     if (FAILED(hr = IMFByteStream_GetCurrentPosition(stream, &position)))
2465         return hr;
2466
2467     hr = IMFByteStream_Read(stream, buffer, sizeof(buffer), &length);
2468     IMFByteStream_SetCurrentPosition(stream, position);
2469     if (FAILED(hr))
2470         return hr;
2471
2472     if (length < sizeof(buffer))
2473         return S_OK;
2474
2475     for (i = 0; i < ARRAY_SIZE(url_hints); ++i)
2476     {
2477         memcpy(pattern, buffer, sizeof(buffer));
2478         if (url_hints[i].mask)
2479         {
2480             unsigned int *mask = (unsigned int *)url_hints[i].mask;
2481             unsigned int *data = (unsigned int *)pattern;
2482
2483             for (j = 0; j < sizeof(buffer) / sizeof(unsigned int); ++j)
2484                 data[j] &= mask[j];
2485
2486         }
2487         if (!memcmp(pattern, url_hints[i].magic, sizeof(pattern)))
2488         {
2489             *url = url_hints[i].url;
2490             break;
2491         }
2492     }
2493
2494     if (*url)
2495         TRACE("Stream type guessed as %s from %s.\n", debugstr_w(*url), debugstr_an((char *)buffer, length));
2496     else
2497         WARN("Unrecognized content type %s.\n", debugstr_an((char *)buffer, length));
2498
2499     return S_OK;
2500 }
2501
2502 static HRESULT create_source_reader_from_stream(IMFByteStream *stream, IMFAttributes *attributes,
2503         REFIID riid, void **out)
2504 {
2505     IPropertyStore *props = NULL;
2506     IMFSourceResolver *resolver;
2507     MF_OBJECT_TYPE obj_type;
2508     IMFMediaSource *source;
2509     const WCHAR *url;
2510     HRESULT hr;
2511
2512     /* If stream does not have content type set, try to guess from starting byte sequence. */
2513     if (FAILED(hr = bytestream_get_url_hint(stream, &url)))
2514         return hr;
2515
2516     if (FAILED(hr = MFCreateSourceResolver(&resolver)))
2517         return hr;
2518
2519     if (attributes)
2520         IMFAttributes_GetUnknown(attributes, &MF_SOURCE_READER_MEDIASOURCE_CONFIG, &IID_IPropertyStore,
2521                 (void **)&props);
2522
2523     hr = IMFSourceResolver_CreateObjectFromByteStream(resolver, stream, url, MF_RESOLUTION_MEDIASOURCE, props,
2524             &obj_type, (IUnknown **)&source);
2525     IMFSourceResolver_Release(resolver);
2526     if (props)
2527         IPropertyStore_Release(props);
2528     if (FAILED(hr))
2529         return hr;
2530
2531     hr = create_source_reader_from_source(source, attributes, TRUE, riid, out);
2532     IMFMediaSource_Release(source);
2533     return hr;
2534 }
2535
2536 static HRESULT create_source_reader_from_url(const WCHAR *url, IMFAttributes *attributes, REFIID riid, void **out)
2537 {
2538     IPropertyStore *props = NULL;
2539     IMFSourceResolver *resolver;
2540     IUnknown *object = NULL;
2541     MF_OBJECT_TYPE obj_type;
2542     IMFMediaSource *source;
2543     HRESULT hr;
2544
2545     if (FAILED(hr = MFCreateSourceResolver(&resolver)))
2546         return hr;
2547
2548     if (attributes)
2549         IMFAttributes_GetUnknown(attributes, &MF_SOURCE_READER_MEDIASOURCE_CONFIG, &IID_IPropertyStore,
2550                 (void **)&props);
2551
2552     hr = IMFSourceResolver_CreateObjectFromURL(resolver, url, MF_RESOLUTION_MEDIASOURCE, props, &obj_type,
2553             &object);
2554     if (SUCCEEDED(hr))
2555     {
2556         switch (obj_type)
2557         {
2558             case MF_OBJECT_BYTESTREAM:
2559                 hr = IMFSourceResolver_CreateObjectFromByteStream(resolver, (IMFByteStream *)object, NULL,
2560                         MF_RESOLUTION_MEDIASOURCE, props, &obj_type, (IUnknown **)&source);
2561                 break;
2562             case MF_OBJECT_MEDIASOURCE:
2563                 source = (IMFMediaSource *)object;
2564                 IMFMediaSource_AddRef(source);
2565                 break;
2566             default:
2567                 WARN("Unknown object type %d.\n", obj_type);
2568                 hr = E_UNEXPECTED;
2569         }
2570         IUnknown_Release(object);
2571     }
2572
2573     IMFSourceResolver_Release(resolver);
2574     if (props)
2575         IPropertyStore_Release(props);
2576     if (FAILED(hr))
2577         return hr;
2578
2579     hr = create_source_reader_from_source(source, attributes, TRUE, riid, out);
2580     IMFMediaSource_Release(source);
2581     return hr;
2582 }
2583
2584 static HRESULT create_source_reader_from_object(IUnknown *unk, IMFAttributes *attributes, REFIID riid, void **out)
2585 {
2586     IMFMediaSource *source = NULL;
2587     IMFByteStream *stream = NULL;
2588     HRESULT hr;
2589
2590     hr = IUnknown_QueryInterface(unk, &IID_IMFMediaSource, (void **)&source);
2591     if (FAILED(hr))
2592         hr = IUnknown_QueryInterface(unk, &IID_IMFByteStream, (void **)&stream);
2593
2594     if (source)
2595     {
2596         UINT32 disconnect = 0;
2597
2598         if (attributes)
2599             IMFAttributes_GetUINT32(attributes, &MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN, &disconnect);
2600         hr = create_source_reader_from_source(source, attributes, !disconnect, riid, out);
2601     }
2602     else if (stream)
2603         hr = create_source_reader_from_stream(stream, attributes, riid, out);
2604
2605     if (source)
2606         IMFMediaSource_Release(source);
2607     if (stream)
2608         IMFByteStream_Release(stream);
2609
2610     return hr;
2611 }
2612
2613 /***********************************************************************
2614  *      MFCreateSourceReaderFromByteStream (mfreadwrite.@)
2615  */
2616 HRESULT WINAPI MFCreateSourceReaderFromByteStream(IMFByteStream *stream, IMFAttributes *attributes,
2617         IMFSourceReader **reader)
2618 {
2619     TRACE("%p, %p, %p.\n", stream, attributes, reader);
2620
2621     return create_source_reader_from_object((IUnknown *)stream, attributes, &IID_IMFSourceReader, (void **)reader);
2622 }
2623
2624 /***********************************************************************
2625  *      MFCreateSourceReaderFromMediaSource (mfreadwrite.@)
2626  */
2627 HRESULT WINAPI MFCreateSourceReaderFromMediaSource(IMFMediaSource *source, IMFAttributes *attributes,
2628         IMFSourceReader **reader)
2629 {
2630     TRACE("%p, %p, %p.\n", source, attributes, reader);
2631
2632     return create_source_reader_from_object((IUnknown *)source, attributes, &IID_IMFSourceReader, (void **)reader);
2633 }
2634
2635 /***********************************************************************
2636  *      MFCreateSourceReaderFromURL (mfreadwrite.@)
2637  */
2638 HRESULT WINAPI MFCreateSourceReaderFromURL(const WCHAR *url, IMFAttributes *attributes, IMFSourceReader **reader)
2639 {
2640     TRACE("%s, %p, %p.\n", debugstr_w(url), attributes, reader);
2641
2642     return create_source_reader_from_url(url, attributes, &IID_IMFSourceReader, (void **)reader);
2643 }
2644
2645 static HRESULT WINAPI readwrite_factory_QueryInterface(IMFReadWriteClassFactory *iface, REFIID riid, void **out)
2646 {
2647     if (IsEqualIID(riid, &IID_IMFReadWriteClassFactory) ||
2648             IsEqualIID(riid, &IID_IUnknown))
2649     {
2650         *out = iface;
2651         IMFReadWriteClassFactory_AddRef(iface);
2652         return S_OK;
2653     }
2654
2655     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
2656     *out = NULL;
2657     return E_NOINTERFACE;
2658 }
2659
2660 static ULONG WINAPI readwrite_factory_AddRef(IMFReadWriteClassFactory *iface)
2661 {
2662     return 2;
2663 }
2664
2665 static ULONG WINAPI readwrite_factory_Release(IMFReadWriteClassFactory *iface)
2666 {
2667     return 1;
2668 }
2669
2670 static HRESULT WINAPI readwrite_factory_CreateInstanceFromURL(IMFReadWriteClassFactory *iface, REFCLSID clsid,
2671         const WCHAR *url, IMFAttributes *attributes, REFIID riid, void **out)
2672 {
2673     TRACE("%s, %s, %p, %s, %p.\n", debugstr_guid(clsid), debugstr_w(url), attributes, debugstr_guid(riid), out);
2674
2675     if (IsEqualGUID(clsid, &CLSID_MFSourceReader))
2676     {
2677         return create_source_reader_from_url(url, attributes, &IID_IMFSourceReader, out);
2678     }
2679
2680     FIXME("Unsupported %s.\n", debugstr_guid(clsid));
2681
2682     return E_NOTIMPL;
2683 }
2684
2685 static HRESULT WINAPI readwrite_factory_CreateInstanceFromObject(IMFReadWriteClassFactory *iface, REFCLSID clsid,
2686         IUnknown *unk, IMFAttributes *attributes, REFIID riid, void **out)
2687 {
2688     HRESULT hr;
2689
2690     TRACE("%s, %p, %p, %s, %p.\n", debugstr_guid(clsid), unk, attributes, debugstr_guid(riid), out);
2691
2692     if (IsEqualGUID(clsid, &CLSID_MFSourceReader))
2693     {
2694         return create_source_reader_from_object(unk, attributes, riid, out);
2695     }
2696     else if (IsEqualGUID(clsid, &CLSID_MFSinkWriter))
2697     {
2698         IMFByteStream *stream = NULL;
2699         IMFMediaSink *sink = NULL;
2700
2701         hr = IUnknown_QueryInterface(unk, &IID_IMFByteStream, (void **)&stream);
2702         if (FAILED(hr))
2703             hr = IUnknown_QueryInterface(unk, &IID_IMFMediaSink, (void **)&sink);
2704
2705         if (stream)
2706             hr = create_sink_writer_from_stream(stream, attributes, riid, out);
2707         else if (sink)
2708             hr = create_sink_writer_from_sink(sink, attributes, riid, out);
2709
2710         if (sink)
2711             IMFMediaSink_Release(sink);
2712         if (stream)
2713             IMFByteStream_Release(stream);
2714
2715         return hr;
2716     }
2717     else
2718     {
2719         WARN("Unsupported class %s.\n", debugstr_guid(clsid));
2720         *out = NULL;
2721         return E_FAIL;
2722     }
2723 }
2724
2725 static const IMFReadWriteClassFactoryVtbl readwrite_factory_vtbl =
2726 {
2727     readwrite_factory_QueryInterface,
2728     readwrite_factory_AddRef,
2729     readwrite_factory_Release,
2730     readwrite_factory_CreateInstanceFromURL,
2731     readwrite_factory_CreateInstanceFromObject,
2732 };
2733
2734 static IMFReadWriteClassFactory readwrite_factory = { &readwrite_factory_vtbl };
2735
2736 static HRESULT WINAPI classfactory_QueryInterface(IClassFactory *iface, REFIID riid, void **out)
2737 {
2738     TRACE("%s, %p.\n", debugstr_guid(riid), out);
2739
2740     if (IsEqualGUID(riid, &IID_IClassFactory) ||
2741             IsEqualGUID(riid, &IID_IUnknown))
2742     {
2743         IClassFactory_AddRef(iface);
2744         *out = iface;
2745         return S_OK;
2746     }
2747
2748     WARN("interface %s not implemented\n", debugstr_guid(riid));
2749     *out = NULL;
2750     return E_NOINTERFACE;
2751 }
2752
2753 static ULONG WINAPI classfactory_AddRef(IClassFactory *iface)
2754 {
2755     return 2;
2756 }
2757
2758 static ULONG WINAPI classfactory_Release(IClassFactory *iface)
2759 {
2760     return 1;
2761 }
2762
2763 static HRESULT WINAPI classfactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **out)
2764 {
2765     TRACE("%p, %s, %p.\n", outer, debugstr_guid(riid), out);
2766
2767     *out = NULL;
2768
2769     if (outer)
2770         return CLASS_E_NOAGGREGATION;
2771
2772     return IMFReadWriteClassFactory_QueryInterface(&readwrite_factory, riid, out);
2773 }
2774
2775 static HRESULT WINAPI classfactory_LockServer(IClassFactory *iface, BOOL dolock)
2776 {
2777     FIXME("%d.\n", dolock);
2778     return S_OK;
2779 }
2780
2781 static const IClassFactoryVtbl classfactoryvtbl =
2782 {
2783     classfactory_QueryInterface,
2784     classfactory_AddRef,
2785     classfactory_Release,
2786     classfactory_CreateInstance,
2787     classfactory_LockServer,
2788 };
2789
2790 static IClassFactory classfactory = { &classfactoryvtbl };
2791
2792 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **out)
2793 {
2794     TRACE("%s, %s, %p.\n", debugstr_guid(clsid), debugstr_guid(riid), out);
2795
2796     if (IsEqualGUID(clsid, &CLSID_MFReadWriteClassFactory))
2797         return IClassFactory_QueryInterface(&classfactory, riid, out);
2798
2799     WARN("Unsupported class %s.\n", debugstr_guid(clsid));
2800     *out = NULL;
2801     return CLASS_E_CLASSNOTAVAILABLE;
2802 }