dlls/evr/presenter.c

   1 /*
   2  * Copyright 2020 Nikolay Sivov
   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 "evr.h"
  22 #include "d3d9.h"
  23 #include "mfapi.h"
  24 #include "mferror.h"
  25
  26 #include "evr_classes.h"
  27 #include "evr_private.h"
  28
  29 #include "wine/debug.h"
  30 #include "wine/heap.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(evr);
  33
  34 struct video_presenter
  35 {
  36     IMFVideoPresenter IMFVideoPresenter_iface;
  37     IMFVideoDeviceID IMFVideoDeviceID_iface;
  38     IMFTopologyServiceLookupClient IMFTopologyServiceLookupClient_iface;
  39     IMFVideoDisplayControl IMFVideoDisplayControl_iface;
  40     IMFRateSupport IMFRateSupport_iface;
  41     IUnknown IUnknown_inner;
  42     IUnknown *outer_unk;
  43     LONG refcount;
  44 };
  45
  46 static struct video_presenter *impl_from_IUnknown(IUnknown *iface)
  47 {
  48     return CONTAINING_RECORD(iface, struct video_presenter, IUnknown_inner);
  49 }
  50
  51 static struct video_presenter *impl_from_IMFVideoPresenter(IMFVideoPresenter *iface)
  52 {
  53     return CONTAINING_RECORD(iface, struct video_presenter, IMFVideoPresenter_iface);
  54 }
  55
  56 static struct video_presenter *impl_from_IMFVideoDeviceID(IMFVideoDeviceID *iface)
  57 {
  58     return CONTAINING_RECORD(iface, struct video_presenter, IMFVideoDeviceID_iface);
  59 }
  60
  61 static struct video_presenter *impl_from_IMFTopologyServiceLookupClient(IMFTopologyServiceLookupClient *iface)
  62 {
  63     return CONTAINING_RECORD(iface, struct video_presenter, IMFTopologyServiceLookupClient_iface);
  64 }
  65
  66 static struct video_presenter *impl_from_IMFVideoDisplayControl(IMFVideoDisplayControl *iface)
  67 {
  68     return CONTAINING_RECORD(iface, struct video_presenter, IMFVideoDisplayControl_iface);
  69 }
  70
  71 static struct video_presenter *impl_from_IMFRateSupport(IMFRateSupport *iface)
  72 {
  73     return CONTAINING_RECORD(iface, struct video_presenter, IMFRateSupport_iface);
  74 }
  75
  76 static HRESULT WINAPI video_presenter_inner_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
  77 {
  78     struct video_presenter *presenter = impl_from_IUnknown(iface);
  79
  80     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  81
  82     if (IsEqualIID(riid, &IID_IUnknown))
  83     {
  84         *obj = iface;
  85     }
  86     else if (IsEqualIID(riid, &IID_IMFClockStateSink)
  87             || IsEqualIID(riid, &IID_IMFVideoPresenter))
  88     {
  89         *obj = &presenter->IMFVideoPresenter_iface;
  90     }
  91     else if (IsEqualIID(riid, &IID_IMFVideoDeviceID))
  92     {
  93         *obj = &presenter->IMFVideoDeviceID_iface;
  94     }
  95     else if (IsEqualIID(riid, &IID_IMFTopologyServiceLookupClient))
  96     {
  97         *obj = &presenter->IMFTopologyServiceLookupClient_iface;
  98     }
  99     else if (IsEqualIID(riid, &IID_IMFVideoDisplayControl))
 100     {
 101         *obj = &presenter->IMFVideoDisplayControl_iface;
 102     }
 103     else if (IsEqualIID(riid, &IID_IMFRateSupport))
 104     {
 105         *obj = &presenter->IMFRateSupport_iface;
 106     }
 107     else
 108     {
 109         WARN("Unimplemented interface %s.\n", debugstr_guid(riid));
 110         *obj = NULL;
 111         return E_NOINTERFACE;
 112     }
 113
 114     IUnknown_AddRef((IUnknown *)*obj);
 115     return S_OK;
 116 }
 117
 118 static ULONG WINAPI video_presenter_inner_AddRef(IUnknown *iface)
 119 {
 120     struct video_presenter *presenter = impl_from_IUnknown(iface);
 121     ULONG refcount = InterlockedIncrement(&presenter->refcount);
 122
 123     TRACE("%p, refcount %u.\n", iface, refcount);
 124
 125     return refcount;
 126 }
 127
 128 static ULONG WINAPI video_presenter_inner_Release(IUnknown *iface)
 129 {
 130     struct video_presenter *presenter = impl_from_IUnknown(iface);
 131     ULONG refcount = InterlockedDecrement(&presenter->refcount);
 132
 133     TRACE("%p, refcount %u.\n", iface, refcount);
 134
 135     if (!refcount)
 136     {
 137         heap_free(presenter);
 138     }
 139
 140     return refcount;
 141 }
 142
 143 static const IUnknownVtbl video_presenter_inner_vtbl =
 144 {
 145     video_presenter_inner_QueryInterface,
 146     video_presenter_inner_AddRef,
 147     video_presenter_inner_Release,
 148 };
 149
 150 static HRESULT WINAPI video_presenter_QueryInterface(IMFVideoPresenter *iface, REFIID riid, void **obj)
 151 {
 152     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 153     return IUnknown_QueryInterface(presenter->outer_unk, riid, obj);
 154 }
 155
 156 static ULONG WINAPI video_presenter_AddRef(IMFVideoPresenter *iface)
 157 {
 158     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 159     return IUnknown_AddRef(presenter->outer_unk);
 160 }
 161
 162 static ULONG WINAPI video_presenter_Release(IMFVideoPresenter *iface)
 163 {
 164     struct video_presenter *presenter = impl_from_IMFVideoPresenter(iface);
 165     return IUnknown_Release(presenter->outer_unk);
 166 }
 167
 168 static HRESULT WINAPI video_presenter_OnClockStart(IMFVideoPresenter *iface, MFTIME systime, LONGLONG offset)
 169 {
 170     FIXME("%p, %s, %s.\n", iface, debugstr_time(systime), wine_dbgstr_longlong(offset));
 171
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI video_presenter_OnClockStop(IMFVideoPresenter *iface, MFTIME systime)
 176 {
 177     FIXME("%p, %s.\n", iface, debugstr_time(systime));
 178
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI video_presenter_OnClockPause(IMFVideoPresenter *iface, MFTIME systime)
 183 {
 184     FIXME("%p, %s.\n", iface, debugstr_time(systime));
 185
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI video_presenter_OnClockRestart(IMFVideoPresenter *iface, MFTIME systime)
 190 {
 191     FIXME("%p, %s.\n", iface, debugstr_time(systime));
 192
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI video_presenter_OnClockSetRate(IMFVideoPresenter *iface, MFTIME systime, float rate)
 197 {
 198     FIXME("%p, %s, %f.\n", iface, debugstr_time(systime), rate);
 199
 200     return E_NOTIMPL;
 201 }
 202
 203 static HRESULT WINAPI video_presenter_ProcessMessage(IMFVideoPresenter *iface, MFVP_MESSAGE_TYPE message, ULONG_PTR param)
 204 {
 205     FIXME("%p, %d, %lu.\n", iface, message, param);
 206
 207     return E_NOTIMPL;
 208 }
 209
 210 static HRESULT WINAPI video_presenter_GetCurrentMediaType(IMFVideoPresenter *iface, IMFVideoMediaType **media_type)
 211 {
 212     FIXME("%p, %p.\n", iface, media_type);
 213
 214     return E_NOTIMPL;
 215 }
 216
 217 static const IMFVideoPresenterVtbl video_presenter_vtbl =
 218 {
 219     video_presenter_QueryInterface,
 220     video_presenter_AddRef,
 221     video_presenter_Release,
 222     video_presenter_OnClockStart,
 223     video_presenter_OnClockStop,
 224     video_presenter_OnClockPause,
 225     video_presenter_OnClockRestart,
 226     video_presenter_OnClockSetRate,
 227     video_presenter_ProcessMessage,
 228     video_presenter_GetCurrentMediaType,
 229 };
 230
 231 static HRESULT WINAPI video_presenter_device_id_QueryInterface(IMFVideoDeviceID *iface, REFIID riid, void **obj)
 232 {
 233     struct video_presenter *presenter = impl_from_IMFVideoDeviceID(iface);
 234     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
 235 }
 236
 237 static ULONG WINAPI video_presenter_device_id_AddRef(IMFVideoDeviceID *iface)
 238 {
 239     struct video_presenter *presenter = impl_from_IMFVideoDeviceID(iface);
 240     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
 241 }
 242
 243 static ULONG WINAPI video_presenter_device_id_Release(IMFVideoDeviceID *iface)
 244 {
 245     struct video_presenter *presenter = impl_from_IMFVideoDeviceID(iface);
 246     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
 247 }
 248
 249 static HRESULT WINAPI video_presenter_device_id_GetDeviceID(IMFVideoDeviceID *iface, IID *device_id)
 250 {
 251     TRACE("%p, %p.\n", iface, device_id);
 252
 253     if (!device_id)
 254         return E_POINTER;
 255
 256     memcpy(device_id, &IID_IDirect3DDevice9, sizeof(*device_id));
 257
 258     return S_OK;
 259 }
 260
 261 static const IMFVideoDeviceIDVtbl video_presenter_device_id_vtbl =
 262 {
 263     video_presenter_device_id_QueryInterface,
 264     video_presenter_device_id_AddRef,
 265     video_presenter_device_id_Release,
 266     video_presenter_device_id_GetDeviceID,
 267 };
 268
 269 static HRESULT WINAPI video_presenter_service_client_QueryInterface(IMFTopologyServiceLookupClient *iface,
 270         REFIID riid, void **obj)
 271 {
 272     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
 273     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
 274 }
 275
 276 static ULONG WINAPI video_presenter_service_client_AddRef(IMFTopologyServiceLookupClient *iface)
 277 {
 278     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
 279     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
 280 }
 281
 282 static ULONG WINAPI video_presenter_service_client_Release(IMFTopologyServiceLookupClient *iface)
 283 {
 284     struct video_presenter *presenter = impl_from_IMFTopologyServiceLookupClient(iface);
 285     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
 286 }
 287
 288 static HRESULT WINAPI video_presenter_service_client_InitServicePointers(IMFTopologyServiceLookupClient *iface,
 289         IMFTopologyServiceLookup *service_lookup)
 290 {
 291     FIXME("%p, %p.\n", iface, service_lookup);
 292
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI video_presenter_service_client_ReleaseServicePointers(IMFTopologyServiceLookupClient *iface)
 297 {
 298     FIXME("%p.\n", iface);
 299
 300     return E_NOTIMPL;
 301 }
 302
 303 static const IMFTopologyServiceLookupClientVtbl video_presenter_service_client_vtbl =
 304 {
 305     video_presenter_service_client_QueryInterface,
 306     video_presenter_service_client_AddRef,
 307     video_presenter_service_client_Release,
 308     video_presenter_service_client_InitServicePointers,
 309     video_presenter_service_client_ReleaseServicePointers,
 310 };
 311
 312 static HRESULT WINAPI video_presenter_control_QueryInterface(IMFVideoDisplayControl *iface, REFIID riid, void **obj)
 313 {
 314     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
 315     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
 316 }
 317
 318 static ULONG WINAPI video_presenter_control_AddRef(IMFVideoDisplayControl *iface)
 319 {
 320     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
 321     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
 322 }
 323
 324 static ULONG WINAPI video_presenter_control_Release(IMFVideoDisplayControl *iface)
 325 {
 326     struct video_presenter *presenter = impl_from_IMFVideoDisplayControl(iface);
 327     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
 328 }
 329
 330 static HRESULT WINAPI video_presenter_control_GetNativeVideoSize(IMFVideoDisplayControl *iface, SIZE *video_size,
 331         SIZE *aspect_ratio)
 332 {
 333     FIXME("%p, %p, %p.\n", iface, video_size, aspect_ratio);
 334
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI video_presenter_control_GetIdealVideoSize(IMFVideoDisplayControl *iface, SIZE *min_size,
 339         SIZE *max_size)
 340 {
 341     FIXME("%p, %p, %p.\n", iface, min_size, max_size);
 342
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI video_presenter_control_SetVideoPosition(IMFVideoDisplayControl *iface,
 347         const MFVideoNormalizedRect *source, const RECT *dest)
 348 {
 349     FIXME("%p, %p, %p.\n", iface, source, dest);
 350
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI video_presenter_control_GetVideoPosition(IMFVideoDisplayControl *iface, MFVideoNormalizedRect *source,
 355         RECT *dest)
 356 {
 357     FIXME("%p, %p, %p.\n", iface, source, dest);
 358
 359     return E_NOTIMPL;
 360 }
 361
 362 static HRESULT WINAPI video_presenter_control_SetAspectRatioMode(IMFVideoDisplayControl *iface, DWORD mode)
 363 {
 364     FIXME("%p, %d.\n", iface, mode);
 365
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT WINAPI video_presenter_control_GetAspectRatioMode(IMFVideoDisplayControl *iface, DWORD *mode)
 370 {
 371     FIXME("%p, %p.\n", iface, mode);
 372
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI video_presenter_control_SetVideoWindow(IMFVideoDisplayControl *iface, HWND window)
 377 {
 378     FIXME("%p, %p.\n", iface, window);
 379
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI video_presenter_control_GetVideoWindow(IMFVideoDisplayControl *iface, HWND *window)
 384 {
 385     FIXME("%p, %p.\n", iface, window);
 386
 387     return E_NOTIMPL;
 388 }
 389
 390 static HRESULT WINAPI video_presenter_control_RepaintVideo(IMFVideoDisplayControl *iface)
 391 {
 392     FIXME("%p.\n", iface);
 393
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI video_presenter_control_GetCurrentImage(IMFVideoDisplayControl *iface, BITMAPINFOHEADER *header,
 398         BYTE **dib, DWORD *dib_size, LONGLONG *timestamp)
 399 {
 400     FIXME("%p, %p, %p, %p, %p.\n", iface, header, dib, dib_size, timestamp);
 401
 402     return E_NOTIMPL;
 403 }
 404
 405 static const IMFVideoDisplayControlVtbl video_presenter_control_vtbl =
 406 {
 407     video_presenter_control_QueryInterface,
 408     video_presenter_control_AddRef,
 409     video_presenter_control_Release,
 410     video_presenter_control_GetNativeVideoSize,
 411     video_presenter_control_GetIdealVideoSize,
 412     video_presenter_control_SetVideoPosition,
 413     video_presenter_control_GetVideoPosition,
 414     video_presenter_control_SetAspectRatioMode,
 415     video_presenter_control_GetAspectRatioMode,
 416     video_presenter_control_SetVideoWindow,
 417     video_presenter_control_GetVideoWindow,
 418     video_presenter_control_RepaintVideo,
 419     video_presenter_control_GetCurrentImage,
 420 };
 421
 422 static HRESULT WINAPI video_presenter_rate_support_QueryInterface(IMFRateSupport *iface, REFIID riid, void **obj)
 423 {
 424     struct video_presenter *presenter = impl_from_IMFRateSupport(iface);
 425     return IMFVideoPresenter_QueryInterface(&presenter->IMFVideoPresenter_iface, riid, obj);
 426 }
 427
 428 static ULONG WINAPI video_presenter_rate_support_AddRef(IMFRateSupport *iface)
 429 {
 430     struct video_presenter *presenter = impl_from_IMFRateSupport(iface);
 431     return IMFVideoPresenter_AddRef(&presenter->IMFVideoPresenter_iface);
 432 }
 433
 434 static ULONG WINAPI video_presenter_rate_support_Release(IMFRateSupport *iface)
 435 {
 436     struct video_presenter *presenter = impl_from_IMFRateSupport(iface);
 437     return IMFVideoPresenter_Release(&presenter->IMFVideoPresenter_iface);
 438 }
 439
 440 static HRESULT WINAPI video_presenter_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
 441         BOOL thin, float *rate)
 442 {
 443     TRACE("%p, %d, %d, %p.\n", iface, direction, thin, rate);
 444
 445     *rate = 0.0f;
 446
 447     return S_OK;
 448 }
 449
 450 static HRESULT WINAPI video_presenter_rate_support_GetFastestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction,
 451         BOOL thin, float *rate)
 452 {
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI video_presenter_rate_support_IsRateSupported(IMFRateSupport *iface, BOOL thin, float rate,
 457         float *nearest_supported_rate)
 458 {
 459     return E_NOTIMPL;
 460 }
 461
 462 static const IMFRateSupportVtbl video_presenter_rate_support_vtbl =
 463 {
 464     video_presenter_rate_support_QueryInterface,
 465     video_presenter_rate_support_AddRef,
 466     video_presenter_rate_support_Release,
 467     video_presenter_rate_support_GetSlowestRate,
 468     video_presenter_rate_support_GetFastestRate,
 469     video_presenter_rate_support_IsRateSupported,
 470 };
 471
 472 HRESULT WINAPI MFCreateVideoPresenter(IUnknown *owner, REFIID riid_device, REFIID riid, void **obj)
 473 {
 474     TRACE("%p, %s, %s, %p.\n", owner, debugstr_guid(riid_device), debugstr_guid(riid), obj);
 475
 476     *obj = NULL;
 477
 478     if (!IsEqualIID(riid_device, &IID_IDirect3DDevice9))
 479         return E_INVALIDARG;
 480
 481     return CoCreateInstance(&CLSID_MFVideoPresenter9, owner, CLSCTX_INPROC_SERVER, riid, obj);
 482 }
 483
 484 HRESULT evr_presenter_create(IUnknown *outer, void **out)
 485 {
 486     struct video_presenter *object;
 487
 488     if (!(object = heap_alloc(sizeof(*object))))
 489         return E_OUTOFMEMORY;
 490
 491     object->IMFVideoPresenter_iface.lpVtbl = &video_presenter_vtbl;
 492     object->IMFVideoDeviceID_iface.lpVtbl = &video_presenter_device_id_vtbl;
 493     object->IMFTopologyServiceLookupClient_iface.lpVtbl = &video_presenter_service_client_vtbl;
 494     object->IMFVideoDisplayControl_iface.lpVtbl = &video_presenter_control_vtbl;
 495     object->IMFRateSupport_iface.lpVtbl = &video_presenter_rate_support_vtbl;
 496     object->IUnknown_inner.lpVtbl = &video_presenter_inner_vtbl;
 497     object->outer_unk = outer ? outer : &object->IUnknown_inner;
 498     object->refcount = 1;
 499
 500     *out = &object->IUnknown_inner;
 501
 502     return S_OK;
 503 }