Sweden-Number/dlls/mfmediaengine/main.c

649 lines
16 KiB
C
Raw Normal View History

/*
* Copyright 2019 Jactry Zeng for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define COBJMACROS
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "mfmediaengine.h"
#include "mferror.h"
#include "dxgi.h"
#include "wine/debug.h"
#include "wine/heap.h"
WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
{
switch (reason)
{
case DLL_WINE_PREATTACH:
return FALSE; /* prefer native version */
case DLL_PROCESS_ATTACH:
DisableThreadLibraryCalls(instance);
break;
}
return TRUE;
}
enum media_engine_mode
{
MEDIA_ENGINE_INVALID,
MEDIA_ENGINE_AUDIO_MODE,
MEDIA_ENGINE_RENDERING_MODE,
MEDIA_ENGINE_FRAME_SERVER_MODE,
};
struct media_engine
{
IMFMediaEngine IMFMediaEngine_iface;
LONG refcount;
DWORD flags;
IMFMediaEngineNotify *callback;
UINT64 playback_hwnd;
DXGI_FORMAT output_format;
IMFDXGIDeviceManager *dxgi_manager;
enum media_engine_mode mode;
};
static inline struct media_engine *impl_from_IMFMediaEngine(IMFMediaEngine *iface)
{
return CONTAINING_RECORD(iface, struct media_engine, IMFMediaEngine_iface);
}
static HRESULT WINAPI media_engine_QueryInterface(IMFMediaEngine *iface, REFIID riid, void **obj)
{
TRACE("(%p, %s, %p).\n", iface, debugstr_guid(riid), obj);
if (IsEqualIID(riid, &IID_IMFMediaEngine) ||
IsEqualIID(riid, &IID_IUnknown))
{
*obj = iface;
IMFMediaEngine_AddRef(iface);
return S_OK;
}
WARN("Unsupported interface %s.\n", debugstr_guid(riid));
*obj = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI media_engine_AddRef(IMFMediaEngine *iface)
{
struct media_engine *engine = impl_from_IMFMediaEngine(iface);
ULONG refcount = InterlockedIncrement(&engine->refcount);
TRACE("(%p) ref=%u.\n", iface, refcount);
return refcount;
}
static void free_media_engine(struct media_engine *engine)
{
if (engine->callback)
IMFMediaEngineNotify_Release(engine->callback);
if (engine->dxgi_manager)
IMFDXGIDeviceManager_Release(engine->dxgi_manager);
heap_free(engine);
}
static ULONG WINAPI media_engine_Release(IMFMediaEngine *iface)
{
struct media_engine *engine = impl_from_IMFMediaEngine(iface);
ULONG refcount = InterlockedDecrement(&engine->refcount);
TRACE("(%p) ref=%u.\n", iface, refcount);
if (!refcount)
free_media_engine(engine);
return refcount;
}
static HRESULT WINAPI media_engine_GetError(IMFMediaEngine *iface, IMFMediaError **error)
{
FIXME("(%p, %p): stub.\n", iface, error);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_SetErrorCode(IMFMediaEngine *iface, MF_MEDIA_ENGINE_ERR error)
{
FIXME("(%p, %d): stub.\n", iface, error);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_SetSourceElements(IMFMediaEngine *iface, IMFMediaEngineSrcElements *elements)
{
FIXME("(%p, %p): stub.\n", iface, elements);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_SetSource(IMFMediaEngine *iface, BSTR url)
{
FIXME("(%p, %s): stub.\n", iface, debugstr_w(url));
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_GetCurrentSource(IMFMediaEngine *iface, BSTR *url)
{
FIXME("(%p, %p): stub.\n", iface, url);
return E_NOTIMPL;
}
static USHORT WINAPI media_engine_GetNetworkState(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0;
}
static MF_MEDIA_ENGINE_PRELOAD WINAPI media_engine_GetPreload(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return MF_MEDIA_ENGINE_PRELOAD_NONE;
}
static HRESULT WINAPI media_engine_SetPreload(IMFMediaEngine *iface, MF_MEDIA_ENGINE_PRELOAD preload)
{
FIXME("(%p, %d): stub.\n", iface, preload);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_GetBuffered(IMFMediaEngine *iface, IMFMediaTimeRange **buffered)
{
FIXME("(%p, %p): stub.\n", iface, buffered);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_Load(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_CanPlayType(IMFMediaEngine *iface, BSTR type, MF_MEDIA_ENGINE_CANPLAY *answer)
{
FIXME("(%p, %s, %p): stub.\n", iface, debugstr_w(type), answer);
return E_NOTIMPL;
}
static USHORT WINAPI media_engine_GetReadyState(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0;
}
static BOOL WINAPI media_engine_IsSeeking(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static double WINAPI media_engine_GetCurrentTime(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0.0;
}
static HRESULT WINAPI media_engine_SetCurrentTime(IMFMediaEngine *iface, double time)
{
FIXME("(%p, %f): stub.\n", iface, time);
return E_NOTIMPL;
}
static double WINAPI media_engine_GetStartTime(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0.0;
}
static double WINAPI media_engine_GetDuration(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0.0;
}
static BOOL WINAPI media_engine_IsPaused(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static double WINAPI media_engine_GetDefaultPlaybackRate(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0.0;
}
static HRESULT WINAPI media_engine_SetDefaultPlaybackRate(IMFMediaEngine *iface, double rate)
{
FIXME("(%p, %f): stub.\n", iface, rate);
return E_NOTIMPL;
}
static double WINAPI media_engine_GetPlaybackRate(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0.0;
}
static HRESULT WINAPI media_engine_SetPlaybackRate(IMFMediaEngine *iface, double rate)
{
FIXME("(%p, %f): stub.\n", iface, rate);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_GetPlayed(IMFMediaEngine *iface, IMFMediaTimeRange **played)
{
FIXME("(%p, %p): stub.\n", iface, played);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_GetSeekable(IMFMediaEngine *iface, IMFMediaTimeRange **seekable)
{
FIXME("(%p, %p): stub.\n", iface, seekable);
return E_NOTIMPL;
}
static BOOL WINAPI media_engine_IsEnded(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static BOOL WINAPI media_engine_GetAutoPlay(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static HRESULT WINAPI media_engine_SetAutoPlay(IMFMediaEngine *iface, BOOL autoplay)
{
FIXME("(%p, %d): stub.\n", iface, autoplay);
return E_NOTIMPL;
}
static BOOL WINAPI media_engine_GetLoop(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static HRESULT WINAPI media_engine_SetLoop(IMFMediaEngine *iface, BOOL loop)
{
FIXME("(%p, %d): stub.\n", iface, loop);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_Play(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_Pause(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return E_NOTIMPL;
}
static BOOL WINAPI media_engine_GetMuted(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static HRESULT WINAPI media_engine_SetMuted(IMFMediaEngine *iface, BOOL muted)
{
FIXME("(%p, %d): stub.\n", iface, muted);
return E_NOTIMPL;
}
static double WINAPI media_engine_GetVolume(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return 0.0;
}
static HRESULT WINAPI media_engine_SetVolume(IMFMediaEngine *iface, double volume)
{
FIXME("(%p, %f): stub.\n", iface, volume);
return E_NOTIMPL;
}
static BOOL WINAPI media_engine_HasVideo(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static BOOL WINAPI media_engine_HasAudio(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return FALSE;
}
static HRESULT WINAPI media_engine_GetNativeVideoSize(IMFMediaEngine *iface, DWORD *cx, DWORD *cy)
{
FIXME("(%p, %p, %p): stub.\n", iface, cx, cy);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_GetVideoAspectRatio(IMFMediaEngine *iface, DWORD *cx, DWORD *cy)
{
FIXME("(%p, %p, %p): stub.\n", iface, cx, cy);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_Shutdown(IMFMediaEngine *iface)
{
FIXME("(%p): stub.\n", iface);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_TransferVideoFrame(IMFMediaEngine *iface, IUnknown *surface,
const MFVideoNormalizedRect *src,
const RECT *dst, const MFARGB *color)
{
FIXME("(%p, %p, %p, %p, %p): stub.\n", iface, surface, src, dst, color);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_OnVideoStreamTick(IMFMediaEngine *iface, LONGLONG *time)
{
FIXME("(%p, %p): stub.\n", iface, time);
return E_NOTIMPL;
}
static const IMFMediaEngineVtbl media_engine_vtbl =
{
media_engine_QueryInterface,
media_engine_AddRef,
media_engine_Release,
media_engine_GetError,
media_engine_SetErrorCode,
media_engine_SetSourceElements,
media_engine_SetSource,
media_engine_GetCurrentSource,
media_engine_GetNetworkState,
media_engine_GetPreload,
media_engine_SetPreload,
media_engine_GetBuffered,
media_engine_Load,
media_engine_CanPlayType,
media_engine_GetReadyState,
media_engine_IsSeeking,
media_engine_GetCurrentTime,
media_engine_SetCurrentTime,
media_engine_GetStartTime,
media_engine_GetDuration,
media_engine_IsPaused,
media_engine_GetDefaultPlaybackRate,
media_engine_SetDefaultPlaybackRate,
media_engine_GetPlaybackRate,
media_engine_SetPlaybackRate,
media_engine_GetPlayed,
media_engine_GetSeekable,
media_engine_IsEnded,
media_engine_GetAutoPlay,
media_engine_SetAutoPlay,
media_engine_GetLoop,
media_engine_SetLoop,
media_engine_Play,
media_engine_Pause,
media_engine_GetMuted,
media_engine_SetMuted,
media_engine_GetVolume,
media_engine_SetVolume,
media_engine_HasVideo,
media_engine_HasAudio,
media_engine_GetNativeVideoSize,
media_engine_GetVideoAspectRatio,
media_engine_Shutdown,
media_engine_TransferVideoFrame,
media_engine_OnVideoStreamTick,
};
static HRESULT WINAPI media_engine_factory_QueryInterface(IMFMediaEngineClassFactory *iface, REFIID riid, void **obj)
{
if (IsEqualIID(riid, &IID_IMFMediaEngineClassFactory) ||
IsEqualIID(riid, &IID_IUnknown))
{
*obj = iface;
IMFMediaEngineClassFactory_AddRef(iface);
return S_OK;
}
WARN("Unsupported interface %s.\n", debugstr_guid(riid));
*obj = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI media_engine_factory_AddRef(IMFMediaEngineClassFactory *iface)
{
return 2;
}
static ULONG WINAPI media_engine_factory_Release(IMFMediaEngineClassFactory *iface)
{
return 1;
}
static HRESULT init_media_engine(IMFAttributes *attributes, struct media_engine *engine)
{
HRESULT hr;
hr = IMFAttributes_GetUnknown(attributes, &MF_MEDIA_ENGINE_CALLBACK, &IID_IMFMediaEngineNotify,
(void **)&engine->callback);
if (FAILED(hr))
return MF_E_ATTRIBUTENOTFOUND;
IMFAttributes_GetUINT64(attributes, &MF_MEDIA_ENGINE_PLAYBACK_HWND, &engine->playback_hwnd);
IMFAttributes_GetUnknown(attributes, &MF_MEDIA_ENGINE_DXGI_MANAGER, &IID_IMFDXGIDeviceManager,
(void **)&engine->dxgi_manager);
hr = IMFAttributes_GetUINT32(attributes, &MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, &engine->output_format);
if (engine->playback_hwnd) /* FIXME: handle MF_MEDIA_ENGINE_PLAYBACK_VISUAL */
engine->mode = MEDIA_ENGINE_RENDERING_MODE;
else
{
if (SUCCEEDED(hr))
engine->mode = MEDIA_ENGINE_FRAME_SERVER_MODE;
else
engine->mode = MEDIA_ENGINE_AUDIO_MODE;
}
return S_OK;
}
static HRESULT WINAPI media_engine_factory_CreateInstance(IMFMediaEngineClassFactory *iface, DWORD flags,
IMFAttributes *attributes, IMFMediaEngine **engine)
{
struct media_engine *object;
HRESULT hr;
TRACE("(%p, %#x, %p, %p).\n", iface, flags, attributes, engine);
if (!attributes || !engine)
return E_POINTER;
object = heap_alloc_zero(sizeof(*object));
if (!object)
return E_OUTOFMEMORY;
hr = init_media_engine(attributes, object);
if (FAILED(hr))
{
free_media_engine(object);
return hr;
}
object->IMFMediaEngine_iface.lpVtbl = &media_engine_vtbl;
object->refcount = 1;
object->flags = flags;
*engine = &object->IMFMediaEngine_iface;
return S_OK;
}
static HRESULT WINAPI media_engine_factory_CreateTimeRange(IMFMediaEngineClassFactory *iface,
IMFMediaTimeRange **range)
{
FIXME("(%p, %p): stub.\n", iface, range);
return E_NOTIMPL;
}
static HRESULT WINAPI media_engine_factory_CreateError(IMFMediaEngineClassFactory *iface, IMFMediaError **error)
{
FIXME("(%p, %p): stub.\n", iface, error);
return E_NOTIMPL;
}
static const IMFMediaEngineClassFactoryVtbl media_engine_factory_vtbl =
{
media_engine_factory_QueryInterface,
media_engine_factory_AddRef,
media_engine_factory_Release,
media_engine_factory_CreateInstance,
media_engine_factory_CreateTimeRange,
media_engine_factory_CreateError,
};
static IMFMediaEngineClassFactory media_engine_factory = { &media_engine_factory_vtbl };
static HRESULT WINAPI classfactory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
{
TRACE("(%s, %p).\n", debugstr_guid(riid), obj);
if (IsEqualGUID(riid, &IID_IClassFactory) ||
IsEqualGUID(riid, &IID_IUnknown))
{
IClassFactory_AddRef(iface);
*obj = iface;
return S_OK;
}
WARN("interface %s not implemented.\n", debugstr_guid(riid));
*obj = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI classfactory_AddRef(IClassFactory *iface)
{
return 2;
}
static ULONG WINAPI classfactory_Release(IClassFactory *iface)
{
return 1;
}
static HRESULT WINAPI classfactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
{
TRACE("(%p, %s, %p).\n", outer, debugstr_guid(riid), obj);
*obj = NULL;
if (outer)
return CLASS_E_NOAGGREGATION;
return IMFMediaEngineClassFactory_QueryInterface(&media_engine_factory, riid, obj);
}
static HRESULT WINAPI classfactory_LockServer(IClassFactory *iface, BOOL dolock)
{
FIXME("(%d): stub.\n", dolock);
return S_OK;
}
static const struct IClassFactoryVtbl class_factory_vtbl =
{
classfactory_QueryInterface,
classfactory_AddRef,
classfactory_Release,
classfactory_CreateInstance,
classfactory_LockServer,
};
static IClassFactory classfactory = { &class_factory_vtbl };
HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **obj)
{
TRACE("(%s, %s, %p).\n", debugstr_guid(clsid), debugstr_guid(riid), obj);
if (IsEqualGUID(clsid, &CLSID_MFMediaEngineClassFactory))
return IClassFactory_QueryInterface(&classfactory, riid, obj);
WARN("Unsupported class %s.\n", debugstr_guid(clsid));
*obj = NULL;
return CLASS_E_CLASSNOTAVAILABLE;
}
HRESULT WINAPI DllCanUnloadNow(void)
{
return S_FALSE;
}