From 3bc15c7c176735d88b7bd5c521b2dcb08aba252a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Wed, 28 Oct 2026 06:09:21 +0000 Subject: [PATCH] Refactor vp9enc for strict Clippy checks --- crates/vp9enc/src/lf.rs | 83 +++++++++++++++++++++---------------- crates/vp9enc/src/lib.rs | 1 - crates/vp9enc/src/probs.rs | 6 ++- crates/vp9enc/src/tables.rs | 2 - crates/vp9enc/src/tile.rs | 37 ++++++++++------- 5 files changed, 75 insertions(+), 54 deletions(-) diff --git a/crates/vp9enc/src/lf.rs b/crates/vp9enc/src/lf.rs index d781144fe..f3a96c558 100644 --- a/crates/vp9enc/src/lf.rs +++ b/crates/vp9enc/src/lf.rs @@ -13,6 +13,14 @@ struct Limits { thresh: i32, } +/// Mode-info grid and thresholds shared by every superblock of this frame. +struct FrameFilter<'a> { + mi: &'a [Mi], + mi_rows: usize, + mi_cols: usize, + limits: Limits, +} + /// Filter the reconstructed planes (Y, U, V, or a prefix of them) in place at `level` (0 = off; /// sharpness 0). pub fn filter_frame(planes: &mut [Plane], mi: &[Mi], mi_rows: usize, mi_cols: usize, level: u8) { @@ -22,55 +30,58 @@ pub fn filter_frame(planes: &mut [Plane], mi: &[Mi], mi_rows: usize, mi_cols: us let l = level as i32; let limit = l.max(1); let lim = Limits { limit, blimit: 2 * (l + 2) + limit, thresh: l >> 4 }; + let filter = FrameFilter { mi, mi_rows, mi_cols, limits: lim }; for sbr in 0..mi_rows.div_ceil(8) { for sbc in 0..mi_cols.div_ceil(8) { for (plane, p) in planes.iter_mut().enumerate() { for pass in 0..2 { - sb_plane(p, mi, mi_rows, mi_cols, plane, pass, sbr * 8, sbc * 8, lim); + filter.sb_plane(p, plane, pass, sbr * 8, sbc * 8); } } } } } -#[allow(clippy::too_many_arguments)] -fn sb_plane(p: &mut Plane, mi: &[Mi], mi_rows: usize, mi_cols: usize, plane: usize, pass: usize, row: usize, col: usize, lim: Limits) { - let (sx, sy) = if plane > 0 { (1, 1) } else { (0, 0) }; - let (sub, edge_len) = if pass == 0 { (sx, 64 >> sy) } else { (sy, 64 >> sx) }; - let stride = p.w; - for edge in 0..(16usize >> sub) { - let mut i = 0; - while i < edge_len { - let (x, y) = if pass == 0 { (col * 8 + edge * (4 << sx), row * 8 + (i << sy)) } else { (col * 8 + (i << sx), row * 8 + edge * (4 << sy)) }; - if x >= 8 * mi_cols || y >= 8 * mi_rows || (pass == 0 && x == 0) || (pass == 1 && y == 0) { - i += 8; - continue; - } - let lc = ((x >> 3) >> sx) << sx; - let lr = ((y >> 3) >> sy) << sy; - let m = mi[lr * mi_cols + lc]; - let size = if sub == 0 { m.size } else { m.size.max(BLOCK_16X16) }; - let n8 = if size >= BLOCK_16X16 { 2 } else { 1 }; - let is_block_edge = if pass == 0 { x & (8 * n8 - 1) == 0 } else { y & (8 * n8 - 1) == 0 }; - let tx_ok = !m.inter || !m.skip; - if !is_block_edge && !tx_ok { - i += 8; - continue; - } - let wide = edge % 8 == 0; - let n = if pass == 0 { (8 * mi_rows - y).div_ceil(1 << sy) } else { (8 * mi_cols - x).div_ceil(1 << sx) }.min(8).min(edge_len - i); - // A transform edge is not filtered in the last odd chroma column. - let odd_last = pass == 1 && sx == 1 && mi_cols & 1 == 1 && edge & 1 == 1; - let (px, py) = (x >> sx, y >> sy); - for l in 0..n { - let is_tx_edge = tx_ok && !(odd_last && x + (l << sx) + 8 >= mi_cols * 8); - if !(is_block_edge || is_tx_edge) { +impl FrameFilter<'_> { + fn sb_plane(&self, p: &mut Plane, plane: usize, pass: usize, row: usize, col: usize) { + let Self { mi, mi_rows, mi_cols, limits: lim } = *self; + let (sx, sy) = if plane > 0 { (1, 1) } else { (0, 0) }; + let (sub, edge_len) = if pass == 0 { (sx, 64 >> sy) } else { (sy, 64 >> sx) }; + let stride = p.w; + for edge in 0..(16usize >> sub) { + let mut i = 0; + while i < edge_len { + let (x, y) = if pass == 0 { (col * 8 + edge * (4 << sx), row * 8 + (i << sy)) } else { (col * 8 + (i << sx), row * 8 + edge * (4 << sy)) }; + if x >= 8 * mi_cols || y >= 8 * mi_rows || (pass == 0 && x == 0) || (pass == 1 && y == 0) { + i += 8; continue; } - let (pos, step) = if pass == 0 { ((py + l) * stride + px, 1) } else { (py * stride + px + l, stride) }; - filter_lane(&mut p.rec, pos, step, wide, lim); + let lc = ((x >> 3) >> sx) << sx; + let lr = ((y >> 3) >> sy) << sy; + let m = mi[lr * mi_cols + lc]; + let size = if sub == 0 { m.size } else { m.size.max(BLOCK_16X16) }; + let n8 = if size >= BLOCK_16X16 { 2 } else { 1 }; + let is_block_edge = if pass == 0 { x & (8 * n8 - 1) == 0 } else { y & (8 * n8 - 1) == 0 }; + let tx_ok = !m.inter || !m.skip; + if !is_block_edge && !tx_ok { + i += 8; + continue; + } + let wide = edge % 8 == 0; + let n = if pass == 0 { (8 * mi_rows - y).div_ceil(1 << sy) } else { (8 * mi_cols - x).div_ceil(1 << sx) }.min(8).min(edge_len - i); + // A transform edge is not filtered in the last odd chroma column. + let odd_last = pass == 1 && sx == 1 && mi_cols & 1 == 1 && edge & 1 == 1; + let (px, py) = (x >> sx, y >> sy); + for l in 0..n { + let is_tx_edge = tx_ok && !(odd_last && x + (l << sx) + 8 >= mi_cols * 8); + if !(is_block_edge || is_tx_edge) { + continue; + } + let (pos, step) = if pass == 0 { ((py + l) * stride + px, 1) } else { (py * stride + px + l, stride) }; + filter_lane(&mut p.rec, pos, step, wide, lim); + } + i += 8; } - i += 8; } } } diff --git a/crates/vp9enc/src/lib.rs b/crates/vp9enc/src/lib.rs index 9364dfaa1..b9b56b693 100644 --- a/crates/vp9enc/src/lib.rs +++ b/crates/vp9enc/src/lib.rs @@ -85,7 +85,6 @@ pub(crate) struct Plane { } impl Plane { - #[allow(clippy::too_many_arguments)] fn new(data: &[u8], vw: usize, vh: usize, w: usize, h: usize, max_x: usize, max_y: usize) -> Plane { let mut src = vec![0u8; w * h]; for y in 0..h { diff --git a/crates/vp9enc/src/probs.rs b/crates/vp9enc/src/probs.rs index 8f55bbba3..57af2e29b 100644 --- a/crates/vp9enc/src/probs.rs +++ b/crates/vp9enc/src/probs.rs @@ -9,7 +9,11 @@ //! entropy codes the recorded symbols with the updated probabilities. use crate::bool::BoolEncoder; -use crate::tables::*; +use crate::tables::{ + DEFAULT_COEF_PROBS, DEFAULT_INTER_MODE_PROBS, DEFAULT_IS_INTER_PROB, DEFAULT_MV_BITS_PROB, DEFAULT_MV_CLASS_PROBS, DEFAULT_MV_CLASS0_BIT_PROB, + DEFAULT_MV_CLASS0_FR_PROBS, DEFAULT_MV_FR_PROBS, DEFAULT_MV_JOINT_PROBS, DEFAULT_MV_SIGN_PROB, DEFAULT_PARTITION_PROBS, DEFAULT_SINGLE_REF_PROB, + DEFAULT_SKIP_PROB, PARETO_TABLE, inv_map_table, +}; /// Coefficient probabilities `[ptype][ref][band][ctx][3]` for 4×4 transforms (band 0 uses /// contexts 0..3 only). diff --git a/crates/vp9enc/src/tables.rs b/crates/vp9enc/src/tables.rs index ffb266419..c70d7d8c2 100644 --- a/crates/vp9enc/src/tables.rs +++ b/crates/vp9enc/src/tables.rs @@ -2,8 +2,6 @@ //! transcribed in FilmCraft's first-party decoder `filmcraft-vp9` (MIT OR Apache-2.0, the same //! licence as this crate). -#![allow(clippy::unreadable_literal)] - pub const DC_QLOOKUP: [i32; 256] = [ 4, 8, 8, 9, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42, 43, 43, 44, 45, 46, 47, 48, 48, 49, 50, 51, 52, 53, 53, 54, 55, 56, 57, 57, 58, 59, 60, 61, 62, 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 70, 71, 72, diff --git a/crates/vp9enc/src/tile.rs b/crates/vp9enc/src/tile.rs index d7f6cb64f..1f0c37d80 100644 --- a/crates/vp9enc/src/tile.rs +++ b/crates/vp9enc/src/tile.rs @@ -8,7 +8,10 @@ use crate::mc::{Mv, PhasePlanes, RefPlane, clamp_for_plane, predict}; use crate::probs::{self, P, Writer, cost, tree_cost}; -use crate::tables::*; +use crate::tables::{ + COEFBAND_4X4, COL_SCAN_4X4, COUNTER_TO_CONTEXT, DEFAULT_SCAN_4X4, ENERGY_CLASS, KF_PARTITION_PROBS, KF_UV_MODE_PROBS, KF_Y_MODE_PROBS, MODE_2_COUNTER, + MV_REF_8X8, MV_REF_16X16, ROW_SCAN_4X4, +}; use crate::transform::{ADST_ADST, ADST_DCT, DCT_ADST, DCT_DCT, Quant}; use crate::{BLOCK_8X8, BLOCK_16X16, Mi, Plane}; @@ -22,6 +25,13 @@ pub const NEARMV: u8 = 11; pub const ZEROMV: u8 = 12; pub const NEWMV: u8 = 13; +/// Which reconstructed neighbours are available for intra prediction. +#[derive(Clone, Copy)] +struct IntraEdges { + left: bool, + above: bool, +} + const PARTITION_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3]; const INTRA_MODE_TREE: [i8; 18] = [0, 2, -9, 4, -1, 6, 8, 12, -2, 10, -4, -5, -3, 14, -8, 16, -6, -7]; /// Leaves are `mode - NEARESTMV`. @@ -104,7 +114,8 @@ fn levels_cost(levels: &[i32; 16], eob: usize) -> u32 { } /// Intra prediction (8.5.1) of a square block for DC / V / H / TM. -fn predict_intra(p: &Plane, x: usize, y: usize, log2: usize, mode: u8, have_left: bool, have_above: bool) -> [i32; 64] { +fn predict_intra(p: &Plane, x: usize, y: usize, log2: usize, mode: u8, edges: IntraEdges) -> [i32; 64] { + let IntraEdges { left: have_left, above: have_above } = edges; let size = 1usize << log2; let base = 128i32; let buf = &p.rec; @@ -356,11 +367,11 @@ impl<'a> Tile<'a> { fn intra_block(&mut self, r: usize, c: usize) { let avail_u = r > 0; let avail_l = c > self.col_start; - let y_mode = self.choose_intra(0, c * 8, r * 8, 3, avail_l, avail_u); + let y_mode = self.choose_intra(0, c * 8, r * 8, 3, IntraEdges { left: avail_l, above: avail_u }); let uv_mode = { let mut best = (i64::MAX, DC_PRED); for m in MODES { - let cost: i64 = (1..3).map(|p| self.intra_cost(p, c * 4, r * 4, 2, m, avail_l, avail_u)).sum(); + let cost: i64 = (1..3).map(|p| self.intra_cost(p, c * 4, r * 4, 2, m, IntraEdges { left: avail_l, above: avail_u })).sum(); if cost < best.0 { best = (cost, m); } @@ -379,17 +390,16 @@ impl<'a> Tile<'a> { // Residual: luma 2×2 transform blocks, then one 4×4 block per chroma plane. for (dy, dx) in [(0, 0), (0, 1), (1, 0), (1, 1)] { let tx = if self.f.quant.lossless { DCT_DCT } else { mode_tx_type(y_mode) }; - self.intra_tx(0, c * 8 + dx * 4, r * 8 + dy * 4, y_mode, tx, avail_l || dx > 0, avail_u || dy > 0); + self.intra_tx(0, c * 8 + dx * 4, r * 8 + dy * 4, y_mode, tx, IntraEdges { left: avail_l || dx > 0, above: avail_u || dy > 0 }); } for p in 1..3 { - self.intra_tx(p, c * 4, r * 4, uv_mode, DCT_DCT, avail_l, avail_u); + self.intra_tx(p, c * 4, r * 4, uv_mode, DCT_DCT, IntraEdges { left: avail_l, above: avail_u }); } } - #[allow(clippy::too_many_arguments)] - fn intra_cost(&self, plane: usize, x: usize, y: usize, log2: usize, mode: u8, have_left: bool, have_above: bool) -> i64 { + fn intra_cost(&self, plane: usize, x: usize, y: usize, log2: usize, mode: u8, edges: IntraEdges) -> i64 { let p = &self.planes[plane]; - let pred = predict_intra(p, x, y, log2, mode, have_left, have_above); + let pred = predict_intra(p, x, y, log2, mode, edges); let size = 1 << log2; let mut s = 0i64; for i in 0..size { @@ -400,10 +410,10 @@ impl<'a> Tile<'a> { s } - fn choose_intra(&self, plane: usize, x: usize, y: usize, log2: usize, have_left: bool, have_above: bool) -> u8 { + fn choose_intra(&self, plane: usize, x: usize, y: usize, log2: usize, edges: IntraEdges) -> u8 { let mut best = (i64::MAX, DC_PRED); for m in MODES { - let cost = self.intra_cost(plane, x, y, log2, m, have_left, have_above); + let cost = self.intra_cost(plane, x, y, log2, m, edges); if cost < best.0 { best = (cost, m); } @@ -411,8 +421,7 @@ impl<'a> Tile<'a> { best.1 } - #[allow(clippy::too_many_arguments)] - fn intra_tx(&mut self, plane: usize, x: usize, y: usize, mode: u8, tx_type: u8, have_left: bool, have_above: bool) { + fn intra_tx(&mut self, plane: usize, x: usize, y: usize, mode: u8, tx_type: u8, edges: IntraEdges) { let ss = (plane > 0) as usize; let max_x = (self.f.mi_cols * 8) >> ss; let max_y = (self.f.mi_rows * 8) >> ss; @@ -424,7 +433,7 @@ impl<'a> Tile<'a> { return; } let p = &self.planes[plane]; - let pred = predict_intra(p, x, y, 2, mode, have_left, have_above); + let pred = predict_intra(p, x, y, 2, mode, edges); let mut res = [0i32; 16]; for i in 0..4 { for j in 0..4 {