GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/af_adeclick.c Lines: 0 386 0.0 %
Date: 2021-04-14 23:45:22 Branches: 0 248 0.0 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2018 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/audio_fifo.h"
22
#include "libavutil/opt.h"
23
#include "avfilter.h"
24
#include "audio.h"
25
#include "filters.h"
26
#include "formats.h"
27
#include "internal.h"
28
29
typedef struct DeclickChannel {
30
    double *auxiliary;
31
    double *detection;
32
    double *acoefficients;
33
    double *acorrelation;
34
    double *tmp;
35
    double *interpolated;
36
    double *matrix;
37
    int matrix_size;
38
    double *vector;
39
    int vector_size;
40
    double *y;
41
    int y_size;
42
    uint8_t *click;
43
    int *index;
44
    unsigned *histogram;
45
    int histogram_size;
46
} DeclickChannel;
47
48
typedef struct AudioDeclickContext {
49
    const AVClass *class;
50
51
    double w;
52
    double overlap;
53
    double threshold;
54
    double ar;
55
    double burst;
56
    int method;
57
    int nb_hbins;
58
59
    int is_declip;
60
    int ar_order;
61
    int nb_burst_samples;
62
    int window_size;
63
    int hop_size;
64
    int overlap_skip;
65
66
    AVFrame *enabled;
67
    AVFrame *in;
68
    AVFrame *out;
69
    AVFrame *buffer;
70
    AVFrame *is;
71
72
    DeclickChannel *chan;
73
74
    int64_t pts;
75
    int nb_channels;
76
    uint64_t nb_samples;
77
    uint64_t detected_errors;
78
    int samples_left;
79
    int eof;
80
81
    AVAudioFifo *efifo;
82
    AVAudioFifo *fifo;
83
    double *window_func_lut;
84
85
    int (*detector)(struct AudioDeclickContext *s, DeclickChannel *c,
86
                    double sigmae, double *detection,
87
                    double *acoefficients, uint8_t *click, int *index,
88
                    const double *src, double *dst);
89
} AudioDeclickContext;
90
91
#define OFFSET(x) offsetof(AudioDeclickContext, x)
92
#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
93
94
static const AVOption adeclick_options[] = {
95
    { "window", "set window size",     OFFSET(w),         AV_OPT_TYPE_DOUBLE, {.dbl=55}, 10,  100, AF },
96
    { "w", "set window size",          OFFSET(w),         AV_OPT_TYPE_DOUBLE, {.dbl=55}, 10,  100, AF },
97
    { "overlap", "set window overlap", OFFSET(overlap),   AV_OPT_TYPE_DOUBLE, {.dbl=75}, 50,   95, AF },
98
    { "o", "set window overlap",       OFFSET(overlap),   AV_OPT_TYPE_DOUBLE, {.dbl=75}, 50,   95, AF },
99
    { "arorder", "set autoregression order", OFFSET(ar),  AV_OPT_TYPE_DOUBLE, {.dbl=2},   0,   25, AF },
100
    { "a", "set autoregression order", OFFSET(ar),        AV_OPT_TYPE_DOUBLE, {.dbl=2},   0,   25, AF },
101
    { "threshold", "set threshold",    OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=2},   1,  100, AF },
102
    { "t", "set threshold",            OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=2},   1,  100, AF },
103
    { "burst", "set burst fusion",     OFFSET(burst),     AV_OPT_TYPE_DOUBLE, {.dbl=2},   0,   10, AF },
104
    { "b", "set burst fusion",         OFFSET(burst),     AV_OPT_TYPE_DOUBLE, {.dbl=2},   0,   10, AF },
105
    { "method", "set overlap method",  OFFSET(method),    AV_OPT_TYPE_INT,    {.i64=0},   0,    1, AF, "m" },
106
    { "m", "set overlap method",       OFFSET(method),    AV_OPT_TYPE_INT,    {.i64=0},   0,    1, AF, "m" },
107
    { "add", "overlap-add",            0,                 AV_OPT_TYPE_CONST,  {.i64=0},   0,    0, AF, "m" },
