136 lines
3.0 KiB
Go
136 lines
3.0 KiB
Go
package audio
|
|
|
|
import (
|
|
"math"
|
|
)
|
|
|
|
// BiquadFilter represents a second-order IIR filter.
|
|
// Formulas from RBJ Audio-EQ-Cookbook.
|
|
type BiquadFilter struct {
|
|
// Coefficients
|
|
b0, b1, b2, a1, a2 float64
|
|
|
|
// State (history)
|
|
x1, x2, y1, y2 float64
|
|
}
|
|
|
|
// NewPeakingEQ creates a peaking EQ filter (boost/cut at specific frequency)
|
|
// rate: sample rate (e.g. 48000)
|
|
// freq: center frequency in Hz
|
|
// q: quality factor (width of the bell)
|
|
// dbGain: gain in decibels (e.g. +3.0, -6.0)
|
|
func NewPeakingEQ(rate, freq, q, dbGain float64) *BiquadFilter {
|
|
f := &BiquadFilter{}
|
|
f.Configure(rate, freq, q, dbGain)
|
|
return f
|
|
}
|
|
|
|
// Configure recalculates coefficients
|
|
func (f *BiquadFilter) Configure(rate, freq, q, dbGain float64) {
|
|
// Intermediate variables
|
|
A := math.Pow(10, dbGain/40)
|
|
omega := 2 * math.Pi * freq / rate
|
|
sn := math.Sin(omega)
|
|
cs := math.Cos(omega)
|
|
alpha := sn / (2 * q)
|
|
|
|
// Coefficients
|
|
b0 := 1 + alpha*A
|
|
b1 := -2 * cs
|
|
b2 := 1 - alpha*A
|
|
a0 := 1 + alpha/A
|
|
a1 := -2 * cs
|
|
a2 := 1 - alpha/A
|
|
|
|
// Normalize by a0
|
|
invA0 := 1 / a0
|
|
f.b0 = b0 * invA0
|
|
f.b1 = b1 * invA0
|
|
f.b2 = b2 * invA0
|
|
f.a1 = a1 * invA0
|
|
f.a2 = a2 * invA0
|
|
}
|
|
|
|
// Process processes a single sample
|
|
func (f *BiquadFilter) Process(in float64) float64 {
|
|
// Difference equation:
|
|
// y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] - a1*y[n-1] - a2*y[n-2]
|
|
out := f.b0*in + f.b1*f.x1 + f.b2*f.x2 - f.a1*f.y1 - f.a2*f.y2
|
|
|
|
// Update history
|
|
f.x2 = f.x1
|
|
f.x1 = in
|
|
f.y2 = f.y1
|
|
f.y1 = out
|
|
|
|
return out
|
|
}
|
|
|
|
// Reset clears the filter memory
|
|
func (f *BiquadFilter) Reset() {
|
|
f.x1, f.x2, f.y1, f.y2 = 0, 0, 0, 0
|
|
}
|
|
|
|
// EQChain manages a cascade of filters (our 5 bands)
|
|
type EQChain struct {
|
|
Filters []*BiquadFilter
|
|
}
|
|
|
|
// NewEQChain creates the standard 5-band EQ chain
|
|
func NewEQChain(sampleRate float64) *EQChain {
|
|
return &EQChain{
|
|
Filters: []*BiquadFilter{
|
|
NewPeakingEQ(sampleRate, 100, 1.0, 0), // SUB (Reduced from 1000 to proper bass freq)
|
|
NewPeakingEQ(sampleRate, 350, 1.0, 0), // LOW
|
|
NewPeakingEQ(sampleRate, 1000, 1.0, 0), // MID
|
|
NewPeakingEQ(sampleRate, 3000, 1.0, 0), // HI
|
|
NewPeakingEQ(sampleRate, 8000, 1.0, 0), // AIR
|
|
},
|
|
}
|
|
}
|
|
|
|
// SetGain sets the gain for a specific band index (0-4)
|
|
func (e *EQChain) SetGain(bandIdx int, dbGain float64) {
|
|
if bandIdx < 0 || bandIdx >= len(e.Filters) {
|
|
return
|
|
}
|
|
|
|
rate := 48000.0 // Assuming fixed rate for now
|
|
// Frequencies map to our standard bands
|
|
freqs := []float64{100, 350, 1000, 3000, 8000}
|
|
|
|
e.Filters[bandIdx].Configure(rate, freqs[bandIdx], 1.0, dbGain)
|
|
}
|
|
|
|
// Reset clears history of all filters
|
|
func (e *EQChain) Reset() {
|
|
for _, f := range e.Filters {
|
|
f.Reset()
|
|
}
|
|
}
|
|
|
|
// ProcessBlock processes a slice of samples in-place (or returns new slice)
|
|
// We'll return a new float buffer for FFT analysis anyway
|
|
func (e *EQChain) Process(samples []int16) []int16 {
|
|
out := make([]int16, len(samples))
|
|
|
|
for i, s := range samples {
|
|
val := float64(s)
|
|
|
|
// Run through cascade
|
|
for _, f := range e.Filters {
|
|
val = f.Process(val)
|
|
}
|
|
|
|
// Clip
|
|
if val > 32767 {
|
|
val = 32767
|
|
} else if val < -32768 {
|
|
val = -32768
|
|
}
|
|
|
|
out[i] = int16(val)
|
|
}
|
|
return out
|
|
}
|