use crate::onset::{AccentFrame, OnsetAnalyzer, SAMPLE_RATE};
use crate::tracker::{Tracker, TrackerUpdate};
use rtrb::{Consumer, Producer, RingBuffer};
use rubato::audioadapter_buffers::direct::InterleavedSlice;
use rubato::{Fft, FixedSync, Resampler};
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum StreamError {
#[error("sample rate {0} Hz is outside the supported range 8000..=192000 Hz")]
UnsupportedSampleRate(usize),
#[error("audio queue capacity must be positive")]
ZeroCapacity,
#[error("could not initialize resampler: {0}")]
Resampler(#[from] rubato::ResamplerConstructionError),
}
const CHUNK: usize = 512;
struct AudioAdapter {
resampler: Option<Fft<f64>>,
input: [f64; CHUNK],
filled: usize,
output: Vec<f64>,
}
impl AudioAdapter {
fn new(sample_rate: usize) -> Result<Self, StreamError> {
if !(8_000..=192_000).contains(&sample_rate) {
return Err(StreamError::UnsupportedSampleRate(sample_rate));
}
let resampler = if sample_rate == SAMPLE_RATE {
None
} else {
Some(Fft::new(
sample_rate,
SAMPLE_RATE,
CHUNK,
1,
FixedSync::Input,
)?)
};
let output = vec![0.; resampler.as_ref().map_or(0, Resampler::output_frames_max)];
Ok(Self {
resampler,
input: [0.; CHUNK],
filled: 0,
output,
})
}
fn resampler_delay(&self) -> usize {
self.resampler.as_ref().map_or(0, Resampler::output_delay)
}
fn reset(&mut self) {
self.filled = 0;
self.input.fill(0.);
if let Some(r) = &mut self.resampler {
r.reset();
}
}
fn process(&mut self, samples: &[f32], mut emit: impl FnMut(&[f64])) {
for &sample in samples {
self.input[self.filled] = if sample.is_finite() {
sample as f64
} else {
0.0
};
self.filled += 1;
if self.filled != CHUNK {
continue;
}
if let Some(r) = &mut self.resampler {
let input = InterleavedSlice::new(&self.input, 1, CHUNK)
.expect("fixed mono input buffer must remain valid");
let output_frames = self.output.len();
let mut output = InterleavedSlice::new_mut(&mut self.output, 1, output_frames)
.expect("preallocated mono output buffer must remain valid");
let (_, count) = r
.process_into_buffer(&input, &mut output, None)
.expect("fixed resampler buffers must remain valid");
emit(&self.output[..count]);
} else {
emit(&self.input);
}
self.filled = 0;
}
}
}
pub struct FeatureStream {
adapter: AudioAdapter,
onset: OnsetAnalyzer,
}
impl FeatureStream {
pub fn new(sample_rate: usize) -> Result<Self, StreamError> {
Ok(Self {
adapter: AudioAdapter::new(sample_rate)?,
onset: OnsetAnalyzer::new(),
})
}
pub fn resampler_delay(&self) -> usize {
self.adapter.resampler_delay()
}
pub fn reset(&mut self) {
self.adapter.reset();
self.onset.reset();
}
pub fn process(&mut self, samples: &[f32], mut emit: impl FnMut(AccentFrame)) {
let engine = &mut self.onset;
self.adapter
.process(samples, |audio| engine.process(audio, &mut emit));
}
}
pub struct MeterStream {
adapter: AudioAdapter,
tracker: Tracker,
}
impl MeterStream {
pub fn new(sample_rate: usize) -> Result<Self, StreamError> {
Ok(Self {
adapter: AudioAdapter::new(sample_rate)?,
tracker: Tracker::new(),
})
}
pub fn resampler_delay(&self) -> usize {
self.adapter.resampler_delay()
}
pub fn reset(&mut self) {
self.adapter.reset();
self.tracker.reset();
}
pub fn process(&mut self, samples: &[f32], mut emit: impl FnMut(TrackerUpdate)) {
let engine = &mut self.tracker;
self.adapter
.process(samples, |audio| engine.process(audio, &mut emit));
}
}
#[derive(Clone, Copy)]
struct Sample {
sequence: u64,
value: f32,
}
pub struct AudioInput {
producer: Producer<Sample>,
sequence: u64,
}
impl AudioInput {
pub fn push(&mut self, mono: &[f32]) -> usize {
let mut dropped = 0;
for &value in mono {
if self
.producer
.push(Sample {
sequence: self.sequence,
value,
})
.is_err()
{
dropped += 1;
}
self.sequence = self.sequence.wrapping_add(1);
}
dropped
}
}
struct AudioQueue {
consumer: Consumer<Sample>,
expected: u64,
generation: u64,
}
impl AudioQueue {
fn new(capacity: usize) -> (AudioInput, Self) {
let (producer, consumer) = RingBuffer::new(capacity);
(
AudioInput {
producer,
sequence: 0,
},
Self {
consumer,
expected: 0,
generation: 0,
},
)
}
fn poll(&mut self, limit: usize, mut consume: impl FnMut(f32, u64, bool)) -> usize {
let mut consumed = 0;
while consumed < limit {
let Ok(sample) = self.consumer.pop() else {
break;
};
let discontinuity = sample.sequence != self.expected;
if discontinuity {
self.generation = self.generation.wrapping_add(1);
}
self.expected = sample.sequence.wrapping_add(1);
consume(sample.value, self.generation, discontinuity);
consumed += 1;
}
consumed
}
}
pub struct FeatureWorker {
queue: AudioQueue,
stream: FeatureStream,
}
impl FeatureWorker {
pub fn resampler_delay(&self) -> usize {
self.stream.resampler_delay()
}
pub fn poll(&mut self, limit: usize, mut emit: impl FnMut(u64, AccentFrame)) -> usize {
let stream = &mut self.stream;
self.queue.poll(limit, |sample, generation, discontinuity| {
if discontinuity {
stream.reset();
}
stream.process(&[sample], |frame| emit(generation, frame));
})
}
}
pub fn audio_channel(
sample_rate: usize,
capacity: usize,
) -> Result<(AudioInput, FeatureWorker), StreamError> {
if capacity == 0 {
return Err(StreamError::ZeroCapacity);
}
let stream = FeatureStream::new(sample_rate)?;
let (input, queue) = AudioQueue::new(capacity);
Ok((input, FeatureWorker { queue, stream }))
}
pub struct MeterWorker {
queue: AudioQueue,
stream: MeterStream,
}
impl MeterWorker {
pub fn resampler_delay(&self) -> usize {
self.stream.resampler_delay()
}
pub fn poll(&mut self, limit: usize, mut emit: impl FnMut(u64, TrackerUpdate)) -> usize {
let stream = &mut self.stream;
self.queue.poll(limit, |sample, generation, discontinuity| {
if discontinuity {
stream.reset();
}
stream.process(&[sample], |frame| emit(generation, frame));
})
}
}
pub fn meter_channel(
sample_rate: usize,
capacity: usize,
) -> Result<(AudioInput, MeterWorker), StreamError> {
if capacity == 0 {
return Err(StreamError::ZeroCapacity);
}
let stream = MeterStream::new(sample_rate)?;
let (input, queue) = AudioQueue::new(capacity);
Ok((input, MeterWorker { queue, stream }))
}