FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavfilter/af_mcompand.c	Lines:	0	327	0.0 %
Date:	2020-08-14 10:39:37	Branches:	0	140	0.0 %


/*
 * COpyright (c) 2002 Daniel Pouzzner
 * Copyright (c) 1999 Chris Bagwell
 * Copyright (c) 1999 Nick Bailey
 * Copyright (c) 2007 Rob Sykes <robs@users.sourceforge.net>
 * Copyright (c) 2013 Paul B Mahol
 * Copyright (c) 2014 Andrew Kelley
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * audio multiband compand filter
 */

#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/ffmath.h"
#include "libavutil/opt.h"
#include "libavutil/samplefmt.h"
#include "audio.h"
#include "avfilter.h"
#include "internal.h"

typedef struct CompandSegment {
    double x, y;
    double a, b;
} CompandSegment;

typedef struct CompandT {
    CompandSegment *segments;
    int nb_segments;
    double in_min_lin;
    double out_min_lin;
    double curve_dB;
    double gain_dB;
} CompandT;

#define N 4

typedef struct PrevCrossover {
    double in;
    double out_low;
    double out_high;
} PrevCrossover[N * 2];

typedef struct Crossover {
  PrevCrossover *previous;
  size_t         pos;
  double         coefs[3 *(N+1)];
} Crossover;

typedef struct CompBand {
    CompandT transfer_fn;
    double *attack_rate;
    double *decay_rate;
    double *volume;
    double delay;
    double topfreq;
    Crossover filter;
    AVFrame *delay_buf;
    size_t delay_size;
    ptrdiff_t delay_buf_ptr;
    size_t delay_buf_cnt;
} CompBand;

typedef struct MCompandContext {
    const AVClass *class;

    char *args;

    int nb_bands;
    CompBand *bands;
    AVFrame *band_buf1, *band_buf2, *band_buf3;
    int band_samples;
    size_t delay_buf_size;
} MCompandContext;

#define OFFSET(x) offsetof(MCompandContext, x)
#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

