use super::frame::{
write_frame_header_modular_plain, write_frame_header_modular_xyb_regular,
write_lossy_modular_dc_quant,
};
use super::{write_modular_transforms_rct_squeeze, write_modular_transforms_squeeze_only};
use crate::bit_writer::BitWriter;
pub(super) static SQUEEZE_XYB_QTABLE: [[f32; 16]; 3] = [
[
163.84, 81.92, 40.96, 20.48, 10.24, 5.12, 2.56, 1.28, 0.64, 0.32, 0.16, 0.08, 0.04, 0.02,
0.01, 0.005,
], [
1024.0, 512.0, 256.0, 128.0, 64.0, 32.0, 16.0, 8.0, 4.0, 2.0, 1.0, 0.5, 0.5, 0.5, 0.5, 0.5,
], [
2048.0, 1024.0, 512.0, 256.0, 128.0, 64.0, 32.0, 16.0, 8.0, 4.0, 2.0, 1.0, 0.5, 0.5, 0.5,
0.5,
], ];
pub(super) static SQUEEZE_QUALITY_FACTOR_XYB: f32 = 4.8;
static LM_ROW_MUL: [f32; 3] = [1.265, 1.704, 0.546];
pub(super) static LOSSY_MODULAR_XYB_SCALE: [f32; 3] = [65536.0, 4096.0, 4096.0];
fn lossy_modular_q(color: usize, hshift: i32, vshift: i32, distance: f32) -> i32 {
let mut shift = (hshift + vshift).min(16);
if shift > 0 {
shift -= 1;
}
let quantizer = 0.25f32 * distance;
let q = quantizer
* SQUEEZE_QUALITY_FACTOR_XYB
* SQUEEZE_XYB_QTABLE[color][shift as usize]
* LM_ROW_MUL[color];
(q as i32).max(1)
}
pub(crate) fn lm_calibrated_distance(d: f32) -> f32 {
static KNOTS: [(f32, f32); 6] = [
(1.0, 1.324),
(1.5, 1.851),
(2.0, 2.259),
(3.0, 2.466),
(4.0, 2.504),
(5.0, 2.350),
];
let knots = KNOTS;
let k = if d <= knots[0].0 {
knots[0].1
} else if d >= knots[knots.len() - 1].0 {
knots[knots.len() - 1].1
} else {
let mut k = knots[0].1;
for w in knots.array_windows::<2>() {
let [(d0, k0), (d1, k1)] = [w[0], w[1]];
if d >= d0 && d <= d1 {
k = k0 + (k1 - k0) * (d - d0) / (d1 - d0);
break;
}
}
k
};
d * k
}
pub(super) fn quantize_channel_divide(ch: &mut crate::squeeze::Channel, q: i32) {
if q <= 1 {
return;
}
for v in ch.data.iter_mut() {
let a = *v;
*v = if a < 0 {
-((-a + q / 2) / q)
} else {
(a + q / 2) / q
};
}
}
fn lm_epf_schedule(layout: LmLayout, effective_distance: f32) -> (u32, f32) {
let eff = effective_distance;
match layout {
LmLayout::Xyb => (if eff < 5.0 { 1 } else { 2 }, 0.69 + 0.25 * eff),
LmLayout::Plain { rct: true, .. } => (2, 1.5 + 0.29 * eff),
LmLayout::Plain { .. } => (if eff < 10.0 { 1 } else { 2 }, 1.6 + 0.055 * eff),
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum LmLayout {
Xyb,
Plain {
ycbcr: bool,
rct: bool,
extra: usize,
},
}
impl LmLayout {
pub(super) fn write_frame_header(self, epf: (u32, f32), w: &mut BitWriter) {
match self {
Self::Xyb => write_frame_header_modular_xyb_regular(epf, w),
Self::Plain { ycbcr, extra, .. } => {
write_frame_header_modular_plain(ycbcr, extra, epf, w);
}
}
}
pub(super) fn write_dc_quant(self, w: &mut BitWriter) {
match self {
Self::Xyb => write_lossy_modular_dc_quant(w),
Self::Plain { .. } => w.write(1, 1),
}
}
pub(super) fn write_transforms(self, steps: &[crate::squeeze::SqueezeStep], w: &mut BitWriter) {
match self {
Self::Plain { rct: true, .. } => write_modular_transforms_rct_squeeze(steps, w),
_ => write_modular_transforms_squeeze_only(steps, w),
}
}
}
pub(crate) struct LmQuantized {
pub(super) channels: Vec<crate::squeeze::Channel>,
pub(super) quants: Vec<u32>,
pub(super) steps: Vec<crate::squeeze::SqueezeStep>,
pub(super) layout: LmLayout,
pub(super) epf: (u32, f32),
pub(super) dc_frame: bool,
pub(super) xsize: usize,
pub(super) ysize: usize,
}
#[derive(Clone, Copy, PartialEq)]
pub(super) enum LmRole {
Luma,
Chroma,
Extra(f32),
}
fn lm_plain_chroma_mul(coding: crate::coding::CodingTransform) -> f32 {
match coding {
crate::coding::CodingTransform::Rgb => 4.0,
_ => 2.5,
}
}
pub(crate) fn lm_plain_distance(coding: crate::coding::CodingTransform, d: f32) -> f32 {
let knots: &[(f32, f32)] = match coding {
crate::coding::CodingTransform::Rgb => &[
(1.0, 1.527),
(1.5, 2.099),
(2.0, 2.599),
(3.0, 2.701),
(4.0, 2.745),
(5.0, 2.641),
],
_ => &[
(1.0, 2.383),
(1.5, 3.324),
(2.0, 3.905),
(3.0, 3.952),
(4.0, 3.895),
(5.0, 3.766),
],
};
d * interpolate_knots(knots, d)
}
pub(super) fn interpolate_knots(knots: &[(f32, f32)], x: f32) -> f32 {
let (first, last) = (knots[0], knots[knots.len() - 1]);
if x <= first.0 {
return first.1;
}
if x >= last.0 {
return last.1;
}
for w in knots.array_windows::<2>() {
let [(x0, y0), (x1, y1)] = [w[0], w[1]];
if x >= x0 && x <= x1 {
return y0 + (y1 - y0) * (x - x0) / (x1 - x0);
}
}
last.1
}
fn lossy_modular_q_plain(distance: f32, hshift: i32, vshift: i32, max: f32, mul: f32) -> i32 {
let mut shift = (hshift + vshift).min(16);
if shift > 0 {
shift -= 1;
}
let unit = max / LOSSY_MODULAR_XYB_SCALE[1];
let q = 0.25 * distance * SQUEEZE_QUALITY_FACTOR_XYB * SQUEEZE_XYB_QTABLE[0][shift as usize];
((q * unit * mul) as i32).max(1)
}
pub(crate) struct LmPlainInput {
pub color: Vec<Vec<i32>>,
pub extra: Vec<(Vec<i32>, f32)>,
pub max: f32,
pub coding: crate::coding::CodingTransform,
}
pub(crate) fn lm_quantize_plain(
input: &LmPlainInput,
xsize: usize,
ysize: usize,
effective_distance: f32,
) -> Option<LmQuantized> {
use crate::coding::CodingTransform;
use crate::squeeze::{
Channel, apply_step_forward, default_squeeze_steps, lossy_squeeze_steps_chroma,
};
let num_color = input.color.len();
debug_assert!(num_color == 1 || num_color == 3);
let num_c = num_color + input.extra.len();
if default_squeeze_steps(xsize, ysize, num_c).is_empty() {
return None;
}
let n = xsize * ysize;
let mut planes: Vec<Vec<i32>> = Vec::with_capacity(num_c);
let mut roles: Vec<LmRole> = Vec::with_capacity(num_c);
let (ycbcr, rct, chroma): (bool, bool, Vec<usize>) = match (num_color, input.coding) {
(3, CodingTransform::YCbCr) => (true, false, vec![0, 2]),
(3, _) => (false, true, vec![1, 2]),
_ => (false, false, Vec::new()),
};
if rct {
let [r, g, b] = [&input.color[0], &input.color[1], &input.color[2]];
let mut y = vec![0i32; n];
let mut co = vec![0i32; n];
let mut cg = vec![0i32; n];
for i in 0..n {
(y[i], co[i], cg[i]) = crate::lossless::forward_ycocg(r[i], g[i], b[i]);
}
planes.extend([y, co, cg]);
} else {
planes.extend(input.color.iter().map(|p| p[..n].to_vec()));
}
roles.extend((0..num_color).map(|c| {
if chroma.contains(&c) {
LmRole::Chroma
} else {
LmRole::Luma
}
}));
for (plane, distance) in &input.extra {
planes.push(plane[..n].to_vec());
roles.push(LmRole::Extra(*distance));
}
let steps = lossy_squeeze_steps_chroma(xsize, ysize, num_c, &chroma);
let n_pre: usize = steps.iter().filter(|s| !s.in_place).map(|s| s.num_c).sum();
let mut channels: Vec<Channel> = planes
.into_iter()
.map(|data| Channel {
data,
w: xsize,
h: ysize,
hshift: 0,
vshift: 0,
})
.collect();
for s in &steps {
apply_step_forward(&mut channels, s);
}
let nb = channels.len();
let mut quants: Vec<u32> = Vec::with_capacity(nb);
for (i, ch) in channels.iter_mut().enumerate() {
let role = if i >= nb - n_pre {
LmRole::Chroma
} else {
roles[i % num_c]
};
let q = match role {
LmRole::Luma => {
lossy_modular_q_plain(effective_distance, ch.hshift, ch.vshift, input.max, 1.0)
}
LmRole::Chroma => lossy_modular_q_plain(
effective_distance,
ch.hshift,
ch.vshift,
input.max,
lm_plain_chroma_mul(input.coding),
),
LmRole::Extra(d) if d > 0.0 => {
lossy_modular_q_plain(d, ch.hshift, ch.vshift, input.max, 1.0)
}
LmRole::Extra(_) => 1,
};
quantize_channel_divide(ch, q);
quants.push(q as u32);
}
let layout = LmLayout::Plain {
ycbcr,
rct,
extra: input.extra.len(),
};
Some(LmQuantized {
channels,
quants,
steps,
layout,
epf: lm_epf_schedule(layout, effective_distance),
dc_frame: false,
xsize,
ysize,
})
}
pub(crate) fn lm_quantize(
xyb: &crate::image::Image3F,
effective_distance: f32,
) -> Option<LmQuantized> {
let steps = crate::squeeze::lossy_squeeze_steps(xyb.xsize(), xyb.ysize(), 3);
lm_quantize_xyb(xyb, steps, |color, hshift, vshift| {
lossy_modular_q(color, hshift, vshift, effective_distance)
})
.map(|quantized| LmQuantized {
epf: lm_epf_schedule(LmLayout::Xyb, effective_distance),
..quantized
})
}
pub(super) fn lm_quantize_xyb(
xyb: &crate::image::Image3F,
steps: Vec<crate::squeeze::SqueezeStep>,
q_of: impl Fn(usize, i32, i32) -> i32,
) -> Option<LmQuantized> {
use crate::squeeze::{Channel, apply_step_forward, default_squeeze_steps};
let xsize = xyb.xsize();
let ysize = xyb.ysize();
let num_c = 3usize;
if default_squeeze_steps(xsize, ysize, num_c).is_empty() {
return None;
}
let chroma_pre = steps.len() >= 2 && !steps[0].in_place;
let n = xsize * ysize;
let input = [
&xyb.plane_data(0)[..n],
&xyb.plane_data(1)[..n],
&xyb.plane_data(2)[..n],
];
let mut planes = [vec![0i32; n], vec![0i32; n], vec![0i32; n]];
{
let [dst_y, dst_x, dst_b] = &mut planes;
let scales = [
LOSSY_MODULAR_XYB_SCALE[0],
LOSSY_MODULAR_XYB_SCALE[1],
LOSSY_MODULAR_XYB_SCALE[2],
];
unsafe {
crate::xyb::selected_quantize_xyb_channels_fn()(input, [dst_y, dst_x, dst_b], scales);
}
}
let mut channels: Vec<Channel> = planes
.into_iter()
.map(|data| Channel {
data,
w: xsize,
h: ysize,
hshift: 0,
vshift: 0,
})
.collect();
for s in &steps {
apply_step_forward(&mut channels, s);
}
let nb = channels.len();
let color_of = |i: usize| {
if chroma_pre && i >= nb - 4 {
1 } else {
i % num_c
}
};
let mut quants: Vec<u32> = Vec::with_capacity(nb);
for (i, ch) in channels.iter_mut().enumerate() {
let q = q_of(color_of(i), ch.hshift, ch.vshift);
quantize_channel_divide(ch, q);
quants.push(q as u32);
}
Some(LmQuantized {
channels,
quants,
steps,
layout: LmLayout::Xyb,
epf: (0, 0.0),
dc_frame: false,
xsize,
ysize,
})
}