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			#define OFFSET(x) offsetof(StackHWContext, x)
20			#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
21
22			#define SET_OUTPUT_REGION(region, rx, ry, rw, rh) do { \
23			region->x = rx; \
24			region->y = ry; \
25			region->width = rw; \
26			region->height = rh; \
27			} while (0)
28
29		✗	static int init_framesync(AVFilterContext *avctx)
30			{
31		✗	StackBaseContext *sctx = avctx->priv;
32			int ret;
33
34		✗	ret = ff_framesync_init(&sctx->fs, avctx, avctx->nb_inputs);
35		✗	if (ret < 0)
36		✗	return ret;
37
38		✗	sctx->fs.on_event = process_frame;
39		✗	sctx->fs.opaque = sctx;
40
41		✗	for (int i = 0; i < sctx->nb_inputs; i++) {
42		✗	FFFrameSyncIn *in = &sctx->fs.in[i];
43
44		✗	in->before = EXT_STOP;
45		✗	in->after = sctx->shortest ? EXT_STOP : EXT_INFINITY;
46		✗	in->sync = 1;
47		✗	in->time_base = avctx->inputs[i]->time_base;
48			}
49
50		✗	return ff_framesync_configure(&sctx->fs);
51			}
52
53		✗	static int config_comm_output(AVFilterLink *outlink)
54			{
55		✗	AVFilterContext *avctx = outlink->src;
56		✗	StackBaseContext *sctx = avctx->priv;
57		✗	AVFilterLink *inlink0 = avctx->inputs[0];
58			int width, height, ret;
59
60		✗	if (sctx->mode == STACK_H) {
61		✗	height = sctx->tile_height;
62		✗	width = 0;
63
64		✗	if (!height)
65		✗	height = inlink0->h;
66
67		✗	for (int i = 0; i < sctx->nb_inputs; i++) {
68		✗	AVFilterLink *inlink = avctx->inputs[i];
69		✗	StackItemRegion *region = &sctx->regions[i];
70
71		✗	SET_OUTPUT_REGION(region, width, 0, av_rescale(height, inlink->w, inlink->h), height);
72		✗	width += av_rescale(height, inlink->w, inlink->h);
73			}
74		✗	} else if (sctx->mode == STACK_V) {
75		✗	height = 0;
76		✗	width = sctx->tile_width;
77
78		✗	if (!width)
79		✗	width = inlink0->w;
80
81		✗	for (int i = 0; i < sctx->nb_inputs; i++) {
82		✗	AVFilterLink *inlink = avctx->inputs[i];
83		✗	StackItemRegion *region = &sctx->regions[i];
84
85		✗	SET_OUTPUT_REGION(region, 0, height, width, av_rescale(width, inlink->h, inlink->w));
86		✗	height += av_rescale(width, inlink->h, inlink->w);
87			}
88		✗	} else if (sctx->nb_grid_rows && sctx->nb_grid_columns) {
89		✗	int xpos = 0, ypos = 0;
90		✗	int ow, oh, k = 0;
91
92		✗	ow = sctx->tile_width;
93		✗	oh = sctx->tile_height;
94
95		✗	if (!ow || !oh) {
96		✗	ow = avctx->inputs[0]->w;
97		✗	oh = avctx->inputs[0]->h;
98			}
99
100		✗	for (int i = 0; i < sctx->nb_grid_columns; i++) {
101		✗	ypos = 0;
102
103		✗	for (int j = 0; j < sctx->nb_grid_rows; j++) {
104		✗	StackItemRegion *region = &sctx->regions[k++];
105
106		✗	SET_OUTPUT_REGION(region, xpos, ypos, ow, oh);
107		✗	ypos += oh;
108			}
109
110		✗	xpos += ow;
111			}
112
113		✗	width = ow * sctx->nb_grid_columns;
114		✗	height = oh * sctx->nb_grid_rows;
115			} else {
116		✗	char *arg, *p = sctx->layout, *saveptr = NULL;
117		✗	char *arg2, *p2, *saveptr2 = NULL;
118		✗	char *arg3, *p3, *saveptr3 = NULL;
119			int xpos, ypos, size;
120			int ow, oh;
121
122		✗	width = 0;
123		✗	height = 0;
124
125		✗	for (int i = 0; i < sctx->nb_inputs; i++) {
126		✗	AVFilterLink *inlink = avctx->inputs[i];
127		✗	StackItemRegion *region = &sctx->regions[i];
128
129		✗	ow = inlink->w;
130		✗	oh = inlink->h;
131
132		✗	if (!(arg = av_strtok(p, "|", &saveptr)))
133		✗	return AVERROR(EINVAL);
134
135		✗	p = NULL;
136		✗	p2 = arg;
137		✗	xpos = ypos = 0;
138
139		✗	for (int j = 0; j < 3; j++) {
140		✗	if (!(arg2 = av_strtok(p2, "_", &saveptr2))) {
141		✗	if (j == 2)
142		✗	break;
143			else
144		✗	return AVERROR(EINVAL);
145			}
146
147		✗	p2 = NULL;
148		✗	p3 = arg2;
149
150		✗	if (j == 2) {
151		✗	if ((ret = av_parse_video_size(&ow, &oh, p3)) < 0) {
152		✗	av_log(avctx, AV_LOG_ERROR, "Invalid size '%s'\n", p3);
153		✗	return ret;
154			}
155
156		✗	break;
157			}
158
159		✗	while ((arg3 = av_strtok(p3, "+", &saveptr3))) {
160		✗	p3 = NULL;
161		✗	if (sscanf(arg3, "w%d", &size) == 1) {
162		✗	if (size == i || size < 0 || size >= sctx->nb_inputs)
163		✗	return AVERROR(EINVAL);
164
165		✗	if (!j)
166		✗	xpos += sctx->regions[size].width;
167			else
168		✗	ypos += sctx->regions[size].width;
169		✗	} else if (sscanf(arg3, "h%d", &size) == 1) {
170		✗	if (size == i || size < 0 || size >= sctx->nb_inputs)
171		✗	return AVERROR(EINVAL);
172
173		✗	if (!j)
174		✗	xpos += sctx->regions[size].height;
175			else
176		✗	ypos += sctx->regions[size].height;
177		✗	} else if (sscanf(arg3, "%d", &size) == 1) {
178		✗	if (size < 0)
179		✗	return AVERROR(EINVAL);
180
181		✗	if (!j)
182		✗	xpos += size;
183			else
184		✗	ypos += size;
185			} else {
186		✗	return AVERROR(EINVAL);
187			}
188			}
189			}
190
191		✗	SET_OUTPUT_REGION(region, xpos, ypos, ow, oh);
192		✗	width = FFMAX(width, xpos + ow);
193		✗	height = FFMAX(height, ypos + oh);
194			}
195
196			}
197
198		✗	outlink->w = width;
199		✗	outlink->h = height;
200		✗	outlink->frame_rate = inlink0->frame_rate;
201		✗	outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
202
203		✗	for (int i = 1; i < sctx->nb_inputs; i++) {
204		✗	AVFilterLink *inlink = avctx->inputs[i];
205		✗	if (outlink->frame_rate.num != inlink->frame_rate.num ||
206		✗	outlink->frame_rate.den != inlink->frame_rate.den) {
207		✗	av_log(avctx, AV_LOG_VERBOSE,
208			"Video inputs have different frame rates, output will be VFR\n");
209		✗	outlink->frame_rate = av_make_q(1, 0);
210		✗	break;
211			}
212			}
213
214		✗	ret = init_framesync(avctx);
215		✗	if (ret < 0)
216		✗	return ret;
217
218		✗	outlink->time_base = sctx->fs.time_base;
219
220		✗	return 0;
221			}
222
223		✗	static int stack_init(AVFilterContext *avctx)
224			{
225		✗	StackBaseContext *sctx = avctx->priv;
226			int ret;
227
228		✗	if (!strcmp(avctx->filter->name, HSTACK_NAME))
229		✗	sctx->mode = STACK_H;
230		✗	else if (!strcmp(avctx->filter->name, VSTACK_NAME))
231		✗	sctx->mode = STACK_V;
232			else {
233			int is_grid;
234
235		✗	av_assert0(strcmp(avctx->filter->name, XSTACK_NAME) == 0);
236		✗	sctx->mode = STACK_X;
237		✗	is_grid = sctx->nb_grid_rows && sctx->nb_grid_columns;
238
239		✗	if (sctx->layout && is_grid) {
240		✗	av_log(avctx, AV_LOG_ERROR, "Both layout and grid were specified. Only one is allowed.\n");
241		✗	return AVERROR(EINVAL);
242			}
243
244		✗	if (!sctx->layout && !is_grid) {
245		✗	if (sctx->nb_inputs == 2) {
246		✗	sctx->nb_grid_rows = 1;
247		✗	sctx->nb_grid_columns = 2;
248		✗	is_grid = 1;
249			} else {
250		✗	av_log(avctx, AV_LOG_ERROR, "No layout or grid specified.\n");
251		✗	return AVERROR(EINVAL);
252			}
253			}
254
255		✗	if (is_grid)
256		✗	sctx->nb_inputs = sctx->nb_grid_rows * sctx->nb_grid_columns;
257
258		✗	if (strcmp(sctx->fillcolor_str, "none") &&
259		✗	av_parse_color(sctx->fillcolor, sctx->fillcolor_str, -1, avctx) >= 0) {
260		✗	sctx->fillcolor_enable = 1;
261			} else {
262		✗	sctx->fillcolor_enable = 0;
263			}
264			}
265
266		✗	for (int i = 0; i < sctx->nb_inputs; i++) {
267		✗	AVFilterPad pad = { 0 };
268
269		✗	pad.type = AVMEDIA_TYPE_VIDEO;
270		✗	pad.name = av_asprintf("input%d", i);
271
272		✗	if (!pad.name)
273		✗	return AVERROR(ENOMEM);
274
275		✗	if ((ret = ff_append_inpad_free_name(avctx, &pad)) < 0)
276		✗	return ret;
277			}
278
279		✗	sctx->regions = av_calloc(sctx->nb_inputs, sizeof(*sctx->regions));
280		✗	if (!sctx->regions)
281		✗	return AVERROR(ENOMEM);
282
283		✗	return 0;
284			}
285
286		✗	static av_cold void stack_uninit(AVFilterContext *avctx)
287			{
288		✗	StackBaseContext *sctx = avctx->priv;
289
290		✗	av_freep(&sctx->regions);
291		✗	ff_framesync_uninit(&sctx->fs);
292		✗	}
293
294		✗	static int stack_activate(AVFilterContext *avctx)
295			{
296		✗	StackBaseContext *sctx = avctx->priv;
297		✗	return ff_framesync_activate(&sctx->fs);
298			}
299
300			static const AVFilterPad stack_outputs[] = {
301			{
302			.name = "default",
303			.type = AVMEDIA_TYPE_VIDEO,
304			.config_props = config_output,
305			},
306			};
307
308			#define STACK_COMMON_OPTS \
309			{ "inputs", "Set number of inputs", OFFSET(base.nb_inputs), AV_OPT_TYPE_INT, { .i64 = 2 }, 2, UINT16_MAX, .flags = FLAGS }, \
310			{ "shortest", "Force termination when the shortest input terminates", OFFSET(base.shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
311
312			#define DEFINE_HSTACK_OPTIONS(api) \
313			static const AVOption hstack_##api##_options[] = { \
314			STACK_COMMON_OPTS \
315			{ "height", "Set output height (0 to use the height of input 0)", OFFSET(base.tile_height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, FLAGS }, \
316			{ NULL } \
317			}
318
319			#define DEFINE_VSTACK_OPTIONS(api) \
320			static const AVOption vstack_##api##_options[] = { \
321			STACK_COMMON_OPTS \
322			{ "width", "Set output width (0 to use the width of input 0)", OFFSET(base.tile_width), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, FLAGS }, \
323			{ NULL } \
324			}
325
326			#define DEFINE_XSTACK_OPTIONS(api) \
327			static const AVOption xstack_##api##_options[] = { \
328			STACK_COMMON_OPTS \
329			{ "layout", "Set custom layout", OFFSET(base.layout), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, .flags = FLAGS }, \
330			{ "grid", "set fixed size grid layout", OFFSET(base.nb_grid_columns), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, .flags = FLAGS }, \
331			{ "grid_tile_size", "set tile size in grid layout", OFFSET(base.tile_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, .flags = FLAGS }, \
332			{ "fill", "Set the color for unused pixels", OFFSET(base.fillcolor_str), AV_OPT_TYPE_STRING, {.str = "none"}, .flags = FLAGS }, \
333			{ NULL } \
334			}
335
336			#define DEFINE_STACK_FILTER(category, api, capi, filter_flags) \
337			static const AVClass category##_##api##_class = { \
338			.class_name = #category "_" #api, \
339			.item_name = av_default_item_name, \
340			.option = category##_##api##_options, \
341			.version = LIBAVUTIL_VERSION_INT, \
342			}; \
343			const AVFilter ff_vf_##category##_##api = { \
344			.name = #category "_" #api, \
345			.description = NULL_IF_CONFIG_SMALL(#capi " " #category), \
346			.priv_size = sizeof(StackHWContext), \
347			.priv_class = &category##_##api##_class, \
348			.init = api##_stack_init, \
349			.uninit = api##_stack_uninit, \
350			.activate = stack_activate, \
351			FILTER_QUERY_FUNC(api##_stack_query_formats), \
352			FILTER_OUTPUTS(stack_outputs), \
353			.flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE, \
354			.flags = AVFILTER_FLAG_DYNAMIC_INPUTS | filter_flags, \
355			}
356