lavfi: add join audio filter.
[ffmpeg.git] / libavfilter / af_join.c
1 /*
2  *
3  * This file is part of Libav.
4  *
5  * Libav is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * Libav is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with Libav; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19
20 /**
21  * @file
22  * Audio join filter
23  *
24  * Join multiple audio inputs as different channels in
25  * a single output
26  */
27
28 #include "libavutil/audioconvert.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/opt.h"
31
32 #include "audio.h"
33 #include "avfilter.h"
34 #include "formats.h"
35 #include "internal.h"
36
37 typedef struct ChannelMap {
38     int input;                ///< input stream index
39     int       in_channel_idx; ///< index of in_channel in the input stream data
40     uint64_t  in_channel;     ///< layout describing the input channel
41     uint64_t out_channel;     ///< layout describing the output channel
42 } ChannelMap;
43
44 typedef struct JoinContext {
45     const AVClass *class;
46
47     int inputs;
48     char *map;
49     char    *channel_layout_str;
50     uint64_t channel_layout;
51
52     int      nb_channels;
53     ChannelMap *channels;
54
55     /**
56      * Temporary storage for input frames, until we get one on each input.
57      */
58     AVFilterBufferRef **input_frames;
59
60     /**
61      *  Temporary storage for data pointers, for assembling the output buffer.
62      */
63     uint8_t **data;
64 } JoinContext;
65
66 /**
67  * To avoid copying the data from input buffers, this filter creates
68  * a custom output buffer that stores references to all inputs and
69  * unrefs them on free.
70  */
71 typedef struct JoinBufferPriv {
72     AVFilterBufferRef **in_buffers;
73     int              nb_in_buffers;
74 } JoinBufferPriv;
75
76 #define OFFSET(x) offsetof(JoinContext, x)
77 #define A AV_OPT_FLAG_AUDIO_PARAM
78 static const AVOption join_options[] = {
79     { "inputs",         "Number of input streams.", OFFSET(inputs),             AV_OPT_TYPE_INT,    { 2 }, 1, INT_MAX,       A },
80     { "channel_layout", "Channel layout of the "
81                         "output stream.",           OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, {.str = "stereo"}, 0, 0, A },
82     { "map",            "A comma-separated list of channels maps in the format "
83                         "'input_stream.input_channel-output_channel.",
84                                                     OFFSET(map),                AV_OPT_TYPE_STRING,                 .flags = A },
85     { NULL },
86 };
87
88 static const AVClass join_class = {
89     .class_name = "join filter",
90     .item_name  = av_default_item_name,
91     .option     = join_options,
92     .version    = LIBAVUTIL_VERSION_INT,
93 };
94
95 static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)
96 {
97     AVFilterContext *ctx = link->dst;
98     JoinContext       *s = ctx->priv;
99     int i;
100
101     for (i = 0; i < ctx->nb_inputs; i++)
102         if (link == ctx->inputs[i])
103             break;
104     av_assert0(i < ctx->nb_inputs);
105     av_assert0(!s->input_frames[i]);
106     s->input_frames[i] = buf;
107 }
108
109 static int parse_maps(AVFilterContext *ctx)
110 {
111     JoinContext *s = ctx->priv;
112     char *cur      = s->map;
113
114     while (cur && *cur) {
115         char *sep, *next, *p;
116         uint64_t in_channel = 0, out_channel = 0;
117         int input_idx, out_ch_idx, in_ch_idx;
118
119         next = strchr(cur, ',');
120         if (next)
121             *next++ = 0;
122
123         /* split the map into input and output parts */
124         if (!(sep = strchr(cur, '-'))) {
125             av_log(ctx, AV_LOG_ERROR, "Missing separator '-' in channel "
126                    "map '%s'\n", cur);
127             return AVERROR(EINVAL);
128         }
129         *sep++ = 0;
130
131 #define PARSE_CHANNEL(str, var, inout)                                         \
132         if (!(var = av_get_channel_layout(str))) {                             \
133             av_log(ctx, AV_LOG_ERROR, "Invalid " inout " channel: %s.\n", str);\
134             return AVERROR(EINVAL);                                            \
135         }                                                                      \
136         if (av_get_channel_layout_nb_channels(var) != 1) {                     \
137             av_log(ctx, AV_LOG_ERROR, "Channel map describes more than one "   \
138                    inout " channel.\n");                                       \
139             return AVERROR(EINVAL);                                            \
140         }
141
142         /* parse output channel */
143         PARSE_CHANNEL(sep, out_channel, "output");
144         if (!(out_channel & s->channel_layout)) {
145             av_log(ctx, AV_LOG_ERROR, "Output channel '%s' is not present in "
146                    "requested channel layout.\n", sep);
147             return AVERROR(EINVAL);
148         }
149
150         out_ch_idx = av_get_channel_layout_channel_index(s->channel_layout,
151                                                          out_channel);
152         if (s->channels[out_ch_idx].input >= 0) {
153             av_log(ctx, AV_LOG_ERROR, "Multiple maps for output channel "
154                    "'%s'.\n", sep);
155             return AVERROR(EINVAL);
156         }
157
158         /* parse input channel */
159         input_idx = strtol(cur, &cur, 0);
160         if (input_idx < 0 || input_idx >= s->inputs) {
161             av_log(ctx, AV_LOG_ERROR, "Invalid input stream index: %d.\n",
162                    input_idx);
163             return AVERROR(EINVAL);
164         }
165
166         if (*cur)
167             cur++;
168
169         in_ch_idx = strtol(cur, &p, 0);
170         if (p == cur) {
171             /* channel specifier is not a number,
172              * try to parse as channel name */
173             PARSE_CHANNEL(cur, in_channel, "input");
174         }
175
176         s->channels[out_ch_idx].input      = input_idx;
177         if (in_channel)
178             s->channels[out_ch_idx].in_channel = in_channel;
179         else
180             s->channels[out_ch_idx].in_channel_idx = in_ch_idx;
181
182         cur = next;
183     }
184     return 0;
185 }
186
187 static int join_init(AVFilterContext *ctx, const char *args, void *opaque)
188 {
189     JoinContext *s = ctx->priv;
190     int ret, i;
191
192     s->class = &join_class;
193     av_opt_set_defaults(s);
194     if ((ret = av_set_options_string(s, args, "=", ":")) < 0) {
195         av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", args);
196         return ret;
197     }
198
199     if (!(s->channel_layout = av_get_channel_layout(s->channel_layout_str))) {
200         av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout '%s'.\n",
201                s->channel_layout_str);
202         ret = AVERROR(EINVAL);
203         goto fail;
204     }
205
206     s->nb_channels  = av_get_channel_layout_nb_channels(s->channel_layout);
207     s->channels     = av_mallocz(sizeof(*s->channels) * s->nb_channels);
208     s->data         = av_mallocz(sizeof(*s->data)     * s->nb_channels);
209     s->input_frames = av_mallocz(sizeof(*s->input_frames) * s->inputs);
210     if (!s->channels || !s->data || !s->input_frames) {
211         ret = AVERROR(ENOMEM);
212         goto fail;
213     }
214
215     for (i = 0; i < s->nb_channels; i++) {
216         s->channels[i].out_channel = av_channel_layout_extract_channel(s->channel_layout, i);
217         s->channels[i].input       = -1;
218     }
219
220     if ((ret = parse_maps(ctx)) < 0)
221         goto fail;
222
223     for (i = 0; i < s->inputs; i++) {
224         char name[32];
225         AVFilterPad pad = { 0 };
226
227         snprintf(name, sizeof(name), "input%d", i);
228         pad.type           = AVMEDIA_TYPE_AUDIO;
229         pad.name           = av_strdup(name);
230         pad.filter_samples = filter_samples;
231
232         pad.needs_fifo = 1;
233
234         ff_insert_inpad(ctx, i, &pad);
235     }
236
237 fail:
238     av_opt_free(s);
239     return ret;
240 }
241
242 static void join_uninit(AVFilterContext *ctx)
243 {
244     JoinContext *s = ctx->priv;
245     int i;
246
247     for (i = 0; i < ctx->nb_inputs; i++) {
248         av_freep(&ctx->input_pads[i].name);
249         avfilter_unref_buffer(s->input_frames[i]);
250     }
251
252     av_freep(&s->channels);
253     av_freep(&s->data);
254     av_freep(&s->input_frames);
255 }
256
257 static int join_query_formats(AVFilterContext *ctx)
258 {
259     JoinContext *s = ctx->priv;
260     AVFilterChannelLayouts *layouts = NULL;
261     int i;
262
263     ff_add_channel_layout(&layouts, s->channel_layout);
264     ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
265
266     for (i = 0; i < ctx->nb_inputs; i++)
267         ff_channel_layouts_ref(ff_all_channel_layouts(),
268                                &ctx->inputs[i]->out_channel_layouts);
269
270     ff_set_common_formats    (ctx, ff_planar_sample_fmts());
271     ff_set_common_samplerates(ctx, ff_all_samplerates());
272
273     return 0;
274 }
275
276 static void guess_map_matching(AVFilterContext *ctx, ChannelMap *ch,
277                                uint64_t *inputs)
278 {
279     int i;
280
281     for (i = 0; i < ctx->nb_inputs; i++) {
282         AVFilterLink *link = ctx->inputs[i];
283
284         if (ch->out_channel & link->channel_layout &&
285             !(ch->out_channel & inputs[i])) {
286             ch->input      = i;
287             ch->in_channel = ch->out_channel;
288             inputs[i]     |= ch->out_channel;
289             return;
290         }
291     }
292 }
293
294 static void guess_map_any(AVFilterContext *ctx, ChannelMap *ch,
295                           uint64_t *inputs)
296 {
297     int i;
298
299     for (i = 0; i < ctx->nb_inputs; i++) {
300         AVFilterLink *link = ctx->inputs[i];
301
302         if ((inputs[i] & link->channel_layout) != link->channel_layout) {
303             uint64_t unused = link->channel_layout & ~inputs[i];
304
305             ch->input      = i;
306             ch->in_channel = av_channel_layout_extract_channel(unused, 0);
307             inputs[i]     |= ch->in_channel;
308             return;
309         }
310     }
311 }
312
313 static int join_config_output(AVFilterLink *outlink)
314 {
315     AVFilterContext *ctx = outlink->src;
316     JoinContext       *s = ctx->priv;
317     uint64_t *inputs;   // nth element tracks which channels are used from nth input
318     int i, ret = 0;
319
320     /* initialize inputs to user-specified mappings */
321     if (!(inputs = av_mallocz(sizeof(*inputs) * ctx->nb_inputs)))
322         return AVERROR(ENOMEM);
323     for (i = 0; i < s->nb_channels; i++) {
324         ChannelMap *ch = &s->channels[i];
325         AVFilterLink *inlink;
326
327         if (ch->input < 0)
328             continue;
329
330         inlink = ctx->inputs[ch->input];
331
332         if (!ch->in_channel)
333             ch->in_channel = av_channel_layout_extract_channel(inlink->channel_layout,
334                                                                ch->in_channel_idx);
335
336         if (!(ch->in_channel & inlink->channel_layout)) {
337             av_log(ctx, AV_LOG_ERROR, "Requested channel %s is not present in "
338                    "input stream #%d.\n", av_get_channel_name(ch->in_channel),
339                    ch->input);
340             ret = AVERROR(EINVAL);
341             goto fail;
342         }
343
344         inputs[ch->input] |= ch->in_channel;
345     }
346
347     /* guess channel maps when not explicitly defined */
348     /* first try unused matching channels */
349     for (i = 0; i < s->nb_channels; i++) {
350         ChannelMap *ch = &s->channels[i];
351
352         if (ch->input < 0)
353             guess_map_matching(ctx, ch, inputs);
354     }
355
356     /* if the above failed, try to find _any_ unused input channel */
357     for (i = 0; i < s->nb_channels; i++) {
358         ChannelMap *ch = &s->channels[i];
359
360         if (ch->input < 0)
361             guess_map_any(ctx, ch, inputs);
362
363         if (ch->input < 0) {
364             av_log(ctx, AV_LOG_ERROR, "Could not find input channel for "
365                    "output channel '%s'.\n",
366                    av_get_channel_name(ch->out_channel));
367             goto fail;
368         }
369
370         ch->in_channel_idx = av_get_channel_layout_channel_index(ctx->inputs[ch->input]->channel_layout,
371                                                                  ch->in_channel);
372     }
373
374     /* print mappings */
375     av_log(ctx, AV_LOG_VERBOSE, "mappings: ");
376     for (i = 0; i < s->nb_channels; i++) {
377         ChannelMap *ch = &s->channels[i];
378         av_log(ctx, AV_LOG_VERBOSE, "%d.%s => %s ", ch->input,
379                av_get_channel_name(ch->in_channel),
380                av_get_channel_name(ch->out_channel));
381     }
382     av_log(ctx, AV_LOG_VERBOSE, "\n");
383
384     for (i = 0; i < ctx->nb_inputs; i++) {
385         if (!inputs[i])
386             av_log(ctx, AV_LOG_WARNING, "No channels are used from input "
387                    "stream %d.\n", i);
388     }
389
390 fail:
391     av_freep(&inputs);
392     return ret;
393 }
394
395 static void join_free_buffer(AVFilterBuffer *buf)
396 {
397     JoinBufferPriv *priv = buf->priv;
398
399     if (priv) {
400         int i;
401
402         for (i = 0; i < priv->nb_in_buffers; i++)
403             avfilter_unref_buffer(priv->in_buffers[i]);
404
405         av_freep(&priv->in_buffers);
406         av_freep(&buf->priv);
407     }
408
409     if (buf->extended_data != buf->data)
410         av_freep(&buf->extended_data);
411     av_freep(&buf);
412 }
413
414 static int join_request_frame(AVFilterLink *outlink)
415 {
416     AVFilterContext *ctx = outlink->src;
417     JoinContext *s       = ctx->priv;
418     AVFilterBufferRef *buf;
419     JoinBufferPriv *priv;
420     int linesize   = INT_MAX;
421     int perms      = ~0;
422     int nb_samples;
423     int i, j, ret;
424
425     /* get a frame on each input */
426     for (i = 0; i < ctx->nb_inputs; i++) {
427         AVFilterLink *inlink = ctx->inputs[i];
428
429         if (!s->input_frames[i] &&
430             (ret = ff_request_frame(inlink)) < 0)
431             return ret;
432
433         /* request the same number of samples on all inputs */
434         if (i == 0) {
435             nb_samples = s->input_frames[0]->audio->nb_samples;
436
437             for (j = 1; !i && j < ctx->nb_inputs; j++)
438                 ctx->inputs[j]->request_samples = nb_samples;
439         }
440     }
441
442     for (i = 0; i < s->nb_channels; i++) {
443         ChannelMap *ch = &s->channels[i];
444         AVFilterBufferRef *cur_buf = s->input_frames[ch->input];
445
446         s->data[i] = cur_buf->extended_data[ch->in_channel_idx];
447         linesize   = FFMIN(linesize, cur_buf->linesize[0]);
448         perms     &= cur_buf->perms;
449     }
450
451     buf = avfilter_get_audio_buffer_ref_from_arrays(s->data, linesize, perms,
452                                                     nb_samples, outlink->format,
453                                                     outlink->channel_layout);
454     if (!buf)
455         return AVERROR(ENOMEM);
456
457     buf->buf->free = join_free_buffer;
458     buf->pts       = s->input_frames[0]->pts;
459
460     if (!(priv = av_mallocz(sizeof(*priv))))
461         goto fail;
462     if (!(priv->in_buffers = av_mallocz(sizeof(*priv->in_buffers) * ctx->nb_inputs)))
463         goto fail;
464
465     for (i = 0; i < ctx->nb_inputs; i++)
466         priv->in_buffers[i] = s->input_frames[i];
467     priv->nb_in_buffers = ctx->nb_inputs;
468     buf->buf->priv      = priv;
469
470     ff_filter_samples(outlink, buf);
471
472     memset(s->input_frames, 0, sizeof(*s->input_frames) * ctx->nb_inputs);
473
474     return 0;
475
476 fail:
477     avfilter_unref_buffer(buf);
478     if (priv)
479         av_freep(&priv->in_buffers);
480     av_freep(&priv);
481     return AVERROR(ENOMEM);
482 }
483
484 AVFilter avfilter_af_join = {
485     .name           = "join",
486     .description    = NULL_IF_CONFIG_SMALL("Join multiple audio streams into "
487                                            "multi-channel output"),
488     .priv_size      = sizeof(JoinContext),
489
490     .init           = join_init,
491     .uninit         = join_uninit,
492     .query_formats  = join_query_formats,
493
494     .inputs  = (const AVFilterPad[]){{ NULL }},
495     .outputs = (const AVFilterPad[]){{ .name          = "default",
496                                        .type          = AVMEDIA_TYPE_AUDIO,
497                                        .config_props  = join_config_output,
498                                        .request_frame = join_request_frame, },
499                                      { NULL }},
500 };