108
    { "a", "overlap-add",              0,                 AV_OPT_TYPE_CONST,  {.i64=0},   0,    0, AF, "m" },
109
    { "save", "overlap-save",          0,                 AV_OPT_TYPE_CONST,  {.i64=1},   0,    0, AF, "m" },
110
    { "s", "overlap-save",             0,                 AV_OPT_TYPE_CONST,  {.i64=1},   0,    0, AF, "m" },
111
    { NULL }
112
};
113
114
AVFILTER_DEFINE_CLASS(adeclick);
115
116
static int query_formats(AVFilterContext *ctx)
117
{
118
    AVFilterFormats *formats = NULL;
119
    AVFilterChannelLayouts *layouts = NULL;
120
    static const enum AVSampleFormat sample_fmts[] = {
121
        AV_SAMPLE_FMT_DBLP,
122
        AV_SAMPLE_FMT_NONE
123
    };
124
    int ret;
125
126
    formats = ff_make_format_list(sample_fmts);
127
    if (!formats)
128
        return AVERROR(ENOMEM);
129
    ret = ff_set_common_formats(ctx, formats);
130
    if (ret < 0)
131
        return ret;
132
133
    layouts = ff_all_channel_counts();
134
    if (!layouts)
135
        return AVERROR(ENOMEM);
136
137
    ret = ff_set_common_channel_layouts(ctx, layouts);
138
    if (ret < 0)
139
        return ret;
140
141
    formats = ff_all_samplerates();
142
    return ff_set_common_samplerates(ctx, formats);
143
}
144
145
static int config_input(AVFilterLink *inlink)
146
{
147
    AVFilterContext *ctx = inlink->dst;
148
    AudioDeclickContext *s = ctx->priv;
149
    int i;
150
151
    s->pts = AV_NOPTS_VALUE;
152
    s->window_size = inlink->sample_rate * s->w / 1000.;
153
    if (s->window_size < 100)
154
        return AVERROR(EINVAL);
155
    s->ar_order = FFMAX(s->window_size * s->ar / 100., 1);
156
    s->nb_burst_samples = s->window_size * s->burst / 1000.;
157
    s->hop_size = s->window_size * (1. - (s->overlap / 100.));
158
    if (s->hop_size < 1)
159
        return AVERROR(EINVAL);
160
161
    s->window_func_lut = av_calloc(s->window_size, sizeof(*s->window_func_lut));
162
    if (!s->window_func_lut)
163
        return AVERROR(ENOMEM);
164
    for (i = 0; i < s->window_size; i++)
165
        s->window_func_lut[i] = sin(M_PI * i / s->window_size) *
166
                                (1. - (s->overlap / 100.)) * M_PI_2;
167
168
    av_frame_free(&s->in);
169
    av_frame_free(&s->out);
170
    av_frame_free(&s->buffer);
171
    av_frame_free(&s->is);
172
    s->enabled = ff_get_audio_buffer(inlink, s->window_size);
173
    s->in = ff_get_audio_buffer(inlink, s->window_size);
174
    s->out = ff_get_audio_buffer(inlink, s->window_size);
175
    s->buffer = ff_get_audio_buffer(inlink, s->window_size * 2);
176
    s->is = ff_get_audio_buffer(inlink, s->window_size);
177
    if (!s->in || !s->out || !s->buffer || !s->is || !s->enabled)
178
        return AVERROR(ENOMEM);
179
180
    s->efifo = av_audio_fifo_alloc(inlink->format, 1, s->window_size);
181
    if (!s->efifo)
182
        return AVERROR(ENOMEM);
183
    s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->window_size);
184
    if (!s->fifo)
185
        return AVERROR(ENOMEM);
186
    s->overlap_skip = s->method ? (s->window_size - s->hop_size) / 2 : 0;
187
    if (s->overlap_skip > 0) {
188
        av_audio_fifo_write(s->fifo, (void **)s->in->extended_data,
189
                            s->overlap_skip);
190
    }
191
192
    s->nb_channels = inlink->channels;
