use ::anyhow::Result;
use crate::dsp::{db_to_gain, smoothing};
use crate::param::Param;
use crate::stage::{Frame, Stage};
use crate::{FRAME_LEN, SAMPLE_RATE};
pub struct Limiter {
delay: [f32; LOOKAHEAD],
gain: f32,
ceiling: Param,
release: Param,
}
pub const LOOKAHEAD: usize = SAMPLE_RATE as usize / 1000;
pub const CEILING_DB: f32 = -1.;
const ATTACK_TAU: f32 = LOOKAHEAD as f32 / SAMPLE_RATE as f32 / 4.;
pub const RELEASE_MS: f32 = 50.;
impl Limiter {
pub fn new() -> Self {
Self {
delay: [0.; LOOKAHEAD],
gain: 1.,
ceiling: Param::new("ceiling", "Ceiling", "dBFS", (-6., 0., 0.5), CEILING_DB),
release: Param::new("release", "Release", "ms", (10., 200., 5.), RELEASE_MS),
}
}
}
impl Default for Limiter {
fn default() -> Self {
Self::new()
}
}
impl Stage for Limiter {
fn name(&self) -> &'static str {
"limiter"
}
fn latency(&self) -> usize {
LOOKAHEAD
}
fn params(&self) -> Vec<Param> {
vec![self.ceiling.clone(), self.release.clone()]
}
fn process(&mut self, frame: &mut Frame) -> Result<()> {
let ceiling = db_to_gain(self.ceiling.get());
let attack = smoothing(ATTACK_TAU);
let release = smoothing(self.release.get() / 1000.);
let mut work = [0.; LOOKAHEAD + FRAME_LEN];
work[..LOOKAHEAD].copy_from_slice(&self.delay);
work[LOOKAHEAD..].copy_from_slice(frame);
let mut peaks = [0f32; FRAME_LEN];
for offset in 0..=LOOKAHEAD {
for (peak, x) in peaks.iter_mut().zip(&work[offset..offset + FRAME_LEN]) {
*peak = peak.max(x.abs());
}
}
for (i, (out, peak)) in frame.iter_mut().zip(peaks).enumerate() {
let wanted = if peak > ceiling { ceiling / peak } else { 1. };
let rate = if wanted < self.gain { attack } else { release };
self.gain += (wanted - self.gain) * rate;
*out = (work[i] * self.gain).clamp(-ceiling, ceiling);
}
self.delay.copy_from_slice(&work[FRAME_LEN..]);
Ok(())
}
}