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 LONG startup_refcount;
  34
  35 static void platform_startup(void)
  36 {
  37     if (InterlockedIncrement(&startup_refcount) == 1)
  38         MFStartup(MF_VERSION, MFSTARTUP_FULL);
  39 }
  40
  41 static void platform_shutdown(void)
  42 {
  43     if (InterlockedDecrement(&startup_refcount) == 0)
  44         MFShutdown();
  45 }
  46
  47 struct media_item
  48 {
  49     IMFPMediaItem IMFPMediaItem_iface;
  50     LONG refcount;
  51     IMFPMediaPlayer *player;
  52     IMFMediaSource *source;
  53     IMFPresentationDescriptor *pd;
  54     DWORD_PTR user_data;
  55 };
  56
  57 struct media_player
  58 {
  59     IMFPMediaPlayer IMFPMediaPlayer_iface;
  60     IPropertyStore IPropertyStore_iface;
  61     IMFAsyncCallback resolver_callback;
  62     LONG refcount;
  63     IMFPMediaPlayerCallback *callback;
  64     IPropertyStore *propstore;
  65     IMFSourceResolver *resolver;
  66 };
  67
  68 static struct media_player *impl_from_IMFPMediaPlayer(IMFPMediaPlayer *iface)
  69 {
  70     return CONTAINING_RECORD(iface, struct media_player, IMFPMediaPlayer_iface);
  71 }
  72
  73 static struct media_player *impl_from_IPropertyStore(IPropertyStore *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct media_player, IPropertyStore_iface);
  76 }
  77
  78 static struct media_player *impl_from_resolver_IMFAsyncCallback(IMFAsyncCallback *iface)
  79 {
  80     return CONTAINING_RECORD(iface, struct media_player, resolver_callback);
  81 }
  82
  83 static struct media_item *impl_from_IMFPMediaItem(IMFPMediaItem *iface)
  84 {
  85     return CONTAINING_RECORD(iface, struct media_item, IMFPMediaItem_iface);
  86 }
  87
  88 static HRESULT WINAPI media_item_QueryInterface(IMFPMediaItem *iface, REFIID riid, void **obj)
  89 {
  90     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  91
  92     if (IsEqualIID(riid, &IID_IMFPMediaItem) ||
  93             IsEqualIID(riid, &IID_IUnknown))
  94     {
  95         *obj = iface;
  96         IMFPMediaItem_AddRef(iface);
  97         return S_OK;
  98     }
  99
 100     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 101     *obj = NULL;
 102     return E_NOINTERFACE;
 103 }
 104
 105 static ULONG WINAPI media_item_AddRef(IMFPMediaItem *iface)
 106 {
 107     struct media_item *item = impl_from_IMFPMediaItem(iface);
 108     ULONG refcount = InterlockedIncrement(&item->refcount);
 109
 110     TRACE("%p, refcount %u.\n", iface, refcount);
 111
 112     return refcount;
 113 }
 114
 115 static ULONG WINAPI media_item_Release(IMFPMediaItem *iface)
 116 {
 117     struct media_item *item = impl_from_IMFPMediaItem(iface);
 118     ULONG refcount = InterlockedDecrement(&item->refcount);
 119
 120     TRACE("%p, refcount %u.\n", iface, refcount);
 121
 122     if (!refcount)
 123     {
 124         if (item->player)
 125             IMFPMediaPlayer_Release(item->player);
 126         if (item->source)
 127             IMFMediaSource_Release(item->source);
 128         if (item->pd)
 129             IMFPresentationDescriptor_Release(item->pd);
 130         heap_free(item);
 131     }
 132
 133     return refcount;
 134 }
 135
 136 static HRESULT WINAPI media_item_GetMediaPlayer(IMFPMediaItem *iface,
 137         IMFPMediaPlayer **player)
 138 {
 139     struct media_item *item = impl_from_IMFPMediaItem(iface);
 140
 141     TRACE("%p, %p.\n", iface, player);
 142
 143     *player = item->player;
 144     IMFPMediaPlayer_AddRef(*player);
 145
 146     return S_OK;
 147 }
 148
 149 static HRESULT WINAPI media_item_GetURL(IMFPMediaItem *iface, LPWSTR *url)
 150 {
 151     FIXME("%p, %p.\n", iface, url);
 152
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT WINAPI media_item_GetObject(IMFPMediaItem *iface, IUnknown **obj)
 157 {
 158     FIXME("%p, %p.\n", iface, obj);
 159
 160     return E_NOTIMPL;
 161 }
 162
 163 static HRESULT WINAPI media_item_GetUserData(IMFPMediaItem *iface, DWORD_PTR *user_data)
 164 {
 165     struct media_item *item = impl_from_IMFPMediaItem(iface);
 166
 167     TRACE("%p, %p.\n", iface, user_data);
 168
 169     *user_data = item->user_data;
 170
 171     return S_OK;
 172 }
 173
 174 static HRESULT WINAPI media_item_SetUserData(IMFPMediaItem *iface, DWORD_PTR user_data)
 175 {
 176     struct media_item *item = impl_from_IMFPMediaItem(iface);
 177
 178     TRACE("%p, %lx.\n", iface, user_data);
 179
 180     item->user_data = user_data;
 181
 182     return S_OK;
 183 }
 184
 185 static HRESULT WINAPI media_item_GetStartStopPosition(IMFPMediaItem *iface, GUID *start_format,
 186         PROPVARIANT *start_position, GUID *stop_format, PROPVARIANT *stop_position)
 187 {
 188     FIXME("%p, %p, %p, %p, %p.\n", iface, start_format, start_position, stop_format, stop_position);
 189
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI media_item_SetStartStopPosition(IMFPMediaItem *iface, const GUID *start_format,
 194         const PROPVARIANT *start_position, const GUID *stop_format, const PROPVARIANT *stop_position)
 195 {
 196     FIXME("%p, %s, %p, %s, %p.\n", iface, debugstr_guid(start_format), start_position,
 197             debugstr_guid(stop_format), stop_position);
 198
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI media_item_HasVideo(IMFPMediaItem *iface, BOOL *has_video, BOOL *selected)
 203 {
 204     FIXME("%p, %p, %p.\n", iface, has_video, selected);
 205
 206     return E_NOTIMPL;
 207 }
 208
 209 static HRESULT WINAPI media_item_HasAudio(IMFPMediaItem *iface, BOOL *has_audio, BOOL *selected)
 210 {
 211     FIXME("%p, %p, %p.\n", iface, has_audio, selected);
 212
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI media_item_IsProtected(IMFPMediaItem *iface, BOOL *protected)
 217 {
 218     struct media_item *item = impl_from_IMFPMediaItem(iface);
 219
 220     TRACE("%p, %p.\n", iface, protected);
 221
 222     *protected = MFRequireProtectedEnvironment(item->pd) == S_OK;
 223
 224     return S_OK;
 225 }
 226
 227 static HRESULT WINAPI media_item_GetDuration(IMFPMediaItem *iface, REFGUID format, PROPVARIANT *value)
 228 {
 229     FIXME("%p, %s, %p.\n", iface, debugstr_guid(format), value);
 230
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI media_item_GetNumberOfStreams(IMFPMediaItem *iface, DWORD *count)
 235 {
 236     struct media_item *item = impl_from_IMFPMediaItem(iface);
 237
 238     TRACE("%p, %p.\n", iface, count);
 239
 240     return IMFPresentationDescriptor_GetStreamDescriptorCount(item->pd, count);
 241 }
 242
 243 static HRESULT WINAPI media_item_GetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL *selected)
 244 {
 245     struct media_item *item = impl_from_IMFPMediaItem(iface);
 246     IMFStreamDescriptor *sd;
 247     HRESULT hr;
 248
 249     TRACE("%p, %u, %p.\n", iface, index, selected);
 250
 251     if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, selected, &sd)))
 252         IMFStreamDescriptor_Release(sd);
 253
 254     return hr;
 255 }
 256
 257 static HRESULT WINAPI media_item_SetStreamSelection(IMFPMediaItem *iface, DWORD index, BOOL select)
 258 {
 259     struct media_item *item = impl_from_IMFPMediaItem(iface);
 260
 261     TRACE("%p, %u, %d.\n", iface, index, select);
 262
 263     return select ? IMFPresentationDescriptor_SelectStream(item->pd, index) :
 264             IMFPresentationDescriptor_DeselectStream(item->pd, index);
 265 }
 266
 267 static HRESULT WINAPI media_item_GetStreamAttribute(IMFPMediaItem *iface, DWORD index, REFGUID key,
 268         PROPVARIANT *value)
 269 {
 270     struct media_item *item = impl_from_IMFPMediaItem(iface);
 271     IMFStreamDescriptor *sd;
 272     BOOL selected;
 273     HRESULT hr;
 274
 275     TRACE("%p, %u, %s, %p.\n", iface, index, debugstr_guid(key), value);
 276
 277     if (SUCCEEDED(hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(item->pd, index, &selected, &sd)))
 278     {
 279         hr = IMFStreamDescriptor_GetItem(sd, key, value);
 280         IMFStreamDescriptor_Release(sd);
 281     }
 282
 283     return hr;
 284 }
 285
 286 static HRESULT WINAPI media_item_GetPresentationAttribute(IMFPMediaItem *iface, REFGUID key,
 287         PROPVARIANT *value)
 288 {
 289     struct media_item *item = impl_from_IMFPMediaItem(iface);
 290
 291     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 292
 293     return IMFPresentationDescriptor_GetItem(item->pd, key, value);
 294 }
 295
 296 static HRESULT WINAPI media_item_GetCharacteristics(IMFPMediaItem *iface, MFP_MEDIAITEM_CHARACTERISTICS *flags)
 297 {
 298     FIXME("%p, %p.\n", iface, flags);
 299
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI media_item_SetStreamSink(IMFPMediaItem *iface, DWORD index, IUnknown *sink)
 304 {
 305     FIXME("%p, %u, %p.\n", iface, index, sink);
 306
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI media_item_GetMetadata(IMFPMediaItem *iface, IPropertyStore **metadata)
 311 {
 312     FIXME("%p, %p.\n", iface, metadata);
 313
 314     return E_NOTIMPL;
 315 }
 316
 317 static const IMFPMediaItemVtbl media_item_vtbl =
 318 {
 319     media_item_QueryInterface,
 320     media_item_AddRef,
 321     media_item_Release,
 322     media_item_GetMediaPlayer,
 323     media_item_GetURL,
 324     media_item_GetObject,
 325     media_item_GetUserData,
 326     media_item_SetUserData,
 327     media_item_GetStartStopPosition,
 328     media_item_SetStartStopPosition,
 329     media_item_HasVideo,
 330     media_item_HasAudio,
 331     media_item_IsProtected,
 332     media_item_GetDuration,
 333     media_item_GetNumberOfStreams,
 334     media_item_GetStreamSelection,
 335     media_item_SetStreamSelection,
 336     media_item_GetStreamAttribute,
 337     media_item_GetPresentationAttribute,
 338     media_item_GetCharacteristics,
 339     media_item_SetStreamSink,
 340     media_item_GetMetadata,
 341 };
 342
 343 static HRESULT create_media_item(IMFPMediaPlayer *player, DWORD_PTR user_data, struct media_item **item)
 344 {
 345     struct media_item *object;
 346
 347     if (!(object = heap_alloc_zero(sizeof(*object))))
 348         return E_OUTOFMEMORY;
 349
 350     object->IMFPMediaItem_iface.lpVtbl = &media_item_vtbl;
 351     object->refcount = 1;
 352     object->user_data = user_data;
 353     object->player = player;
 354     IMFPMediaPlayer_AddRef(object->player);
 355
 356     *item = object;
 357
 358     return S_OK;
 359 }
 360
 361 static HRESULT media_item_set_source(struct media_item *item, IUnknown *object)
 362 {
 363     IMFPresentationDescriptor *pd;
 364     IMFMediaSource *source;
 365     HRESULT hr;
 366
 367     if (FAILED(hr = IUnknown_QueryInterface(object, &IID_IMFMediaSource, (void **)&source)))
 368         return hr;
 369
 370     if (FAILED(hr = IMFMediaSource_CreatePresentationDescriptor(source, &pd)))
 371     {
 372         WARN("Failed to get presentation descriptor, hr %#x.\n", hr);
 373         IMFMediaSource_Release(source);
 374         return hr;
 375     }
 376
 377     item->source = source;
 378     item->pd = pd;
 379
 380     return hr;
 381 }
 382
 383 static HRESULT WINAPI media_player_QueryInterface(IMFPMediaPlayer *iface, REFIID riid, void **obj)
 384 {
 385     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 386
 387     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 388
 389     if (IsEqualIID(riid, &IID_IMFPMediaPlayer) ||
 390             IsEqualIID(riid, &IID_IUnknown))
 391     {
 392         *obj = &player->IMFPMediaPlayer_iface;
 393     }
 394     else if (IsEqualIID(riid, &IID_IPropertyStore))
 395     {
 396         *obj = &player->IPropertyStore_iface;
 397     }
 398     else
 399     {
 400         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 401         *obj = NULL;
 402
 403         return E_NOINTERFACE;
 404     }
 405
 406     IUnknown_AddRef((IUnknown *)*obj);
 407     return S_OK;
 408 }
 409
 410 static ULONG WINAPI media_player_AddRef(IMFPMediaPlayer *iface)
 411 {
 412     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 413     ULONG refcount = InterlockedIncrement(&player->refcount);
 414
 415     TRACE("%p, refcount %u.\n", iface, refcount);
 416
 417     return refcount;
 418 }
 419
 420 static ULONG WINAPI media_player_Release(IMFPMediaPlayer *iface)
 421 {
 422     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 423     ULONG refcount = InterlockedDecrement(&player->refcount);
 424
 425     TRACE("%p, refcount %u.\n", iface, refcount);
 426
 427     if (!refcount)
 428     {
 429         if (player->callback)
 430             IMFPMediaPlayerCallback_Release(player->callback);
 431         if (player->propstore)
 432             IPropertyStore_Release(player->propstore);
 433         if (player->resolver)
 434             IMFSourceResolver_Release(player->resolver);
 435         heap_free(player);
 436
 437         platform_shutdown();
 438     }
 439
 440     return refcount;
 441 }
 442
 443 static HRESULT WINAPI media_player_Play(IMFPMediaPlayer *iface)
 444 {
 445     FIXME("%p.\n", iface);
 446
 447     return E_NOTIMPL;
 448 }
 449
 450 static HRESULT WINAPI media_player_Pause(IMFPMediaPlayer *iface)
 451 {
 452     FIXME("%p.\n", iface);
 453
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI media_player_Stop(IMFPMediaPlayer *iface)
 458 {
 459     FIXME("%p.\n", iface);
 460
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI media_player_FrameStep(IMFPMediaPlayer *iface)
 465 {
 466     FIXME("%p.\n", iface);
 467
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI media_player_SetPosition(IMFPMediaPlayer *iface, REFGUID postype, const PROPVARIANT *position)
 472 {
 473     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 474
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI media_player_GetPosition(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 479 {
 480     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 481
 482     return E_NOTIMPL;
 483 }
 484
 485 static HRESULT WINAPI media_player_GetDuration(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 486 {
 487     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 488
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI media_player_SetRate(IMFPMediaPlayer *iface, float rate)
 493 {
 494     FIXME("%p, %f.\n", iface, rate);
 495
 496     return E_NOTIMPL;
 497 }
 498
 499 static HRESULT WINAPI media_player_GetRate(IMFPMediaPlayer *iface, float *rate)
 500 {
 501     FIXME("%p, %p.\n", iface, rate);
 502
 503     return E_NOTIMPL;
 504 }
 505
 506 static HRESULT WINAPI media_player_GetSupportedRates(IMFPMediaPlayer *iface, BOOL forward, float *slowest_rate, float *fastest_rate)
 507 {
 508     FIXME("%p, %d, %p, %p.\n", iface, forward, slowest_rate, fastest_rate);
 509
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT WINAPI media_player_GetState(IMFPMediaPlayer *iface, MFP_MEDIAPLAYER_STATE *state)
 514 {
 515     FIXME("%p, %p.\n", iface, state);
 516
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI media_player_CreateMediaItemFromURL(IMFPMediaPlayer *iface,
 521         const WCHAR *url, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **ret)
 522 {
 523     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
 524     struct media_item *item;
 525     MF_OBJECT_TYPE obj_type;
 526     IUnknown *object;
 527     HRESULT hr;
 528
 529     TRACE("%p, %s, %d, %lx, %p.\n", iface, debugstr_w(url), sync, user_data, ret);
 530
 531     if (FAILED(hr = create_media_item(iface, user_data, &item)))
 532         return hr;
 533
 534     if (sync)
 535     {
 536         *ret = NULL;
 537
 538         if (SUCCEEDED(hr = IMFSourceResolver_CreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE,
 539                 player->propstore, &obj_type, &object)))
 540         {
 541             hr = media_item_set_source(item, object);
 542             IUnknown_Release(object);
 543         }
 544
 545         if (SUCCEEDED(hr))
 546             *ret = &item->IMFPMediaItem_iface;
 547
 548         return hr;
 549     }
 550     else
 551     {
 552         hr = IMFSourceResolver_BeginCreateObjectFromURL(player->resolver, url, MF_RESOLUTION_MEDIASOURCE,
 553             player->propstore, NULL, &player->resolver_callback, (IUnknown *)&item->IMFPMediaItem_iface);
 554
 555         IMFPMediaItem_Release(&item->IMFPMediaItem_iface);
 556     }
 557
 558     return hr;
 559 }
 560
 561 static HRESULT WINAPI media_player_CreateMediaItemFromObject(IMFPMediaPlayer *iface,
 562         IUnknown *object, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
 563 {
 564     FIXME("%p, %p, %d, %lx, %p.\n", iface, object, sync, user_data, item);
 565
 566     return E_NOTIMPL;
 567 }
 568
 569 static HRESULT WINAPI media_player_SetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem *item)
 570 {
 571     FIXME("%p, %p.\n", iface, item);
 572
 573     return E_NOTIMPL;
 574 }
 575
 576 static HRESULT WINAPI media_player_ClearMediaItem(IMFPMediaPlayer *iface)
 577 {
 578     FIXME("%p.\n", iface);
 579
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI media_player_GetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem **item)
 584 {
 585     FIXME("%p, %p.\n", iface, item);
 586
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI media_player_GetVolume(IMFPMediaPlayer *iface, float *volume)
 591 {
 592     FIXME("%p, %p.\n", iface, volume);
 593
 594     return E_NOTIMPL;
 595 }
 596
 597 static HRESULT WINAPI media_player_SetVolume(IMFPMediaPlayer *iface, float volume)
 598 {
 599     FIXME("%p, %.8e.\n", iface, volume);
 600
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI media_player_GetBalance(IMFPMediaPlayer *iface, float *balance)
 605 {
 606     FIXME("%p, %p.\n", iface, balance);
 607
 608     return E_NOTIMPL;
 609 }
 610
 611 static HRESULT WINAPI media_player_SetBalance(IMFPMediaPlayer *iface, float balance)
 612 {
 613     FIXME("%p, %.8e.\n", iface, balance);
 614
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT WINAPI media_player_GetMute(IMFPMediaPlayer *iface, BOOL *mute)
 619 {
 620     FIXME("%p, %p.\n", iface, mute);
 621
 622     return E_NOTIMPL;
 623 }
 624
 625 static HRESULT WINAPI media_player_SetMute(IMFPMediaPlayer *iface, BOOL mute)
 626 {
 627     FIXME("%p, %d.\n", iface, mute);
 628
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI media_player_GetNativeVideoSize(IMFPMediaPlayer *iface,
 633         SIZE *video, SIZE *arvideo)
 634 {
 635     FIXME("%p, %p, %p.\n", iface, video, arvideo);
 636
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI media_player_GetIdealVideoSize(IMFPMediaPlayer *iface,
 641         SIZE *min_size, SIZE *max_size)
 642 {
 643     FIXME("%p, %p, %p.\n", iface, min_size, max_size);
 644
 645     return E_NOTIMPL;
 646 }
 647
 648 static HRESULT WINAPI media_player_SetVideoSourceRect(IMFPMediaPlayer *iface,
 649         MFVideoNormalizedRect const *rect)
 650 {
 651     FIXME("%p, %p.\n", iface, rect);
 652
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI media_player_GetVideoSourceRect(IMFPMediaPlayer *iface,
 657         MFVideoNormalizedRect *rect)
 658 {
 659     FIXME("%p, %p.\n", iface, rect);
 660
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI media_player_SetAspectRatioMode(IMFPMediaPlayer *iface, DWORD mode)
 665 {
 666     FIXME("%p, %u.\n", iface, mode);
 667
 668     return E_NOTIMPL;
 669 }
 670
 671 static HRESULT WINAPI media_player_GetAspectRatioMode(IMFPMediaPlayer *iface,
 672         DWORD *mode)
 673 {
 674     FIXME("%p, %p.\n", iface, mode);
 675
 676     return E_NOTIMPL;
 677 }
 678
 679 static HRESULT WINAPI media_player_GetVideoWindow(IMFPMediaPlayer *iface, HWND *hwnd)
 680 {
 681     FIXME("%p, %p.\n", iface, hwnd);
 682
 683     return E_NOTIMPL;
 684 }
 685
 686 static HRESULT WINAPI media_player_UpdateVideo(IMFPMediaPlayer *iface)
 687 {
 688     FIXME("%p.\n", iface);
 689
 690     return E_NOTIMPL;
 691 }
 692
 693 static HRESULT WINAPI media_player_SetBorderColor(IMFPMediaPlayer *iface, COLORREF color)
 694 {
 695     FIXME("%p, %#x.\n", iface, color);
 696
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI media_player_GetBorderColor(IMFPMediaPlayer *iface, COLORREF *color)
 701 {
 702     FIXME("%p, %p.\n", iface, color);
 703
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI media_player_InsertEffect(IMFPMediaPlayer *iface, IUnknown *effect,
 708         BOOL optional)
 709 {
 710     FIXME("%p, %p, %d.\n", iface, effect, optional);
 711
 712     return E_NOTIMPL;
 713 }
 714
 715 static HRESULT WINAPI media_player_RemoveEffect(IMFPMediaPlayer *iface, IUnknown *effect)
 716 {
 717     FIXME("%p, %p.\n", iface, effect);
 718
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI media_player_RemoveAllEffects(IMFPMediaPlayer *iface)
 723 {
 724     FIXME("%p.\n", iface);
 725
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI media_player_Shutdown(IMFPMediaPlayer *iface)
 730 {
 731     FIXME("%p.\n", iface);
 732
 733     return E_NOTIMPL;
 734 }
 735
 736 static const IMFPMediaPlayerVtbl media_player_vtbl =
 737 {
 738     media_player_QueryInterface,
 739     media_player_AddRef,
 740     media_player_Release,
 741     media_player_Play,
 742     media_player_Pause,
 743     media_player_Stop,
 744     media_player_FrameStep,
 745     media_player_SetPosition,
 746     media_player_GetPosition,
 747     media_player_GetDuration,
 748     media_player_SetRate,
 749     media_player_GetRate,
 750     media_player_GetSupportedRates,
 751     media_player_GetState,
 752     media_player_CreateMediaItemFromURL,
 753     media_player_CreateMediaItemFromObject,
 754     media_player_SetMediaItem,
 755     media_player_ClearMediaItem,
 756     media_player_GetMediaItem,
 757     media_player_GetVolume,
 758     media_player_SetVolume,
 759     media_player_GetBalance,
 760     media_player_SetBalance,
 761     media_player_GetMute,
 762     media_player_SetMute,
 763     media_player_GetNativeVideoSize,
 764     media_player_GetIdealVideoSize,
 765     media_player_SetVideoSourceRect,
 766     media_player_GetVideoSourceRect,
 767     media_player_SetAspectRatioMode,
 768     media_player_GetAspectRatioMode,
 769     media_player_GetVideoWindow,
 770     media_player_UpdateVideo,
 771     media_player_SetBorderColor,
 772     media_player_GetBorderColor,
 773     media_player_InsertEffect,
 774     media_player_RemoveEffect,
 775     media_player_RemoveAllEffects,
 776     media_player_Shutdown,
 777 };
 778
 779 static HRESULT WINAPI media_player_propstore_QueryInterface(IPropertyStore *iface,
 780         REFIID riid, void **obj)
 781 {
 782     struct media_player *player = impl_from_IPropertyStore(iface);
 783     return IMFPMediaPlayer_QueryInterface(&player->IMFPMediaPlayer_iface, riid, obj);
 784 }
 785
 786 static ULONG WINAPI media_player_propstore_AddRef(IPropertyStore *iface)
 787 {
 788     struct media_player *player = impl_from_IPropertyStore(iface);
 789     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
 790 }
 791
 792 static ULONG WINAPI media_player_propstore_Release(IPropertyStore *iface)
 793 {
 794     struct media_player *player = impl_from_IPropertyStore(iface);
 795     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
 796 }
 797
 798 static HRESULT WINAPI media_player_propstore_GetCount(IPropertyStore *iface, DWORD *count)
 799 {
 800     struct media_player *player = impl_from_IPropertyStore(iface);
 801
 802     TRACE("%p, %p.\n", iface, count);
 803
 804     return IPropertyStore_GetCount(player->propstore, count);
 805 }
 806
 807 static HRESULT WINAPI media_player_propstore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
 808 {
 809     struct media_player *player = impl_from_IPropertyStore(iface);
 810
 811     TRACE("%p, %u, %p.\n", iface, prop, key);
 812
 813     return IPropertyStore_GetAt(player->propstore, prop, key);
 814 }
 815
 816 static HRESULT WINAPI media_player_propstore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *value)
 817 {
 818     struct media_player *player = impl_from_IPropertyStore(iface);
 819
 820     TRACE("%p, %p, %p.\n", iface, key, value);
 821
 822     return IPropertyStore_GetValue(player->propstore, key, value);
 823 }
 824
 825 static HRESULT WINAPI media_player_propstore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT value)
 826 {
 827     struct media_player *player = impl_from_IPropertyStore(iface);
 828
 829     TRACE("%p, %p, %p.\n", iface, key, value);
 830
 831     return IPropertyStore_SetValue(player->propstore, key, value);
 832 }
 833
 834 static HRESULT WINAPI media_player_propstore_Commit(IPropertyStore *iface)
 835 {
 836     struct media_player *player = impl_from_IPropertyStore(iface);
 837
 838     TRACE("%p.\n", iface);
 839
 840     return IPropertyStore_Commit(player->propstore);
 841 }
 842
 843 static const IPropertyStoreVtbl media_player_propstore_vtbl =
 844 {
 845     media_player_propstore_QueryInterface,
 846     media_player_propstore_AddRef,
 847     media_player_propstore_Release,
 848     media_player_propstore_GetCount,
 849     media_player_propstore_GetAt,
 850     media_player_propstore_GetValue,
 851     media_player_propstore_SetValue,
 852     media_player_propstore_Commit,
 853 };
 854
 855 static HRESULT WINAPI media_player_resolver_callback_QueryInterface(IMFAsyncCallback *iface,
 856         REFIID riid, void **obj)
 857 {
 858     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 859             IsEqualIID(riid, &IID_IUnknown))
 860     {
 861         *obj = iface;
 862         IMFAsyncCallback_AddRef(iface);
 863         return S_OK;
 864     }
 865
 866     *obj = NULL;
 867     return E_NOINTERFACE;
 868 }
 869
 870 static ULONG WINAPI media_player_resolver_callback_AddRef(IMFAsyncCallback *iface)
 871 {
 872     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
 873     return IMFPMediaPlayer_AddRef(&player->IMFPMediaPlayer_iface);
 874 }
 875
 876 static ULONG WINAPI media_player_resolver_callback_Release(IMFAsyncCallback *iface)
 877 {
 878     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
 879     return IMFPMediaPlayer_Release(&player->IMFPMediaPlayer_iface);
 880 }
 881
 882 static HRESULT WINAPI media_player_resolver_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags,
 883         DWORD *queue)
 884 {
 885     return E_NOTIMPL;
 886 }
 887
 888 static HRESULT WINAPI media_player_resolver_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 889 {
 890     struct media_player *player = impl_from_resolver_IMFAsyncCallback(iface);
 891     struct media_item *item;
 892     IUnknown *object, *state;
 893     MF_OBJECT_TYPE obj_type;
 894     HRESULT hr;
 895
 896     if (FAILED(IMFAsyncResult_GetState(result, &state)))
 897         return S_OK;
 898
 899     item = impl_from_IMFPMediaItem((IMFPMediaItem *)state);
 900
 901     if (SUCCEEDED(hr = IMFSourceResolver_EndCreateObjectFromURL(player->resolver, result, &obj_type, &object)))
 902     {
 903         hr = media_item_set_source(item, object);
 904         IUnknown_Release(object);
 905     }
 906
 907     if (FAILED(hr))
 908         WARN("Failed to set media source, hr %#x.\n", hr);
 909
 910     /* FIXME: callback notification */
 911
 912     IUnknown_Release(state);
 913
 914     return S_OK;
 915 }
 916
 917 static const IMFAsyncCallbackVtbl media_player_resolver_callback_vtbl =
 918 {
 919     media_player_resolver_callback_QueryInterface,
 920     media_player_resolver_callback_AddRef,
 921     media_player_resolver_callback_Release,
 922     media_player_resolver_callback_GetParameters,
 923     media_player_resolver_callback_Invoke,
 924 };
 925
 926 HRESULT WINAPI MFPCreateMediaPlayer(const WCHAR *url, BOOL start_playback, MFP_CREATION_OPTIONS options,
 927         IMFPMediaPlayerCallback *callback, HWND hwnd, IMFPMediaPlayer **player)
 928 {
 929     struct media_player *object;
 930     HRESULT hr;
 931
 932     TRACE("%s, %d, %#x, %p, %p, %p.\n", debugstr_w(url), start_playback, options, callback, hwnd, player);
 933
 934     if (!(object = heap_alloc_zero(sizeof(*object))))
 935         return E_OUTOFMEMORY;
 936
 937     platform_startup();
 938
 939     object->IMFPMediaPlayer_iface.lpVtbl = &media_player_vtbl;
 940     object->IPropertyStore_iface.lpVtbl = &media_player_propstore_vtbl;
 941     object->resolver_callback.lpVtbl = &media_player_resolver_callback_vtbl;
 942     object->refcount = 1;
 943     object->callback = callback;
 944     if (object->callback)
 945         IMFPMediaPlayerCallback_AddRef(object->callback);
 946     if (FAILED(hr = CreatePropertyStore(&object->propstore)))
 947         goto failed;
 948     if (FAILED(hr = MFCreateSourceResolver(&object->resolver)))
 949         goto failed;
 950
 951     *player = &object->IMFPMediaPlayer_iface;
 952
 953     return S_OK;
 954
 955 failed:
 956
 957     IMFPMediaPlayer_Release(&object->IMFPMediaPlayer_iface);
 958
 959     return hr;
 960 }