use fearless_simd::prelude::*;
use fearless_simd::{Level, dispatch, mask16x16, u8x16, u8x32, u16x16, u32x4, u64x2};
use crate::chunk::{Chunk, Chunks};
use crate::error::{Error, ErrorKind, Limit, VideoError};
use crate::header::{VQAHeader, VQAVersion};
use crate::lcw::{self, LcwError};
use crate::rgb;
const MAX_FRAME_PIXELS: usize = 1 << 24;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Frame {
pub width: usize,
pub height: usize,
pub pixels: FramePixels,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FramePixels {
Indexed {
pixels: Vec<u8>,
palette: Vec<[u8; 3]>,
},
HiColor {
pixels: Vec<u16>,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FrameRef<'a> {
pub width: usize,
pub height: usize,
pub pixels: FramePixelsRef<'a>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FramePixelsRef<'a> {
Indexed {
pixels: &'a [u8],
palette: &'a [[u8; 3]],
},
HiColor {
pixels: &'a [u16],
},
}
impl Frame {
pub fn view(&self) -> FrameRef<'_> {
FrameRef {
width: self.width,
height: self.height,
pixels: match &self.pixels {
FramePixels::Indexed { pixels, palette } => {
FramePixelsRef::Indexed { pixels, palette }
}
FramePixels::HiColor { pixels } => FramePixelsRef::HiColor { pixels },
},
}
}
pub fn to_rgb888(&self) -> Vec<u8> {
self.view().to_rgb888()
}
pub fn write_rgb888(&self, out: &mut [u8]) {
self.view().write_rgb888(out);
}
pub fn to_rgba8888(&self) -> Vec<u8> {
self.view().to_rgba8888()
}
pub fn write_rgba8888(&self, out: &mut [u8]) {
self.view().write_rgba8888(out);
}
pub fn to_xrgb8888(&self) -> Vec<u32> {
self.view().to_xrgb8888()
}
pub fn write_xrgb8888(&self, out: &mut [u32]) {
self.view().write_xrgb8888(out);
}
}
impl FrameRef<'_> {
pub fn to_frame(&self) -> Frame {
Frame {
width: self.width,
height: self.height,
pixels: match self.pixels {
FramePixelsRef::Indexed { pixels, palette } => FramePixels::Indexed {
pixels: pixels.to_vec(),
palette: palette.to_vec(),
},
FramePixelsRef::HiColor { pixels } => FramePixels::HiColor {
pixels: pixels.to_vec(),
},
},
}
}
pub fn to_rgb888(&self) -> Vec<u8> {
let mut out = vec![0; self.pixel_count() * 3];
self.write_rgb888(&mut out);
out
}
pub fn write_rgb888(&self, out: &mut [u8]) {
assert_eq!(
out.len(),
self.pixel_count() * 3,
"RGB888 output must hold three bytes per pixel"
);
match self.pixels {
FramePixelsRef::Indexed { pixels, palette } => {
rgb::indexed_to_rgb888(pixels, palette, out);
}
FramePixelsRef::HiColor { pixels } => rgb::hicolor_to_rgb888(pixels, out),
}
}
pub fn to_rgba8888(&self) -> Vec<u8> {
let mut out = vec![0; self.pixel_count() * 4];
self.write_rgba8888(&mut out);
out
}
pub fn write_rgba8888(&self, out: &mut [u8]) {
assert_eq!(
out.len(),
self.pixel_count() * 4,
"RGBA8888 output must hold four bytes per pixel"
);
match self.pixels {
FramePixelsRef::Indexed { pixels, palette } => {
rgb::indexed_to_rgba8888(pixels, palette, out);
}
FramePixelsRef::HiColor { pixels } => rgb::hicolor_to_rgba8888(pixels, out),
}
}
pub fn to_xrgb8888(&self) -> Vec<u32> {
let mut out = vec![0; self.pixel_count()];
self.write_xrgb8888(&mut out);
out
}
pub fn write_xrgb8888(&self, out: &mut [u32]) {
assert_eq!(
out.len(),
self.pixel_count(),
"XRGB8888 output must hold one word per pixel"
);
match self.pixels {
FramePixelsRef::Indexed { pixels, palette } => {
rgb::indexed_to_xrgb8888(pixels, palette, out);
}
FramePixelsRef::HiColor { pixels } => rgb::hicolor_to_xrgb8888(pixels, out),
}
}
fn pixel_count(&self) -> usize {
match self.pixels {
FramePixelsRef::Indexed { pixels, .. } => pixels.len(),
FramePixelsRef::HiColor { pixels } => pixels.len(),
}
}
}
#[derive(Clone)]
pub struct FrameDecoder {
version: VQAVersion,
hicolor: bool,
width: usize,
height: usize,
block_w: usize,
block_h: usize,
blocks_x: usize,
blocks_y: usize,
fill_sentinel: u8,
max_codebook_bytes: usize,
cbparts: usize,
codebook8: Vec<u8>,
entries8: usize,
codebook16: Vec<u16>,
parts: Vec<u8>,
parts_count: usize,
parts_compressed: bool,
palette: Vec<[u8; 3]>,
frame8: Vec<u8>,
frame16: Vec<u16>,
sources: Vec<u32>,
level: Level,
}
impl FrameDecoder {
pub fn new(header: &VQAHeader) -> Result<FrameDecoder, Error> {
let block_w = usize::from(header.block_width);
let block_h = usize::from(header.block_height);
if block_w == 0 || block_h == 0 {
return Err(ErrorKind::InvalidHeader.into());
}
let width = usize::from(header.width);
let height = usize::from(header.height);
if width * height > MAX_FRAME_PIXELS {
return Err(ErrorKind::TooLarge(Limit::FrameSize).into());
}
let hicolor = header.is_hicolor();
let max_blocks = match header.maxblocks {
0 => 0xff00,
n => usize::from(n),
};
let entry_bytes = block_w * block_h * if hicolor { 2 } else { 1 };
let max_codebook_bytes = max_blocks.saturating_mul(entry_bytes).min(MAX_FRAME_PIXELS);
Ok(FrameDecoder {
version: header.version,
hicolor,
width,
height,
block_w,
block_h,
blocks_x: width / block_w,
blocks_y: height / block_h,
fill_sentinel: if block_h == 4 { 0xff } else { 0x0f },
max_codebook_bytes,
cbparts: usize::from(header.cbparts),
codebook8: if hicolor {
Vec::new()
} else {
fill_entries(block_w * block_h)
},
entries8: 0,
codebook16: Vec::new(),
parts: Vec::new(),
parts_count: 0,
parts_compressed: false,
palette: Vec::new(),
frame8: if hicolor {
Vec::new()
} else {
vec![0; width * height]
},
frame16: if hicolor {
vec![0; width * height]
} else {
Vec::new()
},
sources: if hicolor {
Vec::new()
} else {
vec![0; width / block_w]
},
level: Level::new(),
})
}
pub fn process_vqfl(&mut self, data: &[u8]) -> Result<(), Error> {
self.apply_side_chunks(Chunks::payload(data))
}
pub(crate) fn apply_side_chunks(&mut self, chunks: Chunks<'_>) -> Result<(), Error> {
for chunk in chunks {
let chunk = chunk?;
self.side_chunk(&chunk)
.map_err(|kind| Error::in_chunk(kind, &chunk))?;
}
Ok(())
}
pub fn decode_frame(&mut self, data: &[u8]) -> Result<Frame, Error> {
Ok(self.decode_frame_ref(data)?.to_frame())
}
pub fn decode_frame_ref(&mut self, data: &[u8]) -> Result<FrameRef<'_>, Error> {
self.decode_chunks(Chunks::payload(data))
}
pub(crate) fn decode_chunks(&mut self, chunks: Chunks<'_>) -> Result<FrameRef<'_>, Error> {
for chunk in chunks {
let chunk = chunk?;
self.frame_chunk(&chunk)
.map_err(|kind| Error::in_chunk(kind, &chunk))?;
}
Ok(self.end_frame()?)
}
pub(crate) fn frame_chunk(&mut self, chunk: &Chunk<'_>) -> Result<(), ErrorKind> {
match &chunk.id {
b"VPT0" => self.render_vpt(chunk.data),
b"VPTZ" | b"VPTK" | b"VPTD" => {
let size = ErrorKind::Video(VideoError::PointerTableSize);
let table = decompress(chunk.data, self.pointer_table_len(), size)?;
self.render_vpt(&table)
}
b"VPTR" => self.render_vptr(chunk.data),
b"VPRZ" => {
let cap = self.blocks_x * self.blocks_y * 8 + 256;
let stream = lcw::decompress(chunk.data, cap)?;
self.render_vptr(&stream)
}
_ => self.side_chunk(chunk),
}
}
pub(crate) fn end_frame(&mut self) -> Result<FrameRef<'_>, ErrorKind> {
if self.cbparts != 0 && self.parts_count >= self.cbparts {
self.swap_parts()?;
}
Ok(self.frame())
}
pub fn swap_in_codebook_parts(&mut self) -> Result<(), Error> {
Ok(self.swap_parts()?)
}
fn swap_parts(&mut self) -> Result<(), ErrorKind> {
if self.parts_count == 0 {
return Ok(());
}
let staged = std::mem::take(&mut self.parts);
self.parts_count = 0;
let bytes = if self.parts_compressed {
let too_large = ErrorKind::TooLarge(Limit::Codebook);
decompress(&staged, self.max_codebook_bytes, too_large)?
} else {
staged
};
self.set_codebook(&bytes)
}
fn side_chunk(&mut self, chunk: &Chunk<'_>) -> Result<(), ErrorKind> {
match &chunk.id {
b"CBF0" => self.set_codebook(chunk.data),
b"CBFZ" => {
let too_large = ErrorKind::TooLarge(Limit::Codebook);
let data = decompress(chunk.data, self.max_codebook_bytes, too_large)?;
self.set_codebook(&data)
}
b"CBP0" | b"CBPZ" => self.stage_codebook_part(chunk),
b"CPL0" => self.set_palette(chunk.data),
b"CPLZ" => {
let size = ErrorKind::Video(VideoError::PaletteSize);
let data = decompress(chunk.data, 256 * 3, size)?;
self.set_palette(&data)
}
_ => Ok(()),
}
}
fn entry_len(&self) -> usize {
self.block_w * self.block_h
}
fn pointer_table_len(&self) -> usize {
self.blocks_x * self.blocks_y * 2
}
fn set_codebook(&mut self, bytes: &[u8]) -> Result<(), ErrorKind> {
if bytes.len() > self.max_codebook_bytes {
return Err(ErrorKind::TooLarge(Limit::Codebook));
}
let entry_bytes = self.entry_len() * if self.hicolor { 2 } else { 1 };
let bytes = &bytes[..bytes.len() - bytes.len() % entry_bytes];
if self.hicolor {
self.codebook16 = bytes
.as_chunks::<2>()
.0
.iter()
.map(|&p| u16::from_le_bytes(p))
.collect();
} else {
self.entries8 = bytes.len() / entry_bytes;
self.codebook8.truncate(256 * entry_bytes);
self.codebook8.extend_from_slice(bytes);
}
Ok(())
}
fn stage_codebook_part(&mut self, chunk: &Chunk<'_>) -> Result<(), ErrorKind> {
let compressed = chunk.id[3] == b'Z';
if self.parts_count == 0 {
self.parts.clear();
self.parts_compressed = compressed;
} else if compressed != self.parts_compressed {
return Err(ErrorKind::Video(VideoError::MixedCodebookParts));
}
if self.parts.len() + chunk.data.len() > self.max_codebook_bytes {
return Err(ErrorKind::TooLarge(Limit::Codebook));
}
self.parts.extend_from_slice(chunk.data);
self.parts_count += 1;
Ok(())
}
fn set_palette(&mut self, data: &[u8]) -> Result<(), ErrorKind> {
if !data.len().is_multiple_of(3) || data.len() > 256 * 3 {
return Err(ErrorKind::Video(VideoError::PaletteSize));
}
self.palette = data
.as_chunks::<3>()
.0
.iter()
.map(|&[r, g, b]| {
let scale = |v: u8| (v & 0x3f) << 2 | (v & 0x3f) >> 4;
[scale(r), scale(g), scale(b)]
})
.collect();
Ok(())
}
#[inline(always)]
fn block_size<const BW: usize, const BH: usize>(&self) -> (usize, usize) {
if BW == 0 {
(self.block_w, self.block_h)
} else {
debug_assert_eq!((BW, BH), (self.block_w, self.block_h));
(BW, BH)
}
}
fn render_vpt(&mut self, table: &[u8]) -> Result<(), ErrorKind> {
if self.hicolor {
return Err(ErrorKind::Video(VideoError::WrongPointerFormat));
}
if table.len() != self.blocks_x * self.blocks_y * 2 {
return Err(ErrorKind::Video(VideoError::PointerTableSize));
}
if table.is_empty() {
return Ok(());
}
let level = self.level;
match (self.block_w, self.block_h) {
(4, 2) => dispatch!(level, simd => self.render_vpt_with::<_, 4, 2>(simd, table)),
(4, 4) => dispatch!(level, simd => self.render_vpt_with::<_, 4, 4>(simd, table)),
_ => dispatch!(level, simd => self.render_vpt_with::<_, 0, 0>(simd, table)),
}
}
#[inline(always)]
fn render_vpt_with<S: Simd, const BW: usize, const BH: usize>(
&mut self,
simd: S,
table: &[u8],
) -> Result<(), ErrorKind> {
let (bw, bh) = self.block_size::<BW, BH>();
let (blocks_x, blocks) = (self.blocks_x, self.blocks_x * self.blocks_y);
let (entries, fill) = (self.entries8, self.fill_sentinel);
let vector = !self.level.is_fallback();
let sources = &mut self.sources[..blocks_x];
let strips = self.frame8.chunks_exact_mut(self.width * bh);
for (by, strip) in strips.take(self.blocks_y).enumerate() {
let row = by * blocks_x;
let drawable = match self.version {
VQAVersion::One => {
let words = &table[row * 2..][..blocks_x * 2];
match vector {
true => interleaved_sources(simd, words, entries, sources),
false => interleaved_sources_scalar(words, entries, sources),
}
}
_ => {
let lo = &table[row..][..blocks_x];
let hi = &table[blocks + row..][..blocks_x];
match vector {
true => split_sources(simd, lo, hi, fill, entries, sources),
false => split_sources_scalar(lo, hi, fill, entries, sources),
}
}
};
let sources = &sources[..drawable];
match (BW, BH, vector) {
(0, _, _) => draw_row_any(strip, self.width, bw, &self.codebook8, sources),
(4, 2, true) => {
draw_row_simd::<_, 2>(simd, strip, self.width, &self.codebook8, sources);
}
(4, 4, true) => {
draw_row_simd::<_, 4>(simd, strip, self.width, &self.codebook8, sources);
}
_ => draw_row::<BW, BH>(strip, self.width, &self.codebook8, sources),
}
if drawable < blocks_x {
return Err(ErrorKind::Video(VideoError::BlockIndexOutOfRange));
}
}
Ok(())
}
fn render_vptr(&mut self, stream: &[u8]) -> Result<(), ErrorKind> {
if !self.hicolor {
return Err(ErrorKind::Video(VideoError::WrongPointerFormat));
}
match (self.block_w, self.block_h, self.width % 4) {
(4, 2, 0) => self.render_vptr_with::<4, 2>(stream),
(4, 4, 0) => self.render_vptr_with::<4, 4>(stream),
_ => self.render_vptr_with::<0, 0>(stream),
}
}
#[inline(always)]
fn render_vptr_with<const BW: usize, const BH: usize>(
&mut self,
stream: &[u8],
) -> Result<(), ErrorKind> {
let (bw, bh) = self.block_size::<BW, BH>();
let mut blocks = BlockWriter::<BW, BH> {
frame: &mut self.frame16,
codebook: &self.codebook16,
width: self.width,
bw,
bh,
blocks_x: self.blocks_x,
blocks: self.blocks_x * self.blocks_y,
pos: 0,
bx: 0,
line: 0,
};
let truncated = ErrorKind::Video(VideoError::TruncatedPointerStream);
let mut sp = 0;
while sp < stream.len() {
let Some(&[lo, hi]) = stream[sp..].first_chunk() else {
return Err(truncated);
};
let val = u16::from_le_bytes([lo, hi]);
sp += 2;
if val >> 13 == 0b011 {
blocks.write_one(usize::from(val & 0x1fff))?;
continue;
}
let run_count = usize::from(val >> 8 & 0x1f) + 1;
match val >> 13 {
0b000 => blocks.skip(usize::from(val & 0x1fff)),
0b001 => blocks.write_run(usize::from(val & 0xff), run_count * 2, false)?,
0b010 => {
blocks.write_run(usize::from(val & 0xff), 1, false)?;
let indexes = &stream[sp..(sp + run_count * 2).min(stream.len())];
sp += indexes.len();
blocks.write_each(indexes, run_count * 2)?;
}
0b100 => blocks.write_run(usize::from(val & 0x1fff), 1, true)?,
0b101 | 0b110 => {
let count = *stream.get(sp).ok_or(truncated)?;
sp += 1;
let alpha = val >> 13 == 0b110;
blocks.write_run(usize::from(val & 0x1fff), usize::from(count), alpha)?;
}
_ => return Err(ErrorKind::Video(VideoError::UnknownPointerCommand)),
}
}
Ok(())
}
fn frame(&self) -> FrameRef<'_> {
FrameRef {
width: self.width,
height: self.height,
pixels: if self.hicolor {
FramePixelsRef::HiColor {
pixels: &self.frame16,
}
} else {
FramePixelsRef::Indexed {
pixels: &self.frame8,
palette: &self.palette,
}
},
}
}
}
struct BlockWriter<'a, const BW: usize, const BH: usize> {
frame: &'a mut [u16],
codebook: &'a [u16],
width: usize,
bw: usize,
bh: usize,
blocks_x: usize,
blocks: usize,
pos: usize,
bx: usize,
line: usize,
}
impl<const BW: usize, const BH: usize> BlockWriter<'_, BW, BH> {
#[inline(always)]
fn size(&self) -> (usize, usize) {
match BW {
0 => (self.bw, self.bh),
_ => (BW, BH),
}
}
#[inline(always)]
fn skip(&mut self, count: usize) {
self.pos = self.pos.saturating_add(count);
if self.pos < self.blocks {
self.bx = self.pos % self.blocks_x;
self.line = self.pos / self.blocks_x * self.size().1 * self.width;
}
}
#[inline(always)]
fn advance(&mut self) {
self.pos += 1;
self.bx += 1;
if self.bx == self.blocks_x {
self.bx = 0;
self.line += self.size().1 * self.width;
}
}
#[inline(always)]
fn write_one(&mut self, index: usize) -> Result<(), ErrorKind> {
if self.pos >= self.blocks {
return Err(ErrorKind::Video(VideoError::PointerStreamOverrun));
}
let entry_len = self.size().0 * self.size().1;
if let Some(entry) = self
.codebook
.get(index * entry_len..(index + 1) * entry_len)
{
self.put(entry, false);
}
self.advance();
Ok(())
}
#[inline(always)]
fn write_run(&mut self, index: usize, count: usize, alpha_skip: bool) -> Result<(), ErrorKind> {
let room = self.blocks.saturating_sub(self.pos);
let entry_len = self.size().0 * self.size().1;
let entry = self
.codebook
.get(index * entry_len..(index + 1) * entry_len);
for _ in 0..count.min(room) {
if let Some(entry) = entry {
self.put(entry, alpha_skip);
}
self.advance();
}
match count <= room {
true => Ok(()),
false => Err(ErrorKind::Video(VideoError::PointerStreamOverrun)),
}
}
#[inline(always)]
fn write_each(&mut self, indexes: &[u8], wanted: usize) -> Result<(), ErrorKind> {
let room = self.blocks.saturating_sub(self.pos);
let entry_len = self.size().0 * self.size().1;
let written = indexes.len().min(room);
for &index in &indexes[..written] {
let index = usize::from(index);
if let Some(entry) = self
.codebook
.get(index * entry_len..(index + 1) * entry_len)
{
self.put(entry, false);
}
self.advance();
}
match written {
_ if written == wanted => Ok(()),
_ if written == indexes.len() => {
Err(ErrorKind::Video(VideoError::TruncatedPointerStream))
}
_ => Err(ErrorKind::Video(VideoError::PointerStreamOverrun)),
}
}
#[inline(always)]
fn put(&mut self, entry: &[u16], alpha_skip: bool) {
if let Some(stride) = self.width.checked_div(BW) {
let pieces = self.frame.as_chunks_mut::<BW>().0;
let first = self.line / BW + self.bx;
for (y, src) in entry.as_chunks::<BW>().0.iter().enumerate() {
put_line(&mut pieces[first + y * stride], src, alpha_skip);
}
} else {
let at = self.line + self.bx * self.bw;
for (y, src) in entry.chunks_exact(self.bw).enumerate() {
put_line(
&mut self.frame[at + y * self.width..][..self.bw],
src,
alpha_skip,
);
}
}
}
}
#[inline(always)]
fn put_line(dst: &mut [u16], src: &[u16], alpha_skip: bool) {
if alpha_skip {
for (pixel, &new) in dst.iter_mut().zip(src) {
if new & 0x8000 == 0 {
*pixel = new;
}
}
} else {
dst.copy_from_slice(src);
}
}
fn fill_entries(entry: usize) -> Vec<u8> {
let mut entries = Vec::with_capacity(256 * entry);
for color in 0..=255 {
entries.extend(std::iter::repeat_n(color, entry));
}
entries
}
#[inline(always)]
fn split_sources<S: Simd>(
simd: S,
lo: &[u8],
hi: &[u8],
fill: u8,
entries: usize,
out: &mut [u32],
) -> usize {
let (lo_v, lo_rest) = lo.as_chunks::<16>();
let (hi_v, hi_rest) = hi.as_chunks::<16>();
let (out_v, out_rest) = out.as_chunks_mut::<16>();
let entries_v = u16x16::splat(simd, entries as u16);
for (i, ((lo, hi), out)) in lo_v.iter().zip(hi_v).zip(out_v).enumerate() {
let (lo, hi) = (u8x16::from_slice(simd, lo), u8x16::from_slice(simd, hi));
let index: u16x16<S> = simd
.combine_u8x16(simd.zip_low_u8x16(lo, hi), simd.zip_high_u8x16(lo, hi))
.bitcast();
let is_fill = (index >> 8).simd_eq(u16x16::splat(simd, u16::from(fill)));
let is_bad = !is_fill & index.simd_ge(entries_v);
store_sources(simd, is_fill, index & 0xff, index, out);
if is_bad.any_true() {
return i * 16 + is_bad.to_bitmask().trailing_zeros() as usize;
}
}
let done = lo_v.len() * 16;
done + split_sources_scalar(lo_rest, hi_rest, fill, entries, out_rest)
}
fn split_sources_scalar(lo: &[u8], hi: &[u8], fill: u8, entries: usize, out: &mut [u32]) -> usize {
for (i, ((&lo, &hi), out)) in lo.iter().zip(hi).zip(out).enumerate() {
let index = usize::from(hi) << 8 | usize::from(lo);
*out = match hi == fill {
true => usize::from(lo),
false if index < entries => 256 + index,
false => return i,
} as u32;
}
lo.len()
}
#[inline(always)]
fn interleaved_sources<S: Simd>(simd: S, words: &[u8], entries: usize, out: &mut [u32]) -> usize {
let (words_v, words_rest) = words.as_chunks::<32>();
let (out_v, out_rest) = out.as_chunks_mut::<16>();
let entries_v = u16x16::splat(simd, entries as u16);
for (i, (words, out)) in words_v.iter().zip(out_v).enumerate() {
let word: u16x16<S> = u8x32::from_slice(simd, words).bitcast();
let is_fill = (word >> 8).simd_eq(u16x16::splat(simd, 0xff));
let index = word >> 3;
let is_bad = !is_fill & index.simd_ge(entries_v);
store_sources(simd, is_fill, (word & 0xff) ^ 0xff, index, out);
if is_bad.any_true() {
return i * 16 + is_bad.to_bitmask().trailing_zeros() as usize;
}
}
let done = words_v.len() * 16;
done + interleaved_sources_scalar(words_rest, entries, out_rest)
}
fn interleaved_sources_scalar(words: &[u8], entries: usize, out: &mut [u32]) -> usize {
let words = words.as_chunks::<2>().0;
for (i, (&[lo, hi], out)) in words.iter().zip(out).enumerate() {
let index = (usize::from(hi) << 8 | usize::from(lo)) / 8;
*out = match hi == 0xff {
true => usize::from(255 - lo),
false if index < entries => 256 + index,
false => return i,
} as u32;
}
words.len()
}
#[inline(always)]
fn store_sources<S: Simd>(
simd: S,
is_fill: mask16x16<S>,
color: u16x16<S>,
index: u16x16<S>,
out: &mut [u32; 16],
) {
let (base_lo, base_hi) = simd.widen_u16x16(is_fill.select(color, index));
let offset = is_fill.select(u16x16::splat(simd, 0), u16x16::splat(simd, 256));
let (offset_lo, offset_hi) = simd.widen_u16x16(offset);
let (out_lo, out_hi) = out.split_at_mut(8);
(base_lo + offset_lo).store_slice(out_lo);
(base_hi + offset_hi).store_slice(out_hi);
}
#[inline(always)]
fn draw_row<const BW: usize, const BH: usize>(
strip: &mut [u8],
width: usize,
codebook: &[u8],
sources: &[u32],
) {
let entries = codebook.as_chunks::<BW>().0.as_chunks::<BH>().0;
let mut lines = block_lines::<BW, BH>(strip, width, sources.len());
copy_blocks(&mut lines, entries, sources);
}
#[inline(always)]
fn draw_row_simd<S: Simd, const BH: usize>(
simd: S,
strip: &mut [u8],
width: usize,
codebook: &[u8],
sources: &[u32],
) {
let entries = codebook.as_chunks::<4>().0.as_chunks::<BH>().0;
let Some(last) = entries.len().checked_sub(1) else {
return;
};
let mut lines = block_lines::<4, BH>(strip, width, sources.len());
let (groups, rest) = sources.as_chunks::<4>();
let done = groups.len() * 4;
let mut heads = lines
.each_mut()
.map(|line| line[..done].as_chunks_mut::<4>().0);
for (g, &[a, b, c, d]) in groups.iter().enumerate() {
let a = entry_u32x4(simd, &entries[(a as usize).min(last)]);
let b = entry_u32x4(simd, &entries[(b as usize).min(last)]);
let c = entry_u32x4(simd, &entries[(c as usize).min(last)]);
let d = entry_u32x4(simd, &entries[(d as usize).min(last)]);
let (ab_lo, ab_hi) = (simd.zip_low_u32x4(a, b), simd.zip_high_u32x4(a, b));
let (cd_lo, cd_hi) = (simd.zip_low_u32x4(c, d), simd.zip_high_u32x4(c, d));
let (ab_lo, ab_hi): (u64x2<S>, u64x2<S>) = (ab_lo.bitcast(), ab_hi.bitcast());
let (cd_lo, cd_hi): (u64x2<S>, u64x2<S>) = (cd_lo.bitcast(), cd_hi.bitcast());
let transposed = [
simd.zip_low_u64x2(ab_lo, cd_lo),
simd.zip_high_u64x2(ab_lo, cd_lo),
simd.zip_low_u64x2(ab_hi, cd_hi),
simd.zip_high_u64x2(ab_hi, cd_hi),
];
for (line, pixels) in heads.iter_mut().zip(transposed) {
pixels
.bitcast::<u8x16<S>>()
.store_slice(line[g].as_flattened_mut());
}
}
let mut tails = lines.each_mut().map(|line| &mut line[done..]);
copy_blocks(&mut tails, entries, rest);
}
#[inline(always)]
fn block_lines<const BW: usize, const BH: usize>(
strip: &mut [u8],
width: usize,
n: usize,
) -> [&mut [[u8; BW]]; BH] {
let mut lines = strip.chunks_exact_mut(width);
let lines: [_; BH] = std::array::from_fn(|_| lines.next().unwrap_or_default());
lines.map(|line| &mut line.as_chunks_mut::<BW>().0[..n])
}
#[inline(always)]
fn copy_blocks<const BW: usize, const BH: usize>(
lines: &mut [&mut [[u8; BW]]; BH],
entries: &[[[u8; BW]; BH]],
sources: &[u32],
) {
let Some(last) = entries.len().checked_sub(1) else {
return;
};
let n = sources.len();
let mut lines = lines.each_mut().map(|line| &mut line[..n]);
for (i, &source) in sources.iter().enumerate() {
let entry = &entries[(source as usize).min(last)];
for (line, pixels) in lines.iter_mut().zip(entry) {
line[i] = *pixels;
}
}
}
#[inline(always)]
fn entry_u32x4<S: Simd, const BH: usize>(simd: S, entry: &[[u8; 4]; BH]) -> u32x4<S> {
let mut bytes = [0; 16];
bytes[..BH * 4].copy_from_slice(entry.as_flattened());
u8x16::simd_from(simd, bytes).bitcast()
}
fn draw_row_any(strip: &mut [u8], width: usize, bw: usize, codebook: &[u8], sources: &[u32]) {
let bh = strip.len() / width;
let entry = bw * bh;
let last = codebook.len() / entry - 1;
for (y, line) in strip.chunks_exact_mut(width).enumerate() {
for (pixels, &source) in line.chunks_exact_mut(bw).zip(sources) {
let at = (source as usize).min(last) * entry + y * bw;
pixels.copy_from_slice(&codebook[at..at + bw]);
}
}
}
fn decompress(data: &[u8], max: usize, too_long: ErrorKind) -> Result<Vec<u8>, ErrorKind> {
lcw::decompress(data, max).map_err(|e| match e {
LcwError::TooLarge => too_long,
e => ErrorKind::Lcw(e),
})
}
#[cfg(test)]
#[allow(clippy::unusual_byte_groupings)]
mod tests {
use super::*;
fn v2_header() -> VQAHeader {
VQAHeader {
version: VQAVersion::Two,
flags: 0,
num_frames: 3,
width: 8,
height: 4,
block_width: 4,
block_height: 2,
frame_rate: 15,
cbparts: 0,
colors: 256,
maxblocks: 0x0f00,
x_pos: 0,
y_pos: 0,
max_frame_size: 0,
freq: 22050,
channels: 1,
bits: 16,
alt_freq: 0,
alt_channels: 0,
alt_bits: 0,
future_use: [0; 5],
}
}
fn hicolor_header() -> VQAHeader {
VQAHeader {
version: VQAVersion::Three,
colors: 0,
channels: 2,
..v2_header()
}
}
fn chunk(id: &str, data: &[u8]) -> Vec<u8> {
let mut out = id.as_bytes().to_vec();
out.extend((data.len() as u32).to_be_bytes());
out.extend(data);
if data.len() % 2 == 1 {
out.push(0);
}
out
}
#[test]
fn renders_v2_frame_from_codebook_palette_and_pointers() {
let mut decoder = FrameDecoder::new(&v2_header()).unwrap();
let codebook: Vec<u8> = (0..8).chain(10..18).collect();
let palette = [0x3f, 0, 0, 0, 0x20, 0];
let table = [0u8, 1, 7, 0, 0, 0, 0x0f, 0];
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("CPL0", &palette));
vqfr.extend(chunk("VPT0", &table));
let frame = decoder.decode_frame(&vqfr).unwrap();
match &frame.pixels {
FramePixels::Indexed { pixels, palette } => {
#[rustfmt::skip]
assert_eq!(pixels, &vec![
0, 1, 2, 3, 10, 11, 12, 13,
4, 5, 6, 7, 14, 15, 16, 17,
7, 7, 7, 7, 0, 1, 2, 3,
7, 7, 7, 7, 4, 5, 6, 7,
]);
assert_eq!(palette[0], [0xff, 0, 0]);
assert_eq!(palette[1], [0, 0x82, 0]);
}
_ => panic!("expected an indexed frame"),
}
}
#[test]
fn accumulates_codebook_parts_and_swaps_after_the_carrying_frame() {
let mut header = v2_header();
header.cbparts = 2;
let mut decoder = FrameDecoder::new(&header).unwrap();
let old_codebook: Vec<u8> = vec![1; 8];
let new_first: Vec<u8> = vec![2; 8];
let new_second: Vec<u8> = vec![3; 8];
let table = [0u8, 0, 0, 0, 0, 0, 0, 0];
let mut vqfr = chunk("CBF0", &old_codebook);
vqfr.extend(chunk("CBP0", &new_first));
vqfr.extend(chunk("VPT0", &table));
let frame = decoder.decode_frame(&vqfr).unwrap();
assert!(matches!(&frame.pixels, FramePixels::Indexed { pixels, .. } if pixels[0] == 1));
let mut vqfr = chunk("CBP0", &new_second);
vqfr.extend(chunk("VPT0", &table));
let frame = decoder.decode_frame(&vqfr).unwrap();
assert!(matches!(&frame.pixels, FramePixels::Indexed { pixels, .. } if pixels[0] == 1));
let frame = decoder.decode_frame(&chunk("VPT0", &table)).unwrap();
assert!(matches!(&frame.pixels, FramePixels::Indexed { pixels, .. } if pixels[0] == 2));
}
#[test]
fn decompresses_vptz_pointer_tables() {
let mut decoder = FrameDecoder::new(&v2_header()).unwrap();
let codebook: Vec<u8> = (0..8).collect();
let table = [0u8, 0, 0, 0, 0, 0, 0, 0];
let mut compressed = vec![0x80 | table.len() as u8];
compressed.extend(table);
compressed.push(0x80);
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPTZ", &compressed));
let frame = decoder.decode_frame(&vqfr).unwrap();
assert!(matches!(&frame.pixels, FramePixels::Indexed { pixels, .. }
if pixels[7] == 3 && pixels[15] == 7));
}
#[test]
fn renders_hicolor_vptr_commands_differentially() {
let mut decoder = FrameDecoder::new(&hicolor_header()).unwrap();
let mut codebook = Vec::new();
for pixel in [0x7fffu16; 8].iter().chain([0x0300u16; 8].iter()) {
codebook.extend(&pixel.to_le_bytes());
}
let mut stream = Vec::new();
stream.extend(&(0b011_0000000000001u16).to_le_bytes());
stream.extend(&(0b101_0000000000000u16).to_le_bytes());
stream.push(3);
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPTR", &stream));
let frame = decoder.decode_frame(&vqfr).unwrap();
let FramePixels::HiColor { pixels } = &frame.pixels else {
panic!("expected a hicolor frame");
};
assert_eq!(pixels[0], 0x0300);
assert_eq!(pixels[4], 0x7fff);
assert_eq!(pixels[7], 0x7fff);
let mut stream = Vec::new();
stream.extend(&(0b000_0000000000011u16).to_le_bytes());
stream.extend(&(0b011_0000000000001u16).to_le_bytes());
let frame = decoder.decode_frame(&chunk("VPTR", &stream)).unwrap();
let FramePixels::HiColor { pixels } = &frame.pixels else {
panic!("expected a hicolor frame");
};
assert_eq!(pixels[0], 0x0300); assert_eq!(pixels[4], 0x7fff); assert_eq!(pixels[2 * 8 + 4], 0x0300); }
#[test]
fn hicolor_run_and_indexed_write_commands() {
let mut header = hicolor_header();
header.width = 16;
let mut decoder = FrameDecoder::new(&header).unwrap();
let mut codebook = Vec::new();
for value in [1u16, 2, 3] {
for _ in 0..8 {
codebook.extend(&value.to_le_bytes());
}
}
let mut stream = Vec::new();
stream.extend(&(0b001_00000_00000000u16).to_le_bytes());
stream.extend(&(0b010_00000_00000001u16).to_le_bytes());
stream.push(2);
stream.push(2);
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPTR", &stream));
let frame = decoder.decode_frame(&vqfr).unwrap();
let FramePixels::HiColor { pixels } = &frame.pixels else {
panic!("expected a hicolor frame");
};
assert_eq!(pixels[0], 1); assert_eq!(pixels[4], 1); assert_eq!(pixels[8], 2); assert_eq!(pixels[12], 3); assert_eq!(pixels[2 * 16], 3); assert_eq!(pixels[2 * 16 + 4], 0); }
#[test]
fn drops_stray_bytes_after_the_last_codebook_entry() {
let mut decoder = FrameDecoder::new(&v2_header()).unwrap();
let codebook: Vec<u8> = (0..8).chain([9, 9]).collect();
let table = [0u8, 0, 0, 0, 0, 0, 0, 0];
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPT0", &table));
let frame = decoder.decode_frame(&vqfr).unwrap();
assert!(matches!(&frame.pixels, FramePixels::Indexed { pixels, .. }
if pixels[0] == 0 && pixels[15] == 7));
let table = [0u8, 1, 0, 0, 0, 0, 0, 0]; assert_eq!(
decoder
.decode_frame(&chunk("VPT0", &table))
.map_err(|e| e.kind()),
Err(ErrorKind::Video(VideoError::BlockIndexOutOfRange))
);
}
#[test]
fn rejects_block_indices_outside_the_codebook() {
let mut decoder = FrameDecoder::new(&v2_header()).unwrap();
let codebook: Vec<u8> = (0..8).collect(); let table = [0u8, 1, 0, 0, 0, 0, 0, 0];
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPT0", &table));
assert_eq!(
decoder.decode_frame(&vqfr).map_err(|e| e.kind()),
Err(ErrorKind::Video(VideoError::BlockIndexOutOfRange))
);
}
#[test]
fn hicolor_runs_cross_block_rows_and_fail_where_the_frame_or_stream_ends() {
let codebook: Vec<u8> = [1u16, 2, 3]
.iter()
.flat_map(|&value| [value; 8])
.flat_map(u16::to_le_bytes)
.collect();
for width in [16, 18] {
let mut header = hicolor_header();
header.width = width;
let width = usize::from(width);
let decode = |stream: &[u8]| {
let mut decoder = FrameDecoder::new(&header).unwrap();
decoder.process_vqfl(&chunk("CBF0", &codebook)).unwrap();
let vptr = chunk("VPTR", stream);
let error = decoder.decode_frame_ref(&vptr).err().map(|e| e.kind());
let frame = decoder.decode_frame_ref(&[]).unwrap();
let FramePixelsRef::HiColor { pixels } = frame.pixels else {
panic!("expected a hicolor frame");
};
let blocks: Vec<u16> = (0..8)
.map(|block| pixels[block / 4 * 2 * width + block % 4 * 4])
.collect();
(error, blocks)
};
let mut stream = Vec::new();
stream.extend(0b000_0000000000010u16.to_le_bytes());
stream.extend(0b001_00000_00000000u16.to_le_bytes());
stream.extend(0b101_0000000000001u16.to_le_bytes());
stream.push(3);
let drawn = vec![0, 0, 1, 1, 2, 2, 2, 0];
assert_eq!(decode(&stream), (None, drawn), "{width} wide");
let drawn = vec![0, 0, 1, 1, 2, 2, 2, 3];
stream.extend(0b010_00000_00000010u16.to_le_bytes());
let overrun = [stream.as_slice(), &[0, 0]].concat();
let error = Some(ErrorKind::Video(VideoError::PointerStreamOverrun));
assert_eq!(decode(&overrun), (error, drawn.clone()), "{width} wide");
let error = Some(ErrorKind::Video(VideoError::TruncatedPointerStream));
assert_eq!(decode(&stream), (error, drawn), "{width} wide");
}
}
#[test]
fn skips_hicolor_writes_with_indices_outside_the_codebook() {
let mut decoder = FrameDecoder::new(&hicolor_header()).unwrap();
let mut codebook = Vec::new();
for pixel in [0x0300u16; 8] {
codebook.extend(&pixel.to_le_bytes());
}
let mut stream = Vec::new();
stream.extend(&(0b011_0000000000000u16).to_le_bytes());
stream.extend(&(0b011_1111101010100u16).to_le_bytes());
stream.extend(&(0b011_0000000000000u16).to_le_bytes());
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPTR", &stream));
let frame = decoder.decode_frame(&vqfr).unwrap();
let FramePixels::HiColor { pixels } = &frame.pixels else {
panic!("expected a hicolor frame");
};
assert_eq!(pixels[0], 0x0300);
assert_eq!(pixels[4], 0); assert_eq!(pixels[2 * 8], 0x0300);
}
#[test]
fn long_skip_runs_do_not_overflow_the_block_position() {
let mut decoder = FrameDecoder::new(&hicolor_header()).unwrap();
let mut stream = 0b000_1111111111111u16.to_le_bytes().repeat(600_000);
stream.extend(0b011_0000000000000u16.to_le_bytes());
assert_eq!(
decoder
.decode_frame(&chunk("VPTR", &stream))
.map_err(|e| e.kind()),
Err(ErrorKind::Video(VideoError::PointerStreamOverrun))
);
}
#[test]
fn rejects_unknown_pointer_stream_commands() {
let mut decoder = FrameDecoder::new(&hicolor_header()).unwrap();
let stream = (0b111_0000000000000u16).to_le_bytes();
assert_eq!(
decoder
.decode_frame(&chunk("VPTR", &stream))
.map_err(|e| e.kind()),
Err(ErrorKind::Video(VideoError::UnknownPointerCommand))
);
}
#[test]
fn renders_8bit_blocks_without_a_specialized_size() {
let mut header = v2_header();
(header.width, header.height) = (4, 2);
(header.block_width, header.block_height) = (2, 2);
let mut decoder = FrameDecoder::new(&header).unwrap();
let codebook: Vec<u8> = (0..8).collect(); let table = [1u8, 9, 0, 0x0f];
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPT0", &table));
let frame = decoder.decode_frame(&vqfr).unwrap();
let FramePixels::Indexed { pixels, .. } = &frame.pixels else {
panic!("expected an indexed frame");
};
assert_eq!(pixels, &vec![4, 5, 9, 9, 6, 7, 9, 9]);
}
#[test]
fn vector_block_sources_match_the_scalar_ones() {
let mut state = 0x9e37_79b9_7f4a_7c15u64;
let mut random = move || {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
state
};
for level in [Level::new(), Level::baseline()] {
for len in 0..=70 {
for entries in [0, 1, 300, 0xff00, 0xffff] {
let lo: Vec<u8> = (0..len).map(|_| random() as u8).collect();
let hi: Vec<u8> = (0..len)
.map(|_| match random() % 8 {
0 => 0x0f,
1 => 0xff,
2 => random() as u8,
_ => (random() % 2) as u8,
})
.collect();
let words: Vec<u8> = lo.iter().zip(&hi).flat_map(|(&l, &h)| [l, h]).collect();
let (mut vector, mut scalar) = (vec![0; len], vec![0; len]);
let n = dispatch!(level, simd => split_sources(simd, &lo, &hi, 0x0f, entries, &mut vector));
let m = split_sources_scalar(&lo, &hi, 0x0f, entries, &mut scalar);
assert_eq!(
(n, &vector[..n]),
(m, &scalar[..m]),
"v2 at {level:?}, {len} blocks, {entries} entries"
);
let n = dispatch!(level, simd => interleaved_sources(simd, &words, entries, &mut vector));
let m = interleaved_sources_scalar(&words, entries, &mut scalar);
assert_eq!(
(n, &vector[..n]),
(m, &scalar[..m]),
"v1 at {level:?}, {len} blocks, {entries} entries"
);
}
}
}
}
#[test]
fn a_block_past_the_codebook_fails_with_the_blocks_before_it_drawn() {
let mut header = v2_header();
(header.width, header.height) = (160, 2);
let codebook = [[1; 8], [2; 8]].concat();
for bad in [20, 37] {
let mut decoder = FrameDecoder::new(&header).unwrap();
let mut table = vec![0; 80];
for block in 0..40 {
(table[block], table[40 + block]) = match block {
_ if block == bad => (5, 0), _ if block % 3 == 0 => (7, 0x0f), _ => (block as u8 % 2, 0),
};
}
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPT0", &table));
assert_eq!(
decoder.decode_frame(&vqfr).map_err(|e| e.kind()),
Err(ErrorKind::Video(VideoError::BlockIndexOutOfRange))
);
let frame = decoder.decode_frame_ref(&[]).unwrap();
let FramePixelsRef::Indexed { pixels, .. } = frame.pixels else {
panic!("expected an indexed frame");
};
for block in 0..40 {
let color = match block {
_ if block >= bad => 0, _ if block % 3 == 0 => 7,
_ => block as u8 % 2 + 1,
};
for line in 0..2 {
let at = line * 160 + block * 4;
assert_eq!(pixels[at..at + 4], [color; 4], "block {block} of bad {bad}");
}
}
}
}
#[test]
fn hicolor_alpha_writes_keep_flagged_pixels() {
let mut header = hicolor_header();
(header.width, header.height) = (4, 2);
(header.block_width, header.block_height) = (2, 2);
let mut decoder = FrameDecoder::new(&header).unwrap();
let mut codebook = Vec::new();
for pixel in [0x8001u16, 2, 3, 4, 10, 11, 12, 13] {
codebook.extend(&pixel.to_le_bytes());
}
let mut stream = Vec::new();
stream.extend(&(0b011_0000000000001u16).to_le_bytes());
stream.extend(&(0b011_0000000000001u16).to_le_bytes());
let mut vqfr = chunk("CBF0", &codebook);
vqfr.extend(chunk("VPTR", &stream));
decoder.decode_frame(&vqfr).unwrap();
let stream = (0b100_0000000000000u16).to_le_bytes();
let frame = decoder.decode_frame(&chunk("VPTR", &stream)).unwrap();
let FramePixels::HiColor { pixels } = &frame.pixels else {
panic!("expected a hicolor frame");
};
assert_eq!(pixels, &vec![10, 2, 10, 11, 3, 4, 12, 13]);
}
}