use crate::place::put_block_data;
mod bc7;
use bc7::bc7_block;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Kind {
Bc1,
Bc2,
Bc3,
Bc4,
Bc5,
Bc7,
}
fn pick<T: Copy + Default>(table: &[T], i: usize) -> T {
table.get(i).copied().unwrap_or_default()
}
#[allow(
clippy::inline_always,
clippy::redundant_closure,
reason = "measured: every block's decode inlined"
)]
pub(crate) fn decode(kind: Kind, data: &[u8], w: usize, h: usize, out: &mut [u8]) {
let size = (w, h);
match kind {
Kind::Bc1 => blocks::<8, 16>(
data,
size,
out,
#[inline(always)]
|s, r| bc1_block(s, r),
),
Kind::Bc2 => blocks::<16, 16>(
data,
size,
out,
#[inline(always)]
|s, r| bc2_block(s, r),
),
Kind::Bc3 => blocks::<16, 16>(
data,
size,
out,
#[inline(always)]
|s, r| bc3_block(s, r),
),
Kind::Bc4 => blocks::<8, 4>(
data,
size,
out,
#[inline(always)]
|s, r| bc4_block(s, r),
),
Kind::Bc5 => blocks::<16, 12>(
data,
size,
out,
#[inline(always)]
|s, r| bc5_block(s, r),
),
Kind::Bc7 => blocks::<16, 16>(
data,
size,
out,
#[inline(always)]
|s, r| bc7_block(s, r),
),
}
}
#[allow(
clippy::inline_always,
reason = "measured: each block's decode inlined into the block loop"
)]
#[inline(always)]
fn blocks<const B: usize, const N: usize>(
data: &[u8],
(w, h): (usize, usize),
out: &mut [u8],
block: impl Fn(&[u8; B], [&mut [u8; N]; 4]),
) {
put_block_data(
out,
w.saturating_mul(N / 4),
h,
(w.div_ceil(4), h.div_ceil(4)),
data.as_chunks::<B>().0,
#[inline(always)]
|src, rows| {
block(src, rows);
true
},
);
}
#[allow(clippy::inline_always, reason = "measured: every block's decode")]
#[inline(always)]
fn bc1_block(src: &[u8; 8], rows: [&mut [u8; 16]; 4]) {
let colour = u64::from_le_bytes(*src);
let palette = bc1_palette(colour, false);
put_rgba::<0, 1>(rows, &palette, colour >> 32, &[0], 0);
}
#[allow(clippy::inline_always, reason = "measured: every block's decode")]
#[inline(always)]
fn bc2_block(src: &[u8; 16], rows: [&mut [u8; 16]; 4]) {
let (alpha, colour) = halves(src);
let palette = bc1_palette4(colour);
put_rgba::<4, 16>(rows, &palette, colour >> 32, &BC2_ALPHA, alpha);
}
#[allow(clippy::inline_always, reason = "measured: every block's decode")]
#[inline(always)]
fn bc3_block(src: &[u8; 16], rows: [&mut [u8; 16]; 4]) {
let (alpha, colour) = halves(src);
let palette = bc1_palette4(colour);
let values = bc3_palette::<24>(alpha);
put_rgba::<3, 8>(rows, &palette, colour >> 32, &values, alpha >> 16);
}
#[allow(clippy::inline_always, reason = "measured: every block's decode")]
#[inline(always)]
fn bc4_block(src: &[u8; 8], rows: [&mut [u8; 4]; 4]) {
let block = u64::from_le_bytes(*src);
let values = bc3_palette::<0>(block);
for (y, row) in rows.into_iter().enumerate() {
let [a, b, c, d] = [0, 1, 2, 3].map(|x| pick(&values, alpha_index(block, 4 * y + x)));
*row = (a | b << 8 | c << 16 | d << 24).to_le_bytes();
}
}
#[allow(clippy::inline_always, reason = "measured: every block's decode")]
#[inline(always)]
fn bc5_block(src: &[u8; 16], rows: [&mut [u8; 12]; 4]) {
let (red, green) = halves(src);
let (reds, greens) = (bc3_palette::<0>(red), bc3_palette::<8>(green));
for (y, row) in rows.into_iter().enumerate() {
let mut v = 0u128;
for x in 0..4 {
let n = 4 * y + x;
let px = pick(&reds, alpha_index(red, n)) | pick(&greens, alpha_index(green, n));
v |= u128::from(px) << (24 * x);
}
if let Some(bytes) = v.to_le_bytes().first_chunk::<12>() {
*row = *bytes;
}
}
}
#[inline]
fn alpha_index(block: u64, n: usize) -> usize {
#[allow(clippy::cast_possible_truncation, reason = "masked to 3 bits")]
let i = (block >> (16 + 3 * n) & 7) as usize;
i
}
fn halves(b: &[u8; 16]) -> (u64, u64) {
let v = u128::from_le_bytes(*b);
#[allow(clippy::cast_possible_truncation, reason = "the low half")]
(v as u64, (v >> 64) as u64)
}
#[allow(
clippy::indexing_slicing,
reason = "evaluated at compile time, av below 16"
)]
const BC2_ALPHA: [u32; 16] = {
let mut a = [0; 16];
let mut av: u32 = 0;
while av < 16 {
a[av as usize] = (av << 4 | av) << 24;
av += 1;
}
a
};
#[allow(clippy::inline_always, reason = "measured: every block's pixels")]
#[inline(always)]
fn put_rgba<const AB: u32, const A: usize>(
rows: [&mut [u8; 16]; 4],
palette: &[u32; 4],
lut: u64,
alpha: &[u32; A],
alut: u64,
) {
for (r, row) in rows.into_iter().enumerate() {
for (x, dst) in row.as_chunks_mut::<4>().0.iter_mut().enumerate() {
let n = 4 * r + x;
let (i, ai) = (
(lut >> (2 * n)) & 3,
(alut >> (AB as usize * n)) & ((1 << AB) - 1),
);
#[allow(clippy::cast_possible_truncation, reason = "masked indices")]
let p = pick(palette, i as usize) | if AB == 0 { 0 } else { pick(alpha, ai as usize) };
*dst = p.to_le_bytes();
}
}
}
fn decode_565(x: u32) -> [u32; 4] {
let mut r = (x & 0xf800) >> 8;
r |= r >> 5;
let mut g = (x & 0x7e0) >> 3;
g |= g >> 6;
let mut b = (x & 0x1f) << 3;
b |= b >> 5;
[r, g, b, 0xff]
}
#[inline]
fn bc1_palette(block: u64, separate_alpha: bool) -> [u32; 4] {
#[allow(clippy::cast_possible_truncation, reason = "the block's fields")]
let (c0, c1) = (u32::from(block as u16), u32::from((block >> 16) as u16));
let (l0, l1) = (lanes(decode_565(c0)), lanes(decode_565(c1)));
let third = |v: u64| unlanes((v * 683) >> 11);
let (t2, t3) = (third(2 * l0 + l1), third(l0 + 2 * l1));
#[allow(clippy::manual_midpoint, reason = "the lanes' sums, under 2^10")]
let half = unlanes((l0 + l1) >> 1);
let four = u32::from(c0 > c1 || separate_alpha).wrapping_neg();
[
unlanes(l0),
unlanes(l1),
(t2 & four) | (half & !four),
t3 & four,
]
}
#[inline]
fn bc1_palette4(block: u64) -> [u32; 4] {
#[allow(clippy::cast_possible_truncation, reason = "the block's fields")]
let (c0, c1) = (u32::from(block as u16), u32::from((block >> 16) as u16));
let ([r0, g0, b0, _], [r1, g1, b1, _]) = (decode_565(c0), decode_565(c1));
let third = |a: u32, b: u32| ((2 * a + b) * 683) >> 11;
let rgb = |r: u32, g: u32, b: u32| r | g << 8 | b << 16;
[
rgb(r0, g0, b0),
rgb(r1, g1, b1),
rgb(third(r0, r1), third(g0, g1), third(b0, b1)),
rgb(third(r1, r0), third(g1, g0), third(b1, b0)),
]
}
fn lanes([r, g, b, _]: [u32; 4]) -> u64 {
u64::from(r) | u64::from(g) << 21 | u64::from(b) << 42
}
fn unlanes(v: u64) -> u32 {
#[allow(clippy::cast_possible_truncation, reason = "masked to 3 bytes")]
let rgb = ((v & 0xFF) | (v >> 13 & 0xFF00) | (v >> 26 & 0xFF_0000)) as u32;
rgb | 0xFF00_0000
}
#[inline]
fn bc3_palette<const S: u32>(block: u64) -> [u32; 8] {
#[allow(clippy::cast_possible_truncation, reason = "the block's bytes")]
let (a0, a1) = (u32::from(block as u8), u32::from((block >> 8) as u8));
let ramp = |m: u32, d: u32| {
let step = a1.wrapping_sub(a0).wrapping_mul(m);
let mut product = ((d - 1) * a0 + a1) * m;
let mut out = [0; 6];
for o in &mut out {
*o = (product >> 16) << S;
product = product.wrapping_add(step);
}
out
};
let (e0, e1) = (a0 << S, a1 << S);
if a0 > a1 {
let [v2, v3, v4, v5, v6, v7] = ramp(u32::from(ALPHA_DIV[1]), 7);
[e0, e1, v2, v3, v4, v5, v6, v7]
} else {
let [v2, v3, v4, v5, ..] = ramp(u32::from(ALPHA_DIV[0]), 5);
[e0, e1, v2, v3, v4, v5, 0, 0xff << S]
}
}
const ALPHA_DIV: [u16; 2] = [13108, 9363];
#[cfg(test)]
mod tests {
#[test]
fn alpha_divisions_are_exact() {
for x in 0..2048_u64 {
assert_eq!((x * 683) >> 11, x / 3, "{x}");
}
for (d, m) in [(5_u16, super::ALPHA_DIV[0]), (7, super::ALPHA_DIV[1])] {
for x in 0..=255 * u32::from(d) {
assert_eq!((x * u32::from(m)) >> 16, x / u32::from(d), "{x} / {d}");
}
}
}
}