static const AVOption mcompand_options[] = {
    { "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 },
    { NULL }
};

AVFILTER_DEFINE_CLASS(mcompand);

static av_cold void uninit(AVFilterContext *ctx)
{
    MCompandContext *s = ctx->priv;
    int i;

    av_frame_free(&s->band_buf1);
    av_frame_free(&s->band_buf2);
    av_frame_free(&s->band_buf3);

    if (s->bands) {
        for (i = 0; i < s->nb_bands; i++) {
            av_freep(&s->bands[i].attack_rate);
            av_freep(&s->bands[i].decay_rate);
            av_freep(&s->bands[i].volume);
            av_freep(&s->bands[i].transfer_fn.segments);
            av_freep(&s->bands[i].filter.previous);
            av_frame_free(&s->bands[i].delay_buf);
        }
    }
    av_freep(&s->bands);
}

static int query_formats(AVFilterContext *ctx)
{
    AVFilterChannelLayouts *layouts;
    AVFilterFormats *formats;
    static const enum AVSampleFormat sample_fmts[] = {
        AV_SAMPLE_FMT_DBLP,
        AV_SAMPLE_FMT_NONE
    };
    int ret;

    layouts = ff_all_channel_counts();
    if (!layouts)
        return AVERROR(ENOMEM);
    ret = ff_set_common_channel_layouts(ctx, layouts);
    if (ret < 0)
        return ret;

    formats = ff_make_format_list(sample_fmts);
    if (!formats)
        return AVERROR(ENOMEM);
    ret = ff_set_common_formats(ctx, formats);
    if (ret < 0)
        return ret;

    formats = ff_all_samplerates();
    if (!formats)
        return AVERROR(ENOMEM);
    return ff_set_common_samplerates(ctx, formats);
}

static void count_items(char *item_str, int *nb_items, char delimiter)
{
    char *p;

    *nb_items = 1;
    for (p = item_str; *p; p++) {
        if (*p == delimiter)
            (*nb_items)++;
    }
}

static void update_volume(CompBand *cb, double in, int ch)
{
    double delta = in - cb->volume[ch];

    if (delta > 0.0)
        cb->volume[ch] += delta * cb->attack_rate[ch];
    else
        cb->volume[ch] += delta * cb->decay_rate[ch];
}

static double get_volume(CompandT *s, double in_lin)
{
    CompandSegment *cs;
    double in_log, out_log;
    int i;

    if (in_lin <= s->in_min_lin)
        return s->out_min_lin;

    in_log = log(in_lin);

    for (i = 1; i < s->nb_segments; i++)
        if (in_log <= s->segments[i].x)
            break;
    cs = &s->segments[i - 1];
    in_log -= cs->x;
    out_log = cs->y + in_log * (cs->a * in_log + cs->b);

    return exp(out_log);
}

static int parse_points(char *points, int nb_points, double radius,
                        CompandT *s, AVFilterContext *ctx)
{
    int new_nb_items, num;
    char *saveptr = NULL;
    char *p = points;
    int i;

#define S(x) s->segments[2 * ((x) + 1)]
    for (i = 0, new_nb_items = 0; i < nb_points; i++) {
        char *tstr = av_strtok(p, ",", &saveptr);
        p = NULL;
        if (!tstr || sscanf(tstr, "%lf/%lf", &S(i).x, &S(i).y) != 2) {
            av_log(ctx, AV_LOG_ERROR,
                    "Invalid and/or missing input/output value.\n");
            return AVERROR(EINVAL);
        }
        if (i && S(i - 1).x > S(i).x) {
            av_log(ctx, AV_LOG_ERROR,
                    "Transfer function input values must be increasing.\n");
            return AVERROR(EINVAL);
        }
        S(i).y -= S(i).x;
        av_log(ctx, AV_LOG_DEBUG, "%d: x=%f y=%f\n", i, S(i).x, S(i).y);
        new_nb_items++;
    }
    num = new_nb_items;

    /* Add 0,0 if necessary */
    if (num == 0 || S(num - 1).x)
        num++;

#undef S
#define S(x) s->segments[2 * (x)]
    /* Add a tail off segment at the start */
    S(0).x = S(1).x - 2 * s->curve_dB;
    S(0).y = S(1).y;
    num++;

    /* Join adjacent colinear segments */
    for (i = 2; i < num; i++) {
        double g1 = (S(i - 1).y - S(i - 2).y) * (S(i - 0).x - S(i - 1).x);
        double g2 = (S(i - 0).y - S(i - 1).y) * (S(i - 1).x - S(i - 2).x);
        int j;

        if (fabs(g1 - g2))
            continue;
        num--;
        for (j = --i; j < num; j++)
            S(j) = S(j + 1);
    }

    for (i = 0; i < s->nb_segments; i += 2) {
        s->segments[i].y += s->gain_dB;
        s->segments[i].x *= M_LN10 / 20;
        s->segments[i].y *= M_LN10 / 20;
    }

#define L(x) s->segments[i - (x)]
    for (i = 4; i < s->nb_segments; i += 2) {
        double x, y, cx, cy, in1, in2, out1, out2, theta, len, r;

        L(4).a = 0;
        L(4).b = (L(2).y - L(4).y) / (L(2).x - L(4).x);

        L(2).a = 0;
        L(2).b = (L(0).y - L(2).y) / (L(0).x - L(2).x);

        theta = atan2(L(2).y - L(4).y, L(2).x - L(4).x);
        len = hypot(L(2).x - L(4).x, L(2).y - L(4).y);
        r = FFMIN(radius, len);
        L(3).x = L(2).x - r * cos(theta);
        L(3).y = L(2).y - r * sin(theta);

        theta = atan2(L(0).y - L(2).y, L(0).x - L(2).x);
        len = hypot(L(0).x - L(2).x, L(0).y - L(2).y);
        r = FFMIN(radius, len / 2);
        x = L(2).x + r * cos(theta);
        y = L(2).y + r * sin(theta);

        cx = (L(3).x + L(2).x + x) / 3;
        cy = (L(3).y + L(2).y + y) / 3;

        L(2).x = x;
        L(2).y = y;

        in1  = cx - L(3).x;
        out1 = cy - L(3).y;
        in2  = L(2).x - L(3).x;
        out2 = L(2).y - L(3).y;
        L(3).a = (out2 / in2 - out1 / in1) / (in2 - in1);
        L(3).b = out1 / in1 - L(3).a * in1;
    }
    L(3).x = 0;
    L(3).y = L(2).y;

    s->in_min_lin  = exp(s->segments[1].x);
    s->out_min_lin = exp(s->segments[1].y);

    return 0;
}

static void square_quadratic(double const *x, double *y)
{
    y[0] = x[0] * x[0];
    y[1] = 2 * x[0] * x[1];
    y[2] = 2 * x[0] * x[2] + x[1] * x[1];
    y[3] = 2 * x[1] * x[2];
    y[4] = x[2] * x[2];
}

static int crossover_setup(AVFilterLink *outlink, Crossover *p, double frequency)
{
    double w0 = 2 * M_PI * frequency / outlink->sample_rate;
    double Q = sqrt(.5), alpha = sin(w0) / (2*Q);
    double x[9], norm;
    int i;

    if (w0 > M_PI)
        return AVERROR(EINVAL);

    x[0] =  (1 - cos(w0))/2;           /* Cf. filter_LPF in biquads.c */
    x[1] =   1 - cos(w0);
    x[2] =  (1 - cos(w0))/2;
    x[3] =  (1 + cos(w0))/2;           /* Cf. filter_HPF in biquads.c */
    x[4] = -(1 + cos(w0));
    x[5] =  (1 + cos(w0))/2;
    x[6] =   1 + alpha;
    x[7] =  -2*cos(w0);
    x[8] =   1 - alpha;

    for (norm = x[6], i = 0; i < 9; ++i)
        x[i] /= norm;

    square_quadratic(x    , p->coefs);
    square_quadratic(x + 3, p->coefs + 5);
    square_quadratic(x + 6, p->coefs + 10);

    p->previous = av_calloc(outlink->channels, sizeof(*p->previous));
    if (!p->previous)
        return AVERROR(ENOMEM);

    return 0;
}

static int config_output(AVFilterLink *outlink)
{
    AVFilterContext *ctx  = outlink->src;
    MCompandContext *s    = ctx->priv;
    int ret, ch, i, k, new_nb_items, nb_bands;
    char *p = s->args, *saveptr = NULL;
    int max_delay_size = 0;

    count_items(s->args, &nb_bands, '|');
    s->nb_bands = FFMAX(1, nb_bands);

    s->bands = av_calloc(nb_bands, sizeof(*s->bands));
    if (!s->bands)
        return AVERROR(ENOMEM);

    for (i = 0, new_nb_items = 0; i < nb_bands; i++) {
        int nb_points, nb_attacks, nb_items = 0;
        char *tstr2, *tstr = av_strtok(p, "|", &saveptr);
        char *p2, *p3, *saveptr2 = NULL, *saveptr3 = NULL;
        double radius;

        if (!tstr) {
            uninit(ctx);
            return AVERROR(EINVAL);
        }
        p = NULL;

        p2 = tstr;
        count_items(tstr, &nb_items, ' ');
        tstr2 = av_strtok(p2, " ", &saveptr2);
        if (!tstr2) {
            av_log(ctx, AV_LOG_ERROR, "at least one attacks/decays rate is mandatory\n");
            uninit(ctx);
            return AVERROR(EINVAL);
        }
        p2 = NULL;
        p3 = tstr2;

        count_items(tstr2, &nb_attacks, ',');
        if (!nb_attacks || nb_attacks & 1) {
            av_log(ctx, AV_LOG_ERROR, "number of attacks rate plus decays rate must be even\n");
            uninit(ctx);
            return AVERROR(EINVAL);
        }

        s->bands[i].attack_rate = av_calloc(outlink->channels, sizeof(double));
        s->bands[i].decay_rate = av_calloc(outlink->channels, sizeof(double));
        s->bands[i].volume = av_calloc(outlink->channels, sizeof(double));
        for (k = 0; k < FFMIN(nb_attacks / 2, outlink->channels); k++) {
            char *tstr3 = av_strtok(p3, ",", &saveptr3);

            p3 = NULL;
            sscanf(tstr3, "%lf", &s->bands[i].attack_rate[k]);
            tstr3 = av_strtok(p3, ",", &saveptr3);
            sscanf(tstr3, "%lf", &s->bands[i].decay_rate[k]);

            if (s->bands[i].attack_rate[k] > 1.0 / outlink->sample_rate) {
                s->bands[i].attack_rate[k] = 1.0 - exp(-1.0 / (outlink->sample_rate * s->bands[i].attack_rate[k]));
            } else {
                s->bands[i].attack_rate[k] = 1.0;
            }

            if (s->bands[i].decay_rate[k] > 1.0 / outlink->sample_rate) {
                s->bands[i].decay_rate[k] = 1.0 - exp(-1.0 / (outlink->sample_rate * s->bands[i].decay_rate[k]));
            } else {
                s->bands[i].decay_rate[k] = 1.0;
            }
        }

        for (ch = k; ch < outlink->channels; ch++) {
            s->bands[i].attack_rate[ch] = s->bands[i].attack_rate[k - 1];
            s->bands[i].decay_rate[ch]  = s->bands[i].decay_rate[k - 1];
        }

        tstr2 = av_strtok(p2, " ", &saveptr2);
        if (!tstr2) {
            av_log(ctx, AV_LOG_ERROR, "transfer function curve in dB must be set\n");
            uninit(ctx);
            return AVERROR(EINVAL);
        }
        sscanf(tstr2, "%lf", &s->bands[i].transfer_fn.curve_dB);

        radius = s->bands[i].transfer_fn.curve_dB * M_LN10 / 20.0;

        tstr2 = av_strtok(p2, " ", &saveptr2);
        if (!tstr2) {
            av_log(ctx, AV_LOG_ERROR, "transfer points missing\n");
            uninit(ctx);
            return AVERROR(EINVAL);
        }

        count_items(tstr2, &nb_points, ',');
        s->bands[i].transfer_fn.nb_segments = (nb_points + 4) * 2;
        s->bands[i].transfer_fn.segments = av_calloc(s->bands[i].transfer_fn.nb_segments,
                                                     sizeof(CompandSegment));
        if (!s->bands[i].transfer_fn.segments) {
            uninit(ctx);
            return AVERROR(ENOMEM);
        }

        ret = parse_points(tstr2, nb_points, radius, &s->bands[i].transfer_fn, ctx);
        if (ret < 0) {
            av_log(ctx, AV_LOG_ERROR, "transfer points parsing failed\n");
            uninit(ctx);
            return ret;
        }

        tstr2 = av_strtok(p2, " ", &saveptr2);
        if (!tstr2) {
            av_log(ctx, AV_LOG_ERROR, "crossover_frequency is missing\n");
            uninit(ctx);
            return AVERROR(EINVAL);
        }

        new_nb_items += sscanf(tstr2, "%lf", &s->bands[i].topfreq) == 1;
        if (s->bands[i].topfreq < 0 || s->bands[i].topfreq >= outlink->sample_rate / 2) {
            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);
            uninit(ctx);
            return AVERROR(EINVAL);
        }

        if (s->bands[i].topfreq != 0) {
            ret = crossover_setup(outlink, &s->bands[i].filter, s->bands[i].topfreq);
            if (ret < 0) {
                uninit(ctx);
                return ret;
            }
        }

        tstr2 = av_strtok(p2, " ", &saveptr2);
        if (tstr2) {
            sscanf(tstr2, "%lf", &s->bands[i].delay);
            max_delay_size = FFMAX(max_delay_size, s->bands[i].delay * outlink->sample_rate);

            tstr2 = av_strtok(p2, " ", &saveptr2);
            if (tstr2) {
                double initial_volume;

                sscanf(tstr2, "%lf", &initial_volume);
                initial_volume = pow(10.0, initial_volume / 20);

                for (k = 0; k < outlink->channels; k++) {
                    s->bands[i].volume[k] = initial_volume;
                }

                tstr2 = av_strtok(p2, " ", &saveptr2);
                if (tstr2) {
                    sscanf(tstr2, "%lf", &s->bands[i].transfer_fn.gain_dB);
                }
            }
        }
    }
    s->nb_bands = new_nb_items;

    for (i = 0; max_delay_size > 0 && i < s->nb_bands; i++) {
        s->bands[i].delay_buf = ff_get_audio_buffer(outlink, max_delay_size);
        if (!s->bands[i].delay_buf)
            return AVERROR(ENOMEM);
    }
    s->delay_buf_size = max_delay_size;

    return 0;
}

