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/audio_fifo.h"
24 #include "libavutil/avstring.h"
26 #include "libavutil/opt.h"
27 #include "libavcodec/avfft.h"
28 #include "avfilter.h"
29 #include "audio.h"
30 #include "formats.h"
31 #include "filters.h"
32 
33 #define C (M_LN10 * 0.1)
34 #define RATIO 0.98
35 #define RRATIO (1.0 - RATIO)
36 
37 enum OutModes {
42 };
43 
44 enum NoiseType {
50 };
51 
52 typedef struct DeNoiseChannel {
53  int band_noise[15];
54  double noise_band_auto_var[15];
55  double noise_band_sample[15];
56  double *amt;
57  double *band_amt;
58  double *band_excit;
59  double *gain;
60  double *prior;
62  double *clean_data;
63  double *noisy_data;
64  double *out_samples;
65  double *spread_function;
66  double *abs_var;
67  double *rel_var;
68  double *min_abs_var;
71 
72  double noise_band_norm[15];
73  double noise_band_avr[15];
74  double noise_band_avi[15];
75  double noise_band_var[15];
76 
77  double sfm_threshold;
78  double sfm_alpha;
79  double sfm_results[3];
80  int sfm_fail_flags[512];
83 
84 typedef struct AudioFFTDeNoiseContext {
85  const AVClass *class;
86 
88  float noise_floor;
95 
100  int64_t block_count;
101 
102  int64_t pts;
103  int channels;
107  float sample_rate;
115 
116  int band_centre[15];
117 
118  int *bin2band;
119  double *window;
120  double *band_alpha;
121  double *band_beta;
122 
124 
125  double max_gain;
126  double max_var;
127  double gain_scale;
129  double floor;
130  double sample_floor;
131  double auto_floor;
132 
133  int noise_band_edge[17];
135  double matrix_a[25];
136  double vector_b[5];
137  double matrix_b[75];
138  double matrix_c[75];
139 
142 
143 #define OFFSET(x) offsetof(AudioFFTDeNoiseContext, x)
144 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
145 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
146 
147 static const AVOption afftdn_options[] = {
148  { "nr", "set the noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_FLOAT, {.dbl = 12}, .01, 97, AFR },
149  { "nf", "set the noise floor", OFFSET(noise_floor), AV_OPT_TYPE_FLOAT, {.dbl =-50}, -80,-20, AFR },
150  { "nt", "set the noise type", OFFSET(noise_type), AV_OPT_TYPE_INT, {.i64 = WHITE_NOISE}, WHITE_NOISE, NB_NOISE-1, AF, "type" },
151  { "w", "white noise", 0, AV_OPT_TYPE_CONST, {.i64 = WHITE_NOISE}, 0, 0, AF, "type" },
152  { "v", "vinyl noise", 0, AV_OPT_TYPE_CONST, {.i64 = VINYL_NOISE}, 0, 0, AF, "type" },
153  { "s", "shellac noise", 0, AV_OPT_TYPE_CONST, {.i64 = SHELLAC_NOISE}, 0, 0, AF, "type" },
154  { "c", "custom noise", 0, AV_OPT_TYPE_CONST, {.i64 = CUSTOM_NOISE}, 0, 0, AF, "type" },
155  { "bn", "set the custom bands noise", OFFSET(band_noise_str), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, AF },
156  { "rf", "set the residual floor", OFFSET(residual_floor), AV_OPT_TYPE_FLOAT, {.dbl =-38}, -80,-20, AFR },
157  { "tn", "track noise", OFFSET(track_noise), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR },
158  { "tr", "track residual", OFFSET(track_residual), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR },
159  { "om", "set output mode", OFFSET(output_mode), AV_OPT_TYPE_INT, {.i64 = OUT_MODE}, 0, NB_MODES-1, AFR, "mode" },
160  { "i", "input", 0, AV_OPT_TYPE_CONST, {.i64 = IN_MODE}, 0, 0, AFR, "mode" },
161  { "o", "output", 0, AV_OPT_TYPE_CONST, {.i64 = OUT_MODE}, 0, 0, AFR, "mode" },
162  { "n", "noise", 0, AV_OPT_TYPE_CONST, {.i64 = NOISE_MODE}, 0, 0, AFR, "mode" },
163  { NULL }
164 };
165 
166 AVFILTER_DEFINE_CLASS(afftdn);
167 
169  int band, double a,
170  double b, double c)
171 {
172  double d1, d2, d3;
173 
174  d1 = a / s->band_centre[band];
175  d1 = 10.0 * log(1.0 + d1 * d1) / M_LN10;
176  d2 = b / s->band_centre[band];
177  d2 = 10.0 * log(1.0 + d2 * d2) / M_LN10;
178  d3 = s->band_centre[band] / c;
179  d3 = 10.0 * log(1.0 + d3 * d3) / M_LN10;
180 
181  return lrint(-d1 + d2 - d3);
182 }
183 
184 static void factor(double *array, int size)
185 {
186  for (int i = 0; i < size - 1; i++) {
187  for (int j = i + 1; j < size; j++) {
188  double d = array[j + i * size] / array[i + i * size];
189 
190  array[j + i * size] = d;
191  for (int k = i + 1; k < size; k++) {
192  array[j + k * size] -= d * array[i + k * size];
193  }
194  }
195  }
196 }
197 
198 static void solve(double *matrix, double *vector, int size)
199 {
200  for (int i = 0; i < size - 1; i++) {
201  for (int j = i + 1; j < size; j++) {
202  double d = matrix[j + i * size];
203  vector[j] -= d * vector[i];
204  }
205  }
206 
207  vector[size - 1] /= matrix[size * size - 1];
208 
209  for (int i = size - 2; i >= 0; i--) {
210  double d = vector[i];
211  for (int j = i + 1; j < size; j++)
212  d -= matrix[i + j * size] * vector[j];
213  vector[i] = d / matrix[i + i * size];
214  }
215 }
216 
218  DeNoiseChannel *dnch,
219  int band)
220 {
221  double product, sum, f;
222  int i = 0;
223 
224  if (band < 15)
225  return dnch->band_noise[band];
226 
227  for (int j = 0; j < 5; j++) {
228  sum = 0.0;
229  for (int k = 0; k < 15; k++)
230  sum += s->matrix_b[i++] * dnch->band_noise[k];
231  s->vector_b[j] = sum;
232  }
233 
234  solve(s->matrix_a, s->vector_b, 5);
235  f = (0.5 * s->sample_rate) / s->band_centre[14];
236  f = 15.0 + log(f / 1.5) / log(1.5);
237  sum = 0.0;
238  product = 1.0;
239  for (int j = 0; j < 5; j++) {
240  sum += product * s->vector_b[j];
241  product *= f;
242  }
243 
244  return lrint(sum);
245 }
246 
248  DeNoiseChannel *dnch,
249  int start, int end)
250 {
251  double d1 = 0.0, d2 = 1.0;
252  int i = 0, j = 0;
253 
254  for (int k = start; k < end; k++) {
255  if (dnch->noisy_data[k] > s->sample_floor) {
256  j++;
257  d1 += dnch->noisy_data[k];
258  d2 *= dnch->noisy_data[k];
259  if (d2 > 1.0E100) {
260  d2 *= 1.0E-100;
261  i++;
262  } else if (d2 < 1.0E-100) {
263  d2 *= 1.0E100;
264  i--;
265  }
266  }
267  }
268  if (j > 1) {
269  d1 /= j;
270  dnch->sfm_results[0] = d1;
271  d2 = log(d2) + 230.2585 * i;
272  d2 /= j;
273  d1 = log(d1);
274  dnch->sfm_results[1] = d1;
275  dnch->sfm_results[2] = d1 - d2;
276  } else {
277  dnch->sfm_results[0] = s->auto_floor;
278  dnch->sfm_results[1] = dnch->sfm_threshold;
279  dnch->sfm_results[2] = dnch->sfm_threshold;
280  }
281 }
282 
283 static double limit_gain(double a, double b)
284 {
285  if (a > 1.0)
286  return (b * a - 1.0) / (b + a - 2.0);
287  if (a < 1.0)
288  return (b * a - 2.0 * a + 1.0) / (b - a);
289  return 1.0;
290 }
291 
294  double *prior, double *prior_band_excit, int track_noise)
295 {
296  double d1, d2, d3, gain;
297  int n, i1;
298 
299  d1 = fft_data[0].re * fft_data[0].re;
300  dnch->noisy_data[0] = d1;
301  d2 = d1 / dnch->abs_var[0];
302  d3 = RATIO * prior[0] + RRATIO * fmax(d2 - 1.0, 0.0);
303  gain = d3 / (1.0 + d3);
304  gain *= (gain + M_PI_4 / fmax(d2, 1.0E-6));
305  prior[0] = (d2 * gain);
306  dnch->clean_data[0] = (d1 * gain);
307  gain = sqrt(gain);
308  dnch->gain[0] = gain;
309  n = 0;
310  for (int i = 1; i < s->fft_length2; i++) {
311  d1 = fft_data[i].re * fft_data[i].re + fft_data[i].im * fft_data[i].im;
312  if (d1 > s->sample_floor)
313  n = i;
314 
315  dnch->noisy_data[i] = d1;
316  d2 = d1 / dnch->abs_var[i];
317  d3 = RATIO * prior[i] + RRATIO * fmax(d2 - 1.0, 0.0);
318  gain = d3 / (1.0 + d3);
319  gain *= (gain + M_PI_4 / fmax(d2, 1.0E-6));
320  prior[i] = d2 * gain;
321  dnch->clean_data[i] = d1 * gain;
322  gain = sqrt(gain);
323  dnch->gain[i] = gain;
324  }
325  d1 = fft_data[0].im * fft_data[0].im;
326  if (d1 > s->sample_floor)
327  n = s->fft_length2;
328 
329  dnch->noisy_data[s->fft_length2] = d1;
330  d2 = d1 / dnch->abs_var[s->fft_length2];
331  d3 = RATIO * prior[s->fft_length2] + RRATIO * fmax(d2 - 1.0, 0.0);
332  gain = d3 / (1.0 + d3);
333  gain *= gain + M_PI_4 / fmax(d2, 1.0E-6);
334  prior[s->fft_length2] = d2 * gain;
335  dnch->clean_data[s->fft_length2] = d1 * gain;
336  gain = sqrt(gain);
337  dnch->gain[s->fft_length2] = gain;
338  if (n > s->fft_length2 - 2) {
339  n = s->bin_count;
340  i1 = s->noise_band_count;
341  } else {
342  i1 = 0;
343  for (int i = 0; i <= s->noise_band_count; i++) {
344  if (n > 1.1 * s->noise_band_edge[i]) {
345  i1 = i;
346  }
347  }
348  }
349 
350  if (track_noise && (i1 > s->noise_band_count / 2)) {
351  int j = FFMIN(n, s->noise_band_edge[i1]);
352  int m = 3, k;
353 
354  for (k = i1 - 1; k >= 0; k--) {
355  int i = s->noise_band_edge[k];
356  calculate_sfm(s, dnch, i, j);
357  dnch->noise_band_sample[k] = dnch->sfm_results[0];
358  if (dnch->sfm_results[2] + 0.013 * m * fmax(0.0, dnch->sfm_results[1] - 20.53) >= dnch->sfm_threshold) {
359  break;
360  }
361  j = i;
362  m++;
363  }
364 
365  if (k < i1 - 1) {
366  double sum = 0.0, min, max;
367  int i;
368 
369  for (i = i1 - 1; i > k; i--) {
370  min = log(dnch->noise_band_sample[i] / dnch->noise_band_auto_var[i]);
371  sum += min;
372  }
373 
374  i = i1 - k - 1;
375  if (i < 5) {
376  min = 3.0E-4 * i * i;
377  } else {
378  min = 3.0E-4 * (8 * i - 16);
379  }
380  if (i < 3) {
381  max = 2.0E-4 * i * i;
382  } else {
383  max = 2.0E-4 * (4 * i - 4);
384  }
385 
386  if (s->track_residual) {
387  if (s->last_noise_floor > s->last_residual_floor + 9) {
388  min *= 0.5;
389  max *= 0.75;
390  } else if (s->last_noise_floor > s->last_residual_floor + 6) {
391  min *= 0.4;
392  max *= 1.0;
393  } else if (s->last_noise_floor > s->last_residual_floor + 4) {
394  min *= 0.3;
395  max *= 1.3;
396  } else if (s->last_noise_floor > s->last_residual_floor + 2) {
397  min *= 0.2;
398  max *= 1.6;
399  } else if (s->last_noise_floor > s->last_residual_floor) {
400  min *= 0.1;
401  max *= 2.0;
402  } else {
403  min = 0.0;
404  max *= 2.5;
405  }
406  }
407 
408  sum = av_clipd(sum, -min, max);
409  sum = exp(sum);
410  for (int i = 0; i < 15; i++)
411  dnch->noise_band_auto_var[i] *= sum;
412  } else if (dnch->sfm_results[2] >= dnch->sfm_threshold) {
413  dnch->sfm_fail_flags[s->block_count & 0x1FF] = 1;
414  dnch->sfm_fail_total += 1;
415  }
416  }
417 
418  for (int i = 0; i < s->number_of_bands; i++) {
419  dnch->band_excit[i] = 0.0;
420  dnch->band_amt[i] = 0.0;
421  }
422 
423  for (int i = 0; i < s->bin_count; i++) {
424  dnch->band_excit[s->bin2band[i]] += dnch->clean_data[i];
425  }
426 
427  for (int i = 0; i < s->number_of_bands; i++) {
428  dnch->band_excit[i] = fmax(dnch->band_excit[i],
429  s->band_alpha[i] * dnch->band_excit[i] +
430  s->band_beta[i] * prior_band_excit[i]);
431  prior_band_excit[i] = dnch->band_excit[i];
432  }
433 
434  for (int j = 0, i = 0; j < s->number_of_bands; j++) {
435  for (int k = 0; k < s->number_of_bands; k++) {
436  dnch->band_amt[j] += dnch->spread_function[i++] * dnch->band_excit[k];
437  }
438  }
439 
440  for (int i = 0; i < s->bin_count; i++)
441  dnch->amt[i] = dnch->band_amt[s->bin2band[i]];
442 
443  if (dnch->amt[0] > dnch->abs_var[0]) {
444  dnch->gain[0] = 1.0;
445  } else if (dnch->amt[0] > dnch->min_abs_var[0]) {
446  double limit = sqrt(dnch->abs_var[0] / dnch->amt[0]);
447  dnch->gain[0] = limit_gain(dnch->gain[0], limit);
448  } else {
449  dnch->gain[0] = limit_gain(dnch->gain[0], s->max_gain);
450  }
451  if (dnch->amt[s->fft_length2] > dnch->abs_var[s->fft_length2]) {
452  dnch->gain[s->fft_length2] = 1.0;
453  } else if (dnch->amt[s->fft_length2] > dnch->min_abs_var[s->fft_length2]) {
454  double limit = sqrt(dnch->abs_var[s->fft_length2] / dnch->amt[s->fft_length2]);
455  dnch->gain[s->fft_length2] = limit_gain(dnch->gain[s->fft_length2], limit);
456  } else {
457  dnch->gain[s->fft_length2] = limit_gain(dnch->gain[s->fft_length2], s->max_gain);
458  }
459 
460  for (int i = 1; i < s->fft_length2; i++) {
461  if (dnch->amt[i] > dnch->abs_var[i]) {
462  dnch->gain[i] = 1.0;
463  } else if (dnch->amt[i] > dnch->min_abs_var[i]) {
464  double limit = sqrt(dnch->abs_var[i] / dnch->amt[i]);
465  dnch->gain[i] = limit_gain(dnch->gain[i], limit);
466  } else {
467  dnch->gain[i] = limit_gain(dnch->gain[i], s->max_gain);
468  }
469  }
470 
471  gain = dnch->gain[0];
472  dnch->clean_data[0] = (gain * gain * dnch->noisy_data[0]);
473  fft_data[0].re *= gain;
474  gain = dnch->gain[s->fft_length2];
475  dnch->clean_data[s->fft_length2] = (gain * gain * dnch->noisy_data[s->fft_length2]);
476  fft_data[0].im *= gain;
477  for (int i = 1; i < s->fft_length2; i++) {
478  gain = dnch->gain[i];
479  dnch->clean_data[i] = (gain * gain * dnch->noisy_data[i]);
480  fft_data[i].re *= gain;
481  fft_data[i].im *= gain;
482  }
483 }
484 
485 static double freq2bark(double x)
486 {
487  double d = x / 7500.0;
488 
489  return 13.0 * atan(7.6E-4 * x) + 3.5 * atan(d * d);
490 }
491 
493 {
494  if (band == -1)
495  return lrint(s->band_centre[0] / 1.5);
496 
497  return s->band_centre[band];
498 }
499 
500 static int get_band_edge(AudioFFTDeNoiseContext *s, int band)
501 {
502  int i;
503 
504  if (band == 15) {
505  i = lrint(s->band_centre[14] * 1.224745);
506  } else {
507  i = lrint(s->band_centre[band] / 1.224745);
508  }
509 
510  return FFMIN(i, s->sample_rate / 2);
511 }
512 
514  DeNoiseChannel *dnch)
515 {
516  double band_noise, d2, d3, d4, d5;
517  int i = 0, j = 0, k = 0;
518 
519  d5 = 0.0;
520  band_noise = process_get_band_noise(s, dnch, 0);
521  for (int m = j; m <= s->fft_length2; m++) {
522  if (m == j) {
523  i = j;
524  d5 = band_noise;
525  if (k == 15) {
526  j = s->bin_count;
527  } else {
528  j = s->fft_length * get_band_centre(s, k) / s->sample_rate;
529  }
530  d2 = j - i;
531  band_noise = process_get_band_noise(s, dnch, k);
532  k++;
533  }
534  d3 = (j - m) / d2;
535  d4 = (m - i) / d2;
536  dnch->rel_var[m] = exp((d5 * d3 + band_noise * d4) * C);
537  }
538  dnch->rel_var[s->fft_length2] = exp(band_noise * C);
539 
540  for (i = 0; i < 15; i++)
541  dnch->noise_band_auto_var[i] = s->max_var * exp((process_get_band_noise(s, dnch, i) - 2.0) * C);
542 
543  for (i = 0; i <= s->fft_length2; i++) {
544  dnch->abs_var[i] = fmax(s->max_var * dnch->rel_var[i], 1.0);
545  dnch->min_abs_var[i] = s->gain_scale * dnch->abs_var[i];
546  }
547 }
548 
550 {
551  DeNoiseChannel *dnch = &s->dnch[ch];
552  char *p, *arg, *saveptr = NULL;
553  int i, ret, band_noise[15] = { 0 };
554 
555  if (!s->band_noise_str)
556  return;
557 
558  p = av_strdup(s->band_noise_str);
559  if (!p)
560  return;
561 
562  for (i = 0; i < 15; i++) {
563  if (!(arg = av_strtok(p, "| ", &saveptr)))
564  break;
565 
566  p = NULL;
567 
568  ret = av_sscanf(arg, "%d", &band_noise[i]);
569  if (ret != 1) {
570  av_log(s, AV_LOG_ERROR, "Custom band noise must be integer.\n");
571  break;
572  }
573 
574  band_noise[i] = av_clip(band_noise[i], -24, 24);
575  }
576 
577  av_free(p);
578  memcpy(dnch->band_noise, band_noise, sizeof(band_noise));
579 }
580 
582 {
583  if (s->last_noise_floor != s->noise_floor)
585 
586  if (s->track_residual)
588 
589  s->max_var = s->floor * exp((100.0 + s->last_noise_floor) * C);
590 
591  if (s->track_residual) {
594  s->max_gain = exp(s->last_noise_reduction * (0.5 * C));
595  } else if (s->noise_reduction != s->last_noise_reduction) {
597  s->last_residual_floor = av_clipf(s->last_noise_floor - s->last_noise_reduction, -80, -20);
598  s->max_gain = exp(s->last_noise_reduction * (0.5 * C));
599  }
600 
601  s->gain_scale = 1.0 / (s->max_gain * s->max_gain);
602 
603  for (int ch = 0; ch < s->channels; ch++) {
604  DeNoiseChannel *dnch = &s->dnch[ch];
605 
606  set_band_parameters(s, dnch);
607  }
608 }
609 
611 {
612  AVFilterContext *ctx = inlink->dst;
613  AudioFFTDeNoiseContext *s = ctx->priv;
614  double wscale, sar, sum, sdiv;
615  int i, j, k, m, n;
616 
617  s->dnch = av_calloc(inlink->channels, sizeof(*s->dnch));
618  if (!s->dnch)
619  return AVERROR(ENOMEM);
620 
621  s->pts = AV_NOPTS_VALUE;
622  s->channels = inlink->channels;
623  s->sample_rate = inlink->sample_rate;
624  s->sample_advance = s->sample_rate / 80;
625  s->window_length = 3 * s->sample_advance;
626  s->fft_length2 = 1 << (32 - ff_clz(s->window_length));
627  s->fft_length = s->fft_length2 * 2;
628  s->buffer_length = s->fft_length * 2;
629  s->bin_count = s->fft_length2 + 1;
630 
631  s->band_centre[0] = 80;
632  for (i = 1; i < 15; i++) {
633  s->band_centre[i] = lrint(1.5 * s->band_centre[i - 1] + 5.0);
634  if (s->band_centre[i] < 1000) {
635  s->band_centre[i] = 10 * (s->band_centre[i] / 10);
636  } else if (s->band_centre[i] < 5000) {
637  s->band_centre[i] = 50 * ((s->band_centre[i] + 20) / 50);
638  } else if (s->band_centre[i] < 15000) {
639  s->band_centre[i] = 100 * ((s->band_centre[i] + 45) / 100);
640  } else {
641  s->band_centre[i] = 1000 * ((s->band_centre[i] + 495) / 1000);
642  }
643  }
644 
645  for (j = 0; j < 5; j++) {
646  for (k = 0; k < 5; k++) {
647  s->matrix_a[j + k * 5] = 0.0;
648  for (m = 0; m < 15; m++)
649  s->matrix_a[j + k * 5] += pow(m, j + k);
650  }
651  }
652 
653  factor(s->matrix_a, 5);
654 
655  i = 0;
656  for (j = 0; j < 5; j++)
657  for (k = 0; k < 15; k++)
658  s->matrix_b[i++] = pow(k, j);
659 
660  i = 0;
661  for (j = 0; j < 15; j++)
662  for (k = 0; k < 5; k++)
663  s->matrix_c[i++] = pow(j, k);
664 
665  s->window = av_calloc(s->window_length, sizeof(*s->window));
666  s->bin2band = av_calloc(s->bin_count, sizeof(*s->bin2band));
667  if (!s->window || !s->bin2band)
668  return AVERROR(ENOMEM);
669 
670  sdiv = s->sample_rate / 17640.0;
671  for (i = 0; i <= s->fft_length2; i++)
672  s->bin2band[i] = lrint(sdiv * freq2bark((0.5 * i * s->sample_rate) / s->fft_length2));
673 
674  s->number_of_bands = s->bin2band[s->fft_length2] + 1;
675 
676  s->band_alpha = av_calloc(s->number_of_bands, sizeof(*s->band_alpha));
677  s->band_beta = av_calloc(s->number_of_bands, sizeof(*s->band_beta));
678  if (!s->band_alpha || !s->band_beta)
679  return AVERROR(ENOMEM);
680 
681  for (int ch = 0; ch < inlink->channels; ch++) {
682  DeNoiseChannel *dnch = &s->dnch[ch];
683 
684  switch (s->noise_type) {
685  case WHITE_NOISE:
686  for (i = 0; i < 15; i++)
687  dnch->band_noise[i] = 0;
688  break;
689  case VINYL_NOISE:
690  for (i = 0; i < 15; i++)
691  dnch->band_noise[i] = get_band_noise(s, i, 50.0, 500.5, 2125.0) + FFMAX(i - 7, 0);
692  break;
693  case SHELLAC_NOISE:
694  for (i = 0; i < 15; i++)
695  dnch->band_noise[i] = get_band_noise(s, i, 1.0, 500.0, 1.0E10) + FFMAX(i - 12, -5);
696  break;
697  case CUSTOM_NOISE:
698  read_custom_noise(s, ch);
699  break;
700  default:
701  return AVERROR_BUG;
702  }
703 
704 
705  dnch->sfm_threshold = 0.8;
706  dnch->sfm_alpha = 0.05;
707  for (i = 0; i < 512; i++)
708  dnch->sfm_fail_flags[i] = 0;
709 
710  dnch->sfm_fail_total = 0;
711  j = FFMAX((int)(10.0 * (1.3 - dnch->sfm_threshold)), 1);
712 
713  for (i = 0; i < 512; i += j) {
714  dnch->sfm_fail_flags[i] = 1;
715  dnch->sfm_fail_total += 1;
716  }
717 
718  dnch->amt = av_calloc(s->bin_count, sizeof(*dnch->amt));
719  dnch->band_amt = av_calloc(s->number_of_bands, sizeof(*dnch->band_amt));
720  dnch->band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->band_excit));
721  dnch->gain = av_calloc(s->bin_count, sizeof(*dnch->gain));
722  dnch->prior = av_calloc(s->bin_count, sizeof(*dnch->prior));
723  dnch->prior_band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->prior_band_excit));
724  dnch->clean_data = av_calloc(s->bin_count, sizeof(*dnch->clean_data));
725  dnch->noisy_data = av_calloc(s->bin_count, sizeof(*dnch->noisy_data));
726  dnch->out_samples = av_calloc(s->buffer_length, sizeof(*dnch->out_samples));
727  dnch->abs_var = av_calloc(s->bin_count, sizeof(*dnch->abs_var));
728  dnch->rel_var = av_calloc(s->bin_count, sizeof(*dnch->rel_var));
729  dnch->min_abs_var = av_calloc(s->bin_count, sizeof(*dnch->min_abs_var));
730  dnch->fft_data = av_calloc(s->fft_length2 + 1, sizeof(*dnch->fft_data));
731  dnch->fft = av_fft_init(av_log2(s->fft_length2), 0);
732  dnch->ifft = av_fft_init(av_log2(s->fft_length2), 1);
734  sizeof(*dnch->spread_function));
735 
736  if (!dnch->amt ||
737  !dnch->band_amt ||
738  !dnch->band_excit ||
739  !dnch->gain ||
740  !dnch->prior ||
741  !dnch->prior_band_excit ||
742  !dnch->clean_data ||
743  !dnch->noisy_data ||
744  !dnch->out_samples ||
745  !dnch->fft_data ||
746  !dnch->abs_var ||
747  !dnch->rel_var ||
748  !dnch->min_abs_var ||
749  !dnch->spread_function ||
750  !dnch->fft ||
751  !dnch->ifft)
752  return AVERROR(ENOMEM);
753  }
754 
755  for (int ch = 0; ch < inlink->channels; ch++) {
756  DeNoiseChannel *dnch = &s->dnch[ch];
757  double *prior_band_excit = dnch->prior_band_excit;
758  double *prior = dnch->prior;
759  double min, max;
760  double p1, p2;
761 
762  p1 = pow(0.1, 2.5 / sdiv);
763  p2 = pow(0.1, 1.0 / sdiv);
764  j = 0;
765  for (m = 0; m < s->number_of_bands; m++) {
766  for (n = 0; n < s->number_of_bands; n++) {
767  if (n < m) {
768  dnch->spread_function[j++] = pow(p2, m - n);
769  } else if (n > m) {
770  dnch->spread_function[j++] = pow(p1, n - m);
771  } else {
772  dnch->spread_function[j++] = 1.0;
773  }
774  }
775  }
776 
777  for (m = 0; m < s->number_of_bands; m++) {
778  dnch->band_excit[m] = 0.0;
779  prior_band_excit[m] = 0.0;
780  }
781 
782  for (m = 0; m <= s->fft_length2; m++)
783  dnch->band_excit[s->bin2band[m]] += 1.0;
784 
785  j = 0;
786  for (m = 0; m < s->number_of_bands; m++) {
787  for (n = 0; n < s->number_of_bands; n++)
788  prior_band_excit[m] += dnch->spread_function[j++] * dnch->band_excit[n];
789  }
790 
791  min = pow(0.1, 2.5);
792  max = pow(0.1, 1.0);
793  for (int i = 0; i < s->number_of_bands; i++) {
794  if (i < lrint(12.0 * sdiv)) {
795  dnch->band_excit[i] = pow(0.1, 1.45 + 0.1 * i / sdiv);
796  } else {
797  dnch->band_excit[i] = pow(0.1, 2.5 - 0.2 * (i / sdiv - 14.0));
798  }
799  dnch->band_excit[i] = av_clipd(dnch->band_excit[i], min, max);
800  }
801 
802  for (int i = 0; i <= s->fft_length2; i++)
803  prior[i] = RRATIO;
804  for (int i = 0; i < s->buffer_length; i++)
805  dnch->out_samples[i] = 0;
806 
807  j = 0;
808  for (int i = 0; i < s->number_of_bands; i++)
809  for (int k = 0; k < s->number_of_bands; k++)
810  dnch->spread_function[j++] *= dnch->band_excit[i] / prior_band_excit[i];
811  }
812 
813  j = 0;
814  sar = s->sample_advance / s->sample_rate;
815  for (int i = 0; i <= s->fft_length2; i++) {
816  if ((i == s->fft_length2) || (s->bin2band[i] > j)) {
817  double d6 = (i - 1) * s->sample_rate / s->fft_length;
818  double d7 = fmin(0.008 + 2.2 / d6, 0.03);
819  s->band_alpha[j] = exp(-sar / d7);
820  s->band_beta[j] = 1.0 - s->band_alpha[j];
821  j = s->bin2band[i];
822  }
823  }
824 
825  wscale = sqrt(16.0 / (9.0 * s->fft_length));
826  sum = 0.0;
827  for (int i = 0; i < s->window_length; i++) {
828  double d10 = sin(i * M_PI / s->window_length);
829  d10 *= wscale * d10;
830  s->window[i] = d10;
831  sum += d10 * d10;
832  }
833 
834  s->window_weight = 0.5 * sum;
835  s->floor = (1LL << 48) * exp(-23.025558369790467) * s->window_weight;
836  s->sample_floor = s->floor * exp(4.144600506562284);
837  s->auto_floor = s->floor * exp(6.907667510937141);
838 
839  set_parameters(s);
840 
842  i = 0;
843  for (int j = 1; j < 16; j++) {
845  if (s->noise_band_edge[j] > lrint(1.1 * s->noise_band_edge[j - 1]))
846  i++;
847  s->noise_band_edge[16] = i;
848  }
849  s->noise_band_count = s->noise_band_edge[16];
850 
851  s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->fft_length);
852  if (!s->fifo)
853  return AVERROR(ENOMEM);
854 
855  return 0;
856 }
857 
858 static void preprocess(FFTComplex *in, int len)
859 {
860  double d1, d2, d3, d4, d5, d6, d7, d8, d9, d10;
861  int n, i, k;
862 
863  d5 = 2.0 * M_PI / len;
864  d8 = sin(0.5 * d5);
865  d8 = -2.0 * d8 * d8;
866  d7 = sin(d5);
867  d9 = 1.0 + d8;
868  d6 = d7;
869  n = len / 2;
870 
871  for (i = 1; i < len / 4; i++) {
872  k = n - i;
873  d2 = 0.5 * (in[i].re + in[k].re);
874  d1 = 0.5 * (in[i].im - in[k].im);
875  d4 = 0.5 * (in[i].im + in[k].im);
876  d3 = 0.5 * (in[k].re - in[i].re);
877  in[i].re = d2 + d9 * d4 + d6 * d3;
878  in[i].im = d1 + d9 * d3 - d6 * d4;
879  in[k].re = d2 - d9 * d4 - d6 * d3;
880  in[k].im = -d1 + d9 * d3 - d6 * d4;
881  d10 = d9;
882  d9 += d9 * d8 - d6 * d7;
883  d6 += d6 * d8 + d10 * d7;
884  }
885 
886  d2 = in[0].re;
887  in[0].re = d2 + in[0].im;
888  in[0].im = d2 - in[0].im;
889 }
890 
891 static void postprocess(FFTComplex *in, int len)
892 {
893  double d1, d2, d3, d4, d5, d6, d7, d8, d9, d10;
894  int n, i, k;
895 
896  d5 = 2.0 * M_PI / len;
897  d8 = sin(0.5 * d5);
898  d8 = -2.0 * d8 * d8;
899  d7 = sin(d5);
900  d9 = 1.0 + d8;
901  d6 = d7;
902  n = len / 2;
903  for (i = 1; i < len / 4; i++) {
904  k = n - i;
905  d2 = 0.5 * (in[i].re + in[k].re);
906  d1 = 0.5 * (in[i].im - in[k].im);
907  d4 = 0.5 * (in[i].re - in[k].re);
908  d3 = 0.5 * (in[i].im + in[k].im);
909  in[i].re = d2 - d9 * d3 - d6 * d4;
910  in[i].im = d1 + d9 * d4 - d6 * d3;
911  in[k].re = d2 + d9 * d3 + d6 * d4;
912  in[k].im = -d1 + d9 * d4 - d6 * d3;
913  d10 = d9;
914  d9 += d9 * d8 - d6 * d7;
915  d6 += d6 * d8 + d10 * d7;
916  }
917  d2 = in[0].re;
918  in[0].re = 0.5 * (d2 + in[0].im);
919  in[0].im = 0.5 * (d2 - in[0].im);
920 }
921 
923 {
924  for (int i = 0; i < 15; i++) {
925  dnch->noise_band_norm[i] = 0.0;
926  dnch->noise_band_avr[i] = 0.0;
927  dnch->noise_band_avi[i] = 0.0;
928  dnch->noise_band_var[i] = 0.0;
929  }
930 }
931 
933  DeNoiseChannel *dnch,
934  AVFrame *in, int ch)
935 {
936  float *src = (float *)in->extended_data[ch];
937  double mag2, var = 0.0, avr = 0.0, avi = 0.0;
938  int edge, j, k, n, edgemax;
939 
940  for (int i = 0; i < s->window_length; i++) {
941  dnch->fft_data[i].re = s->window[i] * src[i] * (1LL << 24);
942  dnch->fft_data[i].im = 0.0;
943  }
944 
945  for (int i = s->window_length; i < s->fft_length2; i++) {
946  dnch->fft_data[i].re = 0.0;
947  dnch->fft_data[i].im = 0.0;
948  }
949 
950  av_fft_permute(dnch->fft, dnch->fft_data);
951  av_fft_calc(dnch->fft, dnch->fft_data);
952 
953  preprocess(dnch->fft_data, s->fft_length);
954 
955  edge = s->noise_band_edge[0];
956  j = edge;
957  k = 0;
958  n = j;
959  edgemax = fmin(s->fft_length2, s->noise_band_edge[15]);
960  dnch->fft_data[s->fft_length2].re = dnch->fft_data[0].im;
961  dnch->fft_data[0].im = 0.0;
962  dnch->fft_data[s->fft_length2].im = 0.0;
963 
964  for (int i = j; i <= edgemax; i++) {
965  if ((i == j) && (i < edgemax)) {
966  if (j > edge) {
967  dnch->noise_band_norm[k - 1] += j - edge;
968  dnch->noise_band_avr[k - 1] += avr;
969  dnch->noise_band_avi[k - 1] += avi;
970  dnch->noise_band_var[k - 1] += var;
971  }
972  k++;
973  edge = j;
974  j = s->noise_band_edge[k];
975  if (k == 15) {
976  j++;
977  }
978  var = 0.0;
979  avr = 0.0;
980  avi = 0.0;
981  }
982  avr += dnch->fft_data[n].re;
983  avi += dnch->fft_data[n].im;
984  mag2 = dnch->fft_data[n].re * dnch->fft_data[n].re +
985  dnch->fft_data[n].im * dnch->fft_data[n].im;
986 
987  mag2 = fmax(mag2, s->sample_floor);
988 
989  dnch->noisy_data[i] = mag2;
990  var += mag2;
991  n++;
992  }
993 
994  dnch->noise_band_norm[k - 1] += j - edge;
995  dnch->noise_band_avr[k - 1] += avr;
996  dnch->noise_band_avi[k - 1] += avi;
997  dnch->noise_band_var[k - 1] += var;
998 }
999 
1001  DeNoiseChannel *dnch,
1002  double *sample_noise)
1003 {
1004  for (int i = 0; i < s->noise_band_count; i++) {
1005  dnch->noise_band_avr[i] /= dnch->noise_band_norm[i];
1006  dnch->noise_band_avi[i] /= dnch->noise_band_norm[i];
1007  dnch->noise_band_var[i] /= dnch->noise_band_norm[i];
1008  dnch->noise_band_var[i] -= dnch->noise_band_avr[i] * dnch->noise_band_avr[i] +
1009  dnch->noise_band_avi[i] * dnch->noise_band_avi[i];
1010  dnch->noise_band_auto_var[i] = dnch->noise_band_var[i];
1011  sample_noise[i] = (1.0 / C) * log(dnch->noise_band_var[i] / s->floor) - 100.0;
1012  }
1013  if (s->noise_band_count < 15) {
1014  for (int i = s->noise_band_count; i < 15; i++)
1015  sample_noise[i] = sample_noise[i - 1];
1016  }
1017 }
1018 
1020  DeNoiseChannel *dnch,
1021  double *sample_noise,
1022  int new_profile)
1023 {
1024  int new_band_noise[15];
1025  double temp[15];
1026  double sum = 0.0, d1;
1027  float new_noise_floor;
1028  int i, n;
1029 
1030  for (int m = 0; m < 15; m++)
1031  temp[m] = sample_noise[m];
1032 
1033  if (new_profile) {
1034  i = 0;
1035  for (int m = 0; m < 5; m++) {
1036  sum = 0.0;
1037  for (n = 0; n < 15; n++)
1038  sum += s->matrix_b[i++] * temp[n];
1039  s->vector_b[m] = sum;
1040  }
1041  solve(s->matrix_a, s->vector_b, 5);
1042  i = 0;
1043  for (int m = 0; m < 15; m++) {
1044  sum = 0.0;
1045  for (n = 0; n < 5; n++)
1046  sum += s->matrix_c[i++] * s->vector_b[n];
1047  temp[m] = sum;
1048  }
1049  }
1050 
1051  sum = 0.0;
1052  for (int m = 0; m < 15; m++)
1053  sum += temp[m];
1054 
1055  d1 = (int)(sum / 15.0 - 0.5);
1056  if (!new_profile)
1057  i = lrint(temp[7] - d1);
1058 
1059  for (d1 -= dnch->band_noise[7] - i; d1 > -20.0; d1 -= 1.0)
1060  ;
1061 
1062  for (int m = 0; m < 15; m++)
1063  temp[m] -= d1;
1064 
1065  new_noise_floor = d1 + 2.5;
1066 
1067  if (new_profile) {
1068  av_log(s, AV_LOG_INFO, "bn=");
1069  for (int m = 0; m < 15; m++) {
1070  new_band_noise[m] = lrint(temp[m]);
1071  new_band_noise[m] = av_clip(new_band_noise[m], -24, 24);
1072  av_log(s, AV_LOG_INFO, "%d ", new_band_noise[m]);
1073  }
1074  av_log(s, AV_LOG_INFO, "\n");
1075  memcpy(dnch->band_noise, new_band_noise, sizeof(new_band_noise));
1076  }
1077 
1078  if (s->track_noise)
1079  s->noise_floor = new_noise_floor;
1080 }
1081 
1082 typedef struct ThreadData {
1084 } ThreadData;
1085 
1086 static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
1087 {
1088  AudioFFTDeNoiseContext *s = ctx->priv;
1089  ThreadData *td = arg;
1090  AVFrame *in = td->in;
1091  const int start = (in->channels * jobnr) / nb_jobs;
1092  const int end = (in->channels * (jobnr+1)) / nb_jobs;
1093 
1094  for (int ch = start; ch < end; ch++) {
1095  DeNoiseChannel *dnch = &s->dnch[ch];
1096  const float *src = (const float *)in->extended_data[ch];
1097  double *dst = dnch->out_samples;
1098 
1099  if (s->track_noise) {
1100  int i = s->block_count & 0x1FF;
1101 
1102  if (dnch->sfm_fail_flags[i])
1103  dnch->sfm_fail_total--;
1104  dnch->sfm_fail_flags[i] = 0;
1105  dnch->sfm_threshold *= 1.0 - dnch->sfm_alpha;
1106  dnch->sfm_threshold += dnch->sfm_alpha * (0.5 + (1.0 / 640) * dnch->sfm_fail_total);
1107  }
1108 
1109  for (int m = 0; m < s->window_length; m++) {
1110  dnch->fft_data[m].re = s->window[m] * src[m] * (1LL << 24);
1111  dnch->fft_data[m].im = 0;
1112  }
1113 
1114  for (int m = s->window_length; m < s->fft_length2; m++) {
1115  dnch->fft_data[m].re = 0;
1116  dnch->fft_data[m].im = 0;
1117  }
1118 
1119  av_fft_permute(dnch->fft, dnch->fft_data);
1120  av_fft_calc(dnch->fft, dnch->fft_data);
1121 
1122  preprocess(dnch->fft_data, s->fft_length);
1123  process_frame(s, dnch, dnch->fft_data,
1124  dnch->prior,
1125  dnch->prior_band_excit,
1126  s->track_noise);
1127  postprocess(dnch->fft_data, s->fft_length);
1128 
1129  av_fft_permute(dnch->ifft, dnch->fft_data);
1130  av_fft_calc(dnch->ifft, dnch->fft_data);
1131 
1132  for (int m = 0; m < s->window_length; m++)
1133  dst[m] += s->window[m] * dnch->fft_data[m].re / (1LL << 24);
1134  }
1135 
1136  return 0;
1137 }
1138 
1140  DeNoiseChannel *dnch,
1141  double *levels)
1142 {
1143  if (s->noise_band_count > 0) {
1144  for (int i = 0; i < s->noise_band_count; i++) {
1145  levels[i] = (1.0 / C) * log(dnch->noise_band_auto_var[i] / s->floor) - 100.0;
1146  }
1147  if (s->noise_band_count < 15) {
1148  for (int i = s->noise_band_count; i < 15; i++)
1149  levels[i] = levels[i - 1];
1150  }
1151  } else {
1152  for (int i = 0; i < 15; i++) {
1153  levels[i] = -100.0;
1154  }
1155  }
1156 }
1157 
1159 {
1160  AVFilterContext *ctx = inlink->dst;
1161  AVFilterLink *outlink = ctx->outputs[0];
1162  AudioFFTDeNoiseContext *s = ctx->priv;
1163  AVFrame *out = NULL, *in = NULL;
1164  ThreadData td;
1165  int ret = 0;
1166 
1167  in = ff_get_audio_buffer(outlink, s->window_length);
1168  if (!in)
1169  return AVERROR(ENOMEM);
1170 
1171  ret = av_audio_fifo_peek(s->fifo, (void **)in->extended_data, s->window_length);
1172  if (ret < 0)
1173  goto end;
1174 
1175  if (s->track_noise) {
1176  for (int ch = 0; ch < inlink->channels; ch++) {
1177  DeNoiseChannel *dnch = &s->dnch[ch];
1178  double levels[15];
1179 
1180  get_auto_noise_levels(s, dnch, levels);
1181  set_noise_profile(s, dnch, levels, 0);
1182  }
1183 
1184  if (s->noise_floor != s->last_noise_floor)
1185  set_parameters(s);
1186  }
1187 
1188  if (s->sample_noise_start) {
1189  for (int ch = 0; ch < inlink->channels; ch++) {
1190  DeNoiseChannel *dnch = &s->dnch[ch];
1191 
1192  init_sample_noise(dnch);
1193  }
1194  s->sample_noise_start = 0;
1195  s->sample_noise = 1;
1196  }
1197 
1198  if (s->sample_noise) {
1199  for (int ch = 0; ch < inlink->channels; ch++) {
1200  DeNoiseChannel *dnch = &s->dnch[ch];
1201 
1202  sample_noise_block(s, dnch, in, ch);
1203  }
1204  }
1205 
1206  if (s->sample_noise_end) {
1207  for (int ch = 0; ch < inlink->channels; ch++) {
1208  DeNoiseChannel *dnch = &s->dnch[ch];
1209  double sample_noise[15];
1210 
1211  finish_sample_noise(s, dnch, sample_noise);
1212  set_noise_profile(s, dnch, sample_noise, 1);
1213  set_band_parameters(s, dnch);
1214  }
1215  s->sample_noise = 0;
1216  s->sample_noise_end = 0;
1217  }
1218 
1219  s->block_count++;
1220  td.in = in;
1221  ctx->internal->execute(ctx, filter_channel, &td, NULL,
1222  FFMIN(outlink->channels, ff_filter_get_nb_threads(ctx)));
1223 
1224  out = ff_get_audio_buffer(outlink, s->sample_advance);
1225  if (!out) {
1226  ret = AVERROR(ENOMEM);
1227  goto end;
1228  }
1229 
1230  for (int ch = 0; ch < inlink->channels; ch++) {
1231  DeNoiseChannel *dnch = &s->dnch[ch];
1232  double *src = dnch->out_samples;
1233  float *orig = (float *)in->extended_data[ch];
1234  float *dst = (float *)out->extended_data[ch];
1235 
1236  switch (s->output_mode) {
1237  case IN_MODE:
1238  for (int m = 0; m < s->sample_advance; m++)
1239  dst[m] = orig[m];
1240  break;
1241  case OUT_MODE:
1242  for (int m = 0; m < s->sample_advance; m++)
1243  dst[m] = src[m];
1244  break;
1245  case NOISE_MODE:
1246  for (int m = 0; m < s->sample_advance; m++)
1247  dst[m] = orig[m] - src[m];
1248  break;
1249  default:
1250  av_frame_free(&out);
1251  ret = AVERROR_BUG;
1252  goto end;
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 
1259 
1260  out->pts = s->pts;
1261  ret = ff_filter_frame(outlink, out);
1262  if (ret < 0)
1263  goto end;
1264  s->pts += av_rescale_q(s->sample_advance, (AVRational){1, outlink->sample_rate}, outlink->time_base);
1265 end:
1266  av_frame_free(&in);
1267 
1268  return ret;
1269 }
1270 
1272 {
1273  AVFilterLink *inlink = ctx->inputs[0];
1274  AVFilterLink *outlink = ctx->outputs[0];
1275  AudioFFTDeNoiseContext *s = ctx->priv;
1276  AVFrame *frame = NULL;
1277  int ret;
1278 
1279  FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
1280 
1281  ret = ff_inlink_consume_frame(inlink, &frame);
1282  if (ret < 0)
1283  return ret;
1284 
1285  if (ret > 0) {
1286  if (s->pts == AV_NOPTS_VALUE)
1287  s->pts = frame->pts;
1288 
1289  ret = av_audio_fifo_write(s->fifo, (void **)frame->extended_data, frame->nb_samples);
1290  av_frame_free(&frame);
1291  if (ret < 0)
1292  return ret;
1293  }
1294 
1295  if (av_audio_fifo_size(s->fifo) >= s->window_length)
1296  return output_frame(inlink);
1297 
1298  FF_FILTER_FORWARD_STATUS(inlink, outlink);
1299  if (ff_outlink_frame_wanted(outlink) &&
1301  ff_inlink_request_frame(inlink);
1302  return 0;
1303  }
1304 
1305  return FFERROR_NOT_READY;
1306 }
1307 
1309 {
1310  AudioFFTDeNoiseContext *s = ctx->priv;
1311 
1312  av_freep(&s->window);
1313  av_freep(&s->bin2band);
1314  av_freep(&s->band_alpha);
1315  av_freep(&s->band_beta);
1316 
1317  if (s->dnch) {
1318  for (int ch = 0; ch < s->channels; ch++) {
1319  DeNoiseChannel *dnch = &s->dnch[ch];
1320  av_freep(&dnch->amt);
1321  av_freep(&dnch->band_amt);
1322  av_freep(&dnch->band_excit);
1323  av_freep(&dnch->gain);
1324  av_freep(&dnch->prior);
1325  av_freep(&dnch->prior_band_excit);
1326  av_freep(&dnch->clean_data);
1327  av_freep(&dnch->noisy_data);
1328  av_freep(&dnch->out_samples);
1329  av_freep(&dnch->spread_function);
1330  av_freep(&dnch->abs_var);
1331  av_freep(&dnch->rel_var);
1332  av_freep(&dnch->min_abs_var);
1333  av_freep(&dnch->fft_data);
1334  av_fft_end(dnch->fft);
1335  dnch->fft = NULL;
1336  av_fft_end(dnch->ifft);
1337  dnch->ifft = NULL;
1338  }
1339  av_freep(&s->dnch);
1340  }
1341 
1343 }
1344 
1346 {
1349  static const enum AVSampleFormat sample_fmts[] = {
1352  };
1353  int ret;
1354 
1355  formats = ff_make_format_list(sample_fmts);
1356  if (!formats)
1357  return AVERROR(ENOMEM);
1358  ret = ff_set_common_formats(ctx, formats);
1359  if (ret < 0)
1360  return ret;
1361 
1362  layouts = ff_all_channel_counts();
1363  if (!layouts)
1364  return AVERROR(ENOMEM);
1365 
1366  ret = ff_set_common_channel_layouts(ctx, layouts);
1367  if (ret < 0)
1368  return ret;
1369 
1370  formats = ff_all_samplerates();
1371  return ff_set_common_samplerates(ctx, formats);
1372 }
1373 
1374 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
1375  char *res, int res_len, int flags)
1376 {
1377  AudioFFTDeNoiseContext *s = ctx->priv;
1378  int need_reset = 0;
1379  int ret = 0;
1380 
1381  if (!strcmp(cmd, "sample_noise") ||
1382  !strcmp(cmd, "sn")) {
1383  if (!strcmp(args, "start")) {
1384  s->sample_noise_start = 1;
1385  s->sample_noise_end = 0;
1386  } else if (!strcmp(args, "end") ||
1387  !strcmp(args, "stop")) {
1388  s->sample_noise_start = 0;
1389  s->sample_noise_end = 1;
1390  }
1391  } else {
1392  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
1393  if (ret < 0)
1394  return ret;
1395  need_reset = 1;
1396  }
1397 
1398  if (need_reset)
1399  set_parameters(s);
1400 
1401  return 0;
1402 }
1403 
1404 static const AVFilterPad inputs[] = {
1405  {
1406  .name = "default",
1407  .type = AVMEDIA_TYPE_AUDIO,
1408  .config_props = config_input,
1409  },
1410  { NULL }
1411 };
1412 
1413 static const AVFilterPad outputs[] = {
1414  {
1415  .name = "default",
1416  .type = AVMEDIA_TYPE_AUDIO,
1417  },
1418  { NULL }
1419 };
1420 
1422  .name = "afftdn",
1423  .description = NULL_IF_CONFIG_SMALL("Denoise audio samples using FFT."),
1424  .query_formats = query_formats,
1425  .priv_size = sizeof(AudioFFTDeNoiseContext),
1426  .priv_class = &afftdn_class,
1427  .activate = activate,
1428  .uninit = uninit,
1429  .inputs = inputs,
1430  .outputs = outputs,
1434 };
double * band_excit
Definition: af_afftdn.c:58
float, planar
Definition: samplefmt.h:69
#define C
Definition: af_afftdn.c:33
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link&#39;s FIFO and update the link&#39;s stats.
Definition: avfilter.c:1494
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:550
double noise_band_var[15]
Definition: af_afftdn.c:75
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:59
double noise_band_norm[15]
Definition: af_afftdn.c:72
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
av_cold void av_fft_end(FFTContext *s)
Definition: avfft.c:48
double sfm_results[3]
Definition: af_afftdn.c:79
Main libavfilter public API header.
else temp
Definition: vf_mcdeint.c:256
int band_noise[15]
Definition: af_afftdn.c:53
static void set_parameters(AudioFFTDeNoiseContext *s)
Definition: af_afftdn.c:581
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:45
FF_FILTER_FORWARD_STATUS(inlink, outlink)
int av_log2(unsigned v)
Definition: intmath.c:26
static const AVOption afftdn_options[]
Definition: af_afftdn.c:147
double * min_abs_var
Definition: af_afftdn.c:68
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:36
static void set_noise_profile(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise, int new_profile)
Definition: af_afftdn.c:1019
FFTSample re
Definition: avfft.h:38
NoiseType
Definition: af_afftdn.c:44
void av_fft_permute(FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling ff_fft_calc().
Definition: avfft.c:38
static int process_get_band_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int band)
Definition: af_afftdn.c:217
return FFERROR_NOT_READY
static int config_input(AVFilterLink *inlink)
Definition: af_afftdn.c:610
#define OFFSET(x)
Definition: af_afftdn.c:143
#define src
Definition: vp8dsp.c:254
#define RRATIO
Definition: af_afftdn.c:35
DeNoiseChannel * dnch
Definition: af_afftdn.c:123
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1620
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
int sfm_fail_flags[512]
Definition: af_afftdn.c:80
static void factor(double *array, int size)
Definition: af_afftdn.c:184
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:125
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1093
static double freq2bark(double x)
Definition: af_afftdn.c:485
FFTContext * fft
Definition: af_afftdn.c:70
#define av_cold
Definition: attributes.h:82
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
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
double noise_band_sample[15]
Definition: af_afftdn.c:55
AVAudioFifo * fifo
Definition: af_afftdn.c:140
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
double * clean_data
Definition: af_afftdn.c:62
double * amt
Definition: af_afftdn.c:56
double sfm_alpha
Definition: af_afftdn.c:78
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function.If this function returns true
#define av_log(a,...)
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
A filter pad used for either input or output.
Definition: internal.h:54
static int query_formats(AVFilterContext *ctx)
Definition: af_afftdn.c:1345
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:569
#define td
Definition: regdef.h:70
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:86
double * out_samples
Definition: af_afftdn.c:64
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: af_afftdn.c:1086
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
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:887
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:116
const char * arg
Definition: jacosubdec.c:66
double * prior_band_excit
Definition: af_afftdn.c:61
FFTContext * av_fft_init(int nbits, int inverse)
Set up a complex FFT.
Definition: avfft.c:28
static int get_band_edge(AudioFFTDeNoiseContext *s, int band)
Definition: af_afftdn.c:500
#define FFMAX(a, b)
Definition: common.h:94
static void get_auto_noise_levels(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *levels)
Definition: af_afftdn.c:1139
int8_t exp
Definition: eval.c:72
int av_sscanf(const char *string, const char *format,...)
See libc sscanf manual for more information.
Definition: avsscanf.c:962
double noise_band_auto_var[15]
Definition: af_afftdn.c:54
Context for an Audio FIFO Buffer.
Definition: audio_fifo.c:34
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:228
#define b
Definition: input.c:41
Definition: fft.h:88
int channels
number of audio channels, only used for audio.
Definition: frame.h:601
audio channel layout utility functions
#define E
Definition: avdct.c:32
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afftdn.c:1308
FFTContext * ifft
Definition: af_afftdn.c:70
#define FFMIN(a, b)
Definition: common.h:96
static int get_band_noise(AudioFFTDeNoiseContext *s, int band, double a, double b, double c)
Definition: af_afftdn.c:168
float fmaxf(float, float)
static void read_custom_noise(AudioFFTDeNoiseContext *s, int ch)
Definition: af_afftdn.c:549
int sfm_fail_total
Definition: af_afftdn.c:81
#define ff_clz
Definition: intmath.h:142
#define AF
Definition: af_afftdn.c:144
static void set_band_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch)
Definition: af_afftdn.c:513
AVFormatContext * ctx
Definition: movenc.c:48
static void preprocess(FFTComplex *in, int len)
Definition: af_afftdn.c:858
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
double * gain
Definition: af_afftdn.c:59
#define s(width, name)
Definition: cbs_vp9.c:257
OutModes
Definition: af_afftdn.c:37
static int output_frame(AVFilterLink *inlink)
Definition: af_afftdn.c:1158
int n
Definition: avisynth_c.h:760
static void postprocess(FFTComplex *in, int len)
Definition: af_afftdn.c:891
double noise_band_avr[15]
Definition: af_afftdn.c:73
A list of supported channel layouts.
Definition: formats.h:85
if(ret)
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
double * rel_var
Definition: af_afftdn.c:67
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
FFTComplex * fft_data
Definition: af_afftdn.c:69
Used for passing data between threads.
Definition: dsddec.c:64
double * abs_var
Definition: af_afftdn.c:66
FFT functions.
static const AVFilterPad outputs[]
Definition: af_afftdn.c:1413
double fmax(double, double)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Describe the class of an AVClass context structure.
Definition: log.h:67
double noise_band_avi[15]
Definition: af_afftdn.c:74
Filter definition.
Definition: avfilter.h:144
static double limit_gain(double a, double b)
Definition: af_afftdn.c:283
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFILTER_DEFINE_CLASS(afftdn)
const char * name
Filter name.
Definition: avfilter.h:148
double * band_amt
Definition: af_afftdn.c:57
static void finish_sample_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise)
Definition: af_afftdn.c:1000
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static void solve(double *matrix, double *vector, int size)
Definition: af_afftdn.c:198
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:394
double * spread_function
Definition: af_afftdn.c:65
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:112
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
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
Definition: audio_fifo.c:201
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:184
double * prior
Definition: af_afftdn.c:60
#define M_LN10
Definition: mathematics.h:43
int
static void process_frame(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, FFTComplex *fft_data, double *prior, double *prior_band_excit, int track_noise)
Definition: af_afftdn.c:292
FFTSample im
Definition: avfft.h:38
static int activate(AVFilterContext *ctx)
Definition: af_afftdn.c:1271
#define RATIO
Definition: af_afftdn.c:34
double fmin(double, double)
avfilter_execute_func * execute
Definition: internal.h:155
double sfm_threshold
Definition: af_afftdn.c:77
#define av_free(p)
Audio FIFO Buffer.
int len
static void init_sample_noise(DeNoiseChannel *dnch)
Definition: af_afftdn.c:922
A list of supported formats for one end of a filter link.
Definition: formats.h:64
#define lrint
Definition: tablegen.h:53
int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
Peek data from an AVAudioFifo.
Definition: audio_fifo.c:138
An instance of a filter.
Definition: avfilter.h:338
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
static const AVFilterPad inputs[]
Definition: af_afftdn.c:1404
FILE * out
Definition: movenc.c:54
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_afftdn.c:1374
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
#define M_PI
Definition: mathematics.h:52
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
AVFrame * in
Definition: af_afftdn.c:1083
formats
Definition: signature.h:48
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
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:409
#define AFR
Definition: af_afftdn.c:145
double * noisy_data
Definition: af_afftdn.c:63
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
float min
static void sample_noise_block(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, AVFrame *in, int ch)
Definition: af_afftdn.c:932
void av_fft_calc(FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in av_fft_init().
Definition: avfft.c:43
AVFilter ff_af_afftdn
Definition: af_afftdn.c:1421
static int get_band_centre(AudioFFTDeNoiseContext *s, int band)
Definition: af_afftdn.c:492
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
for(j=16;j >0;--j)
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:557
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static void calculate_sfm(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int start, int end)
Definition: af_afftdn.c:247