← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ffmpeg/vivid

« back to all changes in this revision

Viewing changes to libavfilter/af_biquads.c

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun
  • Date: 2014-11-05 01:18:23 UTC
  • mfrom: (0.2.17 sid)
  • Revision ID: package-import@ubuntu.com-20141105011823-xsbeceffs43wtkn7
Tags: 7:2.4.3-1
* Import new upstream bugfix release 2.4.3.
   - Refresh Change-symbol-versioning.patch.
   - Add new symbols to the libavdevice symbols file.
* Enable libbs2b on arm64, since it is now available.
* Disable frei0r and libx264 on x32, libsoxr and openal on sparc64
  and libopencv on m68k, sh4, sparc64 and x32, because they are not
  (yet) avialable there.
* Disable assembler optimizations on x32, as they wouldn't work there.
* Include config.log in the build-log, when compiling fails.
* Add fix-hppa-tests.patch to work around a gcc bug on hppa.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavfilter/af_biquads.c
 
1
/*
 
2
 * Copyright (c) 2013 Paul B Mahol
 
3
 * Copyright (c) 2006-2008 Rob Sykes <robs@users.sourceforge.net>
 
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
/*
 
23
 * 2-pole filters designed by Robert Bristow-Johnson <rbj@audioimagination.com>
 
24
 *   see http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
 
25
 *
 
26
 * 1-pole filters based on code (c) 2000 Chris Bagwell <cbagwell@sprynet.com>
 
27
 *   Algorithms: Recursive single pole low/high pass filter
 
28
 *   Reference: The Scientist and Engineer's Guide to Digital Signal Processing
 
29
 *
 
30
 *   low-pass: output[N] = input[N] * A + output[N-1] * B
 
31
 *     X = exp(-2.0 * pi * Fc)
 
32
 *     A = 1 - X
 
33
 *     B = X
 
34
 *     Fc = cutoff freq / sample rate
 
35
 *
 
36
 *     Mimics an RC low-pass filter:
 
37
 *
 
38
 *     ---/\/\/\/\----------->
 
39
 *                   |
 
40
 *                  --- C
 
41
 *                  ---
 
42
 *                   |
 
43
 *                   |
 
44
 *                   V
 
45
 *
 
46
 *   high-pass: output[N] = A0 * input[N] + A1 * input[N-1] + B1 * output[N-1]
 
47
 *     X  = exp(-2.0 * pi * Fc)
 
48
 *     A0 = (1 + X) / 2
 
49
 *     A1 = -(1 + X) / 2
 
50
 *     B1 = X
 
51
 *     Fc = cutoff freq / sample rate
 
52
 *
 
53
 *     Mimics an RC high-pass filter:
 
54
 *
 
55
 *         || C
 
56
 *     ----||--------->
 
57
 *         ||    |
 
58
 *               <
 
59
 *               > R
 
60
 *               <
 
61
 *               |
 
62
 *               V
 
63
 */
 
64
 
 
65
#include "libavutil/avassert.h"
 
66
#include "libavutil/opt.h"
 
67
#include "audio.h"
 
68
#include "avfilter.h"
 
69
#include "internal.h"
 
70
 
 
71
enum FilterType {
 
72
    biquad,
 
73
    equalizer,
 
74
    bass,
 
75
    treble,
 
76
    band,
 
77
    bandpass,
 
78
    bandreject,
 
79
    allpass,
 
80
    highpass,
 
81
    lowpass,
 
82
};
 
83
 
 
84
enum WidthType {
 
85
    NONE,
 
86
    HERTZ,
 
87
    OCTAVE,
 
88
    QFACTOR,
 
89
    SLOPE,
 
90
};
 
91
 
 
92
typedef struct ChanCache {
 
93
    double i1, i2;
 
94
    double o1, o2;
 
95
} ChanCache;
 
