use std::convert::TryInto;
use nom::{
IResult, Parser,
branch::alt,
bytes::complete::{tag, take},
combinator::{cond, map, map_opt, opt, value, verify},
multi::count,
number::complete::{be_u32, le_u16, le_u32, u8},
};
fn chunk_data<'a>(size: u32) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], &'a [u8]> {
move |input| {
let (input, data) = take(size).parse(input)?;
let (input, _) = cond(size % 2 == 1, opt(take(1usize))).parse(input)?;
Ok((input, data))
}
}
fn plain_chunk<'a>(id: &'static str) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], (u32, &'a [u8])> {
move |input| {
let (input, _) = tag(id).parse(input)?;
let (input, size) = be_u32(input)?;
let (input, data) = chunk_data(size)(input)?;
Ok((input, (size, data)))
}
}
type CompressiblePayload<'a> = (bool, u32, &'a [u8]);
fn compressible_chunk<'a>(
prefix: &'static str,
) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], CompressiblePayload<'a>> {
move |input| {
let (input, _) = tag(prefix).parse(input)?;
let (input, compressed) =
alt((value(true, tag("Z")), value(false, tag("0")))).parse(input)?;
let (input, size) = be_u32(input)?;
let (input, data) = chunk_data(size)(input)?;
Ok((input, (compressed, size, data)))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RawChunk<'a> {
pub id: [u8; 4],
pub size: u32,
pub data: &'a [u8],
}
pub fn raw_chunk(input: &[u8]) -> IResult<&[u8], RawChunk<'_>> {
let (input, id) = verify(take(4usize), |id: &[u8]| {
id.iter()
.all(|b| b.is_ascii_uppercase() || b.is_ascii_digit())
})
.parse(input)?;
let (input, size) = be_u32(input)?;
let (input, data) = chunk_data(size)(input)?;
Ok((
input,
RawChunk {
id: id.try_into().expect("take(4) yields 4 bytes"),
size,
data,
},
))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FormChunk {
pub size: u32,
}
pub fn form_chunk(input: &[u8]) -> IResult<&[u8], FormChunk> {
let (input, _) = tag("FORM").parse(input)?;
let (input, size) = be_u32(input)?;
Ok((input, FormChunk { size }))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VQAVersion {
One,
Two,
Three,
}
pub fn vqa_version(input: &[u8]) -> IResult<&[u8], VQAVersion> {
map_opt(le_u16, |n| match n {
1 => Some(VQAVersion::One),
2 => Some(VQAVersion::Two),
3 => Some(VQAVersion::Three),
_ => None,
})
.parse(input)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VQAHeader {
pub version: VQAVersion,
pub flags: u16,
pub num_frames: u16,
pub width: u16,
pub height: u16,
pub block_width: u8,
pub block_height: u8,
pub frame_rate: u8,
pub cbparts: u8,
pub colors: u16,
pub maxblocks: u16,
pub unk1: u32,
pub unk2: u16,
pub freq: u16,
pub channels: u8,
pub bits: u8,
pub unk3: u32,
pub unk4: u16,
pub max_cbfz_size: u32,
pub unk5: u32,
}
impl VQAHeader {
pub fn sample_rate(&self) -> u32 {
match self.freq {
0 => 22050,
freq => u32::from(freq),
}
}
pub fn num_channels(&self) -> u8 {
match self.channels {
0 => 1,
channels => channels,
}
}
pub fn bit_depth(&self) -> u8 {
match self.bits {
0 => 8,
bits => bits,
}
}
pub fn has_sound(&self) -> bool {
self.flags & 1 != 0
}
pub fn is_hicolor(&self) -> bool {
self.colors == 0
}
}
pub fn vqa_header(input: &[u8]) -> IResult<&[u8], VQAHeader> {
let (input, _) = tag("VQHD").parse(input)?;
let (input, _) = verify(be_u32, |&size| size == 42).parse(input)?;
let (input, version) = vqa_version(input)?;
let (input, flags) = le_u16(input)?;
let (input, num_frames) = le_u16(input)?;
let (input, width) = le_u16(input)?;
let (input, height) = le_u16(input)?;
let (input, block_width) = u8(input)?;
let (input, block_height) = u8(input)?;
let (input, frame_rate) = u8(input)?;
let (input, cbparts) = u8(input)?;
let (input, colors) = le_u16(input)?;
let (input, maxblocks) = le_u16(input)?;
let (input, unk1) = le_u32(input)?;
let (input, unk2) = le_u16(input)?;
let (input, freq) = le_u16(input)?;
let (input, channels) = u8(input)?;
let (input, bits) = u8(input)?;
let (input, unk3) = le_u32(input)?;
let (input, unk4) = le_u16(input)?;
let (input, max_cbfz_size) = le_u32(input)?;
let (input, unk5) = le_u32(input)?;
Ok((
input,
VQAHeader {
version,
flags,
num_frames,
width,
height,
block_width,
block_height,
frame_rate,
cbparts,
colors,
maxblocks,
unk1,
unk2,
freq,
channels,
bits,
unk3,
unk4,
max_cbfz_size,
unk5,
},
))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FrameInfo {
pub offset: u32,
pub has_palette: bool,
}
const FINF_PALETTE_FLAG: u32 = 0x4000_0000;
pub fn frame_info(input: &[u8]) -> IResult<&[u8], FrameInfo> {
map(le_u32, |raw| FrameInfo {
offset: (raw & (FINF_PALETTE_FLAG - 1)) * 2,
has_palette: raw & FINF_PALETTE_FLAG != 0,
})
.parse(input)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FINFChunk {
pub size: u32,
pub frames: Vec<FrameInfo>,
}
pub fn finf_chunk(input: &[u8]) -> IResult<&[u8], FINFChunk> {
let (input, _) = tag("FINF").parse(input)?;
let (input, size) = be_u32(input)?;
let (input, frames) = count(frame_info, size as usize / 4).parse(input)?;
Ok((input, FINFChunk { size, frames }))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SND2Chunk<'a> {
pub size: u32,
pub data: &'a [u8],
}
pub fn snd2_chunk(input: &[u8]) -> IResult<&[u8], SND2Chunk<'_>> {
let (input, (size, data)) = plain_chunk("SND2")(input)?;
Ok((input, SND2Chunk { size, data }))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VQFRChunk<'a> {
pub size: u32,
pub data: &'a [u8],
}
pub fn vqfr_chunk(input: &[u8]) -> IResult<&[u8], VQFRChunk<'_>> {
let (input, (size, data)) = plain_chunk("VQFR")(input)?;
Ok((input, VQFRChunk { size, data }))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CBFChunk<'a> {
pub size: u32,
pub compressed: bool,
pub data: &'a [u8],
}
pub fn cbf_chunk(input: &[u8]) -> IResult<&[u8], CBFChunk<'_>> {
let (input, (compressed, size, data)) = compressible_chunk("CBF")(input)?;
Ok((
input,
CBFChunk {
size,
compressed,
data,
},
))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CBPChunk<'a> {
pub size: u32,
pub compressed: bool,
pub data: &'a [u8],
}
pub fn cbp_chunk(input: &[u8]) -> IResult<&[u8], CBPChunk<'_>> {
let (input, (compressed, size, data)) = compressible_chunk("CBP")(input)?;
Ok((
input,
CBPChunk {
size,
compressed,
data,
},
))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CPLChunk<'a> {
pub size: u32,
pub compressed: bool,
pub data: &'a [u8],
}
pub fn cpl_chunk(input: &[u8]) -> IResult<&[u8], CPLChunk<'_>> {
let (input, (compressed, size, data)) = compressible_chunk("CPL")(input)?;
Ok((
input,
CPLChunk {
size,
compressed,
data,
},
))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VPTChunk<'a> {
pub size: u32,
pub compressed: bool,
pub data: &'a [u8],
}
pub fn vpt_chunk(input: &[u8]) -> IResult<&[u8], VPTChunk<'_>> {
let (input, (compressed, size, data)) = compressible_chunk("VPT")(input)?;
Ok((
input,
VPTChunk {
size,
compressed,
data,
},
))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VPTRChunk<'a> {
pub size: u32,
pub compressed: bool,
pub data: &'a [u8],
}
pub fn vptr_chunk(input: &[u8]) -> IResult<&[u8], VPTRChunk<'_>> {
let (input, compressed) =
alt((value(false, tag("VPTR")), value(true, tag("VPRZ")))).parse(input)?;
let (input, size) = be_u32(input)?;
let (input, data) = chunk_data(size)(input)?;
Ok((
input,
VPTRChunk {
size,
compressed,
data,
},
))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VQFLChunk<'a> {
pub size: u32,
pub data: &'a [u8],
}
pub fn vqfl_chunk(input: &[u8]) -> IResult<&[u8], VQFLChunk<'_>> {
let (input, (size, data)) = plain_chunk("VQFL")(input)?;
Ok((input, VQFLChunk { size, data }))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SN2JChunk<'a> {
pub size: u32,
pub data: &'a [u8],
}
pub fn sn2j_chunk(input: &[u8]) -> IResult<&[u8], SN2JChunk<'_>> {
let (input, (size, data)) = plain_chunk("SN2J")(input)?;
Ok((input, SN2JChunk { size, data }))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn successfully_parses_form_chunk() {
let input = b"FORM\x00\x00\x00\x10trailing";
let res = form_chunk(input);
assert!(matches!(res, Ok((b"trailing", FormChunk { size: 16 }))));
}
#[test]
fn successfully_parses_vqa_version() {
assert!(matches!(
vqa_version(b"\x01\x00trailing"),
Ok((b"trailing", VQAVersion::One))
));
assert!(matches!(
vqa_version(b"\x02\x00trailing"),
Ok((b"trailing", VQAVersion::Two))
));
assert!(matches!(
vqa_version(b"\x03\x00trailing"),
Ok((b"trailing", VQAVersion::Three))
));
assert!(vqa_version(b"\x04\x00trailing").is_err());
}
#[test]
fn snd2_chunk_leaves_even_sized_payload_unpadded() {
let input = b"SND2\x00\x00\x00\x04abcdnext";
let (rest, chunk) = snd2_chunk(input).unwrap();
assert_eq!(chunk.size, 4);
assert_eq!(chunk.data, b"abcd");
assert_eq!(rest, b"next");
}
#[test]
fn snd2_chunk_consumes_pad_byte_after_odd_sized_payload() {
let input = b"SND2\x00\x00\x00\x03abc\x00next";
let (rest, chunk) = snd2_chunk(input).unwrap();
assert_eq!(chunk.size, 3);
assert_eq!(chunk.data, b"abc");
assert_eq!(rest, b"next");
}
#[test]
fn odd_sized_chunk_at_end_of_input_needs_no_pad_byte() {
let input = b"SND2\x00\x00\x00\x03abc";
let (rest, chunk) = snd2_chunk(input).unwrap();
assert_eq!(chunk.data, b"abc");
assert!(rest.is_empty());
}
#[test]
fn cbf_chunk_parses_both_variants_and_pads() {
let (rest, chunk) = cbf_chunk(b"CBFZ\x00\x00\x00\x03abc\x00next").unwrap();
assert!(chunk.compressed);
assert_eq!(chunk.data, b"abc");
assert_eq!(rest, b"next");
let (rest, chunk) = cbf_chunk(b"CBF0\x00\x00\x00\x04abcdnext").unwrap();
assert!(!chunk.compressed);
assert_eq!(chunk.data, b"abcd");
assert_eq!(rest, b"next");
}
#[test]
fn vqfr_chunk_consumes_pad_byte_after_odd_sized_payload() {
let (rest, chunk) = vqfr_chunk(b"VQFR\x00\x00\x00\x05abcde\x00next").unwrap();
assert_eq!(chunk.data, b"abcde");
assert_eq!(rest, b"next");
}
#[test]
fn raw_chunk_parses_any_id_and_pads() {
let (rest, chunk) = raw_chunk(b"LINF\x00\x00\x00\x03abc\x00next").unwrap();
assert_eq!(&chunk.id, b"LINF");
assert_eq!(chunk.data, b"abc");
assert_eq!(rest, b"next");
}
#[test]
fn raw_chunk_rejects_non_chunk_ids() {
assert!(raw_chunk(b"lin \x00\x00\x00\x00").is_err());
assert!(raw_chunk(b"\x00\x01\x02\x03\x00\x00\x00\x00").is_err());
}
#[test]
fn cbp_cpl_vpt_chunks_parse_both_variants() {
let (_, chunk) = cbp_chunk(b"CBPZ\x00\x00\x00\x02ab").unwrap();
assert!(chunk.compressed);
assert_eq!(chunk.data, b"ab");
let (_, chunk) = cpl_chunk(b"CPL0\x00\x00\x00\x03rgb\x00").unwrap();
assert!(!chunk.compressed);
assert_eq!(chunk.data, b"rgb");
let (_, chunk) = vpt_chunk(b"VPTZ\x00\x00\x00\x02ab").unwrap();
assert!(chunk.compressed);
assert_eq!(chunk.data, b"ab");
}
#[test]
fn vptr_chunk_parses_raw_and_compressed_ids() {
let (_, chunk) = vptr_chunk(b"VPTR\x00\x00\x00\x02ab").unwrap();
assert!(!chunk.compressed);
assert_eq!(chunk.data, b"ab");
let (_, chunk) = vptr_chunk(b"VPRZ\x00\x00\x00\x02ab").unwrap();
assert!(chunk.compressed);
assert!(vptr_chunk(b"VPTZ\x00\x00\x00\x02ab").is_err());
assert!(vpt_chunk(b"VPTR\x00\x00\x00\x02ab").is_err());
}
#[test]
fn vqfl_and_sn2j_chunks_parse() {
let (_, chunk) = vqfl_chunk(b"VQFL\x00\x00\x00\x04abcd").unwrap();
assert_eq!(chunk.data, b"abcd");
let (_, chunk) = sn2j_chunk(b"SN2J\x00\x00\x00\x04abcd").unwrap();
assert_eq!(chunk.data, b"abcd");
}
#[test]
fn finf_chunk_decodes_frame_positions() {
let mut input = b"FINF\x00\x00\x00\x08".to_vec();
input.extend(100u32.to_le_bytes());
input.extend((0x4000_0000u32 | 150).to_le_bytes());
let (_, chunk) = finf_chunk(&input).unwrap();
assert_eq!(
chunk.frames,
vec![
FrameInfo {
offset: 200,
has_palette: false
},
FrameInfo {
offset: 300,
has_palette: true
},
]
);
}
}