FFmpeg
af_afftdn.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2018 The FFmpeg Project
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 <float.h>
22 
23 #include "libavutil/avstring.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/tx.h"
27 #include "avfilter.h"
28 #include "audio.h"
29 #include "formats.h"
30 #include "filters.h"
31 
32 #define C (M_LN10 * 0.1)
33 #define SOLVE_SIZE (5)
34 #define NB_PROFILE_BANDS (15)
35 
41 };
42 
43 enum OutModes {
48 };
49 
56 };
57 
58 enum NoiseType {
64 };
65 
66 typedef struct DeNoiseChannel {
70  double *amt;
71  double *band_amt;
72  double *band_excit;
73  double *gain;
74  double *smoothed_gain;
75  double *prior;
77  double *clean_data;
78  double *noisy_data;
79  double *out_samples;
80  double *spread_function;
81  double *abs_var;
82  double *rel_var;
83  double *min_abs_var;
84  void *fft_in;
85  void *fft_out;
88 
93 
96  double noise_floor;
100  double max_gain;
101  double max_var;
102  double gain_scale;
104 
105 typedef struct AudioFFTDeNoiseContext {
106  const AVClass *class;
107 
108  int format;
109  size_t sample_size;
110 
112  float noise_floor;
120  float ratio;
124 
125  int channels;
129  float sample_rate;
137 
139 
140  int *bin2band;
141  double *window;
142  double *band_alpha;
143  double *band_beta;
144 
146 
148 
150  double floor;
151  double sample_floor;
152 
160 
161 #define OFFSET(x) offsetof(AudioFFTDeNoiseContext, x)
162 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
163 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
164 
165 static const AVOption afftdn_options[] = {
166  { "noise_reduction", "set the noise reduction",OFFSET(noise_reduction), AV_OPT_TYPE_FLOAT,{.dbl = 12}, .01, 97, AFR },
167  { "nr", "set the noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_FLOAT, {.dbl = 12}, .01, 97, AFR },
168  { "noise_floor", "set the noise floor",OFFSET(noise_floor), AV_OPT_TYPE_FLOAT, {.dbl =-50}, -80,-20, AFR },
169  { "nf", "set the noise floor", OFFSET(noise_floor), AV_OPT_TYPE_FLOAT, {.dbl =-50}, -80,-20, AFR },
170  { "noise_type", "set the noise type", OFFSET(noise_type), AV_OPT_TYPE_INT, {.i64 = WHITE_NOISE}, WHITE_NOISE, NB_NOISE-1, AF, "type" },
171  { "nt", "set the noise type", OFFSET(noise_type), AV_OPT_TYPE_INT, {.i64 = WHITE_NOISE}, WHITE_NOISE, NB_NOISE-1, AF, "type" },
172  { "white", "white noise", 0, AV_OPT_TYPE_CONST, {.i64 = WHITE_NOISE}, 0, 0, AF, "type" },
173  { "w", "white noise", 0, AV_OPT_TYPE_CONST, {.i64 = WHITE_NOISE}, 0, 0, AF, "type" },
174  { "vinyl", "vinyl noise", 0, AV_OPT_TYPE_CONST, {.i64 = VINYL_NOISE}, 0, 0, AF, "type" },
175  { "v", "vinyl noise", 0, AV_OPT_TYPE_CONST, {.i64 = VINYL_NOISE}, 0, 0, AF, "type" },
176  { "shellac", "shellac noise", 0, AV_OPT_TYPE_CONST, {.i64 = SHELLAC_NOISE}, 0, 0, AF, "type" },
177  { "s", "shellac noise", 0, AV_OPT_TYPE_CONST, {.i64 = SHELLAC_NOISE}, 0, 0, AF, "type" },
178  { "custom", "custom noise", 0, AV_OPT_TYPE_CONST, {.i64 = CUSTOM_NOISE}, 0, 0, AF, "type" },
179  { "c", "custom noise", 0, AV_OPT_TYPE_CONST, {.i64 = CUSTOM_NOISE}, 0, 0, AF, "type" },
180  { "band_noise", "set the custom bands noise", OFFSET(band_noise_str), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, AF },
181  { "bn", "set the custom bands noise", OFFSET(band_noise_str), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, AF },
182  { "residual_floor", "set the residual floor",OFFSET(residual_floor), AV_OPT_TYPE_FLOAT, {.dbl =-38}, -80,-20, AFR },
183  { "rf", "set the residual floor", OFFSET(residual_floor), AV_OPT_TYPE_FLOAT, {.dbl =-38}, -80,-20, AFR },
184  { "track_noise", "track noise", OFFSET(track_noise), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR },
185  { "tn", "track noise", OFFSET(track_noise), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR },
186  { "track_residual", "track residual", OFFSET(track_residual), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR },
187  { "tr", "track residual", OFFSET(track_residual), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR },
188  { "output_mode", "set output mode", OFFSET(output_mode), AV_OPT_TYPE_INT, {.i64 = OUT_MODE}, 0, NB_MODES-1, AFR, "mode" },
189  { "om", "set output mode", OFFSET(output_mode), AV_OPT_TYPE_INT, {.i64 = OUT_MODE}, 0, NB_MODES-1, AFR, "mode" },
190  { "input", "input", 0, AV_OPT_TYPE_CONST, {.i64 = IN_MODE}, 0, 0, AFR, "mode" },
191  { "i", "input", 0, AV_OPT_TYPE_CONST, {.i64 = IN_MODE}, 0, 0, AFR, "mode" },
192  { "output", "output", 0, AV_OPT_TYPE_CONST, {.i64 = OUT_MODE}, 0, 0, AFR, "mode" },
193  { "o", "output", 0, AV_OPT_TYPE_CONST, {.i64 = OUT_MODE}, 0, 0, AFR, "mode" },
194  { "noise", "noise", 0, AV_OPT_TYPE_CONST, {.i64 = NOISE_MODE}, 0, 0, AFR, "mode" },
195  { "n", "noise", 0, AV_OPT_TYPE_CONST, {.i64 = NOISE_MODE}, 0, 0, AFR, "mode" },
196  { "adaptivity", "set adaptivity factor",OFFSET(ratio), AV_OPT_TYPE_FLOAT, {.dbl = 0.5}, 0, 1, AFR },
197  { "ad", "set adaptivity factor",OFFSET(ratio), AV_OPT_TYPE_FLOAT, {.dbl = 0.5}, 0, 1, AFR },
198  { "floor_offset", "set noise floor offset factor",OFFSET(floor_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, -2, 2, AFR },
199  { "fo", "set noise floor offset factor",OFFSET(floor_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, -2, 2, AFR },
200  { "noise_link", "set the noise floor link",OFFSET(noise_floor_link),AV_OPT_TYPE_INT,{.i64 = MIN_LINK}, 0, NB_LINK-1, AFR, "link" },
201  { "nl", "set the noise floor link", OFFSET(noise_floor_link),AV_OPT_TYPE_INT,{.i64 = MIN_LINK}, 0, NB_LINK-1, AFR, "link" },
202  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = NONE_LINK}, 0, 0, AFR, "link" },
203  { "min", "min", 0, AV_OPT_TYPE_CONST, {.i64 = MIN_LINK}, 0, 0, AFR, "link" },
204  { "max", "max", 0, AV_OPT_TYPE_CONST, {.i64 = MAX_LINK}, 0, 0, AFR, "link" },
205  { "average", "average", 0, AV_OPT_TYPE_CONST, {.i64 = AVERAGE_LINK}, 0, 0, AFR, "link" },
206  { "band_multiplier", "set band multiplier",OFFSET(band_multiplier), AV_OPT_TYPE_FLOAT,{.dbl = 1.25}, 0.2,5, AF },
207  { "bm", "set band multiplier", OFFSET(band_multiplier), AV_OPT_TYPE_FLOAT,{.dbl = 1.25}, 0.2,5, AF },
208  { "sample_noise", "set sample noise mode",OFFSET(sample_noise_mode),AV_OPT_TYPE_INT,{.i64 = SAMPLE_NONE}, 0, NB_SAMPLEMODES-1, AFR, "sample" },
209  { "sn", "set sample noise mode",OFFSET(sample_noise_mode),AV_OPT_TYPE_INT,{.i64 = SAMPLE_NONE}, 0, NB_SAMPLEMODES-1, AFR, "sample" },
210  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_NONE}, 0, 0, AFR, "sample" },
211  { "start", "start", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_START}, 0, 0, AFR, "sample" },
212  { "begin", "start", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_START}, 0, 0, AFR, "sample" },
213  { "stop", "stop", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_STOP}, 0, 0, AFR, "sample" },
214  { "end", "stop", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_STOP}, 0, 0, AFR, "sample" },
215  { "gain_smooth", "set gain smooth radius",OFFSET(gain_smooth), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 50, AFR },
216  { "gs", "set gain smooth radius",OFFSET(gain_smooth), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 50, AFR },
217  { NULL }
218 };
219 
220 AVFILTER_DEFINE_CLASS(afftdn);
221 
223  int band, double a,
224  double b, double c)
225 {
226  double d1, d2, d3;
227 
228  d1 = a / s->band_centre[band];
229  d1 = 10.0 * log(1.0 + d1 * d1) / M_LN10;
230  d2 = b / s->band_centre[band];
231  d2 = 10.0 * log(1.0 + d2 * d2) / M_LN10;
232  d3 = s->band_centre[band] / c;
233  d3 = 10.0 * log(1.0 + d3 * d3) / M_LN10;
234 
235  return -d1 + d2 - d3;
236 }
237 
238 static void factor(double *array, int size)
239 {
240  for (int i = 0; i < size - 1; i++) {
241  for (int j = i + 1; j < size; j++) {
242  double d = array[j + i * size] / array[i + i * size];
243 
244  array[j + i * size] = d;
245  for (int k = i + 1; k < size; k++) {
246  array[j + k * size] -= d * array[i + k * size];
247  }
248  }
249  }
250 }
251 
252 static void solve(double *matrix, double *vector, int size)
253 {
254  for (int i = 0; i < size - 1; i++) {
255  for (int j = i + 1; j < size; j++) {
256  double d = matrix[j + i * size];
257  vector[j] -= d * vector[i];
258  }
259  }
260 
261  vector[size - 1] /= matrix[size * size - 1];
262 
263  for (int i = size - 2; i >= 0; i--) {
264  double d = vector[i];
265  for (int j = i + 1; j < size; j++)
266  d -= matrix[i + j * size] * vector[j];
267  vector[i] = d / matrix[i + i * size];
268  }
269 }
270 
272  DeNoiseChannel *dnch,
273  int band)
274 {
275  double product, sum, f;
276  int i = 0;
277 
278  if (band < NB_PROFILE_BANDS)
279  return dnch->band_noise[band];
280 
281  for (int j = 0; j < SOLVE_SIZE; j++) {
282  sum = 0.0;
283  for (int k = 0; k < NB_PROFILE_BANDS; k++)
284  sum += s->matrix_b[i++] * dnch->band_noise[k];
285  s->vector_b[j] = sum;
286  }
287 
288  solve(s->matrix_a, s->vector_b, SOLVE_SIZE);
289  f = (0.5 * s->sample_rate) / s->band_centre[NB_PROFILE_BANDS-1];
290  f = 15.0 + log(f / 1.5) / log(1.5);
291  sum = 0.0;
292  product = 1.0;
293  for (int j = 0; j < SOLVE_SIZE; j++) {
294  sum += product * s->vector_b[j];
295  product *= f;
296  }
297 
298  return sum;
299 }
300 
301 static double limit_gain(double a, double b)
302 {
303  if (a > 1.0)
304  return (b * a - 1.0) / (b + a - 2.0);
305  if (a < 1.0)
306  return (b * a - 2.0 * a + 1.0) / (b - a);
307  return 1.0;
308 }
309 
310 static void spectral_flatness(AudioFFTDeNoiseContext *s, const double *const spectral,
311  double floor, int len, double *rnum, double *rden)
312 {
313  double num = 0., den = 0.;
314  int size = 0;
315 
316  for (int n = 0; n < len; n++) {
317  const double v = spectral[n];
318  if (v > floor) {
319  num += log(v);
320  den += v;
321  size++;
322  }
323  }
324 
325  size = FFMAX(size, 1);
326 
327  num /= size;
328  den /= size;
329 
330  num = exp(num);
331 
332  *rnum = num;
333  *rden = den;
334 }
335 
336 static void set_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int update_var, int update_auto_var);
337 
338 static double floor_offset(const double *S, int size, double mean)
339 {
340  double offset = 0.0;
341 
342  for (int n = 0; n < size; n++) {
343  const double p = S[n] - mean;
344 
345  offset = fmax(offset, fabs(p));
346  }
347 
348  return offset / mean;
349 }
350 
353  double *prior, double *prior_band_excit, int track_noise)
354 {
355  AVFilterLink *outlink = ctx->outputs[0];
356  const double *abs_var = dnch->abs_var;
357  const double ratio = outlink->frame_count_out ? s->ratio : 1.0;
358  const double rratio = 1. - ratio;
359  const int *bin2band = s->bin2band;
360  double *noisy_data = dnch->noisy_data;
361  double *band_excit = dnch->band_excit;
362  double *band_amt = dnch->band_amt;
363  double *smoothed_gain = dnch->smoothed_gain;
364  AVComplexDouble *fft_data_dbl = dnch->fft_out;
365  AVComplexFloat *fft_data_flt = dnch->fft_out;
366  double *gain = dnch->gain;
367 
368  for (int i = 0; i < s->bin_count; i++) {
369  double sqr_new_gain, new_gain, power, mag, mag_abs_var, new_mag_abs_var;
370 
371  switch (s->format) {
372  case AV_SAMPLE_FMT_FLTP:
373  noisy_data[i] = mag = hypot(fft_data_flt[i].re, fft_data_flt[i].im);
374  break;
375  case AV_SAMPLE_FMT_DBLP:
376  noisy_data[i] = mag = hypot(fft_data_dbl[i].re, fft_data_dbl[i].im);
377  break;
378  }
379 
380  power = mag * mag;
381  mag_abs_var = power / abs_var[i];
382  new_mag_abs_var = ratio * prior[i] + rratio * fmax(mag_abs_var - 1.0, 0.0);
383  new_gain = new_mag_abs_var / (1.0 + new_mag_abs_var);
384  sqr_new_gain = new_gain * new_gain;
385  prior[i] = mag_abs_var * sqr_new_gain;
386  dnch->clean_data[i] = power * sqr_new_gain;
387  gain[i] = new_gain;
388  }
389 
390  if (track_noise) {
391  double flatness, num, den;
392 
393  spectral_flatness(s, noisy_data, s->floor, s->bin_count, &num, &den);
394 
395  flatness = num / den;
396  if (flatness > 0.8) {
397  const double offset = s->floor_offset * floor_offset(noisy_data, s->bin_count, den);
398  const double new_floor = av_clipd(10.0 * log10(den) - 100.0 + offset, -90., -20.);
399 
400  dnch->noise_floor = 0.1 * new_floor + dnch->noise_floor * 0.9;
401  set_parameters(s, dnch, 1, 1);
402  }
403  }
404 
405  for (int i = 0; i < s->number_of_bands; i++) {
406  band_excit[i] = 0.0;
407  band_amt[i] = 0.0;
408  }
409 
410  for (int i = 0; i < s->bin_count; i++)
411  band_excit[bin2band[i]] += dnch->clean_data[i];
412 
413  for (int i = 0; i < s->number_of_bands; i++) {
414  band_excit[i] = fmax(band_excit[i],
415  s->band_alpha[i] * band_excit[i] +
416  s->band_beta[i] * prior_band_excit[i]);
417  prior_band_excit[i] = band_excit[i];
418  }
419 
420  for (int j = 0, i = 0; j < s->number_of_bands; j++) {
421  for (int k = 0; k < s->number_of_bands; k++) {
422  band_amt[j] += dnch->spread_function[i++] * band_excit[k];
423  }
424  }
425 
426  for (int i = 0; i < s->bin_count; i++)
427  dnch->amt[i] = band_amt[bin2band[i]];
428 
429  for (int i = 0; i < s->bin_count; i++) {
430  if (dnch->amt[i] > abs_var[i]) {
431  gain[i] = 1.0;
432  } else if (dnch->amt[i] > dnch->min_abs_var[i]) {
433  const double limit = sqrt(abs_var[i] / dnch->amt[i]);
434 
435  gain[i] = limit_gain(gain[i], limit);
436  } else {
437  gain[i] = limit_gain(gain[i], dnch->max_gain);
438  }
439  }
440 
441  memcpy(smoothed_gain, gain, s->bin_count * sizeof(*smoothed_gain));
442  if (s->gain_smooth > 0) {
443  const int r = s->gain_smooth;
444 
445  for (int i = r; i < s->bin_count - r; i++) {
446  const double gc = gain[i];
447  double num = 0., den = 0.;
448 
449  for (int j = -r; j <= r; j++) {
450  const double g = gain[i + j];
451  const double d = 1. - fabs(g - gc);
452 
453  num += g * d;
454  den += d;
455  }
456 
457  smoothed_gain[i] = num / den;
458  }
459  }
460 
461  switch (s->format) {
462  case AV_SAMPLE_FMT_FLTP:
463  for (int i = 0; i < s->bin_count; i++) {
464  const float new_gain = smoothed_gain[i];
465 
466  fft_data_flt[i].re *= new_gain;
467  fft_data_flt[i].im *= new_gain;
468  }
469  break;
470  case AV_SAMPLE_FMT_DBLP:
471  for (int i = 0; i < s->bin_count; i++) {
472  const double new_gain = smoothed_gain[i];
473 
474  fft_data_dbl[i].re *= new_gain;
475  fft_data_dbl[i].im *= new_gain;
476  }
477  break;
478  }
479 }
480 
481 static double freq2bark(double x)
482 {
483  double d = x / 7500.0;
484 
485  return 13.0 * atan(7.6E-4 * x) + 3.5 * atan(d * d);
486 }
487 
489 {
490  if (band == -1)
491  return lrint(s->band_centre[0] / 1.5);
492 
493  return s->band_centre[band];
494 }
495 
496 static int get_band_edge(AudioFFTDeNoiseContext *s, int band)
497 {
498  int i;
499 
500  if (band == NB_PROFILE_BANDS) {
501  i = lrint(s->band_centre[NB_PROFILE_BANDS - 1] * 1.224745);
502  } else {
503  i = lrint(s->band_centre[band] / 1.224745);
504  }
505 
506  return FFMIN(i, s->sample_rate / 2);
507 }
508 
510  DeNoiseChannel *dnch)
511 {
512  double band_noise, d2, d3, d4, d5;
513  int i = 0, j = 0, k = 0;
514 
515  d5 = 0.0;
516  band_noise = process_get_band_noise(s, dnch, 0);
517  for (int m = j; m < s->bin_count; m++) {
518  if (m == j) {
519  i = j;
520  d5 = band_noise;
521  if (k >= NB_PROFILE_BANDS) {
522  j = s->bin_count;
523  } else {
524  j = s->fft_length * get_band_centre(s, k) / s->sample_rate;
525  }
526  d2 = j - i;
527  band_noise = process_get_band_noise(s, dnch, k);
528  k++;
529  }
530  d3 = (j - m) / d2;
531  d4 = (m - i) / d2;
532  dnch->rel_var[m] = exp((d5 * d3 + band_noise * d4) * C);
533  }
534 
535  for (i = 0; i < NB_PROFILE_BANDS; i++)
536  dnch->noise_band_auto_var[i] = dnch->max_var * exp((process_get_band_noise(s, dnch, i) - 2.0) * C);
537 }
538 
540 {
541  DeNoiseChannel *dnch = &s->dnch[ch];
542  char *custom_noise_str, *p, *arg, *saveptr = NULL;
543  double band_noise[NB_PROFILE_BANDS] = { 0.f };
544  int ret;
545 
546  if (!s->band_noise_str)
547  return;
548 
549  custom_noise_str = p = av_strdup(s->band_noise_str);
550  if (!p)
551  return;
552 
553  for (int i = 0; i < NB_PROFILE_BANDS; i++) {
554  float noise;
555 
556  if (!(arg = av_strtok(p, "| ", &saveptr)))
557  break;
558 
559  p = NULL;
560 
561  ret = av_sscanf(arg, "%f", &noise);
562  if (ret != 1) {
563  av_log(s, AV_LOG_ERROR, "Custom band noise must be float.\n");
564  break;
565  }
566 
567  band_noise[i] = av_clipd(noise, -24., 24.);
568  }
569 
570  av_free(custom_noise_str);
571  memcpy(dnch->band_noise, band_noise, sizeof(band_noise));
572 }
573 
574 static void set_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int update_var, int update_auto_var)
575 {
576  if (dnch->last_noise_floor != dnch->noise_floor)
577  dnch->last_noise_floor = dnch->noise_floor;
578 
579  if (s->track_residual)
581 
582  dnch->max_var = s->floor * exp((100.0 + dnch->last_noise_floor) * C);
583  if (update_auto_var) {
584  for (int i = 0; i < NB_PROFILE_BANDS; i++)
585  dnch->noise_band_auto_var[i] = dnch->max_var * exp((process_get_band_noise(s, dnch, i) - 2.0) * C);
586  }
587 
588  if (s->track_residual) {
589  if (update_var || dnch->last_residual_floor != dnch->residual_floor) {
590  update_var = 1;
591  dnch->last_residual_floor = dnch->residual_floor;
592  dnch->last_noise_reduction = fmax(dnch->last_noise_floor - dnch->last_residual_floor + 100., 0);
593  dnch->max_gain = exp(dnch->last_noise_reduction * (0.5 * C));
594  }
595  } else if (update_var || dnch->noise_reduction != dnch->last_noise_reduction) {
596  update_var = 1;
598  dnch->last_residual_floor = av_clipd(dnch->last_noise_floor - dnch->last_noise_reduction, -80, -20);
599  dnch->max_gain = exp(dnch->last_noise_reduction * (0.5 * C));
600  }
601 
602  dnch->gain_scale = 1.0 / (dnch->max_gain * dnch->max_gain);
603 
604  if (update_var) {
605  set_band_parameters(s, dnch);
606 
607  for (int i = 0; i < s->bin_count; i++) {
608  dnch->abs_var[i] = fmax(dnch->max_var * dnch->rel_var[i], 1.0);
609  dnch->min_abs_var[i] = dnch->gain_scale * dnch->abs_var[i];
610  }
611  }
612 }
613 
614 static void reduce_mean(double *band_noise)
615 {
616  double mean = 0.f;
617 
618  for (int i = 0; i < NB_PROFILE_BANDS; i++)
619  mean += band_noise[i];
621 
622  for (int i = 0; i < NB_PROFILE_BANDS; i++)
623  band_noise[i] -= mean;
624 }
625 
627 {
628  AVFilterContext *ctx = inlink->dst;
629  AudioFFTDeNoiseContext *s = ctx->priv;
630  size_t complex_sample_size;
631  double wscale, sar, sum, sdiv;
632  int i, j, k, m, n, ret, tx_type;
633  double dscale = 1.;
634  float fscale = 1.f;
635  void *scale;
636 
637  s->format = inlink->format;
638 
639  switch (s->format) {
640  case AV_SAMPLE_FMT_FLTP:
641  s->sample_size = sizeof(float);
642  complex_sample_size = sizeof(AVComplexFloat);
643  tx_type = AV_TX_FLOAT_RDFT;
644  scale = &fscale;
645  break;
646  case AV_SAMPLE_FMT_DBLP:
647  s->sample_size = sizeof(double);
648  complex_sample_size = sizeof(AVComplexDouble);
649  tx_type = AV_TX_DOUBLE_RDFT;
650  scale = &dscale;
651  break;
652  }
653 
654  s->dnch = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->dnch));
655  if (!s->dnch)
656  return AVERROR(ENOMEM);
657 
658  s->channels = inlink->ch_layout.nb_channels;
659  s->sample_rate = inlink->sample_rate;
660  s->sample_advance = s->sample_rate / 80;
661  s->window_length = 3 * s->sample_advance;
662  s->fft_length2 = 1 << (32 - ff_clz(s->window_length));
663  s->fft_length = s->fft_length2;
664  s->buffer_length = s->fft_length * 2;
665  s->bin_count = s->fft_length2 / 2 + 1;
666 
667  s->band_centre[0] = 80;
668  for (i = 1; i < NB_PROFILE_BANDS; i++) {
669  s->band_centre[i] = lrint(1.5 * s->band_centre[i - 1] + 5.0);
670  if (s->band_centre[i] < 1000) {
671  s->band_centre[i] = 10 * (s->band_centre[i] / 10);
672  } else if (s->band_centre[i] < 5000) {
673  s->band_centre[i] = 50 * ((s->band_centre[i] + 20) / 50);
674  } else if (s->band_centre[i] < 15000) {
675  s->band_centre[i] = 100 * ((s->band_centre[i] + 45) / 100);
676  } else {
677  s->band_centre[i] = 1000 * ((s->band_centre[i] + 495) / 1000);
678  }
679  }
680 
681  for (j = 0; j < SOLVE_SIZE; j++) {
682  for (k = 0; k < SOLVE_SIZE; k++) {
683  s->matrix_a[j + k * SOLVE_SIZE] = 0.0;
684  for (m = 0; m < NB_PROFILE_BANDS; m++)
685  s->matrix_a[j + k * SOLVE_SIZE] += pow(m, j + k);
686  }
687  }
688 
689  factor(s->matrix_a, SOLVE_SIZE);
690 
691  i = 0;
692  for (j = 0; j < SOLVE_SIZE; j++)
693  for (k = 0; k < NB_PROFILE_BANDS; k++)
694  s->matrix_b[i++] = pow(k, j);
695 
696  i = 0;
697  for (j = 0; j < NB_PROFILE_BANDS; j++)
698  for (k = 0; k < SOLVE_SIZE; k++)
699  s->matrix_c[i++] = pow(j, k);
700 
701  s->window = av_calloc(s->window_length, sizeof(*s->window));
702  s->bin2band = av_calloc(s->bin_count, sizeof(*s->bin2band));
703  if (!s->window || !s->bin2band)
704  return AVERROR(ENOMEM);
705 
706  sdiv = s->band_multiplier;
707  for (i = 0; i < s->bin_count; i++)
708  s->bin2band[i] = lrint(sdiv * freq2bark((0.5 * i * s->sample_rate) / s->fft_length2));
709 
710  s->number_of_bands = s->bin2band[s->bin_count - 1] + 1;
711 
712  s->band_alpha = av_calloc(s->number_of_bands, sizeof(*s->band_alpha));
713  s->band_beta = av_calloc(s->number_of_bands, sizeof(*s->band_beta));
714  if (!s->band_alpha || !s->band_beta)
715  return AVERROR(ENOMEM);
716 
717  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
718  DeNoiseChannel *dnch = &s->dnch[ch];
719 
720  switch (s->noise_type) {
721  case WHITE_NOISE:
722  for (i = 0; i < NB_PROFILE_BANDS; i++)
723  dnch->band_noise[i] = 0.;
724  break;
725  case VINYL_NOISE:
726  for (i = 0; i < NB_PROFILE_BANDS; i++)
727  dnch->band_noise[i] = get_band_noise(s, i, 50.0, 500.5, 2125.0);
728  break;
729  case SHELLAC_NOISE:
730  for (i = 0; i < NB_PROFILE_BANDS; i++)
731  dnch->band_noise[i] = get_band_noise(s, i, 1.0, 500.0, 1.0E10);
732  break;
733  case CUSTOM_NOISE:
734  read_custom_noise(s, ch);
735  break;
736  default:
737  return AVERROR_BUG;
738  }
739 
740  reduce_mean(dnch->band_noise);
741 
742  dnch->amt = av_calloc(s->bin_count, sizeof(*dnch->amt));
743  dnch->band_amt = av_calloc(s->number_of_bands, sizeof(*dnch->band_amt));
744  dnch->band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->band_excit));
745  dnch->gain = av_calloc(s->bin_count, sizeof(*dnch->gain));
746  dnch->smoothed_gain = av_calloc(s->bin_count, sizeof(*dnch->smoothed_gain));
747  dnch->prior = av_calloc(s->bin_count, sizeof(*dnch->prior));
748  dnch->prior_band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->prior_band_excit));
749  dnch->clean_data = av_calloc(s->bin_count, sizeof(*dnch->clean_data));
750  dnch->noisy_data = av_calloc(s->bin_count, sizeof(*dnch->noisy_data));
751  dnch->out_samples = av_calloc(s->buffer_length, sizeof(*dnch->out_samples));
752  dnch->abs_var = av_calloc(s->bin_count, sizeof(*dnch->abs_var));
753  dnch->rel_var = av_calloc(s->bin_count, sizeof(*dnch->rel_var));
754  dnch->min_abs_var = av_calloc(s->bin_count, sizeof(*dnch->min_abs_var));
755  dnch->fft_in = av_calloc(s->fft_length2, s->sample_size);
756  dnch->fft_out = av_calloc(s->fft_length2 + 1, complex_sample_size);
757  ret = av_tx_init(&dnch->fft, &dnch->tx_fn, tx_type, 0, s->fft_length2, scale, 0);
758  if (ret < 0)
759  return ret;
760  ret = av_tx_init(&dnch->ifft, &dnch->itx_fn, tx_type, 1, s->fft_length2, scale, 0);
761  if (ret < 0)
762  return ret;
763  dnch->spread_function = av_calloc(s->number_of_bands * s->number_of_bands,
764  sizeof(*dnch->spread_function));
765 
766  if (!dnch->amt ||
767  !dnch->band_amt ||
768  !dnch->band_excit ||
769  !dnch->gain ||
770  !dnch->smoothed_gain ||
771  !dnch->prior ||
772  !dnch->prior_band_excit ||
773  !dnch->clean_data ||
774  !dnch->noisy_data ||
775  !dnch->out_samples ||
776  !dnch->fft_in ||
777  !dnch->fft_out ||
778  !dnch->abs_var ||
779  !dnch->rel_var ||
780  !dnch->min_abs_var ||
781  !dnch->spread_function ||
782  !dnch->fft ||
783  !dnch->ifft)
784  return AVERROR(ENOMEM);
785  }
786 
787  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
788  DeNoiseChannel *dnch = &s->dnch[ch];
789  double *prior_band_excit = dnch->prior_band_excit;
790  double min, max;
791  double p1, p2;
792 
793  p1 = pow(0.1, 2.5 / sdiv);
794  p2 = pow(0.1, 1.0 / sdiv);
795  j = 0;
796  for (m = 0; m < s->number_of_bands; m++) {
797  for (n = 0; n < s->number_of_bands; n++) {
798  if (n < m) {
799  dnch->spread_function[j++] = pow(p2, m - n);
800  } else if (n > m) {
801  dnch->spread_function[j++] = pow(p1, n - m);
802  } else {
803  dnch->spread_function[j++] = 1.0;
804  }
805  }
806  }
807 
808  for (m = 0; m < s->number_of_bands; m++) {
809  dnch->band_excit[m] = 0.0;
810  prior_band_excit[m] = 0.0;
811  }
812 
813  for (m = 0; m < s->bin_count; m++)
814  dnch->band_excit[s->bin2band[m]] += 1.0;
815 
816  j = 0;
817  for (m = 0; m < s->number_of_bands; m++) {
818  for (n = 0; n < s->number_of_bands; n++)
819  prior_band_excit[m] += dnch->spread_function[j++] * dnch->band_excit[n];
820  }
821 
822  min = pow(0.1, 2.5);
823  max = pow(0.1, 1.0);
824  for (int i = 0; i < s->number_of_bands; i++) {
825  if (i < lrint(12.0 * sdiv)) {
826  dnch->band_excit[i] = pow(0.1, 1.45 + 0.1 * i / sdiv);
827  } else {
828  dnch->band_excit[i] = pow(0.1, 2.5 - 0.2 * (i / sdiv - 14.0));
829  }
830  dnch->band_excit[i] = av_clipd(dnch->band_excit[i], min, max);
831  }
832 
833  for (int i = 0; i < s->buffer_length; i++)
834  dnch->out_samples[i] = 0;
835 
836  j = 0;
837  for (int i = 0; i < s->number_of_bands; i++)
838  for (int k = 0; k < s->number_of_bands; k++)
839  dnch->spread_function[j++] *= dnch->band_excit[i] / prior_band_excit[i];
840  }
841 
842  j = 0;
843  sar = s->sample_advance / s->sample_rate;
844  for (int i = 0; i < s->bin_count; i++) {
845  if ((i == s->fft_length2) || (s->bin2band[i] > j)) {
846  double d6 = (i - 1) * s->sample_rate / s->fft_length;
847  double d7 = fmin(0.008 + 2.2 / d6, 0.03);
848  s->band_alpha[j] = exp(-sar / d7);
849  s->band_beta[j] = 1.0 - s->band_alpha[j];
850  j = s->bin2band[i];
851  }
852  }
853 
854  s->winframe = ff_get_audio_buffer(inlink, s->window_length);
855  if (!s->winframe)
856  return AVERROR(ENOMEM);
857 
858  wscale = sqrt(8.0 / (9.0 * s->fft_length));
859  sum = 0.0;
860  for (int i = 0; i < s->window_length; i++) {
861  double d10 = sin(i * M_PI / s->window_length);
862  d10 *= wscale * d10;
863  s->window[i] = d10;
864  sum += d10 * d10;
865  }
866 
867  s->window_weight = 0.5 * sum;
868  s->floor = (1LL << 48) * exp(-23.025558369790467) * s->window_weight;
869  s->sample_floor = s->floor * exp(4.144600506562284);
870 
871  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
872  DeNoiseChannel *dnch = &s->dnch[ch];
873 
874  dnch->noise_reduction = s->noise_reduction;
875  dnch->noise_floor = s->noise_floor;
876  dnch->residual_floor = s->residual_floor;
877 
878  set_parameters(s, dnch, 1, 1);
879  }
880 
881  s->noise_band_edge[0] = FFMIN(s->fft_length2, s->fft_length * get_band_edge(s, 0) / s->sample_rate);
882  i = 0;
883  for (int j = 1; j < NB_PROFILE_BANDS + 1; j++) {
884  s->noise_band_edge[j] = FFMIN(s->fft_length2, s->fft_length * get_band_edge(s, j) / s->sample_rate);
885  if (s->noise_band_edge[j] > lrint(1.1 * s->noise_band_edge[j - 1]))
886  i++;
887  s->noise_band_edge[NB_PROFILE_BANDS + 1] = i;
888  }
889  s->noise_band_count = s->noise_band_edge[NB_PROFILE_BANDS + 1];
890 
891  return 0;
892 }
893 
895 {
896  for (int i = 0; i < NB_PROFILE_BANDS; i++) {
897  dnch->noise_band_norm[i] = 0.0;
898  dnch->noise_band_avr[i] = 0.0;
899  dnch->noise_band_avi[i] = 0.0;
900  dnch->noise_band_var[i] = 0.0;
901  }
902 }
903 
905  DeNoiseChannel *dnch,
906  AVFrame *in, int ch)
907 {
908  double *src_dbl = (double *)in->extended_data[ch];
909  float *src_flt = (float *)in->extended_data[ch];
910  double mag2, var = 0.0, avr = 0.0, avi = 0.0;
911  AVComplexDouble *fft_out_dbl = dnch->fft_out;
912  AVComplexFloat *fft_out_flt = dnch->fft_out;
913  double *fft_in_dbl = dnch->fft_in;
914  float *fft_in_flt = dnch->fft_in;
915  int edge, j, k, n, edgemax;
916 
917  switch (s->format) {
918  case AV_SAMPLE_FMT_FLTP:
919  for (int i = 0; i < s->window_length; i++)
920  fft_in_flt[i] = s->window[i] * src_flt[i] * (1LL << 23);
921 
922  for (int i = s->window_length; i < s->fft_length2; i++)
923  fft_in_flt[i] = 0.f;
924  break;
925  case AV_SAMPLE_FMT_DBLP:
926  for (int i = 0; i < s->window_length; i++)
927  fft_in_dbl[i] = s->window[i] * src_dbl[i] * (1LL << 23);
928 
929  for (int i = s->window_length; i < s->fft_length2; i++)
930  fft_in_dbl[i] = 0.;
931  break;
932  }
933 
934  dnch->tx_fn(dnch->fft, dnch->fft_out, dnch->fft_in, sizeof(s->sample_size));
935 
936  edge = s->noise_band_edge[0];
937  j = edge;
938  k = 0;
939  n = j;
940  edgemax = fmin(s->fft_length2, s->noise_band_edge[NB_PROFILE_BANDS]);
941  for (int i = j; i <= edgemax; i++) {
942  if ((i == j) && (i < edgemax)) {
943  if (j > edge) {
944  dnch->noise_band_norm[k - 1] += j - edge;
945  dnch->noise_band_avr[k - 1] += avr;
946  dnch->noise_band_avi[k - 1] += avi;
947  dnch->noise_band_var[k - 1] += var;
948  }
949  k++;
950  edge = j;
951  j = s->noise_band_edge[k];
952  if (k == NB_PROFILE_BANDS) {
953  j++;
954  }
955  var = 0.0;
956  avr = 0.0;
957  avi = 0.0;
958  }
959 
960  switch (s->format) {
961  case AV_SAMPLE_FMT_FLTP:
962  avr += fft_out_flt[n].re;
963  avi += fft_out_flt[n].im;
964  mag2 = fft_out_flt[n].re * fft_out_flt[n].re +
965  fft_out_flt[n].im * fft_out_flt[n].im;
966  break;
967  case AV_SAMPLE_FMT_DBLP:
968  avr += fft_out_dbl[n].re;
969  avi += fft_out_dbl[n].im;
970  mag2 = fft_out_dbl[n].re * fft_out_dbl[n].re +
971  fft_out_dbl[n].im * fft_out_dbl[n].im;
972  break;
973  }
974 
975  mag2 = fmax(mag2, s->sample_floor);
976 
977  var += mag2;
978  n++;
979  }
980 
981  dnch->noise_band_norm[k - 1] += j - edge;
982  dnch->noise_band_avr[k - 1] += avr;
983  dnch->noise_band_avi[k - 1] += avi;
984  dnch->noise_band_var[k - 1] += var;
985 }
986 
988  DeNoiseChannel *dnch,
989  double *sample_noise)
990 {
991  for (int i = 0; i < s->noise_band_count; i++) {
992  dnch->noise_band_avr[i] /= dnch->noise_band_norm[i];
993  dnch->noise_band_avi[i] /= dnch->noise_band_norm[i];
994  dnch->noise_band_var[i] /= dnch->noise_band_norm[i];
995  dnch->noise_band_var[i] -= dnch->noise_band_avr[i] * dnch->noise_band_avr[i] +
996  dnch->noise_band_avi[i] * dnch->noise_band_avi[i];
997  dnch->noise_band_auto_var[i] = dnch->noise_band_var[i];
998  sample_noise[i] = 10.0 * log10(dnch->noise_band_var[i] / s->floor) - 100.0;
999  }
1000  if (s->noise_band_count < NB_PROFILE_BANDS) {
1001  for (int i = s->noise_band_count; i < NB_PROFILE_BANDS; i++)
1002  sample_noise[i] = sample_noise[i - 1];
1003  }
1004 }
1005 
1007  DeNoiseChannel *dnch,
1008  double *sample_noise)
1009 {
1010  double new_band_noise[NB_PROFILE_BANDS];
1011  double temp[NB_PROFILE_BANDS];
1012  double sum = 0.0;
1013 
1014  for (int m = 0; m < NB_PROFILE_BANDS; m++)
1015  temp[m] = sample_noise[m];
1016 
1017  for (int m = 0, i = 0; m < SOLVE_SIZE; m++) {
1018  sum = 0.0;
1019  for (int n = 0; n < NB_PROFILE_BANDS; n++)
1020  sum += s->matrix_b[i++] * temp[n];
1021  s->vector_b[m] = sum;
1022  }
1023  solve(s->matrix_a, s->vector_b, SOLVE_SIZE);
1024  for (int m = 0, i = 0; m < NB_PROFILE_BANDS; m++) {
1025  sum = 0.0;
1026  for (int n = 0; n < SOLVE_SIZE; n++)
1027  sum += s->matrix_c[i++] * s->vector_b[n];
1028  temp[m] = sum;
1029  }
1030 
1031  reduce_mean(temp);
1032 
1033  av_log(s, AV_LOG_INFO, "bn=");
1034  for (int m = 0; m < NB_PROFILE_BANDS; m++) {
1035  new_band_noise[m] = temp[m];
1036  new_band_noise[m] = av_clipd(new_band_noise[m], -24.0, 24.0);
1037  av_log(s, AV_LOG_INFO, "%f ", new_band_noise[m]);
1038  }
1039  av_log(s, AV_LOG_INFO, "\n");
1040  memcpy(dnch->band_noise, new_band_noise, sizeof(new_band_noise));
1041 }
1042 
1043 static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
1044 {
1045  AudioFFTDeNoiseContext *s = ctx->priv;
1046  AVFrame *in = arg;
1047  const int start = (in->ch_layout.nb_channels * jobnr) / nb_jobs;
1048  const int end = (in->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
1049  const int window_length = s->window_length;
1050  const double *window = s->window;
1051 
1052  for (int ch = start; ch < end; ch++) {
1053  DeNoiseChannel *dnch = &s->dnch[ch];
1054  const double *src_dbl = (const double *)in->extended_data[ch];
1055  const float *src_flt = (const float *)in->extended_data[ch];
1056  double *dst = dnch->out_samples;
1057  double *fft_in_dbl = dnch->fft_in;
1058  float *fft_in_flt = dnch->fft_in;
1059 
1060  switch (s->format) {
1061  case AV_SAMPLE_FMT_FLTP:
1062  for (int m = 0; m < window_length; m++)
1063  fft_in_flt[m] = window[m] * src_flt[m] * (1LL << 23);
1064 
1065  for (int m = window_length; m < s->fft_length2; m++)
1066  fft_in_flt[m] = 0.f;
1067  break;
1068  case AV_SAMPLE_FMT_DBLP:
1069  for (int m = 0; m < window_length; m++)
1070  fft_in_dbl[m] = window[m] * src_dbl[m] * (1LL << 23);
1071 
1072  for (int m = window_length; m < s->fft_length2; m++)
1073  fft_in_dbl[m] = 0.;
1074  break;
1075  }
1076 
1077  dnch->tx_fn(dnch->fft, dnch->fft_out, dnch->fft_in, sizeof(s->sample_size));
1078 
1079  process_frame(ctx, s, dnch,
1080  dnch->prior,
1081  dnch->prior_band_excit,
1082  s->track_noise);
1083 
1084  dnch->itx_fn(dnch->ifft, dnch->fft_in, dnch->fft_out, sizeof(s->sample_size));
1085 
1086  switch (s->format) {
1087  case AV_SAMPLE_FMT_FLTP:
1088  for (int m = 0; m < window_length; m++)
1089  dst[m] += s->window[m] * fft_in_flt[m] / (1LL << 23);
1090  break;
1091  case AV_SAMPLE_FMT_DBLP:
1092  for (int m = 0; m < window_length; m++)
1093  dst[m] += s->window[m] * fft_in_dbl[m] / (1LL << 23);
1094  break;
1095  }
1096  }
1097 
1098  return 0;
1099 }
1100 
1102 {
1103  AVFilterContext *ctx = inlink->dst;
1104  AVFilterLink *outlink = ctx->outputs[0];
1105  AudioFFTDeNoiseContext *s = ctx->priv;
1106  const int output_mode = ctx->is_disabled ? IN_MODE : s->output_mode;
1107  const int offset = s->window_length - s->sample_advance;
1108  AVFrame *out;
1109 
1110  for (int ch = 0; ch < s->channels; ch++) {
1111  uint8_t *src = (uint8_t *)s->winframe->extended_data[ch];
1112 
1113  memmove(src, src + s->sample_advance * s->sample_size,
1114  offset * s->sample_size);
1115  memcpy(src + offset * s->sample_size, in->extended_data[ch],
1116  in->nb_samples * s->sample_size);
1117  memset(src + s->sample_size * (offset + in->nb_samples), 0,
1118  (s->sample_advance - in->nb_samples) * s->sample_size);
1119  }
1120 
1121  if (s->track_noise) {
1122  double average = 0.0, min = DBL_MAX, max = -DBL_MAX;
1123 
1124  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1125  DeNoiseChannel *dnch = &s->dnch[ch];
1126 
1127  average += dnch->noise_floor;
1128  max = fmax(max, dnch->noise_floor);
1129  min = fmin(min, dnch->noise_floor);
1130  }
1131 
1132  average /= inlink->ch_layout.nb_channels;
1133 
1134  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1135  DeNoiseChannel *dnch = &s->dnch[ch];
1136 
1137  switch (s->noise_floor_link) {
1138  case MIN_LINK: dnch->noise_floor = min; break;
1139  case MAX_LINK: dnch->noise_floor = max; break;
1140  case AVERAGE_LINK: dnch->noise_floor = average; break;
1141  case NONE_LINK:
1142  default:
1143  break;
1144  }
1145 
1146  if (dnch->noise_floor != dnch->last_noise_floor)
1147  set_parameters(s, dnch, 1, 0);
1148  }
1149  }
1150 
1151  if (s->sample_noise_mode == SAMPLE_START) {
1152  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1153  DeNoiseChannel *dnch = &s->dnch[ch];
1154 
1155  init_sample_noise(dnch);
1156  }
1157  s->sample_noise_mode = SAMPLE_NONE;
1158  s->sample_noise = 1;
1159  s->sample_noise_blocks = 0;
1160  }
1161 
1162  if (s->sample_noise) {
1163  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1164  DeNoiseChannel *dnch = &s->dnch[ch];
1165 
1166  sample_noise_block(s, dnch, s->winframe, ch);
1167  }
1168  s->sample_noise_blocks++;
1169  }
1170 
1171  if (s->sample_noise_mode == SAMPLE_STOP) {
1172  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1173  DeNoiseChannel *dnch = &s->dnch[ch];
1174  double sample_noise[NB_PROFILE_BANDS];
1175 
1176  if (s->sample_noise_blocks <= 0)
1177  break;
1178  finish_sample_noise(s, dnch, sample_noise);
1179  set_noise_profile(s, dnch, sample_noise);
1180  set_parameters(s, dnch, 1, 1);
1181  }
1182  s->sample_noise = 0;
1183  s->sample_noise_blocks = 0;
1184  s->sample_noise_mode = SAMPLE_NONE;
1185  }
1186 
1187  ff_filter_execute(ctx, filter_channel, s->winframe, NULL,
1189 
1190  if (av_frame_is_writable(in)) {
1191  out = in;
1192  } else {
1193  out = ff_get_audio_buffer(outlink, in->nb_samples);
1194  if (!out) {
1195  av_frame_free(&in);
1196  return AVERROR(ENOMEM);
1197  }
1198 
1199  out->pts = in->pts;
1200  }
1201 
1202  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1203  DeNoiseChannel *dnch = &s->dnch[ch];
1204  double *src = dnch->out_samples;
1205  const double *orig_dbl = (const double *)s->winframe->extended_data[ch];
1206  const float *orig_flt = (const float *)s->winframe->extended_data[ch];
1207  double *dst_dbl = (double *)out->extended_data[ch];
1208  float *dst_flt = (float *)out->extended_data[ch];
1209 
1210  switch (output_mode) {
1211  case IN_MODE:
1212  switch (s->format) {
1213  case AV_SAMPLE_FMT_FLTP:
1214  for (int m = 0; m < out->nb_samples; m++)
1215  dst_flt[m] = orig_flt[m];
1216  break;
1217  case AV_SAMPLE_FMT_DBLP:
1218  for (int m = 0; m < out->nb_samples; m++)
1219  dst_dbl[m] = orig_dbl[m];
1220  break;
1221  }
1222  break;
1223  case OUT_MODE:
1224  switch (s->format) {
1225  case AV_SAMPLE_FMT_FLTP:
1226  for (int m = 0; m < out->nb_samples; m++)
1227  dst_flt[m] = src[m];
1228  break;
1229  case AV_SAMPLE_FMT_DBLP:
1230  for (int m = 0; m < out->nb_samples; m++)
1231  dst_dbl[m] = src[m];
1232  break;
1233  }
1234  break;
1235  case NOISE_MODE:
1236  switch (s->format) {
1237  case AV_SAMPLE_FMT_FLTP:
1238  for (int m = 0; m < out->nb_samples; m++)
1239  dst_flt[m] = orig_flt[m] - src[m];
1240  break;
1241  case AV_SAMPLE_FMT_DBLP:
1242  for (int m = 0; m < out->nb_samples; m++)
1243  dst_dbl[m] = orig_dbl[m] - src[m];
1244  break;
1245  }
1246  break;
1247  default:
1248  if (in != out)
1249  av_frame_free(&in);
1250  av_frame_free(&out);
1251  return AVERROR_BUG;
1252  }
1253 
1254  memmove(src, src + s->sample_advance, (s->window_length - s->sample_advance) * sizeof(*src));
1255  memset(src + (s->window_length - s->sample_advance), 0, s->sample_advance * sizeof(*src));
1256  }
1257 
1258  if (out != in)
1259  av_frame_free(&in);
1260  return ff_filter_frame(outlink, out);
1261 }
1262 
1264 {
1265  AVFilterLink *inlink = ctx->inputs[0];
1266  AVFilterLink *outlink = ctx->outputs[0];
1267  AudioFFTDeNoiseContext *s = ctx->priv;
1268  AVFrame *in = NULL;
1269  int ret;
1270 
1272 
1273  ret = ff_inlink_consume_samples(inlink, s->sample_advance, s->sample_advance, &in);
1274  if (ret < 0)
1275  return ret;
1276  if (ret > 0)
1277  return output_frame(inlink, in);
1278 
1279  if (ff_inlink_queued_samples(inlink) >= s->sample_advance) {
1280  ff_filter_set_ready(ctx, 10);
1281  return 0;
1282  }
1283 
1284  FF_FILTER_FORWARD_STATUS(inlink, outlink);
1285  FF_FILTER_FORWARD_WANTED(outlink, inlink);
1286 
1287  return FFERROR_NOT_READY;
1288 }
1289 
1291 {
1292  AudioFFTDeNoiseContext *s = ctx->priv;
1293 
1294  av_freep(&s->window);
1295  av_freep(&s->bin2band);
1296  av_freep(&s->band_alpha);
1297  av_freep(&s->band_beta);
1298  av_frame_free(&s->winframe);
1299 
1300  if (s->dnch) {
1301  for (int ch = 0; ch < s->channels; ch++) {
1302  DeNoiseChannel *dnch = &s->dnch[ch];
1303  av_freep(&dnch->amt);
1304  av_freep(&dnch->band_amt);
1305  av_freep(&dnch->band_excit);
1306  av_freep(&dnch->gain);
1307  av_freep(&dnch->smoothed_gain);
1308  av_freep(&dnch->prior);
1309  av_freep(&dnch->prior_band_excit);
1310  av_freep(&dnch->clean_data);
1311  av_freep(&dnch->noisy_data);
1312  av_freep(&dnch->out_samples);
1313  av_freep(&dnch->spread_function);
1314  av_freep(&dnch->abs_var);
1315  av_freep(&dnch->rel_var);
1316  av_freep(&dnch->min_abs_var);
1317  av_freep(&dnch->fft_in);
1318  av_freep(&dnch->fft_out);
1319  av_tx_uninit(&dnch->fft);
1320  av_tx_uninit(&dnch->ifft);
1321  }
1322  av_freep(&s->dnch);
1323  }
1324 }
1325 
1326 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
1327  char *res, int res_len, int flags)
1328 {
1329  AudioFFTDeNoiseContext *s = ctx->priv;
1330  int ret = 0;
1331 
1332  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
1333  if (ret < 0)
1334  return ret;
1335 
1336  if (!strcmp(cmd, "sample_noise") || !strcmp(cmd, "sn"))
1337  return 0;
1338 
1339  for (int ch = 0; ch < s->channels; ch++) {
1340  DeNoiseChannel *dnch = &s->dnch[ch];
1341 
1342  dnch->noise_reduction = s->noise_reduction;
1343  dnch->noise_floor = s->noise_floor;
1344  dnch->residual_floor = s->residual_floor;
1345 
1346  set_parameters(s, dnch, 1, 1);
1347  }
1348 
1349  return 0;
1350 }
1351 
1352 static const AVFilterPad inputs[] = {
1353  {
1354  .name = "default",
1355  .type = AVMEDIA_TYPE_AUDIO,
1356  .config_props = config_input,
1357  },
1358 };
1359 
1360 static const AVFilterPad outputs[] = {
1361  {
1362  .name = "default",
1363  .type = AVMEDIA_TYPE_AUDIO,
1364  },
1365 };
1366 
1368  .name = "afftdn",
1369  .description = NULL_IF_CONFIG_SMALL("Denoise audio samples using FFT."),
1370  .priv_size = sizeof(AudioFFTDeNoiseContext),
1371  .priv_class = &afftdn_class,
1372  .activate = activate,
1373  .uninit = uninit,
1377  .process_command = process_command,
1380 };
NB_PROFILE_BANDS
#define NB_PROFILE_BANDS
Definition: af_afftdn.c:34
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:100
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
NB_MODES
@ NB_MODES
Definition: af_afftdn.c:47
DeNoiseChannel::noise_floor
double noise_floor
Definition: af_afftdn.c:96
AudioFFTDeNoiseContext::floor
double floor
Definition: af_afftdn.c:150
DeNoiseChannel::clean_data
double * clean_data
Definition: af_afftdn.c:77
DeNoiseChannel::noise_band_auto_var
double noise_band_auto_var[NB_PROFILE_BANDS]
Definition: af_afftdn.c:68
C
#define C
Definition: af_afftdn.c:32
DeNoiseChannel::ifft
AVTXContext * ifft
Definition: af_afftdn.c:86
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1009
activate
static int activate(AVFilterContext *ctx)
Definition: af_afftdn.c:1263
inputs
static const AVFilterPad inputs[]
Definition: af_afftdn.c:1352
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
matrix
Definition: vc1dsp.c:42
AVTXContext
Definition: tx_priv.h:202
AudioFFTDeNoiseContext::window_weight
double window_weight
Definition: af_afftdn.c:149
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
ff_clz
#define ff_clz
Definition: intmath.h:143
solve
static void solve(double *matrix, double *vector, int size)
Definition: af_afftdn.c:252
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
im
float im
Definition: fft.c:79
OUT_MODE
@ OUT_MODE
Definition: af_afftdn.c:45
SOLVE_SIZE
#define SOLVE_SIZE
Definition: af_afftdn.c:33
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:432
process_frame
static void process_frame(AVFilterContext *ctx, AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *prior, double *prior_band_excit, int track_noise)
Definition: af_afftdn.c:351
sample_noise_block
static void sample_noise_block(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, AVFrame *in, int ch)
Definition: af_afftdn.c:904
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
NONE_LINK
@ NONE_LINK
Definition: af_afftdn.c:51
AVComplexDouble::im
double im
Definition: tx.h:32
float.h
AVComplexFloat
Definition: tx.h:27
max
#define max(a, b)
Definition: cuda_runtime.h:33
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
DeNoiseChannel::max_var
double max_var
Definition: af_afftdn.c:101
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:303
AudioFFTDeNoiseContext::fft_length2
int fft_length2
Definition: af_afftdn.c:132
AudioFFTDeNoiseContext::vector_b
double vector_b[SOLVE_SIZE]
Definition: af_afftdn.c:156
DeNoiseChannel::band_amt
double * band_amt
Definition: af_afftdn.c:71
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
AudioFFTDeNoiseContext::noise_floor_link
int noise_floor_link
Definition: af_afftdn.c:119
AudioFFTDeNoiseContext::sample_noise_mode
int sample_noise_mode
Definition: af_afftdn.c:128
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:651
NoiseType
NoiseType
Definition: af_afftdn.c:58
formats.h
S
#define S(s, c, i)
Definition: flacdsp_template.c:46
DeNoiseChannel::noise_band_norm
double noise_band_norm[NB_PROFILE_BANDS]
Definition: af_afftdn.c:89
factor
static void factor(double *array, int size)
Definition: af_afftdn.c:238
DeNoiseChannel::noise_band_avr
double noise_band_avr[NB_PROFILE_BANDS]
Definition: af_afftdn.c:90
config_input
static int config_input(AVFilterLink *inlink)
Definition: af_afftdn.c:626
AudioFFTDeNoiseContext::residual_floor
float residual_floor
Definition: af_afftdn.c:115
AudioFFTDeNoiseContext::buffer_length
int buffer_length
Definition: af_afftdn.c:130
AVComplexFloat::im
float im
Definition: tx.h:28
window
static SDL_Window * window
Definition: ffplay.c:365
freq2bark
static double freq2bark(double x)
Definition: af_afftdn.c:481
AudioFFTDeNoiseContext::number_of_bands
int number_of_bands
Definition: af_afftdn.c:136
DeNoiseChannel::band_noise
double band_noise[NB_PROFILE_BANDS]
Definition: af_afftdn.c:67
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:709
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
AudioFFTDeNoiseContext::window_length
int window_length
Definition: af_afftdn.c:134
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
lrint
#define lrint
Definition: tablegen.h:53
AudioFFTDeNoiseContext::dnch
DeNoiseChannel * dnch
Definition: af_afftdn.c:145
AudioFFTDeNoiseContext::sample_size
size_t sample_size
Definition: af_afftdn.c:109
DeNoiseChannel::spread_function
double * spread_function
Definition: af_afftdn.c:80
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
OFFSET
#define OFFSET(x)
Definition: af_afftdn.c:161
NoiseLinkType
NoiseLinkType
Definition: af_afftdn.c:50
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:111
float
float
Definition: af_crystalizer.c:122
DeNoiseChannel::last_noise_reduction
double last_noise_reduction
Definition: af_afftdn.c:95
afftdn_options
static const AVOption afftdn_options[]
Definition: af_afftdn.c:165
s
#define s(width, name)
Definition: cbs_vp9.c:256
AudioFFTDeNoiseContext::winframe
AVFrame * winframe
Definition: af_afftdn.c:147
NB_NOISE
@ NB_NOISE
Definition: af_afftdn.c:63
AudioFFTDeNoiseContext::matrix_a
double matrix_a[SOLVE_SIZE *SOLVE_SIZE]
Definition: af_afftdn.c:155
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:189
AudioFFTDeNoiseContext
Definition: af_afftdn.c:105
DeNoiseChannel::gain
double * gain
Definition: af_afftdn.c:73
filters.h
DeNoiseChannel::rel_var
double * rel_var
Definition: af_afftdn.c:82
DeNoiseChannel
Definition: af_afftdn.c:66
DeNoiseChannel::min_abs_var
double * min_abs_var
Definition: af_afftdn.c:83
ctx
AVFormatContext * ctx
Definition: movenc.c:48
DeNoiseChannel::noise_band_sample
double noise_band_sample[NB_PROFILE_BANDS]
Definition: af_afftdn.c:69
DeNoiseChannel::fft_out
void * fft_out
Definition: af_afftdn.c:85
AudioFFTDeNoiseContext::sample_noise_blocks
int sample_noise_blocks
Definition: af_afftdn.c:127
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:190
E
#define E
Definition: avdct.c:32
get_band_edge
static int get_band_edge(AudioFFTDeNoiseContext *s, int band)
Definition: af_afftdn.c:496
arg
const char * arg
Definition: jacosubdec.c:67
AF
#define AF
Definition: af_afftdn.c:162
av_sscanf
int av_sscanf(const char *string, const char *format,...)
See libc sscanf manual for more information.
Definition: avsscanf.c:962
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1423
NULL
#define NULL
Definition: coverity.c:32
DeNoiseChannel::last_noise_floor
double last_noise_floor
Definition: af_afftdn.c:97
DeNoiseChannel::max_gain
double max_gain
Definition: af_afftdn.c:100
DeNoiseChannel::residual_floor
double residual_floor
Definition: af_afftdn.c:98
AudioFFTDeNoiseContext::matrix_b
double matrix_b[SOLVE_SIZE *NB_PROFILE_BANDS]
Definition: af_afftdn.c:157
SampleNoiseModes
SampleNoiseModes
Definition: af_afftdn.c:36
AudioFFTDeNoiseContext::ratio
float ratio
Definition: af_afftdn.c:120
filter_channel
static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_afftdn.c:1043
AudioFFTDeNoiseContext::noise_type
int noise_type
Definition: af_afftdn.c:113
NB_SAMPLEMODES
@ NB_SAMPLEMODES
Definition: af_afftdn.c:40
double
double
Definition: af_crystalizer.c:132
set_band_parameters
static void set_band_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch)
Definition: af_afftdn.c:509
WHITE_NOISE
@ WHITE_NOISE
Definition: af_afftdn.c:59
exp
int8_t exp
Definition: eval.c:72
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
init_sample_noise
static void init_sample_noise(DeNoiseChannel *dnch)
Definition: af_afftdn.c:894
NOISE_MODE
@ NOISE_MODE
Definition: af_afftdn.c:46
read_custom_noise
static void read_custom_noise(AudioFFTDeNoiseContext *s, int ch)
Definition: af_afftdn.c:539
AudioFFTDeNoiseContext::sample_advance
int sample_advance
Definition: af_afftdn.c:135
OutModes
OutModes
Definition: af_afftdn.c:43
DeNoiseChannel::last_residual_floor
double last_residual_floor
Definition: af_afftdn.c:99
f
f
Definition: af_crystalizer.c:122
AudioFFTDeNoiseContext::output_mode
int output_mode
Definition: af_afftdn.c:118
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:115
NB_LINK
@ NB_LINK
Definition: af_afftdn.c:55
outputs
static const AVFilterPad outputs[]
Definition: af_afftdn.c:1360
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AudioFFTDeNoiseContext::format
int format
Definition: af_afftdn.c:108
output_frame
static int output_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_afftdn.c:1101
fmin
double fmin(double, double)
hypot
static av_const double hypot(double x, double y)
Definition: libm.h:366
size
int size
Definition: twinvq_data.h:10344
AVComplexFloat::re
float re
Definition: tx.h:28
AudioFFTDeNoiseContext::matrix_c
double matrix_c[SOLVE_SIZE *NB_PROFILE_BANDS]
Definition: af_afftdn.c:158
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:533
AudioFFTDeNoiseContext::track_noise
int track_noise
Definition: af_afftdn.c:116
AudioFFTDeNoiseContext::noise_reduction
float noise_reduction
Definition: af_afftdn.c:111
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:873
AudioFFTDeNoiseContext::window
double * window
Definition: af_afftdn.c:141
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
finish_sample_noise
static void finish_sample_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise)
Definition: af_afftdn.c:987
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
VINYL_NOISE
@ VINYL_NOISE
Definition: af_afftdn.c:60
AudioFFTDeNoiseContext::band_alpha
double * band_alpha
Definition: af_afftdn.c:142
limit_gain
static double limit_gain(double a, double b)
Definition: af_afftdn.c:301
MIN_LINK
@ MIN_LINK
Definition: af_afftdn.c:52
AudioFFTDeNoiseContext::channels
int channels
Definition: af_afftdn.c:125
M_PI
#define M_PI
Definition: mathematics.h:52
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:248
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afftdn.c:1290
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
DeNoiseChannel::out_samples
double * out_samples
Definition: af_afftdn.c:79
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:405
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
DeNoiseChannel::itx_fn
av_tx_fn itx_fn
Definition: af_afftdn.c:87
DeNoiseChannel::fft
AVTXContext * fft
Definition: af_afftdn.c:86
AudioFFTDeNoiseContext::gain_smooth
int gain_smooth
Definition: af_afftdn.c:121
SAMPLE_START
@ SAMPLE_START
Definition: af_afftdn.c:38
DeNoiseChannel::noise_band_avi
double noise_band_avi[NB_PROFILE_BANDS]
Definition: af_afftdn.c:91
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:386
DeNoiseChannel::prior_band_excit
double * prior_band_excit
Definition: af_afftdn.c:76
SAMPLE_NONE
@ SAMPLE_NONE
Definition: af_afftdn.c:37
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:793
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_afftdn.c:1326
SAMPLE_STOP
@ SAMPLE_STOP
Definition: af_afftdn.c:39
DeNoiseChannel::smoothed_gain
double * smoothed_gain
Definition: af_afftdn.c:74
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_TX_DOUBLE_RDFT
@ AV_TX_DOUBLE_RDFT
Definition: tx.h:89
SHELLAC_NOISE
@ SHELLAC_NOISE
Definition: af_afftdn.c:61
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1383
AVComplexDouble
Definition: tx.h:31
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
AudioFFTDeNoiseContext::track_residual
int track_residual
Definition: af_afftdn.c:117
AudioFFTDeNoiseContext::noise_floor
float noise_floor
Definition: af_afftdn.c:112
limit
static double limit(double x)
Definition: vf_pseudocolor.c:128
AVFilter
Filter definition.
Definition: avfilter.h:171
DeNoiseChannel::amt
double * amt
Definition: af_afftdn.c:70
AVERAGE_LINK
@ AVERAGE_LINK
Definition: af_afftdn.c:54
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:111
ret
ret
Definition: filter_design.txt:187
AVComplexDouble::re
double re
Definition: tx.h:32
MAX_LINK
@ MAX_LINK
Definition: af_afftdn.c:53
get_band_noise
static double get_band_noise(AudioFFTDeNoiseContext *s, int band, double a, double b, double c)
Definition: af_afftdn.c:222
AudioFFTDeNoiseContext::bin2band
int * bin2band
Definition: af_afftdn.c:140
CUSTOM_NOISE
@ CUSTOM_NOISE
Definition: af_afftdn.c:62
IN_MODE
@ IN_MODE
Definition: af_afftdn.c:44
DeNoiseChannel::noisy_data
double * noisy_data
Definition: af_afftdn.c:78
AudioFFTDeNoiseContext::floor_offset
float floor_offset
Definition: af_afftdn.c:123
AV_TX_FLOAT_RDFT
@ AV_TX_FLOAT_RDFT
Real to complex and complex to real DFTs.
Definition: tx.h:88
fmax
double fmax(double, double)
AudioFFTDeNoiseContext::noise_band_count
int noise_band_count
Definition: af_afftdn.c:154
AFR
#define AFR
Definition: af_afftdn.c:163
AudioFFTDeNoiseContext::band_noise_str
char * band_noise_str
Definition: af_afftdn.c:114
DeNoiseChannel::tx_fn
av_tx_fn tx_fn
Definition: af_afftdn.c:87
power
static float power(float r, float g, float b, float max)
Definition: preserve_color.h:45
channel_layout.h
set_parameters
static void set_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int update_var, int update_auto_var)
Definition: af_afftdn.c:574
process_get_band_noise
static double process_get_band_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int band)
Definition: af_afftdn.c:271
noise
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:120
spectral_flatness
static void spectral_flatness(AudioFFTDeNoiseContext *s, const double *const spectral, double floor, int len, double *rnum, double *rden)
Definition: af_afftdn.c:310
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
DeNoiseChannel::band_excit
double * band_excit
Definition: af_afftdn.c:72
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
temp
else temp
Definition: vf_mcdeint.c:248
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:857
DeNoiseChannel::noise_reduction
double noise_reduction
Definition: af_afftdn.c:94
AudioFFTDeNoiseContext::band_beta
double * band_beta
Definition: af_afftdn.c:143
AVFilterContext
An instance of a filter.
Definition: avfilter.h:408
DeNoiseChannel::noise_band_var
double noise_band_var[NB_PROFILE_BANDS]
Definition: af_afftdn.c:92
AudioFFTDeNoiseContext::band_centre
int band_centre[NB_PROFILE_BANDS]
Definition: af_afftdn.c:138
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:127
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(afftdn)
audio.h
M_LN10
#define M_LN10
Definition: mathematics.h:43
DeNoiseChannel::prior
double * prior
Definition: af_afftdn.c:75
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
DeNoiseChannel::fft_in
void * fft_in
Definition: af_afftdn.c:84
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
floor_offset
static double floor_offset(const double *S, int size, double mean)
Definition: af_afftdn.c:338
AudioFFTDeNoiseContext::noise_band_edge
int noise_band_edge[NB_PROFILE_BANDS+2]
Definition: af_afftdn.c:153
d
d
Definition: ffmpeg_filter.c:156
AudioFFTDeNoiseContext::bin_count
int bin_count
Definition: af_afftdn.c:133
reduce_mean
static void reduce_mean(double *band_noise)
Definition: af_afftdn.c:614
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:160
AudioFFTDeNoiseContext::sample_noise
int sample_noise
Definition: af_afftdn.c:126
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AudioFFTDeNoiseContext::fft_length
int fft_length
Definition: af_afftdn.c:131
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AudioFFTDeNoiseContext::sample_floor
double sample_floor
Definition: af_afftdn.c:151
set_noise_profile
static void set_noise_profile(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise)
Definition: af_afftdn.c:1006
DeNoiseChannel::abs_var
double * abs_var
Definition: af_afftdn.c:81
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:142
get_band_centre
static int get_band_centre(AudioFFTDeNoiseContext *s, int band)
Definition: af_afftdn.c:488
AudioFFTDeNoiseContext::sample_rate
float sample_rate
Definition: af_afftdn.c:129
DeNoiseChannel::gain_scale
double gain_scale
Definition: af_afftdn.c:102
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_af_afftdn
const AVFilter ff_af_afftdn
Definition: af_afftdn.c:1367
AudioFFTDeNoiseContext::band_multiplier
float band_multiplier
Definition: af_afftdn.c:122
av_clipd
av_clipd
Definition: af_crystalizer.c:132
FILTER_SAMPLEFMTS
#define FILTER_SAMPLEFMTS(...)
Definition: internal.h:178
ff_filter_set_ready
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:199
tx.h
re
float re
Definition: fft.c:79
min
float min
Definition: vorbis_enc_data.h:429