libavfilter/ebur128: add target value to statistics line
[ffmpeg.git] / libavfilter / af_mcompand.c
1 /*
2  * COpyright (c) 2002 Daniel Pouzzner
3  * Copyright (c) 1999 Chris Bagwell
4  * Copyright (c) 1999 Nick Bailey
5  * Copyright (c) 2007 Rob Sykes <robs@users.sourceforge.net>
6  * Copyright (c) 2013 Paul B Mahol
7  * Copyright (c) 2014 Andrew Kelley
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25
26 /**
27  * @file
28  * audio multiband compand filter
29  */
30
31 #include "libavutil/avassert.h"
32 #include "libavutil/avstring.h"
33 #include "libavutil/ffmath.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/samplefmt.h"
36 #include "audio.h"
37 #include "avfilter.h"
38 #include "internal.h"
39
40 typedef struct CompandSegment {
41     double x, y;
42     double a, b;
43 } CompandSegment;
44
45 typedef struct CompandT {
46     CompandSegment *segments;
47     int nb_segments;
48     double in_min_lin;
49     double out_min_lin;
50     double curve_dB;
51     double gain_dB;
52 } CompandT;
53
54 #define N 4
55
56 typedef struct PrevCrossover {
57     double in;
58     double out_low;
59     double out_high;
60 } PrevCrossover[N * 2];
61
62 typedef struct Crossover {
63   PrevCrossover *previous;
64   size_t         pos;
65   double         coefs[3 *(N+1)];
66 } Crossover;
67
68 typedef struct CompBand {
69     CompandT transfer_fn;
70     double *attack_rate;
71     double *decay_rate;
72     double *volume;
73     double delay;
74     double topfreq;
75     Crossover filter;
76     AVFrame *delay_buf;
77     size_t delay_size;
78     ptrdiff_t delay_buf_ptr;
79     size_t delay_buf_cnt;
80 } CompBand;
81
82 typedef struct MCompandContext {
83     const AVClass *class;
84
85     char *args;
86
87     int nb_bands;
88     CompBand *bands;
89     AVFrame *band_buf1, *band_buf2, *band_buf3;
90     int band_samples;
91     size_t delay_buf_size;
92 } MCompandContext;
93
94 #define OFFSET(x) offsetof(MCompandContext, x)
95 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
96
97 static const AVOption mcompand_options[] = {
98     { "args", "set parameters for each band", OFFSET(args), AV_OPT_TYPE_STRING, { .str = "0.005,0.1 6 -47/-40,-34/-34,-17/-33 100 | 0.003,0.05 6 -47/-40,-34/-34,-17/-33 400 | 0.000625,0.0125 6 -47/-40,-34/-34,-15/-33 1600 | 0.0001,0.025 6 -47/-40,-34/-34,-31/-31,-0/-30 6400 | 0,0.025 6 -38/-31,-28/-28,-0/-25 22000" }, 0, 0, A },
99     { NULL }
100 };
101
102 AVFILTER_DEFINE_CLASS(mcompand);
103
104 static av_cold void uninit(AVFilterContext *ctx)
105 {
106     MCompandContext *s = ctx->priv;
107     int i;
108
109     av_frame_free(&s->band_buf1);
110     av_frame_free(&s->band_buf2);
111     av_frame_free(&s->band_buf3);
112
113     if (s->bands) {
114         for (i = 0; i < s->nb_bands; i++) {
115             av_freep(&s->bands[i].attack_rate);
116             av_freep(&s->bands[i].decay_rate);
117             av_freep(&s->bands[i].volume);
118             av_freep(&s->bands[i].transfer_fn.segments);
119             av_freep(&s->bands[i].filter.previous);
120             av_frame_free(&s->bands[i].delay_buf);
121         }
122     }
123     av_freep(&s->bands);
124 }
125
126 static int query_formats(AVFilterContext *ctx)
127 {
128     AVFilterChannelLayouts *layouts;
129     AVFilterFormats *formats;
130     static const enum AVSampleFormat sample_fmts[] = {
131         AV_SAMPLE_FMT_DBLP,
132         AV_SAMPLE_FMT_NONE
133     };
134     int ret;
135
136     layouts = ff_all_channel_counts();
137     if (!layouts)
138         return AVERROR(ENOMEM);
139     ret = ff_set_common_channel_layouts(ctx, layouts);
140     if (ret < 0)
141         return ret;
142
143     formats = ff_make_format_list(sample_fmts);
144     if (!formats)
145         return AVERROR(ENOMEM);
146     ret = ff_set_common_formats(ctx, formats);
147     if (ret < 0)
148         return ret;
149
150     formats = ff_all_samplerates();
151     if (!formats)
152         return AVERROR(ENOMEM);
153     return ff_set_common_samplerates(ctx, formats);
154 }
155
156 static void count_items(char *item_str, int *nb_items, char delimiter)
157 {
158     char *p;
159
160     *nb_items = 1;
161     for (p = item_str; *p; p++) {
162         if (*p == delimiter)
163             (*nb_items)++;
164     }
165 }
166
167 static void update_volume(CompBand *cb, double in, int ch)
168 {
169     double delta = in - cb->volume[ch];
170
171     if (delta > 0.0)
172         cb->volume[ch] += delta * cb->attack_rate[ch];
173     else
174         cb->volume[ch] += delta * cb->decay_rate[ch];
175 }
176
177 static double get_volume(CompandT *s, double in_lin)
178 {
179     CompandSegment *cs;
180     double in_log, out_log;
181     int i;
182
183     if (in_lin <= s->in_min_lin)
184         return s->out_min_lin;
185
186     in_log = log(in_lin);
187
188     for (i = 1; i < s->nb_segments; i++)
189         if (in_log <= s->segments[i].x)
190             break;
191     cs = &s->segments[i - 1];
192     in_log -= cs->x;
193     out_log = cs->y + in_log * (cs->a * in_log + cs->b);
194
195     return exp(out_log);
196 }
197
198 static int parse_points(char *points, int nb_points, double radius,
199                         CompandT *s, AVFilterContext *ctx)
200 {
201     int new_nb_items, num;
202     char *saveptr = NULL;
203     char *p = points;
204     int i;
205
206 #define S(x) s->segments[2 * ((x) + 1)]
207     for (i = 0, new_nb_items = 0; i < nb_points; i++) {
208         char *tstr = av_strtok(p, ",", &saveptr);
209         p = NULL;
210         if (!tstr || sscanf(tstr, "%lf/%lf", &S(i).x, &S(i).y) != 2) {
211             av_log(ctx, AV_LOG_ERROR,
212                     "Invalid and/or missing input/output value.\n");
213             return AVERROR(EINVAL);
214         }
215         if (i && S(i - 1).x > S(i).x) {
216             av_log(ctx, AV_LOG_ERROR,
217                     "Transfer function input values must be increasing.\n");
218             return AVERROR(EINVAL);
219         }
220         S(i).y -= S(i).x;
221         av_log(ctx, AV_LOG_DEBUG, "%d: x=%f y=%f\n", i, S(i).x, S(i).y);
222         new_nb_items++;
223     }
224     num = new_nb_items;
225
226     /* Add 0,0 if necessary */
227     if (num == 0 || S(num - 1).x)
228         num++;
229
230 #undef S
231 #define S(x) s->segments[2 * (x)]
232     /* Add a tail off segment at the start */
233     S(0).x = S(1).x - 2 * s->curve_dB;
234     S(0).y = S(1).y;
235     num++;
236
237     /* Join adjacent colinear segments */
238     for (i = 2; i < num; i++) {
239         double g1 = (S(i - 1).y - S(i - 2).y) * (S(i - 0).x - S(i - 1).x);
240         double g2 = (S(i - 0).y - S(i - 1).y) * (S(i - 1).x - S(i - 2).x);
241         int j;
242
243         if (fabs(g1 - g2))
244             continue;
245         num--;
246         for (j = --i; j < num; j++)
247             S(j) = S(j + 1);
248     }
249
250     for (i = 0; i < s->nb_segments; i += 2) {
251         s->segments[i].y += s->gain_dB;
252         s->segments[i].x *= M_LN10 / 20;
253         s->segments[i].y *= M_LN10 / 20;
254     }
255
256 #define L(x) s->segments[i - (x)]
257     for (i = 4; i < s->nb_segments; i += 2) {
258         double x, y, cx, cy, in1, in2, out1, out2, theta, len, r;
259
260         L(4).a = 0;
261         L(4).b = (L(2).y - L(4).y) / (L(2).x - L(4).x);
262
263         L(2).a = 0;
264         L(2).b = (L(0).y - L(2).y) / (L(0).x - L(2).x);
265
266         theta = atan2(L(2).y - L(4).y, L(2).x - L(4).x);
267         len = hypot(L(2).x - L(4).x, L(2).y - L(4).y);
268         r = FFMIN(radius, len);
269         L(3).x = L(2).x - r * cos(theta);
270         L(3).y = L(2).y - r * sin(theta);
271
272         theta = atan2(L(0).y - L(2).y, L(0).x - L(2).x);
273         len = hypot(L(0).x - L(2).x, L(0).y - L(2).y);
274         r = FFMIN(radius, len / 2);
275         x = L(2).x + r * cos(theta);
276         y = L(2).y + r * sin(theta);
277
278         cx = (L(3).x + L(2).x + x) / 3;
279         cy = (L(3).y + L(2).y + y) / 3;
280
281         L(2).x = x;
282         L(2).y = y;
283
284         in1  = cx - L(3).x;
285         out1 = cy - L(3).y;
286         in2  = L(2).x - L(3).x;
287         out2 = L(2).y - L(3).y;
288         L(3).a = (out2 / in2 - out1 / in1) / (in2 - in1);
289         L(3).b = out1 / in1 - L(3).a * in1;
290     }
291     L(3).x = 0;
292     L(3).y = L(2).y;
293
294     s->in_min_lin  = exp(s->segments[1].x);
295     s->out_min_lin = exp(s->segments[1].y);
296
297     return 0;
298 }
299
300 static void square_quadratic(double const *x, double *y)
301 {
302     y[0] = x[0] * x[0];
303     y[1] = 2 * x[0] * x[1];
304     y[2] = 2 * x[0] * x[2] + x[1] * x[1];
305     y[3] = 2 * x[1] * x[2];
306     y[4] = x[2] * x[2];
307 }
308
309 static int crossover_setup(AVFilterLink *outlink, Crossover *p, double frequency)
310 {
311     double w0 = 2 * M_PI * frequency / outlink->sample_rate;
312     double Q = sqrt(.5), alpha = sin(w0) / (2*Q);
313     double x[9], norm;
314     int i;
315
316     if (w0 > M_PI)
317         return AVERROR(EINVAL);
318
319     x[0] =  (1 - cos(w0))/2;           /* Cf. filter_LPF in biquads.c */
320     x[1] =   1 - cos(w0);
321     x[2] =  (1 - cos(w0))/2;
322     x[3] =  (1 + cos(w0))/2;           /* Cf. filter_HPF in biquads.c */
323     x[4] = -(1 + cos(w0));
324     x[5] =  (1 + cos(w0))/2;
325     x[6] =   1 + alpha;
326     x[7] =  -2*cos(w0);
327     x[8] =   1 - alpha;
328
329     for (norm = x[6], i = 0; i < 9; ++i)
330         x[i] /= norm;
331
332     square_quadratic(x    , p->coefs);
333     square_quadratic(x + 3, p->coefs + 5);
334     square_quadratic(x + 6, p->coefs + 10);
335
336     p->previous = av_calloc(outlink->channels, sizeof(*p->previous));
337     if (!p->previous)
338         return AVERROR(ENOMEM);
339
340     return 0;
341 }
342
343 static int config_output(AVFilterLink *outlink)
344 {
345     AVFilterContext *ctx  = outlink->src;
346     MCompandContext *s    = ctx->priv;
347     int ret, ch, i, k, new_nb_items, nb_bands;
348     char *p = s->args, *saveptr = NULL;
349     int max_delay_size = 0;
350
351     count_items(s->args, &nb_bands, '|');
352     s->nb_bands = FFMAX(1, nb_bands);
353
354     s->bands = av_calloc(nb_bands, sizeof(*s->bands));
355     if (!s->bands)
356         return AVERROR(ENOMEM);
357
358     for (i = 0, new_nb_items = 0; i < nb_bands; i++) {
359         int nb_points, nb_attacks, nb_items = 0;
360         char *tstr2, *tstr = av_strtok(p, "|", &saveptr);
361         char *p2, *p3, *saveptr2 = NULL, *saveptr3 = NULL;
362         double radius;
363
364         if (!tstr) {
365             uninit(ctx);
366             return AVERROR(EINVAL);
367         }
368         p = NULL;
369
370         p2 = tstr;
371         count_items(tstr, &nb_items, ' ');
372         tstr2 = av_strtok(p2, " ", &saveptr2);
373         if (!tstr2) {
374             av_log(ctx, AV_LOG_ERROR, "at least one attacks/decays rate is mandatory\n");
375             uninit(ctx);
376             return AVERROR(EINVAL);
377         }
378         p2 = NULL;
379         p3 = tstr2;
380
381         count_items(tstr2, &nb_attacks, ',');
382         if (!nb_attacks || nb_attacks & 1) {
383             av_log(ctx, AV_LOG_ERROR, "number of attacks rate plus decays rate must be even\n");
384             uninit(ctx);
385             return AVERROR(EINVAL);
386         }
387
388         s->bands[i].attack_rate = av_calloc(outlink->channels, sizeof(double));
389         s->bands[i].decay_rate = av_calloc(outlink->channels, sizeof(double));
390         s->bands[i].volume = av_calloc(outlink->channels, sizeof(double));
391         for (k = 0; k < FFMIN(nb_attacks / 2, outlink->channels); k++) {
392             char *tstr3 = av_strtok(p3, ",", &saveptr3);
393
394             p3 = NULL;
395             sscanf(tstr3, "%lf", &s->bands[i].attack_rate[k]);
396             tstr3 = av_strtok(p3, ",", &saveptr3);
397             sscanf(tstr3, "%lf", &s->bands[i].decay_rate[k]);
398
399             if (s->bands[i].attack_rate[k] > 1.0 / outlink->sample_rate) {
400                 s->bands[i].attack_rate[k] = 1.0 - exp(-1.0 / (outlink->sample_rate * s->bands[i].attack_rate[k]));
401             } else {
402                 s->bands[i].attack_rate[k] = 1.0;
403             }
404
405             if (s->bands[i].decay_rate[k] > 1.0 / outlink->sample_rate) {
406                 s->bands[i].decay_rate[k] = 1.0 - exp(-1.0 / (outlink->sample_rate * s->bands[i].decay_rate[k]));
407             } else {
408                 s->bands[i].decay_rate[k] = 1.0;
409             }
410         }
411
412         for (ch = k; ch < outlink->channels; ch++) {
413             s->bands[i].attack_rate[ch] = s->bands[i].attack_rate[k - 1];
414             s->bands[i].decay_rate[ch]  = s->bands[i].decay_rate[k - 1];
415         }
416
417         tstr2 = av_strtok(p2, " ", &saveptr2);
418         if (!tstr2) {
419             av_log(ctx, AV_LOG_ERROR, "transfer function curve in dB must be set\n");
420             uninit(ctx);
421             return AVERROR(EINVAL);
422         }
423         sscanf(tstr2, "%lf", &s->bands[i].transfer_fn.curve_dB);
424
425         radius = s->bands[i].transfer_fn.curve_dB * M_LN10 / 20.0;
426
427         tstr2 = av_strtok(p2, " ", &saveptr2);
428         if (!tstr2) {
429             av_log(ctx, AV_LOG_ERROR, "transfer points missing\n");
430             uninit(ctx);
431             return AVERROR(EINVAL);
432         }
433
434         count_items(tstr2, &nb_points, ',');
435         s->bands[i].transfer_fn.nb_segments = (nb_points + 4) * 2;
436         s->bands[i].transfer_fn.segments = av_calloc(s->bands[i].transfer_fn.nb_segments,
437                                                      sizeof(CompandSegment));
438         if (!s->bands[i].transfer_fn.segments) {
439             uninit(ctx);
440             return AVERROR(ENOMEM);
441         }
442
443         ret = parse_points(tstr2, nb_points, radius, &s->bands[i].transfer_fn, ctx);
444         if (ret < 0) {
445             av_log(ctx, AV_LOG_ERROR, "transfer points parsing failed\n");
446             uninit(ctx);
447             return ret;
448         }
449
450         tstr2 = av_strtok(p2, " ", &saveptr2);
451         if (!tstr2) {
452             av_log(ctx, AV_LOG_ERROR, "crossover_frequency is missing\n");
453             uninit(ctx);
454             return AVERROR(EINVAL);
455         }
456
457         new_nb_items += sscanf(tstr2, "%lf", &s->bands[i].topfreq) == 1;
458         if (s->bands[i].topfreq < 0 || s->bands[i].topfreq >= outlink->sample_rate / 2) {
459             av_log(ctx, AV_LOG_ERROR, "crossover_frequency: %f, should be >=0 and lower than half of sample rate: %d.\n", s->bands[i].topfreq, outlink->sample_rate / 2);
460             uninit(ctx);
461             return AVERROR(EINVAL);
462         }
463
464         if (s->bands[i].topfreq != 0) {
465             ret = crossover_setup(outlink, &s->bands[i].filter, s->bands[i].topfreq);
466             if (ret < 0) {
467                 uninit(ctx);
468                 return ret;
469             }
470         }
471
472         tstr2 = av_strtok(p2, " ", &saveptr2);
473         if (tstr2) {
474             sscanf(tstr2, "%lf", &s->bands[i].delay);
475             max_delay_size = FFMAX(max_delay_size, s->bands[i].delay * outlink->sample_rate);
476
477             tstr2 = av_strtok(p2, " ", &saveptr2);
478             if (tstr2) {
479                 double initial_volume;
480
481                 sscanf(tstr2, "%lf", &initial_volume);
482                 initial_volume = pow(10.0, initial_volume / 20);
483
484                 for (k = 0; k < outlink->channels; k++) {
485                     s->bands[i].volume[k] = initial_volume;
486                 }
487
488                 tstr2 = av_strtok(p2, " ", &saveptr2);
489                 if (tstr2) {
490                     sscanf(tstr2, "%lf", &s->bands[i].transfer_fn.gain_dB);
491                 }
492             }
493         }
494     }
495     s->nb_bands = new_nb_items;
496
497     for (i = 0; max_delay_size > 0 && i < s->nb_bands; i++) {
498         s->bands[i].delay_buf = ff_get_audio_buffer(outlink, max_delay_size);
499         if (!s->bands[i].delay_buf)
500             return AVERROR(ENOMEM);
501     }
502     s->delay_buf_size = max_delay_size;
503
504     return 0;
505 }
506
507 #define CONVOLVE _ _ _ _
508
509 static void crossover(int ch, Crossover *p,
510                       double *ibuf, double *obuf_low,
511                       double *obuf_high, size_t len)
512 {
513     double out_low, out_high;
514
515     while (len--) {
516         p->pos = p->pos ? p->pos - 1 : N - 1;
517 #define _ out_low += p->coefs[j] * p->previous[ch][p->pos + j].in \
518             - p->coefs[2*N+2 + j] * p->previous[ch][p->pos + j].out_low, j++;
519         {
520             int j = 1;
521             out_low = p->coefs[0] * *ibuf;
522             CONVOLVE
523             *obuf_low++ = out_low;
524         }
525 #undef _
526 #define _ out_high += p->coefs[j+N+1] * p->previous[ch][p->pos + j].in \
527             - p->coefs[2*N+2 + j] * p->previous[ch][p->pos + j].out_high, j++;
528         {
529             int j = 1;
530             out_high = p->coefs[N+1] * *ibuf;
531             CONVOLVE
532             *obuf_high++ = out_high;
533         }
534         p->previous[ch][p->pos + N].in = p->previous[ch][p->pos].in = *ibuf++;
535         p->previous[ch][p->pos + N].out_low = p->previous[ch][p->pos].out_low = out_low;
536         p->previous[ch][p->pos + N].out_high = p->previous[ch][p->pos].out_high = out_high;
537     }
538 }
539
540 static int mcompand_channel(MCompandContext *c, CompBand *l, double *ibuf, double *obuf, int len, int ch)
541 {
542     int i;
543
544     for (i = 0; i < len; i++) {
545         double level_in_lin, level_out_lin, checkbuf;
546         /* Maintain the volume fields by simulating a leaky pump circuit */
547         update_volume(l, fabs(ibuf[i]), ch);
548
549         /* Volume memory is updated: perform compand */
550         level_in_lin = l->volume[ch];
551         level_out_lin = get_volume(&l->transfer_fn, level_in_lin);
552
553         if (c->delay_buf_size <= 0) {
554             checkbuf = ibuf[i] * level_out_lin;
555             obuf[i] = checkbuf;
556         } else {
557             double *delay_buf = (double *)l->delay_buf->extended_data[ch];
558
559             /* FIXME: note that this lookahead algorithm is really lame:
560                the response to a peak is released before the peak
561                arrives. */
562
563             /* because volume application delays differ band to band, but
564                total delay doesn't, the volume is applied in an iteration
565                preceding that in which the sample goes to obuf, except in
566                the band(s) with the longest vol app delay.
567
568                the offset between delay_buf_ptr and the sample to apply
569                vol to, is a constant equal to the difference between this
570                band's delay and the longest delay of all the bands. */
571
572             if (l->delay_buf_cnt >= l->delay_size) {
573                 checkbuf =
574                     delay_buf[(l->delay_buf_ptr +
575                                c->delay_buf_size -
576                                l->delay_size) % c->delay_buf_size] * level_out_lin;
577                 delay_buf[(l->delay_buf_ptr + c->delay_buf_size -
578                            l->delay_size) % c->delay_buf_size] = checkbuf;
579             }
580             if (l->delay_buf_cnt >= c->delay_buf_size) {
581                 obuf[i] = delay_buf[l->delay_buf_ptr];
582             } else {
583                 l->delay_buf_cnt++;
584             }
585             delay_buf[l->delay_buf_ptr++] = ibuf[i];
586             l->delay_buf_ptr %= c->delay_buf_size;
587         }
588     }
589
590     return 0;
591 }
592
593 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
594 {
595     AVFilterContext  *ctx = inlink->dst;
596     AVFilterLink *outlink = ctx->outputs[0];
597     MCompandContext *s    = ctx->priv;
598     AVFrame *out, *abuf, *bbuf, *cbuf;
599     int ch, band, i;
600
601     out = ff_get_audio_buffer(outlink, in->nb_samples);
602     if (!out) {
603         av_frame_free(&in);
604         return AVERROR(ENOMEM);
605     }
606
607     if (s->band_samples < in->nb_samples) {
608         av_frame_free(&s->band_buf1);
609         av_frame_free(&s->band_buf2);
610         av_frame_free(&s->band_buf3);
611
612         s->band_buf1 = ff_get_audio_buffer(outlink, in->nb_samples);
613         s->band_buf2 = ff_get_audio_buffer(outlink, in->nb_samples);
614         s->band_buf3 = ff_get_audio_buffer(outlink, in->nb_samples);
615         s->band_samples = in->nb_samples;
616     }
617
618     for (ch = 0; ch < outlink->channels; ch++) {
619         double *a, *dst = (double *)out->extended_data[ch];
620
621         for (band = 0, abuf = in, bbuf = s->band_buf2, cbuf = s->band_buf1; band < s->nb_bands; band++) {
622             CompBand *b = &s->bands[band];
623
624             if (b->topfreq) {
625                 crossover(ch, &b->filter, (double *)abuf->extended_data[ch],
626                           (double *)bbuf->extended_data[ch], (double *)cbuf->extended_data[ch], in->nb_samples);
627             } else {
628                 bbuf = abuf;
629                 abuf = cbuf;
630             }
631
632             if (abuf == in)
633                 abuf = s->band_buf3;
634             mcompand_channel(s, b, (double *)bbuf->extended_data[ch], (double *)abuf->extended_data[ch], out->nb_samples, ch);
635             a = (double *)abuf->extended_data[ch];
636             for (i = 0; i < out->nb_samples; i++) {
637                 dst[i] += a[i];
638             }
639
640             FFSWAP(AVFrame *, abuf, cbuf);
641         }
642     }
643
644     out->pts = in->pts;
645     av_frame_free(&in);
646     return ff_filter_frame(outlink, out);
647 }
648
649 static int request_frame(AVFilterLink *outlink)
650 {
651     AVFilterContext *ctx = outlink->src;
652     int ret;
653
654     ret = ff_request_frame(ctx->inputs[0]);
655
656     return ret;
657 }
658
659 static const AVFilterPad mcompand_inputs[] = {
660     {
661         .name           = "default",
662         .type           = AVMEDIA_TYPE_AUDIO,
663         .filter_frame   = filter_frame,
664     },
665     { NULL }
666 };
667
668 static const AVFilterPad mcompand_outputs[] = {
669     {
670         .name          = "default",
671         .type          = AVMEDIA_TYPE_AUDIO,
672         .request_frame = request_frame,
673         .config_props  = config_output,
674     },
675     { NULL }
676 };
677
678
679 AVFilter ff_af_mcompand = {
680     .name           = "mcompand",
681     .description    = NULL_IF_CONFIG_SMALL(
682             "Multiband Compress or expand audio dynamic range."),
683     .query_formats  = query_formats,
684     .priv_size      = sizeof(MCompandContext),
685     .priv_class     = &mcompand_class,
686     .uninit         = uninit,
687     .inputs         = mcompand_inputs,
688     .outputs        = mcompand_outputs,
689 };