use ::std::sync::Arc;
use ::std::sync::atomic::{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::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>,
}
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,
}
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.),
}
}
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 echo = Self {
apm,
reference: consumer,
render: [0.; FRAME_LEN],
render_out: [0.; FRAME_LEN],
capture: [0.; FRAME_LEN],
status: status.clone(),
};
(echo, Reference { producer, status })
}
pub fn status(&self) -> Arc<EchoStatus> {
self.status.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 process(&mut self, frame: &mut Frame) -> Result<()> {
let _flush = FlushDenormals::new();
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.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))
};
}
}