use super::modular::{LM_GATE_MARGIN, lm_plain_input, lm_texture_factor};
use super::quantization::compute_distance_params;
use super::vardct::encode_frame_vardct;
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;
#[allow(clippy::too_many_arguments)]
pub(crate) fn encode_frame(
ctx: &EncodingContext,
scratch: &mut CoderScratch,
distance: f32,
linear: Image3F,
coded: Option<Image3F>,
is_achromatic: bool,
alpha: Option<&AlphaPlane>,
fill_invisible: bool,
coeff_shifts: &[u32],
patches: bool,
integer_samples: bool,
writer: &mut BitWriter,
) -> Result<bool, EncodeError> {
let distp = compute_distance_params(distance);
if fill_invisible
&& let Some(alpha) =
alpha.filter(|a| !a.is_constant() && a.len() == linear.xsize() * linear.ysize())
{
let _ = ctx.alpha_aq.set(crate::adaptive_quant::alpha_block_factors(
alpha,
linear.xsize(),
linear.ysize(),
));
}
if !ctx.coding.is_xyb() {
let mut coded = coded.expect("non-XYB frames carry their coded planes");
if fill_invisible && let Some(alpha) = alpha {
crate::invisible::fill_invisible(&mut coded, alpha);
}
let modular = |scratch: &mut CoderScratch| -> Option<(BitWriter, usize)> {
if !integer_samples {
return None;
}
let mut w = BitWriter::new();
let original_bits = crate::lossy_modular::encode_plain_frame(
&lm_plain_input(ctx, &coded, is_achromatic, alpha)?,
coded.xsize(),
coded.ysize(),
crate::lossy_modular::plain_distance(ctx.coding, distance)
* lm_texture_factor(&linear),
ctx.speed,
&ctx.thread_pool,
scratch,
&mut w,
)?;
Some((w, original_bits))
};
let auto =
ctx.lossy_modular == crate::LossyModular::Auto && ctx.speed.effort().lossy_modular_auto;
let modular_writer = match ctx.lossy_modular {
crate::LossyModular::Force => match modular(scratch) {
Some((w, _)) => {
writer.append(&w);
return Ok(true);
}
None => None,
},
crate::LossyModular::Auto if auto => modular(scratch),
_ => None,
};
let mut aq_source = to_xyb_image(ctx, scratch, linear);
if fill_invisible && let Some(alpha) = alpha {
crate::invisible::fill_invisible(&mut aq_source, alpha);
}
let _ = ctx.aq_source.set(aq_source);
ctx.set_plain_matrices(&coded);
ctx.set_cfl_frame(crate::coding::fit_cfl_frame(ctx.coding, &coded));
let mut vardct_writer = BitWriter::new();
encode_frame_vardct(
ctx,
scratch,
distance,
&distp,
coded,
true,
alpha,
coeff_shifts,
false,
&mut vardct_writer,
)?;
return Ok(match modular_writer {
Some((m, original_bits))
if (original_bits as f64) * LM_GATE_MARGIN
< vardct_writer.bits_written() as f64 =>
{
writer.append(&m);
true
}
_ => {
writer.append(&vardct_writer);
false
}
});
}
let lossy_modular = alpha.is_none()
&& (ctx.lossy_modular == crate::LossyModular::Force
|| (ctx.lossy_modular == crate::LossyModular::Auto
&& ctx.speed.effort().lossy_modular_auto));
let texture = lossy_modular.then(|| lm_texture_factor(&linear));
let mut xyb = to_xyb_image(ctx, scratch, linear);
if fill_invisible && let Some(alpha) = alpha {
crate::invisible::fill_invisible(&mut xyb, alpha);
}
if is_achromatic {
snap_achromatic_xyb(&mut xyb);
}
let screen = lossy_modular && crate::frame::is_screen_content(&xyb);
let modular_distance = texture.map_or(0.0, |texture| {
crate::lossy_modular::calibrated_distance(distance, screen) * texture
});
if alpha.is_none()
&& ctx.lossy_modular == crate::LossyModular::Force
&& let Some((modular_writer, _)) = encode_modular_xyb(
ctx,
scratch,
distance,
modular_distance,
screen,
&xyb,
patches,
)
{
writer.append(&modular_writer);
return Ok(false);
}
if screen && ctx.lossy_modular == crate::LossyModular::Auto {
let modular = encode_modular_xyb(
ctx,
scratch,
distance,
modular_distance,
screen,
&xyb,
patches,
);
let original_modular_bits = modular.as_ref().map(|(_, bits)| *bits);
let modular_writer = modular.map(|(w, _)| w).unwrap_or_default();
let mut vardct_writer = BitWriter::new();
encode_frame_vardct(
ctx,
scratch,
distance,
&distp,
xyb,
is_achromatic,
alpha,
coeff_shifts,
patches,
&mut vardct_writer,
)?;
if original_modular_bits.is_some_and(|bits| {
(bits as f64) * LM_GATE_MARGIN < vardct_writer.bits_written() as f64
}) {
writer.append(&modular_writer);
} else {
writer.append(&vardct_writer);
}
return Ok(false);
}
encode_frame_vardct(
ctx,
scratch,
distance,
&distp,
xyb,
is_achromatic,
alpha,
coeff_shifts,
patches,
writer,
)?;
Ok(false)
}
fn encode_modular_xyb(
ctx: &EncodingContext,
scratch: &mut CoderScratch,
distance: f32,
modular_distance: f32,
screen: bool,
xyb: &Image3F,
patches: bool,
) -> Option<(BitWriter, usize)> {
use super::variants::{
GLYPH_SINGLETON_FREE_MAX_DISTANCE, GLYPH_SINGLETON_RACE_MAX_DISTANCE, GlyphStage,
};
let encode = |glyphs: Option<GlyphStage>, scratch: &mut CoderScratch| {
let (mut writer, image, references) = match glyphs {
Some(glyphs) => {
let (atlas, base, references) = glyphs.into_parts();
(atlas, std::borrow::Cow::Owned(base), references)
}
None => (
BitWriter::new(),
std::borrow::Cow::Borrowed(xyb),
Vec::new(),
),
};
let atlas_bits = writer.bits_written();
let bits = crate::lossy_modular::encode_xyb_frame(
&image,
modular_distance,
screen,
&references,
ctx.speed,
&ctx.thread_pool,
scratch,
&mut writer,
)?;
Some((writer, atlas_bits + bits))
};
let free_singles = distance <= GLYPH_SINGLETON_FREE_MAX_DISTANCE;
let glyphs = patches
.then(|| GlyphStage::find(ctx, scratch, distance, xyb, None, free_singles))
.flatten();
let best = encode(glyphs, scratch)?;
if !patches
|| free_singles
|| distance > GLYPH_SINGLETON_RACE_MAX_DISTANCE
|| ctx.speed < crate::Speed::Slow
{
return Some(best);
}
let best_bits = best.0.bits_written();
match GlyphStage::find(ctx, scratch, distance, xyb, None, true) {
Some(singles)
if singles.atlas_bits() < best_bits && singles.atlas_bits() * 4 >= best_bits =>
{
match encode(Some(singles), scratch) {
Some(arm) if arm.0.bits_written() < best_bits => Some(arm),
_ => Some(best),
}
}
_ => Some(best),
}
}
fn snap_achromatic_xyb(xyb: &mut Image3F) {
for y in 0..xyb.ysize() {
let [x_row, y_row, b_row] = xyb.all_plane_rows_mut(y);
x_row.fill(0.0);
b_row.copy_from_slice(y_row);
}
}
fn to_xyb_image(ctx: &EncodingContext, scratch: &mut CoderScratch, mut linear: Image3F) -> Image3F {
crate::xyb::to_xyb_in_place_with_fn(
ctx.to_xyb_band,
&ctx.xyb,
&mut linear,
&ctx.thread_pool,
scratch,
);
linear
}