2 * This file is part of FFmpeg.
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * A hardware accelerated overlay filter based on Intel Quick Sync Video VPP
24 #include "libavutil/opt.h"
25 #include "libavutil/common.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/eval.h"
28 #include "libavutil/hwcontext.h"
29 #include "libavutil/avstring.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/mathematics.h"
39 #include "framesync.h"
45 #define OFFSET(x) offsetof(QSVOverlayContext, x)
46 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
53 VAR_OVERLAY_X, VAR_OX,
54 VAR_OVERLAY_Y, VAR_OY,
55 VAR_OVERLAY_W, VAR_OW,
56 VAR_OVERLAY_H, VAR_OH,
60 typedef struct QSVOverlayContext {
65 QSVVPPParam qsv_param;
66 mfxExtVPPComposite comp_conf;
67 double var_values[VAR_VARS_NB];
69 char *overlay_ox, *overlay_oy, *overlay_ow, *overlay_oh;
70 uint16_t overlay_alpha, overlay_pixel_alpha;
74 static const char *const var_names[] = {
75 "main_w", "W", /* input width of the main layer */
76 "main_h", "H", /* input height of the main layer */
77 "overlay_iw", /* input width of the overlay layer */
78 "overlay_ih", /* input height of the overlay layer */
79 "overlay_x", "x", /* x position of the overlay layer inside of main */
80 "overlay_y", "y", /* y position of the overlay layer inside of main */
81 "overlay_w", "w", /* output width of overlay layer */
82 "overlay_h", "h", /* output height of overlay layer */
86 static const AVOption overlay_qsv_options[] = {
87 { "x", "Overlay x position", OFFSET(overlay_ox), AV_OPT_TYPE_STRING, { .str="0"}, 0, 255, .flags = FLAGS},
88 { "y", "Overlay y position", OFFSET(overlay_oy), AV_OPT_TYPE_STRING, { .str="0"}, 0, 255, .flags = FLAGS},
89 { "w", "Overlay width", OFFSET(overlay_ow), AV_OPT_TYPE_STRING, { .str="overlay_iw"}, 0, 255, .flags = FLAGS},
90 { "h", "Overlay height", OFFSET(overlay_oh), AV_OPT_TYPE_STRING, { .str="overlay_ih*w/overlay_iw"}, 0, 255, .flags = FLAGS},
91 { "alpha", "Overlay global alpha", OFFSET(overlay_alpha), AV_OPT_TYPE_INT, { .i64 = 255}, 0, 255, .flags = FLAGS},
92 { "eof_action", "Action to take when encountering EOF from secondary input ",
93 OFFSET(fs.opt_eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT },
94 EOF_ACTION_REPEAT, EOF_ACTION_PASS, .flags = FLAGS, "eof_action" },
95 { "repeat", "Repeat the previous frame.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_REPEAT }, .flags = FLAGS, "eof_action" },
96 { "endall", "End both streams.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ENDALL }, .flags = FLAGS, "eof_action" },
97 { "pass", "Pass through the main input.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS }, .flags = FLAGS, "eof_action" },
98 { "shortest", "force termination when the shortest input terminates", OFFSET(fs.opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
99 { "repeatlast", "repeat overlay of the last overlay frame", OFFSET(fs.opt_repeatlast), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
103 FRAMESYNC_DEFINE_CLASS(overlay_qsv, QSVOverlayContext, fs);
105 static int eval_expr(AVFilterContext *ctx)
107 QSVOverlayContext *vpp = ctx->priv;
108 double *var_values = vpp->var_values;
110 AVExpr *ox_expr = NULL, *oy_expr = NULL;
111 AVExpr *ow_expr = NULL, *oh_expr = NULL;
113 #define PASS_EXPR(e, s) {\
114 ret = av_expr_parse(&e, s, var_names, NULL, NULL, NULL, NULL, 0, ctx); \
116 av_log(ctx, AV_LOG_ERROR, "Error when passing '%s'.\n", s);\
120 PASS_EXPR(ox_expr, vpp->overlay_ox);
121 PASS_EXPR(oy_expr, vpp->overlay_oy);
122 PASS_EXPR(ow_expr, vpp->overlay_ow);
123 PASS_EXPR(oh_expr, vpp->overlay_oh);
126 var_values[VAR_OVERLAY_W] =
127 var_values[VAR_OW] = av_expr_eval(ow_expr, var_values, NULL);
128 var_values[VAR_OVERLAY_H] =
129 var_values[VAR_OH] = av_expr_eval(oh_expr, var_values, NULL);
131 /* calc again in case ow is relative to oh */
132 var_values[VAR_OVERLAY_W] =
133 var_values[VAR_OW] = av_expr_eval(ow_expr, var_values, NULL);
135 var_values[VAR_OVERLAY_X] =
136 var_values[VAR_OX] = av_expr_eval(ox_expr, var_values, NULL);
137 var_values[VAR_OVERLAY_Y] =
138 var_values[VAR_OY] = av_expr_eval(oy_expr, var_values, NULL);
140 /* calc again in case ox is relative to oy */
141 var_values[VAR_OVERLAY_X] =
142 var_values[VAR_OX] = av_expr_eval(ox_expr, var_values, NULL);
144 /* calc overlay_w and overlay_h again incase relative to ox,oy */
145 var_values[VAR_OVERLAY_W] =
146 var_values[VAR_OW] = av_expr_eval(ow_expr, var_values, NULL);
147 var_values[VAR_OVERLAY_H] =
148 var_values[VAR_OH] = av_expr_eval(oh_expr, var_values, NULL);
149 var_values[VAR_OVERLAY_W] =
150 var_values[VAR_OW] = av_expr_eval(ow_expr, var_values, NULL);
153 av_expr_free(ox_expr);
154 av_expr_free(oy_expr);
155 av_expr_free(ow_expr);
156 av_expr_free(oh_expr);
161 static int have_alpha_planar(AVFilterLink *link)
163 enum AVPixelFormat pix_fmt;
164 const AVPixFmtDescriptor *desc;
165 AVHWFramesContext *fctx;
167 if (link->format == AV_PIX_FMT_QSV) {
168 fctx = (AVHWFramesContext *)link->hw_frames_ctx->data;
169 pix_fmt = fctx->sw_format;
172 desc = av_pix_fmt_desc_get(pix_fmt);
176 return !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
179 static int config_main_input(AVFilterLink *inlink)
181 AVFilterContext *ctx = inlink->dst;
182 QSVOverlayContext *vpp = ctx->priv;
183 mfxVPPCompInputStream *st = &vpp->comp_conf.InputStream[0];
185 av_log(ctx, AV_LOG_DEBUG, "Input[%d] is of %s.\n", FF_INLINK_IDX(inlink),
186 av_get_pix_fmt_name(inlink->format));
188 vpp->var_values[VAR_MAIN_iW] =
189 vpp->var_values[VAR_MW] = inlink->w;
190 vpp->var_values[VAR_MAIN_iH] =
191 vpp->var_values[VAR_MH] = inlink->h;
195 st->DstW = inlink->w;
196 st->DstH = inlink->h;
197 st->GlobalAlphaEnable = 0;
198 st->PixelAlphaEnable = 0;
203 static int config_overlay_input(AVFilterLink *inlink)
205 AVFilterContext *ctx = inlink->dst;
206 QSVOverlayContext *vpp = ctx->priv;
207 mfxVPPCompInputStream *st = &vpp->comp_conf.InputStream[1];
210 av_log(ctx, AV_LOG_DEBUG, "Input[%d] is of %s.\n", FF_INLINK_IDX(inlink),
211 av_get_pix_fmt_name(inlink->format));
213 vpp->var_values[VAR_OVERLAY_iW] = inlink->w;
214 vpp->var_values[VAR_OVERLAY_iH] = inlink->h;
216 ret = eval_expr(ctx);
220 st->DstX = vpp->var_values[VAR_OX];
221 st->DstY = vpp->var_values[VAR_OY];
222 st->DstW = vpp->var_values[VAR_OW];
223 st->DstH = vpp->var_values[VAR_OH];
224 st->GlobalAlpha = vpp->overlay_alpha;
225 st->GlobalAlphaEnable = (st->GlobalAlpha < 255);
226 st->PixelAlphaEnable = have_alpha_planar(inlink);
231 static int process_frame(FFFrameSync *fs)
233 AVFilterContext *ctx = fs->parent;
234 QSVOverlayContext *s = fs->opaque;
235 AVFrame *frame = NULL;
238 for (i = 0; i < ctx->nb_inputs; i++) {
239 ret = ff_framesync_get_frame(fs, i, &frame, 0);
241 ret = ff_qsvvpp_filter_frame(s->qsv, ctx->inputs[i], frame);
242 if (ret < 0 && ret != AVERROR(EAGAIN))
249 static int init_framesync(AVFilterContext *ctx)
251 QSVOverlayContext *s = ctx->priv;
254 s->fs.on_event = process_frame;
256 ret = ff_framesync_init(&s->fs, ctx, ctx->nb_inputs);
260 for (i = 0; i < ctx->nb_inputs; i++) {
261 FFFrameSyncIn *in = &s->fs.in[i];
262 in->before = EXT_STOP;
263 in->after = EXT_INFINITY;
264 in->sync = i ? 1 : 2;
265 in->time_base = ctx->inputs[i]->time_base;
268 return ff_framesync_configure(&s->fs);
271 static int config_output(AVFilterLink *outlink)
273 AVFilterContext *ctx = outlink->src;
274 QSVOverlayContext *vpp = ctx->priv;
275 AVFilterLink *in0 = ctx->inputs[0];
276 AVFilterLink *in1 = ctx->inputs[1];
279 av_log(ctx, AV_LOG_DEBUG, "Output is of %s.\n", av_get_pix_fmt_name(outlink->format));
280 if ((in0->format == AV_PIX_FMT_QSV && in1->format != AV_PIX_FMT_QSV) ||
281 (in0->format != AV_PIX_FMT_QSV && in1->format == AV_PIX_FMT_QSV)) {
282 av_log(ctx, AV_LOG_ERROR, "Mixing hardware and software pixel formats is not supported.\n");
283 return AVERROR(EINVAL);
284 } else if (in0->format == AV_PIX_FMT_QSV) {
285 AVHWFramesContext *hw_frame0 = (AVHWFramesContext *)in0->hw_frames_ctx->data;
286 AVHWFramesContext *hw_frame1 = (AVHWFramesContext *)in1->hw_frames_ctx->data;
288 if (hw_frame0->device_ctx != hw_frame1->device_ctx) {
289 av_log(ctx, AV_LOG_ERROR, "Inputs with different underlying QSV devices are forbidden.\n");
290 return AVERROR(EINVAL);
294 outlink->w = vpp->var_values[VAR_MW];
295 outlink->h = vpp->var_values[VAR_MH];
296 outlink->frame_rate = in0->frame_rate;
297 outlink->time_base = av_inv_q(outlink->frame_rate);
299 ret = init_framesync(ctx);
303 return ff_qsvvpp_create(ctx, &vpp->qsv, &vpp->qsv_param);
307 * Callback for qsvvpp
308 * @Note: qsvvpp composition does not generate PTS for result frame.
309 * so we assign the PTS from framesync to the output frame.
312 static int filter_callback(AVFilterLink *outlink, AVFrame *frame)
314 QSVOverlayContext *s = outlink->src->priv;
315 frame->pts = av_rescale_q(s->fs.pts,
316 s->fs.time_base, outlink->time_base);
317 return ff_filter_frame(outlink, frame);
321 static int overlay_qsv_init(AVFilterContext *ctx)
323 QSVOverlayContext *vpp = ctx->priv;
325 /* fill composite config */
326 vpp->comp_conf.Header.BufferId = MFX_EXTBUFF_VPP_COMPOSITE;
327 vpp->comp_conf.Header.BufferSz = sizeof(vpp->comp_conf);
328 vpp->comp_conf.NumInputStream = ctx->nb_inputs;
329 vpp->comp_conf.InputStream = av_mallocz_array(ctx->nb_inputs,
330 sizeof(*vpp->comp_conf.InputStream));
331 if (!vpp->comp_conf.InputStream)
332 return AVERROR(ENOMEM);
334 /* initialize QSVVPP params */
335 vpp->qsv_param.filter_frame = filter_callback;
336 vpp->qsv_param.ext_buf = av_mallocz(sizeof(*vpp->qsv_param.ext_buf));
337 if (!vpp->qsv_param.ext_buf)
338 return AVERROR(ENOMEM);
340 vpp->qsv_param.ext_buf[0] = (mfxExtBuffer *)&vpp->comp_conf;
341 vpp->qsv_param.num_ext_buf = 1;
342 vpp->qsv_param.out_sw_format = AV_PIX_FMT_NV12;
343 vpp->qsv_param.num_crop = 0;
348 static void overlay_qsv_uninit(AVFilterContext *ctx)
350 QSVOverlayContext *vpp = ctx->priv;
352 ff_qsvvpp_free(&vpp->qsv);
353 ff_framesync_uninit(&vpp->fs);
354 av_freep(&vpp->comp_conf.InputStream);
355 av_freep(&vpp->qsv_param.ext_buf);
358 static int activate(AVFilterContext *ctx)
360 QSVOverlayContext *s = ctx->priv;
361 return ff_framesync_activate(&s->fs);
364 static int overlay_qsv_query_formats(AVFilterContext *ctx)
369 static const enum AVPixelFormat main_in_fmts[] = {
377 static const enum AVPixelFormat out_pix_fmts[] = {
383 for (i = 0; i < ctx->nb_inputs; i++) {
384 ret = ff_formats_ref(ff_make_format_list(main_in_fmts), &ctx->inputs[i]->out_formats);
389 ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats);
396 static const AVFilterPad overlay_qsv_inputs[] = {
399 .type = AVMEDIA_TYPE_VIDEO,
400 .config_props = config_main_input,
405 .type = AVMEDIA_TYPE_VIDEO,
406 .config_props = config_overlay_input,
412 static const AVFilterPad overlay_qsv_outputs[] = {
415 .type = AVMEDIA_TYPE_VIDEO,
416 .config_props = config_output,
421 AVFilter ff_vf_overlay_qsv = {
422 .name = "overlay_qsv",
423 .description = NULL_IF_CONFIG_SMALL("Quick Sync Video overlay."),
424 .priv_size = sizeof(QSVOverlayContext),
425 .query_formats = overlay_qsv_query_formats,
426 .preinit = overlay_qsv_framesync_preinit,
427 .init = overlay_qsv_init,
428 .uninit = overlay_qsv_uninit,
429 .activate = activate,
430 .inputs = overlay_qsv_inputs,
431 .outputs = overlay_qsv_outputs,
432 .priv_class = &overlay_qsv_class,
433 .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,