use ::std::sync::Arc;
use ::std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
use ::std::time::Instant;
use ::rtrb::{Consumer, Producer, RingBuffer};
use crate::atomic::AtomicF32;
use crate::chain::Chain;
use crate::frame_time::{FrameTime, Summary};
use crate::level::{self, Meter, NoiseFloor};
use crate::rt_alloc;
use crate::stage::Frame;
use crate::{FRAME_LEN, SAMPLE_RATE};
#[derive(Default)]
pub struct Stats {
pub frames: AtomicU64,
pub errors: AtomicU64,
pub underruns: AtomicU64,
pub dropped: AtomicU64,
pub frame_times: [FrameTime; FRAME_TIME_PARTS.len()],
pub bridge_delay: AtomicI64,
pub quantum: AtomicU64,
pub capture_delay: AtomicI64,
pub playback_delay: AtomicI64,
pub input_db: AtomicF32,
pub output_db: AtomicF32,
pub input_floor_db: AtomicF32,
captured_at_ns: AtomicI64,
captured_block: AtomicU64,
pending: AtomicU64,
}
pub const FRAME_TIME_PARTS: [&str; 4] = ["total", "echo", "denoise", "other"];
const TIMED: [&str; 2] = ["echo", "denoise"];
impl Stats {
pub fn frame_times(&self) -> impl Iterator<Item = (&'static str, Summary)> {
FRAME_TIME_PARTS
.into_iter()
.zip(&self.frame_times)
.map(|(part, time)| (part, time.last()))
}
pub fn latency(&self, chain_latency: usize) -> [(&'static str, i64); 4] {
[
("microphone", self.capture_delay.load(Ordering::Relaxed)),
("bridge", self.bridge_delay.load(Ordering::Relaxed)),
("chain", chain_latency as i64),
("app", self.playback_delay.load(Ordering::Relaxed)),
]
}
}
pub struct Capture {
chain: Chain,
frame: Frame,
filled: usize,
output: Producer<f32>,
stats: Arc<Stats>,
input_meter: Meter,
output_meter: Meter,
input_floor: NoiseFloor,
}
pub struct Playback {
input: Consumer<f32>,
stats: Arc<Stats>,
}
const CAPACITY: usize = 16 * FRAME_LEN;
pub fn bridge(mut chain: Chain) -> (Capture, Playback, Arc<Stats>) {
chain.time(&TIMED);
let (output, input) = RingBuffer::new(CAPACITY);
let stats = Arc::new(Stats::default());
for level in [&stats.input_db, &stats.output_db, &stats.input_floor_db] {
level.store(-120.);
}
let capture = Capture {
chain,
frame: [0.; FRAME_LEN],
filled: 0,
output,
stats: stats.clone(),
input_meter: Meter::new(),
output_meter: Meter::new(),
input_floor: NoiseFloor::new(),
};
let playback = Playback {
input,
stats: stats.clone(),
};
(capture, playback, stats)
}
impl Capture {
pub fn latency(&self) -> usize {
self.chain.latency()
}
pub fn push(&mut self, mut samples: &[f32], now_ns: i64) {
self.stats.captured_at_ns.store(now_ns, Ordering::Relaxed);
self.stats
.captured_block
.store(samples.len() as u64, Ordering::Relaxed);
while !samples.is_empty() {
let n = (FRAME_LEN - self.filled).min(samples.len());
self.frame[self.filled..self.filled + n].copy_from_slice(&samples[..n]);
self.filled += n;
samples = &samples[n..];
if self.filled == FRAME_LEN {
self.filled = 0;
self.process_frame();
}
}
self.stats
.pending
.store(self.filled as u64, Ordering::Relaxed);
}
fn process_frame(&mut self) {
let started = Instant::now();
let input_db = level::frame_db(&self.frame);
if rt_alloc::audio_path(|| self.chain.process(&mut self.frame)).is_err() {
self.stats.errors.fetch_add(1, Ordering::Relaxed);
self.frame.fill(0.);
}
let elapsed = started.elapsed().as_nanos() as u64;
let stats = &self.stats;
let [total, timed @ .., other] = &stats.frame_times;
total.record(elapsed);
let mut timed_ns = 0;
for (time, &ns) in timed.iter().zip(self.chain.times()) {
time.record(ns);
timed_ns += ns;
}
other.record(elapsed.saturating_sub(timed_ns));
stats.input_db.store(self.input_meter.push(input_db));
stats.input_floor_db.store(self.input_floor.push(input_db));
let output_db = level::frame_db(&self.frame);
stats.output_db.store(self.output_meter.push(output_db));
self.stats.frames.fetch_add(1, Ordering::Relaxed);
match self.output.write_chunk_uninit(FRAME_LEN) {
Ok(chunk) => {
chunk.fill_from_iter(self.frame.iter().copied());
}
Err(_) => {
self.stats
.dropped
.fetch_add(FRAME_LEN as u64, Ordering::Relaxed);
}
}
}
}
impl Playback {
pub fn pull(&mut self, out: &mut [f32], now_ns: i64) {
self.update_delay(out.len(), now_ns);
let n = self.input.slots().min(out.len());
if let Ok(chunk) = self.input.read_chunk(n) {
let (first, second) = chunk.as_slices();
out[..first.len()].copy_from_slice(first);
out[first.len()..n].copy_from_slice(second);
chunk.commit_all();
}
if n < out.len() {
out[n..].fill(0.);
self.stats
.underruns
.fetch_add((out.len() - n) as u64, Ordering::Relaxed);
}
let left = self.input.slots();
if left > out.len() + 2 * FRAME_LEN {
let drop = left - (out.len() + FRAME_LEN);
if let Ok(chunk) = self.input.read_chunk(drop) {
chunk.commit_all();
}
self.stats.dropped.fetch_add(drop as u64, Ordering::Relaxed);
}
}
fn update_delay(&self, quantum: usize, now_ns: i64) {
let stats = &self.stats;
stats.quantum.store(quantum as u64, Ordering::Relaxed);
let block = stats.captured_block.load(Ordering::Relaxed) as i64;
if block == 0 {
return;
}
let since_push_ns = now_ns - stats.captured_at_ns.load(Ordering::Relaxed);
let since_push = (since_push_ns as f64 * SAMPLE_RATE as f64 / 1e9).round() as i64;
let waiting = self.input.slots() as i64 + stats.pending.load(Ordering::Relaxed) as i64;
stats
.bridge_delay
.store(since_push - block + waiting, Ordering::Relaxed);
}
pub fn buffered(&self) -> usize {
self.input.slots()
}
}