use ::std::sync::Arc;
use ::std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use ::anyhow::{Result, anyhow};
use ::rtrb::{Consumer, Producer, RingBuffer};
use ::sonora::config::{EchoCanceller, MaxProcessingRate, Pipeline};
use ::sonora::{AudioProcessing, Config, StreamConfig};
use crate::atomic::AtomicF32;
use crate::level;
use crate::param::Param;
use crate::stage::{Frame, Stage};
use crate::{FRAME_LEN, SAMPLE_RATE};
pub struct Echo {
apm: AudioProcessing,
reference: Consumer<f32>,
render: [f32; FRAME_LEN],
render_out: [f32; FRAME_LEN],
capture: [f32; FRAME_LEN],
status: Arc<EchoStatus>,
delay: [f32; LATENCY + FRAME_LEN],
sidechain: Arc<Sidechain>,
silent: usize,
idle: usize,
}
pub const SILENT_DB: f32 = -70.;
pub const SILENCE_FRAMES: usize = 100;
#[derive(Debug)]
pub struct Sidechain {
frames: AtomicU64,
raw: [AtomicF32; FRAME_LEN],
status: Arc<EchoStatus>,
protect: Param,
}
impl Sidechain {
pub fn frames(&self) -> u64 {
self.frames.load(Ordering::Relaxed)
}
pub fn raw(&self, out: &mut Frame) {
for (x, slot) in out.iter_mut().zip(&self.raw) {
*x = slot.load();
}
}
pub fn playing(&self) -> bool {
self.status.playing()
}
pub fn protect(&self) -> f32 {
self.protect.get() / 100.
}
}
pub struct Reference {
producer: Producer<f32>,
status: Arc<EchoStatus>,
}
#[derive(Debug)]
pub struct EchoStatus {
capture_frames: AtomicU64,
reference_frames: AtomicU64,
reference_db: AtomicF32,
erle_db: AtomicF32,
erl_db: AtomicF32,
delay_ms: AtomicF32,
playing: AtomicBool,
}
const REFERENCE_DECAY_DB: f32 = 0.6;
impl EchoStatus {
fn new() -> Self {
Self {
capture_frames: AtomicU64::new(0),
reference_frames: AtomicU64::new(0),
reference_db: AtomicF32::new(-120.),
erle_db: AtomicF32::new(0.),
erl_db: AtomicF32::new(0.),
delay_ms: AtomicF32::new(0.),
playing: AtomicBool::new(false),
}
}
pub fn playing(&self) -> bool {
self.playing.load(Ordering::Relaxed)
}
pub fn capture_frames(&self) -> u64 {
self.capture_frames.load(Ordering::Relaxed)
}
pub fn reference_frames(&self) -> u64 {
self.reference_frames.load(Ordering::Relaxed)
}
pub fn reference_db(&self) -> f32 {
self.reference_db.load()
}
pub fn erle_db(&self) -> f32 {
self.erle_db.load()
}
pub fn erl_db(&self) -> f32 {
self.erl_db.load()
}
pub fn delay_ms(&self) -> f32 {
self.delay_ms.load()
}
}
const REFERENCE_CAPACITY: usize = 16384;
impl Echo {
pub fn new() -> (Self, Reference) {
let config = Config {
pipeline: Pipeline {
maximum_internal_processing_rate: MaxProcessingRate::Rate48kHz,
..Pipeline::default()
},
echo_canceller: Some(EchoCanceller::default()),
..Config::default()
};
let stream = StreamConfig::new(SAMPLE_RATE, 1);
let apm = AudioProcessing::builder()
.config(config)
.capture_config(stream)
.render_config(stream)
.build();
let (producer, consumer) = RingBuffer::new(REFERENCE_CAPACITY);
let status = Arc::new(EchoStatus::new());
let sidechain = Arc::new(Sidechain {
frames: AtomicU64::new(0),
raw: ::std::array::from_fn(|_| AtomicF32::new(0.)),
status: status.clone(),
protect: Param::new("protect", "Voice Protection", "%", (0., 100., 5.), 25.),
});
let echo = Self {
apm,
reference: consumer,
render: [0.; FRAME_LEN],
render_out: [0.; FRAME_LEN],
capture: [0.; FRAME_LEN],
status: status.clone(),
delay: [0.; LATENCY + FRAME_LEN],
sidechain,
silent: SILENCE_FRAMES,
idle: 0,
};
(echo, Reference { producer, status })
}
pub fn status(&self) -> Arc<EchoStatus> {
self.status.clone()
}
pub fn sidechain(&self) -> Arc<Sidechain> {
self.sidechain.clone()
}
}
impl Reference {
pub fn push(&mut self, samples: &[f32]) -> usize {
let fits = samples.len().min(self.producer.slots());
if let Ok(chunk) = self.producer.write_chunk_uninit(fits) {
chunk.fill_from_iter(samples[..fits].iter().copied());
}
samples.len() - fits
}
pub fn status(&self) -> Arc<EchoStatus> {
self.status.clone()
}
}
impl Stage for Echo {
fn name(&self) -> &'static str {
"echo"
}
fn latency(&self) -> usize {
LATENCY
}
fn resume_frames(&self) -> usize {
REFERENCE_CAPACITY.div_ceil(FRAME_LEN)
}
fn params(&self) -> Vec<Param> {
vec![self.sidechain.protect.clone()]
}
fn trace(&self) -> Option<(&'static str, f32)> {
Some(("playing", f32::from(u8::from(self.status.playing()))))
}
fn process(&mut self, frame: &mut Frame) -> Result<()> {
let _flush = FlushDenormals::new();
if self.reference.slots() < FRAME_LEN {
self.idle += 1;
if self.idle == SILENCE_FRAMES {
self.silent = SILENCE_FRAMES;
self.status.playing.store(false, Ordering::Relaxed);
}
} else {
self.idle = 0;
}
while self.reference.slots() >= FRAME_LEN {
let chunk = self
.reference
.read_chunk(FRAME_LEN)
.map_err(|err| anyhow!("{err}"))?;
let (first, second) = chunk.as_slices();
self.render[..first.len()].copy_from_slice(first);
self.render[first.len()..].copy_from_slice(second);
chunk.commit_all();
self.apm
.process_render_f32(&[&self.render], &mut [&mut self.render_out])
.map_err(|err| anyhow!("{err}"))?;
let status = &self.status;
let level_db = level::frame_db(&self.render);
let peak_db = (status.reference_db() - REFERENCE_DECAY_DB).max(level_db);
status.reference_db.store(peak_db);
status.reference_frames.fetch_add(1, Ordering::Relaxed);
self.silent = if level_db < SILENT_DB {
self.silent.saturating_add(1)
} else {
0
};
status
.playing
.store(self.silent < SILENCE_FRAMES, Ordering::Relaxed);
}
self.delay[LATENCY..].copy_from_slice(frame);
for (slot, x) in self.sidechain.raw.iter().zip(&self.delay) {
slot.store(*x);
}
self.delay.copy_within(FRAME_LEN.., 0);
self.sidechain.frames.fetch_add(1, Ordering::Relaxed);
self.capture.copy_from_slice(frame);
self.apm
.process_capture_f32(&[&self.capture], &mut [frame])
.map_err(|err| anyhow!("{err}"))?;
let stats = self.apm.statistics();
let status = &self.status;
if let Some(erle) = stats.echo_return_loss_enhancement {
status.erle_db.store(erle as f32);
}
if let Some(erl) = stats.echo_return_loss {
status.erl_db.store(erl as f32);
}
if let Some(delay) = stats.delay_ms {
status.delay_ms.store(delay as f32);
}
status.capture_frames.fetch_add(1, Ordering::Relaxed);
Ok(())
}
}
pub const LATENCY: usize = 238;
struct FlushDenormals {
#[cfg(target_arch = "x86_64")]
saved: u32,
}
impl FlushDenormals {
#[cfg(target_arch = "x86_64")]
fn new() -> Self {
const FTZ_DAZ: u32 = 0x8040;
let mut saved = 0u32;
unsafe { ::std::arch::asm!("stmxcsr [{}]", in(reg) &mut saved, options(nostack)) };
let flushing = saved | FTZ_DAZ;
unsafe { ::std::arch::asm!("ldmxcsr [{}]", in(reg) &flushing, options(nostack)) };
Self { saved }
}
#[cfg(not(target_arch = "x86_64"))]
fn new() -> Self {
Self {}
}
}
impl Drop for FlushDenormals {
fn drop(&mut self) {
#[cfg(target_arch = "x86_64")]
unsafe {
::std::arch::asm!("ldmxcsr [{}]", in(reg) &self.saved, options(nostack))
};
}
}