use crate::cabac::CabacEstimator;
use crate::contexts::{Contexts, ctx};
use crate::residual::{
ResidualPricingScratch, ScanOrder, estimate_residual_bits_into, get_scan_4x4,
get_scan_sub_block,
};
use crate::transform::DequantParams;
const QUANT_SCALE: [i64; 6] = [26214, 23302, 20560, 18396, 16384, 14564];
const MAX_TR_DYNAMIC_RANGE: i32 = 15;
const QUANT_SHIFT: i32 = 14;
const SCALE_BITS: i32 = 15;
const BYPASS_BITS: u64 = CabacEstimator::SCALE;
fn rdoq_lambda_scale() -> f64 {
use std::sync::OnceLock;
static V: OnceLock<f64> = OnceLock::new();
*V.get_or_init(|| {
std::env::var("BPG_RDOQ_LAMBDA_SCALE")
.ok()
.and_then(|s| s.trim().parse::<f64>().ok())
.filter(|v| v.is_finite() && *v > 0.0)
.unwrap_or(1.0)
})
}
fn x265_empty_cg_carry_enabled() -> bool {
use std::sync::OnceLock;
static V: OnceLock<bool> = OnceLock::new();
*V.get_or_init(|| {
std::env::var("BPG_RDOQ_X265_EMPTY_CG_CARRY")
.ok()
.map(|s| matches!(s.trim().to_ascii_lowercase().as_str(), "1" | "true" | "on"))
.unwrap_or(false)
})
}
fn x265_last_stop_enabled() -> bool {
use std::sync::OnceLock;
static V: OnceLock<bool> = OnceLock::new();
*V.get_or_init(|| {
std::env::var("BPG_RDOQ_X265_LAST_STOP")
.ok()
.map(|s| matches!(s.trim().to_ascii_lowercase().as_str(), "1" | "true" | "on"))
.unwrap_or(false)
})
}
pub(crate) fn rice_bins(value: u32, rice: u32) -> u32 {
if value < (4u32 << rice) {
(value >> rice) + 1 + rice
} else {
let mut p = 4u32;
loop {
let base = ((1u32 << (p - 3)) + 2) << rice;
let width = 1u32 << (p - 3 + rice);
if value < base + width {
return p + 1 + (p - 3 + rice);
}
p += 1;
}
}
}
#[inline]
fn ic_level_bits(
level: u32,
base_level: u32,
gt1: [u64; 2],
gt2: [u64; 2],
c1c2idx: u32,
go_rice: u32,
) -> u64 {
let diff = level as i64 - base_level as i64;
if diff < 0 {
gt1[(level == 2) as usize] + if level == 2 { gt2[0] } else { 0 }
} else {
let c1c2_rate =
(if c1c2idx & 1 != 0 { gt1[1] } else { 0 }) + (if c1c2idx == 3 { gt2[1] } else { 0 });
rice_bins(diff as u32, go_rice) as u64 * BYPASS_BITS + c1c2_rate
}
}
#[cfg(test)]
fn last_axis_bits(ctxs: &Contexts, value: u32, log2_size: u8, c_idx: u8, is_x: bool) -> u64 {
let ctx_base = if is_x {
ctx::LAST_SIG_COEFF_X_PREFIX
} else {
ctx::LAST_SIG_COEFF_Y_PREFIX
};
let (ctx_offset, ctx_shift) = if c_idx == 0 {
let offset = 3 * (log2_size as usize - 2) + ((log2_size as usize - 1) >> 2);
let shift = (log2_size + 1) >> 2;
(offset, shift)
} else {
(15usize, log2_size - 2)
};
let max_prefix = ((log2_size << 1) - 1) as u32;
let (prefix, n_bits) = if value <= 3 {
(value, 0u8)
} else {
let group = 31 - value.leading_zeros();
(2 * group + ((value >> (group - 1)) & 1), (group - 1) as u8)
};
let mut bits = 0u64;
for j in 0..prefix {
let ci = ctx_base + ctx_offset + (j as usize >> ctx_shift as usize);
bits += ctxs.models[ci].entropy_bits(1) as u64;
}
if prefix < max_prefix {
let ci = ctx_base + ctx_offset + (prefix as usize >> ctx_shift as usize);
bits += ctxs.models[ci].entropy_bits(0) as u64;
}
if value > 3 {
bits += n_bits as u64 * BYPASS_BITS;
}
bits
}
#[inline]
fn fill_last_axis_bits(
out: &mut [u64; 32],
ctxs: &Contexts,
size: usize,
log2_size: u8,
c_idx: u8,
is_x: bool,
) {
let ctx_base = if is_x {
ctx::LAST_SIG_COEFF_X_PREFIX
} else {
ctx::LAST_SIG_COEFF_Y_PREFIX
};
let (ctx_offset, ctx_shift) = if c_idx == 0 {
(
3 * (log2_size as usize - 2) + ((log2_size as usize - 1) >> 2),
(log2_size + 1) >> 2,
)
} else {
(15usize, log2_size - 2)
};
let max_prefix = ((log2_size << 1) - 1) as usize;
let mut one_prefix = [0u64; 11];
for prefix in 0..max_prefix {
let ci = ctx_base + ctx_offset + (prefix >> ctx_shift as usize);
one_prefix[prefix + 1] = one_prefix[prefix] + ctxs.models[ci].entropy_bits(1) as u64;
}
for (value, slot) in out.iter_mut().take(size).enumerate() {
let value = value as u32;
let (prefix, n_bits) = if value <= 3 {
(value as usize, 0u8)
} else {
let group = 31 - value.leading_zeros();
(
(2 * group + ((value >> (group - 1)) & 1)) as usize,
(group - 1) as u8,
)
};
let mut bits = one_prefix[prefix];
if prefix < max_prefix {
let ci = ctx_base + ctx_offset + (prefix >> ctx_shift as usize);
bits += ctxs.models[ci].entropy_bits(0) as u64;
}
if value > 3 {
bits += n_bits as u64 * BYPASS_BITS;
}
*slot = bits;
}
}
#[derive(Clone, Copy, Default)]
struct CoeffRec {
idx: usize, x: u32,
y: u32,
level: i16, dist0: i64, rd_normal: i64, rd_last: i64, }
const RD_NEVER: i64 = i64::MAX;
#[derive(Default)]
pub struct RdoqScratch {
recs: Vec<CoeffRec>,
suff_zero: Vec<i64>,
pref_normal: Vec<i64>,
levels: Vec<i16>,
price_scratch: ResidualPricingScratch,
dequant: Vec<i16>,
recon: Vec<i16>,
trial_levels: Vec<i16>,
}
pub struct RdoqResult<'a> {
pub levels: &'a mut [i16],
pub nnz: u32,
}
#[derive(Clone, Copy)]
pub struct RdoqPsy<'a> {
pub src_dct: &'a [i16],
pub psy_scale: i64,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum RdoqPricingMode {
#[default]
Frozen,
Running,
Hybrid,
ExactCleanup,
BoundedTrellis,
}
pub fn rdoq_refine_enabled() -> bool {
use std::sync::OnceLock;
static V: OnceLock<bool> = OnceLock::new();
*V.get_or_init(|| {
std::env::var("BPG_RDOQ_REFINE")
.ok()
.map(|s| matches!(s.trim(), "1" | "true" | "on"))
.unwrap_or(false)
})
}
#[allow(clippy::too_many_arguments)]
pub fn refine_rdoq_levels(
base_ctxs: &Contexts,
coeffs: &[i16],
residual: &[i16],
levels: &mut [i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
) -> u32 {
use crate::residual::{ResidualPricingScratch, estimate_residual_bits_into};
use crate::transform::reconstruct_residual;
let mut scratch = ResidualPricingScratch::default();
let cost = |levels: &[i16], scratch: &mut ResidualPricingScratch| -> f64 {
let recon = reconstruct_residual(levels, log2_size, qp, bit_depth, is_dst4);
let dist: f64 = residual
.iter()
.zip(&recon)
.map(|(&r, &c)| {
let d = r as i64 - c as i64;
(d * d) as f64
})
.sum();
let bits =
estimate_residual_bits_into(base_ctxs, levels, log2_size, c_idx, scan, false, scratch);
dist + lambda * bits as f64 / CabacEstimator::SCALE as f64
};
let mut best = cost(levels, &mut scratch);
loop {
let mut improved = false;
for i in 0..levels.len() {
let sign: i32 = if levels[i] != 0 {
levels[i].signum() as i32
} else if coeffs[i] != 0 {
coeffs[i].signum() as i32
} else {
continue; };
let m = levels[i].unsigned_abs() as i32;
let cands = [
0i16,
(sign * (m - 1).max(0)) as i16,
(sign * (m + 1)) as i16,
];
for &cand in &cands {
if cand == levels[i] {
continue;
}
let save = levels[i];
levels[i] = cand;
let c = cost(levels, &mut scratch);
if c + 1e-6 < best {
best = c;
improved = true;
} else {
levels[i] = save;
}
}
}
if !improved {
break;
}
}
levels.iter().filter(|&&l| l != 0).count() as u32
}
#[allow(clippy::too_many_arguments)]
fn exact_rd_cost(
base_ctxs: &Contexts,
residual: &[i16],
levels: &[i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
scratch: &mut RdoqScratch,
) -> f64 {
crate::transform::reconstruct_residual_into(
levels,
log2_size,
qp,
bit_depth,
is_dst4,
&mut scratch.dequant,
&mut scratch.recon,
);
let dist: f64 = residual
.iter()
.zip(&scratch.recon)
.map(|(&r, &c)| {
let d = r as i64 - c as i64;
(d * d) as f64
})
.sum();
let bits = estimate_residual_bits_into(
base_ctxs,
levels,
log2_size,
c_idx,
scan,
false,
&mut scratch.price_scratch,
);
dist + lambda * bits as f64 / CabacEstimator::SCALE as f64
}
fn level_sign(coeff: i16, level: i16) -> Option<i32> {
if level != 0 {
Some(level.signum() as i32)
} else if coeff != 0 {
Some(coeff.signum() as i32)
} else {
None
}
}
fn signed_level(sign: i32, mag: i32) -> i16 {
let mag = mag.clamp(0, i16::MAX as i32);
(sign * mag) as i16
}
fn nnz(levels: &[i16]) -> u32 {
levels.iter().filter(|&&l| l != 0).count() as u32
}
fn scan_indices(log2_size: u8, scan: ScanOrder) -> Vec<usize> {
let size = 1usize << log2_size;
let mut out = Vec::with_capacity(size * size);
for &(sbx, sby) in get_scan_sub_block(log2_size, scan).iter() {
for &(px, py) in get_scan_4x4(scan).iter() {
let x = sbx as usize * 4 + px as usize;
let y = sby as usize * 4 + py as usize;
if x < size && y < size {
out.push(y * size + x);
}
}
}
out
}
#[allow(clippy::too_many_arguments)]
fn keep_if_better(
base_ctxs: &Contexts,
residual: &[i16],
levels: &mut [i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
scratch: &mut RdoqScratch,
best: &mut f64,
) -> bool {
let cost = exact_rd_cost(
base_ctxs, residual, levels, log2_size, c_idx, qp, bit_depth, is_dst4, scan, lambda,
scratch,
);
if cost + 1e-6 < *best {
*best = cost;
true
} else {
false
}
}
#[allow(clippy::too_many_arguments)]
fn try_set_level(
base_ctxs: &Contexts,
residual: &[i16],
levels: &mut [i16],
idx: usize,
cand: i16,
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
scratch: &mut RdoqScratch,
best: &mut f64,
) -> bool {
if levels[idx] == cand {
return false;
}
let save = levels[idx];
levels[idx] = cand;
if keep_if_better(
base_ctxs, residual, levels, log2_size, c_idx, qp, bit_depth, is_dst4, scan, lambda,
scratch, best,
) {
true
} else {
levels[idx] = save;
false
}
}
#[allow(clippy::too_many_arguments)]
fn exact_drop_sweep(
base_ctxs: &Contexts,
coeffs: &[i16],
residual: &[i16],
levels: &mut [i16],
order: &[usize],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
scratch: &mut RdoqScratch,
best: &mut f64,
) -> bool {
let mut improved = false;
for &idx in order.iter().rev() {
let cur = levels[idx];
if cur == 0 {
continue;
}
let sign = level_sign(coeffs[idx], cur).unwrap_or(1);
let mag = cur.unsigned_abs() as i32;
let down = signed_level(sign, mag - 1);
if try_set_level(
base_ctxs, residual, levels, idx, down, log2_size, c_idx, qp, bit_depth, is_dst4, scan,
lambda, scratch, best,
) {
improved = true;
}
if levels[idx] != 0
&& try_set_level(
base_ctxs, residual, levels, idx, 0, log2_size, c_idx, qp, bit_depth, is_dst4,
scan, lambda, scratch, best,
)
{
improved = true;
}
}
improved
}
#[allow(clippy::too_many_arguments)]
fn exact_tail_cleanup(
base_ctxs: &Contexts,
residual: &[i16],
levels: &mut [i16],
order: &[usize],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
scratch: &mut RdoqScratch,
best: &mut f64,
) -> bool {
let mut improved = false;
scratch.trial_levels.clear();
scratch.trial_levels.extend_from_slice(levels);
if scratch.trial_levels.iter().any(|&l| l != 0) {
for v in &mut scratch.trial_levels {
*v = 0;
}
let trial = scratch.trial_levels.clone();
let cost = exact_rd_cost(
base_ctxs, residual, &trial, log2_size, c_idx, qp, bit_depth, is_dst4, scan, lambda,
scratch,
);
if cost + 1e-6 < *best {
*best = cost;
levels.copy_from_slice(&trial);
improved = true;
}
}
scratch.trial_levels.clear();
scratch.trial_levels.extend_from_slice(levels);
for last_rank in (0..order.len()).rev() {
let last_idx = order[last_rank];
if levels[last_idx] == 0 {
continue;
}
scratch.trial_levels.copy_from_slice(levels);
for &idx in order.iter().skip(last_rank + 1) {
scratch.trial_levels[idx] = 0;
}
let trial = scratch.trial_levels.clone();
let cost = exact_rd_cost(
base_ctxs, residual, &trial, log2_size, c_idx, qp, bit_depth, is_dst4, scan, lambda,
scratch,
);
if cost + 1e-6 < *best {
*best = cost;
levels.copy_from_slice(&trial);
improved = true;
}
}
improved
}
#[allow(clippy::too_many_arguments)]
fn exact_subblock_cleanup(
base_ctxs: &Contexts,
residual: &[i16],
levels: &mut [i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
scratch: &mut RdoqScratch,
best: &mut f64,
) -> bool {
let size = 1usize << log2_size;
let sb_width = size / 4;
let mut improved = false;
for &(sbx, sby) in get_scan_sub_block(log2_size, scan).iter().rev() {
let (sbx, sby) = (sbx as usize, sby as usize);
if sbx >= sb_width || sby >= sb_width {
continue;
}
let mut has_nz = false;
scratch.trial_levels.clear();
scratch.trial_levels.extend_from_slice(levels);
for y in sby * 4..((sby + 1) * 4).min(size) {
for x in sbx * 4..((sbx + 1) * 4).min(size) {
let idx = y * size + x;
has_nz |= scratch.trial_levels[idx] != 0;
scratch.trial_levels[idx] = 0;
}
}
if !has_nz {
continue;
}
let trial = scratch.trial_levels.clone();
let cost = exact_rd_cost(
base_ctxs, residual, &trial, log2_size, c_idx, qp, bit_depth, is_dst4, scan, lambda,
scratch,
);
if cost + 1e-6 < *best {
*best = cost;
levels.copy_from_slice(&trial);
improved = true;
}
}
improved
}
#[allow(clippy::too_many_arguments)]
fn exact_coordinate_descent(
base_ctxs: &Contexts,
coeffs: &[i16],
residual: &[i16],
levels: &mut [i16],
order: &[usize],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
scratch: &mut RdoqScratch,
best: &mut f64,
) {
loop {
let mut improved = false;
for &idx in order.iter().rev() {
let Some(sign) = level_sign(coeffs[idx], levels[idx]) else {
continue;
};
let mag = levels[idx].unsigned_abs() as i32;
let cands = [0, signed_level(sign, mag - 1), signed_level(sign, mag + 1)];
for cand in cands {
if try_set_level(
base_ctxs, residual, levels, idx, cand, log2_size, c_idx, qp, bit_depth,
is_dst4, scan, lambda, scratch, best,
) {
improved = true;
}
}
}
if !improved {
break;
}
}
}
#[allow(clippy::too_many_arguments)]
fn bounded_trellis(
base_ctxs: &Contexts,
coeffs: &[i16],
residual: &[i16],
levels: &mut [i16],
order: &[usize],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
beam_width: usize,
scratch: &mut RdoqScratch,
best: &mut f64,
) {
const MAX_TRELLIS_POSITIONS: usize = 32;
let beam_width = beam_width.clamp(1, 16);
let mut positions: Vec<usize> = order
.iter()
.rev()
.copied()
.filter(|&idx| levels[idx] != 0 || coeffs[idx] != 0)
.take(MAX_TRELLIS_POSITIONS)
.collect();
if positions.is_empty() {
return;
}
positions.reverse();
let mut beam = vec![(levels.to_vec(), *best)];
for idx in positions {
let mut next: Vec<(Vec<i16>, f64)> = Vec::new();
for (state, _) in beam.iter() {
let Some(sign) = level_sign(coeffs[idx], state[idx]) else {
continue;
};
let mag = state[idx].unsigned_abs() as i32;
let cands = [
state[idx],
0,
signed_level(sign, mag - 1),
signed_level(sign, mag + 1),
];
for cand in cands {
let mut candidate = state.clone();
candidate[idx] = cand;
if next.iter().any(|(seen, _)| seen == &candidate) {
continue;
}
let cost = exact_rd_cost(
base_ctxs, residual, &candidate, log2_size, c_idx, qp, bit_depth, is_dst4,
scan, lambda, scratch,
);
next.push((candidate, cost));
}
}
next.sort_by(|a, b| a.1.total_cmp(&b.1));
next.truncate(beam_width);
if next.is_empty() {
break;
}
beam = next;
}
if let Some((state, cost)) = beam.first() {
if *cost + 1e-6 < *best {
*best = *cost;
levels.copy_from_slice(state);
}
}
}
#[allow(clippy::too_many_arguments)]
pub fn apply_rdoq_pricing_mode(
base_ctxs: &Contexts,
coeffs: &[i16],
residual: &[i16],
levels: &mut [i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
is_dst4: bool,
scan: ScanOrder,
lambda: f64,
mode: RdoqPricingMode,
trellis_beam: usize,
scratch: &mut RdoqScratch,
) -> u32 {
if mode == RdoqPricingMode::Frozen {
return nnz(levels);
}
let order = scan_indices(log2_size, scan);
let mut best = exact_rd_cost(
base_ctxs, residual, levels, log2_size, c_idx, qp, bit_depth, is_dst4, scan, lambda,
scratch,
);
match mode {
RdoqPricingMode::Frozen => {}
RdoqPricingMode::Running => exact_coordinate_descent(
base_ctxs, coeffs, residual, levels, &order, log2_size, c_idx, qp, bit_depth, is_dst4,
scan, lambda, scratch, &mut best,
),
RdoqPricingMode::Hybrid => {
exact_tail_cleanup(
base_ctxs, residual, levels, &order, log2_size, c_idx, qp, bit_depth, is_dst4,
scan, lambda, scratch, &mut best,
);
exact_drop_sweep(
base_ctxs, coeffs, residual, levels, &order, log2_size, c_idx, qp, bit_depth,
is_dst4, scan, lambda, scratch, &mut best,
);
}
RdoqPricingMode::ExactCleanup => loop {
let changed_tail = exact_tail_cleanup(
base_ctxs, residual, levels, &order, log2_size, c_idx, qp, bit_depth, is_dst4,
scan, lambda, scratch, &mut best,
);
let changed_sb = exact_subblock_cleanup(
base_ctxs, residual, levels, log2_size, c_idx, qp, bit_depth, is_dst4, scan,
lambda, scratch, &mut best,
);
let changed_drop = exact_drop_sweep(
base_ctxs, coeffs, residual, levels, &order, log2_size, c_idx, qp, bit_depth,
is_dst4, scan, lambda, scratch, &mut best,
);
if !(changed_tail || changed_sb || changed_drop) {
break;
}
},
RdoqPricingMode::BoundedTrellis => bounded_trellis(
base_ctxs,
coeffs,
residual,
levels,
&order,
log2_size,
c_idx,
qp,
bit_depth,
is_dst4,
scan,
lambda,
trellis_beam,
scratch,
&mut best,
),
}
nnz(levels)
}
#[allow(clippy::too_many_arguments)]
pub fn rdoq_single_scan_into<'scratch>(
ctxs: &Contexts,
coeffs: &[i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
scan_order: ScanOrder,
lambda: f64,
level2: bool,
psy: Option<RdoqPsy<'_>>,
scratch: &'scratch mut RdoqScratch,
) -> RdoqResult<'scratch> {
let size = 1usize << log2_size;
let scan_sub = get_scan_sub_block(log2_size, scan_order);
let scan_pos = get_scan_4x4(scan_order);
let scan_idx = scan_order as u8;
let sb_width = size / 4;
let per = qp / 6;
let rem = (qp % 6) as usize;
let transform_shift = MAX_TR_DYNAMIC_RANGE - bit_depth as i32 - log2_size as i32;
let qbits = QUANT_SHIFT + per + transform_shift;
let scale = QUANT_SCALE[rem];
let round = 1i64 << (qbits - 1);
let dq = DequantParams::new(log2_size, qp, bit_depth);
let scale_bits = (SCALE_BITS - 2 * transform_shift) as u32;
debug_assert!((SCALE_BITS - 2 * transform_shift) > 0);
let lam = (rdoq_lambda_scale() * lambda * 256.0).round() as i64;
let rate = |bits: u64| -> i64 { (lam * bits as i64) >> 8 };
let psy_shift = (2 * transform_shift + 1).max(0) as u32;
let psy_value = |rec: i64| -> i64 {
match psy {
Some(p) => (p.psy_scale * rec) >> psy_shift,
None => 0,
}
};
let psy_predicted = |idx: usize| -> Option<i64> {
match psy {
Some(p) if idx != 0 => Some(p.src_dct[idx] as i64 - coeffs[idx] as i64),
_ => None,
}
};
let bits = |ci: usize, bin: u8| -> u64 { ctxs.models[ci].entropy_bits(bin) as u64 };
let ctx_set = if c_idx > 0 { 0usize } else { 2 };
let gt1_ci =
ctx::COEFF_ABS_LEVEL_GREATER1_FLAG + if c_idx > 0 { 16 } else { 0 } + ctx_set * 4 + 1;
let gt2_ci = ctx::COEFF_ABS_LEVEL_GREATER2_FLAG + if c_idx > 0 { 4 } else { 0 } + ctx_set;
let magnitude_bits = |l: u32| -> u64 {
let mag = match l {
1 => bits(gt1_ci, 0),
2 => bits(gt1_ci, 1) + bits(gt2_ci, 0),
_ => bits(gt1_ci, 1) + bits(gt2_ci, 1) + rice_bins(l - 3, 0) as u64 * BYPASS_BITS,
};
mag + BYPASS_BITS };
let gt1_base = ctx::COEFF_ABS_LEVEL_GREATER1_FLAG + if c_idx > 0 { 16 } else { 0 };
let gt2_base = ctx::COEFF_ABS_LEVEL_GREATER2_FLAG + if c_idx > 0 { 4 } else { 0 };
debug_assert_eq!(scan_sub.len() * 16, size * size);
let sig_threshold = ((round + scale - 1) / scale) as u32;
let mut last_sig_rank: isize = -1;
'find_last: for (sb_i, &(sbx, sby)) in scan_sub.iter().enumerate().rev() {
let row0 = sby as usize * 4 * size + sbx as usize * 4;
for pos in (0..16).rev() {
let (px, py) = scan_pos[pos];
let abs = coeffs[row0 + py as usize * size + px as usize].unsigned_abs() as u32;
if abs >= sig_threshold {
last_sig_rank = (sb_i * 16 + pos) as isize;
break 'find_last;
}
}
}
if last_sig_rank < 0 {
scratch.levels.clear();
scratch.levels.resize(size * size, 0);
return RdoqResult {
levels: &mut scratch.levels,
nnz: 0,
};
}
let last_cg = last_sig_rank as usize / 16;
let last_cg_top = last_sig_rank as usize % 16;
let kept_cgs = last_cg + 1;
let kept = last_sig_rank as usize + 1;
let recs = &mut scratch.recs;
recs.clear();
recs.resize(kept, CoeffRec::default());
let mut tail_zero_dist = 0i64;
for &(sbx, sby) in scan_sub[kept_cgs..].iter() {
let row0 = sby as usize * 4 * size + sbx as usize * 4;
for &(px, py) in scan_pos.iter() {
let idx = row0 + py as usize * size + px as usize;
let abs = coeffs[idx].unsigned_abs() as i64;
tail_zero_dist += (abs * abs) << scale_bits;
if let Some(predicted) = psy_predicted(idx) {
tail_zero_dist -= psy_value(predicted);
}
}
}
{
let (sbx, sby) = scan_sub[last_cg];
let row0 = sby as usize * 4 * size + sbx as usize * 4;
for pos in last_cg_top + 1..16 {
let (px, py) = scan_pos[pos];
let idx = row0 + py as usize * size + px as usize;
let abs = coeffs[idx].unsigned_abs() as i64;
tail_zero_dist += (abs * abs) << scale_bits;
if let Some(predicted) = psy_predicted(idx) {
tail_zero_dist -= psy_value(predicted);
}
}
}
let mut coded_sb_flags = [0u8; 8];
let mut prev_cg_c1 = 1u32;
for (sb_i, &(sbx, sby)) in scan_sub[..kept_cgs].iter().enumerate().rev() {
let sbx = sbx as usize;
let sby = sby as usize;
let right = sbx + 1 < sb_width && (coded_sb_flags[sby] & (1u8 << (sbx + 1))) != 0;
let below = sby + 1 < sb_width && (coded_sb_flags[sby + 1] & (1u8 << sbx)) != 0;
let prev_csbf = (right as u8) | ((below as u8) << 1);
let cg_is_not_dc = !(sbx == 0 && sby == 0);
let mut ctx_set2 = if cg_is_not_dc && c_idx == 0 { 2u32 } else { 0 };
if prev_cg_c1 == 0 {
ctx_set2 += 1;
}
let mut c1 = 1u32;
let mut c2 = 0u32;
let mut go_rice = 0u32;
let mut level_threshold = 3u32;
let mut c1_idx = 0u32;
let mut c2_idx = 0u32;
let gt2 = if level2 {
let gt2_ci = gt2_base + ctx_set2 as usize;
[bits(gt2_ci, 0), bits(gt2_ci, 1)]
} else {
[0, 0]
};
let sig_row =
crate::residual::sig_ctx_row(log2_size, c_idx, scan_idx, !cg_is_not_dc, prev_csbf);
let mut sb_has_sig = false;
let top = if sb_i == last_cg { last_cg_top } else { 15 };
for pos in (0..=top).rev() {
let (px, py) = scan_pos[pos];
let x = sbx * 4 + px as usize;
let y = sby * 4 + py as usize;
let rank = sb_i * 16 + pos;
let idx = y * size + x;
let coeff = coeffs[idx];
let abs = coeff.unsigned_abs() as i64;
let q = ((abs * scale + round) >> qbits).min(32767) as i32;
let sig_ci = sig_row[pos] as usize;
let sig0 = bits(sig_ci, 0);
let predicted = psy_predicted(idx);
let mut dist0 = (abs * abs) << scale_bits;
if let Some(predicted) = predicted {
dist0 -= psy_value(predicted);
}
let rec = &mut recs[rank];
rec.idx = idx;
rec.x = x as u32;
rec.y = y as u32;
rec.dist0 = dist0;
if q == 0 {
rec.level = 0;
rec.rd_normal = dist0 + rate(sig0);
rec.rd_last = RD_NEVER;
continue;
}
let sig1 = bits(sig_ci, 1);
let (base_level, gt1, c1c2idx) = if level2 {
let c1c2idx =
(if c1_idx < 8 { 1u32 } else { 0 }) + (if c2_idx == 0 { 2 } else { 0 });
let base_level = if c1_idx < 8 {
if c2_idx == 0 { 3 } else { 2 }
} else {
1
};
let gt1_ci = gt1_base + 4 * ctx_set2 as usize + c1 as usize;
(base_level, [bits(gt1_ci, 0), bits(gt1_ci, 1)], c1c2idx)
} else {
(0, [0, 0], 0)
};
let mut best_l = 0i64;
let mut best_levbits = 0u64;
let mut best_distl = dist0;
let mut best_cost = dist0 + rate(sig0);
for l in (q - 1).max(1)..=q {
let unquant = dq.apply(l as i16) as i64;
let dl = abs - unquant;
let mut dist = (dl * dl) << scale_bits;
if let Some(predicted) = predicted {
let aligned = if coeff >= 0 { predicted } else { -predicted };
dist -= psy_value((unquant + aligned).abs());
}
let mb = if level2 {
ic_level_bits(l as u32, base_level, gt1, gt2, c1c2idx, go_rice) + BYPASS_BITS
} else {
magnitude_bits(l as u32)
};
let cost = dist + rate(sig1 + mb);
if cost < best_cost {
best_cost = cost;
best_l = l as i64;
best_levbits = mb;
best_distl = dist;
}
}
let rec = &mut recs[rank];
rec.dist0 = dist0;
if best_l != 0 {
rec.level = if coeff < 0 { -best_l } else { best_l } as i16;
rec.rd_normal = best_distl + rate(sig1 + best_levbits);
rec.rd_last = best_distl + rate(best_levbits);
sb_has_sig = true;
} else {
rec.level = 0;
rec.rd_normal = dist0 + rate(sig0);
rec.rd_last = RD_NEVER; }
if level2 {
let l = best_l as u32; if l >= base_level && go_rice < 4 && l > level_threshold {
go_rice += 1;
level_threshold <<= 1;
}
if best_l != 0 {
c1_idx += 1;
}
if l > 1 {
c1 = 0;
if c2 < 2 {
c2 += 1;
}
c2_idx += 1;
} else if (c1 == 1 || c1 == 2) && best_l != 0 {
c1 += 1;
}
}
}
if level2 {
if sb_has_sig || x265_empty_cg_carry_enabled() {
prev_cg_c1 = c1;
}
}
if sb_has_sig {
coded_sb_flags[sby] |= 1u8 << sbx;
}
}
let total = recs.len();
let suff_zero = &mut scratch.suff_zero;
suff_zero.clear();
suff_zero.resize(total + 1, 0);
suff_zero[total] = tail_zero_dist;
for k in (0..total).rev() {
suff_zero[k] = suff_zero[k + 1] + recs[k].dist0;
}
let mut best_cost = suff_zero[0];
let mut best_last: isize = -1;
let mut last_x_bits_by_val = [0u64; 32];
let mut last_y_bits_by_val = [0u64; 32];
fill_last_axis_bits(&mut last_x_bits_by_val, ctxs, size, log2_size, c_idx, true);
fill_last_axis_bits(&mut last_y_bits_by_val, ctxs, size, log2_size, c_idx, false);
let last_bits_for_rec = |rec: &CoeffRec| -> u64 {
let (raw_x, raw_y) = if scan_order == ScanOrder::Vertical {
(rec.y as usize, rec.x as usize)
} else {
(rec.x as usize, rec.y as usize)
};
last_x_bits_by_val[raw_x] + last_y_bits_by_val[raw_y]
};
let last_stop = x265_last_stop_enabled();
if last_stop {
let pref_normal = &mut scratch.pref_normal;
pref_normal.clear();
pref_normal.resize(total + 1, 0);
for k in 0..total {
pref_normal[k + 1] = pref_normal[k] + recs[k].rd_normal;
}
for p in (0..total).rev() {
if recs[p].level == 0 {
continue;
}
let lp = rate(last_bits_for_rec(&recs[p]));
let cost = pref_normal[p] + recs[p].rd_last + suff_zero[p + 1] + lp;
if cost < best_cost {
best_cost = cost;
best_last = p as isize;
}
if recs[p].level.unsigned_abs() > 1 {
break;
}
}
} else {
let mut pref_normal = 0i64;
for p in 0..total {
if recs[p].level != 0 {
let lp = rate(last_bits_for_rec(&recs[p]));
let cost = pref_normal + recs[p].rd_last + suff_zero[p + 1] + lp;
if cost < best_cost {
best_cost = cost;
best_last = p as isize;
}
}
pref_normal += recs[p].rd_normal;
}
}
let last_sb_scan = if best_last >= 0 {
best_last as usize / 16
} else {
0
};
if last_sb_scan > 1 {
let last = best_last as usize;
let mut coded = [0u8; 8];
for rec in recs.iter().take(last + 1) {
if rec.level != 0 {
coded[rec.y as usize / 4] |= 1u8 << (rec.x as usize / 4);
}
}
for sb_scan in (1..last_sb_scan).rev() {
let (sbx, sby) = scan_sub[sb_scan];
let (sbx, sby) = (sbx as usize, sby as usize);
if (coded[sby] & (1u8 << sbx)) == 0 {
continue; }
let right = sbx + 1 < sb_width && (coded[sby] & (1u8 << (sbx + 1))) != 0;
let below = sby + 1 < sb_width && (coded[sby + 1] & (1u8 << sbx)) != 0;
let csbf_neighbors = (right as u8) | ((below as u8) << 1);
let csbf_ci = ctx::CODED_SUB_BLOCK_FLAG
+ (csbf_neighbors != 0) as usize
+ if c_idx > 0 { 2 } else { 0 };
let mut keep = rate(bits(csbf_ci, 1));
let mut zero = rate(bits(csbf_ci, 0));
for rank in sb_scan * 16..(sb_scan + 1) * 16 {
keep += recs[rank].rd_normal;
zero += recs[rank].dist0;
}
if zero < keep {
for rank in sb_scan * 16..(sb_scan + 1) * 16 {
recs[rank].level = 0;
}
coded[sby] &= !(1u8 << sbx);
}
}
}
let levels = &mut scratch.levels;
levels.clear();
levels.resize(size * size, 0);
let mut nnz = 0u32;
if best_last >= 0 {
let last = best_last as usize;
for rec in recs.iter().take(last + 1) {
if rec.level != 0 {
levels[rec.idx] = rec.level;
nnz += 1;
}
}
}
RdoqResult {
levels: &mut scratch.levels,
nnz,
}
}
#[cfg(test)]
mod rdoq_optimality_tests {
use super::{
RdoqPricingMode, RdoqPsy, RdoqScratch, apply_rdoq_pricing_mode, rdoq_single_scan_into,
};
use crate::cabac::CabacEstimator;
use crate::contexts::Contexts;
use crate::residual::{ScanOrder, estimate_residual_bits};
use crate::transform::{forward_transform, quantize, reconstruct_residual};
fn lambda(qp: i32) -> f64 {
0.57 * 2f64.powf((qp as f64 - 12.0) / 3.0)
}
#[allow(clippy::too_many_arguments)]
fn rdoq_single_scan(
ctxs: &Contexts,
coeffs: &[i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
scan_order: ScanOrder,
lambda: f64,
level2: bool,
psy: Option<RdoqPsy<'_>>,
) -> (Vec<i16>, u32) {
let mut scratch = RdoqScratch::default();
let result = rdoq_single_scan_into(
ctxs,
coeffs,
log2_size,
c_idx,
qp,
bit_depth,
scan_order,
lambda,
level2,
psy,
&mut scratch,
);
(result.levels.to_vec(), result.nnz)
}
fn true_rd(
levels: &[i16],
residual: &[i16],
log2: u8,
qp: i32,
bd: u8,
scan: ScanOrder,
lam: f64,
) -> (f64, f64, u64) {
let recon = reconstruct_residual(levels, log2, qp, bd, false);
let dist: f64 = residual
.iter()
.zip(&recon)
.map(|(&r, &c)| {
let d = r as i64 - c as i64;
(d * d) as f64
})
.sum();
let mut ctx = Contexts::new(qp);
let bits = estimate_residual_bits(&mut ctx, levels, log2, 0, scan, false);
(
dist + lam * bits as f64 / CabacEstimator::SCALE as f64,
dist,
bits,
)
}
#[test]
fn pricing_modes_do_not_worsen_exact_rd_objective() {
let log2 = 3;
let qp = 28;
let bd = 8;
let scan = ScanOrder::Diagonal;
let lam = lambda(qp);
let residual: Vec<i16> = (0..64)
.map(|i| {
let x = (i & 7) as i16;
let y = (i >> 3) as i16;
(x * 9 - y * 5 + ((i % 5) as i16 - 2) * 7).clamp(-127, 127)
})
.collect();
let coeffs = forward_transform(&residual, log2, false, bd);
let ctx = Contexts::new(qp);
let (start, _) = rdoq_single_scan(&ctx, &coeffs, log2, 0, qp, bd, scan, lam, true, None);
for mode in [
RdoqPricingMode::Running,
RdoqPricingMode::Hybrid,
RdoqPricingMode::ExactCleanup,
RdoqPricingMode::BoundedTrellis,
] {
let mut levels = start.clone();
let before = true_rd(&levels, &residual, log2, qp, bd, scan, lam).0;
let mut scratch = RdoqScratch::default();
let returned_nnz = apply_rdoq_pricing_mode(
&ctx,
&coeffs,
&residual,
&mut levels,
log2,
0,
qp,
bd,
false,
scan,
lam,
mode,
4,
&mut scratch,
);
let after = true_rd(&levels, &residual, log2, qp, bd, scan, lam).0;
assert!(
after <= before + 1e-6,
"{mode:?} worsened exact RD: before={before}, after={after}"
);
assert_eq!(
returned_nnz,
levels.iter().filter(|&&l| l != 0).count() as u32
);
}
}
fn optimize(
start: &[i16],
hq: &[i16],
coeffs: &[i16],
residual: &[i16],
log2: u8,
qp: i32,
bd: u8,
scan: ScanOrder,
lam: f64,
) -> Vec<i16> {
let mut cur = start.to_vec();
let mut best = true_rd(&cur, residual, log2, qp, bd, scan, lam).0;
loop {
let mut improved = false;
for i in 0..cur.len() {
let center = hq[i];
let sign: i16 = if center != 0 {
center.signum()
} else if coeffs[i] != 0 {
coeffs[i].signum()
} else {
1
};
let m = center.unsigned_abs() as i32;
let cands = [
0i16,
(sign as i32 * (m - 1).max(0)) as i16,
(sign as i32 * m) as i16,
(sign as i32 * (m + 1)) as i16,
];
for &cand in &cands {
if cand == cur[i] {
continue;
}
let save = cur[i];
cur[i] = cand;
let c = true_rd(&cur, residual, log2, qp, bd, scan, lam).0;
if c + 1e-6 < best {
best = c;
improved = true;
} else {
cur[i] = save;
}
}
}
if !improved {
break;
}
}
cur
}
fn make_residual(n: usize, scale: f64, seed: u64) -> Vec<i16> {
let mut s = seed.wrapping_add(0x9E3779B97F4A7C15);
let mut next = || {
s = s
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
((s >> 33) as f64) / (1u64 << 31) as f64
};
(0..n)
.map(|_| {
let u = next().max(1e-6);
let sign = if next() < 0.5 { -1.0 } else { 1.0 };
(sign * -scale * u.ln()).round().clamp(-90.0, 90.0) as i16
})
.collect()
}
#[test]
fn rdoq_vs_bruteforce_optimum() {
let log2: u8 = 3; let n = 1usize << (2 * log2);
let bd = 8u8;
let scan = ScanOrder::Diagonal;
let mut agg_rdoq_excess = 0.0f64; let mut agg_hq_excess = 0.0f64;
let mut count = 0;
let mut rdoq_beaten = 0;
println!(
"\n qp scale seed | nnz(hq/rdoq/opt) | RD hq / rdoq / opt | rdoq-excess% hq-excess%"
);
for qp in [22i32, 28, 34] {
let lam = lambda(qp);
for &scale in &[6.0f64, 12.0, 22.0] {
for seed in 0..6u64 {
let residual = make_residual(n, scale, seed * 131 + qp as u64);
let coeffs = forward_transform(&residual, log2, false, bd);
let (hq, _) = quantize(&coeffs, log2, qp, bd);
let ctx = Contexts::new(qp);
let (rdoq, _) =
rdoq_single_scan(&ctx, &coeffs, log2, 0, qp, bd, scan, lam, true, None);
if hq.iter().all(|&l| l == 0) && rdoq.iter().all(|&l| l == 0) {
continue;
}
let opt_from_hq =
optimize(&hq, &hq, &coeffs, &residual, log2, qp, bd, scan, lam);
let opt_from_rdoq =
optimize(&rdoq, &hq, &coeffs, &residual, log2, qp, bd, scan, lam);
let rd_hq = true_rd(&hq, &residual, log2, qp, bd, scan, lam).0;
let rd_rdoq = true_rd(&rdoq, &residual, log2, qp, bd, scan, lam).0;
let rd_o1 = true_rd(&opt_from_hq, &residual, log2, qp, bd, scan, lam).0;
let rd_o2 = true_rd(&opt_from_rdoq, &residual, log2, qp, bd, scan, lam).0;
let rd_opt = rd_o1.min(rd_o2);
let nz = |v: &[i16]| v.iter().filter(|&&l| l != 0).count();
let rdoq_excess = 100.0 * (rd_rdoq - rd_opt) / rd_opt.max(1.0);
let hq_excess = 100.0 * (rd_hq - rd_opt) / rd_opt.max(1.0);
agg_rdoq_excess += rdoq_excess;
agg_hq_excess += hq_excess;
count += 1;
if rd_opt + 1.0 < rd_rdoq {
rdoq_beaten += 1;
}
if seed < 2 {
println!(
" {qp:2} {scale:4.0} {seed:4} | {:2}/{:2}/{:2} | {:9.0} {:9.0} {:9.0} | {:+6.2}% {:+6.2}%",
nz(&hq),
nz(&rdoq),
nz(&opt_from_rdoq),
rd_hq,
rd_rdoq,
rd_opt,
rdoq_excess,
hq_excess
);
}
}
}
}
println!(
"\n AGGREGATE over {count} blocks: mean RDOQ excess over local-opt = {:.3}%, \
mean hard-quant excess = {:.3}%, RDOQ beaten in {rdoq_beaten}/{count} blocks",
agg_rdoq_excess / count as f64,
agg_hq_excess / count as f64
);
}
}
#[cfg(test)]
mod psy_rdoq_tests {
use super::{RdoqPsy, RdoqScratch, rdoq_single_scan_into};
use crate::contexts::Contexts;
use crate::residual::ScanOrder;
fn lambda(qp: i32) -> f64 {
0.57 * 2f64.powf((qp as f64 - 12.0) / 3.0)
}
#[allow(clippy::too_many_arguments)]
fn rdoq_single_scan(
ctxs: &Contexts,
coeffs: &[i16],
log2_size: u8,
c_idx: u8,
qp: i32,
bit_depth: u8,
scan_order: ScanOrder,
lambda: f64,
level2: bool,
psy: Option<RdoqPsy<'_>>,
) -> (Vec<i16>, u32) {
let mut scratch = RdoqScratch::default();
let result = rdoq_single_scan_into(
ctxs,
coeffs,
log2_size,
c_idx,
qp,
bit_depth,
scan_order,
lambda,
level2,
psy,
&mut scratch,
);
(result.levels.to_vec(), result.nnz)
}
#[test]
fn psy_keeps_ac_coefficient_that_plain_rdoq_zeroes() {
let log2 = 3u8;
let size = 1usize << log2;
let qp = 34;
let bd = 8u8;
let scan = ScanOrder::Diagonal;
let lam = lambda(qp);
let ctx = Contexts::new(qp);
let mut coeffs = vec![0i16; size * size];
let pos = 3 * size + 2;
coeffs[pos] = 260;
let (plain, plain_nnz) =
rdoq_single_scan(&ctx, &coeffs, log2, 0, qp, bd, scan, lam, true, None);
assert_eq!(plain[pos], 0, "test premise: plain RDOQ zeroes this coef");
assert_eq!(plain_nnz, 0);
let psy = RdoqPsy {
src_dct: &coeffs, psy_scale: 1 << 28, };
let (kept, kept_nnz) =
rdoq_single_scan(&ctx, &coeffs, log2, 0, qp, bd, scan, lam, true, Some(psy));
assert_ne!(kept[pos], 0, "psy-rdoq must keep the AC coefficient");
assert_eq!(kept_nnz, 1);
assert!(kept[pos] > 0, "level sign must follow the coefficient sign");
}
#[test]
fn psy_skips_dc_position() {
let log2 = 3u8;
let size = 1usize << log2;
let qp = 30;
let bd = 8u8;
let scan = ScanOrder::Diagonal;
let lam = lambda(qp);
let ctx = Contexts::new(qp);
let mut coeffs = vec![0i16; size * size];
coeffs[0] = 600;
let (plain, plain_nnz) =
rdoq_single_scan(&ctx, &coeffs, log2, 0, qp, bd, scan, lam, true, None);
let mut src_dct = vec![0i16; size * size];
src_dct[0] = 30000; let psy = RdoqPsy {
src_dct: &src_dct,
psy_scale: 1 << 30,
};
let (biased, biased_nnz) =
rdoq_single_scan(&ctx, &coeffs, log2, 0, qp, bd, scan, lam, true, Some(psy));
assert_eq!(plain, biased, "DC-only block must be psy-invariant");
assert_eq!(plain_nnz, biased_nnz);
}
}
#[cfg(test)]
mod last_axis_table_tests {
use super::{fill_last_axis_bits, last_axis_bits};
use crate::contexts::Contexts;
#[test]
fn cumulative_last_axis_tables_match_scalar_reference() {
for qp in [0, 22, 28, 37, 51] {
let ctxs = Contexts::new(qp);
for log2_size in 2..=5 {
let size = 1usize << log2_size;
for c_idx in [0u8, 1, 2] {
for is_x in [false, true] {
let mut got = [0u64; 32];
fill_last_axis_bits(&mut got, &ctxs, size, log2_size, c_idx, is_x);
for (value, &bits) in got.iter().take(size).enumerate() {
assert_eq!(
bits,
last_axis_bits(&ctxs, value as u32, log2_size, c_idx, is_x,),
"qp={qp} log2={log2_size} c={c_idx} x={is_x} value={value}",
);
}
}
}
}
}
}
}
#[cfg(test)]
mod context_drift_sizing {
use crate::contexts::Contexts;
use crate::residual::{ScanOrder, estimate_residual_bits};
use crate::transform::{forward_transform, quantize};
fn make_residual(n: usize, scale: f64, seed: u64) -> Vec<i16> {
let mut s = seed.wrapping_add(0x9E3779B97F4A7C15);
let mut next = || {
s = s
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
((s >> 33) as f64) / (1u64 << 31) as f64
};
(0..n)
.map(|_| {
let u = next().max(1e-6);
let sign = if next() < 0.5 { -1.0 } else { 1.0 };
(sign * -scale * u.ln()).round().clamp(-90.0, 90.0) as i16
})
.collect()
}
#[test]
fn context_drift_pricing_magnitude() {
let log2 = 3u8;
let n = 1usize << (2 * log2);
let bd = 8u8;
let scan = ScanOrder::Diagonal;
let drift_blocks = 30; for qp in [22i32, 28, 34] {
for &scale in &[8.0f64, 18.0] {
let mut sum_fresh = 0i64;
let mut sum_drift = 0i64;
let mut sum_abs_delta = 0i64;
let trials = 40;
for t in 0..trials {
let coeffs = forward_transform(
&make_residual(n, scale, t * 7 + qp as u64),
log2,
false,
bd,
);
let (levels, _) = quantize(&coeffs, log2, qp, bd);
let mut cf = Contexts::new(qp);
let bf = estimate_residual_bits(&mut cf, &levels, log2, 0, scan, false) as i64;
let mut cd = Contexts::new(qp);
for k in 0..drift_blocks {
let pc = forward_transform(
&make_residual(n, scale, 9000 + t * 131 + k * 17 + qp as u64),
log2,
false,
bd,
);
let (pl, _) = quantize(&pc, log2, qp, bd);
let _ = estimate_residual_bits(&mut cd, &pl, log2, 0, scan, false);
}
let bd2 = estimate_residual_bits(&mut cd, &levels, log2, 0, scan, false) as i64;
sum_fresh += bf;
sum_drift += bd2;
sum_abs_delta += (bf - bd2).abs();
}
let scale_u = crate::cabac::CabacEstimator::SCALE as f64;
let mf = sum_fresh as f64 / trials as f64 / scale_u;
let md = sum_drift as f64 / trials as f64 / scale_u;
println!(
" qp{qp} scale{scale:4.0}: fresh={mf:7.1}b drift={md:7.1}b mean_signed_delta={:+.2}b ({:+.2}%) mean_abs_delta={:.2}b",
md - mf,
100.0 * (md - mf) / mf,
sum_abs_delta as f64 / trials as f64 / scale_u
);
}
}
}
}