GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/af_anlms.c Lines: 0 127 0.0 %
Date: 2020-08-14 10:39:37 Branches: 0 77 0.0 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2019 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
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/avassert.h"
22
#include "libavutil/channel_layout.h"
23
#include "libavutil/common.h"
24
#include "libavutil/float_dsp.h"
25
#include "libavutil/opt.h"
26
27
#include "audio.h"
28
#include "avfilter.h"
29
#include "formats.h"
30
#include "filters.h"
31
#include "internal.h"
32
33
enum OutModes {
34
    IN_MODE,
35
    DESIRED_MODE,
36
    OUT_MODE,
37
    NOISE_MODE,
38
    NB_OMODES
39
};
40
41
typedef struct AudioNLMSContext {
42
    const AVClass *class;
43
44
    int order;
45
    float mu;
46
    float eps;
47
    float leakage;
48
    int output_mode;
49
50
    int kernel_size;
51
    AVFrame *offset;
52
    AVFrame *delay;
53
    AVFrame *coeffs;
54
    AVFrame *tmp;
55
56
    AVFrame *frame[2];
57
58
    AVFloatDSPContext *fdsp;
59
} AudioNLMSContext;
60
61
#define OFFSET(x) offsetof(AudioNLMSContext, x)
62
#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
63
#define AT AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
64
65
static const AVOption anlms_options[] = {
66
    { "order",   "set the filter order",   OFFSET(order),   AV_OPT_TYPE_INT,   {.i64=256},  1, INT16_MAX, A },
67
    { "mu",      "set the filter mu",      OFFSET(mu),      AV_OPT_TYPE_FLOAT, {.dbl=0.75}, 0, 2, AT },
68
    { "eps",     "set the filter eps",     OFFSET(eps),     AV_OPT_TYPE_FLOAT, {.dbl=1},    0, 1, AT },
69
    { "leakage", "set the filter leakage", OFFSET(leakage), AV_OPT_TYPE_FLOAT, {.dbl=0},    0, 1, AT },
70
    { "out_mode", "set output mode",       OFFSET(output_mode), AV_OPT_TYPE_INT, {.i64=OUT_MODE}, 0, NB_OMODES-1, AT, "mode" },
71
    {  "i", "input",                 0,          AV_OPT_TYPE_CONST,    {.i64=IN_MODE},      0, 0, AT, "mode" },
72
    {  "d", "desired",               0,          AV_OPT_TYPE_CONST,    {.i64=DESIRED_MODE}, 0, 0, AT, "mode" },
73
    {  "o", "output",                0,          AV_OPT_TYPE_CONST,    {.i64=OUT_MODE},     0, 0, AT, "mode" },
74
    {  "n", "noise",                 0,          AV_OPT_TYPE_CONST,    {.i64=NOISE_MODE},   0, 0, AT, "mode" },
75
    { NULL }
76
};
77
78
AVFILTER_DEFINE_CLASS(anlms);
79
80
static int query_formats(AVFilterContext *ctx)
81
{
82
    AVFilterFormats *formats;
83
    AVFilterChannelLayouts *layouts;
84
    static const enum AVSampleFormat sample_fmts[] = {
85
        AV_SAMPLE_FMT_FLTP,
86
        AV_SAMPLE_FMT_NONE
87
    };
88
    int ret;
89
90
    layouts = ff_all_channel_counts();
91
    if (!layouts)
92
        return AVERROR(ENOMEM);
93
    ret = ff_set_common_channel_layouts(ctx, layouts);
94
    if (ret < 0)
95
        return ret;
96
97
    formats = ff_make_format_list(sample_fmts);
98
    if (!formats)
99
        return AVERROR(ENOMEM);
100
    ret = ff_set_common_formats(ctx, formats);
101
    if (ret < 0)
102
        return ret;
103
104
    formats = ff_all_samplerates();
105
    if (!formats)
106
        return AVERROR(ENOMEM);
107
    return ff_set_common_samplerates(ctx, formats);
108
}
109
110
static float fir_sample(AudioNLMSContext *s, float sample, float *delay,
111
                        float *coeffs, float *tmp, int *offset)
