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"
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/tx.h"
27 #include "avfilter.h"
28 #include "audio.h"
29 #include "filters.h"
30 
31 #define C (M_LN10 * 0.1)
32 #define SOLVE_SIZE (5)
33 #define NB_PROFILE_BANDS (15)
34 
35 enum SampleNoiseModes {
36  SAMPLE_NONE,
37  SAMPLE_START,
38  SAMPLE_STOP,
39  NB_SAMPLEMODES
40 };
41 
42 enum OutModes {
43  IN_MODE,
44  OUT_MODE,
45  NOISE_MODE,
46  NB_MODES
47 };
48 
49 enum NoiseLinkType {
50  NONE_LINK,
51  MIN_LINK,
52  MAX_LINK,
53  AVERAGE_LINK,
54  NB_LINK
55 };
56 
57 enum NoiseType {
58  WHITE_NOISE,
59  VINYL_NOISE,
60  SHELLAC_NOISE,
61  CUSTOM_NOISE,
62  NB_NOISE
63 };
64 
65 typedef struct DeNoiseChannel {
66  double band_noise[NB_PROFILE_BANDS];
67  double noise_band_auto_var[NB_PROFILE_BANDS];
68  double noise_band_sample[NB_PROFILE_BANDS];
69  double *amt;
70  double *band_amt;
71  double *band_excit;
72  double *gain;
73  double *smoothed_gain;
74  double *prior;
75  double *prior_band_excit;
76  double *clean_data;
77  double *noisy_data;
78  double *out_samples;
79  double *spread_function;
80  double *abs_var;
81  double *rel_var;
82  double *min_abs_var;
83  void *fft_in;
84  void *fft_out;
85  AVTXContext *fft, *ifft;
86  av_tx_fn tx_fn, itx_fn;
87 
88  double noise_band_norm[NB_PROFILE_BANDS];
89  double noise_band_avr[NB_PROFILE_BANDS];
90  double noise_band_avi[NB_PROFILE_BANDS];
91  double noise_band_var[NB_PROFILE_BANDS];
92 
93  double noise_reduction;
94  double last_noise_reduction;
95  double noise_floor;
96  double last_noise_floor;
97  double residual_floor;
98  double last_residual_floor;
99  double max_gain;
100  double max_var;
101  double gain_scale;
102 } DeNoiseChannel;
103 
104 typedef struct AudioFFTDeNoiseContext {
105  const AVClass *class;
106 
107  int format;
108  size_t sample_size;
109  size_t complex_sample_size;
110 
111  float noise_reduction;
112  float noise_floor;
113  int noise_type;
114  char *band_noise_str;
115  float residual_floor;
116  int track_noise;
117  int track_residual;
118  int output_mode;
119  int noise_floor_link;
120  float ratio;
121  int gain_smooth;
122  float band_multiplier;
123  float floor_offset;
124 
125  int channels;
126  int sample_noise;
127  int sample_noise_blocks;
128  int sample_noise_mode;
129  float sample_rate;
130  int buffer_length;
131  int fft_length;
132  int fft_length2;
133  int bin_count;
134  int window_length;
135  int sample_advance;
136  int number_of_bands;
137 
138  int band_centre[NB_PROFILE_BANDS];
139 
140  int *bin2band;
141  double *window;
142  double *band_alpha;
143  double *band_beta;
144 
145  DeNoiseChannel *dnch;
146 
147  AVFrame *winframe;
148 
149  double window_weight;
150  double floor;
151  double sample_floor;
152 
153  int noise_band_edge[NB_PROFILE_BANDS + 2];
154  int noise_band_count;
155  double matrix_a[SOLVE_SIZE * SOLVE_SIZE];
156  double vector_b[SOLVE_SIZE];
157  double matrix_b[SOLVE_SIZE * NB_PROFILE_BANDS];
158  double matrix_c[SOLVE_SIZE * NB_PROFILE_BANDS];
159 } AudioFFTDeNoiseContext;
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 
222 static double get_band_noise(AudioFFTDeNoiseContext *s,
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 
271 static double process_get_band_noise(AudioFFTDeNoiseContext *s,
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 
351 static void process_frame(AVFilterContext *ctx,
352  AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch,
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 
488 static int get_band_centre(AudioFFTDeNoiseContext *s, int band)
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 
509 static void set_band_parameters(AudioFFTDeNoiseContext *s,
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 
539 static void read_custom_noise(AudioFFTDeNoiseContext *s, int ch)
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)
580  dnch->last_noise_floor = fmax(dnch->last_noise_floor, dnch->residual_floor);
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;
597  dnch->last_noise_reduction = dnch->noise_reduction;
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];
620  mean /= NB_PROFILE_BANDS;
621 
622  for (int i = 0; i < NB_PROFILE_BANDS; i++)
623  band_noise[i] -= mean;
624 }
625 
626 static int config_input(AVFilterLink *inlink)
627 {
628  AVFilterContext *ctx = inlink->dst;
629  AudioFFTDeNoiseContext *s = ctx->priv;
630  double wscale, sar, sum, sdiv;
631  int i, j, k, m, n, ret, tx_type;
632  double dscale = 1.;
633  float fscale = 1.f;
634  void *scale;
635 
636  s->format = inlink->format;
637 
638  switch (s->format) {
639  case AV_SAMPLE_FMT_FLTP:
640  s->sample_size = sizeof(float);
641  s->complex_sample_size = sizeof(AVComplexFloat);
642  tx_type = AV_TX_FLOAT_RDFT;
643  scale = &fscale;
644  break;
645  case AV_SAMPLE_FMT_DBLP:
646  s->sample_size = sizeof(double);
647  s->complex_sample_size = sizeof(AVComplexDouble);
648  tx_type = AV_TX_DOUBLE_RDFT;
649  scale = &dscale;
650  break;
651  }
652 
653  s->dnch = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->dnch));
654  if (!s->dnch)
655  return AVERROR(ENOMEM);
656 
657  s->channels = inlink->ch_layout.nb_channels;
658  s->sample_rate = inlink->sample_rate;
659  s->sample_advance = s->sample_rate / 80;
660  s->window_length = 3 * s->sample_advance;
661  s->fft_length2 = 1 << (32 - ff_clz(s->window_length));
662  s->fft_length = s->fft_length2;
663  s->buffer_length = s->fft_length * 2;
664  s->bin_count = s->fft_length2 / 2 + 1;
665 
666  s->band_centre[0] = 80;
667  for (i = 1; i < NB_PROFILE_BANDS; i++) {
668  s->band_centre[i] = lrint(1.5 * s->band_centre[i - 1] + 5.0);
669  if (s->band_centre[i] < 1000) {
670  s->band_centre[i] = 10 * (s->band_centre[i] / 10);
671  } else if (s->band_centre[i] < 5000) {
672  s->band_centre[i] = 50 * ((s->band_centre[i] + 20) / 50);
673  } else if (s->band_centre[i] < 15000) {
674  s->band_centre[i] = 100 * ((s->band_centre[i] + 45) / 100);
675  } else {
676  s->band_centre[i] = 1000 * ((s->band_centre[i] + 495) / 1000);
677  }
678  }
679 
680  for (j = 0; j < SOLVE_SIZE; j++) {
681  for (k = 0; k < SOLVE_SIZE; k++) {
682  s->matrix_a[j + k * SOLVE_SIZE] = 0.0;
683  for (m = 0; m < NB_PROFILE_BANDS; m++)
684  s->matrix_a[j + k * SOLVE_SIZE] += pow(m, j + k);
685  }
686  }
687 
688  factor(s->matrix_a, SOLVE_SIZE);
689 
690  i = 0;
691  for (j = 0; j < SOLVE_SIZE; j++)
692  for (k = 0; k < NB_PROFILE_BANDS; k++)
693  s->matrix_b[i++] = pow(k, j);
694 
695  i = 0;
696  for (j = 0; j < NB_PROFILE_BANDS; j++)
697  for (k = 0; k < SOLVE_SIZE; k++)
698  s->matrix_c[i++] = pow(j, k);
699 
700  s->window = av_calloc(s->window_length, sizeof(*s->window));
701  s->bin2band = av_calloc(s->bin_count, sizeof(*s->bin2band));
702  if (!s->window || !s->bin2band)
703  return AVERROR(ENOMEM);
704 
705  sdiv = s->band_multiplier;
706  for (i = 0; i < s->bin_count; i++)
707  s->bin2band[i] = lrint(sdiv * freq2bark((0.5 * i * s->sample_rate) / s->fft_length2));
708 
709  s->number_of_bands = s->bin2band[s->bin_count - 1] + 1;
710 
711  s->band_alpha = av_calloc(s->number_of_bands, sizeof(*s->band_alpha));
712  s->band_beta = av_calloc(s->number_of_bands, sizeof(*s->band_beta));
713  if (!s->band_alpha || !s->band_beta)
714  return AVERROR(ENOMEM);
715 
716  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
717  DeNoiseChannel *dnch = &s->dnch[ch];
718 
719  switch (s->noise_type) {
720  case WHITE_NOISE:
721  for (i = 0; i < NB_PROFILE_BANDS; i++)
722  dnch->band_noise[i] = 0.;
723  break;
724  case VINYL_NOISE:
725  for (i = 0; i < NB_PROFILE_BANDS; i++)
726  dnch->band_noise[i] = get_band_noise(s, i, 50.0, 500.5, 2125.0);
727  break;
728  case SHELLAC_NOISE:
729  for (i = 0; i < NB_PROFILE_BANDS; i++)
730  dnch->band_noise[i] = get_band_noise(s, i, 1.0, 500.0, 1.0E10);
731  break;
732  case CUSTOM_NOISE:
733  read_custom_noise(s, ch);
734  break;
735  default:
736  return AVERROR_BUG;
737  }
738 
739  reduce_mean(dnch->band_noise);
740 
741  dnch->amt = av_calloc(s->bin_count, sizeof(*dnch->amt));
742  dnch->band_amt = av_calloc(s->number_of_bands, sizeof(*dnch->band_amt));
743  dnch->band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->band_excit));
744  dnch->gain = av_calloc(s->bin_count, sizeof(*dnch->gain));
745  dnch->smoothed_gain = av_calloc(s->bin_count, sizeof(*dnch->smoothed_gain));
746  dnch->prior = av_calloc(s->bin_count, sizeof(*dnch->prior));
747  dnch->prior_band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->prior_band_excit));
748  dnch->clean_data = av_calloc(s->bin_count, sizeof(*dnch->clean_data));
749  dnch->noisy_data = av_calloc(s->bin_count, sizeof(*dnch->noisy_data));
750  dnch->out_samples = av_calloc(s->buffer_length, sizeof(*dnch->out_samples));
751  dnch->abs_var = av_calloc(s->bin_count, sizeof(*dnch->abs_var));
752  dnch->rel_var = av_calloc(s->bin_count, sizeof(*dnch->rel_var));
753  dnch->min_abs_var = av_calloc(s->bin_count, sizeof(*dnch->min_abs_var));
754  dnch->fft_in = av_calloc(s->fft_length2, s->sample_size);
755  dnch->fft_out = av_calloc(s->fft_length2 + 1, s->complex_sample_size);
756  ret = av_tx_init(&dnch->fft, &dnch->tx_fn, tx_type, 0, s->fft_length2, scale, 0);
757  if (ret < 0)
758  return ret;
759  ret = av_tx_init(&dnch->ifft, &dnch->itx_fn, tx_type, 1, s->fft_length2, scale, 0);
760  if (ret < 0)
761  return ret;
762  dnch->spread_function = av_calloc(s->number_of_bands * s->number_of_bands,
763  sizeof(*dnch->spread_function));
764 
765  if (!dnch->amt ||
766  !dnch->band_amt ||
767  !dnch->band_excit ||
768  !dnch->gain ||
769  !dnch->smoothed_gain ||
770  !dnch->prior ||
771  !dnch->prior_band_excit ||
772  !dnch->clean_data ||
773  !dnch->noisy_data ||
774  !dnch->out_samples ||
775  !dnch->fft_in ||
776  !dnch->fft_out ||
777  !dnch->abs_var ||
778  !dnch->rel_var ||
779  !dnch->min_abs_var ||
780  !dnch->spread_function ||
781  !dnch->fft ||
782  !dnch->ifft)
783  return AVERROR(ENOMEM);
784  }
785 
786  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
787  DeNoiseChannel *dnch = &s->dnch[ch];
788  double *prior_band_excit = dnch->prior_band_excit;
789  double min, max;
790  double p1, p2;
791 
792  p1 = pow(0.1, 2.5 / sdiv);
793  p2 = pow(0.1, 1.0 / sdiv);
794  j = 0;
795  for (m = 0; m < s->number_of_bands; m++) {
796  for (n = 0; n < s->number_of_bands; n++) {
797  if (n < m) {
798  dnch->spread_function[j++] = pow(p2, m - n);
799  } else if (n > m) {
800  dnch->spread_function[j++] = pow(p1, n - m);
801  } else {
802  dnch->spread_function[j++] = 1.0;
803  }
804  }
805  }
806 
807  for (m = 0; m < s->number_of_bands; m++) {
808  dnch->band_excit[m] = 0.0;
809  prior_band_excit[m] = 0.0;
810  }
811 
812  for (m = 0; m < s->bin_count; m++)
813  dnch->band_excit[s->bin2band[m]] += 1.0;
814 
815  j = 0;
816  for (m = 0; m < s->number_of_bands; m++) {
817  for (n = 0; n < s->number_of_bands; n++)
818  prior_band_excit[m] += dnch->spread_function[j++] * dnch->band_excit[n];
819  }
820 
821  min = pow(0.1, 2.5);
822  max = pow(0.1, 1.0);
823  for (int i = 0; i < s->number_of_bands; i++) {
824  if (i < lrint(12.0 * sdiv)) {
825  dnch->band_excit[i] = pow(0.1, 1.45 + 0.1 * i / sdiv);
826  } else {
827  dnch->band_excit[i] = pow(0.1, 2.5 - 0.2 * (i / sdiv - 14.0));
828  }
829  dnch->band_excit[i] = av_clipd(dnch->band_excit[i], min, max);
830  }
831 
832  for (int i = 0; i < s->buffer_length; i++)
833  dnch->out_samples[i] = 0;
834 
835  j = 0;
836  for (int i = 0; i < s->number_of_bands; i++)
837  for (int k = 0; k < s->number_of_bands; k++)
838  dnch->spread_function[j++] *= dnch->band_excit[i] / prior_band_excit[i];
839  }
840 
841  j = 0;
842  sar = s->sample_advance / s->sample_rate;
843  for (int i = 0; i < s->bin_count; i++) {
844  if ((i == s->fft_length2) || (s->bin2band[i] > j)) {
845  double d6 = (i - 1) * s->sample_rate / s->fft_length;
846  double d7 = fmin(0.008 + 2.2 / d6, 0.03);
847  s->band_alpha[j] = exp(-sar / d7);
848  s->band_beta[j] = 1.0 - s->band_alpha[j];
849  j = s->bin2band[i];
850  }
851  }
852 
853  s->winframe = ff_get_audio_buffer(inlink, s->window_length);
854  if (!s->winframe)
855  return AVERROR(ENOMEM);
856 
857  wscale = sqrt(8.0 / (9.0 * s->fft_length));
858  sum = 0.0;
859  for (int i = 0; i < s->window_length; i++) {
860  double d10 = sin(i * M_PI / s->window_length);
861  d10 *= wscale * d10;
862  s->window[i] = d10;
863  sum += d10 * d10;
864  }
865 
866  s->window_weight = 0.5 * sum;
867  s->floor = (1LL << 48) * exp(-23.025558369790467) * s->window_weight;
868  s->sample_floor = s->floor * exp(4.144600506562284);
869 
870  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
871  DeNoiseChannel *dnch = &s->dnch[ch];
872 
873  dnch->noise_reduction = s->noise_reduction;
874  dnch->noise_floor = s->noise_floor;
875  dnch->residual_floor = s->residual_floor;
876 
877  set_parameters(s, dnch, 1, 1);
878  }
879 
880  s->noise_band_edge[0] = FFMIN(s->fft_length2, s->fft_length * get_band_edge(s, 0) / s->sample_rate);
881  i = 0;
882  for (int j = 1; j < NB_PROFILE_BANDS + 1; j++) {
883  s->noise_band_edge[j] = FFMIN(s->fft_length2, s->fft_length * get_band_edge(s, j) / s->sample_rate);
884  if (s->noise_band_edge[j] > lrint(1.1 * s->noise_band_edge[j - 1]))
885  i++;
886  s->noise_band_edge[NB_PROFILE_BANDS + 1] = i;
887  }
888  s->noise_band_count = s->noise_band_edge[NB_PROFILE_BANDS + 1];
889 
890  return 0;
891 }
892 
893 static void init_sample_noise(DeNoiseChannel *dnch)
894 {
895  for (int i = 0; i < NB_PROFILE_BANDS; i++) {
896  dnch->noise_band_norm[i] = 0.0;
897  dnch->noise_band_avr[i] = 0.0;
898  dnch->noise_band_avi[i] = 0.0;
899  dnch->noise_band_var[i] = 0.0;
900  }
901 }
902 
903 static void sample_noise_block(AudioFFTDeNoiseContext *s,
904  DeNoiseChannel *dnch,
905  AVFrame *in, int ch)
906 {
907  double *src_dbl = (double *)in->extended_data[ch];
908  float *src_flt = (float *)in->extended_data[ch];
909  double mag2, var = 0.0, avr = 0.0, avi = 0.0;
910  AVComplexDouble *fft_out_dbl = dnch->fft_out;
911  AVComplexFloat *fft_out_flt = dnch->fft_out;
912  double *fft_in_dbl = dnch->fft_in;
913  float *fft_in_flt = dnch->fft_in;
914  int edge, j, k, n, edgemax;
915 
916  switch (s->format) {
917  case AV_SAMPLE_FMT_FLTP:
918  for (int i = 0; i < s->window_length; i++)
919  fft_in_flt[i] = s->window[i] * src_flt[i] * (1LL << 23);
920 
921  for (int i = s->window_length; i < s->fft_length2; i++)
922  fft_in_flt[i] = 0.f;
923  break;
924  case AV_SAMPLE_FMT_DBLP:
925  for (int i = 0; i < s->window_length; i++)
926  fft_in_dbl[i] = s->window[i] * src_dbl[i] * (1LL << 23);
927 
928  for (int i = s->window_length; i < s->fft_length2; i++)
929  fft_in_dbl[i] = 0.;
930  break;
931  }
932 
933  dnch->tx_fn(dnch->fft, dnch->fft_out, dnch->fft_in, s->sample_size);
934 
935  edge = s->noise_band_edge[0];
936  j = edge;
937  k = 0;
938  n = j;
939  edgemax = fmin(s->fft_length2, s->noise_band_edge[NB_PROFILE_BANDS]);
940  for (int i = j; i <= edgemax; i++) {
941  if ((i == j) && (i < edgemax)) {
942  if (j > edge) {
943  dnch->noise_band_norm[k - 1] += j - edge;
944  dnch->noise_band_avr[k - 1] += avr;
945  dnch->noise_band_avi[k - 1] += avi;
946  dnch->noise_band_var[k - 1] += var;
947  }
948  k++;
949  edge = j;
950  j = s->noise_band_edge[k];
951  if (k == NB_PROFILE_BANDS) {
952  j++;
953  }
954  var = 0.0;
955  avr = 0.0;
956  avi = 0.0;
957  }
958 
959  switch (s->format) {
960  case AV_SAMPLE_FMT_FLTP:
961  avr += fft_out_flt[n].re;
962  avi += fft_out_flt[n].im;
963  mag2 = fft_out_flt[n].re * fft_out_flt[n].re +
964  fft_out_flt[n].im * fft_out_flt[n].im;
965  break;
966  case AV_SAMPLE_FMT_DBLP:
967  avr += fft_out_dbl[n].re;
968  avi += fft_out_dbl[n].im;
969  mag2 = fft_out_dbl[n].re * fft_out_dbl[n].re +
970  fft_out_dbl[n].im * fft_out_dbl[n].im;
971  break;
972  }
973 
974  mag2 = fmax(mag2, s->sample_floor);
975 
976  var += mag2;
977  n++;
978  }
979 
980  dnch->noise_band_norm[k - 1] += j - edge;
981  dnch->noise_band_avr[k - 1] += avr;
982  dnch->noise_band_avi[k - 1] += avi;
983  dnch->noise_band_var[k - 1] += var;
984 }
985 
986 static void finish_sample_noise(AudioFFTDeNoiseContext *s,
987  DeNoiseChannel *dnch,
988  double *sample_noise)
989 {
990  for (int i = 0; i < s->noise_band_count; i++) {
991  dnch->noise_band_avr[i] /= dnch->noise_band_norm[i];
992  dnch->noise_band_avi[i] /= dnch->noise_band_norm[i];
993  dnch->noise_band_var[i] /= dnch->noise_band_norm[i];
994  dnch->noise_band_var[i] -= dnch->noise_band_avr[i] * dnch->noise_band_avr[i] +
995  dnch->noise_band_avi[i] * dnch->noise_band_avi[i];
996  dnch->noise_band_auto_var[i] = dnch->noise_band_var[i];
997  sample_noise[i] = 10.0 * log10(dnch->noise_band_var[i] / s->floor) - 100.0;
998  }
999  if (s->noise_band_count < NB_PROFILE_BANDS) {
1000  for (int i = s->noise_band_count; i < NB_PROFILE_BANDS; i++)
1001  sample_noise[i] = sample_noise[i - 1];
1002  }
1003 }
1004 
1005 static void set_noise_profile(AudioFFTDeNoiseContext *s,
1006  DeNoiseChannel *dnch,
1007  double *sample_noise)
1008 {
1009  double new_band_noise[NB_PROFILE_BANDS];
1010  double temp[NB_PROFILE_BANDS];
1011  double sum = 0.0;
1012 
1013  for (int m = 0; m < NB_PROFILE_BANDS; m++)
1014  temp[m] = sample_noise[m];
1015 
1016  for (int m = 0, i = 0; m < SOLVE_SIZE; m++) {
1017  sum = 0.0;
1018  for (int n = 0; n < NB_PROFILE_BANDS; n++)
1019  sum += s->matrix_b[i++] * temp[n];
1020  s->vector_b[m] = sum;
1021  }
1022  solve(s->matrix_a, s->vector_b, SOLVE_SIZE);
1023  for (int m = 0, i = 0; m < NB_PROFILE_BANDS; m++) {
1024  sum = 0.0;
1025  for (int n = 0; n < SOLVE_SIZE; n++)
1026  sum += s->matrix_c[i++] * s->vector_b[n];
1027  temp[m] = sum;
1028  }
1029 
1030  reduce_mean(temp);
1031 
1032  av_log(s, AV_LOG_INFO, "bn=");
1033  for (int m = 0; m < NB_PROFILE_BANDS; m++) {
1034  new_band_noise[m] = temp[m];
1035  new_band_noise[m] = av_clipd(new_band_noise[m], -24.0, 24.0);
1036  av_log(s, AV_LOG_INFO, "%f ", new_band_noise[m]);
1037  }
1038  av_log(s, AV_LOG_INFO, "\n");
1039  memcpy(dnch->band_noise, new_band_noise, sizeof(new_band_noise));
1040 }
1041 
1042 static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
1043 {
1044  AudioFFTDeNoiseContext *s = ctx->priv;
1045  AVFrame *in = arg;
1046  const int start = (in->ch_layout.nb_channels * jobnr) / nb_jobs;
1047  const int end = (in->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
1048  const int window_length = s->window_length;
1049  const double *window = s->window;
1050 
1051  for (int ch = start; ch < end; ch++) {
1052  DeNoiseChannel *dnch = &s->dnch[ch];
1053  const double *src_dbl = (const double *)in->extended_data[ch];
1054  const float *src_flt = (const float *)in->extended_data[ch];
1055  double *dst = dnch->out_samples;
1056  double *fft_in_dbl = dnch->fft_in;
1057  float *fft_in_flt = dnch->fft_in;
1058 
1059  switch (s->format) {
1060  case AV_SAMPLE_FMT_FLTP:
1061  for (int m = 0; m < window_length; m++)
1062  fft_in_flt[m] = window[m] * src_flt[m] * (1LL << 23);
1063 
1064  for (int m = window_length; m < s->fft_length2; m++)
1065  fft_in_flt[m] = 0.f;
1066  break;
1067  case AV_SAMPLE_FMT_DBLP:
1068  for (int m = 0; m < window_length; m++)
1069  fft_in_dbl[m] = window[m] * src_dbl[m] * (1LL << 23);
1070 
1071  for (int m = window_length; m < s->fft_length2; m++)
1072  fft_in_dbl[m] = 0.;
1073  break;
1074  }
1075 
1076  dnch->tx_fn(dnch->fft, dnch->fft_out, dnch->fft_in, s->sample_size);
1077 
1078  process_frame(ctx, s, dnch,
1079  dnch->prior,
1080  dnch->prior_band_excit,
1081  s->track_noise);
1082 
1083  dnch->itx_fn(dnch->ifft, dnch->fft_in, dnch->fft_out, s->complex_sample_size);
1084 
1085  switch (s->format) {
1086  case AV_SAMPLE_FMT_FLTP:
1087  for (int m = 0; m < window_length; m++)
1088  dst[m] += s->window[m] * fft_in_flt[m] / (1LL << 23);
1089  break;
1090  case AV_SAMPLE_FMT_DBLP:
1091  for (int m = 0; m < window_length; m++)
1092  dst[m] += s->window[m] * fft_in_dbl[m] / (1LL << 23);
1093  break;
1094  }
1095  }
1096 
1097  return 0;
1098 }
1099 
1100 static int output_frame(AVFilterLink *inlink, AVFrame *in)
1101 {
1102  AVFilterContext *ctx = inlink->dst;
1103  AVFilterLink *outlink = ctx->outputs[0];
1104  AudioFFTDeNoiseContext *s = ctx->priv;
1105  const int output_mode = ctx->is_disabled ? IN_MODE : s->output_mode;
1106  const int offset = s->window_length - s->sample_advance;
1107  AVFrame *out;
1108 
1109  for (int ch = 0; ch < s->channels; ch++) {
1110  uint8_t *src = (uint8_t *)s->winframe->extended_data[ch];
1111 
1112  memmove(src, src + s->sample_advance * s->sample_size,
1113  offset * s->sample_size);
1114  memcpy(src + offset * s->sample_size, in->extended_data[ch],
1115  in->nb_samples * s->sample_size);
1116  memset(src + s->sample_size * (offset + in->nb_samples), 0,
1117  (s->sample_advance - in->nb_samples) * s->sample_size);
1118  }
1119 
1120  if (s->track_noise) {
1121  double average = 0.0, min = DBL_MAX, max = -DBL_MAX;
1122 
1123  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1124  DeNoiseChannel *dnch = &s->dnch[ch];
1125 
1126  average += dnch->noise_floor;
1127  max = fmax(max, dnch->noise_floor);
1128  min = fmin(min, dnch->noise_floor);
1129  }
1130 
1131  average /= inlink->ch_layout.nb_channels;
1132 
1133  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1134  DeNoiseChannel *dnch = &s->dnch[ch];
1135 
1136  switch (s->noise_floor_link) {
1137  case MIN_LINK: dnch->noise_floor = min; break;
1138  case MAX_LINK: dnch->noise_floor = max; break;
1139  case AVERAGE_LINK: dnch->noise_floor = average; break;
1140  case NONE_LINK:
1141  default:
1142  break;
1143  }
1144 
1145  if (dnch->noise_floor != dnch->last_noise_floor)
1146  set_parameters(s, dnch, 1, 0);
1147  }
1148  }
1149 
1150  if (s->sample_noise_mode == SAMPLE_START) {
1151  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1152  DeNoiseChannel *dnch = &s->dnch[ch];
1153 
1154  init_sample_noise(dnch);
1155  }
1156  s->sample_noise_mode = SAMPLE_NONE;
1157  s->sample_noise = 1;
1158  s->sample_noise_blocks = 0;
1159  }
1160 
1161  if (s->sample_noise) {
1162  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1163  DeNoiseChannel *dnch = &s->dnch[ch];
1164 
1165  sample_noise_block(s, dnch, s->winframe, ch);
1166  }
1167  s->sample_noise_blocks++;
1168  }
1169 
1170  if (s->sample_noise_mode == SAMPLE_STOP) {
1171  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1172  DeNoiseChannel *dnch = &s->dnch[ch];
1173  double sample_noise[NB_PROFILE_BANDS];
1174 
1175  if (s->sample_noise_blocks <= 0)
1176  break;
1177  finish_sample_noise(s, dnch, sample_noise);
1178  set_noise_profile(s, dnch, sample_noise);
1179  set_parameters(s, dnch, 1, 1);
1180  }
1181  s->sample_noise = 0;
1182  s->sample_noise_blocks = 0;
1183  s->sample_noise_mode = SAMPLE_NONE;
1184  }
1185 
1186  ff_filter_execute(ctx, filter_channel, s->winframe, NULL,
1187  FFMIN(outlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
1188 
1189  if (av_frame_is_writable(in)) {
1190  out = in;
1191  } else {
1192  out = ff_get_audio_buffer(outlink, in->nb_samples);
1193  if (!out) {
1194  av_frame_free(&in);
1195  return AVERROR(ENOMEM);
1196  }
1197 
1198  av_frame_copy_props(out, in);
1199  }
1200 
1201  for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) {
1202  DeNoiseChannel *dnch = &s->dnch[ch];
1203  double *src = dnch->out_samples;
1204  const double *orig_dbl = (const double *)s->winframe->extended_data[ch];
1205  const float *orig_flt = (const float *)s->winframe->extended_data[ch];
1206  double *dst_dbl = (double *)out->extended_data[ch];
1207  float *dst_flt = (float *)out->extended_data[ch];
1208 
1209  switch (output_mode) {
1210  case IN_MODE:
1211  switch (s->format) {
1212  case AV_SAMPLE_FMT_FLTP:
1213  for (int m = 0; m < out->nb_samples; m++)
1214  dst_flt[m] = orig_flt[m];
1215  break;
1216  case AV_SAMPLE_FMT_DBLP:
1217  for (int m = 0; m < out->nb_samples; m++)
1218  dst_dbl[m] = orig_dbl[m];
1219  break;
1220  }
1221  break;
1222  case OUT_MODE:
1223  switch (s->format) {
1224  case AV_SAMPLE_FMT_FLTP:
1225  for (int m = 0; m < out->nb_samples; m++)
1226  dst_flt[m] = src[m];
1227  break;
1228  case AV_SAMPLE_FMT_DBLP:
1229  for (int m = 0; m < out->nb_samples; m++)
1230  dst_dbl[m] = src[m];
1231  break;
1232  }
1233  break;
1234  case NOISE_MODE:
1235  switch (s->format) {
1236  case AV_SAMPLE_FMT_FLTP:
1237  for (int m = 0; m < out->nb_samples; m++)
1238  dst_flt[m] = orig_flt[m] - src[m];
1239  break;
1240  case AV_SAMPLE_FMT_DBLP:
1241  for (int m = 0; m < out->nb_samples; m++)
1242  dst_dbl[m] = orig_dbl[m] - src[m];
1243  break;
1244  }
1245  break;
1246  default:
1247  if (in != out)
1248  av_frame_free(&in);
1249  av_frame_free(&out);
1250  return AVERROR_BUG;
1251  }
1252 
1253  memmove(src, src + s->sample_advance, (s->window_length - s->sample_advance) * sizeof(*src));
1254  memset(src + (s->window_length - s->sample_advance), 0, s->sample_advance * sizeof(*src));
1255  }
1256 
1257  if (out != in)
1258  av_frame_free(&in);
1259  return ff_filter_frame(outlink, out);
1260 }
1261 
1262 static int activate(AVFilterContext *ctx)
1263 {
1264  AVFilterLink *inlink = ctx->inputs[0];
1265  AVFilterLink *outlink = ctx->outputs[0];
1266  AudioFFTDeNoiseContext *s = ctx->priv;
1267  AVFrame *in = NULL;
1268  int ret;
1269 
1270  FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
1271 
1272  ret = ff_inlink_consume_samples(inlink, s->sample_advance, s->sample_advance, &in);
1273  if (ret < 0)
1274  return ret;
1275  if (ret > 0)
1276  return output_frame(inlink, in);
1277 
1278  if (ff_inlink_queued_samples(inlink) >= s->sample_advance) {
1279  ff_filter_set_ready(ctx, 10);
1280  return 0;
1281  }
1282 
1283  FF_FILTER_FORWARD_STATUS(inlink, outlink);
1284  FF_FILTER_FORWARD_WANTED(outlink, inlink);
1285 
1286  return FFERROR_NOT_READY;
1287 }
1288 
1289 static av_cold void uninit(AVFilterContext *ctx)
1290 {
1291  AudioFFTDeNoiseContext *s = ctx->priv;
1292 
1293  av_freep(&s->window);
1294  av_freep(&s->bin2band);
1295  av_freep(&s->band_alpha);
1296  av_freep(&s->band_beta);
1297  av_frame_free(&s->winframe);
1298 
1299  if (s->dnch) {
1300  for (int ch = 0; ch < s->channels; ch++) {
1301  DeNoiseChannel *dnch = &s->dnch[ch];
1302  av_freep(&dnch->amt);
1303  av_freep(&dnch->band_amt);
1304  av_freep(&dnch->band_excit);
1305  av_freep(&dnch->gain);
1306  av_freep(&dnch->smoothed_gain);
1307  av_freep(&dnch->prior);
1308  av_freep(&dnch->prior_band_excit);
1309  av_freep(&dnch->clean_data);
1310  av_freep(&dnch->noisy_data);
1311  av_freep(&dnch->out_samples);
1312  av_freep(&dnch->spread_function);
1313  av_freep(&dnch->abs_var);
1314  av_freep(&dnch->rel_var);
1315  av_freep(&dnch->min_abs_var);
1316  av_freep(&dnch->fft_in);
1317  av_freep(&dnch->fft_out);
1318  av_tx_uninit(&dnch->fft);
1319  av_tx_uninit(&dnch->ifft);
1320  }
1321  av_freep(&s->dnch);
1322  }
1323 }
1324 
1325 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
1326  char *res, int res_len, int flags)
1327 {
1328  AudioFFTDeNoiseContext *s = ctx->priv;
1329  int ret = 0;
1330 
1331  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
1332  if (ret < 0)
1333  return ret;
1334 
1335  if (!strcmp(cmd, "sample_noise") || !strcmp(cmd, "sn"))
1336  return 0;
1337 
1338  for (int ch = 0; ch < s->channels; ch++) {
1339  DeNoiseChannel *dnch = &s->dnch[ch];
1340 
1341  dnch->noise_reduction = s->noise_reduction;
1342  dnch->noise_floor = s->noise_floor;
1343  dnch->residual_floor = s->residual_floor;
1344 
1345  set_parameters(s, dnch, 1, 1);
1346  }
1347 
1348  return 0;
1349 }
1350 
1351 static const AVFilterPad inputs[] = {
1352  {
1353  .name = "default",
1354  .type = AVMEDIA_TYPE_AUDIO,
1355  .config_props = config_input,
1356  },
1357 };
1358 
1359 const AVFilter ff_af_afftdn = {
1360  .name = "afftdn",
1361  .description = NULL_IF_CONFIG_SMALL("Denoise audio samples using FFT."),
1362  .priv_size = sizeof(AudioFFTDeNoiseContext),
1363  .priv_class = &afftdn_class,
1364  .activate = activate,
1365  .uninit = uninit,
1366  FILTER_INPUTS(inputs),
1367  FILTER_OUTPUTS(ff_audio_default_filterpad),
1368  FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP),
1369  .process_command = process_command,
1370  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
1371  AVFILTER_FLAG_SLICE_THREADS,
1372 };
NB_PROFILE_BANDS
#define NB_PROFILE_BANDS
Definition: af_afftdn.c:33
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:107
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
NB_MODES
@ NB_MODES
Definition: af_afftdn.c:46
DeNoiseChannel::noise_floor
double noise_floor
Definition: af_afftdn.c:95
AudioFFTDeNoiseContext::floor
double floor
Definition: af_afftdn.c:150
DeNoiseChannel::clean_data
double * clean_data
Definition: af_afftdn.c:76
DeNoiseChannel::noise_band_auto_var
double noise_band_auto_var[NB_PROFILE_BANDS]
Definition: af_afftdn.c:67
C
#define C
Definition: af_afftdn.c:31
DeNoiseChannel::ifft
AVTXContext * ifft
Definition: af_afftdn.c:85
r
const char * r
Definition: vf_curves.c:126
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:978
activate
static int activate(AVFilterContext *ctx)
Definition: af_afftdn.c:1262
inputs
static const AVFilterPad inputs[]
Definition: af_afftdn.c:1351
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
matrix
Definition: vc1dsp.c:42
AVTXContext
Definition: tx_priv.h:235
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
normalize.log
log
Definition: normalize.py:21
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
im
float im
Definition: fft.c:83
OUT_MODE
@ OUT_MODE
Definition: af_afftdn.c:44
SOLVE_SIZE
#define SOLVE_SIZE
Definition: af_afftdn.c:32
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
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:903
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
NONE_LINK
@ NONE_LINK
Definition: af_afftdn.c:50
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:170
DeNoiseChannel::max_var
double max_var
Definition: af_afftdn.c:100
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
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:70
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:901
NoiseType
NoiseType
Definition: af_afftdn.c:57
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:88
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:89
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:360
AudioFFTDeNoiseContext::complex_sample_size
size_t complex_sample_size
Definition: af_afftdn.c:109
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:66
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:802
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:47
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:108
DeNoiseChannel::spread_function
double * spread_function
Definition: af_afftdn.c:79
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:49
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:151
float
float
Definition: af_crystalizer.c:121
DeNoiseChannel::last_noise_reduction
double last_noise_reduction
Definition: af_afftdn.c:94
afftdn_options
static const AVOption afftdn_options[]
Definition: af_afftdn.c:165
s
#define s(width, name)
Definition: cbs_vp9.c:198
AudioFFTDeNoiseContext::winframe
AVFrame * winframe
Definition: af_afftdn.c:147
NB_NOISE
@ NB_NOISE
Definition: af_afftdn.c:62
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:127
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:178
AudioFFTDeNoiseContext
Definition: af_afftdn.c:104
DeNoiseChannel::gain
double * gain
Definition: af_afftdn.c:72
filters.h
DeNoiseChannel::rel_var
double * rel_var
Definition: af_afftdn.c:81
DeNoiseChannel
Definition: af_afftdn.c:65
DeNoiseChannel::min_abs_var
double * min_abs_var
Definition: af_afftdn.c:82
ctx
AVFormatContext * ctx
Definition: movenc.c:48
DeNoiseChannel::noise_band_sample
double noise_band_sample[NB_PROFILE_BANDS]
Definition: af_afftdn.c:68
DeNoiseChannel::fft_out
void * fft_out
Definition: af_afftdn.c:84
AudioFFTDeNoiseContext::sample_noise_blocks
int sample_noise_blocks
Definition: af_afftdn.c:127
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:192
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:1402
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
DeNoiseChannel::last_noise_floor
double last_noise_floor
Definition: af_afftdn.c:96
DeNoiseChannel::max_gain
double max_gain
Definition: af_afftdn.c:99
DeNoiseChannel::residual_floor
double residual_floor
Definition: af_afftdn.c:97
AudioFFTDeNoiseContext::matrix_b
double matrix_b[SOLVE_SIZE *NB_PROFILE_BANDS]
Definition: af_afftdn.c:157
SampleNoiseModes
SampleNoiseModes
Definition: af_afftdn.c:35
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:1042
AudioFFTDeNoiseContext::noise_type
int noise_type
Definition: af_afftdn.c:113
NB_SAMPLEMODES
@ NB_SAMPLEMODES
Definition: af_afftdn.c:39
ff_audio_default_filterpad
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
Definition: audio.c:32
double
double
Definition: af_crystalizer.c:131
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:58
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:893
NOISE_MODE
@ NOISE_MODE
Definition: af_afftdn.c:45
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:42
DeNoiseChannel::last_residual_floor
double last_residual_floor
Definition: af_afftdn.c:98
f
f
Definition: af_crystalizer.c:121
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:106
NB_LINK
@ NB_LINK
Definition: af_afftdn.c:54
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AudioFFTDeNoiseContext::format
int format
Definition: af_afftdn.c:107
output_frame
static int output_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_afftdn.c:1100
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:666
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:851
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:986
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:59
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:51
AudioFFTDeNoiseContext::channels
int channels
Definition: af_afftdn.c:125
M_PI
#define M_PI
Definition: mathematics.h:67
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:294
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:1289
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
DeNoiseChannel::out_samples
double * out_samples
Definition: af_afftdn.c:78
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:244
DeNoiseChannel::itx_fn
av_tx_fn itx_fn
Definition: af_afftdn.c:86
DeNoiseChannel::fft
AVTXContext * fft
Definition: af_afftdn.c:85
AudioFFTDeNoiseContext::gain_smooth
int gain_smooth
Definition: af_afftdn.c:121
SAMPLE_START
@ SAMPLE_START
Definition: af_afftdn.c:37
DeNoiseChannel::noise_band_avi
double noise_band_avi[NB_PROFILE_BANDS]
Definition: af_afftdn.c:90
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
DeNoiseChannel::prior_band_excit
double * prior_band_excit
Definition: af_afftdn.c:75
SAMPLE_NONE
@ SAMPLE_NONE
Definition: af_afftdn.c:36
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:786
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:1325
SAMPLE_STOP
@ SAMPLE_STOP
Definition: af_afftdn.c:38
DeNoiseChannel::smoothed_gain
double * smoothed_gain
Definition: af_afftdn.c:73
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_TX_DOUBLE_RDFT
@ AV_TX_DOUBLE_RDFT
Definition: tx.h:91
SHELLAC_NOISE
@ SHELLAC_NOISE
Definition: af_afftdn.c:60
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:53
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1362
AVComplexDouble
Definition: tx.h:31
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
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:142
AVFilter
Filter definition.
Definition: avfilter.h:166
DeNoiseChannel::amt
double * amt
Definition: af_afftdn.c:69
AVERAGE_LINK
@ AVERAGE_LINK
Definition: af_afftdn.c:53
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:52
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:61
IN_MODE
@ IN_MODE
Definition: af_afftdn.c:43
DeNoiseChannel::noisy_data
double * noisy_data
Definition: af_afftdn.c:77
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:90
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:86
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:126
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:71
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
temp
else temp
Definition: vf_mcdeint.c:263
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:862
DeNoiseChannel::noise_reduction
double noise_reduction
Definition: af_afftdn.c:93
AudioFFTDeNoiseContext::band_beta
double * band_beta
Definition: af_afftdn.c:143
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
DeNoiseChannel::noise_band_var
double noise_band_var[NB_PROFILE_BANDS]
Definition: af_afftdn.c:91
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:117
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(afftdn)
audio.h
M_LN10
#define M_LN10
Definition: mathematics.h:49
DeNoiseChannel::prior
double * prior
Definition: af_afftdn.c:74
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:83
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:193
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:331
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:155
AudioFFTDeNoiseContext::sample_noise
int sample_noise
Definition: af_afftdn.c:126
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:467
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:1005
DeNoiseChannel::abs_var
double * abs_var
Definition: af_afftdn.c:80
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:144
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:101
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_af_afftdn
const AVFilter ff_af_afftdn
Definition: af_afftdn.c:1359
AudioFFTDeNoiseContext::band_multiplier
float band_multiplier
Definition: af_afftdn.c:122
av_clipd
av_clipd
Definition: af_crystalizer.c:131
FILTER_SAMPLEFMTS
#define FILTER_SAMPLEFMTS(...)
Definition: internal.h:180
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:216
tx.h
re
float re
Definition: fft.c:83
min
float min
Definition: vorbis_enc_data.h:429
Generated on Sat Sep 23 2023 19:21:59 for FFmpeg by   doxygen 1.8.17