diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/classes/audio_clip.rs | 19 | ||||
| -rw-r--r-- | src/fmod.rs | 252 | ||||
| -rw-r--r-- | src/helper.rs | 7 | ||||
| -rw-r--r-- | src/lib.rs | 1 |
4 files changed, 269 insertions, 10 deletions
diff --git a/src/classes/audio_clip.rs b/src/classes/audio_clip.rs index 53a265f..a3e8d22 100644 --- a/src/classes/audio_clip.rs +++ b/src/classes/audio_clip.rs @@ -1,10 +1,11 @@ use super::streamed_resource::StreamedResource; use crate::{ + fmod::FmodSoundBank, object::{Value, parser::FromValue}, unityfs::UnityFS, }; -use anyhow::{Result, anyhow, bail}; -use log::info; +use anyhow::{Ok, Result, anyhow, bail}; +use log::{debug, info}; use serde::Serialize; use std::io::{Cursor, Read, Seek}; @@ -48,15 +49,13 @@ impl AudioClip { match self.compression_format { AudioCompressionFormat::Vorbis => { info!("reading vorbis FMOD sound bank"); - let bank = fsbex::Bank::new(Cursor::new(data))?; - assert_eq!(bank.format(), fsbex::AudioFormat::Vorbis); - assert_eq!(u32::from(bank.num_streams()), 1); - let stream = bank.into_iter().next().unwrap(); + let mut bank = FmodSoundBank::open(Cursor::new(data))?; + // Ok(buf.into_inner()) + for i in 0..bank.streams.len() { + let data = bank.read_stream(i)?; + } - let mut buf = Cursor::new(Vec::new()); - stream.write(&mut buf)?; - - Ok(buf.into_inner()) + Ok(Vec::new()) } x => todo!("audio format {x:?}"), } diff --git a/src/fmod.rs b/src/fmod.rs new file mode 100644 index 0000000..f0e7b4c --- /dev/null +++ b/src/fmod.rs @@ -0,0 +1,252 @@ +use crate::helper::ReadExt; +use anyhow::{Ok, Result, bail}; +use log::debug; +use std::io::{Cursor, Read, Seek, SeekFrom}; + +pub struct FmodSoundBank<T> { + inner: T, + data_base_offset: u64, + header: FsbHeader, + pub streams: Vec<StreamInfo>, +} + +pub struct StreamInfo { + header: StreamHeader, +} + +struct FsbHeader { + version: u32, + num_streams: u32, + stream_headers_size: u32, + name_table_size: u32, + data_size: u32, + format: FsbFormat, +} + +#[repr(u32)] +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum FsbFormat { + None, + Pcm8, + Pcm16, + Pcm24, + Pcm32, + PcmFloat, + GcAdPcm, + ImaAdPcm, + Vag, + HeVag, + Xma, + Mpeg, + Celt, + At9, + Xwma, + Vorbis, + FAdPcm, + Opus, +} + +impl FsbHeader { + pub fn read(mut f: impl Read) -> Result<Self> { + let mut buf = [0; 4]; + f.read_exact(&mut buf)?; + if &buf != b"FSB5" { + bail!("invalid magic") + } + + let version = f.read_u32_le()?; + let num_streams = f.read_u32_le()?; + let stream_headers_size = f.read_u32_le()?; + let name_table_size = f.read_u32_le()?; + let data_size = f.read_u32_le()?; + let format = FsbFormat::from_num(f.read_u32_le()?)?; + + debug!("FSB version: {version}"); + debug!("Sample Count: {num_streams}"); + debug!("Format: {format:?}"); + + f.discard(32)?; + + Ok(Self { + data_size, + format, + name_table_size, + num_streams, + stream_headers_size, + version, + }) + } +} + +impl FsbFormat { + pub fn from_num(x: u32) -> Result<Self> { + if x < 18 { + Ok(unsafe { std::mem::transmute(x) }) + } else { + bail!("audio format out of range") + } + } +} + +impl<T: Read + Seek> FmodSoundBank<T> { + pub fn open(mut file: T) -> Result<Self> { + let header = FsbHeader::read(&mut file)?; + let mut streams = Vec::new(); + + for _ in 0..header.num_streams { + let header = StreamHeader::from_packed(file.read_u64_le()?)?; + eprintln!("{header:?}"); + let mut next = header.next_chunk; + while next { + let chunk = ChunkHeader::from_packed(file.read_u32_le()?)?; + + match chunk.kind { + k => todo!("chunk kind {k:?}"), + } + + next = chunk.next_chunk; + } + streams.push(StreamInfo { header }); + } + + if header.name_table_size != 0 { + let mut offsets = Vec::new(); + for _ in 0..header.num_streams { + offsets.push(file.read_u32_le()?); + } + let mut buf = vec![0u8; header.name_table_size as usize]; + file.read_exact(&mut buf)?; + let mut buf = Cursor::new(buf); + let mut names = Vec::new(); + for o in offsets { + buf.seek(SeekFrom::Start(o as u64))?; + names.push(buf.read_cstr()?); + } + } + let data_base_offset = file.stream_position()?; + + Ok(Self { + data_base_offset, + header, + streams, + inner: file, + }) + } + pub fn read_stream(&mut self, n: usize) -> Result<()> { + let info = &self.streams[n]; + + let start = info.header.data_offset; + let end = self + .streams + .get(n + 1) + .map_or(self.header.data_size, |s| s.header.data_offset); + + let mut data = vec![0; (end - start) as usize]; + debug!("{} {}", start, end); + self.inner + .seek(SeekFrom::Start(start as u64 + self.data_base_offset))?; + self.inner.read_exact(&mut data)?; + + Ok(()) + } +} + +#[derive(Debug)] +struct StreamHeader { + next_chunk: bool, + samplerate: u32, + channels: u8, + data_offset: u32, + samples: u32, +} +impl StreamHeader { + const MASKS: &[u64] = &[ + 0b1000000000000000000000000000000000000000000000000000000000000000, + 0b0111100000000000000000000000000000000000000000000000000000000000, + 0b0000011000000000000000000000000000000000000000000000000000000000, + 0b0000000111111111111111111111111111000000000000000000000000000000, + 0b0000000000000000000000000000000000111111111111111111111111111111, + ]; + pub fn from_packed(x: u64) -> Result<Self> { + let next_chunk = x & Self::MASKS[0] != 0; + let samplerate_raw = (x & Self::MASKS[1]) >> Self::MASKS[1].trailing_zeros(); + let channels_raw = x & Self::MASKS[2] >> Self::MASKS[2].trailing_zeros(); + let data_offset = (x & Self::MASKS[3]) >> Self::MASKS[3].trailing_zeros(); + let samples = x & Self::MASKS[4]; + Ok(Self { + next_chunk, + samplerate: match samplerate_raw { + 0 => 4000, + 1 => 8000, + 2 => 11000, + 3 => 11025, + 4 => 16000, + 5 => 22050, + 6 => 24000, + 7 => 32000, + 8 => 44100, + 9 => 48000, + 10 => 96000, + x => bail!("invalid sampling frequency: {x}"), + }, + channels: match channels_raw { + 0 => 1, + 1 => 2, + 2 => 4, + 3 => 8, + x => bail!("invalid channel count: {x}"), + }, + data_offset: data_offset as u32 * 16, + samples: samples as u32, + }) + } +} + +struct ChunkHeader { + next_chunk: bool, + size: u32, + kind: ChunkKind, +} +impl ChunkHeader { + const MASKS: &[u32] = &[ + 0b10000000000000000000000000000000, + 0b01111111111111111111111110000000, + 0b00000000000000000000000001111111, + ]; + pub fn from_packed(x: u32) -> Result<Self> { + let next_chunk = x & Self::MASKS[0] != 0; + let size = (x & Self::MASKS[1]) >> Self::MASKS[1].trailing_zeros(); + let kind = x & Self::MASKS[2]; + Ok(Self { + kind: ChunkKind::from_num(kind as u8)?, + size, + next_chunk, + }) + } +} + +#[repr(u8)] +#[derive(Debug, Clone, Copy, PartialEq)] +enum ChunkKind { + Channels, + Samplerate, + Loop, + Comment, + XmaSeekTable, + DspCoefficients, + Atrac9Config, + XwmaConfig, + VorbisSeekTable, + PeakVolume, + VorbisIntraLayers, + OpusDataSize, +} +impl ChunkKind { + pub fn from_num(n: u8) -> Result<Self> { + if n < 13 { + Ok(unsafe { std::mem::transmute(n) }) + } else { + bail!("unknown chunk type {n:02x}") + } + } +} diff --git a/src/helper.rs b/src/helper.rs index 0681b62..18efa4e 100644 --- a/src/helper.rs +++ b/src/helper.rs @@ -36,6 +36,7 @@ pub trait ReadExt { fn read_f64_be(&mut self) -> Result<f64>; fn read_f64_le(&mut self) -> Result<f64>; fn read_cstr(&mut self) -> Result<String>; + fn discard(&mut self, n: usize) -> Result<()>; } impl<T: Read> ReadExt for T { @@ -192,6 +193,12 @@ impl<T: Read> ReadExt for T { } Ok(String::from_utf8_lossy(&s).to_string()) } + fn discard(&mut self, n: usize) -> Result<()> { + for _ in 0..n { + self.read_u8()?; + } + Ok(()) + } } pub trait AlignExt { @@ -6,3 +6,4 @@ pub mod object; pub mod serialized_file; pub mod unityfs; pub mod assetbundle; +pub mod fmod; |