dlls/mfplay/player.c

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