FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/af_amix.c
Date: 2022-12-05 20:26:17
Exec Total Coverage
Lines: 231 286 80.8%
Functions: 14 15 93.3%
Branches: 132 186 71.0%

Line Branch Exec Source
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"
35 #include "libavutil/channel_layout.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 "formats.h"
47 #include "internal.h"
48
49 #define INPUT_ON 1 /**< input is active */
50 #define INPUT_EOF 2 /**< input has reached EOF (may still be active) */
51
52 #define DURATION_LONGEST 0
53 #define DURATION_SHORTEST 1
54 #define DURATION_FIRST 2
55
56
57 typedef struct FrameInfo {
58 int nb_samples;
59 int64_t pts;
60 struct FrameInfo *next;
61 } FrameInfo;
62
63 /**
64 * Linked list used to store timestamps and frame sizes of all frames in the
65 * FIFO for the first input.
66 *
67 * This is needed to keep timestamps synchronized for the case where multiple
68 * input frames are pushed to the filter for processing before a frame is
69 * requested by the output link.
70 */
71 typedef struct FrameList {
72 int nb_frames;
73 int nb_samples;
74 FrameInfo *list;
75 FrameInfo *end;
76 } FrameList;
77
78 890 static void frame_list_clear(FrameList *frame_list)
79 {
80
2/2
✓ Branch 0 taken 884 times.
✓ Branch 1 taken 6 times.
890 if (frame_list) {
81
2/2
✓ Branch 0 taken 874 times.
✓ Branch 1 taken 884 times.
1758 while (frame_list->list) {
82 874 FrameInfo *info = frame_list->list;
83 874 frame_list->list = info->next;
84 874 av_free(info);
85 }
86 884 frame_list->nb_frames = 0;
87 884 frame_list->nb_samples = 0;
88 884 frame_list->end = NULL;
89 }
90 890 }
91
92 2717 static int frame_list_next_frame_size(FrameList *frame_list)
93 {
94
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2713 times.
2717 if (!frame_list->list)
95 4 return 0;
96 2713 return frame_list->list->nb_samples;
97 }
98
99 884 static int64_t frame_list_next_pts(FrameList *frame_list)
100 {
101
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 880 times.
884 if (!frame_list->list)
102 4 return AV_NOPTS_VALUE;
103 880 return frame_list->list->pts;
104 }
105
106 884 static void frame_list_remove_samples(FrameList *frame_list, int nb_samples)
107 {
108
2/2
✓ Branch 0 taken 878 times.
✓ Branch 1 taken 6 times.
884 if (nb_samples >= frame_list->nb_samples) {
109 878 frame_list_clear(frame_list);
110 } else {
111 6 int samples = nb_samples;
112
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
12 while (samples > 0) {
113 6 FrameInfo *info = frame_list->list;
114
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 av_assert0(info);
115
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (info->nb_samples <= samples) {
116 samples -= info->nb_samples;
117 frame_list->list = info->next;
118 if (!frame_list->list)
119 frame_list->end = NULL;
120 frame_list->nb_frames--;
121 frame_list->nb_samples -= info->nb_samples;
122 av_free(info);
123 } else {
124 6 info->nb_samples -= samples;
125 6 info->pts += samples;
126 6 frame_list->nb_samples -= samples;
127 6 samples = 0;
128 }
129 }
130 }
131 884 }
132
133 874 static int frame_list_add_frame(FrameList *frame_list, int nb_samples, int64_t pts)
134 {
135 874 FrameInfo *info = av_malloc(sizeof(*info));
136
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 874 times.
874 if (!info)
137 return AVERROR(ENOMEM);
138 874 info->nb_samples = nb_samples;
139 874 info->pts = pts;
140 874 info->next = NULL;
141
142
1/2
✓ Branch 0 taken 874 times.
✗ Branch 1 not taken.
874 if (!frame_list->list) {
143 874 frame_list->list = info;
144 874 frame_list->end = info;
145 } else {
146 av_assert0(frame_list->end);
147 frame_list->end->next = info;
148 frame_list->end = info;
149 }
150 874 frame_list->nb_frames++;
151 874 frame_list->nb_samples += nb_samples;
152
153 874 return 0;
154 }
155
156 /* FIXME: use directly links fifo */
157
158 typedef struct MixContext {
159 const AVClass *class; /**< class for AVOptions */
160 AVFloatDSPContext *fdsp;
161
162 int nb_inputs; /**< number of inputs */
163 int active_inputs; /**< number of input currently active */
164 int duration_mode; /**< mode for determining duration */
165 float dropout_transition; /**< transition time when an input drops out */
166 char *weights_str; /**< string for custom weights for every input */
167 int normalize; /**< if inputs are scaled */
168
169 int nb_channels; /**< number of channels */
170 int sample_rate; /**< sample rate */
171 int planar;
172 AVAudioFifo **fifos; /**< audio fifo for each input */
173 uint8_t *input_state; /**< current state of each input */
174 float *input_scale; /**< mixing scale factor for each input */
175 float *weights; /**< custom weights for every input */
176 float weight_sum; /**< sum of custom weights for every input */
177 float *scale_norm; /**< normalization factor for every input */
178 int64_t next_pts; /**< calculated pts for next output frame */
179 FrameList *frame_list; /**< list of frame info for the first input */
180 } MixContext;
181
182 #define OFFSET(x) offsetof(MixContext, x)
183 #define A AV_OPT_FLAG_AUDIO_PARAM
184 #define F AV_OPT_FLAG_FILTERING_PARAM
185 #define T AV_OPT_FLAG_RUNTIME_PARAM
186 static const AVOption amix_options[] = {
187 { "inputs", "Number of inputs.",
188 OFFSET(nb_inputs), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, INT16_MAX, A|F },
189 { "duration", "How to determine the end-of-stream.",
190 OFFSET(duration_mode), AV_OPT_TYPE_INT, { .i64 = DURATION_LONGEST }, 0, 2, A|F, "duration" },
191 { "longest", "Duration of longest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST }, 0, 0, A|F, "duration" },
192 { "shortest", "Duration of shortest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, 0, 0, A|F, "duration" },
193 { "first", "Duration of first input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST }, 0, 0, A|F, "duration" },
194 { "dropout_transition", "Transition time, in seconds, for volume "
195 "renormalization when an input stream ends.",
196 OFFSET(dropout_transition), AV_OPT_TYPE_FLOAT, { .dbl = 2.0 }, 0, INT_MAX, A|F },
197 { "weights", "Set weight for each input.",
198 OFFSET(weights_str), AV_OPT_TYPE_STRING, {.str="1 1"}, 0, 0, A|F|T },
199 { "normalize", "Scale inputs",
200 OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, A|F|T },
201 { NULL }
202 };
203
204 AVFILTER_DEFINE_CLASS(amix);
205
206 /**
207 * Update the scaling factors to apply to each input during mixing.
208 *
209 * This balances the full volume range between active inputs and handles
210 * volume transitions when EOF is encountered on an input but mixing continues
211 * with the remaining inputs.
212 */
213 890 static void calculate_scales(MixContext *s, int nb_samples)
214 {
215 890 float weight_sum = 0.f;
216 int i;
217
218
2/2
✓ Branch 0 taken 2042 times.
✓ Branch 1 taken 890 times.
2932 for (i = 0; i < s->nb_inputs; i++)
219
2/2
✓ Branch 0 taken 1511 times.
✓ Branch 1 taken 531 times.
2042 if (s->input_state[i] & INPUT_ON)
220 1511 weight_sum += FFABS(s->weights[i]);
221
222
2/2
✓ Branch 0 taken 2042 times.
✓ Branch 1 taken 890 times.
2932 for (i = 0; i < s->nb_inputs; i++) {
223
2/2
✓ Branch 0 taken 1511 times.
✓ Branch 1 taken 531 times.
2042 if (s->input_state[i] & INPUT_ON) {
224
2/2
✓ Branch 0 taken 293 times.
✓ Branch 1 taken 1218 times.
1511 if (s->scale_norm[i] > weight_sum / FFABS(s->weights[i])) {
225 293 s->scale_norm[i] -= ((s->weight_sum / FFABS(s->weights[i])) / s->nb_inputs) *
226 293 nb_samples / (s->dropout_transition * s->sample_rate);
227
2/2
✓ Branch 0 taken 289 times.
✓ Branch 1 taken 4 times.
293 s->scale_norm[i] = FFMAX(s->scale_norm[i], weight_sum / FFABS(s->weights[i]));
228 }
229 }
230 }
231
232
2/2
✓ Branch 0 taken 2042 times.
✓ Branch 1 taken 890 times.
2932 for (i = 0; i < s->nb_inputs; i++) {
233
2/2
✓ Branch 0 taken 1511 times.
✓ Branch 1 taken 531 times.
2042 if (s->input_state[i] & INPUT_ON) {
234
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1511 times.
1511 if (!s->normalize)
235 s->input_scale[i] = FFABS(s->weights[i]);
236 else
237
1/2
✓ Branch 0 taken 1511 times.
✗ Branch 1 not taken.
1511 s->input_scale[i] = 1.0f / s->scale_norm[i] * FFSIGN(s->weights[i]);
238 } else {
239 531 s->input_scale[i] = 0.0f;
240 }
241 }
242 890 }
243
244 6 static int config_output(AVFilterLink *outlink)
245 {
246 6 AVFilterContext *ctx = outlink->src;
247 6 MixContext *s = ctx->priv;
248 int i;
249 char buf[64];
250
251 6 s->planar = av_sample_fmt_is_planar(outlink->format);
252 6 s->sample_rate = outlink->sample_rate;
253 6 outlink->time_base = (AVRational){ 1, outlink->sample_rate };
254 6 s->next_pts = AV_NOPTS_VALUE;
255
256 6 s->frame_list = av_mallocz(sizeof(*s->frame_list));
257
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (!s->frame_list)
258 return AVERROR(ENOMEM);
259
260 6 s->fifos = av_calloc(s->nb_inputs, sizeof(*s->fifos));
261
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (!s->fifos)
262 return AVERROR(ENOMEM);
263
264 6 s->nb_channels = outlink->ch_layout.nb_channels;
265
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 6 times.
19 for (i = 0; i < s->nb_inputs; i++) {
266 13 s->fifos[i] = av_audio_fifo_alloc(outlink->format, s->nb_channels, 1024);
267
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (!s->fifos[i])
268 return AVERROR(ENOMEM);
269 }
270
271 6 s->input_state = av_malloc(s->nb_inputs);
272
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (!s->input_state)
273 return AVERROR(ENOMEM);
274 6 memset(s->input_state, INPUT_ON, s->nb_inputs);
275 6 s->active_inputs = s->nb_inputs;
276
277 6 s->input_scale = av_calloc(s->nb_inputs, sizeof(*s->input_scale));
278 6 s->scale_norm = av_calloc(s->nb_inputs, sizeof(*s->scale_norm));
279
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
6 if (!s->input_scale || !s->scale_norm)
280 return AVERROR(ENOMEM);
281
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 6 times.
19 for (i = 0; i < s->nb_inputs; i++)
282 13 s->scale_norm[i] = s->weight_sum / FFABS(s->weights[i]);
283 6 calculate_scales(s, 0);
284
285 6 av_channel_layout_describe(&outlink->ch_layout, buf, sizeof(buf));
286
287 6 av_log(ctx, AV_LOG_VERBOSE,
288 "inputs:%d fmt:%s srate:%d cl:%s\n", s->nb_inputs,
289 6 av_get_sample_fmt_name(outlink->format), outlink->sample_rate, buf);
290
291 6 return 0;
292 }
293
294 /**
295 * Read samples from the input FIFOs, mix, and write to the output link.
296 */
297 2100 static int output_frame(AVFilterLink *outlink)
298 {
299 2100 AVFilterContext *ctx = outlink->src;
300 2100 MixContext *s = ctx->priv;
301 AVFrame *out_buf, *in_buf;
302 int nb_samples, ns, i;
303
304
1/2
✓ Branch 0 taken 2100 times.
✗ Branch 1 not taken.
2100 if (s->input_state[0] & INPUT_ON) {
305 /* first input live: use the corresponding frame size */
306 2100 nb_samples = frame_list_next_frame_size(s->frame_list);
307
2/2
✓ Branch 0 taken 2536 times.
✓ Branch 1 taken 884 times.
3420 for (i = 1; i < s->nb_inputs; i++) {
308
2/2
✓ Branch 0 taken 2005 times.
✓ Branch 1 taken 531 times.
2536 if (s->input_state[i] & INPUT_ON) {
309 2005 ns = av_audio_fifo_size(s->fifos[i]);
310
2/2
✓ Branch 0 taken 1222 times.
✓ Branch 1 taken 783 times.
2005 if (ns < nb_samples) {
311
2/2
✓ Branch 0 taken 1216 times.
✓ Branch 1 taken 6 times.
1222 if (!(s->input_state[i] & INPUT_EOF))
312 /* unclosed input with not enough samples */
313 1216 return 0;
314 /* closed input to drain */
315 6 nb_samples = ns;
316 }
317 }
318 }
319
320 884 s->next_pts = frame_list_next_pts(s->frame_list);
321 } else {
322 /* first input closed: use the available samples */
323 nb_samples = INT_MAX;
324 for (i = 1; i < s->nb_inputs; i++) {
325 if (s->input_state[i] & INPUT_ON) {
326 ns = av_audio_fifo_size(s->fifos[i]);
327 nb_samples = FFMIN(nb_samples, ns);
328 }
329 }
330 if (nb_samples == INT_MAX) {
331 ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
332 return 0;
333 }
334 }
335
336 884 frame_list_remove_samples(s->frame_list, nb_samples);
337
338 884 calculate_scales(s, nb_samples);
339
340
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 880 times.
884 if (nb_samples == 0)
341 4 return 0;
342
343 880 out_buf = ff_get_audio_buffer(outlink, nb_samples);
344
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 880 times.
880 if (!out_buf)
345 return AVERROR(ENOMEM);
346
347 880 in_buf = ff_get_audio_buffer(outlink, nb_samples);
348
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 880 times.
880 if (!in_buf) {
349 av_frame_free(&out_buf);
350 return AVERROR(ENOMEM);
351 }
352
353
2/2
✓ Branch 0 taken 2021 times.
✓ Branch 1 taken 880 times.
2901 for (i = 0; i < s->nb_inputs; i++) {
354
2/2
✓ Branch 0 taken 1490 times.
✓ Branch 1 taken 531 times.
2021 if (s->input_state[i] & INPUT_ON) {
355 int planes, plane_size, p;
356
357 1490 av_audio_fifo_read(s->fifos[i], (void **)in_buf->extended_data,
358 nb_samples);
359
360
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1490 times.
1490 planes = s->planar ? s->nb_channels : 1;
361
1/2
✓ Branch 0 taken 1490 times.
✗ Branch 1 not taken.
1490 plane_size = nb_samples * (s->planar ? 1 : s->nb_channels);
362 1490 plane_size = FFALIGN(plane_size, 16);
363
364
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1490 times.
1490 if (out_buf->format == AV_SAMPLE_FMT_FLT ||
365 out_buf->format == AV_SAMPLE_FMT_FLTP) {
366
2/2
✓ Branch 0 taken 1490 times.
✓ Branch 1 taken 1490 times.
2980 for (p = 0; p < planes; p++) {
367 1490 s->fdsp->vector_fmac_scalar((float *)out_buf->extended_data[p],
368 1490 (float *) in_buf->extended_data[p],
369 1490 s->input_scale[i], plane_size);
370 }
371 } else {
372 for (p = 0; p < planes; p++) {
373 s->fdsp->vector_dmac_scalar((double *)out_buf->extended_data[p],
374 (double *) in_buf->extended_data[p],
375 s->input_scale[i], plane_size);
376 }
377 }
378 }
379 }
380 880 av_frame_free(&in_buf);
381
382 880 out_buf->pts = s->next_pts;
383
1/2
✓ Branch 0 taken 880 times.
✗ Branch 1 not taken.
880 if (s->next_pts != AV_NOPTS_VALUE)
384 880 s->next_pts += nb_samples;
385
386 880 return ff_filter_frame(outlink, out_buf);
387 }
388
389 /**
390 * Requests a frame, if needed, from each input link other than the first.
391 */
392 617 static int request_samples(AVFilterContext *ctx, int min_samples)
393 {
394 617 MixContext *s = ctx->priv;
395 int i;
396
397
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
617 av_assert0(s->nb_inputs > 1);
398
399
2/2
✓ Branch 0 taken 881 times.
✓ Branch 1 taken 617 times.
1498 for (i = 1; i < s->nb_inputs; i++) {
400
2/2
✓ Branch 0 taken 786 times.
✓ Branch 1 taken 95 times.
881 if (!(s->input_state[i] & INPUT_ON) ||
401
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 780 times.
786 (s->input_state[i] & INPUT_EOF))
402 101 continue;
403
2/2
✓ Branch 1 taken 89 times.
✓ Branch 2 taken 691 times.
780 if (av_audio_fifo_size(s->fifos[i]) >= min_samples)
404 89 continue;
405 691 ff_inlink_request_frame(ctx->inputs[i]);
406 }
407 617 return output_frame(ctx->outputs[0]);
408 }
409
410 /**
411 * Calculates the number of active inputs and determines EOF based on the
412 * duration option.
413 *
414 * @return 0 if mixing should continue, or AVERROR_EOF if mixing should stop.
415 */
416 2372 static int calc_active_inputs(MixContext *s)
417 {
418 int i;
419 2372 int active_inputs = 0;
420
2/2
✓ Branch 0 taken 5527 times.
✓ Branch 1 taken 2372 times.
7899 for (i = 0; i < s->nb_inputs; i++)
421 5527 active_inputs += !!(s->input_state[i] & INPUT_ON);
422 2372 s->active_inputs = active_inputs;
423
424
2/2
✓ Branch 0 taken 2367 times.
✓ Branch 1 taken 5 times.
2372 if (!active_inputs ||
425
4/4
✓ Branch 0 taken 262 times.
✓ Branch 1 taken 2105 times.
✓ Branch 2 taken 261 times.
✓ Branch 3 taken 1 times.
2367 (s->duration_mode == DURATION_FIRST && !(s->input_state[0] & INPUT_ON)) ||
426
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2366 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
2366 (s->duration_mode == DURATION_SHORTEST && active_inputs != s->nb_inputs))
427 6 return AVERROR_EOF;
428 2366 return 0;
429 }
430
431 2378 static int activate(AVFilterContext *ctx)
432 {
433 2378 AVFilterLink *outlink = ctx->outputs[0];
434 2378 MixContext *s = ctx->priv;
435 2378 AVFrame *buf = NULL;
436 int i, ret;
437
438
4/4
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 2372 times.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 6 times.
2391 FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
439
440
2/2
✓ Branch 0 taken 5527 times.
✓ Branch 1 taken 2372 times.
7899 for (i = 0; i < s->nb_inputs; i++) {
441 5527 AVFilterLink *inlink = ctx->inputs[i];
442
443
2/2
✓ Branch 1 taken 1483 times.
✓ Branch 2 taken 4044 times.
5527 if ((ret = ff_inlink_consume_frame(ctx->inputs[i], &buf)) > 0) {
444
2/2
✓ Branch 0 taken 874 times.
✓ Branch 1 taken 609 times.
1483 if (i == 0) {
445 874 int64_t pts = av_rescale_q(buf->pts, inlink->time_base,
446 outlink->time_base);
447 874 ret = frame_list_add_frame(s->frame_list, buf->nb_samples, pts);
448
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 874 times.
874 if (ret < 0) {
449 av_frame_free(&buf);
450 return ret;
451 }
452 }
453
454 1483 ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,
455 1483 buf->nb_samples);
456
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1483 times.
1483 if (ret < 0) {
457 av_frame_free(&buf);
458 return ret;
459 }
460
461 1483 av_frame_free(&buf);
462
463 1483 ret = output_frame(outlink);
464
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1483 times.
1483 if (ret < 0)
465 return ret;
466 }
467 }
468
469
2/2
✓ Branch 0 taken 5527 times.
✓ Branch 1 taken 2372 times.
7899 for (i = 0; i < s->nb_inputs; i++) {
470 int64_t pts;
471 int status;
472
473
2/2
✓ Branch 1 taken 1163 times.
✓ Branch 2 taken 4364 times.
5527 if (ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts)) {
474
1/2
✓ Branch 0 taken 1163 times.
✗ Branch 1 not taken.
1163 if (status == AVERROR_EOF) {
475
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1157 times.
1163 if (i == 0) {
476 6 s->input_state[i] = 0;
477
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (s->nb_inputs == 1) {
478 ff_outlink_set_status(outlink, status, pts);
479 return 0;
480 }
481 } else {
482 1157 s->input_state[i] |= INPUT_EOF;
483
2/2
✓ Branch 1 taken 1151 times.
✓ Branch 2 taken 6 times.
1157 if (av_audio_fifo_size(s->fifos[i]) == 0) {
484 1151 s->input_state[i] = 0;
485 }
486 }
487 }
488 }
489 }
490
491
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 2366 times.
2372 if (calc_active_inputs(s)) {
492 6 ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
493 6 return 0;
494 }
495
496
2/2
✓ Branch 1 taken 1488 times.
✓ Branch 2 taken 878 times.
2366 if (ff_outlink_frame_wanted(outlink)) {
497 int wanted_samples;
498
499
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1488 times.
1488 if (!(s->input_state[0] & INPUT_ON))
500 return request_samples(ctx, 1);
501
502
2/2
✓ Branch 0 taken 871 times.
✓ Branch 1 taken 617 times.
1488 if (s->frame_list->nb_frames == 0) {
503 871 ff_inlink_request_frame(ctx->inputs[0]);
504 871 return 0;
505 }
506
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
617 av_assert0(s->frame_list->nb_frames > 0);
507
508 617 wanted_samples = frame_list_next_frame_size(s->frame_list);
509
510 617 return request_samples(ctx, wanted_samples);
511 }
512
513 878 return 0;
514 }
515
516 12 static void parse_weights(AVFilterContext *ctx)
517 {
518 12 MixContext *s = ctx->priv;
519 12 float last_weight = 1.f;
520 char *p;
521 int i;
522
523 12 s->weight_sum = 0.f;
524 12 p = s->weights_str;
525
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
24 for (i = 0; i < s->nb_inputs; i++) {
526 24 last_weight = av_strtod(p, &p);
527 24 s->weights[i] = last_weight;
528 24 s->weight_sum += FFABS(last_weight);
529
3/4
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 12 times.
24 if (p && *p) {
530 12 p++;
531 } else {
532 12 i++;
533 12 break;
534 }
535 }
536
537
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12 times.
14 for (; i < s->nb_inputs; i++) {
538 2 s->weights[i] = last_weight;
539 2 s->weight_sum += FFABS(last_weight);
540 }
541 12 }
542
543 12 static av_cold int init(AVFilterContext *ctx)
544 {
545 12 MixContext *s = ctx->priv;
546 int i, ret;
547
548
2/2
✓ Branch 0 taken 26 times.
✓ Branch 1 taken 12 times.
38 for (i = 0; i < s->nb_inputs; i++) {
549 26 AVFilterPad pad = { 0 };
550
551 26 pad.type = AVMEDIA_TYPE_AUDIO;
552 26 pad.name = av_asprintf("input%d", i);
553
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
26 if (!pad.name)
554 return AVERROR(ENOMEM);
555
556
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 26 times.
26 if ((ret = ff_append_inpad_free_name(ctx, &pad)) < 0)
557 return ret;
558 }
559
560 12 s->fdsp = avpriv_float_dsp_alloc(0);
561
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
12 if (!s->fdsp)
562 return AVERROR(ENOMEM);
563
564 12 s->weights = av_calloc(s->nb_inputs, sizeof(*s->weights));
565
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
12 if (!s->weights)
566 return AVERROR(ENOMEM);
567
568 12 parse_weights(ctx);
569
570 12 return 0;
571 }
572
573 12 static av_cold void uninit(AVFilterContext *ctx)
574 {
575 int i;
576 12 MixContext *s = ctx->priv;
577
578
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
12 if (s->fifos) {
579
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 6 times.
19 for (i = 0; i < s->nb_inputs; i++)
580 13 av_audio_fifo_free(s->fifos[i]);
581 6 av_freep(&s->fifos);
582 }
583 12 frame_list_clear(s->frame_list);
584 12 av_freep(&s->frame_list);
585 12 av_freep(&s->input_state);
586 12 av_freep(&s->input_scale);
587 12 av_freep(&s->scale_norm);
588 12 av_freep(&s->weights);
589 12 av_freep(&s->fdsp);
590 12 }
591
592 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
593 char *res, int res_len, int flags)
594 {
595 MixContext *s = ctx->priv;
596 int ret;
597
598 ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
599 if (ret < 0)
600 return ret;
601
602 parse_weights(ctx);
603 for (int i = 0; i < s->nb_inputs; i++)
604 s->scale_norm[i] = s->weight_sum / FFABS(s->weights[i]);
605 calculate_scales(s, 0);
606
607 return 0;
608 }
609
610 static const AVFilterPad avfilter_af_amix_outputs[] = {
611 {
612 .name = "default",
613 .type = AVMEDIA_TYPE_AUDIO,
614 .config_props = config_output,
615 },
616 };
617
618 const AVFilter ff_af_amix = {
619 .name = "amix",
620 .description = NULL_IF_CONFIG_SMALL("Audio mixing."),
621 .priv_size = sizeof(MixContext),
622 .priv_class = &amix_class,
623 .init = init,
624 .uninit = uninit,
625 .activate = activate,
626 .inputs = NULL,
627 FILTER_OUTPUTS(avfilter_af_amix_outputs),
628 FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
629 AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP),
630 .process_command = process_command,
631 .flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
632 };
633