GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/asrc_afirsrc.c Lines: 0 123 0.0 %
Date: 2020-10-23 17:01:47 Branches: 0 72 0.0 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2020 Paul B Mahol
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 License
8
 * 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
14
 * GNU Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public License
17
 * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
18
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
#include "libavutil/eval.h"
22
#include "libavutil/opt.h"
23
#include "libavutil/tx.h"
24
#include "audio.h"
25
#include "avfilter.h"
26
#include "internal.h"
27
#include "window_func.h"
28
29
typedef struct AudioFIRSourceContext {
30
    const AVClass *class;
31
32
    char *freq_points_str;
33
    char *magnitude_str;
34
    char *phase_str;
35
    int nb_taps;
36
    int sample_rate;
37
    int nb_samples;
38
    int win_func;
39
40
    AVComplexFloat *complexf;
41
    float *freq;
42
    float *magnitude;
43
    float *phase;
44
    int freq_size;
45
    int magnitude_size;
46
    int phase_size;
47
    int nb_freq;
48
    int nb_magnitude;
49
    int nb_phase;
50
51
    float *taps;
52
    float *win;
53
    int64_t pts;
54
55
    AVTXContext *tx_ctx;
56
    av_tx_fn tx_fn;
57
} AudioFIRSourceContext;
58
59
#define OFFSET(x) offsetof(AudioFIRSourceContext, x)
60
#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
61
62
static const AVOption afirsrc_options[] = {
63
    { "taps",      "set number of taps",   OFFSET(nb_taps),         AV_OPT_TYPE_INT,    {.i64=1025}, 9, UINT16_MAX, FLAGS },
64
    { "t",         "set number of taps",   OFFSET(nb_taps),         AV_OPT_TYPE_INT,    {.i64=1025}, 9, UINT16_MAX, FLAGS },
65
    { "frequency", "set frequency points", OFFSET(freq_points_str), AV_OPT_TYPE_STRING, {.str="0 1"}, 0, 0, FLAGS },
66
    { "f",         "set frequency points", OFFSET(freq_points_str), AV_OPT_TYPE_STRING, {.str="0 1"}, 0, 0, FLAGS },
67
    { "magnitude", "set magnitude values", OFFSET(magnitude_str),   AV_OPT_TYPE_STRING, {.str="1 1"}, 0, 0, FLAGS },
68
    { "m",         "set magnitude values", OFFSET(magnitude_str),   AV_OPT_TYPE_STRING, {.str="1 1"}, 0, 0, FLAGS },
69
    { "phase",     "set phase values",     OFFSET(phase_str),       AV_OPT_TYPE_STRING, {.str="0 0"}, 0, 0, FLAGS },
70
    { "p",         "set phase values",     OFFSET(phase_str),       AV_OPT_TYPE_STRING, {.str="0 0"}, 0, 0, FLAGS },
71
    { "sample_rate", "set sample rate",    OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100},  1, INT_MAX,    FLAGS },
72
    { "r",           "set sample rate",    OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100},  1, INT_MAX,    FLAGS },
73
    { "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
74
    { "n",          "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
75
    { "win_func", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" },
76
    { "w",        "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64=WFUNC_BLACKMAN}, 0, NB_WFUNC-1, FLAGS, "win_func" },
77
        { "rect",     "Rectangular",      0, AV_OPT_TYPE_CONST, {.i64=WFUNC_RECT},     0, 0, FLAGS, "win_func" },
78
        { "bartlett", "Bartlett",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BARTLETT}, 0, 0, FLAGS, "win_func" },
79
        { "hanning",  "Hanning",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HANNING},  0, 0, FLAGS, "win_func" },
80
        { "hamming",  "Hamming",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HAMMING},  0, 0, FLAGS, "win_func" },
81
        { "blackman", "Blackman",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BLACKMAN}, 0, 0, FLAGS, "win_func" },
82
        { "welch",    "Welch",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_WELCH},    0, 0, FLAGS, "win_func" },
83
        { "flattop",  "Flat-top",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_FLATTOP},  0, 0, FLAGS, "win_func" },
84
        { "bharris",  "Blackman-Harris",  0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHARRIS},  0, 0, FLAGS, "win_func" },
85
        { "bnuttall", "Blackman-Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BNUTTALL}, 0, 0, FLAGS, "win_func" },
86
        { "bhann",    "Bartlett-Hann",    0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHANN},    0, 0, FLAGS, "win_func" },
87
        { "sine",     "Sine",             0, AV_OPT_TYPE_CONST, {.i64=WFUNC_SINE},     0, 0, FLAGS, "win_func" },
88
        { "nuttall",  "Nuttall",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_NUTTALL},  0, 0, FLAGS, "win_func" },
89
        { "lanczos",  "Lanczos",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_LANCZOS},  0, 0, FLAGS, "win_func" },
90
        { "gauss",    "Gauss",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_GAUSS},    0, 0, FLAGS, "win_func" },
