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" }, 0, 0, FLAGS },
122 { "ch", "set the height crop area expression", OFFSET(ch), AV_OPT_TYPE_STRING, { .str = "ih" }, 0, 0, FLAGS },
123 { "cx", "set the x crop area expression", OFFSET(cx), AV_OPT_TYPE_STRING, { .str = "(in_w-out_w)/2" }, 0, 0, FLAGS },
124 { "cy", "set the y crop area expression", OFFSET(cy), AV_OPT_TYPE_STRING, { .str = "(in_h-out_h)/2" }, 0, 0, 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
eval_expr(AVFilterContext * ctx)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
vpp_init(AVFilterContext * ctx)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
config_input(AVFilterLink * inlink)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
config_output(AVFilterLink * outlink)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 if (vpp->out_format == AV_PIX_FMT_NONE)
316 vpp->out_format = in_format;
317 param.out_sw_format = vpp->out_format;
318
319 if (vpp->use_crop) {
320 crop.in_idx = 0;
321 crop.x = vpp->crop_x;
322 crop.y = vpp->crop_y;
323 crop.w = vpp->crop_w;
324 crop.h = vpp->crop_h;
325
326 param.num_crop = 1;
327 param.crop = &crop;
328 }
329
330 if (vpp->deinterlace) {
331 memset(&vpp->deinterlace_conf, 0, sizeof(mfxExtVPPDeinterlacing));
332 vpp->deinterlace_conf.Header.BufferId = MFX_EXTBUFF_VPP_DEINTERLACING;
333 vpp->deinterlace_conf.Header.BufferSz = sizeof(mfxExtVPPDeinterlacing);
334 vpp->deinterlace_conf.Mode = vpp->deinterlace == 1 ?
335 MFX_DEINTERLACING_BOB : MFX_DEINTERLACING_ADVANCED;
336
337 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->deinterlace_conf;
338 }
339
340 if (vpp->use_frc) {
341 memset(&vpp->frc_conf, 0, sizeof(mfxExtVPPFrameRateConversion));
342 vpp->frc_conf.Header.BufferId = MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION;
343 vpp->frc_conf.Header.BufferSz = sizeof(mfxExtVPPFrameRateConversion);
344 vpp->frc_conf.Algorithm = MFX_FRCALGM_DISTRIBUTED_TIMESTAMP;
345
346 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->frc_conf;
347 }
348
349 if (vpp->denoise) {
350 memset(&vpp->denoise_conf, 0, sizeof(mfxExtVPPDenoise));
351 vpp->denoise_conf.Header.BufferId = MFX_EXTBUFF_VPP_DENOISE;
352 vpp->denoise_conf.Header.BufferSz = sizeof(mfxExtVPPDenoise);
353 vpp->denoise_conf.DenoiseFactor = vpp->denoise;
354
355 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->denoise_conf;
356 }
357
358 if (vpp->detail) {
359 memset(&vpp->detail_conf, 0, sizeof(mfxExtVPPDetail));
360 vpp->detail_conf.Header.BufferId = MFX_EXTBUFF_VPP_DETAIL;
361 vpp->detail_conf.Header.BufferSz = sizeof(mfxExtVPPDetail);
362 vpp->detail_conf.DetailFactor = vpp->detail;
363
364 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->detail_conf;
365 }
366
367 if (vpp->procamp) {
368 memset(&vpp->procamp_conf, 0, sizeof(mfxExtVPPProcAmp));
369 vpp->procamp_conf.Header.BufferId = MFX_EXTBUFF_VPP_PROCAMP;
370 vpp->procamp_conf.Header.BufferSz = sizeof(mfxExtVPPProcAmp);
371 vpp->procamp_conf.Hue = vpp->hue;
372 vpp->procamp_conf.Saturation = vpp->saturation;
373 vpp->procamp_conf.Contrast = vpp->contrast;
374 vpp->procamp_conf.Brightness = vpp->brightness;
375
376 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->procamp_conf;
377 }
378
379 if (vpp->transpose >= 0) {
380 #ifdef QSV_HAVE_ROTATION
381 switch (vpp->transpose) {
382 case TRANSPOSE_CCLOCK_FLIP:
383 vpp->rotate = MFX_ANGLE_270;
384 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
385 break;
386 case TRANSPOSE_CLOCK:
387 vpp->rotate = MFX_ANGLE_90;
388 vpp->hflip = MFX_MIRRORING_DISABLED;
389 break;
390 case TRANSPOSE_CCLOCK:
391 vpp->rotate = MFX_ANGLE_270;
392 vpp->hflip = MFX_MIRRORING_DISABLED;
393 break;
394 case TRANSPOSE_CLOCK_FLIP:
395 vpp->rotate = MFX_ANGLE_90;
396 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
397 break;
398 case TRANSPOSE_REVERSAL:
399 vpp->rotate = MFX_ANGLE_180;
400 vpp->hflip = MFX_MIRRORING_DISABLED;
401 break;
402 case TRANSPOSE_HFLIP:
403 vpp->rotate = MFX_ANGLE_0;
404 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
405 break;
406 case TRANSPOSE_VFLIP:
407 vpp->rotate = MFX_ANGLE_180;
408 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
409 break;
410 default:
411 av_log(ctx, AV_LOG_ERROR, "Failed to set transpose mode to %d.\n", vpp->transpose);
412 return AVERROR(EINVAL);
413 }
414 #else
415 av_log(ctx, AV_LOG_WARNING, "The QSV VPP transpose option is "
416 "not supported with this MSDK version.\n");
417 vpp->transpose = 0;
418 #endif
419 }
420
421 if (vpp->rotate) {
422 #ifdef QSV_HAVE_ROTATION
423 memset(&vpp->rotation_conf, 0, sizeof(mfxExtVPPRotation));
424 vpp->rotation_conf.Header.BufferId = MFX_EXTBUFF_VPP_ROTATION;
425 vpp->rotation_conf.Header.BufferSz = sizeof(mfxExtVPPRotation);
426 vpp->rotation_conf.Angle = vpp->rotate;
427
428 if (MFX_ANGLE_90 == vpp->rotate || MFX_ANGLE_270 == vpp->rotate) {
429 FFSWAP(int, vpp->out_width, vpp->out_height);
430 FFSWAP(int, outlink->w, outlink->h);
431 av_log(ctx, AV_LOG_DEBUG, "Swap width and height for clock/cclock rotation.\n");
432 }
433
434 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->rotation_conf;
435 #else
436 av_log(ctx, AV_LOG_WARNING, "The QSV VPP rotate option is "
437 "not supported with this MSDK version.\n");
438 vpp->rotate = 0;
439 #endif
440 }
441
442 if (vpp->hflip) {
443 #ifdef QSV_HAVE_MIRRORING
444 memset(&vpp->mirroring_conf, 0, sizeof(mfxExtVPPMirroring));
445 vpp->mirroring_conf.Header.BufferId = MFX_EXTBUFF_VPP_MIRRORING;
446 vpp->mirroring_conf.Header.BufferSz = sizeof(mfxExtVPPMirroring);
447 vpp->mirroring_conf.Type = vpp->hflip;
448
449 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->mirroring_conf;
450 #else
451 av_log(ctx, AV_LOG_WARNING, "The QSV VPP hflip option is "
452 "not supported with this MSDK version.\n");
453 vpp->hflip = 0;
454 #endif
455 }
456
457 if (vpp->use_frc || vpp->use_crop || vpp->deinterlace || vpp->denoise ||
458 vpp->detail || vpp->procamp || vpp->rotate || vpp->hflip ||
459 inlink->w != outlink->w || inlink->h != outlink->h || in_format != vpp->out_format)
460 return ff_qsvvpp_create(ctx, &vpp->qsv, ¶m);
461 else {
462 av_log(ctx, AV_LOG_VERBOSE, "qsv vpp pass through mode.\n");
463 if (inlink->hw_frames_ctx)
464 outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx);
465 }
466
467 return 0;
468 }
469
filter_frame(AVFilterLink * inlink,AVFrame * picref)470 static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
471 {
472 int ret = 0;
473 AVFilterContext *ctx = inlink->dst;
474 VPPContext *vpp = inlink->dst->priv;
475 AVFilterLink *outlink = ctx->outputs[0];
476
477 if (vpp->qsv) {
478 ret = ff_qsvvpp_filter_frame(vpp->qsv, inlink, picref);
479 av_frame_free(&picref);
480 } else {
481 if (picref->pts != AV_NOPTS_VALUE)
482 picref->pts = av_rescale_q(picref->pts, inlink->time_base, outlink->time_base);
483 ret = ff_filter_frame(outlink, picref);
484 }
485
486 return ret;
487 }
488
query_formats(AVFilterContext * ctx)489 static int query_formats(AVFilterContext *ctx)
490 {
491 int ret;
492 static const enum AVPixelFormat in_pix_fmts[] = {
493 AV_PIX_FMT_YUV420P,
494 AV_PIX_FMT_NV12,
495 AV_PIX_FMT_YUYV422,
496 AV_PIX_FMT_RGB32,
497 AV_PIX_FMT_QSV,
498 AV_PIX_FMT_NONE
499 };
500 static const enum AVPixelFormat out_pix_fmts[] = {
501 AV_PIX_FMT_NV12,
502 AV_PIX_FMT_P010,
503 AV_PIX_FMT_QSV,
504 AV_PIX_FMT_NONE
505 };
506
507 ret = ff_formats_ref(ff_make_format_list(in_pix_fmts),
508 &ctx->inputs[0]->outcfg.formats);
509 if (ret < 0)
510 return ret;
511 return ff_formats_ref(ff_make_format_list(out_pix_fmts),
512 &ctx->outputs[0]->incfg.formats);
513 }
514
vpp_uninit(AVFilterContext * ctx)515 static av_cold void vpp_uninit(AVFilterContext *ctx)
516 {
517 VPPContext *vpp = ctx->priv;
518
519 ff_qsvvpp_free(&vpp->qsv);
520 }
521
522 static const AVClass vpp_class = {
523 .class_name = "vpp_qsv",
524 .item_name = av_default_item_name,
525 .option = options,
526 .version = LIBAVUTIL_VERSION_INT,
527 };
528
529 static const AVFilterPad vpp_inputs[] = {
530 {
531 .name = "default",
532 .type = AVMEDIA_TYPE_VIDEO,
533 .config_props = config_input,
534 .filter_frame = filter_frame,
535 },
536 { NULL }
537 };
538
539 static const AVFilterPad vpp_outputs[] = {
540 {
541 .name = "default",
542 .type = AVMEDIA_TYPE_VIDEO,
543 .config_props = config_output,
544 },
545 { NULL }
546 };
547
548 AVFilter ff_vf_vpp_qsv = {
549 .name = "vpp_qsv",
550 .description = NULL_IF_CONFIG_SMALL("Quick Sync Video VPP."),
551 .priv_size = sizeof(VPPContext),
552 .query_formats = query_formats,
553 .init = vpp_init,
554 .uninit = vpp_uninit,
555 .inputs = vpp_inputs,
556 .outputs = vpp_outputs,
557 .priv_class = &vpp_class,
558 .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
559 };
560