use crate::hevc::cabac::{CabacEncoder, CtxModel};
const INIT_LAST_X: [u8; 18] = [
110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, 79, 108, 123, 63,
];
const INIT_LAST_Y: [u8; 18] = INIT_LAST_X;
const INIT_CSBF: [u8; 4] = [91, 171, 134, 141];
const INIT_SIG: [u8; 42] = [
111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179,
153, 125, 107, 125, 141, 179, 153, 125, 140, 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
];
const INIT_GT1: [u8; 24] = [
140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107, 122, 152, 140, 179, 166,
182, 140, 227, 122, 197,
];
const INIT_GT2: [u8; 6] = [138, 153, 136, 167, 152, 152];
#[derive(Clone, Copy)]
pub struct ResidualCtx {
last_x: [CtxModel; 18],
last_y: [CtxModel; 18],
csbf: [CtxModel; 4],
sig: [CtxModel; 42],
gt1: [CtxModel; 24],
gt2: [CtxModel; 6],
}
impl ResidualCtx {
pub fn new(qp: i32) -> Self {
Self {
last_x: std::array::from_fn(|i| CtxModel::init(INIT_LAST_X[i], qp)),
last_y: std::array::from_fn(|i| CtxModel::init(INIT_LAST_Y[i], qp)),
csbf: std::array::from_fn(|i| CtxModel::init(INIT_CSBF[i], qp)),
sig: std::array::from_fn(|i| CtxModel::init(INIT_SIG[i], qp)),
gt1: std::array::from_fn(|i| CtxModel::init(INIT_GT1[i], qp)),
gt2: std::array::from_fn(|i| CtxModel::init(INIT_GT2[i], qp)),
}
}
}
pub fn scan_kxk(k: usize, scan_idx: u8) -> Vec<(usize, usize)> {
let mut v = Vec::with_capacity(k * k);
match scan_idx {
1 => {
for y in 0..k {
for x in 0..k {
v.push((x, y));
}
}
}
2 => {
for x in 0..k {
for y in 0..k {
v.push((x, y));
}
}
}
_ => {
for d in 0..(2 * k - 1) {
for x in 0..k {
let y = d as isize - x as isize;
if y >= 0 && (y as usize) < k {
v.push((x, y as usize));
}
}
}
}
}
v
}
pub fn full_scan(n: usize, scan_idx: u8) -> Vec<(usize, usize)> {
if n == 4 {
return scan_kxk(4, scan_idx);
}
let sb = scan_kxk(n / 4, scan_idx);
let inner = scan_kxk(4, scan_idx);
let mut out = Vec::with_capacity(n * n);
for &(sx, sy) in &sb {
for &(px, py) in &inner {
out.push((sx * 4 + px, sy * 4 + py));
}
}
out
}
#[inline]
fn log2(n: usize) -> usize {
n.trailing_zeros() as usize
}
const GROUP_IDX: [usize; 32] = [
0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
];
const MIN_IN_GROUP: [usize; 10] = [0, 1, 2, 3, 4, 6, 8, 12, 16, 24];
fn last_ctx(bin_idx: usize, log2n: usize, chroma: bool) -> usize {
if chroma {
15 + (bin_idx >> (log2n - 2))
} else {
let offset = 3 * (log2n - 2) + ((log2n - 1) >> 2);
let shift = (log2n + 1) >> 2;
(bin_idx >> shift) + offset
}
}
fn sig_ctx(
xc: usize,
yc: usize,
log2n: usize,
chroma: bool,
sub_nonzero: bool,
csbf_rb: u8,
scan_idx: u8,
) -> usize {
if log2n == 2 {
const MAP: [usize; 16] = [0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8];
let base = MAP[(yc << 2) + xc];
return if chroma { 27 + base } else { base };
}
if xc + yc == 0 {
return if chroma { 27 } else { 0 };
}
let (xp, yp) = (xc & 3, yc & 3);
let mut s = match csbf_rb {
0 => {
if xp + yp == 0 {
2
} else if xp + yp < 3 {
1
} else {
0
}
}
1 => {
if yp == 0 {
2
} else if yp == 1 {
1
} else {
0
}
}
2 => {
if xp == 0 {
2
} else if xp == 1 {
1
} else {
0
}
}
_ => 2,
};
if !chroma {
if sub_nonzero {
s += 3;
}
s + if log2n == 3 {
if scan_idx == 0 {
9
} else {
15
}
} else {
21
}
} else {
27 + s + if log2n == 3 { 9 } else { 12 }
}
}
pub fn encode(
cabac: &mut CabacEncoder,
ctx: &mut ResidualCtx,
coeff: &[i32],
n: usize,
chroma: bool,
scan_idx: u8,
) {
let log2n = log2(n);
let scan = full_scan(n, scan_idx);
let inner = scan_kxk(4, scan_idx);
let sb_per_side = n / 4;
let last_scan = (0..scan.len())
.rev()
.find(|&i| coeff[scan[i].1 * n + scan[i].0] != 0)
.unwrap();
let (last_x, last_y) = if scan_idx == 2 {
(scan[last_scan].1, scan[last_scan].0)
} else {
scan[last_scan]
};
let gx = code_last_prefix(cabac, &mut ctx.last_x, last_x, log2n, chroma);
let gy = code_last_prefix(cabac, &mut ctx.last_y, last_y, log2n, chroma);
code_last_suffix(cabac, last_x, gx);
code_last_suffix(cabac, last_y, gy);
let last_sb = last_scan / 16;
let last_pos_in_sb = last_scan % 16;
let mut csbf = vec![vec![false; sb_per_side]; sb_per_side];
let sb_scan = scan_kxk(sb_per_side, scan_idx);
let mut c1_carry = 1u32;
for si in (0..=last_sb).rev() {
let (sxs, sys) = sb_scan[si];
let mut infer_dc = false;
let is_first = si == 0;
let is_last = si == last_sb;
if !is_first && !is_last {
let rb = csbf_right_below(&csbf, sxs, sys, sb_per_side);
let ctx_i = (rb.min(1) as usize) + if chroma { 2 } else { 0 };
let bit = block_has_sig(coeff, n, sxs, sys, &inner);
cabac.encode_bin(&mut ctx.csbf[ctx_i], bit as u32);
csbf[sys][sxs] = bit;
if !bit {
continue;
}
infer_dc = true;
} else {
csbf[sys][sxs] = true;
}
let csbf_rb = csbf_right_below(&csbf, sxs, sys, sb_per_side);
let start = if is_last {
last_pos_in_sb as i32 - 1
} else {
15
};
let mut sig = [false; 16];
if is_last {
sig[last_pos_in_sb] = true;
}
let sub_nonzero = sxs + sys != 0;
let mut num_sig = if is_last { 1 } else { 0 };
for p in (0..=start).rev() {
let (px, py) = inner[p as usize];
let (xc, yc) = (sxs * 4 + px, sys * 4 + py);
if p == 0 && infer_dc && num_sig == 0 {
sig[0] = true;
num_sig += 1;
break;
}
let ci = sig_ctx(xc, yc, log2n, chroma, sub_nonzero, csbf_rb, scan_idx);
let bit = coeff[yc * n + xc] != 0;
cabac.encode_bin(&mut ctx.sig[ci], bit as u32);
if bit {
sig[p as usize] = true;
num_sig += 1;
}
}
if num_sig == 0 {
continue;
}
let mut abs_levels = Vec::with_capacity(num_sig);
let mut positions = Vec::with_capacity(num_sig);
for p in (0..16).rev() {
if sig[p] {
let (px, py) = inner[p];
let (xc, yc) = (sxs * 4 + px, sys * 4 + py);
abs_levels.push(coeff[yc * n + xc].unsigned_abs());
positions.push((xc, yc));
}
}
let ctx_set_base = if si > 0 && !chroma { 2 } else { 0 };
let ctx_set = ctx_set_base + if c1_carry == 0 { 1 } else { 0 };
let mut c1 = 1u32;
let mut first_gt1: i32 = -1;
let n_gt1 = abs_levels.len().min(8);
for idx in 0..n_gt1 {
let bin = (abs_levels[idx] > 1) as u32;
let base = if chroma { 16 } else { 0 };
let ci = base + (ctx_set << 2) + c1 as usize;
cabac.encode_bin(&mut ctx.gt1[ci], bin);
if bin == 1 {
c1 = 0;
if first_gt1 < 0 {
first_gt1 = idx as i32;
}
} else if c1 > 0 && c1 < 3 {
c1 += 1;
}
}
c1_carry = c1;
if first_gt1 >= 0 {
let bin = (abs_levels[first_gt1 as usize] > 2) as u32;
let base = if chroma { 4 } else { 0 };
cabac.encode_bin(&mut ctx.gt2[base + ctx_set], bin);
}
for &(xc, yc) in &positions {
let sign = (coeff[yc * n + xc] < 0) as u32;
cabac.encode_bypass(sign);
}
let mut first_coeff2 = 1u32;
let mut rice = 0u32;
for (idx, &abs) in abs_levels.iter().enumerate() {
let base_level = if idx < 8 { 2 + first_coeff2 } else { 1 };
if abs >= base_level {
write_remaining(cabac, abs - base_level, rice);
if abs > 3 * (1 << rice) {
rice = (rice + 1).min(4);
}
}
if abs >= 2 {
first_coeff2 = 0;
}
}
}
}
fn code_last_prefix(
cabac: &mut CabacEncoder,
ctxs: &mut [CtxModel],
pos: usize,
log2n: usize,
chroma: bool,
) -> usize {
let group = GROUP_IDX[pos];
let c_max = (log2n << 1) - 1;
for b in 0..group {
cabac.encode_bin(&mut ctxs[last_ctx(b, log2n, chroma)], 1);
}
if group < c_max {
cabac.encode_bin(&mut ctxs[last_ctx(group, log2n, chroma)], 0);
}
group
}
fn code_last_suffix(cabac: &mut CabacEncoder, pos: usize, group: usize) {
if group > 3 {
let nbits = (group >> 1) - 1;
let suffix = (pos - MIN_IN_GROUP[group]) as u32;
cabac.encode_bypass_bits(suffix, nbits as u32);
}
}
fn write_remaining(cabac: &mut CabacEncoder, value: u32, rice: u32) {
let threshold = 3u32 << rice;
if value < threshold {
let prefix = value >> rice;
for _ in 0..prefix {
cabac.encode_bypass(1);
}
cabac.encode_bypass(0);
if rice > 0 {
cabac.encode_bypass_bits(value & ((1 << rice) - 1), rice);
}
} else {
let mut v = value - threshold;
let mut len = rice;
while v >= (1 << len) {
v -= 1 << len;
len += 1;
}
let prefix_ones = 3 + len - rice;
for _ in 0..prefix_ones {
cabac.encode_bypass(1);
}
cabac.encode_bypass(0);
cabac.encode_bypass_bits(v, len);
}
}
fn csbf_right_below(csbf: &[Vec<bool>], sx: usize, sy: usize, side: usize) -> u8 {
let right = if sx + 1 < side {
csbf[sy][sx + 1] as u8
} else {
0
};
let below = if sy + 1 < side {
csbf[sy + 1][sx] as u8
} else {
0
};
right + 2 * below
}
fn block_has_sig(
coeff: &[i32],
n: usize,
sxs: usize,
sys: usize,
inner: &[(usize, usize)],
) -> bool {
inner
.iter()
.any(|&(px, py)| coeff[(sys * 4 + py) * n + (sxs * 4 + px)] != 0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn last_significant_coefficient_groups_tile_the_positions() {
for (pos, &g) in GROUP_IDX.iter().enumerate() {
let first = GROUP_IDX.iter().position(|&x| x == g).unwrap();
assert_eq!(MIN_IN_GROUP[g], first, "group {g} starts at {first}");
assert!(pos >= MIN_IN_GROUP[g], "position {pos} precedes its group");
}
for g in 4..MIN_IN_GROUP.len() {
let end = MIN_IN_GROUP.get(g + 1).copied().unwrap_or(GROUP_IDX.len());
let span = end - MIN_IN_GROUP[g];
assert_eq!(span, 1 << ((g >> 1) - 1), "group {g} spans {span}");
}
assert_eq!(GROUP_IDX[31], (5 << 1) - 1);
}
use crate::hevc::cabac::CtxModel;
include!("residual_decode_test.rs");
}