96
 
 
97
typedef struct {
 
98
    const AVClass *class;
 
99
 
 
100
    enum FilterType filter_type;
 
101
    enum WidthType width_type;
 
102
    int poles;
 
103
    int csg;
 
104
 
 
105
    double gain;
 
106
    double frequency;
 
107
    double width;
 
108
 
 
109
    double a0, a1, a2;
 
110
    double b0, b1, b2;
 
111
 
 
112
    ChanCache *cache;
 
113
 
 
114
    void (*filter)(const void *ibuf, void *obuf, int len,
 
115
                   double *i1, double *i2, double *o1, double *o2,
 
116
                   double b0, double b1, double b2, double a1, double a2);
 
117
} BiquadsContext;
 
118
 
 
119
static av_cold int init(AVFilterContext *ctx)
 
120
{
 
121
    BiquadsContext *p = ctx->priv;
 
122
 
 
123
    if (p->filter_type != biquad) {
 
124
        if (p->frequency <= 0 || p->width <= 0) {
 
125
            av_log(ctx, AV_LOG_ERROR, "Invalid frequency %f and/or width %f <= 0\n",
 
126
                   p->frequency, p->width);
 
127
            return AVERROR(EINVAL);
 
128
        }
 
129
    }
 
130
 
 
131
    return 0;
 
132
}
 
133
 
 
134
static int query_formats(AVFilterContext *ctx)
 
135
{
 
136
    AVFilterFormats *formats;
 
137
    AVFilterChannelLayouts *layouts;
 
138
    static const enum AVSampleFormat sample_fmts[] = {
 
139
        AV_SAMPLE_FMT_S16P,
 
140
        AV_SAMPLE_FMT_S32P,
 
141
        AV_SAMPLE_FMT_FLTP,
 
142
        AV_SAMPLE_FMT_DBLP,
 
143
        AV_SAMPLE_FMT_NONE
 
144
    };
 
145
 
 
146
    layouts = ff_all_channel_layouts();
 
147
    if (!layouts)
 
148
        return AVERROR(ENOMEM);
 
149
    ff_set_common_channel_layouts(ctx, layouts);
 
150
 
 
151
    formats = ff_make_format_list(sample_fmts);
 
152
    if (!formats)
 
153
        return AVERROR(ENOMEM);
 
154
    ff_set_common_formats(ctx, formats);
 
155
 
 
156
    formats = ff_all_samplerates();
 
157
    if (!formats)
 
158
        return AVERROR(ENOMEM);
 
159
    ff_set_common_samplerates(ctx, formats);
 
160
 
 
161
    return 0;
 
162
}
 
163
 
 
164
#define BIQUAD_FILTER(name, type, min, max, need_clipping)                    \
 
165
static void biquad_## name (const void *input, void *output, int len,         \
 
166
                            double *in1, double *in2,                         \
 
167
                            double *out1, double *out2,                       \
 
168
                            double b0, double b1, double b2,                  \
 
169
                            double a1, double a2)                             \
 
