126 lines
4.5 KiB
Rust
126 lines
4.5 KiB
Rust
use std::time::Duration;
|
|
|
|
use anyhow::{Result, bail};
|
|
use audioadapter_buffers::direct::InterleavedSlice;
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
use rubato::Resampler;
|
|
use tracing::error;
|
|
|
|
pub struct Audio {
|
|
#[allow(unused)]
|
|
stream: cpal::Stream,
|
|
sampler: rubato::Async<f32>,
|
|
input_buffer: Vec<f32>,
|
|
output_buffer: Vec<f32>,
|
|
sample_sink: rtrb::Producer<f32>,
|
|
}
|
|
|
|
const VB_FREQUENCY: usize = 41700;
|
|
|
|
impl Audio {
|
|
pub fn init() -> Result<Self> {
|
|
let host = cpal::default_host();
|
|
let Some(device) = host.default_output_device() else {
|
|
bail!("No output device available");
|
|
};
|
|
let Some(config) = device
|
|
.supported_output_configs()?
|
|
.find(|c| c.channels() == 2 && c.sample_format().is_float())
|
|
else {
|
|
bail!("No suitable output config available");
|
|
};
|
|
let mut config = config.with_max_sample_rate().config();
|
|
let resample_ratio = config.sample_rate.0 as f64 / VB_FREQUENCY as f64;
|
|
let chunk_size = (834.0 * resample_ratio) as usize;
|
|
let sampler = rubato::Async::new_poly(
|
|
resample_ratio,
|
|
64.0,
|
|
rubato::PolynomialDegree::Cubic,
|
|
chunk_size,
|
|
2,
|
|
rubato::FixedAsync::Output,
|
|
)?;
|
|
config.buffer_size = cpal::BufferSize::Fixed(sampler.output_frames_max() as u32);
|
|
|
|
let input_buffer = Vec::with_capacity(sampler.nbr_channels() * sampler.input_frames_max());
|
|
let output_buffer = vec![0.0; sampler.nbr_channels() * sampler.output_frames_max()];
|
|
let (sample_sink, mut sample_source) =
|
|
rtrb::RingBuffer::new(sampler.output_frames_max() * 4);
|
|
|
|
let stream = device.build_output_stream(
|
|
&config,
|
|
move |data: &mut [f32], _| {
|
|
let requested = data.len();
|
|
let chunk = match sample_source.read_chunk(data.len()) {
|
|
Ok(c) => c,
|
|
Err(rtrb::chunks::ChunkError::TooFewSlots(n)) => {
|
|
sample_source.read_chunk(n).unwrap()
|
|
}
|
|
};
|
|
let len = chunk.len();
|
|
let (first, second) = chunk.as_slices();
|
|
data[0..first.len()].copy_from_slice(first);
|
|
data[first.len()..len].copy_from_slice(second);
|
|
for rest in &mut data[len..requested] {
|
|
*rest = 0.0;
|
|
}
|
|
chunk.commit_all();
|
|
},
|
|
move |error| error!(%error, "stream error"),
|
|
None,
|
|
)?;
|
|
stream.play()?;
|
|
Ok(Self {
|
|
stream,
|
|
sampler,
|
|
input_buffer,
|
|
output_buffer,
|
|
sample_sink,
|
|
})
|
|
}
|
|
|
|
pub fn update(&mut self, mut samples: &[f32]) {
|
|
while self.input_buffer.len() + samples.len() >= self.sampler.input_frames_next() * 2 {
|
|
let samples_needed =
|
|
(self.sampler.input_frames_next() * 2).saturating_sub(self.input_buffer.len());
|
|
let (current_samples, future_samples) = samples.split_at(samples_needed);
|
|
self.input_buffer.extend_from_slice(current_samples);
|
|
samples = future_samples;
|
|
|
|
let buffer_in =
|
|
InterleavedSlice::new(&self.input_buffer, 2, self.sampler.input_frames_next())
|
|
.unwrap();
|
|
let mut buffer_out = InterleavedSlice::new_mut(
|
|
&mut self.output_buffer,
|
|
2,
|
|
self.sampler.output_frames_next(),
|
|
)
|
|
.unwrap();
|
|
let (_, output_samples) = self
|
|
.sampler
|
|
.process_into_buffer(&buffer_in, &mut buffer_out, None)
|
|
.unwrap();
|
|
let chunk = match self.sample_sink.write_chunk_uninit(output_samples * 2) {
|
|
Ok(c) => c,
|
|
Err(rtrb::chunks::ChunkError::TooFewSlots(n)) => {
|
|
self.sample_sink.write_chunk_uninit(n).unwrap()
|
|
}
|
|
};
|
|
chunk.fill_from_iter(self.output_buffer[..output_samples * 2].iter().copied());
|
|
|
|
self.input_buffer.clear();
|
|
}
|
|
self.input_buffer.extend_from_slice(samples);
|
|
|
|
while self.sample_sink.slots() < self.sampler.output_frames_max() * 2 {
|
|
std::thread::sleep(Duration::from_micros(500));
|
|
}
|
|
}
|
|
|
|
pub fn set_speed(&mut self, speed: f64) -> Result<()> {
|
|
self.sampler
|
|
.set_resample_ratio_relative(1.0 / speed, false)?;
|
|
Ok(())
|
|
}
|
|
}
|