use super::*;
use crate::sound::PendingSoundCallback;
#[test]
fn legacy_sound_volume_apis_update_one_shared_speaker_control() {
use crate::memory::bus::{LEGACY_SOUND_PORT_A_OFFSET, LEGACY_SPEAKER_VOLUME};
use crate::memory::globals::addr;
for name in [
b"SetSoundVol".as_slice(),
b"Control".as_slice(),
b"PBControl".as_slice(),
] {
for (level, expected) in [
(0u16, 0u8),
(7, 7),
(3, 3),
(8, 7),
(0x0100, 7),
(0xFFFF, 7),
] {
for device in [true, false] {
let mut loaded = load_pef_application(&synthetic_pef_with_import(name)).unwrap();
assert_eq!(
loaded.memory.read_u8(addr::SD_VOLUME),
Some(LEGACY_SPEAKER_VOLUME)
);
let pb = PPC_HEAP_BASE;
let via = pb + 0x400;
let port_a = via + LEGACY_SOUND_PORT_A_OFFSET;
loaded.memory.add_region(pb, vec![0; 0x3000]);
loaded
.memory
.write_u32_be(addr::VIA_BASE, if device { via } else { 0 })
.unwrap();
loaded.memory.write_u8(port_a, 0xaf).unwrap();
loaded.memory.write_u8(addr::SD_VOLUME, 0xf8 | 2).unwrap();
match name {
b"SetSoundVol" => loaded.cpu.gpr[3] = u32::from(level),
b"Control" => {
loaded.cpu.gpr[3] = (-4i32) as u32;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = pb + 28;
}
_ => {
loaded.cpu.gpr[3] = pb;
loaded.memory.write_u16_be(pb + 16, 0x7777).unwrap();
loaded.memory.write_u16_be(pb + 24, (-4i16) as u16).unwrap();
loaded.memory.write_u16_be(pb + 26, 2).unwrap();
}
}
loaded.memory.write_u16_be(pb + 28, level).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(addr::SD_VOLUME), Some(0xf8 | expected));
let port = if device { (0xaf & !7) | expected } else { 0xaf };
assert_eq!(loaded.memory.read_u8(port_a), Some(port));
assert_eq!(loaded.sound.manager.legacy_speaker_muted, expected == 0);
if name != b"SetSoundVol" {
assert_eq!(loaded.cpu.gpr[3], 0);
}
if name == b"PBControl" {
assert_eq!(loaded.memory.read_u16_be(pb + 16), Some(0));
}
}
}
}
}
#[test]
fn legacy_sound_driver_control_sets_amplitude_and_rejects_other_codes() {
use crate::memory::globals::addr;
for name in [b"Control".as_slice(), b"PBControl".as_slice()] {
for (code, result, amplitude) in [(3u16, 0i16, 200u8), (4, -17, 0)] {
let mut loaded = load_pef_application(&synthetic_pef_with_import(name)).unwrap();
let pb = PPC_HEAP_BASE;
loaded.memory.add_region(pb, vec![0; 0x100]);
loaded.memory.write_u8(addr::SOUND_LEVEL, 0).unwrap();
if name == b"Control" {
loaded.cpu.gpr[3] = (-4i32) as u32;
loaded.cpu.gpr[4] = u32::from(code);
loaded.cpu.gpr[5] = pb + 28;
} else {
loaded.cpu.gpr[3] = pb;
loaded.memory.write_u16_be(pb + 24, (-4i16) as u16).unwrap();
loaded.memory.write_u16_be(pb + 26, code).unwrap();
}
loaded.memory.write_u16_be(pb + 28, 200).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3] as u16 as i16, result);
if name == b"PBControl" {
assert_eq!(loaded.memory.read_u16_be(pb + 16), Some(result as u16));
}
assert_eq!(loaded.memory.read_u8(addr::SOUND_LEVEL), Some(amplitude));
}
}
}
#[test]
fn hle_import_runner_builds_standard_sound_resource_header() {
let pef = synthetic_pef_with_import(b"SetupSndHeader");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = PPC_HEAP_BASE;
let data = handle + 4;
let header_len = data + 64;
loaded.memory.add_region(handle, vec![0xA5; 128]);
loaded.memory.write_u32_be(handle, data).unwrap();
test_handles!(loaded).push(PpcHandleRecord {
handle,
ptr: data,
size: 64,
capacity: 64,
});
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x2B77_45D1;
loaded.cpu.gpr[6] = 8;
loaded.cpu.gpr[7] = u32::from_be_bytes(*b"NONE");
loaded.cpu.gpr[8] = 60;
loaded.cpu.gpr[9] = 4;
loaded.cpu.gpr[10] = header_len;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u16_be(header_len), Some(42));
assert_eq!(loaded.memory.read_u16_be(data), Some(1));
assert_eq!(loaded.memory.read_u16_be(data + 2), Some(1));
assert_eq!(loaded.memory.read_u16_be(data + 4), Some(5));
assert_eq!(loaded.memory.read_u32_be(data + 6), Some(0x80));
assert_eq!(loaded.memory.read_u16_be(data + 10), Some(1));
assert_eq!(loaded.memory.read_u16_be(data + 12), Some(0x8051));
assert_eq!(loaded.memory.read_u32_be(data + 16), Some(20));
assert_eq!(loaded.memory.read_u32_be(data + 20), Some(0));
assert_eq!(loaded.memory.read_u32_be(data + 24), Some(4));
assert_eq!(loaded.memory.read_u32_be(data + 28), Some(0x2B77_45D1));
assert_eq!(loaded.memory.read_u8(data + 40), Some(0));
assert_eq!(loaded.memory.read_u8(data + 41), Some(60));
assert_eq!(loaded.memory.read_u8(data + 42), Some(0xA5));
assert_eq!(ppc_sound_header_offset(&mut loaded.memory, data), Some(20));
}
#[test]
fn setup_snd_header_rejects_short_handle_without_writing() {
let pef = synthetic_pef_with_import(b"SetupSndHeader");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = PPC_HEAP_BASE;
let data = handle + 4;
let header_len = data + 64;
loaded.memory.add_region(handle, vec![0xA5; 128]);
loaded.memory.write_u32_be(handle, data).unwrap();
test_handles!(loaded).push(PpcHandleRecord {
handle,
ptr: data,
size: 40,
capacity: 40,
});
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x2B77_45D1;
loaded.cpu.gpr[6] = 8;
loaded.cpu.gpr[7] = u32::from_be_bytes(*b"NONE");
loaded.cpu.gpr[8] = 60;
loaded.cpu.gpr[9] = 4;
loaded.cpu.gpr[10] = header_len;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_MEM_FULL_ERR));
assert_eq!(loaded.memory.read_u16_be(data), Some(0xA5A5));
assert_eq!(loaded.memory.read_u16_be(header_len), Some(0xA5A5));
}
#[test]
fn setup_snd_header_builds_stereo_16_bit_extended_header() {
let pef = synthetic_pef_with_import(b"SetupSndHeader");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = PPC_HEAP_BASE;
let data = handle + 4;
let header_len = data + 100;
loaded.memory.add_region(handle, vec![0xA5; 128]);
loaded.memory.write_u32_be(handle, data).unwrap();
test_handles!(loaded).push(PpcHandleRecord {
handle,
ptr: data,
size: 96,
capacity: 96,
});
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 0xAC44_0000;
loaded.cpu.gpr[6] = 16;
loaded.cpu.gpr[7] = u32::from_be_bytes(*b"NONE");
loaded.cpu.gpr[8] = 60;
loaded.cpu.gpr[9] = 16;
loaded.cpu.gpr[10] = header_len;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u16_be(header_len), Some(84));
assert_eq!(loaded.memory.read_u32_be(data + 6), Some(0xC0));
assert_eq!(loaded.memory.read_u32_be(data + 24), Some(2));
assert_eq!(loaded.memory.read_u32_be(data + 28), Some(0xAC44_0000));
assert_eq!(loaded.memory.read_u8(data + 40), Some(0xFF));
assert_eq!(loaded.memory.read_u32_be(data + 42), Some(4));
assert_eq!(loaded.memory.read_u16_be(data + 68), Some(16));
assert_eq!(loaded.memory.read_u8(data + 84), Some(0xA5));
assert!(ppc_parse_snd_header_fields(&mut loaded.memory, data, 20).is_some());
}
#[test]
fn setup_snd_header_builds_mace_3_to_1_header() {
let pef = synthetic_pef_with_import(b"SetupSndHeader");
let mut loaded = load_pef_application(&pef).unwrap();
let handle = PPC_HEAP_BASE;
let data = handle + 4;
let header_len = data + 100;
loaded.memory.add_region(handle, vec![0xA5; 128]);
loaded.memory.write_u32_be(handle, data).unwrap();
test_handles!(loaded).push(PpcHandleRecord {
handle,
ptr: data,
size: 96,
capacity: 96,
});
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = 1;
loaded.cpu.gpr[5] = 0x5622_0000;
loaded.cpu.gpr[6] = 8;
loaded.cpu.gpr[7] = u32::from_be_bytes(*b"MAC3");
loaded.cpu.gpr[8] = 60;
loaded.cpu.gpr[9] = 1000;
loaded.cpu.gpr[10] = header_len;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u16_be(header_len), Some(84));
assert_eq!(loaded.memory.read_u32_be(data + 6), Some(0x380));
assert_eq!(loaded.memory.read_u8(data + 40), Some(0xFE));
assert_eq!(loaded.memory.read_u32_be(data + 42), Some(3000));
assert_eq!(loaded.memory.read_u32_be(data + 60), Some(u32::from_be_bytes(*b"MAC3")));
assert_eq!(loaded.memory.read_u16_be(data + 76), Some(u16::MAX));
assert_eq!(loaded.memory.read_u16_be(data + 78), Some(16));
assert_eq!(loaded.memory.read_u16_be(data + 82), Some(8));
}
#[test]
fn hle_import_runner_handles_sound_manager_version() {
let pef = synthetic_pef_with_import(b"SndSoundManagerVersion");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.memory.add_region(PPC_HEAP_BASE, vec![0; 16]);
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_HEAP_BASE);
assert_eq!(
loaded.memory.read_u32_be(PPC_HEAP_BASE),
Some(PPC_SOUND_MANAGER_VERSION)
);
}
#[test]
fn hle_snd_control_reports_documented_synth_queries() {
let pef = synthetic_pef_with_import(b"SndControl");
let mut loaded = load_pef_application(&pef).unwrap();
let command = PPC_HEAP_BASE;
loaded.memory.add_region(command, vec![0; 8]);
for (synth, number, options, expected_param1, expected_param2) in [
(5, crate::sound::cmd::AVAILABLE, 0, 1, 0),
(5, crate::sound::cmd::AVAILABLE, 1, 0, 1),
(2, crate::sound::cmd::AVAILABLE, 0, 0, 0),
(5, crate::sound::cmd::VERSION, 0, 0, 0x0003_0000),
(2, crate::sound::cmd::VERSION, 0, 0, 0),
(5, crate::sound::cmd::TOTAL_LOAD, 42, 0, 42),
] {
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = synth;
loaded.cpu.gpr[4] = command;
loaded.memory.write_u16_be(command, number).unwrap();
loaded.memory.write_u16_be(command + 2, 9).unwrap();
loaded.memory.write_u32_be(command + 4, options).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u16_be(command + 2), Some(expected_param1));
assert_eq!(loaded.memory.read_u32_be(command + 4), Some(expected_param2));
}
}
#[test]
fn hle_import_runner_handles_unsigned_fixed_mul_div() {
let pef = synthetic_pef_with_import(b"UnsignedFixedMulDiv");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.imports[0].library_name = "SoundLib".to_string();
loaded.imports[0].dispatcher_target = dispatcher_target_for_import(
&loaded.imports[0].library_name,
&loaded.imports[0].symbol_name,
);
loaded.cpu.gpr[3] = 0x0001_0000;
loaded.cpu.gpr[4] = 0x5622_0000;
loaded.cpu.gpr[5] = 0x5622_0000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x0001_0000);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = u32::MAX;
loaded.cpu.gpr[4] = u32::MAX;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(loaded.cpu.gpr[3], u32::MAX);
}
#[test]
fn hle_import_runner_gets_default_sound_output_sample_rate() {
let pef = synthetic_pef_with_library_import(b"SoundLib", b"GetSoundOutputInfo");
let mut loaded = load_pef_application(&pef).unwrap();
let rate_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(rate_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = 0;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"srat");
loaded.cpu.gpr[5] = rate_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.memory.read_u32_be(rate_ptr),
Some(crate::sound::OUTPUT_RATE << 16)
);
}
#[test]
fn snd_set_info_updates_channel_sample_rate_and_rejects_invalid_arguments() {
let pef = synthetic_pef_with_library_import(b"SoundLib", b"SndSetInfo");
let mut loaded = load_pef_application(&pef).unwrap();
let channel = PPC_DATA_BASE + 0x1000;
let rate_ptr = PPC_DATA_BASE + 0x1100;
let output_ptr = PPC_DATA_BASE + 0x1200;
loaded.memory.add_region(rate_ptr, vec![0; 4]);
loaded.memory.add_region(output_ptr, vec![0; 4]);
loaded.memory.write_u32_be(rate_ptr, 0x5622_0000).unwrap();
loaded
.sound
.manager
.with_ensured_channel_mut(channel, |_| {});
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"srat");
loaded.cpu.gpr[5] = rate_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded
.sound
.manager
.find_channel(channel)
.unwrap()
.sample_rate(),
0x5622_0000
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndGetInfo;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"srat");
loaded.cpu.gpr[5] = output_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(output_ptr), Some(0x5622_0000));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndSetInfo;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"srat");
loaded.cpu.gpr[5] = 0x5622_0000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(
loaded
.sound
.manager
.find_channel(channel)
.unwrap()
.sample_rate(),
0x5622_0000
);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = u32::from_be_bytes(*b"xxxx");
loaded.cpu.gpr[5] = rate_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(-231));
}
#[test]
fn hle_import_runner_handles_get_default_output_volume() {
let pef = synthetic_pef_with_import(b"GetDefaultOutputVolume");
let mut loaded = load_pef_application(&pef).unwrap();
let volume_out_ptr = PPC_HEAP_BASE;
loaded
.sound
.manager
.set_default_output_volume(0x0000_8000);
loaded.memory.add_region(volume_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = volume_out_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(volume_out_ptr), Some(0x0000_8000));
}
#[test]
fn hle_import_runner_handles_set_default_output_volume() {
let pef = synthetic_pef_with_import(b"SetDefaultOutputVolume");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x0000_4000;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.sound.manager.default_output_volume(),
0x0000_4000
);
}
#[test]
fn hle_import_runner_records_sys_beep_and_queues_pcm() {
let pef = synthetic_pef_with_import(b"SysBeep");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.cpu.gpr[3] = 0x0000_003c;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x0000_003c);
assert_eq!(loaded.sound.sys_beep_count, 1);
assert_eq!(loaded.sound.last_sys_beep_duration, 60);
assert!(loaded.sound.immediate_commands.is_empty());
assert!(loaded.sound.file_playbacks.is_empty());
assert!(loaded.sound.decoded_file_playbacks.is_empty());
assert!(loaded.sound.manager.pending_sound_callbacks.is_empty());
assert!(loaded.sound.completion_invocations.is_empty());
assert_eq!(loaded.sound.manager.channels.len(), 1);
let beep_audio = loaded
.sound
.manager
.mix_frame(crate::sound::OUTPUT_RATE as usize);
assert!(
beep_audio.iter().any(|sample| *sample != 0x80),
"native SysBeep must enqueue non-silent PCM"
);
let beep_channel = loaded.sound.manager.channels[0].guest_ptr;
assert_ne!(beep_channel, 0);
assert!(loaded
.sound
.manager
.idle_auto_dispose_channel_ptrs()
.contains(&beep_channel));
loaded.sound.manager.remove_channel(beep_channel);
assert!(loaded.sound.manager.channels.is_empty());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = 0x0000_ffff;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], 0x0000_ffff);
assert_eq!(loaded.sound.sys_beep_count, 2);
assert_eq!(loaded.sound.last_sys_beep_duration, -1);
assert_eq!(loaded.sound.start_count, 0);
assert_eq!(loaded.sound.pause_count, 0);
assert_eq!(loaded.sound.stop_count, 0);
}
#[test]
fn hle_import_runner_handles_snd_new_channel() {
let pef = synthetic_pef_with_import(b"SndNewChannel");
let mut loaded = load_pef_application(&pef).unwrap();
let channel_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(channel_out_ptr, vec![0; 4]);
loaded.cpu.gpr[3] = channel_out_ptr;
loaded.cpu.gpr[4] = 5; loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 0x0123_4567;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
let channel = loaded.memory.read_u32_be(channel_out_ptr).unwrap();
assert_ne!(channel, 0);
assert_eq!(loaded.memory.read_u32_be(channel), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 4), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 8), Some(0x0123_4567));
assert_eq!(loaded.memory.read_u32_be(channel + 12), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 16), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 20), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 24), Some(0));
assert_eq!(loaded.memory.read_u16_be(channel + 28), Some(0));
assert_eq!(loaded.memory.read_u16_be(channel + 30), Some(128));
assert_eq!(loaded.memory.read_u16_be(channel + 32), Some(0));
assert_eq!(loaded.memory.read_u16_be(channel + 34), Some(0));
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn queued_callback_command_schedules_the_async_snd_play_completion() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let channel = PPC_DATA_BASE + 0x1000;
let sound_handle = PPC_DATA_BASE + 0x1100;
let sound_ptr = PPC_DATA_BASE + 0x1200;
let command_ptr = PPC_DATA_BASE + 0x1300;
let completion = PPC_CODE_BASE + 0x80;
let samples = [0x80, 0x90, 0x70, 0x80];
let mut resource = vec![0; 40];
write_u16(&mut resource, 0, 2);
write_u16(&mut resource, 4, 1);
write_u16(&mut resource, 6, 0x8050);
write_u32(&mut resource, 10, 14);
write_u32(&mut resource, 18, samples.len() as u32);
write_u32(&mut resource, 22, crate::sound::OUTPUT_RATE << 16);
resource[34] = 0;
resource[35] = 60;
resource[36..40].copy_from_slice(&samples);
loaded
.memory
.add_region(channel, vec![0; PPC_GUEST_SND_CHANNEL_SIZE as usize]);
loaded.memory.add_region(sound_handle, vec![0; 4]);
loaded.memory.add_region(sound_ptr, resource.clone());
loaded.memory.add_region(command_ptr, vec![0; 8]);
loaded.memory.write_u32_be(channel + 8, completion).unwrap();
loaded.sound.manager.register_channel(
channel,
false,
completion,
CallbackTaskArchitecture::PowerPc,
);
loaded.memory.write_u32_be(sound_handle, sound_ptr).unwrap();
test_handles!(loaded).push(PpcHandleRecord {
handle: sound_handle,
ptr: sound_ptr,
size: resource.len() as u32,
capacity: resource.len() as u32,
});
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = sound_handle;
loaded.cpu.gpr[5] = 1;
assert_eq!(
ppc_snd_play(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
&mut loaded.sound,
),
PPC_NO_ERR
);
assert!(loaded.sound.file_playbacks.is_empty());
assert_eq!(loaded.sound.manager.debug_buffer_cmd_count, 1);
assert_eq!(loaded.sound.manager.debug_file_play_count, 0);
loaded.memory.write_u16_be(command_ptr, 13).unwrap();
loaded.memory.write_u16_be(command_ptr + 2, 0x5348).unwrap();
loaded
.memory
.write_u32_be(command_ptr + 4, 0x0200_0000)
.unwrap();
loaded.cpu.gpr[4] = command_ptr;
loaded.cpu.gpr[5] = 1;
assert_eq!(
ppc_snd_do_command(&loaded.cpu, &mut loaded.memory, &mut loaded.sound),
PPC_NO_ERR
);
let command = PpcSndCommandRecord {
channel,
command: 13,
param1: 0x5348,
param2: 0x0200_0000,
};
assert_eq!(loaded.sound.queued_commands, vec![command]);
loaded.sound.manager.mix_frame(8);
loaded.sound.manager.mix_frame(1);
assert_eq!(loaded.sound.manager.pending_sound_callbacks.len(), 1);
match &loaded.sound.manager.pending_sound_callbacks[0] {
PendingSoundCallback::Command {
architecture,
callback_addr,
chan_ptr,
cmd,
} => {
assert_eq!(*architecture, CallbackTaskArchitecture::PowerPc);
assert_eq!(*callback_addr, completion);
assert_eq!(*chan_ptr, channel);
assert_eq!(
PpcSndCommandRecord {
channel: *chan_ptr,
command: cmd.cmd,
param1: cmd.param1,
param2: cmd.param2,
},
command
);
}
other => panic!("expected native PPC command callback, got {other:?}"),
}
}
#[test]
fn sndplay_preserves_multiple_resource_commands_and_fires_callback_once() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let channel = PPC_DATA_BASE + 0x1800;
let sound_handle = PPC_DATA_BASE + 0x1900;
let sound_ptr = PPC_DATA_BASE + 0x1a00;
let callback = PPC_CODE_BASE + 0x180;
let mut resource = vec![0; 100];
let commands_end = 38usize;
let header_one = commands_end;
let header_two = 64usize;
write_u16(&mut resource, 0, 2); write_u16(&mut resource, 4, 4); write_u16(&mut resource, 6, 0x8050); write_u32(&mut resource, 10, header_one as u32);
write_u16(&mut resource, 14, crate::sound::cmd::VOLUME);
write_u32(&mut resource, 18, 0x0040_0040);
write_u16(&mut resource, 22, 0x8051); write_u32(&mut resource, 26, header_two as u32);
write_u16(&mut resource, 30, crate::sound::cmd::CALLBACK);
write_u16(&mut resource, 32, 0x1234);
write_u32(&mut resource, 34, 0x5678_9abc);
for (header, samples) in [(header_one, [0xa0, 0xa0, 0xa0, 0xa0]),
(header_two, [0xa0, 0xa0, 0xa0, 0xa0])]
{
write_u32(&mut resource, header, 0); write_u32(&mut resource, header + 4, samples.len() as u32);
write_u32(&mut resource, header + 8, crate::sound::OUTPUT_RATE << 16);
resource[header + 20] = 0; resource[header + 21] = 60;
resource[header + 22..header + 26].copy_from_slice(&samples);
}
loaded
.memory
.add_region(channel, vec![0; PPC_GUEST_SND_CHANNEL_SIZE as usize]);
loaded.memory.add_region(sound_handle, vec![0; 4]);
loaded.memory.add_region(sound_ptr, resource.clone());
loaded.memory.write_u32_be(channel + 8, callback).unwrap();
loaded.sound.manager.register_channel(
channel,
false,
callback,
CallbackTaskArchitecture::PowerPc,
);
loaded.memory.write_u32_be(sound_handle, sound_ptr).unwrap();
test_handles!(loaded).push(PpcHandleRecord {
handle: sound_handle,
ptr: sound_ptr,
size: resource.len() as u32,
capacity: resource.len() as u32,
});
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = sound_handle;
loaded.cpu.gpr[5] = 1;
assert_eq!(
ppc_snd_play(
&loaded.cpu,
&mut loaded.memory,
&test_handle_records!(loaded),
&mut loaded.sound,
),
PPC_NO_ERR
);
assert_eq!(loaded.sound.manager.debug_buffer_cmd_count, 2);
assert_eq!(loaded.sound.manager.channel_has_queued_commands(channel), Some(true));
assert_eq!(loaded.sound.manager.mix_frame(4), vec![0xa0; 4]);
assert_eq!(loaded.sound.manager.mix_frame(1), vec![0x88]);
loaded.sound.manager.mix_frame(4);
loaded.sound.manager.mix_frame(1); assert_eq!(loaded.sound.manager.pending_sound_callbacks.len(), 1);
loaded.sound.manager.mix_frame(1);
assert_eq!(
loaded.sound.manager.pending_sound_callbacks.len(),
1,
"one resource callback command must not be scheduled twice"
);
match &loaded.sound.manager.pending_sound_callbacks[0] {
PendingSoundCallback::Command { cmd, chan_ptr, .. } => {
assert_eq!(*chan_ptr, channel);
assert_eq!(cmd.cmd, crate::sound::cmd::CALLBACK);
assert_eq!(cmd.param1, 0x1234);
assert_eq!(cmd.param2, 0x5678_9abc);
}
other => panic!("expected command callback, got {other:?}"),
}
}
#[test]
fn snd_do_command_reports_queue_full_for_both_wait_modes() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let channel = PPC_DATA_BASE + 0x1b00;
let command_ptr = PPC_DATA_BASE + 0x1c00;
loaded.memory.add_region(command_ptr, vec![0; 8]);
loaded.sound.manager.register_channel(
channel,
false,
0,
CallbackTaskArchitecture::PowerPc,
);
for _ in 0..128 {
assert!(loaded.sound.manager.enqueue_command(
channel,
crate::sound::SndCommand {
cmd: crate::sound::cmd::NULL,
param1: 0,
param2: 0,
},
));
}
loaded.memory.write_u16_be(command_ptr, crate::sound::cmd::NULL).unwrap();
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = command_ptr;
loaded.cpu.gpr[5] = 1; assert_eq!(
ppc_snd_do_command(&loaded.cpu, &mut loaded.memory, &mut loaded.sound),
-203
);
loaded.cpu.gpr[5] = 0; assert_eq!(
ppc_snd_do_command(&loaded.cpu, &mut loaded.memory, &mut loaded.sound),
-203
);
}
#[test]
fn snd_channel_status_reports_active_native_buffer_then_idle() {
let mut loaded = load_pef_application(&synthetic_pef()).unwrap();
let channel = PPC_DATA_BASE + 0x1d00;
let status_ptr = PPC_DATA_BASE + 0x1e00;
loaded.memory.add_region(status_ptr, vec![0xaa; 22]);
loaded.sound.manager.register_channel(
channel,
false,
0,
CallbackTaskArchitecture::PowerPc,
);
loaded.sound.manager.play_buffer_command_for_architecture(
channel,
vec![0xa0, 0xa0],
crate::sound::OUTPUT_RATE << 16,
CallbackTaskArchitecture::PowerPc,
);
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = 22;
loaded.cpu.gpr[5] = status_ptr;
assert_eq!(
ppc_snd_channel_status(&mut loaded.cpu, &mut loaded.memory, &loaded.sound),
PPC_NO_ERR
);
assert_eq!(loaded.memory.read_u8(status_ptr + 12), Some(1));
assert_eq!(loaded.memory.read_u8(status_ptr + 14), Some(0));
loaded.sound.manager.mix_frame(2);
assert_eq!(
ppc_snd_channel_status(&mut loaded.cpu, &mut loaded.memory, &loaded.sound),
PPC_NO_ERR
);
assert_eq!(loaded.memory.read_u8(status_ptr + 12), Some(0));
}
#[test]
fn hle_import_runner_handles_snd_play_double_buffer() {
let pef = synthetic_pef_with_import(b"SndPlayDoubleBuffer");
let mut loaded = load_pef_application(&pef).unwrap();
let channel = PPC_DATA_BASE + 0x1000;
let header = PPC_DATA_BASE + 0x2000;
loaded
.memory
.add_region(channel, vec![0xdd; PPC_GUEST_SND_CHANNEL_SIZE as usize]);
loaded.memory.add_region(header, vec![0; 24]);
loaded.memory.add_region(PPC_DATA_BASE + 0x3000, vec![0; 24]);
loaded.memory.add_region(PPC_DATA_BASE + 0x4000, vec![0; 24]);
loaded
.memory
.write_u32_be(PPC_DATA_BASE + 0x3000, 2)
.unwrap();
loaded
.memory
.write_u32_be(PPC_DATA_BASE + 0x3004, 1)
.unwrap();
loaded
.memory
.write_bytes(
PPC_DATA_BASE + 0x3010,
&[0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0x7f, 0xff],
)
.unwrap();
loaded.memory.write_u16_be(header, 2).unwrap();
loaded.memory.write_u16_be(header + 2, 16).unwrap();
loaded
.memory
.write_u32_be(header + 8, 22_050u32 << 16)
.unwrap();
loaded
.memory
.write_u32_be(header + 12, PPC_DATA_BASE + 0x3000)
.unwrap();
loaded
.memory
.write_u32_be(header + 16, PPC_DATA_BASE + 0x4000)
.unwrap();
loaded
.memory
.write_u32_be(header + 20, PPC_CODE_BASE + 0x40)
.unwrap();
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = header;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.sound.double_buffer_play_count, 1);
assert_eq!(loaded.sound.last_double_buffer_channel, channel);
assert_eq!(loaded.sound.last_double_buffer_header, header);
assert_eq!(
loaded.sound.manager.double_buffer_playbacks,
vec![PpcSoundDoubleBufferPlaybackRecord {
channel,
header,
buffers: [PPC_DATA_BASE + 0x3000, PPC_DATA_BASE + 0x4000],
callback: PPC_CODE_BASE + 0x40,
callback_architecture: CallbackTaskArchitecture::PowerPc,
sample_rate_fixed: 22_050u32 << 16,
num_channels: 2,
sample_size: 16,
compression_id: 0,
format: 0,
packet_size: 0,
current_buffer_index: 0,
callback_pending_mask: 0,
active: true,
host_initialized: true,
host_buffer_loaded: true,
}]
);
assert_eq!(loaded.sound.manager.debug_double_buffer_count, 1);
assert!(loaded
.sound
.manager
.channels
.iter()
.any(|candidate| candidate.guest_ptr == channel && candidate.has_active_playback()));
assert!(loaded.sound.manager.pending_process_doublebacks.is_empty());
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.sound.double_buffer_play_count, 1);
}
#[test]
fn hle_import_runner_handles_snd_dispose_channel() {
let pef = synthetic_pef_with_import(b"SndDisposeChannel");
let mut loaded = load_pef_application(&pef).unwrap();
let channel = 0x0500_1000;
loaded
.sound
.file_playbacks
.push(PpcSoundFilePlaybackRecord {
channel,
ref_num: 0,
resource_id: 0,
buffer_size: 0,
buffer: 0,
selection: 0,
completion: 0,
completion_command: None,
async_play: false,
aiff: None,
decoded_aiff: None,
});
loaded.sound.manager.play_file_buffer(
channel,
vec![0x80],
crate::sound::OUTPUT_RATE << 16,
None,
);
loaded.sound.decoded_file_playbacks.push(PpcDecodedAiffPlaybackRecord {
file_playback_index: 0,
channel,
sample_rate_fixed: crate::sound::OUTPUT_RATE << 16,
samples: vec![0xa0],
});
loaded.sound.manager.queue_sound_callback(
PendingSoundCallback::FileCompletion {
architecture: CallbackTaskArchitecture::PowerPc,
callback_addr: PPC_CODE_BASE + 0x220,
chan_ptr: channel,
},
);
assert_eq!(loaded.sound.manager.toggle_file_paused(channel), Some(true));
loaded.cpu.gpr[3] = channel;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.sound.manager.file_playback_paused(channel), None);
assert!(loaded.sound.file_playbacks.is_empty());
assert!(loaded.sound.decoded_file_playbacks.is_empty());
assert!(loaded.sound.manager.pending_sound_callbacks.is_empty());
}
#[test]
fn hle_import_runner_snd_new_channel_rejects_unsupported_synth_without_side_effects() {
let pef = synthetic_pef_with_import(b"SndNewChannel");
let mut loaded = load_pef_application(&pef).unwrap();
let channel_out_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(channel_out_ptr, vec![0xaa; 4]);
let initial_heap_cursor = loaded.heap_cursor();
loaded.set_last_mem_error(123);
loaded.cpu.gpr[3] = channel_out_ptr;
loaded.cpu.gpr[4] = 2;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 0x0123_4567;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_RES_PROBLEM));
assert_eq!(loaded.heap_cursor(), initial_heap_cursor);
assert_eq!(loaded.last_mem_error(), 123);
assert_ppc_bytes_equal(&mut loaded.memory, channel_out_ptr, 4, 0xaa);
}
#[test]
fn hle_import_runner_snd_new_channel_reuses_existing_channel_record() {
let pef = synthetic_pef_with_import(b"SndNewChannel");
let mut loaded = load_pef_application(&pef).unwrap();
let channel_out_ptr = PPC_DATA_BASE + 0x1000;
let channel = PPC_DATA_BASE + 0x1100;
loaded.memory.add_region(channel_out_ptr, vec![0; 4]);
loaded
.memory
.add_region(channel, vec![0xdd; PPC_GUEST_SND_CHANNEL_SIZE as usize]);
loaded
.memory
.write_u32_be(channel_out_ptr, channel)
.unwrap();
loaded
.memory
.write_u32_be(channel + 12, 0xcafe_babe)
.unwrap();
loaded.memory.write_u16_be(channel + 30, 4).unwrap();
let initial_heap_cursor = loaded.heap_cursor();
loaded.cpu.gpr[3] = channel_out_ptr;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = 0x89ab_cdef;
loaded.cpu.gpr[6] = 0x0123_4567;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.heap_cursor(), initial_heap_cursor);
assert_eq!(loaded.memory.read_u32_be(channel_out_ptr), Some(channel));
assert_eq!(loaded.memory.read_u32_be(channel), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 4), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 8), Some(0x0123_4567));
assert_eq!(loaded.memory.read_u32_be(channel + 12), Some(0xcafe_babe));
assert_eq!(loaded.memory.read_u32_be(channel + 16), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 20), Some(0));
assert_eq!(loaded.memory.read_u32_be(channel + 24), Some(0));
assert_eq!(loaded.memory.read_u16_be(channel + 28), Some(0));
assert_eq!(loaded.memory.read_u16_be(channel + 30), Some(4));
assert_eq!(loaded.memory.read_u16_be(channel + 32), Some(0));
assert_eq!(loaded.memory.read_u16_be(channel + 34), Some(0));
assert_eq!(loaded.last_mem_error(), PPC_NO_ERR);
}
#[test]
fn hle_import_runner_handles_snd_channel_status() {
let pef = synthetic_pef_with_import(b"SndChannelStatus");
let mut loaded = load_pef_application(&pef).unwrap();
let status_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(status_ptr, vec![0xaa; 22]);
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
loaded.cpu.gpr[4] = 22;
loaded.cpu.gpr[5] = status_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
for offset in 0..22 {
assert_eq!(loaded.memory.read_u8(status_ptr + offset), Some(0));
}
}
#[test]
fn hle_import_runner_prevalidates_sound_manager_output_buffers() {
let pef = synthetic_pef_with_import(b"SndSoundManagerVersion");
let mut loaded = load_pef_application(&pef).unwrap();
let version_ptr = PPC_DATA_BASE + 0x1000;
let volume_ptr = PPC_DATA_BASE + 0x1100;
let channel_out_ptr = PPC_DATA_BASE + 0x1200;
let status_ptr = PPC_DATA_BASE + 0x1300;
let cmd_ptr = PPC_DATA_BASE + 0x1400;
let rate_ptr = PPC_DATA_BASE + 0x1500;
let offset_ptr = PPC_DATA_BASE + 0x1600;
loaded.memory.add_region(version_ptr, vec![0xa1; 3]);
loaded.memory.add_region(volume_ptr, vec![0xa2; 3]);
loaded.memory.add_region(channel_out_ptr, vec![0xa3; 3]);
loaded.memory.add_region(status_ptr, vec![0xa4; 7]);
loaded.memory.add_region(cmd_ptr, vec![0; 8]);
loaded.memory.add_region(rate_ptr, vec![0xa5; 3]);
loaded.memory.add_region(offset_ptr, vec![0xa6; 3]);
loaded.cpu.gpr[3] = version_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], version_ptr);
for offset in 0..3 {
assert_eq!(loaded.memory.read_u8(version_ptr + offset), Some(0xa1));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetDefaultOutputVolume;
loaded.cpu.gpr[3] = volume_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
for offset in 0..3 {
assert_eq!(loaded.memory.read_u8(volume_ptr + offset), Some(0xa2));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndNewChannel;
let initial_heap_cursor = loaded.heap_cursor();
loaded.set_last_mem_error(123);
loaded.cpu.gpr[3] = channel_out_ptr;
loaded.cpu.gpr[4] = 5;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert_eq!(loaded.heap_cursor(), initial_heap_cursor);
assert_eq!(loaded.last_mem_error(), 123);
for offset in 0..3 {
assert_eq!(loaded.memory.read_u8(channel_out_ptr + offset), Some(0xa3));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndChannelStatus;
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
loaded.cpu.gpr[4] = 8;
loaded.cpu.gpr[5] = status_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
for offset in 0..7 {
assert_eq!(loaded.memory.read_u8(status_ptr + offset), Some(0xa4));
}
loaded.memory.write_u16_be(cmd_ptr, 85).unwrap();
loaded.memory.write_u16_be(cmd_ptr + 2, 0).unwrap();
loaded.memory.write_u32_be(cmd_ptr + 4, rate_ptr).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndDoImmediate;
loaded.cpu.gpr[3] = PPC_HEAP_BASE;
loaded.cpu.gpr[4] = cmd_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
assert!(loaded.sound.immediate_commands.is_empty());
for offset in 0..3 {
assert_eq!(loaded.memory.read_u8(rate_ptr + offset), Some(0xa5));
}
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::GetSoundHeaderOffset;
loaded.cpu.gpr[3] = PPC_DATA_BASE + 0x7000;
loaded.cpu.gpr[4] = offset_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_PARAM_ERR));
for offset in 0..3 {
assert_eq!(loaded.memory.read_u8(offset_ptr + offset), Some(0xa6));
}
}
#[test]
fn hle_snd_do_command_decodes_external_extended_sound_header() {
let pef = synthetic_pef_with_import(b"SndDoCommand");
let mut loaded = load_pef_application(&pef).unwrap();
let channel = 0x0500_1000;
let cmd_ptr = PPC_DATA_BASE + 0x1000;
let header_ptr = cmd_ptr + 0x20;
let samples_ptr = cmd_ptr + 0x100;
let samples = [0x80, 0x90, 0x70, 0xa0];
loaded.memory.add_region(cmd_ptr, vec![0; 0x200]);
loaded.memory.write_u16_be(cmd_ptr, 81).unwrap(); loaded.memory.write_u32_be(cmd_ptr + 4, header_ptr).unwrap();
loaded.memory.write_u32_be(header_ptr, samples_ptr).unwrap();
loaded.memory.write_u32_be(header_ptr + 4, 1).unwrap();
loaded
.memory
.write_u32_be(header_ptr + 8, 22_050u32 << 16)
.unwrap();
loaded.memory.write_u8(header_ptr + 20, 0xff).unwrap(); loaded
.memory
.write_u32_be(header_ptr + 22, samples.len() as u32)
.unwrap();
loaded.memory.write_u16_be(header_ptr + 48, 8).unwrap();
loaded.memory.write_bytes(samples_ptr, &samples).unwrap();
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = cmd_ptr;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.sound.manager.debug_buffer_cmd_count, 1);
assert!(loaded
.sound
.manager
.channels
.iter()
.any(|candidate| candidate.guest_ptr == channel && candidate.has_active_playback()));
assert_eq!(
loaded.sound.queued_commands,
vec![PpcSndCommandRecord {
channel,
command: 81,
param1: 0,
param2: header_ptr,
}]
);
}
#[test]
fn hle_import_runner_tracks_sound_commands_and_file_playback() {
let pef = synthetic_pef_with_import(b"SndDoImmediate");
let mut loaded = load_pef_application(&pef).unwrap();
let channel = 0x0500_1000;
let cmd_ptr = PPC_DATA_BASE + 0x1000;
let rate_ptr = PPC_DATA_BASE + 0x1010;
loaded.memory.add_region(cmd_ptr, vec![0; 20]);
loaded.memory.write_u16_be(cmd_ptr, 85).unwrap(); loaded.memory.write_u16_be(cmd_ptr + 2, 0).unwrap();
loaded.memory.write_u32_be(cmd_ptr + 4, rate_ptr).unwrap();
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = cmd_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(rate_ptr), Some(0x0001_0000));
assert_eq!(
loaded.sound.immediate_commands,
vec![PpcSndCommandRecord {
channel,
command: 85,
param1: 0,
param2: rate_ptr,
}]
);
loaded.memory.write_u16_be(cmd_ptr, 80).unwrap(); loaded.memory.write_u16_be(cmd_ptr + 2, 0).unwrap();
loaded
.memory
.write_u32_be(cmd_ptr + 4, 0x0040_0040)
.unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndDoCommand;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = cmd_ptr;
loaded.cpu.gpr[5] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.sound.queued_commands,
vec![PpcSndCommandRecord {
channel,
command: 80,
param1: 0,
param2: 0x0040_0040,
}]
);
let path = "Data/Audio/Valid.aiff";
loaded.push_test_open_file(PpcFileRecord {
ref_num: 128,
path: path.to_string(),
position: 0,
});
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: path.to_string(),
data: aiff_header_api_fixture(false).into(),
creator: u32::from_be_bytes(*b"ttxt"),
file_type: u32::from_be_bytes(*b"AIFF"),
finder_flags: 0,
dirty: false,
});
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndStartFilePlay;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = 128u32;
loaded.cpu.gpr[5] = (-1i16) as u16 as u32;
loaded.cpu.gpr[6] = 20_480;
loaded.cpu.gpr[7] = PPC_DATA_BASE + 0x2000;
loaded.cpu.gpr[8] = PPC_DATA_BASE + 0x2100;
loaded.cpu.gpr[9] = PPC_CODE_BASE + 0x40;
loaded.cpu.gpr[10] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.sound.start_count, 1);
assert_eq!(
loaded.sound.file_playbacks.last().copied(),
Some(PpcSoundFilePlaybackRecord {
channel,
ref_num: 128,
resource_id: -1,
buffer_size: 20_480,
buffer: PPC_DATA_BASE + 0x2000,
selection: PPC_DATA_BASE + 0x2100,
completion: PPC_CODE_BASE + 0x40,
completion_command: None,
async_play: true,
aiff: Some(PpcAiffMetadata {
form_type: u32::from_be_bytes(*b"AIFF"),
channel_count: 2,
sample_frame_count: 2,
sample_size: 16,
sample_rate_hz: 22_051,
compression_type: u32::from_be_bytes(*b"NONE"),
sound_data_offset: 54,
sound_data_size: 8,
}),
decoded_aiff: Some(PpcDecodedAiffSamples {
sample_rate_fixed: (22_050u32 << 16) + 32_768,
sample_count: 2,
preview_len: 2,
preview: [128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
}),
})
);
let status_ptr = PPC_DATA_BASE + 0x3000;
loaded.memory.add_region(status_ptr, vec![0xaa; 22]);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndChannelStatus;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = 22;
loaded.cpu.gpr[5] = status_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(status_ptr + 12), Some(1));
assert_eq!(loaded.memory.read_u8(status_ptr + 14), Some(0));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndPauseFilePlay;
loaded.cpu.gpr[3] = channel;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.sound.pause_count, 1);
assert_eq!(
loaded.sound.manager.file_playback_paused(channel),
Some(true)
);
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndChannelStatus;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = 22;
loaded.cpu.gpr[5] = status_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u8(status_ptr + 12), Some(1));
assert_eq!(loaded.memory.read_u8(status_ptr + 14), Some(1));
loaded.cpu.pc = loaded.entry_pc;
loaded.imports[0].dispatcher_target = PpcImportDispatcherTarget::SndStopFilePlay;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.sound.stop_count, 1);
assert_eq!(loaded.sound.manager.file_playback_paused(channel), None);
}
#[test]
fn hle_import_runner_sound_completion_callback_populates_parameter_area() {
let pef = synthetic_pef();
let mut loaded = load_pef_application(&pef).unwrap();
let tvector = PPC_HEAP_BASE + 0x1000;
let callback_entry = PPC_HEAP_BASE + 0x1100;
let callback_rtoc = PPC_HEAP_BASE + 0x2000;
let channel = 0x0500_1234;
let callback_sp = ppc_interrupt_callback_stack_pointer(loaded.cpu.gpr[1]);
let command_ptr =
callback_sp + PPC_PARAMETER_AREA_OFFSET + PPC_NATIVE_PARAMETER_GPR_COUNT as u32 * 4;
let mut callback = Vec::new();
for word in [
d_form_u(36, 3, 2, 0),
d_form_u(36, 4, 2, 4),
d_form_u(32, 5, 1, PPC_PARAMETER_AREA_OFFSET as u16),
d_form_u(32, 6, 1, (PPC_PARAMETER_AREA_OFFSET + 7 * 4) as u16),
d_form_u(36, 5, 2, 8),
d_form_u(36, 6, 2, 12),
d_form_u(36, 1, 2, 16),
BLR,
] {
callback.extend_from_slice(&word.to_be_bytes());
}
loaded.memory.add_region(tvector, vec![0; 8]);
loaded.memory.add_region(callback_entry, callback);
loaded.memory.add_region(callback_rtoc, vec![0; 0x100]);
loaded.memory.write_u32_be(tvector, callback_entry).unwrap();
loaded
.memory
.write_u32_be(tvector + 4, callback_rtoc)
.unwrap();
for slot in 0..PPC_NATIVE_PARAMETER_GPR_COUNT {
let addr = ppc_parameter_area_slot_addr(callback_sp, slot).unwrap();
loaded
.memory
.write_u32_be(addr, 0xdead_1000 | u32::try_from(slot).unwrap())
.unwrap();
}
loaded.cpu.cr = 0x1234_5678;
loaded.cpu.lr = 0x8765_4321;
let saved_sp = loaded.cpu.gpr[1];
let red_zone_start = saved_sp - PPC_INTERRUPT_RED_ZONE_SIZE;
let red_zone = vec![0x5a; PPC_INTERRUPT_RED_ZONE_SIZE as usize];
loaded
.memory
.write_bytes(red_zone_start, &red_zone)
.unwrap();
let saved_rtoc = loaded.cpu.gpr[2];
let saved_cr = loaded.cpu.cr;
let saved_lr = loaded.cpu.lr;
loaded.cpu.gpr[4] = 0xfeed_face;
let probe = loaded.run_sound_completion_callback(
PpcSoundCompletionRecord {
file_playback_index: 3,
channel,
completion: tvector,
command: Some(PpcSndCommandRecord {
channel,
command: 13,
param1: 0x5348,
param2: 0x0200_0000,
}),
tick: 7,
instruction_count: 11,
scheduled_tick: 13,
scheduled_instruction_count: 17,
},
64,
false,
false,
);
assert!(matches!(
probe.invocation.result,
PpcRunResult::Halted {
pc: PPC_HALT_PC,
..
}
));
assert_eq!(probe.invocation.callback_entry, callback_entry);
assert_eq!(probe.invocation.callback_rtoc, callback_rtoc);
assert_eq!(probe.invocation.end_sp, callback_sp);
assert_eq!(probe.invocation.end_r3, channel);
assert_eq!(loaded.cpu.gpr[1], saved_sp);
assert_eq!(loaded.cpu.gpr[2], saved_rtoc);
assert_eq!(loaded.cpu.cr, saved_cr);
assert_eq!(loaded.cpu.lr, saved_lr);
assert_eq!(
ppc_memory_read_bytes(
&mut loaded.memory,
red_zone_start,
PPC_INTERRUPT_RED_ZONE_SIZE
),
Some(red_zone),
"an asynchronous native callback must preserve the interrupted leaf routine's Red Zone"
);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_BACK_CHAIN_OFFSET),
Some(saved_sp)
);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_SAVED_CR_OFFSET),
Some(saved_cr)
);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_SAVED_LR_OFFSET),
Some(saved_lr)
);
assert_eq!(
loaded
.memory
.read_u32_be(callback_sp + PPC_LINKAGE_SAVED_RTOC_OFFSET),
Some(saved_rtoc)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc), Some(channel));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 4),
Some(command_ptr)
);
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 8), Some(channel));
assert_eq!(loaded.memory.read_u32_be(callback_rtoc + 12), Some(0));
assert_eq!(
loaded.memory.read_u32_be(callback_rtoc + 16),
Some(callback_sp)
);
assert_eq!(
loaded
.memory
.read_u32_be(ppc_parameter_area_slot_addr(callback_sp, 0).unwrap()),
Some(channel)
);
assert_eq!(
loaded
.memory
.read_u32_be(ppc_parameter_area_slot_addr(callback_sp, 1).unwrap()),
Some(command_ptr)
);
assert_eq!(loaded.memory.read_u16_be(command_ptr), Some(13));
assert_eq!(loaded.memory.read_u16_be(command_ptr + 2), Some(0x5348));
assert_eq!(
loaded.memory.read_u32_be(command_ptr + 4),
Some(0x0200_0000)
);
assert_eq!(
loaded.memory.read_u32_be(
ppc_parameter_area_slot_addr(callback_sp, PPC_NATIVE_PARAMETER_GPR_COUNT - 1)
.unwrap()
),
Some(0)
);
}
#[test]
fn hle_import_runner_captures_aiff_metadata_for_sound_file_playback() {
let pef = synthetic_pef_with_import(b"SndStartFilePlay");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num = 128i16;
let channel = 0x0500_1000;
let path = "Data/Audio/TitleSong.aiff";
let mut aiff = vec![0; 60];
aiff[0..4].copy_from_slice(b"FORM");
write_u32(&mut aiff, 4, 52);
aiff[8..12].copy_from_slice(b"AIFF");
aiff[12..16].copy_from_slice(b"COMM");
write_u32(&mut aiff, 16, 18);
write_u16(&mut aiff, 20, 2);
write_u32(&mut aiff, 22, 1000);
write_u16(&mut aiff, 26, 16);
aiff[28..38].copy_from_slice(&[0x40, 0x0e, 0xac, 0x44, 0, 0, 0, 0, 0, 0]);
aiff[38..42].copy_from_slice(b"SSND");
write_u32(&mut aiff, 42, 14);
write_u32(&mut aiff, 46, 0);
write_u32(&mut aiff, 50, 0);
aiff[54..60].copy_from_slice(&[1, 2, 3, 4, 5, 6]);
loaded.push_test_open_file(PpcFileRecord {
ref_num,
path: path.to_string(),
position: 0,
});
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: path.to_string(),
data: (aiff).into(),
creator: u32::from_be_bytes(*b"ttxt"),
file_type: u32::from_be_bytes(*b"AIFF"),
finder_flags: 0,
dirty: false,
});
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = ref_num as u16 as u32;
loaded.cpu.gpr[5] = (-1i16) as u16 as u32;
loaded.cpu.gpr[6] = 20_480;
loaded.cpu.gpr[7] = PPC_DATA_BASE + 0x2000;
loaded.cpu.gpr[8] = 0;
loaded.cpu.gpr[9] = 0;
loaded.cpu.gpr[10] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(
loaded.sound.file_playbacks.last().unwrap().aiff,
Some(PpcAiffMetadata {
form_type: u32::from_be_bytes(*b"AIFF"),
channel_count: 2,
sample_frame_count: 1000,
sample_size: 16,
sample_rate_hz: 44_100,
compression_type: u32::from_be_bytes(*b"NONE"),
sound_data_offset: 54,
sound_data_size: 6,
})
);
let mut expected_preview = [0; 16];
expected_preview[0] = 130;
assert_eq!(
loaded.sound.file_playbacks.last().unwrap().decoded_aiff,
Some(PpcDecodedAiffSamples {
sample_rate_fixed: 44_100u32 << 16,
sample_count: 1,
preview_len: 1,
preview: expected_preview,
})
);
assert_eq!(loaded.sound.manager.debug_file_play_count, 1);
assert!(loaded
.sound
.manager
.channels
.iter()
.any(|candidate| candidate.guest_ptr == channel && candidate.has_active_playback()));
}
#[test]
fn hle_import_runner_decodes_snd_resource_for_file_playback() {
let pef = synthetic_pef_with_import(b"SndStartFilePlay");
for resource_id in [0i16, 200] {
let mut loaded = load_pef_application(&pef).unwrap();
let channel = 0x0500_1000;
let samples = [0x80, 0x90, 0x70, 0x80];
let mut resource = vec![0; 40];
write_u16(&mut resource, 0, 2); write_u16(&mut resource, 2, 0); write_u16(&mut resource, 4, 1); write_u16(&mut resource, 6, 0x8050); write_u16(&mut resource, 8, 0);
write_u32(&mut resource, 10, 14); write_u32(&mut resource, 14, 0); write_u32(&mut resource, 18, samples.len() as u32);
write_u32(&mut resource, 22, crate::sound::OUTPUT_RATE << 16);
write_u32(&mut resource, 26, 0); write_u32(&mut resource, 30, 0); resource[34] = 0; resource[35] = 60; resource[36..40].copy_from_slice(&samples);
let current_resource_refnum = *loaded.process_file_system.current_resource_file;
loaded
.process_file_system
.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current_resource_refnum,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"snd "),
res_id: resource_id,
name: b"Roar".to_vec(),
data: resource.into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = 0;
loaded.cpu.gpr[5] = resource_id as u16 as u32;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = 0;
loaded.cpu.gpr[9] = 0;
loaded.cpu.gpr[10] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.sound.start_count, 1);
let playback = loaded.sound.file_playbacks.last().unwrap();
assert_eq!(playback.channel, channel);
assert_eq!(playback.ref_num, 0);
assert_eq!(playback.resource_id, resource_id);
assert_eq!(playback.decoded_aiff.unwrap().sample_count, 4);
assert_eq!(
loaded.sound.decoded_file_playbacks,
vec![PpcDecodedAiffPlaybackRecord {
file_playback_index: 0,
channel,
sample_rate_fixed: crate::sound::OUTPUT_RATE << 16,
samples: samples.to_vec(),
}]
);
}
}
#[test]
fn ppc_snd_resource_decoder_expands_mace3_headers() {
let mut resource = vec![0; 80];
write_u16(&mut resource, 0, 2); write_u16(&mut resource, 2, 0);
write_u16(&mut resource, 4, 1);
write_u16(&mut resource, 6, 0x8051); write_u16(&mut resource, 8, 0);
write_u32(&mut resource, 10, 14);
write_u32(&mut resource, 14, 0); write_u32(&mut resource, 18, 1); write_u32(&mut resource, 22, crate::sound::OUTPUT_RATE << 16);
write_u32(&mut resource, 26, 0); write_u32(&mut resource, 30, 0); resource[34] = 0xfe; resource[35] = 60;
write_u32(&mut resource, 36, 1); write_u32(&mut resource, 54, u32::from_be_bytes(*b"MAC3"));
write_u16(&mut resource, 70, 3); write_u16(&mut resource, 72, 16); write_u16(&mut resource, 76, 8); resource[78] = 0;
resource[79] = 0;
let decoded = ppc_decode_snd_resource_samples(&resource).expect("MACE3 resource decodes");
assert_eq!(
decoded.summary.sample_rate_fixed,
crate::sound::OUTPUT_RATE << 16
);
assert_eq!(decoded.summary.sample_count, 6);
assert_eq!(decoded.samples, vec![0x80; 6]);
}
#[test]
fn hle_import_runner_handles_get_sound_header_offset() {
let pef = synthetic_pef_with_import(b"GetSoundHeaderOffset");
let mut loaded = load_pef_application(&pef).unwrap();
let mut resource = vec![0; 0x34];
write_u16(&mut resource, 0, 1);
write_u16(&mut resource, 2, 1);
write_u16(&mut resource, 4, 5);
write_u32(&mut resource, 6, 0);
write_u16(&mut resource, 10, 2);
write_u16(&mut resource, 12, 0);
write_u16(&mut resource, 14, 0);
write_u32(&mut resource, 16, 0);
write_u16(&mut resource, 20, 0x8051);
write_u16(&mut resource, 22, 0);
write_u32(&mut resource, 24, 0x28);
let handle = ppc_alloc_handle_with_bytes(
&mut loaded.memory,
test_heap_cursor!(loaded),
test_heap_limit!(loaded),
test_handles!(loaded),
&resource,
);
assert_ne!(handle, 0);
let offset_ptr = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(offset_ptr, vec![0xaa; 4]);
loaded.cpu.gpr[3] = handle;
loaded.cpu.gpr[4] = offset_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
assert_eq!(loaded.memory.read_u32_be(offset_ptr), Some(0x28));
}
#[test]
fn import_bindings_classify_sound_manager_volume_imports() {
assert_eq!(
dispatcher_target_for_import("SoundLib", "UnsignedFixedMulDiv"),
PpcImportDispatcherTarget::UnsignedFixedMulDiv
);
assert_eq!(
dispatcher_target_for_import("SoundLib", "GetSoundOutputInfo"),
PpcImportDispatcherTarget::GetSoundOutputInfo
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SysBeep"),
PpcImportDispatcherTarget::SysBeep
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetDefaultOutputVolume"),
PpcImportDispatcherTarget::GetDefaultOutputVolume
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SetDefaultOutputVolume"),
PpcImportDispatcherTarget::SetDefaultOutputVolume
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndNewChannel"),
PpcImportDispatcherTarget::SndNewChannel
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndDisposeChannel"),
PpcImportDispatcherTarget::SndDisposeChannel
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndChannelStatus"),
PpcImportDispatcherTarget::SndChannelStatus
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndDoImmediate"),
PpcImportDispatcherTarget::SndDoImmediate
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndDoCommand"),
PpcImportDispatcherTarget::SndDoCommand
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndPlayDoubleBuffer"),
PpcImportDispatcherTarget::SndPlayDoubleBuffer
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndStartFilePlay"),
PpcImportDispatcherTarget::SndStartFilePlay
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndPauseFilePlay"),
PpcImportDispatcherTarget::SndPauseFilePlay
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "SndStopFilePlay"),
PpcImportDispatcherTarget::SndStopFilePlay
);
assert_eq!(
dispatcher_target_for_import("InterfaceLib", "GetSoundHeaderOffset"),
PpcImportDispatcherTarget::GetSoundHeaderOffset
);
}
#[test]
fn sound_input_open_failure_clears_the_output_reference() {
let mut loaded = load_pef_application(&synthetic_pef_with_import(b"SPBOpenDevice")).unwrap();
let output = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(output, vec![0xaa; 4]);
loaded.cpu.gpr[5] = output;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.memory.read_u32_be(output), Some(0));
assert_eq!(
loaded.cpu.gpr[3],
ppc_i16_result(PPC_NOT_ENOUGH_HARDWARE_ERR)
);
}
#[test]
fn hle_import_runner_exposes_sound_driver_in_unit_table() {
let pef = synthetic_pef_with_import(b"LMGetUTableBase");
let mut loaded = load_pef_application(&pef).unwrap();
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.handled_import_count, 1);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], PPC_UNIT_TABLE);
assert_eq!(
loaded.memory.read_u32_be(PPC_UNIT_TABLE + 3 * 4),
Some(PPC_SOUND_DCE_HANDLE)
);
assert_eq!(
loaded.memory.read_u32_be(PPC_SOUND_DCE_HANDLE),
Some(PPC_SOUND_DCE)
);
assert_eq!(
loaded.memory.read_u16_be(PPC_SOUND_DCE + 24),
Some((-4i16) as u16)
);
}
#[test]
fn import_bindings_classify_speech_and_sound_input_imports() {
for (symbol, operation) in [
("CountVoices", PpcSpeechCompatibilityOperation::CountVoices),
(
"DisposeSpeechChannel",
PpcSpeechCompatibilityOperation::DisposeSpeechChannel,
),
("GetIndVoice", PpcSpeechCompatibilityOperation::GetIndVoice),
(
"GetVoiceDescription",
PpcSpeechCompatibilityOperation::GetVoiceDescription,
),
(
"NewSpeechChannel",
PpcSpeechCompatibilityOperation::NewSpeechChannel,
),
("SpeakString", PpcSpeechCompatibilityOperation::SpeakString),
("SpeakText", PpcSpeechCompatibilityOperation::SpeakText),
("SpeechBusy", PpcSpeechCompatibilityOperation::SpeechBusy),
] {
assert_eq!(
dispatcher_target_for_import("SpeechLib", symbol),
PpcImportDispatcherTarget::SpeechCompatibility(operation),
);
}
for (symbol, operation) in [
("SPBCloseDevice", PpcSoundInputCompatibilityOperation::CloseDevice),
("SPBGetDeviceInfo", PpcSoundInputCompatibilityOperation::GetDeviceInfo),
("SPBOpenDevice", PpcSoundInputCompatibilityOperation::OpenDevice),
("SPBRecord", PpcSoundInputCompatibilityOperation::Record),
("SPBSetDeviceInfo", PpcSoundInputCompatibilityOperation::SetDeviceInfo),
("SPBStopRecording", PpcSoundInputCompatibilityOperation::StopRecording),
] {
assert_eq!(
dispatcher_target_for_import("InterfaceLib", symbol),
PpcImportDispatcherTarget::SoundInputCompatibility(operation),
);
}
}
fn ima4_test_packet(fill: u8) -> Vec<u8> {
let mut packet = vec![fill; 34];
packet[0] = 0;
packet[1] = 0;
packet
}
#[test]
fn get_compression_info_fills_an_uninitialised_record() {
let mut loaded = load_pef_application(&synthetic_pef_with_library_import(
b"SoundLib",
b"GetCompressionInfo",
))
.unwrap();
let out = PPC_DATA_BASE + 0x3000;
let run = |loaded: &mut PpcLoadedApp, id: i16, format: &[u8; 4], channels: u32, bits: u32| {
loaded.memory.add_region(out, vec![0xaa; 20]);
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.lr = PPC_HALT_PC;
loaded.cpu.gpr[3] = id as u16 as u32;
loaded.cpu.gpr[4] = u32::from_be_bytes(*format);
loaded.cpu.gpr[5] = channels;
loaded.cpu.gpr[6] = bits;
loaded.cpu.gpr[7] = out;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
let fields = (0..8)
.map(|index| match index {
0 => loaded.memory.read_u32_be(out).unwrap(),
1 => loaded.memory.read_u32_be(out + 4).unwrap(),
_ => u32::from(loaded.memory.read_u16_be(out + 4 + index * 2).unwrap()),
})
.collect::<Vec<_>>();
(loaded.cpu.gpr[3], fields)
};
let (result, fields) = run(&mut loaded, -1, b"ima4", 2, 16);
assert_eq!(result, ppc_i16_result(PPC_NO_ERR));
assert_eq!(fields, vec![20, u32::from_be_bytes(*b"ima4"), 0xffff, 64, 34, 68, 2, 0]);
let (result, fields) = run(&mut loaded, 3, b"\0\0\0\0", 1, 8);
assert_eq!(result, ppc_i16_result(PPC_NO_ERR));
assert_eq!(fields, vec![20, u32::from_be_bytes(*b"MAC3"), 3, 6, 2, 2, 1, 0]);
let (result, fields) = run(&mut loaded, -1, b"ulaw", 1, 16);
assert_eq!(result, ppc_i16_result(PPC_NO_ERR));
assert_eq!(fields[3..7], [1, 1, 1, 2]);
let (result, _) = run(&mut loaded, -1, b"QDM2", 2, 16);
assert_eq!(result, ppc_i16_result(PPC_PARAM_ERR));
}
#[test]
fn ima4_and_mu_law_decode_through_the_sound_codec() {
assert_eq!(ppc_sound_codec(-1, u32::from_be_bytes(*b"ima4"), 16), Some(PpcSoundCodec::Ima4));
assert_eq!(ppc_sound_codec(0, 0, 16), Some(PpcSoundCodec::Pcm(16)));
assert_eq!(ppc_sound_codec(-1, u32::from_be_bytes(*b"QDM2"), 16), None);
let left = ima4_test_packet(0x77);
let right = ima4_test_packet(0xff);
let expected_left = ppc_qt_decode_ima4_channel_packet(&left).unwrap();
let expected_right = ppc_qt_decode_ima4_channel_packet(&right).unwrap();
let buffer = PPC_DATA_BASE + 0x4000;
let mut memory = PpcSectionMem::new();
let mut bytes = vec![0; 16];
bytes[0..4].copy_from_slice(&1u32.to_be_bytes());
bytes[4..8].copy_from_slice(&1u32.to_be_bytes());
bytes.extend_from_slice(&left);
bytes.extend_from_slice(&right);
memory.add_region(buffer, bytes);
let playback = PpcSoundDoubleBufferPlaybackRecord {
channel: 1,
header: 0,
buffers: [buffer, 0],
callback: 0,
callback_architecture: crate::callback_manager::CallbackTaskArchitecture::PowerPc,
sample_rate_fixed: 0,
num_channels: 2,
sample_size: 16,
compression_id: -1,
format: u32::from_be_bytes(*b"ima4"),
packet_size: 0,
current_buffer_index: 0,
callback_pending_mask: 0,
active: true,
host_initialized: true,
host_buffer_loaded: false,
};
let samples = ppc_decode_ready_double_buffer(&mut memory, playback).unwrap();
assert_eq!(samples.len(), 64);
let to_u8 = |sample: i16| ((i32::from(sample) >> 8) + 128) as u8;
assert_eq!(samples[63].left, to_u8(expected_left[63]));
assert_eq!(samples[63].right, to_u8(expected_right[63]));
assert!(samples[63].left > 0x80 && samples[63].right < 0x80);
let mut header = vec![0u8; 64];
header[4..8].copy_from_slice(&1u32.to_be_bytes());
header[8..12].copy_from_slice(&0x5622_0000u32.to_be_bytes());
header[20] = 0xfe;
header[22..26].copy_from_slice(&1u32.to_be_bytes());
header[40..44].copy_from_slice(b"ima4");
header[56..58].copy_from_slice(&(-1i16).to_be_bytes());
header[62..64].copy_from_slice(&16u16.to_be_bytes());
header.extend_from_slice(&left);
let decoded = ppc_decode_snd_header_at(&header, 0).unwrap();
assert_eq!(decoded.samples.len(), 64);
assert_eq!(decoded.samples[63], to_u8(expected_left[63]));
header[40..44].copy_from_slice(b"ulaw");
header.truncate(64);
header[22..26].copy_from_slice(&3u32.to_be_bytes());
header.extend_from_slice(&[0xff, 0x00, 0x80]);
let decoded = ppc_decode_snd_header_at(&header, 0).unwrap();
assert_eq!(decoded.samples, vec![0x80, 0x02, 0xfd]);
}
#[test]
fn sound_command_installs_a_sampled_sound_that_freq_command_plays() {
let pef = synthetic_pef_with_import(b"SndDoImmediate");
let mut loaded = load_pef_application(&pef).unwrap();
let channel = 0x0500_1000;
let cmd_ptr = PPC_DATA_BASE + 0x1000;
let header = PPC_DATA_BASE + 0x1100;
let samples = [0x80, 0xa0, 0x60, 0x80];
let mut bytes = vec![0u8; 22];
bytes[4..8].copy_from_slice(&(samples.len() as u32).to_be_bytes());
bytes[8..12].copy_from_slice(&0x5622_0000u32.to_be_bytes());
bytes[20] = 0x00; bytes[21] = 60; bytes.extend_from_slice(&samples);
loaded.memory.add_region(cmd_ptr, vec![0; 8]);
loaded.memory.add_region(header, bytes);
let immediate = |loaded: &mut PpcLoadedApp, command: u16, param2: u32| {
loaded.memory.write_u16_be(cmd_ptr, command).unwrap();
loaded.memory.write_u16_be(cmd_ptr + 2, 0).unwrap();
loaded.memory.write_u32_be(cmd_ptr + 4, param2).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = cmd_ptr;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
};
let playback_rate = |loaded: &PpcLoadedApp| {
loaded
.sound
.manager
.channels
.iter()
.find(|candidate| candidate.guest_ptr == channel)
.and_then(|candidate| candidate.playback_sample_rate())
};
immediate(&mut loaded, 80, header);
assert_eq!(playback_rate(&loaded), None);
let installed = loaded
.sound
.manager
.channels
.iter()
.find(|candidate| candidate.guest_ptr == channel)
.and_then(|candidate| candidate.instrument().cloned())
.expect("soundCmd installs a voice");
assert_eq!(installed.samples, samples);
assert_eq!(installed.base_note, 60);
immediate(&mut loaded, 42, 60);
assert_eq!(playback_rate(&loaded), Some(0x5622_0000));
immediate(&mut loaded, 3, 0); assert_eq!(playback_rate(&loaded), None);
immediate(&mut loaded, 40, 72); assert_eq!(playback_rate(&loaded), Some(0xAC44_0000));
immediate(&mut loaded, 3, 0);
immediate(&mut loaded, 42, 0x0100_0048);
assert_eq!(playback_rate(&loaded), Some(0x5622_0000));
immediate(&mut loaded, 3, 0);
loaded.memory.write_u8(header + 21, 200).unwrap();
immediate(&mut loaded, 80, header);
immediate(&mut loaded, 42, 72);
assert_eq!(playback_rate(&loaded), Some(0x5622_0000));
}
#[test]
fn queued_sound_command_installs_a_voice_that_a_queued_freq_command_plays() {
let pef = synthetic_pef_with_import(b"SndDoCommand");
let mut loaded = load_pef_application(&pef).unwrap();
let channel = 0x0500_1000;
let cmd_ptr = PPC_DATA_BASE + 0x1000;
let header = PPC_DATA_BASE + 0x1100;
let mut bytes = vec![0u8; 22];
bytes[4..8].copy_from_slice(&4u32.to_be_bytes());
bytes[8..12].copy_from_slice(&(crate::sound::OUTPUT_RATE << 16).to_be_bytes());
bytes[21] = 60;
bytes.extend_from_slice(&[0xC0; 4]);
loaded.memory.add_region(cmd_ptr, vec![0; 8]);
loaded.memory.add_region(header, bytes);
for (command, param2) in [(80u16, header), (42, 60)] {
loaded.memory.write_u16_be(cmd_ptr, command).unwrap();
loaded.memory.write_u16_be(cmd_ptr + 2, 0).unwrap();
loaded.memory.write_u32_be(cmd_ptr + 4, param2).unwrap();
loaded.cpu.pc = loaded.entry_pc;
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = cmd_ptr;
loaded.cpu.gpr[5] = 0;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(PPC_NO_ERR));
}
let mixed = loaded
.sound
.manager
.with_mut(|manager| manager.mix_frame(4));
assert_eq!(mixed, vec![0xC0; 4]);
}
fn compressed_aifc(compression: &[u8; 4], sample_size: u16, packets: u32, data: &[u8]) -> Vec<u8> {
let mut comm = Vec::new();
comm.extend_from_slice(&1u16.to_be_bytes());
comm.extend_from_slice(&packets.to_be_bytes());
comm.extend_from_slice(&sample_size.to_be_bytes());
comm.extend_from_slice(&[0x40, 0x0e, 0xac, 0x44, 0, 0, 0, 0, 0, 0]);
comm.extend_from_slice(compression);
comm.extend_from_slice(&[0, 0]); let mut body = b"AIFC".to_vec();
body.extend_from_slice(b"COMM");
body.extend_from_slice(&(comm.len() as u32).to_be_bytes());
body.extend_from_slice(&comm);
body.extend_from_slice(b"SSND");
body.extend_from_slice(&(8 + data.len() as u32).to_be_bytes());
body.extend_from_slice(&[0; 8]); body.extend_from_slice(data);
let mut file = b"FORM".to_vec();
file.extend_from_slice(&(body.len() as u32).to_be_bytes());
file.extend_from_slice(&body);
file
}
#[test]
fn file_playback_decodes_compressed_aifc_sound_data() {
let to_u8 = |sample: i16| ((i32::from(sample) >> 8) + 128) as u8;
let first = ima4_test_packet(0x77);
let second = ima4_test_packet(0xff);
let data = [first.as_slice(), second.as_slice()].concat();
let decoded = ppc_decode_aiff_samples(&compressed_aifc(b"ima4", 16, 3, &data))
.expect("IMA4 AIFF-C decodes");
let expected_first = ppc_qt_decode_ima4_channel_packet(&first).unwrap();
let expected_second = ppc_qt_decode_ima4_channel_packet(&second).unwrap();
assert_eq!(decoded.samples.len(), 128);
assert_eq!(decoded.samples[63], to_u8(expected_first[63]));
assert_eq!(decoded.samples[127], to_u8(expected_second[63]));
assert_eq!(decoded.summary.sample_rate_fixed, 44_100 << 16);
let mace = [0x12, 0x34, 0xa5, 0x5a];
let decoded = ppc_decode_aiff_samples(&compressed_aifc(b"MAC3", 8, 2, &mace))
.expect("MACE3 AIFF-C decodes");
assert_eq!(decoded.samples, crate::trap::decode_mace3_mono_to_u8(&mace));
assert_eq!(decoded.samples.len(), 12);
assert!(ppc_decode_aiff_samples(&compressed_aifc(b"QDM2", 16, 1, &first)).is_none());
}
#[test]
fn file_playback_rejects_a_data_fork_that_is_not_aiff() {
let pef = synthetic_pef_with_import(b"SndStartFilePlay");
let mut loaded = load_pef_application(&pef).unwrap();
let ref_num = 128i16;
let channel = 0x0500_1000;
let path = "Data/Audio/Notes.txt";
loaded.push_test_open_file(PpcFileRecord {
ref_num,
path: path.to_string(),
position: 0,
});
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: path.to_string(),
data: b"plain text, not a FORM".to_vec().into(),
creator: u32::from_be_bytes(*b"ttxt"),
file_type: u32::from_be_bytes(*b"TEXT"),
finder_flags: 0,
dirty: false,
});
loaded.cpu.gpr[3] = channel;
loaded.cpu.gpr[4] = ref_num as u16 as u32;
loaded.cpu.gpr[5] = 0;
loaded.cpu.gpr[6] = 0;
loaded.cpu.gpr[7] = 0;
loaded.cpu.gpr[8] = 0;
loaded.cpu.gpr[9] = PPC_DATA_BASE + 0x20;
loaded.cpu.gpr[10] = 1;
let probe = loaded.run_with_hle_imports(64);
assert_eq!(probe.unsupported_import_index, None);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(-208));
assert!(loaded.sound.file_playbacks.is_empty());
assert_eq!(loaded.sound.start_count, 0);
assert!(!loaded
.sound
.manager
.channels
.iter()
.any(|candidate| candidate.guest_ptr == channel && candidate.has_active_playback()));
}
#[test]
fn sound_file_playback_rejects_missing_sources_without_scheduling_completion() {
let pef = synthetic_pef_with_import(b"SndStartFilePlay");
let mut loaded = load_pef_application(&pef).unwrap();
loaded.push_test_open_file(PpcFileRecord {
ref_num: 128,
path: "Missing.aiff".to_string(),
position: 0,
});
let current = *loaded.process_file_system.current_resource_file;
loaded
.process_file_system
.push_vfs_resource(PpcVfsResourceRecord {
ref_num: current,
path: "Test App".to_string(),
res_type: u32::from_be_bytes(*b"snd "),
res_id: 7,
name: Vec::new(),
data: vec![0].into(),
raw_data: None,
raw_attrs: None,
attrs: 0,
handle: 0,
});
for (reference, resource, expected) in [
(0, 0, PPC_RES_PROBLEM),
(0, 1234, PPC_RES_PROBLEM),
(0, 7, PPC_BAD_FORMAT),
(222, 0, PPC_RF_NUM_ERR),
(128, 0, PPC_FNF_ERR),
] {
loaded.cpu.gpr[3] = 0x0500_1000;
loaded.cpu.gpr[4] = reference;
loaded.cpu.gpr[5] = resource;
loaded.cpu.gpr[9] = PPC_CODE_BASE + 0x80;
loaded.cpu.gpr[10] = 1;
run_test_import(&mut loaded, PpcImportDispatcherTarget::SndStartFilePlay);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(expected));
assert_eq!(loaded.sound.start_count, 0);
assert!(loaded.sound.file_playbacks.is_empty());
assert!(loaded.sound.decoded_file_playbacks.is_empty());
loaded.sound.manager.with_mut(|manager| {
manager.mix_frame(8);
assert_eq!(manager.debug_file_play_count, 0);
assert!(manager.pending_sound_callbacks.is_empty());
assert!(manager.channels.is_empty());
});
}
}
fn aiff_header_api_fixture(compressed: bool) -> Vec<u8> {
let mut data = b"FORM\0\0\0\0AIFF".to_vec();
if compressed {
data[8..12].copy_from_slice(b"AIFC");
}
data.extend_from_slice(b"COMM");
data.extend_from_slice(&(if compressed { 22u32 } else { 18u32 }).to_be_bytes());
data.extend_from_slice(&2u16.to_be_bytes());
data.extend_from_slice(&(if compressed { 1u32 } else { 2u32 }).to_be_bytes());
data.extend_from_slice(&16u16.to_be_bytes());
data.extend_from_slice(&[0x40, 0x0d, 0xac, 0x45, 0, 0, 0, 0, 0, 0]);
if compressed {
data.extend_from_slice(b"ima4FVER\0\0\0\x04\xa2\x80\x51\x40");
}
data.extend_from_slice(b"SSND");
let bytes = if compressed { 68u32 } else { 8u32 };
data.extend_from_slice(&(bytes + 8).to_be_bytes());
data.extend_from_slice(&[0; 8]);
data.resize(data.len() + bytes as usize, 0);
let size = data.len() as u32 - 8;
data[4..8].copy_from_slice(&size.to_be_bytes());
data
}
#[test]
fn parse_aiff_header_reports_pcm_and_compressed_metadata_without_decoding() {
for compressed in [false, true] {
let pef = synthetic_pef_with_library_import(b"SoundLib", b"ParseAIFFHeader");
let mut loaded = load_pef_application(&pef).unwrap();
assert_eq!(
loaded.imports[0].dispatcher_target,
PpcImportDispatcherTarget::ParseAIFFHeader
);
let data = aiff_header_api_fixture(compressed);
let path = "Audio/Test.aiff";
loaded.push_test_open_file(PpcFileRecord {
ref_num: 128,
path: path.into(),
position: 17,
});
loaded.push_test_vfs_file(PpcVfsFileRecord {
path: path.into(),
data: data.into(),
creator: 0,
file_type: 0,
finder_flags: 0,
dirty: false,
});
let info = PPC_DATA_BASE + 0x1000;
loaded.memory.add_region(info, vec![0xaa; 40]);
loaded.cpu.gpr[3] = 128;
loaded.cpu.gpr[4] = info;
loaded.cpu.gpr[5] = info + 28;
loaded.cpu.gpr[6] = info + 32;
run_test_import(&mut loaded, PpcImportDispatcherTarget::ParseAIFFHeader);
assert_eq!(loaded.cpu.gpr[3], 0);
assert_eq!(loaded.memory.read_u32_be(info), Some(0));
assert_eq!(
loaded.memory.read_u32_be(info + 4),
Some(u32::from_be_bytes(if compressed {
*b"ima4"
} else {
*b"twos"
}))
);
assert_eq!(loaded.memory.read_u16_be(info + 8), Some(2));
assert_eq!(loaded.memory.read_u16_be(info + 10), Some(16));
assert_eq!(loaded.memory.read_u32_be(info + 12), Some(0x5622_8000));
let frames = if compressed { 1 } else { 2 };
assert_eq!(loaded.memory.read_u32_be(info + 16), Some(frames));
assert_eq!(loaded.memory.read_u32_be(info + 20), Some(0));
assert_eq!(loaded.memory.read_u32_be(info + 24), Some(0));
assert_eq!(loaded.memory.read_u32_be(info + 28), Some(frames));
assert_eq!(
loaded.memory.read_u32_be(info + 32),
Some(if compressed { 70 } else { 54 })
);
assert_eq!(loaded.memory.read_u32_be(info + 36), Some(0xaaaa_aaaa));
for (refnum, out, error) in [
(999, info, PPC_RF_NUM_ERR),
(128, 0, PPC_PARAM_ERR),
(128, 0xffff_fffe, PPC_PARAM_ERR),
] {
loaded.memory.write_bytes(info, &[0xaa; 40]).unwrap();
loaded.cpu.gpr[3] = refnum;
loaded.cpu.gpr[4] = out;
loaded.cpu.gpr[5] = info + 28;
loaded.cpu.gpr[6] = info + 32;
run_test_import(&mut loaded, PpcImportDispatcherTarget::ParseAIFFHeader);
assert_eq!(loaded.cpu.gpr[3], ppc_i16_result(error));
assert_eq!(loaded.memory.read_u32_be(info + 28), Some(0xaaaa_aaaa));
assert_eq!(loaded.memory.read_u32_be(info + 32), Some(0xaaaa_aaaa));
}
}
}
#[test]
fn parse_aiff_header_rejects_malformed_forms_and_chunk_offsets() {
let valid = aiff_header_api_fixture(true);
assert!(ppc_parse_aiff_header_fields(&valid).is_some());
let mut malformed = vec![vec![], valid[..11].to_vec()];
for (at, bytes) in [
(4, vec![0xff; 4]),
(4, 4u32.to_be_bytes().to_vec()),
(16, 17u32.to_be_bytes().to_vec()),
(20, vec![0; 2]),
(26, vec![0; 2]),
(28, vec![0x80, 0x0d]),
(28, vec![0x7f, 0xff]),
(50, vec![0; 4]),
(58, u32::MAX.to_be_bytes().to_vec()),
(62, u32::MAX.to_be_bytes().to_vec()),
] {
let mut data = valid.clone();
data[at..at + bytes.len()].copy_from_slice(&bytes);
malformed.push(data);
}
let mut crossed = valid.clone();
crossed[4..8].copy_from_slice(&66u32.to_be_bytes());
malformed.push(crossed);
for data in malformed {
assert!(ppc_parse_aiff_header_fields(&data).is_none());
}
let mut trailing = valid;
trailing.extend_from_slice(b"ignored bytes outside FORM");
assert!(ppc_parse_aiff_header_fields(&trailing).is_some());
}