Go to the documentation of this file.
33 #define C (M_LN10 * 0.1)
34 #define SOLVE_SIZE (5)
35 #define NB_PROFILE_BANDS (15)
163 #define OFFSET(x) offsetof(AudioFFTDeNoiseContext, x)
164 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
165 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
230 d1 =
a /
s->band_centre[band];
232 d2 =
b /
s->band_centre[band];
234 d3 =
s->band_centre[band] /
c;
237 return -d1 + d2 - d3;
242 for (
int i = 0;
i <
size - 1;
i++) {
243 for (
int j =
i + 1; j <
size; j++) {
247 for (
int k =
i + 1; k <
size; k++) {
256 for (
int i = 0;
i <
size - 1;
i++) {
257 for (
int j =
i + 1; j <
size; j++) {
259 vector[j] -= d * vector[
i];
265 for (
int i =
size - 2;
i >= 0;
i--) {
266 double d = vector[
i];
267 for (
int j =
i + 1; j <
size; j++)
277 double product, sum,
f;
287 s->vector_b[j] = sum;
296 sum += product *
s->vector_b[j];
306 return (
b *
a - 1.0) / (
b +
a - 2.0);
308 return (
b *
a - 2.0 *
a + 1.0) / (
b -
a);
313 double floor,
int len,
double *rnum,
double *rden)
315 double num = 0., den = 0.;
318 for (
int n = 0; n <
len; n++) {
319 const double v = spectral[n];
344 for (
int n = 0; n <
size; n++) {
345 const double p =
S[n] -
mean;
355 double *prior,
double *prior_band_excit,
int track_noise)
359 const double *abs_var = dnch->
abs_var;
361 const double rratio = 1. - ratio;
362 const int *bin2band =
s->bin2band;
369 double *gain = dnch->
gain;
371 for (
int i = 0;
i <
s->bin_count;
i++) {
372 double sqr_new_gain, new_gain,
power, mag, mag_abs_var, new_mag_abs_var;
376 noisy_data[
i] = mag =
hypot(fft_data_flt[
i].re, fft_data_flt[
i].im);
379 noisy_data[
i] = mag =
hypot(fft_data_dbl[
i].re, fft_data_dbl[
i].im);
386 mag_abs_var =
power / abs_var[
i];
387 new_mag_abs_var = ratio * prior[
i] + rratio *
fmax(mag_abs_var - 1.0, 0.0);
388 new_gain = new_mag_abs_var / (1.0 + new_mag_abs_var);
389 sqr_new_gain = new_gain * new_gain;
390 prior[
i] = mag_abs_var * sqr_new_gain;
396 double flatness, num, den;
400 flatness = num / den;
401 if (flatness > 0.8) {
403 const double new_floor =
av_clipd(10.0 * log10(den) - 100.0 +
offset, -90., -20.);
410 for (
int i = 0;
i <
s->number_of_bands;
i++) {
415 for (
int i = 0;
i <
s->bin_count;
i++)
418 for (
int i = 0;
i <
s->number_of_bands;
i++) {
419 band_excit[
i] =
fmax(band_excit[
i],
420 s->band_alpha[
i] * band_excit[
i] +
421 s->band_beta[
i] * prior_band_excit[
i]);
422 prior_band_excit[
i] = band_excit[
i];
425 for (
int j = 0,
i = 0; j <
s->number_of_bands; j++) {
426 for (
int k = 0; k <
s->number_of_bands; k++) {
431 for (
int i = 0;
i <
s->bin_count;
i++)
432 dnch->
amt[
i] = band_amt[bin2band[
i]];
434 for (
int i = 0;
i <
s->bin_count;
i++) {
435 if (dnch->
amt[
i] > abs_var[
i]) {
438 const double limit = sqrt(abs_var[
i] / dnch->
amt[
i]);
446 memcpy(smoothed_gain, gain,
s->bin_count *
sizeof(*smoothed_gain));
447 if (
s->gain_smooth > 0) {
448 const int r =
s->gain_smooth;
450 for (
int i =
r;
i <
s->bin_count -
r;
i++) {
451 const double gc = gain[
i];
452 double num = 0., den = 0.;
454 for (
int j = -
r; j <=
r; j++) {
455 const double g = gain[
i + j];
456 const double d = 1. -
fabs(
g - gc);
462 smoothed_gain[
i] = num / den;
468 for (
int i = 0;
i <
s->bin_count;
i++) {
469 const float new_gain = smoothed_gain[
i];
471 fft_data_flt[
i].
re *= new_gain;
472 fft_data_flt[
i].
im *= new_gain;
476 for (
int i = 0;
i <
s->bin_count;
i++) {
477 const double new_gain = smoothed_gain[
i];
479 fft_data_dbl[
i].
re *= new_gain;
480 fft_data_dbl[
i].
im *= new_gain;
488 double d = x / 7500.0;
490 return 13.0 * atan(7.6
E-4 * x) + 3.5 * atan(d * d);
496 return lrint(
s->band_centre[0] / 1.5);
498 return s->band_centre[band];
508 i =
lrint(
s->band_centre[band] / 1.224745);
511 return FFMIN(
i,
s->sample_rate / 2);
517 double band_noise, d2, d3, d4, d5;
518 int i = 0, j = 0, k = 0;
522 for (
int m = j; m <
s->bin_count; m++) {
537 dnch->
rel_var[m] =
exp((d5 * d3 + band_noise * d4) *
C);
547 char *custom_noise_str, *p, *
arg, *saveptr =
NULL;
551 if (!
s->band_noise_str)
554 custom_noise_str = p =
av_strdup(
s->band_noise_str);
576 memcpy(dnch->
band_noise, band_noise,
sizeof(band_noise));
584 if (
s->track_residual)
588 if (update_auto_var) {
593 if (
s->track_residual) {
612 for (
int i = 0;
i <
s->bin_count;
i++) {
624 mean += band_noise[
i];
628 band_noise[
i] -=
mean;
635 double wscale, sar, sum, sdiv;
636 int i, j, k, m, n,
ret, tx_type;
645 s->sample_size =
sizeof(
float);
651 s->sample_size =
sizeof(
double);
662 s->channels =
inlink->ch_layout.nb_channels;
663 s->sample_rate =
inlink->sample_rate;
664 s->sample_advance =
s->sample_rate / 80;
665 s->window_length = 3 *
s->sample_advance;
666 s->fft_length2 = 1 << (32 -
ff_clz(
s->window_length));
667 s->fft_length =
s->fft_length2;
668 s->buffer_length =
s->fft_length * 2;
669 s->bin_count =
s->fft_length2 / 2 + 1;
671 s->band_centre[0] = 80;
673 s->band_centre[
i] =
lrint(1.5 *
s->band_centre[
i - 1] + 5.0);
674 if (
s->band_centre[
i] < 1000) {
675 s->band_centre[
i] = 10 * (
s->band_centre[
i] / 10);
676 }
else if (
s->band_centre[
i] < 5000) {
677 s->band_centre[
i] = 50 * ((
s->band_centre[
i] + 20) / 50);
678 }
else if (
s->band_centre[
i] < 15000) {
679 s->band_centre[
i] = 100 * ((
s->band_centre[
i] + 45) / 100);
681 s->band_centre[
i] = 1000 * ((
s->band_centre[
i] + 495) / 1000);
698 s->matrix_b[
i++] = pow(k, j);
703 s->matrix_c[
i++] = pow(j, k);
705 s->window =
av_calloc(
s->window_length,
sizeof(*
s->window));
706 s->bin2band =
av_calloc(
s->bin_count,
sizeof(*
s->bin2band));
707 if (!
s->window || !
s->bin2band)
710 sdiv =
s->band_multiplier;
711 for (
i = 0;
i <
s->bin_count;
i++)
714 s->number_of_bands =
s->bin2band[
s->bin_count - 1] + 1;
716 s->band_alpha =
av_calloc(
s->number_of_bands,
sizeof(*
s->band_alpha));
717 s->band_beta =
av_calloc(
s->number_of_bands,
sizeof(*
s->band_beta));
718 if (!
s->band_alpha || !
s->band_beta)
721 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
724 switch (
s->noise_type) {
791 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
797 p1 = pow(0.1, 2.5 / sdiv);
798 p2 = pow(0.1, 1.0 / sdiv);
800 for (m = 0; m <
s->number_of_bands; m++) {
801 for (n = 0; n <
s->number_of_bands; n++) {
812 for (m = 0; m <
s->number_of_bands; m++) {
814 prior_band_excit[m] = 0.0;
817 for (m = 0; m <
s->bin_count; m++)
821 for (m = 0; m <
s->number_of_bands; m++) {
822 for (n = 0; n <
s->number_of_bands; n++)
828 for (
int i = 0;
i <
s->number_of_bands;
i++) {
829 if (
i <
lrint(12.0 * sdiv)) {
832 dnch->
band_excit[
i] = pow(0.1, 2.5 - 0.2 * (
i / sdiv - 14.0));
837 for (
int i = 0;
i <
s->buffer_length;
i++)
841 for (
int i = 0;
i <
s->number_of_bands;
i++)
842 for (
int k = 0; k <
s->number_of_bands; k++)
847 sar =
s->sample_advance /
s->sample_rate;
848 for (
int i = 0;
i <
s->bin_count;
i++) {
849 if ((
i ==
s->fft_length2) || (
s->bin2band[
i] > j)) {
850 double d6 = (
i - 1) *
s->sample_rate /
s->fft_length;
851 double d7 =
fmin(0.008 + 2.2 / d6, 0.03);
852 s->band_alpha[j] =
exp(-sar / d7);
853 s->band_beta[j] = 1.0 -
s->band_alpha[j];
862 wscale = sqrt(8.0 / (9.0 *
s->fft_length));
864 for (
int i = 0;
i <
s->window_length;
i++) {
865 double d10 = sin(
i *
M_PI /
s->window_length);
871 s->window_weight = 0.5 * sum;
872 s->floor = (1LL << 48) *
exp(-23.025558369790467) *
s->window_weight;
873 s->sample_floor =
s->floor *
exp(4.144600506562284);
875 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
889 if (
s->noise_band_edge[j] >
lrint(1.1 *
s->noise_band_edge[j - 1]))
914 double mag2, var = 0.0, avr = 0.0, avi = 0.0;
917 double *fft_in_dbl = dnch->
fft_in;
918 float *fft_in_flt = dnch->
fft_in;
919 int edge, j, k, n, edgemax;
923 for (
int i = 0;
i <
s->window_length;
i++)
924 fft_in_flt[
i] =
s->window[
i] * src_flt[
i] * (1LL << 23);
926 for (
int i =
s->window_length; i < s->fft_length2;
i++)
930 for (
int i = 0;
i <
s->window_length;
i++)
931 fft_in_dbl[
i] =
s->window[
i] * src_dbl[
i] * (1LL << 23);
933 for (
int i =
s->window_length; i < s->fft_length2;
i++)
940 edge =
s->noise_band_edge[0];
945 for (
int i = j;
i <= edgemax;
i++) {
946 if ((
i == j) && (
i < edgemax)) {
955 j =
s->noise_band_edge[k];
966 avr += fft_out_flt[n].
re;
967 avi += fft_out_flt[n].
im;
968 mag2 = fft_out_flt[n].
re * fft_out_flt[n].
re +
969 fft_out_flt[n].
im * fft_out_flt[n].
im;
972 avr += fft_out_dbl[n].
re;
973 avi += fft_out_dbl[n].
im;
974 mag2 = fft_out_dbl[n].
re * fft_out_dbl[n].
re +
975 fft_out_dbl[n].
im * fft_out_dbl[n].
im;
981 mag2 =
fmax(mag2,
s->sample_floor);
995 double *sample_noise)
997 for (
int i = 0;
i <
s->noise_band_count;
i++) {
1008 sample_noise[
i] = sample_noise[
i - 1];
1014 double *sample_noise)
1021 temp[m] = sample_noise[m];
1026 sum +=
s->matrix_b[
i++] *
temp[n];
1027 s->vector_b[m] = sum;
1033 sum +=
s->matrix_c[
i++] *
s->vector_b[n];
1041 new_band_noise[m] =
temp[m];
1042 new_band_noise[m] =
av_clipd(new_band_noise[m], -24.0, 24.0);
1046 memcpy(dnch->
band_noise, new_band_noise,
sizeof(new_band_noise));
1055 const int window_length =
s->window_length;
1056 const double *
window =
s->window;
1058 for (
int ch = start; ch < end; ch++) {
1060 const double *src_dbl = (
const double *)in->
extended_data[ch];
1061 const float *src_flt = (
const float *)in->
extended_data[ch];
1063 double *fft_in_dbl = dnch->
fft_in;
1064 float *fft_in_flt = dnch->
fft_in;
1066 switch (
s->format) {
1068 for (
int m = 0; m < window_length; m++)
1069 fft_in_flt[m] =
window[m] * src_flt[m] * (1LL << 23);
1071 for (
int m = window_length; m <
s->fft_length2; m++)
1072 fft_in_flt[m] = 0.
f;
1075 for (
int m = 0; m < window_length; m++)
1076 fft_in_dbl[m] =
window[m] * src_dbl[m] * (1LL << 23);
1078 for (
int m = window_length; m <
s->fft_length2; m++)
1092 switch (
s->format) {
1094 for (
int m = 0; m < window_length; m++)
1095 dst[m] +=
s->window[m] * fft_in_flt[m] / (1LL << 23);
1098 for (
int m = 0; m < window_length; m++)
1099 dst[m] +=
s->window[m] * fft_in_dbl[m] / (1LL << 23);
1112 const int output_mode =
ctx->is_disabled ?
IN_MODE :
s->output_mode;
1113 const int offset =
s->window_length -
s->sample_advance;
1116 for (
int ch = 0; ch <
s->channels; ch++) {
1117 uint8_t *
src = (uint8_t *)
s->winframe->extended_data[ch];
1119 memmove(
src,
src +
s->sample_advance *
s->sample_size,
1124 (
s->sample_advance - in->
nb_samples) *
s->sample_size);
1127 if (
s->track_noise) {
1128 double average = 0.0,
min = DBL_MAX,
max = -DBL_MAX;
1130 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
1138 average /=
inlink->ch_layout.nb_channels;
1140 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
1143 switch (
s->noise_floor_link) {
1158 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
1164 s->sample_noise = 1;
1165 s->sample_noise_blocks = 0;
1168 if (
s->sample_noise) {
1169 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
1174 s->sample_noise_blocks++;
1178 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
1182 if (
s->sample_noise_blocks <= 0)
1188 s->sample_noise = 0;
1189 s->sample_noise_blocks = 0;
1208 for (
int ch = 0; ch <
inlink->ch_layout.nb_channels; ch++) {
1211 const double *orig_dbl = (
const double *)
s->winframe->extended_data[ch];
1212 const float *orig_flt = (
const float *)
s->winframe->extended_data[ch];
1213 double *dst_dbl = (
double *)
out->extended_data[ch];
1214 float *dst_flt = (
float *)
out->extended_data[ch];
1216 switch (output_mode) {
1218 switch (
s->format) {
1220 for (
int m = 0; m <
out->nb_samples; m++)
1221 dst_flt[m] = orig_flt[m];
1224 for (
int m = 0; m <
out->nb_samples; m++)
1225 dst_dbl[m] = orig_dbl[m];
1230 switch (
s->format) {
1232 for (
int m = 0; m <
out->nb_samples; m++)
1233 dst_flt[m] =
src[m];
1236 for (
int m = 0; m <
out->nb_samples; m++)
1237 dst_dbl[m] =
src[m];
1242 switch (
s->format) {
1244 for (
int m = 0; m <
out->nb_samples; m++)
1245 dst_flt[m] = orig_flt[m] -
src[m];
1248 for (
int m = 0; m <
out->nb_samples; m++)
1249 dst_dbl[m] = orig_dbl[m] -
src[m];
1260 memmove(
src,
src +
s->sample_advance, (
s->window_length -
s->sample_advance) *
sizeof(*
src));
1261 memset(
src + (
s->window_length -
s->sample_advance), 0,
s->sample_advance *
sizeof(*
src));
1307 for (
int ch = 0; ch <
s->channels; ch++) {
1333 char *res,
int res_len,
int flags)
1342 if (!strcmp(cmd,
"sample_noise") || !strcmp(cmd,
"sn"))
1345 for (
int ch = 0; ch <
s->channels; ch++) {
1370 .priv_class = &afftdn_class,
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
@ AV_SAMPLE_FMT_FLTP
float, planar
double noise_band_auto_var[NB_PROFILE_BANDS]
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
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static int activate(AVFilterContext *ctx)
static const AVFilterPad inputs[]
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
static void solve(double *matrix, double *vector, int size)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define FILTER_INPUTS(array)
This structure describes decoded (raw) audio or video data.
static void process_frame(AVFilterContext *ctx, AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *prior, double *prior_band_excit, int track_noise)
static void sample_noise_block(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, AVFrame *in, int ch)
const char * name
Filter name.
int nb_channels
Number of channels in this layout.
A link between two filters.
double vector_b[SOLVE_SIZE]
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Link properties exposed to filter code, but not external callers.
double noise_band_norm[NB_PROFILE_BANDS]
static void factor(double *array, int size)
double noise_band_avr[NB_PROFILE_BANDS]
static int config_input(AVFilterLink *inlink)
static SDL_Window * window
size_t complex_sample_size
static double freq2bark(double x)
static int noise(AVBSFContext *ctx, AVPacket *pkt)
double band_noise[NB_PROFILE_BANDS]
AVChannelLayout ch_layout
Channel layout of the audio data.
A filter pad used for either input or output.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FILTER_SAMPLEFMTS(...)
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
double last_noise_reduction
static const AVOption afftdn_options[]
double matrix_a[SOLVE_SIZE *SOLVE_SIZE]
static __device__ float floor(float a)
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().
double noise_band_sample[NB_PROFILE_BANDS]
#define FILTER_OUTPUTS(array)
static int get_band_edge(AudioFFTDeNoiseContext *s, int band)
int av_sscanf(const char *string, const char *format,...)
See libc sscanf manual for more information.
Describe the class of an AVClass context structure.
static __device__ float fabs(float a)
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
double matrix_b[SOLVE_SIZE *NB_PROFILE_BANDS]
static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
static void set_band_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch)
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
static FilterLink * ff_filter_link(AVFilterLink *link)
static void init_sample_noise(DeNoiseChannel *dnch)
static void read_custom_noise(AudioFFTDeNoiseContext *s, int ch)
double last_residual_floor
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
static int output_frame(AVFilterLink *inlink, AVFrame *in)
double fmin(double, double)
static av_const double hypot(double x, double y)
double matrix_c[SOLVE_SIZE *NB_PROFILE_BANDS]
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
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.
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
static void finish_sample_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
FF_FILTER_FORWARD_WANTED(outlink, inlink)
static double limit_gain(double a, double b)
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
#define AV_LOG_INFO
Standard information.
static av_cold void uninit(AVFilterContext *ctx)
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
int nb_samples
number of audio samples (per channel) described by this frame
#define i(width, name, range_min, range_max)
double noise_band_avi[NB_PROFILE_BANDS]
uint8_t ** extended_data
pointers to the data planes/channels.
double * prior_band_excit
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
const char * name
Pad name.
int ff_inlink_queued_samples(AVFilterLink *link)
void * av_calloc(size_t nmemb, size_t size)
static double limit(double x)
static int array[MAX_W *MAX_W]
static double get_band_noise(AudioFFTDeNoiseContext *s, int band, double a, double b, double c)
@ AV_TX_FLOAT_RDFT
Real to complex and complex to real DFTs.
double fmax(double, double)
static float power(float r, float g, float b, float max)
static void set_parameters(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int update_var, int update_auto_var)
static double process_get_band_noise(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, int band)
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static void spectral_flatness(AudioFFTDeNoiseContext *s, const double *const spectral, double floor, int len, double *rnum, double *rden)
@ AV_OPT_TYPE_INT
Underlying C type is int.
@ AV_SAMPLE_FMT_DBLP
double, planar
static float mean(const float *input, int size)
double noise_band_var[NB_PROFILE_BANDS]
int band_centre[NB_PROFILE_BANDS]
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
char * av_strdup(const char *s)
Duplicate a string.
AVFILTER_DEFINE_CLASS(afftdn)
AVChannelLayout ch_layout
channel layout of current buffer (see libavutil/channel_layout.h)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
FF_FILTER_FORWARD_STATUS(inlink, outlink)
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
static double floor_offset(const double *S, int size, double mean)
int noise_band_edge[NB_PROFILE_BANDS+2]
static void reduce_mean(double *band_noise)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
#define flags(name, subs,...)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static void set_noise_profile(AudioFFTDeNoiseContext *s, DeNoiseChannel *dnch, double *sample_noise)
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
static int get_band_centre(AudioFFTDeNoiseContext *s, int band)
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
const AVFilter ff_af_afftdn
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.