dlls/mfplay/player.c

   1 /*
   2  * Copyright 2019 Nikolay Sivov for CodeWeavers
   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 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "mfapi.h"
  26 #include "mfplay.h"
  27
  28 #include "wine/debug.h"
  29 #include "wine/heap.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  32
  33 static const WCHAR eventclassW[] = L"MediaPlayerEventCallbackClass";
  34
  35 static LONG startup_refcount;
  36 static HINSTANCE mfplay_instance;
  37
  38 static void platform_startup(void)
  39 {
  40     if (InterlockedIncrement(&startup_refcount) == 1)
  41         MFStartup(MF_VERSION, MFSTARTUP_FULL);
  42 }
  43
  44 static void platform_shutdown(void)
  45 {
  46     if (InterlockedDecrement(&startup_refcount) == 0)
  47         MFShutdown();
  48 }
  49
  50 struct media_item
  51 {
  52     IMFPMediaItem IMFPMediaItem_iface;
  53     LONG refcount;
  54     IMFPMediaPlayer *player;
  55     IMFMediaSource *source;
  56     IMFPresentationDescriptor *pd;
  57     DWORD_PTR user_data;
  58 };
  59
  60 struct media_player
  61 {
  62     IMFPMediaPlayer IMFPMediaPlayer_iface;
  63     IPropertyStore IPropertyStore_iface;
  64     IMFAsyncCallback resolver_callback;
  65     IMFAsyncCallback events_callback;
  66     IMFAsyncCallback session_events_callback;
  67     LONG refcount;
  68     IMFPMediaPlayerCallback *callback;
  69     IPropertyStore *propstore;
  70     IMFSourceResolver *resolver;
  71     IMFMediaSession *session;
  72     MFP_CREATION_OPTIONS options;
  73     MFP_MEDIAPLAYER_STATE state;
  74     HWND event_window;
  75     HWND output_window;
  76     CRITICAL_SECTION cs;
  77 };
  78
  79 struct generic_event
  80 {
  81     MFP_EVENT_HEADER header;
  82     IMFPMediaItem *item;
  83 };
  84
  85 struct media_event
  86 {
  87     IUnknown IUnknown_iface;
  88     LONG refcount;
  89     union
  90     {
  91         MFP_EVENT_HEADER header;
  92         struct generic_event generic;
  93         MFP_PLAY_EVENT play;
  94         MFP_PAUSE_EVENT pause;
  95         MFP_STOP_EVENT stop;
  96         MFP_POSITION_SET_EVENT position_set;
  97         MFP_RATE_SET_EVENT rate_set;
  98         MFP_MEDIAITEM_CREATED_EVENT item_created;
  99         MFP_MEDIAITEM_SET_EVENT item_set;
 100         MFP_MEDIAITEM_CLEARED_EVENT item_cleared;
 101         MFP_MF_EVENT event;
 102         MFP_ERROR_EVENT error;
 103         MFP_PLAYBACK_ENDED_EVENT ended;
 104         MFP_ACQUIRE_USER_CREDENTIAL_EVENT acquire_creds;
 105     } u;
 106 };
 107
 108 static struct media_player *impl_from_IMFPMediaPlayer(IMFPMediaPlayer *iface)
 109 {
 110     return CONTAINING_RECORD(iface, struct media_player, IMFPMediaPlayer_iface);
 111 }
 112
 113 static struct media_player *impl_from_IPropertyStore(IPropertyStore *iface)
 114 {
 115     return CONTAINING_RECORD(iface, struct media_player, IPropertyStore_iface);
 116 }
 117
 118 static struct media_player *impl_from_resolver_IMFAsyncCallback(IMFAsyncCallback *iface)
 119 {
 120     return CONTAINING_RECORD(iface, struct media_player, resolver_callback);
 121 }
 122
 123 static struct media_player *impl_from_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 124 {
 125     return CONTAINING_RECORD(iface, struct media_player, events_callback);
 126 }
 127
 128 static struct media_player *impl_from_session_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 129 {
 130     return CONTAINING_RECORD(iface, struct media_player, session_events_callback);
 131 }
 132
 133 static struct media_item *impl_from_IMFPMediaItem(IMFPMediaItem *iface)
 134 {
 135     return CONTAINING_RECORD(iface, struct media_item, IMFPMediaItem_iface);
 136 }
 137
 138 static struct media_event *impl_event_from_IUnknown(IUnknown *iface)
 139 {
 140     return CONTAINING_RECORD(iface, struct media_event, IUnknown_iface);
 141 }
 142
 143 static HRESULT WINAPI media_event_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 144 {
 145     if (IsEqualIID(riid, &IID_IUnknown))
 146     {
 147         *obj = iface;
 148         IUnknown_AddRef(iface);
 149         return S_OK;
 150     }
 151
 152     *obj = NULL;
 153     return E_NOINTERFACE;
 154 }
 155
 156 static ULONG WINAPI media_event_AddRef(IUnknown *iface)
 157 {
 158     struct media_event *event = impl_event_from_IUnknown(iface);
 159     ULONG refcount = InterlockedIncrement(&event->refcount);
 160
 161     TRACE("%p, refcount %u.\n", iface, refcount);
 162
 163     return refcount;
 164 }
 165
 166 static ULONG WINAPI media_event_Release(IUnknown *iface)
 167 {
 168     struct media_event *event = impl_event_from_IUnknown(iface);
 169     ULONG refcount = InterlockedDecrement(&event->refcount);
 170
 171     TRACE("%p, refcount %u.\n", iface, refcount);
 172
 173     if (!refcount)
 174     {
 175         if (event->u.header.pMediaPlayer)
 176             IMFPMediaPlayer_Release(event->u.header.pMediaPlayer);
 177         if (event->u.header.pPropertyStore)
 178             IPropertyStore_Release(event->u.header.pPropertyStore);
 179
 180         switch (event->u.header.eEventType)
 181         {
 182             /* Most types share same layout. */
 183             case MFP_EVENT_TYPE_PLAY:
 184             case MFP_EVENT_TYPE_PAUSE:
 185             case MFP_EVENT_TYPE_STOP:
 186             case MFP_EVENT_TYPE_POSITION_SET:
 187             case MFP_EVENT_TYPE_RATE_SET:
 188             case MFP_EVENT_TYPE_MEDIAITEM_CREATED:
 189             case MFP_EVENT_TYPE_MEDIAITEM_SET:
 190             case MFP_EVENT_TYPE_FRAME_STEP:
 191             case MFP_EVENT_TYPE_MEDIAITEM_CLEARED:
 192             case MFP_EVENT_TYPE_PLAYBACK_ENDED:
 193                 if (event->u.generic.item)
 194                     IMFPMediaItem_Release(event->u.generic.item);
 195                 break;
 196             case MFP_EVENT_TYPE_MF:
 197                 if (event->u.event.pMFMediaEvent)
 198                     IMFMediaEvent_Release(event->u.event.pMFMediaEvent);
 199                 if (event->u.event.pMediaItem)
 200                     IMFPMediaItem_Release(event->u.event.pMediaItem);
 201                 break;
 202             default:
 203                 FIXME("Unsupported event %u.\n", event->u.header.eEventType);
 204                 break;
 205         }
 206
 207         heap_free(event);
 208     }
 209
 210     return refcount;
 211 }
 212
 213 static const IUnknownVtbl media_event_vtbl =
 214 {
 215     media_event_QueryInterface,
 216     media_event_AddRef,
 217     media_event_Release,
 218 };
 219
 220 static HRESULT media_event_create(struct media_player *player, MFP_EVENT_TYPE event_type,
 221         HRESULT hr, struct media_event **event)
 222 {
 223     struct media_event *object;
 224
 225     if (!(object = heap_alloc_zero(sizeof(*object))))
 226         return E_OUTOFMEMORY;
 227
 228     object->IUnknown_iface.lpVtbl = &media_event_vtbl;
 229     object->refcount = 1;
 230     object->u.header.eEventType = event_type;
 231     object->u.header.hrEvent = hr;
 232     object->u.header.pMediaPlayer = &player->IMFPMediaPlayer_iface;
 233     IMFPMediaPlayer_AddRef(object->u.header.pMediaPlayer);
 234     object->u.header.eState = player->state;
 235     /* FIXME: set properties for some events? */
 236
 237     *event = object;
 238
 239     return S_OK;
 240 }
 241
 242 static LRESULT WINAPI media_player_event_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 243 {
 244     struct media_event *event = (void *)lparam;
 245     struct media_player *player;
 246
 247     if (msg == WM_USER)
 248     {
 249         player = impl_from_IMFPMediaPlayer(event->u.header.pMediaPlayer);
 250         if (player->callback)
 251             IMFPMediaPlayerCallback_OnMediaPlayerEvent(player->callback, &event->u.header);
 252         IUnknown_Release(&event->IUnknown_iface);
 253         return 0;
 254     }
 255
 256     return DefWindowProcW(hwnd, msg, wparam, lparam);
 257 }
 258
 259 static void media_player_set_state(struct media_player *player, MFP_MEDIAPLAYER_STATE state)
 260 {
 261     if (player->state != MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 262     {
 263         if (state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 264             IMFMediaSession_Shutdown(player->session);
 265         player->state = state;
 266     }
 267 }
 268
 269 static HRESULT WINAPI media_item_QueryInterface(IMFPMediaItem *iface, REFIID riid, void **obj)
 270 {
 271     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 272
 273     if (IsEqualIID(riid, &IID_IMFPMediaItem) ||
 274             IsEqualIID(riid, &IID_IUnknown))
 275     {
 276         *obj = iface;
 277         IMFPMediaItem_AddRef(iface);
 278         return S_OK;
 279     }
 280
 281     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 282     *obj = NULL;
 283     return E_NOINTERFACE;
 284 }
 285
 286 static ULONG WINAPI media_item_AddRef(IMFPMediaItem *iface)
 287 {
 288     struct media_item *item = impl_from_IMFPMediaItem(iface);
 289     ULONG refcount = InterlockedIncrement(&item->refcount);
 290
 291     TRACE("%p, refcount %u.\n", iface, refcount);
 292
 293     return refcount;
 294 }
 295
 296 static ULONG WINAPI media_item_Release(IMFPMediaItem *iface)
 297 {
 298     struct media_item *item = impl_from_IMFPMediaItem(iface);
 299     ULONG refcount = InterlockedDecrement(&item->refcount);
 300
 301     TRACE("%p, refcount %u.\n", iface, refcount);
 302
 303     if (!refcount)
 304     {
 305         if (item->player)
 306             IMFPMediaPlayer_Release(item->player);
 307         if (item->source)
 308             IMFMediaSource_Release(item->source);
 309         if (item->pd)
 310             IMFPresentationDescriptor_Release(item->pd);
 311         heap_free(item);
 312     }
 313
 314     return refcount;
 315 }
 316
 317 static HRESULT WINAPI media_item_GetMediaPlayer(IMFPMediaItem *iface,
 318         IMFPMediaPlayer **player)
 319 {
 320     struct media_item *item = impl_from_IMFPMediaItem(iface);
 321
 322     TRACE("%p, %p.\n", iface, player);
 323
 324     *player = item->player;
 325     IMFPMediaPlayer_AddRef(*player);
 326
 327     return S_OK;
 328 }
 329
 330 static HRESULT WINAPI media_item_GetURL(IMFPMediaItem *iface, LPWSTR *url)
 331 {
 332     FIXME("%p, %p.\n", iface, url);
 333
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI media_item_GetObject(IMFPMediaItem *iface, IUnknown **obj)
 338 {
 339     FIXME("%p, %p.\n", iface, obj);
 340
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI media_item_GetUserData(IMFPMediaItem *iface, DWORD_PTR *user_data)
 345 {
 346     struct media_item *item = impl_from_IMFPMediaItem(iface);
 347
 348     TRACE("%p, %p.\n", iface, user_data);
 349
 350     *user_data = item->user_data;
 351
 352     return S_OK;
 353 }
 354
 355 static HRESULT WINAPI media_item_SetUserData(IMFPMediaItem *iface, DWORD_PTR user_data)
 356 {
 357     struct media_item *item = impl_from_IMFPMediaItem(iface);
 358
 359     TRACE("%p, %lx.\n", iface, user_data);
 360
 361     item->user_data = user_data;
 362
 363     return S_OK;
 364 }
 365
 366 static HRESULT WINAPI media_item_GetStartStopPosition(IMFPMediaItem *iface, GUID *start_format,
 367         PROPVARIANT *start_position, GUID *stop_format, PROPVARIANT *stop_position)
 368 {
 369     FIXME("%p, %p, %p, %p, %p.\n", iface, start_format, start_position, stop_format, stop_position);
 370
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT WINAPI media_item_SetStartStopPosition(IMFPMediaItem *iface, const GUID *start_format,
 375         const PROPVARIANT *start_position, const GUID *stop_format, const PROPVARIANT *stop_position)
 376 {
 377     FIXME("%p, %s, %p, %s, %p.\n", iface, debugstr_guid(start_format), start_position,
 378             debugstr_guid(stop_format), stop_position);
 379
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI media_item_HasVideo(IMFPMediaItem *iface, BOOL *has_video, BOOL *selected)
 384 {
 385     FIXME("%p, %p, %p.\n", iface, has_video, selected);
 386
 387     return E_NOTIMPL;
 388 }
 389
 390 static HRESULT WINAPI media_item_HasAudio(IMFPMediaItem *iface, BOOL *has_audio, BOOL *selected)
 391 {
 392     FIXME("%p, %p, %p.\n", iface, has_audio, selected);
 393
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI media_item_IsProtected(IMFPMediaItem *iface, BOOL *protected)
 398 {
 399     struct media_item *item = impl_from_IMFPMediaItem(iface);
 400
 401     TRACE("%p, %p.\n", iface, protected);
 402
 403     *protected = MFRequireProtectedEnvironment(item->pd) == S_OK;
 404
 405     return S_OK;
 406 }
 407
 408 static HRESULT WINAPI media_item_GetDuration(IMFPMediaItem *iface, REFGUID format, PROPVARIANT *value)
 409 {
 410     struct media_item *item = impl_from_IMFPMediaItem(iface);
 411
 412     TRACE("%p, %s, %p.\n", iface, debugstr_guid(format), value);
 413
 414     return IMFPresentationDescriptor_GetItem(item->pd, &MF_PD_DURATION, value);
 415 }
 416
 417 static HRESULT WINAPI media_item_GetNumberOfStreams(IMFPMediaItem *iface, DWORD *count)
 418 {
 419     struct media_item *item = impl_from_IMFPMediaItem(iface);
 420
 421     TRACE("%p, %p.\n", iface, count);
 422
 423     return IMFPresentationDescriptor_GetStreamDescriptorCount(item->pd, count);
 424 }
 425
 426 static HRESULT WINAPI media_item_GetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL *selected)
 427 {
 428     struct media_item *item = impl_from_IMFPMediaItem(iface);
 429     IMFStreamDescriptor *sd;
 430     HRESULT hr;
 431
 432     TRACE("%p, %u, %p.\n", iface, index, selected);
 433
 434     if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, selected, &sd)))
 435         IMFStreamDescriptor_Release(sd);
 436
 437     return hr;
 438 }
 439
 440 static HRESULT WINAPI media_item_SetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL select)
 441 {
 442     struct media_item *item = impl_from_IMFPMediaItem(iface);
 443
 444     TRACE("%p, %u, %d.\n", iface, index, select);
 445
 446     return select ? IMFPresentationDescriptor_SelectStream(item->pd, index) :
 447             IMFPresentationDescriptor_DeselectStream(item->pd, index);
 448 }
 449
 450 static HRESULT WINAPI media_item_GetStreamAttribute(IMFPMediaItem *iface, DWORD index, REFGUID key,
 451         PROPVARIANT *value)
 452 {
 453     struct media_item *item = impl_from_IMFPMediaItem(iface);
 454     IMFStreamDescriptor *sd;
 455     BOOL selected;
 456     HRESULT hr;
 457
 458     TRACE("%p, %u, %s, %p.\n", iface, index, debugstr_guid(key), value);
 459
 460     if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, &selected, &sd)))
 461     {
 462         hr = IMFStreamDescriptor_GetItem(sd, key, value);
 463         IMFStreamDescriptor_Release(sd);
 464     }
 465
 466     return hr;
 467 }
 468
 469 static HRESULT WINAPI media_item_GetPresentationAttribute(IMFPMediaItem *iface, REFGUID key,
 470         PROPVARIANT *value)
 471 {
 472     struct media_item *item = impl_from_IMFPMediaItem(iface);
 473
 474     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 475
 476     return IMFPresentationDescriptor_GetItem(item->pd, key, value);
 477 }
 478
 479 static HRESULT WINAPI media_item_GetCharacteristics(IMFPMediaItem *iface, MFP_MEDIAITEM_CHARACTERISTICS *flags)
 480 {
 481     struct media_item *item = impl_from_IMFPMediaItem(iface);
 482     HRESULT hr;
 483
 484     TRACE("%p, %p.\n", iface, flags);
 485
 486     *flags = 0;
 487
 488     if (SUCCEEDED(hr = IMFMediaSource_GetCharacteristics(item->source, flags)))
 489     {
 490         *flags &= (MFP_MEDIAITEM_IS_LIVE | MFP_MEDIAITEM_CAN_SEEK |
 491                 MFP_MEDIAITEM_CAN_PAUSE | MFP_MEDIAITEM_HAS_SLOW_SEEK);
 492     }
 493
 494     return hr;
 495 }
 496
 497 static HRESULT WINAPI media_item_SetStreamSink(IMFPMediaItem *iface, DWORD index, IUnknown *sink)
 498 {
 499     FIXME("%p, %u, %p.\n", iface, index, sink);
 500
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI media_item_GetMetadata(IMFPMediaItem *iface, IPropertyStore **metadata)
 505 {
 506     struct media_item *item = impl_from_IMFPMediaItem(iface);
 507
 508     TRACE("%p, %p.\n", iface, metadata);
 509
 510     return MFGetService((IUnknown *)item->source, &MF_PROPERTY_HANDLER_SERVICE,
 511             &IID_IPropertyStore, (void **)&metadata);
 512 }
 513
 514 static const IMFPMediaItemVtbl media_item_vtbl =
 515 {
 516     media_item_QueryInterface,
 517     media_item_AddRef,
 518     media_item_Release,
 519     media_item_GetMediaPlayer,
 520     media_item_GetURL,
 521     media_item_GetObject,
 522     media_item_GetUserData,
 523     media_item_SetUserData,
 524     media_item_GetStartStopPosition,
 525     media_item_SetStartStopPosition,
 526     media_item_HasVideo,
 527     media_item_HasAudio,
 528     media_item_IsProtected,
 529     media_item_GetDuration,
 530     media_item_GetNumberOfStreams,
 531     media_item_GetStreamSelection,
 532     media_item_SetStreamSelection,
 533     media_item_GetStreamAttribute,
 534     media_item_GetPresentationAttribute,
 535     media_item_GetCharacteristics,
 536     media_item_SetStreamSink,
 537     media_item_GetMetadata,
 538 };
 539
 540 static HRESULT create_media_item(IMFPMediaPlayer *player, DWORD_PTR user_data, struct media_item **item)
 541 {
 542     struct media_item *object;
 543
 544     if (!(object = heap_alloc_zero(sizeof(*object))))
 545         return E_OUTOFMEMORY;
 546
 547     object->IMFPMediaItem_iface.lpVtbl = &media_item_vtbl;
 548     object->refcount = 1;
 549     object->user_data = user_data;
 550     object->player = player;
 551     IMFPMediaPlayer_AddRef(object->player);
 552
 553     *item = object;
 554
 555     return S_OK;
 556 }
 557
 558 static HRESULT media_item_set_source(struct media_item *item, IUnknown *object)
 559 {
 560     IMFPresentationDescriptor *pd;
 561     IMFMediaSource *source;
 562     HRESULT hr;
 563
 564     if (FAILED(hr = IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
 565         return hr;
 566
 567     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(source, &pd)))
 568     {
 569         WARN("Failed to get presentation descriptor, hr %#x.\n", hr);
 570         IMFMediaSource_Release(source);
 571         return hr;
 572     }
 573
 574     item->source = source;
 575     item->pd = pd;
 576
 577     return hr;
 578 }
 579
 580 static void media_player_queue_event(struct media_player *player, struct media_event *event)
 581 {
 582     if (player->options & MFP_OPTION_FREE_THREADED_CALLBACK)
 583     {
 584         MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_MULTITHREADED, &player->events_callback, &event->IUnknown_iface);
 585     }
 586     else
 587     {
 588         IUnknown_AddRef(&event->IUnknown_iface);
 589         PostMessageW(player->event_window, WM_USER, 0, (LPARAM)event);
 590     }
 591 }
 592
 593 static HRESULT WINAPI media_player_QueryInterface(IMFPMediaPlayer *iface, REFIID riid, void **obj)
 594 {
 595     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 596
 597     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 598
 599     if (IsEqualIID(riid, &IID_IMFPMediaPlayer) ||
 600             IsEqualIID(riid, &IID_IUnknown))
 601     {
 602         *obj = &player->IMFPMediaPlayer_iface;
 603     }
 604     else if (IsEqualIID(riid, &IID_IPropertyStore))
 605     {
 606         *obj = &player->IPropertyStore_iface;
 607     }
 608     else
 609     {
 610         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 611         *obj = NULL;
 612
 613         return E_NOINTERFACE;
 614     }
 615
 616     IUnknown_AddRef((IUnknown *)*obj);
 617     return S_OK;
 618 }
 619
 620 static ULONG WINAPI media_player_AddRef(IMFPMediaPlayer *iface)
 621 {
 622     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 623     ULONG refcount = InterlockedIncrement(&player->refcount);
 624
 625     TRACE("%p, refcount %u.\n", iface, refcount);
 626
 627     return refcount;
 628 }
 629
 630 static ULONG WINAPI media_player_Release(IMFPMediaPlayer *iface)
 631 {
 632     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 633     ULONG refcount = InterlockedDecrement(&player->refcount);
 634
 635     TRACE("%p, refcount %u.\n", iface, refcount);
 636
 637     if (!refcount)
 638     {
 639         if (player->callback)
 640             IMFPMediaPlayerCallback_Release(player->callback);
 641         if (player->propstore)
 642             IPropertyStore_Release(player->propstore);
 643         if (player->resolver)
 644             IMFSourceResolver_Release(player->resolver);
 645         if (player->session)
 646             IMFMediaSession_Release(player->session);
 647         DestroyWindow(player->event_window);
 648         DeleteCriticalSection(&player->cs);
 649         heap_free(player);
 650
 651         platform_shutdown();
 652     }
 653
 654     return refcount;
 655 }
 656
 657 static HRESULT WINAPI media_player_Play(IMFPMediaPlayer *iface)
 658 {
 659     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 660     PROPVARIANT pos;
 661
 662     TRACE("%p.\n", iface);
 663
 664     pos.vt = VT_EMPTY;
 665     return IMFMediaSession_Start(player->session, &GUID_NULL, &pos);
 666 }
 667
 668 static HRESULT WINAPI media_player_Pause(IMFPMediaPlayer *iface)
 669 {
 670     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 671
 672     TRACE("%p.\n", iface);
 673
 674     return IMFMediaSession_Pause(player->session);
 675 }
 676
 677 static HRESULT WINAPI media_player_Stop(IMFPMediaPlayer *iface)
 678 {
 679     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 680
 681     TRACE("%p.\n", iface);
 682
 683     return IMFMediaSession_Stop(player->session);
 684 }
 685
 686 static HRESULT WINAPI media_player_FrameStep(IMFPMediaPlayer *iface)
 687 {
 688     FIXME("%p.\n", iface);
 689
 690     return E_NOTIMPL;
 691 }
 692
 693 static HRESULT WINAPI media_player_SetPosition(IMFPMediaPlayer *iface, REFGUID postype, const PROPVARIANT *position)
 694 {
 695     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 696
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI media_player_GetPosition(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 701 {
 702     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 703
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI media_player_GetDuration(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 708 {
 709     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 710
 711     return E_NOTIMPL;
 712 }
 713
 714 static HRESULT WINAPI media_player_SetRate(IMFPMediaPlayer *iface, float rate)
 715 {
 716     FIXME("%p, %f.\n", iface, rate);
 717
 718     return E_NOTIMPL;
 719 }
 720
 721 static HRESULT WINAPI media_player_GetRate(IMFPMediaPlayer *iface, float *rate)
 722 {
 723     FIXME("%p, %p.\n", iface, rate);
 724
 725     return E_NOTIMPL;
 726 }
 727
 728 static HRESULT WINAPI media_player_GetSupportedRates(IMFPMediaPlayer *iface, BOOL forward,
 729         float *slowest_rate, float *fastest_rate)
 730 {
 731     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 732     IMFRateSupport *rs;
 733     HRESULT hr;
 734
 735     TRACE("%p, %d, %p, %p.\n", iface, forward, slowest_rate, fastest_rate);
 736
 737     if (SUCCEEDED(hr = MFGetService((IUnknown *)player->session, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateSupport, (void **)&rs)))
 738     {
 739         if (SUCCEEDED(hr = IMFRateSupport_GetSlowestRate(rs, forward ? MFRATE_FORWARD : MFRATE_REVERSE, FALSE, slowest_rate)))
 740             hr = IMFRateSupport_GetFastestRate(rs, forward ? MFRATE_FORWARD : MFRATE_REVERSE, FALSE, fastest_rate);
 741         IMFRateSupport_Release(rs);
 742     }
 743
 744     return hr;
 745 }
 746
 747 static HRESULT WINAPI media_player_GetState(IMFPMediaPlayer *iface, MFP_MEDIAPLAYER_STATE *state)
 748 {
 749     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 750
 751     TRACE("%p, %p.\n", iface, state);
 752
 753     *state = player->state;
 754
 755     return S_OK;
 756 }
 757
 758 static HRESULT WINAPI media_player_CreateMediaItemFromURL(IMFPMediaPlayer *iface,
 759         const WCHAR *url, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **ret)
 760 {
 761     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 762     struct media_item *item;
 763     MF_OBJECT_TYPE obj_type;
 764     IUnknown *object;
 765     HRESULT hr;
 766
 767     TRACE("%p, %s, %d, %lx, %p.\n", iface, debugstr_w(url), sync, user_data, ret);
 768
 769     if (FAILED(hr = create_media_item(iface, user_data, &item)))
 770         return hr;
 771
 772     if (sync)
 773     {
 774         *ret = NULL;
 775
 776         if (SUCCEEDED(hr = IMFSourceResolver_CreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE,
 777                 player->propstore, &obj_type, &object)))
 778         {
 779             hr = media_item_set_source(item, object);
 780             IUnknown_Release(object);
 781         }
 782
 783         if (SUCCEEDED(hr))
 784             *ret = &item->IMFPMediaItem_iface;
 785
 786         return hr;
 787     }
 788     else
 789     {
 790         hr = IMFSourceResolver_BeginCreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE,
 791             player->propstore, NULL, &player->resolver_callback, (IUnknown *)&item->IMFPMediaItem_iface);
 792
 793         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 794     }
 795
 796     return hr;
 797 }
 798
 799 static HRESULT WINAPI media_player_CreateMediaItemFromObject(IMFPMediaPlayer *iface,
 800         IUnknown *object, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
 801 {
 802     FIXME("%p, %p, %d, %lx, %p.\n", iface, object, sync, user_data, item);
 803
 804     return E_NOTIMPL;
 805 }
 806
 807 static HRESULT WINAPI media_player_SetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem *item)
 808 {
 809     FIXME("%p, %p.\n", iface, item);
 810
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI media_player_ClearMediaItem(IMFPMediaPlayer *iface)
 815 {
 816     FIXME("%p.\n", iface);
 817
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI media_player_GetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem **item)
 822 {
 823     FIXME("%p, %p.\n", iface, item);
 824
 825     return E_NOTIMPL;
 826 }
 827
 828 static HRESULT WINAPI media_player_GetVolume(IMFPMediaPlayer *iface, float *volume)
 829 {
 830     FIXME("%p, %p.\n", iface, volume);
 831
 832     return E_NOTIMPL;
 833 }
 834
 835 static HRESULT WINAPI media_player_SetVolume(IMFPMediaPlayer *iface, float volume)
 836 {
 837     FIXME("%p, %.8e.\n", iface, volume);
 838
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI media_player_GetBalance(IMFPMediaPlayer *iface, float *balance)
 843 {
 844     FIXME("%p, %p.\n", iface, balance);
 845
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI media_player_SetBalance(IMFPMediaPlayer *iface, float balance)
 850 {
 851     FIXME("%p, %.8e.\n", iface, balance);
 852
 853     return E_NOTIMPL;
 854 }
 855
 856 static HRESULT WINAPI media_player_GetMute(IMFPMediaPlayer *iface, BOOL *mute)
 857 {
 858     FIXME("%p, %p.\n", iface, mute);
 859
 860     return E_NOTIMPL;
 861 }
 862
 863 static HRESULT WINAPI media_player_SetMute(IMFPMediaPlayer *iface, BOOL mute)
 864 {
 865     FIXME("%p, %d.\n", iface, mute);
 866
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI media_player_GetNativeVideoSize(IMFPMediaPlayer *iface,
 871         SIZE *video, SIZE *arvideo)
 872 {
 873     FIXME("%p, %p, %p.\n", iface, video, arvideo);
 874
 875     return E_NOTIMPL;
 876 }
 877
 878 static HRESULT WINAPI media_player_GetIdealVideoSize(IMFPMediaPlayer *iface,
 879         SIZE *min_size, SIZE *max_size)
 880 {
 881     FIXME("%p, %p, %p.\n", iface, min_size, max_size);
 882
 883     return E_NOTIMPL;
 884 }
 885
 886 static HRESULT WINAPI media_player_SetVideoSourceRect(IMFPMediaPlayer *iface,
 887         MFVideoNormalizedRect const *rect)
 888 {
 889     FIXME("%p, %p.\n", iface, rect);
 890
 891     return E_NOTIMPL;
 892 }
 893
 894 static HRESULT WINAPI media_player_GetVideoSourceRect(IMFPMediaPlayer *iface,
 895         MFVideoNormalizedRect *rect)
 896 {
 897     FIXME("%p, %p.\n", iface, rect);
 898
 899     return E_NOTIMPL;
 900 }
 901
 902 static HRESULT WINAPI media_player_SetAspectRatioMode(IMFPMediaPlayer *iface, DWORD mode)
 903 {
 904     FIXME("%p, %u.\n", iface, mode);
 905
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI media_player_GetAspectRatioMode(IMFPMediaPlayer *iface,
 910         DWORD *mode)
 911 {
 912     FIXME("%p, %p.\n", iface, mode);
 913
 914     return E_NOTIMPL;
 915 }
 916
 917 static HRESULT WINAPI media_player_GetVideoWindow(IMFPMediaPlayer *iface, HWND *window)
 918 {
 919     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 920
 921     TRACE("%p, %p.\n", iface, window);
 922
 923     *window = player->output_window;
 924
 925     return S_OK;
 926 }
 927
 928 static HRESULT WINAPI media_player_UpdateVideo(IMFPMediaPlayer *iface)
 929 {
 930     FIXME("%p.\n", iface);
 931
 932     return E_NOTIMPL;
 933 }
 934
 935 static HRESULT WINAPI media_player_SetBorderColor(IMFPMediaPlayer *iface, COLORREF color)
 936 {
 937     FIXME("%p, %#x.\n", iface, color);
 938
 939     return E_NOTIMPL;
 940 }
 941
 942 static HRESULT WINAPI media_player_GetBorderColor(IMFPMediaPlayer *iface, COLORREF *color)
 943 {
 944     FIXME("%p, %p.\n", iface, color);
 945
 946     return E_NOTIMPL;
 947 }
 948
 949 static HRESULT WINAPI media_player_InsertEffect(IMFPMediaPlayer *iface, IUnknown *effect,
 950         BOOL optional)
 951 {
 952     FIXME("%p, %p, %d.\n", iface, effect, optional);
 953
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI media_player_RemoveEffect(IMFPMediaPlayer *iface, IUnknown *effect)
 958 {
 959     FIXME("%p, %p.\n", iface, effect);
 960
 961     return E_NOTIMPL;
 962 }
 963
 964 static HRESULT WINAPI media_player_RemoveAllEffects(IMFPMediaPlayer *iface)
 965 {
 966     FIXME("%p.\n", iface);
 967
 968     return E_NOTIMPL;
 969 }
 970
 971 static HRESULT WINAPI media_player_Shutdown(IMFPMediaPlayer *iface)
 972 {
 973     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 974
 975     TRACE("%p.\n", iface);
 976
 977     EnterCriticalSection(&player->cs);
 978     media_player_set_state(player, MFP_MEDIAPLAYER_STATE_SHUTDOWN);
 979     LeaveCriticalSection(&player->cs);
 980
 981     return S_OK;
 982 }
 983
 984 static const IMFPMediaPlayerVtbl media_player_vtbl =
 985 {
 986     media_player_QueryInterface,
 987     media_player_AddRef,
 988     media_player_Release,
 989     media_player_Play,
 990     media_player_Pause,
 991     media_player_Stop,
 992     media_player_FrameStep,
 993     media_player_SetPosition,
 994     media_player_GetPosition,
 995     media_player_GetDuration,
 996     media_player_SetRate,
 997     media_player_GetRate,
 998     media_player_GetSupportedRates,
 999     media_player_GetState,
1000     media_player_CreateMediaItemFromURL,
1001     media_player_CreateMediaItemFromObject,
1002     media_player_SetMediaItem,
1003     media_player_ClearMediaItem,
1004     media_player_GetMediaItem,
1005     media_player_GetVolume,
1006     media_player_SetVolume,
1007     media_player_GetBalance,
1008     media_player_SetBalance,
1009     media_player_GetMute,
1010     media_player_SetMute,
1011     media_player_GetNativeVideoSize,
1012     media_player_GetIdealVideoSize,
1013     media_player_SetVideoSourceRect,
1014     media_player_GetVideoSourceRect,
1015     media_player_SetAspectRatioMode,
1016     media_player_GetAspectRatioMode,
1017     media_player_GetVideoWindow,
1018     media_player_UpdateVideo,
1019     media_player_SetBorderColor,
1020     media_player_GetBorderColor,
1021     media_player_InsertEffect,
1022     media_player_RemoveEffect,
1023     media_player_RemoveAllEffects,
1024     media_player_Shutdown,
1025 };
1026
1027 static HRESULT WINAPI media_player_propstore_QueryInterface(IPropertyStore *iface,
1028         REFIID riid, void **obj)
1029 {
1030     struct media_player *player = impl_from_IPropertyStore(iface);
1031     return IMFPMediaPlayer_QueryInterface(&player->IMFPMediaPlayer_iface, riid, obj);
1032 }
1033
1034 static ULONG WINAPI media_player_propstore_AddRef(IPropertyStore *iface)
1035 {
1036     struct media_player *player = impl_from_IPropertyStore(iface);
1037     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1038 }
1039
1040 static ULONG WINAPI media_player_propstore_Release(IPropertyStore *iface)
1041 {
1042     struct media_player *player = impl_from_IPropertyStore(iface);
1043     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1044 }
1045
1046 static HRESULT WINAPI media_player_propstore_GetCount(IPropertyStore *iface, DWORD *count)
1047 {
1048     struct media_player *player = impl_from_IPropertyStore(iface);
1049
1050     TRACE("%p, %p.\n", iface, count);
1051
1052     return IPropertyStore_GetCount(player->propstore, count);
1053 }
1054
1055 static HRESULT WINAPI media_player_propstore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1056 {
1057     struct media_player *player = impl_from_IPropertyStore(iface);
1058
1059     TRACE("%p, %u, %p.\n", iface, prop, key);
1060
1061     return IPropertyStore_GetAt(player->propstore, prop, key);
1062 }
1063
1064 static HRESULT WINAPI media_player_propstore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
1065 {
1066     struct media_player *player = impl_from_IPropertyStore(iface);
1067
1068     TRACE("%p, %p, %p.\n", iface, key, value);
1069
1070     return IPropertyStore_GetValue(player->propstore, key, value);
1071 }
1072
1073 static HRESULT WINAPI media_player_propstore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
1074 {
1075     struct media_player *player = impl_from_IPropertyStore(iface);
1076
1077     TRACE("%p, %p, %p.\n", iface, key, value);
1078
1079     return IPropertyStore_SetValue(player->propstore, key, value);
1080 }
1081
1082 static HRESULT WINAPI media_player_propstore_Commit(IPropertyStore *iface)
1083 {
1084     struct media_player *player = impl_from_IPropertyStore(iface);
1085
1086     TRACE("%p.\n", iface);
1087
1088     return IPropertyStore_Commit(player->propstore);
1089 }
1090
1091 static const IPropertyStoreVtbl media_player_propstore_vtbl =
1092 {
1093     media_player_propstore_QueryInterface,
1094     media_player_propstore_AddRef,
1095     media_player_propstore_Release,
1096     media_player_propstore_GetCount,
1097     media_player_propstore_GetAt,
1098     media_player_propstore_GetValue,
1099     media_player_propstore_SetValue,
1100     media_player_propstore_Commit,
1101 };
1102
1103 static HRESULT WINAPI media_player_callback_QueryInterface(IMFAsyncCallback *iface,
1104         REFIID riid, void **obj)
1105 {
1106     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1107             IsEqualIID(riid, &IID_IUnknown))
1108     {
1109         *obj = iface;
1110         IMFAsyncCallback_AddRef(iface);
1111         return S_OK;
1112     }
1113
1114     *obj = NULL;
1115     return E_NOINTERFACE;
1116 }
1117
1118 static ULONG WINAPI media_player_resolver_callback_AddRef(IMFAsyncCallback *iface)
1119 {
1120     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1121     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1122 }
1123
1124 static ULONG WINAPI media_player_resolver_callback_Release(IMFAsyncCallback *iface)
1125 {
1126     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1127     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1128 }
1129
1130 static HRESULT WINAPI media_player_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags,
1131         DWORD *queue)
1132 {
1133     return E_NOTIMPL;
1134 }
1135
1136 static HRESULT WINAPI media_player_resolver_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1137 {
1138     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1139     struct media_event *event;
1140     IUnknown *object, *state;
1141     MF_OBJECT_TYPE obj_type;
1142     struct media_item *item;
1143     HRESULT hr;
1144
1145     if (FAILED(IMFAsyncResult_GetState(result, &state)))
1146         return S_OK;
1147
1148     item = impl_from_IMFPMediaItem((IMFPMediaItem *)state);
1149
1150     if (SUCCEEDED(hr = IMFSourceResolver_EndCreateObjectFromURL(player->resolver, result, &obj_type, &object)))
1151     {
1152         hr = media_item_set_source(item, object);
1153         IUnknown_Release(object);
1154     }
1155
1156     if (FAILED(hr))
1157         WARN("Failed to set media source, hr %#x.\n", hr);
1158
1159     if (FAILED(media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_CREATED, hr, &event)))
1160     {
1161         WARN("Failed to create event object.\n");
1162         IUnknown_Release(state);
1163         return S_OK;
1164     }
1165
1166     if (SUCCEEDED(hr))
1167     {
1168         event->u.item_created.pMediaItem = &item->IMFPMediaItem_iface;
1169         IMFPMediaItem_AddRef(event->u.item_created.pMediaItem);
1170     }
1171     event->u.item_created.dwUserData = item->user_data;
1172
1173     media_player_queue_event(player, event);
1174
1175     IUnknown_Release(&event->IUnknown_iface);
1176     IUnknown_Release(state);
1177
1178     return S_OK;
1179 }
1180
1181 static const IMFAsyncCallbackVtbl media_player_resolver_callback_vtbl =
1182 {
1183     media_player_callback_QueryInterface,
1184     media_player_resolver_callback_AddRef,
1185     media_player_resolver_callback_Release,
1186     media_player_callback_GetParameters,
1187     media_player_resolver_callback_Invoke,
1188 };
1189
1190 static ULONG WINAPI media_player_events_callback_AddRef(IMFAsyncCallback *iface)
1191 {
1192     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1193     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1194 }
1195
1196 static ULONG WINAPI media_player_events_callback_Release(IMFAsyncCallback *iface)
1197 {
1198     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1199     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1200 }
1201
1202 static HRESULT WINAPI media_player_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1203 {
1204     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1205     struct media_event *event;
1206     IUnknown *state;
1207
1208     if (FAILED(IMFAsyncResult_GetState(result, &state)))
1209         return S_OK;
1210
1211     event = impl_event_from_IUnknown(state);
1212
1213     if (player->callback)
1214         IMFPMediaPlayerCallback_OnMediaPlayerEvent(player->callback, &event->u.header);
1215
1216     IUnknown_Release(state);
1217
1218     return S_OK;
1219 }
1220
1221 static const IMFAsyncCallbackVtbl media_player_events_callback_vtbl =
1222 {
1223     media_player_callback_QueryInterface,
1224     media_player_events_callback_AddRef,
1225     media_player_events_callback_Release,
1226     media_player_callback_GetParameters,
1227     media_player_events_callback_Invoke,
1228 };
1229
1230 static ULONG WINAPI media_player_session_events_callback_AddRef(IMFAsyncCallback *iface)
1231 {
1232     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
1233     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1234 }
1235
1236 static ULONG WINAPI media_player_session_events_callback_Release(IMFAsyncCallback *iface)
1237 {
1238     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
1239     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1240 }
1241
1242 static HRESULT WINAPI media_player_session_events_callback_Invoke(IMFAsyncCallback *iface,
1243         IMFAsyncResult *result)
1244 {
1245     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
1246     MediaEventType session_event_type = MEUnknown;
1247     struct media_event *event = NULL;
1248     IMFMediaEvent *session_event;
1249     MFP_MEDIAPLAYER_STATE state;
1250     MFP_EVENT_TYPE event_type;
1251     HRESULT hr, event_status;
1252
1253     if (FAILED(hr = IMFMediaSession_EndGetEvent(player->session, result, &session_event)))
1254         return S_OK;
1255
1256     IMFMediaEvent_GetType(session_event, &session_event_type);
1257     IMFMediaEvent_GetStatus(session_event, &event_status);
1258
1259     switch (session_event_type)
1260     {
1261         case MESessionStarted:
1262         case MESessionStopped:
1263         case MESessionPaused:
1264             if (session_event_type == MESessionStarted)
1265             {
1266                 event_type = MFP_EVENT_TYPE_PLAY;
1267                 state = MFP_MEDIAPLAYER_STATE_PLAYING;
1268             }
1269             else if (session_event_type == MESessionStopped)
1270             {
1271                 event_type = MFP_EVENT_TYPE_STOP;
1272                 state = MFP_MEDIAPLAYER_STATE_STOPPED;
1273             }
1274             else
1275             {
1276                 event_type = MFP_EVENT_TYPE_PAUSE;
1277                 state = MFP_MEDIAPLAYER_STATE_PAUSED;
1278             }
1279
1280             EnterCriticalSection(&player->cs);
1281             media_player_set_state(player, state);
1282             media_event_create(player, event_type, event_status, &event);
1283             LeaveCriticalSection(&player->cs);
1284
1285             /* FIXME: set pMediaItem */
1286             media_player_queue_event(player, event);
1287             IUnknown_Release(&event->IUnknown_iface);
1288
1289             break;
1290         default:
1291             ;
1292     }
1293
1294     if (event)
1295     {
1296         IUnknown_Release(&event->IUnknown_iface);
1297     }
1298
1299     IMFMediaSession_BeginGetEvent(player->session, &player->session_events_callback, NULL);
1300     IMFMediaEvent_Release(session_event);
1301
1302     return S_OK;
1303 }
1304
1305 static const IMFAsyncCallbackVtbl media_player_session_events_callback_vtbl =
1306 {
1307     media_player_callback_QueryInterface,
1308     media_player_session_events_callback_AddRef,
1309     media_player_session_events_callback_Release,
1310     media_player_callback_GetParameters,
1311     media_player_session_events_callback_Invoke,
1312 };
1313
1314 HRESULT WINAPI MFPCreateMediaPlayer(const WCHAR *url, BOOL start_playback, MFP_CREATION_OPTIONS options,
1315         IMFPMediaPlayerCallback *callback, HWND window, IMFPMediaPlayer **player)
1316 {
1317     struct media_player *object;
1318     HRESULT hr;
1319
1320     TRACE("%s, %d, %#x, %p, %p, %p.\n", debugstr_w(url), start_playback, options, callback, window, player);
1321
1322     if (!(object = heap_alloc_zero(sizeof(*object))))
1323         return E_OUTOFMEMORY;
1324
1325     platform_startup();
1326
1327     object->IMFPMediaPlayer_iface.lpVtbl = &media_player_vtbl;
1328     object->IPropertyStore_iface.lpVtbl = &media_player_propstore_vtbl;
1329     object->resolver_callback.lpVtbl = &media_player_resolver_callback_vtbl;
1330     object->events_callback.lpVtbl = &media_player_events_callback_vtbl;
1331     object->session_events_callback.lpVtbl = &media_player_session_events_callback_vtbl;
1332     object->refcount = 1;
1333     object->callback = callback;
1334     if (object->callback)
1335         IMFPMediaPlayerCallback_AddRef(object->callback);
1336     object->options = options;
1337     object->output_window = window;
1338     InitializeCriticalSection(&object->cs);
1339     if (FAILED(hr = CreatePropertyStore(&object->propstore)))
1340         goto failed;
1341     if (FAILED(hr = MFCreateSourceResolver(&object->resolver)))
1342         goto failed;
1343     if (FAILED(hr = MFCreateMediaSession(NULL, &object->session)))
1344         goto failed;
1345     if (FAILED(hr = IMFMediaSession_BeginGetEvent(object->session, &object->session_events_callback, NULL)))
1346         goto failed;
1347     if (!(object->options & MFP_OPTION_FREE_THREADED_CALLBACK))
1348     {
1349         object->event_window = CreateWindowW(eventclassW, NULL, 0, 0, 0, 0, 0, HWND_MESSAGE,
1350                 0, mfplay_instance, NULL);
1351     }
1352
1353     *player = &object->IMFPMediaPlayer_iface;
1354
1355     return S_OK;
1356
1357 failed:
1358
1359     IMFPMediaPlayer_Release(&object->IMFPMediaPlayer_iface);
1360
1361     return hr;
1362 }
1363
1364 static void media_player_register_window_class(void)
1365 {
1366     WNDCLASSW cls = { 0 };
1367
1368     cls.lpfnWndProc = media_player_event_proc;
1369     cls.hInstance = mfplay_instance;
1370     cls.lpszClassName = eventclassW;
1371
1372     RegisterClassW(&cls);
1373 }
1374
1375 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
1376 {
1377     switch (reason)
1378     {
1379         case DLL_PROCESS_ATTACH:
1380             mfplay_instance = instance;
1381             DisableThreadLibraryCalls(instance);
1382             media_player_register_window_class();
1383             break;
1384         case DLL_PROCESS_DETACH:
1385             if (reserved) break;
1386             UnregisterClassW(eventclassW, instance);
1387             break;
1388     }
1389
1390     return TRUE;
1391 }