GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/af_superequalizer.c Lines: 0 154 0.0 %
Date: 2020-09-25 14:59:26 Branches: 0 72 0.0 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2002 Naoki Shibata
3
 * Copyright (c) 2017 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
24
#include "libavcodec/avfft.h"
25
26
#include "audio.h"
27
#include "avfilter.h"
28
#include "filters.h"
29
#include "internal.h"
30
31
#define NBANDS 17
32
#define M 15
33
34
typedef struct EqParameter {
35
    float lower, upper, gain;
36
} EqParameter;
37
38
typedef struct SuperEqualizerContext {
39
    const AVClass *class;
40
41
    EqParameter params[NBANDS + 1];
42
43
    float gains[NBANDS + 1];
44
45
    float fact[M + 1];
46
    float aa;
47
    float iza;
48
    float *ires, *irest;
49
    float *fsamples;
50
    int winlen, tabsize;
51
52
    AVFrame *in, *out;
53
    RDFTContext *rdft, *irdft;
54
} SuperEqualizerContext;
55
56
static const float bands[] = {
57
    65.406392, 92.498606, 130.81278, 184.99721, 261.62557, 369.99442, 523.25113, 739.9884, 1046.5023,
58
    1479.9768, 2093.0045, 2959.9536, 4186.0091, 5919.9072, 8372.0181, 11839.814, 16744.036
59
};
60
61
static float izero(SuperEqualizerContext *s, float x)
62
{
63
    float ret = 1;
64
    int m;
65
66
    for (m = 1; m <= M; m++) {
67
        float t;
68
69
        t = pow(x / 2, m) / s->fact[m];
70
        ret += t*t;
71
    }
72
73
    return ret;
74
}
75
76
static float hn_lpf(int n, float f, float fs)
77
{
78
    float t = 1 / fs;
79
    float omega = 2 * M_PI * f;
80
81
    if (n * omega * t == 0)
82
        return 2 * f * t;
83
    return 2 * f * t * sinf(n * omega * t) / (n * omega * t);
84
}
85
86
static float hn_imp(int n)
87
{
88
    return n == 0 ? 1.f : 0.f;
89
}
90
91
static float hn(int n, EqParameter *param, float fs)
92
{
93
    float ret, lhn;
94
    int i;
95
96
    lhn = hn_lpf(n, param[0].upper, fs);
97
    ret = param[0].gain*lhn;
98
99
    for (i = 1; i < NBANDS + 1 && param[i].upper < fs / 2; i++) {
100
        float lhn2 = hn_lpf(n, param[i].upper, fs);
101
        ret += param[i].gain * (lhn2 - lhn);
102
        lhn = lhn2;
103
    }
104
105
    ret += param[i].gain * (hn_imp(n) - lhn);
106
107
    return ret;
108
}
109
110
static float alpha(float a)
111
{
112
    if (a <= 21)
113
        return 0;
114
    if (a <= 50)
115
        return .5842f * pow(a - 21, 0.4f) + 0.07886f * (a - 21);
116
    return .1102f * (a - 8.7f);
117
}
118
119
static float win(SuperEqualizerContext *s, float n, int N)
120
{
121
    return izero(s, alpha(s->aa) * sqrtf(1 - 4 * n * n / ((N - 1) * (N - 1)))) / s->iza;
122
}
123
124
static void process_param(float *bc, EqParameter *param, float fs)
125
{
126
    int i;
127
128
    for (i = 0; i <= NBANDS; i++) {
129
        param[i].lower = i == 0 ? 0 : bands[i - 1];
130
        param[i].upper = i == NBANDS ? fs : bands[i];
131
        param[i].gain  = bc[i];
132
    }
133
}
134
135
static int equ_init(SuperEqualizerContext *s, int wb)
136
{
137
    int i,j;
138
139
    s->rdft  = av_rdft_init(wb, DFT_R2C);
140
    s->irdft = av_rdft_init(wb, IDFT_C2R);
141
    if (!s->rdft || !s->irdft)
142
        return AVERROR(ENOMEM);
143
144
    s->aa = 96;
145
    s->winlen = (1 << (wb-1))-1;
146
    s->tabsize  = 1 << wb;
147
148
    s->ires     = av_calloc(s->tabsize, sizeof(float));
149
    s->irest    = av_calloc(s->tabsize, sizeof(float));
150
    s->fsamples = av_calloc(s->tabsize, sizeof(float));
151
152
    for (i = 0; i <= M; i++) {
153
        s->fact[i] = 1;
154
        for (j = 1; j <= i; j++)
155
            s->fact[i] *= j;
156
    }
157
158
    s->iza = izero(s, alpha(s->aa));
159
160
    return 0;
161
}
162
163
static void make_fir(SuperEqualizerContext *s, float *lbc, float *rbc, EqParameter *param, float fs)
164
{
165
    const int winlen = s->winlen;
166
    const int tabsize = s->tabsize;
167
    float *nires;
168
    int i;
169
170
    if (fs <= 0)
171
        return;
172
173
    process_param(lbc, param, fs);
174
    for (i = 0; i < winlen; i++)
175
        s->irest[i] = hn(i - winlen / 2, param, fs) * win(s, i - winlen / 2, winlen);
176
    for (; i < tabsize; i++)
177
        s->irest[i] = 0;
178
179
    av_rdft_calc(s->rdft, s->irest);
180
    nires = s->ires;
181
    for (i = 0; i < tabsize; i++)
182
        nires[i] = s->irest[i];
183
}
184
185
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
186
{
187
    AVFilterContext *ctx = inlink->dst;
188
    SuperEqualizerContext *s = ctx->priv;
189
    AVFilterLink *outlink = ctx->outputs[0];
190
    const float *ires = s->ires;
191
    float *fsamples = s->fsamples;
192
    int ch, i;
193
194
    AVFrame *out = ff_get_audio_buffer(outlink, s->winlen);
195
    float *src, *dst, *ptr;
196
197
    if (!out) {
198
        av_frame_free(&in);
199
        return AVERROR(ENOMEM);
200
    }
201
202
    for (ch = 0; ch < in->channels; ch++) {
203
        ptr = (float *)out->extended_data[ch];
204
        dst = (float *)s->out->extended_data[ch];
205
        src = (float *)in->extended_data[ch];
206
207
        for (i = 0; i < in->nb_samples; i++)
208
            fsamples[i] = src[i];
209
        for (; i < s->tabsize; i++)
210
            fsamples[i] = 0;
211
212
        av_rdft_calc(s->rdft, fsamples);
213
214
        fsamples[0] = ires[0] * fsamples[0];
215
        fsamples[1] = ires[1] * fsamples[1];
216
        for (i = 1; i < s->tabsize / 2; i++) {
217
            float re, im;
218
219
            re = ires[i*2  ] * fsamples[i*2] - ires[i*2+1] * fsamples[i*2+1];
220
            im = ires[i*2+1] * fsamples[i*2] + ires[i*2  ] * fsamples[i*2+1];
221
222
            fsamples[i*2  ] = re;
223
            fsamples[i*2+1] = im;
224
        }
225
226
        av_rdft_calc(s->irdft, fsamples);
227
228
        for (i = 0; i < s->winlen; i++)
229
            dst[i] += fsamples[i] / s->tabsize * 2;
230
        for (i = s->winlen; i < s->tabsize; i++)
231
            dst[i]  = fsamples[i] / s->tabsize * 2;
232
        for (i = 0; i < s->winlen; i++)
233
            ptr[i] = dst[i];
234
        for (i = 0; i < s->winlen; i++)
235
            dst[i] = dst[i+s->winlen];
236
    }
237
238
    out->pts = in->pts;
239
    av_frame_free(&in);
240
241
    return ff_filter_frame(outlink, out);
242
}
243
244
static int activate(AVFilterContext *ctx)
245
{
246
    AVFilterLink *inlink = ctx->inputs[0];
247
    AVFilterLink *outlink = ctx->outputs[0];
248
    SuperEqualizerContext *s = ctx->priv;
249
    AVFrame *in = NULL;
250
    int ret;
251
252
    FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
253
254
    ret = ff_inlink_consume_samples(inlink, s->winlen, s->winlen, &in);
255
    if (ret < 0)
256
        return ret;
257
    if (ret > 0)
258
        return filter_frame(inlink, in);
259
260
    FF_FILTER_FORWARD_STATUS(inlink, outlink);
261
    FF_FILTER_FORWARD_WANTED(outlink, inlink);
262
263
    return FFERROR_NOT_READY;
264
}
265
266
static av_cold int init(AVFilterContext *ctx)
267
{
268
    SuperEqualizerContext *s = ctx->priv;
269
270
    return equ_init(s, 14);
271
}
272
273
static int query_formats(AVFilterContext *ctx)
274
{
275
    AVFilterFormats *formats;
276
    AVFilterChannelLayouts *layouts;
277
    static const enum AVSampleFormat sample_fmts[] = {
278
        AV_SAMPLE_FMT_FLTP,
279
        AV_SAMPLE_FMT_NONE
280
    };
281
    int ret;
282
283
    layouts = ff_all_channel_counts();
284
    if (!layouts)
285
        return AVERROR(ENOMEM);
286
    ret = ff_set_common_channel_layouts(ctx, layouts);
287
    if (ret < 0)
288
        return ret;
289
290
    formats = ff_make_format_list(sample_fmts);
291
    if ((ret = ff_set_common_formats(ctx, formats)) < 0)
292
        return ret;
293
294
    formats = ff_all_samplerates();
295
    return ff_set_common_samplerates(ctx, formats);
296
}
297
298
static int config_input(AVFilterLink *inlink)
299
{
300
    AVFilterContext *ctx = inlink->dst;
301
    SuperEqualizerContext *s = ctx->priv;
302
303
    s->out = ff_get_audio_buffer(inlink, s->tabsize);
304
    if (!s->out)
305
        return AVERROR(ENOMEM);
306
307
    return 0;
308
}
309
310
static int config_output(AVFilterLink *outlink)
311
{
312
    AVFilterContext *ctx = outlink->src;
313
    SuperEqualizerContext *s = ctx->priv;
314
315
    make_fir(s, s->gains, s->gains, s->params, outlink->sample_rate);
316
317
    return 0;
318
}
319
320
static av_cold void uninit(AVFilterContext *ctx)
321
{
322
    SuperEqualizerContext *s = ctx->priv;
323
324
    av_frame_free(&s->out);
325
    av_freep(&s->irest);
326
    av_freep(&s->ires);
327
    av_freep(&s->fsamples);
328
    av_rdft_end(s->rdft);
329
    av_rdft_end(s->irdft);
330
}
331
332
static const AVFilterPad superequalizer_inputs[] = {
333
    {
334
        .name         = "default",
335
        .type         = AVMEDIA_TYPE_AUDIO,
336
        .config_props = config_input,
337
    },
338
    { NULL }
339
};
340
341
static const AVFilterPad superequalizer_outputs[] = {
342
    {
343
        .name         = "default",
344
        .type         = AVMEDIA_TYPE_AUDIO,
345
        .config_props = config_output,
346
    },
347
    { NULL }
348
};
349
350
#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
351
#define OFFSET(x) offsetof(SuperEqualizerContext, x)
352
353
static const AVOption superequalizer_options[] = {
354
    {  "1b", "set 65Hz band gain",    OFFSET(gains [0]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
355
    {  "2b", "set 92Hz band gain",    OFFSET(gains [1]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
356
    {  "3b", "set 131Hz band gain",   OFFSET(gains [2]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
357
    {  "4b", "set 185Hz band gain",   OFFSET(gains [3]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
358
    {  "5b", "set 262Hz band gain",   OFFSET(gains [4]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
359
    {  "6b", "set 370Hz band gain",   OFFSET(gains [5]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
360
    {  "7b", "set 523Hz band gain",   OFFSET(gains [6]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
361
    {  "8b", "set 740Hz band gain",   OFFSET(gains [7]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
362
    {  "9b", "set 1047Hz band gain",  OFFSET(gains [8]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
363
    { "10b", "set 1480Hz band gain",  OFFSET(gains [9]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
364
    { "11b", "set 2093Hz band gain",  OFFSET(gains[10]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
365
    { "12b", "set 2960Hz band gain",  OFFSET(gains[11]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
366
    { "13b", "set 4186Hz band gain",  OFFSET(gains[12]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
367
    { "14b", "set 5920Hz band gain",  OFFSET(gains[13]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
368
    { "15b", "set 8372Hz band gain",  OFFSET(gains[14]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
369
    { "16b", "set 11840Hz band gain", OFFSET(gains[15]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
370
    { "17b", "set 16744Hz band gain", OFFSET(gains[16]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
371
    { "18b", "set 20000Hz band gain", OFFSET(gains[17]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
372
    { NULL }
373
};
374
375
AVFILTER_DEFINE_CLASS(superequalizer);
376
377
AVFilter ff_af_superequalizer = {
378
    .name          = "superequalizer",
379
    .description   = NULL_IF_CONFIG_SMALL("Apply 18 band equalization filter."),
380
    .priv_size     = sizeof(SuperEqualizerContext),
381
    .priv_class    = &superequalizer_class,
382
    .query_formats = query_formats,
383
    .init          = init,
384
    .activate      = activate,
385
    .uninit        = uninit,
386
    .inputs        = superequalizer_inputs,
387
    .outputs       = superequalizer_outputs,
388
};