use crate::h264::deblock_tables::{ALPHA, BETA, TC0};
use crate::h264::params::MB_SIZE;
const BS_MB_EDGE: usize = 4;
const BS_INTERNAL: usize = 3;
#[inline]
fn clip1(v: i32) -> u8 {
v.clamp(0, 255) as u8
}
pub fn deblock(
y: &mut [u8],
u: &mut [u8],
v: &mut [u8],
cw: u32,
ch: u32,
mb_qp: &[i32],
qp_c: impl Fn(i32) -> i32,
) {
let (mbw, mbh) = ((cw / MB_SIZE) as usize, (ch / MB_SIZE) as usize);
let cwc = cw / 2;
for mby in 0..mbh {
for mbx in 0..mbw {
let qp_here = mb_qp[mby * mbw + mbx];
let qp_left = (mbx > 0).then(|| mb_qp[mby * mbw + mbx - 1]);
let qp_above = (mby > 0).then(|| mb_qp[(mby - 1) * mbw + mbx]);
let (ox, oy) = (
(mbx * MB_SIZE as usize) as u32,
(mby * MB_SIZE as usize) as u32,
);
for e in 0..4u32 {
let (bs, qp_p) = match (e, qp_left) {
(0, None) => continue, (0, Some(q)) => (BS_MB_EDGE, q),
_ => (BS_INTERNAL, qp_here),
};
let x = ox + e * 4;
filter_edge(
y,
cw,
x,
oy,
1,
cw as isize,
MB_SIZE,
bs,
qp_p,
qp_here,
false,
);
}
for e in 0..4u32 {
let (bs, qp_p) = match (e, qp_above) {
(0, None) => continue,
(0, Some(q)) => (BS_MB_EDGE, q),
_ => (BS_INTERNAL, qp_here),
};
let yy = oy + e * 4;
filter_edge(
y,
cw,
ox,
yy,
cw as isize,
1,
MB_SIZE,
bs,
qp_p,
qp_here,
false,
);
}
let (cx, cy) = (ox / 2, oy / 2);
for plane in [&mut *u, &mut *v] {
for e in 0..2u32 {
let (bs, qp_p) = match (e, qp_left) {
(0, None) => continue,
(0, Some(q)) => (BS_MB_EDGE, q),
_ => (BS_INTERNAL, qp_here),
};
filter_edge(
plane,
cwc,
cx + e * 4,
cy,
1,
cwc as isize,
8,
bs,
qp_c(qp_p),
qp_c(qp_here),
true,
);
}
for e in 0..2u32 {
let (bs, qp_p) = match (e, qp_above) {
(0, None) => continue,
(0, Some(q)) => (BS_MB_EDGE, q),
_ => (BS_INTERNAL, qp_here),
};
filter_edge(
plane,
cwc,
cx,
cy + e * 4,
cwc as isize,
1,
8,
bs,
qp_c(qp_p),
qp_c(qp_here),
true,
);
}
}
}
}
}
#[allow(clippy::too_many_arguments)]
fn filter_edge(
plane: &mut [u8],
w: u32,
x: u32,
y: u32,
step: isize,
along: isize,
len: u32,
bs: usize,
qp_p: i32,
qp_q: i32,
chroma: bool,
) {
let idx = ((qp_p + qp_q + 1) >> 1).clamp(0, 51) as usize;
let (alpha, beta) = (ALPHA[idx], BETA[idx]);
if alpha == 0 {
return;
}
let base = (y * w + x) as isize;
for k in 0..len as isize {
let o = base + k * along;
let at = |i: isize| plane[(o + i * step) as usize] as i32;
let (p0, p1, p2, p3) = (at(-1), at(-2), at(-3), at(-4));
let (q0, q1, q2, q3) = (at(0), at(1), at(2), at(3));
if (p0 - q0).abs() >= alpha || (p1 - p0).abs() >= beta || (q1 - q0).abs() >= beta {
continue;
}
let ap = (p2 - p0).abs();
let aq = (q2 - q0).abs();
let set = |plane: &mut [u8], i: isize, val: u8| plane[(o + i * step) as usize] = val;
if bs < 4 {
let tc0 = TC0[idx][bs];
let tc = if chroma {
tc0 + 1
} else {
tc0 + i32::from(ap < beta) + i32::from(aq < beta)
};
let delta = ((((q0 - p0) << 2) + (p1 - q1) + 4) >> 3).clamp(-tc, tc);
set(plane, -1, clip1(p0 + delta));
set(plane, 0, clip1(q0 - delta));
if !chroma && ap < beta {
let d = ((p2 + ((p0 + q0 + 1) >> 1) - (p1 << 1)) >> 1).clamp(-tc0, tc0);
set(plane, -2, clip1(p1 + d));
}
if !chroma && aq < beta {
let d = ((q2 + ((p0 + q0 + 1) >> 1) - (q1 << 1)) >> 1).clamp(-tc0, tc0);
set(plane, 1, clip1(q1 + d));
}
} else {
let strong = (p0 - q0).abs() < ((alpha >> 2) + 2);
if !chroma && ap < beta && strong {
set(
plane,
-1,
clip1((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3),
);
set(plane, -2, clip1((p2 + p1 + p0 + q0 + 2) >> 2));
set(plane, -3, clip1((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3));
} else {
set(plane, -1, clip1((2 * p1 + p0 + q1 + 2) >> 2));
}
if !chroma && aq < beta && strong {
set(
plane,
0,
clip1((q2 + 2 * q1 + 2 * q0 + 2 * p0 + p1 + 4) >> 3),
);
set(plane, 1, clip1((q2 + q1 + q0 + p0 + 2) >> 2));
set(plane, 2, clip1((2 * q3 + 3 * q2 + q1 + q0 + p0 + 4) >> 3));
} else {
set(plane, 0, clip1((2 * q1 + q0 + p1 + 2) >> 2));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn low_qp_is_a_no_op() {
let (cw, ch) = (32u32, 32u32);
let mut y: Vec<u8> = (0..cw * ch).map(|i| ((i * 37) % 256) as u8).collect();
let mut u = vec![100u8; (cw * ch / 4) as usize];
let mut v = vec![160u8; (cw * ch / 4) as usize];
let (y0, u0, v0) = (y.clone(), u.clone(), v.clone());
deblock(&mut y, &mut u, &mut v, cw, ch, &[10; 4], |q| q);
assert_eq!(y, y0, "luma untouched at qp 10");
assert_eq!((u, v), (u0, v0), "chroma untouched at qp 10");
}
#[test]
fn flat_picture_survives_any_qp() {
let (cw, ch) = (48u32, 32u32);
for qp in [20, 30, 40, 51] {
let mut y = vec![137u8; (cw * ch) as usize];
let mut u = vec![90u8; (cw * ch / 4) as usize];
let mut v = vec![210u8; (cw * ch / 4) as usize];
deblock(&mut y, &mut u, &mut v, cw, ch, &[qp; 6], |q| q);
assert!(y.iter().all(|&s| s == 137), "luma moved at qp {qp}");
assert!(u.iter().all(|&s| s == 90), "cb moved at qp {qp}");
assert!(v.iter().all(|&s| s == 210), "cr moved at qp {qp}");
}
}
#[test]
fn a_macroblock_edge_step_is_smoothed_locally() {
let (cw, ch) = (32u32, 16u32);
let mut y: Vec<u8> = (0..cw * ch)
.map(|i| if (i % cw) < 16 { 100u8 } else { 130u8 })
.collect();
let before = y.clone();
let mut u = vec![128u8; (cw * ch / 4) as usize];
let mut v = vec![128u8; (cw * ch / 4) as usize];
deblock(&mut y, &mut u, &mut v, cw, ch, &[36; 2], |q| q);
let row = 8 * cw as usize;
let step_before = (before[row + 16] as i32 - before[row + 15] as i32).abs();
let step_after = (y[row + 16] as i32 - y[row + 15] as i32).abs();
assert!(
step_after < step_before,
"step {step_before} -> {step_after} at the macroblock edge"
);
for k in 0..11 {
assert_eq!(y[row + k], before[row + k], "column {k} is out of reach");
}
for k in 20..32 {
assert_eq!(y[row + k], before[row + k], "column {k} is out of reach");
}
}
}