use ::std::sync::Arc;
use ::std::sync::atomic::{AtomicBool, Ordering};
use ::anyhow::Result;
use crate::FRAME_LEN;
use crate::agc::Agc;
use crate::compressor::Compressor;
use crate::deesser::DeEsser;
use crate::denoise::Denoise;
use crate::dsp::ramp;
use crate::echo::{Echo, Reference};
use crate::equalizer::Equalizer;
use crate::expander::Expander;
use crate::highpass::HighPass;
use crate::limiter::Limiter;
use crate::param::Param;
use crate::stage::{Frame, Stage};
pub fn build(atten_lim: Option<f32>) -> Result<(Chain, Reference)> {
let denoise = Denoise::new()?;
build_with(match atten_lim {
Some(db) => denoise.with_atten_lim(db),
None => denoise,
})
}
pub fn build_with(denoise: Denoise) -> Result<(Chain, Reference)> {
let (echo, reference) = Echo::new();
let denoise = denoise.with_sidechain(echo.sidechain());
let agc = Agc::new().listening(denoise.speech(), denoise.latency() / FRAME_LEN)?;
let compressor = Compressor::new().following(agc.target());
let expander = Expander::new().listening(denoise.speech());
let chain = Chain::new(vec![
Box::new(HighPass::new()),
Box::new(echo),
Box::new(denoise),
Box::new(Equalizer::new()),
Box::new(DeEsser::new()),
Box::new(agc),
Box::new(compressor),
Box::new(expander),
Box::new(Limiter::new()),
]);
Ok((chain, reference))
}
pub struct Chain {
slots: Vec<Slot>,
}
struct Slot {
stage: Box<dyn Stage>,
enabled: Arc<AtomicBool>,
mix: f32,
dry: Vec<f32>,
paused: bool,
resuming: usize,
}
impl Chain {
pub fn new(stages: Vec<Box<dyn Stage>>) -> Self {
let slots = stages
.into_iter()
.map(|stage| Slot {
dry: vec![0.; stage.latency() + FRAME_LEN],
stage,
enabled: Arc::new(AtomicBool::new(true)),
mix: 1.,
paused: false,
resuming: 0,
})
.collect();
Self { slots }
}
pub fn stages(&self) -> impl Iterator<Item = &dyn Stage> {
self.slots.iter().map(|slot| &*slot.stage)
}
pub fn stages_mut(&mut self) -> impl Iterator<Item = &mut Box<dyn Stage>> {
self.slots.iter_mut().map(|slot| &mut slot.stage)
}
pub fn switches(&self) -> Vec<(&'static str, Arc<AtomicBool>)> {
self.slots
.iter()
.map(|slot| (slot.stage.name(), slot.enabled.clone()))
.collect()
}
pub fn params(&self) -> Vec<(&'static str, Param)> {
self.slots
.iter()
.flat_map(|slot| {
let name = slot.stage.name();
slot.stage
.params()
.into_iter()
.map(move |param| (name, param))
})
.collect()
}
pub fn latency(&self) -> usize {
self.slots.iter().map(|slot| slot.stage.latency()).sum()
}
pub fn process(&mut self, frame: &mut Frame) -> Result<()> {
for slot in &mut self.slots {
slot.process(frame)?;
}
Ok(())
}
}
impl Slot {
fn process(&mut self, frame: &mut Frame) -> Result<()> {
let enabled = self.enabled.load(Ordering::Relaxed);
if enabled && self.paused {
self.paused = false;
self.resuming = self.stage.resume_frames();
}
let latency = self.dry.len() - FRAME_LEN;
self.dry[latency..].copy_from_slice(frame);
if enabled || self.mix > 0. {
self.stage.process(frame)?;
let target = if enabled && self.resuming == 0 {
1.
} else {
0.
};
self.resuming = self.resuming.saturating_sub(1);
if target != 1. || self.mix != 1. {
let mixes = ramp(self.mix, target);
for ((wet, dry), mix) in frame.iter_mut().zip(&self.dry).zip(mixes) {
*wet = *wet * mix + dry * (1. - mix);
}
}
self.mix = target;
} else {
self.paused = true;
frame.copy_from_slice(&self.dry[..FRAME_LEN]);
}
self.dry.copy_within(FRAME_LEN.., 0);
Ok(())
}
}