Add self-contained SoundBanks and MusicBanks with per-sample PCM16 and IMA ADPCM storage, materialized to resident PCM16. Integrate instrument envelopes, automation, shared DSP and host lifecycle controls while preserving staged real-time execution.
610 lines
23 KiB
Rust
610 lines
23 KiB
Rust
use prometeu_drivers::{Audio, MemoryBanks};
|
|
use prometeu_hal::{AudioBridge, LoopMode, sample::Sample};
|
|
use prometeu_host_desktop_winit::audio::AudioCallback;
|
|
use std::alloc::{GlobalAlloc, Layout, System};
|
|
use std::cell::Cell;
|
|
use std::sync::Arc;
|
|
|
|
thread_local! {
|
|
static COUNTS: Cell<Option<(usize, usize)>> = const { Cell::new(None) };
|
|
}
|
|
struct Counter;
|
|
fn count(alloc: usize, free: usize) {
|
|
let _ = COUNTS.try_with(|c| {
|
|
if let Some((a, d)) = c.get() {
|
|
c.set(Some((a + alloc, d + free)));
|
|
}
|
|
});
|
|
}
|
|
unsafe impl GlobalAlloc for Counter {
|
|
unsafe fn alloc(&self, l: Layout) -> *mut u8 {
|
|
count(1, 0);
|
|
unsafe { System.alloc(l) }
|
|
}
|
|
unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 {
|
|
count(1, 0);
|
|
unsafe { System.alloc_zeroed(l) }
|
|
}
|
|
unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
|
|
count(0, 1);
|
|
unsafe { System.dealloc(p, l) }
|
|
}
|
|
unsafe fn realloc(&self, p: *mut u8, l: Layout, n: usize) -> *mut u8 {
|
|
count(1, 1);
|
|
unsafe { System.realloc(p, l, n) }
|
|
}
|
|
}
|
|
#[global_allocator]
|
|
static ALLOCATOR: Counter = Counter;
|
|
|
|
fn measured(f: impl FnOnce()) -> (usize, usize) {
|
|
COUNTS.with(|c| c.set(Some((0, 0))));
|
|
f();
|
|
COUNTS.with(|c| c.replace(None).unwrap())
|
|
}
|
|
|
|
fn play(audio: &mut Audio, voice: usize, looping: bool) -> std::sync::Weak<Sample> {
|
|
let sample = Arc::new(Sample::new(48000, vec![1000; 4]));
|
|
let weak = Arc::downgrade(&sample);
|
|
assert_eq!(
|
|
audio.play_sample(
|
|
sample,
|
|
voice,
|
|
255,
|
|
0,
|
|
1.0,
|
|
0,
|
|
if looping { LoopMode::On } else { LoopMode::Off }
|
|
),
|
|
prometeu_hal::AudioOpStatus::Ok
|
|
);
|
|
weak
|
|
}
|
|
fn render(callback: &mut AudioCallback, audio: &Audio, pcm: &mut [f32], label: &str) {
|
|
let counts = measured(|| callback.render(&audio.transport(), pcm));
|
|
println!("{label}: {counts:?}");
|
|
assert_eq!(counts, (0, 0), "{label}");
|
|
}
|
|
|
|
#[test]
|
|
fn callback_owners_do_not_use_allocator() {
|
|
let mut audio = Audio::new(Arc::new(MemoryBanks::new()));
|
|
let (mut callback, mut reclaimer) = AudioCallback::new();
|
|
let mut pcm = [0.0; 32];
|
|
let weak = play(&mut audio, 0, false);
|
|
audio.finish_frame();
|
|
render(&mut callback, &audio, &mut pcm, "natural_completion_and_batch");
|
|
assert!(weak.upgrade().is_some(), "owner must await service");
|
|
reclaimer.service(&audio.transport());
|
|
assert!(weak.upgrade().is_none());
|
|
for _ in 0..8 {
|
|
play(&mut audio, 0, true);
|
|
audio.stop(0);
|
|
let replacement = play(&mut audio, 0, true);
|
|
audio.finish_frame();
|
|
render(&mut callback, &audio, &mut pcm, "replacement_stop_fifo");
|
|
assert!(pcm.iter().step_by(2).all(|&v| v == 1000.0 / 32768.0));
|
|
reclaimer.service(&audio.transport());
|
|
audio.set_paused(true);
|
|
render(&mut callback, &audio, &mut pcm, "pause");
|
|
assert!(pcm.iter().all(|&v| v == 0.0));
|
|
reclaimer.service(&audio.transport());
|
|
audio.reset();
|
|
render(&mut callback, &audio, &mut pcm, "epoch_reset");
|
|
assert!(replacement.upgrade().is_some());
|
|
reclaimer.service(&audio.transport());
|
|
assert!(replacement.upgrade().is_none());
|
|
}
|
|
audio.stop(0);
|
|
audio.finish_frame();
|
|
render(&mut callback, &audio, &mut pcm, "control_batch");
|
|
}
|
|
|
|
#[test]
|
|
fn stalled_service_bounds_retention_and_recovers_pending_delivery() {
|
|
let mut audio = Audio::new(Arc::new(MemoryBanks::new()));
|
|
let (mut callback, mut reclaimer) = AudioCallback::new();
|
|
let owners: Vec<_> = (0..8).map(|voice| play(&mut audio, voice, false)).collect();
|
|
audio.finish_frame();
|
|
// Keep all voices playing until both packets have been returned.
|
|
render(&mut callback, &audio, &mut [], "start_16");
|
|
render(&mut callback, &audio, &mut [], "exhaust_pool");
|
|
let mut pcm = [0.0; 32];
|
|
render(&mut callback, &audio, &mut pcm, "finish_16_without_packet");
|
|
assert!(owners.iter().all(|owner| owner.upgrade().is_some()));
|
|
let next = play(&mut audio, 0, true);
|
|
audio.finish_frame();
|
|
for _ in 0..10 {
|
|
render(&mut callback, &audio, &mut pcm, "starved_silent_pending");
|
|
assert!(!audio.ready());
|
|
assert!(pcm.iter().all(|&v| v == 0.0));
|
|
}
|
|
reclaimer.service(&audio.transport());
|
|
render(&mut callback, &audio, &mut pcm, "recover");
|
|
assert!(audio.ready());
|
|
reclaimer.service(&audio.transport());
|
|
assert!(owners.iter().all(|owner| owner.upgrade().is_none()));
|
|
assert!(next.upgrade().is_some());
|
|
drop(callback); // Teardown belongs to the service/main thread.
|
|
drop(reclaimer);
|
|
assert!(next.upgrade().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn full_frame_and_combined_lifecycle_fit_one_packet() {
|
|
let mut audio = Audio::new(Arc::new(MemoryBanks::new()));
|
|
let (mut callback, mut reclaimer) = AudioCallback::new();
|
|
let mut owners = Vec::new();
|
|
for voice in 0..8 {
|
|
owners.push(play(&mut audio, voice, false));
|
|
}
|
|
audio.finish_frame();
|
|
render(&mut callback, &audio, &mut [], "initial_16");
|
|
reclaimer.service(&audio.transport());
|
|
// The published frame, interrupted next-frame prefix and lifecycle each
|
|
// admit 1024 commands. Every command replaces an owner on the same voice.
|
|
for _ in 0..1024 {
|
|
owners.push(play(&mut audio, 0, false));
|
|
}
|
|
audio.finish_frame();
|
|
for _ in 0..1024 {
|
|
owners.push(play(&mut audio, 0, false));
|
|
}
|
|
audio.begin_lifecycle();
|
|
for _ in 0..1024 {
|
|
owners.push(play(&mut audio, 0, false));
|
|
}
|
|
audio.finish_lifecycle(true);
|
|
let mut pcm = [0.0; 32];
|
|
render(&mut callback, &audio, &mut pcm, "3072_commands_plus_completion");
|
|
reclaimer.service(&audio.transport());
|
|
assert!(owners.iter().skip(8).all(|owner| owner.upgrade().is_none()));
|
|
audio.reset();
|
|
render(&mut callback, &audio, &mut pcm, "reset_remaining_voices");
|
|
reclaimer.service(&audio.transport());
|
|
assert!(owners.iter().all(|owner| owner.upgrade().is_none()));
|
|
}
|
|
|
|
/// Physical observations, deliberately excluded from ordinary CI. The pressure
|
|
/// fixture reads the checked-in asset pack and writes a temporary host save;
|
|
/// it does not certify asset decoding or guest memcard scheduling.
|
|
#[test]
|
|
#[ignore = "requires physical audio output; 8 quiet voices and temporary file I/O"]
|
|
fn physical_callback_duration_8_sfx_voices_with_io_pressure() {
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
use prometeu_host_desktop_winit::fs_backend::HostDirBackend;
|
|
use prometeu_system::fs::FsBackend;
|
|
use ringbuf::{
|
|
HeapRb,
|
|
traits::{Consumer, Producer, Split},
|
|
};
|
|
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
|
|
use std::time::{Duration, Instant};
|
|
let device = cpal::default_host().default_output_device().expect("physical output");
|
|
let device_name = device.name().unwrap();
|
|
let mut audio = Audio::new(Arc::new(MemoryBanks::new()));
|
|
let (mut callback, mut reclaimer) = AudioCallback::new();
|
|
let mut owners = vec![];
|
|
for voice in 0..8 {
|
|
let sample = Arc::new(Sample::new(48000, vec![32; 4800]));
|
|
owners.push(Arc::downgrade(&sample));
|
|
audio.play_sample(sample, voice, 8, 127, 1.0, 0, LoopMode::On);
|
|
}
|
|
audio.finish_frame();
|
|
let config = cpal::StreamConfig {
|
|
channels: 2,
|
|
sample_rate: cpal::SampleRate(48000),
|
|
buffer_size: cpal::BufferSize::Fixed(256),
|
|
};
|
|
let transport = audio.transport();
|
|
let (mut timings, mut observations) = HeapRb::<(u64, usize)>::new(4096).split();
|
|
let allocator_calls = Arc::new(AtomicUsize::new(0));
|
|
let failed = Arc::new(AtomicBool::new(false));
|
|
let counter = allocator_calls.clone();
|
|
let error = failed.clone();
|
|
let stream = device
|
|
.build_output_stream(
|
|
&config,
|
|
move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
|
|
let start = Instant::now();
|
|
let (alloc, free) = measured(|| callback.render(&transport, data));
|
|
counter.fetch_add(alloc + free, Ordering::Relaxed);
|
|
let _ = timings.try_push((start.elapsed().as_nanos() as u64, data.len() / 2));
|
|
},
|
|
move |_| {
|
|
error.store(true, Ordering::Relaxed);
|
|
},
|
|
None,
|
|
)
|
|
.unwrap();
|
|
let root =
|
|
std::env::temp_dir().join(format!("prometeu-audio-qualification-{}", std::process::id()));
|
|
std::fs::create_dir_all(&root).unwrap();
|
|
let mut filesystem = HostDirBackend::new(root.clone());
|
|
let asset = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../../../test-cartridges/stress-console/assets.pa");
|
|
let save = vec![0x5a; 1024 * 1024];
|
|
stream.play().unwrap();
|
|
let deadline = Instant::now() + Duration::from_secs(2);
|
|
let mut io_cycles = 0;
|
|
while Instant::now() < deadline {
|
|
let payload = std::fs::read(&asset).unwrap();
|
|
assert!(!payload.is_empty());
|
|
filesystem.write_file("/user/audio-pressure.bin", &save).unwrap();
|
|
reclaimer.service(&audio.transport());
|
|
io_cycles += 1;
|
|
std::thread::sleep(Duration::from_millis(2));
|
|
}
|
|
stream.pause().unwrap();
|
|
let live_before = owners.iter().filter(|owner| owner.upgrade().is_some()).count();
|
|
drop(stream);
|
|
reclaimer.service(&audio.transport());
|
|
let live_after = owners.iter().filter(|owner| owner.upgrade().is_some()).count();
|
|
let mut samples = vec![];
|
|
let mut frames = vec![];
|
|
while let Some((time, count)) = observations.try_pop() {
|
|
samples.push(time);
|
|
frames.push(count);
|
|
}
|
|
filesystem.delete("/user/audio-pressure.bin").unwrap();
|
|
std::fs::remove_dir(root.join("user")).unwrap();
|
|
std::fs::remove_dir(root).unwrap();
|
|
samples.sort_unstable();
|
|
assert!(!samples.is_empty(), "physical stream delivered no callbacks");
|
|
println!(
|
|
"device={device_name:?}, callbacks={}, io_cycles={io_cycles}, frames_min={}, frames_max={}, p50_ns={}, p95_ns={}, p99_ns={}, max_ns={}, allocator_calls={}, owners_before={live_before}, owners_after={live_after}",
|
|
samples.len(),
|
|
frames.iter().min().unwrap(),
|
|
frames.iter().max().unwrap(),
|
|
samples[samples.len() / 2],
|
|
samples[samples.len() * 95 / 100],
|
|
samples[samples.len() * 99 / 100],
|
|
samples.last().unwrap(),
|
|
allocator_calls.load(Ordering::Relaxed)
|
|
);
|
|
assert!(!failed.load(Ordering::Relaxed));
|
|
assert_eq!(allocator_calls.load(Ordering::Relaxed), 0);
|
|
assert_eq!((live_before, live_after), (8, 0));
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "release timing observation with temporary asset-read/save-write pressure"]
|
|
fn callback_duration_8_sfx_voices_with_io_pressure() {
|
|
use prometeu_host_desktop_winit::fs_backend::HostDirBackend;
|
|
use prometeu_system::fs::FsBackend;
|
|
use std::time::Instant;
|
|
let mut audio = Audio::new(Arc::new(MemoryBanks::new()));
|
|
let (mut callback, mut reclaimer) = AudioCallback::new();
|
|
let owners: Vec<_> = (0..8).map(|voice| play(&mut audio, voice, true)).collect();
|
|
audio.finish_frame();
|
|
let mut pcm = [0.0; 512]; // 256 stereo frames: nominal 5.333 ms at 48 kHz.
|
|
callback.render(&audio.transport(), &mut pcm);
|
|
reclaimer.service(&audio.transport());
|
|
let root = std::env::temp_dir().join(format!("prometeu-audio-timing-{}", std::process::id()));
|
|
std::fs::create_dir_all(&root).unwrap();
|
|
let mut filesystem = HostDirBackend::new(root.clone());
|
|
let asset = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../../../test-cartridges/stress-console/assets.pa");
|
|
let save = vec![0x5a; 1024 * 1024];
|
|
let mut samples = Vec::with_capacity(1000);
|
|
let mut counts = (0, 0);
|
|
for _ in 0..1000 {
|
|
assert!(!std::fs::read(&asset).unwrap().is_empty());
|
|
filesystem.write_file("/user/audio-pressure.bin", &save).unwrap();
|
|
let start = Instant::now();
|
|
let measured = measured(|| callback.render(&audio.transport(), &mut pcm));
|
|
samples.push(start.elapsed().as_nanos());
|
|
counts.0 += measured.0;
|
|
counts.1 += measured.1;
|
|
reclaimer.service(&audio.transport());
|
|
}
|
|
samples.sort_unstable();
|
|
let before = owners.iter().filter(|owner| owner.upgrade().is_some()).count();
|
|
drop(callback);
|
|
drop(reclaimer);
|
|
let after = owners.iter().filter(|owner| owner.upgrade().is_some()).count();
|
|
filesystem.delete("/user/audio-pressure.bin").unwrap();
|
|
std::fs::remove_dir(root.join("user")).unwrap();
|
|
std::fs::remove_dir(root).unwrap();
|
|
println!(
|
|
"synthetic callbacks=1000, frames=256, nominal_period_ns=5333333, io_cycles=1000, p50_ns={}, p95_ns={}, p99_ns={}, max_ns={}, alloc_free={counts:?}, owners_before={before}, owners_after={after}",
|
|
samples[500], samples[950], samples[990], samples[999]
|
|
);
|
|
assert_eq!(counts, (0, 0));
|
|
assert_eq!((before, after), (8, 0));
|
|
}
|
|
|
|
#[test]
|
|
fn unloaded_banks_empty_samples_and_controls_reclaim_on_service() {
|
|
use prometeu_drivers::SoundBankPoolInstaller;
|
|
use prometeu_hal::sound_bank::SoundBank;
|
|
let banks = Arc::new(MemoryBanks::new());
|
|
let sample = Arc::new(Sample::new(48000, vec![1000; 16]));
|
|
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 callback, mut reclaimer) = AudioCallback::new();
|
|
audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::On);
|
|
audio.finish_frame();
|
|
banks.clear_sound_banks();
|
|
let mut pcm = [0.0; 16];
|
|
render(&mut callback, &audio, &mut pcm, "unloaded_bank");
|
|
assert!(weak.upgrade().is_some());
|
|
reclaimer.service(&audio.transport());
|
|
audio.set_volume(0, 127);
|
|
audio.set_pan(0, 255);
|
|
audio.set_pitch(0, 0.5);
|
|
audio.stop(0);
|
|
let empty = Arc::new(Sample::new(48000, vec![]));
|
|
let weak_empty = Arc::downgrade(&empty);
|
|
audio.play_sample(empty, 1, 255, 0, 1.0, 0, LoopMode::Off);
|
|
audio.finish_frame();
|
|
render(&mut callback, &audio, &mut pcm, "controls_stop_empty");
|
|
assert!(pcm.iter().all(|&sample| sample == 0.0));
|
|
assert!(weak.upgrade().is_none() && weak_empty.upgrade().is_some());
|
|
reclaimer.service(&audio.transport());
|
|
assert!(weak.upgrade().is_none() && weak_empty.upgrade().is_none());
|
|
}
|
|
|
|
fn music_fixture() -> Arc<prometeu_hal::music_bank::MusicBank> {
|
|
use prometeu_hal::music_bank::{Instrument, MusicBank, MusicEvent};
|
|
let sample =
|
|
Arc::new(Sample::new(48000, vec![1000, -1500]).with_channels(2).unwrap().with_loop(0, 1));
|
|
let mut events: Vec<_> = (0..12)
|
|
.map(|id| MusicEvent { kind: 1, a: id, c: 60, d: 255, ..Default::default() })
|
|
.collect();
|
|
// Every frame replaces a voice while envelopes and modulation keep running.
|
|
for tick in 1..500 {
|
|
events.push(MusicEvent {
|
|
tick,
|
|
kind: 1,
|
|
a: 12 + tick,
|
|
c: 60 + (tick % 12) as i32,
|
|
d: 180,
|
|
..Default::default()
|
|
});
|
|
}
|
|
Arc::new(
|
|
MusicBank::compile(
|
|
"rt".into(),
|
|
vec![sample],
|
|
vec![Instrument {
|
|
looping: true,
|
|
attack_us: 100,
|
|
release_us: 1000,
|
|
vibrato_millihz: 6000,
|
|
vibrato_cents: 20,
|
|
tremolo_millihz: 4000,
|
|
tremolo_depth: 1000,
|
|
send: 32768,
|
|
..Default::default()
|
|
}],
|
|
events,
|
|
960,
|
|
20_000,
|
|
1000,
|
|
None,
|
|
1,
|
|
)
|
|
.unwrap(),
|
|
)
|
|
}
|
|
#[test]
|
|
fn thirty_two_stereo_voices_sequences_dsp_and_bank_retirement_never_call_allocator() {
|
|
use prometeu_drivers::SoundBankPoolInstaller;
|
|
use prometeu_hal::audio_bridge::AudioControl;
|
|
let banks = Arc::new(MemoryBanks::new());
|
|
let mut audio = Audio::new(banks.clone());
|
|
banks.install_music_bank(0, music_fixture());
|
|
audio.music_play(0, 0, true);
|
|
audio.music_play(1, 0, true);
|
|
for voice in 0..8 {
|
|
let sample =
|
|
Arc::new(Sample::new(48000, vec![500, -500]).with_channels(2).unwrap().with_loop(0, 1));
|
|
audio.play_sample(sample, voice, 255, 128, 1.0, 0, LoopMode::On);
|
|
}
|
|
for group in 0..3 {
|
|
audio.control(AudioControl::Effect {
|
|
group,
|
|
cutoff_hz: 6000,
|
|
delay_frames: 48,
|
|
feedback: 0.5,
|
|
wet: 0.3,
|
|
dry: 0.7,
|
|
});
|
|
}
|
|
audio.finish_frame();
|
|
let (mut callback, mut reclaimer) = AudioCallback::new();
|
|
let mut pcm = [0.0; 512];
|
|
render(&mut callback, &audio, &mut pcm, "32_stereo_sequencers_adsr_modulation_dsp");
|
|
assert_eq!(callback.diagnostics().maximum_voices, 32);
|
|
reclaimer.service(&audio.transport());
|
|
for _ in 0..20 {
|
|
banks.install_music_bank(0, music_fixture());
|
|
audio.music_play(0, 0, true);
|
|
audio.music_play(1, 0, true);
|
|
audio.control(AudioControl::Crossfade { source: 0, target: 1, frames: 48, smooth: true });
|
|
audio.finish_frame();
|
|
render(&mut callback, &audio, &mut pcm, "32_bank_replacement_and_crossfade");
|
|
reclaimer.service(&audio.transport());
|
|
}
|
|
// Exhaust both packets, then invalidate banks and keep processing safely.
|
|
render(&mut callback, &audio, &mut pcm, "pool_first");
|
|
render(&mut callback, &audio, &mut pcm, "pool_second");
|
|
banks.unload_audio_bank(true, 0);
|
|
for _ in 0..10 {
|
|
render(&mut callback, &audio, &mut pcm, "music_invalidated_without_packet");
|
|
}
|
|
reclaimer.service(&audio.transport());
|
|
render(&mut callback, &audio, &mut pcm, "retire_after_starvation");
|
|
reclaimer.service(&audio.transport());
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "physical 48 kHz output; emits a quiet tone for two seconds"]
|
|
fn physical_32_stereo_voices_with_dsp_and_bank_replacement() {
|
|
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
|
use prometeu_drivers::SoundBankPoolInstaller;
|
|
use prometeu_hal::{
|
|
audio_bridge::AudioControl,
|
|
music_bank::{Instrument, MusicBank, MusicEvent},
|
|
};
|
|
use ringbuf::{
|
|
HeapRb,
|
|
traits::{Consumer, Producer, Split},
|
|
};
|
|
use std::{
|
|
sync::atomic::{AtomicUsize, Ordering},
|
|
time::{Duration, Instant},
|
|
};
|
|
let device = cpal::default_host().default_output_device().expect("physical output device");
|
|
let name = device.name().unwrap();
|
|
let sample = Arc::new(
|
|
Sample::new(
|
|
48000,
|
|
(0..256)
|
|
.flat_map(|i| {
|
|
let v = ((i as f64 * std::f64::consts::TAU / 256.0).sin() * 512.0) as i16;
|
|
[v, v]
|
|
})
|
|
.collect(),
|
|
)
|
|
.with_channels(2)
|
|
.unwrap()
|
|
.with_loop(0, 256),
|
|
);
|
|
let make_bank = || {
|
|
Arc::new(
|
|
MusicBank::compile(
|
|
"physical".into(),
|
|
vec![sample.clone()],
|
|
vec![Instrument { looping: true, send: 32768, ..Default::default() }],
|
|
(0..12)
|
|
.map(|n| MusicEvent {
|
|
kind: 1,
|
|
a: n,
|
|
c: 60 + n as i32,
|
|
d: 255,
|
|
..Default::default()
|
|
})
|
|
.collect(),
|
|
960,
|
|
500000,
|
|
3840,
|
|
None,
|
|
1,
|
|
)
|
|
.unwrap(),
|
|
)
|
|
};
|
|
let banks = Arc::new(MemoryBanks::new());
|
|
banks.install_music_bank(0, make_bank());
|
|
banks.install_music_bank(1, make_bank());
|
|
let mut audio = Audio::new(banks.clone());
|
|
audio.music_play(0, 0, true);
|
|
audio.music_play(1, 1, true);
|
|
for group in 0..2 {
|
|
audio.control(AudioControl::MusicVolume { group, gain: 8 });
|
|
}
|
|
for voice in 0..8 {
|
|
audio.play_sample(sample.clone(), voice, 8, 128, 1.0, 0, LoopMode::On);
|
|
audio.control(AudioControl::SfxSend { voice, gain: 100 });
|
|
}
|
|
for group in 0..3 {
|
|
audio.control(AudioControl::Effect {
|
|
group,
|
|
cutoff_hz: 6000,
|
|
delay_frames: 4800,
|
|
feedback: 0.5,
|
|
wet: 0.3,
|
|
dry: 0.7,
|
|
});
|
|
}
|
|
audio.finish_frame();
|
|
let (mut callback, mut reclaimer) = AudioCallback::new();
|
|
let transport = audio.transport();
|
|
let (mut writer, mut reader) = HeapRb::<(u64, usize, usize)>::new(4096).split();
|
|
let failures = Arc::new(AtomicUsize::new(0));
|
|
let allocator = Arc::new(AtomicUsize::new(0));
|
|
let failure = failures.clone();
|
|
let allocations = allocator.clone();
|
|
let config = cpal::StreamConfig {
|
|
channels: 2,
|
|
sample_rate: cpal::SampleRate(48000),
|
|
buffer_size: cpal::BufferSize::Fixed(256),
|
|
};
|
|
let stream = device
|
|
.build_output_stream(
|
|
&config,
|
|
move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
|
|
let start = Instant::now();
|
|
let (a, d) = measured(|| callback.render(&transport, data));
|
|
allocations.fetch_add(a + d, Ordering::Relaxed);
|
|
let _ = writer.try_push((
|
|
start.elapsed().as_nanos() as u64,
|
|
data.len() / 2,
|
|
callback.diagnostics().maximum_voices,
|
|
));
|
|
},
|
|
move |_| {
|
|
failure.fetch_add(1, Ordering::Relaxed);
|
|
},
|
|
None,
|
|
)
|
|
.unwrap();
|
|
let temporary =
|
|
std::env::temp_dir().join(format!("prometeu-audio-32-pressure-{}", std::process::id()));
|
|
let pressure = vec![0x5a; 512 * 1024];
|
|
let fixture = include_bytes!(concat!(
|
|
env!("CARGO_MANIFEST_DIR"),
|
|
"/../../../test-fixtures/audio/mixed-music.mbnk"
|
|
));
|
|
stream.play().unwrap();
|
|
let end = Instant::now() + Duration::from_secs(2);
|
|
let mut replacements = 0;
|
|
while Instant::now() < end {
|
|
std::fs::write(&temporary, &pressure).unwrap();
|
|
let decoded = prometeu_drivers::bank_format::decode_audio_bank(fixture, true).unwrap();
|
|
std::hint::black_box(decoded);
|
|
reclaimer.service(&audio.transport());
|
|
if audio.ready() {
|
|
banks.install_music_bank(0, make_bank());
|
|
audio.music_play(0, 0, true);
|
|
audio.control(AudioControl::MusicVolume { group: 0, gain: 8 });
|
|
audio.finish_frame();
|
|
replacements += 1;
|
|
}
|
|
std::thread::sleep(Duration::from_millis(2));
|
|
}
|
|
stream.pause().unwrap();
|
|
drop(stream);
|
|
reclaimer.service(&audio.transport());
|
|
std::fs::remove_file(temporary).unwrap();
|
|
let mut timings = Vec::new();
|
|
let mut overruns = 0;
|
|
let mut maximum_voices = 0;
|
|
while let Some((n, frames, voices)) = reader.try_pop() {
|
|
maximum_voices = maximum_voices.max(voices);
|
|
timings.push(n);
|
|
if n as u128 > frames as u128 * 1_000_000_000 / 48000 {
|
|
overruns += 1;
|
|
}
|
|
}
|
|
timings.sort_unstable();
|
|
assert!(!timings.is_empty());
|
|
let n = timings.len();
|
|
println!(
|
|
"physical_32_stereo device={name:?} maximum_voices={maximum_voices} callbacks={n} replacements={replacements} p50_ns={} p95_ns={} p99_ns={} max_ns={} budget_overruns={overruns} device_errors={} allocator_calls={} maximum_retired_pcm_bytes={}",
|
|
timings[n / 2],
|
|
timings[n * 95 / 100],
|
|
timings[n * 99 / 100],
|
|
timings[n - 1],
|
|
failures.load(Ordering::Relaxed),
|
|
allocator.load(Ordering::Relaxed),
|
|
reclaimer.maximum_retired_pcm_bytes
|
|
);
|
|
assert_eq!(maximum_voices, 32);
|
|
assert_eq!(failures.load(Ordering::Relaxed), 0);
|
|
assert_eq!(allocator.load(Ordering::Relaxed), 0);
|
|
}
|