use super::chroma::configure_chroma;
use super::quantization::DistanceParams;
use super::variants::{
GLYPH_BITS_MARGIN, GLYPH_SINGLETON_FREE_MAX_DISTANCE, GLYPH_SINGLETON_RACE_MAX_DISTANCE,
GlyphStage, LATTICE_BITS_MARGIN, PreparedVarDct, UNPATCHED_BITS_MARGIN, lattice_variants,
prepare_vardct_variant,
};
#[cfg(feature = "splines")]
use super::variants::{SplineStage, spline_quant_field};
use crate::bit_writer::BitWriter;
use crate::coder_scratch::CoderScratch;
use crate::encode_image::AlphaPlane;
use crate::encoding_context::EncodingContext;
use crate::image::Image3F;
use crate::util::EncodeError;
use std::borrow::Cow;
#[allow(clippy::too_many_arguments)]
pub(super) fn encode_frame_vardct(
ctx: &EncodingContext,
scratch: &mut CoderScratch,
distance: f32,
distp: &DistanceParams,
xyb: Image3F,
is_achromatic: bool,
alpha: Option<&AlphaPlane>,
coeff_shifts: &[u32],
patches: bool,
writer: &mut BitWriter,
) -> Result<(), EncodeError> {
configure_chroma(ctx, distance, distp, &xyb, is_achromatic);
#[cfg(feature = "splines")]
let quant_field = if ctx.splines || ctx.dots {
spline_quant_field(ctx, scratch, &xyb, distp)?
} else {
Vec::new()
};
#[cfg(feature = "splines")]
let spline_candidates = if ctx.splines || ctx.dots {
crate::splines::find_candidates(ctx, scratch, distance, &xyb, &quant_field)
} else {
None
};
#[cfg(feature = "splines")]
let stage = spline_candidates.as_ref().map(|candidates| SplineStage {
candidates,
quant_field: &quant_field,
before_tiles: false,
});
if !patches {
let prepared = prepare_vardct_variant(
ctx,
scratch,
distance,
distp,
Cow::Owned(xyb),
alpha,
coeff_shifts,
false,
None,
true,
#[cfg(feature = "splines")]
stage.as_ref(),
)?;
#[cfg(feature = "splines")]
drop(spline_candidates);
return prepared.encode(ctx, scratch, distance, alpha, coeff_shifts, writer);
}
let lattice = if ctx.patch_lite {
None
} else {
crate::lattice_patches::find(&xyb)
};
let retain_epf_luma = ctx.patch_epf
&& super::vardct_encoder::epf_fit_enabled(ctx, distance)
&& !ctx.progressive_dc
&& coeff_shifts == [0]
&& xyb.xsize() >= 16
&& xyb.ysize() >= 16;
let mut glyphs = GlyphStage::find(
ctx,
scratch,
distance,
&xyb,
alpha,
distance <= GLYPH_SINGLETON_FREE_MAX_DISTANCE,
retain_epf_luma,
);
let mut best = prepare_vardct_variant(
ctx,
scratch,
distance,
distp,
Cow::Borrowed(&xyb),
alpha,
coeff_shifts,
true,
glyphs.as_ref().map(Cow::Borrowed),
true,
#[cfg(feature = "splines")]
stage.as_ref(),
)?;
let estimate_trusted =
ctx.frame_role == crate::encoding_context::FrameRole::Last || ctx.crop_base;
if (!ctx.patch_lite || glyphs.is_some())
&& distance > GLYPH_SINGLETON_FREE_MAX_DISTANCE
&& (estimate_trusted || distance <= GLYPH_SINGLETON_RACE_MAX_DISTANCE)
&& let Some(singles) =
GlyphStage::find(ctx, scratch, distance, &xyb, alpha, true, retain_epf_luma)
{
let best_bits = best.estimate(ctx, scratch, distance, alpha, coeff_shifts)?;
if (singles.atlas_bits() as f64) < best_bits {
let mut arm = prepare_vardct_variant(
ctx,
scratch,
distance,
distp,
Cow::Borrowed(&xyb),
alpha,
coeff_shifts,
true,
Some(Cow::Borrowed(&singles)),
true,
#[cfg(feature = "splines")]
None,
)?;
if arm.estimate(ctx, scratch, distance, alpha, coeff_shifts)? < best_bits {
#[cfg(feature = "splines")]
if stage.is_some() {
let full = prepare_vardct_variant(
ctx,
scratch,
distance,
distp,
Cow::Borrowed(&xyb),
alpha,
coeff_shifts,
true,
Some(Cow::Borrowed(&singles)),
true,
stage.as_ref(),
)?;
if full.has_splines() {
arm = full;
} else {
arm.tiles_touched = full.tiles_touched;
}
}
best = arm;
glyphs = Some(singles);
}
}
}
let race_unpatched = (ctx.frame_role == crate::encoding_context::FrameRole::Last
|| ctx.crop_base)
&& (glyphs.is_some() || best.used_tiles || lattice.is_some());
let defer_unpatched = race_unpatched && glyphs.is_some() && !distp.gab_enabled;
#[cfg(feature = "splines")]
let defer_unpatched = defer_unpatched && stage.is_none();
if !best.used_tiles || lattice.is_some() {
drop(glyphs.take());
}
let mut unpatched = if defer_unpatched {
let bits =
PreparedVarDct::estimate_regular(ctx, scratch, distance, &xyb, alpha, coeff_shifts)?;
Some((None, bits))
} else if race_unpatched {
let mut arm = prepare_vardct_variant(
ctx,
scratch,
distance,
distp,
Cow::Borrowed(&xyb),
alpha,
coeff_shifts,
false,
None,
true,
#[cfg(feature = "splines")]
stage.as_ref(),
)?;
let bits = arm.estimate(ctx, scratch, distance, alpha, coeff_shifts)?;
Some((Some(arm), bits))
} else {
None
};
let mut pick = |mut best: PreparedVarDct,
best_bits: Option<f64>,
original: Option<Image3F>,
scratch: &mut CoderScratch|
-> Result<PreparedVarDct, EncodeError> {
let Some((arm, bits)) = unpatched.take() else {
return Ok(best);
};
let best_bits = match best_bits {
Some(bits) => bits,
None => best.estimate(ctx, scratch, distance, alpha, coeff_shifts)?,
};
Ok(if bits * UNPATCHED_BITS_MARGIN < best_bits {
arm.unwrap_or_else(|| PreparedVarDct::regular(original.expect("unpatched source")))
} else {
best
})
};
if !best.used_tiles && lattice.is_none() {
let original = defer_unpatched.then_some(xyb);
#[cfg(feature = "splines")]
drop(spline_candidates);
let best = pick(best, None, original, scratch)?;
return best.encode(ctx, scratch, distance, alpha, coeff_shifts, writer);
}
#[allow(unused_mut)]
let mut best_bits = best.estimate(ctx, scratch, distance, alpha, coeff_shifts)?;
if let Some(plan) = lattice {
let original = defer_unpatched.then_some(xyb);
#[cfg(feature = "splines")]
drop(spline_candidates);
let patched_bits = best_bits;
best_bits *= LATTICE_BITS_MARGIN;
let mut lattice_won = false;
for mut arm in lattice_variants(ctx, scratch, distance, distp, plan, alpha)? {
let bits = arm.estimate(ctx, scratch, distance, alpha, coeff_shifts)?;
if bits < best_bits {
best = arm;
best_bits = bits;
lattice_won = true;
}
}
let best = pick(
best,
Some(if lattice_won { best_bits } else { patched_bits }),
original,
scratch,
)?;
return best.encode(ctx, scratch, distance, alpha, coeff_shifts, writer);
}
#[cfg(feature = "splines")]
if best.tiles_touched {
let stage = SplineStage {
before_tiles: true,
..stage.expect("candidates touched a tile")
};
let mut splines_first = prepare_vardct_variant(
ctx,
scratch,
distance,
distp,
Cow::Borrowed(&xyb),
alpha,
coeff_shifts,
true,
glyphs.as_ref().map(Cow::Borrowed),
true,
Some(&stage),
)?;
let bits = splines_first.estimate(ctx, scratch, distance, alpha, coeff_shifts)?;
if bits < best_bits {
best = splines_first;
best_bits = bits;
}
}
let mut original = Some(xyb);
let input = if defer_unpatched {
Cow::Borrowed(original.as_ref().unwrap())
} else {
Cow::Owned(original.take().unwrap())
};
let mut no_tiles = prepare_vardct_variant(
ctx,
scratch,
distance,
distp,
input,
alpha,
coeff_shifts,
true,
glyphs.map(Cow::Owned),
false,
#[cfg(feature = "splines")]
stage.as_ref(),
)?;
let no_tile_bits = no_tiles.estimate(ctx, scratch, distance, alpha, coeff_shifts)?;
if no_tile_bits * GLYPH_BITS_MARGIN < best_bits {
best = no_tiles;
best_bits = no_tile_bits;
} else {
drop(no_tiles);
}
#[cfg(feature = "splines")]
drop(spline_candidates);
let best = pick(best, Some(best_bits), original, scratch)?;
best.encode(ctx, scratch, distance, alpha, coeff_shifts, writer)
}