/* * Copyright (c) 2018 The FFmpeg Project * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include "libavutil/avstring.h" #include "libavutil/channel_layout.h" #include "libavutil/opt.h" #include "libavutil/tx.h" #include "avfilter.h" #include "audio.h" #include "formats.h" #include "filters.h" #define C (M_LN10 * 0.1) #define SOLVE_SIZE (5) #define NB_PROFILE_BANDS (15) enum SampleNoiseModes { SAMPLE_NONE, SAMPLE_START, SAMPLE_STOP, NB_SAMPLEMODES }; enum OutModes { IN_MODE, OUT_MODE, NOISE_MODE, NB_MODES }; enum NoiseLinkType { NONE_LINK, MIN_LINK, MAX_LINK, AVERAGE_LINK, NB_LINK }; enum NoiseType { WHITE_NOISE, VINYL_NOISE, SHELLAC_NOISE, CUSTOM_NOISE, NB_NOISE }; typedef struct DeNoiseChannel { double band_noise[NB_PROFILE_BANDS]; double noise_band_auto_var[NB_PROFILE_BANDS]; double noise_band_sample[NB_PROFILE_BANDS]; double *amt; double *band_amt; double *band_excit; double *gain; double *smoothed_gain; double *prior; double *prior_band_excit; double *clean_data; double *noisy_data; double *out_samples; double *spread_function; double *abs_var; double *rel_var; double *min_abs_var; void *fft_in; void *fft_out; AVTXContext *fft, *ifft; av_tx_fn tx_fn, itx_fn; double noise_band_norm[NB_PROFILE_BANDS]; double noise_band_avr[NB_PROFILE_BANDS]; double noise_band_avi[NB_PROFILE_BANDS]; double noise_band_var[NB_PROFILE_BANDS]; double noise_reduction; double last_noise_reduction; double noise_floor; double last_noise_floor; double residual_floor; double last_residual_floor; double max_gain; double max_var; double gain_scale; } DeNoiseChannel; typedef struct AudioFFTDeNoiseContext { const AVClass *class; int format; size_t sample_size; size_t complex_sample_size; float noise_reduction; float noise_floor; int noise_type; char *band_noise_str; float residual_floor; int track_noise; int track_residual; int output_mode; int noise_floor_link; float ratio; int gain_smooth; float band_multiplier; float floor_offset; int channels; int sample_noise; int sample_noise_blocks; int sample_noise_mode; float sample_rate; int buffer_length; int fft_length; int fft_length2; int bin_count; int window_length; int sample_advance; int number_of_bands; int band_centre[NB_PROFILE_BANDS]; int *bin2band; double *window; double *band_alpha; double *band_beta; DeNoiseChannel *dnch; AVFrame *winframe; double window_weight; double floor; double sample_floor; int noise_band_edge[NB_PROFILE_BANDS + 2]; int noise_band_count; double matrix_a[SOLVE_SIZE * SOLVE_SIZE]; double vector_b[SOLVE_SIZE]; double matrix_b[SOLVE_SIZE * NB_PROFILE_BANDS]; double matrix_c[SOLVE_SIZE * NB_PROFILE_BANDS]; } AudioFFTDeNoiseContext; #define OFFSET(x) offsetof(AudioFFTDeNoiseContext, x) #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM static const AVOption afftdn_options[] = { { "noise_reduction", "set the noise reduction",OFFSET(noise_reduction), AV_OPT_TYPE_FLOAT,{.dbl = 12}, .01, 97, AFR }, { "nr", "set the noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_FLOAT, {.dbl = 12}, .01, 97, AFR }, { "noise_floor", "set the noise floor",OFFSET(noise_floor), AV_OPT_TYPE_FLOAT, {.dbl =-50}, -80,-20, AFR }, { "nf", "set the noise floor", OFFSET(noise_floor), AV_OPT_TYPE_FLOAT, {.dbl =-50}, -80,-20, AFR }, { "noise_type", "set the noise type", OFFSET(noise_type), AV_OPT_TYPE_INT, {.i64 = WHITE_NOISE}, WHITE_NOISE, NB_NOISE-1, AF, "type" }, { "nt", "set the noise type", OFFSET(noise_type), AV_OPT_TYPE_INT, {.i64 = WHITE_NOISE}, WHITE_NOISE, NB_NOISE-1, AF, "type" }, { "white", "white noise", 0, AV_OPT_TYPE_CONST, {.i64 = WHITE_NOISE}, 0, 0, AF, "type" }, { "w", "white noise", 0, AV_OPT_TYPE_CONST, {.i64 = WHITE_NOISE}, 0, 0, AF, "type" }, { "vinyl", "vinyl noise", 0, AV_OPT_TYPE_CONST, {.i64 = VINYL_NOISE}, 0, 0, AF, "type" }, { "v", "vinyl noise", 0, AV_OPT_TYPE_CONST, {.i64 = VINYL_NOISE}, 0, 0, AF, "type" }, { "shellac", "shellac noise", 0, AV_OPT_TYPE_CONST, {.i64 = SHELLAC_NOISE}, 0, 0, AF, "type" }, { "s", "shellac noise", 0, AV_OPT_TYPE_CONST, {.i64 = SHELLAC_NOISE}, 0, 0, AF, "type" }, { "custom", "custom noise", 0, AV_OPT_TYPE_CONST, {.i64 = CUSTOM_NOISE}, 0, 0, AF, "type" }, { "c", "custom noise", 0, AV_OPT_TYPE_CONST, {.i64 = CUSTOM_NOISE}, 0, 0, AF, "type" }, { "band_noise", "set the custom bands noise", OFFSET(band_noise_str), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, AF }, { "bn", "set the custom bands noise", OFFSET(band_noise_str), AV_OPT_TYPE_STRING, {.str = 0}, 0, 0, AF }, { "residual_floor", "set the residual floor",OFFSET(residual_floor), AV_OPT_TYPE_FLOAT, {.dbl =-38}, -80,-20, AFR }, { "rf", "set the residual floor", OFFSET(residual_floor), AV_OPT_TYPE_FLOAT, {.dbl =-38}, -80,-20, AFR }, { "track_noise", "track noise", OFFSET(track_noise), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR }, { "tn", "track noise", OFFSET(track_noise), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR }, { "track_residual", "track residual", OFFSET(track_residual), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR }, { "tr", "track residual", OFFSET(track_residual), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AFR }, { "output_mode", "set output mode", OFFSET(output_mode), AV_OPT_TYPE_INT, {.i64 = OUT_MODE}, 0, NB_MODES-1, AFR, "mode" }, { "om", "set output mode", OFFSET(output_mode), AV_OPT_TYPE_INT, {.i64 = OUT_MODE}, 0, NB_MODES-1, AFR, "mode" }, { "input", "input", 0, AV_OPT_TYPE_CONST, {.i64 = IN_MODE}, 0, 0, AFR, "mode" }, { "i", "input", 0, AV_OPT_TYPE_CONST, {.i64 = IN_MODE}, 0, 0, AFR, "mode" }, { "output", "output", 0, AV_OPT_TYPE_CONST, {.i64 = OUT_MODE}, 0, 0, AFR, "mode" }, { "o", "output", 0, AV_OPT_TYPE_CONST, {.i64 = OUT_MODE}, 0, 0, AFR, "mode" }, { "noise", "noise", 0, AV_OPT_TYPE_CONST, {.i64 = NOISE_MODE}, 0, 0, AFR, "mode" }, { "n", "noise", 0, AV_OPT_TYPE_CONST, {.i64 = NOISE_MODE}, 0, 0, AFR, "mode" }, { "adaptivity", "set adaptivity factor",OFFSET(ratio), AV_OPT_TYPE_FLOAT, {.dbl = 0.5}, 0, 1, AFR }, { "ad", "set adaptivity factor",OFFSET(ratio), AV_OPT_TYPE_FLOAT, {.dbl = 0.5}, 0, 1, AFR }, { "floor_offset", "set noise floor offset factor",OFFSET(floor_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, -2, 2, AFR }, { "fo", "set noise floor offset factor",OFFSET(floor_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, -2, 2, AFR }, { "noise_link", "set the noise floor link",OFFSET(noise_floor_link),AV_OPT_TYPE_INT,{.i64 = MIN_LINK}, 0, NB_LINK-1, AFR, "link" }, { "nl", "set the noise floor link", OFFSET(noise_floor_link),AV_OPT_TYPE_INT,{.i64 = MIN_LINK}, 0, NB_LINK-1, AFR, "link" }, { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = NONE_LINK}, 0, 0, AFR, "link" }, { "min", "min", 0, AV_OPT_TYPE_CONST, {.i64 = MIN_LINK}, 0, 0, AFR, "link" }, { "max", "max", 0, AV_OPT_TYPE_CONST, {.i64 = MAX_LINK}, 0, 0, AFR, "link" }, { "average", "average", 0, AV_OPT_TYPE_CONST, {.i64 = AVERAGE_LINK}, 0, 0, AFR, "link" }, { "band_multiplier", "set band multiplier",OFFSET(band_multiplier), AV_OPT_TYPE_FLOAT,{.dbl = 1.25}, 0.2,5, AF }, { "bm", "set band multiplier", OFFSET(band_multiplier), AV_OPT_TYPE_FLOAT,{.dbl = 1.25}, 0.2,5, AF }, { "sample_noise", "set sample noise mode",OFFSET(sample_noise_mode),AV_OPT_TYPE_INT,{.i64 = SAMPLE_NONE}, 0, NB_SAMPLEMODES-1, AFR, "sample" }, { "sn", "set sample noise mode",OFFSET(sample_noise_mode),AV_OPT_TYPE_INT,{.i64 = SAMPLE_NONE}, 0, NB_SAMPLEMODES-1, AFR, "sample" }, { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_NONE}, 0, 0, AFR, "sample" }, { "start", "start", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_START}, 0, 0, AFR, "sample" }, { "begin", "start", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_START}, 0, 0, AFR, "sample" }, { "stop", "stop", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_STOP}, 0, 0, AFR, "sample" }, { "end", "stop", 0, AV_OPT_TYPE_CONST, {.i64 = SAMPLE_STOP}, 0, 0, AFR, "sample" }, { "gain_smooth", "set gain smooth radius",OFFSET(gain_smooth), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 50, AFR }, { "gs", "set gain smooth radius",OFFSET(gain_smooth), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 50, AFR }, { NULL } }; AVFILTER_DEFINE_CLASS(afftdn); static double get_band_noise(AudioFFTDeNoiseContext *s, int band, double a, double b, double c) { double d1, d2, d3; d1 = a / s->band_centre[band]; d1 = 10.0 * log(1.0 + d1 * d1) / M_LN10; d2 = b / s->band_centre[band]; d2 = 10.0 * log(1.0 + d2 * d2) / M_LN10; d3 = s->band_centre[band] / c; d3 = 10.0 * log(1.0 + d3 * d3) / M_LN10; return -d1 + d2 - d3; } static void factor(double *array, int size) { for (int i = 0; i < size - 1; i++) { for (int j = i + 1; j < size; j++) { double d = array[j + i * size] / array[i + i * size]; array[j + i * size] = d; for (int k = i + 1; k < size; k++) { array[j + k * size] -= d * array[i + k * size]; } } } } static void solve(double *matrix, double *vector, int size) { for (int i = 0; i < size - 1; i++) { for (int j = i + 1; j < size; j++) { double d = matrix[j + i * size]; vector[j] -= d * vector[i]; } } vector[size - 1] /= matrix[size * size - 1]; for (int i = size - 2; i >= 0; i--) { double d = vector[i]; for (int j = i + 1; j < size; j++) d -= matrix[i + j * size] * vector[j]; vector[i] = d / matrix[i + i * size]; } } static double process_get_band_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int band) { double product, sum, f; int i = 0; if (band < NB_PROFILE_BANDS) return dnch->band_noise[band]; for (int j = 0; j < SOLVE_SIZE; j++) { sum = 0.0; for (int k = 0; k < NB_PROFILE_BANDS; k++) sum += s->matrix_b[i++] * dnch->band_noise[k]; s->vector_b[j] = sum; } solve(s->matrix_a, s->vector_b, SOLVE_SIZE); f = (0.5 * s->sample_rate) / s->band_centre[NB_PROFILE_BANDS-1]; f = 15.0 + log(f / 1.5) / log(1.5); sum = 0.0; product = 1.0; for (int j = 0; j < SOLVE_SIZE; j++) { sum += product * s->vector_b[j]; product *= f; } return sum; } static double limit_gain(double a, double b) { if (a > 1.0) return (b * a - 1.0) / (b + a - 2.0); if (a < 1.0) return (b * a - 2.0 * a + 1.0) / (b - a); return 1.0; } static void spectral_flatness(AudioFFTDeNoiseContext *s, const double *const spectral, double floor, int len, double *rnum, double *rden) { double num = 0., den = 0.; int size = 0; for (int n = 0; n < len; n++) { const double v = spectral[n]; if (v > floor) { num += log(v); den += v; size++; } } size = FFMAX(size, 1); num /= size; den /= size; num = exp(num); *rnum = num; *rden = den; } static void set_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int update_var, int update_auto_var); static double floor_offset(const double *S, int size, double mean) { double offset = 0.0; for (int n = 0; n < size; n++) { const double p = S[n] - mean; offset = fmax(offset, fabs(p)); } return offset / mean; } static void process_frame(AVFilterContext *ctx, AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *prior, double *prior_band_excit, int track_noise) { AVFilterLink *outlink = ctx->outputs[0]; const double *abs_var = dnch->abs_var; const double ratio = outlink->frame_count_out ? s->ratio : 1.0; const double rratio = 1. - ratio; const int *bin2band = s->bin2band; double *noisy_data = dnch->noisy_data; double *band_excit = dnch->band_excit; double *band_amt = dnch->band_amt; double *smoothed_gain = dnch->smoothed_gain; AVComplexDouble *fft_data_dbl = dnch->fft_out; AVComplexFloat *fft_data_flt = dnch->fft_out; double *gain = dnch->gain; for (int i = 0; i < s->bin_count; i++) { double sqr_new_gain, new_gain, power, mag, mag_abs_var, new_mag_abs_var; switch (s->format) { case AV_SAMPLE_FMT_FLTP: noisy_data[i] = mag = hypot(fft_data_flt[i].re, fft_data_flt[i].im); break; case AV_SAMPLE_FMT_DBLP: noisy_data[i] = mag = hypot(fft_data_dbl[i].re, fft_data_dbl[i].im); break; } power = mag * mag; mag_abs_var = power / abs_var[i]; new_mag_abs_var = ratio * prior[i] + rratio * fmax(mag_abs_var - 1.0, 0.0); new_gain = new_mag_abs_var / (1.0 + new_mag_abs_var); sqr_new_gain = new_gain * new_gain; prior[i] = mag_abs_var * sqr_new_gain; dnch->clean_data[i] = power * sqr_new_gain; gain[i] = new_gain; } if (track_noise) { double flatness, num, den; spectral_flatness(s, noisy_data, s->floor, s->bin_count, &num, &den); flatness = num / den; if (flatness > 0.8) { const double offset = s->floor_offset * floor_offset(noisy_data, s->bin_count, den); const double new_floor = av_clipd(10.0 * log10(den) - 100.0 + offset, -90., -20.); dnch->noise_floor = 0.1 * new_floor + dnch->noise_floor * 0.9; set_parameters(s, dnch, 1, 1); } } for (int i = 0; i < s->number_of_bands; i++) { band_excit[i] = 0.0; band_amt[i] = 0.0; } for (int i = 0; i < s->bin_count; i++) band_excit[bin2band[i]] += dnch->clean_data[i]; for (int i = 0; i < s->number_of_bands; i++) { band_excit[i] = fmax(band_excit[i], s->band_alpha[i] * band_excit[i] + s->band_beta[i] * prior_band_excit[i]); prior_band_excit[i] = band_excit[i]; } for (int j = 0, i = 0; j < s->number_of_bands; j++) { for (int k = 0; k < s->number_of_bands; k++) { band_amt[j] += dnch->spread_function[i++] * band_excit[k]; } } for (int i = 0; i < s->bin_count; i++) dnch->amt[i] = band_amt[bin2band[i]]; for (int i = 0; i < s->bin_count; i++) { if (dnch->amt[i] > abs_var[i]) { gain[i] = 1.0; } else if (dnch->amt[i] > dnch->min_abs_var[i]) { const double limit = sqrt(abs_var[i] / dnch->amt[i]); gain[i] = limit_gain(gain[i], limit); } else { gain[i] = limit_gain(gain[i], dnch->max_gain); } } memcpy(smoothed_gain, gain, s->bin_count * sizeof(*smoothed_gain)); if (s->gain_smooth > 0) { const int r = s->gain_smooth; for (int i = r; i < s->bin_count - r; i++) { const double gc = gain[i]; double num = 0., den = 0.; for (int j = -r; j <= r; j++) { const double g = gain[i + j]; const double d = 1. - fabs(g - gc); num += g * d; den += d; } smoothed_gain[i] = num / den; } } switch (s->format) { case AV_SAMPLE_FMT_FLTP: for (int i = 0; i < s->bin_count; i++) { const float new_gain = smoothed_gain[i]; fft_data_flt[i].re *= new_gain; fft_data_flt[i].im *= new_gain; } break; case AV_SAMPLE_FMT_DBLP: for (int i = 0; i < s->bin_count; i++) { const double new_gain = smoothed_gain[i]; fft_data_dbl[i].re *= new_gain; fft_data_dbl[i].im *= new_gain; } break; } } static double freq2bark(double x) { double d = x / 7500.0; return 13.0 * atan(7.6E-4 * x) + 3.5 * atan(d * d); } static int get_band_centre(AudioFFTDeNoiseContext *s, int band) { if (band == -1) return lrint(s->band_centre[0] / 1.5); return s->band_centre[band]; } static int get_band_edge(AudioFFTDeNoiseContext *s, int band) { int i; if (band == NB_PROFILE_BANDS) { i = lrint(s->band_centre[NB_PROFILE_BANDS - 1] * 1.224745); } else { i = lrint(s->band_centre[band] / 1.224745); } return FFMIN(i, s->sample_rate / 2); } static void set_band_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch) { double band_noise, d2, d3, d4, d5; int i = 0, j = 0, k = 0; d5 = 0.0; band_noise = process_get_band_noise(s, dnch, 0); for (int m = j; m < s->bin_count; m++) { if (m == j) { i = j; d5 = band_noise; if (k >= NB_PROFILE_BANDS) { j = s->bin_count; } else { j = s->fft_length * get_band_centre(s, k) / s->sample_rate; } d2 = j - i; band_noise = process_get_band_noise(s, dnch, k); k++; } d3 = (j - m) / d2; d4 = (m - i) / d2; dnch->rel_var[m] = exp((d5 * d3 + band_noise * d4) * C); } for (i = 0; i < NB_PROFILE_BANDS; i++) dnch->noise_band_auto_var[i] = dnch->max_var * exp((process_get_band_noise(s, dnch, i) - 2.0) * C); } static void read_custom_noise(AudioFFTDeNoiseContext *s, int ch) { DeNoiseChannel *dnch = &s->dnch[ch]; char *custom_noise_str, *p, *arg, *saveptr = NULL; double band_noise[NB_PROFILE_BANDS] = { 0.f }; int ret; if (!s->band_noise_str) return; custom_noise_str = p = av_strdup(s->band_noise_str); if (!p) return; for (int i = 0; i < NB_PROFILE_BANDS; i++) { float noise; if (!(arg = av_strtok(p, "| ", &saveptr))) break; p = NULL; ret = av_sscanf(arg, "%f", &noise); if (ret != 1) { av_log(s, AV_LOG_ERROR, "Custom band noise must be float.\n"); break; } band_noise[i] = av_clipd(noise, -24., 24.); } av_free(custom_noise_str); memcpy(dnch->band_noise, band_noise, sizeof(band_noise)); } static void set_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int update_var, int update_auto_var) { if (dnch->last_noise_floor != dnch->noise_floor) dnch->last_noise_floor = dnch->noise_floor; if (s->track_residual) dnch->last_noise_floor = fmax(dnch->last_noise_floor, dnch->residual_floor); dnch->max_var = s->floor * exp((100.0 + dnch->last_noise_floor) * C); if (update_auto_var) { for (int i = 0; i < NB_PROFILE_BANDS; i++) dnch->noise_band_auto_var[i] = dnch->max_var * exp((process_get_band_noise(s, dnch, i) - 2.0) * C); } if (s->track_residual) { if (update_var || dnch->last_residual_floor != dnch->residual_floor) { update_var = 1; dnch->last_residual_floor = dnch->residual_floor; dnch->last_noise_reduction = fmax(dnch->last_noise_floor - dnch->last_residual_floor + 100., 0); dnch->max_gain = exp(dnch->last_noise_reduction * (0.5 * C)); } } else if (update_var || dnch->noise_reduction != dnch->last_noise_reduction) { update_var = 1; dnch->last_noise_reduction = dnch->noise_reduction; dnch->last_residual_floor = av_clipd(dnch->last_noise_floor - dnch->last_noise_reduction, -80, -20); dnch->max_gain = exp(dnch->last_noise_reduction * (0.5 * C)); } dnch->gain_scale = 1.0 / (dnch->max_gain * dnch->max_gain); if (update_var) { set_band_parameters(s, dnch); for (int i = 0; i < s->bin_count; i++) { dnch->abs_var[i] = fmax(dnch->max_var * dnch->rel_var[i], 1.0); dnch->min_abs_var[i] = dnch->gain_scale * dnch->abs_var[i]; } } } static void reduce_mean(double *band_noise) { double mean = 0.f; for (int i = 0; i < NB_PROFILE_BANDS; i++) mean += band_noise[i]; mean /= NB_PROFILE_BANDS; for (int i = 0; i < NB_PROFILE_BANDS; i++) band_noise[i] -= mean; } static int config_input(AVFilterLink *inlink) { AVFilterContext *ctx = inlink->dst; AudioFFTDeNoiseContext *s = ctx->priv; double wscale, sar, sum, sdiv; int i, j, k, m, n, ret, tx_type; double dscale = 1.; float fscale = 1.f; void *scale; s->format = inlink->format; switch (s->format) { case AV_SAMPLE_FMT_FLTP: s->sample_size = sizeof(float); s->complex_sample_size = sizeof(AVComplexFloat); tx_type = AV_TX_FLOAT_RDFT; scale = &fscale; break; case AV_SAMPLE_FMT_DBLP: s->sample_size = sizeof(double); s->complex_sample_size = sizeof(AVComplexDouble); tx_type = AV_TX_DOUBLE_RDFT; scale = &dscale; break; } s->dnch = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->dnch)); if (!s->dnch) return AVERROR(ENOMEM); s->channels = inlink->ch_layout.nb_channels; s->sample_rate = inlink->sample_rate; s->sample_advance = s->sample_rate / 80; s->window_length = 3 * s->sample_advance; s->fft_length2 = 1 << (32 - ff_clz(s->window_length)); s->fft_length = s->fft_length2; s->buffer_length = s->fft_length * 2; s->bin_count = s->fft_length2 / 2 + 1; s->band_centre[0] = 80; for (i = 1; i < NB_PROFILE_BANDS; i++) { s->band_centre[i] = lrint(1.5 * s->band_centre[i - 1] + 5.0); if (s->band_centre[i] < 1000) { s->band_centre[i] = 10 * (s->band_centre[i] / 10); } else if (s->band_centre[i] < 5000) { s->band_centre[i] = 50 * ((s->band_centre[i] + 20) / 50); } else if (s->band_centre[i] < 15000) { s->band_centre[i] = 100 * ((s->band_centre[i] + 45) / 100); } else { s->band_centre[i] = 1000 * ((s->band_centre[i] + 495) / 1000); } } for (j = 0; j < SOLVE_SIZE; j++) { for (k = 0; k < SOLVE_SIZE; k++) { s->matrix_a[j + k * SOLVE_SIZE] = 0.0; for (m = 0; m < NB_PROFILE_BANDS; m++) s->matrix_a[j + k * SOLVE_SIZE] += pow(m, j + k); } } factor(s->matrix_a, SOLVE_SIZE); i = 0; for (j = 0; j < SOLVE_SIZE; j++) for (k = 0; k < NB_PROFILE_BANDS; k++) s->matrix_b[i++] = pow(k, j); i = 0; for (j = 0; j < NB_PROFILE_BANDS; j++) for (k = 0; k < SOLVE_SIZE; k++) s->matrix_c[i++] = pow(j, k); s->window = av_calloc(s->window_length, sizeof(*s->window)); s->bin2band = av_calloc(s->bin_count, sizeof(*s->bin2band)); if (!s->window || !s->bin2band) return AVERROR(ENOMEM); sdiv = s->band_multiplier; for (i = 0; i < s->bin_count; i++) s->bin2band[i] = lrint(sdiv * freq2bark((0.5 * i * s->sample_rate) / s->fft_length2)); s->number_of_bands = s->bin2band[s->bin_count - 1] + 1; s->band_alpha = av_calloc(s->number_of_bands, sizeof(*s->band_alpha)); s->band_beta = av_calloc(s->number_of_bands, sizeof(*s->band_beta)); if (!s->band_alpha || !s->band_beta) return AVERROR(ENOMEM); for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; switch (s->noise_type) { case WHITE_NOISE: for (i = 0; i < NB_PROFILE_BANDS; i++) dnch->band_noise[i] = 0.; break; case VINYL_NOISE: for (i = 0; i < NB_PROFILE_BANDS; i++) dnch->band_noise[i] = get_band_noise(s, i, 50.0, 500.5, 2125.0); break; case SHELLAC_NOISE: for (i = 0; i < NB_PROFILE_BANDS; i++) dnch->band_noise[i] = get_band_noise(s, i, 1.0, 500.0, 1.0E10); break; case CUSTOM_NOISE: read_custom_noise(s, ch); break; default: return AVERROR_BUG; } reduce_mean(dnch->band_noise); dnch->amt = av_calloc(s->bin_count, sizeof(*dnch->amt)); dnch->band_amt = av_calloc(s->number_of_bands, sizeof(*dnch->band_amt)); dnch->band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->band_excit)); dnch->gain = av_calloc(s->bin_count, sizeof(*dnch->gain)); dnch->smoothed_gain = av_calloc(s->bin_count, sizeof(*dnch->smoothed_gain)); dnch->prior = av_calloc(s->bin_count, sizeof(*dnch->prior)); dnch->prior_band_excit = av_calloc(s->number_of_bands, sizeof(*dnch->prior_band_excit)); dnch->clean_data = av_calloc(s->bin_count, sizeof(*dnch->clean_data)); dnch->noisy_data = av_calloc(s->bin_count, sizeof(*dnch->noisy_data)); dnch->out_samples = av_calloc(s->buffer_length, sizeof(*dnch->out_samples)); dnch->abs_var = av_calloc(s->bin_count, sizeof(*dnch->abs_var)); dnch->rel_var = av_calloc(s->bin_count, sizeof(*dnch->rel_var)); dnch->min_abs_var = av_calloc(s->bin_count, sizeof(*dnch->min_abs_var)); dnch->fft_in = av_calloc(s->fft_length2, s->sample_size); dnch->fft_out = av_calloc(s->fft_length2 + 1, s->complex_sample_size); ret = av_tx_init(&dnch->fft, &dnch->tx_fn, tx_type, 0, s->fft_length2, scale, 0); if (ret < 0) return ret; ret = av_tx_init(&dnch->ifft, &dnch->itx_fn, tx_type, 1, s->fft_length2, scale, 0); if (ret < 0) return ret; dnch->spread_function = av_calloc(s->number_of_bands * s->number_of_bands, sizeof(*dnch->spread_function)); if (!dnch->amt || !dnch->band_amt || !dnch->band_excit || !dnch->gain || !dnch->smoothed_gain || !dnch->prior || !dnch->prior_band_excit || !dnch->clean_data || !dnch->noisy_data || !dnch->out_samples || !dnch->fft_in || !dnch->fft_out || !dnch->abs_var || !dnch->rel_var || !dnch->min_abs_var || !dnch->spread_function || !dnch->fft || !dnch->ifft) return AVERROR(ENOMEM); } for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; double *prior_band_excit = dnch->prior_band_excit; double min, max; double p1, p2; p1 = pow(0.1, 2.5 / sdiv); p2 = pow(0.1, 1.0 / sdiv); j = 0; for (m = 0; m < s->number_of_bands; m++) { for (n = 0; n < s->number_of_bands; n++) { if (n < m) { dnch->spread_function[j++] = pow(p2, m - n); } else if (n > m) { dnch->spread_function[j++] = pow(p1, n - m); } else { dnch->spread_function[j++] = 1.0; } } } for (m = 0; m < s->number_of_bands; m++) { dnch->band_excit[m] = 0.0; prior_band_excit[m] = 0.0; } for (m = 0; m < s->bin_count; m++) dnch->band_excit[s->bin2band[m]] += 1.0; j = 0; for (m = 0; m < s->number_of_bands; m++) { for (n = 0; n < s->number_of_bands; n++) prior_band_excit[m] += dnch->spread_function[j++] * dnch->band_excit[n]; } min = pow(0.1, 2.5); max = pow(0.1, 1.0); for (int i = 0; i < s->number_of_bands; i++) { if (i < lrint(12.0 * sdiv)) { dnch->band_excit[i] = pow(0.1, 1.45 + 0.1 * i / sdiv); } else { dnch->band_excit[i] = pow(0.1, 2.5 - 0.2 * (i / sdiv - 14.0)); } dnch->band_excit[i] = av_clipd(dnch->band_excit[i], min, max); } for (int i = 0; i < s->buffer_length; i++) dnch->out_samples[i] = 0; j = 0; for (int i = 0; i < s->number_of_bands; i++) for (int k = 0; k < s->number_of_bands; k++) dnch->spread_function[j++] *= dnch->band_excit[i] / prior_band_excit[i]; } j = 0; sar = s->sample_advance / s->sample_rate; for (int i = 0; i < s->bin_count; i++) { if ((i == s->fft_length2) || (s->bin2band[i] > j)) { double d6 = (i - 1) * s->sample_rate / s->fft_length; double d7 = fmin(0.008 + 2.2 / d6, 0.03); s->band_alpha[j] = exp(-sar / d7); s->band_beta[j] = 1.0 - s->band_alpha[j]; j = s->bin2band[i]; } } s->winframe = ff_get_audio_buffer(inlink, s->window_length); if (!s->winframe) return AVERROR(ENOMEM); wscale = sqrt(8.0 / (9.0 * s->fft_length)); sum = 0.0; for (int i = 0; i < s->window_length; i++) { double d10 = sin(i * M_PI / s->window_length); d10 *= wscale * d10; s->window[i] = d10; sum += d10 * d10; } s->window_weight = 0.5 * sum; s->floor = (1LL << 48) * exp(-23.025558369790467) * s->window_weight; s->sample_floor = s->floor * exp(4.144600506562284); for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; dnch->noise_reduction = s->noise_reduction; dnch->noise_floor = s->noise_floor; dnch->residual_floor = s->residual_floor; set_parameters(s, dnch, 1, 1); } s->noise_band_edge[0] = FFMIN(s->fft_length2, s->fft_length * get_band_edge(s, 0) / s->sample_rate); i = 0; for (int j = 1; j < NB_PROFILE_BANDS + 1; j++) { s->noise_band_edge[j] = FFMIN(s->fft_length2, s->fft_length * get_band_edge(s, j) / s->sample_rate); if (s->noise_band_edge[j] > lrint(1.1 * s->noise_band_edge[j - 1])) i++; s->noise_band_edge[NB_PROFILE_BANDS + 1] = i; } s->noise_band_count = s->noise_band_edge[NB_PROFILE_BANDS + 1]; return 0; } static void init_sample_noise(DeNoiseChannel *dnch) { for (int i = 0; i < NB_PROFILE_BANDS; i++) { dnch->noise_band_norm[i] = 0.0; dnch->noise_band_avr[i] = 0.0; dnch->noise_band_avi[i] = 0.0; dnch->noise_band_var[i] = 0.0; } } static void sample_noise_block(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, AVFrame *in, int ch) { double *src_dbl = (double *)in->extended_data[ch]; float *src_flt = (float *)in->extended_data[ch]; double mag2, var = 0.0, avr = 0.0, avi = 0.0; AVComplexDouble *fft_out_dbl = dnch->fft_out; AVComplexFloat *fft_out_flt = dnch->fft_out; double *fft_in_dbl = dnch->fft_in; float *fft_in_flt = dnch->fft_in; int edge, j, k, n, edgemax; switch (s->format) { case AV_SAMPLE_FMT_FLTP: for (int i = 0; i < s->window_length; i++) fft_in_flt[i] = s->window[i] * src_flt[i] * (1LL << 23); for (int i = s->window_length; i < s->fft_length2; i++) fft_in_flt[i] = 0.f; break; case AV_SAMPLE_FMT_DBLP: for (int i = 0; i < s->window_length; i++) fft_in_dbl[i] = s->window[i] * src_dbl[i] * (1LL << 23); for (int i = s->window_length; i < s->fft_length2; i++) fft_in_dbl[i] = 0.; break; } dnch->tx_fn(dnch->fft, dnch->fft_out, dnch->fft_in, s->sample_size); edge = s->noise_band_edge[0]; j = edge; k = 0; n = j; edgemax = fmin(s->fft_length2, s->noise_band_edge[NB_PROFILE_BANDS]); for (int i = j; i <= edgemax; i++) { if ((i == j) && (i < edgemax)) { if (j > edge) { dnch->noise_band_norm[k - 1] += j - edge; dnch->noise_band_avr[k - 1] += avr; dnch->noise_band_avi[k - 1] += avi; dnch->noise_band_var[k - 1] += var; } k++; edge = j; j = s->noise_band_edge[k]; if (k == NB_PROFILE_BANDS) { j++; } var = 0.0; avr = 0.0; avi = 0.0; } switch (s->format) { case AV_SAMPLE_FMT_FLTP: avr += fft_out_flt[n].re; avi += fft_out_flt[n].im; mag2 = fft_out_flt[n].re * fft_out_flt[n].re + fft_out_flt[n].im * fft_out_flt[n].im; break; case AV_SAMPLE_FMT_DBLP: avr += fft_out_dbl[n].re; avi += fft_out_dbl[n].im; mag2 = fft_out_dbl[n].re * fft_out_dbl[n].re + fft_out_dbl[n].im * fft_out_dbl[n].im; break; } mag2 = fmax(mag2, s->sample_floor); var += mag2; n++; } dnch->noise_band_norm[k - 1] += j - edge; dnch->noise_band_avr[k - 1] += avr; dnch->noise_band_avi[k - 1] += avi; dnch->noise_band_var[k - 1] += var; } static void finish_sample_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise) { for (int i = 0; i < s->noise_band_count; i++) { dnch->noise_band_avr[i] /= dnch->noise_band_norm[i]; dnch->noise_band_avi[i] /= dnch->noise_band_norm[i]; dnch->noise_band_var[i] /= dnch->noise_band_norm[i]; dnch->noise_band_var[i] -= dnch->noise_band_avr[i] * dnch->noise_band_avr[i] + dnch->noise_band_avi[i] * dnch->noise_band_avi[i]; dnch->noise_band_auto_var[i] = dnch->noise_band_var[i]; sample_noise[i] = 10.0 * log10(dnch->noise_band_var[i] / s->floor) - 100.0; } if (s->noise_band_count < NB_PROFILE_BANDS) { for (int i = s->noise_band_count; i < NB_PROFILE_BANDS; i++) sample_noise[i] = sample_noise[i - 1]; } } static void set_noise_profile(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise) { double new_band_noise[NB_PROFILE_BANDS]; double temp[NB_PROFILE_BANDS]; double sum = 0.0; for (int m = 0; m < NB_PROFILE_BANDS; m++) temp[m] = sample_noise[m]; for (int m = 0, i = 0; m < SOLVE_SIZE; m++) { sum = 0.0; for (int n = 0; n < NB_PROFILE_BANDS; n++) sum += s->matrix_b[i++] * temp[n]; s->vector_b[m] = sum; } solve(s->matrix_a, s->vector_b, SOLVE_SIZE); for (int m = 0, i = 0; m < NB_PROFILE_BANDS; m++) { sum = 0.0; for (int n = 0; n < SOLVE_SIZE; n++) sum += s->matrix_c[i++] * s->vector_b[n]; temp[m] = sum; } reduce_mean(temp); av_log(s, AV_LOG_INFO, "bn="); for (int m = 0; m < NB_PROFILE_BANDS; m++) { new_band_noise[m] = temp[m]; new_band_noise[m] = av_clipd(new_band_noise[m], -24.0, 24.0); av_log(s, AV_LOG_INFO, "%f ", new_band_noise[m]); } av_log(s, AV_LOG_INFO, "\n"); memcpy(dnch->band_noise, new_band_noise, sizeof(new_band_noise)); } static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) { AudioFFTDeNoiseContext *s = ctx->priv; AVFrame *in = arg; const int start = (in->ch_layout.nb_channels * jobnr) / nb_jobs; const int end = (in->ch_layout.nb_channels * (jobnr+1)) / nb_jobs; const int window_length = s->window_length; const double *window = s->window; for (int ch = start; ch < end; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; const double *src_dbl = (const double *)in->extended_data[ch]; const float *src_flt = (const float *)in->extended_data[ch]; double *dst = dnch->out_samples; double *fft_in_dbl = dnch->fft_in; float *fft_in_flt = dnch->fft_in; switch (s->format) { case AV_SAMPLE_FMT_FLTP: for (int m = 0; m < window_length; m++) fft_in_flt[m] = window[m] * src_flt[m] * (1LL << 23); for (int m = window_length; m < s->fft_length2; m++) fft_in_flt[m] = 0.f; break; case AV_SAMPLE_FMT_DBLP: for (int m = 0; m < window_length; m++) fft_in_dbl[m] = window[m] * src_dbl[m] * (1LL << 23); for (int m = window_length; m < s->fft_length2; m++) fft_in_dbl[m] = 0.; break; } dnch->tx_fn(dnch->fft, dnch->fft_out, dnch->fft_in, s->sample_size); process_frame(ctx, s, dnch, dnch->prior, dnch->prior_band_excit, s->track_noise); dnch->itx_fn(dnch->ifft, dnch->fft_in, dnch->fft_out, s->complex_sample_size); switch (s->format) { case AV_SAMPLE_FMT_FLTP: for (int m = 0; m < window_length; m++) dst[m] += s->window[m] * fft_in_flt[m] / (1LL << 23); break; case AV_SAMPLE_FMT_DBLP: for (int m = 0; m < window_length; m++) dst[m] += s->window[m] * fft_in_dbl[m] / (1LL << 23); break; } } return 0; } static int output_frame(AVFilterLink *inlink, AVFrame *in) { AVFilterContext *ctx = inlink->dst; AVFilterLink *outlink = ctx->outputs[0]; AudioFFTDeNoiseContext *s = ctx->priv; const int output_mode = ctx->is_disabled ? IN_MODE : s->output_mode; const int offset = s->window_length - s->sample_advance; AVFrame *out; for (int ch = 0; ch < s->channels; ch++) { uint8_t *src = (uint8_t *)s->winframe->extended_data[ch]; memmove(src, src + s->sample_advance * s->sample_size, offset * s->sample_size); memcpy(src + offset * s->sample_size, in->extended_data[ch], in->nb_samples * s->sample_size); memset(src + s->sample_size * (offset + in->nb_samples), 0, (s->sample_advance - in->nb_samples) * s->sample_size); } if (s->track_noise) { double average = 0.0, min = DBL_MAX, max = -DBL_MAX; for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; average += dnch->noise_floor; max = fmax(max, dnch->noise_floor); min = fmin(min, dnch->noise_floor); } average /= inlink->ch_layout.nb_channels; for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; switch (s->noise_floor_link) { case MIN_LINK: dnch->noise_floor = min; break; case MAX_LINK: dnch->noise_floor = max; break; case AVERAGE_LINK: dnch->noise_floor = average; break; case NONE_LINK: default: break; } if (dnch->noise_floor != dnch->last_noise_floor) set_parameters(s, dnch, 1, 0); } } if (s->sample_noise_mode == SAMPLE_START) { for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; init_sample_noise(dnch); } s->sample_noise_mode = SAMPLE_NONE; s->sample_noise = 1; s->sample_noise_blocks = 0; } if (s->sample_noise) { for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; sample_noise_block(s, dnch, s->winframe, ch); } s->sample_noise_blocks++; } if (s->sample_noise_mode == SAMPLE_STOP) { for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; double sample_noise[NB_PROFILE_BANDS]; if (s->sample_noise_blocks <= 0) break; finish_sample_noise(s, dnch, sample_noise); set_noise_profile(s, dnch, sample_noise); set_parameters(s, dnch, 1, 1); } s->sample_noise = 0; s->sample_noise_blocks = 0; s->sample_noise_mode = SAMPLE_NONE; } ff_filter_execute(ctx, filter_channel, s->winframe, NULL, FFMIN(outlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx))); if (av_frame_is_writable(in)) { out = in; } else { out = ff_get_audio_buffer(outlink, in->nb_samples); if (!out) { av_frame_free(&in); return AVERROR(ENOMEM); } av_frame_copy_props(out, in); } for (int ch = 0; ch < inlink->ch_layout.nb_channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; double *src = dnch->out_samples; const double *orig_dbl = (const double *)s->winframe->extended_data[ch]; const float *orig_flt = (const float *)s->winframe->extended_data[ch]; double *dst_dbl = (double *)out->extended_data[ch]; float *dst_flt = (float *)out->extended_data[ch]; switch (output_mode) { case IN_MODE: switch (s->format) { case AV_SAMPLE_FMT_FLTP: for (int m = 0; m < out->nb_samples; m++) dst_flt[m] = orig_flt[m]; break; case AV_SAMPLE_FMT_DBLP: for (int m = 0; m < out->nb_samples; m++) dst_dbl[m] = orig_dbl[m]; break; } break; case OUT_MODE: switch (s->format) { case AV_SAMPLE_FMT_FLTP: for (int m = 0; m < out->nb_samples; m++) dst_flt[m] = src[m]; break; case AV_SAMPLE_FMT_DBLP: for (int m = 0; m < out->nb_samples; m++) dst_dbl[m] = src[m]; break; } break; case NOISE_MODE: switch (s->format) { case AV_SAMPLE_FMT_FLTP: for (int m = 0; m < out->nb_samples; m++) dst_flt[m] = orig_flt[m] - src[m]; break; case AV_SAMPLE_FMT_DBLP: for (int m = 0; m < out->nb_samples; m++) dst_dbl[m] = orig_dbl[m] - src[m]; break; } break; default: if (in != out) av_frame_free(&in); av_frame_free(&out); return AVERROR_BUG; } memmove(src, src + s->sample_advance, (s->window_length - s->sample_advance) * sizeof(*src)); memset(src + (s->window_length - s->sample_advance), 0, s->sample_advance * sizeof(*src)); } if (out != in) av_frame_free(&in); return ff_filter_frame(outlink, out); } static int activate(AVFilterContext *ctx) { AVFilterLink *inlink = ctx->inputs[0]; AVFilterLink *outlink = ctx->outputs[0]; AudioFFTDeNoiseContext *s = ctx->priv; AVFrame *in = NULL; int ret; FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink); ret = ff_inlink_consume_samples(inlink, s->sample_advance, s->sample_advance, &in); if (ret < 0) return ret; if (ret > 0) return output_frame(inlink, in); if (ff_inlink_queued_samples(inlink) >= s->sample_advance) { ff_filter_set_ready(ctx, 10); return 0; } FF_FILTER_FORWARD_STATUS(inlink, outlink); FF_FILTER_FORWARD_WANTED(outlink, inlink); return FFERROR_NOT_READY; } static av_cold void uninit(AVFilterContext *ctx) { AudioFFTDeNoiseContext *s = ctx->priv; av_freep(&s->window); av_freep(&s->bin2band); av_freep(&s->band_alpha); av_freep(&s->band_beta); av_frame_free(&s->winframe); if (s->dnch) { for (int ch = 0; ch < s->channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; av_freep(&dnch->amt); av_freep(&dnch->band_amt); av_freep(&dnch->band_excit); av_freep(&dnch->gain); av_freep(&dnch->smoothed_gain); av_freep(&dnch->prior); av_freep(&dnch->prior_band_excit); av_freep(&dnch->clean_data); av_freep(&dnch->noisy_data); av_freep(&dnch->out_samples); av_freep(&dnch->spread_function); av_freep(&dnch->abs_var); av_freep(&dnch->rel_var); av_freep(&dnch->min_abs_var); av_freep(&dnch->fft_in); av_freep(&dnch->fft_out); av_tx_uninit(&dnch->fft); av_tx_uninit(&dnch->ifft); } av_freep(&s->dnch); } } static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags) { AudioFFTDeNoiseContext *s = ctx->priv; int ret = 0; ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags); if (ret < 0) return ret; if (!strcmp(cmd, "sample_noise") || !strcmp(cmd, "sn")) return 0; for (int ch = 0; ch < s->channels; ch++) { DeNoiseChannel *dnch = &s->dnch[ch]; dnch->noise_reduction = s->noise_reduction; dnch->noise_floor = s->noise_floor; dnch->residual_floor = s->residual_floor; set_parameters(s, dnch, 1, 1); } return 0; } static const AVFilterPad inputs[] = { { .name = "default", .type = AVMEDIA_TYPE_AUDIO, .config_props = config_input, }, }; static const AVFilterPad outputs[] = { { .name = "default", .type = AVMEDIA_TYPE_AUDIO, }, }; const AVFilter ff_af_afftdn = { .name = "afftdn", .description = NULL_IF_CONFIG_SMALL("Denoise audio samples using FFT."), .priv_size = sizeof(AudioFFTDeNoiseContext), .priv_class = &afftdn_class, .activate = activate, .uninit = uninit, FILTER_INPUTS(inputs), FILTER_OUTPUTS(outputs), FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP), .process_command = process_command, .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS, };