use super::bool_decoder::BoolDecoder;
use super::tables::{AC_QUANT, COEFF_PROBS, COEFF_UPDATE_PROBS, DC_QUANT};
use crate::webp::DecodeError;
pub(super) const SEGMENTS: usize = 4;
const FRAME_HEADER_SIZE: usize = 10;
const START_CODE: [u8; 3] = [0x9D, 0x01, 0x2A];
pub(super) type CoeffProbs = [[[[u8; 11]; 3]; 8]; 4];
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(super) struct Quantizers {
pub(super) y1: [i32; 2],
pub(super) y2: [i32; 2],
pub(super) uv: [i32; 2],
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(super) struct FilterStrength {
pub(super) limit: i32,
pub(super) interior: i32,
pub(super) hev_threshold: i32,
pub(super) inner: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum FilterKind {
None,
Simple,
Normal,
}
#[derive(Debug)]
pub(super) struct FrameHeader<'a> {
pub(super) width: usize,
pub(super) height: usize,
pub(super) segment_map: bool,
pub(super) segment_probs: [u8; 3],
pub(super) quantizers: [Quantizers; SEGMENTS],
pub(super) filter: FilterKind,
pub(super) strengths: [[FilterStrength; 2]; SEGMENTS],
pub(super) coeff_probs: Box<CoeffProbs>,
pub(super) skip_prob: Option<u8>,
pub(super) partitions: Vec<&'a [u8]>,
}
pub(crate) fn read_info(data: &[u8]) -> Result<(u32, u32), DecodeError> {
if data.len() < FRAME_HEADER_SIZE {
return Err(DecodeError::Truncated);
}
let tag = u32::from(data[0]) | (u32::from(data[1]) << 8) | (u32::from(data[2]) << 16);
let key_frame = tag & 1 == 0;
let profile = (tag >> 1) & 7;
let shown = (tag >> 4) & 1 == 1;
let first_partition = (tag >> 5) as usize;
let width = u32::from(u16::from_le_bytes([data[6], data[7]]) & 0x3FFF);
let height = u32::from(u16::from_le_bytes([data[8], data[9]]) & 0x3FFF);
let valid = data[3..6] == START_CODE
&& key_frame
&& profile <= 3
&& shown
&& first_partition < data.len()
&& width > 0
&& height > 0;
if valid {
Ok((width, height))
} else {
Err(DecodeError::LossyHeader)
}
}
pub(super) fn parse(data: &[u8]) -> Result<(FrameHeader<'_>, BoolDecoder<'_>), DecodeError> {
let (width, height) = read_info(data)?;
let first_size = (u32::from_le_bytes([data[0], data[1], data[2], 0]) >> 5) as usize;
let rest = &data[FRAME_HEADER_SIZE..];
if first_size > rest.len() {
return Err(DecodeError::Truncated);
}
let (first, tokens) = rest.split_at(first_size);
let mut reader = BoolDecoder::new(first);
reader.literal(2);
let segments = SegmentHeader::read(&mut reader);
let filter = FilterHeader::read(&mut reader);
if reader.is_eof() {
return Err(DecodeError::LossyHeader);
}
let partitions = split_partitions(&mut reader, tokens)?;
let quantizers = read_quantizers(&mut reader, &segments);
reader.flag();
let coeff_probs = read_coeff_probs(&mut reader);
let skip_prob = reader.flag().then(|| reader.literal(8) as u8);
let header = FrameHeader {
width: width as usize,
height: height as usize,
segment_map: segments.update_map,
segment_probs: segments.tree_probs,
quantizers,
filter: filter.kind(),
strengths: filter.strengths(&segments),
coeff_probs,
skip_prob,
partitions,
};
Ok((header, reader))
}
#[derive(Debug)]
struct SegmentHeader {
enabled: bool,
update_map: bool,
absolute: bool,
quantizer: [i32; SEGMENTS],
filter_level: [i32; SEGMENTS],
tree_probs: [u8; 3],
}
impl SegmentHeader {
fn read(reader: &mut BoolDecoder<'_>) -> Self {
let mut header = Self {
enabled: reader.flag(),
update_map: false,
absolute: true,
quantizer: [0; SEGMENTS],
filter_level: [0; SEGMENTS],
tree_probs: [255; 3],
};
if !header.enabled {
return header;
}
header.update_map = reader.flag();
if reader.flag() {
header.absolute = reader.flag();
header.quantizer = std::array::from_fn(|_| reader.optional_signed(7));
header.filter_level = std::array::from_fn(|_| reader.optional_signed(6));
}
if header.update_map {
header.tree_probs = std::array::from_fn(|_| {
if reader.flag() {
reader.literal(8) as u8
} else {
255
}
});
}
header
}
}
#[derive(Debug)]
struct FilterHeader {
simple: bool,
level: i32,
sharpness: i32,
deltas: Option<(i32, i32)>,
}
impl FilterHeader {
fn read(reader: &mut BoolDecoder<'_>) -> Self {
let simple = reader.flag();
let level = reader.literal(6) as i32;
let sharpness = reader.literal(3) as i32;
let deltas = reader.flag().then(|| {
let mut reference = [0; 4];
let mut mode = [0; 4];
if reader.flag() {
for delta in reference.iter_mut().chain(&mut mode) {
if reader.flag() {
*delta = reader.signed_literal(6);
}
}
}
(reference[0], mode[0])
});
Self {
simple,
level,
sharpness,
deltas,
}
}
fn kind(&self) -> FilterKind {
match (self.level, self.simple) {
(0, _) => FilterKind::None,
(_, true) => FilterKind::Simple,
(_, false) => FilterKind::Normal,
}
}
fn strengths(&self, segments: &SegmentHeader) -> [[FilterStrength; 2]; SEGMENTS] {
std::array::from_fn(|segment| {
let base = if segments.enabled {
segments.filter_level[segment] + if segments.absolute { 0 } else { self.level }
} else {
self.level
};
std::array::from_fn(|intra4| {
let mut level = base;
if let Some((reference, mode)) = self.deltas {
level += reference + if intra4 == 1 { mode } else { 0 };
}
self.strength(level.clamp(0, 63), intra4 == 1)
})
})
}
fn strength(&self, level: i32, inner: bool) -> FilterStrength {
if level == 0 {
return FilterStrength {
inner,
..FilterStrength::default()
};
}
let mut interior = level;
if self.sharpness > 0 {
interior >>= if self.sharpness > 4 { 2 } else { 1 };
interior = interior.min(9 - self.sharpness);
}
let interior = interior.max(1);
FilterStrength {
limit: 2 * level + interior,
interior,
hev_threshold: match level {
40.. => 2,
15.. => 1,
_ => 0,
},
inner,
}
}
}
fn split_partitions<'a>(
reader: &mut BoolDecoder<'_>,
data: &'a [u8],
) -> Result<Vec<&'a [u8]>, DecodeError> {
let count = 1usize << reader.literal(2);
let table_size = 3 * (count - 1);
if data.len() < table_size {
return Err(DecodeError::InvalidPartitions);
}
let (sizes, mut rest) = data.split_at(table_size);
let mut partitions = Vec::with_capacity(count);
for size in sizes.as_chunks::<3>().0 {
let size = u32::from_le_bytes([size[0], size[1], size[2], 0]) as usize;
let (partition, after) = rest.split_at(size.min(rest.len()));
partitions.push(partition);
rest = after;
}
if rest.is_empty() {
return Err(DecodeError::InvalidPartitions);
}
partitions.push(rest);
Ok(partitions)
}
fn read_quantizers(
reader: &mut BoolDecoder<'_>,
segments: &SegmentHeader,
) -> [Quantizers; SEGMENTS] {
let base = reader.literal(7) as i32;
let [y1_dc, y2_dc, y2_ac, uv_dc, uv_ac] = std::array::from_fn(|_| reader.optional_signed(4));
let dc = |q: i32, max: i32| i32::from(DC_QUANT[q.clamp(0, max) as usize]);
let ac = |q: i32| i32::from(AC_QUANT[q.clamp(0, 127) as usize]);
let factors = |q: i32| Quantizers {
y1: [dc(q + y1_dc, 127), ac(q)],
y2: [
dc(q + y2_dc, 127) * 2,
((ac(q + y2_ac) * 101_581) >> 16).max(8),
],
uv: [dc(q + uv_dc, 117), ac(q + uv_ac)],
};
if segments.enabled {
std::array::from_fn(|segment| {
let q = segments.quantizer[segment] + if segments.absolute { 0 } else { base };
factors(q)
})
} else {
[factors(base); SEGMENTS]
}
}
fn read_coeff_probs(reader: &mut BoolDecoder<'_>) -> Box<CoeffProbs> {
let mut probs = Box::new(COEFF_PROBS);
for (plane, updates) in probs.iter_mut().zip(&COEFF_UPDATE_PROBS) {
for (band, updates) in plane.iter_mut().zip(updates) {
for (context, updates) in band.iter_mut().zip(updates) {
for (prob, &update) in context.iter_mut().zip(updates) {
if reader.bit(update) {
*prob = reader.literal(8) as u8;
}
}
}
}
}
probs
}
#[cfg(test)]
mod tests {
use super::*;
fn tag(size: u32, width: u16, height: u16) -> Vec<u8> {
let bits = (size << 5) | (1 << 4);
let mut data = bits.to_le_bytes()[..3].to_vec();
data.extend(START_CODE);
data.extend(width.to_le_bytes());
data.extend(height.to_le_bytes());
data
}
#[test]
fn frame_tags_are_checked_like_libwebp() {
let mut data = tag(1, 3, 2);
data.push(0);
assert_eq!(read_info(&data), Ok((3, 2)));
assert_eq!(read_info(&data[..9]), Err(DecodeError::Truncated));
let mut inter = data.clone();
inter[0] |= 1;
assert_eq!(read_info(&inter), Err(DecodeError::LossyHeader));
let mut empty = tag(1, 0, 2);
empty.push(0);
assert_eq!(read_info(&empty), Err(DecodeError::LossyHeader));
let too_long = tag(64, 3, 2);
assert_eq!(read_info(&too_long), Err(DecodeError::LossyHeader));
}
#[test]
fn filter_strengths_follow_sharpness() {
let header = FilterHeader {
simple: false,
level: 20,
sharpness: 5,
deltas: Some((2, -30)),
};
let segments = SegmentHeader {
enabled: false,
update_map: false,
absolute: true,
quantizer: [0; SEGMENTS],
filter_level: [0; SEGMENTS],
tree_probs: [255; 3],
};
let [intra16, intra4] = header.strengths(&segments)[0];
assert_eq!(
intra16,
FilterStrength {
limit: 48,
interior: 4,
hev_threshold: 1,
inner: false
}
);
assert_eq!(intra4.limit, 0);
assert!(intra4.inner);
}
}