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 #include "transpose.h"
  40
  41 #define OFFSET(x) offsetof(VPPContext, x)
  42 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
  43
  44 /* number of video enhancement filters */
  45 #define ENH_FILTERS_COUNT (7)
  46 #define QSV_HAVE_ROTATION  QSV_VERSION_ATLEAST(1, 17)
  47 #define QSV_HAVE_MIRRORING QSV_VERSION_ATLEAST(1, 19)
  48
  49 typedef struct VPPContext{
  50     const AVClass *class;
  51
  52     QSVVPPContext *qsv;
  53
  54     /* Video Enhancement Algorithms */
  55     mfxExtVPPDeinterlacing  deinterlace_conf;
  56     mfxExtVPPFrameRateConversion frc_conf;
  57     mfxExtVPPDenoise denoise_conf;
  58     mfxExtVPPDetail detail_conf;
  59     mfxExtVPPProcAmp procamp_conf;
  60     mfxExtVPPRotation rotation_conf;
  61     mfxExtVPPMirroring mirroring_conf;
  62
  63     int out_width;
  64     int out_height;
  65     /**
  66      * Output sw format. AV_PIX_FMT_NONE for no conversion.
  67      */
  68     enum AVPixelFormat out_format;
  69
  70     AVRational framerate;       /* target framerate */
  71     int use_frc;                /* use framerate conversion */
  72     int deinterlace;            /* deinterlace mode : 0=off, 1=bob, 2=advanced */
  73     int denoise;                /* Enable Denoise algorithm. Value [0, 100] */
  74     int detail;                 /* Enable Detail Enhancement algorithm. */
  75                                 /* Level is the optional, value [0, 100] */
  76     int use_crop;               /* 1 = use crop; 0=none */
  77     int crop_w;
  78     int crop_h;
  79     int crop_x;
  80     int crop_y;
  81
  82     int transpose;
  83     int rotate;                 /* rotate angle : [0, 90, 180, 270] */
  84     int hflip;                  /* flip mode : 0 = off, 1 = HORIZONTAL flip */
  85
  86     /* param for the procamp */
  87     int    procamp;            /* enable procamp */
  88     float  hue;
  89     float  saturation;
  90     float  contrast;
  91     float  brightness;
  92
  93     char *cx, *cy, *cw, *ch;
  94     char *ow, *oh;
  95     char *output_format_str;
  96 } VPPContext;
  97
  98 static const AVOption options[] = {
  99     { "deinterlace", "deinterlace mode: 0=off, 1=bob, 2=advanced", OFFSET(deinterlace), AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, MFX_DEINTERLACING_ADVANCED, .flags = FLAGS, "deinterlace" },
 100     { "bob",         "Bob deinterlace mode.",                      0,                   AV_OPT_TYPE_CONST,    { .i64 = MFX_DEINTERLACING_BOB },            .flags = FLAGS, "deinterlace" },
 101     { "advanced",    "Advanced deinterlace mode. ",                0,                   AV_OPT_TYPE_CONST,    { .i64 = MFX_DEINTERLACING_ADVANCED },       .flags = FLAGS, "deinterlace" },
 102
 103     { "denoise",     "denoise level [0, 100]",       OFFSET(denoise),     AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, 100, .flags = FLAGS },
 104     { "detail",      "enhancement level [0, 100]",   OFFSET(detail),      AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, 100, .flags = FLAGS },
 105     { "framerate",   "output framerate",             OFFSET(framerate),   AV_OPT_TYPE_RATIONAL, { .dbl = 0.0 },0, DBL_MAX, .flags = FLAGS },
 106     { "procamp",     "Enable ProcAmp",               OFFSET(procamp),     AV_OPT_TYPE_INT,      { .i64 = 0 }, 0, 1, .flags = FLAGS},
 107     { "hue",         "ProcAmp hue",                  OFFSET(hue),         AV_OPT_TYPE_FLOAT,    { .dbl = 0.0 }, -180.0, 180.0, .flags = FLAGS},
 108     { "saturation",  "ProcAmp saturation",           OFFSET(saturation),  AV_OPT_TYPE_FLOAT,    { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
 109     { "contrast",    "ProcAmp contrast",             OFFSET(contrast),    AV_OPT_TYPE_FLOAT,    { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
 110     { "brightness",  "ProcAmp brightness",           OFFSET(brightness),  AV_OPT_TYPE_FLOAT,    { .dbl = 0.0 }, -100.0, 100.0, .flags = FLAGS},
 111
 112     { "transpose",  "set transpose direction",       OFFSET(transpose),   AV_OPT_TYPE_INT,      { .i64 = -1 }, -1, 6, FLAGS, "transpose"},
 113         { "cclock_hflip",  "rotate counter-clockwise with horizontal flip",  0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK_FLIP }, .flags=FLAGS, .unit = "transpose" },
 114         { "clock",         "rotate clockwise",                               0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK       }, .flags=FLAGS, .unit = "transpose" },
 115         { "cclock",        "rotate counter-clockwise",                       0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK      }, .flags=FLAGS, .unit = "transpose" },
 116         { "clock_hflip",   "rotate clockwise with horizontal flip",          0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK_FLIP  }, .flags=FLAGS, .unit = "transpose" },
 117         { "reversal",      "rotate by half-turn",                            0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_REVERSAL    }, .flags=FLAGS, .unit = "transpose" },
 118         { "hflip",         "flip horizontally",                              0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_HFLIP       }, .flags=FLAGS, .unit = "transpose" },
 119         { "vflip",         "flip vertically",                                0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_VFLIP       }, .flags=FLAGS, .unit = "transpose" },
 120
 121     { "cw",   "set the width crop area expression",   OFFSET(cw), AV_OPT_TYPE_STRING, { .str = "iw" }, CHAR_MIN, CHAR_MAX, FLAGS },
 122     { "ch",   "set the height crop area expression",  OFFSET(ch), AV_OPT_TYPE_STRING, { .str = "ih" }, CHAR_MIN, CHAR_MAX, FLAGS },
 123     { "cx",   "set the x crop area expression",       OFFSET(cx), AV_OPT_TYPE_STRING, { .str = "(in_w-out_w)/2" }, CHAR_MIN, CHAR_MAX, FLAGS },
 124     { "cy",   "set the y crop area expression",       OFFSET(cy), AV_OPT_TYPE_STRING, { .str = "(in_h-out_h)/2" }, CHAR_MIN, CHAR_MAX, FLAGS },
 125
 126     { "w",      "Output video width",  OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
 127     { "width",  "Output video width",  OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
 128     { "h",      "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
 129     { "height", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
 130     { "format", "Output pixel format", OFFSET(output_format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },
 131
 132     { NULL }
 133 };
 134
 135 static const char *const var_names[] = {
 136     "iw", "in_w",
 137     "ih", "in_h",
 138     "ow", "out_w", "w",
 139     "oh", "out_h", "h",
 140     "cw",
 141     "ch",
 142     "cx",
 143     "cy",
 144     NULL
 145 };
 146
 147 enum var_name {
 148     VAR_iW, VAR_IN_W,
 149     VAR_iH, VAR_IN_H,
 150     VAR_oW, VAR_OUT_W, VAR_W,
 151     VAR_oH, VAR_OUT_H, VAR_H,
 152     CW,
 153     CH,
 154     CX,
 155     CY,
 156     VAR_VARS_NB
 157 };
 158
 159 static int eval_expr(AVFilterContext *ctx)
 160 {
 161 #define PASS_EXPR(e, s) {\
 162     ret = av_expr_parse(&e, s, var_names, NULL, NULL, NULL, NULL, 0, ctx); \
 163     if (ret < 0) {\
 164         av_log(ctx, AV_LOG_ERROR, "Error when passing '%s'.\n", s);\
 165         goto release;\
 166     }\
 167 }
 168 #define CALC_EXPR(e, v, i) {\
 169     i = v = av_expr_eval(e, var_values, NULL); \
 170 }
 171     VPPContext *vpp = ctx->priv;
 172     double  var_values[VAR_VARS_NB] = { NAN };
 173     AVExpr *w_expr  = NULL, *h_expr  = NULL;
 174     AVExpr *cw_expr = NULL, *ch_expr = NULL;
 175     AVExpr *cx_expr = NULL, *cy_expr = NULL;
 176     int     ret = 0;
 177
 178     PASS_EXPR(cw_expr, vpp->cw);
 179     PASS_EXPR(ch_expr, vpp->ch);
 180
 181     PASS_EXPR(w_expr, vpp->ow);
 182     PASS_EXPR(h_expr, vpp->oh);
 183
 184     PASS_EXPR(cx_expr, vpp->cx);
 185     PASS_EXPR(cy_expr, vpp->cy);
 186
 187     var_values[VAR_iW] =
 188     var_values[VAR_IN_W] = ctx->inputs[0]->w;
 189
 190     var_values[VAR_iH] =
 191     var_values[VAR_IN_H] = ctx->inputs[0]->h;
 192
 193     /* crop params */
 194     CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
 195     CALC_EXPR(ch_expr, var_values[CH], vpp->crop_h);
 196
 197     /* calc again in case cw is relative to ch */
 198     CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
 199
 200     CALC_EXPR(w_expr,
 201             var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
 202             vpp->out_width);
 203     CALC_EXPR(h_expr,
 204             var_values[VAR_OUT_H] = var_values[VAR_oH] = var_values[VAR_H],
 205             vpp->out_height);
 206
 207     /* calc again in case ow is relative to oh */
 208     CALC_EXPR(w_expr,
 209             var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
 210             vpp->out_width);
 211
 212
 213     CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
 214     CALC_EXPR(cy_expr, var_values[CY], vpp->crop_y);
 215
 216     /* calc again in case cx is relative to cy */
 217     CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
 218
 219     if ((vpp->crop_w != var_values[VAR_iW]) || (vpp->crop_h != var_values[VAR_iH]))
 220         vpp->use_crop = 1;
 221
 222 release:
 223     av_expr_free(w_expr);
 224     av_expr_free(h_expr);
 225     av_expr_free(cw_expr);
 226     av_expr_free(ch_expr);
 227     av_expr_free(cx_expr);
 228     av_expr_free(cy_expr);
 229 #undef PASS_EXPR
 230 #undef CALC_EXPR
 231
 232     return ret;
 233 }
 234
 235 static av_cold int vpp_init(AVFilterContext *ctx)
 236 {
 237     VPPContext  *vpp  = ctx->priv;
 238
 239     if (!strcmp(vpp->output_format_str, "same")) {
 240         vpp->out_format = AV_PIX_FMT_NONE;
 241     } else {
 242         vpp->out_format = av_get_pix_fmt(vpp->output_format_str);
 243         if (vpp->out_format == AV_PIX_FMT_NONE) {
 244             av_log(ctx, AV_LOG_ERROR, "Unrecognized output pixel format: %s\n", vpp->output_format_str);
 245             return AVERROR(EINVAL);
 246         }
 247     }
 248
 249     return 0;
 250 }
 251
 252 static int config_input(AVFilterLink *inlink)
 253 {
 254     AVFilterContext *ctx = inlink->dst;
 255     VPPContext      *vpp = ctx->priv;
 256     int              ret;
 257
 258     if (vpp->framerate.den == 0 || vpp->framerate.num == 0)
 259         vpp->framerate = inlink->frame_rate;
 260
 261     if (av_cmp_q(vpp->framerate, inlink->frame_rate))
 262         vpp->use_frc = 1;
 263
 264     ret = eval_expr(ctx);
 265     if (ret != 0) {
 266         av_log(ctx, AV_LOG_ERROR, "Fail to eval expr.\n");
 267         return ret;
 268     }
 269
 270     if (vpp->out_height == 0 || vpp->out_width == 0) {
 271         vpp->out_width  = inlink->w;
 272         vpp->out_height = inlink->h;
 273     }
 274
 275     if (vpp->use_crop) {
 276         vpp->crop_x = FFMAX(vpp->crop_x, 0);
 277         vpp->crop_y = FFMAX(vpp->crop_y, 0);
 278
 279         if(vpp->crop_w + vpp->crop_x > inlink->w)
 280            vpp->crop_x = inlink->w - vpp->crop_w;
 281         if(vpp->crop_h + vpp->crop_y > inlink->h)
 282            vpp->crop_y = inlink->h - vpp->crop_h;
 283     }
 284
 285     return 0;
 286 }
 287
 288 static int config_output(AVFilterLink *outlink)
 289 {
 290     AVFilterContext *ctx = outlink->src;
 291     VPPContext      *vpp = ctx->priv;
 292     QSVVPPParam     param = { NULL };
 293     QSVVPPCrop      crop  = { 0 };
 294     mfxExtBuffer    *ext_buf[ENH_FILTERS_COUNT];
 295     AVFilterLink    *inlink = ctx->inputs[0];
 296     enum AVPixelFormat in_format;
 297
 298     outlink->w          = vpp->out_width;
 299     outlink->h          = vpp->out_height;
 300     outlink->frame_rate = vpp->framerate;
 301     outlink->time_base  = av_inv_q(vpp->framerate);
 302
 303     param.filter_frame  = NULL;
 304     param.num_ext_buf   = 0;
 305     param.ext_buf       = ext_buf;
 306
 307     if (inlink->format == AV_PIX_FMT_QSV) {
 308          if (!inlink->hw_frames_ctx || !inlink->hw_frames_ctx->data)
 309              return AVERROR(EINVAL);
 310          else
 311              in_format = ((AVHWFramesContext*)inlink->hw_frames_ctx->data)->sw_format;
 312     } else
 313         in_format = inlink->format;
 314
 315     param.out_sw_format  = (vpp->out_format == AV_PIX_FMT_NONE) ? in_format : vpp->out_format;
 316
 317     if (vpp->use_crop) {
 318         crop.in_idx = 0;
 319         crop.x = vpp->crop_x;
 320         crop.y = vpp->crop_y;
 321         crop.w = vpp->crop_w;
 322         crop.h = vpp->crop_h;
 323
 324         param.num_crop = 1;
 325         param.crop     = &crop;
 326     }
 327
 328     if (vpp->deinterlace) {
 329         memset(&vpp->deinterlace_conf, 0, sizeof(mfxExtVPPDeinterlacing));
 330         vpp->deinterlace_conf.Header.BufferId = MFX_EXTBUFF_VPP_DEINTERLACING;
 331         vpp->deinterlace_conf.Header.BufferSz = sizeof(mfxExtVPPDeinterlacing);
 332         vpp->deinterlace_conf.Mode = vpp->deinterlace == 1 ?
 333                                      MFX_DEINTERLACING_BOB : MFX_DEINTERLACING_ADVANCED;
 334
 335         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->deinterlace_conf;
 336     }
 337
 338     if (vpp->use_frc) {
 339         memset(&vpp->frc_conf, 0, sizeof(mfxExtVPPFrameRateConversion));
 340         vpp->frc_conf.Header.BufferId = MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION;
 341         vpp->frc_conf.Header.BufferSz = sizeof(mfxExtVPPFrameRateConversion);
 342         vpp->frc_conf.Algorithm = MFX_FRCALGM_DISTRIBUTED_TIMESTAMP;
 343
 344         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->frc_conf;
 345     }
 346
 347     if (vpp->denoise) {
 348         memset(&vpp->denoise_conf, 0, sizeof(mfxExtVPPDenoise));
 349         vpp->denoise_conf.Header.BufferId = MFX_EXTBUFF_VPP_DENOISE;
 350         vpp->denoise_conf.Header.BufferSz = sizeof(mfxExtVPPDenoise);
 351         vpp->denoise_conf.DenoiseFactor   = vpp->denoise;
 352
 353         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->denoise_conf;
 354     }
 355
 356     if (vpp->detail) {
 357         memset(&vpp->detail_conf, 0, sizeof(mfxExtVPPDetail));
 358         vpp->detail_conf.Header.BufferId  = MFX_EXTBUFF_VPP_DETAIL;
 359         vpp->detail_conf.Header.BufferSz  = sizeof(mfxExtVPPDetail);
 360         vpp->detail_conf.DetailFactor = vpp->detail;
 361
 362         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->detail_conf;
 363     }
 364
 365     if (vpp->procamp) {
 366         memset(&vpp->procamp_conf, 0, sizeof(mfxExtVPPProcAmp));
 367         vpp->procamp_conf.Header.BufferId  = MFX_EXTBUFF_VPP_PROCAMP;
 368         vpp->procamp_conf.Header.BufferSz  = sizeof(mfxExtVPPProcAmp);
 369         vpp->procamp_conf.Hue              = vpp->hue;
 370         vpp->procamp_conf.Saturation       = vpp->saturation;
 371         vpp->procamp_conf.Contrast         = vpp->contrast;
 372         vpp->procamp_conf.Brightness       = vpp->brightness;
 373
 374         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->procamp_conf;
 375     }
 376
 377     if (vpp->transpose >= 0) {
 378 #ifdef QSV_HAVE_ROTATION
 379         switch (vpp->transpose) {
 380         case TRANSPOSE_CCLOCK_FLIP:
 381             vpp->rotate = MFX_ANGLE_270;
 382             vpp->hflip  = MFX_MIRRORING_HORIZONTAL;
 383             break;
 384         case TRANSPOSE_CLOCK:
 385             vpp->rotate = MFX_ANGLE_90;
 386             vpp->hflip  = MFX_MIRRORING_DISABLED;
 387             break;
 388         case TRANSPOSE_CCLOCK:
 389             vpp->rotate = MFX_ANGLE_270;
 390             vpp->hflip  = MFX_MIRRORING_DISABLED;
 391             break;
 392         case TRANSPOSE_CLOCK_FLIP:
 393             vpp->rotate = MFX_ANGLE_90;
 394             vpp->hflip  = MFX_MIRRORING_HORIZONTAL;
 395             break;
 396         case TRANSPOSE_REVERSAL:
 397             vpp->rotate = MFX_ANGLE_180;
 398             vpp->hflip  = MFX_MIRRORING_DISABLED;
 399             break;
 400         case TRANSPOSE_HFLIP:
 401             vpp->rotate = MFX_ANGLE_0;
 402             vpp->hflip  = MFX_MIRRORING_HORIZONTAL;
 403             break;
 404         case TRANSPOSE_VFLIP:
 405             vpp->rotate = MFX_ANGLE_180;
 406             vpp->hflip  = MFX_MIRRORING_HORIZONTAL;
 407             break;
 408         default:
 409             av_log(ctx, AV_LOG_ERROR, "Failed to set transpose mode to %d.\n", vpp->transpose);
 410             return AVERROR(EINVAL);
 411         }
 412 #else
 413         av_log(ctx, AV_LOG_WARNING, "The QSV VPP transpose option is "
 414             "not supported with this MSDK version.\n");
 415         vpp->transpose = 0;
 416 #endif
 417     }
 418
 419     if (vpp->rotate) {
 420 #ifdef QSV_HAVE_ROTATION
 421         memset(&vpp->rotation_conf, 0, sizeof(mfxExtVPPRotation));
 422         vpp->rotation_conf.Header.BufferId  = MFX_EXTBUFF_VPP_ROTATION;
 423         vpp->rotation_conf.Header.BufferSz  = sizeof(mfxExtVPPRotation);
 424         vpp->rotation_conf.Angle = vpp->rotate;
 425
 426         if (MFX_ANGLE_90 == vpp->rotate || MFX_ANGLE_270 == vpp->rotate) {
 427             FFSWAP(int, vpp->out_width, vpp->out_height);
 428             FFSWAP(int, outlink->w, outlink->h);
 429             av_log(ctx, AV_LOG_DEBUG, "Swap width and height for clock/cclock rotation.\n");
 430         }
 431
 432         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->rotation_conf;
 433 #else
 434         av_log(ctx, AV_LOG_WARNING, "The QSV VPP rotate option is "
 435             "not supported with this MSDK version.\n");
 436         vpp->rotate = 0;
 437 #endif
 438     }
 439
 440     if (vpp->hflip) {
 441 #ifdef QSV_HAVE_MIRRORING
 442         memset(&vpp->mirroring_conf, 0, sizeof(mfxExtVPPMirroring));
 443         vpp->mirroring_conf.Header.BufferId = MFX_EXTBUFF_VPP_MIRRORING;
 444         vpp->mirroring_conf.Header.BufferSz = sizeof(mfxExtVPPMirroring);
 445         vpp->mirroring_conf.Type = vpp->hflip;
 446
 447         param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->mirroring_conf;
 448 #else
 449         av_log(ctx, AV_LOG_WARNING, "The QSV VPP hflip option is "
 450             "not supported with this MSDK version.\n");
 451         vpp->hflip = 0;
 452 #endif
 453     }
 454
 455     if (vpp->use_frc || vpp->use_crop || vpp->deinterlace || vpp->denoise ||
 456         vpp->detail || vpp->procamp || vpp->rotate || vpp->hflip ||
 457         inlink->w != outlink->w || inlink->h != outlink->h)
 458         return ff_qsvvpp_create(ctx, &vpp->qsv, &param);
 459     else {
 460         av_log(ctx, AV_LOG_VERBOSE, "qsv vpp pass through mode.\n");
 461         if (inlink->hw_frames_ctx)
 462             outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx);
 463     }
 464
 465     return 0;
 466 }
 467
 468 static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
 469 {
 470     int              ret = 0;
 471     AVFilterContext  *ctx = inlink->dst;
 472     VPPContext       *vpp = inlink->dst->priv;
 473     AVFilterLink     *outlink = ctx->outputs[0];
 474
 475     if (vpp->qsv) {
 476         ret = ff_qsvvpp_filter_frame(vpp->qsv, inlink, picref);
 477         av_frame_free(&picref);
 478     } else {
 479         if (picref->pts != AV_NOPTS_VALUE)
 480             picref->pts = av_rescale_q(picref->pts, inlink->time_base, outlink->time_base);
 481         ret = ff_filter_frame(outlink, picref);
 482     }
 483
 484     return ret;
 485 }
 486
 487 static int query_formats(AVFilterContext *ctx)
 488 {
 489     int ret;
 490     AVFilterFormats *in_fmts, *out_fmts;
 491     static const enum AVPixelFormat in_pix_fmts[] = {
 492         AV_PIX_FMT_YUV420P,
 493         AV_PIX_FMT_NV12,
 494         AV_PIX_FMT_YUYV422,
 495         AV_PIX_FMT_RGB32,
 496         AV_PIX_FMT_QSV,
 497         AV_PIX_FMT_NONE
 498     };
 499     static const enum AVPixelFormat out_pix_fmts[] = {
 500         AV_PIX_FMT_NV12,
 501         AV_PIX_FMT_P010,
 502         AV_PIX_FMT_QSV,
 503         AV_PIX_FMT_NONE
 504     };
 505
 506     in_fmts  = ff_make_format_list(in_pix_fmts);
 507     out_fmts = ff_make_format_list(out_pix_fmts);
 508     ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats);
 509     if (ret < 0)
 510         return ret;
 511     ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
 512     if (ret < 0)
 513         return ret;
 514
 515     return 0;
 516 }
 517
 518 static av_cold void vpp_uninit(AVFilterContext *ctx)
 519 {
 520     VPPContext *vpp = ctx->priv;
 521
 522     ff_qsvvpp_free(&vpp->qsv);
 523 }
 524
 525 static const AVClass vpp_class = {
 526     .class_name = "vpp_qsv",
 527     .item_name  = av_default_item_name,
 528     .option     = options,
 529     .version    = LIBAVUTIL_VERSION_INT,
 530 };
 531
 532 static const AVFilterPad vpp_inputs[] = {
 533     {
 534         .name          = "default",
 535         .type          = AVMEDIA_TYPE_VIDEO,
 536         .config_props  = config_input,
 537         .filter_frame  = filter_frame,
 538     },
 539     { NULL }
 540 };
 541
 542 static const AVFilterPad vpp_outputs[] = {
 543     {
 544         .name          = "default",
 545         .type          = AVMEDIA_TYPE_VIDEO,
 546         .config_props  = config_output,
 547     },
 548     { NULL }
 549 };
 550
 551 AVFilter ff_vf_vpp_qsv = {
 552     .name          = "vpp_qsv",
 553     .description   = NULL_IF_CONFIG_SMALL("Quick Sync Video VPP."),
 554     .priv_size     = sizeof(VPPContext),
 555     .query_formats = query_formats,
 556     .init          = vpp_init,
 557     .uninit        = vpp_uninit,
 558     .inputs        = vpp_inputs,
 559     .outputs       = vpp_outputs,
 560     .priv_class    = &vpp_class,
 561     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 562 };