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