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