mod flat;
mod trees;
use super::context::{try_encode_context_tree_multi_group, try_encode_context_tree_single_group};
use super::frame::keep_smaller_writer;
use super::palette::{try_encode_local_palette_multi_group, try_encode_palette_single_group};
use super::predictor::{
GradPackInteriorFn, choose_predictors_with_wp, choose_wp_params, fixed_predictor,
selected_grad_pack_interior_fn,
};
use super::rct::{rank_rcts, rct_candidates, rct_planes};
use super::squeeze::{encode_squeeze_multigroup, encode_squeeze_single_group};
use super::{GroupGrid, GroupLayout, LosslessSettings, constant_alpha_value, lossless_min_symbol};
use crate::bit_writer::BitWriter;
use crate::coder_scratch::CoderScratch;
use crate::effort::Effort;
use crate::encode_image::AlphaPlane;
use crate::image::Image3Si;
use crate::patches::ModularFrameKind;
use crate::thread_pool::ThreadPool;
use crate::weighted_predictor::WpParams;
use flat::FlatCoder;
pub(super) const MA_DECISIVE_MIN_SAVINGS: f64 = 0.18;
const RCT_DENSE_ROW_STEP: usize = 4;
const RCT_SPARSE_ROW_STEP: usize = 16;
#[inline]
pub(super) fn learned_tree_is_decisive(estimated_savings: f64) -> bool {
estimated_savings >= MA_DECISIVE_MIN_SAVINGS
}
#[derive(Clone, Copy)]
pub(super) enum TreeSearch {
Full,
Global,
Vector,
}
pub(crate) fn encode_frame_lossless_core(
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
settings: LosslessSettings,
frame_kind: ModularFrameKind<'_>,
local_trees: bool,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) -> bool {
encode_frame_lossless_core_impl(
linear,
alpha,
settings,
frame_kind,
true,
if local_trees {
TreeSearch::Full
} else {
TreeSearch::Global
},
pool,
scratch,
writer,
)
}
#[allow(clippy::too_many_arguments)]
pub(super) fn encode_frame_lossless_core_impl(
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
settings: LosslessSettings,
frame_kind: ModularFrameKind<'_>,
allow_palette_candidates: bool,
tree_search: TreeSearch,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) -> bool {
let frame = CoreFrame::new(linear, alpha, settings, frame_kind, tree_search);
if allow_palette_candidates
&& let Some(decisive) = frame.encode_palette_transform(pool, scratch, writer)
{
return decisive;
}
if frame.encode_squeeze(pool, scratch, writer) {
return false;
}
let mut color = ColorTransform::rank(&frame, pool, scratch);
let wp_params = frame.choose_wp_params(color.rct_type, pool, scratch);
let mut best = SmallestFrame::default();
let trees =
trees::learn_tree_candidates(&frame, &mut color, wp_params, &mut best, pool, scratch);
if trees.decisive || trees.skip_alternatives {
writer.append(best.get().expect("decisive learned-tree candidate"));
return trees.decisive;
}
let layout = trees.layout;
let grid = GroupGrid::new(frame.xsize, frame.ysize, layout);
let rct_type = color.rct_type;
let planes = color.planes(pool, scratch);
let predictors = if frame.effort.predictor_search {
choose_predictors_with_wp(
planes,
frame.alpha.filter(|_| frame.alpha_constant.is_none()),
frame.xsize,
frame.ysize,
frame.num_color,
pool,
scratch,
trees.wp_params,
frame.use_wp,
)
} else {
[fixed_predictor(frame.use_wp); 4]
};
let flat = FlatCoder::new(
&frame,
planes,
rct_type,
layout,
&predictors,
trees.wp_params,
);
if frame.compare_tree_candidates && frame.effort.tree_ctx_v1 && frame.use_wp {
let mut candidate = BitWriter::new();
let written = if grid.single_group() {
try_encode_context_tree_single_group(
frame.settings.speed,
frame.num_color,
planes,
frame.alpha,
frame.alpha_constant,
frame.xsize,
frame.ysize,
layout,
frame.kind,
&predictors,
frame.min_symbol,
rct_type,
pool,
scratch,
trees.wp_params,
&mut candidate,
)
} else {
try_encode_context_tree_multi_group(
frame.settings.speed,
frame.num_color,
planes,
frame.alpha,
frame.alpha_constant,
frame.xsize,
frame.ysize,
layout,
frame.kind,
&predictors,
grid.x_groups,
grid.y_groups,
grid.num_dc_groups(),
frame.min_symbol,
rct_type,
pool,
scratch,
trees.wp_params,
&mut candidate,
)
};
if written {
best.offer(candidate);
}
}
if frame.compare_tree_candidates {
let mut candidate = BitWriter::new();
flat.write_frame(pool, scratch, &mut candidate);
best.offer(candidate);
writer.append(best.get().expect("flat lossless candidate"));
} else {
flat.write_frame(pool, scratch, writer);
}
false
}
struct CoreFrame<'a> {
ycocg: &'a Image3Si,
alpha: Option<&'a AlphaPlane>,
settings: LosslessSettings,
effort: Effort,
kind: ModularFrameKind<'a>,
tree_search: TreeSearch,
xsize: usize,
ysize: usize,
num_color: usize,
nb_chans: usize,
alpha_constant: Option<i32>,
coded_chans: usize,
use_wp: bool,
min_symbol: u32,
grid: GroupGrid,
grad_pack_fn: GradPackInteriorFn,
compare_tree_candidates: bool,
}
impl<'a> CoreFrame<'a> {
fn new(
ycocg: &'a Image3Si,
alpha: Option<&'a AlphaPlane>,
settings: LosslessSettings,
kind: ModularFrameKind<'a>,
tree_search: TreeSearch,
) -> Self {
let effort = *settings.speed.effort();
let (xsize, ysize) = (ycocg.xsize(), ycocg.ysize());
let num_color = settings.num_color;
let alpha_constant = alpha.and_then(constant_alpha_value);
Self {
ycocg,
alpha,
settings,
effort,
kind,
tree_search,
xsize,
ysize,
num_color,
nb_chans: num_color + usize::from(alpha.is_some()),
alpha_constant,
coded_chans: num_color + usize::from(alpha.is_some() && alpha_constant.is_none()),
use_wp: settings.decoding_speed.use_weighted_predictor()
&& (effort.learned_tree || !settings.near_lossless),
min_symbol: lossless_min_symbol(settings.max_bits),
grid: GroupGrid::new(xsize, ysize, GroupLayout::DEFAULT),
grad_pack_fn: selected_grad_pack_interior_fn(),
compare_tree_candidates: kind.allows_learned_tree()
&& effort.learned_tree
&& (num_color == 3 || num_color == 1)
&& settings.decoding_speed.use_ma_trees(),
}
}
fn default_layout(&self) -> GroupLayout {
GroupLayout::DEFAULT.with_upsampling(self.settings.upsampling)
}
fn wp_header_count(&self) -> usize {
if self.grid.single_group() {
1
} else {
2 + self.grid.num_dc_groups() + self.grid.num_groups()
}
}
fn wp_header_bits(&self, params: WpParams) -> f64 {
if params == WpParams::DEFAULT {
0.0
} else {
(51 * self.wp_header_count()) as f64
}
}
fn encode_palette_transform(
&self,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) -> Option<bool> {
if !self.kind.is_regular() || self.num_color != 3 {
return None;
}
let mut palette_writer = BitWriter::new();
let applies = if self.grid.single_group() {
try_encode_palette_single_group(
self.ycocg,
self.alpha,
self.xsize,
self.ysize,
self.min_symbol,
self.grad_pack_fn,
self.settings.speed,
self.use_wp,
self.kind,
self.default_layout(),
scratch,
&mut palette_writer,
)
} else {
try_encode_local_palette_multi_group(
self.ycocg,
self.alpha,
self.xsize,
self.ysize,
self.grid.x_groups,
self.grid.y_groups,
self.grid.num_dc_groups(),
self.min_symbol,
self.grad_pack_fn,
self.settings.speed,
self.use_wp,
self.kind,
self.default_layout(),
pool,
scratch,
&mut palette_writer,
)
};
if !applies {
return None;
}
if self.effort.palette_dual {
let mut normal_writer = BitWriter::new();
let normal_decisive = encode_frame_lossless_core_impl(
self.ycocg,
self.alpha,
self.settings,
self.kind,
false,
self.tree_search,
pool,
scratch,
&mut normal_writer,
);
if normal_writer.bits_written() < palette_writer.bits_written() {
writer.append(&normal_writer);
return Some(normal_decisive);
}
}
writer.append(&palette_writer);
Some(false)
}
fn encode_squeeze(
&self,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) -> bool {
if !self.settings.progressive || !self.kind.is_regular() || self.num_color != 3 {
return false;
}
if self.grid.single_group() {
encode_squeeze_single_group(
self.ycocg,
self.alpha,
self.xsize,
self.ysize,
self.min_symbol,
self.grad_pack_fn,
self.settings.speed,
self.use_wp,
self.kind,
self.default_layout(),
pool,
scratch,
writer,
);
true
} else {
encode_squeeze_multigroup(
self.ycocg,
self.alpha,
self.xsize,
self.ysize,
self.min_symbol,
self.grid.x_groups,
self.grid.y_groups,
self.grid.x_dc_groups,
self.grid.y_dc_groups,
self.grid.num_dc_groups(),
self.grid.num_groups(),
self.grad_pack_fn,
self.settings.speed,
self.use_wp,
self.kind,
self.default_layout(),
pool,
scratch,
writer,
)
}
}
fn choose_wp_params(
&self,
rct_type: u32,
pool: &ThreadPool,
scratch: &mut CoderScratch,
) -> WpParams {
if self.effort.wp_search && self.use_wp {
choose_wp_params(
self.ycocg,
rct_type,
self.alpha,
self.alpha_constant,
self.num_color,
self.wp_header_count(),
pool,
scratch,
)
} else {
WpParams::DEFAULT
}
}
}
struct ColorTransform<'a> {
ycocg: &'a Image3Si,
num_color: usize,
rct_type: u32,
planes: Option<Image3Si>,
ranked: Vec<(u32, f32)>,
}
impl<'a> ColorTransform<'a> {
fn rank(frame: &CoreFrame<'a>, pool: &ThreadPool, scratch: &mut CoderScratch) -> Self {
let effort = frame.effort;
let ranked = if frame.kind.allows_learned_tree()
&& (effort.rct_search || frame.settings.near_lossless)
&& frame.num_color == 3
{
let row_step = if effort.rct_every_row {
1
} else if effort.rct_dense_rows {
RCT_DENSE_ROW_STEP
} else {
RCT_SPARSE_ROW_STEP
};
rank_rcts(
frame.ycocg,
frame.xsize,
frame.ysize,
row_step,
rct_candidates(effort.rct_all_types),
pool,
scratch,
)
} else {
Vec::new()
};
let default_rct = if frame.num_color == 3 { 6 } else { 0 };
Self {
ycocg: frame.ycocg,
num_color: frame.num_color,
rct_type: ranked.first().map_or(default_rct, |&(t, _)| t),
planes: None,
ranked,
}
}
pub(super) fn runner_up(&self) -> Option<(u32, f32)> {
const TWIN_TOLERANCE: f32 = 1e-4;
let (_, best) = *self.ranked.first()?;
self.ranked
.iter()
.skip(1)
.copied()
.find(|&(_, cost)| cost > best * (1.0 + TWIN_TOLERANCE))
}
fn planes(&mut self, pool: &ThreadPool, scratch: &mut CoderScratch) -> &Image3Si {
if self.num_color != 3 || self.rct_type == 6 {
return self.ycocg;
}
let ycocg = self.ycocg;
let rct_type = self.rct_type;
self.planes.get_or_insert_with(|| {
rct_planes(ycocg, ycocg.xsize(), ycocg.ysize(), rct_type, pool, scratch)
})
}
fn release_planes(&mut self) {
self.planes = None;
}
fn adopt(&mut self, rct_type: u32, planes: Option<Image3Si>) {
self.rct_type = rct_type;
self.planes = planes;
}
}
#[derive(Default)]
struct SmallestFrame {
writer: Option<BitWriter>,
}
impl SmallestFrame {
fn offer(&mut self, candidate: BitWriter) {
keep_smaller_writer(&mut self.writer, candidate);
}
fn bits(&self) -> Option<usize> {
self.writer.as_ref().map(BitWriter::bits_written)
}
fn get(&self) -> Option<&BitWriter> {
self.writer.as_ref()
}
}