cbs_h264: Fix handling of unknown SEI
[ffmpeg.git] / libavfilter / vf_overlay_qsv.c
1 /*
2  * This file is part of FFmpeg.
3  *
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.
8  *
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.
13  *
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
17  */
18
19 /**
20  * @file
21  * A hardware accelerated overlay filter based on Intel Quick Sync Video VPP
22  */
23
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"
33
34 #include "internal.h"
35 #include "avfilter.h"
36 #include "formats.h"
37 #include "video.h"
38
39 #include "framesync.h"
40 #include "qsvvpp.h"
41
42 #define MAIN    0
43 #define OVERLAY 1
44
45 #define OFFSET(x) offsetof(QSVOverlayContext, x)
46 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
47
48 enum var_name {
49     VAR_MAIN_iW,     VAR_MW,
50     VAR_MAIN_iH,     VAR_MH,
51     VAR_OVERLAY_iW,
52     VAR_OVERLAY_iH,
53     VAR_OVERLAY_X,  VAR_OX,
54     VAR_OVERLAY_Y,  VAR_OY,
55     VAR_OVERLAY_W,  VAR_OW,
56     VAR_OVERLAY_H,  VAR_OH,
57     VAR_VARS_NB
58 };
59
60 typedef struct QSVOverlayContext {
61     const AVClass      *class;
62
63     FFFrameSync fs;
64     QSVVPPContext      *qsv;
65     QSVVPPParam        qsv_param;
66     mfxExtVPPComposite comp_conf;
67     double             var_values[VAR_VARS_NB];
68
69     char     *overlay_ox, *overlay_oy, *overlay_ow, *overlay_oh;
70     uint16_t  overlay_alpha, overlay_pixel_alpha;
71
72 } QSVOverlayContext;
73
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 */
83     NULL
84 };
85
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 },
100     { NULL }
101 };
102
103 FRAMESYNC_DEFINE_CLASS(overlay_qsv, QSVOverlayContext, fs);
104
105 static int eval_expr(AVFilterContext *ctx)
106 {
107     QSVOverlayContext *vpp = ctx->priv;
108     double     *var_values = vpp->var_values;
109     int                ret = 0;
110     AVExpr *ox_expr = NULL, *oy_expr = NULL;
111     AVExpr *ow_expr = NULL, *oh_expr = NULL;
112
113 #define PASS_EXPR(e, s) {\
114     ret = av_expr_parse(&e, s, var_names, NULL, NULL, NULL, NULL, 0, ctx); \
115     if (ret < 0) {\
116         av_log(ctx, AV_LOG_ERROR, "Error when passing '%s'.\n", s);\
117         goto release;\
118     }\
119 }
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);
124 #undef PASS_EXPR
125
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);
130
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);
134
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);
139
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);
143
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);
151
152 release:
153     av_expr_free(ox_expr);
154     av_expr_free(oy_expr);
155     av_expr_free(ow_expr);
156     av_expr_free(oh_expr);
157
158     return ret;
159 }
160
161 static int have_alpha_planar(AVFilterLink *link)
162 {
163     enum AVPixelFormat pix_fmt;
164     const AVPixFmtDescriptor *desc;
165     AVHWFramesContext *fctx;
166
167     if (link->format == AV_PIX_FMT_QSV) {
168         fctx    = (AVHWFramesContext *)link->hw_frames_ctx->data;
169         pix_fmt = fctx->sw_format;
170     }
171
172     desc = av_pix_fmt_desc_get(pix_fmt);
173     if (!desc)
174         return 0;
175
176     return !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
177 }
178
179 static int config_main_input(AVFilterLink *inlink)
180 {
181     AVFilterContext      *ctx = inlink->dst;
182     QSVOverlayContext    *vpp = ctx->priv;
183     mfxVPPCompInputStream *st = &vpp->comp_conf.InputStream[0];
184
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));
187
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;
192
193     st->DstX              = 0;
194     st->DstY              = 0;
195     st->DstW              = inlink->w;
196     st->DstH              = inlink->h;
197     st->GlobalAlphaEnable = 0;
198     st->PixelAlphaEnable  = 0;
199
200     return 0;
201 }
202
203 static int config_overlay_input(AVFilterLink *inlink)
204 {
205     AVFilterContext       *ctx = inlink->dst;
206     QSVOverlayContext     *vpp = ctx->priv;
207     mfxVPPCompInputStream *st  = &vpp->comp_conf.InputStream[1];
208     int                    ret = 0;
209
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));
212
213     vpp->var_values[VAR_OVERLAY_iW] = inlink->w;
214     vpp->var_values[VAR_OVERLAY_iH] = inlink->h;
215
216     ret = eval_expr(ctx);
217     if (ret < 0)
218         return ret;
219
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);
227
228     return 0;
229 }
230
231 static int process_frame(FFFrameSync *fs)
232 {
233     AVFilterContext  *ctx = fs->parent;
234     QSVOverlayContext  *s = fs->opaque;
235     AVFrame        *frame = NULL;
236     int               ret = 0, i;
237
238     for (i = 0; i < ctx->nb_inputs; i++) {
239         ret = ff_framesync_get_frame(fs, i, &frame, 0);
240         if (ret == 0)
241             ret = ff_qsvvpp_filter_frame(s->qsv, ctx->inputs[i], frame);
242         if (ret < 0 && ret != AVERROR(EAGAIN))
243             break;
244     }
245
246     return ret;
247 }
248
249 static int init_framesync(AVFilterContext *ctx)
250 {
251     QSVOverlayContext *s = ctx->priv;
252     int ret, i;
253
254     s->fs.on_event = process_frame;
255     s->fs.opaque   = s;
256     ret = ff_framesync_init(&s->fs, ctx, ctx->nb_inputs);
257     if (ret < 0)
258         return ret;
259
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;
266     }
267
268     return ff_framesync_configure(&s->fs);
269 }
270
271 static int config_output(AVFilterLink *outlink)
272 {
273     AVFilterContext   *ctx = outlink->src;
274     QSVOverlayContext *vpp = ctx->priv;
275     AVFilterLink      *in0 = ctx->inputs[0];
276     AVFilterLink      *in1 = ctx->inputs[1];
277     int ret;
278
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;
287
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);
291         }
292     }
293
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);
298
299     ret = init_framesync(ctx);
300     if (ret < 0)
301         return ret;
302
303     return ff_qsvvpp_create(ctx, &vpp->qsv, &vpp->qsv_param);
304 }
305
306 /*
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.
310  */
311
312 static int filter_callback(AVFilterLink *outlink, AVFrame *frame)
313 {
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);
318 }
319
320
321 static int overlay_qsv_init(AVFilterContext *ctx)
322 {
323     QSVOverlayContext *vpp = ctx->priv;
324
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);
333
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);
339
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;
344
345     return 0;
346 }
347
348 static void overlay_qsv_uninit(AVFilterContext *ctx)
349 {
350     QSVOverlayContext *vpp = ctx->priv;
351
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);
356 }
357
358 static int activate(AVFilterContext *ctx)
359 {
360     QSVOverlayContext *s = ctx->priv;
361     return ff_framesync_activate(&s->fs);
362 }
363
364 static int overlay_qsv_query_formats(AVFilterContext *ctx)
365 {
366     int i;
367     int ret;
368
369     static const enum AVPixelFormat main_in_fmts[] = {
370         AV_PIX_FMT_YUV420P,
371         AV_PIX_FMT_NV12,
372         AV_PIX_FMT_YUYV422,
373         AV_PIX_FMT_RGB32,
374         AV_PIX_FMT_QSV,
375         AV_PIX_FMT_NONE
376     };
377     static const enum AVPixelFormat out_pix_fmts[] = {
378         AV_PIX_FMT_NV12,
379         AV_PIX_FMT_QSV,
380         AV_PIX_FMT_NONE
381     };
382
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);
385         if (ret < 0)
386             return ret;
387     }
388
389     ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats);
390     if (ret < 0)
391         return ret;
392
393     return 0;
394 }
395
396 static const AVFilterPad overlay_qsv_inputs[] = {
397     {
398         .name          = "main",
399         .type          = AVMEDIA_TYPE_VIDEO,
400         .config_props  = config_main_input,
401         .needs_fifo    = 1,
402     },
403     {
404         .name          = "overlay",
405         .type          = AVMEDIA_TYPE_VIDEO,
406         .config_props  = config_overlay_input,
407         .needs_fifo    = 1,
408     },
409     { NULL }
410 };
411
412 static const AVFilterPad overlay_qsv_outputs[] = {
413     {
414         .name          = "default",
415         .type          = AVMEDIA_TYPE_VIDEO,
416         .config_props  = config_output,
417     },
418     { NULL }
419 };
420
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,
434 };