Central frequencies of band filters with cut-offs at 0 and the sampling rate

Question

I'm trying to configure AutoEq for SuperEQ. The latter was originally a Winamp DSP, but now it's used in foobar2000 and DeaDBeeF.

AutoEq requires a list of central frequencies and Q-factors for equaliser bands. SuperEQ's cut-off frequencies can be found in the source:

#define NBANDS 17
static REAL bands[NBANDS] = {
    65.406392,92.498606,130.81278,184.99721,261.62557,369.99442,523.25113,
    739.9884 ,1046.5023,1479.9768,2093.0045,2959.9536,4186.0091,5919.9072,
    8372.0181,11839.814,16744.036
};

For the middle bands, central frequencies computed as geometric means sqrt(bands[i + 1] * bands[i]) do match the values displayed in GUI:

"55 Hz",
"77 Hz",
"110 Hz",
"156 Hz",
"220 Hz",
"311 Hz",
"440 Hz",
"622 Hz",
"880 Hz",
"1.2 kHz",
"1.8 kHz",
"2.5 kHz",
"3.5 kHz",
"5 kHz",
"7 kHz",
"10 kHz",
"14 kHz",
"20 kHz"

Q-factor for the middle bands sqrt(bands[i + 1] * bands[i]) / (bands[i + 1] - bands[i]) is 2.871.

The lowest and the highest bands, however, are problematic. Cut-off for the lowest band is 0, for the highest band it is the sampling rate (source):

(*pp)->lower = i == 0      ?  0 : bands[i-1];
(*pp)->upper = i == NBANDS ? fs : bands[i  ];

Geometric mean of 0 is zero, yet the central frequency of the lowest band is claimed to be 55 Hz in GUI. For the highest band, for a typical sampling rate of 44100, sqrt(16744.036 * 44100) = 27173.73709, which matches neither 20 kHz in DeaDBeeF's GUI, nor 19912 in Shibatch's original DSP.

Are there some different formulas for computing the central frequencies that would've reproduced 55 Hz and 20 kHz?

UPDATE: According to AviSynth docs, SuperEQ uses 16383th order FIR filters using FFT.

Also, it seems that only frequencies up to half of the sampling rate are actually used (makes sense considering the Nyquist–Shannon theorem):

for(e=param2.elm->next;e->next != NULL && e->upper < fs/2;e = e->next)

Answer 1

Apparently 55 Hz and 19912 Hz labels in the GUI were obtained by dividing next/multiplying previous centre by $\sqrt 2$ (which is correct for the middle bands), without paying any attention to the fact that it doesn't reflect the actual implementation.

Equalisation in the lowest band has no definite peak (see below); thus computing bandwidth at -3 dB of the peak is not gonna work. Seems like the centre frequency have to be computed as 65.406392 / 2, and not as a geometric mean, resulting in a Q-factor of 0.5.

When it comes to experimentation, I've downloaded white noise from https://www.audiocheck.net/testtones_whitenoise.php, and passed it through Foobar's converter with +10 dB equalisation.

from dataclasses import dataclass
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from scipy.signal import savgol_filter, spectrogram
@dataclass
class WavData:
    rate: int
    pcm: np.ndarray
    freqs: np.ndarray
    spectrum: np.ndarray
def read_wav(wav_path: str) -> WavData:
    rate, wav = wavfile.read(wav_path)
    freqs, _, spectrum = spectrogram(wav, rate, window=np.ones(wav.size), mode='magnitude')
    return WavData(rate, wav, freqs, spectrum.ravel())
orig = read_wav('./audiocheck.net_gaussian_whitenoise.wav')
gauss_low = read_wav('./Gaussian 55 10.wav')
gauss_high = read_wav('./Gaussian 20k 10.wav')
fig, axs = plt.subplots(3, 2)
for i, (title, wav) in enumerate([
    ('original', orig), ('55 Hz\n+10 dB', gauss_low), ('20 kHz\n+10 dB', gauss_high)
]):
    axs[i][0].set_ylabel(title)
    axs[i][0].plot(wav.freqs, wav.spectrum)
    axs[i][1].semilogx(wav.freqs, wav.spectrum)
fig.tight_layout()

gauss_low_diff = gauss_low.spectrum - orig.spectrum
gauss_high_diff = gauss_high.spectrum - orig.spectrum
fig, axs = plt.subplots(4, 2)
for i, (eq, wav, diff, slc, savgol_win) in enumerate([
    ('55 Hz\n+10 dB', gauss_low, gauss_low_diff, slice(None, 1000), 100),
    ('20 kHz\n+10 dB', gauss_high, gauss_high_diff, slice(160000, None), 1000)
]):
    for row, title, data in [
        (2 * i, eq, diff[slc]),
        (2 * i + 1, f'smooth\n{eq}', savgol_filter(diff[slc], savgol_win, 3))
    ]:
        axs[row][0].set_ylabel(title)
        axs[row][0].plot(wav.freqs[slc], data)
        axs[row][1].semilogx(wav.freqs[slc], data)
fig.tight_layout()

Answer 2

Ok, I looked around AutoEq code, and found out that the filter with zero cut-off is called low-shelf filter: main.py#L43.

Searching for “Q-factor for low-shelf filter” leads to Calculate Q factor of a Low Shelf and High Shelf filter on this very site. This question can be closed as a duplicate.

Formulas for shelf filters can be found at https://www.w3.org/TR/audio-eq-cookbook/:

$$ \frac 1 Q = \sqrt{\left(A + \frac 1 A\right)\left(\frac 1 S - 1\right) + 2} $$

Slope for SuperEQ is unknown, but it was suggested to always use 1, which results in $Q = \sqrt 2$. There is already a number of equalisers with such a value in AutoEq database:

'8_PEAKING_WITH_SHELVES': {
    ...
    'filters': [{
        'type': 'LOW_SHELF',
        'fc': 105.0,
        'q': 0.7
    },
    ...
}