FFmpeg
af_amix.c
Go to the documentation of this file.
1 /*
2  * Audio Mix Filter
3  * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Audio Mix Filter
25  *
26  * Mixes audio from multiple sources into a single output. The channel layout,
27  * sample rate, and sample format will be the same for all inputs and the
28  * output.
29  */
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/audio_fifo.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
36 #include "libavutil/common.h"
37 #include "libavutil/eval.h"
38 #include "libavutil/float_dsp.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/samplefmt.h"
42 
43 #include "audio.h"
44 #include "avfilter.h"
45 #include "filters.h"
46 #include "internal.h"
47 
48 #define INPUT_ON 1 /**< input is active */
49 #define INPUT_EOF 2 /**< input has reached EOF (may still be active) */
50 
51 #define DURATION_LONGEST 0
52 #define DURATION_SHORTEST 1
53 #define DURATION_FIRST 2
54 
55 
56 typedef struct FrameInfo {
58  int64_t pts;
59  struct FrameInfo *next;
60 } FrameInfo;
61 
62 /**
63  * Linked list used to store timestamps and frame sizes of all frames in the
64  * FIFO for the first input.
65  *
66  * This is needed to keep timestamps synchronized for the case where multiple
67  * input frames are pushed to the filter for processing before a frame is
68  * requested by the output link.
69  */
70 typedef struct FrameList {
71  int nb_frames;
75 } FrameList;
76 
77 static void frame_list_clear(FrameList *frame_list)
78 {
79  if (frame_list) {
80  while (frame_list->list) {
81  FrameInfo *info = frame_list->list;
82  frame_list->list = info->next;
83  av_free(info);
84  }
85  frame_list->nb_frames = 0;
86  frame_list->nb_samples = 0;
87  frame_list->end = NULL;
88  }
89 }
90 
91 static int frame_list_next_frame_size(FrameList *frame_list)
92 {
93  if (!frame_list->list)
94  return 0;
95  return frame_list->list->nb_samples;
96 }
97 
98 static int64_t frame_list_next_pts(FrameList *frame_list)
99 {
100  if (!frame_list->list)
101  return AV_NOPTS_VALUE;
102  return frame_list->list->pts;
103 }
104 
105 static void frame_list_remove_samples(FrameList *frame_list, int nb_samples)
106 {
107  if (nb_samples >= frame_list->nb_samples) {
108  frame_list_clear(frame_list);
109  } else {
110  int samples = nb_samples;
111  while (samples > 0) {
112  FrameInfo *info = frame_list->list;
113  av_assert0(info);
114  if (info->nb_samples <= samples) {
115  samples -= info->nb_samples;
116  frame_list->list = info->next;
117  if (!frame_list->list)
118  frame_list->end = NULL;
119  frame_list->nb_frames--;
120  frame_list->nb_samples -= info->nb_samples;
121  av_free(info);
122  } else {
123  info->nb_samples -= samples;
124  info->pts += samples;
125  frame_list->nb_samples -= samples;
126  samples = 0;
127  }
128  }
129  }
130 }
131 
132 static int frame_list_add_frame(FrameList *frame_list, int nb_samples, int64_t pts)
133 {
134  FrameInfo *info = av_malloc(sizeof(*info));
135  if (!info)
136  return AVERROR(ENOMEM);
137  info->nb_samples = nb_samples;
138  info->pts = pts;
139  info->next = NULL;
140 
141  if (!frame_list->list) {
142  frame_list->list = info;
143  frame_list->end = info;
144  } else {
145  av_assert0(frame_list->end);
146  frame_list->end->next = info;
147  frame_list->end = info;
148  }
149  frame_list->nb_frames++;
150  frame_list->nb_samples += nb_samples;
151 
152  return 0;
153 }
154 
155 /* FIXME: use directly links fifo */
156 
157 typedef struct MixContext {
158  const AVClass *class; /**< class for AVOptions */
160 
161  int nb_inputs; /**< number of inputs */
162  int active_inputs; /**< number of input currently active */
163  int duration_mode; /**< mode for determining duration */
164  float dropout_transition; /**< transition time when an input drops out */
165  char *weights_str; /**< string for custom weights for every input */
166  int normalize; /**< if inputs are scaled */
167 
168  int nb_channels; /**< number of channels */
169  int sample_rate; /**< sample rate */
170  int planar;
171  AVAudioFifo **fifos; /**< audio fifo for each input */
172  uint8_t *input_state; /**< current state of each input */
173  float *input_scale; /**< mixing scale factor for each input */
174  float *weights; /**< custom weights for every input */
175  float weight_sum; /**< sum of custom weights for every input */
176  float *scale_norm; /**< normalization factor for every input */
177  int64_t next_pts; /**< calculated pts for next output frame */
178  FrameList *frame_list; /**< list of frame info for the first input */
179 } MixContext;
180 
181 #define OFFSET(x) offsetof(MixContext, x)
182 #define A AV_OPT_FLAG_AUDIO_PARAM
183 #define F AV_OPT_FLAG_FILTERING_PARAM
184 #define T AV_OPT_FLAG_RUNTIME_PARAM
185 static const AVOption amix_options[] = {
186  { "inputs", "Number of inputs.",
187  OFFSET(nb_inputs), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, INT16_MAX, A|F },
188  { "duration", "How to determine the end-of-stream.",
189  OFFSET(duration_mode), AV_OPT_TYPE_INT, { .i64 = DURATION_LONGEST }, 0, 2, A|F, .unit = "duration" },
190  { "longest", "Duration of longest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST }, 0, 0, A|F, .unit = "duration" },
191  { "shortest", "Duration of shortest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, 0, 0, A|F, .unit = "duration" },
192  { "first", "Duration of first input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST }, 0, 0, A|F, .unit = "duration" },
193  { "dropout_transition", "Transition time, in seconds, for volume "
194  "renormalization when an input stream ends.",
195  OFFSET(dropout_transition), AV_OPT_TYPE_FLOAT, { .dbl = 2.0 }, 0, INT_MAX, A|F },
196  { "weights", "Set weight for each input.",
197  OFFSET(weights_str), AV_OPT_TYPE_STRING, {.str="1 1"}, 0, 0, A|F|T },
198  { "normalize", "Scale inputs",
199  OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, A|F|T },
200  { NULL }
201 };
202 
204 
205 /**
206  * Update the scaling factors to apply to each input during mixing.
207  *
208  * This balances the full volume range between active inputs and handles
209  * volume transitions when EOF is encountered on an input but mixing continues
210  * with the remaining inputs.
211  */
212 static void calculate_scales(MixContext *s, int nb_samples)
213 {
214  float weight_sum = 0.f;
215  int i;
216 
217  for (i = 0; i < s->nb_inputs; i++)
218  if (s->input_state[i] & INPUT_ON)
219  weight_sum += FFABS(s->weights[i]);
220 
221  for (i = 0; i < s->nb_inputs; i++) {
222  if (s->input_state[i] & INPUT_ON) {
223  if (s->scale_norm[i] > weight_sum / FFABS(s->weights[i])) {
224  s->scale_norm[i] -= ((s->weight_sum / FFABS(s->weights[i])) / s->nb_inputs) *
225  nb_samples / (s->dropout_transition * s->sample_rate);
226  s->scale_norm[i] = FFMAX(s->scale_norm[i], weight_sum / FFABS(s->weights[i]));
227  }
228  }
229  }
230 
231  for (i = 0; i < s->nb_inputs; i++) {
232  if (s->input_state[i] & INPUT_ON) {
233  if (!s->normalize)
234  s->input_scale[i] = FFABS(s->weights[i]);
235  else
236  s->input_scale[i] = 1.0f / s->scale_norm[i] * FFSIGN(s->weights[i]);
237  } else {
238  s->input_scale[i] = 0.0f;
239  }
240  }
241 }
242 
243 static int config_output(AVFilterLink *outlink)
244 {
245  AVFilterContext *ctx = outlink->src;
246  MixContext *s = ctx->priv;
247  int i;
248  char buf[64];
249 
250  s->planar = av_sample_fmt_is_planar(outlink->format);
251  s->sample_rate = outlink->sample_rate;
252  outlink->time_base = (AVRational){ 1, outlink->sample_rate };
253  s->next_pts = AV_NOPTS_VALUE;
254 
255  s->frame_list = av_mallocz(sizeof(*s->frame_list));
256  if (!s->frame_list)
257  return AVERROR(ENOMEM);
258 
259  s->fifos = av_calloc(s->nb_inputs, sizeof(*s->fifos));
260  if (!s->fifos)
261  return AVERROR(ENOMEM);
262 
263  s->nb_channels = outlink->ch_layout.nb_channels;
264  for (i = 0; i < s->nb_inputs; i++) {
265  s->fifos[i] = av_audio_fifo_alloc(outlink->format, s->nb_channels, 1024);
266  if (!s->fifos[i])
267  return AVERROR(ENOMEM);
268  }
269 
270  s->input_state = av_malloc(s->nb_inputs);
271  if (!s->input_state)
272  return AVERROR(ENOMEM);
273  memset(s->input_state, INPUT_ON, s->nb_inputs);
274  s->active_inputs = s->nb_inputs;
275 
276  s->input_scale = av_calloc(s->nb_inputs, sizeof(*s->input_scale));
277  s->scale_norm = av_calloc(s->nb_inputs, sizeof(*s->scale_norm));
278  if (!s->input_scale || !s->scale_norm)
279  return AVERROR(ENOMEM);
280  for (i = 0; i < s->nb_inputs; i++)
281  s->scale_norm[i] = s->weight_sum / FFABS(s->weights[i]);
282  calculate_scales(s, 0);
283 
284  av_channel_layout_describe(&outlink->ch_layout, buf, sizeof(buf));
285 
287  "inputs:%d fmt:%s srate:%d cl:%s\n", s->nb_inputs,
288  av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf);
289 
290  return 0;
291 }
292 
293 /**
294  * Read samples from the input FIFOs, mix, and write to the output link.
295  */
296 static int output_frame(AVFilterLink *outlink)
297 {
298  AVFilterContext *ctx = outlink->src;
299  MixContext *s = ctx->priv;
300  AVFrame *out_buf, *in_buf;
301  int nb_samples, ns, i;
302 
303  if (s->input_state[0] & INPUT_ON) {
304  /* first input live: use the corresponding frame size */
305  nb_samples = frame_list_next_frame_size(s->frame_list);
306  for (i = 1; i < s->nb_inputs; i++) {
307  if (s->input_state[i] & INPUT_ON) {
308  ns = av_audio_fifo_size(s->fifos[i]);
309  if (ns < nb_samples) {
310  if (!(s->input_state[i] & INPUT_EOF))
311  /* unclosed input with not enough samples */
312  return 0;
313  /* closed input to drain */
314  nb_samples = ns;
315  }
316  }
317  }
318 
319  s->next_pts = frame_list_next_pts(s->frame_list);
320  } else {
321  /* first input closed: use the available samples */
322  nb_samples = INT_MAX;
323  for (i = 1; i < s->nb_inputs; i++) {
324  if (s->input_state[i] & INPUT_ON) {
325  ns = av_audio_fifo_size(s->fifos[i]);
326  nb_samples = FFMIN(nb_samples, ns);
327  }
328  }
329  if (nb_samples == INT_MAX) {
330  ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
331  return 0;
332  }
333  }
334 
335  frame_list_remove_samples(s->frame_list, nb_samples);
336 
337  calculate_scales(s, nb_samples);
338 
339  if (nb_samples == 0)
340  return 0;
341 
342  out_buf = ff_get_audio_buffer(outlink, nb_samples);
343  if (!out_buf)
344  return AVERROR(ENOMEM);
345 
346  in_buf = ff_get_audio_buffer(outlink, nb_samples);
347  if (!in_buf) {
348  av_frame_free(&out_buf);
349  return AVERROR(ENOMEM);
350  }
351 
352  for (i = 0; i < s->nb_inputs; i++) {
353  if (s->input_state[i] & INPUT_ON) {
354  int planes, plane_size, p;
355 
356  av_audio_fifo_read(s->fifos[i], (void **)in_buf->extended_data,
357  nb_samples);
358 
359  planes = s->planar ? s->nb_channels : 1;
360  plane_size = nb_samples * (s->planar ? 1 : s->nb_channels);
361  plane_size = FFALIGN(plane_size, 16);
362 
363  if (out_buf->format == AV_SAMPLE_FMT_FLT ||
364  out_buf->format == AV_SAMPLE_FMT_FLTP) {
365  for (p = 0; p < planes; p++) {
366  s->fdsp->vector_fmac_scalar((float *)out_buf->extended_data[p],
367  (float *) in_buf->extended_data[p],
368  s->input_scale[i], plane_size);
369  }
370  } else {
371  for (p = 0; p < planes; p++) {
372  s->fdsp->vector_dmac_scalar((double *)out_buf->extended_data[p],
373  (double *) in_buf->extended_data[p],
374  s->input_scale[i], plane_size);
375  }
376  }
377  }
378  }
379  av_frame_free(&in_buf);
380 
381  out_buf->pts = s->next_pts;
382  out_buf->duration = av_rescale_q(out_buf->nb_samples, av_make_q(1, outlink->sample_rate),
383  outlink->time_base);
384 
385  if (s->next_pts != AV_NOPTS_VALUE)
386  s->next_pts += nb_samples;
387 
388  return ff_filter_frame(outlink, out_buf);
389 }
390 
391 /**
392  * Requests a frame, if needed, from each input link other than the first.
393  */
394 static int request_samples(AVFilterContext *ctx, int min_samples)
395 {
396  MixContext *s = ctx->priv;
397  int i;
398 
399  av_assert0(s->nb_inputs > 1);
400  if (min_samples == 1 && s->duration_mode == DURATION_FIRST)
401  min_samples = av_audio_fifo_size(s->fifos[0]);
402 
403  for (i = 1; i < s->nb_inputs; i++) {
404  if (!(s->input_state[i] & INPUT_ON) ||
405  (s->input_state[i] & INPUT_EOF))
406  continue;
407  if (av_audio_fifo_size(s->fifos[i]) >= min_samples)
408  continue;
409  ff_inlink_request_frame(ctx->inputs[i]);
410  return 0;
411  }
412  return output_frame(ctx->outputs[0]);
413 }
414 
415 /**
416  * Calculates the number of active inputs and determines EOF based on the
417  * duration option.
418  *
419  * @return 0 if mixing should continue, or AVERROR_EOF if mixing should stop.
420  */
422 {
423  int i;
424  int active_inputs = 0;
425  for (i = 0; i < s->nb_inputs; i++)
426  active_inputs += !!(s->input_state[i] & INPUT_ON);
427  s->active_inputs = active_inputs;
428 
429  if (!active_inputs ||
430  (s->duration_mode == DURATION_FIRST && !(s->input_state[0] & INPUT_ON)) ||
431  (s->duration_mode == DURATION_SHORTEST && active_inputs != s->nb_inputs))
432  return AVERROR_EOF;
433  return 0;
434 }
435 
437 {
438  AVFilterLink *outlink = ctx->outputs[0];
439  MixContext *s = ctx->priv;
440  AVFrame *buf = NULL;
441  int i, ret;
442 
444 
445  for (i = 0; i < s->nb_inputs; i++) {
446  AVFilterLink *inlink = ctx->inputs[i];
447 
448  if ((ret = ff_inlink_consume_frame(ctx->inputs[i], &buf)) > 0) {
449  if (i == 0) {
450  int64_t pts = av_rescale_q(buf->pts, inlink->time_base,
451  outlink->time_base);
452  ret = frame_list_add_frame(s->frame_list, buf->nb_samples, pts);
453  if (ret < 0) {
454  av_frame_free(&buf);
455  return ret;
456  }
457  }
458 
459  ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,
460  buf->nb_samples);
461  if (ret < 0) {
462  av_frame_free(&buf);
463  return ret;
464  }
465 
466  av_frame_free(&buf);
467 
468  ret = output_frame(outlink);
469  if (ret < 0)
470  return ret;
471  }
472  }
473 
474  for (i = 0; i < s->nb_inputs; i++) {
475  int64_t pts;
476  int status;
477 
478  if (ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts)) {
479  if (status == AVERROR_EOF) {
480  s->input_state[i] |= INPUT_EOF;
481  if (av_audio_fifo_size(s->fifos[i]) == 0) {
482  s->input_state[i] &= ~INPUT_ON;
483  if (s->nb_inputs == 1) {
484  ff_outlink_set_status(outlink, status, pts);
485  return 0;
486  }
487  }
488  }
489  }
490  }
491 
492  if (calc_active_inputs(s)) {
493  ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
494  return 0;
495  }
496 
497  if (ff_outlink_frame_wanted(outlink)) {
498  int wanted_samples;
499 
500  if (!(s->input_state[0] & INPUT_ON))
501  return request_samples(ctx, 1);
502 
503  if (s->frame_list->nb_frames == 0) {
504  ff_inlink_request_frame(ctx->inputs[0]);
505  return 0;
506  }
507  av_assert0(s->frame_list->nb_frames > 0);
508 
509  wanted_samples = frame_list_next_frame_size(s->frame_list);
510 
511  return request_samples(ctx, wanted_samples);
512  }
513 
514  return 0;
515 }
516 
518 {
519  MixContext *s = ctx->priv;
520  float last_weight = 1.f;
521  char *p;
522  int i;
523 
524  s->weight_sum = 0.f;
525  p = s->weights_str;
526  for (i = 0; i < s->nb_inputs; i++) {
527  last_weight = av_strtod(p, &p);
528  s->weights[i] = last_weight;
529  s->weight_sum += FFABS(last_weight);
530  if (p && *p) {
531  p++;
532  } else {
533  i++;
534  break;
535  }
536  }
537 
538  for (; i < s->nb_inputs; i++) {
539  s->weights[i] = last_weight;
540  s->weight_sum += FFABS(last_weight);
541  }
542 }
543 
545 {
546  MixContext *s = ctx->priv;
547  int i, ret;
548 
549  for (i = 0; i < s->nb_inputs; i++) {
550  AVFilterPad pad = { 0 };
551 
552  pad.type = AVMEDIA_TYPE_AUDIO;
553  pad.name = av_asprintf("input%d", i);
554  if (!pad.name)
555  return AVERROR(ENOMEM);
556 
557  if ((ret = ff_append_inpad_free_name(ctx, &pad)) < 0)
558  return ret;
559  }
560 
561  s->fdsp = avpriv_float_dsp_alloc(0);
562  if (!s->fdsp)
563  return AVERROR(ENOMEM);
564 
565  s->weights = av_calloc(s->nb_inputs, sizeof(*s->weights));
566  if (!s->weights)
567  return AVERROR(ENOMEM);
568 
570 
571  return 0;
572 }
573 
575 {
576  int i;
577  MixContext *s = ctx->priv;
578 
579  if (s->fifos) {
580  for (i = 0; i < s->nb_inputs; i++)
581  av_audio_fifo_free(s->fifos[i]);
582  av_freep(&s->fifos);
583  }
584  frame_list_clear(s->frame_list);
585  av_freep(&s->frame_list);
586  av_freep(&s->input_state);
587  av_freep(&s->input_scale);
588  av_freep(&s->scale_norm);
589  av_freep(&s->weights);
590  av_freep(&s->fdsp);
591 }
592 
593 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
594  char *res, int res_len, int flags)
595 {
596  MixContext *s = ctx->priv;
597  int ret;
598 
599  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
600  if (ret < 0)
601  return ret;
602 
604  for (int i = 0; i < s->nb_inputs; i++)
605  s->scale_norm[i] = s->weight_sum / FFABS(s->weights[i]);
606  calculate_scales(s, 0);
607 
608  return 0;
609 }
610 
612  {
613  .name = "default",
614  .type = AVMEDIA_TYPE_AUDIO,
615  .config_props = config_output,
616  },
617 };
618 
620  .name = "amix",
621  .description = NULL_IF_CONFIG_SMALL("Audio mixing."),
622  .priv_size = sizeof(MixContext),
623  .priv_class = &amix_class,
624  .init = init,
625  .uninit = uninit,
626  .activate = activate,
627  .inputs = NULL,
631  .process_command = process_command,
633 };
av_audio_fifo_free
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:48
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:109
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
FrameList::end
FrameInfo * end
Definition: af_amix.c:74
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
FrameList::nb_frames
int nb_frames
Definition: af_amix.c:71
DURATION_LONGEST
#define DURATION_LONGEST
Definition: af_amix.c:51
DURATION_FIRST
#define DURATION_FIRST
Definition: af_amix.c:53
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:807
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_audio_fifo_write
int av_audio_fifo_write(AVAudioFifo *af, void *const *data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:119
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
MixContext::fdsp
AVFloatDSPContext * fdsp
Definition: af_amix.c:159
AVOption
AVOption.
Definition: opt.h:294
MixContext
Definition: af_amix.c:157
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
ff_af_amix
const AVFilter ff_af_amix
Definition: af_amix.c:619
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
FrameList::nb_samples
int nb_samples
Definition: af_amix.c:72
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_amix.c:593
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
INPUT_ON
#define INPUT_ON
input is active
Definition: af_amix.c:48
MixContext::input_scale
float * input_scale
mixing scale factor for each input
Definition: af_amix.c:173
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1438
INPUT_EOF
#define INPUT_EOF
input has reached EOF (may still be active)
Definition: af_amix.c:49
MixContext::sample_rate
int sample_rate
sample rate
Definition: af_amix.c:169
FF_FILTER_FORWARD_STATUS_BACK_ALL
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Definition: filters.h:212
AVAudioFifo
Context for an Audio FIFO Buffer.
Definition: audio_fifo.c:37
MixContext::frame_list
FrameList * frame_list
list of frame info for the first input
Definition: af_amix.c:178
FFSIGN
#define FFSIGN(a)
Definition: common.h:73
samplefmt.h
MixContext::normalize
int normalize
if inputs are scaled
Definition: af_amix.c:166
A
#define A
Definition: af_amix.c:182
pts
static int64_t pts
Definition: transcode_aac.c:643
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:106
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
avfilter_af_amix_outputs
static const AVFilterPad avfilter_af_amix_outputs[]
Definition: af_amix.c:611
avassert.h
amix_options
static const AVOption amix_options[]
Definition: af_amix.c:185
av_cold
#define av_cold
Definition: attributes.h:90
calculate_scales
static void calculate_scales(MixContext *s, int nb_samples)
Update the scaling factors to apply to each input during mixing.
Definition: af_amix.c:212
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:847
ff_outlink_set_status
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
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1564
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
info
MIPS optimizations info
Definition: mips.txt:2
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
MixContext::active_inputs
int active_inputs
number of input currently active
Definition: af_amix.c:162
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:51
MixContext::planar
int planar
Definition: af_amix.c:170
MixContext::duration_mode
int duration_mode
mode for determining duration
Definition: af_amix.c:163
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
MixContext::nb_channels
int nb_channels
number of channels
Definition: af_amix.c:168
MixContext::dropout_transition
float dropout_transition
transition time when an input drops out
Definition: af_amix.c:164
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_audio_fifo_alloc
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:62
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:131
MixContext::fifos
AVAudioFifo ** fifos
audio fifo for each input
Definition: af_amix.c:171
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
FrameList
Linked list used to store timestamps and frame sizes of all frames in the FIFO for the first input.
Definition: af_amix.c:70
MixContext::input_state
uint8_t * input_state
current state of each input
Definition: af_amix.c:172
ff_inlink_acknowledge_status
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:1386
FrameInfo
Definition: af_amix.c:56
frame_list_add_frame
static int frame_list_add_frame(FrameList *frame_list, int nb_samples, int64_t pts)
Definition: af_amix.c:132
float_dsp.h
eval.h
planes
static const struct @378 planes[]
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_amix.c:243
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_amix.c:574
av_audio_fifo_read
int av_audio_fifo_read(AVAudioFifo *af, void *const *data, int nb_samples)
Read data from an AVAudioFifo.
Definition: audio_fifo.c:175
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MixContext::scale_norm
float * scale_norm
normalization factor for every input
Definition: af_amix.c:176
MixContext::weights_str
char * weights_str
string for custom weights for every input
Definition: af_amix.c:165
AVFloatDSPContext
Definition: float_dsp.h:24
output_frame
static int output_frame(AVFilterLink *outlink)
Read samples from the input FIFOs, mix, and write to the output link.
Definition: af_amix.c:296
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
activate
static int activate(AVFilterContext *ctx)
Definition: af_amix.c:436
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:879
frame_list_next_pts
static int64_t frame_list_next_pts(FrameList *frame_list)
Definition: af_amix.c:98
attributes.h
ns
#define ns(max_value, name, subs,...)
Definition: cbs_av1.c:608
av_audio_fifo_size
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:222
MixContext::weight_sum
float weight_sum
sum of custom weights for every input
Definition: af_amix.c:175
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
MixContext::next_pts
int64_t next_pts
calculated pts for next output frame
Definition: af_amix.c:177
normalize
Definition: normalize.py:1
FrameInfo::nb_samples
int nb_samples
Definition: af_amix.c:57
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
FrameInfo::next
struct FrameInfo * next
Definition: af_amix.c:59
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
common.h
frame_list_next_frame_size
static int frame_list_next_frame_size(FrameList *frame_list)
Definition: af_amix.c:91
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
audio_fifo.h
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:44
av_strtod
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:108
MixContext::weights
float * weights
custom weights for every input
Definition: af_amix.c:174
status
ov_status_e status
Definition: dnn_backend_openvino.c:120
channel_layout.h
calc_active_inputs
static int calc_active_inputs(MixContext *s)
Calculates the number of active inputs and determines EOF based on the duration option.
Definition: af_amix.c:421
F
#define F
Definition: af_amix.c:183
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(amix)
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
AVFilterContext
An instance of a filter.
Definition: avfilter.h:409
T
#define T
Definition: af_amix.c:184
audio.h
request_samples
static int request_samples(AVFilterContext *ctx, int min_samples)
Requests a frame, if needed, from each input link other than the first.
Definition: af_amix.c:394
DURATION_SHORTEST
#define DURATION_SHORTEST
Definition: af_amix.c:52
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
OFFSET
#define OFFSET(x)
Definition: af_amix.c:181
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
init
static av_cold int init(AVFilterContext *ctx)
Definition: af_amix.c:544
frame_list_clear
static void frame_list_clear(FrameList *frame_list)
Definition: af_amix.c:77
parse_weights
static void parse_weights(AVFilterContext *ctx)
Definition: af_amix.c:517
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:61
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
FrameInfo::pts
int64_t pts
Definition: af_amix.c:58
FrameList::list
FrameInfo * list
Definition: af_amix.c:73
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
frame_list_remove_samples
static void frame_list_remove_samples(FrameList *frame_list, int nb_samples)
Definition: af_amix.c:105
MixContext::nb_inputs
int nb_inputs
number of inputs
Definition: af_amix.c:161
FILTER_SAMPLEFMTS
#define FILTER_SAMPLEFMTS(...)
Definition: internal.h:170