FFmpeg
vf_vpp_qsv.c
Go to the documentation of this file.
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/hwcontext.h"
30 #include "libavutil/pixdesc.h"
31 #include "libavutil/mathematics.h"
32 
33 #include "formats.h"
34 #include "internal.h"
35 #include "avfilter.h"
36 #include "filters.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 (8)
46 #define QSV_HAVE_ROTATION QSV_VERSION_ATLEAST(1, 17)
47 #define QSV_HAVE_MIRRORING QSV_VERSION_ATLEAST(1, 19)
48 #define QSV_HAVE_SCALING_CONFIG QSV_VERSION_ATLEAST(1, 19)
49 
50 typedef struct VPPContext{
51  const AVClass *class;
52 
54 
55  /* Video Enhancement Algorithms */
56  mfxExtVPPDeinterlacing deinterlace_conf;
57  mfxExtVPPFrameRateConversion frc_conf;
58  mfxExtVPPDenoise denoise_conf;
59  mfxExtVPPDetail detail_conf;
60  mfxExtVPPProcAmp procamp_conf;
61  mfxExtVPPRotation rotation_conf;
62  mfxExtVPPMirroring mirroring_conf;
63 #ifdef QSV_HAVE_SCALING_CONFIG
64  mfxExtVPPScaling scale_conf;
65 #endif
66 
67  int out_width;
69  /**
70  * Output sw format. AV_PIX_FMT_NONE for no conversion.
71  */
73 
74  AVRational framerate; /* target framerate */
75  int use_frc; /* use framerate conversion */
76  int deinterlace; /* deinterlace mode : 0=off, 1=bob, 2=advanced */
77  int denoise; /* Enable Denoise algorithm. Value [0, 100] */
78  int detail; /* Enable Detail Enhancement algorithm. */
79  /* Level is the optional, value [0, 100] */
80  int use_crop; /* 1 = use crop; 0=none */
81  int crop_w;
82  int crop_h;
83  int crop_x;
84  int crop_y;
85 
86  int transpose;
87  int rotate; /* rotate angle : [0, 90, 180, 270] */
88  int hflip; /* flip mode : 0 = off, 1 = HORIZONTAL flip */
89 
90  int scale_mode; /* scale mode : 0 = auto, 1 = low power, 2 = high quality */
91 
92  /* param for the procamp */
93  int procamp; /* enable procamp */
94  float hue;
95  float saturation;
96  float contrast;
97  float brightness;
98 
99  char *cx, *cy, *cw, *ch;
100  char *ow, *oh;
102 
104  int eof;
105 } VPPContext;
106 
107 static const AVOption options[] = {
108  { "deinterlace", "deinterlace mode: 0=off, 1=bob, 2=advanced", OFFSET(deinterlace), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, MFX_DEINTERLACING_ADVANCED, .flags = FLAGS, "deinterlace" },
109  { "bob", "Bob deinterlace mode.", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_DEINTERLACING_BOB }, .flags = FLAGS, "deinterlace" },
110  { "advanced", "Advanced deinterlace mode. ", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_DEINTERLACING_ADVANCED }, .flags = FLAGS, "deinterlace" },
111 
112  { "denoise", "denoise level [0, 100]", OFFSET(denoise), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, .flags = FLAGS },
113  { "detail", "enhancement level [0, 100]", OFFSET(detail), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, .flags = FLAGS },
114  { "framerate", "output framerate", OFFSET(framerate), AV_OPT_TYPE_RATIONAL, { .dbl = 0.0 },0, DBL_MAX, .flags = FLAGS },
115  { "procamp", "Enable ProcAmp", OFFSET(procamp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = FLAGS},
116  { "hue", "ProcAmp hue", OFFSET(hue), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, -180.0, 180.0, .flags = FLAGS},
117  { "saturation", "ProcAmp saturation", OFFSET(saturation), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
118  { "contrast", "ProcAmp contrast", OFFSET(contrast), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 }, 0.0, 10.0, .flags = FLAGS},
119  { "brightness", "ProcAmp brightness", OFFSET(brightness), AV_OPT_TYPE_FLOAT, { .dbl = 0.0 }, -100.0, 100.0, .flags = FLAGS},
120 
121  { "transpose", "set transpose direction", OFFSET(transpose), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 6, FLAGS, "transpose"},
122  { "cclock_hflip", "rotate counter-clockwise with horizontal flip", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK_FLIP }, .flags=FLAGS, .unit = "transpose" },
123  { "clock", "rotate clockwise", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK }, .flags=FLAGS, .unit = "transpose" },
124  { "cclock", "rotate counter-clockwise", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK }, .flags=FLAGS, .unit = "transpose" },
125  { "clock_hflip", "rotate clockwise with horizontal flip", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK_FLIP }, .flags=FLAGS, .unit = "transpose" },
126  { "reversal", "rotate by half-turn", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_REVERSAL }, .flags=FLAGS, .unit = "transpose" },
127  { "hflip", "flip horizontally", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_HFLIP }, .flags=FLAGS, .unit = "transpose" },
128  { "vflip", "flip vertically", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_VFLIP }, .flags=FLAGS, .unit = "transpose" },
129 
130  { "cw", "set the width crop area expression", OFFSET(cw), AV_OPT_TYPE_STRING, { .str = "iw" }, 0, 0, FLAGS },
131  { "ch", "set the height crop area expression", OFFSET(ch), AV_OPT_TYPE_STRING, { .str = "ih" }, 0, 0, FLAGS },
132  { "cx", "set the x crop area expression", OFFSET(cx), AV_OPT_TYPE_STRING, { .str = "(in_w-out_w)/2" }, 0, 0, FLAGS },
133  { "cy", "set the y crop area expression", OFFSET(cy), AV_OPT_TYPE_STRING, { .str = "(in_h-out_h)/2" }, 0, 0, FLAGS },
134 
135  { "w", "Output video width", OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
136  { "width", "Output video width", OFFSET(ow), AV_OPT_TYPE_STRING, { .str="cw" }, 0, 255, .flags = FLAGS },
137  { "h", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
138  { "height", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
139  { "format", "Output pixel format", OFFSET(output_format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },
140  { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(async_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, .flags = FLAGS },
141 #ifdef QSV_HAVE_SCALING_CONFIG
142  { "scale_mode", "scale mode: 0=auto, 1=low power, 2=high quality", OFFSET(scale_mode), AV_OPT_TYPE_INT, { .i64 = MFX_SCALING_MODE_DEFAULT }, MFX_SCALING_MODE_DEFAULT, MFX_SCALING_MODE_QUALITY, .flags = FLAGS, "scale mode" },
143 #endif
144  { NULL }
145 };
146 
147 static const char *const var_names[] = {
148  "iw", "in_w",
149  "ih", "in_h",
150  "ow", "out_w", "w",
151  "oh", "out_h", "h",
152  "cw",
153  "ch",
154  "cx",
155  "cy",
156  NULL
157 };
158 
159 enum var_name {
164  CW,
165  CH,
166  CX,
167  CY,
169 };
170 
172 {
173 #define PASS_EXPR(e, s) {\
174  ret = av_expr_parse(&e, s, var_names, NULL, NULL, NULL, NULL, 0, ctx); \
175  if (ret < 0) {\
176  av_log(ctx, AV_LOG_ERROR, "Error when passing '%s'.\n", s);\
177  goto release;\
178  }\
179 }
180 #define CALC_EXPR(e, v, i) {\
181  i = v = av_expr_eval(e, var_values, NULL); \
182 }
183  VPPContext *vpp = ctx->priv;
184  double var_values[VAR_VARS_NB] = { NAN };
185  AVExpr *w_expr = NULL, *h_expr = NULL;
186  AVExpr *cw_expr = NULL, *ch_expr = NULL;
187  AVExpr *cx_expr = NULL, *cy_expr = NULL;
188  int ret = 0;
189 
190  PASS_EXPR(cw_expr, vpp->cw);
191  PASS_EXPR(ch_expr, vpp->ch);
192 
193  PASS_EXPR(w_expr, vpp->ow);
194  PASS_EXPR(h_expr, vpp->oh);
195 
196  PASS_EXPR(cx_expr, vpp->cx);
197  PASS_EXPR(cy_expr, vpp->cy);
198 
199  var_values[VAR_iW] =
200  var_values[VAR_IN_W] = ctx->inputs[0]->w;
201 
202  var_values[VAR_iH] =
203  var_values[VAR_IN_H] = ctx->inputs[0]->h;
204 
205  /* crop params */
206  CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
207  CALC_EXPR(ch_expr, var_values[CH], vpp->crop_h);
208 
209  /* calc again in case cw is relative to ch */
210  CALC_EXPR(cw_expr, var_values[CW], vpp->crop_w);
211 
212  CALC_EXPR(w_expr,
213  var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
214  vpp->out_width);
215  CALC_EXPR(h_expr,
216  var_values[VAR_OUT_H] = var_values[VAR_oH] = var_values[VAR_H],
217  vpp->out_height);
218 
219  /* calc again in case ow is relative to oh */
220  CALC_EXPR(w_expr,
221  var_values[VAR_OUT_W] = var_values[VAR_oW] = var_values[VAR_W],
222  vpp->out_width);
223 
224 
225  CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
226  CALC_EXPR(cy_expr, var_values[CY], vpp->crop_y);
227 
228  /* calc again in case cx is relative to cy */
229  CALC_EXPR(cx_expr, var_values[CX], vpp->crop_x);
230 
231  if ((vpp->crop_w != var_values[VAR_iW]) || (vpp->crop_h != var_values[VAR_iH]))
232  vpp->use_crop = 1;
233 
234 release:
235  av_expr_free(w_expr);
236  av_expr_free(h_expr);
237  av_expr_free(cw_expr);
238  av_expr_free(ch_expr);
239  av_expr_free(cx_expr);
240  av_expr_free(cy_expr);
241 #undef PASS_EXPR
242 #undef CALC_EXPR
243 
244  return ret;
245 }
246 
248 {
249  VPPContext *vpp = ctx->priv;
250 
251  if (!strcmp(vpp->output_format_str, "same")) {
253  } else {
255  if (vpp->out_format == AV_PIX_FMT_NONE) {
256  av_log(ctx, AV_LOG_ERROR, "Unrecognized output pixel format: %s\n", vpp->output_format_str);
257  return AVERROR(EINVAL);
258  }
259  }
260 
261  return 0;
262 }
263 
265 {
266  AVFilterContext *ctx = inlink->dst;
267  VPPContext *vpp = ctx->priv;
268  int ret;
269 
270  if (vpp->framerate.den == 0 || vpp->framerate.num == 0)
271  vpp->framerate = inlink->frame_rate;
272 
273  if (av_cmp_q(vpp->framerate, inlink->frame_rate))
274  vpp->use_frc = 1;
275 
276  ret = eval_expr(ctx);
277  if (ret != 0) {
278  av_log(ctx, AV_LOG_ERROR, "Fail to eval expr.\n");
279  return ret;
280  }
281 
282  if (vpp->out_height == 0 || vpp->out_width == 0) {
283  vpp->out_width = inlink->w;
284  vpp->out_height = inlink->h;
285  }
286 
287  if (vpp->use_crop) {
288  vpp->crop_x = FFMAX(vpp->crop_x, 0);
289  vpp->crop_y = FFMAX(vpp->crop_y, 0);
290 
291  if(vpp->crop_w + vpp->crop_x > inlink->w)
292  vpp->crop_x = inlink->w - vpp->crop_w;
293  if(vpp->crop_h + vpp->crop_y > inlink->h)
294  vpp->crop_y = inlink->h - vpp->crop_h;
295  }
296 
297  return 0;
298 }
299 
300 static mfxStatus get_mfx_version(const AVFilterContext *ctx, mfxVersion *mfx_version)
301 {
302  const AVFilterLink *inlink = ctx->inputs[0];
303  AVBufferRef *device_ref;
304  AVHWDeviceContext *device_ctx;
305  AVQSVDeviceContext *device_hwctx;
306 
307  if (inlink->hw_frames_ctx) {
308  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)inlink->hw_frames_ctx->data;
309  device_ref = frames_ctx->device_ref;
310  } else if (ctx->hw_device_ctx) {
311  device_ref = ctx->hw_device_ctx;
312  } else {
313  // Unavailable hw context doesn't matter in pass-through mode,
314  // so don't error here but let runtime version checks fail by setting to 0.0
315  mfx_version->Major = 0;
316  mfx_version->Minor = 0;
317  return MFX_ERR_NONE;
318  }
319 
320  device_ctx = (AVHWDeviceContext *)device_ref->data;
321  device_hwctx = device_ctx->hwctx;
322 
323  return MFXQueryVersion(device_hwctx->session, mfx_version);
324 }
325 
326 static int config_output(AVFilterLink *outlink)
327 {
328  AVFilterContext *ctx = outlink->src;
329  VPPContext *vpp = ctx->priv;
330  QSVVPPParam param = { NULL };
331  QSVVPPCrop crop = { 0 };
332  mfxExtBuffer *ext_buf[ENH_FILTERS_COUNT];
333  mfxVersion mfx_version;
334  AVFilterLink *inlink = ctx->inputs[0];
335  enum AVPixelFormat in_format;
336 
337  outlink->w = vpp->out_width;
338  outlink->h = vpp->out_height;
339  outlink->frame_rate = vpp->framerate;
340  outlink->time_base = inlink->time_base;
341 
342  param.filter_frame = NULL;
343  param.num_ext_buf = 0;
344  param.ext_buf = ext_buf;
345  param.async_depth = vpp->async_depth;
346 
347  if (get_mfx_version(ctx, &mfx_version) != MFX_ERR_NONE) {
348  av_log(ctx, AV_LOG_ERROR, "Failed to query mfx version.\n");
349  return AVERROR(EINVAL);
350  }
351 
352  if (inlink->format == AV_PIX_FMT_QSV) {
353  if (!inlink->hw_frames_ctx || !inlink->hw_frames_ctx->data)
354  return AVERROR(EINVAL);
355  else
356  in_format = ((AVHWFramesContext*)inlink->hw_frames_ctx->data)->sw_format;
357  } else
358  in_format = inlink->format;
359 
360  if (vpp->out_format == AV_PIX_FMT_NONE)
361  vpp->out_format = in_format;
362  param.out_sw_format = vpp->out_format;
363 
364  if (vpp->use_crop) {
365  crop.in_idx = 0;
366  crop.x = vpp->crop_x;
367  crop.y = vpp->crop_y;
368  crop.w = vpp->crop_w;
369  crop.h = vpp->crop_h;
370 
371  param.num_crop = 1;
372  param.crop = &crop;
373  }
374 
375  if (vpp->deinterlace) {
376  memset(&vpp->deinterlace_conf, 0, sizeof(mfxExtVPPDeinterlacing));
377  vpp->deinterlace_conf.Header.BufferId = MFX_EXTBUFF_VPP_DEINTERLACING;
378  vpp->deinterlace_conf.Header.BufferSz = sizeof(mfxExtVPPDeinterlacing);
379  vpp->deinterlace_conf.Mode = vpp->deinterlace == 1 ?
380  MFX_DEINTERLACING_BOB : MFX_DEINTERLACING_ADVANCED;
381 
382  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->deinterlace_conf;
383  }
384 
385  if (vpp->use_frc) {
386  memset(&vpp->frc_conf, 0, sizeof(mfxExtVPPFrameRateConversion));
387  vpp->frc_conf.Header.BufferId = MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION;
388  vpp->frc_conf.Header.BufferSz = sizeof(mfxExtVPPFrameRateConversion);
389  vpp->frc_conf.Algorithm = MFX_FRCALGM_DISTRIBUTED_TIMESTAMP;
390 
391  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->frc_conf;
392  }
393 
394  if (vpp->denoise) {
395  memset(&vpp->denoise_conf, 0, sizeof(mfxExtVPPDenoise));
396  vpp->denoise_conf.Header.BufferId = MFX_EXTBUFF_VPP_DENOISE;
397  vpp->denoise_conf.Header.BufferSz = sizeof(mfxExtVPPDenoise);
398  vpp->denoise_conf.DenoiseFactor = vpp->denoise;
399 
400  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->denoise_conf;
401  }
402 
403  if (vpp->detail) {
404  memset(&vpp->detail_conf, 0, sizeof(mfxExtVPPDetail));
405  vpp->detail_conf.Header.BufferId = MFX_EXTBUFF_VPP_DETAIL;
406  vpp->detail_conf.Header.BufferSz = sizeof(mfxExtVPPDetail);
407  vpp->detail_conf.DetailFactor = vpp->detail;
408 
409  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->detail_conf;
410  }
411 
412  if (vpp->procamp) {
413  memset(&vpp->procamp_conf, 0, sizeof(mfxExtVPPProcAmp));
414  vpp->procamp_conf.Header.BufferId = MFX_EXTBUFF_VPP_PROCAMP;
415  vpp->procamp_conf.Header.BufferSz = sizeof(mfxExtVPPProcAmp);
416  vpp->procamp_conf.Hue = vpp->hue;
417  vpp->procamp_conf.Saturation = vpp->saturation;
418  vpp->procamp_conf.Contrast = vpp->contrast;
419  vpp->procamp_conf.Brightness = vpp->brightness;
420 
421  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->procamp_conf;
422  }
423 
424  if (vpp->transpose >= 0) {
425 #ifdef QSV_HAVE_ROTATION
426  switch (vpp->transpose) {
428  vpp->rotate = MFX_ANGLE_270;
429  vpp->hflip = MFX_MIRRORING_HORIZONTAL;
430  break;
431  case TRANSPOSE_CLOCK:
432  vpp->rotate = MFX_ANGLE_90;
433  vpp->hflip = MFX_MIRRORING_DISABLED;
434  break;
435  case TRANSPOSE_CCLOCK:
436  vpp->rotate = MFX_ANGLE_270;
437  vpp->hflip = MFX_MIRRORING_DISABLED;
438  break;
440  vpp->rotate = MFX_ANGLE_90;
441  vpp->hflip = MFX_MIRRORING_HORIZONTAL;
442  break;
443  case TRANSPOSE_REVERSAL:
444  vpp->rotate = MFX_ANGLE_180;
445  vpp->hflip = MFX_MIRRORING_DISABLED;
446  break;
447  case TRANSPOSE_HFLIP:
448  vpp->rotate = MFX_ANGLE_0;
449  vpp->hflip = MFX_MIRRORING_HORIZONTAL;
450  break;
451  case TRANSPOSE_VFLIP:
452  vpp->rotate = MFX_ANGLE_180;
453  vpp->hflip = MFX_MIRRORING_HORIZONTAL;
454  break;
455  default:
456  av_log(ctx, AV_LOG_ERROR, "Failed to set transpose mode to %d.\n", vpp->transpose);
457  return AVERROR(EINVAL);
458  }
459 #else
460  av_log(ctx, AV_LOG_WARNING, "The QSV VPP transpose option is "
461  "not supported with this MSDK version.\n");
462  vpp->transpose = 0;
463 #endif
464  }
465 
466  if (vpp->rotate) {
467 #ifdef QSV_HAVE_ROTATION
468  memset(&vpp->rotation_conf, 0, sizeof(mfxExtVPPRotation));
469  vpp->rotation_conf.Header.BufferId = MFX_EXTBUFF_VPP_ROTATION;
470  vpp->rotation_conf.Header.BufferSz = sizeof(mfxExtVPPRotation);
471  vpp->rotation_conf.Angle = vpp->rotate;
472 
473  if (MFX_ANGLE_90 == vpp->rotate || MFX_ANGLE_270 == vpp->rotate) {
474  FFSWAP(int, vpp->out_width, vpp->out_height);
475  FFSWAP(int, outlink->w, outlink->h);
476  av_log(ctx, AV_LOG_DEBUG, "Swap width and height for clock/cclock rotation.\n");
477  }
478 
479  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->rotation_conf;
480 #else
481  av_log(ctx, AV_LOG_WARNING, "The QSV VPP rotate option is "
482  "not supported with this MSDK version.\n");
483  vpp->rotate = 0;
484 #endif
485  }
486 
487  if (vpp->hflip) {
488 #ifdef QSV_HAVE_MIRRORING
489  memset(&vpp->mirroring_conf, 0, sizeof(mfxExtVPPMirroring));
490  vpp->mirroring_conf.Header.BufferId = MFX_EXTBUFF_VPP_MIRRORING;
491  vpp->mirroring_conf.Header.BufferSz = sizeof(mfxExtVPPMirroring);
492  vpp->mirroring_conf.Type = vpp->hflip;
493 
494  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->mirroring_conf;
495 #else
496  av_log(ctx, AV_LOG_WARNING, "The QSV VPP hflip option is "
497  "not supported with this MSDK version.\n");
498  vpp->hflip = 0;
499 #endif
500  }
501 
502 #ifdef QSV_HAVE_SCALING_CONFIG
503  if (inlink->w != outlink->w || inlink->h != outlink->h) {
504  if (QSV_RUNTIME_VERSION_ATLEAST(mfx_version, 1, 19)) {
505  memset(&vpp->scale_conf, 0, sizeof(mfxExtVPPScaling));
506  vpp->scale_conf.Header.BufferId = MFX_EXTBUFF_VPP_SCALING;
507  vpp->scale_conf.Header.BufferSz = sizeof(mfxExtVPPScaling);
508  vpp->scale_conf.ScalingMode = vpp->scale_mode;
509 
510  param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->scale_conf;
511  } else
512  av_log(ctx, AV_LOG_WARNING, "The QSV VPP Scale option is "
513  "not supported with this MSDK version.\n");
514  }
515 #endif
516 
517  if (vpp->use_frc || vpp->use_crop || vpp->deinterlace || vpp->denoise ||
518  vpp->detail || vpp->procamp || vpp->rotate || vpp->hflip ||
519  inlink->w != outlink->w || inlink->h != outlink->h || in_format != vpp->out_format)
520  return ff_qsvvpp_create(ctx, &vpp->qsv, &param);
521  else {
522  av_log(ctx, AV_LOG_VERBOSE, "qsv vpp pass through mode.\n");
523  if (inlink->hw_frames_ctx)
524  outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx);
525  }
526 
527  return 0;
528 }
529 
531 {
532  AVFilterLink *inlink = ctx->inputs[0];
533  AVFilterLink *outlink = ctx->outputs[0];
534  VPPContext *s =ctx->priv;
535  QSVVPPContext *qsv = s->qsv;
536  AVFrame *in = NULL;
537  int ret, status = 0;
538  int64_t pts = AV_NOPTS_VALUE;
539 
541 
542  if (!s->eof) {
544  if (ret < 0)
545  return ret;
546 
548  if (status == AVERROR_EOF) {
549  s->eof = 1;
550  }
551  }
552  }
553 
554  if (qsv) {
555  if (in || s->eof) {
556  qsv->eof = s->eof;
557  ret = ff_qsvvpp_filter_frame(qsv, inlink, in);
558  av_frame_free(&in);
559 
560  if (s->eof) {
561  ff_outlink_set_status(outlink, status, pts);
562  return 0;
563  }
564 
565  if (qsv->got_frame) {
566  qsv->got_frame = 0;
567  return ret;
568  }
569  }
570  } else {
571  if (in) {
572  if (in->pts != AV_NOPTS_VALUE)
573  in->pts = av_rescale_q(in->pts, inlink->time_base, outlink->time_base);
574 
575  ret = ff_filter_frame(outlink, in);
576  return ret;
577  }
578  }
579 
580  if (s->eof) {
581  ff_outlink_set_status(outlink, status, pts);
582  return 0;
583  } else {
585  }
586 
587  return FFERROR_NOT_READY;
588 }
589 
591 {
592  int ret;
593  static const enum AVPixelFormat in_pix_fmts[] = {
600  };
601  static const enum AVPixelFormat out_pix_fmts[] = {
606  };
607 
609  &ctx->inputs[0]->outcfg.formats);
610  if (ret < 0)
611  return ret;
613  &ctx->outputs[0]->incfg.formats);
614 }
615 
617 {
618  VPPContext *vpp = ctx->priv;
619 
620  ff_qsvvpp_free(&vpp->qsv);
621 }
622 
623 static const AVClass vpp_class = {
624  .class_name = "vpp_qsv",
625  .item_name = av_default_item_name,
626  .option = options,
627  .version = LIBAVUTIL_VERSION_INT,
628 };
629 
630 static const AVFilterPad vpp_inputs[] = {
631  {
632  .name = "default",
633  .type = AVMEDIA_TYPE_VIDEO,
634  .config_props = config_input,
635  },
636 };
637 
638 static const AVFilterPad vpp_outputs[] = {
639  {
640  .name = "default",
641  .type = AVMEDIA_TYPE_VIDEO,
642  .config_props = config_output,
643  },
644 };
645 
647  .name = "vpp_qsv",
648  .description = NULL_IF_CONFIG_SMALL("Quick Sync Video VPP."),
649  .priv_size = sizeof(VPPContext),
650  .init = vpp_init,
651  .uninit = vpp_uninit,
655  .activate = activate,
656  .priv_class = &vpp_class,
657  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
658 };
VAR_oW
@ VAR_oW
Definition: vf_vpp_qsv.c:162
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:92
QSVVPPCrop::in_idx
int in_idx
Input index.
Definition: qsvvpp.h:80
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_vf_vpp_qsv
const AVFilter ff_vf_vpp_qsv
Definition: vf_vpp_qsv.c:646
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
VPPContext::eof
int eof
Definition: vf_vpp_qsv.c:104
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:380
OFFSET
#define OFFSET(x)
Definition: vf_vpp_qsv.c:41
FF_FILTER_FLAG_HWFRAME_AWARE
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
Definition: internal.h:370
QSVVPPParam::crop
QSVVPPCrop * crop
Definition: qsvvpp.h:97
QSVVPPParam::out_sw_format
enum AVPixelFormat out_sw_format
Definition: qsvvpp.h:93
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:999
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
VPPContext::cx
char * cx
Definition: vf_vpp_qsv.c:99
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
VPPContext::crop_w
int crop_w
Definition: vf_vpp_qsv.c:81
VPPContext::crop_h
int crop_h
Definition: vf_vpp_qsv.c:82
VPPContext::detail
int detail
Definition: vf_vpp_qsv.c:78
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:432
AVQSVDeviceContext
This struct is allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_qsv.h:35
AVOption
AVOption.
Definition: opt.h:251
VPPContext::scale_mode
int scale_mode
Definition: vf_vpp_qsv.c:90
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:167
VPPContext::contrast
float contrast
Definition: vf_vpp_qsv.c:96
vpp_uninit
static av_cold void vpp_uninit(AVFilterContext *ctx)
Definition: vf_vpp_qsv.c:616
VPPContext::qsv
QSVVPPContext * qsv
Definition: vf_vpp_qsv.c:53
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
float.h
TRANSPOSE_CLOCK_FLIP
@ TRANSPOSE_CLOCK_FLIP
Definition: transpose.h:34
VAR_OUT_H
@ VAR_OUT_H
Definition: vf_vpp_qsv.c:163
VPPContext::hue
float hue
Definition: vf_vpp_qsv.c:94
mathematics.h
CY
@ CY
Definition: vf_vpp_qsv.c:167
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
VAR_IN_H
@ VAR_IN_H
Definition: vf_vpp_qsv.c:161
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:230
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
formats.h
init
static int init
Definition: av_tx.c:47
TRANSPOSE_CCLOCK
@ TRANSPOSE_CCLOCK
Definition: transpose.h:33
framerate
int framerate
Definition: h264_levels.c:65
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1394
VAR_oH
@ VAR_oH
Definition: vf_vpp_qsv.c:163
VPPContext::saturation
float saturation
Definition: vf_vpp_qsv.c:95
qsvvpp.h
VAR_IN_W
@ VAR_IN_W
Definition: vf_vpp_qsv.c:160
VPPContext::transpose
int transpose
Definition: vf_vpp_qsv.c:86
pts
static int64_t pts
Definition: transcode_aac.c:654
PASS_EXPR
#define PASS_EXPR(e, s)
VPPContext::out_format
enum AVPixelFormat out_format
Output sw format.
Definition: vf_vpp_qsv.c:72
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
VPPContext::out_width
int out_width
Definition: vf_vpp_qsv.c:67
FLAGS
#define FLAGS
Definition: vf_vpp_qsv.c:42
TRANSPOSE_HFLIP
@ TRANSPOSE_HFLIP
Definition: transpose.h:36
in_pix_fmts
static enum AVPixelFormat in_pix_fmts[]
Definition: vf_ciescope.c:128
VPPContext::crop_x
int crop_x
Definition: vf_vpp_qsv.c:83
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
VPPContext::use_frc
int use_frc
Definition: vf_vpp_qsv.c:75
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
QSVVPPCrop::w
int w
Definition: qsvvpp.h:81
s
#define s(width, name)
Definition: cbs_vp9.c:256
VPPContext::denoise_conf
mfxExtVPPDenoise denoise_conf
Definition: vf_vpp_qsv.c:58
ff_qsvvpp_create
int ff_qsvvpp_create(AVFilterContext *avctx, QSVVPPContext **vpp, QSVVPPParam *param)
Definition: qsvvpp.c:650
QSV_RUNTIME_VERSION_ATLEAST
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:61
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:596
filters.h
var_name
var_name
Definition: noise_bsf.c:46
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
activate
static int activate(AVFilterContext *ctx)
Definition: vf_vpp_qsv.c:530
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVExpr
Definition: eval.c:157
VPPContext::detail_conf
mfxExtVPPDetail detail_conf
Definition: vf_vpp_qsv.c:59
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
NAN
#define NAN
Definition: mathematics.h:64
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:190
options
static const AVOption options[]
Definition: vf_vpp_qsv.c:107
QSVVPPParam::async_depth
int async_depth
Definition: qsvvpp.h:99
VAR_iW
@ VAR_iW
Definition: vf_vpp_qsv.c:160
QSVVPPContext
Definition: qsvvpp.h:50
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
ENH_FILTERS_COUNT
#define ENH_FILTERS_COUNT
Definition: vf_vpp_qsv.c:45
QSVVPPParam::num_crop
int num_crop
Definition: qsvvpp.h:96
QSVVPPParam
Definition: qsvvpp.h:84
QSVVPPCrop::x
int x
Definition: qsvvpp.h:81
VPPContext::cw
char * cw
Definition: vf_vpp_qsv.c:99
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVHWFramesContext::device_ref
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:141
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
VPPContext::deinterlace
int deinterlace
Definition: vf_vpp_qsv.c:76
CALC_EXPR
#define CALC_EXPR(e, v, i)
VAR_H
@ VAR_H
Definition: vf_vpp_qsv.c:163
VPPContext::deinterlace_conf
mfxExtVPPDeinterlacing deinterlace_conf
Definition: vf_vpp_qsv.c:56
VPPContext::frc_conf
mfxExtVPPFrameRateConversion frc_conf
Definition: vf_vpp_qsv.c:57
vpp_inputs
static const AVFilterPad vpp_inputs[]
Definition: vf_vpp_qsv.c:630
VPPContext::denoise
int denoise
Definition: vf_vpp_qsv.c:77
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:212
VPPContext
Definition: vf_vpp_qsv.c:50
QSVVPPContext::got_frame
int got_frame
Definition: qsvvpp.h:72
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1348
ff_qsvvpp_free
int ff_qsvvpp_free(QSVVPPContext **vpp)
Definition: qsvvpp.c:768
VPPContext::ow
char * ow
Definition: vf_vpp_qsv.c:100
VPPContext::hflip
int hflip
Definition: vf_vpp_qsv.c:88
VPPContext::scale_conf
mfxExtVPPScaling scale_conf
Definition: vf_vpp_qsv.c:64
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_vpp_qsv.c:590
eval.h
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
VAR_W
@ VAR_W
Definition: vf_vpp_qsv.c:162
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_vpp_qsv.c:264
VPPContext::rotate
int rotate
Definition: vf_vpp_qsv.c:87
VAR_iH
@ VAR_iH
Definition: vf_vpp_qsv.c:161
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
VAR_OUT_W
@ VAR_OUT_W
Definition: vf_vpp_qsv.c:162
VPPContext::output_format_str
char * output_format_str
Definition: vf_vpp_qsv.c:101
VAR_VARS_NB
@ VAR_VARS_NB
Definition: vf_vpp_qsv.c:168
VPPContext::ch
char * ch
Definition: vf_vpp_qsv.c:99
VPPContext::procamp_conf
mfxExtVPPProcAmp procamp_conf
Definition: vf_vpp_qsv.c:60
CH
@ CH
Definition: vf_vpp_qsv.c:165
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:379
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
QSVVPPContext::eof
int eof
Definition: qsvvpp.h:74
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
denoise
#define denoise(...)
Definition: vf_hqdn3d.c:156
hwcontext_qsv.h
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_vpp_qsv.c:326
VPPContext::rotation_conf
mfxExtVPPRotation rotation_conf
Definition: vf_vpp_qsv.c:61
out_pix_fmts
static enum AVPixelFormat out_pix_fmts[]
Definition: vf_ciescope.c:137
QSVVPPParam::num_ext_buf
int num_ext_buf
Definition: qsvvpp.h:89
get_mfx_version
static mfxStatus get_mfx_version(const AVFilterContext *ctx, mfxVersion *mfx_version)
Definition: vf_vpp_qsv.c:300
TRANSPOSE_CLOCK
@ TRANSPOSE_CLOCK
Definition: transpose.h:32
QSVVPPParam::filter_frame
int(* filter_frame)(AVFilterLink *outlink, AVFrame *frame)
Definition: qsvvpp.h:86
VPPContext::crop_y
int crop_y
Definition: vf_vpp_qsv.c:84
VPPContext::framerate
AVRational framerate
Definition: vf_vpp_qsv.c:74
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
VPPContext::out_height
int out_height
Definition: vf_vpp_qsv.c:68
vpp_init
static av_cold int vpp_init(AVFilterContext *ctx)
Definition: vf_vpp_qsv.c:247
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVFilter
Filter definition.
Definition: avfilter.h:171
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
ret
ret
Definition: filter_design.txt:187
VPPContext::async_depth
int async_depth
Definition: vf_vpp_qsv.c:103
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2594
QSVVPPCrop::h
int h
Crop rectangle.
Definition: qsvvpp.h:81
QSVVPPCrop::y
int y
Definition: qsvvpp.h:81
VPPContext::oh
char * oh
Definition: vf_vpp_qsv.c:100
TRANSPOSE_CCLOCK_FLIP
@ TRANSPOSE_CCLOCK_FLIP
Definition: transpose.h:31
ff_qsvvpp_filter_frame
int ff_qsvvpp_filter_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picref)
Definition: qsvvpp.c:793
eval_expr
static int eval_expr(AVFilterContext *ctx)
Definition: vf_vpp_qsv.c:171
AVQSVDeviceContext::session
mfxSession session
Definition: hwcontext_qsv.h:36
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
vpp_class
static const AVClass vpp_class
Definition: vf_vpp_qsv.c:623
VPPContext::use_crop
int use_crop
Definition: vf_vpp_qsv.c:80
transpose.h
TRANSPOSE_REVERSAL
@ TRANSPOSE_REVERSAL
Definition: transpose.h:35
VPPContext::cy
char * cy
Definition: vf_vpp_qsv.c:99
AVFilterContext
An instance of a filter.
Definition: avfilter.h:408
TRANSPOSE_VFLIP
@ TRANSPOSE_VFLIP
Definition: transpose.h:37
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:455
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
var_names
static const char *const var_names[]
Definition: vf_vpp_qsv.c:147
CW
@ CW
Definition: vf_vpp_qsv.c:164
VPPContext::mirroring_conf
mfxExtVPPMirroring mirroring_conf
Definition: vf_vpp_qsv.c:62
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
CX
@ CX
Definition: vf_vpp_qsv.c:166
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:285
QSVVPPCrop
Definition: qsvvpp.h:79
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
transpose
#define transpose(x)
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
VPPContext::brightness
float brightness
Definition: vf_vpp_qsv.c:97
VPPContext::procamp
int procamp
Definition: vf_vpp_qsv.c:93
QSVVPPParam::ext_buf
mfxExtBuffer ** ext_buf
Definition: qsvvpp.h:90
vpp_outputs
static const AVFilterPad vpp_outputs[]
Definition: vf_vpp_qsv.c:638