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.
This commit is contained in:
2026-11-20 22:15:24 +00:00
parent a32f834b2b
commit 8510c5b00d
40 changed files with 4708 additions and 509 deletions
@@ -0,0 +1,256 @@
//! Repeatable CPU/memory observations, not a handheld or physical-device guarantee.
use prometeu_drivers::{
Audio, MemoryBanks, SoundBankPoolInstaller,
bank_format::{decode_audio_bank, encode_ima_wav4},
engine::{AudioMixer, Packet},
};
use prometeu_hal::{
AudioBridge, LoopMode,
audio_bridge::AudioControl,
music_bank::{Instrument, MusicBank, MusicEvent},
sample::Sample,
sound_bank::SoundBank,
};
use serde_json::{Value, json};
use std::{
alloc::{GlobalAlloc, Layout, System},
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
time::Instant,
};
struct Counter;
static LIVE: AtomicUsize = AtomicUsize::new(0);
static PEAK: AtomicUsize = AtomicUsize::new(0);
unsafe impl GlobalAlloc for Counter {
unsafe fn alloc(&self, l: Layout) -> *mut u8 {
let p = unsafe { System.alloc(l) };
if !p.is_null() {
let n = LIVE.fetch_add(l.size(), Ordering::Relaxed) + l.size();
PEAK.fetch_max(n, Ordering::Relaxed);
}
p
}
unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
LIVE.fetch_sub(l.size(), Ordering::Relaxed);
unsafe { System.dealloc(p, l) }
}
}
#[global_allocator]
static ALLOCATOR: Counter = Counter;
fn stats(values: &mut [u64]) -> Value {
values.sort_unstable();
let n = values.len();
json!({"p50_ns":values[n/2],"p95_ns":values[n*95/100],"p99_ns":values[n*99/100],"max_ns":values[n-1]})
}
fn music(channels: u8) -> Arc<MusicBank> {
let pcm = (0..4096)
.flat_map(|i| {
std::iter::repeat_n(((i as f64 * 0.05).sin() * 800.0) as i16, channels as usize)
})
.collect();
let sample =
Arc::new(Sample::new(48000, pcm).with_channels(channels).unwrap().with_loop(0, 4096));
let events = (0..12)
.map(|id| MusicEvent { kind: 1, a: id, c: 60 + id as i32, d: 180, ..Default::default() })
.collect();
Arc::new(
MusicBank::compile(
"measure".into(),
vec![sample],
vec![Instrument {
looping: true,
attack_us: 1000,
decay_us: 10_000,
sustain: 50000,
release_us: 10_000,
send: 20000,
vibrato_cents: 10,
vibrato_millihz: 5000,
tremolo_depth: 1000,
tremolo_millihz: 3000,
..Default::default()
}],
events,
960,
500000,
3840,
None,
1,
)
.unwrap(),
)
}
fn scenario(channels: u8, dsp: bool, replacement: bool) -> Value {
let banks = Arc::new(MemoryBanks::new());
let mut audio = Audio::new(banks.clone());
banks.install_music_bank(0, music(channels));
banks.install_music_bank(1, music(channels));
audio.music_play(0, 0, true);
audio.music_play(1, 1, true);
let sample = Arc::new(
Sample::new(48000, vec![500; 4096 * channels as usize])
.with_channels(channels)
.unwrap()
.with_loop(0, 4096),
);
for voice in 0..8 {
audio.play_sample(sample.clone(), voice, 255, 128, 1.0, 0, LoopMode::On);
audio.control(AudioControl::SfxSend { voice, gain: 100 });
}
if dsp {
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 mixer = AudioMixer::new();
let mut packet = Packet::new();
mixer.apply_delivery_into(audio.transport().try_take().unwrap(), &mut packet);
packet.recycle(&audio.transport());
let mut pcm = [0.0; 512];
let mut timings = Vec::with_capacity(1000);
let mut overruns = 0;
let mut max_retired = 0;
let baseline = LIVE.load(Ordering::Relaxed);
PEAK.store(baseline, Ordering::Relaxed);
for iteration in 0..1000 {
if replacement && iteration % 10 == 0 {
banks.install_music_bank(0, music(channels));
audio.music_play(0, 0, true);
audio.control(AudioControl::MusicFade {
group: 1,
gain: 180,
frames: 2400,
smooth: true,
});
audio.finish_frame();
}
let start = Instant::now();
mixer.retire_inactive(&mut packet);
if let Some(delivery) = audio.transport().try_take() {
mixer.apply_delivery_into(delivery, &mut packet);
}
mixer.mix(&mut pcm);
mixer.retire_inactive(&mut packet);
let elapsed = start.elapsed().as_nanos() as u64;
if elapsed > 5_333_333 {
overruns += 1;
}
timings.push(elapsed);
max_retired = max_retired.max(packet.retained_pcm_bytes());
packet.recycle(&audio.transport());
std::hint::black_box(&pcm);
}
json!({"channels_per_voice":channels,"dsp":dsp,"replacement_every_10_buffers":replacement,"buffers":1000,"frames_per_buffer":256,"nominal_buffer_ns":5_333_333,"observed_budget_overruns":overruns,"timing":stats(&mut timings),"maximum_active_voices":mixer.diagnostics.maximum_voices,"engine_prepared_bytes":mixer.prepared_bytes(),"maximum_retired_pcm_bytes":max_retired,"baseline_allocated_bytes":baseline,"peak_allocated_bytes":PEAK.load(Ordering::Relaxed)})
}
fn codec_and_memory() -> Value {
let pcm: Vec<i16> = (0..480_000)
.flat_map(|i| {
[((i as f64 * 0.04).sin() * 12000.0) as i16, ((i as f64 * 0.06).cos() * 9000.0) as i16]
})
.collect();
let start = Instant::now();
let compressed = encode_ima_wav4(&pcm, 2, 512).unwrap();
let encode_ns = start.elapsed().as_nanos();
let mut bytes = vec![0u8; 88];
bytes[..4].copy_from_slice(b"SBNK");
bytes[4] = 1;
bytes[48] = 1;
bytes[49] = 2;
bytes[80] = 255;
bytes[81] = 128;
for (at, n) in [
(8, 1u32),
(20, 960),
(24, 500000),
(32, u32::MAX),
(52, 48000),
(56, 480000),
(68, 88),
(72, compressed.len() as u32),
(84, 65536),
] {
bytes[at..at + 4].copy_from_slice(&n.to_le_bytes());
}
bytes[76..78].copy_from_slice(&512u16.to_le_bytes());
bytes[78..80].copy_from_slice(&505u16.to_le_bytes());
bytes.extend(&compressed);
let mut decode = Vec::with_capacity(20);
let baseline = LIVE.load(Ordering::Relaxed);
PEAK.store(baseline, Ordering::Relaxed);
for _ in 0..20 {
let start = Instant::now();
let bank = decode_audio_bank(&bytes, false).unwrap();
decode.push(start.elapsed().as_nanos() as u64);
std::hint::black_box(bank);
}
let decode_peak = PEAK.load(Ordering::Relaxed);
let banks = MemoryBanks::new();
for slot in 0..16 {
banks.install_sound_bank(
slot,
Arc::new(SoundBank::new(vec![Arc::new(Sample::new(48000, vec![0; 1_048_576]))])),
);
}
let large_music = || {
let sample = Arc::new(Sample::new(48000, vec![0; 1_048_576]).with_loop(0, 1_048_576));
Arc::new(
MusicBank::compile(
"large".into(),
vec![sample],
vec![Instrument { looping: true, ..Default::default() }],
vec![MusicEvent { kind: 1, a: 1, c: 60, d: 255, ..Default::default() }],
960,
500000,
3840,
None,
1,
)
.unwrap(),
)
};
for slot in 0..16 {
banks.install_music_bank(slot, large_music());
}
let snapshot = banks.audio_memory();
let mut mixer = AudioMixer::new();
let mut packet = Packet::new();
use prometeu_drivers::SoundBankPoolAccess;
mixer.apply_delivery_into(
prometeu_drivers::AudioDelivery {
epoch: 0,
paused: false,
frame: Some(vec![prometeu_drivers::AudioCommand::MusicPlay {
group: 0,
bank: banks.music_bank_slot(0).unwrap(),
looping: true,
}]),
lifecycle: None,
},
&mut packet,
);
packet.recycle(&prometeu_drivers::AudioTransport::default());
mixer.mix(&mut [0.0; 2]);
let before = LIVE.load(Ordering::Relaxed);
PEAK.store(before, Ordering::Relaxed);
banks.install_music_bank(0, large_music());
mixer.retire_inactive(&mut packet);
let retired = packet.retained_pcm_bytes();
let replacement_peak = PEAK.load(Ordering::Relaxed);
packet.recycle(&prometeu_drivers::AudioTransport::default());
let after = LIVE.load(Ordering::Relaxed);
json!({"source_frames":480000,"channels":2,"pcm_bytes":pcm.len()*2,"cartridge_sample_bytes":compressed.len(),"compression_ratio":compressed.len()as f64/(pcm.len()*2)as f64,"encode_ns":encode_ns,"decode_timing":stats(&mut decode),"decode_baseline_allocated_bytes":baseline,"decode_peak_allocated_bytes":decode_peak,"large_bank_count":snapshot.banks.len(),"large_banks_unique_pcm_bytes":snapshot.unique_pcm_bytes,"replacement_baseline_allocated_bytes":before,"replacement_peak_allocated_bytes":replacement_peak,"replacement_after_reclamation_bytes":after,"retained_replaced_pcm_bytes":retired,"resident_accounted_metadata_bytes":snapshot.metadata_bytes,"resident_total_accounted_bytes":snapshot.total_accounted_bytes})
}
fn main() {
println!("{}",serde_json::to_string_pretty(&json!({"arch":std::env::consts::ARCH,"os":std::env::consts::OS,"observations":[scenario(1,false,false),scenario(2,false,false),scenario(2,true,false),scenario(2,true,true)],"codecs_and_memory":codec_and_memory()})).unwrap());
}
+243 -9
View File
@@ -1,6 +1,7 @@
#![allow(clippy::collapsible_if)]
mod decode;
mod resumable;
use crate::audio::bank_format::{DecodedAudioBank, decode_audio_bank};
use crate::memory_banks::{GlyphBankPoolInstaller, SceneBankPoolInstaller, SoundBankPoolInstaller};
use prometeu_hal::AssetBridge;
use prometeu_hal::asset::{
@@ -14,7 +15,7 @@ use prometeu_hal::cartridge::AssetsPayloadSource;
use prometeu_hal::color::Color;
use prometeu_hal::glyph::Glyph;
use prometeu_hal::glyph_bank::{GlyphBank, TileSize};
use prometeu_hal::sample::Sample;
use prometeu_hal::music_bank::MusicBank;
use prometeu_hal::scene_bank::SceneBank;
use prometeu_hal::scene_layer::{ParallaxFactor, SceneLayer};
use prometeu_hal::sound_bank::SoundBank;
@@ -61,6 +62,7 @@ pub struct AssetPipelineTelemetry {
pub active_progress: u16,
pub glyph_latency: AssetLatencyPercentiles,
pub sound_latency: AssetLatencyPercentiles,
pub music_latency: AssetLatencyPercentiles,
pub scene_latency: AssetLatencyPercentiles,
pub last_asset_id: Option<AssetId>,
pub last_asset_latency: AssetLatencyPercentiles,
@@ -130,6 +132,7 @@ impl AssetPipelineTelemetryState {
);
self.snapshot.glyph_latency = percentile_snapshot(self.bank_samples.get(&BankType::GLYPH));
self.snapshot.sound_latency = percentile_snapshot(self.bank_samples.get(&BankType::SOUNDS));
self.snapshot.music_latency = percentile_snapshot(self.bank_samples.get(&BankType::MUSIC));
self.snapshot.scene_latency = percentile_snapshot(self.bank_samples.get(&BankType::SCENE));
self.snapshot.last_asset_id = Some(asset_id);
self.snapshot.last_asset_latency = percentile_snapshot(self.asset_samples.get(&asset_id));
@@ -329,12 +332,14 @@ pub struct AssetManager {
gfx_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
glyph_slot_index: GlyphAssetSlotIndex,
sound_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
music_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
scene_slots: Arc<RwLock<[Option<AssetId>; 16]>>,
/// Residency policy for GFX glyph banks.
gfx_policy: BankPolicy<GlyphBank>,
/// Residency policy for sound banks.
sound_policy: BankPolicy<SoundBank>,
music_policy: BankPolicy<MusicBank>,
/// Residency policy for scene banks.
scene_policy: BankPolicy<SceneBank>,
@@ -370,6 +375,7 @@ struct AssetLoadJobResources<'a> {
pipeline_telemetry: &'a Arc<Mutex<AssetPipelineTelemetryState>>,
gfx_policy: &'a BankPolicy<GlyphBank>,
sound_policy: &'a BankPolicy<SoundBank>,
music_policy: &'a BankPolicy<MusicBank>,
scene_policy: &'a BankPolicy<SceneBank>,
}
@@ -479,6 +485,7 @@ struct AssetLoadWorker {
}
impl AssetLoadWorker {
#[allow(clippy::too_many_arguments)]
fn new(
handles: Arc<RwLock<HandleTable>>,
target_generations: Arc<RwLock<TargetGenerationTable>>,
@@ -486,6 +493,7 @@ impl AssetLoadWorker {
pipeline_telemetry: Arc<Mutex<AssetPipelineTelemetryState>>,
gfx_policy: BankPolicy<GlyphBank>,
sound_policy: BankPolicy<SoundBank>,
music_policy: BankPolicy<MusicBank>,
scene_policy: BankPolicy<SceneBank>,
) -> Self {
let queue = Arc::new(AssetLoadQueue::default());
@@ -498,6 +506,7 @@ impl AssetLoadWorker {
pipeline_telemetry: &pipeline_telemetry,
gfx_policy: &gfx_policy,
sound_policy: &sound_policy,
music_policy: &music_policy,
scene_policy: &scene_policy,
};
while let Some(job) = worker_queue.next_job() {
@@ -554,6 +563,9 @@ enum AssetOpMode {
}
impl AssetBridge for AssetManager {
fn unload_audio(&self, music: bool, slot: usize) -> AssetOpStatus {
self.unload_audio(music, slot)
}
fn bind_background_work(
&mut self,
lane: Arc<dyn prometeu_hal::background_work::BackgroundWork>,
@@ -647,7 +659,9 @@ impl AssetManager {
fn op_mode_for(entry: &AssetEntry) -> Result<AssetOpMode, String> {
match (entry.bank_type, entry.codec) {
(BankType::GLYPH, AssetCodec::None) => Ok(AssetOpMode::StageInMemory),
(BankType::SOUNDS, AssetCodec::None) => Ok(AssetOpMode::DirectFromSlice),
(BankType::SOUNDS, AssetCodec::None) | (BankType::MUSIC, AssetCodec::None) => {
Ok(AssetOpMode::DirectFromSlice)
}
(BankType::SCENE, AssetCodec::None) => Ok(AssetOpMode::DirectFromSlice),
}
}
@@ -670,6 +684,7 @@ impl AssetManager {
let pipeline_telemetry = Arc::new(Mutex::new(AssetPipelineTelemetryState::default()));
let gfx_policy = BankPolicy::new();
let sound_policy = BankPolicy::new();
let music_policy = BankPolicy::new();
let scene_policy = BankPolicy::new();
let load_worker = AssetLoadWorker::new(
Arc::clone(&handles),
@@ -678,6 +693,7 @@ impl AssetManager {
Arc::clone(&pipeline_telemetry),
gfx_policy.clone(),
sound_policy.clone(),
music_policy.clone(),
scene_policy.clone(),
);
@@ -689,9 +705,11 @@ impl AssetManager {
gfx_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
glyph_slot_index: GlyphAssetSlotIndex::new(),
sound_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
music_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
scene_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
gfx_policy,
sound_policy,
music_policy,
scene_policy,
handles,
target_handles: Arc::new(RwLock::new(HashMap::new())),
@@ -776,6 +794,23 @@ impl AssetManager {
}
}
}
BankType::MUSIC => {
if let Ok(bank) =
Self::perform_load_music_bank(&entry, self.assets_data.clone())
{
let bank_arc = Arc::new(bank);
self.music_policy.put_resident(
entry.asset_id,
Arc::clone(&bank_arc),
entry.decoded_size as usize,
);
self.sound_installer.install_music_bank(slot_index, bank_arc);
let mut slots = self.music_slots.write().unwrap();
if slot_index < slots.len() {
slots[slot_index] = Some(entry.asset_id);
}
}
}
BankType::SCENE => {
if let Ok(bank) =
Self::perform_load_scene_bank(&entry, self.assets_data.clone())
@@ -840,6 +875,7 @@ impl AssetManager {
fn clear_staging_for_handle(&self, handle_id: HandleId) {
self.gfx_policy.take_staging(handle_id);
self.sound_policy.take_staging(handle_id);
self.music_policy.take_staging(handle_id);
self.scene_policy.take_staging(handle_id);
}
@@ -855,6 +891,7 @@ impl AssetManager {
match slot.asset_type {
BankType::GLYPH => self.gfx_slots.read().unwrap().get(slot.index).and_then(|s| *s),
BankType::SOUNDS => self.sound_slots.read().unwrap().get(slot.index).and_then(|s| *s),
BankType::MUSIC => self.music_slots.read().unwrap().get(slot.index).and_then(|s| *s),
BankType::SCENE => self.scene_slots.read().unwrap().get(slot.index).and_then(|s| *s),
}
}
@@ -874,6 +911,7 @@ impl AssetManager {
let slot = match entry.bank_type {
BankType::GLYPH => SlotRef::gfx(slot_index),
BankType::SOUNDS => SlotRef::audio(slot_index),
BankType::MUSIC => SlotRef::music(slot_index),
BankType::SCENE => SlotRef::scene(slot_index),
};
@@ -899,6 +937,14 @@ impl AssetManager {
false
}
}
BankType::MUSIC => {
if let Some(bank) = self.music_policy.get_resident(asset_id) {
self.music_policy.stage(handle_id, bank, entry.decoded_size as usize);
true
} else {
false
}
}
BankType::SCENE => {
if let Some(bank) = self.scene_policy.get_resident(asset_id) {
self.scene_policy.stage(handle_id, bank, entry.decoded_size as usize);
@@ -1081,6 +1127,57 @@ impl AssetManager {
}
}
}
BankType::MUSIC => {
let result =
Self::perform_load_music_bank(&job.entry, Arc::clone(resources.assets_data));
match result {
Ok(musicbank) => {
if !Self::is_current_target_generation(
resources.target_generations,
job.slot,
job.request_generation,
) {
resources.pipeline_telemetry.lock().unwrap().record_stale_discard();
return;
}
let bank_arc = Arc::new(musicbank);
let resident_arc = resources.music_policy.put_resident(
job.asset_id,
bank_arc,
job.entry.decoded_size as usize,
);
if !Self::is_current_target_generation(
resources.target_generations,
job.slot,
job.request_generation,
) {
resources.pipeline_telemetry.lock().unwrap().record_stale_discard();
return;
}
resources.music_policy.stage(
job.handle_id,
resident_arc,
job.entry.decoded_size as usize,
);
Self::complete_load_job(resources.handles, &job, LoadStatus::READY);
Self::record_load_job_finished(
resources.pipeline_telemetry,
&job,
started_at,
LoadStatus::READY,
);
}
Err(_) => {
Self::complete_load_job(resources.handles, &job, LoadStatus::ERROR);
Self::record_load_job_finished(
resources.pipeline_telemetry,
&job,
started_at,
LoadStatus::ERROR,
);
}
}
}
BankType::SCENE => {
let result =
Self::perform_load_scene_bank(&job.entry, Arc::clone(resources.assets_data));
@@ -1268,6 +1365,32 @@ impl AssetManager {
}
}
fn perform_load_music_bank(
entry: &AssetEntry,
assets_data: Arc<RwLock<AssetsPayloadSource>>,
) -> Result<MusicBank, String> {
let op_mode = Self::op_mode_for(entry)?;
let slice = {
let assets_data = assets_data.read().unwrap();
assets_data
.open_slice(entry.offset, entry.size)
.map_err(|_| "Asset offset/size out of bounds".to_string())?
};
match op_mode {
AssetOpMode::DirectFromSlice => {
let mut reader =
slice.open_reader().map_err(|_| "Asset payload read failed".to_string())?;
Self::decode_music_bank_from_reader(entry, &mut reader)
}
AssetOpMode::StageInMemory => {
let buffer =
slice.read_all().map_err(|_| "Asset payload read failed".to_string())?;
Self::decode_music_bank_from_buffer(entry, &buffer)
}
}
}
fn perform_load_scene_bank(
entry: &AssetEntry,
assets_data: Arc<RwLock<AssetsPayloadSource>>,
@@ -1334,13 +1457,32 @@ impl AssetManager {
entry: &AssetEntry,
buffer: &[u8],
) -> Result<SoundBank, String> {
let sample_rate = decode::sound_rate(entry)?;
decode::payload_size(entry, buffer.len())?;
let mut data = Vec::with_capacity(buffer.len() / 2);
decode::append_pcm(&mut data, buffer);
let bank = decode_audio_bank(buffer, false)?;
if bank.decoded_size() as u64 != entry.decoded_size {
return Err("audio decoded_size mismatch".into());
}
if let DecodedAudioBank::Sound(bank) = bank {
Ok(bank)
} else {
Err("audio bank type mismatch".into())
}
}
let sample = Arc::new(Sample::new(sample_rate, data));
Ok(SoundBank::new(vec![sample]))
fn decode_music_bank_from_buffer(
entry: &AssetEntry,
buffer: &[u8],
) -> Result<MusicBank, String> {
decode::payload_size(entry, buffer.len())?;
let bank = decode_audio_bank(buffer, true)?;
if bank.decoded_size() as u64 != entry.decoded_size {
return Err("audio decoded_size mismatch".into());
}
if let DecodedAudioBank::Music(bank) = bank {
Ok(bank)
} else {
Err("audio bank type mismatch".into())
}
}
fn decode_sound_bank_from_reader(
@@ -1352,6 +1494,15 @@ impl AssetManager {
Self::decode_sound_bank_from_buffer(entry, &raw)
}
fn decode_music_bank_from_reader(
entry: &AssetEntry,
reader: &mut impl Read,
) -> Result<MusicBank, String> {
let mut raw = Vec::new();
reader.read_to_end(&mut raw).map_err(|_| "Asset payload read failed".to_string())?;
Self::decode_music_bank_from_buffer(entry, &raw)
}
pub fn status(&self, handle: HandleId) -> LoadStatus {
if let Some(status) = self.handles.read().unwrap().get(&handle).map(|h| h.status) {
return status;
@@ -1480,6 +1631,7 @@ impl AssetManager {
let slot_ref = match bank_type {
BankType::GLYPH => SlotRef::gfx(slot),
BankType::SOUNDS => SlotRef::audio(slot),
BankType::MUSIC => SlotRef::music(slot),
BankType::SCENE => SlotRef::scene(slot),
};
let handle = self.handle_for_slot(slot_ref);
@@ -1595,6 +1747,16 @@ impl AssetManager {
h.status = LoadStatus::COMMITTED;
}
}
BankType::MUSIC => {
if let Some((bank, _)) = self.music_policy.take_staging(handle_id) {
self.sound_installer.install_music_bank(h.slot.index, bank);
let mut slots = self.music_slots.write().unwrap();
if h.slot.index < slots.len() {
slots[h.slot.index] = Some(h._asset_id);
}
h.status = LoadStatus::COMMITTED;
}
}
BankType::SCENE => {
if let Some((bank, _)) = self.scene_policy.take_staging(handle_id) {
self.scene_installer.install_scene_bank(h.slot.index, bank);
@@ -1609,12 +1771,57 @@ impl AssetManager {
}
}
}
self.reap_audio_cache();
}
fn reap_audio_cache(&self) {
fn reap<T>(policy: &BankPolicy<T>, slots: &[Option<AssetId>; 16]) {
let mut resident = policy.resident.write().unwrap();
resident.retain(|id, entry| {
let keep = slots.contains(&Some(*id)) || Arc::strong_count(&entry.value) > 1;
if !keep {
policy.used_bytes.fetch_sub(entry.bytes, Ordering::Relaxed);
}
keep
});
}
reap(&self.sound_policy, &self.sound_slots.read().unwrap());
reap(&self.music_policy, &self.music_slots.read().unwrap());
}
pub fn unload_audio(&self, music: bool, slot: usize) -> AssetOpStatus {
if slot >= 16 {
return AssetOpStatus::InvalidState;
}
let target = if music { SlotRef::music(slot) } else { SlotRef::audio(slot) };
self.bump_target_generation(target);
if let Some(handle) = self.target_handles.read().unwrap().get(&target).copied() {
self.clear_staging_for_handle(handle);
if let Some(h) = self.handles.write().unwrap().get_mut(&handle) {
h.status = LoadStatus::CANCELED;
}
}
let slots = if music { &self.music_slots } else { &self.sound_slots };
let mut ids = slots.write().unwrap();
let previous = ids[slot].take();
self.sound_installer.unload_audio_bank(music, slot);
if let Some(id) = previous.filter(|id| !ids.contains(&Some(*id))) {
if music {
if let Some(old) = self.music_policy.resident.write().unwrap().remove(&id) {
self.music_policy.used_bytes.fetch_sub(old.bytes, Ordering::Relaxed);
}
} else if let Some(old) = self.sound_policy.resident.write().unwrap().remove(&id) {
self.sound_policy.used_bytes.fetch_sub(old.bytes, Ordering::Relaxed);
}
}
AssetOpStatus::Ok
}
pub fn bank_telemetry(&self) -> Vec<BankTelemetry> {
vec![
self.bank_telemetry_for(BankType::GLYPH),
self.bank_telemetry_for(BankType::SOUNDS),
self.bank_telemetry_for(BankType::MUSIC),
self.bank_telemetry_for(BankType::SCENE),
]
}
@@ -1627,6 +1834,9 @@ impl AssetManager {
BankType::SOUNDS => {
self.sound_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
}
BankType::MUSIC => {
self.music_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
}
BankType::SCENE => {
self.scene_slots.read().unwrap().iter().filter(|slot| slot.is_some()).count()
}
@@ -1679,6 +1889,27 @@ impl AssetManager {
SlotStats { asset_id, asset_name, generation: 0, resident_bytes: bytes }
}
BankType::MUSIC => {
let slots = self.music_slots.read().unwrap();
let asset_id = slots.get(slot.index).and_then(|s| *s);
let (bytes, asset_name) = if let Some(id) = &asset_id {
let bytes = self
.music_policy
.resident
.read()
.unwrap()
.get(id)
.map(|entry| entry.bytes)
.unwrap_or(0);
let name = self.assets.read().unwrap().get(id).map(|e| e.asset_name.clone());
(bytes, name)
} else {
(0, None)
};
SlotStats { asset_id, asset_name, generation: 0, resident_bytes: bytes }
}
BankType::SCENE => {
let slots = self.scene_slots.read().unwrap();
let asset_id = slots.get(slot.index).and_then(|s| *s);
@@ -1711,6 +1942,7 @@ impl AssetManager {
}
self.gfx_policy.clear();
self.sound_policy.clear();
self.music_policy.clear();
self.scene_policy.clear();
self.handles.write().unwrap().clear();
self.target_handles.write().unwrap().clear();
@@ -1721,9 +1953,11 @@ impl AssetManager {
self.gfx_slots.write().unwrap().fill(None);
self.glyph_slot_index.clear();
self.sound_slots.write().unwrap().fill(None);
self.music_slots.write().unwrap().fill(None);
self.scene_slots.write().unwrap().fill(None);
self.gfx_installer.clear_glyph_banks();
self.sound_installer.clear_sound_banks();
self.sound_installer.clear_music_banks();
self.scene_installer.clear_scene_banks();
}
@@ -2512,7 +2746,7 @@ mod tests {
let scene_installer = Arc::clone(&banks) as Arc<dyn SceneBankPoolInstaller>;
// 100 samples of 16-bit PCM (zeros)
let data = vec![0u8; 200];
let data = crate::bank_format::test_pcm_bank(&[0u8; 200], 44100);
let asset_entry = AssetEntry {
asset_id: 1,
@@ -2558,7 +2792,7 @@ mod tests {
let sound_installer = Arc::clone(&banks) as Arc<dyn SoundBankPoolInstaller>;
let scene_installer = Arc::clone(&banks) as Arc<dyn SceneBankPoolInstaller>;
let data = vec![0u8; 200];
let data = crate::bank_format::test_pcm_bank(&[0u8; 200], 44100);
let asset_entry = AssetEntry {
asset_id: 2,
@@ -69,13 +69,6 @@ pub(super) fn write_palettes(
palettes[at / 16][at % 16] = Color::rgba(rgba[0], rgba[1], rgba[2], rgba[3]);
}
}
pub(super) fn sound_rate(entry: &AssetEntry) -> Result<u32, String> {
Ok(entry.metadata_as_sound_bank()?.sample_rate)
}
// Callers split on even chunk boundaries. Only the final odd byte is ignored.
pub(super) fn append_pcm(data: &mut Vec<i16>, bytes: &[u8]) {
data.extend(bytes.as_chunks::<2>().0.iter().map(|p| i16::from_le_bytes(*p)));
}
pub(super) fn payload_size(entry: &AssetEntry, actual: usize) -> Result<(), String> {
if actual as u64 != entry.size {
return Err("Invalid asset payload size".into());
@@ -32,47 +32,33 @@ fn pcm_entry(size: u64) -> AssetEntry {
}
#[test]
fn pcm_chunk_edges_and_odd_tails_have_explicit_baseline_outputs() {
fn pcm_chunk_edges_validate_all_declared_frames_and_reject_odd_tails() {
for len in [0, 1, 2, 3, 4095, 4096, 4097, 8191, 8192, 8193] {
let bytes: Vec<u8> = (0..len).map(|i| if i % 2 == 0 { 0x34 } else { 0x12 }).collect();
let entry = pcm_entry(len as u64);
let expected = json!([[vec![0x1234_i16; len / 2], 44100, null, null]]);
let buffer = AssetManager::decode_sound_bank_from_buffer(&entry, &bytes).unwrap();
let reader = AssetManager::decode_sound_bank_from_reader(&entry, &mut &bytes[..]).unwrap();
let source = Arc::new(RwLock::new(AssetsPayloadSource::from_bytes(bytes)));
let production = AssetManager::perform_load_sound_bank(&entry, source.clone()).unwrap();
assert_eq!(sound_snapshot(&buffer), expected, "buffer len={len}");
assert_eq!(sound_snapshot(&reader), expected, "reader len={len}");
assert_eq!(sound_snapshot(&production), expected, "legacy load len={len}");
assert_eq!(
resumable::conformance_result(&entry, &source).unwrap(),
expected,
"resumable len={len}"
);
let raw: Vec<u8> = (0..len).map(|i| if i % 2 == 0 { 0x34 } else { 0x12 }).collect();
let bytes = crate::bank_format::test_pcm_bank(&raw, 44100);
let expected = if len % 2 == 0 {
Some(json!([[vec![0x1234_i16; len / 2], 44100, null, null]]))
} else {
None
};
check_case("pcm-chunk", &pcm_entry(bytes.len() as u64), bytes, expected);
}
}
#[test]
fn physically_truncated_pcm_file_is_rejected_by_both_modes() {
// Two actual bytes, three declared bytes: the missing byte is an odd tail.
// The approved rule rejects missing declared bytes, including an odd tail.
let fixture = FileFixture::new("truncated-pcm", &[0x34, 0x12]);
let entry = pcm_entry(3);
let source = fixture.source(3);
fn physically_truncated_pcm_file_is_rejected_by_all_modes() {
let bytes = crate::bank_format::test_pcm_bank(&[0x34, 0x12], 44100);
let entry = pcm_entry(bytes.len() as u64);
let fixture = FileFixture::new("truncated-pcm", &bytes[..bytes.len() - 1]);
let source = fixture.source(bytes.len() as u64);
assert!(AssetManager::perform_load_sound_bank(&entry, source.clone()).is_err());
assert!(resumable::conformance_result(&entry, &source).is_err());
// With the declared byte physically present, both accept and ignore it.
std::fs::write(&fixture.0, [0x34, 0x12, 0xff]).unwrap();
std::fs::write(&fixture.0, &bytes).unwrap();
let expected = json!([[[0x1234], 44100, null, null]]);
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
assert_eq!(
sound_snapshot(&AssetManager::perform_load_sound_bank(&entry, source.clone()).unwrap()),
sound_snapshot(&AssetManager::perform_load_sound_bank(&entry, source).unwrap()),
expected
);
// Memory carriers reject the range before either decoder can accept it.
let memory = Arc::new(RwLock::new(AssetsPayloadSource::from_bytes(vec![0x34, 0x12])));
assert!(AssetManager::perform_load_sound_bank(&entry, memory.clone()).is_err());
assert!(resumable::conformance_result(&entry, &memory).is_err());
}
#[test]
@@ -129,6 +115,8 @@ fn check_case(name: &str, entry: &AssetEntry, bytes: Vec<u8>, expected: Option<V
AssetManager::perform_load_sound_bank(entry, source.clone())
.map(|b| sound_snapshot(&b))
}
BankType::MUSIC => AssetManager::perform_load_music_bank(entry, source.clone())
.map(|b| music_snapshot(&b)),
BankType::SCENE => AssetManager::perform_load_scene_bank(entry, source.clone())
.map(|b| scene_snapshot(&b)),
};
@@ -153,6 +141,8 @@ fn check_case(name: &str, entry: &AssetEntry, bytes: Vec<u8>, expected: Option<V
AssetManager::decode_sound_bank_from_reader(entry, &mut reader)
.map(|b| sound_snapshot(&b))
}
(BankType::MUSIC, _) => AssetManager::decode_music_bank_from_buffer(entry, &bytes)
.map(|b| music_snapshot(&b)),
(BankType::SCENE, 0) => AssetManager::decode_scene_bank_from_buffer(entry, &bytes)
.map(|b| scene_snapshot(&b)),
(BankType::SCENE, _) => {
@@ -319,35 +309,29 @@ fn scene_tile_chunk_edges_flags_and_reserved_bytes() {
}
#[test]
fn pcm_metadata_and_source_range_corpus() {
for metadata in [
json!(null),
json!({}),
json!({"sample_rate":-1,"channels":1}),
json!({"sample_rate":44100,"channels":"bad"}),
] {
let mut e = pcm_entry(2);
e.metadata = metadata;
check_case("pcm-metadata", &e, vec![0x34, 0x12], None);
fn pcm_descriptor_and_source_range_corpus() {
let bytes = crate::bank_format::test_pcm_bank(&[0x34, 0x12], 44100);
let entry = pcm_entry(bytes.len() as u64);
// Audio metadata lives in the versioned payload, so it can vary per sample.
for (offset, value) in
[(48, 99u32), (49, 0), (52, 0), (56, 2), (60, 1), (68, 0), (72, 3), (84, 0)]
{
let mut invalid = bytes.clone();
if offset == 48 || offset == 49 {
invalid[offset] = value as u8;
} else {
invalid[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
}
check_case("descriptor", &entry, invalid, None);
}
// These fields are currently descriptive, not extra PCM layout constraints.
let mut e = pcm_entry(2);
e.metadata = json!({"sample_rate":0,"channels":0});
e.decoded_size = 999;
check_case(
"pcm-permissive-metadata",
&e,
vec![0x34, 0x12],
Some(json!([[[0x1234], 0, null, null]])),
);
for offset in [1, u64::MAX] {
let mut e = pcm_entry(2);
e.offset = offset;
check_case("source-range", &e, vec![0x34, 0x12], None);
let mut invalid = entry.clone();
invalid.offset = offset;
check_case("source-range", &invalid, bytes.clone(), None);
}
let mut e = pcm_entry(2);
e.size = u64::MAX;
check_case("source-size-overflow", &e, vec![0x34, 0x12], None);
let mut invalid = entry;
invalid.decoded_size += 1;
check_case("decoded-size", &invalid, bytes, None);
}
pub(in crate::asset) fn glyph_snapshot(bank: &GlyphBank) -> Value {
@@ -430,3 +414,48 @@ fn physically_truncated_glyph_palette_is_rejected_by_both_modes() {
);
assert_eq!(resumable::conformance_result(&entry, &source).unwrap(), expected);
}
pub(in crate::asset) fn music_snapshot(bank: &prometeu_hal::music_bank::MusicBank) -> Value {
json!({"name": bank.name, "events": bank.events.len(), "pcm": bank.metrics.pcm_bytes})
}
#[test]
fn mixed_audio_fixtures_conform_across_all_asset_decode_modes() {
for (music, bytes) in [
(
false,
&include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/mixed-sound.sbnk"
))[..],
),
(
true,
&include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/mixed-music.mbnk"
))[..],
),
] {
let decoded = crate::bank_format::decode_audio_bank(bytes, music).unwrap();
let size = decoded.decoded_size();
let expected = match decoded {
DecodedAudioBank::Sound(b) => sound_snapshot(&b),
DecodedAudioBank::Music(b) => music_snapshot(&b),
};
let entry = AssetEntry {
asset_id: 7,
asset_name: "mixed".into(),
bank_type: if music { BankType::MUSIC } else { BankType::SOUNDS },
offset: 0,
size: bytes.len() as u64,
decoded_size: size as u64,
codec: AssetCodec::None,
metadata: json!({"version":1}),
};
check_case("mixed-audio", &entry, bytes.to_vec(), Some(expected));
let mut invalid = bytes.to_vec();
invalid[0] = 0;
check_case("mixed-bad-magic", &entry, invalid, None);
}
}
@@ -11,6 +11,7 @@ pub(super) struct Resources {
telemetry: Arc<Mutex<AssetPipelineTelemetryState>>,
gfx: BankPolicy<GlyphBank>,
sound: BankPolicy<SoundBank>,
music: BankPolicy<MusicBank>,
scene: BankPolicy<SceneBank>,
}
impl Resources {
@@ -22,6 +23,7 @@ impl Resources {
telemetry: m.pipeline_telemetry.clone(),
gfx: m.gfx_policy.clone(),
sound: m.sound_policy.clone(),
music: m.music_policy.clone(),
scene: m.scene_policy.clone(),
}
}
@@ -142,6 +144,18 @@ pub(super) fn schedule(
job.entry.decoded_size as usize,
);
}
Decoded::Music(bank) => {
let resident = resources.music.put_resident(
job.asset_id,
Arc::new(bank),
job.entry.decoded_size as usize,
);
resources.music.stage(
job.handle_id,
resident,
job.entry.decoded_size as usize,
);
}
Decoded::Scene(bank) => {
let resident = resources.scene.put_resident(
job.asset_id,
@@ -188,6 +202,7 @@ pub(super) fn schedule(
enum Decoded {
Glyph(GlyphBank),
Sound(SoundBank),
Music(MusicBank),
Scene(SceneBank),
}
enum State {
@@ -199,10 +214,11 @@ enum State {
palette_position: usize,
},
Sound {
sample_rate: u32,
data: Vec<i16>,
raw: Vec<u8>,
remaining: usize,
music: bool,
},
Audio(Box<crate::bank_format::AudioBankMaterializer<'static>>),
Scene {
layers: [SceneLayer; SCENE_LAYER_COUNT_V1],
layer: usize,
@@ -245,12 +261,16 @@ impl Decoder {
palette_position: 0,
}
}
BankType::SOUNDS => {
let sample_rate = decode::sound_rate(entry)?;
BankType::SOUNDS | BankType::MUSIC => {
let mut raw = Vec::new();
raw.try_reserve_exact(
usize::try_from(entry.size).map_err(|_| "audio size overflow")?,
)
.map_err(|_| "audio allocation failed")?;
State::Sound {
sample_rate,
data: Vec::with_capacity(entry.size as usize / 2),
raw,
remaining: entry.size as usize,
music: entry.bank_type == BankType::MUSIC,
}
}
BankType::SCENE => {
@@ -294,18 +314,34 @@ impl Decoder {
};
Ok(Some(Decoded::Glyph(bank)))
}
State::Sound { sample_rate, data, remaining } => {
State::Sound { raw, remaining, music } => {
if *remaining > 0 {
let n = (*remaining).min(bytes.len());
self.reader.read_exact(&mut bytes[..n]).map_err(|e| e.to_string())?;
decode::append_pcm(data, &bytes[..n]);
let n = (*remaining).min(4096);
let mut buffer = [0; 4096];
self.reader.read_exact(&mut buffer[..n]).map_err(|e| e.to_string())?;
raw.extend_from_slice(&buffer[..n]);
*remaining -= n;
return Ok(None);
}
let rate = *sample_rate;
let data = std::mem::take(data);
let decoder = crate::bank_format::AudioBankMaterializer::new(
std::borrow::Cow::Owned(std::mem::take(raw)),
*music,
)?;
self.state = State::Audio(Box::new(decoder));
Ok(None)
}
State::Audio(decoder) => {
let Some(bank) = decoder.step()? else {
return Ok(None);
};
if bank.decoded_size() as u64 != self.entry.decoded_size {
return Err("audio decoded_size mismatch".into());
}
self.state = State::Done;
Ok(Some(Decoded::Sound(SoundBank::new(vec![Arc::new(Sample::new(rate, data))]))))
Ok(Some(match bank {
DecodedAudioBank::Sound(b) => Decoded::Sound(b),
DecodedAudioBank::Music(b) => Decoded::Music(b),
}))
}
State::Scene { layers, layer, tiles_left, header, decoded } => {
if !*header {
@@ -372,6 +408,7 @@ pub(super) fn conformance_result(
Decoded::Glyph(bank) => super::decode::tests::glyph_snapshot(&bank),
Decoded::Sound(bank) => super::decode::tests::sound_snapshot(&bank),
Decoded::Scene(bank) => super::decode::tests::scene_snapshot(&bank),
Decoded::Music(bank) => super::decode::tests::music_snapshot(&bank),
});
}
}
@@ -448,9 +485,12 @@ mod tests {
panic!("decoder did not finish")
}
#[test]
fn resumable_sound_and_scene_preserve_existing_formats() {
fn resumable_audio_bank_and_scene_use_canonical_formats() {
let pcm: Vec<i16> = (0..5000).map(|n| n as i16 - 2500).collect();
let bytes: Vec<u8> = pcm.iter().flat_map(|n| n.to_le_bytes()).collect();
let bytes = crate::bank_format::test_pcm_bank(
&pcm.iter().flat_map(|n| n.to_le_bytes()).collect::<Vec<_>>(),
44100,
);
let entry = AssetEntry {
asset_id: 1,
asset_name: "pcm".into(),
@@ -485,7 +525,7 @@ mod tests {
}
#[test]
fn shared_preload_waits_for_worker_and_frame_publication() {
let bytes = vec![0; 8192];
let bytes = crate::bank_format::test_pcm_bank(&[0; 8192], 44100);
let entry = AssetEntry {
asset_id: 1,
asset_name: "pcm".into(),
@@ -521,7 +561,7 @@ mod tests {
#[test]
fn canceled_and_superseded_partial_decoders_never_publish() {
use crate::memory_banks::SoundBankPoolAccess;
let bytes = vec![0x12; 16384];
let bytes = crate::bank_format::test_pcm_bank(&[0x12; 16384], 44100);
let entry = AssetEntry {
asset_id: 1,
asset_name: "pcm".into(),
+100 -15
View File
@@ -1,8 +1,14 @@
use prometeu_hal::{AudioBridge, AudioOpStatus};
use prometeu_hal::music_bank::MusicBank;
use prometeu_hal::{AudioBridge, AudioOpStatus, audio_bridge::AudioControl};
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
pub mod bank_format;
/// Maximum number of simultaneous audio voices supported by the hardware.
pub const MAX_CHANNELS: usize = 16;
pub const MAX_CHANNELS: usize = 32;
pub const SFX_CHANNELS: usize = 8;
pub const SFX_START: usize = 24;
pub mod engine;
/// Standard sample rate for the final audio output.
pub const OUTPUT_SAMPLE_RATE: u32 = 48000;
@@ -19,13 +25,14 @@ pub struct Channel {
pub sample: Option<Arc<Sample>>,
/// Whether this channel is currently active.
pub active: bool,
pub alive: Option<Arc<AtomicBool>>,
/// Current playback position within the sample (fractional for pitch shifting).
pub pos: f64,
/// Playback speed multiplier (1.0 = original speed).
pub pitch: f64,
/// Voice volume (0-255).
pub volume: u8,
/// Stereo panning (0=Full Left, 127=Center, 255=Full Right).
/// Stereo panning (0=Full Left, 128=Center, 255=Full Right).
pub pan: u8,
/// Loop configuration for this voice.
pub loop_mode: LoopMode,
@@ -38,10 +45,11 @@ impl Default for Channel {
Self {
sample: None,
active: false,
alive: None,
pos: 0.0,
pitch: 1.0,
volume: 255,
pan: 127,
pan: 128,
loop_mode: LoopMode::Off,
priority: 0,
}
@@ -53,9 +61,16 @@ impl Default for Channel {
/// Because the Core logic runs at 60Hz and Audio is generated at 48kHz,
/// we use an asynchronous command queue to synchronize them.
pub enum AudioCommand {
MusicPlay {
group: usize,
bank: Arc<MusicBank>,
looping: bool,
},
Control(AudioControl),
/// Start playing a sample on a specific voice.
Play {
sample: Arc<Sample>,
alive: Option<Arc<AtomicBool>>,
voice_id: usize,
volume: u8,
pan: u8,
@@ -64,13 +79,24 @@ pub enum AudioCommand {
loop_mode: LoopMode,
},
/// Stop playback on a voice when this command is applied.
Stop { voice_id: usize },
Stop {
voice_id: usize,
},
/// Update volume of an ongoing playback.
SetVolume { voice_id: usize, volume: u8 },
SetVolume {
voice_id: usize,
volume: u8,
},
/// Update panning of an ongoing playback.
SetPan { voice_id: usize, pan: u8 },
SetPan {
voice_id: usize,
pan: u8,
},
/// Update pitch of an ongoing playback.
SetPitch { voice_id: usize, pitch: f64 },
SetPitch {
voice_id: usize,
pitch: f64,
},
}
mod transport;
@@ -109,7 +135,7 @@ impl Audio {
}
fn enqueue(&mut self, voice: usize, command: AudioCommand) -> AudioOpStatus {
if voice >= MAX_CHANNELS {
if voice >= SFX_CHANNELS {
return AudioOpStatus::VoiceInvalid;
}
let admitted = if self.in_lifecycle {
@@ -142,7 +168,7 @@ impl AudioBridge for Audio {
priority: u8,
loop_mode: LoopMode,
) -> AudioOpStatus {
if voice_id >= MAX_CHANNELS {
if voice_id >= SFX_CHANNELS {
return AudioOpStatus::VoiceInvalid;
}
if !pitch.is_finite() || pitch <= 0.0 {
@@ -154,7 +180,19 @@ impl AudioBridge for Audio {
let Some(sample) = bank.samples.get(sample_id as usize).cloned() else {
return AudioOpStatus::SampleNotFound;
};
self.play_sample(sample, voice_id, volume, pan, pitch, priority, loop_mode)
self.enqueue(
voice_id,
AudioCommand::Play {
sample,
alive: Some(bank.alive.clone()),
voice_id,
volume,
pan,
pitch,
priority,
loop_mode,
},
)
}
fn play_sample(
@@ -167,7 +205,7 @@ impl AudioBridge for Audio {
priority: u8,
loop_mode: LoopMode,
) -> AudioOpStatus {
if voice_id >= MAX_CHANNELS {
if voice_id >= SFX_CHANNELS {
return AudioOpStatus::VoiceInvalid;
}
if !pitch.is_finite() || pitch <= 0.0 {
@@ -175,10 +213,57 @@ impl AudioBridge for Audio {
}
self.enqueue(
voice_id,
AudioCommand::Play { sample, voice_id, volume, pan, pitch, priority, loop_mode },
AudioCommand::Play {
sample,
alive: None,
voice_id,
volume,
pan,
pitch,
priority,
loop_mode,
},
)
}
fn music_play(&mut self, group: usize, bank: usize, looping: bool) -> AudioOpStatus {
if group > 1 {
return AudioOpStatus::ArgRangeInvalid;
}
let Some(bank) = self.sound_banks.music_bank_slot(bank) else {
return AudioOpStatus::BankInvalid;
};
self.enqueue(0, AudioCommand::MusicPlay { group, bank, looping })
}
fn control(&mut self, control: AudioControl) -> AudioOpStatus {
let valid = match control {
AudioControl::MusicStop { group }
| AudioControl::MusicPause { group, .. }
| AudioControl::MusicVolume { group, .. }
| AudioControl::MusicFade { group, .. } => group < 2,
AudioControl::Crossfade { source, target, .. } => {
source < 2 && target < 2 && source != target
}
AudioControl::BusVolume { bus, .. } => bus < 3,
AudioControl::GroupVolume { group, .. } => group < 3,
AudioControl::SfxSend { voice, .. } => voice < SFX_CHANNELS,
AudioControl::Effect { group, cutoff_hz, delay_frames, feedback, wet, dry } => {
group < 3
&& cutoff_hz <= OUTPUT_SAMPLE_RATE / 2
&& delay_frames <= 96_000
&& feedback.is_finite()
&& feedback.abs() < 1.0
&& wet.is_finite()
&& dry.is_finite()
&& (0.0..=1.0).contains(&wet)
&& (0.0..=1.0).contains(&dry)
}
};
if !valid {
return AudioOpStatus::ArgRangeInvalid;
}
self.enqueue(0, AudioCommand::Control(control))
}
fn stop(&mut self, voice_id: usize) -> AudioOpStatus {
self.enqueue(voice_id, AudioCommand::Stop { voice_id })
}
@@ -189,7 +274,7 @@ impl AudioBridge for Audio {
self.enqueue(voice_id, AudioCommand::SetPan { voice_id, pan })
}
fn set_pitch(&mut self, voice_id: usize, pitch: f64) -> AudioOpStatus {
if voice_id >= MAX_CHANNELS {
if voice_id >= SFX_CHANNELS {
return AudioOpStatus::VoiceInvalid;
}
if !pitch.is_finite() || pitch <= 0.0 {
@@ -311,7 +396,7 @@ mod control_tests {
for _ in 0..MAX_COMMANDS_PER_FRAME - 1 {
assert_eq!(audio.stop(0), AudioOpStatus::Ok);
}
assert_eq!(audio.set_volume(15, 0), AudioOpStatus::Ok);
assert_eq!(audio.set_volume(7, 0), AudioOpStatus::Ok);
assert_eq!(audio.set_pan(0, 255), AudioOpStatus::CommandLimit);
assert_eq!(audio.set_pitch(16, f64::NAN), AudioOpStatus::VoiceInvalid);
assert_eq!(audio.set_pitch(0, f64::NAN), AudioOpStatus::ArgRangeInvalid);
@@ -0,0 +1,592 @@
//! SBNK/MBNK v1. IMA WAVE4 algorithm implemented here from the published Intel
//! format, not copied from a third-party decoder. Project MIT license applies.
use prometeu_hal::{
music_bank::{Instrument, MusicBank, MusicCompiler, MusicEvent},
sample::Sample,
sound_bank::{AudioBankMetrics, SoundBank},
};
use std::sync::Arc;
pub const HEADER_BYTES: usize = 48;
pub const SAMPLE_BYTES: usize = 40;
pub const INSTRUMENT_BYTES: usize = 64;
pub const EVENT_BYTES: usize = 32;
pub enum DecodedAudioBank {
Sound(SoundBank),
Music(MusicBank),
}
impl DecodedAudioBank {
pub fn decoded_size(&self) -> usize {
match self {
Self::Sound(b) => b.metrics.canonical_decoded_bytes,
Self::Music(b) => b.metrics.canonical_decoded_bytes,
}
}
}
fn bytes(data: &[u8], offset: usize, len: usize) -> Result<&[u8], String> {
data.get(offset..offset.checked_add(len).ok_or("audio offset overflow")?)
.ok_or_else(|| "truncated audio bank".into())
}
fn u16le(b: &[u8], o: usize) -> Result<u16, String> {
Ok(u16::from_le_bytes(bytes(b, o, 2)?.try_into().unwrap()))
}
fn u32le(b: &[u8], o: usize) -> Result<u32, String> {
Ok(u32::from_le_bytes(bytes(b, o, 4)?.try_into().unwrap()))
}
fn zero(b: &[u8]) -> Result<(), String> {
if b.iter().any(|&x| x != 0) { Err("nonzero audio reserved bytes".into()) } else { Ok(()) }
}
fn vector<T>(n: usize) -> Result<Vec<T>, String> {
let mut v = Vec::new();
v.try_reserve_exact(n).map_err(|_| "audio allocation failed")?;
Ok(v)
}
/// One bank owns its serialized bytes while materializing. IO and CPU preparation
/// yield separately; no partially decoded bank escapes this object.
pub struct AudioBankMaterializer<'a> {
data: std::borrow::Cow<'a, [u8]>,
music: bool,
ns: usize,
ni: usize,
ne: usize,
ppq: u32,
tempo: u32,
duration: u32,
loop_tick: Option<u32>,
tracks: usize,
name: String,
samples_at: usize,
metadata: usize,
payload_end: usize,
samples: Vec<Arc<Sample>>,
instruments: Vec<Instrument>,
events: Vec<MusicEvent>,
current: Option<SampleMaterializer>,
compiler: Option<MusicCompiler>,
pcm_bytes: usize,
started: std::time::Instant,
}
struct SampleMaterializer {
sample: Sample,
codec: u8,
frames: usize,
offset: usize,
size: usize,
align: usize,
spb: usize,
consumed: usize,
}
impl<'a> AudioBankMaterializer<'a> {
pub fn new(data: std::borrow::Cow<'a, [u8]>, music: bool) -> Result<Self, String> {
let started = std::time::Instant::now();
bytes(&data, 0, HEADER_BYTES)?;
if &data[..4] != if music { b"MBNK" } else { b"SBNK" }
|| u16le(&data, 4)? != 1
|| u16le(&data, 6)? != 0
{
return Err("unsupported audio bank magic/version/flags".into());
}
let ns = u32le(&data, 8)? as usize;
let ni = u32le(&data, 12)? as usize;
let ne = u32le(&data, 16)? as usize;
let ppq = u32le(&data, 20)?;
let tempo = u32le(&data, 24)?;
let duration = u32le(&data, 28)?;
let lp = u32le(&data, 32)?;
let tracks = u32le(&data, 36)? as usize;
let name_len = u32le(&data, 40)? as usize;
zero(bytes(&data, 44, 4)?)?;
if ns > 65536
|| ppq != 960
|| tempo == 0
|| (!music
&& (ns == 0
|| ni != 0
|| ne != 0
|| duration != 0
|| tracks != 0
|| lp != u32::MAX))
{
return Err("invalid audio bank counts/clock".into());
}
if music
&& (duration == 0 || !(1..=256).contains(&tracks) || (lp != u32::MAX && lp >= duration))
{
return Err("invalid music clock/tracks/loop".into());
}
let mut offset = HEADER_BYTES.checked_add(name_len).ok_or("audio name overflow")?;
let samples_at = offset;
for (n, size) in [(ns, SAMPLE_BYTES), (ni, INSTRUMENT_BYTES), (ne, EVENT_BYTES)] {
offset = offset
.checked_add(n.checked_mul(size).ok_or("audio table overflow")?)
.ok_or("audio table overflow")?;
}
bytes(&data, 0, offset)?;
let text = std::str::from_utf8(bytes(&data, HEADER_BYTES, name_len)?)
.map_err(|_| "audio name UTF-8")?;
let mut name = String::new();
name.try_reserve_exact(text.len()).map_err(|_| "audio allocation failed")?;
name.push_str(text);
Ok(Self {
data,
music,
ns,
ni,
ne,
ppq,
tempo,
duration,
loop_tick: (lp != u32::MAX).then_some(lp),
tracks,
name,
samples_at,
metadata: offset,
payload_end: offset,
samples: vector(ns)?,
instruments: vector(ni)?,
events: vector(ne)?,
current: None,
compiler: None,
pcm_bytes: 0,
started,
})
}
fn start_sample(&mut self) -> Result<(), String> {
let d =
bytes(&self.data, self.samples_at + self.samples.len() * SAMPLE_BYTES, SAMPLE_BYTES)?;
let codec = d[0];
let channels = d[1];
let flags = u16le(d, 2)?;
let rate = u32le(d, 4)?;
let frames = u32le(d, 8)? as usize;
let start = u32le(d, 12)?;
let end = u32le(d, 16)?;
let offset = u32le(d, 20)? as usize;
let size = u32le(d, 24)? as usize;
let align = u16le(d, 28)? as usize;
let spb = u16le(d, 30)? as usize;
let pitch = u32le(d, 36)?;
zero(bytes(d, 34, 2)?)?;
if !(1..=2).contains(&channels)
|| rate == 0
|| pitch == 0
|| flags & !1 != 0
|| offset != self.payload_end
|| (flags == 0 && (start != 0 || end != 0))
|| (flags == 1 && (start >= end || end as usize > frames))
{
return Err("invalid audio sample descriptor/loop".into());
}
let scalar = frames.checked_mul(channels as usize).ok_or("PCM frame overflow")?;
let resident = scalar.checked_mul(2).ok_or("PCM byte overflow")?;
bytes(&self.data, offset, size)?;
match codec {
0 => {
if size != resident || align != 0 || spb != 0 {
return Err("PCM payload/frame count mismatch".into());
}
}
1 => {
let c = channels as usize;
if align < 8 * c
|| !align.is_multiple_of(4 * c)
|| spb != 1 + (align - 4 * c) * 2 / c
|| !size.is_multiple_of(align)
|| size / align != frames.div_ceil(spb)
{
return Err("IMA block layout/frame count".into());
}
}
_ => return Err("unsupported sample codec".into()),
}
let mut sample = Sample::new(rate, vector(scalar)?).with_channels(channels)?;
if flags == 1 {
sample = sample.with_loop(start, end);
}
sample.default_volume = d[32];
sample.default_pan = d[33];
sample.default_pitch = pitch as f64 / 65536.0;
self.pcm_bytes =
self.pcm_bytes.checked_add(resident).ok_or("resident audio size overflow")?;
self.current = Some(SampleMaterializer {
sample,
codec,
frames,
offset,
size,
align,
spb,
consumed: 0,
});
Ok(())
}
/// Decode at most 4096 PCM bytes or one independently bounded IMA block;
/// parse at most 64 metadata records; compile at most 64 music records.
pub fn step(&mut self) -> Result<Option<DecodedAudioBank>, String> {
if let Some(compiler) = &mut self.compiler {
return match compiler.step()? {
Some(mut bank) => {
bank.metrics = self.metrics()?;
Ok(Some(DecodedAudioBank::Music(bank)))
}
None => Ok(None),
};
}
if self.samples.len() < self.ns {
if self.current.is_none() {
self.start_sample()?;
}
let current = self.current.as_mut().unwrap();
if current.consumed < current.size {
if current.codec == 0 {
let count = (current.size - current.consumed).min(4096);
let part = bytes(&self.data, current.offset + current.consumed, count)?;
current
.sample
.data
.extend(part.as_chunks::<2>().0.iter().map(|p| i16::from_le_bytes(*p)));
current.consumed += count;
} else {
let frames = (current.frames - current.sample.frames_len()).min(current.spb);
let pcm = decode_ima_wav4(
bytes(&self.data, current.offset + current.consumed, current.align)?,
current.sample.channels,
frames,
current.align,
current.spb,
)?;
current.sample.data.extend(pcm);
current.consumed += current.align;
}
}
if current.consumed == current.size {
self.payload_end = current.offset + current.size;
let current = self.current.take().unwrap();
self.samples.push(Arc::new(current.sample));
}
return Ok(None);
}
if self.payload_end != self.data.len() {
return Err("audio trailing/unreferenced payload".into());
}
if !self.music {
let mut bank = SoundBank::new(std::mem::take(&mut self.samples));
bank.name = std::mem::take(&mut self.name);
bank.metrics = self.metrics()?;
return Ok(Some(DecodedAudioBank::Sound(bank)));
}
let inst_at = self.samples_at + self.ns * SAMPLE_BYTES;
if self.instruments.len() < self.ni {
for _ in 0..64 {
if self.instruments.len() == self.ni {
break;
}
let d = bytes(
&self.data,
inst_at + self.instruments.len() * INSTRUMENT_BYTES,
INSTRUMENT_BYTES,
)?;
if d[7] & !1 != 0 {
return Err("instrument flags".into());
}
zero(bytes(d, 22, 2)?)?;
zero(bytes(d, 43, 21)?)?;
self.instruments.push(Instrument {
id: u16le(d, 0)?,
sample: u16le(d, 2)?,
low: d[4],
high: d[5],
root: d[6],
looping: d[7] & 1 != 0,
tuning_cents: u16le(d, 8)? as i16,
pan: d[10],
gain: d[11],
attack_us: u32le(d, 12)?,
decay_us: u32le(d, 16)?,
sustain: u16le(d, 20)?,
release_us: u32le(d, 24)?,
vibrato_millihz: u32le(d, 28)?,
vibrato_cents: u16le(d, 32)?,
tremolo_depth: u16le(d, 34)?,
tremolo_millihz: u32le(d, 36)?,
send: u16le(d, 40)?,
curve: d[42],
});
}
return Ok(None);
}
if self.events.len() < self.ne {
let at = inst_at + self.ni * INSTRUMENT_BYTES;
for _ in 0..64 {
if self.events.len() == self.ne {
break;
}
let d = bytes(&self.data, at + self.events.len() * EVENT_BYTES, EVENT_BYTES)?;
self.events.push(MusicEvent {
tick: u32le(d, 0)?,
kind: d[4],
track: d[5],
flags: u16le(d, 6)?,
a: u32le(d, 8)?,
b: u32le(d, 12)?,
c: u32le(d, 16)? as i32,
d: u32le(d, 20)? as i32,
duration_frames: u32le(d, 24)?,
curve: u32le(d, 28)?,
});
}
return Ok(None);
}
self.compiler = Some(MusicCompiler::new(
std::mem::take(&mut self.name),
std::mem::take(&mut self.samples),
std::mem::take(&mut self.instruments),
std::mem::take(&mut self.events),
self.ppq,
self.tempo,
self.duration,
self.loop_tick,
self.tracks,
)?);
Ok(None)
}
fn metrics(&self) -> Result<AudioBankMetrics, String> {
Ok(AudioBankMetrics {
cartridge_bytes: self.data.len(),
pcm_bytes: self.pcm_bytes,
canonical_decoded_bytes: self
.metadata
.checked_add(self.pcm_bytes)
.ok_or("decoded audio size overflow")?,
materialization_ns: self.started.elapsed().as_nanos().min(u64::MAX as u128) as u64,
})
}
}
pub fn decode_audio_bank(data: &[u8], music: bool) -> Result<DecodedAudioBank, String> {
let mut decoder = AudioBankMaterializer::new(std::borrow::Cow::Borrowed(data), music)?;
loop {
if let Some(bank) = decoder.step()? {
return Ok(bank);
}
}
}
const STEP: [i32; 89] = [
7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66,
73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449,
494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272,
2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,
10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,
];
const INDEX: [i32; 8] = [-1, -1, -1, -1, 2, 4, 6, 8];
fn ima_code(code: u8, predictor: &mut i32, index: &mut usize) -> i16 {
let step = STEP[*index];
let mut diff = step >> 3;
if code & 1 != 0 {
diff += step >> 2;
}
if code & 2 != 0 {
diff += step >> 1;
}
if code & 4 != 0 {
diff += step;
}
*predictor = (*predictor + if code & 8 != 0 { -diff } else { diff }).clamp(-32768, 32767);
*index = (*index as i32 + INDEX[(code & 7) as usize]).clamp(0, 88) as usize;
*predictor as i16
}
pub fn decode_ima_wav4(
data: &[u8],
channels: u8,
frames: usize,
align: usize,
spb: usize,
) -> Result<Vec<i16>, String> {
let c = channels as usize;
if !(1..=2).contains(&channels)
|| align > u16::MAX as usize
|| align < 8 * c
|| !align.is_multiple_of(4 * c)
|| spb != 1 + (align - 4 * c) * 2 / c
|| !data.len().is_multiple_of(align)
|| data.len() / align != frames.div_ceil(spb)
{
return Err("invalid IMA WAVE4 block/frame layout".into());
}
let mut out = vector(frames.checked_mul(c).ok_or("IMA frame overflow")?)?;
for (block_index, block) in data.chunks_exact(align).enumerate() {
let mut pred = [0i32; 2];
let mut index = [0usize; 2];
for ch in 0..c {
pred[ch] = i16::from_le_bytes([block[ch * 4], block[ch * 4 + 1]]) as i32;
index[ch] = block[ch * 4 + 2] as usize;
if index[ch] > 88 || block[ch * 4 + 3] != 0 {
return Err("IMA predictor index/reserved".into());
}
out.push(pred[ch] as i16);
}
let remaining = (frames - block_index * spb).min(spb);
for group in 0..(spb - 1) / 8 {
let mut decoded = [[0i16; 8]; 2];
for ch in 0..c {
for n in 0..8 {
let b = block[4 * c + group * 4 * c + ch * 4 + n / 2];
let code = (b >> ((n % 2) * 4)) & 15;
if 1 + group * 8 + n >= remaining && code != 0 {
return Err("nonzero IMA padding".into());
}
decoded[ch][n] = ima_code(code, &mut pred[ch], &mut index[ch]);
}
}
for n in 0..8 {
if 1 + group * 8 + n < remaining {
for channel in decoded.iter().take(c) {
out.push(channel[n]);
}
}
}
}
}
Ok(out)
}
/// Deterministic storage encoder used by conformance tools/fixtures (never RT).
pub fn encode_ima_wav4(pcm: &[i16], channels: u8, align: usize) -> Result<Vec<u8>, String> {
let c = channels as usize;
if !(1..=2).contains(&channels)
|| !pcm.len().is_multiple_of(c)
|| align > u16::MAX as usize
|| align < 8 * c
|| !align.is_multiple_of(4 * c)
{
return Err("IMA encoder shape".into());
}
let spb = 1 + (align - 4 * c) * 2 / c;
if spb > u16::MAX as usize {
return Err("IMA block exceeds descriptor range".into());
}
let frames = pcm.len() / c;
let nblocks = frames.div_ceil(spb);
let mut out = vector(nblocks.checked_mul(align).ok_or("IMA encoded size overflow")?)?;
for block in 0..nblocks {
let first = block * spb;
let count = (frames - first).min(spb);
let mut pred = [0i32; 2];
let mut index = [0usize; 2];
for ch in 0..c {
pred[ch] = pcm[first * c + ch] as i32;
let n = (count - 1).min(32);
let sum: i32 = (1..=n)
.map(|i| {
(pcm[(first + i) * c + ch] as i32 - pcm[(first + i - 1) * c + ch] as i32).abs()
})
.sum();
let mean = if n == 0 { 0 } else { sum / n as i32 };
index[ch] = STEP.iter().position(|&s| s >= mean).unwrap_or(88);
out.extend_from_slice(&(pred[ch] as i16).to_le_bytes());
out.push(index[ch] as u8);
out.push(0);
}
for group in 0..(spb - 1) / 8 {
for ch in 0..c {
for byte in 0..4 {
let mut packed = 0;
for nibble in 0..2 {
let f = 1 + group * 8 + byte * 2 + nibble;
let code = if f >= count {
0
} else {
let diff = pcm[(first + f) * c + ch] as i32 - pred[ch];
let mut magnitude = diff.abs();
let step = STEP[index[ch]];
let mut code = if diff < 0 { 8 } else { 0 };
if magnitude >= step {
code |= 4;
magnitude -= step;
}
if magnitude >= step >> 1 {
code |= 2;
magnitude -= step >> 1;
}
if magnitude >= step >> 2 {
code |= 1;
}
code
};
ima_code(code, &mut pred[ch], &mut index[ch]);
packed |= code << (nibble * 4);
}
out.push(packed);
}
}
}
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ima_known_nibbles_and_stereo_headers() {
let block = [0, 0, 0, 0, 0x11, 0, 0, 0];
assert_eq!(decode_ima_wav4(&block, 1, 3, 8, 9).unwrap(), [0, 1, 2]);
let mut stereo = vec![0, 0, 0, 0, 100, 0, 0, 0];
stereo.extend([0u8; 8]);
let decoded = decode_ima_wav4(&stereo, 2, 9, 16, 9).unwrap();
assert_eq!(&decoded[..6], [0, 100, 0, 100, 0, 100]);
stereo[2] = 89;
assert!(decode_ima_wav4(&stereo, 2, 9, 16, 9).is_err());
}
#[test]
fn ima_partial_block_padding_round_trip_is_deterministic() {
let pcm: Vec<i16> = (0..1111)
.flat_map(|i| {
[
((i as f64 * 0.03).sin() * 12000.0) as i16,
((i as f64 * 0.02).cos() * 9000.0) as i16,
]
})
.collect();
let encoded = encode_ima_wav4(&pcm, 2, 512).unwrap();
assert_eq!(encoded, encode_ima_wav4(&pcm, 2, 512).unwrap());
let decoded = decode_ima_wav4(&encoded, 2, 1111, 512, 505).unwrap();
assert_eq!(decoded.len(), pcm.len());
assert_eq!(decoded[1010], pcm[1010]);
assert!(decode_ima_wav4(&encoded[..encoded.len() - 1], 2, 1111, 512, 505).is_err());
let error: f64 =
pcm.iter().zip(decoded).map(|(&a, b)| (a as f64 - b as f64).powi(2)).sum::<f64>()
/ pcm.len() as f64;
assert!(error.sqrt() < 400.0, "RMS error {error}");
}
}
#[cfg(test)]
pub(crate) fn test_pcm_bank(raw: &[u8], rate: u32) -> Vec<u8> {
let mut bytes = vec![0u8; 88];
bytes[..4].copy_from_slice(b"SBNK");
bytes[4] = 1;
for (at, value) in [
(8, 1),
(20, 960),
(24, 500000),
(32, u32::MAX),
(52, rate),
(56, (raw.len() / 2) as u32),
(68, 88),
(72, raw.len() as u32),
(84, 65536),
] {
bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
}
bytes[49] = 1;
bytes[80] = 255;
bytes[81] = 128;
bytes.extend_from_slice(raw);
bytes
}
#[cfg(test)]
#[path = "bank_tests.rs"]
mod bank_tests;
@@ -0,0 +1,182 @@
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());
}
@@ -0,0 +1,924 @@
//! Host-independent bounded PCM engine. Construct resources off the render lane.
use super::{
AudioCommand, AudioDelivery, AudioTransport, Channel, LoopMode, MAX_CHANNELS,
MAX_COMMANDS_PER_FRAME, SFX_CHANNELS, SFX_START,
};
use prometeu_hal::{
audio_bridge::AudioControl,
music_bank::{Instrument, MAX_MUSIC_TRACKS, MusicBank, MusicEvent},
sample::Sample,
};
use std::{
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
time::{Duration, Instant},
};
pub const RETIRED_CAPACITY: usize = 2 * (3 * MAX_COMMANDS_PER_FRAME + MAX_CHANNELS + 2);
/// Owning resources leave the real-time lane in a preallocated packet.
#[allow(dead_code)]
enum Retired {
Sample(Arc<Sample>),
Bank(Arc<MusicBank>),
Token(Arc<AtomicBool>),
}
pub struct Packet {
retired: Vec<Retired>,
pub batches: [Option<Vec<AudioCommand>>; 2],
}
impl Default for Packet {
fn default() -> Self {
Self::new()
}
}
impl Packet {
pub fn new() -> Self {
Self { retired: Vec::with_capacity(RETIRED_CAPACITY), batches: [None, None] }
}
fn push(&mut self, owner: Retired) {
assert!(self.retired.len() < RETIRED_CAPACITY, "audio retirement bound");
self.retired.push(owner);
}
fn voice(&mut self, voice: &mut Channel) {
if let Some(s) = voice.sample.take() {
self.push(Retired::Sample(s));
}
if let Some(t) = voice.alive.take() {
self.push(Retired::Token(t));
}
voice.active = false;
}
pub fn recycle(&mut self, transport: &AudioTransport) {
self.retired.clear();
for batch in &mut self.batches {
if let Some(batch) = batch.take() {
transport.recycle_commands(batch);
}
}
}
/// Service thread only: count distinct retired PCM payloads, excluding Arc overhead.
pub fn retained_pcm_bytes(&self) -> usize {
let mut seen = std::collections::HashSet::new();
let mut bytes = 0;
let mut add = |sample: &Arc<Sample>| {
if seen.insert(Arc::as_ptr(sample)) {
bytes += sample.data.capacity() * 2;
}
};
for owner in &self.retired {
match owner {
Retired::Sample(sample) => add(sample),
Retired::Bank(bank) => {
for sample in bank.samples.iter() {
add(sample);
}
}
Retired::Token(_) => {}
}
}
for batch in self.batches.iter().flatten() {
for command in batch {
match command {
AudioCommand::Play { sample, .. } => add(sample),
AudioCommand::MusicPlay { bank, .. } => {
for sample in bank.samples.iter() {
add(sample);
}
}
_ => {}
}
}
}
bytes
}
pub fn is_empty(&self) -> bool {
self.retired.is_empty() && self.batches.iter().all(Option::is_none)
}
pub fn capacity(&self) -> usize {
self.retired.capacity()
}
}
#[derive(Clone, Copy)]
struct Ramp {
from: f64,
to: f64,
start: u64,
duration: u32,
smooth: bool,
}
impl Ramp {
fn constant(value: f64) -> Self {
Self { from: value, to: value, start: 0, duration: 0, smooth: false }
}
fn at(self, now: u64) -> f64 {
if self.duration == 0 {
return self.to;
}
let elapsed = now.saturating_sub(self.start);
if elapsed >= self.duration as u64 {
return self.to;
}
let x = elapsed as f64 / self.duration as f64;
let x = if self.smooth { x * x * (3.0 - 2.0 * x) } else { x };
self.from + (self.to - self.from) * x
}
fn set(&mut self, value: f64, now: u64, duration: u32, smooth: bool) {
*self = Self { from: self.at(now), to: value, start: now, duration, smooth };
}
fn done(self, now: u64) -> bool {
now.saturating_sub(self.start) >= self.duration as u64
}
}
#[derive(Clone, Copy)]
struct SendRamp {
base: Ramp,
scale: Ramp,
}
impl Default for SendRamp {
fn default() -> Self {
Self { base: Ramp::constant(0.0), scale: Ramp::constant(1.0) }
}
}
impl SendRamp {
fn at(self, now: u64, instrument_default: f64) -> f64 {
self.base.at(now) + self.scale.at(now) * instrument_default
}
fn set(&mut self, to: f64, now: u64, frames: u32, smooth: bool) {
self.base.set(to, now, frames, smooth);
self.scale.set(0.0, now, frames, smooth);
}
}
#[derive(Clone, Copy)]
struct Track {
gain: Ramp,
pan: Ramp,
pitch: Ramp,
send: SendRamp,
vibrato: Option<(u32, f64)>,
tremolo: Option<(u32, f64)>,
}
impl Default for Track {
fn default() -> Self {
Self {
gain: Ramp::constant(1.0),
pan: Ramp::constant(128.0),
pitch: Ramp::constant(0.0),
send: SendRamp::default(),
vibrato: None,
tremolo: None,
}
}
}
struct MusicGroup {
bank: Option<Arc<MusicBank>>,
active: bool,
paused: bool,
looping: bool,
time: u128,
cursor: usize,
frame: u64,
iteration: u64,
tracks: [Track; MAX_MUSIC_TRACKS],
gain: Ramp,
stop_after_fade: bool,
}
impl Default for MusicGroup {
fn default() -> Self {
Self {
bank: None,
active: false,
paused: false,
looping: false,
time: 0,
cursor: 0,
frame: 0,
iteration: 0,
tracks: [Track::default(); MAX_MUSIC_TRACKS],
gain: Ramp::constant(1.0),
stop_after_fade: false,
}
}
}
#[derive(Clone, Copy)]
struct VoiceState {
inst: Instrument,
track: usize,
note_id: u32,
iteration: u64,
born: u64,
age: u64,
release_age: Option<u64>,
release_level: f64,
release_order: Option<u64>,
level: f64,
cached_cents: f64,
pitch_factor: f64,
glide: Ramp,
send: f64,
zone: usize,
}
impl Default for VoiceState {
fn default() -> Self {
Self {
inst: Instrument::default(),
track: 0,
note_id: 0,
iteration: 0,
born: 0,
age: 0,
release_age: None,
release_level: 0.0,
release_order: None,
level: 1.0,
cached_cents: f64::INFINITY,
pitch_factor: 1.0,
glide: Ramp::constant(0.0),
send: 0.0,
zone: 0,
}
}
}
struct Effect {
delay: Vec<[f32; 2]>,
write: usize,
history: usize,
frames: usize,
feedback: f32,
wet: f32,
dry: f32,
coefficient: f32,
filter: [f32; 2],
}
impl Effect {
fn new() -> Self {
Self {
delay: vec![[0.0; 2]; 96_000],
write: 0,
history: 0,
frames: 0,
feedback: 0.0,
wet: 0.0,
dry: 1.0,
coefficient: 1.0,
filter: [0.0; 2],
}
}
fn reset(&mut self) {
self.write = 0;
self.history = 0;
self.filter = [0.0; 2];
}
fn process(&mut self, input: [f32; 2], send: [f32; 2]) -> [f32; 2] {
if self.frames == 0 && self.coefficient == 1.0 {
self.filter = input;
return [input[0] * self.dry, input[1] * self.dry];
}
let mut out = [0.0; 2];
for c in 0..2 {
self.filter[c] += self.coefficient * (input[c] - self.filter[c]);
// Flush subnormals without denormal-sensitive host settings.
if self.filter[c].abs() < 1e-20 {
self.filter[c] = 0.0;
}
let echo = if self.frames != 0 && self.history >= self.frames {
self.delay[(self.write + 96_000 - self.frames) % 96_000][c]
} else {
0.0
};
out[c] = self.filter[c] * self.dry + echo * self.wet;
self.delay[self.write][c] = send[c] + echo * self.feedback;
if self.delay[self.write][c].abs() < 1e-20 {
self.delay[self.write][c] = 0.0;
}
}
self.write = (self.write + 1) % 96_000;
self.history = (self.history + 1).min(96_000);
out
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct AudioDiagnostics {
pub frames: u64,
pub active_voices: usize,
pub maximum_voices: usize,
pub last_render_us: u64,
pub maximum_render_us: u64,
}
pub struct AudioMixer {
pub voices: [Channel; MAX_CHANNELS],
states: [VoiceState; MAX_CHANNELS],
groups: [MusicGroup; 2],
effects: [Effect; 3],
bus: [f32; 3],
sfx_gain: f32,
exponential: [f64; 1025],
sine: [f64; 4097],
pub last_processing_time: Duration,
paused: bool,
epoch: u64,
pub diagnostics: AudioDiagnostics,
note_serial: u64,
}
impl Default for AudioMixer {
fn default() -> Self {
Self::new()
}
}
impl AudioMixer {
pub fn new() -> Self {
Self {
voices: std::array::from_fn(|_| Channel::default()),
states: [VoiceState::default(); MAX_CHANNELS],
groups: std::array::from_fn(|_| MusicGroup::default()),
effects: std::array::from_fn(|_| Effect::new()),
bus: [1.0; 3],
sfx_gain: 1.0,
exponential: std::array::from_fn(|i| {
((-6.0 * i as f64 / 1024.0).exp() - (-6.0f64).exp()) / (1.0 - (-6.0f64).exp())
}),
sine: std::array::from_fn(|i| (std::f64::consts::TAU * i as f64 / 4096.0).sin()),
last_processing_time: Duration::ZERO,
paused: false,
epoch: 0,
diagnostics: AudioDiagnostics::default(),
note_serial: 0,
}
}
pub fn prepared_bytes(&self) -> usize {
std::mem::size_of::<Self>()
+ self
.effects
.iter()
.map(|e| e.delay.capacity() * std::mem::size_of::<[f32; 2]>())
.sum::<usize>()
}
fn stop_group(&mut self, group: usize, packet: &mut Packet) {
for v in &mut self.voices[group * 12..group * 12 + 12] {
packet.voice(v);
}
if let Some(bank) = self.groups[group].bank.take() {
packet.push(Retired::Bank(bank));
}
let gain = self.groups[group].gain.at(self.groups[group].frame);
self.groups[group] = MusicGroup::default();
self.groups[group].gain = Ramp::constant(gain);
self.effects[group].reset();
}
pub fn retire_inactive(&mut self, packet: &mut Packet) {
for g in 0..2 {
if self.groups[g].bank.as_ref().is_some_and(|b| !b.alive.load(Ordering::Acquire))
|| (self.groups[g].stop_after_fade && !self.groups[g].active)
{
self.stop_group(g, packet);
}
}
for v in &mut self.voices {
if !v.active || v.alive.as_ref().is_some_and(|a| !a.load(Ordering::Acquire)) {
packet.voice(v);
}
}
}
pub 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 group in 0..2 {
self.stop_group(group, packet);
}
for voice in &mut self.voices {
packet.voice(voice);
*voice = Channel::default();
}
for group in &mut self.groups {
group.gain = Ramp::constant(1.0);
}
for effect in &mut self.effects {
effect.reset();
effect.frames = 0;
effect.feedback = 0.0;
effect.wet = 0.0;
effect.dry = 1.0;
effect.coefficient = 1.0;
}
self.bus = [1.0; 3];
self.sfx_gain = 1.0;
self.epoch = delivery.epoch;
}
packet.batches = [delivery.frame, delivery.lifecycle];
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: SFX_CHANNELS });
self.process_command(command, packet);
}
packet.batches[index] = Some(batch);
}
}
self.paused = delivery.paused;
}
/// Convenience for non-real-time signal tests/offline owners.
pub fn apply_delivery(&mut self, delivery: AudioDelivery) {
self.apply_delivery_into(delivery, &mut Packet::new());
}
pub fn fill_buffer(&mut self, buffer: &mut [f32]) {
self.mix(buffer);
self.retire_inactive(&mut Packet::new());
}
fn process_command(&mut self, command: AudioCommand, packet: &mut Packet) {
match command {
AudioCommand::Play {
sample,
alive,
voice_id,
volume,
pan,
pitch,
priority,
loop_mode,
} => {
if voice_id >= SFX_CHANNELS
|| alive.as_ref().is_some_and(|a| !a.load(Ordering::Acquire))
{
packet.push(Retired::Sample(sample));
if let Some(t) = alive {
packet.push(Retired::Token(t));
}
return;
}
let index = SFX_START + voice_id;
packet.voice(&mut self.voices[index]);
self.voices[index] = Channel {
sample: Some(sample),
alive,
active: true,
pos: 0.0,
pitch,
volume,
pan,
loop_mode,
priority,
};
self.states[index] = VoiceState::default();
}
AudioCommand::Stop { voice_id } => {
if voice_id < SFX_CHANNELS {
packet.voice(&mut self.voices[SFX_START + voice_id]);
}
}
AudioCommand::SetVolume { voice_id, volume } => {
if voice_id < SFX_CHANNELS {
self.voices[SFX_START + voice_id].volume = volume;
}
}
AudioCommand::SetPan { voice_id, pan } => {
if voice_id < SFX_CHANNELS {
self.voices[SFX_START + voice_id].pan = pan;
}
}
AudioCommand::SetPitch { voice_id, pitch } => {
if voice_id < SFX_CHANNELS {
self.voices[SFX_START + voice_id].pitch = pitch;
}
}
AudioCommand::MusicPlay { group, bank, looping } => {
if group >= 2 || !bank.alive.load(Ordering::Acquire) {
packet.push(Retired::Bank(bank));
return;
}
self.stop_group(group, packet);
self.groups[group].bank = Some(bank);
self.groups[group].active = true;
self.groups[group].looping = looping;
}
AudioCommand::Control(control) => match control {
AudioControl::GroupVolume { group, gain } => {
if group == 2 {
self.sfx_gain = gain as f32 / 255.0;
} else {
self.groups[group].gain = Ramp::constant(gain as f64 / 255.0);
self.groups[group].stop_after_fade = false;
}
}
AudioControl::MusicStop { group } => self.stop_group(group, packet),
AudioControl::MusicPause { group, paused } => self.groups[group].paused = paused,
AudioControl::MusicVolume { group, gain } => {
self.groups[group].gain = Ramp::constant(gain as f64 / 255.0);
self.groups[group].stop_after_fade = false;
}
AudioControl::MusicFade { group, gain, frames, smooth } => {
let g = &mut self.groups[group];
g.gain.set(gain as f64 / 255.0, g.frame, frames, smooth);
g.stop_after_fade = false;
}
AudioControl::Crossfade { source, target, frames, smooth } => {
if !self.groups[source].active || !self.groups[target].active {
return;
}
for (g, value) in [(source, 0.0), (target, 1.0)] {
let group = &mut self.groups[g];
group.gain.set(value, group.frame, frames, smooth);
group.stop_after_fade = g == source;
}
}
AudioControl::BusVolume { bus, gain } => self.bus[bus] = gain as f32 / 255.0,
AudioControl::SfxSend { voice, gain } => {
self.states[SFX_START + voice].send = gain as f64 / 255.0
}
AudioControl::Effect { group, cutoff_hz, delay_frames, feedback, wet, dry } => {
let effect = &mut self.effects[group];
effect.coefficient = if cutoff_hz == 0 {
1.0
} else {
(1.0 - (-std::f32::consts::TAU * cutoff_hz as f32 / 48_000.0).exp())
.clamp(0.0, 1.0)
};
if effect.frames != delay_frames as usize {
effect.reset();
}
effect.frames = delay_frames as usize;
effect.feedback = feedback;
effect.wet = wet;
effect.dry = dry;
}
},
}
}
fn release(&mut self, index: usize) {
let state = &mut self.states[index];
if state.release_age.is_none() {
let level = envelope(state, &self.exponential);
state.release_age = Some(state.age);
state.release_order = Some(self.note_serial);
self.note_serial = self.note_serial.wrapping_add(1);
state.release_level = level;
}
}
fn event(&mut self, group: usize, event: MusicEvent, zone: usize) {
let frame = self.groups[group].frame;
let track = event.track as usize;
if event.kind == 1 {
let bank = self.groups[group].bank.as_ref().unwrap();
let inst = bank.instruments[zone];
let cents = (event.c - inst.root as i32) as f64 * 100.0 + inst.tuning_cents as f64;
let range = group * 12..group * 12 + 12;
self.note_serial = self.note_serial.wrapping_add(1);
let legato = if event.flags & 1 != 0 {
range
.clone()
.filter(|&i| {
self.voices[i].active
&& self.states[i].track == track
&& self.states[i].release_age.is_none()
})
.max_by_key(|&i| (self.states[i].born, i))
} else {
None
};
if let Some(index) = legato.filter(|&i| self.states[i].zone == zone) {
let state = &mut self.states[index];
state.glide.set(cents, frame, event.duration_frames, event.curve == 1);
state.note_id = event.a;
state.born = self.note_serial;
state.iteration = self.groups[group].iteration;
self.voices[index].volume = ((inst.gain as u16 * event.d as u16 + 127) / 255) as u8;
return;
}
let index = legato.unwrap_or_else(|| {
range.clone().find(|&i| !self.voices[i].active).unwrap_or_else(|| {
range
.min_by_key(|&i| {
(
self.states[i].release_age.is_none(),
self.states[i].release_order.unwrap_or(self.states[i].born),
i,
)
})
.unwrap()
})
});
// Music samples always have an owner in this group's retained bank.
self.voices[index] = Channel {
sample: Some(bank.samples[inst.sample as usize].clone()),
alive: None,
active: true,
pos: 0.0,
pitch: 1.0,
volume: ((inst.gain as u16 * event.d as u16 + 127) / 255) as u8,
pan: inst.pan,
loop_mode: if inst.looping { LoopMode::On } else { LoopMode::Off },
priority: 0,
};
self.states[index] = VoiceState {
inst,
track,
note_id: event.a,
iteration: self.groups[group].iteration,
born: self.note_serial,
glide: Ramp::constant(cents),
send: inst.send as f64 / 65535.0,
zone,
..VoiceState::default()
};
} else if event.kind == 2 {
for index in group * 12..group * 12 + 12 {
let state = &self.states[index];
if self.voices[index].active
&& state.track == track
&& state.note_id == event.a
&& state.iteration == self.groups[group].iteration
{
self.release(index);
}
}
} else {
let t = &mut self.groups[group].tracks[track];
let smooth = event.curve == 1;
match event.kind {
4 => t.gain.set(event.c as f64 / 65535.0, frame, event.duration_frames, smooth),
5 => t.pan.set(event.c as f64, frame, event.duration_frames, smooth),
6 => t.pitch.set(event.c as f64, frame, event.duration_frames, smooth),
7 => t.vibrato = Some((event.a, event.c as f64)),
8 => t.tremolo = Some((event.a, event.c as f64 / 65535.0)),
9 => t.send.set(event.c as f64 / 65535.0, frame, event.duration_frames, smooth),
_ => {} // Tempo/instrument selection were resolved during compilation.
}
}
}
fn sequence(&mut self, group: usize) {
if !self.groups[group].active || self.groups[group].paused {
return;
}
loop {
let g = &self.groups[group];
let bank = g.bank.as_ref().unwrap();
if let Some(event) = bank.events.get(g.cursor).filter(|e| e.time <= g.time) {
let event = *event;
self.groups[group].cursor += 1;
self.event(group, event.event, event.zone);
continue;
}
if g.time < bank.end_time {
break;
}
let loop_start = bank.loop_time.unwrap_or(0);
let loop_event = if bank.loop_time.is_some() { bank.loop_event } else { 0 };
let loop_length = bank.end_time - loop_start;
for index in group * 12..group * 12 + 12 {
self.release(index);
}
let g = &mut self.groups[group];
if !g.looping {
g.active = false;
break;
}
g.time -= loop_length;
g.cursor = loop_event;
g.iteration = g.iteration.wrapping_add(1);
}
}
pub fn mix(&mut self, buffer: &mut [f32]) {
let start = Instant::now();
buffer.fill(0.0);
if self.paused {
self.last_processing_time = start.elapsed();
return;
}
for frame in buffer.as_chunks_mut::<2>().0 {
// Invalidated resources stay owned until a reclamation packet is available.
for g in 0..2 {
if self.groups[g].bank.as_ref().is_some_and(|b| !b.alive.load(Ordering::Acquire)) {
self.groups[g].active = false;
for v in &mut self.voices[g * 12..g * 12 + 12] {
v.active = false;
}
self.effects[g].reset();
}
self.sequence(g);
}
let mut dry = [[0.0f32; 2]; 3];
let mut send = [[0.0f32; 2]; 3];
let mut active = 0;
for index in 0..MAX_CHANNELS {
let group = if index < 12 {
0
} else if index < 24 {
1
} else {
2
};
if group < 2 && self.groups[group].paused {
continue;
}
let voice = &mut self.voices[index];
if !voice.active {
continue;
}
if voice.alive.as_ref().is_some_and(|a| !a.load(Ordering::Acquire)) {
voice.active = false;
continue;
}
let Some(sample) = &voice.sample else {
continue;
};
let len = sample.frames_len();
if len == 0 {
voice.active = false;
continue;
}
active += 1;
let state = &mut self.states[index];
let mut volume = voice.volume as f64 / 255.0;
let mut pan = voice.pan as f64;
let mut pitch = voice.pitch;
let mut amount = state.send;
if group < 2 {
let g = &self.groups[group];
let track = g.tracks[state.track];
state.level = envelope(state, &self.exponential);
if state.release_age.is_some() && state.level <= 0.0 {
voice.active = false;
continue;
}
let vib = track
.vibrato
.unwrap_or((state.inst.vibrato_millihz, state.inst.vibrato_cents as f64));
let trem = track.tremolo.unwrap_or((
state.inst.tremolo_millihz,
state.inst.tremolo_depth as f64 / 65535.0,
));
let cents = state.glide.at(g.frame)
+ track.pitch.at(g.frame)
+ lfo(&self.sine, state.age, vib.0) * vib.1;
if cents != state.cached_cents {
state.pitch_factor = (cents / 1200.0).exp2();
state.cached_cents = cents;
}
pitch *= state.pitch_factor;
volume *= state.level
* track.gain.at(g.frame)
* (1.0 - trem.1 * (lfo(&self.sine, state.age, trem.0) + 1.0) * 0.5);
pan = (pan + track.pan.at(g.frame) - 128.0).clamp(0.0, 255.0);
amount = track.send.at(g.frame, state.send);
state.age = state.age.wrapping_add(1);
}
let channels = sample.channels as usize;
let (loop_start, end) = match (voice.loop_mode, sample.loop_start, sample.loop_end)
{
(LoopMode::On, Some(a), Some(b)) if a < b && b as usize <= len => {
(a as f64, b as f64)
}
_ => (0.0, len as f64),
};
let pos = voice.pos as usize;
if pos >= len {
voice.active = false;
continue;
}
let next = if voice.loop_mode == LoopMode::On && (pos + 1) as f64 >= end {
loop_start as usize
} else {
pos + 1
};
let frac = (voice.pos - pos as f64) as f32;
let value = |c: usize| {
let a = sample.data[pos * channels + c] as f32 / 32768.0;
let b =
sample.data.get(next * channels + c).copied().unwrap_or(0) as f32 / 32768.0;
a + (b - a) * frac
};
if volume != 0.0 {
let normalized_pan =
if pan <= 128.0 { pan / 256.0 } else { 0.5 + (pan - 128.0) / 254.0 };
let gains = if channels == 1 {
[(1.0 - normalized_pan).sqrt(), normalized_pan.sqrt()]
} else {
[
if pan <= 128.0 { 1.0 } else { (255.0 - pan) / 127.0 },
if pan >= 128.0 { 1.0 } else { pan / 128.0 },
]
};
for c in 0..2 {
let v =
value(if channels == 1 { 0 } else { c }) * (volume * gains[c]) as f32;
dry[group][c] += v;
send[group][c] += v * amount as f32;
}
}
let ratio = sample.sample_rate as f64 / 48_000.0;
if ratio > 0.0 {
if pitch >= (end - voice.pos) / ratio {
if voice.loop_mode == LoopMode::Off {
voice.active = false;
} else {
let length = end - loop_start;
let step = (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 += pitch * ratio;
}
}
}
self.diagnostics.active_voices = active;
self.diagnostics.maximum_voices = self.diagnostics.maximum_voices.max(active);
for group in 0..3 {
if group < 2 && self.groups[group].paused {
continue;
}
let gain = if group < 2 {
self.groups[group].gain.at(self.groups[group].frame) as f32 * self.bus[0]
} else {
self.bus[1] * self.sfx_gain
};
let values = self.effects[group].process(dry[group], send[group]);
for c in 0..2 {
frame[c] += values[c] * gain;
}
}
for value in frame {
*value = (*value * self.bus[2]).clamp(-1.0, 1.0);
}
for group in &mut self.groups {
if !group.paused
&& let Some(bank) = &group.bank
{
group.frame = group.frame.wrapping_add(1);
if group.active {
group.time += bank.denominator;
}
if group.stop_after_fade && group.gain.done(group.frame) {
group.active = false;
}
}
}
// Crossfade completion silences/relinquishes notes; bank reclamation is deferred.
for g in 0..2 {
if self.groups[g].stop_after_fade && !self.groups[g].active {
for voice in &mut self.voices[g * 12..g * 12 + 12] {
voice.active = false;
}
self.effects[g].reset();
}
}
self.diagnostics.frames += 1;
}
self.last_processing_time = start.elapsed();
self.diagnostics.last_render_us = self.last_processing_time.as_micros() as u64;
self.diagnostics.maximum_render_us =
self.diagnostics.maximum_render_us.max(self.diagnostics.last_render_us);
}
}
fn lfo(table: &[f64; 4097], age: u64, millihz: u32) -> f64 {
let phase = ((age % 48_000_000) * millihz as u64 % 48_000_000) as f64 / 48_000_000.0 * 4096.0;
let index = phase as usize;
table[index] + (table[index + 1] - table[index]) * (phase - index as f64)
}
fn micros_frames(value: u32) -> u64 {
(value as u64 * 48_000).div_ceil(1_000_000)
}
fn envelope(state: &VoiceState, table: &[f64; 1025]) -> f64 {
let curve = |x: f64| {
if state.inst.curve == 0 {
1.0 - x
} else {
let p = x.clamp(0.0, 1.0) * 1024.0;
let i = (p as usize).min(1023);
table[i] + (table[i + 1] - table[i]) * (p - i as f64)
}
};
if let Some(start) = state.release_age {
let duration = micros_frames(state.inst.release_us);
let elapsed = state.age - start;
return if duration == 0 || elapsed >= duration {
0.0
} else {
state.release_level * curve(elapsed as f64 / duration as f64)
};
}
let attack = micros_frames(state.inst.attack_us);
let decay = micros_frames(state.inst.decay_us);
if state.age < attack {
return state.age as f64 / attack as f64;
}
let sustain = state.inst.sustain as f64 / 65535.0;
if state.age - attack < decay {
sustain + (1.0 - sustain) * curve((state.age - attack) as f64 / decay as f64)
} else {
sustain
}
}
#[cfg(test)]
#[path = "engine_tests.rs"]
mod tests;
@@ -0,0 +1,508 @@
use super::*;
use crate::{Audio, MemoryBanks, SoundBankPoolAccess, SoundBankPoolInstaller};
use prometeu_hal::{AudioBridge, AudioOpStatus, music_bank::AUDIO_PPQ, sound_bank::SoundBank};
fn note(tick: u32, id: u32) -> MusicEvent {
MusicEvent { tick, kind: 1, a: id, c: 60, d: 255, ..Default::default() }
}
fn bank(events: Vec<MusicEvent>, inst: Instrument, tempo: u32, duration: u32) -> Arc<MusicBank> {
Arc::new(
MusicBank::compile(
"test".into(),
vec![Arc::new(
Sample::new(48_000, vec![1024, -2048, 1024, -2048])
.with_channels(2)
.unwrap()
.with_loop(0, 2),
)],
vec![inst],
events,
AUDIO_PPQ,
tempo,
duration,
None,
1,
)
.unwrap(),
)
}
fn pair() -> (Arc<MemoryBanks>, Audio, AudioMixer) {
let banks = Arc::new(MemoryBanks::new());
(banks.clone(), Audio::new(banks), AudioMixer::new())
}
fn publish(audio: &mut Audio, mixer: &mut AudioMixer) {
audio.finish_frame();
mixer.apply_delivery(audio.transport().try_take().unwrap());
}
fn install(banks: &MemoryBanks, slot: usize, events: Vec<MusicEvent>) {
banks.install_music_bank(
slot,
bank(events, Instrument { looping: true, ..Default::default() }, 20_000, 100_000),
);
}
#[test]
fn thirty_two_stereo_voices_have_fixed_group_ownership_and_safe_clipping() {
let (banks, mut audio, mut mixer) = pair();
install(&banks, 0, (0..12).map(|n| note(0, n)).collect());
assert_eq!(audio.music_play(0, 0, true), AudioOpStatus::Ok);
assert_eq!(audio.music_play(1, 0, true), AudioOpStatus::Ok);
let sample = Arc::new(Sample::new(48_000, vec![1024, -2048]));
// Stereo uses one cursor/slot; no channel consumes a second voice.
let sample = Arc::new(
Sample::new(48_000, sample.data.clone()).with_channels(2).unwrap().with_loop(0, 1),
);
for i in 0..8 {
assert_eq!(
audio.play_sample(sample.clone(), i, 255, 128, 1.0, 0, LoopMode::On),
AudioOpStatus::Ok
);
}
assert_eq!(audio.stop(8), AudioOpStatus::VoiceInvalid);
publish(&mut audio, &mut mixer);
let mut pcm = [0.0; 2];
mixer.mix(&mut pcm);
assert_eq!(mixer.voices.iter().filter(|v| v.active).count(), 32);
assert_eq!(mixer.diagnostics.maximum_voices, 32);
assert_eq!(pcm, [1.0, -1.0]);
audio.control(AudioControl::MusicStop { group: 0 });
publish(&mut audio, &mut mixer);
assert!(mixer.voices[..12].iter().all(|v| !v.active));
assert!(mixer.voices[12..].iter().all(|v| v.active));
for i in 0..8 {
audio.stop(i);
}
publish(&mut audio, &mut mixer);
assert!(mixer.voices[12..24].iter().all(|v| v.active));
}
#[test]
fn audio_time_does_not_wait_for_frame_sync_and_buffer_partition_is_invariant() {
let (banks, mut audio, mut a) = pair();
install(&banks, 0, vec![note(17, 1)]);
audio.music_play(0, 0, false);
publish(&mut audio, &mut a);
let mut b = AudioMixer::new();
let resident = banks.music_bank_slot(0).unwrap();
b.process_command(
AudioCommand::MusicPlay { group: 0, bank: resident, looping: false },
&mut Packet::new(),
);
let mut whole = vec![0.0; 4000];
a.mix(&mut whole);
let mut pieces = vec![0.0; 4000];
for piece in pieces.chunks_mut(14) {
b.mix(piece);
}
assert_eq!(whole, pieces);
assert!(whole[..34].iter().all(|&v| v == 0.0));
assert_ne!(whole[34], 0.0);
assert_eq!(a.groups[0].frame, 2000);
}
#[test]
fn fractional_tempo_changes_and_loop_remainder_have_no_cumulative_drift() {
let events = vec![MusicEvent { tick: 2, kind: 3, a: 30_001, ..Default::default() }, note(3, 1)];
let music = bank(events, Instrument::default(), 20_001, 5);
assert_eq!(music.events[1].time, 2 * 20_001u128 * 48_000 + 30_001u128 * 48_000);
let mut mixer = AudioMixer::new();
let end = music.end_time;
let den = music.denominator;
mixer.process_command(
AudioCommand::MusicPlay { group: 0, bank: music, looping: true },
&mut Packet::new(),
);
let n = 100_000;
mixer.mix(&mut vec![0.0; n * 2]);
// The first event of a loop is evaluated before the rendered frame.
assert_eq!(mixer.groups[0].iteration, ((n - 1) as u128 * den / end) as u64);
assert_eq!(mixer.groups[0].time, n as u128 * den - mixer.groups[0].iteration as u128 * end);
}
#[test]
fn music_allocator_uses_free_then_release_then_oldest_and_stale_off_does_not_stop_reuse() {
let (banks, mut audio, mut mixer) = pair();
let mut events: Vec<_> = (0..12).map(|n| note(0, n)).collect();
events.push(MusicEvent { tick: 1, kind: 2, a: 3, ..Default::default() });
events.push(note(2, 12));
events.push(MusicEvent { tick: 3, kind: 2, a: 3, ..Default::default() });
events.push(note(4, 13));
banks.install_music_bank(
0,
bank(
events,
Instrument { looping: true, release_us: 1_000_000, ..Default::default() },
20_000,
1000,
),
);
audio.music_play(0, 0, false);
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 10]);
assert_eq!(mixer.states[3].note_id, 12);
assert_eq!(mixer.states[0].note_id, 13);
assert!(mixer.states[3].release_age.is_none());
}
#[test]
fn envelopes_have_exact_endpoints_and_note_off_releases() {
let mut state = VoiceState {
inst: Instrument {
attack_us: 1000,
decay_us: 1000,
sustain: 32768,
release_us: 1000,
curve: 0,
..Default::default()
},
..Default::default()
};
let mut mixer = AudioMixer::new();
for (age, value) in [(0, 0.0), (24, 0.5), (48, 1.0), (96, 32768.0 / 65535.0)] {
state.age = age;
assert!((envelope(&state, &mixer.exponential) - value).abs() < 1e-12);
}
state.release_age = Some(96);
state.release_level = 0.5;
for (age, value) in [(96, 0.5), (120, 0.25), (144, 0.0)] {
state.age = age;
assert!((envelope(&state, &mixer.exponential) - value).abs() < 1e-12);
}
for i in 0..10_000 {
let x = i as f64 / 10_000.0;
state.inst.curve = 1;
state.inst.release_us = 1_000_000;
state.release_age = Some(0);
state.release_level = 1.0;
state.age = (x * 48_000.0) as u64;
let x = state.age as f64 / 48_000.0;
let expected = ((-6.0 * x).exp() - (-6.0f64).exp()) / (1.0 - (-6.0f64).exp());
assert!((envelope(&state, &mixer.exponential) - expected).abs() < 1e-4);
}
let music = bank(
vec![note(0, 1), MusicEvent { tick: 2, kind: 2, a: 1, ..Default::default() }],
Instrument { looping: true, release_us: 1000, ..Default::default() },
20_000,
1000,
);
mixer.process_command(
AudioCommand::MusicPlay { group: 0, bank: music, looping: false },
&mut Packet::new(),
);
mixer.mix(&mut [0.0; 8]);
assert!(mixer.voices[0].active);
mixer.mix(&mut [0.0; 100]);
assert!(!mixer.voices[0].active);
}
#[test]
fn legato_retains_cursor_and_envelope_only_for_same_zone() {
let (banks, mut audio, mut mixer) = pair();
let mut legato = note(1, 2);
legato.flags = 1;
legato.c = 72;
legato.duration_frames = 10;
legato.curve = 1;
install(&banks, 0, vec![note(0, 1), legato]);
audio.music_play(0, 0, false);
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 8]);
assert_eq!(mixer.voices[..12].iter().filter(|v| v.active).count(), 1);
assert_eq!(mixer.states[0].age, 4);
assert!((mixer.states[0].cached_cents - 124.8).abs() < 1e-10);
assert_eq!(mixer.states[0].note_id, 2);
assert_eq!(mixer.states[0].glide.to, 1200.0);
}
#[test]
fn pause_freezes_sequence_envelopes_fade_and_effect_timeline() {
let (banks, mut audio, mut mixer) = pair();
install(&banks, 0, vec![note(0, 1)]);
audio.music_play(0, 0, true);
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 6]);
audio.control(AudioControl::MusicPause { group: 0, paused: true });
publish(&mut audio, &mut mixer);
let before = (mixer.groups[0].time, mixer.states[0].age, mixer.effects[0].write);
let mut pcm = [1.0; 200];
mixer.mix(&mut pcm);
assert_eq!(pcm, [0.0; 200]);
assert_eq!(before, (mixer.groups[0].time, mixer.states[0].age, mixer.effects[0].write));
audio.control(AudioControl::MusicPause { group: 0, paused: false });
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 2]);
assert_eq!(mixer.states[0].age, before.1 + 1);
}
#[test]
fn crossfade_stops_outgoing_group_and_target_keeps_its_sequence() {
let (banks, mut audio, mut mixer) = pair();
install(&banks, 0, vec![note(0, 1)]);
audio.music_play(0, 0, true);
audio.music_play(1, 0, true);
audio.control(AudioControl::MusicVolume { group: 1, gain: 0 });
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 10]);
audio.control(AudioControl::Crossfade { source: 0, target: 1, frames: 10, smooth: true });
publish(&mut audio, &mut mixer);
mixer.fill_buffer(&mut [0.0; 20]);
assert!(mixer.groups[0].bank.is_none());
assert_eq!(mixer.groups[1].frame, 15);
assert_eq!(mixer.groups[1].gain.at(15), 1.0);
assert!(mixer.voices[12].active);
}
#[test]
fn shared_delay_has_selective_sends_and_sfx_tails_survive_unload() {
let (banks, mut audio, mut mixer) = pair();
banks.install_sound_bank(
0,
Arc::new(SoundBank::new(vec![Arc::new(Sample::new(48_000, vec![16384]))])),
);
audio.control(AudioControl::Effect {
group: 2,
cutoff_hz: 0,
delay_frames: 2,
feedback: 0.5,
wet: 1.0,
dry: 0.0,
});
audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::Off);
audio.control(AudioControl::SfxSend { voice: 0, gain: 255 });
publish(&mut audio, &mut mixer);
let mut first = [0.0; 2];
mixer.mix(&mut first);
assert_eq!(first, [0.0; 2]);
banks.unload_audio_bank(false, 0);
let mut tail = [0.0; 8];
mixer.fill_buffer(&mut tail);
assert_eq!(tail, [0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.25, 0.0]);
}
#[test]
fn replacing_or_unloading_bank_invalidates_queued_play_and_only_its_resident_instance() {
let (banks, mut audio, mut mixer) = pair();
let source = Arc::new(SoundBank::new(vec![Arc::new(Sample::new(48_000, vec![16384; 4]))]));
banks.install_sound_bank(0, source.clone());
banks.install_sound_bank(1, source);
audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::On);
audio.play(1, 0, 1, 255, 0, 1.0, 0, LoopMode::On);
audio.finish_frame();
banks.unload_audio_bank(false, 0);
mixer.apply_delivery(audio.transport().try_take().unwrap());
assert!(!mixer.voices[24].active);
assert!(mixer.voices[25].active);
install(&banks, 0, vec![note(0, 1)]);
audio.music_play(0, 0, true);
audio.music_play(1, 0, true);
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 2]);
banks.unload_audio_bank(true, 0);
mixer.fill_buffer(&mut [0.0; 2]);
assert!(mixer.voices[..24].iter().all(|v| !v.active));
assert!(mixer.groups.iter().all(|g| g.bank.is_none()));
assert!(mixer.voices[25].active);
}
#[test]
fn stealing_respects_release_order_and_serialized_onsets_within_one_frame() {
let (banks, mut audio, mut mixer) = pair();
install(&banks, 0, (0..14).map(|n| note(0, n)).collect());
audio.music_play(0, 0, false);
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 2]);
assert_eq!(mixer.states[0].note_id, 12);
assert_eq!(mixer.states[1].note_id, 13);
let mut events: Vec<_> = (0..12).map(|n| note(0, n)).collect();
events.push(MusicEvent { tick: 1, kind: 2, a: 4, ..Default::default() });
events.push(MusicEvent { tick: 2, kind: 2, a: 2, ..Default::default() });
events.push(note(3, 20));
banks.install_music_bank(
0,
bank(
events,
Instrument { looping: true, release_us: 1_000_000, ..Default::default() },
20000,
1000,
),
);
audio.music_play(0, 0, false);
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 8]);
assert_eq!(mixer.states[4].note_id, 20);
assert!(mixer.states[2].release_age.is_some());
}
#[test]
fn incompatible_legato_retriggers_the_same_voice_with_no_hidden_polyphony() {
let sample = Arc::new(Sample::new(48000, vec![1000; 8]).with_loop(0, 8));
let mut legato = note(2, 2);
legato.flags = 1;
legato.c = 72;
let music = MusicBank::compile(
"zones".into(),
vec![sample.clone(), sample],
vec![
Instrument { low: 0, high: 63, looping: true, ..Default::default() },
Instrument { low: 64, high: 127, sample: 1, looping: true, ..Default::default() },
],
vec![note(0, 1), legato],
960,
20000,
1000,
None,
1,
)
.unwrap();
let mut mixer = AudioMixer::new();
mixer.process_command(
AudioCommand::MusicPlay { group: 0, bank: Arc::new(music), looping: false },
&mut Packet::new(),
);
mixer.mix(&mut [0.0; 6]);
assert_eq!(mixer.voices[..12].iter().filter(|v| v.active).count(), 1);
assert_eq!(mixer.states[0].age, 1);
assert_eq!(mixer.states[0].zone, 1);
assert_eq!(mixer.states[0].note_id, 2);
}
#[test]
fn parameter_ramps_lfos_and_send_override_use_the_current_audio_value() {
let mut send = SendRamp::default();
assert_eq!(send.at(0, 0.8), 0.8);
send.set(0.0, 0, 100, false);
assert_eq!(send.at(50, 0.8), 0.4);
send.set(1.0, 50, 100, false);
assert_eq!(send.at(50, 0.8), 0.4);
assert!((send.at(100, 0.8) - 0.7).abs() < 1e-12);
assert_eq!(send.at(150, 0.8), 1.0);
let events = vec![
note(0, 1),
MusicEvent { kind: 4, c: 0, duration_frames: 480, ..Default::default() },
MusicEvent { kind: 5, c: 255, duration_frames: 480, ..Default::default() },
MusicEvent { kind: 6, c: 1200, duration_frames: 480, ..Default::default() },
MusicEvent { kind: 7, a: 100000, c: 1200, ..Default::default() },
MusicEvent { kind: 8, a: 100000, c: 65535, ..Default::default() },
];
let mut mixer = AudioMixer::new();
mixer.process_command(
AudioCommand::MusicPlay {
group: 0,
bank: bank(events, Instrument { looping: true, ..Default::default() }, 20000, 1000),
looping: false,
},
&mut Packet::new(),
);
let mut pcm = [0.0; 962];
mixer.mix(&mut pcm);
assert_eq!(&pcm[..2], &[1.0 / 64.0, -1.0 / 32.0]);
assert!(pcm[240].abs() < 1e-8 && pcm[241].abs() < 1e-8);
assert_eq!(&pcm[960..], &[0.0, 0.0]);
assert!(mixer.voices[0].active);
assert_eq!(mixer.groups[0].tracks[0].gain.at(240), 0.5);
assert_eq!(mixer.groups[0].tracks[0].pan.at(240), 191.5);
assert_eq!(mixer.groups[0].tracks[0].pitch.at(240), 600.0);
let mut ramp = Ramp::constant(0.0);
ramp.set(1.0, 0, 100, true);
assert_eq!(ramp.at(0), 0.0);
assert_eq!(ramp.at(50), 0.5);
assert_eq!(ramp.at(100), 1.0);
let endpoint = 1.0 / 65535.0;
ramp.set(endpoint, 100, 100, false);
assert_eq!(ramp.at(200), endpoint);
assert_eq!(ramp.at(1000), endpoint);
}
#[test]
fn music_sfx_and_master_gains_remain_independent_of_group_gain() {
let (_, mut audio, mut mixer) = pair();
audio.play_sample(
Arc::new(Sample::new(48000, vec![16384; 4])),
0,
255,
0,
1.0,
0,
LoopMode::On,
);
audio.control(AudioControl::GroupVolume { group: 2, gain: 128 });
audio.control(AudioControl::BusVolume { bus: 1, gain: 128 });
audio.control(AudioControl::BusVolume { bus: 2, gain: 128 });
publish(&mut audio, &mut mixer);
let mut pcm = [0.0; 2];
mixer.mix(&mut pcm);
assert!((pcm[0] - 0.5 * (128.0f32 / 255.0).powi(3)).abs() < 1e-7);
assert_eq!(pcm[1], 0.0);
}
#[test]
fn invalidating_one_music_slot_clears_only_its_effect_history() {
let (banks, mut audio, mut mixer) = pair();
install(&banks, 0, vec![note(0, 1)]);
install(&banks, 1, vec![note(0, 1)]);
audio.music_play(0, 0, true);
audio.music_play(1, 1, true);
for group in 0..2 {
audio.control(AudioControl::Effect {
group,
cutoff_hz: 6000,
delay_frames: 48,
feedback: 0.5,
wet: 0.3,
dry: 0.7,
});
}
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 100]);
banks.unload_audio_bank(true, 0);
mixer.retire_inactive(&mut Packet::new());
assert_eq!(mixer.effects[0].history, 0);
assert_eq!(mixer.effects[1].history, 50);
assert!(mixer.voices[12].active);
}
#[test]
fn crossfade_with_absent_target_does_not_silence_the_active_source() {
let (banks, mut audio, mut mixer) = pair();
install(&banks, 0, vec![note(0, 1)]);
audio.music_play(0, 0, true);
audio.control(AudioControl::Crossfade { source: 0, target: 1, frames: 0, smooth: false });
publish(&mut audio, &mut mixer);
mixer.mix(&mut [0.0; 2]);
assert!(mixer.groups[0].active);
assert_eq!(mixer.groups[0].gain.at(1), 1.0);
}
#[test]
fn resident_memory_diagnostics_deduplicate_shared_pcm_across_all_slots() {
let banks = MemoryBanks::new();
let sample = Arc::new(Sample::new(48000, vec![1, 2, 3, 4]));
let source = Arc::new(SoundBank::new(vec![sample]));
for slot in 0..16 {
banks.install_sound_bank(slot, source.clone());
banks.install_music_bank(slot, bank(vec![note(0, 1)], Instrument::default(), 20000, 1000));
}
let snapshot = banks.audio_memory();
assert_eq!(snapshot.banks.len(), 32);
assert_eq!(snapshot.unique_pcm_bytes, 8 + 16 * 8);
assert!(snapshot.metadata_bytes > 0);
assert_eq!(
snapshot.total_accounted_bytes,
snapshot.allocated_pcm_bytes + snapshot.metadata_bytes
);
}
#[test]
fn group_configuration_survives_play_stop_and_replacement_but_not_session_reset() {
let (banks, mut audio, mut mixer) = pair();
install(&banks, 0, vec![note(0, 1)]);
audio.control(AudioControl::MusicVolume { group: 0, gain: 0 });
audio.music_play(0, 0, true);
publish(&mut audio, &mut mixer);
let mut pcm = [1.0; 2];
mixer.mix(&mut pcm);
assert_eq!(pcm, [0.0; 2]);
assert_eq!(mixer.groups[0].gain.at(0), 0.0);
audio.control(AudioControl::Effect {
group: 0,
cutoff_hz: 1000,
delay_frames: 48,
feedback: 0.5,
wet: 0.5,
dry: 0.5,
});
audio.control(AudioControl::MusicStop { group: 0 });
audio.music_play(0, 0, true);
publish(&mut audio, &mut mixer);
assert_eq!(mixer.groups[0].gain.at(0), 0.0);
assert_eq!(mixer.effects[0].frames, 48);
audio.reset();
mixer.apply_delivery(audio.transport().try_take().unwrap());
assert_eq!(mixer.groups[0].gain.at(0), 1.0);
assert_eq!(mixer.effects[0].frames, 0);
assert_eq!(mixer.effects[0].coefficient, 1.0);
assert_eq!(mixer.effects[0].wet, 0.0);
assert_eq!(mixer.effects[0].dry, 1.0);
}
@@ -123,6 +123,7 @@ mod reuse_tests {
let allocation = batch.as_ptr();
batch.push(AudioCommand::Play {
sample,
alive: None,
voice_id: 0,
volume: 255,
pan: 0,
@@ -13,6 +13,7 @@ mod touch;
mod wall_clock;
pub use crate::asset::AssetManager;
pub use crate::audio::bank_format;
pub use crate::audio::{
Audio, AudioCommand, AudioDelivery, AudioTransport, Channel, MAX_CHANNELS,
MAX_COMMANDS_PER_FRAME, OUTPUT_SAMPLE_RATE,
@@ -29,3 +30,5 @@ pub use crate::test_platform::TestPlatform;
pub use crate::wall_clock::ControlledWallClock;
pub mod memcard;
pub use crate::audio::{SFX_CHANNELS, SFX_START, engine};
@@ -7,6 +7,7 @@
//! the render read surface.
use prometeu_hal::glyph_bank::GlyphBank;
use prometeu_hal::music_bank::MusicBank;
use prometeu_hal::render_resources::RenderResourceAccess as HalRenderResourceAccess;
use prometeu_hal::scene_bank::SceneBank;
use prometeu_hal::sound_bank::SoundBank;
@@ -30,6 +31,7 @@ pub trait GlyphBankPoolInstaller: Send + Sync {
/// Non-generic interface for peripherals to access sound banks.
pub trait SoundBankPoolAccess: Send + Sync {
fn music_bank_slot(&self, slot: usize) -> Option<Arc<MusicBank>>;
/// Returns a reference to the resident SoundBank in the specified slot, if any.
fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>>;
/// Returns the total number of slots available in this bank.
@@ -38,6 +40,9 @@ pub trait SoundBankPoolAccess: Send + Sync {
/// Non-generic interface for the AssetManager to install sound banks.
pub trait SoundBankPoolInstaller: Send + Sync {
fn install_music_bank(&self, slot: usize, bank: Arc<MusicBank>);
fn clear_music_banks(&self);
fn unload_audio_bank(&self, music: bool, slot: usize);
/// Atomically swaps the resident SoundBank in the specified slot.
fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>);
/// Clears all resident SoundBank slots.
@@ -68,6 +73,7 @@ pub trait SceneBankPoolInstaller: Send + Sync {
pub struct MemoryBanks {
glyph_bank_pool: Arc<RwLock<[Option<Arc<GlyphBank>>; 16]>>,
sound_bank_pool: Arc<RwLock<[Option<Arc<SoundBank>>; 16]>>,
music_bank_pool: Arc<RwLock<[Option<Arc<MusicBank>>; 16]>>,
scene_bank_pool: Arc<RwLock<[Option<Arc<SceneBank>>; 16]>>,
}
@@ -83,6 +89,7 @@ impl MemoryBanks {
Self {
glyph_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
sound_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
music_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
scene_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
}
}
@@ -113,6 +120,9 @@ impl GlyphBankPoolInstaller for MemoryBanks {
}
impl SoundBankPoolAccess for MemoryBanks {
fn music_bank_slot(&self, slot: usize) -> Option<Arc<MusicBank>> {
self.music_bank_pool.read().unwrap().get(slot).and_then(Clone::clone)
}
fn sound_bank_slot(&self, slot: usize) -> Option<Arc<SoundBank>> {
let pool = self.sound_bank_pool.read().unwrap();
pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone))
@@ -124,15 +134,61 @@ impl SoundBankPoolAccess for MemoryBanks {
}
impl SoundBankPoolInstaller for MemoryBanks {
fn install_music_bank(&self, slot: usize, bank: Arc<MusicBank>) {
if slot >= 16 {
return;
}
let prepared = Arc::new(bank.resident_copy());
let mut pool = self.music_bank_pool.write().unwrap();
if let Some(target) = pool.get_mut(slot) {
if let Some(old) = target.take() {
old.invalidate();
}
*target = Some(prepared);
}
}
fn clear_music_banks(&self) {
let mut pool = self.music_bank_pool.write().unwrap();
for bank in pool.iter_mut() {
if let Some(old) = bank.take() {
old.invalidate();
}
}
}
fn unload_audio_bank(&self, music: bool, slot: usize) {
if music {
if let Some(bank) =
self.music_bank_pool.write().unwrap().get_mut(slot).and_then(Option::take)
{
bank.invalidate();
}
} else if let Some(bank) =
self.sound_bank_pool.write().unwrap().get_mut(slot).and_then(Option::take)
{
bank.invalidate();
}
}
fn install_sound_bank(&self, slot: usize, bank: Arc<SoundBank>) {
if slot >= 16 {
return;
}
let prepared = Arc::new(bank.resident_copy());
let mut pool = self.sound_bank_pool.write().unwrap();
if slot < 16 {
pool[slot] = Some(bank);
if let Some(old) = pool[slot].take() {
old.invalidate();
}
pool[slot] = Some(prepared);
}
}
fn clear_sound_banks(&self) {
self.sound_bank_pool.write().unwrap().fill(None);
let mut pool = self.sound_bank_pool.write().unwrap();
for bank in pool.iter_mut() {
if let Some(old) = bank.take() {
old.invalidate();
}
}
}
}
@@ -246,3 +302,84 @@ mod tests {
assert_eq!(HalRenderResourceAccess::scene_bank_count(&banks), 16);
}
}
/// Owner-thread diagnostics: canonical bank costs and unique PCM allocation costs
/// are separate, so loading the same asset in two slots does not double-count RAM.
#[derive(Debug, Clone)]
pub struct AudioSlotMemory {
pub music: bool,
pub slot: usize,
pub name: String,
pub metrics: prometeu_hal::sound_bank::AudioBankMetrics,
}
#[derive(Debug, Default)]
pub struct AudioMemorySnapshot {
pub banks: Vec<AudioSlotMemory>,
pub unique_pcm_bytes: usize,
pub allocated_pcm_bytes: usize,
/// Resident Rust structs/vector/string capacities; excludes allocator/Arc headers and host caches.
pub metadata_bytes: usize,
pub total_accounted_bytes: usize,
}
impl MemoryBanks {
pub fn audio_memory(&self) -> AudioMemorySnapshot {
let mut snapshot = AudioMemorySnapshot::default();
let mut seen = std::collections::HashSet::new();
let mut metadata = 0usize;
let mut vectors = std::collections::HashSet::new();
let mut add =
|music, slot, name: String, metrics, samples: &[Arc<prometeu_hal::sample::Sample>]| {
for sample in samples {
if seen.insert(Arc::as_ptr(sample)) {
metadata += std::mem::size_of::<prometeu_hal::sample::Sample>();
snapshot.unique_pcm_bytes += sample.data.len() * 2;
snapshot.allocated_pcm_bytes += sample.data.capacity() * 2;
}
}
snapshot.banks.push(AudioSlotMemory { music, slot, name, metrics });
};
for (slot, bank) in self.sound_bank_pool.read().unwrap().iter().enumerate() {
if let Some(b) = bank {
add(false, slot, b.name.clone(), b.metrics, &b.samples);
snapshot.metadata_bytes += std::mem::size_of::<SoundBank>()
+ b.name.capacity()
+ std::mem::size_of::<std::sync::atomic::AtomicBool>();
if vectors.insert(Arc::as_ptr(&b.samples) as usize) {
snapshot.metadata_bytes += std::mem::size_of::<
Vec<Arc<prometeu_hal::sample::Sample>>,
>() + b.samples.capacity()
* std::mem::size_of::<Arc<prometeu_hal::sample::Sample>>();
}
}
}
for (slot, bank) in self.music_bank_pool.read().unwrap().iter().enumerate() {
if let Some(b) = bank {
add(true, slot, b.name.clone(), b.metrics, &b.samples);
snapshot.metadata_bytes += std::mem::size_of::<MusicBank>()
+ b.name.capacity()
+ std::mem::size_of::<std::sync::atomic::AtomicBool>();
if vectors.insert(Arc::as_ptr(&b.samples) as usize) {
snapshot.metadata_bytes += std::mem::size_of::<
Vec<Arc<prometeu_hal::sample::Sample>>,
>() + b.samples.capacity()
* std::mem::size_of::<Arc<prometeu_hal::sample::Sample>>();
}
if vectors.insert(Arc::as_ptr(&b.instruments) as usize) {
snapshot.metadata_bytes += std::mem::size_of::<
Vec<prometeu_hal::music_bank::Instrument>,
>() + b.instruments.capacity()
* std::mem::size_of::<prometeu_hal::music_bank::Instrument>();
}
if vectors.insert(Arc::as_ptr(&b.events) as usize) {
snapshot.metadata_bytes += std::mem::size_of::<
Vec<prometeu_hal::music_bank::TimedMusicEvent>,
>() + b.events.capacity()
* std::mem::size_of::<prometeu_hal::music_bank::TimedMusicEvent>();
}
}
}
snapshot.metadata_bytes += metadata;
snapshot.total_accounted_bytes = snapshot.allocated_pcm_bytes + snapshot.metadata_bytes;
snapshot
}
}
+15 -11
View File
@@ -8,6 +8,7 @@ pub type AssetId = i32;
pub enum BankType {
GLYPH,
SOUNDS,
MUSIC,
SCENE,
// TILEMAPS,
// BLOBS,
@@ -41,9 +42,8 @@ pub struct GlyphBankMetadata {
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SoundBankMetadata {
pub sample_rate: u32,
pub channels: u32,
pub struct AudioBankMetadata {
pub version: u16,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
@@ -73,15 +73,16 @@ impl AssetEntry {
.map_err(|e| format!("Invalid GLYPH metadata for asset {}: {}", self.asset_id, e))
}
pub fn metadata_as_sound_bank(&self) -> Result<SoundBankMetadata, String> {
if self.bank_type != BankType::SOUNDS {
return Err(format!(
"Asset {} is not a SOUNDS bank (type: {:?})",
self.asset_id, self.bank_type
));
pub fn metadata_as_audio_bank(&self) -> Result<AudioBankMetadata, String> {
if !matches!(self.bank_type, BankType::SOUNDS | BankType::MUSIC) {
return Err("asset is not an audio bank".into());
}
serde_json::from_value(self.metadata.clone())
.map_err(|e| format!("Invalid SOUNDS metadata for asset {}: {}", self.asset_id, e))
let metadata: AudioBankMetadata = serde_json::from_value(self.metadata.clone())
.map_err(|e| format!("Invalid audio metadata: {e}"))?;
if metadata.version != 1 {
return Err("unsupported audio metadata version".into());
}
Ok(metadata)
}
pub fn metadata_as_scene_bank(&self) -> Result<SceneBankMetadata, String> {
@@ -189,6 +190,9 @@ pub struct SlotRef {
}
impl SlotRef {
pub fn music(index: usize) -> Self {
Self { asset_type: BankType::MUSIC, index }
}
pub fn gfx(index: usize) -> Self {
Self { asset_type: BankType::GLYPH, index }
}
@@ -6,6 +6,9 @@ use crate::asset::{
use crate::cartridge::AssetsPayloadSource;
pub trait AssetBridge {
fn unload_audio(&self, _music: bool, _slot: usize) -> AssetOpStatus {
AssetOpStatus::InvalidState
}
/// Bind before cartridge preload/loading. Hosts supporting memcard must use
/// this same lane for assets; an unsupported bridge refuses the fast profile.
fn bind_background_work(
@@ -20,6 +20,20 @@ pub enum AudioOpStatus {
CommandLimit = 7,
}
/// High-level commands are staged with the ordinary frame/lifecycle batch.
#[derive(Debug, Clone, Copy)]
pub enum AudioControl {
GroupVolume { group: usize, gain: u8 },
MusicStop { group: usize },
MusicPause { group: usize, paused: bool },
MusicVolume { group: usize, gain: u8 },
MusicFade { group: usize, gain: u8, frames: u32, smooth: bool },
Crossfade { source: usize, target: usize, frames: u32, smooth: bool },
BusVolume { bus: usize, gain: u8 },
Effect { group: usize, cutoff_hz: u32, delay_frames: u32, feedback: f32, wet: f32, dry: f32 },
SfxSend { voice: usize, gain: u8 },
}
pub trait AudioBridge {
#[allow(clippy::too_many_arguments)]
fn play(
@@ -44,6 +58,8 @@ pub trait AudioBridge {
priority: u8,
loop_mode: LoopMode,
) -> AudioOpStatus;
fn music_play(&mut self, group: usize, bank: usize, looping: bool) -> AudioOpStatus;
fn control(&mut self, control: AudioControl) -> AudioOpStatus;
fn stop(&mut self, voice_id: usize) -> AudioOpStatus;
fn set_volume(&mut self, voice_id: usize, volume: u8) -> AudioOpStatus;
fn set_pan(&mut self, voice_id: usize, pan: u8) -> AudioOpStatus;
+1
View File
@@ -18,6 +18,7 @@ pub mod host_return;
pub mod input_signals;
pub mod log;
pub mod memcard;
pub mod music_bank;
pub mod native_helpers;
pub mod native_interface;
pub mod owned_frame;
@@ -0,0 +1,376 @@
//! Resident, self-contained music data. Construction/compilation is off the audio lane.
use crate::{sample::Sample, sound_bank::AudioBankMetrics};
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
pub const AUDIO_PPQ: u32 = 960;
pub const AUDIO_RATE: u32 = 48_000;
pub const MAX_MUSIC_TRACKS: usize = 256;
pub const MAX_EVENTS_PER_FRAME: usize = 64;
#[derive(Debug, Clone, Copy)]
pub struct Instrument {
pub id: u16,
pub sample: u16,
pub low: u8,
pub high: u8,
pub root: u8,
pub looping: bool,
pub tuning_cents: i16,
pub pan: u8,
pub gain: u8,
pub attack_us: u32,
pub decay_us: u32,
pub sustain: u16,
pub release_us: u32,
pub vibrato_millihz: u32,
pub vibrato_cents: u16,
pub tremolo_depth: u16,
pub tremolo_millihz: u32,
pub send: u16,
pub curve: u8,
}
impl Default for Instrument {
fn default() -> Self {
Self {
id: 0,
sample: 0,
low: 0,
high: 127,
root: 60,
looping: false,
tuning_cents: 0,
pan: 128,
gain: 255,
attack_us: 0,
decay_us: 0,
sustain: u16::MAX,
release_us: 0,
vibrato_millihz: 0,
vibrato_cents: 0,
tremolo_depth: 0,
tremolo_millihz: 0,
send: 0,
curve: 1,
}
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct MusicEvent {
pub tick: u32,
pub kind: u8,
pub track: u8,
pub flags: u16,
pub a: u32,
pub b: u32,
pub c: i32,
pub d: i32,
pub duration_frames: u32,
pub curve: u32,
}
#[derive(Debug, Clone, Copy)]
pub struct TimedMusicEvent {
pub time: u128,
pub event: MusicEvent,
pub zone: usize,
}
#[derive(Debug)]
pub struct MusicBank {
pub name: String,
pub samples: Arc<Vec<Arc<Sample>>>,
pub instruments: Arc<Vec<Instrument>>,
pub events: Arc<Vec<TimedMusicEvent>>,
pub denominator: u128,
pub end_time: u128,
pub loop_time: Option<u128>,
pub loop_event: usize,
pub tracks: usize,
pub alive: Arc<AtomicBool>,
pub metrics: AudioBankMetrics,
}
impl MusicBank {
#[allow(clippy::too_many_arguments)]
pub fn compile(
name: String,
samples: Vec<Arc<Sample>>,
instruments: Vec<Instrument>,
events: Vec<MusicEvent>,
ppq: u32,
tempo: u32,
duration: u32,
loop_tick: Option<u32>,
tracks: usize,
) -> Result<Self, String> {
let mut compiler = MusicCompiler::new(
name,
samples,
instruments,
events,
ppq,
tempo,
duration,
loop_tick,
tracks,
)?;
loop {
if let Some(bank) = compiler.step()? {
return Ok(bank);
}
}
}
pub fn invalidate(&self) {
self.alive.store(false, Ordering::Release);
}
pub fn resident_copy(&self) -> Self {
Self {
name: self.name.clone(),
samples: self.samples.clone(),
instruments: self.instruments.clone(),
events: self.events.clone(),
denominator: self.denominator,
end_time: self.end_time,
loop_time: self.loop_time,
loop_event: self.loop_event,
tracks: self.tracks,
alive: Arc::new(AtomicBool::new(true)),
metrics: self.metrics,
}
}
}
/// Cooperative off-lane validation/clock compilation. At most 64 zones/events
/// per step; lookup is logarithmic and the loop-seam check is bounded by 65.
pub struct MusicCompiler {
name: Option<String>,
samples: Vec<Arc<Sample>>,
instruments: Vec<Instrument>,
source: std::vec::IntoIter<MusicEvent>,
compiled: Vec<TimedMusicEvent>,
zones: std::collections::BTreeMap<(u16, u8), usize>,
zone_cursor: usize,
ppq: u32,
tempo: u32,
duration: u32,
loop_tick: Option<u32>,
tracks: usize,
tick: u32,
time: u128,
loop_time: Option<u128>,
selected: [u32; MAX_MUSIC_TRACKS],
}
impl MusicCompiler {
#[allow(clippy::too_many_arguments)]
pub fn new(
name: String,
samples: Vec<Arc<Sample>>,
instruments: Vec<Instrument>,
events: Vec<MusicEvent>,
ppq: u32,
tempo: u32,
duration: u32,
loop_tick: Option<u32>,
tracks: usize,
) -> Result<Self, String> {
if ppq != AUDIO_PPQ
|| tempo == 0
|| duration == 0
|| tracks == 0
|| tracks > MAX_MUSIC_TRACKS
|| loop_tick.is_some_and(|t| t >= duration)
{
return Err("invalid music clock/tracks/loop".into());
}
let mut compiled = Vec::new();
compiled.try_reserve_exact(events.len()).map_err(|_| "music allocation failed")?;
Ok(Self {
name: Some(name),
samples,
instruments,
source: events.into_iter(),
compiled,
zones: std::collections::BTreeMap::new(),
zone_cursor: 0,
ppq,
tempo,
duration,
loop_tick,
tracks,
tick: 0,
time: 0,
loop_time: None,
selected: [u32::MAX; MAX_MUSIC_TRACKS],
})
}
pub fn step(&mut self) -> Result<Option<MusicBank>, String> {
let denominator = self.ppq as u128 * 1_000_000;
for _ in 0..64 {
if self.zone_cursor < self.instruments.len() {
let i = self.zone_cursor;
let inst = self.instruments[i];
if inst.low > inst.high
|| inst.high > 127
|| inst.root > 127
|| inst.curve > 1
|| inst.sample as usize >= self.samples.len()
|| inst.vibrato_millihz > 100_000
|| inst.tremolo_millihz > 100_000
|| inst.vibrato_cents > 2400
{
return Err("invalid instrument zone/modulation".into());
}
if inst.looping && self.samples[inst.sample as usize].loop_start.is_none() {
return Err("instrument requires a sample loop".into());
}
if self
.zones
.range((inst.id, 0)..=(inst.id, inst.high))
.next_back()
.is_some_and(|(_, j)| self.instruments[*j].high >= inst.low)
{
return Err("overlapping instrument zones".into());
}
self.zones.insert((inst.id, inst.low), i);
self.zone_cursor += 1;
continue;
}
let Some(event) = self.source.next() else {
return self.finish(denominator).map(Some);
};
if event.tick < self.tick
|| event.tick > self.duration
|| event.track as usize >= self.tracks
|| event.curve > 1
|| event.flags & !1 != 0
|| !(1..=10).contains(&event.kind)
{
return Err("invalid music event ordering/shape".into());
}
if let Some(t) = self.loop_tick.filter(|&t| t >= self.tick && t <= event.tick)
&& self.loop_time.is_none()
{
self.loop_time = Some(
self.time + (t - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128,
);
}
self.time += (event.tick - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128;
self.tick = event.tick;
let mut zone = 0;
match event.kind {
1 => {
if !(0..=127).contains(&event.c) || !(0..=255).contains(&event.d) {
return Err("invalid note/velocity".into());
}
let id = if event.b == u32::MAX {
self.selected[event.track as usize]
} else {
event.b
};
if id > u16::MAX as u32 {
return Err("note has no bank-local instrument".into());
}
zone = *self
.zones
.range((id as u16, 0)..=(id as u16, event.c as u8))
.next_back()
.map(|(_, i)| i)
.filter(|&&i| self.instruments[i].high as i32 >= event.c)
.ok_or("note has no bank-local instrument zone")?;
}
3 => {
if event.a == 0 {
return Err("zero tempo".into());
}
self.tempo = event.a;
}
4 | 9 => {
if !(0..=65535).contains(&event.c) {
return Err("invalid gain/send".into());
}
}
5 => {
if !(0..=255).contains(&event.c) {
return Err("invalid pan".into());
}
}
6 => {
if !(-9600..=9600).contains(&event.c) {
return Err("invalid pitch bend".into());
}
}
7 | 8 => {
if event.a > 100_000
|| event.c < 0
|| event.c > if event.kind == 7 { 2400 } else { 65535 }
{
return Err("invalid modulation".into());
}
}
10 => {
if event.a > u16::MAX as u32
|| self
.zones
.range((event.a as u16, 0)..=(event.a as u16, 127))
.next()
.is_none()
{
return Err("unknown instrument".into());
}
self.selected[event.track as usize] = event.a;
}
_ => {}
}
if self.compiled.len() >= MAX_EVENTS_PER_FRAME
&& self.time - self.compiled[self.compiled.len() - MAX_EVENTS_PER_FRAME].time
< denominator
{
return Err("music event density exceeds real-time bound".into());
}
self.compiled.push(TimedMusicEvent { time: self.time, event, zone });
}
Ok(None)
}
fn finish(&mut self, denominator: u128) -> Result<MusicBank, String> {
if let Some(t) = self.loop_tick.filter(|&t| t >= self.tick)
&& self.loop_time.is_none()
{
self.loop_time =
Some(self.time + (t - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128);
}
let end_time = self.time
+ (self.duration - self.tick) as u128 * self.tempo as u128 * AUDIO_RATE as u128;
if end_time < denominator || self.loop_time.is_some_and(|t| end_time - t < denominator) {
return Err("music/loop shorter than one output frame".into());
}
let loop_event =
self.loop_time.map_or(0, |t| self.compiled.partition_point(|e| e.time < t));
let length = end_time - self.loop_time.unwrap_or(0);
let slice = &self.compiled[loop_event..];
for i in 0..slice.len().min(MAX_EVENTS_PER_FRAME + 1) {
let tail =
slice.len().saturating_sub(MAX_EVENTS_PER_FRAME - i.min(MAX_EVENTS_PER_FRAME));
if tail < slice.len()
&& slice.len() - tail + i + 1 > MAX_EVENTS_PER_FRAME
&& slice[i].time + length - slice[tail].time < denominator
{
return Err("music loop seam event density".into());
}
}
let pcm_bytes = self.samples.iter().map(|s| s.data.len() * 2).sum();
Ok(MusicBank {
name: self.name.take().ok_or("compiler already complete")?,
samples: Arc::new(std::mem::take(&mut self.samples)),
instruments: Arc::new(std::mem::take(&mut self.instruments)),
events: Arc::new(std::mem::take(&mut self.compiled)),
denominator,
end_time,
loop_time: self.loop_time,
loop_event,
tracks: self.tracks,
alive: Arc::new(AtomicBool::new(true)),
metrics: AudioBankMetrics { pcm_bytes, ..Default::default() },
})
}
}
+24 -2
View File
@@ -1,13 +1,27 @@
#[derive(Debug)]
pub struct Sample {
pub sample_rate: u32,
pub channels: u8,
pub data: Vec<i16>,
pub loop_start: Option<u32>,
pub loop_end: Option<u32>,
pub default_volume: u8,
pub default_pan: u8,
pub default_pitch: f64,
}
impl Sample {
pub fn new(sample_rate: u32, data: Vec<i16>) -> Self {
Self { sample_rate, data, loop_start: None, loop_end: None }
Self {
sample_rate,
channels: 1,
data,
loop_start: None,
loop_end: None,
default_volume: 255,
default_pan: 128,
default_pitch: 1.0,
}
}
pub fn with_loop(mut self, start: u32, end: u32) -> Self {
@@ -17,6 +31,14 @@ impl Sample {
}
pub fn frames_len(&self) -> usize {
self.data.len()
self.data.len() / self.channels.max(1) as usize
}
pub fn with_channels(mut self, channels: u8) -> Result<Self, String> {
if !(1..=2).contains(&channels) || !self.data.len().is_multiple_of(channels as usize) {
return Err("audio sample channels/frame count".into());
}
self.channels = channels;
Ok(self)
}
}
+33 -2
View File
@@ -1,16 +1,47 @@
use crate::sample::Sample;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
#[derive(Debug, Clone, Copy, Default)]
pub struct AudioBankMetrics {
pub cartridge_bytes: usize,
pub pcm_bytes: usize,
pub canonical_decoded_bytes: usize,
pub materialization_ns: u64,
}
/// A container for audio assets.
///
/// A SoundBank stores multiple audio samples that can be played by the
/// audio subsystem.
#[derive(Debug)]
pub struct SoundBank {
pub samples: Vec<Arc<Sample>>,
pub samples: Arc<Vec<Arc<Sample>>>,
pub name: String,
pub alive: Arc<AtomicBool>,
pub metrics: AudioBankMetrics,
}
impl SoundBank {
pub fn new(samples: Vec<Arc<Sample>>) -> Self {
Self { samples }
let pcm_bytes = samples.iter().map(|s| s.data.len() * 2).sum();
Self {
samples: Arc::new(samples),
name: String::new(),
alive: Arc::new(AtomicBool::new(true)),
metrics: AudioBankMetrics { pcm_bytes, ..Default::default() },
}
}
pub fn invalidate(&self) {
self.alive.store(false, Ordering::Release);
}
pub fn resident_copy(&self) -> Self {
Self {
samples: self.samples.clone(),
name: self.name.clone(),
alive: Arc::new(AtomicBool::new(true)),
metrics: self.metrics,
}
}
}
@@ -59,6 +59,19 @@ pub enum Syscall {
AudioSetVolume = 0x3004,
AudioSetPan = 0x3005,
AudioSetPitch = 0x3006,
MusicPlay = 0x3010,
MusicStop = 0x3011,
MusicPause = 0x3012,
MusicResume = 0x3013,
MusicSetVolume = 0x3014,
MusicFadeTo = 0x3015,
MusicCrossfade = 0x3016,
AudioSetBusVolume = 0x3020,
AudioSetEffect = 0x3021,
AudioSetSend = 0x3022,
AudioUnloadBank = 0x3023,
AudioSetGroupVolume = 0x3024,
FsOpen = 0x4001,
FsRead = 0x4002,
FsWrite = 0x4003,
@@ -31,4 +31,64 @@ pub(crate) const ENTRIES: &[SyscallRegistryEntry] = &[
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::MusicPlay, "music", "play")
.args(3)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::MusicStop, "music", "stop")
.args(1)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::MusicPause, "music", "pause")
.args(1)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::MusicResume, "music", "resume")
.args(1)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::MusicSetVolume, "music", "set_volume")
.args(2)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::MusicFadeTo, "music", "fade_to")
.args(4)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::MusicCrossfade, "music", "crossfade")
.args(4)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::AudioSetBusVolume, "audio", "set_bus_volume")
.args(2)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::AudioSetEffect, "audio", "set_effect")
.args(6)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::AudioSetSend, "audio", "set_send")
.args(2)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::AudioUnloadBank, "audio", "unload_bank")
.args(2)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
SyscallRegistryEntry::builder(Syscall::AudioSetGroupVolume, "audio", "set_group_volume")
.args(2)
.rets(1)
.caps(caps::AUDIO)
.cost(5),
];
@@ -37,6 +37,19 @@ impl Syscall {
0x3004 => Some(Self::AudioSetVolume),
0x3005 => Some(Self::AudioSetPan),
0x3006 => Some(Self::AudioSetPitch),
0x3010 => Some(Self::MusicPlay),
0x3011 => Some(Self::MusicStop),
0x3012 => Some(Self::MusicPause),
0x3013 => Some(Self::MusicResume),
0x3014 => Some(Self::MusicSetVolume),
0x3015 => Some(Self::MusicFadeTo),
0x3016 => Some(Self::MusicCrossfade),
0x3020 => Some(Self::AudioSetBusVolume),
0x3021 => Some(Self::AudioSetEffect),
0x3022 => Some(Self::AudioSetSend),
0x3023 => Some(Self::AudioUnloadBank),
0x3024 => Some(Self::AudioSetGroupVolume),
0x4001 => Some(Self::FsOpen),
0x4002 => Some(Self::FsRead),
0x4003 => Some(Self::FsWrite),
@@ -110,6 +123,19 @@ impl Syscall {
Self::AudioSetVolume => "AudioSetVolume",
Self::AudioSetPan => "AudioSetPan",
Self::AudioSetPitch => "AudioSetPitch",
Self::MusicPlay => "MusicPlay",
Self::MusicStop => "MusicStop",
Self::MusicPause => "MusicPause",
Self::MusicResume => "MusicResume",
Self::MusicSetVolume => "MusicSetVolume",
Self::MusicFadeTo => "MusicFadeTo",
Self::MusicCrossfade => "MusicCrossfade",
Self::AudioSetBusVolume => "AudioSetBusVolume",
Self::AudioSetEffect => "AudioSetEffect",
Self::AudioSetSend => "AudioSetSend",
Self::AudioUnloadBank => "AudioUnloadBank",
Self::AudioSetGroupVolume => "AudioSetGroupVolume",
Self::FsOpen => "FsOpen",
Self::FsRead => "FsRead",
Self::FsWrite => "FsWrite",
@@ -960,7 +960,7 @@ fn persistent_save_preempts_real_multichunk_asset_decoders() {
self.inner.sync()
}
}
for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::SCENE] {
for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::MUSIC, BankType::SCENE] {
let (card, disk) = formatted();
drop(card);
let events: Events = Arc::default();
@@ -985,8 +985,37 @@ fn persistent_save_preempts_real_multichunk_asset_decoders() {
)
}
BankType::SOUNDS => {
(vec![0x12; 16385], 16385, serde_json::json!({"sample_rate":44100,"channels":1}))
let mut bytes = vec![0u8; 88];
bytes[..4].copy_from_slice(b"SBNK");
bytes[4] = 1;
bytes[49] = 1;
bytes[80] = 255;
bytes[81] = 128;
for (at, value) in [
(8, 1u32),
(20, 960),
(24, 500000),
(32, u32::MAX),
(52, 44100),
(56, 8192),
(68, 88),
(72, 16384),
(84, 65536),
] {
bytes[at..at + 4].copy_from_slice(&value.to_le_bytes());
}
bytes.extend([0x12; 16384]);
(bytes, 16472, serde_json::json!({"version":1}))
}
BankType::MUSIC => (
include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/mixed-music.mbnk"
))
.to_vec(),
6395,
serde_json::json!({"version":1}),
),
BankType::SCENE => {
let mut bytes = vec![0; 140];
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
@@ -1079,6 +1108,12 @@ fn persistent_save_preempts_real_multichunk_asset_decoders() {
assert_eq!(bank.samples[0].sample_rate, 44100);
assert_eq!(bank.samples[0].data, vec![0x1212; 8192]);
}
BankType::MUSIC => {
let bank = banks.music_bank_slot(0).unwrap();
assert_eq!(bank.events.len(), 4);
assert_eq!(bank.samples.len(), 2);
assert_eq!(bank.samples[1].channels, 2);
}
BankType::SCENE => {
let bank = banks.scene_bank_slot(0).unwrap();
assert_eq!(
@@ -4,6 +4,7 @@ use crate::services::memcard::MemcardService;
use prometeu_bytecode::{TRAP_INVALID_SYSCALL, TRAP_OOB, TRAP_TYPE, Value};
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::asset::{AssetId, AssetOpStatus, BankType};
use prometeu_hal::audio_bridge::AudioControl;
use prometeu_hal::color::Color;
use prometeu_hal::glyph::Glyph;
use prometeu_hal::log::{LogLevel, LogSource};
@@ -465,7 +466,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
let pan_raw = expect_int(args, 3)?;
let pitch = expect_number(args, 4, "pitch")?;
if !(0..16).contains(&voice_id_raw) {
if !(0..8).contains(&voice_id_raw) {
ret.push_int(AudioOpStatus::VoiceInvalid as i64);
return Ok(());
}
@@ -508,7 +509,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
prometeu_hal::LoopMode::On
};
if !(0..16).contains(&voice_id_raw) {
if !(0..8).contains(&voice_id_raw) {
ret.push_int(AudioOpStatus::VoiceInvalid as i64);
return Ok(());
}
@@ -558,7 +559,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
} else {
1.0
};
let status = if !(0..16).contains(&voice) {
let status = if !(0..8).contains(&voice) {
AudioOpStatus::VoiceInvalid
} else if !(0..=255).contains(&value) || !pitch.is_finite() || pitch <= 0.0 {
AudioOpStatus::ArgRangeInvalid
@@ -575,6 +576,113 @@ impl NativeInterface for VmRuntimeHost<'_> {
ret.push_int(status as i64);
Ok(())
}
Syscall::MusicPlay
| Syscall::MusicStop
| Syscall::MusicPause
| Syscall::MusicResume
| Syscall::MusicSetVolume
| Syscall::MusicFadeTo
| Syscall::MusicCrossfade
| Syscall::AudioSetBusVolume
| Syscall::AudioSetEffect
| Syscall::AudioSetSend
| Syscall::AudioUnloadBank
| Syscall::AudioSetGroupVolume => {
macro_rules! uint {
($i:expr, $max:expr) => {{
let n = expect_int(args, $i)?;
if !(0..=$max).contains(&n) {
ret.push_int(AudioOpStatus::ArgRangeInvalid as i64);
return Ok(());
}
n as u32
}};
}
let status = match syscall {
Syscall::MusicPlay => {
let group = uint!(0, 1);
let bank = uint!(1, 15);
let looping = uint!(2, 1);
platform.audio_mut().music_play(group as usize, bank as usize, looping != 0)
}
Syscall::AudioUnloadBank => {
let music = uint!(0, 1);
let slot = uint!(1, 15);
let result = platform.assets().unload_audio(music != 0, slot as usize);
ret.push_int(if result == AssetOpStatus::Ok {
AudioOpStatus::Ok
} else {
AudioOpStatus::BankInvalid
} as i64);
return Ok(());
}
_ => {
let control = match syscall {
Syscall::MusicStop => {
AudioControl::MusicStop { group: uint!(0, 1) as usize }
}
Syscall::MusicPause | Syscall::MusicResume => {
AudioControl::MusicPause {
group: uint!(0, 1) as usize,
paused: syscall == Syscall::MusicPause,
}
}
Syscall::MusicSetVolume => AudioControl::MusicVolume {
group: uint!(0, 1) as usize,
gain: uint!(1, 255) as u8,
},
Syscall::MusicFadeTo => {
let group = uint!(0, 1) as usize;
let gain = uint!(1, 255) as u8;
let ms = uint!(2, (u32::MAX / 48) as i64);
let curve = uint!(3, 1);
AudioControl::MusicFade {
group,
gain,
frames: ms * 48,
smooth: curve != 0,
}
}
Syscall::MusicCrossfade => {
let source = uint!(0, 1) as usize;
let target = uint!(1, 1) as usize;
let ms = uint!(2, (u32::MAX / 48) as i64);
let curve = uint!(3, 1);
AudioControl::Crossfade {
source,
target,
frames: ms * 48,
smooth: curve != 0,
}
}
Syscall::AudioSetGroupVolume => AudioControl::GroupVolume {
group: uint!(0, 2) as usize,
gain: uint!(1, 255) as u8,
},
Syscall::AudioSetBusVolume => AudioControl::BusVolume {
bus: uint!(0, 2) as usize,
gain: uint!(1, 255) as u8,
},
Syscall::AudioSetSend => AudioControl::SfxSend {
voice: uint!(0, 7) as usize,
gain: uint!(1, 255) as u8,
},
Syscall::AudioSetEffect => AudioControl::Effect {
group: uint!(0, 2) as usize,
cutoff_hz: uint!(1, 24_000),
delay_frames: uint!(2, 2000) * 48,
feedback: expect_number(args, 3, "feedback")? as f32,
wet: expect_number(args, 4, "wet")? as f32,
dry: expect_number(args, 5, "dry")? as f32,
},
_ => unreachable!(),
};
platform.audio_mut().control(control)
}
};
ret.push_int(status as i64);
Ok(())
}
Syscall::FsOpen => {
let path = expect_string(args, 0, "path")?;
if *self.fs_state != FsState::Mounted {
@@ -749,6 +857,7 @@ impl NativeInterface for VmRuntimeHost<'_> {
0 => BankType::GLYPH,
1 => BankType::SOUNDS,
2 => BankType::SCENE,
3 => BankType::MUSIC,
other => {
return Err(VmFault::Trap(
TRAP_TYPE,
@@ -770,6 +879,8 @@ impl NativeInterface for VmRuntimeHost<'_> {
let asset_type = match expect_int(args, 0)? as u32 {
0 => BankType::GLYPH,
1 => BankType::SOUNDS,
2 => BankType::SCENE,
3 => BankType::MUSIC,
_ => return Err(VmFault::Trap(TRAP_TYPE, "Invalid asset type".to_string())),
};
let telemetry = platform
@@ -14,13 +14,16 @@ struct Harness {
}
impl Harness {
fn new(code: &str, name: &str, args: u16) -> Self {
Self::new_domain(code, "audio", name, args)
}
fn new_domain(code: &str, module: &str, name: &str, args: u16) -> Self {
let mut runtime = VirtualMachineRuntime::new(None);
let mut vm = VirtualMachine::default();
let mut log = LogService::new(4096);
let program = serialized_single_function_module(
assemble(code).unwrap(),
vec![SyscallDecl {
module: "audio".into(),
module: module.into(),
name: name.into(),
version: 1,
arg_slots: args,
@@ -76,7 +79,7 @@ impl Harness {
fn guest_audio_status_matrix_and_type_traps() {
for (name, args, inputs, expected) in [
("stop", 1, "PUSH_I32 0", 0),
("stop", 1, "PUSH_I32 15", 0),
("stop", 1, "PUSH_I32 7", 0),
("stop", 1, "PUSH_I32 -1", 1),
("stop", 1, "PUSH_I32 16", 1),
("set_volume", 2, "PUSH_I32 0\nPUSH_I32 0", 0),
@@ -84,7 +87,7 @@ fn guest_audio_status_matrix_and_type_traps() {
("set_volume", 2, "PUSH_I32 0\nPUSH_I32 256", 3),
("set_pan", 2, "PUSH_I32 0\nPUSH_I32 -1", 3),
("set_pan", 2, "PUSH_I32 16\nPUSH_I32 -1", 1),
("set_pan", 2, "PUSH_I32 15\nPUSH_I32 255", 0),
("set_pan", 2, "PUSH_I32 7\nPUSH_I32 255", 0),
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 1", 0),
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 0", 3),
("set_pitch", 2, "PUSH_I32 0\nPUSH_I32 -1", 3),
@@ -216,3 +219,61 @@ fn normal_entry_return_is_a_successful_implicit_audio_frame() {
}
assert_eq!(h.transport().try_take().unwrap().frame.unwrap().len(), 1);
}
#[test]
fn music_and_bus_controls_resolve_with_audio_capability_and_validate_without_partial_commands() {
use prometeu_drivers::SoundBankPoolInstaller;
use prometeu_drivers::bank_format::{DecodedAudioBank, decode_audio_bank};
for (module, name, args, inputs, expected) in [
("music", "play", 3, "PUSH_I32 0\nPUSH_I32 0\nPUSH_I32 1", 0),
("music", "play", 3, "PUSH_I32 0\nPUSH_I32 16\nPUSH_I32 1", 3),
("music", "stop", 1, "PUSH_I32 1", 0),
("music", "pause", 1, "PUSH_I32 0", 0),
("music", "resume", 1, "PUSH_I32 0", 0),
("music", "set_volume", 2, "PUSH_I32 0\nPUSH_I32 255", 0),
("music", "fade_to", 4, "PUSH_I32 0\nPUSH_I32 0\nPUSH_I32 2000\nPUSH_I32 1", 0),
("music", "crossfade", 4, "PUSH_I32 0\nPUSH_I32 1\nPUSH_I32 2000\nPUSH_I32 0", 0),
("music", "crossfade", 4, "PUSH_I32 0\nPUSH_I32 0\nPUSH_I32 2000\nPUSH_I32 0", 3),
("audio", "set_group_volume", 2, "PUSH_I32 2\nPUSH_I32 255", 0),
("audio", "set_bus_volume", 2, "PUSH_I32 2\nPUSH_I32 255", 0),
("audio", "set_send", 2, "PUSH_I32 7\nPUSH_I32 128", 0),
(
"audio",
"set_effect",
6,
"PUSH_I32 2\nPUSH_I32 4000\nPUSH_I32 2000\nPUSH_F64 f64:0x3fe0000000000000\nPUSH_F64 f64:0x3fd3333333333333\nPUSH_F64 f64:0x3fe6666666666666",
0,
),
(
"audio",
"set_effect",
6,
"PUSH_I32 2\nPUSH_I32 4000\nPUSH_I32 2001\nPUSH_F64 f64:0x3fe0000000000000\nPUSH_F64 f64:0x3fd3333333333333\nPUSH_F64 f64:0x3fe6666666666666",
3,
),
("audio", "unload_bank", 2, "PUSH_I32 1\nPUSH_I32 0", 0),
] {
let mut h = Harness::new_domain(
&format!("{inputs}\nHOSTCALL 0\nFRAME_SYNC\nHALT"),
module,
name,
args,
);
let bytes = include_bytes!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../../test-fixtures/audio/mixed-music.mbnk"
));
let DecodedAudioBank::Music(bank) = decode_audio_bank(bytes, true).unwrap() else {
panic!()
};
h.platform.local_hardware().memory_banks.install_music_bank(0, Arc::new(bank));
assert!(h.tick().is_none(), "{module}.{name}");
assert_eq!(h.vm.operand_stack_top(1), vec![Value::Int64(expected)], "{module}.{name}");
let batch = h.transport().try_take().unwrap().frame;
assert_eq!(
batch.map_or(0, |v| v.len()),
usize::from(expected == 0 && name != "unload_bank"),
"{module}.{name}"
);
}
}