#[derive(Clone, Copy)]
pub struct PlaneRef<'a> {
pub data: &'a [u8],
pub width: usize,
pub height: usize,
}
impl PlaneRef<'_> {
#[inline(always)]
fn at(&self, x: isize, y: isize) -> i32 {
let x = x.clamp(0, self.width as isize - 1) as usize;
let y = y.clamp(0, self.height as isize - 1) as usize;
self.data[y * self.width + x] as i32
}
#[inline(always)]
fn tap_h(&self, x: isize, y: isize) -> i32 {
self.at(x - 2, y) - 5 * self.at(x - 1, y) + 20 * self.at(x, y) + 20 * self.at(x + 1, y) - 5 * self.at(x + 2, y) + self.at(x + 3, y)
}
#[inline(always)]
fn tap_v(&self, x: isize, y: isize) -> i32 {
self.at(x, y - 2) - 5 * self.at(x, y - 1) + 20 * self.at(x, y) + 20 * self.at(x, y + 1) - 5 * self.at(x, y + 2) + self.at(x, y + 3)
}
fn b(&self, x: isize, y: isize) -> i32 {
((self.tap_h(x, y) + 16) >> 5).clamp(0, 255)
}
fn h(&self, x: isize, y: isize) -> i32 {
((self.tap_v(x, y) + 16) >> 5).clamp(0, 255)
}
fn j(&self, x: isize, y: isize) -> i32 {
let t = |r: isize| self.tap_h(x, y + r);
let j1 = t(-2) - 5 * t(-1) + 20 * t(0) + 20 * t(1) - 5 * t(2) + t(3);
((j1 + 512) >> 10).clamp(0, 255)
}
pub fn sample(&self, x: isize, y: isize, xf: usize, yf: usize) -> i32 {
let avg = |a: i32, b: i32| (a + b + 1) >> 1;
let g = || self.at(x, y);
match (xf, yf) {
(0, 0) => g(),
(1, 0) => avg(g(), self.b(x, y)),
(2, 0) => self.b(x, y),
(3, 0) => avg(self.b(x, y), self.at(x + 1, y)),
(0, 1) => avg(g(), self.h(x, y)),
(0, 2) => self.h(x, y),
(0, 3) => avg(self.h(x, y), self.at(x, y + 1)),
(2, 2) => self.j(x, y),
(2, 1) => avg(self.b(x, y), self.j(x, y)),
(2, 3) => avg(self.j(x, y), self.b(x, y + 1)),
(1, 2) => avg(self.h(x, y), self.j(x, y)),
(3, 2) => avg(self.j(x, y), self.h(x + 1, y)),
(xf, yf) => avg(self.b(x, y + (yf == 3) as isize), self.h(x + (xf == 3) as isize, y)),
}
}
pub fn block(&self, x: isize, y: isize, xf: usize, yf: usize, w: usize, h: usize, out: &mut [i32]) {
for r in 0..h {
for c in 0..w {
out[r * w + c] = self.sample(x + c as isize, y + r as isize, xf, yf);
}
}
}
}
pub struct HalfPlanes {
width: usize,
height: usize,
stride: usize,
g: Vec<u8>,
b: Vec<u8>,
h: Vec<u8>,
j: Vec<u8>,
}
const PAD: isize = 8;
impl HalfPlanes {
pub fn new(data: &[u8], width: usize, height: usize, threads: usize) -> HalfPlanes {
let p = PlaneRef { data, width, height };
let (sw, sh) = (width + 2 * PAD as usize, height + 2 * PAD as usize);
let mut g = vec![0u8; sw * sh];
let mut b = vec![0u8; sw * sh];
let mut h = vec![0u8; sw * sh];
let mut j = vec![0u8; sw * sh];
let b1_rows = sh + 5;
let mut b1 = vec![0i32; sw * b1_rows];
let rows_each = |n: usize| n.div_ceil(threads.max(1)).max(1);
let fill = |out: &mut [i32], first_row: usize, f: &(dyn Fn(isize, isize) -> i32 + Sync)| {
for (k, v) in out.iter_mut().enumerate() {
let (r, c) = (first_row + k / sw, k % sw);
*v = f(c as isize - PAD, r as isize);
}
};
let tap_h = |x: isize, r: isize| p.tap_h(x, r - PAD - 2);
std::thread::scope(|scope| {
for (i, chunk) in b1.chunks_mut(rows_each(b1_rows) * sw).enumerate() {
let first = i * rows_each(b1_rows);
scope.spawn(move || fill(chunk, first, &tap_h));
}
});
let b1 = &b1;
let n = rows_each(sh);
std::thread::scope(|scope| {
for (i, (((gc, bc), hc), jc)) in g.chunks_mut(n * sw).zip(b.chunks_mut(n * sw)).zip(h.chunks_mut(n * sw)).zip(j.chunks_mut(n * sw)).enumerate() {
scope.spawn(move || {
for k in 0..gc.len() {
let (r, c) = (i * n + k / sw, k % sw);
let (x, y) = (c as isize - PAD, r as isize - PAD);
gc[k] = p.at(x, y) as u8;
bc[k] = ((b1[(r + 2) * sw + c] + 16) >> 5).clamp(0, 255) as u8;
hc[k] = ((p.tap_v(x, y) + 16) >> 5).clamp(0, 255) as u8;
let t = |d: usize| b1[(r + d) * sw + c];
let j1 = t(0) - 5 * t(1) + 20 * t(2) + 20 * t(3) - 5 * t(4) + t(5);
jc[k] = ((j1 + 512) >> 10).clamp(0, 255) as u8;
}
});
}
});
HalfPlanes { width, height, stride: sw, g, b, h, j }
}
#[inline(always)]
fn idx(&self, x: isize, y: isize) -> usize {
let x = x.clamp(-PAD + 1, self.width as isize + PAD - 2);
let y = y.clamp(-PAD + 1, self.height as isize + PAD - 2);
(y + PAD) as usize * self.stride + (x + PAD) as usize
}
#[inline(always)]
pub fn sample(&self, x: isize, y: isize, xf: usize, yf: usize) -> i32 {
let avg = |a: u8, b: u8| (a as i32 + b as i32 + 1) >> 1;
let i = self.idx(x, y);
let (g, b, h, j) = (&self.g, &self.b, &self.h, &self.j);
match (xf, yf) {
(0, 0) => g[i] as i32,
(1, 0) => avg(g[i], b[i]),
(2, 0) => b[i] as i32,
(3, 0) => avg(b[i], g[self.idx(x + 1, y)]),
(0, 1) => avg(g[i], h[i]),
(0, 2) => h[i] as i32,
(0, 3) => avg(h[i], g[self.idx(x, y + 1)]),
(2, 2) => j[i] as i32,
(2, 1) => avg(b[i], j[i]),
(2, 3) => avg(j[i], b[self.idx(x, y + 1)]),
(1, 2) => avg(h[i], j[i]),
(3, 2) => avg(j[i], h[self.idx(x + 1, y)]),
(xf, yf) => avg(b[self.idx(x, y + (yf == 3) as isize)], h[self.idx(x + (xf == 3) as isize, y)]),
}
}
pub fn block(&self, x: isize, y: isize, xf: usize, yf: usize, w: usize, h: usize, out: &mut [i32]) {
for r in 0..h {
for c in 0..w {
out[r * w + c] = self.sample(x + c as isize, y + r as isize, xf, yf);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tables_match_direct_interpolation_everywhere() {
let (w, h) = (37usize, 29usize);
let data: Vec<u8> = (0..w * h).map(|i| ((i * 97 + (i / w) * 31) % 256) as u8).collect();
let direct = PlaneRef { data: &data, width: w, height: h };
let tables = HalfPlanes::new(&data, w, h, 3);
for y in -20..h as isize + 20 {
for x in -20..w as isize + 20 {
for xf in 0..4 {
for yf in 0..4 {
assert_eq!(tables.sample(x, y, xf, yf), direct.sample(x, y, xf, yf), "({x}, {y}) + ({xf}, {yf})/4");
}
}
}
}
}
#[test]
fn flat_stays_flat_and_halves_average() {
let data = vec![100u8; 32 * 32];
let p = PlaneRef { data: &data, width: 32, height: 32 };
for xf in 0..4 {
for yf in 0..4 {
assert_eq!(p.sample(10, 10, xf, yf), 100, "({xf}, {yf})");
}
}
let step: Vec<u8> = (0..32 * 32).map(|i| if i % 32 < 16 { 0 } else { 200 }).collect();
let p = PlaneRef { data: &step, width: 32, height: 32 };
assert_eq!(p.sample(15, 5, 2, 0), 100);
assert_eq!(p.sample(15, 5, 0, 2), 0, "vertical half of a vertical edge column");
}
#[test]
fn edges_clamp() {
let data: Vec<u8> = (0..16 * 16).map(|i| (i % 16 * 10) as u8).collect();
let p = PlaneRef { data: &data, width: 16, height: 16 };
assert_eq!(p.sample(-5, -5, 0, 0), 0);
assert_eq!(p.sample(40, 3, 0, 0), 150);
let _ = p.sample(-3, 20, 3, 3);
}
}