EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
av1enc: truncate instead of floor, log2 lookup table, skip division in the dead zone
vangel7612af1c19cbdf
diff --git a/crates/av1enc/src/decide.rs b/crates/av1enc/src/decide.rsindex 494e914c0..a93d80bea 100644--- a/crates/av1enc/src/decide.rs+++ b/crates/av1enc/src/decide.rs@@ -127,6 +127,8 @@ pub(crate) struct Decider<'a> {ac_q: f32,dc_qi: i64,ac_qi: i64,+ /// Smallest magnitude that quantises to a non-zero level, `[dc, ac][intra]`.+ dead_zone: [[f32; 2]; 2],lambda: f64,lambda_sad: f64,/// Half-sample interpolations of the reference luma (visible area): (8, 0), (0, 8), (8, 8).@@ -134,6 +136,9 @@ pub(crate) struct Decider<'a> {}const MODE_BITS_INTRA: f64 = 3.0;+/// Dead-zone quantiser rounding offsets (below one half) for inter and intra blocks.+const INTER_RND: f32 = 0.30;+const INTRA_RND: f32 = 0.38;impl<'a> Decider<'a> {pub fn new(g: &'a FrameGeom, bd: u32, qidx: u8, intra_only: bool, src: &'a [Plane; 3], refr: Option<&'a RefFrame>) -> Self {@@ -160,6 +165,7 @@ impl<'a> Decider<'a> {ac_q: ac_qi as f32,dc_qi,ac_qi,+ dead_zone: [dc_qi, ac_qi].map(|q| [INTER_RND, INTRA_RND].map(|rnd| zero_threshold(q as f32, rnd))),lambda,lambda_sad: lambda.sqrt(),half: match refr {@@ -515,8 +521,9 @@ impl<'a> Decider<'a> {let (dy, dx) = (m[0] >> 3, m[1] >> 3);dx >= lim_x.0 && dx <= lim_x.1 && dy >= lim_y.0 && dy <= lim_y.1};+ let lg = log2_table();let mv_bits = |m: [i32; 2]| -> f64 {- let comp = |d: i32| if d == 0 { 0.5 } else { 2.0 + 2.0 * ((d.abs() / 8) as f64 + 1.0).log2() };+ let comp = |d: i32| if d == 0 { 0.5 } else { 2.0 + 2.0 * log2_of(lg, (d.abs() / 8) as usize + 1) };comp(m[0] - pred_mv[0]) + comp(m[1] - pred_mv[1])};let cost =@@ -795,12 +802,18 @@ impl<'a> Decider<'a> {let mut coef = vec![0f32; n * n];forward_2d(&res, &mut coef, n, tx_type);// dead-zone quantiser: rounding offset below one half- let rnd = if intra { 0.38f32 } else { 0.30f32 };+ let rnd = if intra { INTRA_RND } else { INTER_RND };+ let [dc_thr, ac_thr] = [self.dead_zone[0][intra as usize], self.dead_zone[1][intra as usize]];let mut levels = vec![0i32; n * n];let mut nonzero = false;for (k, (&cf, l)) in coef.iter().zip(levels.iter_mut()).enumerate() {- let q = if k == 0 { self.dc_q } else { self.ac_q };- let a = (cf.abs() / q + rnd).floor() as i32;+ let (q, thr) = if k == 0 { (self.dc_q, dc_thr) } else { (self.ac_q, ac_thr) };+ // dead zone: below the exact threshold the level is zero, no division needed+ if cf.abs() < thr {+ continue;+ }+ // the operand is >= 0, so truncation equals floor+ let a = (cf.abs() / q + rnd) as i32;if a != 0 {*l = if cf < 0.0 { -a.min(1 << 16) } else { a.min(1 << 16) };nonzero = true;@@ -841,6 +854,33 @@ impl<'a> Decider<'a> {}}+/// Smallest `x >= 0` with `(x / q + rnd) as i32 >= 1` in f32 arithmetic. The expression is+/// monotone in `x`, so a binary search over the bit patterns finds the exact boundary.+fn zero_threshold(q: f32, rnd: f32) -> f32 {+ let (mut lo, mut hi) = (0u32, f32::MAX.to_bits());+ while lo < hi {+ let mid = lo + (hi - lo) / 2;+ if (f32::from_bits(mid) / q + rnd) as i32 >= 1 {+ hi = mid;+ } else {+ lo = mid + 1;+ }+ }+ f32::from_bits(lo)+}++const LOG2_TABLE_LEN: usize = 1025;++/// `log2(i)` for `i < LOG2_TABLE_LEN`, computed with the same `f64::log2` call as the direct form.+fn log2_table() -> &'static [f64; LOG2_TABLE_LEN] {+ static TABLE: std::sync::OnceLock<[f64; LOG2_TABLE_LEN]> = std::sync::OnceLock::new();+ TABLE.get_or_init(|| std::array::from_fn(|i| (i as f64).log2()))+}++fn log2_of(table: &[f64; LOG2_TABLE_LEN], v: usize) -> f64 {+ if v < LOG2_TABLE_LEN { table[v] } else { (v as f64).log2() }+}+/// Unnormalised Walsh-Hadamard transform of 4 or 8 values, in place.fn hadamard(v: &mut [i32]) {let n = v.len();@@ -869,13 +909,14 @@ fn estimate_bits(levels: &[i32], tx_sz: usize) -> f64 {if eob == 0 {return 1.0;}- let mut bits = 3.0 + (eob as f64).log2();+ let lg = log2_table();+ let mut bits = 3.0 + log2_of(lg, eob);for &pos in &scan[..eob] {let a = levels[pos as usize].unsigned_abs();bits += match a {0 => 0.7,1 => 2.5,- _ => 3.5 + 1.6 * (a as f64).log2(),+ _ => 3.5 + 1.6 * log2_of(lg, a as usize),};}bits@@ -889,3 +930,64 @@ pub(crate) fn scan_for(tx_sz: usize) -> &'static [u16] {_ => &DEFAULT_SCAN_32X32,}}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::tables::{AC_QLOOKUP, DC_QLOOKUP};++ /// The quantiser as it was before the dead-zone threshold and the truncation.+ fn quant_ref(cf: f32, q: f32, rnd: f32) -> i32 {+ (cf.abs() / q + rnd).floor() as i32+ }++ fn quant_new(cf: f32, q: f32, rnd: f32, thr: f32) -> i32 {+ if cf.abs() < thr {+ return 0;+ }+ (cf.abs() / q + rnd) as i32+ }++ #[test]+ fn dead_zone_threshold_is_exact() {+ let mut state = 0x1234_5678_9abc_def0u64;+ let mut next = move || {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ state+ };+ for table in AC_QLOOKUP.iter().chain(DC_QLOOKUP.iter()) {+ for &qi in table.iter() {+ let q = qi as f32;+ for rnd in [INTER_RND, INTRA_RND] {+ let thr = zero_threshold(q, rnd);+ // the boundary itself and its neighbours+ let b = thr.to_bits();+ for bits in b.saturating_sub(3)..=b + 3 {+ let cf = f32::from_bits(bits);+ assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr), "q {q} rnd {rnd} cf {cf}");+ assert_eq!(quant_ref(-cf, q, rnd), quant_new(-cf, q, rnd, thr));+ }+ for _ in 0..200 {+ let cf = f32::from_bits((next() >> 32) as u32 & 0x7fff_ffff);+ if cf.is_nan() {+ continue;+ }+ assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr));+ let cf = (next() % 100_000) as f32 / 100.0;+ assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr));+ }+ }+ }+ }+ }++ #[test]+ fn log2_table_matches_direct_log2() {+ let t = log2_table();+ for v in 1..3000usize {+ assert_eq!(log2_of(t, v).to_bits(), (v as f64).log2().to_bits(), "{v}");+ }+ }+}