#define CONVOLVE _ _ _ _

static void crossover(int ch, Crossover *p,
                      double *ibuf, double *obuf_low,
                      double *obuf_high, size_t len)
{
    double out_low, out_high;

    while (len--) {
        p->pos = p->pos ? p->pos - 1 : N - 1;
#define _ out_low += p->coefs[j] * p->previous[ch][p->pos + j].in \
            - p->coefs[2*N+2 + j] * p->previous[ch][p->pos + j].out_low, j++;
        {
            int j = 1;
            out_low = p->coefs[0] * *ibuf;
            CONVOLVE
            *obuf_low++ = out_low;
        }
#undef _
#define _ out_high += p->coefs[j+N+1] * p->previous[ch][p->pos + j].in \
            - p->coefs[2*N+2 + j] * p->previous[ch][p->pos + j].out_high, j++;
        {
            int j = 1;
            out_high = p->coefs[N+1] * *ibuf;
            CONVOLVE
            *obuf_high++ = out_high;
        }
        p->previous[ch][p->pos + N].in = p->previous[ch][p->pos].in = *ibuf++;
        p->previous[ch][p->pos + N].out_low = p->previous[ch][p->pos].out_low = out_low;
        p->previous[ch][p->pos + N].out_high = p->previous[ch][p->pos].out_high = out_high;
    }
}