193
    s->chan = av_calloc(inlink->channels, sizeof(*s->chan));
194
    if (!s->chan)
195
        return AVERROR(ENOMEM);
196
197
    for (i = 0; i < inlink->channels; i++) {
198
        DeclickChannel *c = &s->chan[i];
199
200
        c->detection = av_calloc(s->window_size, sizeof(*c->detection));
201
        c->auxiliary = av_calloc(s->ar_order + 1, sizeof(*c->auxiliary));
202
        c->acoefficients = av_calloc(s->ar_order + 1, sizeof(*c->acoefficients));
203
        c->acorrelation = av_calloc(s->ar_order + 1, sizeof(*c->acorrelation));
204
        c->tmp = av_calloc(s->ar_order, sizeof(*c->tmp));
205
        c->click = av_calloc(s->window_size, sizeof(*c->click));
206
        c->index = av_calloc(s->window_size, sizeof(*c->index));
207
        c->interpolated = av_calloc(s->window_size, sizeof(*c->interpolated));
208
        if (!c->auxiliary || !c->acoefficients || !c->detection || !c->click ||
209
            !c->index || !c->interpolated || !c->acorrelation || !c->tmp)
210
            return AVERROR(ENOMEM);
211
    }
212
213
    return 0;
214
}
215
216
static void autocorrelation(const double *input, int order, int size,
217
                            double *output, double scale)
218
{
219
    int i, j;
220
221
    for (i = 0; i <= order; i++) {
222
        double value = 0.;
223
224
        for (j = i; j < size; j++)
225
            value += input[j] * input[j - i];
226
227
        output[i] = value * scale;
228
    }
229
}
230
231
static double autoregression(const double *samples, int ar_order,
232
                             int nb_samples, double *k, double *r, double *a)
233
{
234
    double alpha;
235
    int i, j;
236
237
    memset(a, 0, ar_order * sizeof(*a));
238
239
    autocorrelation(samples, ar_order, nb_samples, r, 1. / nb_samples);
240
241
    /* Levinson-Durbin algorithm */
242
    k[0] = a[0] = -r[1] / r[0];
243
    alpha = r[0] * (1. - k[0] * k[0]);
244
    for (i = 1; i < ar_order; i++) {
245
        double epsilon = 0.;
246
247
        for (j = 0; j < i; j++)
248
            epsilon += a[j] * r[i - j];
249
        epsilon += r[i + 1];
250
251
        k[i] = -epsilon / alpha;
252
        alpha *= (1. - k[i] * k[i]);
253
        for (j = i - 1; j >= 0; j--)
254
            k[j] = a[j] + k[i] * a[i - j - 1];
255
        for (j = 0; j <= i; j++)
256
            a[j] = k[j];
257
    }
258
259
    k[0] = 1.;
260
    for (i = 1; i <= ar_order; i++)
261
        k[i] = a[i - 1];
262
263
    return sqrt(alpha);
264
}
265
266
static int isfinite_array(double *samples, int nb_samples)
267
{
268
    int i;
269
270
    for (i = 0; i < nb_samples; i++)
271
        if (!isfinite(samples[i]))
272
            return 0;
273
274
    return 1;
275
}
276
277
static int find_index(int *index, int value, int size)
278
{
279
    int i, start, end;
280
281
    if ((value < index[0]) || (value > index[size - 1]))
282
        return 1;
283
284
    i = start = 0;
285
    end = size - 1;
286
287
    while (start <= end) {
288
        i = (end + start) / 2;
289
        if (index[i] == value)
290
            return 0;
291
        if (value < index[i])
292
            end = i - 1;
293
        if (value > index[i])
294
            start = i + 1;
295
    }
296
297
    return 1;
298
}
299
300
static int factorization(double *matrix, int n)
301
{
302
    int i, j, k;
303
304
    for (i = 0; i < n; i++) {
305
        const int in = i * n;
306
        double value;
307
308
        value = matrix[in + i];
309
        for (j = 0; j < i; j++)
310
            value -= matrix[j * n + j] * matrix[in + j] * matrix[in + j];
311
312
        if (value == 0.) {
313
            return -1;
314
        }
315
316
        matrix[in + i] = value;
317
        for (j = i + 1; j < n; j++) {
318
            const int jn = j * n;
319
            double x;
320
321
            x = matrix[jn + i];
322
            for (k = 0; k < i; k++)
323
                x -= matrix[k * n + k] * matrix[in + k] * matrix[jn + k];
324
            matrix[jn + i] = x / matrix[in + i];
325
        }
326
    }
327
328
    return 0;
329
}
330
331
static int do_interpolation(DeclickChannel *c, double *matrix,
332
                            double *vector, int n, double *out)
