[FFmpeg-devel] [PATCH] lavfi: add compand filter

Paul B Mahol onemda at gmail.com
Sat Jul 27 16:29:32 CEST 2013


On 7/27/13, Stefano Sabatini <stefasab at gmail.com> wrote:
> On date Thursday 2013-07-25 13:24:58 +0000, Paul B Mahol encoded:
>> Signed-off-by: Paul B Mahol <onemda at gmail.com>
>> ---
>>  doc/filters.texi         |  48 +++++
>>  libavfilter/Makefile     |   1 +
>>  libavfilter/af_compand.c | 514
>> +++++++++++++++++++++++++++++++++++++++++++++++
>>  libavfilter/allfilters.c |   1 +
>>  4 files changed, 564 insertions(+)
>>  create mode 100644 libavfilter/af_compand.c
>>
>> diff --git a/doc/filters.texi b/doc/filters.texi
>> index 0c18446..080c598 100644
>> --- a/doc/filters.texi
>> +++ b/doc/filters.texi
>> @@ -1176,6 +1176,54 @@ front_center.wav -map '[LFE]' lfe.wav -map '[SL]'
>> side_left.wav -map '[SR]'
>>  side_right.wav
>>  @end example
>>
>> + at section compand
>> +
>> +Compress or expand the dynamic range of the audio.
>> +
>
>> +A description of the accepted parameters follows.
>
> s/parameters/options?
>
>> +
>> + at table @option
>> + at item attacks
>> + at item decays
>> +Set list of times in seconds for each channel over which the
>> instantaneous level
>> +of the input signal is averaged to determine its volume.
>
>> + at option{attacks} refer to increase of volume and @option{decays} to
>> decrease of
>> +volume.
>
> refers
>
>> +For most situations, tha attack time (response to the music getting
>> louder)
>
> the attack
>
> overall s/music/sound/
>
>> +should be shorter than the decay time because the human ear is more
>> sensitive
>> +to sudden loud music than sudden soft music.
>> +Typical value for attack is 0.3 seconds and for decay 0.8 seconds.
>> +
>
>> + at item points
>> +Set list of points for tranfer function, specified in dB relative to
>> maximum possible
>> +signal amplitued.
>> +The input values must be in strictly increasing order but the transfer
>> function does
>> +not have to me monotonically rising. The point 0/0 is assumed but may be
>> overriden
>> +(by 0\out-dBn). Typical values for the transfer function are
>> @code{-70\-60|-20\0}.
>
> Syntax is not specified.
>
>> +
>> + at item soft-knee
>> +Set amount for which the points at where adjacent line segments on the
>> transfer function meet will be rounded.
>> +
>> + at item gain
>> +Set additional gain in dB to be applied at all points on the transfer
>> function
>> +and allows easy adjustment of the overall gain.
>> +Default is @code{0}.
>> +
>> + at item volume
>> +Set initial volume in dB to be assumed for each channel when filtering
>> starts.
>> +This permits the user to supply a nominal level initially, so that, for
>> example,
>> +a very large gain is not applied to initial signal levels before the
>> companding
>> +has begun to operates. A typical value, for audio which is initially
>> quiet is -90 dB.
>> +Default is @code{0}.
>> +
>> + at item delay
>
>> +Set delay in seconds. Default is @code{0}. The input audio
>> +is analysed immediately, but is delayed before being fed to the
>
> what is delayed?
>
>> +volume adjuster. Specifying a delay approximately equal to the
>> attack/decay
>> +times allow the filter to effectively operate in predictive rather than
>
> allows
>
>> +reactive mode.
>> + at end table


All above fixed.

>
> A few examples would be useful.

I like when users write them. Will add some.

