d865783b6c
For filters based on framesync, the input frame was managed by framesync, so we should not directly keep and destroy it, instead we make a clone of it here, or else double-free will occur. But for other filters not based on framesync, we still need to free the input frame inside filter_frame. Signed-off-by: Ruiling Song <ruiling.song@intel.com>
430 lines
14 KiB
C
430 lines
14 KiB
C
/*
|
|
* 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
|
|
*/
|
|
|
|
/**
|
|
** @file
|
|
** Hardware accelerated common filters based on Intel Quick Sync Video VPP
|
|
**/
|
|
|
|
#include <float.h>
|
|
|
|
#include "libavutil/opt.h"
|
|
#include "libavutil/eval.h"
|
|
#include "libavutil/avassert.h"
|
|
#include "libavutil/pixdesc.h"
|
|
#include "libavutil/mathematics.h"
|
|
|
|
#include "formats.h"
|
|
#include "internal.h"
|
|
#include "avfilter.h"
|
|
#include "libavcodec/avcodec.h"
|
|
#include "libavformat/avformat.h"
|
|
|
|
#include "qsvvpp.h"
|
|
|
|
#define OFFSET(x) offsetof(VPPContext, x)
|
|
#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
|
|
|
|
/* number of video enhancement filters */
|
|
#define ENH_FILTERS_COUNT (5)
|
|
|
|
typedef struct VPPContext{
|
|
const AVClass *class;
|
|
|
|
QSVVPPContext *qsv;
|
|
|
|
/* Video Enhancement Algorithms */
|
|
mfxExtVPPDeinterlacing deinterlace_conf;
|
|
mfxExtVPPFrameRateConversion frc_conf;
|
|
mfxExtVPPDenoise denoise_conf;
|
|
mfxExtVPPDetail detail_conf;
|
|
mfxExtVPPProcAmp procamp_conf;
|
|
|
|
int out_width;
|
|
int out_height;
|
|
|
|
AVRational framerate; /* target framerate */
|
|
int use_frc; /* use framerate conversion */
|
|
int deinterlace; /* deinterlace mode : 0=off, 1=bob, 2=advanced */
|
|
int denoise; /* Enable Denoise algorithm. Value [0, 100] */
|
|
int detail; /* Enable Detail Enhancement algorithm. */
|
|
/* Level is the optional, value [0, 100] */
|
|
int use_crop; /* 1 = use crop; 0=none */
|
|
int crop_w;
|
|
int crop_h;
|
|
int crop_x;
|
|
int crop_y;
|
|
|
|
/* param for the procamp */
|
|
int procamp; /* enable procamp */
|
|
float hue;
|
|
float saturation;
|
|
float contrast;
|
|
float brightness;
|
|
|
|
char *cx, *cy, *cw, *ch;
|
|
char *ow, *oh;
|
|
} VPPContext;
|
|
|
|
static const AVOption options[] = {
|
|
{ "deinterlace", "deinterlace mode: 0=off, 1=bob, 2=advanced", OFFSET(deinterlace), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, MFX_DEINTERLACING_ADVANCED, .flags = FLAGS, "deinterlace" },
|
|
{ "bob", "Bob deinterlace mode.", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_DEINTERLACING_BOB }, .flags = FLAGS, "deinterlace" },
|
|
{ "advanced", "Advanced deinterlace mode. ", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_DEINTERLACING_ADVANCED }, .flags = FLAGS, "deinterlace" },
|
|
|
|
{ "denoise", "denoise level [0, 100]", OFFSET(denoise), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, .flags = FLAGS },
|
|
{ "detail", "enhancement level [0, 100]", OFFSET(detail), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, .flags = FLAGS },
|
|
{ "framerate", "output framerate", OFFSET(framerate), AV_OPT_TYPE_RATIONAL, { .dbl = 0.0 },0, DBL_MAX, .flags = FLAGS },
|
|
{ "procamp", "Enable ProcAmp", OFFSET(procamp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = FLAGS},
|
|
{ "hue", "ProcAmp hue", OFFSET(hue), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, -180.0, 180.0, .flags = FLAGS},
|
|
{ "saturation", "ProcAmp saturation", OFFSET(saturation), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
|
|
{ "contrast", "ProcAmp contrast", OFFSET(contrast), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
|
|
{ "brightness", "ProcAmp brightness", OFFSET(brightness), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, -100.0, 100.0, .flags = FLAGS},
|
|
|
|
{ "cw", "set the width crop area expression", OFFSET(cw), AV_OPT_TYPE_STRING, { .str = "iw" }, CHAR_MIN, CHAR_MAX, FLAGS },
|
|
{ "ch", "set the height crop area expression", OFFSET(ch), AV_OPT_TYPE_STRING, { .str = "ih" }, CHAR_MIN, CHAR_MAX, FLAGS },
|
|
{ "cx", "set the x crop area expression", OFFSET(cx), AV_OPT_TYPE_STRING, { .str = "(in_w-out_w)/2" }, CHAR_MIN, CHAR_MAX, FLAGS },
|
|
{ "cy", "set the y crop area expression", OFFSET(cy), AV_OPT_TYPE_STRING, { .str = "(in_h-out_h)/2" }, CHAR_MIN, CHAR_MAX, FLAGS },
|
|
|
|
{ "w", "Output video width", OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
|
|
{ "width", "Output video width", OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
|
|
{ "h", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
|
|
{ "height", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
|
|
{ NULL }
|
|
};
|
|
|
|
static const char *const var_names[] = {
|
|
"iw", "in_w",
|
|
"ih", "in_h",
|
|
"ow", "out_w", "w",
|
|
"oh", "out_h", "h",
|
|
"cw",
|
|
"ch",
|
|
"cx",
|
|
"cy",
|
|
NULL
|
|
};
|
|
|
|
enum var_name {
|
|
VAR_iW, VAR_IN_W,
|
|
VAR_iH, VAR_IN_H,
|
|
VAR_oW, VAR_OUT_W, VAR_W,
|
|
VAR_oH, VAR_OUT_H, VAR_H,
|
|
CW,
|
|
CH,
|
|
CX,
|
|
CY,
|
|
VAR_VARS_NB
|
|
};
|
|
|
|
static int eval_expr(AVFilterContext *ctx)
|
|
{
|
|
#define PASS_EXPR(e, s) {\
|
|
ret = av_expr_parse(&e, s, var_names, NULL, NULL, NULL, NULL, 0, ctx); \
|
|
if (ret < 0) {\
|
|
av_log(ctx, AV_LOG_ERROR, "Error when passing '%s'.\n", s);\
|
|
goto release;\
|
|
}\
|
|
}
|
|
#define CALC_EXPR(e, v, i) {\
|
|
i = v = av_expr_eval(e, var_values, NULL); \
|
|
}
|
|
VPPContext *vpp = ctx->priv;
|
|
double var_values[VAR_VARS_NB] = { NAN };
|
|
AVExpr *w_expr = NULL, *h_expr = NULL;
|
|
AVExpr *cw_expr = NULL, *ch_expr = NULL;
|
|
AVExpr *cx_expr = NULL, *cy_expr = NULL;
|
|
int ret = 0;
|
|
|
|
PASS_EXPR(cw_expr, vpp->cw);
|
|
PASS_EXPR(ch_expr, vpp->ch);
|
|
|
|
PASS_EXPR(w_expr, vpp->ow);
|
|
PASS_EXPR(h_expr, vpp->oh);
|
|
|
|
PASS_EXPR(cx_expr, vpp->cx);
|
|
PASS_EXPR(cy_expr, vpp->cy);
|
|
|
|
var_values[VAR_iW] =
|
|
var_values[VAR_IN_W] = ctx->inputs[0]->w;
|
|
|
|
var_values[VAR_iH] =
|
|
var_values[VAR_IN_H] = ctx->inputs[0]->h;
|
|
|
|
/* crop params */
|
|
CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
|
|
CALC_EXPR(ch_expr, var_values[CH], vpp->crop_h);
|
|
|
|
/* calc again in case cw is relative to ch */
|
|
CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
|
|
|
|
CALC_EXPR(w_expr,
|
|
var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
|
|
vpp->out_width);
|
|
CALC_EXPR(h_expr,
|
|
var_values[VAR_OUT_H] = var_values[VAR_oH] = var_values[VAR_H],
|
|
vpp->out_height);
|
|
|
|
/* calc again in case ow is relative to oh */
|
|
CALC_EXPR(w_expr,
|
|
var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
|
|
vpp->out_width);
|
|
|
|
|
|
CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
|
|
CALC_EXPR(cy_expr, var_values[CY], vpp->crop_y);
|
|
|
|
/* calc again in case cx is relative to cy */
|
|
CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
|
|
|
|
if ((vpp->crop_w != var_values[VAR_iW]) || (vpp->crop_h != var_values[VAR_iH]))
|
|
vpp->use_crop = 1;
|
|
|
|
release:
|
|
av_expr_free(w_expr);
|
|
av_expr_free(h_expr);
|
|
av_expr_free(cw_expr);
|
|
av_expr_free(ch_expr);
|
|
av_expr_free(cx_expr);
|
|
av_expr_free(cy_expr);
|
|
#undef PASS_EXPR
|
|
#undef CALC_EXPR
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int config_input(AVFilterLink *inlink)
|
|
{
|
|
AVFilterContext *ctx = inlink->dst;
|
|
VPPContext *vpp = ctx->priv;
|
|
int ret;
|
|
|
|
if (vpp->framerate.den == 0 || vpp->framerate.num == 0)
|
|
vpp->framerate = inlink->frame_rate;
|
|
|
|
if (av_cmp_q(vpp->framerate, inlink->frame_rate))
|
|
vpp->use_frc = 1;
|
|
|
|
ret = eval_expr(ctx);
|
|
if (ret != 0) {
|
|
av_log(ctx, AV_LOG_ERROR, "Fail to eval expr.\n");
|
|
return ret;
|
|
}
|
|
|
|
if (vpp->out_height == 0 || vpp->out_width == 0) {
|
|
vpp->out_width = inlink->w;
|
|
vpp->out_height = inlink->h;
|
|
}
|
|
|
|
if (vpp->use_crop) {
|
|
vpp->crop_x = FFMAX(vpp->crop_x, 0);
|
|
vpp->crop_y = FFMAX(vpp->crop_y, 0);
|
|
|
|
if(vpp->crop_w + vpp->crop_x > inlink->w)
|
|
vpp->crop_x = inlink->w - vpp->crop_w;
|
|
if(vpp->crop_h + vpp->crop_y > inlink->h)
|
|
vpp->crop_y = inlink->h - vpp->crop_h;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int config_output(AVFilterLink *outlink)
|
|
{
|
|
AVFilterContext *ctx = outlink->src;
|
|
VPPContext *vpp = ctx->priv;
|
|
QSVVPPParam param = { NULL };
|
|
QSVVPPCrop crop = { 0 };
|
|
mfxExtBuffer *ext_buf[ENH_FILTERS_COUNT];
|
|
AVFilterLink *inlink = ctx->inputs[0];
|
|
|
|
outlink->w = vpp->out_width;
|
|
outlink->h = vpp->out_height;
|
|
outlink->frame_rate = vpp->framerate;
|
|
outlink->time_base = av_inv_q(vpp->framerate);
|
|
|
|
param.filter_frame = NULL;
|
|
param.out_sw_format = AV_PIX_FMT_NV12;
|
|
param.num_ext_buf = 0;
|
|
param.ext_buf = ext_buf;
|
|
|
|
if (vpp->use_crop) {
|
|
crop.in_idx = 0;
|
|
crop.x = vpp->crop_x;
|
|
crop.y = vpp->crop_y;
|
|
crop.w = vpp->crop_w;
|
|
crop.h = vpp->crop_h;
|
|
|
|
param.num_crop = 1;
|
|
param.crop = &crop;
|
|
}
|
|
|
|
if (vpp->deinterlace) {
|
|
memset(&vpp->deinterlace_conf, 0, sizeof(mfxExtVPPDeinterlacing));
|
|
vpp->deinterlace_conf.Header.BufferId = MFX_EXTBUFF_VPP_DEINTERLACING;
|
|
vpp->deinterlace_conf.Header.BufferSz = sizeof(mfxExtVPPDeinterlacing);
|
|
vpp->deinterlace_conf.Mode = vpp->deinterlace == 1 ?
|
|
MFX_DEINTERLACING_BOB : MFX_DEINTERLACING_ADVANCED;
|
|
|
|
param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->deinterlace_conf;
|
|
}
|
|
|
|
if (vpp->use_frc) {
|
|
memset(&vpp->frc_conf, 0, sizeof(mfxExtVPPFrameRateConversion));
|
|
vpp->frc_conf.Header.BufferId = MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION;
|
|
vpp->frc_conf.Header.BufferSz = sizeof(mfxExtVPPFrameRateConversion);
|
|
vpp->frc_conf.Algorithm = MFX_FRCALGM_DISTRIBUTED_TIMESTAMP;
|
|
|
|
param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->frc_conf;
|
|
}
|
|
|
|
if (vpp->denoise) {
|
|
memset(&vpp->denoise_conf, 0, sizeof(mfxExtVPPDenoise));
|
|
vpp->denoise_conf.Header.BufferId = MFX_EXTBUFF_VPP_DENOISE;
|
|
vpp->denoise_conf.Header.BufferSz = sizeof(mfxExtVPPDenoise);
|
|
vpp->denoise_conf.DenoiseFactor = vpp->denoise;
|
|
|
|
param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->denoise_conf;
|
|
}
|
|
|
|
if (vpp->detail) {
|
|
memset(&vpp->detail_conf, 0, sizeof(mfxExtVPPDetail));
|
|
vpp->detail_conf.Header.BufferId = MFX_EXTBUFF_VPP_DETAIL;
|
|
vpp->detail_conf.Header.BufferSz = sizeof(mfxExtVPPDetail);
|
|
vpp->detail_conf.DetailFactor = vpp->detail;
|
|
|
|
param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->detail_conf;
|
|
}
|
|
|
|
if (vpp->procamp) {
|
|
memset(&vpp->procamp_conf, 0, sizeof(mfxExtVPPProcAmp));
|
|
vpp->procamp_conf.Header.BufferId = MFX_EXTBUFF_VPP_PROCAMP;
|
|
vpp->procamp_conf.Header.BufferSz = sizeof(mfxExtVPPProcAmp);
|
|
vpp->procamp_conf.Hue = vpp->hue;
|
|
vpp->procamp_conf.Saturation = vpp->saturation;
|
|
vpp->procamp_conf.Contrast = vpp->contrast;
|
|
vpp->procamp_conf.Brightness = vpp->brightness;
|
|
|
|
param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->procamp_conf;
|
|
}
|
|
|
|
if (vpp->use_frc || vpp->use_crop || vpp->deinterlace || vpp->denoise ||
|
|
vpp->detail || vpp->procamp || inlink->w != outlink->w || inlink->h != outlink->h)
|
|
return ff_qsvvpp_create(ctx, &vpp->qsv, ¶m);
|
|
else {
|
|
av_log(ctx, AV_LOG_VERBOSE, "qsv vpp pass through mode.\n");
|
|
if (inlink->hw_frames_ctx)
|
|
outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
|
|
{
|
|
int ret = 0;
|
|
AVFilterContext *ctx = inlink->dst;
|
|
VPPContext *vpp = inlink->dst->priv;
|
|
AVFilterLink *outlink = ctx->outputs[0];
|
|
|
|
if (vpp->qsv) {
|
|
ret = ff_qsvvpp_filter_frame(vpp->qsv, inlink, picref);
|
|
av_frame_free(&picref);
|
|
} else {
|
|
if (picref->pts != AV_NOPTS_VALUE)
|
|
picref->pts = av_rescale_q(picref->pts, inlink->time_base, outlink->time_base);
|
|
ret = ff_filter_frame(outlink, picref);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int query_formats(AVFilterContext *ctx)
|
|
{
|
|
int ret;
|
|
AVFilterFormats *in_fmts, *out_fmts;
|
|
static const enum AVPixelFormat in_pix_fmts[] = {
|
|
AV_PIX_FMT_YUV420P,
|
|
AV_PIX_FMT_NV12,
|
|
AV_PIX_FMT_YUYV422,
|
|
AV_PIX_FMT_RGB32,
|
|
AV_PIX_FMT_QSV,
|
|
AV_PIX_FMT_NONE
|
|
};
|
|
static const enum AVPixelFormat out_pix_fmts[] = {
|
|
AV_PIX_FMT_NV12,
|
|
AV_PIX_FMT_QSV,
|
|
AV_PIX_FMT_NONE
|
|
};
|
|
|
|
in_fmts = ff_make_format_list(in_pix_fmts);
|
|
out_fmts = ff_make_format_list(out_pix_fmts);
|
|
ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats);
|
|
if (ret < 0)
|
|
return ret;
|
|
ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static av_cold void vpp_uninit(AVFilterContext *ctx)
|
|
{
|
|
VPPContext *vpp = ctx->priv;
|
|
|
|
ff_qsvvpp_free(&vpp->qsv);
|
|
}
|
|
|
|
static const AVClass vpp_class = {
|
|
.class_name = "vpp_qsv",
|
|
.item_name = av_default_item_name,
|
|
.option = options,
|
|
.version = LIBAVUTIL_VERSION_INT,
|
|
};
|
|
|
|
static const AVFilterPad vpp_inputs[] = {
|
|
{
|
|
.name = "default",
|
|
.type = AVMEDIA_TYPE_VIDEO,
|
|
.config_props = config_input,
|
|
.filter_frame = filter_frame,
|
|
},
|
|
{ NULL }
|
|
};
|
|
|
|
static const AVFilterPad vpp_outputs[] = {
|
|
{
|
|
.name = "default",
|
|
.type = AVMEDIA_TYPE_VIDEO,
|
|
.config_props = config_output,
|
|
},
|
|
{ NULL }
|
|
};
|
|
|
|
AVFilter ff_vf_vpp_qsv = {
|
|
.name = "vpp_qsv",
|
|
.description = NULL_IF_CONFIG_SMALL("Quick Sync Video VPP."),
|
|
.priv_size = sizeof(VPPContext),
|
|
.query_formats = query_formats,
|
|
.uninit = vpp_uninit,
|
|
.inputs = vpp_inputs,
|
|
.outputs = vpp_outputs,
|
|
.priv_class = &vpp_class,
|
|
.flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
|
|
};
|