333
{
334
    int i, j, ret;
335
    double *y;
336
337
    ret = factorization(matrix, n);
338
    if (ret < 0)
339
        return ret;
340
341
    av_fast_malloc(&c->y, &c->y_size, n * sizeof(*c->y));
342
    y = c->y;
343
    if (!y)
344
        return AVERROR(ENOMEM);
345
346
    for (i = 0; i < n; i++) {
347
        const int in = i * n;
348
        double value;
349
350
        value = vector[i];
351
        for (j = 0; j < i; j++)
352
            value -= matrix[in + j] * y[j];
353
        y[i] = value;
354
    }
355
356
    for (i = n - 1; i >= 0; i--) {
357
        out[i] = y[i] / matrix[i * n + i];
358
        for (j = i + 1; j < n; j++)
359
            out[i] -= matrix[j * n + i] * out[j];
360
    }
361
362
    return 0;
363
}
364
365
static int interpolation(DeclickChannel *c, const double *src, int ar_order,
366
                         double *acoefficients, int *index, int nb_errors,
367
                         double *auxiliary, double *interpolated)
368
{
369
    double *vector, *matrix;
370
    int i, j;
371
372
    av_fast_malloc(&c->matrix, &c->matrix_size, nb_errors * nb_errors * sizeof(*c->matrix));
373
    matrix = c->matrix;
374
    if (!matrix)
375
        return AVERROR(ENOMEM);
376
377
    av_fast_malloc(&c->vector, &c->vector_size, nb_errors * sizeof(*c->vector));
378
    vector = c->vector;
379
    if (!vector)
380
        return AVERROR(ENOMEM);
381
382
    autocorrelation(acoefficients, ar_order, ar_order + 1, auxiliary, 1.);
383
384
    for (i = 0; i < nb_errors; i++) {
385
        const int im = i * nb_errors;
386
387
        for (j = i; j < nb_errors; j++) {
388
            if (abs(index[j] - index[i]) <= ar_order) {
389
                matrix[j * nb_errors + i] = matrix[im + j] = auxiliary[abs(index[j] - index[i])];
390
            } else {
391
                matrix[j * nb_errors + i] = matrix[im + j] = 0;
392
            }
393
        }
394
    }
395
396
    for (i = 0; i < nb_errors; i++) {
397
        double value = 0.;
398
399
        for (j = -ar_order; j <= ar_order; j++)
400
            if (find_index(index, index[i] - j, nb_errors))
401
                value -= src[index[i] - j] * auxiliary[abs(j)];
402
403
        vector[i] = value;
404
    }
405
406
    return do_interpolation(c, matrix, vector, nb_errors, interpolated);
407
}
408
409
static int detect_clips(AudioDeclickContext *s, DeclickChannel *c,
410
                        double unused0,
411
                        double *unused1, double *unused2,
412
                        uint8_t *clip, int *index,
413
                        const double *src, double *dst)
