use std::ops::Range;
use super::palette::Colors;
use super::syntax::Mode;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct Neighbour {
pub(crate) mode: Mode,
pub(crate) skip: bool,
pub(crate) size_log2: u8,
pub(crate) palettes: [Colors; 2],
}
impl Default for Neighbour {
fn default() -> Self {
Self {
mode: Mode::Dc,
skip: false,
size_log2: 0,
palettes: [Colors::default(); 2],
}
}
}
#[derive(Clone, Debug)]
pub(crate) struct Edge {
pub(crate) level: [Vec<u8>; 3],
pub(crate) dc: [Vec<u8>; 3],
pub(crate) blocks: Vec<Neighbour>,
ss: u32,
}
#[derive(Clone, Debug)]
pub(crate) struct EdgeSpan {
luma: Range<usize>,
level: [Vec<u8>; 3],
dc: [Vec<u8>; 3],
blocks: Vec<Neighbour>,
}
impl Edge {
pub(crate) fn new(units: usize, ss: u32) -> Self {
let chroma = units >> ss;
Self {
level: [vec![0; units], vec![0; chroma], vec![0; chroma]],
dc: [vec![0; units], vec![0; chroma], vec![0; chroma]],
blocks: vec![Neighbour::default(); units],
ss,
}
}
pub(crate) fn plane_range(&self, plane: usize, luma: &Range<usize>) -> Range<usize> {
let ss = if plane == 0 { 0 } else { self.ss };
luma.start >> ss..luma.end >> ss
}
pub(crate) fn clear_levels(&mut self, luma: &Range<usize>) {
for plane in 0..3 {
let range = self.plane_range(plane, luma);
self.level[plane][range.clone()].fill(0);
self.dc[plane][range].fill(0);
}
}
pub(crate) fn set_block(&mut self, luma: Range<usize>, block: Neighbour) {
self.blocks[luma].fill(block);
}
pub(crate) fn save(&self, luma: Range<usize>) -> EdgeSpan {
let planes = |values: &[Vec<u8>; 3]| {
[0, 1, 2].map(|plane| values[plane][self.plane_range(plane, &luma)].to_vec())
};
EdgeSpan {
level: planes(&self.level),
dc: planes(&self.dc),
blocks: self.blocks[luma.clone()].to_vec(),
luma,
}
}
pub(crate) fn restore(&mut self, span: &EdgeSpan) {
for plane in 0..3 {
let range = self.plane_range(plane, &span.luma);
self.level[plane][range.clone()].copy_from_slice(&span.level[plane]);
self.dc[plane][range].copy_from_slice(&span.dc[plane]);
}
self.blocks[span.luma.clone()].copy_from_slice(&span.blocks);
}
}
#[derive(Clone, Debug)]
pub(crate) struct Contexts {
pub(crate) above: Edge,
pub(crate) left: Edge,
}
#[derive(Clone, Debug)]
pub(crate) struct ContextSpan {
above: EdgeSpan,
left: EdgeSpan,
}
impl Contexts {
pub(crate) fn new((columns, rows): (usize, usize), (ss_x, ss_y): (u32, u32)) -> Self {
Self {
above: Edge::new(columns, ss_x),
left: Edge::new(rows, ss_y),
}
}
pub(crate) fn save(&self, r: usize, c: usize, units: usize) -> ContextSpan {
ContextSpan {
above: self.above.save(c..c + units),
left: self.left.save(r..r + units),
}
}
pub(crate) fn restore(&mut self, span: &ContextSpan) {
self.above.restore(&span.above);
self.left.restore(&span.left);
}
}
#[derive(Clone, Debug)]
pub(crate) struct Decoded {
sides: Vec<i32>,
flags: Vec<Vec<bool>>,
}
impl Decoded {
pub(crate) fn new(planes: usize, ss: u32) -> Self {
let sides: Vec<i32> = (0..planes)
.map(|plane| 16 >> if plane == 0 { 0 } else { ss })
.collect();
let flags = sides
.iter()
.map(|&side| vec![false; ((side + 2) * (side + 2)) as usize])
.collect();
Self { sides, flags }
}
fn index(&self, plane: usize, y: i32, x: i32) -> usize {
((y + 1) * (self.sides[plane] + 2) + x + 1) as usize
}
pub(crate) fn unit(&self, plane: usize, sample: usize) -> i32 {
(sample as i32 >> 2) & (self.sides[plane] - 1)
}
pub(crate) fn get(&self, plane: usize, y: i32, x: i32) -> bool {
self.flags[plane][self.index(plane, y, x)]
}
pub(crate) fn clear(&mut self, (r, c): (usize, usize), end: (usize, usize), ss: u32) {
for plane in 0..self.sides.len() {
let ss = if plane == 0 { 0 } else { ss };
let side = self.sides[plane];
let width = ((end.1 - c) >> ss) as i32;
let height = ((end.0 - r) >> ss) as i32;
for y in -1..=side {
for x in -1..=side {
let decoded = (y < 0 && x < width) || (x < 0 && y >= 0 && y < height);
let index = self.index(plane, y, x);
self.flags[plane][index] = decoded;
}
}
let corner = self.index(plane, side, -1);
self.flags[plane][corner] = false;
}
}
pub(crate) fn mark(&mut self, plane: usize, (y, x): (i32, i32), units: usize) {
for row in y..y + units as i32 {
let start = self.index(plane, row, x);
self.flags[plane][start..start + units].fill(true);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn decoded_units_follow_the_tile() {
let mut decoded = Decoded::new(3, 1);
decoded.clear((0, 0), (8, 24), 1);
assert!(decoded.get(0, -1, 16) && decoded.get(0, -1, -1));
assert!(decoded.get(0, 7, -1) && !decoded.get(0, 8, -1));
assert!(!decoded.get(0, 0, 0) && !decoded.get(0, 16, -1));
assert!(decoded.get(1, -1, 8) && decoded.get(1, 3, -1) && !decoded.get(1, 4, -1));
decoded.mark(0, (2, 4), 4);
assert!(decoded.get(0, 5, 7) && !decoded.get(0, 6, 7) && !decoded.get(0, 5, 8));
assert_eq!(decoded.unit(0, 70), 1);
assert_eq!(decoded.unit(1, 36), 1);
}
#[test]
fn spans_round_trip() {
let mut contexts = Contexts::new((16, 8), (1, 1));
contexts.above.level[0][4] = 7;
contexts.above.level[1][2] = 3;
contexts.left.blocks[2].mode = Mode::Paeth;
let saved = contexts.save(2, 4, 4);
contexts.above.level[0][4] = 0;
contexts.above.level[1][2] = 0;
contexts.left.blocks[2].mode = Mode::Dc;
contexts.above.blocks[9].skip = true;
contexts.restore(&saved);
assert_eq!(contexts.above.level[0][4], 7);
assert_eq!(contexts.above.level[1][2], 3);
assert_eq!(contexts.left.blocks[2].mode, Mode::Paeth);
assert!(contexts.above.blocks[9].skip);
}
#[test]
fn clearing_covers_the_chroma_units() {
let mut edge = Edge::new(8, 1);
edge.level = [vec![1; 8], vec![1; 4], vec![1; 4]];
edge.clear_levels(&(2..6));
assert_eq!(edge.level[0], [1, 1, 0, 0, 0, 0, 1, 1]);
assert_eq!(edge.level[2], [1, 0, 0, 1]);
}
}