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