414
{
415
    const double threshold = s->threshold;
416
    double max_amplitude = 0;
417
    unsigned *histogram;
418
    int i, nb_clips = 0;
419
420
    av_fast_malloc(&c->histogram, &c->histogram_size, s->nb_hbins * sizeof(*c->histogram));
421
    if (!c->histogram)
422
        return AVERROR(ENOMEM);
423
    histogram = c->histogram;
424
    memset(histogram, 0, sizeof(*histogram) * s->nb_hbins);
425
426
    for (i = 0; i < s->window_size; i++) {
427
        const unsigned index = fmin(fabs(src[i]), 1) * (s->nb_hbins - 1);
428
429
        histogram[index]++;
430
        dst[i] = src[i];
431
        clip[i] = 0;
432
    }
433
434
    for (i = s->nb_hbins - 1; i > 1; i--) {
435
        if (histogram[i]) {
436
            if (histogram[i] / (double)FFMAX(histogram[i - 1], 1) > threshold) {
437
                max_amplitude = i / (double)s->nb_hbins;
438
            }
439
            break;
440
        }
441
    }
442
443
    if (max_amplitude > 0.) {
444
        for (i = 0; i < s->window_size; i++) {
445
            clip[i] = fabs(src[i]) >= max_amplitude;
446
        }
447
    }
448
449
    memset(clip, 0, s->ar_order * sizeof(*clip));
450
    memset(clip + (s->window_size - s->ar_order), 0, s->ar_order * sizeof(*clip));
451
452
    for (i = s->ar_order; i < s->window_size - s->ar_order; i++)
453
        if (clip[i])
454
            index[nb_clips++] = i;
455
456
    return nb_clips;
457
}
458
459
static int detect_clicks(AudioDeclickContext *s, DeclickChannel *c,
460
                         double sigmae,
461
                         double *detection, double *acoefficients,
462
                         uint8_t *click, int *index,
463
                         const double *src, double *dst)
