Files
prometeu-runtime/crates/console/prometeu-drivers/src/audio/bank_tests.rs
T
bquarkz 8510c5b00d feat(audio): add 32-voice PCM mixing and native music sequencing
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.
2026-11-20 22:15:24 +00:00

183 lines
6.8 KiB
Rust

use super::*;
use crate::{AssetManager, MemoryBanks, SoundBankPoolAccess};
use prometeu_hal::{
asset::{AssetCodec, AssetEntry, AssetOpStatus, BankType, LoadStatus, SlotRef},
cartridge::AssetsPayloadSource,
};
use std::time::{Duration, Instant};
fn fixtures() -> Vec<(&'static [u8], bool)> {
vec![
(
include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/pcm-only.sbnk"
)),
false,
),
(
include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/ima-only.sbnk"
)),
false,
),
(
include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/mixed-sound.sbnk"
)),
false,
),
(
include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/mixed-music.mbnk"
)),
true,
),
]
}
#[test]
fn packer_binary_fixtures_materialize_mixed_stereo_banks_and_separate_encoded_from_pcm_sizes() {
for (index, (bytes, music)) in fixtures().into_iter().enumerate() {
let decoded = decode_audio_bank(bytes, music).unwrap();
let (samples, metrics) = match &decoded {
DecodedAudioBank::Sound(b) => (&b.samples, b.metrics),
DecodedAudioBank::Music(b) => {
assert_eq!(b.events.len(), 4);
assert_eq!(b.instruments.len(), 2);
assert_eq!(b.tracks, 2);
(&b.samples, b.metrics)
}
};
assert_eq!(metrics.cartridge_bytes, bytes.len());
assert_eq!(metrics.pcm_bytes, if index < 2 { 2000 } else { 6000 });
assert_eq!(samples[0].frames_len(), 1000);
assert_eq!(samples[0].loop_end, Some(1000));
if index >= 2 {
assert_eq!(samples[1].channels, 2);
assert_eq!(samples[1].frames_len(), 1000);
}
if index != 0 {
assert!(decoded.decoded_size() > bytes.len());
}
}
}
#[test]
fn complete_validation_rejects_truncation_unknown_codec_bad_loops_and_reserved_bytes() {
for (bytes, music) in fixtures() {
for cut in [0, 4, 47, 48, bytes.len() - 1] {
assert!(decode_audio_bank(&bytes[..cut], music).is_err());
}
let name = u32le(bytes, 40).unwrap() as usize;
let sample = 48 + name;
for (at, value) in
[(4, 2), (44, 1), (sample, 99), (sample + 1, 3), (sample + 2, 2), (sample + 34, 1)]
{
let mut bad = bytes.to_vec();
bad[at] = value;
assert!(decode_audio_bank(&bad, music).is_err(), "{at}");
}
let mut bad = bytes.to_vec();
bad[sample + 12..sample + 16].copy_from_slice(&1001u32.to_le_bytes());
assert!(decode_audio_bank(&bad, music).is_err());
let mut bad = bytes.to_vec();
bad.push(0);
assert!(decode_audio_bank(&bad, music).is_err());
// Mutating every byte must produce either a validated bank or a clean error.
for i in 0..bytes.len() {
let mut changed = bytes.to_vec();
changed[i] ^= 0xff;
let _ = decode_audio_bank(&changed, music);
}
}
}
fn entry(id: i32, offset: usize, bytes: &[u8], music: bool) -> AssetEntry {
AssetEntry {
asset_id: id,
asset_name: format!("bank{id}"),
bank_type: if music { BankType::MUSIC } else { BankType::SOUNDS },
offset: offset as u64,
size: bytes.len() as u64,
decoded_size: decode_audio_bank(bytes, music).unwrap().decoded_size() as u64,
codec: AssetCodec::None,
metadata: serde_json::json!({"version":1}),
}
}
fn ready(manager: &AssetManager, handle: u32) {
let end = Instant::now() + Duration::from_secs(3);
while matches!(
manager.status(handle),
LoadStatus::QUEUED | LoadStatus::LOADING | LoadStatus::PENDING | LoadStatus::ACTIVE
) {
assert!(Instant::now() < end);
std::thread::yield_now();
}
assert_eq!(manager.status(handle), LoadStatus::READY);
}
#[test]
fn audio_loading_commit_replacement_and_unload_are_atomic_and_type_isolated() {
let fixtures = fixtures();
let sound = fixtures[2].0;
let music = fixtures[3].0;
let mut payload = sound.to_vec();
payload.extend_from_slice(music);
let bad_at = payload.len();
let mut corrupt = sound.to_vec();
corrupt[0] = 0;
payload.extend(&corrupt);
let mut bad = entry(3, bad_at, sound, false);
bad.decoded_size += 1;
let banks = Arc::new(MemoryBanks::new());
let manager = AssetManager::new(
vec![entry(1, 0, sound, false), entry(2, sound.len(), music, true), bad],
AssetsPayloadSource::from_bytes(payload),
banks.clone(),
banks.clone(),
banks.clone(),
);
let s = manager.load(1, 0).unwrap();
ready(&manager, s);
assert!(banks.sound_bank_slot(0).is_none());
assert_eq!(manager.commit(s), AssetOpStatus::Ok);
manager.apply_commits();
let old = banks.sound_bank_slot(0).unwrap();
let m = manager.load(2, 0).unwrap();
ready(&manager, m);
manager.commit(m);
manager.apply_commits();
assert!(old.alive.load(std::sync::atomic::Ordering::Acquire));
assert!(banks.music_bank_slot(0).is_some());
let failing = manager.load(3, 0).unwrap();
let end = Instant::now() + Duration::from_secs(3);
while manager.status(failing) != LoadStatus::ERROR {
assert!(Instant::now() < end);
std::thread::yield_now();
}
manager.apply_commits();
assert!(Arc::ptr_eq(&old, &banks.sound_bank_slot(0).unwrap()));
let replacement = manager.load(1, 0).unwrap();
ready(&manager, replacement);
assert!(old.alive.load(std::sync::atomic::Ordering::Acquire));
manager.commit(replacement);
manager.apply_commits();
assert!(!old.alive.load(std::sync::atomic::Ordering::Acquire));
assert_eq!(manager.unload_audio(true, 0), AssetOpStatus::Ok);
assert!(banks.music_bank_slot(0).is_none());
assert!(banks.sound_bank_slot(0).is_some());
assert_eq!(manager.slot_info(SlotRef::music(0)).asset_id, None);
assert_eq!(manager.unload_audio(false, 0), AssetOpStatus::Ok);
assert!(banks.sound_bank_slot(0).is_none());
assert_eq!(manager.unload_audio(false, 16), AssetOpStatus::InvalidState);
}
#[test]
fn codec_tooling_rejects_overflowing_block_parameters_without_panicking() {
for align in [0, 4, usize::MAX - 3, usize::MAX] {
assert!(encode_ima_wav4(&[1, 2], 1, align).is_err());
assert!(decode_ima_wav4(&[0; 8], 1, 9, align, 9).is_err());
}
assert!(encode_ima_wav4(&[1], 1, 65532).is_err());
assert!(decode_ima_wav4(&[0; 8], 1, usize::MAX, 8, 9).is_err());
assert!(encode_ima_wav4(&[1], 0, 256).is_err());
}