use super::encoder::encode_frame_lossless_core;
use super::header::write_patch_dictionary;
use super::ma_learning::rank_coarse;
use super::ma_source::{MA_FULL_SAMPLING, PATCH_MIN_COVERAGE, rgb_ma_source};
use super::{GroupLayout, LosslessSettings, constant_alpha_value, lossless_min_symbol};
use crate::bit_writer::BitWriter;
use crate::coder_scratch::CoderScratch;
use crate::encode_image::AlphaPlane;
use crate::image::Image3Si;
use crate::patches::{
LosslessPatches, ModularFrameKind, find_lossless_glyph_patches, find_lossless_patches,
};
use crate::region_frames::Region;
use crate::thread_pool::ThreadPool;
use crate::weighted_predictor::WpParams;
const REGION_FRAME_OVERHEAD_BITS: f64 = 1600.0;
const REGION_GLYPH_SAVING: f64 = 0.1;
const REGION_SPLIT_MARGIN: f64 = 0.99;
const GLYPH_REGULAR_COARSE_MARGIN: f64 = 1.10;
const GLYPH_UNSURE_CODED_SHARE: f64 = 0.55;
const GLYPH_REGULAR_UNSURE_MARGIN: f64 = 1.25;
pub(super) fn keep_smaller_writer(best: &mut Option<BitWriter>, candidate: BitWriter) {
if best
.as_ref()
.is_none_or(|current| candidate.bits_written() < current.bits_written())
{
*best = Some(candidate);
}
}
fn append_smaller(first: &BitWriter, second: &BitWriter, writer: &mut BitWriter) {
if second.bits_written() < first.bits_written() {
writer.append(second);
} else {
writer.append(first);
}
}
pub(crate) fn encode_frame_lossless(
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
settings: LosslessSettings,
patches: bool,
num_threads: usize,
writer: &mut BitWriter,
) {
let pool = ThreadPool::new_lossless(num_threads);
let mut scratch = Box::new(CoderScratch::lossless());
FrameCoder {
settings,
patches,
pool: &pool,
scratch: &mut scratch,
}
.encode_image(linear, alpha, writer);
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn encode_frame_lossless_base(
linear: &Image3Si,
alpha: &AlphaPlane,
patches: bool,
speed: crate::Speed,
decoding_speed: crate::DecodingSpeed,
near_lossless: bool,
pool: &ThreadPool,
scratch: &mut CoderScratch,
writer: &mut BitWriter,
) {
FrameCoder {
settings: LosslessSettings {
near_lossless,
..LosslessSettings::rgb8(speed, decoding_speed)
},
patches,
pool,
scratch,
}
.encode_displayed(linear, Some(alpha), true, None, writer);
}
struct FrameCoder<'p, 's> {
settings: LosslessSettings,
patches: bool,
pool: &'p ThreadPool,
scratch: &'s mut CoderScratch,
}
struct RegionSplit {
regions: Vec<Region>,
crops: Vec<(Image3Si, Option<AlphaPlane>)>,
base: Image3Si,
base_alpha: Option<AlphaPlane>,
}
impl FrameCoder<'_, '_> {
fn core(
&mut self,
image: &Image3Si,
alpha: Option<&AlphaPlane>,
settings: LosslessSettings,
kind: ModularFrameKind<'_>,
local_trees: bool,
writer: &mut BitWriter,
) -> bool {
encode_frame_lossless_core(
image,
alpha,
settings,
kind,
local_trees,
self.pool,
self.scratch,
writer,
)
}
fn coarse_bits(&mut self, image: &Image3Si, alpha: Option<&AlphaPlane>) -> Option<f64> {
coarse_frame_bits(
image,
alpha,
lossless_min_symbol(self.settings.max_bits),
self.settings.decoding_speed.use_weighted_predictor(),
self.pool,
self.scratch,
)
}
fn encode_image(
&mut self,
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
writer: &mut BitWriter,
) {
let mut whole_glyphs: Option<Option<LosslessPatches>> = None;
if let Some(split) = self.plan_region_split(linear, alpha, &mut whole_glyphs) {
let mut split_writer = BitWriter::new();
self.encode_region_split(&split, &mut split_writer);
drop(split);
let mut whole_writer = BitWriter::new();
self.encode_displayed(linear, alpha, false, whole_glyphs.take(), &mut whole_writer);
append_smaller(&split_writer, &whole_writer, writer);
return;
}
self.encode_displayed(linear, alpha, false, whole_glyphs, writer);
}
fn plan_region_split(
&mut self,
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
whole_glyphs: &mut Option<Option<LosslessPatches>>,
) -> Option<RegionSplit> {
let s = self.settings;
if !s.speed.effort().region_frames
|| s.upsampling != 1
|| s.progressive
|| s.num_color != 3
|| s.max_bits != 8
{
return None;
}
let mut regions = crate::region_frames::plan(linear, alpha)?;
let mut crops: Vec<_> = regions
.iter()
.map(|r| crate::region_frames::crop(linear, alpha, r))
.collect();
let mut own: Vec<Option<f64>> = crops
.iter()
.map(|(c, a)| self.coarse_bits(c, a.as_ref()))
.collect();
if self.patches
&& let Some(glyphs) = whole_glyphs.insert(find_lossless_glyph_patches(linear))
{
let keep: Vec<bool> = regions
.iter()
.zip(&own)
.map(|(r, &own)| {
let (patched, patched_alpha) =
crate::region_frames::crop(&glyphs.base, alpha, r);
let text_like = match (own, self.coarse_bits(&patched, patched_alpha.as_ref()))
{
(Some(own), Some(patched)) => patched < own * (1.0 - REGION_GLYPH_SAVING),
_ => false,
};
!text_like
})
.collect();
retain_kept(&mut regions, &keep);
retain_kept(&mut crops, &keep);
retain_kept(&mut own, &keep);
}
let (base, base_alpha) = crate::region_frames::cut(linear, alpha, ®ions);
let whole = self.coarse_bits(linear, alpha);
let base_bits = self.coarse_bits(&base, base_alpha.as_ref());
let split = own
.iter()
.copied()
.chain([base_bits])
.sum::<Option<f64>>()
.map(|bits| bits + REGION_FRAME_OVERHEAD_BITS * regions.len() as f64);
let favoured = matches!(
(whole, split),
(Some(whole), Some(split)) if split < whole * REGION_SPLIT_MARGIN
);
(!regions.is_empty() && favoured).then_some(RegionSplit {
regions,
crops,
base,
base_alpha,
})
}
fn encode_region_split(&mut self, split: &RegionSplit, writer: &mut BitWriter) {
self.encode_displayed(&split.base, split.base_alpha.as_ref(), true, None, writer);
for (i, ((crop, crop_alpha), r)) in split.crops.iter().zip(&split.regions).enumerate() {
self.core(
crop,
crop_alpha.as_ref(),
self.settings.single_pass(),
ModularFrameKind::RgbCrop {
x0: r.x0,
y0: r.y0,
width: r.width,
height: r.height,
full: r.width == split.base.xsize() && r.height == split.base.ysize(),
last: i + 1 == split.regions.len(),
},
true,
writer,
);
}
}
fn encode_displayed(
&mut self,
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
saved_first: bool,
glyph_plan: Option<Option<LosslessPatches>>,
writer: &mut BitWriter,
) {
let regular = if saved_first {
ModularFrameKind::RgbSavedFirst
} else {
ModularFrameKind::Regular
};
let with_patches = self.patches && self.settings.num_color == 3;
let glyph_plan = match glyph_plan {
Some(plan) => plan,
None if with_patches => find_lossless_glyph_patches(linear),
None => None,
};
let is_glyph_plan = glyph_plan.is_some();
let plan = if with_patches {
glyph_plan.or_else(|| find_lossless_patches(linear, self.pool, self.scratch))
} else {
None
};
let Some(plan) = plan else {
self.core(linear, alpha, self.settings, regular, true, writer);
return;
};
let mut regular_writer = BitWriter::new();
if !is_glyph_plan {
let decisive_tree = self.core(
linear,
alpha,
self.settings,
regular,
true,
&mut regular_writer,
);
let coverage = patch_coverage(&plan, linear.xsize() * linear.ysize());
if decisive_tree || coverage < PATCH_MIN_COVERAGE {
writer.append(®ular_writer);
return;
}
}
let mut patched_writer = BitWriter::new();
let atlas_bits = self.encode_patched(&plan, alpha, saved_first, &mut patched_writer);
if is_glyph_plan
&& self.regular_competes(
linear,
alpha,
&plan,
atlas_bits,
patched_writer.bits_written(),
)
{
self.core(
linear,
alpha,
self.settings,
regular,
false,
&mut regular_writer,
);
}
if regular_writer.bits_written() > 0
&& regular_writer.bits_written() < patched_writer.bits_written()
{
writer.append(®ular_writer);
} else {
writer.append(&patched_writer);
}
}
fn encode_patched(
&mut self,
plan: &LosslessPatches,
alpha: Option<&AlphaPlane>,
saved_first: bool,
writer: &mut BitWriter,
) -> usize {
let (atlas_w, atlas_h) = (plan.atlas.xsize(), plan.atlas.ysize());
let atlas_alpha = zero_alpha_like(alpha, atlas_w.saturating_mul(atlas_h));
self.core(
&plan.atlas,
atlas_alpha.as_ref(),
self.settings.single_pass(),
ModularFrameKind::ReferenceOnly {
width: atlas_w,
height: atlas_h,
},
true,
writer,
);
let atlas_bits = writer.bits_written();
self.core(
&plan.base,
alpha,
self.settings.single_pass(),
ModularFrameKind::Patched {
references: &plan.references,
saved_first,
},
true,
writer,
);
atlas_bits
}
fn regular_competes(
&mut self,
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
plan: &LosslessPatches,
atlas_bits: usize,
patched_bits: usize,
) -> bool {
let regular_est = self.coarse_bits(linear, alpha);
let base_est = self.coarse_bits(&plan.base, alpha);
let (Some(regular), Some(base)) = (regular_est, base_est) else {
return true;
};
let mut dictionary = BitWriter::new();
write_patch_dictionary(
&plan.references,
alpha.is_some(),
self.scratch,
&mut dictionary,
);
let patched = base + (atlas_bits + dictionary.bits_written()) as f64;
let margin = if (patched_bits as f64) < patched * GLYPH_UNSURE_CODED_SHARE {
GLYPH_REGULAR_UNSURE_MARGIN
} else {
GLYPH_REGULAR_COARSE_MARGIN
};
regular <= patched * margin
}
}
fn retain_kept<T>(items: &mut Vec<T>, keep: &[bool]) {
let mut kept = keep.iter();
items.retain(|_| *kept.next().unwrap_or(&true));
}
fn patch_coverage(plan: &LosslessPatches, pixels: usize) -> f64 {
let covered: usize = plan
.references
.iter()
.map(|r| r.positions.len() * r.width * r.height)
.sum();
covered as f64 / pixels as f64
}
fn zero_alpha_like(alpha: Option<&AlphaPlane>, pixels: usize) -> Option<AlphaPlane> {
match alpha {
Some(AlphaPlane::U8(_)) => Some(AlphaPlane::U8(vec![0; pixels])),
Some(AlphaPlane::U16 { bits, .. }) => Some(AlphaPlane::U16 {
data: vec![0; pixels],
bits: *bits,
}),
Some(AlphaPlane::F32(_)) => Some(AlphaPlane::F32(vec![0; pixels])),
None => None,
}
}
fn coarse_frame_bits(
linear: &Image3Si,
alpha: Option<&AlphaPlane>,
min_symbol: u32,
use_wp: bool,
pool: &ThreadPool,
scratch: &mut CoderScratch,
) -> Option<f64> {
let (xsize, ysize) = (linear.xsize(), linear.ysize());
let source = rgb_ma_source(
linear,
alpha,
xsize,
6,
alpha.and_then(constant_alpha_value),
3,
);
let stage = rank_coarse(
&source,
xsize,
ysize,
min_symbol,
WpParams::DEFAULT,
use_wp,
GroupLayout::LARGE,
MA_FULL_SAMPLING,
pool,
scratch,
)?;
Some(stage.candidate.est_real.min(stage.candidate.flat_real))
}