FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vaapi_vpp.c
Date: 2022-12-05 20:26:17
Exec Total Coverage
Lines: 0 318 0.0%
Functions: 0 15 0.0%
Branches: 0 155 0.0%

Line Branch Exec Source
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 #include <string.h>
20
21 #include "libavutil/avassert.h"
22 #include "libavutil/pixdesc.h"
23 #include "formats.h"
24 #include "internal.h"
25 #include "vaapi_vpp.h"
26
27 int ff_vaapi_vpp_query_formats(AVFilterContext *avctx)
28 {
29 enum AVPixelFormat pix_fmts[] = {
30 AV_PIX_FMT_VAAPI, AV_PIX_FMT_NONE,
31 };
32 int err;
33
34 if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
35 &avctx->inputs[0]->outcfg.formats)) < 0)
36 return err;
37 if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
38 &avctx->outputs[0]->incfg.formats)) < 0)
39 return err;
40
41 return 0;
42 }
43
44 void ff_vaapi_vpp_pipeline_uninit(AVFilterContext *avctx)
45 {
46 VAAPIVPPContext *ctx = avctx->priv;
47 int i;
48 for (i = 0; i < ctx->nb_filter_buffers; i++) {
49 if (ctx->filter_buffers[i] != VA_INVALID_ID) {
50 vaDestroyBuffer(ctx->hwctx->display, ctx->filter_buffers[i]);
51 ctx->filter_buffers[i] = VA_INVALID_ID;
52 }
53 }
54 ctx->nb_filter_buffers = 0;
55
56 if (ctx->va_context != VA_INVALID_ID) {
57 vaDestroyContext(ctx->hwctx->display, ctx->va_context);
58 ctx->va_context = VA_INVALID_ID;
59 }
60
61 if (ctx->va_config != VA_INVALID_ID) {
62 vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
63 ctx->va_config = VA_INVALID_ID;
64 }
65
66 av_buffer_unref(&ctx->device_ref);
67 ctx->hwctx = NULL;
68 }
69
70 int ff_vaapi_vpp_config_input(AVFilterLink *inlink)
71 {
72 AVFilterContext *avctx = inlink->dst;
73 VAAPIVPPContext *ctx = avctx->priv;
74
75 if (ctx->pipeline_uninit)
76 ctx->pipeline_uninit(avctx);
77
78 if (!inlink->hw_frames_ctx) {
79 av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
80 "required to associate the processing device.\n");
81 return AVERROR(EINVAL);
82 }
83
84 ctx->input_frames_ref = av_buffer_ref(inlink->hw_frames_ctx);
85 if (!ctx->input_frames_ref) {
86 av_log(avctx, AV_LOG_ERROR, "A input frames reference create "
87 "failed.\n");
88 return AVERROR(ENOMEM);
89 }
90 ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
91
92 return 0;
93 }
94
95 int ff_vaapi_vpp_config_output(AVFilterLink *outlink)
96 {
97 AVFilterContext *avctx = outlink->src;
98 VAAPIVPPContext *ctx = avctx->priv;
99 AVVAAPIHWConfig *hwconfig = NULL;
100 AVHWFramesConstraints *constraints = NULL;
101 AVHWFramesContext *output_frames;
102 AVVAAPIFramesContext *va_frames;
103 VAStatus vas;
104 int err, i;
105
106 if (ctx->pipeline_uninit)
107 ctx->pipeline_uninit(avctx);
108
109 if (!ctx->output_width)
110 ctx->output_width = avctx->inputs[0]->w;
111 if (!ctx->output_height)
112 ctx->output_height = avctx->inputs[0]->h;
113
114 av_assert0(ctx->input_frames);
115 ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
116 if (!ctx->device_ref) {
117 av_log(avctx, AV_LOG_ERROR, "A device reference create "
118 "failed.\n");
119 return AVERROR(ENOMEM);
120 }
121 ctx->hwctx = ((AVHWDeviceContext*)ctx->device_ref->data)->hwctx;
122
123 av_assert0(ctx->va_config == VA_INVALID_ID);
124 vas = vaCreateConfig(ctx->hwctx->display, VAProfileNone,
125 VAEntrypointVideoProc, NULL, 0, &ctx->va_config);
126 if (vas != VA_STATUS_SUCCESS) {
127 av_log(avctx, AV_LOG_ERROR, "Failed to create processing pipeline "
128 "config: %d (%s).\n", vas, vaErrorStr(vas));
129 err = AVERROR(EIO);
130 goto fail;
131 }
132
133 hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
134 if (!hwconfig) {
135 err = AVERROR(ENOMEM);
136 goto fail;
137 }
138 hwconfig->config_id = ctx->va_config;
139
140 constraints = av_hwdevice_get_hwframe_constraints(ctx->device_ref,
141 hwconfig);
142 if (!constraints) {
143 err = AVERROR(ENOMEM);
144 goto fail;
145 }
146
147 if (ctx->output_format == AV_PIX_FMT_NONE)
148 ctx->output_format = ctx->input_frames->sw_format;
149 if (constraints->valid_sw_formats) {
150 for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
151 if (ctx->output_format == constraints->valid_sw_formats[i])
152 break;
153 }
154 if (constraints->valid_sw_formats[i] == AV_PIX_FMT_NONE) {
155 av_log(avctx, AV_LOG_ERROR, "Hardware does not support output "
156 "format %s.\n", av_get_pix_fmt_name(ctx->output_format));
157 err = AVERROR(EINVAL);
158 goto fail;
159 }
160 }
161
162 if (ctx->output_width < constraints->min_width ||
163 ctx->output_height < constraints->min_height ||
164 ctx->output_width > constraints->max_width ||
165 ctx->output_height > constraints->max_height) {
166 av_log(avctx, AV_LOG_ERROR, "Hardware does not support scaling to "
167 "size %dx%d (constraints: width %d-%d height %d-%d).\n",
168 ctx->output_width, ctx->output_height,
169 constraints->min_width, constraints->max_width,
170 constraints->min_height, constraints->max_height);
171 err = AVERROR(EINVAL);
172 goto fail;
173 }
174
175 outlink->hw_frames_ctx = av_hwframe_ctx_alloc(ctx->device_ref);
176 if (!outlink->hw_frames_ctx) {
177 av_log(avctx, AV_LOG_ERROR, "Failed to create HW frame context "
178 "for output.\n");
179 err = AVERROR(ENOMEM);
180 goto fail;
181 }
182
183 output_frames = (AVHWFramesContext*)outlink->hw_frames_ctx->data;
184
185 output_frames->format = AV_PIX_FMT_VAAPI;
186 output_frames->sw_format = ctx->output_format;
187 output_frames->width = ctx->output_width;
188 output_frames->height = ctx->output_height;
189
190 output_frames->initial_pool_size = 4;
191
192 err = ff_filter_init_hw_frames(avctx, outlink, 10);
193 if (err < 0)
194 goto fail;
195
196 err = av_hwframe_ctx_init(outlink->hw_frames_ctx);
197 if (err < 0) {
198 av_log(avctx, AV_LOG_ERROR, "Failed to initialise VAAPI frame "
199 "context for output: %d\n", err);
200 goto fail;
201 }
202
203 va_frames = output_frames->hwctx;
204
205 av_assert0(ctx->va_context == VA_INVALID_ID);
206 vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
207 ctx->output_width, ctx->output_height,
208 VA_PROGRESSIVE,
209 va_frames->surface_ids, va_frames->nb_surfaces,
210 &ctx->va_context);
211 if (vas != VA_STATUS_SUCCESS) {
212 av_log(avctx, AV_LOG_ERROR, "Failed to create processing pipeline "
213 "context: %d (%s).\n", vas, vaErrorStr(vas));
214 return AVERROR(EIO);
215 }
216
217 outlink->w = ctx->output_width;
218 outlink->h = ctx->output_height;
219
220 if (ctx->build_filter_params) {
221 err = ctx->build_filter_params(avctx);
222 if (err < 0)
223 goto fail;
224 }
225
226 av_freep(&hwconfig);
227 av_hwframe_constraints_free(&constraints);
228 return 0;
229
230 fail:
231 av_buffer_unref(&outlink->hw_frames_ctx);
232 av_freep(&hwconfig);
233 av_hwframe_constraints_free(&constraints);
234 return err;
235 }
236
237 typedef struct VAAPIColourProperties {
238 VAProcColorStandardType va_color_standard;
239
240 enum AVColorPrimaries color_primaries;
241 enum AVColorTransferCharacteristic color_trc;
242 enum AVColorSpace colorspace;
243
244 uint8_t va_chroma_sample_location;
245 uint8_t va_color_range;
246
247 enum AVColorRange color_range;
248 enum AVChromaLocation chroma_sample_location;
249 } VAAPIColourProperties;
250
251 static const VAAPIColourProperties vaapi_colour_standard_map[] = {
252 { VAProcColorStandardBT601, 5, 6, 5 },
253 { VAProcColorStandardBT601, 6, 6, 6 },
254 { VAProcColorStandardBT709, 1, 1, 1 },
255 { VAProcColorStandardBT470M, 4, 4, 4 },
256 { VAProcColorStandardBT470BG, 5, 5, 5 },
257 { VAProcColorStandardSMPTE170M, 6, 6, 6 },
258 { VAProcColorStandardSMPTE240M, 7, 7, 7 },
259 { VAProcColorStandardGenericFilm, 8, 1, 1 },
260 #if VA_CHECK_VERSION(1, 1, 0)
261 { VAProcColorStandardSRGB, 1, 13, 0 },
262 { VAProcColorStandardXVYCC601, 1, 11, 5 },
263 { VAProcColorStandardXVYCC709, 1, 11, 1 },
264 { VAProcColorStandardBT2020, 9, 14, 9 },
265 #endif
266 };
267
268 static void vaapi_vpp_fill_colour_standard(VAAPIColourProperties *props,
269 VAProcColorStandardType *vacs,
270 int nb_vacs)
271 {
272 const VAAPIColourProperties *t;
273 int i, j, score, best_score, worst_score;
274 VAProcColorStandardType best_standard;
275
276 #if VA_CHECK_VERSION(1, 3, 0)
277 // If the driver supports explicit use of the standard values then just
278 // use them and avoid doing any mapping. (The driver may not support
279 // some particular code point, but it still has enough information to
280 // make a better fallback choice than we do in that case.)
281 for (i = 0; i < nb_vacs; i++) {
282 if (vacs[i] == VAProcColorStandardExplicit) {
283 props->va_color_standard = VAProcColorStandardExplicit;
284 return;
285 }
286 }
287 #endif
288
289 // Give scores to the possible options and choose the lowest one.
290 // An exact match will score zero and therefore always be chosen, as
291 // will a partial match where all unmatched elements are explicitly
292 // unspecified. If no options match at all then just pass "none" to
293 // the driver and let it make its own choice.
294 best_standard = VAProcColorStandardNone;
295 best_score = -1;
296 worst_score = 4 * (props->colorspace != AVCOL_SPC_UNSPECIFIED &&
297 props->colorspace != AVCOL_SPC_RGB) +
298 2 * (props->color_trc != AVCOL_TRC_UNSPECIFIED) +
299 (props->color_primaries != AVCOL_PRI_UNSPECIFIED);
300
301 if (worst_score == 0) {
302 // No properties are specified, so we aren't going to be able to
303 // make a useful choice.
304 props->va_color_standard = VAProcColorStandardNone;
305 return;
306 }
307
308 for (i = 0; i < nb_vacs; i++) {
309 for (j = 0; j < FF_ARRAY_ELEMS(vaapi_colour_standard_map); j++) {
310 t = &vaapi_colour_standard_map[j];
311 if (t->va_color_standard != vacs[i])
312 continue;
313
314 score = 0;
315 if (props->colorspace != AVCOL_SPC_UNSPECIFIED &&
316 props->colorspace != AVCOL_SPC_RGB)
317 score += 4 * (props->colorspace != t->colorspace);
318 if (props->color_trc != AVCOL_TRC_UNSPECIFIED)
319 score += 2 * (props->color_trc != t->color_trc);
320 if (props->color_primaries != AVCOL_PRI_UNSPECIFIED)
321 score += (props->color_primaries != t->color_primaries);
322
323 // Only include choices which matched something.
324 if (score < worst_score &&
325 (best_score == -1 || score < best_score)) {
326 best_score = score;
327 best_standard = t->va_color_standard;
328 }
329 }
330 }
331 props->va_color_standard = best_standard;
332 }
333
334 static void vaapi_vpp_fill_chroma_sample_location(VAAPIColourProperties *props)
335 {
336 #if VA_CHECK_VERSION(1, 1, 0)
337 static const struct {
338 enum AVChromaLocation av;
339 uint8_t va;
340 } csl_map[] = {
341 { AVCHROMA_LOC_UNSPECIFIED, VA_CHROMA_SITING_UNKNOWN },
342 { AVCHROMA_LOC_LEFT, VA_CHROMA_SITING_VERTICAL_CENTER |
343 VA_CHROMA_SITING_HORIZONTAL_LEFT },
344 { AVCHROMA_LOC_CENTER, VA_CHROMA_SITING_VERTICAL_CENTER |
345 VA_CHROMA_SITING_HORIZONTAL_CENTER },
346 { AVCHROMA_LOC_TOPLEFT, VA_CHROMA_SITING_VERTICAL_TOP |
347 VA_CHROMA_SITING_HORIZONTAL_LEFT },
348 { AVCHROMA_LOC_TOP, VA_CHROMA_SITING_VERTICAL_TOP |
349 VA_CHROMA_SITING_HORIZONTAL_CENTER },
350 { AVCHROMA_LOC_BOTTOMLEFT, VA_CHROMA_SITING_VERTICAL_BOTTOM |
351 VA_CHROMA_SITING_HORIZONTAL_LEFT },
352 { AVCHROMA_LOC_BOTTOM, VA_CHROMA_SITING_VERTICAL_BOTTOM |
353 VA_CHROMA_SITING_HORIZONTAL_CENTER },
354 };
355 int i;
356
357 for (i = 0; i < FF_ARRAY_ELEMS(csl_map); i++) {
358 if (props->chroma_sample_location == csl_map[i].av) {
359 props->va_chroma_sample_location = csl_map[i].va;
360 return;
361 }
362 }
363 props->va_chroma_sample_location = VA_CHROMA_SITING_UNKNOWN;
364 #else
365 props->va_chroma_sample_location = 0;
366 #endif
367 }
368
369 static void vaapi_vpp_fill_colour_range(VAAPIColourProperties *props)
370 {
371 #if VA_CHECK_VERSION(1, 1, 0)
372 switch (props->color_range) {
373 case AVCOL_RANGE_MPEG:
374 props->va_color_range = VA_SOURCE_RANGE_REDUCED;
375 break;
376 case AVCOL_RANGE_JPEG:
377 props->va_color_range = VA_SOURCE_RANGE_FULL;
378 break;
379 case AVCOL_RANGE_UNSPECIFIED:
380 default:
381 props->va_color_range = VA_SOURCE_RANGE_UNKNOWN;
382 }
383 #else
384 props->va_color_range = 0;
385 #endif
386 }
387
388 static void vaapi_vpp_fill_colour_properties(AVFilterContext *avctx,
389 VAAPIColourProperties *props,
390 VAProcColorStandardType *vacs,
391 int nb_vacs)
392 {
393 vaapi_vpp_fill_colour_standard(props, vacs, nb_vacs);
394 vaapi_vpp_fill_chroma_sample_location(props);
395 vaapi_vpp_fill_colour_range(props);
396
397 av_log(avctx, AV_LOG_DEBUG, "Mapped colour properties %s %s/%s/%s %s "
398 "to VA standard %d chroma siting %#x range %#x.\n",
399 av_color_range_name(props->color_range),
400 av_color_space_name(props->colorspace),
401 av_color_primaries_name(props->color_primaries),
402 av_color_transfer_name(props->color_trc),
403 av_chroma_location_name(props->chroma_sample_location),
404 props->va_color_standard,
405 props->va_chroma_sample_location, props->va_color_range);
406 }
407
408 static int vaapi_vpp_frame_is_rgb(const AVFrame *frame)
409 {
410 const AVHWFramesContext *hwfc;
411 const AVPixFmtDescriptor *desc;
412 av_assert0(frame->format == AV_PIX_FMT_VAAPI &&
413 frame->hw_frames_ctx);
414 hwfc = (const AVHWFramesContext*)frame->hw_frames_ctx->data;
415 desc = av_pix_fmt_desc_get(hwfc->sw_format);
416 av_assert0(desc);
417 return !!(desc->flags & AV_PIX_FMT_FLAG_RGB);
418 }
419
420 static int vaapi_vpp_colour_properties(AVFilterContext *avctx,
421 VAProcPipelineParameterBuffer *params,
422 const AVFrame *input_frame,
423 AVFrame *output_frame)
424 {
425 VAAPIVPPContext *ctx = avctx->priv;
426 VAAPIColourProperties input_props, output_props;
427 VAProcPipelineCaps caps;
428 VAStatus vas;
429
430 vas = vaQueryVideoProcPipelineCaps(ctx->hwctx->display, ctx->va_context,
431 ctx->filter_buffers, ctx->nb_filter_buffers,
432 &caps);
433 if (vas != VA_STATUS_SUCCESS) {
434 av_log(avctx, AV_LOG_ERROR, "Failed to query capabilities for "
435 "colour standard support: %d (%s).\n", vas, vaErrorStr(vas));
436 return AVERROR_EXTERNAL;
437 }
438
439 input_props = (VAAPIColourProperties) {
440 .colorspace = vaapi_vpp_frame_is_rgb(input_frame)
441 ? AVCOL_SPC_RGB : input_frame->colorspace,
442 .color_primaries = input_frame->color_primaries,
443 .color_trc = input_frame->color_trc,
444 .color_range = input_frame->color_range,
445 .chroma_sample_location = input_frame->chroma_location,
446 };
447
448 vaapi_vpp_fill_colour_properties(avctx, &input_props,
449 caps.input_color_standards,
450 caps.num_input_color_standards);
451
452 output_props = (VAAPIColourProperties) {
453 .colorspace = vaapi_vpp_frame_is_rgb(output_frame)
454 ? AVCOL_SPC_RGB : output_frame->colorspace,
455 .color_primaries = output_frame->color_primaries,
456 .color_trc = output_frame->color_trc,
457 .color_range = output_frame->color_range,
458 .chroma_sample_location = output_frame->chroma_location,
459 };
460 vaapi_vpp_fill_colour_properties(avctx, &output_props,
461 caps.output_color_standards,
462 caps.num_output_color_standards);
463
464 // If the properties weren't filled completely in the output frame and
465 // we chose a fixed standard then fill the known values in here.
466 #if VA_CHECK_VERSION(1, 3, 0)
467 if (output_props.va_color_standard != VAProcColorStandardExplicit)
468 #endif
469 {
470 const VAAPIColourProperties *output_standard = NULL;
471 int i;
472
473 for (i = 0; i < FF_ARRAY_ELEMS(vaapi_colour_standard_map); i++) {
474 if (output_props.va_color_standard ==
475 vaapi_colour_standard_map[i].va_color_standard) {
476 output_standard = &vaapi_colour_standard_map[i];
477 break;
478 }
479 }
480 if (output_standard) {
481 output_frame->colorspace = vaapi_vpp_frame_is_rgb(output_frame)
482 ? AVCOL_SPC_RGB : output_standard->colorspace;
483 output_frame->color_primaries = output_standard->color_primaries;
484 output_frame->color_trc = output_standard->color_trc;
485 }
486 }
487
488 params->surface_color_standard = input_props.va_color_standard;
489 params->output_color_standard = output_props.va_color_standard;
490
491 #if VA_CHECK_VERSION(1, 1, 0)
492 params->input_color_properties = (VAProcColorProperties) {
493 .chroma_sample_location = input_props.va_chroma_sample_location,
494 .color_range = input_props.va_color_range,
495 #if VA_CHECK_VERSION(1, 3, 0)
496 .colour_primaries = input_props.color_primaries,
497 .transfer_characteristics = input_props.color_trc,
498 .matrix_coefficients = input_props.colorspace,
499 #endif
500 };
501 params->output_color_properties = (VAProcColorProperties) {
502 .chroma_sample_location = output_props.va_chroma_sample_location,
503 .color_range = output_props.va_color_range,
504 #if VA_CHECK_VERSION(1, 3, 0)
505 .colour_primaries = output_props.color_primaries,
506 .transfer_characteristics = output_props.color_trc,
507 .matrix_coefficients = output_props.colorspace,
508 #endif
509 };
510 #endif
511
512 return 0;
513 }
514
515 int ff_vaapi_vpp_init_params(AVFilterContext *avctx,
516 VAProcPipelineParameterBuffer *params,
517 const AVFrame *input_frame,
518 AVFrame *output_frame)
519 {
520 VAAPIVPPContext *ctx = avctx->priv;
521 VASurfaceID input_surface;
522 int err;
523
524 ctx->input_region = (VARectangle) {
525 .x = input_frame->crop_left,
526 .y = input_frame->crop_top,
527 .width = input_frame->width -
528 (input_frame->crop_left + input_frame->crop_right),
529 .height = input_frame->height -
530 (input_frame->crop_top + input_frame->crop_bottom),
531 };
532 output_frame->crop_top = 0;
533 output_frame->crop_bottom = 0;
534 output_frame->crop_left = 0;
535 output_frame->crop_right = 0;
536
537 input_surface = (VASurfaceID)(uintptr_t)input_frame->data[3],
538
539 *params = (VAProcPipelineParameterBuffer) {
540 .surface = input_surface,
541 .surface_region = &ctx->input_region,
542 .output_region = NULL,
543 .output_background_color = VAAPI_VPP_BACKGROUND_BLACK,
544 .pipeline_flags = 0,
545 .filter_flags = VA_FRAME_PICTURE,
546
547 // Filter and reference data filled by the filter itself.
548
549 #if VA_CHECK_VERSION(1, 1, 0)
550 .rotation_state = VA_ROTATION_NONE,
551 .mirror_state = VA_MIRROR_NONE,
552 #endif
553 };
554
555 err = vaapi_vpp_colour_properties(avctx, params,
556 input_frame, output_frame);
557 if (err < 0)
558 return err;
559
560 return 0;
561 }
562
563 int ff_vaapi_vpp_make_param_buffers(AVFilterContext *avctx,
564 int type,
565 const void *data,
566 size_t size,
567 int count)
568 {
569 VAStatus vas;
570 VABufferID buffer;
571 VAAPIVPPContext *ctx = avctx->priv;
572
573 av_assert0(ctx->nb_filter_buffers + 1 <= VAProcFilterCount);
574
575 vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
576 type, size, count, (void*)data, &buffer);
577 if (vas != VA_STATUS_SUCCESS) {
578 av_log(avctx, AV_LOG_ERROR, "Failed to create parameter "
579 "buffer (type %d): %d (%s).\n",
580 type, vas, vaErrorStr(vas));
581 return AVERROR(EIO);
582 }
583
584 ctx->filter_buffers[ctx->nb_filter_buffers++] = buffer;
585
586 av_log(avctx, AV_LOG_DEBUG, "Param buffer (type %d, %zu bytes, count %d) "
587 "is %#x.\n", type, size, count, buffer);
588 return 0;
589 }
590
591
592 int ff_vaapi_vpp_render_picture(AVFilterContext *avctx,
593 VAProcPipelineParameterBuffer *params,
594 AVFrame *output_frame)
595 {
596 VAAPIVPPContext *ctx = avctx->priv;
597 VASurfaceID output_surface;
598 VABufferID params_id;
599 VAStatus vas;
600 int err;
601
602 output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];
603
604 vas = vaBeginPicture(ctx->hwctx->display,
605 ctx->va_context, output_surface);
606 if (vas != VA_STATUS_SUCCESS) {
607 av_log(avctx, AV_LOG_ERROR, "Failed to attach new picture: "
608 "%d (%s).\n", vas, vaErrorStr(vas));
609 err = AVERROR(EIO);
610 goto fail;
611 }
612
613 vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
614 VAProcPipelineParameterBufferType,
615 sizeof(*params), 1, params, &params_id);
616 if (vas != VA_STATUS_SUCCESS) {
617 av_log(avctx, AV_LOG_ERROR, "Failed to create parameter buffer: "
618 "%d (%s).\n", vas, vaErrorStr(vas));
619 err = AVERROR(EIO);
620 goto fail_after_begin;
621 }
622 av_log(avctx, AV_LOG_DEBUG, "Pipeline parameter buffer is %#x.\n",
623 params_id);
624
625 vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
626 &params_id, 1);
627 if (vas != VA_STATUS_SUCCESS) {
628 av_log(avctx, AV_LOG_ERROR, "Failed to render parameter buffer: "
629 "%d (%s).\n", vas, vaErrorStr(vas));
630 err = AVERROR(EIO);
631 goto fail_after_begin;
632 }
633
634 vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
635 if (vas != VA_STATUS_SUCCESS) {
636 av_log(avctx, AV_LOG_ERROR, "Failed to start picture processing: "
637 "%d (%s).\n", vas, vaErrorStr(vas));
638 err = AVERROR(EIO);
639 goto fail_after_render;
640 }
641
642 if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
643 AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
644 vas = vaDestroyBuffer(ctx->hwctx->display, params_id);
645 if (vas != VA_STATUS_SUCCESS) {
646 av_log(avctx, AV_LOG_ERROR, "Failed to free parameter buffer: "
647 "%d (%s).\n", vas, vaErrorStr(vas));
648 // And ignore.
649 }
650 }
651
652 return 0;
653
654 // We want to make sure that if vaBeginPicture has been called, we also
655 // call vaRenderPicture and vaEndPicture. These calls may well fail or
656 // do something else nasty, but once we're in this failure case there
657 // isn't much else we can do.
658 fail_after_begin:
659 vaRenderPicture(ctx->hwctx->display, ctx->va_context, &params_id, 1);
660 fail_after_render:
661 vaEndPicture(ctx->hwctx->display, ctx->va_context);
662 fail:
663 return err;
664 }
665
666 void ff_vaapi_vpp_ctx_init(AVFilterContext *avctx)
667 {
668 int i;
669 VAAPIVPPContext *ctx = avctx->priv;
670
671 ctx->va_config = VA_INVALID_ID;
672 ctx->va_context = VA_INVALID_ID;
673 ctx->valid_ids = 1;
674
675 for (i = 0; i < VAProcFilterCount; i++)
676 ctx->filter_buffers[i] = VA_INVALID_ID;
677 ctx->nb_filter_buffers = 0;
678 }
679
680 void ff_vaapi_vpp_ctx_uninit(AVFilterContext *avctx)
681 {
682 VAAPIVPPContext *ctx = avctx->priv;
683 if (ctx->valid_ids && ctx->pipeline_uninit)
684 ctx->pipeline_uninit(avctx);
685
686 av_buffer_unref(&ctx->input_frames_ref);
687 av_buffer_unref(&ctx->device_ref);
688 }
689