FFmpeg coverage

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 "libavutil/colorspace.h"
20			#include "libavutil/eval.h"
21			#include "libavutil/opt.h"
22
23			#include "avfilter.h"
24			#include "internal.h"
25			#include "vaapi_vpp.h"
26			#include "video.h"
27
28			static const char *const var_names[] = {
29			"in_h", "ih",
30			"in_w", "iw",
31			"x",
32			"y",
33			"h",
34			"w",
35			"t",
36			"fill",
37			NULL
38			};
39
40			enum var_name {
41			VAR_IN_H, VAR_IH,
42			VAR_IN_W, VAR_IW,
43			VAR_X,
44			VAR_Y,
45			VAR_H,
46			VAR_W,
47			VAR_T,
48			VAR_MAX,
49			VARS_NB
50			};
51
52			static const int NUM_EXPR_EVALS = 5;
53
54			typedef struct DrawboxVAAPIContext {
55			VAAPIVPPContext vpp_ctx; // must be the first field
56			VARectangle outer_rect, inner_rect;
57
58			/* The hardware frame context containing the frames for outer_rect. */
59			AVBufferRef *outer_frames_ref;
60			AVHWFramesContext *outer_frames;
61			AVFrame *outer_frame;
62
63			char *x_expr;
64			char *y_expr;
65			char *w_expr;
66			char *h_expr;
67			char *t_expr;
68
69			int w, h;
70			int x, y;
71			int replace;
72			uint32_t thickness;
73			uint8_t drawbox_rgba[4];
74
75			int fill;
76
77			} DrawboxVAAPIContext;
78
79		✗	static int drawbox_vaapi_config_output(AVFilterLink *outlink)
80			{
81		✗	AVFilterContext *avctx = outlink->src;
82		✗	AVFilterLink *inlink = avctx->inputs[0];
83		✗	DrawboxVAAPIContext *ctx = avctx->priv;
84		✗	VAAPIVPPContext *vpp_ctx = avctx->priv;
85			double var_values[VARS_NB], res;
86			int ret, i;
87			char *expr;
88
89		✗	var_values[VAR_IN_W] = var_values[VAR_IW] = inlink->w;
90		✗	var_values[VAR_IN_H] = var_values[VAR_IH] = inlink->h;
91		✗	var_values[VAR_X] = NAN;
92		✗	var_values[VAR_Y] = NAN;
93		✗	var_values[VAR_H] = NAN;
94		✗	var_values[VAR_W] = NAN;
95		✗	var_values[VAR_T] = NAN;
96
97		✗	for (i = 0; i <= NUM_EXPR_EVALS; i++) {
98			/* evaluate expressions, fail on last iteration */
99		✗	var_values[VAR_MAX] = inlink->w;
100		✗	if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->x_expr),
101			var_names, var_values,
102		✗	NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
103		✗	goto fail;
104		✗	ctx->x = var_values[VAR_X] = res;
105
106		✗	var_values[VAR_MAX] = inlink->h;
107		✗	if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->y_expr),
108			var_names, var_values,
109		✗	NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
110		✗	goto fail;
111		✗	ctx->y = var_values[VAR_Y] = res;
112
113		✗	var_values[VAR_MAX] = inlink->w - ctx->x;
114		✗	if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->w_expr),
115			var_names, var_values,
116		✗	NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
117		✗	goto fail;
118		✗	ctx->w = var_values[VAR_W] = res;
119
120		✗	var_values[VAR_MAX] = inlink->h - ctx->y;
121		✗	if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->h_expr),
122			var_names, var_values,
123		✗	NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
124		✗	goto fail;
125		✗	ctx->h = var_values[VAR_H] = res;
126
127		✗	var_values[VAR_MAX] = INT_MAX;
128		✗	if ((ret = av_expr_parse_and_eval(&res, (expr = ctx->t_expr),
129			var_names, var_values,
130		✗	NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0 && i == NUM_EXPR_EVALS)
131		✗	goto fail;
132		✗	ctx->thickness = var_values[VAR_T] = res;
133			}
134
135			/* Sanity check */
136		✗	ctx->w = (ctx->w > 0) ? ctx->w : inlink->w;
137		✗	ctx->h = (ctx->h > 0) ? ctx->h : inlink->h;
138		✗	if (ctx->x + ctx->w > inlink->w)
139		✗	ctx->w = inlink->w - ctx->x;
140		✗	if (ctx->y + ctx->h > inlink->h)
141		✗	ctx->h = inlink->h - ctx->y;
142
143		✗	ctx->outer_rect.x = ctx->x;
144		✗	ctx->outer_rect.y = ctx->y;
145		✗	ctx->outer_rect.width = ctx->w;
146		✗	ctx->outer_rect.height = ctx->h;
147
148		✗	if (ctx->outer_rect.width <= ctx->thickness * 2 ||
149		✗	ctx->outer_rect.height <= ctx->thickness * 2) {
150		✗	ctx->fill = 1;
151			} else {
152		✗	ctx->fill = 0;
153		✗	ctx->inner_rect.x = ctx->outer_rect.x + ctx->thickness;
154		✗	ctx->inner_rect.y = ctx->outer_rect.y + ctx->thickness;
155		✗	ctx->inner_rect.width = ctx->outer_rect.width - ctx->thickness * 2;
156		✗	ctx->inner_rect.height = ctx->outer_rect.height - ctx->thickness * 2;
157			}
158
159		✗	vpp_ctx->output_width = inlink->w;
160		✗	vpp_ctx->output_height = inlink->h;
161
162		✗	ret = ff_vaapi_vpp_config_output(outlink);
163		✗	if (ret < 0)
164		✗	return ret;
165
166		✗	ctx->outer_frames_ref = av_hwframe_ctx_alloc(vpp_ctx->device_ref);
167		✗	if (!ctx->outer_frames_ref) {
168		✗	return AVERROR(ENOMEM);
169			}
170
171		✗	ctx->outer_frames = (AVHWFramesContext*)ctx->outer_frames_ref->data;
172
173		✗	ctx->outer_frames->format = AV_PIX_FMT_VAAPI;
174		✗	ctx->outer_frames->sw_format = vpp_ctx->input_frames->sw_format;
175		✗	ctx->outer_frames->width = ctx->outer_rect.width;
176		✗	ctx->outer_frames->height = ctx->outer_rect.height;
177
178		✗	return av_hwframe_ctx_init(ctx->outer_frames_ref);
179
180		✗	fail:
181		✗	av_log(avctx, AV_LOG_ERROR,
182			"Error when evaluating the expression '%s'.\n",
183			expr);
184		✗	return ret;
185			}
186
187		✗	static int drawbox_vaapi_filter_frame(AVFilterLink *link, AVFrame *input_frame)
188			{
189		✗	AVFilterContext *avctx = link->dst;
190		✗	AVFilterLink *outlink = avctx->outputs[0];
191		✗	VAAPIVPPContext *vpp_ctx = avctx->priv;
192		✗	DrawboxVAAPIContext *drawbox_ctx = avctx->priv;
193		✗	AVFrame *output_frame = NULL;
194			VAProcPipelineParameterBuffer box_params;
195			VAProcPipelineParameterBuffer params[3];
196		✗	VABlendState blend_state = {
197			.flags = VA_BLEND_GLOBAL_ALPHA,
198			};
199			VARectangle box[4];
200		✗	int err, nb_params = 0;
201
202		✗	if (!input_frame->hw_frames_ctx ||
203		✗	vpp_ctx->va_context == VA_INVALID_ID) {
204		✗	err = AVERROR(EINVAL);
205		✗	goto fail;
206			}
207
208		✗	if (!drawbox_ctx->outer_frame) {
209		✗	drawbox_ctx->outer_frame = av_frame_alloc();
210		✗	if (!drawbox_ctx->outer_frame) {
211		✗	err = AVERROR(ENOMEM);
212		✗	goto fail;
213			}
214
215		✗	err = av_hwframe_get_buffer(drawbox_ctx->outer_frames_ref, drawbox_ctx->outer_frame, 0);
216		✗	if (err < 0) {
217		✗	err = AVERROR(ENOMEM);
218		✗	goto fail;
219			}
220
221			/* Create image for the outer rect */
222		✗	err = ff_vaapi_vpp_init_params(avctx, &box_params,
223			input_frame, drawbox_ctx->outer_frame);
224		✗	if (err < 0)
225		✗	goto fail;
226
227		✗	blend_state.global_alpha = 0.0f;
228		✗	box_params.surface_region = &drawbox_ctx->outer_rect;
229		✗	box_params.blend_state = &blend_state;
230		✗	box_params.output_background_color = (drawbox_ctx->drawbox_rgba[3] << 24 |
231		✗	drawbox_ctx->drawbox_rgba[0] << 16 |
232		✗	drawbox_ctx->drawbox_rgba[1] << 8 |
233		✗	drawbox_ctx->drawbox_rgba[2]);
234
235		✗	err = ff_vaapi_vpp_render_picture(avctx, &box_params, drawbox_ctx->outer_frame);
236		✗	if (err < 0)
237		✗	goto fail;
238			}
239
240			/* Draw outer & inner rects on the input video, then we can get a box*/
241		✗	output_frame = ff_get_video_buffer(outlink, outlink->w, outlink->h);
242		✗	if (!output_frame) {
243		✗	err = AVERROR(ENOMEM);
244		✗	goto fail;
245			}
246
247		✗	err = av_frame_copy_props(output_frame, input_frame);
248		✗	if (err < 0)
249		✗	goto fail;
250
251		✗	err = ff_vaapi_vpp_init_params(avctx, &params[nb_params],
252			input_frame, output_frame);
253		✗	if (err < 0)
254		✗	goto fail;
255
256		✗	box[0].x = 0;
257		✗	box[0].y = 0;
258		✗	box[0].width = link->w;
259		✗	box[0].height = link->h;
260		✗	params[nb_params].surface_region = &box[0];
261		✗	params[nb_params].output_background_color = 0;
262		✗	nb_params++;
263
264		✗	err = ff_vaapi_vpp_init_params(avctx, &params[nb_params],
265		✗	drawbox_ctx->outer_frame, output_frame);
266		✗	if (err < 0)
267		✗	goto fail;
268
269		✗	box[1] = drawbox_ctx->outer_rect;
270		✗	if (drawbox_ctx->drawbox_rgba[3] != 255 && !drawbox_ctx->replace) {
271		✗	blend_state.global_alpha = (float)drawbox_ctx->drawbox_rgba[3] / 255;
272		✗	params[nb_params].blend_state = &blend_state;
273			}
274		✗	params[nb_params].output_region = &box[1];
275		✗	params[nb_params].output_background_color = 0;
276		✗	nb_params++;
277
278		✗	if (!drawbox_ctx->fill) {
279		✗	box[3] = box[2] = drawbox_ctx->inner_rect;
280		✗	params[nb_params] = params[0];
281		✗	params[nb_params].surface_region = &box[2];
282		✗	params[nb_params].output_region = &box[3];
283		✗	params[nb_params].output_background_color = 0;
284		✗	nb_params++;
285			}
286
287		✗	err = ff_vaapi_vpp_render_pictures(avctx, params, nb_params, output_frame);
288		✗	if (err < 0)
289		✗	goto fail;
290
291		✗	av_frame_free(&input_frame);
292
293		✗	return ff_filter_frame(outlink, output_frame);
294
295		✗	fail:
296		✗	av_frame_free(&input_frame);
297		✗	av_frame_free(&output_frame);
298		✗	return err;
299			}
300
301		✗	static av_cold int drawbox_vaapi_init(AVFilterContext *avctx)
302			{
303		✗	VAAPIVPPContext *vpp_ctx = avctx->priv;
304
305		✗	ff_vaapi_vpp_ctx_init(avctx);
306		✗	vpp_ctx->pipeline_uninit = ff_vaapi_vpp_pipeline_uninit;
307		✗	vpp_ctx->output_format = AV_PIX_FMT_NONE;
308
309		✗	return 0;
310			}
311
312		✗	static av_cold void drawbox_vaapi_uninit(AVFilterContext *avctx)
313			{
314		✗	DrawboxVAAPIContext *ctx = avctx->priv;
315
316		✗	av_frame_free(&ctx->outer_frame);
317		✗	av_buffer_unref(&ctx->outer_frames_ref);
318		✗	ff_vaapi_vpp_ctx_uninit(avctx);
319		✗	}
320
321			#define OFFSET(x) offsetof(DrawboxVAAPIContext, x)
322			#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
323
324			static const AVOption drawbox_vaapi_options[] = {
325			{ "x", "set horizontal position of the left box edge", OFFSET(x_expr), AV_OPT_TYPE_STRING, { .str="0" }, 0, 0, FLAGS },
326			{ "y", "set vertical position of the top box edge", OFFSET(y_expr), AV_OPT_TYPE_STRING, { .str="0" }, 0, 0, FLAGS },
327			{ "width", "set width of the box", OFFSET(w_expr), AV_OPT_TYPE_STRING, { .str="0" }, 0, 0, FLAGS },
328			{ "w", "set width of the box", OFFSET(w_expr), AV_OPT_TYPE_STRING, { .str="0" }, 0, 0, FLAGS },
329			{ "height", "set height of the box", OFFSET(h_expr), AV_OPT_TYPE_STRING, { .str="0" }, 0, 0, FLAGS },
330			{ "h", "set height of the box", OFFSET(h_expr), AV_OPT_TYPE_STRING, { .str="0" }, 0, 0, FLAGS },
331			{ "color", "set color of the box", OFFSET(drawbox_rgba), AV_OPT_TYPE_COLOR, { .str = "black" }, 0, 0, FLAGS },
332			{ "c", "set color of the box", OFFSET(drawbox_rgba), AV_OPT_TYPE_COLOR, { .str = "black" }, 0, 0, FLAGS },
333			{ "thickness", "set the box thickness", OFFSET(t_expr), AV_OPT_TYPE_STRING, { .str="3" }, 0, 0, FLAGS },
334			{ "t", "set the box thickness", OFFSET(t_expr), AV_OPT_TYPE_STRING, { .str="3" }, 0, 0, FLAGS },
335			{ "replace", "replace color", OFFSET(replace), AV_OPT_TYPE_BOOL, { .i64=0 }, 0, 1, FLAGS },
336			{ NULL }
337			};
338
339			AVFILTER_DEFINE_CLASS(drawbox_vaapi);
340
341			static const AVFilterPad drawbox_vaapi_inputs[] = {
342			{
343			.name = "default",
344			.type = AVMEDIA_TYPE_VIDEO,
345			.filter_frame = drawbox_vaapi_filter_frame,
346			.config_props = &ff_vaapi_vpp_config_input,
347			},
348			};
349
350			static const AVFilterPad drawbox_vaapi_outputs[] = {
351			{
352			.name = "default",
353			.type = AVMEDIA_TYPE_VIDEO,
354			.config_props = &drawbox_vaapi_config_output,
355			},
356			};
357
358			const AVFilter ff_vf_drawbox_vaapi = {
359			.name = "drawbox_vaapi",
360			.description = NULL_IF_CONFIG_SMALL("Draw a colored box on the input video."),
361			.priv_size = sizeof(DrawboxVAAPIContext),
362			.priv_class = &drawbox_vaapi_class,
363			.init = &drawbox_vaapi_init,
364			.uninit = &drawbox_vaapi_uninit,
365			FILTER_INPUTS(drawbox_vaapi_inputs),
366			FILTER_OUTPUTS(drawbox_vaapi_outputs),
367			FILTER_QUERY_FUNC(&ff_vaapi_vpp_query_formats),
368			.flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
369			};
370