464
{
465
    const double threshold = s->threshold;
466
    int i, j, nb_clicks = 0, prev = -1;
467
468
    memset(detection, 0, s->window_size * sizeof(*detection));
469
470
    for (i = s->ar_order; i < s->window_size; i++) {
471
        for (j = 0; j <= s->ar_order; j++) {
472
            detection[i] += acoefficients[j] * src[i - j];
473
        }
474
    }
475
476
    for (i = 0; i < s->window_size; i++) {
477
        click[i] = fabs(detection[i]) > sigmae * threshold;
478
        dst[i] = src[i];
479
    }
480
481
    for (i = 0; i < s->window_size; i++) {
482
        if (!click[i])
483
            continue;
484
485
        if (prev >= 0 && (i > prev + 1) && (i <= s->nb_burst_samples + prev))
486
            for (j = prev + 1; j < i; j++)
487
                click[j] = 1;
488
        prev = i;
489
    }
490
491
    memset(click, 0, s->ar_order * sizeof(*click));
492
    memset(click + (s->window_size - s->ar_order), 0, s->ar_order * sizeof(*click));
493
494
    for (i = s->ar_order; i < s->window_size - s->ar_order; i++)
495
        if (click[i])
496
            index[nb_clicks++] = i;
497
498
    return nb_clicks;
499
}
500
501
typedef struct ThreadData {
502
    AVFrame *out;
503
} ThreadData;
504
505
static int filter_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
506
{
507
    AudioDeclickContext *s = ctx->priv;
508
    ThreadData *td = arg;
509
    AVFrame *out = td->out;
510
    const double *src = (const double *)s->in->extended_data[ch];
511
    double *is = (double *)s->is->extended_data[ch];
512
    double *dst = (double *)s->out->extended_data[ch];
513
    double *ptr = (double *)out->extended_data[ch];
514
    double *buf = (double *)s->buffer->extended_data[ch];
515
    const double *w = s->window_func_lut;
516
    DeclickChannel *c = &s->chan[ch];
517
    double sigmae;
518
    int j, ret;
519
520
    sigmae = autoregression(src, s->ar_order, s->window_size, c->acoefficients, c->acorrelation, c->tmp);
521
522
    if (isfinite_array(c->acoefficients, s->ar_order + 1)) {
523
        double *interpolated = c->interpolated;
524
        int *index = c->index;
525
        int nb_errors;
526
527
        nb_errors = s->detector(s, c, sigmae, c->detection, c->acoefficients,
528
                                c->click, index, src, dst);
529
        if (nb_errors > 0) {
530
            double *enabled = (double *)s->enabled->extended_data[0];
531
532
            ret = interpolation(c, src, s->ar_order, c->acoefficients, index,
533
                                nb_errors, c->auxiliary, interpolated);
534
            if (ret < 0)
535
                return ret;
536
537
            av_audio_fifo_peek(s->efifo, (void**)s->enabled->extended_data, s->window_size);
538
539
            for (j = 0; j < nb_errors; j++) {
540
                if (enabled[index[j]]) {
541
                    dst[index[j]] = interpolated[j];
542
                    is[index[j]] = 1;
543
                }
544
            }
545
        }
546
    } else {
547
        memcpy(dst, src, s->window_size * sizeof(*dst));
548
    }
549
550
    if (s->method == 0) {
551
        for (j = 0; j < s->window_size; j++)
552
            buf[j] += dst[j] * w[j];
553
    } else {
554
        const int skip = s->overlap_skip;
555
556
        for (j = 0; j < s->hop_size; j++)
557
            buf[j] = dst[skip + j];
558
    }
559
    for (j = 0; j < s->hop_size; j++)
560
        ptr[j] = buf[j];
561
562
    memmove(buf, buf + s->hop_size, (s->window_size * 2 - s->hop_size) * sizeof(*buf));
563
    memmove(is, is + s->hop_size, (s->window_size - s->hop_size) * sizeof(*is));
564
    memset(buf + s->window_size * 2 - s->hop_size, 0, s->hop_size * sizeof(*buf));
565
    memset(is + s->window_size - s->hop_size, 0, s->hop_size * sizeof(*is));
566
567
    return 0;
568
}
569
570
static int filter_frame(AVFilterLink *inlink)
571
{
572
    AVFilterContext *ctx = inlink->dst;
573
    AVFilterLink *outlink = ctx->outputs[0];
574
    AudioDeclickContext *s = ctx->priv;
575
    AVFrame *out = NULL;
576
    int ret = 0, j, ch, detected_errors = 0;
577
    ThreadData td;
578
579
    out = ff_get_audio_buffer(outlink, s->hop_size);
580
    if (!out)
581
        return AVERROR(ENOMEM);
582
583
    ret = av_audio_fifo_peek(s->fifo, (void **)s->in->extended_data,
584
                             s->window_size);
585
    if (ret < 0)
586
        goto fail;
587
588
    td.out = out;
589
    ret = ctx->internal->execute(ctx, filter_channel, &td, NULL, inlink->channels);
590
    if (ret < 0)
591
        goto fail;
592
593
    for (ch = 0; ch < s->in->channels; ch++) {
594
        double *is = (double *)s->is->extended_data[ch];
595
596
        for (j = 0; j < s->hop_size; j++) {
597
            if (is[j])
598
                detected_errors++;
599
        }
600
    }
601
602
    av_audio_fifo_drain(s->fifo, s->hop_size);
603
    av_audio_fifo_drain(s->efifo, s->hop_size);
604
605
    if (s->samples_left > 0)
606
        out->nb_samples = FFMIN(s->hop_size, s->samples_left);
607
608
    out->pts = s->pts;
609
    s->pts += av_rescale_q(s->hop_size, (AVRational){1, outlink->sample_rate}, outlink->time_base);
610
611
    s->detected_errors += detected_errors;
612
    s->nb_samples += out->nb_samples * inlink->channels;
613
614
    ret = ff_filter_frame(outlink, out);
615
    if (ret < 0)
616
        return ret;
617
618
    if (s->samples_left > 0) {
619
        s->samples_left -= s->hop_size;
620
        if (s->samples_left <= 0)
621
            av_audio_fifo_drain(s->fifo, av_audio_fifo_size(s->fifo));
622
    }
623
624
fail:
625
    if (ret < 0)
626
        av_frame_free(&out);
627
    return ret;
628
}
629
630
static int activate(AVFilterContext *ctx)
631
{
632
    AVFilterLink *inlink = ctx->inputs[0];
633
    AVFilterLink *outlink = ctx->outputs[0];
634
    AudioDeclickContext *s = ctx->priv;
635
    AVFrame *in;
636
    int ret, status;
637
    int64_t pts;
638
639
    FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
640
641
    ret = ff_inlink_consume_samples(inlink, s->window_size, s->window_size, &in);
642
    if (ret < 0)
643
        return ret;
644
    if (ret > 0) {
645
        double *e = (double *)s->enabled->extended_data[0];
646
647
        if (s->pts == AV_NOPTS_VALUE)
648
            s->pts = in->pts;
649
650
        ret = av_audio_fifo_write(s->fifo, (void **)in->extended_data,
651
                                  in->nb_samples);
652
        for (int i = 0; i < in->nb_samples; i++)
653
            e[i] = !ctx->is_disabled;
654
655
        av_audio_fifo_write(s->efifo, (void**)s->enabled->extended_data, in->nb_samples);
656
        av_frame_free(&in);
657
        if (ret < 0)
658
            return ret;
659
    }
660
661
    if (av_audio_fifo_size(s->fifo) >= s->window_size ||
662
        s->samples_left > 0)
663
        return filter_frame(inlink);
664
665
    if (av_audio_fifo_size(s->fifo) >= s->window_size) {
666
        ff_filter_set_ready(ctx, 100);
667
        return 0;
668
    }
669
670
    if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
671
        if (status == AVERROR_EOF) {
672
            s->eof = 1;
673
            s->samples_left = av_audio_fifo_size(s->fifo) - s->overlap_skip;
674
            ff_filter_set_ready(ctx, 100);
675
            return 0;
676
        }
677
    }