91
        { "tukey",    "Tukey",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_TUKEY},    0, 0, FLAGS, "win_func" },
92
        { "dolph",    "Dolph-Chebyshev",  0, AV_OPT_TYPE_CONST, {.i64=WFUNC_DOLPH},    0, 0, FLAGS, "win_func" },
93
        { "cauchy",   "Cauchy",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_CAUCHY},   0, 0, FLAGS, "win_func" },
94
        { "parzen",   "Parzen",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_PARZEN},   0, 0, FLAGS, "win_func" },
95
        { "poisson",  "Poisson",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_POISSON},  0, 0, FLAGS, "win_func" },
96
        { "bohman" ,  "Bohman",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BOHMAN},   0, 0, FLAGS, "win_func" },
97
    {NULL}
98
};
99
100
AVFILTER_DEFINE_CLASS(afirsrc);
101
102
static av_cold int init(AVFilterContext *ctx)
103
{
104
    AudioFIRSourceContext *s = ctx->priv;
105
106
    if (!(s->nb_taps & 1)) {
107
        av_log(s, AV_LOG_WARNING, "Number of taps %d must be odd length.\n", s->nb_taps);
108
        s->nb_taps |= 1;
109
    }
110
111
    return 0;
112
}
113
114
static av_cold void uninit(AVFilterContext *ctx)
115
{
116
    AudioFIRSourceContext *s = ctx->priv;
117
118
    av_freep(&s->win);
119
    av_freep(&s->taps);
120
    av_freep(&s->freq);
121
    av_freep(&s->magnitude);
122
    av_freep(&s->phase);
123
    av_freep(&s->complexf);
124
    av_tx_uninit(&s->tx_ctx);
125
}
126
127
static av_cold int query_formats(AVFilterContext *ctx)
128
{
129
    AudioFIRSourceContext *s = ctx->priv;
130
    static const int64_t chlayouts[] = { AV_CH_LAYOUT_MONO, -1 };
131
    int sample_rates[] = { s->sample_rate, -1 };
132
    static const enum AVSampleFormat sample_fmts[] = {
133
        AV_SAMPLE_FMT_FLT,
134
        AV_SAMPLE_FMT_NONE
135
    };
136
137
    AVFilterFormats *formats;
138
    AVFilterChannelLayouts *layouts;
139
    int ret;
140
141
    formats = ff_make_format_list(sample_fmts);
142
    if (!formats)
143
        return AVERROR(ENOMEM);
144
    ret = ff_set_common_formats (ctx, formats);
145
    if (ret < 0)
146
        return ret;
147
148
    layouts = ff_make_format64_list(chlayouts);
149
    if (!layouts)
150
        return AVERROR(ENOMEM);
151
    ret = ff_set_common_channel_layouts(ctx, layouts);
152
    if (ret < 0)
153
        return ret;
154
155
    formats = ff_make_format_list(sample_rates);
156
    if (!formats)
157
        return AVERROR(ENOMEM);
158
    return ff_set_common_samplerates(ctx, formats);
159
}
160
161
static int parse_string(char *str, float **items, int *nb_items, int *items_size)
162
{
163
    float *new_items;
164
    char *tail;
165
166
    new_items = av_fast_realloc(NULL, items_size, 1 * sizeof(float));
167
    if (!new_items)
168
        return AVERROR(ENOMEM);
169
    *items = new_items;
170
171
    tail = str;
172
    if (!tail)
173
        return AVERROR(EINVAL);
174
175
    do {
176
        (*items)[(*nb_items)++] = av_strtod(tail, &tail);
177
        new_items = av_fast_realloc(*items, items_size, (*nb_items + 1) * sizeof(float));
178
        if (!new_items)
179
            return AVERROR(ENOMEM);
180
        *items = new_items;
181
        if (tail && *tail)
182
            tail++;
183
    } while (tail && *tail);
184
185
    return 0;
186
}
187
188
static void lininterp(AVComplexFloat *complexf,
189
                      const float *freq,
190
                      const float *magnitude,
191
                      const float *phase,
192
                      int m, int minterp)
