use crate::codec::FourCc;
use crate::error::DecodeError;
pub(crate) const RIFF: FourCc = FourCc(*b"RIFF");
pub(crate) const RF64: FourCc = FourCc(*b"RF64");
pub(crate) const WAVE: FourCc = FourCc(*b"WAVE");
pub(crate) const DS64: FourCc = FourCc(*b"ds64");
pub(crate) const FMT: FourCc = FourCc(*b"fmt ");
pub(crate) const DATA: FourCc = FourCc(*b"data");
pub(crate) const SIZE_SENTINEL: u32 = u32::MAX;
pub(crate) const MAX_DS64_BYTES: u64 = 65_536;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ByteOrder {
Little,
Big,
}
pub(crate) const fn pad_len(size: u64) -> u64 {
size & 1
}
pub(crate) fn u16_at(bytes: &[u8], at: usize) -> Option<u16> {
let field = bytes.get(at..at.checked_add(2)?)?;
Some(u16::from_le_bytes([field[0], field[1]]))
}
pub(crate) fn u16_be_at(bytes: &[u8], at: usize) -> Option<u16> {
let field = bytes.get(at..at.checked_add(2)?)?;
Some(u16::from_be_bytes([field[0], field[1]]))
}
pub(crate) fn u32_at(bytes: &[u8], at: usize) -> Option<u32> {
let field = bytes.get(at..at.checked_add(4)?)?;
Some(u32::from_le_bytes([field[0], field[1], field[2], field[3]]))
}
pub(crate) fn u32_be_at(bytes: &[u8], at: usize) -> Option<u32> {
let field = bytes.get(at..at.checked_add(4)?)?;
Some(u32::from_be_bytes([field[0], field[1], field[2], field[3]]))
}
pub(crate) fn u32_at_in(bytes: &[u8], at: usize, order: ByteOrder) -> Option<u32> {
match order {
ByteOrder::Little => u32_at(bytes, at),
ByteOrder::Big => u32_be_at(bytes, at),
}
}
pub(crate) fn four_cc_at(bytes: &[u8], at: usize) -> Option<FourCc> {
let field = bytes.get(at..at.checked_add(4)?)?;
Some(FourCc([field[0], field[1], field[2], field[3]]))
}
fn u64_at(bytes: &[u8], at: usize) -> Option<u64> {
let low = u32_at(bytes, at)?;
let high = u32_at(bytes, at.checked_add(4)?)?;
Some(u64::from(low) | (u64::from(high) << 32))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct RiffHeader {
pub(crate) magic: FourCc,
pub(crate) form: FourCc,
}
pub(crate) const HEADER_BYTES: u64 = 12;
pub(crate) const CHUNK_HEADER_BYTES: u64 = 8;
pub(crate) fn read_riff_header(bytes: &[u8]) -> Result<RiffHeader, DecodeError> {
let (Some(magic), Some(form)) = (four_cc_at(bytes, 0), four_cc_at(bytes, 8)) else {
return Err(DecodeError::Truncated {
expected: HEADER_BYTES,
available: bytes.len() as u64,
});
};
if magic != RIFF && magic != RF64 {
return Err(DecodeError::UnsupportedContainer { tag: magic });
}
Ok(RiffHeader { magic, form })
}
pub(crate) fn parse_ds64(body: &[u8], offset: u64) -> Result<Vec<(FourCc, u64)>, DecodeError> {
const FIXED_BYTES: usize = 28;
const ENTRY_BYTES: u64 = 12;
let (Some(data_size), Some(table_length)) = (u64_at(body, 8), u32_at(body, 24)) else {
return Err(DecodeError::Malformed {
expected: "a ds64 chunk of at least 28 bytes",
offset,
});
};
let declared = u64::from(table_length)
.checked_mul(ENTRY_BYTES)
.and_then(|table| table.checked_add(FIXED_BYTES as u64));
if declared.is_none_or(|needed| needed > body.len() as u64) {
return Err(DecodeError::Malformed {
expected: "a ds64 table length that fits the ds64 chunk",
offset,
});
}
let count = table_length as usize;
let mut overrides = Vec::with_capacity(count + 1);
overrides.push((DATA, data_size));
for entry in 0..count {
let at = FIXED_BYTES + entry * ENTRY_BYTES as usize;
let (Some(id), Some(size)) = (four_cc_at(body, at), u64_at(body, at + 4)) else {
return Err(DecodeError::Malformed {
expected: "a ds64 table length that fits the ds64 chunk",
offset,
});
};
overrides.push((id, size));
}
Ok(overrides)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Chunk<'a> {
pub(crate) id: FourCc,
pub(crate) offset: u64,
pub(crate) body: &'a [u8],
}
#[derive(Debug)]
pub(crate) struct ChunkWalker<'a> {
bytes: &'a [u8],
offset: usize,
order: ByteOrder,
overrides: Vec<(FourCc, u64)>,
finished: bool,
}
impl<'a> ChunkWalker<'a> {
pub(crate) fn new(bytes: &'a [u8], order: ByteOrder) -> Self {
Self {
bytes,
offset: HEADER_BYTES as usize,
order,
overrides: Vec::new(),
finished: bytes.len() < HEADER_BYTES as usize,
}
}
pub(crate) fn set_overrides(&mut self, overrides: Vec<(FourCc, u64)>) {
self.overrides = overrides;
}
}
pub(crate) fn resolve_size(overrides: &[(FourCc, u64)], id: FourCc, declared: u32) -> u64 {
if declared == SIZE_SENTINEL {
if let Some((_, size)) = overrides.iter().find(|(name, _)| *name == id) {
return *size;
}
}
u64::from(declared)
}
impl<'a> Iterator for ChunkWalker<'a> {
type Item = Result<Chunk<'a>, DecodeError>;
fn next(&mut self) -> Option<Self::Item> {
if self.finished {
return None;
}
let total = self.bytes.len() as u64;
let offset = self.offset as u64;
if total - offset < CHUNK_HEADER_BYTES {
self.finished = true;
return None;
}
let (Some(id), Some(declared)) = (
four_cc_at(self.bytes, self.offset),
u32_at_in(self.bytes, self.offset + 4, self.order),
) else {
self.finished = true;
return None;
};
let size = resolve_size(&self.overrides, id, declared);
let body_start = self.offset + CHUNK_HEADER_BYTES as usize;
let available = total - body_start as u64;
if size > available {
self.finished = true;
return Some(Err(DecodeError::Truncated {
expected: size,
available,
}));
}
let Ok(size) = usize::try_from(size) else {
self.finished = true;
return Some(Err(DecodeError::Truncated {
expected: available,
available,
}));
};
let body = &self.bytes[body_start..body_start + size];
self.offset = (body_start + size)
.saturating_add(pad_len(size as u64) as usize)
.min(self.bytes.len());
Some(Ok(Chunk { id, offset, body }))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn chunk(id: &[u8; 4], body: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(id);
out.extend_from_slice(&(body.len() as u32).to_le_bytes());
out.extend_from_slice(body);
if body.len() % 2 == 1 {
out.push(0);
}
out
}
fn riff(magic: &[u8; 4], chunks: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(magic);
out.extend_from_slice(&(4 + chunks.len() as u32).to_le_bytes());
out.extend_from_slice(b"WAVE");
out.extend_from_slice(chunks);
out
}
fn ids(bytes: &[u8]) -> Vec<FourCc> {
ChunkWalker::new(bytes, ByteOrder::Little)
.map(|chunk| chunk.expect("walk").id)
.collect()
}
#[test]
fn a_short_input_is_truncated_rather_than_an_invented_tag() {
for length in 0..12 {
let error = read_riff_header(&vec![b'R'; length]).expect_err("must reject");
assert!(
matches!(error, DecodeError::Truncated { expected: 12, available } if available == length as u64),
"{length} bytes: unexpected error: {error}"
);
}
}
#[test]
fn an_unknown_magic_names_the_bytes_it_saw() {
let bytes = riff(b"FORM", b"");
let error = read_riff_header(&bytes).expect_err("must reject");
assert!(
matches!(error, DecodeError::UnsupportedContainer { tag } if tag == FourCc(*b"FORM")),
"unexpected error: {error}"
);
assert_eq!(
read_riff_header(&riff(b"RIFF", b"")).expect("RIFF").magic,
RIFF
);
assert_eq!(
read_riff_header(&riff(b"RF64", b"")).expect("RF64").magic,
RF64
);
}
#[test]
fn the_declared_riff_size_is_reported_and_never_acted_on() {
let body = [chunk(b"one ", &[1, 2, 3, 4]), chunk(b"two ", &[5, 6])].concat();
let truthful = riff(b"RIFF", &body);
let mut under = truthful.clone();
under[4..8].copy_from_slice(&4u32.to_le_bytes());
let mut over = truthful.clone();
over[4..8].copy_from_slice(&u32::MAX.to_le_bytes());
let expected = vec![FourCc(*b"one "), FourCc(*b"two ")];
assert_eq!(ids(&truthful), expected, "matching");
assert_eq!(ids(&under), expected, "under-declared");
assert_eq!(ids(&over), expected, "over-declared");
for bytes in [&truthful, &under, &over] {
assert_eq!(read_riff_header(bytes).expect("header").magic, RIFF);
}
}
#[test]
fn an_odd_chunk_is_followed_by_a_pad_byte() {
let body = [chunk(b"one ", b"INFOx"), chunk(b"two ", &[5, 6])].concat();
let bytes = riff(b"RIFF", &body);
assert_eq!(ids(&bytes), vec![FourCc(*b"one "), FourCc(*b"two ")]);
let mut unpadded = bytes.clone();
unpadded.remove(12 + 8 + 5);
let walked: Vec<_> = ChunkWalker::new(&unpadded, ByteOrder::Little).collect();
let found: Vec<FourCc> = walked
.iter()
.filter_map(|chunk| chunk.as_ref().ok().map(|chunk| chunk.id))
.collect();
assert!(
!found.contains(&FourCc(*b"two ")),
"the walk found `two ` without the pad byte: {found:?}"
);
}
#[test]
fn a_final_odd_chunk_without_its_pad_byte_is_still_read() {
let mut bytes = riff(b"RIFF", &chunk(b"one ", b"odd"));
bytes.pop(); let walked: Vec<_> = ChunkWalker::new(&bytes, ByteOrder::Little).collect();
assert_eq!(walked.len(), 1);
let chunk = walked[0].as_ref().expect("the chunk itself is complete");
assert_eq!(chunk.body, b"odd");
}
#[test]
fn a_chunk_declaring_more_than_the_file_holds_is_truncated() {
let mut bytes = riff(b"RIFF", &chunk(b"data", &[0; 16]));
bytes[16..20].copy_from_slice(&0xFFFF_FFF0u32.to_le_bytes());
let mut walker = ChunkWalker::new(&bytes, ByteOrder::Little);
let error = walker
.next()
.expect("a chunk header is present")
.expect_err("must reject");
assert!(
matches!(
error,
DecodeError::Truncated {
expected: 0xFFFF_FFF0,
available: 16
}
),
"unexpected error: {error}"
);
assert!(walker.next().is_none());
}
#[test]
fn a_chunk_size_chosen_to_wrap_the_offset_arithmetic_is_rejected() {
for declared in [u32::MAX, u32::MAX - 7, 0xFFFF_FFF8, 0x8000_0000] {
let mut bytes = riff(b"RIFF", &chunk(b"data", &[0; 8]));
bytes[16..20].copy_from_slice(&declared.to_le_bytes());
let outcome: Vec<_> = ChunkWalker::new(&bytes, ByteOrder::Little).collect();
assert_eq!(outcome.len(), 1, "declared {declared:#x}");
assert!(
matches!(outcome[0], Err(DecodeError::Truncated { .. })),
"declared {declared:#x} did not reject: {:?}",
outcome[0]
);
}
}
#[test]
fn a_ds64_table_length_is_checked_against_the_body_before_it_is_reserved_for() {
let mut body = Vec::new();
body.extend_from_slice(&[0; 8]); body.extend_from_slice(&256u64.to_le_bytes()); body.extend_from_slice(&[0; 8]); body.extend_from_slice(&u32::MAX.to_le_bytes());
let error = parse_ds64(&body, 12).expect_err("must reject");
assert!(
matches!(
error,
DecodeError::Malformed {
expected: "a ds64 table length that fits the ds64 chunk",
offset: 12
}
),
"unexpected error: {error}"
);
body[24..28].copy_from_slice(&1u32.to_le_bytes());
body.extend_from_slice(b"big ");
body.extend_from_slice(&5_000_000_000u64.to_le_bytes());
assert_eq!(
parse_ds64(&body, 12).expect("a fitting table"),
vec![(DATA, 256), (FourCc(*b"big "), 5_000_000_000)]
);
}
#[test]
fn a_short_ds64_body_is_malformed() {
for length in 0..28 {
let error = parse_ds64(&vec![0; length], 12).expect_err("must reject");
assert!(
matches!(
error,
DecodeError::Malformed {
expected: "a ds64 chunk of at least 28 bytes",
..
}
),
"{length} bytes: unexpected error: {error}"
);
}
}
#[test]
fn an_override_applies_only_where_the_size_field_is_the_sentinel() {
let overrides = [(DATA, 5_000_000_000)];
assert_eq!(resolve_size(&overrides, DATA, SIZE_SENTINEL), 5_000_000_000);
assert_eq!(resolve_size(&overrides, DATA, 128), 128);
assert_eq!(
resolve_size(&overrides, FMT, SIZE_SENTINEL),
u64::from(SIZE_SENTINEL)
);
}
#[test]
fn the_walk_reports_where_each_chunk_started() {
let body = [chunk(b"one ", &[1, 2]), chunk(b"two ", &[3, 4, 5, 6])].concat();
let bytes = riff(b"RIFF", &body);
let offsets: Vec<u64> = ChunkWalker::new(&bytes, ByteOrder::Little)
.map(|chunk| chunk.expect("walk").offset)
.collect();
assert_eq!(offsets, vec![12, 22]);
}
#[test]
fn a_walk_over_an_input_with_no_room_for_a_chunk_yields_nothing() {
for length in 0..20 {
let bytes = vec![0u8; length];
let walked: Vec<_> = ChunkWalker::new(&bytes, ByteOrder::Little).collect();
assert!(walked.is_empty(), "{length} bytes yielded a chunk");
}
}
fn be_chunk(id: &[u8; 4], body: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(id);
out.extend_from_slice(&(body.len() as u32).to_be_bytes());
out.extend_from_slice(body);
if body.len() % 2 == 1 {
out.push(0);
}
out
}
#[test]
fn the_walk_reads_big_endian_sizes_when_told_to() {
let body = [
be_chunk(b"COMM", &[1, 2, 3, 4, 5]),
be_chunk(b"SSND", &[6, 7]),
]
.concat();
let mut bytes = Vec::new();
bytes.extend_from_slice(b"FORM");
bytes.extend_from_slice(&(4 + body.len() as u32).to_be_bytes());
bytes.extend_from_slice(b"AIFF");
bytes.extend_from_slice(&body);
let walked: Vec<_> = ChunkWalker::new(&bytes, ByteOrder::Big)
.map(|chunk| chunk.expect("walk"))
.collect();
assert_eq!(walked.len(), 2);
assert_eq!(walked[0].id, FourCc(*b"COMM"));
assert_eq!(walked[0].body, &[1, 2, 3, 4, 5]);
assert_eq!(walked[1].id, FourCc(*b"SSND"));
assert_eq!(walked[1].body, &[6, 7]);
let wrong: Vec<_> = ChunkWalker::new(&bytes, ByteOrder::Little).collect();
assert!(
matches!(wrong[0], Err(DecodeError::Truncated { .. })),
"a little-endian read of a big-endian size was accepted: {:?}",
wrong[0]
);
}
}