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 #include <assert.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "mfapi.h"
  27 #include "mfplay.h"
  28 #include "mferror.h"
  29
  30 #include "wine/debug.h"
  31
  32 #include "initguid.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  35
  36 DEFINE_GUID(_MF_TOPO_MEDIA_ITEM, 0x6c1bb4df, 0x59ba, 0x4020, 0x85, 0x0c, 0x35, 0x79, 0xa2, 0x7a, 0xe2, 0x51);
  37 DEFINE_GUID(_MF_CUSTOM_SINK, 0x7c1bb4df, 0x59ba, 0x4020, 0x85, 0x0c, 0x35, 0x79, 0xa2, 0x7a, 0xe2, 0x51);
  38
  39 static const WCHAR eventclassW[] = L"MediaPlayerEventCallbackClass";
  40
  41 static LONG startup_refcount;
  42 static HINSTANCE mfplay_instance;
  43
  44 static void platform_startup(void)
  45 {
  46     if (InterlockedIncrement(&startup_refcount) == 1)
  47         MFStartup(MF_VERSION, MFSTARTUP_FULL);
  48 }
  49
  50 static void platform_shutdown(void)
  51 {
  52     if (InterlockedDecrement(&startup_refcount) == 0)
  53         MFShutdown();
  54 }
  55
  56 struct media_item
  57 {
  58     IMFPMediaItem IMFPMediaItem_iface;
  59     LONG refcount;
  60     IMFPMediaPlayer *player;
  61     IMFMediaSource *source;
  62     IMFPresentationDescriptor *pd;
  63     DWORD_PTR user_data;
  64     WCHAR *url;
  65     IUnknown *object;
  66 };
  67
  68 struct media_player
  69 {
  70     IMFPMediaPlayer IMFPMediaPlayer_iface;
  71     IPropertyStore IPropertyStore_iface;
  72     IMFAsyncCallback resolver_callback;
  73     IMFAsyncCallback events_callback;
  74     IMFAsyncCallback session_events_callback;
  75     LONG refcount;
  76     IMFPMediaPlayerCallback *callback;
  77     IPropertyStore *propstore;
  78     IMFSourceResolver *resolver;
  79     IMFMediaSession *session;
  80     IMFPMediaItem *item;
  81     MFP_CREATION_OPTIONS options;
  82     MFP_MEDIAPLAYER_STATE state;
  83     HWND event_window;
  84     HWND output_window;
  85     CRITICAL_SECTION cs;
  86 };
  87
  88 struct generic_event
  89 {
  90     MFP_EVENT_HEADER header;
  91     IMFPMediaItem *item;
  92 };
  93
  94 struct media_event
  95 {
  96     IUnknown IUnknown_iface;
  97     LONG refcount;
  98     union
  99     {
 100         MFP_EVENT_HEADER header;
 101         struct generic_event generic;
 102         MFP_PLAY_EVENT play;
 103         MFP_PAUSE_EVENT pause;
 104         MFP_STOP_EVENT stop;
 105         MFP_POSITION_SET_EVENT position_set;
 106         MFP_RATE_SET_EVENT rate_set;
 107         MFP_MEDIAITEM_CREATED_EVENT item_created;
 108         MFP_MEDIAITEM_SET_EVENT item_set;
 109         MFP_MEDIAITEM_CLEARED_EVENT item_cleared;
 110         MFP_MF_EVENT event;
 111         MFP_ERROR_EVENT error;
 112         MFP_PLAYBACK_ENDED_EVENT ended;
 113         MFP_ACQUIRE_USER_CREDENTIAL_EVENT acquire_creds;
 114     } u;
 115 };
 116
 117 static struct media_player *impl_from_IMFPMediaPlayer(IMFPMediaPlayer *iface)
 118 {
 119     return CONTAINING_RECORD(iface, struct media_player, IMFPMediaPlayer_iface);
 120 }
 121
 122 static struct media_player *impl_from_IPropertyStore(IPropertyStore *iface)
 123 {
 124     return CONTAINING_RECORD(iface, struct media_player, IPropertyStore_iface);
 125 }
 126
 127 static struct media_player *impl_from_resolver_IMFAsyncCallback(IMFAsyncCallback *iface)
 128 {
 129     return CONTAINING_RECORD(iface, struct media_player, resolver_callback);
 130 }
 131
 132 static struct media_player *impl_from_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 133 {
 134     return CONTAINING_RECORD(iface, struct media_player, events_callback);
 135 }
 136
 137 static struct media_player *impl_from_session_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 138 {
 139     return CONTAINING_RECORD(iface, struct media_player, session_events_callback);
 140 }
 141
 142 static struct media_item *impl_from_IMFPMediaItem(IMFPMediaItem *iface)
 143 {
 144     return CONTAINING_RECORD(iface, struct media_item, IMFPMediaItem_iface);
 145 }
 146
 147 static struct media_event *impl_event_from_IUnknown(IUnknown *iface)
 148 {
 149     return CONTAINING_RECORD(iface, struct media_event, IUnknown_iface);
 150 }
 151
 152 static HRESULT WINAPI media_event_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 153 {
 154     if (IsEqualIID(riid, &IID_IUnknown))
 155     {
 156         *obj = iface;
 157         IUnknown_AddRef(iface);
 158         return S_OK;
 159     }
 160
 161     *obj = NULL;
 162     return E_NOINTERFACE;
 163 }
 164
 165 static ULONG WINAPI media_event_AddRef(IUnknown *iface)
 166 {
 167     struct media_event *event = impl_event_from_IUnknown(iface);
 168     ULONG refcount = InterlockedIncrement(&event->refcount);
 169
 170     TRACE("%p, refcount %u.\n", iface, refcount);
 171
 172     return refcount;
 173 }
 174
 175 static ULONG WINAPI media_event_Release(IUnknown *iface)
 176 {
 177     struct media_event *event = impl_event_from_IUnknown(iface);
 178     ULONG refcount = InterlockedDecrement(&event->refcount);
 179
 180     TRACE("%p, refcount %u.\n", iface, refcount);
 181
 182     if (!refcount)
 183     {
 184         if (event->u.header.pMediaPlayer)
 185             IMFPMediaPlayer_Release(event->u.header.pMediaPlayer);
 186         if (event->u.header.pPropertyStore)
 187             IPropertyStore_Release(event->u.header.pPropertyStore);
 188
 189         switch (event->u.header.eEventType)
 190         {
 191             /* Most types share same layout. */
 192             case MFP_EVENT_TYPE_PLAY:
 193             case MFP_EVENT_TYPE_PAUSE:
 194             case MFP_EVENT_TYPE_STOP:
 195             case MFP_EVENT_TYPE_POSITION_SET:
 196             case MFP_EVENT_TYPE_RATE_SET:
 197             case MFP_EVENT_TYPE_MEDIAITEM_CREATED:
 198             case MFP_EVENT_TYPE_MEDIAITEM_SET:
 199             case MFP_EVENT_TYPE_FRAME_STEP:
 200             case MFP_EVENT_TYPE_MEDIAITEM_CLEARED:
 201             case MFP_EVENT_TYPE_PLAYBACK_ENDED:
 202                 if (event->u.generic.item)
 203                     IMFPMediaItem_Release(event->u.generic.item);
 204                 break;
 205             case MFP_EVENT_TYPE_MF:
 206                 if (event->u.event.pMFMediaEvent)
 207                     IMFMediaEvent_Release(event->u.event.pMFMediaEvent);
 208                 if (event->u.event.pMediaItem)
 209                     IMFPMediaItem_Release(event->u.event.pMediaItem);
 210                 break;
 211             default:
 212                 FIXME("Unsupported event %u.\n", event->u.header.eEventType);
 213                 break;
 214         }
 215
 216         free(event);
 217     }
 218
 219     return refcount;
 220 }
 221
 222 static const IUnknownVtbl media_event_vtbl =
 223 {
 224     media_event_QueryInterface,
 225     media_event_AddRef,
 226     media_event_Release,
 227 };
 228
 229 static HRESULT media_event_create(struct media_player *player, MFP_EVENT_TYPE event_type,
 230         HRESULT hr, IMFPMediaItem *item, struct media_event **event)
 231 {
 232     struct media_event *object;
 233
 234     if (!(object = calloc(1, sizeof(*object))))
 235         return E_OUTOFMEMORY;
 236
 237     object->IUnknown_iface.lpVtbl = &media_event_vtbl;
 238     object->refcount = 1;
 239     object->u.header.eEventType = event_type;
 240     object->u.header.hrEvent = hr;
 241     object->u.header.pMediaPlayer = &player->IMFPMediaPlayer_iface;
 242     IMFPMediaPlayer_AddRef(object->u.header.pMediaPlayer);
 243     object->u.header.eState = player->state;
 244     switch (event_type)
 245     {
 246         case MFP_EVENT_TYPE_PLAY:
 247         case MFP_EVENT_TYPE_PAUSE:
 248         case MFP_EVENT_TYPE_STOP:
 249         case MFP_EVENT_TYPE_POSITION_SET:
 250         case MFP_EVENT_TYPE_RATE_SET:
 251         case MFP_EVENT_TYPE_MEDIAITEM_CREATED:
 252         case MFP_EVENT_TYPE_MEDIAITEM_SET:
 253         case MFP_EVENT_TYPE_FRAME_STEP:
 254         case MFP_EVENT_TYPE_MEDIAITEM_CLEARED:
 255         case MFP_EVENT_TYPE_PLAYBACK_ENDED:
 256             object->u.generic.item = item;
 257             if (object->u.generic.item)
 258                 IMFPMediaItem_AddRef(object->u.generic.item);
 259             break;
 260         case MFP_EVENT_TYPE_MF:
 261             object->u.event.pMediaItem = item;
 262             if (object->u.event.pMediaItem)
 263                 IMFPMediaItem_AddRef(object->u.event.pMediaItem);
 264             break;
 265         default:
 266             ;
 267     }
 268
 269     /* FIXME: set properties for some events? */
 270
 271     *event = object;
 272
 273     return S_OK;
 274 }
 275
 276 static LRESULT WINAPI media_player_event_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 277 {
 278     struct media_event *event = (void *)lparam;
 279     struct media_player *player;
 280
 281     if (msg == WM_USER)
 282     {
 283         player = impl_from_IMFPMediaPlayer(event->u.header.pMediaPlayer);
 284         if (player->callback)
 285             IMFPMediaPlayerCallback_OnMediaPlayerEvent(player->callback, &event->u.header);
 286         IUnknown_Release(&event->IUnknown_iface);
 287         return 0;
 288     }
 289
 290     return DefWindowProcW(hwnd, msg, wparam, lparam);
 291 }
 292
 293 static void media_player_set_state(struct media_player *player, MFP_MEDIAPLAYER_STATE state)
 294 {
 295     if (player->state != MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 296     {
 297         if (state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 298             IMFMediaSession_Shutdown(player->session);
 299         player->state = state;
 300     }
 301 }
 302
 303 static HRESULT WINAPI media_item_QueryInterface(IMFPMediaItem *iface, REFIID riid, void **obj)
 304 {
 305     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 306
 307     if (IsEqualIID(riid, &IID_IMFPMediaItem) ||
 308             IsEqualIID(riid, &IID_IUnknown))
 309     {
 310         *obj = iface;
 311         IMFPMediaItem_AddRef(iface);
 312         return S_OK;
 313     }
 314
 315     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 316     *obj = NULL;
 317     return E_NOINTERFACE;
 318 }
 319
 320 static ULONG WINAPI media_item_AddRef(IMFPMediaItem *iface)
 321 {
 322     struct media_item *item = impl_from_IMFPMediaItem(iface);
 323     ULONG refcount = InterlockedIncrement(&item->refcount);
 324
 325     TRACE("%p, refcount %u.\n", iface, refcount);
 326
 327     return refcount;
 328 }
 329
 330 static ULONG WINAPI media_item_Release(IMFPMediaItem *iface)
 331 {
 332     struct media_item *item = impl_from_IMFPMediaItem(iface);
 333     ULONG refcount = InterlockedDecrement(&item->refcount);
 334
 335     TRACE("%p, refcount %u.\n", iface, refcount);
 336
 337     if (!refcount)
 338     {
 339         if (item->player)
 340             IMFPMediaPlayer_Release(item->player);
 341         if (item->source)
 342             IMFMediaSource_Release(item->source);
 343         if (item->pd)
 344             IMFPresentationDescriptor_Release(item->pd);
 345         if (item->object)
 346             IUnknown_Release(item->object);
 347         free(item->url);
 348         free(item);
 349     }
 350
 351     return refcount;
 352 }
 353
 354 static HRESULT WINAPI media_item_GetMediaPlayer(IMFPMediaItem *iface,
 355         IMFPMediaPlayer **player)
 356 {
 357     struct media_item *item = impl_from_IMFPMediaItem(iface);
 358
 359     TRACE("%p, %p.\n", iface, player);
 360
 361     *player = item->player;
 362     IMFPMediaPlayer_AddRef(*player);
 363
 364     return S_OK;
 365 }
 366
 367 static HRESULT WINAPI media_item_GetURL(IMFPMediaItem *iface, LPWSTR *url)
 368 {
 369     struct media_item *item = impl_from_IMFPMediaItem(iface);
 370
 371     TRACE("%p, %p.\n", iface, url);
 372
 373     if (!item->url)
 374         return MF_E_NOT_FOUND;
 375
 376     if (!(*url = CoTaskMemAlloc((wcslen(item->url) + 1) * sizeof(*item->url))))
 377         return E_OUTOFMEMORY;
 378
 379     wcscpy(*url, item->url);
 380
 381     return S_OK;
 382 }
 383
 384 static HRESULT WINAPI media_item_GetObject(IMFPMediaItem *iface, IUnknown **object)
 385 {
 386     struct media_item *item = impl_from_IMFPMediaItem(iface);
 387
 388     TRACE("%p, %p.\n", iface, object);
 389
 390     if (!item->object)
 391         return MF_E_NOT_FOUND;
 392
 393     *object = item->object;
 394     IUnknown_AddRef(*object);
 395
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI media_item_GetUserData(IMFPMediaItem *iface, DWORD_PTR *user_data)
 400 {
 401     struct media_item *item = impl_from_IMFPMediaItem(iface);
 402
 403     TRACE("%p, %p.\n", iface, user_data);
 404
 405     *user_data = item->user_data;
 406
 407     return S_OK;
 408 }
 409
 410 static HRESULT WINAPI media_item_SetUserData(IMFPMediaItem *iface, DWORD_PTR user_data)
 411 {
 412     struct media_item *item = impl_from_IMFPMediaItem(iface);
 413
 414     TRACE("%p, %lx.\n", iface, user_data);
 415
 416     item->user_data = user_data;
 417
 418     return S_OK;
 419 }
 420
 421 static HRESULT WINAPI media_item_GetStartStopPosition(IMFPMediaItem *iface, GUID *start_format,
 422         PROPVARIANT *start_position, GUID *stop_format, PROPVARIANT *stop_position)
 423 {
 424     FIXME("%p, %p, %p, %p, %p.\n", iface, start_format, start_position, stop_format, stop_position);
 425
 426     return E_NOTIMPL;
 427 }
 428
 429 static HRESULT WINAPI media_item_SetStartStopPosition(IMFPMediaItem *iface, const GUID *start_format,
 430         const PROPVARIANT *start_position, const GUID *stop_format, const PROPVARIANT *stop_position)
 431 {
 432     FIXME("%p, %s, %p, %s, %p.\n", iface, debugstr_guid(start_format), start_position,
 433             debugstr_guid(stop_format), stop_position);
 434
 435     return E_NOTIMPL;
 436 }
 437
 438 static HRESULT WINAPI media_item_HasVideo(IMFPMediaItem *iface, BOOL *has_video, BOOL *selected)
 439 {
 440     FIXME("%p, %p, %p.\n", iface, has_video, selected);
 441
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI media_item_HasAudio(IMFPMediaItem *iface, BOOL *has_audio, BOOL *selected)
 446 {
 447     FIXME("%p, %p, %p.\n", iface, has_audio, selected);
 448
 449     return E_NOTIMPL;
 450 }
 451
 452 static HRESULT WINAPI media_item_IsProtected(IMFPMediaItem *iface, BOOL *protected)
 453 {
 454     struct media_item *item = impl_from_IMFPMediaItem(iface);
 455
 456     TRACE("%p, %p.\n", iface, protected);
 457
 458     *protected = MFRequireProtectedEnvironment(item->pd) == S_OK;
 459
 460     return S_OK;
 461 }
 462
 463 static HRESULT WINAPI media_item_GetDuration(IMFPMediaItem *iface, REFGUID format, PROPVARIANT *value)
 464 {
 465     struct media_item *item = impl_from_IMFPMediaItem(iface);
 466
 467     TRACE("%p, %s, %p.\n", iface, debugstr_guid(format), value);
 468
 469     return IMFPresentationDescriptor_GetItem(item->pd, &MF_PD_DURATION, value);
 470 }
 471
 472 static HRESULT WINAPI media_item_GetNumberOfStreams(IMFPMediaItem *iface, DWORD *count)
 473 {
 474     struct media_item *item = impl_from_IMFPMediaItem(iface);
 475
 476     TRACE("%p, %p.\n", iface, count);
 477
 478     return IMFPresentationDescriptor_GetStreamDescriptorCount(item->pd, count);
 479 }
 480
 481 static HRESULT WINAPI media_item_GetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL *selected)
 482 {
 483     struct media_item *item = impl_from_IMFPMediaItem(iface);
 484     IMFStreamDescriptor *sd;
 485     HRESULT hr;
 486
 487     TRACE("%p, %u, %p.\n", iface, index, selected);
 488
 489     if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, selected, &sd)))
 490         IMFStreamDescriptor_Release(sd);
 491
 492     return hr;
 493 }
 494
 495 static HRESULT WINAPI media_item_SetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL select)
 496 {
 497     struct media_item *item = impl_from_IMFPMediaItem(iface);
 498
 499     TRACE("%p, %u, %d.\n", iface, index, select);
 500
 501     return select ? IMFPresentationDescriptor_SelectStream(item->pd, index) :
 502             IMFPresentationDescriptor_DeselectStream(item->pd, index);
 503 }
 504
 505 static HRESULT WINAPI media_item_GetStreamAttribute(IMFPMediaItem *iface, DWORD index, REFGUID key,
 506         PROPVARIANT *value)
 507 {
 508     struct media_item *item = impl_from_IMFPMediaItem(iface);
 509     IMFStreamDescriptor *sd;
 510     BOOL selected;
 511     HRESULT hr;
 512
 513     TRACE("%p, %u, %s, %p.\n", iface, index, debugstr_guid(key), value);
 514
 515     if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, &selected, &sd)))
 516     {
 517         hr = IMFStreamDescriptor_GetItem(sd, key, value);
 518         IMFStreamDescriptor_Release(sd);
 519     }
 520
 521     return hr;
 522 }
 523
 524 static HRESULT WINAPI media_item_GetPresentationAttribute(IMFPMediaItem *iface, REFGUID key,
 525         PROPVARIANT *value)
 526 {
 527     struct media_item *item = impl_from_IMFPMediaItem(iface);
 528
 529     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 530
 531     return IMFPresentationDescriptor_GetItem(item->pd, key, value);
 532 }
 533
 534 static HRESULT WINAPI media_item_GetCharacteristics(IMFPMediaItem *iface, MFP_MEDIAITEM_CHARACTERISTICS *flags)
 535 {
 536     struct media_item *item = impl_from_IMFPMediaItem(iface);
 537     HRESULT hr;
 538
 539     TRACE("%p, %p.\n", iface, flags);
 540
 541     *flags = 0;
 542
 543     if (SUCCEEDED(hr = IMFMediaSource_GetCharacteristics(item->source, flags)))
 544     {
 545         *flags &= (MFP_MEDIAITEM_IS_LIVE | MFP_MEDIAITEM_CAN_SEEK |
 546                 MFP_MEDIAITEM_CAN_PAUSE | MFP_MEDIAITEM_HAS_SLOW_SEEK);
 547     }
 548
 549     return hr;
 550 }
 551
 552 static HRESULT WINAPI media_item_SetStreamSink(IMFPMediaItem *iface, DWORD index, IUnknown *sink)
 553 {
 554     struct media_item *item = impl_from_IMFPMediaItem(iface);
 555     IMFStreamDescriptor *sd;
 556     IUnknown *sink_object;
 557     BOOL selected;
 558     HRESULT hr;
 559
 560     TRACE("%p, %u, %p.\n", iface, index, sink);
 561
 562     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, &selected, &sd)))
 563         return hr;
 564
 565     if (sink)
 566     {
 567         if (FAILED(hr = IUnknown_QueryInterface(sink, &IID_IMFStreamSink, (void **)&sink_object)))
 568             hr = IUnknown_QueryInterface(sink, &IID_IMFActivate, (void **)&sink_object);
 569
 570         if (sink_object)
 571         {
 572             hr = IMFStreamDescriptor_SetUnknown(sd, &_MF_CUSTOM_SINK, sink_object);
 573             IUnknown_Release(sink_object);
 574         }
 575     }
 576     else
 577         IMFStreamDescriptor_DeleteItem(sd, &_MF_CUSTOM_SINK);
 578
 579     IMFStreamDescriptor_Release(sd);
 580
 581     return hr;
 582 }
 583
 584 static HRESULT WINAPI media_item_GetMetadata(IMFPMediaItem *iface, IPropertyStore **metadata)
 585 {
 586     struct media_item *item = impl_from_IMFPMediaItem(iface);
 587
 588     TRACE("%p, %p.\n", iface, metadata);
 589
 590     return MFGetService((IUnknown *)item->source, &MF_PROPERTY_HANDLER_SERVICE,
 591             &IID_IPropertyStore, (void **)&metadata);
 592 }
 593
 594 static const IMFPMediaItemVtbl media_item_vtbl =
 595 {
 596     media_item_QueryInterface,
 597     media_item_AddRef,
 598     media_item_Release,
 599     media_item_GetMediaPlayer,
 600     media_item_GetURL,
 601     media_item_GetObject,
 602     media_item_GetUserData,
 603     media_item_SetUserData,
 604     media_item_GetStartStopPosition,
 605     media_item_SetStartStopPosition,
 606     media_item_HasVideo,
 607     media_item_HasAudio,
 608     media_item_IsProtected,
 609     media_item_GetDuration,
 610     media_item_GetNumberOfStreams,
 611     media_item_GetStreamSelection,
 612     media_item_SetStreamSelection,
 613     media_item_GetStreamAttribute,
 614     media_item_GetPresentationAttribute,
 615     media_item_GetCharacteristics,
 616     media_item_SetStreamSink,
 617     media_item_GetMetadata,
 618 };
 619
 620 static struct media_item *unsafe_impl_from_IMFPMediaItem(IMFPMediaItem *iface)
 621 {
 622     if (!iface)
 623         return NULL;
 624     assert(iface->lpVtbl == (IMFPMediaItemVtbl *)&media_item_vtbl);
 625     return CONTAINING_RECORD(iface, struct media_item, IMFPMediaItem_iface);
 626 }
 627
 628 static HRESULT create_media_item(IMFPMediaPlayer *player, DWORD_PTR user_data, struct media_item **item)
 629 {
 630     struct media_item *object;
 631
 632     if (!(object = calloc(1, sizeof(*object))))
 633         return E_OUTOFMEMORY;
 634
 635     object->IMFPMediaItem_iface.lpVtbl = &media_item_vtbl;
 636     object->refcount = 1;
 637     object->user_data = user_data;
 638     object->player = player;
 639     IMFPMediaPlayer_AddRef(object->player);
 640
 641     *item = object;
 642
 643     return S_OK;
 644 }
 645
 646 static HRESULT media_item_set_source(struct media_item *item, IUnknown *object)
 647 {
 648     IMFPresentationDescriptor *pd;
 649     IMFMediaSource *source;
 650     HRESULT hr;
 651
 652     if (FAILED(hr = IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
 653         return hr;
 654
 655     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(source, &pd)))
 656     {
 657         WARN("Failed to get presentation descriptor, hr %#x.\n", hr);
 658         IMFMediaSource_Release(source);
 659         return hr;
 660     }
 661
 662     item->source = source;
 663     item->pd = pd;
 664
 665     return hr;
 666 }
 667
 668 static void media_player_queue_event(struct media_player *player, struct media_event *event)
 669 {
 670     if (player->options & MFP_OPTION_FREE_THREADED_CALLBACK)
 671     {
 672         MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_MULTITHREADED, &player->events_callback, &event->IUnknown_iface);
 673     }
 674     else
 675     {
 676         IUnknown_AddRef(&event->IUnknown_iface);
 677         PostMessageW(player->event_window, WM_USER, 0, (LPARAM)event);
 678     }
 679 }
 680
 681 static HRESULT WINAPI media_player_QueryInterface(IMFPMediaPlayer *iface, REFIID riid, void **obj)
 682 {
 683     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 684
 685     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 686
 687     if (IsEqualIID(riid, &IID_IMFPMediaPlayer) ||
 688             IsEqualIID(riid, &IID_IUnknown))
 689     {
 690         *obj = &player->IMFPMediaPlayer_iface;
 691     }
 692     else if (IsEqualIID(riid, &IID_IPropertyStore))
 693     {
 694         *obj = &player->IPropertyStore_iface;
 695     }
 696     else
 697     {
 698         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 699         *obj = NULL;
 700
 701         return E_NOINTERFACE;
 702     }
 703
 704     IUnknown_AddRef((IUnknown *)*obj);
 705     return S_OK;
 706 }
 707
 708 static ULONG WINAPI media_player_AddRef(IMFPMediaPlayer *iface)
 709 {
 710     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 711     ULONG refcount = InterlockedIncrement(&player->refcount);
 712
 713     TRACE("%p, refcount %u.\n", iface, refcount);
 714
 715     return refcount;
 716 }
 717
 718 static ULONG WINAPI media_player_Release(IMFPMediaPlayer *iface)
 719 {
 720     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 721     ULONG refcount = InterlockedDecrement(&player->refcount);
 722
 723     TRACE("%p, refcount %u.\n", iface, refcount);
 724
 725     if (!refcount)
 726     {
 727         if (player->callback)
 728             IMFPMediaPlayerCallback_Release(player->callback);
 729         if (player->propstore)
 730             IPropertyStore_Release(player->propstore);
 731         if (player->resolver)
 732             IMFSourceResolver_Release(player->resolver);
 733         if (player->session)
 734             IMFMediaSession_Release(player->session);
 735         DestroyWindow(player->event_window);
 736         DeleteCriticalSection(&player->cs);
 737         free(player);
 738
 739         platform_shutdown();
 740     }
 741
 742     return refcount;
 743 }
 744
 745 static HRESULT WINAPI media_player_Play(IMFPMediaPlayer *iface)
 746 {
 747     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 748     PROPVARIANT pos;
 749
 750     TRACE("%p.\n", iface);
 751
 752     pos.vt = VT_EMPTY;
 753     return IMFMediaSession_Start(player->session, &GUID_NULL, &pos);
 754 }
 755
 756 static HRESULT WINAPI media_player_Pause(IMFPMediaPlayer *iface)
 757 {
 758     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 759
 760     TRACE("%p.\n", iface);
 761
 762     return IMFMediaSession_Pause(player->session);
 763 }
 764
 765 static HRESULT WINAPI media_player_Stop(IMFPMediaPlayer *iface)
 766 {
 767     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 768
 769     TRACE("%p.\n", iface);
 770
 771     return IMFMediaSession_Stop(player->session);
 772 }
 773
 774 static HRESULT WINAPI media_player_FrameStep(IMFPMediaPlayer *iface)
 775 {
 776     FIXME("%p.\n", iface);
 777
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI media_player_SetPosition(IMFPMediaPlayer *iface, REFGUID postype, const PROPVARIANT *position)
 782 {
 783     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 784
 785     return E_NOTIMPL;
 786 }
 787
 788 static HRESULT WINAPI media_player_GetPosition(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 789 {
 790     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 791
 792     return E_NOTIMPL;
 793 }
 794
 795 static HRESULT WINAPI media_player_GetDuration(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 796 {
 797     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 798
 799     return E_NOTIMPL;
 800 }
 801
 802 static HRESULT WINAPI media_player_SetRate(IMFPMediaPlayer *iface, float rate)
 803 {
 804     FIXME("%p, %f.\n", iface, rate);
 805
 806     return E_NOTIMPL;
 807 }
 808
 809 static HRESULT WINAPI media_player_GetRate(IMFPMediaPlayer *iface, float *rate)
 810 {
 811     FIXME("%p, %p.\n", iface, rate);
 812
 813     return E_NOTIMPL;
 814 }
 815
 816 static HRESULT WINAPI media_player_GetSupportedRates(IMFPMediaPlayer *iface, BOOL forward,
 817         float *slowest_rate, float *fastest_rate)
 818 {
 819     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 820     IMFRateSupport *rs;
 821     HRESULT hr;
 822
 823     TRACE("%p, %d, %p, %p.\n", iface, forward, slowest_rate, fastest_rate);
 824
 825     if (SUCCEEDED(hr = MFGetService((IUnknown *)player->session, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateSupport, (void **)&rs)))
 826     {
 827         if (SUCCEEDED(hr = IMFRateSupport_GetSlowestRate(rs, forward ? MFRATE_FORWARD : MFRATE_REVERSE, FALSE, slowest_rate)))
 828             hr = IMFRateSupport_GetFastestRate(rs, forward ? MFRATE_FORWARD : MFRATE_REVERSE, FALSE, fastest_rate);
 829         IMFRateSupport_Release(rs);
 830     }
 831
 832     return hr;
 833 }
 834
 835 static HRESULT WINAPI media_player_GetState(IMFPMediaPlayer *iface, MFP_MEDIAPLAYER_STATE *state)
 836 {
 837     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 838
 839     TRACE("%p, %p.\n", iface, state);
 840
 841     *state = player->state;
 842
 843     return S_OK;
 844 }
 845
 846 static HRESULT media_player_create_item_from_url(struct media_player *player,
 847         const WCHAR *url, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **ret)
 848 {
 849     struct media_item *item;
 850     MF_OBJECT_TYPE obj_type;
 851     IUnknown *object;
 852     HRESULT hr;
 853
 854     *ret = NULL;
 855
 856     if (FAILED(hr = create_media_item(&player->IMFPMediaPlayer_iface, user_data, &item)))
 857         return hr;
 858
 859     if (url && !(item->url = wcsdup(url)))
 860     {
 861         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 862         return E_OUTOFMEMORY;
 863     }
 864
 865     if (sync)
 866     {
 867         if (SUCCEEDED(hr = IMFSourceResolver_CreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE,
 868                 player->propstore, &obj_type, &object)))
 869         {
 870             hr = media_item_set_source(item, object);
 871             IUnknown_Release(object);
 872         }
 873
 874         if (SUCCEEDED(hr))
 875         {
 876             *ret = &item->IMFPMediaItem_iface;
 877             IMFPMediaItem_AddRef(*ret);
 878         }
 879
 880         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 881
 882         return hr;
 883     }
 884     else
 885     {
 886         hr = IMFSourceResolver_BeginCreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE,
 887             player->propstore, NULL, &player->resolver_callback, (IUnknown *)&item->IMFPMediaItem_iface);
 888
 889         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 890     }
 891
 892     return hr;
 893 }
 894
 895 static HRESULT WINAPI media_player_CreateMediaItemFromURL(IMFPMediaPlayer *iface,
 896         const WCHAR *url, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
 897 {
 898     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 899     HRESULT hr;
 900
 901     TRACE("%p, %s, %d, %lx, %p.\n", iface, debugstr_w(url), sync, user_data, item);
 902
 903     EnterCriticalSection(&player->cs);
 904     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 905         hr = MF_E_SHUTDOWN;
 906     else
 907         hr = media_player_create_item_from_url(player, url, sync, user_data, item);
 908     LeaveCriticalSection(&player->cs);
 909
 910     return hr;
 911 }
 912
 913 static HRESULT media_player_create_item_from_object(struct media_player *player,
 914         IUnknown *object, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **ret)
 915 {
 916     struct media_item *item;
 917     MF_OBJECT_TYPE obj_type;
 918     HRESULT hr;
 919     IMFByteStream *stream = NULL;
 920     IMFMediaSource *source = NULL;
 921
 922     *ret = NULL;
 923
 924     if (FAILED(hr = create_media_item(&player->IMFPMediaPlayer_iface, user_data, &item)))
 925         return hr;
 926
 927     item->object = object;
 928     IUnknown_AddRef(item->object);
 929
 930     if (FAILED(IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
 931         IUnknown_QueryInterface(object, &IID_IMFByteStream, (void **)&stream);
 932
 933     if (!source && !stream)
 934     {
 935         WARN("Unsupported object type.\n");
 936         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 937         return E_UNEXPECTED;
 938     }
 939
 940     if (sync)
 941     {
 942         if (stream)
 943             hr = IMFSourceResolver_CreateObjectFromByteStream(player->resolver, stream, NULL,
 944                     MF_RESOLUTION_MEDIASOURCE, player->propstore, &obj_type, &object);
 945         else
 946             IUnknown_AddRef(object);
 947
 948         if (SUCCEEDED(hr))
 949             hr = media_item_set_source(item, object);
 950
 951         IUnknown_Release(object);
 952
 953         if (SUCCEEDED(hr))
 954         {
 955             *ret = &item->IMFPMediaItem_iface;
 956             IMFPMediaItem_AddRef(*ret);
 957         }
 958
 959         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 960     }
 961     else
 962     {
 963         if (stream)
 964         {
 965             hr = IMFSourceResolver_BeginCreateObjectFromByteStream(player->resolver, stream, NULL, MF_RESOLUTION_MEDIASOURCE,
 966                     player->propstore, NULL, &player->resolver_callback, (IUnknown *)&item->IMFPMediaItem_iface);
 967         }
 968         else
 969         {
 970             /* Resolver callback will check again if item's object is a source. */
 971             hr = MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_MULTITHREADED, &player->resolver_callback,
 972                     (IUnknown *)&item->IMFPMediaItem_iface);
 973         }
 974
 975         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 976     }
 977
 978     if (source)
 979         IMFMediaSource_Release(source);
 980     if (stream)
 981         IMFByteStream_Release(stream);
 982
 983     return hr;
 984 }
 985
 986 static HRESULT WINAPI media_player_CreateMediaItemFromObject(IMFPMediaPlayer *iface,
 987         IUnknown *object, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
 988 {
 989     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 990     HRESULT hr;
 991
 992     TRACE("%p, %p, %d, %lx, %p.\n", iface, object, sync, user_data, item);
 993
 994     EnterCriticalSection(&player->cs);
 995     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 996         hr = MF_E_SHUTDOWN;
 997     else
 998         hr = media_player_create_item_from_object(player, object, sync, user_data, item);
 999     LeaveCriticalSection(&player->cs);
1000
1001     return hr;
1002 }
1003
1004 static HRESULT media_item_get_stream_type(IMFStreamDescriptor *sd, GUID *major)
1005 {
1006     IMFMediaTypeHandler *handler;
1007     HRESULT hr;
1008
1009     if (SUCCEEDED(hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler)))
1010     {
1011         hr = IMFMediaTypeHandler_GetMajorType(handler, major);
1012         IMFMediaTypeHandler_Release(handler);
1013     }
1014
1015     return hr;
1016 }
1017
1018 static HRESULT media_item_create_topology(struct media_player *player, struct media_item *item, IMFTopology **out)
1019 {
1020     IMFTopologyNode *src_node, *sink_node;
1021     IMFActivate *sar_activate;
1022     IMFStreamDescriptor *sd;
1023     IMFTopology *topology;
1024     unsigned int idx;
1025     BOOL selected;
1026     HRESULT hr;
1027     GUID major;
1028
1029     if (FAILED(hr = MFCreateTopology(&topology)))
1030         return hr;
1031
1032     /* FIXME: handle user sinks */
1033
1034     /* Use first stream if none selected. */
1035     if (player->output_window)
1036     {
1037         FIXME("Video streams are not handled.\n");
1038     }
1039
1040     /* Set up audio branches for all selected streams. */
1041
1042     idx = 0;
1043     while (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, idx++, &selected, &sd)))
1044     {
1045         if (selected && SUCCEEDED(media_item_get_stream_type(sd, &major)) && IsEqualGUID(&major, &MFMediaType_Audio))
1046         {
1047             if (SUCCEEDED(hr = MFCreateTopologyNode(MF_TOPOLOGY_SOURCESTREAM_NODE, &src_node)))
1048             {
1049                 IMFTopologyNode_SetUnknown(src_node, &MF_TOPONODE_SOURCE, (IUnknown *)item->source);
1050                 IMFTopologyNode_SetUnknown(src_node, &MF_TOPONODE_PRESENTATION_DESCRIPTOR, (IUnknown *)item->pd);
1051                 IMFTopologyNode_SetUnknown(src_node, &MF_TOPONODE_STREAM_DESCRIPTOR, (IUnknown *)sd);
1052
1053                 IMFTopology_AddNode(topology, src_node);
1054             }
1055
1056             if (SUCCEEDED(hr = MFCreateTopologyNode(MF_TOPOLOGY_OUTPUT_NODE, &sink_node)))
1057             {
1058                 if (SUCCEEDED(MFCreateAudioRendererActivate(&sar_activate)))
1059                 {
1060                     IMFTopologyNode_SetObject(sink_node, (IUnknown *)sar_activate);
1061                     IMFActivate_Release(sar_activate);
1062                 }
1063
1064                 IMFTopology_AddNode(topology, sink_node);
1065             }
1066
1067             if (src_node && sink_node)
1068                 IMFTopologyNode_ConnectOutput(src_node, 0, sink_node, 0);
1069
1070             if (src_node)
1071                 IMFTopologyNode_Release(src_node);
1072             if (sink_node)
1073                 IMFTopologyNode_Release(sink_node);
1074         }
1075
1076         IMFStreamDescriptor_Release(sd);
1077     }
1078
1079     *out = topology;
1080
1081     return S_OK;
1082 }
1083
1084 static HRESULT WINAPI media_player_SetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem *item_iface)
1085 {
1086     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1087     struct media_item *item = unsafe_impl_from_IMFPMediaItem(item_iface);
1088     IMFTopology *topology;
1089     HRESULT hr;
1090
1091     TRACE("%p, %p.\n", iface, item_iface);
1092
1093     if (item->player != iface)
1094         return E_INVALIDARG;
1095
1096     if (FAILED(hr = media_item_create_topology(player, item, &topology)))
1097         return hr;
1098
1099     IMFTopology_SetUnknown(topology, &_MF_TOPO_MEDIA_ITEM, (IUnknown *)item_iface);
1100     hr = IMFMediaSession_SetTopology(player->session, MFSESSION_SETTOPOLOGY_IMMEDIATE, topology);
1101     IMFTopology_Release(topology);
1102
1103     return hr;
1104 }
1105
1106 static HRESULT WINAPI media_player_ClearMediaItem(IMFPMediaPlayer *iface)
1107 {
1108     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1109
1110     TRACE("%p.\n", iface);
1111
1112     return IMFMediaSession_SetTopology(player->session, MFSESSION_SETTOPOLOGY_CLEAR_CURRENT, NULL);
1113 }
1114
1115 static HRESULT WINAPI media_player_GetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem **item)
1116 {
1117     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1118     HRESULT hr = S_OK;
1119
1120     TRACE("%p, %p.\n", iface, item);
1121
1122     if (!item)
1123         return E_POINTER;
1124
1125     EnterCriticalSection(&player->cs);
1126     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
1127         hr = MF_E_SHUTDOWN;
1128     else if (!player->item)
1129         hr = MF_E_NOT_FOUND;
1130     else
1131     {
1132         *item = player->item;
1133         IMFPMediaItem_AddRef(player->item);
1134     }
1135     LeaveCriticalSection(&player->cs);
1136
1137     return hr;
1138 }
1139
1140 static HRESULT WINAPI media_player_GetVolume(IMFPMediaPlayer *iface, float *volume)
1141 {
1142     FIXME("%p, %p.\n", iface, volume);
1143
1144     return E_NOTIMPL;
1145 }
1146
1147 static HRESULT WINAPI media_player_SetVolume(IMFPMediaPlayer *iface, float volume)
1148 {
1149     FIXME("%p, %.8e.\n", iface, volume);
1150
1151     return E_NOTIMPL;
1152 }
1153
1154 static HRESULT WINAPI media_player_GetBalance(IMFPMediaPlayer *iface, float *balance)
1155 {
1156     FIXME("%p, %p.\n", iface, balance);
1157
1158     return E_NOTIMPL;
1159 }
1160
1161 static HRESULT WINAPI media_player_SetBalance(IMFPMediaPlayer *iface, float balance)
1162 {
1163     FIXME("%p, %.8e.\n", iface, balance);
1164
1165     return E_NOTIMPL;
1166 }
1167
1168 static HRESULT WINAPI media_player_GetMute(IMFPMediaPlayer *iface, BOOL *mute)
1169 {
1170     FIXME("%p, %p.\n", iface, mute);
1171
1172     return E_NOTIMPL;
1173 }
1174
1175 static HRESULT WINAPI media_player_SetMute(IMFPMediaPlayer *iface, BOOL mute)
1176 {
1177     FIXME("%p, %d.\n", iface, mute);
1178
1179     return E_NOTIMPL;
1180 }
1181
1182 static HRESULT WINAPI media_player_GetNativeVideoSize(IMFPMediaPlayer *iface,
1183         SIZE *video, SIZE *arvideo)
1184 {
1185     FIXME("%p, %p, %p.\n", iface, video, arvideo);
1186
1187     return E_NOTIMPL;
1188 }
1189
1190 static HRESULT WINAPI media_player_GetIdealVideoSize(IMFPMediaPlayer *iface,
1191         SIZE *min_size, SIZE *max_size)
1192 {
1193     FIXME("%p, %p, %p.\n", iface, min_size, max_size);
1194
1195     return E_NOTIMPL;
1196 }
1197
1198 static HRESULT WINAPI media_player_SetVideoSourceRect(IMFPMediaPlayer *iface,
1199         MFVideoNormalizedRect const *rect)
1200 {
1201     FIXME("%p, %p.\n", iface, rect);
1202
1203     return E_NOTIMPL;
1204 }
1205
1206 static HRESULT WINAPI media_player_GetVideoSourceRect(IMFPMediaPlayer *iface,
1207         MFVideoNormalizedRect *rect)
1208 {
1209     FIXME("%p, %p.\n", iface, rect);
1210
1211     return E_NOTIMPL;
1212 }
1213
1214 static HRESULT WINAPI media_player_SetAspectRatioMode(IMFPMediaPlayer *iface, DWORD mode)
1215 {
1216     FIXME("%p, %u.\n", iface, mode);
1217
1218     return E_NOTIMPL;
1219 }
1220
1221 static HRESULT WINAPI media_player_GetAspectRatioMode(IMFPMediaPlayer *iface,
1222         DWORD *mode)
1223 {
1224     FIXME("%p, %p.\n", iface, mode);
1225
1226     return E_NOTIMPL;
1227 }
1228
1229 static HRESULT WINAPI media_player_GetVideoWindow(IMFPMediaPlayer *iface, HWND *window)
1230 {
1231     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1232
1233     TRACE("%p, %p.\n", iface, window);
1234
1235     *window = player->output_window;
1236
1237     return S_OK;
1238 }
1239
1240 static HRESULT WINAPI media_player_UpdateVideo(IMFPMediaPlayer *iface)
1241 {
1242     FIXME("%p.\n", iface);
1243
1244     return E_NOTIMPL;
1245 }
1246
1247 static HRESULT WINAPI media_player_SetBorderColor(IMFPMediaPlayer *iface, COLORREF color)
1248 {
1249     FIXME("%p, %#x.\n", iface, color);
1250
1251     return E_NOTIMPL;
1252 }
1253
1254 static HRESULT WINAPI media_player_GetBorderColor(IMFPMediaPlayer *iface, COLORREF *color)
1255 {
1256     FIXME("%p, %p.\n", iface, color);
1257
1258     return E_NOTIMPL;
1259 }
1260
1261 static HRESULT WINAPI media_player_InsertEffect(IMFPMediaPlayer *iface, IUnknown *effect,
1262         BOOL optional)
1263 {
1264     FIXME("%p, %p, %d.\n", iface, effect, optional);
1265
1266     return E_NOTIMPL;
1267 }
1268
1269 static HRESULT WINAPI media_player_RemoveEffect(IMFPMediaPlayer *iface, IUnknown *effect)
1270 {
1271     FIXME("%p, %p.\n", iface, effect);
1272
1273     return E_NOTIMPL;
1274 }
1275
1276 static HRESULT WINAPI media_player_RemoveAllEffects(IMFPMediaPlayer *iface)
1277 {
1278     FIXME("%p.\n", iface);
1279
1280     return E_NOTIMPL;
1281 }
1282
1283 static HRESULT WINAPI media_player_Shutdown(IMFPMediaPlayer *iface)
1284 {
1285     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1286
1287     TRACE("%p.\n", iface);
1288
1289     EnterCriticalSection(&player->cs);
1290     media_player_set_state(player, MFP_MEDIAPLAYER_STATE_SHUTDOWN);
1291     if (player->item)
1292     {
1293         IMFPMediaItem_Release(player->item);
1294         player->item = NULL;
1295     }
1296     LeaveCriticalSection(&player->cs);
1297
1298     return S_OK;
1299 }
1300
1301 static const IMFPMediaPlayerVtbl media_player_vtbl =
1302 {
1303     media_player_QueryInterface,
1304     media_player_AddRef,
1305     media_player_Release,
1306     media_player_Play,
1307     media_player_Pause,
1308     media_player_Stop,
1309     media_player_FrameStep,
1310     media_player_SetPosition,
1311     media_player_GetPosition,
1312     media_player_GetDuration,
1313     media_player_SetRate,
1314     media_player_GetRate,
1315     media_player_GetSupportedRates,
1316     media_player_GetState,
1317     media_player_CreateMediaItemFromURL,
1318     media_player_CreateMediaItemFromObject,
1319     media_player_SetMediaItem,
1320     media_player_ClearMediaItem,
1321     media_player_GetMediaItem,
1322     media_player_GetVolume,
1323     media_player_SetVolume,
1324     media_player_GetBalance,
1325     media_player_SetBalance,
1326     media_player_GetMute,
1327     media_player_SetMute,
1328     media_player_GetNativeVideoSize,
1329     media_player_GetIdealVideoSize,
1330     media_player_SetVideoSourceRect,
1331     media_player_GetVideoSourceRect,
1332     media_player_SetAspectRatioMode,
1333     media_player_GetAspectRatioMode,
1334     media_player_GetVideoWindow,
1335     media_player_UpdateVideo,
1336     media_player_SetBorderColor,
1337     media_player_GetBorderColor,
1338     media_player_InsertEffect,
1339     media_player_RemoveEffect,
1340     media_player_RemoveAllEffects,
1341     media_player_Shutdown,
1342 };
1343
1344 static HRESULT WINAPI media_player_propstore_QueryInterface(IPropertyStore *iface,
1345         REFIID riid, void **obj)
1346 {
1347     struct media_player *player = impl_from_IPropertyStore(iface);
1348     return IMFPMediaPlayer_QueryInterface(&player->IMFPMediaPlayer_iface, riid, obj);
1349 }
1350
1351 static ULONG WINAPI media_player_propstore_AddRef(IPropertyStore *iface)
1352 {
1353     struct media_player *player = impl_from_IPropertyStore(iface);
1354     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1355 }
1356
1357 static ULONG WINAPI media_player_propstore_Release(IPropertyStore *iface)
1358 {
1359     struct media_player *player = impl_from_IPropertyStore(iface);
1360     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1361 }
1362
1363 static HRESULT WINAPI media_player_propstore_GetCount(IPropertyStore *iface, DWORD *count)
1364 {
1365     struct media_player *player = impl_from_IPropertyStore(iface);
1366
1367     TRACE("%p, %p.\n", iface, count);
1368
1369     return IPropertyStore_GetCount(player->propstore, count);
1370 }
1371
1372 static HRESULT WINAPI media_player_propstore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1373 {
1374     struct media_player *player = impl_from_IPropertyStore(iface);
1375
1376     TRACE("%p, %u, %p.\n", iface, prop, key);
1377
1378     return IPropertyStore_GetAt(player->propstore, prop, key);
1379 }
1380
1381 static HRESULT WINAPI media_player_propstore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
1382 {
1383     struct media_player *player = impl_from_IPropertyStore(iface);
1384
1385     TRACE("%p, %p, %p.\n", iface, key, value);
1386
1387     return IPropertyStore_GetValue(player->propstore, key, value);
1388 }
1389
1390 static HRESULT WINAPI media_player_propstore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
1391 {
1392     struct media_player *player = impl_from_IPropertyStore(iface);
1393
1394     TRACE("%p, %p, %p.\n", iface, key, value);
1395
1396     return IPropertyStore_SetValue(player->propstore, key, value);
1397 }
1398
1399 static HRESULT WINAPI media_player_propstore_Commit(IPropertyStore *iface)
1400 {
1401     struct media_player *player = impl_from_IPropertyStore(iface);
1402
1403     TRACE("%p.\n", iface);
1404
1405     return IPropertyStore_Commit(player->propstore);
1406 }
1407
1408 static const IPropertyStoreVtbl media_player_propstore_vtbl =
1409 {
1410     media_player_propstore_QueryInterface,
1411     media_player_propstore_AddRef,
1412     media_player_propstore_Release,
1413     media_player_propstore_GetCount,
1414     media_player_propstore_GetAt,
1415     media_player_propstore_GetValue,
1416     media_player_propstore_SetValue,
1417     media_player_propstore_Commit,
1418 };
1419
1420 static HRESULT WINAPI media_player_callback_QueryInterface(IMFAsyncCallback *iface,
1421         REFIID riid, void **obj)
1422 {
1423     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1424             IsEqualIID(riid, &IID_IUnknown))
1425     {
1426         *obj = iface;
1427         IMFAsyncCallback_AddRef(iface);
1428         return S_OK;
1429     }
1430
1431     *obj = NULL;
1432     return E_NOINTERFACE;
1433 }
1434
1435 static ULONG WINAPI media_player_resolver_callback_AddRef(IMFAsyncCallback *iface)
1436 {
1437     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1438     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1439 }
1440
1441 static ULONG WINAPI media_player_resolver_callback_Release(IMFAsyncCallback *iface)
1442 {
1443     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1444     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1445 }
1446
1447 static HRESULT WINAPI media_player_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags,
1448         DWORD *queue)
1449 {
1450     return E_NOTIMPL;
1451 }
1452
1453 static HRESULT WINAPI media_player_resolver_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1454 {
1455     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1456     struct media_event *event;
1457     IUnknown *object, *state;
1458     MF_OBJECT_TYPE obj_type;
1459     struct media_item *item;
1460     HRESULT hr;
1461
1462     if (FAILED(IMFAsyncResult_GetState(result, &state)))
1463         return S_OK;
1464
1465     item = impl_from_IMFPMediaItem((IMFPMediaItem *)state);
1466
1467     if (item->object)
1468     {
1469         if (FAILED(hr = IUnknown_QueryInterface(item->object, &IID_IMFMediaSource, (void **)&object)))
1470             hr = IMFSourceResolver_EndCreateObjectFromByteStream(player->resolver, result, &obj_type, &object);
1471     }
1472     else
1473         hr = IMFSourceResolver_EndCreateObjectFromURL(player->resolver, result, &obj_type, &object);
1474
1475     if (SUCCEEDED(hr))
1476     {
1477         hr = media_item_set_source(item, object);
1478         IUnknown_Release(object);
1479     }
1480
1481     if (FAILED(hr))
1482         WARN("Failed to set media source, hr %#x.\n", hr);
1483
1484     if (FAILED(media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_CREATED, hr,
1485             &item->IMFPMediaItem_iface, &event)))
1486     {
1487         WARN("Failed to create event object.\n");
1488         IUnknown_Release(state);
1489         return S_OK;
1490     }
1491     event->u.item_created.dwUserData = item->user_data;
1492
1493     media_player_queue_event(player, event);
1494
1495     IUnknown_Release(&event->IUnknown_iface);
1496     IUnknown_Release(state);
1497
1498     return S_OK;
1499 }
1500
1501 static const IMFAsyncCallbackVtbl media_player_resolver_callback_vtbl =
1502 {
1503     media_player_callback_QueryInterface,
1504     media_player_resolver_callback_AddRef,
1505     media_player_resolver_callback_Release,
1506     media_player_callback_GetParameters,
1507     media_player_resolver_callback_Invoke,
1508 };
1509
1510 static ULONG WINAPI media_player_events_callback_AddRef(IMFAsyncCallback *iface)
1511 {
1512     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1513     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1514 }
1515
1516 static ULONG WINAPI media_player_events_callback_Release(IMFAsyncCallback *iface)
1517 {
1518     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1519     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1520 }
1521
1522 static HRESULT WINAPI media_player_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1523 {
1524     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1525     struct media_event *event;
1526     IUnknown *state;
1527
1528     if (FAILED(IMFAsyncResult_GetState(result, &state)))
1529         return S_OK;
1530
1531     event = impl_event_from_IUnknown(state);
1532
1533     if (player->callback)
1534         IMFPMediaPlayerCallback_OnMediaPlayerEvent(player->callback, &event->u.header);
1535
1536     IUnknown_Release(state);
1537
1538     return S_OK;
1539 }
1540
1541 static const IMFAsyncCallbackVtbl media_player_events_callback_vtbl =
1542 {
1543     media_player_callback_QueryInterface,
1544     media_player_events_callback_AddRef,
1545     media_player_events_callback_Release,
1546     media_player_callback_GetParameters,
1547     media_player_events_callback_Invoke,
1548 };
1549
1550 static ULONG WINAPI media_player_session_events_callback_AddRef(IMFAsyncCallback *iface)
1551 {
1552     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
1553     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1554 }
1555
1556 static ULONG WINAPI media_player_session_events_callback_Release(IMFAsyncCallback *iface)
1557 {
1558     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
1559     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1560 }
1561
1562 static void media_player_change_state(struct media_player *player, MFP_MEDIAPLAYER_STATE state,
1563         HRESULT event_status, struct media_event **event)
1564 {
1565     MFP_EVENT_TYPE event_type;
1566
1567     EnterCriticalSection(&player->cs);
1568
1569     if (state == MFP_MEDIAPLAYER_STATE_PLAYING)
1570         event_type = MFP_EVENT_TYPE_PLAY;
1571     else if (state == MFP_MEDIAPLAYER_STATE_PAUSED)
1572         event_type = MFP_EVENT_TYPE_PAUSE;
1573     else
1574         event_type = MFP_EVENT_TYPE_STOP;
1575
1576     media_player_set_state(player, state);
1577     media_event_create(player, event_type, event_status, player->item, event);
1578
1579     LeaveCriticalSection(&player->cs);
1580 }
1581
1582 static void media_player_set_item(struct media_player *player, IMFTopology *topology, HRESULT event_status,
1583         struct media_event **event)
1584 {
1585     IMFPMediaItem *item;
1586
1587     if (FAILED(IMFTopology_GetUnknown(topology, &_MF_TOPO_MEDIA_ITEM, &IID_IMFPMediaItem, (void **)&item)))
1588         return;
1589
1590     EnterCriticalSection(&player->cs);
1591
1592     if (player->item)
1593         IMFPMediaItem_Release(player->item);
1594     player->item = item;
1595     IMFPMediaItem_AddRef(player->item);
1596
1597     media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_SET, event_status, item, event);
1598
1599     LeaveCriticalSection(&player->cs);
1600
1601     IMFPMediaItem_Release(item);
1602 }
1603
1604 static void media_player_clear_item(struct media_player *player, HRESULT event_status,
1605         struct media_event **event)
1606 {
1607     IMFPMediaItem *item;
1608
1609     EnterCriticalSection(&player->cs);
1610
1611     item = player->item;
1612     player->item = NULL;
1613
1614     media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_SET, event_status, item, event);
1615
1616     LeaveCriticalSection(&player->cs);
1617 }
1618
1619 static void media_player_create_forward_event(struct media_player *player, HRESULT event_status, IMFMediaEvent *session_event,
1620         struct media_event **event)
1621 {
1622     EnterCriticalSection(&player->cs);
1623
1624     if (SUCCEEDED(media_event_create(player, MFP_EVENT_TYPE_MF, event_status, player->item, event)))
1625     {
1626         IMFMediaEvent_GetType(session_event, &(*event)->u.event.MFEventType);
1627         (*event)->u.event.pMFMediaEvent = session_event;
1628         IMFMediaEvent_AddRef((*event)->u.event.pMFMediaEvent);
1629     }
1630
1631     LeaveCriticalSection(&player->cs);
1632 }
1633
1634 static void media_player_create_playback_ended_event(struct media_player *player, HRESULT event_status,
1635         struct media_event **event)
1636 {
1637     EnterCriticalSection(&player->cs);
1638
1639     if (SUCCEEDED(media_event_create(player, MFP_EVENT_TYPE_PLAYBACK_ENDED, event_status, player->item, event)))
1640     {
1641         if (player->item)
1642             IMFPMediaItem_Release(player->item);
1643         player->item = NULL;
1644     }
1645
1646     LeaveCriticalSection(&player->cs);
1647 }
1648
1649 static HRESULT WINAPI media_player_session_events_callback_Invoke(IMFAsyncCallback *iface,
1650         IMFAsyncResult *result)
1651 {
1652     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
1653     MediaEventType session_event_type = MEUnknown;
1654     struct media_event *event = NULL;
1655     IMFMediaEvent *session_event;
1656     MFP_MEDIAPLAYER_STATE state;
1657     HRESULT hr, event_status;
1658     IMFPMediaItem *item = NULL;
1659     IMFTopology *topology;
1660     unsigned int status;
1661     PROPVARIANT value;
1662
1663     if (FAILED(hr = IMFMediaSession_EndGetEvent(player->session, result, &session_event)))
1664         return S_OK;
1665
1666     IMFMediaEvent_GetType(session_event, &session_event_type);
1667     IMFMediaEvent_GetStatus(session_event, &event_status);
1668
1669     switch (session_event_type)
1670     {
1671         case MESessionStarted:
1672         case MESessionStopped:
1673         case MESessionPaused:
1674
1675             if (session_event_type == MESessionStarted)
1676                 state = MFP_MEDIAPLAYER_STATE_PLAYING;
1677             else if (session_event_type == MESessionPaused)
1678                 state = MFP_MEDIAPLAYER_STATE_PAUSED;
1679             else
1680                 state = MFP_MEDIAPLAYER_STATE_STOPPED;
1681
1682             media_player_change_state(player, state, event_status, &event);
1683
1684             break;
1685
1686         case MESessionTopologySet:
1687
1688             value.vt = VT_EMPTY;
1689             if (SUCCEEDED(IMFMediaEvent_GetValue(session_event, &value)))
1690             {
1691                 if (value.vt == VT_EMPTY)
1692                 {
1693                     media_player_clear_item(player, event_status, &event);
1694                 }
1695                 else if (value.vt == VT_UNKNOWN && value.punkVal &&
1696                         SUCCEEDED(IUnknown_QueryInterface(value.punkVal, &IID_IMFTopology, (void **)&topology)))
1697                 {
1698                     media_player_set_item(player, topology, event_status, &event);
1699                     IMFTopology_Release(topology);
1700                 }
1701                 PropVariantClear(&value);
1702             }
1703
1704             break;
1705
1706         case MESessionTopologyStatus:
1707
1708             if (SUCCEEDED(IMFMediaEvent_GetUINT32(session_event, &MF_EVENT_TOPOLOGY_STATUS, &status)) &&
1709                     status == MF_TOPOSTATUS_ENDED)
1710             {
1711                 media_player_create_playback_ended_event(player, event_status, &event);
1712             }
1713
1714             break;
1715
1716         case MEBufferingStarted:
1717         case MEBufferingStopped:
1718         case MEExtendedType:
1719         case MEReconnectStart:
1720         case MEReconnectEnd:
1721         case MERendererEvent:
1722         case MEStreamSinkFormatChanged:
1723
1724             media_player_create_forward_event(player, event_status, session_event, &event);
1725
1726             break;
1727
1728         case MEError:
1729
1730             media_event_create(player, MFP_EVENT_TYPE_ERROR, event_status, NULL, &event);
1731
1732             break;
1733
1734         default:
1735             ;
1736     }
1737
1738     if (item)
1739         IMFPMediaItem_Release(item);
1740
1741     if (event)
1742     {
1743         media_player_queue_event(player, event);
1744         IUnknown_Release(&event->IUnknown_iface);
1745     }
1746
1747     IMFMediaSession_BeginGetEvent(player->session, &player->session_events_callback, NULL);
1748     IMFMediaEvent_Release(session_event);
1749
1750     return S_OK;
1751 }
1752
1753 static const IMFAsyncCallbackVtbl media_player_session_events_callback_vtbl =
1754 {
1755     media_player_callback_QueryInterface,
1756     media_player_session_events_callback_AddRef,
1757     media_player_session_events_callback_Release,
1758     media_player_callback_GetParameters,
1759     media_player_session_events_callback_Invoke,
1760 };
1761
1762 HRESULT WINAPI MFPCreateMediaPlayer(const WCHAR *url, BOOL start_playback, MFP_CREATION_OPTIONS options,
1763         IMFPMediaPlayerCallback *callback, HWND window, IMFPMediaPlayer **player)
1764 {
1765     struct media_player *object;
1766     HRESULT hr;
1767
1768     TRACE("%s, %d, %#x, %p, %p, %p.\n", debugstr_w(url), start_playback, options, callback, window, player);
1769
1770     if (!(object = calloc(1, sizeof(*object))))
1771         return E_OUTOFMEMORY;
1772
1773     platform_startup();
1774
1775     object->IMFPMediaPlayer_iface.lpVtbl = &media_player_vtbl;
1776     object->IPropertyStore_iface.lpVtbl = &media_player_propstore_vtbl;
1777     object->resolver_callback.lpVtbl = &media_player_resolver_callback_vtbl;
1778     object->events_callback.lpVtbl = &media_player_events_callback_vtbl;
1779     object->session_events_callback.lpVtbl = &media_player_session_events_callback_vtbl;
1780     object->refcount = 1;
1781     object->callback = callback;
1782     if (object->callback)
1783         IMFPMediaPlayerCallback_AddRef(object->callback);
1784     object->options = options;
1785     object->output_window = window;
1786     InitializeCriticalSection(&object->cs);
1787     if (FAILED(hr = CreatePropertyStore(&object->propstore)))
1788         goto failed;
1789     if (FAILED(hr = MFCreateSourceResolver(&object->resolver)))
1790         goto failed;
1791     if (FAILED(hr = MFCreateMediaSession(NULL, &object->session)))
1792         goto failed;
1793     if (FAILED(hr = IMFMediaSession_BeginGetEvent(object->session, &object->session_events_callback, NULL)))
1794         goto failed;
1795     if (!(object->options & MFP_OPTION_FREE_THREADED_CALLBACK))
1796     {
1797         object->event_window = CreateWindowW(eventclassW, NULL, 0, 0, 0, 0, 0, HWND_MESSAGE,
1798                 0, mfplay_instance, NULL);
1799     }
1800
1801     *player = &object->IMFPMediaPlayer_iface;
1802
1803     return S_OK;
1804
1805 failed:
1806
1807     IMFPMediaPlayer_Release(&object->IMFPMediaPlayer_iface);
1808
1809     return hr;
1810 }
1811
1812 static void media_player_register_window_class(void)
1813 {
1814     WNDCLASSW cls = { 0 };
1815
1816     cls.lpfnWndProc = media_player_event_proc;
1817     cls.hInstance = mfplay_instance;
1818     cls.lpszClassName = eventclassW;
1819
1820     RegisterClassW(&cls);
1821 }
1822
1823 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
1824 {
1825     switch (reason)
1826     {
1827         case DLL_PROCESS_ATTACH:
1828             mfplay_instance = instance;
1829             DisableThreadLibraryCalls(instance);
1830             media_player_register_window_class();
1831             break;
1832         case DLL_PROCESS_DETACH:
1833             if (reserved) break;
1834             UnregisterClassW(eventclassW, instance);
1835             break;
1836     }
1837
1838     return TRUE;
1839 }