git.sesse.net Git - ffmpeg/blob - 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 = link->format;
 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 av_cold 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]->outcfg.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]->incfg.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     },
 402     {
 403         .name          = "overlay",
 404         .type          = AVMEDIA_TYPE_VIDEO,
 405         .config_props  = config_overlay_input,
 406     },
 407     { NULL }
 408 };
 409
 410 static const AVFilterPad overlay_qsv_outputs[] = {
 411     {
 412         .name          = "default",
 413         .type          = AVMEDIA_TYPE_VIDEO,
 414         .config_props  = config_output,
 415     },
 416     { NULL }
 417 };
 418
 419 const AVFilter ff_vf_overlay_qsv = {
 420     .name           = "overlay_qsv",
 421     .description    = NULL_IF_CONFIG_SMALL("Quick Sync Video overlay."),
 422     .priv_size      = sizeof(QSVOverlayContext),
 423     .query_formats  = overlay_qsv_query_formats,
 424     .preinit        = overlay_qsv_framesync_preinit,
 425     .init           = overlay_qsv_init,
 426     .uninit         = overlay_qsv_uninit,
 427     .activate       = activate,
 428     .inputs         = overlay_qsv_inputs,
 429     .outputs        = overlay_qsv_outputs,
 430     .priv_class     = &overlay_qsv_class,
 431     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 432 };