#define TAU_F32 6.28318530717958647692f internal void fft_init(Arena *arena, FFT *fft, u32 size_pow2) { Assert(is_pow(size_pow2) && size_pow2 >= 8 && size_pow2 <= 65536); fft->size = size_pow2; fft->log2_size = (u32)__builtin_ctz(size_pow2); fft->bit_reverse = PushArrayAligned(arena, u16, size_pow2); for(u32 index = 0; index < size_pow2; ++index) { u32 reversed = 0; for(u32 bit = 0; bit < fft->log2_size; ++bit) { reversed |= ((index >> bit) & 1) << (fft->log2_size - 1 - bit); } fft->bit_reverse[index] = (u16)reversed; } fft->twiddle_re = PushArrayAligned(arena, f32, size_pow2); fft->twiddle_im = PushArrayAligned(arena, f32, size_pow2); for(u32 half = 1; half < size_pow2; half <<= 1) { for(u32 k = 0; k < half; ++k) { f64 angle = -(f64)TAU_F32 * (f64)k / (f64)(half * 2); fft->twiddle_re[half - 1 + k] = (f32)cos(angle); fft->twiddle_im[half - 1 + k] = (f32)sin(angle); } } } internal void fft_forward(FFT *fft, f32 *re, f32 *im) { u32 n = fft->size; //- bit reversal permutation for(u32 index = 0; index < n; ++index) { u32 other = fft->bit_reverse[index]; if(other > index) { f32 tr = re[index]; re[index] = re[other]; re[other] = tr; f32 ti = im[index]; im[index] = im[other]; im[other] = ti; } } //- stage 1 and 2 are scalar, the butterflies are too narrow for 4 lanes for(u32 start = 0; start < n; start += 2) { f32 ar = re[start], ai = im[start]; f32 br = re[start + 1], bi = im[start + 1]; re[start] = ar + br; im[start] = ai + bi; re[start + 1] = ar - br; im[start + 1] = ai - bi; } for(u32 start = 0; start < n; start += 4) { // k = 0: w = 1 f32 ar = re[start], ai = im[start]; f32 br = re[start + 2], bi = im[start + 2]; re[start] = ar + br; im[start] = ai + bi; re[start + 2] = ar - br; im[start + 2] = ai - bi; // k = 1: w = -i, so b*w = (bi, -br) ar = re[start + 1]; ai = im[start + 1]; br = re[start + 3]; bi = im[start + 3]; re[start + 1] = ar + bi; im[start + 1] = ai - br; re[start + 3] = ar - bi; im[start + 3] = ai + br; } //- remaining stages, half >= 4 for(u32 half = 4; half < n; half <<= 1) { const f32 *wr_table = fft->twiddle_re + half - 1; const f32 *wi_table = fft->twiddle_im + half - 1; u32 size = half * 2; for(u32 start = 0; start < n; start += size) { f32 *a_re = re + start; f32 *a_im = im + start; f32 *b_re = re + start + half; f32 *b_im = im + start + half; u32 k = 0; #if SIMD_NEON || SIMD_SSE for(; k + 4 <= half; k += 4) { f32x4 wr = f32x4_load(wr_table + k); f32x4 wi = f32x4_load(wi_table + k); f32x4 br = f32x4_load(b_re + k); f32x4 bi = f32x4_load(b_im + k); // t = b * w f32x4 tr = f32x4_msub(f32x4_mul(br, wr), bi, wi); f32x4 ti = f32x4_madd(f32x4_mul(br, wi), bi, wr); f32x4 ar = f32x4_load(a_re + k); f32x4 ai = f32x4_load(a_im + k); f32x4_store(a_re + k, f32x4_add(ar, tr)); f32x4_store(a_im + k, f32x4_add(ai, ti)); f32x4_store(b_re + k, f32x4_sub(ar, tr)); f32x4_store(b_im + k, f32x4_sub(ai, ti)); } #endif for(; k < half; ++k) { f32 wr = wr_table[k], wi = wi_table[k]; f32 tr = b_re[k] * wr - b_im[k] * wi; f32 ti = b_re[k] * wi + b_im[k] * wr; f32 ar = a_re[k], ai = a_im[k]; a_re[k] = ar + tr; a_im[k] = ai + ti; b_re[k] = ar - tr; b_im[k] = ai - ti; } } } } //- spectrum internal void spectrum_init(Arena *arena, Spectrum *spectrum) { MemSetZero(spectrum, sizeof(*spectrum)); fft_init(arena, &spectrum->fft, SPECTRUM_FFT_SIZE); u32 n = SPECTRUM_FFT_SIZE; spectrum->window = PushArrayAligned(arena, f32, n); spectrum->re = PushArrayAligned(arena, f32, n); spectrum->im = PushArrayAligned(arena, f32, n); spectrum->power = PushArrayAligned(arena, f32, n / 2); for(u32 index = 0; index < n; ++index) { spectrum->window[index] = 0.5f - 0.5f * cosf(TAU_F32 * (f32)index / (f32)(n - 1)); } spectrum_set_rate(spectrum, 44100); } internal void spectrum_set_rate(Spectrum *spectrum, u32 rate) { if(rate == 0 || rate == spectrum->rate) { return; } spectrum->rate = rate; // NOTE: log spaced bars between 50hz and 14khz, recitation lives mostly in 100hz-5khz so the // log mapping gives the voice most of the width f32 low = 50.0f; f32 high = Min(14000.0f, (f32)rate * 0.45f); f32 bin_hz = (f32)rate / (f32)SPECTRUM_FFT_SIZE; u32 max_bin = SPECTRUM_FFT_SIZE / 2 - 1; u32 last_used = 0; for(u32 bar = 0; bar < SPECTRUM_BARS; ++bar) { f32 f0 = low * powf(high / low, (f32)bar / SPECTRUM_BARS); f32 f1 = low * powf(high / low, (f32)(bar + 1) / SPECTRUM_BARS); u32 first = (u32)(f0 / bin_hz); u32 last = (u32)(f1 / bin_hz); first = Clamp(first, 1u, max_bin); last = Clamp(last, first, max_bin); spectrum->bar_first[bar] = (u16)first; spectrum->bar_last[bar] = (u16)last; last_used = last; } } internal void spectrum_update(Spectrum *spectrum, const f32 *stereo, f32 dt) { u32 n = SPECTRUM_FFT_SIZE; simd_mono_window(spectrum->re, stereo, spectrum->window, n); MemSetZero(spectrum->im, sizeof(f32) * n); fft_forward(&spectrum->fft, spectrum->re, spectrum->im); simd_power(spectrum->power, spectrum->re, spectrum->im, n / 2); // NOTE: a full scale sine through a hann window peaks at n/4 in magnitude f32 reference_power = (f32)(n / 4) * (f32)(n / 4); f32 attack = 1.0f - expf(-dt * 30.0f); f32 release = 1.0f - expf(-dt * 7.0f); f32 loudness = 0.0f; for(u32 bar = 0; bar < SPECTRUM_BARS; ++bar) { f32 power = 0.0f; for(u32 bin = spectrum->bar_first[bar]; bin <= spectrum->bar_last[bar]; ++bin) { power = Max(power, spectrum->power[bin]); } // -72 dB .. -6 dB mapped to 0..1, plus a gentle tilt so the highs aren't always dead f32 db = 10.0f * log10f(power / reference_power + 1e-12f); f32 tilt = 9.0f * (f32)bar / SPECTRUM_BARS; f32 target = Clamp((db + tilt + 72.0f) / 66.0f, 0.0f, 1.0f); f32 *value = &spectrum->bars[bar]; *value += (target - *value) * ((target > *value) ? attack : release); f32 *peak = &spectrum->peaks[bar]; *peak = Max(*peak - dt * 0.35f, *value); loudness += *value; } loudness /= SPECTRUM_BARS; spectrum->level += (loudness - spectrum->level) * release; } internal void spectrum_decay(Spectrum *spectrum, f32 dt) { f32 release = 1.0f - expf(-dt * 6.0f); for(u32 bar = 0; bar < SPECTRUM_BARS; ++bar) { spectrum->bars[bar] -= spectrum->bars[bar] * release; spectrum->peaks[bar] = Max(spectrum->peaks[bar] - dt * 0.35f, spectrum->bars[bar]); } spectrum->level -= spectrum->level * release; }