>
>> +
>>  @section earwax
>>
>>  Make audio easier to listen to on headphones.
>> diff --git a/libavfilter/Makefile b/libavfilter/Makefile
>> index f54e100..3751d54 100644
>> --- a/libavfilter/Makefile
>> +++ b/libavfilter/Makefile
>> @@ -84,6 +84,7 @@ OBJS-$(CONFIG_BASS_FILTER)                   +=
>> af_biquads.o
>>  OBJS-$(CONFIG_BIQUAD_FILTER)                 += af_biquads.o
>>  OBJS-$(CONFIG_CHANNELMAP_FILTER)             += af_channelmap.o
>>  OBJS-$(CONFIG_CHANNELSPLIT_FILTER)           += af_channelsplit.o
>> +OBJS-$(CONFIG_COMPAND_FILTER)                += af_compand.o
>>  OBJS-$(CONFIG_EARWAX_FILTER)                 += af_earwax.o
>>  OBJS-$(CONFIG_EBUR128_FILTER)                += f_ebur128.o
>>  OBJS-$(CONFIG_EQUALIZER_FILTER)              += af_biquads.o
>> diff --git a/libavfilter/af_compand.c b/libavfilter/af_compand.c
>> new file mode 100644
>> index 0000000..e76b3fd
>> --- /dev/null
>> +++ b/libavfilter/af_compand.c
>> @@ -0,0 +1,514 @@
>> +/*
>> + * Copyright (c) 1999 Chris Bagwell
>> + * Copyright (c) 1999 Nick Bailey
>> + * Copyright (c) 2007 Rob Sykes <robs at users.sourceforge.net>
>> + * Copyright (c) 2013 Paul B Mahol
>> + *
>> + * 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
>> + *
>> + */
>> +
>> +#include "libavutil/avstring.h"
>> +#include "libavutil/opt.h"
>> +#include "libavutil/samplefmt.h"
>> +#include "avfilter.h"
>> +#include "audio.h"
>> +#include "internal.h"
>> +
>> +typedef struct ChanParam {
>> +    double attack;
>> +    double decay;
>> +    double volume;
>> +} ChanParam;
>> +
>> +typedef struct CompandSegment {
>> +    double x, y;
>> +    double a, b;
>> +} CompandSegment;
>> +
>> +typedef struct CompandContext {
>> +    const AVClass *class;
>> +    char *attacks, *decays, *points;
>> +    CompandSegment *segments;
>> +    ChanParam *channels;
>> +    double in_min_lin;
>> +    double out_min_lin;
>> +    double curve_dB;
>> +    double gain_dB;
>> +    double initial_volume;
>> +    double delay;
>> +    uint8_t **delayptrs;
>> +    int delay_samples;
>> +    int delay_count;
>> +    int delay_index;
>> +    int64_t pts;
>> +
>> +    int (*compand)(AVFilterContext *ctx, AVFrame *frame);
>> +} CompandContext;
>> +
>> +#define OFFSET(x) offsetof(CompandContext, x)
>> +#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
>> +
>> +static const AVOption compand_options[] = {
>> +    { "attacks", "set time over which increase of volume is determined",
>> OFFSET(attacks), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
>> +    { "decays", "set time over which decrease of volume is determined",
>> OFFSET(decays), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
>> +    { "points", "set points of transfer function", OFFSET(points),
>> AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
>> +    { "soft-knee", "set soft-knee", OFFSET(curve_dB), AV_OPT_TYPE_DOUBLE,
>> {.dbl=0.01}, 0.01, 900, A },
>> +    { "gain", "set output gain", OFFSET(gain_dB), AV_OPT_TYPE_DOUBLE,
>> {.dbl=0}, -900, 900, A },
>> +    { "volume", "set initial volume", OFFSET(initial_volume),
>> AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 0, A },
>> +    { "delay", "set delay for samples before sending them to volume
>> adjuster", OFFSET(delay), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 20, A },
>> +    { NULL },
>> +};
>> +
>> +AVFILTER_DEFINE_CLASS(compand);
>> +
>> +static av_cold int init(AVFilterContext *ctx)
>> +{
>> +    CompandContext *s = ctx->priv;
>> +
>> +    if (!s->attacks || !s->decays || !s->points) {
>> +        av_log(ctx, AV_LOG_ERROR, "Missing attacks and/or decays and/or
>> points.\n");
>
> Nit: skip the ending dot
>
>> +        return AVERROR(EINVAL);
>> +    }
>> +
>> +    return 0;
>> +}
>> +
>> +static av_cold void uninit(AVFilterContext *ctx)
>> +{
>> +    CompandContext *s = ctx->priv;
>> +
>> +    av_freep(&s->channels);
>> +    av_freep(&s->segments);
>> +    if (s->delayptrs)
>> +        av_freep(&s->delayptrs[0]);
>> +    av_freep(&s->delayptrs);
>> +}
>> +
>> +static int query_formats(AVFilterContext *ctx)
>> +{
>> +    AVFilterChannelLayouts *layouts;
>> +    AVFilterFormats *formats;
>> +    static const enum AVSampleFormat sample_fmts[] = {
>> +        AV_SAMPLE_FMT_DBLP,
>> +        AV_SAMPLE_FMT_NONE
>> +    };
>> +
>> +    layouts = ff_all_channel_layouts();
>> +    if (!layouts)
>> +        return AVERROR(ENOMEM);
>> +    ff_set_common_channel_layouts(ctx, layouts);
>> +
>> +    formats = ff_make_format_list(sample_fmts);
>> +    if (!formats)
>> +        return AVERROR(ENOMEM);
>> +    ff_set_common_formats(ctx, formats);
>> +
>> +    formats = ff_all_samplerates();
>> +    if (!formats)
>> +        return AVERROR(ENOMEM);
>> +    ff_set_common_samplerates(ctx, formats);
>> +
>> +    return 0;
>> +}
>> +
>> +static void count_items(char *item_str, int *nb_items)
>> +{
>> +    char *p;
>> +
>> +    *nb_items = 1;
>> +    for (p = item_str; *p; p++) {
>> +        if (*p == '|')
>> +            (*nb_items)++;
>> +    }
>> +
>> +}
>> +
>> +static void update_volume(ChanParam *cp, double in)
>> +{
>> +    double delta = in - cp->volume;
>> +
>> +    if (delta > 0.0)
>> +        cp->volume += delta * cp->attack;
>> +    else
>> +        cp->volume += delta * cp->decay;
>> +}
>> +
>
>> +static double get_volume(CompandContext *s, double in_lin)
>> +{
>
> nit: s -> compand, so the following is more readable (or it's just
> me?)

I prefer to type less.

>
>> +    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++)
>> +        if (in_log <= s->segments[i + 1].x)
>> +            break;
>
> can't overflow?

It should not.

>
>> +    cs = &s->segments[i];
>> +    in_log -= cs->x;
>> +    out_log = cs->y + in_log * (cs->a * in_log + cs->b);
>> +
>> +    return exp(out_log);
>> +}
>> +
>> +static int compand_nodelay(AVFilterContext *ctx, AVFrame *frame)
>> +{
>> +    CompandContext *s = ctx->priv;
>> +    AVFilterLink *inlink = ctx->inputs[0];
>> +    const int channels = inlink->channels;
>> +    const int nb_samples = frame->nb_samples;
>> +    AVFrame *out_frame;
>> +    int chan, i;
>> +
>> +    if (av_frame_is_writable(frame)) {
>> +        out_frame = frame;
>> +    } else {
>> +        out_frame = ff_get_audio_buffer(inlink, nb_samples);
>> +        if (!out_frame)
>> +            return AVERROR(ENOMEM);
>> +        av_frame_copy_props(out_frame, frame);
>> +    }
>> +
>> +    for (chan = 0; chan < channels; chan++) {
>> +        const double *src = (double *)frame->data[chan];
>> +        double *dst = (double *)out_frame->data[chan];
>> +        ChanParam *cp = &s->channels[chan];
>> +        double volume = get_volume(s, cp->volume);
>> +
>> +        for (i = 0; i < nb_samples; i++) {
>> +            update_volume(cp, fabs(src[i]));
>> +
>> +            dst[i] = av_clipd(src[i] * volume, -1, 1);
>> +        }
>> +    }
>> +
>> +    if (frame != out_frame)
>> +        av_frame_free(&frame);
>> +
>> +    return ff_filter_frame(ctx->outputs[0], out_frame);
>> +}
>> +
>> +#define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))
>> +
>> +static int compand_delay(AVFilterContext *ctx, AVFrame *frame)
>> +{
>> +    CompandContext *s = ctx->priv;
>> +    AVFilterLink *inlink = ctx->inputs[0];
>> +    const int channels = inlink->channels;
>> +    const int nb_samples = frame->nb_samples;
>> +    int chan, i, dindex, oindex, count;
>> +    AVFrame *out_frame = NULL;
>> +
>> +    for (chan = 0; chan < channels; chan++) {
>> +        const double *src = (double *)frame->data[chan];
>> +        double *dbuf = (double *)s->delayptrs[chan];
>> +        double *dst;
>> +        ChanParam *cp = &s->channels[chan];
>> +
>> +        count  = s->delay_count;
>> +        dindex = s->delay_index;
>> +        for (i = 0, oindex = 0; i < nb_samples; i++) {
>> +            const double in = src[i];
>> +            update_volume(cp, fabs(in));
>> +
>> +            if (count >= s->delay_samples) {
>> +                if (!out_frame) {
>> +                    out_frame = ff_get_audio_buffer(inlink, nb_samples -
>> i);
>> +                    if (!out_frame)
>> +                        return AVERROR(ENOMEM);
>> +                    av_frame_copy_props(out_frame, frame);
>> +                    out_frame->pts = s->pts;
>> +                    s->pts += av_rescale_q(nb_samples - i,
>> (AVRational){1, inlink->sample_rate}, inlink->time_base);
>> +                }
>> +
>> +                dst = (double *)out_frame->data[chan];
>> +                dst[oindex++] = av_clipd(dbuf[dindex] * get_volume(s,
>> cp->volume), -1, 1);
>> +            } else {
>> +                count++;
>> +            }
>> +
>> +            dbuf[dindex] = in;
>> +            dindex = MOD(dindex + 1, s->delay_samples);
>> +        }
>> +    }
>> +
>> +    s->delay_count = count;
>> +    s->delay_index = dindex;
>> +
>> +    av_frame_free(&frame);
>> +    return out_frame ? ff_filter_frame(ctx->outputs[0], out_frame) : 0;
>> +}
>> +
>> +static int compand_drain(AVFilterLink *outlink)
>> +{
>> +    AVFilterContext *ctx = outlink->src;
>> +    CompandContext *s = ctx->priv;
>> +    const int channels = outlink->channels;
>> +    int chan, i, dindex;
>> +    AVFrame *frame = NULL;
>> +
>> +    frame = ff_get_audio_buffer(outlink, FFMIN(2048, s->delay_count));
>> +    if (!frame)
>> +        return AVERROR(ENOMEM);
>> +    frame->pts = s->pts;
>> +    s->pts += av_rescale_q(frame->nb_samples, (AVRational){1,
>> outlink->sample_rate}, outlink->time_base);
>> +
>> +    for (chan = 0; chan < channels; chan++) {
>> +        double *dbuf = (double *)s->delayptrs[chan];
>> +        double *dst = (double *)frame->data[chan];
>> +        ChanParam *cp = &s->channels[chan];
>> +
>> +        dindex = s->delay_index;
>> +        for (i = 0; i < frame->nb_samples; i++) {
>> +            dst[i] = av_clipd(dbuf[dindex] * get_volume(s, cp->volume),
>> -1, 1);
>> +            dindex = MOD(dindex + 1, s->delay_samples);
>> +        }
>> +    }
>> +    s->delay_count -= frame->nb_samples;
>> +    s->delay_index = dindex;
>> +
>> +    return ff_filter_frame(outlink, frame);
>> +}
>> +
>> +static int config_output(AVFilterLink *outlink)
>> +{
>> +    AVFilterContext *ctx = outlink->src;
>> +    CompandContext *s = ctx->priv;
>> +    const int sample_rate = outlink->sample_rate;
>> +    double radius = s->curve_dB * M_LN10 / 20;
>> +    int nb_attacks, nb_decays, nb_points;
>> +    char *p, *saveptr = NULL;
>> +    int new_nb_items, num;
>> +    int i;
>> +
>> +    count_items(s->attacks, &nb_attacks);
>> +    count_items(s->decays, &nb_decays);
>> +    count_items(s->points, &nb_points);
>> +
>
>> +    if ((nb_attacks > outlink->channels) || (nb_decays >
>> outlink->channels))
>> +        return AVERROR(EINVAL);

Added.

>
> No feedback?
>
>> +
>> +    uninit(ctx);
>
> why?

Filter reconfiguration.

>
>> +
>> +    s->channels = av_mallocz_array(outlink->channels,
>> sizeof(*s->channels));
>> +    s->segments = av_mallocz_array((nb_points + 4) * 2,
>> sizeof(*s->segments));
>> +
>> +    if (!s->channels || !s->segments)
>> +        return AVERROR(ENOMEM);
>> +
>
>> +    p = s->attacks;
>> +    for (i = 0, new_nb_items = 0; i < nb_attacks; i++) {
>> +        char *tstr = av_strtok(p, "|", &saveptr);
>> +        p = NULL;
>> +        new_nb_items += sscanf(tstr, "%lf", &s->channels[i].attack) ==
>> 1;
>> +        if (s->channels[i].attack < 0)
>> +            return AVERROR(EINVAL);
>> +    }
>> +    nb_attacks = new_nb_items;
>> +
>> +    p = s->decays;
>> +    for (i = 0, new_nb_items = 0; i < nb_decays; i++) {
>> +        char *tstr = av_strtok(p, "|", &saveptr);
>> +        p = NULL;
>> +        new_nb_items += sscanf(tstr, "%lf", &s->channels[i].decay) == 1;
>> +        if (s->channels[i].decay < 0)
>> +            return AVERROR(EINVAL);
>> +    }
>> +    nb_decays = new_nb_items;
>> +
>
> Nit: could be factorized
>
>> +    if (nb_attacks != nb_decays) {
>> +        av_log(ctx, AV_LOG_ERROR, "Number of attacks %d differs from
>> number of decays %d.\n", nb_attacks, nb_decays);
>
> Nit: skip ending dot, here and in the messages below
>
>> +        return AVERROR(EINVAL);
>> +    }
>> +
>> +#define S(x) s->segments[2 * ((x) + 1)]
>> +    p = s->points;
>> +    for (i = 0, new_nb_items = 0; i < nb_points; i++) {
>> +        char *tstr = av_strtok(p, "|", &saveptr);
>> +        p = NULL;
>> +        if (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=%lf y=%lf\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->segments[i - 2].x; 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; s->segments[i - 2].x; 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 = sqrt(pow(L(2).x - L(4).x, 2.) + pow(L(2).y - L(4).y, 2.));
>> +        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 = sqrt(pow(L(0).x - L(2).x, 2.) + pow(L(0).y - L(2).y, 2.));
>> +        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);
>> +
>> +    for (i = 0; i < outlink->channels; i++) {
>> +        ChanParam *cp = &s->channels[i];
>> +
>> +        if (cp->attack > 1.0 / sample_rate)
>> +            cp->attack = 1.0 - exp(-1.0 / (sample_rate * cp->attack));
>> +        else
>> +            cp->attack = 1.0;
>> +        if (cp->decay > 1.0 / sample_rate)
>> +            cp->decay = 1.0 - exp(-1.0 / (sample_rate * cp->decay));
>> +        else
>> +            cp->decay = 1.0;
>> +        cp->volume = pow(10.0, s->initial_volume / 20);
>> +    }
>> +
>> +    s->delay_samples = s->delay * sample_rate;
>> +    if (s->delay_samples > 0) {
>> +        int ret;
>> +        if ((ret = av_samples_alloc_array_and_samples(&s->delayptrs,
>> NULL,
>> +                                                      outlink->channels,
>> +                                                      s->delay_samples,
>> +                                                      outlink->format,
>> 0)) < 0)
>> +            return ret;
>> +        s->compand = compand_delay;
>> +        outlink->flags |= FF_LINK_FLAG_REQUEST_LOOP;
>> +    } else {
>> +        s->compand = compand_nodelay;
>> +    }
>> +    return 0;
>> +}
>> +
>> +static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
>> +{
>> +    AVFilterContext *ctx = inlink->dst;
>> +    CompandContext *s = ctx->priv;
>> +
>> +    return s->compand(ctx, frame);
>> +}
>> +
>> +static int request_frame(AVFilterLink *outlink)
>> +{
>> +    AVFilterContext *ctx = outlink->src;
>> +    CompandContext *s = ctx->priv;
>> +    int ret;
>> +
>> +    ret = ff_request_frame(ctx->inputs[0]);
>> +
>> +    if (ret == AVERROR_EOF && !ctx->is_disabled && s->delay_count)
>> +        ret = compand_drain(outlink);
>> +
>> +    return ret;
>> +}
>> +
>> +static const AVFilterPad compand_inputs[] = {
>> +    {
>> +        .name         = "default",
>> +        .type         = AVMEDIA_TYPE_AUDIO,
>> +        .filter_frame = filter_frame,
>> +    },
>> +    { NULL },
>> +};
>> +
>> +static const AVFilterPad compand_outputs[] = {
>> +    {
>> +        .name          = "default",
>> +        .request_frame = request_frame,
>> +        .config_props  = config_output,
>> +        .type          = AVMEDIA_TYPE_AUDIO,
>> +    },
>> +    { NULL },
>> +};
>> +
>> +AVFilter avfilter_af_compand = {
>> +    .name          = "compand",
>> +    .description   = NULL_IF_CONFIG_SMALL("Compress or expand the dynamic
>> range of the audio."),
>> +    .query_formats = query_formats,
>> +    .priv_size     = sizeof(CompandContext),
>> +    .priv_class    = &compand_class,
>> +    .init          = init,
>> +    .uninit        = uninit,
>> +    .inputs        = compand_inputs,
>> +    .outputs       = compand_outputs,
>> +};
>
> No timeline?

How would you want to do it?

Possible implementation: if not enabled just feed samples to volume
adjuster but do not actually modify samples.

>
> [...]
> --
> FFmpeg = Fanciful and Freak Merciless Patchable Ecumenical Game
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel at ffmpeg.org
> http://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>


More information about the ffmpeg-devel mailing list