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/avstring.h"
20			#include "libavutil/internal.h"
21			#include "libavutil/mem.h"
22			#include "libavutil/opt.h"
23			#include "avfilter.h"
24			#include "audio.h"
25			#include "filters.h"
26			#include "formats.h"
27			#include "framesync.h"
28			#include "video.h"
29
30			typedef struct StreamSelectContext {
31			const AVClass *class;
32			int nb_inputs;
33			char *map_str;
34			int *map;
35			int nb_map;
36			int is_audio;
37			int64_t *last_pts;
38			AVFrame **frames;
39			FFFrameSync fs;
40			} StreamSelectContext;
41
42			#define OFFSET(x) offsetof(StreamSelectContext, x)
43			#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
44			#define TFLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_RUNTIME_PARAM
45			static const AVOption streamselect_options[] = {
46			{ "inputs", "number of input streams", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64=2}, 2, INT_MAX, .flags=FLAGS },
47			{ "map", "input indexes to remap to outputs", OFFSET(map_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags=TFLAGS },
48			{ NULL }
49			};
50
51			AVFILTER_DEFINE_CLASS_EXT(streamselect, "(a)streamselect", streamselect_options);
52
53		✗	static int process_frame(FFFrameSync *fs)
54			{
55		✗	AVFilterContext *ctx = fs->parent;
56		✗	StreamSelectContext *s = fs->opaque;
57		✗	AVFrame **in = s->frames;
58		✗	int i, j, ret = 0, have_out = 0;
59
60		✗	for (i = 0; i < ctx->nb_inputs; i++) {
61		✗	if ((ret = ff_framesync_get_frame(&s->fs, i, &in[i], 0)) < 0)
62		✗	return ret;
63			}
64
65		✗	for (j = 0; j < ctx->nb_inputs; j++) {
66		✗	for (i = 0; i < s->nb_map; i++) {
67		✗	FilterLink *outl = ff_filter_link(ctx->outputs[i]);
68		✗	if (s->map[i] == j) {
69			AVFrame *out;
70
71		✗	if (s->is_audio && s->last_pts[j] == in[j]->pts &&
72		✗	outl->frame_count_in > 0)
73		✗	continue;
74		✗	out = av_frame_clone(in[j]);
75		✗	if (!out)
76		✗	return AVERROR(ENOMEM);
77
78		✗	out->pts = av_rescale_q(s->fs.pts, s->fs.time_base, ctx->outputs[i]->time_base);
79		✗	s->last_pts[j] = in[j]->pts;
80		✗	ret = ff_filter_frame(ctx->outputs[i], out);
81		✗	have_out = 1;
82		✗	if (ret < 0)
83		✗	return ret;
84			}
85			}
86			}
87
88		✗	if (!have_out)
89		✗	ff_filter_set_ready(ctx, 100);
90		✗	return ret;
91			}
92
93		✗	static int activate(AVFilterContext *ctx)
94			{
95		✗	StreamSelectContext *s = ctx->priv;
96		✗	return ff_framesync_activate(&s->fs);
97			}
98
99		✗	static int config_output(AVFilterLink *outlink)
100			{
101		✗	FilterLink *outl = ff_filter_link(outlink);
102		✗	AVFilterContext *ctx = outlink->src;
103		✗	StreamSelectContext *s = ctx->priv;
104		✗	const int outlink_idx = FF_OUTLINK_IDX(outlink);
105		✗	const int inlink_idx = s->map[outlink_idx];
106		✗	AVFilterLink *inlink = ctx->inputs[inlink_idx];
107		✗	FilterLink *inl = ff_filter_link(inlink);
108			FFFrameSyncIn *in;
109			int i, ret;
110
111		✗	av_log(ctx, AV_LOG_VERBOSE, "config output link %d "
112			"with settings from input link %d\n",
113			outlink_idx, inlink_idx);
114
115		✗	switch (outlink->type) {
116		✗	case AVMEDIA_TYPE_VIDEO:
117		✗	outlink->w = inlink->w;
118		✗	outlink->h = inlink->h;
119		✗	outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
120		✗	outl->frame_rate = inl->frame_rate;
121		✗	break;
122		✗	case AVMEDIA_TYPE_AUDIO:
123		✗	outlink->sample_rate = inlink->sample_rate;
124		✗	outlink->ch_layout.nb_channels = inlink->ch_layout.nb_channels;
125		✗	break;
126			}
127
128		✗	outlink->time_base = inlink->time_base;
129		✗	outlink->format = inlink->format;
130
131		✗	if (s->fs.opaque == s)
132		✗	return 0;
133
134		✗	if ((ret = ff_framesync_init(&s->fs, ctx, ctx->nb_inputs)) < 0)
135		✗	return ret;
136
137		✗	in = s->fs.in;
138		✗	s->fs.opaque = s;
139		✗	s->fs.on_event = process_frame;
140
141		✗	for (i = 0; i < ctx->nb_inputs; i++) {
142		✗	in[i].time_base = ctx->inputs[i]->time_base;
143		✗	in[i].sync = 1;
144		✗	in[i].before = EXT_STOP;
145		✗	in[i].after = EXT_STOP;
146			}
147
148		✗	s->frames = av_calloc(ctx->nb_inputs, sizeof(*s->frames));
149		✗	if (!s->frames)
150		✗	return AVERROR(ENOMEM);
151
152		✗	return ff_framesync_configure(&s->fs);
153			}
154
155		✗	static int parse_definition(AVFilterContext *ctx, int nb_pads, int is_input, int is_audio)
156			{
157		✗	const char *padtype = is_input ? "in" : "out";
158		✗	int i = 0, ret = 0;
159
160		✗	for (i = 0; i < nb_pads; i++) {
161		✗	AVFilterPad pad = { 0 };
162
163		✗	pad.type = is_audio ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
164
165		✗	pad.name = av_asprintf("%sput%d", padtype, i);
166		✗	if (!pad.name)
167		✗	return AVERROR(ENOMEM);
168
169		✗	av_log(ctx, AV_LOG_DEBUG, "Add %s pad %s\n", padtype, pad.name);
170
171		✗	if (is_input) {
172		✗	ret = ff_append_inpad_free_name(ctx, &pad);
173			} else {
174		✗	pad.config_props = config_output;
175		✗	ret = ff_append_outpad_free_name(ctx, &pad);
176			}
177		✗	if (ret < 0)
178		✗	return ret;
179			}
180
181		✗	return 0;
182			}
183
184		✗	static int parse_mapping(AVFilterContext *ctx, const char *map)
185			{
186		✗	StreamSelectContext *s = ctx->priv;
187			int *new_map;
188		✗	int new_nb_map = 0;
189
190		✗	if (!map) {
191		✗	av_log(ctx, AV_LOG_ERROR, "mapping definition is not set\n");
192		✗	return AVERROR(EINVAL);
193			}
194
195		✗	new_map = av_calloc(s->nb_inputs, sizeof(*new_map));
196		✗	if (!new_map)
197		✗	return AVERROR(ENOMEM);
198
199		✗	while (1) {
200			char *p;
201		✗	const int n = strtol(map, &p, 0);
202
203		✗	av_log(ctx, AV_LOG_DEBUG, "n=%d map=%p p=%p\n", n, map, p);
204
205		✗	if (map == p)
206		✗	break;
207		✗	map = p;
208
209		✗	if (new_nb_map >= s->nb_inputs) {
210		✗	av_log(ctx, AV_LOG_ERROR, "Unable to map more than the %d "
211			"input pads available\n", s->nb_inputs);
212		✗	av_free(new_map);
213		✗	return AVERROR(EINVAL);
214			}
215
216		✗	if (n < 0 || n >= ctx->nb_inputs) {
217		✗	av_log(ctx, AV_LOG_ERROR, "Input stream index %d doesn't exist "
218			"(there is only %d input streams defined)\n",
219			n, s->nb_inputs);
220		✗	av_free(new_map);
221		✗	return AVERROR(EINVAL);
222			}
223
224		✗	av_log(ctx, AV_LOG_VERBOSE, "Map input stream %d to output stream %d\n", n, new_nb_map);
225		✗	new_map[new_nb_map++] = n;
226			}
227
228		✗	if (!new_nb_map) {
229		✗	av_log(ctx, AV_LOG_ERROR, "invalid mapping\n");
230		✗	av_free(new_map);
231		✗	return AVERROR(EINVAL);
232			}
233
234		✗	av_freep(&s->map);
235		✗	s->map = new_map;
236		✗	s->nb_map = new_nb_map;
237
238		✗	av_log(ctx, AV_LOG_VERBOSE, "%d map set\n", s->nb_map);
239
240		✗	return 0;
241			}
242
243		✗	static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
244			char *res, int res_len, int flags)
245			{
246		✗	if (!strcmp(cmd, "map")) {
247		✗	int ret = parse_mapping(ctx, args);
248
249		✗	if (ret < 0)
250		✗	return ret;
251		✗	return 0;
252			}
253		✗	return AVERROR(ENOSYS);
254			}
255
256		✗	static av_cold int init(AVFilterContext *ctx)
257			{
258		✗	StreamSelectContext *s = ctx->priv;
259		✗	int ret, nb_outputs = 0;
260		✗	char *map = s->map_str;
261
262		✗	if (!strcmp(ctx->filter->name, "astreamselect"))
263		✗	s->is_audio = 1;
264
265		✗	for (; map;) {
266			char *p;
267
268		✗	strtol(map, &p, 0);
269		✗	if (map == p)
270		✗	break;
271		✗	nb_outputs++;
272		✗	map = p;
273			}
274
275		✗	s->last_pts = av_calloc(s->nb_inputs, sizeof(*s->last_pts));
276		✗	if (!s->last_pts)
277		✗	return AVERROR(ENOMEM);
278
279		✗	if ((ret = parse_definition(ctx, s->nb_inputs, 1, s->is_audio)) < 0 ||
280		✗	(ret = parse_definition(ctx, nb_outputs, 0, s->is_audio)) < 0)
281		✗	return ret;
282
283		✗	av_log(ctx, AV_LOG_DEBUG, "Configured with %d inpad and %d outpad\n",
284			ctx->nb_inputs, ctx->nb_outputs);
285
286		✗	return parse_mapping(ctx, s->map_str);
287			}
288
289		✗	static av_cold void uninit(AVFilterContext *ctx)
290			{
291		✗	StreamSelectContext *s = ctx->priv;
292
293		✗	av_freep(&s->last_pts);
294		✗	av_freep(&s->map);
295		✗	av_freep(&s->frames);
296		✗	ff_framesync_uninit(&s->fs);
297		✗	}
298
299			const AVFilter ff_vf_streamselect = {
300			.name = "streamselect",
301			.description = NULL_IF_CONFIG_SMALL("Select video streams"),
302			.init = init,
303			.process_command = process_command,
304			.uninit = uninit,
305			.activate = activate,
306			.priv_size = sizeof(StreamSelectContext),
307			.priv_class = &streamselect_class,
308			.flags = AVFILTER_FLAG_DYNAMIC_INPUTS | AVFILTER_FLAG_DYNAMIC_OUTPUTS,
309			};
310
311			const AVFilter ff_af_astreamselect = {
312			.name = "astreamselect",
313			.description = NULL_IF_CONFIG_SMALL("Select audio streams"),
314			.priv_class = &streamselect_class,
315			.init = init,
316			.process_command = process_command,
317			.uninit = uninit,
318			.activate = activate,
319			.priv_size = sizeof(StreamSelectContext),
320			.flags = AVFILTER_FLAG_DYNAMIC_INPUTS | AVFILTER_FLAG_DYNAMIC_OUTPUTS,
321			};
322