FFmpeg  4.3
af_amerge.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Nicolas George <nicolas.george@normalesup.org>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Audio merging filter
24  */
25 
26 #include "libavutil/avstring.h"
27 #include "libavutil/bprint.h"
29 #include "libavutil/opt.h"
30 #include "avfilter.h"
31 #include "filters.h"
32 #include "audio.h"
33 #include "internal.h"
34 
35 #define SWR_CH_MAX 64
36 
37 typedef struct AMergeContext {
38  const AVClass *class;
39  int nb_inputs;
40  int route[SWR_CH_MAX]; /**< channels routing, see copy_samples */
41  int bps;
42  struct amerge_input {
43  int nb_ch; /**< number of channels for the input */
44  } *in;
46 
47 #define OFFSET(x) offsetof(AMergeContext, x)
48 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
49 
50 static const AVOption amerge_options[] = {
51  { "inputs", "specify the number of inputs", OFFSET(nb_inputs),
52  AV_OPT_TYPE_INT, { .i64 = 2 }, 1, SWR_CH_MAX, FLAGS },
53  { NULL }
54 };
55 
56 AVFILTER_DEFINE_CLASS(amerge);
57 
59 {
60  AMergeContext *s = ctx->priv;
61  int i;
62 
63  for (i = 0; i < s->nb_inputs; i++) {
64  if (ctx->input_pads)
65  av_freep(&ctx->input_pads[i].name);
66  }
67  av_freep(&s->in);
68 }
69 
71 {
72  AMergeContext *s = ctx->priv;
73  int64_t inlayout[SWR_CH_MAX], outlayout = 0;
76  int i, ret, overlap = 0, nb_ch = 0;
77 
78  for (i = 0; i < s->nb_inputs; i++) {
79  if (!ctx->inputs[i]->in_channel_layouts ||
82  "No channel layout for input %d\n", i + 1);
83  return AVERROR(EAGAIN);
84  }
85  inlayout[i] = ctx->inputs[i]->in_channel_layouts->channel_layouts[0];
86  if (ctx->inputs[i]->in_channel_layouts->nb_channel_layouts > 1) {
87  char buf[256];
88  av_get_channel_layout_string(buf, sizeof(buf), 0, inlayout[i]);
89  av_log(ctx, AV_LOG_INFO, "Using \"%s\" for input %d\n", buf, i + 1);
90  }
91  s->in[i].nb_ch = FF_LAYOUT2COUNT(inlayout[i]);
92  if (s->in[i].nb_ch) {
93  overlap++;
94  } else {
95  s->in[i].nb_ch = av_get_channel_layout_nb_channels(inlayout[i]);
96  if (outlayout & inlayout[i])
97  overlap++;
98  outlayout |= inlayout[i];
99  }
100  nb_ch += s->in[i].nb_ch;
101  }
102  if (nb_ch > SWR_CH_MAX) {
103  av_log(ctx, AV_LOG_ERROR, "Too many channels (max %d)\n", SWR_CH_MAX);
104  return AVERROR(EINVAL);
105  }
106  if (overlap) {
107  av_log(ctx, AV_LOG_WARNING,
108  "Input channel layouts overlap: "
109  "output layout will be determined by the number of distinct input channels\n");
110  for (i = 0; i < nb_ch; i++)
111  s->route[i] = i;
112  outlayout = av_get_default_channel_layout(nb_ch);
113  if (!outlayout && nb_ch)
114  outlayout = 0xFFFFFFFFFFFFFFFFULL >> (64 - nb_ch);
115  } else {
116  int *route[SWR_CH_MAX];
117  int c, out_ch_number = 0;
118 
119  route[0] = s->route;
120  for (i = 1; i < s->nb_inputs; i++)
121  route[i] = route[i - 1] + s->in[i - 1].nb_ch;
122  for (c = 0; c < 64; c++)
123  for (i = 0; i < s->nb_inputs; i++)
124  if ((inlayout[i] >> c) & 1)
125  *(route[i]++) = out_ch_number++;
126  }
128  if ((ret = ff_set_common_formats(ctx, formats)) < 0)
129  return ret;
130  for (i = 0; i < s->nb_inputs; i++) {
131  layouts = NULL;
132  if ((ret = ff_add_channel_layout(&layouts, inlayout[i])) < 0)
133  return ret;
134  if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0)
135  return ret;
136  }
137  layouts = NULL;
138  if ((ret = ff_add_channel_layout(&layouts, outlayout)) < 0)
139  return ret;
140  if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0)
141  return ret;
142 
144 }
145 
146 static int config_output(AVFilterLink *outlink)
147 {
148  AVFilterContext *ctx = outlink->src;
149  AMergeContext *s = ctx->priv;
150  AVBPrint bp;
151  int i;
152 
153  for (i = 1; i < s->nb_inputs; i++) {
154  if (ctx->inputs[i]->sample_rate != ctx->inputs[0]->sample_rate) {
155  av_log(ctx, AV_LOG_ERROR,
156  "Inputs must have the same sample rate "
157  "%d for in%d vs %d\n",
158  ctx->inputs[i]->sample_rate, i, ctx->inputs[0]->sample_rate);
159  return AVERROR(EINVAL);
160  }
161  }
162  s->bps = av_get_bytes_per_sample(ctx->outputs[0]->format);
163  outlink->sample_rate = ctx->inputs[0]->sample_rate;
164  outlink->time_base = ctx->inputs[0]->time_base;
165 
167  for (i = 0; i < s->nb_inputs; i++) {
168  av_bprintf(&bp, "%sin%d:", i ? " + " : "", i);
170  }
171  av_bprintf(&bp, " -> out:");
173  av_log(ctx, AV_LOG_VERBOSE, "%s\n", bp.str);
174 
175  return 0;
176 }
177 
178 /**
179  * Copy samples from several input streams to one output stream.
180  * @param nb_inputs number of inputs
181  * @param in inputs; used only for the nb_ch field;
182  * @param route routing values;
183  * input channel i goes to output channel route[i];
184  * i < in[0].nb_ch are the channels from the first output;
185  * i >= in[0].nb_ch are the channels from the second output
186  * @param ins pointer to the samples of each inputs, in packed format;
187  * will be left at the end of the copied samples
188  * @param outs pointer to the samples of the output, in packet format;
189  * must point to a buffer big enough;
190  * will be left at the end of the copied samples
191  * @param ns number of samples to copy
192  * @param bps bytes per sample
193  */
194 static inline void copy_samples(int nb_inputs, struct amerge_input in[],
195  int *route, uint8_t *ins[],
196  uint8_t **outs, int ns, int bps)
197 {
198  int *route_cur;
199  int i, c, nb_ch = 0;
200 
201  for (i = 0; i < nb_inputs; i++)
202  nb_ch += in[i].nb_ch;
203  while (ns--) {
204  route_cur = route;
205  for (i = 0; i < nb_inputs; i++) {
206  for (c = 0; c < in[i].nb_ch; c++) {
207  memcpy((*outs) + bps * *(route_cur++), ins[i], bps);
208  ins[i] += bps;
209  }
210  }
211  *outs += nb_ch * bps;
212  }
213 }
214 
215 static void free_frames(int nb_inputs, AVFrame **input_frames)
216 {
217  int i;
218  for (i = 0; i < nb_inputs; i++)
219  av_frame_free(&input_frames[i]);
220 }
221 
222 static int try_push_frame(AVFilterContext *ctx, int nb_samples)
223 {
224  AMergeContext *s = ctx->priv;
225  AVFilterLink *outlink = ctx->outputs[0];
226  int i, ret;
227  AVFrame *outbuf, *inbuf[SWR_CH_MAX] = { NULL };
228  uint8_t *outs, *ins[SWR_CH_MAX];
229 
230  for (i = 0; i < ctx->nb_inputs; i++) {
231  ret = ff_inlink_consume_samples(ctx->inputs[i], nb_samples, nb_samples, &inbuf[i]);
232  if (ret < 0) {
233  free_frames(i, inbuf);
234  return ret;
235  }
236  ins[i] = inbuf[i]->data[0];
237  }
238 
239  outbuf = ff_get_audio_buffer(ctx->outputs[0], nb_samples);
240  if (!outbuf) {
241  free_frames(s->nb_inputs, inbuf);
242  return AVERROR(ENOMEM);
243  }
244 
245  outs = outbuf->data[0];
246  outbuf->pts = inbuf[0]->pts;
247 
248  outbuf->nb_samples = nb_samples;
249  outbuf->channel_layout = outlink->channel_layout;
250  outbuf->channels = outlink->channels;
251 
252  while (nb_samples) {
253  /* Unroll the most common sample formats: speed +~350% for the loop,
254  +~13% overall (including two common decoders) */
255  switch (s->bps) {
256  case 1:
257  copy_samples(s->nb_inputs, s->in, s->route, ins, &outs, nb_samples, 1);
258  break;
259  case 2:
260  copy_samples(s->nb_inputs, s->in, s->route, ins, &outs, nb_samples, 2);
261  break;
262  case 4:
263  copy_samples(s->nb_inputs, s->in, s->route, ins, &outs, nb_samples, 4);
264  break;
265  default:
266  copy_samples(s->nb_inputs, s->in, s->route, ins, &outs, nb_samples, s->bps);
267  break;
268  }
269 
270  nb_samples = 0;
271  }
272 
273  free_frames(s->nb_inputs, inbuf);
274  return ff_filter_frame(ctx->outputs[0], outbuf);
275 }
276 
278 {
279  int i, status;
280  int ret, nb_samples;
281  int64_t pts;
282 
284 
285  nb_samples = ff_inlink_queued_samples(ctx->inputs[0]);
286  for (i = 1; i < ctx->nb_inputs && nb_samples > 0; i++) {
287  nb_samples = FFMIN(ff_inlink_queued_samples(ctx->inputs[i]), nb_samples);
288  }
289 
290  if (nb_samples) {
291  ret = try_push_frame(ctx, nb_samples);
292  if (ret < 0)
293  return ret;
294  }
295 
296  for (i = 0; i < ctx->nb_inputs; i++) {
297  if (ff_inlink_queued_samples(ctx->inputs[i]))
298  continue;
299 
300  if (ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts)) {
301  ff_outlink_set_status(ctx->outputs[0], status, pts);
302  return 0;
303  } else if (ff_outlink_frame_wanted(ctx->outputs[0])) {
305  return 0;
306  }
307  }
308 
309  return 0;
310 }
311 
313 {
314  AMergeContext *s = ctx->priv;
315  int i, ret;
316 
317  s->in = av_calloc(s->nb_inputs, sizeof(*s->in));
318  if (!s->in)
319  return AVERROR(ENOMEM);
320  for (i = 0; i < s->nb_inputs; i++) {
321  char *name = av_asprintf("in%d", i);
322  AVFilterPad pad = {
323  .name = name,
324  .type = AVMEDIA_TYPE_AUDIO,
325  };
326  if (!name)
327  return AVERROR(ENOMEM);
328  if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
329  av_freep(&pad.name);
330  return ret;
331  }
332  }
333  return 0;
334 }
335 
336 static const AVFilterPad amerge_outputs[] = {
337  {
338  .name = "default",
339  .type = AVMEDIA_TYPE_AUDIO,
340  .config_props = config_output,
341  },
342  { NULL }
343 };
344 
346  .name = "amerge",
347  .description = NULL_IF_CONFIG_SMALL("Merge two or more audio streams into "
348  "a single multi-channel stream."),
349  .priv_size = sizeof(AMergeContext),
350  .init = init,
351  .uninit = uninit,
353  .activate = activate,
354  .inputs = NULL,
355  .outputs = amerge_outputs,
356  .priv_class = &amerge_class,
358 };
struct AMergeContext::amerge_input * in
#define NULL
Definition: coverity.c:32
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
int nb_ch
number of channels for the input
Definition: af_amerge.c:43
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVOption.
Definition: opt.h:246
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Definition: filters.h:212
Main libavfilter public API header.
#define SWR_CH_MAX
Definition: af_amerge.c:35
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:105
AVFILTER_DEFINE_CLASS(amerge)
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1602
static int ff_outlink_frame_wanted(AVFilterLink *link)
Test if a frame is wanted on an output link.
Definition: filters.h:172
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:247
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
static int activate(AVFilterContext *ctx)
Definition: af_amerge.c:277
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:465
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
uint8_t
#define av_cold
Definition: attributes.h:88
AVOptions.
#define FF_LAYOUT2COUNT(l)
Decode a channel count encoded as a channel layout.
Definition: formats.h:108
static enum AVSampleFormat ff_packed_sample_fmts_array[]
Definition: audio.h:28
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
static av_cold int init(AVFilterContext *ctx)
Definition: af_amerge.c:312
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define av_log(a,...)
static void free_frames(int nb_inputs, AVFrame **input_frames)
Definition: af_amerge.c:215
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_amerge.c:58
A filter pad used for either input or output.
Definition: internal.h:54
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1431
static const AVFilterPad amerge_outputs[]
Definition: af_amerge.c:336
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:600
static const AVOption amerge_options[]
Definition: af_amerge.c:50
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:342
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:86
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
void * priv
private data for use by the filter
Definition: avfilter.h:353
uint64_t * channel_layouts
list of channel layouts
Definition: formats.h:86
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:477
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
static int config_output(AVFilterLink *outlink)
Definition: af_amerge.c:146
const char * name
Definition: qsvenc.c:46
int channels
number of audio channels, only used for audio.
Definition: frame.h:606
audio channel layout utility functions
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
#define FFMIN(a, b)
Definition: common.h:96
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1456
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int try_push_frame(AVFilterContext *ctx, int nb_samples)
Definition: af_amerge.c:222
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
A list of supported channel layouts.
Definition: formats.h:85
void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout)
Append a description of a channel layout to a bprint buffer.
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
#define FLAGS
Definition: af_amerge.c:48
static int query_formats(AVFilterContext *ctx)
Definition: af_amerge.c:70
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define AV_BPRINT_SIZE_AUTOMATIC
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link&#39;s FIFO and update the link&#39;s stats.
Definition: avfilter.c:1495
AVFilter ff_af_amerge
Definition: af_amerge.c:345
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
const char * name
Filter name.
Definition: avfilter.h:148
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:425
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:564
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
#define ns(max_value, name, subs,...)
Definition: cbs_av1.c:685
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
#define OFFSET(x)
Definition: af_amerge.c:47
static double c[64]
int route[SWR_CH_MAX]
channels routing, see copy_samples
Definition: af_amerge.c:40
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
static void copy_samples(int nb_inputs, struct amerge_input in[], int *route, uint8_t *ins[], uint8_t **outs, int ns, int bps)
Copy samples from several input streams to one output stream.
Definition: af_amerge.c:194
#define av_freep(p)
formats
Definition: signature.h:48
internal API functions
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:366
for(j=16;j >0;--j)
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:588
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.
Definition: internal.h:266