678
679
    if (s->eof && s->samples_left <= 0) {
680
        ff_outlink_set_status(outlink, AVERROR_EOF, s->pts);
681
        return 0;
682
    }
683
684
    if (!s->eof)
685
        FF_FILTER_FORWARD_WANTED(outlink, inlink);
686
687
    return FFERROR_NOT_READY;
688
}
689
690
static av_cold int init(AVFilterContext *ctx)
691
{
692
    AudioDeclickContext *s = ctx->priv;
693
694
    s->is_declip = !strcmp(ctx->filter->name, "adeclip");
695
    if (s->is_declip) {
696
        s->detector = detect_clips;
697
    } else {
698
        s->detector = detect_clicks;
699
    }
700
701
    return 0;
702
}
703
704
static av_cold void uninit(AVFilterContext *ctx)
705
{
706
    AudioDeclickContext *s = ctx->priv;
707
    int i;
708
709
    av_log(ctx, AV_LOG_INFO, "Detected %s in %"PRId64" of %"PRId64" samples (%g%%).\n",
710
           s->is_declip ? "clips" : "clicks", s->detected_errors,
711
           s->nb_samples, 100. * s->detected_errors / s->nb_samples);
712
713
    av_audio_fifo_free(s->fifo);
714
    av_audio_fifo_free(s->efifo);
715
    av_freep(&s->window_func_lut);
716
    av_frame_free(&s->enabled);
717
    av_frame_free(&s->in);
718
    av_frame_free(&s->out);
719
    av_frame_free(&s->buffer);
720
    av_frame_free(&s->is);
721
722
    if (s->chan) {
723
        for (i = 0; i < s->nb_channels; i++) {
724
            DeclickChannel *c = &s->chan[i];
725
726
            av_freep(&c->detection);
727
            av_freep(&c->auxiliary);
728
            av_freep(&c->acoefficients);
729
            av_freep(&c->acorrelation);
730
            av_freep(&c->tmp);
731
            av_freep(&c->click);
732
            av_freep(&c->index);
733
            av_freep(&c->interpolated);
734
            av_freep(&c->matrix);
735
            c->matrix_size = 0;
736
            av_freep(&c->histogram);
737
            c->histogram_size = 0;
738
            av_freep(&c->vector);
739
            c->vector_size = 0;
740
            av_freep(&c->y);
741
            c->y_size = 0;
742
        }
743
    }
744
    av_freep(&s->chan);
745
    s->nb_channels = 0;
746
}
747
748
static const AVFilterPad inputs[] = {
749
    {
750
        .name         = "default",
751
        .type         = AVMEDIA_TYPE_AUDIO,
752
        .config_props = config_input,
753
    },
754
    { NULL }
755
};
756
757
static const AVFilterPad outputs[] = {
758
    {
759
        .name          = "default",
760
        .type          = AVMEDIA_TYPE_AUDIO,
761
    },
762
    { NULL }
763
};
764
765
AVFilter ff_af_adeclick = {
766
    .name          = "adeclick",
767
    .description   = NULL_IF_CONFIG_SMALL("Remove impulsive noise from input audio."),
768
    .query_formats = query_formats,
769
    .priv_size     = sizeof(AudioDeclickContext),
770
    .priv_class    = &adeclick_class,
771
    .init          = init,
772
    .activate      = activate,
773
    .uninit        = uninit,
774
    .inputs        = inputs,
775
    .outputs       = outputs,
776
    .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
777
};
778
779
static const AVOption adeclip_options[] = {
780
    { "window", "set window size",     OFFSET(w),         AV_OPT_TYPE_DOUBLE, {.dbl=55},     10,  100, AF },
781
    { "w", "set window size",          OFFSET(w),         AV_OPT_TYPE_DOUBLE, {.dbl=55},     10,  100, AF },
782
    { "overlap", "set window overlap", OFFSET(overlap),   AV_OPT_TYPE_DOUBLE, {.dbl=75},     50,   95, AF },
783
    { "o", "set window overlap",       OFFSET(overlap),   AV_OPT_TYPE_DOUBLE, {.dbl=75},     50,   95, AF },
784
    { "arorder", "set autoregression order", OFFSET(ar),  AV_OPT_TYPE_DOUBLE, {.dbl=8},       0,   25, AF },
785
    { "a", "set autoregression order", OFFSET(ar),        AV_OPT_TYPE_DOUBLE, {.dbl=8},       0,   25, AF },
786
    { "threshold", "set threshold",    OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=10},      1,  100, AF },
