mirror of https://github.com/FFmpeg/FFmpeg.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1131 lines
35 KiB
1131 lines
35 KiB
/* |
|
* This file is part of Libav. |
|
* |
|
* Libav 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. |
|
* |
|
* Libav 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 Libav; if not, write to the Free Software |
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
*/ |
|
|
|
#include <stdint.h> |
|
#include <string.h> |
|
|
|
#include <mfx/mfxvideo.h> |
|
|
|
#include "config.h" |
|
|
|
#if CONFIG_VAAPI |
|
#include "hwcontext_vaapi.h" |
|
#endif |
|
#if CONFIG_DXVA2 |
|
#include "hwcontext_dxva2.h" |
|
#endif |
|
|
|
#include "buffer.h" |
|
#include "common.h" |
|
#include "hwcontext.h" |
|
#include "hwcontext_internal.h" |
|
#include "hwcontext_qsv.h" |
|
#include "mem.h" |
|
#include "pixfmt.h" |
|
#include "pixdesc.h" |
|
#include "time.h" |
|
|
|
typedef struct QSVDevicePriv { |
|
AVBufferRef *child_device_ctx; |
|
} QSVDevicePriv; |
|
|
|
typedef struct QSVDeviceContext { |
|
mfxHDL handle; |
|
mfxHandleType handle_type; |
|
mfxVersion ver; |
|
mfxIMPL impl; |
|
|
|
enum AVHWDeviceType child_device_type; |
|
enum AVPixelFormat child_pix_fmt; |
|
} QSVDeviceContext; |
|
|
|
typedef struct QSVFramesContext { |
|
mfxSession session_download; |
|
mfxSession session_upload; |
|
|
|
AVBufferRef *child_frames_ref; |
|
mfxFrameSurface1 *surfaces_internal; |
|
int nb_surfaces_used; |
|
|
|
// used in the frame allocator for non-opaque surfaces |
|
mfxMemId *mem_ids; |
|
// used in the opaque alloc request for opaque surfaces |
|
mfxFrameSurface1 **surface_ptrs; |
|
|
|
mfxExtOpaqueSurfaceAlloc opaque_alloc; |
|
mfxExtBuffer *ext_buffers[1]; |
|
} QSVFramesContext; |
|
|
|
static const struct { |
|
mfxHandleType handle_type; |
|
enum AVHWDeviceType device_type; |
|
enum AVPixelFormat pix_fmt; |
|
} supported_handle_types[] = { |
|
#if CONFIG_VAAPI |
|
{ MFX_HANDLE_VA_DISPLAY, AV_HWDEVICE_TYPE_VAAPI, AV_PIX_FMT_VAAPI }, |
|
#endif |
|
#if CONFIG_DXVA2 |
|
{ MFX_HANDLE_D3D9_DEVICE_MANAGER, AV_HWDEVICE_TYPE_DXVA2, AV_PIX_FMT_DXVA2_VLD }, |
|
#endif |
|
{ 0 }, |
|
}; |
|
|
|
static const struct { |
|
enum AVPixelFormat pix_fmt; |
|
uint32_t fourcc; |
|
} supported_pixel_formats[] = { |
|
{ AV_PIX_FMT_NV12, MFX_FOURCC_NV12 }, |
|
{ AV_PIX_FMT_P010, MFX_FOURCC_P010 }, |
|
{ AV_PIX_FMT_PAL8, MFX_FOURCC_P8 }, |
|
}; |
|
|
|
static uint32_t qsv_fourcc_from_pix_fmt(enum AVPixelFormat pix_fmt) |
|
{ |
|
int i; |
|
for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) { |
|
if (supported_pixel_formats[i].pix_fmt == pix_fmt) |
|
return supported_pixel_formats[i].fourcc; |
|
} |
|
return 0; |
|
} |
|
|
|
static int qsv_device_init(AVHWDeviceContext *ctx) |
|
{ |
|
AVQSVDeviceContext *hwctx = ctx->hwctx; |
|
QSVDeviceContext *s = ctx->internal->priv; |
|
|
|
mfxStatus err; |
|
int i; |
|
|
|
for (i = 0; supported_handle_types[i].handle_type; i++) { |
|
err = MFXVideoCORE_GetHandle(hwctx->session, supported_handle_types[i].handle_type, |
|
&s->handle); |
|
if (err == MFX_ERR_NONE) { |
|
s->handle_type = supported_handle_types[i].handle_type; |
|
s->child_device_type = supported_handle_types[i].device_type; |
|
s->child_pix_fmt = supported_handle_types[i].pix_fmt; |
|
break; |
|
} |
|
} |
|
if (!s->handle) { |
|
av_log(ctx, AV_LOG_VERBOSE, "No supported hw handle could be retrieved " |
|
"from the session\n"); |
|
} |
|
|
|
err = MFXQueryIMPL(hwctx->session, &s->impl); |
|
if (err == MFX_ERR_NONE) |
|
err = MFXQueryVersion(hwctx->session, &s->ver); |
|
if (err != MFX_ERR_NONE) { |
|
av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n"); |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static void qsv_frames_uninit(AVHWFramesContext *ctx) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
|
|
if (s->session_download) { |
|
MFXVideoVPP_Close(s->session_download); |
|
MFXClose(s->session_download); |
|
} |
|
s->session_download = NULL; |
|
|
|
if (s->session_upload) { |
|
MFXVideoVPP_Close(s->session_upload); |
|
MFXClose(s->session_upload); |
|
} |
|
s->session_upload = NULL; |
|
|
|
av_freep(&s->mem_ids); |
|
av_freep(&s->surface_ptrs); |
|
av_freep(&s->surfaces_internal); |
|
av_buffer_unref(&s->child_frames_ref); |
|
} |
|
|
|
static void qsv_pool_release_dummy(void *opaque, uint8_t *data) |
|
{ |
|
} |
|
|
|
static AVBufferRef *qsv_pool_alloc(void *opaque, int size) |
|
{ |
|
AVHWFramesContext *ctx = (AVHWFramesContext*)opaque; |
|
QSVFramesContext *s = ctx->internal->priv; |
|
AVQSVFramesContext *hwctx = ctx->hwctx; |
|
|
|
if (s->nb_surfaces_used < hwctx->nb_surfaces) { |
|
s->nb_surfaces_used++; |
|
return av_buffer_create((uint8_t*)(s->surfaces_internal + s->nb_surfaces_used - 1), |
|
sizeof(*hwctx->surfaces), qsv_pool_release_dummy, NULL, 0); |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
static int qsv_init_child_ctx(AVHWFramesContext *ctx) |
|
{ |
|
AVQSVFramesContext *hwctx = ctx->hwctx; |
|
QSVFramesContext *s = ctx->internal->priv; |
|
QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv; |
|
|
|
AVBufferRef *child_device_ref = NULL; |
|
AVBufferRef *child_frames_ref = NULL; |
|
|
|
AVHWDeviceContext *child_device_ctx; |
|
AVHWFramesContext *child_frames_ctx; |
|
|
|
int i, ret = 0; |
|
|
|
if (!device_priv->handle) { |
|
av_log(ctx, AV_LOG_ERROR, |
|
"Cannot create a non-opaque internal surface pool without " |
|
"a hardware handle\n"); |
|
return AVERROR(EINVAL); |
|
} |
|
|
|
child_device_ref = av_hwdevice_ctx_alloc(device_priv->child_device_type); |
|
if (!child_device_ref) |
|
return AVERROR(ENOMEM); |
|
child_device_ctx = (AVHWDeviceContext*)child_device_ref->data; |
|
|
|
#if CONFIG_VAAPI |
|
if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) { |
|
AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx; |
|
child_device_hwctx->display = (VADisplay)device_priv->handle; |
|
} |
|
#endif |
|
#if CONFIG_DXVA2 |
|
if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) { |
|
AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx; |
|
child_device_hwctx->devmgr = (IDirect3DDeviceManager9*)device_priv->handle; |
|
} |
|
#endif |
|
|
|
ret = av_hwdevice_ctx_init(child_device_ref); |
|
if (ret < 0) { |
|
av_log(ctx, AV_LOG_ERROR, "Error initializing a child device context\n"); |
|
goto fail; |
|
} |
|
|
|
child_frames_ref = av_hwframe_ctx_alloc(child_device_ref); |
|
if (!child_frames_ref) { |
|
ret = AVERROR(ENOMEM); |
|
goto fail; |
|
} |
|
child_frames_ctx = (AVHWFramesContext*)child_frames_ref->data; |
|
|
|
child_frames_ctx->format = device_priv->child_pix_fmt; |
|
child_frames_ctx->sw_format = ctx->sw_format; |
|
child_frames_ctx->initial_pool_size = ctx->initial_pool_size; |
|
child_frames_ctx->width = ctx->width; |
|
child_frames_ctx->height = ctx->height; |
|
|
|
#if CONFIG_DXVA2 |
|
if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) { |
|
AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx; |
|
if (hwctx->frame_type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) |
|
child_frames_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget; |
|
else |
|
child_frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget; |
|
} |
|
#endif |
|
|
|
ret = av_hwframe_ctx_init(child_frames_ref); |
|
if (ret < 0) { |
|
av_log(ctx, AV_LOG_ERROR, "Error initializing a child frames context\n"); |
|
goto fail; |
|
} |
|
|
|
#if CONFIG_VAAPI |
|
if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) { |
|
AVVAAPIFramesContext *child_frames_hwctx = child_frames_ctx->hwctx; |
|
for (i = 0; i < ctx->initial_pool_size; i++) |
|
s->surfaces_internal[i].Data.MemId = child_frames_hwctx->surface_ids + i; |
|
hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET; |
|
} |
|
#endif |
|
#if CONFIG_DXVA2 |
|
if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) { |
|
AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx; |
|
for (i = 0; i < ctx->initial_pool_size; i++) |
|
s->surfaces_internal[i].Data.MemId = (mfxMemId)child_frames_hwctx->surfaces[i]; |
|
if (child_frames_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget) |
|
hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET; |
|
else |
|
hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET; |
|
} |
|
#endif |
|
|
|
s->child_frames_ref = child_frames_ref; |
|
child_frames_ref = NULL; |
|
|
|
fail: |
|
av_buffer_unref(&child_device_ref); |
|
av_buffer_unref(&child_frames_ref); |
|
return ret; |
|
} |
|
|
|
static int qsv_init_surface(AVHWFramesContext *ctx, mfxFrameSurface1 *surf) |
|
{ |
|
const AVPixFmtDescriptor *desc; |
|
uint32_t fourcc; |
|
|
|
desc = av_pix_fmt_desc_get(ctx->sw_format); |
|
if (!desc) |
|
return AVERROR(EINVAL); |
|
|
|
fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format); |
|
if (!fourcc) |
|
return AVERROR(EINVAL); |
|
|
|
surf->Info.BitDepthLuma = desc->comp[0].depth; |
|
surf->Info.BitDepthChroma = desc->comp[0].depth; |
|
surf->Info.Shift = desc->comp[0].depth > 8; |
|
|
|
if (desc->log2_chroma_w && desc->log2_chroma_h) |
|
surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV420; |
|
else if (desc->log2_chroma_w) |
|
surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV422; |
|
else |
|
surf->Info.ChromaFormat = MFX_CHROMAFORMAT_YUV444; |
|
|
|
surf->Info.FourCC = fourcc; |
|
surf->Info.Width = ctx->width; |
|
surf->Info.CropW = ctx->width; |
|
surf->Info.Height = ctx->height; |
|
surf->Info.CropH = ctx->height; |
|
surf->Info.FrameRateExtN = 25; |
|
surf->Info.FrameRateExtD = 1; |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
AVQSVFramesContext *frames_hwctx = ctx->hwctx; |
|
|
|
int i, ret = 0; |
|
|
|
if (ctx->initial_pool_size <= 0) { |
|
av_log(ctx, AV_LOG_ERROR, "QSV requires a fixed frame pool size\n"); |
|
return AVERROR(EINVAL); |
|
} |
|
|
|
s->surfaces_internal = av_mallocz_array(ctx->initial_pool_size, |
|
sizeof(*s->surfaces_internal)); |
|
if (!s->surfaces_internal) |
|
return AVERROR(ENOMEM); |
|
|
|
for (i = 0; i < ctx->initial_pool_size; i++) { |
|
ret = qsv_init_surface(ctx, &s->surfaces_internal[i]); |
|
if (ret < 0) |
|
return ret; |
|
} |
|
|
|
if (!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)) { |
|
ret = qsv_init_child_ctx(ctx); |
|
if (ret < 0) |
|
return ret; |
|
} |
|
|
|
ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(mfxFrameSurface1), |
|
ctx, qsv_pool_alloc, NULL); |
|
if (!ctx->internal->pool_internal) |
|
return AVERROR(ENOMEM); |
|
|
|
frames_hwctx->surfaces = s->surfaces_internal; |
|
frames_hwctx->nb_surfaces = ctx->initial_pool_size; |
|
|
|
return 0; |
|
} |
|
|
|
static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, |
|
mfxFrameAllocResponse *resp) |
|
{ |
|
AVHWFramesContext *ctx = pthis; |
|
QSVFramesContext *s = ctx->internal->priv; |
|
AVQSVFramesContext *hwctx = ctx->hwctx; |
|
mfxFrameInfo *i = &req->Info; |
|
mfxFrameInfo *i1 = &hwctx->surfaces[0].Info; |
|
|
|
if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) || |
|
!(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) || |
|
!(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME)) |
|
return MFX_ERR_UNSUPPORTED; |
|
if (i->Width != i1->Width || i->Height != i1->Height || |
|
i->FourCC != i1->FourCC || i->ChromaFormat != i1->ChromaFormat) { |
|
av_log(ctx, AV_LOG_ERROR, "Mismatching surface properties in an " |
|
"allocation request: %dx%d %d %d vs %dx%d %d %d\n", |
|
i->Width, i->Height, i->FourCC, i->ChromaFormat, |
|
i1->Width, i1->Height, i1->FourCC, i1->ChromaFormat); |
|
return MFX_ERR_UNSUPPORTED; |
|
} |
|
|
|
resp->mids = s->mem_ids; |
|
resp->NumFrameActual = hwctx->nb_surfaces; |
|
|
|
return MFX_ERR_NONE; |
|
} |
|
|
|
static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp) |
|
{ |
|
return MFX_ERR_NONE; |
|
} |
|
|
|
static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr) |
|
{ |
|
return MFX_ERR_UNSUPPORTED; |
|
} |
|
|
|
static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr) |
|
{ |
|
return MFX_ERR_UNSUPPORTED; |
|
} |
|
|
|
static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl) |
|
{ |
|
*hdl = mid; |
|
return MFX_ERR_NONE; |
|
} |
|
|
|
static int qsv_init_internal_session(AVHWFramesContext *ctx, |
|
mfxSession *session, int upload) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
AVQSVFramesContext *frames_hwctx = ctx->hwctx; |
|
QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv; |
|
int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME); |
|
|
|
mfxFrameAllocator frame_allocator = { |
|
.pthis = ctx, |
|
.Alloc = frame_alloc, |
|
.Lock = frame_lock, |
|
.Unlock = frame_unlock, |
|
.GetHDL = frame_get_hdl, |
|
.Free = frame_free, |
|
}; |
|
|
|
mfxVideoParam par; |
|
mfxStatus err; |
|
|
|
err = MFXInit(device_priv->impl, &device_priv->ver, session); |
|
if (err != MFX_ERR_NONE) { |
|
av_log(ctx, AV_LOG_ERROR, "Error initializing an internal session\n"); |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
if (device_priv->handle) { |
|
err = MFXVideoCORE_SetHandle(*session, device_priv->handle_type, |
|
device_priv->handle); |
|
if (err != MFX_ERR_NONE) |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
if (!opaque) { |
|
err = MFXVideoCORE_SetFrameAllocator(*session, &frame_allocator); |
|
if (err != MFX_ERR_NONE) |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
memset(&par, 0, sizeof(par)); |
|
|
|
if (opaque) { |
|
par.ExtParam = s->ext_buffers; |
|
par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers); |
|
par.IOPattern = upload ? MFX_IOPATTERN_OUT_OPAQUE_MEMORY : |
|
MFX_IOPATTERN_IN_OPAQUE_MEMORY; |
|
} else { |
|
par.IOPattern = upload ? MFX_IOPATTERN_OUT_VIDEO_MEMORY : |
|
MFX_IOPATTERN_IN_VIDEO_MEMORY; |
|
} |
|
|
|
par.IOPattern |= upload ? MFX_IOPATTERN_IN_SYSTEM_MEMORY : |
|
MFX_IOPATTERN_OUT_SYSTEM_MEMORY; |
|
par.AsyncDepth = 1; |
|
|
|
par.vpp.In = frames_hwctx->surfaces[0].Info; |
|
|
|
/* Apparently VPP requires the frame rate to be set to some value, otherwise |
|
* init will fail (probably for the framerate conversion filter). Since we |
|
* are only doing data upload/download here, we just invent an arbitrary |
|
* value */ |
|
par.vpp.In.FrameRateExtN = 25; |
|
par.vpp.In.FrameRateExtD = 1; |
|
par.vpp.Out = par.vpp.In; |
|
|
|
err = MFXVideoVPP_Init(*session, &par); |
|
if (err != MFX_ERR_NONE) { |
|
av_log(ctx, AV_LOG_VERBOSE, "Error opening the internal VPP session." |
|
"Surface upload/download will not be possible\n"); |
|
MFXClose(*session); |
|
*session = NULL; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_frames_init(AVHWFramesContext *ctx) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
AVQSVFramesContext *frames_hwctx = ctx->hwctx; |
|
|
|
int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME); |
|
|
|
uint32_t fourcc; |
|
int i, ret; |
|
|
|
fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format); |
|
if (!fourcc) { |
|
av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format\n"); |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
if (!ctx->pool) { |
|
ret = qsv_init_pool(ctx, fourcc); |
|
if (ret < 0) { |
|
av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n"); |
|
return ret; |
|
} |
|
} |
|
|
|
if (opaque) { |
|
s->surface_ptrs = av_mallocz_array(frames_hwctx->nb_surfaces, |
|
sizeof(*s->surface_ptrs)); |
|
if (!s->surface_ptrs) |
|
return AVERROR(ENOMEM); |
|
|
|
for (i = 0; i < frames_hwctx->nb_surfaces; i++) |
|
s->surface_ptrs[i] = frames_hwctx->surfaces + i; |
|
|
|
s->opaque_alloc.In.Surfaces = s->surface_ptrs; |
|
s->opaque_alloc.In.NumSurface = frames_hwctx->nb_surfaces; |
|
s->opaque_alloc.In.Type = frames_hwctx->frame_type; |
|
|
|
s->opaque_alloc.Out = s->opaque_alloc.In; |
|
|
|
s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION; |
|
s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc); |
|
|
|
s->ext_buffers[0] = (mfxExtBuffer*)&s->opaque_alloc; |
|
} else { |
|
s->mem_ids = av_mallocz_array(frames_hwctx->nb_surfaces, sizeof(*s->mem_ids)); |
|
if (!s->mem_ids) |
|
return AVERROR(ENOMEM); |
|
|
|
for (i = 0; i < frames_hwctx->nb_surfaces; i++) |
|
s->mem_ids[i] = frames_hwctx->surfaces[i].Data.MemId; |
|
} |
|
|
|
ret = qsv_init_internal_session(ctx, &s->session_download, 0); |
|
if (ret < 0) |
|
return ret; |
|
|
|
ret = qsv_init_internal_session(ctx, &s->session_upload, 1); |
|
if (ret < 0) |
|
return ret; |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_get_buffer(AVHWFramesContext *ctx, AVFrame *frame) |
|
{ |
|
frame->buf[0] = av_buffer_pool_get(ctx->pool); |
|
if (!frame->buf[0]) |
|
return AVERROR(ENOMEM); |
|
|
|
frame->data[3] = frame->buf[0]->data; |
|
frame->format = AV_PIX_FMT_QSV; |
|
frame->width = ctx->width; |
|
frame->height = ctx->height; |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_transfer_get_formats(AVHWFramesContext *ctx, |
|
enum AVHWFrameTransferDirection dir, |
|
enum AVPixelFormat **formats) |
|
{ |
|
enum AVPixelFormat *fmts; |
|
|
|
fmts = av_malloc_array(2, sizeof(*fmts)); |
|
if (!fmts) |
|
return AVERROR(ENOMEM); |
|
|
|
fmts[0] = ctx->sw_format; |
|
fmts[1] = AV_PIX_FMT_NONE; |
|
|
|
*formats = fmts; |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_frames_derive_from(AVHWFramesContext *dst_ctx, |
|
AVHWFramesContext *src_ctx, int flags) |
|
{ |
|
AVQSVFramesContext *src_hwctx = src_ctx->hwctx; |
|
int i; |
|
|
|
switch (dst_ctx->device_ctx->type) { |
|
#if CONFIG_VAAPI |
|
case AV_HWDEVICE_TYPE_VAAPI: |
|
{ |
|
AVVAAPIFramesContext *dst_hwctx = dst_ctx->hwctx; |
|
dst_hwctx->surface_ids = av_mallocz_array(src_hwctx->nb_surfaces, |
|
sizeof(*dst_hwctx->surface_ids)); |
|
if (!dst_hwctx->surface_ids) |
|
return AVERROR(ENOMEM); |
|
for (i = 0; i < src_hwctx->nb_surfaces; i++) |
|
dst_hwctx->surface_ids[i] = |
|
*(VASurfaceID*)src_hwctx->surfaces[i].Data.MemId; |
|
dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces; |
|
} |
|
break; |
|
#endif |
|
#if CONFIG_DXVA2 |
|
case AV_HWDEVICE_TYPE_DXVA2: |
|
{ |
|
AVDXVA2FramesContext *dst_hwctx = dst_ctx->hwctx; |
|
dst_hwctx->surfaces = av_mallocz_array(src_hwctx->nb_surfaces, |
|
sizeof(*dst_hwctx->surfaces)); |
|
if (!dst_hwctx->surfaces) |
|
return AVERROR(ENOMEM); |
|
for (i = 0; i < src_hwctx->nb_surfaces; i++) |
|
dst_hwctx->surfaces[i] = |
|
(IDirect3DSurface9*)src_hwctx->surfaces[i].Data.MemId; |
|
dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces; |
|
if (src_hwctx->frame_type == MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET) |
|
dst_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget; |
|
else |
|
dst_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget; |
|
} |
|
break; |
|
#endif |
|
default: |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_map_from(AVHWFramesContext *ctx, |
|
AVFrame *dst, const AVFrame *src, int flags) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
mfxFrameSurface1 *surf = (mfxFrameSurface1*)src->data[3]; |
|
AVHWFramesContext *child_frames_ctx; |
|
const AVPixFmtDescriptor *desc; |
|
uint8_t *child_data; |
|
AVFrame *dummy; |
|
int ret = 0; |
|
|
|
if (!s->child_frames_ref) |
|
return AVERROR(ENOSYS); |
|
child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data; |
|
|
|
switch (child_frames_ctx->device_ctx->type) { |
|
#if CONFIG_VAAPI |
|
case AV_HWDEVICE_TYPE_VAAPI: |
|
child_data = (uint8_t*)(intptr_t)*(VASurfaceID*)surf->Data.MemId; |
|
break; |
|
#endif |
|
#if CONFIG_DXVA2 |
|
case AV_HWDEVICE_TYPE_DXVA2: |
|
child_data = surf->Data.MemId; |
|
break; |
|
#endif |
|
default: |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
if (dst->format == child_frames_ctx->format) { |
|
ret = ff_hwframe_map_create(s->child_frames_ref, |
|
dst, src, NULL, NULL); |
|
if (ret < 0) |
|
return ret; |
|
|
|
dst->width = src->width; |
|
dst->height = src->height; |
|
dst->data[3] = child_data; |
|
|
|
return 0; |
|
} |
|
|
|
desc = av_pix_fmt_desc_get(dst->format); |
|
if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL) { |
|
// This only supports mapping to software. |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
dummy = av_frame_alloc(); |
|
if (!dummy) |
|
return AVERROR(ENOMEM); |
|
|
|
dummy->buf[0] = av_buffer_ref(src->buf[0]); |
|
dummy->hw_frames_ctx = av_buffer_ref(s->child_frames_ref); |
|
if (!dummy->buf[0] || !dummy->hw_frames_ctx) |
|
goto fail; |
|
|
|
dummy->format = child_frames_ctx->format; |
|
dummy->width = src->width; |
|
dummy->height = src->height; |
|
dummy->data[3] = child_data; |
|
|
|
ret = av_hwframe_map(dst, dummy, flags); |
|
|
|
fail: |
|
av_frame_free(&dummy); |
|
|
|
return ret; |
|
} |
|
|
|
static int qsv_transfer_data_child(AVHWFramesContext *ctx, AVFrame *dst, |
|
const AVFrame *src) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
AVHWFramesContext *child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data; |
|
int download = !!src->hw_frames_ctx; |
|
mfxFrameSurface1 *surf = (mfxFrameSurface1*)(download ? src->data[3] : dst->data[3]); |
|
|
|
AVFrame *dummy; |
|
int ret; |
|
|
|
dummy = av_frame_alloc(); |
|
if (!dummy) |
|
return AVERROR(ENOMEM); |
|
|
|
dummy->format = child_frames_ctx->format; |
|
dummy->width = src->width; |
|
dummy->height = src->height; |
|
dummy->buf[0] = download ? src->buf[0] : dst->buf[0]; |
|
dummy->data[3] = surf->Data.MemId; |
|
dummy->hw_frames_ctx = s->child_frames_ref; |
|
|
|
ret = download ? av_hwframe_transfer_data(dst, dummy, 0) : |
|
av_hwframe_transfer_data(dummy, src, 0); |
|
|
|
dummy->buf[0] = NULL; |
|
dummy->data[3] = NULL; |
|
dummy->hw_frames_ctx = NULL; |
|
|
|
av_frame_free(&dummy); |
|
|
|
return ret; |
|
} |
|
|
|
static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst, |
|
const AVFrame *src) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
mfxFrameSurface1 out = {{ 0 }}; |
|
mfxFrameSurface1 *in = (mfxFrameSurface1*)src->data[3]; |
|
|
|
mfxSyncPoint sync = NULL; |
|
mfxStatus err; |
|
|
|
if (!s->session_download) { |
|
if (s->child_frames_ref) |
|
return qsv_transfer_data_child(ctx, dst, src); |
|
|
|
av_log(ctx, AV_LOG_ERROR, "Surface download not possible\n"); |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
out.Info = in->Info; |
|
out.Data.PitchLow = dst->linesize[0]; |
|
out.Data.Y = dst->data[0]; |
|
out.Data.U = dst->data[1]; |
|
out.Data.V = dst->data[2]; |
|
out.Data.A = dst->data[3]; |
|
|
|
do { |
|
err = MFXVideoVPP_RunFrameVPPAsync(s->session_download, in, &out, NULL, &sync); |
|
if (err == MFX_WRN_DEVICE_BUSY) |
|
av_usleep(1); |
|
} while (err == MFX_WRN_DEVICE_BUSY); |
|
|
|
if (err < 0 || !sync) { |
|
av_log(ctx, AV_LOG_ERROR, "Error downloading the surface\n"); |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
do { |
|
err = MFXVideoCORE_SyncOperation(s->session_download, sync, 1000); |
|
} while (err == MFX_WRN_IN_EXECUTION); |
|
if (err < 0) { |
|
av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err); |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst, |
|
const AVFrame *src) |
|
{ |
|
QSVFramesContext *s = ctx->internal->priv; |
|
mfxFrameSurface1 in = {{ 0 }}; |
|
mfxFrameSurface1 *out = (mfxFrameSurface1*)dst->data[3]; |
|
|
|
mfxSyncPoint sync = NULL; |
|
mfxStatus err; |
|
|
|
if (!s->session_upload) { |
|
if (s->child_frames_ref) |
|
return qsv_transfer_data_child(ctx, dst, src); |
|
|
|
av_log(ctx, AV_LOG_ERROR, "Surface upload not possible\n"); |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
in.Info = out->Info; |
|
in.Data.PitchLow = src->linesize[0]; |
|
in.Data.Y = src->data[0]; |
|
in.Data.U = src->data[1]; |
|
in.Data.V = src->data[2]; |
|
in.Data.A = src->data[3]; |
|
|
|
do { |
|
err = MFXVideoVPP_RunFrameVPPAsync(s->session_upload, &in, out, NULL, &sync); |
|
if (err == MFX_WRN_DEVICE_BUSY) |
|
av_usleep(1); |
|
} while (err == MFX_WRN_DEVICE_BUSY); |
|
|
|
if (err < 0 || !sync) { |
|
av_log(ctx, AV_LOG_ERROR, "Error uploading the surface\n"); |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
do { |
|
err = MFXVideoCORE_SyncOperation(s->session_upload, sync, 1000); |
|
} while (err == MFX_WRN_IN_EXECUTION); |
|
if (err < 0) { |
|
av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation\n"); |
|
return AVERROR_UNKNOWN; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_frames_derive_to(AVHWFramesContext *dst_ctx, |
|
AVHWFramesContext *src_ctx, int flags) |
|
{ |
|
QSVFramesContext *s = dst_ctx->internal->priv; |
|
AVQSVFramesContext *dst_hwctx = dst_ctx->hwctx; |
|
int i; |
|
|
|
switch (src_ctx->device_ctx->type) { |
|
#if CONFIG_VAAPI |
|
case AV_HWDEVICE_TYPE_VAAPI: |
|
{ |
|
AVVAAPIFramesContext *src_hwctx = src_ctx->hwctx; |
|
s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces, |
|
sizeof(*s->surfaces_internal)); |
|
if (!s->surfaces_internal) |
|
return AVERROR(ENOMEM); |
|
for (i = 0; i < src_hwctx->nb_surfaces; i++) { |
|
qsv_init_surface(dst_ctx, &s->surfaces_internal[i]); |
|
s->surfaces_internal[i].Data.MemId = src_hwctx->surface_ids + i; |
|
} |
|
dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces; |
|
dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET; |
|
} |
|
break; |
|
#endif |
|
#if CONFIG_DXVA2 |
|
case AV_HWDEVICE_TYPE_DXVA2: |
|
{ |
|
AVDXVA2FramesContext *src_hwctx = src_ctx->hwctx; |
|
s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces, |
|
sizeof(*s->surfaces_internal)); |
|
if (!s->surfaces_internal) |
|
return AVERROR(ENOMEM); |
|
for (i = 0; i < src_hwctx->nb_surfaces; i++) { |
|
qsv_init_surface(dst_ctx, &s->surfaces_internal[i]); |
|
s->surfaces_internal[i].Data.MemId = (mfxMemId)src_hwctx->surfaces[i]; |
|
} |
|
dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces; |
|
if (src_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget) |
|
dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET; |
|
else |
|
dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET; |
|
} |
|
break; |
|
#endif |
|
default: |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
dst_hwctx->surfaces = s->surfaces_internal; |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_map_to(AVHWFramesContext *dst_ctx, |
|
AVFrame *dst, const AVFrame *src, int flags) |
|
{ |
|
AVQSVFramesContext *hwctx = dst_ctx->hwctx; |
|
int i, err; |
|
|
|
for (i = 0; i < hwctx->nb_surfaces; i++) { |
|
#if CONFIG_VAAPI |
|
if (*(VASurfaceID*)hwctx->surfaces[i].Data.MemId == |
|
(VASurfaceID)(uintptr_t)src->data[3]) |
|
break; |
|
#endif |
|
#if CONFIG_DXVA2 |
|
if ((IDirect3DSurface9*)hwctx->surfaces[i].Data.MemId == |
|
(IDirect3DSurface9*)(uintptr_t)src->data[3]) |
|
break; |
|
#endif |
|
} |
|
if (i >= hwctx->nb_surfaces) { |
|
av_log(dst_ctx, AV_LOG_ERROR, "Trying to map from a surface which " |
|
"is not in the mapped frames context.\n"); |
|
return AVERROR(EINVAL); |
|
} |
|
|
|
err = ff_hwframe_map_create(dst->hw_frames_ctx, |
|
dst, src, NULL, NULL); |
|
if (err) |
|
return err; |
|
|
|
dst->width = src->width; |
|
dst->height = src->height; |
|
dst->data[3] = (uint8_t*)&hwctx->surfaces[i]; |
|
|
|
return 0; |
|
} |
|
|
|
static int qsv_frames_get_constraints(AVHWDeviceContext *ctx, |
|
const void *hwconfig, |
|
AVHWFramesConstraints *constraints) |
|
{ |
|
int i; |
|
|
|
constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_pixel_formats) + 1, |
|
sizeof(*constraints->valid_sw_formats)); |
|
if (!constraints->valid_sw_formats) |
|
return AVERROR(ENOMEM); |
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) |
|
constraints->valid_sw_formats[i] = supported_pixel_formats[i].pix_fmt; |
|
constraints->valid_sw_formats[FF_ARRAY_ELEMS(supported_pixel_formats)] = AV_PIX_FMT_NONE; |
|
|
|
constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats)); |
|
if (!constraints->valid_hw_formats) |
|
return AVERROR(ENOMEM); |
|
|
|
constraints->valid_hw_formats[0] = AV_PIX_FMT_QSV; |
|
constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE; |
|
|
|
return 0; |
|
} |
|
|
|
static void qsv_device_free(AVHWDeviceContext *ctx) |
|
{ |
|
AVQSVDeviceContext *hwctx = ctx->hwctx; |
|
QSVDevicePriv *priv = ctx->user_opaque; |
|
|
|
if (hwctx->session) |
|
MFXClose(hwctx->session); |
|
|
|
av_buffer_unref(&priv->child_device_ctx); |
|
av_freep(&priv); |
|
} |
|
|
|
static mfxIMPL choose_implementation(const char *device) |
|
{ |
|
static const struct { |
|
const char *name; |
|
mfxIMPL impl; |
|
} impl_map[] = { |
|
{ "auto", MFX_IMPL_AUTO }, |
|
{ "sw", MFX_IMPL_SOFTWARE }, |
|
{ "hw", MFX_IMPL_HARDWARE }, |
|
{ "auto_any", MFX_IMPL_AUTO_ANY }, |
|
{ "hw_any", MFX_IMPL_HARDWARE_ANY }, |
|
{ "hw2", MFX_IMPL_HARDWARE2 }, |
|
{ "hw3", MFX_IMPL_HARDWARE3 }, |
|
{ "hw4", MFX_IMPL_HARDWARE4 }, |
|
}; |
|
|
|
mfxIMPL impl = MFX_IMPL_AUTO_ANY; |
|
int i; |
|
|
|
if (device) { |
|
for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++) |
|
if (!strcmp(device, impl_map[i].name)) { |
|
impl = impl_map[i].impl; |
|
break; |
|
} |
|
if (i == FF_ARRAY_ELEMS(impl_map)) |
|
impl = strtol(device, NULL, 0); |
|
} |
|
|
|
return impl; |
|
} |
|
|
|
static int qsv_device_derive_from_child(AVHWDeviceContext *ctx, |
|
mfxIMPL implementation, |
|
AVHWDeviceContext *child_device_ctx, |
|
int flags) |
|
{ |
|
AVQSVDeviceContext *hwctx = ctx->hwctx; |
|
QSVDeviceContext *s = ctx->internal->priv; |
|
|
|
mfxVersion ver = { { 3, 1 } }; |
|
mfxHDL handle; |
|
mfxHandleType handle_type; |
|
mfxStatus err; |
|
int ret; |
|
|
|
switch (child_device_ctx->type) { |
|
#if CONFIG_VAAPI |
|
case AV_HWDEVICE_TYPE_VAAPI: |
|
{ |
|
AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx; |
|
handle_type = MFX_HANDLE_VA_DISPLAY; |
|
handle = (mfxHDL)child_device_hwctx->display; |
|
} |
|
break; |
|
#endif |
|
#if CONFIG_DXVA2 |
|
case AV_HWDEVICE_TYPE_DXVA2: |
|
{ |
|
AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx; |
|
handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER; |
|
handle = (mfxHDL)child_device_hwctx->devmgr; |
|
} |
|
break; |
|
#endif |
|
default: |
|
ret = AVERROR(ENOSYS); |
|
goto fail; |
|
} |
|
|
|
err = MFXInit(implementation, &ver, &hwctx->session); |
|
if (err != MFX_ERR_NONE) { |
|
av_log(ctx, AV_LOG_ERROR, "Error initializing an MFX session: " |
|
"%d.\n", err); |
|
ret = AVERROR_UNKNOWN; |
|
goto fail; |
|
} |
|
|
|
err = MFXVideoCORE_SetHandle(hwctx->session, handle_type, handle); |
|
if (err != MFX_ERR_NONE) { |
|
av_log(ctx, AV_LOG_ERROR, "Error setting child device handle: " |
|
"%d\n", err); |
|
ret = AVERROR_UNKNOWN; |
|
goto fail; |
|
} |
|
|
|
ret = qsv_device_init(ctx); |
|
if (ret < 0) |
|
goto fail; |
|
if (s->handle_type != handle_type) { |
|
av_log(ctx, AV_LOG_ERROR, "Error in child device handle setup: " |
|
"type mismatch (%d != %d).\n", s->handle_type, handle_type); |
|
err = AVERROR_UNKNOWN; |
|
goto fail; |
|
} |
|
|
|
return 0; |
|
|
|
fail: |
|
if (hwctx->session) |
|
MFXClose(hwctx->session); |
|
return ret; |
|
} |
|
|
|
static int qsv_device_derive(AVHWDeviceContext *ctx, |
|
AVHWDeviceContext *child_device_ctx, int flags) |
|
{ |
|
return qsv_device_derive_from_child(ctx, MFX_IMPL_HARDWARE_ANY, |
|
child_device_ctx, flags); |
|
} |
|
|
|
static int qsv_device_create(AVHWDeviceContext *ctx, const char *device, |
|
AVDictionary *opts, int flags) |
|
{ |
|
QSVDevicePriv *priv; |
|
enum AVHWDeviceType child_device_type; |
|
AVHWDeviceContext *child_device; |
|
AVDictionaryEntry *e; |
|
|
|
mfxIMPL impl; |
|
int ret; |
|
|
|
priv = av_mallocz(sizeof(*priv)); |
|
if (!priv) |
|
return AVERROR(ENOMEM); |
|
|
|
ctx->user_opaque = priv; |
|
ctx->free = qsv_device_free; |
|
|
|
e = av_dict_get(opts, "child_device", NULL, 0); |
|
|
|
if (CONFIG_VAAPI) |
|
child_device_type = AV_HWDEVICE_TYPE_VAAPI; |
|
else if (CONFIG_DXVA2) |
|
child_device_type = AV_HWDEVICE_TYPE_DXVA2; |
|
else { |
|
av_log(ctx, AV_LOG_ERROR, "No supported child device type is enabled\n"); |
|
return AVERROR(ENOSYS); |
|
} |
|
|
|
ret = av_hwdevice_ctx_create(&priv->child_device_ctx, child_device_type, |
|
e ? e->value : NULL, NULL, 0); |
|
if (ret < 0) |
|
return ret; |
|
|
|
child_device = (AVHWDeviceContext*)priv->child_device_ctx->data; |
|
|
|
impl = choose_implementation(device); |
|
|
|
return qsv_device_derive_from_child(ctx, impl, child_device, 0); |
|
} |
|
|
|
const HWContextType ff_hwcontext_type_qsv = { |
|
.type = AV_HWDEVICE_TYPE_QSV, |
|
.name = "QSV", |
|
|
|
.device_hwctx_size = sizeof(AVQSVDeviceContext), |
|
.device_priv_size = sizeof(QSVDeviceContext), |
|
.frames_hwctx_size = sizeof(AVQSVFramesContext), |
|
.frames_priv_size = sizeof(QSVFramesContext), |
|
|
|
.device_create = qsv_device_create, |
|
.device_derive = qsv_device_derive, |
|
.device_init = qsv_device_init, |
|
.frames_get_constraints = qsv_frames_get_constraints, |
|
.frames_init = qsv_frames_init, |
|
.frames_uninit = qsv_frames_uninit, |
|
.frames_get_buffer = qsv_get_buffer, |
|
.transfer_get_formats = qsv_transfer_get_formats, |
|
.transfer_data_to = qsv_transfer_data_to, |
|
.transfer_data_from = qsv_transfer_data_from, |
|
.map_to = qsv_map_to, |
|
.map_from = qsv_map_from, |
|
.frames_derive_to = qsv_frames_derive_to, |
|
.frames_derive_from = qsv_frames_derive_from, |
|
|
|
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_QSV, AV_PIX_FMT_NONE }, |
|
};
|
|
|