719 lines
28 KiB
C++
719 lines
28 KiB
C++
/* ****************************************************************************** *\
|
|
|
|
Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
- Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
- Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
- Neither the name of Intel Corporation nor the names of its contributors
|
|
may be used to endorse or promote products derived from this software
|
|
without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
File Name: mfxplugin++.h
|
|
|
|
\* ****************************************************************************** */
|
|
|
|
#ifndef __MFXPLUGINPLUSPLUS_H
|
|
#define __MFXPLUGINPLUSPLUS_H
|
|
|
|
#include "mfxplugin.h"
|
|
|
|
// base class for MFXVideoUSER/MFXAudioUSER API
|
|
|
|
class MFXBaseUSER {
|
|
public:
|
|
explicit MFXBaseUSER(mfxSession session = NULL)
|
|
: m_session(session){}
|
|
|
|
virtual ~MFXBaseUSER() {};
|
|
|
|
virtual mfxStatus Register(mfxU32 type, const mfxPlugin *par) = 0;
|
|
virtual mfxStatus Unregister(mfxU32 type) = 0;
|
|
virtual mfxStatus ProcessFrameAsync(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp) = 0;
|
|
|
|
protected:
|
|
mfxSession m_session;
|
|
};
|
|
|
|
//c++ wrapper over only 3 exposed functions from MFXVideoUSER module
|
|
class MFXVideoUSER: public MFXBaseUSER {
|
|
public:
|
|
explicit MFXVideoUSER(mfxSession session = NULL)
|
|
: MFXBaseUSER(session){}
|
|
|
|
virtual mfxStatus Register(mfxU32 type, const mfxPlugin *par) {
|
|
return MFXVideoUSER_Register(m_session, type, par);
|
|
}
|
|
virtual mfxStatus Unregister(mfxU32 type) {
|
|
return MFXVideoUSER_Unregister(m_session, type);
|
|
}
|
|
virtual mfxStatus ProcessFrameAsync(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp) {
|
|
return MFXVideoUSER_ProcessFrameAsync(m_session, in, in_num, out, out_num, syncp);
|
|
}
|
|
};
|
|
|
|
//c++ wrapper over only 3 exposed functions from MFXAudioUSER module
|
|
class MFXAudioUSER: public MFXBaseUSER {
|
|
public:
|
|
explicit MFXAudioUSER(mfxSession session = NULL)
|
|
: MFXBaseUSER(session){}
|
|
|
|
virtual mfxStatus Register(mfxU32 type, const mfxPlugin *par) {
|
|
return MFXAudioUSER_Register(m_session, type, par);
|
|
}
|
|
virtual mfxStatus Unregister(mfxU32 type) {
|
|
return MFXAudioUSER_Unregister(m_session, type);
|
|
}
|
|
virtual mfxStatus ProcessFrameAsync(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp) {
|
|
return MFXAudioUSER_ProcessFrameAsync(m_session, in, in_num, out, out_num, syncp);
|
|
}
|
|
};
|
|
|
|
|
|
//initialize mfxPlugin struct
|
|
class MFXPluginParam {
|
|
mfxPluginParam m_param;
|
|
|
|
public:
|
|
MFXPluginParam(mfxU32 CodecId, mfxU32 Type, mfxPluginUID uid, mfxThreadPolicy ThreadPolicy = MFX_THREADPOLICY_SERIAL, mfxU32 MaxThreadNum = 1)
|
|
: m_param() {
|
|
m_param.PluginUID = uid;
|
|
m_param.Type = Type;
|
|
m_param.CodecId = CodecId;
|
|
m_param.MaxThreadNum = MaxThreadNum;
|
|
m_param.ThreadPolicy = ThreadPolicy;
|
|
}
|
|
operator const mfxPluginParam& () const {
|
|
return m_param;
|
|
}
|
|
operator mfxPluginParam& () {
|
|
return m_param;
|
|
}
|
|
};
|
|
|
|
//common interface part for every plugin: decoder/encoder and generic
|
|
struct MFXPlugin
|
|
{
|
|
virtual ~MFXPlugin() {};
|
|
//init function always required for any transform or codec plugins, for codec plugins it maps to callback from MediaSDK
|
|
//for generic plugin application should call it
|
|
//MediaSDK mfxPlugin API mapping
|
|
virtual mfxStatus PluginInit(mfxCoreInterface *core) = 0;
|
|
//release CoreInterface, and destroy plugin state, not destroy plugin instance
|
|
virtual mfxStatus PluginClose() = 0;
|
|
virtual mfxStatus GetPluginParam(mfxPluginParam *par) = 0;
|
|
virtual mfxStatus Execute(mfxThreadTask task, mfxU32 uid_p, mfxU32 uid_a) = 0;
|
|
virtual mfxStatus FreeResources(mfxThreadTask task, mfxStatus sts) = 0;
|
|
//destroy plugin due to shared module distribution model plugin wont support virtual destructor
|
|
virtual void Release() = 0;
|
|
//release resources associated with current instance of plugin, but do not release CoreInterface related resource set in pluginInit
|
|
virtual mfxStatus Close() = 0;
|
|
//communication protocol between particular version of plugin and application
|
|
virtual mfxStatus SetAuxParams(void* auxParam, int auxParamSize) = 0;
|
|
};
|
|
|
|
//common extension interface that codec plugins should expose additionally to MFXPlugin
|
|
struct MFXCodecPlugin : MFXPlugin
|
|
{
|
|
virtual mfxStatus Init(mfxVideoParam *par) = 0;
|
|
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out) = 0;
|
|
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) =0;
|
|
virtual mfxStatus Reset(mfxVideoParam *par) = 0;
|
|
virtual mfxStatus GetVideoParam(mfxVideoParam *par) = 0;
|
|
};
|
|
|
|
//common extension interface that audio codec plugins should expose additionally to MFXPlugin
|
|
struct MFXAudioCodecPlugin : MFXPlugin
|
|
{
|
|
virtual mfxStatus Init(mfxAudioParam *par) = 0;
|
|
virtual mfxStatus Query(mfxAudioParam *in, mfxAudioParam *out) =0;
|
|
virtual mfxStatus QueryIOSize(mfxAudioParam *par, mfxAudioAllocRequest *request) = 0;
|
|
virtual mfxStatus Reset(mfxAudioParam *par) = 0;
|
|
virtual mfxStatus GetAudioParam(mfxAudioParam *par) = 0;
|
|
};
|
|
|
|
//general purpose transform plugin interface, not a codec plugin
|
|
struct MFXGenericPlugin : MFXPlugin
|
|
{
|
|
virtual mfxStatus Init(mfxVideoParam *par) = 0;
|
|
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out) = 0;
|
|
virtual mfxStatus Submit(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task) = 0;
|
|
};
|
|
|
|
//decoder plugins may only support this interface
|
|
struct MFXDecoderPlugin : MFXCodecPlugin
|
|
{
|
|
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxVideoParam *par) = 0;
|
|
virtual mfxStatus GetPayload(mfxU64 *ts, mfxPayload *payload) = 0;
|
|
virtual mfxStatus DecodeFrameSubmit(mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) = 0;
|
|
};
|
|
|
|
//audio decoder plugins may only support this interface
|
|
struct MFXAudioDecoderPlugin : MFXAudioCodecPlugin
|
|
{
|
|
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxAudioParam *par) = 0;
|
|
// virtual mfxStatus GetPayload(mfxU64 *ts, mfxPayload *payload) = 0;
|
|
virtual mfxStatus DecodeFrameSubmit(mfxBitstream *in, mfxAudioFrame *out, mfxThreadTask *task) = 0;
|
|
};
|
|
|
|
//encoder plugins may only support this interface
|
|
struct MFXEncoderPlugin : MFXCodecPlugin
|
|
{
|
|
virtual mfxStatus EncodeFrameSubmit(mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxThreadTask *task) = 0;
|
|
};
|
|
|
|
//audio encoder plugins may only support this interface
|
|
struct MFXAudioEncoderPlugin : MFXAudioCodecPlugin
|
|
{
|
|
virtual mfxStatus EncodeFrameSubmit(mfxAudioFrame *aFrame, mfxBitstream *out, mfxThreadTask *task) = 0;
|
|
};
|
|
|
|
//vpp plugins may only support this interface
|
|
struct MFXVPPPlugin : MFXCodecPlugin
|
|
{
|
|
virtual mfxStatus VPPFrameSubmit(mfxFrameSurface1 *surface_in, mfxFrameSurface1 *surface_out, mfxExtVppAuxData *aux, mfxThreadTask *task) = 0;
|
|
virtual mfxStatus VPPFrameSubmitEx(mfxFrameSurface1 *in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) = 0;
|
|
};
|
|
|
|
struct MFXEncPlugin : MFXCodecPlugin
|
|
{
|
|
virtual mfxStatus EncFrameSubmit(mfxENCInput *in, mfxENCOutput *out, mfxThreadTask *task) = 0;
|
|
};
|
|
|
|
|
|
|
|
|
|
class MFXCoreInterface
|
|
{
|
|
protected:
|
|
mfxCoreInterface m_core;
|
|
public:
|
|
|
|
MFXCoreInterface()
|
|
: m_core() {
|
|
}
|
|
MFXCoreInterface(const mfxCoreInterface & pCore)
|
|
: m_core(pCore) {
|
|
}
|
|
|
|
MFXCoreInterface(const MFXCoreInterface & that)
|
|
: m_core(that.m_core) {
|
|
}
|
|
MFXCoreInterface &operator = (const MFXCoreInterface & that)
|
|
{
|
|
m_core = that.m_core;
|
|
return *this;
|
|
}
|
|
bool IsCoreSet() {
|
|
return m_core.pthis != 0;
|
|
}
|
|
mfxStatus GetCoreParam(mfxCoreParam *par) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.GetCoreParam(m_core.pthis, par);
|
|
}
|
|
mfxStatus GetHandle (mfxHandleType type, mfxHDL *handle) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.GetHandle(m_core.pthis, type, handle);
|
|
}
|
|
mfxStatus IncreaseReference (mfxFrameData *fd) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.IncreaseReference(m_core.pthis, fd);
|
|
}
|
|
mfxStatus DecreaseReference (mfxFrameData *fd) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.DecreaseReference(m_core.pthis, fd);
|
|
}
|
|
mfxStatus CopyFrame (mfxFrameSurface1 *dst, mfxFrameSurface1 *src) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.CopyFrame(m_core.pthis, dst, src);
|
|
}
|
|
mfxStatus CopyBuffer(mfxU8 *dst, mfxU32 size, mfxFrameSurface1 *src) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.CopyBuffer(m_core.pthis, dst, size, src);
|
|
}
|
|
mfxStatus MapOpaqueSurface(mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.MapOpaqueSurface(m_core.pthis, num, type, op_surf);
|
|
}
|
|
mfxStatus UnmapOpaqueSurface(mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.UnmapOpaqueSurface(m_core.pthis, num, type, op_surf);
|
|
}
|
|
mfxStatus GetRealSurface(mfxFrameSurface1 *op_surf, mfxFrameSurface1 **surf) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.GetRealSurface(m_core.pthis, op_surf, surf);
|
|
}
|
|
mfxStatus GetOpaqueSurface(mfxFrameSurface1 *surf, mfxFrameSurface1 **op_surf) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.GetOpaqueSurface(m_core.pthis, surf, op_surf);
|
|
}
|
|
mfxStatus CreateAccelerationDevice(mfxHandleType type, mfxHDL *handle) {
|
|
if (!IsCoreSet()) {
|
|
return MFX_ERR_NULL_PTR;
|
|
}
|
|
return m_core.CreateAccelerationDevice(m_core.pthis, type, handle);
|
|
}
|
|
mfxFrameAllocator & FrameAllocator() {
|
|
return m_core.FrameAllocator;
|
|
}
|
|
|
|
} ;
|
|
|
|
/* Class adapter between "C" structure mfxPlugin and C++ interface MFXPlugin */
|
|
|
|
namespace detail
|
|
{
|
|
template <class T>
|
|
class MFXPluginAdapterBase
|
|
{
|
|
protected:
|
|
mfxPlugin m_mfxAPI;
|
|
public:
|
|
MFXPluginAdapterBase( T *plugin, mfxVideoCodecPlugin *pCodec = NULL)
|
|
{
|
|
SetupCallbacks(plugin, pCodec);
|
|
}
|
|
|
|
MFXPluginAdapterBase( T *plugin, mfxAudioCodecPlugin *pCodec)
|
|
{
|
|
SetupCallbacks(plugin, pCodec);
|
|
}
|
|
|
|
operator mfxPlugin () const {
|
|
return m_mfxAPI;
|
|
}
|
|
void SetupCallbacks(T *plugin) {
|
|
m_mfxAPI.pthis = plugin;
|
|
m_mfxAPI.PluginInit = _PluginInit;
|
|
m_mfxAPI.PluginClose = _PluginClose;
|
|
m_mfxAPI.GetPluginParam = _GetPluginParam;
|
|
m_mfxAPI.Submit = 0;
|
|
m_mfxAPI.Execute = _Execute;
|
|
m_mfxAPI.FreeResources = _FreeResources;
|
|
}
|
|
|
|
void SetupCallbacks( T *plugin, mfxVideoCodecPlugin *pCodec) {
|
|
SetupCallbacks(plugin);
|
|
m_mfxAPI.Video = pCodec;
|
|
}
|
|
|
|
void SetupCallbacks( T *plugin, mfxAudioCodecPlugin *pCodec) {
|
|
SetupCallbacks(plugin);
|
|
m_mfxAPI.Audio = pCodec;
|
|
}
|
|
private:
|
|
|
|
static mfxStatus _PluginInit(mfxHDL pthis, mfxCoreInterface *core) {
|
|
return reinterpret_cast<T*>(pthis)->PluginInit(core);
|
|
}
|
|
static mfxStatus _PluginClose(mfxHDL pthis) {
|
|
return reinterpret_cast<T*>(pthis)->PluginClose();
|
|
}
|
|
static mfxStatus _GetPluginParam(mfxHDL pthis, mfxPluginParam *par) {
|
|
return reinterpret_cast<T*>(pthis)->GetPluginParam(par);
|
|
}
|
|
static mfxStatus _Execute(mfxHDL pthis, mfxThreadTask task, mfxU32 thread_id, mfxU32 call_count) {
|
|
return reinterpret_cast<T*>(pthis)->Execute(task, thread_id, call_count);
|
|
}
|
|
static mfxStatus _FreeResources(mfxHDL pthis, mfxThreadTask task, mfxStatus sts) {
|
|
return reinterpret_cast<T*>(pthis)->FreeResources(task, sts);
|
|
}
|
|
};
|
|
|
|
template<class T>
|
|
class MFXCodecPluginAdapterBase : public MFXPluginAdapterBase<T>
|
|
{
|
|
protected:
|
|
//stub to feed mediasdk plugin API
|
|
mfxVideoCodecPlugin m_codecPlg;
|
|
public:
|
|
MFXCodecPluginAdapterBase(T * pCodecPlg)
|
|
: MFXPluginAdapterBase<T>(pCodecPlg, &m_codecPlg)
|
|
, m_codecPlg()
|
|
{
|
|
m_codecPlg.Query = _Query;
|
|
m_codecPlg.QueryIOSurf = _QueryIOSurf ;
|
|
m_codecPlg.Init = _Init;
|
|
m_codecPlg.Reset = _Reset;
|
|
m_codecPlg.Close = _Close;
|
|
m_codecPlg.GetVideoParam = _GetVideoParam;
|
|
}
|
|
MFXCodecPluginAdapterBase(const MFXCodecPluginAdapterBase<T> & that)
|
|
: MFXPluginAdapterBase<T>(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg)
|
|
, m_codecPlg() {
|
|
SetupCallbacks();
|
|
}
|
|
MFXCodecPluginAdapterBase<T>& operator = (const MFXCodecPluginAdapterBase<T> & that) {
|
|
MFXPluginAdapterBase<T> :: SetupCallbacks(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg);
|
|
SetupCallbacks();
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
void SetupCallbacks() {
|
|
m_codecPlg.Query = _Query;
|
|
m_codecPlg.QueryIOSurf = _QueryIOSurf ;
|
|
m_codecPlg.Init = _Init;
|
|
m_codecPlg.Reset = _Reset;
|
|
m_codecPlg.Close = _Close;
|
|
m_codecPlg.GetVideoParam = _GetVideoParam;
|
|
}
|
|
static mfxStatus _Query(mfxHDL pthis, mfxVideoParam *in, mfxVideoParam *out) {
|
|
return reinterpret_cast<T*>(pthis)->Query(in, out);
|
|
}
|
|
static mfxStatus _QueryIOSurf(mfxHDL pthis, mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out){
|
|
return reinterpret_cast<T*>(pthis)->QueryIOSurf(par, in, out);
|
|
}
|
|
static mfxStatus _Init(mfxHDL pthis, mfxVideoParam *par){
|
|
return reinterpret_cast<T*>(pthis)->Init(par);
|
|
}
|
|
static mfxStatus _Reset(mfxHDL pthis, mfxVideoParam *par){
|
|
return reinterpret_cast<T*>(pthis)->Reset(par);
|
|
}
|
|
static mfxStatus _Close(mfxHDL pthis) {
|
|
return reinterpret_cast<T*>(pthis)->Close();
|
|
}
|
|
static mfxStatus _GetVideoParam(mfxHDL pthis, mfxVideoParam *par) {
|
|
return reinterpret_cast<T*>(pthis)->GetVideoParam(par);
|
|
}
|
|
};
|
|
|
|
template<class T>
|
|
class MFXAudioCodecPluginAdapterBase : public MFXPluginAdapterBase<T>
|
|
{
|
|
protected:
|
|
//stub to feed mediasdk plugin API
|
|
mfxAudioCodecPlugin m_codecPlg;
|
|
public:
|
|
MFXAudioCodecPluginAdapterBase(T * pCodecPlg)
|
|
: MFXPluginAdapterBase<T>(pCodecPlg, &m_codecPlg)
|
|
, m_codecPlg()
|
|
{
|
|
m_codecPlg.Query = _Query;
|
|
m_codecPlg.QueryIOSize = _QueryIOSize ;
|
|
m_codecPlg.Init = _Init;
|
|
m_codecPlg.Reset = _Reset;
|
|
m_codecPlg.Close = _Close;
|
|
m_codecPlg.GetAudioParam = _GetAudioParam;
|
|
}
|
|
MFXAudioCodecPluginAdapterBase(const MFXCodecPluginAdapterBase<T> & that)
|
|
: MFXPluginAdapterBase<T>(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg)
|
|
, m_codecPlg() {
|
|
SetupCallbacks();
|
|
}
|
|
MFXAudioCodecPluginAdapterBase<T>& operator = (const MFXAudioCodecPluginAdapterBase<T> & that) {
|
|
MFXPluginAdapterBase<T> :: SetupCallbacks(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg);
|
|
SetupCallbacks();
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
void SetupCallbacks() {
|
|
m_codecPlg.Query = _Query;
|
|
m_codecPlg.QueryIOSize = _QueryIOSize;
|
|
m_codecPlg.Init = _Init;
|
|
m_codecPlg.Reset = _Reset;
|
|
m_codecPlg.Close = _Close;
|
|
m_codecPlg.GetAudioParam = _GetAudioParam;
|
|
}
|
|
static mfxStatus _Query(mfxHDL pthis, mfxAudioParam *in, mfxAudioParam *out) {
|
|
return reinterpret_cast<T*>(pthis)->Query(in, out);
|
|
}
|
|
static mfxStatus _QueryIOSize(mfxHDL pthis, mfxAudioParam *par, mfxAudioAllocRequest *request){
|
|
return reinterpret_cast<T*>(pthis)->QueryIOSize(par, request);
|
|
}
|
|
static mfxStatus _Init(mfxHDL pthis, mfxAudioParam *par){
|
|
return reinterpret_cast<T*>(pthis)->Init(par);
|
|
}
|
|
static mfxStatus _Reset(mfxHDL pthis, mfxAudioParam *par){
|
|
return reinterpret_cast<T*>(pthis)->Reset(par);
|
|
}
|
|
static mfxStatus _Close(mfxHDL pthis) {
|
|
return reinterpret_cast<T*>(pthis)->Close();
|
|
}
|
|
static mfxStatus _GetAudioParam(mfxHDL pthis, mfxAudioParam *par) {
|
|
return reinterpret_cast<T*>(pthis)->GetAudioParam(par);
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct MFXPluginAdapterInternal{};
|
|
template<>
|
|
class MFXPluginAdapterInternal<MFXGenericPlugin> : public MFXPluginAdapterBase<MFXGenericPlugin>
|
|
{
|
|
public:
|
|
MFXPluginAdapterInternal(MFXGenericPlugin *pPlugin)
|
|
: MFXPluginAdapterBase<MFXGenericPlugin>(pPlugin)
|
|
{
|
|
m_mfxAPI.Submit = _Submit;
|
|
}
|
|
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that )
|
|
: MFXPluginAdapterBase<MFXGenericPlugin>(that) {
|
|
m_mfxAPI.Submit = that._Submit;
|
|
}
|
|
MFXPluginAdapterInternal<MFXGenericPlugin>& operator = (const MFXPluginAdapterInternal<MFXGenericPlugin> & that) {
|
|
MFXPluginAdapterBase<MFXGenericPlugin>::operator=(that);
|
|
m_mfxAPI.Submit = that._Submit;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
static mfxStatus _Submit(mfxHDL pthis, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXGenericPlugin*>(pthis)->Submit(in, in_num, out, out_num, task);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
class MFXPluginAdapterInternal<MFXDecoderPlugin> : public MFXCodecPluginAdapterBase<MFXDecoderPlugin>
|
|
{
|
|
public:
|
|
MFXPluginAdapterInternal(MFXDecoderPlugin *pPlugin)
|
|
: MFXCodecPluginAdapterBase<MFXDecoderPlugin>(pPlugin)
|
|
{
|
|
SetupCallbacks();
|
|
}
|
|
|
|
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
|
|
: MFXCodecPluginAdapterBase<MFXDecoderPlugin>(that) {
|
|
SetupCallbacks();
|
|
}
|
|
|
|
MFXPluginAdapterInternal<MFXDecoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXDecoderPlugin> & that) {
|
|
MFXCodecPluginAdapterBase<MFXDecoderPlugin>::operator=(that);
|
|
SetupCallbacks();
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
void SetupCallbacks() {
|
|
m_codecPlg.DecodeHeader = _DecodeHeader;
|
|
m_codecPlg.GetPayload = _GetPayload;
|
|
m_codecPlg.DecodeFrameSubmit = _DecodeFrameSubmit;
|
|
}
|
|
static mfxStatus _DecodeHeader(mfxHDL pthis, mfxBitstream *bs, mfxVideoParam *par) {
|
|
return reinterpret_cast<MFXDecoderPlugin*>(pthis)->DecodeHeader(bs, par);
|
|
}
|
|
static mfxStatus _GetPayload(mfxHDL pthis, mfxU64 *ts, mfxPayload *payload) {
|
|
return reinterpret_cast<MFXDecoderPlugin*>(pthis)->GetPayload(ts, payload);
|
|
}
|
|
static mfxStatus _DecodeFrameSubmit(mfxHDL pthis, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXDecoderPlugin*>(pthis)->DecodeFrameSubmit(bs, surface_work, surface_out, task);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
class MFXPluginAdapterInternal<MFXAudioDecoderPlugin> : public MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>
|
|
{
|
|
public:
|
|
MFXPluginAdapterInternal(MFXAudioDecoderPlugin *pPlugin)
|
|
: MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>(pPlugin)
|
|
{
|
|
SetupCallbacks();
|
|
}
|
|
|
|
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
|
|
: MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>(that) {
|
|
SetupCallbacks();
|
|
}
|
|
|
|
MFXPluginAdapterInternal<MFXAudioDecoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXAudioDecoderPlugin> & that) {
|
|
MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>::operator=(that);
|
|
SetupCallbacks();
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
void SetupCallbacks() {
|
|
m_codecPlg.DecodeHeader = _DecodeHeader;
|
|
// m_codecPlg.GetPayload = _GetPayload;
|
|
m_codecPlg.DecodeFrameSubmit = _DecodeFrameSubmit;
|
|
}
|
|
static mfxStatus _DecodeHeader(mfxHDL pthis, mfxBitstream *bs, mfxAudioParam *par) {
|
|
return reinterpret_cast<MFXAudioDecoderPlugin*>(pthis)->DecodeHeader(bs, par);
|
|
}
|
|
// static mfxStatus _GetPayload(mfxHDL pthis, mfxU64 *ts, mfxPayload *payload) {
|
|
// return reinterpret_cast<MFXAudioDecoderPlugin*>(pthis)->GetPayload(ts, payload);
|
|
// }
|
|
static mfxStatus _DecodeFrameSubmit(mfxHDL pthis, mfxBitstream *in, mfxAudioFrame *out, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXAudioDecoderPlugin*>(pthis)->DecodeFrameSubmit(in, out, task);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
class MFXPluginAdapterInternal<MFXEncoderPlugin> : public MFXCodecPluginAdapterBase<MFXEncoderPlugin>
|
|
{
|
|
public:
|
|
MFXPluginAdapterInternal(MFXEncoderPlugin *pPlugin)
|
|
: MFXCodecPluginAdapterBase<MFXEncoderPlugin>(pPlugin)
|
|
{
|
|
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
|
|
}
|
|
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
|
|
: MFXCodecPluginAdapterBase<MFXEncoderPlugin>(that) {
|
|
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
|
|
}
|
|
|
|
MFXPluginAdapterInternal<MFXEncoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXEncoderPlugin> & that) {
|
|
MFXCodecPluginAdapterBase<MFXEncoderPlugin>::operator = (that);
|
|
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
static mfxStatus _EncodeFrameSubmit(mfxHDL pthis, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXEncoderPlugin*>(pthis)->EncodeFrameSubmit(ctrl, surface, bs, task);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
class MFXPluginAdapterInternal<MFXAudioEncoderPlugin> : public MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>
|
|
{
|
|
public:
|
|
MFXPluginAdapterInternal(MFXAudioEncoderPlugin *pPlugin)
|
|
: MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>(pPlugin)
|
|
{
|
|
SetupCallbacks();
|
|
}
|
|
|
|
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
|
|
: MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>(that) {
|
|
SetupCallbacks();
|
|
}
|
|
|
|
MFXPluginAdapterInternal<MFXAudioEncoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXAudioEncoderPlugin> & that) {
|
|
MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>::operator=(that);
|
|
SetupCallbacks();
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
void SetupCallbacks() {
|
|
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
|
|
}
|
|
static mfxStatus _EncodeFrameSubmit(mfxHDL pthis, mfxAudioFrame *aFrame, mfxBitstream *out, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXAudioEncoderPlugin*>(pthis)->EncodeFrameSubmit(aFrame, out, task);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
class MFXPluginAdapterInternal<MFXEncPlugin> : public MFXCodecPluginAdapterBase<MFXEncPlugin>
|
|
{
|
|
public:
|
|
MFXPluginAdapterInternal(MFXEncPlugin *pPlugin)
|
|
: MFXCodecPluginAdapterBase<MFXEncPlugin>(pPlugin)
|
|
{
|
|
m_codecPlg.ENCFrameSubmit = _ENCFrameSubmit;
|
|
}
|
|
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
|
|
: MFXCodecPluginAdapterBase<MFXEncPlugin>(that) {
|
|
m_codecPlg.ENCFrameSubmit = _ENCFrameSubmit;
|
|
}
|
|
|
|
MFXPluginAdapterInternal<MFXEncPlugin>& operator = (const MFXPluginAdapterInternal<MFXEncPlugin> & that) {
|
|
MFXCodecPluginAdapterBase<MFXEncPlugin>::operator = (that);
|
|
m_codecPlg.ENCFrameSubmit = _ENCFrameSubmit;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
static mfxStatus _ENCFrameSubmit(mfxHDL pthis,mfxENCInput *in, mfxENCOutput *out, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXEncPlugin*>(pthis)->EncFrameSubmit(in, out, task);
|
|
}
|
|
};
|
|
|
|
|
|
template<>
|
|
class MFXPluginAdapterInternal<MFXVPPPlugin> : public MFXCodecPluginAdapterBase<MFXVPPPlugin>
|
|
{
|
|
public:
|
|
MFXPluginAdapterInternal(MFXVPPPlugin *pPlugin)
|
|
: MFXCodecPluginAdapterBase<MFXVPPPlugin>(pPlugin)
|
|
{
|
|
SetupCallbacks();
|
|
}
|
|
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
|
|
: MFXCodecPluginAdapterBase<MFXVPPPlugin>(that) {
|
|
SetupCallbacks();
|
|
}
|
|
|
|
MFXPluginAdapterInternal<MFXVPPPlugin>& operator = (const MFXPluginAdapterInternal<MFXVPPPlugin> & that) {
|
|
MFXCodecPluginAdapterBase<MFXVPPPlugin>::operator = (that);
|
|
SetupCallbacks();
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
void SetupCallbacks() {
|
|
m_codecPlg.VPPFrameSubmit = _VPPFrameSubmit;
|
|
m_codecPlg.VPPFrameSubmitEx = _VPPFrameSubmitEx;
|
|
}
|
|
static mfxStatus _VPPFrameSubmit(mfxHDL pthis, mfxFrameSurface1 *surface_in, mfxFrameSurface1 *surface_out, mfxExtVppAuxData *aux, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXVPPPlugin*>(pthis)->VPPFrameSubmit(surface_in, surface_out, aux, task);
|
|
}
|
|
static mfxStatus _VPPFrameSubmitEx(mfxHDL pthis, mfxFrameSurface1 *surface_in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) {
|
|
return reinterpret_cast<MFXVPPPlugin*>(pthis)->VPPFrameSubmitEx(surface_in, surface_work, surface_out, task);
|
|
}
|
|
};
|
|
}
|
|
|
|
/* adapter for particular plugin type*/
|
|
template<class T>
|
|
class MFXPluginAdapter
|
|
{
|
|
public:
|
|
detail::MFXPluginAdapterInternal<T> m_Adapter;
|
|
|
|
operator mfxPlugin () const {
|
|
return m_Adapter.operator mfxPlugin();
|
|
}
|
|
|
|
MFXPluginAdapter(T* pPlugin = NULL)
|
|
: m_Adapter(pPlugin)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<class T>
|
|
inline MFXPluginAdapter<T> make_mfx_plugin_adapter(T* pPlugin) {
|
|
|
|
MFXPluginAdapter<T> adapt(pPlugin);
|
|
return adapt;
|
|
}
|
|
|
|
#endif // __MFXPLUGINPLUSPLUS_H
|