static int mcompand_channel(MCompandContext *c, CompBand *l, double *ibuf, double *obuf, int len, int ch)
{
    int i;

    for (i = 0; i < len; i++) {
        double level_in_lin, level_out_lin, checkbuf;
        /* Maintain the volume fields by simulating a leaky pump circuit */
        update_volume(l, fabs(ibuf[i]), ch);

        /* Volume memory is updated: perform compand */
        level_in_lin = l->volume[ch];
        level_out_lin = get_volume(&l->transfer_fn, level_in_lin);

        if (c->delay_buf_size <= 0) {
            checkbuf = ibuf[i] * level_out_lin;
            obuf[i] = checkbuf;
        } else {
            double *delay_buf = (double *)l->delay_buf->extended_data[ch];

            /* FIXME: note that this lookahead algorithm is really lame:
               the response to a peak is released before the peak
               arrives. */

            /* because volume application delays differ band to band, but
               total delay doesn't, the volume is applied in an iteration
               preceding that in which the sample goes to obuf, except in
               the band(s) with the longest vol app delay.

               the offset between delay_buf_ptr and the sample to apply
               vol to, is a constant equal to the difference between this
               band's delay and the longest delay of all the bands. */

            if (l->delay_buf_cnt >= l->delay_size) {
                checkbuf =
                    delay_buf[(l->delay_buf_ptr +
                               c->delay_buf_size -
                               l->delay_size) % c->delay_buf_size] * level_out_lin;
                delay_buf[(l->delay_buf_ptr + c->delay_buf_size -
                           l->delay_size) % c->delay_buf_size] = checkbuf;
            }
            if (l->delay_buf_cnt >= c->delay_buf_size) {
                obuf[i] = delay_buf[l->delay_buf_ptr];
            } else {
                l->delay_buf_cnt++;
            }
            delay_buf[l->delay_buf_ptr++] = ibuf[i];
            l->delay_buf_ptr %= c->delay_buf_size;
        }
    }

    return 0;
}

