mod alpha;
#[cfg(test)]
mod alpha_tests;
mod cache;
mod calibrate;
mod closed_loop;
mod code;
mod fold;
mod forest;
mod layout;
#[cfg(feature = "extraslow")]
mod polish;
mod pyramid;
#[cfg(test)]
mod pyramid_tests;
mod quantize;
mod race;
mod single;
mod tags;
mod tokens;
mod trees;
mod write;
pub(crate) use alpha::ExtraSqueeze;
pub(crate) use calibrate::{calibrated_distance, plain_distance};
pub(crate) use pyramid::PlainInput;
use crate::bit_writer::BitWriter;
use crate::coder_scratch::CoderScratch;
use crate::entropy::f_log2;
use crate::image::Image3F;
use crate::thread_pool::ThreadPool;
use pyramid::Pyramid;
pub(crate) fn encode_xyb_frame(
xyb: &Image3F,
distance: f32,
screen: bool,
patches: &[crate::patches::PatchReference],
speed: crate::Speed,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) -> Option<usize> {
let mut pyramid = Pyramid::xyb(xyb, distance, screen, pool)?;
pyramid.patches = patches.to_vec();
pyramid.group_shift = group_shift(speed);
#[cfg(feature = "extraslow")]
if speed.effort().lm_residual_polish() {
polish::polish_frame(&mut pyramid, xyb, distance, screen, pool, scratch);
}
race::encode(pyramid, speed, pool, scratch, writer)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn encode_plain_frame(
input: &PlainInput,
xsize: usize,
ysize: usize,
distance: f32,
speed: crate::Speed,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) -> Option<usize> {
let unsqueeze = input.extra.last().is_some_and(|&(_, d)| d == 0.0)
&& (speed < crate::Speed::Slow || {
let probe = PlainInput {
color: vec![vec![0; xsize * ysize]],
extra: input.extra.clone(),
max: input.max,
coding: input.coding,
};
let bits = |unsqueeze: bool, scratch: &mut CoderScratch| {
let pyramid = Pyramid::plain(&probe, xsize, ysize, distance, unsqueeze, pool)?;
let mut w = BitWriter::new();
code::write_frame(&pyramid, crate::Speed::Fastest, pool, scratch, &mut w, None);
Some(w.bits_written())
};
match (bits(false, scratch), bits(true, scratch)) {
(Some(squeezed), Some(plain)) => plain < squeezed,
_ => false,
}
});
let mut pyramid = Pyramid::plain(input, xsize, ysize, distance, unsqueeze, pool)?;
pyramid.group_shift = group_shift(speed);
let Some(levels) = (speed >= crate::Speed::Slow)
.then(|| lossy_palette_levels(input, &pyramid, xsize, ysize))
.flatten()
else {
return race::encode(pyramid, speed, pool, scratch, writer);
};
let palette_bits = palette_index_bits(&levels, xsize, ysize);
if palette_bits >= PALETTE_RATE_MARGIN * squeezed_extra_bits(&pyramid, input.color.len()) {
return race::encode(pyramid, speed, pool, scratch, writer);
}
let levels = PlainInput {
color: input.color.clone(),
extra: vec![(levels, 0.0)],
max: input.max,
coding: input.coding,
};
let Some(mut palette) = Pyramid::plain_palette(&levels, xsize, ysize, distance, pool) else {
return race::encode(pyramid, speed, pool, scratch, writer);
};
palette.group_shift = pyramid.group_shift;
race::encode(palette, speed, pool, scratch, writer)
}
const PALETTE_RATE_MARGIN: f64 = 1.45;
fn residual_token(e: u32) -> (u32, u32) {
if e < 16 {
(e, 0)
} else {
let n = 31 - e.leading_zeros();
(16 + (n - 4) * 2 + ((e >> (n - 1)) & 1), n - 1)
}
}
fn context_entropy_bits(samples: impl Iterator<Item = (usize, i32)>, contexts: usize) -> f64 {
let mut hist = vec![std::collections::HashMap::<u32, u32>::new(); contexts];
let mut bits = 0f64;
for (c, v) in samples {
let (token, raw) = residual_token(crate::entropy::pack_signed(v));
*hist[c].entry(token).or_default() += 1;
bits += f64::from(raw);
}
for h in &hist {
let n: u32 = h.values().sum();
if n == 0 {
continue;
}
bits += 12.0 + 6.0 * h.len() as f64;
for &k in h.values() {
bits -= f64::from(k) * f_log2(f64::from(k) / f64::from(n));
}
}
bits
}
fn neighbours(data: &[i32], w: usize, x: usize, y: usize) -> (i32, i32, i32) {
let left = if x > 0 {
data[y * w + x - 1]
} else if y > 0 {
data[(y - 1) * w + x]
} else {
0
};
let top = if y > 0 { data[(y - 1) * w + x] } else { left };
let top_left = if x > 0 && y > 0 {
data[(y - 1) * w + x - 1]
} else {
left
};
(left, top, top_left)
}
fn squeezed_extra_bits(p: &Pyramid, num_color: usize) -> f64 {
let planes = num_color + 1;
let n_pre: usize = p
.steps
.iter()
.filter(|s| !s.in_place)
.map(|s| s.num_c)
.sum();
let channels = &p.channels[..p.channels.len() - n_pre];
let samples = channels
.iter()
.enumerate()
.filter(|&(i, _)| i % planes == num_color)
.flat_map(|(i, ch)| {
(0..ch.w * ch.h).map(move |k| {
let (x, y) = (k % ch.w, k / ch.w);
let (left, top, top_left) = neighbours(&ch.data, ch.w, x, y);
let v = ch.data[k];
if i < planes {
let pred = (left + top - top_left).clamp(left.min(top), left.max(top));
(4, v - pred)
} else {
(usize::from(left != 0) * 2 + usize::from(top != 0), v)
}
})
});
context_entropy_bits(samples, 5)
}
fn palette_index_bits(levels: &[i32], xsize: usize, ysize: usize) -> f64 {
let mut entries = levels.to_vec();
entries.sort_unstable();
entries.dedup();
let indices: Vec<i32> = levels
.iter()
.map(|v| entries.binary_search(v).unwrap_or(0) as i32)
.collect();
let samples = (0..xsize * ysize).map(|k| {
let (left, top, top_left) = neighbours(&indices, xsize, k % xsize, k / xsize);
(
usize::from(left == top) * 2 + usize::from(top == top_left),
indices[k] - left,
)
});
context_entropy_bits(samples, 4)
}
fn lossy_palette_levels(
input: &PlainInput,
squeezed: &Pyramid,
xsize: usize,
ysize: usize,
) -> Option<Vec<i32>> {
use crate::encode_image::AlphaPlane;
use crate::frame::extra_levels::{LOSSY_PALETTE_ERROR, error_weights, fewest_levels};
let [(plane, d)] = input.extra.as_slice() else {
return None;
};
if *d <= 0.0 || plane.iter().any(|&v| !(0..=65535).contains(&v)) {
return None;
}
let source = AlphaPlane::U16 {
data: plane.iter().map(|&v| v as u16).collect(),
bits: 16,
};
let weights = error_weights(&source, xsize, ysize);
let error: f64 = squeezed
.decoded_extra(0)
.iter()
.zip(plane)
.zip(&weights)
.map(|((&v, &s), &w)| {
let e = f64::from(v.clamp(0, 65535) - s);
f64::from(w) * e * e
})
.sum();
let AlphaPlane::U16 { data, .. } =
fewest_levels(&source, &weights, LOSSY_PALETTE_ERROR * error)?
else {
unreachable!("levels keep the plane's type")
};
Some(data.into_iter().map(i32::from).collect())
}
fn group_shift(speed: crate::Speed) -> u32 {
if speed >= crate::Speed::Slow {
crate::lossless::kit::GroupLayout::LARGE.shift
} else {
crate::lossless::kit::GroupLayout::DEFAULT.shift
}
}
pub(crate) fn encode_dc_frame(
dc: &Image3F,
vardct_steps: [f32; 3],
levels: Option<u32>,
speed: crate::Speed,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) -> bool {
match Pyramid::dc_frame(dc, vardct_steps, levels, pool) {
Some(pyramid) => race::encode(pyramid, speed, pool, scratch, writer).is_some(),
None => false,
}
}
pub(crate) fn dc_frame_supported(xsize: usize, ysize: usize) -> bool {
!crate::squeeze::default_squeeze_steps(xsize, ysize, 3).is_empty()
}