use ::std::sync::Arc;
use ::anyhow::Result;
use crate::denoise::{Speech, SpeechReader};
use crate::dsp::{db_to_gain, ramp};
use crate::level;
use crate::param::Param;
use crate::stage::{Frame, Stage};
use crate::{FRAME_LEN, FRAME_S, SAMPLE_RATE};
pub struct Expander {
speech: SpeechReader,
range: Param,
threshold: Param,
hold: Param,
level: Param,
gain_db: f32,
holding: usize,
}
pub const RANGE_DB: f32 = 20.;
pub const THRESHOLD_DB: f32 = 0.;
pub const HOLD_MS: f32 = 200.;
pub const LEVEL_DB: f32 = -50.;
pub const RELEASE_S: f32 = 0.15;
impl Expander {
pub fn new() -> Self {
Self {
speech: SpeechReader::new(Arc::new(Speech::new())),
range: Param::new("range", "Range", "dB", (0., 40., 1.), RANGE_DB),
threshold: Param::new(
"threshold",
"Speech Threshold",
"dB",
(-10., 20., 0.5),
THRESHOLD_DB,
),
hold: Param::new("hold", "Hold", "ms", (50., 1000., 10.), HOLD_MS),
level: Param::new("level", "Opens Above", "dBFS", (-70., -20., 1.), LEVEL_DB),
gain_db: 0.,
holding: 0,
}
}
pub fn listening(self, speech: Arc<Speech>) -> Self {
Self {
speech: SpeechReader::new(speech),
..self
}
}
pub fn gain_db(&self) -> f32 {
self.gain_db
}
fn speaks(&mut self, frame: &Frame) -> bool {
let snr_db = self.speech.read();
level::frame_db(frame) > self.level.get()
|| snr_db.is_some_and(|snr_db| snr_db > self.threshold.get())
}
}
impl Default for Expander {
fn default() -> Self {
Self::new()
}
}
impl Stage for Expander {
fn name(&self) -> &'static str {
"expander"
}
fn latency(&self) -> usize {
0
}
fn params(&self) -> Vec<Param> {
vec![
self.range.clone(),
self.threshold.clone(),
self.hold.clone(),
self.level.clone(),
]
}
fn trace(&self) -> Option<(&'static str, f32)> {
Some(("gain", self.gain_db))
}
fn process(&mut self, frame: &mut Frame) -> Result<()> {
let range = self.range.get();
if self.speaks(frame) {
self.holding = (self.hold.get() / 1000. * SAMPLE_RATE as f32) as usize;
}
let previous = self.gain_db.max(-range);
self.gain_db = if self.holding > 0 {
self.holding = self.holding.saturating_sub(FRAME_LEN);
0.
} else {
let step = range / RELEASE_S * FRAME_S;
(previous - step).max(-range)
};
if previous == self.gain_db {
if previous < 0. {
let gain = db_to_gain(previous);
frame.iter_mut().for_each(|sample| *sample *= gain);
}
return Ok(());
}
for (sample, db) in frame.iter_mut().zip(ramp(previous, self.gain_db)) {
*sample *= db_to_gain(db);
}
Ok(())
}
}