git.sesse.net Git - ffmpeg/blob - 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 "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 };