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.
183 lines
6.8 KiB
Rust
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());
|
|
}
|