use std::ops::Range;
use super::Delivery;
use crate::{Events, Sample};
#[derive(Default)]
pub(super) struct Output<S> {
quiet: Vec<Vec<S>>,
ready: Vec<Vec<S>>,
silence: Option<(f64, usize)>,
quiet_frames: usize,
pub emitted: usize,
}
impl<S: Sample> Output<S> {
pub fn start(&mut self, channels: usize, silence: Option<(f64, usize)>) {
for buffers in [&mut self.quiet, &mut self.ready] {
buffers.resize_with(channels, Vec::new);
buffers.iter_mut().for_each(Vec::clear);
}
self.silence = silence;
self.quiet_frames = 0;
self.emitted = 0;
}
pub fn accept(
&mut self,
block: &[Vec<S>],
count: usize,
start: usize,
skip: usize,
body: usize,
) -> Option<usize> {
let first = skip.saturating_sub(start).min(count);
let Some((threshold, hold)) = self.silence else {
self.emit(block, first..count);
return None;
};
let tail = body.saturating_sub(start).clamp(first, count);
self.emit(block, first..tail);
let hold = hold.max(1);
let quiet = |index: usize| {
block
.iter()
.all(|channel| channel[index].to_f64().abs() <= threshold)
};
let mut index = tail;
while index < count {
let silent = quiet(index);
let run = index
+ 1
+ (index + 1..count)
.take_while(|&i| quiet(i) == silent)
.count();
if silent {
let end = run.min(index.saturating_add(hold - self.quiet_frames));
for (held, channel) in self.quiet.iter_mut().zip(block) {
held.extend_from_slice(&channel[index..end]);
}
self.quiet_frames += end - index;
if self.quiet_frames >= hold {
return Some(end);
}
} else {
self.emit(block, index..run);
}
index = run;
}
None
}
fn emit(&mut self, block: &[Vec<S>], range: Range<usize>) {
if range.is_empty() {
return;
}
for ((ready, held), channel) in self.ready.iter_mut().zip(&mut self.quiet).zip(block) {
ready.append(held);
ready.extend_from_slice(&channel[range.clone()]);
}
self.emitted += self.quiet_frames + range.len();
self.quiet_frames = 0;
}
pub fn deliver(&mut self, events: &mut Events, consume: &mut impl FnMut(Delivery<'_, S>)) {
if self.ready.iter().any(|channel| !channel.is_empty()) || !events.is_empty() {
consume(Delivery {
audio: &self.ready.iter().map(Vec::as_slice).collect::<Vec<_>>(),
events,
});
for channel in &mut self.ready {
channel.clear();
}
events.clear();
}
}
}