169 lines
3.6 KiB
Rust
169 lines
3.6 KiB
Rust
//! Marathon Sounds format handling.
|
|
|
|
use crate::durandal::{bin::*, err::*, fixed::*, sound::*};
|
|
use bitflags::bitflags;
|
|
use serde::Serialize;
|
|
use std::collections::HashMap;
|
|
|
|
fn sound(b: &[u8]) -> ResultS<Sound16>
|
|
{
|
|
read_data! {
|
|
21, BE in b =>
|
|
len = u32[4] as usize;
|
|
rate = u16[8];
|
|
lp_beg = u32[12] as usize;
|
|
lp_end = u32[16] as usize;
|
|
magic = u8[20];
|
|
}
|
|
|
|
match magic {
|
|
0 => {
|
|
let stream = &b[22..22 + len];
|
|
Ok(Sound16::new_from_8(rate, lp_beg, lp_end, stream))
|
|
}
|
|
0xFF => {
|
|
read_data! {
|
|
63, BE in b =>
|
|
len = u32[22] as usize;
|
|
bps = u16[48];
|
|
}
|
|
|
|
match bps {
|
|
16 => {
|
|
let stream = &b[63..63 + len * 2];
|
|
Ok(Sound16::new_from_16(rate, lp_beg, lp_end, stream))
|
|
}
|
|
8 => {
|
|
let stream = &b[63..63 + len];
|
|
Ok(Sound16::new_from_8(rate, lp_beg, lp_end, stream))
|
|
}
|
|
_ => bail!("bad bits per sample"),
|
|
}
|
|
}
|
|
_ => bail!("invalid magic number"),
|
|
}
|
|
}
|
|
|
|
fn sound_def(b: &[u8]) -> ResultS<Option<(Vec<usize>, u16, SoundDef)>>
|
|
{
|
|
read_data! {
|
|
64, BE in b =>
|
|
index = u16[0];
|
|
volume = u16[2];
|
|
flags = u16[4];
|
|
chance = u16[6];
|
|
pitch_lo = u32[8];
|
|
pitch_hi = u32[12];
|
|
n_sounds = u16[16] as usize;
|
|
grp_ofs = u32[20] as usize;
|
|
}
|
|
|
|
let flags = ok!(SoundFlags::from_bits(flags), "bad SoundFlags")?;
|
|
let volume = Volume::from_repr(volume)?;
|
|
let pitch_lo = Fixed::from_bits(pitch_lo);
|
|
let pitch_hi = Fixed::from_bits(pitch_hi);
|
|
|
|
if index == u16::max_value() {
|
|
return Ok(None);
|
|
}
|
|
|
|
if n_sounds > 5 {
|
|
bail!("too many sounds");
|
|
}
|
|
|
|
let mut ofs = Vec::with_capacity(n_sounds);
|
|
let mut p = 36;
|
|
|
|
for _ in 0..n_sounds {
|
|
ofs.push(grp_ofs + u32b(&b[p..]) as usize);
|
|
p += 4;
|
|
}
|
|
|
|
let header = SoundHead{volume, flags, chance, pitch_lo, pitch_hi};
|
|
let sounds = Vec::with_capacity(n_sounds);
|
|
|
|
Ok(Some((ofs, index, SoundDef{header, sounds})))
|
|
}
|
|
|
|
pub fn read_sounds(b: &[u8]) -> ResultS<Vec<SoundTable>>
|
|
{
|
|
read_data! {
|
|
260, BE in b =>
|
|
version = u32[0];
|
|
magic = iden[4];
|
|
src_num = u16[8] as usize;
|
|
snd_num = u16[10] as usize;
|
|
}
|
|
|
|
if version != 1 || magic != *b"snd2" {
|
|
bail!("bad sound header");
|
|
}
|
|
|
|
let mut sc = Vec::with_capacity(src_num);
|
|
let mut p = 260;
|
|
|
|
for _ in 0..src_num {
|
|
let mut st = HashMap::with_capacity(snd_num);
|
|
|
|
for _ in 0..snd_num {
|
|
if let Some((ofs, idx, mut def)) = sound_def(&b[p..p + 64])? {
|
|
for &ofs in &ofs {
|
|
def.sounds.push(sound(&b[ofs..])?);
|
|
}
|
|
|
|
st.insert(idx, def);
|
|
}
|
|
|
|
p += 64;
|
|
}
|
|
|
|
sc.push(st);
|
|
}
|
|
|
|
Ok(sc)
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct SoundHead
|
|
{
|
|
pub volume: Volume,
|
|
pub flags: SoundFlags,
|
|
pub chance: u16,
|
|
pub pitch_lo: Fixed,
|
|
pub pitch_hi: Fixed,
|
|
}
|
|
|
|
pub struct SoundDef
|
|
{
|
|
pub header: SoundHead,
|
|
pub sounds: Vec<Sound16>,
|
|
}
|
|
|
|
pub type SoundTable = HashMap<u16, SoundDef>;
|
|
|
|
bitflags! {
|
|
#[derive(Serialize)]
|
|
pub struct SoundFlags: u16
|
|
{
|
|
const NoRestart = 1;
|
|
const NoChannelSwitch = 1 << 1;
|
|
const LessPitchChange = 1 << 2;
|
|
const NoPitchChange = 1 << 3;
|
|
const NoObstruction = 1 << 4;
|
|
const NoMediaObstruct = 1 << 5;
|
|
const Ambient = 1 << 6;
|
|
}
|
|
}
|
|
|
|
c_enum! {
|
|
#[derive(Debug, Serialize)]
|
|
pub enum Volume: u16
|
|
{
|
|
0 => Quiet,
|
|
1 => Normal,
|
|
2 => Loud,
|
|
}
|
|
}
|
|
|
|
// EOF
|