libavfilter/af_compensationdelay.c

   1 /*
   2  * Copyright (c) 2001-2010 Krzysztof Foltman, Markus Schmidt, Thor Harald Johansen, Vladimir Sadovnikov and others
   3  * Copyright (c) 2015 Paul B Mahol
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/opt.h"
  23 #include "libavutil/samplefmt.h"
  24 #include "avfilter.h"
  25 #include "audio.h"
  26 #include "filters.h"
  27
  28 typedef struct CompensationDelayContext {
  29     const AVClass *class;
  30     int distance_mm;
  31     int distance_cm;
  32     int distance_m;
  33     double dry, wet;
  34     int temp;
  35
  36     unsigned delay;
  37     unsigned w_ptr;
  38     unsigned buf_size;
  39     AVFrame *delay_frame;
  40 } CompensationDelayContext;
  41
  42 #define OFFSET(x) offsetof(CompensationDelayContext, x)
  43 #define A (AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM)
  44
  45 static const AVOption compensationdelay_options[] = {
  46     { "mm",   "set mm distance",    OFFSET(distance_mm), AV_OPT_TYPE_INT,    {.i64=0},    0,  10, A },
  47     { "cm",   "set cm distance",    OFFSET(distance_cm), AV_OPT_TYPE_INT,    {.i64=0},    0, 100, A },
  48     { "m",    "set meter distance", OFFSET(distance_m),  AV_OPT_TYPE_INT,    {.i64=0},    0, 100, A },
  49     { "dry",  "set dry amount",     OFFSET(dry),         AV_OPT_TYPE_DOUBLE, {.dbl=0},    0,   1, A },
  50     { "wet",  "set wet amount",     OFFSET(wet),         AV_OPT_TYPE_DOUBLE, {.dbl=1},    0,   1, A },
  51     { "temp", "set temperature °C", OFFSET(temp),        AV_OPT_TYPE_INT,    {.i64=20}, -50,  50, A },
  52     { NULL }
  53 };
  54
  55 AVFILTER_DEFINE_CLASS(compensationdelay);
  56
  57 // The maximum distance for options
  58 #define COMP_DELAY_MAX_DISTANCE            (100.0 * 100.0 + 100.0 * 1.0 + 1.0)
  59 // The actual speed of sound in normal conditions
  60 #define COMP_DELAY_SOUND_SPEED_KM_H(temp)  1.85325 * (643.95 * sqrt(((temp + 273.15) / 273.15)))
  61 #define COMP_DELAY_SOUND_SPEED_CM_S(temp)  (COMP_DELAY_SOUND_SPEED_KM_H(temp) * (1000.0 * 100.0) /* cm/km */ / (60.0 * 60.0) /* s/h */)
  62 #define COMP_DELAY_SOUND_FRONT_DELAY(temp) (1.0 / COMP_DELAY_SOUND_SPEED_CM_S(temp))
  63 // The maximum delay may be reached by this filter
  64 #define COMP_DELAY_MAX_DELAY               (COMP_DELAY_MAX_DISTANCE * COMP_DELAY_SOUND_FRONT_DELAY(50))
  65
  66 static int config_input(AVFilterLink *inlink)
  67 {
  68     AVFilterContext *ctx = inlink->dst;
  69     CompensationDelayContext *s = ctx->priv;
  70     unsigned min_size, new_size = 1;
  71
  72     s->delay = (s->distance_m * 100. + s->distance_cm * 1. + s->distance_mm * .1) *
  73                COMP_DELAY_SOUND_FRONT_DELAY(s->temp) * inlink->sample_rate;
  74     min_size = inlink->sample_rate * COMP_DELAY_MAX_DELAY;
  75
  76     while (new_size < min_size)
  77         new_size <<= 1;
  78
  79     s->buf_size = new_size;
  80     s->delay_frame = ff_get_audio_buffer(inlink, s->buf_size);
  81     if (!s->delay_frame)
  82         return AVERROR(ENOMEM);
  83
  84     return 0;
  85 }
  86
  87 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
  88 {
  89     AVFilterContext *ctx = inlink->dst;
  90     AVFilterLink *outlink = ctx->outputs[0];
  91     CompensationDelayContext *s = ctx->priv;
  92     const unsigned b_mask = s->buf_size - 1;
  93     const unsigned buf_size = s->buf_size;
  94     const unsigned delay = s->delay;
  95     const double dry = s->dry;
  96     const double wet = s->wet;
  97     unsigned r_ptr, w_ptr = 0;
  98     AVFrame *out;
  99     int n, ch;
 100
 101     out = ff_get_audio_buffer(outlink, in->nb_samples);
 102     if (!out) {
 103         av_frame_free(&in);
 104         return AVERROR(ENOMEM);
 105     }
 106     av_frame_copy_props(out, in);
 107
 108     for (ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
 109         const double *src = (const double *)in->extended_data[ch];
 110         double *dst = (double *)out->extended_data[ch];
 111         double *buffer = (double *)s->delay_frame->extended_data[ch];
 112
 113         w_ptr =  s->w_ptr;
 114         r_ptr = (w_ptr + buf_size - delay) & b_mask;
 115
 116         for (n = 0; n < in->nb_samples; n++) {
 117             const double sample = src[n];
 118
 119             buffer[w_ptr] = sample;
 120             dst[n] = dry * sample + wet * buffer[r_ptr];
 121             w_ptr = (w_ptr + 1) & b_mask;
 122             r_ptr = (r_ptr + 1) & b_mask;
 123         }
 124     }
 125     s->w_ptr = w_ptr;
 126
 127     if (ctx->is_disabled) {
 128         av_frame_free(&out);
 129         return ff_filter_frame(outlink, in);
 130     }
 131
 132     av_frame_free(&in);
 133     return ff_filter_frame(outlink, out);
 134 }
 135
 136 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
 137                            char *res, int res_len, int flags)
 138 {
 139     CompensationDelayContext *s = ctx->priv;
 140     AVFilterLink *outlink = ctx->outputs[0];
 141     int ret;
 142
 143     ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
 144     if (ret < 0)
 145         return ret;
 146
 147     s->delay = (s->distance_m * 100. + s->distance_cm * 1. + s->distance_mm * .1) *
 148                COMP_DELAY_SOUND_FRONT_DELAY(s->temp) * outlink->sample_rate;
 149
 150     return 0;
 151 }
 152
 153 static av_cold void uninit(AVFilterContext *ctx)
 154 {
 155     CompensationDelayContext *s = ctx->priv;
 156
 157     av_frame_free(&s->delay_frame);
 158 }
 159
 160 static const AVFilterPad compensationdelay_inputs[] = {
 161     {
 162         .name         = "default",
 163         .type         = AVMEDIA_TYPE_AUDIO,
 164         .config_props = config_input,
 165         .filter_frame = filter_frame,
 166     },
 167 };
 168
 169 const FFFilter ff_af_compensationdelay = {
 170     .p.name        = "compensationdelay",
 171     .p.description = NULL_IF_CONFIG_SMALL("Audio Compensation Delay Line."),
 172     .p.priv_class  = &compensationdelay_class,
 173     .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 174     .priv_size     = sizeof(CompensationDelayContext),
 175     .uninit        = uninit,
 176     FILTER_INPUTS(compensationdelay_inputs),
 177     FILTER_OUTPUTS(ff_audio_default_filterpad),
 178     FILTER_SINGLE_SAMPLEFMT(AV_SAMPLE_FMT_DBLP),
 179     .process_command = process_command,
 180 };