112
{
113
    const int order = s->order;
114
    float output;
115
116
    delay[*offset] = sample;
117
118
    memcpy(tmp, coeffs + order - *offset, order * sizeof(float));
119
120
    output = s->fdsp->scalarproduct_float(delay, tmp, s->kernel_size);
121
122
    if (--(*offset) < 0)
123
        *offset = order - 1;
124
125
    return output;
126
}
127
128
static float process_sample(AudioNLMSContext *s, float input, float desired,
129
                            float *delay, float *coeffs, float *tmp, int *offsetp)
130
{
131
    const int order = s->order;
132
    const float leakage = s->leakage;
133
    const float mu = s->mu;
134
    const float a = 1.f - leakage * mu;
135
    float sum, output, e, norm, b;
136
    int offset = *offsetp;
137
138
    delay[offset + order] = input;
139
140
    output = fir_sample(s, input, delay, coeffs, tmp, offsetp);
141
    e = desired - output;
142
143
    sum = s->fdsp->scalarproduct_float(delay, delay, s->kernel_size);
144
145
    norm = s->eps + sum;
146
    b = mu * e / norm;
147
148
    memcpy(tmp, delay + offset, order * sizeof(float));
149
150
    s->fdsp->vector_fmul_scalar(coeffs, coeffs, a, s->kernel_size);
151
152
    s->fdsp->vector_fmac_scalar(coeffs, tmp, b, s->kernel_size);
153
154
    memcpy(coeffs + order, coeffs, order * sizeof(float));
155
156
    switch (s->output_mode) {
157
    case IN_MODE:       output = input;         break;
158
    case DESIRED_MODE:  output = desired;       break;
159
    case OUT_MODE: /*output = output;*/         break;
160
    case NOISE_MODE: output = desired - output; break;
161
    }
162
    return output;
163
}
164
165
static int process_channels(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
166
{
167
    AudioNLMSContext *s = ctx->priv;
168
    AVFrame *out = arg;
169
    const int start = (out->channels * jobnr) / nb_jobs;
170
    const int end = (out->channels * (jobnr+1)) / nb_jobs;
171
172
    for (int c = start; c < end; c++) {
173
        const float *input = (const float *)s->frame[0]->extended_data[c];
174
        const float *desired = (const float *)s->frame[1]->extended_data[c];
175
        float *delay = (float *)s->delay->extended_data[c];
176
        float *coeffs = (float *)s->coeffs->extended_data[c];
177
        float *tmp = (float *)s->tmp->extended_data[c];
178
        int *offset = (int *)s->offset->extended_data[c];
179
        float *output = (float *)out->extended_data[c];
180
181
        for (int n = 0; n < out->nb_samples; n++)
182
            output[n] = process_sample(s, input[n], desired[n], delay, coeffs, tmp, offset);
183
    }
184
185
    return 0;
186
}
187
188
static int activate(AVFilterContext *ctx)
189
{
190
    AudioNLMSContext *s = ctx->priv;
191
    int i, ret, status;
192
    int nb_samples;
193
    int64_t pts;
194
195
    FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
196
197
    nb_samples = FFMIN(ff_inlink_queued_samples(ctx->inputs[0]),
198
                       ff_inlink_queued_samples(ctx->inputs[1]));
199
    for (i = 0; i < ctx->nb_inputs && nb_samples > 0; i++) {
200
        if (s->frame[i])
201
            continue;
202
203
        if (ff_inlink_check_available_samples(ctx->inputs[i], nb_samples) > 0) {
204
            ret = ff_inlink_consume_samples(ctx->inputs[i], nb_samples, nb_samples, &s->frame[i]);
205
            if (ret < 0)
206
                return ret;
207
        }
208
    }
209
210
    if (s->frame[0] && s->frame[1]) {
211
        AVFrame *out;
212
213
        out = ff_get_audio_buffer(ctx->outputs[0], s->frame[0]->nb_samples);
214
        if (!out) {
215
            av_frame_free(&s->frame[0]);
216
            av_frame_free(&s->frame[1]);
217
            return AVERROR(ENOMEM);
218
        }
219
220
        ctx->internal->execute(ctx, process_channels, out, NULL, FFMIN(ctx->outputs[0]->channels,
221
                                                                       ff_filter_get_nb_threads(ctx)));
222
223
        out->pts = s->frame[0]->pts;
224
225
        av_frame_free(&s->frame[0]);
226
        av_frame_free(&s->frame[1]);
227
228
        ret = ff_filter_frame(ctx->outputs[0], out);
229
        if (ret < 0)
230
            return ret;
231
    }
232
233
    if (!nb_samples) {
234
        for (i = 0; i < 2; i++) {
235
            if (ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts)) {
236
                ff_outlink_set_status(ctx->outputs[0], status, pts);
237
                return 0;
238
            }
239
        }
240
    }
241
242
    if (ff_outlink_frame_wanted(ctx->outputs[0])) {
243
        for (i = 0; i < 2; i++) {
244
            if (ff_inlink_queued_samples(ctx->inputs[i]) > 0)
245
                continue;
246
            ff_inlink_request_frame(ctx->inputs[i]);
247
            return 0;
248
        }
249
    }
250
    return 0;
251
}
252
253
static int config_output(AVFilterLink *outlink)
254
{
255
    AVFilterContext *ctx = outlink->src;
256
    AudioNLMSContext *s = ctx->priv;
257
258
    s->kernel_size = FFALIGN(s->order, 16);
259
260
    if (!s->offset)
261
        s->offset = ff_get_audio_buffer(outlink, 1);
262
    if (!s->delay)
263
        s->delay = ff_get_audio_buffer(outlink, 2 * s->kernel_size);
264
    if (!s->coeffs)
265
        s->coeffs = ff_get_audio_buffer(outlink, 2 * s->kernel_size);
266
    if (!s->tmp)
267
        s->tmp = ff_get_audio_buffer(outlink, s->kernel_size);
268
    if (!s->delay || !s->coeffs || !s->offset || !s->tmp)
269
        return AVERROR(ENOMEM);
270
271
    return 0;
272
}
273
274
static av_cold int init(AVFilterContext *ctx)
275
{
276
    AudioNLMSContext *s = ctx->priv;
277
278
    s->fdsp = avpriv_float_dsp_alloc(0);
279
    if (!s->fdsp)
280
        return AVERROR(ENOMEM);
281
282
    return 0;
283
}
284
285
static av_cold void uninit(AVFilterContext *ctx)
286
{
287
    AudioNLMSContext *s = ctx->priv;
288
289
    av_freep(&s->fdsp);
290
    av_frame_free(&s->delay);
291
    av_frame_free(&s->coeffs);
292
    av_frame_free(&s->offset);
293
    av_frame_free(&s->tmp);
294
}
295
296
static const AVFilterPad inputs[] = {
297
    {
298
        .name = "input",
299
        .type = AVMEDIA_TYPE_AUDIO,
300
    },
301
    {
302
        .name = "desired",
303
        .type = AVMEDIA_TYPE_AUDIO,
304
    },
305
    { NULL }
306
};
307
308
static const AVFilterPad outputs[] = {
309
    {
310
        .name         = "default",
311
        .type         = AVMEDIA_TYPE_AUDIO,
312
        .config_props = config_output,
313
    },
314
    { NULL }
315
};
316
317
AVFilter ff_af_anlms = {
318
    .name           = "anlms",
319
    .description    = NULL_IF_CONFIG_SMALL("Apply Normalized Least-Mean-Squares algorithm to first audio stream."),
320
    .priv_size      = sizeof(AudioNLMSContext),
321
    .priv_class     = &anlms_class,
322
    .init           = init,
323
    .uninit         = uninit,
324
    .activate       = activate,
325
    .query_formats  = query_formats,
326
    .inputs         = inputs,
327
    .outputs        = outputs,
328
    .flags          = AVFILTER_FLAG_SLICE_THREADS,
329
    .process_command = ff_filter_process_command,
330
};