git.sesse.net Git - ffmpeg/blob - libavfilter/af_agate.c

   1 /*
   2  * Copyright (C) 2001-2010 Krzysztof Foltman, Markus Schmidt, Thor Harald Johansen, Damien Zammit
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/channel_layout.h"
  22 #include "libavutil/opt.h"
  23 #include "avfilter.h"
  24 #include "audio.h"
  25 #include "formats.h"
  26 #include "hermite.h"
  27
  28 typedef struct AudioGateContext {
  29     const AVClass *class;
  30
  31     double level_in;
  32     double attack;
  33     double release;
  34     double threshold;
  35     double ratio;
  36     double knee;
  37     double makeup;
  38     double range;
  39     int link;
  40     int detection;
  41
  42     double thres;
  43     double knee_start;
  44     double lin_knee_stop;
  45     double knee_stop;
  46     double lin_slope;
  47     double attack_coeff;
  48     double release_coeff;
  49 } AudioGateContext;
  50
  51 #define OFFSET(x) offsetof(AudioGateContext, x)
  52 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
  53
  54 static const AVOption agate_options[] = {
  55     { "level_in",  "set input level",        OFFSET(level_in),  AV_OPT_TYPE_DOUBLE, {.dbl=1},           0.015625,   64, A },
  56     { "range",     "set max gain reduction", OFFSET(range),     AV_OPT_TYPE_DOUBLE, {.dbl=0.06125},     0, 1, A },
  57     { "threshold", "set threshold",          OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=0.125},       0, 1, A },
  58     { "ratio",     "set ratio",              OFFSET(ratio),     AV_OPT_TYPE_DOUBLE, {.dbl=2},           1,  9000, A },
  59     { "attack",    "set attack",             OFFSET(attack),    AV_OPT_TYPE_DOUBLE, {.dbl=20},          0.01, 9000, A },
  60     { "release",   "set release",            OFFSET(release),   AV_OPT_TYPE_DOUBLE, {.dbl=250},         0.01, 9000, A },
  61     { "makeup",    "set makeup gain",        OFFSET(makeup),    AV_OPT_TYPE_DOUBLE, {.dbl=1},           1,   64, A },
  62     { "knee",      "set knee",               OFFSET(knee),      AV_OPT_TYPE_DOUBLE, {.dbl=2.828427125}, 1,    8, A },
  63     { "detection", "set detection",          OFFSET(detection), AV_OPT_TYPE_INT,    {.i64=0},           0,    1, A, "detection" },
  64     {   "peak",    0,                        0,                 AV_OPT_TYPE_CONST,  {.i64=0},           0,    0, A, "detection" },
  65     {   "rms",     0,                        0,                 AV_OPT_TYPE_CONST,  {.i64=1},           0,    0, A, "detection" },
  66     { "link",      "set link",               OFFSET(link),      AV_OPT_TYPE_INT,    {.i64=0},           0,    1, A, "link" },
  67     {   "average", 0,                        0,                 AV_OPT_TYPE_CONST,  {.i64=0},           0,    0, A, "link" },
  68     {   "maximum", 0,                        0,                 AV_OPT_TYPE_CONST,  {.i64=1},           0,    0, A, "link" },
  69     { NULL }
  70 };
  71
  72 AVFILTER_DEFINE_CLASS(agate);
  73
  74 static int query_formats(AVFilterContext *ctx)
  75 {
  76     AVFilterFormats *formats = NULL;
  77     AVFilterChannelLayouts *layouts;
  78     int ret;
  79
  80     if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_DBL)) < 0)
  81         return ret;
  82     ret = ff_set_common_formats(ctx, formats);
  83     if (ret < 0)
  84         return ret;
  85
  86     layouts = ff_all_channel_counts();
  87     if (!layouts)
  88         return AVERROR(ENOMEM);
  89     ret = ff_set_common_channel_layouts(ctx, layouts);
  90     if (ret < 0)
  91         return ret;
  92
  93     formats = ff_all_samplerates();
  94     if (!formats)
  95         return AVERROR(ENOMEM);
  96
  97     return ff_set_common_samplerates(ctx, formats);
  98 }
  99
 100 static int config_input(AVFilterLink *inlink)
 101 {
 102     AVFilterContext *ctx = inlink->dst;
 103     AudioGateContext *s = ctx->priv;
 104     double lin_threshold = s->threshold;
 105     double lin_knee_sqrt = sqrt(s->knee);
 106     double lin_knee_start;
 107
 108     if (s->detection)
 109         lin_threshold *= lin_threshold;
 110
 111     s->attack_coeff  = FFMIN(1., 1. / (s->attack * inlink->sample_rate / 4000.));
 112     s->release_coeff = FFMIN(1., 1. / (s->release * inlink->sample_rate / 4000.));
 113     s->lin_knee_stop = lin_threshold * lin_knee_sqrt;
 114     lin_knee_start = lin_threshold / lin_knee_sqrt;
 115     s->thres = log(lin_threshold);
 116     s->knee_start = log(lin_knee_start);
 117     s->knee_stop = log(s->lin_knee_stop);
 118
 119     return 0;
 120 }
 121
 122 // A fake infinity value (because real infinity may break some hosts)
 123 #define FAKE_INFINITY (65536.0 * 65536.0)
 124
 125 // Check for infinity (with appropriate-ish tolerance)
 126 #define IS_FAKE_INFINITY(value) (fabs(value-FAKE_INFINITY) < 1.0)
 127
 128 static double output_gain(double lin_slope, double ratio, double thres,
 129                           double knee, double knee_start, double knee_stop,
 130                           double lin_knee_stop, double range)
 131 {
 132     if (lin_slope < lin_knee_stop) {
 133         double slope = log(lin_slope);
 134         double tratio = ratio;
 135         double gain = 0.;
 136         double delta = 0.;
 137
 138         if (IS_FAKE_INFINITY(ratio))
 139             tratio = 1000.;
 140         gain = (slope - thres) * tratio + thres;
 141         delta = tratio;
 142
 143         if (knee > 1. && slope > knee_start) {
 144             gain = hermite_interpolation(slope, knee_start, knee_stop, ((knee_start - thres) * tratio  + thres), knee_stop, delta, 1.);
 145         }
 146         return FFMAX(range, exp(gain - slope));
 147     }
 148
 149     return 1.;
 150 }
 151
 152 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 153 {
 154     AVFilterContext *ctx = inlink->dst;
 155     AVFilterLink *outlink = ctx->outputs[0];
 156     AudioGateContext *s = ctx->priv;
 157     const double *src = (const double *)in->data[0];
 158     const double makeup = s->makeup;
 159     const double attack_coeff = s->attack_coeff;
 160     const double release_coeff = s->release_coeff;
 161     const double level_in = s->level_in;
 162     AVFrame *out;
 163     double *dst;
 164     int n, c;
 165
 166     if (av_frame_is_writable(in)) {
 167         out = in;
 168     } else {
 169         out = ff_get_audio_buffer(inlink, in->nb_samples);
 170         if (!out) {
 171             av_frame_free(&in);
 172             return AVERROR(ENOMEM);
 173         }
 174         av_frame_copy_props(out, in);
 175     }
 176     dst = (double *)out->data[0];
 177
 178     for (n = 0; n < in->nb_samples; n++, src += inlink->channels, dst += inlink->channels) {
 179         double abs_sample = fabs(src[0]), gain = 1.0;
 180
 181         for (c = 0; c < inlink->channels; c++)
 182             dst[c] = src[c] * level_in;
 183
 184         if (s->link == 1) {
 185             for (c = 1; c < inlink->channels; c++)
 186                 abs_sample = FFMAX(fabs(src[c]), abs_sample);
 187         } else {
 188             for (c = 1; c < inlink->channels; c++)
 189                 abs_sample += fabs(src[c]);
 190
 191             abs_sample /= inlink->channels;
 192         }
 193
 194         if (s->detection)
 195             abs_sample *= abs_sample;
 196
 197         s->lin_slope += (abs_sample - s->lin_slope) * (abs_sample > s->lin_slope ? attack_coeff : release_coeff);
 198         if (s->lin_slope > 0.0)
 199             gain = output_gain(s->lin_slope, s->ratio, s->thres,
 200                                s->knee, s->knee_start, s->knee_stop,
 201                                s->lin_knee_stop, s->range);
 202
 203         for (c = 0; c < inlink->channels; c++)
 204             dst[c] *= gain * makeup;
 205     }
 206
 207     if (out != in)
 208         av_frame_free(&in);
 209     return ff_filter_frame(outlink, out);
 210 }
 211
 212 static const AVFilterPad inputs[] = {
 213     {
 214         .name         = "default",
 215         .type         = AVMEDIA_TYPE_AUDIO,
 216         .filter_frame = filter_frame,
 217         .config_props = config_input,
 218     },
 219     { NULL }
 220 };
 221
 222 static const AVFilterPad outputs[] = {
 223     {
 224         .name = "default",
 225         .type = AVMEDIA_TYPE_AUDIO,
 226     },
 227     { NULL }
 228 };
 229
 230 AVFilter ff_af_agate = {
 231     .name           = "agate",
 232     .description    = NULL_IF_CONFIG_SMALL("Audio gate."),
 233     .query_formats  = query_formats,
 234     .priv_size      = sizeof(AudioGateContext),
 235     .priv_class     = &agate_class,
 236     .inputs         = inputs,
 237     .outputs        = outputs,
 238 };