1
0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
FFmpeg/libavcodec/qsv.c
Derek Buitenhuis c182845068 Merge commit '92c1a83ee9394b39d68f6affd9104752a03714f8'
* commit '92c1a83ee9394b39d68f6affd9104752a03714f8':
  qsv: Fix loading multiple plugins

Merged-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>
2016-04-13 17:31:36 +01:00

272 lines
7.8 KiB
C

/*
* Intel MediaSDK QSV encoder/decoder shared code
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <mfx/mfxvideo.h>
#include <mfx/mfxplugin.h>
#include <stdio.h>
#include <string.h>
#include "libavutil/avstring.h"
#include "libavutil/error.h"
#include "avcodec.h"
#include "qsv_internal.h"
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
{
switch (codec_id) {
case AV_CODEC_ID_H264:
return MFX_CODEC_AVC;
#if QSV_VERSION_ATLEAST(1, 8)
case AV_CODEC_ID_HEVC:
return MFX_CODEC_HEVC;
#endif
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
return MFX_CODEC_MPEG2;
case AV_CODEC_ID_VC1:
return MFX_CODEC_VC1;
default:
break;
}
return AVERROR(ENOSYS);
}
int ff_qsv_error(int mfx_err)
{
switch (mfx_err) {
case MFX_ERR_NONE:
return 0;
case MFX_ERR_MEMORY_ALLOC:
case MFX_ERR_NOT_ENOUGH_BUFFER:
return AVERROR(ENOMEM);
case MFX_ERR_INVALID_HANDLE:
return AVERROR(EINVAL);
case MFX_ERR_DEVICE_FAILED:
case MFX_ERR_DEVICE_LOST:
case MFX_ERR_LOCK_MEMORY:
return AVERROR(EIO);
case MFX_ERR_NULL_PTR:
case MFX_ERR_UNDEFINED_BEHAVIOR:
case MFX_ERR_NOT_INITIALIZED:
return AVERROR_BUG;
case MFX_ERR_UNSUPPORTED:
case MFX_ERR_NOT_FOUND:
return AVERROR(ENOSYS);
case MFX_ERR_MORE_DATA:
case MFX_ERR_MORE_SURFACE:
case MFX_ERR_MORE_BITSTREAM:
return AVERROR(EAGAIN);
case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
case MFX_ERR_INVALID_VIDEO_PARAM:
return AVERROR(EINVAL);
case MFX_ERR_ABORTED:
case MFX_ERR_UNKNOWN:
default:
return AVERROR_UNKNOWN;
}
}
static int ff_qsv_set_display_handle(AVCodecContext *avctx, QSVSession *qs)
{
// this code is only required for Linux. It searches for a valid
// display handle. First in /dev/dri/renderD then in /dev/dri/card
#ifdef AVCODEC_QSV_LINUX_SESSION_HANDLE
// VAAPI display handle
int ret = 0;
VADisplay va_dpy = NULL;
VAStatus va_res = VA_STATUS_SUCCESS;
int major_version = 0, minor_version = 0;
int fd = -1;
char adapterpath[256];
int adapter_num;
qs->fd_display = -1;
qs->va_display = NULL;
//search for valid graphics device
for (adapter_num = 0;adapter_num < 6;adapter_num++) {
if (adapter_num<3) {
snprintf(adapterpath,sizeof(adapterpath),
"/dev/dri/renderD%d", adapter_num+128);
} else {
snprintf(adapterpath,sizeof(adapterpath),
"/dev/dri/card%d", adapter_num-3);
}
fd = open(adapterpath, O_RDWR);
if (fd < 0) {
av_log(avctx, AV_LOG_ERROR,
"mfx init: %s fd open failed\n", adapterpath);
continue;
}
va_dpy = vaGetDisplayDRM(fd);
if (!va_dpy) {
av_log(avctx, AV_LOG_ERROR,
"mfx init: %s vaGetDisplayDRM failed\n", adapterpath);
close(fd);
continue;
}
va_res = vaInitialize(va_dpy, &major_version, &minor_version);
if (VA_STATUS_SUCCESS != va_res) {
av_log(avctx, AV_LOG_ERROR,
"mfx init: %s vaInitialize failed\n", adapterpath);
close(fd);
fd = -1;
continue;
} else {
av_log(avctx, AV_LOG_VERBOSE,
"mfx initialization: %s vaInitialize successful\n",adapterpath);
qs->fd_display = fd;
qs->va_display = va_dpy;
ret = MFXVideoCORE_SetHandle(qs->session,
(mfxHandleType)MFX_HANDLE_VA_DISPLAY, (mfxHDL)va_dpy);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
"Error %d during set display handle\n", ret);
return ff_qsv_error(ret);
}
break;
}
}
#endif //AVCODEC_QSV_LINUX_SESSION_HANDLE
return 0;
}
/**
* @brief Initialize a MSDK session
*
* Media SDK is based on sessions, so this is the prerequisite
* initialization for HW acceleration. For Windows the session is
* complete and ready to use, for Linux a display handle is
* required. For releases of Media Server Studio >= 2015 R4 the
* render nodes interface is preferred (/dev/dri/renderD).
* Using Media Server Studio 2015 R4 or newer is recommended
* but the older /dev/dri/card interface is also searched
* for broader compatibility.
*
* @param avctx ffmpeg metadata for this codec context
* @param session the MSDK session used
*/
int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs,
const char *load_plugins)
{
mfxIMPL impl = MFX_IMPL_AUTO_ANY;
mfxVersion ver = { { QSV_VERSION_MINOR, QSV_VERSION_MAJOR } };
const char *desc;
int ret;
ret = MFXInit(impl, &ver, &qs->session);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Error initializing an internal MFX session\n");
return ff_qsv_error(ret);
}
ret = ff_qsv_set_display_handle(avctx, qs);
if (ret < 0)
return ret;
if (load_plugins && *load_plugins) {
while (*load_plugins) {
mfxPluginUID uid;
int i, err = 0;
char *plugin = av_get_token(&load_plugins, ":");
if (!plugin)
return AVERROR(ENOMEM);
if (strlen(plugin) != 2 * sizeof(uid.Data)) {
av_log(avctx, AV_LOG_ERROR, "Invalid plugin UID length\n");
err = AVERROR(EINVAL);
goto load_plugin_fail;
}
for (i = 0; i < sizeof(uid.Data); i++) {
err = sscanf(plugin + 2 * i, "%2hhx", uid.Data + i);
if (err != 1) {
av_log(avctx, AV_LOG_ERROR, "Invalid plugin UID\n");
err = AVERROR(EINVAL);
goto load_plugin_fail;
}
}
ret = MFXVideoUSER_Load(qs->session, &uid, 1);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Could not load the requested plugin: %s\n",
plugin);
err = ff_qsv_error(ret);
goto load_plugin_fail;
}
if (*load_plugins)
load_plugins++;
load_plugin_fail:
av_freep(&plugin);
if (err < 0)
return err;
}
}
MFXQueryIMPL(qs->session, &impl);
switch (MFX_IMPL_BASETYPE(impl)) {
case MFX_IMPL_SOFTWARE:
desc = "software";
break;
case MFX_IMPL_HARDWARE:
case MFX_IMPL_HARDWARE2:
case MFX_IMPL_HARDWARE3:
case MFX_IMPL_HARDWARE4:
desc = "hardware accelerated";
break;
default:
desc = "unknown";
}
av_log(avctx, AV_LOG_VERBOSE,
"Initialized an internal MFX session using %s implementation\n",
desc);
return 0;
}
int ff_qsv_close_internal_session(QSVSession *qs)
{
if (qs->session) {
MFXClose(qs->session);
qs->session = NULL;
}
#ifdef AVCODEC_QSV_LINUX_SESSION_HANDLE
if (qs->va_display) {
vaTerminate(qs->va_display);
qs->va_display = NULL;
}
if (qs->fd_display > 0) {
close(qs->fd_display);
qs->fd_display = -1;
}
#endif
return 0;
}