lagertonne/yolobs-studio
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Upstream version 0.14.2+dfsg1

Browse source 
-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABCAAGBQJXRLkNAAoJEGny/FFupxmTPMQP/02YfsEVr5k6eIjluFMODQ85
 6nQCFPZ8VmYAQfoLtE0oP4UiGV0x4gsVjzHCKJ3XZPkGSUzPdalZo5xKyTvAPxfY
 ihSM7/XN5MAtHIP3jQO89hvkbDx4V3yO6WHTwxIjltmHSl+YUC2/bYHO1hz0uVUz
 TNjcmQSmDevfac1uTQmvH6jjiTlVipQodVC8vOGFPS1F/CBlJtc6T/ZASXx5HdUT
 Q2Rf79ZNUWLJkkvc31lsd6JGPl9HUdkwW2d9AP8/5p+SJPqLo+2DB1VLqWWxcf4C
 wLGR5DSQmqeIU7oH+L1BI1bhZst7pP5qwUdBkCnnmhY4SuvwC3Me/PN56WbTDdMe
 yJvBi0JLL6g4CEZq3Pp2IDTi6o57zcSpIhtW/xxo1pilgQhqd7nJhIyDR4U2BmXR
 lc68yPY6uLczUQ3igYd1azmfAbBubiR0EQ8uMFFv8behRHCz4k2PDzPI7Sbl2W5f
 qBpkgOmTJoQ+TwKx2U4wlV4nzWnMsi6iUNhtU+PrFMJJgWNiZVRyGWPmq5YvVw9F
 IVKfkZgepoEsusrg6GMEVTmc32G7P07qCkLoFxhv3Lf7R3Ko0DIXPL3adUG9EKeY
 5F+X24ucjR7CRil9tDIuWYs1WNDK3PEYk9+HPxBFNO5zjlGurxLg2JfPEfSXhTBG
 J/vCAE+RUCyYbL3FlZsu
 =bMfJ
 -----END PGP SIGNATURE-----

Merge tag 'upstream/0.14.2+dfsg1'

Upstream version 0.14.2+dfsg1

# gpg: Signature made Tue 24 May 2016 22:26:53 CEST using RSA key ID 6EA71993
# gpg: Good signature from "Sebastian Ramacher <sebastian@ramacher.at>"
# gpg:                 aka "Sebastian Ramacher <s.ramacher@gmail.com>"
# gpg:                 aka "Sebastian Ramacher <s.ramacher@gmx.at>"
# gpg:                 aka "Sebastian Ramacher <s.ramacher@student.tugraz.at>"
# gpg:                 aka "Sebastian Ramacher <sramacher@debian.org>"
# gpg:                 aka "Sebastian Ramacher <sebastian.ramacher@iaik.tugraz.at>"
This commit is contained in:
Sebastian Ramacher 2016-05-24 22:26:56 +02:00
commit 5b801c8c0a
78 changed files with 0 additions and 13347 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

86
plugins/obs-qsv11/CMakeLists.txt
View file

@ -1,86 +0,0 @@
project(obs-qsv11)
include_directories(libmfx/include/msdk/include)
include_directories(libmfx/include)
set(obs-qsv11_libmfx_SOURCES
libmfx/src/main.cpp
libmfx/src/mfx_critical_section.cpp
libmfx/src/mfx_dispatcher.cpp
libmfx/src/mfx_dispatcher_log.cpp
libmfx/src/mfx_dxva2_device.cpp
libmfx/src/mfx_function_table.cpp
libmfx/src/mfx_library_iterator.cpp
libmfx/src/mfx_load_dll.cpp
libmfx/src/mfx_load_plugin.cpp
libmfx/src/mfx_plugin_hive.cpp
libmfx/src/mfx_win_reg_key.cpp
)
set(obs-qsv11_libmfx_HEADERS
libmfx/include/msdk/include/mfxastructures.h
libmfx/include/msdk/include/mfxaudio.h
libmfx/include/msdk/include/mfxaudio++.h
libmfx/include/msdk/include/mfxcommon.h
libmfx/include/msdk/include/mfxdefs.h
libmfx/include/msdk/include/mfxjpeg.h
libmfx/include/msdk/include/mfxmvc.h
libmfx/include/msdk/include/mfxplugin.h
libmfx/include/msdk/include/mfxplugin++.h
libmfx/include/msdk/include/mfxsession.h
libmfx/include/msdk/include/mfxstructures.h
libmfx/include/msdk/include/mfxvideo.h
libmfx/include/msdk/include/mfxvideo++.h
libmfx/include/msdk/include/mfxvstructures.h
libmfx/include/mfx_critical_section.h
libmfx/include/mfx_dispatcher.h
libmfx/include/mfx_dispatcher_defs.h
libmfx/include/mfx_dispatcher_log.h
libmfx/include/mfx_dxva2_device.h
libmfx/include/mfx_exposed_functions_list.h
libmfx/include/mfx_library_iterator.h
libmfx/include/mfx_load_dll.h
libmfx/include/mfx_load_plugin.h
libmfx/include/mfx_plugin_hive.h
libmfx/include/mfx_vector.h
libmfx/include/mfx_win_reg_key.h
libmfx/include/mfxaudio_exposed_functions_list.h
)
set(obs-qsv11_SOURCES
common_directx11.cpp
common_utils.cpp
common_utils_windows.cpp
QSV_Encoder.cpp
QSV_Encoder_Internal.cpp
obs-qsv11.c
obs-qsv11-plugin-main.c)
set(obs-qsv11_HEADERS
bits/linux_defs.h
bits/windows_defs.h
common_directx11.h
common_utils.h
QSV_Encoder.h
QSV_Encoder_Internal.h)
add_library(obs-qsv11 MODULE
${obs-qsv11_SOURCES}
${obs-qsv11_HEADERS}
${obs-qsv11_libmfx_SOURCES}
${obs-qsv11_libmfx_HEADERS}
)
target_link_libraries(obs-qsv11
libobs
d3d11
dxgi
)
target_compile_definitions(obs-qsv11 PRIVATE DX11_D3D)
source_group("obs-qsv11\\Source Files" FILES ${obs-qsv11_SOURCES})
source_group("obs-qsv11\\Header Files" FILES ${obs-qsv11_HEADERS})
source_group("libmfx\\Source Files" FILES ${obs-qsv11_libmfx_SOURCES})
source_group("libmfx\\Header Files" FILES ${obs-qsv11_libmfx_HEADERS})
install_obs_plugin_with_data(obs-qsv11 data)

228
plugins/obs-qsv11/QSV_Encoder.cpp
View file

@ -1,228 +0,0 @@
/*
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright(c) Oct. 2015 Intel Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program 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
General Public License for more details.
Contact Information:
Seung-Woo Kim, seung-woo.kim@intel.com
705 5th Ave S #500, Seattle, WA 98104
BSD LICENSE
Copyright(c) <date> Intel Corporation.
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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"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 THE COPYRIGHT
OWNER OR CONTRIBUTORS 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.
*/
// QSV_Encoder.cpp : Defines the exported functions for the DLL application.
//
#include "QSV_Encoder.h"
#include "QSV_Encoder_Internal.h"
#include <obs-module.h>
#include <string>
#include <mutex>
#define do_log(level, format, ...) \
blog(level, "[qsv encoder: '%s'] " format, \
"msdk_impl", ##__VA_ARGS__)
mfxIMPL impl = MFX_IMPL_HARDWARE_ANY;
mfxVersion ver = {{0, 1}}; // for backward compatibility
std::mutex active_mutex;
void qsv_encoder_version(unsigned short *major, unsigned short *minor)
{
*major = ver.Major;
*minor = ver.Minor;
}
qsv_t *qsv_encoder_open(qsv_param_t *pParams)
{
if (!active_mutex.try_lock()) {
do_log(LOG_ERROR, "Cannot have more than one encoder "
"active at a time");
return NULL;
}
QSV_Encoder_Internal *pEncoder = new QSV_Encoder_Internal(impl, ver);
mfxStatus sts = pEncoder->Open(pParams);
if (sts != MFX_ERR_NONE) {
delete pEncoder;
if (pEncoder)
active_mutex.unlock();
return NULL;
}
return (qsv_t *) pEncoder;
}
int qsv_encoder_headers(qsv_t *pContext, uint8_t **pSPS, uint8_t **pPPS,
uint16_t *pnSPS, uint16_t *pnPPS)
{
QSV_Encoder_Internal *pEncoder = (QSV_Encoder_Internal *)pContext;
pEncoder->GetSPSPPS(pSPS, pPPS, pnSPS, pnPPS);
return 0;
}
int qsv_encoder_encode(qsv_t * pContext, uint64_t ts, uint8_t *pDataY,
uint8_t *pDataUV, uint32_t strideY, uint32_t strideUV,
mfxBitstream **pBS)
{
QSV_Encoder_Internal *pEncoder = (QSV_Encoder_Internal *)pContext;
mfxStatus sts = MFX_ERR_NONE;
if (pDataY != NULL && pDataUV != NULL)
sts = pEncoder->Encode(ts, pDataY, pDataUV, strideY, strideUV,
pBS);
if (sts == MFX_ERR_NONE)
return 0;
else if (sts == MFX_ERR_MORE_DATA)
return 1;
else
return -1;
}
int qsv_encoder_close(qsv_t *pContext)
{
QSV_Encoder_Internal *pEncoder = (QSV_Encoder_Internal *)pContext;
delete pEncoder;
if (pEncoder)
active_mutex.unlock();
return 0;
}
/*
int qsv_param_default_preset(qsv_param_t *pParams, const char *preset,
const char *tune)
{
return 0;
}
int qsv_param_parse(qsv_param_t *, const char *name, const char *value)
{
return 0;
}
int qsv_param_apply_profile(qsv_param_t *, const char *profile)
{
return 0;
}
*/
int qsv_encoder_reconfig(qsv_t *pContext, qsv_param_t *pParams)
{
QSV_Encoder_Internal *pEncoder = (QSV_Encoder_Internal *)pContext;
mfxStatus sts = pEncoder->Reset(pParams);
if (sts == MFX_ERR_NONE)
return 0;
else
return -1;
}
enum qsv_cpu_platform qsv_get_cpu_platform()
{
using std::string;
int cpuInfo[4];
__cpuid(cpuInfo, 0);
string vendor;
vendor += string((char*)&cpuInfo[1], 4);
vendor += string((char*)&cpuInfo[3], 4);
vendor += string((char*)&cpuInfo[2], 4);
if (vendor != "GenuineIntel")
return QSV_CPU_PLATFORM_UNKNOWN;
__cpuid(cpuInfo, 1);
BYTE model = ((cpuInfo[0] >> 4) & 0xF) + ((cpuInfo[0] >> 12) & 0xF0);
BYTE family = ((cpuInfo[0] >> 8) & 0xF) + ((cpuInfo[0] >> 20) & 0xFF);
// See Intel 64 and IA-32 Architectures Software Developer's Manual,
// Vol 3C Table 35-1
if (family != 6)
return QSV_CPU_PLATFORM_UNKNOWN;
switch (model)
{
case 0x1C:
case 0x26:
case 0x27:
case 0x35:
case 0x36:
return QSV_CPU_PLATFORM_BNL;
case 0x2a:
case 0x2d:
return QSV_CPU_PLATFORM_SNB;
case 0x3a:
case 0x3e:
return QSV_CPU_PLATFORM_IVB;
case 0x37:
case 0x4A:
case 0x4D:
case 0x5A:
case 0x5D:
return QSV_CPU_PLATFORM_SLM;
case 0x4C:
return QSV_CPU_PLATFORM_CHT;
case 0x3c:
case 0x3f:
case 0x45:
case 0x46:
return QSV_CPU_PLATFORM_HSW;
}
//assume newer revisions are at least as capable as haswell
return QSV_CPU_PLATFORM_INTEL;
}

149
plugins/obs-qsv11/QSV_Encoder.h
View file

@ -1,149 +0,0 @@
/*
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright(c) Oct. 2015 Intel Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program 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
General Public License for more details.
Contact Information:
Seung-Woo Kim, seung-woo.kim@intel.com
705 5th Ave S #500, Seattle, WA 98104
BSD LICENSE
Copyright(c) <date> Intel Corporation.
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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"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 THE COPYRIGHT
OWNER OR CONTRIBUTORS 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.
*/
#pragma once
#include <Windows.h>
#include "mfxstructures.h"
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
struct qsv_rate_control_info {
const char *name;
bool haswell_or_greater;
};
static const struct qsv_rate_control_info qsv_ratecontrols[] = {
{"CBR", false},
{"VBR", false},
{"VCM", true},
{"CQP", false},
{"AVBR", false},
{"ICQ", true},
{"LA_ICQ", true},
{"LA", true},
{0, false}
};
static const char * const qsv_profile_names[] = {
"high",
"main",
"baseline",
0
};
static const char * const qsv_usage_names[] = {
"quality",
"balanced",
"speed",
0
};
typedef struct qsv_t qsv_t;
typedef struct
{
mfxU16 nTargetUsage; /* 1 through 7, 1 being best quality and 7
being the best speed */
mfxU16 nWidth; /* source picture width */
mfxU16 nHeight; /* source picture height */
mfxU16 nAsyncDepth;
mfxU16 nFpsNum;
mfxU16 nFpsDen;
mfxU16 nTargetBitRate;
mfxU16 nMaxBitRate;
mfxU16 nCodecProfile;
mfxU16 nRateControl;
mfxU16 nAccuracy;
mfxU16 nConvergence;
mfxU16 nQPI;
mfxU16 nQPP;
mfxU16 nQPB;
mfxU16 nLADEPTH;
mfxU16 nKeyIntSec;
mfxU16 nbFrames;
mfxU16 nICQQuality;
} qsv_param_t;
enum qsv_cpu_platform {
QSV_CPU_PLATFORM_UNKNOWN,
QSV_CPU_PLATFORM_BNL,
QSV_CPU_PLATFORM_SNB,
QSV_CPU_PLATFORM_IVB,
QSV_CPU_PLATFORM_SLM,
QSV_CPU_PLATFORM_CHT,
QSV_CPU_PLATFORM_HSW,
QSV_CPU_PLATFORM_INTEL
};
int qsv_encoder_close(qsv_t *);
int qsv_param_parse(qsv_param_t *, const char *name, const char *value);
int qsv_param_apply_profile(qsv_param_t *, const char *profile);
int qsv_param_default_preset(qsv_param_t *, const char *preset,
const char *tune);
int qsv_encoder_reconfig(qsv_t *, qsv_param_t *);
void qsv_encoder_version(unsigned short *major, unsigned short *minor);
qsv_t *qsv_encoder_open( qsv_param_t * );
int qsv_encoder_encode(qsv_t *, uint64_t, uint8_t *, uint8_t *, uint32_t,
uint32_t, mfxBitstream **pBS);
int qsv_encoder_headers(qsv_t *, uint8_t **pSPS, uint8_t **pPPS,
uint16_t *pnSPS, uint16_t *pnPPS);
enum qsv_cpu_platform qsv_get_cpu_platform();
#ifdef __cplusplus
}
#endif

598
plugins/obs-qsv11/QSV_Encoder_Internal.cpp
View file

@ -1,598 +0,0 @@
/*
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright(c) Oct. 2015 Intel Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program 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
General Public License for more details.
Contact Information:
Seung-Woo Kim, seung-woo.kim@intel.com
705 5th Ave S #500, Seattle, WA 98104
BSD LICENSE
Copyright(c) <date> Intel Corporation.
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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"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 THE COPYRIGHT
OWNER OR CONTRIBUTORS 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.
*/
#include "QSV_Encoder_Internal.h"
#include "QSV_Encoder.h"
#include "mfxastructures.h"
#include "mfxvideo++.h"
#include <VersionHelpers.h>
#include <obs-module.h>
#define do_log(level, format, ...) \
blog(level, "[qsv encoder: '%s'] " format, \
"msdk_impl", ##__VA_ARGS__)
#define warn(format, ...) do_log(LOG_WARNING, format, ##__VA_ARGS__)
#define info(format, ...) do_log(LOG_INFO, format, ##__VA_ARGS__)
#define debug(format, ...) do_log(LOG_DEBUG, format, ##__VA_ARGS__)
QSV_Encoder_Internal::QSV_Encoder_Internal(mfxIMPL& impl, mfxVersion& version) :
m_pmfxENC(NULL),
m_nSPSBufferSize(100),
m_nPPSBufferSize(100),
m_nTaskPool(0),
m_pTaskPool(NULL),
m_nTaskIdx(0),
m_nFirstSyncTask(0)
{
mfxIMPL tempImpl;
mfxStatus sts;
m_bIsWindows8OrGreater = IsWindows8OrGreater();
m_bUseD3D11 = false;
if (m_bIsWindows8OrGreater) {
tempImpl = impl | MFX_IMPL_VIA_D3D11;
sts = m_session.Init(tempImpl, &version);
if (sts == MFX_ERR_NONE) {
m_session.QueryVersion(&version);
m_session.Close();
// Use D3D11 surface
// m_bUseD3D11 = ((version.Major > 1) ||
// (version.Major == 1 && version.Minor >= 8));
m_bUseD3D11 = true;
if (m_bUseD3D11)
blog(LOG_INFO, "\timpl: D3D11\n"
"\tsurf: D3D11");
else
blog(LOG_INFO, "\timpl: D3D11\n"
"\tsurf: SysMem");
m_impl = tempImpl;
m_ver = version;
return;
}
}
// Either windows 7 or D3D11 failed at this point.
tempImpl = impl | MFX_IMPL_VIA_D3D9;
sts = m_session.Init(tempImpl, &version);
if (sts == MFX_ERR_NONE) {
m_session.QueryVersion(&version);
m_session.Close();
blog(LOG_INFO, "\timpl: D3D09\n"
"\tsurf: SysMem");
m_impl = tempImpl;
m_ver = version;
}
}
QSV_Encoder_Internal::~QSV_Encoder_Internal()
{
if (m_pmfxENC)
ClearData();
}
mfxStatus QSV_Encoder_Internal::Open(qsv_param_t * pParams)
{
mfxStatus sts = MFX_ERR_NONE;
if (m_bUseD3D11)
// Use D3D11 surface
sts = Initialize(m_impl, m_ver, &m_session, &m_mfxAllocator);
else
// Use system memory
sts = Initialize(m_impl, m_ver, &m_session, NULL);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
m_pmfxENC = new MFXVideoENCODE(m_session);
InitParams(pParams);
sts = m_pmfxENC->Query(&m_mfxEncParams, &m_mfxEncParams);
MSDK_IGNORE_MFX_STS(sts, MFX_WRN_INCOMPATIBLE_VIDEO_PARAM);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
sts = AllocateSurfaces();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
sts = m_pmfxENC->Init(&m_mfxEncParams);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
sts = GetVideoParam();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
sts = InitBitstream();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
return sts;
}
bool QSV_Encoder_Internal::InitParams(qsv_param_t * pParams)
{
memset(&m_mfxEncParams, 0, sizeof(m_mfxEncParams));
m_mfxEncParams.mfx.CodecId = MFX_CODEC_AVC;
m_mfxEncParams.mfx.GopOptFlag = MFX_GOP_STRICT;
m_mfxEncParams.mfx.NumSlice = 1;
m_mfxEncParams.mfx.TargetUsage = pParams->nTargetUsage;
m_mfxEncParams.mfx.CodecProfile = pParams->nCodecProfile;
m_mfxEncParams.mfx.FrameInfo.FrameRateExtN = pParams->nFpsNum;
m_mfxEncParams.mfx.FrameInfo.FrameRateExtD = pParams->nFpsDen;
m_mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_NV12;
m_mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
m_mfxEncParams.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
m_mfxEncParams.mfx.FrameInfo.CropX = 0;
m_mfxEncParams.mfx.FrameInfo.CropY = 0;
m_mfxEncParams.mfx.FrameInfo.CropW = pParams->nWidth;
m_mfxEncParams.mfx.FrameInfo.CropH = pParams->nHeight;
m_mfxEncParams.mfx.RateControlMethod = pParams->nRateControl;
switch (pParams->nRateControl) {
case MFX_RATECONTROL_CBR:
m_mfxEncParams.mfx.TargetKbps = pParams->nTargetBitRate;
break;
case MFX_RATECONTROL_VBR:
case MFX_RATECONTROL_VCM:
m_mfxEncParams.mfx.TargetKbps = pParams->nTargetBitRate;
m_mfxEncParams.mfx.MaxKbps = pParams->nMaxBitRate;
break;
case MFX_RATECONTROL_CQP:
m_mfxEncParams.mfx.QPI = pParams->nQPI;
m_mfxEncParams.mfx.QPB = pParams->nQPB;
m_mfxEncParams.mfx.QPP = pParams->nQPP;
break;
case MFX_RATECONTROL_AVBR:
m_mfxEncParams.mfx.TargetKbps = pParams->nTargetBitRate;
m_mfxEncParams.mfx.Accuracy = pParams->nAccuracy;
m_mfxEncParams.mfx.Convergence = pParams->nConvergence;
break;
case MFX_RATECONTROL_ICQ:
m_mfxEncParams.mfx.ICQQuality = pParams->nICQQuality;
break;
case MFX_RATECONTROL_LA:
m_mfxEncParams.mfx.TargetKbps = pParams->nTargetBitRate;
break;
case MFX_RATECONTROL_LA_ICQ:
m_mfxEncParams.mfx.ICQQuality = pParams->nICQQuality;
break;
default:
break;
}
m_mfxEncParams.AsyncDepth = pParams->nAsyncDepth;
m_mfxEncParams.mfx.GopPicSize = (mfxU16)(pParams->nKeyIntSec *
pParams->nFpsNum / (float)pParams->nFpsDen);
static mfxExtBuffer* extendedBuffers[2];
int iBuffers = 0;
if (pParams->nAsyncDepth == 1) {
m_mfxEncParams.mfx.NumRefFrame = 1;
// low latency, I and P frames only
m_mfxEncParams.mfx.GopRefDist = 1;
memset(&m_co, 0, sizeof(mfxExtCodingOption));
m_co.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
m_co.Header.BufferSz = sizeof(mfxExtCodingOption);
m_co.MaxDecFrameBuffering = 1;
extendedBuffers[iBuffers++] = (mfxExtBuffer*)&m_co;
}
else
m_mfxEncParams.mfx.GopRefDist = pParams->nbFrames + 1;
if (pParams->nRateControl == MFX_RATECONTROL_LA_ICQ ||
pParams->nRateControl == MFX_RATECONTROL_LA) {
memset(&m_co2, 0, sizeof(mfxExtCodingOption2));
m_co2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
m_co2.Header.BufferSz = sizeof(m_co2);
m_co2.LookAheadDepth = pParams->nLADEPTH;
extendedBuffers[iBuffers++] = (mfxExtBuffer*)& m_co2;
}
if (iBuffers > 0) {
m_mfxEncParams.ExtParam = extendedBuffers;
m_mfxEncParams.NumExtParam = (mfxU16)iBuffers;
}
// Width must be a multiple of 16
// Height must be a multiple of 16 in case of frame picture and a
// multiple of 32 in case of field picture
m_mfxEncParams.mfx.FrameInfo.Width = MSDK_ALIGN16(pParams->nWidth);
m_mfxEncParams.mfx.FrameInfo.Height = MSDK_ALIGN16(pParams->nHeight);
if (m_bUseD3D11)
m_mfxEncParams.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
else
m_mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
return true;
}
mfxStatus QSV_Encoder_Internal::AllocateSurfaces()
{
// Query number of required surfaces for encoder
mfxFrameAllocRequest EncRequest;
memset(&EncRequest, 0, sizeof(EncRequest));
mfxStatus sts = m_pmfxENC->QueryIOSurf(&m_mfxEncParams, &EncRequest);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
EncRequest.Type |= WILL_WRITE;
// SNB hack. On some SNB, it seems to require more surfaces
EncRequest.NumFrameSuggested += m_mfxEncParams.AsyncDepth;
// Allocate required surfaces
if (m_bUseD3D11) {
sts = m_mfxAllocator.Alloc(m_mfxAllocator.pthis, &EncRequest,
&m_mfxResponse);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
m_nSurfNum = m_mfxResponse.NumFrameActual;
m_pmfxSurfaces = new mfxFrameSurface1 *[m_nSurfNum];
MSDK_CHECK_POINTER(m_pmfxSurfaces, MFX_ERR_MEMORY_ALLOC);
for (int i = 0; i < m_nSurfNum; i++) {
m_pmfxSurfaces[i] = new mfxFrameSurface1;
memset(m_pmfxSurfaces[i], 0, sizeof(mfxFrameSurface1));
memcpy(&(m_pmfxSurfaces[i]->Info),
&(m_mfxEncParams.mfx.FrameInfo),
sizeof(mfxFrameInfo));
m_pmfxSurfaces[i]->Data.MemId = m_mfxResponse.mids[i];
}
}
else {
mfxU16 width = (mfxU16)MSDK_ALIGN32(EncRequest.Info.Width);
mfxU16 height = (mfxU16)MSDK_ALIGN32(EncRequest.Info.Height);
mfxU8 bitsPerPixel = 12;
mfxU32 surfaceSize = width * height * bitsPerPixel / 8;
m_nSurfNum = EncRequest.NumFrameSuggested;
m_pmfxSurfaces = new mfxFrameSurface1 *[m_nSurfNum];
for (int i = 0; i < m_nSurfNum; i++) {
m_pmfxSurfaces[i] = new mfxFrameSurface1;
memset(m_pmfxSurfaces[i], 0, sizeof(mfxFrameSurface1));
memcpy(&(m_pmfxSurfaces[i]->Info),
&(m_mfxEncParams.mfx.FrameInfo),
sizeof(mfxFrameInfo));
mfxU8* pSurface = (mfxU8*) new mfxU8[surfaceSize];
m_pmfxSurfaces[i]->Data.Y = pSurface;
m_pmfxSurfaces[i]->Data.U = pSurface + width * height;
m_pmfxSurfaces[i]->Data.V = pSurface + width * height + 1;
m_pmfxSurfaces[i]->Data.Pitch = width;
}
}
blog(LOG_INFO, "\tm_nSurfNum: %d", m_nSurfNum);
return sts;
}
mfxStatus QSV_Encoder_Internal::GetVideoParam()
{
memset(&m_parameter, 0, sizeof(m_parameter));
mfxExtCodingOptionSPSPPS opt;
memset(&m_parameter, 0, sizeof(m_parameter));
opt.Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS;
opt.Header.BufferSz = sizeof(mfxExtCodingOptionSPSPPS);
static mfxExtBuffer* extendedBuffers[1];
extendedBuffers[0] = (mfxExtBuffer*)& opt;
m_parameter.ExtParam = extendedBuffers;
m_parameter.NumExtParam = 1;
opt.SPSBuffer = m_SPSBuffer;
opt.PPSBuffer = m_PPSBuffer;
opt.SPSBufSize = 100; // m_nSPSBufferSize;
opt.PPSBufSize = 100; // m_nPPSBufferSize;
mfxStatus sts = m_pmfxENC->GetVideoParam(&m_parameter);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
m_nSPSBufferSize = opt.SPSBufSize;
m_nPPSBufferSize = opt.PPSBufSize;
return sts;
}
void QSV_Encoder_Internal::GetSPSPPS(mfxU8 **pSPSBuf, mfxU8 **pPPSBuf,
mfxU16 *pnSPSBuf, mfxU16 *pnPPSBuf)
{
*pSPSBuf = m_SPSBuffer;
*pPPSBuf = m_PPSBuffer;
*pnSPSBuf = m_nSPSBufferSize;
*pnPPSBuf = m_nPPSBufferSize;
}
mfxStatus QSV_Encoder_Internal::InitBitstream()
{
m_nTaskPool = m_parameter.AsyncDepth;
m_nFirstSyncTask = 0;
m_pTaskPool = new Task[m_nTaskPool];
memset(m_pTaskPool, 0, sizeof(Task) * m_nTaskPool);
for (int i = 0; i < m_nTaskPool; i++) {
m_pTaskPool[i].mfxBS.MaxLength =
m_parameter.mfx.BufferSizeInKB * 1000;
m_pTaskPool[i].mfxBS.Data =
new mfxU8[m_pTaskPool[i].mfxBS.MaxLength];
m_pTaskPool[i].mfxBS.DataOffset = 0;
m_pTaskPool[i].mfxBS.DataLength = 0;
MSDK_CHECK_POINTER(m_pTaskPool[i].mfxBS.Data,
MFX_ERR_MEMORY_ALLOC);
}
memset(&m_outBitstream, 0, sizeof(mfxBitstream));
m_outBitstream.MaxLength = m_parameter.mfx.BufferSizeInKB * 1000;
m_outBitstream.Data = new mfxU8[m_outBitstream.MaxLength];
m_outBitstream.DataOffset = 0;
m_outBitstream.DataLength = 0;
blog(LOG_INFO, "\tm_nTaskPool: %d", m_nTaskPool);
return MFX_ERR_NONE;
}
mfxStatus QSV_Encoder_Internal::LoadNV12(mfxFrameSurface1 *pSurface,
uint8_t *pDataY, uint8_t *pDataUV, uint32_t strideY,
uint32_t strideUV)
{
mfxU16 w, h, i, pitch;
mfxU8* ptr;
mfxFrameInfo* pInfo = &pSurface->Info;
mfxFrameData* pData = &pSurface->Data;
if (pInfo->CropH > 0 && pInfo->CropW > 0)
{
w = pInfo->CropW;
h = pInfo->CropH;
}
else
{
w = pInfo->Width;
h = pInfo->Height;
}
pitch = pData->Pitch;
ptr = pData->Y + pInfo->CropX + pInfo->CropY * pData->Pitch;
// load Y plane
for (i = 0; i < h; i++)
memcpy(ptr + i * pitch, pDataY + i * strideY, w);
// load UV plane
h /= 2;
ptr = pData->UV + pInfo->CropX + (pInfo->CropY / 2) * pitch;
for (i = 0; i < h; i++)
memcpy(ptr + i * pitch, pDataUV + i * strideUV, w);
return MFX_ERR_NONE;
}
int QSV_Encoder_Internal::GetFreeTaskIndex(Task* pTaskPool, mfxU16 nPoolSize)
{
if (pTaskPool)
for (int i = 0; i < nPoolSize; i++)
if (!pTaskPool[i].syncp)
return i;
return MFX_ERR_NOT_FOUND;
}
mfxStatus QSV_Encoder_Internal::Encode(uint64_t ts, uint8_t *pDataY,
uint8_t *pDataUV, uint32_t strideY, uint32_t strideUV,
mfxBitstream **pBS)
{
mfxStatus sts = MFX_ERR_NONE;
*pBS = NULL;
int nTaskIdx = GetFreeTaskIndex(m_pTaskPool, m_nTaskPool);
#if 0
info("MSDK Encode:\n"
"\tTaskIndex: %d",
nTaskIdx);
#endif
int nSurfIdx = GetFreeSurfaceIndex(m_pmfxSurfaces, m_nSurfNum);
#if 0
info("MSDK Encode:\n"
"\tnSurfIdx: %d",
nSurfIdx);
#endif
while (MFX_ERR_NOT_FOUND == nTaskIdx || MFX_ERR_NOT_FOUND == nSurfIdx) {
// No more free tasks or surfaces, need to sync
sts = m_session.SyncOperation(m_pTaskPool[m_nFirstSyncTask].syncp,
60000);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
mfxU8 *pTemp = m_outBitstream.Data;
memcpy(&m_outBitstream, &m_pTaskPool[m_nFirstSyncTask].mfxBS,
sizeof(mfxBitstream));
m_pTaskPool[m_nFirstSyncTask].mfxBS.Data = pTemp;
m_pTaskPool[m_nFirstSyncTask].mfxBS.DataLength = 0;
m_pTaskPool[m_nFirstSyncTask].mfxBS.DataOffset = 0;
m_pTaskPool[m_nFirstSyncTask].syncp = NULL;
nTaskIdx = m_nFirstSyncTask;
m_nFirstSyncTask = (m_nFirstSyncTask + 1) % m_nTaskPool;
*pBS = &m_outBitstream;
#if 0
info("MSDK Encode:\n"
"\tnew FirstSyncTask: %d\n"
"\tTaskIndex: %d",
m_nFirstSyncTask,
nTaskIdx);
#endif
nSurfIdx = GetFreeSurfaceIndex(m_pmfxSurfaces, m_nSurfNum);
#if 0
info("MSDK Encode:\n"
"\tnSurfIdx: %d",
nSurfIdx);
#endif
}
mfxFrameSurface1 *pSurface = m_pmfxSurfaces[nSurfIdx];
if (m_bUseD3D11)
sts = m_mfxAllocator.Lock(m_mfxAllocator.pthis,
pSurface->Data.MemId, &(pSurface->Data));
sts = LoadNV12(pSurface, pDataY, pDataUV, strideY, strideUV);
pSurface->Data.TimeStamp = ts;
if (m_bUseD3D11)
sts = m_mfxAllocator.Unlock(m_mfxAllocator.pthis,
pSurface->Data.MemId, &(pSurface->Data));
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
for (;;) {
// Encode a frame asychronously (returns immediately)
sts = m_pmfxENC->EncodeFrameAsync(NULL, pSurface,
&m_pTaskPool[nTaskIdx].mfxBS,
&m_pTaskPool[nTaskIdx].syncp);
if (MFX_ERR_NONE < sts && !m_pTaskPool[nTaskIdx].syncp) {
// Repeat the call if warning and no output
if (MFX_WRN_DEVICE_BUSY == sts)
MSDK_SLEEP(1); // Wait if device is busy, then repeat the same call
} else if (MFX_ERR_NONE < sts && m_pTaskPool[nTaskIdx].syncp) {
sts = MFX_ERR_NONE; // Ignore warnings if output is available
break;
} else if (MFX_ERR_NOT_ENOUGH_BUFFER == sts) {
// Allocate more bitstream buffer memory here if needed...
break;
} else
break;
}
return sts;
}
mfxStatus QSV_Encoder_Internal::Drain()
{
mfxStatus sts = MFX_ERR_NONE;
while (m_pTaskPool[m_nFirstSyncTask].syncp) {
sts = m_session.SyncOperation(m_pTaskPool[m_nFirstSyncTask].syncp, 60000);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
m_pTaskPool[m_nFirstSyncTask].syncp = NULL;
m_nFirstSyncTask = (m_nFirstSyncTask + 1) % m_nTaskPool;
}
return sts;
}
mfxStatus QSV_Encoder_Internal::ClearData()
{
mfxStatus sts = MFX_ERR_NONE;
sts = Drain();
sts = m_pmfxENC->Close();
if (m_bUseD3D11)
m_mfxAllocator.Free(m_mfxAllocator.pthis, &m_mfxResponse);
for (int i = 0; i < m_nSurfNum; i++) {
if (!m_bUseD3D11)
delete m_pmfxSurfaces[i]->Data.Y;
delete m_pmfxSurfaces[i];
}
MSDK_SAFE_DELETE_ARRAY(m_pmfxSurfaces);
for (int i = 0; i < m_nTaskPool; i++)
delete m_pTaskPool[i].mfxBS.Data;
MSDK_SAFE_DELETE_ARRAY(m_pTaskPool);
delete m_outBitstream.Data;
if (m_pmfxENC != NULL) {
delete m_pmfxENC;
m_pmfxENC = NULL;
}
if (m_bUseD3D11)
Release();
m_session.Close();
return sts;
}
mfxStatus QSV_Encoder_Internal::Reset(qsv_param_t *pParams)
{
mfxStatus sts = ClearData();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
sts = Open(pParams);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
return sts;
}

112
plugins/obs-qsv11/QSV_Encoder_Internal.h
View file

@ -1,112 +0,0 @@
/*
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright(c) Oct. 2015 Intel Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program 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
General Public License for more details.
Contact Information:
Seung-Woo Kim, seung-woo.kim@intel.com
705 5th Ave S #500, Seattle, WA 98104
BSD LICENSE
Copyright(c) <date> Intel Corporation.
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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"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 THE COPYRIGHT
OWNER OR CONTRIBUTORS 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.
*/
#pragma once
#include "mfxastructures.h"
#include "mfxvideo++.h"
#include "QSV_Encoder.h"
#include "common_utils.h"
class QSV_Encoder_Internal
{
public:
QSV_Encoder_Internal(mfxIMPL& impl, mfxVersion& version);
~QSV_Encoder_Internal();
mfxStatus Open(qsv_param_t * pParams);
void GetSPSPPS(mfxU8 **pSPSBuf, mfxU8 **pPPSBuf,
mfxU16 *pnSPSBuf, mfxU16 *pnPPSBuf);
mfxStatus Encode(uint64_t ts, uint8_t *pDataY, uint8_t *pDataUV,
uint32_t strideY, uint32_t strideUV, mfxBitstream
**pBS);
mfxStatus ClearData();
mfxStatus Reset(qsv_param_t *pParams);
protected:
bool InitParams(qsv_param_t * pParams);
mfxStatus AllocateSurfaces();
mfxStatus GetVideoParam();
mfxStatus InitBitstream();
mfxStatus LoadNV12(mfxFrameSurface1 *pSurface, uint8_t *pDataY,
uint8_t *pDataUV, uint32_t strideY, uint32_t strideUV);
mfxStatus Drain();
int GetFreeTaskIndex(Task* pTaskPool, mfxU16 nPoolSize);
private:
mfxIMPL m_impl;
mfxVersion m_ver;
MFXVideoSession m_session;
mfxFrameAllocator m_mfxAllocator;
mfxVideoParam m_mfxEncParams;
mfxFrameAllocResponse m_mfxResponse;
mfxFrameSurface1** m_pmfxSurfaces;
mfxU16 m_nSurfNum;
MFXVideoENCODE* m_pmfxENC;
mfxU8 m_SPSBuffer[100];
mfxU8 m_PPSBuffer[100];
mfxU16 m_nSPSBufferSize;
mfxU16 m_nPPSBufferSize;
mfxVideoParam m_parameter;
mfxExtCodingOption2 m_co2;
mfxExtCodingOption m_co;
mfxU16 m_nTaskPool;
Task* m_pTaskPool;
int m_nTaskIdx;
int m_nFirstSyncTask;
mfxBitstream m_outBitstream;
bool m_bIsWindows8OrGreater;
bool m_bUseD3D11;
};

19
plugins/obs-qsv11/bits/linux_defs.h
View file

@ -1,19 +0,0 @@
/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#define MSDK_FOPEN(FH, FN, M) { FH=fopen(FN,M); }
#define MSDK_SLEEP(X) { usleep(1000*(X)); }
typedef timespec mfxTime;

16
plugins/obs-qsv11/bits/windows_defs.h
View file

@ -1,16 +0,0 @@
/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#include <windows.h>
#define MSDK_FOPEN(FH, FN, M) { fopen_s(&FH, FN, M); }
#define MSDK_SLEEP(X) { Sleep(X); }
typedef LARGE_INTEGER mfxTime;

487
plugins/obs-qsv11/common_directx11.cpp
View file

@ -1,487 +0,0 @@
/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#include "common_directx11.h"
#include<map>
ID3D11Device* g_pD3D11Device;
ID3D11DeviceContext* g_pD3D11Ctx;
IDXGIFactory2* g_pDXGIFactory;
IDXGIAdapter* g_pAdapter;
std::map<mfxMemId*, mfxHDL> allocResponses;
std::map<mfxHDL, mfxFrameAllocResponse> allocDecodeResponses;
std::map<mfxHDL, int> allocDecodeRefCount;
typedef struct {
mfxMemId memId;
mfxMemId memIdStage;
mfxU16 rw;
} CustomMemId;
const struct {
mfxIMPL impl; // actual implementation
mfxU32 adapterID; // device adapter number
} implTypes[] = {
{MFX_IMPL_HARDWARE, 0},
{MFX_IMPL_HARDWARE2, 1},
{MFX_IMPL_HARDWARE3, 2},
{MFX_IMPL_HARDWARE4, 3}
};
// =================================================================
// DirectX functionality required to manage DX11 device and surfaces
//
IDXGIAdapter* GetIntelDeviceAdapterHandle(mfxSession session)
{
mfxU32 adapterNum = 0;
mfxIMPL impl;
MFXQueryIMPL(session, &impl);
mfxIMPL baseImpl = MFX_IMPL_BASETYPE(impl); // Extract Media SDK base implementation type
// get corresponding adapter number
for (mfxU8 i = 0; i < sizeof(implTypes)/sizeof(implTypes[0]); i++) {
if (implTypes[i].impl == baseImpl) {
adapterNum = implTypes[i].adapterID;
break;
}
}
HRESULT hres = CreateDXGIFactory(__uuidof(IDXGIFactory2), (void**)(&g_pDXGIFactory) );
if (FAILED(hres)) return NULL;
IDXGIAdapter* adapter;
hres = g_pDXGIFactory->EnumAdapters(adapterNum, &adapter);
if (FAILED(hres)) return NULL;
return adapter;
}
// Create HW device context
mfxStatus CreateHWDevice(mfxSession session, mfxHDL* deviceHandle, HWND hWnd, bool bCreateSharedHandles)
{
//Note: not using bCreateSharedHandles for DX11 -- for API consistency only
hWnd; // Window handle not required by DX11 since we do not showcase rendering.
bCreateSharedHandles; // For rendering, not used here. Just for consistencies sake.
HRESULT hres = S_OK;
static D3D_FEATURE_LEVEL FeatureLevels[] = {
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0
};
D3D_FEATURE_LEVEL pFeatureLevelsOut;
g_pAdapter = GetIntelDeviceAdapterHandle(session);
if (NULL == g_pAdapter)
return MFX_ERR_DEVICE_FAILED;
UINT dxFlags = 0;
//UINT dxFlags = D3D11_CREATE_DEVICE_DEBUG;
hres = D3D11CreateDevice( g_pAdapter,
D3D_DRIVER_TYPE_UNKNOWN,
NULL,
dxFlags,
FeatureLevels,
(sizeof(FeatureLevels) / sizeof(FeatureLevels[0])),
D3D11_SDK_VERSION,
&g_pD3D11Device,
&pFeatureLevelsOut,
&g_pD3D11Ctx);
if (FAILED(hres))
return MFX_ERR_DEVICE_FAILED;
// turn on multithreading for the DX11 context
CComQIPtr<ID3D10Multithread> p_mt(g_pD3D11Ctx);
if (p_mt)
p_mt->SetMultithreadProtected(true);
else
return MFX_ERR_DEVICE_FAILED;
*deviceHandle = (mfxHDL)g_pD3D11Device;
return MFX_ERR_NONE;
}
void SetHWDeviceContext(CComPtr<ID3D11DeviceContext> devCtx)
{
g_pD3D11Ctx = devCtx;
devCtx->GetDevice(&g_pD3D11Device);
}
// Free HW device context
void CleanupHWDevice()
{
if (g_pAdapter)
{
g_pAdapter->Release();
g_pAdapter = NULL;
}
if (g_pD3D11Device)
{
g_pD3D11Device->Release();
g_pD3D11Device = NULL;
}
if (g_pD3D11Ctx)
{
g_pD3D11Ctx->Release();
g_pD3D11Ctx = NULL;
}
if (g_pDXGIFactory)
{
g_pDXGIFactory->Release();
g_pDXGIFactory = NULL;
}
}
CComPtr<ID3D11DeviceContext> GetHWDeviceContext()
{
return g_pD3D11Ctx;
}
/* (Hugh) Functions currently unused */
#if 0
void ClearYUVSurfaceD3D(mfxMemId memId)
{
// TBD
}
void ClearRGBSurfaceD3D(mfxMemId memId)
{
// TBD
}
#endif
//
// Intel Media SDK memory allocator entrypoints....
//
mfxStatus _simple_alloc(mfxFrameAllocRequest* request, mfxFrameAllocResponse* response)
{
HRESULT hRes;
// Determine surface format
DXGI_FORMAT format;
if (MFX_FOURCC_NV12 == request->Info.FourCC)
format = DXGI_FORMAT_NV12;
else if (MFX_FOURCC_RGB4 == request->Info.FourCC)
format = DXGI_FORMAT_B8G8R8A8_UNORM;
else if (MFX_FOURCC_YUY2== request->Info.FourCC)
format = DXGI_FORMAT_YUY2;
else if (MFX_FOURCC_P8 == request->Info.FourCC ) //|| MFX_FOURCC_P8_TEXTURE == request->Info.FourCC
format = DXGI_FORMAT_P8;
else
format = DXGI_FORMAT_UNKNOWN;
if (DXGI_FORMAT_UNKNOWN == format)
return MFX_ERR_UNSUPPORTED;
// Allocate custom container to keep texture and stage buffers for each surface
// Container also stores the intended read and/or write operation.
CustomMemId** mids = (CustomMemId**)calloc(request->NumFrameSuggested, sizeof(CustomMemId*));
if (!mids) return MFX_ERR_MEMORY_ALLOC;
for (int i=0; i<request->NumFrameSuggested; i++) {
mids[i] = (CustomMemId*)calloc(1, sizeof(CustomMemId));
if (!mids[i]) {
return MFX_ERR_MEMORY_ALLOC;
}
mids[i]->rw = request->Type & 0xF000; // Set intended read/write operation
}
request->Type = request->Type & 0x0FFF;
// because P8 data (bitstream) for h264 encoder should be allocated by CreateBuffer()
// but P8 data (MBData) for MPEG2 encoder should be allocated by CreateTexture2D()
if (request->Info.FourCC == MFX_FOURCC_P8) {
D3D11_BUFFER_DESC desc = { 0 };
if (!request->NumFrameSuggested) return MFX_ERR_MEMORY_ALLOC;
desc.ByteWidth = request->Info.Width * request->Info.Height;
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
ID3D11Buffer* buffer = 0;
hRes = g_pD3D11Device->CreateBuffer(&desc, 0, &buffer);
if (FAILED(hRes))
return MFX_ERR_MEMORY_ALLOC;
mids[0]->memId = reinterpret_cast<ID3D11Texture2D*>(buffer);
} else {
D3D11_TEXTURE2D_DESC desc = {0};
desc.Width = request->Info.Width;
desc.Height = request->Info.Height;
desc.MipLevels = 1;
desc.ArraySize = 1; // number of subresources is 1 in this case
desc.Format = format;
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_DECODER;
desc.MiscFlags = 0;
//desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
if ( (MFX_MEMTYPE_FROM_VPPIN & request->Type) &&
(DXGI_FORMAT_B8G8R8A8_UNORM == desc.Format) ) {
desc.BindFlags = D3D11_BIND_RENDER_TARGET;
if (desc.ArraySize > 2)
return MFX_ERR_MEMORY_ALLOC;
}
if ( (MFX_MEMTYPE_FROM_VPPOUT & request->Type) ||
(MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET & request->Type)) {
desc.BindFlags = D3D11_BIND_RENDER_TARGET;
if (desc.ArraySize > 2)
return MFX_ERR_MEMORY_ALLOC;
}
if ( DXGI_FORMAT_P8 == desc.Format )
desc.BindFlags = 0;
ID3D11Texture2D* pTexture2D;
// Create surface textures
for (size_t i = 0; i < request->NumFrameSuggested / desc.ArraySize; i++) {
hRes = g_pD3D11Device->CreateTexture2D(&desc, NULL, &pTexture2D);
if (FAILED(hRes))
return MFX_ERR_MEMORY_ALLOC;
mids[i]->memId = pTexture2D;
}
desc.ArraySize = 1;
desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;// | D3D11_CPU_ACCESS_WRITE;
desc.BindFlags = 0;
desc.MiscFlags = 0;
//desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
// Create surface staging textures
for (size_t i = 0; i < request->NumFrameSuggested; i++) {
hRes = g_pD3D11Device->CreateTexture2D(&desc, NULL, &pTexture2D);
if (FAILED(hRes))
return MFX_ERR_MEMORY_ALLOC;
mids[i]->memIdStage = pTexture2D;
}
}
response->mids = (mfxMemId*)mids;
response->NumFrameActual = request->NumFrameSuggested;
return MFX_ERR_NONE;
}
mfxStatus simple_alloc(mfxHDL pthis, mfxFrameAllocRequest* request, mfxFrameAllocResponse* response)
{
mfxStatus sts = MFX_ERR_NONE;
if (request->Type & MFX_MEMTYPE_SYSTEM_MEMORY)
return MFX_ERR_UNSUPPORTED;
if (allocDecodeResponses.find(pthis) != allocDecodeResponses.end() &&
MFX_MEMTYPE_EXTERNAL_FRAME & request->Type &&
MFX_MEMTYPE_FROM_DECODE & request->Type) {
// Memory for this request was already allocated during manual allocation stage. Return saved response
// When decode acceleration device (DXVA) is created it requires a list of d3d surfaces to be passed.
// Therefore Media SDK will ask for the surface info/mids again at Init() stage, thus requiring us to return the saved response
// (No such restriction applies to Encode or VPP)
*response = allocDecodeResponses[pthis];
allocDecodeRefCount[pthis]++;
} else {
sts = _simple_alloc(request, response);
if (MFX_ERR_NONE == sts) {
if ( MFX_MEMTYPE_EXTERNAL_FRAME & request->Type &&
MFX_MEMTYPE_FROM_DECODE & request->Type) {
// Decode alloc response handling
allocDecodeResponses[pthis] = *response;
allocDecodeRefCount[pthis]++;
} else {
// Encode and VPP alloc response handling
allocResponses[response->mids] = pthis;
}
}
}
return sts;
}
mfxStatus simple_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData* ptr)
{
pthis; // To suppress warning for this unused parameter
HRESULT hRes = S_OK;
D3D11_TEXTURE2D_DESC desc = {0};
D3D11_MAPPED_SUBRESOURCE lockedRect = {0};
CustomMemId* memId = (CustomMemId*)mid;
ID3D11Texture2D* pSurface = (ID3D11Texture2D*)memId->memId;
ID3D11Texture2D* pStage = (ID3D11Texture2D*)memId->memIdStage;
D3D11_MAP mapType = D3D11_MAP_READ;
UINT mapFlags = D3D11_MAP_FLAG_DO_NOT_WAIT;
if (NULL == pStage) {
hRes = g_pD3D11Ctx->Map(pSurface, 0, mapType, mapFlags, &lockedRect);
desc.Format = DXGI_FORMAT_P8;
} else {
pSurface->GetDesc(&desc);
// copy data only in case of user wants o read from stored surface
if (memId->rw & WILL_READ)
g_pD3D11Ctx->CopySubresourceRegion(pStage, 0, 0, 0, 0, pSurface, 0, NULL);
do {
hRes = g_pD3D11Ctx->Map(pStage, 0, mapType, mapFlags, &lockedRect);
if (S_OK != hRes && DXGI_ERROR_WAS_STILL_DRAWING != hRes)
return MFX_ERR_LOCK_MEMORY;
} while (DXGI_ERROR_WAS_STILL_DRAWING == hRes);
}
if (FAILED(hRes))
return MFX_ERR_LOCK_MEMORY;
switch (desc.Format) {
case DXGI_FORMAT_NV12:
ptr->Pitch = (mfxU16)lockedRect.RowPitch;
ptr->Y = (mfxU8*)lockedRect.pData;
ptr->U = (mfxU8*)lockedRect.pData + desc.Height * lockedRect.RowPitch;
ptr->V = ptr->U + 1;
break;
case DXGI_FORMAT_B8G8R8A8_UNORM :
ptr->Pitch = (mfxU16)lockedRect.RowPitch;
ptr->B = (mfxU8*)lockedRect.pData;
ptr->G = ptr->B + 1;
ptr->R = ptr->B + 2;
ptr->A = ptr->B + 3;
break;
case DXGI_FORMAT_YUY2:
ptr->Pitch = (mfxU16)lockedRect.RowPitch;
ptr->Y = (mfxU8*)lockedRect.pData;
ptr->U = ptr->Y + 1;
ptr->V = ptr->Y + 3;
break;
case DXGI_FORMAT_P8 :
ptr->Pitch = (mfxU16)lockedRect.RowPitch;
ptr->Y = (mfxU8*)lockedRect.pData;
ptr->U = 0;
ptr->V = 0;
break;
default:
return MFX_ERR_LOCK_MEMORY;
}
return MFX_ERR_NONE;
}
mfxStatus simple_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData* ptr)
{
pthis; // To suppress warning for this unused parameter
CustomMemId* memId = (CustomMemId*)mid;
ID3D11Texture2D* pSurface = (ID3D11Texture2D*)memId->memId;
ID3D11Texture2D* pStage = (ID3D11Texture2D*)memId->memIdStage;
if (NULL == pStage) {
g_pD3D11Ctx->Unmap(pSurface, 0);
} else {
g_pD3D11Ctx->Unmap(pStage, 0);
// copy data only in case of user wants to write to stored surface
if (memId->rw & WILL_WRITE)
g_pD3D11Ctx->CopySubresourceRegion(pSurface, 0, 0, 0, 0, pStage, 0, NULL);
}
if (ptr) {
ptr->Pitch=0;
ptr->U=ptr->V=ptr->Y=0;
ptr->A=ptr->R=ptr->G=ptr->B=0;
}
return MFX_ERR_NONE;
}
mfxStatus simple_gethdl(mfxHDL pthis, mfxMemId mid, mfxHDL* handle)
{
pthis; // To suppress warning for this unused parameter
if (NULL == handle)
return MFX_ERR_INVALID_HANDLE;
mfxHDLPair* pPair = (mfxHDLPair*)handle;
CustomMemId* memId = (CustomMemId*)mid;
pPair->first = memId->memId; // surface texture
pPair->second = 0;
return MFX_ERR_NONE;
}
mfxStatus _simple_free(mfxFrameAllocResponse* response)
{
if (response->mids) {
for (mfxU32 i = 0; i < response->NumFrameActual; i++) {
if (response->mids[i]) {
CustomMemId* mid = (CustomMemId*)response->mids[i];
ID3D11Texture2D* pSurface = (ID3D11Texture2D*)mid->memId;
ID3D11Texture2D* pStage = (ID3D11Texture2D*)mid->memIdStage;
if (pSurface)
pSurface->Release();
if (pStage)
pStage->Release();
free(mid);
}
}
free(response->mids);
response->mids = NULL;
}
return MFX_ERR_NONE;
}
mfxStatus simple_free(mfxHDL pthis, mfxFrameAllocResponse* response)
{
if (NULL == response)
return MFX_ERR_NULL_PTR;
if (allocResponses.find(response->mids) == allocResponses.end()) {
// Decode free response handling
if (--allocDecodeRefCount[pthis] == 0) {
_simple_free(response);
allocDecodeResponses.erase(pthis);
allocDecodeRefCount.erase(pthis);
}
} else {
// Encode and VPP free response handling
allocResponses.erase(response->mids);
_simple_free(response);
}
return MFX_ERR_NONE;
}

39
plugins/obs-qsv11/common_directx11.h
View file

@ -1,39 +0,0 @@
/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#pragma once
#include "common_utils.h"
#include <windows.h>
#include <d3d11.h>
#include <dxgi1_2.h>
#include <atlbase.h>
#define DEVICE_MGR_TYPE MFX_HANDLE_D3D11_DEVICE
// =================================================================
// DirectX functionality required to manage D3D surfaces
//
// Create DirectX 11 device context
// - Required when using D3D surfaces.
// - D3D Device created and handed to Intel Media SDK
// - Intel graphics device adapter will be determined automatically (does not have to be primary),
// but with the following caveats:
// - Device must be active (but monitor does NOT have to be attached)
// - Device must be enabled in BIOS. Required for the case when used together with a discrete graphics card
// - For switchable graphics solutions (mobile) make sure that Intel device is the active device
mfxStatus CreateHWDevice(mfxSession session, mfxHDL* deviceHandle, HWND hWnd, bool bCreateSharedHandles);
void CleanupHWDevice();
void SetHWDeviceContext(CComPtr<ID3D11DeviceContext> devCtx);
CComPtr<ID3D11DeviceContext> GetHWDeviceContext();
void ClearYUVSurfaceD3D(mfxMemId memId);
void ClearRGBSurfaceD3D(mfxMemId memId);

306
plugins/obs-qsv11/common_utils.cpp
View file

@ -1,306 +0,0 @@
/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#include "common_utils.h"
// =================================================================
// Utility functions, not directly tied to Intel Media SDK functionality
//
void PrintErrString(int err,const char* filestr,int line)
{
switch (err) {
case 0:
printf("\n No error.\n");
break;
case -1:
printf("\n Unknown error: %s %d\n",filestr,line);
break;
case -2:
printf("\n Null pointer. Check filename/path + permissions? %s %d\n",filestr,line);
break;
case -3:
printf("\n Unsupported feature/library load error. %s %d\n",filestr,line);
break;
case -4:
printf("\n Could not allocate memory. %s %d\n",filestr,line);
break;
case -5:
printf("\n Insufficient IO buffers. %s %d\n",filestr,line);
break;
case -6:
printf("\n Invalid handle. %s %d\n",filestr,line);
break;
case -7:
printf("\n Memory lock failure. %s %d\n",filestr,line);
break;
case -8:
printf("\n Function called before initialization. %s %d\n",filestr,line);
break;
case -9:
printf("\n Specified object not found. %s %d\n",filestr,line);
break;
case -10:
printf("\n More input data expected. %s %d\n",filestr,line);
break;
case -11:
printf("\n More output surfaces expected. %s %d\n",filestr,line);
break;
case -12:
printf("\n Operation aborted. %s %d\n",filestr,line);
break;
case -13:
printf("\n HW device lost. %s %d\n",filestr,line);
break;
case -14:
printf("\n Incompatible video parameters. %s %d\n",filestr,line);
break;
case -15:
printf("\n Invalid video parameters. %s %d\n",filestr,line);
break;
case -16:
printf("\n Undefined behavior. %s %d\n",filestr,line);
break;
case -17:
printf("\n Device operation failure. %s %d\n",filestr,line);
break;
case -18:
printf("\n More bitstream data expected. %s %d\n",filestr,line);
break;
case -19:
printf("\n Incompatible audio parameters. %s %d\n",filestr,line);
break;
case -20:
printf("\n Invalid audio parameters. %s %d\n",filestr,line);
break;
default:
printf("\nError code %d,\t%s\t%d\n\n", err, filestr, line);
}
}
mfxStatus ReadPlaneData(mfxU16 w, mfxU16 h, mfxU8* buf, mfxU8* ptr,
mfxU16 pitch, mfxU16 offset, FILE* fSource)
{
mfxU32 nBytesRead;
for (mfxU16 i = 0; i < h; i++) {
nBytesRead = (mfxU32) fread(buf, 1, w, fSource);
if (w != nBytesRead)
return MFX_ERR_MORE_DATA;
for (mfxU16 j = 0; j < w; j++)
ptr[i * pitch + j * 2 + offset] = buf[j];
}
return MFX_ERR_NONE;
}
mfxStatus LoadRawFrame(mfxFrameSurface1* pSurface, FILE* fSource)
{
if (!fSource) {
// Simulate instantaneous access to 1000 "empty" frames.
static int frameCount = 0;
if (1000 == frameCount++)
return MFX_ERR_MORE_DATA;
else
return MFX_ERR_NONE;
}
mfxStatus sts = MFX_ERR_NONE;
mfxU32 nBytesRead;
mfxU16 w, h, i, pitch;
mfxU8* ptr;
mfxFrameInfo* pInfo = &pSurface->Info;
mfxFrameData* pData = &pSurface->Data;
if (pInfo->CropH > 0 && pInfo->CropW > 0) {
w = pInfo->CropW;
h = pInfo->CropH;
} else {
w = pInfo->Width;
h = pInfo->Height;
}
pitch = pData->Pitch;
ptr = pData->Y + pInfo->CropX + pInfo->CropY * pData->Pitch;
// read luminance plane
for (i = 0; i < h; i++) {
nBytesRead = (mfxU32) fread(ptr + i * pitch, 1, w, fSource);
if (w != nBytesRead)
return MFX_ERR_MORE_DATA;
}
mfxU8 buf[2048]; // maximum supported chroma width for nv12
w /= 2;
h /= 2;
ptr = pData->UV + pInfo->CropX + (pInfo->CropY / 2) * pitch;
if (w > 2048)
return MFX_ERR_UNSUPPORTED;
// load U
sts = ReadPlaneData(w, h, buf, ptr, pitch, 0, fSource);
if (MFX_ERR_NONE != sts)
return sts;
// load V
ReadPlaneData(w, h, buf, ptr, pitch, 1, fSource);
if (MFX_ERR_NONE != sts)
return sts;
return MFX_ERR_NONE;
}
mfxStatus LoadRawRGBFrame(mfxFrameSurface1* pSurface, FILE* fSource)
{
if (!fSource) {
// Simulate instantaneous access to 1000 "empty" frames.
static int frameCount = 0;
if (1000 == frameCount++)
return MFX_ERR_MORE_DATA;
else
return MFX_ERR_NONE;
}
size_t nBytesRead;
mfxU16 w, h;
mfxFrameInfo* pInfo = &pSurface->Info;
if (pInfo->CropH > 0 && pInfo->CropW > 0) {
w = pInfo->CropW;
h = pInfo->CropH;
} else {
w = pInfo->Width;
h = pInfo->Height;
}
for (mfxU16 i = 0; i < h; i++) {
nBytesRead = fread(pSurface->Data.B + i * pSurface->Data.Pitch,
1, w * 4, fSource);
if ((size_t)(w * 4) != nBytesRead)
return MFX_ERR_MORE_DATA;
}
return MFX_ERR_NONE;
}
mfxStatus WriteBitStreamFrame(mfxBitstream* pMfxBitstream, FILE* fSink)
{
mfxU32 nBytesWritten =
(mfxU32) fwrite(pMfxBitstream->Data + pMfxBitstream->DataOffset, 1,
pMfxBitstream->DataLength, fSink);
if (nBytesWritten != pMfxBitstream->DataLength)
return MFX_ERR_UNDEFINED_BEHAVIOR;
pMfxBitstream->DataLength = 0;
return MFX_ERR_NONE;
}
mfxStatus ReadBitStreamData(mfxBitstream* pBS, FILE* fSource)
{
memmove(pBS->Data, pBS->Data + pBS->DataOffset, pBS->DataLength);
pBS->DataOffset = 0;
mfxU32 nBytesRead = (mfxU32) fread(pBS->Data + pBS->DataLength, 1,
pBS->MaxLength - pBS->DataLength,
fSource);
if (0 == nBytesRead)
return MFX_ERR_MORE_DATA;
pBS->DataLength += nBytesRead;
return MFX_ERR_NONE;
}
mfxStatus WriteSection(mfxU8* plane, mfxU16 factor, mfxU16 chunksize,
mfxFrameInfo* pInfo, mfxFrameData* pData, mfxU32 i,
mfxU32 j, FILE* fSink)
{
if (chunksize !=
fwrite(plane +
(pInfo->CropY * pData->Pitch / factor + pInfo->CropX) +
i * pData->Pitch + j, 1, chunksize, fSink))
return MFX_ERR_UNDEFINED_BEHAVIOR;
return MFX_ERR_NONE;
}
mfxStatus WriteRawFrame(mfxFrameSurface1* pSurface, FILE* fSink)
{
mfxFrameInfo* pInfo = &pSurface->Info;
mfxFrameData* pData = &pSurface->Data;
mfxU32 i, j, h, w;
mfxStatus sts = MFX_ERR_NONE;
for (i = 0; i < pInfo->CropH; i++)
sts =
WriteSection(pData->Y, 1, pInfo->CropW, pInfo, pData, i, 0,
fSink);
h = pInfo->CropH / 2;
w = pInfo->CropW;
for (i = 0; i < h; i++)
for (j = 0; j < w; j += 2)
sts =
WriteSection(pData->UV, 2, 1, pInfo, pData, i, j,
fSink);
for (i = 0; i < h; i++)
for (j = 1; j < w; j += 2)
sts =
WriteSection(pData->UV, 2, 1, pInfo, pData, i, j,
fSink);
return sts;
}
int GetFreeTaskIndex(Task* pTaskPool, mfxU16 nPoolSize)
{
if (pTaskPool)
for (int i = 0; i < nPoolSize; i++)
if (!pTaskPool[i].syncp)
return i;
return MFX_ERR_NOT_FOUND;
}
void ClearYUVSurfaceSysMem(mfxFrameSurface1* pSfc, mfxU16 width, mfxU16 height)
{
// In case simulating direct access to frames we initialize the allocated surfaces with default pattern
memset(pSfc->Data.Y, 100, width * height); // Y plane
memset(pSfc->Data.U, 50, (width * height)/2); // UV plane
}
// Get free raw frame surface
int GetFreeSurfaceIndex(mfxFrameSurface1** pSurfacesPool, mfxU16 nPoolSize)
{
if (pSurfacesPool)
for (mfxU16 i = 0; i < nPoolSize; i++)
if (0 == pSurfacesPool[i]->Data.Locked)
return i;
return MFX_ERR_NOT_FOUND;
}
char mfxFrameTypeString(mfxU16 FrameType)
{
mfxU8 FrameTmp = FrameType & 0xF;
char FrameTypeOut;
switch (FrameTmp) {
case MFX_FRAMETYPE_I:
FrameTypeOut = 'I';
break;
case MFX_FRAMETYPE_P:
FrameTypeOut = 'P';
break;
case MFX_FRAMETYPE_B:
FrameTypeOut = 'B';
break;
default:
FrameTypeOut = '*';
}
return FrameTypeOut;
}

109
plugins/obs-qsv11/common_utils.h
View file

@ -1,109 +0,0 @@
/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#pragma once
#include <stdio.h>
#include "mfxvideo++.h"
// =================================================================
// OS-specific definitions of types, macro, etc...
// The following should be defined:
// - mfxTime
// - MSDK_FOPEN
// - MSDK_SLEEP
#if defined(_WIN32) || defined(_WIN64)
#include "bits/windows_defs.h"
#elif defined(__linux__)
#include "bits/linux_defs.h"
#endif
// =================================================================
// Helper macro definitions...
#define MSDK_PRINT_RET_MSG(ERR) {PrintErrString(ERR, __FILE__, __LINE__);}
#define MSDK_CHECK_RESULT(P, X, ERR) {if ((X) > (P)) {MSDK_PRINT_RET_MSG(ERR); return ERR;}}
#define MSDK_CHECK_POINTER(P, ERR) {if (!(P)) {MSDK_PRINT_RET_MSG(ERR); return ERR;}}
#define MSDK_CHECK_ERROR(P, X, ERR) {if ((X) == (P)) {MSDK_PRINT_RET_MSG(ERR); return ERR;}}
#define MSDK_IGNORE_MFX_STS(P, X) {if ((X) == (P)) {P = MFX_ERR_NONE;}}
#define MSDK_BREAK_ON_ERROR(P) {if (MFX_ERR_NONE != (P)) break;}
#define MSDK_SAFE_DELETE_ARRAY(P) {if (P) {delete[] P; P = NULL;}}
#define MSDK_ALIGN32(X) (((mfxU32)((X)+31)) & (~ (mfxU32)31))
#define MSDK_ALIGN16(value) (((value + 15) >> 4) << 4)
#define MSDK_SAFE_RELEASE(X) {if (X) { X->Release(); X = NULL; }}
#define MSDK_MAX(A, B) (((A) > (B)) ? (A) : (B))
// Usage of the following two macros are only required for certain Windows DirectX11 use cases
#define WILL_READ 0x1000
#define WILL_WRITE 0x2000
// =================================================================
// Intel Media SDK memory allocator entrypoints....
// Implementation of this functions is OS/Memory type specific.
mfxStatus simple_alloc(mfxHDL pthis, mfxFrameAllocRequest* request, mfxFrameAllocResponse* response);
mfxStatus simple_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData* ptr);
mfxStatus simple_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData* ptr);
mfxStatus simple_gethdl(mfxHDL pthis, mfxMemId mid, mfxHDL* handle);
mfxStatus simple_free(mfxHDL pthis, mfxFrameAllocResponse* response);
// =================================================================
// Utility functions, not directly tied to Media SDK functionality
//
void PrintErrString(int err,const char* filestr,int line);
// LoadRawFrame: Reads raw frame from YUV file (YV12) into NV12 surface
// - YV12 is a more common format for for YUV files than NV12 (therefore the conversion during read and write)
// - For the simulation case (fSource = NULL), the surface is filled with default image data
// LoadRawRGBFrame: Reads raw RGB32 frames from file into RGB32 surface
// - For the simulation case (fSource = NULL), the surface is filled with default image data
mfxStatus LoadRawFrame(mfxFrameSurface1* pSurface, FILE* fSource);
mfxStatus LoadRawRGBFrame(mfxFrameSurface1* pSurface, FILE* fSource);
// Write raw YUV (NV12) surface to YUV (YV12) file
mfxStatus WriteRawFrame(mfxFrameSurface1* pSurface, FILE* fSink);
// Write bit stream data for frame to file
mfxStatus WriteBitStreamFrame(mfxBitstream* pMfxBitstream, FILE* fSink);
// Read bit stream data from file. Stream is read as large chunks (= many frames)
mfxStatus ReadBitStreamData(mfxBitstream* pBS, FILE* fSource);
void ClearYUVSurfaceSysMem(mfxFrameSurface1* pSfc, mfxU16 width, mfxU16 height);
void ClearYUVSurfaceVMem(mfxMemId memId);
void ClearRGBSurfaceVMem(mfxMemId memId);
// Get free raw frame surface
int GetFreeSurfaceIndex(mfxFrameSurface1** pSurfacesPool, mfxU16 nPoolSize);
// For use with asynchronous task management
typedef struct {
mfxBitstream mfxBS;
mfxSyncPoint syncp;
} Task;
// Get free task
int GetFreeTaskIndex(Task* pTaskPool, mfxU16 nPoolSize);
// Initialize Intel Media SDK Session, device/display and memory manager
mfxStatus Initialize(mfxIMPL impl, mfxVersion ver, MFXVideoSession* pSession, mfxFrameAllocator* pmfxAllocator, bool bCreateSharedHandles = false);
// Release resources (device/display)
void Release();
// Convert frame type to string
char mfxFrameTypeString(mfxU16 FrameType);
void mfxGetTime(mfxTime* timestamp);
//void mfxInitTime(); might need this for Windows
double TimeDiffMsec(mfxTime tfinish, mfxTime tstart);

104
plugins/obs-qsv11/common_utils_windows.cpp
View file

@ -1,104 +0,0 @@
/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#include "common_utils.h"
// ATTENTION: If D3D surfaces are used, DX9_D3D or DX11_D3D must be set in project settings or hardcoded here
#ifdef DX9_D3D
#include "common_directx.h"
#elif DX11_D3D
#include "common_directx11.h"
#endif
/* =======================================================
* Windows implementation of OS-specific utility functions
*/
mfxStatus Initialize(mfxIMPL impl, mfxVersion ver, MFXVideoSession* pSession, mfxFrameAllocator* pmfxAllocator, bool bCreateSharedHandles)
{
bCreateSharedHandles; // (Hugh) Currently unused
pmfxAllocator; // (Hugh) Currently unused
mfxStatus sts = MFX_ERR_NONE;
// If mfxFrameAllocator is provided it means we need to setup DirectX device and memory allocator
if (pmfxAllocator) {
// Initialize Intel Media SDK Session
sts = pSession->Init(impl, &ver);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
// Create DirectX device context
mfxHDL deviceHandle;
sts = CreateHWDevice(*pSession, &deviceHandle, NULL, bCreateSharedHandles);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
// Provide device manager to Media SDK
sts = pSession->SetHandle(DEVICE_MGR_TYPE, deviceHandle);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
pmfxAllocator->pthis = *pSession; // We use Media SDK session ID as the allocation identifier
pmfxAllocator->Alloc = simple_alloc;
pmfxAllocator->Free = simple_free;
pmfxAllocator->Lock = simple_lock;
pmfxAllocator->Unlock = simple_unlock;
pmfxAllocator->GetHDL = simple_gethdl;
// Since we are using video memory we must provide Media SDK with an external allocator
sts = pSession->SetFrameAllocator(pmfxAllocator);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
}
else
{
// Initialize Intel Media SDK Session
sts = pSession->Init(impl, &ver);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
}
return sts;
}
void Release()
{
#if defined(DX9_D3D) || defined(DX11_D3D)
CleanupHWDevice();
#endif
}
void mfxGetTime(mfxTime* timestamp)
{
QueryPerformanceCounter(timestamp);
}
double TimeDiffMsec(mfxTime tfinish, mfxTime tstart)
{
static LARGE_INTEGER tFreq = { 0 };
if (!tFreq.QuadPart) QueryPerformanceFrequency(&tFreq);
double freq = (double)tFreq.QuadPart;
return 1000.0 * ((double)tfinish.QuadPart - (double)tstart.QuadPart) / freq;
}
/* (Hugh) Functions currently unused */
#if 0
void ClearYUVSurfaceVMem(mfxMemId memId)
{
#if defined(DX9_D3D) || defined(DX11_D3D)
ClearYUVSurfaceD3D(memId);
#endif
}
void ClearRGBSurfaceVMem(mfxMemId memId)
{
#if defined(DX9_D3D) || defined(DX11_D3D)
ClearRGBSurfaceD3D(memId);
#endif
}
#endif

5
plugins/obs-qsv11/data/locale/ar-SA.ini
View file

@ -1,5 +0,0 @@
Bitrate="معدّل البِت"
KeyframeIntervalSec="الفاصل الزمني لـKeyframe (ثانية, 0=تلقائي)"
Profile="الملف الشخصي"
Accuracy="الدقة"

12
plugins/obs-qsv11/data/locale/ca-ES.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Ús de destí"
Bitrate="Taxa de bits"
MaxBitrate="Taxa de bits màxima"
RateControl="Control de la freqüència"
KeyframeIntervalSec="Interval de fotograma clau (en segons, 0 = automàtic)"
Profile="Perfil"
AsyncDepth="Profunditat d'Async"
Accuracy="Precisió"
Convergence="Convergència"
ICQQuality="Qualitat ICQ"
LookAheadDepth="Profunditat de cerca anticipada"

12
plugins/obs-qsv11/data/locale/cs-CZ.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Cíl použití"
Bitrate="Bitrate"
MaxBitrate="Maximální bitrate"
RateControl="Řízení toku"
KeyframeIntervalSec="Interval klíč. snímků (vteřiny, 0=auto)"
Profile="Profil"
AsyncDepth="Asynchronní hloubka"
Accuracy="Přesnost"
Convergence="Konvergence"
ICQQuality="Kvalita ICQ"
LookAheadDepth="Hloubka dopředné analýzy"

12
plugins/obs-qsv11/data/locale/de-DE.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Zielnutzung"
Bitrate="Bitrate"
MaxBitrate="Max Bitrate"
RateControl="Qualitäts Regulierungsmethode"
KeyframeIntervalSec="Keyframeintervall (Sekunden, 0=auto)"
Profile="Profil"
AsyncDepth="Async Depth"
Accuracy="Genauigkeit"
Convergence="Konvergenz"
ICQQuality="ICQ-Qualität"
LookAheadDepth="Lookahead Depth"

11
plugins/obs-qsv11/data/locale/en-US.ini
View file

@ -1,11 +0,0 @@
TargetUsage="Target Usage"
Bitrate="Bitrate"
MaxBitrate="Max Bitrate"
RateControl="Rate Control"
KeyframeIntervalSec="Keyframe Interval (seconds, 0=auto)"
Profile="Profile"
AsyncDepth="Async Depth"
Accuracy="Accuracy"
Convergence="Convergence"
ICQQuality="ICQ Quality"
LookAheadDepth="Lookahead Depth"

12
plugins/obs-qsv11/data/locale/es-ES.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Uso de destino"
Bitrate="Bitrate"
MaxBitrate="Tasa de bits máxima"
RateControl="Control de la frecuencia"
KeyframeIntervalSec="Intervalo de keyframes (segundos, 0=auto)"
Profile="Perfíl"
AsyncDepth="Profundidad de Async"
Accuracy="Precision"
Convergence="Convergencia"
ICQQuality="Calidad ICQ"
LookAheadDepth="Profundidad de búsqueda anticipada"

12
plugins/obs-qsv11/data/locale/eu-ES.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Xede Erabilpena"
Bitrate="Bitneurria"
MaxBitrate="Geh Bitneurria"
RateControl="Neurri Agintea"
KeyframeIntervalSec="Giltzaframe Tartea (segundu, 0=berez)"
Profile="Profila"
AsyncDepth="Async Sakonera"
Accuracy="Zehaztasuna"
Convergence="Bateratasuna"
ICQQuality="ICQ Ontasuna"
LookAheadDepth="Aurrerabegirako Sakonera"

12
plugins/obs-qsv11/data/locale/fi-FI.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Käyttötarkoitus"
Bitrate="Bitrate"
MaxBitrate="Bitrate-maksimi"
RateControl="Nopeudensäädin"
KeyframeIntervalSec="Keyframe-väli (sec, 0=auto)"
Profile="Profiili"
AsyncDepth="Async-syvyys"
Accuracy="Tarkkus"
Convergence="Suppeneminen"
ICQQuality="ICQ laatu"
LookAheadDepth="Lookadead-syvyys"

12
plugins/obs-qsv11/data/locale/fr-FR.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Utilisation ciblée"
Bitrate="Débit"
MaxBitrate="Débit maximal"
RateControl="Contrôle du débit"
KeyframeIntervalSec="Intervalle d'image-clé (en secondes, 0 = auto)"
Profile="Profil"
AsyncDepth="Profondeur d'asynchronisme"
Accuracy="Précision"
Convergence="Convergence"
ICQQuality="Qualité ICQ"
LookAheadDepth="Profondeur d'anticipation"

2
plugins/obs-qsv11/data/locale/gl-ES.ini
View file

@ -1,2 +0,0 @@
Profile="Perfil"

12
plugins/obs-qsv11/data/locale/hr-HR.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Ciljno zauzeće"
Bitrate="Protok"
MaxBitrate="Maksimalni protok"
RateControl="Kontrola protoka"
KeyframeIntervalSec="Interval ključnih frejmova (sekunde, 0=automatski)"
Profile="Profil"
AsyncDepth="Dubina asinhronizacije"
Accuracy="Preciznost"
Convergence="Konvergencija"
ICQQuality="ICQ kvalitet"
LookAheadDepth="Dubina predviđanja"

12
plugins/obs-qsv11/data/locale/hu-HU.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Felhasználási cél"
Bitrate="Bitráta"
MaxBitrate="Max bitráta"
RateControl="Sebesség Vezérlés"
KeyframeIntervalSec="Kulcsképkocka időköze (másodperc, 0=auto)"
Profile="Profil"
AsyncDepth="Aszinkron mélység"
Accuracy="Pontosság"
Convergence="Konvergencia"
ICQQuality="ICQ minőség"
LookAheadDepth="Lookahead mélység"

12
plugins/obs-qsv11/data/locale/ja-JP.ini
View file

@ -1,12 +0,0 @@
TargetUsage="ターゲットの使用法"
Bitrate="ビットレート"
MaxBitrate="最大ビットレート"
RateControl="レート制御"
KeyframeIntervalSec="キーフレーム間隔 (秒, 0=自動)"
Profile="プロファイル"
AsyncDepth="非同期深度"
Accuracy="精度"
Convergence="収束"
ICQQuality="ICQ の品質"
LookAheadDepth="先読み深度"

12
plugins/obs-qsv11/data/locale/ko-KR.ini
View file

@ -1,12 +0,0 @@
TargetUsage="목표 사용 수준"
Bitrate="비트레이트"
MaxBitrate="최대 비트레이트"
RateControl="데이터율 제어"
KeyframeIntervalSec="키프레임 간격 (초 단위, 0=자동)"
Profile="프로파일"
AsyncDepth="비동기(Async) 심도"
Accuracy="정확도"
Convergence="수렴도"
ICQQuality="ICQ 품질"
LookAheadDepth="미리보기(Lookahead) 심도"

12
plugins/obs-qsv11/data/locale/nl-NL.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Doelgebruik"
Bitrate="Bitrate"
MaxBitrate="Maximale bitrate"
RateControl="Rate Control"
KeyframeIntervalSec="Tijd tussen keyframes (seconden, 0=auto)"
Profile="Profiel"
AsyncDepth="Async diepte"
Accuracy="Nauwkeurigheid"
Convergence="Convergentie"
ICQQuality="ICQ kwaliteit"
LookAheadDepth="Lookahead diepte"

12
plugins/obs-qsv11/data/locale/pl-PL.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Tryb enkodowania"
Bitrate="Przepływność (bitrate)"
MaxBitrate="Maksymalna przepływność (bitrate)"
RateControl="Kontrola przepływności"
KeyframeIntervalSec="Odstęp między klatkami kluczowymi (sekundy, 0=automatyczny)"
Profile="Profil"
AsyncDepth="Głębokość async"
Accuracy="Dokładność"
Convergence="Zbieżność"
ICQQuality="Jakość ICQ"
LookAheadDepth="Głębokość lookahead"

4
plugins/obs-qsv11/data/locale/ro-RO.ini
View file

@ -1,4 +0,0 @@
Bitrate="Rată de biți"
MaxBitrate="Rată de biți maximă"
Profile="Profil"

12
plugins/obs-qsv11/data/locale/ru-RU.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Целевое использование"
Bitrate="Битрейт"
MaxBitrate="Максимальный битрейт"
RateControl="Управление битрейтом"
KeyframeIntervalSec="Интервал ключевых кадров (сек, 0=авто)"
Profile="Профиль"
AsyncDepth="Сила асинхронизации"
Accuracy="Точность"
Convergence="Конвергенция"
ICQQuality="Качество ICQ"
LookAheadDepth="Глубина просмотра наперёд"

12
plugins/obs-qsv11/data/locale/sr-CS.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Ciljno zauzeće"
Bitrate="Protok"
MaxBitrate="Maksimalni protok"
RateControl="Kontrola protoka"
KeyframeIntervalSec="Interval ključnih frejmova (sekunde, 0=automatski)"
Profile="Profil"
AsyncDepth="Dubina asinhronizacije"
Accuracy="Preciznost"
Convergence="Konvergencija"
ICQQuality="ICQ kvalitet"
LookAheadDepth="Dubina predviđanja"

12
plugins/obs-qsv11/data/locale/sr-SP.ini
View file

@ -1,12 +0,0 @@
TargetUsage="Циљно заузеће"
Bitrate="Проток"
MaxBitrate="Максимални проток"
RateControl="Контрола протока"
KeyframeIntervalSec="Интервал кључних фрејмова (секунде, 0=аутоматски)"
Profile="Профил"
AsyncDepth="Дубина асинхронизације"
Accuracy="Прецизност"
Convergence="Конвергенција"
ICQQuality="ICQ квалитет"
LookAheadDepth="Дубина предвиђања"

6
plugins/obs-qsv11/data/locale/sv-SE.ini
View file

@ -1,6 +0,0 @@
TargetUsage="Målanvändning"
Bitrate="Bithastighet"
MaxBitrate="Maximal bithastighet"
Profile="Profil"
Accuracy="Noggrannhet"

6
plugins/obs-qsv11/data/locale/tr-TR.ini
View file

@ -1,6 +0,0 @@
Bitrate="Bit hızı"
MaxBitrate="Maks Bit hızı"
KeyframeIntervalSec="Anahtarkare Aralığı (saniye, 0=otomatik)"
Profile="Profil"
Accuracy="Doğruluk"

12
plugins/obs-qsv11/data/locale/zh-CN.ini
View file

@ -1,12 +0,0 @@
TargetUsage="目标使用"
Bitrate="比特率"
MaxBitrate="最大比特率"
RateControl="速率控制"
KeyframeIntervalSec="关键帧间隔(秒, 0=自动)"
Profile="配置文件"
AsyncDepth="异步深度"
Accuracy="精确度"
Convergence="收敛性"
ICQQuality="ICQ 质量"
LookAheadDepth="预测先行深度"

10
plugins/obs-qsv11/data/locale/zh-TW.ini
View file

@ -1,10 +0,0 @@
TargetUsage="目標使用"
Bitrate="位元率："
MaxBitrate="最大位元率"
RateControl="速率控制"
KeyframeIntervalSec="關鍵影格間隔 (秒，0 = 自動)"
Profile="設定檔"
AsyncDepth="非同步深度"
Accuracy="精準度"
ICQQuality="ICQ 品質"

76
plugins/obs-qsv11/libmfx/include/mfx_critical_section.h
View file

@ -1,76 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-2013 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: mfx_critical_section.h
\* ****************************************************************************** */
#if !defined(__MFX_CRITICAL_SECTION_H)
#define __MFX_CRITICAL_SECTION_H
#include <mfxdefs.h>
namespace MFX
{
// Just set "critical section" instance to zero for initialization.
typedef volatile mfxL32 mfxCriticalSection;
// Enter the global critical section.
void mfxEnterCriticalSection(mfxCriticalSection *pCSection);
// Leave the global critical section.
void mfxLeaveCriticalSection(mfxCriticalSection *pCSection);
class MFXAutomaticCriticalSection
{
public:
// Constructor
explicit MFXAutomaticCriticalSection(mfxCriticalSection *pCSection)
{
m_pCSection = pCSection;
mfxEnterCriticalSection(m_pCSection);
}
// Destructor
~MFXAutomaticCriticalSection()
{
mfxLeaveCriticalSection(m_pCSection);
}
protected:
// Pointer to a critical section
mfxCriticalSection *m_pCSection;
private:
// unimplemented by intent to make this class non-copyable
MFXAutomaticCriticalSection(const MFXAutomaticCriticalSection &);
void operator=(const MFXAutomaticCriticalSection &);
};
} // namespace MFX
#endif // __MFX_CRITICAL_SECTION_H

213
plugins/obs-qsv11/libmfx/include/mfx_dispatcher.h
View file

@ -1,213 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-2015 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: mfx_dispatcher.h
\* ****************************************************************************** */
#if !defined(__MFX_DISPATCHER_H)
#define __MFX_DISPATCHER_H
#include <mfxvideo.h>
#include <mfxaudio.h>
#include <mfxplugin.h>
#include <stddef.h>
#include "mfx_dispatcher_defs.h"
#include "mfx_load_plugin.h"
#include "mfxenc.h"
#include "mfxpak.h"
mfxStatus MFXQueryVersion(mfxSession session, mfxVersion *version);
enum
{
// to avoid code changing versions are just inherited
// from the API header file.
DEFAULT_API_VERSION_MAJOR = MFX_VERSION_MAJOR,
DEFAULT_API_VERSION_MINOR = MFX_VERSION_MINOR
};
//
// declare functions' integer identifiers.
//
#undef FUNCTION
#define FUNCTION(return_value, func_name, formal_param_list, actual_param_list) \
e##func_name,
enum eFunc
{
eMFXInit,
eMFXClose,
eMFXQueryIMPL,
eMFXQueryVersion,
eMFXJoinSession,
eMFXDisjoinSession,
eMFXCloneSession,
eMFXSetPriority,
eMFXGetPriority,
eMFXInitEx,
#include "mfx_exposed_functions_list.h"
eVideoFuncTotal
};
enum eAudioFunc
{
eFakeAudioEnum = eMFXGetPriority,
#include "mfxaudio_exposed_functions_list.h"
eAudioFuncTotal
};
// declare max buffer length for regsitry key name
enum
{
MFX_MAX_REGISTRY_KEY_NAME = 256
};
// declare the maximum DLL path
enum
{
MFX_MAX_DLL_PATH = 1024
};
// declare library's implementation types
enum eMfxImplType
{
MFX_LIB_HARDWARE = 0,
MFX_LIB_SOFTWARE = 1,
MFX_LIB_PSEUDO = 2,
MFX_LIB_IMPL_TYPES
};
// declare dispatcher's version
enum
{
MFX_DISPATCHER_VERSION_MAJOR = 1,
MFX_DISPATCHER_VERSION_MINOR = 2
};
// declare a dispatcher's handle
struct MFX_DISP_HANDLE
{
// Default constructor
MFX_DISP_HANDLE(const mfxVersion requiredVersion);
// Destructor
~MFX_DISP_HANDLE(void);
// Load the library's module
mfxStatus LoadSelectedDLL(const msdk_disp_char *pPath, eMfxImplType implType, mfxIMPL impl, mfxIMPL implInterface, mfxInitParam &par);
// Unload the library's module
mfxStatus UnLoadSelectedDLL(void);
// Close the handle
mfxStatus Close(void);
// NOTE: changing order of struct's members can make different version of
// dispatchers incompatible. Think of different modules (e.g. MFT filters)
// within a single application.
// Library's implementation type (hardware or software)
eMfxImplType implType;
// Current library's implementation (exact implementation)
mfxIMPL impl;
// Current library's VIA interface
mfxIMPL implInterface;
// Dispatcher's version. If version is 1.1 or lower, then old dispatcher's
// architecture is used. Otherwise it means current dispatcher's version.
mfxVersion dispVersion;
// A real handle passed to a called function
mfxSession session;
// Required API version of session initialized
const mfxVersion apiVersion;
// Actual library API version
mfxVersion actualApiVersion;
// Status of loaded dll
mfxStatus loadStatus;
// Resgistry subkey name for windows version
msdk_disp_char subkeyName[MFX_MAX_REGISTRY_KEY_NAME];
// Storage ID for windows version
int storageID;
// Library's module handle
mfxModuleHandle hModule;
MFX::MFXPluginStorage pluginHive;
MFX::MFXPluginFactory pluginFactory;
// function call table
mfxFunctionPointer callTable[eVideoFuncTotal];
mfxFunctionPointer callAudioTable[eAudioFuncTotal];
private:
// Declare assignment operator and copy constructor to prevent occasional assignment
MFX_DISP_HANDLE(const MFX_DISP_HANDLE &);
MFX_DISP_HANDLE & operator = (const MFX_DISP_HANDLE &);
};
// declare comparison operator
inline
bool operator == (const mfxVersion &one, const mfxVersion &two)
{
return (one.Version == two.Version);
} // bool operator == (const mfxVersion &one, const mfxVersion &two)
inline
bool operator < (const mfxVersion &one, const mfxVersion &two)
{
return (one.Major == two.Major) && (one.Minor < two.Minor);
} // bool operator < (const mfxVersion &one, const mfxVersion &two)
inline
bool operator <= (const mfxVersion &one, const mfxVersion &two)
{
return (one == two) || (one < two);
} // bool operator <= (const mfxVersion &one, const mfxVersion &two)
//
// declare a table with functions descriptions
//
typedef
struct FUNCTION_DESCRIPTION
{
// Literal function's name
const char *pName;
// API version when function appeared first time
mfxVersion apiVersion;
} FUNCTION_DESCRIPTION;
extern const
FUNCTION_DESCRIPTION APIFunc[eVideoFuncTotal];
extern const
FUNCTION_DESCRIPTION APIAudioFunc[eAudioFuncTotal];
#endif // __MFX_DISPATCHER_H

85
plugins/obs-qsv11/libmfx/include/mfx_dispatcher_defs.h
View file

@ -1,85 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2013-2015 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: mfx_dispatcher_defs.h
\* ****************************************************************************** */
#pragma once
#include "mfxdefs.h"
#include <cstring>
#if defined(MFX_DISPATCHER_LOG)
#include <string>
#include <string.h>
#endif
#if defined(_WIN32) || defined(_WIN64)
typedef wchar_t msdk_disp_char;
#define MSDK2WIDE(x) x
#if _MSC_VER >= 1400
#define msdk_disp_char_cpy_s(to, to_size, from) wcscpy_s(to,to_size, from)
#else
#define msdk_disp_char_cpy_s(to, to_size, from) wcscpy(to, from)
#endif
#else
typedef char msdk_disp_char;
//#define msdk_disp_char_cpy_s(to, to_size, from) strcpy(to, from)
inline void msdk_disp_char_cpy_s(char * to, size_t to_size, const char * from)
{
size_t source_len = strlen(from);
size_t num_chars = (to_size - 1) < source_len ? (to_size - 1) : source_len;
strncpy(to, from, num_chars);
to[num_chars] = 0;
}
#if defined(MFX_DISPATCHER_LOG)
#define MSDK2WIDE(x) getWideString(x).c_str()
inline std::wstring getWideString(const char * string)
{
size_t len = strlen(string);
return std::wstring(string, string + len);
}
#else
#define MSDK2WIDE(x) x
#endif
#endif
#ifdef __GNUC__
#define sscanf_s sscanf
#define swscanf_s swscanf
#endif
// declare library module's handle
typedef void * mfxModuleHandle;
typedef void (MFX_CDECL * mfxFunctionPointer)(void);

306
plugins/obs-qsv11/libmfx/include/mfx_dispatcher_log.h
View file

@ -1,306 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_dispatcher_log.h
\* ****************************************************************************** */
#if !defined(__MFX_DISPATCHER_LOG_H)
#define __MFX_DISPATCHER_LOG_H
//////////////////////////////////////////////////////////////////////////
//dispatcher log (DL) level
#define DL_INFO 1
#define DL_WRN 2
#define DL_ERROR 4
#define DL_LOADED_LIBRARY 8
//////////////////////////////////////////////////////////////////////////
//opcodes used only in events
enum
{
DL_EVENT_START = 1,
DL_EVENT_STOP,
DL_EVENT_MSG
};
//////////////////////////////////////////////////////////////////////////
#define DL_SINK_NULL 0
#define DL_SINK_PRINTF 1
#define DL_SINK_IMsgHandler 2
#define MFXFOURCCTYPE() "%c%c%c%c"
#define ZERO_OR_SPACE(value) ((0==(value)) ? '0' : (value))
#define MFXU32TOFOURCC(mfxu32)\
ZERO_OR_SPACE((char)(mfxu32 & 0xFF)), \
ZERO_OR_SPACE((char)((mfxu32 >> 8) & 0xFF)),\
ZERO_OR_SPACE((char)((mfxu32 >> 16) & 0xFF)),\
ZERO_OR_SPACE((char)((mfxu32 >> 24) & 0xFF))
#define MFXGUIDTYPE() "%X-%X-%X-%X-%X-%X-%X-%X-%X-%X-%X-%X-%X-%X-%X-%X"
#define MFXGUIDTOHEX(guid)\
(guid)->Data[0],\
(guid)->Data[1],\
(guid)->Data[2],\
(guid)->Data[3],\
(guid)->Data[4],\
(guid)->Data[5],\
(guid)->Data[6],\
(guid)->Data[7],\
(guid)->Data[8],\
(guid)->Data[9],\
(guid)->Data[10],\
(guid)->Data[11],\
(guid)->Data[12],\
(guid)->Data[13],\
(guid)->Data[14],\
(guid)->Data[15]
#if defined(MFX_DISPATCHER_LOG)
//---------------------------setup section------------------------
//using of formating instead of variadic macro with NULL end,
//leads to more flexibility in format, however constructing string
//with vsprintf_s is a time wasting
#define DISPATCHER_LOG_USE_FORMATING 1
//creates unique object, event guid registration, factories on heap
//heap reduce stack allocation and reduce reservation time at startup
//is a vital if mediasdk wont use
#define DISPATCHER_LOG_HEAP_SINGLETONES
#if defined(_WIN32) || defined(_WIN64)
// guid for all dispatcher events
#define DISPATCHER_LOG_EVENT_GUID L"{EB0538CC-4FEE-484d-ACEE-1182E9F37A57}"
//puts a sink into listeners list
//#define DISPATCHER_LOG_REGISTER_EVENT_PROVIDER
//puts a sink into listeners list
//#define DISPATCHER_LOG_REGISTER_FILE_WRITER
#define DISPACTHER_LOG_FW_PATH "c:\\dispatcher.log"
#endif // #if defined(_WIN32) || defined(_WIN64)
#include <stdio.h>
#include <stdarg.h>
//callback interface for intercept logging messages
class IMsgHandler
{
public:
virtual ~IMsgHandler(){}
virtual void Write(int level, int opcode, const char * msg, va_list argptr) = 0;
};
#if defined(_WIN32) || defined(_WIN64)
#if DISPATCHER_LOG_USE_FORMATING
#define DISPATCHER_LOG(lvl, opcode, str)\
{\
DispatcherLogBracketsHelper wrt(lvl,opcode);\
wrt.Write str;\
}
#else
#define DISPATCHER_LOG_VA_ARGS(...) wrt.Write(__VA_ARGS__, NULL)
//WARNING: don't use types that occupy more that 4 bytes in memory
//WARNING: don't use %s in format specifier
#define DISPATCHER_LOG(lvl, opcode, str) \
{\
DispatcherLogBracketsHelper wrt(lvl, opcode);\
DISPATCHER_LOG_VA_ARGS str;\
}
#endif//DISPATCHER_LOG_USE_FORMATING
#define DISPATCHER_LOG_OPERATION(operation) operation
#else
#define DISPATCHER_LOG(lvl, opcode, str)
#define DISPATCHER_LOG_OPERATION(operation)
#endif
#define __name_from_line( name, line ) name ## line
#define _name_from_line( name , line) __name_from_line( name, line )
#define name_from_line( name ) _name_from_line( name, __LINE__)
#define DISPATCHER_LOG_AUTO(lvl, msg)\
DispatchLogBlockHelper name_from_line(__auto_log_)(lvl); name_from_line(__auto_log_).Write msg;
#include <memory>
#include <map>
#include <list>
#include <string>
template <class T>
class DSSingleTone
{
public:
template <class TParam1>
inline static T & get(TParam1 par1)
{
T * pstored;
if (NULL == (pstored = store_or_load()))
{
return *store_or_load(new T(par1));
}
return *pstored;
}
inline static T & get()
{
T * pstored;
if (NULL == (pstored = store_or_load()))
{
return *store_or_load(new T());
}
return *pstored;
}
private:
//if obj == NULL, then it load
//if obj != NULL then it store obj
inline static T * store_or_load(T * obj = NULL)
{
static std::auto_ptr<T> instance;
if (NULL != obj)
{
instance.reset(obj);
}
return instance.get();
}
};
class DispatchLog
: public DSSingleTone<DispatchLog>
{
friend class DSSingleTone<DispatchLog>;
std::list<IMsgHandler*>m_Recepients;
int m_DispatcherLogSink;
public:
//sets current sink
void SetSink(int nsink, IMsgHandler *pHandler);
void AttachSink(int nsink, IMsgHandler *pHandler);
void DetachSink(int nsink, IMsgHandler *pHandler);
void ExchangeSink(int nsink, IMsgHandler *pOld, IMsgHandler *pNew);
void DetachAllSinks();
void Write(int level, int opcode, const char * msg, va_list argptr);
protected:
DispatchLog();
};
//allows to push arguments on the stack without declaring them as function parameters
struct DispatcherLogBracketsHelper
{
int m_level;
int m_opcode;
DispatcherLogBracketsHelper(int level, int opcode)
:m_level(level)
,m_opcode(opcode)
{
}
void Write(const char * str, ...);
} ;
//auto log on ctor dtor
struct DispatchLogBlockHelper
{
int m_level;
void Write(const char * str, ...);
DispatchLogBlockHelper (int level)
: m_level(level)
{
}
~DispatchLogBlockHelper();
};
//----utility sinks-----
#if defined(_WIN32) || defined(_WIN64)
#if defined(DISPATCHER_LOG_REGISTER_EVENT_PROVIDER)
class ETWHandlerFactory
: public DSSingleTone<ETWHandlerFactory>
{
friend class DSSingleTone<ETWHandlerFactory>;
typedef std::map<std::wstring, IMsgHandler*> _storage_type;
_storage_type m_storage;
public:
~ETWHandlerFactory();
IMsgHandler *GetSink(const wchar_t* sguid = DISPATCHER_LOG_EVENT_GUID);
protected:
ETWHandlerFactory(){}
};
#endif
#endif // #if defined(_WIN32) || defined(_WIN64)
#if defined(DISPATCHER_LOG_REGISTER_FILE_WRITER)
class FileSink
: public DSSingleTone<FileSink>
, public IMsgHandler
{
friend class DSSingleTone<FileSink>;
public:
virtual void Write(int level, int opcode, const char * msg, va_list argptr);
~FileSink()
{
if (NULL != m_hdl)
fclose(m_hdl);
}
private:
FILE * m_hdl;
FileSink(const std::string & log_file)
{
#if defined(_WIN32) || defined(_WIN64)
fopen_s(&m_hdl, log_file.c_str(), "a");
#else
m_hdl = fopen(log_file.c_str(), "a");
#endif
}
};
#endif
//-----utility functions
//since they are not called outside of macro we can define them here
std::string DispatcherLog_GetMFXImplString(int impl);
const char *DispatcherLog_GetMFXStatusString(int sts);
#else // !defined(MFX_DISPATCHER_LOG)
#define DISPATCHER_LOG(level, opcode, message)
#define DISPATCHER_LOG_AUTO(level, message)
#define DISPATCHER_LOG_OPERATION(operation)
#endif// !defined(MFX_DISPATCHER_LOG)
#define DISPATCHER_LOG_INFO(msg) DISPATCHER_LOG(DL_INFO, DL_EVENT_MSG, msg)
#define DISPATCHER_LOG_WRN(msg) DISPATCHER_LOG(DL_WRN, DL_EVENT_MSG, msg)
#define DISPATCHER_LOG_ERROR(msg) DISPATCHER_LOG(DL_ERROR, DL_EVENT_MSG, msg)
#define DISPATCHER_LOG_LIBRARY(msg) DISPATCHER_LOG(DL_LOADED_LIBRARY, DL_EVENT_MSG, msg)
#define DISPATCHER_LOG_BLOCK(msg) DISPATCHER_LOG_AUTO(DL_INFO, msg)
#endif // !defined(__MFX_DISPATCHER_LOG_H)

210
plugins/obs-qsv11/libmfx/include/mfx_dxva2_device.h
View file

@ -1,210 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-2013 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: mfx_dxva2_device.h
\* ****************************************************************************** */
#if !defined(__MFX_DXVA2_DEVICE_H)
#define __MFX_DXVA2_DEVICE_H
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#endif // #if defined(_WIN32) || defined(_WIN64)
#include <mfxdefs.h>
#ifdef DXVA2DEVICE_LOG
#include <stdio.h>
#define DXVA2DEVICE_TRACE(expr) printf expr;
#define DXVA2DEVICE_TRACE_OPERATION(expr) expr;
#else
#define DXVA2DEVICE_TRACE(expr)
#define DXVA2DEVICE_TRACE_OPERATION(expr)
#endif
namespace MFX
{
class DXDevice
{
public:
// Default constructor
DXDevice(void);
// Destructor
virtual
~DXDevice(void) = 0;
// Initialize device using DXGI 1.1 or VAAPI interface
virtual
bool Init(const mfxU32 adapterNum) = 0;
// Obtain graphic card's parameter
mfxU32 GetVendorID(void) const;
mfxU32 GetDeviceID(void) const;
mfxU64 GetDriverVersion(void) const;
mfxU64 GetLUID(void) const;
// Provide the number of available adapters
mfxU32 GetAdapterCount(void) const;
// Close the object
virtual
void Close(void);
// Load the required DLL module
void LoadDLLModule(const wchar_t *pModuleName);
protected:
// Free DLL module
void UnloadDLLModule(void);
#if defined(_WIN32) || defined(_WIN64)
// Handle to the DLL library
HMODULE m_hModule;
#endif // #if defined(_WIN32) || defined(_WIN64)
// Number of adapters available
mfxU32 m_numAdapters;
// Vendor ID
mfxU32 m_vendorID;
// Device ID
mfxU32 m_deviceID;
// x.x.x.x each x of two bytes
mfxU64 m_driverVersion;
// LUID
mfxU64 m_luid;
private:
// unimplemented by intent to make this class and its descendants non-copyable
DXDevice(const DXDevice &);
void operator=(const DXDevice &);
};
#if defined(_WIN32) || defined(_WIN64)
class D3D9Device : public DXDevice
{
public:
// Default constructor
D3D9Device(void);
// Destructor
virtual
~D3D9Device(void);
// Initialize device using D3D v9 interface
virtual
bool Init(const mfxU32 adapterNum);
// Close the object
virtual
void Close(void);
protected:
// Pointer to the D3D v9 interface
void *m_pD3D9;
// Pointer to the D3D v9 extended interface
void *m_pD3D9Ex;
};
class DXGI1Device : public DXDevice
{
public:
// Default constructor
DXGI1Device(void);
// Destructor
virtual
~DXGI1Device(void);
// Initialize device
virtual
bool Init(const mfxU32 adapterNum);
// Close the object
virtual
void Close(void);
protected:
// Pointer to the DXGI1 factory
void *m_pDXGIFactory1;
// Pointer to the current DXGI1 adapter
void *m_pDXGIAdapter1;
};
#endif // #if defined(_WIN32) || defined(_WIN64)
class DXVA2Device
{
public:
// Default constructor
DXVA2Device(void);
// Destructor
~DXVA2Device(void);
// Initialize device using D3D v9 interface
bool InitD3D9(const mfxU32 adapterNum);
// Initialize device using DXGI 1.1 interface
bool InitDXGI1(const mfxU32 adapterNum);
// Obtain graphic card's parameter
mfxU32 GetVendorID(void) const;
mfxU32 GetDeviceID(void) const;
mfxU64 GetDriverVersion(void) const;
// Provide the number of available adapters
mfxU32 GetAdapterCount(void) const;
void Close(void);
protected:
// Get vendor & device IDs by alternative way (D3D9 in Remote Desktop sessions)
void UseAlternativeWay(const D3D9Device *pD3D9Device);
// Number of adapters available
mfxU32 m_numAdapters;
// Vendor ID
mfxU32 m_vendorID;
// Device ID
mfxU32 m_deviceID;
//x.x.x.x
mfxU64 m_driverVersion;
private:
// unimplemented by intent to make this class non-copyable
DXVA2Device(const DXVA2Device &);
void operator=(const DXVA2Device &);
};
} // namespace MFX
#endif // __MFX_DXVA2_DEVICE_H

142
plugins/obs-qsv11/libmfx/include/mfx_exposed_functions_list.h
View file

@ -1,142 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_exposed_functions_list.h
\* ****************************************************************************** */
//
// WARNING:
// this file doesn't contain an include guard by intension.
// The file may be included into a source file many times.
// That is why this header doesn't contain any include directive.
// Please, do no try to fix it.
//
// Use define API_VERSION to set the API of functions listed further
// When new functions are added new section with functions declarations must be started with updated define
//
// API version 1.0 functions
//
// API version where a function is added. Minor value should precedes the major value
#define API_VERSION {{0, 1}}
// CORE interface functions
FUNCTION(mfxStatus, MFXVideoCORE_SetBufferAllocator, (mfxSession session, mfxBufferAllocator *allocator), (session, allocator))
FUNCTION(mfxStatus, MFXVideoCORE_SetFrameAllocator, (mfxSession session, mfxFrameAllocator *allocator), (session, allocator))
FUNCTION(mfxStatus, MFXVideoCORE_SetHandle, (mfxSession session, mfxHandleType type, mfxHDL hdl), (session, type, hdl))
FUNCTION(mfxStatus, MFXVideoCORE_GetHandle, (mfxSession session, mfxHandleType type, mfxHDL *hdl), (session, type, hdl))
FUNCTION(mfxStatus, MFXVideoCORE_SyncOperation, (mfxSession session, mfxSyncPoint syncp, mfxU32 wait), (session, syncp, wait))
// ENCODE interface functions
FUNCTION(mfxStatus, MFXVideoENCODE_Query, (mfxSession session, mfxVideoParam *in, mfxVideoParam *out), (session, in, out))
FUNCTION(mfxStatus, MFXVideoENCODE_QueryIOSurf, (mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request), (session, par, request))
FUNCTION(mfxStatus, MFXVideoENCODE_Init, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoENCODE_Reset, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoENCODE_Close, (mfxSession session), (session))
FUNCTION(mfxStatus, MFXVideoENCODE_GetVideoParam, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoENCODE_GetEncodeStat, (mfxSession session, mfxEncodeStat *stat), (session, stat))
FUNCTION(mfxStatus, MFXVideoENCODE_EncodeFrameAsync, (mfxSession session, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxSyncPoint *syncp), (session, ctrl, surface, bs, syncp))
// DECODE interface functions
FUNCTION(mfxStatus, MFXVideoDECODE_Query, (mfxSession session, mfxVideoParam *in, mfxVideoParam *out), (session, in, out))
FUNCTION(mfxStatus, MFXVideoDECODE_DecodeHeader, (mfxSession session, mfxBitstream *bs, mfxVideoParam *par), (session, bs, par))
FUNCTION(mfxStatus, MFXVideoDECODE_QueryIOSurf, (mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request), (session, par, request))
FUNCTION(mfxStatus, MFXVideoDECODE_Init, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoDECODE_Reset, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoDECODE_Close, (mfxSession session), (session))
FUNCTION(mfxStatus, MFXVideoDECODE_GetVideoParam, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoDECODE_GetDecodeStat, (mfxSession session, mfxDecodeStat *stat), (session, stat))
FUNCTION(mfxStatus, MFXVideoDECODE_SetSkipMode, (mfxSession session, mfxSkipMode mode), (session, mode))
FUNCTION(mfxStatus, MFXVideoDECODE_GetPayload, (mfxSession session, mfxU64 *ts, mfxPayload *payload), (session, ts, payload))
FUNCTION(mfxStatus, MFXVideoDECODE_DecodeFrameAsync, (mfxSession session, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp), (session, bs, surface_work, surface_out, syncp))
// VPP interface functions
FUNCTION(mfxStatus, MFXVideoVPP_Query, (mfxSession session, mfxVideoParam *in, mfxVideoParam *out), (session, in, out))
FUNCTION(mfxStatus, MFXVideoVPP_QueryIOSurf, (mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request), (session, par, request))
FUNCTION(mfxStatus, MFXVideoVPP_Init, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoVPP_Reset, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoVPP_Close, (mfxSession session), (session))
FUNCTION(mfxStatus, MFXVideoVPP_GetVideoParam, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoVPP_GetVPPStat, (mfxSession session, mfxVPPStat *stat), (session, stat))
FUNCTION(mfxStatus, MFXVideoVPP_RunFrameVPPAsync, (mfxSession session, mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxSyncPoint *syncp), (session, in, out, aux, syncp))
#undef API_VERSION
//
// API version 1.1 functions
//
#define API_VERSION {{1, 1}}
FUNCTION(mfxStatus, MFXVideoUSER_Register, (mfxSession session, mfxU32 type, const mfxPlugin *par), (session, type, par))
FUNCTION(mfxStatus, MFXVideoUSER_Unregister, (mfxSession session, mfxU32 type), (session, type))
FUNCTION(mfxStatus, MFXVideoUSER_ProcessFrameAsync, (mfxSession session, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp), (session, in, in_num, out, out_num, syncp))
#undef API_VERSION
//
// API version 1.10 functions
//
#define API_VERSION {{10, 1}}
FUNCTION(mfxStatus, MFXVideoENC_Query,(mfxSession session, mfxVideoParam *in, mfxVideoParam *out), (session,in,out))
FUNCTION(mfxStatus, MFXVideoENC_QueryIOSurf,(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request), (session,par,request))
FUNCTION(mfxStatus, MFXVideoENC_Init,(mfxSession session, mfxVideoParam *par), (session,par))
FUNCTION(mfxStatus, MFXVideoENC_Reset,(mfxSession session, mfxVideoParam *par), (session,par))
FUNCTION(mfxStatus, MFXVideoENC_Close,(mfxSession session),(session))
FUNCTION(mfxStatus, MFXVideoENC_ProcessFrameAsync,(mfxSession session, mfxENCInput *in, mfxENCOutput *out, mfxSyncPoint *syncp),(session,in,out,syncp))
FUNCTION(mfxStatus, MFXVideoVPP_RunFrameVPPAsyncEx, (mfxSession session, mfxFrameSurface1 *in, mfxFrameSurface1 *work, mfxFrameSurface1 **out, mfxSyncPoint *syncp), (session, in, work, out, syncp))
#undef API_VERSION
#define API_VERSION {{13, 1}}
FUNCTION(mfxStatus, MFXVideoPAK_Query, (mfxSession session, mfxVideoParam *in, mfxVideoParam *out), (session, in, out))
FUNCTION(mfxStatus, MFXVideoPAK_QueryIOSurf, (mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request), (session, par, request))
FUNCTION(mfxStatus, MFXVideoPAK_Init, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoPAK_Reset, (mfxSession session, mfxVideoParam *par), (session, par))
FUNCTION(mfxStatus, MFXVideoPAK_Close, (mfxSession session), (session))
FUNCTION(mfxStatus, MFXVideoPAK_ProcessFrameAsync, (mfxSession session, mfxPAKInput *in, mfxPAKOutput *out, mfxSyncPoint *syncp), (session, in, out, syncp))
#undef API_VERSION
#define API_VERSION {{14, 1}}
// FUNCTION(mfxStatus, MFXInitEx, (mfxInitParam par, mfxSession session), (par, session))
FUNCTION(mfxStatus, MFXDoWork, (mfxSession session), (session))
#undef API_VERSION

161
plugins/obs-qsv11/libmfx/include/mfx_library_iterator.h
View file

@ -1,161 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_library_iterator.h
\* ****************************************************************************** */
#if !defined(__MFX_LIBRARY_ITERATOR_H)
#define __MFX_LIBRARY_ITERATOR_H
#include <mfxvideo.h>
#include "mfx_win_reg_key.h"
#include "mfx_dispatcher.h"
#if !defined(_WIN32) && !defined(_WIN64)
struct mfx_disp_adapters
{
mfxU32 vendor_id;
mfxU32 device_id;
};
#ifndef __APPLE__
#define MFX_SO_BASE_NAME_LEN 15 // sizeof("libmfxhw32-p.so") = 15
#else
#define MFX_SO_BASE_NAME_LEN 16 // sizeof("libmfxhw64.dylib") = 16
#endif
#define MFX_MIN_REAL_LIBNAME MFX_SO_BASE_NAME_LEN + 4 // sizeof("libmfxhw32-p.so.0.0") >= 19
#define MFX_MAX_REAL_LIBNAME MFX_MIN_REAL_LIBNAME + 8 // sizeof("libmfxhw32-p.so.<mj>.<mn>") <= 27, max(sizeof(<mj>))=sizeof(0xFFFF) = sizeof(65535) = 5
struct mfx_libs
{
char name[MFX_MAX_REAL_LIBNAME+1];
mfxVersion version;
};
#endif
namespace MFX
{
// declare desired storage ID
#if defined(_WIN32) || defined(_WIN64)
enum
{
MFX_UNKNOWN_KEY = -1,
MFX_CURRENT_USER_KEY = 0,
MFX_LOCAL_MACHINE_KEY = 1,
MFX_APP_FOLDER = 2,
MFX_STORAGE_ID_FIRST = MFX_CURRENT_USER_KEY,
MFX_STORAGE_ID_LAST = MFX_LOCAL_MACHINE_KEY
};
#else
enum
{
MFX_UNKNOWN_KEY = -1,
MFX_STORAGE_ID_OPT = 0, // storage is: /opt/intel
MFX_APP_FOLDER = 1,
MFX_STORAGE_ID_FIRST = MFX_STORAGE_ID_OPT,
MFX_STORAGE_ID_LAST = MFX_STORAGE_ID_OPT
};
#endif
// Try to initialize using given implementation type. Select appropriate type automatically in case of MFX_IMPL_VIA_ANY.
// Params: adapterNum - in, pImplInterface - in/out, pVendorID - out, pDeviceID - out
mfxStatus SelectImplementationType(const mfxU32 adapterNum, mfxIMPL *pImplInterface, mfxU32 *pVendorID, mfxU32 *pDeviceID);
class MFXLibraryIterator
{
public:
// Default constructor
MFXLibraryIterator(void);
// Destructor
~MFXLibraryIterator(void);
// Initialize the iterator
mfxStatus Init(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, int storageID);
// Get the next library path
mfxStatus SelectDLLVersion(msdk_disp_char *pPath, size_t pathSize,
eMfxImplType *pImplType, mfxVersion minVersion);
// Return interface type on which Intel adapter was found (if any): D3D9 or D3D11
mfxIMPL GetImplementationType();
// Retrun registry subkey name on which dll was selected after sucesfull call to selectDllVesion
bool GetSubKeyName(msdk_disp_char *subKeyName, size_t length) const;
int GetStorageID() const { return m_StorageID; }
protected:
// Release the iterator
void Release(void);
// Initialize the registry iterator
mfxStatus InitRegistry(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, int storageID);
// Initialize the app folder iterator
mfxStatus InitFolder(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, const msdk_disp_char * path);
eMfxImplType m_implType; // Required library implementation
mfxIMPL m_implInterface; // Required interface (D3D9, D3D11)
mfxU32 m_vendorID; // (mfxU32) property of used graphic card
mfxU32 m_deviceID; // (mfxU32) property of used graphic card
bool m_bIsSubKeyValid;
wchar_t m_SubKeyName[MFX_MAX_REGISTRY_KEY_NAME]; // registry subkey for selected module loaded
int m_StorageID;
#if defined(_WIN32) || defined(_WIN64)
WinRegKey m_baseRegKey; // (WinRegKey) main registry key
mfxU32 m_lastLibIndex; // (mfxU32) index of previously returned library
mfxU32 m_lastLibMerit; // (mfxU32) merit of previously returned library
#else
int m_lastLibIndex; // (mfxU32) index of previously returned library
mfxU32 m_adapters_num;
struct mfx_disp_adapters* m_adapters;
int m_selected_adapter;
mfxU32 m_libs_num;
struct mfx_libs* m_libs;
#endif // #if defined(_WIN32) || defined(_WIN64)
msdk_disp_char m_path[260];
private:
// unimplemented by intent to make this class non-copyable
MFXLibraryIterator(const MFXLibraryIterator &);
void operator=(const MFXLibraryIterator &);
};
} // namespace MFX
#endif // __MFX_LIBRARY_ITERATOR_H

59
plugins/obs-qsv11/libmfx/include/mfx_load_dll.h
View file

@ -1,59 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_load_dll.h
\* ****************************************************************************** */
#if !defined(__MFX_LOAD_DLL_H)
#define __MFX_LOAD_DLL_H
#include "mfx_dispatcher.h"
namespace MFX
{
//
// declare DLL loading routines
//
mfxStatus mfx_get_rt_dll_name(msdk_disp_char *pPath, size_t pathSize);
mfxStatus mfx_get_default_dll_name(msdk_disp_char *pPath, size_t pathSize, eMfxImplType implType);
mfxStatus mfx_get_default_plugin_name(msdk_disp_char *pPath, size_t pathSize, eMfxImplType implType);
mfxStatus mfx_get_default_audio_dll_name(msdk_disp_char *pPath, size_t pathSize, eMfxImplType implType);
mfxModuleHandle mfx_dll_load(const msdk_disp_char *file_name);
//increments reference counter
mfxModuleHandle mfx_get_dll_handle(const msdk_disp_char *file_name);
mfxFunctionPointer mfx_dll_get_addr(mfxModuleHandle handle, const char *func_name);
bool mfx_dll_free(mfxModuleHandle handle);
} // namespace MFX
#endif // __MFX_LOAD_DLL_H

93
plugins/obs-qsv11/libmfx/include/mfx_load_plugin.h
View file

@ -1,93 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2013-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: mfx_load_plugin.h
\* ****************************************************************************** */
#pragma once
#include "mfxplugin.h"
#include "mfx_dispatcher_defs.h"
#include "mfx_plugin_hive.h"
namespace MFX
{
typedef mfxStatus (MFX_CDECL *CreatePluginPtr_t)(mfxPluginUID uid, mfxPlugin* plugin);
class PluginModule
{
mfxModuleHandle mHmodule;
CreatePluginPtr_t mCreatePluginPtr;
msdk_disp_char mPath[MAX_PLUGIN_PATH];
public:
PluginModule();
PluginModule(const msdk_disp_char * path);
PluginModule(const PluginModule & that) ;
PluginModule & operator = (const PluginModule & that);
bool Create(mfxPluginUID guid, mfxPlugin&);
~PluginModule(void);
private:
void Tidy();
};
class MFXPluginFactory {
struct FactoryRecord {
mfxPluginParam plgParams;
PluginModule module;
mfxPlugin plugin;
FactoryRecord () {}
FactoryRecord(const mfxPluginParam &plgParams,
PluginModule &module,
mfxPlugin plugin)
: plgParams(plgParams)
, module(module)
, plugin(plugin) {
}
};
MFXVector<FactoryRecord> mPlugins;
mfxU32 nPlugins;
mfxSession mSession;
public:
MFXPluginFactory(mfxSession session);
void Close();
mfxStatus Create(const PluginDescriptionRecord &);
bool Destroy(const mfxPluginUID &);
~MFXPluginFactory();
protected:
void DestroyPlugin( FactoryRecord & );
static bool RunVerification( const mfxPlugin & plg, const PluginDescriptionRecord &dsc, mfxPluginParam &pluginParams );
static bool VerifyEncoder( const mfxVideoCodecPlugin &videoCodec );
static bool VerifyAudioEncoder( const mfxAudioCodecPlugin &audioCodec );
static bool VerifyEnc( const mfxVideoCodecPlugin &videoEnc );
static bool VerifyVpp( const mfxVideoCodecPlugin &videoCodec );
static bool VerifyDecoder( const mfxVideoCodecPlugin &videoCodec );
static bool VerifyAudioDecoder( const mfxAudioCodecPlugin &audioCodec );
static bool VerifyCodecCommon( const mfxVideoCodecPlugin & Video );
};
}

132
plugins/obs-qsv11/libmfx/include/mfx_plugin_hive.h
View file

@ -1,132 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2013-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: mfx_plugin_hive.h
\* ****************************************************************************** */
#pragma once
#include "mfx_dispatcher_defs.h"
#include "mfxplugin.h"
#include "mfx_win_reg_key.h"
#include "mfx_vector.h"
#include <string.h>
#include <memory>
#include <stdio.h>
struct MFX_DISP_HANDLE;
namespace MFX {
enum
{
MAX_PLUGIN_PATH = 4096
};
enum
{
MAX_PLUGIN_NAME = 4096
};
inline bool operator == (const mfxPluginUID &lhs, const mfxPluginUID & rhs)
{
return !memcmp(lhs.Data, rhs.Data, sizeof(mfxPluginUID));
}
inline bool operator != (const mfxPluginUID &lhs, const mfxPluginUID & rhs)
{
return !(lhs == rhs);
}
#ifdef _WIN32
//warning C4351: new behavior: elements of array 'MFX::PluginDescriptionRecord::sName' will be default initialized
#pragma warning (disable: 4351)
#endif
class PluginDescriptionRecord : public mfxPluginParam
{
public:
msdk_disp_char sPath[MAX_PLUGIN_PATH];
char sName[MAX_PLUGIN_NAME];
//used for FS plugins that has poor description
bool onlyVersionRegistered;
bool Default;
PluginDescriptionRecord()
: mfxPluginParam()
, sPath()
, sName()
, onlyVersionRegistered()
, Default()
{
}
};
typedef MFXVector<PluginDescriptionRecord> MFXPluginStorage;
class MFXPluginStorageBase : public MFXPluginStorage
{
protected:
mfxVersion mCurrentAPIVersion;
protected:
MFXPluginStorageBase(mfxVersion currentAPIVersion)
: mCurrentAPIVersion(currentAPIVersion)
{
}
void ConvertAPIVersion( mfxU32 APIVersion, PluginDescriptionRecord &descriptionRecord) const
{
descriptionRecord.APIVersion.Minor = static_cast<mfxU16> (APIVersion & 0x0ff);
descriptionRecord.APIVersion.Major = static_cast<mfxU16> (APIVersion >> 8);
}
};
//populated from registry
class MFXPluginsInHive : public MFXPluginStorageBase
{
public:
MFXPluginsInHive(int mfxStorageID, const msdk_disp_char *msdkLibSubKey, mfxVersion currentAPIVersion);
};
//plugins are loaded from FS close to executable
class MFXPluginsInFS : public MFXPluginStorageBase
{
bool mIsVersionParsed;
bool mIsAPIVersionParsed;
public:
MFXPluginsInFS(mfxVersion currentAPIVersion);
private:
bool ParseFile(FILE * f, PluginDescriptionRecord & des);
bool ParseKVPair( msdk_disp_char *key, msdk_disp_char * value, PluginDescriptionRecord & des);
};
//plugins are loaded from FS close to Runtime library
class MFXDefaultPlugins : public MFXPluginStorageBase
{
public:
MFXDefaultPlugins(mfxVersion currentAPIVersion, MFX_DISP_HANDLE * hdl, int implType);
private:
};
}

220
plugins/obs-qsv11/libmfx/include/mfx_vector.h
View file

@ -1,220 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2013-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: mfx_vector.h
\* ****************************************************************************** */
#pragma once
#include "mfxstructures.h"
#include <exception>
namespace MFX
{
template <class T>
class iterator_tmpl
{
template <class U> friend class MFXVector;
mfxU32 mIndex;
T* mRecords;
iterator_tmpl(mfxU32 index , T * records)
: mIndex (index)
, mRecords(records)
{}
public:
iterator_tmpl()
: mIndex ()
, mRecords()
{}
bool operator ==(const iterator_tmpl<T> & that )const
{
return mIndex == that.mIndex;
}
bool operator !=(const iterator_tmpl<T> & that )const
{
return mIndex != that.mIndex;
}
mfxU32 operator - (const iterator_tmpl<T> &that) const
{
return mIndex - that.mIndex;
}
iterator_tmpl<T> & operator ++()
{
mIndex++;
return * this;
}
iterator_tmpl<T> & operator ++(int)
{
mIndex++;
return * this;
}
T & operator *()
{
return mRecords[mIndex];
}
T * operator ->()
{
return mRecords + mIndex;
}
};
class MFXVectorRangeError : public std::exception
{
};
template <class T>
class MFXVector
{
T* mRecords;
mfxU32 mNrecords;
public:
MFXVector()
: mRecords()
, mNrecords()
{}
MFXVector(const MFXVector & rhs)
: mRecords()
, mNrecords()
{
insert(end(), rhs.begin(), rhs.end());
}
MFXVector & operator = (const MFXVector & rhs)
{
if (this != &rhs)
{
clear();
insert(end(), rhs.begin(), rhs.end());
}
return *this;
}
virtual ~MFXVector ()
{
clear();
}
typedef iterator_tmpl<T> iterator;
iterator begin() const
{
return iterator(0u, mRecords);
}
iterator end() const
{
return iterator(mNrecords, mRecords);
}
void insert(iterator where, iterator beg_iter, iterator end_iter)
{
mfxU32 elementsToInsert = (end_iter - beg_iter);
if (!elementsToInsert)
{
return;
}
if (where.mIndex > mNrecords)
{
throw MFXVectorRangeError();
}
T *newRecords = new T[mNrecords + elementsToInsert]();
mfxU32 i = 0;
// save left
for (; i < where.mIndex; i++)
{
newRecords[i] = mRecords[i];
}
// insert
for (; beg_iter != end_iter; beg_iter++, i++)
{
newRecords[i] = *beg_iter;
}
//save right
for (; i < mNrecords + elementsToInsert; i++)
{
newRecords[i] = mRecords[i - elementsToInsert];
}
delete [] mRecords;
mRecords = newRecords;
mNrecords = i;
}
T& operator [] (mfxU32 idx)
{
return mRecords[idx];
}
void push_back(const T& obj)
{
T *newRecords = new T[mNrecords + 1]();
mfxU32 i = 0;
for (; i <mNrecords; i++)
{
newRecords[i] = mRecords[i];
}
newRecords[i] = obj;
delete [] mRecords;
mRecords = newRecords;
mNrecords = i + 1;
}
void erase (iterator at)
{
if (at.mIndex >= mNrecords)
{
throw MFXVectorRangeError();
}
mNrecords--;
mfxU32 i = at.mIndex;
for (; i != mNrecords; i++)
{
mRecords[i] = mRecords[i+1];
}
//destroy last element
mRecords[i] = T();
}
void resize(mfxU32 nSize)
{
T * newRecords = new T[nSize]();
for (mfxU32 i = 0; i <mNrecords; i++)
{
newRecords[i] = mRecords[i];
}
delete [] mRecords;
mRecords = newRecords;
mNrecords = nSize;
}
mfxU32 size() const
{
return mNrecords;
}
void clear()
{
delete [] mRecords;
mRecords = 0;
mNrecords = 0;
}
};
}

116
plugins/obs-qsv11/libmfx/include/mfx_win_reg_key.h
View file

@ -1,116 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_win_reg_key.h
\* ****************************************************************************** */
#if !defined(__MFX_WIN_REG_KEY_H)
#define __MFX_WIN_REG_KEY_H
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#include "mfxplugin.h"
#include "mfx_dispatcher_log.h"
namespace MFX {
template<class T> struct RegKey{};
template<> struct RegKey<bool>{enum {type = REG_DWORD};};
template<> struct RegKey<mfxU32>{enum {type = REG_DWORD};};
template<> struct RegKey<mfxPluginUID>{enum {type = REG_BINARY};};
template<> struct RegKey<mfxVersion>{enum {type = REG_DWORD};};
template<> struct RegKey<char*>{enum {type = REG_SZ};};
template<> struct RegKey<wchar_t*>{enum {type = REG_SZ};};
class WinRegKey
{
public:
// Default constructor
WinRegKey(void);
// Destructor
~WinRegKey(void);
// Open a registry key
bool Open(HKEY hRootKey, const wchar_t *pSubKey, REGSAM samDesired);
bool Open(WinRegKey &rootKey, const wchar_t *pSubKey, REGSAM samDesired);
// Query value
bool QueryInfo(LPDWORD lpcSubkeys);
bool QueryValueSize(const wchar_t *pValueName, DWORD type, LPDWORD pcbData);
bool Query(const wchar_t *pValueName, DWORD type, LPBYTE pData, LPDWORD pcbData);
bool Query(const wchar_t *pValueName, wchar_t *pData, mfxU32 &nData) {
DWORD dw = (DWORD)nData;
if (!Query(pValueName, RegKey<wchar_t*>::type, (LPBYTE)pData, &dw)){
return false;
}
nData = dw;
return true;
}
// Enumerate value names
bool EnumValue(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName, LPDWORD pType);
bool EnumKey(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName);
protected:
// Release the object
void Release(void);
HKEY m_hKey; // (HKEY) handle to the opened key
private:
// unimplemented by intent to make this class non-copyable
WinRegKey(const WinRegKey &);
void operator=(const WinRegKey &);
};
template<class T>
inline bool QueryKey(WinRegKey & key, const wchar_t *pValueName, T &data ) {
DWORD size = sizeof(data);
return key.Query(pValueName, RegKey<T>::type, (LPBYTE) &data, &size);
}
template<>
inline bool QueryKey<bool>(WinRegKey & key, const wchar_t *pValueName, bool &data ) {
mfxU32 value = 0;
bool bRes = QueryKey(key, pValueName, value);
data = (1 == value);
return bRes;
}
} // namespace MFX
#endif // #if defined(_WIN32) || defined(_WIN64)
#endif // __MFX_WIN_REG_KEY_H

81
plugins/obs-qsv11/libmfx/include/mfxaudio_exposed_functions_list.h
View file

@ -1,81 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2013-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: mfxaudio_exposed_function_list.h
\* ****************************************************************************** */
//
// WARNING:
// this file doesn't contain an include guard by intension.
// The file may be included into a source file many times.
// That is why this header doesn't contain any include directive.
// Please, do no try to fix it.
//
//
// API version 1.8 functions
//
// Minor value should precedes the major value
#define API_VERSION {{8, 1}}
// CORE interface functions
FUNCTION(mfxStatus, MFXAudioCORE_SyncOperation, (mfxSession session, mfxSyncPoint syncp, mfxU32 wait), (session, syncp, wait))
// ENCODE interface functions
FUNCTION(mfxStatus, MFXAudioENCODE_Query, (mfxSession session, mfxAudioParam *in, mfxAudioParam *out), (session, in, out))
FUNCTION(mfxStatus, MFXAudioENCODE_QueryIOSize, (mfxSession session, mfxAudioParam *par, mfxAudioAllocRequest *request), (session, par, request))
FUNCTION(mfxStatus, MFXAudioENCODE_Init, (mfxSession session, mfxAudioParam *par), (session, par))
FUNCTION(mfxStatus, MFXAudioENCODE_Reset, (mfxSession session, mfxAudioParam *par), (session, par))
FUNCTION(mfxStatus, MFXAudioENCODE_Close, (mfxSession session), (session))
FUNCTION(mfxStatus, MFXAudioENCODE_GetAudioParam, (mfxSession session, mfxAudioParam *par), (session, par))
FUNCTION(mfxStatus, MFXAudioENCODE_EncodeFrameAsync, (mfxSession session, mfxAudioFrame *frame, mfxBitstream *buffer_out, mfxSyncPoint *syncp), (session, frame, buffer_out, syncp))
// DECODE interface functions
FUNCTION(mfxStatus, MFXAudioDECODE_Query, (mfxSession session, mfxAudioParam *in, mfxAudioParam *out), (session, in, out))
FUNCTION(mfxStatus, MFXAudioDECODE_DecodeHeader, (mfxSession session, mfxBitstream *bs, mfxAudioParam *par), (session, bs, par))
FUNCTION(mfxStatus, MFXAudioDECODE_Init, (mfxSession session, mfxAudioParam *par), (session, par))
FUNCTION(mfxStatus, MFXAudioDECODE_Reset, (mfxSession session, mfxAudioParam *par), (session, par))
FUNCTION(mfxStatus, MFXAudioDECODE_Close, (mfxSession session), (session))
FUNCTION(mfxStatus, MFXAudioDECODE_QueryIOSize, (mfxSession session, mfxAudioParam *par, mfxAudioAllocRequest *request), (session, par, request))
FUNCTION(mfxStatus, MFXAudioDECODE_GetAudioParam, (mfxSession session, mfxAudioParam *par), (session, par))
FUNCTION(mfxStatus, MFXAudioDECODE_DecodeFrameAsync, (mfxSession session, mfxBitstream *bs, mfxAudioFrame *frame_out, mfxSyncPoint *syncp), (session, bs, frame_out, syncp))
#undef API_VERSION
//
// API version 1.9 functions
//
#define API_VERSION {{9, 1}}
FUNCTION(mfxStatus, MFXAudioUSER_Register, (mfxSession session, mfxU32 type, const mfxPlugin *par), (session, type, par))
FUNCTION(mfxStatus, MFXAudioUSER_Unregister, (mfxSession session, mfxU32 type), (session, type))
FUNCTION(mfxStatus, MFXAudioUSER_ProcessFrameAsync, (mfxSession session, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp), (session, in, in_num, out, out_num, syncp))
#undef API_VERSION

172
plugins/obs-qsv11/libmfx/include/msdk/include/mfxastructures.h
View file

@ -1,172 +0,0 @@
/*******************************************************************************
Copyright (C) 2013 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: mfxastructures.h
*******************************************************************************/
#ifndef __MFXASTRUCTURES_H__
#define __MFXASTRUCTURES_H__
#include "mfxcommon.h"
#if !defined (__GNUC__)
#pragma warning(disable: 4201)
#endif
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* CodecId */
enum {
MFX_CODEC_AAC =MFX_MAKEFOURCC('A','A','C',' '),
MFX_CODEC_MP3 =MFX_MAKEFOURCC('M','P','3',' ')
};
enum {
/* AAC Profiles & Levels */
MFX_PROFILE_AAC_LC =2,
MFX_PROFILE_AAC_LTP =4,
MFX_PROFILE_AAC_MAIN =1,
MFX_PROFILE_AAC_SSR =3,
MFX_PROFILE_AAC_HE =5,
MFX_PROFILE_AAC_ALS =0x20,
MFX_PROFILE_AAC_BSAC =22,
MFX_PROFILE_AAC_PS =29,
/*MPEG AUDIO*/
MFX_AUDIO_MPEG1_LAYER1 =0x00000110,
MFX_AUDIO_MPEG1_LAYER2 =0x00000120,
MFX_AUDIO_MPEG1_LAYER3 =0x00000140,
MFX_AUDIO_MPEG2_LAYER1 =0x00000210,
MFX_AUDIO_MPEG2_LAYER2 =0x00000220,
MFX_AUDIO_MPEG2_LAYER3 =0x00000240
};
/*AAC HE decoder down sampling*/
enum {
MFX_AUDIO_AAC_HE_DWNSMPL_OFF=0,
MFX_AUDIO_AAC_HE_DWNSMPL_ON= 1
};
/* AAC decoder support of PS */
enum {
MFX_AUDIO_AAC_PS_DISABLE= 0,
MFX_AUDIO_AAC_PS_PARSER= 1,
MFX_AUDIO_AAC_PS_ENABLE_BL= 111,
MFX_AUDIO_AAC_PS_ENABLE_UR= 411
};
/*AAC decoder SBR support*/
enum {
MFX_AUDIO_AAC_SBR_DISABLE = 0,
MFX_AUDIO_AAC_SBR_ENABLE= 1,
MFX_AUDIO_AAC_SBR_UNDEF= 2
};
/*AAC header type*/
enum{
MFX_AUDIO_AAC_ADTS= 1,
MFX_AUDIO_AAC_ADIF= 2,
MFX_AUDIO_AAC_RAW= 3,
};
/*AAC encoder stereo mode*/
enum
{
MFX_AUDIO_AAC_MONO= 0,
MFX_AUDIO_AAC_LR_STEREO= 1,
MFX_AUDIO_AAC_MS_STEREO= 2,
MFX_AUDIO_AAC_JOINT_STEREO= 3
};
typedef struct {
mfxU32 CodecId;
mfxU16 CodecProfile;
mfxU16 CodecLevel;
mfxU32 Bitrate;
mfxU32 SampleFrequency;
mfxU16 NumChannel;
mfxU16 BitPerSample;
mfxU16 reserved1[22];
union {
struct { /* AAC Decoding Options */
mfxU16 FlagPSSupportLev;
mfxU16 Layer;
mfxU16 AACHeaderDataSize;
mfxU8 AACHeaderData[64];
};
struct { /* AAC Encoding Options */
mfxU16 OutputFormat;
mfxU16 StereoMode;
mfxU16 reserved2[61];
};
};
} mfxAudioInfoMFX;
typedef struct {
mfxU16 AsyncDepth;
mfxU16 Protected;
mfxU16 reserved[14];
mfxAudioInfoMFX mfx;
mfxExtBuffer** ExtParam;
mfxU16 NumExtParam;
} mfxAudioParam;
typedef struct {
mfxU32 SuggestedInputSize;
mfxU32 SuggestedOutputSize;
mfxU32 reserved[6];
} mfxAudioAllocRequest;
typedef struct {
mfxU64 TimeStamp; /* 1/90KHz */
mfxU16 Locked;
mfxU16 NumChannels;
mfxU32 SampleFrequency;
mfxU16 BitPerSample;
mfxU16 reserved1[7];
mfxU8* Data;
mfxU32 reserved2;
mfxU32 DataLength;
mfxU32 MaxLength;
mfxU32 NumExtParam;
mfxExtBuffer **ExtParam;
} mfxAudioFrame;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif

113
plugins/obs-qsv11/libmfx/include/msdk/include/mfxaudio++.h
View file

@ -1,113 +0,0 @@
/*******************************************************************************
Copyright (C) 2013 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: mfxaudio++.h
*******************************************************************************/
#ifndef __MFXAUDIOPLUSPLUS_H
#define __MFXAUDIOPLUSPLUS_H
#include "mfxaudio.h"
class MFXAudioSession
{
public:
MFXAudioSession(void) { m_session = (mfxSession) 0; }
virtual ~MFXAudioSession(void) { Close(); }
virtual mfxStatus Init(mfxIMPL impl, mfxVersion *ver) { return MFXInit(impl, ver, &m_session); }
virtual mfxStatus Close(void)
{
mfxStatus mfxRes;
mfxRes = MFXClose(m_session); m_session = (mfxSession) 0;
return mfxRes;
}
virtual mfxStatus QueryIMPL(mfxIMPL *impl) { return MFXQueryIMPL(m_session, impl); }
virtual mfxStatus QueryVersion(mfxVersion *version) { return MFXQueryVersion(m_session, version); }
virtual mfxStatus JoinSession(mfxSession child_session) { return MFXJoinSession(m_session, child_session);}
virtual mfxStatus DisjoinSession( ) { return MFXDisjoinSession(m_session);}
virtual mfxStatus CloneSession( mfxSession *clone) { return MFXCloneSession(m_session, clone);}
virtual mfxStatus SetPriority( mfxPriority priority) { return MFXSetPriority(m_session, priority);}
virtual mfxStatus GetPriority( mfxPriority *priority) { return MFXGetPriority(m_session, priority);}
virtual mfxStatus SyncOperation(mfxSyncPoint syncp, mfxU32 wait) { return MFXAudioCORE_SyncOperation(m_session, syncp, wait); }
virtual operator mfxSession (void) { return m_session; }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXAudioDECODE
{
public:
MFXAudioDECODE(mfxSession session) { m_session = session; }
virtual ~MFXAudioDECODE(void) { Close(); }
virtual mfxStatus Query(mfxAudioParam *in, mfxAudioParam *out) { return MFXAudioDECODE_Query(m_session, in, out); }
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxAudioParam *par) { return MFXAudioDECODE_DecodeHeader(m_session, bs, par); }
virtual mfxStatus QueryIOSize(mfxAudioParam *par, mfxAudioAllocRequest *request) { return MFXAudioDECODE_QueryIOSize(m_session, par, request); }
virtual mfxStatus Init(mfxAudioParam *par) { return MFXAudioDECODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxAudioParam *par) { return MFXAudioDECODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXAudioDECODE_Close(m_session); }
virtual mfxStatus GetAudioParam(mfxAudioParam *par) { return MFXAudioDECODE_GetAudioParam(m_session, par); }
virtual mfxStatus DecodeFrameAsync(mfxBitstream *bs, mfxAudioFrame *frame, mfxSyncPoint *syncp) { return MFXAudioDECODE_DecodeFrameAsync(m_session, bs, frame, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXAudioENCODE
{
public:
MFXAudioENCODE(mfxSession session) { m_session = session; }
virtual ~MFXAudioENCODE(void) { Close(); }
virtual mfxStatus Query(mfxAudioParam *in, mfxAudioParam *out) { return MFXAudioENCODE_Query(m_session, in, out); }
virtual mfxStatus QueryIOSize(mfxAudioParam *par, mfxAudioAllocRequest *request) { return MFXAudioENCODE_QueryIOSize(m_session, par, request); }
virtual mfxStatus Init(mfxAudioParam *par) { return MFXAudioENCODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxAudioParam *par) { return MFXAudioENCODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXAudioENCODE_Close(m_session); }
virtual mfxStatus GetAudioParam(mfxAudioParam *par) { return MFXAudioENCODE_GetAudioParam(m_session, par); }
virtual mfxStatus EncodeFrameAsync(mfxAudioFrame *frame, mfxBitstream *buffer_out, mfxSyncPoint *syncp) { return MFXAudioENCODE_EncodeFrameAsync(m_session, frame, buffer_out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
#endif

70
plugins/obs-qsv11/libmfx/include/msdk/include/mfxaudio.h
View file

@ -1,70 +0,0 @@
/*******************************************************************************
Copyright (C) 2013 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: mfxaudio.h
*******************************************************************************/
#ifndef __MFXAUDIO_H__
#define __MFXAUDIO_H__
#include "mfxsession.h"
#include "mfxastructures.h"
#define MFX_AUDIO_VERSION_MAJOR 1
#define MFX_AUDIO_VERSION_MINOR 15
#ifdef __cplusplus
extern "C"
{
#endif
/* AudioCORE */
mfxStatus MFX_CDECL MFXAudioCORE_SyncOperation(mfxSession session, mfxSyncPoint syncp, mfxU32 wait);
/* AudioENCODE */
mfxStatus MFX_CDECL MFXAudioENCODE_Query(mfxSession session, mfxAudioParam *in, mfxAudioParam *out);
mfxStatus MFX_CDECL MFXAudioENCODE_QueryIOSize(mfxSession session, mfxAudioParam *par, mfxAudioAllocRequest *request);
mfxStatus MFX_CDECL MFXAudioENCODE_Init(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioENCODE_Reset(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioENCODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXAudioENCODE_GetAudioParam(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioENCODE_EncodeFrameAsync(mfxSession session, mfxAudioFrame *frame, mfxBitstream *bs, mfxSyncPoint *syncp);
/* AudioDECODE */
mfxStatus MFX_CDECL MFXAudioDECODE_Query(mfxSession session, mfxAudioParam *in, mfxAudioParam *out);
mfxStatus MFX_CDECL MFXAudioDECODE_DecodeHeader(mfxSession session, mfxBitstream *bs, mfxAudioParam* par);
mfxStatus MFX_CDECL MFXAudioDECODE_Init(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioDECODE_Reset(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioDECODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXAudioDECODE_QueryIOSize(mfxSession session, mfxAudioParam *par, mfxAudioAllocRequest *request);
mfxStatus MFX_CDECL MFXAudioDECODE_GetAudioParam(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioDECODE_DecodeFrameAsync(mfxSession session, mfxBitstream *bs, mfxAudioFrame *frame, mfxSyncPoint *syncp);
#ifdef __cplusplus
} // extern "C"
#endif
#endif

159
plugins/obs-qsv11/libmfx/include/msdk/include/mfxcommon.h
View file

@ -1,159 +0,0 @@
/*******************************************************************************
Copyright (C) 2013-2015 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: mfxcommon.h
*******************************************************************************/
#ifndef __MFXCOMMON_H__
#define __MFXCOMMON_H__
#include "mfxdefs.h"
#if !defined (__GNUC__)
#pragma warning(disable: 4201)
#endif
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#define MFX_MAKEFOURCC(A,B,C,D) ((((int)A))+(((int)B)<<8)+(((int)C)<<16)+(((int)D)<<24))
/* Extended Configuration Header Structure */
typedef struct {
mfxU32 BufferId;
mfxU32 BufferSz;
} mfxExtBuffer;
/* Library initialization and deinitialization */
typedef mfxI32 mfxIMPL;
#define MFX_IMPL_BASETYPE(x) (0x00ff & (x))
enum {
MFX_IMPL_AUTO = 0x0000, /* Auto Selection/In or Not Supported/Out */
MFX_IMPL_SOFTWARE = 0x0001, /* Pure Software Implementation */
MFX_IMPL_HARDWARE = 0x0002, /* Hardware Accelerated Implementation (default device) */
MFX_IMPL_AUTO_ANY = 0x0003, /* Auto selection of any hardware/software implementation */
MFX_IMPL_HARDWARE_ANY = 0x0004, /* Auto selection of any hardware implementation */
MFX_IMPL_HARDWARE2 = 0x0005, /* Hardware accelerated implementation (2nd device) */
MFX_IMPL_HARDWARE3 = 0x0006, /* Hardware accelerated implementation (3rd device) */
MFX_IMPL_HARDWARE4 = 0x0007, /* Hardware accelerated implementation (4th device) */
MFX_IMPL_RUNTIME = 0x0008,
MFX_IMPL_VIA_ANY = 0x0100,
MFX_IMPL_VIA_D3D9 = 0x0200,
MFX_IMPL_VIA_D3D11 = 0x0300,
MFX_IMPL_VIA_VAAPI = 0x0400,
MFX_IMPL_AUDIO = 0x8000,
MFX_IMPL_UNSUPPORTED = 0x0000 /* One of the MFXQueryIMPL returns */
};
/* Version Info */
typedef union {
struct {
mfxU16 Minor;
mfxU16 Major;
};
mfxU32 Version;
} mfxVersion;
/* session priority */
typedef enum
{
MFX_PRIORITY_LOW = 0,
MFX_PRIORITY_NORMAL = 1,
MFX_PRIORITY_HIGH = 2
} mfxPriority;
typedef struct _mfxEncryptedData mfxEncryptedData;
typedef struct {
union {
struct {
mfxEncryptedData* EncryptedData;
mfxExtBuffer **ExtParam;
mfxU16 NumExtParam;
};
mfxU32 reserved[6];
};
mfxI64 DecodeTimeStamp;
mfxU64 TimeStamp;
mfxU8* Data;
mfxU32 DataOffset;
mfxU32 DataLength;
mfxU32 MaxLength;
mfxU16 PicStruct;
mfxU16 FrameType;
mfxU16 DataFlag;
mfxU16 reserved2;
} mfxBitstream;
typedef struct _mfxSyncPoint *mfxSyncPoint;
/* GPUCopy */
enum {
MFX_GPUCOPY_DEFAULT = 0,
MFX_GPUCOPY_ON = 1,
MFX_GPUCOPY_OFF = 2
};
typedef struct {
mfxIMPL Implementation;
mfxVersion Version;
mfxU16 ExternalThreads;
union {
struct {
mfxExtBuffer **ExtParam;
mfxU16 NumExtParam;
};
mfxU16 reserved2[5];
};
mfxU16 GPUCopy;
mfxU16 reserved[21];
} mfxInitParam;
enum {
MFX_EXTBUFF_THREADS_PARAM = MFX_MAKEFOURCC('T','H','D','P')
};
typedef struct {
mfxExtBuffer Header;
mfxU16 NumThread;
mfxI32 SchedulingType;
mfxI32 Priority;
mfxU16 reserved[55];
} mfxExtThreadsParam;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif

153
plugins/obs-qsv11/libmfx/include/msdk/include/mfxdefs.h
View file

@ -1,153 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2007-2015 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: mfxdefs.h
\* ****************************************************************************** */
#ifndef __MFXDEFS_H__
#define __MFXDEFS_H__
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#if (defined( _WIN32 ) || defined ( _WIN64 )) && !defined (__GNUC__)
#define __INT64 __int64
#define __UINT64 unsigned __int64
#else
#define __INT64 long long
#define __UINT64 unsigned long long
#endif
#ifdef _WIN32
#define MFX_CDECL __cdecl
#define MFX_STDCALL __stdcall
#else
#define MFX_CDECL
#define MFX_STDCALL
#endif /* _WIN32 */
#define MFX_INFINITE 0xFFFFFFFF
typedef unsigned char mfxU8;
typedef char mfxI8;
typedef short mfxI16;
typedef unsigned short mfxU16;
typedef unsigned int mfxU32;
typedef int mfxI32;
#if defined( _WIN32 ) || defined ( _WIN64 )
typedef unsigned long mfxUL32;
typedef long mfxL32;
#else
typedef unsigned int mfxUL32;
typedef int mfxL32;
#endif
typedef float mfxF32;
typedef double mfxF64;
typedef __UINT64 mfxU64;
typedef __INT64 mfxI64;
typedef void* mfxHDL;
typedef mfxHDL mfxMemId;
typedef void* mfxThreadTask;
typedef char mfxChar;
typedef struct {
mfxI16 x;
mfxI16 y;
} mfxI16Pair;
typedef struct {
mfxHDL first;
mfxHDL second;
} mfxHDLPair;
/*********************************************************************************\
Error message
\*********************************************************************************/
typedef enum
{
/* no error */
MFX_ERR_NONE = 0, /* no error */
/* reserved for unexpected errors */
MFX_ERR_UNKNOWN = -1, /* unknown error. */
/* error codes <0 */
MFX_ERR_NULL_PTR = -2, /* null pointer */
MFX_ERR_UNSUPPORTED = -3, /* undeveloped feature */
MFX_ERR_MEMORY_ALLOC = -4, /* failed to allocate memory */
MFX_ERR_NOT_ENOUGH_BUFFER = -5, /* insufficient buffer at input/output */
MFX_ERR_INVALID_HANDLE = -6, /* invalid handle */
MFX_ERR_LOCK_MEMORY = -7, /* failed to lock the memory block */
MFX_ERR_NOT_INITIALIZED = -8, /* member function called before initialization */
MFX_ERR_NOT_FOUND = -9, /* the specified object is not found */
MFX_ERR_MORE_DATA = -10, /* expect more data at input */
MFX_ERR_MORE_SURFACE = -11, /* expect more surface at output */
MFX_ERR_ABORTED = -12, /* operation aborted */
MFX_ERR_DEVICE_LOST = -13, /* lose the HW acceleration device */
MFX_ERR_INCOMPATIBLE_VIDEO_PARAM = -14, /* incompatible video parameters */
MFX_ERR_INVALID_VIDEO_PARAM = -15, /* invalid video parameters */
MFX_ERR_UNDEFINED_BEHAVIOR = -16, /* undefined behavior */
MFX_ERR_DEVICE_FAILED = -17, /* device operation failure */
MFX_ERR_MORE_BITSTREAM = -18, /* expect more bitstream buffers at output */
MFX_ERR_INCOMPATIBLE_AUDIO_PARAM = -19, /* incompatible audio parameters */
MFX_ERR_INVALID_AUDIO_PARAM = -20, /* invalid audio parameters */
/* warnings >0 */
MFX_WRN_IN_EXECUTION = 1, /* the previous asynchronous operation is in execution */
MFX_WRN_DEVICE_BUSY = 2, /* the HW acceleration device is busy */
MFX_WRN_VIDEO_PARAM_CHANGED = 3, /* the video parameters are changed during decoding */
MFX_WRN_PARTIAL_ACCELERATION = 4, /* SW is used */
MFX_WRN_INCOMPATIBLE_VIDEO_PARAM = 5, /* incompatible video parameters */
MFX_WRN_VALUE_NOT_CHANGED = 6, /* the value is saturated based on its valid range */
MFX_WRN_OUT_OF_RANGE = 7, /* the value is out of valid range */
MFX_WRN_FILTER_SKIPPED = 10, /* one of requested filters has been skipped */
MFX_WRN_INCOMPATIBLE_AUDIO_PARAM = 11, /* incompatible audio parameters */
/* threading statuses */
MFX_TASK_DONE = MFX_ERR_NONE, /* task has been completed */
MFX_TASK_WORKING = 8, /* there is some more work to do */
MFX_TASK_BUSY = 9 /* task is waiting for resources */
} mfxStatus;
// Application
#if defined(MFX_DISPATCHER_EXPOSED_PREFIX)
#include "mfxdispatcherprefixedfunctions.h"
#endif // MFX_DISPATCHER_EXPOSED_PREFIX
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __MFXDEFS_H__ */

80
plugins/obs-qsv11/libmfx/include/msdk/include/mfxenc.h
View file

@ -1,80 +0,0 @@
/******************************************************************************* *\
Copyright (C) 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: mfxenc.h
*******************************************************************************/
#ifndef __MFXENC_H__
#define __MFXENC_H__
#include "mfxdefs.h"
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
typedef struct _mfxENCInput mfxENCInput;
struct _mfxENCInput{
mfxU32 reserved[32];
mfxFrameSurface1 *InSurface;
mfxU16 NumFrameL0;
mfxFrameSurface1 **L0Surface;
mfxU16 NumFrameL1;
mfxFrameSurface1 **L1Surface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
} ;
typedef struct _mfxENCOutput mfxENCOutput;
struct _mfxENCOutput{
mfxU32 reserved[32];
mfxFrameSurface1 *OutSurface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
} ;
mfxStatus MFX_CDECL MFXVideoENC_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoENC_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
mfxStatus MFX_CDECL MFXVideoENC_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENC_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENC_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoENC_ProcessFrameAsync(mfxSession session, mfxENCInput *in, mfxENCOutput *out, mfxSyncPoint *syncp);
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

107
plugins/obs-qsv11/libmfx/include/msdk/include/mfxjpeg.h
View file

@ -1,107 +0,0 @@
/******************************************************************************* *\
Copyright (C) 2010-2013 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: mfxjpeg.h
*******************************************************************************/
#ifndef __MFX_JPEG_H__
#define __MFX_JPEG_H__
#include "mfxdefs.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* CodecId */
enum {
MFX_CODEC_JPEG = MFX_MAKEFOURCC('J','P','E','G')
};
/* CodecProfile, CodecLevel */
enum
{
MFX_PROFILE_JPEG_BASELINE = 1
};
enum
{
MFX_ROTATION_0 = 0,
MFX_ROTATION_90 = 1,
MFX_ROTATION_180 = 2,
MFX_ROTATION_270 = 3
};
enum {
MFX_EXTBUFF_JPEG_QT = MFX_MAKEFOURCC('J','P','G','Q'),
MFX_EXTBUFF_JPEG_HUFFMAN = MFX_MAKEFOURCC('J','P','G','H')
};
enum {
MFX_JPEG_COLORFORMAT_UNKNOWN = 0,
MFX_JPEG_COLORFORMAT_YCbCr = 1,
MFX_JPEG_COLORFORMAT_RGB = 2
};
enum {
MFX_SCANTYPE_UNKNOWN = 0,
MFX_SCANTYPE_INTERLEAVED = 1,
MFX_SCANTYPE_NONINTERLEAVED = 2
};
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved[7];
mfxU16 NumTable;
mfxU16 Qm[4][64];
} mfxExtJPEGQuantTables;
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved[2];
mfxU16 NumDCTable;
mfxU16 NumACTable;
struct {
mfxU8 Bits[16];
mfxU8 Values[12];
} DCTables[4];
struct {
mfxU8 Bits[16];
mfxU8 Values[162];
} ACTables[4];
} mfxExtJPEGHuffmanTables;
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif // __MFX_JPEG_H__

109
plugins/obs-qsv11/libmfx/include/msdk/include/mfxmvc.h
View file

@ -1,109 +0,0 @@
/******************************************************************************* *\
Copyright (C) 2010-2013 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: mfxmvc.h
*******************************************************************************/
#ifndef __MFXMVC_H__
#define __MFXMVC_H__
#include "mfxdefs.h"
#ifdef __cplusplus
extern "C" {
#endif
/* CodecProfile, CodecLevel */
enum {
/* MVC profiles */
MFX_PROFILE_AVC_MULTIVIEW_HIGH =118,
MFX_PROFILE_AVC_STEREO_HIGH =128
};
/* Extended Buffer Ids */
enum {
MFX_EXTBUFF_MVC_SEQ_DESC = MFX_MAKEFOURCC('M','V','C','D'),
MFX_EXTBUFF_MVC_TARGET_VIEWS = MFX_MAKEFOURCC('M','V','C','T')
};
typedef struct {
mfxU16 ViewId;
mfxU16 NumAnchorRefsL0;
mfxU16 NumAnchorRefsL1;
mfxU16 AnchorRefL0[16];
mfxU16 AnchorRefL1[16];
mfxU16 NumNonAnchorRefsL0;
mfxU16 NumNonAnchorRefsL1;
mfxU16 NonAnchorRefL0[16];
mfxU16 NonAnchorRefL1[16];
} mfxMVCViewDependency;
typedef struct {
mfxU16 TemporalId;
mfxU16 LevelIdc;
mfxU16 NumViews;
mfxU16 NumTargetViews;
mfxU16 *TargetViewId;
} mfxMVCOperationPoint;
typedef struct {
mfxExtBuffer Header;
mfxU32 NumView;
mfxU32 NumViewAlloc;
mfxMVCViewDependency *View;
mfxU32 NumViewId;
mfxU32 NumViewIdAlloc;
mfxU16 *ViewId;
mfxU32 NumOP;
mfxU32 NumOPAlloc;
mfxMVCOperationPoint *OP;
mfxU16 NumRefsTotal;
mfxU32 Reserved[16];
} mfxExtMVCSeqDesc;
typedef struct {
mfxExtBuffer Header;
mfxU16 TemporalId;
mfxU32 NumView;
mfxU16 ViewId[1024];
} mfxExtMVCTargetViews ;
#ifdef __cplusplus
} // extern "C"
#endif
#endif

78
plugins/obs-qsv11/libmfx/include/msdk/include/mfxpak.h
View file

@ -1,78 +0,0 @@
/******************************************************************************* *\
Copyright (C) 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: mfxpak.h
*******************************************************************************/
#ifndef __MFXPAK_H__
#define __MFXPAK_H__
#include "mfxdefs.h"
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
typedef struct {
mfxU32 reserved[32];
mfxFrameSurface1 *InSurface;
mfxU16 NumFrameL0;
mfxFrameSurface1 **L0Surface;
mfxU16 NumFrameL1;
mfxFrameSurface1 **L1Surface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
} mfxPAKInput;
typedef struct {
mfxBitstream *Bs;
mfxFrameSurface1 *OutSurface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
} mfxPAKOutput;
typedef struct _mfxSession *mfxSession;
mfxStatus MFX_CDECL MFXVideoPAK_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoPAK_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
mfxStatus MFX_CDECL MFXVideoPAK_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoPAK_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoPAK_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoPAK_ProcessFrameAsync(mfxSession session, mfxPAKInput *in, mfxPAKOutput *out, mfxSyncPoint *syncp);
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

719
plugins/obs-qsv11/libmfx/include/msdk/include/mfxplugin++.h
View file

@ -1,719 +0,0 @@
/* ****************************************************************************** *\
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

206
plugins/obs-qsv11/libmfx/include/msdk/include/mfxplugin.h
View file

@ -1,206 +0,0 @@
/******************************************************************************* *\
Copyright (C) 2007-2015 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 __MFXPLUGIN_H__
#define __MFXPLUGIN_H__
#include "mfxvideo.h"
#include "mfxaudio.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
typedef struct {
mfxU8 Data[16];
} mfxPluginUID;
static const mfxPluginUID MFX_PLUGINID_HEVCD_SW = {{0x15, 0xdd, 0x93, 0x68, 0x25, 0xad, 0x47, 0x5e, 0xa3, 0x4e, 0x35, 0xf3, 0xf5, 0x42, 0x17, 0xa6}};
static const mfxPluginUID MFX_PLUGINID_HEVCD_HW = {{0x33, 0xa6, 0x1c, 0x0b, 0x4c, 0x27, 0x45, 0x4c, 0xa8, 0xd8, 0x5d, 0xde, 0x75, 0x7c, 0x6f, 0x8e}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_SW = {{0x2f, 0xca, 0x99, 0x74, 0x9f, 0xdb, 0x49, 0xae, 0xb1, 0x21, 0xa5, 0xb6, 0x3e, 0xf5, 0x68, 0xf7}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_GACC = {{0xe5, 0x40, 0x0a, 0x06, 0xc7, 0x4d, 0x41, 0xf5, 0xb1, 0x2d, 0x43, 0x0b, 0xba, 0xa2, 0x3d, 0x0b}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_HW = {{0x6f, 0xad, 0xc7, 0x91, 0xa0, 0xc2, 0xeb, 0x47, 0x9a, 0xb6, 0xdc, 0xd5, 0xea, 0x9d, 0xa3, 0x47}};
static const mfxPluginUID MFX_PLUGINID_VP8D_HW = {{0xf6, 0x22, 0x39, 0x4d, 0x8d, 0x87, 0x45, 0x2f, 0x87, 0x8c, 0x51, 0xf2, 0xfc, 0x9b, 0x41, 0x31}};
static const mfxPluginUID MFX_PLUGINID_VP8E_HW = {{0xbf, 0xfc, 0x51, 0x8c, 0xde, 0x13, 0x4d, 0xf9, 0x8a, 0x96, 0xf4, 0xcf, 0x81, 0x6c, 0x0f, 0xac}};
static const mfxPluginUID MFX_PLUGINID_VP9E_HW = {{0xce, 0x44, 0xef, 0x6f, 0x1a, 0x6d, 0x22, 0x46, 0xb4, 0x12, 0xbb, 0x38, 0xd6, 0xe4, 0x51, 0x82}};
static const mfxPluginUID MFX_PLUGINID_VP9D_HW = {{0xa9, 0x22, 0x39, 0x4d, 0x8d, 0x87, 0x45, 0x2f, 0x87, 0x8c, 0x51, 0xf2, 0xfc, 0x9b, 0x41, 0x31}};
static const mfxPluginUID MFX_PLUGINID_CAMERA_HW = {{0x54, 0x54, 0x26, 0x16, 0x24, 0x33, 0x41, 0xe6, 0x93, 0xae, 0x89, 0x99, 0x42, 0xce, 0x73, 0x55}};
static const mfxPluginUID MFX_PLUGINID_CAPTURE_HW = {{0x22, 0xd6, 0x2c, 0x07, 0xe6, 0x72, 0x40, 0x8f, 0xbb, 0x4c, 0xc2, 0x0e, 0xd7, 0xa0, 0x53, 0xe4}};
static const mfxPluginUID MFX_PLUGINID_ITELECINE_HW = {{0xe7, 0x44, 0x75, 0x3a, 0xcd, 0x74, 0x40, 0x2e, 0x89, 0xa2, 0xee, 0x06, 0x35, 0x49, 0x61, 0x79}};
static const mfxPluginUID MFX_PLUGINID_H264LA_HW = {{0x58, 0x8f, 0x11, 0x85, 0xd4, 0x7b, 0x42, 0x96, 0x8d, 0xea, 0x37, 0x7b, 0xb5, 0xd0, 0xdc, 0xb4}};
static const mfxPluginUID MFX_PLUGINID_AACD = {{0xe9, 0x34, 0x67, 0x25, 0xac, 0x2f, 0x4c, 0x93, 0xaa, 0x58, 0x5c, 0x11, 0xc7, 0x08, 0x7c, 0xf4}};
static const mfxPluginUID MFX_PLUGINID_AACE = {{0xb2, 0xa2, 0xa0, 0x5a, 0x4e, 0xac, 0x46, 0xbf, 0xa9, 0xde, 0x7e, 0x80, 0xc9, 0x8d, 0x2e, 0x18}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_FEI_HW = {{0x87, 0xe0, 0xe8, 0x02, 0x07, 0x37, 0x52, 0x40, 0x85, 0x25, 0x15, 0xcf, 0x4a, 0x5e, 0xdd, 0xe6}};
typedef enum {
MFX_PLUGINTYPE_VIDEO_GENERAL = 0,
MFX_PLUGINTYPE_VIDEO_DECODE = 1,
MFX_PLUGINTYPE_VIDEO_ENCODE = 2,
MFX_PLUGINTYPE_VIDEO_VPP = 3,
MFX_PLUGINTYPE_VIDEO_ENC = 4,
MFX_PLUGINTYPE_AUDIO_DECODE = 5,
MFX_PLUGINTYPE_AUDIO_ENCODE = 6
} mfxPluginType;
typedef enum {
MFX_THREADPOLICY_SERIAL = 0,
MFX_THREADPOLICY_PARALLEL = 1
} mfxThreadPolicy;
typedef struct mfxPluginParam {
mfxU32 reserved[6];
mfxU16 reserved1;
mfxU16 PluginVersion;
mfxVersion APIVersion;
mfxPluginUID PluginUID;
mfxU32 Type;
mfxU32 CodecId;
mfxThreadPolicy ThreadPolicy;
mfxU32 MaxThreadNum;
} mfxPluginParam;
typedef struct mfxCoreParam{
mfxU32 reserved[13];
mfxIMPL Impl;
mfxVersion Version;
mfxU32 NumWorkingThread;
} mfxCoreParam;
typedef struct mfxCoreInterface {
mfxHDL pthis;
mfxHDL reserved1[2];
mfxFrameAllocator FrameAllocator;
mfxBufferAllocator reserved3;
mfxStatus (MFX_CDECL *GetCoreParam)(mfxHDL pthis, mfxCoreParam *par);
mfxStatus (MFX_CDECL *GetHandle) (mfxHDL pthis, mfxHandleType type, mfxHDL *handle);
mfxStatus (MFX_CDECL *IncreaseReference) (mfxHDL pthis, mfxFrameData *fd);
mfxStatus (MFX_CDECL *DecreaseReference) (mfxHDL pthis, mfxFrameData *fd);
mfxStatus (MFX_CDECL *CopyFrame) (mfxHDL pthis, mfxFrameSurface1 *dst, mfxFrameSurface1 *src);
mfxStatus (MFX_CDECL *CopyBuffer)(mfxHDL pthis, mfxU8 *dst, mfxU32 size, mfxFrameSurface1 *src);
mfxStatus (MFX_CDECL *MapOpaqueSurface)(mfxHDL pthis, mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf);
mfxStatus (MFX_CDECL *UnmapOpaqueSurface)(mfxHDL pthis, mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf);
mfxStatus (MFX_CDECL *GetRealSurface)(mfxHDL pthis, mfxFrameSurface1 *op_surf, mfxFrameSurface1 **surf);
mfxStatus (MFX_CDECL *GetOpaqueSurface)(mfxHDL pthis, mfxFrameSurface1 *surf, mfxFrameSurface1 **op_surf);
mfxStatus (MFX_CDECL *CreateAccelerationDevice)(mfxHDL pthis, mfxHandleType type, mfxHDL *handle);
mfxHDL reserved4[3];
} mfxCoreInterface;
/* video codec plugin extension*/
typedef struct _mfxENCInput mfxENCInput;
typedef struct _mfxENCOutput mfxENCOutput;
typedef struct mfxVideoCodecPlugin{
mfxStatus (MFX_CDECL *Query)(mfxHDL pthis, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus (MFX_CDECL *QueryIOSurf)(mfxHDL pthis, mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out);
mfxStatus (MFX_CDECL *Init)(mfxHDL pthis, mfxVideoParam *par);
mfxStatus (MFX_CDECL *Reset)(mfxHDL pthis, mfxVideoParam *par);
mfxStatus (MFX_CDECL *Close)(mfxHDL pthis);
mfxStatus (MFX_CDECL *GetVideoParam)(mfxHDL pthis, mfxVideoParam *par);
mfxStatus (MFX_CDECL *EncodeFrameSubmit)(mfxHDL pthis, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxThreadTask *task);
mfxStatus (MFX_CDECL *DecodeHeader)(mfxHDL pthis, mfxBitstream *bs, mfxVideoParam *par);
mfxStatus (MFX_CDECL *GetPayload)(mfxHDL pthis, mfxU64 *ts, mfxPayload *payload);
mfxStatus (MFX_CDECL *DecodeFrameSubmit)(mfxHDL pthis, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task);
mfxStatus (MFX_CDECL *VPPFrameSubmit)(mfxHDL pthis, mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxThreadTask *task);
mfxStatus (MFX_CDECL *VPPFrameSubmitEx)(mfxHDL pthis, mfxFrameSurface1 *in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task);
mfxStatus (MFX_CDECL *ENCFrameSubmit)(mfxHDL pthis, mfxENCInput *in, mfxENCOutput *out, mfxThreadTask *task);
mfxHDL reserved1[3];
mfxU32 reserved2[8];
} mfxVideoCodecPlugin;
typedef struct mfxAudioCodecPlugin{
mfxStatus (MFX_CDECL *Query)(mfxHDL pthis, mfxAudioParam *in, mfxAudioParam *out);
mfxStatus (MFX_CDECL *QueryIOSize)(mfxHDL pthis, mfxAudioParam *par, mfxAudioAllocRequest *request);
mfxStatus (MFX_CDECL *Init)(mfxHDL pthis, mfxAudioParam *par);
mfxStatus (MFX_CDECL *Reset)(mfxHDL pthis, mfxAudioParam *par);
mfxStatus (MFX_CDECL *Close)(mfxHDL pthis);
mfxStatus (MFX_CDECL *GetAudioParam)(mfxHDL pthis, mfxAudioParam *par);
mfxStatus (MFX_CDECL *EncodeFrameSubmit)(mfxHDL pthis, mfxAudioFrame *aFrame, mfxBitstream *out, mfxThreadTask *task);
mfxStatus (MFX_CDECL *DecodeHeader)(mfxHDL pthis, mfxBitstream *bs, mfxAudioParam *par);
// mfxStatus (MFX_CDECL *GetPayload)(mfxHDL pthis, mfxU64 *ts, mfxPayload *payload);
mfxStatus (MFX_CDECL *DecodeFrameSubmit)(mfxHDL pthis, mfxBitstream *in, mfxAudioFrame *out, mfxThreadTask *task);
mfxHDL reserved1[6];
mfxU32 reserved2[8];
} mfxAudioCodecPlugin;
typedef struct mfxPlugin{
mfxHDL pthis;
mfxStatus (MFX_CDECL *PluginInit) (mfxHDL pthis, mfxCoreInterface *core);
mfxStatus (MFX_CDECL *PluginClose) (mfxHDL pthis);
mfxStatus (MFX_CDECL *GetPluginParam)(mfxHDL pthis, mfxPluginParam *par);
mfxStatus (MFX_CDECL *Submit)(mfxHDL pthis, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task);
mfxStatus (MFX_CDECL *Execute)(mfxHDL pthis, mfxThreadTask task, mfxU32 uid_p, mfxU32 uid_a);
mfxStatus (MFX_CDECL *FreeResources)(mfxHDL pthis, mfxThreadTask task, mfxStatus sts);
union {
mfxVideoCodecPlugin *Video;
mfxAudioCodecPlugin *Audio;
};
mfxHDL reserved[8];
} mfxPlugin;
mfxStatus MFX_CDECL MFXVideoUSER_Register(mfxSession session, mfxU32 type, const mfxPlugin *par);
mfxStatus MFX_CDECL MFXVideoUSER_Unregister(mfxSession session, mfxU32 type);
mfxStatus MFX_CDECL MFXVideoUSER_ProcessFrameAsync(mfxSession session, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXVideoUSER_Load(mfxSession session, const mfxPluginUID *uid, mfxU32 version);
mfxStatus MFX_CDECL MFXVideoUSER_LoadByPath(mfxSession session, const mfxPluginUID *uid, mfxU32 version, const mfxChar *path, mfxU32 len);
mfxStatus MFX_CDECL MFXVideoUSER_UnLoad(mfxSession session, const mfxPluginUID *uid);
mfxStatus MFX_CDECL MFXAudioUSER_Register(mfxSession session, mfxU32 type, const mfxPlugin *par);
mfxStatus MFX_CDECL MFXAudioUSER_Unregister(mfxSession session, mfxU32 type);
mfxStatus MFX_CDECL MFXAudioUSER_ProcessFrameAsync(mfxSession session, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXAudioUSER_Load(mfxSession session, const mfxPluginUID *uid, mfxU32 version);
mfxStatus MFX_CDECL MFXAudioUSER_UnLoad(mfxSession session, const mfxPluginUID *uid);
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif /* __MFXPLUGIN_H__ */

60
plugins/obs-qsv11/libmfx/include/msdk/include/mfxsession.h
View file

@ -1,60 +0,0 @@
/*******************************************************************************
Copyright (C) 2013 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: mfxsession.h
*******************************************************************************/
#ifndef __MFXSESSION_H__
#define __MFXSESSION_H__
#include "mfxcommon.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* Global Functions */
typedef struct _mfxSession *mfxSession;
mfxStatus MFX_CDECL MFXInit(mfxIMPL impl, mfxVersion *ver, mfxSession *session);
mfxStatus MFX_CDECL MFXInitEx(mfxInitParam par, mfxSession *session);
mfxStatus MFX_CDECL MFXClose(mfxSession session);
mfxStatus MFX_CDECL MFXQueryIMPL(mfxSession session, mfxIMPL *impl);
mfxStatus MFX_CDECL MFXQueryVersion(mfxSession session, mfxVersion *version);
mfxStatus MFX_CDECL MFXJoinSession(mfxSession session, mfxSession child);
mfxStatus MFX_CDECL MFXDisjoinSession(mfxSession session);
mfxStatus MFX_CDECL MFXCloneSession(mfxSession session, mfxSession *clone);
mfxStatus MFX_CDECL MFXSetPriority(mfxSession session, mfxPriority priority);
mfxStatus MFX_CDECL MFXGetPriority(mfxSession session, mfxPriority *priority);
mfxStatus MFX_CDECL MFXDoWork(mfxSession session);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif

1379
plugins/obs-qsv11/libmfx/include/msdk/include/mfxstructures.h
View file

File diff suppressed because it is too large Load diff

197
plugins/obs-qsv11/libmfx/include/msdk/include/mfxvideo++.h
View file

@ -1,197 +0,0 @@
/* ****************************************************************************** *\
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: mfxvideo++.h
\* ****************************************************************************** */
#ifndef __MFXVIDEOPLUSPLUS_H
#define __MFXVIDEOPLUSPLUS_H
#include "mfxvideo.h"
#include "mfxenc.h"
#include "mfxpak.h"
class MFXVideoSession
{
public:
MFXVideoSession(void) { m_session = (mfxSession) 0; }
virtual ~MFXVideoSession(void) { Close(); }
virtual mfxStatus Init(mfxIMPL impl, mfxVersion *ver) { return MFXInit(impl, ver, &m_session); }
virtual mfxStatus InitEx(mfxInitParam par) { return MFXInitEx(par, &m_session); }
virtual mfxStatus Close(void)
{
mfxStatus mfxRes;
mfxRes = MFXClose(m_session); m_session = (mfxSession) 0;
return mfxRes;
}
virtual mfxStatus QueryIMPL(mfxIMPL *impl) { return MFXQueryIMPL(m_session, impl); }
virtual mfxStatus QueryVersion(mfxVersion *version) { return MFXQueryVersion(m_session, version); }
virtual mfxStatus JoinSession(mfxSession child_session) { return MFXJoinSession(m_session, child_session);}
virtual mfxStatus DisjoinSession( ) { return MFXDisjoinSession(m_session);}
virtual mfxStatus CloneSession( mfxSession *clone) { return MFXCloneSession(m_session, clone);}
virtual mfxStatus SetPriority( mfxPriority priority) { return MFXSetPriority(m_session, priority);}
virtual mfxStatus GetPriority( mfxPriority *priority) { return MFXGetPriority(m_session, priority);}
virtual mfxStatus SetBufferAllocator(mfxBufferAllocator *allocator) { return MFXVideoCORE_SetBufferAllocator(m_session, allocator); }
virtual mfxStatus SetFrameAllocator(mfxFrameAllocator *allocator) { return MFXVideoCORE_SetFrameAllocator(m_session, allocator); }
virtual mfxStatus SetHandle(mfxHandleType type, mfxHDL hdl) { return MFXVideoCORE_SetHandle(m_session, type, hdl); }
virtual mfxStatus GetHandle(mfxHandleType type, mfxHDL *hdl) { return MFXVideoCORE_GetHandle(m_session, type, hdl); }
virtual mfxStatus SyncOperation(mfxSyncPoint syncp, mfxU32 wait) { return MFXVideoCORE_SyncOperation(m_session, syncp, wait); }
virtual mfxStatus DoWork() { return MFXDoWork(m_session); }
virtual operator mfxSession (void) { return m_session; }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
private:
MFXVideoSession(const MFXVideoSession &);
void operator=(MFXVideoSession &);
};
class MFXVideoENCODE
{
public:
MFXVideoENCODE(mfxSession session) { m_session = session; }
virtual ~MFXVideoENCODE(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoENCODE_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoENCODE_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoENCODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoENCODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoENCODE_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoENCODE_GetVideoParam(m_session, par); }
virtual mfxStatus GetEncodeStat(mfxEncodeStat *stat) { return MFXVideoENCODE_GetEncodeStat(m_session, stat); }
virtual mfxStatus EncodeFrameAsync(mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxSyncPoint *syncp) { return MFXVideoENCODE_EncodeFrameAsync(m_session, ctrl, surface, bs, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoDECODE
{
public:
MFXVideoDECODE(mfxSession session) { m_session = session; }
virtual ~MFXVideoDECODE(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoDECODE_Query(m_session, in, out); }
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxVideoParam *par) { return MFXVideoDECODE_DecodeHeader(m_session, bs, par); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoDECODE_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoDECODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoDECODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoDECODE_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoDECODE_GetVideoParam(m_session, par); }
virtual mfxStatus GetDecodeStat(mfxDecodeStat *stat) { return MFXVideoDECODE_GetDecodeStat(m_session, stat); }
virtual mfxStatus GetPayload(mfxU64 *ts, mfxPayload *payload) {return MFXVideoDECODE_GetPayload(m_session, ts, payload); }
virtual mfxStatus SetSkipMode(mfxSkipMode mode) { return MFXVideoDECODE_SetSkipMode(m_session, mode); }
virtual mfxStatus DecodeFrameAsync(mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp) { return MFXVideoDECODE_DecodeFrameAsync(m_session, bs, surface_work, surface_out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoVPP
{
public:
MFXVideoVPP(mfxSession session) { m_session = session; }
virtual ~MFXVideoVPP(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoVPP_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest request[2]) { return MFXVideoVPP_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoVPP_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoVPP_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoVPP_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoVPP_GetVideoParam(m_session, par); }
virtual mfxStatus GetVPPStat(mfxVPPStat *stat) { return MFXVideoVPP_GetVPPStat(m_session, stat); }
virtual mfxStatus RunFrameVPPAsync(mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxSyncPoint *syncp) { return MFXVideoVPP_RunFrameVPPAsync(m_session, in, out, aux, syncp); }
virtual mfxStatus RunFrameVPPAsyncEx(mfxFrameSurface1 *in, mfxFrameSurface1 *work, mfxFrameSurface1 **out, mfxSyncPoint *syncp) {return MFXVideoVPP_RunFrameVPPAsyncEx(m_session, in, work, out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoENC
{
public:
MFXVideoENC(mfxSession session) { m_session = session; }
virtual ~MFXVideoENC(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoENC_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoENC_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoENC_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoENC_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoENC_Close(m_session); }
virtual mfxStatus ProcessFrameAsync(mfxENCInput *in, mfxENCOutput *out, mfxSyncPoint *syncp) { return MFXVideoENC_ProcessFrameAsync(m_session, in, out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoPAK
{
public:
MFXVideoPAK(mfxSession session) { m_session = session; }
virtual ~MFXVideoPAK(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoPAK_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoPAK_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoPAK_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoPAK_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoPAK_Close(m_session); }
//virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoENCODE_GetVideoParam(m_session, par); }
//virtual mfxStatus GetEncodeStat(mfxEncodeStat *stat) { return MFXVideoENCODE_GetEncodeStat(m_session, stat); }
virtual mfxStatus ProcessFrameAsync(mfxPAKInput *in, mfxPAKOutput *out, mfxSyncPoint *syncp) { return MFXVideoPAK_ProcessFrameAsync(m_session, in, out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
#endif // __MFXVIDEOPLUSPLUS_H

112
plugins/obs-qsv11/libmfx/include/msdk/include/mfxvideo.h
View file

@ -1,112 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2007-2015 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: mfxvideo.h
\* ****************************************************************************** */
#ifndef __MFXVIDEO_H__
#define __MFXVIDEO_H__
#include "mfxsession.h"
#include "mfxvstructures.h"
#define MFX_VERSION_MAJOR 1
#define MFX_VERSION_MINOR 17
#ifdef __cplusplus
extern "C"
{
#endif
/* MFXVideoCORE */
typedef struct {
mfxU32 reserved[4];
mfxHDL pthis;
mfxStatus (MFX_CDECL *Alloc) (mfxHDL pthis, mfxU32 nbytes, mfxU16 type, mfxMemId *mid);
mfxStatus (MFX_CDECL *Lock) (mfxHDL pthis, mfxMemId mid, mfxU8 **ptr);
mfxStatus (MFX_CDECL *Unlock) (mfxHDL pthis, mfxMemId mid);
mfxStatus (MFX_CDECL *Free) (mfxHDL pthis, mfxMemId mid);
} mfxBufferAllocator;
typedef struct {
mfxU32 reserved[4];
mfxHDL pthis;
mfxStatus (MFX_CDECL *Alloc) (mfxHDL pthis, mfxFrameAllocRequest *request, mfxFrameAllocResponse *response);
mfxStatus (MFX_CDECL *Lock) (mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr);
mfxStatus (MFX_CDECL *Unlock) (mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr);
mfxStatus (MFX_CDECL *GetHDL) (mfxHDL pthis, mfxMemId mid, mfxHDL *handle);
mfxStatus (MFX_CDECL *Free) (mfxHDL pthis, mfxFrameAllocResponse *response);
} mfxFrameAllocator;
/* VideoCORE */
mfxStatus MFX_CDECL MFXVideoCORE_SetBufferAllocator(mfxSession session, mfxBufferAllocator *allocator);
mfxStatus MFX_CDECL MFXVideoCORE_SetFrameAllocator(mfxSession session, mfxFrameAllocator *allocator);
mfxStatus MFX_CDECL MFXVideoCORE_SetHandle(mfxSession session, mfxHandleType type, mfxHDL hdl);
mfxStatus MFX_CDECL MFXVideoCORE_GetHandle(mfxSession session, mfxHandleType type, mfxHDL *hdl);
mfxStatus MFX_CDECL MFXVideoCORE_SyncOperation(mfxSession session, mfxSyncPoint syncp, mfxU32 wait);
/* VideoENCODE */
mfxStatus MFX_CDECL MFXVideoENCODE_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoENCODE_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
mfxStatus MFX_CDECL MFXVideoENCODE_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENCODE_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENCODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoENCODE_GetVideoParam(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENCODE_GetEncodeStat(mfxSession session, mfxEncodeStat *stat);
mfxStatus MFX_CDECL MFXVideoENCODE_EncodeFrameAsync(mfxSession session, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxSyncPoint *syncp);
/* VideoDECODE */
mfxStatus MFX_CDECL MFXVideoDECODE_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoDECODE_DecodeHeader(mfxSession session, mfxBitstream *bs, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
mfxStatus MFX_CDECL MFXVideoDECODE_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoDECODE_GetVideoParam(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_GetDecodeStat(mfxSession session, mfxDecodeStat *stat);
mfxStatus MFX_CDECL MFXVideoDECODE_SetSkipMode(mfxSession session, mfxSkipMode mode);
mfxStatus MFX_CDECL MFXVideoDECODE_GetPayload(mfxSession session, mfxU64 *ts, mfxPayload *payload);
mfxStatus MFX_CDECL MFXVideoDECODE_DecodeFrameAsync(mfxSession session, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp);
/* VideoVPP */
mfxStatus MFX_CDECL MFXVideoVPP_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoVPP_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest request[2]);
mfxStatus MFX_CDECL MFXVideoVPP_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoVPP_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoVPP_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoVPP_GetVideoParam(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoVPP_GetVPPStat(mfxSession session, mfxVPPStat *stat);
mfxStatus MFX_CDECL MFXVideoVPP_RunFrameVPPAsync(mfxSession session, mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXVideoVPP_RunFrameVPPAsyncEx(mfxSession session, mfxFrameSurface1 *in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp);
#ifdef __cplusplus
} // extern "C"
#endif
#endif

32
plugins/obs-qsv11/libmfx/include/msdk/include/mfxvstructures.h
View file

@ -1,32 +0,0 @@
/*******************************************************************************
Copyright (C) 2013 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: mfxvstructures.h
*******************************************************************************/
#include "mfxstructures.h"

937
plugins/obs-qsv11/libmfx/src/main.cpp
View file

@ -1,937 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-2015 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: main.cpp
\* ****************************************************************************** */
#include "mfx_dispatcher.h"
#include "mfx_load_dll.h"
#include "mfx_dispatcher_log.h"
#include "mfx_library_iterator.h"
#include "mfx_critical_section.h"
#include <string.h> /* for memset on Linux */
#include <memory>
#include <stdlib.h> /* for qsort on Linux */
#include "mfx_load_plugin.h"
#include "mfx_plugin_hive.h"
// module-local definitions
namespace
{
const
struct
{
// instance implementation type
eMfxImplType implType;
// real implementation
mfxIMPL impl;
// adapter numbers
mfxU32 adapterID;
} implTypes[] =
{
// MFX_IMPL_AUTO case
{MFX_LIB_HARDWARE, MFX_IMPL_HARDWARE, 0},
{MFX_LIB_SOFTWARE, MFX_IMPL_SOFTWARE, 0},
// MFX_IMPL_ANY case
{MFX_LIB_HARDWARE, MFX_IMPL_HARDWARE, 0},
{MFX_LIB_HARDWARE, MFX_IMPL_HARDWARE2, 1},
{MFX_LIB_HARDWARE, MFX_IMPL_HARDWARE3, 2},
{MFX_LIB_HARDWARE, MFX_IMPL_HARDWARE4, 3},
{MFX_LIB_SOFTWARE, MFX_IMPL_SOFTWARE, 0},
{MFX_LIB_SOFTWARE, MFX_IMPL_SOFTWARE | MFX_IMPL_AUDIO, 0}
};
const
struct
{
// start index in implTypes table for specified implementation
mfxU32 minIndex;
// last index in implTypes table for specified implementation
mfxU32 maxIndex;
} implTypesRange[] =
{
{0, 1}, // MFX_IMPL_AUTO
{1, 1}, // MFX_IMPL_SOFTWARE
{0, 0}, // MFX_IMPL_HARDWARE
{2, 6}, // MFX_IMPL_AUTO_ANY
{2, 5}, // MFX_IMPL_HARDWARE_ANY
{3, 3}, // MFX_IMPL_HARDWARE2
{4, 4}, // MFX_IMPL_HARDWARE3
{5, 5}, // MFX_IMPL_HARDWARE4
{2, 6}, // MFX_IMPL_RUNTIME, same as MFX_IMPL_HARDWARE_ANY
{7, 7} // MFX_IMPL_AUDIO
};
MFX::mfxCriticalSection dispGuard = 0;
} // namespace
using namespace MFX;
//
// Implement DLL exposed functions. MFXInit and MFXClose have to do
// slightly more than other. They require to be implemented explicitly.
// All other functions are implemented implicitly.
//
typedef MFXVector<MFX_DISP_HANDLE*> HandleVector;
typedef MFXVector<mfxStatus> StatusVector;
struct VectorHandleGuard
{
VectorHandleGuard(HandleVector& aVector): m_vector(aVector) {}
~VectorHandleGuard()
{
HandleVector::iterator it = m_vector.begin(),
et = m_vector.end();
for ( ; it != et; ++it)
{
delete *it;
}
}
HandleVector& m_vector;
private:
void operator=(const VectorHandleGuard&);
};
int HandleSort (const void * plhs, const void * prhs)
{
const MFX_DISP_HANDLE * lhs = *(const MFX_DISP_HANDLE **)plhs;
const MFX_DISP_HANDLE * rhs = *(const MFX_DISP_HANDLE **)prhs;
if (lhs->actualApiVersion < rhs->actualApiVersion)
{
return -1;
}
if (rhs->actualApiVersion < lhs->actualApiVersion)
{
return 1;
}
// if versions are equal prefer library with HW
if (lhs->loadStatus == MFX_WRN_PARTIAL_ACCELERATION && rhs->loadStatus == MFX_ERR_NONE)
{
return 1;
}
if (lhs->loadStatus == MFX_ERR_NONE && rhs->loadStatus == MFX_WRN_PARTIAL_ACCELERATION)
{
return -1;
}
return 0;
}
mfxStatus MFXInit(mfxIMPL impl, mfxVersion *pVer, mfxSession *session)
{
mfxInitParam par = {};
par.Implementation = impl;
if (pVer)
{
par.Version = *pVer;
}
else
{
par.Version.Major = DEFAULT_API_VERSION_MAJOR;
par.Version.Minor = DEFAULT_API_VERSION_MINOR;
}
par.ExternalThreads = 0;
return MFXInitEx(par, session);
}
mfxStatus MFXInitEx(mfxInitParam par, mfxSession *session)
{
MFX::MFXAutomaticCriticalSection guard(&dispGuard);
DISPATCHER_LOG_BLOCK( ("MFXInitEx (impl=%s, pVer=%d.%d, ExternalThreads=%d session=0x%p\n"
, DispatcherLog_GetMFXImplString(par.Implementation).c_str()
, par.Version.Major
, par.Version.Minor
, par.ExternalThreads
, session));
mfxStatus mfxRes;
HandleVector allocatedHandle;
VectorHandleGuard handleGuard(allocatedHandle);
MFX_DISP_HANDLE *pHandle;
msdk_disp_char dllName[MFX_MAX_DLL_PATH];
MFX::MFXLibraryIterator libIterator;
// there iterators are used only if the caller specified implicit type like AUTO
mfxU32 curImplIdx, maxImplIdx;
// particular implementation value
mfxIMPL curImpl;
// implementation method masked from the input parameter
// special case for audio library
const mfxIMPL implMethod = (par.Implementation & MFX_IMPL_AUDIO) ? (sizeof(implTypesRange) / sizeof(implTypesRange[0]) - 1) : (par.Implementation & (MFX_IMPL_VIA_ANY - 1));
// implementation interface masked from the input parameter
mfxIMPL implInterface = par.Implementation & -MFX_IMPL_VIA_ANY;
mfxIMPL implInterfaceOrig = implInterface;
mfxVersion requiredVersion = {{MFX_VERSION_MINOR, MFX_VERSION_MAJOR}};
// check error(s)
if (NULL == session)
{
return MFX_ERR_NULL_PTR;
}
if (((MFX_IMPL_AUTO > implMethod) || (MFX_IMPL_RUNTIME < implMethod)) && !(par.Implementation & MFX_IMPL_AUDIO))
{
return MFX_ERR_UNSUPPORTED;
}
// set the minimal required version
requiredVersion = par.Version;
try
{
// reset the session value
*session = 0;
// allocate the dispatching handle and call-table
pHandle = new MFX_DISP_HANDLE(requiredVersion);
}
catch(...)
{
return MFX_ERR_MEMORY_ALLOC;
}
DISPATCHER_LOG_INFO((("Required API version is %u.%u\n"), requiredVersion.Major, requiredVersion.Minor));
// Load HW library or RT from system location
curImplIdx = implTypesRange[implMethod].minIndex;
maxImplIdx = implTypesRange[implMethod].maxIndex;
mfxU32 hwImplIdx = 0;
do
{
int currentStorage = MFX::MFX_STORAGE_ID_FIRST;
implInterface = implInterfaceOrig;
do
{
// initialize the library iterator
mfxRes = libIterator.Init(implTypes[curImplIdx].implType,
implInterface,
implTypes[curImplIdx].adapterID,
currentStorage);
// look through the list of installed SDK version,
// looking for a suitable library with higher merit value.
if (MFX_ERR_NONE == mfxRes)
{
if (
MFX_LIB_HARDWARE == implTypes[curImplIdx].implType
&& (!implInterface
|| MFX_IMPL_VIA_ANY == implInterface))
{
implInterface = libIterator.GetImplementationType();
}
do
{
eMfxImplType implType;
// select a desired DLL
mfxRes = libIterator.SelectDLLVersion(dllName,
sizeof(dllName) / sizeof(dllName[0]),
&implType,
pHandle->apiVersion);
if (MFX_ERR_NONE != mfxRes)
{
break;
}
DISPATCHER_LOG_INFO((("loading library %S\n"), MSDK2WIDE(dllName)));
if (MFX_LIB_HARDWARE == implTypes[curImplIdx].implType)
hwImplIdx = curImplIdx;
// try to load the selected DLL
curImpl = implTypes[curImplIdx].impl;
mfxRes = pHandle->LoadSelectedDLL(dllName, implType, curImpl, implInterface, par);
// unload the failed DLL
if (MFX_ERR_NONE != mfxRes)
{
pHandle->Close();
}
else
{
libIterator.GetSubKeyName(pHandle->subkeyName, sizeof(pHandle->subkeyName)/sizeof(pHandle->subkeyName[0])) ;
pHandle->storageID = libIterator.GetStorageID();
allocatedHandle.push_back(pHandle);
pHandle = new MFX_DISP_HANDLE(requiredVersion);
}
} while (MFX_ERR_NONE != mfxRes);
}
// select another registry key
currentStorage += 1;
} while ((MFX_ERR_NONE != mfxRes) && (MFX::MFX_STORAGE_ID_LAST >= currentStorage));
} while ((MFX_ERR_NONE != mfxRes) && (++curImplIdx <= maxImplIdx));
curImplIdx = implTypesRange[implMethod].minIndex;
maxImplIdx = implTypesRange[implMethod].maxIndex;
// Load RT from app folder (libmfxsw64 with API >= 1.10)
do
{
implInterface = implInterfaceOrig;
// initialize the library iterator
mfxRes = libIterator.Init(implTypes[curImplIdx].implType,
implInterface,
implTypes[curImplIdx].adapterID,
MFX::MFX_APP_FOLDER);
if (MFX_ERR_NONE == mfxRes)
{
if (
MFX_LIB_HARDWARE == implTypes[curImplIdx].implType
&& (!implInterface
|| MFX_IMPL_VIA_ANY == implInterface))
{
implInterface = libIterator.GetImplementationType();
}
do
{
eMfxImplType implType;
// select a desired DLL
mfxRes = libIterator.SelectDLLVersion(dllName,
sizeof(dllName) / sizeof(dllName[0]),
&implType,
pHandle->apiVersion);
if (MFX_ERR_NONE != mfxRes)
{
break;
}
DISPATCHER_LOG_INFO((("loading library %S\n"), MSDK2WIDE(dllName)));
// try to load the selected DLL
curImpl = implTypes[curImplIdx].impl;
mfxRes = pHandle->LoadSelectedDLL(dllName, implType, curImpl, implInterface, par);
// unload the failed DLL
if (MFX_ERR_NONE != mfxRes)
{
pHandle->Close();
}
else
{
if (pHandle->actualApiVersion.Major == 1 && pHandle->actualApiVersion.Minor <= 9)
{
// this is not RT, skip it
mfxRes = MFX_ERR_ABORTED;
break;
}
pHandle->storageID = MFX::MFX_UNKNOWN_KEY;
allocatedHandle.push_back(pHandle);
pHandle = new MFX_DISP_HANDLE(requiredVersion);
}
} while (MFX_ERR_NONE != mfxRes);
}
} while ((MFX_ERR_NONE != mfxRes) && (++curImplIdx <= maxImplIdx));
// Load HW and SW libraries using legacy default DLL search mechanism
// set current library index again
curImplIdx = implTypesRange[implMethod].minIndex;
do
{
mfxU32 backupIdx = curImplIdx;
if (MFX_LIB_HARDWARE == implTypes[curImplIdx].implType)
{
curImplIdx = hwImplIdx;
}
implInterface = implInterfaceOrig;
if (par.Implementation & MFX_IMPL_AUDIO)
{
mfxRes = MFX::mfx_get_default_audio_dll_name(dllName,
sizeof(dllName) / sizeof(dllName[0]),
implTypes[curImplIdx].implType);
}
else
{
mfxRes = MFX::mfx_get_default_dll_name(dllName,
sizeof(dllName) / sizeof(dllName[0]),
implTypes[curImplIdx].implType);
}
if (MFX_ERR_NONE == mfxRes)
{
DISPATCHER_LOG_INFO((("loading default library %S\n"), MSDK2WIDE(dllName)))
// try to load the selected DLL using default DLL search mechanism
if (MFX_LIB_HARDWARE == implTypes[curImplIdx].implType)
{
if (!implInterface)
{
implInterface = MFX_IMPL_VIA_ANY;
}
mfxRes = MFX::SelectImplementationType(implTypes[curImplIdx].adapterID, &implInterface, NULL, NULL);
}
if (MFX_ERR_NONE == mfxRes)
{
// try to load the selected DLL using default DLL search mechanism
mfxRes = pHandle->LoadSelectedDLL(dllName,
implTypes[curImplIdx].implType,
implTypes[curImplIdx].impl,
implInterface,
par);
}
// unload the failed DLL
if ((MFX_ERR_NONE != mfxRes) &&
(MFX_WRN_PARTIAL_ACCELERATION != mfxRes))
{
pHandle->Close();
}
else
{
pHandle->storageID = MFX::MFX_UNKNOWN_KEY;
allocatedHandle.push_back(pHandle);
pHandle = new MFX_DISP_HANDLE(requiredVersion);
}
}
curImplIdx = backupIdx;
}
while ((MFX_ERR_NONE > mfxRes) && (++curImplIdx <= maxImplIdx));
delete pHandle;
if (allocatedHandle.size() == 0)
return MFX_ERR_UNSUPPORTED;
bool NeedSort = false;
HandleVector::iterator first = allocatedHandle.begin(),
it = allocatedHandle.begin(),
et = allocatedHandle.end();
for (it++; it != et; ++it)
if (HandleSort(&(*first), &(*it)) != 0)
NeedSort = true;
// select dll with version with lowest version number still greater or equal to requested
if (NeedSort)
qsort(&(*allocatedHandle.begin()), allocatedHandle.size(), sizeof(MFX_DISP_HANDLE*), &HandleSort);
HandleVector::iterator candidate = allocatedHandle.begin();
// check the final result of loading
try
{
pHandle = *candidate;
//pulling up current mediasdk version, that required to match plugin version
mfxVersion apiVerActual;
mfxStatus stsQueryVersion;
stsQueryVersion = MFXQueryVersion((mfxSession)pHandle, &apiVerActual);
if (MFX_ERR_NONE != stsQueryVersion)
{
DISPATCHER_LOG_ERROR((("MFXQueryVersion returned: %d, cannot load plugins\n"), mfxRes))
}
else
{
MFX::MFXPluginStorage & hive = pHandle->pluginHive;
HandleVector::iterator it = allocatedHandle.begin(),
et = allocatedHandle.end();
for (; it != et; ++it)
{
// Registering default plugins set
MFX::MFXDefaultPlugins defaultPugins(apiVerActual, *it, (*it)->implType);
hive.insert(hive.end(), defaultPugins.begin(), defaultPugins.end());
if ((*it)->storageID != MFX::MFX_UNKNOWN_KEY)
{
// Scan HW plugins in subkeys of registry library
MFX::MFXPluginsInHive plgsInHive((*it)->storageID, (*it)->subkeyName, apiVerActual);
hive.insert(hive.end(), plgsInHive.begin(), plgsInHive.end());
}
}
//setting up plugins records
for(int i = MFX::MFX_STORAGE_ID_FIRST; i <= MFX::MFX_STORAGE_ID_LAST; i++)
{
MFX::MFXPluginsInHive plgsInHive(i, NULL, apiVerActual);
hive.insert(hive.end(), plgsInHive.begin(), plgsInHive.end());
}
MFX::MFXPluginsInFS plgsInFS(apiVerActual);
hive.insert(hive.end(), plgsInFS.begin(), plgsInFS.end());
}
}
catch(...)
{
DISPATCHER_LOG_ERROR((("unknown exception while loading plugins\n")))
}
// everything is OK. Save pointers to the output variable
*candidate = 0; // keep this one safe from guard destructor
*((MFX_DISP_HANDLE **) session) = pHandle;
return pHandle->loadStatus;
} // mfxStatus MFXInit(mfxIMPL impl, mfxVersion *ver, mfxSession *session)
mfxStatus MFXClose(mfxSession session)
{
MFX::MFXAutomaticCriticalSection guard(&dispGuard);
mfxStatus mfxRes = MFX_ERR_INVALID_HANDLE;
MFX_DISP_HANDLE *pHandle = (MFX_DISP_HANDLE *) session;
// check error(s)
if (pHandle)
{
try
{
// unload the DLL library
mfxRes = pHandle->Close();
// it is possible, that there is an active child session.
// can't unload library in that case.
if (MFX_ERR_UNDEFINED_BEHAVIOR != mfxRes)
{
// release the handle
delete pHandle;
}
}
catch(...)
{
mfxRes = MFX_ERR_INVALID_HANDLE;
}
}
return mfxRes;
} // mfxStatus MFXClose(mfxSession session)
mfxStatus MFXJoinSession(mfxSession session, mfxSession child_session)
{
mfxStatus mfxRes = MFX_ERR_INVALID_HANDLE;
MFX_DISP_HANDLE *pHandle = (MFX_DISP_HANDLE *) session;
MFX_DISP_HANDLE *pChildHandle = (MFX_DISP_HANDLE *) child_session;
// get the function's address and make a call
if ((pHandle) && (pChildHandle) && (pHandle->apiVersion == pChildHandle->apiVersion))
{
/* check whether it is audio session or video */
int tableIndex = eMFXJoinSession;
mfxFunctionPointer pFunc;
if (pHandle->impl & MFX_IMPL_AUDIO)
{
pFunc = pHandle->callAudioTable[tableIndex];
}
else
{
pFunc = pHandle->callTable[tableIndex];
}
if (pFunc)
{
// pass down the call
mfxRes = (*(mfxStatus (MFX_CDECL *) (mfxSession, mfxSession)) pFunc) (pHandle->session,
pChildHandle->session);
}
}
return mfxRes;
} // mfxStatus MFXJoinSession(mfxSession session, mfxSession child_session)
mfxStatus MFXCloneSession(mfxSession session, mfxSession *clone)
{
mfxStatus mfxRes = MFX_ERR_INVALID_HANDLE;
MFX_DISP_HANDLE *pHandle = (MFX_DISP_HANDLE *) session;
mfxVersion apiVersion;
mfxIMPL impl;
// check error(s)
if (pHandle)
{
// initialize the clone session
apiVersion = pHandle->apiVersion;
impl = pHandle->impl | pHandle->implInterface;
mfxRes = MFXInit(impl, &apiVersion, clone);
if (MFX_ERR_NONE != mfxRes)
{
return mfxRes;
}
// join the sessions
mfxRes = MFXJoinSession(session, *clone);
if (MFX_ERR_NONE != mfxRes)
{
MFXClose(*clone);
*clone = NULL;
return mfxRes;
}
}
return mfxRes;
} // mfxStatus MFXCloneSession(mfxSession session, mfxSession *clone)
mfxStatus MFXVideoUSER_Load(mfxSession session, const mfxPluginUID *uid, mfxU32 version)
{
mfxStatus sts = MFX_ERR_NONE;
bool ErrFlag = false;
MFX_DISP_HANDLE &pHandle = *(MFX_DISP_HANDLE *) session;
if (!&pHandle)
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_Load: session=NULL\n")));
return MFX_ERR_NULL_PTR;
}
if (!uid)
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_Load: uid=NULL\n")));
return MFX_ERR_NULL_PTR;
}
DISPATCHER_LOG_INFO((("MFXVideoUSER_Load: uid="MFXGUIDTYPE()" version=%d\n")
, MFXGUIDTOHEX(uid)
, version))
size_t pluginsChecked = 0;
for (MFX::MFXPluginStorage::iterator i = pHandle.pluginHive.begin();i != pHandle.pluginHive.end(); i++, pluginsChecked++)
{
if (i->PluginUID != *uid)
{
continue;
}
//check rest in records
if (i->PluginVersion < version)
{
DISPATCHER_LOG_INFO((("MFXVideoUSER_Load: registered \"Plugin Version\" for GUID="MFXGUIDTYPE()" is %d, that is smaller that requested\n")
, MFXGUIDTOHEX(uid)
, i->PluginVersion))
continue;
}
try
{
sts = pHandle.pluginFactory.Create(*i);
if( MFX_ERR_NONE != sts)
{
ErrFlag = (ErrFlag || (sts == MFX_ERR_UNDEFINED_BEHAVIOR));
continue;
}
return MFX_ERR_NONE;
}
catch(...)
{
continue;
}
}
// Specified UID was not found among individually registed plugins, now try load it from default sets if any
for (MFX::MFXPluginStorage::iterator i = pHandle.pluginHive.begin();i != pHandle.pluginHive.end(); i++, pluginsChecked++)
{
if (!i->Default)
continue;
i->PluginUID = *uid;
i->PluginVersion = (mfxU16)version;
try
{
sts = pHandle.pluginFactory.Create(*i);
if( MFX_ERR_NONE != sts)
{
ErrFlag = (ErrFlag || (sts == MFX_ERR_UNDEFINED_BEHAVIOR));
continue;
}
return MFX_ERR_NONE;
}
catch(...)
{
continue;
}
}
DISPATCHER_LOG_ERROR((("MFXVideoUSER_Load: cannot find registered plugin with requested UID, total plugins available=%d\n"), pHandle.pluginHive.size()));
if (ErrFlag)
return MFX_ERR_UNDEFINED_BEHAVIOR;
else
return MFX_ERR_NOT_FOUND;
}
mfxStatus MFXVideoUSER_LoadByPath(mfxSession session, const mfxPluginUID *uid, mfxU32 version, const mfxChar *path, mfxU32 len)
{
MFX_DISP_HANDLE &pHandle = *(MFX_DISP_HANDLE *) session;
if (!&pHandle)
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_LoadByPath: session=NULL\n")));
return MFX_ERR_NULL_PTR;
}
if (!uid)
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_LoadByPath: uid=NULL\n")));
return MFX_ERR_NULL_PTR;
}
DISPATCHER_LOG_INFO((("MFXVideoUSER_LoadByPath: %S uid="MFXGUIDTYPE()" version=%d\n")
, MSDK2WIDE(path)
, MFXGUIDTOHEX(uid)
, version))
PluginDescriptionRecord record;
record.sName[0] = 0;
#ifdef _WIN32
msdk_disp_char wPath[MAX_PLUGIN_PATH];
int res = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, path, len, wPath, MAX_PLUGIN_PATH);
if (!res)
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_LoadByPath: cant convert UTF-8 path to UTF-16\n")));
return MFX_ERR_NOT_FOUND;
}
msdk_disp_char_cpy_s(record.sPath, res < MAX_PLUGIN_PATH ? res : MAX_PLUGIN_PATH, wPath);
#else // Linux/Android
msdk_disp_char_cpy_s(record.sPath, len < MAX_PLUGIN_PATH ? len : MAX_PLUGIN_PATH, path);
#endif
record.PluginUID = *uid;
record.PluginVersion = (mfxU16)version;
record.Default = true;
try
{
return pHandle.pluginFactory.Create(record);
}
catch(...)
{
return MFX_ERR_NOT_FOUND;
}
}
mfxStatus MFXVideoUSER_UnLoad(mfxSession session, const mfxPluginUID *uid)
{
MFX_DISP_HANDLE &rHandle = *(MFX_DISP_HANDLE *) session;
if (!&rHandle)
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_UnLoad: session=NULL\n")));
return MFX_ERR_NULL_PTR;
}
if (!uid)
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_Load: uid=NULL\n")));
return MFX_ERR_NULL_PTR;
}
bool bDestroyed = rHandle.pluginFactory.Destroy(*uid);
if (bDestroyed)
{
DISPATCHER_LOG_INFO((("MFXVideoUSER_UnLoad : plugin with GUID="MFXGUIDTYPE()" unloaded\n"), MFXGUIDTOHEX(uid)));
} else
{
DISPATCHER_LOG_ERROR((("MFXVideoUSER_UnLoad : plugin with GUID="MFXGUIDTYPE()" not found\n"), MFXGUIDTOHEX(uid)));
}
return bDestroyed ? MFX_ERR_NONE : MFX_ERR_NOT_FOUND;
}
mfxStatus MFXAudioUSER_Load(mfxSession session, const mfxPluginUID *uid, mfxU32 version)
{
MFX_DISP_HANDLE &pHandle = *(MFX_DISP_HANDLE *) session;
if (!&pHandle)
{
DISPATCHER_LOG_ERROR((("MFXAudioUSER_Load: session=NULL\n")));
return MFX_ERR_NULL_PTR;
}
if (!uid)
{
DISPATCHER_LOG_ERROR((("MFXAudioUSER_Load: uid=NULL\n")));
return MFX_ERR_NULL_PTR;
}
DISPATCHER_LOG_INFO((("MFXAudioUSER_Load: uid="MFXGUIDTYPE()" version=%d\n")
, MFXGUIDTOHEX(uid)
, version))
size_t pluginsChecked = 0;
PluginDescriptionRecord defaultPluginRecord;
for (MFX::MFXPluginStorage::iterator i = pHandle.pluginHive.begin();i != pHandle.pluginHive.end(); i++, pluginsChecked++)
{
if (i->PluginUID != *uid)
{
if (i->Default) // PluginUID == 0 for default set
{
defaultPluginRecord = *i;
}
continue;
}
//check rest in records
if (i->PluginVersion < version)
{
DISPATCHER_LOG_INFO((("MFXAudioUSER_Load: registered \"Plugin Version\" for GUID="MFXGUIDTYPE()" is %d, that is smaller that requested\n")
, MFXGUIDTOHEX(uid)
, i->PluginVersion))
continue;
}
try {
return pHandle.pluginFactory.Create(*i);
}
catch(...) {
return MFX_ERR_UNKNOWN;
}
}
// Specified UID was not found among individually registed plugins, now try load it from default set if any
if (defaultPluginRecord.Default)
{
defaultPluginRecord.PluginUID = *uid;
defaultPluginRecord.onlyVersionRegistered = true;
defaultPluginRecord.PluginVersion = (mfxU16)version;
try {
return pHandle.pluginFactory.Create(defaultPluginRecord);
}
catch(...) {
return MFX_ERR_UNKNOWN;
}
}
DISPATCHER_LOG_ERROR((("MFXAudioUSER_Load: cannot find registered plugin with requested UID, total plugins available=%d\n"), pHandle.pluginHive.size()));
return MFX_ERR_NOT_FOUND;
}
mfxStatus MFXAudioUSER_UnLoad(mfxSession session, const mfxPluginUID *uid)
{
MFX_DISP_HANDLE &rHandle = *(MFX_DISP_HANDLE *) session;
if (!&rHandle)
{
DISPATCHER_LOG_ERROR((("MFXAudioUSER_UnLoad: session=NULL\n")));
return MFX_ERR_NULL_PTR;
}
if (!uid)
{
DISPATCHER_LOG_ERROR((("MFXAudioUSER_Load: uid=NULL\n")));
return MFX_ERR_NULL_PTR;
}
bool bDestroyed = rHandle.pluginFactory.Destroy(*uid);
if (bDestroyed)
{
DISPATCHER_LOG_INFO((("MFXAudioUSER_UnLoad : plugin with GUID="MFXGUIDTYPE()" unloaded\n"), MFXGUIDTOHEX(uid)));
} else
{
DISPATCHER_LOG_ERROR((("MFXAudioUSER_UnLoad : plugin with GUID="MFXGUIDTYPE()" not found\n"), MFXGUIDTOHEX(uid)));
}
return bDestroyed ? MFX_ERR_NONE : MFX_ERR_NOT_FOUND;
}
//
// implement all other calling functions.
// They just call a procedure of DLL library from the table.
//
// define for common functions (from mfxsession.h)
#undef FUNCTION
#define FUNCTION(return_value, func_name, formal_param_list, actual_param_list) \
return_value func_name formal_param_list \
{ \
mfxStatus mfxRes = MFX_ERR_INVALID_HANDLE; \
MFX_DISP_HANDLE *pHandle = (MFX_DISP_HANDLE *) session; \
/* get the function's address and make a call */ \
if (pHandle) \
{ \
/* check whether it is audio session or video */ \
int tableIndex = e##func_name; \
mfxFunctionPointer pFunc; \
if (pHandle->impl & MFX_IMPL_AUDIO) \
{ \
pFunc = pHandle->callAudioTable[tableIndex]; \
} \
else \
{ \
pFunc = pHandle->callTable[tableIndex]; \
} \
if (pFunc) \
{ \
/* get the real session pointer */ \
session = pHandle->session; \
/* pass down the call */ \
mfxRes = (*(mfxStatus (MFX_CDECL *) formal_param_list) pFunc) actual_param_list; \
} \
} \
return mfxRes; \
}
FUNCTION(mfxStatus, MFXQueryIMPL, (mfxSession session, mfxIMPL *impl), (session, impl))
FUNCTION(mfxStatus, MFXQueryVersion, (mfxSession session, mfxVersion *version), (session, version))
FUNCTION(mfxStatus, MFXDisjoinSession, (mfxSession session), (session))
FUNCTION(mfxStatus, MFXSetPriority, (mfxSession session, mfxPriority priority), (session, priority))
FUNCTION(mfxStatus, MFXGetPriority, (mfxSession session, mfxPriority *priority), (session, priority))
#undef FUNCTION
#define FUNCTION(return_value, func_name, formal_param_list, actual_param_list) \
return_value func_name formal_param_list \
{ \
mfxStatus mfxRes = MFX_ERR_INVALID_HANDLE; \
MFX_DISP_HANDLE *pHandle = (MFX_DISP_HANDLE *) session; \
/* get the function's address and make a call */ \
if (pHandle) \
{ \
mfxFunctionPointer pFunc = pHandle->callTable[e##func_name]; \
if (pFunc) \
{ \
/* get the real session pointer */ \
session = pHandle->session; \
/* pass down the call */ \
mfxRes = (*(mfxStatus (MFX_CDECL *) formal_param_list) pFunc) actual_param_list; \
} \
} \
return mfxRes; \
}
#include "mfx_exposed_functions_list.h"
#undef FUNCTION
#define FUNCTION(return_value, func_name, formal_param_list, actual_param_list) \
return_value func_name formal_param_list \
{ \
mfxStatus mfxRes = MFX_ERR_INVALID_HANDLE; \
MFX_DISP_HANDLE *pHandle = (MFX_DISP_HANDLE *) session; \
/* get the function's address and make a call */ \
if (pHandle) \
{ \
mfxFunctionPointer pFunc = pHandle->callAudioTable[e##func_name]; \
if (pFunc) \
{ \
/* get the real session pointer */ \
session = pHandle->session; \
/* pass down the call */ \
mfxRes = (*(mfxStatus (MFX_CDECL *) formal_param_list) pFunc) actual_param_list; \
} \
} \
return mfxRes; \
}
#include "mfxaudio_exposed_functions_list.h"

88
plugins/obs-qsv11/libmfx/src/mfx_critical_section.cpp
View file

@ -1,88 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-2013 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: mfx_critical_section.cpp
\* ****************************************************************************** */
#include "mfx_critical_section.h"
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
// SDK re-declares the following functions with different call declarator.
// We don't need them. Just redefine them to nothing.
#define _interlockedbittestandset fake_set
#define _interlockedbittestandreset fake_reset
#define _interlockedbittestandset64 fake_set64
#define _interlockedbittestandreset64 fake_reset64
#include <intrin.h>
#define MFX_WAIT() SwitchToThread()
// static section of the file
namespace
{
enum
{
MFX_SC_IS_FREE = 0,
MFX_SC_IS_TAKEN = 1
};
} // namespace
namespace MFX
{
mfxU32 mfxInterlockedCas32(mfxCriticalSection *pCSection, mfxU32 value_to_exchange, mfxU32 value_to_compare)
{
return _InterlockedCompareExchange(pCSection, value_to_exchange, value_to_compare);
}
mfxU32 mfxInterlockedXchg32(mfxCriticalSection *pCSection, mfxU32 value)
{
return _InterlockedExchange(pCSection, value);
}
void mfxEnterCriticalSection(mfxCriticalSection *pCSection)
{
while (MFX_SC_IS_TAKEN == mfxInterlockedCas32(pCSection,
MFX_SC_IS_TAKEN,
MFX_SC_IS_FREE))
{
MFX_WAIT();
}
} // void mfxEnterCriticalSection(mfxCriticalSection *pCSection)
void mfxLeaveCriticalSection(mfxCriticalSection *pCSection)
{
mfxInterlockedXchg32(pCSection, MFX_SC_IS_FREE);
} // void mfxLeaveCriticalSection(mfxCriticalSection *pCSection)
} // namespace MFX
#endif // #if defined(_WIN32) || defined(_WIN64)

349
plugins/obs-qsv11/libmfx/src/mfx_dispatcher.cpp
View file

@ -1,349 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-2015 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: mfx_dispatcher.cpp
\* ****************************************************************************** */
#include "mfx_dispatcher.h"
#include "mfx_dispatcher_log.h"
#include "mfx_load_dll.h"
#include <string.h>
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#pragma warning(disable:4355)
#else
#include <dlfcn.h>
#include <iostream>
#endif // defined(_WIN32) || defined(_WIN64)
MFX_DISP_HANDLE::MFX_DISP_HANDLE(const mfxVersion requiredVersion) :
apiVersion(requiredVersion),
pluginFactory((mfxSession)this)
{
actualApiVersion.Version = 0;
implType = MFX_LIB_SOFTWARE;
impl = MFX_IMPL_SOFTWARE;
loadStatus = MFX_ERR_NOT_FOUND;
dispVersion.Major = MFX_DISPATCHER_VERSION_MAJOR;
dispVersion.Minor = MFX_DISPATCHER_VERSION_MINOR;
session = (mfxSession) 0;
hModule = (mfxModuleHandle) 0;
memset(callTable, 0, sizeof(callTable));
memset(callAudioTable, 0, sizeof(callAudioTable));
} // MFX_DISP_HANDLE::MFX_DISP_HANDLE(const mfxVersion requiredVersion)
MFX_DISP_HANDLE::~MFX_DISP_HANDLE(void)
{
Close();
} // MFX_DISP_HANDLE::~MFX_DISP_HANDLE(void)
mfxStatus MFX_DISP_HANDLE::Close(void)
{
mfxStatus mfxRes;
mfxRes = UnLoadSelectedDLL();
// the library wasn't unloaded
if (MFX_ERR_NONE == mfxRes)
{
implType = MFX_LIB_SOFTWARE;
impl = MFX_IMPL_SOFTWARE;
loadStatus = MFX_ERR_NOT_FOUND;
dispVersion.Major = MFX_DISPATCHER_VERSION_MAJOR;
dispVersion.Minor = MFX_DISPATCHER_VERSION_MINOR;
session = (mfxSession) 0;
hModule = (mfxModuleHandle) 0;
memset(callTable, 0, sizeof(callTable));
memset(callAudioTable, 0, sizeof(callAudioTable));
}
return mfxRes;
} // mfxStatus MFX_DISP_HANDLE::Close(void)
mfxStatus MFX_DISP_HANDLE::LoadSelectedDLL(const msdk_disp_char *pPath, eMfxImplType implType,
mfxIMPL impl, mfxIMPL implInterface, mfxInitParam &par)
{
mfxStatus mfxRes = MFX_ERR_NONE;
// check error(s)
if ((MFX_LIB_SOFTWARE != implType) &&
(MFX_LIB_HARDWARE != implType))
{
DISPATCHER_LOG_ERROR((("implType == %s, should be either MFX_LIB_SOFTWARE ot MFX_LIB_HARDWARE\n"), DispatcherLog_GetMFXImplString(implType).c_str()));
loadStatus = MFX_ERR_ABORTED;
return loadStatus;
}
// only exact types of implementation is allowed
if (!(impl & MFX_IMPL_AUDIO) &&
(MFX_IMPL_SOFTWARE != impl) &&
(MFX_IMPL_HARDWARE != impl) &&
(MFX_IMPL_HARDWARE2 != impl) &&
(MFX_IMPL_HARDWARE3 != impl) &&
(MFX_IMPL_HARDWARE4 != impl))
{
DISPATCHER_LOG_ERROR((("invalid implementation impl == %s\n"), DispatcherLog_GetMFXImplString(impl).c_str()));
loadStatus = MFX_ERR_ABORTED;
return loadStatus;
}
// only mfxExtThreadsParam is allowed
if (par.NumExtParam)
{
if ((par.NumExtParam > 1) || !par.ExtParam)
{
loadStatus = MFX_ERR_ABORTED;
return loadStatus;
}
if ((par.ExtParam[0]->BufferId != MFX_EXTBUFF_THREADS_PARAM) ||
(par.ExtParam[0]->BufferSz != sizeof(mfxExtThreadsParam)))
{
loadStatus = MFX_ERR_ABORTED;
return loadStatus;
}
}
// close the handle before initialization
Close();
// save the library's type
this->implType = implType;
this->impl = impl;
this->implInterface = implInterface;
{
DISPATCHER_LOG_BLOCK(("invoking LoadLibrary(%S)\n", MSDK2WIDE(pPath)));
// load the DLL into the memory
hModule = MFX::mfx_dll_load(pPath);
if (hModule)
{
int i;
DISPATCHER_LOG_OPERATION({
msdk_disp_char modulePath[1024];
GetModuleFileNameW((HMODULE)hModule, modulePath, sizeof(modulePath)/sizeof(modulePath[0]));
DISPATCHER_LOG_INFO((("loaded module %S\n"), MSDK2WIDE(modulePath)))
});
if (impl & MFX_IMPL_AUDIO)
{
// load audio functions: pointers to exposed functions
for (i = 0; i < eAudioFuncTotal; i += 1)
{
// construct correct name of the function - remove "_a" postfix
mfxFunctionPointer pProc = (mfxFunctionPointer) MFX::mfx_dll_get_addr(hModule, APIAudioFunc[i].pName);
#ifdef ANDROID
// on Android very first call to dlsym may fail
if (!pProc) pProc = (mfxFunctionPointer) MFX::mfx_dll_get_addr(hModule, APIAudioFunc[i].pName);
#endif
if (pProc)
{
// function exists in the library,
// save the pointer.
callAudioTable[i] = pProc;
}
else
{
// The library doesn't contain the function
DISPATCHER_LOG_WRN((("Can't find API function \"%s\"\n"), APIAudioFunc[i].pName));
if (apiVersion.Version >= APIAudioFunc[i].apiVersion.Version)
{
DISPATCHER_LOG_ERROR((("\"%s\" is required for API %u.%u\n"), APIAudioFunc[i].pName, apiVersion.Major, apiVersion.Minor));
mfxRes = MFX_ERR_UNSUPPORTED;
break;
}
}
}
}
else
{
// load video functions: pointers to exposed functions
for (i = 0; i < eVideoFuncTotal; i += 1)
{
mfxFunctionPointer pProc = (mfxFunctionPointer) MFX::mfx_dll_get_addr(hModule, APIFunc[i].pName);
#ifdef ANDROID
// on Android very first call to dlsym may fail
if (!pProc) pProc = (mfxFunctionPointer) MFX::mfx_dll_get_addr(hModule, APIFunc[i].pName);
#endif
if (pProc)
{
// function exists in the library,
// save the pointer.
callTable[i] = pProc;
}
else
{
// The library doesn't contain the function
DISPATCHER_LOG_WRN((("Can't find API function \"%s\"\n"), APIFunc[i].pName));
if (apiVersion.Version >= APIFunc[i].apiVersion.Version)
{
DISPATCHER_LOG_ERROR((("\"%s\" is required for API %u.%u\n"), APIFunc[i].pName, apiVersion.Major, apiVersion.Minor));
mfxRes = MFX_ERR_UNSUPPORTED;
break;
}
}
}
}
}
else
{
#if defined(_WIN32) || defined(_WIN64)
DISPATCHER_LOG_WRN((("can't find DLL: GetLastErr()=0x%x\n"), GetLastError()))
#else
DISPATCHER_LOG_WRN((("can't find DLL: dlerror() = \"%s\"\n"), dlerror()));
#endif
mfxRes = MFX_ERR_UNSUPPORTED;
}
}
// initialize the loaded DLL
if (MFX_ERR_NONE == mfxRes)
{
mfxVersion version(apiVersion);
/* check whether it is audio session or video */
mfxFunctionPointer *actualTable = (impl & MFX_IMPL_AUDIO) ? callAudioTable : callTable;
// Call old-style MFXInit init for older libraries and audio library
bool callOldInit = (impl & MFX_IMPL_AUDIO) || !actualTable[eMFXInitEx]; // if true call eMFXInit, if false - eMFXInitEx
int tableIndex = (callOldInit) ? eMFXInit : eMFXInitEx;
mfxFunctionPointer pFunc = actualTable[tableIndex];
{
if (callOldInit)
{
DISPATCHER_LOG_BLOCK(("MFXInit(%s,ver=%u.%u,session=0x%p)\n"
, DispatcherLog_GetMFXImplString(impl | implInterface).c_str()
, apiVersion.Major
, apiVersion.Minor
, &session));
mfxRes = (*(mfxStatus(MFX_CDECL *) (mfxIMPL, mfxVersion *, mfxSession *)) pFunc) (impl | implInterface, &version, &session);
}
else
{
DISPATCHER_LOG_BLOCK(("MFXInitEx(%s,ver=%u.%u,ExtThreads=%d,session=0x%p)\n"
, DispatcherLog_GetMFXImplString(impl | implInterface).c_str()
, apiVersion.Major
, apiVersion.Minor
, par.ExternalThreads
, &session));
mfxInitParam initPar = par;
// adjusting user parameters
initPar.Implementation = impl | implInterface;
initPar.Version = version;
mfxRes = (*(mfxStatus(MFX_CDECL *) (mfxInitParam, mfxSession *)) pFunc) (initPar, &session);
}
}
if (MFX_ERR_NONE != mfxRes)
{
DISPATCHER_LOG_WRN((("library can't be load. MFXInit returned %s \n"), DispatcherLog_GetMFXStatusString(mfxRes)))
}
else
{
mfxRes = MFXQueryVersion((mfxSession) this, &actualApiVersion);
if (MFX_ERR_NONE != mfxRes)
{
DISPATCHER_LOG_ERROR((("MFXQueryVersion returned: %d, skiped this library\n"), mfxRes))
}
else
{
DISPATCHER_LOG_INFO((("MFXQueryVersion returned API: %d.%d\n"), actualApiVersion.Major, actualApiVersion.Minor))
//special hook for applications that uses sink api to get loaded library path
DISPATCHER_LOG_LIBRARY(("%p" , hModule));
DISPATCHER_LOG_INFO(("library loaded succesfully\n"))
}
}
}
loadStatus = mfxRes;
return mfxRes;
} // mfxStatus MFX_DISP_HANDLE::LoadSelectedDLL(const msdk_disp_char *pPath, eMfxImplType implType, mfxIMPL impl)
mfxStatus MFX_DISP_HANDLE::UnLoadSelectedDLL(void)
{
mfxStatus mfxRes = MFX_ERR_NONE;
//unregistered plugins if any
pluginFactory.Close();
// close the loaded DLL
if (session)
{
/* check whether it is audio session or video */
int tableIndex = eMFXClose;
mfxFunctionPointer pFunc;
if (impl & MFX_IMPL_AUDIO)
{
pFunc = callAudioTable[tableIndex];
}
else
{
pFunc = callTable[tableIndex];
}
mfxRes = (*(mfxStatus (MFX_CDECL *) (mfxSession)) pFunc) (session);
if (MFX_ERR_NONE == mfxRes)
{
session = (mfxSession) 0;
}
DISPATCHER_LOG_INFO((("MFXClose(0x%x) returned %d\n"), session, mfxRes));
// actually, the return value is required to pass outside only.
}
// it is possible, that there is an active child session.
// can't unload library in that case.
if ((MFX_ERR_UNDEFINED_BEHAVIOR != mfxRes) &&
(hModule))
{
// unload the library.
if (!MFX::mfx_dll_free(hModule))
{
mfxRes = MFX_ERR_UNDEFINED_BEHAVIOR;
}
hModule = (mfxModuleHandle) 0;
}
return mfxRes;
} // mfxStatus MFX_DISP_HANDLE::UnLoadSelectedDLL(void)

449
plugins/obs-qsv11/libmfx/src/mfx_dispatcher_log.cpp
View file

@ -1,449 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_dispatcher_log.h
\* ****************************************************************************** */
#if defined(MFX_DISPATCHER_LOG)
#include "mfx_dispatcher_log.h"
#include "mfxstructures.h"
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#if defined(DISPATCHER_LOG_REGISTER_EVENT_PROVIDER)
#include <evntprov.h>
#include <winmeta.h>
#endif
#endif // #if defined(_WIN32) || defined(_WIN64)
#include <stdarg.h>
#include <algorithm>
#include <string>
#include <sstream>
struct CodeStringTable
{
int code;
const char *string;
} LevelStrings []=
{
{DL_INFO, "INFO: "},
{DL_WRN, "WARNING:"},
{DL_ERROR, "ERROR: "}
};
#define DEFINE_CODE(code)\
{code, #code}
static CodeStringTable StringsOfImpl[] = {
DEFINE_CODE(MFX_IMPL_AUTO),
DEFINE_CODE(MFX_IMPL_SOFTWARE),
DEFINE_CODE(MFX_IMPL_HARDWARE),
DEFINE_CODE(MFX_IMPL_AUTO_ANY),
DEFINE_CODE(MFX_IMPL_HARDWARE_ANY),
DEFINE_CODE(MFX_IMPL_HARDWARE2),
DEFINE_CODE(MFX_IMPL_HARDWARE3),
DEFINE_CODE(MFX_IMPL_HARDWARE4),
DEFINE_CODE(MFX_IMPL_UNSUPPORTED)
};
static CodeStringTable StringsOfImplVIA[] = {
DEFINE_CODE(MFX_IMPL_VIA_ANY),
DEFINE_CODE(MFX_IMPL_VIA_D3D9),
DEFINE_CODE(MFX_IMPL_VIA_D3D11),
};
static CodeStringTable StringsOfStatus[] =
{
DEFINE_CODE(MFX_ERR_NONE ),
DEFINE_CODE(MFX_ERR_UNKNOWN ),
DEFINE_CODE(MFX_ERR_NULL_PTR ),
DEFINE_CODE(MFX_ERR_UNSUPPORTED ),
DEFINE_CODE(MFX_ERR_MEMORY_ALLOC ),
DEFINE_CODE(MFX_ERR_NOT_ENOUGH_BUFFER ),
DEFINE_CODE(MFX_ERR_INVALID_HANDLE ),
DEFINE_CODE(MFX_ERR_LOCK_MEMORY ),
DEFINE_CODE(MFX_ERR_NOT_INITIALIZED ),
DEFINE_CODE(MFX_ERR_NOT_FOUND ),
DEFINE_CODE(MFX_ERR_MORE_DATA ),
DEFINE_CODE(MFX_ERR_MORE_SURFACE ),
DEFINE_CODE(MFX_ERR_ABORTED ),
DEFINE_CODE(MFX_ERR_DEVICE_LOST ),
DEFINE_CODE(MFX_ERR_INCOMPATIBLE_VIDEO_PARAM),
DEFINE_CODE(MFX_ERR_INVALID_VIDEO_PARAM ),
DEFINE_CODE(MFX_ERR_UNDEFINED_BEHAVIOR ),
DEFINE_CODE(MFX_ERR_DEVICE_FAILED ),
DEFINE_CODE(MFX_WRN_IN_EXECUTION ),
DEFINE_CODE(MFX_WRN_DEVICE_BUSY ),
DEFINE_CODE(MFX_WRN_VIDEO_PARAM_CHANGED ),
DEFINE_CODE(MFX_WRN_PARTIAL_ACCELERATION ),
DEFINE_CODE(MFX_WRN_INCOMPATIBLE_VIDEO_PARAM),
DEFINE_CODE(MFX_WRN_VALUE_NOT_CHANGED ),
DEFINE_CODE(MFX_WRN_OUT_OF_RANGE ),
};
#define CODE_TO_STRING(code, array)\
CodeToString(code, array, sizeof(array)/sizeof(array[0]))
const char* CodeToString(int code, CodeStringTable array[], int len )
{
for (int i = 0 ; i < len; i++)
{
if (array[i].code == code)
return array[i].string;
}
return "undef";
}
std::string DispatcherLog_GetMFXImplString(int impl)
{
std::string str1 = CODE_TO_STRING(impl & ~(-MFX_IMPL_VIA_ANY), StringsOfImpl);
std::string str2 = CODE_TO_STRING(impl & (-MFX_IMPL_VIA_ANY), StringsOfImplVIA);
return str1 + (str2 == "undef" ? "" : "|"+str2);
}
const char *DispatcherLog_GetMFXStatusString(int sts)
{
return CODE_TO_STRING(sts, StringsOfStatus);
}
//////////////////////////////////////////////////////////////////////////
void DispatcherLogBracketsHelper::Write(const char * str, ...)
{
va_list argsptr;
va_start(argsptr, str);
DispatchLog::get().Write(m_level, m_opcode, str, argsptr);
va_end(argsptr);
}
void DispatchLogBlockHelper::Write(const char * str, ...)
{
va_list argsptr;
va_start(argsptr, str);
DispatchLog::get().Write(m_level, DL_EVENT_START, str, argsptr);
va_end(argsptr);
}
DispatchLogBlockHelper::~DispatchLogBlockHelper()
{
DispatchLog::get().Write(m_level, DL_EVENT_STOP, NULL, NULL);
}
//////////////////////////////////////////////////////////////////////////
DispatchLog::DispatchLog()
: m_DispatcherLogSink(DL_SINK_PRINTF)
{
}
void DispatchLog::SetSink(int nSink, IMsgHandler * pHandler)
{
DetachAllSinks();
AttachSink(nSink, pHandler);
}
void DispatchLog::AttachSink(int nsink, IMsgHandler *pHandler)
{
m_DispatcherLogSink |= nsink;
if (NULL != pHandler)
m_Recepients.push_back(pHandler);
}
void DispatchLog::DetachSink(int nsink, IMsgHandler *pHandler)
{
if (nsink & DL_SINK_IMsgHandler)
{
m_Recepients.remove(pHandler);
}
m_DispatcherLogSink &= ~nsink;
}
void DispatchLog::ExchangeSink(int nsink, IMsgHandler *oldHdl, IMsgHandler *newHdl)
{
if (nsink & DL_SINK_IMsgHandler)
{
std::list<IMsgHandler*> :: iterator it = std::find(m_Recepients.begin(), m_Recepients.end(), oldHdl);
//cannot exchange in that case
if (m_Recepients.end() == it)
return;
*it = newHdl;
}
}
void DispatchLog::DetachAllSinks()
{
m_Recepients.clear();
m_DispatcherLogSink = DL_SINK_NULL;
}
void DispatchLog::Write(int level, int opcode, const char * msg, va_list argptr)
{
int sinkTable[] =
{
DL_SINK_PRINTF,
DL_SINK_IMsgHandler,
};
for (size_t i = 0; i < sizeof(sinkTable) / sizeof(sinkTable[0]); i++)
{
switch(m_DispatcherLogSink & sinkTable[i])
{
case DL_SINK_NULL:
break;
case DL_SINK_PRINTF:
{
char msg_formated[8048] = {0};
if (NULL != msg && level != DL_LOADED_LIBRARY)
{
#if _MSC_VER >= 1400
vsprintf_s(msg_formated, sizeof(msg_formated)/sizeof(msg_formated[0]), msg, argptr);
#else
vsnprintf(msg_formated, sizeof(msg_formated)/sizeof(msg_formated[0]), msg, argptr);
#endif
//TODO: improve this , add opcode handling
printf("%s %s", CODE_TO_STRING(level, LevelStrings), msg_formated);
}
break;
}
case DL_SINK_IMsgHandler:
{
std::list<IMsgHandler*>::iterator it;
for (it = m_Recepients.begin(); it != m_Recepients.end(); ++it)
{
(*it)->Write(level, opcode, msg, argptr);
}
break;
}
}
}
}
#if defined(DISPATCHER_LOG_REGISTER_EVENT_PROVIDER)
class ETWHandler : public IMsgHandler
{
public:
ETWHandler(const wchar_t * guid_str)
: m_bUseFormatter(DISPATCHER_LOG_USE_FORMATING)
, m_EventHandle()
, m_bProviderEnable()
{
GUID rguid = GUID_NULL;
if (FAILED(CLSIDFromString(guid_str, &rguid)))
{
return;
}
EventRegister(&rguid, NULL, NULL, &m_EventHandle);
m_bProviderEnable = 0 != EventProviderEnabled(m_EventHandle, 1,0);
}
~ETWHandler()
{
if (m_EventHandle)
{
EventUnregister(m_EventHandle);
}
}
virtual void Write(int level, int opcode, const char * msg, va_list argptr)
{
//event not registered
if (0==m_EventHandle)
{
return;
}
if (!m_bProviderEnable)
{
return;
}
if (level == DL_LOADED_LIBRARY)
{
return;
}
char msg_formated[1024];
EVENT_DESCRIPTOR descriptor;
EVENT_DATA_DESCRIPTOR data_descriptor;
EventDescZero(&descriptor);
descriptor.Opcode = (UCHAR)opcode;
descriptor.Level = (UCHAR)level;
if (m_bUseFormatter)
{
if (NULL != msg)
{
#if _MSC_VER >= 1400
vsprintf_s(msg_formated, sizeof (msg_formated) / sizeof (msg_formated[0]), msg, argptr);
#else
vsnprintf(msg_formated, sizeof (msg_formated) / sizeof (msg_formated[0]), msg, argptr);
#endif
EventDataDescCreate(&data_descriptor, msg_formated, (ULONG)(strlen(msg_formated) + 1));
}else
{
EventDataDescCreate(&data_descriptor, NULL, 0);
}
}else
{
//TODO: non formated events supports under zbb
}
EventWrite(m_EventHandle, &descriptor, 1, &data_descriptor);
}
protected:
//we may not use formatter in some cases described in dispatch_log macro
//it significantly increases performance by eliminating any vsprintf operations
bool m_bUseFormatter;
//consumer is attached, dispatcher trace to reduce formating overhead
//submits event only if consumer attached
bool m_bProviderEnable;
REGHANDLE m_EventHandle;
};
//
IMsgHandler *ETWHandlerFactory::GetSink(const wchar_t* sguid)
{
_storage_type::iterator it;
it = m_storage.find(sguid);
if (it == m_storage.end())
{
ETWHandler * handler = new ETWHandler(sguid);
_storage_type::_Pairib it_bool = m_storage.insert(_storage_type::value_type(sguid, handler));
it = it_bool.first;
}
return it->second;
}
ETWHandlerFactory::~ETWHandlerFactory()
{
for each(_storage_type::value_type val in m_storage)
{
delete val.second;
}
}
class EventRegistrator : public IMsgHandler
{
const wchar_t * m_sguid;
public:
EventRegistrator(const wchar_t* sguid = DISPATCHER_LOG_EVENT_GUID)
:m_sguid(sguid)
{
DispatchLog::get().AttachSink( DL_SINK_IMsgHandler
, this);
}
virtual void Write(int level, int opcode, const char * msg, va_list argptr)
{
//we cannot call attach sink since we may have been called from iteration
//we axchanging preserve that placeholding
IMsgHandler * pSink = NULL;
DispatchLog::get().ExchangeSink(DL_SINK_IMsgHandler,
this,
pSink = ETWHandlerFactory::get().GetSink(m_sguid));
//need to call only once here all next calls will be done inside dispatcherlog
if (NULL != pSink)
{
pSink->Write(level, opcode, msg, argptr);
}
}
};
#endif
template <class TSink>
class SinkRegistrator
{
};
#if defined(DISPATCHER_LOG_REGISTER_EVENT_PROVIDER)
template <>
class SinkRegistrator<ETWHandlerFactory>
{
public:
SinkRegistrator(const wchar_t* sguid = DISPATCHER_LOG_EVENT_GUID)
{
DispatchLog::get().AttachSink( DL_SINK_IMsgHandler
, ETWHandlerFactory::get().GetSink(sguid));
}
};
#endif
#if defined(DISPATCHER_LOG_REGISTER_FILE_WRITER)
template <>
class SinkRegistrator<FileSink>
{
public:
SinkRegistrator()
{
DispatchLog::get().AttachSink( DL_SINK_IMsgHandler, &FileSink::get(DISPACTHER_LOG_FW_PATH));
}
};
void FileSink::Write(int level, int /*opcode*/, const char * msg, va_list argptr)
{
if (NULL != m_hdl && NULL != msg)
{
fprintf(m_hdl, "%s", CODE_TO_STRING(level, LevelStrings));
vfprintf(m_hdl, msg, argptr);
}
}
#endif
//////////////////////////////////////////////////////////////////////////
//singletons initialization section
#ifdef DISPATCHER_LOG_REGISTER_EVENT_PROVIDER
static SinkRegistrator<ETWHandlerFactory> g_registrator1;
#endif
#ifdef DISPATCHER_LOG_REGISTER_FILE_WRITER
static SinkRegistrator<FileSink> g_registrator2;
#endif
#endif//(MFX_DISPATCHER_LOG)

558
plugins/obs-qsv11/libmfx/src/mfx_dxva2_device.cpp
View file

@ -1,558 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_dxva2_device.cpp
\* ****************************************************************************** */
#if defined(_WIN32) || defined(_WIN64)
#define INITGUID
#include <d3d9.h>
#include <dxgi.h>
#include "mfx_dxva2_device.h"
using namespace MFX;
DXDevice::DXDevice(void)
{
m_hModule = (HMODULE) 0;
m_numAdapters = 0;
m_vendorID = 0;
m_deviceID = 0;
m_driverVersion = 0;
m_luid = 0;
} // DXDevice::DXDevice(void)
DXDevice::~DXDevice(void)
{
Close();
// free DX library only when device is destroyed
UnloadDLLModule();
} // DXDevice::~DXDevice(void)
mfxU32 DXDevice::GetVendorID(void) const
{
return m_vendorID;
} // mfxU32 DXDevice::GetVendorID(void) const
mfxU32 DXDevice::GetDeviceID(void) const
{
return m_deviceID;
} // mfxU32 DXDevice::GetDeviceID(void) const
mfxU64 DXDevice::GetDriverVersion(void) const
{
return m_driverVersion;
}// mfxU64 DXDevice::GetDriverVersion(void) const
mfxU64 DXDevice::GetLUID(void) const
{
return m_luid;
} // mfxU64 DXDevice::GetLUID(void) const
mfxU32 DXDevice::GetAdapterCount(void) const
{
return m_numAdapters;
} // mfxU32 DXDevice::GetAdapterCount(void) const
void DXDevice::Close(void)
{
m_numAdapters = 0;
m_vendorID = 0;
m_deviceID = 0;
m_luid = 0;
} // void DXDevice::Close(void)
void DXDevice::LoadDLLModule(const wchar_t *pModuleName)
{
DWORD prevErrorMode = 0;
// unload the module if it is required
UnloadDLLModule();
// set the silent error mode
#if (_WIN32_WINNT >= 0x0600) && !(__GNUC__)
SetThreadErrorMode(SEM_FAILCRITICALERRORS, &prevErrorMode);
#else
prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
#endif
// load specified library
m_hModule = LoadLibraryExW(pModuleName, NULL, 0);
// set the previous error mode
#if (_WIN32_WINNT >= 0x0600) && !(__GNUC__)
SetThreadErrorMode(prevErrorMode, NULL);
#else
SetErrorMode(prevErrorMode);
#endif
} // void LoadDLLModule(const wchar_t *pModuleName)
void DXDevice::UnloadDLLModule(void)
{
if (m_hModule)
{
FreeLibrary(m_hModule);
m_hModule = (HMODULE) 0;
}
} // void DXDevice::UnloaDLLdModule(void)
D3D9Device::D3D9Device(void)
{
m_pD3D9 = (void *) 0;
m_pD3D9Ex = (void *) 0;
} // D3D9Device::D3D9Device(void)
D3D9Device::~D3D9Device(void)
{
Close();
} // D3D9Device::~D3D9Device(void)
void D3D9Device::Close(void)
{
// release the interfaces
if (m_pD3D9Ex)
{
((IDirect3D9Ex *) m_pD3D9Ex)->Release();
}
// release the interfaces
if (m_pD3D9)
{
((IDirect3D9 *) m_pD3D9)->Release();
}
m_pD3D9 = (void *) 0;
m_pD3D9Ex = (void *) 0;
} // void D3D9Device::Close(void)
typedef
IDirect3D9 * (WINAPI *D3DCreateFunctionPtr_t) (UINT);
typedef
HRESULT (WINAPI *D3DExCreateFunctionPtr_t) (UINT, IDirect3D9Ex **);
bool D3D9Device::Init(const mfxU32 adapterNum)
{
// close the device before initialization
Close();
// load the library
if (NULL == m_hModule)
{
LoadDLLModule(L"d3d9.dll");
}
if (m_hModule)
{
D3DCreateFunctionPtr_t pFunc;
// load address of procedure to create D3D device
pFunc = (D3DCreateFunctionPtr_t) GetProcAddress(m_hModule, "Direct3DCreate9");
if (pFunc)
{
D3DADAPTER_IDENTIFIER9 adapterIdent;
IDirect3D9 *pD3D9;
HRESULT hRes;
// create D3D object
m_pD3D9 = pFunc(D3D_SDK_VERSION);
if (NULL == m_pD3D9)
{
DXVA2DEVICE_TRACE(("FAIL: Direct3DCreate9(%d) : GetLastError()=0x%x", D3D_SDK_VERSION, GetLastError()));
return false;
}
// cast the interface
pD3D9 = (IDirect3D9 *) m_pD3D9;
m_numAdapters = pD3D9->GetAdapterCount();
if (adapterNum >= m_numAdapters)
{
return false;
}
// get the card's parameters
hRes = pD3D9->GetAdapterIdentifier(adapterNum, 0, &adapterIdent);
if (D3D_OK != hRes)
{
DXVA2DEVICE_TRACE(("FAIL: GetAdapterIdentifier(%d) = 0x%x \n", adapterNum, hRes));
return false;
}
m_vendorID = adapterIdent.VendorId;
m_deviceID = adapterIdent.DeviceId;
m_driverVersion = (mfxU64)adapterIdent.DriverVersion.QuadPart;
// load LUID
IDirect3D9Ex *pD3D9Ex;
D3DExCreateFunctionPtr_t pFuncEx;
LUID d3d9LUID;
// find the appropriate function
pFuncEx = (D3DExCreateFunctionPtr_t) GetProcAddress(m_hModule, "Direct3DCreate9Ex");
if (NULL == pFuncEx)
{
// the extended interface is not supported
return true;
}
// create extended interface
hRes = pFuncEx(D3D_SDK_VERSION, &pD3D9Ex);
if (FAILED(hRes))
{
// can't create extended interface
return true;
}
m_pD3D9Ex = pD3D9Ex;
// obtain D3D9 device LUID
hRes = pD3D9Ex->GetAdapterLUID(adapterNum, &d3d9LUID);
if (FAILED(hRes))
{
// can't get LUID
return true;
}
// copy the LUID
*((LUID *) &m_luid) = d3d9LUID;
}
else
{
DXVA2DEVICE_TRACE_OPERATION({
wchar_t path[1024];
DWORD lastErr = GetLastError();
GetModuleFileNameW(m_hModule, path, sizeof(path)/sizeof(path[0]));
DXVA2DEVICE_TRACE(("FAIL: invoking GetProcAddress(Direct3DCreate9) in %S : GetLastError()==0x%x\n", path, lastErr)); });
return false;
}
}
else
{
DXVA2DEVICE_TRACE(("FAIL: invoking LoadLibrary(\"d3d9.dll\") : GetLastError()==0x%x\n", GetLastError()));
return false;
}
return true;
} // bool D3D9Device::Init(const mfxU32 adapterNum)
typedef
HRESULT (WINAPI *DXGICreateFactoryFunc) (REFIID riid, void **ppFactory);
DXGI1Device::DXGI1Device(void)
{
m_pDXGIFactory1 = (void *) 0;
m_pDXGIAdapter1 = (void *) 0;
} // DXGI1Device::DXGI1Device(void)
DXGI1Device::~DXGI1Device(void)
{
Close();
} // DXGI1Device::~DXGI1Device(void)
void DXGI1Device::Close(void)
{
// release the interfaces
if (m_pDXGIAdapter1)
{
((IDXGIAdapter1 *) m_pDXGIAdapter1)->Release();
}
if (m_pDXGIFactory1)
{
((IDXGIFactory1 *) m_pDXGIFactory1)->Release();
}
m_pDXGIFactory1 = (void *) 0;
m_pDXGIAdapter1 = (void *) 0;
} // void DXGI1Device::Close(void)
bool DXGI1Device::Init(const mfxU32 adapterNum)
{
// release the object before initialization
Close();
// load up the library if it is not loaded
if (NULL == m_hModule)
{
LoadDLLModule(L"dxgi.dll");
}
if (m_hModule)
{
DXGICreateFactoryFunc pFunc;
IDXGIFactory1 *pFactory;
IDXGIAdapter1 *pAdapter;
DXGI_ADAPTER_DESC1 desc;
mfxU32 curAdapter, maxAdapters;
HRESULT hRes;
// load address of procedure to create DXGI 1.1 factory
pFunc = (DXGICreateFactoryFunc) GetProcAddress(m_hModule, "CreateDXGIFactory1");
if (NULL == pFunc)
{
return false;
}
// create the factory
#if _MSC_VER >= 1400
hRes = pFunc(__uuidof(IDXGIFactory1), (void**) (&pFactory));
#else
hRes = pFunc(IID_IDXGIFactory1, (void**) (&pFactory));
#endif
if (FAILED(hRes))
{
return false;
}
m_pDXGIFactory1 = pFactory;
// get the number of adapters
curAdapter = 0;
maxAdapters = 0;
do
{
// get the required adapted
hRes = pFactory->EnumAdapters1(curAdapter, &pAdapter);
if (FAILED(hRes))
{
break;
}
// if it is the required adapter, save the interface
if (curAdapter == adapterNum)
{
m_pDXGIAdapter1 = pAdapter;
}
else
{
pAdapter->Release();
}
// get the next adapter
curAdapter += 1;
} while (SUCCEEDED(hRes));
maxAdapters = curAdapter;
// there is no required adapter
if (adapterNum >= maxAdapters)
{
return false;
}
pAdapter = (IDXGIAdapter1 *) m_pDXGIAdapter1;
// get the adapter's parameters
hRes = pAdapter->GetDesc1(&desc);
if (FAILED(hRes))
{
return false;
}
// save the parameters
m_vendorID = desc.VendorId;
m_deviceID = desc.DeviceId;
*((LUID *) &m_luid) = desc.AdapterLuid;
}
return true;
} // bool DXGI1Device::Init(const mfxU32 adapterNum)
DXVA2Device::DXVA2Device(void)
{
m_numAdapters = 0;
m_vendorID = 0;
m_deviceID = 0;
} // DXVA2Device::DXVA2Device(void)
DXVA2Device::~DXVA2Device(void)
{
Close();
} // DXVA2Device::~DXVA2Device(void)
void DXVA2Device::Close(void)
{
m_numAdapters = 0;
m_vendorID = 0;
m_deviceID = 0;
} // void DXVA2Device::Close(void)
bool DXVA2Device::InitD3D9(const mfxU32 adapterNum)
{
D3D9Device d3d9Device;
bool bRes;
// release the object before initialization
Close();
// create 'old fashion' device
bRes = d3d9Device.Init(adapterNum);
if (false == bRes)
{
return false;
}
m_numAdapters = d3d9Device.GetAdapterCount();
// check if the application is under Remote Desktop
if ((0 == d3d9Device.GetVendorID()) || (0 == d3d9Device.GetDeviceID()))
{
// get the required parameters alternative way and ...
UseAlternativeWay(&d3d9Device);
}
else
{
// save the parameters and ...
m_vendorID = d3d9Device.GetVendorID();
m_deviceID = d3d9Device.GetDeviceID();
m_driverVersion = d3d9Device.GetDriverVersion();
}
// ... say goodbye
return true;
} // bool InitD3D9(const mfxU32 adapterNum)
bool DXVA2Device::InitDXGI1(const mfxU32 adapterNum)
{
DXGI1Device dxgi1Device;
bool bRes;
// release the object before initialization
Close();
// create modern DXGI device
bRes = dxgi1Device.Init(adapterNum);
if (false == bRes)
{
return false;
}
// save the parameters and ...
m_vendorID = dxgi1Device.GetVendorID();
m_deviceID = dxgi1Device.GetDeviceID();
m_numAdapters = dxgi1Device.GetAdapterCount();
// ... say goodbye
return true;
} // bool DXVA2Device::InitDXGI1(const mfxU32 adapterNum)
void DXVA2Device::UseAlternativeWay(const D3D9Device *pD3D9Device)
{
mfxU64 d3d9LUID = pD3D9Device->GetLUID();
// work only with valid LUIDs
if (0 == d3d9LUID)
{
return;
}
DXGI1Device dxgi1Device;
mfxU32 curDevice = 0;
bool bRes = false;
do
{
// initialize the next DXGI1 or DXGI device
bRes = dxgi1Device.Init(curDevice);
if (false == bRes)
{
// there is no more devices
break;
}
// is it required device ?
if (d3d9LUID == dxgi1Device.GetLUID())
{
m_vendorID = dxgi1Device.GetVendorID();
m_deviceID = dxgi1Device.GetDeviceID();
m_driverVersion = dxgi1Device.GetDriverVersion();
return ;
}
// get the next device
curDevice += 1;
} while (bRes);
dxgi1Device.Close();
// we need to match a DXGI(1) device to the D3D9 device
} // void DXVA2Device::UseAlternativeWay(const D3D9Device *pD3D9Device)
mfxU32 DXVA2Device::GetVendorID(void) const
{
return m_vendorID;
} // mfxU32 DXVA2Device::GetVendorID(void) const
mfxU32 DXVA2Device::GetDeviceID(void) const
{
return m_deviceID;
} // mfxU32 DXVA2Device::GetDeviceID(void) const
mfxU64 DXVA2Device::GetDriverVersion(void) const
{
return m_driverVersion;
}// mfxU64 DXVA2Device::GetDriverVersion(void) const
mfxU32 DXVA2Device::GetAdapterCount(void) const
{
return m_numAdapters;
} // mfxU32 DXVA2Device::GetAdapterCount(void) const
#endif

143
plugins/obs-qsv11/libmfx/src/mfx_function_table.cpp
View file

@ -1,143 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_function_table.cpp
\* ****************************************************************************** */
#include "mfx_dispatcher.h"
//
// implement a table with functions names
//
#undef FUNCTION
#define FUNCTION(return_value, func_name, formal_param_list, actual_param_list) \
{#func_name, API_VERSION},
const
FUNCTION_DESCRIPTION APIFunc[eVideoFuncTotal] =
{
{"MFXInit", {{0, 1}}},
{"MFXClose", {{0, 1}}},
{"MFXQueryIMPL", {{0, 1}}},
{"MFXQueryVersion", {{0, 1}}},
{"MFXJoinSession", {{1, 1}}},
{"MFXDisjoinSession", {{1, 1}}},
{"MFXCloneSession", {{1, 1}}},
{"MFXSetPriority", {{1, 1}}},
{"MFXGetPriority", {{1, 1}}},
{"MFXInitEx", {{1, 14}}},
#include "mfx_exposed_functions_list.h"
};
const
FUNCTION_DESCRIPTION APIAudioFunc[eAudioFuncTotal] =
{
{"MFXInit", {{8, 1}}},
{"MFXClose", {{8, 1}}},
{"MFXQueryIMPL", {{8, 1}}},
{"MFXQueryVersion", {{8, 1}}},
{"MFXJoinSession", {{8, 1}}},
{"MFXDisjoinSession", {{8, 1}}},
{"MFXCloneSession", {{8, 1}}},
{"MFXSetPriority", {{8, 1}}},
{"MFXGetPriority", {{8, 1}}},
#include "mfxaudio_exposed_functions_list.h"
};
// static section of the file
namespace
{
//
// declare pseudo-functions.
// they are used as default values for call-tables.
//
mfxStatus pseudoMFXInit(mfxIMPL impl, mfxVersion *ver, mfxSession *session)
{
// touch unreferenced parameters
impl = impl;
ver = ver;
session = session;
return MFX_ERR_UNKNOWN;
} // mfxStatus pseudoMFXInit(mfxIMPL impl, mfxVersion *ver, mfxSession *session)
mfxStatus pseudoMFXClose(mfxSession session)
{
// touch unreferenced parameters
session = session;
return MFX_ERR_UNKNOWN;
} // mfxStatus pseudoMFXClose(mfxSession session)
mfxStatus pseudoMFXJoinSession(mfxSession session, mfxSession child_session)
{
// touch unreferenced parameters
session = session;
child_session = child_session;
return MFX_ERR_UNKNOWN;
} // mfxStatus pseudoMFXJoinSession(mfxSession session, mfxSession child_session)
mfxStatus pseudoMFXCloneSession(mfxSession session, mfxSession *clone)
{
// touch unreferenced parameters
session = session;
clone = clone;
return MFX_ERR_UNKNOWN;
} // mfxStatus pseudoMFXCloneSession(mfxSession session, mfxSession *clone)
void SuppressWarnings(...)
{
// this functions is suppose to suppress warnings.
// Actually it does nothing.
} // void SuppressWarnings(...)
#undef FUNCTION
#define FUNCTION(return_value, func_name, formal_param_list, actual_param_list) \
return_value pseudo##func_name formal_param_list \
{ \
SuppressWarnings actual_param_list; \
return MFX_ERR_UNKNOWN; \
}
#include "mfx_exposed_functions_list.h"
} // namespace

475
plugins/obs-qsv11/libmfx/src/mfx_library_iterator.cpp
View file

@ -1,475 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-2015 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: mfx_library_iterator.cpp
\* ****************************************************************************** */
#if defined(_WIN32) || defined(_WIN64)
#include "mfx_library_iterator.h"
#include "mfx_dispatcher.h"
#include "mfx_dispatcher_log.h"
#include "mfx_dxva2_device.h"
#include "mfx_load_dll.h"
#include <tchar.h>
#include <windows.h>
namespace MFX
{
enum
{
MFX_MAX_MERIT = 0x7fffffff
};
//
// declare registry keys
//
const
wchar_t rootDispPath[] = L"Software\\Intel\\MediaSDK\\Dispatch";
const
wchar_t vendorIDKeyName[] = L"VendorID";
const
wchar_t deviceIDKeyName[] = L"DeviceID";
const
wchar_t meritKeyName[] = L"Merit";
const
wchar_t pathKeyName[] = L"Path";
const
wchar_t apiVersionName[] = L"APIVersion";
mfxStatus SelectImplementationType(const mfxU32 adapterNum, mfxIMPL *pImplInterface, mfxU32 *pVendorID, mfxU32 *pDeviceID)
{
if (NULL == pImplInterface)
{
return MFX_ERR_NULL_PTR;
}
DXVA2Device dxvaDevice;
if (MFX_IMPL_VIA_D3D9 == *pImplInterface)
{
// try to create the Direct3D 9 device and find right adapter
if (!dxvaDevice.InitD3D9(adapterNum))
{
DISPATCHER_LOG_INFO((("dxvaDevice.InitD3D9(%d) Failed "), adapterNum ));
return MFX_ERR_UNSUPPORTED;
}
}
else if (MFX_IMPL_VIA_D3D11 == *pImplInterface)
{
// try to open DXGI 1.1 device to get hardware ID
if (!dxvaDevice.InitDXGI1(adapterNum))
{
DISPATCHER_LOG_INFO((("dxvaDevice.InitDXGI1(%d) Failed "), adapterNum ));
return MFX_ERR_UNSUPPORTED;
}
}
else if (MFX_IMPL_VIA_ANY == *pImplInterface)
{
// try the Direct3D 9 device
if (dxvaDevice.InitD3D9(adapterNum))
{
*pImplInterface = MFX_IMPL_VIA_D3D9; // store value for GetImplementationType() call
}
// else try to open DXGI 1.1 device to get hardware ID
else if (dxvaDevice.InitDXGI1(adapterNum))
{
*pImplInterface = MFX_IMPL_VIA_D3D11; // store value for GetImplementationType() call
}
else
{
DISPATCHER_LOG_INFO((("Unsupported adapter %d "), adapterNum ));
return MFX_ERR_UNSUPPORTED;
}
}
else
{
DISPATCHER_LOG_ERROR((("Unknown implementation type %d "), *pImplInterface ));
return MFX_ERR_UNSUPPORTED;
}
// obtain card's parameters
if (pVendorID && pDeviceID)
{
*pVendorID = dxvaDevice.GetVendorID();
*pDeviceID = dxvaDevice.GetDeviceID();
}
return MFX_ERR_NONE;
}
MFXLibraryIterator::MFXLibraryIterator(void)
{
m_implType = MFX_LIB_PSEUDO;
m_implInterface = MFX_IMPL_UNSUPPORTED;
m_vendorID = 0;
m_deviceID = 0;
m_lastLibIndex = 0;
m_lastLibMerit = MFX_MAX_MERIT;
m_bIsSubKeyValid = 0;
m_StorageID = 0;
m_SubKeyName[0] = 0;
} // MFXLibraryIterator::MFXLibraryIterator(void)
MFXLibraryIterator::~MFXLibraryIterator(void)
{
Release();
} // MFXLibraryIterator::~MFXLibraryIterator(void)
void MFXLibraryIterator::Release(void)
{
m_implType = MFX_LIB_PSEUDO;
m_implInterface = MFX_IMPL_UNSUPPORTED;
m_vendorID = 0;
m_deviceID = 0;
m_lastLibIndex = 0;
m_lastLibMerit = MFX_MAX_MERIT;
m_SubKeyName[0] = 0;
} // void MFXLibraryIterator::Release(void)
mfxStatus MFXLibraryIterator::Init(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, int storageID)
{
// check error(s)
if ((MFX_LIB_SOFTWARE != implType) &&
(MFX_LIB_HARDWARE != implType))
{
return MFX_ERR_UNSUPPORTED;
}
// release the object before initialization
Release();
m_StorageID = storageID;
m_lastLibIndex = 0;
if (storageID == MFX_CURRENT_USER_KEY || storageID == MFX_LOCAL_MACHINE_KEY)
{
return InitRegistry(implType, implInterface, adapterNum, storageID);
}
else if (storageID == MFX_APP_FOLDER)
{
msdk_disp_char path[_MAX_PATH] = {};
::GetModuleFileNameW(0, path, _MAX_PATH);
msdk_disp_char * dirSeparator = wcsrchr(path, L'\\');
if (dirSeparator < (path + _MAX_PATH))
{
*++dirSeparator = 0;
}
return InitFolder(implType, implInterface, adapterNum, path);
}
return MFX_ERR_UNSUPPORTED;
} // mfxStatus MFXLibraryIterator::Init(eMfxImplType implType, const mfxU32 adapterNum, int storageID)
mfxStatus MFXLibraryIterator::InitRegistry(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, int storageID)
{
HKEY rootHKey;
bool bRes;
// open required registry key
rootHKey = (MFX_LOCAL_MACHINE_KEY == storageID) ? (HKEY_LOCAL_MACHINE) : (HKEY_CURRENT_USER);
bRes = m_baseRegKey.Open(rootHKey, rootDispPath, KEY_READ);
if (false == bRes)
{
DISPATCHER_LOG_WRN((("Can't open %s\\%S : RegOpenKeyExA()==0x%x\n"),
(MFX_LOCAL_MACHINE_KEY == storageID) ? ("HKEY_LOCAL_MACHINE") : ("HKEY_CURRENT_USER"),
rootDispPath, GetLastError()))
return MFX_ERR_UNKNOWN;
}
// set the required library's implementation type
m_implType = implType;
m_implInterface = implInterface != 0
? implInterface
: MFX_IMPL_VIA_ANY;
//deviceID and vendorID are not actual for SW library loading
if (m_implType != MFX_LIB_SOFTWARE)
{
mfxStatus mfxRes = MFX::SelectImplementationType(adapterNum, &m_implInterface, &m_vendorID, &m_deviceID);
if (MFX_ERR_NONE != mfxRes)
{
return mfxRes;
}
}
DISPATCHER_LOG_INFO((("Inspecting %s\\%S\n"),
(MFX_LOCAL_MACHINE_KEY == storageID) ? ("HKEY_LOCAL_MACHINE") : ("HKEY_CURRENT_USER"),
rootDispPath))
return MFX_ERR_NONE;
} // mfxStatus MFXLibraryIterator::InitRegistry(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, int storageID)
mfxStatus MFXLibraryIterator::InitFolder(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, const msdk_disp_char * path)
{
const int maxPathLen = sizeof(m_path)/sizeof(m_path[0]);
m_path[0] = 0;
msdk_disp_char_cpy_s(m_path, maxPathLen, path);
size_t pathLen = wcslen(m_path);
// we looking for runtime in application folder, it should be named libmfxsw64 or libmfxsw32
mfx_get_default_dll_name(m_path + pathLen, maxPathLen - pathLen, MFX_LIB_SOFTWARE);
// set the required library's implementation type
m_implType = implType;
m_implInterface = implInterface != 0
? implInterface
: MFX_IMPL_VIA_ANY;
//deviceID and vendorID are not actual for SW library loading
if (m_implType != MFX_LIB_SOFTWARE)
{
mfxStatus mfxRes = MFX::SelectImplementationType(adapterNum, &m_implInterface, &m_vendorID, &m_deviceID);
if (MFX_ERR_NONE != mfxRes)
{
return mfxRes;
}
}
return MFX_ERR_NONE;
} // mfxStatus MFXLibraryIterator::InitFolder(eMfxImplType implType, mfxIMPL implInterface, const mfxU32 adapterNum, const msdk_disp_char * path)
mfxStatus MFXLibraryIterator::SelectDLLVersion(wchar_t *pPath
, size_t pathSize
, eMfxImplType *pImplType, mfxVersion minVersion)
{
UNREFERENCED_PARAMETER(minVersion);
if (m_StorageID == MFX_APP_FOLDER)
{
if (m_lastLibIndex != 0)
return MFX_ERR_NOT_FOUND;
m_lastLibIndex = 1;
msdk_disp_char_cpy_s(pPath, pathSize, m_path);
*pImplType = MFX_LIB_SOFTWARE;
return MFX_ERR_NONE;
}
wchar_t libPath[MFX_MAX_DLL_PATH] = L"";
DWORD libIndex = 0;
DWORD libMerit = 0;
DWORD index;
bool enumRes;
// main query cycle
index = 0;
m_bIsSubKeyValid = false;
do
{
WinRegKey subKey;
wchar_t subKeyName[MFX_MAX_REGISTRY_KEY_NAME];
DWORD subKeyNameSize = sizeof(subKeyName) / sizeof(subKeyName[0]);
// query next value name
enumRes = m_baseRegKey.EnumKey(index, subKeyName, &subKeyNameSize);
if (!enumRes)
{
DISPATCHER_LOG_WRN((("no more subkeys : RegEnumKeyExA()==0x%x\n"), GetLastError()))
}
else
{
DISPATCHER_LOG_INFO((("found subkey: %S\n"), subKeyName))
bool bRes;
// open the sub key
bRes = subKey.Open(m_baseRegKey, subKeyName, KEY_READ);
if (!bRes)
{
DISPATCHER_LOG_WRN((("error opening key %S :RegOpenKeyExA()==0x%x\n"), subKeyName, GetLastError()));
}
else
{
DISPATCHER_LOG_INFO((("opened key: %S\n"), subKeyName));
mfxU32 vendorID = 0, deviceID = 0, merit = 0;
DWORD size;
// query vendor and device IDs
size = sizeof(vendorID);
bRes = subKey.Query(vendorIDKeyName, REG_DWORD, (LPBYTE) &vendorID, &size);
DISPATCHER_LOG_OPERATION({
if (bRes)
{
DISPATCHER_LOG_INFO((("loaded %S : 0x%x\n"), vendorIDKeyName, vendorID));
}
else
{
DISPATCHER_LOG_WRN((("querying %S : RegQueryValueExA()==0x%x\n"), vendorIDKeyName, GetLastError()));
}
})
if (bRes)
{
size = sizeof(deviceID);
bRes = subKey.Query(deviceIDKeyName, REG_DWORD, (LPBYTE) &deviceID, &size);
DISPATCHER_LOG_OPERATION({
if (bRes)
{
DISPATCHER_LOG_INFO((("loaded %S : 0x%x\n"), deviceIDKeyName, deviceID));
}
else
{
DISPATCHER_LOG_WRN((("querying %S : RegQueryValueExA()==0x%x\n"), deviceIDKeyName, GetLastError()));
}
})
}
// query merit value
if (bRes)
{
size = sizeof(merit);
bRes = subKey.Query(meritKeyName, REG_DWORD, (LPBYTE) &merit, &size);
DISPATCHER_LOG_OPERATION({
if (bRes)
{
DISPATCHER_LOG_INFO((("loaded %S : %d\n"), meritKeyName, merit));
}
else
{
DISPATCHER_LOG_WRN((("querying %S : RegQueryValueExA()==0x%x\n"), meritKeyName, GetLastError()));
}
})
}
// if the library fits required parameters,
// query the library's path
if (bRes)
{
// compare device's and library's IDs
if (MFX_LIB_HARDWARE == m_implType)
{
if (m_vendorID != vendorID)
{
bRes = false;
DISPATCHER_LOG_WRN((("%S conflict, actual = 0x%x : required = 0x%x\n"), vendorIDKeyName, m_vendorID, vendorID));
}
if (bRes && m_deviceID != deviceID)
{
bRes = false;
DISPATCHER_LOG_WRN((("%S conflict, actual = 0x%x : required = 0x%x\n"), deviceIDKeyName, m_deviceID, deviceID));
}
}
DISPATCHER_LOG_OPERATION({
if (bRes)
{
if (!(((m_lastLibMerit > merit) || ((m_lastLibMerit == merit) && (m_lastLibIndex < index))) &&
(libMerit < merit)))
{
DISPATCHER_LOG_WRN((("merit conflict: lastMerit = 0x%x, requiredMerit = 0x%x, libraryMerit = 0x%x, lastindex = %d, index = %d\n")
, m_lastLibMerit, merit, libMerit, m_lastLibIndex, index));
}
}})
if ((bRes) &&
((m_lastLibMerit > merit) || ((m_lastLibMerit == merit) && (m_lastLibIndex < index))) &&
(libMerit < merit))
{
wchar_t tmpPath[MFX_MAX_DLL_PATH];
DWORD tmpPathSize = sizeof(tmpPath);
bRes = subKey.Query(pathKeyName, REG_SZ, (LPBYTE) tmpPath, &tmpPathSize);
if (!bRes)
{
DISPATCHER_LOG_WRN((("error querying %S : RegQueryValueExA()==0x%x\n"), pathKeyName, GetLastError()));
}
else
{
DISPATCHER_LOG_INFO((("loaded %S : %S\n"), pathKeyName, tmpPath));
msdk_disp_char_cpy_s(libPath, sizeof(libPath) / sizeof(libPath[0]), tmpPath);
msdk_disp_char_cpy_s(m_SubKeyName, sizeof(m_SubKeyName) / sizeof(m_SubKeyName[0]), subKeyName);
libMerit = merit;
libIndex = index;
// set the library's type
if ((0 == vendorID) || (0 == deviceID))
{
*pImplType = MFX_LIB_SOFTWARE;
DISPATCHER_LOG_INFO((("Library type is MFX_LIB_SOFTWARE\n")));
}
else
{
*pImplType = MFX_LIB_HARDWARE;
DISPATCHER_LOG_INFO((("Library type is MFX_LIB_HARDWARE\n")));
}
}
}
}
}
}
// advance key index
index += 1;
} while (enumRes);
// if the library's path was successfully read,
// the merit variable holds valid value
if (0 == libMerit)
{
return MFX_ERR_NOT_FOUND;
}
msdk_disp_char_cpy_s(pPath, pathSize, libPath);
m_lastLibIndex = libIndex;
m_lastLibMerit = libMerit;
m_bIsSubKeyValid = true;
return MFX_ERR_NONE;
} // mfxStatus MFXLibraryIterator::SelectDLLVersion(wchar_t *pPath, size_t pathSize, eMfxImplType *pImplType, mfxVersion minVersion)
mfxIMPL MFXLibraryIterator::GetImplementationType()
{
return m_implInterface;
} // mfxIMPL MFXLibraryIterator::GetImplementationType()
bool MFXLibraryIterator::GetSubKeyName(msdk_disp_char *subKeyName, size_t length) const
{
msdk_disp_char_cpy_s(subKeyName, length, m_SubKeyName);
return m_bIsSubKeyValid;
}
} // namespace MFX
#endif // #if defined(_WIN32) || defined(_WIN64)

241
plugins/obs-qsv11/libmfx/src/mfx_load_dll.cpp
View file

@ -1,241 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_load_dll.cpp
\* ****************************************************************************** */
#if defined(_WIN32) || defined(_WIN64)
#include "mfx_dispatcher.h"
#include "mfx_load_dll.h"
#include <wchar.h>
#include <string.h>
#include <windows.h>
#if !defined(_DEBUG)
#if defined(_WIN64)
const
wchar_t * const defaultDLLName[2] = {L"libmfxhw64.dll",
L"libmfxsw64.dll"};
const
wchar_t * const defaultAudioDLLName[2] = {L"libmfxaudiosw64.dll",
L"libmfxaudiosw64.dll"};
const
wchar_t * const defaultPluginDLLName[2] = {L"mfxplugin64_hw.dll",
L"mfxplugin64_sw.dll"};
#elif defined(_WIN32)
const
wchar_t * const defaultDLLName[2] = {L"libmfxhw32.dll",
L"libmfxsw32.dll"};
const
wchar_t * const defaultAudioDLLName[2] = {L"libmfxaudiosw32.dll",
L"libmfxaudiosw32.dll"};
const
wchar_t * const defaultPluginDLLName[2] = {L"mfxplugin32_hw.dll",
L"mfxplugin32_sw.dll"};
#endif // (defined(_WIN64))
#else // defined(_DEBUG)
#if defined(_WIN64)
const
wchar_t * const defaultDLLName[2] = {L"libmfxhw64_d.dll",
L"libmfxsw64_d.dll"};
const
wchar_t * const defaultAudioDLLName[2] = {L"libmfxaudiosw64_d.dll",
L"libmfxaudiosw64_d.dll"};
const
wchar_t * const defaultPluginDLLName[2] = {L"mfxplugin64_hw_d.dll",
L"mfxplugin64_sw_d.dll"};
#elif defined(WIN32)
const
wchar_t * const defaultDLLName[2] = {L"libmfxhw32_d.dll",
L"libmfxsw32_d.dll"};
const
wchar_t * const defaultAudioDLLName[2] = {L"libmfxaudiosw32_d.dll",
L"libmfxaudiosw32_d.dll"};
const
wchar_t * const defaultPluginDLLName[2] = {L"mfxplugin32_hw_d.dll",
L"mfxplugin32_sw_d.dll"};
#endif // (defined(_WIN64))
#endif // !defined(_DEBUG)
namespace MFX
{
mfxStatus mfx_get_default_dll_name(msdk_disp_char *pPath, size_t pathSize, eMfxImplType implType)
{
if (!pPath)
{
return MFX_ERR_NULL_PTR;
}
// there are only 2 implementation with default DLL names
#if _MSC_VER >= 1400
return 0 == wcscpy_s(pPath, pathSize, defaultDLLName[implType & 1])
? MFX_ERR_NONE : MFX_ERR_UNKNOWN;
#else
wcscpy(pPath, defaultDLLName[implType & 1]);
return MFX_ERR_NONE;
#endif
} // mfxStatus mfx_get_default_dll_name(wchar_t *pPath, size_t pathSize, eMfxImplType implType)
mfxStatus mfx_get_default_plugin_name(msdk_disp_char *pPath, size_t pathSize, eMfxImplType implType)
{
if (!pPath)
{
return MFX_ERR_NULL_PTR;
}
// there are only 2 implementation with default DLL names
#if _MSC_VER >= 1400
return 0 == wcscpy_s(pPath, pathSize, defaultPluginDLLName[implType & 1])
? MFX_ERR_NONE : MFX_ERR_UNKNOWN;
#else
wcscpy(pPath, defaultPluginDLLName[implType & 1]);
return MFX_ERR_NONE;
#endif
}
mfxStatus mfx_get_default_audio_dll_name(msdk_disp_char *pPath, size_t pathSize, eMfxImplType implType)
{
if (!pPath)
{
return MFX_ERR_NULL_PTR;
}
// there are only 2 implementation with default DLL names
#if _MSC_VER >= 1400
return 0 == wcscpy_s(pPath, pathSize, defaultAudioDLLName[implType & 1])
? MFX_ERR_NONE : MFX_ERR_UNKNOWN;
#else
wcscpy(pPath, defaultAudioDLLName[implType & 1]);
return MFX_ERR_NONE;
#endif
} // mfxStatus mfx_get_default_audio_dll_name(wchar_t *pPath, size_t pathSize, eMfxImplType implType)
mfxModuleHandle mfx_dll_load(const msdk_disp_char *pFileName)
{
mfxModuleHandle hModule = (mfxModuleHandle) 0;
// check error(s)
if (NULL == pFileName)
{
return NULL;
}
// set the silent error mode
DWORD prevErrorMode = 0;
#if (_WIN32_WINNT >= 0x0600) && !(__GNUC__)
SetThreadErrorMode(SEM_FAILCRITICALERRORS, &prevErrorMode);
#else
prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
#endif
// load the library's module
hModule = LoadLibraryExW(pFileName,NULL,0);
// set the previous error mode
#if (_WIN32_WINNT >= 0x0600) && !(__GNUC__)
SetThreadErrorMode(prevErrorMode, NULL);
#else
SetErrorMode(prevErrorMode);
#endif
return hModule;
} // mfxModuleHandle mfx_dll_load(const wchar_t *pFileName)
mfxFunctionPointer mfx_dll_get_addr(mfxModuleHandle handle, const char *pFunctionName)
{
if (NULL == handle)
{
return NULL;
}
return (mfxFunctionPointer) GetProcAddress((HMODULE) handle, pFunctionName);
} // mfxFunctionPointer mfx_dll_get_addr(mfxModuleHandle handle, const char *pFunctionName)
bool mfx_dll_free(mfxModuleHandle handle)
{
if (NULL == handle)
{
return true;
}
BOOL bRes = FreeLibrary((HMODULE)handle);
return !!bRes;
} // bool mfx_dll_free(mfxModuleHandle handle)
mfxModuleHandle mfx_get_dll_handle(const msdk_disp_char *pFileName)
{
mfxModuleHandle hModule = (mfxModuleHandle) 0;
// check error(s)
if (NULL == pFileName)
{
return NULL;
}
// set the silent error mode
DWORD prevErrorMode = 0;
#if (_WIN32_WINNT >= 0x0600) && !(__GNUC__)
SetThreadErrorMode(SEM_FAILCRITICALERRORS, &prevErrorMode);
#else
prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
#endif
// load the library's module
GetModuleHandleExW(0, pFileName, (HMODULE*) &hModule);
// set the previous error mode
#if (_WIN32_WINNT >= 0x0600) && !(__GNUC__)
SetThreadErrorMode(prevErrorMode, NULL);
#else
SetErrorMode(prevErrorMode);
#endif
return hModule;
}
} // namespace MFX
#endif // #if defined(_WIN32) || defined(_WIN64)

458
plugins/obs-qsv11/libmfx/src/mfx_load_plugin.cpp
View file

@ -1,458 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2013-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: mfx_load_plugin.h
\* ****************************************************************************** */
#include "mfx_load_plugin.h"
#include "mfx_load_dll.h"
#include "mfx_dispatcher_log.h"
#define TRACE_PLUGIN_ERROR(str, ...) DISPATCHER_LOG_ERROR((("[PLUGIN]: "str), __VA_ARGS__))
#define TRACE_PLUGIN_INFO(str, ...) DISPATCHER_LOG_INFO((("[PLUGIN]: "str), __VA_ARGS__))
#define CREATE_PLUGIN_FNC "CreatePlugin"
MFX::PluginModule::PluginModule()
: mHmodule()
, mCreatePluginPtr()
, mPath()
{
}
MFX::PluginModule::PluginModule(const PluginModule & that)
: mHmodule(mfx_dll_load(that.mPath))
, mCreatePluginPtr(that.mCreatePluginPtr)
{
msdk_disp_char_cpy_s(mPath, sizeof(mPath) / sizeof(*mPath), that.mPath);
}
MFX::PluginModule & MFX::PluginModule::operator = (const MFX::PluginModule & that)
{
if (this != &that)
{
Tidy();
mHmodule = mfx_dll_load(that.mPath);
mCreatePluginPtr = that.mCreatePluginPtr;
msdk_disp_char_cpy_s(mPath, sizeof(mPath) / sizeof(*mPath), that.mPath);
}
return *this;
}
MFX::PluginModule::PluginModule(const msdk_disp_char * path)
: mCreatePluginPtr()
{
mHmodule = mfx_dll_load(path);
if (NULL == mHmodule) {
TRACE_PLUGIN_ERROR("Cannot load module: %S\n", MSDK2WIDE(path));
return ;
}
TRACE_PLUGIN_INFO("Plugin loaded at: %S\n", MSDK2WIDE(path));
mCreatePluginPtr = (CreatePluginPtr_t)mfx_dll_get_addr(mHmodule, CREATE_PLUGIN_FNC);
if (NULL == mCreatePluginPtr) {
TRACE_PLUGIN_ERROR("Cannot get procedure address: %s\n", CREATE_PLUGIN_FNC);
return ;
}
msdk_disp_char_cpy_s(mPath, sizeof(mPath) / sizeof(*mPath), path);
}
bool MFX::PluginModule::Create( mfxPluginUID uid, mfxPlugin& plg)
{
bool result = false;
if (mCreatePluginPtr)
{
mfxStatus mfxResult = mCreatePluginPtr(uid, &plg);
result = (MFX_ERR_NONE == mfxResult);
if (!result) {
TRACE_PLUGIN_ERROR("\"%S::%s\" returned %d\n", MSDK2WIDE(mPath), CREATE_PLUGIN_FNC, mfxResult);
} else {
TRACE_PLUGIN_INFO("\"%S::%s\" SUCCEED\n", MSDK2WIDE(mPath), CREATE_PLUGIN_FNC);
}
}
return result;
}
void MFX::PluginModule::Tidy()
{
mfx_dll_free(mHmodule);
mCreatePluginPtr = NULL;
mHmodule = NULL;
}
MFX::PluginModule::~PluginModule(void)
{
Tidy();
}
bool MFX::MFXPluginFactory::RunVerification( const mfxPlugin & plg, const PluginDescriptionRecord &dsc, mfxPluginParam &pluginParams)
{
if (plg.PluginInit == 0)
{
TRACE_PLUGIN_ERROR("plg->PluginInit = 0\n", 0);
return false;
}
if (plg.PluginClose == 0)
{
TRACE_PLUGIN_ERROR("plg->PluginClose = 0\n", 0);
return false;
}
if (plg.GetPluginParam == 0)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam = 0\n", 0);
return false;
}
if (plg.Execute == 0)
{
TRACE_PLUGIN_ERROR("plg->Execute = 0\n", 0);
return false;
}
if (plg.FreeResources == 0)
{
TRACE_PLUGIN_ERROR("plg->FreeResources = 0\n", 0);
return false;
}
mfxStatus sts = plg.GetPluginParam(plg.pthis, &pluginParams);
if (sts != MFX_ERR_NONE)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam() returned %d\n", sts);
return false;
}
if (dsc.Default)
{
// for default plugins there is no description, dsc.APIVersion, dsc.PluginVersion and dsc.PluginUID were set by dispatcher
// dsc.PluginVersion == requested plugin version (parameter of MFXVideoUSER_Load); dsc.APIVersion == loaded library API
if (dsc.PluginVersion > pluginParams.PluginVersion)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam() returned PluginVersion=%d, but it is smaller than requested : %d\n", pluginParams.PluginVersion, dsc.PluginVersion);
return false;
}
}
else
{
if (!dsc.onlyVersionRegistered && pluginParams.CodecId != dsc.CodecId)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam() returned CodecId="MFXFOURCCTYPE()", but registration has CodecId="MFXFOURCCTYPE()"\n"
, MFXU32TOFOURCC(pluginParams.CodecId), MFXU32TOFOURCC(dsc.CodecId));
return false;
}
if (!dsc.onlyVersionRegistered && pluginParams.Type != dsc.Type)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam() returned Type=%d, but registration has Type=%d\n", pluginParams.Type, dsc.Type);
return false;
}
if (pluginParams.PluginUID != dsc.PluginUID)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam() returned UID="MFXGUIDTYPE()", but registration has UID="MFXGUIDTYPE()"\n"
, MFXGUIDTOHEX(&pluginParams.PluginUID), MFXGUIDTOHEX(&dsc.PluginUID));
return false;
}
if (pluginParams.PluginVersion != dsc.PluginVersion)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam() returned PluginVersion=%d, but registration has PlgVer=%d\n", pluginParams.PluginVersion, dsc.PluginVersion);
return false;
}
if (pluginParams.APIVersion.Version != dsc.APIVersion.Version)
{
TRACE_PLUGIN_ERROR("plg->GetPluginParam() returned APIVersion=%d.%d, but registration has APIVer=%d.%d\n"
, pluginParams.APIVersion.Major, pluginParams.APIVersion.Minor
, dsc.APIVersion.Major, dsc.APIVersion.Minor);
return false;
}
}
switch(pluginParams.Type)
{
case MFX_PLUGINTYPE_VIDEO_DECODE:
case MFX_PLUGINTYPE_VIDEO_ENCODE:
case MFX_PLUGINTYPE_VIDEO_VPP:
{
TRACE_PLUGIN_INFO("plugin type= %d\n", pluginParams.Type);
if (plg.Video == 0)
{
TRACE_PLUGIN_ERROR("plg->Video = 0\n", 0);
return false;
}
if (!VerifyCodecCommon(*plg.Video))
return false;
break;
}
}
switch(pluginParams.Type)
{
case MFX_PLUGINTYPE_VIDEO_DECODE:
return VerifyDecoder(*plg.Video);
case MFX_PLUGINTYPE_AUDIO_DECODE:
return VerifyAudioDecoder(*plg.Audio);
case MFX_PLUGINTYPE_VIDEO_ENCODE:
return VerifyEncoder(*plg.Video);
case MFX_PLUGINTYPE_AUDIO_ENCODE:
return VerifyAudioEncoder(*plg.Audio);
case MFX_PLUGINTYPE_VIDEO_VPP:
return VerifyVpp(*plg.Video);
case MFX_PLUGINTYPE_VIDEO_ENC:
return VerifyEnc(*plg.Video);
default:
{
TRACE_PLUGIN_ERROR("unsupported plugin type: %d\n", pluginParams.Type);
return false;
}
}
}
bool MFX::MFXPluginFactory::VerifyVpp( const mfxVideoCodecPlugin &vpp )
{
if (vpp.VPPFrameSubmit == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->VPPFrameSubmit = 0\n", 0);
return false;
}
return true;
}
bool MFX::MFXPluginFactory::VerifyEncoder( const mfxVideoCodecPlugin &encoder )
{
if (encoder.EncodeFrameSubmit == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->EncodeFrameSubmit = 0\n", 0);
return false;
}
return true;
}
bool MFX::MFXPluginFactory::VerifyAudioEncoder( const mfxAudioCodecPlugin &encoder )
{
if (encoder.EncodeFrameSubmit == 0)
{
TRACE_PLUGIN_ERROR("plg->Audio->EncodeFrameSubmit = 0\n", 0);
return false;
}
return true;
}
bool MFX::MFXPluginFactory::VerifyEnc( const mfxVideoCodecPlugin &videoEnc )
{
if (videoEnc.ENCFrameSubmit == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->EncodeFrameSubmit = 0\n", 0);
return false;
}
return true;
}
bool MFX::MFXPluginFactory::VerifyDecoder( const mfxVideoCodecPlugin &decoder )
{
if (decoder.DecodeHeader == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->DecodeHeader = 0\n", 0);
return false;
}
if (decoder.GetPayload == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->GetPayload = 0\n", 0);
return false;
}
if (decoder.DecodeFrameSubmit == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->DecodeFrameSubmit = 0\n", 0);
return false;
}
return true;
}
bool MFX::MFXPluginFactory::VerifyAudioDecoder( const mfxAudioCodecPlugin &decoder )
{
if (decoder.DecodeHeader == 0)
{
TRACE_PLUGIN_ERROR("plg->Audio->DecodeHeader = 0\n", 0);
return false;
}
// if (decoder.GetPayload == 0)
{
// TRACE_PLUGIN_ERROR("plg->Audio->GetPayload = 0\n", 0);
// return false;
}
if (decoder.DecodeFrameSubmit == 0)
{
TRACE_PLUGIN_ERROR("plg->Audio->DecodeFrameSubmit = 0\n", 0);
return false;
}
return true;
}
bool MFX::MFXPluginFactory::VerifyCodecCommon( const mfxVideoCodecPlugin & videoCodec )
{
if (videoCodec.Query == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->Query = 0\n", 0);
return false;
}
//todo: remove
if (videoCodec.Query == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->Query = 0\n", 0);
return false;
}
if (videoCodec.QueryIOSurf == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->QueryIOSurf = 0\n", 0);
return false;
}
if (videoCodec.Init == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->Init = 0\n", 0);
return false;
}
if (videoCodec.Reset == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->Reset = 0\n", 0);
return false;
}
if (videoCodec.Close == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->Close = 0\n", 0);
return false;
}
if (videoCodec.GetVideoParam == 0)
{
TRACE_PLUGIN_ERROR("plg->Video->GetVideoParam = 0\n", 0);
return false;
}
return true;
}
mfxStatus MFX::MFXPluginFactory::Create(const PluginDescriptionRecord & rec)
{
PluginModule plgModule(rec.sPath);
mfxPlugin plg = {};
mfxPluginParam plgParams;
if (!plgModule.Create(rec.PluginUID, plg))
{
return MFX_ERR_UNKNOWN;
}
if (!RunVerification(plg, rec, plgParams))
{
//will do not call plugin close since it is not safe to do that until structure is corrected
return MFX_ERR_UNKNOWN;
}
if (rec.Type == MFX_PLUGINTYPE_AUDIO_DECODE ||
rec.Type == MFX_PLUGINTYPE_AUDIO_ENCODE)
{
mfxStatus sts = MFXAudioUSER_Register(mSession, plgParams.Type, &plg);
if (MFX_ERR_NONE != sts)
{
TRACE_PLUGIN_ERROR(" MFXAudioUSER_Register returned %d\n", sts);
return sts;
}
}
else
{
mfxStatus sts = MFXVideoUSER_Register(mSession, plgParams.Type, &plg);
if (MFX_ERR_NONE != sts)
{
TRACE_PLUGIN_ERROR(" MFXVideoUSER_Register returned %d\n", sts);
return sts;
}
}
mPlugins.push_back(FactoryRecord(plgParams, plgModule, plg));
return MFX_ERR_NONE;
}
MFX::MFXPluginFactory::~MFXPluginFactory()
{
Close();
}
MFX::MFXPluginFactory::MFXPluginFactory( mfxSession session )
{
mSession = session;
}
bool MFX::MFXPluginFactory::Destroy( const mfxPluginUID & uidToDestroy)
{
for (MFXVector<FactoryRecord >::iterator i = mPlugins.begin(); i!= mPlugins.end(); i++)
{
if (i->plgParams.PluginUID == uidToDestroy)
{
DestroyPlugin(*i);
//dll unload should happen here
//todo: check that dll_free fail is traced
mPlugins.erase(i);
return true;
}
}
return false;
}
void MFX::MFXPluginFactory::Close()
{
for (MFXVector<FactoryRecord>::iterator i = mPlugins.begin(); i!= mPlugins.end(); i++)
{
DestroyPlugin(*i);
}
mPlugins.clear();
}
void MFX::MFXPluginFactory::DestroyPlugin( FactoryRecord & record)
{
mfxStatus sts;
if (record.plgParams.Type == MFX_PLUGINTYPE_AUDIO_DECODE ||
record.plgParams.Type == MFX_PLUGINTYPE_AUDIO_ENCODE)
{
sts = MFXAudioUSER_Unregister(mSession, record.plgParams.Type);
TRACE_PLUGIN_INFO(" MFXAudioUSER_Unregister for Type=%d, returned %d\n", record.plgParams.Type, sts);
}
else
{
sts = MFXVideoUSER_Unregister(mSession, record.plgParams.Type);
TRACE_PLUGIN_INFO(" MFXVideoUSER_Unregister for Type=%d, returned %d\n", record.plgParams.Type, sts);
}
}

500
plugins/obs-qsv11/libmfx/src/mfx_plugin_hive.cpp
View file

@ -1,500 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2013-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: mfx_plugin_hive.cpp
\* ****************************************************************************** */
#if defined(_WIN32) || defined(_WIN64)
#include "mfx_plugin_hive.h"
#include "mfx_library_iterator.h"
#include "mfx_dispatcher.h"
#include "mfx_dispatcher_log.h"
#include "mfx_load_dll.h"
#define TRACE_HIVE_ERROR(str, ...) DISPATCHER_LOG_ERROR((("[HIVE]: "str), __VA_ARGS__))
#define TRACE_HIVE_INFO(str, ...) DISPATCHER_LOG_INFO((("[HIVE]: "str), __VA_ARGS__))
#define TRACE_HIVE_WRN(str, ...) DISPATCHER_LOG_WRN((("[HIVE]: "str), __VA_ARGS__))
namespace
{
const wchar_t rootPluginPath[] = L"Software\\Intel\\MediaSDK\\Plugin";
const wchar_t rootDispatchPath[] = L"Software\\Intel\\MediaSDK\\Dispatch";
const wchar_t pluginSubkey[] = L"Plugin";
const wchar_t TypeKeyName[] = L"Type";
const wchar_t CodecIDKeyName[] = L"CodecID";
const wchar_t GUIDKeyName[] = L"GUID";
const wchar_t PathKeyName[] = L"Path";
const wchar_t DefaultKeyName[] = L"Default";
const wchar_t PlgVerKeyName[] = L"PluginVersion";
const wchar_t APIVerKeyName[] = L"APIVersion";
}
namespace
{
#ifdef _WIN64
const wchar_t pluginFileName[] = L"FileName64";
#else
const wchar_t pluginFileName[] = L"FileName32";
#endif // _WIN64
//do not allow store plugin in different hierarchy
const wchar_t pluginFileNameRestrictedCharacters[] = L"\\/";
const wchar_t pluginCfgFileName[] = L"plugin.cfg";
const wchar_t pluginSearchPattern[] = L"????????????????????????????????";
const mfxU32 pluginCfgFileNameLen = 10;
const mfxU32 pluginDirNameLen = 32;
const mfxU32 defaultPluginNameLen = 25;
const mfxU32 charsPermfxU8 = 2;
const mfxU32 slashLen = 1;
enum
{
MAX_PLUGIN_FILE_LINE = 4096
};
#define alignStr() "%-14S"
}
MFX::MFXPluginsInHive::MFXPluginsInHive(int mfxStorageID, const msdk_disp_char *msdkLibSubKey, mfxVersion currentAPIVersion)
: MFXPluginStorageBase(currentAPIVersion)
{
HKEY rootHKey;
bool bRes;
WinRegKey regKey;
if (MFX_LOCAL_MACHINE_KEY != mfxStorageID && MFX_CURRENT_USER_KEY != mfxStorageID)
return;
// open required registry key
rootHKey = (MFX_LOCAL_MACHINE_KEY == mfxStorageID) ? (HKEY_LOCAL_MACHINE) : (HKEY_CURRENT_USER);
if (msdkLibSubKey) {
//dispatch/subkey/plugin
bRes = regKey.Open(rootHKey, rootDispatchPath, KEY_READ);
if (bRes)
{
bRes = regKey.Open(regKey, msdkLibSubKey, KEY_READ);
}
if (bRes)
{
bRes = regKey.Open(regKey, pluginSubkey, KEY_READ);
}
}
else
{
bRes = regKey.Open(rootHKey, rootPluginPath, KEY_READ);
}
if (false == bRes) {
return;
}
DWORD index = 0;
if (!regKey.QueryInfo(&index)) {
return;
}
try
{
resize(index);
}
catch (...) {
TRACE_HIVE_ERROR("new PluginDescriptionRecord[%d] threw an exception: \n", index);
return;
}
for(index = 0; ; index++)
{
wchar_t subKeyName[MFX_MAX_REGISTRY_KEY_NAME];
DWORD subKeyNameSize = sizeof(subKeyName) / sizeof(subKeyName[0]);
WinRegKey subKey;
// query next value name
bool enumRes = regKey.EnumKey(index, subKeyName, &subKeyNameSize);
if (!enumRes) {
break;
}
// open the sub key
bRes = subKey.Open(regKey, subKeyName, KEY_READ);
if (!bRes) {
continue;
}
if (msdkLibSubKey)
{
TRACE_HIVE_INFO("Found Plugin: %s\\%S\\%S\\%S\\%S\n", (MFX_LOCAL_MACHINE_KEY == mfxStorageID) ? ("HKEY_LOCAL_MACHINE") : ("HKEY_CURRENT_USER"),
rootDispatchPath, msdkLibSubKey, pluginSubkey, subKeyName);
}
else
{
TRACE_HIVE_INFO("Found Plugin: %s\\%S\\%S\n", (MFX_LOCAL_MACHINE_KEY == mfxStorageID) ? ("HKEY_LOCAL_MACHINE") : ("HKEY_CURRENT_USER"),
rootPluginPath, subKeyName);
}
PluginDescriptionRecord descriptionRecord;
if (!QueryKey(subKey, TypeKeyName, descriptionRecord.Type))
{
continue;
}
TRACE_HIVE_INFO(alignStr()" : %d\n", TypeKeyName, descriptionRecord.Type);
if (QueryKey(subKey, CodecIDKeyName, descriptionRecord.CodecId))
{
TRACE_HIVE_INFO(alignStr()" : "MFXFOURCCTYPE()" \n", CodecIDKeyName, MFXU32TOFOURCC(descriptionRecord.CodecId));
}
else
{
TRACE_HIVE_INFO(alignStr()" : \n", CodecIDKeyName, "NOT REGISTERED");
}
if (!QueryKey(subKey, GUIDKeyName, descriptionRecord.PluginUID))
{
continue;
}
TRACE_HIVE_INFO(alignStr()" : "MFXGUIDTYPE()"\n", GUIDKeyName, MFXGUIDTOHEX(&descriptionRecord.PluginUID));
mfxU32 nSize = sizeof(descriptionRecord.sPath)/sizeof(*descriptionRecord.sPath);
if (!subKey.Query(PathKeyName, descriptionRecord.sPath, nSize))
{
TRACE_HIVE_WRN("no value for : %S\n", PathKeyName);
continue;
}
TRACE_HIVE_INFO(alignStr()" : %S\n", PathKeyName, descriptionRecord.sPath);
if (!QueryKey(subKey, DefaultKeyName, descriptionRecord.Default))
{
continue;
}
TRACE_HIVE_INFO(alignStr()" : %s\n", DefaultKeyName, descriptionRecord.Default ? "true" : "false");
mfxU32 version;
if (!QueryKey(subKey, PlgVerKeyName, version))
{
continue;
}
descriptionRecord.PluginVersion = static_cast<mfxU16>(version);
if (0 == version)
{
TRACE_HIVE_ERROR(alignStr()" : %d, which is invalid\n", PlgVerKeyName, descriptionRecord.PluginVersion);
continue;
}
else
{
TRACE_HIVE_INFO(alignStr()" : %d\n", PlgVerKeyName, descriptionRecord.PluginVersion);
}
mfxU32 APIVersion;
if (!QueryKey(subKey, APIVerKeyName, APIVersion))
{
continue;
}
ConvertAPIVersion(APIVersion, descriptionRecord);
TRACE_HIVE_INFO(alignStr()" : %d.%d \n", APIVerKeyName, descriptionRecord.APIVersion.Major, descriptionRecord.APIVersion.Minor);
try
{
operator[](index) = descriptionRecord;
}
catch (...) {
TRACE_HIVE_ERROR("operator[](%d) = descriptionRecord; - threw exception \n", index);
}
}
}
MFX::MFXPluginsInFS::MFXPluginsInFS( mfxVersion currentAPIVersion )
: MFXPluginStorageBase(currentAPIVersion)
, mIsVersionParsed()
, mIsAPIVersionParsed()
{
WIN32_FIND_DATAW find_data;
msdk_disp_char currentModuleName[MAX_PLUGIN_PATH];
GetModuleFileNameW(NULL, currentModuleName, MAX_PLUGIN_PATH);
if (GetLastError() != 0)
{
TRACE_HIVE_ERROR("GetModuleFileName() reported an error: %d\n", GetLastError());
return;
}
msdk_disp_char *lastSlashPos = wcsrchr(currentModuleName, L'\\');
if (!lastSlashPos) {
lastSlashPos = currentModuleName;
}
mfxU32 executableDirLen = (mfxU32)(lastSlashPos - currentModuleName) + slashLen;
if (executableDirLen + pluginDirNameLen + pluginCfgFileNameLen >= MAX_PLUGIN_PATH)
{
TRACE_HIVE_ERROR("MAX_PLUGIN_PATH which is %d, not enough to locate plugin path\n", MAX_PLUGIN_PATH);
return;
}
msdk_disp_char_cpy_s(lastSlashPos + slashLen
, MAX_PLUGIN_PATH - executableDirLen, pluginSearchPattern);
HANDLE fileFirst = FindFirstFileW(currentModuleName, &find_data);
if (INVALID_HANDLE_VALUE == fileFirst)
{
TRACE_HIVE_ERROR("FindFirstFileW() unable to locate any plugins folders\n", 0);
return;
}
do
{
if (!(find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
continue;
}
if (pluginDirNameLen != wcslen(find_data.cFileName))
{
continue;
}
//converting dirname into guid
PluginDescriptionRecord descriptionRecord;
descriptionRecord.APIVersion = currentAPIVersion;
descriptionRecord.onlyVersionRegistered = true;
mfxU32 i = 0;
for(i = 0; i != pluginDirNameLen / charsPermfxU8; i++)
{
mfxU32 hexNum = 0;
if (1 != swscanf_s(find_data.cFileName + charsPermfxU8 * i, L"%2x", &hexNum))
{
// it is ok to have non-plugin subdirs with length 32
//TRACE_HIVE_INFO("folder name \"%S\" is not a valid GUID string\n", find_data.cFileName);
break;
}
if (hexNum == 0 && find_data.cFileName + charsPermfxU8 * i != wcsstr(find_data.cFileName + 2*i, L"00"))
{
// it is ok to have non-plugin subdirs with length 32
//TRACE_HIVE_INFO("folder name \"%S\" is not a valid GUID string\n", find_data.cFileName);
break;
}
descriptionRecord.PluginUID.Data[i] = (mfxU8)hexNum;
}
if (i != pluginDirNameLen / charsPermfxU8) {
continue;
}
msdk_disp_char_cpy_s(currentModuleName + executableDirLen
, MAX_PLUGIN_PATH - executableDirLen, find_data.cFileName);
msdk_disp_char_cpy_s(currentModuleName + executableDirLen + pluginDirNameLen
, MAX_PLUGIN_PATH - executableDirLen - pluginDirNameLen, L"\\");
//this is path to plugin directory
msdk_disp_char_cpy_s(descriptionRecord.sPath
, sizeof(descriptionRecord.sPath) / sizeof(*descriptionRecord.sPath), currentModuleName);
msdk_disp_char_cpy_s(currentModuleName + executableDirLen + pluginDirNameLen + slashLen
, MAX_PLUGIN_PATH - executableDirLen - pluginDirNameLen - slashLen, pluginCfgFileName);
FILE *pluginCfgFile = 0;
_wfopen_s(&pluginCfgFile, currentModuleName, L"r");
if (!pluginCfgFile)
{
TRACE_HIVE_INFO("in directory \"%S\" no mandatory \"%S\"\n"
, find_data.cFileName, pluginCfgFileName);
continue;
}
if (ParseFile(pluginCfgFile, descriptionRecord))
{
try
{
push_back(descriptionRecord);
}
catch (...) {
TRACE_HIVE_ERROR("mRecords.push_back(descriptionRecord); - threw exception \n", 0);
}
}
fclose(pluginCfgFile);
}while (FindNextFileW(fileFirst, &find_data));
FindClose(fileFirst);
}
bool MFX::MFXPluginsInFS::ParseFile(FILE * f, PluginDescriptionRecord & descriptionRecord)
{
msdk_disp_char line[MAX_PLUGIN_FILE_LINE];
while(NULL != fgetws(line, sizeof(line) / sizeof(*line), f))
{
msdk_disp_char *delimiter = wcschr(line, L'=');
if (0 == delimiter)
{
TRACE_HIVE_INFO("plugin.cfg contains line \"%S\" which is not in K=V format, skipping \n", line);
continue;
}
*delimiter = 0;
if (!ParseKVPair(line, delimiter + 1, descriptionRecord))
{
return false;
}
}
if (!mIsVersionParsed)
{
TRACE_HIVE_ERROR("%S : Mandatory key %S not found\n", pluginCfgFileName, PlgVerKeyName);
return false;
}
if (!mIsAPIVersionParsed)
{
TRACE_HIVE_ERROR("%S : Mandatory key %S not found\n", pluginCfgFileName, APIVerKeyName);
return false;
}
if (!wcslen(descriptionRecord.sPath))
{
TRACE_HIVE_ERROR("%S : Mandatory key %S not found\n", pluginCfgFileName, pluginFileName);
return false;
}
return true;
}
bool MFX::MFXPluginsInFS::ParseKVPair( msdk_disp_char * key, msdk_disp_char* value, PluginDescriptionRecord & descriptionRecord)
{
if (0 != wcsstr(key, PlgVerKeyName))
{
mfxU32 version ;
if (0 == swscanf_s(value, L"%d", &version))
{
return false;
}
descriptionRecord.PluginVersion = (mfxU16)version;
if (0 == descriptionRecord.PluginVersion)
{
TRACE_HIVE_ERROR("%S: %S = %d, which is invalid\n", pluginCfgFileName, PlgVerKeyName, descriptionRecord.PluginVersion);
return false;
}
TRACE_HIVE_INFO("%S: %S = %d \n", pluginCfgFileName, PlgVerKeyName, descriptionRecord.PluginVersion);
mIsVersionParsed = true;
return true;
}
if (0 != wcsstr(key, APIVerKeyName))
{
mfxU32 APIversion;
if (0 == swscanf_s(value, L"%d", &APIversion))
{
return false;
}
ConvertAPIVersion(APIversion, descriptionRecord);
TRACE_HIVE_INFO("%S: %S = %d.%d \n", pluginCfgFileName, APIVerKeyName, descriptionRecord.APIVersion.Major, descriptionRecord.APIVersion.Minor);
mIsAPIVersionParsed = true;
return true;
}
if (0!=wcsstr(key, pluginFileName))
{
msdk_disp_char *startQuoteMark = wcschr(value, L'\"');
if (!startQuoteMark)
{
TRACE_HIVE_ERROR("plugin filename not in quotes : %S\n", value);
return false;
}
msdk_disp_char *endQuoteMark = wcschr(startQuoteMark + 1, L'\"');
if (!endQuoteMark)
{
TRACE_HIVE_ERROR("plugin filename not in quotes : %S\n", value);
return false;
}
*endQuoteMark = 0;
mfxU32 currentPathLen = (mfxU32)wcslen(descriptionRecord.sPath);
if (currentPathLen + wcslen(startQuoteMark + 1) > sizeof(descriptionRecord.sPath) / sizeof(*descriptionRecord.sPath))
{
TRACE_HIVE_ERROR("buffer of MAX_PLUGIN_PATH characters which is %d, not enough lo store plugin path: %S%S\n"
, MAX_PLUGIN_PATH, descriptionRecord.sPath, startQuoteMark + 1);
return false;
}
size_t restrictedCharIdx = wcscspn(startQuoteMark + 1, pluginFileNameRestrictedCharacters);
if (restrictedCharIdx != wcslen(startQuoteMark + 1))
{
TRACE_HIVE_ERROR("plugin filename :%S, contains one of restricted characters: %S\n", startQuoteMark + 1, pluginFileNameRestrictedCharacters);
return false;
}
msdk_disp_char_cpy_s(descriptionRecord.sPath + currentPathLen
, sizeof(descriptionRecord.sPath) / sizeof(*descriptionRecord.sPath) - currentPathLen, startQuoteMark + 1);
TRACE_HIVE_INFO("%S: %S = \"%S\" \n", pluginCfgFileName, pluginFileName, startQuoteMark + 1);
return true;
}
return true;
}
MFX::MFXDefaultPlugins::MFXDefaultPlugins(mfxVersion currentAPIVersion, MFX_DISP_HANDLE * hdl, int implType)
: MFXPluginStorageBase(currentAPIVersion)
{
msdk_disp_char libModuleName[MAX_PLUGIN_PATH];
GetModuleFileNameW((HMODULE)hdl->hModule, libModuleName, MAX_PLUGIN_PATH);
if (GetLastError() != 0)
{
TRACE_HIVE_ERROR("GetModuleFileName() reported an error: %d\n", GetLastError());
return;
}
msdk_disp_char *lastSlashPos = wcsrchr(libModuleName, L'\\');
if (!lastSlashPos) {
lastSlashPos = libModuleName;
}
mfxU32 executableDirLen = (mfxU32)(lastSlashPos - libModuleName) + slashLen;
if (executableDirLen + defaultPluginNameLen >= MAX_PLUGIN_PATH)
{
TRACE_HIVE_ERROR("MAX_PLUGIN_PATH which is %d, not enough to locate default plugin path\n", MAX_PLUGIN_PATH);
return;
}
mfx_get_default_plugin_name(lastSlashPos + slashLen, MAX_PLUGIN_PATH - executableDirLen, (eMfxImplType)implType);
if (-1 != GetFileAttributesW(libModuleName))
{
// add single default plugin description
PluginDescriptionRecord descriptionRecord;
descriptionRecord.APIVersion = currentAPIVersion;
descriptionRecord.Default = true;
msdk_disp_char_cpy_s(descriptionRecord.sPath
, sizeof(descriptionRecord.sPath) / sizeof(*descriptionRecord.sPath), libModuleName);
push_back(descriptionRecord);
}
else
{
TRACE_HIVE_INFO("GetFileAttributesW() unable to locate default plugin dll named %S\n", libModuleName);
}
}
#endif

228
plugins/obs-qsv11/libmfx/src/mfx_win_reg_key.cpp
View file

@ -1,228 +0,0 @@
/* ****************************************************************************** *\
Copyright (C) 2012-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: mfx_win_reg_key.cpp
\* ****************************************************************************** */
#if defined(_WIN32) || defined(_WIN64)
#include "mfx_win_reg_key.h"
#include "mfx_dispatcher_log.h"
#define TRACE_WINREG_ERROR(str, ...) DISPATCHER_LOG_ERROR((("[WINREG]: "str), __VA_ARGS__))
namespace MFX
{
WinRegKey::WinRegKey(void)
{
m_hKey = (HKEY) 0;
} // WinRegKey::WinRegKey(void)
WinRegKey::~WinRegKey(void)
{
Release();
} // WinRegKey::~WinRegKey(void)
void WinRegKey::Release(void)
{
// close the opened key
if (m_hKey)
{
RegCloseKey(m_hKey);
}
m_hKey = (HKEY) 0;
} // void WinRegKey::Release(void)
bool WinRegKey::Open(HKEY hRootKey, const wchar_t *pSubKey, REGSAM samDesired)
{
LONG lRes;
HKEY hTemp;
//
// All operation are performed in this order by intention.
// It makes possible to reopen the keys, using itself as a base.
//
// try to the open registry key
lRes = RegOpenKeyExW(hRootKey, pSubKey, 0, samDesired, &hTemp);
if (ERROR_SUCCESS != lRes)
{
DISPATCHER_LOG_OPERATION(SetLastError(lRes));
TRACE_WINREG_ERROR("Opening key \"%s\\%S\" : RegOpenKeyExW()==0x%x\n"
, (HKEY_LOCAL_MACHINE == hRootKey) ? ("HKEY_LOCAL_MACHINE")
: (HKEY_CURRENT_USER == hRootKey) ? ("HKEY_CURRENT_USER")
: "UNSUPPORTED_KEY", pSubKey, GetLastError());
return false;
}
// release the object before initialization
Release();
// save the handle
m_hKey = hTemp;
return true;
} // bool WinRegKey::Open(HKEY hRootKey, const wchar_t *pSubKey, REGSAM samDesired)
bool WinRegKey::Open(WinRegKey &rootKey, const wchar_t *pSubKey, REGSAM samDesired)
{
return Open(rootKey.m_hKey, pSubKey, samDesired);
} // bool WinRegKey::Open(WinRegKey &rootKey, const wchar_t *pSubKey, REGSAM samDesired)
bool WinRegKey::QueryValueSize(const wchar_t *pValueName, DWORD type, LPDWORD pcbData) {
DWORD keyType = type;
LONG lRes;
// query the value
lRes = RegQueryValueExW(m_hKey, pValueName, NULL, &keyType, 0, pcbData);
if (ERROR_SUCCESS != lRes)
{
DISPATCHER_LOG_OPERATION(SetLastError(lRes));
TRACE_WINREG_ERROR("Querying \"%S\" : RegQueryValueExA()==0x%x\n", pValueName, GetLastError());
return false;
}
return true;
}
bool WinRegKey::Query(const wchar_t *pValueName, DWORD type, LPBYTE pData, LPDWORD pcbData)
{
DWORD keyType = type;
LONG lRes;
DWORD dstSize = (pcbData) ? (*pcbData) : (0);
// query the value
lRes = RegQueryValueExW(m_hKey, pValueName, NULL, &keyType, pData, pcbData);
if (ERROR_SUCCESS != lRes)
{
DISPATCHER_LOG_OPERATION(SetLastError(lRes));
TRACE_WINREG_ERROR("Querying \"%S\" : RegQueryValueExA()==0x%x\n", pValueName, GetLastError());
return false;
}
// check the type
if (keyType != type)
{
TRACE_WINREG_ERROR("Querying \"%S\" : expectedType=%d, returned=%d\n", pValueName, type, keyType);
return false;
}
// terminate the string only if pointers not NULL
if ((REG_SZ == type || REG_EXPAND_SZ == type) && NULL != pData && NULL != pcbData)
{
wchar_t *pString = (wchar_t *) pData;
size_t NullEndingSizeBytes = sizeof(wchar_t); // size of string termination null character
if (dstSize < NullEndingSizeBytes)
{
TRACE_WINREG_ERROR("Querying \"%S\" : buffer is too small for null-terminated string", pValueName);
return false;
}
size_t maxStringLengthBytes = dstSize - NullEndingSizeBytes;
size_t maxStringIndex = dstSize / sizeof(wchar_t) - 1;
size_t lastIndex = (maxStringLengthBytes < *pcbData) ? (maxStringIndex) : (*pcbData) / sizeof(wchar_t);
pString[lastIndex] = (wchar_t) 0;
}
else if(REG_MULTI_SZ == type && NULL != pData && NULL != pcbData)
{
wchar_t *pString = (wchar_t *) pData;
size_t NullEndingSizeBytes = sizeof(wchar_t)*2; // size of string termination null characters
if (dstSize < NullEndingSizeBytes)
{
TRACE_WINREG_ERROR("Querying \"%S\" : buffer is too small for multi-line null-terminated string", pValueName);
return false;
}
size_t maxStringLengthBytes = dstSize - NullEndingSizeBytes;
size_t maxStringIndex = dstSize / sizeof(wchar_t) - 1;
size_t lastIndex = (maxStringLengthBytes < *pcbData) ? (maxStringIndex) : (*pcbData) / sizeof(wchar_t) + 1;
// last 2 bytes should be 0 in case of REG_MULTI_SZ
pString[lastIndex] = pString[lastIndex - 1] = (wchar_t) 0;
}
return true;
} // bool WinRegKey::Query(const wchar_t *pValueName, DWORD type, LPBYTE pData, LPDWORD pcbData)
bool WinRegKey::EnumValue(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName, LPDWORD pType)
{
LONG lRes;
// enum the values
lRes = RegEnumValueW(m_hKey, index, pValueName, pcchValueName, 0, pType, NULL, NULL);
if (ERROR_SUCCESS != lRes)
{
DISPATCHER_LOG_OPERATION(SetLastError(lRes));
return false;
}
return true;
} // bool WinRegKey::EnumValue(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName, LPDWORD pType)
bool WinRegKey::EnumKey(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName)
{
LONG lRes;
// enum the keys
lRes = RegEnumKeyExW(m_hKey, index, pValueName, pcchValueName, NULL, NULL, NULL, NULL);
if (ERROR_SUCCESS != lRes)
{
DISPATCHER_LOG_OPERATION(SetLastError(lRes));
TRACE_WINREG_ERROR("EnumKey with index=%d: RegEnumKeyExW()==0x%x\n", index, GetLastError());
return false;
}
return true;
} // bool WinRegKey::EnumKey(DWORD index, wchar_t *pValueName, LPDWORD pcchValueName)
bool WinRegKey::QueryInfo(LPDWORD lpcSubkeys)
{
LONG lRes;
lRes = RegQueryInfoKeyW(m_hKey, NULL, 0, 0, lpcSubkeys, 0, 0, 0, 0, 0, 0, 0);
if (ERROR_SUCCESS != lRes) {
TRACE_WINREG_ERROR("RegQueryInfoKeyW()==0x%x\n", lRes);
return false;
}
return true;
} //bool QueryInfo(LPDWORD lpcSubkeys);
} // namespace MFX
#endif // #if defined(_WIN32) || defined(_WIN64)

86
plugins/obs-qsv11/obs-qsv11-plugin-main.c
View file

@ -1,86 +0,0 @@
/*
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright(c) Oct. 2015 Intel Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program 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
General Public License for more details.
Contact Information:
Seung-Woo Kim, seung-woo.kim@intel.com
705 5th Ave S #500, Seattle, WA 98104
BSD LICENSE
Copyright(c) <date> Intel Corporation.
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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"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 THE COPYRIGHT
OWNER OR CONTRIBUTORS 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.
*/
#include <obs-module.h>
#include "mfxsession.h"
OBS_DECLARE_MODULE()
OBS_MODULE_USE_DEFAULT_LOCALE("obs-qsv11", "en-US")
extern struct obs_encoder_info obs_qsv_encoder;
bool obs_module_load(void)
{
mfxIMPL impl = MFX_IMPL_HARDWARE_ANY | MFX_IMPL_VIA_D3D11;
mfxVersion ver = {{0 , 1}};
mfxSession session;
mfxStatus sts;
sts = MFXInit(impl, &ver, &session);
if (sts == MFX_ERR_NONE) {
obs_register_encoder(&obs_qsv_encoder);
MFXClose(session);
} else {
impl = MFX_IMPL_HARDWARE_ANY | MFX_IMPL_VIA_D3D9;
sts = MFXInit(impl, &ver, &session);
if (sts == MFX_ERR_NONE) {
obs_register_encoder(&obs_qsv_encoder);
MFXClose(session);
}
}
return true;
}

694
plugins/obs-qsv11/obs-qsv11.c
View file

@ -1,694 +0,0 @@
/*
This file is provided under a dual BSD/GPLv2 license. When using or
redistributing this file, you may do so under either license.
GPL LICENSE SUMMARY
Copyright(c) Oct. 2015 Intel Corporation.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program 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
General Public License for more details.
Contact Information:
Seung-Woo Kim, seung-woo.kim@intel.com
705 5th Ave S #500, Seattle, WA 98104
BSD LICENSE
Copyright(c) <date> Intel Corporation.
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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"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 THE COPYRIGHT
OWNER OR CONTRIBUTORS 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.
*/
#include <stdio.h>
#include <util/dstr.h>
#include <util/darray.h>
#include <util/platform.h>
#include <obs-module.h>
#ifndef _STDINT_H_INCLUDED
#define _STDINT_H_INCLUDED
#endif
#include "QSV_Encoder.h"
#include <Windows.h>
#define do_log(level, format, ...) \
blog(level, "[qsv encoder: '%s'] " format, \
obs_encoder_get_name(obsqsv->encoder), ##__VA_ARGS__)
#define warn(format, ...) do_log(LOG_WARNING, format, ##__VA_ARGS__)
#define info(format, ...) do_log(LOG_INFO, format, ##__VA_ARGS__)
#define debug(format, ...) do_log(LOG_DEBUG, format, ##__VA_ARGS__)
/* ------------------------------------------------------------------------- */
struct obs_qsv {
obs_encoder_t *encoder;
qsv_param_t params;
qsv_t *context;
DARRAY(uint8_t) packet_data;
uint8_t *extra_data;
uint8_t *sei;
size_t extra_data_size;
size_t sei_size;
os_performance_token_t *performance_token;
};
/* ------------------------------------------------------------------------- */
static CRITICAL_SECTION g_QsvCs;
static unsigned short g_verMajor;
static unsigned short g_verMinor;
static int64_t g_pts2dtsShift;
static int64_t g_prevDts;
static bool g_bFirst;
static const char *obs_qsv_getname(void *type_data)
{
UNUSED_PARAMETER(type_data);
return "QuickSync H.264";
}
static void obs_qsv_stop(void *data);
static void clear_data(struct obs_qsv *obsqsv)
{
if (obsqsv->context) {
qsv_encoder_close(obsqsv->context);
// bfree(obsqsv->sei);
bfree(obsqsv->extra_data);
obsqsv->context = NULL;
// obsqsv->sei = NULL;
obsqsv->extra_data = NULL;
}
}
static void obs_qsv_destroy(void *data)
{
struct obs_qsv *obsqsv = (struct obs_qsv *)data;
if (obsqsv) {
os_end_high_performance(obsqsv->performance_token);
clear_data(obsqsv);
da_free(obsqsv->packet_data);
bfree(obsqsv);
}
}
static void obs_qsv_defaults(obs_data_t *settings)
{
obs_data_set_default_string(settings, "target_usage", "balanced");
obs_data_set_default_int(settings, "bitrate", 2500);
obs_data_set_default_int(settings, "max_bitrate", 3000);
obs_data_set_default_string(settings, "profile", "main");
obs_data_set_default_int(settings, "async_depth", 4);
obs_data_set_default_string(settings, "rate_control", "CBR");
obs_data_set_default_int(settings, "accuracy", 1000);
obs_data_set_default_int(settings, "convergence", 1);
obs_data_set_default_int(settings, "qpi", 23);
obs_data_set_default_int(settings, "qpp", 23);
obs_data_set_default_int(settings, "qpb", 23);
obs_data_set_default_int(settings, "icq_quality", 23);
obs_data_set_default_int(settings, "la_depth", 40);
obs_data_set_default_int(settings, "keyint_sec", 3);
}
static inline void add_strings(obs_property_t *list, const char *const *strings)
{
while (*strings) {
obs_property_list_add_string(list, *strings, *strings);
strings++;
}
}
#define TEXT_SPEED obs_module_text("TargetUsage")
#define TEXT_TARGET_BITRATE obs_module_text("Bitrate")
#define TEXT_MAX_BITRATE obs_module_text("MaxBitrate")
#define TEXT_PROFILE obs_module_text("Profile")
#define TEXT_ASYNC_DEPTH obs_module_text("AsyncDepth")
#define TEXT_RATE_CONTROL obs_module_text("RateControl")
#define TEXT_ACCURACY obs_module_text("Accuracy")
#define TEXT_CONVERGENCE obs_module_text("Convergence")
#define TEXT_ICQ_QUALITY obs_module_text("ICQQuality")
#define TEXT_LA_DEPTH obs_module_text("LookAheadDepth")
#define TEXT_KEYINT_SEC obs_module_text("KeyframeIntervalSec")
static bool rate_control_modified(obs_properties_t *ppts, obs_property_t *p,
obs_data_t *settings)
{
const char *rate_control = obs_data_get_string(settings, "rate_control");
bool bVisible =
astrcmpi(rate_control, "VCM") == 0 ||
astrcmpi(rate_control, "VBR") == 0;
p = obs_properties_get(ppts, "max_bitrate");
obs_property_set_visible(p, bVisible);
bVisible =
astrcmpi(rate_control, "CQP") == 0 ||
astrcmpi(rate_control, "LA_ICQ") == 0 ||
astrcmpi(rate_control, "ICQ") == 0;
p = obs_properties_get(ppts, "bitrate");
obs_property_set_visible(p, !bVisible);
bVisible = astrcmpi(rate_control, "AVBR") == 0;
p = obs_properties_get(ppts, "accuracy");
obs_property_set_visible(p, bVisible);
p = obs_properties_get(ppts, "convergence");
obs_property_set_visible(p, bVisible);
bVisible = astrcmpi(rate_control, "CQP") == 0;
p = obs_properties_get(ppts, "qpi");
obs_property_set_visible(p, bVisible);
p = obs_properties_get(ppts, "qpb");
obs_property_set_visible(p, bVisible);
p = obs_properties_get(ppts, "qpp");
obs_property_set_visible(p, bVisible);
bVisible = astrcmpi(rate_control, "ICQ") == 0 ||
astrcmpi(rate_control, "LA_ICQ") == 0;
p = obs_properties_get(ppts, "icq_quality");
obs_property_set_visible(p, bVisible);
bVisible = astrcmpi(rate_control, "LA_ICQ") == 0 ||
astrcmpi(rate_control, "LA") == 0;
p = obs_properties_get(ppts, "la_depth");
obs_property_set_visible(p, bVisible);
return true;
}
static inline void add_rate_controls(obs_property_t *list,
const struct qsv_rate_control_info *rc)
{
enum qsv_cpu_platform plat = qsv_get_cpu_platform();
while (rc->name) {
if (!rc->haswell_or_greater || plat >= QSV_CPU_PLATFORM_HSW)
obs_property_list_add_string(list, rc->name, rc->name);
rc++;
}
}
static obs_properties_t *obs_qsv_props(void *unused)
{
UNUSED_PARAMETER(unused);
obs_properties_t *props = obs_properties_create();
obs_property_t *list;
list = obs_properties_add_list(props, "target_usage", TEXT_SPEED,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
add_strings(list, qsv_usage_names);
list = obs_properties_add_list(props, "profile", TEXT_PROFILE,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
add_strings(list, qsv_profile_names);
obs_properties_add_int(props, "keyint_sec", TEXT_KEYINT_SEC, 1, 20, 1);
obs_properties_add_int(props, "async_depth", TEXT_ASYNC_DEPTH, 1, 7, 1);
list = obs_properties_add_list(props, "rate_control", TEXT_RATE_CONTROL,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
add_rate_controls(list, qsv_ratecontrols);
obs_property_set_modified_callback(list, rate_control_modified);
obs_properties_add_int(props, "bitrate", TEXT_TARGET_BITRATE, 50,
10000000, 1);
obs_properties_add_int(props, "max_bitrate", TEXT_MAX_BITRATE, 50,
10000000, 1);
obs_properties_add_int(props, "accuracy", TEXT_ACCURACY, 0, 10000, 1);
obs_properties_add_int(props, "convergence", TEXT_CONVERGENCE, 0, 10, 1);
obs_properties_add_int(props, "qpi", "QPI", 1, 51, 1);
obs_properties_add_int(props, "qpp", "QPP", 1, 51, 1);
obs_properties_add_int(props, "qpb", "QPB", 1, 51, 1);
obs_properties_add_int(props, "icq_quality", TEXT_ICQ_QUALITY, 1, 51, 1);
obs_properties_add_int(props, "la_depth", TEXT_LA_DEPTH, 10, 100, 1);
return props;
}
static void update_params(struct obs_qsv *obsqsv, obs_data_t *settings)
{
video_t *video = obs_encoder_video(obsqsv->encoder);
const struct video_output_info *voi = video_output_get_info(video);
const char *target_usage = obs_data_get_string(settings, "target_usage");
const char *profile = obs_data_get_string(settings, "profile");
const char *rate_control = obs_data_get_string(settings, "rate_control");
int async_depth = (int)obs_data_get_int(settings, "async_depth");
int target_bitrate = (int)obs_data_get_int(settings, "bitrate");
int max_bitrate = (int)obs_data_get_int(settings, "max_bitrate");
int accuracy = (int)obs_data_get_int(settings, "accuracy");
int convergence = (int)obs_data_get_int(settings, "convergence");
int qpi = (int)obs_data_get_int(settings, "qpi");
int qpp = (int)obs_data_get_int(settings, "qpp");
int qpb = (int)obs_data_get_int(settings, "qpb");
int icq_quality = (int)obs_data_get_int(settings, "icq_quality");
int la_depth = (int)obs_data_get_int(settings, "la_depth");
int keyint_sec = (int)obs_data_get_int(settings, "keyint_sec");
bool cbr_override = obs_data_get_bool(settings, "cbr");
int bFrames = 7;
int width = (int)obs_encoder_get_width(obsqsv->encoder);
int height = (int)obs_encoder_get_height(obsqsv->encoder);
if (astrcmpi(target_usage, "quality") == 0)
obsqsv->params.nTargetUsage = MFX_TARGETUSAGE_BEST_QUALITY;
else if (astrcmpi(target_usage, "balanced") == 0)
obsqsv->params.nTargetUsage = MFX_TARGETUSAGE_BALANCED;
else if (astrcmpi(target_usage, "speed") == 0)
obsqsv->params.nTargetUsage = MFX_TARGETUSAGE_BEST_SPEED;
if (astrcmpi(profile, "baseline") == 0)
obsqsv->params.nCodecProfile = MFX_PROFILE_AVC_BASELINE;
else if (astrcmpi(profile, "main") == 0)
obsqsv->params.nCodecProfile = MFX_PROFILE_AVC_MAIN;
else if (astrcmpi(profile, "high") == 0)
obsqsv->params.nCodecProfile = MFX_PROFILE_AVC_HIGH;
/* internal convenience parameter, overrides rate control param
* XXX: Deprecated */
if (cbr_override) {
warn("\"cbr\" setting has been deprecated for all encoders! "
"Please set \"rate_control\" to \"CBR\" instead. "
"Forcing CBR mode. "
"(Note to all: this is why you shouldn't use strings for "
"common settings)");
rate_control = "CBR";
}
if (astrcmpi(rate_control, "CBR") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_CBR;
else if (astrcmpi(rate_control, "VBR") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_VBR;
else if (astrcmpi(rate_control, "VCM") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_VCM;
else if (astrcmpi(rate_control, "CQP") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_CQP;
else if (astrcmpi(rate_control, "AVBR") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_AVBR;
else if (astrcmpi(rate_control, "ICQ") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_ICQ;
else if (astrcmpi(rate_control, "LA_ICQ") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_LA_ICQ;
else if (astrcmpi(rate_control, "LA") == 0)
obsqsv->params.nRateControl = MFX_RATECONTROL_LA;
obsqsv->params.nAsyncDepth = (mfxU16)async_depth;
obsqsv->params.nAccuracy = (mfxU16)accuracy;
obsqsv->params.nConvergence = (mfxU16)convergence;
obsqsv->params.nQPI = (mfxU16)qpi;
obsqsv->params.nQPP = (mfxU16)qpp;
obsqsv->params.nQPB = (mfxU16)qpb;
obsqsv->params.nLADEPTH = (mfxU16)la_depth;
obsqsv->params.nTargetBitRate = (mfxU16)target_bitrate;
obsqsv->params.nMaxBitRate = (mfxU16)max_bitrate;
obsqsv->params.nWidth = (mfxU16)width;
obsqsv->params.nHeight = (mfxU16)height;
obsqsv->params.nFpsNum = (mfxU16)voi->fps_num;
obsqsv->params.nFpsDen = (mfxU16)voi->fps_den;
obsqsv->params.nbFrames = (mfxU16)bFrames;
obsqsv->params.nKeyIntSec = (mfxU16)keyint_sec;
obsqsv->params.nICQQuality = (mfxU16)icq_quality;
info("settings:\n\trate_control: %s", rate_control);
if (obsqsv->params.nRateControl != MFX_RATECONTROL_LA_ICQ &&
obsqsv->params.nRateControl != MFX_RATECONTROL_ICQ &&
obsqsv->params.nRateControl != MFX_RATECONTROL_CQP)
blog(LOG_INFO,
"\ttarget_bitrate: %d",
(int)obsqsv->params.nTargetBitRate);
if (obsqsv->params.nRateControl == MFX_RATECONTROL_VBR ||
obsqsv->params.nRateControl == MFX_RATECONTROL_VCM)
blog(LOG_INFO,
"\tmax_bitrate: %d",
(int)obsqsv->params.nMaxBitRate);
if (obsqsv->params.nRateControl == MFX_RATECONTROL_LA_ICQ ||
obsqsv->params.nRateControl == MFX_RATECONTROL_ICQ)
blog(LOG_INFO,
"\tICQ Quality: %d",
(int)obsqsv->params.nICQQuality);
if (obsqsv->params.nRateControl == MFX_RATECONTROL_LA_ICQ ||
obsqsv->params.nRateControl == MFX_RATECONTROL_LA)
blog(LOG_INFO,
"\tLookahead Depth:%d",
(int)obsqsv->params.nLADEPTH);
if (obsqsv->params.nRateControl == MFX_RATECONTROL_CQP)
blog(LOG_INFO,
"\tqpi: %d\n"
"\tqpb: %d\n"
"\tqpp: %d",
qpi, qpb, qpp);
blog(LOG_INFO,
"\tfps_num: %d\n"
"\tfps_den: %d\n"
"\twidth: %d\n"
"\theight: %d",
voi->fps_num, voi->fps_den,
width, height);
info("debug info:");
}
static bool update_settings(struct obs_qsv *obsqsv, obs_data_t *settings)
{
update_params(obsqsv, settings);
return true;
}
static void load_headers(struct obs_qsv *obsqsv)
{
DARRAY(uint8_t) header;
uint8_t sei = 0;
// Not sure if SEI is needed.
// Just filling in empty meaningless SEI message.
// Seems to work fine.
// DARRAY(uint8_t) sei;
da_init(header);
// da_init(sei);
uint8_t *pSPS, *pPPS;
uint16_t nSPS, nPPS;
qsv_encoder_headers(obsqsv->context, &pSPS, &pPPS, &nSPS, &nPPS);
da_push_back_array(header, pSPS, nSPS);
da_push_back_array(header, pPPS, nPPS);
obsqsv->extra_data = header.array;
obsqsv->extra_data_size = header.num;
obsqsv->sei = &sei;
obsqsv->sei_size = 1;
}
static bool obs_qsv_update(void *data, obs_data_t *settings)
{
struct obs_qsv *obsqsv = data;
bool success = update_settings(obsqsv, settings);
int ret;
if (success) {
EnterCriticalSection(&g_QsvCs);
ret = qsv_encoder_reconfig(obsqsv->context, &obsqsv->params);
if (ret != 0)
warn("Failed to reconfigure: %d", ret);
LeaveCriticalSection(&g_QsvCs);
return ret == 0;
}
return false;
}
static void *obs_qsv_create(obs_data_t *settings, obs_encoder_t *encoder)
{
InitializeCriticalSection(&g_QsvCs);
struct obs_qsv *obsqsv = bzalloc(sizeof(struct obs_qsv));
obsqsv->encoder = encoder;
if (update_settings(obsqsv, settings)) {
obsqsv->context = qsv_encoder_open(&obsqsv->params);
if (obsqsv->context == NULL)
warn("qsv failed to load");
else
load_headers(obsqsv);
} else {
warn("bad settings specified");
}
qsv_encoder_version(&g_verMajor, &g_verMinor);
blog(LOG_INFO, "\tmajor: %d\n"
"\tminor: %d",
g_verMajor, g_verMinor);
// MSDK 1.6 or less doesn't have automatic DTS calculation
// including early SandyBridge.
// Need to add manual DTS from PTS.
if (g_verMajor == 1 && g_verMinor < 7) {
int64_t interval = obsqsv->params.nbFrames + 1;
int64_t GopPicSize = (int64_t)(obsqsv->params.nKeyIntSec *
obsqsv->params.nFpsNum /
(float)obsqsv->params.nFpsDen);
g_pts2dtsShift = GopPicSize - (GopPicSize / interval) *
interval;
blog(LOG_INFO, "\tinterval: %d\n"
"\tGopPictSize: %d\n"
"\tg_pts2dtsShift: %d",
interval, GopPicSize, g_pts2dtsShift);
}
else
g_pts2dtsShift = -1;
if (!obsqsv->context) {
bfree(obsqsv);
return NULL;
}
obsqsv->performance_token =
os_request_high_performance("qsv encoding");
g_bFirst = true;
return obsqsv;
}
static bool obs_qsv_extra_data(void *data, uint8_t **extra_data, size_t *size)
{
struct obs_qsv *obsqsv = data;
if (!obsqsv->context)
return false;
*extra_data = obsqsv->extra_data;
*size = obsqsv->extra_data_size;
return true;
}
static bool obs_qsv_sei(void *data, uint8_t **sei,size_t *size)
{
struct obs_qsv *obsqsv = data;
if (!obsqsv->context)
return false;
/* (Jim) Unused */
UNUSED_PARAMETER(sei);
UNUSED_PARAMETER(size);
*sei = obsqsv->sei;
*size = obsqsv->sei_size;
return true;
}
static inline bool valid_format(enum video_format format)
{
return format == VIDEO_FORMAT_NV12;
}
static inline void cap_resolution(obs_encoder_t *encoder,
struct video_scale_info *info)
{
enum qsv_cpu_platform qsv_platform = qsv_get_cpu_platform();
uint32_t width = obs_encoder_get_width(encoder);
uint32_t height = obs_encoder_get_height(encoder);
info->height = height;
info->width = width;
if (qsv_platform <= QSV_CPU_PLATFORM_IVB) {
if (width > 1920) {
info->width = 1920;
}
if (height > 1200) {
info->height = 1200;
}
}
}
static void obs_qsv_video_info(void *data, struct video_scale_info *info)
{
struct obs_qsv *obsqsv = data;
enum video_format pref_format;
pref_format = obs_encoder_get_preferred_video_format(obsqsv->encoder);
if (!valid_format(pref_format)) {
pref_format = valid_format(info->format) ?
info->format : VIDEO_FORMAT_NV12;
}
info->format = pref_format;
cap_resolution(obsqsv->encoder, info);
}
static void parse_packet(struct obs_qsv *obsqsv, struct encoder_packet *packet, mfxBitstream *pBS, uint32_t fps_num, bool *received_packet)
{
if (pBS == NULL || pBS->DataLength == 0) {
*received_packet = false;
return;
}
da_resize(obsqsv->packet_data, 0);
da_push_back_array(obsqsv->packet_data, &pBS->Data[pBS->DataOffset],
pBS->DataLength);
packet->data = obsqsv->packet_data.array;
packet->size = obsqsv->packet_data.num;
packet->type = OBS_ENCODER_VIDEO;
packet->pts = pBS->TimeStamp * fps_num / 90000;
packet->keyframe = (pBS->FrameType &
(MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF));
//bool iFrame = pBS->FrameType & MFX_FRAMETYPE_I;
//bool bFrame = pBS->FrameType & MFX_FRAMETYPE_B;
bool pFrame = pBS->FrameType & MFX_FRAMETYPE_P;
//int iType = iFrame ? 0 : (bFrame ? 1 : (pFrame ? 2 : -1));
//int64_t interval = obsqsv->params.nbFrames + 1;
// In case MSDK does't support automatic DecodeTimeStamp, do manual
// calculation
if (g_pts2dtsShift >= 0)
{
if (g_bFirst) {
packet->dts = packet->pts - 3 * obsqsv->params.nFpsDen;
} else if (pFrame) {
packet->dts = packet->pts - 10 * obsqsv->params.nFpsDen;
g_prevDts = packet->dts;
} else {
packet->dts = g_prevDts + obsqsv->params.nFpsDen;
g_prevDts = packet->dts;
}
} else {
packet->dts = pBS->DecodeTimeStamp * fps_num / 90000;
}
#if 0
info("parse packet:\n"
"\tFrameType: %d\n"
"\tpts: %d\n"
"\tdts: %d",
iType, packet->pts, packet->dts);
#endif
*received_packet = true;
pBS->DataLength = 0;
g_bFirst = false;
}
static bool obs_qsv_encode(void *data, struct encoder_frame *frame,
struct encoder_packet *packet, bool *received_packet)
{
struct obs_qsv *obsqsv = data;
if (!frame || !packet || !received_packet)
return false;
EnterCriticalSection(&g_QsvCs);
video_t *video = obs_encoder_video(obsqsv->encoder);
const struct video_output_info *voi = video_output_get_info(video);
mfxBitstream *pBS = NULL;
int ret;
mfxU64 qsvPTS = frame->pts * 90000 / voi->fps_num;
if (frame)
ret = qsv_encoder_encode(
obsqsv->context,
qsvPTS,
frame->data[0], frame->data[1], frame->linesize[0],
frame->linesize[1],
&pBS);
else
ret = qsv_encoder_encode(
obsqsv->context,
qsvPTS,
NULL, NULL, 0, 0, &pBS);
if (ret < 0) {
warn("encode failed");
return false;
}
parse_packet(obsqsv, packet, pBS, voi->fps_num, received_packet);
LeaveCriticalSection(&g_QsvCs);
return true;
}
struct obs_encoder_info obs_qsv_encoder = {
.id = "obs_qsv11",
.type = OBS_ENCODER_VIDEO,
.codec = "h264",
.get_name = obs_qsv_getname,
.create = obs_qsv_create,
.destroy = obs_qsv_destroy,
.encode = obs_qsv_encode,
.update = obs_qsv_update,
.get_properties = obs_qsv_props,
.get_defaults = obs_qsv_defaults,
.get_extra_data = obs_qsv_extra_data,
.get_sei_data = obs_qsv_sei,
.get_video_info = obs_qsv_video_info
};