1#!/usr/bin/awk -f
2#
3# SPDX-License-Identifier: BSD-2-Clause
4#
5# Copyright (c) 2008-2009 Ariff Abdullah <ariff@FreeBSD.org>
6# All rights reserved.
7#
8# Redistribution and use in source and binary forms, with or without
9# modification, are permitted provided that the following conditions
10# are met:
11# 1. Redistributions of source code must retain the above copyright
12#    notice, this list of conditions and the following disclaimer.
13# 2. Redistributions in binary form must reproduce the above copyright
14#    notice, this list of conditions and the following disclaimer in the
15#    documentation and/or other materials provided with the distribution.
16#
17# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27# SUCH DAMAGE.
28#
29#
30
31#
32# Biquad coefficients generator for Parametric Software Equalizer. Not as ugly
33# as 'feeder_rate_mkfilter.awk'
34#
35# Based on:
36#
37#  "Cookbook formulae for audio EQ biquad filter coefficients"
38#    by Robert Bristow-Johnson  <rbj@audioimagination.com>
39#
40#    -  http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
41#
42
43
44
45#
46# Some basic Math functions.
47#
48function abs(x)
49{
50	return (((x < 0) ? -x : x) + 0);
51}
52
53function fabs(x)
54{
55	return (((x < 0.0) ? -x : x) + 0.0);
56}
57
58function floor(x, r)
59{
60	r = int(x);
61	if (r > x)
62		r--;
63	return (r + 0);
64}
65
66function pow(x, y)
67{
68	return (exp(1.0 * y * log(1.0 * x)));
69}
70
71#
72# What the hell...
73#
74function shl(x, y)
75{
76	while (y > 0) {
77		x *= 2;
78		y--;
79	}
80	return (x);
81}
82
83function feedeq_w0(fc, rate)
84{
85	return ((2.0 * M_PI * fc) / (1.0 * rate));
86}
87
88function feedeq_A(gain, A)
89{
90	if (FEEDEQ_TYPE == FEEDEQ_TYPE_PEQ || FEEDEQ_TYPE == FEEDEQ_TYPE_SHELF)
91		A = pow(10, gain / 40.0);
92	else
93		A = sqrt(pow(10, gain / 20.0));
94
95	return (A);
96}
97
98function feedeq_alpha(w0, A, QS)
99{
100	if (FEEDEQ_TYPE == FEEDEQ_TYPE_PEQ)
101		alpha = sin(w0) / (2.0 * QS);
102	else if (FEEDEQ_TYPE == FEEDEQ_TYPE_SHELF)
103		alpha = sin(w0) * 0.5 * sqrt(A + ((1.0 / A) *		\
104		    ((1.0 / QS) - 1.0)) + 2.0);
105	else
106		alpha = 0.0;
107
108	return (alpha);
109}
110
111function feedeq_fx_floor(v, r)
112{
113	if (fabs(v) < fabs(smallest))
114		smallest = v;
115	if (fabs(v) > fabs(largest))
116		largest = v;
117
118	r = floor((v * FEEDEQ_COEFF_ONE) + 0.5);
119
120	if (r < INT32_MIN || r > INT32_MAX)
121		printf("\n#error overflow v=%f, "			\
122		    "please reduce FEEDEQ_COEFF_SHIFT\n", v);
123
124	return (r);
125}
126
127function feedeq_gen_biquad_coeffs(coeffs, rate, gain,			\
128    w0, A, alpha, a0, a1, a2, b0, b1, b2)
129{
130	w0    = feedeq_w0(FEEDEQ_TREBLE_SFREQ, 1.0 * rate);
131	A     = feedeq_A(1.0 * gain);
132	alpha = feedeq_alpha(w0, A, FEEDEQ_TREBLE_SLOPE);
133
134	if (FEEDEQ_TYPE == FEEDEQ_TYPE_PEQ) {
135		b0 =  1.0 + (alpha * A);
136		b1 = -2.0 * cos(w0);
137		b2 =  1.0 - (alpha * A);
138		a0 =  1.0 + (alpha / A);
139		a1 = -2.0 * cos(w0);
140		a2 =  1.0 - (alpha / A);
141	} else if (FEEDEQ_TYPE == FEEDEQ_TYPE_SHELF) {
142		b0 =      A*((A+1.0)+((A-1.0)*cos(w0))+(2.0*sqrt(A)*alpha));
143		b1 = -2.0*A*((A-1.0)+((A+1.0)*cos(w0))                    );
144		b2 =      A*((A+1.0)+((A-1.0)*cos(w0))-(2.0*sqrt(A)*alpha));
145		a0 =         (A+1.0)-((A-1.0)*cos(w0))+(2.0*sqrt(A)*alpha );
146		a1 =  2.0 * ((A-1.0)-((A+1.0)*cos(w0))                    );
147		a2 =         (A+1.0)-((A-1.0)*cos(w0))-(2.0*sqrt(A)*alpha );
148	} else
149		b0 = b1 = b2 = a0 = a1 = a2 = 0.0;
150
151	b0 /= a0;
152	b1 /= a0;
153	b2 /= a0;
154	a1 /= a0;
155	a2 /= a0;
156
157	coeffs["treble", gain, 0] = feedeq_fx_floor(a0);
158	coeffs["treble", gain, 1] = feedeq_fx_floor(a1);
159	coeffs["treble", gain, 2] = feedeq_fx_floor(a2);
160	coeffs["treble", gain, 3] = feedeq_fx_floor(b0);
161	coeffs["treble", gain, 4] = feedeq_fx_floor(b1);
162	coeffs["treble", gain, 5] = feedeq_fx_floor(b2);
163
164	w0    = feedeq_w0(FEEDEQ_BASS_SFREQ, 1.0 * rate);
165	A     = feedeq_A(1.0 * gain);
166	alpha = feedeq_alpha(w0, A, FEEDEQ_BASS_SLOPE);
167
168	if (FEEDEQ_TYPE == FEEDEQ_TYPE_PEQ) {
169		b0 =  1.0 + (alpha * A);
170		b1 = -2.0 * cos(w0);
171		b2 =  1.0 - (alpha * A);
172		a0 =  1.0 + (alpha / A);
173		a1 = -2.0 * cos(w0);
174		a2 =  1.0 - (alpha / A);
175	} else if (FEEDEQ_TYPE == FEEDEQ_TYPE_SHELF) {
176		b0 =      A*((A+1.0)-((A-1.0)*cos(w0))+(2.0*sqrt(A)*alpha));
177		b1 =  2.0*A*((A-1.0)-((A+1.0)*cos(w0))                    );
178		b2 =      A*((A+1.0)-((A-1.0)*cos(w0))-(2.0*sqrt(A)*alpha));
179		a0 =         (A+1.0)+((A-1.0)*cos(w0))+(2.0*sqrt(A)*alpha );
180		a1 = -2.0 * ((A-1.0)+((A+1.0)*cos(w0))                    );
181		a2 =         (A+1.0)+((A-1.0)*cos(w0))-(2.0*sqrt(A)*alpha );
182	} else
183		b0 = b1 = b2 = a0 = a1 = a2 = 0.0;
184
185	b0 /= a0;
186	b1 /= a0;
187	b2 /= a0;
188	a1 /= a0;
189	a2 /= a0;
190
191	coeffs["bass", gain, 0] = feedeq_fx_floor(a0);
192	coeffs["bass", gain, 1] = feedeq_fx_floor(a1);
193	coeffs["bass", gain, 2] = feedeq_fx_floor(a2);
194	coeffs["bass", gain, 3] = feedeq_fx_floor(b0);
195	coeffs["bass", gain, 4] = feedeq_fx_floor(b1);
196	coeffs["bass", gain, 5] = feedeq_fx_floor(b2);
197}
198
199function feedeq_gen_freq_coeffs(frq, g, i, v)
200{
201	coeffs[0] = 0;
202
203	for (g = (FEEDEQ_GAIN_MIN * FEEDEQ_GAIN_DIV);			\
204	    g <= (FEEDEQ_GAIN_MAX * FEEDEQ_GAIN_DIV);			\
205	    g += FEEDEQ_GAIN_STEP) {
206		feedeq_gen_biquad_coeffs(coeffs, frq,			\
207		    g * FEEDEQ_GAIN_RECIPROCAL);
208	}
209
210	printf("\nstatic struct feed_eq_coeff eq_%d[%d] "		\
211	    "= {\n", frq, FEEDEQ_LEVELS);
212	for (g = (FEEDEQ_GAIN_MIN * FEEDEQ_GAIN_DIV);			\
213	    g <= (FEEDEQ_GAIN_MAX * FEEDEQ_GAIN_DIV);			\
214	    g += FEEDEQ_GAIN_STEP) {
215		printf("     {{ ");
216		for (i = 1; i < 6; i++) {
217			v = coeffs["treble", g * FEEDEQ_GAIN_RECIPROCAL, i];
218			printf("%s0x%08x%s",				\
219			    (v < 0) ? "-" : " ", abs(v),		\
220			    (i == 5) ? " " : ", ");
221		}
222		printf("},\n      { ");
223		for (i = 1; i < 6; i++) {
224			v = coeffs["bass", g * FEEDEQ_GAIN_RECIPROCAL, i];
225			printf("%s0x%08x%s",				\
226			    (v < 0) ? "-" : " ", abs(v),		\
227			    (i == 5) ? " " : ", ");
228		}
229		printf("}}%s\n",					\
230		    (g < (FEEDEQ_GAIN_MAX * FEEDEQ_GAIN_DIV)) ? "," : "");
231	}
232	printf("};\n");
233}
234
235function feedeq_calc_preamp(norm, gain, shift, mul, bit, attn)
236{
237	shift = FEEDEQ_PREAMP_SHIFT;
238
239	if (floor(FEEDEQ_PREAMP_BITDB) == 6 &&				\
240	    (1.0 * floor(gain)) == gain && (floor(gain) % 6) == 0) {
241		mul = 1;
242		shift = floor(floor(gain) / 6);
243	} else {
244		bit = 32.0 - ((1.0 * gain) / (1.0 * FEEDEQ_PREAMP_BITDB));
245		attn = pow(2.0, bit) / pow(2.0, 32.0);
246		mul = floor((attn * FEEDEQ_PREAMP_ONE) + 0.5);
247	}
248
249	while ((mul % 2) == 0 && shift > 0) {
250		mul = floor(mul / 2);
251		shift--;
252	}
253
254	norm["mul"] = mul;
255	norm["shift"] = shift;
256}
257
258BEGIN {
259	M_PI = atan2(0.0, -1.0);
260
261	INT32_MAX = 1 + ((shl(1, 30) - 1) * 2);
262	INT32_MIN = -1 - INT32_MAX;
263
264	FEEDEQ_TYPE_PEQ   = 0;
265	FEEDEQ_TYPE_SHELF = 1;
266
267	FEEDEQ_TYPE       = FEEDEQ_TYPE_PEQ;
268
269	FEEDEQ_COEFF_SHIFT = 24;
270	FEEDEQ_COEFF_ONE   = shl(1, FEEDEQ_COEFF_SHIFT);
271
272	FEEDEQ_PREAMP_SHIFT = 31;
273	FEEDEQ_PREAMP_ONE   = shl(1, FEEDEQ_PREAMP_SHIFT);
274	FEEDEQ_PREAMP_BITDB = 6; # 20.0 * (log(2.0) / log(10.0));
275
276	FEEDEQ_GAIN_DIV   = 10;
277	i = 0;
278	j = 1;
279	while (j < FEEDEQ_GAIN_DIV) {
280		j *= 2;
281		i++;
282	}
283	FEEDEQ_GAIN_SHIFT = i;
284	FEEDEQ_GAIN_FMASK = shl(1, FEEDEQ_GAIN_SHIFT) - 1;
285
286	FEEDEQ_GAIN_RECIPROCAL = 1.0 / FEEDEQ_GAIN_DIV;
287
288	if (ARGC == 2) {
289		i = 1;
290		split(ARGV[1], arg, ":");
291		while (match(arg[i], "^[^0-9]*$")) {
292			if (arg[i] == "PEQ") {
293				FEEDEQ_TYPE = FEEDEQ_TYPE_PEQ;
294			} else if (arg[i] == "SHELF") {
295				FEEDEQ_TYPE = FEEDEQ_TYPE_SHELF;
296			}
297			i++;
298		}
299		split(arg[i++], subarg, ",");
300		FEEDEQ_TREBLE_SFREQ = 1.0 * subarg[1];
301		FEEDEQ_TREBLE_SLOPE = 1.0 * subarg[2];
302		FEEDEQ_BASS_SFREQ = 1.0 * subarg[3];
303		FEEDEQ_BASS_SLOPE = 1.0 * subarg[4];
304		split(arg[i++], subarg, ",");
305		FEEDEQ_GAIN_MIN = floor(1.0 * subarg[1]);
306		FEEDEQ_GAIN_MAX = floor(1.0 * subarg[2]);
307		if (length(subarg) > 2) {
308			j = floor(1.0 * FEEDEQ_GAIN_DIV * subarg[3]);
309			if (j < 2)
310				j = 1;
311			else if (j < 5)
312				j = 2;
313			else if (j < 10)
314				j = 5;
315			else
316				j = 10;
317			if (j > FEEDEQ_GAIN_DIV || (FEEDEQ_GAIN_DIV % j) != 0)
318				j = FEEDEQ_GAIN_DIV;
319			FEEDEQ_GAIN_STEP = j;
320		} else
321			FEEDEQ_GAIN_STEP = FEEDEQ_GAIN_DIV;
322		split(arg[i], subarg, ",");
323		for (i = 1; i <= length(subarg); i++)
324			allfreq[i - 1] = floor(1.0 * subarg[i]);
325	} else {
326		FEEDEQ_TREBLE_SFREQ  = 16000.0;
327		FEEDEQ_TREBLE_SLOPE  = 0.25;
328		FEEDEQ_BASS_SFREQ    = 62.0;
329		FEEDEQ_BASS_SLOPE    = 0.25;
330
331		FEEDEQ_GAIN_MIN  = -9;
332		FEEDEQ_GAIN_MAX  = 9;
333
334		FEEDEQ_GAIN_STEP = FEEDEQ_GAIN_DIV;
335
336
337		allfreq[0] = 44100;
338		allfreq[1] = 48000;
339		allfreq[2] = 88200;
340		allfreq[3] = 96000;
341		allfreq[4] = 176400;
342		allfreq[5] = 192000;
343	}
344
345	FEEDEQ_LEVELS = ((FEEDEQ_GAIN_MAX - FEEDEQ_GAIN_MIN) *		\
346	    floor(FEEDEQ_GAIN_DIV / FEEDEQ_GAIN_STEP)) + 1;
347
348	FEEDEQ_ERR_CLIP = 0;
349
350	smallest = 10.000000;
351	largest  =  0.000010;
352
353	printf("#ifndef _FEEDER_EQ_GEN_H_\n");
354	printf("#define _FEEDER_EQ_GEN_H_\n\n");
355	printf("/*\n");
356	printf(" * Generated using feeder_eq_mkfilter.awk, heaven, wind and awesome.\n");
357	printf(" *\n");
358	printf(" * DO NOT EDIT!\n");
359	printf(" */\n\n");
360	printf("/*\n");
361	printf(" * EQ: %s\n", (FEEDEQ_TYPE == FEEDEQ_TYPE_SHELF) ?	\
362	    "Shelving" : "Peaking EQ");
363	printf(" */\n");
364	printf("#define FEEDER_EQ_PRESETS\t\"");
365	printf("%s:%d,%.4f,%d,%.4f:%d,%d,%.1f:",			\
366	    (FEEDEQ_TYPE == FEEDEQ_TYPE_SHELF) ? "SHELF" : "PEQ",	\
367	    FEEDEQ_TREBLE_SFREQ, FEEDEQ_TREBLE_SLOPE,			\
368	    FEEDEQ_BASS_SFREQ, FEEDEQ_BASS_SLOPE,			\
369	    FEEDEQ_GAIN_MIN, FEEDEQ_GAIN_MAX,				\
370	    FEEDEQ_GAIN_STEP * FEEDEQ_GAIN_RECIPROCAL);
371	for (i = 0; i < length(allfreq); i++) {
372		if (i != 0)
373			printf(",");
374		printf("%d", allfreq[i]);
375	}
376	printf("\"\n\n");
377	printf("struct feed_eq_coeff_tone {\n");
378	printf("\tint32_t a1, a2;\n");
379	printf("\tint32_t b0, b1, b2;\n");
380	printf("};\n\n");
381	printf("struct feed_eq_coeff {\n");
382	#printf("\tstruct {\n");
383	#printf("\t\tint32_t a1, a2;\n");
384	#printf("\t\tint32_t b0, b1, b2;\n");
385	#printf("\t} treble, bass;\n");
386	printf("\tstruct feed_eq_coeff_tone treble;\n");
387	printf("\tstruct feed_eq_coeff_tone bass;\n");
388	#printf("\tstruct {\n");
389	#printf("\t\tint32_t a1, a2;\n");
390	#printf("\t\tint32_t b0, b1, b2;\n");
391	#printf("\t} bass;\n");
392	printf("};\n");
393	for (i = 0; i < length(allfreq); i++)
394		feedeq_gen_freq_coeffs(allfreq[i]);
395	printf("\n");
396	printf("static const struct {\n");
397	printf("\tuint32_t rate;\n");
398	printf("\tstruct feed_eq_coeff *coeff;\n");
399	printf("} feed_eq_tab[] = {\n");
400	for (i = 0; i < length(allfreq); i++) {
401		printf("\t{ %6d, eq_%-6d },\n", allfreq[i], allfreq[i]);
402	}
403	printf("};\n");
404
405	printf("\n#define FEEDEQ_RATE_MIN\t\t%d\n", allfreq[0]);
406	printf("#define FEEDEQ_RATE_MAX\t\t%d\n", allfreq[length(allfreq) - 1]);
407	printf("\n#define FEEDEQ_TAB_SIZE\t\t\t\t\t\t\t\\\n");
408	printf("\t((int32_t)(sizeof(feed_eq_tab) / sizeof(feed_eq_tab[0])))\n");
409
410	printf("\nstatic const struct {\n");
411	printf("\tint32_t mul, shift;\n");
412	printf("} feed_eq_preamp[] = {\n");
413	for (i = (FEEDEQ_GAIN_MAX * 2 * FEEDEQ_GAIN_DIV); i >= 0;	\
414	    i -= FEEDEQ_GAIN_STEP) {
415		feedeq_calc_preamp(norm, i * FEEDEQ_GAIN_RECIPROCAL);
416		dbgain = ((FEEDEQ_GAIN_MAX * FEEDEQ_GAIN_DIV) - i) *	\
417		    FEEDEQ_GAIN_RECIPROCAL;
418		printf("\t{ 0x%08x, 0x%08x },\t/* %+5.1f dB */\n",	\
419		    norm["mul"], norm["shift"], dbgain);
420	}
421	printf("};\n");
422
423	printf("\n#define FEEDEQ_GAIN_MIN\t\t%d", FEEDEQ_GAIN_MIN);
424	printf("\n#define FEEDEQ_GAIN_MAX\t\t%d\n", FEEDEQ_GAIN_MAX);
425
426	printf("\n#define FEEDEQ_GAIN_SHIFT\t%d\n", FEEDEQ_GAIN_SHIFT);
427	printf("#define FEEDEQ_GAIN_DIV\t\t%d\n", FEEDEQ_GAIN_DIV);
428	printf("#define FEEDEQ_GAIN_FMASK\t0x%08x\n", FEEDEQ_GAIN_FMASK);
429	printf("#define FEEDEQ_GAIN_STEP\t%d\n", FEEDEQ_GAIN_STEP);
430
431	#printf("\n#define FEEDEQ_PREAMP_MIN\t-%d\n",			\
432	#    shl(FEEDEQ_GAIN_MAX, FEEDEQ_GAIN_SHIFT));
433	#printf("#define FEEDEQ_PREAMP_MAX\t%d\n",			\
434	#    shl(FEEDEQ_GAIN_MAX, FEEDEQ_GAIN_SHIFT));
435
436	printf("\n#define FEEDEQ_COEFF_SHIFT\t%d\n", FEEDEQ_COEFF_SHIFT);
437
438	#feedeq_calc_preamp(norm, FEEDEQ_GAIN_MAX);
439
440	#printf("#define FEEDEQ_COEFF_NORM(v)\t(");
441	#if (norm["mul"] == 1)
442	#	printf("(v) >> %d", norm["shift"]);
443	#else
444	#	printf("(0x%xLL * (v)) >> %d", norm["mul"], norm["shift"]);
445	#printf(")\n");
446
447	#printf("\n#define FEEDEQ_LEVELS\t\t%d\n", FEEDEQ_LEVELS);
448	if (FEEDEQ_ERR_CLIP != 0)
449		printf("\n#define FEEDEQ_ERR_CLIP\t\t%d\n", FEEDEQ_ERR_CLIP);
450	printf("\n/*\n");
451	printf(" * volume level mapping (0 - 100):\n");
452	printf(" *\n");
453
454	for (i = 0; i <= 100; i++) {
455		ind = floor((i * FEEDEQ_LEVELS) / 100);
456		if (ind >= FEEDEQ_LEVELS)
457			ind = FEEDEQ_LEVELS - 1;
458		printf(" *\t%3d  ->  %3d (%+5.1f dB)\n",		\
459		    i, ind, FEEDEQ_GAIN_MIN +				\
460		    (ind * (FEEDEQ_GAIN_RECIPROCAL * FEEDEQ_GAIN_STEP)));
461	}
462
463	printf(" */\n");
464	printf("\n/*\n * smallest: %.32f\n *  largest: %.32f\n */\n",	\
465	    smallest, largest);
466	printf("\n#endif\t/* !_FEEDER_EQ_GEN_H_ */\n");
467}
468