const char* hb_qsv_impl_get_name(int impl)
{
switch (MFX_IMPL_BASETYPE(impl))
{
case MFX_IMPL_SOFTWARE:
return "software";
case MFX_IMPL_HARDWARE:
return "hardware (1)";
case MFX_IMPL_HARDWARE2:
return "hardware (2)";
case MFX_IMPL_HARDWARE3:
return "hardware (3)";
case MFX_IMPL_HARDWARE4:
return "hardware (4)";
case MFX_IMPL_HARDWARE_ANY:
return "hardware (any)";
case MFX_IMPL_AUTO:
return "automatic";
case MFX_IMPL_AUTO_ANY:
return "automatic (any)";
default:
return NULL;
}
}
int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session,
const char *load_plugins)
{
mfxIMPL impl = MFX_IMPL_AUTO_ANY;
mfxVersion ver = { { QSV_VERSION_MINOR, QSV_VERSION_MAJOR } };
const char *desc;
int ret;
ret = MFXInit(impl, &ver, session);
if (ret < 0)
return ff_qsv_print_error(avctx, ret,
"Error initializing an internal MFX session");
ret = qsv_load_plugins(*session, load_plugins, avctx);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Error loading plugins\n");
return ret;
}
MFXQueryIMPL(*session, &impl);
switch (MFX_IMPL_BASETYPE(impl)) {
case MFX_IMPL_SOFTWARE:
desc = "software";
break;
case MFX_IMPL_HARDWARE:
case MFX_IMPL_HARDWARE2:
case MFX_IMPL_HARDWARE3:
case MFX_IMPL_HARDWARE4:
desc = "hardware accelerated";
break;
default:
desc = "unknown";
}
av_log(avctx, AV_LOG_VERBOSE,
"Initialized an internal MFX session using %s implementation\n",
desc);
return 0;
}
mfxStatus CRendererPipeline::CreateAllocator()
{
mfxStatus sts = MFX_ERR_NONE;
if (D3D11_MEMORY == m_memType)
{
sts = CreateHWDevice();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
// create system memory allocator
m_pMFXAllocator = new SysMemFrameAllocator;
MSDK_CHECK_POINTER(m_pMFXAllocator, MFX_ERR_MEMORY_ALLOC);
// initialize memory allocator
sts = m_pMFXAllocator->Init(m_pmfxAllocatorParams);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
return sts;
}
if (D3D9_MEMORY == m_memType || D3D11_MEMORY == m_memType)
{
#if D3D_SURFACES_SUPPORT
sts = CreateHWDevice();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
mfxHDL hdl = NULL;
mfxHandleType hdl_t =
#if MFX_D3D11_SUPPORT
D3D11_MEMORY == m_memType ? MFX_HANDLE_D3D11_DEVICE :
#endif // #if MFX_D3D11_SUPPORT
MFX_HANDLE_D3D9_DEVICE_MANAGER;
sts = m_hwdev->GetHandle(hdl_t, &hdl);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
// handle is needed for HW library only
mfxIMPL impl = 0;
m_mfxSession.QueryIMPL(&impl);
if (impl != MFX_IMPL_SOFTWARE)
{
sts = m_mfxSession.SetHandle(hdl_t, hdl);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
}
// create D3D allocator
#if MFX_D3D11_SUPPORT
if (D3D11_MEMORY == m_memType)
{
m_pMFXAllocator = new D3D11FrameAllocator;
MSDK_CHECK_POINTER(m_pMFXAllocator, MFX_ERR_MEMORY_ALLOC);
D3D11AllocatorParams *pd3dAllocParams = new D3D11AllocatorParams;
MSDK_CHECK_POINTER(pd3dAllocParams, MFX_ERR_MEMORY_ALLOC);
pd3dAllocParams->pDevice = reinterpret_cast<ID3D11Device *>(hdl);
m_pmfxAllocatorParams = pd3dAllocParams;
}
else
#endif // #if MFX_D3D11_SUPPORT
{
m_pMFXAllocator = new D3DFrameAllocator;
MSDK_CHECK_POINTER(m_pMFXAllocator, MFX_ERR_MEMORY_ALLOC);
D3DAllocatorParams *pd3dAllocParams = new D3DAllocatorParams;
MSDK_CHECK_POINTER(pd3dAllocParams, MFX_ERR_MEMORY_ALLOC);
pd3dAllocParams->pManager = reinterpret_cast<IDirect3DDeviceManager9 *>(hdl);
m_pmfxAllocatorParams = pd3dAllocParams;
}
/* In case of video memory we must provide MediaSDK with external allocator
thus we demonstrate "external allocator" usage model.
Call SetAllocator to pass allocator to Media SDK */
sts = m_mfxSession.SetFrameAllocator(m_pMFXAllocator);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
#endif
#ifdef LIBVA_SUPPORT
sts = CreateHWDevice();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
/* It's possible to skip failed result here and switch to SW implementation,
but we don't process this way */
mfxHDL hdl = NULL;
sts = m_hwdev->GetHandle(MFX_HANDLE_VA_DISPLAY, &hdl);
// provide device manager to MediaSDK
sts = m_mfxSession.SetHandle(MFX_HANDLE_VA_DISPLAY, hdl);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
// create VAAPI allocator
m_pMFXAllocator = new vaapiFrameAllocator;
MSDK_CHECK_POINTER(m_pMFXAllocator, MFX_ERR_MEMORY_ALLOC);
vaapiAllocatorParams *p_vaapiAllocParams = new vaapiAllocatorParams;
MSDK_CHECK_POINTER(p_vaapiAllocParams, MFX_ERR_MEMORY_ALLOC);
p_vaapiAllocParams->m_dpy = (VADisplay)hdl;
m_pmfxAllocatorParams = p_vaapiAllocParams;
/* In case of video memory we must provide MediaSDK with external allocator
thus we demonstrate "external allocator" usage model.
Call SetAllocator to pass allocator to mediasdk */
sts = m_mfxSession.SetFrameAllocator(m_pMFXAllocator);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
#endif
}
else
{
#ifdef LIBVA_SUPPORT
//in case of system memory allocator we also have to pass MFX_HANDLE_VA_DISPLAY to HW library
mfxIMPL impl;
m_mfxSession.QueryIMPL(&impl);
if(MFX_IMPL_HARDWARE == MFX_IMPL_BASETYPE(impl))
{
sts = CreateHWDevice();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
mfxHDL hdl = NULL;
sts = m_hwdev->GetHandle(MFX_HANDLE_VA_DISPLAY, &hdl);
// provide device manager to MediaSDK
sts = m_mfxSession.SetHandle(MFX_HANDLE_VA_DISPLAY, hdl);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
}
#endif
// create system memory allocator
m_pMFXAllocator = new SysMemFrameAllocator;
MSDK_CHECK_POINTER(m_pMFXAllocator, MFX_ERR_MEMORY_ALLOC);
/* In case of system memory we demonstrate "no external allocator" usage model.
We don't call SetAllocator, Media SDK uses internal allocator.
We use system memory allocator simply as a memory manager for application*/
}
// initialize memory allocator
sts = m_pMFXAllocator->Init(m_pmfxAllocatorParams);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
return MFX_ERR_NONE;
}
