FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavfilter/af_mcompand.c	Lines:	0	317	0.0 %
Date:	2020-10-23 17:01:47	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)
            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");
            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");
            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");
            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");
            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)
            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");
            return ret;
        }

        tstr2 = av_strtok(p2, " ", &saveptr2);
        if (!tstr2) {
            av_log(ctx, AV_LOG_ERROR, "crossover_frequency is missing\n");
            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);
            return AVERROR(EINVAL);
        }

        if (s->bands[i].topfreq != 0) {
            ret = crossover_setup(outlink, &s->bands[i].filter, s->bands[i].topfreq);
            if (ret < 0)
                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			return AVERROR(EINVAL);
366			p = NULL;
367
368			p2 = tstr;
369			count_items(tstr, &nb_items, ' ');
370			tstr2 = av_strtok(p2, " ", &saveptr2);
371			if (!tstr2) {
372			av_log(ctx, AV_LOG_ERROR, "at least one attacks/decays rate is mandatory\n");
373			return AVERROR(EINVAL);
374			}
375			p2 = NULL;
376			p3 = tstr2;
377
378			count_items(tstr2, &nb_attacks, ',');
379			if (!nb_attacks \|\| nb_attacks & 1) {
380			av_log(ctx, AV_LOG_ERROR, "number of attacks rate plus decays rate must be even\n");
381			return AVERROR(EINVAL);
382			}
383
384			s->bands[i].attack_rate = av_calloc(outlink->channels, sizeof(double));
385			s->bands[i].decay_rate = av_calloc(outlink->channels, sizeof(double));
386			s->bands[i].volume = av_calloc(outlink->channels, sizeof(double));
387			for (k = 0; k < FFMIN(nb_attacks / 2, outlink->channels); k++) {
388			char *tstr3 = av_strtok(p3, ",", &saveptr3);
389
390			p3 = NULL;
391			sscanf(tstr3, "%lf", &s->bands[i].attack_rate[k]);
392			tstr3 = av_strtok(p3, ",", &saveptr3);
393			sscanf(tstr3, "%lf", &s->bands[i].decay_rate[k]);
394
395			if (s->bands[i].attack_rate[k] > 1.0 / outlink->sample_rate) {
396			s->bands[i].attack_rate[k] = 1.0 - exp(-1.0 / (outlink->sample_rate * s->bands[i].attack_rate[k]));
397			} else {
398			s->bands[i].attack_rate[k] = 1.0;
399			}
400
401			if (s->bands[i].decay_rate[k] > 1.0 / outlink->sample_rate) {
402			s->bands[i].decay_rate[k] = 1.0 - exp(-1.0 / (outlink->sample_rate * s->bands[i].decay_rate[k]));
403			} else {
404			s->bands[i].decay_rate[k] = 1.0;
405			}
406			}
407
408			for (ch = k; ch < outlink->channels; ch++) {
409			s->bands[i].attack_rate[ch] = s->bands[i].attack_rate[k - 1];
410			s->bands[i].decay_rate[ch] = s->bands[i].decay_rate[k - 1];
411			}
412
413			tstr2 = av_strtok(p2, " ", &saveptr2);
414			if (!tstr2) {
415			av_log(ctx, AV_LOG_ERROR, "transfer function curve in dB must be set\n");
416			return AVERROR(EINVAL);
417			}
418			sscanf(tstr2, "%lf", &s->bands[i].transfer_fn.curve_dB);
419
420			radius = s->bands[i].transfer_fn.curve_dB * M_LN10 / 20.0;
421
422			tstr2 = av_strtok(p2, " ", &saveptr2);
423			if (!tstr2) {
424			av_log(ctx, AV_LOG_ERROR, "transfer points missing\n");
425			return AVERROR(EINVAL);
426			}
427
428			count_items(tstr2, &nb_points, ',');
429			s->bands[i].transfer_fn.nb_segments = (nb_points + 4) * 2;
430			s->bands[i].transfer_fn.segments = av_calloc(s->bands[i].transfer_fn.nb_segments,
431			sizeof(CompandSegment));
432			if (!s->bands[i].transfer_fn.segments)
433			return AVERROR(ENOMEM);
434
435			ret = parse_points(tstr2, nb_points, radius, &s->bands[i].transfer_fn, ctx);
436			if (ret < 0) {
437			av_log(ctx, AV_LOG_ERROR, "transfer points parsing failed\n");
438			return ret;
439			}
440
441			tstr2 = av_strtok(p2, " ", &saveptr2);
442			if (!tstr2) {
443			av_log(ctx, AV_LOG_ERROR, "crossover_frequency is missing\n");
444			return AVERROR(EINVAL);
445			}
446
447			new_nb_items += sscanf(tstr2, "%lf", &s->bands[i].topfreq) == 1;
448			if (s->bands[i].topfreq < 0 \|\| s->bands[i].topfreq >= outlink->sample_rate / 2) {
449			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);
450			return AVERROR(EINVAL);
451			}
452
453			if (s->bands[i].topfreq != 0) {
454			ret = crossover_setup(outlink, &s->bands[i].filter, s->bands[i].topfreq);
455			if (ret < 0)
456			return ret;
457			}
458
459			tstr2 = av_strtok(p2, " ", &saveptr2);
460			if (tstr2) {
461			sscanf(tstr2, "%lf", &s->bands[i].delay);
462			max_delay_size = FFMAX(max_delay_size, s->bands[i].delay * outlink->sample_rate);
463
464			tstr2 = av_strtok(p2, " ", &saveptr2);
465			if (tstr2) {
466			double initial_volume;
467
468			sscanf(tstr2, "%lf", &initial_volume);
469			initial_volume = pow(10.0, initial_volume / 20);
470
471			for (k = 0; k < outlink->channels; k++) {
472			s->bands[i].volume[k] = initial_volume;
473			}
474
475			tstr2 = av_strtok(p2, " ", &saveptr2);
476			if (tstr2) {
477			sscanf(tstr2, "%lf", &s->bands[i].transfer_fn.gain_dB);
478			}
479			}
480			}
481			}
482			s->nb_bands = new_nb_items;
483
484			for (i = 0; max_delay_size > 0 && i < s->nb_bands; i++) {
485			s->bands[i].delay_buf = ff_get_audio_buffer(outlink, max_delay_size);
486			if (!s->bands[i].delay_buf)
487			return AVERROR(ENOMEM);
488			}
489			s->delay_buf_size = max_delay_size;
490
491			return 0;
492			}
493
494			#define CONVOLVE _ _ _ _
495
496			static void crossover(int ch, Crossover *p,
497			double ibuf, double obuf_low,
498			double *obuf_high, size_t len)
499			{
500			double out_low, out_high;
501
502			while (len--) {
503			p->pos = p->pos ? p->pos - 1 : N - 1;
504			#define _ out_low += p->coefs[j] * p->previous[ch][p->pos + j].in \
505			- p->coefs[2N+2 + j] p->previous[ch][p->pos + j].out_low, j++;
506			{
507			int j = 1;
508			out_low = p->coefs[0] * *ibuf;
509			CONVOLVE
510			*obuf_low++ = out_low;
511			}
512			#undef _
513			#define _ out_high += p->coefs[j+N+1] * p->previous[ch][p->pos + j].in \
514			- p->coefs[2N+2 + j] p->previous[ch][p->pos + j].out_high, j++;
515			{
516			int j = 1;
517			out_high = p->coefs[N+1] * *ibuf;
518			CONVOLVE
519			*obuf_high++ = out_high;
520			}
521			p->previous[ch][p->pos + N].in = p->previous[ch][p->pos].in = *ibuf++;
522			p->previous[ch][p->pos + N].out_low = p->previous[ch][p->pos].out_low = out_low;
523			p->previous[ch][p->pos + N].out_high = p->previous[ch][p->pos].out_high = out_high;
524			}
525			}
526
527			static int mcompand_channel(MCompandContext c, CompBand l, double ibuf, double obuf, int len, int ch)
528			{
529			int i;
530
531			for (i = 0; i < len; i++) {
532			double level_in_lin, level_out_lin, checkbuf;
533			/* Maintain the volume fields by simulating a leaky pump circuit */
534			update_volume(l, fabs(ibuf[i]), ch);
535
536			/* Volume memory is updated: perform compand */
537			level_in_lin = l->volume[ch];
538			level_out_lin = get_volume(&l->transfer_fn, level_in_lin);
539
540			if (c->delay_buf_size <= 0) {
541			checkbuf = ibuf[i] * level_out_lin;
542			obuf[i] = checkbuf;
543			} else {
544			double delay_buf = (double )l->delay_buf->extended_data[ch];
545
546			/* FIXME: note that this lookahead algorithm is really lame:
547			the response to a peak is released before the peak
548			arrives. */
549
550			/* because volume application delays differ band to band, but
551			total delay doesn't, the volume is applied in an iteration
552			preceding that in which the sample goes to obuf, except in
553			the band(s) with the longest vol app delay.
554
555			the offset between delay_buf_ptr and the sample to apply
556			vol to, is a constant equal to the difference between this
557			band's delay and the longest delay of all the bands. */
558
559			if (l->delay_buf_cnt >= l->delay_size) {
560			checkbuf =
561			delay_buf[(l->delay_buf_ptr +
562			c->delay_buf_size -
563			l->delay_size) % c->delay_buf_size] * level_out_lin;
564			delay_buf[(l->delay_buf_ptr + c->delay_buf_size -
565			l->delay_size) % c->delay_buf_size] = checkbuf;
566			}
567			if (l->delay_buf_cnt >= c->delay_buf_size) {
568			obuf[i] = delay_buf[l->delay_buf_ptr];
569			} else {
570			l->delay_buf_cnt++;
571			}
572			delay_buf[l->delay_buf_ptr++] = ibuf[i];
573			l->delay_buf_ptr %= c->delay_buf_size;
574			}
575			}
576
577			return 0;
578			}
579
580			static int filter_frame(AVFilterLink inlink, AVFrame in)
581			{
582			AVFilterContext *ctx = inlink->dst;
583			AVFilterLink *outlink = ctx->outputs[0];
584			MCompandContext *s = ctx->priv;
585			AVFrame out, abuf, bbuf, cbuf;
586			int ch, band, i;
587
588			out = ff_get_audio_buffer(outlink, in->nb_samples);
589			if (!out) {
590			av_frame_free(&in);
591			return AVERROR(ENOMEM);
592			}
593
594			if (s->band_samples < in->nb_samples) {
595			av_frame_free(&s->band_buf1);
596			av_frame_free(&s->band_buf2);
597			av_frame_free(&s->band_buf3);
598
599			s->band_buf1 = ff_get_audio_buffer(outlink, in->nb_samples);
600			s->band_buf2 = ff_get_audio_buffer(outlink, in->nb_samples);
601			s->band_buf3 = ff_get_audio_buffer(outlink, in->nb_samples);
602			s->band_samples = in->nb_samples;
603			}
604
605			for (ch = 0; ch < outlink->channels; ch++) {
606			double a, dst = (double *)out->extended_data[ch];
607
608			for (band = 0, abuf = in, bbuf = s->band_buf2, cbuf = s->band_buf1; band < s->nb_bands; band++) {
609			CompBand *b = &s->bands[band];
610
611			if (b->topfreq) {
612			crossover(ch, &b->filter, (double *)abuf->extended_data[ch],
613			(double )bbuf->extended_data[ch], (double )cbuf->extended_data[ch], in->nb_samples);
614			} else {
615			bbuf = abuf;
616			abuf = cbuf;
617			}
618
619			if (abuf == in)
620			abuf = s->band_buf3;
621			mcompand_channel(s, b, (double )bbuf->extended_data[ch], (double )abuf->extended_data[ch], out->nb_samples, ch);
622			a = (double *)abuf->extended_data[ch];
623			for (i = 0; i < out->nb_samples; i++) {
624			dst[i] += a[i];
625			}
626
627			FFSWAP(AVFrame *, abuf, cbuf);
628			}
629			}
630
631			out->pts = in->pts;
632			av_frame_free(&in);
633			return ff_filter_frame(outlink, out);
634			}
635
636			static int request_frame(AVFilterLink *outlink)
637			{
638			AVFilterContext *ctx = outlink->src;
639			int ret;
640
641			ret = ff_request_frame(ctx->inputs[0]);
642
643			return ret;
644			}
645
646			static const AVFilterPad mcompand_inputs[] = {
647			{
648			.name = "default",
649			.type = AVMEDIA_TYPE_AUDIO,
650			.filter_frame = filter_frame,
651			},
652			{ NULL }
653			};
654
655			static const AVFilterPad mcompand_outputs[] = {
656			{
657			.name = "default",
658			.type = AVMEDIA_TYPE_AUDIO,
659			.request_frame = request_frame,
660			.config_props = config_output,
661			},
662			{ NULL }
663			};
664
665
666			AVFilter ff_af_mcompand = {
667			.name = "mcompand",
668			.description = NULL_IF_CONFIG_SMALL(
669			"Multiband Compress or expand audio dynamic range."),
670			.query_formats = query_formats,
671			.priv_size = sizeof(MCompandContext),
672			.priv_class = &mcompand_class,
673			.uninit = uninit,
674			.inputs = mcompand_inputs,
675			.outputs = mcompand_outputs,
676			};