FFmpeg
af_afwtdn.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2020 Paul B Mahol
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/avassert.h"
24 #include "libavutil/opt.h"
25 #include "avfilter.h"
26 #include "audio.h"
27 #include "filters.h"
28 
36  BL3,
38 };
39 
40 /*
41  * All wavelets coefficients are taken from: http://wavelets.pybytes.com/
42  */
43 
44 static const double bl3_lp[42] = {
45  0.000146098, -0.000232304, -0.000285414, 0.000462093, 0.000559952,
46  -0.000927187, -0.001103748, 0.00188212, 0.002186714, -0.003882426,
47  -0.00435384, 0.008201477, 0.008685294, -0.017982291, -0.017176331,
48  0.042068328, 0.032080869, -0.110036987, -0.050201753, 0.433923147,
49  0.766130398, 0.433923147, -0.050201753, -0.110036987, 0.032080869,
50  0.042068328, -0.017176331, -0.017982291, 0.008685294, 0.008201477,
51  -0.00435384, -0.003882426, 0.002186714, 0.00188212, -0.001103748,
52  -0.000927187, 0.000559952, 0.000462093, -0.000285414, -0.000232304,
53  0.000146098, 0.0,
54 };
55 
56 static const double bl3_hp[42] = {
57  0.0, 0.000146098, 0.000232304, -0.000285414, -0.000462093, 0.000559952,
58  0.000927187, -0.001103748, -0.00188212, 0.002186714, 0.003882426,
59  -0.00435384, -0.008201477, 0.008685294, 0.017982291, -0.017176331,
60  -0.042068328, 0.032080869, 0.110036987, -0.050201753, -0.433923147,
61  0.766130398, -0.433923147, -0.050201753, 0.110036987, 0.032080869,
62  -0.042068328, -0.017176331, 0.017982291, 0.008685294, -0.008201477,
63  -0.00435384, 0.003882426, 0.002186714, -0.00188212, -0.001103748,
64  0.000927187, 0.000559952, -0.000462093, -0.000285414, 0.000232304,
65  0.000146098,
66 };
67 
68 static const double bl3_ilp[42] = {
69  0.0, 0.000146098, -0.000232304, -0.000285414, 0.000462093, 0.000559952,
70  -0.000927187, -0.001103748, 0.00188212, 0.002186714, -0.003882426,
71  -0.00435384, 0.008201477, 0.008685294, -0.017982291, -0.017176331,
72  0.042068328, 0.032080869, -0.110036987, -0.050201753, 0.433923147,
73  0.766130398, 0.433923147, -0.050201753, -0.110036987, 0.032080869,
74  0.042068328, -0.017176331, -0.017982291, 0.008685294, 0.008201477,
75  -0.00435384, -0.003882426, 0.002186714, 0.00188212, -0.001103748,
76  -0.000927187, 0.000559952, 0.000462093, -0.000285414, -0.000232304,
77  0.000146098,
78 };
79 
80 static const double bl3_ihp[42] = {
81  0.000146098, 0.000232304, -0.000285414, -0.000462093, 0.000559952,
82  0.000927187, -0.001103748, -0.00188212, 0.002186714, 0.003882426,
83  -0.00435384, -0.008201477, 0.008685294, 0.017982291, -0.017176331,
84  -0.042068328, 0.032080869, 0.110036987, -0.050201753, -0.433923147,
85  0.766130398, -0.433923147, -0.050201753, 0.110036987, 0.032080869,
86  -0.042068328, -0.017176331, 0.017982291, 0.008685294, -0.008201477,
87  -0.00435384, 0.003882426, 0.002186714, -0.00188212, -0.001103748,
88  0.000927187, 0.000559952, -0.000462093, -0.000285414, 0.000232304,
89  0.000146098,
90 };
91 
92 static const double sym10_lp[20] = {
93  0.0007701598091144901, 9.563267072289475e-05,
94  -0.008641299277022422, -0.0014653825813050513,
95  0.0459272392310922, 0.011609893903711381,
96  -0.15949427888491757, -0.07088053578324385,
97  0.47169066693843925, 0.7695100370211071,
98  0.38382676106708546, -0.03553674047381755,
99  -0.0319900568824278, 0.04999497207737669,
100  0.005764912033581909, -0.02035493981231129,
101  -0.0008043589320165449, 0.004593173585311828,
102  5.7036083618494284e-05, -0.0004593294210046588,
103 };
104 
105 static const double sym10_hp[20] = {
106  0.0004593294210046588, 5.7036083618494284e-05,
107  -0.004593173585311828, -0.0008043589320165449,
108  0.02035493981231129, 0.005764912033581909,
109  -0.04999497207737669, -0.0319900568824278,
110  0.03553674047381755, 0.38382676106708546,
111  -0.7695100370211071, 0.47169066693843925,
112  0.07088053578324385, -0.15949427888491757,
113  -0.011609893903711381, 0.0459272392310922,
114  0.0014653825813050513, -0.008641299277022422,
115  -9.563267072289475e-05, 0.0007701598091144901,
116 };
117 
118 static const double sym10_ilp[20] = {
119  -0.0004593294210046588, 5.7036083618494284e-05,
120  0.004593173585311828, -0.0008043589320165449,
121  -0.02035493981231129, 0.005764912033581909,
122  0.04999497207737669, -0.0319900568824278,
123  -0.03553674047381755, 0.38382676106708546,
124  0.7695100370211071, 0.47169066693843925,
125  -0.07088053578324385, -0.15949427888491757,
126  0.011609893903711381, 0.0459272392310922,
127  -0.0014653825813050513, -0.008641299277022422,
128  9.563267072289475e-05, 0.0007701598091144901,
129 };
130 
131 static const double sym10_ihp[20] = {
132  0.0007701598091144901, -9.563267072289475e-05,
133  -0.008641299277022422, 0.0014653825813050513,
134  0.0459272392310922, -0.011609893903711381,
135  -0.15949427888491757, 0.07088053578324385,
136  0.47169066693843925, -0.7695100370211071,
137  0.38382676106708546, 0.03553674047381755,
138  -0.0319900568824278, -0.04999497207737669,
139  0.005764912033581909, 0.02035493981231129,
140  -0.0008043589320165449, -0.004593173585311828,
141  5.7036083618494284e-05, 0.0004593294210046588,
142 };
143 
144 static const double rbior68_lp[18] = {
145  0.0, 0.0, 0.0, 0.0,
146  0.014426282505624435, 0.014467504896790148,
147  -0.07872200106262882, -0.04036797903033992,
148  0.41784910915027457, 0.7589077294536541,
149  0.41784910915027457, -0.04036797903033992,
150  -0.07872200106262882, 0.014467504896790148,
151  0.014426282505624435, 0.0, 0.0, 0.0,
152 };
153 
154 static const double rbior68_hp[18] = {
155  -0.0019088317364812906, -0.0019142861290887667,
156  0.016990639867602342, 0.01193456527972926,
157  -0.04973290349094079, -0.07726317316720414,
158  0.09405920349573646, 0.4207962846098268,
159  -0.8259229974584023, 0.4207962846098268,
160  0.09405920349573646, -0.07726317316720414,
161  -0.04973290349094079, 0.01193456527972926,
162  0.016990639867602342, -0.0019142861290887667,
163  -0.0019088317364812906, 0.0,
164 };
165 
166 static const double rbior68_ilp[18] = {
167  0.0019088317364812906, -0.0019142861290887667,
168  -0.016990639867602342, 0.01193456527972926,
169  0.04973290349094079, -0.07726317316720414,
170  -0.09405920349573646, 0.4207962846098268,
171  0.8259229974584023, 0.4207962846098268,
172  -0.09405920349573646, -0.07726317316720414,
173  0.04973290349094079, 0.01193456527972926,
174  -0.016990639867602342, -0.0019142861290887667,
175  0.0019088317364812906, 0.0,
176 };
177 
178 static const double rbior68_ihp[18] = {
179  0.0, 0.0, 0.0, 0.0,
180  0.014426282505624435, -0.014467504896790148,
181  -0.07872200106262882, 0.04036797903033992,
182  0.41784910915027457, -0.7589077294536541,
183  0.41784910915027457, 0.04036797903033992,
184  -0.07872200106262882, -0.014467504896790148,
185  0.014426282505624435, 0.0, 0.0, 0.0,
186 };
187 
188 static const double coif5_lp[30] = {
189  -9.517657273819165e-08, -1.6744288576823017e-07,
190  2.0637618513646814e-06, 3.7346551751414047e-06,
191  -2.1315026809955787e-05, -4.134043227251251e-05,
192  0.00014054114970203437, 0.00030225958181306315,
193  -0.0006381313430451114, -0.0016628637020130838,
194  0.0024333732126576722, 0.006764185448053083,
195  -0.009164231162481846, -0.01976177894257264,
196  0.03268357426711183, 0.0412892087501817,
197  -0.10557420870333893, -0.06203596396290357,
198  0.4379916261718371, 0.7742896036529562,
199  0.4215662066908515, -0.05204316317624377,
200  -0.09192001055969624, 0.02816802897093635,
201  0.023408156785839195, -0.010131117519849788,
202  -0.004159358781386048, 0.0021782363581090178,
203  0.00035858968789573785, -0.00021208083980379827,
204 };
205 
206 static const double coif5_hp[30] = {
207  0.00021208083980379827, 0.00035858968789573785,
208  -0.0021782363581090178, -0.004159358781386048,
209  0.010131117519849788, 0.023408156785839195,
210  -0.02816802897093635, -0.09192001055969624,
211  0.05204316317624377, 0.4215662066908515,
212  -0.7742896036529562, 0.4379916261718371,
213  0.06203596396290357, -0.10557420870333893,
214  -0.0412892087501817, 0.03268357426711183,
215  0.01976177894257264, -0.009164231162481846,
216  -0.006764185448053083, 0.0024333732126576722,
217  0.0016628637020130838, -0.0006381313430451114,
218  -0.00030225958181306315, 0.00014054114970203437,
219  4.134043227251251e-05, -2.1315026809955787e-05,
220  -3.7346551751414047e-06, 2.0637618513646814e-06,
221  1.6744288576823017e-07, -9.517657273819165e-08,
222 };
223 
224 static const double coif5_ilp[30] = {
225  -0.00021208083980379827, 0.00035858968789573785,
226  0.0021782363581090178, -0.004159358781386048,
227  -0.010131117519849788, 0.023408156785839195,
228  0.02816802897093635, -0.09192001055969624,
229  -0.05204316317624377, 0.4215662066908515,
230  0.7742896036529562, 0.4379916261718371,
231  -0.06203596396290357, -0.10557420870333893,
232  0.0412892087501817, 0.03268357426711183,
233  -0.01976177894257264, -0.009164231162481846,
234  0.006764185448053083, 0.0024333732126576722,
235  -0.0016628637020130838, -0.0006381313430451114,
236  0.00030225958181306315, 0.00014054114970203437,
237  -4.134043227251251e-05, -2.1315026809955787e-05,
238  3.7346551751414047e-06, 2.0637618513646814e-06,
239  -1.6744288576823017e-07, -9.517657273819165e-08,
240 };
241 
242 static const double coif5_ihp[30] = {
243  -9.517657273819165e-08, 1.6744288576823017e-07,
244  2.0637618513646814e-06, -3.7346551751414047e-06,
245  -2.1315026809955787e-05, 4.134043227251251e-05,
246  0.00014054114970203437, -0.00030225958181306315,
247  -0.0006381313430451114, 0.0016628637020130838,
248  0.0024333732126576722, -0.006764185448053083,
249  -0.009164231162481846, 0.01976177894257264,
250  0.03268357426711183, -0.0412892087501817,
251  -0.10557420870333893, 0.06203596396290357,
252  0.4379916261718371, -0.7742896036529562,
253  0.4215662066908515, 0.05204316317624377,
254  -0.09192001055969624, -0.02816802897093635,
255  0.023408156785839195, 0.010131117519849788,
256  -0.004159358781386048, -0.0021782363581090178,
257  0.00035858968789573785, 0.00021208083980379827,
258 };
259 
260 static const double deb10_lp[20] = {
261  -1.326420300235487e-05, 9.358867000108985e-05,
262  -0.0001164668549943862, -0.0006858566950046825,
263  0.00199240529499085, 0.0013953517469940798,
264  -0.010733175482979604, 0.0036065535669883944,
265  0.03321267405893324, -0.02945753682194567,
266  -0.07139414716586077, 0.09305736460380659,
267  0.12736934033574265, -0.19594627437659665,
268  -0.24984642432648865, 0.2811723436604265,
269  0.6884590394525921, 0.5272011889309198,
270  0.18817680007762133, 0.026670057900950818,
271 };
272 
273 static const double deb10_hp[20] = {
274  -0.026670057900950818, 0.18817680007762133,
275  -0.5272011889309198, 0.6884590394525921,
276  -0.2811723436604265, -0.24984642432648865,
277  0.19594627437659665, 0.12736934033574265,
278  -0.09305736460380659, -0.07139414716586077,
279  0.02945753682194567, 0.03321267405893324,
280  -0.0036065535669883944, -0.010733175482979604,
281  -0.0013953517469940798, 0.00199240529499085,
282  0.0006858566950046825, -0.0001164668549943862,
283  -9.358867000108985e-05, -1.326420300235487e-05,
284 };
285 
286 static const double deb10_ilp[20] = {
287  0.026670057900950818, 0.18817680007762133,
288  0.5272011889309198, 0.6884590394525921,
289  0.2811723436604265, -0.24984642432648865,
290  -0.19594627437659665, 0.12736934033574265,
291  0.09305736460380659, -0.07139414716586077,
292  -0.02945753682194567, 0.03321267405893324,
293  0.0036065535669883944, -0.010733175482979604,
294  0.0013953517469940798, 0.00199240529499085,
295  -0.0006858566950046825, -0.0001164668549943862,
296  9.358867000108985e-05, -1.326420300235487e-05,
297 };
298 
299 static const double deb10_ihp[20] = {
300  -1.326420300235487e-05, -9.358867000108985e-05,
301  -0.0001164668549943862, 0.0006858566950046825,
302  0.00199240529499085, -0.0013953517469940798,
303  -0.010733175482979604, -0.0036065535669883944,
304  0.03321267405893324, 0.02945753682194567,
305  -0.07139414716586077, -0.09305736460380659,
306  0.12736934033574265, 0.19594627437659665,
307  -0.24984642432648865, -0.2811723436604265,
308  0.6884590394525921, -0.5272011889309198,
309  0.18817680007762133, -0.026670057900950818,
310 };
311 
312 static const double sym4_lp[8] = {
313  -0.07576571478927333,
314  -0.02963552764599851,
315  0.49761866763201545,
316  0.8037387518059161,
317  0.29785779560527736,
318  -0.09921954357684722,
319  -0.012603967262037833,
320  0.0322231006040427,
321 };
322 
323 static const double sym4_hp[8] = {
324  -0.0322231006040427,
325  -0.012603967262037833,
326  0.09921954357684722,
327  0.29785779560527736,
328  -0.8037387518059161,
329  0.49761866763201545,
330  0.02963552764599851,
331  -0.07576571478927333,
332 };
333 
334 static const double sym4_ilp[8] = {
335  0.0322231006040427,
336  -0.012603967262037833,
337  -0.09921954357684722,
338  0.29785779560527736,
339  0.8037387518059161,
340  0.49761866763201545,
341  -0.02963552764599851,
342  -0.07576571478927333,
343 };
344 
345 static const double sym4_ihp[8] = {
346  -0.07576571478927333,
347  0.02963552764599851,
348  0.49761866763201545,
349  -0.8037387518059161,
350  0.29785779560527736,
351  0.09921954357684722,
352  -0.012603967262037833,
353  -0.0322231006040427,
354 };
355 
356 static const double sym2_lp[4] = {
357  -0.12940952255092145, 0.22414386804185735,
358  0.836516303737469, 0.48296291314469025,
359 };
360 
361 static const double sym2_hp[4] = {
362  -0.48296291314469025, 0.836516303737469,
363  -0.22414386804185735, -0.12940952255092145,
364 };
365 
366 static const double sym2_ilp[4] = {
367  0.48296291314469025, 0.836516303737469,
368  0.22414386804185735, -0.12940952255092145,
369 };
370 
371 static const double sym2_ihp[4] = {
372  -0.12940952255092145, -0.22414386804185735,
373  0.836516303737469, -0.48296291314469025,
374 };
375 
376 #define MAX_LEVELS 13
377 
378 typedef struct ChannelParams {
381  double **output_coefs;
383  double **filter_coefs;
384 
392 
393  double *tempa;
394  double *tempd;
395  double *temp_in;
396  double *buffer;
397  double *buffer2;
398  double *prev;
399  double *overlap;
400 } ChannelParams;
401 
402 typedef struct AudioFWTDNContext {
403  const AVClass *class;
404 
405  double sigma;
406  double percent;
407  double softness;
408 
409  uint64_t sn;
410  int64_t eof_pts;
411  int eof;
412 
414  int channels;
416  int levels;
420  int adaptive;
421 
422  int delay;
428 
429  const double *lp, *hp;
430  const double *ilp, *ihp;
431 
434 
435  int (*filter_channel)(AVFilterContext *ctx, void *arg, int ch, int nb_jobs);
437 
438 #define OFFSET(x) offsetof(AudioFWTDNContext, x)
439 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
440 #define AFR AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
441 
442 static const AVOption afwtdn_options[] = {
443  { "sigma", "set noise sigma", OFFSET(sigma), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 1, AFR },
444  { "levels", "set number of wavelet levels", OFFSET(levels), AV_OPT_TYPE_INT, {.i64=10}, 1, MAX_LEVELS-1, AF },
445  { "wavet", "set wavelet type", OFFSET(wavelet_type), AV_OPT_TYPE_INT, {.i64=SYM10}, 0, NB_WAVELET_TYPES - 1, AF, .unit = "wavet" },
446  { "sym2", "sym2", 0, AV_OPT_TYPE_CONST, {.i64=SYM2}, 0, 0, AF, .unit = "wavet" },
447  { "sym4", "sym4", 0, AV_OPT_TYPE_CONST, {.i64=SYM4}, 0, 0, AF, .unit = "wavet" },
448  { "rbior68", "rbior68", 0, AV_OPT_TYPE_CONST, {.i64=RBIOR68}, 0, 0, AF, .unit = "wavet" },
449  { "deb10", "deb10", 0, AV_OPT_TYPE_CONST, {.i64=DEB10}, 0, 0, AF, .unit = "wavet" },
450  { "sym10", "sym10", 0, AV_OPT_TYPE_CONST, {.i64=SYM10}, 0, 0, AF, .unit = "wavet" },
451  { "coif5", "coif5", 0, AV_OPT_TYPE_CONST, {.i64=COIF5}, 0, 0, AF, .unit = "wavet" },
452  { "bl3", "bl3", 0, AV_OPT_TYPE_CONST, {.i64=BL3}, 0, 0, AF, .unit = "wavet" },
453  { "percent", "set percent of full denoising", OFFSET(percent),AV_OPT_TYPE_DOUBLE, {.dbl=85}, 0, 100, AFR },
454  { "profile", "profile noise", OFFSET(need_profile), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AFR },
455  { "adaptive", "adaptive profiling of noise", OFFSET(adaptive), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AFR },
456  { "samples", "set frame size in number of samples", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64=8192}, 512, 65536, AF },
457  { "softness", "set thresholding softness", OFFSET(softness), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 10, AFR },
458  { NULL }
459 };
460 
461 AVFILTER_DEFINE_CLASS(afwtdn);
462 
463 #define pow2(x) (1U << (x))
464 #define mod_pow2(x, power_of_two) ((x) & ((power_of_two) - 1))
465 
466 static void conv_down(double *in, int in_length, double *low, double *high,
467  int out_length, const double *lp, const double *hp,
468  int wavelet_length, int skip,
469  double *buffer, int buffer_length)
470 {
471  double thigh = 0.0, tlow = 0.0;
472  int buff_idx = 1 + skip;
473 
474  memcpy(buffer, in, buff_idx * sizeof(*buffer));
475  memset(buffer + buff_idx, 0, (buffer_length - buff_idx) * sizeof(*buffer));
476 
477  for (int i = 0; i < out_length - 1; i++) {
478  double thigh = 0.0, tlow = 0.0;
479 
480  for (int j = 0; j < wavelet_length; j++) {
481  const int idx = mod_pow2(-j + buff_idx - 1, buffer_length);
482  const double btemp = buffer[idx];
483 
484  thigh += btemp * hp[j];
485  tlow += btemp * lp[j];
486  }
487 
488  high[i] = thigh;
489  low[i] = tlow;
490  buffer[buff_idx++] = in[2 * i + 1 + skip];
491  buffer[buff_idx++] = in[2 * i + 2 + skip];
492  buff_idx = mod_pow2(buff_idx, buffer_length);
493  }
494 
495  for (int i = 0; i < wavelet_length; i++) {
496  const int idx = mod_pow2(-i + buff_idx - 1, buffer_length);
497  const double btemp = buffer[idx];
498 
499  thigh += btemp * hp[i];
500  tlow += btemp * lp[i];
501  }
502 
503  high[out_length - 1] = thigh;
504  low[out_length - 1] = tlow;
505 }
506 
507 static int left_ext(int wavelet_length, int levels, uint64_t sn)
508 {
509  if (!sn)
510  return 0;
511  return (pow2(levels) - 1) * (wavelet_length - 2) + mod_pow2(sn, pow2(levels));
512 }
513 
514 static int nb_coefs(int length, int level, uint64_t sn)
515 {
516  const int pow2_level = pow2(level);
517 
518  return (sn + length) / pow2_level - sn / pow2_level;
519 }
520 
521 static int reallocate_inputs(double **out, int *out_length,
522  int in_length, int levels, int ch, uint64_t sn)
523 {
524  const int temp_length = nb_coefs(in_length, levels, sn);
525 
526  for (int level = 0; level < levels; level++) {
527  const int temp_length = nb_coefs(in_length, level + 1, sn);
528 
529  if (temp_length > out_length[level]) {
530  av_freep(&out[level]);
531  out_length[level] = 0;
532 
533  out[level] = av_calloc(temp_length + 1, sizeof(**out));
534  if (!out[level])
535  return AVERROR(ENOMEM);
536  out_length[level] = temp_length + 1;
537  }
538 
539  memset(out[level] + temp_length, 0,
540  (out_length[level] - temp_length) * sizeof(**out));
541  out_length[level] = temp_length;
542  }
543 
544  if (temp_length > out_length[levels]) {
545  av_freep(&out[levels]);
546  out_length[levels] = 0;
547 
548  out[levels] = av_calloc(temp_length + 1, sizeof(**out));
549  if (!out[levels])
550  return AVERROR(ENOMEM);
551  out_length[levels] = temp_length + 1;
552  }
553 
554  memset(out[levels] + temp_length, 0,
555  (out_length[levels] - temp_length) * sizeof(**out));
556  out_length[levels] = temp_length;
557 
558  return 0;
559 }
560 
561 static int max_left_zeros_inverse(int levels, int level, int wavelet_length)
562 {
563  return (pow2(levels - level) - 1) * (wavelet_length - 1);
564 }
565 
567  double **out, int *out_length,
568  int in_length, int levels, int ch, uint64_t sn)
569 {
570  ChannelParams *cp = &s->cp[ch];
571  int temp_length = 0;
572  int add = 0;
573 
574  for (int level = 0; level < levels; level++) {
575  temp_length = nb_coefs(in_length, level + 1, sn);
576  if (temp_length > out_length[level]) {
578  out_length[level] = 0;
579 
580  add = max_left_zeros_inverse(levels, level + 1, s->wavelet_length);
581  cp->subbands_to_free[level] = av_calloc(add + temp_length + 1, sizeof(**out));
582  if (!cp->subbands_to_free[level])
583  return AVERROR(ENOMEM);
584  out_length[level] = add + temp_length + 1;
585  out[level] = cp->subbands_to_free[level] + add;
586  }
587 
588  memset(out[level] + temp_length, 0,
589  FFMAX(out_length[level] - temp_length - add, 0) * sizeof(**out));
590  out_length[level] = temp_length;
591  }
592 
593  temp_length = nb_coefs(in_length, levels, sn);
594  if (temp_length > out_length[levels]) {
595  av_freep(&cp->subbands_to_free[levels]);
596  out_length[levels] = 0;
597 
598  cp->subbands_to_free[levels] = av_calloc(temp_length + 1, sizeof(**out));
599  if (!cp->subbands_to_free[levels])
600  return AVERROR(ENOMEM);
601  out_length[levels] = temp_length + 1;
602  out[levels] = cp->subbands_to_free[levels];
603  }
604 
605  memset(out[levels] + temp_length, 0,
606  (out_length[levels] - temp_length) * sizeof(**out));
607  out_length[levels] = temp_length;
608 
609  return 0;
610 }
611 
612 static int discard_left_ext(int wavelet_length, int levels, int level, uint64_t sn)
613 {
614  if (levels == level || sn == 0)
615  return 0;
616  return (pow2(levels - level) - 1) * (wavelet_length - 2) + mod_pow2(sn, pow2(levels)) / pow2(level);
617 }
618 
620  const double *in, int in_length,
621  double **out, int *out_length, int ch, uint64_t sn)
622 {
623  ChannelParams *cp = &s->cp[ch];
624  int levels = s->levels;
625  int skip = sn ? s->wavelet_length - 1 : 1;
626  int leftext, ret;
627 
628  ret = reallocate_inputs(out, out_length, in_length, levels, ch, sn);
629  if (ret < 0)
630  return ret;
632  in_length, levels, ch, sn);
633  if (ret < 0)
634  return ret;
635 
636  leftext = left_ext(s->wavelet_length, levels, sn);
637 
638  if (cp->temp_in_max_length < in_length + cp->max_left_ext + skip) {
639  av_freep(&cp->temp_in);
640  cp->temp_in_max_length = in_length + cp->max_left_ext + skip;
641  cp->temp_in = av_calloc(cp->temp_in_max_length, sizeof(*cp->temp_in));
642  if (!cp->temp_in) {
643  cp->temp_in_max_length = 0;
644  return AVERROR(ENOMEM);
645  }
646  }
647 
648  memset(cp->temp_in, 0, cp->temp_in_max_length * sizeof(*cp->temp_in));
649  cp->temp_in_length = in_length + leftext;
650 
651  if (leftext)
652  memcpy(cp->temp_in, cp->prev + s->prev_length - leftext, leftext * sizeof(*cp->temp_in));
653  memcpy(cp->temp_in + leftext, in, in_length * sizeof(*in));
654 
655  if (levels == 1) {
656  conv_down(cp->temp_in, cp->temp_in_length, out[1], out[0], out_length[1],
657  s->lp, s->hp, s->wavelet_length, skip,
658  cp->buffer, cp->buffer_length);
659  } else {
660  int discard = discard_left_ext(s->wavelet_length, levels, 1, sn);
661  int tempa_length_prev;
662 
663  if (cp->tempa_len_max < (in_length + cp->max_left_ext + s->wavelet_length - 1) / 2) {
664  av_freep(&cp->tempa);
665  av_freep(&cp->tempd);
666  cp->tempa_len_max = (in_length + cp->max_left_ext + s->wavelet_length - 1) / 2;
667  cp->tempa = av_calloc(cp->tempa_len_max, sizeof(*cp->tempa));
668  cp->tempd = av_calloc(cp->tempa_len_max, sizeof(*cp->tempd));
669  if (!cp->tempa || !cp->tempd) {
670  cp->tempa_len_max = 0;
671  return AVERROR(ENOMEM);
672  }
673  }
674 
675  memset(cp->tempa, 0, cp->tempa_len_max * sizeof(*cp->tempa));
676  memset(cp->tempd, 0, cp->tempa_len_max * sizeof(*cp->tempd));
677 
678  cp->tempa_length = out_length[0] + discard;
680  cp->tempa, cp->tempd, cp->tempa_length,
681  s->lp, s->hp, s->wavelet_length, skip,
682  cp->buffer, cp->buffer_length);
683  memcpy(out[0], cp->tempd + discard, out_length[0] * sizeof(**out));
684  tempa_length_prev = cp->tempa_length;
685 
686  for (int level = 1; level < levels - 1; level++) {
687  if (out_length[level] == 0)
688  return 0;
689  discard = discard_left_ext(s->wavelet_length, levels, level + 1, sn);
690  cp->tempa_length = out_length[level] + discard;
691  conv_down(cp->tempa, tempa_length_prev,
692  cp->tempa, cp->tempd, cp->tempa_length,
693  s->lp, s->hp, s->wavelet_length, skip,
694  cp->buffer, cp->buffer_length);
695  memcpy(out[level], cp->tempd + discard, out_length[level] * sizeof(**out));
696  tempa_length_prev = cp->tempa_length;
697  }
698 
699  if (out_length[levels] == 0)
700  return 0;
701  conv_down(cp->tempa, cp->tempa_length, out[levels], out[levels - 1], out_length[levels],
702  s->lp, s->hp, s->wavelet_length, skip,
703  cp->buffer, cp->buffer_length);
704  }
705 
706  if (s->prev_length < in_length) {
707  memcpy(cp->prev, in + in_length - cp->max_left_ext, cp->max_left_ext * sizeof(*cp->prev));
708  } else {
709  memmove(cp->prev, cp->prev + in_length, (s->prev_length - in_length) * sizeof(*cp->prev));
710  memcpy(cp->prev + s->prev_length - in_length, in, in_length * sizeof(*cp->prev));
711  }
712 
713  return 0;
714 }
715 
716 static void conv_up(double *low, double *high, int in_length, double *out, int out_length,
717  const double *lp, const double *hp, int filter_length,
718  double *buffer, double *buffer2, int buffer_length)
719 {
720  int shift = 0, buff_idx = 0, in_idx = 0;
721 
722  memset(buffer, 0, buffer_length * sizeof(*buffer));
723  memset(buffer2, 0, buffer_length * sizeof(*buffer2));
724 
725  for (int i = 0; i < out_length; i++) {
726  double sum = 0.0;
727 
728  if ((i & 1) == 0) {
729  if (in_idx < in_length) {
730  buffer[buff_idx] = low[in_idx];
731  buffer2[buff_idx] = high[in_idx++];
732  } else {
733  buffer[buff_idx] = 0;
734  buffer2[buff_idx] = 0;
735  }
736  buff_idx++;
737  if (buff_idx >= buffer_length)
738  buff_idx = 0;
739  shift = 0;
740  }
741 
742  for (int j = 0; j < (filter_length - shift + 1) / 2; j++) {
743  const int idx = mod_pow2(-j + buff_idx - 1, buffer_length);
744 
745  sum += buffer[idx] * lp[j * 2 + shift] + buffer2[idx] * hp[j * 2 + shift];
746  }
747  out[i] = sum;
748  shift = 1;
749  }
750 }
751 
752 static int append_left_ext(int wavelet_length, int levels, int level, uint64_t sn)
753 {
754  if (levels == level)
755  return 0;
756 
757  return (pow2(levels - level) - 1) * (wavelet_length - 2) +
758  mod_pow2(sn, pow2(levels)) / pow2(level);
759 }
760 
762  double **in, int *in_length,
763  double *out, int out_length, int ch, uint64_t sn)
764 {
765  ChannelParams *cp = &s->cp[ch];
766  const int levels = s->levels;
767  int leftext = left_ext(s->wavelet_length, levels, sn);
768  int temp_skip = 0;
769 
770  if (sn == 0)
771  temp_skip = cp->min_left_ext;
772 
773  memset(out, 0, out_length * sizeof(*out));
774 
775  if (cp->temp_in_max_length < out_length + cp->max_left_ext + s->wavelet_length - 1) {
776  av_freep(&cp->temp_in);
777  cp->temp_in_max_length = out_length + cp->max_left_ext + s->wavelet_length - 1;
778  cp->temp_in = av_calloc(cp->temp_in_max_length, sizeof(*cp->temp_in));
779  if (!cp->temp_in) {
780  cp->temp_in_max_length = 0;
781  return AVERROR(ENOMEM);
782  }
783  }
784 
785  memset(cp->temp_in, 0, cp->temp_in_max_length * sizeof(*cp->temp_in));
786  cp->temp_in_length = out_length + cp->max_left_ext;
787 
788  if (levels == 1) {
789  conv_up(in[1], in[0], in_length[1], cp->temp_in, cp->temp_in_length,
790  s->ilp, s->ihp, s->wavelet_length,
791  cp->buffer, cp->buffer2, cp->buffer_length);
792  memcpy(out + cp->max_left_ext - leftext, cp->temp_in + temp_skip,
793  FFMAX(0, out_length - (cp->max_left_ext - leftext)) * sizeof(*out));
794  } else {
795  double *hp1, *hp2;
796  int add, add2;
797 
798  if (cp->tempa_len_max < (out_length + cp->max_left_ext + s->wavelet_length - 1) / 2) {
799  av_freep(&cp->tempa);
800  cp->tempa_len_max = (out_length + cp->max_left_ext + s->wavelet_length - 1) / 2;
801  cp->tempa = av_calloc(cp->tempa_len_max, sizeof(*cp->tempa));
802  if (!cp->tempa) {
803  cp->tempa_len_max = 0;
804  return AVERROR(ENOMEM);
805  }
806  }
807 
808  memset(cp->tempa, 0, cp->tempa_len_max * sizeof(*cp->tempa));
809 
810  hp1 = levels & 1 ? cp->temp_in : cp->tempa;
811  hp2 = levels & 1 ? cp->tempa : cp->temp_in;
812 
813  add = append_left_ext(s->wavelet_length, levels, levels - 1, sn);
814  conv_up(in[levels], in[levels - 1], in_length[levels], hp1, in_length[levels - 2] + add,
815  s->ilp, s->ihp, s->wavelet_length, cp->buffer, cp->buffer2, cp->buffer_length);
816 
817  for (int level = levels - 1; level > 1; level--) {
818  add2 = append_left_ext(s->wavelet_length, levels, level - 1, sn);
819  add = append_left_ext(s->wavelet_length, levels, level, sn);
820  conv_up(hp1, in[level - 1] - add, in_length[level - 1] + add,
821  hp2, in_length[level - 2] + add2,
822  s->ilp, s->ihp, s->wavelet_length,
823  cp->buffer, cp->buffer2, cp->buffer_length);
824  FFSWAP(double *, hp1, hp2);
825  }
826 
827  add = append_left_ext(s->wavelet_length, levels, 1, sn);
828  conv_up(hp1, in[0] - add, in_length[0] + add, cp->temp_in, cp->temp_in_length,
829  s->ilp, s->ihp, s->wavelet_length,
830  cp->buffer, cp->buffer2, cp->buffer_length);
831  }
832 
833  memset(cp->temp_in, 0, temp_skip * sizeof(*cp->temp_in));
834  if (s->overlap_length <= out_length) {
835  memcpy(out + cp->max_left_ext - leftext, cp->temp_in + temp_skip,
836  FFMAX(0, out_length - (cp->max_left_ext - leftext)) * sizeof(*out));
837  for (int i = 0;i < FFMIN(s->overlap_length, out_length); i++)
838  out[i] += cp->overlap[i];
839 
840  memcpy(cp->overlap, cp->temp_in + out_length - (cp->max_left_ext - leftext),
841  s->overlap_length * sizeof(*cp->overlap));
842  } else {
843  for (int i = 0;i < s->overlap_length - (cp->max_left_ext - leftext); i++)
844  cp->overlap[i + cp->max_left_ext - leftext] += cp->temp_in[i];
845  memcpy(out, cp->overlap, out_length * sizeof(*out));
846  memmove(cp->overlap, cp->overlap + out_length,
847  (s->overlap_length - out_length) * sizeof(*cp->overlap));
848  memcpy(cp->overlap + s->overlap_length - out_length, cp->temp_in + leftext,
849  out_length * sizeof(*cp->overlap));
850  }
851 
852  return 0;
853 }
854 
855 static int next_pow2(int in)
856 {
857  return 1 << (av_log2(in) + 1);
858 }
859 
860 static void denoise_level(double *out, const double *in,
861  const double *filter,
862  double percent, int length)
863 {
864  const double x = percent * 0.01;
865  const double y = 1.0 - x;
866 
867  for (int i = 0; i < length; i++)
868  out[i] = x * filter[i] + in[i] * y;
869 }
870 
871 static double sqr(double in)
872 {
873  return in * in;
874 }
875 
876 static double measure_mean(const double *in, int length)
877 {
878  double sum = 0.0;
879 
880  for (int i = 0; i < length; i++)
881  sum += in[i];
882 
883  return sum / length;
884 }
885 
886 static double measure_absmean(const double *in, int length)
887 {
888  double sum = 0.0;
889 
890  for (int i = 0; i < length; i++)
891  sum += fabs(in[i]);
892 
893  return sum / length;
894 }
895 
896 static double measure_stddev(const double *in, int length, double mean)
897 {
898  double sum = 0.;
899 
900  for (int i = 0; i < length; i++) {
901  sum += sqr(in[i] - mean);
902  }
903 
904  return sqrt(sum / length);
905 }
906 
907 static void noise_filter(const double stddev, const double *in,
908  double *out, double absmean, double softness,
909  double new_stddev, int length)
910 {
911  for (int i = 0; i < length; i++) {
912  if (new_stddev <= stddev)
913  out[i] = 0.0;
914  else if (fabs(in[i]) <= absmean)
915  out[i] = 0.0;
916  else
917  out[i] = in[i] - FFSIGN(in[i]) * absmean / exp(3.0 * softness * (fabs(in[i]) - absmean) / absmean);
918  }
919 }
920 
921 typedef struct ThreadData {
922  AVFrame *in, *out;
923 } ThreadData;
924 
925 static int filter_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
926 {
927  AudioFWTDNContext *s = ctx->priv;
928  ThreadData *td = arg;
929  AVFrame *in = td->in;
930  AVFrame *out = td->out;
931  ChannelParams *cp = &s->cp[ch];
932  const double *src = (const double *)(in->extended_data[ch]);
933  double *dst = (double *)out->extended_data[ch];
934  double *absmean = (double *)s->absmean->extended_data[ch];
935  double *new_absmean = (double *)s->new_absmean->extended_data[ch];
936  double *stddev = (double *)s->stddev->extended_data[ch];
937  double *new_stddev = (double *)s->new_stddev->extended_data[ch];
938  double *filter = (double *)s->filter->extended_data[ch];
939  double is_noise = 0.0;
940  int ret;
941 
942  ret = forward(s, src, in->nb_samples, cp->output_coefs, cp->output_length, ch, s->sn);
943  if (ret < 0)
944  return ret;
945 
946  if (!s->got_profile && s->need_profile) {
947  for (int level = 0; level <= s->levels; level++) {
948  const int length = cp->output_length[level];
949  const double scale = sqrt(2.0 * log(length));
950 
951  stddev[level] = measure_stddev(cp->output_coefs[level], length,
952  measure_mean(cp->output_coefs[level], length)) * scale;
953  absmean[level] = measure_absmean(cp->output_coefs[level], length) * scale;
954  }
955  } else if (!s->got_profile && !s->need_profile && !s->adaptive) {
956  for (int level = 0; level <= s->levels; level++) {
957  const int length = cp->output_length[level];
958  const double scale = sqrt(2.0 * log(length));
959 
960  stddev[level] = 0.5 * s->sigma * scale;
961  absmean[level] = 0.5 * s->sigma * scale;
962  }
963  }
964 
965  for (int level = 0; level <= s->levels; level++) {
966  const int length = cp->output_length[level];
967  double vad;
968 
969  new_stddev[level] = measure_stddev(cp->output_coefs[level], length,
970  measure_mean(cp->output_coefs[level], length));
971  new_absmean[level] = measure_absmean(cp->output_coefs[level], length);
972  if (new_absmean[level] <= FLT_EPSILON)
973  vad = 1.0;
974  else
975  vad = new_stddev[level] / new_absmean[level];
976  if (level < s->levels)
977  is_noise += sqr(vad - 1.232);
978  }
979 
980  is_noise *= in->sample_rate;
981  is_noise /= s->nb_samples;
982  for (int level = 0; level <= s->levels; level++) {
983  const double percent = ctx->is_disabled ? 0. : s->percent;
984  const int length = cp->output_length[level];
985  const double scale = sqrt(2.0 * log(length));
986 
987  if (is_noise < 0.05 && s->adaptive) {
988  stddev[level] = new_stddev[level] * scale;
989  absmean[level] = new_absmean[level] * scale;
990  }
991 
992  noise_filter(stddev[level], cp->output_coefs[level], filter, absmean[level],
993  s->softness, new_stddev[level], length);
994  denoise_level(cp->filter_coefs[level], cp->output_coefs[level], filter, percent, length);
995  }
996 
997  ret = inverse(s, cp->filter_coefs, cp->filter_length, dst, out->nb_samples, ch, s->sn);
998  if (ret < 0)
999  return ret;
1000 
1001  return 0;
1002 }
1003 
1005 {
1006  AVFilterContext *ctx = inlink->dst;
1007  AudioFWTDNContext *s = ctx->priv;
1008  AVFilterLink *outlink = ctx->outputs[0];
1009  ThreadData td;
1010  AVFrame *out;
1011  int eof = in == NULL;
1012 
1013  out = ff_get_audio_buffer(outlink, s->nb_samples);
1014  if (!out) {
1015  av_frame_free(&in);
1016  return AVERROR(ENOMEM);
1017  }
1018  if (in) {
1019  av_frame_copy_props(out, in);
1020  s->eof_pts = in->pts + in->nb_samples;
1021  }
1022  if (eof)
1023  out->pts = s->eof_pts - s->padd_samples;
1024 
1025  if (!in || in->nb_samples < s->nb_samples) {
1026  AVFrame *new_in = ff_get_audio_buffer(outlink, s->nb_samples);
1027 
1028  if (!new_in) {
1029  av_frame_free(&in);
1030  av_frame_free(&out);
1031  return AVERROR(ENOMEM);
1032  }
1033  if (in)
1034  av_frame_copy_props(new_in, in);
1035 
1036  s->padd_samples -= s->nb_samples - (in ? in->nb_samples: 0);
1037  if (in)
1038  av_samples_copy(new_in->extended_data, in->extended_data, 0, 0,
1039  in->nb_samples, in->ch_layout.nb_channels, in->format);
1040  av_frame_free(&in);
1041  in = new_in;
1042  }
1043 
1044  td.in = in;
1045  td.out = out;
1046  ff_filter_execute(ctx, s->filter_channel, &td, NULL, inlink->ch_layout.nb_channels);
1047  if (s->need_profile)
1048  s->got_profile = 1;
1049 
1050  s->sn += s->nb_samples;
1051 
1052  if (s->drop_samples >= in->nb_samples) {
1053  s->drop_samples -= in->nb_samples;
1054  s->delay += in->nb_samples;
1055  av_frame_free(&in);
1056  av_frame_free(&out);
1057  FF_FILTER_FORWARD_STATUS(inlink, outlink);
1058  FF_FILTER_FORWARD_WANTED(outlink, inlink);
1059  return 0;
1060  } else if (s->drop_samples > 0) {
1061  for (int ch = 0; ch < out->ch_layout.nb_channels; ch++) {
1062  memmove(out->extended_data[ch],
1063  out->extended_data[ch] + s->drop_samples * sizeof(double),
1064  (in->nb_samples - s->drop_samples) * sizeof(double));
1065  }
1066 
1067  out->nb_samples = in->nb_samples - s->drop_samples;
1068  out->pts = in->pts - av_rescale_q(s->delay, (AVRational){1, outlink->sample_rate}, outlink->time_base);
1069  s->delay += s->drop_samples;
1070  s->drop_samples = 0;
1071  } else {
1072  if (s->padd_samples < 0 && eof) {
1073  out->nb_samples = FFMAX(0, out->nb_samples + s->padd_samples);
1074  s->padd_samples = 0;
1075  }
1076  if (!eof)
1077  out->pts = in->pts - av_rescale_q(s->delay, (AVRational){1, outlink->sample_rate}, outlink->time_base);
1078  }
1079 
1080  av_frame_free(&in);
1081  return ff_filter_frame(outlink, out);
1082 }
1083 
1084 static int max_left_ext(int wavelet_length, int levels)
1085 {
1086  return (pow2(levels) - 1) * (wavelet_length - 1);
1087 }
1088 
1089 static int min_left_ext(int wavelet_length, int levels)
1090 {
1091  return (pow2(levels) - 1) * (wavelet_length - 2);
1092 }
1093 
1094 static int config_output(AVFilterLink *outlink)
1095 {
1096  AVFilterContext *ctx = outlink->src;
1097  AudioFWTDNContext *s = ctx->priv;
1098 
1099  switch (s->wavelet_type) {
1100  case SYM2:
1101  s->wavelet_length = 4;
1102  s->lp = sym2_lp;
1103  s->hp = sym2_hp;
1104  s->ilp = sym2_ilp;
1105  s->ihp = sym2_ihp;
1106  break;
1107  case SYM4:
1108  s->wavelet_length = 8;
1109  s->lp = sym4_lp;
1110  s->hp = sym4_hp;
1111  s->ilp = sym4_ilp;
1112  s->ihp = sym4_ihp;
1113  break;
1114  case RBIOR68:
1115  s->wavelet_length = 18;
1116  s->lp = rbior68_lp;
1117  s->hp = rbior68_hp;
1118  s->ilp = rbior68_ilp;
1119  s->ihp = rbior68_ihp;
1120  break;
1121  case DEB10:
1122  s->wavelet_length = 20;
1123  s->lp = deb10_lp;
1124  s->hp = deb10_hp;
1125  s->ilp = deb10_ilp;
1126  s->ihp = deb10_ihp;
1127  break;
1128  case SYM10:
1129  s->wavelet_length = 20;
1130  s->lp = sym10_lp;
1131  s->hp = sym10_hp;
1132  s->ilp = sym10_ilp;
1133  s->ihp = sym10_ihp;
1134  break;
1135  case COIF5:
1136  s->wavelet_length = 30;
1137  s->lp = coif5_lp;
1138  s->hp = coif5_hp;
1139  s->ilp = coif5_ilp;
1140  s->ihp = coif5_ihp;
1141  break;
1142  case BL3:
1143  s->wavelet_length = 42;
1144  s->lp = bl3_lp;
1145  s->hp = bl3_hp;
1146  s->ilp = bl3_ilp;
1147  s->ihp = bl3_ihp;
1148  break;
1149  default:
1150  av_assert0(0);
1151  }
1152 
1153  s->levels = FFMIN(s->levels, lrint(log(s->nb_samples / (s->wavelet_length - 1.0)) / M_LN2));
1154  av_log(ctx, AV_LOG_VERBOSE, "levels: %d\n", s->levels);
1155  s->filter_channel = filter_channel;
1156 
1157  s->stddev = ff_get_audio_buffer(outlink, MAX_LEVELS);
1158  s->new_stddev = ff_get_audio_buffer(outlink, MAX_LEVELS);
1159  s->filter = ff_get_audio_buffer(outlink, s->nb_samples);
1160  s->absmean = ff_get_audio_buffer(outlink, MAX_LEVELS);
1161  s->new_absmean = ff_get_audio_buffer(outlink, MAX_LEVELS);
1162  if (!s->stddev || !s->absmean || !s->filter ||
1163  !s->new_stddev || !s->new_absmean)
1164  return AVERROR(ENOMEM);
1165 
1166  s->channels = outlink->ch_layout.nb_channels;
1167  s->overlap_length = max_left_ext(s->wavelet_length, s->levels);
1168  s->prev_length = s->overlap_length;
1169  s->drop_samples = s->overlap_length;
1170  s->padd_samples = s->overlap_length;
1171  s->sn = 1;
1172 
1173  s->cp = av_calloc(s->channels, sizeof(*s->cp));
1174  if (!s->cp)
1175  return AVERROR(ENOMEM);
1176 
1177  for (int ch = 0; ch < s->channels; ch++) {
1178  ChannelParams *cp = &s->cp[ch];
1179 
1180  cp->output_coefs = av_calloc(s->levels + 1, sizeof(*cp->output_coefs));
1181  cp->filter_coefs = av_calloc(s->levels + 1, sizeof(*cp->filter_coefs));
1182  cp->output_length = av_calloc(s->levels + 1, sizeof(*cp->output_length));
1183  cp->filter_length = av_calloc(s->levels + 1, sizeof(*cp->filter_length));
1184  cp->buffer_length = next_pow2(s->wavelet_length);
1185  cp->buffer = av_calloc(cp->buffer_length, sizeof(*cp->buffer));
1186  cp->buffer2 = av_calloc(cp->buffer_length, sizeof(*cp->buffer2));
1187  cp->subbands_to_free = av_calloc(s->levels + 1, sizeof(*cp->subbands_to_free));
1188  cp->prev = av_calloc(s->prev_length, sizeof(*cp->prev));
1189  cp->overlap = av_calloc(s->overlap_length, sizeof(*cp->overlap));
1190  cp->max_left_ext = max_left_ext(s->wavelet_length, s->levels);
1191  cp->min_left_ext = min_left_ext(s->wavelet_length, s->levels);
1192  if (!cp->output_coefs || !cp->filter_coefs || !cp->output_length ||
1193  !cp->filter_length || !cp->subbands_to_free || !cp->prev || !cp->overlap ||
1194  !cp->buffer || !cp->buffer2)
1195  return AVERROR(ENOMEM);
1196  }
1197 
1198  return 0;
1199 }
1200 
1202 {
1203  AVFilterLink *inlink = ctx->inputs[0];
1204  AVFilterLink *outlink = ctx->outputs[0];
1205  AudioFWTDNContext *s = ctx->priv;
1206  AVFrame *in = NULL;
1207  int ret, status;
1208  int64_t pts;
1209 
1211 
1212  if (!s->eof) {
1213  ret = ff_inlink_consume_samples(inlink, s->nb_samples, s->nb_samples, &in);
1214  if (ret < 0)
1215  return ret;
1216  if (ret > 0)
1217  return filter_frame(inlink, in);
1218  }
1219 
1221  if (status == AVERROR_EOF)
1222  s->eof = 1;
1223  }
1224 
1225  if (s->eof && s->padd_samples != 0) {
1226  return filter_frame(inlink, NULL);
1227  } else if (s->eof) {
1228  ff_outlink_set_status(outlink, AVERROR_EOF, s->eof_pts);
1229  return 0;
1230  }
1231 
1232  FF_FILTER_FORWARD_WANTED(outlink, inlink);
1233 
1234  return FFERROR_NOT_READY;
1235 }
1236 
1238 {
1239  AudioFWTDNContext *s = ctx->priv;
1240 
1241  av_frame_free(&s->filter);
1242  av_frame_free(&s->new_stddev);
1243  av_frame_free(&s->stddev);
1244  av_frame_free(&s->new_absmean);
1245  av_frame_free(&s->absmean);
1246 
1247  for (int ch = 0; s->cp && ch < s->channels; ch++) {
1248  ChannelParams *cp = &s->cp[ch];
1249 
1250  av_freep(&cp->tempa);
1251  av_freep(&cp->tempd);
1252  av_freep(&cp->temp_in);
1253  av_freep(&cp->buffer);
1254  av_freep(&cp->buffer2);
1255  av_freep(&cp->prev);
1256  av_freep(&cp->overlap);
1257 
1258  av_freep(&cp->output_length);
1259  av_freep(&cp->filter_length);
1260 
1261  if (cp->output_coefs) {
1262  for (int level = 0; level <= s->levels; level++)
1263  av_freep(&cp->output_coefs[level]);
1264  }
1265 
1266  if (cp->subbands_to_free) {
1267  for (int level = 0; level <= s->levels; level++)
1269  }
1270 
1271  av_freep(&cp->subbands_to_free);
1272  av_freep(&cp->output_coefs);
1273  av_freep(&cp->filter_coefs);
1274  }
1275 
1276  av_freep(&s->cp);
1277 }
1278 
1279 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
1280  char *res, int res_len, int flags)
1281 {
1282  AudioFWTDNContext *s = ctx->priv;
1283  int ret;
1284 
1285  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
1286  if (ret < 0)
1287  return ret;
1288 
1289  if (!strcmp(cmd, "profile") && s->need_profile)
1290  s->got_profile = 0;
1291 
1292  return 0;
1293 }
1294 
1295 static const AVFilterPad outputs[] = {
1296  {
1297  .name = "default",
1298  .type = AVMEDIA_TYPE_AUDIO,
1299  .config_props = config_output,
1300  },
1301 };
1302 
1304  .name = "afwtdn",
1305  .description = NULL_IF_CONFIG_SMALL("Denoise audio stream using Wavelets."),
1306  .priv_size = sizeof(AudioFWTDNContext),
1307  .priv_class = &afwtdn_class,
1308  .activate = activate,
1309  .uninit = uninit,
1313  .process_command = process_command,
1316 };
av_samples_copy
int av_samples_copy(uint8_t *const *dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
Definition: samplefmt.c:222
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:109
coif5_ilp
static const double coif5_ilp[30]
Definition: af_afwtdn.c:224
nb_coefs
static int nb_coefs(int length, int level, uint64_t sn)
Definition: af_afwtdn.c:514
td
#define td
Definition: regdef.h:70
filter_channel
static int filter_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
Definition: af_afwtdn.c:925
AudioFWTDNContext::got_profile
int got_profile
Definition: af_afwtdn.c:419
level
uint8_t level
Definition: svq3.c:204
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ChannelParams::overlap
double * overlap
Definition: af_afwtdn.c:399
AudioFWTDNContext::padd_samples
int padd_samples
Definition: af_afwtdn.c:424
ChannelParams::temp_in_length
int temp_in_length
Definition: af_afwtdn.c:387
ChannelParams::tempa
double * tempa
Definition: af_afwtdn.c:393
out
FILE * out
Definition: movenc.c:54
AudioFWTDNContext::adaptive
int adaptive
Definition: af_afwtdn.c:420
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
ChannelParams::min_left_ext
int min_left_ext
Definition: af_afwtdn.c:390
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
FILTER_SINGLE_SAMPLEFMT
#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_)
Definition: internal.h:175
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
normalize.log
log
Definition: normalize.py:21
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
SYM2
@ SYM2
Definition: af_afwtdn.c:30
AudioFWTDNContext::hp
const double * hp
Definition: af_afwtdn.c:429
AudioFWTDNContext::absmean
AVFrame * absmean
Definition: af_afwtdn.c:432
AVOption
AVOption.
Definition: opt.h:294
AudioFWTDNContext::new_stddev
AVFrame * new_stddev
Definition: af_afwtdn.c:433
AudioFWTDNContext::levels
int levels
Definition: af_afwtdn.c:416
sym4_ilp
static const double sym4_ilp[8]
Definition: af_afwtdn.c:334
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
float.h
ChannelParams::output_length
int * output_length
Definition: af_afwtdn.c:379
coif5_hp
static const double coif5_hp[30]
Definition: af_afwtdn.c:206
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
sqr
static double sqr(double in)
Definition: af_afwtdn.c:871
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
ThreadData::out
AVFrame * out
Definition: af_adeclick.c:526
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
ThreadData::in
AVFrame * in
Definition: af_adecorrelate.c:153
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
reallocate_outputs
static int reallocate_outputs(AudioFWTDNContext *s, double **out, int *out_length, int in_length, int levels, int ch, uint64_t sn)
Definition: af_afwtdn.c:566
sym2_ihp
static const double sym2_ihp[4]
Definition: af_afwtdn.c:371
M_LN2
#define M_LN2
Definition: mathematics.h:43
SYM4
@ SYM4
Definition: af_afwtdn.c:31
min_left_ext
static int min_left_ext(int wavelet_length, int levels)
Definition: af_afwtdn.c:1089
pow2
#define pow2(x)
Definition: af_afwtdn.c:463
conv_up
static void conv_up(double *low, double *high, int in_length, double *out, int out_length, const double *lp, const double *hp, int filter_length, double *buffer, double *buffer2, int buffer_length)
Definition: af_afwtdn.c:716
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(afwtdn)
FFSIGN
#define FFSIGN(a)
Definition: common.h:73
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:802
pts
static int64_t pts
Definition: transcode_aac.c:643
next_pow2
static int next_pow2(int in)
Definition: af_afwtdn.c:855
AudioFWTDNContext::nb_samples
int nb_samples
Definition: af_afwtdn.c:415
coif5_lp
static const double coif5_lp[30]
Definition: af_afwtdn.c:188
sym10_lp
static const double sym10_lp[20]
Definition: af_afwtdn.c:92
AudioFWTDNContext::sigma
double sigma
Definition: af_afwtdn.c:405
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
ChannelParams::buffer
double * buffer
Definition: af_afwtdn.c:396
coif5_ihp
static const double coif5_ihp[30]
Definition: af_afwtdn.c:242
avassert.h
lrint
#define lrint
Definition: tablegen.h:53
av_cold
#define av_cold
Definition: attributes.h:90
sym4_lp
static const double sym4_lp[8]
Definition: af_afwtdn.c:312
deb10_ilp
static const double deb10_ilp[20]
Definition: af_afwtdn.c:286
sym4_ihp
static const double sym4_ihp[8]
Definition: af_afwtdn.c:345
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
AudioFWTDNContext::eof_pts
int64_t eof_pts
Definition: af_afwtdn.c:410
s
#define s(width, name)
Definition: cbs_vp9.c:198
deb10_hp
static const double deb10_hp[20]
Definition: af_afwtdn.c:273
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
sym10_ilp
static const double sym10_ilp[20]
Definition: af_afwtdn.c:118
SYM10
@ SYM10
Definition: af_afwtdn.c:34
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
filters.h
rbior68_ihp
static const double rbior68_ihp[18]
Definition: af_afwtdn.c:178
AudioFWTDNContext::delay
int delay
Definition: af_afwtdn.c:422
noise_filter
static void noise_filter(const double stddev, const double *in, double *out, double absmean, double softness, double new_stddev, int length)
Definition: af_afwtdn.c:907
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_rescale_q
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
ChannelParams::prev
double * prev
Definition: af_afwtdn.c:398
AudioFWTDNContext::channels
int channels
Definition: af_afwtdn.c:414
AudioFWTDNContext::cp
ChannelParams * cp
Definition: af_afwtdn.c:427
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
arg
const char * arg
Definition: jacosubdec.c:67
sym2_lp
static const double sym2_lp[4]
Definition: af_afwtdn.c:356
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
rbior68_hp
static const double rbior68_hp[18]
Definition: af_afwtdn.c:154
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
denoise_level
static void denoise_level(double *out, const double *in, const double *filter, double percent, int length)
Definition: af_afwtdn.c:860
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1458
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
OFFSET
#define OFFSET(x)
Definition: af_afwtdn.c:438
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
sym4_hp
static const double sym4_hp[8]
Definition: af_afwtdn.c:323
ff_audio_default_filterpad
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
Definition: audio.c:33
AudioFWTDNContext
Definition: af_afwtdn.c:402
NB_WAVELET_TYPES
@ NB_WAVELET_TYPES
Definition: af_afwtdn.c:37
ff_af_afwtdn
const AVFilter ff_af_afwtdn
Definition: af_afwtdn.c:1303
exp
int8_t exp
Definition: eval.c:74
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1386
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_afwtdn.c:1004
sym10_ihp
static const double sym10_ihp[20]
Definition: af_afwtdn.c:131
AudioFWTDNContext::new_absmean
AVFrame * new_absmean
Definition: af_afwtdn.c:433
sym10_hp
static const double sym10_hp[20]
Definition: af_afwtdn.c:105
bl3_ihp
static const double bl3_ihp[42]
Definition: af_afwtdn.c:80
ChannelParams::tempd
double * tempd
Definition: af_afwtdn.c:394
ChannelParams::output_coefs
double ** output_coefs
Definition: af_afwtdn.c:381
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
AudioFWTDNContext::wavelet_length
int wavelet_length
Definition: af_afwtdn.c:417
shift
static int shift(int a, int b)
Definition: bonk.c:262
bl3_hp
static const double bl3_hp[42]
Definition: af_afwtdn.c:56
measure_stddev
static double measure_stddev(const double *in, int length, double mean)
Definition: af_afwtdn.c:896
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:567
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
BL3
@ BL3
Definition: af_afwtdn.c:36
AudioFWTDNContext::wavelet_type
int wavelet_type
Definition: af_afwtdn.c:413
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:879
MAX_LEVELS
#define MAX_LEVELS
Definition: af_afwtdn.c:376
AudioFWTDNContext::sn
uint64_t sn
Definition: af_afwtdn.c:409
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
forward
static int forward(AudioFWTDNContext *s, const double *in, int in_length, double **out, int *out_length, int ch, uint64_t sn)
Definition: af_afwtdn.c:619
max_left_ext
static int max_left_ext(int wavelet_length, int levels)
Definition: af_afwtdn.c:1084
ChannelParams::tempa_len_max
int tempa_len_max
Definition: af_afwtdn.c:386
AFR
#define AFR
Definition: af_afwtdn.c:440
AudioFWTDNContext::prev_length
int prev_length
Definition: af_afwtdn.c:426
deb10_ihp
static const double deb10_ihp[20]
Definition: af_afwtdn.c:299
AF
#define AF
Definition: af_afwtdn.c:439
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
ChannelParams::temp_in
double * temp_in
Definition: af_afwtdn.c:395
ThreadData
Used for passing data between threads.
Definition: dsddec.c:69
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
discard_left_ext
static int discard_left_ext(int wavelet_length, int levels, int level, uint64_t sn)
Definition: af_afwtdn.c:612
ChannelParams
sample data coding information
Definition: mlp.h:97
ChannelParams::tempa_length
int tempa_length
Definition: af_afwtdn.c:385
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
bl3_ilp
static const double bl3_ilp[42]
Definition: af_afwtdn.c:68
AudioFWTDNContext::need_profile
int need_profile
Definition: af_afwtdn.c:418
conv_down
static void conv_down(double *in, int in_length, double *low, double *high, int out_length, const double *lp, const double *hp, int wavelet_length, int skip, double *buffer, int buffer_length)
Definition: af_afwtdn.c:466
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AudioFWTDNContext::drop_samples
int drop_samples
Definition: af_afwtdn.c:423
AudioFWTDNContext::ilp
const double * ilp
Definition: af_afwtdn.c:430
rbior68_lp
static const double rbior68_lp[18]
Definition: af_afwtdn.c:144
AudioFWTDNContext::filter_channel
int(* filter_channel)(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
Definition: af_afwtdn.c:435
AVFilter
Filter definition.
Definition: avfilter.h:166
AudioFWTDNContext::filter
AVFrame * filter
Definition: af_afwtdn.c:432
AudioFWTDNContext::eof
int eof
Definition: af_afwtdn.c:411
sym2_hp
static const double sym2_hp[4]
Definition: af_afwtdn.c:361
ret
ret
Definition: filter_design.txt:187
sym2_ilp
static const double sym2_ilp[4]
Definition: af_afwtdn.c:366
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
ChannelParams::buffer_length
int buffer_length
Definition: af_afwtdn.c:389
DEB10
@ DEB10
Definition: af_afwtdn.c:33
left_ext
static int left_ext(int wavelet_length, int levels, uint64_t sn)
Definition: af_afwtdn.c:507
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_afwtdn.c:1237
rbior68_ilp
static const double rbior68_ilp[18]
Definition: af_afwtdn.c:166
ChannelParams::subbands_to_free
double ** subbands_to_free
Definition: af_afwtdn.c:382
status
ov_status_e status
Definition: dnn_backend_openvino.c:120
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_afwtdn.c:1094
measure_mean
static double measure_mean(const double *in, int length)
Definition: af_afwtdn.c:876
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
outputs
static const AVFilterPad outputs[]
Definition: af_afwtdn.c:1295
AudioFWTDNContext::stddev
AVFrame * stddev
Definition: af_afwtdn.c:432
ChannelParams::max_left_ext
int max_left_ext
Definition: af_afwtdn.c:391
inverse
static int inverse(AudioFWTDNContext *s, double **in, int *in_length, double *out, int out_length, int ch, uint64_t sn)
Definition: af_afwtdn.c:761
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
max_left_zeros_inverse
static int max_left_zeros_inverse(int levels, int level, int wavelet_length)
Definition: af_afwtdn.c:561
append_left_ext
static int append_left_ext(int wavelet_length, int levels, int level, uint64_t sn)
Definition: af_afwtdn.c:752
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
WaveletTypes
WaveletTypes
Definition: af_afwtdn.c:29
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:862
deb10_lp
static const double deb10_lp[20]
Definition: af_afwtdn.c:260
AVFilterContext
An instance of a filter.
Definition: avfilter.h:409
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
AudioFWTDNContext::ihp
const double * ihp
Definition: af_afwtdn.c:430
audio.h
ChannelParams::filter_coefs
double ** filter_coefs
Definition: af_afwtdn.c:383
ChannelParams::filter_length
int * filter_length
Definition: af_afwtdn.c:380
FF_FILTER_FORWARD_STATUS
FF_FILTER_FORWARD_STATUS(inlink, outlink)
AudioFWTDNContext::lp
const double * lp
Definition: af_afwtdn.c:429
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
reallocate_inputs
static int reallocate_inputs(double **out, int *out_length, int in_length, int levels, int ch, uint64_t sn)
Definition: af_afwtdn.c:521
bl3_lp
static const double bl3_lp[42]
Definition: af_afwtdn.c:44
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:155
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AudioFWTDNContext::percent
double percent
Definition: af_afwtdn.c:406
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
afwtdn_options
static const AVOption afwtdn_options[]
Definition: af_afwtdn.c:442
COIF5
@ COIF5
Definition: af_afwtdn.c:35
ChannelParams::temp_in_max_length
int temp_in_max_length
Definition: af_afwtdn.c:388
activate
static int activate(AVFilterContext *ctx)
Definition: af_afwtdn.c:1201
RBIOR68
@ RBIOR68
Definition: af_afwtdn.c:32
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_afwtdn.c:1279
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:134
int
int
Definition: ffmpeg_filter.c:424
measure_absmean
static double measure_absmean(const double *in, int length)
Definition: af_afwtdn.c:886
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
mod_pow2
#define mod_pow2(x, power_of_two)
Definition: af_afwtdn.c:464
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
AudioFWTDNContext::overlap_length
int overlap_length
Definition: af_afwtdn.c:425
ChannelParams::buffer2
double * buffer2
Definition: af_afwtdn.c:397
AudioFWTDNContext::softness
double softness
Definition: af_afwtdn.c:407