static int filter_frame(AVFilterLink *inlink, AVFrame *in)
{
    AVFilterContext  *ctx = inlink->dst;
    AVFilterLink *outlink = ctx->outputs[0];
    MCompandContext *s    = ctx->priv;
    AVFrame *out, *abuf, *bbuf, *cbuf;
    int ch, band, i;

    out = ff_get_audio_buffer(outlink, in->nb_samples);
    if (!out) {
        av_frame_free(&in);
        return AVERROR(ENOMEM);
    }

    if (s->band_samples < in->nb_samples) {
        av_frame_free(&s->band_buf1);
        av_frame_free(&s->band_buf2);
        av_frame_free(&s->band_buf3);

        s->band_buf1 = ff_get_audio_buffer(outlink, in->nb_samples);
        s->band_buf2 = ff_get_audio_buffer(outlink, in->nb_samples);
        s->band_buf3 = ff_get_audio_buffer(outlink, in->nb_samples);
        s->band_samples = in->nb_samples;
    }

    for (ch = 0; ch < outlink->channels; ch++) {
        double *a, *dst = (double *)out->extended_data[ch];

        for (band = 0, abuf = in, bbuf = s->band_buf2, cbuf = s->band_buf1; band < s->nb_bands; band++) {
            CompBand *b = &s->bands[band];

            if (b->topfreq) {
                crossover(ch, &b->filter, (double *)abuf->extended_data[ch],
                          (double *)bbuf->extended_data[ch], (double *)cbuf->extended_data[ch], in->nb_samples);
            } else {
                bbuf = abuf;
                abuf = cbuf;
            }

            if (abuf == in)
                abuf = s->band_buf3;
            mcompand_channel(s, b, (double *)bbuf->extended_data[ch], (double *)abuf->extended_data[ch], out->nb_samples, ch);
            a = (double *)abuf->extended_data[ch];
            for (i = 0; i < out->nb_samples; i++) {
                dst[i] += a[i];
            }

            FFSWAP(AVFrame *, abuf, cbuf);
        }
    }

    out->pts = in->pts;
    av_frame_free(&in);
    return ff_filter_frame(outlink, out);
}

static int request_frame(AVFilterLink *outlink)
{
    AVFilterContext *ctx = outlink->src;
    int ret;

    ret = ff_request_frame(ctx->inputs[0]);

    return ret;
}

static const AVFilterPad mcompand_inputs[] = {
    {
        .name           = "default",
        .type           = AVMEDIA_TYPE_AUDIO,
        .filter_frame   = filter_frame,
    },
    { NULL }
};

static const AVFilterPad mcompand_outputs[] = {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_AUDIO,
        .request_frame = request_frame,
        .config_props  = config_output,
    },
    { NULL }
};


AVFilter ff_af_mcompand = {
    .name           = "mcompand",
    .description    = NULL_IF_CONFIG_SMALL(
            "Multiband Compress or expand audio dynamic range."),
    .query_formats  = query_formats,
    .priv_size      = sizeof(MCompandContext),
    .priv_class     = &mcompand_class,
    .uninit         = uninit,
    .inputs         = mcompand_inputs,
    .outputs        = mcompand_outputs,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
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[2N+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[2N+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			};