787
    { "t", "set threshold",            OFFSET(threshold), AV_OPT_TYPE_DOUBLE, {.dbl=10},      1,  100, AF },
788
    { "hsize", "set histogram size",   OFFSET(nb_hbins),  AV_OPT_TYPE_INT,    {.i64=1000},  100, 9999, AF },
789
    { "n", "set histogram size",       OFFSET(nb_hbins),  AV_OPT_TYPE_INT,    {.i64=1000},  100, 9999, AF },
790
    { "method", "set overlap method",  OFFSET(method),    AV_OPT_TYPE_INT,    {.i64=0},       0,    1, AF, "m" },
791
    { "m", "set overlap method",       OFFSET(method),    AV_OPT_TYPE_INT,    {.i64=0},       0,    1, AF, "m" },
792
    { "add", "overlap-add",            0,                 AV_OPT_TYPE_CONST,  {.i64=0},       0,    0, AF, "m" },
793
    { "a", "overlap-add",              0,                 AV_OPT_TYPE_CONST,  {.i64=0},       0,    0, AF, "m" },
794
    { "save", "overlap-save",          0,                 AV_OPT_TYPE_CONST,  {.i64=1},       0,    0, AF, "m" },
795
    { "s", "overlap-save",             0,                 AV_OPT_TYPE_CONST,  {.i64=1},       0,    0, AF, "m" },
796
    { NULL }
797
};
798
799
AVFILTER_DEFINE_CLASS(adeclip);
800
801
AVFilter ff_af_adeclip = {
802
    .name          = "adeclip",
803
    .description   = NULL_IF_CONFIG_SMALL("Remove clipping from input audio."),
804
    .query_formats = query_formats,
805
    .priv_size     = sizeof(AudioDeclickContext),
806
    .priv_class    = &adeclip_class,
807
    .init          = init,
808
    .activate      = activate,
809
    .uninit        = uninit,
810
    .inputs        = inputs,
811
    .outputs       = outputs,
812
    .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
813
};