#[path = "dct_matrix.rs"]
mod matrix;
#[cfg(test)]
pub(crate) use matrix::{DCT_MATRIX, DST_MATRIX};
use matrix::{M4, M8, M16, M32, MDST};
use super::extent::extent;
const COEFF_MIN: i32 = -32768;
const COEFF_MAX: i32 = 32767;
const STAGE1_SHIFT: u32 = 7;
const MIN_BIT_DEPTH: u8 = 8;
const MAX_BIT_DEPTH: u8 = 16;
#[allow(clippy::manual_clamp)]
fn clip_coeff(v: i32) -> i32 {
if v < COEFF_MIN {
COEFF_MIN
} else if v > COEFF_MAX {
COEFF_MAX
} else {
v
}
}
const fn bd_shift_of(bit_depth: u8) -> Option<u32> {
if bit_depth >= MIN_BIT_DEPTH && bit_depth <= MAX_BIT_DEPTH {
Some(20 - bit_depth as u32)
} else {
None
}
}
fn mul_1d<const N: usize, const SKIP: bool>(
m: &[[i32; N]; N],
src: &[i32; N],
terms: usize,
) -> [i32; N] {
let mut acc = [0i32; N];
for j in 0..core::cmp::min(terms, N) {
let c = src[j];
if SKIP && c == 0 {
continue;
}
let row = &m[j];
for i in 0..N {
acc[i] += row[i] * c;
}
}
acc
}
fn two_stage<const N: usize, const BOUNDED: bool>(
block: &mut [i32],
m: &[[i32; N]; N],
bd_shift: u32,
) {
let b = &mut block[..N * N];
let (rows, cols) = if BOUNDED { extent(b, N) } else { (N, N) };
let rnd = 1i32 << (bd_shift - 1);
if BOUNDED && rows == 1 {
let mut g0 = [0i32; N];
for (g, &c) in g0.iter_mut().zip(b.iter()).take(cols) {
*g = clip_coeff((m[0][0] * c + (1 << (STAGE1_SHIFT - 1))) >> STAGE1_SHIFT);
}
let mut row = mul_1d::<N, true>(m, &g0, cols);
for v in row.iter_mut() {
*v = (*v + rnd) >> bd_shift;
}
for out in b.chunks_exact_mut(N) {
out.copy_from_slice(&row);
}
return;
}
let mut g = [[0i32; N]; N];
let mut col = [0i32; N];
for x in 0..cols {
for j in 0..rows {
col[j] = b[j * N + x];
}
let e = mul_1d::<N, BOUNDED>(m, &col, rows);
for y in 0..N {
g[y][x] = clip_coeff((e[y] + (1 << (STAGE1_SHIFT - 1))) >> STAGE1_SHIFT);
}
}
for y in 0..N {
if BOUNDED && cols == 1 {
b[y * N..y * N + N].fill((m[0][0] * g[y][0] + rnd) >> bd_shift);
continue;
}
let r = mul_1d::<N, BOUNDED>(m, &g[y], cols);
for i in 0..N {
b[y * N + i] = (r[i] + rnd) >> bd_shift;
}
}
}
pub fn inverse_transform(block: &mut [i32], n: usize, tr_type: u8, bit_depth: u8) {
let bd_shift = match bd_shift_of(bit_depth) {
Some(s) => s,
None => return,
};
match (tr_type, n) {
(1, 4) if block.len() >= 16 => two_stage::<4, false>(block, &MDST, bd_shift),
(0, 4) if block.len() >= 16 => two_stage::<4, false>(block, &M4, bd_shift),
(0, 8) if block.len() >= 64 => two_stage::<8, true>(block, &M8, bd_shift),
(0, 16) if block.len() >= 256 => two_stage::<16, true>(block, &M16, bd_shift),
(0, 32) if block.len() >= 1024 => two_stage::<32, true>(block, &M32, bd_shift),
_ => {}
}
}
pub fn transform_skip(block: &mut [i32], n: usize, bit_depth: u8, rotate: bool) {
let log2_n: u32 = match n {
4 => 2,
8 => 3,
16 => 4,
32 => 5,
_ => return,
};
let bd_shift = match bd_shift_of(bit_depth) {
Some(s) => s,
None => return,
};
if block.len() < n * n {
return;
}
let b = &mut block[..n * n];
if rotate {
b.reverse();
}
let ts_shift = 5 + log2_n;
let rnd = 1i32 << (bd_shift - 1);
for v in b.iter_mut() {
*v = ((*v << ts_shift) + rnd) >> bd_shift;
}
}
#[cfg(test)]
#[path = "dct_ref.rs"]
mod reference;
#[cfg(test)]
#[path = "dct_tests.rs"]
mod tests;