git.sesse.net Git - ffmpeg/blob - libavfilter/vf_vpp_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  ** Hardware accelerated common filters based on Intel Quick Sync Video VPP
  22  **/
  23
  24 #include <float.h>
  25
  26 #include "libavutil/opt.h"
  27 #include "libavutil/eval.h"
  28 #include "libavutil/avassert.h"
  29 #include "libavutil/pixdesc.h"
  30 #include "libavutil/mathematics.h"
  31
  32 #include "formats.h"
  33 #include "internal.h"
  34 #include "avfilter.h"
  35 #include "libavcodec/avcodec.h"
  36 #include "libavformat/avformat.h"
  37
  38 #include "qsvvpp.h"
  39
  40 #define OFFSET(x) offsetof(VPPContext, x)
  41 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
  42
  43 /* number of video enhancement filters */
  44 #define ENH_FILTERS_COUNT (5)
  45
  46 typedef struct VPPContext{
  47     const AVClass *class;
  48
  49     QSVVPPContext *qsv;
  50
  51     /* Video Enhancement Algorithms */
  52     mfxExtVPPDeinterlacing  deinterlace_conf;
  53     mfxExtVPPFrameRateConversion frc_conf;
  54     mfxExtVPPDenoise denoise_conf;
  55     mfxExtVPPDetail detail_conf;
  56     mfxExtVPPProcAmp procamp_conf;
  57
  58     int out_width;
  59     int out_height;
  60     /**
  61      * Output sw format. AV_PIX_FMT_NONE for no conversion.
  62      */
  63     enum AVPixelFormat out_format;
  64
  65     AVRational framerate;       /* target framerate */
  66     int use_frc;                /* use framerate conversion */
  67     int deinterlace;            /* deinterlace mode : 0=off, 1=bob, 2=advanced */
  68     int denoise;                /* Enable Denoise algorithm. Value [0, 100] */
  69     int detail;                 /* Enable Detail Enhancement algorithm. */
  70                                 /* Level is the optional, value [0, 100] */
  71     int use_crop;               /* 1 = use crop; 0=none */
  72     int crop_w;
  73     int crop_h;
  74     int crop_x;
  75     int crop_y;
  76
  77     /* param for the procamp */
  78     int    procamp;            /* enable procamp */
  79     float  hue;
  80     float  saturation;
  81     float  contrast;
  82     float  brightness;
  83
  84     char *cx, *cy, *cw, *ch;
  85     char *ow, *oh;
  86     char *output_format_str;
  87 } VPPContext;
  88
  89 static const AVOption options[] = {
  90     { "deinterlace", "deinterlace mode: 0=off, 1=bob, 2=advanced", OFFSET(deinterlace), AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, MFX_DEINTERLACING_ADVANCED, .flags = FLAGS, "deinterlace" },
  91     { "bob",         "Bob deinterlace mode.",                      0,                   AV_OPT_TYPE_CONST,    { .i64 = MFX_DEINTERLACING_BOB },            .flags = FLAGS, "deinterlace" },
  92     { "advanced",    "Advanced deinterlace mode. ",                0,                   AV_OPT_TYPE_CONST,    { .i64 = MFX_DEINTERLACING_ADVANCED },       .flags = FLAGS, "deinterlace" },
  93
  94     { "denoise",     "denoise level [0, 100]",       OFFSET(denoise),     AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, 100, .flags = FLAGS },
  95     { "detail",      "enhancement level [0, 100]",   OFFSET(detail),      AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, 100, .flags = FLAGS },
  96     { "framerate",   "output framerate",             OFFSET(framerate),   AV_OPT_TYPE_RATIONAL, { .dbl = 0.0 },0, DBL_MAX, .flags = FLAGS },
  97     { "procamp",     "Enable ProcAmp",               OFFSET(procamp),     AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, 1, .flags = FLAGS},
  98     { "hue",         "ProcAmp hue",                  OFFSET(hue),         AV_OPT_TYPE_FLOAT,    { .dbl = 0.0 }, -180.0, 180.0, .flags = FLAGS},
  99     { "saturation",  "ProcAmp saturation",           OFFSET(saturation),  AV_OPT_TYPE_FLOAT,    { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
 100     { "contrast",    "ProcAmp contrast",             OFFSET(contrast),    AV_OPT_TYPE_FLOAT,    { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
 101     { "brightness",  "ProcAmp brightness",           OFFSET(brightness),  AV_OPT_TYPE_FLOAT,    { .dbl = 0.0 }, -100.0, 100.0, .flags = FLAGS},
 102
 103     { "cw",   "set the width crop area expression",   OFFSET(cw), AV_OPT_TYPE_STRING, { .str = "iw" }, CHAR_MIN, CHAR_MAX, FLAGS },
 104     { "ch",   "set the height crop area expression",  OFFSET(ch), AV_OPT_TYPE_STRING, { .str = "ih" }, CHAR_MIN, CHAR_MAX, FLAGS },
 105     { "cx",   "set the x crop area expression",       OFFSET(cx), AV_OPT_TYPE_STRING, { .str = "(in_w-out_w)/2" }, CHAR_MIN, CHAR_MAX, FLAGS },
 106     { "cy",   "set the y crop area expression",       OFFSET(cy), AV_OPT_TYPE_STRING, { .str = "(in_h-out_h)/2" }, CHAR_MIN, CHAR_MAX, FLAGS },
 107
 108     { "w",      "Output video width",  OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
 109     { "width",  "Output video width",  OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
 110     { "h",      "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
 111     { "height", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
 112     { "format", "Output pixel format", OFFSET(output_format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },
 113
 114     { NULL }
 115 };
 116
 117 static const char *const var_names[] = {
 118     "iw", "in_w",
 119     "ih", "in_h",
 120     "ow", "out_w", "w",
 121     "oh", "out_h", "h",
 122     "cw",
 123     "ch",
 124     "cx",
 125     "cy",
 126     NULL
 127 };
 128
 129 enum var_name {
 130     VAR_iW, VAR_IN_W,
 131     VAR_iH, VAR_IN_H,
 132     VAR_oW, VAR_OUT_W, VAR_W,
 133     VAR_oH, VAR_OUT_H, VAR_H,
 134     CW,
 135     CH,
 136     CX,
 137     CY,
 138     VAR_VARS_NB
 139 };
 140
 141 static int eval_expr(AVFilterContext *ctx)
 142 {
 143 #define PASS_EXPR(e, s) {\
 144     ret = av_expr_parse(&e, s, var_names, NULL, NULL, NULL, NULL, 0, ctx); \
 145     if (ret < 0) {\
 146         av_log(ctx, AV_LOG_ERROR, "Error when passing '%s'.\n", s);\
 147         goto release;\
 148     }\
 149 }
 150 #define CALC_EXPR(e, v, i) {\
 151     i = v = av_expr_eval(e, var_values, NULL); \
 152 }
 153     VPPContext *vpp = ctx->priv;
 154     double  var_values[VAR_VARS_NB] = { NAN };
 155     AVExpr *w_expr  = NULL, *h_expr  = NULL;
 156     AVExpr *cw_expr = NULL, *ch_expr = NULL;
 157     AVExpr *cx_expr = NULL, *cy_expr = NULL;
 158     int     ret = 0;
 159
 160     PASS_EXPR(cw_expr, vpp->cw);
 161     PASS_EXPR(ch_expr, vpp->ch);
 162
 163     PASS_EXPR(w_expr, vpp->ow);
 164     PASS_EXPR(h_expr, vpp->oh);
 165
 166     PASS_EXPR(cx_expr, vpp->cx);
 167     PASS_EXPR(cy_expr, vpp->cy);
 168
 169     var_values[VAR_iW] =
 170     var_values[VAR_IN_W] = ctx->inputs[0]->w;
 171
 172     var_values[VAR_iH] =
 173     var_values[VAR_IN_H] = ctx->inputs[0]->h;
 174
 175     /* crop params */
 176     CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
 177     CALC_EXPR(ch_expr, var_values[CH], vpp->crop_h);
 178
 179     /* calc again in case cw is relative to ch */
 180     CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
 181
 182     CALC_EXPR(w_expr,
 183             var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
 184             vpp->out_width);
 185     CALC_EXPR(h_expr,
 186             var_values[VAR_OUT_H] = var_values[VAR_oH] = var_values[VAR_H],
 187             vpp->out_height);
 188
 189     /* calc again in case ow is relative to oh */
 190     CALC_EXPR(w_expr,
 191             var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
 192             vpp->out_width);
 193
 194
 195     CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
 196     CALC_EXPR(cy_expr, var_values[CY], vpp->crop_y);
 197
 198     /* calc again in case cx is relative to cy */
 199     CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
 200
 201     if ((vpp->crop_w != var_values[VAR_iW]) || (vpp->crop_h != var_values[VAR_iH]))
 202         vpp->use_crop = 1;
 203
 204 release:
 205     av_expr_free(w_expr);
 206     av_expr_free(h_expr);
 207     av_expr_free(cw_expr);
 208     av_expr_free(ch_expr);
 209     av_expr_free(cx_expr);
 210     av_expr_free(cy_expr);
 211 #undef PASS_EXPR
 212 #undef CALC_EXPR
 213
 214     return ret;
 215 }
 216
 217 static av_cold int vpp_init(AVFilterContext *ctx)
 218 {
 219     VPPContext  *vpp  = ctx->priv;
 220
 221     if (!strcmp(vpp->output_format_str, "same")) {
 222         vpp->out_format = AV_PIX_FMT_NONE;
 223     } else {
 224         vpp->out_format = av_get_pix_fmt(vpp->output_format_str);
 225         if (vpp->out_format == AV_PIX_FMT_NONE) {
 226             av_log(ctx, AV_LOG_ERROR, "Unrecognized output pixel format: %s\n", vpp->output_format_str);
 227             return AVERROR(EINVAL);
 228         }
 229     }
 230
 231     return 0;
 232 }
 233
 234 static int config_input(AVFilterLink *inlink)
 235 {
 236     AVFilterContext *ctx = inlink->dst;
 237     VPPContext      *vpp = ctx->priv;
 238     int              ret;
 239
 240     if (vpp->framerate.den == 0 || vpp->framerate.num == 0)
 241         vpp->framerate = inlink->frame_rate;
 242
 243     if (av_cmp_q(vpp->framerate, inlink->frame_rate))
 244         vpp->use_frc = 1;
 245
 246     ret = eval_expr(ctx);
 247     if (ret != 0) {
 248         av_log(ctx, AV_LOG_ERROR, "Fail to eval expr.\n");
 249         return ret;
 250     }
 251
 252     if (vpp->out_height == 0 || vpp->out_width == 0) {
 253         vpp->out_width  = inlink->w;
 254         vpp->out_height = inlink->h;
 255     }
 256
 257     if (vpp->use_crop) {
 258         vpp->crop_x = FFMAX(vpp->crop_x, 0);
 259         vpp->crop_y = FFMAX(vpp->crop_y, 0);
 260
 261         if(vpp->crop_w + vpp->crop_x > inlink->w)
 262            vpp->crop_x = inlink->w - vpp->crop_w;
 263         if(vpp->crop_h + vpp->crop_y > inlink->h)
 264            vpp->crop_y = inlink->h - vpp->crop_h;
 265     }
 266
 267     return 0;
 268 }
 269
 270 static int config_output(AVFilterLink *outlink)
 271 {
 272     AVFilterContext *ctx = outlink->src;
 273     VPPContext      *vpp = ctx->priv;
 274     QSVVPPParam     param = { NULL };
 275     QSVVPPCrop      crop  = { 0 };
 276     mfxExtBuffer    *ext_buf[ENH_FILTERS_COUNT];
 277     AVFilterLink    *inlink = ctx->inputs[0];
 278     enum AVPixelFormat in_format;
 279
 280     outlink->w          = vpp->out_width;
 281     outlink->h          = vpp->out_height;
 282     outlink->frame_rate = vpp->framerate;
 283     outlink->time_base  = av_inv_q(vpp->framerate);
 284
 285     param.filter_frame  = NULL;
 286     param.num_ext_buf   = 0;
 287     param.ext_buf       = ext_buf;
 288
 289     if (inlink->format == AV_PIX_FMT_QSV) {
 290          if (!inlink->hw_frames_ctx || !inlink->hw_frames_ctx->data)
 291              return AVERROR(EINVAL);
 292          else
 293              in_format = ((AVHWFramesContext*)inlink->hw_frames_ctx->data)->sw_format;
 294     } else
 295         in_format = inlink->format;
 296
 297     param.out_sw_format  = (vpp->out_format == AV_PIX_FMT_NONE) ? in_format : vpp->out_format;
 298
 299     if (vpp->use_crop) {
 300         crop.in_idx = 0;
 301         crop.x = vpp->crop_x;
 302         crop.y = vpp->crop_y;
 303         crop.w = vpp->crop_w;
 304         crop.h = vpp->crop_h;
 305
 306         param.num_crop = 1;
 307         param.crop     = &crop;
 308     }
 309
 310     if (vpp->deinterlace) {
 311         memset(&vpp->deinterlace_conf, 0, sizeof(mfxExtVPPDeinterlacing));
 312         vpp->deinterlace_conf.Header.BufferId = MFX_EXTBUFF_VPP_DEINTERLACING;
 313         vpp->deinterlace_conf.Header.BufferSz = sizeof(mfxExtVPPDeinterlacing);
 314         vpp->deinterlace_conf.Mode = vpp->deinterlace == 1 ?
 315                                      MFX_DEINTERLACING_BOB : MFX_DEINTERLACING_ADVANCED;
 316
 317         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->deinterlace_conf;
 318     }
 319
 320     if (vpp->use_frc) {
 321         memset(&vpp->frc_conf, 0, sizeof(mfxExtVPPFrameRateConversion));
 322         vpp->frc_conf.Header.BufferId = MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION;
 323         vpp->frc_conf.Header.BufferSz = sizeof(mfxExtVPPFrameRateConversion);
 324         vpp->frc_conf.Algorithm = MFX_FRCALGM_DISTRIBUTED_TIMESTAMP;
 325
 326         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->frc_conf;
 327     }
 328
 329     if (vpp->denoise) {
 330         memset(&vpp->denoise_conf, 0, sizeof(mfxExtVPPDenoise));
 331         vpp->denoise_conf.Header.BufferId = MFX_EXTBUFF_VPP_DENOISE;
 332         vpp->denoise_conf.Header.BufferSz = sizeof(mfxExtVPPDenoise);
 333         vpp->denoise_conf.DenoiseFactor   = vpp->denoise;
 334
 335         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->denoise_conf;
 336     }
 337
 338     if (vpp->detail) {
 339         memset(&vpp->detail_conf, 0, sizeof(mfxExtVPPDetail));
 340         vpp->detail_conf.Header.BufferId  = MFX_EXTBUFF_VPP_DETAIL;
 341         vpp->detail_conf.Header.BufferSz  = sizeof(mfxExtVPPDetail);
 342         vpp->detail_conf.DetailFactor = vpp->detail;
 343
 344         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->detail_conf;
 345     }
 346
 347     if (vpp->procamp) {
 348         memset(&vpp->procamp_conf, 0, sizeof(mfxExtVPPProcAmp));
 349         vpp->procamp_conf.Header.BufferId  = MFX_EXTBUFF_VPP_PROCAMP;
 350         vpp->procamp_conf.Header.BufferSz  = sizeof(mfxExtVPPProcAmp);
 351         vpp->procamp_conf.Hue              = vpp->hue;
 352         vpp->procamp_conf.Saturation       = vpp->saturation;
 353         vpp->procamp_conf.Contrast         = vpp->contrast;
 354         vpp->procamp_conf.Brightness       = vpp->brightness;
 355
 356         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->procamp_conf;
 357     }
 358
 359     if (vpp->use_frc || vpp->use_crop || vpp->deinterlace || vpp->denoise ||
 360         vpp->detail || vpp->procamp || inlink->w != outlink->w || inlink->h != outlink->h)
 361         return ff_qsvvpp_create(ctx, &vpp->qsv, &param);
 362     else {
 363         av_log(ctx, AV_LOG_VERBOSE, "qsv vpp pass through mode.\n");
 364         if (inlink->hw_frames_ctx)
 365             outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx);
 366     }
 367
 368     return 0;
 369 }
 370
 371 static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
 372 {
 373     int              ret = 0;
 374     AVFilterContext  *ctx = inlink->dst;
 375     VPPContext       *vpp = inlink->dst->priv;
 376     AVFilterLink     *outlink = ctx->outputs[0];
 377
 378     if (vpp->qsv) {
 379         ret = ff_qsvvpp_filter_frame(vpp->qsv, inlink, picref);
 380         av_frame_free(&picref);
 381     } else {
 382         if (picref->pts != AV_NOPTS_VALUE)
 383             picref->pts = av_rescale_q(picref->pts, inlink->time_base, outlink->time_base);
 384         ret = ff_filter_frame(outlink, picref);
 385     }
 386
 387     return ret;
 388 }
 389
 390 static int query_formats(AVFilterContext *ctx)
 391 {
 392     int ret;
 393     AVFilterFormats *in_fmts, *out_fmts;
 394     static const enum AVPixelFormat in_pix_fmts[] = {
 395         AV_PIX_FMT_YUV420P,
 396         AV_PIX_FMT_NV12,
 397         AV_PIX_FMT_YUYV422,
 398         AV_PIX_FMT_RGB32,
 399         AV_PIX_FMT_QSV,
 400         AV_PIX_FMT_NONE
 401     };
 402     static const enum AVPixelFormat out_pix_fmts[] = {
 403         AV_PIX_FMT_NV12,
 404         AV_PIX_FMT_P010,
 405         AV_PIX_FMT_QSV,
 406         AV_PIX_FMT_NONE
 407     };
 408
 409     in_fmts  = ff_make_format_list(in_pix_fmts);
 410     out_fmts = ff_make_format_list(out_pix_fmts);
 411     ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats);
 412     if (ret < 0)
 413         return ret;
 414     ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
 415     if (ret < 0)
 416         return ret;
 417
 418     return 0;
 419 }
 420
 421 static av_cold void vpp_uninit(AVFilterContext *ctx)
 422 {
 423     VPPContext *vpp = ctx->priv;
 424
 425     ff_qsvvpp_free(&vpp->qsv);
 426 }
 427
 428 static const AVClass vpp_class = {
 429     .class_name = "vpp_qsv",
 430     .item_name  = av_default_item_name,
 431     .option     = options,
 432     .version    = LIBAVUTIL_VERSION_INT,
 433 };
 434
 435 static const AVFilterPad vpp_inputs[] = {
 436     {
 437         .name          = "default",
 438         .type          = AVMEDIA_TYPE_VIDEO,
 439         .config_props  = config_input,
 440         .filter_frame  = filter_frame,
 441     },
 442     { NULL }
 443 };
 444
 445 static const AVFilterPad vpp_outputs[] = {
 446     {
 447         .name          = "default",
 448         .type          = AVMEDIA_TYPE_VIDEO,
 449         .config_props  = config_output,
 450     },
 451     { NULL }
 452 };
 453
 454 AVFilter ff_vf_vpp_qsv = {
 455     .name          = "vpp_qsv",
 456     .description   = NULL_IF_CONFIG_SMALL("Quick Sync Video VPP."),
 457     .priv_size     = sizeof(VPPContext),
 458     .query_formats = query_formats,
 459     .init          = vpp_init,
 460     .uninit        = vpp_uninit,
 461     .inputs        = vpp_inputs,
 462     .outputs       = vpp_outputs,
 463     .priv_class    = &vpp_class,
 464     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 465 };