FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/af_afwtdn.c
Date: 2022-12-05 03:11:11
Exec Total Coverage
Lines: 0 532 0.0%
Functions: 0 26 0.0%
Branches: 0 254 0.0%

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