use ::std::sync::Arc;
use ::anyhow::{Result, ensure};
use crate::FRAME_S;
use crate::denoise::{Speech, SpeechReader};
use crate::dsp::{db_to_gain, ramp};
use crate::level::{self, SpeechLevel};
pub use crate::level::{MIN_SPEECH_FRAMES, SPEECH_ABOVE_FLOOR_DB};
use crate::param::Param;
use crate::stage::{Frame, Stage};
pub struct Agc {
level: SpeechLevel,
gain_db: f32,
speech: SpeechReader,
estimates: [Option<f32>; MAX_AHEAD + 1],
estimate: usize,
ahead: usize,
target: Param,
max_gain: Param,
threshold: Param,
}
pub const TARGET_DB: f32 = -18.;
pub const GATE_DB: f32 = -55.;
pub const MAX_GAIN_DB: f32 = 30.;
pub const MIN_GAIN_DB: f32 = -12.;
pub const SPEECH_SNR_DB: f32 = 0.;
pub const SNR_OFF_DB: f32 = -20.;
pub const MAX_AHEAD: usize = 8;
const RISE_DB_PER_S: f32 = 6.;
const FALL_DB_PER_S: f32 = 30.;
impl Agc {
pub fn new() -> Self {
Self {
level: SpeechLevel::new(GATE_DB, TARGET_DB),
gain_db: 0.,
speech: SpeechReader::new(Arc::new(Speech::new())),
estimates: [None; MAX_AHEAD + 1],
estimate: 0,
ahead: 0,
target: target_param(),
max_gain: Param::new("max-gain", "Maximum Gain", "dB", (0., 40., 1.), MAX_GAIN_DB),
threshold: Param::new(
"threshold",
"Speech Threshold",
"dB",
(SNR_OFF_DB, 20., 0.5),
SPEECH_SNR_DB,
),
}
}
pub fn listening(self, speech: Arc<Speech>, ahead: usize) -> Result<Self> {
ensure!(
ahead <= MAX_AHEAD,
"the estimate comes {ahead} frames ahead, at most {MAX_AHEAD} are supported"
);
Ok(Self {
speech: SpeechReader::new(speech),
ahead,
..self
})
}
fn hears_speech(&mut self) -> Option<bool> {
self.estimates[self.estimate] = self.speech.read();
let len = self.estimates.len();
let belonging = self.estimates[(self.estimate + len - self.ahead) % len];
self.estimate = (self.estimate + 1) % len;
belonging.map(|snr_db| snr_db > self.threshold.get())
}
pub fn target(&self) -> Param {
self.target.clone()
}
pub fn gain_db(&self) -> f32 {
self.gain_db
}
}
impl Default for Agc {
fn default() -> Self {
Self::new()
}
}
impl Stage for Agc {
fn name(&self) -> &'static str {
"agc"
}
fn latency(&self) -> usize {
0
}
fn params(&self) -> Vec<Param> {
vec![
self.target.clone(),
self.max_gain.clone(),
self.threshold.clone(),
]
}
fn trace(&self) -> Option<(&'static str, f32)> {
Some(("gain", self.gain_db))
}
fn process(&mut self, frame: &mut Frame) -> Result<()> {
let frame_db = level::frame_db(frame);
let heard = self.hears_speech().unwrap_or(true);
let level_db = self.level.push(frame_db, heard);
let wanted = (self.target.get() - level_db).clamp(MIN_GAIN_DB, self.max_gain.get());
let previous = self.gain_db;
self.gain_db = if wanted > previous {
wanted.min(previous + RISE_DB_PER_S * FRAME_S)
} else {
wanted.max(previous - FALL_DB_PER_S * FRAME_S)
};
let gains = ramp(db_to_gain(previous), db_to_gain(self.gain_db));
for (sample, gain) in frame.iter_mut().zip(gains) {
*sample *= gain;
}
Ok(())
}
}
pub fn target_param() -> Param {
Param::new(
"target",
"Target Level",
"dBFS",
(-30., -12., 0.5),
TARGET_DB,
)
}