use crate::error::{Error, ErrorKind};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum VQAVersion {
One = 1,
Two = 2,
Three = 3,
}
impl From<VQAVersion> for u16 {
fn from(version: VQAVersion) -> u16 {
version as u16
}
}
impl TryFrom<u16> for VQAVersion {
type Error = Error;
fn try_from(number: u16) -> Result<VQAVersion, Error> {
match number {
1 => Ok(VQAVersion::One),
2 => Ok(VQAVersion::Two),
3 => Ok(VQAVersion::Three),
_ => Err(ErrorKind::InvalidHeader.into()),
}
}
}
#[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 x_pos: u16,
pub y_pos: u16,
pub max_frame_size: u16,
pub freq: u16,
pub channels: u8,
pub bits: u8,
pub alt_freq: u16,
pub alt_channels: u8,
pub alt_bits: u8,
pub future_use: [u16; 5],
}
const HEADER_LEN: usize = 42;
impl VQAHeader {
pub fn parse(vqhd: &[u8]) -> Result<VQAHeader, Error> {
let vqhd: &[u8; HEADER_LEN] = vqhd
.try_into()
.map_err(|_| Error::from(ErrorKind::InvalidHeader))?;
let u16_at = |at: usize| u16::from_le_bytes([vqhd[at], vqhd[at + 1]]);
Ok(VQAHeader {
version: VQAVersion::try_from(u16_at(0))?,
flags: u16_at(2),
num_frames: u16_at(4),
width: u16_at(6),
height: u16_at(8),
block_width: vqhd[10],
block_height: vqhd[11],
frame_rate: vqhd[12],
cbparts: vqhd[13],
colors: u16_at(14),
maxblocks: u16_at(16),
x_pos: u16_at(18),
y_pos: u16_at(20),
max_frame_size: u16_at(22),
freq: u16_at(24),
channels: vqhd[26],
bits: vqhd[27],
alt_freq: u16_at(28),
alt_channels: vqhd[30],
alt_bits: vqhd[31],
future_use: [32, 34, 36, 38, 40].map(u16_at),
})
}
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 max_cbfz_size(&self) -> u32 {
u32::from(self.future_use[1]) | u32::from(self.future_use[2]) << 16
}
pub fn has_sound(&self) -> bool {
self.flags & 1 != 0
}
pub fn is_hicolor(&self) -> bool {
self.colors == 0
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FrameInfo {
pub offset: u32,
pub has_palette: bool,
}
const FINF_PALETTE_FLAG: u32 = 0x4000_0000;
const FINF_OFFSET: u32 = 0x0fff_ffff;
impl FrameInfo {
pub const fn from_raw(entry: u32) -> FrameInfo {
FrameInfo {
offset: (entry & FINF_OFFSET) * 2,
has_palette: entry & FINF_PALETTE_FLAG != 0,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn versions_convert_to_and_from_their_numbers() {
for (number, version) in [
(1, VQAVersion::One),
(2, VQAVersion::Two),
(3, VQAVersion::Three),
] {
assert_eq!(VQAVersion::try_from(number), Ok(version));
assert_eq!(u16::from(version), number);
}
assert!(VQAVersion::try_from(0).is_err());
assert!(VQAVersion::try_from(4).is_err());
}
#[test]
fn header_payload_must_be_42_bytes() {
let mut vqhd = [0u8; 42];
vqhd[0] = 2;
assert!(VQAHeader::parse(&vqhd).is_ok());
assert!(VQAHeader::parse(&vqhd[..41]).is_err());
assert!(VQAHeader::parse(&[&vqhd[..], &[0]].concat()).is_err());
}
#[test]
fn frame_info_decodes_offset_and_palette_flag() {
let info = FrameInfo::from_raw(0x4000_0000 | 150);
assert_eq!((info.offset, info.has_palette), (300, true));
let info = FrameInfo::from_raw(0xb000_0000 | 100);
assert_eq!((info.offset, info.has_palette), (200, false));
}
}