avfilter: rename variables in geq
[ffmpeg.git] / libavfilter / af_haas.c
1 /*
2  * Copyright (c) 2001-2010 Vladimir Sadovnikov
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
27 #define MAX_HAAS_DELAY 40
28
29 typedef struct HaasContext {
30     const AVClass *class;
31
32     int par_m_source;
33     double par_delay0;
34     double par_delay1;
35     int par_phase0;
36     int par_phase1;
37     int par_middle_phase;
38     double par_side_gain;
39     double par_gain0;
40     double par_gain1;
41     double par_balance0;
42     double par_balance1;
43     double level_in;
44     double level_out;
45
46     double *buffer;
47     size_t buffer_size;
48     uint32_t write_ptr;
49     uint32_t delay[2];
50     double balance_l[2];
51     double balance_r[2];
52     double phase0;
53     double phase1;
54 } HaasContext;
55
56 #define OFFSET(x) offsetof(HaasContext, x)
57 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
58
59 static const AVOption haas_options[] = {
60     { "level_in",      "set level in",      OFFSET(level_in),         AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
61     { "level_out",     "set level out",     OFFSET(level_out),        AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
62     { "side_gain",     "set side gain",     OFFSET(par_side_gain),    AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
63     { "middle_source", "set middle source", OFFSET(par_m_source),     AV_OPT_TYPE_INT,     {.i64=2},        0,   3, A, "source" },
64     {   "left",        0,                   0,                        AV_OPT_TYPE_CONST,   {.i64=0},        0,   0, A, "source" },
65     {   "right",       0,                   0,                        AV_OPT_TYPE_CONST,   {.i64=1},        0,   0, A, "source" },
66     {   "mid",         "L+R",               0,                        AV_OPT_TYPE_CONST,   {.i64=2},        0,   0, A, "source" },
67     {   "side",        "L-R",               0,                        AV_OPT_TYPE_CONST,   {.i64=3},        0,   0, A, "source" },
68     { "middle_phase",  "set middle phase",  OFFSET(par_middle_phase), AV_OPT_TYPE_BOOL,    {.i64=0},        0,   1, A },
69     { "left_delay",    "set left delay",    OFFSET(par_delay0),       AV_OPT_TYPE_DOUBLE,  {.dbl=2.05},     0,  MAX_HAAS_DELAY, A },
70     { "left_balance",  "set left balance",  OFFSET(par_balance0),     AV_OPT_TYPE_DOUBLE,  {.dbl=-1.0},    -1,   1, A },
71     { "left_gain",     "set left gain",     OFFSET(par_gain0),        AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
72     { "left_phase",    "set left phase",    OFFSET(par_phase0),       AV_OPT_TYPE_BOOL,    {.i64=0},        0,   1, A },
73     { "right_delay",   "set right delay",   OFFSET(par_delay1),       AV_OPT_TYPE_DOUBLE,  {.dbl=2.12},     0,  MAX_HAAS_DELAY, A },
74     { "right_balance", "set right balance", OFFSET(par_balance1),     AV_OPT_TYPE_DOUBLE,  {.dbl=1},       -1,   1, A },
75     { "right_gain",    "set right gain",    OFFSET(par_gain1),        AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
76     { "right_phase",   "set right phase",   OFFSET(par_phase1),       AV_OPT_TYPE_BOOL,    {.i64=1},        0,   1, A },
77     { NULL }
78 };
79
80 AVFILTER_DEFINE_CLASS(haas);
81
82 static int query_formats(AVFilterContext *ctx)
83 {
84     AVFilterFormats *formats = NULL;
85     AVFilterChannelLayouts *layout = NULL;
86     int ret;
87
88     if ((ret = ff_add_format                 (&formats, AV_SAMPLE_FMT_DBL  )) < 0 ||
89         (ret = ff_set_common_formats         (ctx     , formats            )) < 0 ||
90         (ret = ff_add_channel_layout         (&layout , AV_CH_LAYOUT_STEREO)) < 0 ||
91         (ret = ff_set_common_channel_layouts (ctx     , layout             )) < 0)
92         return ret;
93
94     formats = ff_all_samplerates();
95     return ff_set_common_samplerates(ctx, formats);
96 }
97
98 static int config_input(AVFilterLink *inlink)
99 {
100     AVFilterContext *ctx = inlink->dst;
101     HaasContext *s = ctx->priv;
102     size_t min_buf_size = (size_t)(inlink->sample_rate * MAX_HAAS_DELAY * 0.001);
103     size_t new_buf_size = 1;
104
105     while (new_buf_size < min_buf_size)
106         new_buf_size <<= 1;
107
108     av_freep(&s->buffer);
109     s->buffer = av_calloc(new_buf_size, sizeof(*s->buffer));
110     if (!s->buffer)
111         return AVERROR(ENOMEM);
112
113     s->buffer_size = new_buf_size;
114     s->write_ptr = 0;
115
116     s->delay[0] = (uint32_t)(s->par_delay0 * 0.001 * inlink->sample_rate);
117     s->delay[1] = (uint32_t)(s->par_delay1 * 0.001 * inlink->sample_rate);
118
119     s->phase0 = s->par_phase0 ? 1.0 : -1.0;
120     s->phase1 = s->par_phase1 ? 1.0 : -1.0;
121
122     s->balance_l[0] = (s->par_balance0 + 1) / 2 * s->par_gain0 * s->phase0;
123     s->balance_r[0] = (1.0 - (s->par_balance0 + 1) / 2) * (s->par_gain0) * s->phase0;
124     s->balance_l[1] = (s->par_balance1 + 1) / 2 * s->par_gain1 * s->phase1;
125     s->balance_r[1] = (1.0 - (s->par_balance1 + 1) / 2) * (s->par_gain1) * s->phase1;
126
127     return 0;
128 }
129
130 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
131 {
132     AVFilterContext *ctx = inlink->dst;
133     AVFilterLink *outlink = ctx->outputs[0];
134     HaasContext *s = ctx->priv;
135     const double *src = (const double *)in->data[0];
136     const double level_in = s->level_in;
137     const double level_out = s->level_out;
138     const uint32_t mask = s->buffer_size - 1;
139     double *buffer = s->buffer;
140     AVFrame *out;
141     double *dst;
142     int n;
143
144     if (av_frame_is_writable(in)) {
145         out = in;
146     } else {
147         out = ff_get_audio_buffer(outlink, in->nb_samples);
148         if (!out) {
149             av_frame_free(&in);
150             return AVERROR(ENOMEM);
151         }
152         av_frame_copy_props(out, in);
153     }
154     dst = (double *)out->data[0];
155
156     for (n = 0; n < in->nb_samples; n++, src += 2, dst += 2) {
157         double mid, side[2], side_l, side_r;
158         uint32_t s0_ptr, s1_ptr;
159
160         switch (s->par_m_source) {
161         case 0: mid = src[0]; break;
162         case 1: mid = src[1]; break;
163         case 2: mid = (src[0] + src[1]) * 0.5; break;
164         case 3: mid = (src[0] - src[1]) * 0.5; break;
165         }
166
167         mid *= level_in;
168
169         buffer[s->write_ptr] = mid;
170
171         s0_ptr = (s->write_ptr + s->buffer_size - s->delay[0]) & mask;
172         s1_ptr = (s->write_ptr + s->buffer_size - s->delay[1]) & mask;
173
174         if (s->par_middle_phase)
175             mid = -mid;
176
177         side[0] = buffer[s0_ptr] * s->par_side_gain;
178         side[1] = buffer[s1_ptr] * s->par_side_gain;
179         side_l  = side[0] * s->balance_l[0] - side[1] * s->balance_l[1];
180         side_r  = side[1] * s->balance_r[1] - side[0] * s->balance_r[0];
181
182         dst[0] = (mid + side_l) * level_out;
183         dst[1] = (mid + side_r) * level_out;
184
185         s->write_ptr = (s->write_ptr + 1) & mask;
186     }
187
188     if (out != in)
189         av_frame_free(&in);
190     return ff_filter_frame(outlink, out);
191 }
192
193 static av_cold void uninit(AVFilterContext *ctx)
194 {
195     HaasContext *s = ctx->priv;
196
197     av_freep(&s->buffer);
198     s->buffer_size = 0;
199 }
200
201 static const AVFilterPad inputs[] = {
202     {
203         .name         = "default",
204         .type         = AVMEDIA_TYPE_AUDIO,
205         .filter_frame = filter_frame,
206         .config_props = config_input,
207     },
208     { NULL }
209 };
210
211 static const AVFilterPad outputs[] = {
212     {
213         .name = "default",
214         .type = AVMEDIA_TYPE_AUDIO,
215     },
216     { NULL }
217 };
218
219 AVFilter ff_af_haas = {
220     .name           = "haas",
221     .description    = NULL_IF_CONFIG_SMALL("Apply Haas Stereo Enhancer."),
222     .query_formats  = query_formats,
223     .priv_size      = sizeof(HaasContext),
224     .priv_class     = &haas_class,
225     .uninit         = uninit,
226     .inputs         = inputs,
227     .outputs        = outputs,
228 };