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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "mfidl.h"
  26 #include "mfapi.h"
  27 #include "mferror.h"
  28
  29 #include "wine/debug.h"
  30 #include "wine/heap.h"
  31 #include "wine/list.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  34
  35 enum session_command
  36 {
  37     SESSION_CMD_CLEAR_TOPOLOGIES,
  38     SESSION_CMD_CLOSE,
  39 };
  40
  41 struct session_op
  42 {
  43     IUnknown IUnknown_iface;
  44     LONG refcount;
  45     enum session_command command;
  46 };
  47
  48 struct queued_topology
  49 {
  50     struct list entry;
  51     IMFTopology *topology;
  52 };
  53
  54 enum session_state
  55 {
  56     SESSION_STATE_STOPPED = 0,
  57     SESSION_STATE_CLOSED,
  58     SESSION_STATE_SHUT_DOWN,
  59 };
  60
  61 struct media_session
  62 {
  63     IMFMediaSession IMFMediaSession_iface;
  64     IMFGetService IMFGetService_iface;
  65     IMFRateSupport IMFRateSupport_iface;
  66     IMFRateControl IMFRateControl_iface;
  67     IMFAsyncCallback commands_callback;
  68     LONG refcount;
  69     IMFMediaEventQueue *event_queue;
  70     IMFPresentationClock *clock;
  71     struct list topologies;
  72     enum session_state state;
  73     CRITICAL_SECTION cs;
  74 };
  75
  76 struct clock_sink
  77 {
  78     struct list entry;
  79     IMFClockStateSink *state_sink;
  80 };
  81
  82 enum clock_command
  83 {
  84     CLOCK_CMD_START = 0,
  85     CLOCK_CMD_STOP,
  86     CLOCK_CMD_PAUSE,
  87     CLOCK_CMD_SET_RATE,
  88     CLOCK_CMD_MAX,
  89 };
  90
  91 enum clock_notification
  92 {
  93     CLOCK_NOTIFY_START,
  94     CLOCK_NOTIFY_STOP,
  95     CLOCK_NOTIFY_PAUSE,
  96     CLOCK_NOTIFY_RESTART,
  97     CLOCK_NOTIFY_SET_RATE,
  98 };
  99
 100 struct clock_state_change_param
 101 {
 102     union
 103     {
 104         LONGLONG offset;
 105         float rate;
 106     } u;
 107 };
 108
 109 struct sink_notification
 110 {
 111     IUnknown IUnknown_iface;
 112     LONG refcount;
 113     MFTIME system_time;
 114     struct clock_state_change_param param;
 115     enum clock_notification notification;
 116     IMFClockStateSink *sink;
 117 };
 118
 119 struct presentation_clock
 120 {
 121     IMFPresentationClock IMFPresentationClock_iface;
 122     IMFRateControl IMFRateControl_iface;
 123     IMFTimer IMFTimer_iface;
 124     IMFShutdown IMFShutdown_iface;
 125     IMFAsyncCallback IMFAsyncCallback_iface;
 126     LONG refcount;
 127     IMFPresentationTimeSource *time_source;
 128     IMFClockStateSink *time_source_sink;
 129     MFCLOCK_STATE state;
 130     struct list sinks;
 131     float rate;
 132     CRITICAL_SECTION cs;
 133 };
 134
 135 static inline struct media_session *impl_from_IMFMediaSession(IMFMediaSession *iface)
 136 {
 137     return CONTAINING_RECORD(iface, struct media_session, IMFMediaSession_iface);
 138 }
 139
 140 static struct media_session *impl_from_commands_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
 141 {
 142     return CONTAINING_RECORD(iface, struct media_session, commands_callback);
 143 }
 144
 145 static struct media_session *impl_from_IMFGetService(IMFGetService *iface)
 146 {
 147     return CONTAINING_RECORD(iface, struct media_session, IMFGetService_iface);
 148 }
 149
 150 static struct media_session *impl_session_from_IMFRateSupport(IMFRateSupport *iface)
 151 {
 152     return CONTAINING_RECORD(iface, struct media_session, IMFRateSupport_iface);
 153 }
 154
 155 static struct media_session *impl_session_from_IMFRateControl(IMFRateControl *iface)
 156 {
 157     return CONTAINING_RECORD(iface, struct media_session, IMFRateControl_iface);
 158 }
 159
 160 static struct session_op *impl_op_from_IUnknown(IUnknown *iface)
 161 {
 162     return CONTAINING_RECORD(iface, struct session_op, IUnknown_iface);
 163 }
 164
 165 static struct presentation_clock *impl_from_IMFPresentationClock(IMFPresentationClock *iface)
 166 {
 167     return CONTAINING_RECORD(iface, struct presentation_clock, IMFPresentationClock_iface);
 168 }
 169
 170 static struct presentation_clock *impl_from_IMFRateControl(IMFRateControl *iface)
 171 {
 172     return CONTAINING_RECORD(iface, struct presentation_clock, IMFRateControl_iface);
 173 }
 174
 175 static struct presentation_clock *impl_from_IMFTimer(IMFTimer *iface)
 176 {
 177     return CONTAINING_RECORD(iface, struct presentation_clock, IMFTimer_iface);
 178 }
 179
 180 static struct presentation_clock *impl_from_IMFShutdown(IMFShutdown *iface)
 181 {
 182     return CONTAINING_RECORD(iface, struct presentation_clock, IMFShutdown_iface);
 183 }
 184
 185 static struct presentation_clock *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface)
 186 {
 187     return CONTAINING_RECORD(iface, struct presentation_clock, IMFAsyncCallback_iface);
 188 }
 189
 190 static struct sink_notification *impl_from_IUnknown(IUnknown *iface)
 191 {
 192     return CONTAINING_RECORD(iface, struct sink_notification, IUnknown_iface);
 193 }
 194
 195 static HRESULT WINAPI session_op_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 196 {
 197     if (IsEqualIID(riid, &IID_IUnknown))
 198     {
 199         *obj = iface;
 200         IUnknown_AddRef(iface);
 201         return S_OK;
 202     }
 203
 204     *obj = NULL;
 205     return E_NOINTERFACE;
 206 }
 207
 208 static ULONG WINAPI session_op_AddRef(IUnknown *iface)
 209 {
 210     struct session_op *op = impl_op_from_IUnknown(iface);
 211     ULONG refcount = InterlockedIncrement(&op->refcount);
 212
 213     TRACE("%p, refcount %u.\n", iface, refcount);
 214
 215     return refcount;
 216 }
 217
 218 static ULONG WINAPI session_op_Release(IUnknown *iface)
 219 {
 220     struct session_op *op = impl_op_from_IUnknown(iface);
 221     ULONG refcount = InterlockedDecrement(&op->refcount);
 222
 223     TRACE("%p, refcount %u.\n", iface, refcount);
 224
 225     if (!refcount)
 226     {
 227         heap_free(op);
 228     }
 229
 230     return refcount;
 231 }
 232
 233 static IUnknownVtbl session_op_vtbl =
 234 {
 235     session_op_QueryInterface,
 236     session_op_AddRef,
 237     session_op_Release,
 238 };
 239
 240 static HRESULT create_session_op(enum session_command command, IUnknown **ret)
 241 {
 242     struct session_op *op;
 243
 244     if (!(op = heap_alloc(sizeof(*op))))
 245         return E_OUTOFMEMORY;
 246
 247     op->IUnknown_iface.lpVtbl = &session_op_vtbl;
 248     op->refcount = 1;
 249     op->command = command;
 250
 251     *ret = &op->IUnknown_iface;
 252
 253     return S_OK;
 254 }
 255
 256 static void session_clear_topologies(struct media_session *session)
 257 {
 258     struct queued_topology *ptr, *next;
 259
 260     LIST_FOR_EACH_ENTRY_SAFE(ptr, next, &session->topologies, struct queued_topology, entry)
 261     {
 262         list_remove(&ptr->entry);
 263         IMFTopology_Release(ptr->topology);
 264         heap_free(ptr);
 265     }
 266 }
 267
 268 static HRESULT WINAPI mfsession_QueryInterface(IMFMediaSession *iface, REFIID riid, void **out)
 269 {
 270     struct media_session *session = impl_from_IMFMediaSession(iface);
 271
 272     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), out);
 273
 274     if (IsEqualIID(riid, &IID_IMFMediaSession) ||
 275             IsEqualIID(riid, &IID_IMFMediaEventGenerator) ||
 276             IsEqualIID(riid, &IID_IUnknown))
 277     {
 278         *out = &session->IMFMediaSession_iface;
 279         IMFMediaSession_AddRef(iface);
 280         return S_OK;
 281     }
 282     else if (IsEqualIID(riid, &IID_IMFGetService))
 283     {
 284         *out = &session->IMFGetService_iface;
 285         IMFMediaSession_AddRef(iface);
 286         return S_OK;
 287     }
 288
 289     WARN("Unsupported %s.\n", debugstr_guid(riid));
 290     *out = NULL;
 291     return E_NOINTERFACE;
 292 }
 293
 294 static ULONG WINAPI mfsession_AddRef(IMFMediaSession *iface)
 295 {
 296     struct media_session *session = impl_from_IMFMediaSession(iface);
 297     ULONG refcount = InterlockedIncrement(&session->refcount);
 298
 299     TRACE("(%p) refcount=%u\n", iface, refcount);
 300
 301     return refcount;
 302 }
 303
 304 static ULONG WINAPI mfsession_Release(IMFMediaSession *iface)
 305 {
 306     struct media_session *session = impl_from_IMFMediaSession(iface);
 307     ULONG refcount = InterlockedDecrement(&session->refcount);
 308
 309     TRACE("(%p) refcount=%u\n", iface, refcount);
 310
 311     if (!refcount)
 312     {
 313         session_clear_topologies(session);
 314         if (session->event_queue)
 315             IMFMediaEventQueue_Release(session->event_queue);
 316         if (session->clock)
 317             IMFPresentationClock_Release(session->clock);
 318         DeleteCriticalSection(&session->cs);
 319         heap_free(session);
 320     }
 321
 322     return refcount;
 323 }
 324
 325 static HRESULT WINAPI mfsession_GetEvent(IMFMediaSession *iface, DWORD flags, IMFMediaEvent **event)
 326 {
 327     struct media_session *session = impl_from_IMFMediaSession(iface);
 328
 329     TRACE("(%p)->(%#x, %p)\n", iface, flags, event);
 330
 331     return IMFMediaEventQueue_GetEvent(session->event_queue, flags, event);
 332 }
 333
 334 static HRESULT WINAPI mfsession_BeginGetEvent(IMFMediaSession *iface, IMFAsyncCallback *callback, IUnknown *state)
 335 {
 336     struct media_session *session = impl_from_IMFMediaSession(iface);
 337
 338     TRACE("(%p)->(%p, %p)\n", iface, callback, state);
 339
 340     return IMFMediaEventQueue_BeginGetEvent(session->event_queue, callback, state);
 341 }
 342
 343 static HRESULT WINAPI mfsession_EndGetEvent(IMFMediaSession *iface, IMFAsyncResult *result, IMFMediaEvent **event)
 344 {
 345     struct media_session *session = impl_from_IMFMediaSession(iface);
 346
 347     TRACE("(%p)->(%p, %p)\n", iface, result, event);
 348
 349     return IMFMediaEventQueue_EndGetEvent(session->event_queue, result, event);
 350 }
 351
 352 static HRESULT WINAPI mfsession_QueueEvent(IMFMediaSession *iface, MediaEventType event_type, REFGUID ext_type,
 353         HRESULT hr, const PROPVARIANT *value)
 354 {
 355     struct media_session *session = impl_from_IMFMediaSession(iface);
 356
 357     TRACE("(%p)->(%d, %s, %#x, %p)\n", iface, event_type, debugstr_guid(ext_type), hr, value);
 358
 359     return IMFMediaEventQueue_QueueEventParamVar(session->event_queue, event_type, ext_type, hr, value);
 360 }
 361
 362 static HRESULT WINAPI mfsession_SetTopology(IMFMediaSession *iface, DWORD flags, IMFTopology *topology)
 363 {
 364     struct media_session *session = impl_from_IMFMediaSession(iface);
 365     struct queued_topology *queued_topology;
 366
 367     FIXME("%p, %#x, %p.\n", iface, flags, topology);
 368
 369     if (!(queued_topology = heap_alloc(sizeof(*queued_topology))))
 370         return E_OUTOFMEMORY;
 371
 372     queued_topology->topology = topology;
 373     IMFTopology_AddRef(queued_topology->topology);
 374
 375     EnterCriticalSection(&session->cs);
 376     list_add_tail(&session->topologies, &queued_topology->entry);
 377     LeaveCriticalSection(&session->cs);
 378
 379     return S_OK;
 380 }
 381
 382 static HRESULT session_submit_command(struct media_session *session, IUnknown *op)
 383 {
 384     HRESULT hr;
 385
 386     EnterCriticalSection(&session->cs);
 387     if (session->state == SESSION_STATE_SHUT_DOWN)
 388         hr = MF_E_SHUTDOWN;
 389     else
 390         hr = MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_STANDARD, &session->commands_callback, op);
 391     LeaveCriticalSection(&session->cs);
 392
 393     return hr;
 394 }
 395
 396 static HRESULT WINAPI mfsession_ClearTopologies(IMFMediaSession *iface)
 397 {
 398     struct media_session *session = impl_from_IMFMediaSession(iface);
 399     IUnknown *op;
 400     HRESULT hr;
 401
 402     TRACE("%p.\n", iface);
 403
 404     if (FAILED(hr = create_session_op(SESSION_CMD_CLEAR_TOPOLOGIES, &op)))
 405         return hr;
 406
 407     hr = session_submit_command(session, op);
 408     IUnknown_Release(op);
 409
 410     return hr;
 411 }
 412
 413 static HRESULT WINAPI mfsession_Start(IMFMediaSession *iface, const GUID *format, const PROPVARIANT *start)
 414 {
 415     FIXME("(%p)->(%s, %p)\n", iface, debugstr_guid(format), start);
 416
 417     return E_NOTIMPL;
 418 }
 419
 420 static HRESULT WINAPI mfsession_Pause(IMFMediaSession *iface)
 421 {
 422     FIXME("(%p)\n", iface);
 423
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI mfsession_Stop(IMFMediaSession *iface)
 428 {
 429     FIXME("(%p)\n", iface);
 430
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI mfsession_Close(IMFMediaSession *iface)
 435 {
 436     struct media_session *session = impl_from_IMFMediaSession(iface);
 437     IUnknown *op;
 438     HRESULT hr;
 439
 440     TRACE("(%p)\n", iface);
 441
 442     if (FAILED(hr = create_session_op(SESSION_CMD_CLOSE, &op)))
 443         return hr;
 444
 445     hr = session_submit_command(session, op);
 446     IUnknown_Release(op);
 447
 448     return hr;
 449 }
 450
 451 static HRESULT WINAPI mfsession_Shutdown(IMFMediaSession *iface)
 452 {
 453     struct media_session *session = impl_from_IMFMediaSession(iface);
 454     HRESULT hr = S_OK;
 455
 456     FIXME("(%p)\n", iface);
 457
 458     EnterCriticalSection(&session->cs);
 459     if (session->state == SESSION_STATE_SHUT_DOWN)
 460         hr = MF_E_SHUTDOWN;
 461     else
 462     {
 463         session->state = SESSION_STATE_SHUT_DOWN;
 464         IMFMediaEventQueue_Shutdown(session->event_queue);
 465     }
 466     LeaveCriticalSection(&session->cs);
 467
 468     return hr;
 469 }
 470
 471 static HRESULT WINAPI mfsession_GetClock(IMFMediaSession *iface, IMFClock **clock)
 472 {
 473     struct media_session *session = impl_from_IMFMediaSession(iface);
 474
 475     TRACE("%p, %p.\n", iface, clock);
 476
 477     *clock = (IMFClock *)session->clock;
 478     IMFClock_AddRef(*clock);
 479
 480     return S_OK;
 481 }
 482
 483 static HRESULT WINAPI mfsession_GetSessionCapabilities(IMFMediaSession *iface, DWORD *caps)
 484 {
 485     FIXME("(%p)->(%p)\n", iface, caps);
 486
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI mfsession_GetFullTopology(IMFMediaSession *iface, DWORD flags, TOPOID id, IMFTopology **topology)
 491 {
 492     FIXME("(%p)->(%#x, %s, %p)\n", iface, flags, wine_dbgstr_longlong(id), topology);
 493
 494     return E_NOTIMPL;
 495 }
 496
 497 static const IMFMediaSessionVtbl mfmediasessionvtbl =
 498 {
 499     mfsession_QueryInterface,
 500     mfsession_AddRef,
 501     mfsession_Release,
 502     mfsession_GetEvent,
 503     mfsession_BeginGetEvent,
 504     mfsession_EndGetEvent,
 505     mfsession_QueueEvent,
 506     mfsession_SetTopology,
 507     mfsession_ClearTopologies,
 508     mfsession_Start,
 509     mfsession_Pause,
 510     mfsession_Stop,
 511     mfsession_Close,
 512     mfsession_Shutdown,
 513     mfsession_GetClock,
 514     mfsession_GetSessionCapabilities,
 515     mfsession_GetFullTopology,
 516 };
 517
 518 static HRESULT WINAPI session_get_service_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 519 {
 520     struct media_session *session = impl_from_IMFGetService(iface);
 521     return IMFMediaSession_QueryInterface(&session->IMFMediaSession_iface, riid, obj);
 522 }
 523
 524 static ULONG WINAPI session_get_service_AddRef(IMFGetService *iface)
 525 {
 526     struct media_session *session = impl_from_IMFGetService(iface);
 527     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
 528 }
 529
 530 static ULONG WINAPI session_get_service_Release(IMFGetService *iface)
 531 {
 532     struct media_session *session = impl_from_IMFGetService(iface);
 533     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
 534 }
 535
 536 static HRESULT WINAPI session_get_service_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 537 {
 538     struct media_session *session = impl_from_IMFGetService(iface);
 539
 540     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 541
 542     *obj = NULL;
 543
 544     if (IsEqualGUID(service, &MF_RATE_CONTROL_SERVICE))
 545     {
 546         if (IsEqualIID(riid, &IID_IMFRateSupport))
 547         {
 548             *obj = &session->IMFRateSupport_iface;
 549         }
 550         else if (IsEqualIID(riid, &IID_IMFRateControl))
 551         {
 552             *obj = &session->IMFRateControl_iface;
 553         }
 554
 555         if (*obj)
 556             IUnknown_AddRef((IUnknown *)*obj);
 557
 558         return *obj ? S_OK : E_NOINTERFACE;
 559     }
 560     else
 561         FIXME("Unsupported service %s.\n", debugstr_guid(service));
 562
 563     return E_NOTIMPL;
 564 }
 565
 566 static const IMFGetServiceVtbl session_get_service_vtbl =
 567 {
 568     session_get_service_QueryInterface,
 569     session_get_service_AddRef,
 570     session_get_service_Release,
 571     session_get_service_GetService,
 572 };
 573
 574 static HRESULT WINAPI session_commands_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj)
 575 {
 576     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 577             IsEqualIID(riid, &IID_IUnknown))
 578     {
 579         *obj = iface;
 580         IMFAsyncCallback_AddRef(iface);
 581         return S_OK;
 582     }
 583
 584     WARN("Unsupported %s.\n", debugstr_guid(riid));
 585     *obj = NULL;
 586     return E_NOINTERFACE;
 587 }
 588
 589 static ULONG WINAPI session_commands_callback_AddRef(IMFAsyncCallback *iface)
 590 {
 591     struct media_session *session = impl_from_commands_callback_IMFAsyncCallback(iface);
 592     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
 593 }
 594
 595 static ULONG WINAPI session_commands_callback_Release(IMFAsyncCallback *iface)
 596 {
 597     struct media_session *session = impl_from_commands_callback_IMFAsyncCallback(iface);
 598     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
 599 }
 600
 601 static HRESULT WINAPI session_commands_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
 602 {
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI session_commands_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 607 {
 608     struct session_op *op = impl_op_from_IUnknown(IMFAsyncResult_GetStateNoAddRef(result));
 609     struct media_session *session = impl_from_commands_callback_IMFAsyncCallback(iface);
 610
 611     switch (op->command)
 612     {
 613         case SESSION_CMD_CLEAR_TOPOLOGIES:
 614             EnterCriticalSection(&session->cs);
 615             session_clear_topologies(session);
 616             LeaveCriticalSection(&session->cs);
 617
 618             IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionTopologiesCleared, &GUID_NULL,
 619                     S_OK, NULL);
 620             break;
 621         case SESSION_CMD_CLOSE:
 622             EnterCriticalSection(&session->cs);
 623             if (session->state != SESSION_STATE_CLOSED)
 624             {
 625                 /* FIXME: actually do something to presentation objects */
 626                 session->state = SESSION_STATE_CLOSED;
 627                 IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MESessionClosed, &GUID_NULL, S_OK, NULL);
 628             }
 629             LeaveCriticalSection(&session->cs);
 630             break;
 631         default:
 632             ;
 633     }
 634
 635     return S_OK;
 636 }
 637
 638 static const IMFAsyncCallbackVtbl session_commands_callback_vtbl =
 639 {
 640     session_commands_callback_QueryInterface,
 641     session_commands_callback_AddRef,
 642     session_commands_callback_Release,
 643     session_commands_callback_GetParameters,
 644     session_commands_callback_Invoke,
 645 };
 646
 647 static HRESULT WINAPI session_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
 648 {
 649     struct media_session *session = impl_session_from_IMFRateSupport(iface);
 650     return IMFMediaSession_QueryInterface(&session->IMFMediaSession_iface, riid, obj);
 651 }
 652
 653 static ULONG WINAPI session_rate_support_AddRef(IMFRateSupport *iface)
 654 {
 655     struct media_session *session = impl_session_from_IMFRateSupport(iface);
 656     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
 657 }
 658
 659 static ULONG WINAPI session_rate_support_Release(IMFRateSupport *iface)
 660 {
 661     struct media_session *session = impl_session_from_IMFRateSupport(iface);
 662     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
 663 }
 664
 665 static HRESULT WINAPI session_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
 666         BOOL thin, float *rate)
 667 {
 668     FIXME("%p, %d, %d, %p.\n", iface, direction, thin, rate);
 669
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI session_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
 674         BOOL thin, float *rate)
 675 {
 676     FIXME("%p, %d, %d, %p.\n", iface, direction, thin, rate);
 677
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI session_rate_support_IsSupported(IMFRateSupport *iface, BOOL thin, float rate,
 682         float *nearest_supported_rate)
 683 {
 684     FIXME("%p, %d, %f, %p.\n", iface, thin, rate, nearest_supported_rate);
 685
 686     return E_NOTIMPL;
 687 }
 688
 689 static const IMFRateSupportVtbl session_rate_support_vtbl =
 690 {
 691     session_rate_support_QueryInterface,
 692     session_rate_support_AddRef,
 693     session_rate_support_Release,
 694     session_rate_support_GetSlowestRate,
 695     session_rate_support_GetFastestRate,
 696     session_rate_support_IsSupported,
 697 };
 698
 699 static HRESULT WINAPI session_rate_control_QueryInterface(IMFRateControl *iface, REFIID riid, void **obj)
 700 {
 701     struct media_session *session = impl_session_from_IMFRateControl(iface);
 702     return IMFMediaSession_QueryInterface(&session->IMFMediaSession_iface, riid, obj);
 703 }
 704
 705 static ULONG WINAPI session_rate_control_AddRef(IMFRateControl *iface)
 706 {
 707     struct media_session *session = impl_session_from_IMFRateControl(iface);
 708     return IMFMediaSession_AddRef(&session->IMFMediaSession_iface);
 709 }
 710
 711 static ULONG WINAPI session_rate_control_Release(IMFRateControl *iface)
 712 {
 713     struct media_session *session = impl_session_from_IMFRateControl(iface);
 714     return IMFMediaSession_Release(&session->IMFMediaSession_iface);
 715 }
 716
 717 static HRESULT WINAPI session_rate_control_SetRate(IMFRateControl *iface, BOOL thin, float rate)
 718 {
 719     FIXME("%p, %d, %f.\n", iface, thin, rate);
 720
 721     return E_NOTIMPL;
 722 }
 723
 724 static HRESULT WINAPI session_rate_control_GetRate(IMFRateControl *iface, BOOL *thin, float *rate)
 725 {
 726     FIXME("%p, %p, %p.\n", iface, thin, rate);
 727
 728     return E_NOTIMPL;
 729 }
 730
 731 static const IMFRateControlVtbl session_rate_control_vtbl =
 732 {
 733     session_rate_control_QueryInterface,
 734     session_rate_control_AddRef,
 735     session_rate_control_Release,
 736     session_rate_control_SetRate,
 737     session_rate_control_GetRate,
 738 };
 739
 740 /***********************************************************************
 741  *      MFCreateMediaSession (mf.@)
 742  */
 743 HRESULT WINAPI MFCreateMediaSession(IMFAttributes *config, IMFMediaSession **session)
 744 {
 745     struct media_session *object;
 746     HRESULT hr;
 747
 748     TRACE("(%p, %p)\n", config, session);
 749
 750     if (config)
 751         FIXME("session configuration ignored\n");
 752
 753     object = heap_alloc_zero(sizeof(*object));
 754     if (!object)
 755         return E_OUTOFMEMORY;
 756
 757     object->IMFMediaSession_iface.lpVtbl = &mfmediasessionvtbl;
 758     object->IMFGetService_iface.lpVtbl = &session_get_service_vtbl;
 759     object->IMFRateSupport_iface.lpVtbl = &session_rate_support_vtbl;
 760     object->IMFRateControl_iface.lpVtbl = &session_rate_control_vtbl;
 761     object->commands_callback.lpVtbl = &session_commands_callback_vtbl;
 762     object->refcount = 1;
 763     list_init(&object->topologies);
 764     InitializeCriticalSection(&object->cs);
 765
 766     if (FAILED(hr = MFCreateEventQueue(&object->event_queue)))
 767         goto failed;
 768
 769     if (FAILED(hr = MFCreatePresentationClock(&object->clock)))
 770         goto failed;
 771
 772     *session = &object->IMFMediaSession_iface;
 773
 774     return S_OK;
 775
 776 failed:
 777     IMFMediaSession_Release(&object->IMFMediaSession_iface);
 778     return hr;
 779 }
 780
 781 static HRESULT WINAPI present_clock_QueryInterface(IMFPresentationClock *iface, REFIID riid, void **out)
 782 {
 783     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 784
 785     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 786
 787     if (IsEqualIID(riid, &IID_IMFPresentationClock) ||
 788             IsEqualIID(riid, &IID_IMFClock) ||
 789             IsEqualIID(riid, &IID_IUnknown))
 790     {
 791         *out = &clock->IMFPresentationClock_iface;
 792     }
 793     else if (IsEqualIID(riid, &IID_IMFRateControl))
 794     {
 795         *out = &clock->IMFRateControl_iface;
 796     }
 797     else if (IsEqualIID(riid, &IID_IMFTimer))
 798     {
 799         *out = &clock->IMFTimer_iface;
 800     }
 801     else if (IsEqualIID(riid, &IID_IMFShutdown))
 802     {
 803         *out = &clock->IMFShutdown_iface;
 804     }
 805     else
 806     {
 807         WARN("Unsupported %s.\n", debugstr_guid(riid));
 808         *out = NULL;
 809         return E_NOINTERFACE;
 810     }
 811
 812     IUnknown_AddRef((IUnknown *)*out);
 813     return S_OK;
 814 }
 815
 816 static ULONG WINAPI present_clock_AddRef(IMFPresentationClock *iface)
 817 {
 818     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 819     ULONG refcount = InterlockedIncrement(&clock->refcount);
 820
 821     TRACE("%p, refcount %u.\n", iface, refcount);
 822
 823     return refcount;
 824 }
 825
 826 static ULONG WINAPI present_clock_Release(IMFPresentationClock *iface)
 827 {
 828     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 829     ULONG refcount = InterlockedDecrement(&clock->refcount);
 830     struct clock_sink *sink, *sink2;
 831
 832     TRACE("%p, refcount %u.\n", iface, refcount);
 833
 834     if (!refcount)
 835     {
 836         if (clock->time_source)
 837             IMFPresentationTimeSource_Release(clock->time_source);
 838         if (clock->time_source_sink)
 839             IMFClockStateSink_Release(clock->time_source_sink);
 840         LIST_FOR_EACH_ENTRY_SAFE(sink, sink2, &clock->sinks, struct clock_sink, entry)
 841         {
 842             list_remove(&sink->entry);
 843             IMFClockStateSink_Release(sink->state_sink);
 844             heap_free(sink);
 845         }
 846         DeleteCriticalSection(&clock->cs);
 847         heap_free(clock);
 848     }
 849
 850     return refcount;
 851 }
 852
 853 static HRESULT WINAPI present_clock_GetClockCharacteristics(IMFPresentationClock *iface, DWORD *flags)
 854 {
 855     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 856     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
 857
 858     TRACE("%p, %p.\n", iface, flags);
 859
 860     EnterCriticalSection(&clock->cs);
 861     if (clock->time_source)
 862         hr = IMFPresentationTimeSource_GetClockCharacteristics(clock->time_source, flags);
 863     LeaveCriticalSection(&clock->cs);
 864
 865     return hr;
 866 }
 867
 868 static HRESULT WINAPI present_clock_GetCorrelatedTime(IMFPresentationClock *iface, DWORD reserved,
 869         LONGLONG *clock_time, MFTIME *system_time)
 870 {
 871     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 872     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
 873
 874     TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time);
 875
 876     EnterCriticalSection(&clock->cs);
 877     if (clock->time_source)
 878         hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, reserved, clock_time, system_time);
 879     LeaveCriticalSection(&clock->cs);
 880
 881     return hr;
 882 }
 883
 884 static HRESULT WINAPI present_clock_GetContinuityKey(IMFPresentationClock *iface, DWORD *key)
 885 {
 886     TRACE("%p, %p.\n", iface, key);
 887
 888     *key = 0;
 889
 890     return S_OK;
 891 }
 892
 893 static HRESULT WINAPI present_clock_GetState(IMFPresentationClock *iface, DWORD reserved, MFCLOCK_STATE *state)
 894 {
 895     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 896
 897     TRACE("%p, %#x, %p.\n", iface, reserved, state);
 898
 899     EnterCriticalSection(&clock->cs);
 900     *state = clock->state;
 901     LeaveCriticalSection(&clock->cs);
 902
 903     return S_OK;
 904 }
 905
 906 static HRESULT WINAPI present_clock_GetProperties(IMFPresentationClock *iface, MFCLOCK_PROPERTIES *props)
 907 {
 908     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 909     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
 910
 911     TRACE("%p, %p.\n", iface, props);
 912
 913     EnterCriticalSection(&clock->cs);
 914     if (clock->time_source)
 915         hr = IMFPresentationTimeSource_GetProperties(clock->time_source, props);
 916     LeaveCriticalSection(&clock->cs);
 917
 918     return hr;
 919 }
 920
 921 static HRESULT WINAPI present_clock_SetTimeSource(IMFPresentationClock *iface,
 922         IMFPresentationTimeSource *time_source)
 923 {
 924     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 925     HRESULT hr;
 926
 927     TRACE("%p, %p.\n", iface, time_source);
 928
 929     EnterCriticalSection(&clock->cs);
 930     if (clock->time_source)
 931         IMFPresentationTimeSource_Release(clock->time_source);
 932     if (clock->time_source_sink)
 933         IMFClockStateSink_Release(clock->time_source_sink);
 934     clock->time_source = NULL;
 935     clock->time_source_sink = NULL;
 936
 937     hr = IMFPresentationTimeSource_QueryInterface(time_source, &IID_IMFClockStateSink, (void **)&clock->time_source_sink);
 938     if (SUCCEEDED(hr))
 939     {
 940         clock->time_source = time_source;
 941         IMFPresentationTimeSource_AddRef(clock->time_source);
 942     }
 943
 944     LeaveCriticalSection(&clock->cs);
 945
 946     return hr;
 947 }
 948
 949 static HRESULT WINAPI present_clock_GetTimeSource(IMFPresentationClock *iface,
 950         IMFPresentationTimeSource **time_source)
 951 {
 952     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 953     HRESULT hr = S_OK;
 954
 955     TRACE("%p, %p.\n", iface, time_source);
 956
 957     if (!time_source)
 958         return E_INVALIDARG;
 959
 960     EnterCriticalSection(&clock->cs);
 961     if (clock->time_source)
 962     {
 963         *time_source = clock->time_source;
 964         IMFPresentationTimeSource_AddRef(*time_source);
 965     }
 966     else
 967         hr = MF_E_CLOCK_NO_TIME_SOURCE;
 968     LeaveCriticalSection(&clock->cs);
 969
 970     return hr;
 971 }
 972
 973 static HRESULT WINAPI present_clock_GetTime(IMFPresentationClock *iface, MFTIME *time)
 974 {
 975     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 976     HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE;
 977     MFTIME systime;
 978
 979     TRACE("%p, %p.\n", iface, time);
 980
 981     if (!time)
 982         return E_POINTER;
 983
 984     EnterCriticalSection(&clock->cs);
 985     if (clock->time_source)
 986         hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, 0, time, &systime);
 987     LeaveCriticalSection(&clock->cs);
 988
 989     return hr;
 990 }
 991
 992 static HRESULT WINAPI present_clock_AddClockStateSink(IMFPresentationClock *iface, IMFClockStateSink *state_sink)
 993 {
 994     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
 995     struct clock_sink *sink, *cur;
 996     HRESULT hr = S_OK;
 997
 998     TRACE("%p, %p.\n", iface, state_sink);
 999
1000     if (!state_sink)
1001         return E_INVALIDARG;
1002
1003     sink = heap_alloc(sizeof(*sink));
1004     if (!sink)
1005         return E_OUTOFMEMORY;
1006
1007     sink->state_sink = state_sink;
1008     IMFClockStateSink_AddRef(sink->state_sink);
1009
1010     EnterCriticalSection(&clock->cs);
1011     LIST_FOR_EACH_ENTRY(cur, &clock->sinks, struct clock_sink, entry)
1012     {
1013         if (cur->state_sink == state_sink)
1014         {
1015             hr = E_INVALIDARG;
1016             break;
1017         }
1018     }
1019     if (SUCCEEDED(hr))
1020         list_add_tail(&clock->sinks, &sink->entry);
1021     LeaveCriticalSection(&clock->cs);
1022
1023     if (FAILED(hr))
1024     {
1025         IMFClockStateSink_Release(sink->state_sink);
1026         heap_free(sink);
1027     }
1028
1029     return hr;
1030 }
1031
1032 static HRESULT WINAPI present_clock_RemoveClockStateSink(IMFPresentationClock *iface,
1033         IMFClockStateSink *state_sink)
1034 {
1035     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
1036     struct clock_sink *sink;
1037
1038     TRACE("%p, %p.\n", iface, state_sink);
1039
1040     if (!state_sink)
1041         return E_INVALIDARG;
1042
1043     EnterCriticalSection(&clock->cs);
1044     LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry)
1045     {
1046         if (sink->state_sink == state_sink)
1047         {
1048             IMFClockStateSink_Release(sink->state_sink);
1049             list_remove(&sink->entry);
1050             heap_free(sink);
1051             break;
1052         }
1053     }
1054     LeaveCriticalSection(&clock->cs);
1055
1056     return S_OK;
1057 }
1058
1059 static HRESULT WINAPI sink_notification_QueryInterface(IUnknown *iface, REFIID riid, void **out)
1060 {
1061     if (IsEqualIID(riid, &IID_IUnknown))
1062     {
1063         *out = iface;
1064         IUnknown_AddRef(iface);
1065         return S_OK;
1066     }
1067
1068     WARN("Unsupported %s.\n", debugstr_guid(riid));
1069     *out = NULL;
1070     return E_NOINTERFACE;
1071 }
1072
1073 static ULONG WINAPI sink_notification_AddRef(IUnknown *iface)
1074 {
1075     struct sink_notification *notification = impl_from_IUnknown(iface);
1076     ULONG refcount = InterlockedIncrement(&notification->refcount);
1077
1078     TRACE("%p, refcount %u.\n", iface, refcount);
1079
1080     return refcount;
1081 }
1082
1083 static ULONG WINAPI sink_notification_Release(IUnknown *iface)
1084 {
1085     struct sink_notification *notification = impl_from_IUnknown(iface);
1086     ULONG refcount = InterlockedDecrement(&notification->refcount);
1087
1088     TRACE("%p, refcount %u.\n", iface, refcount);
1089
1090     if (!refcount)
1091     {
1092         IMFClockStateSink_Release(notification->sink);
1093         heap_free(notification);
1094     }
1095
1096     return refcount;
1097 }
1098
1099 static const IUnknownVtbl sinknotificationvtbl =
1100 {
1101     sink_notification_QueryInterface,
1102     sink_notification_AddRef,
1103     sink_notification_Release,
1104 };
1105
1106 static HRESULT create_sink_notification(MFTIME system_time, struct clock_state_change_param param,
1107         enum clock_notification notification, IMFClockStateSink *sink, IUnknown **out)
1108 {
1109     struct sink_notification *object;
1110
1111     object = heap_alloc(sizeof(*object));
1112     if (!object)
1113         return E_OUTOFMEMORY;
1114
1115     object->IUnknown_iface.lpVtbl = &sinknotificationvtbl;
1116     object->refcount = 1;
1117     object->system_time = system_time;
1118     object->param = param;
1119     object->notification = notification;
1120     object->sink = sink;
1121     IMFClockStateSink_AddRef(object->sink);
1122
1123     *out = &object->IUnknown_iface;
1124
1125     return S_OK;
1126 }
1127
1128 static HRESULT clock_call_state_change(MFTIME system_time, struct clock_state_change_param param,
1129         enum clock_notification notification, IMFClockStateSink *sink)
1130 {
1131     HRESULT hr = S_OK;
1132
1133     switch (notification)
1134     {
1135         case CLOCK_NOTIFY_START:
1136             hr = IMFClockStateSink_OnClockStart(sink, system_time, param.u.offset);
1137             break;
1138         case CLOCK_NOTIFY_STOP:
1139             hr = IMFClockStateSink_OnClockStop(sink, system_time);
1140             break;
1141         case CLOCK_NOTIFY_PAUSE:
1142             hr = IMFClockStateSink_OnClockPause(sink, system_time);
1143             break;
1144         case CLOCK_NOTIFY_RESTART:
1145             hr = IMFClockStateSink_OnClockRestart(sink, system_time);
1146             break;
1147         case CLOCK_NOTIFY_SET_RATE:
1148             /* System time source does not allow 0.0 rate, presentation clock allows it without raising errors. */
1149             IMFClockStateSink_OnClockSetRate(sink, system_time, param.u.rate);
1150             break;
1151         default:
1152             ;
1153     }
1154
1155     return hr;
1156 }
1157
1158 static HRESULT clock_change_state(struct presentation_clock *clock, enum clock_command command,
1159         struct clock_state_change_param param)
1160 {
1161     static const BYTE state_change_is_allowed[MFCLOCK_STATE_PAUSED+1][CLOCK_CMD_MAX] =
1162     {   /*              S  S* P, R  */
1163         /* INVALID */ { 1, 1, 1, 1 },
1164         /* RUNNING */ { 1, 1, 1, 1 },
1165         /* STOPPED */ { 1, 1, 0, 1 },
1166         /* PAUSED  */ { 1, 1, 0, 1 },
1167     };
1168     static const MFCLOCK_STATE states[CLOCK_CMD_MAX] =
1169     {
1170         /* CLOCK_CMD_START    */ MFCLOCK_STATE_RUNNING,
1171         /* CLOCK_CMD_STOP     */ MFCLOCK_STATE_STOPPED,
1172         /* CLOCK_CMD_PAUSE    */ MFCLOCK_STATE_PAUSED,
1173         /* CLOCK_CMD_SET_RATE */ 0, /* Unused */
1174     };
1175     enum clock_notification notification;
1176     struct clock_sink *sink;
1177     IUnknown *notify_object;
1178     IMFAsyncResult *result;
1179     MFTIME system_time;
1180     HRESULT hr;
1181
1182     if (command != CLOCK_CMD_SET_RATE && clock->state == states[command] && clock->state != MFCLOCK_STATE_RUNNING)
1183         return MF_E_CLOCK_STATE_ALREADY_SET;
1184
1185     if (!state_change_is_allowed[clock->state][command])
1186         return MF_E_INVALIDREQUEST;
1187
1188     system_time = MFGetSystemTime();
1189
1190     switch (command)
1191     {
1192         case CLOCK_CMD_START:
1193             if (clock->state == MFCLOCK_STATE_PAUSED && param.u.offset == PRESENTATION_CURRENT_POSITION)
1194                 notification = CLOCK_NOTIFY_RESTART;
1195             else
1196                 notification = CLOCK_NOTIFY_START;
1197             break;
1198         case CLOCK_CMD_STOP:
1199             notification = CLOCK_NOTIFY_STOP;
1200             break;
1201         case CLOCK_CMD_PAUSE:
1202             notification = CLOCK_NOTIFY_PAUSE;
1203             break;
1204         case CLOCK_CMD_SET_RATE:
1205             notification = CLOCK_NOTIFY_SET_RATE;
1206             break;
1207         default:
1208             ;
1209     }
1210
1211     if (FAILED(hr = clock_call_state_change(system_time, param, notification, clock->time_source_sink)))
1212         return hr;
1213
1214     clock->state = states[command];
1215
1216     LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry)
1217     {
1218         if (SUCCEEDED(create_sink_notification(system_time, param, notification, sink->state_sink, &notify_object)))
1219         {
1220             hr = MFCreateAsyncResult(notify_object, &clock->IMFAsyncCallback_iface, NULL, &result);
1221             IUnknown_Release(notify_object);
1222             if (SUCCEEDED(hr))
1223             {
1224                 MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_STANDARD, result);
1225                 IMFAsyncResult_Release(result);
1226             }
1227         }
1228     }
1229
1230     return S_OK;
1231 }
1232
1233 static HRESULT WINAPI present_clock_Start(IMFPresentationClock *iface, LONGLONG start_offset)
1234 {
1235     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
1236     struct clock_state_change_param param = {{0}};
1237     HRESULT hr;
1238
1239     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(start_offset));
1240
1241     EnterCriticalSection(&clock->cs);
1242     param.u.offset = start_offset;
1243     hr = clock_change_state(clock, CLOCK_CMD_START, param);
1244     LeaveCriticalSection(&clock->cs);
1245
1246     return hr;
1247 }
1248
1249 static HRESULT WINAPI present_clock_Stop(IMFPresentationClock *iface)
1250 {
1251     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
1252     struct clock_state_change_param param = {{0}};
1253     HRESULT hr;
1254
1255     TRACE("%p.\n", iface);
1256
1257     EnterCriticalSection(&clock->cs);
1258     hr = clock_change_state(clock, CLOCK_CMD_STOP, param);
1259     LeaveCriticalSection(&clock->cs);
1260
1261     return hr;
1262 }
1263
1264 static HRESULT WINAPI present_clock_Pause(IMFPresentationClock *iface)
1265 {
1266     struct presentation_clock *clock = impl_from_IMFPresentationClock(iface);
1267     struct clock_state_change_param param = {{0}};
1268     HRESULT hr;
1269
1270     TRACE("%p.\n", iface);
1271
1272     EnterCriticalSection(&clock->cs);
1273     hr = clock_change_state(clock, CLOCK_CMD_PAUSE, param);
1274     LeaveCriticalSection(&clock->cs);
1275
1276     return hr;
1277 }
1278
1279 static const IMFPresentationClockVtbl presentationclockvtbl =
1280 {
1281     present_clock_QueryInterface,
1282     present_clock_AddRef,
1283     present_clock_Release,
1284     present_clock_GetClockCharacteristics,
1285     present_clock_GetCorrelatedTime,
1286     present_clock_GetContinuityKey,
1287     present_clock_GetState,
1288     present_clock_GetProperties,
1289     present_clock_SetTimeSource,
1290     present_clock_GetTimeSource,
1291     present_clock_GetTime,
1292     present_clock_AddClockStateSink,
1293     present_clock_RemoveClockStateSink,
1294     present_clock_Start,
1295     present_clock_Stop,
1296     present_clock_Pause,
1297 };
1298
1299 static HRESULT WINAPI present_clock_rate_control_QueryInterface(IMFRateControl *iface, REFIID riid, void **out)
1300 {
1301     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
1302     return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out);
1303 }
1304
1305 static ULONG WINAPI present_clock_rate_control_AddRef(IMFRateControl *iface)
1306 {
1307     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
1308     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
1309 }
1310
1311 static ULONG WINAPI present_clock_rate_control_Release(IMFRateControl *iface)
1312 {
1313     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
1314     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
1315 }
1316
1317 static HRESULT WINAPI present_clock_rate_SetRate(IMFRateControl *iface, BOOL thin, float rate)
1318 {
1319     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
1320     struct clock_state_change_param param;
1321     HRESULT hr;
1322
1323     TRACE("%p, %d, %f.\n", iface, thin, rate);
1324
1325     if (thin)
1326         return MF_E_THINNING_UNSUPPORTED;
1327
1328     EnterCriticalSection(&clock->cs);
1329     param.u.rate = rate;
1330     if (SUCCEEDED(hr = clock_change_state(clock, CLOCK_CMD_SET_RATE, param)))
1331         clock->rate = rate;
1332     LeaveCriticalSection(&clock->cs);
1333
1334     return hr;
1335 }
1336
1337 static HRESULT WINAPI present_clock_rate_GetRate(IMFRateControl *iface, BOOL *thin, float *rate)
1338 {
1339     struct presentation_clock *clock = impl_from_IMFRateControl(iface);
1340
1341     TRACE("%p, %p, %p.\n", iface, thin, rate);
1342
1343     if (!rate)
1344         return E_INVALIDARG;
1345
1346     if (thin)
1347         *thin = FALSE;
1348
1349     EnterCriticalSection(&clock->cs);
1350     *rate = clock->rate;
1351     LeaveCriticalSection(&clock->cs);
1352
1353     return S_OK;
1354 }
1355
1356 static const IMFRateControlVtbl presentclockratecontrolvtbl =
1357 {
1358     present_clock_rate_control_QueryInterface,
1359     present_clock_rate_control_AddRef,
1360     present_clock_rate_control_Release,
1361     present_clock_rate_SetRate,
1362     present_clock_rate_GetRate,
1363 };
1364
1365 static HRESULT WINAPI present_clock_timer_QueryInterface(IMFTimer *iface, REFIID riid, void **out)
1366 {
1367     struct presentation_clock *clock = impl_from_IMFTimer(iface);
1368     return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out);
1369 }
1370
1371 static ULONG WINAPI present_clock_timer_AddRef(IMFTimer *iface)
1372 {
1373     struct presentation_clock *clock = impl_from_IMFTimer(iface);
1374     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
1375 }
1376
1377 static ULONG WINAPI present_clock_timer_Release(IMFTimer *iface)
1378 {
1379     struct presentation_clock *clock = impl_from_IMFTimer(iface);
1380     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
1381 }
1382
1383 static HRESULT WINAPI present_clock_timer_SetTimer(IMFTimer *iface, DWORD flags, LONGLONG time,
1384         IMFAsyncCallback *callback, IUnknown *state, IUnknown **cancel_key)
1385 {
1386     FIXME("%p, %#x, %s, %p, %p, %p.\n", iface, flags, wine_dbgstr_longlong(time), callback, state, cancel_key);
1387
1388     return E_NOTIMPL;
1389 }
1390
1391 static HRESULT WINAPI present_clock_timer_CancelTimer(IMFTimer *iface, IUnknown *cancel_key)
1392 {
1393     FIXME("%p, %p.\n", iface, cancel_key);
1394
1395     return E_NOTIMPL;
1396 }
1397
1398 static const IMFTimerVtbl presentclocktimervtbl =
1399 {
1400     present_clock_timer_QueryInterface,
1401     present_clock_timer_AddRef,
1402     present_clock_timer_Release,
1403     present_clock_timer_SetTimer,
1404     present_clock_timer_CancelTimer,
1405 };
1406
1407 static HRESULT WINAPI present_clock_shutdown_QueryInterface(IMFShutdown *iface, REFIID riid, void **out)
1408 {
1409     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
1410     return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out);
1411 }
1412
1413 static ULONG WINAPI present_clock_shutdown_AddRef(IMFShutdown *iface)
1414 {
1415     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
1416     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
1417 }
1418
1419 static ULONG WINAPI present_clock_shutdown_Release(IMFShutdown *iface)
1420 {
1421     struct presentation_clock *clock = impl_from_IMFShutdown(iface);
1422     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
1423 }
1424
1425 static HRESULT WINAPI present_clock_shutdown_Shutdown(IMFShutdown *iface)
1426 {
1427     FIXME("%p.\n", iface);
1428
1429     return E_NOTIMPL;
1430 }
1431
1432 static HRESULT WINAPI present_clock_shutdown_GetShutdownStatus(IMFShutdown *iface, MFSHUTDOWN_STATUS *status)
1433 {
1434     FIXME("%p, %p.\n", iface, status);
1435
1436     return E_NOTIMPL;
1437 }
1438
1439 static const IMFShutdownVtbl presentclockshutdownvtbl =
1440 {
1441     present_clock_shutdown_QueryInterface,
1442     present_clock_shutdown_AddRef,
1443     present_clock_shutdown_Release,
1444     present_clock_shutdown_Shutdown,
1445     present_clock_shutdown_GetShutdownStatus,
1446 };
1447
1448 static HRESULT WINAPI present_clock_sink_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **out)
1449 {
1450     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1451             IsEqualIID(riid, &IID_IUnknown))
1452     {
1453         *out = iface;
1454         IMFAsyncCallback_AddRef(iface);
1455         return S_OK;
1456     }
1457
1458     WARN("Unsupported %s.\n", wine_dbgstr_guid(riid));
1459     *out = NULL;
1460     return E_NOINTERFACE;
1461 }
1462
1463 static ULONG WINAPI present_clock_sink_callback_AddRef(IMFAsyncCallback *iface)
1464 {
1465     struct presentation_clock *clock = impl_from_IMFAsyncCallback(iface);
1466     return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface);
1467 }
1468
1469 static ULONG WINAPI present_clock_sink_callback_Release(IMFAsyncCallback *iface)
1470 {
1471     struct presentation_clock *clock = impl_from_IMFAsyncCallback(iface);
1472     return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface);
1473 }
1474
1475 static HRESULT WINAPI present_clock_sink_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue)
1476 {
1477     return E_NOTIMPL;
1478 }
1479
1480 static HRESULT WINAPI present_clock_sink_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1481 {
1482     struct sink_notification *data;
1483     IUnknown *object;
1484     HRESULT hr;
1485
1486     if (FAILED(hr = IMFAsyncResult_GetObject(result, &object)))
1487         return hr;
1488
1489     data = impl_from_IUnknown(object);
1490
1491     clock_call_state_change(data->system_time, data->param, data->notification, data->sink);
1492
1493     IUnknown_Release(object);
1494
1495     return S_OK;
1496 }
1497
1498 static const IMFAsyncCallbackVtbl presentclocksinkcallbackvtbl =
1499 {
1500     present_clock_sink_callback_QueryInterface,
1501     present_clock_sink_callback_AddRef,
1502     present_clock_sink_callback_Release,
1503     present_clock_sink_callback_GetParameters,
1504     present_clock_sink_callback_Invoke,
1505 };
1506
1507 /***********************************************************************
1508  *      MFCreatePresentationClock (mf.@)
1509  */
1510 HRESULT WINAPI MFCreatePresentationClock(IMFPresentationClock **clock)
1511 {
1512     struct presentation_clock *object;
1513
1514     TRACE("%p.\n", clock);
1515
1516     object = heap_alloc_zero(sizeof(*object));
1517     if (!object)
1518         return E_OUTOFMEMORY;
1519
1520     object->IMFPresentationClock_iface.lpVtbl = &presentationclockvtbl;
1521     object->IMFRateControl_iface.lpVtbl = &presentclockratecontrolvtbl;
1522     object->IMFTimer_iface.lpVtbl = &presentclocktimervtbl;
1523     object->IMFShutdown_iface.lpVtbl = &presentclockshutdownvtbl;
1524     object->IMFAsyncCallback_iface.lpVtbl = &presentclocksinkcallbackvtbl;
1525     object->refcount = 1;
1526     list_init(&object->sinks);
1527     object->rate = 1.0f;
1528     InitializeCriticalSection(&object->cs);
1529
1530     *clock = &object->IMFPresentationClock_iface;
1531
1532     return S_OK;
1533 }