use crate::bit_writer::BitWriter;
use crate::coder_scratch::CoderScratch;
use crate::encode_image::AlphaPlane;
use crate::entropy::{
HuffmanNode, OwnedEntropyCode, Token, optimize_entropy_code, pack_signed, write_entropy_code,
write_prefix_codes, write_token,
};
use std::sync::OnceLock;
const TREE_CTX_SPLITVAL: u32 = 0;
const TREE_CTX_PROPERTY: u32 = 1;
const TREE_CTX_PREDICTOR: u32 = 2;
const TREE_CTX_OFFSET: u32 = 3;
const TREE_CTX_MULTIPLIER_LOG: u32 = 4;
const TREE_CTX_MULTIPLIER_BITS: u32 = 5;
const NUM_TREE_CONTEXTS: usize = 6;
const PREDICTOR_GRADIENT: u32 = 5;
const GROUP_DIM: usize = 256;
pub(crate) fn write_lfglobal_alpha_section(
alpha: &AlphaPlane,
xsize: usize,
ysize: usize,
step: u32,
global_code_ans: bool,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
assert_eq!(alpha.len(), xsize * ysize);
if xsize <= GROUP_DIM && ysize <= GROUP_DIM && step > 1 {
write_lattice_section(alpha, step, 0, 0, xsize, ysize, xsize, scratch, w);
} else if xsize <= GROUP_DIM && ysize <= GROUP_DIM {
let tokens = tokenize_channel(alpha, xsize, ysize);
let mut plain = BitWriter::new();
{
write_group_header_local_tree(&mut plain);
let pixel_code = build_pixel_code(&tokens, scratch);
write_tree_and_pixel_histograms(&pixel_code, scratch, &mut plain);
let code_ref = pixel_code.as_ref();
for tok in &tokens {
write_token(*tok, &code_ref, &mut plain);
}
}
let mut lz = BitWriter::new();
let lz_ok = crate::lossless::write_single_channel_lz77_section(&tokens, scratch, &mut lz);
if lz_ok && lz.bits_written() < plain.bits_written() {
w.append(&lz);
} else {
w.append(&plain);
}
} else {
write_group_header_global_tree(w);
if global_code_ans {
w.write(32, u64::from(crate::entropy::ANS_SIGNATURE << 16));
}
}
}
#[inline]
pub(crate) fn write_global_alpha_modular(
alpha: &AlphaPlane,
xsize: usize,
ysize: usize,
step: u32,
global_code_ans: bool,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
write_lfglobal_alpha_section(alpha, xsize, ysize, step, global_code_ans, scratch, w);
}
pub(crate) fn write_ac_group_alpha(
alpha: &AlphaPlane,
full_xsize: usize,
full_ysize: usize,
x0: usize,
y0: usize,
gw: usize,
gh: usize,
step: u32,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
if full_xsize <= GROUP_DIM && full_ysize <= GROUP_DIM {
return;
}
if step > 1 {
write_lattice_section(alpha, step, x0, y0, gw, gh, full_xsize, scratch, w);
return;
}
let full_size = full_xsize
.checked_mul(full_ysize)
.expect("alpha dimensions overflow usize");
assert_eq!(alpha.len(), full_size);
assert!(x0 <= full_xsize && gw <= full_xsize - x0);
assert!(y0 <= full_ysize && gh <= full_ysize - y0);
let token_count = gw
.checked_mul(gh)
.expect("alpha group size overflows usize");
scratch.alpha_tokens.resize(token_count, Token::new(0, 0));
if token_count != 0 {
match alpha {
AlphaPlane::U8(data) => tokenize_ac_group_alpha_u8(
data,
full_xsize,
x0,
y0,
gw,
gh,
&mut scratch.alpha_tokens,
),
AlphaPlane::U16 { data, .. } => tokenize_ac_group_alpha_u16(
data,
full_xsize,
x0,
y0,
gw,
gh,
&mut scratch.alpha_tokens,
),
AlphaPlane::F32(data) => {
tokenize_ac_group_alpha(data, full_xsize, x0, y0, gw, gh, &mut scratch.alpha_tokens)
}
}
}
let tokens = std::mem::take(&mut scratch.alpha_tokens);
let mut plain = BitWriter::new();
{
const NUM_CTX: usize = 2; let pixel_code = build_pixel_code_n(&tokens, NUM_CTX, &mut scratch.huffman_pool);
write_group_header_local_tree(&mut plain); write_split_tree(scratch, &mut plain); plain.write(1, 0); write_entropy_code(&pixel_code.as_ref(), &mut scratch.huffman_pool, &mut plain);
let code_ref = pixel_code.as_ref();
for tok in &tokens {
write_token(*tok, &code_ref, &mut plain);
}
}
let mut lz = BitWriter::new();
let lz_ok = crate::lossless::write_single_channel_lz77_section(&tokens, scratch, &mut lz);
scratch.alpha_tokens = tokens;
if lz_ok && lz.bits_written() < plain.bits_written() {
w.append(&lz);
} else {
w.append(&plain);
}
}
pub(crate) fn write_global_palette_alpha_modular(
entries: &[i32],
bits: u8,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
let meta = if bits <= 8 {
AlphaPlane::U8(entries.iter().map(|&v| v as u8).collect())
} else {
AlphaPlane::U16 {
data: entries.iter().map(|&v| v as u16).collect(),
bits,
}
};
let tokens = tokenize_channel(&meta, entries.len(), 1);
w.write(1, 0); w.write(1, 1); crate::lossless::write_palette_transform(1, entries.len() as u32, w);
let pixel_code = build_pixel_code(&tokens, scratch);
write_tree_and_pixel_histograms(&pixel_code, scratch, w);
let code_ref = pixel_code.as_ref();
for tok in &tokens {
write_token(*tok, &code_ref, w);
}
}
pub(crate) fn snap_to_lattice(plane: &mut AlphaPlane, step: u32) {
let max = match plane {
AlphaPlane::U8(_) => 255u32,
AlphaPlane::U16 { bits, .. } => (1u32 << *bits) - 1,
AlphaPlane::F32(_) => unreachable!("float planes are not quantized"),
};
let snap = |v: u32| -> u32 {
let ink = max - v.min(max);
let q = ((ink + step / 2) / step) * step;
max - q.min(max - max % step)
};
match plane {
AlphaPlane::U8(data) => data.iter_mut().for_each(|v| *v = snap(u32::from(*v)) as u8),
AlphaPlane::U16 { data, .. } => data
.iter_mut()
.for_each(|v| *v = snap(u32::from(*v)) as u16),
AlphaPlane::F32(_) => unreachable!(),
}
}
#[allow(clippy::too_many_arguments)]
fn write_lattice_section(
plane: &AlphaPlane,
step: u32,
x0: usize,
y0: usize,
gw: usize,
gh: usize,
stride: usize,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
const PROP_Y: u32 = 2;
const PROP_X: u32 = 3;
const PREDICTOR_ZERO: u32 = 0;
let max = match plane {
AlphaPlane::U8(_) => 255i32,
AlphaPlane::U16 { bits, .. } => (1i32 << *bits) - 1,
AlphaPlane::F32(_) => unreachable!(),
};
let step_i = step as i32;
let residue = max.rem_euclid(step_i);
let log = step.trailing_zeros();
let bits = (step >> log) - 1;
let leaf = |predictor: u32, offset: i32| {
[
Token::new(TREE_CTX_PROPERTY, 0),
Token::new(TREE_CTX_PREDICTOR, predictor),
Token::new(TREE_CTX_OFFSET, pack_signed(offset)),
Token::new(TREE_CTX_MULTIPLIER_LOG, log),
Token::new(TREE_CTX_MULTIPLIER_BITS, bits),
]
};
let mut tree_tokens = vec![
Token::new(TREE_CTX_PROPERTY, PROP_Y + 1),
Token::new(TREE_CTX_SPLITVAL, pack_signed(0)),
];
tree_tokens.extend(leaf(PREDICTOR_GRADIENT, 0));
tree_tokens.extend([
Token::new(TREE_CTX_PROPERTY, PROP_X + 1),
Token::new(TREE_CTX_SPLITVAL, pack_signed(0)),
]);
tree_tokens.extend(leaf(PREDICTOR_GRADIENT, 0));
tree_tokens.extend(leaf(PREDICTOR_ZERO, residue));
let mut tokens = Vec::with_capacity(gw * gh);
for y in 0..gh {
for x in 0..gw {
let at = |dx: usize, dy: usize| plane.get_i32((y0 + y - dy) * stride + x0 + x - dx);
let v = at(0, 0);
let (context, pred) = match (x, y) {
(0, 0) => (2, residue),
(_, 0) => (1, at(1, 0)),
(0, _) => (0, at(0, 1)),
_ => (0, gradient(at(1, 0), at(0, 1), at(1, 1))),
};
debug_assert_eq!((v - pred).rem_euclid(step_i), 0, "value off the lattice");
tokens.push(Token::new(context, pack_signed((v - pred) / step_i)));
}
}
write_group_header_local_tree(w);
let tree_code =
optimize_entropy_code(&tree_tokens, NUM_TREE_CONTEXTS, &mut scratch.huffman_pool);
w.write(1, 0); write_entropy_code(&tree_code.as_ref(), &mut scratch.huffman_pool, w);
for tok in &tree_tokens {
write_token(*tok, &tree_code.as_ref(), w);
}
let pixel_code = build_pixel_code_n(&tokens, 3, &mut scratch.huffman_pool);
w.write(1, 0); write_entropy_code(&pixel_code.as_ref(), &mut scratch.huffman_pool, w);
let code_ref = pixel_code.as_ref();
for tok in &tokens {
write_token(*tok, &code_ref, w);
}
}
trait AlphaSample: Copy {
const ZERO: Self;
fn to_i32(self) -> i32;
}
impl AlphaSample for u8 {
const ZERO: Self = 0;
#[inline]
fn to_i32(self) -> i32 {
self as i32
}
}
impl AlphaSample for u16 {
const ZERO: Self = 0;
#[inline]
fn to_i32(self) -> i32 {
self as i32
}
}
impl AlphaSample for i32 {
const ZERO: Self = 0;
#[inline]
fn to_i32(self) -> i32 {
self
}
}
#[inline]
fn alpha_token<T: AlphaSample>(v: T, w: T, n: T, nw: T) -> Token {
let v = v.to_i32();
let w = w.to_i32();
let n = n.to_i32();
let nw = nw.to_i32();
let grad = w + n - nw;
let pred = grad.clamp(w.min(n), w.max(n));
let context = if grad > 0 { 0 } else { 1 };
Token::new(context, pack_signed(v - pred))
}
#[inline]
pub(crate) fn alpha_token_u8(v: u8, w: u8, n: u8, nw: u8) -> Token {
alpha_token(v, w, n, nw)
}
#[inline]
pub(crate) fn alpha_token_u16(v: u16, w: u16, n: u16, nw: u16) -> Token {
alpha_token(v, w, n, nw)
}
type TokenizeAlphaFirstRowFn<T> = fn(&[T], &mut [Token]);
type TokenizeAlphaInteriorFn<T> = fn(&[T], &[T], &mut [Token]);
type TokenizeAlphaFns<T> = (TokenizeAlphaFirstRowFn<T>, TokenizeAlphaInteriorFn<T>);
type TokenizeAlphaU8Fns = TokenizeAlphaFns<u8>;
#[cfg(not(all(target_arch = "aarch64", feature = "neon")))]
fn tokenize_alpha_u8_first_row_scalar(row: &[u8], out: &mut [Token]) {
debug_assert_eq!(row.len(), out.len());
for ((&value, &west), out) in row[1..].iter().zip(row.iter()).zip(out[1..].iter_mut()) {
*out = alpha_token_u8(value, west, 0, 0);
}
}
#[cfg(not(all(target_arch = "aarch64", feature = "neon")))]
fn tokenize_alpha_u8_interior_scalar(row: &[u8], north: &[u8], out: &mut [Token]) {
debug_assert_eq!(row.len(), north.len());
debug_assert_eq!(row.len(), out.len());
for ((((&value, &west), &north), &northwest), out) in row[1..]
.iter()
.zip(row.iter())
.zip(north[1..].iter())
.zip(north.iter())
.zip(out[1..].iter_mut())
{
*out = alpha_token_u8(value, west, north, northwest);
}
}
#[cfg(all(target_arch = "aarch64", feature = "neon"))]
fn select_tokenize_alpha_u8() -> TokenizeAlphaU8Fns {
(
|row, out| unsafe { crate::neon::tokenize_alpha_u8_first_row_neon(row, out) },
|row, north, out| unsafe { crate::neon::tokenize_alpha_u8_interior_neon(row, north, out) },
)
}
#[cfg(not(all(target_arch = "aarch64", feature = "neon")))]
fn select_tokenize_alpha_u8() -> TokenizeAlphaU8Fns {
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
if std::is_x86_feature_detected!("avx2") {
return (
|row, out| unsafe { crate::avx::tokenize_alpha_u8_first_row_avx2(row, out) },
|row, north, out| unsafe {
crate::avx::tokenize_alpha_u8_interior_avx2(row, north, out)
},
);
}
#[cfg(all(any(target_arch = "x86_64", target_arch = "x86"), feature = "sse"))]
if std::is_x86_feature_detected!("sse4.1") {
return (
|row, out| unsafe { crate::sse::tokenize_alpha_u8_first_row_sse41(row, out) },
|row, north, out| unsafe {
crate::sse::tokenize_alpha_u8_interior_sse41(row, north, out)
},
);
}
(
tokenize_alpha_u8_first_row_scalar,
tokenize_alpha_u8_interior_scalar,
)
}
static TOKENIZE_ALPHA_U8: OnceLock<TokenizeAlphaU8Fns> = OnceLock::new();
#[inline]
fn selected_tokenize_alpha_u8() -> TokenizeAlphaU8Fns {
*TOKENIZE_ALPHA_U8.get_or_init(select_tokenize_alpha_u8)
}
fn tokenize_ac_group_alpha_with<T: AlphaSample>(
first_row: TokenizeAlphaFirstRowFn<T>,
interior: TokenizeAlphaInteriorFn<T>,
samples: &[T],
stride: usize,
x0: usize,
y0: usize,
gw: usize,
gh: usize,
dst: &mut [Token],
) {
debug_assert_ne!(gw, 0);
debug_assert_ne!(gh, 0);
debug_assert_eq!(dst.len(), gw * gh);
let mut src_rows = samples.chunks_exact(stride).skip(y0).take(gh);
let mut dst_rows = dst.chunks_exact_mut(gw);
let first = &src_rows.next().unwrap()[x0..x0 + gw];
let first_dst = dst_rows.next().unwrap();
let (&first_value, _) = first.split_first().unwrap();
let (first_out, _) = first_dst.split_first_mut().unwrap();
*first_out = alpha_token(first_value, T::ZERO, T::ZERO, T::ZERO);
first_row(first, first_dst);
let mut north = first;
for (row, out) in src_rows.zip(dst_rows) {
let row = &row[x0..x0 + gw];
let (&value, _) = row.split_first().unwrap();
let (&north_value, _) = north.split_first().unwrap();
let (first_out, _) = out.split_first_mut().unwrap();
*first_out = alpha_token(value, T::ZERO, north_value, T::ZERO);
interior(row, north, out);
north = row;
}
}
#[inline]
fn tokenize_ac_group_alpha_u8(
samples: &[u8],
stride: usize,
x0: usize,
y0: usize,
gw: usize,
gh: usize,
dst: &mut [Token],
) {
let (first_row, interior) = selected_tokenize_alpha_u8();
tokenize_ac_group_alpha_with(first_row, interior, samples, stride, x0, y0, gw, gh, dst);
}
type TokenizeAlphaU16Fns = TokenizeAlphaFns<u16>;
#[cfg(not(all(target_arch = "aarch64", feature = "neon")))]
fn tokenize_alpha_u16_first_row_scalar(row: &[u16], out: &mut [Token]) {
debug_assert_eq!(row.len(), out.len());
for ((&value, &west), out) in row[1..].iter().zip(row.iter()).zip(out[1..].iter_mut()) {
*out = alpha_token_u16(value, west, 0, 0);
}
}
#[cfg(not(all(target_arch = "aarch64", feature = "neon")))]
fn tokenize_alpha_u16_interior_scalar(row: &[u16], north: &[u16], out: &mut [Token]) {
debug_assert_eq!(row.len(), north.len());
debug_assert_eq!(row.len(), out.len());
for ((((&value, &west), &north), &northwest), out) in row[1..]
.iter()
.zip(row.iter())
.zip(north[1..].iter())
.zip(north.iter())
.zip(out[1..].iter_mut())
{
*out = alpha_token_u16(value, west, north, northwest);
}
}
#[cfg(all(target_arch = "aarch64", feature = "neon"))]
fn select_tokenize_alpha_u16() -> TokenizeAlphaU16Fns {
(
|row, out| unsafe { crate::neon::tokenize_alpha_u16_first_row_neon(row, out) },
|row, north, out| unsafe { crate::neon::tokenize_alpha_u16_interior_neon(row, north, out) },
)
}
#[cfg(not(all(target_arch = "aarch64", feature = "neon")))]
fn select_tokenize_alpha_u16() -> TokenizeAlphaU16Fns {
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
if std::is_x86_feature_detected!("avx2") {
return (
|row, out| unsafe { crate::avx::tokenize_alpha_u16_first_row_avx2(row, out) },
|row, north, out| unsafe {
crate::avx::tokenize_alpha_u16_interior_avx2(row, north, out)
},
);
}
#[cfg(all(any(target_arch = "x86_64", target_arch = "x86"), feature = "sse"))]
if std::is_x86_feature_detected!("sse4.1") {
return (
|row, out| unsafe { crate::sse::tokenize_alpha_u16_first_row_sse41(row, out) },
|row, north, out| unsafe {
crate::sse::tokenize_alpha_u16_interior_sse41(row, north, out)
},
);
}
(
tokenize_alpha_u16_first_row_scalar,
tokenize_alpha_u16_interior_scalar,
)
}
static TOKENIZE_ALPHA_U16: OnceLock<TokenizeAlphaU16Fns> = OnceLock::new();
#[inline]
fn selected_tokenize_alpha_u16() -> TokenizeAlphaU16Fns {
*TOKENIZE_ALPHA_U16.get_or_init(select_tokenize_alpha_u16)
}
#[inline]
fn tokenize_ac_group_alpha_u16(
samples: &[u16],
stride: usize,
x0: usize,
y0: usize,
gw: usize,
gh: usize,
dst: &mut [Token],
) {
let (first_row, interior) = selected_tokenize_alpha_u16();
tokenize_ac_group_alpha_with(first_row, interior, samples, stride, x0, y0, gw, gh, dst);
}
fn tokenize_ac_group_alpha<T: AlphaSample>(
samples: &[T],
stride: usize,
x0: usize,
y0: usize,
gw: usize,
gh: usize,
dst: &mut [Token],
) {
debug_assert_ne!(gw, 0);
debug_assert_ne!(gh, 0);
debug_assert_eq!(dst.len(), gw * gh);
let mut src_rows = samples.chunks_exact(stride).skip(y0).take(gh);
let mut dst_rows = dst.chunks_exact_mut(gw);
let first = &src_rows.next().unwrap()[x0..x0 + gw];
let first_dst = dst_rows.next().unwrap();
first_dst[0] = alpha_token(first[0], T::ZERO, T::ZERO, T::ZERO);
for ((&v, &w), out) in first[1..]
.iter()
.zip(first[..gw - 1].iter())
.zip(first_dst[1..].iter_mut())
{
*out = alpha_token(v, w, T::ZERO, T::ZERO);
}
let mut north = first;
for (row, out) in src_rows.zip(dst_rows) {
let row = &row[x0..x0 + gw];
out[0] = alpha_token(row[0], T::ZERO, north[0], T::ZERO);
for ((((&v, &w), &n), &nw), out) in row[1..]
.iter()
.zip(row[..gw - 1].iter())
.zip(north[1..].iter())
.zip(north[..gw - 1].iter())
.zip(out[1..].iter_mut())
{
*out = alpha_token(v, w, n, nw);
}
north = row;
}
}
pub(crate) fn write_group_header_local_tree(w: &mut BitWriter) {
w.write(1, 0); w.write(1, 1); w.write(2, 0); }
fn write_group_header_global_tree(w: &mut BitWriter) {
w.write(1, 1); w.write(1, 1); w.write(2, 0); }
pub(crate) fn write_tree_and_pixel_histograms(
pixel_code: &OwnedEntropyCode,
scratch: &mut CoderScratch,
w: &mut BitWriter,
) {
let tree_tokens = [
Token::new(TREE_CTX_PROPERTY, 0),
Token::new(TREE_CTX_PREDICTOR, PREDICTOR_GRADIENT),
Token::new(TREE_CTX_OFFSET, pack_signed(0)),
Token::new(TREE_CTX_MULTIPLIER_LOG, 0),
Token::new(TREE_CTX_MULTIPLIER_BITS, 0),
];
let tree_code =
optimize_entropy_code(&tree_tokens, NUM_TREE_CONTEXTS, &mut scratch.huffman_pool);
let tree_code_ref = tree_code.as_ref();
w.write(1, 0); write_entropy_code(&tree_code_ref, &mut scratch.huffman_pool, w);
for tok in &tree_tokens {
write_token(*tok, &tree_code_ref, w);
}
w.write(1, 0); write_prefix_codes(
&pixel_code.prefix_codes,
&pixel_code.hybrid_uint_configs,
&mut scratch.huffman_pool,
w,
);
}
#[allow(dead_code)]
fn write_split_tree(scratch: &mut CoderScratch, w: &mut BitWriter) {
const PROP_GRAD: u32 = 9;
let tree_tokens = [
Token::new(TREE_CTX_PROPERTY, PROP_GRAD + 1),
Token::new(TREE_CTX_SPLITVAL, pack_signed(0)),
Token::new(TREE_CTX_PROPERTY, 0),
Token::new(TREE_CTX_PREDICTOR, PREDICTOR_GRADIENT),
Token::new(TREE_CTX_OFFSET, pack_signed(0)),
Token::new(TREE_CTX_MULTIPLIER_LOG, 0),
Token::new(TREE_CTX_MULTIPLIER_BITS, 0),
Token::new(TREE_CTX_PROPERTY, 0),
Token::new(TREE_CTX_PREDICTOR, PREDICTOR_GRADIENT),
Token::new(TREE_CTX_OFFSET, pack_signed(0)),
Token::new(TREE_CTX_MULTIPLIER_LOG, 0),
Token::new(TREE_CTX_MULTIPLIER_BITS, 0),
];
let tree_code =
optimize_entropy_code(&tree_tokens, NUM_TREE_CONTEXTS, &mut scratch.huffman_pool);
let tree_code_ref = tree_code.as_ref();
w.write(1, 0); write_entropy_code(&tree_code_ref, &mut scratch.huffman_pool, w);
for tok in &tree_tokens {
write_token(*tok, &tree_code_ref, w);
}
}
pub(crate) fn build_pixel_code(tokens: &[Token], scratch: &mut CoderScratch) -> OwnedEntropyCode {
build_pixel_code_n(tokens, 1, &mut scratch.huffman_pool)
}
fn build_pixel_code_n(
tokens: &[Token],
num_contexts: usize,
huffman_pool: &mut Vec<HuffmanNode>,
) -> OwnedEntropyCode {
let mut code = if num_contexts > 1 {
crate::entropy::build_entropy_code_no_cluster(tokens, num_contexts, huffman_pool)
} else {
optimize_entropy_code(tokens, num_contexts, huffman_pool)
};
for pc in &mut code.prefix_codes {
let mut nonzero = 0;
let mut idx = 0;
for (i, &d) in pc.depths.iter().enumerate() {
if d != 0 {
nonzero += 1;
idx = i;
if nonzero > 1 {
break;
}
}
}
if nonzero == 1 {
if idx == 0 {
pc.depths[idx] = 0;
pc.bits[idx] = 0;
} else {
pc.depths[0] = 1;
pc.bits[0] = 0;
pc.depths[idx] = 1;
pc.bits[idx] = 1;
}
}
pc.update_single_symbol();
}
code
}
#[inline]
pub(crate) fn gradient(w: i32, n: i32, nw: i32) -> i32 {
let lo = w.min(n);
let hi = w.max(n);
(w + n - nw).clamp(lo, hi)
}
fn tokenize_channel(alpha: &AlphaPlane, xsize: usize, ysize: usize) -> Vec<Token> {
let mut tokens = vec![Token::new(0, 0); xsize * ysize];
if tokens.is_empty() {
return tokens;
}
match alpha {
AlphaPlane::U8(data) => {
tokenize_ac_group_alpha_u8(data, xsize, 0, 0, xsize, ysize, &mut tokens)
}
AlphaPlane::U16 { data, .. } => {
tokenize_ac_group_alpha_u16(data, xsize, 0, 0, xsize, ysize, &mut tokens)
}
AlphaPlane::F32(data) => {
tokenize_ac_group_alpha(data, xsize, 0, 0, xsize, ysize, &mut tokens)
}
}
for token in &mut tokens {
token.context = 0;
}
tokens
}
#[cfg(test)]
mod tests {
use super::*;
use crate::encode_image::AlphaPlane;
fn check_ac_group_tokenization<T: AlphaSample>(
samples: &[T],
stride: usize,
x0: usize,
y0: usize,
gw: usize,
gh: usize,
) {
let mut actual = vec![Token::new(0, 0); gw * gh];
tokenize_ac_group_alpha(samples, stride, x0, y0, gw, gh, &mut actual);
for gy in 0..gh {
for gx in 0..gw {
let at = |x: usize, y: usize| samples[(y0 + y) * stride + x0 + x].to_i32();
let v = at(gx, gy);
let w = if gx == 0 { 0 } else { at(gx - 1, gy) };
let n = if gy == 0 { 0 } else { at(gx, gy - 1) };
let nw = if gx == 0 || gy == 0 {
0
} else {
at(gx - 1, gy - 1)
};
let pred = gradient(w, n, nw);
let expected =
Token::new(if w + n - nw > 0 { 0 } else { 1 }, pack_signed(v - pred));
let actual = &actual[gy * gw + gx];
assert_eq!(actual.context, expected.context);
assert_eq!(actual.value, expected.value);
}
}
}
fn check_u8_tokenizer((first_row, interior): TokenizeAlphaU8Fns) {
for &gw in &[1usize, 2, 7, 8, 9, 15, 16, 17, 31, 32, 255, 256] {
for &gh in &[1usize, 2, 3, 7] {
let x0 = 3;
let y0 = 2;
let stride = x0 + gw + 5;
let height = y0 + gh + 1;
let mut state = 0x1234_5678u32 ^ (gw as u32) ^ ((gh as u32) << 16);
let samples: Vec<u8> = (0..stride * height)
.map(|i| {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
match i & 7 {
0 => 0,
1 => 255,
_ => (state >> 24) as u8,
}
})
.collect();
let sentinel = Token::new(u32::MAX, u32::MAX);
let mut expected = vec![sentinel; gw * gh];
let mut actual = vec![sentinel; gw * gh];
tokenize_ac_group_alpha(&samples, stride, x0, y0, gw, gh, &mut expected);
tokenize_ac_group_alpha_with(
first_row,
interior,
&samples,
stride,
x0,
y0,
gw,
gh,
&mut actual,
);
for (i, (actual, expected)) in actual.iter().zip(&expected).enumerate() {
assert_eq!(
(actual.context, actual.value),
(expected.context, expected.value),
"u8 alpha token mismatch at index {i} for {gw}x{gh}",
);
}
}
}
}
fn check_u16_tokenizer((first_row, interior): TokenizeAlphaU16Fns) {
for gw in [1usize, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 255, 256] {
for gh in [1usize, 2, 3, 7] {
let x0 = 3;
let y0 = 2;
let stride = x0 + gw + 5;
let height = y0 + gh + 1;
let mut state = 0x89ab_cdefu32 ^ (gw as u32) ^ ((gh as u32) << 16);
let samples: Vec<u16> = (0..stride * height)
.map(|i| {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
match i & 7 {
0 => 0,
1 => u16::MAX,
_ => (state >> 16) as u16,
}
})
.collect();
let sentinel = Token::new(u32::MAX, u32::MAX);
let mut expected = vec![sentinel; gw * gh];
let mut actual = vec![sentinel; gw * gh];
tokenize_ac_group_alpha(&samples, stride, x0, y0, gw, gh, &mut expected);
tokenize_ac_group_alpha_with(
first_row,
interior,
&samples,
stride,
x0,
y0,
gw,
gh,
&mut actual,
);
for (i, (actual, expected)) in actual.iter().zip(&expected).enumerate() {
assert_eq!(
(actual.context, actual.value),
(expected.context, expected.value),
"u16 alpha token mismatch at index {i} for {gw}x{gh}",
);
}
}
}
}
#[test]
fn gradient_basic() {
assert_eq!(gradient(50, 50, 0), 50);
assert_eq!(gradient(50, 50, 100), 50);
assert_eq!(gradient(10, 20, 5), 20);
assert_eq!(gradient(10, 20, 25), 10);
assert_eq!(gradient(10, 20, 15), 15);
}
#[test]
fn tokenize_constant_zero() {
let chan = vec![0u8; 16 * 16];
let alpha = AlphaPlane::from_u8(chan);
let toks = tokenize_channel(&alpha, 16, 16);
for t in &toks {
assert_eq!(t.value, 0);
}
}
#[test]
fn tokenize_channel_matches_scalar_for_all_sample_types() {
for width in [
1usize, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 255, 256,
] {
for height in [1usize, 2, 7] {
let mut state = 0x1234_5678u32;
let samples: Vec<u16> = (0..width * height)
.map(|i| {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
match i & 7 {
0 => 0,
1 => u16::MAX,
_ => (state >> 16) as u16,
}
})
.collect();
for alpha in [
AlphaPlane::U8(samples.iter().map(|&v| v as u8).collect()),
AlphaPlane::U16 {
data: samples.clone(),
bits: 16,
},
AlphaPlane::F32(samples.iter().map(|&v| i32::from(v) - 32768).collect()),
] {
let tokens = tokenize_channel(&alpha, width, height);
assert_eq!(tokens.len(), width * height);
for y in 0..height {
for x in 0..width {
let at = |x, y| alpha.get_i32(y * width + x);
let west = if x > 0 { at(x - 1, y) } else { 0 };
let north = if y > 0 { at(x, y - 1) } else { 0 };
let northwest = if x > 0 && y > 0 { at(x - 1, y - 1) } else { 0 };
let expected = pack_signed(at(x, y) - gradient(west, north, northwest));
let token = tokens[y * width + x];
assert_eq!(
(token.context, token.value),
(0, expected),
"channel token mismatch at ({x}, {y}) for {width}x{height}",
);
}
}
}
}
}
}
#[test]
fn tokenize_empty_channel() {
for (width, height) in [(0, 0), (0, 3), (3, 0)] {
assert!(tokenize_channel(&AlphaPlane::U8(Vec::new()), width, height).is_empty());
}
}
#[test]
fn tokenize_ac_group_matches_scalar_for_all_sample_types() {
let u8_samples: Vec<u8> = (0..64).map(|v| ((v * 37 + 11) % 251) as u8).collect();
check_ac_group_tokenization(&u8_samples, 8, 2, 1, 5, 6);
check_ac_group_tokenization(&u8_samples, 8, 4, 3, 1, 1);
let u16_samples: Vec<u16> = (0..64).map(|v| ((v * 977 + 31) % 4096) as u16).collect();
check_ac_group_tokenization(&u16_samples, 8, 1, 2, 6, 5);
let i32_samples: Vec<i32> = (0..64).map(|v| (v * 43 + 17) % 257 - 128).collect();
check_ac_group_tokenization(&i32_samples, 8, 3, 1, 4, 7);
}
#[test]
fn selected_u8_ac_group_tokenizer_matches_scalar() {
check_u8_tokenizer(selected_tokenize_alpha_u8());
}
#[cfg(all(target_arch = "aarch64", feature = "neon"))]
#[test]
fn neon_u8_ac_group_tokenizer_matches_scalar() {
check_u8_tokenizer((
|row, out| unsafe { crate::neon::tokenize_alpha_u8_first_row_neon(row, out) },
|row, north, out| unsafe {
crate::neon::tokenize_alpha_u8_interior_neon(row, north, out)
},
));
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
#[test]
fn avx2_u8_ac_group_tokenizer_matches_scalar() {
if std::is_x86_feature_detected!("avx2") {
check_u8_tokenizer((
|row, out| unsafe { crate::avx::tokenize_alpha_u8_first_row_avx2(row, out) },
|row, north, out| unsafe {
crate::avx::tokenize_alpha_u8_interior_avx2(row, north, out)
},
));
}
}
#[cfg(all(any(target_arch = "x86_64", target_arch = "x86"), feature = "sse"))]
#[test]
fn sse41_u8_ac_group_tokenizer_matches_scalar() {
if std::is_x86_feature_detected!("sse4.1") {
check_u8_tokenizer((
|row, out| unsafe { crate::sse::tokenize_alpha_u8_first_row_sse41(row, out) },
|row, north, out| unsafe {
crate::sse::tokenize_alpha_u8_interior_sse41(row, north, out)
},
));
}
}
#[test]
fn selected_u16_ac_group_tokenizer_matches_scalar() {
check_u16_tokenizer(selected_tokenize_alpha_u16());
}
#[cfg(all(target_arch = "aarch64", feature = "neon"))]
#[test]
fn neon_u16_ac_group_tokenizer_matches_scalar() {
check_u16_tokenizer((
|row, out| unsafe { crate::neon::tokenize_alpha_u16_first_row_neon(row, out) },
|row, north, out| unsafe {
crate::neon::tokenize_alpha_u16_interior_neon(row, north, out)
},
));
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
#[test]
fn avx2_u16_ac_group_tokenizer_matches_scalar() {
if std::is_x86_feature_detected!("avx2") {
check_u16_tokenizer((
|row, out| unsafe { crate::avx::tokenize_alpha_u16_first_row_avx2(row, out) },
|row, north, out| unsafe {
crate::avx::tokenize_alpha_u16_interior_avx2(row, north, out)
},
));
}
}
#[cfg(all(any(target_arch = "x86_64", target_arch = "x86"), feature = "sse"))]
#[test]
fn sse41_u16_ac_group_tokenizer_matches_scalar() {
if std::is_x86_feature_detected!("sse4.1") {
check_u16_tokenizer((
|row, out| unsafe { crate::sse::tokenize_alpha_u16_first_row_sse41(row, out) },
|row, north, out| unsafe {
crate::sse::tokenize_alpha_u16_interior_sse41(row, north, out)
},
));
}
}
#[test]
fn write_alpha_small_emits_bytes() {
let mut w = BitWriter::new();
let chan = vec![128u8; 8 * 8];
let alpha = AlphaPlane::from_u8(chan);
let mut scratch = CoderScratch::default();
write_global_alpha_modular(&alpha, 8, 8, 1, true, &mut scratch, &mut w);
let bits = w.bits_written();
w.zero_pad_to_byte();
assert!(!w.into_bytes().is_empty());
assert!(bits > 0);
}
#[test]
fn write_alpha_large_emits_header_only() {
let chan = vec![200u8; 512 * 400];
let alpha = AlphaPlane::from_u8(chan);
let mut scratch = CoderScratch::default();
let bits = |ans: bool, scratch: &mut CoderScratch| {
let mut w = BitWriter::new();
write_lfglobal_alpha_section(&alpha, 512, 400, 1, ans, scratch, &mut w);
w.bits_written()
};
assert_eq!(bits(false, &mut scratch), 4);
assert_eq!(bits(true, &mut scratch), 4 + 32);
}
#[test]
fn near_constant_16bit_alpha_group_takes_the_lz77_section() {
let (w, h) = (512, 256);
let mut data = vec![u16::MAX; w * h];
data[1234] = u16::MAX - 1;
let alpha = AlphaPlane::U16 { data, bits: 16 };
let mut scratch = CoderScratch::default();
let mut section = BitWriter::new();
write_ac_group_alpha(&alpha, w, h, 0, 0, 256, 256, 1, &mut scratch, &mut section);
assert!(section.bits_written() < 1024, "{}", section.bits_written());
}
}