Files
prometeu-runtime/crates/tools/pbxgen-stress/tests/music_cartridge.rs
T
bquarkz c2bf8d055c feat(stress): add a deterministic particle demo with sequenced music
Move Storm Eagle playback and source assets to Stress Console and keep Dummy Boy silent. Exercise VM math, seeded Random and persistent typed particles with a projected tunnel, bounded 512-sprite heavy workload, reproducible replays and measured costs.
2026-11-20 22:15:47 +00:00

201 lines
8.6 KiB
Rust

use prometeu_drivers::bank_format::{decode_audio_bank, DecodedAudioBank};
use prometeu_host_headless::{AdvanceFrameOutcome, HeadlessHost};
use std::path::PathBuf;
struct Cartridge(PathBuf);
impl Cartridge {
fn new() -> Self {
let unique =
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
let path = std::env::temp_dir()
.join(format!("stress-console-music-{}-{unique}", std::process::id()));
std::fs::create_dir_all(&path).unwrap();
std::fs::write(path.join("program.pbx"), pbxgen_stress::build_program()).unwrap();
std::fs::write(path.join("manifest.json"), pbxgen_stress::manifest_json()).unwrap();
std::fs::write(path.join("assets.pa"), pbxgen_stress::build_assets_pack().unwrap())
.unwrap();
Self(path)
}
fn boot(&self) -> HeadlessHost {
let mut host = HeadlessHost::new();
host.boot(self.0.to_string_lossy()).unwrap();
assert!(matches!(
host.advance_frame().unwrap(),
AdvanceFrameOutcome::FrameCompleted { .. }
));
host.resume().unwrap();
host
}
}
impl Drop for Cartridge {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
#[test]
fn bank_preserves_transcription_and_mixed_samples() {
let bytes = include_bytes!("../music/storm-eagle.mbnk");
let decoded =
decode_audio_bank(bytes, true).expect("packer bank must load in the real decoder");
let metrics: serde_json::Value =
serde_json::from_str(include_str!("../music/bank-metrics.json")).unwrap();
assert_eq!(decoded.decoded_size() as u64, metrics["decoded_size"].as_u64().unwrap());
let DecodedAudioBank::Music(bank) = decoded else { panic!("expected music") };
assert_eq!(bank.samples.len(), 8);
assert_eq!(bank.instruments.len(), 8);
let manifest: serde_json::Value =
serde_json::from_str(include_str!("../music/song.json")).unwrap();
let lead: Vec<_> = manifest["events"]
.as_array()
.unwrap()
.iter()
.filter(|e| e["kind"] == 1 && e["track"] == 0)
.collect();
assert_eq!(lead.len(), 90);
let first_pitches: Vec<_> = lead.iter().take(8).map(|e| e["c"].as_u64().unwrap()).collect();
assert_eq!(first_pitches, [71, 70, 71, 73, 74, 73, 71, 78]);
assert_eq!(lead[4]["tick"], 3840);
assert_eq!(lead[5]["tick"], 4160);
assert_eq!(lead[6]["tick"], 4480);
assert_eq!(manifest["duration_ticks"], 69120);
let mapping: serde_json::Value =
serde_json::from_str(include_str!("../music/instrument-mapping.json")).unwrap();
assert_eq!(mapping["voicings"].as_array().unwrap().len(), 20);
assert_eq!(mapping["voicings"][4]["target_tones"], serde_json::json!([58, 61, 66]));
let samples_at = 48 + u32::from_le_bytes(bytes[40..44].try_into().unwrap()) as usize;
let codecs: Vec<_> = (0..8).map(|i| bytes[samples_at + i * 40]).collect();
assert!(codecs.contains(&0) && codecs.contains(&1));
}
#[test]
fn tracked_cartridge_is_the_exact_generator_output() {
let root =
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../test-cartridges/stress-console");
assert_eq!(std::fs::read(root.join("program.pbx")).unwrap(), pbxgen_stress::build_program());
assert_eq!(std::fs::read(root.join("manifest.json")).unwrap(), pbxgen_stress::manifest_json());
assert_eq!(
std::fs::read(root.join("assets.pa")).unwrap(),
pbxgen_stress::build_assets_pack().unwrap()
);
}
#[test]
fn guest_preloads_music_and_renders_audio() {
let cartridge = Cartridge::new();
let mut host = cartridge.boot();
let mut output = [0.0; 9600];
host.render_audio(&mut output);
assert!(output.iter().any(|x| x.abs() > 0.001));
assert!(host.audio_diagnostics().maximum_voices > 0);
assert_eq!(host.audio_diagnostics().frames, 4800);
}
fn render_sequence(
mut host: HeadlessHost,
frames: usize,
graphics_and_pause: bool,
) -> (Vec<f32>, prometeu_drivers::engine::AudioDiagnostics, usize) {
let mut output = vec![0.0; frames * 2];
let mut graphics_frames = 0;
for (index, buffer) in output.chunks_mut(1600).enumerate() {
if graphics_and_pause {
// Exercise the heavy workload at bounded checkpoints across both loops.
// This is a sequencing regression test, not a 60 FPS performance run.
if index < 6 || index % 120 == 0 || [60, 1543, 3086].contains(&index) {
assert!(matches!(
host.advance_frame().unwrap(),
AdvanceFrameOutcome::FrameCompleted { .. }
));
graphics_frames += 1;
host.resume().unwrap();
}
if index == 60 {
let before = host.audio_diagnostics().frames;
host.pause().unwrap();
let mut silence = [1.0; 2048];
host.render_audio(&mut silence);
assert_eq!(silence, [0.0; 2048]);
assert_eq!(host.audio_diagnostics().frames, before);
host.resume().unwrap();
}
}
host.render_audio(buffer);
}
let diagnostics = host.audio_diagnostics();
assert_eq!(diagnostics.frames, frames as u64);
(output, diagnostics, graphics_frames)
}
fn write_wav(path: &std::path::Path, pcm: &[f32]) {
use std::io::Write;
let mut file = std::fs::File::create(path).unwrap();
let byte_count = u32::try_from(pcm.len() * 2).unwrap();
file.write_all(b"RIFF").unwrap();
file.write_all(&(36 + byte_count).to_le_bytes()).unwrap();
file.write_all(b"WAVEfmt \x10\0\0\0\x01\0\x02\0").unwrap();
file.write_all(&48_000_u32.to_le_bytes()).unwrap();
file.write_all(&192_000_u32.to_le_bytes()).unwrap();
file.write_all(&4_u16.to_le_bytes()).unwrap();
file.write_all(&16_u16.to_le_bytes()).unwrap();
file.write_all(b"data").unwrap();
file.write_all(&byte_count.to_le_bytes()).unwrap();
let mut bytes = Vec::with_capacity(pcm.len() * 2);
for value in pcm {
bytes.extend_from_slice(&((value.clamp(-1.0, 1.0) * 32767.0).round() as i16).to_le_bytes());
}
file.write_all(&bytes).unwrap();
}
#[test]
fn full_sequence_loops_and_frame_controls_preserve_audio() {
let cartridge = Cartridge::new();
let one_loop_numerator = 48_000_u64 * 72 * 357_143;
let first_loop = one_loop_numerator.div_ceil(1_000_000) as usize;
let frames = (one_loop_numerator * 2).div_ceil(1_000_000) as usize + 48_000;
let (reference, diagnostics, _) = render_sequence(cartridge.boot(), frames, false);
let (with_frames, _, graphics_frames) = render_sequence(cartridge.boot(), frames, true);
assert!(graphics_frames >= 30);
assert_eq!(
reference, with_frames,
"graphics and explicit pause/resume must not change a single PCM sample"
);
assert!((6..=12).contains(&diagnostics.maximum_voices));
let peak = reference.iter().map(|x| x.abs()).fold(0.0_f32, f32::max);
let energy: f64 = reference.iter().map(|x| f64::from(*x).powi(2)).sum();
let rms = (energy / reference.len() as f64).sqrt();
let clipped = reference.iter().filter(|x| x.abs() >= 1.0).count();
let stereo_difference: f64 =
reference.as_chunks::<2>().0.iter().map(|lr| f64::from(lr[0] - lr[1]).powi(2)).sum();
// Loop onset should reproduce the opening. A subframe remainder and the shared
// echo tail may differ, so compare relative signal energy rather than bit identity.
let mut loop_error = 0.0;
let mut opening_energy = 0.0;
for i in 400..4000 {
loop_error += f64::from(reference[i] - reference[first_loop * 2 + i]).powi(2);
opening_energy += f64::from(reference[i]).powi(2);
}
let loop_error_ratio = loop_error / opening_energy;
let report = serde_json::json!({
"sample_rate": 48000, "channels": 2, "audio_frames": frames,
"seconds": frames as f64 / 48000.0, "first_loop_frame": first_loop,
"maximum_voices": diagnostics.maximum_voices, "peak": peak,
"rms": rms, "clipped_samples": clipped,
"loop_onset_relative_error": loop_error_ratio,
"graphics_pause_pcm_identical": true,
"interleaved_graphics_frames": graphics_frames,
});
println!("stress_music={report}");
if let Some(path) = std::env::var_os("PROMETEU_STRESS_WAV") {
write_wav(std::path::Path::new(&path), &reference);
}
assert!(reference.iter().all(|x| x.is_finite()));
assert!(rms > 0.005 && stereo_difference > 0.01);
assert_eq!(clipped, 0, "adjust arrangement gain rather than delivering clipped audio");
assert!(
loop_error_ratio < 0.04,
"loop did not reproduce the musical opening: {loop_error_ratio}"
);
}