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 static inline const char *debugstr_normalized_rect(const MFVideoNormalizedRect *rect)
  57 {
  58     if (!rect) return "(null)";
  59     return wine_dbg_sprintf("(%.8e,%.8e)-(%.8e,%.8e)", rect->left, rect->top, rect->right, rect->bottom);
  60 }
  61
  62 struct media_player;
  63
  64 enum media_item_flags
  65 {
  66     MEDIA_ITEM_SOURCE_NEEDS_SHUTDOWN = 0x1,
  67 };
  68
  69 struct media_item
  70 {
  71     IMFPMediaItem IMFPMediaItem_iface;
  72     LONG refcount;
  73     struct media_player *player;
  74     IMFMediaSource *source;
  75     IMFPresentationDescriptor *pd;
  76     DWORD_PTR user_data;
  77     WCHAR *url;
  78     IUnknown *object;
  79     LONGLONG start_position;
  80     LONGLONG stop_position;
  81     unsigned int flags;
  82 };
  83
  84 struct media_player
  85 {
  86     IMFPMediaPlayer IMFPMediaPlayer_iface;
  87     IPropertyStore IPropertyStore_iface;
  88     IMFAsyncCallback resolver_callback;
  89     IMFAsyncCallback events_callback;
  90     IMFAsyncCallback session_events_callback;
  91     LONG refcount;
  92     IMFPMediaPlayerCallback *callback;
  93     IPropertyStore *propstore;
  94     IMFSourceResolver *resolver;
  95     IMFMediaSession *session;
  96     IMFPMediaItem *item;
  97     MFP_CREATION_OPTIONS options;
  98     MFP_MEDIAPLAYER_STATE state;
  99     HWND event_window;
 100     HWND output_window;
 101     CRITICAL_SECTION cs;
 102 };
 103
 104 struct generic_event
 105 {
 106     MFP_EVENT_HEADER header;
 107     IMFPMediaItem *item;
 108 };
 109
 110 struct media_event
 111 {
 112     IUnknown IUnknown_iface;
 113     LONG refcount;
 114     union
 115     {
 116         MFP_EVENT_HEADER header;
 117         struct generic_event generic;
 118         MFP_PLAY_EVENT play;
 119         MFP_PAUSE_EVENT pause;
 120         MFP_STOP_EVENT stop;
 121         MFP_POSITION_SET_EVENT position_set;
 122         MFP_RATE_SET_EVENT rate_set;
 123         MFP_MEDIAITEM_CREATED_EVENT item_created;
 124         MFP_MEDIAITEM_SET_EVENT item_set;
 125         MFP_MEDIAITEM_CLEARED_EVENT item_cleared;
 126         MFP_MF_EVENT event;
 127         MFP_ERROR_EVENT error;
 128         MFP_PLAYBACK_ENDED_EVENT ended;
 129         MFP_ACQUIRE_USER_CREDENTIAL_EVENT acquire_creds;
 130     } u;
 131 };
 132
 133 static struct media_player *impl_from_IMFPMediaPlayer(IMFPMediaPlayer *iface)
 134 {
 135     return CONTAINING_RECORD(iface, struct media_player, IMFPMediaPlayer_iface);
 136 }
 137
 138 static struct media_player *impl_from_IPropertyStore(IPropertyStore *iface)
 139 {
 140     return CONTAINING_RECORD(iface, struct media_player, IPropertyStore_iface);
 141 }
 142
 143 static struct media_player *impl_from_resolver_IMFAsyncCallback(IMFAsyncCallback *iface)
 144 {
 145     return CONTAINING_RECORD(iface, struct media_player, resolver_callback);
 146 }
 147
 148 static struct media_player *impl_from_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 149 {
 150     return CONTAINING_RECORD(iface, struct media_player, events_callback);
 151 }
 152
 153 static struct media_player *impl_from_session_events_IMFAsyncCallback(IMFAsyncCallback *iface)
 154 {
 155     return CONTAINING_RECORD(iface, struct media_player, session_events_callback);
 156 }
 157
 158 static struct media_item *impl_from_IMFPMediaItem(IMFPMediaItem *iface)
 159 {
 160     return CONTAINING_RECORD(iface, struct media_item, IMFPMediaItem_iface);
 161 }
 162
 163 static struct media_event *impl_event_from_IUnknown(IUnknown *iface)
 164 {
 165     return CONTAINING_RECORD(iface, struct media_event, IUnknown_iface);
 166 }
 167
 168 static HRESULT WINAPI media_event_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 169 {
 170     if (IsEqualIID(riid, &IID_IUnknown))
 171     {
 172         *obj = iface;
 173         IUnknown_AddRef(iface);
 174         return S_OK;
 175     }
 176
 177     *obj = NULL;
 178     return E_NOINTERFACE;
 179 }
 180
 181 static ULONG WINAPI media_event_AddRef(IUnknown *iface)
 182 {
 183     struct media_event *event = impl_event_from_IUnknown(iface);
 184     ULONG refcount = InterlockedIncrement(&event->refcount);
 185
 186     TRACE("%p, refcount %lu.\n", iface, refcount);
 187
 188     return refcount;
 189 }
 190
 191 static ULONG WINAPI media_event_Release(IUnknown *iface)
 192 {
 193     struct media_event *event = impl_event_from_IUnknown(iface);
 194     ULONG refcount = InterlockedDecrement(&event->refcount);
 195
 196     TRACE("%p, refcount %lu.\n", iface, refcount);
 197
 198     if (!refcount)
 199     {
 200         if (event->u.header.pMediaPlayer)
 201             IMFPMediaPlayer_Release(event->u.header.pMediaPlayer);
 202         if (event->u.header.pPropertyStore)
 203             IPropertyStore_Release(event->u.header.pPropertyStore);
 204
 205         switch (event->u.header.eEventType)
 206         {
 207             /* Most types share same layout. */
 208             case MFP_EVENT_TYPE_PLAY:
 209             case MFP_EVENT_TYPE_PAUSE:
 210             case MFP_EVENT_TYPE_STOP:
 211             case MFP_EVENT_TYPE_POSITION_SET:
 212             case MFP_EVENT_TYPE_RATE_SET:
 213             case MFP_EVENT_TYPE_MEDIAITEM_CREATED:
 214             case MFP_EVENT_TYPE_MEDIAITEM_SET:
 215             case MFP_EVENT_TYPE_FRAME_STEP:
 216             case MFP_EVENT_TYPE_MEDIAITEM_CLEARED:
 217             case MFP_EVENT_TYPE_PLAYBACK_ENDED:
 218                 if (event->u.generic.item)
 219                     IMFPMediaItem_Release(event->u.generic.item);
 220                 break;
 221             case MFP_EVENT_TYPE_MF:
 222                 if (event->u.event.pMFMediaEvent)
 223                     IMFMediaEvent_Release(event->u.event.pMFMediaEvent);
 224                 if (event->u.event.pMediaItem)
 225                     IMFPMediaItem_Release(event->u.event.pMediaItem);
 226                 break;
 227             default:
 228                 FIXME("Unsupported event %u.\n", event->u.header.eEventType);
 229                 break;
 230         }
 231
 232         free(event);
 233     }
 234
 235     return refcount;
 236 }
 237
 238 static const IUnknownVtbl media_event_vtbl =
 239 {
 240     media_event_QueryInterface,
 241     media_event_AddRef,
 242     media_event_Release,
 243 };
 244
 245 static HRESULT media_event_create(struct media_player *player, MFP_EVENT_TYPE event_type,
 246         HRESULT hr, IMFPMediaItem *item, struct media_event **event)
 247 {
 248     struct media_event *object;
 249
 250     if (!(object = calloc(1, sizeof(*object))))
 251         return E_OUTOFMEMORY;
 252
 253     object->IUnknown_iface.lpVtbl = &media_event_vtbl;
 254     object->refcount = 1;
 255     object->u.header.eEventType = event_type;
 256     object->u.header.hrEvent = hr;
 257     object->u.header.pMediaPlayer = &player->IMFPMediaPlayer_iface;
 258     IMFPMediaPlayer_AddRef(object->u.header.pMediaPlayer);
 259     object->u.header.eState = player->state;
 260     switch (event_type)
 261     {
 262         case MFP_EVENT_TYPE_PLAY:
 263         case MFP_EVENT_TYPE_PAUSE:
 264         case MFP_EVENT_TYPE_STOP:
 265         case MFP_EVENT_TYPE_POSITION_SET:
 266         case MFP_EVENT_TYPE_RATE_SET:
 267         case MFP_EVENT_TYPE_MEDIAITEM_CREATED:
 268         case MFP_EVENT_TYPE_MEDIAITEM_SET:
 269         case MFP_EVENT_TYPE_FRAME_STEP:
 270         case MFP_EVENT_TYPE_MEDIAITEM_CLEARED:
 271         case MFP_EVENT_TYPE_PLAYBACK_ENDED:
 272             object->u.generic.item = item;
 273             if (object->u.generic.item)
 274                 IMFPMediaItem_AddRef(object->u.generic.item);
 275             break;
 276         case MFP_EVENT_TYPE_MF:
 277             object->u.event.pMediaItem = item;
 278             if (object->u.event.pMediaItem)
 279                 IMFPMediaItem_AddRef(object->u.event.pMediaItem);
 280             break;
 281         default:
 282             ;
 283     }
 284
 285     /* FIXME: set properties for some events? */
 286
 287     *event = object;
 288
 289     return S_OK;
 290 }
 291
 292 static LRESULT WINAPI media_player_event_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 293 {
 294     struct media_event *event = (void *)lparam;
 295     struct media_player *player;
 296
 297     if (msg == WM_USER)
 298     {
 299         player = impl_from_IMFPMediaPlayer(event->u.header.pMediaPlayer);
 300         if (player->callback)
 301             IMFPMediaPlayerCallback_OnMediaPlayerEvent(player->callback, &event->u.header);
 302         IUnknown_Release(&event->IUnknown_iface);
 303         return 0;
 304     }
 305
 306     return DefWindowProcW(hwnd, msg, wparam, lparam);
 307 }
 308
 309 static void media_player_set_state(struct media_player *player, MFP_MEDIAPLAYER_STATE state)
 310 {
 311     if (player->state != MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 312     {
 313         if (state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 314             IMFMediaSession_Shutdown(player->session);
 315         player->state = state;
 316     }
 317 }
 318
 319 static HRESULT media_item_get_pd(const struct media_item *item, IMFPresentationDescriptor **pd)
 320 {
 321     if (item->player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 322         return MF_E_SHUTDOWN;
 323
 324     *pd = item->pd;
 325     IMFPresentationDescriptor_AddRef(*pd);
 326     return S_OK;
 327 }
 328
 329 static HRESULT WINAPI media_item_QueryInterface(IMFPMediaItem *iface, REFIID riid, void **obj)
 330 {
 331     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 332
 333     if (IsEqualIID(riid, &IID_IMFPMediaItem) ||
 334             IsEqualIID(riid, &IID_IUnknown))
 335     {
 336         *obj = iface;
 337         IMFPMediaItem_AddRef(iface);
 338         return S_OK;
 339     }
 340
 341     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 342     *obj = NULL;
 343     return E_NOINTERFACE;
 344 }
 345
 346 static ULONG WINAPI media_item_AddRef(IMFPMediaItem *iface)
 347 {
 348     struct media_item *item = impl_from_IMFPMediaItem(iface);
 349     ULONG refcount = InterlockedIncrement(&item->refcount);
 350
 351     TRACE("%p, refcount %lu.\n", iface, refcount);
 352
 353     return refcount;
 354 }
 355
 356 static ULONG WINAPI media_item_Release(IMFPMediaItem *iface)
 357 {
 358     struct media_item *item = impl_from_IMFPMediaItem(iface);
 359     ULONG refcount = InterlockedDecrement(&item->refcount);
 360
 361     TRACE("%p, refcount %lu.\n", iface, refcount);
 362
 363     if (!refcount)
 364     {
 365         if (item->player)
 366             IMFPMediaPlayer_Release(&item->player->IMFPMediaPlayer_iface);
 367         if (item->source)
 368         {
 369             if (item->flags & MEDIA_ITEM_SOURCE_NEEDS_SHUTDOWN)
 370                 IMFMediaSource_Shutdown(item->source);
 371             IMFMediaSource_Release(item->source);
 372         }
 373         if (item->pd)
 374             IMFPresentationDescriptor_Release(item->pd);
 375         if (item->object)
 376             IUnknown_Release(item->object);
 377         free(item->url);
 378         free(item);
 379     }
 380
 381     return refcount;
 382 }
 383
 384 static HRESULT WINAPI media_item_GetMediaPlayer(IMFPMediaItem *iface,
 385         IMFPMediaPlayer **player)
 386 {
 387     struct media_item *item = impl_from_IMFPMediaItem(iface);
 388     HRESULT hr = S_OK;
 389
 390     TRACE("%p, %p.\n", iface, player);
 391
 392     EnterCriticalSection(&item->player->cs);
 393     if (item->player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 394     {
 395         hr = MF_E_SHUTDOWN;
 396         *player = NULL;
 397     }
 398     else
 399     {
 400         *player = &item->player->IMFPMediaPlayer_iface;
 401         IMFPMediaPlayer_AddRef(*player);
 402     }
 403     LeaveCriticalSection(&item->player->cs);
 404
 405     return hr;
 406 }
 407
 408 static HRESULT WINAPI media_item_GetURL(IMFPMediaItem *iface, LPWSTR *url)
 409 {
 410     struct media_item *item = impl_from_IMFPMediaItem(iface);
 411     HRESULT hr = S_OK;
 412
 413     TRACE("%p, %p.\n", iface, url);
 414
 415     EnterCriticalSection(&item->player->cs);
 416     if (item->player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 417         hr = MF_E_SHUTDOWN;
 418     else if (!item->url)
 419         hr = MF_E_NOT_FOUND;
 420     else
 421     {
 422         if (!(*url = CoTaskMemAlloc((wcslen(item->url) + 1) * sizeof(*item->url))))
 423             hr = E_OUTOFMEMORY;
 424         if (*url)
 425             wcscpy(*url, item->url);
 426     }
 427     LeaveCriticalSection(&item->player->cs);
 428
 429     return hr;
 430 }
 431
 432 static HRESULT WINAPI media_item_GetObject(IMFPMediaItem *iface, IUnknown **object)
 433 {
 434     struct media_item *item = impl_from_IMFPMediaItem(iface);
 435     HRESULT hr = S_OK;
 436
 437     TRACE("%p, %p.\n", iface, object);
 438
 439     EnterCriticalSection(&item->player->cs);
 440     if (item->player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 441         hr = MF_E_SHUTDOWN;
 442     else if (!item->object)
 443         hr = MF_E_NOT_FOUND;
 444     else
 445     {
 446         *object = item->object;
 447         IUnknown_AddRef(*object);
 448     }
 449     LeaveCriticalSection(&item->player->cs);
 450
 451     return hr;
 452 }
 453
 454 static HRESULT WINAPI media_item_GetUserData(IMFPMediaItem *iface, DWORD_PTR *user_data)
 455 {
 456     struct media_item *item = impl_from_IMFPMediaItem(iface);
 457
 458     TRACE("%p, %p.\n", iface, user_data);
 459
 460     *user_data = item->user_data;
 461
 462     return S_OK;
 463 }
 464
 465 static HRESULT WINAPI media_item_SetUserData(IMFPMediaItem *iface, DWORD_PTR user_data)
 466 {
 467     struct media_item *item = impl_from_IMFPMediaItem(iface);
 468
 469     TRACE("%p, %Ix.\n", iface, user_data);
 470
 471     item->user_data = user_data;
 472
 473     return S_OK;
 474 }
 475
 476 static HRESULT media_item_set_position(const GUID *format, const PROPVARIANT *position, LARGE_INTEGER *ret)
 477 {
 478     ret->QuadPart = 0;
 479
 480     if (format && !IsEqualGUID(format, &MFP_POSITIONTYPE_100NS))
 481         return E_INVALIDARG;
 482
 483     if ((format != NULL) ^ (position != NULL))
 484         return E_POINTER;
 485
 486     if (position && position->vt != VT_EMPTY && position->vt != VT_I8)
 487         return E_INVALIDARG;
 488
 489     if ((!format && !position) || position->vt == VT_EMPTY)
 490         return S_OK;
 491
 492     if (position->hVal.QuadPart == 0)
 493         return MF_E_OUT_OF_RANGE;
 494
 495     ret->QuadPart = position->hVal.QuadPart;
 496
 497     return S_OK;
 498 }
 499
 500 static void media_item_get_position(LONGLONG value, GUID *format, PROPVARIANT *position)
 501 {
 502     if (!format)
 503         return;
 504
 505     memcpy(format, &MFP_POSITIONTYPE_100NS, sizeof(*format));
 506
 507     if (value)
 508     {
 509         position->vt = VT_I8;
 510         position->hVal.QuadPart = value;
 511     }
 512 }
 513
 514 static HRESULT WINAPI media_item_GetStartStopPosition(IMFPMediaItem *iface, GUID *start_format,
 515         PROPVARIANT *start_position, GUID *stop_format, PROPVARIANT *stop_position)
 516 {
 517     struct media_item *item = impl_from_IMFPMediaItem(iface);
 518
 519     TRACE("%p, %p, %p, %p, %p.\n", iface, start_format, start_position, stop_format, stop_position);
 520
 521     if (start_position)
 522         start_position->vt = VT_EMPTY;
 523     if (stop_position)
 524         stop_position->vt = VT_EMPTY;
 525
 526     if (((start_format != NULL) ^ (start_position != NULL)) ||
 527             ((stop_format != NULL) ^ (stop_position != NULL)))
 528     {
 529         return E_POINTER;
 530     }
 531
 532     media_item_get_position(item->start_position, start_format, start_position);
 533     media_item_get_position(item->stop_position, stop_format, stop_position);
 534
 535     return S_OK;
 536 }
 537
 538 static HRESULT WINAPI media_item_SetStartStopPosition(IMFPMediaItem *iface, const GUID *start_format,
 539         const PROPVARIANT *start_position, const GUID *stop_format, const PROPVARIANT *stop_position)
 540 {
 541     struct media_item *item = impl_from_IMFPMediaItem(iface);
 542     LARGE_INTEGER start, stop;
 543     HRESULT hr;
 544
 545     TRACE("%p, %s, %p, %s, %p.\n", iface, debugstr_guid(start_format), start_position,
 546             debugstr_guid(stop_format), stop_position);
 547
 548     hr = media_item_set_position(start_format, start_position, &start);
 549     if (SUCCEEDED(hr))
 550         hr = media_item_set_position(stop_format, stop_position, &stop);
 551
 552     if (FAILED(hr))
 553         return hr;
 554
 555     if (start.QuadPart > stop.QuadPart)
 556         return MF_E_OUT_OF_RANGE;
 557
 558     item->start_position = start.QuadPart;
 559     item->stop_position = stop.QuadPart;
 560
 561     return hr;
 562 }
 563
 564 static HRESULT media_item_get_stream_type(IMFStreamDescriptor *sd, GUID *major)
 565 {
 566     IMFMediaTypeHandler *handler;
 567     HRESULT hr;
 568
 569     if (SUCCEEDED(hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler)))
 570     {
 571         hr = IMFMediaTypeHandler_GetMajorType(handler, major);
 572         IMFMediaTypeHandler_Release(handler);
 573     }
 574
 575     return hr;
 576 }
 577
 578 static HRESULT media_item_has_stream(struct media_item *item, const GUID *major, BOOL *has_stream, BOOL *is_selected)
 579 {
 580     IMFPresentationDescriptor *pd;
 581     IMFStreamDescriptor *sd;
 582     unsigned int idx = 0;
 583     BOOL selected;
 584     HRESULT hr;
 585     GUID guid;
 586
 587     EnterCriticalSection(&item->player->cs);
 588
 589     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 590     {
 591         *has_stream = *is_selected = FALSE;
 592
 593         while (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, idx++, &selected, &sd)))
 594         {
 595             if (SUCCEEDED(media_item_get_stream_type(sd, &guid)) && IsEqualGUID(&guid, major))
 596             {
 597                 *has_stream = TRUE;
 598                 *is_selected = selected;
 599             }
 600
 601             IMFStreamDescriptor_Release(sd);
 602
 603             if (*has_stream && *is_selected)
 604                 break;
 605         }
 606         IMFPresentationDescriptor_Release(pd);
 607     }
 608
 609     LeaveCriticalSection(&item->player->cs);
 610
 611     return hr;
 612 }
 613
 614 static HRESULT WINAPI media_item_HasVideo(IMFPMediaItem *iface, BOOL *has_video, BOOL *selected)
 615 {
 616     struct media_item *item = impl_from_IMFPMediaItem(iface);
 617
 618     TRACE("%p, %p, %p.\n", iface, has_video, selected);
 619
 620     return media_item_has_stream(item, &MFMediaType_Video, has_video, selected);
 621 }
 622
 623 static HRESULT WINAPI media_item_HasAudio(IMFPMediaItem *iface, BOOL *has_audio, BOOL *selected)
 624 {
 625     struct media_item *item = impl_from_IMFPMediaItem(iface);
 626
 627     TRACE("%p, %p, %p.\n", iface, has_audio, selected);
 628
 629     return media_item_has_stream(item, &MFMediaType_Audio, has_audio, selected);
 630 }
 631
 632 static HRESULT WINAPI media_item_IsProtected(IMFPMediaItem *iface, BOOL *protected)
 633 {
 634     struct media_item *item = impl_from_IMFPMediaItem(iface);
 635     IMFPresentationDescriptor *pd;
 636     HRESULT hr;
 637
 638     TRACE("%p, %p.\n", iface, protected);
 639
 640     if (!protected)
 641         return E_POINTER;
 642
 643     EnterCriticalSection(&item->player->cs);
 644     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 645     {
 646         *protected = (hr = MFRequireProtectedEnvironment(pd)) == S_OK;
 647         IMFPresentationDescriptor_Release(pd);
 648     }
 649     LeaveCriticalSection(&item->player->cs);
 650
 651     return hr;
 652 }
 653
 654 static HRESULT WINAPI media_item_GetDuration(IMFPMediaItem *iface, REFGUID format, PROPVARIANT *value)
 655 {
 656     struct media_item *item = impl_from_IMFPMediaItem(iface);
 657     IMFPresentationDescriptor *pd;
 658     HRESULT hr;
 659
 660     TRACE("%p, %s, %p.\n", iface, debugstr_guid(format), value);
 661
 662     EnterCriticalSection(&item->player->cs);
 663     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 664     {
 665         hr = IMFPresentationDescriptor_GetItem(pd, &MF_PD_DURATION, value);
 666         IMFPresentationDescriptor_Release(pd);
 667     }
 668     LeaveCriticalSection(&item->player->cs);
 669
 670     return hr;
 671 }
 672
 673 static HRESULT WINAPI media_item_GetNumberOfStreams(IMFPMediaItem *iface, DWORD *count)
 674 {
 675     struct media_item *item = impl_from_IMFPMediaItem(iface);
 676     IMFPresentationDescriptor *pd;
 677     HRESULT hr;
 678
 679     TRACE("%p, %p.\n", iface, count);
 680
 681     EnterCriticalSection(&item->player->cs);
 682     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 683     {
 684         hr = IMFPresentationDescriptor_GetStreamDescriptorCount(pd, count);
 685         IMFPresentationDescriptor_Release(pd);
 686     }
 687     LeaveCriticalSection(&item->player->cs);
 688
 689     return hr;
 690 }
 691
 692 static HRESULT WINAPI media_item_GetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL *selected)
 693 {
 694     struct media_item *item = impl_from_IMFPMediaItem(iface);
 695     IMFPresentationDescriptor *pd;
 696     IMFStreamDescriptor *sd;
 697     HRESULT hr;
 698
 699     TRACE("%p, %lu, %p.\n", iface, index, selected);
 700
 701     EnterCriticalSection(&item->player->cs);
 702     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 703     {
 704         if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, index, selected, &sd)))
 705             IMFStreamDescriptor_Release(sd);
 706         IMFPresentationDescriptor_Release(pd);
 707     }
 708     LeaveCriticalSection(&item->player->cs);
 709
 710     return hr;
 711 }
 712
 713 static HRESULT WINAPI media_item_SetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL select)
 714 {
 715     struct media_item *item = impl_from_IMFPMediaItem(iface);
 716     IMFPresentationDescriptor *pd;
 717     HRESULT hr;
 718
 719     TRACE("%p, %lu, %d.\n", iface, index, select);
 720
 721     EnterCriticalSection(&item->player->cs);
 722     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 723     {
 724         hr = select ? IMFPresentationDescriptor_SelectStream(pd, index) :
 725                 IMFPresentationDescriptor_DeselectStream(pd, index);
 726         IMFPresentationDescriptor_Release(pd);
 727     }
 728     LeaveCriticalSection(&item->player->cs);
 729
 730     return hr;
 731 }
 732
 733 static HRESULT WINAPI media_item_GetStreamAttribute(IMFPMediaItem *iface, DWORD index, REFGUID key,
 734         PROPVARIANT *value)
 735 {
 736     struct media_item *item = impl_from_IMFPMediaItem(iface);
 737     IMFPresentationDescriptor *pd;
 738     IMFStreamDescriptor *sd;
 739     BOOL selected;
 740     HRESULT hr;
 741
 742     TRACE("%p, %lu, %s, %p.\n", iface, index, debugstr_guid(key), value);
 743
 744     EnterCriticalSection(&item->player->cs);
 745     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 746     {
 747         if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, index, &selected, &sd)))
 748         {
 749             hr = IMFStreamDescriptor_GetItem(sd, key, value);
 750             IMFStreamDescriptor_Release(sd);
 751         }
 752         IMFPresentationDescriptor_Release(pd);
 753     }
 754     LeaveCriticalSection(&item->player->cs);
 755
 756     return hr;
 757 }
 758
 759 static HRESULT WINAPI media_item_GetPresentationAttribute(IMFPMediaItem *iface, REFGUID key,
 760         PROPVARIANT *value)
 761 {
 762     struct media_item *item = impl_from_IMFPMediaItem(iface);
 763     IMFPresentationDescriptor *pd;
 764     HRESULT hr;
 765
 766     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 767
 768     EnterCriticalSection(&item->player->cs);
 769     if (SUCCEEDED(hr = media_item_get_pd(item, &pd)))
 770     {
 771         hr = IMFPresentationDescriptor_GetItem(pd, key, value);
 772         IMFPresentationDescriptor_Release(pd);
 773     }
 774     LeaveCriticalSection(&item->player->cs);
 775
 776     return hr;
 777 }
 778
 779 static HRESULT WINAPI media_item_GetCharacteristics(IMFPMediaItem *iface, MFP_MEDIAITEM_CHARACTERISTICS *flags)
 780 {
 781     struct media_item *item = impl_from_IMFPMediaItem(iface);
 782     DWORD value = 0;
 783     HRESULT hr;
 784
 785     TRACE("%p, %p.\n", iface, flags);
 786
 787     *flags = 0;
 788
 789     EnterCriticalSection(&item->player->cs);
 790     if (item->player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
 791         hr = MF_E_SHUTDOWN;
 792     else
 793     {
 794         if (SUCCEEDED(hr = IMFMediaSource_GetCharacteristics(item->source, &value)))
 795         {
 796             *flags = value & (MFP_MEDIAITEM_IS_LIVE | MFP_MEDIAITEM_CAN_SEEK
 797                     | MFP_MEDIAITEM_CAN_PAUSE | MFP_MEDIAITEM_HAS_SLOW_SEEK);
 798         }
 799     }
 800     LeaveCriticalSection(&item->player->cs);
 801
 802     return hr;
 803 }
 804
 805 static HRESULT WINAPI media_item_SetStreamSink(IMFPMediaItem *iface, DWORD index, IUnknown *sink)
 806 {
 807     struct media_item *item = impl_from_IMFPMediaItem(iface);
 808     IMFStreamDescriptor *sd;
 809     IUnknown *sink_object;
 810     BOOL selected;
 811     HRESULT hr;
 812
 813     TRACE("%p, %lu, %p.\n", iface, index, sink);
 814
 815     if (FAILED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, &selected, &sd)))
 816         return hr;
 817
 818     if (sink)
 819     {
 820         if (FAILED(hr = IUnknown_QueryInterface(sink, &IID_IMFStreamSink, (void **)&sink_object)))
 821             hr = IUnknown_QueryInterface(sink, &IID_IMFActivate, (void **)&sink_object);
 822
 823         if (sink_object)
 824         {
 825             hr = IMFStreamDescriptor_SetUnknown(sd, &_MF_CUSTOM_SINK, sink_object);
 826             IUnknown_Release(sink_object);
 827         }
 828     }
 829     else
 830         IMFStreamDescriptor_DeleteItem(sd, &_MF_CUSTOM_SINK);
 831
 832     IMFStreamDescriptor_Release(sd);
 833
 834     return hr;
 835 }
 836
 837 static HRESULT WINAPI media_item_GetMetadata(IMFPMediaItem *iface, IPropertyStore **metadata)
 838 {
 839     struct media_item *item = impl_from_IMFPMediaItem(iface);
 840
 841     TRACE("%p, %p.\n", iface, metadata);
 842
 843     return MFGetService((IUnknown *)item->source, &MF_PROPERTY_HANDLER_SERVICE,
 844             &IID_IPropertyStore, (void **)metadata);
 845 }
 846
 847 static const IMFPMediaItemVtbl media_item_vtbl =
 848 {
 849     media_item_QueryInterface,
 850     media_item_AddRef,
 851     media_item_Release,
 852     media_item_GetMediaPlayer,
 853     media_item_GetURL,
 854     media_item_GetObject,
 855     media_item_GetUserData,
 856     media_item_SetUserData,
 857     media_item_GetStartStopPosition,
 858     media_item_SetStartStopPosition,
 859     media_item_HasVideo,
 860     media_item_HasAudio,
 861     media_item_IsProtected,
 862     media_item_GetDuration,
 863     media_item_GetNumberOfStreams,
 864     media_item_GetStreamSelection,
 865     media_item_SetStreamSelection,
 866     media_item_GetStreamAttribute,
 867     media_item_GetPresentationAttribute,
 868     media_item_GetCharacteristics,
 869     media_item_SetStreamSink,
 870     media_item_GetMetadata,
 871 };
 872
 873 static struct media_item *unsafe_impl_from_IMFPMediaItem(IMFPMediaItem *iface)
 874 {
 875     if (!iface)
 876         return NULL;
 877     assert(iface->lpVtbl == (IMFPMediaItemVtbl *)&media_item_vtbl);
 878     return CONTAINING_RECORD(iface, struct media_item, IMFPMediaItem_iface);
 879 }
 880
 881 static HRESULT create_media_item(struct media_player *player, DWORD_PTR user_data, struct media_item **item)
 882 {
 883     struct media_item *object;
 884
 885     if (!(object = calloc(1, sizeof(*object))))
 886         return E_OUTOFMEMORY;
 887
 888     object->IMFPMediaItem_iface.lpVtbl = &media_item_vtbl;
 889     object->refcount = 1;
 890     object->user_data = user_data;
 891     object->player = player;
 892     IMFPMediaPlayer_AddRef(&object->player->IMFPMediaPlayer_iface);
 893
 894     *item = object;
 895
 896     return S_OK;
 897 }
 898
 899 static HRESULT media_item_set_source(struct media_item *item, IUnknown *object)
 900 {
 901     IMFPresentationDescriptor *pd;
 902     IMFMediaSource *source;
 903     HRESULT hr;
 904
 905     if (FAILED(hr = IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
 906         return hr;
 907
 908     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(source, &pd)))
 909     {
 910         WARN("Failed to get presentation descriptor, hr %#lx.\n", hr);
 911         IMFMediaSource_Release(source);
 912         return hr;
 913     }
 914
 915     item->source = source;
 916     item->pd = pd;
 917
 918     return hr;
 919 }
 920
 921 static void media_player_queue_event(struct media_player *player, struct media_event *event)
 922 {
 923     if (player->options & MFP_OPTION_FREE_THREADED_CALLBACK)
 924     {
 925         MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_MULTITHREADED, &player->events_callback, &event->IUnknown_iface);
 926     }
 927     else
 928     {
 929         IUnknown_AddRef(&event->IUnknown_iface);
 930         PostMessageW(player->event_window, WM_USER, 0, (LPARAM)event);
 931     }
 932 }
 933
 934 static HRESULT WINAPI media_player_QueryInterface(IMFPMediaPlayer *iface, REFIID riid, void **obj)
 935 {
 936     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 937
 938     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 939
 940     if (IsEqualIID(riid, &IID_IMFPMediaPlayer) ||
 941             IsEqualIID(riid, &IID_IUnknown))
 942     {
 943         *obj = &player->IMFPMediaPlayer_iface;
 944     }
 945     else if (IsEqualIID(riid, &IID_IPropertyStore))
 946     {
 947         *obj = &player->IPropertyStore_iface;
 948     }
 949     else
 950     {
 951         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 952         *obj = NULL;
 953
 954         return E_NOINTERFACE;
 955     }
 956
 957     IUnknown_AddRef((IUnknown *)*obj);
 958     return S_OK;
 959 }
 960
 961 static ULONG WINAPI media_player_AddRef(IMFPMediaPlayer *iface)
 962 {
 963     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 964     ULONG refcount = InterlockedIncrement(&player->refcount);
 965
 966     TRACE("%p, refcount %lu.\n", iface, refcount);
 967
 968     return refcount;
 969 }
 970
 971 static ULONG WINAPI media_player_Release(IMFPMediaPlayer *iface)
 972 {
 973     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 974     ULONG refcount = InterlockedDecrement(&player->refcount);
 975
 976     TRACE("%p, refcount %lu.\n", iface, refcount);
 977
 978     if (!refcount)
 979     {
 980         if (player->callback)
 981             IMFPMediaPlayerCallback_Release(player->callback);
 982         if (player->propstore)
 983             IPropertyStore_Release(player->propstore);
 984         if (player->resolver)
 985             IMFSourceResolver_Release(player->resolver);
 986         if (player->session)
 987             IMFMediaSession_Release(player->session);
 988         DestroyWindow(player->event_window);
 989         DeleteCriticalSection(&player->cs);
 990         free(player);
 991
 992         platform_shutdown();
 993     }
 994
 995     return refcount;
 996 }
 997
 998 static HRESULT WINAPI media_player_Play(IMFPMediaPlayer *iface)
 999 {
1000     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1001     PROPVARIANT pos;
1002
1003     TRACE("%p.\n", iface);
1004
1005     pos.vt = VT_EMPTY;
1006     return IMFMediaSession_Start(player->session, &GUID_NULL, &pos);
1007 }
1008
1009 static HRESULT WINAPI media_player_Pause(IMFPMediaPlayer *iface)
1010 {
1011     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1012
1013     TRACE("%p.\n", iface);
1014
1015     return IMFMediaSession_Pause(player->session);
1016 }
1017
1018 static HRESULT WINAPI media_player_Stop(IMFPMediaPlayer *iface)
1019 {
1020     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1021
1022     TRACE("%p.\n", iface);
1023
1024     return IMFMediaSession_Stop(player->session);
1025 }
1026
1027 static HRESULT WINAPI media_player_FrameStep(IMFPMediaPlayer *iface)
1028 {
1029     FIXME("%p.\n", iface);
1030
1031     return E_NOTIMPL;
1032 }
1033
1034 static HRESULT WINAPI media_player_SetPosition(IMFPMediaPlayer *iface, REFGUID postype, const PROPVARIANT *position)
1035 {
1036     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
1037
1038     return E_NOTIMPL;
1039 }
1040
1041 static HRESULT WINAPI media_player_GetPosition(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
1042 {
1043     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1044     IMFPresentationClock *presentation_clock;
1045     IMFClock *clock;
1046     HRESULT hr;
1047
1048     TRACE("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
1049
1050     if (!position)
1051         return E_POINTER;
1052
1053     if (!IsEqualGUID(postype, &MFP_POSITIONTYPE_100NS))
1054         return E_INVALIDARG;
1055
1056     EnterCriticalSection(&player->cs);
1057     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
1058         hr = MF_E_SHUTDOWN;
1059     else if (!player->item)
1060         hr = MF_E_INVALIDREQUEST;
1061     else
1062     {
1063         if (SUCCEEDED(hr = IMFMediaSession_GetClock(player->session, &clock)))
1064         {
1065             if (SUCCEEDED(hr = IMFClock_QueryInterface(clock, &IID_IMFPresentationClock, (void **)&presentation_clock)))
1066             {
1067                 position->vt = VT_UI8;
1068                 hr = IMFPresentationClock_GetTime(presentation_clock, (MFTIME *)&position->uhVal.QuadPart);
1069                 IMFPresentationClock_Release(presentation_clock);
1070             }
1071             IMFClock_Release(clock);
1072         }
1073     }
1074     LeaveCriticalSection(&player->cs);
1075
1076     return hr;
1077 }
1078
1079 static HRESULT WINAPI media_player_GetDuration(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *duration)
1080 {
1081     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1082     HRESULT hr;
1083
1084     TRACE("%p, %s, %p.\n", iface, debugstr_guid(postype), duration);
1085
1086     if (!duration)
1087         return E_POINTER;
1088
1089     if (!IsEqualGUID(postype, &MFP_POSITIONTYPE_100NS))
1090         return E_INVALIDARG;
1091
1092     EnterCriticalSection(&player->cs);
1093     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
1094         hr = MF_E_SHUTDOWN;
1095     else if (!player->item)
1096         hr = MF_E_INVALIDREQUEST;
1097     else
1098         /* FIXME: use start/stop markers for resulting duration */
1099         hr = IMFPMediaItem_GetDuration(player->item, postype, duration);
1100     LeaveCriticalSection(&player->cs);
1101
1102     return hr;
1103 }
1104
1105 static HRESULT WINAPI media_player_SetRate(IMFPMediaPlayer *iface, float rate)
1106 {
1107     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1108     IMFRateControl *rate_control;
1109     HRESULT hr;
1110
1111     TRACE("%p, %f.\n", iface, rate);
1112
1113     if (rate == 0.0f)
1114         return MF_E_OUT_OF_RANGE;
1115
1116     if (SUCCEEDED(hr = MFGetService((IUnknown *)player->session, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateControl,
1117             (void **)&rate_control)))
1118     {
1119         hr = IMFRateControl_SetRate(rate_control, FALSE, rate);
1120         IMFRateControl_Release(rate_control);
1121     }
1122
1123     return hr;
1124 }
1125
1126 static HRESULT WINAPI media_player_GetRate(IMFPMediaPlayer *iface, float *rate)
1127 {
1128     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1129     IMFRateControl *rate_control;
1130     HRESULT hr;
1131
1132     TRACE("%p, %p.\n", iface, rate);
1133
1134     if (!rate)
1135         return E_POINTER;
1136
1137     if (SUCCEEDED(hr = MFGetService((IUnknown *)player->session, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateControl,
1138             (void **)&rate_control)))
1139     {
1140         hr = IMFRateControl_GetRate(rate_control, NULL, rate);
1141         IMFRateControl_Release(rate_control);
1142     }
1143
1144     return hr;
1145 }
1146
1147 static HRESULT WINAPI media_player_GetSupportedRates(IMFPMediaPlayer *iface, BOOL forward,
1148         float *slowest_rate, float *fastest_rate)
1149 {
1150     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1151     IMFRateSupport *rs;
1152     HRESULT hr;
1153
1154     TRACE("%p, %d, %p, %p.\n", iface, forward, slowest_rate, fastest_rate);
1155
1156     if (SUCCEEDED(hr = MFGetService((IUnknown *)player->session, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateSupport, (void **)&rs)))
1157     {
1158         if (SUCCEEDED(hr = IMFRateSupport_GetSlowestRate(rs, forward ? MFRATE_FORWARD : MFRATE_REVERSE, FALSE, slowest_rate)))
1159             hr = IMFRateSupport_GetFastestRate(rs, forward ? MFRATE_FORWARD : MFRATE_REVERSE, FALSE, fastest_rate);
1160         IMFRateSupport_Release(rs);
1161     }
1162
1163     return hr;
1164 }
1165
1166 static HRESULT WINAPI media_player_GetState(IMFPMediaPlayer *iface, MFP_MEDIAPLAYER_STATE *state)
1167 {
1168     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1169
1170     TRACE("%p, %p.\n", iface, state);
1171
1172     *state = player->state;
1173
1174     return S_OK;
1175 }
1176
1177 static HRESULT media_player_create_item_from_url(struct media_player *player,
1178         const WCHAR *url, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **ret)
1179 {
1180     struct media_item *item;
1181     MF_OBJECT_TYPE obj_type;
1182     IUnknown *object;
1183     HRESULT hr;
1184
1185     if (sync && !ret)
1186         return E_POINTER;
1187
1188     if (!sync && !player->callback)
1189     {
1190         WARN("Asynchronous item creation is not supported without user callback.\n");
1191         return MF_E_INVALIDREQUEST;
1192     }
1193
1194     if (FAILED(hr = create_media_item(player, user_data, &item)))
1195         return hr;
1196
1197     if (url && !(item->url = wcsdup(url)))
1198     {
1199         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
1200         return E_OUTOFMEMORY;
1201     }
1202     item->flags |= MEDIA_ITEM_SOURCE_NEEDS_SHUTDOWN;
1203
1204     if (sync)
1205     {
1206         *ret = NULL;
1207
1208         if (SUCCEEDED(hr = IMFSourceResolver_CreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE
1209                 | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE, player->propstore, &obj_type, &object)))
1210         {
1211             hr = media_item_set_source(item, object);
1212             IUnknown_Release(object);
1213         }
1214
1215         if (SUCCEEDED(hr))
1216         {
1217             *ret = &item->IMFPMediaItem_iface;
1218             IMFPMediaItem_AddRef(*ret);
1219         }
1220
1221         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
1222     }
1223     else
1224     {
1225         if (ret) *ret = NULL;
1226
1227         hr = IMFSourceResolver_BeginCreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE
1228                 | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE, player->propstore, NULL,
1229                 &player->resolver_callback, (IUnknown *)&item->IMFPMediaItem_iface);
1230
1231         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
1232     }
1233
1234     return hr;
1235 }
1236
1237 static HRESULT WINAPI media_player_CreateMediaItemFromURL(IMFPMediaPlayer *iface,
1238         const WCHAR *url, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
1239 {
1240     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1241     HRESULT hr;
1242
1243     TRACE("%p, %s, %d, %Ix, %p.\n", iface, debugstr_w(url), sync, user_data, item);
1244
1245     EnterCriticalSection(&player->cs);
1246     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
1247         hr = MF_E_SHUTDOWN;
1248     else
1249         hr = media_player_create_item_from_url(player, url, sync, user_data, item);
1250     LeaveCriticalSection(&player->cs);
1251
1252     return hr;
1253 }
1254
1255 static HRESULT media_player_create_item_from_object(struct media_player *player,
1256         IUnknown *object, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **ret)
1257 {
1258     IMFMediaSource *source = NULL;
1259     IMFByteStream *stream = NULL;
1260     struct media_item *item;
1261     MF_OBJECT_TYPE obj_type;
1262     HRESULT hr;
1263
1264     *ret = NULL;
1265
1266     if (FAILED(hr = create_media_item(player, user_data, &item)))
1267         return hr;
1268
1269     item->object = object;
1270     IUnknown_AddRef(item->object);
1271
1272     if (FAILED(IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
1273         IUnknown_QueryInterface(object, &IID_IMFByteStream, (void **)&stream);
1274
1275     if (!source && !stream)
1276     {
1277         WARN("Unsupported object type.\n");
1278         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
1279         return E_UNEXPECTED;
1280     }
1281
1282     if (source)
1283         item->flags |= MEDIA_ITEM_SOURCE_NEEDS_SHUTDOWN;
1284
1285     if (sync)
1286     {
1287         if (stream)
1288             hr = IMFSourceResolver_CreateObjectFromByteStream(player->resolver, stream, NULL, MF_RESOLUTION_MEDIASOURCE
1289                     | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE, player->propstore, &obj_type, &object);
1290         else
1291             IUnknown_AddRef(object);
1292
1293         if (SUCCEEDED(hr))
1294             hr = media_item_set_source(item, object);
1295
1296         IUnknown_Release(object);
1297
1298         if (SUCCEEDED(hr))
1299         {
1300             *ret = &item->IMFPMediaItem_iface;
1301             IMFPMediaItem_AddRef(*ret);
1302         }
1303
1304         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
1305     }
1306     else
1307     {
1308         if (stream)
1309         {
1310             hr = IMFSourceResolver_BeginCreateObjectFromByteStream(player->resolver, stream, NULL, MF_RESOLUTION_MEDIASOURCE
1311                     | MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE, player->propstore, NULL,
1312                     &player->resolver_callback, (IUnknown *)&item->IMFPMediaItem_iface);
1313         }
1314         else
1315         {
1316             /* Resolver callback will check again if item's object is a source. */
1317             hr = MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_MULTITHREADED, &player->resolver_callback,
1318                     (IUnknown *)&item->IMFPMediaItem_iface);
1319         }
1320
1321         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
1322     }
1323
1324     if (source)
1325         IMFMediaSource_Release(source);
1326     if (stream)
1327         IMFByteStream_Release(stream);
1328
1329     return hr;
1330 }
1331
1332 static HRESULT WINAPI media_player_CreateMediaItemFromObject(IMFPMediaPlayer *iface,
1333         IUnknown *object, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
1334 {
1335     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1336     HRESULT hr;
1337
1338     TRACE("%p, %p, %d, %Ix, %p.\n", iface, object, sync, user_data, item);
1339
1340     EnterCriticalSection(&player->cs);
1341     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
1342         hr = MF_E_SHUTDOWN;
1343     else
1344         hr = media_player_create_item_from_object(player, object, sync, user_data, item);
1345     LeaveCriticalSection(&player->cs);
1346
1347     return hr;
1348 }
1349
1350 static HRESULT media_item_create_source_node(struct media_item *item, IMFStreamDescriptor *sd,
1351         IMFTopologyNode **node)
1352 {
1353     HRESULT hr;
1354
1355     if (SUCCEEDED(hr = MFCreateTopologyNode(MF_TOPOLOGY_SOURCESTREAM_NODE, node)))
1356     {
1357         IMFTopologyNode_SetUnknown(*node, &MF_TOPONODE_SOURCE, (IUnknown *)item->source);
1358         IMFTopologyNode_SetUnknown(*node, &MF_TOPONODE_PRESENTATION_DESCRIPTOR, (IUnknown *)item->pd);
1359         IMFTopologyNode_SetUnknown(*node, &MF_TOPONODE_STREAM_DESCRIPTOR, (IUnknown *)sd);
1360         if (item->start_position)
1361             IMFTopologyNode_SetUINT64(*node, &MF_TOPONODE_MEDIASTART, item->start_position);
1362         if (item->stop_position)
1363             IMFTopologyNode_SetUINT64(*node, &MF_TOPONODE_MEDIASTOP, item->stop_position);
1364     }
1365
1366     return hr;
1367 }
1368
1369 static HRESULT media_item_create_sink_node(IUnknown *sink, IMFTopologyNode **node)
1370 {
1371     HRESULT hr;
1372
1373     if (SUCCEEDED(hr = MFCreateTopologyNode(MF_TOPOLOGY_OUTPUT_NODE, node)))
1374         IMFTopologyNode_SetObject(*node, sink);
1375
1376     return hr;
1377 }
1378
1379 static HRESULT media_item_create_topology(struct media_player *player, struct media_item *item, IMFTopology **out)
1380 {
1381     BOOL selected, video_added = FALSE;
1382     IMFStreamDescriptor *sd;
1383     IMFTopology *topology;
1384     unsigned int idx;
1385     IUnknown *sink;
1386     HRESULT hr;
1387     GUID major;
1388
1389     if (FAILED(hr = MFCreateTopology(&topology)))
1390         return hr;
1391
1392     /* Set up branches for all selected streams. */
1393
1394     idx = 0;
1395     while (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, idx++, &selected, &sd)))
1396     {
1397         if (!selected || FAILED(media_item_get_stream_type(sd, &major)))
1398         {
1399             IMFStreamDescriptor_Release(sd);
1400             continue;
1401         }
1402
1403         sink = NULL;
1404
1405         if (SUCCEEDED(IMFStreamDescriptor_GetUnknown(sd, &_MF_CUSTOM_SINK, &IID_IUnknown, (void **)&sink)))
1406         {
1407             /* User sink is attached as-is. */
1408         }
1409         else if (IsEqualGUID(&major, &MFMediaType_Audio))
1410         {
1411             if (FAILED(hr = MFCreateAudioRendererActivate((IMFActivate **)&sink)))
1412                 WARN("Failed to create SAR activation object, hr %#lx.\n", hr);
1413         }
1414         else if (IsEqualGUID(&major, &MFMediaType_Video) && player->output_window && !video_added)
1415         {
1416             if (FAILED(hr = MFCreateVideoRendererActivate(player->output_window, (IMFActivate **)&sink)))
1417                 WARN("Failed to create EVR activation object, hr %#lx.\n", hr);
1418             video_added = SUCCEEDED(hr);
1419         }
1420
1421         if (sink)
1422         {
1423             IMFTopologyNode *src_node = NULL, *sink_node = NULL;
1424
1425             hr = media_item_create_source_node(item, sd, &src_node);
1426             if (SUCCEEDED(hr))
1427                 hr = media_item_create_sink_node(sink, &sink_node);
1428
1429             if (SUCCEEDED(hr))
1430             {
1431                 IMFTopology_AddNode(topology, src_node);
1432                 IMFTopology_AddNode(topology, sink_node);
1433                 IMFTopologyNode_ConnectOutput(src_node, 0, sink_node, 0);
1434             }
1435
1436             if (src_node)
1437                 IMFTopologyNode_Release(src_node);
1438             if (sink_node)
1439                 IMFTopologyNode_Release(sink_node);
1440
1441             IUnknown_Release(sink);
1442         }
1443
1444         IMFStreamDescriptor_Release(sd);
1445     }
1446
1447     IMFTopology_SetUINT32(topology, &MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES, TRUE);
1448
1449     *out = topology;
1450
1451     return S_OK;
1452 }
1453
1454 static HRESULT WINAPI media_player_SetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem *item_iface)
1455 {
1456     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1457     struct media_item *item;
1458     IMFTopology *topology;
1459     HRESULT hr;
1460
1461     TRACE("%p, %p.\n", iface, item_iface);
1462
1463     if (!item_iface)
1464         return E_POINTER;
1465
1466     item = unsafe_impl_from_IMFPMediaItem(item_iface);
1467     if (item->player != player)
1468         return E_INVALIDARG;
1469
1470     if (FAILED(hr = media_item_create_topology(player, item, &topology)))
1471         return hr;
1472
1473     IMFTopology_SetUnknown(topology, &_MF_TOPO_MEDIA_ITEM, (IUnknown *)item_iface);
1474     hr = IMFMediaSession_SetTopology(player->session, MFSESSION_SETTOPOLOGY_IMMEDIATE, topology);
1475     IMFTopology_Release(topology);
1476
1477     return hr;
1478 }
1479
1480 static HRESULT WINAPI media_player_ClearMediaItem(IMFPMediaPlayer *iface)
1481 {
1482     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1483
1484     TRACE("%p.\n", iface);
1485
1486     return IMFMediaSession_SetTopology(player->session, MFSESSION_SETTOPOLOGY_CLEAR_CURRENT, NULL);
1487 }
1488
1489 static HRESULT WINAPI media_player_GetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem **item)
1490 {
1491     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1492     HRESULT hr = S_OK;
1493
1494     TRACE("%p, %p.\n", iface, item);
1495
1496     if (!item)
1497         return E_POINTER;
1498
1499     EnterCriticalSection(&player->cs);
1500     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
1501         hr = MF_E_SHUTDOWN;
1502     else if (!player->item)
1503         hr = MF_E_NOT_FOUND;
1504     else
1505     {
1506         *item = player->item;
1507         IMFPMediaItem_AddRef(player->item);
1508     }
1509     LeaveCriticalSection(&player->cs);
1510
1511     return hr;
1512 }
1513
1514 static HRESULT WINAPI media_player_GetVolume(IMFPMediaPlayer *iface, float *volume)
1515 {
1516     FIXME("%p, %p.\n", iface, volume);
1517
1518     return E_NOTIMPL;
1519 }
1520
1521 static HRESULT WINAPI media_player_SetVolume(IMFPMediaPlayer *iface, float volume)
1522 {
1523     FIXME("%p, %.8e.\n", iface, volume);
1524
1525     return E_NOTIMPL;
1526 }
1527
1528 static HRESULT WINAPI media_player_GetBalance(IMFPMediaPlayer *iface, float *balance)
1529 {
1530     FIXME("%p, %p.\n", iface, balance);
1531
1532     return E_NOTIMPL;
1533 }
1534
1535 static HRESULT WINAPI media_player_SetBalance(IMFPMediaPlayer *iface, float balance)
1536 {
1537     FIXME("%p, %.8e.\n", iface, balance);
1538
1539     return E_NOTIMPL;
1540 }
1541
1542 static HRESULT WINAPI media_player_GetMute(IMFPMediaPlayer *iface, BOOL *mute)
1543 {
1544     FIXME("%p, %p.\n", iface, mute);
1545
1546     return E_NOTIMPL;
1547 }
1548
1549 static HRESULT WINAPI media_player_SetMute(IMFPMediaPlayer *iface, BOOL mute)
1550 {
1551     FIXME("%p, %d.\n", iface, mute);
1552
1553     return E_NOTIMPL;
1554 }
1555
1556 static HRESULT media_player_get_display_control(const struct media_player *player,
1557         IMFVideoDisplayControl **display_control)
1558 {
1559     HRESULT hr = MFGetService((IUnknown *)player->session, &MR_VIDEO_RENDER_SERVICE,
1560             &IID_IMFVideoDisplayControl, (void **)display_control);
1561     if (SUCCEEDED(hr)) return hr;
1562     return hr == MF_E_SHUTDOWN ? hr : MF_E_INVALIDREQUEST;
1563 }
1564
1565 static HRESULT WINAPI media_player_GetNativeVideoSize(IMFPMediaPlayer *iface,
1566         SIZE *video, SIZE *arvideo)
1567 {
1568     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1569     IMFVideoDisplayControl *display_control;
1570     HRESULT hr;
1571
1572     TRACE("%p, %p, %p.\n", iface, video, arvideo);
1573
1574     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1575     {
1576         hr = IMFVideoDisplayControl_GetNativeVideoSize(display_control, video, arvideo);
1577         IMFVideoDisplayControl_Release(display_control);
1578     }
1579
1580     return hr;
1581 }
1582
1583 static HRESULT WINAPI media_player_GetIdealVideoSize(IMFPMediaPlayer *iface,
1584         SIZE *min_size, SIZE *max_size)
1585 {
1586     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1587     IMFVideoDisplayControl *display_control;
1588     HRESULT hr;
1589
1590     TRACE("%p, %p, %p.\n", iface, min_size, max_size);
1591
1592     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1593     {
1594         hr = IMFVideoDisplayControl_GetIdealVideoSize(display_control, min_size, max_size);
1595         IMFVideoDisplayControl_Release(display_control);
1596     }
1597
1598     return hr;
1599 }
1600
1601 static HRESULT WINAPI media_player_SetVideoSourceRect(IMFPMediaPlayer *iface,
1602         MFVideoNormalizedRect const *rect)
1603 {
1604     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1605     IMFVideoDisplayControl *display_control;
1606     RECT dst_rect;
1607     HRESULT hr;
1608
1609     TRACE("%p, %s.\n", iface, debugstr_normalized_rect(rect));
1610
1611     if (!GetClientRect(player->output_window, &dst_rect))
1612         hr = HRESULT_FROM_WIN32(GetLastError());
1613     else if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1614     {
1615         hr = IMFVideoDisplayControl_SetVideoPosition(display_control, rect, &dst_rect);
1616         IMFVideoDisplayControl_Release(display_control);
1617     }
1618
1619     return hr;
1620 }
1621
1622 static HRESULT WINAPI media_player_GetVideoSourceRect(IMFPMediaPlayer *iface,
1623         MFVideoNormalizedRect *rect)
1624 {
1625     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1626     IMFVideoDisplayControl *display_control;
1627     HRESULT hr;
1628     RECT dest;
1629
1630     TRACE("%p, %p.\n", iface, rect);
1631
1632     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1633     {
1634         hr = IMFVideoDisplayControl_GetVideoPosition(display_control, rect, &dest);
1635         IMFVideoDisplayControl_Release(display_control);
1636     }
1637
1638     return hr;
1639 }
1640
1641 static HRESULT WINAPI media_player_SetAspectRatioMode(IMFPMediaPlayer *iface, DWORD mode)
1642 {
1643     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1644     IMFVideoDisplayControl *display_control;
1645     HRESULT hr;
1646
1647     TRACE("%p, %lu.\n", iface, mode);
1648
1649     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1650     {
1651         hr = IMFVideoDisplayControl_SetAspectRatioMode(display_control, mode);
1652         IMFVideoDisplayControl_Release(display_control);
1653     }
1654
1655     return hr;
1656 }
1657
1658 static HRESULT WINAPI media_player_GetAspectRatioMode(IMFPMediaPlayer *iface,
1659         DWORD *mode)
1660 {
1661     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1662     IMFVideoDisplayControl *display_control;
1663     HRESULT hr;
1664
1665     TRACE("%p, %p.\n", iface, mode);
1666
1667     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1668     {
1669         hr = IMFVideoDisplayControl_GetAspectRatioMode(display_control, mode);
1670         IMFVideoDisplayControl_Release(display_control);
1671     }
1672
1673     return hr;
1674 }
1675
1676 static HRESULT WINAPI media_player_GetVideoWindow(IMFPMediaPlayer *iface, HWND *window)
1677 {
1678     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1679
1680     TRACE("%p, %p.\n", iface, window);
1681
1682     *window = player->output_window;
1683
1684     return S_OK;
1685 }
1686
1687 static HRESULT WINAPI media_player_UpdateVideo(IMFPMediaPlayer *iface)
1688 {
1689     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1690     IMFVideoDisplayControl *display_control;
1691     HRESULT hr;
1692     RECT rect;
1693
1694     TRACE("%p.\n", iface);
1695
1696     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1697     {
1698         if (GetClientRect(player->output_window, &rect))
1699             hr = IMFVideoDisplayControl_SetVideoPosition(display_control, NULL, &rect);
1700         if (SUCCEEDED(hr))
1701             hr = IMFVideoDisplayControl_RepaintVideo(display_control);
1702         IMFVideoDisplayControl_Release(display_control);
1703     }
1704
1705     return hr;
1706 }
1707
1708 static HRESULT WINAPI media_player_SetBorderColor(IMFPMediaPlayer *iface, COLORREF color)
1709 {
1710     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1711     IMFVideoDisplayControl *display_control;
1712     HRESULT hr;
1713
1714     TRACE("%p, %#lx.\n", iface, color);
1715
1716     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1717     {
1718         hr = IMFVideoDisplayControl_SetBorderColor(display_control, color);
1719         IMFVideoDisplayControl_Release(display_control);
1720     }
1721
1722     return hr;
1723 }
1724
1725 static HRESULT WINAPI media_player_GetBorderColor(IMFPMediaPlayer *iface, COLORREF *color)
1726 {
1727     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1728     IMFVideoDisplayControl *display_control;
1729     HRESULT hr;
1730
1731     TRACE("%p, %p.\n", iface, color);
1732
1733     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1734     {
1735         hr = IMFVideoDisplayControl_GetBorderColor(display_control, color);
1736         IMFVideoDisplayControl_Release(display_control);
1737     }
1738
1739     return hr;
1740 }
1741
1742 static HRESULT WINAPI media_player_InsertEffect(IMFPMediaPlayer *iface, IUnknown *effect,
1743         BOOL optional)
1744 {
1745     FIXME("%p, %p, %d.\n", iface, effect, optional);
1746
1747     return E_NOTIMPL;
1748 }
1749
1750 static HRESULT WINAPI media_player_RemoveEffect(IMFPMediaPlayer *iface, IUnknown *effect)
1751 {
1752     FIXME("%p, %p.\n", iface, effect);
1753
1754     return E_NOTIMPL;
1755 }
1756
1757 static HRESULT WINAPI media_player_RemoveAllEffects(IMFPMediaPlayer *iface)
1758 {
1759     FIXME("%p.\n", iface);
1760
1761     return E_NOTIMPL;
1762 }
1763
1764 static HRESULT WINAPI media_player_Shutdown(IMFPMediaPlayer *iface)
1765 {
1766     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1767
1768     TRACE("%p.\n", iface);
1769
1770     EnterCriticalSection(&player->cs);
1771     media_player_set_state(player, MFP_MEDIAPLAYER_STATE_SHUTDOWN);
1772     if (player->item)
1773     {
1774         IMFPMediaItem_Release(player->item);
1775         player->item = NULL;
1776     }
1777     LeaveCriticalSection(&player->cs);
1778
1779     return S_OK;
1780 }
1781
1782 static const IMFPMediaPlayerVtbl media_player_vtbl =
1783 {
1784     media_player_QueryInterface,
1785     media_player_AddRef,
1786     media_player_Release,
1787     media_player_Play,
1788     media_player_Pause,
1789     media_player_Stop,
1790     media_player_FrameStep,
1791     media_player_SetPosition,
1792     media_player_GetPosition,
1793     media_player_GetDuration,
1794     media_player_SetRate,
1795     media_player_GetRate,
1796     media_player_GetSupportedRates,
1797     media_player_GetState,
1798     media_player_CreateMediaItemFromURL,
1799     media_player_CreateMediaItemFromObject,
1800     media_player_SetMediaItem,
1801     media_player_ClearMediaItem,
1802     media_player_GetMediaItem,
1803     media_player_GetVolume,
1804     media_player_SetVolume,
1805     media_player_GetBalance,
1806     media_player_SetBalance,
1807     media_player_GetMute,
1808     media_player_SetMute,
1809     media_player_GetNativeVideoSize,
1810     media_player_GetIdealVideoSize,
1811     media_player_SetVideoSourceRect,
1812     media_player_GetVideoSourceRect,
1813     media_player_SetAspectRatioMode,
1814     media_player_GetAspectRatioMode,
1815     media_player_GetVideoWindow,
1816     media_player_UpdateVideo,
1817     media_player_SetBorderColor,
1818     media_player_GetBorderColor,
1819     media_player_InsertEffect,
1820     media_player_RemoveEffect,
1821     media_player_RemoveAllEffects,
1822     media_player_Shutdown,
1823 };
1824
1825 static HRESULT WINAPI media_player_propstore_QueryInterface(IPropertyStore *iface,
1826         REFIID riid, void **obj)
1827 {
1828     struct media_player *player = impl_from_IPropertyStore(iface);
1829     return IMFPMediaPlayer_QueryInterface(&player->IMFPMediaPlayer_iface, riid, obj);
1830 }
1831
1832 static ULONG WINAPI media_player_propstore_AddRef(IPropertyStore *iface)
1833 {
1834     struct media_player *player = impl_from_IPropertyStore(iface);
1835     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1836 }
1837
1838 static ULONG WINAPI media_player_propstore_Release(IPropertyStore *iface)
1839 {
1840     struct media_player *player = impl_from_IPropertyStore(iface);
1841     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1842 }
1843
1844 static HRESULT WINAPI media_player_propstore_GetCount(IPropertyStore *iface, DWORD *count)
1845 {
1846     struct media_player *player = impl_from_IPropertyStore(iface);
1847
1848     TRACE("%p, %p.\n", iface, count);
1849
1850     return IPropertyStore_GetCount(player->propstore, count);
1851 }
1852
1853 static HRESULT WINAPI media_player_propstore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1854 {
1855     struct media_player *player = impl_from_IPropertyStore(iface);
1856
1857     TRACE("%p, %lu, %p.\n", iface, prop, key);
1858
1859     return IPropertyStore_GetAt(player->propstore, prop, key);
1860 }
1861
1862 static HRESULT WINAPI media_player_propstore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
1863 {
1864     struct media_player *player = impl_from_IPropertyStore(iface);
1865
1866     TRACE("%p, %p, %p.\n", iface, key, value);
1867
1868     return IPropertyStore_GetValue(player->propstore, key, value);
1869 }
1870
1871 static HRESULT WINAPI media_player_propstore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
1872 {
1873     struct media_player *player = impl_from_IPropertyStore(iface);
1874
1875     TRACE("%p, %p, %p.\n", iface, key, value);
1876
1877     return IPropertyStore_SetValue(player->propstore, key, value);
1878 }
1879
1880 static HRESULT WINAPI media_player_propstore_Commit(IPropertyStore *iface)
1881 {
1882     struct media_player *player = impl_from_IPropertyStore(iface);
1883
1884     TRACE("%p.\n", iface);
1885
1886     return IPropertyStore_Commit(player->propstore);
1887 }
1888
1889 static const IPropertyStoreVtbl media_player_propstore_vtbl =
1890 {
1891     media_player_propstore_QueryInterface,
1892     media_player_propstore_AddRef,
1893     media_player_propstore_Release,
1894     media_player_propstore_GetCount,
1895     media_player_propstore_GetAt,
1896     media_player_propstore_GetValue,
1897     media_player_propstore_SetValue,
1898     media_player_propstore_Commit,
1899 };
1900
1901 static HRESULT WINAPI media_player_callback_QueryInterface(IMFAsyncCallback *iface,
1902         REFIID riid, void **obj)
1903 {
1904     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1905             IsEqualIID(riid, &IID_IUnknown))
1906     {
1907         *obj = iface;
1908         IMFAsyncCallback_AddRef(iface);
1909         return S_OK;
1910     }
1911
1912     *obj = NULL;
1913     return E_NOINTERFACE;
1914 }
1915
1916 static ULONG WINAPI media_player_resolver_callback_AddRef(IMFAsyncCallback *iface)
1917 {
1918     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1919     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1920 }
1921
1922 static ULONG WINAPI media_player_resolver_callback_Release(IMFAsyncCallback *iface)
1923 {
1924     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1925     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1926 }
1927
1928 static HRESULT WINAPI media_player_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags,
1929         DWORD *queue)
1930 {
1931     return E_NOTIMPL;
1932 }
1933
1934 static HRESULT WINAPI media_player_resolver_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1935 {
1936     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1937     struct media_event *event;
1938     IUnknown *object, *state;
1939     MF_OBJECT_TYPE obj_type;
1940     struct media_item *item;
1941     HRESULT hr;
1942
1943     if (FAILED(IMFAsyncResult_GetState(result, &state)))
1944         return S_OK;
1945
1946     item = impl_from_IMFPMediaItem((IMFPMediaItem *)state);
1947
1948     if (item->object)
1949     {
1950         if (FAILED(hr = IUnknown_QueryInterface(item->object, &IID_IMFMediaSource, (void **)&object)))
1951             hr = IMFSourceResolver_EndCreateObjectFromByteStream(player->resolver, result, &obj_type, &object);
1952     }
1953     else
1954         hr = IMFSourceResolver_EndCreateObjectFromURL(player->resolver, result, &obj_type, &object);
1955
1956     if (SUCCEEDED(hr))
1957     {
1958         hr = media_item_set_source(item, object);
1959         IUnknown_Release(object);
1960     }
1961
1962     if (FAILED(hr))
1963         WARN("Failed to set media source, hr %#lx.\n", hr);
1964
1965     if (FAILED(media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_CREATED, hr,
1966             &item->IMFPMediaItem_iface, &event)))
1967     {
1968         WARN("Failed to create event object.\n");
1969         IUnknown_Release(state);
1970         return S_OK;
1971     }
1972     event->u.item_created.dwUserData = item->user_data;
1973
1974     media_player_queue_event(player, event);
1975
1976     IUnknown_Release(&event->IUnknown_iface);
1977     IUnknown_Release(state);
1978
1979     return S_OK;
1980 }
1981
1982 static const IMFAsyncCallbackVtbl media_player_resolver_callback_vtbl =
1983 {
1984     media_player_callback_QueryInterface,
1985     media_player_resolver_callback_AddRef,
1986     media_player_resolver_callback_Release,
1987     media_player_callback_GetParameters,
1988     media_player_resolver_callback_Invoke,
1989 };
1990
1991 static ULONG WINAPI media_player_events_callback_AddRef(IMFAsyncCallback *iface)
1992 {
1993     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1994     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1995 }
1996
1997 static ULONG WINAPI media_player_events_callback_Release(IMFAsyncCallback *iface)
1998 {
1999     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
2000     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
2001 }
2002
2003 static HRESULT WINAPI media_player_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
2004 {
2005     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
2006     struct media_event *event;
2007     IUnknown *state;
2008
2009     if (FAILED(IMFAsyncResult_GetState(result, &state)))
2010         return S_OK;
2011
2012     event = impl_event_from_IUnknown(state);
2013
2014     if (player->callback)
2015         IMFPMediaPlayerCallback_OnMediaPlayerEvent(player->callback, &event->u.header);
2016
2017     IUnknown_Release(state);
2018
2019     return S_OK;
2020 }
2021
2022 static const IMFAsyncCallbackVtbl media_player_events_callback_vtbl =
2023 {
2024     media_player_callback_QueryInterface,
2025     media_player_events_callback_AddRef,
2026     media_player_events_callback_Release,
2027     media_player_callback_GetParameters,
2028     media_player_events_callback_Invoke,
2029 };
2030
2031 static ULONG WINAPI media_player_session_events_callback_AddRef(IMFAsyncCallback *iface)
2032 {
2033     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
2034     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
2035 }
2036
2037 static ULONG WINAPI media_player_session_events_callback_Release(IMFAsyncCallback *iface)
2038 {
2039     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
2040     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
2041 }
2042
2043 static void media_player_change_state(struct media_player *player, MFP_MEDIAPLAYER_STATE state,
2044         HRESULT event_status, struct media_event **event)
2045 {
2046     MFP_EVENT_TYPE event_type;
2047
2048     EnterCriticalSection(&player->cs);
2049
2050     if (state == MFP_MEDIAPLAYER_STATE_PLAYING)
2051         event_type = MFP_EVENT_TYPE_PLAY;
2052     else if (state == MFP_MEDIAPLAYER_STATE_PAUSED)
2053         event_type = MFP_EVENT_TYPE_PAUSE;
2054     else
2055         event_type = MFP_EVENT_TYPE_STOP;
2056
2057     media_player_set_state(player, state);
2058     media_event_create(player, event_type, event_status, player->item, event);
2059
2060     LeaveCriticalSection(&player->cs);
2061 }
2062
2063 static void media_player_set_item(struct media_player *player, IMFTopology *topology, HRESULT event_status,
2064         struct media_event **event)
2065 {
2066     IMFPMediaItem *item;
2067
2068     if (FAILED(IMFTopology_GetUnknown(topology, &_MF_TOPO_MEDIA_ITEM, &IID_IMFPMediaItem, (void **)&item)))
2069         return;
2070
2071     EnterCriticalSection(&player->cs);
2072
2073     if (player->item)
2074         IMFPMediaItem_Release(player->item);
2075     player->item = item;
2076     IMFPMediaItem_AddRef(player->item);
2077
2078     media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_SET, event_status, item, event);
2079
2080     LeaveCriticalSection(&player->cs);
2081
2082     IMFPMediaItem_Release(item);
2083 }
2084
2085 static void media_player_clear_item(struct media_player *player, HRESULT event_status,
2086         struct media_event **event)
2087 {
2088     IMFPMediaItem *item;
2089
2090     EnterCriticalSection(&player->cs);
2091
2092     item = player->item;
2093     player->item = NULL;
2094
2095     media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_SET, event_status, item, event);
2096
2097     LeaveCriticalSection(&player->cs);
2098 }
2099
2100 static void media_player_create_forward_event(struct media_player *player, HRESULT event_status, IMFMediaEvent *session_event,
2101         struct media_event **event)
2102 {
2103     EnterCriticalSection(&player->cs);
2104
2105     if (SUCCEEDED(media_event_create(player, MFP_EVENT_TYPE_MF, event_status, player->item, event)))
2106     {
2107         IMFMediaEvent_GetType(session_event, &(*event)->u.event.MFEventType);
2108         (*event)->u.event.pMFMediaEvent = session_event;
2109         IMFMediaEvent_AddRef((*event)->u.event.pMFMediaEvent);
2110     }
2111
2112     LeaveCriticalSection(&player->cs);
2113 }
2114
2115 static void media_player_playback_ended(struct media_player *player, HRESULT event_status,
2116         struct media_event **event)
2117 {
2118     EnterCriticalSection(&player->cs);
2119
2120     media_player_set_state(player, MFP_MEDIAPLAYER_STATE_STOPPED);
2121     media_event_create(player, MFP_EVENT_TYPE_PLAYBACK_ENDED, event_status, player->item, event);
2122
2123     LeaveCriticalSection(&player->cs);
2124 }
2125
2126 static void media_player_rate_changed(struct media_player *player, HRESULT event_status,
2127         float rate, struct media_event **event)
2128 {
2129     EnterCriticalSection(&player->cs);
2130
2131     if (SUCCEEDED(media_event_create(player, MFP_EVENT_TYPE_RATE_SET, event_status, player->item, event)))
2132         (*event)->u.rate_set.flRate = rate;
2133
2134     LeaveCriticalSection(&player->cs);
2135 }
2136
2137 static HRESULT WINAPI media_player_session_events_callback_Invoke(IMFAsyncCallback *iface,
2138         IMFAsyncResult *result)
2139 {
2140     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
2141     MediaEventType session_event_type = MEUnknown;
2142     struct media_event *event = NULL;
2143     IMFMediaEvent *session_event;
2144     MFP_MEDIAPLAYER_STATE state;
2145     HRESULT hr, event_status;
2146     IMFTopology *topology;
2147     unsigned int status;
2148     PROPVARIANT value;
2149     float rate;
2150
2151     if (FAILED(hr = IMFMediaSession_EndGetEvent(player->session, result, &session_event)))
2152         return S_OK;
2153
2154     IMFMediaEvent_GetType(session_event, &session_event_type);
2155     IMFMediaEvent_GetStatus(session_event, &event_status);
2156
2157     switch (session_event_type)
2158     {
2159         case MESessionStarted:
2160         case MESessionStopped:
2161         case MESessionPaused:
2162
2163             if (session_event_type == MESessionStarted)
2164                 state = MFP_MEDIAPLAYER_STATE_PLAYING;
2165             else if (session_event_type == MESessionPaused)
2166                 state = MFP_MEDIAPLAYER_STATE_PAUSED;
2167             else
2168                 state = MFP_MEDIAPLAYER_STATE_STOPPED;
2169
2170             media_player_change_state(player, state, event_status, &event);
2171
2172             break;
2173
2174         case MESessionTopologySet:
2175
2176             value.vt = VT_EMPTY;
2177             if (SUCCEEDED(IMFMediaEvent_GetValue(session_event, &value)))
2178             {
2179                 if (value.vt == VT_EMPTY)
2180                 {
2181                     media_player_clear_item(player, event_status, &event);
2182                 }
2183                 else if (value.vt == VT_UNKNOWN && value.punkVal &&
2184                         SUCCEEDED(IUnknown_QueryInterface(value.punkVal, &IID_IMFTopology, (void **)&topology)))
2185                 {
2186                     media_player_set_item(player, topology, event_status, &event);
2187                     IMFTopology_Release(topology);
2188                 }
2189                 PropVariantClear(&value);
2190             }
2191
2192             break;
2193
2194         case MESessionTopologyStatus:
2195
2196             if (SUCCEEDED(IMFMediaEvent_GetUINT32(session_event, &MF_EVENT_TOPOLOGY_STATUS, &status)) &&
2197                     status == MF_TOPOSTATUS_ENDED)
2198             {
2199                 media_player_playback_ended(player, event_status, &event);
2200             }
2201
2202             break;
2203
2204         case MESessionRateChanged:
2205
2206             rate = 0.0f;
2207             if (SUCCEEDED(IMFMediaEvent_GetValue(session_event, &value)))
2208             {
2209                 if (value.vt == VT_R4)
2210                     rate = value.fltVal;
2211                 PropVariantClear(&value);
2212             }
2213
2214             media_player_rate_changed(player, event_status, rate, &event);
2215
2216             break;
2217
2218         case MEBufferingStarted:
2219         case MEBufferingStopped:
2220         case MEExtendedType:
2221         case MEReconnectStart:
2222         case MEReconnectEnd:
2223         case MERendererEvent:
2224         case MEStreamSinkFormatChanged:
2225
2226             media_player_create_forward_event(player, event_status, session_event, &event);
2227
2228             break;
2229
2230         case MEError:
2231
2232             media_event_create(player, MFP_EVENT_TYPE_ERROR, event_status, NULL, &event);
2233
2234             break;
2235
2236         default:
2237             ;
2238     }
2239
2240     if (event)
2241     {
2242         media_player_queue_event(player, event);
2243         IUnknown_Release(&event->IUnknown_iface);
2244     }
2245
2246     IMFMediaSession_BeginGetEvent(player->session, &player->session_events_callback, NULL);
2247     IMFMediaEvent_Release(session_event);
2248
2249     return S_OK;
2250 }
2251
2252 static const IMFAsyncCallbackVtbl media_player_session_events_callback_vtbl =
2253 {
2254     media_player_callback_QueryInterface,
2255     media_player_session_events_callback_AddRef,
2256     media_player_session_events_callback_Release,
2257     media_player_callback_GetParameters,
2258     media_player_session_events_callback_Invoke,
2259 };
2260
2261 /***********************************************************************
2262  *      MFPCreateMediaPlayer (mfplay.@)
2263  */
2264 HRESULT WINAPI MFPCreateMediaPlayer(const WCHAR *url, BOOL start_playback, MFP_CREATION_OPTIONS options,
2265         IMFPMediaPlayerCallback *callback, HWND window, IMFPMediaPlayer **player)
2266 {
2267     struct media_player *object;
2268     IMFPMediaItem *item;
2269     HRESULT hr;
2270
2271     TRACE("%s, %d, %#x, %p, %p, %p.\n", debugstr_w(url), start_playback, options, callback, window, player);
2272
2273     if (!player)
2274         return E_POINTER;
2275
2276     *player = NULL;
2277
2278     if (!url && start_playback)
2279         return E_INVALIDARG;
2280
2281     if (!(object = calloc(1, sizeof(*object))))
2282         return E_OUTOFMEMORY;
2283
2284     platform_startup();
2285
2286     object->IMFPMediaPlayer_iface.lpVtbl = &media_player_vtbl;
2287     object->IPropertyStore_iface.lpVtbl = &media_player_propstore_vtbl;
2288     object->resolver_callback.lpVtbl = &media_player_resolver_callback_vtbl;
2289     object->events_callback.lpVtbl = &media_player_events_callback_vtbl;
2290     object->session_events_callback.lpVtbl = &media_player_session_events_callback_vtbl;
2291     object->refcount = 1;
2292     object->callback = callback;
2293     if (object->callback)
2294         IMFPMediaPlayerCallback_AddRef(object->callback);
2295     object->options = options;
2296     object->output_window = window;
2297     InitializeCriticalSection(&object->cs);
2298     if (FAILED(hr = CreatePropertyStore(&object->propstore)))
2299         goto failed;
2300     if (FAILED(hr = MFCreateSourceResolver(&object->resolver)))
2301         goto failed;
2302     if (FAILED(hr = MFCreateMediaSession(NULL, &object->session)))
2303         goto failed;
2304     if (FAILED(hr = IMFMediaSession_BeginGetEvent(object->session, &object->session_events_callback, NULL)))
2305         goto failed;
2306     if (!(object->options & MFP_OPTION_FREE_THREADED_CALLBACK))
2307     {
2308         object->event_window = CreateWindowW(eventclassW, NULL, 0, 0, 0, 0, 0, HWND_MESSAGE,
2309                 0, mfplay_instance, NULL);
2310     }
2311
2312     if (url)
2313     {
2314         if (FAILED(hr = media_player_create_item_from_url(object, url, TRUE, 0, &item)))
2315         {
2316             WARN("Failed to create media item, hr %#lx.\n", hr);
2317             goto failed;
2318         }
2319
2320         hr = IMFPMediaPlayer_SetMediaItem(&object->IMFPMediaPlayer_iface, item);
2321         IMFPMediaItem_Release(item);
2322         if (FAILED(hr))
2323         {
2324             WARN("Failed to set media item, hr %#lx.\n", hr);
2325             goto failed;
2326         }
2327
2328         if (start_playback)
2329             IMFPMediaPlayer_Play(&object->IMFPMediaPlayer_iface);
2330     }
2331
2332     *player = &object->IMFPMediaPlayer_iface;
2333
2334     return S_OK;
2335
2336 failed:
2337
2338     IMFPMediaPlayer_Release(&object->IMFPMediaPlayer_iface);
2339
2340     return hr;
2341 }
2342
2343 static void media_player_register_window_class(void)
2344 {
2345     WNDCLASSW cls = { 0 };
2346
2347     cls.lpfnWndProc = media_player_event_proc;
2348     cls.hInstance = mfplay_instance;
2349     cls.lpszClassName = eventclassW;
2350
2351     RegisterClassW(&cls);
2352 }
2353
2354 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
2355 {
2356     switch (reason)
2357     {
2358         case DLL_PROCESS_ATTACH:
2359             mfplay_instance = instance;
2360             DisableThreadLibraryCalls(instance);
2361             media_player_register_window_class();
2362             break;
2363         case DLL_PROCESS_DETACH:
2364             if (reserved) break;
2365             UnregisterClassW(eventclassW, instance);
2366             break;
2367     }
2368
2369     return TRUE;
2370 }