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     IMFTopologyNode *src_node, *sink_node;
1382     BOOL selected, video_added = FALSE;
1383     IMFStreamDescriptor *sd;
1384     IMFTopology *topology;
1385     unsigned int idx;
1386     IUnknown *sink;
1387     HRESULT hr;
1388     GUID major;
1389
1390     if (FAILED(hr = MFCreateTopology(&topology)))
1391         return hr;
1392
1393     /* Set up branches for all selected streams. */
1394
1395     idx = 0;
1396     while (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, idx++, &selected, &sd)))
1397     {
1398         if (!selected || FAILED(media_item_get_stream_type(sd, &major)))
1399         {
1400             IMFStreamDescriptor_Release(sd);
1401             continue;
1402         }
1403
1404         sink = NULL;
1405
1406         if (SUCCEEDED(IMFStreamDescriptor_GetUnknown(sd, &_MF_CUSTOM_SINK, &IID_IUnknown, (void **)&sink)))
1407         {
1408             /* User sink is attached as-is. */
1409         }
1410         else if (IsEqualGUID(&major, &MFMediaType_Audio))
1411         {
1412             if (FAILED(hr = MFCreateAudioRendererActivate((IMFActivate **)&sink)))
1413                 WARN("Failed to create SAR activation object, hr %#lx.\n", hr);
1414         }
1415         else if (IsEqualGUID(&major, &MFMediaType_Video) && player->output_window && !video_added)
1416         {
1417             if (FAILED(hr = MFCreateVideoRendererActivate(player->output_window, (IMFActivate **)&sink)))
1418                 WARN("Failed to create EVR activation object, hr %#lx.\n", hr);
1419             video_added = SUCCEEDED(hr);
1420         }
1421
1422         if (sink)
1423         {
1424             hr = media_item_create_source_node(item, sd, &src_node);
1425             if (SUCCEEDED(hr))
1426                 hr = media_item_create_sink_node(sink, &sink_node);
1427
1428             if (SUCCEEDED(hr))
1429             {
1430                 IMFTopology_AddNode(topology, src_node);
1431                 IMFTopology_AddNode(topology, sink_node);
1432                 IMFTopologyNode_ConnectOutput(src_node, 0, sink_node, 0);
1433             }
1434
1435             if (src_node)
1436                 IMFTopologyNode_Release(src_node);
1437             if (sink_node)
1438                 IMFTopologyNode_Release(sink_node);
1439
1440             IUnknown_Release(sink);
1441         }
1442
1443         IMFStreamDescriptor_Release(sd);
1444     }
1445
1446     IMFTopology_SetUINT32(topology, &MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES, TRUE);
1447
1448     *out = topology;
1449
1450     return S_OK;
1451 }
1452
1453 static HRESULT WINAPI media_player_SetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem *item_iface)
1454 {
1455     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1456     struct media_item *item;
1457     IMFTopology *topology;
1458     HRESULT hr;
1459
1460     TRACE("%p, %p.\n", iface, item_iface);
1461
1462     if (!item_iface)
1463         return E_POINTER;
1464
1465     item = unsafe_impl_from_IMFPMediaItem(item_iface);
1466     if (item->player != player)
1467         return E_INVALIDARG;
1468
1469     if (FAILED(hr = media_item_create_topology(player, item, &topology)))
1470         return hr;
1471
1472     IMFTopology_SetUnknown(topology, &_MF_TOPO_MEDIA_ITEM, (IUnknown *)item_iface);
1473     hr = IMFMediaSession_SetTopology(player->session, MFSESSION_SETTOPOLOGY_IMMEDIATE, topology);
1474     IMFTopology_Release(topology);
1475
1476     return hr;
1477 }
1478
1479 static HRESULT WINAPI media_player_ClearMediaItem(IMFPMediaPlayer *iface)
1480 {
1481     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1482
1483     TRACE("%p.\n", iface);
1484
1485     return IMFMediaSession_SetTopology(player->session, MFSESSION_SETTOPOLOGY_CLEAR_CURRENT, NULL);
1486 }
1487
1488 static HRESULT WINAPI media_player_GetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem **item)
1489 {
1490     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1491     HRESULT hr = S_OK;
1492
1493     TRACE("%p, %p.\n", iface, item);
1494
1495     if (!item)
1496         return E_POINTER;
1497
1498     EnterCriticalSection(&player->cs);
1499     if (player->state == MFP_MEDIAPLAYER_STATE_SHUTDOWN)
1500         hr = MF_E_SHUTDOWN;
1501     else if (!player->item)
1502         hr = MF_E_NOT_FOUND;
1503     else
1504     {
1505         *item = player->item;
1506         IMFPMediaItem_AddRef(player->item);
1507     }
1508     LeaveCriticalSection(&player->cs);
1509
1510     return hr;
1511 }
1512
1513 static HRESULT WINAPI media_player_GetVolume(IMFPMediaPlayer *iface, float *volume)
1514 {
1515     FIXME("%p, %p.\n", iface, volume);
1516
1517     return E_NOTIMPL;
1518 }
1519
1520 static HRESULT WINAPI media_player_SetVolume(IMFPMediaPlayer *iface, float volume)
1521 {
1522     FIXME("%p, %.8e.\n", iface, volume);
1523
1524     return E_NOTIMPL;
1525 }
1526
1527 static HRESULT WINAPI media_player_GetBalance(IMFPMediaPlayer *iface, float *balance)
1528 {
1529     FIXME("%p, %p.\n", iface, balance);
1530
1531     return E_NOTIMPL;
1532 }
1533
1534 static HRESULT WINAPI media_player_SetBalance(IMFPMediaPlayer *iface, float balance)
1535 {
1536     FIXME("%p, %.8e.\n", iface, balance);
1537
1538     return E_NOTIMPL;
1539 }
1540
1541 static HRESULT WINAPI media_player_GetMute(IMFPMediaPlayer *iface, BOOL *mute)
1542 {
1543     FIXME("%p, %p.\n", iface, mute);
1544
1545     return E_NOTIMPL;
1546 }
1547
1548 static HRESULT WINAPI media_player_SetMute(IMFPMediaPlayer *iface, BOOL mute)
1549 {
1550     FIXME("%p, %d.\n", iface, mute);
1551
1552     return E_NOTIMPL;
1553 }
1554
1555 static HRESULT media_player_get_display_control(const struct media_player *player,
1556         IMFVideoDisplayControl **display_control)
1557 {
1558     HRESULT hr = MFGetService((IUnknown *)player->session, &MR_VIDEO_RENDER_SERVICE,
1559             &IID_IMFVideoDisplayControl, (void **)display_control);
1560     if (SUCCEEDED(hr)) return hr;
1561     return hr == MF_E_SHUTDOWN ? hr : MF_E_INVALIDREQUEST;
1562 }
1563
1564 static HRESULT WINAPI media_player_GetNativeVideoSize(IMFPMediaPlayer *iface,
1565         SIZE *video, SIZE *arvideo)
1566 {
1567     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1568     IMFVideoDisplayControl *display_control;
1569     HRESULT hr;
1570
1571     TRACE("%p, %p, %p.\n", iface, video, arvideo);
1572
1573     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1574     {
1575         hr = IMFVideoDisplayControl_GetNativeVideoSize(display_control, video, arvideo);
1576         IMFVideoDisplayControl_Release(display_control);
1577     }
1578
1579     return hr;
1580 }
1581
1582 static HRESULT WINAPI media_player_GetIdealVideoSize(IMFPMediaPlayer *iface,
1583         SIZE *min_size, SIZE *max_size)
1584 {
1585     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1586     IMFVideoDisplayControl *display_control;
1587     HRESULT hr;
1588
1589     TRACE("%p, %p, %p.\n", iface, min_size, max_size);
1590
1591     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1592     {
1593         hr = IMFVideoDisplayControl_GetIdealVideoSize(display_control, min_size, max_size);
1594         IMFVideoDisplayControl_Release(display_control);
1595     }
1596
1597     return hr;
1598 }
1599
1600 static HRESULT WINAPI media_player_SetVideoSourceRect(IMFPMediaPlayer *iface,
1601         MFVideoNormalizedRect const *rect)
1602 {
1603     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1604     IMFVideoDisplayControl *display_control;
1605     RECT dst_rect;
1606     HRESULT hr;
1607
1608     TRACE("%p, %s.\n", iface, debugstr_normalized_rect(rect));
1609
1610     if (!GetClientRect(player->output_window, &dst_rect))
1611         hr = HRESULT_FROM_WIN32(GetLastError());
1612     else if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1613     {
1614         hr = IMFVideoDisplayControl_SetVideoPosition(display_control, rect, &dst_rect);
1615         IMFVideoDisplayControl_Release(display_control);
1616     }
1617
1618     return hr;
1619 }
1620
1621 static HRESULT WINAPI media_player_GetVideoSourceRect(IMFPMediaPlayer *iface,
1622         MFVideoNormalizedRect *rect)
1623 {
1624     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1625     IMFVideoDisplayControl *display_control;
1626     HRESULT hr;
1627     RECT dest;
1628
1629     TRACE("%p, %p.\n", iface, rect);
1630
1631     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1632     {
1633         hr = IMFVideoDisplayControl_GetVideoPosition(display_control, rect, &dest);
1634         IMFVideoDisplayControl_Release(display_control);
1635     }
1636
1637     return hr;
1638 }
1639
1640 static HRESULT WINAPI media_player_SetAspectRatioMode(IMFPMediaPlayer *iface, DWORD mode)
1641 {
1642     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1643     IMFVideoDisplayControl *display_control;
1644     HRESULT hr;
1645
1646     TRACE("%p, %lu.\n", iface, mode);
1647
1648     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1649     {
1650         hr = IMFVideoDisplayControl_SetAspectRatioMode(display_control, mode);
1651         IMFVideoDisplayControl_Release(display_control);
1652     }
1653
1654     return hr;
1655 }
1656
1657 static HRESULT WINAPI media_player_GetAspectRatioMode(IMFPMediaPlayer *iface,
1658         DWORD *mode)
1659 {
1660     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1661     IMFVideoDisplayControl *display_control;
1662     HRESULT hr;
1663
1664     TRACE("%p, %p.\n", iface, mode);
1665
1666     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1667     {
1668         hr = IMFVideoDisplayControl_GetAspectRatioMode(display_control, mode);
1669         IMFVideoDisplayControl_Release(display_control);
1670     }
1671
1672     return hr;
1673 }
1674
1675 static HRESULT WINAPI media_player_GetVideoWindow(IMFPMediaPlayer *iface, HWND *window)
1676 {
1677     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1678
1679     TRACE("%p, %p.\n", iface, window);
1680
1681     *window = player->output_window;
1682
1683     return S_OK;
1684 }
1685
1686 static HRESULT WINAPI media_player_UpdateVideo(IMFPMediaPlayer *iface)
1687 {
1688     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1689     IMFVideoDisplayControl *display_control;
1690     HRESULT hr;
1691     RECT rect;
1692
1693     TRACE("%p.\n", iface);
1694
1695     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1696     {
1697         if (GetClientRect(player->output_window, &rect))
1698             hr = IMFVideoDisplayControl_SetVideoPosition(display_control, NULL, &rect);
1699         if (SUCCEEDED(hr))
1700             hr = IMFVideoDisplayControl_RepaintVideo(display_control);
1701         IMFVideoDisplayControl_Release(display_control);
1702     }
1703
1704     return hr;
1705 }
1706
1707 static HRESULT WINAPI media_player_SetBorderColor(IMFPMediaPlayer *iface, COLORREF color)
1708 {
1709     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1710     IMFVideoDisplayControl *display_control;
1711     HRESULT hr;
1712
1713     TRACE("%p, %#lx.\n", iface, color);
1714
1715     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1716     {
1717         hr = IMFVideoDisplayControl_SetBorderColor(display_control, color);
1718         IMFVideoDisplayControl_Release(display_control);
1719     }
1720
1721     return hr;
1722 }
1723
1724 static HRESULT WINAPI media_player_GetBorderColor(IMFPMediaPlayer *iface, COLORREF *color)
1725 {
1726     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1727     IMFVideoDisplayControl *display_control;
1728     HRESULT hr;
1729
1730     TRACE("%p, %p.\n", iface, color);
1731
1732     if (SUCCEEDED(hr = media_player_get_display_control(player, &display_control)))
1733     {
1734         hr = IMFVideoDisplayControl_GetBorderColor(display_control, color);
1735         IMFVideoDisplayControl_Release(display_control);
1736     }
1737
1738     return hr;
1739 }
1740
1741 static HRESULT WINAPI media_player_InsertEffect(IMFPMediaPlayer *iface, IUnknown *effect,
1742         BOOL optional)
1743 {
1744     FIXME("%p, %p, %d.\n", iface, effect, optional);
1745
1746     return E_NOTIMPL;
1747 }
1748
1749 static HRESULT WINAPI media_player_RemoveEffect(IMFPMediaPlayer *iface, IUnknown *effect)
1750 {
1751     FIXME("%p, %p.\n", iface, effect);
1752
1753     return E_NOTIMPL;
1754 }
1755
1756 static HRESULT WINAPI media_player_RemoveAllEffects(IMFPMediaPlayer *iface)
1757 {
1758     FIXME("%p.\n", iface);
1759
1760     return E_NOTIMPL;
1761 }
1762
1763 static HRESULT WINAPI media_player_Shutdown(IMFPMediaPlayer *iface)
1764 {
1765     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
1766
1767     TRACE("%p.\n", iface);
1768
1769     EnterCriticalSection(&player->cs);
1770     media_player_set_state(player, MFP_MEDIAPLAYER_STATE_SHUTDOWN);
1771     if (player->item)
1772     {
1773         IMFPMediaItem_Release(player->item);
1774         player->item = NULL;
1775     }
1776     LeaveCriticalSection(&player->cs);
1777
1778     return S_OK;
1779 }
1780
1781 static const IMFPMediaPlayerVtbl media_player_vtbl =
1782 {
1783     media_player_QueryInterface,
1784     media_player_AddRef,
1785     media_player_Release,
1786     media_player_Play,
1787     media_player_Pause,
1788     media_player_Stop,
1789     media_player_FrameStep,
1790     media_player_SetPosition,
1791     media_player_GetPosition,
1792     media_player_GetDuration,
1793     media_player_SetRate,
1794     media_player_GetRate,
1795     media_player_GetSupportedRates,
1796     media_player_GetState,
1797     media_player_CreateMediaItemFromURL,
1798     media_player_CreateMediaItemFromObject,
1799     media_player_SetMediaItem,
1800     media_player_ClearMediaItem,
1801     media_player_GetMediaItem,
1802     media_player_GetVolume,
1803     media_player_SetVolume,
1804     media_player_GetBalance,
1805     media_player_SetBalance,
1806     media_player_GetMute,
1807     media_player_SetMute,
1808     media_player_GetNativeVideoSize,
1809     media_player_GetIdealVideoSize,
1810     media_player_SetVideoSourceRect,
1811     media_player_GetVideoSourceRect,
1812     media_player_SetAspectRatioMode,
1813     media_player_GetAspectRatioMode,
1814     media_player_GetVideoWindow,
1815     media_player_UpdateVideo,
1816     media_player_SetBorderColor,
1817     media_player_GetBorderColor,
1818     media_player_InsertEffect,
1819     media_player_RemoveEffect,
1820     media_player_RemoveAllEffects,
1821     media_player_Shutdown,
1822 };
1823
1824 static HRESULT WINAPI media_player_propstore_QueryInterface(IPropertyStore *iface,
1825         REFIID riid, void **obj)
1826 {
1827     struct media_player *player = impl_from_IPropertyStore(iface);
1828     return IMFPMediaPlayer_QueryInterface(&player->IMFPMediaPlayer_iface, riid, obj);
1829 }
1830
1831 static ULONG WINAPI media_player_propstore_AddRef(IPropertyStore *iface)
1832 {
1833     struct media_player *player = impl_from_IPropertyStore(iface);
1834     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1835 }
1836
1837 static ULONG WINAPI media_player_propstore_Release(IPropertyStore *iface)
1838 {
1839     struct media_player *player = impl_from_IPropertyStore(iface);
1840     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1841 }
1842
1843 static HRESULT WINAPI media_player_propstore_GetCount(IPropertyStore *iface, DWORD *count)
1844 {
1845     struct media_player *player = impl_from_IPropertyStore(iface);
1846
1847     TRACE("%p, %p.\n", iface, count);
1848
1849     return IPropertyStore_GetCount(player->propstore, count);
1850 }
1851
1852 static HRESULT WINAPI media_player_propstore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1853 {
1854     struct media_player *player = impl_from_IPropertyStore(iface);
1855
1856     TRACE("%p, %lu, %p.\n", iface, prop, key);
1857
1858     return IPropertyStore_GetAt(player->propstore, prop, key);
1859 }
1860
1861 static HRESULT WINAPI media_player_propstore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
1862 {
1863     struct media_player *player = impl_from_IPropertyStore(iface);
1864
1865     TRACE("%p, %p, %p.\n", iface, key, value);
1866
1867     return IPropertyStore_GetValue(player->propstore, key, value);
1868 }
1869
1870 static HRESULT WINAPI media_player_propstore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
1871 {
1872     struct media_player *player = impl_from_IPropertyStore(iface);
1873
1874     TRACE("%p, %p, %p.\n", iface, key, value);
1875
1876     return IPropertyStore_SetValue(player->propstore, key, value);
1877 }
1878
1879 static HRESULT WINAPI media_player_propstore_Commit(IPropertyStore *iface)
1880 {
1881     struct media_player *player = impl_from_IPropertyStore(iface);
1882
1883     TRACE("%p.\n", iface);
1884
1885     return IPropertyStore_Commit(player->propstore);
1886 }
1887
1888 static const IPropertyStoreVtbl media_player_propstore_vtbl =
1889 {
1890     media_player_propstore_QueryInterface,
1891     media_player_propstore_AddRef,
1892     media_player_propstore_Release,
1893     media_player_propstore_GetCount,
1894     media_player_propstore_GetAt,
1895     media_player_propstore_GetValue,
1896     media_player_propstore_SetValue,
1897     media_player_propstore_Commit,
1898 };
1899
1900 static HRESULT WINAPI media_player_callback_QueryInterface(IMFAsyncCallback *iface,
1901         REFIID riid, void **obj)
1902 {
1903     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
1904             IsEqualIID(riid, &IID_IUnknown))
1905     {
1906         *obj = iface;
1907         IMFAsyncCallback_AddRef(iface);
1908         return S_OK;
1909     }
1910
1911     *obj = NULL;
1912     return E_NOINTERFACE;
1913 }
1914
1915 static ULONG WINAPI media_player_resolver_callback_AddRef(IMFAsyncCallback *iface)
1916 {
1917     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1918     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1919 }
1920
1921 static ULONG WINAPI media_player_resolver_callback_Release(IMFAsyncCallback *iface)
1922 {
1923     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1924     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
1925 }
1926
1927 static HRESULT WINAPI media_player_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags,
1928         DWORD *queue)
1929 {
1930     return E_NOTIMPL;
1931 }
1932
1933 static HRESULT WINAPI media_player_resolver_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
1934 {
1935     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
1936     struct media_event *event;
1937     IUnknown *object, *state;
1938     MF_OBJECT_TYPE obj_type;
1939     struct media_item *item;
1940     HRESULT hr;
1941
1942     if (FAILED(IMFAsyncResult_GetState(result, &state)))
1943         return S_OK;
1944
1945     item = impl_from_IMFPMediaItem((IMFPMediaItem *)state);
1946
1947     if (item->object)
1948     {
1949         if (FAILED(hr = IUnknown_QueryInterface(item->object, &IID_IMFMediaSource, (void **)&object)))
1950             hr = IMFSourceResolver_EndCreateObjectFromByteStream(player->resolver, result, &obj_type, &object);
1951     }
1952     else
1953         hr = IMFSourceResolver_EndCreateObjectFromURL(player->resolver, result, &obj_type, &object);
1954
1955     if (SUCCEEDED(hr))
1956     {
1957         hr = media_item_set_source(item, object);
1958         IUnknown_Release(object);
1959     }
1960
1961     if (FAILED(hr))
1962         WARN("Failed to set media source, hr %#lx.\n", hr);
1963
1964     if (FAILED(media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_CREATED, hr,
1965             &item->IMFPMediaItem_iface, &event)))
1966     {
1967         WARN("Failed to create event object.\n");
1968         IUnknown_Release(state);
1969         return S_OK;
1970     }
1971     event->u.item_created.dwUserData = item->user_data;
1972
1973     media_player_queue_event(player, event);
1974
1975     IUnknown_Release(&event->IUnknown_iface);
1976     IUnknown_Release(state);
1977
1978     return S_OK;
1979 }
1980
1981 static const IMFAsyncCallbackVtbl media_player_resolver_callback_vtbl =
1982 {
1983     media_player_callback_QueryInterface,
1984     media_player_resolver_callback_AddRef,
1985     media_player_resolver_callback_Release,
1986     media_player_callback_GetParameters,
1987     media_player_resolver_callback_Invoke,
1988 };
1989
1990 static ULONG WINAPI media_player_events_callback_AddRef(IMFAsyncCallback *iface)
1991 {
1992     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1993     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
1994 }
1995
1996 static ULONG WINAPI media_player_events_callback_Release(IMFAsyncCallback *iface)
1997 {
1998     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
1999     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
2000 }
2001
2002 static HRESULT WINAPI media_player_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
2003 {
2004     struct media_player *player = impl_from_events_IMFAsyncCallback(iface);
2005     struct media_event *event;
2006     IUnknown *state;
2007
2008     if (FAILED(IMFAsyncResult_GetState(result, &state)))
2009         return S_OK;
2010
2011     event = impl_event_from_IUnknown(state);
2012
2013     if (player->callback)
2014         IMFPMediaPlayerCallback_OnMediaPlayerEvent(player->callback, &event->u.header);
2015
2016     IUnknown_Release(state);
2017
2018     return S_OK;
2019 }
2020
2021 static const IMFAsyncCallbackVtbl media_player_events_callback_vtbl =
2022 {
2023     media_player_callback_QueryInterface,
2024     media_player_events_callback_AddRef,
2025     media_player_events_callback_Release,
2026     media_player_callback_GetParameters,
2027     media_player_events_callback_Invoke,
2028 };
2029
2030 static ULONG WINAPI media_player_session_events_callback_AddRef(IMFAsyncCallback *iface)
2031 {
2032     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
2033     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
2034 }
2035
2036 static ULONG WINAPI media_player_session_events_callback_Release(IMFAsyncCallback *iface)
2037 {
2038     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
2039     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
2040 }
2041
2042 static void media_player_change_state(struct media_player *player, MFP_MEDIAPLAYER_STATE state,
2043         HRESULT event_status, struct media_event **event)
2044 {
2045     MFP_EVENT_TYPE event_type;
2046
2047     EnterCriticalSection(&player->cs);
2048
2049     if (state == MFP_MEDIAPLAYER_STATE_PLAYING)
2050         event_type = MFP_EVENT_TYPE_PLAY;
2051     else if (state == MFP_MEDIAPLAYER_STATE_PAUSED)
2052         event_type = MFP_EVENT_TYPE_PAUSE;
2053     else
2054         event_type = MFP_EVENT_TYPE_STOP;
2055
2056     media_player_set_state(player, state);
2057     media_event_create(player, event_type, event_status, player->item, event);
2058
2059     LeaveCriticalSection(&player->cs);
2060 }
2061
2062 static void media_player_set_item(struct media_player *player, IMFTopology *topology, HRESULT event_status,
2063         struct media_event **event)
2064 {
2065     IMFPMediaItem *item;
2066
2067     if (FAILED(IMFTopology_GetUnknown(topology, &_MF_TOPO_MEDIA_ITEM, &IID_IMFPMediaItem, (void **)&item)))
2068         return;
2069
2070     EnterCriticalSection(&player->cs);
2071
2072     if (player->item)
2073         IMFPMediaItem_Release(player->item);
2074     player->item = item;
2075     IMFPMediaItem_AddRef(player->item);
2076
2077     media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_SET, event_status, item, event);
2078
2079     LeaveCriticalSection(&player->cs);
2080
2081     IMFPMediaItem_Release(item);
2082 }
2083
2084 static void media_player_clear_item(struct media_player *player, HRESULT event_status,
2085         struct media_event **event)
2086 {
2087     IMFPMediaItem *item;
2088
2089     EnterCriticalSection(&player->cs);
2090
2091     item = player->item;
2092     player->item = NULL;
2093
2094     media_event_create(player, MFP_EVENT_TYPE_MEDIAITEM_SET, event_status, item, event);
2095
2096     LeaveCriticalSection(&player->cs);
2097 }
2098
2099 static void media_player_create_forward_event(struct media_player *player, HRESULT event_status, IMFMediaEvent *session_event,
2100         struct media_event **event)
2101 {
2102     EnterCriticalSection(&player->cs);
2103
2104     if (SUCCEEDED(media_event_create(player, MFP_EVENT_TYPE_MF, event_status, player->item, event)))
2105     {
2106         IMFMediaEvent_GetType(session_event, &(*event)->u.event.MFEventType);
2107         (*event)->u.event.pMFMediaEvent = session_event;
2108         IMFMediaEvent_AddRef((*event)->u.event.pMFMediaEvent);
2109     }
2110
2111     LeaveCriticalSection(&player->cs);
2112 }
2113
2114 static void media_player_playback_ended(struct media_player *player, HRESULT event_status,
2115         struct media_event **event)
2116 {
2117     EnterCriticalSection(&player->cs);
2118
2119     media_player_set_state(player, MFP_MEDIAPLAYER_STATE_STOPPED);
2120     media_event_create(player, MFP_EVENT_TYPE_PLAYBACK_ENDED, event_status, player->item, event);
2121
2122     LeaveCriticalSection(&player->cs);
2123 }
2124
2125 static void media_player_rate_changed(struct media_player *player, HRESULT event_status,
2126         float rate, struct media_event **event)
2127 {
2128     EnterCriticalSection(&player->cs);
2129
2130     if (SUCCEEDED(media_event_create(player, MFP_EVENT_TYPE_RATE_SET, event_status, player->item, event)))
2131         (*event)->u.rate_set.flRate = rate;
2132
2133     LeaveCriticalSection(&player->cs);
2134 }
2135
2136 static HRESULT WINAPI media_player_session_events_callback_Invoke(IMFAsyncCallback *iface,
2137         IMFAsyncResult *result)
2138 {
2139     struct media_player *player = impl_from_session_events_IMFAsyncCallback(iface);
2140     MediaEventType session_event_type = MEUnknown;
2141     struct media_event *event = NULL;
2142     IMFMediaEvent *session_event;
2143     MFP_MEDIAPLAYER_STATE state;
2144     HRESULT hr, event_status;
2145     IMFTopology *topology;
2146     unsigned int status;
2147     PROPVARIANT value;
2148     float rate;
2149
2150     if (FAILED(hr = IMFMediaSession_EndGetEvent(player->session, result, &session_event)))
2151         return S_OK;
2152
2153     IMFMediaEvent_GetType(session_event, &session_event_type);
2154     IMFMediaEvent_GetStatus(session_event, &event_status);
2155
2156     switch (session_event_type)
2157     {
2158         case MESessionStarted:
2159         case MESessionStopped:
2160         case MESessionPaused:
2161
2162             if (session_event_type == MESessionStarted)
2163                 state = MFP_MEDIAPLAYER_STATE_PLAYING;
2164             else if (session_event_type == MESessionPaused)
2165                 state = MFP_MEDIAPLAYER_STATE_PAUSED;
2166             else
2167                 state = MFP_MEDIAPLAYER_STATE_STOPPED;
2168
2169             media_player_change_state(player, state, event_status, &event);
2170
2171             break;
2172
2173         case MESessionTopologySet:
2174
2175             value.vt = VT_EMPTY;
2176             if (SUCCEEDED(IMFMediaEvent_GetValue(session_event, &value)))
2177             {
2178                 if (value.vt == VT_EMPTY)
2179                 {
2180                     media_player_clear_item(player, event_status, &event);
2181                 }
2182                 else if (value.vt == VT_UNKNOWN && value.punkVal &&
2183                         SUCCEEDED(IUnknown_QueryInterface(value.punkVal, &IID_IMFTopology, (void **)&topology)))
2184                 {
2185                     media_player_set_item(player, topology, event_status, &event);
2186                     IMFTopology_Release(topology);
2187                 }
2188                 PropVariantClear(&value);
2189             }
2190
2191             break;
2192
2193         case MESessionTopologyStatus:
2194
2195             if (SUCCEEDED(IMFMediaEvent_GetUINT32(session_event, &MF_EVENT_TOPOLOGY_STATUS, &status)) &&
2196                     status == MF_TOPOSTATUS_ENDED)
2197             {
2198                 media_player_playback_ended(player, event_status, &event);
2199             }
2200
2201             break;
2202
2203         case MESessionRateChanged:
2204
2205             rate = 0.0f;
2206             if (SUCCEEDED(IMFMediaEvent_GetValue(session_event, &value)))
2207             {
2208                 if (value.vt == VT_R4)
2209                     rate = value.fltVal;
2210                 PropVariantClear(&value);
2211             }
2212
2213             media_player_rate_changed(player, event_status, rate, &event);
2214
2215             break;
2216
2217         case MEBufferingStarted:
2218         case MEBufferingStopped:
2219         case MEExtendedType:
2220         case MEReconnectStart:
2221         case MEReconnectEnd:
2222         case MERendererEvent:
2223         case MEStreamSinkFormatChanged:
2224
2225             media_player_create_forward_event(player, event_status, session_event, &event);
2226
2227             break;
2228
2229         case MEError:
2230
2231             media_event_create(player, MFP_EVENT_TYPE_ERROR, event_status, NULL, &event);
2232
2233             break;
2234
2235         default:
2236             ;
2237     }
2238
2239     if (event)
2240     {
2241         media_player_queue_event(player, event);
2242         IUnknown_Release(&event->IUnknown_iface);
2243     }
2244
2245     IMFMediaSession_BeginGetEvent(player->session, &player->session_events_callback, NULL);
2246     IMFMediaEvent_Release(session_event);
2247
2248     return S_OK;
2249 }
2250
2251 static const IMFAsyncCallbackVtbl media_player_session_events_callback_vtbl =
2252 {
2253     media_player_callback_QueryInterface,
2254     media_player_session_events_callback_AddRef,
2255     media_player_session_events_callback_Release,
2256     media_player_callback_GetParameters,
2257     media_player_session_events_callback_Invoke,
2258 };
2259
2260 /***********************************************************************
2261  *      MFPCreateMediaPlayer (mfplay.@)
2262  */
2263 HRESULT WINAPI MFPCreateMediaPlayer(const WCHAR *url, BOOL start_playback, MFP_CREATION_OPTIONS options,
2264         IMFPMediaPlayerCallback *callback, HWND window, IMFPMediaPlayer **player)
2265 {
2266     struct media_player *object;
2267     IMFPMediaItem *item;
2268     HRESULT hr;
2269
2270     TRACE("%s, %d, %#x, %p, %p, %p.\n", debugstr_w(url), start_playback, options, callback, window, player);
2271
2272     if (!player)
2273         return E_POINTER;
2274
2275     *player = NULL;
2276
2277     if (!url && start_playback)
2278         return E_INVALIDARG;
2279
2280     if (!(object = calloc(1, sizeof(*object))))
2281         return E_OUTOFMEMORY;
2282
2283     platform_startup();
2284
2285     object->IMFPMediaPlayer_iface.lpVtbl = &media_player_vtbl;
2286     object->IPropertyStore_iface.lpVtbl = &media_player_propstore_vtbl;
2287     object->resolver_callback.lpVtbl = &media_player_resolver_callback_vtbl;
2288     object->events_callback.lpVtbl = &media_player_events_callback_vtbl;
2289     object->session_events_callback.lpVtbl = &media_player_session_events_callback_vtbl;
2290     object->refcount = 1;
2291     object->callback = callback;
2292     if (object->callback)
2293         IMFPMediaPlayerCallback_AddRef(object->callback);
2294     object->options = options;
2295     object->output_window = window;
2296     InitializeCriticalSection(&object->cs);
2297     if (FAILED(hr = CreatePropertyStore(&object->propstore)))
2298         goto failed;
2299     if (FAILED(hr = MFCreateSourceResolver(&object->resolver)))
2300         goto failed;
2301     if (FAILED(hr = MFCreateMediaSession(NULL, &object->session)))
2302         goto failed;
2303     if (FAILED(hr = IMFMediaSession_BeginGetEvent(object->session, &object->session_events_callback, NULL)))
2304         goto failed;
2305     if (!(object->options & MFP_OPTION_FREE_THREADED_CALLBACK))
2306     {
2307         object->event_window = CreateWindowW(eventclassW, NULL, 0, 0, 0, 0, 0, HWND_MESSAGE,
2308                 0, mfplay_instance, NULL);
2309     }
2310
2311     if (url)
2312     {
2313         if (FAILED(hr = media_player_create_item_from_url(object, url, TRUE, 0, &item)))
2314         {
2315             WARN("Failed to create media item, hr %#lx.\n", hr);
2316             goto failed;
2317         }
2318
2319         hr = IMFPMediaPlayer_SetMediaItem(&object->IMFPMediaPlayer_iface, item);
2320         IMFPMediaItem_Release(item);
2321         if (FAILED(hr))
2322         {
2323             WARN("Failed to set media item, hr %#lx.\n", hr);
2324             goto failed;
2325         }
2326
2327         if (start_playback)
2328             IMFPMediaPlayer_Play(&object->IMFPMediaPlayer_iface);
2329     }
2330
2331     *player = &object->IMFPMediaPlayer_iface;
2332
2333     return S_OK;
2334
2335 failed:
2336
2337     IMFPMediaPlayer_Release(&object->IMFPMediaPlayer_iface);
2338
2339     return hr;
2340 }
2341
2342 static void media_player_register_window_class(void)
2343 {
2344     WNDCLASSW cls = { 0 };
2345
2346     cls.lpfnWndProc = media_player_event_proc;
2347     cls.hInstance = mfplay_instance;
2348     cls.lpszClassName = eventclassW;
2349
2350     RegisterClassW(&cls);
2351 }
2352
2353 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
2354 {
2355     switch (reason)
2356     {
2357         case DLL_PROCESS_ATTACH:
2358             mfplay_instance = instance;
2359             DisableThreadLibraryCalls(instance);
2360             media_player_register_window_class();
2361             break;
2362         case DLL_PROCESS_DETACH:
2363             if (reserved) break;
2364             UnregisterClassW(eventclassW, instance);
2365             break;
2366     }
2367
2368     return TRUE;
2369 }