dlls/mf/session.c

   1 /*
   2  * Copyright 2017 Nikolay Sivov
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <math.h>
  21 #include <float.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "mfidl.h"
  28 #include "evr.h"
  29
  30 #include "wine/debug.h"
  31 #include "wine/heap.h"
  32 #include "wine/list.h"
  33
  34 #include "mf_private.h"
  35
  36 #include "initguid.h"
  37
  38 DEFINE_GUID(_MF_TOPONODE_IMFActivate, 0x33706f4a, 0x309a, 0x49be, 0xa8, 0xdd, 0xe7, 0xc0, 0x87, 0x5e, 0xb6, 0x79);
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  41
  42 enum session_command
  43 {
  44     SESSION_CMD_CLEAR_TOPOLOGIES,
  45     SESSION_CMD_CLOSE,
  46     SESSION_CMD_SET_TOPOLOGY,
  47     SESSION_CMD_START,
  48     SESSION_CMD_PAUSE,
  49     SESSION_CMD_STOP,
  50     /* Internally used commands. */
  51     SESSION_CMD_END,
  52     SESSION_CMD_QM_NOTIFY_TOPOLOGY,
  53     SESSION_CMD_SA_READY,
  54 };
  55
  56 struct session_op
  57 {
  58     IUnknown IUnknown_iface;
  59     LONG refcount;
  60     enum session_command command;
  61     union
  62     {
  63         struct
  64         {
  65             DWORD flags;
  66             IMFTopology *topology;
  67         } set_topology;
  68         struct
  69         {
  70             GUID time_format;
  71             PROPVARIANT start_position;
  72         } start;
  73         struct
  74         {
  75             IMFTopology *topology;
  76         } notify_topology;
  77         struct
  78         {
  79             TOPOID node_id;
  80         } sa_ready;
  81     } u;
  82     struct list entry;
  83 };
  84
  85 struct queued_topology
  86 {
  87     struct list entry;
  88     IMFTopology *topology;
  89     MF_TOPOSTATUS status;
  90 };
  91
  92 enum session_state
  93 {
  94     SESSION_STATE_STOPPED = 0,
  95     SESSION_STATE_STARTING_SOURCES,
  96     SESSION_STATE_PREROLLING_SINKS,
  97     SESSION_STATE_STARTING_SINKS,
  98     SESSION_STATE_STARTED,
  99     SESSION_STATE_PAUSING_SINKS,
 100     SESSION_STATE_PAUSING_SOURCES,
 101     SESSION_STATE_PAUSED,
 102     SESSION_STATE_STOPPING_SINKS,
 103     SESSION_STATE_STOPPING_SOURCES,
 104     SESSION_STATE_FINALIZING_SINKS,
 105     SESSION_STATE_CLOSED,
 106     SESSION_STATE_SHUT_DOWN,
 107 };
 108
 109 enum object_state
 110 {
 111     OBJ_STATE_STOPPED = 0,
 112     OBJ_STATE_STARTED,
 113     OBJ_STATE_PAUSED,
 114     OBJ_STATE_PREROLLED,
 115     OBJ_STATE_INVALID,
 116 };
 117
 118 enum media_source_flags
 119 {
 120     SOURCE_FLAG_END_OF_PRESENTATION = 0x1,
 121 };
 122
 123 struct media_source
 124 {
 125     struct list entry;
 126     IMFMediaSource *source;
 127     IMFPresentationDescriptor *pd;
 128     enum object_state state;
 129     unsigned int flags;
 130 };
 131
 132 struct media_sink
 133 {
 134     struct list entry;
 135     IMFMediaSink *sink;
 136     IMFMediaSinkPreroll *preroll;
 137     IMFMediaEventGenerator *event_generator;
 138     BOOL finalized;
 139 };
 140
 141 struct sample
 142 {
 143     struct list entry;
 144     IMFSample *sample;
 145 };
 146
 147 struct transform_stream
 148 {
 149     struct list samples;
 150     unsigned int requests;
 151     unsigned int min_buffer_size;
 152 };
 153
 154 enum topo_node_flags
 155 {
 156     TOPO_NODE_END_OF_STREAM = 0x1,
 157 };
 158
 159 struct topo_node
 160 {
 161     struct list entry;
 162     struct media_session *session;
 163     MF_TOPOLOGY_TYPE type;
 164     TOPOID node_id;
 165     IMFTopologyNode *node;
 166     enum object_state state;
 167     unsigned int flags;
 168     union
 169     {
 170         IMFMediaStream *source_stream;
 171         IMFStreamSink *sink_stream;
 172         IMFTransform *transform;
 173         IUnknown *object;
 174     } object;
 175
 176     union
 177     {
 178         struct
 179         {
 180             IMFMediaSource *source;
 181             unsigned int stream_id;
 182         } source;
 183         struct
 184         {
 185             unsigned int requests;
 186             IMFVideoSampleAllocatorNotify notify_cb;
 187             IMFVideoSampleAllocator *allocator;
 188             IMFVideoSampleAllocatorCallback *allocator_cb;
 189         } sink;
 190         struct
 191         {
 192             struct transform_stream *inputs;
 193             unsigned int *input_map;
 194             unsigned int input_count;
 195
 196             struct transform_stream *outputs;
 197             unsigned int *output_map;
 198             unsigned int output_count;
 199         } transform;
 200     } u;
 201 };
 202
 203 enum presentation_flags
 204 {
 205     SESSION_FLAG_SOURCES_SUBSCRIBED = 0x1,
 206     SESSION_FLAG_PRESENTATION_CLOCK_SET = 0x2,
 207     SESSION_FLAG_FINALIZE_SINKS = 0x4,
 208     SESSION_FLAG_NEEDS_PREROLL = 0x8,
 209     SESSION_FLAG_END_OF_PRESENTATION = 0x10,
 210 };
 211
 212 struct media_session
 213 {
 214     IMFMediaSession IMFMediaSession_iface;
 215     IMFGetService IMFGetService_iface;
 216     IMFRateSupport IMFRateSupport_iface;
 217     IMFRateControl IMFRateControl_iface;
 218     IMFTopologyNodeAttributeEditor IMFTopologyNodeAttributeEditor_iface;
 219     IMFAsyncCallback commands_callback;
 220     IMFAsyncCallback events_callback;
 221     IMFAsyncCallback sink_finalizer_callback;
 222     LONG refcount;
 223     IMFMediaEventQueue *event_queue;
 224     IMFPresentationClock *clock;
 225     IMFPresentationTimeSource *system_time_source;
 226     IMFRateControl *clock_rate_control;
 227     IMFTopoLoader *topo_loader;
 228     IMFQualityManager *quality_manager;
 229     struct
 230     {
 231         IMFTopology *current_topology;
 232         MF_TOPOSTATUS topo_status;
 233         MFTIME clock_stop_time;
 234         unsigned int flags;
 235         struct list sources;
 236         struct list sinks;
 237         struct list nodes;
 238
 239         /* Latest Start() arguments. */
 240         GUID time_format;
 241         PROPVARIANT start_position;
 242     } presentation;
 243     struct list topologies;
 244     struct list commands;
 245     enum session_state state;
 246     DWORD caps;
 247     CRITICAL_SECTION cs;
 248 };
 249
 250 struct clock_sink
 251 {
 252     struct list entry;
 253     IMFClockStateSink *state_sink;
 254 };
 255
 256 enum clock_command
 257 {
 258     CLOCK_CMD_START = 0,
 259     CLOCK_CMD_STOP,
 260     CLOCK_CMD_PAUSE,
 261     CLOCK_CMD_SET_RATE,
 262     CLOCK_CMD_MAX,
 263 };
 264
 265 enum clock_notification
 266 {
 267     CLOCK_NOTIFY_START,
 268     CLOCK_NOTIFY_STOP,
 269     CLOCK_NOTIFY_PAUSE,
 270     CLOCK_NOTIFY_RESTART,
 271     CLOCK_NOTIFY_SET_RATE,
 272 };
 273
 274 struct clock_state_change_param
 275 {
 276     union
 277     {
 278         LONGLONG offset;
 279         float rate;
 280     } u;
 281 };
 282
 283 struct sink_notification
 284 {
 285     IUnknown IUnknown_iface;
 286     LONG refcount;
 287     MFTIME system_time;
 288     struct clock_state_change_param param;
 289     enum clock_notification notification;
 290     IMFClockStateSink *sink;
 291 };
 292
 293 struct clock_timer
 294 {
 295     IUnknown IUnknown_iface;
 296     LONG refcount;
 297     IMFAsyncResult *result;
 298     IMFAsyncCallback *callback;
 299     MFWORKITEM_KEY key;
 300     struct list entry;
 301 };
 302
 303 struct presentation_clock
 304 {
 305     IMFPresentationClock IMFPresentationClock_iface;
 306     IMFRateControl IMFRateControl_iface;
 307     IMFTimer IMFTimer_iface;
 308     IMFShutdown IMFShutdown_iface;
 309     IMFAsyncCallback sink_callback;
 310     IMFAsyncCallback timer_callback;
 311     LONG refcount;
 312     IMFPresentationTimeSource *time_source;
 313     IMFClockStateSink *time_source_sink;
 314     MFCLOCK_STATE state;
 315     LONGLONG start_offset;
 316     struct list sinks;
 317     struct list timers;
 318     float rate;
 319     LONGLONG frequency;
 320     CRITICAL_SECTION cs;
 321     BOOL is_shut_down;
 322 };
 323
 324 enum quality_manager_state
 325 {
 326     QUALITY_MANAGER_READY = 0,
 327     QUALITY_MANAGER_SHUT_DOWN,
 328 };
 329
 330 struct quality_manager
 331 {
 332     IMFQualityManager IMFQualityManager_iface;
 333     IMFClockStateSink IMFClockStateSink_iface;
 334     LONG refcount;
 335
 336     IMFTopology *topology;
 337     IMFPresentationClock *clock;
 338     unsigned int state;
 339     CRITICAL_SECTION cs;
 340 };
 341
 342 static inline struct media_session *impl_from_IMFMediaSession(IMFMediaSession *iface)
 343 {
 344     return CONTAINING_RECORD(iface, struct media_session, IMFMediaSession_iface);
 345 }
 346
 347 static struct media_session *impl_from_commands_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 348 {
 349     return CONTAINING_RECORD(iface, struct media_session, commands_callback);
 350 }
 351
 352 static struct media_session *impl_from_events_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 353 {
 354     return CONTAINING_RECORD(iface, struct media_session, events_callback);
 355 }
 356
 357 static struct media_session *impl_from_sink_finalizer_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 358 {
 359     return CONTAINING_RECORD(iface, struct media_session, sink_finalizer_callback);
 360 }
 361
 362 static struct media_session *impl_from_IMFGetService(IMFGetService *iface)
 363 {
 364     return CONTAINING_RECORD(iface, struct media_session, IMFGetService_iface);
 365 }
 366
 367 static struct media_session *impl_session_from_IMFRateSupport(IMFRateSupport *iface)
 368 {
 369     return CONTAINING_RECORD(iface, struct media_session, IMFRateSupport_iface);
 370 }
 371
 372 static struct media_session *impl_session_from_IMFRateControl(IMFRateControl *iface)
 373 {
 374     return CONTAINING_RECORD(iface, struct media_session, IMFRateControl_iface);
 375 }
 376
 377 static struct media_session *impl_session_from_IMFTopologyNodeAttributeEditor(IMFTopologyNodeAttributeEditor *iface)
 378 {
 379     return CONTAINING_RECORD(iface, struct media_session, IMFTopologyNodeAttributeEditor_iface);
 380 }
 381
 382 static struct session_op *impl_op_from_IUnknown(IUnknown *iface)
 383 {
 384     return CONTAINING_RECORD(iface, struct session_op, IUnknown_iface);
 385 }
 386
 387 static struct presentation_clock *impl_from_IMFPresentationClock(IMFPresentationClock *iface)
 388 {
 389     return CONTAINING_RECORD(iface, struct presentation_clock, IMFPresentationClock_iface);
 390 }
 391
 392 static struct presentation_clock *impl_from_IMFRateControl(IMFRateControl *iface)
 393 {
 394     return CONTAINING_RECORD(iface, struct presentation_clock, IMFRateControl_iface);
 395 }
 396
 397 static struct presentation_clock *impl_from_IMFTimer(IMFTimer *iface)
 398 {
 399     return CONTAINING_RECORD(iface, struct presentation_clock, IMFTimer_iface);
 400 }
 401
 402 static struct presentation_clock *impl_from_IMFShutdown(IMFShutdown *iface)
 403 {
 404     return CONTAINING_RECORD(iface, struct presentation_clock, IMFShutdown_iface);
 405 }
 406
 407 static struct presentation_clock *impl_from_sink_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 408 {
 409     return CONTAINING_RECORD(iface, struct presentation_clock, sink_callback);
 410 }
 411
 412 static struct presentation_clock *impl_from_timer_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 413 {
 414     return CONTAINING_RECORD(iface, struct presentation_clock, timer_callback);
 415 }
 416
 417 static struct clock_timer *impl_clock_timer_from_IUnknown(IUnknown *iface)
 418 {
 419     return CONTAINING_RECORD(iface, struct clock_timer, IUnknown_iface);
 420 }
 421
 422 static struct sink_notification *impl_sink_notification_from_IUnknown(IUnknown *iface)
 423 {
 424     return CONTAINING_RECORD(iface, struct sink_notification, IUnknown_iface);
 425 }
 426
 427 static struct quality_manager *impl_from_IMFQualityManager(IMFQualityManager *iface)
 428 {
 429     return CONTAINING_RECORD(iface, struct quality_manager, IMFQualityManager_iface);
 430 }
 431
 432 static struct quality_manager *impl_from_qm_IMFClockStateSink(IMFClockStateSink *iface)
 433 {
 434     return CONTAINING_RECORD(iface, struct quality_manager, IMFClockStateSink_iface);
 435 }
 436
 437 static struct topo_node *impl_node_from_IMFVideoSampleAllocatorNotify(IMFVideoSampleAllocatorNotify *iface)
 438 {
 439     return CONTAINING_RECORD(iface, struct topo_node, u.sink.notify_cb);
 440 }
 441
 442 /* IMFLocalMFTRegistration */
 443 static HRESULT WINAPI local_mft_registration_QueryInterface(IMFLocalMFTRegistration *iface, REFIID riid, void **obj)
 444 {
 445     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 446
 447     if (IsEqualIID(riid, &IID_IMFLocalMFTRegistration) ||
 448             IsEqualIID(riid, &IID_IUnknown))
 449     {
 450         *obj = iface;
 451         IMFLocalMFTRegistration_AddRef(iface);
 452         return S_OK;
 453     }
 454
 455     WARN("Unexpected %s.\n", debugstr_guid(riid));
 456     *obj = NULL;
 457     return E_NOINTERFACE;
 458 }
 459
 460 static ULONG WINAPI local_mft_registration_AddRef(IMFLocalMFTRegistration *iface)
 461 {
 462     return 2;
 463 }
 464
 465 static ULONG WINAPI local_mft_registration_Release(IMFLocalMFTRegistration *iface)
 466 {
 467     return 1;
 468 }
 469
 470 static HRESULT WINAPI local_mft_registration_RegisterMFTs(IMFLocalMFTRegistration *iface, MFT_REGISTRATION_INFO *info,
 471         DWORD count)
 472 {
 473     HRESULT hr = S_OK;
 474     DWORD i;
 475
 476     TRACE("%p, %p, %u.\n", iface, info, count);
 477
 478     for (i = 0; i < count; ++i)
 479     {
 480         if (FAILED(hr = MFTRegisterLocalByCLSID(&info[i].clsid, &info[i].guidCategory, info[i].pszName,
 481                 info[i].uiFlags, info[i].cInTypes, info[i].pInTypes, info[i].cOutTypes, info[i].pOutTypes)))
 482         {
 483             break;
 484         }
 485     }
 486
 487     return hr;
 488 }
 489
 490 static const IMFLocalMFTRegistrationVtbl local_mft_registration_vtbl =
 491 {
 492     local_mft_registration_QueryInterface,
 493     local_mft_registration_AddRef,
 494     local_mft_registration_Release,
 495     local_mft_registration_RegisterMFTs,
 496 };
 497
 498 static IMFLocalMFTRegistration local_mft_registration = { &local_mft_registration_vtbl };
 499
 500 static HRESULT WINAPI session_op_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 501 {
 502     if (IsEqualIID(riid, &IID_IUnknown))
 503     {
 504         *obj = iface;
 505         IUnknown_AddRef(iface);
 506         return S_OK;
 507     }
 508
 509     *obj = NULL;
 510     return E_NOINTERFACE;
 511 }
 512
 513 static ULONG WINAPI session_op_AddRef(IUnknown *iface)
 514 {
 515     struct session_op *op = impl_op_from_IUnknown(iface);
 516     ULONG refcount = InterlockedIncrement(&op->refcount);
 517
 518     TRACE("%p, refcount %u.\n", iface, refcount);
 519
 520     return refcount;
 521 }
 522
 523 static ULONG WINAPI session_op_Release(IUnknown *iface)
 524 {
 525     struct session_op *op = impl_op_from_IUnknown(iface);
 526     ULONG refcount = InterlockedDecrement(&op->refcount);
 527
 528     TRACE("%p, refcount %u.\n", iface, refcount);
 529
 530     if (!refcount)
 531     {
 532         switch (op->command)
 533         {
 534             case SESSION_CMD_SET_TOPOLOGY:
 535                 if (op->u.set_topology.topology)
 536                     IMFTopology_Release(op->u.set_topology.topology);
 537                 break;
 538             case SESSION_CMD_START:
 539                 PropVariantClear(&op->u.start.start_position);
 540                 break;
 541             case SESSION_CMD_QM_NOTIFY_TOPOLOGY:
 542                 if (op->u.notify_topology.topology)
 543                     IMFTopology_Release(op->u.notify_topology.topology);
 544                 break;
 545             default:
 546                 ;
 547         }
 548         heap_free(op);
 549     }
 550
 551     return refcount;
 552 }
 553
 554 static const IUnknownVtbl session_op_vtbl =
 555 {
 556     session_op_QueryInterface,
 557     session_op_AddRef,
 558     session_op_Release,
 559 };
 560
 561 static HRESULT create_session_op(enum session_command command, struct session_op **ret)
 562 {
 563     struct session_op *op;
 564
 565     if (!(op = heap_alloc_zero(sizeof(*op))))
 566         return E_OUTOFMEMORY;
 567
 568     op->IUnknown_iface.lpVtbl = &session_op_vtbl;
 569     op->refcount = 1;
 570     op->command = command;
 571
 572     *ret = op;
 573
 574     return S_OK;
 575 }
 576
 577 static HRESULT session_is_shut_down(struct media_session *session)
 578 {
 579     return session->state == SESSION_STATE_SHUT_DOWN ? MF_E_SHUTDOWN : S_OK;
 580 }
 581
 582 static void session_push_back_command(struct media_session *session, enum session_command command)
 583 {
 584     struct session_op *op;
 585
 586     if (SUCCEEDED(create_session_op(command, &op)))
 587         list_add_head(&session->commands, &op->entry);
 588 }
 589
 590 static HRESULT session_submit_command(struct media_session *session, struct session_op *op)
 591 {
 592     HRESULT hr;
 593
 594     EnterCriticalSection(&session->cs);
 595     if (SUCCEEDED(hr = session_is_shut_down(session)))
 596     {
 597         if (list_empty(&session->commands))
 598             hr = MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, &session->commands_callback, &op->IUnknown_iface);
 599         list_add_tail(&session->commands, &op->entry);
 600         IUnknown_AddRef(&op->IUnknown_iface);
 601     }
 602     LeaveCriticalSection(&session->cs);
 603
 604     return hr;
 605 }
 606
 607 static HRESULT session_submit_simple_command(struct media_session *session, enum session_command command)
 608 {
 609     struct session_op *op;
 610     HRESULT hr;
 611
 612     if (FAILED(hr = create_session_op(command, &op)))
 613         return hr;
 614
 615     hr = session_submit_command(session, op);
 616     IUnknown_Release(&op->IUnknown_iface);
 617     return hr;
 618 }
 619
 620 static void session_clear_topologies(struct media_session *session)
 621 {
 622     struct queued_topology *ptr, *next;
 623
 624     LIST_FOR_EACH_ENTRY_SAFE(ptr, next, &session->topologies, struct queued_topology, entry)
 625     {
 626         list_remove(&ptr->entry);
 627         IMFTopology_Release(ptr->topology);
 628         heap_free(ptr);
 629     }
 630 }
 631
 632 static void session_set_topo_status(struct media_session *session, HRESULT status,
 633         MF_TOPOSTATUS topo_status)
 634 {
 635     IMFMediaEvent *event;
 636     PROPVARIANT param;
 637
 638     if (topo_status == MF_TOPOSTATUS_INVALID)
 639         return;
 640
 641     if (list_empty(&session->topologies))
 642     {
 643         FIXME("Unexpectedly empty topology queue.\n");
 644         return;
 645     }
 646
 647     if (topo_status > session->presentation.topo_status)
 648     {
 649         struct queued_topology *topology = LIST_ENTRY(list_head(&session->topologies), struct queued_topology, entry);
 650
 651         param.vt = VT_UNKNOWN;
 652         param.punkVal = (IUnknown *)topology->topology;
 653
 654         if (FAILED(MFCreateMediaEvent(MESessionTopologyStatus, &GUID_NULL, status, &param, &event)))
 655             return;
 656
 657         session->presentation.topo_status = topo_status;
 658
 659         IMFMediaEvent_SetUINT32(event, &MF_EVENT_TOPOLOGY_STATUS, topo_status);
 660         IMFMediaEventQueue_QueueEvent(session->event_queue, event);
 661         IMFMediaEvent_Release(event);
 662     }
 663 }
 664
 665 static HRESULT session_bind_output_nodes(IMFTopology *topology)
 666 {
 667     MF_TOPOLOGY_TYPE node_type;
 668     IMFStreamSink *stream_sink;
 669     IMFMediaSink *media_sink;
 670     WORD node_count = 0, i;
 671     IMFTopologyNode *node;
 672     IMFActivate *activate;
 673     UINT32 stream_id;
 674     IUnknown *object;
 675     HRESULT hr;
 676
 677     hr = IMFTopology_GetNodeCount(topology, &node_count);
 678
 679     for (i = 0; i < node_count; ++i)
 680     {
 681         if (FAILED(hr = IMFTopology_GetNode(topology, i, &node)))
 682             break;
 683
 684         if (FAILED(hr = IMFTopologyNode_GetNodeType(node, &node_type)) || node_type != MF_TOPOLOGY_OUTPUT_NODE)
 685         {
 686             IMFTopologyNode_Release(node);
 687             continue;
 688         }
 689
 690         if (SUCCEEDED(hr = IMFTopologyNode_GetObject(node, &object)))
 691         {
 692             stream_sink = NULL;
 693             if (FAILED(IUnknown_QueryInterface(object, &IID_IMFStreamSink, (void **)&stream_sink)))
 694             {
 695                 if (SUCCEEDED(hr = IUnknown_QueryInterface(object, &IID_IMFActivate, (void **)&activate)))
 696                 {
 697                     if (SUCCEEDED(hr = IMFActivate_ActivateObject(activate, &IID_IMFMediaSink, (void **)&media_sink)))
 698                     {
 699                         if (FAILED(IMFTopologyNode_GetUINT32(node, &MF_TOPONODE_STREAMID, &stream_id)))
 700                             stream_id = 0;
 701
 702                         stream_sink = NULL;
 703                         if (FAILED(IMFMediaSink_GetStreamSinkById(media_sink, stream_id, &stream_sink)))
 704                             hr = IMFMediaSink_AddStreamSink(media_sink, stream_id, NULL, &stream_sink);
 705
 706                         if (stream_sink)
 707                             hr = IMFTopologyNode_SetObject(node, (IUnknown *)stream_sink);
 708
 709                         IMFMediaSink_Release(media_sink);
 710                     }
 711
 712                     if (SUCCEEDED(hr))
 713                         IMFTopologyNode_SetUnknown(node, &_MF_TOPONODE_IMFActivate, (IUnknown *)activate);
 714
 715                     IMFActivate_Release(activate);
 716                 }
 717             }
 718
 719             if (stream_sink)
 720                 IMFStreamSink_Release(stream_sink);
 721             IUnknown_Release(object);
 722         }
 723
 724         IMFTopologyNode_Release(node);
 725     }
 726
 727     return hr;
 728 }
 729
 730 static void session_set_caps(struct media_session *session, DWORD caps)
 731 {
 732     DWORD delta = session->caps ^ caps;
 733     IMFMediaEvent *event;
 734
 735     /* Delta is documented to reflect rate value changes as well, but it's not clear what to compare
 736        them to, since session always queries for current object rates. */
 737     if (!delta)
 738         return;
 739
 740     session->caps = caps;
 741
 742     if (FAILED(MFCreateMediaEvent(MESessionCapabilitiesChanged, &GUID_NULL, S_OK, NULL, &event)))
 743         return;
 744
 745     IMFMediaEvent_SetUINT32(event, &MF_EVENT_SESSIONCAPS, caps);
 746     IMFMediaEvent_SetUINT32(event, &MF_EVENT_SESSIONCAPS_DELTA, delta);
 747
 748     IMFMediaEventQueue_QueueEvent(session->event_queue, event);
 749     IMFMediaEvent_Release(event);
 750 }
 751
 752 static void transform_release_sample(struct sample *sample)
 753 {
 754     list_remove(&sample->entry);
 755     if (sample->sample)
 756         IMFSample_Release(sample->sample);
 757     heap_free(sample);
 758 }
 759
 760 static void transform_stream_drop_samples(struct transform_stream *stream)
 761 {
 762     struct sample *sample, *sample2;
 763
 764     LIST_FOR_EACH_ENTRY_SAFE(sample, sample2, &stream->samples, struct sample, entry)
 765         transform_release_sample(sample);
 766 }
 767
 768 static void release_topo_node(struct topo_node *node)
 769 {
 770     unsigned int i;
 771
 772     switch (node->type)
 773     {
 774         case MF_TOPOLOGY_SOURCESTREAM_NODE:
 775             if (node->u.source.source)
 776                 IMFMediaSource_Release(node->u.source.source);
 777             break;
 778         case MF_TOPOLOGY_TRANSFORM_NODE:
 779             for (i = 0; i < node->u.transform.input_count; ++i)
 780                 transform_stream_drop_samples(&node->u.transform.inputs[i]);
 781             for (i = 0; i < node->u.transform.output_count; ++i)
 782                 transform_stream_drop_samples(&node->u.transform.outputs[i]);
 783             heap_free(node->u.transform.inputs);
 784             heap_free(node->u.transform.outputs);
 785             heap_free(node->u.transform.input_map);
 786             heap_free(node->u.transform.output_map);
 787             break;
 788         case MF_TOPOLOGY_OUTPUT_NODE:
 789             if (node->u.sink.allocator)
 790                 IMFVideoSampleAllocator_Release(node->u.sink.allocator);
 791             if (node->u.sink.allocator_cb)
 792             {
 793                 IMFVideoSampleAllocatorCallback_SetCallback(node->u.sink.allocator_cb, NULL);
 794                 IMFVideoSampleAllocatorCallback_Release(node->u.sink.allocator_cb);
 795             }
 796             break;
 797         default:
 798             ;
 799     }
 800
 801     if (node->object.object)
 802         IUnknown_Release(node->object.object);
 803     if (node->node)
 804         IMFTopologyNode_Release(node->node);
 805     heap_free(node);
 806 }
 807
 808 static void session_shutdown_current_topology(struct media_session *session)
 809 {
 810     unsigned int shutdown, force_shutdown;
 811     MF_TOPOLOGY_TYPE node_type;
 812     IMFStreamSink *stream_sink;
 813     IMFTopology *topology;
 814     IMFTopologyNode *node;
 815     IMFActivate *activate;
 816     IMFMediaSink *sink;
 817     WORD idx = 0;
 818     HRESULT hr;
 819
 820     topology = session->presentation.current_topology;
 821     force_shutdown = session->state == SESSION_STATE_SHUT_DOWN;
 822
 823     /* FIXME: should handle async MFTs, but these are not supported by the rest of the pipeline currently. */
 824
 825     while (SUCCEEDED(IMFTopology_GetNode(topology, idx++, &node)))
 826     {
 827         if (SUCCEEDED(IMFTopologyNode_GetNodeType(node, &node_type)) &&
 828                 node_type == MF_TOPOLOGY_OUTPUT_NODE)
 829         {
 830             shutdown = 1;
 831             IMFTopologyNode_GetUINT32(node, &MF_TOPONODE_NOSHUTDOWN_ON_REMOVE, &shutdown);
 832
 833             if (force_shutdown || shutdown)
 834             {
 835                 if (SUCCEEDED(IMFTopologyNode_GetUnknown(node, &_MF_TOPONODE_IMFActivate, &IID_IMFActivate,
 836                         (void **)&activate)))
 837                 {
 838                     if (FAILED(hr = IMFActivate_ShutdownObject(activate)))
 839                         WARN("Failed to shut down activation object for the sink, hr %#x.\n", hr);
 840                     IMFActivate_Release(activate);
 841                 }
 842                 else if (SUCCEEDED(topology_node_get_object(node, &IID_IMFStreamSink, (void **)&stream_sink)))
 843                 {
 844                     if (SUCCEEDED(IMFStreamSink_GetMediaSink(stream_sink, &sink)))
 845                     {
 846                         IMFMediaSink_Shutdown(sink);
 847                         IMFMediaSink_Release(sink);
 848                     }
 849
 850                     IMFStreamSink_Release(stream_sink);
 851                 }
 852             }
 853         }
 854
 855         IMFTopologyNode_Release(node);
 856     }
 857 }
 858
 859 static void session_clear_command_list(struct media_session *session)
 860 {
 861     struct session_op *op, *op2;
 862
 863     LIST_FOR_EACH_ENTRY_SAFE(op, op2, &session->commands, struct session_op, entry)
 864     {
 865         list_remove(&op->entry);
 866         IUnknown_Release(&op->IUnknown_iface);
 867     }
 868 }
 869
 870 static void session_clear_presentation(struct media_session *session)
 871 {
 872     struct media_source *source, *source2;
 873     struct media_sink *sink, *sink2;
 874     struct topo_node *node, *node2;
 875
 876     session_shutdown_current_topology(session);
 877
 878     IMFTopology_Clear(session->presentation.current_topology);
 879     session->presentation.topo_status = MF_TOPOSTATUS_INVALID;
 880
 881     LIST_FOR_EACH_ENTRY_SAFE(source, source2, &session->presentation.sources, struct media_source, entry)
 882     {
 883         list_remove(&source->entry);
 884         if (source->source)
 885             IMFMediaSource_Release(source->source);
 886         if (source->pd)
 887             IMFPresentationDescriptor_Release(source->pd);
 888         heap_free(source);
 889     }
 890
 891     LIST_FOR_EACH_ENTRY_SAFE(node, node2, &session->presentation.nodes, struct topo_node, entry)
 892     {
 893         list_remove(&node->entry);
 894         release_topo_node(node);
 895     }
 896
 897     LIST_FOR_EACH_ENTRY_SAFE(sink, sink2, &session->presentation.sinks, struct media_sink, entry)
 898     {
 899         list_remove(&sink->entry);
 900
 901         if (sink->sink)
 902             IMFMediaSink_Release(sink->sink);
 903         if (sink->preroll)
 904             IMFMediaSinkPreroll_Release(sink->preroll);
 905         if (sink->event_generator)
 906             IMFMediaEventGenerator_Release(sink->event_generator);
 907         heap_free(sink);
 908     }
 909 }
 910
 911 static struct topo_node *session_get_node_by_id(const struct media_session *session, TOPOID id)
 912 {
 913     struct topo_node *node;
 914
 915     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
 916     {
 917         if (node->node_id == id)
 918             return node;
 919     }
 920
 921     return NULL;
 922 }
 923
 924 static void session_start(struct media_session *session, const GUID *time_format, const PROPVARIANT *start_position)
 925 {
 926     struct media_source *source;
 927     HRESULT hr;
 928
 929     switch (session->state)
 930     {
 931         case SESSION_STATE_STOPPED:
 932         case SESSION_STATE_PAUSED:
 933
 934             session->presentation.time_format = *time_format;
 935             session->presentation.start_position.vt = VT_EMPTY;
 936             PropVariantCopy(&session->presentation.start_position, start_position);
 937
 938             LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
 939             {
 940                 if (!(session->presentation.flags & SESSION_FLAG_SOURCES_SUBSCRIBED))
 941                 {
 942                     if (FAILED(hr = IMFMediaSource_BeginGetEvent(source->source, &session->events_callback,
 943                             (IUnknown *)source->source)))
 944                     {
 945                         WARN("Failed to subscribe to source events, hr %#x.\n", hr);
 946                     }
 947                 }
 948
 949                 if (FAILED(hr = IMFMediaSource_Start(source->source, source->pd, &GUID_NULL, start_position)))
 950                     WARN("Failed to start media source %p, hr %#x.\n", source->source, hr);
 951             }
 952
 953             session->presentation.flags |= SESSION_FLAG_SOURCES_SUBSCRIBED;
 954             session->state = SESSION_STATE_STARTING_SOURCES;
 955             break;
 956         case SESSION_STATE_STARTED:
 957             FIXME("Seeking is not implemented.\n");
 958             break;
 959         case SESSION_STATE_CLOSED:
 960             IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionStarted, &GUID_NULL,
 961                     MF_E_INVALIDREQUEST, NULL);
 962             break;
 963         default:
 964             ;
 965     }
 966 }
 967
 968 static void session_command_complete(struct media_session *session)
 969 {
 970     struct session_op *op;
 971     struct list *e;
 972
 973     /* Pop current command, submit next. */
 974     if ((e = list_head(&session->commands)))
 975     {
 976         op = LIST_ENTRY(e, struct session_op, entry);
 977         list_remove(&op->entry);
 978         IUnknown_Release(&op->IUnknown_iface);
 979     }
 980
 981     if ((e = list_head(&session->commands)))
 982     {
 983         op = LIST_ENTRY(e, struct session_op, entry);
 984         MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, &session->commands_callback, &op->IUnknown_iface);
 985     }
 986 }
 987
 988 static void session_set_started(struct media_session *session)
 989 {
 990     struct media_source *source;
 991     unsigned int caps, flags;
 992     IMFMediaEvent *event;
 993
 994     session->state = SESSION_STATE_STARTED;
 995
 996     caps = session->caps | MFSESSIONCAP_PAUSE;
 997
 998     LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
 999     {
1000         if (SUCCEEDED(IMFMediaSource_GetCharacteristics(source->source, &flags)))
1001         {
1002             if (!(flags & MFMEDIASOURCE_CAN_PAUSE))
1003             {
1004                 caps &= ~MFSESSIONCAP_PAUSE;
1005                 break;
1006             }
1007         }
1008     }
1009
1010     session_set_caps(session, caps);
1011
1012     if (SUCCEEDED(MFCreateMediaEvent(MESessionStarted, &GUID_NULL, S_OK, NULL, &event)))
1013     {
1014         IMFMediaEvent_SetUINT64(event, &MF_EVENT_PRESENTATION_TIME_OFFSET, 0);
1015         IMFMediaEventQueue_QueueEvent(session->event_queue, event);
1016         IMFMediaEvent_Release(event);
1017     }
1018     session_command_complete(session);
1019 }
1020
1021 static void session_set_paused(struct media_session *session, HRESULT status)
1022 {
1023     session->state = SESSION_STATE_PAUSED;
1024     if (SUCCEEDED(status))
1025         session_set_caps(session, session->caps & ~MFSESSIONCAP_PAUSE);
1026     IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionPaused, &GUID_NULL, status, NULL);
1027     session_command_complete(session);
1028 }
1029
1030 static void session_set_closed(struct media_session *session, HRESULT status)
1031 {
1032     session->state = SESSION_STATE_CLOSED;
1033     if (SUCCEEDED(status))
1034         session_set_caps(session, session->caps & ~(MFSESSIONCAP_START | MFSESSIONCAP_SEEK));
1035     IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionClosed, &GUID_NULL, status, NULL);
1036     session_command_complete(session);
1037 }
1038
1039 static void session_pause(struct media_session *session)
1040 {
1041     HRESULT hr;
1042
1043     switch (session->state)
1044     {
1045         case SESSION_STATE_STARTED:
1046
1047             /* Transition in two steps - pause the clock, wait for sinks, then pause sources. */
1048             if (SUCCEEDED(hr = IMFPresentationClock_Pause(session->clock)))
1049                 session->state = SESSION_STATE_PAUSING_SINKS;
1050
1051             break;
1052         default:
1053             hr = MF_E_INVALIDREQUEST;
1054     }
1055
1056     if (FAILED(hr))
1057         session_set_paused(session, hr);
1058 }
1059
1060 static void session_set_stopped(struct media_session *session, HRESULT status)
1061 {
1062     MediaEventType event_type;
1063     IMFMediaEvent *event;
1064
1065     session->state = SESSION_STATE_STOPPED;
1066     event_type = session->presentation.flags & SESSION_FLAG_END_OF_PRESENTATION ? MESessionEnded : MESessionStopped;
1067
1068     if (SUCCEEDED(MFCreateMediaEvent(event_type, &GUID_NULL, status, NULL, &event)))
1069     {
1070         IMFMediaEvent_SetUINT64(event, &MF_SESSION_APPROX_EVENT_OCCURRENCE_TIME, session->presentation.clock_stop_time);
1071         IMFMediaEventQueue_QueueEvent(session->event_queue, event);
1072         IMFMediaEvent_Release(event);
1073     }
1074     session_command_complete(session);
1075 }
1076
1077 static void session_stop(struct media_session *session)
1078 {
1079     HRESULT hr = MF_E_INVALIDREQUEST;
1080
1081     switch (session->state)
1082     {
1083         case SESSION_STATE_STARTED:
1084         case SESSION_STATE_PAUSED:
1085
1086             /* Transition in two steps - stop the clock, wait for sinks, then stop sources. */
1087             IMFPresentationClock_GetTime(session->clock, &session->presentation.clock_stop_time);
1088             if (SUCCEEDED(hr = IMFPresentationClock_Stop(session->clock)))
1089                 session->state = SESSION_STATE_STOPPING_SINKS;
1090             else
1091                 session_set_stopped(session, hr);
1092
1093             break;
1094         case SESSION_STATE_STOPPED:
1095             hr = S_OK;
1096             /* fallthrough */
1097         default:
1098             IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionStopped, &GUID_NULL, hr, NULL);
1099             session_command_complete(session);
1100             break;
1101     }
1102 }
1103
1104 static HRESULT session_finalize_sinks(struct media_session *session)
1105 {
1106     IMFFinalizableMediaSink *fin_sink;
1107     BOOL sinks_finalized = TRUE;
1108     struct media_sink *sink;
1109     HRESULT hr = S_OK;
1110
1111     session->presentation.flags &= ~SESSION_FLAG_FINALIZE_SINKS;
1112     session->state = SESSION_STATE_FINALIZING_SINKS;
1113
1114     LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry)
1115     {
1116         if (SUCCEEDED(IMFMediaSink_QueryInterface(sink->sink, &IID_IMFFinalizableMediaSink, (void **)&fin_sink)))
1117         {
1118             hr = IMFFinalizableMediaSink_BeginFinalize(fin_sink, &session->sink_finalizer_callback,
1119                     (IUnknown *)fin_sink);
1120             IMFFinalizableMediaSink_Release(fin_sink);
1121             if (FAILED(hr))
1122                 break;
1123             sinks_finalized = FALSE;
1124         }
1125         else
1126             sink->finalized = TRUE;
1127     }
1128
1129     if (sinks_finalized)
1130         session_set_closed(session, hr);
1131
1132     return hr;
1133 }
1134
1135 static void session_close(struct media_session *session)
1136 {
1137     HRESULT hr = S_OK;
1138
1139     switch (session->state)
1140     {
1141         case SESSION_STATE_STOPPED:
1142             hr = session_finalize_sinks(session);
1143             break;
1144         case SESSION_STATE_STARTED:
1145         case SESSION_STATE_PAUSED:
1146             session->presentation.flags |= SESSION_FLAG_FINALIZE_SINKS;
1147             if (SUCCEEDED(hr = IMFPresentationClock_Stop(session->clock)))
1148                 session->state = SESSION_STATE_STOPPING_SINKS;
1149             break;
1150         default:
1151             hr = MF_E_INVALIDREQUEST;
1152             break;
1153     }
1154
1155     if (FAILED(hr))
1156         session_set_closed(session, hr);
1157 }
1158
1159 static struct media_source *session_get_media_source(struct media_session *session, IMFMediaSource *source)
1160 {
1161     struct media_source *cur;
1162
1163     LIST_FOR_EACH_ENTRY(cur, &session->presentation.sources, struct media_source, entry)
1164     {
1165         if (source == cur->source)
1166             return cur;
1167     }
1168
1169     return NULL;
1170 }
1171
1172 static void session_release_media_source(struct media_source *source)
1173 {
1174     IMFMediaSource_Release(source->source);
1175     if (source->pd)
1176         IMFPresentationDescriptor_Release(source->pd);
1177     heap_free(source);
1178 }
1179
1180 static HRESULT session_add_media_source(struct media_session *session, IMFTopologyNode *node, IMFMediaSource *source)
1181 {
1182     struct media_source *media_source;
1183     HRESULT hr;
1184
1185     if (session_get_media_source(session, source))
1186         return S_FALSE;
1187
1188     if (!(media_source = heap_alloc_zero(sizeof(*media_source))))
1189         return E_OUTOFMEMORY;
1190
1191     media_source->source = source;
1192     IMFMediaSource_AddRef(media_source->source);
1193
1194     hr = IMFTopologyNode_GetUnknown(node, &MF_TOPONODE_PRESENTATION_DESCRIPTOR, &IID_IMFPresentationDescriptor,
1195             (void **)&media_source->pd);
1196
1197     if (SUCCEEDED(hr))
1198         list_add_tail(&session->presentation.sources, &media_source->entry);
1199     else
1200         session_release_media_source(media_source);
1201
1202     return hr;
1203 }
1204
1205 static void session_raise_topology_set(struct media_session *session, IMFTopology *topology, HRESULT status)
1206 {
1207     PROPVARIANT param;
1208
1209     param.vt = topology ? VT_UNKNOWN : VT_EMPTY;
1210     param.punkVal = (IUnknown *)topology;
1211
1212     IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionTopologySet, &GUID_NULL, status, &param);
1213 }
1214
1215 static DWORD session_get_object_rate_caps(IUnknown *object)
1216 {
1217     IMFRateSupport *rate_support;
1218     DWORD caps = 0;
1219     float rate;
1220
1221     if (SUCCEEDED(MFGetService(object, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateSupport, (void **)&rate_support)))
1222     {
1223         rate = 0.0f;
1224         if (SUCCEEDED(IMFRateSupport_GetFastestRate(rate_support, MFRATE_FORWARD, TRUE, &rate)) && rate != 0.0f)
1225             caps |= MFSESSIONCAP_RATE_FORWARD;
1226
1227         rate = 0.0f;
1228         if (SUCCEEDED(IMFRateSupport_GetFastestRate(rate_support, MFRATE_REVERSE, TRUE, &rate)) && rate != 0.0f)
1229             caps |= MFSESSIONCAP_RATE_REVERSE;
1230
1231         IMFRateSupport_Release(rate_support);
1232     }
1233
1234     return caps;
1235 }
1236
1237 static HRESULT session_add_media_sink(struct media_session *session, IMFTopologyNode *node, IMFMediaSink *sink)
1238 {
1239     struct media_sink *media_sink;
1240     unsigned int disable_preroll = 0;
1241     DWORD flags;
1242
1243     LIST_FOR_EACH_ENTRY(media_sink, &session->presentation.sinks, struct media_sink, entry)
1244     {
1245         if (sink == media_sink->sink)
1246             return S_FALSE;
1247     }
1248
1249     if (!(media_sink = heap_alloc_zero(sizeof(*media_sink))))
1250         return E_OUTOFMEMORY;
1251
1252     media_sink->sink = sink;
1253     IMFMediaSink_AddRef(media_sink->sink);
1254
1255     IMFMediaSink_QueryInterface(media_sink->sink, &IID_IMFMediaEventGenerator, (void **)&media_sink->event_generator);
1256
1257     IMFTopologyNode_GetUINT32(node, &MF_TOPONODE_DISABLE_PREROLL, &disable_preroll);
1258     if (SUCCEEDED(IMFMediaSink_GetCharacteristics(sink, &flags)) && flags & MEDIASINK_CAN_PREROLL && !disable_preroll)
1259     {
1260         if (SUCCEEDED(IMFMediaSink_QueryInterface(media_sink->sink, &IID_IMFMediaSinkPreroll, (void **)&media_sink->preroll)))
1261             session->presentation.flags |= SESSION_FLAG_NEEDS_PREROLL;
1262     }
1263
1264     list_add_tail(&session->presentation.sinks, &media_sink->entry);
1265
1266     return S_OK;
1267 }
1268
1269 static unsigned int transform_node_get_stream_id(struct topo_node *node, BOOL output, unsigned int index)
1270 {
1271     unsigned int *map = output ? node->u.transform.output_map : node->u.transform.input_map;
1272     return map ? map[index] : index;
1273 }
1274
1275 static HRESULT session_set_transform_stream_info(struct topo_node *node)
1276 {
1277     unsigned int *input_map = NULL, *output_map = NULL;
1278     unsigned int i, input_count, output_count, block_alignment;
1279     struct transform_stream *streams;
1280     IMFMediaType *media_type;
1281     GUID major = { 0 };
1282     HRESULT hr;
1283
1284     hr = IMFTransform_GetStreamCount(node->object.transform, &input_count, &output_count);
1285     if (SUCCEEDED(hr) && (input_count > 1 || output_count > 1))
1286     {
1287         input_map = heap_calloc(input_count, sizeof(*input_map));
1288         output_map = heap_calloc(output_count, sizeof(*output_map));
1289         if (FAILED(IMFTransform_GetStreamIDs(node->object.transform, input_count, input_map,
1290                 output_count, output_map)))
1291         {
1292             /* Assume sequential identifiers. */
1293             heap_free(input_map);
1294             heap_free(output_map);
1295             input_map = output_map = NULL;
1296         }
1297     }
1298
1299     if (SUCCEEDED(hr))
1300     {
1301         node->u.transform.input_map = input_map;
1302         node->u.transform.output_map = output_map;
1303
1304         streams = heap_calloc(input_count, sizeof(*streams));
1305         for (i = 0; i < input_count; ++i)
1306             list_init(&streams[i].samples);
1307         node->u.transform.inputs = streams;
1308         node->u.transform.input_count = input_count;
1309
1310         streams = heap_calloc(output_count, sizeof(*streams));
1311         for (i = 0; i < output_count; ++i)
1312         {
1313             list_init(&streams[i].samples);
1314
1315             if (SUCCEEDED(IMFTransform_GetOutputCurrentType(node->object.transform,
1316                     transform_node_get_stream_id(node, TRUE, i), &media_type)))
1317             {
1318                 if (SUCCEEDED(IMFMediaType_GetMajorType(media_type, &major)) && IsEqualGUID(&major, &MFMediaType_Audio)
1319                         && SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
1320                 {
1321                     streams[i].min_buffer_size = block_alignment;
1322                 }
1323                 IMFMediaType_Release(media_type);
1324             }
1325         }
1326         node->u.transform.outputs = streams;
1327         node->u.transform.output_count = output_count;
1328     }
1329
1330     return hr;
1331 }
1332
1333 static HRESULT session_get_stream_sink_type(IMFStreamSink *sink, IMFMediaType **media_type)
1334 {
1335     IMFMediaTypeHandler *handler;
1336     HRESULT hr;
1337
1338     if (SUCCEEDED(hr = IMFStreamSink_GetMediaTypeHandler(sink, &handler)))
1339     {
1340         hr = IMFMediaTypeHandler_GetCurrentMediaType(handler, media_type);
1341         IMFMediaTypeHandler_Release(handler);
1342     }
1343
1344     return hr;
1345 }
1346
1347 static HRESULT WINAPI node_sample_allocator_cb_QueryInterface(IMFVideoSampleAllocatorNotify *iface,
1348         REFIID riid, void **obj)
1349 {
1350     if (IsEqualIID(riid, &IID_IMFVideoSampleAllocatorNotify) ||
1351             IsEqualIID(riid, &IID_IUnknown))
1352     {
1353         *obj = iface;
1354         IMFVideoSampleAllocatorNotify_AddRef(iface);
1355         return S_OK;
1356     }
1357
1358     *obj = NULL;
1359     return E_NOINTERFACE;
1360 }
1361
1362 static ULONG WINAPI node_sample_allocator_cb_AddRef(IMFVideoSampleAllocatorNotify *iface)
1363 {
1364     return 2;
1365 }
1366
1367 static ULONG WINAPI node_sample_allocator_cb_Release(IMFVideoSampleAllocatorNotify *iface)
1368 {
1369     return 1;
1370 }
1371
1372 static HRESULT session_request_sample_from_node(struct media_session *session, IMFTopologyNode *node, DWORD output);
1373
1374 static HRESULT WINAPI node_sample_allocator_cb_NotifyRelease(IMFVideoSampleAllocatorNotify *iface)
1375 {
1376     struct topo_node *topo_node = impl_node_from_IMFVideoSampleAllocatorNotify(iface);
1377     struct session_op *op;
1378
1379     if (SUCCEEDED(create_session_op(SESSION_CMD_SA_READY, &op)))
1380     {
1381         op->u.sa_ready.node_id = topo_node->node_id;
1382         MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, &topo_node->session->commands_callback, &op->IUnknown_iface);
1383         IUnknown_Release(&op->IUnknown_iface);
1384     }
1385
1386     return S_OK;
1387 }
1388
1389 static const IMFVideoSampleAllocatorNotifyVtbl node_sample_allocator_cb_vtbl =
1390 {
1391     node_sample_allocator_cb_QueryInterface,
1392     node_sample_allocator_cb_AddRef,
1393     node_sample_allocator_cb_Release,
1394     node_sample_allocator_cb_NotifyRelease,
1395 };
1396
1397 static HRESULT session_append_node(struct media_session *session, IMFTopologyNode *node)
1398 {
1399     struct topo_node *topo_node;
1400     IMFMediaSink *media_sink;
1401     IMFMediaType *media_type;
1402     IMFStreamDescriptor *sd;
1403     HRESULT hr = S_OK;
1404
1405     if (!(topo_node = heap_alloc_zero(sizeof(*topo_node))))
1406         return E_OUTOFMEMORY;
1407
1408     IMFTopologyNode_GetNodeType(node, &topo_node->type);
1409     IMFTopologyNode_GetTopoNodeID(node, &topo_node->node_id);
1410     topo_node->node = node;
1411     IMFTopologyNode_AddRef(topo_node->node);
1412     topo_node->session = session;
1413
1414     switch (topo_node->type)
1415     {
1416         case MF_TOPOLOGY_OUTPUT_NODE:
1417             topo_node->u.sink.notify_cb.lpVtbl = &node_sample_allocator_cb_vtbl;
1418
1419             if (FAILED(hr = topology_node_get_object(node, &IID_IMFStreamSink, (void **)&topo_node->object.object)))
1420             {
1421                 WARN("Failed to get stream sink interface, hr %#x.\n", hr);
1422                 break;
1423             }
1424
1425             if (FAILED(hr = IMFStreamSink_GetMediaSink(topo_node->object.sink_stream, &media_sink)))
1426                 break;
1427
1428             if (SUCCEEDED(hr = session_add_media_sink(session, node, media_sink)))
1429             {
1430                 if (SUCCEEDED(session_get_stream_sink_type(topo_node->object.sink_stream, &media_type)))
1431                 {
1432                     if (SUCCEEDED(MFGetService(topo_node->object.object, &MR_VIDEO_ACCELERATION_SERVICE,
1433                         &IID_IMFVideoSampleAllocator, (void **)&topo_node->u.sink.allocator)))
1434                     {
1435                         if (FAILED(hr = IMFVideoSampleAllocator_InitializeSampleAllocator(topo_node->u.sink.allocator,
1436                                 2, media_type)))
1437                         {
1438                             WARN("Failed to initialize sample allocator for the stream, hr %#x.\n", hr);
1439                         }
1440                         IMFVideoSampleAllocator_QueryInterface(topo_node->u.sink.allocator,
1441                                 &IID_IMFVideoSampleAllocatorCallback, (void **)&topo_node->u.sink.allocator_cb);
1442                         IMFVideoSampleAllocatorCallback_SetCallback(topo_node->u.sink.allocator_cb,
1443                                 &topo_node->u.sink.notify_cb);
1444                     }
1445                     IMFMediaType_Release(media_type);
1446                 }
1447             }
1448             IMFMediaSink_Release(media_sink);
1449
1450             break;
1451         case MF_TOPOLOGY_SOURCESTREAM_NODE:
1452             if (FAILED(IMFTopologyNode_GetUnknown(node, &MF_TOPONODE_SOURCE, &IID_IMFMediaSource,
1453                     (void **)&topo_node->u.source.source)))
1454             {
1455                 WARN("Missing MF_TOPONODE_SOURCE, hr %#x.\n", hr);
1456                 break;
1457             }
1458
1459             if (FAILED(hr = session_add_media_source(session, node, topo_node->u.source.source)))
1460                 break;
1461
1462             if (FAILED(hr = IMFTopologyNode_GetUnknown(node, &MF_TOPONODE_STREAM_DESCRIPTOR,
1463                     &IID_IMFStreamDescriptor, (void **)&sd)))
1464             {
1465                 WARN("Missing MF_TOPONODE_STREAM_DESCRIPTOR, hr %#x.\n", hr);
1466                 break;
1467             }
1468
1469             hr = IMFStreamDescriptor_GetStreamIdentifier(sd, &topo_node->u.source.stream_id);
1470             IMFStreamDescriptor_Release(sd);
1471
1472             break;
1473         case MF_TOPOLOGY_TRANSFORM_NODE:
1474
1475             if (SUCCEEDED(hr = topology_node_get_object(node, &IID_IMFTransform, (void **)&topo_node->object.transform)))
1476             {
1477                 hr = session_set_transform_stream_info(topo_node);
1478             }
1479             else
1480                 WARN("Failed to get IMFTransform for MFT node, hr %#x.\n", hr);
1481
1482             break;
1483         case MF_TOPOLOGY_TEE_NODE:
1484             FIXME("Unsupported node type %d.\n", topo_node->type);
1485
1486             break;
1487         default:
1488             ;
1489     }
1490
1491     if (SUCCEEDED(hr))
1492         list_add_tail(&session->presentation.nodes, &topo_node->entry);
1493     else
1494         release_topo_node(topo_node);
1495
1496     return hr;
1497 }
1498
1499 static HRESULT session_collect_nodes(struct media_session *session)
1500 {
1501     IMFTopology *topology = session->presentation.current_topology;
1502     IMFTopologyNode *node;
1503     WORD i, count = 0;
1504     HRESULT hr;
1505
1506     if (!list_empty(&session->presentation.nodes))
1507         return S_OK;
1508
1509     if (FAILED(hr = IMFTopology_GetNodeCount(topology, &count)))
1510         return hr;
1511
1512     for (i = 0; i < count; ++i)
1513     {
1514         if (FAILED(hr = IMFTopology_GetNode(topology, i, &node)))
1515         {
1516             WARN("Failed to get node %u.\n", i);
1517             break;
1518         }
1519
1520         hr = session_append_node(session, node);
1521         IMFTopologyNode_Release(node);
1522         if (FAILED(hr))
1523         {
1524             WARN("Failed to add node %u.\n", i);
1525             break;
1526         }
1527     }
1528
1529     return hr;
1530 }
1531
1532 static HRESULT session_set_current_topology(struct media_session *session, IMFTopology *topology)
1533 {
1534     struct media_source *source;
1535     DWORD caps, object_flags;
1536     struct media_sink *sink;
1537     struct topo_node *node;
1538     struct session_op *op;
1539     IMFMediaEvent *event;
1540     HRESULT hr;
1541
1542     if (session->quality_manager)
1543     {
1544         if (SUCCEEDED(create_session_op(SESSION_CMD_QM_NOTIFY_TOPOLOGY, &op)))
1545         {
1546             op->u.notify_topology.topology = topology;
1547             IMFTopology_AddRef(op->u.notify_topology.topology);
1548             session_submit_command(session, op);
1549             IUnknown_Release(&op->IUnknown_iface);
1550         }
1551     }
1552
1553     if (FAILED(hr = IMFTopology_CloneFrom(session->presentation.current_topology, topology)))
1554     {
1555         WARN("Failed to clone topology, hr %#x.\n", hr);
1556         return hr;
1557     }
1558
1559     session_collect_nodes(session);
1560
1561     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
1562     {
1563         if (node->type == MF_TOPOLOGY_TRANSFORM_NODE)
1564         {
1565             if (FAILED(hr = IMFTransform_ProcessMessage(node->object.transform,
1566                     MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0)))
1567                 return hr;
1568         }
1569     }
1570
1571     /* FIXME: attributes are all zero for now */
1572     if (SUCCEEDED(MFCreateMediaEvent(MESessionNotifyPresentationTime, &GUID_NULL, S_OK, NULL, &event)))
1573     {
1574         IMFMediaEvent_SetUINT64(event, &MF_EVENT_START_PRESENTATION_TIME, 0);
1575         IMFMediaEvent_SetUINT64(event, &MF_EVENT_PRESENTATION_TIME_OFFSET, 0);
1576         IMFMediaEvent_SetUINT64(event, &MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT, 0);
1577
1578         IMFMediaEventQueue_QueueEvent(session->event_queue, event);
1579         IMFMediaEvent_Release(event);
1580     }
1581
1582     /* Update session caps. */
1583     caps = MFSESSIONCAP_START | MFSESSIONCAP_SEEK | MFSESSIONCAP_RATE_FORWARD | MFSESSIONCAP_RATE_REVERSE |
1584             MFSESSIONCAP_DOES_NOT_USE_NETWORK;
1585
1586     LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
1587     {
1588         if (!caps)
1589             break;
1590
1591         object_flags = 0;
1592         if (SUCCEEDED(IMFMediaSource_GetCharacteristics(source->source, &object_flags)))
1593         {
1594             if (!(object_flags & MFMEDIASOURCE_DOES_NOT_USE_NETWORK))
1595                 caps &= ~MFSESSIONCAP_DOES_NOT_USE_NETWORK;
1596             if (!(object_flags & MFMEDIASOURCE_CAN_SEEK))
1597                 caps &= ~MFSESSIONCAP_SEEK;
1598         }
1599
1600         /* Mask unsupported rate caps. */
1601
1602         caps &= session_get_object_rate_caps((IUnknown *)source->source)
1603                 | ~(MFSESSIONCAP_RATE_FORWARD | MFSESSIONCAP_RATE_REVERSE);
1604     }
1605
1606     LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry)
1607     {
1608         if (!caps)
1609             break;
1610
1611         object_flags = 0;
1612         if (SUCCEEDED(IMFMediaSink_GetCharacteristics(sink->sink, &object_flags)))
1613         {
1614             if (!(object_flags & MEDIASINK_RATELESS))
1615                 caps &= session_get_object_rate_caps((IUnknown *)sink->sink)
1616                         | ~(MFSESSIONCAP_RATE_FORWARD | MFSESSIONCAP_RATE_REVERSE);
1617         }
1618     }
1619
1620     session_set_caps(session, caps);
1621
1622     return S_OK;
1623 }
1624
1625 static void session_set_topology(struct media_session *session, DWORD flags, IMFTopology *topology)
1626 {
1627     IMFTopology *resolved_topology = NULL;
1628     HRESULT hr = S_OK;
1629
1630     /* Resolve unless claimed to be full. */
1631     if (!(flags & MFSESSION_SETTOPOLOGY_CLEAR_CURRENT) && topology)
1632     {
1633         if (!(flags & MFSESSION_SETTOPOLOGY_NORESOLUTION))
1634         {
1635             hr = session_bind_output_nodes(topology);
1636
1637             if (SUCCEEDED(hr))
1638                 hr = IMFTopoLoader_Load(session->topo_loader, topology, &resolved_topology, NULL /* FIXME? */);
1639
1640             if (SUCCEEDED(hr))
1641             {
1642                 topology = resolved_topology;
1643             }
1644         }
1645     }
1646
1647     if (flags & MFSESSION_SETTOPOLOGY_CLEAR_CURRENT)
1648     {
1649         if ((topology && topology == session->presentation.current_topology) || !topology)
1650         {
1651             /* FIXME: stop current topology, queue next one. */
1652             session_clear_presentation(session);
1653         }
1654         else
1655             hr = S_FALSE;
1656
1657         topology = NULL;
1658     }
1659     else if (topology && flags & MFSESSION_SETTOPOLOGY_IMMEDIATE)
1660     {
1661         session_clear_topologies(session);
1662         session_clear_presentation(session);
1663     }
1664
1665     session_raise_topology_set(session, topology, hr);
1666
1667     /* With no current topology set it right away, otherwise queue. */
1668     if (topology)
1669     {
1670         struct queued_topology *queued_topology;
1671
1672         if ((queued_topology = heap_alloc_zero(sizeof(*queued_topology))))
1673         {
1674             queued_topology->topology = topology;
1675             IMFTopology_AddRef(queued_topology->topology);
1676
1677             list_add_tail(&session->topologies, &queued_topology->entry);
1678         }
1679
1680         if (session->presentation.topo_status == MF_TOPOSTATUS_INVALID)
1681         {
1682             hr = session_set_current_topology(session, topology);
1683             session_set_topo_status(session, hr, MF_TOPOSTATUS_READY);
1684         }
1685     }
1686
1687     if (resolved_topology)
1688         IMFTopology_Release(resolved_topology);
1689 }
1690
1691 static HRESULT WINAPI mfsession_QueryInterface(IMFMediaSession *iface, REFIID riid, void **out)
1692 {
1693     struct media_session *session = impl_from_IMFMediaSession(iface);
1694
1695     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
1696
1697     if (IsEqualIID(riid, &IID_IMFMediaSession) ||
1698             IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
1699             IsEqualIID(riid, &IID_IUnknown))
1700     {
1701         *out = &session->IMFMediaSession_iface;
1702         IMFMediaSession_AddRef(iface);
1703         return S_OK;
1704     }
1705     else if (IsEqualIID(riid, &IID_IMFGetService))
1706     {
1707         *out = &session->IMFGetService_iface;
1708         IMFMediaSession_AddRef(iface);
1709         return S_OK;
1710     }
1711
1712     WARN("Unsupported %s.\n", debugstr_guid(riid));
1713     *out = NULL;
1714     return E_NOINTERFACE;
1715 }
1716
1717 static ULONG WINAPI mfsession_AddRef(IMFMediaSession *iface)
1718 {
1719     struct media_session *session = impl_from_IMFMediaSession(iface);
1720     ULONG refcount = InterlockedIncrement(&session->refcount);
1721
1722     TRACE("%p, refcount %u.\n", iface, refcount);
1723
1724     return refcount;
1725 }
1726
1727 static ULONG WINAPI mfsession_Release(IMFMediaSession *iface)
1728 {
1729     struct media_session *session = impl_from_IMFMediaSession(iface);
1730     ULONG refcount = InterlockedDecrement(&session->refcount);
1731
1732     TRACE("%p, refcount %u.\n", iface, refcount);
1733
1734     if (!refcount)
1735     {
1736         session_clear_topologies(session);
1737         session_clear_presentation(session);
1738         session_clear_command_list(session);
1739         if (session->presentation.current_topology)
1740             IMFTopology_Release(session->presentation.current_topology);
1741         if (session->event_queue)
1742             IMFMediaEventQueue_Release(session->event_queue);
1743         if (session->clock)
1744             IMFPresentationClock_Release(session->clock);
1745         if (session->system_time_source)
1746             IMFPresentationTimeSource_Release(session->system_time_source);
1747         if (session->clock_rate_control)
1748             IMFRateControl_Release(session->clock_rate_control);
1749         if (session->topo_loader)
1750             IMFTopoLoader_Release(session->topo_loader);
1751         if (session->quality_manager)
1752             IMFQualityManager_Release(session->quality_manager);
1753         DeleteCriticalSection(&session->cs);
1754         heap_free(session);
1755     }
1756
1757     return refcount;
1758 }
1759
1760 static HRESULT WINAPI mfsession_GetEvent(IMFMediaSession *iface, DWORD flags, IMFMediaEvent **event)
1761 {
1762     struct media_session *session = impl_from_IMFMediaSession(iface);
1763
1764     TRACE("%p, %#x, %p.\n", iface, flags, event);
1765
1766     return IMFMediaEventQueue_GetEvent(session->event_queue, flags, event);
1767 }
1768
1769 static HRESULT WINAPI mfsession_BeginGetEvent(IMFMediaSession *iface, IMFAsyncCallback *callback, IUnknown *state)
1770 {
1771     struct media_session *session = impl_from_IMFMediaSession(iface);
1772
1773     TRACE("%p, %p, %p.\n", iface, callback, state);
1774
1775     return IMFMediaEventQueue_BeginGetEvent(session->event_queue, callback, state);
1776 }
1777
1778 static HRESULT WINAPI mfsession_EndGetEvent(IMFMediaSession *iface, IMFAsyncResult *result, IMFMediaEvent **event)
1779 {
1780     struct media_session *session = impl_from_IMFMediaSession(iface);
1781
1782     TRACE("%p, %p, %p.\n", iface, result, event);
1783
1784     return IMFMediaEventQueue_EndGetEvent(session->event_queue, result, event);
1785 }
1786
1787 static HRESULT WINAPI mfsession_QueueEvent(IMFMediaSession *iface, MediaEventType event_type, REFGUID ext_type,
1788         HRESULT hr, const PROPVARIANT *value)
1789 {
1790     struct media_session *session = impl_from_IMFMediaSession(iface);
1791
1792     TRACE("%p, %d, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value);
1793
1794     return IMFMediaEventQueue_QueueEventParamVar(session->event_queue, event_type, ext_type, hr, value);
1795 }
1796
1797 static HRESULT WINAPI mfsession_SetTopology(IMFMediaSession *iface, DWORD flags, IMFTopology *topology)
1798 {
1799     struct media_session *session = impl_from_IMFMediaSession(iface);
1800     struct session_op *op;
1801     WORD node_count = 0;
1802     HRESULT hr;
1803
1804     TRACE("%p, %#x, %p.\n", iface, flags, topology);
1805
1806     if (topology)
1807     {
1808         if (FAILED(IMFTopology_GetNodeCount(topology, &node_count)) || node_count == 0)
1809             return E_INVALIDARG;
1810     }
1811
1812     if (FAILED(hr = create_session_op(SESSION_CMD_SET_TOPOLOGY, &op)))
1813         return hr;
1814
1815     op->u.set_topology.flags = flags;
1816     op->u.set_topology.topology = topology;
1817     if (op->u.set_topology.topology)
1818         IMFTopology_AddRef(op->u.set_topology.topology);
1819
1820     hr = session_submit_command(session, op);
1821     IUnknown_Release(&op->IUnknown_iface);
1822
1823     return hr;
1824 }
1825
1826 static HRESULT WINAPI mfsession_ClearTopologies(IMFMediaSession *iface)
1827 {
1828     struct media_session *session = impl_from_IMFMediaSession(iface);
1829
1830     TRACE("%p.\n", iface);
1831
1832     return session_submit_simple_command(session, SESSION_CMD_CLEAR_TOPOLOGIES);
1833 }
1834
1835 static HRESULT WINAPI mfsession_Start(IMFMediaSession *iface, const GUID *format, const PROPVARIANT *start_position)
1836 {
1837     struct media_session *session = impl_from_IMFMediaSession(iface);
1838     struct session_op *op;
1839     HRESULT hr;
1840
1841     TRACE("%p, %s, %p.\n", iface, debugstr_guid(format), start_position);
1842
1843     if (!start_position)
1844         return E_POINTER;
1845
1846     if (FAILED(hr = create_session_op(SESSION_CMD_START, &op)))
1847         return hr;
1848
1849     op->u.start.time_format = format ? *format : GUID_NULL;
1850     hr = PropVariantCopy(&op->u.start.start_position, start_position);
1851
1852     if (SUCCEEDED(hr))
1853         hr = session_submit_command(session, op);
1854
1855     IUnknown_Release(&op->IUnknown_iface);
1856     return hr;
1857 }
1858
1859 static HRESULT WINAPI mfsession_Pause(IMFMediaSession *iface)
1860 {
1861     struct media_session *session = impl_from_IMFMediaSession(iface);
1862
1863     TRACE("%p.\n", iface);
1864
1865     return session_submit_simple_command(session, SESSION_CMD_PAUSE);
1866 }
1867
1868 static HRESULT WINAPI mfsession_Stop(IMFMediaSession *iface)
1869 {
1870     struct media_session *session = impl_from_IMFMediaSession(iface);
1871
1872     TRACE("%p.\n", iface);
1873
1874     return session_submit_simple_command(session, SESSION_CMD_STOP);
1875 }
1876
1877 static HRESULT WINAPI mfsession_Close(IMFMediaSession *iface)
1878 {
1879     struct media_session *session = impl_from_IMFMediaSession(iface);
1880
1881     TRACE("%p.\n", iface);
1882
1883     return session_submit_simple_command(session, SESSION_CMD_CLOSE);
1884 }
1885
1886 static HRESULT WINAPI mfsession_Shutdown(IMFMediaSession *iface)
1887 {
1888     struct media_session *session = impl_from_IMFMediaSession(iface);
1889     HRESULT hr = S_OK;
1890
1891     TRACE("%p.\n", iface);
1892
1893     EnterCriticalSection(&session->cs);
1894     if (SUCCEEDED(hr = session_is_shut_down(session)))
1895     {
1896         session->state = SESSION_STATE_SHUT_DOWN;
1897         IMFMediaEventQueue_Shutdown(session->event_queue);
1898         if (session->quality_manager)
1899             IMFQualityManager_Shutdown(session->quality_manager);
1900         MFShutdownObject((IUnknown *)session->clock);
1901         IMFPresentationClock_Release(session->clock);
1902         session->clock = NULL;
1903         session_clear_presentation(session);
1904         session_clear_command_list(session);
1905     }
1906     LeaveCriticalSection(&session->cs);
1907
1908     return hr;
1909 }
1910
1911 static HRESULT WINAPI mfsession_GetClock(IMFMediaSession *iface, IMFClock **clock)
1912 {
1913     struct media_session *session = impl_from_IMFMediaSession(iface);
1914     HRESULT hr;
1915
1916     TRACE("%p, %p.\n", iface, clock);
1917
1918     EnterCriticalSection(&session->cs);
1919     if (SUCCEEDED(hr = session_is_shut_down(session)))
1920     {
1921         *clock = (IMFClock *)session->clock;
1922         IMFClock_AddRef(*clock);
1923     }
1924     LeaveCriticalSection(&session->cs);
1925
1926     return hr;
1927 }
1928
1929 static HRESULT WINAPI mfsession_GetSessionCapabilities(IMFMediaSession *iface, DWORD *caps)
1930 {
1931     struct media_session *session = impl_from_IMFMediaSession(iface);
1932     HRESULT hr = S_OK;
1933
1934     TRACE("%p, %p.\n", iface, caps);
1935
1936     if (!caps)
1937         return E_POINTER;
1938
1939     EnterCriticalSection(&session->cs);
1940     if (SUCCEEDED(hr = session_is_shut_down(session)))
1941         *caps = session->caps;
1942     LeaveCriticalSection(&session->cs);
1943
1944     return hr;
1945 }
1946
1947 static HRESULT WINAPI mfsession_GetFullTopology(IMFMediaSession *iface, DWORD flags, TOPOID id, IMFTopology **topology)
1948 {
1949     struct media_session *session = impl_from_IMFMediaSession(iface);
1950     struct queued_topology *queued;
1951     TOPOID topo_id;
1952     HRESULT hr;
1953
1954     TRACE("%p, %#x, %s, %p.\n", iface, flags, wine_dbgstr_longlong(id), topology);
1955
1956     *topology = NULL;
1957
1958     EnterCriticalSection(&session->cs);
1959
1960     if (SUCCEEDED(hr = session_is_shut_down(session)))
1961     {
1962         if (flags & MFSESSION_GETFULLTOPOLOGY_CURRENT)
1963         {
1964             if (session->presentation.topo_status != MF_TOPOSTATUS_INVALID)
1965                 *topology = session->presentation.current_topology;
1966             else
1967                 hr = MF_E_INVALIDREQUEST;
1968         }
1969         else
1970         {
1971             LIST_FOR_EACH_ENTRY(queued, &session->topologies, struct queued_topology, entry)
1972             {
1973                 if (SUCCEEDED(IMFTopology_GetTopologyID(queued->topology, &topo_id)) && topo_id == id)
1974                 {
1975                     *topology = queued->topology;
1976                     break;
1977                 }
1978             }
1979         }
1980
1981         if (*topology)
1982             IMFTopology_AddRef(*topology);
1983     }
1984
1985     LeaveCriticalSection(&session->cs);
1986
1987     return hr;
1988 }
1989
1990 static const IMFMediaSessionVtbl mfmediasessionvtbl =
1991 {
1992     mfsession_QueryInterface,
1993     mfsession_AddRef,
1994     mfsession_Release,
1995     mfsession_GetEvent,
1996     mfsession_BeginGetEvent,
1997     mfsession_EndGetEvent,
1998     mfsession_QueueEvent,
1999     mfsession_SetTopology,
2000     mfsession_ClearTopologies,
2001     mfsession_Start,
2002     mfsession_Pause,
2003     mfsession_Stop,
2004     mfsession_Close,
2005     mfsession_Shutdown,
2006     mfsession_GetClock,
2007     mfsession_GetSessionCapabilities,
2008     mfsession_GetFullTopology,
2009 };
2010
2011 static HRESULT WINAPI session_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
2012 {
2013     struct media_session *session = impl_from_IMFGetService(iface);
2014     return IMFMediaSession_QueryInterface(&session->IMFMediaSession_iface, riid, obj);
2015 }
2016
2017 static ULONG WINAPI session_get_service_AddRef(IMFGetService *iface)
2018 {
2019     struct media_session *session = impl_from_IMFGetService(iface);
2020     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
2021 }
2022
2023 static ULONG WINAPI session_get_service_Release(IMFGetService *iface)
2024 {
2025     struct media_session *session = impl_from_IMFGetService(iface);
2026     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
2027 }
2028
2029 static HRESULT session_get_video_render_service(struct media_session *session, REFGUID service,
2030         REFIID riid, void **obj)
2031 {
2032     IMFStreamSink *stream_sink;
2033     IMFTopologyNode *node;
2034     IMFCollection *nodes;
2035     IMFMediaSink *sink;
2036     unsigned int i = 0;
2037     IUnknown *vr;
2038     HRESULT hr = E_FAIL;
2039
2040     /* Use first sink to support IMFVideoRenderer. */
2041     if (session->presentation.current_topology)
2042     {
2043         if (SUCCEEDED(IMFTopology_GetOutputNodeCollection(session->presentation.current_topology,
2044                 &nodes)))
2045         {
2046             while (IMFCollection_GetElement(nodes, i++, (IUnknown **)&node) == S_OK)
2047             {
2048                 if (SUCCEEDED(topology_node_get_object(node, &IID_IMFStreamSink, (void **)&stream_sink)))
2049                 {
2050                     if (SUCCEEDED(IMFStreamSink_GetMediaSink(stream_sink, &sink)))
2051                     {
2052                         if (SUCCEEDED(IMFMediaSink_QueryInterface(sink, &IID_IMFVideoRenderer, (void **)&vr)))
2053                         {
2054                             if (FAILED(hr = MFGetService(vr, service, riid, obj)))
2055                                 WARN("Failed to get service from video renderer %#x.\n", hr);
2056                             IUnknown_Release(vr);
2057                         }
2058                     }
2059                     IMFStreamSink_Release(stream_sink);
2060                 }
2061
2062                 IMFTopologyNode_Release(node);
2063
2064                 if (*obj)
2065                     break;
2066             }
2067
2068             IMFCollection_Release(nodes);
2069         }
2070     }
2071
2072     return hr;
2073 }
2074
2075 static HRESULT WINAPI session_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
2076 {
2077     struct media_session *session = impl_from_IMFGetService(iface);
2078     HRESULT hr = S_OK;
2079
2080     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
2081
2082     *obj = NULL;
2083
2084     EnterCriticalSection(&session->cs);
2085     if (FAILED(hr = session_is_shut_down(session)))
2086     {
2087     }
2088     else if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE))
2089     {
2090         if (IsEqualIID(riid, &IID_IMFRateSupport))
2091         {
2092             *obj = &session->IMFRateSupport_iface;
2093         }
2094         else if (IsEqualIID(riid, &IID_IMFRateControl))
2095         {
2096             *obj = &session->IMFRateControl_iface;
2097         }
2098         else
2099             hr = E_NOINTERFACE;
2100
2101         if (*obj)
2102             IUnknown_AddRef((IUnknown *)*obj);
2103     }
2104     else if (IsEqualGUID(service, &MF_LOCAL_MFT_REGISTRATION_SERVICE))
2105     {
2106         hr = IMFLocalMFTRegistration_QueryInterface(&local_mft_registration, riid, obj);
2107     }
2108     else if (IsEqualGUID(service, &MF_TOPONODE_ATTRIBUTE_EDITOR_SERVICE))
2109     {
2110         *obj = &session->IMFTopologyNodeAttributeEditor_iface;
2111         IUnknown_AddRef((IUnknown *)*obj);
2112     }
2113     else if (IsEqualGUID(service, &MR_VIDEO_RENDER_SERVICE))
2114     {
2115         hr = session_get_video_render_service(session, service, riid, obj);
2116     }
2117     else
2118         FIXME("Unsupported service %s.\n", debugstr_guid(service));
2119
2120     LeaveCriticalSection(&session->cs);
2121
2122     return hr;
2123 }
2124
2125 static const IMFGetServiceVtbl session_get_service_vtbl =
2126 {
2127     session_get_service_QueryInterface,
2128     session_get_service_AddRef,
2129     session_get_service_Release,
2130     session_get_service_GetService,
2131 };
2132
2133 static HRESULT WINAPI session_commands_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
2134 {
2135     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
2136             IsEqualIID(riid, &IID_IUnknown))
2137     {
2138         *obj = iface;
2139         IMFAsyncCallback_AddRef(iface);
2140         return S_OK;
2141     }
2142
2143     WARN("Unsupported %s.\n", debugstr_guid(riid));
2144     *obj = NULL;
2145     return E_NOINTERFACE;
2146 }
2147
2148 static ULONG WINAPI session_commands_callback_AddRef(IMFAsyncCallback *iface)
2149 {
2150     struct media_session *session = impl_from_commands_callback_IMFAsyncCallback(iface);
2151     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
2152 }
2153
2154 static ULONG WINAPI session_commands_callback_Release(IMFAsyncCallback *iface)
2155 {
2156     struct media_session *session = impl_from_commands_callback_IMFAsyncCallback(iface);
2157     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
2158 }
2159
2160 static HRESULT WINAPI session_commands_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
2161 {
2162     return E_NOTIMPL;
2163 }
2164
2165 static HRESULT WINAPI session_commands_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
2166 {
2167     struct session_op *op = impl_op_from_IUnknown(IMFAsyncResult_GetStateNoAddRef(result));
2168     struct media_session *session = impl_from_commands_callback_IMFAsyncCallback(iface);
2169     struct topo_node *topo_node;
2170     IMFTopologyNode *upstream_node;
2171     unsigned int upstream_output;
2172
2173     EnterCriticalSection(&session->cs);
2174
2175     switch (op->command)
2176     {
2177         case SESSION_CMD_CLEAR_TOPOLOGIES:
2178             session_clear_topologies(session);
2179             IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionTopologiesCleared, &GUID_NULL,
2180                     S_OK, NULL);
2181             session_command_complete(session);
2182             break;
2183         case SESSION_CMD_SET_TOPOLOGY:
2184             session_set_topology(session, op->u.set_topology.flags, op->u.set_topology.topology);
2185             session_command_complete(session);
2186             break;
2187         case SESSION_CMD_START:
2188             session_start(session, &op->u.start.time_format, &op->u.start.start_position);
2189             break;
2190         case SESSION_CMD_PAUSE:
2191             session_pause(session);
2192             break;
2193         case SESSION_CMD_STOP:
2194             session_stop(session);
2195             break;
2196         case SESSION_CMD_CLOSE:
2197             session_close(session);
2198             break;
2199         case SESSION_CMD_QM_NOTIFY_TOPOLOGY:
2200             IMFQualityManager_NotifyTopology(session->quality_manager, op->u.notify_topology.topology);
2201             session_command_complete(session);
2202             break;
2203         case SESSION_CMD_SA_READY:
2204             topo_node = session_get_node_by_id(session, op->u.sa_ready.node_id);
2205
2206             if (topo_node->u.sink.requests)
2207             {
2208                 if (SUCCEEDED(IMFTopologyNode_GetInput(topo_node->node, 0, &upstream_node, &upstream_output)))
2209                 {
2210                     session_request_sample_from_node(session, upstream_node, upstream_output);
2211                     IMFTopologyNode_Release(upstream_node);
2212                 }
2213             }
2214             break;
2215         default:
2216             ;
2217     }
2218
2219     LeaveCriticalSection(&session->cs);
2220
2221     return S_OK;
2222 }
2223
2224 static const IMFAsyncCallbackVtbl session_commands_callback_vtbl =
2225 {
2226     session_commands_callback_QueryInterface,
2227     session_commands_callback_AddRef,
2228     session_commands_callback_Release,
2229     session_commands_callback_GetParameters,
2230     session_commands_callback_Invoke,
2231 };
2232
2233 static HRESULT WINAPI session_events_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
2234 {
2235     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
2236             IsEqualIID(riid, &IID_IUnknown))
2237     {
2238         *obj = iface;
2239         IMFAsyncCallback_AddRef(iface);
2240         return S_OK;
2241     }
2242
2243     WARN("Unsupported %s.\n", debugstr_guid(riid));
2244     *obj = NULL;
2245     return E_NOINTERFACE;
2246 }
2247
2248 static ULONG WINAPI session_events_callback_AddRef(IMFAsyncCallback *iface)
2249 {
2250     struct media_session *session = impl_from_events_callback_IMFAsyncCallback(iface);
2251     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
2252 }
2253
2254 static ULONG WINAPI session_events_callback_Release(IMFAsyncCallback *iface)
2255 {
2256     struct media_session *session = impl_from_events_callback_IMFAsyncCallback(iface);
2257     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
2258 }
2259
2260 static HRESULT WINAPI session_events_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
2261 {
2262     return E_NOTIMPL;
2263 }
2264
2265 static HRESULT session_add_media_stream(struct media_session *session, IMFMediaSource *source, IMFMediaStream *stream)
2266 {
2267     struct topo_node *node;
2268     IMFStreamDescriptor *sd;
2269     DWORD stream_id = 0;
2270     HRESULT hr;
2271
2272     if (FAILED(hr = IMFMediaStream_GetStreamDescriptor(stream, &sd)))
2273         return hr;
2274
2275     hr = IMFStreamDescriptor_GetStreamIdentifier(sd, &stream_id);
2276     IMFStreamDescriptor_Release(sd);
2277     if (FAILED(hr))
2278         return hr;
2279
2280     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2281     {
2282         if (node->type == MF_TOPOLOGY_SOURCESTREAM_NODE && node->u.source.source == source
2283                 && node->u.source.stream_id == stream_id)
2284         {
2285             if (node->object.source_stream)
2286             {
2287                 WARN("Node already has stream set.\n");
2288                 return S_FALSE;
2289             }
2290
2291             node->object.source_stream = stream;
2292             IMFMediaStream_AddRef(node->object.source_stream);
2293             break;
2294         }
2295     }
2296
2297     return S_OK;
2298 }
2299
2300 static BOOL session_is_source_nodes_state(struct media_session *session, enum object_state state)
2301 {
2302     struct media_source *source;
2303     struct topo_node *node;
2304
2305     LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
2306     {
2307         if (source->state != state)
2308             return FALSE;
2309     }
2310
2311     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2312     {
2313         if (node->type == MF_TOPOLOGY_SOURCESTREAM_NODE && node->state != state)
2314             return FALSE;
2315     }
2316
2317     return TRUE;
2318 }
2319
2320 static BOOL session_is_output_nodes_state(struct media_session *session, enum object_state state)
2321 {
2322     struct topo_node *node;
2323
2324     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2325     {
2326         if (node->type == MF_TOPOLOGY_OUTPUT_NODE && node->state != state)
2327             return FALSE;
2328     }
2329
2330     return TRUE;
2331 }
2332
2333 static enum object_state session_get_object_state_for_event(MediaEventType event)
2334 {
2335     switch (event)
2336     {
2337         case MESourceStarted:
2338         case MEStreamStarted:
2339         case MEStreamSinkStarted:
2340             return OBJ_STATE_STARTED;
2341         case MESourcePaused:
2342         case MEStreamPaused:
2343         case MEStreamSinkPaused:
2344             return OBJ_STATE_PAUSED;
2345         case MESourceStopped:
2346         case MEStreamStopped:
2347         case MEStreamSinkStopped:
2348             return OBJ_STATE_STOPPED;
2349         case MEStreamSinkPrerolled:
2350             return OBJ_STATE_PREROLLED;
2351         default:
2352             return OBJ_STATE_INVALID;
2353     }
2354 }
2355
2356 static void session_set_consumed_clock(IUnknown *object, IMFPresentationClock *clock)
2357 {
2358     IMFClockConsumer *consumer;
2359
2360     if (SUCCEEDED(IUnknown_QueryInterface(object, &IID_IMFClockConsumer, (void **)&consumer)))
2361     {
2362         IMFClockConsumer_SetPresentationClock(consumer, clock);
2363         IMFClockConsumer_Release(consumer);
2364     }
2365 }
2366
2367 static void session_set_presentation_clock(struct media_session *session)
2368 {
2369     IMFPresentationTimeSource *time_source = NULL;
2370     struct media_source *source;
2371     struct media_sink *sink;
2372     struct topo_node *node;
2373     HRESULT hr;
2374
2375     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2376     {
2377         if (node->type == MF_TOPOLOGY_TRANSFORM_NODE)
2378             IMFTransform_ProcessMessage(node->object.transform, MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0);
2379     }
2380
2381     if (!(session->presentation.flags & SESSION_FLAG_PRESENTATION_CLOCK_SET))
2382     {
2383         /* Attempt to get time source from the sinks. */
2384         LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry)
2385         {
2386             if (SUCCEEDED(IMFMediaSink_QueryInterface(sink->sink, &IID_IMFPresentationTimeSource,
2387                     (void **)&time_source)))
2388                  break;
2389         }
2390
2391         if (time_source)
2392         {
2393             hr = IMFPresentationClock_SetTimeSource(session->clock, time_source);
2394             IMFPresentationTimeSource_Release(time_source);
2395         }
2396         else
2397             hr = IMFPresentationClock_SetTimeSource(session->clock, session->system_time_source);
2398
2399         if (FAILED(hr))
2400             WARN("Failed to set time source, hr %#x.\n", hr);
2401
2402         LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2403         {
2404             if (node->type != MF_TOPOLOGY_OUTPUT_NODE)
2405                 continue;
2406
2407             if (FAILED(hr = IMFStreamSink_BeginGetEvent(node->object.sink_stream, &session->events_callback,
2408                     node->object.object)))
2409             {
2410                 WARN("Failed to subscribe to stream sink events, hr %#x.\n", hr);
2411             }
2412         }
2413
2414         /* Set clock for all topology nodes. */
2415         LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
2416         {
2417             session_set_consumed_clock((IUnknown *)source->source, session->clock);
2418         }
2419
2420         LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry)
2421         {
2422             if (sink->event_generator && FAILED(hr = IMFMediaEventGenerator_BeginGetEvent(sink->event_generator,
2423                     &session->events_callback, (IUnknown *)sink->event_generator)))
2424             {
2425                 WARN("Failed to subscribe to sink events, hr %#x.\n", hr);
2426             }
2427
2428             if (FAILED(hr = IMFMediaSink_SetPresentationClock(sink->sink, session->clock)))
2429                 WARN("Failed to set presentation clock for the sink, hr %#x.\n", hr);
2430         }
2431
2432         LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2433         {
2434             if (node->type != MF_TOPOLOGY_TRANSFORM_NODE)
2435                 continue;
2436
2437             session_set_consumed_clock(node->object.object, session->clock);
2438         }
2439
2440         session->presentation.flags |= SESSION_FLAG_PRESENTATION_CLOCK_SET;
2441     }
2442 }
2443
2444 static HRESULT session_start_clock(struct media_session *session)
2445 {
2446     LONGLONG start_offset = 0;
2447     HRESULT hr;
2448
2449     if (IsEqualGUID(&session->presentation.time_format, &GUID_NULL))
2450     {
2451         if (session->presentation.start_position.vt == VT_EMPTY)
2452             start_offset = PRESENTATION_CURRENT_POSITION;
2453         else if (session->presentation.start_position.vt == VT_I8)
2454             start_offset = session->presentation.start_position.hVal.QuadPart;
2455         else
2456             FIXME("Unhandled position type %d.\n", session->presentation.start_position.vt);
2457     }
2458     else
2459         FIXME("Unhandled time format %s.\n", debugstr_guid(&session->presentation.time_format));
2460
2461     if (FAILED(hr = IMFPresentationClock_Start(session->clock, start_offset)))
2462         WARN("Failed to start session clock, hr %#x.\n", hr);
2463
2464     return hr;
2465 }
2466
2467 static struct topo_node *session_get_node_object(struct media_session *session, IUnknown *object,
2468         MF_TOPOLOGY_TYPE node_type)
2469 {
2470     struct topo_node *node = NULL;
2471
2472     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2473     {
2474         if (node->type == node_type && object == node->object.object)
2475             break;
2476     }
2477
2478     return node;
2479 }
2480
2481 static BOOL session_set_node_object_state(struct media_session *session, IUnknown *object,
2482         MF_TOPOLOGY_TYPE node_type, enum object_state state)
2483 {
2484     struct topo_node *node;
2485     BOOL changed = FALSE;
2486
2487     if ((node = session_get_node_object(session, object, node_type)))
2488     {
2489         changed = node->state != state;
2490         node->state = state;
2491     }
2492
2493     return changed;
2494 }
2495
2496 static void session_set_source_object_state(struct media_session *session, IUnknown *object,
2497         MediaEventType event_type)
2498 {
2499     IMFStreamSink *stream_sink;
2500     struct media_source *src;
2501     struct media_sink *sink;
2502     enum object_state state;
2503     struct topo_node *node;
2504     unsigned int i, count;
2505     BOOL changed = FALSE;
2506     HRESULT hr;
2507
2508     if ((state = session_get_object_state_for_event(event_type)) == OBJ_STATE_INVALID)
2509         return;
2510
2511     switch (event_type)
2512     {
2513         case MESourceStarted:
2514         case MESourcePaused:
2515         case MESourceStopped:
2516
2517             LIST_FOR_EACH_ENTRY(src, &session->presentation.sources, struct media_source, entry)
2518             {
2519                 if (object == (IUnknown *)src->source)
2520                 {
2521                     changed = src->state != state;
2522                     src->state = state;
2523                     break;
2524                 }
2525             }
2526             break;
2527         case MEStreamStarted:
2528         case MEStreamPaused:
2529         case MEStreamStopped:
2530
2531             changed = session_set_node_object_state(session, object, MF_TOPOLOGY_SOURCESTREAM_NODE, state);
2532         default:
2533             ;
2534     }
2535
2536     if (!changed)
2537         return;
2538
2539     switch (session->state)
2540     {
2541         case SESSION_STATE_STARTING_SOURCES:
2542             if (!session_is_source_nodes_state(session, OBJ_STATE_STARTED))
2543                 break;
2544
2545             session_set_topo_status(session, S_OK, MF_TOPOSTATUS_STARTED_SOURCE);
2546
2547             session_set_presentation_clock(session);
2548
2549             if (session->presentation.flags & SESSION_FLAG_NEEDS_PREROLL)
2550             {
2551                 MFTIME preroll_time = 0;
2552
2553                 if (session->presentation.start_position.vt == VT_I8)
2554                     preroll_time = session->presentation.start_position.hVal.QuadPart;
2555
2556                 /* Mark stream sinks without prerolling support as PREROLLED to keep state test logic generic. */
2557                 LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry)
2558                 {
2559                     if (sink->preroll)
2560                     {
2561                         /* FIXME: abort and enter error state on failure. */
2562                         if (FAILED(hr = IMFMediaSinkPreroll_NotifyPreroll(sink->preroll, preroll_time)))
2563                             WARN("Preroll notification failed, hr %#x.\n", hr);
2564                     }
2565                     else
2566                     {
2567                         if (SUCCEEDED(IMFMediaSink_GetStreamSinkCount(sink->sink, &count)))
2568                         {
2569                             for (i = 0; i < count; ++i)
2570                             {
2571                                 if (SUCCEEDED(IMFMediaSink_GetStreamSinkByIndex(sink->sink, i, &stream_sink)))
2572                                 {
2573                                     session_set_node_object_state(session, (IUnknown *)stream_sink, MF_TOPOLOGY_OUTPUT_NODE,
2574                                             OBJ_STATE_PREROLLED);
2575                                     IMFStreamSink_Release(stream_sink);
2576                                 }
2577                             }
2578                         }
2579                     }
2580                 }
2581                 session->state = SESSION_STATE_PREROLLING_SINKS;
2582             }
2583             else if (SUCCEEDED(session_start_clock(session)))
2584                 session->state = SESSION_STATE_STARTING_SINKS;
2585
2586             break;
2587         case SESSION_STATE_PAUSING_SOURCES:
2588             if (!session_is_source_nodes_state(session, OBJ_STATE_PAUSED))
2589                 break;
2590
2591             session_set_paused(session, S_OK);
2592             break;
2593         case SESSION_STATE_STOPPING_SOURCES:
2594             if (!session_is_source_nodes_state(session, OBJ_STATE_STOPPED))
2595                 break;
2596
2597             LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2598             {
2599                 switch (node->type)
2600                 {
2601                     case MF_TOPOLOGY_OUTPUT_NODE:
2602                         IMFStreamSink_Flush(node->object.sink_stream);
2603                         break;
2604                     case MF_TOPOLOGY_TRANSFORM_NODE:
2605                         IMFTransform_ProcessMessage(node->object.transform, MFT_MESSAGE_COMMAND_FLUSH, 0);
2606                         break;
2607                     default:
2608                         ;
2609                 }
2610             }
2611
2612             session_set_caps(session, session->caps & ~MFSESSIONCAP_PAUSE);
2613
2614             if (session->presentation.flags & SESSION_FLAG_FINALIZE_SINKS)
2615                 session_finalize_sinks(session);
2616             else
2617                 session_set_stopped(session, S_OK);
2618
2619             break;
2620         default:
2621             ;
2622     }
2623 }
2624
2625 static void session_set_sink_stream_state(struct media_session *session, IMFStreamSink *stream,
2626         MediaEventType event_type)
2627 {
2628     struct media_source *source;
2629     enum object_state state;
2630     HRESULT hr = S_OK;
2631     BOOL changed;
2632
2633     if ((state = session_get_object_state_for_event(event_type)) == OBJ_STATE_INVALID)
2634         return;
2635
2636     if (!(changed = session_set_node_object_state(session, (IUnknown *)stream, MF_TOPOLOGY_OUTPUT_NODE, state)))
2637         return;
2638
2639     switch (session->state)
2640     {
2641         case SESSION_STATE_PREROLLING_SINKS:
2642             if (!session_is_output_nodes_state(session, OBJ_STATE_PREROLLED))
2643                 break;
2644
2645             if (SUCCEEDED(session_start_clock(session)))
2646                 session->state = SESSION_STATE_STARTING_SINKS;
2647             break;
2648         case SESSION_STATE_STARTING_SINKS:
2649             if (!session_is_output_nodes_state(session, OBJ_STATE_STARTED))
2650                 break;
2651
2652             session_set_started(session);
2653             break;
2654         case SESSION_STATE_PAUSING_SINKS:
2655             if (!session_is_output_nodes_state(session, OBJ_STATE_PAUSED))
2656                 break;
2657
2658             session->state = SESSION_STATE_PAUSING_SOURCES;
2659
2660             LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
2661             {
2662                 if (FAILED(hr = IMFMediaSource_Pause(source->source)))
2663                     break;
2664             }
2665
2666             if (FAILED(hr))
2667                 session_set_paused(session, hr);
2668
2669             break;
2670         case SESSION_STATE_STOPPING_SINKS:
2671             if (!session_is_output_nodes_state(session, OBJ_STATE_STOPPED))
2672                 break;
2673
2674             session->state = SESSION_STATE_STOPPING_SOURCES;
2675
2676             LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
2677             {
2678                 if (session->presentation.flags & SESSION_FLAG_END_OF_PRESENTATION)
2679                     IMFMediaSource_Stop(source->source);
2680                 else if (FAILED(hr = IMFMediaSource_Stop(source->source)))
2681                     break;
2682             }
2683
2684             if (session->presentation.flags & SESSION_FLAG_END_OF_PRESENTATION || FAILED(hr))
2685                 session_set_stopped(session, hr);
2686
2687             break;
2688         default:
2689             ;
2690     }
2691 }
2692
2693 static struct sample *transform_create_sample(IMFSample *sample)
2694 {
2695     struct sample *sample_entry = heap_alloc_zero(sizeof(*sample_entry));
2696
2697     if (sample_entry)
2698     {
2699         sample_entry->sample = sample;
2700         if (sample_entry->sample)
2701             IMFSample_AddRef(sample_entry->sample);
2702     }
2703
2704     return sample_entry;
2705 }
2706
2707 static HRESULT transform_get_external_output_sample(const struct media_session *session, struct topo_node *transform,
2708         unsigned int output_index, const MFT_OUTPUT_STREAM_INFO *stream_info, IMFSample **sample)
2709 {
2710     unsigned int buffer_size, downstream_input;
2711     IMFTopologyNode *downstream_node;
2712     IMFMediaBuffer *buffer = NULL;
2713     struct topo_node *topo_node;
2714     TOPOID node_id;
2715     HRESULT hr;
2716
2717     if (FAILED(IMFTopologyNode_GetOutput(transform->node, output_index, &downstream_node, &downstream_input)))
2718     {
2719         WARN("Failed to get connected node for output %u.\n", output_index);
2720         return MF_E_UNEXPECTED;
2721     }
2722
2723     IMFTopologyNode_GetTopoNodeID(downstream_node, &node_id);
2724     IMFTopologyNode_Release(downstream_node);
2725
2726     topo_node = session_get_node_by_id(session, node_id);
2727
2728     if (topo_node->type == MF_TOPOLOGY_OUTPUT_NODE && topo_node->u.sink.allocator)
2729     {
2730         hr = IMFVideoSampleAllocator_AllocateSample(topo_node->u.sink.allocator, sample);
2731     }
2732     else
2733     {
2734         buffer_size = max(stream_info->cbSize, transform->u.transform.outputs[output_index].min_buffer_size);
2735
2736         hr = MFCreateAlignedMemoryBuffer(buffer_size, stream_info->cbAlignment, &buffer);
2737         if (SUCCEEDED(hr))
2738             hr = MFCreateSample(sample);
2739
2740         if (SUCCEEDED(hr))
2741             hr = IMFSample_AddBuffer(*sample, buffer);
2742
2743         if (buffer)
2744             IMFMediaBuffer_Release(buffer);
2745     }
2746
2747     return hr;
2748 }
2749
2750 static HRESULT transform_node_pull_samples(const struct media_session *session, struct topo_node *node)
2751 {
2752     MFT_OUTPUT_STREAM_INFO stream_info;
2753     MFT_OUTPUT_DATA_BUFFER *buffers;
2754     struct sample *queued_sample;
2755     DWORD status = 0;
2756     unsigned int i;
2757     HRESULT hr = E_UNEXPECTED;
2758
2759     if (!(buffers = heap_calloc(node->u.transform.output_count, sizeof(*buffers))))
2760         return E_OUTOFMEMORY;
2761
2762     for (i = 0; i < node->u.transform.output_count; ++i)
2763     {
2764         buffers[i].dwStreamID = transform_node_get_stream_id(node, TRUE, i);
2765         buffers[i].pSample = NULL;
2766         buffers[i].dwStatus = 0;
2767         buffers[i].pEvents = NULL;
2768
2769         memset(&stream_info, 0, sizeof(stream_info));
2770         if (FAILED(hr = IMFTransform_GetOutputStreamInfo(node->object.transform, buffers[i].dwStreamID, &stream_info)))
2771             break;
2772
2773         if (!(stream_info.dwFlags & (MFT_OUTPUT_STREAM_PROVIDES_SAMPLES | MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES)))
2774         {
2775             if (FAILED(hr = transform_get_external_output_sample(session, node, i, &stream_info, &buffers[i].pSample)))
2776                 break;
2777         }
2778     }
2779
2780     if (SUCCEEDED(hr))
2781         hr = IMFTransform_ProcessOutput(node->object.transform, 0, node->u.transform.output_count, buffers, &status);
2782
2783     /* Collect returned samples for all streams. */
2784     for (i = 0; i < node->u.transform.output_count; ++i)
2785     {
2786         if (buffers[i].pEvents)
2787             IMFCollection_Release(buffers[i].pEvents);
2788
2789         if (SUCCEEDED(hr) && !(buffers[i].dwStatus & MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE))
2790         {
2791             if (session->quality_manager)
2792                 IMFQualityManager_NotifyProcessOutput(session->quality_manager, node->node, i, buffers[i].pSample);
2793
2794             queued_sample = transform_create_sample(buffers[i].pSample);
2795             list_add_tail(&node->u.transform.outputs[i].samples, &queued_sample->entry);
2796         }
2797
2798         if (buffers[i].pSample)
2799             IMFSample_Release(buffers[i].pSample);
2800     }
2801
2802     heap_free(buffers);
2803
2804     return hr;
2805 }
2806
2807 static void session_deliver_sample_to_node(struct media_session *session, IMFTopologyNode *node, unsigned int input,
2808         IMFSample *sample)
2809 {
2810     struct sample *sample_entry, *sample_entry2;
2811     DWORD stream_id, downstream_input;
2812     IMFTopologyNode *downstream_node;
2813     struct topo_node *topo_node;
2814     MF_TOPOLOGY_TYPE node_type;
2815     BOOL drain = FALSE;
2816     TOPOID node_id;
2817     unsigned int i;
2818     HRESULT hr;
2819
2820     if (session->quality_manager)
2821         IMFQualityManager_NotifyProcessInput(session->quality_manager, node, input, sample);
2822
2823     IMFTopologyNode_GetNodeType(node, &node_type);
2824     IMFTopologyNode_GetTopoNodeID(node, &node_id);
2825
2826     topo_node = session_get_node_by_id(session, node_id);
2827
2828     switch (node_type)
2829     {
2830         case MF_TOPOLOGY_OUTPUT_NODE:
2831             if (sample)
2832             {
2833                 if (topo_node->u.sink.requests)
2834                 {
2835                     if (FAILED(hr = IMFStreamSink_ProcessSample(topo_node->object.sink_stream, sample)))
2836                         WARN("Stream sink failed to process sample, hr %#x.\n", hr);
2837                     topo_node->u.sink.requests--;
2838                 }
2839             }
2840             else if (FAILED(hr = IMFStreamSink_PlaceMarker(topo_node->object.sink_stream, MFSTREAMSINK_MARKER_ENDOFSEGMENT,
2841                     NULL, NULL)))
2842             {
2843                 WARN("Failed to place sink marker, hr %#x.\n", hr);
2844             }
2845             break;
2846         case MF_TOPOLOGY_TRANSFORM_NODE:
2847
2848             transform_node_pull_samples(session, topo_node);
2849
2850             sample_entry = transform_create_sample(sample);
2851             list_add_tail(&topo_node->u.transform.inputs[input].samples, &sample_entry->entry);
2852
2853             for (i = 0; i < topo_node->u.transform.input_count; ++i)
2854             {
2855                 stream_id = transform_node_get_stream_id(topo_node, FALSE, i);
2856                 LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &topo_node->u.transform.inputs[i].samples,
2857                         struct sample, entry)
2858                 {
2859                     if (sample_entry->sample)
2860                     {
2861                         if ((hr = IMFTransform_ProcessInput(topo_node->object.transform, stream_id,
2862                                 sample_entry->sample, 0)) == MF_E_NOTACCEPTING)
2863                             break;
2864                         if (FAILED(hr))
2865                             WARN("Failed to process input for stream %u/%u, hr %#x.\n", i, stream_id, hr);
2866                         transform_release_sample(sample_entry);
2867                     }
2868                     else
2869                     {
2870                         transform_stream_drop_samples(&topo_node->u.transform.inputs[i]);
2871                         drain = TRUE;
2872                     }
2873                 }
2874             }
2875
2876             if (drain)
2877             {
2878                 if (FAILED(hr = IMFTransform_ProcessMessage(topo_node->object.transform, MFT_MESSAGE_COMMAND_DRAIN, 0)))
2879                     WARN("Drain command failed for transform, hr %#x.\n", hr);
2880             }
2881
2882             transform_node_pull_samples(session, topo_node);
2883
2884             /* Remaining unprocessed input has been discarded, now queue markers for every output. */
2885             if (drain)
2886             {
2887                 for (i = 0; i < topo_node->u.transform.output_count; ++i)
2888                 {
2889                      if ((sample_entry = transform_create_sample(NULL)))
2890                          list_add_tail(&topo_node->u.transform.outputs[i].samples, &sample_entry->entry);
2891                 }
2892             }
2893
2894             /* Push down all available output. */
2895             for (i = 0; i < topo_node->u.transform.output_count; ++i)
2896             {
2897                 if (FAILED(IMFTopologyNode_GetOutput(node, i, &downstream_node, &downstream_input)))
2898                 {
2899                     WARN("Failed to get connected node for output %u.\n", i);
2900                     continue;
2901                 }
2902
2903                 LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &topo_node->u.transform.outputs[i].samples,
2904                         struct sample, entry)
2905                 {
2906                     if (!topo_node->u.transform.outputs[i].requests)
2907                         break;
2908
2909                     session_deliver_sample_to_node(session, downstream_node, downstream_input, sample_entry->sample);
2910                     topo_node->u.transform.outputs[i].requests--;
2911
2912                     transform_release_sample(sample_entry);
2913                 }
2914
2915                 IMFTopologyNode_Release(downstream_node);
2916             }
2917
2918             break;
2919         case MF_TOPOLOGY_TEE_NODE:
2920             FIXME("Unhandled downstream node type %d.\n", node_type);
2921             break;
2922         default:
2923             ;
2924     }
2925 }
2926
2927 static HRESULT session_request_sample_from_node(struct media_session *session, IMFTopologyNode *node, DWORD output)
2928 {
2929     IMFTopologyNode *downstream_node, *upstream_node;
2930     unsigned int downstream_input, upstream_output;
2931     struct topo_node *topo_node;
2932     MF_TOPOLOGY_TYPE node_type;
2933     struct sample *sample;
2934     TOPOID node_id;
2935     HRESULT hr;
2936
2937     IMFTopologyNode_GetNodeType(node, &node_type);
2938     IMFTopologyNode_GetTopoNodeID(node, &node_id);
2939
2940     topo_node = session_get_node_by_id(session, node_id);
2941
2942     switch (node_type)
2943     {
2944         case MF_TOPOLOGY_SOURCESTREAM_NODE:
2945             if (FAILED(hr = IMFMediaStream_RequestSample(topo_node->object.source_stream, NULL)))
2946                 WARN("Sample request failed, hr %#x.\n", hr);
2947             break;
2948         case MF_TOPOLOGY_TRANSFORM_NODE:
2949
2950             if (list_empty(&topo_node->u.transform.outputs[output].samples))
2951             {
2952                 /* Forward request to upstream node. */
2953                 if (SUCCEEDED(hr = IMFTopologyNode_GetInput(node, 0 /* FIXME */, &upstream_node, &upstream_output)))
2954                 {
2955                     if (SUCCEEDED(hr = session_request_sample_from_node(session, upstream_node, upstream_output)))
2956                         topo_node->u.transform.outputs[output].requests++;
2957                     IMFTopologyNode_Release(upstream_node);
2958                 }
2959             }
2960             else
2961             {
2962                 if (SUCCEEDED(hr = IMFTopologyNode_GetOutput(node, output, &downstream_node, &downstream_input)))
2963                 {
2964                     sample = LIST_ENTRY(list_head(&topo_node->u.transform.outputs[output].samples), struct sample, entry);
2965                     session_deliver_sample_to_node(session, downstream_node, downstream_input, sample->sample);
2966                     transform_release_sample(sample);
2967                     IMFTopologyNode_Release(downstream_node);
2968                 }
2969             }
2970
2971             break;
2972         case MF_TOPOLOGY_TEE_NODE:
2973             FIXME("Unhandled upstream node type %d.\n", node_type);
2974         default:
2975             hr = E_UNEXPECTED;
2976     }
2977
2978     return hr;
2979 }
2980
2981 static void session_request_sample(struct media_session *session, IMFStreamSink *sink_stream)
2982 {
2983     struct topo_node *sink_node = NULL, *node;
2984     IMFTopologyNode *upstream_node;
2985     DWORD upstream_output;
2986     HRESULT hr;
2987
2988     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
2989     {
2990         if (node->type == MF_TOPOLOGY_OUTPUT_NODE && node->object.sink_stream == sink_stream)
2991         {
2992             sink_node = node;
2993             break;
2994         }
2995     }
2996
2997     if (!sink_node)
2998         return;
2999
3000     if (FAILED(hr = IMFTopologyNode_GetInput(sink_node->node, 0, &upstream_node, &upstream_output)))
3001     {
3002         WARN("Failed to get upstream node connection, hr %#x.\n", hr);
3003         return;
3004     }
3005
3006     if (SUCCEEDED(session_request_sample_from_node(session, upstream_node, upstream_output)))
3007         sink_node->u.sink.requests++;
3008     IMFTopologyNode_Release(upstream_node);
3009 }
3010
3011 static void session_deliver_sample(struct media_session *session, IMFMediaStream *stream, const PROPVARIANT *value)
3012 {
3013     struct topo_node *source_node = NULL, *node;
3014     IMFTopologyNode *downstream_node;
3015     DWORD downstream_input;
3016     HRESULT hr;
3017
3018     if (value && (value->vt != VT_UNKNOWN || !value->punkVal))
3019     {
3020         WARN("Unexpected value type %d.\n", value->vt);
3021         return;
3022     }
3023
3024     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
3025     {
3026         if (node->type == MF_TOPOLOGY_SOURCESTREAM_NODE && node->object.source_stream == stream)
3027         {
3028             source_node = node;
3029             break;
3030         }
3031     }
3032
3033     if (!source_node)
3034         return;
3035
3036     if (!value)
3037         source_node->flags |= TOPO_NODE_END_OF_STREAM;
3038
3039     if (FAILED(hr = IMFTopologyNode_GetOutput(source_node->node, 0, &downstream_node, &downstream_input)))
3040     {
3041         WARN("Failed to get downstream node connection, hr %#x.\n", hr);
3042         return;
3043     }
3044
3045     session_deliver_sample_to_node(session, downstream_node, downstream_input, value ? (IMFSample *)value->punkVal : NULL);
3046     IMFTopologyNode_Release(downstream_node);
3047 }
3048
3049 static void session_sink_invalidated(struct media_session *session, IMFMediaEvent *event, IMFStreamSink *sink)
3050 {
3051     struct topo_node *node, *sink_node = NULL;
3052     HRESULT hr;
3053
3054     LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
3055     {
3056         if (node->type == MF_TOPOLOGY_OUTPUT_NODE && node->object.sink_stream == sink)
3057         {
3058             sink_node = node;
3059             break;
3060         }
3061     }
3062
3063     if (!sink_node)
3064         return;
3065
3066     if (!event)
3067     {
3068         if (FAILED(hr = MFCreateMediaEvent(MESinkInvalidated, &GUID_NULL, S_OK, NULL, &event)))
3069             WARN("Failed to create event, hr %#x.\n", hr);
3070     }
3071
3072     if (!event)
3073         return;
3074
3075     IMFMediaEvent_SetUINT64(event, &MF_EVENT_OUTPUT_NODE, sink_node->node_id);
3076     IMFMediaEventQueue_QueueEvent(session->event_queue, event);
3077
3078     session_set_topo_status(session, S_OK, MF_TOPOSTATUS_ENDED);
3079 }
3080
3081 static BOOL session_nodes_is_mask_set(struct media_session *session, MF_TOPOLOGY_TYPE node_type, unsigned int flags)
3082 {
3083     struct media_source *source;
3084     struct topo_node *node;
3085
3086     if (node_type == MF_TOPOLOGY_MAX)
3087     {
3088         LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
3089         {
3090             if ((source->flags & flags) != flags)
3091                 return FALSE;
3092         }
3093     }
3094     else
3095     {
3096         LIST_FOR_EACH_ENTRY(node, &session->presentation.nodes, struct topo_node, entry)
3097         {
3098             if (node->type == node_type && (node->flags & flags) != flags)
3099                 return FALSE;
3100         }
3101     }
3102
3103     return TRUE;
3104 }
3105
3106 static void session_raise_end_of_presentation(struct media_session *session)
3107 {
3108     if (!(session_nodes_is_mask_set(session, MF_TOPOLOGY_SOURCESTREAM_NODE, TOPO_NODE_END_OF_STREAM)))
3109         return;
3110
3111     if (!(session->presentation.flags & SESSION_FLAG_END_OF_PRESENTATION))
3112     {
3113         if (session_nodes_is_mask_set(session, MF_TOPOLOGY_MAX, SOURCE_FLAG_END_OF_PRESENTATION))
3114         {
3115             session->presentation.flags |= SESSION_FLAG_END_OF_PRESENTATION;
3116             session_push_back_command(session, SESSION_CMD_END);
3117             IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MEEndOfPresentation, &GUID_NULL, S_OK, NULL);
3118         }
3119     }
3120 }
3121
3122 static void session_handle_end_of_stream(struct media_session *session, IMFMediaStream *stream)
3123 {
3124     struct topo_node *node;
3125
3126     if (!(node = session_get_node_object(session, (IUnknown *)stream, MF_TOPOLOGY_SOURCESTREAM_NODE))
3127             || node->flags & TOPO_NODE_END_OF_STREAM)
3128     {
3129         return;
3130     }
3131
3132     session_deliver_sample(session, stream, NULL);
3133
3134     session_raise_end_of_presentation(session);
3135 }
3136
3137 static void session_handle_end_of_presentation(struct media_session *session, IMFMediaSource *object)
3138 {
3139     struct media_source *source;
3140
3141     LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
3142     {
3143         if (source->source == object)
3144         {
3145             if (!(source->flags & SOURCE_FLAG_END_OF_PRESENTATION))
3146             {
3147                 source->flags |= SOURCE_FLAG_END_OF_PRESENTATION;
3148                 session_raise_end_of_presentation(session);
3149             }
3150
3151             break;
3152         }
3153     }
3154 }
3155
3156 static void session_sink_stream_marker(struct media_session *session, IMFStreamSink *stream_sink)
3157 {
3158     struct topo_node *node;
3159
3160     if (!(node = session_get_node_object(session, (IUnknown *)stream_sink, MF_TOPOLOGY_OUTPUT_NODE))
3161             || node->flags & TOPO_NODE_END_OF_STREAM)
3162     {
3163         return;
3164     }
3165
3166     node->flags |= TOPO_NODE_END_OF_STREAM;
3167
3168     if (session->presentation.flags & SESSION_FLAG_END_OF_PRESENTATION &&
3169             session_nodes_is_mask_set(session, MF_TOPOLOGY_OUTPUT_NODE, TOPO_NODE_END_OF_STREAM))
3170     {
3171         session_set_topo_status(session, S_OK, MF_TOPOSTATUS_ENDED);
3172         session_set_caps(session, session->caps & ~MFSESSIONCAP_PAUSE);
3173         session_stop(session);
3174     }
3175 }
3176
3177 static HRESULT WINAPI session_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
3178 {
3179     struct media_session *session = impl_from_events_callback_IMFAsyncCallback(iface);
3180     IMFMediaEventGenerator *event_source;
3181     IMFMediaEvent *event = NULL;
3182     MediaEventType event_type;
3183     IUnknown *object = NULL;
3184     IMFMediaSource *source;
3185     IMFMediaStream *stream;
3186     PROPVARIANT value;
3187     HRESULT hr;
3188
3189     if (FAILED(hr = IMFAsyncResult_GetState(result, (IUnknown **)&event_source)))
3190         return hr;
3191
3192     if (FAILED(hr = IMFMediaEventGenerator_EndGetEvent(event_source, result, &event)))
3193     {
3194         WARN("Failed to get event from %p, hr %#x.\n", event_source, hr);
3195         goto failed;
3196     }
3197
3198     if (FAILED(hr = IMFMediaEvent_GetType(event, &event_type)))
3199     {
3200         WARN("Failed to get event type, hr %#x.\n", hr);
3201         goto failed;
3202     }
3203
3204     value.vt = VT_EMPTY;
3205     if (FAILED(hr = IMFMediaEvent_GetValue(event, &value)))
3206     {
3207         WARN("Failed to get event value, hr %#x.\n", hr);
3208         goto failed;
3209     }
3210
3211     switch (event_type)
3212     {
3213         case MESourceStarted:
3214         case MESourcePaused:
3215         case MESourceStopped:
3216         case MEStreamStarted:
3217         case MEStreamPaused:
3218         case MEStreamStopped:
3219
3220             EnterCriticalSection(&session->cs);
3221             session_set_source_object_state(session, (IUnknown *)event_source, event_type);
3222             LeaveCriticalSection(&session->cs);
3223
3224             break;
3225
3226         case MEBufferingStarted:
3227         case MEBufferingStopped:
3228
3229             EnterCriticalSection(&session->cs);
3230             if (session_get_media_source(session, (IMFMediaSource *)event_source))
3231             {
3232                 if (event_type == MEBufferingStarted)
3233                     IMFPresentationClock_Pause(session->clock);
3234                 else
3235                     IMFPresentationClock_Start(session->clock, PRESENTATION_CURRENT_POSITION);
3236
3237                 IMFMediaEventQueue_QueueEvent(session->event_queue, event);
3238             }
3239             LeaveCriticalSection(&session->cs);
3240             break;
3241
3242         case MEReconnectStart:
3243         case MEReconnectEnd:
3244
3245             EnterCriticalSection(&session->cs);
3246             if (session_get_media_source(session, (IMFMediaSource *)event_source))
3247                 IMFMediaEventQueue_QueueEvent(session->event_queue, event);
3248             LeaveCriticalSection(&session->cs);
3249             break;
3250
3251         case MEExtendedType:
3252         case MERendererEvent:
3253         case MEStreamSinkFormatChanged:
3254
3255             IMFMediaEventQueue_QueueEvent(session->event_queue, event);
3256             break;
3257
3258         case MENewStream:
3259             stream = (IMFMediaStream *)value.punkVal;
3260
3261             if (value.vt != VT_UNKNOWN || !stream)
3262             {
3263                 WARN("Unexpected event value.\n");
3264                 break;
3265             }
3266
3267             if (FAILED(hr = IMFMediaStream_GetMediaSource(stream, &source)))
3268                 break;
3269
3270             EnterCriticalSection(&session->cs);
3271             if (SUCCEEDED(hr = session_add_media_stream(session, source, stream)))
3272                 hr = IMFMediaStream_BeginGetEvent(stream, &session->events_callback, (IUnknown *)stream);
3273             LeaveCriticalSection(&session->cs);
3274
3275             IMFMediaSource_Release(source);
3276
3277             break;
3278         case MEStreamSinkStarted:
3279         case MEStreamSinkPaused:
3280         case MEStreamSinkStopped:
3281         case MEStreamSinkPrerolled:
3282
3283             EnterCriticalSection(&session->cs);
3284             session_set_sink_stream_state(session, (IMFStreamSink *)event_source, event_type);
3285             LeaveCriticalSection(&session->cs);
3286
3287             break;
3288         case MEStreamSinkMarker:
3289
3290             EnterCriticalSection(&session->cs);
3291             session_sink_stream_marker(session, (IMFStreamSink *)event_source);
3292             LeaveCriticalSection(&session->cs);
3293
3294             break;
3295         case MEStreamSinkRequestSample:
3296
3297             EnterCriticalSection(&session->cs);
3298             session_request_sample(session, (IMFStreamSink *)event_source);
3299             LeaveCriticalSection(&session->cs);
3300
3301             break;
3302         case MEMediaSample:
3303
3304             EnterCriticalSection(&session->cs);
3305             session_deliver_sample(session, (IMFMediaStream *)event_source, &value);
3306             LeaveCriticalSection(&session->cs);
3307
3308             break;
3309         case MEEndOfStream:
3310
3311             EnterCriticalSection(&session->cs);
3312             session_handle_end_of_stream(session, (IMFMediaStream *)event_source);
3313             LeaveCriticalSection(&session->cs);
3314
3315             break;
3316
3317         case MEEndOfPresentation:
3318
3319             EnterCriticalSection(&session->cs);
3320             session_handle_end_of_presentation(session, (IMFMediaSource *)event_source);
3321             LeaveCriticalSection(&session->cs);
3322
3323             break;
3324         case MEAudioSessionGroupingParamChanged:
3325         case MEAudioSessionIconChanged:
3326         case MEAudioSessionNameChanged:
3327         case MEAudioSessionVolumeChanged:
3328
3329             IMFMediaEventQueue_QueueEvent(session->event_queue, event);
3330
3331             break;
3332         case MEAudioSessionDeviceRemoved:
3333         case MEAudioSessionDisconnected:
3334         case MEAudioSessionExclusiveModeOverride:
3335         case MEAudioSessionFormatChanged:
3336         case MEAudioSessionServerShutdown:
3337
3338             IMFMediaEventQueue_QueueEvent(session->event_queue, event);
3339             /* fallthrough */
3340         case MESinkInvalidated:
3341
3342             EnterCriticalSection(&session->cs);
3343             session_sink_invalidated(session, event_type == MESinkInvalidated ? event : NULL,
3344                     (IMFStreamSink *)event_source);
3345             LeaveCriticalSection(&session->cs);
3346
3347             break;
3348         case MEQualityNotify:
3349
3350             if (session->quality_manager)
3351             {
3352                 if (FAILED(IMFMediaEventGenerator_QueryInterface(event_source, &IID_IMFStreamSink, (void **)&object)))
3353                     IMFMediaEventGenerator_QueryInterface(event_source, &IID_IMFTransform, (void **)&object);
3354
3355                 if (object)
3356                 {
3357                     IMFQualityManager_NotifyQualityEvent(session->quality_manager, object, event);
3358                     IUnknown_Release(object);
3359                 }
3360             }
3361
3362             break;
3363         default:
3364             ;
3365     }
3366
3367     PropVariantClear(&value);
3368
3369 failed:
3370     if (event)
3371         IMFMediaEvent_Release(event);
3372
3373     if (FAILED(hr = IMFMediaEventGenerator_BeginGetEvent(event_source, iface, (IUnknown *)event_source)))
3374         WARN("Failed to re-subscribe, hr %#x.\n", hr);
3375
3376     IMFMediaEventGenerator_Release(event_source);
3377
3378     return hr;
3379 }
3380
3381 static const IMFAsyncCallbackVtbl session_events_callback_vtbl =
3382 {
3383     session_events_callback_QueryInterface,
3384     session_events_callback_AddRef,
3385     session_events_callback_Release,
3386     session_events_callback_GetParameters,
3387     session_events_callback_Invoke,
3388 };
3389
3390 static HRESULT WINAPI session_sink_finalizer_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
3391 {
3392     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
3393             IsEqualIID(riid, &IID_IUnknown))
3394     {
3395         *obj = iface;
3396         IMFAsyncCallback_AddRef(iface);
3397         return S_OK;
3398     }
3399
3400     WARN("Unsupported %s.\n", debugstr_guid(riid));
3401     *obj = NULL;
3402     return E_NOINTERFACE;
3403 }
3404
3405 static ULONG WINAPI session_sink_finalizer_callback_AddRef(IMFAsyncCallback *iface)
3406 {
3407     struct media_session *session = impl_from_sink_finalizer_callback_IMFAsyncCallback(iface);
3408     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
3409 }
3410
3411 static ULONG WINAPI session_sink_finalizer_callback_Release(IMFAsyncCallback *iface)
3412 {
3413     struct media_session *session = impl_from_sink_finalizer_callback_IMFAsyncCallback(iface);
3414     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
3415 }
3416
3417 static HRESULT WINAPI session_sink_finalizer_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
3418 {
3419     return E_NOTIMPL;
3420 }
3421
3422 static HRESULT WINAPI session_sink_finalizer_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
3423 {
3424     struct media_session *session = impl_from_sink_finalizer_callback_IMFAsyncCallback(iface);
3425     IMFFinalizableMediaSink *fin_sink = NULL;
3426     BOOL sinks_finalized = TRUE;
3427     struct media_sink *sink;
3428     IUnknown *state;
3429     HRESULT hr;
3430
3431     if (FAILED(hr = IMFAsyncResult_GetState(result, &state)))
3432         return hr;
3433
3434     EnterCriticalSection(&session->cs);
3435
3436     LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry)
3437     {
3438         if (state == (IUnknown *)sink->sink)
3439         {
3440             if (FAILED(hr = IMFMediaSink_QueryInterface(sink->sink, &IID_IMFFinalizableMediaSink, (void **)&fin_sink)))
3441                 WARN("Unexpected, missing IMFFinalizableSink, hr %#x.\n", hr);
3442         }
3443         else
3444         {
3445             sinks_finalized &= sink->finalized;
3446             if (!sinks_finalized)
3447                 break;
3448         }
3449     }
3450
3451     IUnknown_Release(state);
3452
3453     if (fin_sink)
3454     {
3455         /* Complete session transition, or close prematurely on error. */
3456         if (SUCCEEDED(hr = IMFFinalizableMediaSink_EndFinalize(fin_sink, result)))
3457         {
3458             sink->finalized = TRUE;
3459             if (sinks_finalized)
3460                 session_set_closed(session, hr);
3461         }
3462         IMFFinalizableMediaSink_Release(fin_sink);
3463     }
3464
3465     LeaveCriticalSection(&session->cs);
3466
3467     return S_OK;
3468 }
3469
3470 static const IMFAsyncCallbackVtbl session_sink_finalizer_callback_vtbl =
3471 {
3472     session_sink_finalizer_callback_QueryInterface,
3473     session_sink_finalizer_callback_AddRef,
3474     session_sink_finalizer_callback_Release,
3475     session_sink_finalizer_callback_GetParameters,
3476     session_sink_finalizer_callback_Invoke,
3477 };
3478
3479 static HRESULT WINAPI session_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
3480 {
3481     struct media_session *session = impl_session_from_IMFRateSupport(iface);
3482     return IMFMediaSession_QueryInterface(&session->IMFMediaSession_iface, riid, obj);
3483 }
3484
3485 static ULONG WINAPI session_rate_support_AddRef(IMFRateSupport *iface)
3486 {
3487     struct media_session *session = impl_session_from_IMFRateSupport(iface);
3488     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
3489 }
3490
3491 static ULONG WINAPI session_rate_support_Release(IMFRateSupport *iface)
3492 {
3493     struct media_session *session = impl_session_from_IMFRateSupport(iface);
3494     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
3495 }
3496
3497 static HRESULT session_presentation_object_get_rate(IUnknown *object, MFRATE_DIRECTION direction,
3498         BOOL thin, BOOL fastest, float *result)
3499 {
3500     IMFRateSupport *rate_support;
3501     float rate;
3502     HRESULT hr;
3503
3504     /* For objects that don't support rate control, it's assumed that only forward direction is allowed, at 1.0f. */
3505
3506     if (FAILED(hr = MFGetService(object, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateSupport, (void **)&rate_support)))
3507     {
3508         if (direction == MFRATE_FORWARD)
3509         {
3510             *result = 1.0f;
3511             return S_OK;
3512         }
3513         else
3514             return MF_E_REVERSE_UNSUPPORTED;
3515     }
3516
3517     rate = 0.0f;
3518     if (fastest)
3519     {
3520         if (SUCCEEDED(hr = IMFRateSupport_GetFastestRate(rate_support, direction, thin, &rate)))
3521             *result = min(fabsf(rate), *result);
3522     }
3523     else
3524     {
3525         if (SUCCEEDED(hr = IMFRateSupport_GetSlowestRate(rate_support, direction, thin, &rate)))
3526             *result = max(fabsf(rate), *result);
3527     }
3528
3529     IMFRateSupport_Release(rate_support);
3530
3531     return hr;
3532 }
3533
3534 static HRESULT session_get_presentation_rate(struct media_session *session, MFRATE_DIRECTION direction,
3535         BOOL thin, BOOL fastest, float *result)
3536 {
3537     struct media_source *source;
3538     struct media_sink *sink;
3539     HRESULT hr = E_POINTER;
3540     float rate;
3541
3542     rate = fastest ? FLT_MAX : 0.0f;
3543
3544     EnterCriticalSection(&session->cs);
3545
3546     if (session->presentation.topo_status != MF_TOPOSTATUS_INVALID)
3547     {
3548         LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry)
3549         {
3550             if (FAILED(hr = session_presentation_object_get_rate((IUnknown *)source->source, direction, thin, fastest, &rate)))
3551                 break;
3552         }
3553
3554         if (SUCCEEDED(hr))
3555         {
3556             LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry)
3557             {
3558                 if (FAILED(hr = session_presentation_object_get_rate((IUnknown *)sink->sink, direction, thin, fastest, &rate)))
3559                     break;
3560             }
3561         }
3562     }
3563
3564     LeaveCriticalSection(&session->cs);
3565
3566     if (SUCCEEDED(hr))
3567         *result = direction == MFRATE_FORWARD ? rate : -rate;
3568
3569     return hr;
3570 }
3571
3572 static HRESULT WINAPI session_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
3573         BOOL thin, float *rate)
3574 {
3575     struct media_session *session = impl_session_from_IMFRateSupport(iface);
3576
3577     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
3578
3579     return session_get_presentation_rate(session, direction, thin, FALSE, rate);
3580 }
3581
3582 static HRESULT WINAPI session_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
3583         BOOL thin, float *rate)
3584 {
3585     struct media_session *session = impl_session_from_IMFRateSupport(iface);
3586
3587     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
3588
3589     return session_get_presentation_rate(session, direction, thin, TRUE, rate);
3590 }
3591
3592 static HRESULT WINAPI session_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
3593         float *nearest_supported_rate)
3594 {
3595     FIXME("%p, %d, %f, %p.\n", iface, thin, rate, nearest_supported_rate);
3596
3597     return E_NOTIMPL;
3598 }
3599
3600 static const IMFRateSupportVtbl session_rate_support_vtbl =
3601 {
3602     session_rate_support_QueryInterface,
3603     session_rate_support_AddRef,
3604     session_rate_support_Release,
3605     session_rate_support_GetSlowestRate,
3606     session_rate_support_GetFastestRate,
3607     session_rate_support_IsRateSupported,
3608 };
3609
3610 static HRESULT WINAPI session_rate_control_QueryInterface(IMFRateControl *iface, REFIID riid, void **obj)
3611 {
3612     struct media_session *session = impl_session_from_IMFRateControl(iface);
3613     return IMFMediaSession_QueryInterface(&session->IMFMediaSession_iface, riid, obj);
3614 }
3615
3616 static ULONG WINAPI session_rate_control_AddRef(IMFRateControl *iface)
3617 {
3618     struct media_session *session = impl_session_from_IMFRateControl(iface);
3619     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
3620 }
3621
3622 static ULONG WINAPI session_rate_control_Release(IMFRateControl *iface)
3623 {
3624     struct media_session *session = impl_session_from_IMFRateControl(iface);
3625     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
3626 }
3627
3628 static HRESULT WINAPI session_rate_control_SetRate(IMFRateControl *iface, BOOL thin, float rate)
3629 {
3630     FIXME("%p, %d, %f.\n", iface, thin, rate);
3631
3632     return E_NOTIMPL;
3633 }
3634
3635 static HRESULT WINAPI session_rate_control_GetRate(IMFRateControl *iface, BOOL *thin, float *rate)
3636 {
3637     struct media_session *session = impl_session_from_IMFRateControl(iface);
3638
3639     TRACE("%p, %p, %p.\n", iface, thin, rate);
3640
3641     return IMFRateControl_GetRate(session->clock_rate_control, thin, rate);
3642 }
3643
3644 static const IMFRateControlVtbl session_rate_control_vtbl =
3645 {
3646     session_rate_control_QueryInterface,
3647     session_rate_control_AddRef,
3648     session_rate_control_Release,
3649     session_rate_control_SetRate,
3650     session_rate_control_GetRate,
3651 };
3652
3653 static HRESULT WINAPI node_attribute_editor_QueryInterface(IMFTopologyNodeAttributeEditor *iface,
3654         REFIID riid, void **obj)
3655 {
3656     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
3657
3658     if (IsEqualIID(riid, &IID_IMFTopologyNodeAttributeEditor) ||
3659             IsEqualIID(riid, &IID_IUnknown))
3660     {
3661         *obj = iface;
3662         IMFTopologyNodeAttributeEditor_AddRef(iface);
3663         return S_OK;
3664     }
3665
3666     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
3667     *obj = NULL;
3668     return E_NOINTERFACE;
3669 }
3670
3671 static ULONG WINAPI node_attribute_editor_AddRef(IMFTopologyNodeAttributeEditor *iface)
3672 {
3673     struct media_session *session = impl_session_from_IMFTopologyNodeAttributeEditor(iface);
3674     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
3675 }
3676
3677 static ULONG WINAPI node_attribute_editor_Release(IMFTopologyNodeAttributeEditor *iface)
3678 {
3679     struct media_session *session = impl_session_from_IMFTopologyNodeAttributeEditor(iface);
3680     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
3681 }
3682
3683 static HRESULT WINAPI node_attribute_editor_UpdateNodeAttributes(IMFTopologyNodeAttributeEditor *iface,
3684         TOPOID id, DWORD count, MFTOPONODE_ATTRIBUTE_UPDATE *updates)
3685 {
3686     FIXME("%p, %s, %u, %p.\n", iface, wine_dbgstr_longlong(id), count, updates);
3687
3688     return E_NOTIMPL;
3689 }
3690
3691 static const IMFTopologyNodeAttributeEditorVtbl node_attribute_editor_vtbl =
3692 {
3693     node_attribute_editor_QueryInterface,
3694     node_attribute_editor_AddRef,
3695     node_attribute_editor_Release,
3696     node_attribute_editor_UpdateNodeAttributes,
3697 };
3698
3699 /***********************************************************************
3700  *      MFCreateMediaSession (mf.@)
3701  */
3702 HRESULT WINAPI MFCreateMediaSession(IMFAttributes *config, IMFMediaSession **session)
3703 {
3704     BOOL without_quality_manager = FALSE;
3705     struct media_session *object;
3706     HRESULT hr;
3707
3708     TRACE("%p, %p.\n", config, session);
3709
3710     object = heap_alloc_zero(sizeof(*object));
3711     if (!object)
3712         return E_OUTOFMEMORY;
3713
3714     object->IMFMediaSession_iface.lpVtbl = &mfmediasessionvtbl;
3715     object->IMFGetService_iface.lpVtbl = &session_get_service_vtbl;
3716     object->IMFRateSupport_iface.lpVtbl = &session_rate_support_vtbl;
3717     object->IMFRateControl_iface.lpVtbl = &session_rate_control_vtbl;
3718     object->IMFTopologyNodeAttributeEditor_iface.lpVtbl = &node_attribute_editor_vtbl;
3719     object->commands_callback.lpVtbl = &session_commands_callback_vtbl;
3720     object->events_callback.lpVtbl = &session_events_callback_vtbl;
3721     object->sink_finalizer_callback.lpVtbl = &session_sink_finalizer_callback_vtbl;
3722     object->refcount = 1;
3723     list_init(&object->topologies);
3724     list_init(&object->commands);
3725     list_init(&object->presentation.sources);
3726     list_init(&object->presentation.sinks);
3727     list_init(&object->presentation.nodes);
3728     InitializeCriticalSection(&object->cs);
3729
3730     if (FAILED(hr = MFCreateTopology(&object->presentation.current_topology)))
3731         goto failed;
3732
3733     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
3734         goto failed;
3735
3736     if (FAILED(hr = MFCreatePresentationClock(&object->clock)))
3737         goto failed;
3738
3739     if (FAILED(hr = MFCreateSystemTimeSource(&object->system_time_source)))
3740         goto failed;
3741
3742     if (FAILED(hr = IMFPresentationClock_QueryInterface(object->clock, &IID_IMFRateControl,
3743             (void **)&object->clock_rate_control)))
3744     {
3745         goto failed;
3746     }
3747
3748     if (config)
3749     {
3750         GUID clsid;
3751
3752         if (SUCCEEDED(IMFAttributes_GetGUID(config, &MF_SESSION_TOPOLOADER, &clsid)))
3753         {
3754             if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTopoLoader,
3755                     (void **)&object->topo_loader)))
3756             {
3757                 WARN("Failed to create custom topology loader, hr %#x.\n", hr);
3758             }
3759         }
3760
3761         if (SUCCEEDED(IMFAttributes_GetGUID(config, &MF_SESSION_QUALITY_MANAGER, &clsid)))
3762         {
3763             if (!(without_quality_manager = IsEqualGUID(&clsid, &GUID_NULL)))
3764             {
3765                 if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFQualityManager,
3766                         (void **)&object->quality_manager)))
3767                 {
3768                     WARN("Failed to create custom quality manager, hr %#x.\n", hr);
3769                 }
3770             }
3771         }
3772     }
3773
3774     if (!object->topo_loader && FAILED(hr = MFCreateTopoLoader(&object->topo_loader)))
3775         goto failed;
3776
3777     if (!object->quality_manager && !without_quality_manager &&
3778             FAILED(hr = MFCreateStandardQualityManager(&object->quality_manager)))
3779     {
3780         goto failed;
3781     }
3782
3783     if (object->quality_manager && FAILED(hr = IMFQualityManager_NotifyPresentationClock(object->quality_manager,
3784             object->clock)))
3785     {
3786         goto failed;
3787     }
3788
3789     *session = &object->IMFMediaSession_iface;
3790
3791     return S_OK;
3792
3793 failed:
3794     IMFMediaSession_Release(&object->IMFMediaSession_iface);
3795     return hr;
3796 }
3797
3798 static HRESULT WINAPI sink_notification_QueryInterface(IUnknown *iface, REFIID riid, void **out)
3799 {
3800     if (IsEqualIID(riid, &IID_IUnknown))
3801     {
3802         *out = iface;
3803         IUnknown_AddRef(iface);
3804         return S_OK;
3805     }
3806
3807     WARN("Unsupported %s.\n", debugstr_guid(riid));
3808     *out = NULL;
3809     return E_NOINTERFACE;
3810 }
3811
3812 static ULONG WINAPI sink_notification_AddRef(IUnknown *iface)
3813 {
3814     struct sink_notification *notification = impl_sink_notification_from_IUnknown(iface);
3815     ULONG refcount = InterlockedIncrement(&notification->refcount);
3816
3817     TRACE("%p, refcount %u.\n", iface, refcount);
3818
3819     return refcount;
3820 }
3821
3822 static ULONG WINAPI sink_notification_Release(IUnknown *iface)
3823 {
3824     struct sink_notification *notification = impl_sink_notification_from_IUnknown(iface);
3825     ULONG refcount = InterlockedDecrement(&notification->refcount);
3826
3827     TRACE("%p, refcount %u.\n", iface, refcount);
3828
3829     if (!refcount)
3830     {
3831         IMFClockStateSink_Release(notification->sink);
3832         heap_free(notification);
3833     }
3834
3835     return refcount;
3836 }
3837
3838 static const IUnknownVtbl sinknotificationvtbl =
3839 {
3840     sink_notification_QueryInterface,
3841     sink_notification_AddRef,
3842     sink_notification_Release,
3843 };
3844
3845 static void clock_notify_async_sink(struct presentation_clock *clock, MFTIME system_time,
3846         struct clock_state_change_param param, enum clock_notification notification, IMFClockStateSink *sink)
3847 {
3848     struct sink_notification *object;
3849     IMFAsyncResult *result;
3850     HRESULT hr;
3851
3852     object = heap_alloc(sizeof(*object));
3853     if (!object)
3854         return;
3855
3856     object->IUnknown_iface.lpVtbl = &sinknotificationvtbl;
3857     object->refcount = 1;
3858     object->system_time = system_time;
3859     object->param = param;
3860     object->notification = notification;
3861     object->sink = sink;
3862     IMFClockStateSink_AddRef(object->sink);
3863
3864     hr = MFCreateAsyncResult(&object->IUnknown_iface, &clock->sink_callback, NULL, &result);
3865     IUnknown_Release(&object->IUnknown_iface);
3866     if (SUCCEEDED(hr))
3867     {
3868         MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_STANDARD, result);
3869         IMFAsyncResult_Release(result);
3870     }
3871 }
3872
3873 static HRESULT WINAPI present_clock_QueryInterface(IMFPresentationClock *iface, REFIID riid, void **out)
3874 {
3875     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
3876
3877     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
3878
3879     if (IsEqualIID(riid, &IID_IMFPresentationClock) ||
3880             IsEqualIID(riid, &IID_IMFClock) ||
3881             IsEqualIID(riid, &IID_IUnknown))
3882     {
3883         *out = &clock->IMFPresentationClock_iface;
3884     }
3885     else if (IsEqualIID(riid, &IID_IMFRateControl))
3886     {
3887         *out = &clock->IMFRateControl_iface;
3888     }
3889     else if (IsEqualIID(riid, &IID_IMFTimer))
3890     {
3891         *out = &clock->IMFTimer_iface;
3892     }
3893     else if (IsEqualIID(riid, &IID_IMFShutdown))
3894     {
3895         *out = &clock->IMFShutdown_iface;
3896     }
3897     else
3898     {
3899         WARN("Unsupported %s.\n", debugstr_guid(riid));
3900         *out = NULL;
3901         return E_NOINTERFACE;
3902     }
3903
3904     IUnknown_AddRef((IUnknown *)*out);
3905     return S_OK;
3906 }
3907
3908 static ULONG WINAPI present_clock_AddRef(IMFPresentationClock *iface)
3909 {
3910     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
3911     ULONG refcount = InterlockedIncrement(&clock->refcount);
3912
3913     TRACE("%p, refcount %u.\n", iface, refcount);
3914
3915     return refcount;
3916 }
3917
3918 static ULONG WINAPI present_clock_Release(IMFPresentationClock *iface)
3919 {
3920     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
3921     ULONG refcount = InterlockedDecrement(&clock->refcount);
3922     struct clock_timer *timer, *timer2;
3923     struct clock_sink *sink, *sink2;
3924
3925     TRACE("%p, refcount %u.\n", iface, refcount);
3926
3927     if (!refcount)
3928     {
3929         if (clock->time_source)
3930             IMFPresentationTimeSource_Release(clock->time_source);
3931         if (clock->time_source_sink)
3932             IMFClockStateSink_Release(clock->time_source_sink);
3933         LIST_FOR_EACH_ENTRY_SAFE(sink, sink2, &clock->sinks, struct clock_sink, entry)
3934         {
3935             list_remove(&sink->entry);
3936             IMFClockStateSink_Release(sink->state_sink);
3937             heap_free(sink);
3938         }
3939         LIST_FOR_EACH_ENTRY_SAFE(timer, timer2, &clock->timers, struct clock_timer, entry)
3940         {
3941             list_remove(&timer->entry);
3942             IUnknown_Release(&timer->IUnknown_iface);
3943         }
3944         DeleteCriticalSection(&clock->cs);
3945         heap_free(clock);
3946     }
3947
3948     return refcount;
3949 }
3950
3951 static HRESULT WINAPI present_clock_GetClockCharacteristics(IMFPresentationClock *iface, DWORD *flags)
3952 {
3953     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
3954     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
3955
3956     TRACE("%p, %p.\n", iface, flags);
3957
3958     EnterCriticalSection(&clock->cs);
3959     if (clock->time_source)
3960         hr = IMFPresentationTimeSource_GetClockCharacteristics(clock->time_source, flags);
3961     LeaveCriticalSection(&clock->cs);
3962
3963     return hr;
3964 }
3965
3966 static HRESULT WINAPI present_clock_GetCorrelatedTime(IMFPresentationClock *iface, DWORD reserved,
3967         LONGLONG *clock_time, MFTIME *system_time)
3968 {
3969     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
3970     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
3971
3972     TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time);
3973
3974     EnterCriticalSection(&clock->cs);
3975     if (clock->time_source)
3976         hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, reserved, clock_time, system_time);
3977     LeaveCriticalSection(&clock->cs);
3978
3979     return hr;
3980 }
3981
3982 static HRESULT WINAPI present_clock_GetContinuityKey(IMFPresentationClock *iface, DWORD *key)
3983 {
3984     TRACE("%p, %p.\n", iface, key);
3985
3986     *key = 0;
3987
3988     return S_OK;
3989 }
3990
3991 static HRESULT WINAPI present_clock_GetState(IMFPresentationClock *iface, DWORD reserved, MFCLOCK_STATE *state)
3992 {
3993     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
3994
3995     TRACE("%p, %#x, %p.\n", iface, reserved, state);
3996
3997     EnterCriticalSection(&clock->cs);
3998     *state = clock->state;
3999     LeaveCriticalSection(&clock->cs);
4000
4001     return S_OK;
4002 }
4003
4004 static HRESULT WINAPI present_clock_GetProperties(IMFPresentationClock *iface, MFCLOCK_PROPERTIES *props)
4005 {
4006     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4007     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
4008
4009     TRACE("%p, %p.\n", iface, props);
4010
4011     EnterCriticalSection(&clock->cs);
4012     if (clock->time_source)
4013         hr = IMFPresentationTimeSource_GetProperties(clock->time_source, props);
4014     LeaveCriticalSection(&clock->cs);
4015
4016     return hr;
4017 }
4018
4019 static HRESULT WINAPI present_clock_SetTimeSource(IMFPresentationClock *iface,
4020         IMFPresentationTimeSource *time_source)
4021 {
4022     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4023     MFCLOCK_PROPERTIES props;
4024     IMFClock *source_clock;
4025     HRESULT hr;
4026
4027     TRACE("%p, %p.\n", iface, time_source);
4028
4029     EnterCriticalSection(&clock->cs);
4030
4031     if (clock->time_source)
4032         IMFPresentationTimeSource_Release(clock->time_source);
4033     if (clock->time_source_sink)
4034         IMFClockStateSink_Release(clock->time_source_sink);
4035     clock->time_source = NULL;
4036     clock->time_source_sink = NULL;
4037
4038     hr = IMFPresentationTimeSource_QueryInterface(time_source, &IID_IMFClockStateSink, (void **)&clock->time_source_sink);
4039     if (SUCCEEDED(hr))
4040     {
4041         clock->time_source = time_source;
4042         IMFPresentationTimeSource_AddRef(clock->time_source);
4043     }
4044
4045     if (SUCCEEDED(IMFPresentationTimeSource_GetUnderlyingClock(time_source, &source_clock)))
4046     {
4047         if (SUCCEEDED(IMFClock_GetProperties(source_clock, &props)))
4048             clock->frequency = props.qwClockFrequency;
4049         IMFClock_Release(source_clock);
4050     }
4051
4052     if (!clock->frequency)
4053         clock->frequency = MFCLOCK_FREQUENCY_HNS;
4054
4055     LeaveCriticalSection(&clock->cs);
4056
4057     return hr;
4058 }
4059
4060 static HRESULT WINAPI present_clock_GetTimeSource(IMFPresentationClock *iface,
4061         IMFPresentationTimeSource **time_source)
4062 {
4063     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4064     HRESULT hr = S_OK;
4065
4066     TRACE("%p, %p.\n", iface, time_source);
4067
4068     if (!time_source)
4069         return E_INVALIDARG;
4070
4071     EnterCriticalSection(&clock->cs);
4072     if (clock->time_source)
4073     {
4074         *time_source = clock->time_source;
4075         IMFPresentationTimeSource_AddRef(*time_source);
4076     }
4077     else
4078         hr = MF_E_CLOCK_NO_TIME_SOURCE;
4079     LeaveCriticalSection(&clock->cs);
4080
4081     return hr;
4082 }
4083
4084 static HRESULT WINAPI present_clock_GetTime(IMFPresentationClock *iface, MFTIME *time)
4085 {
4086     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4087     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
4088     MFTIME systime;
4089
4090     TRACE("%p, %p.\n", iface, time);
4091
4092     if (!time)
4093         return E_POINTER;
4094
4095     EnterCriticalSection(&clock->cs);
4096     if (clock->time_source)
4097         hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, 0, time, &systime);
4098     LeaveCriticalSection(&clock->cs);
4099
4100     return hr;
4101 }
4102
4103 static HRESULT WINAPI present_clock_AddClockStateSink(IMFPresentationClock *iface, IMFClockStateSink *state_sink)
4104 {
4105     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4106     struct clock_sink *sink, *cur;
4107     HRESULT hr = S_OK;
4108
4109     TRACE("%p, %p.\n", iface, state_sink);
4110
4111     if (!state_sink)
4112         return E_INVALIDARG;
4113
4114     sink = heap_alloc(sizeof(*sink));
4115     if (!sink)
4116         return E_OUTOFMEMORY;
4117
4118     sink->state_sink = state_sink;
4119     IMFClockStateSink_AddRef(sink->state_sink);
4120
4121     EnterCriticalSection(&clock->cs);
4122     LIST_FOR_EACH_ENTRY(cur, &clock->sinks, struct clock_sink, entry)
4123     {
4124         if (cur->state_sink == state_sink)
4125         {
4126             hr = E_INVALIDARG;
4127             break;
4128         }
4129     }
4130     if (SUCCEEDED(hr))
4131     {
4132         static const enum clock_notification notifications[MFCLOCK_STATE_PAUSED + 1] =
4133         {
4134             /* MFCLOCK_STATE_INVALID */ 0, /* Does not apply */
4135             /* MFCLOCK_STATE_RUNNING */ CLOCK_NOTIFY_START,
4136             /* MFCLOCK_STATE_STOPPED */ CLOCK_NOTIFY_STOP,
4137             /* MFCLOCK_STATE_PAUSED  */ CLOCK_NOTIFY_PAUSE,
4138         };
4139         struct clock_state_change_param param;
4140
4141         if (!clock->is_shut_down && clock->state != MFCLOCK_STATE_INVALID)
4142         {
4143             param.u.offset = clock->start_offset;
4144             clock_notify_async_sink(clock, MFGetSystemTime(), param, notifications[clock->state], sink->state_sink);
4145         }
4146
4147         list_add_tail(&clock->sinks, &sink->entry);
4148     }
4149     LeaveCriticalSection(&clock->cs);
4150
4151     if (FAILED(hr))
4152     {
4153         IMFClockStateSink_Release(sink->state_sink);
4154         heap_free(sink);
4155     }
4156
4157     return hr;
4158 }
4159
4160 static HRESULT WINAPI present_clock_RemoveClockStateSink(IMFPresentationClock *iface,
4161         IMFClockStateSink *state_sink)
4162 {
4163     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4164     struct clock_sink *sink;
4165
4166     TRACE("%p, %p.\n", iface, state_sink);
4167
4168     if (!state_sink)
4169         return E_INVALIDARG;
4170
4171     EnterCriticalSection(&clock->cs);
4172     LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry)
4173     {
4174         if (sink->state_sink == state_sink)
4175         {
4176             IMFClockStateSink_Release(sink->state_sink);
4177             list_remove(&sink->entry);
4178             heap_free(sink);
4179             break;
4180         }
4181     }
4182     LeaveCriticalSection(&clock->cs);
4183
4184     return S_OK;
4185 }
4186
4187 static HRESULT clock_call_state_change(MFTIME system_time, struct clock_state_change_param param,
4188         enum clock_notification notification, IMFClockStateSink *sink)
4189 {
4190     HRESULT hr = S_OK;
4191
4192     switch (notification)
4193     {
4194         case CLOCK_NOTIFY_START:
4195             hr = IMFClockStateSink_OnClockStart(sink, system_time, param.u.offset);
4196             break;
4197         case CLOCK_NOTIFY_STOP:
4198             hr = IMFClockStateSink_OnClockStop(sink, system_time);
4199             break;
4200         case CLOCK_NOTIFY_PAUSE:
4201             hr = IMFClockStateSink_OnClockPause(sink, system_time);
4202             break;
4203         case CLOCK_NOTIFY_RESTART:
4204             hr = IMFClockStateSink_OnClockRestart(sink, system_time);
4205             break;
4206         case CLOCK_NOTIFY_SET_RATE:
4207             /* System time source does not allow 0.0 rate, presentation clock allows it without raising errors. */
4208             IMFClockStateSink_OnClockSetRate(sink, system_time, param.u.rate);
4209             break;
4210         default:
4211             ;
4212     }
4213
4214     return hr;
4215 }
4216
4217 static HRESULT clock_change_state(struct presentation_clock *clock, enum clock_command command,
4218         struct clock_state_change_param param)
4219 {
4220     static const BYTE state_change_is_allowed[MFCLOCK_STATE_PAUSED+1][CLOCK_CMD_MAX] =
4221     {   /*              S  S* P, R  */
4222         /* INVALID */ { 1, 1, 1, 1 },
4223         /* RUNNING */ { 1, 1, 1, 1 },
4224         /* STOPPED */ { 1, 1, 0, 1 },
4225         /* PAUSED  */ { 1, 1, 0, 1 },
4226     };
4227     static const MFCLOCK_STATE states[CLOCK_CMD_MAX] =
4228     {
4229         /* CLOCK_CMD_START    */ MFCLOCK_STATE_RUNNING,
4230         /* CLOCK_CMD_STOP     */ MFCLOCK_STATE_STOPPED,
4231         /* CLOCK_CMD_PAUSE    */ MFCLOCK_STATE_PAUSED,
4232         /* CLOCK_CMD_SET_RATE */ 0, /* Unused */
4233     };
4234     static const enum clock_notification notifications[CLOCK_CMD_MAX] =
4235     {
4236         /* CLOCK_CMD_START    */ CLOCK_NOTIFY_START,
4237         /* CLOCK_CMD_STOP     */ CLOCK_NOTIFY_STOP,
4238         /* CLOCK_CMD_PAUSE    */ CLOCK_NOTIFY_PAUSE,
4239         /* CLOCK_CMD_SET_RATE */ CLOCK_NOTIFY_SET_RATE,
4240     };
4241     enum clock_notification notification;
4242     struct clock_sink *sink;
4243     MFCLOCK_STATE old_state;
4244     IMFAsyncResult *result;
4245     MFTIME system_time;
4246     HRESULT hr;
4247
4248     if (!clock->time_source)
4249         return MF_E_CLOCK_NO_TIME_SOURCE;
4250
4251     if (command != CLOCK_CMD_SET_RATE && clock->state == states[command] && clock->state != MFCLOCK_STATE_RUNNING)
4252         return MF_E_CLOCK_STATE_ALREADY_SET;
4253
4254     if (!state_change_is_allowed[clock->state][command])
4255         return MF_E_INVALIDREQUEST;
4256
4257     system_time = MFGetSystemTime();
4258
4259     if (command == CLOCK_CMD_START && clock->state == MFCLOCK_STATE_PAUSED &&
4260             param.u.offset == PRESENTATION_CURRENT_POSITION)
4261     {
4262         notification = CLOCK_NOTIFY_RESTART;
4263     }
4264     else
4265         notification = notifications[command];
4266
4267     if (FAILED(hr = clock_call_state_change(system_time, param, notification, clock->time_source_sink)))
4268         return hr;
4269
4270     old_state = clock->state;
4271     if (command != CLOCK_CMD_SET_RATE)
4272         clock->state = states[command];
4273
4274     /* Dump all pending timer requests immediately on start; otherwise try to cancel scheduled items when
4275        transitioning from running state. */
4276     if ((clock->state == MFCLOCK_STATE_RUNNING) ^ (old_state == MFCLOCK_STATE_RUNNING))
4277     {
4278         struct clock_timer *timer, *timer2;
4279
4280         if (clock->state == MFCLOCK_STATE_RUNNING)
4281         {
4282             LIST_FOR_EACH_ENTRY_SAFE(timer, timer2, &clock->timers, struct clock_timer, entry)
4283             {
4284                 list_remove(&timer->entry);
4285                 hr = MFCreateAsyncResult(&timer->IUnknown_iface, &clock->timer_callback, NULL, &result);
4286                 IUnknown_Release(&timer->IUnknown_iface);
4287                 if (SUCCEEDED(hr))
4288                 {
4289                     MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_TIMER, result);
4290                     IMFAsyncResult_Release(result);
4291                 }
4292             }
4293         }
4294         else
4295         {
4296             LIST_FOR_EACH_ENTRY(timer, &clock->timers, struct clock_timer, entry)
4297             {
4298                 if (timer->key)
4299                 {
4300                     MFCancelWorkItem(timer->key);
4301                     timer->key = 0;
4302                 }
4303             }
4304         }
4305     }
4306
4307     LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry)
4308     {
4309         clock_notify_async_sink(clock, system_time, param, notification, sink->state_sink);
4310     }
4311
4312     return S_OK;
4313 }
4314
4315 static HRESULT WINAPI present_clock_Start(IMFPresentationClock *iface, LONGLONG start_offset)
4316 {
4317     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4318     struct clock_state_change_param param = {{0}};
4319     HRESULT hr;
4320
4321     TRACE("%p, %s.\n", iface, debugstr_time(start_offset));
4322
4323     EnterCriticalSection(&clock->cs);
4324     clock->start_offset = param.u.offset = start_offset;
4325     hr = clock_change_state(clock, CLOCK_CMD_START, param);
4326     LeaveCriticalSection(&clock->cs);
4327
4328     return hr;
4329 }
4330
4331 static HRESULT WINAPI present_clock_Stop(IMFPresentationClock *iface)
4332 {
4333     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4334     struct clock_state_change_param param = {{0}};
4335     HRESULT hr;
4336
4337     TRACE("%p.\n", iface);
4338
4339     EnterCriticalSection(&clock->cs);
4340     hr = clock_change_state(clock, CLOCK_CMD_STOP, param);
4341     LeaveCriticalSection(&clock->cs);
4342
4343     return hr;
4344 }
4345
4346 static HRESULT WINAPI present_clock_Pause(IMFPresentationClock *iface)
4347 {
4348     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
4349     struct clock_state_change_param param = {{0}};
4350     HRESULT hr;
4351
4352     TRACE("%p.\n", iface);
4353
4354     EnterCriticalSection(&clock->cs);
4355     hr = clock_change_state(clock, CLOCK_CMD_PAUSE, param);
4356     LeaveCriticalSection(&clock->cs);
4357
4358     return hr;
4359 }
4360
4361 static const IMFPresentationClockVtbl presentationclockvtbl =
4362 {
4363     present_clock_QueryInterface,
4364     present_clock_AddRef,
4365     present_clock_Release,
4366     present_clock_GetClockCharacteristics,
4367     present_clock_GetCorrelatedTime,
4368     present_clock_GetContinuityKey,
4369     present_clock_GetState,
4370     present_clock_GetProperties,
4371     present_clock_SetTimeSource,
4372     present_clock_GetTimeSource,
4373     present_clock_GetTime,
4374     present_clock_AddClockStateSink,
4375     present_clock_RemoveClockStateSink,
4376     present_clock_Start,
4377     present_clock_Stop,
4378     present_clock_Pause,
4379 };
4380
4381 static HRESULT WINAPI present_clock_rate_control_QueryInterface(IMFRateControl *iface, REFIID riid, void **out)
4382 {
4383     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
4384     return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out);
4385 }
4386
4387 static ULONG WINAPI present_clock_rate_control_AddRef(IMFRateControl *iface)
4388 {
4389     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
4390     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
4391 }
4392
4393 static ULONG WINAPI present_clock_rate_control_Release(IMFRateControl *iface)
4394 {
4395     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
4396     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
4397 }
4398
4399 static HRESULT WINAPI present_clock_rate_SetRate(IMFRateControl *iface, BOOL thin, float rate)
4400 {
4401     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
4402     struct clock_state_change_param param;
4403     HRESULT hr;
4404
4405     TRACE("%p, %d, %f.\n", iface, thin, rate);
4406
4407     if (thin)
4408         return MF_E_THINNING_UNSUPPORTED;
4409
4410     EnterCriticalSection(&clock->cs);
4411     param.u.rate = rate;
4412     if (SUCCEEDED(hr = clock_change_state(clock, CLOCK_CMD_SET_RATE, param)))
4413         clock->rate = rate;
4414     LeaveCriticalSection(&clock->cs);
4415
4416     return hr;
4417 }
4418
4419 static HRESULT WINAPI present_clock_rate_GetRate(IMFRateControl *iface, BOOL *thin, float *rate)
4420 {
4421     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
4422
4423     TRACE("%p, %p, %p.\n", iface, thin, rate);
4424
4425     if (!rate)
4426         return E_INVALIDARG;
4427
4428     if (thin)
4429         *thin = FALSE;
4430
4431     EnterCriticalSection(&clock->cs);
4432     *rate = clock->rate;
4433     LeaveCriticalSection(&clock->cs);
4434
4435     return S_OK;
4436 }
4437
4438 static const IMFRateControlVtbl presentclockratecontrolvtbl =
4439 {
4440     present_clock_rate_control_QueryInterface,
4441     present_clock_rate_control_AddRef,
4442     present_clock_rate_control_Release,
4443     present_clock_rate_SetRate,
4444     present_clock_rate_GetRate,
4445 };
4446
4447 static HRESULT WINAPI present_clock_timer_QueryInterface(IMFTimer *iface, REFIID riid, void **out)
4448 {
4449     struct presentation_clock *clock = impl_from_IMFTimer(iface);
4450     return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out);
4451 }
4452
4453 static ULONG WINAPI present_clock_timer_AddRef(IMFTimer *iface)
4454 {
4455     struct presentation_clock *clock = impl_from_IMFTimer(iface);
4456     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
4457 }
4458
4459 static ULONG WINAPI present_clock_timer_Release(IMFTimer *iface)
4460 {
4461     struct presentation_clock *clock = impl_from_IMFTimer(iface);
4462     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
4463 }
4464
4465 static HRESULT present_clock_schedule_timer(struct presentation_clock *clock, DWORD flags, LONGLONG time,
4466         struct clock_timer *timer)
4467 {
4468     IMFAsyncResult *result;
4469     MFTIME systime, clocktime;
4470     LONGLONG frequency;
4471     HRESULT hr;
4472
4473     if (!(flags & MFTIMER_RELATIVE))
4474     {
4475         if (FAILED(hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, 0, &clocktime, &systime)))
4476         {
4477             WARN("Failed to get clock time, hr %#x.\n", hr);
4478             return hr;
4479         }
4480         time -= clocktime;
4481     }
4482
4483     frequency = clock->frequency / 1000;
4484     time /= frequency;
4485
4486     /* Scheduled item is using clock instance callback, with timer instance as an object. Clock callback will
4487        call user callback and cleanup timer list. */
4488
4489     if (FAILED(hr = MFCreateAsyncResult(&timer->IUnknown_iface, &clock->timer_callback, NULL, &result)))
4490         return hr;
4491
4492     hr = MFScheduleWorkItemEx(result, -time, &timer->key);
4493     IMFAsyncResult_Release(result);
4494
4495     return hr;
4496 }
4497
4498 static HRESULT WINAPI clock_timer_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
4499 {
4500     if (IsEqualIID(riid, &IID_IUnknown))
4501     {
4502         *obj = iface;
4503         IUnknown_AddRef(iface);
4504         return S_OK;
4505     }
4506
4507     *obj = NULL;
4508     return E_NOINTERFACE;
4509 }
4510
4511 static ULONG WINAPI clock_timer_AddRef(IUnknown *iface)
4512 {
4513     struct clock_timer *timer = impl_clock_timer_from_IUnknown(iface);
4514     return InterlockedIncrement(&timer->refcount);
4515 }
4516
4517 static ULONG WINAPI clock_timer_Release(IUnknown *iface)
4518 {
4519     struct clock_timer *timer = impl_clock_timer_from_IUnknown(iface);
4520     ULONG refcount = InterlockedDecrement(&timer->refcount);
4521
4522     if (!refcount)
4523     {
4524         IMFAsyncResult_Release(timer->result);
4525         IMFAsyncCallback_Release(timer->callback);
4526         heap_free(timer);
4527     }
4528
4529     return refcount;
4530 }
4531
4532 static const IUnknownVtbl clock_timer_vtbl =
4533 {
4534     clock_timer_QueryInterface,
4535     clock_timer_AddRef,
4536     clock_timer_Release,
4537 };
4538
4539 static HRESULT WINAPI present_clock_timer_SetTimer(IMFTimer *iface, DWORD flags, LONGLONG time,
4540         IMFAsyncCallback *callback, IUnknown *state, IUnknown **cancel_key)
4541 {
4542     struct presentation_clock *clock = impl_from_IMFTimer(iface);
4543     struct clock_timer *clock_timer;
4544     HRESULT hr;
4545
4546     TRACE("%p, %#x, %s, %p, %p, %p.\n", iface, flags, debugstr_time(time), callback, state, cancel_key);
4547
4548     if (!(clock_timer = heap_alloc_zero(sizeof(*clock_timer))))
4549         return E_OUTOFMEMORY;
4550
4551     if (FAILED(hr = MFCreateAsyncResult(NULL, NULL, state, &clock_timer->result)))
4552     {
4553         heap_free(clock_timer);
4554         return hr;
4555     }
4556
4557     clock_timer->IUnknown_iface.lpVtbl = &clock_timer_vtbl;
4558     clock_timer->refcount = 1;
4559     clock_timer->callback = callback;
4560     IMFAsyncCallback_AddRef(clock_timer->callback);
4561
4562     EnterCriticalSection(&clock->cs);
4563
4564     if (clock->state == MFCLOCK_STATE_RUNNING)
4565         hr = present_clock_schedule_timer(clock, flags, time, clock_timer);
4566     else if (clock->state == MFCLOCK_STATE_STOPPED)
4567         hr = MF_S_CLOCK_STOPPED;
4568
4569     if (SUCCEEDED(hr))
4570     {
4571         list_add_tail(&clock->timers, &clock_timer->entry);
4572         if (cancel_key)
4573         {
4574             *cancel_key = &clock_timer->IUnknown_iface;
4575             IUnknown_AddRef(*cancel_key);
4576         }
4577     }
4578
4579     LeaveCriticalSection(&clock->cs);
4580
4581     if (FAILED(hr))
4582         IUnknown_Release(&clock_timer->IUnknown_iface);
4583
4584     return hr;
4585 }
4586
4587 static HRESULT WINAPI present_clock_timer_CancelTimer(IMFTimer *iface, IUnknown *cancel_key)
4588 {
4589     struct presentation_clock *clock = impl_from_IMFTimer(iface);
4590     struct clock_timer *timer;
4591
4592     TRACE("%p, %p.\n", iface, cancel_key);
4593
4594     EnterCriticalSection(&clock->cs);
4595
4596     LIST_FOR_EACH_ENTRY(timer, &clock->timers, struct clock_timer, entry)
4597     {
4598         if (&timer->IUnknown_iface == cancel_key)
4599         {
4600             list_remove(&timer->entry);
4601             if (timer->key)
4602             {
4603                 MFCancelWorkItem(timer->key);
4604                 timer->key = 0;
4605             }
4606             IUnknown_Release(&timer->IUnknown_iface);
4607             break;
4608         }
4609     }
4610
4611     LeaveCriticalSection(&clock->cs);
4612
4613     return S_OK;
4614 }
4615
4616 static const IMFTimerVtbl presentclocktimervtbl =
4617 {
4618     present_clock_timer_QueryInterface,
4619     present_clock_timer_AddRef,
4620     present_clock_timer_Release,
4621     present_clock_timer_SetTimer,
4622     present_clock_timer_CancelTimer,
4623 };
4624
4625 static HRESULT WINAPI present_clock_shutdown_QueryInterface(IMFShutdown *iface, REFIID riid, void **out)
4626 {
4627     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
4628     return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out);
4629 }
4630
4631 static ULONG WINAPI present_clock_shutdown_AddRef(IMFShutdown *iface)
4632 {
4633     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
4634     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
4635 }
4636
4637 static ULONG WINAPI present_clock_shutdown_Release(IMFShutdown *iface)
4638 {
4639     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
4640     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
4641 }
4642
4643 static HRESULT WINAPI present_clock_shutdown_Shutdown(IMFShutdown *iface)
4644 {
4645     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
4646
4647     TRACE("%p.\n", iface);
4648
4649     EnterCriticalSection(&clock->cs);
4650     clock->is_shut_down = TRUE;
4651     LeaveCriticalSection(&clock->cs);
4652
4653     return S_OK;
4654 }
4655
4656 static HRESULT WINAPI present_clock_shutdown_GetShutdownStatus(IMFShutdown *iface, MFSHUTDOWN_STATUS *status)
4657 {
4658     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
4659     HRESULT hr = S_OK;
4660
4661     TRACE("%p, %p.\n", iface, status);
4662
4663     if (!status)
4664         return E_INVALIDARG;
4665
4666     EnterCriticalSection(&clock->cs);
4667     if (clock->is_shut_down)
4668         *status = MFSHUTDOWN_COMPLETED;
4669     else
4670         hr = MF_E_INVALIDREQUEST;
4671     LeaveCriticalSection(&clock->cs);
4672
4673     return hr;
4674 }
4675
4676 static const IMFShutdownVtbl presentclockshutdownvtbl =
4677 {
4678     present_clock_shutdown_QueryInterface,
4679     present_clock_shutdown_AddRef,
4680     present_clock_shutdown_Release,
4681     present_clock_shutdown_Shutdown,
4682     present_clock_shutdown_GetShutdownStatus,
4683 };
4684
4685 static HRESULT WINAPI present_clock_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **out)
4686 {
4687     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
4688             IsEqualIID(riid, &IID_IUnknown))
4689     {
4690         *out = iface;
4691         IMFAsyncCallback_AddRef(iface);
4692         return S_OK;
4693     }
4694
4695     WARN("Unsupported %s.\n", wine_dbgstr_guid(riid));
4696     *out = NULL;
4697     return E_NOINTERFACE;
4698 }
4699
4700 static ULONG WINAPI present_clock_sink_callback_AddRef(IMFAsyncCallback *iface)
4701 {
4702     struct presentation_clock *clock = impl_from_sink_callback_IMFAsyncCallback(iface);
4703     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
4704 }
4705
4706 static ULONG WINAPI present_clock_sink_callback_Release(IMFAsyncCallback *iface)
4707 {
4708     struct presentation_clock *clock = impl_from_sink_callback_IMFAsyncCallback(iface);
4709     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
4710 }
4711
4712 static HRESULT WINAPI present_clock_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
4713 {
4714     return E_NOTIMPL;
4715 }
4716
4717 static HRESULT WINAPI present_clock_sink_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
4718 {
4719     struct sink_notification *data;
4720     IUnknown *object;
4721     HRESULT hr;
4722
4723     if (FAILED(hr = IMFAsyncResult_GetObject(result, &object)))
4724         return hr;
4725
4726     data = impl_sink_notification_from_IUnknown(object);
4727
4728     clock_call_state_change(data->system_time, data->param, data->notification, data->sink);
4729
4730     IUnknown_Release(object);
4731
4732     return S_OK;
4733 }
4734
4735 static const IMFAsyncCallbackVtbl presentclocksinkcallbackvtbl =
4736 {
4737     present_clock_callback_QueryInterface,
4738     present_clock_sink_callback_AddRef,
4739     present_clock_sink_callback_Release,
4740     present_clock_callback_GetParameters,
4741     present_clock_sink_callback_Invoke,
4742 };
4743
4744 static ULONG WINAPI present_clock_timer_callback_AddRef(IMFAsyncCallback *iface)
4745 {
4746     struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface);
4747     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
4748 }
4749
4750 static ULONG WINAPI present_clock_timer_callback_Release(IMFAsyncCallback *iface)
4751 {
4752     struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface);
4753     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
4754 }
4755
4756 static HRESULT WINAPI present_clock_timer_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
4757 {
4758     struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface);
4759     struct clock_timer *timer;
4760     IUnknown *object;
4761     HRESULT hr;
4762
4763     if (FAILED(hr = IMFAsyncResult_GetObject(result, &object)))
4764         return hr;
4765
4766     timer = impl_clock_timer_from_IUnknown(object);
4767
4768     EnterCriticalSection(&clock->cs);
4769     list_remove(&timer->entry);
4770     IUnknown_Release(&timer->IUnknown_iface);
4771     LeaveCriticalSection(&clock->cs);
4772
4773     IMFAsyncCallback_Invoke(timer->callback, timer->result);
4774
4775     IUnknown_Release(object);
4776
4777     return S_OK;
4778 }
4779
4780 static const IMFAsyncCallbackVtbl presentclocktimercallbackvtbl =
4781 {
4782     present_clock_callback_QueryInterface,
4783     present_clock_timer_callback_AddRef,
4784     present_clock_timer_callback_Release,
4785     present_clock_callback_GetParameters,
4786     present_clock_timer_callback_Invoke,
4787 };
4788
4789 /***********************************************************************
4790  *      MFCreatePresentationClock (mf.@)
4791  */
4792 HRESULT WINAPI MFCreatePresentationClock(IMFPresentationClock **clock)
4793 {
4794     struct presentation_clock *object;
4795
4796     TRACE("%p.\n", clock);
4797
4798     object = heap_alloc_zero(sizeof(*object));
4799     if (!object)
4800         return E_OUTOFMEMORY;
4801
4802     object->IMFPresentationClock_iface.lpVtbl = &presentationclockvtbl;
4803     object->IMFRateControl_iface.lpVtbl = &presentclockratecontrolvtbl;
4804     object->IMFTimer_iface.lpVtbl = &presentclocktimervtbl;
4805     object->IMFShutdown_iface.lpVtbl = &presentclockshutdownvtbl;
4806     object->sink_callback.lpVtbl = &presentclocksinkcallbackvtbl;
4807     object->timer_callback.lpVtbl = &presentclocktimercallbackvtbl;
4808     object->refcount = 1;
4809     list_init(&object->sinks);
4810     list_init(&object->timers);
4811     object->rate = 1.0f;
4812     InitializeCriticalSection(&object->cs);
4813
4814     *clock = &object->IMFPresentationClock_iface;
4815
4816     return S_OK;
4817 }
4818
4819 static HRESULT WINAPI standard_quality_manager_QueryInterface(IMFQualityManager *iface, REFIID riid, void **out)
4820 {
4821     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
4822
4823     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
4824
4825     if (IsEqualIID(riid, &IID_IMFQualityManager) ||
4826             IsEqualIID(riid, &IID_IUnknown))
4827     {
4828         *out = iface;
4829     }
4830     else if (IsEqualIID(riid, &IID_IMFClockStateSink))
4831     {
4832         *out = &manager->IMFClockStateSink_iface;
4833     }
4834     else
4835     {
4836         WARN("Unsupported %s.\n", debugstr_guid(riid));
4837         *out = NULL;
4838         return E_NOINTERFACE;
4839     }
4840
4841     IUnknown_AddRef((IUnknown *)*out);
4842     return S_OK;
4843 }
4844
4845 static ULONG WINAPI standard_quality_manager_AddRef(IMFQualityManager *iface)
4846 {
4847     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
4848     ULONG refcount = InterlockedIncrement(&manager->refcount);
4849
4850     TRACE("%p, refcount %u.\n", iface, refcount);
4851
4852     return refcount;
4853 }
4854
4855 static ULONG WINAPI standard_quality_manager_Release(IMFQualityManager *iface)
4856 {
4857     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
4858     ULONG refcount = InterlockedDecrement(&manager->refcount);
4859
4860     TRACE("%p, refcount %u.\n", iface, refcount);
4861
4862     if (!refcount)
4863     {
4864         if (manager->clock)
4865             IMFPresentationClock_Release(manager->clock);
4866         if (manager->topology)
4867             IMFTopology_Release(manager->topology);
4868         DeleteCriticalSection(&manager->cs);
4869         heap_free(manager);
4870     }
4871
4872     return refcount;
4873 }
4874
4875 static void standard_quality_manager_set_topology(struct quality_manager *manager, IMFTopology *topology)
4876 {
4877     if (manager->topology)
4878         IMFTopology_Release(manager->topology);
4879     manager->topology = topology;
4880     if (manager->topology)
4881         IMFTopology_AddRef(manager->topology);
4882 }
4883
4884 static HRESULT WINAPI standard_quality_manager_NotifyTopology(IMFQualityManager *iface, IMFTopology *topology)
4885 {
4886     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
4887     HRESULT hr = S_OK;
4888
4889     TRACE("%p, %p.\n", iface, topology);
4890
4891     EnterCriticalSection(&manager->cs);
4892     if (manager->state == QUALITY_MANAGER_SHUT_DOWN)
4893         hr = MF_E_SHUTDOWN;
4894     else
4895     {
4896         standard_quality_manager_set_topology(manager, topology);
4897     }
4898     LeaveCriticalSection(&manager->cs);
4899
4900     return hr;
4901 }
4902
4903 static void standard_quality_manager_release_clock(struct quality_manager *manager)
4904 {
4905     if (manager->clock)
4906     {
4907         IMFPresentationClock_RemoveClockStateSink(manager->clock, &manager->IMFClockStateSink_iface);
4908         IMFPresentationClock_Release(manager->clock);
4909     }
4910     manager->clock = NULL;
4911 }
4912
4913 static HRESULT WINAPI standard_quality_manager_NotifyPresentationClock(IMFQualityManager *iface,
4914         IMFPresentationClock *clock)
4915 {
4916     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
4917     HRESULT hr = S_OK;
4918
4919     TRACE("%p, %p.\n", iface, clock);
4920
4921     EnterCriticalSection(&manager->cs);
4922     if (manager->state == QUALITY_MANAGER_SHUT_DOWN)
4923         hr = MF_E_SHUTDOWN;
4924     else if (!clock)
4925         hr = E_POINTER;
4926     else
4927     {
4928         standard_quality_manager_release_clock(manager);
4929         manager->clock = clock;
4930         IMFPresentationClock_AddRef(manager->clock);
4931         if (FAILED(IMFPresentationClock_AddClockStateSink(manager->clock, &manager->IMFClockStateSink_iface)))
4932             WARN("Failed to set state sink.\n");
4933     }
4934     LeaveCriticalSection(&manager->cs);
4935
4936     return hr;
4937 }
4938
4939 static HRESULT WINAPI standard_quality_manager_NotifyProcessInput(IMFQualityManager *iface, IMFTopologyNode *node,
4940         LONG input_index, IMFSample *sample)
4941 {
4942     TRACE("%p, %p, %d, %p stub.\n", iface, node, input_index, sample);
4943
4944     return E_NOTIMPL;
4945 }
4946
4947 static HRESULT WINAPI standard_quality_manager_NotifyProcessOutput(IMFQualityManager *iface, IMFTopologyNode *node,
4948         LONG output_index, IMFSample *sample)
4949 {
4950     TRACE("%p, %p, %d, %p stub.\n", iface, node, output_index, sample);
4951
4952     return E_NOTIMPL;
4953 }
4954
4955 static HRESULT WINAPI standard_quality_manager_NotifyQualityEvent(IMFQualityManager *iface, IUnknown *object,
4956         IMFMediaEvent *event)
4957 {
4958     FIXME("%p, %p, %p stub.\n", iface, object, event);
4959
4960     return E_NOTIMPL;
4961 }
4962
4963 static HRESULT WINAPI standard_quality_manager_Shutdown(IMFQualityManager *iface)
4964 {
4965     struct quality_manager *manager = impl_from_IMFQualityManager(iface);
4966
4967     TRACE("%p.\n", iface);
4968
4969     EnterCriticalSection(&manager->cs);
4970     if (manager->state != QUALITY_MANAGER_SHUT_DOWN)
4971     {
4972         standard_quality_manager_release_clock(manager);
4973         standard_quality_manager_set_topology(manager, NULL);
4974         manager->state = QUALITY_MANAGER_SHUT_DOWN;
4975     }
4976     LeaveCriticalSection(&manager->cs);
4977
4978     return S_OK;
4979 }
4980
4981 static const IMFQualityManagerVtbl standard_quality_manager_vtbl =
4982 {
4983     standard_quality_manager_QueryInterface,
4984     standard_quality_manager_AddRef,
4985     standard_quality_manager_Release,
4986     standard_quality_manager_NotifyTopology,
4987     standard_quality_manager_NotifyPresentationClock,
4988     standard_quality_manager_NotifyProcessInput,
4989     standard_quality_manager_NotifyProcessOutput,
4990     standard_quality_manager_NotifyQualityEvent,
4991     standard_quality_manager_Shutdown,
4992 };
4993
4994 static HRESULT WINAPI standard_quality_manager_sink_QueryInterface(IMFClockStateSink *iface,
4995         REFIID riid, void **obj)
4996 {
4997     struct quality_manager *manager = impl_from_qm_IMFClockStateSink(iface);
4998     return IMFQualityManager_QueryInterface(&manager->IMFQualityManager_iface, riid, obj);
4999 }
5000
5001 static ULONG WINAPI standard_quality_manager_sink_AddRef(IMFClockStateSink *iface)
5002 {
5003     struct quality_manager *manager = impl_from_qm_IMFClockStateSink(iface);
5004     return IMFQualityManager_AddRef(&manager->IMFQualityManager_iface);
5005 }
5006
5007 static ULONG WINAPI standard_quality_manager_sink_Release(IMFClockStateSink *iface)
5008 {
5009     struct quality_manager *manager = impl_from_qm_IMFClockStateSink(iface);
5010     return IMFQualityManager_Release(&manager->IMFQualityManager_iface);
5011 }
5012
5013 static HRESULT WINAPI standard_quality_manager_sink_OnClockStart(IMFClockStateSink *iface,
5014         MFTIME systime, LONGLONG offset)
5015 {
5016     return S_OK;
5017 }
5018
5019 static HRESULT WINAPI standard_quality_manager_sink_OnClockStop(IMFClockStateSink *iface,
5020         MFTIME systime)
5021 {
5022     return S_OK;
5023 }
5024
5025 static HRESULT WINAPI standard_quality_manager_sink_OnClockPause(IMFClockStateSink *iface,
5026         MFTIME systime)
5027 {
5028     return S_OK;
5029 }
5030
5031 static HRESULT WINAPI standard_quality_manager_sink_OnClockRestart(IMFClockStateSink *iface,
5032         MFTIME systime)
5033 {
5034     return S_OK;
5035 }
5036
5037 static HRESULT WINAPI standard_quality_manager_sink_OnClockSetRate(IMFClockStateSink *iface,
5038         MFTIME systime, float rate)
5039 {
5040     return S_OK;
5041 }
5042
5043 static const IMFClockStateSinkVtbl standard_quality_manager_sink_vtbl =
5044 {
5045     standard_quality_manager_sink_QueryInterface,
5046     standard_quality_manager_sink_AddRef,
5047     standard_quality_manager_sink_Release,
5048     standard_quality_manager_sink_OnClockStart,
5049     standard_quality_manager_sink_OnClockStop,
5050     standard_quality_manager_sink_OnClockPause,
5051     standard_quality_manager_sink_OnClockRestart,
5052     standard_quality_manager_sink_OnClockSetRate,
5053 };
5054
5055 HRESULT WINAPI MFCreateStandardQualityManager(IMFQualityManager **manager)
5056 {
5057     struct quality_manager *object;
5058
5059     TRACE("%p.\n", manager);
5060
5061     object = heap_alloc_zero(sizeof(*object));
5062     if (!object)
5063         return E_OUTOFMEMORY;
5064
5065     object->IMFQualityManager_iface.lpVtbl = &standard_quality_manager_vtbl;
5066     object->IMFClockStateSink_iface.lpVtbl = &standard_quality_manager_sink_vtbl;
5067     object->refcount = 1;
5068     InitializeCriticalSection(&object->cs);
5069
5070     *manager = &object->IMFQualityManager_iface;
5071
5072     return S_OK;
5073 }