1085 lines
38 KiB
Rust
1085 lines
38 KiB
Rust
mod reclamation;
|
|
pub use reclamation::AudioReclaimer;
|
|
use reclamation::{CallbackLane, Packet};
|
|
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
use prometeu_drivers::{AudioCommand, Channel, MAX_CHANNELS, OUTPUT_SAMPLE_RATE};
|
|
use prometeu_drivers::{AudioDelivery, AudioTransport};
|
|
use prometeu_hal::LoopMode;
|
|
use ringbuf::HeapRb;
|
|
use ringbuf::traits::{Consumer, Producer, Split};
|
|
use std::error::Error;
|
|
use std::fmt;
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
|
use std::time::{Duration, Instant};
|
|
|
|
trait AudioStreamHandle {
|
|
fn stop(&self) {}
|
|
}
|
|
|
|
impl AudioStreamHandle for cpal::Stream {
|
|
fn stop(&self) {
|
|
let _ = self.pause();
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum HostAudioError {
|
|
NoOutputDevice,
|
|
BuildStream(String),
|
|
PlayStream(String),
|
|
}
|
|
|
|
impl fmt::Display for HostAudioError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
HostAudioError::NoOutputDevice => write!(f, "no output device available"),
|
|
HostAudioError::BuildStream(err) => write!(f, "failed to build audio stream: {}", err),
|
|
HostAudioError::PlayStream(err) => write!(f, "failed to play audio stream: {}", err),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Error for HostAudioError {}
|
|
|
|
trait AudioRuntime {
|
|
type Device;
|
|
type Stream: AudioStreamHandle + 'static;
|
|
|
|
fn default_output_device(&self) -> Option<Self::Device>;
|
|
|
|
fn build_output_stream<D, E>(
|
|
&self,
|
|
device: &Self::Device,
|
|
config: &cpal::StreamConfig,
|
|
data_callback: D,
|
|
error_callback: E,
|
|
) -> Result<Self::Stream, HostAudioError>
|
|
where
|
|
D: FnMut(&mut [f32]) + Send + 'static,
|
|
E: FnMut(String) + Send + 'static;
|
|
|
|
fn play_stream(&self, stream: &Self::Stream) -> Result<(), HostAudioError>;
|
|
}
|
|
|
|
struct CpalAudioRuntime;
|
|
|
|
impl AudioRuntime for CpalAudioRuntime {
|
|
type Device = cpal::Device;
|
|
type Stream = cpal::Stream;
|
|
|
|
fn default_output_device(&self) -> Option<Self::Device> {
|
|
cpal::default_host().default_output_device()
|
|
}
|
|
|
|
fn build_output_stream<D, E>(
|
|
&self,
|
|
device: &Self::Device,
|
|
config: &cpal::StreamConfig,
|
|
mut data_callback: D,
|
|
mut error_callback: E,
|
|
) -> Result<Self::Stream, HostAudioError>
|
|
where
|
|
D: FnMut(&mut [f32]) + Send + 'static,
|
|
E: FnMut(String) + Send + 'static,
|
|
{
|
|
device
|
|
.build_output_stream(
|
|
config,
|
|
move |data: &mut [f32], _: &cpal::OutputCallbackInfo| data_callback(data),
|
|
move |err| error_callback(err.to_string()),
|
|
None,
|
|
)
|
|
.map_err(|err| HostAudioError::BuildStream(err.to_string()))
|
|
}
|
|
|
|
fn play_stream(&self, stream: &Self::Stream) -> Result<(), HostAudioError> {
|
|
stream.play().map_err(|err| HostAudioError::PlayStream(err.to_string()))
|
|
}
|
|
}
|
|
|
|
pub struct HostAudio {
|
|
transport: AudioTransport,
|
|
failed: Arc<AtomicBool>,
|
|
heartbeat: Arc<AtomicU64>,
|
|
last_heartbeat: u64,
|
|
last_progress: Instant,
|
|
pub perf_consumer: Option<ringbuf::wrap::CachingCons<Arc<HeapRb<u64>>>>,
|
|
_stream: Option<Box<dyn AudioStreamHandle>>,
|
|
reclaimer: Option<AudioReclaimer>,
|
|
}
|
|
|
|
impl Default for HostAudio {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl HostAudio {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
transport: AudioTransport::default(),
|
|
failed: Arc::new(AtomicBool::new(false)),
|
|
heartbeat: Arc::new(AtomicU64::new(0)),
|
|
last_heartbeat: 0,
|
|
last_progress: Instant::now(),
|
|
perf_consumer: None,
|
|
_stream: None,
|
|
reclaimer: None,
|
|
}
|
|
}
|
|
|
|
pub fn init(&mut self, transport: AudioTransport) -> Result<(), HostAudioError> {
|
|
self.transport = transport;
|
|
self.init_with_runtime(&CpalAudioRuntime)
|
|
}
|
|
|
|
fn init_with_runtime<R: AudioRuntime>(&mut self, runtime: &R) -> Result<(), HostAudioError> {
|
|
self.failed = Arc::new(AtomicBool::new(false));
|
|
self.heartbeat = Arc::new(AtomicU64::new(0));
|
|
self.last_heartbeat = 0;
|
|
self.last_progress = Instant::now();
|
|
self.perf_consumer = None;
|
|
self.stop_stream();
|
|
|
|
let device = runtime.default_output_device().ok_or(HostAudioError::NoOutputDevice)?;
|
|
|
|
let config = cpal::StreamConfig {
|
|
channels: 2,
|
|
sample_rate: cpal::SampleRate(OUTPUT_SAMPLE_RATE),
|
|
buffer_size: cpal::BufferSize::Default,
|
|
};
|
|
|
|
let transport = self.transport.clone();
|
|
let failed = self.failed.clone();
|
|
let heartbeat = self.heartbeat.clone();
|
|
|
|
let (mut callback, reclaimer) = AudioCallback::new();
|
|
|
|
// To pass performance data from the audio thread to the main thread
|
|
let audio_perf_rb = HeapRb::<u64>::new(64);
|
|
let (mut perf_prod, perf_cons) = audio_perf_rb.split();
|
|
|
|
let stream = runtime.build_output_stream(
|
|
&device,
|
|
&config,
|
|
move |data: &mut [f32]| {
|
|
heartbeat.fetch_add(1, Ordering::Relaxed);
|
|
callback.render(&transport, data);
|
|
// Sends processing time in microseconds
|
|
let _ = perf_prod.try_push(callback.mixer.last_processing_time.as_micros() as u64);
|
|
},
|
|
move |err| {
|
|
failed.store(true, Ordering::Relaxed);
|
|
eprintln!("audio stream error: {err}; switching to silent audio");
|
|
},
|
|
)?;
|
|
|
|
runtime.play_stream(&stream)?;
|
|
self.reclaimer = Some(reclaimer);
|
|
self.perf_consumer = Some(perf_cons);
|
|
self._stream = Some(Box::new(stream));
|
|
Ok(())
|
|
}
|
|
|
|
/// Called even while guest execution is backpressured. A failed or stalled
|
|
/// device cannot retain the only publication slot indefinitely.
|
|
pub fn service(&mut self) {
|
|
if let Some(reclaimer) = &mut self.reclaimer {
|
|
reclaimer.service(&self.transport);
|
|
}
|
|
let heartbeat = self.heartbeat.load(Ordering::Relaxed);
|
|
if heartbeat != self.last_heartbeat {
|
|
self.last_heartbeat = heartbeat;
|
|
self.last_progress = Instant::now();
|
|
}
|
|
if self._stream.is_some()
|
|
&& (self.failed.load(Ordering::Relaxed)
|
|
|| self.last_progress.elapsed() >= Duration::from_secs(2))
|
|
{
|
|
eprintln!("[HostAudio] Output unavailable/stalled; consuming audio silently.");
|
|
self.stop_stream();
|
|
self.perf_consumer = None;
|
|
}
|
|
if self._stream.is_none() {
|
|
self.transport.consume_silently();
|
|
}
|
|
}
|
|
|
|
fn stop_stream(&mut self) {
|
|
if let Some(stream) = self._stream.take() {
|
|
stream.stop();
|
|
drop(stream); // Stop/drop the callback before any silent consumer takes over.
|
|
}
|
|
if let Some(mut reclaimer) = self.reclaimer.take() {
|
|
reclaimer.service(&self.transport);
|
|
}
|
|
}
|
|
|
|
pub fn update_stats(&mut self, stats: &mut crate::stats::HostStats) {
|
|
if let Some(cons) = &mut self.perf_consumer {
|
|
while let Some(us) = cons.try_pop() {
|
|
stats.record_audio_perf(us);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drop for HostAudio {
|
|
fn drop(&mut self) {
|
|
self.stop_stream();
|
|
self.transport.consume_silently();
|
|
}
|
|
}
|
|
|
|
/// The same bounded runtime-owned data path used by CPAL and allocator tests.
|
|
pub struct AudioCallback {
|
|
mixer: AudioMixer,
|
|
lane: CallbackLane,
|
|
}
|
|
impl AudioCallback {
|
|
pub fn new() -> (Self, AudioReclaimer) {
|
|
let (lane, reclaimer) = reclamation::pool();
|
|
(Self { mixer: AudioMixer::new(), lane }, reclaimer)
|
|
}
|
|
pub fn render(&mut self, transport: &AudioTransport, data: &mut [f32]) {
|
|
let mut packet = self.lane.take();
|
|
if let Some(packet) = &mut packet {
|
|
// Reserve reclamation before acquiring any publication ownership.
|
|
self.mixer.retire_inactive(packet);
|
|
if let Some(delivery) = transport.try_take() {
|
|
self.mixer.apply_delivery_into(delivery, packet);
|
|
}
|
|
}
|
|
self.mixer.mix(data);
|
|
if let Some(mut packet) = packet {
|
|
self.mixer.retire_inactive(&mut packet);
|
|
self.lane.give_back(packet);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[allow(clippy::items_after_test_module)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::stats::HostStats;
|
|
|
|
struct FakeStream;
|
|
|
|
impl AudioStreamHandle for FakeStream {}
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct FakeDevice;
|
|
|
|
struct FakeRuntime {
|
|
has_device: bool,
|
|
build_result: Result<(), HostAudioError>,
|
|
play_result: Result<(), HostAudioError>,
|
|
}
|
|
|
|
impl AudioRuntime for FakeRuntime {
|
|
type Device = FakeDevice;
|
|
type Stream = FakeStream;
|
|
|
|
fn default_output_device(&self) -> Option<Self::Device> {
|
|
self.has_device.then_some(FakeDevice)
|
|
}
|
|
|
|
fn build_output_stream<D, E>(
|
|
&self,
|
|
_device: &Self::Device,
|
|
_config: &cpal::StreamConfig,
|
|
_data_callback: D,
|
|
_error_callback: E,
|
|
) -> Result<Self::Stream, HostAudioError>
|
|
where
|
|
D: FnMut(&mut [f32]) + Send + 'static,
|
|
E: FnMut(String) + Send + 'static,
|
|
{
|
|
self.build_result.clone().map(|_| FakeStream)
|
|
}
|
|
|
|
fn play_stream(&self, _stream: &Self::Stream) -> Result<(), HostAudioError> {
|
|
self.play_result.clone()
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_service_without_audio_is_safe() {
|
|
let mut audio = HostAudio::new();
|
|
audio.service();
|
|
assert!(audio.transport.ready());
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_stats_without_audio_is_safe() {
|
|
let mut audio = HostAudio::new();
|
|
let mut stats = HostStats::new();
|
|
|
|
audio.update_stats(&mut stats);
|
|
|
|
assert_eq!(stats.audio_load_accum_us, 0);
|
|
assert_eq!(stats.audio_load_samples, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_init_returns_error_when_no_output_device_exists() {
|
|
let mut audio = HostAudio::new();
|
|
let runtime = FakeRuntime { has_device: false, build_result: Ok(()), play_result: Ok(()) };
|
|
|
|
let result = audio.init_with_runtime(&runtime);
|
|
|
|
assert_eq!(result, Err(HostAudioError::NoOutputDevice));
|
|
assert!(audio.perf_consumer.is_none());
|
|
assert!(audio._stream.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_init_returns_error_when_stream_build_fails() {
|
|
let mut audio = HostAudio::new();
|
|
let runtime = FakeRuntime {
|
|
has_device: true,
|
|
build_result: Err(HostAudioError::BuildStream("simulated build failure".to_string())),
|
|
play_result: Ok(()),
|
|
};
|
|
|
|
let result = audio.init_with_runtime(&runtime);
|
|
|
|
assert_eq!(result, Err(HostAudioError::BuildStream("simulated build failure".to_string())));
|
|
assert!(audio.perf_consumer.is_none());
|
|
assert!(audio._stream.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_init_returns_error_when_stream_play_fails() {
|
|
let mut audio = HostAudio::new();
|
|
let runtime = FakeRuntime {
|
|
has_device: true,
|
|
build_result: Ok(()),
|
|
play_result: Err(HostAudioError::PlayStream("simulated play failure".to_string())),
|
|
};
|
|
|
|
let result = audio.init_with_runtime(&runtime);
|
|
|
|
assert_eq!(result, Err(HostAudioError::PlayStream("simulated play failure".to_string())));
|
|
assert!(audio.perf_consumer.is_none());
|
|
assert!(audio._stream.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_init_populates_audio_state_on_success() {
|
|
let mut audio = HostAudio::new();
|
|
let runtime = FakeRuntime { has_device: true, build_result: Ok(()), play_result: Ok(()) };
|
|
|
|
audio.init_with_runtime(&runtime).unwrap();
|
|
|
|
assert!(audio.perf_consumer.is_some());
|
|
assert!(audio._stream.is_some());
|
|
}
|
|
}
|
|
|
|
pub struct AudioMixer {
|
|
voices: [Channel; MAX_CHANNELS],
|
|
pub last_processing_time: Duration,
|
|
paused: bool,
|
|
epoch: u64,
|
|
}
|
|
|
|
impl Default for AudioMixer {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl AudioMixer {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
voices: Default::default(),
|
|
last_processing_time: Duration::ZERO,
|
|
paused: false,
|
|
epoch: 0,
|
|
}
|
|
}
|
|
|
|
fn apply_delivery_into(&mut self, delivery: AudioDelivery, packet: &mut Packet) {
|
|
if delivery.epoch < self.epoch {
|
|
packet.batches = [delivery.frame, delivery.lifecycle];
|
|
return;
|
|
}
|
|
if delivery.epoch != self.epoch {
|
|
for voice in &mut self.voices {
|
|
packet.retire(voice.sample.take());
|
|
*voice = Channel::default();
|
|
}
|
|
self.epoch = delivery.epoch;
|
|
}
|
|
for (slot, batch) in packet.batches.iter_mut().zip([delivery.frame, delivery.lifecycle]) {
|
|
*slot = batch;
|
|
}
|
|
// Move commands out of slots, keeping each vector allocation in its packet.
|
|
for index in 0..2 {
|
|
if let Some(mut batch) = packet.batches[index].take() {
|
|
for command in &mut batch {
|
|
let command =
|
|
std::mem::replace(command, AudioCommand::Stop { voice_id: MAX_CHANNELS });
|
|
self.process_command(command, packet);
|
|
}
|
|
packet.batches[index] = Some(batch);
|
|
}
|
|
}
|
|
self.paused = delivery.paused;
|
|
}
|
|
|
|
fn retire_inactive(&mut self, packet: &mut Packet) {
|
|
for voice in &mut self.voices {
|
|
if !voice.active {
|
|
packet.retire(voice.sample.take());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Signal-only tests use synchronous reclamation outside a data callback.
|
|
#[cfg(test)]
|
|
fn apply_delivery(&mut self, delivery: AudioDelivery) {
|
|
self.apply_delivery_into(delivery, &mut Packet::new());
|
|
}
|
|
#[cfg(test)]
|
|
fn fill_buffer(&mut self, buffer: &mut [f32]) {
|
|
self.mix(buffer);
|
|
self.retire_inactive(&mut Packet::new());
|
|
}
|
|
|
|
fn process_command(&mut self, cmd: AudioCommand, packet: &mut Packet) {
|
|
match cmd {
|
|
AudioCommand::Play { sample, voice_id, volume, pan, pitch, priority, loop_mode } => {
|
|
if voice_id < MAX_CHANNELS {
|
|
packet.retire(self.voices[voice_id].sample.take());
|
|
self.voices[voice_id] = Channel {
|
|
sample: Some(sample),
|
|
active: true,
|
|
pos: 0.0,
|
|
pitch,
|
|
volume,
|
|
pan,
|
|
loop_mode,
|
|
priority,
|
|
};
|
|
} else {
|
|
packet.retire(Some(sample));
|
|
}
|
|
}
|
|
AudioCommand::Stop { voice_id } => {
|
|
if voice_id < MAX_CHANNELS {
|
|
self.voices[voice_id].active = false;
|
|
packet.retire(self.voices[voice_id].sample.take());
|
|
}
|
|
}
|
|
AudioCommand::SetVolume { voice_id, volume } => {
|
|
if voice_id < MAX_CHANNELS {
|
|
self.voices[voice_id].volume = volume;
|
|
}
|
|
}
|
|
AudioCommand::SetPan { voice_id, pan } => {
|
|
if voice_id < MAX_CHANNELS {
|
|
self.voices[voice_id].pan = pan;
|
|
}
|
|
}
|
|
AudioCommand::SetPitch { voice_id, pitch } => {
|
|
if voice_id < MAX_CHANNELS {
|
|
self.voices[voice_id].pitch = pitch;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn mix(&mut self, buffer: &mut [f32]) {
|
|
let start = std::time::Instant::now();
|
|
// Zeroes the buffer (stereo)
|
|
for sample in buffer.iter_mut() {
|
|
*sample = 0.0;
|
|
}
|
|
|
|
if self.paused {
|
|
self.last_processing_time = start.elapsed();
|
|
return;
|
|
}
|
|
|
|
for voice in self.voices.iter_mut() {
|
|
if !voice.active {
|
|
continue;
|
|
}
|
|
let Some(sample) = voice.sample.as_ref() else {
|
|
continue;
|
|
};
|
|
let len = sample.data.len();
|
|
if len == 0 {
|
|
voice.active = false;
|
|
continue;
|
|
}
|
|
let (loop_start, end) = match (voice.loop_mode, sample.loop_start, sample.loop_end) {
|
|
(LoopMode::On, Some(start), Some(end)) if start < end && end as usize <= len => {
|
|
(start as f64, end as f64)
|
|
}
|
|
_ => (0.0, len as f64),
|
|
};
|
|
let ratio = sample.sample_rate as f64 / OUTPUT_SAMPLE_RATE as f64;
|
|
let volume = voice.volume as f32 / 255.0;
|
|
let pan = voice.pan as f32 / 255.0;
|
|
let left = volume * (1.0 - pan).sqrt();
|
|
let right = volume * pan.sqrt();
|
|
for frame in buffer.as_chunks_mut::<2>().0 {
|
|
let pos = voice.pos as usize;
|
|
if pos >= len {
|
|
voice.active = false;
|
|
break;
|
|
}
|
|
let s1 = sample.data[pos] as f32 / 32768.0;
|
|
let next = if voice.loop_mode == LoopMode::On && (pos + 1) as f64 >= end {
|
|
loop_start as usize
|
|
} else {
|
|
pos + 1
|
|
};
|
|
let s2 = sample.data.get(next).copied().unwrap_or(0) as f32 / 32768.0;
|
|
let value = s1 + (s2 - s1) * (voice.pos - pos as f64) as f32;
|
|
frame[0] += value * left;
|
|
frame[1] += value * right;
|
|
if ratio == 0.0 {
|
|
continue;
|
|
}
|
|
if voice.pitch >= (end - voice.pos) / ratio {
|
|
if voice.loop_mode == LoopMode::Off {
|
|
voice.active = false;
|
|
break;
|
|
}
|
|
let length = end - loop_start;
|
|
// Reduce before multiplication: every finite positive pitch,
|
|
// including f64::MAX, remains finite and wraps multiple loops.
|
|
let step = (voice.pitch % (length / ratio)) * ratio;
|
|
voice.pos = loop_start + (voice.pos - loop_start + step).rem_euclid(length);
|
|
if voice.pos >= end {
|
|
voice.pos = loop_start;
|
|
}
|
|
} else {
|
|
voice.pos += voice.pitch * ratio;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Final clamp to avoid clipping (optional if using f32, but good for fidelity)
|
|
for sample in buffer.iter_mut() {
|
|
*sample = sample.clamp(-1.0, 1.0);
|
|
}
|
|
self.last_processing_time = start.elapsed();
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod control_tests {
|
|
use super::*;
|
|
use prometeu_drivers::{Audio, MemoryBanks};
|
|
use prometeu_hal::{AudioBridge, AudioOpStatus, sample::Sample};
|
|
|
|
fn pair() -> (Audio, AudioMixer) {
|
|
(Audio::new(Arc::new(MemoryBanks::new())), AudioMixer::new())
|
|
}
|
|
fn apply(audio: &Audio, mixer: &mut AudioMixer) {
|
|
mixer.apply_delivery(audio.transport().try_take().unwrap());
|
|
}
|
|
fn play(audio: &mut Audio, sample: Arc<Sample>, pitch: f64, looping: bool) {
|
|
assert_eq!(
|
|
audio.play_sample(
|
|
sample,
|
|
0,
|
|
255,
|
|
0,
|
|
pitch,
|
|
0,
|
|
if looping { LoopMode::On } else { LoopMode::Off }
|
|
),
|
|
AudioOpStatus::Ok
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn one_shot_ignores_markers_and_loop_preserves_intro() {
|
|
for looping in [false, true] {
|
|
let (mut audio, mut mixer) = pair();
|
|
let sample =
|
|
Sample::new(48_000, vec![1024, 2048, 4096, 8192, 12288, 16384, 20480, 24576])
|
|
.with_loop(2, 4);
|
|
play(&mut audio, Arc::new(sample), 1.0, looping);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 20];
|
|
mixer.fill_buffer(&mut pcm);
|
|
let expected = if looping {
|
|
[1024, 2048, 4096, 8192, 4096, 8192, 4096, 8192, 4096, 8192]
|
|
} else {
|
|
[1024, 2048, 4096, 8192, 12288, 16384, 20480, 24576, 0, 0]
|
|
};
|
|
for (frame, value) in pcm.as_chunks::<2>().0.iter().zip(expected) {
|
|
assert_eq!(*frame, [value as f32 / 32768.0, 0.0]);
|
|
}
|
|
assert_eq!(mixer.voices[0].active, looping);
|
|
assert_eq!(mixer.voices[0].sample.is_some(), looping);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn absent_partial_and_invalid_markers_fall_back_to_full_sample() {
|
|
for (start, end) in [
|
|
(None, None),
|
|
(Some(1), None),
|
|
(None, Some(2)),
|
|
(Some(2), Some(2)),
|
|
(Some(3), Some(1)),
|
|
(Some(0), Some(5)),
|
|
(Some(u32::MAX), Some(u32::MAX)),
|
|
(Some(0), Some(0)),
|
|
] {
|
|
for looping in [false, true] {
|
|
let (mut audio, mut mixer) = pair();
|
|
let mut sample = Sample::new(48_000, vec![4096, 8192, 12288, 16384]);
|
|
sample.loop_start = start;
|
|
sample.loop_end = end;
|
|
play(&mut audio, Arc::new(sample), 1.0, looping);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 16];
|
|
mixer.fill_buffer(&mut pcm);
|
|
for (i, frame) in pcm.as_chunks::<2>().0.iter().enumerate() {
|
|
let value = if looping || i < 4 { (i % 4 + 1) as f32 / 8.0 } else { 0.0 };
|
|
assert_eq!(*frame, [value, 0.0], "markers {start:?}/{end:?}, loop {looping}");
|
|
}
|
|
assert_eq!(mixer.voices[0].active, looping);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn fractional_interpolation_uses_loop_seam_or_actual_tail() {
|
|
// Both rate conversion and fractional pitch produce a half-frame step.
|
|
for (rate, pitch) in [(48_000, 0.5), (24_000, 1.0), (96_000, 0.25)] {
|
|
for looping in [false, true] {
|
|
let (mut audio, mut mixer) = pair();
|
|
play(
|
|
&mut audio,
|
|
Arc::new(Sample::new(rate, vec![4096, 8192, 16384, 24576]).with_loop(1, 3)),
|
|
pitch,
|
|
looping,
|
|
);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 18];
|
|
mixer.fill_buffer(&mut pcm);
|
|
let expected = if looping {
|
|
[0.125, 0.1875, 0.25, 0.375, 0.5, 0.375, 0.25, 0.375, 0.5]
|
|
} else {
|
|
[0.125, 0.1875, 0.25, 0.375, 0.5, 0.625, 0.75, 0.375, 0.0]
|
|
};
|
|
for (frame, value) in pcm.as_chunks::<2>().0.iter().zip(expected) {
|
|
assert!((frame[0] - value).abs() <= 1e-6);
|
|
assert_eq!(frame[1], 0.0);
|
|
}
|
|
assert_eq!(mixer.voices[0].active, looping);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn empty_samples_terminate_without_indexing() {
|
|
for looping in [false, true] {
|
|
for marked in [false, true] {
|
|
let (mut audio, mut mixer) = pair();
|
|
let sample = Sample::new(48_000, vec![]);
|
|
let sample = if marked { sample.with_loop(0, 1) } else { sample };
|
|
play(&mut audio, Arc::new(sample), f64::MAX, looping);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [1.0; 8];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0; 8]);
|
|
assert!(!mixer.voices[0].active);
|
|
assert!(mixer.voices[0].sample.is_none());
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn multiple_wrap_pitch_preserves_selected_interval_and_signal() {
|
|
for (rate, pitch) in [(48_000, 5.0), (96_000, 2.5)] {
|
|
let (mut audio, mut mixer) = pair();
|
|
play(
|
|
&mut audio,
|
|
Arc::new(Sample::new(rate, vec![4096, 8192, 16384, 24576]).with_loop(1, 3)),
|
|
pitch,
|
|
true,
|
|
);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 10];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.125, 0.0, 0.25, 0.0, 0.5, 0.0, 0.25, 0.0, 0.5, 0.0]);
|
|
assert_eq!(mixer.voices[0].pos, 1.0);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn extreme_pitch_and_source_rates_keep_positions_finite() {
|
|
for rate in [0, 1, 44_100, 48_000, 96_000, u32::MAX] {
|
|
for looping in [false, true] {
|
|
let (mut audio, mut mixer) = pair();
|
|
play(
|
|
&mut audio,
|
|
Arc::new(Sample::new(rate, vec![4096, 8192, 16384, 24576]).with_loop(1, 3)),
|
|
f64::MAX,
|
|
looping,
|
|
);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 128];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert!(pcm.iter().all(|value| value.is_finite()));
|
|
assert!(mixer.voices[0].pos.is_finite());
|
|
if rate == 0 {
|
|
assert_eq!(mixer.voices[0].pos, 0.0);
|
|
assert!(pcm.as_chunks::<2>().0.iter().all(|frame| *frame == [0.125, 0.0]));
|
|
} else if looping {
|
|
assert!((1.0..3.0).contains(&mixer.voices[0].pos));
|
|
assert!(
|
|
pcm.as_chunks::<2>()
|
|
.0
|
|
.iter()
|
|
.skip(1)
|
|
.all(|frame| (0.25..=0.5).contains(&frame[0]))
|
|
);
|
|
} else {
|
|
assert_eq!(&pcm[..2], &[0.125, 0.0]);
|
|
assert!(pcm[2..].iter().all(|value| *value == 0.0));
|
|
}
|
|
assert_eq!(mixer.voices[0].active, looping || rate == 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pcm_controls_preserve_position_and_stop_is_idempotent() {
|
|
let (mut audio, mut mixer) = pair();
|
|
play(&mut audio, Arc::new(Sample::new(48_000, vec![16384; 32])), 1.0, true);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 4];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.5, 0.0, 0.5, 0.0]);
|
|
assert_eq!(mixer.voices[0].pos, 2.0);
|
|
audio.set_pan(0, 255);
|
|
audio.set_volume(0, 51);
|
|
audio.set_pitch(0, 2.0);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
assert_eq!(mixer.voices[0].pos, 2.0);
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0, 0.1, 0.0, 0.1]);
|
|
assert_eq!(mixer.voices[0].pos, 6.0);
|
|
audio.set_volume(0, 0);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0; 4]);
|
|
assert_eq!(mixer.voices[0].pos, 10.0);
|
|
audio.stop(0);
|
|
audio.stop(0);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0; 4]);
|
|
assert!(mixer.voices[0].sample.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn fifo_reuse_and_inactive_setters_do_not_create_play_defaults() {
|
|
let (mut audio, mut mixer) = pair();
|
|
audio.set_volume(0, 0);
|
|
audio.set_pitch(0, 4.0);
|
|
play(&mut audio, Arc::new(Sample::new(48_000, vec![16384; 16])), 1.0, true);
|
|
audio.stop(0);
|
|
play(&mut audio, Arc::new(Sample::new(48_000, vec![8192; 16])), 1.0, true);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 2];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.25, 0.0]);
|
|
assert_eq!(mixer.voices[0].pos, 1.0);
|
|
}
|
|
|
|
#[test]
|
|
fn pause_and_session_reset_work_with_pending_batches() {
|
|
let (mut audio, mut mixer) = pair();
|
|
audio.set_session(Some(1));
|
|
play(&mut audio, Arc::new(Sample::new(48_000, vec![16384; 16])), 1.0, true);
|
|
audio.finish_frame();
|
|
audio.set_paused(true);
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [1.0; 4];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0; 4]);
|
|
assert_eq!(mixer.voices[0].pos, 0.0);
|
|
audio.begin_lifecycle();
|
|
audio.set_pan(0, 255);
|
|
audio.finish_lifecycle(true);
|
|
audio.set_paused(false);
|
|
apply(&audio, &mut mixer);
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0, 0.5, 0.0, 0.5]);
|
|
assert_eq!(mixer.voices[0].pos, 2.0);
|
|
play(&mut audio, Arc::new(Sample::new(48_000, vec![16384; 16])), 1.0, true);
|
|
audio.finish_frame();
|
|
let stale = audio.transport().try_take().unwrap();
|
|
audio.reset();
|
|
apply(&audio, &mut mixer);
|
|
mixer.apply_delivery(stale);
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0; 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn play_before_home_cannot_restart_after_callback_stop_and_resume() {
|
|
let (mut audio, mut mixer) = pair();
|
|
play(&mut audio, Arc::new(Sample::new(48_000, vec![16384; 16])), 1.0, true);
|
|
// Home occurs before FRAME_SYNC; the old play must precede the hook stop.
|
|
audio.set_paused(true);
|
|
audio.begin_lifecycle();
|
|
audio.stop(0);
|
|
audio.finish_lifecycle(true);
|
|
apply(&audio, &mut mixer);
|
|
assert!(mixer.voices[0].sample.is_none());
|
|
audio.begin_lifecycle();
|
|
audio.finish_lifecycle(true);
|
|
audio.set_paused(false);
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [1.0; 16];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0; 16]);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm, [0.0; 16]);
|
|
assert!(mixer.voices[0].sample.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn short_loops_and_extreme_pitch_remain_finite_and_release_at_completion() {
|
|
for pitch in [0.125, 1.0, 4.0, 1000.0, f64::MAX] {
|
|
let (mut audio, mut mixer) = pair();
|
|
play(
|
|
&mut audio,
|
|
Arc::new(Sample::new(96_000, vec![16384; 3]).with_loop(1, 3)),
|
|
pitch,
|
|
true,
|
|
);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 128];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert!(pcm.iter().all(|v| v.is_finite()));
|
|
assert!(pcm.as_chunks::<2>().0.iter().all(|frame| *frame == [0.5, 0.0]));
|
|
assert!(mixer.voices[0].active);
|
|
assert!(mixer.voices[0].pos >= 1.0 && mixer.voices[0].pos < 3.0);
|
|
}
|
|
let (mut audio, mut mixer) = pair();
|
|
let sample = Arc::new(Sample::new(48_000, vec![16384]));
|
|
let weak = Arc::downgrade(&sample);
|
|
play(&mut audio, sample, 1.0, false);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
mixer.fill_buffer(&mut [0.0; 4]);
|
|
assert!(weak.upgrade().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn unloading_bank_keeps_playback_until_stop() {
|
|
use prometeu_drivers::SoundBankPoolInstaller;
|
|
use prometeu_hal::sound_bank::SoundBank;
|
|
let banks = Arc::new(MemoryBanks::new());
|
|
let sample = Arc::new(Sample::new(48_000, vec![16384; 4]));
|
|
let weak = Arc::downgrade(&sample);
|
|
banks.install_sound_bank(0, Arc::new(SoundBank::new(vec![sample])));
|
|
let mut audio = Audio::new(banks.clone());
|
|
let mut mixer = AudioMixer::new();
|
|
assert_eq!(audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::On), AudioOpStatus::Ok);
|
|
audio.finish_frame();
|
|
banks.clear_sound_banks();
|
|
apply(&audio, &mut mixer);
|
|
let mut pcm = [0.0; 8];
|
|
mixer.fill_buffer(&mut pcm);
|
|
assert_eq!(pcm[0], 0.5);
|
|
assert!(weak.upgrade().is_some());
|
|
assert_eq!(audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::On), AudioOpStatus::BankInvalid);
|
|
audio.stop(0);
|
|
audio.finish_frame();
|
|
apply(&audio, &mut mixer);
|
|
assert!(weak.upgrade().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn failed_or_stalled_output_releases_backpressure() {
|
|
for failed in [true, false] {
|
|
let (mut audio, _) = pair();
|
|
audio.stop(0);
|
|
audio.finish_frame();
|
|
let mut host = HostAudio::new();
|
|
host.transport = audio.transport();
|
|
host._stream = Some(Box::new(FakeSmokeStream));
|
|
host.failed.store(failed, Ordering::Relaxed);
|
|
if !failed {
|
|
host.last_progress = Instant::now() - Duration::from_secs(3);
|
|
}
|
|
host.service();
|
|
assert!(audio.ready());
|
|
assert!(host._stream.is_none());
|
|
}
|
|
}
|
|
struct FakeSmokeStream;
|
|
impl AudioStreamHandle for FakeSmokeStream {}
|
|
|
|
#[test]
|
|
#[ignore = "requires a real desktop audio device; emits a brief quiet tone"]
|
|
fn desktop_audio_device_smoke() {
|
|
let (mut audio, _) = pair();
|
|
let mut host = HostAudio::new();
|
|
host.init(audio.transport()).expect("physical output device");
|
|
let data = (0..4800)
|
|
.map(|i| ((i as f64 * std::f64::consts::TAU * 440.0 / 48_000.0).sin() * 1500.0) as i16)
|
|
.collect();
|
|
play(&mut audio, Arc::new(Sample::new(48_000, data)), 1.0, true);
|
|
audio.finish_frame();
|
|
let deadline = Instant::now() + Duration::from_secs(2);
|
|
while !audio.ready() && Instant::now() < deadline {
|
|
host.service();
|
|
std::thread::sleep(Duration::from_millis(10));
|
|
}
|
|
assert!(audio.ready());
|
|
assert!(host.heartbeat.load(Ordering::Relaxed) > 0);
|
|
audio.set_volume(0, 127);
|
|
audio.set_pan(0, 255);
|
|
audio.set_pitch(0, 1.5);
|
|
audio.finish_frame();
|
|
for _ in 0..10 {
|
|
host.service();
|
|
std::thread::sleep(Duration::from_millis(10));
|
|
}
|
|
assert!(audio.ready());
|
|
audio.stop(0);
|
|
audio.finish_frame();
|
|
for _ in 0..10 {
|
|
host.service();
|
|
std::thread::sleep(Duration::from_millis(10));
|
|
}
|
|
assert!(audio.ready());
|
|
assert!(!host.failed.load(Ordering::Relaxed));
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod reclamation_tests {
|
|
use super::*;
|
|
use prometeu_drivers::{Audio, MemoryBanks};
|
|
use prometeu_hal::{AudioBridge, sample::Sample};
|
|
|
|
#[test]
|
|
fn stale_delivery_moves_whole_vectors_to_service_without_changing_playback() {
|
|
let mut audio = Audio::new(Arc::new(MemoryBanks::new()));
|
|
let sample = Arc::new(Sample::new(48000, vec![1000; 16]));
|
|
let weak = Arc::downgrade(&sample);
|
|
audio.play_sample(sample, 0, 255, 0, 1.0, 0, LoopMode::On);
|
|
audio.finish_frame();
|
|
let stale = audio.transport().try_take().unwrap();
|
|
let allocation = stale.frame.as_ref().unwrap().as_ptr();
|
|
audio.reset();
|
|
let mut mixer = AudioMixer::new();
|
|
mixer.apply_delivery(audio.transport().try_take().unwrap());
|
|
let mut packet = Packet::new();
|
|
mixer.apply_delivery_into(stale, &mut packet);
|
|
assert_eq!(packet.batches[0].as_ref().unwrap().as_ptr(), allocation);
|
|
assert!(weak.upgrade().is_some());
|
|
mixer.mix(&mut [0.0; 32]);
|
|
assert!(mixer.voices.iter().all(|voice| !voice.active));
|
|
drop(packet); // Main/service thread, including stale command owners.
|
|
assert!(weak.upgrade().is_none());
|
|
}
|
|
|
|
type Callback = Box<dyn FnMut(&mut [f32]) + Send>;
|
|
struct ManualStream(Arc<std::sync::Mutex<Option<Callback>>>);
|
|
impl AudioStreamHandle for ManualStream {}
|
|
impl Drop for ManualStream {
|
|
fn drop(&mut self) {
|
|
self.0.lock().unwrap().take();
|
|
}
|
|
}
|
|
struct ManualRuntime(Arc<std::sync::Mutex<Option<Callback>>>);
|
|
impl AudioRuntime for ManualRuntime {
|
|
type Device = ();
|
|
type Stream = ManualStream;
|
|
fn default_output_device(&self) -> Option<()> {
|
|
Some(())
|
|
}
|
|
fn build_output_stream<D, E>(
|
|
&self,
|
|
_: &(),
|
|
_: &cpal::StreamConfig,
|
|
data: D,
|
|
_: E,
|
|
) -> Result<ManualStream, HostAudioError>
|
|
where
|
|
D: FnMut(&mut [f32]) + Send + 'static,
|
|
E: FnMut(String) + Send + 'static,
|
|
{
|
|
*self.0.lock().unwrap() = Some(Box::new(data));
|
|
Ok(ManualStream(self.0.clone()))
|
|
}
|
|
fn play_stream(&self, _: &ManualStream) -> Result<(), HostAudioError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
#[test]
|
|
fn failure_stall_and_teardown_release_callback_and_pending_owners() {
|
|
for mode in 0..3 {
|
|
let callbacks = Arc::new(std::sync::Mutex::new(None));
|
|
let mut audio = Audio::new(Arc::new(MemoryBanks::new()));
|
|
let mut host = HostAudio::new();
|
|
host.transport = audio.transport();
|
|
host.init_with_runtime(&ManualRuntime(callbacks.clone())).unwrap();
|
|
let mut owners = vec![];
|
|
for _ in 0..2 {
|
|
let sample = Arc::new(Sample::new(48000, vec![1000; 16]));
|
|
owners.push(Arc::downgrade(&sample));
|
|
audio.play_sample(sample, 0, 255, 0, 1.0, 0, LoopMode::On);
|
|
audio.finish_frame();
|
|
callbacks.lock().unwrap().as_mut().unwrap()(&mut []);
|
|
}
|
|
let sample = Arc::new(Sample::new(48000, vec![1000; 16]));
|
|
owners.push(Arc::downgrade(&sample));
|
|
audio.play_sample(sample, 0, 255, 0, 1.0, 0, LoopMode::On);
|
|
audio.finish_frame();
|
|
assert!(!audio.ready());
|
|
if mode == 0 {
|
|
host.failed.store(true, Ordering::Relaxed);
|
|
}
|
|
if mode == 1 {
|
|
host.last_progress = Instant::now() - Duration::from_secs(3);
|
|
host.last_heartbeat = host.heartbeat.load(Ordering::Relaxed);
|
|
}
|
|
if mode < 2 {
|
|
host.service();
|
|
assert!(host._stream.is_none());
|
|
}
|
|
drop(host);
|
|
assert!(audio.ready());
|
|
assert!(callbacks.lock().unwrap().is_none());
|
|
assert!(owners.iter().all(|owner| owner.upgrade().is_none()));
|
|
}
|
|
}
|
|
}
|