488 lines
16 KiB
Rust
488 lines
16 KiB
Rust
use raptor_replica::audio::{DigitalSample, Mixer, MusScore};
|
|
use std::{fs, path::Path, process::Command};
|
|
|
|
fn instruments(double: bool) -> Vec<u8> {
|
|
let mut bytes = b"#OPL_II#".to_vec();
|
|
for n in 0..175 {
|
|
let mut instrument = [0u8; 36];
|
|
instrument[0] = if n == 1 {
|
|
1
|
|
} else if double {
|
|
4
|
|
} else {
|
|
0
|
|
};
|
|
instrument[2] = 128;
|
|
instrument[3] = 48;
|
|
for part in 0..2 {
|
|
let start = 4 + part * 16;
|
|
instrument[start..start + 6].copy_from_slice(&[0x21, 0xf2, 0x52, 0, 0, 32]);
|
|
instrument[start + 6] = 0;
|
|
instrument[start + 7..start + 13].copy_from_slice(&[0x21, 0xf2, 0x52, 0, 0, 0]);
|
|
}
|
|
bytes.extend(instrument);
|
|
}
|
|
bytes
|
|
}
|
|
fn mus(body: &[u8], channels: u16) -> Vec<u8> {
|
|
let mut bytes = b"MUS\x1a".to_vec();
|
|
bytes.extend((body.len() as u16).to_le_bytes());
|
|
bytes.extend(16u16.to_le_bytes());
|
|
bytes.extend(channels.to_le_bytes());
|
|
bytes.extend([0; 6]);
|
|
bytes.extend(body);
|
|
bytes
|
|
}
|
|
fn score() -> Vec<u8> {
|
|
mus(
|
|
&[
|
|
0x40, 0, 0, 0x90, 188, 100, 10, 0xa0, 144, 5, 0xc0, 3, 90, 5, 0x80, 60, 10, 0x60,
|
|
],
|
|
1,
|
|
)
|
|
}
|
|
fn sample(data: Vec<u8>) -> DigitalSample {
|
|
DigitalSample { rate: 11025, data }
|
|
}
|
|
fn patch(data: &[u8]) -> Vec<u8> {
|
|
let mut bytes = vec![3, 0];
|
|
bytes.extend(11025u16.to_le_bytes());
|
|
bytes.extend(((data.len() + 32) as u32).to_le_bytes());
|
|
bytes.extend([0xff; 16]);
|
|
bytes.extend(data);
|
|
bytes.extend([0; 16]);
|
|
bytes
|
|
}
|
|
fn mixer() -> Mixer {
|
|
Mixer::new(44100, &instruments(false)).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn digital_decoder_excludes_both_padding_regions() {
|
|
let decoded = DigitalSample::decode(&patch(&[0, 64, 128, 192, 255])).unwrap();
|
|
assert_eq!(decoded.rate, 11025);
|
|
assert_eq!(decoded.data, vec![0, 64, 128, 192, 255]);
|
|
assert!(DigitalSample::decode(&patch(&[])).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn music_events_start_on_the_first_seventy_hertz_service_tick() {
|
|
let mut mixer = mixer();
|
|
mixer.music_volume = 127;
|
|
mixer.play(MusScore::decode(&score()).unwrap(), false);
|
|
let mut prefix = vec![1; 630 * 2];
|
|
mixer.mix(&mut prefix);
|
|
assert!(prefix.iter().all(|n| *n == 0));
|
|
let mut following = vec![0; 3000 * 2];
|
|
mixer.mix(&mut following);
|
|
assert!(following.iter().any(|n| *n != 0));
|
|
}
|
|
|
|
#[test]
|
|
fn fm_and_digital_output_do_not_depend_on_audio_callback_size() {
|
|
let table = instruments(true);
|
|
let mut whole = Mixer::new(44117, &table).unwrap();
|
|
let mut chunked = Mixer::new(44117, &table).unwrap();
|
|
for m in [&mut whole, &mut chunked] {
|
|
m.play_with_fade(MusScore::decode(&score()).unwrap(), true, true);
|
|
m.sample(
|
|
sample((0..255).cycle().take(5000).collect()),
|
|
37,
|
|
192,
|
|
100,
|
|
1,
|
|
);
|
|
}
|
|
let mut expected = vec![0; 44117 * 2];
|
|
whole.mix(&mut expected);
|
|
let mut actual = vec![0; expected.len()];
|
|
let mut frame = 0;
|
|
for count in [1usize, 3, 17, 512, 127].into_iter().cycle() {
|
|
let count = count.min(actual.len() / 2 - frame);
|
|
chunked.mix(&mut actual[frame * 2..(frame + count) * 2]);
|
|
frame += count;
|
|
if frame == actual.len() / 2 {
|
|
break;
|
|
}
|
|
}
|
|
assert_eq!(actual, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn digital_mixing_uses_the_original_11025_hertz_sample_hold() {
|
|
let mut mixer = mixer();
|
|
mixer.fx_volume = 127;
|
|
mixer.sample(sample(vec![255, 255]), 128, 128, 127, 1);
|
|
let mut out = [0; 24];
|
|
mixer.mix(&mut out);
|
|
assert_eq!(&out[..6], &[0; 6]);
|
|
assert!(out[6] > 0 && out[7] > 0);
|
|
assert_eq!(&out[6..8], &out[8..10]);
|
|
assert_eq!(&out[6..8], &out[10..12]);
|
|
assert_eq!(&out[6..8], &out[12..14]);
|
|
assert_eq!(&out[22..24], &[0, 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn pitch_zero_is_a_valid_quarter_speed_pitch() {
|
|
let mut normal = mixer();
|
|
let mut slow = mixer();
|
|
normal.fx_volume = 127;
|
|
slow.fx_volume = 127;
|
|
normal.sample(sample(vec![255; 8]), 128, 128, 127, 1);
|
|
slow.sample(sample(vec![255; 8]), 128, 0, 127, 1);
|
|
let mut fast = [0; 100];
|
|
let mut quarter = [0; 100];
|
|
normal.mix(&mut fast);
|
|
slow.mix(&mut quarter);
|
|
assert!(fast[80..].iter().all(|v| *v == 0));
|
|
assert!(quarter[80..].iter().any(|v| *v > 0));
|
|
}
|
|
|
|
#[test]
|
|
fn lower_numeric_digital_priority_wins() {
|
|
let mut mixer = mixer();
|
|
mixer.fx_volume = 127;
|
|
mixer.set_fx_channels(1);
|
|
mixer.sample(sample(vec![255; 1000]), 128, 128, 127, 1);
|
|
mixer.sample(sample(vec![0; 1000]), 128, 128, 127, 8);
|
|
let mut protected = [0; 64];
|
|
mixer.mix(&mut protected);
|
|
assert!(protected[8..].iter().all(|v| *v > 0));
|
|
mixer.sample(sample(vec![0; 1000]), 128, 128, 127, 0);
|
|
let mut replaced = [0; 64];
|
|
mixer.mix(&mut replaced);
|
|
assert!(replaced[8..].iter().all(|v| *v < 0));
|
|
}
|
|
|
|
#[test]
|
|
fn digital_voices_clip_together_before_being_added_to_fm() {
|
|
let mut mixer = mixer();
|
|
mixer.fx_volume = 127;
|
|
mixer.set_fx_channels(8);
|
|
for _ in 0..8 {
|
|
mixer.sample(sample(vec![255; 100]), 128, 128, 127, 1);
|
|
}
|
|
let mut out = [0; 64];
|
|
mixer.mix(&mut out);
|
|
assert_eq!(out[20], 127 * 128);
|
|
assert_eq!(out[21], 127 * 128);
|
|
}
|
|
|
|
#[test]
|
|
fn changing_fx_volume_mutes_and_restores_already_playing_samples() {
|
|
let mut mixer = mixer();
|
|
mixer.fx_volume = 127;
|
|
mixer.sample(sample(vec![255; 4000]), 127, 128, 127, 0);
|
|
let mut before = [0; 128];
|
|
mixer.mix(&mut before);
|
|
assert!(before[16..].iter().all(|v| *v > 0));
|
|
mixer.fx_volume = 0;
|
|
let mut muted = [99; 256];
|
|
mixer.mix(&mut muted);
|
|
assert!(muted.iter().all(|v| *v == 0));
|
|
mixer.fx_volume = 127;
|
|
let mut restored = [0; 128];
|
|
mixer.mix(&mut restored);
|
|
assert!(restored[16..].iter().all(|v| *v > 0));
|
|
mixer.fx_volume = 32;
|
|
let mut reduced = [0; 128];
|
|
mixer.mix(&mut reduced);
|
|
assert!(reduced[16..].iter().all(|v| *v > 0));
|
|
assert!(reduced[16..].iter().max().unwrap() < &(restored[16..].iter().max().unwrap() / 2));
|
|
}
|
|
|
|
#[test]
|
|
fn music_mute_is_immediate_and_restores_an_active_score_without_muting_effects() {
|
|
let mut mixer = mixer();
|
|
mixer.music_volume = 127;
|
|
mixer.play(
|
|
MusScore::decode(&mus(&[0x90, 188, 100, 127, 0x60], 1)).unwrap(),
|
|
false,
|
|
);
|
|
let mut before = vec![0; 3000 * 2];
|
|
mixer.mix(&mut before);
|
|
assert!(before.iter().any(|v| *v != 0));
|
|
mixer.music_volume = 0;
|
|
let mut muted = [99; 512];
|
|
mixer.mix(&mut muted);
|
|
assert!(muted.iter().all(|v| *v == 0));
|
|
mixer.music_volume = 127;
|
|
let mut restored = vec![0; 3000 * 2];
|
|
mixer.mix(&mut restored);
|
|
assert!(restored.iter().any(|v| *v != 0));
|
|
mixer.music_volume = 0;
|
|
mixer.fx_volume = 127;
|
|
mixer.sample(sample(vec![255; 4000]), 127, 128, 127, 0);
|
|
mixer.mix(&mut muted);
|
|
assert!(muted[16..].iter().all(|v| *v > 0));
|
|
}
|
|
|
|
#[test]
|
|
fn bounded_capture_records_exact_callback_output_without_changing_it() {
|
|
let mut captured = mixer();
|
|
let mut normal = mixer();
|
|
captured.start_capture(1).unwrap();
|
|
assert!(normal.start_capture(0).is_err());
|
|
assert!(normal.start_capture(121).is_err());
|
|
for mixer in [&mut captured, &mut normal] {
|
|
mixer.fx_volume = 127;
|
|
mixer.sample(
|
|
sample((0..255).cycle().take(12000).collect()),
|
|
0,
|
|
128,
|
|
100,
|
|
0,
|
|
);
|
|
}
|
|
let mut actual = vec![0; 44100 * 4];
|
|
let mut expected = vec![0; actual.len()];
|
|
captured.mix(&mut actual);
|
|
normal.mix(&mut expected);
|
|
assert_eq!(actual, expected);
|
|
let capture = captured.take_capture().unwrap();
|
|
assert_eq!(capture.rate, 44100);
|
|
assert_eq!(capture.samples.len(), 44100 * 2);
|
|
assert_eq!(capture.samples, actual[..44100 * 2]);
|
|
assert!(capture.samples.chunks_exact(2).any(|s| s[0] != 0));
|
|
// Native DSP panning deliberately retains a small opposite-channel bleed.
|
|
let left: i64 = capture
|
|
.samples
|
|
.chunks_exact(2)
|
|
.map(|s| i64::from(s[0]).abs())
|
|
.sum();
|
|
let right: i64 = capture
|
|
.samples
|
|
.chunks_exact(2)
|
|
.map(|s| i64::from(s[1]).abs())
|
|
.sum();
|
|
assert!(left > right * 4);
|
|
let wav = raptor_replica::sound::encode_capture(&capture).unwrap();
|
|
assert_eq!(&wav[..4], b"RIFF");
|
|
assert_eq!(u16::from_le_bytes(wav[22..24].try_into().unwrap()), 2);
|
|
assert_eq!(
|
|
u32::from_le_bytes(wav[40..44].try_into().unwrap()),
|
|
44100 * 4
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_scores_controller_values_and_missing_end_events_are_rejected() {
|
|
for body in [
|
|
vec![0x90, 188],
|
|
vec![0x90, 188, 200, 1, 0x60],
|
|
vec![0xc0, 3, 255, 1, 0x60],
|
|
vec![0x30, 9, 0x60],
|
|
vec![0x90, 188, 127, 1],
|
|
] {
|
|
assert!(MusScore::decode(&mus(&body, 1)).is_err());
|
|
}
|
|
assert!(MusScore::decode(&mus(&[0x60], 16)).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn a_zero_duration_loop_and_an_odd_output_slice_terminate_cleanly() {
|
|
let mut mixer = mixer();
|
|
mixer.play(MusScore::decode(&mus(&[0x60], 1)).unwrap(), true);
|
|
let mut out = [99; 2001];
|
|
mixer.mix(&mut out);
|
|
assert_eq!(out[2000], 0);
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "requires the original untracked catalog"]
|
|
fn original_music_and_sound_assets_decode_locally() {
|
|
use raptor_replica::assets::Catalog;
|
|
let root = std::env::var_os("RAPTOR_TEST_DATA")
|
|
.map(std::path::PathBuf::from)
|
|
.unwrap_or_else(|| Path::new(env!("CARGO_MANIFEST_DIR")).join("../data"));
|
|
let catalog = Catalog::open(root).unwrap();
|
|
let mut music = 0;
|
|
let mut sounds = 0;
|
|
for entry in catalog.entries.values() {
|
|
let bytes = catalog.read(entry.id).unwrap();
|
|
if bytes.starts_with(b"MUS\x1a") {
|
|
MusScore::decode(&bytes).unwrap();
|
|
music += 1;
|
|
}
|
|
if bytes.get(..4) == Some(&[3, 0, 0x11, 0x2b]) {
|
|
DigitalSample::decode(&bytes).unwrap();
|
|
sounds += 1;
|
|
}
|
|
}
|
|
assert_eq!(music, 16);
|
|
assert_eq!(sounds, 26, "digital samples");
|
|
Mixer::new(44100, &catalog.named("GENMIDI_OP2").unwrap()).unwrap();
|
|
}
|
|
|
|
const NATIVE_REFERENCE: &str = r#"
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <vector>
|
|
#include <fstream>
|
|
#include <iterator>
|
|
#include "SDL.h"
|
|
#include "musapi.h"
|
|
#include "i_oplmusic.h"
|
|
#include "dspapi.h"
|
|
#include "cards.h"
|
|
int fx_freq=44100, gsshack=0, gssrate=0, sys_midi=0;
|
|
musdevice_t mus_device_alsa={}, mus_device_tsf={};
|
|
void SND_Lock(){} void SND_Unlock(){} void GSS_Service(){} void GSS_Poll(){}
|
|
extern "C" Uint32 SDL_GetTicks(){return 0;}
|
|
std::vector<char> read(const char *path){std::ifstream in(path,std::ios::binary);return {std::istreambuf_iterator<char>(in),{}};}
|
|
int main(int argc,char **argv){
|
|
if(argc!=9)return 2;
|
|
auto gen=read(argv[1]),score=read(argv[2]),patch=read(argv[3]);
|
|
int frames=std::atoi(argv[4]),mode=std::atoi(argv[5]),fade=std::atoi(argv[6]),loop=std::atoi(argv[7]);
|
|
std::vector<int16_t> out(frames*2,0);
|
|
if(mode!=1){LoadInstrumentTable(gen.data());MUS_Init(M_ADLIB,0);MUS_SetVolume(127);MUS_PlaySong(score.data(),loop,fade);}
|
|
if(mode!=0){DSP_Init(8,11025);DSP_StartPatch((dsp_t*)patch.data(),37,192,85,1);}
|
|
if(mode!=1)MUS_Mix(out.data(),frames);
|
|
if(mode!=0)DSP_Mix(out.data(),frames);
|
|
FILE *file=fopen(argv[8],"wb");if(!file)return 3;
|
|
fwrite(out.data(),sizeof(int16_t),out.size(),file);fclose(file);return 0;
|
|
}
|
|
"#;
|
|
|
|
#[test]
|
|
#[ignore = "requires g++ and SDL2 development headers; synthetic assets only"]
|
|
fn rust_fm_mus_and_digital_pcm_match_the_retained_native_reference() {
|
|
let temp = tempfile::tempdir().unwrap();
|
|
let binary = compile_reference(temp.path());
|
|
let patch_data: Vec<_> = (0..255).cycle().take(2000).collect();
|
|
let patch_path = temp.path().join("patch.bin");
|
|
fs::write(&patch_path, patch(&patch_data)).unwrap();
|
|
for (double, mode, fade, looping) in [
|
|
(false, 0, false, false),
|
|
(true, 0, false, false),
|
|
(false, 1, false, false),
|
|
(true, 2, true, true),
|
|
] {
|
|
let bank = instruments(double);
|
|
let song = score();
|
|
let frames = 44100;
|
|
let gen_path = temp.path().join("genmidi.bin");
|
|
fs::write(&gen_path, &bank).unwrap();
|
|
let score_path = temp.path().join("score.bin");
|
|
fs::write(&score_path, &song).unwrap();
|
|
let output = temp.path().join("reference.pcm");
|
|
let status = Command::new(&binary)
|
|
.arg(&gen_path)
|
|
.arg(&score_path)
|
|
.arg(&patch_path)
|
|
.arg(frames.to_string())
|
|
.arg(mode.to_string())
|
|
.arg(i32::from(fade).to_string())
|
|
.arg(i32::from(looping).to_string())
|
|
.arg(&output)
|
|
.status()
|
|
.unwrap();
|
|
assert!(status.success());
|
|
let expected = fs::read(output).unwrap();
|
|
let mut mixer = Mixer::new(44100, &bank).unwrap();
|
|
mixer.music_volume = 127;
|
|
mixer.fx_volume = 127;
|
|
mixer.set_fx_channels(8);
|
|
if mode != 1 {
|
|
mixer.play_with_fade(MusScore::decode(&song).unwrap(), looping, fade);
|
|
}
|
|
if mode != 0 {
|
|
mixer.sample(sample(patch_data.clone()), 37, 192, 85, 1);
|
|
}
|
|
let mut out = vec![0; frames * 2];
|
|
mixer.mix(&mut out);
|
|
let actual: Vec<_> = out.iter().flat_map(|v| v.to_le_bytes()).collect();
|
|
if let Some(index) = actual
|
|
.chunks_exact(2)
|
|
.zip(expected.chunks_exact(2))
|
|
.position(|(a, b)| a != b)
|
|
{
|
|
let want = i16::from_le_bytes(expected[index * 2..index * 2 + 2].try_into().unwrap());
|
|
panic!(
|
|
"PCM mismatch double={double} mode={mode} fade={fade} loop={looping}: frame={} channel={} got={} expected={want}",
|
|
index / 2,
|
|
index % 2,
|
|
out[index]
|
|
);
|
|
}
|
|
assert_eq!(actual.len(), expected.len());
|
|
}
|
|
}
|
|
|
|
fn compile_reference(directory: &Path) -> std::path::PathBuf {
|
|
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
|
|
let source = directory.join("reference.cpp");
|
|
fs::write(&source, NATIVE_REFERENCE).unwrap();
|
|
let binary = directory.join("reference");
|
|
let mut compile = Command::new("g++");
|
|
compile
|
|
.args(["-std=c++17", "-O2"])
|
|
.arg("-I")
|
|
.arg(root.join("../raptor/src"));
|
|
compile.arg("-I").arg("/usr/include/SDL2");
|
|
if let Some(home) = std::env::var_os("HOME") {
|
|
compile
|
|
.arg("-I")
|
|
.arg(Path::new(&home).join(".local/include/SDL2"));
|
|
}
|
|
compile.arg(&source);
|
|
for path in ["i_oplmusic.cpp", "opl3.cpp", "musapi.cpp", "dspapi.cpp"] {
|
|
compile.arg(root.join("../raptor/src").join(path));
|
|
}
|
|
let result = compile.arg("-o").arg(&binary).output().unwrap();
|
|
assert!(
|
|
result.status.success(),
|
|
"{}",
|
|
String::from_utf8_lossy(&result.stderr)
|
|
);
|
|
binary
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "requires original untracked music assets, g++ and SDL2 headers"]
|
|
fn original_intro_pcm_matches_the_retained_native_reference() {
|
|
use raptor_replica::assets::Catalog;
|
|
let temp = tempfile::tempdir().unwrap();
|
|
let root = std::env::var_os("RAPTOR_TEST_DATA")
|
|
.map(std::path::PathBuf::from)
|
|
.unwrap_or_else(|| Path::new(env!("CARGO_MANIFEST_DIR")).join("../data"));
|
|
let catalog = Catalog::open(root).unwrap();
|
|
let bank = catalog.named("GENMIDI_OP2").unwrap();
|
|
let song = catalog.named("RINTRO_MUS").unwrap();
|
|
let binary = compile_reference(temp.path());
|
|
fs::write(temp.path().join("genmidi.bin"), &bank).unwrap();
|
|
fs::write(temp.path().join("score.bin"), &song).unwrap();
|
|
fs::write(temp.path().join("patch.bin"), patch(&[128; 33])).unwrap();
|
|
let frames = 44100 * 4;
|
|
let output = temp.path().join("reference.pcm");
|
|
let status = Command::new(binary)
|
|
.arg(temp.path().join("genmidi.bin"))
|
|
.arg(temp.path().join("score.bin"))
|
|
.arg(temp.path().join("patch.bin"))
|
|
.arg(frames.to_string())
|
|
.args(["0", "1", "1"])
|
|
.arg(&output)
|
|
.status()
|
|
.unwrap();
|
|
assert!(status.success());
|
|
let expected = fs::read(output).unwrap();
|
|
let mut mixer = Mixer::new(44100, &bank).unwrap();
|
|
mixer.music_volume = 127;
|
|
mixer.play_with_fade(MusScore::decode(&song).unwrap(), true, true);
|
|
let mut actual = vec![0i16; frames * 2];
|
|
mixer.mix(&mut actual);
|
|
for (index, (got, bytes)) in actual.iter().zip(expected.chunks_exact(2)).enumerate() {
|
|
let want = i16::from_le_bytes(bytes.try_into().unwrap());
|
|
assert_eq!(
|
|
*got,
|
|
want,
|
|
"original intro frame {} channel {}",
|
|
index / 2,
|
|
index % 2
|
|
);
|
|
}
|
|
assert_eq!(actual.len() * 2, expected.len());
|
|
}
|