170
{                                                                             \
 
171
    const type *ibuf = input;                                                 \
 
172
    type *obuf = output;                                                      \
 
173
    double i1 = *in1;                                                         \
 
174
    double i2 = *in2;                                                         \
 
175
    double o1 = *out1;                                                        \
 
176
    double o2 = *out2;                                                        \
 
177
    int i;                                                                    \
 
178
    a1 = -a1;                                                                 \
 
179
    a2 = -a2;                                                                 \
 
180
                                                                              \
 
181
    for (i = 0; i+1 < len; i++) {                                             \
 
182
        o2 = i2 * b2 + i1 * b1 + ibuf[i] * b0 + o2 * a2 + o1 * a1;            \
 
183
        i2 = ibuf[i];                                                         \
 
184
        if (need_clipping && o2 < min) {                                      \
 
185
            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 
186
            obuf[i] = min;                                                    \
 
187
        } else if (need_clipping && o2 > max) {                               \
 
188
            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 
189
            obuf[i] = max;                                                    \
 
190
        } else {                                                              \
 
191
            obuf[i] = o2;                                                     \
 
192
        }                                                                     \
 
193
        i++;                                                                  \
 
194
        o1 = i1 * b2 + i2 * b1 + ibuf[i] * b0 + o1 * a2 + o2 * a1;            \
 
195
        i1 = ibuf[i];                                                         \
 
196
        if (need_clipping && o1 < min) {                                      \
 
197
            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 
198
            obuf[i] = min;                                                    \
 
199
        } else if (need_clipping && o1 > max) {                               \
 
200
            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 
201
            obuf[i] = max;                                                    \
 
202
        } else {                                                              \
 
203
            obuf[i] = o1;                                                     \
 
204
        }                                                                     \
 
205
    }                                                                         \
 
206
    if (i < len) {                                                            \
 
207
        double o0 = ibuf[i] * b0 + i1 * b1 + i2 * b2 + o1 * a1 + o2 * a2;     \
 
208
        i2 = i1;                                                              \
 
209
        i1 = ibuf[i];                                                         \
 
210
        o2 = o1;                                                              \
 
211
        o1 = o0;                                                              \
 
212
        if (need_clipping && o0 < min) {                                      \
 
213
            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 
214
            obuf[i] = min;                                                    \
 
215
        } else if (need_clipping && o0 > max) {                               \
 
216
            av_log(NULL, AV_LOG_WARNING, "clipping\n");                       \
 
217
            obuf[i] = max;                                                    \
 
218
        } else {                                                              \
 
219
            obuf[i] = o0;                                                     \
 
220
        }                                                                     \
 
221
    }                                                                         \
 
222
    *in1  = i1;                                                               \
 
223
    *in2  = i2;                                                               \
 
224
    *out1 = o1;                                                               \
 
225
    *out2 = o2;                                                               \
 
226
}
 
227
 
 
228
BIQUAD_FILTER(s16, int16_t, INT16_MIN, INT16_MAX, 1)
 
229
BIQUAD_FILTER(s32, int32_t, INT32_MIN, INT32_MAX, 1)
 
230
BIQUAD_FILTER(flt, float,   -1., 1., 0)
 
231
BIQUAD_FILTER(dbl, double,  -1., 1., 0)
 
232
 
 
233
static int config_output(AVFilterLink *outlink)
 
