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