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 "mfplay.h"
  26
  27 #include "wine/debug.h"
  28 #include "wine/heap.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  31
  32 struct media_player
  33 {
  34     IMFPMediaPlayer IMFPMediaPlayer_iface;
  35     LONG refcount;
  36     IMFPMediaPlayerCallback *callback;
  37 };
  38
  39 static struct media_player *impl_from_IMFPMediaPlayer(IMFPMediaPlayer *iface)
  40 {
  41     return CONTAINING_RECORD(iface, struct media_player, IMFPMediaPlayer_iface);
  42 }
  43
  44 static HRESULT WINAPI media_player_QueryInterface(IMFPMediaPlayer *iface, REFIID riid, void **obj)
  45 {
  46     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  47
  48     if (IsEqualIID(riid, &IID_IMFPMediaPlayer) ||
  49             IsEqualIID(riid, &IID_IUnknown))
  50     {
  51         *obj = iface;
  52         IMFPMediaPlayer_AddRef(iface);
  53         return S_OK;
  54     }
  55
  56     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
  57     *obj = NULL;
  58
  59     return E_NOINTERFACE;
  60 }
  61
  62 static ULONG WINAPI media_player_AddRef(IMFPMediaPlayer *iface)
  63 {
  64     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
  65     ULONG refcount = InterlockedIncrement(&player->refcount);
  66
  67     TRACE("%p, refcount %u.\n", iface, refcount);
  68
  69     return refcount;
  70 }
  71
  72 static ULONG WINAPI media_player_Release(IMFPMediaPlayer *iface)
  73 {
  74     struct media_player *player = impl_from_IMFPMediaPlayer(iface);
  75     ULONG refcount = InterlockedDecrement(&player->refcount);
  76
  77     TRACE("%p, refcount %u.\n", iface, refcount);
  78
  79     if (!refcount)
  80     {
  81         if (player->callback)
  82             IMFPMediaPlayerCallback_Release(player->callback);
  83         heap_free(player);
  84     }
  85
  86     return refcount;
  87 }
  88
  89 static HRESULT WINAPI media_player_Play(IMFPMediaPlayer *iface)
  90 {
  91     FIXME("%p.\n", iface);
  92
  93     return E_NOTIMPL;
  94 }
  95
  96 static HRESULT WINAPI media_player_Pause(IMFPMediaPlayer *iface)
  97 {
  98     FIXME("%p.\n", iface);
  99
 100     return E_NOTIMPL;
 101 }
 102
 103 static HRESULT WINAPI media_player_Stop(IMFPMediaPlayer *iface)
 104 {
 105     FIXME("%p.\n", iface);
 106
 107     return E_NOTIMPL;
 108 }
 109
 110 static HRESULT WINAPI media_player_FrameStep(IMFPMediaPlayer *iface)
 111 {
 112     FIXME("%p.\n", iface);
 113
 114     return E_NOTIMPL;
 115 }
 116
 117 static HRESULT WINAPI media_player_SetPosition(IMFPMediaPlayer *iface, REFGUID postype, const PROPVARIANT *position)
 118 {
 119     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 120
 121     return E_NOTIMPL;
 122 }
 123
 124 static HRESULT WINAPI media_player_GetPosition(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 125 {
 126     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 127
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI media_player_GetDuration(IMFPMediaPlayer *iface, REFGUID postype, PROPVARIANT *position)
 132 {
 133     FIXME("%p, %s, %p.\n", iface, debugstr_guid(postype), position);
 134
 135     return E_NOTIMPL;
 136 }
 137
 138 static HRESULT WINAPI media_player_SetRate(IMFPMediaPlayer *iface, float rate)
 139 {
 140     FIXME("%p, %f.\n", iface, rate);
 141
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI media_player_GetRate(IMFPMediaPlayer *iface, float *rate)
 146 {
 147     FIXME("%p, %p.\n", iface, rate);
 148
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI media_player_GetSupportedRates(IMFPMediaPlayer *iface, BOOL forward, float *slowest_rate, float *fastest_rate)
 153 {
 154     FIXME("%p, %d, %p, %p.\n", iface, forward, slowest_rate, fastest_rate);
 155
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI media_player_GetState(IMFPMediaPlayer *iface, MFP_MEDIAPLAYER_STATE *state)
 160 {
 161     FIXME("%p, %p.\n", iface, state);
 162
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI media_player_CreateMediaItemFromURL(IMFPMediaPlayer *iface,
 167         const WCHAR *url, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
 168 {
 169     FIXME("%p, %s, %d, %lx, %p.\n", iface, debugstr_w(url), sync, user_data, item);
 170
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI media_player_CreateMediaItemFromObject(IMFPMediaPlayer *iface,
 175         IUnknown *object, BOOL sync, DWORD_PTR user_data, IMFPMediaItem **item)
 176 {
 177     FIXME("%p, %p, %d, %lx, %p.\n", iface, object, sync, user_data, item);
 178
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI media_player_SetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem *item)
 183 {
 184     FIXME("%p, %p.\n", iface, item);
 185
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI media_player_ClearMediaItem(IMFPMediaPlayer *iface)
 190 {
 191     FIXME("%p.\n", iface);
 192
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI media_player_GetMediaItem(IMFPMediaPlayer *iface, IMFPMediaItem **item)
 197 {
 198     FIXME("%p, %p.\n", iface, item);
 199
 200     return E_NOTIMPL;
 201 }
 202
 203 static HRESULT WINAPI media_player_GetVolume(IMFPMediaPlayer *iface, float *volume)
 204 {
 205     FIXME("%p, %p.\n", iface, volume);
 206
 207     return E_NOTIMPL;
 208 }
 209
 210 static HRESULT WINAPI media_player_SetVolume(IMFPMediaPlayer *iface, float volume)
 211 {
 212     FIXME("%p, %.8e.\n", iface, volume);
 213
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI media_player_GetBalance(IMFPMediaPlayer *iface, float *balance)
 218 {
 219     FIXME("%p, %p.\n", iface, balance);
 220
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT WINAPI media_player_SetBalance(IMFPMediaPlayer *iface, float balance)
 225 {
 226     FIXME("%p, %.8e.\n", iface, balance);
 227
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI media_player_GetMute(IMFPMediaPlayer *iface, BOOL *mute)
 232 {
 233     FIXME("%p, %p.\n", iface, mute);
 234
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI media_player_SetMute(IMFPMediaPlayer *iface, BOOL mute)
 239 {
 240     FIXME("%p, %d.\n", iface, mute);
 241
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI media_player_GetNativeVideoSize(IMFPMediaPlayer *iface,
 246         SIZE *video, SIZE *arvideo)
 247 {
 248     FIXME("%p, %p, %p.\n", iface, video, arvideo);
 249
 250     return E_NOTIMPL;
 251 }
 252
 253 static HRESULT WINAPI media_player_GetIdealVideoSize(IMFPMediaPlayer *iface,
 254         SIZE *min_size, SIZE *max_size)
 255 {
 256     FIXME("%p, %p, %p.\n", iface, min_size, max_size);
 257
 258     return E_NOTIMPL;
 259 }
 260
 261 static HRESULT WINAPI media_player_SetVideoSourceRect(IMFPMediaPlayer *iface,
 262         MFVideoNormalizedRect const *rect)
 263 {
 264     FIXME("%p, %p.\n", iface, rect);
 265
 266     return E_NOTIMPL;
 267 }
 268
 269 static HRESULT WINAPI media_player_GetVideoSourceRect(IMFPMediaPlayer *iface,
 270         MFVideoNormalizedRect *rect)
 271 {
 272     FIXME("%p, %p.\n", iface, rect);
 273
 274     return E_NOTIMPL;
 275 }
 276
 277 static HRESULT WINAPI media_player_SetAspectRatioMode(IMFPMediaPlayer *iface, DWORD mode)
 278 {
 279     FIXME("%p, %u.\n", iface, mode);
 280
 281     return E_NOTIMPL;
 282 }
 283
 284 static HRESULT WINAPI media_player_GetAspectRatioMode(IMFPMediaPlayer *iface,
 285         DWORD *mode)
 286 {
 287     FIXME("%p, %p.\n", iface, mode);
 288
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI media_player_GetVideoWindow(IMFPMediaPlayer *iface, HWND *hwnd)
 293 {
 294     FIXME("%p, %p.\n", iface, hwnd);
 295
 296     return E_NOTIMPL;
 297 }
 298
 299 static HRESULT WINAPI media_player_UpdateVideo(IMFPMediaPlayer *iface)
 300 {
 301     FIXME("%p.\n", iface);
 302
 303     return E_NOTIMPL;
 304 }
 305
 306 static HRESULT WINAPI media_player_SetBorderColor(IMFPMediaPlayer *iface, COLORREF color)
 307 {
 308     FIXME("%p, %#x.\n", iface, color);
 309
 310     return E_NOTIMPL;
 311 }
 312
 313 static HRESULT WINAPI media_player_GetBorderColor(IMFPMediaPlayer *iface, COLORREF *color)
 314 {
 315     FIXME("%p, %p.\n", iface, color);
 316
 317     return E_NOTIMPL;
 318 }
 319
 320 static HRESULT WINAPI media_player_InsertEffect(IMFPMediaPlayer *iface, IUnknown *effect,
 321         BOOL optional)
 322 {
 323     FIXME("%p, %p, %d.\n", iface, effect, optional);
 324
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT WINAPI media_player_RemoveEffect(IMFPMediaPlayer *iface, IUnknown *effect)
 329 {
 330     FIXME("%p, %p.\n", iface, effect);
 331
 332     return E_NOTIMPL;
 333 }
 334
 335 static HRESULT WINAPI media_player_RemoveAllEffects(IMFPMediaPlayer *iface)
 336 {
 337     FIXME("%p.\n", iface);
 338
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT WINAPI media_player_Shutdown(IMFPMediaPlayer *iface)
 343 {
 344     FIXME("%p.\n", iface);
 345
 346     return E_NOTIMPL;
 347 }
 348
 349 static const IMFPMediaPlayerVtbl media_player_vtbl =
 350 {
 351     media_player_QueryInterface,
 352     media_player_AddRef,
 353     media_player_Release,
 354     media_player_Play,
 355     media_player_Pause,
 356     media_player_Stop,
 357     media_player_FrameStep,
 358     media_player_SetPosition,
 359     media_player_GetPosition,
 360     media_player_GetDuration,
 361     media_player_SetRate,
 362     media_player_GetRate,
 363     media_player_GetSupportedRates,
 364     media_player_GetState,
 365     media_player_CreateMediaItemFromURL,
 366     media_player_CreateMediaItemFromObject,
 367     media_player_SetMediaItem,
 368     media_player_ClearMediaItem,
 369     media_player_GetMediaItem,
 370     media_player_GetVolume,
 371     media_player_SetVolume,
 372     media_player_GetBalance,
 373     media_player_SetBalance,
 374     media_player_GetMute,
 375     media_player_SetMute,
 376     media_player_GetNativeVideoSize,
 377     media_player_GetIdealVideoSize,
 378     media_player_SetVideoSourceRect,
 379     media_player_GetVideoSourceRect,
 380     media_player_SetAspectRatioMode,
 381     media_player_GetAspectRatioMode,
 382     media_player_GetVideoWindow,
 383     media_player_UpdateVideo,
 384     media_player_SetBorderColor,
 385     media_player_GetBorderColor,
 386     media_player_InsertEffect,
 387     media_player_RemoveEffect,
 388     media_player_RemoveAllEffects,
 389     media_player_Shutdown,
 390 };
 391
 392 HRESULT WINAPI MFPCreateMediaPlayer(const WCHAR *url, BOOL start_playback, MFP_CREATION_OPTIONS options,
 393         IMFPMediaPlayerCallback *callback, HWND hwnd, IMFPMediaPlayer **player)
 394 {
 395     struct media_player *object;
 396
 397     TRACE("%s, %d, %#x, %p, %p, %p.\n", debugstr_w(url), start_playback, options, callback, hwnd, player);
 398
 399     if (!(object = heap_alloc_zero(sizeof(*object))))
 400         return E_OUTOFMEMORY;
 401
 402     object->IMFPMediaPlayer_iface.lpVtbl = &media_player_vtbl;
 403     object->refcount = 1;
 404     object->callback = callback;
 405     if (object->callback)
 406         IMFPMediaPlayerCallback_AddRef(object->callback);
 407
 408     *player = &object->IMFPMediaPlayer_iface;
 409
 410     return S_OK;
 411 }