use ::std::sync::Arc;
use ::anyhow::{Result, ensure};
use crate::denoise::{Speech, SpeechReader};
use crate::dsp::{db_to_gain, ramp};
use crate::level::{self, NoiseFloor};
use crate::param::Param;
use crate::stage::{Frame, Stage};
use crate::{FRAME_LEN, SAMPLE_RATE};
pub struct Agc {
level_db: f32,
gain_db: f32,
floor: NoiseFloor,
loud_frames: usize,
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_ABOVE_FLOOR_DB: f32 = 10.;
pub const MIN_SPEECH_FRAMES: usize = 8;
pub const SPEECH_SNR_DB: f32 = 0.;
pub const SNR_OFF_DB: f32 = -20.;
pub const MAX_AHEAD: usize = 8;
const LEVEL_TAU: f32 = 0.3;
const RISE_DB_PER_S: f32 = 6.;
const FALL_DB_PER_S: f32 = 30.;
const FRAME_S: f32 = FRAME_LEN as f32 / SAMPLE_RATE as f32;
impl Agc {
pub fn new() -> Self {
Self {
level_db: TARGET_DB,
gain_db: 0.,
floor: NoiseFloor::new(),
loud_frames: 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 process(&mut self, frame: &mut Frame) -> Result<()> {
let frame_db = level::frame_db(frame);
let floor_db = self.floor.push(frame_db);
let loud = frame_db > GATE_DB && frame_db > floor_db + SPEECH_ABOVE_FLOOR_DB;
let heard = self.hears_speech().unwrap_or(true);
let speech = loud && heard;
self.loud_frames = if speech {
(self.loud_frames + 1).min(MIN_SPEECH_FRAMES)
} else {
0
};
if self.loud_frames == MIN_SPEECH_FRAMES {
let alpha = 1. - (-FRAME_S / LEVEL_TAU).exp();
self.level_db += (frame_db - self.level_db) * alpha;
}
let wanted = (self.target.get() - self.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,
)
}