FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/stack_internal.c
Date: 2024-04-12 08:31:17
Exec Total Coverage
Lines: 0 167 0.0%
Functions: 0 5 0.0%
Branches: 0 114 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 #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