234
{
 
235
    AVFilterContext *ctx    = outlink->src;
 
236
    BiquadsContext *p       = ctx->priv;
 
237
    AVFilterLink *inlink    = ctx->inputs[0];
 
238
    double A = exp(p->gain / 40 * log(10.));
 
239
    double w0 = 2 * M_PI * p->frequency / inlink->sample_rate;
 
240
    double alpha;
 
241
 
 
242
    if (w0 > M_PI) {
 
243
        av_log(ctx, AV_LOG_ERROR,
 
244
               "Invalid frequency %f. Frequency must be less than half the sample-rate %d.\n",
 
245
               p->frequency, inlink->sample_rate);
 
246
        return AVERROR(EINVAL);
 
247
    }
 
248
 
 
249
    switch (p->width_type) {
 
250
    case NONE:
 
251
        alpha = 0.0;
 
252
        break;
 
253
    case HERTZ:
 
254
        alpha = sin(w0) / (2 * p->frequency / p->width);
 
255
        break;
 
256
    case OCTAVE:
 
257
        alpha = sin(w0) * sinh(log(2.) / 2 * p->width * w0 / sin(w0));
 
258
        break;
 
259
    case QFACTOR:
 
260
        alpha = sin(w0) / (2 * p->width);
 
261
        break;
 
262
    case SLOPE:
 
263
        alpha = sin(w0) / 2 * sqrt((A + 1 / A) * (1 / p->width - 1) + 2);
 
264
        break;
 
265
    default:
 
266
        av_assert0(0);
 
267
    }
 
268
 
 
269
    switch (p->filter_type) {
 
270
    case biquad:
 
271
        break;
 
272
    case equalizer:
 
273
        p->a0 =   1 + alpha / A;
 
274
        p->a1 =  -2 * cos(w0);
 
275
        p->a2 =   1 - alpha / A;
 
276
        p->b0 =   1 + alpha * A;
 
277
        p->b1 =  -2 * cos(w0);
 
278
        p->b2 =   1 - alpha * A;
 
279
        break;
 
280
    case bass:
 
281
        p->a0 =          (A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;
 
282
        p->a1 =    -2 * ((A - 1) + (A + 1) * cos(w0));
 
283
        p->a2 =          (A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;
 
284
        p->b0 =     A * ((A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);
 
285
        p->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));
 
286
        p->b2 =     A * ((A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);
 
287
        break;
 
288
    case treble:
 
289
        p->a0 =          (A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;
 
290
        p->a1 =     2 * ((A - 1) - (A + 1) * cos(w0));
 
291
        p->a2 =          (A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;
 
292
        p->b0 =     A * ((A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);
 
293
        p->b1 =-2 * A * ((A - 1) + (A + 1) * cos(w0));
 
294
        p->b2 =     A * ((A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);
 
295
        break;
 
296
    case bandpass:
 
297
        if (p->csg) {
 
298
            p->a0 =  1 + alpha;
 
299
            p->a1 = -2 * cos(w0);
 
300
            p->a2 =  1 - alpha;
 
301
            p->b0 =  sin(w0) / 2;
 
302
            p->b1 =  0;
 
303
            p->b2 = -sin(w0) / 2;
 
304
        } else {
 
305
            p->a0 =  1 + alpha;
 
306
            p->a1 = -2 * cos(w0);
 
307
            p->a2 =  1 - alpha;
 
308
            p->b0 =  alpha;
 
309
            p->b1 =  0;
 
310
            p->b2 = -alpha;
 
311
        }
 
312
        break;
 
313
    case bandreject:
 
314
        p->a0 =  1 + alpha;
 
315
        p->a1 = -2 * cos(w0);
 
316
        p->a2 =  1 - alpha;
 
317
        p->b0 =  1;
 
318
        p->b1 = -2 * cos(w0);
 
319
        p->b2 =  1;
 
320
        break;
 
321
    case lowpass:
 
322
        if (p->poles == 1) {
 
323
            p->a0 = 1;
 
324
            p->a1 = -exp(-w0);
 
325
            p->a2 = 0;
 
326
            p->b0 = 1 + p->a1;
 
327
            p->b1 = 0;
 
328
            p->b2 = 0;
 
329
        } else {
 
330
            p->a0 =  1 + alpha;
 
331
            p->a1 = -2 * cos(w0);
 
332
            p->a2 =  1 - alpha;
 
333
            p->b0 = (1 - cos(w0)) / 2;
 
334
            p->b1 =  1 - cos(w0);
 
335
            p->b2 = (1 - cos(w0)) / 2;
 
336
        }
 
337
        break;
 
338
    case highpass:
 
339
        if (p->poles == 1) {
 
340
            p->a0 = 1;
 
341
            p->a1 = -exp(-w0);
 
342
            p->a2 = 0;
 
343
            p->b0 = (1 - p->a1) / 2;
 
344
            p->b1 = -p->b0;
 
345
            p->b2 = 0;
 
346
        } else {
 
347
            p->a0 =   1 + alpha;
 
348
            p->a1 =  -2 * cos(w0);
 
349
            p->a2 =   1 - alpha;
 
350
            p->b0 =  (1 + cos(w0)) / 2;
 
351
            p->b1 = -(1 + cos(w0));
 
352
            p->b2 =  (1 + cos(w0)) / 2;
 
353
        }
 
354
        break;
 
355
    case allpass:
 
356
        p->a0 =  1 + alpha;
 
357
        p->a1 = -2 * cos(w0);
 
358
        p->a2 =  1 - alpha;
 
359
        p->b0 =  1 - alpha;
 
360
        p->b1 = -2 * cos(w0);
 
361
        p->b2 =  1 + alpha;
 
362
        break;
 
363
    default:
 
364
        av_assert0(0);
 
365
    }
 
366
 
 
367
    p->a1 /= p->a0;
 
368
    p->a2 /= p->a0;
 
369
    p->b0 /= p->a0;
 
370
    p->b1 /= p->a0;
 
371
    p->b2 /= p->a0;
 
372
 
 
373
    p->cache = av_realloc_f(p->cache, sizeof(ChanCache), inlink->channels);
 
374
    if (!p->cache)
 
375
        return AVERROR(ENOMEM);
 
376
    memset(p->cache, 0, sizeof(ChanCache) * inlink->channels);
 
377
 
 
378
    switch (inlink->format) {
 
379
    case AV_SAMPLE_FMT_S16P: p->filter = biquad_s16; break;
 
380
    case AV_SAMPLE_FMT_S32P: p->filter = biquad_s32; break;
 
381
    case AV_SAMPLE_FMT_FLTP: p->filter = biquad_flt; break;
 
382
    case AV_SAMPLE_FMT_DBLP: p->filter = biquad_dbl; break;
 
383
    default: av_assert0(0);
 
384
    }
 
385
 
 
386
    return 0;
 
387
}
 
388
 
 
389
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
 
390
{
 
391
    BiquadsContext *p       = inlink->dst->priv;
 
392
    AVFilterLink *outlink   = inlink->dst->outputs[0];
 
393
    AVFrame *out_buf;
 
394
    int nb_samples = buf->nb_samples;
 
395
    int ch;
 
396
 
 
397
    if (av_frame_is_writable(buf)) {
 
398
        out_buf = buf;
 
399
    } else {
 
400
        out_buf = ff_get_audio_buffer(inlink, nb_samples);
 
401
        if (!out_buf)
 
402
            return AVERROR(ENOMEM);
 
403
        av_frame_copy_props(out_buf, buf);
 
404
    }
 
405
 
 
406
    for (ch = 0; ch < av_frame_get_channels(buf); ch++)
 
407
        p->filter(buf->extended_data[ch],
 
408
                  out_buf->extended_data[ch], nb_samples,
 
409
                  &p->cache[ch].i1, &p->cache[ch].i2,
 
410
                  &p->cache[ch].o1, &p->cache[ch].o2,
 
411
                  p->b0, p->b1, p->b2, p->a1, p->a2);
 
412
 
 
413
    if (buf != out_buf)
 
414
        av_frame_free(&buf);
 
415
 
 
416
    return ff_filter_frame(outlink, out_buf);
 
417
}
 
418
 
 
419
static av_cold void uninit(AVFilterContext *ctx)
 
420
{
 
421
    BiquadsContext *p = ctx->priv;
 
422
 
 
423
    av_freep(&p->cache);
 
424
}
 
425
 
 
426
static const AVFilterPad inputs[] = {
 
427
    {
 
428
        .name         = "default",
 
429
        .type         = AVMEDIA_TYPE_AUDIO,
 
430
        .filter_frame = filter_frame,
 
431
    },
 
432
    { NULL }
 
433
};
 
434
 
 
435
static const AVFilterPad outputs[] = {
 
436
    {
 
437
        .name         = "default",
 
438
        .type         = AVMEDIA_TYPE_AUDIO,
 
439
        .config_props = config_output,
 
440
    },
 
441
    { NULL }
 
442
};
 
443
 
 
444
#define OFFSET(x) offsetof(BiquadsContext, x)
 
445
#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 
446
 
 
447
#define DEFINE_BIQUAD_FILTER(name_, description_)                       \
 
448
AVFILTER_DEFINE_CLASS(name_);                                           \
 
449
static av_cold int name_##_init(AVFilterContext *ctx) \
 
450
{                                                                       \
 
451
    BiquadsContext *p = ctx->priv;                                      \
 
452
    p->class = &name_##_class;                                          \
 
453
    p->filter_type = name_;                                             \
 
454
    return init(ctx);                                             \
 
455
}                                                                       \
 
456
                                                         \
 
457
AVFilter ff_af_##name_ = {                         \
 
458
    .name          = #name_,                             \
 
459
    .description   = NULL_IF_CONFIG_SMALL(description_), \
 
460
    .priv_size     = sizeof(BiquadsContext),             \
 
461
    .init          = name_##_init,                       \
 
462
    .uninit        = uninit,                             \
 
463
    .query_formats = query_formats,                      \
 
464
    .inputs        = inputs,                             \
 
465
    .outputs       = outputs,                            \
 
466
    .priv_class    = &name_##_class,                     \
 
467
}
 
468
 
 
469
#if CONFIG_EQUALIZER_FILTER
 
470
static const AVOption equalizer_options[] = {
 
471
    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
 
472
    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
 
473
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
 
474
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
475
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
476
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
477
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
478
    {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},
 
479
    {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},
 
480
    {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 
481
    {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 
482
    {NULL}
 
483
};
 
484
 
 
485
DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");
 
486
#endif  /* CONFIG_EQUALIZER_FILTER */
 
487
#if CONFIG_BASS_FILTER
 
488
static const AVOption bass_options[] = {
 
489
    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
 
490
    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
 
491
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
 
492
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
493
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
494
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
495
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
496
    {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 
497
    {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 
498
    {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 
499
    {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 
500
    {NULL}
 
501
};
 
502
 
 
503
DEFINE_BIQUAD_FILTER(bass, "Boost or cut lower frequencies.");
 
504
#endif  /* CONFIG_BASS_FILTER */
 
505
#if CONFIG_TREBLE_FILTER
 
506
static const AVOption treble_options[] = {
 
507
    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
508
    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
509
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
 
510
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
511
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
512
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
513
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
514
    {"width", "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 
515
    {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
 
516
    {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 
517
    {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
 
518
    {NULL}
 
519
};
 
520
 
 
521
DEFINE_BIQUAD_FILTER(treble, "Boost or cut upper frequencies.");
 
522
#endif  /* CONFIG_TREBLE_FILTER */
 
523
#if CONFIG_BANDPASS_FILTER
 
524
static const AVOption bandpass_options[] = {
 
525
    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
526
    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
527
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
 
528
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
529
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
530
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
531
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
532
    {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 
533
    {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 
534
    {"csg",   "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
 
535
    {NULL}
 
536
};
 
537
 
 
538
DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");
 
539
#endif  /* CONFIG_BANDPASS_FILTER */
 
540
#if CONFIG_BANDREJECT_FILTER
 
541
static const AVOption bandreject_options[] = {
 
542
    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
543
    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
544
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
 
545
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
546
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
547
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
548
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
549
    {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 
550
    {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
 
551
    {NULL}
 
552
};
 
553
 
 
554
DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");
 
555
#endif  /* CONFIG_BANDREJECT_FILTER */
 
556
#if CONFIG_LOWPASS_FILTER
 
557
static const AVOption lowpass_options[] = {
 
558
    {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
 
559
    {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
 
560
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
 
561
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
562
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
563
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
564
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
565
    {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 
566
    {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 
567
    {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 
568
    {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 
569
    {NULL}
 
570
};
 
571
 
 
572
DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");
 
573
#endif  /* CONFIG_LOWPASS_FILTER */
 
574
#if CONFIG_HIGHPASS_FILTER
 
575
static const AVOption highpass_options[] = {
 
576
    {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
577
    {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
578
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
 
579
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
580
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
581
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
582
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
583
    {"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 
584
    {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
 
585
    {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 
586
    {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
 
587
    {NULL}
 
588
};
 
589
 
 
590
DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");
 
591
#endif  /* CONFIG_HIGHPASS_FILTER */
 
592
#if CONFIG_ALLPASS_FILTER
 
593
static const AVOption allpass_options[] = {
 
594
    {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
595
    {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
 
596
    {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, SLOPE, FLAGS, "width_type"},
 
597
    {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
 
598
    {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
 
599
    {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
 
600
    {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
 
601
    {"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
 
602
    {"w",     "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
 
603
    {NULL}
 
604
};
 
605
 
 
606
DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");
 
607
#endif  /* CONFIG_ALLPASS_FILTER */
 
608
#if CONFIG_BIQUAD_FILTER
 
609
static const AVOption biquad_options[] = {
 
610
    {"a0", NULL, OFFSET(a0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
 
611
    {"a1", NULL, OFFSET(a1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
 
612
    {"a2", NULL, OFFSET(a2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
 
613
    {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
 
614
    {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
 
615
    {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
 
616
    {NULL}
 
617
};
 
618
 
 
619
DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");
 
620
#endif  /* CONFIG_BIQUAD_FILTER */