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