193
{
194
    for (int i = 0; i < minterp; i++) {
195
        for (int j = 1; j < m; j++) {
196
            const float x = i / (float)minterp;
197
198
            if (x <= freq[j]) {
199
                const float mg = (x - freq[j-1]) / (freq[j] - freq[j-1]) * (magnitude[j] - magnitude[j-1]) + magnitude[j-1];
200
                const float ph = (x - freq[j-1]) / (freq[j] - freq[j-1]) * (phase[j] - phase[j-1]) + phase[j-1];
201
202
                complexf[i].re = mg * cosf(ph);
203
                complexf[i].im = mg * sinf(ph);
204
                break;
205
            }
206
        }
207
    }
208
}
209
210
static av_cold int config_output(AVFilterLink *outlink)
211
{
212
    AVFilterContext *ctx = outlink->src;
213
    AudioFIRSourceContext *s = ctx->priv;
214
    float overlap, scale = 1.f, compensation;
215
    int fft_size, middle, ret;
216
217
    s->nb_freq = s->nb_magnitude = s->nb_phase = 0;
218
219
    ret = parse_string(s->freq_points_str, &s->freq, &s->nb_freq, &s->freq_size);
220
    if (ret < 0)
221
        return ret;
222
223
    ret = parse_string(s->magnitude_str, &s->magnitude, &s->nb_magnitude, &s->magnitude_size);
224
    if (ret < 0)
225
        return ret;
226
227
    ret = parse_string(s->phase_str, &s->phase, &s->nb_phase, &s->phase_size);
228
    if (ret < 0)
229
        return ret;
230
231
    if (s->nb_freq != s->nb_magnitude && s->nb_freq != s->nb_phase && s->nb_freq >= 2) {
232
        av_log(ctx, AV_LOG_ERROR, "Number of frequencies, magnitudes and phases must be same and >= 2.\n");
233
        return AVERROR(EINVAL);
234
    }
235
236
    for (int i = 0; i < s->nb_freq; i++) {
237
        if (i == 0 && s->freq[i] != 0.f) {
238
            av_log(ctx, AV_LOG_ERROR, "First frequency must be 0.\n");
239
            return AVERROR(EINVAL);
240
        }
241
242
        if (i == s->nb_freq - 1 && s->freq[i] != 1.f) {
243
            av_log(ctx, AV_LOG_ERROR, "Last frequency must be 1.\n");
244
            return AVERROR(EINVAL);
245
        }
246
247
        if (i && s->freq[i] < s->freq[i-1]) {
248
            av_log(ctx, AV_LOG_ERROR, "Frequencies must be in increasing order.\n");
249
            return AVERROR(EINVAL);
250
        }
251
    }
252
253
    fft_size = 1 << (av_log2(s->nb_taps) + 1);
254
    s->complexf = av_calloc(fft_size * 2, sizeof(*s->complexf));
255
    if (!s->complexf)
256
        return AVERROR(ENOMEM);
257
258
    ret = av_tx_init(&s->tx_ctx, &s->tx_fn, AV_TX_FLOAT_FFT, 1, fft_size, &scale, 0);
259
    if (ret < 0)
260
        return ret;
261
262
    s->taps = av_calloc(s->nb_taps, sizeof(*s->taps));
263
    if (!s->taps)
264
        return AVERROR(ENOMEM);
265
266
    s->win = av_calloc(s->nb_taps, sizeof(*s->win));
267
    if (!s->win)
268
        return AVERROR(ENOMEM);
269
270
    generate_window_func(s->win, s->nb_taps, s->win_func, &overlap);
271
272
    lininterp(s->complexf, s->freq, s->magnitude, s->phase, s->nb_freq, fft_size / 2);
273
274
    s->tx_fn(s->tx_ctx, s->complexf + fft_size, s->complexf, sizeof(float));
275
276
    compensation = 2.f / fft_size;
277
    middle = s->nb_taps / 2;
278
279
    for (int i = 0; i <= middle; i++) {
280
        s->taps[         i] = s->complexf[fft_size + middle - i].re * compensation * s->win[i];
281
        s->taps[middle + i] = s->complexf[fft_size          + i].re * compensation * s->win[middle + i];
282
    }
283
284
    s->pts = 0;
285
286
    return 0;
287
}
288
289
static int request_frame(AVFilterLink *outlink)
290
{
291
    AVFilterContext *ctx = outlink->src;
292
    AudioFIRSourceContext *s = ctx->priv;
293
    AVFrame *frame;
294
    int nb_samples;
295
296
    nb_samples = FFMIN(s->nb_samples, s->nb_taps - s->pts);
297
    if (!nb_samples)
298
        return AVERROR_EOF;
299
300
    if (!(frame = ff_get_audio_buffer(outlink, nb_samples)))
301
        return AVERROR(ENOMEM);
302
303
    memcpy(frame->data[0], s->taps + s->pts, nb_samples * sizeof(float));
304
305
    frame->pts = s->pts;
306
    s->pts    += nb_samples;
307
    return ff_filter_frame(outlink, frame);
308
}
309
310
static const AVFilterPad afirsrc_outputs[] = {
311
    {
312
        .name          = "default",
313
        .type          = AVMEDIA_TYPE_AUDIO,
314
        .request_frame = request_frame,
315
        .config_props  = config_output,
316
    },
317
    { NULL }
318
};
319
320
AVFilter ff_asrc_afirsrc = {
321
    .name          = "afirsrc",
322
    .description   = NULL_IF_CONFIG_SMALL("Generate a FIR coefficients audio stream."),
323
    .query_formats = query_formats,
324
    .init          = init,
325
    .uninit        = uninit,
326
    .priv_size     = sizeof(AudioFIRSourceContext),
327
    .inputs        = NULL,
328
    .outputs       = afirsrc_outputs,
329
    .priv_class    = &afirsrc_class,
330
};