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:
@@ -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(),
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user