FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2013 Paul B Mahol
3			* Copyright (c) 2006-2008 Rob Sykes <robs@users.sourceforge.net>
4			*
5			* This file is part of FFmpeg.
6			*
7			* FFmpeg is free software; you can redistribute it and/or
8			* modify it under the terms of the GNU Lesser General Public
9			* License as published by the Free Software Foundation; either
10			* version 2.1 of the License, or (at your option) any later version.
11			*
12			* FFmpeg is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15			* Lesser General Public License for more details.
16			*
17			* You should have received a copy of the GNU Lesser General Public
18			* License along with FFmpeg; if not, write to the Free Software
19			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20			*/
21
22			/*
23			* 2-pole filters designed by Robert Bristow-Johnson <rbj@audioimagination.com>
24			* see http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
25			*
26			* 1-pole filters based on code (c) 2000 Chris Bagwell <cbagwell@sprynet.com>
27			* Algorithms: Recursive single pole low/high pass filter
28			* Reference: The Scientist and Engineer's Guide to Digital Signal Processing
29			*
30			* low-pass: output[N] = input[N] * A + output[N-1] * B
31			* X = exp(-2.0 * pi * Fc)
32			* A = 1 - X
33			* B = X
34			* Fc = cutoff freq / sample rate
35			*
36			* Mimics an RC low-pass filter:
37			*
38			* ---/\/\/\/\----------->
39			* |
40			* --- C
41			* ---
42			* |
43			* |
44			* V
45			*
46			* high-pass: output[N] = A0 * input[N] + A1 * input[N-1] + B1 * output[N-1]
47			* X = exp(-2.0 * pi * Fc)
48			* A0 = (1 + X) / 2
49			* A1 = -(1 + X) / 2
50			* B1 = X
51			* Fc = cutoff freq / sample rate
52			*
53			* Mimics an RC high-pass filter:
54			*
55			* || C
56			* ----||--------->
57			* || |
58			* <
59			* > R
60			* <
61			* |
62			* V
63			*/
64
65			#include "config_components.h"
66
67			#include "libavutil/avassert.h"
68			#include "libavutil/channel_layout.h"
69			#include "libavutil/ffmath.h"
70			#include "libavutil/mem.h"
71			#include "libavutil/opt.h"
72			#include "audio.h"
73			#include "avfilter.h"
74			#include "filters.h"
75			#include "formats.h"
76			#include "internal.h"
77
78			enum FilterType {
79			biquad,
80			equalizer,
81			bass,
82			treble,
83			bandpass,
84			bandreject,
85			allpass,
86			highpass,
87			lowpass,
88			lowshelf,
89			highshelf,
90			tiltshelf,
91			};
92
93			enum WidthType {
94			NONE,
95			HERTZ,
96			OCTAVE,
97			QFACTOR,
98			SLOPE,
99			KHERTZ,
100			NB_WTYPE,
101			};
102
103			enum TransformType {
104			DI,
105			DII,
106			TDI,
107			TDII,
108			LATT,
109			SVF,
110			ZDF,
111			NB_TTYPE,
112			};
113
114			typedef struct BiquadsContext {
115			const AVClass *class;
116
117			enum FilterType filter_type;
118			int width_type;
119			int poles;
120			int csg;
121			int transform_type;
122			int precision;
123			int block_samples;
124
125			int bypass;
126
127			double gain;
128			double frequency;
129			double width;
130			double mix;
131			char *ch_layout_str;
132			AVChannelLayout ch_layout;
133			int normalize;
134			int order;
135
136			double a_double[3];
137			double b_double[3];
138
139			float a_float[3];
140			float b_float[3];
141
142			double oa[3];
143			double ob[3];
144
145			AVFrame *block[3];
146
147			int *clip;
148			AVFrame *cache[2];
149			int block_align;
150
151			int64_t pts;
152			int nb_samples;
153
154			void (*filter)(struct BiquadsContext *s, const void *ibuf, void *obuf, int len,
155			void *cache, int *clip, int disabled);
156			} BiquadsContext;
157
158		✗	static int query_formats(AVFilterContext *ctx)
159			{
160		✗	BiquadsContext *s = ctx->priv;
161			static const enum AVSampleFormat auto_sample_fmts[] = {
162			AV_SAMPLE_FMT_S16P,
163			AV_SAMPLE_FMT_S32P,
164			AV_SAMPLE_FMT_FLTP,
165			AV_SAMPLE_FMT_DBLP,
166			AV_SAMPLE_FMT_NONE
167			};
168		✗	enum AVSampleFormat sample_fmts[] = {
169			AV_SAMPLE_FMT_S16P,
170			AV_SAMPLE_FMT_NONE
171			};
172		✗	const enum AVSampleFormat *sample_fmts_list = sample_fmts;
173		✗	int ret = ff_set_common_all_channel_counts(ctx);
174		✗	if (ret < 0)
175		✗	return ret;
176
177		✗	switch (s->precision) {
178		✗	case 0:
179		✗	sample_fmts[0] = AV_SAMPLE_FMT_S16P;
180		✗	break;
181		✗	case 1:
182		✗	sample_fmts[0] = AV_SAMPLE_FMT_S32P;
183		✗	break;
184		✗	case 2:
185		✗	sample_fmts[0] = AV_SAMPLE_FMT_FLTP;
186		✗	break;
187		✗	case 3:
188		✗	sample_fmts[0] = AV_SAMPLE_FMT_DBLP;
189		✗	break;
190		✗	default:
191		✗	sample_fmts_list = auto_sample_fmts;
192		✗	break;
193			}
194		✗	ret = ff_set_common_formats_from_list(ctx, sample_fmts_list);
195		✗	if (ret < 0)
196		✗	return ret;
197
198		✗	return ff_set_common_all_samplerates(ctx);
199			}
200
201			#define BIQUAD_FILTER(name, type, ftype, min, max, need_clipping) \
202			static void biquad_## name (BiquadsContext *s, \
203			const void *input, void *output, int len, \
204			void *cache, int *clippings, int disabled) \
205			{ \
206			const type *ibuf = input; \
207			type *obuf = output; \
208			ftype *fcache = cache; \
209			ftype i1 = fcache[0], i2 = fcache[1], o1 = fcache[2], o2 = fcache[3]; \
210			ftype *a = s->a_##ftype; \
211			ftype *b = s->b_##ftype; \
212			ftype a1 = -a[1]; \
213			ftype a2 = -a[2]; \
214			ftype b0 = b[0]; \
215			ftype b1 = b[1]; \
216			ftype b2 = b[2]; \
217			ftype wet = s->mix; \
218			ftype dry = 1. - wet; \
219			ftype out; \
220			int i; \
221			\
222			for (i = 0; i+1 < len; i++) { \
223			o2 = i2 * b2 + i1 * b1 + ibuf[i] * b0 + o2 * a2 + o1 * a1; \
224			i2 = ibuf[i]; \
225			out = o2 * wet + i2 * dry; \
226			if (disabled) { \
227			obuf[i] = i2; \
228			} else if (need_clipping && out < min) { \
229			(*clippings)++; \
230			obuf[i] = min; \
231			} else if (need_clipping && out > max) { \
232			(*clippings)++; \
233			obuf[i] = max; \
234			} else { \
235			obuf[i] = out; \
236			} \
237			i++; \
238			o1 = i1 * b2 + i2 * b1 + ibuf[i] * b0 + o1 * a2 + o2 * a1; \
239			i1 = ibuf[i]; \
240			out = o1 * wet + i1 * dry; \
241			if (disabled) { \
242			obuf[i] = i1; \
243			} else if (need_clipping && out < min) { \
244			(*clippings)++; \
245			obuf[i] = min; \
246			} else if (need_clipping && out > max) { \
247			(*clippings)++; \
248			obuf[i] = max; \
249			} else { \
250			obuf[i] = out; \
251			} \
252			} \
253			if (i < len) { \
254			ftype o0 = ibuf[i] * b0 + i1 * b1 + i2 * b2 + o1 * a1 + o2 * a2; \
255			i2 = i1; \
256			i1 = ibuf[i]; \
257			o2 = o1; \
258			o1 = o0; \
259			out = o0 * wet + i1 * dry; \
260			if (disabled) { \
261			obuf[i] = i1; \
262			} else if (need_clipping && out < min) { \
263			(*clippings)++; \
264			obuf[i] = min; \
265			} else if (need_clipping && out > max) { \
266			(*clippings)++; \
267			obuf[i] = max; \
268			} else { \
269			obuf[i] = out; \
270			} \
271			} \
272			fcache[0] = i1; \
273			fcache[1] = i2; \
274			fcache[2] = o1; \
275			fcache[3] = o2; \
276			}
277
278		✗	BIQUAD_FILTER(s16, int16_t, float, INT16_MIN, INT16_MAX, 1)
279		✗	BIQUAD_FILTER(s32, int32_t, double, INT32_MIN, INT32_MAX, 1)
280		✗	BIQUAD_FILTER(flt, float, float, -1.f, 1.f, 0)
281		✗	BIQUAD_FILTER(dbl, double, double, -1., 1., 0)
282
283			#define BIQUAD_DII_FILTER(name, type, ftype, min, max, need_clipping) \
284			static void biquad_dii_## name (BiquadsContext *s, \
285			const void *input, void *output, int len, \
286			void *cache, int *clippings, int disabled) \
287			{ \
288			const type *ibuf = input; \
289			type *obuf = output; \
290			ftype *fcache = cache; \
291			ftype *a = s->a_##ftype; \
292			ftype *b = s->b_##ftype; \
293			ftype a1 = -a[1]; \
294			ftype a2 = -a[2]; \
295			ftype b0 = b[0]; \
296			ftype b1 = b[1]; \
297			ftype b2 = b[2]; \
298			ftype w1 = fcache[0]; \
299			ftype w2 = fcache[1]; \
300			ftype wet = s->mix; \
301			ftype dry = 1. - wet; \
302			ftype in, out, w0; \
303			\
304			for (int i = 0; i < len; i++) { \
305			in = ibuf[i]; \
306			w0 = in + a1 * w1 + a2 * w2; \
307			out = b0 * w0 + b1 * w1 + b2 * w2; \
308			w2 = w1; \
309			w1 = w0; \
310			out = out * wet + in * dry; \
311			if (disabled) { \
312			obuf[i] = in; \
313			} else if (need_clipping && out < min) { \
314			(*clippings)++; \
315			obuf[i] = min; \
316			} else if (need_clipping && out > max) { \
317			(*clippings)++; \
318			obuf[i] = max; \
319			} else { \
320			obuf[i] = out; \
321			} \
322			} \
323			fcache[0] = w1; \
324			fcache[1] = w2; \
325			}
326
327		✗	BIQUAD_DII_FILTER(s16, int16_t, float, INT16_MIN, INT16_MAX, 1)
328		✗	BIQUAD_DII_FILTER(s32, int32_t, double, INT32_MIN, INT32_MAX, 1)
329		✗	BIQUAD_DII_FILTER(flt, float, float, -1.f, 1.f, 0)
330		✗	BIQUAD_DII_FILTER(dbl, double, double, -1., 1., 0)
331
332			#define BIQUAD_TDI_FILTER(name, type, ftype, min, max, need_clipping) \
333			static void biquad_tdi_## name (BiquadsContext *s, \
334			const void *input, void *output, int len, \
335			void *cache, int *clippings, int disabled) \
336			{ \
337			const type *ibuf = input; \
338			type *obuf = output; \
339			ftype *fcache = cache; \
340			ftype *a = s->a_##ftype; \
341			ftype *b = s->b_##ftype; \
342			ftype a1 = -a[1]; \
343			ftype a2 = -a[2]; \
344			ftype b0 = b[0]; \
345			ftype b1 = b[1]; \
346			ftype b2 = b[2]; \
347			ftype s1 = fcache[0]; \
348			ftype s2 = fcache[1]; \
349			ftype s3 = fcache[2]; \
350			ftype s4 = fcache[3]; \
351			ftype wet = s->mix; \
352			ftype dry = 1. - wet; \
353			ftype in, out; \
354			\
355			for (int i = 0; i < len; i++) { \
356			ftype t1, t2, t3, t4; \
357			in = ibuf[i] + s1; \
358			t1 = in * a1 + s2; \
359			t2 = in * a2; \
360			t3 = in * b1 + s4; \
361			t4 = in * b2; \
362			out = b0 * in + s3; \
363			out = out * wet + in * dry; \
364			s1 = t1; s2 = t2; s3 = t3; s4 = t4; \
365			if (disabled) { \
366			obuf[i] = in; \
367			} else if (need_clipping && out < min) { \
368			(*clippings)++; \
369			obuf[i] = min; \
370			} else if (need_clipping && out > max) { \
371			(*clippings)++; \
372			obuf[i] = max; \
373			} else { \
374			obuf[i] = out; \
375			} \
376			} \
377			\
378			fcache[0] = s1; \
379			fcache[1] = s2; \
380			fcache[2] = s3; \
381			fcache[3] = s4; \
382			}
383
384		✗	BIQUAD_TDI_FILTER(s16, int16_t, float, INT16_MIN, INT16_MAX, 1)
385		✗	BIQUAD_TDI_FILTER(s32, int32_t, double, INT32_MIN, INT32_MAX, 1)
386		✗	BIQUAD_TDI_FILTER(flt, float, float, -1.f, 1.f, 0)
387		✗	BIQUAD_TDI_FILTER(dbl, double, double, -1., 1., 0)
388
389			#define BIQUAD_TDII_FILTER(name, type, ftype, min, max, need_clipping) \
390			static void biquad_tdii_## name (BiquadsContext *s, \
391			const void *input, void *output, int len, \
392			void *cache, int *clippings, int disabled) \
393			{ \
394			const type *ibuf = input; \
395			type *obuf = output; \
396			ftype *fcache = cache; \
397			ftype *a = s->a_##ftype; \
398			ftype *b = s->b_##ftype; \
399			ftype a1 = -a[1]; \
400			ftype a2 = -a[2]; \
401			ftype b0 = b[0]; \
402			ftype b1 = b[1]; \
403			ftype b2 = b[2]; \
404			ftype w1 = fcache[0]; \
405			ftype w2 = fcache[1]; \
406			ftype wet = s->mix; \
407			ftype dry = 1. - wet; \
408			ftype in, out; \
409			\
410			for (int i = 0; i < len; i++) { \
411			in = ibuf[i]; \
412			out = b0 * in + w1; \
413			w1 = b1 * in + w2 + a1 * out; \
414			w2 = b2 * in + a2 * out; \
415			out = out * wet + in * dry; \
416			if (disabled) { \
417			obuf[i] = in; \
418			} else if (need_clipping && out < min) { \
419			(*clippings)++; \
420			obuf[i] = min; \
421			} else if (need_clipping && out > max) { \
422			(*clippings)++; \
423			obuf[i] = max; \
424			} else { \
425			obuf[i] = out; \
426			} \
427			} \
428			fcache[0] = w1; \
429			fcache[1] = w2; \
430			}
431
432		✗	BIQUAD_TDII_FILTER(s16, int16_t, float, INT16_MIN, INT16_MAX, 1)
433		✗	BIQUAD_TDII_FILTER(s32, int32_t, double, INT32_MIN, INT32_MAX, 1)
434		✗	BIQUAD_TDII_FILTER(flt, float, float, -1.f, 1.f, 0)
435		✗	BIQUAD_TDII_FILTER(dbl, double, double, -1., 1., 0)
436
437			#define BIQUAD_LATT_FILTER(name, type, ftype, min, max, need_clipping) \
438			static void biquad_latt_## name (BiquadsContext *s, \
439			const void *input, void *output, int len, \
440			void *cache, int *clippings, int disabled) \
441			{ \
442			const type *ibuf = input; \
443			type *obuf = output; \
444			ftype *fcache = cache; \
445			ftype *a = s->a_##ftype; \
446			ftype *b = s->b_##ftype; \
447			ftype k0 = a[1]; \
448			ftype k1 = a[2]; \
449			ftype v0 = b[0]; \
450			ftype v1 = b[1]; \
451			ftype v2 = b[2]; \
452			ftype s0 = fcache[0]; \
453			ftype s1 = fcache[1]; \
454			ftype wet = s->mix; \
455			ftype dry = 1. - wet; \
456			ftype in, out; \
457			ftype t0, t1; \
458			\
459			for (int i = 0; i < len; i++) { \
460			out = 0.; \
461			in = ibuf[i]; \
462			t0 = in - k1 * s0; \
463			t1 = t0 * k1 + s0; \
464			out += t1 * v2; \
465			\
466			t0 = t0 - k0 * s1; \
467			t1 = t0 * k0 + s1; \
468			out += t1 * v1; \
469			\
470			out += t0 * v0; \
471			s0 = t1; \
472			s1 = t0; \
473			\
474			out = out * wet + in * dry; \
475			if (disabled) { \
476			obuf[i] = in; \
477			} else if (need_clipping && out < min) { \
478			(*clippings)++; \
479			obuf[i] = min; \
480			} else if (need_clipping && out > max) { \
481			(*clippings)++; \
482			obuf[i] = max; \
483			} else { \
484			obuf[i] = out; \
485			} \
486			} \
487			fcache[0] = s0; \
488			fcache[1] = s1; \
489			}
490
491		✗	BIQUAD_LATT_FILTER(s16, int16_t, float, INT16_MIN, INT16_MAX, 1)
492		✗	BIQUAD_LATT_FILTER(s32, int32_t, double, INT32_MIN, INT32_MAX, 1)
493		✗	BIQUAD_LATT_FILTER(flt, float, float, -1.f, 1.f, 0)
494		✗	BIQUAD_LATT_FILTER(dbl, double, double, -1., 1., 0)
495
496			#define BIQUAD_SVF_FILTER(name, type, ftype, min, max, need_clipping) \
497			static void biquad_svf_## name (BiquadsContext *s, \
498			const void *input, void *output, int len, \
499			void *cache, int *clippings, int disabled) \
500			{ \
501			const type *ibuf = input; \
502			type *obuf = output; \
503			ftype *fcache = cache; \
504			ftype *a = s->a_##ftype; \
505			ftype *b = s->b_##ftype; \
506			ftype a1 = a[1]; \
507			ftype a2 = a[2]; \
508			ftype b0 = b[0]; \
509			ftype b1 = b[1]; \
510			ftype b2 = b[2]; \
511			ftype s0 = fcache[0]; \
512			ftype s1 = fcache[1]; \
513			ftype wet = s->mix; \
514			ftype dry = 1. - wet; \
515			ftype in, out; \
516			ftype t0, t1; \
517			\
518			for (int i = 0; i < len; i++) { \
519			in = ibuf[i]; \
520			out = b2 * in + s0; \
521			t0 = b0 * in + a1 * s0 + s1; \
522			t1 = b1 * in + a2 * s0; \
523			s0 = t0; \
524			s1 = t1; \
525			\
526			out = out * wet + in * dry; \
527			if (disabled) { \
528			obuf[i] = in; \
529			} else if (need_clipping && out < min) { \
530			(*clippings)++; \
531			obuf[i] = min; \
532			} else if (need_clipping && out > max) { \
533			(*clippings)++; \
534			obuf[i] = max; \
535			} else { \
536			obuf[i] = out; \
537			} \
538			} \
539			fcache[0] = s0; \
540			fcache[1] = s1; \
541			}
542
543		✗	BIQUAD_SVF_FILTER(s16, int16_t, float, INT16_MIN, INT16_MAX, 1)
544		✗	BIQUAD_SVF_FILTER(s32, int32_t, double, INT32_MIN, INT32_MAX, 1)
545		✗	BIQUAD_SVF_FILTER(flt, float, float, -1.f, 1.f, 0)
546		✗	BIQUAD_SVF_FILTER(dbl, double, double, -1., 1., 0)
547
548			#define BIQUAD_ZDF_FILTER(name, type, ftype, min, max, need_clipping, two) \
549			static void biquad_zdf_## name (BiquadsContext *s, \
550			const void *input, void *output, int len, \
551			void *cache, int *clippings, int disabled) \
552			{ \
553			const type *ibuf = input; \
554			type *obuf = output; \
555			ftype *fcache = cache; \
556			ftype *a = s->a_##ftype; \
557			ftype *b = s->b_##ftype; \
558			ftype m0 = b[0]; \
559			ftype m1 = b[1]; \
560			ftype m2 = b[2]; \
561			ftype a0 = a[0]; \
562			ftype a1 = a[1]; \
563			ftype a2 = a[2]; \
564			ftype b0 = fcache[0]; \
565			ftype b1 = fcache[1]; \
566			ftype wet = s->mix; \
567			ftype dry = 1. - wet; \
568			ftype out; \
569			\
570			for (int i = 0; i < len; i++) { \
571			const ftype in = ibuf[i]; \
572			const ftype v0 = in; \
573			const ftype v3 = v0 - b1; \
574			const ftype v1 = a0 * b0 + a1 * v3; \
575			const ftype v2 = b1 + a1 * b0 + a2 * v3; \
576			\
577			b0 = two * v1 - b0; \
578			b1 = two * v2 - b1; \
579			\
580			out = m0 * v0 + m1 * v1 + m2 * v2; \
581			out = out * wet + in * dry; \
582			if (disabled) { \
583			obuf[i] = in; \
584			} else if (need_clipping && out < min) { \
585			(*clippings)++; \
586			obuf[i] = min; \
587			} else if (need_clipping && out > max) { \
588			(*clippings)++; \
589			obuf[i] = max; \
590			} else { \
591			obuf[i] = out; \
592			} \
593			} \
594			fcache[0] = b0; \
595			fcache[1] = b1; \
596			}
597
598		✗	BIQUAD_ZDF_FILTER(s16, int16_t, float, INT16_MIN, INT16_MAX, 1, 2.f)
599		✗	BIQUAD_ZDF_FILTER(s32, int32_t, double, INT32_MIN, INT32_MAX, 1, 2.0)
600		✗	BIQUAD_ZDF_FILTER(flt, float, float, -1.f, 1.f, 0, 2.f)
601		✗	BIQUAD_ZDF_FILTER(dbl, double, double, -1., 1., 0, 2.0)
602
603		✗	static void convert_dir2latt(BiquadsContext *s)
604			{
605			double k0, k1, v0, v1, v2;
606
607		✗	k1 = s->a_double[2];
608		✗	k0 = s->a_double[1] / (1. + k1);
609		✗	v2 = s->b_double[2];
610		✗	v1 = s->b_double[1] - v2 * s->a_double[1];
611		✗	v0 = s->b_double[0] - v1 * k0 - v2 * k1;
612
613		✗	s->a_double[1] = k0;
614		✗	s->a_double[2] = k1;
615		✗	s->b_double[0] = v0;
616		✗	s->b_double[1] = v1;
617		✗	s->b_double[2] = v2;
618		✗	}
619
620		✗	static void convert_dir2svf(BiquadsContext *s)
621			{
622			double a[2];
623			double b[3];
624
625		✗	a[0] = -s->a_double[1];
626		✗	a[1] = -s->a_double[2];
627		✗	b[0] = s->b_double[1] - s->a_double[1] * s->b_double[0];
628		✗	b[1] = s->b_double[2] - s->a_double[2] * s->b_double[0];
629		✗	b[2] = s->b_double[0];
630
631		✗	s->a_double[1] = a[0];
632		✗	s->a_double[2] = a[1];
633		✗	s->b_double[0] = b[0];
634		✗	s->b_double[1] = b[1];
635		✗	s->b_double[2] = b[2];
636		✗	}
637
638		✗	static double convert_width2qfactor(double width,
639			double frequency,
640			double gain,
641			double sample_rate,
642			int width_type)
643			{
644		✗	double w0 = 2. * M_PI * frequency / sample_rate;
645		✗	double A = ff_exp10(gain / 40.);
646			double ret;
647
648		✗	switch (width_type) {
649		✗	case NONE:
650			case QFACTOR:
651		✗	ret = width;
652		✗	break;
653		✗	case HERTZ:
654		✗	ret = frequency / width;
655		✗	break;
656		✗	case KHERTZ:
657		✗	ret = frequency / (width * 1000.);
658		✗	break;
659		✗	case OCTAVE:
660		✗	ret = 1. / (2. * sinh(log(2.) / 2. * width * w0 / sin(w0)));
661		✗	break;
662		✗	case SLOPE:
663		✗	ret = 1. / sqrt((A + 1. / A) * (1. / width - 1.) + 2.);
664		✗	break;
665		✗	default:
666		✗	av_assert0(0);
667			break;
668			}
669
670		✗	return ret;
671			}
672
673		✗	static void convert_dir2zdf(BiquadsContext *s, int sample_rate)
674			{
675		✗	double Q = convert_width2qfactor(s->width, s->frequency, s->gain, sample_rate, s->width_type);
676			double g, k, A;
677			double a[3];
678			double m[3];
679
680		✗	switch (s->filter_type) {
681		✗	case biquad:
682		✗	a[0] = s->oa[0];
683		✗	a[1] = s->oa[1];
684		✗	a[2] = s->oa[2];
685		✗	m[0] = s->ob[0];
686		✗	m[1] = s->ob[1];
687		✗	m[2] = s->ob[2];
688		✗	break;
689		✗	case equalizer:
690		✗	A = ff_exp10(s->gain / 40.);
691		✗	g = tan(M_PI * s->frequency / sample_rate);
692		✗	k = 1. / (Q * A);
693		✗	a[0] = 1. / (1. + g * (g + k));
694		✗	a[1] = g * a[0];
695		✗	a[2] = g * a[1];
696		✗	m[0] = 1.;
697		✗	m[1] = k * (A * A - 1.);
698		✗	m[2] = 0.;
699		✗	break;
700		✗	case bass:
701			case lowshelf:
702		✗	A = ff_exp10(s->gain / 40.);
703		✗	g = tan(M_PI * s->frequency / sample_rate) / sqrt(A);
704		✗	k = 1. / Q;
705		✗	a[0] = 1. / (1. + g * (g + k));
706		✗	a[1] = g * a[0];
707		✗	a[2] = g * a[1];
708		✗	m[0] = 1.;
709		✗	m[1] = k * (A - 1.);
710		✗	m[2] = A * A - 1.;
711		✗	break;
712		✗	case tiltshelf:
713		✗	A = ff_exp10(s->gain / 20.);
714		✗	g = tan(M_PI * s->frequency / sample_rate) / sqrt(A);
715		✗	k = 1. / Q;
716		✗	a[0] = 1. / (1. + g * (g + k));
717		✗	a[1] = g * a[0];
718		✗	a[2] = g * a[1];
719		✗	m[0] = 1./ A;
720		✗	m[1] = k * (A - 1.) / A;
721		✗	m[2] = (A * A - 1.) / A;
722		✗	break;
723		✗	case treble:
724			case highshelf:
725		✗	A = ff_exp10(s->gain / 40.);
726		✗	g = tan(M_PI * s->frequency / sample_rate) * sqrt(A);
727		✗	k = 1. / Q;
728		✗	a[0] = 1. / (1. + g * (g + k));
729		✗	a[1] = g * a[0];
730		✗	a[2] = g * a[1];
731		✗	m[0] = A * A;
732		✗	m[1] = k * (1. - A) * A;
733		✗	m[2] = 1. - A * A;
734		✗	break;
735		✗	case bandpass:
736		✗	g = tan(M_PI * s->frequency / sample_rate);
737		✗	k = 1. / Q;
738		✗	a[0] = 1. / (1. + g * (g + k));
739		✗	a[1] = g * a[0];
740		✗	a[2] = g * a[1];
741		✗	m[0] = 0.;
742		✗	m[1] = s->csg ? 1. : k;
743		✗	m[2] = 0.;
744		✗	break;
745		✗	case bandreject:
746		✗	g = tan(M_PI * s->frequency / sample_rate);
747		✗	k = 1. / Q;
748		✗	a[0] = 1. / (1. + g * (g + k));
749		✗	a[1] = g * a[0];
750		✗	a[2] = g * a[1];
751		✗	m[0] = 1.;
752		✗	m[1] = -k;
753		✗	m[2] = 0.;
754		✗	break;
755		✗	case lowpass:
756		✗	g = tan(M_PI * s->frequency / sample_rate);
757		✗	k = 1. / Q;
758		✗	a[0] = 1. / (1. + g * (g + k));
759		✗	a[1] = g * a[0];
760		✗	a[2] = g * a[1];
761		✗	m[0] = 0.;
762		✗	m[1] = 0.;
763		✗	m[2] = 1.;
764		✗	break;
765		✗	case highpass:
766		✗	g = tan(M_PI * s->frequency / sample_rate);
767		✗	k = 1. / Q;
768		✗	a[0] = 1. / (1. + g * (g + k));
769		✗	a[1] = g * a[0];
770		✗	a[2] = g * a[1];
771		✗	m[0] = 1.;
772		✗	m[1] = -k;
773		✗	m[2] = -1.;
774		✗	break;
775		✗	case allpass:
776		✗	g = tan(M_PI * s->frequency / sample_rate);
777		✗	k = 1. / Q;
778		✗	a[0] = 1. / (1. + g * (g + k));
779		✗	a[1] = g * a[0];
780		✗	a[2] = g * a[1];
781		✗	m[0] = 1.;
782		✗	m[1] = -2. * k;
783		✗	m[2] = 0.;
784		✗	break;
785		✗	default:
786		✗	av_assert0(0);
787			}
788
789		✗	s->a_double[0] = a[0];
790		✗	s->a_double[1] = a[1];
791		✗	s->a_double[2] = a[2];
792		✗	s->b_double[0] = m[0];
793		✗	s->b_double[1] = m[1];
794		✗	s->b_double[2] = m[2];
795		✗	}
796
797		✗	static int config_filter(AVFilterLink *outlink, int reset)
798			{
799		✗	AVFilterContext *ctx = outlink->src;
800		✗	BiquadsContext *s = ctx->priv;
801		✗	AVFilterLink *inlink = ctx->inputs[0];
802		✗	double gain = s->gain * ((s->filter_type == tiltshelf) + 1.);
803		✗	double A = ff_exp10(gain / 40);
804		✗	double w0 = 2 * M_PI * s->frequency / inlink->sample_rate;
805		✗	double K = tan(w0 / 2.);
806			double alpha, beta;
807
808		✗	s->bypass = (((w0 > M_PI || w0 <= 0.) && reset) || (s->width <= 0.)) && (s->filter_type != biquad);
809		✗	if (s->bypass) {
810		✗	av_log(ctx, AV_LOG_WARNING, "Invalid frequency and/or width!\n");
811		✗	return 0;
812			}
813
814		✗	if ((w0 > M_PI || w0 <= 0.) && (s->filter_type != biquad))
815		✗	return AVERROR(EINVAL);
816
817		✗	switch (s->width_type) {
818		✗	case NONE:
819		✗	alpha = 0.0;
820		✗	break;
821		✗	case HERTZ:
822		✗	alpha = sin(w0) / (2 * s->frequency / s->width);
823		✗	break;
824		✗	case KHERTZ:
825		✗	alpha = sin(w0) / (2 * s->frequency / (s->width * 1000));
826		✗	break;
827		✗	case OCTAVE:
828		✗	alpha = sin(w0) * sinh(log(2.) / 2 * s->width * w0 / sin(w0));
829		✗	break;
830		✗	case QFACTOR:
831		✗	alpha = sin(w0) / (2 * s->width);
832		✗	break;
833		✗	case SLOPE:
834		✗	alpha = sin(w0) / 2 * sqrt((A + 1 / A) * (1 / s->width - 1) + 2);
835		✗	break;
836		✗	default:
837		✗	av_assert0(0);
838			}
839
840		✗	beta = 2 * sqrt(A);
841
842		✗	switch (s->filter_type) {
843		✗	case biquad:
844		✗	s->a_double[0] = s->oa[0];
845		✗	s->a_double[1] = s->oa[1];
846		✗	s->a_double[2] = s->oa[2];
847		✗	s->b_double[0] = s->ob[0];
848		✗	s->b_double[1] = s->ob[1];
849		✗	s->b_double[2] = s->ob[2];
850		✗	break;
851		✗	case equalizer:
852		✗	s->a_double[0] = 1 + alpha / A;
853		✗	s->a_double[1] = -2 * cos(w0);
854		✗	s->a_double[2] = 1 - alpha / A;
855		✗	s->b_double[0] = 1 + alpha * A;
856		✗	s->b_double[1] = -2 * cos(w0);
857		✗	s->b_double[2] = 1 - alpha * A;
858		✗	break;
859		✗	case bass:
860		✗	beta = sqrt((A * A + 1) - (A - 1) * (A - 1));
861		✗	case tiltshelf:
862			case lowshelf:
863		✗	if (s->poles == 1) {
864		✗	double A = ff_exp10(gain / 20);
865		✗	double ro = -sin(w0 / 2. - M_PI_4) / sin(w0 / 2. + M_PI_4);
866		✗	double n = (A + 1) / (A - 1);
867		✗	double alpha1 = A == 1. ? 0. : n - FFSIGN(n) * sqrt(n * n - 1);
868		✗	double beta0 = ((1 + A) + (1 - A) * alpha1) * 0.5;
869		✗	double beta1 = ((1 - A) + (1 + A) * alpha1) * 0.5;
870
871		✗	s->a_double[0] = 1 + ro * alpha1;
872		✗	s->a_double[1] = -ro - alpha1;
873		✗	s->a_double[2] = 0;
874		✗	s->b_double[0] = beta0 + ro * beta1;
875		✗	s->b_double[1] = -beta1 - ro * beta0;
876		✗	s->b_double[2] = 0;
877			} else {
878		✗	s->a_double[0] = (A + 1) + (A - 1) * cos(w0) + beta * alpha;
879		✗	s->a_double[1] = -2 * ((A - 1) + (A + 1) * cos(w0));
880		✗	s->a_double[2] = (A + 1) + (A - 1) * cos(w0) - beta * alpha;
881		✗	s->b_double[0] = A * ((A + 1) - (A - 1) * cos(w0) + beta * alpha);
882		✗	s->b_double[1] = 2 * A * ((A - 1) - (A + 1) * cos(w0));
883		✗	s->b_double[2] = A * ((A + 1) - (A - 1) * cos(w0) - beta * alpha);
884			}
885		✗	break;
886		✗	case treble:
887		✗	beta = sqrt((A * A + 1) - (A - 1) * (A - 1));
888		✗	case highshelf:
889		✗	if (s->poles == 1) {
890		✗	double A = ff_exp10(gain / 20);
891		✗	double ro = sin(w0 / 2. - M_PI_4) / sin(w0 / 2. + M_PI_4);
892		✗	double n = (A + 1) / (A - 1);
893		✗	double alpha1 = A == 1. ? 0. : n - FFSIGN(n) * sqrt(n * n - 1);
894		✗	double beta0 = ((1 + A) + (1 - A) * alpha1) * 0.5;
895		✗	double beta1 = ((1 - A) + (1 + A) * alpha1) * 0.5;
896
897		✗	s->a_double[0] = 1 + ro * alpha1;
898		✗	s->a_double[1] = ro + alpha1;
899		✗	s->a_double[2] = 0;
900		✗	s->b_double[0] = beta0 + ro * beta1;
901		✗	s->b_double[1] = beta1 + ro * beta0;
902		✗	s->b_double[2] = 0;
903			} else {
904		✗	s->a_double[0] = (A + 1) - (A - 1) * cos(w0) + beta * alpha;
905		✗	s->a_double[1] = 2 * ((A - 1) - (A + 1) * cos(w0));
906		✗	s->a_double[2] = (A + 1) - (A - 1) * cos(w0) - beta * alpha;
907		✗	s->b_double[0] = A * ((A + 1) + (A - 1) * cos(w0) + beta * alpha);
908		✗	s->b_double[1] =-2 * A * ((A - 1) + (A + 1) * cos(w0));
909		✗	s->b_double[2] = A * ((A + 1) + (A - 1) * cos(w0) - beta * alpha);
910			}
911		✗	break;
912		✗	case bandpass:
913		✗	if (s->csg) {
914		✗	s->a_double[0] = 1 + alpha;
915		✗	s->a_double[1] = -2 * cos(w0);
916		✗	s->a_double[2] = 1 - alpha;
917		✗	s->b_double[0] = sin(w0) / 2;
918		✗	s->b_double[1] = 0;
919		✗	s->b_double[2] = -sin(w0) / 2;
920			} else {
921		✗	s->a_double[0] = 1 + alpha;
922		✗	s->a_double[1] = -2 * cos(w0);
923		✗	s->a_double[2] = 1 - alpha;
924		✗	s->b_double[0] = alpha;
925		✗	s->b_double[1] = 0;
926		✗	s->b_double[2] = -alpha;
927			}
928		✗	break;
929		✗	case bandreject:
930		✗	s->a_double[0] = 1 + alpha;
931		✗	s->a_double[1] = -2 * cos(w0);
932		✗	s->a_double[2] = 1 - alpha;
933		✗	s->b_double[0] = 1;
934		✗	s->b_double[1] = -2 * cos(w0);
935		✗	s->b_double[2] = 1;
936		✗	break;
937		✗	case lowpass:
938		✗	if (s->poles == 1) {
939		✗	s->a_double[0] = 1;
940		✗	s->a_double[1] = -exp(-w0);
941		✗	s->a_double[2] = 0;
942		✗	s->b_double[0] = 1 + s->a_double[1];
943		✗	s->b_double[1] = 0;
944		✗	s->b_double[2] = 0;
945			} else {
946		✗	s->a_double[0] = 1 + alpha;
947		✗	s->a_double[1] = -2 * cos(w0);
948		✗	s->a_double[2] = 1 - alpha;
949		✗	s->b_double[0] = (1 - cos(w0)) / 2;
950		✗	s->b_double[1] = 1 - cos(w0);
951		✗	s->b_double[2] = (1 - cos(w0)) / 2;
952			}
953		✗	break;
954		✗	case highpass:
955		✗	if (s->poles == 1) {
956		✗	s->a_double[0] = 1;
957		✗	s->a_double[1] = -exp(-w0);
958		✗	s->a_double[2] = 0;
959		✗	s->b_double[0] = (1 - s->a_double[1]) / 2;
960		✗	s->b_double[1] = -s->b_double[0];
961		✗	s->b_double[2] = 0;
962			} else {
963		✗	s->a_double[0] = 1 + alpha;
964		✗	s->a_double[1] = -2 * cos(w0);
965		✗	s->a_double[2] = 1 - alpha;
966		✗	s->b_double[0] = (1 + cos(w0)) / 2;
967		✗	s->b_double[1] = -(1 + cos(w0));
968		✗	s->b_double[2] = (1 + cos(w0)) / 2;
969			}
970		✗	break;
971		✗	case allpass:
972		✗	switch (s->order) {
973		✗	case 1:
974		✗	s->a_double[0] = 1.;
975		✗	s->a_double[1] = -(1. - K) / (1. + K);
976		✗	s->a_double[2] = 0.;
977		✗	s->b_double[0] = s->a_double[1];
978		✗	s->b_double[1] = s->a_double[0];
979		✗	s->b_double[2] = 0.;
980		✗	break;
981		✗	case 2:
982		✗	s->a_double[0] = 1 + alpha;
983		✗	s->a_double[1] = -2 * cos(w0);
984		✗	s->a_double[2] = 1 - alpha;
985		✗	s->b_double[0] = 1 - alpha;
986		✗	s->b_double[1] = -2 * cos(w0);
987		✗	s->b_double[2] = 1 + alpha;
988		✗	break;
989			}
990		✗	break;
991		✗	default:
992		✗	av_assert0(0);
993			}
994
995		✗	av_log(ctx, AV_LOG_VERBOSE, "a=%f %f %f:b=%f %f %f\n",
996			s->a_double[0], s->a_double[1], s->a_double[2],
997			s->b_double[0], s->b_double[1], s->b_double[2]);
998
999		✗	s->a_double[1] /= s->a_double[0];
1000		✗	s->a_double[2] /= s->a_double[0];
1001		✗	s->b_double[0] /= s->a_double[0];
1002		✗	s->b_double[1] /= s->a_double[0];
1003		✗	s->b_double[2] /= s->a_double[0];
1004		✗	s->a_double[0] /= s->a_double[0];
1005
1006		✗	if (s->normalize && fabs(s->b_double[0] + s->b_double[1] + s->b_double[2]) > 1e-6) {
1007		✗	double factor = (s->a_double[0] + s->a_double[1] + s->a_double[2]) /
1008		✗	(s->b_double[0] + s->b_double[1] + s->b_double[2]);
1009
1010		✗	s->b_double[0] *= factor;
1011		✗	s->b_double[1] *= factor;
1012		✗	s->b_double[2] *= factor;
1013			}
1014
1015		✗	switch (s->filter_type) {
1016		✗	case tiltshelf:
1017		✗	s->b_double[0] /= A;
1018		✗	s->b_double[1] /= A;
1019		✗	s->b_double[2] /= A;
1020		✗	break;
1021			}
1022
1023		✗	if (!s->cache[0])
1024		✗	s->cache[0] = ff_get_audio_buffer(outlink, 4 * sizeof(double));
1025		✗	if (!s->clip)
1026		✗	s->clip = av_calloc(outlink->ch_layout.nb_channels, sizeof(*s->clip));
1027		✗	if (!s->cache[0] || !s->clip)
1028		✗	return AVERROR(ENOMEM);
1029		✗	if (reset) {
1030		✗	av_samples_set_silence(s->cache[0]->extended_data, 0, s->cache[0]->nb_samples,
1031		✗	s->cache[0]->ch_layout.nb_channels, s->cache[0]->format);
1032			}
1033
1034		✗	if (reset && s->block_samples > 0) {
1035		✗	if (!s->cache[1])
1036		✗	s->cache[1] = ff_get_audio_buffer(outlink, 4 * sizeof(double));
1037		✗	if (!s->cache[1])
1038		✗	return AVERROR(ENOMEM);
1039		✗	av_samples_set_silence(s->cache[1]->extended_data, 0, s->cache[1]->nb_samples,
1040		✗	s->cache[1]->ch_layout.nb_channels, s->cache[1]->format);
1041		✗	for (int i = 0; i < 3; i++) {
1042		✗	if (!s->block[i])
1043		✗	s->block[i] = ff_get_audio_buffer(outlink, s->block_samples * 2);
1044		✗	if (!s->block[i])
1045		✗	return AVERROR(ENOMEM);
1046		✗	av_samples_set_silence(s->block[i]->extended_data, 0, s->block_samples * 2,
1047		✗	s->block[i]->ch_layout.nb_channels, s->block[i]->format);
1048			}
1049			}
1050
1051		✗	switch (s->transform_type) {
1052		✗	case DI:
1053		✗	switch (inlink->format) {
1054		✗	case AV_SAMPLE_FMT_S16P:
1055		✗	s->filter = biquad_s16;
1056		✗	break;
1057		✗	case AV_SAMPLE_FMT_S32P:
1058		✗	s->filter = biquad_s32;
1059		✗	break;
1060		✗	case AV_SAMPLE_FMT_FLTP:
1061		✗	s->filter = biquad_flt;
1062		✗	break;
1063		✗	case AV_SAMPLE_FMT_DBLP:
1064		✗	s->filter = biquad_dbl;
1065		✗	break;
1066		✗	default: av_assert0(0);
1067			}
1068		✗	break;
1069		✗	case DII:
1070		✗	switch (inlink->format) {
1071		✗	case AV_SAMPLE_FMT_S16P:
1072		✗	s->filter = biquad_dii_s16;
1073		✗	break;
1074		✗	case AV_SAMPLE_FMT_S32P:
1075		✗	s->filter = biquad_dii_s32;
1076		✗	break;
1077		✗	case AV_SAMPLE_FMT_FLTP:
1078		✗	s->filter = biquad_dii_flt;
1079		✗	break;
1080		✗	case AV_SAMPLE_FMT_DBLP:
1081		✗	s->filter = biquad_dii_dbl;
1082		✗	break;
1083		✗	default: av_assert0(0);
1084			}
1085		✗	break;
1086		✗	case TDI:
1087		✗	switch (inlink->format) {
1088		✗	case AV_SAMPLE_FMT_S16P:
1089		✗	s->filter = biquad_tdi_s16;
1090		✗	break;
1091		✗	case AV_SAMPLE_FMT_S32P:
1092		✗	s->filter = biquad_tdi_s32;
1093		✗	break;
1094		✗	case AV_SAMPLE_FMT_FLTP:
1095		✗	s->filter = biquad_tdi_flt;
1096		✗	break;
1097		✗	case AV_SAMPLE_FMT_DBLP:
1098		✗	s->filter = biquad_tdi_dbl;
1099		✗	break;
1100		✗	default: av_assert0(0);
1101			}
1102		✗	break;
1103		✗	case TDII:
1104		✗	switch (inlink->format) {
1105		✗	case AV_SAMPLE_FMT_S16P:
1106		✗	s->filter = biquad_tdii_s16;
1107		✗	break;
1108		✗	case AV_SAMPLE_FMT_S32P:
1109		✗	s->filter = biquad_tdii_s32;
1110		✗	break;
1111		✗	case AV_SAMPLE_FMT_FLTP:
1112		✗	s->filter = biquad_tdii_flt;
1113		✗	break;
1114		✗	case AV_SAMPLE_FMT_DBLP:
1115		✗	s->filter = biquad_tdii_dbl;
1116		✗	break;
1117		✗	default: av_assert0(0);
1118			}
1119		✗	break;
1120		✗	case LATT:
1121		✗	switch (inlink->format) {
1122		✗	case AV_SAMPLE_FMT_S16P:
1123		✗	s->filter = biquad_latt_s16;
1124		✗	break;
1125		✗	case AV_SAMPLE_FMT_S32P:
1126		✗	s->filter = biquad_latt_s32;
1127		✗	break;
1128		✗	case AV_SAMPLE_FMT_FLTP:
1129		✗	s->filter = biquad_latt_flt;
1130		✗	break;
1131		✗	case AV_SAMPLE_FMT_DBLP:
1132		✗	s->filter = biquad_latt_dbl;
1133		✗	break;
1134		✗	default: av_assert0(0);
1135			}
1136		✗	break;
1137		✗	case SVF:
1138		✗	switch (inlink->format) {
1139		✗	case AV_SAMPLE_FMT_S16P:
1140		✗	s->filter = biquad_svf_s16;
1141		✗	break;
1142		✗	case AV_SAMPLE_FMT_S32P:
1143		✗	s->filter = biquad_svf_s32;
1144		✗	break;
1145		✗	case AV_SAMPLE_FMT_FLTP:
1146		✗	s->filter = biquad_svf_flt;
1147		✗	break;
1148		✗	case AV_SAMPLE_FMT_DBLP:
1149		✗	s->filter = biquad_svf_dbl;
1150		✗	break;
1151		✗	default: av_assert0(0);
1152			}
1153		✗	break;
1154		✗	case ZDF:
1155		✗	switch (inlink->format) {
1156		✗	case AV_SAMPLE_FMT_S16P:
1157		✗	s->filter = biquad_zdf_s16;
1158		✗	break;
1159		✗	case AV_SAMPLE_FMT_S32P:
1160		✗	s->filter = biquad_zdf_s32;
1161		✗	break;
1162		✗	case AV_SAMPLE_FMT_FLTP:
1163		✗	s->filter = biquad_zdf_flt;
1164		✗	break;
1165		✗	case AV_SAMPLE_FMT_DBLP:
1166		✗	s->filter = biquad_zdf_dbl;
1167		✗	break;
1168		✗	default: av_assert0(0);
1169			}
1170		✗	break;
1171		✗	default:
1172		✗	av_assert0(0);
1173			}
1174
1175		✗	s->block_align = av_get_bytes_per_sample(inlink->format);
1176
1177		✗	if (s->transform_type == LATT)
1178		✗	convert_dir2latt(s);
1179		✗	else if (s->transform_type == SVF)
1180		✗	convert_dir2svf(s);
1181		✗	else if (s->transform_type == ZDF)
1182		✗	convert_dir2zdf(s, inlink->sample_rate);
1183
1184		✗	s->a_float[0] = s->a_double[0];
1185		✗	s->a_float[1] = s->a_double[1];
1186		✗	s->a_float[2] = s->a_double[2];
1187		✗	s->b_float[0] = s->b_double[0];
1188		✗	s->b_float[1] = s->b_double[1];
1189		✗	s->b_float[2] = s->b_double[2];
1190
1191		✗	return 0;
1192			}
1193
1194		✗	static int config_output(AVFilterLink *outlink)
1195			{
1196		✗	return config_filter(outlink, 1);
1197			}
1198
1199			typedef struct ThreadData {
1200			AVFrame *in, *out;
1201			int eof;
1202			} ThreadData;
1203
1204		✗	static void reverse_samples(AVFrame *out, AVFrame *in, int p,
1205			int oo, int io, int nb_samples)
1206			{
1207		✗	switch (out->format) {
1208		✗	case AV_SAMPLE_FMT_S16P: {
1209		✗	const int16_t *src = ((const int16_t *)in->extended_data[p]) + io;
1210		✗	int16_t *dst = ((int16_t *)out->extended_data[p]) + oo;
1211		✗	for (int i = 0, j = nb_samples - 1; i < nb_samples; i++, j--)
1212		✗	dst[i] = src[j];
1213			}
1214		✗	break;
1215		✗	case AV_SAMPLE_FMT_S32P: {
1216		✗	const int32_t *src = ((const int32_t *)in->extended_data[p]) + io;
1217		✗	int32_t *dst = ((int32_t *)out->extended_data[p]) + oo;
1218		✗	for (int i = 0, j = nb_samples - 1; i < nb_samples; i++, j--)
1219		✗	dst[i] = src[j];
1220			}
1221		✗	break;
1222		✗	case AV_SAMPLE_FMT_FLTP: {
1223		✗	const float *src = ((const float *)in->extended_data[p]) + io;
1224		✗	float *dst = ((float *)out->extended_data[p]) + oo;
1225		✗	for (int i = 0, j = nb_samples - 1; i < nb_samples; i++, j--)
1226		✗	dst[i] = src[j];
1227			}
1228		✗	break;
1229		✗	case AV_SAMPLE_FMT_DBLP: {
1230		✗	const double *src = ((const double *)in->extended_data[p]) + io;
1231		✗	double *dst = ((double *)out->extended_data[p]) + oo;
1232		✗	for (int i = 0, j = nb_samples - 1; i < nb_samples; i++, j--)
1233		✗	dst[i] = src[j];
1234			}
1235		✗	break;
1236			}
1237		✗	}
1238
1239		✗	static int filter_channel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
1240			{
1241		✗	AVFilterLink *inlink = ctx->inputs[0];
1242		✗	ThreadData *td = arg;
1243		✗	AVFrame *buf = td->in;
1244		✗	AVFrame *out_buf = td->out;
1245		✗	BiquadsContext *s = ctx->priv;
1246		✗	const int start = (buf->ch_layout.nb_channels * jobnr) / nb_jobs;
1247		✗	const int end = (buf->ch_layout.nb_channels * (jobnr+1)) / nb_jobs;
1248			int ch;
1249
1250		✗	for (ch = start; ch < end; ch++) {
1251		✗	enum AVChannel channel = av_channel_layout_channel_from_index(&inlink->ch_layout, ch);
1252
1253		✗	if (av_channel_layout_index_from_channel(&s->ch_layout, channel) < 0) {
1254		✗	if (buf != out_buf)
1255		✗	memcpy(out_buf->extended_data[ch], buf->extended_data[ch],
1256		✗	buf->nb_samples * s->block_align);
1257		✗	continue;
1258			}
1259
1260		✗	if (!s->block_samples) {
1261		✗	s->filter(s, buf->extended_data[ch], out_buf->extended_data[ch], buf->nb_samples,
1262		✗	s->cache[0]->extended_data[ch], s->clip+ch, ctx->is_disabled);
1263		✗	} else if (td->eof) {
1264		✗	memcpy(out_buf->extended_data[ch], s->block[1]->extended_data[ch] + s->block_align * s->block_samples,
1265		✗	s->nb_samples * s->block_align);
1266			} else {
1267		✗	memcpy(s->block[0]->extended_data[ch] + s->block_align * s->block_samples, buf->extended_data[ch],
1268		✗	buf->nb_samples * s->block_align);
1269		✗	memset(s->block[0]->extended_data[ch] + s->block_align * (s->block_samples + buf->nb_samples),
1270		✗	0, (s->block_samples - buf->nb_samples) * s->block_align);
1271		✗	s->filter(s, s->block[0]->extended_data[ch], s->block[1]->extended_data[ch], s->block_samples,
1272		✗	s->cache[0]->extended_data[ch], s->clip+ch, ctx->is_disabled);
1273		✗	av_samples_copy(s->cache[1]->extended_data, s->cache[0]->extended_data, 0, 0,
1274		✗	s->cache[0]->nb_samples, s->cache[0]->ch_layout.nb_channels,
1275		✗	s->cache[0]->format);
1276		✗	s->filter(s, s->block[0]->extended_data[ch] + s->block_samples * s->block_align,
1277		✗	s->block[1]->extended_data[ch] + s->block_samples * s->block_align,
1278		✗	s->block_samples, s->cache[1]->extended_data[ch], s->clip+ch,
1279			ctx->is_disabled);
1280		✗	reverse_samples(s->block[2], s->block[1], ch, 0, 0, 2 * s->block_samples);
1281		✗	av_samples_set_silence(s->cache[1]->extended_data, 0, s->cache[1]->nb_samples,
1282		✗	s->cache[1]->ch_layout.nb_channels, s->cache[1]->format);
1283		✗	s->filter(s, s->block[2]->extended_data[ch], s->block[2]->extended_data[ch], 2 * s->block_samples,
1284		✗	s->cache[1]->extended_data[ch], s->clip+ch, ctx->is_disabled);
1285		✗	reverse_samples(s->block[1], s->block[2], ch, 0, 0, 2 * s->block_samples);
1286		✗	memcpy(out_buf->extended_data[ch], s->block[1]->extended_data[ch],
1287		✗	s->block_samples * s->block_align);
1288		✗	memmove(s->block[0]->extended_data[ch], s->block[0]->extended_data[ch] + s->block_align * s->block_samples,
1289		✗	s->block_samples * s->block_align);
1290			}
1291			}
1292
1293		✗	return 0;
1294			}
1295
1296		✗	static int filter_frame(AVFilterLink *inlink, AVFrame *buf, int eof)
1297			{
1298		✗	AVFilterContext *ctx = inlink->dst;
1299		✗	BiquadsContext *s = ctx->priv;
1300		✗	AVFilterLink *outlink = ctx->outputs[0];
1301			AVFrame *out_buf;
1302			ThreadData td;
1303		✗	int ch, ret, drop = 0;
1304
1305		✗	if (s->bypass)
1306		✗	return ff_filter_frame(outlink, buf);
1307
1308		✗	ret = av_channel_layout_copy(&s->ch_layout, &inlink->ch_layout);
1309		✗	if (ret < 0) {
1310		✗	av_frame_free(&buf);
1311		✗	return ret;
1312			}
1313		✗	if (strcmp(s->ch_layout_str, "all"))
1314		✗	av_channel_layout_from_string(&s->ch_layout,
1315		✗	s->ch_layout_str);
1316
1317		✗	if (av_frame_is_writable(buf) && s->block_samples == 0) {
1318		✗	out_buf = buf;
1319			} else {
1320		✗	out_buf = ff_get_audio_buffer(outlink, s->block_samples > 0 ? s->block_samples : buf->nb_samples);
1321		✗	if (!out_buf) {
1322		✗	av_frame_free(&buf);
1323		✗	return AVERROR(ENOMEM);
1324			}
1325		✗	av_frame_copy_props(out_buf, buf);
1326			}
1327
1328		✗	if (s->block_samples > 0 && s->pts == AV_NOPTS_VALUE)
1329		✗	drop = 1;
1330		✗	td.in = buf;
1331		✗	td.out = out_buf;
1332		✗	td.eof = eof;
1333		✗	ff_filter_execute(ctx, filter_channel, &td, NULL,
1334		✗	FFMIN(outlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
1335
1336		✗	for (ch = 0; ch < outlink->ch_layout.nb_channels; ch++) {
1337		✗	if (s->clip[ch] > 0)
1338		✗	av_log(ctx, AV_LOG_WARNING, "Channel %d clipping %d times. Please reduce gain.\n",
1339		✗	ch, s->clip[ch]);
1340		✗	s->clip[ch] = 0;
1341			}
1342
1343		✗	if (s->block_samples > 0) {
1344		✗	int nb_samples = buf->nb_samples;
1345		✗	int64_t pts = buf->pts;
1346
1347		✗	out_buf->pts = s->pts;
1348		✗	out_buf->nb_samples = s->nb_samples;
1349		✗	s->pts = pts;
1350		✗	s->nb_samples = nb_samples;
1351			}
1352
1353		✗	if (buf != out_buf)
1354		✗	av_frame_free(&buf);
1355
1356		✗	if (!drop)
1357		✗	return ff_filter_frame(outlink, out_buf);
1358			else {
1359		✗	av_frame_free(&out_buf);
1360		✗	ff_filter_set_ready(ctx, 10);
1361		✗	return 0;
1362			}
1363			}
1364
1365		✗	static int activate(AVFilterContext *ctx)
1366			{
1367		✗	AVFilterLink *inlink = ctx->inputs[0];
1368		✗	AVFilterLink *outlink = ctx->outputs[0];
1369		✗	BiquadsContext *s = ctx->priv;
1370		✗	AVFrame *in = NULL;
1371			int64_t pts;
1372			int status;
1373			int ret;
1374
1375		✗	FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
1376
1377		✗	if (s->block_samples > 0) {
1378		✗	ret = ff_inlink_consume_samples(inlink, s->block_samples, s->block_samples, &in);
1379			} else {
1380		✗	ret = ff_inlink_consume_frame(inlink, &in);
1381			}
1382		✗	if (ret < 0)
1383		✗	return ret;
1384		✗	if (ret > 0)
1385		✗	return filter_frame(inlink, in, 0);
1386
1387		✗	if (s->block_samples > 0 && ff_inlink_queued_samples(inlink) >= s->block_samples) {
1388		✗	ff_filter_set_ready(ctx, 10);
1389		✗	return 0;
1390			}
1391
1392		✗	if (ff_inlink_acknowledge_status(inlink, &status, &pts)) {
1393		✗	if (s->block_samples > 0) {
1394		✗	AVFrame *in = ff_get_audio_buffer(outlink, s->block_samples);
1395		✗	if (!in)
1396		✗	return AVERROR(ENOMEM);
1397
1398		✗	ret = filter_frame(inlink, in, 1);
1399			}
1400
1401		✗	ff_outlink_set_status(outlink, status, pts);
1402
1403		✗	return ret;
1404			}
1405
1406		✗	FF_FILTER_FORWARD_WANTED(outlink, inlink);
1407
1408		✗	return FFERROR_NOT_READY;
1409			}
1410
1411		✗	static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
1412			char *res, int res_len, int flags)
1413			{
1414		✗	AVFilterLink *outlink = ctx->outputs[0];
1415			int ret;
1416
1417		✗	ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
1418		✗	if (ret < 0)
1419		✗	return ret;
1420
1421		✗	return config_filter(outlink, 0);
1422			}
1423
1424		✗	static av_cold void uninit(AVFilterContext *ctx)
1425			{
1426		✗	BiquadsContext *s = ctx->priv;
1427
1428		✗	for (int i = 0; i < 3; i++)
1429		✗	av_frame_free(&s->block[i]);
1430		✗	av_frame_free(&s->cache[0]);
1431		✗	av_frame_free(&s->cache[1]);
1432		✗	av_freep(&s->clip);
1433		✗	av_channel_layout_uninit(&s->ch_layout);
1434		✗	}
1435
1436			static const AVFilterPad outputs[] = {
1437			{
1438			.name = "default",
1439			.type = AVMEDIA_TYPE_AUDIO,
1440			.config_props = config_output,
1441			},
1442			};
1443
1444			#define OFFSET(x) offsetof(BiquadsContext, x)
1445			#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
1446			#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
1447
1448			#define DEFINE_BIQUAD_FILTER_2(name_, description_, priv_class_) \
1449			static av_cold int name_##_init(AVFilterContext *ctx) \
1450			{ \
1451			BiquadsContext *s = ctx->priv; \
1452			s->filter_type = name_; \
1453			s->pts = AV_NOPTS_VALUE; \
1454			return 0; \
1455			} \
1456			\
1457			const AVFilter ff_af_##name_ = { \
1458			.name = #name_, \
1459			.description = NULL_IF_CONFIG_SMALL(description_), \
1460			.priv_class = &priv_class_##_class, \
1461			.priv_size = sizeof(BiquadsContext), \
1462			.init = name_##_init, \
1463			.activate = activate, \
1464			.uninit = uninit, \
1465			FILTER_INPUTS(ff_audio_default_filterpad), \
1466			FILTER_OUTPUTS(outputs), \
1467			FILTER_QUERY_FUNC(query_formats), \
1468			.process_command = process_command, \
1469			.flags = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL, \
1470			}
1471
1472			#define DEFINE_BIQUAD_FILTER(name, description) \
1473			AVFILTER_DEFINE_CLASS(name); \
1474			DEFINE_BIQUAD_FILTER_2(name, description, name)
1475
1476			#define WIDTH_OPTION(x) \
1477			{"width", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=x}, 0, 99999, FLAGS}, \
1478			{"w", "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=x}, 0, 99999, FLAGS}
1479
1480			#define WIDTH_TYPE_OPTION(x) \
1481			{"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=x}, HERTZ, NB_WTYPE-1, FLAGS, .unit = "width_type"}, \
1482			{"t", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=x}, HERTZ, NB_WTYPE-1, FLAGS, .unit = "width_type"}, \
1483			{"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, .unit = "width_type"}, \
1484			{"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, .unit = "width_type"}, \
1485			{"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, .unit = "width_type"}, \
1486			{"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, .unit = "width_type"}, \
1487			{"k", "kHz", 0, AV_OPT_TYPE_CONST, {.i64=KHERTZ}, 0, 0, FLAGS, .unit = "width_type"}
1488
1489			#define MIX_CHANNELS_NORMALIZE_OPTION(x, y, z) \
1490			{"mix", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=x}, 0, 1, FLAGS}, \
1491			{"m", "set mix", OFFSET(mix), AV_OPT_TYPE_DOUBLE, {.dbl=x}, 0, 1, FLAGS}, \
1492			{"channels", "set channels to filter", OFFSET(ch_layout_str), AV_OPT_TYPE_STRING, {.str=y}, 0, 0, FLAGS}, \
1493			{"c", "set channels to filter", OFFSET(ch_layout_str), AV_OPT_TYPE_STRING, {.str=y}, 0, 0, FLAGS}, \
1494			{"normalize", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=z}, 0, 1, FLAGS}, \
1495			{"n", "normalize coefficients", OFFSET(normalize), AV_OPT_TYPE_BOOL, {.i64=z}, 0, 1, FLAGS}
1496
1497			#define TRANSFORM_OPTION(x) \
1498			{"transform", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=x}, 0, NB_TTYPE-1, AF, .unit = "transform_type"}, \
1499			{"a", "set transform type", OFFSET(transform_type), AV_OPT_TYPE_INT, {.i64=x}, 0, NB_TTYPE-1, AF, .unit = "transform_type"}, \
1500			{"di", "direct form I", 0, AV_OPT_TYPE_CONST, {.i64=DI}, 0, 0, AF, .unit = "transform_type"}, \
1501			{"dii", "direct form II", 0, AV_OPT_TYPE_CONST, {.i64=DII}, 0, 0, AF, .unit = "transform_type"}, \
1502			{"tdi", "transposed direct form I", 0, AV_OPT_TYPE_CONST, {.i64=TDI}, 0, 0, AF, .unit = "transform_type"}, \
1503			{"tdii", "transposed direct form II", 0, AV_OPT_TYPE_CONST, {.i64=TDII}, 0, 0, AF, .unit = "transform_type"}, \
1504			{"latt", "lattice-ladder form", 0, AV_OPT_TYPE_CONST, {.i64=LATT}, 0, 0, AF, .unit = "transform_type"}, \
1505			{"svf", "state variable filter form", 0, AV_OPT_TYPE_CONST, {.i64=SVF}, 0, 0, AF, .unit = "transform_type"}, \
1506			{"zdf", "zero-delay filter form", 0, AV_OPT_TYPE_CONST, {.i64=ZDF}, 0, 0, AF, .unit = "transform_type"}
1507
1508			#define PRECISION_OPTION(x) \
1509			{"precision", "set filtering precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=x}, -1, 3, AF, .unit = "precision"}, \
1510			{"r", "set filtering precision", OFFSET(precision), AV_OPT_TYPE_INT, {.i64=x}, -1, 3, AF, .unit = "precision"}, \
1511			{"auto", "automatic", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, AF, .unit = "precision"}, \
1512			{"s16", "signed 16-bit", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AF, .unit = "precision"}, \
1513			{"s32", "signed 32-bit", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AF, .unit = "precision"}, \
1514			{"f32", "floating-point single", 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, AF, .unit = "precision"}, \
1515			{"f64", "floating-point double", 0, AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, AF, .unit = "precision"}
1516
1517			#define BLOCKSIZE_OPTION(x) \
1518			{"blocksize", "set the block size", OFFSET(block_samples), AV_OPT_TYPE_INT, {.i64=x}, 0, 32768, AF}, \
1519			{"b", "set the block size", OFFSET(block_samples), AV_OPT_TYPE_INT, {.i64=x}, 0, 32768, AF}
1520
1521			#if CONFIG_EQUALIZER_FILTER
1522			static const AVOption equalizer_options[] = {
1523			{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
1524			{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
1525			WIDTH_TYPE_OPTION(QFACTOR),
1526			WIDTH_OPTION(1.0),
1527			{"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
1528			{"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
1529			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1530			TRANSFORM_OPTION(DI),
1531			PRECISION_OPTION(-1),
1532			BLOCKSIZE_OPTION(0),
1533			{NULL}
1534			};
1535
1536		✗	DEFINE_BIQUAD_FILTER(equalizer, "Apply two-pole peaking equalization (EQ) filter.");
1537			#endif /* CONFIG_EQUALIZER_FILTER */
1538			#if CONFIG_BASS_FILTER || CONFIG_LOWSHELF_FILTER
1539			static const AVOption bass_lowshelf_options[] = {
1540			{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
1541			{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
1542			WIDTH_TYPE_OPTION(QFACTOR),
1543			WIDTH_OPTION(0.5),
1544			{"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
1545			{"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
1546			{"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1547			{"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1548			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1549			TRANSFORM_OPTION(DI),
1550			PRECISION_OPTION(-1),
1551			BLOCKSIZE_OPTION(0),
1552			{NULL}
1553			};
1554
1555			AVFILTER_DEFINE_CLASS_EXT(bass_lowshelf, "bass/lowshelf", bass_lowshelf_options);
1556			#if CONFIG_BASS_FILTER
1557		✗	DEFINE_BIQUAD_FILTER_2(bass, "Boost or cut lower frequencies.", bass_lowshelf);
1558			#endif /* CONFIG_BASS_FILTER */
1559
1560			#if CONFIG_LOWSHELF_FILTER
1561		✗	DEFINE_BIQUAD_FILTER_2(lowshelf, "Apply a low shelf filter.", bass_lowshelf);
1562			#endif /* CONFIG_LOWSHELF_FILTER */
1563			#endif /* CONFIG_BASS_FILTER || CONFIG LOWSHELF_FILTER */
1564			#if CONFIG_TREBLE_FILTER || CONFIG_HIGHSHELF_FILTER || CONFIG_TILTSHELF_FILTER
1565			static const AVOption treble_highshelf_options[] = {
1566			{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1567			{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1568			WIDTH_TYPE_OPTION(QFACTOR),
1569			WIDTH_OPTION(0.5),
1570			{"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
1571			{"g", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
1572			{"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1573			{"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1574			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1575			TRANSFORM_OPTION(DI),
1576			PRECISION_OPTION(-1),
1577			BLOCKSIZE_OPTION(0),
1578			{NULL}
1579			};
1580
1581			AVFILTER_DEFINE_CLASS_EXT(treble_highshelf, "treble/high/tiltshelf",
1582			treble_highshelf_options);
1583
1584			#if CONFIG_TREBLE_FILTER
1585		✗	DEFINE_BIQUAD_FILTER_2(treble, "Boost or cut upper frequencies.", treble_highshelf);
1586			#endif /* CONFIG_TREBLE_FILTER */
1587
1588			#if CONFIG_HIGHSHELF_FILTER
1589		✗	DEFINE_BIQUAD_FILTER_2(highshelf, "Apply a high shelf filter.", treble_highshelf);
1590			#endif /* CONFIG_HIGHSHELF_FILTER */
1591
1592			#if CONFIG_TILTSHELF_FILTER
1593		✗	DEFINE_BIQUAD_FILTER_2(tiltshelf, "Apply a tilt shelf filter.", treble_highshelf);
1594			#endif
1595			#endif /* CONFIG_TREBLE_FILTER || CONFIG_HIGHSHELF_FILTER || CONFIG_TILTSHELF_FILTER */
1596
1597			#if CONFIG_BANDPASS_FILTER
1598			static const AVOption bandpass_options[] = {
1599			{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1600			{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1601			WIDTH_TYPE_OPTION(QFACTOR),
1602			WIDTH_OPTION(0.5),
1603			{"csg", "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
1604			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1605			TRANSFORM_OPTION(DI),
1606			PRECISION_OPTION(-1),
1607			BLOCKSIZE_OPTION(0),
1608			{NULL}
1609			};
1610
1611		✗	DEFINE_BIQUAD_FILTER(bandpass, "Apply a two-pole Butterworth band-pass filter.");
1612			#endif /* CONFIG_BANDPASS_FILTER */
1613			#if CONFIG_BANDREJECT_FILTER
1614			static const AVOption bandreject_options[] = {
1615			{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1616			{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1617			WIDTH_TYPE_OPTION(QFACTOR),
1618			WIDTH_OPTION(0.5),
1619			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1620			TRANSFORM_OPTION(DI),
1621			PRECISION_OPTION(-1),
1622			BLOCKSIZE_OPTION(0),
1623			{NULL}
1624			};
1625
1626		✗	DEFINE_BIQUAD_FILTER(bandreject, "Apply a two-pole Butterworth band-reject filter.");
1627			#endif /* CONFIG_BANDREJECT_FILTER */
1628			#if CONFIG_LOWPASS_FILTER
1629			static const AVOption lowpass_options[] = {
1630			{"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
1631			{"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
1632			WIDTH_TYPE_OPTION(QFACTOR),
1633			WIDTH_OPTION(0.707),
1634			{"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1635			{"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1636			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1637			TRANSFORM_OPTION(DI),
1638			PRECISION_OPTION(-1),
1639			BLOCKSIZE_OPTION(0),
1640			{NULL}
1641			};
1642
1643		✗	DEFINE_BIQUAD_FILTER(lowpass, "Apply a low-pass filter with 3dB point frequency.");
1644			#endif /* CONFIG_LOWPASS_FILTER */
1645			#if CONFIG_HIGHPASS_FILTER
1646			static const AVOption highpass_options[] = {
1647			{"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1648			{"f", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1649			WIDTH_TYPE_OPTION(QFACTOR),
1650			WIDTH_OPTION(0.707),
1651			{"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1652			{"p", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, AF},
1653			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1654			TRANSFORM_OPTION(DI),
1655			PRECISION_OPTION(-1),
1656			BLOCKSIZE_OPTION(0),
1657			{NULL}
1658			};
1659
1660		✗	DEFINE_BIQUAD_FILTER(highpass, "Apply a high-pass filter with 3dB point frequency.");
1661			#endif /* CONFIG_HIGHPASS_FILTER */
1662			#if CONFIG_ALLPASS_FILTER
1663			static const AVOption allpass_options[] = {
1664			{"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1665			{"f", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
1666			WIDTH_TYPE_OPTION(QFACTOR),
1667			WIDTH_OPTION(0.707),
1668			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1669			{"order", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
1670			{"o", "set filter order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
1671			TRANSFORM_OPTION(DI),
1672			PRECISION_OPTION(-1),
1673			{NULL}
1674			};
1675
1676		✗	DEFINE_BIQUAD_FILTER(allpass, "Apply a two-pole all-pass filter.");
1677			#endif /* CONFIG_ALLPASS_FILTER */
1678			#if CONFIG_BIQUAD_FILTER
1679			static const AVOption biquad_options[] = {
1680			{"a0", NULL, OFFSET(oa[0]), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT32_MIN, INT32_MAX, FLAGS},
1681			{"a1", NULL, OFFSET(oa[1]), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
1682			{"a2", NULL, OFFSET(oa[2]), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
1683			{"b0", NULL, OFFSET(ob[0]), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
1684			{"b1", NULL, OFFSET(ob[1]), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
1685			{"b2", NULL, OFFSET(ob[2]), AV_OPT_TYPE_DOUBLE, {.dbl=0}, INT32_MIN, INT32_MAX, FLAGS},
1686			MIX_CHANNELS_NORMALIZE_OPTION(1, "all", 0),
1687			TRANSFORM_OPTION(DI),
1688			PRECISION_OPTION(-1),
1689			BLOCKSIZE_OPTION(0),
1690			{NULL}
1691			};
1692
1693		✗	DEFINE_BIQUAD_FILTER(biquad, "Apply a biquad IIR filter with the given coefficients.");
1694			#endif /* CONFIG_BIQUAD_FILTER */
1695