Skip to main content

threers_codec/vp9/
loopfilter.rs

1//! VP9 8-bit in-loop deblocking filter — a from-scratch port of libvpx
2//! v1.14.1's `vpx_dsp/loopfilter.c` (`filter4`/`filter8`/`filter16`,
3//! `vpx_lpf_*_c`) and `vp9/common/vp9_loopfilter.c` (`update_sharpness`,
4//! `vp9_loop_filter_frame_init`, `vp9_build_mask`, `vp9_adjust_mask`,
5//! `vp9_filter_block_plane_ss00`/`ss11`).
6//!
7//! This module intentionally supports a *reduced* surface compared to
8//! libvpx: no highbitdepth, no SIMD "dual" batching (the `_dual_c` reference
9//! functions are themselves just two calls to the non-dual function, so
10//! skipping them is bit-exact). Segmentation may alter per-block Q via
11//! `SEG_LVL_ALT_Q` in the encoder; the loop filter itself still uses the
12//! frame-level filter level with default mode/ref deltas (no `SEG_LVL_ALT_L`).
13//! Per-ref/mode filter levels are resolved by the caller into [`LfMi::level`].
14//! Square and rectangular coding blocks (8×8 through 64×64, including
15//! HORZ/VERT partitions) are handled via the full `BLOCK_SIZES` mask tables.
16//!
17//! Filtering order follows libvpx exactly: superblocks are visited in raster
18//! order, and within each 64×64 superblock the luma plane is filtered
19//! (vertical edges, then horizontal edges) before the two chroma planes —
20//! each of which is itself filtered vertical-then-horizontal. This ordering
21//! matters for bit-exactness because a superblock's left/top edges read
22//! pixels already rewritten by its already-processed neighbours.
23//!
24//! When mode/ref deltas are enabled (libvpx defaults after a keyframe), each
25//! MI's effective level is `clamp(base + ref_δ·scale + mode_δ·scale)` with
26//! `scale = 1 << (base >> 5)`. Pass the resolved level in [`LfMi::level`].
27
28/// Per-MI info needed for mask building.
29pub struct LfMi {
30    pub skip: bool,
31    pub is_inter: bool,
32    /// 0=4x4, 1=8x8, 2=16x16, 3=32x32.
33    pub tx_size_y: u8,
34    /// Block width/height in MI units (8×8).
35    pub bw_mi: u8,
36    pub bh_mi: u8,
37    /// `BLOCK_SIZES` index into the LF mask tables (3=8×8 … 12=64×64).
38    pub bsize_idx: usize,
39    /// True only for the top-left MI of a coding block.
40    pub block_origin: bool,
41    /// Effective loop-filter level for this MI (`0` skips filtering its edges).
42    pub level: u8,
43}
44
45/// Default `ref_deltas` after `vp9_setup_past_independence` / `set_default_lf_deltas`.
46/// Indexed by `INTRA_FRAME`..=`ALTREF_FRAME`.
47pub const DEFAULT_LF_REF_DELTAS: [i8; 4] = [1, 0, -1, -1];
48
49/// Default `mode_deltas`: `[ZEROMV, other inter]`.
50pub const DEFAULT_LF_MODE_DELTAS: [i8; 2] = [0, 0];
51
52/// `mode_lf_lut[mode]` — 0 for ZEROMV (and intra), 1 for other inter modes.
53pub fn mode_lf_delta_idx(mode: i8) -> usize {
54    match mode {
55        // NEARESTMV=10, NEARMV=11, ZEROMV=12, NEWMV=13
56        12 => 0, // ZEROMV
57        10 | 11 | 13 => 1,
58        _ => 0, // intra
59    }
60}
61
62/// Effective filter level for one MI (`vp9_loop_filter_frame_init` + `get_filter_level`).
63pub fn lf_level_for_mi(base: u8, ref_frame: i8, mode: i8) -> u8 {
64    if base == 0 {
65        return 0;
66    }
67    let scale = 1i32 << (base >> 5);
68    let rf = ref_frame.clamp(0, 3) as usize;
69    let md = mode_lf_delta_idx(mode);
70    let lvl = i32::from(base)
71        + i32::from(DEFAULT_LF_REF_DELTAS[rf]) * scale
72        + i32::from(DEFAULT_LF_MODE_DELTAS[md]) * scale;
73    lvl.clamp(0, 63) as u8
74}
75
76const MI_BLOCK_SIZE: usize = 8; // MI units (8x8 each) per 64x64 superblock side.
77const MAX_LOOP_FILTER: usize = 63;
78
79// ---------------------------------------------------------------------------
80// Sharpness -> per-level thresholds (vp9_loopfilter.c: update_sharpness,
81// vp9_loop_filter_init).
82// ---------------------------------------------------------------------------
83
84#[derive(Clone, Copy, Default)]
85struct LoopFilterThresh {
86    mblim: u8,
87    lim: u8,
88    hev_thr: u8,
89}
90
91fn build_thresholds(sharpness: u8) -> [LoopFilterThresh; MAX_LOOP_FILTER + 1] {
92    let mut out = [LoopFilterThresh::default(); MAX_LOOP_FILTER + 1];
93    let sharpness = sharpness as i32;
94    for lvl in 0..=MAX_LOOP_FILTER {
95        let lvl_i = lvl as i32;
96        let mut block_inside_limit = lvl_i >> ((sharpness > 0) as i32 + (sharpness > 4) as i32);
97        if sharpness > 0 && block_inside_limit > 9 - sharpness {
98            block_inside_limit = 9 - sharpness;
99        }
100        if block_inside_limit < 1 {
101            block_inside_limit = 1;
102        }
103        out[lvl].lim = block_inside_limit as u8;
104        out[lvl].mblim = (2 * (lvl_i + 2) + block_inside_limit) as u8;
105        out[lvl].hev_thr = (lvl_i >> 4) as u8;
106    }
107    out
108}
109
110// ---------------------------------------------------------------------------
111// Mask-building tables (vp9_loopfilter.c) — full `BLOCK_SIZES` (indices 0..=12).
112// We only emit blocks at indices 3..=12 (8×8 and up).
113// ---------------------------------------------------------------------------
114
115const LEFT_PRED_MASK_Y: [u64; 13] = [
116    0x0000_0000_0000_0001, // 4×4
117    0x0000_0000_0000_0001, // 4×8
118    0x0000_0000_0000_0001, // 8×4
119    0x0000_0000_0000_0001, // 8×8
120    0x0000_0000_0000_0101, // 8×16
121    0x0000_0000_0000_0001, // 16×8
122    0x0000_0000_0000_0101, // 16×16
123    0x0000_0000_0101_0101, // 16×32
124    0x0000_0000_0000_0101, // 32×16
125    0x0000_0000_0101_0101, // 32×32
126    0x0101_0101_0101_0101, // 32×64
127    0x0000_0000_0101_0101, // 64×32
128    0x0101_0101_0101_0101, // 64×64
129];
130const ABOVE_PRED_MASK_Y: [u64; 13] = [
131    0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x3, 0x3, 0xf, 0xf, 0xf, 0xff, 0xff,
132];
133const SIZE_MASK_Y: [u64; 13] = [
134    0x0000_0000_0000_0001,
135    0x0000_0000_0000_0001,
136    0x0000_0000_0000_0001,
137    0x0000_0000_0000_0001, // 8×8
138    0x0000_0000_0000_0101, // 8×16
139    0x0000_0000_0000_0003, // 16×8
140    0x0000_0000_0000_0303, // 16×16
141    0x0000_0000_0303_0303, // 16×32
142    0x0000_0000_0000_0f0f, // 32×16
143    0x0000_0000_0f0f_0f0f, // 32×32
144    0x0f0f_0f0f_0f0f_0f0f, // 32×64
145    0x0000_0000_ffff_ffff, // 64×32
146    0xffff_ffff_ffff_ffff, // 64×64
147];
148
149const LEFT_PRED_MASK_UV: [u16; 13] = [
150    0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0011, 0x0001, 0x0011, 0x1111, 0x0011,
151    0x1111,
152];
153const ABOVE_PRED_MASK_UV: [u16; 13] = [
154    0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0003, 0x0003, 0x0003, 0x000f,
155    0x000f,
156];
157const SIZE_MASK_UV: [u16; 13] = [
158    0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0011, 0x0003, 0x0033, 0x3333, 0x00ff,
159    0xffff,
160];
161
162// Indexed by TX_SIZE (0=4x4,1=8x8,2=16x16,3=32x32).
163const LEFT_TXFORM_MASK_Y: [u64; 4] = [
164    0xffff_ffff_ffff_ffff,
165    0xffff_ffff_ffff_ffff,
166    0x5555_5555_5555_5555,
167    0x1111_1111_1111_1111,
168];
169const ABOVE_TXFORM_MASK_Y: [u64; 4] = [
170    0xffff_ffff_ffff_ffff,
171    0xffff_ffff_ffff_ffff,
172    0x00ff_00ff_00ff_00ff,
173    0x0000_00ff_0000_00ff,
174];
175const LEFT_TXFORM_MASK_UV: [u16; 4] = [0xffff, 0xffff, 0x5555, 0x1111];
176const ABOVE_TXFORM_MASK_UV: [u16; 4] = [0xffff, 0xffff, 0x0f0f, 0x000f];
177
178const LEFT_BORDER_Y: u64 = 0x1111_1111_1111_1111;
179const ABOVE_BORDER_Y: u64 = 0x0000_00ff_0000_00ff;
180const LEFT_BORDER_UV: u16 = 0x1111;
181const ABOVE_BORDER_UV: u16 = 0x000f;
182
183/// `first_block_in_16x16[8][8]`: true where both `row` and `col` (mod 8) are even.
184#[inline]
185fn first_block_in_16x16(row_in_sb: usize, col_in_sb: usize) -> bool {
186    row_in_sb.is_multiple_of(2) && col_in_sb.is_multiple_of(2)
187}
188
189/// Per-superblock loop filter mask state (`LOOP_FILTER_MASK`).
190#[derive(Clone)]
191struct LoopFilterMask {
192    left_y: [u64; 4],
193    above_y: [u64; 4],
194    int_4x4_y: u64,
195    lfl_y: [u8; 64],
196    left_uv: [u16; 4],
197    above_uv: [u16; 4],
198    int_4x4_uv: u16,
199}
200
201impl Default for LoopFilterMask {
202    fn default() -> Self {
203        LoopFilterMask {
204            left_y: [0; 4],
205            above_y: [0; 4],
206            int_4x4_y: 0,
207            lfl_y: [0; 64],
208            left_uv: [0; 4],
209            above_uv: [0; 4],
210            int_4x4_uv: 0,
211        }
212    }
213}
214
215/// `vp9_build_mask` for any `BLOCK_SIZES` entry. `level == 0` skips the block.
216#[allow(clippy::too_many_arguments)]
217fn build_mask(
218    level: u8,
219    is_inter: bool,
220    skip: bool,
221    tx_size_y: u8,
222    bsize_idx: usize,
223    bw_mi: usize,
224    bh_mi: usize,
225    row_in_sb: usize,
226    col_in_sb: usize,
227    lfm: &mut LoopFilterMask,
228) {
229    if level == 0 {
230        return;
231    }
232    // TX UV capped by the shorter edge in MI units (≈ square log2).
233    let tx_cap = (bw_mi.min(bh_mi).trailing_zeros()) as u8;
234    let tx_size_uv = tx_size_y.min(tx_cap);
235
236    let shift_y = col_in_sb + (row_in_sb << 3);
237    let shift_uv = (col_in_sb >> 1) + ((row_in_sb >> 1) << 2);
238    let build_uv = first_block_in_16x16(row_in_sb, col_in_sb);
239
240    let mut index = shift_y;
241    for _ in 0..bh_mi {
242        for k in 0..bw_mi {
243            lfm.lfl_y[index + k] = level;
244        }
245        index += 8;
246    }
247
248    lfm.above_y[tx_size_y as usize] |= ABOVE_PRED_MASK_Y[bsize_idx] << shift_y;
249    lfm.left_y[tx_size_y as usize] |= LEFT_PRED_MASK_Y[bsize_idx] << shift_y;
250    if build_uv {
251        lfm.above_uv[tx_size_uv as usize] |= ABOVE_PRED_MASK_UV[bsize_idx] << shift_uv;
252        lfm.left_uv[tx_size_uv as usize] |= LEFT_PRED_MASK_UV[bsize_idx] << shift_uv;
253    }
254
255    if skip && is_inter {
256        return;
257    }
258
259    lfm.above_y[tx_size_y as usize] |=
260        (SIZE_MASK_Y[bsize_idx] & ABOVE_TXFORM_MASK_Y[tx_size_y as usize]) << shift_y;
261    lfm.left_y[tx_size_y as usize] |=
262        (SIZE_MASK_Y[bsize_idx] & LEFT_TXFORM_MASK_Y[tx_size_y as usize]) << shift_y;
263    if build_uv {
264        lfm.above_uv[tx_size_uv as usize] |=
265            (SIZE_MASK_UV[bsize_idx] & ABOVE_TXFORM_MASK_UV[tx_size_uv as usize]) << shift_uv;
266        lfm.left_uv[tx_size_uv as usize] |=
267            (SIZE_MASK_UV[bsize_idx] & LEFT_TXFORM_MASK_UV[tx_size_uv as usize]) << shift_uv;
268    }
269
270    if tx_size_y == 0 {
271        lfm.int_4x4_y |= SIZE_MASK_Y[bsize_idx] << shift_y;
272    }
273    if build_uv && tx_size_uv == 0 {
274        lfm.int_4x4_uv |= SIZE_MASK_UV[bsize_idx] << shift_uv;
275    }
276}
277
278/// `vp9_adjust_mask`.
279fn adjust_mask(
280    mi_rows: usize,
281    mi_cols: usize,
282    sb_row: usize,
283    sb_col: usize,
284    lfm: &mut LoopFilterMask,
285) {
286    lfm.left_y[2] |= lfm.left_y[3];
287    lfm.above_y[2] |= lfm.above_y[3];
288    lfm.left_uv[2] |= lfm.left_uv[3];
289    lfm.above_uv[2] |= lfm.above_uv[3];
290
291    lfm.left_y[1] |= lfm.left_y[0] & LEFT_BORDER_Y;
292    lfm.left_y[0] &= !LEFT_BORDER_Y;
293    lfm.above_y[1] |= lfm.above_y[0] & ABOVE_BORDER_Y;
294    lfm.above_y[0] &= !ABOVE_BORDER_Y;
295    lfm.left_uv[1] |= lfm.left_uv[0] & LEFT_BORDER_UV;
296    lfm.left_uv[0] &= !LEFT_BORDER_UV;
297    lfm.above_uv[1] |= lfm.above_uv[0] & ABOVE_BORDER_UV;
298    lfm.above_uv[0] &= !ABOVE_BORDER_UV;
299
300    if sb_row + MI_BLOCK_SIZE > mi_rows {
301        let rows = (mi_rows - sb_row) as u32;
302        let mask_y: u64 = (1u64 << (rows * 8)) - 1;
303        let mask_uv: u16 = (((1u32 << (((rows + 1) >> 1) * 4)) - 1) & 0xffff) as u16;
304
305        for i in 0..3 {
306            lfm.left_y[i] &= mask_y;
307            lfm.above_y[i] &= mask_y;
308            lfm.left_uv[i] &= mask_uv;
309            lfm.above_uv[i] &= mask_uv;
310        }
311        lfm.int_4x4_y &= mask_y;
312        lfm.int_4x4_uv &= mask_uv;
313
314        if rows == 1 {
315            lfm.above_uv[1] |= lfm.above_uv[2];
316            lfm.above_uv[2] = 0;
317        }
318        if rows == 5 {
319            lfm.above_uv[1] |= lfm.above_uv[2] & 0xff00;
320            lfm.above_uv[2] &= !0xff00u16;
321        }
322    }
323
324    if sb_col + MI_BLOCK_SIZE > mi_cols {
325        let columns = (mi_cols - sb_col) as u32;
326        let mask_y: u64 = ((1u64 << columns) - 1).wrapping_mul(0x0101_0101_0101_0101);
327        let mask_uv: u16 =
328            (((1u32 << ((columns + 1) >> 1)) - 1).wrapping_mul(0x1111) & 0xffff) as u16;
329        let mask_uv_int: u16 =
330            (((1u32 << (columns >> 1)) - 1).wrapping_mul(0x1111) & 0xffff) as u16;
331
332        for i in 0..3 {
333            lfm.left_y[i] &= mask_y;
334            lfm.above_y[i] &= mask_y;
335            lfm.left_uv[i] &= mask_uv;
336            lfm.above_uv[i] &= mask_uv;
337        }
338        lfm.int_4x4_y &= mask_y;
339        lfm.int_4x4_uv &= mask_uv_int;
340
341        if columns == 1 {
342            lfm.left_uv[1] |= lfm.left_uv[2];
343            lfm.left_uv[2] = 0;
344        }
345        if columns == 5 {
346            lfm.left_uv[1] |= lfm.left_uv[2] & 0xcccc;
347            lfm.left_uv[2] &= !0xccccu16;
348        }
349    }
350
351    if sb_col == 0 {
352        for i in 0..3 {
353            lfm.left_y[i] &= 0xfefe_fefe_fefe_fefe;
354            lfm.left_uv[i] &= 0xeeee;
355        }
356    }
357}
358
359// ---------------------------------------------------------------------------
360// Core pixel filters (vpx_dsp/loopfilter.c: filter4/filter8/filter16).
361// ---------------------------------------------------------------------------
362
363#[inline]
364fn signed_char_clamp(t: i32) -> i32 {
365    t.clamp(-128, 127)
366}
367
368#[inline]
369fn round_pow2_i(v: i32, n: u32) -> i32 {
370    (v + (1 << (n - 1))) >> n
371}
372
373#[inline]
374fn round_pow2_u(v: u32, n: u32) -> u32 {
375    (v + (1 << (n - 1))) >> n
376}
377
378#[inline]
379fn filter_mask(
380    limit: u8,
381    blimit: u8,
382    p3: u8,
383    p2: u8,
384    p1: u8,
385    p0: u8,
386    q0: u8,
387    q1: u8,
388    q2: u8,
389    q3: u8,
390) -> bool {
391    let limit = limit as i32;
392    let blimit = blimit as i32;
393    let d = |a: u8, b: u8| (a as i32 - b as i32).abs();
394    d(p3, p2) <= limit
395        && d(p2, p1) <= limit
396        && d(p1, p0) <= limit
397        && d(q1, q0) <= limit
398        && d(q2, q1) <= limit
399        && d(q3, q2) <= limit
400        && d(p0, q0) * 2 + d(p1, q1) / 2 <= blimit
401}
402
403#[inline]
404fn flat_mask4(thresh: u8, p3: u8, p2: u8, p1: u8, p0: u8, q0: u8, q1: u8, q2: u8, q3: u8) -> bool {
405    let thresh = thresh as i32;
406    let d = |a: u8, b: u8| (a as i32 - b as i32).abs();
407    d(p1, p0) <= thresh
408        && d(q1, q0) <= thresh
409        && d(p2, p0) <= thresh
410        && d(q2, q0) <= thresh
411        && d(p3, p0) <= thresh
412        && d(q3, q0) <= thresh
413}
414
415#[inline]
416#[allow(clippy::too_many_arguments)]
417fn flat_mask5(
418    thresh: u8,
419    p4: u8,
420    p3: u8,
421    p2: u8,
422    p1: u8,
423    p0: u8,
424    q0: u8,
425    q1: u8,
426    q2: u8,
427    q3: u8,
428    q4: u8,
429) -> bool {
430    let thresh_i = thresh as i32;
431    flat_mask4(thresh, p3, p2, p1, p0, q0, q1, q2, q3)
432        && (p4 as i32 - p0 as i32).abs() <= thresh_i
433        && (q4 as i32 - q0 as i32).abs() <= thresh_i
434}
435
436#[inline]
437fn hev_mask(thresh: u8, p1: u8, p0: u8, q0: u8, q1: u8) -> bool {
438    let thresh = thresh as i32;
439    (p1 as i32 - p0 as i32).abs() > thresh || (q1 as i32 - q0 as i32).abs() > thresh
440}
441
442/// `filter4`.
443fn filter4(mask: bool, thresh: u8, buf: &mut [u8], op1: usize, op0: usize, oq0: usize, oq1: usize) {
444    let (p1, p0, q0, q1) = (buf[op1], buf[op0], buf[oq0], buf[oq1]);
445    let (ps1, ps0, qs0, qs1) = (
446        p1 as i32 - 128,
447        p0 as i32 - 128,
448        q0 as i32 - 128,
449        q1 as i32 - 128,
450    );
451    let hev = hev_mask(thresh, p1, p0, q0, q1);
452
453    let mut filter = signed_char_clamp(ps1 - qs1);
454    filter = if hev { filter } else { 0 };
455
456    filter = signed_char_clamp(filter + 3 * (qs0 - ps0));
457    filter = if mask { filter } else { 0 };
458
459    let filter1 = signed_char_clamp(filter + 4) >> 3;
460    let filter2 = signed_char_clamp(filter + 3) >> 3;
461
462    buf[oq0] = (signed_char_clamp(qs0 - filter1) + 128) as u8;
463    buf[op0] = (signed_char_clamp(ps0 + filter2) + 128) as u8;
464
465    let outer = round_pow2_i(filter1, 1);
466    let outer = if hev { 0 } else { outer };
467
468    buf[oq1] = (signed_char_clamp(qs1 - outer) + 128) as u8;
469    buf[op1] = (signed_char_clamp(ps1 + outer) + 128) as u8;
470}
471
472/// `filter8`.
473#[allow(clippy::too_many_arguments)]
474fn filter8(
475    mask: bool,
476    thresh: u8,
477    flat: bool,
478    buf: &mut [u8],
479    op3: usize,
480    op2: usize,
481    op1: usize,
482    op0: usize,
483    oq0: usize,
484    oq1: usize,
485    oq2: usize,
486    oq3: usize,
487) {
488    if flat && mask {
489        let p3 = buf[op3] as u32;
490        let p2 = buf[op2] as u32;
491        let p1 = buf[op1] as u32;
492        let p0 = buf[op0] as u32;
493        let q0 = buf[oq0] as u32;
494        let q1 = buf[oq1] as u32;
495        let q2 = buf[oq2] as u32;
496        let q3 = buf[oq3] as u32;
497
498        buf[op2] = round_pow2_u(p3 + p3 + p3 + 2 * p2 + p1 + p0 + q0, 3) as u8;
499        buf[op1] = round_pow2_u(p3 + p3 + p2 + 2 * p1 + p0 + q0 + q1, 3) as u8;
500        buf[op0] = round_pow2_u(p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2, 3) as u8;
501        buf[oq0] = round_pow2_u(p2 + p1 + p0 + 2 * q0 + q1 + q2 + q3, 3) as u8;
502        buf[oq1] = round_pow2_u(p1 + p0 + q0 + 2 * q1 + q2 + q3 + q3, 3) as u8;
503        buf[oq2] = round_pow2_u(p0 + q0 + q1 + 2 * q2 + q3 + q3 + q3, 3) as u8;
504    } else {
505        filter4(mask, thresh, buf, op1, op0, oq0, oq1);
506    }
507}
508
509/// `filter16`.
510#[allow(clippy::too_many_arguments)]
511fn filter16(
512    mask: bool,
513    thresh: u8,
514    flat: bool,
515    flat2: bool,
516    buf: &mut [u8],
517    idx: [usize; 16], // op7,op6,op5,op4,op3,op2,op1,op0,oq0,oq1,oq2,oq3,oq4,oq5,oq6,oq7
518) {
519    let [op7, op6, op5, op4, op3, op2, op1, op0, oq0, oq1, oq2, oq3, oq4, oq5, oq6, oq7] = idx;
520    if flat2 && flat && mask {
521        let p7 = buf[op7] as u32;
522        let p6 = buf[op6] as u32;
523        let p5 = buf[op5] as u32;
524        let p4 = buf[op4] as u32;
525        let p3 = buf[op3] as u32;
526        let p2 = buf[op2] as u32;
527        let p1 = buf[op1] as u32;
528        let p0 = buf[op0] as u32;
529        let q0 = buf[oq0] as u32;
530        let q1 = buf[oq1] as u32;
531        let q2 = buf[oq2] as u32;
532        let q3 = buf[oq3] as u32;
533        let q4 = buf[oq4] as u32;
534        let q5 = buf[oq5] as u32;
535        let q6 = buf[oq6] as u32;
536        let q7 = buf[oq7] as u32;
537
538        buf[op6] = round_pow2_u(p7 * 7 + p6 * 2 + p5 + p4 + p3 + p2 + p1 + p0 + q0, 4) as u8;
539        buf[op5] = round_pow2_u(p7 * 6 + p6 + p5 * 2 + p4 + p3 + p2 + p1 + p0 + q0 + q1, 4) as u8;
540        buf[op4] = round_pow2_u(
541            p7 * 5 + p6 + p5 + p4 * 2 + p3 + p2 + p1 + p0 + q0 + q1 + q2,
542            4,
543        ) as u8;
544        buf[op3] = round_pow2_u(
545            p7 * 4 + p6 + p5 + p4 + p3 * 2 + p2 + p1 + p0 + q0 + q1 + q2 + q3,
546            4,
547        ) as u8;
548        buf[op2] = round_pow2_u(
549            p7 * 3 + p6 + p5 + p4 + p3 + p2 * 2 + p1 + p0 + q0 + q1 + q2 + q3 + q4,
550            4,
551        ) as u8;
552        buf[op1] = round_pow2_u(
553            p7 * 2 + p6 + p5 + p4 + p3 + p2 + p1 * 2 + p0 + q0 + q1 + q2 + q3 + q4 + q5,
554            4,
555        ) as u8;
556        buf[op0] = round_pow2_u(
557            p7 + p6 + p5 + p4 + p3 + p2 + p1 + p0 * 2 + q0 + q1 + q2 + q3 + q4 + q5 + q6,
558            4,
559        ) as u8;
560        buf[oq0] = round_pow2_u(
561            p6 + p5 + p4 + p3 + p2 + p1 + p0 + q0 * 2 + q1 + q2 + q3 + q4 + q5 + q6 + q7,
562            4,
563        ) as u8;
564        buf[oq1] = round_pow2_u(
565            p5 + p4 + p3 + p2 + p1 + p0 + q0 + q1 * 2 + q2 + q3 + q4 + q5 + q6 + q7 * 2,
566            4,
567        ) as u8;
568        buf[oq2] = round_pow2_u(
569            p4 + p3 + p2 + p1 + p0 + q0 + q1 + q2 * 2 + q3 + q4 + q5 + q6 + q7 * 3,
570            4,
571        ) as u8;
572        buf[oq3] = round_pow2_u(
573            p3 + p2 + p1 + p0 + q0 + q1 + q2 + q3 * 2 + q4 + q5 + q6 + q7 * 4,
574            4,
575        ) as u8;
576        buf[oq4] = round_pow2_u(
577            p2 + p1 + p0 + q0 + q1 + q2 + q3 + q4 * 2 + q5 + q6 + q7 * 5,
578            4,
579        ) as u8;
580        buf[oq5] = round_pow2_u(p1 + p0 + q0 + q1 + q2 + q3 + q4 + q5 * 2 + q6 + q7 * 6, 4) as u8;
581        buf[oq6] = round_pow2_u(p0 + q0 + q1 + q2 + q3 + q4 + q5 + q6 * 2 + q7 * 7, 4) as u8;
582    } else {
583        filter8(
584            mask, thresh, flat, buf, op3, op2, op1, op0, oq0, oq1, oq2, oq3,
585        );
586    }
587}
588
589// ---------------------------------------------------------------------------
590// Edge sweeps (`vpx_lpf_{vertical,horizontal}_{4,8,16}_c`), non-dual only.
591// `pos` is the index of `q0` (first sample past the edge). `pitch` is the
592// step to walk from `q0` to `q1` (1 for a vertical edge, `stride` for a
593// horizontal edge); the sweep itself always advances by `stride` for
594// vertical edges (down the column) or by `1` for horizontal edges (across
595// the row), matching the C reference's inner loops.
596// ---------------------------------------------------------------------------
597
598fn lpf_vertical_4(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
599    for i in 0..8 {
600        let s = pos + i * stride;
601        let (p3, p2, p1, p0) = (buf[s - 4], buf[s - 3], buf[s - 2], buf[s - 1]);
602        let (q0, q1, q2, q3) = (buf[s], buf[s + 1], buf[s + 2], buf[s + 3]);
603        let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
604        filter4(mask, thresh, buf, s - 2, s - 1, s, s + 1);
605    }
606}
607
608fn lpf_vertical_8(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
609    for i in 0..8 {
610        let s = pos + i * stride;
611        let (p3, p2, p1, p0) = (buf[s - 4], buf[s - 3], buf[s - 2], buf[s - 1]);
612        let (q0, q1, q2, q3) = (buf[s], buf[s + 1], buf[s + 2], buf[s + 3]);
613        let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
614        let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
615        filter8(
616            mask,
617            thresh,
618            flat,
619            buf,
620            s - 4,
621            s - 3,
622            s - 2,
623            s - 1,
624            s,
625            s + 1,
626            s + 2,
627            s + 3,
628        );
629    }
630}
631
632fn lpf_vertical_16(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
633    for i in 0..8 {
634        let s = pos + i * stride;
635        let (p3, p2, p1, p0) = (buf[s - 4], buf[s - 3], buf[s - 2], buf[s - 1]);
636        let (q0, q1, q2, q3) = (buf[s], buf[s + 1], buf[s + 2], buf[s + 3]);
637        let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
638        let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
639        let flat2 = flat_mask5(
640            1,
641            buf[s - 8],
642            buf[s - 7],
643            buf[s - 6],
644            buf[s - 5],
645            p0,
646            q0,
647            buf[s + 4],
648            buf[s + 5],
649            buf[s + 6],
650            buf[s + 7],
651        );
652        filter16(
653            mask,
654            thresh,
655            flat,
656            flat2,
657            buf,
658            [
659                s - 8,
660                s - 7,
661                s - 6,
662                s - 5,
663                s - 4,
664                s - 3,
665                s - 2,
666                s - 1,
667                s,
668                s + 1,
669                s + 2,
670                s + 3,
671                s + 4,
672                s + 5,
673                s + 6,
674                s + 7,
675            ],
676        );
677    }
678}
679
680fn lpf_horizontal_4(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
681    for i in 0..8 {
682        let s = pos + i;
683        let (p3, p2, p1, p0) = (
684            buf[s - 4 * stride],
685            buf[s - 3 * stride],
686            buf[s - 2 * stride],
687            buf[s - stride],
688        );
689        let (q0, q1, q2, q3) = (
690            buf[s],
691            buf[s + stride],
692            buf[s + 2 * stride],
693            buf[s + 3 * stride],
694        );
695        let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
696        filter4(mask, thresh, buf, s - 2 * stride, s - stride, s, s + stride);
697    }
698}
699
700fn lpf_horizontal_8(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
701    for i in 0..8 {
702        let s = pos + i;
703        let (p3, p2, p1, p0) = (
704            buf[s - 4 * stride],
705            buf[s - 3 * stride],
706            buf[s - 2 * stride],
707            buf[s - stride],
708        );
709        let (q0, q1, q2, q3) = (
710            buf[s],
711            buf[s + stride],
712            buf[s + 2 * stride],
713            buf[s + 3 * stride],
714        );
715        let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
716        let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
717        filter8(
718            mask,
719            thresh,
720            flat,
721            buf,
722            s - 4 * stride,
723            s - 3 * stride,
724            s - 2 * stride,
725            s - stride,
726            s,
727            s + stride,
728            s + 2 * stride,
729            s + 3 * stride,
730        );
731    }
732}
733
734fn lpf_horizontal_16(buf: &mut [u8], stride: usize, pos: usize, blimit: u8, limit: u8, thresh: u8) {
735    for i in 0..8 {
736        let s = pos + i;
737        let (p3, p2, p1, p0) = (
738            buf[s - 4 * stride],
739            buf[s - 3 * stride],
740            buf[s - 2 * stride],
741            buf[s - stride],
742        );
743        let (q0, q1, q2, q3) = (
744            buf[s],
745            buf[s + stride],
746            buf[s + 2 * stride],
747            buf[s + 3 * stride],
748        );
749        let mask = filter_mask(limit, blimit, p3, p2, p1, p0, q0, q1, q2, q3);
750        let flat = flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3);
751        let flat2 = flat_mask5(
752            1,
753            buf[s - 8 * stride],
754            buf[s - 7 * stride],
755            buf[s - 6 * stride],
756            buf[s - 5 * stride],
757            p0,
758            q0,
759            buf[s + 4 * stride],
760            buf[s + 5 * stride],
761            buf[s + 6 * stride],
762            buf[s + 7 * stride],
763        );
764        filter16(
765            mask,
766            thresh,
767            flat,
768            flat2,
769            buf,
770            [
771                s - 8 * stride,
772                s - 7 * stride,
773                s - 6 * stride,
774                s - 5 * stride,
775                s - 4 * stride,
776                s - 3 * stride,
777                s - 2 * stride,
778                s - stride,
779                s,
780                s + stride,
781                s + 2 * stride,
782                s + 3 * stride,
783                s + 4 * stride,
784                s + 5 * stride,
785                s + 6 * stride,
786                s + 7 * stride,
787            ],
788        );
789    }
790}
791
792// ---------------------------------------------------------------------------
793// Per-row-band mask application (`filter_selectively_vert`/`_horiz`,
794// non-dual). `num_cols` is 8 for luma, 4 for 4:2:0 chroma; each mask bit
795// covers one 8-pixel-wide column within the band.
796// ---------------------------------------------------------------------------
797
798#[allow(clippy::too_many_arguments)]
799fn filter_selectively_vert(
800    buf: &mut [u8],
801    stride: usize,
802    pos: usize,
803    mask16: u32,
804    mask8: u32,
805    mask4: u32,
806    mask4i: u32,
807    thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
808    lfl: &[u8],
809    num_cols: usize,
810) {
811    let (mut m16, mut m8, mut m4, mut m4i) = (mask16, mask8, mask4, mask4i);
812    for c in 0..num_cols {
813        let p = pos + c * 8;
814        let t = &thr[lfl[c] as usize];
815        if m16 & 1 != 0 {
816            lpf_vertical_16(buf, stride, p, t.mblim, t.lim, t.hev_thr);
817        } else if m8 & 1 != 0 {
818            lpf_vertical_8(buf, stride, p, t.mblim, t.lim, t.hev_thr);
819        } else if m4 & 1 != 0 {
820            lpf_vertical_4(buf, stride, p, t.mblim, t.lim, t.hev_thr);
821        }
822        if m4i & 1 != 0 {
823            lpf_vertical_4(buf, stride, p + 4, t.mblim, t.lim, t.hev_thr);
824        }
825        m16 >>= 1;
826        m8 >>= 1;
827        m4 >>= 1;
828        m4i >>= 1;
829    }
830}
831
832#[allow(clippy::too_many_arguments)]
833fn filter_selectively_horiz(
834    buf: &mut [u8],
835    stride: usize,
836    pos: usize,
837    mask16: u32,
838    mask8: u32,
839    mask4: u32,
840    mask4i: u32,
841    thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
842    lfl: &[u8],
843    num_cols: usize,
844) {
845    let (mut m16, mut m8, mut m4, mut m4i) = (mask16, mask8, mask4, mask4i);
846    for c in 0..num_cols {
847        let p = pos + c * 8;
848        let t = &thr[lfl[c] as usize];
849        if m16 & 1 != 0 {
850            lpf_horizontal_16(buf, stride, p, t.mblim, t.lim, t.hev_thr);
851        } else if m8 & 1 != 0 {
852            lpf_horizontal_8(buf, stride, p, t.mblim, t.lim, t.hev_thr);
853        } else if m4 & 1 != 0 {
854            lpf_horizontal_4(buf, stride, p, t.mblim, t.lim, t.hev_thr);
855        }
856        if m4i & 1 != 0 {
857            lpf_horizontal_4(buf, stride, p + 4 * stride, t.mblim, t.lim, t.hev_thr);
858        }
859        m16 >>= 1;
860        m8 >>= 1;
861        m4 >>= 1;
862        m4i >>= 1;
863    }
864}
865
866// ---------------------------------------------------------------------------
867// Plane filtering (`vp9_filter_block_plane_ss00`/`ss11`).
868// ---------------------------------------------------------------------------
869
870/// Luma (no subsampling): `vp9_filter_block_plane_ss00`.
871fn filter_plane_ss00(
872    buf: &mut [u8],
873    stride: usize,
874    base: usize,
875    sb_row: usize,
876    mi_rows: usize,
877    lfm: &LoopFilterMask,
878    thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
879) {
880    for r in 0..MI_BLOCK_SIZE {
881        if sb_row + r >= mi_rows {
882            break;
883        }
884        let m16 = ((lfm.left_y[2] >> (r * 8)) & 0xff) as u32;
885        let m8 = ((lfm.left_y[1] >> (r * 8)) & 0xff) as u32;
886        let m4 = ((lfm.left_y[0] >> (r * 8)) & 0xff) as u32;
887        let m4i = ((lfm.int_4x4_y >> (r * 8)) & 0xff) as u32;
888        let pos = base + r * 8 * stride;
889        filter_selectively_vert(
890            buf,
891            stride,
892            pos,
893            m16,
894            m8,
895            m4,
896            m4i,
897            thr,
898            &lfm.lfl_y[r * 8..r * 8 + 8],
899            8,
900        );
901    }
902
903    for r in 0..MI_BLOCK_SIZE {
904        if sb_row + r >= mi_rows {
905            break;
906        }
907        let (m16, m8, m4) = if sb_row + r == 0 {
908            (0, 0, 0)
909        } else {
910            (
911                ((lfm.above_y[2] >> (r * 8)) & 0xff) as u32,
912                ((lfm.above_y[1] >> (r * 8)) & 0xff) as u32,
913                ((lfm.above_y[0] >> (r * 8)) & 0xff) as u32,
914            )
915        };
916        let m4i = ((lfm.int_4x4_y >> (r * 8)) & 0xff) as u32;
917        let pos = base + r * 8 * stride;
918        filter_selectively_horiz(
919            buf,
920            stride,
921            pos,
922            m16,
923            m8,
924            m4,
925            m4i,
926            thr,
927            &lfm.lfl_y[r * 8..r * 8 + 8],
928            8,
929        );
930    }
931}
932
933/// 4:2:0 chroma: `vp9_filter_block_plane_ss11`.
934fn filter_plane_ss11(
935    buf: &mut [u8],
936    stride: usize,
937    base: usize,
938    sb_row: usize,
939    mi_rows: usize,
940    lfm: &LoopFilterMask,
941    thr: &[LoopFilterThresh; MAX_LOOP_FILTER + 1],
942) {
943    for r_uv in 0..4 {
944        let mi_r = r_uv * 2;
945        if sb_row + mi_r >= mi_rows {
946            break;
947        }
948        let m16 = ((lfm.left_uv[2] >> (r_uv * 4)) & 0xf) as u32;
949        let m8 = ((lfm.left_uv[1] >> (r_uv * 4)) & 0xf) as u32;
950        let m4 = ((lfm.left_uv[0] >> (r_uv * 4)) & 0xf) as u32;
951        let m4i = ((lfm.int_4x4_uv >> (r_uv * 4)) & 0xf) as u32;
952        let mut lfl_uv = [0u8; 4];
953        for c in 0..4 {
954            lfl_uv[c] = lfm.lfl_y[mi_r * 8 + c * 2];
955        }
956        let pos = base + r_uv * 8 * stride;
957        filter_selectively_vert(buf, stride, pos, m16, m8, m4, m4i, thr, &lfl_uv, 4);
958    }
959
960    for r_uv in 0..4 {
961        let mi_r = r_uv * 2;
962        if sb_row + mi_r >= mi_rows {
963            break;
964        }
965        let skip_border = sb_row + mi_r == mi_rows - 1;
966        let m4i_full = ((lfm.int_4x4_uv >> (r_uv * 4)) & 0xf) as u32;
967        let m4i = if skip_border { 0 } else { m4i_full };
968        let (m16, m8, m4) = if sb_row + mi_r == 0 {
969            (0, 0, 0)
970        } else {
971            (
972                ((lfm.above_uv[2] >> (r_uv * 4)) & 0xf) as u32,
973                ((lfm.above_uv[1] >> (r_uv * 4)) & 0xf) as u32,
974                ((lfm.above_uv[0] >> (r_uv * 4)) & 0xf) as u32,
975            )
976        };
977        let mut lfl_uv = [0u8; 4];
978        for c in 0..4 {
979            lfl_uv[c] = lfm.lfl_y[mi_r * 8 + c * 2];
980        }
981        let pos = base + r_uv * 8 * stride;
982        filter_selectively_horiz(buf, stride, pos, m16, m8, m4, m4i, thr, &lfl_uv, 4);
983    }
984}
985
986// ---------------------------------------------------------------------------
987// Public entry point.
988// ---------------------------------------------------------------------------
989
990/// Apply in-loop deblocking to a YUV420 frame in place.
991///
992/// `mi` is row-major, length `mi_rows * mi_cols`, one entry per 8×8 MI.
993///
994/// Like libvpx, this filters whole 64×64 superblocks, so the very last
995/// (possibly partial) superblock in each row/column is still filtered up to
996/// its full 64×64/32×32 (luma/chroma) extent even if `mi_rows`/`mi_cols` end
997/// mid-superblock — mirroring how VP9 always reconstructs full superblocks
998/// and only crops to the visible frame for display. Callers must therefore
999/// pad `y`/`u`/`v` (and their strides) up to the next multiple of 64 luma /
1000/// 32 chroma pixels in both dimensions, not just to `mi_rows*8`/`mi_cols*8`.
1001///
1002/// `filter_level` is the frame base level in `0..=63` (`0` is a no-op for the
1003/// whole frame). Per-MI strength comes from [`LfMi::level`] (already including
1004/// mode/ref deltas). `sharpness` in `0..=7`.
1005pub fn loop_filter_frame(
1006    y: &mut [u8],
1007    y_stride: usize,
1008    u: &mut [u8],
1009    v: &mut [u8],
1010    uv_stride: usize,
1011    _width: usize,
1012    _height: usize,
1013    mi: &[LfMi],
1014    mi_rows: usize,
1015    mi_cols: usize,
1016    filter_level: u8,
1017    sharpness: u8,
1018) {
1019    if filter_level == 0 || mi_rows == 0 || mi_cols == 0 {
1020        return;
1021    }
1022    debug_assert_eq!(mi.len(), mi_rows * mi_cols);
1023
1024    let thresholds = build_thresholds(sharpness);
1025
1026    let mut sb_row = 0;
1027    while sb_row < mi_rows {
1028        let mut sb_col = 0;
1029        while sb_col < mi_cols {
1030            let mut lfm = LoopFilterMask::default();
1031
1032            for r in 0..MI_BLOCK_SIZE {
1033                let row = sb_row + r;
1034                if row >= mi_rows {
1035                    break;
1036                }
1037                for c in 0..MI_BLOCK_SIZE {
1038                    let col = sb_col + c;
1039                    if col >= mi_cols {
1040                        break;
1041                    }
1042                    let m = &mi[row * mi_cols + col];
1043                    if !m.block_origin {
1044                        continue;
1045                    }
1046                    build_mask(
1047                        m.level,
1048                        m.is_inter,
1049                        m.skip,
1050                        m.tx_size_y,
1051                        m.bsize_idx,
1052                        m.bw_mi as usize,
1053                        m.bh_mi as usize,
1054                        r,
1055                        c,
1056                        &mut lfm,
1057                    );
1058                }
1059            }
1060
1061            adjust_mask(mi_rows, mi_cols, sb_row, sb_col, &mut lfm);
1062
1063            let y_base = sb_row * 8 * y_stride + sb_col * 8;
1064            filter_plane_ss00(y, y_stride, y_base, sb_row, mi_rows, &lfm, &thresholds);
1065
1066            let uv_base = sb_row * 4 * uv_stride + sb_col * 4;
1067            filter_plane_ss11(u, uv_stride, uv_base, sb_row, mi_rows, &lfm, &thresholds);
1068            filter_plane_ss11(v, uv_stride, uv_base, sb_row, mi_rows, &lfm, &thresholds);
1069
1070            sb_col += MI_BLOCK_SIZE;
1071        }
1072        sb_row += MI_BLOCK_SIZE;
1073    }
1074}
1075
1076#[cfg(test)]
1077mod tests {
1078    use super::*;
1079
1080    /// Buffers are padded to the enclosing 64x64-superblock grid, per
1081    /// [`loop_filter_frame`]'s buffer contract; `w`/`h` here are that padded
1082    /// (superblock-aligned) size.
1083    fn make_step_frame(w: usize, h: usize) -> (Vec<u8>, usize) {
1084        let stride = w;
1085        let mut y = vec![0u8; stride * h];
1086        for row in 0..h {
1087            for col in 0..w {
1088                y[row * stride + col] = if col < w / 2 { 100 } else { 150 };
1089            }
1090        }
1091        (y, stride)
1092    }
1093
1094    fn flat_mi(mi_rows: usize, mi_cols: usize, level: u8) -> Vec<LfMi> {
1095        (0..mi_rows * mi_cols)
1096            .map(|_| LfMi {
1097                skip: false,
1098                is_inter: false,
1099                tx_size_y: 0,
1100                bw_mi: 1,
1101                bh_mi: 1,
1102                bsize_idx: 3,       // BLOCK_8X8
1103                block_origin: true, // every 8×8 is its own block
1104                level,
1105            })
1106            .collect()
1107    }
1108
1109    fn sb_align(n: usize) -> usize {
1110        n.div_ceil(64) * 64
1111    }
1112
1113    #[test]
1114    fn filter_level_zero_is_noop() {
1115        let (w, h) = (64, 64);
1116        let (mut y, y_stride) = make_step_frame(w, h);
1117        let y_orig = y.clone();
1118        let mut u = vec![128u8; (w / 2) * (h / 2)];
1119        let mut v = vec![128u8; (w / 2) * (h / 2)];
1120        let uv_stride = w / 2;
1121        let mi_rows = h / 8;
1122        let mi_cols = w / 8;
1123        let mi = flat_mi(mi_rows, mi_cols, 10);
1124
1125        loop_filter_frame(
1126            &mut y, y_stride, &mut u, &mut v, uv_stride, w, h, &mi, mi_rows, mi_cols, 0, 0,
1127        );
1128
1129        assert_eq!(y, y_orig, "filter_level=0 must not modify the luma plane");
1130    }
1131
1132    #[test]
1133    fn synthetic_edge_is_modified_when_level_positive() {
1134        let (w, h) = (64, 64);
1135        let (mut y, y_stride) = make_step_frame(w, h);
1136        let y_orig = y.clone();
1137        let mut u = vec![128u8; (w / 2) * (h / 2)];
1138        let mut v = vec![128u8; (w / 2) * (h / 2)];
1139        let uv_stride = w / 2;
1140        let mi_rows = h / 8;
1141        let mi_cols = w / 8;
1142        let mi = flat_mi(mi_rows, mi_cols, 63);
1143
1144        loop_filter_frame(
1145            &mut y, y_stride, &mut u, &mut v, uv_stride, w, h, &mi, mi_rows, mi_cols, 63, 0,
1146        );
1147
1148        assert_ne!(
1149            y, y_orig,
1150            "filter_level>0 should modify pixels near the synthetic edge"
1151        );
1152
1153        // Columns 0 and w-1 sit on the frame border and are excluded by the
1154        // "no filtering on the outermost edge" rule; interior edge columns
1155        // around the step (col = w/2) should change.
1156        let mid_row = h / 2;
1157        let mut changed = false;
1158        for col in (w / 2 - 4)..(w / 2 + 4) {
1159            if y[mid_row * y_stride + col] != y_orig[mid_row * y_stride + col] {
1160                changed = true;
1161            }
1162        }
1163        assert!(
1164            changed,
1165            "expected pixels around the synthetic step edge to change"
1166        );
1167    }
1168
1169    #[test]
1170    fn no_panic_on_partial_superblock_frame() {
1171        // Visible content is 40x24 (not a superblock multiple), exercising the
1172        // adjust_mask edge-clip paths, but per the buffer contract the actual
1173        // Y/U/V allocations are padded up to the enclosing 64x64/32x32 superblock.
1174        let (w, h) = (40usize, 24usize);
1175        let mi_rows = h.div_ceil(8);
1176        let mi_cols = w.div_ceil(8);
1177        let mi = flat_mi(mi_rows, mi_cols, 30);
1178
1179        let (pad_w, pad_h) = (sb_align(w), sb_align(h));
1180        let (mut y, y_stride) = make_step_frame(pad_w, pad_h);
1181        let uv_stride = pad_w / 2;
1182        let mut u = vec![128u8; uv_stride * (pad_h / 2)];
1183        let mut v = vec![128u8; uv_stride * (pad_h / 2)];
1184
1185        loop_filter_frame(
1186            &mut y, y_stride, &mut u, &mut v, uv_stride, w, h, &mi, mi_rows, mi_cols, 30, 2,
1187        );
1188    }
1189
1190    #[test]
1191    fn lf_level_applies_default_ref_deltas() {
1192        // base 10, scale 1: LAST→10, GOLDEN/ALTREF→9, INTRA→11.
1193        assert_eq!(lf_level_for_mi(10, 1, 12), 10); // LAST + ZEROMV
1194        assert_eq!(lf_level_for_mi(10, 2, 10), 9); // GOLDEN + NEARESTMV
1195        assert_eq!(lf_level_for_mi(10, 3, 13), 9); // ALTREF + NEWMV
1196        assert_eq!(lf_level_for_mi(10, 0, 0), 11); // INTRA
1197        assert_eq!(lf_level_for_mi(0, 1, 12), 0);
1198    }
1199}