Skip to main content

threers_codec/vp9/
inter.rs

1//! VP9 inter (P-frame) encoder.
2//!
3//! - [`encode_inter_zeromv_skip`]: every 8×8 is LAST / ZEROMV / skip (copy ref).
4//! - [`encode_inter_newmv_skip`]: every 8×8 is LAST / NEWMV / skip with a constant
5//!   MV in 1/8-pel luma units (even values; `allow_hp=0`).
6//! - [`encode_inter_residual`]: ZEROMV + 4×4 DCT residual against LAST.
7//! - [`encode_inter_newmv_residual`]: NEWMV + residual (EIGHTTAP MC + inter coeffs).
8//! - [`encode_inter_frame`]: per-block SAD search with NEARESTMV/NEARMV/ZEROMV/NEWMV
9//!   and 16/32/64 `PARTITION_NONE` when a single MV wins.
10//! - [`encode_inter_frame_golden`]: same, also choosing LAST vs GOLDEN per block.
11//! - [`encode_inter_frame_altref`]: LAST / GOLDEN / ALTREF per block, plus
12//!   LAST/GOLDEN+ALTREF compound (avg of two refs) when it wins SAD.
13//! - [`encode_inter_frame_refresh`]: LAST-only ME with a custom `refresh_frame_flags`.
14
15use crate::bitstream::BitWriter;
16use crate::hevc::Yuv420Frame;
17use crate::vp9::bool_coder::BoolEncoder;
18use crate::vp9::encoder::Reconstruction;
19use crate::vp9::loopfilter::{lf_level_for_mi, loop_filter_frame, LfMi};
20use crate::vp9::mc::{predict_inter, InterpFilter};
21use crate::vp9::me::{sad_mv, search_mv, DEFAULT_RANGE_PEL};
22use crate::vp9::mv::{write_mv, Mv};
23use crate::vp9::quant::{
24    ac_quant, dc_quant, quantize, quantize_16x16, quantize_32x32, quantize_8x8,
25};
26use crate::vp9::tables::{
27    bsl_from_px, counter_to_inter_mode_ctx, max_tx_size_wh, mode_2_counter, partition_ctx_index,
28    partition_ctx_index_wh, tx_size_px, uv_tx_size_wh, ALTREF_FRAME, DEFAULT_COMP_INTER_PROBS,
29    DEFAULT_COMP_REF_PROBS, DEFAULT_INTER_MODE_PROBS, DEFAULT_INTRA_INTER_PROBS,
30    DEFAULT_PARTITION_PROBS, DEFAULT_SINGLE_REF_PROBS, DEFAULT_SKIP_PROBS,
31    DEFAULT_SWITCHABLE_INTERP_PROBS, DEFAULT_TX_PROBS_16, DEFAULT_TX_PROBS_32, DEFAULT_TX_PROBS_8,
32    DIFF_UPDATE_PROB, GOLDEN_FRAME, INTER_MODE_TREE, INTER_OFFSET_NEARESTMV, INTER_OFFSET_NEARMV,
33    INTER_OFFSET_NEWMV, INTER_OFFSET_ZEROMV, INTRA_FRAME, LAST_FRAME, NEARESTMV, NEARMV, NEWMV,
34    PARTITION_CONTEXT_LOOKUP, PARTITION_HORZ, PARTITION_NONE, PARTITION_SPLIT, PARTITION_TREE,
35    PARTITION_VERT, SWITCHABLE_INTERP_TREE, TX_16X16, TX_4X4, TX_8X8, ZEROMV,
36};
37
38/// Frame-level `REFERENCE_MODE` (libvpx). Compound allowed once ALTREF sign-bias differs.
39#[derive(Clone, Copy, PartialEq, Eq)]
40enum RefMode {
41    /// Only single-ref blocks; one bit `0` in the compressed header.
42    Single,
43    /// Only compound blocks; bits `1,0`.
44    Compound,
45    /// Per-block select; bits `1,1`.
46    Select,
47}
48
49/// With LAST/GOLDEN bias 0 and ALTREF bias 1 → fixed=ALTREF, var=[LAST, GOLDEN].
50const COMP_FIXED_REF: i8 = ALTREF_FRAME;
51const COMP_VAR_REF: [i8; 2] = [LAST_FRAME, GOLDEN_FRAME];
52
53#[inline]
54fn ref_sign_bias(rf: i8) -> bool {
55    rf == ALTREF_FRAME
56}
57
58#[inline]
59fn scale_mv_for_ref(mv: Mv, from_ref: i8, to_ref: i8) -> Mv {
60    if ref_sign_bias(from_ref) != ref_sign_bias(to_ref) {
61        Mv {
62            row: -mv.row,
63            col: -mv.col,
64        }
65    } else {
66        mv
67    }
68}
69
70#[inline]
71fn avg_bytes(a: &[u8], b: &[u8], out: &mut [u8]) {
72    debug_assert_eq!(a.len(), b.len());
73    debug_assert_eq!(a.len(), out.len());
74    for i in 0..out.len() {
75        out[i] = ((u16::from(a[i]) + u16::from(b[i]) + 1) >> 1) as u8;
76    }
77}
78use crate::vp9::tokens::{write_coefs, write_coefs_16x16, write_coefs_32x32, write_coefs_8x8};
79use crate::vp9::transform::{
80    fdct16x16, fdct32x32, fdct8x8, fht4x4, idct16x16_add, idct32x32_add, idct8x8_add, iht4x4_add,
81    TxType,
82};
83
84const MAX_TILE_WIDTH_SB: u32 = 64;
85const MIN_TILE_WIDTH_SB: u32 = 4;
86const QINDEX: u32 = 128;
87const QINDEX_USIZE: usize = 128;
88/// Segment 1 uses `SEG_LVL_ALT_Q` with this delta (abs_delta=0).
89const SEG1_ALT_Q_DELTA: i32 = 32;
90const MAX_SEGMENTS: usize = 8;
91const SEG_TREE_PROBS: usize = 7;
92const SEG_LVL_ALT_Q: usize = 0;
93const SEG_LVL_MAX: usize = 4;
94const MAX_PROB: u8 = 255;
95const MAXQ: i32 = 255;
96/// `vp9_segment_tree` — walked with `vp9_write_tree(..., segment_id, 3, 0)`.
97const SEGMENT_TREE: [i8; 14] = [2, 4, 6, 8, 10, 12, 0, -1, -2, -3, -4, -5, -6, -7];
98/// Frame loop-filter level (sharpness 0, no mode/ref deltas).
99const FILTER_LEVEL: u8 = 10;
100const FILTER_SHARPNESS: u8 = 0;
101
102#[derive(Clone, Copy)]
103enum EntPlane {
104    Y,
105    U,
106    V,
107}
108
109/// Forward transform + quantize for a residual tile (`$tx_px` ∈ {4,8,16,32}).
110macro_rules! fwd_quant_tx {
111    (4, $res:expr, $q:expr) => {{
112        let mut coeff = [0i32; 16];
113        fht4x4($res, &mut coeff, TxType::DctDct);
114        quantize(&coeff, $q)
115    }};
116    (8, $res:expr, $q:expr) => {{
117        let mut coeff = [0i32; 64];
118        fdct8x8($res, &mut coeff);
119        quantize_8x8(&coeff, $q)
120    }};
121    (16, $res:expr, $q:expr) => {{
122        let mut coeff = [0i32; 256];
123        fdct16x16($res, &mut coeff);
124        quantize_16x16(&coeff, $q)
125    }};
126    (32, $res:expr, $q:expr) => {{
127        let mut coeff = [0i32; 1024];
128        fdct32x32($res, &mut coeff);
129        quantize_32x32(&coeff, $q)
130    }};
131}
132
133macro_rules! idct_add_tx {
134    (4, $dq:expr, $block:expr) => {
135        iht4x4_add($dq, $block, 4, TxType::DctDct)
136    };
137    (8, $dq:expr, $block:expr) => {
138        idct8x8_add($dq, $block, 8)
139    };
140    (16, $dq:expr, $block:expr) => {
141        idct16x16_add($dq, $block, 16)
142    };
143    (32, $dq:expr, $block:expr) => {
144        idct32x32_add($dq, $block, 32)
145    };
146}
147
148macro_rules! write_coefs_tx {
149    (4, $e:expr, $q:expr, $is_y:expr, $ctx:expr, $dc:expr, $ac:expr) => {
150        write_coefs($e, $q, $is_y, true, $ctx, TxType::DctDct, $dc, $ac)
151    };
152    (8, $e:expr, $q:expr, $is_y:expr, $ctx:expr, $dc:expr, $ac:expr) => {
153        write_coefs_8x8($e, $q, $is_y, $ctx)
154    };
155    (16, $e:expr, $q:expr, $is_y:expr, $ctx:expr, $dc:expr, $ac:expr) => {
156        write_coefs_16x16($e, $q, $is_y, $ctx)
157    };
158    (32, $e:expr, $q:expr, $is_y:expr, $ctx:expr, $dc:expr, $ac:expr) => {
159        write_coefs_32x32($e, $q, $is_y, $ctx)
160    };
161}
162
163/// Score all TX tiles of one plane for a fixed `$tx_px`.
164macro_rules! score_plane_tx_px {
165    ($tx_px:tt, $ncoef:tt, $pred:expr, $bw:expr, $bh:expr, $src:expr, $stride:expr, $ox:expr, $oy:expr, $qindex:expr) => {{
166        let n_w = $bw / $tx_px;
167        let n_h = $bh / $tx_px;
168        let mut cost = 0u32;
169        let mut any = false;
170        for ty in 0..n_h {
171            for txc in 0..n_w {
172                let mut residual = [0i16; $ncoef];
173                for r in 0..$tx_px {
174                    for c in 0..$tx_px {
175                        let pi = (ty * $tx_px + r) * $bw + txc * $tx_px + c;
176                        let s = $src[($oy + ty * $tx_px + r) * $stride + ($ox + txc * $tx_px + c)]
177                            as i16;
178                        residual[r * $tx_px + c] = s - $pred[pi] as i16;
179                    }
180                }
181                let (q, _) = fwd_quant_tx!($tx_px, &residual, $qindex);
182                for &c in &q {
183                    cost = cost.saturating_add(c.unsigned_abs());
184                }
185                any |= q.iter().any(|&c| c != 0);
186            }
187        }
188        (cost, any)
189    }};
190}
191
192fn score_plane_tx(
193    pred: &[u8],
194    bw: usize,
195    bh: usize,
196    src: &[u8],
197    stride: usize,
198    ox: usize,
199    oy: usize,
200    tx: u8,
201    qindex: usize,
202) -> (u32, bool) {
203    match tx {
204        TX_4X4 => score_plane_tx_px!(4, 16, pred, bw, bh, src, stride, ox, oy, qindex),
205        TX_8X8 => score_plane_tx_px!(8, 64, pred, bw, bh, src, stride, ox, oy, qindex),
206        TX_16X16 => score_plane_tx_px!(16, 256, pred, bw, bh, src, stride, ox, oy, qindex),
207        _ => score_plane_tx_px!(32, 1024, pred, bw, bh, src, stride, ox, oy, qindex),
208    }
209}
210
211fn store_plane(
212    dst: &mut [u8],
213    stride: usize,
214    x: usize,
215    y: usize,
216    bw: usize,
217    bh: usize,
218    src: &[u8],
219) {
220    for r in 0..bh {
221        dst[(y + r) * stride + x..(y + r) * stride + x + bw]
222            .copy_from_slice(&src[r * bw..r * bw + bw]);
223    }
224}
225
226struct TxTile {
227    /// Absolute plane origin (entropy contexts).
228    x: usize,
229    y: usize,
230    /// Block-local origin into the recon buffer.
231    lx: usize,
232    ly: usize,
233    q: Vec<i32>,
234    dq: Vec<i32>,
235    pred: Vec<u8>,
236}
237
238macro_rules! prepare_plane_tx_px {
239    ($tx_px:tt, $ncoef:tt, $pred:expr, $bw:expr, $bh:expr, $src:expr, $stride:expr, $ox:expr, $oy:expr, $qindex:expr) => {{
240        let n_w = $bw / $tx_px;
241        let n_h = $bh / $tx_px;
242        let mut tiles = Vec::with_capacity(n_w * n_h);
243        for ty in 0..n_h {
244            for txc in 0..n_w {
245                let x = $ox + txc * $tx_px;
246                let y = $oy + ty * $tx_px;
247                let mut residual = [0i16; $ncoef];
248                let mut pred_tile = [0u8; $ncoef];
249                for r in 0..$tx_px {
250                    for c in 0..$tx_px {
251                        let pi = (ty * $tx_px + r) * $bw + txc * $tx_px + c;
252                        pred_tile[r * $tx_px + c] = $pred[pi];
253                        residual[r * $tx_px + c] = $src[(y + r) * $stride + (x + c)] as i16
254                            - pred_tile[r * $tx_px + c] as i16;
255                    }
256                }
257                let (q, dq) = fwd_quant_tx!($tx_px, &residual, $qindex);
258                tiles.push(TxTile {
259                    x,
260                    y,
261                    lx: txc * $tx_px,
262                    ly: ty * $tx_px,
263                    q: q.to_vec(),
264                    dq: dq.to_vec(),
265                    pred: pred_tile.to_vec(),
266                });
267            }
268        }
269        tiles
270    }};
271}
272
273fn prepare_plane_tx(
274    pred: &[u8],
275    bw: usize,
276    bh: usize,
277    src: &[u8],
278    stride: usize,
279    ox: usize,
280    oy: usize,
281    tx: u8,
282    qindex: usize,
283) -> Vec<TxTile> {
284    match tx {
285        TX_4X4 => prepare_plane_tx_px!(4, 16, pred, bw, bh, src, stride, ox, oy, qindex),
286        TX_8X8 => prepare_plane_tx_px!(8, 64, pred, bw, bh, src, stride, ox, oy, qindex),
287        TX_16X16 => prepare_plane_tx_px!(16, 256, pred, bw, bh, src, stride, ox, oy, qindex),
288        _ => prepare_plane_tx_px!(32, 1024, pred, bw, bh, src, stride, ox, oy, qindex),
289    }
290}
291
292/// Encode a showable P-frame that copies `reference` (ZEROMV + skip on LAST).
293pub fn encode_inter_zeromv_skip(reference: &Reconstruction) -> (Vec<u8>, Reconstruction) {
294    encode_inter_skip(reference, Mv { row: 0, col: 0 }, false)
295}
296
297/// Encode a ZEROMV P-frame with 4×4 DCT residual against LAST.
298///
299/// Prediction is a copy of `reference` at the same position; the residual of
300/// `src − pred` is transform-coded with inter coefficient probabilities.
301/// `src` and `reference` must share dimensions (multiples of 8).
302pub fn encode_inter_residual(
303    src: &Yuv420Frame,
304    reference: &Reconstruction,
305) -> (Vec<u8>, Reconstruction) {
306    encode_inter_residual_mv(
307        src,
308        reference,
309        None,
310        None,
311        Mv::default(),
312        false,
313        false,
314        0x01,
315        RefMode::Single,
316    )
317}
318
319/// Encode a NEWMV P-frame with 4×4 DCT residual against LAST.
320///
321/// `mv_row_q3` / `mv_col_q3` are luma **1/8-pel** units and must be even
322/// (`allow_hp=0`). Prediction uses EIGHTTAP MC; residual uses inter coef probs.
323pub fn encode_inter_newmv_residual(
324    src: &Yuv420Frame,
325    reference: &Reconstruction,
326    mv_row_q3: i16,
327    mv_col_q3: i16,
328) -> (Vec<u8>, Reconstruction) {
329    assert!(
330        mv_row_q3 % 2 == 0 && mv_col_q3 % 2 == 0,
331        "NEWMV residual needs even Q3 MVs with allow_hp=0 (got {}, {})",
332        mv_row_q3,
333        mv_col_q3
334    );
335    assert!(
336        mv_row_q3 != 0 || mv_col_q3 != 0,
337        "use encode_inter_residual for a zero MV"
338    );
339    encode_inter_residual_mv(
340        src,
341        reference,
342        None,
343        None,
344        Mv {
345            row: mv_row_q3,
346            col: mv_col_q3,
347        },
348        true,
349        false,
350        0x01,
351        RefMode::Single,
352    )
353}
354
355/// Encode a P-frame with **per-block** SAD motion search + 4×4 DCT residual.
356///
357/// Each block picks an even-Q3 MV via SAD search, then codes NEARESTMV / NEARMV /
358/// ZEROMV / NEWMV plus residual against EIGHTTAP prediction from LAST.
359pub fn encode_inter_frame(src: &Yuv420Frame, last: &Reconstruction) -> (Vec<u8>, Reconstruction) {
360    encode_inter_residual_mv(
361        src,
362        last,
363        None,
364        None,
365        Mv::default(),
366        false,
367        true,
368        0x01,
369        RefMode::Single,
370    )
371}
372
373/// Like [`encode_inter_frame`], but each block may also predict from `golden`.
374///
375/// Frame buffers: LAST→slot 0, GOLDEN→slot 1, ALTREF→slot 2 (keyframe fills all
376/// slots; this path refreshes only slot 0). Pass the previous showable recon as
377/// `last` and an older still-valid recon (often the keyframe) as `golden`.
378pub fn encode_inter_frame_golden(
379    src: &Yuv420Frame,
380    last: &Reconstruction,
381    golden: &Reconstruction,
382) -> (Vec<u8>, Reconstruction) {
383    assert_eq!(last.width, golden.width);
384    assert_eq!(last.height, golden.height);
385    encode_inter_residual_mv(
386        src,
387        last,
388        Some(golden),
389        None,
390        Mv::default(),
391        false,
392        true,
393        0x01,
394        RefMode::Single,
395    )
396}
397
398/// Like [`encode_inter_frame_golden`], also allowing ALTREF per block.
399///
400/// Pass distinct recons for slots that still hold those pictures. Use
401/// [`encode_inter_frame_refresh`] with `0x04` earlier in the GOP if ALTREF
402/// should differ from GOLDEN (keyframe alone leaves both equal to the key).
403pub fn encode_inter_frame_altref(
404    src: &Yuv420Frame,
405    last: &Reconstruction,
406    golden: &Reconstruction,
407    altref: &Reconstruction,
408) -> (Vec<u8>, Reconstruction) {
409    assert_eq!(last.width, golden.width);
410    assert_eq!(last.height, golden.height);
411    assert_eq!(last.width, altref.width);
412    assert_eq!(last.height, altref.height);
413    encode_inter_residual_mv(
414        src,
415        last,
416        Some(golden),
417        Some(altref),
418        Mv::default(),
419        false,
420        true,
421        0x01,
422        RefMode::Select,
423    )
424}
425
426/// Like [`encode_inter_frame_altref`], but every block is LAST+ALTREF compound
427/// (`REFERENCE_MODE` = compound; prediction is the average of the two refs).
428pub fn encode_inter_frame_compound(
429    src: &Yuv420Frame,
430    last: &Reconstruction,
431    golden: &Reconstruction,
432    altref: &Reconstruction,
433) -> (Vec<u8>, Reconstruction) {
434    assert_eq!(last.width, golden.width);
435    assert_eq!(last.height, golden.height);
436    assert_eq!(last.width, altref.width);
437    assert_eq!(last.height, altref.height);
438    encode_inter_residual_mv(
439        src,
440        last,
441        Some(golden),
442        Some(altref),
443        Mv::default(),
444        false,
445        true,
446        0x01,
447        RefMode::Compound,
448    )
449}
450
451/// LAST-only ME P-frame with a custom `refresh_frame_flags` bitmask.
452///
453/// Bit `i` writes this recon into reference slot `i`. Common values: `0x01`
454/// (LAST/slot 0, default), `0x04` (ALTREF/slot 2 only — leaves LAST/GOLDEN).
455pub fn encode_inter_frame_refresh(
456    src: &Yuv420Frame,
457    last: &Reconstruction,
458    refresh_frame_flags: u8,
459) -> (Vec<u8>, Reconstruction) {
460    encode_inter_residual_mv(
461        src,
462        last,
463        None,
464        None,
465        Mv::default(),
466        false,
467        true,
468        refresh_frame_flags,
469        RefMode::Single,
470    )
471}
472
473fn encode_inter_residual_mv(
474    src: &Yuv420Frame,
475    last: &Reconstruction,
476    golden: Option<&Reconstruction>,
477    altref: Option<&Reconstruction>,
478    mv: Mv,
479    newmv: bool,
480    search: bool,
481    refresh_frame_flags: u8,
482    ref_mode: RefMode,
483) -> (Vec<u8>, Reconstruction) {
484    assert_eq!(src.width, last.width);
485    assert_eq!(src.height, last.height);
486    assert!(
487        src.width >= 8
488            && src.height >= 8
489            && src.width.is_multiple_of(8)
490            && src.height.is_multiple_of(8),
491        "VP9 inter residual needs dims that are multiples of 8 (got {}×{})",
492        src.width,
493        src.height
494    );
495
496    let mut enc = ResidualInterEnc::new(src, last, golden, altref, mv, newmv, search, ref_mode);
497    let compressed = compressed_header_inter(ref_mode);
498    let log2_tile_cols = choose_log2_tile_cols(src.width);
499    let tile = enc.encode_tiles(log2_tile_cols);
500
501    let mut wb = BitWriter::new();
502    write_uncompressed_inter_header(
503        &mut wb,
504        src.width,
505        src.height,
506        compressed.len() as u32,
507        refresh_frame_flags,
508        log2_tile_cols,
509    );
510    let mut out = wb.finish();
511    out.extend_from_slice(&compressed);
512    out.extend_from_slice(&tile);
513
514    let mut recon = Reconstruction {
515        width: src.width,
516        height: src.height,
517        y: enc.recon_y,
518        u: enc.recon_u,
519        v: enc.recon_v,
520    };
521    let lf_mi = lf_mi_from_residual(&enc.mi);
522    apply_loop_filter(&mut recon, &lf_mi, enc.mi_rows, enc.mi_cols);
523    (crate::vp9::finalize_frame(out), recon)
524}
525
526/// Encode a showable P-frame: NEWMV + skip with a constant MV in **1/8-pel luma**.
527///
528/// Values must be even (`allow_hp=0`). Reconstruction is EIGHTTAP motion-
529/// compensation of `reference` (full- or sub-pel) with edge clamping.
530pub fn encode_inter_newmv_skip(
531    reference: &Reconstruction,
532    mv_row_q3: i16,
533    mv_col_q3: i16,
534) -> (Vec<u8>, Reconstruction) {
535    assert!(
536        mv_row_q3 % 2 == 0 && mv_col_q3 % 2 == 0,
537        "NEWMV skip needs even Q3 MVs with allow_hp=0 (got {}, {})",
538        mv_row_q3,
539        mv_col_q3
540    );
541    assert!(
542        mv_row_q3 != 0 || mv_col_q3 != 0,
543        "use encode_inter_zeromv_skip for a zero MV"
544    );
545    encode_inter_skip(
546        reference,
547        Mv {
548            row: mv_row_q3,
549            col: mv_col_q3,
550        },
551        true,
552    )
553}
554
555fn encode_inter_skip(reference: &Reconstruction, mv: Mv, newmv: bool) -> (Vec<u8>, Reconstruction) {
556    assert!(
557        reference.width >= 8
558            && reference.height >= 8
559            && reference.width.is_multiple_of(8)
560            && reference.height.is_multiple_of(8),
561        "VP9 inter needs dims that are multiples of 8 (got {}×{})",
562        reference.width,
563        reference.height
564    );
565
566    let mut enc = InterEnc::new(reference, mv, newmv);
567    let compressed = compressed_header_inter(RefMode::Single);
568    let log2_tile_cols = choose_log2_tile_cols(reference.width);
569    let tile = enc.encode_tiles(log2_tile_cols);
570
571    let mut wb = BitWriter::new();
572    write_uncompressed_inter_header(
573        &mut wb,
574        reference.width,
575        reference.height,
576        compressed.len() as u32,
577        0x01,
578        log2_tile_cols,
579    );
580    let mut out = wb.finish();
581    out.extend_from_slice(&compressed);
582    out.extend_from_slice(&tile);
583
584    let mut recon = motion_compensate(reference, mv);
585    let lf_mi: Vec<LfMi> = enc
586        .mi
587        .iter()
588        .map(|m| LfMi {
589            skip: m.skip,
590            is_inter: m.is_inter,
591            tx_size_y: 1, // BLOCK_8X8 → TX_8X8
592            bw_mi: 1,
593            bh_mi: 1,
594            bsize_idx: partition_ctx_index_wh(8, 8),
595            block_origin: true,
596            level: lf_level_for_mi(FILTER_LEVEL, m.ref_frame, m.mode),
597        })
598        .collect();
599    apply_loop_filter(&mut recon, &lf_mi, enc.mi_rows, enc.mi_cols);
600    (crate::vp9::finalize_frame(out), recon)
601}
602
603fn motion_compensate(reference: &Reconstruction, mv: Mv) -> Reconstruction {
604    let (w, h) = (reference.width as usize, reference.height as usize);
605    let mut y = vec![0u8; w * h];
606    predict_inter(
607        &reference.y,
608        w,
609        w,
610        h,
611        0,
612        0,
613        w,
614        h,
615        mv.row,
616        mv.col,
617        false,
618        InterpFilter::EightTap,
619        &mut y,
620    );
621    let (cw, ch) = (w / 2, h / 2);
622    let mut u = vec![0u8; cw * ch];
623    let mut v = vec![0u8; cw * ch];
624    predict_inter(
625        &reference.u,
626        cw,
627        cw,
628        ch,
629        0,
630        0,
631        cw,
632        ch,
633        mv.row,
634        mv.col,
635        true,
636        InterpFilter::EightTap,
637        &mut u,
638    );
639    predict_inter(
640        &reference.v,
641        cw,
642        cw,
643        ch,
644        0,
645        0,
646        cw,
647        ch,
648        mv.row,
649        mv.col,
650        true,
651        InterpFilter::EightTap,
652        &mut v,
653    );
654    Reconstruction {
655        width: reference.width,
656        height: reference.height,
657        y,
658        u,
659        v,
660    }
661}
662
663struct MiInfo {
664    mode: i8,
665    skip: bool,
666    is_inter: bool,
667    ref_frame: i8,
668    mv: Mv,
669    interp_filter: InterpFilter,
670}
671
672struct InterEnc<'a> {
673    reference: &'a Reconstruction,
674    mv: Mv,
675    newmv: bool,
676    mi_cols: usize,
677    mi_rows: usize,
678    tile_col_start: usize,
679    tile_col_end: usize,
680    mi: Vec<MiInfo>,
681    above_ctx: Vec<u8>,
682    left_ctx: [u8; 8],
683    bool: BoolEncoder,
684}
685
686impl<'a> InterEnc<'a> {
687    fn new(reference: &'a Reconstruction, mv: Mv, newmv: bool) -> Self {
688        let mi_cols = reference.width as usize / 8;
689        let mi_rows = reference.height as usize / 8;
690        let mode = if newmv { NEWMV } else { ZEROMV };
691        Self {
692            reference,
693            mv,
694            newmv,
695            mi_cols,
696            mi_rows,
697            tile_col_start: 0,
698            tile_col_end: mi_cols,
699            mi: (0..mi_cols * mi_rows)
700                .map(|_| MiInfo {
701                    mode,
702                    skip: true,
703                    is_inter: true,
704                    ref_frame: LAST_FRAME,
705                    mv,
706                    interp_filter: InterpFilter::EightTap,
707                })
708                .collect(),
709            above_ctx: vec![0; mi_cols],
710            left_ctx: [0; 8],
711            bool: BoolEncoder::new(),
712        }
713    }
714
715    fn encode_tiles(&mut self, log2_tile_cols: u32) -> Vec<u8> {
716        let tile_cols = 1usize << log2_tile_cols;
717        let mut tiles = Vec::with_capacity(tile_cols);
718        for tile_col in 0..tile_cols {
719            let (start, end) = tile_mi_col_range(self.mi_cols, log2_tile_cols, tile_col as u32);
720            self.tile_col_start = start;
721            self.tile_col_end = end;
722            tiles.push(self.encode_one_tile());
723        }
724        pack_tile_data(&tiles)
725    }
726
727    fn encode_one_tile(&mut self) -> Vec<u8> {
728        let mut mi_row = 0;
729        while mi_row < self.mi_rows {
730            self.left_ctx = [0; 8];
731            let mut mi_col = self.tile_col_start;
732            while mi_col < self.tile_col_end {
733                self.encode_partition(mi_row, mi_col, 64);
734                mi_col += 8;
735            }
736            mi_row += 8;
737        }
738        std::mem::take(&mut self.bool).finish()
739    }
740
741    fn encode_partition(&mut self, mi_row: usize, mi_col: usize, bsize_px: u32) {
742        if mi_row >= self.mi_rows || mi_col >= self.mi_cols {
743            return;
744        }
745        let mi_half = (bsize_px as usize / 8) / 2;
746        let has_rows = mi_row + mi_half < self.mi_rows;
747        let has_cols = mi_col + mi_half < self.mi_cols;
748        let partition = if bsize_px == 8 {
749            PARTITION_NONE
750        } else {
751            PARTITION_SPLIT
752        };
753
754        self.write_partition(mi_row, mi_col, bsize_px, has_rows, has_cols, partition);
755
756        if bsize_px == 8 {
757            self.encode_block(mi_row, mi_col);
758            self.update_partition_context(mi_row, mi_col, bsize_px, bsize_px);
759            return;
760        }
761
762        let sub_px = bsize_px / 2;
763        self.encode_partition(mi_row, mi_col, sub_px);
764        self.encode_partition(mi_row, mi_col + mi_half, sub_px);
765        self.encode_partition(mi_row + mi_half, mi_col, sub_px);
766        self.encode_partition(mi_row + mi_half, mi_col + mi_half, sub_px);
767    }
768
769    fn write_partition(
770        &mut self,
771        mi_row: usize,
772        mi_col: usize,
773        bsize_px: u32,
774        has_rows: bool,
775        has_cols: bool,
776        partition: i8,
777    ) {
778        let ctx = self.partition_context(mi_row, mi_col, bsize_px);
779        let probs = &DEFAULT_PARTITION_PROBS[ctx];
780        if has_rows && has_cols {
781            write_tree(&mut self.bool, &PARTITION_TREE, probs, partition);
782        } else if !has_rows && has_cols {
783            self.bool.put_bool(probs[1], partition == PARTITION_SPLIT);
784        } else if has_rows && !has_cols {
785            self.bool.put_bool(probs[2], partition == PARTITION_SPLIT);
786        }
787    }
788
789    fn partition_context(&self, mi_row: usize, mi_col: usize, bsize_px: u32) -> usize {
790        let bsl = bsl_from_px(bsize_px);
791        let above = (self.above_ctx[mi_col] >> bsl) & 1;
792        let left = (self.left_ctx[mi_row & 7] >> bsl) & 1;
793        bsl * 4 + (left as usize) * 2 + above as usize
794    }
795
796    fn update_partition_context(
797        &mut self,
798        mi_row: usize,
799        mi_col: usize,
800        sub_px: u32,
801        bsize_px: u32,
802    ) {
803        let bs = bsize_px as usize / 8;
804        let (above_v, left_v) = PARTITION_CONTEXT_LOOKUP[partition_ctx_index(sub_px)];
805        for i in 0..bs {
806            if mi_col + i < self.mi_cols {
807                self.above_ctx[mi_col + i] = above_v;
808            }
809            self.left_ctx[(mi_row + i) & 7] = left_v;
810        }
811    }
812
813    fn encode_block(&mut self, mi_row: usize, mi_col: usize) {
814        let skip = true;
815        let is_inter = true;
816        write_segment_id(&mut self.bool, segment_id_for_mi_col(mi_col, self.mi_cols));
817        let skip_ctx = self.skip_context(mi_row, mi_col);
818        self.bool.put_bool(DEFAULT_SKIP_PROBS[skip_ctx], skip);
819
820        let ii_ctx = self.intra_inter_context(mi_row, mi_col);
821        self.bool
822            .put_bool(DEFAULT_INTRA_INTER_PROBS[ii_ctx], is_inter);
823
824        let ref_ctx = self.single_ref_p1_context(mi_row, mi_col);
825        self.bool
826            .put_bool(DEFAULT_SINGLE_REF_PROBS[ref_ctx][0], false);
827
828        let mode_ctx = self.inter_mode_context(mi_row, mi_col);
829        if self.newmv {
830            write_tree(
831                &mut self.bool,
832                &INTER_MODE_TREE,
833                &DEFAULT_INTER_MODE_PROBS[mode_ctx],
834                INTER_OFFSET_NEWMV,
835            );
836        } else {
837            write_tree(
838                &mut self.bool,
839                &INTER_MODE_TREE,
840                &DEFAULT_INTER_MODE_PROBS[mode_ctx],
841                INTER_OFFSET_ZEROMV,
842            );
843        }
844
845        let filt_ctx = self.switchable_interp_context(mi_row, mi_col);
846        write_tree(
847            &mut self.bool,
848            &SWITCHABLE_INTERP_TREE,
849            &DEFAULT_SWITCHABLE_INTERP_PROBS[filt_ctx],
850            InterpFilter::EightTap as i8,
851        );
852
853        if self.newmv {
854            let ref_mv = self.nearest_ref_mv(mi_row, mi_col);
855            write_mv(&mut self.bool, self.mv, ref_mv, false);
856        }
857
858        self.mi[mi_row * self.mi_cols + mi_col] = MiInfo {
859            mode: if self.newmv { NEWMV } else { ZEROMV },
860            skip,
861            is_inter,
862            ref_frame: LAST_FRAME,
863            mv: self.mv,
864            interp_filter: InterpFilter::EightTap,
865        };
866        let _ = self.reference;
867    }
868
869    /// NEWMV nearest ref: first unique LAST MV from neighbors (above, then left)
870    /// — matches `mv_ref_blocks[BLOCK_8X8]` / `find_mv_refs_idx`.
871    fn nearest_ref_mv(&self, mi_row: usize, mi_col: usize) -> Mv {
872        const NBRS: [(i32, i32); 8] = [
873            (-1, 0),
874            (0, -1),
875            (-1, -1),
876            (-2, 0),
877            (0, -2),
878            (-2, -1),
879            (-1, -2),
880            (-2, -2),
881        ];
882        for &(dr, dc) in &NBRS {
883            let r = mi_row as i32 + dr;
884            let c = mi_col as i32 + dc;
885            if !self.mi_in_tile(r, c) {
886                continue;
887            }
888            let n = &self.mi[r as usize * self.mi_cols + c as usize];
889            if n.is_inter && n.ref_frame == LAST_FRAME {
890                return clamp_mv_ref(n.mv, mi_row, mi_col, self.mi_rows, self.mi_cols, 1, 1);
891            }
892        }
893        Mv::default()
894    }
895
896    fn mi_in_tile(&self, r: i32, c: i32) -> bool {
897        r >= 0
898            && (r as usize) < self.mi_rows
899            && c >= self.tile_col_start as i32
900            && (c as usize) < self.tile_col_end
901    }
902
903    fn left_available(&self, mi_col: usize) -> bool {
904        mi_col > self.tile_col_start
905    }
906
907    fn switchable_interp_context(&self, mi_row: usize, mi_col: usize) -> usize {
908        let missing = InterpFilter::SWITCHABLE_FILTERS as usize;
909        let left = if self.left_available(mi_col) {
910            self.mi[mi_row * self.mi_cols + mi_col - 1].interp_filter as usize
911        } else {
912            missing
913        };
914        let above = if mi_row > 0 {
915            self.mi[(mi_row - 1) * self.mi_cols + mi_col].interp_filter as usize
916        } else {
917            missing
918        };
919        if left == above {
920            left
921        } else if left == missing {
922            above
923        } else if above == missing {
924            left
925        } else {
926            missing
927        }
928    }
929
930    fn skip_context(&self, mi_row: usize, mi_col: usize) -> usize {
931        let above = if mi_row > 0 {
932            self.mi[(mi_row - 1) * self.mi_cols + mi_col].skip as usize
933        } else {
934            0
935        };
936        let left = if self.left_available(mi_col) {
937            self.mi[mi_row * self.mi_cols + (mi_col - 1)].skip as usize
938        } else {
939            0
940        };
941        above + left
942    }
943
944    fn intra_inter_context(&self, mi_row: usize, mi_col: usize) -> usize {
945        let above = if mi_row > 0 {
946            Some(&self.mi[(mi_row - 1) * self.mi_cols + mi_col])
947        } else {
948            None
949        };
950        let left = if self.left_available(mi_col) {
951            Some(&self.mi[mi_row * self.mi_cols + (mi_col - 1)])
952        } else {
953            None
954        };
955        match (above, left) {
956            (Some(a), Some(l)) => {
957                let ai = !a.is_inter;
958                let li = !l.is_inter;
959                if li && ai {
960                    3
961                } else if li || ai {
962                    1
963                } else {
964                    0
965                }
966            }
967            (Some(e), None) | (None, Some(e)) => 2 * (!e.is_inter as usize),
968            (None, None) => 0,
969        }
970    }
971
972    fn inter_mode_context(&self, mi_row: usize, mi_col: usize) -> usize {
973        let mut counter = 0i32;
974        if self.left_available(mi_col) {
975            counter += mode_2_counter(self.mi[mi_row * self.mi_cols + (mi_col - 1)].mode);
976        }
977        if mi_row > 0 {
978            counter += mode_2_counter(self.mi[(mi_row - 1) * self.mi_cols + mi_col].mode);
979        }
980        counter_to_inter_mode_ctx(counter)
981    }
982
983    fn single_ref_p1_context(&self, mi_row: usize, mi_col: usize) -> usize {
984        let above = if mi_row > 0 {
985            Some(&self.mi[(mi_row - 1) * self.mi_cols + mi_col])
986        } else {
987            None
988        };
989        let left = if self.left_available(mi_col) {
990            Some(&self.mi[mi_row * self.mi_cols + (mi_col - 1)])
991        } else {
992            None
993        };
994        match (above, left) {
995            (Some(a), Some(l)) => {
996                let ai = !a.is_inter;
997                let li = !l.is_inter;
998                if ai && li {
999                    2
1000                } else if ai || li {
1001                    let edge = if ai { l } else { a };
1002                    4 * (edge.ref_frame == LAST_FRAME) as usize
1003                } else {
1004                    2 * (a.ref_frame == LAST_FRAME) as usize
1005                        + 2 * (l.ref_frame == LAST_FRAME) as usize
1006                }
1007            }
1008            (Some(e), None) | (None, Some(e)) => {
1009                if !e.is_inter {
1010                    2
1011                } else {
1012                    4 * (e.ref_frame == LAST_FRAME) as usize
1013                }
1014            }
1015            (None, None) => 2,
1016        }
1017    }
1018}
1019
1020// ---- ZEROMV + residual -------------------------------------------------------
1021
1022#[derive(Clone, Copy)]
1023struct ResidualMi {
1024    skip: bool,
1025    is_inter: bool,
1026    ref_frame: i8,
1027    /// Second ref for compound; [`INTRA_FRAME`] means single-ref.
1028    second_ref: i8,
1029    mode: i8,
1030    mv: Mv,
1031    mv1: Mv,
1032    bw_px: u32,
1033    bh_px: u32,
1034    /// True only on the top-left MI of this coding block.
1035    block_origin: bool,
1036    /// Coded (or implied-on-skip) transform size for TX_MODE_SELECT / LF.
1037    tx_size: u8,
1038    interp_filter: InterpFilter,
1039}
1040
1041impl ResidualMi {
1042    fn is_compound(self) -> bool {
1043        self.second_ref > INTRA_FRAME
1044    }
1045}
1046
1047#[derive(Clone, Copy)]
1048struct InterPick {
1049    mv: Mv,
1050    mv1: Mv,
1051    mode: i8,
1052    ref_frame: i8,
1053    second_ref: i8,
1054}
1055
1056struct ResidualInterEnc<'a> {
1057    src: &'a Yuv420Frame,
1058    reference: &'a Reconstruction,
1059    golden: Option<&'a Reconstruction>,
1060    altref: Option<&'a Reconstruction>,
1061    mv: Mv,
1062    newmv: bool,
1063    search: bool,
1064    ref_mode: RefMode,
1065    mi_cols: usize,
1066    mi_rows: usize,
1067    tile_col_start: usize,
1068    tile_col_end: usize,
1069    recon_y: Vec<u8>,
1070    recon_u: Vec<u8>,
1071    recon_v: Vec<u8>,
1072    mi: Vec<ResidualMi>,
1073    above_ctx: Vec<u8>,
1074    left_ctx: [u8; 8],
1075    above_ent_y: Vec<u8>,
1076    left_ent_y: [u8; 16],
1077    above_ent_u: Vec<u8>,
1078    left_ent_u: [u8; 8],
1079    above_ent_v: Vec<u8>,
1080    left_ent_v: [u8; 8],
1081    bool: BoolEncoder,
1082}
1083
1084impl<'a> ResidualInterEnc<'a> {
1085    fn new(
1086        src: &'a Yuv420Frame,
1087        reference: &'a Reconstruction,
1088        golden: Option<&'a Reconstruction>,
1089        altref: Option<&'a Reconstruction>,
1090        mv: Mv,
1091        newmv: bool,
1092        search: bool,
1093        ref_mode: RefMode,
1094    ) -> Self {
1095        let (w, h) = (src.width as usize, src.height as usize);
1096        let mi_cols = w / 8;
1097        let mi_rows = h / 8;
1098        let (cw, ch) = (w / 2, h / 2);
1099        let mode = if newmv { NEWMV } else { ZEROMV };
1100        Self {
1101            src,
1102            reference,
1103            golden,
1104            altref,
1105            mv,
1106            newmv,
1107            search,
1108            ref_mode,
1109            mi_cols,
1110            mi_rows,
1111            tile_col_start: 0,
1112            tile_col_end: mi_cols,
1113            recon_y: vec![0; w * h],
1114            recon_u: vec![128; cw * ch],
1115            recon_v: vec![128; cw * ch],
1116            mi: (0..mi_cols * mi_rows)
1117                .map(|_| ResidualMi {
1118                    skip: true,
1119                    is_inter: true,
1120                    ref_frame: LAST_FRAME,
1121                    second_ref: INTRA_FRAME,
1122                    mode,
1123                    mv,
1124                    mv1: Mv::default(),
1125                    bw_px: 8,
1126                    bh_px: 8,
1127                    block_origin: true,
1128                    tx_size: TX_8X8,
1129                    interp_filter: InterpFilter::EightTap,
1130                })
1131                .collect(),
1132            above_ctx: vec![0; mi_cols],
1133            left_ctx: [0; 8],
1134            above_ent_y: vec![0; mi_cols * 2],
1135            left_ent_y: [0; 16],
1136            above_ent_u: vec![0; mi_cols],
1137            left_ent_u: [0; 8],
1138            above_ent_v: vec![0; mi_cols],
1139            left_ent_v: [0; 8],
1140            bool: BoolEncoder::new(),
1141        }
1142    }
1143
1144    fn encode_tiles(&mut self, log2_tile_cols: u32) -> Vec<u8> {
1145        let tile_cols = 1usize << log2_tile_cols;
1146        let mut tiles = Vec::with_capacity(tile_cols);
1147        for tile_col in 0..tile_cols {
1148            let (start, end) = tile_mi_col_range(self.mi_cols, log2_tile_cols, tile_col as u32);
1149            self.tile_col_start = start;
1150            self.tile_col_end = end;
1151            tiles.push(self.encode_one_tile());
1152        }
1153        pack_tile_data(&tiles)
1154    }
1155
1156    fn encode_one_tile(&mut self) -> Vec<u8> {
1157        let mut mi_row = 0;
1158        while mi_row < self.mi_rows {
1159            self.left_ctx = [0; 8];
1160            self.left_ent_y = [0; 16];
1161            self.left_ent_u = [0; 8];
1162            self.left_ent_v = [0; 8];
1163            let mut mi_col = self.tile_col_start;
1164            while mi_col < self.tile_col_end {
1165                self.encode_partition(mi_row, mi_col, 64);
1166                mi_col += 8;
1167            }
1168            mi_row += 8;
1169        }
1170        std::mem::take(&mut self.bool).finish()
1171    }
1172
1173    fn mi_in_tile(&self, r: i32, c: i32) -> bool {
1174        r >= 0
1175            && (r as usize) < self.mi_rows
1176            && c >= self.tile_col_start as i32
1177            && (c as usize) < self.tile_col_end
1178    }
1179
1180    fn left_available(&self, mi_col: usize) -> bool {
1181        mi_col > self.tile_col_start
1182    }
1183
1184    fn encode_partition(&mut self, mi_row: usize, mi_col: usize, bsize_px: u32) {
1185        if mi_row >= self.mi_rows || mi_col >= self.mi_cols {
1186            return;
1187        }
1188        let mi_half = (bsize_px as usize / 8) / 2;
1189        let has_rows = mi_row + mi_half < self.mi_rows;
1190        let has_cols = mi_col + mi_half < self.mi_cols;
1191        let bs_mi = (bsize_px / 8) as usize;
1192        let block_fits = mi_row + bs_mi <= self.mi_rows && mi_col + bs_mi <= self.mi_cols;
1193        let partition = if bsize_px == 8 {
1194            PARTITION_NONE
1195        } else if matches!(bsize_px, 16 | 32 | 64) && block_fits && self.search {
1196            self.pick_partition(mi_row, mi_col, bsize_px)
1197        } else {
1198            PARTITION_SPLIT
1199        };
1200        self.write_partition(mi_row, mi_col, bsize_px, has_rows, has_cols, partition);
1201        match partition {
1202            PARTITION_NONE => {
1203                self.encode_block(mi_row, mi_col, bsize_px, bsize_px);
1204                self.update_partition_context(
1205                    mi_row, mi_col, bsize_px, bsize_px, bsize_px, bsize_px,
1206                );
1207            }
1208            PARTITION_HORZ => {
1209                let sub_h = bsize_px / 2;
1210                self.encode_block(mi_row, mi_col, bsize_px, sub_h);
1211                self.encode_block(mi_row + mi_half, mi_col, bsize_px, sub_h);
1212                self.update_partition_context(mi_row, mi_col, bsize_px, sub_h, bsize_px, bsize_px);
1213            }
1214            PARTITION_VERT => {
1215                let sub_w = bsize_px / 2;
1216                self.encode_block(mi_row, mi_col, sub_w, bsize_px);
1217                self.encode_block(mi_row, mi_col + mi_half, sub_w, bsize_px);
1218                self.update_partition_context(mi_row, mi_col, sub_w, bsize_px, bsize_px, bsize_px);
1219            }
1220            _ => {
1221                let sub_px = bsize_px / 2;
1222                self.encode_partition(mi_row, mi_col, sub_px);
1223                self.encode_partition(mi_row, mi_col + mi_half, sub_px);
1224                self.encode_partition(mi_row + mi_half, mi_col, sub_px);
1225                self.encode_partition(mi_row + mi_half, mi_col + mi_half, sub_px);
1226            }
1227        }
1228    }
1229
1230    /// Pick NONE/HORZ/VERT/SPLIT by luma SAD, biased toward fewer coding blocks.
1231    fn pick_partition(&self, mi_row: usize, mi_col: usize, bsize_px: u32) -> i8 {
1232        let w = self.src.width as usize;
1233        let h = self.src.height as usize;
1234        let px = mi_col * 8;
1235        let py = mi_row * 8;
1236        let bw = bsize_px as usize;
1237        let hw = bw / 2;
1238        let score = |dx: usize, dy: usize, sw: usize, sh: usize| {
1239            let mv = search_mv(
1240                &self.src.y,
1241                w,
1242                &self.reference.y,
1243                w,
1244                w,
1245                h,
1246                px + dx,
1247                py + dy,
1248                sw,
1249                sh,
1250                DEFAULT_RANGE_PEL,
1251            );
1252            sad_mv(
1253                &self.src.y,
1254                w,
1255                &self.reference.y,
1256                w,
1257                w,
1258                h,
1259                px + dx,
1260                py + dy,
1261                sw,
1262                sh,
1263                mv,
1264            )
1265        };
1266        let sad_none = score(0, 0, bw, bw);
1267        let sad_horz = score(0, 0, bw, hw).saturating_add(score(0, hw, bw, hw));
1268        let sad_vert = score(0, 0, hw, bw).saturating_add(score(hw, 0, hw, bw));
1269        let sad_split = score(0, 0, hw, hw)
1270            .saturating_add(score(hw, 0, hw, hw))
1271            .saturating_add(score(0, hw, hw, hw))
1272            .saturating_add(score(hw, hw, hw, hw));
1273        // Approximate the mode/MV/tree cost saved by using fewer blocks.
1274        let bias = match bsize_px {
1275            16 => 256,
1276            32 => 1024,
1277            64 => 4096,
1278            _ => 256,
1279        };
1280        let choices = [
1281            (sad_none, PARTITION_NONE),
1282            (sad_horz.saturating_add(bias / 2), PARTITION_HORZ),
1283            (sad_vert.saturating_add(bias / 2), PARTITION_VERT),
1284            (sad_split.saturating_add(bias), PARTITION_SPLIT),
1285        ];
1286        choices
1287            .into_iter()
1288            .min_by_key(|&(cost, partition)| (cost, partition))
1289            .unwrap()
1290            .1
1291    }
1292
1293    fn write_partition(
1294        &mut self,
1295        mi_row: usize,
1296        mi_col: usize,
1297        bsize_px: u32,
1298        has_rows: bool,
1299        has_cols: bool,
1300        partition: i8,
1301    ) {
1302        let bsl = bsl_from_px(bsize_px);
1303        let above = (self.above_ctx[mi_col] >> bsl) & 1;
1304        let left = (self.left_ctx[mi_row & 7] >> bsl) & 1;
1305        let ctx = bsl * 4 + (left as usize) * 2 + above as usize;
1306        let probs = &DEFAULT_PARTITION_PROBS[ctx];
1307        if has_rows && has_cols {
1308            write_tree(&mut self.bool, &PARTITION_TREE, probs, partition);
1309        } else if !has_rows && has_cols {
1310            self.bool.put_bool(probs[1], partition == PARTITION_SPLIT);
1311        } else if has_rows && !has_cols {
1312            self.bool.put_bool(probs[2], partition == PARTITION_SPLIT);
1313        }
1314    }
1315
1316    fn update_partition_context(
1317        &mut self,
1318        mi_row: usize,
1319        mi_col: usize,
1320        sub_bw: u32,
1321        sub_bh: u32,
1322        bw: u32,
1323        bh: u32,
1324    ) {
1325        let bs_w = bw as usize / 8;
1326        let bs_h = bh as usize / 8;
1327        let (above_v, left_v) = PARTITION_CONTEXT_LOOKUP[partition_ctx_index_wh(sub_bw, sub_bh)];
1328        for i in 0..bs_w {
1329            if mi_col + i < self.mi_cols {
1330                self.above_ctx[mi_col + i] = above_v;
1331            }
1332        }
1333        for i in 0..bs_h {
1334            self.left_ctx[(mi_row + i) & 7] = left_v;
1335        }
1336    }
1337
1338    fn encode_block(&mut self, mi_row: usize, mi_col: usize, bw_px: u32, bh_px: u32) {
1339        debug_assert!(matches!(
1340            (bw_px, bh_px),
1341            (8, 8)
1342                | (8, 16)
1343                | (16, 8)
1344                | (16, 16)
1345                | (16, 32)
1346                | (32, 16)
1347                | (32, 32)
1348                | (32, 64)
1349                | (64, 32)
1350                | (64, 64)
1351        ));
1352        let bw_mi = (bw_px / 8) as usize;
1353        let bh_mi = (bh_px / 8) as usize;
1354        let (px, py) = (mi_col * 8, mi_row * 8);
1355        let w = self.src.width as usize;
1356        let h = self.src.height as usize;
1357        let (cpx, cpy) = (px / 2, py / 2);
1358        let cw = w / 2;
1359        let ch = h / 2;
1360        let bw = bw_px as usize;
1361        let bh = bh_px as usize;
1362        let cw_blk = bw / 2;
1363        let ch_blk = bh / 2;
1364
1365        let pick = if self.search {
1366            self.pick_ref_and_mode(mi_row, mi_col, bw_px, bh_px, px, py, bw, bh, w, h)
1367        } else if self.newmv {
1368            InterPick {
1369                mv: self.mv,
1370                mv1: Mv::default(),
1371                mode: NEWMV,
1372                ref_frame: LAST_FRAME,
1373                second_ref: INTRA_FRAME,
1374            }
1375        } else {
1376            InterPick {
1377                mv: Mv::default(),
1378                mv1: Mv::default(),
1379                mode: ZEROMV,
1380                ref_frame: LAST_FRAME,
1381                second_ref: INTRA_FRAME,
1382            }
1383        };
1384        let (mv, mv1, mode, ref_frame, second_ref) = (
1385            pick.mv,
1386            pick.mv1,
1387            pick.mode,
1388            pick.ref_frame,
1389            pick.second_ref,
1390        );
1391        let ref_recon = self.recon_for(ref_frame);
1392        let compound = second_ref > INTRA_FRAME;
1393        let interp_filter =
1394            self.pick_interp_filter(px, py, bw, bh, w, h, mv, mv1, ref_frame, second_ref);
1395
1396        let mut y_pred = vec![0u8; bw * bh];
1397        let mut u_pred = vec![0u8; cw_blk * ch_blk];
1398        let mut v_pred = vec![0u8; cw_blk * ch_blk];
1399        if compound {
1400            let r1 = self.recon_for(second_ref);
1401            let mut ya = vec![0u8; bw * bh];
1402            let mut yb = vec![0u8; bw * bh];
1403            predict_inter(
1404                &ref_recon.y,
1405                w,
1406                w,
1407                h,
1408                px,
1409                py,
1410                bw,
1411                bh,
1412                mv.row,
1413                mv.col,
1414                false,
1415                interp_filter,
1416                &mut ya,
1417            );
1418            predict_inter(
1419                &r1.y,
1420                w,
1421                w,
1422                h,
1423                px,
1424                py,
1425                bw,
1426                bh,
1427                mv1.row,
1428                mv1.col,
1429                false,
1430                interp_filter,
1431                &mut yb,
1432            );
1433            avg_bytes(&ya, &yb, &mut y_pred);
1434            let mut ua = vec![0u8; cw_blk * ch_blk];
1435            let mut ub = vec![0u8; cw_blk * ch_blk];
1436            let mut va = vec![0u8; cw_blk * ch_blk];
1437            let mut vb = vec![0u8; cw_blk * ch_blk];
1438            predict_inter(
1439                &ref_recon.u,
1440                cw,
1441                cw,
1442                ch,
1443                cpx,
1444                cpy,
1445                cw_blk,
1446                ch_blk,
1447                mv.row,
1448                mv.col,
1449                true,
1450                interp_filter,
1451                &mut ua,
1452            );
1453            predict_inter(
1454                &r1.u,
1455                cw,
1456                cw,
1457                ch,
1458                cpx,
1459                cpy,
1460                cw_blk,
1461                ch_blk,
1462                mv1.row,
1463                mv1.col,
1464                true,
1465                interp_filter,
1466                &mut ub,
1467            );
1468            predict_inter(
1469                &ref_recon.v,
1470                cw,
1471                cw,
1472                ch,
1473                cpx,
1474                cpy,
1475                cw_blk,
1476                ch_blk,
1477                mv.row,
1478                mv.col,
1479                true,
1480                interp_filter,
1481                &mut va,
1482            );
1483            predict_inter(
1484                &r1.v,
1485                cw,
1486                cw,
1487                ch,
1488                cpx,
1489                cpy,
1490                cw_blk,
1491                ch_blk,
1492                mv1.row,
1493                mv1.col,
1494                true,
1495                interp_filter,
1496                &mut vb,
1497            );
1498            avg_bytes(&ua, &ub, &mut u_pred);
1499            avg_bytes(&va, &vb, &mut v_pred);
1500        } else {
1501            predict_inter(
1502                &ref_recon.y,
1503                w,
1504                w,
1505                h,
1506                px,
1507                py,
1508                bw,
1509                bh,
1510                mv.row,
1511                mv.col,
1512                false,
1513                interp_filter,
1514                &mut y_pred,
1515            );
1516            predict_inter(
1517                &ref_recon.u,
1518                cw,
1519                cw,
1520                ch,
1521                cpx,
1522                cpy,
1523                cw_blk,
1524                ch_blk,
1525                mv.row,
1526                mv.col,
1527                true,
1528                interp_filter,
1529                &mut u_pred,
1530            );
1531            predict_inter(
1532                &ref_recon.v,
1533                cw,
1534                cw,
1535                ch,
1536                cpx,
1537                cpy,
1538                cw_blk,
1539                ch_blk,
1540                mv.row,
1541                mv.col,
1542                true,
1543                interp_filter,
1544                &mut v_pred,
1545            );
1546        }
1547
1548        let segment_id = segment_id_for_mi_col(mi_col, self.mi_cols);
1549        let qindex = qindex_for_segment(segment_id);
1550
1551        let max_tx = max_tx_size_wh(bw_px, bh_px);
1552        let cand = if max_tx == TX_4X4 {
1553            [max_tx, max_tx]
1554        } else {
1555            [max_tx, max_tx - 1]
1556        };
1557        let cand = if max_tx == TX_4X4 {
1558            &cand[..1]
1559        } else {
1560            &cand[..]
1561        };
1562
1563        let mut best_tx = max_tx;
1564        let mut best_cost = u32::MAX;
1565        let mut best_any = true;
1566        for &tx in cand {
1567            let (cost, any) = self.score_block_tx(
1568                bw_px, bh_px, tx, &y_pred, &u_pred, &v_pred, w, cw, px, py, cpx, cpy, qindex,
1569            );
1570            // Prefer all-zero (skip); else lower coef cost; prefer smaller TX on ties.
1571            let better = (!any && best_any)
1572                || (any == best_any && (cost < best_cost || (cost == best_cost && tx < best_tx)));
1573            if better {
1574                best_tx = tx;
1575                best_cost = cost;
1576                best_any = any;
1577            }
1578        }
1579
1580        let skip = !best_any;
1581        let tx_size = if skip { max_tx } else { best_tx };
1582        self.write_inter_mode_bits(
1583            mi_row,
1584            mi_col,
1585            bw_px,
1586            bh_px,
1587            skip,
1588            tx_size,
1589            mode,
1590            ref_frame,
1591            second_ref,
1592            mv,
1593            mv1,
1594            interp_filter,
1595            segment_id,
1596        );
1597
1598        let mut y_recon = y_pred.clone();
1599        let mut u_recon = u_pred.clone();
1600        let mut v_recon = v_pred.clone();
1601        if !skip {
1602            let y_tiles =
1603                prepare_plane_tx(&y_pred, bw, bh, &self.src.y, w, px, py, tx_size, qindex);
1604            let uv_tx = uv_tx_size_wh(bw_px, bh_px, tx_size);
1605            let u_tiles = prepare_plane_tx(
1606                &u_pred,
1607                cw_blk,
1608                ch_blk,
1609                &self.src.u,
1610                cw,
1611                cpx,
1612                cpy,
1613                uv_tx,
1614                qindex,
1615            );
1616            let v_tiles = prepare_plane_tx(
1617                &v_pred,
1618                cw_blk,
1619                ch_blk,
1620                &self.src.v,
1621                cw,
1622                cpx,
1623                cpy,
1624                uv_tx,
1625                qindex,
1626            );
1627            self.emit_plane_tx(EntPlane::Y, &y_tiles, &mut y_recon, bw, tx_size, qindex);
1628            self.emit_plane_tx(EntPlane::U, &u_tiles, &mut u_recon, cw_blk, uv_tx, qindex);
1629            self.emit_plane_tx(EntPlane::V, &v_tiles, &mut v_recon, cw_blk, uv_tx, qindex);
1630        } else {
1631            self.clear_ent_block(mi_row, mi_col, bw_mi, bh_mi);
1632        }
1633
1634        store_plane(&mut self.recon_y, w, px, py, bw, bh, &y_recon);
1635        store_plane(&mut self.recon_u, cw, cpx, cpy, cw_blk, ch_blk, &u_recon);
1636        store_plane(&mut self.recon_v, cw, cpx, cpy, cw_blk, ch_blk, &v_recon);
1637
1638        self.store_mi(
1639            mi_row,
1640            mi_col,
1641            bw_mi,
1642            bh_mi,
1643            ResidualMi {
1644                skip,
1645                is_inter: true,
1646                ref_frame,
1647                second_ref,
1648                mode,
1649                mv,
1650                mv1,
1651                bw_px,
1652                bh_px,
1653                block_origin: true,
1654                tx_size,
1655                interp_filter,
1656            },
1657        );
1658    }
1659
1660    /// Coef-cost probe for one TX size (no bitstream writes).
1661    fn score_block_tx(
1662        &self,
1663        bw_px: u32,
1664        bh_px: u32,
1665        y_tx: u8,
1666        y_pred: &[u8],
1667        u_pred: &[u8],
1668        v_pred: &[u8],
1669        w: usize,
1670        cw: usize,
1671        px: usize,
1672        py: usize,
1673        cpx: usize,
1674        cpy: usize,
1675        qindex: usize,
1676    ) -> (u32, bool) {
1677        let bw = bw_px as usize;
1678        let bh = bh_px as usize;
1679        let uv_tx = uv_tx_size_wh(bw_px, bh_px, y_tx);
1680        let (mut cost, mut any) =
1681            score_plane_tx(y_pred, bw, bh, &self.src.y, w, px, py, y_tx, qindex);
1682        let cw_blk = bw / 2;
1683        let ch_blk = bh / 2;
1684        let (cu, au) = score_plane_tx(
1685            u_pred,
1686            cw_blk,
1687            ch_blk,
1688            &self.src.u,
1689            cw,
1690            cpx,
1691            cpy,
1692            uv_tx,
1693            qindex,
1694        );
1695        let (cv, av) = score_plane_tx(
1696            v_pred,
1697            cw_blk,
1698            ch_blk,
1699            &self.src.v,
1700            cw,
1701            cpx,
1702            cpy,
1703            uv_tx,
1704            qindex,
1705        );
1706        cost = cost.saturating_add(cu).saturating_add(cv);
1707        any |= au | av;
1708        (cost, any)
1709    }
1710
1711    fn emit_plane_tx(
1712        &mut self,
1713        ent: EntPlane,
1714        tiles: &[TxTile],
1715        recon: &mut [u8],
1716        bw: usize,
1717        tx: u8,
1718        qindex: usize,
1719    ) {
1720        let tx_px = tx_size_px(tx);
1721        let n4 = tx_px / 4;
1722        let is_y = matches!(ent, EntPlane::Y);
1723        let dc_q = dc_quant(qindex);
1724        let ac_q = ac_quant(qindex);
1725        for t in tiles {
1726            let ctx = self.ent_ctx(ent, t.x, t.y, n4);
1727            let eob = match tx {
1728                TX_4X4 => {
1729                    let mut q = [0i32; 16];
1730                    q.copy_from_slice(&t.q);
1731                    write_coefs_tx!(4, &mut self.bool, &q, is_y, ctx, dc_q, ac_q)
1732                }
1733                TX_8X8 => {
1734                    let mut q = [0i32; 64];
1735                    q.copy_from_slice(&t.q);
1736                    write_coefs_tx!(8, &mut self.bool, &q, is_y, ctx, dc_q, ac_q)
1737                }
1738                TX_16X16 => {
1739                    let mut q = [0i32; 256];
1740                    q.copy_from_slice(&t.q);
1741                    write_coefs_tx!(16, &mut self.bool, &q, is_y, ctx, dc_q, ac_q)
1742                }
1743                _ => {
1744                    let mut q = [0i32; 1024];
1745                    q.copy_from_slice(&t.q);
1746                    write_coefs_tx!(32, &mut self.bool, &q, is_y, ctx, dc_q, ac_q)
1747                }
1748            };
1749            self.set_ent(ent, t.x, t.y, n4, (eob > 0) as u8);
1750            match tx {
1751                TX_4X4 => {
1752                    let mut b = [0u8; 16];
1753                    b.copy_from_slice(&t.pred);
1754                    let mut dq = [0i32; 16];
1755                    dq.copy_from_slice(&t.dq);
1756                    idct_add_tx!(4, &dq, &mut b);
1757                    for r in 0..4 {
1758                        for c in 0..4 {
1759                            recon[(t.ly + r) * bw + t.lx + c] = b[r * 4 + c];
1760                        }
1761                    }
1762                }
1763                TX_8X8 => {
1764                    let mut b = [0u8; 64];
1765                    b.copy_from_slice(&t.pred);
1766                    let mut dq = [0i32; 64];
1767                    dq.copy_from_slice(&t.dq);
1768                    idct_add_tx!(8, &dq, &mut b);
1769                    for r in 0..8 {
1770                        for c in 0..8 {
1771                            recon[(t.ly + r) * bw + t.lx + c] = b[r * 8 + c];
1772                        }
1773                    }
1774                }
1775                TX_16X16 => {
1776                    let mut b = [0u8; 256];
1777                    b.copy_from_slice(&t.pred);
1778                    let mut dq = [0i32; 256];
1779                    dq.copy_from_slice(&t.dq);
1780                    idct_add_tx!(16, &dq, &mut b);
1781                    for r in 0..16 {
1782                        for c in 0..16 {
1783                            recon[(t.ly + r) * bw + t.lx + c] = b[r * 16 + c];
1784                        }
1785                    }
1786                }
1787                _ => {
1788                    let mut b = [0u8; 1024];
1789                    b.copy_from_slice(&t.pred);
1790                    let mut dq = [0i32; 1024];
1791                    dq.copy_from_slice(&t.dq);
1792                    idct_add_tx!(32, &dq, &mut b);
1793                    for r in 0..32 {
1794                        for c in 0..32 {
1795                            recon[(t.ly + r) * bw + t.lx + c] = b[r * 32 + c];
1796                        }
1797                    }
1798                }
1799            }
1800        }
1801    }
1802
1803    fn ent_ctx(&self, plane: EntPlane, x: usize, y: usize, n4: usize) -> usize {
1804        match plane {
1805            EntPlane::Y => {
1806                let a = (0..n4).any(|i| self.above_ent_y[x / 4 + i] != 0);
1807                let l = (0..n4).any(|i| self.left_ent_y[(y / 4 + i) & 15] != 0);
1808                a as usize + l as usize
1809            }
1810            EntPlane::U => {
1811                let a = (0..n4).any(|i| self.above_ent_u[x / 4 + i] != 0);
1812                let l = (0..n4).any(|i| self.left_ent_u[(y / 4 + i) & 7] != 0);
1813                a as usize + l as usize
1814            }
1815            EntPlane::V => {
1816                let a = (0..n4).any(|i| self.above_ent_v[x / 4 + i] != 0);
1817                let l = (0..n4).any(|i| self.left_ent_v[(y / 4 + i) & 7] != 0);
1818                a as usize + l as usize
1819            }
1820        }
1821    }
1822
1823    fn set_ent(&mut self, plane: EntPlane, x: usize, y: usize, n4: usize, has: u8) {
1824        match plane {
1825            EntPlane::Y => {
1826                for i in 0..n4 {
1827                    self.above_ent_y[x / 4 + i] = has;
1828                    self.left_ent_y[(y / 4 + i) & 15] = has;
1829                }
1830            }
1831            EntPlane::U => {
1832                for i in 0..n4 {
1833                    self.above_ent_u[x / 4 + i] = has;
1834                    self.left_ent_u[(y / 4 + i) & 7] = has;
1835                }
1836            }
1837            EntPlane::V => {
1838                for i in 0..n4 {
1839                    self.above_ent_v[x / 4 + i] = has;
1840                    self.left_ent_v[(y / 4 + i) & 7] = has;
1841                }
1842            }
1843        }
1844    }
1845
1846    fn clear_ent_block(&mut self, mi_row: usize, mi_col: usize, bw_mi: usize, bh_mi: usize) {
1847        for c in 0..bw_mi {
1848            if mi_col + c >= self.mi_cols {
1849                break;
1850            }
1851            for t in 0..2 {
1852                self.above_ent_y[(mi_col + c) * 2 + t] = 0;
1853            }
1854            self.above_ent_u[mi_col + c] = 0;
1855            self.above_ent_v[mi_col + c] = 0;
1856        }
1857        for r in 0..bh_mi {
1858            if mi_row + r >= self.mi_rows {
1859                break;
1860            }
1861            for t in 0..2 {
1862                self.left_ent_y[((mi_row + r) & 7) * 2 + t] = 0;
1863            }
1864            self.left_ent_u[(mi_row + r) & 7] = 0;
1865            self.left_ent_v[(mi_row + r) & 7] = 0;
1866        }
1867    }
1868
1869    fn write_inter_mode_bits(
1870        &mut self,
1871        mi_row: usize,
1872        mi_col: usize,
1873        bw_px: u32,
1874        bh_px: u32,
1875        skip: bool,
1876        tx_size: u8,
1877        mode: i8,
1878        ref_frame: i8,
1879        second_ref: i8,
1880        mv: Mv,
1881        mv1: Mv,
1882        interp_filter: InterpFilter,
1883        segment_id: u8,
1884    ) {
1885        write_segment_id(&mut self.bool, segment_id);
1886        let skip_ctx = self.skip_context(mi_row, mi_col);
1887        self.bool.put_bool(DEFAULT_SKIP_PROBS[skip_ctx], skip);
1888
1889        let ii_ctx = self.intra_inter_context(mi_row, mi_col);
1890        self.bool.put_bool(DEFAULT_INTRA_INTER_PROBS[ii_ctx], true);
1891
1892        // TX_MODE_SELECT: size is coded for inter blocks that are not skip.
1893        if !skip {
1894            self.write_selected_tx_size(mi_row, mi_col, bw_px, bh_px, tx_size);
1895        }
1896
1897        let compound = second_ref > INTRA_FRAME;
1898        match self.ref_mode {
1899            RefMode::Select => {
1900                let ctx = self.comp_inter_context(mi_row, mi_col);
1901                self.bool.put_bool(DEFAULT_COMP_INTER_PROBS[ctx], compound);
1902            }
1903            RefMode::Compound => debug_assert!(compound),
1904            RefMode::Single => debug_assert!(!compound),
1905        }
1906
1907        if compound {
1908            // idx = sign_bias[fixed]=1 → variable is ref_frame[0], fixed is ref_frame[1].
1909            let bit = ref_frame == COMP_VAR_REF[1];
1910            let ctx = self.comp_ref_context(mi_row, mi_col);
1911            self.bool.put_bool(DEFAULT_COMP_REF_PROBS[ctx], bit);
1912        } else {
1913            let ref_ctx = self.single_ref_p1_context(mi_row, mi_col);
1914            if ref_frame == LAST_FRAME {
1915                self.bool
1916                    .put_bool(DEFAULT_SINGLE_REF_PROBS[ref_ctx][0], false);
1917            } else {
1918                self.bool
1919                    .put_bool(DEFAULT_SINGLE_REF_PROBS[ref_ctx][0], true);
1920                let ctx2 = self.single_ref_p2_context(mi_row, mi_col);
1921                self.bool
1922                    .put_bool(DEFAULT_SINGLE_REF_PROBS[ctx2][1], ref_frame != GOLDEN_FRAME);
1923            }
1924        }
1925
1926        let mode_ctx = self.inter_mode_context(mi_row, mi_col, bw_px, bh_px);
1927        write_tree(
1928            &mut self.bool,
1929            &INTER_MODE_TREE,
1930            &DEFAULT_INTER_MODE_PROBS[mode_ctx],
1931            inter_mode_token(mode),
1932        );
1933
1934        let filt_ctx = self.switchable_interp_context(mi_row, mi_col);
1935        write_tree(
1936            &mut self.bool,
1937            &SWITCHABLE_INTERP_TREE,
1938            &DEFAULT_SWITCHABLE_INTERP_PROBS[filt_ctx],
1939            interp_filter as i8,
1940        );
1941
1942        if mode == NEWMV {
1943            let (nearest0, _) = self.ref_mvs(mi_row, mi_col, bw_px, bh_px, ref_frame);
1944            write_mv(&mut self.bool, mv, nearest0, false);
1945            if compound {
1946                let (nearest1, _) = self.ref_mvs(mi_row, mi_col, bw_px, bh_px, second_ref);
1947                write_mv(&mut self.bool, mv1, nearest1, false);
1948            }
1949        }
1950    }
1951
1952    fn switchable_interp_context(&self, mi_row: usize, mi_col: usize) -> usize {
1953        // `get_pred_context_switchable_interp` — missing neighbors use SWITCHABLE_FILTERS.
1954        let missing = InterpFilter::SWITCHABLE_FILTERS as usize;
1955        let left = if self.left_available(mi_col) {
1956            self.mi[mi_row * self.mi_cols + mi_col - 1].interp_filter as usize
1957        } else {
1958            missing
1959        };
1960        let above = if mi_row > 0 {
1961            self.mi[(mi_row - 1) * self.mi_cols + mi_col].interp_filter as usize
1962        } else {
1963            missing
1964        };
1965        if left == above {
1966            left
1967        } else if left == missing {
1968            above
1969        } else if above == missing {
1970            left
1971        } else {
1972            missing
1973        }
1974    }
1975
1976    fn pick_interp_filter(
1977        &self,
1978        px: usize,
1979        py: usize,
1980        bw: usize,
1981        bh: usize,
1982        w: usize,
1983        h: usize,
1984        mv: Mv,
1985        mv1: Mv,
1986        ref_frame: i8,
1987        second_ref: i8,
1988    ) -> InterpFilter {
1989        let subpel = (mv.row & 7) != 0
1990            || (mv.col & 7) != 0
1991            || (second_ref > INTRA_FRAME && ((mv1.row & 7) != 0 || (mv1.col & 7) != 0));
1992        if !subpel {
1993            return InterpFilter::EightTap;
1994        }
1995        let compound = second_ref > INTRA_FRAME;
1996        let ref0 = self.recon_for(ref_frame);
1997        let mut best = InterpFilter::EightTap;
1998        let mut best_sad = u32::MAX;
1999        for &f in &[
2000            InterpFilter::EightTap,
2001            InterpFilter::EightTapSmooth,
2002            InterpFilter::EightTapSharp,
2003        ] {
2004            let mut pred = vec![0u8; bw * bh];
2005            if compound {
2006                let ref1 = self.recon_for(second_ref);
2007                let mut a = vec![0u8; bw * bh];
2008                let mut b = vec![0u8; bw * bh];
2009                predict_inter(
2010                    &ref0.y, w, w, h, px, py, bw, bh, mv.row, mv.col, false, f, &mut a,
2011                );
2012                predict_inter(
2013                    &ref1.y, w, w, h, px, py, bw, bh, mv1.row, mv1.col, false, f, &mut b,
2014                );
2015                avg_bytes(&a, &b, &mut pred);
2016            } else {
2017                predict_inter(
2018                    &ref0.y, w, w, h, px, py, bw, bh, mv.row, mv.col, false, f, &mut pred,
2019                );
2020            }
2021            let mut sad = 0u32;
2022            for r in 0..bh {
2023                for c in 0..bw {
2024                    let s = self.src.y[(py + r) * w + px + c];
2025                    sad += u32::from(s.abs_diff(pred[r * bw + c]));
2026                }
2027            }
2028            if sad < best_sad || (sad == best_sad && (f as u8) < (best as u8)) {
2029                best_sad = sad;
2030                best = f;
2031            }
2032        }
2033        best
2034    }
2035
2036    fn write_selected_tx_size(
2037        &mut self,
2038        mi_row: usize,
2039        mi_col: usize,
2040        bw_px: u32,
2041        bh_px: u32,
2042        tx_size: u8,
2043    ) {
2044        let max_tx = max_tx_size_wh(bw_px, bh_px);
2045        let ctx = self.tx_size_context(mi_row, mi_col, max_tx);
2046        match max_tx {
2047            TX_8X8 => {
2048                self.bool
2049                    .put_bool(DEFAULT_TX_PROBS_8[ctx][0], tx_size != TX_4X4);
2050            }
2051            TX_16X16 => {
2052                let probs = &DEFAULT_TX_PROBS_16[ctx];
2053                self.bool.put_bool(probs[0], tx_size != TX_4X4);
2054                if tx_size != TX_4X4 {
2055                    self.bool.put_bool(probs[1], tx_size != TX_8X8);
2056                }
2057            }
2058            _ => {
2059                let probs = &DEFAULT_TX_PROBS_32[ctx];
2060                self.bool.put_bool(probs[0], tx_size != TX_4X4);
2061                if tx_size != TX_4X4 {
2062                    self.bool.put_bool(probs[1], tx_size != TX_8X8);
2063                    if tx_size != TX_8X8 {
2064                        self.bool.put_bool(probs[2], tx_size != TX_16X16);
2065                    }
2066                }
2067            }
2068        }
2069    }
2070
2071    /// `get_tx_size_context` — `(above + left) > max_tx_size`.
2072    fn tx_size_context(&self, mi_row: usize, mi_col: usize, max_tx: u8) -> usize {
2073        let has_above = mi_row > 0;
2074        let has_left = self.left_available(mi_col);
2075        let mut above_ctx = if has_above {
2076            let m = &self.mi[(mi_row - 1) * self.mi_cols + mi_col];
2077            if !m.skip {
2078                m.tx_size as i32
2079            } else {
2080                max_tx as i32
2081            }
2082        } else {
2083            max_tx as i32
2084        };
2085        let mut left_ctx = if has_left {
2086            let m = &self.mi[mi_row * self.mi_cols + mi_col - 1];
2087            if !m.skip {
2088                m.tx_size as i32
2089            } else {
2090                max_tx as i32
2091            }
2092        } else {
2093            max_tx as i32
2094        };
2095        if !has_left {
2096            left_ctx = above_ctx;
2097        }
2098        if !has_above {
2099            above_ctx = left_ctx;
2100        }
2101        ((above_ctx + left_ctx) > max_tx as i32) as usize
2102    }
2103
2104    fn store_mi(
2105        &mut self,
2106        mi_row: usize,
2107        mi_col: usize,
2108        bw_mi: usize,
2109        bh_mi: usize,
2110        info: ResidualMi,
2111    ) {
2112        for r in 0..bh_mi {
2113            for c in 0..bw_mi {
2114                if mi_row + r < self.mi_rows && mi_col + c < self.mi_cols {
2115                    self.mi[(mi_row + r) * self.mi_cols + mi_col + c] = ResidualMi {
2116                        block_origin: r == 0 && c == 0,
2117                        ..info
2118                    };
2119                }
2120            }
2121        }
2122    }
2123
2124    /// Pick LAST / GOLDEN / ALTREF (single) or LAST/GOLDEN+ALTREF compound by SAD.
2125    fn pick_ref_and_mode(
2126        &self,
2127        mi_row: usize,
2128        mi_col: usize,
2129        bw_px: u32,
2130        bh_px: u32,
2131        px: usize,
2132        py: usize,
2133        bw: usize,
2134        bh: usize,
2135        w: usize,
2136        h: usize,
2137    ) -> InterPick {
2138        let try_ref = |recon: &Reconstruction, ref_frame: i8| {
2139            let (nearest, near) = self.ref_mvs(mi_row, mi_col, bw_px, bh_px, ref_frame);
2140            let searched = search_mv(
2141                &self.src.y,
2142                w,
2143                &recon.y,
2144                w,
2145                w,
2146                h,
2147                px,
2148                py,
2149                bw,
2150                bh,
2151                DEFAULT_RANGE_PEL,
2152            );
2153            let (mv, mode) = pick_inter_mode(searched, nearest, near);
2154            let sad = sad_mv(&self.src.y, w, &recon.y, w, w, h, px, py, bw, bh, mv);
2155            (
2156                InterPick {
2157                    mv,
2158                    mv1: Mv::default(),
2159                    mode,
2160                    ref_frame,
2161                    second_ref: INTRA_FRAME,
2162                },
2163                sad as u64,
2164            )
2165        };
2166
2167        let mut best: Option<(InterPick, u64)> = None;
2168        if self.ref_mode != RefMode::Compound {
2169            best = Some(try_ref(self.reference, LAST_FRAME));
2170            if let Some(golden) = self.golden {
2171                let gold = try_ref(golden, GOLDEN_FRAME);
2172                if gold.1 <= best.as_ref().unwrap().1 {
2173                    best = Some(gold);
2174                }
2175            }
2176            if let Some(altref) = self.altref {
2177                let alt = try_ref(altref, ALTREF_FRAME);
2178                if alt.1 <= best.as_ref().unwrap().1 {
2179                    best = Some(alt);
2180                }
2181            }
2182        }
2183
2184        // Compound: fixed=ALTREF + var∈{LAST, GOLDEN}.
2185        if self.ref_mode == RefMode::Compound
2186            && let Some(alt) = self.altref
2187        {
2188            let try_comp = |var_recon: &Reconstruction, var_ref: i8| {
2189                let (n0, near0) = self.ref_mvs(mi_row, mi_col, bw_px, bh_px, var_ref);
2190                let (n1, near1) = self.ref_mvs(mi_row, mi_col, bw_px, bh_px, ALTREF_FRAME);
2191                let s0 = search_mv(
2192                    &self.src.y,
2193                    w,
2194                    &var_recon.y,
2195                    w,
2196                    w,
2197                    h,
2198                    px,
2199                    py,
2200                    bw,
2201                    bh,
2202                    DEFAULT_RANGE_PEL,
2203                );
2204                let s1 = search_mv(
2205                    &self.src.y,
2206                    w,
2207                    &alt.y,
2208                    w,
2209                    w,
2210                    h,
2211                    px,
2212                    py,
2213                    bw,
2214                    bh,
2215                    DEFAULT_RANGE_PEL,
2216                );
2217                // Independent searches are not jointly optimal — score the
2218                // standard mode candidates (incl. colocated ZEROMV).
2219                let cands = [
2220                    (Mv::default(), Mv::default(), ZEROMV),
2221                    (n0, n1, NEARESTMV),
2222                    (near0, near1, NEARMV),
2223                    (s0, s1, NEWMV),
2224                ];
2225                let mut best_c = None;
2226                for &(mv0, mv1, mode) in &cands {
2227                    let sad = sad_compound(
2228                        &self.src.y,
2229                        w,
2230                        &var_recon.y,
2231                        w,
2232                        &alt.y,
2233                        w,
2234                        w,
2235                        h,
2236                        px,
2237                        py,
2238                        bw,
2239                        bh,
2240                        mv0,
2241                        mv1,
2242                    );
2243                    let pick = InterPick {
2244                        mv: mv0,
2245                        mv1,
2246                        mode,
2247                        ref_frame: var_ref,
2248                        second_ref: ALTREF_FRAME,
2249                    };
2250                    match best_c {
2251                        None => best_c = Some((pick, sad)),
2252                        Some((_, s)) if sad < s => best_c = Some((pick, sad)),
2253                        _ => {}
2254                    }
2255                }
2256                best_c.unwrap()
2257            };
2258            let mut best_c = try_comp(self.reference, LAST_FRAME);
2259            if let Some(golden) = self.golden {
2260                let gold_c = try_comp(golden, GOLDEN_FRAME);
2261                if gold_c.1 < best_c.1 {
2262                    best_c = gold_c;
2263                }
2264            }
2265            return best_c.0;
2266        }
2267        // SELECT: also try compound when it strictly beats single.
2268        if self.ref_mode == RefMode::Select
2269            && let Some(alt) = self.altref
2270        {
2271            let try_comp = |var_recon: &Reconstruction, var_ref: i8| {
2272                let (n0, near0) = self.ref_mvs(mi_row, mi_col, bw_px, bh_px, var_ref);
2273                let (n1, near1) = self.ref_mvs(mi_row, mi_col, bw_px, bh_px, ALTREF_FRAME);
2274                let s0 = search_mv(
2275                    &self.src.y,
2276                    w,
2277                    &var_recon.y,
2278                    w,
2279                    w,
2280                    h,
2281                    px,
2282                    py,
2283                    bw,
2284                    bh,
2285                    DEFAULT_RANGE_PEL,
2286                );
2287                let s1 = search_mv(
2288                    &self.src.y,
2289                    w,
2290                    &alt.y,
2291                    w,
2292                    w,
2293                    h,
2294                    px,
2295                    py,
2296                    bw,
2297                    bh,
2298                    DEFAULT_RANGE_PEL,
2299                );
2300                let cands = [
2301                    (Mv::default(), Mv::default(), ZEROMV),
2302                    (n0, n1, NEARESTMV),
2303                    (near0, near1, NEARMV),
2304                    (s0, s1, NEWMV),
2305                ];
2306                let mut best_c = None;
2307                for &(mv0, mv1, mode) in &cands {
2308                    let sad = sad_compound(
2309                        &self.src.y,
2310                        w,
2311                        &var_recon.y,
2312                        w,
2313                        &alt.y,
2314                        w,
2315                        w,
2316                        h,
2317                        px,
2318                        py,
2319                        bw,
2320                        bh,
2321                        mv0,
2322                        mv1,
2323                    );
2324                    let pick = InterPick {
2325                        mv: mv0,
2326                        mv1,
2327                        mode,
2328                        ref_frame: var_ref,
2329                        second_ref: ALTREF_FRAME,
2330                    };
2331                    match best_c {
2332                        None => best_c = Some((pick, sad)),
2333                        Some((_, s)) if sad < s => best_c = Some((pick, sad)),
2334                        _ => {}
2335                    }
2336                }
2337                best_c.unwrap()
2338            };
2339            let last_c = try_comp(self.reference, LAST_FRAME);
2340            if last_c.1 < best.as_ref().unwrap().1 {
2341                best = Some(last_c);
2342            }
2343            if let Some(golden) = self.golden {
2344                let gold_c = try_comp(golden, GOLDEN_FRAME);
2345                if gold_c.1 < best.as_ref().unwrap().1 {
2346                    best = Some(gold_c);
2347                }
2348            }
2349        }
2350        best.expect("no inter pick").0
2351    }
2352
2353    fn recon_for(&self, ref_frame: i8) -> &'a Reconstruction {
2354        match ref_frame {
2355            GOLDEN_FRAME => self.golden.unwrap_or(self.reference),
2356            ALTREF_FRAME => self.altref.unwrap_or(self.reference),
2357            _ => self.reference,
2358        }
2359    }
2360
2361    /// Neighbor offsets for `mv_ref_blocks` / mode-context first two slots.
2362    fn mv_ref_neighbors(bw_px: u32, bh_px: u32) -> &'static [(i32, i32)] {
2363        match (bw_px, bh_px) {
2364            (8, 16) => &[
2365                (0, -1),
2366                (-1, 0),
2367                (1, -1),
2368                (-1, -1),
2369                (0, -2),
2370                (-2, 0),
2371                (-2, -1),
2372                (-1, -2),
2373            ],
2374            (16, 8) => &[
2375                (-1, 0),
2376                (0, -1),
2377                (-1, 1),
2378                (-1, -1),
2379                (-2, 0),
2380                (0, -2),
2381                (-1, -2),
2382                (-2, -1),
2383            ],
2384            (16, 32) => &[
2385                (0, -1),
2386                (-1, 0),
2387                (2, -1),
2388                (-1, -1),
2389                (-1, 1),
2390                (0, -3),
2391                (-3, 0),
2392                (-3, -3),
2393            ],
2394            (32, 16) => &[
2395                (-1, 0),
2396                (0, -1),
2397                (-1, 2),
2398                (-1, -1),
2399                (1, -1),
2400                (-3, 0),
2401                (0, -3),
2402                (-3, -3),
2403            ],
2404            (32, 64) => &[
2405                (0, -1),
2406                (-1, 0),
2407                (4, -1),
2408                (-1, 2),
2409                (-1, -1),
2410                (0, -3),
2411                (-3, 0),
2412                (2, -1),
2413            ],
2414            (64, 32) => &[
2415                (-1, 0),
2416                (0, -1),
2417                (-1, 4),
2418                (2, -1),
2419                (-1, -1),
2420                (-3, 0),
2421                (0, -3),
2422                (-1, 2),
2423            ],
2424            (64, 64) => &[
2425                (-1, 3),
2426                (3, -1),
2427                (-1, 4),
2428                (4, -1),
2429                (-1, -1),
2430                (-1, 0),
2431                (0, -1),
2432                (-1, 6),
2433            ],
2434            (32, 32) => &[
2435                (-1, 1),
2436                (1, -1),
2437                (-1, 2),
2438                (2, -1),
2439                (-1, -1),
2440                (-3, 0),
2441                (0, -3),
2442                (-3, -3),
2443            ],
2444            (16, 16) => &[
2445                (-1, 0),
2446                (0, -1),
2447                (-1, 1),
2448                (1, -1),
2449                (-1, -1),
2450                (-3, 0),
2451                (0, -3),
2452                (-3, -3),
2453            ],
2454            _ => &[
2455                (-1, 0),
2456                (0, -1),
2457                (-1, -1),
2458                (-2, 0),
2459                (0, -2),
2460                (-2, -1),
2461                (-1, -2),
2462                (-2, -2),
2463            ],
2464        }
2465    }
2466
2467    /// Nearest + near MVs for `ref_frame` (`find_mv_refs_idx`).
2468    fn ref_mvs(
2469        &self,
2470        mi_row: usize,
2471        mi_col: usize,
2472        bw_px: u32,
2473        bh_px: u32,
2474        ref_frame: i8,
2475    ) -> (Mv, Mv) {
2476        let nbrs = Self::mv_ref_neighbors(bw_px, bh_px);
2477        let bw_mi = (bw_px / 8) as usize;
2478        let bh_mi = (bh_px / 8) as usize;
2479        let mut list = [Mv::default(); 2];
2480        let mut count = 0usize;
2481        let clamp = |cand: Mv| {
2482            clamp_mv_ref(
2483                cand,
2484                mi_row,
2485                mi_col,
2486                self.mi_rows,
2487                self.mi_cols,
2488                bw_mi,
2489                bh_mi,
2490            )
2491        };
2492        let add = |list: &mut [Mv; 2], count: &mut usize, cand: Mv| -> bool {
2493            let cand = clamp(cand);
2494            if *count == 0 {
2495                list[0] = cand;
2496                *count = 1;
2497                false
2498            } else if cand != list[0] {
2499                list[1] = cand;
2500                true
2501            } else {
2502                false
2503            }
2504        };
2505        let mut different_ref_found = false;
2506        for &(dr, dc) in nbrs {
2507            let r = mi_row as i32 + dr;
2508            let c = mi_col as i32 + dc;
2509            if !self.mi_in_tile(r, c) {
2510                continue;
2511            }
2512            different_ref_found = true;
2513            let n = &self.mi[r as usize * self.mi_cols + c as usize];
2514            if n.is_inter && n.ref_frame == ref_frame {
2515                if add(&mut list, &mut count, n.mv) {
2516                    return (list[0], list[1]);
2517                }
2518            } else if n.is_inter && n.second_ref == ref_frame && add(&mut list, &mut count, n.mv1) {
2519                return (list[0], list[1]);
2520            }
2521        }
2522        // `IF_DIFF_REF_FRAME_ADD_MV` — negate when sign biases differ.
2523        if different_ref_found && count < 2 {
2524            for &(dr, dc) in nbrs {
2525                let r = mi_row as i32 + dr;
2526                let c = mi_col as i32 + dc;
2527                if !self.mi_in_tile(r, c) {
2528                    continue;
2529                }
2530                let n = &self.mi[r as usize * self.mi_cols + c as usize];
2531                if !n.is_inter {
2532                    continue;
2533                }
2534                if n.ref_frame != ref_frame
2535                    && add(
2536                        &mut list,
2537                        &mut count,
2538                        scale_mv_for_ref(n.mv, n.ref_frame, ref_frame),
2539                    )
2540                {
2541                    return (list[0], list[1]);
2542                }
2543                if n.second_ref > INTRA_FRAME
2544                    && n.second_ref != ref_frame
2545                    && n.mv1 != n.mv
2546                    && add(
2547                        &mut list,
2548                        &mut count,
2549                        scale_mv_for_ref(n.mv1, n.second_ref, ref_frame),
2550                    )
2551                {
2552                    return (list[0], list[1]);
2553                }
2554            }
2555        }
2556        (list[0], list[1])
2557    }
2558
2559    fn skip_context(&self, mi_row: usize, mi_col: usize) -> usize {
2560        let above = if mi_row > 0 {
2561            self.mi[(mi_row - 1) * self.mi_cols + mi_col].skip as usize
2562        } else {
2563            0
2564        };
2565        let left = if self.left_available(mi_col) {
2566            self.mi[mi_row * self.mi_cols + (mi_col - 1)].skip as usize
2567        } else {
2568            0
2569        };
2570        above + left
2571    }
2572
2573    fn intra_inter_context(&self, mi_row: usize, mi_col: usize) -> usize {
2574        let above = if mi_row > 0 {
2575            Some(&self.mi[(mi_row - 1) * self.mi_cols + mi_col])
2576        } else {
2577            None
2578        };
2579        let left = if self.left_available(mi_col) {
2580            Some(&self.mi[mi_row * self.mi_cols + (mi_col - 1)])
2581        } else {
2582            None
2583        };
2584        match (above, left) {
2585            (Some(a), Some(l)) => {
2586                let ai = !a.is_inter;
2587                let li = !l.is_inter;
2588                if li && ai {
2589                    3
2590                } else if li || ai {
2591                    1
2592                } else {
2593                    0
2594                }
2595            }
2596            (Some(e), None) | (None, Some(e)) => 2 * (!e.is_inter as usize),
2597            (None, None) => 0,
2598        }
2599    }
2600
2601    /// Inter-mode entropy context from the first two `mv_ref_blocks` neighbors
2602    /// (`find_mv_refs_idx` / `mode_context[ref_frame]`).
2603    fn inter_mode_context(&self, mi_row: usize, mi_col: usize, bw_px: u32, bh_px: u32) -> usize {
2604        let nbrs = Self::mv_ref_neighbors(bw_px, bh_px);
2605        let mut counter = 0i32;
2606        for &(dr, dc) in nbrs.iter().take(2) {
2607            let r = mi_row as i32 + dr;
2608            let c = mi_col as i32 + dc;
2609            if !self.mi_in_tile(r, c) {
2610                continue;
2611            }
2612            counter += mode_2_counter(self.mi[r as usize * self.mi_cols + c as usize].mode);
2613        }
2614        counter_to_inter_mode_ctx(counter)
2615    }
2616
2617    fn single_ref_p1_context(&self, mi_row: usize, mi_col: usize) -> usize {
2618        let above = if mi_row > 0 {
2619            Some(&self.mi[(mi_row - 1) * self.mi_cols + mi_col])
2620        } else {
2621            None
2622        };
2623        let left = if self.left_available(mi_col) {
2624            Some(&self.mi[mi_row * self.mi_cols + (mi_col - 1)])
2625        } else {
2626            None
2627        };
2628        match (above, left) {
2629            (Some(a), Some(l)) => {
2630                let ai = !a.is_inter;
2631                let li = !l.is_inter;
2632                if ai && li {
2633                    2
2634                } else if ai || li {
2635                    let edge = if ai { l } else { a };
2636                    if !edge.is_compound() {
2637                        4 * (edge.ref_frame == LAST_FRAME) as usize
2638                    } else {
2639                        1 + (edge.ref_frame == LAST_FRAME || edge.second_ref == LAST_FRAME) as usize
2640                    }
2641                } else {
2642                    let a2 = a.is_compound();
2643                    let l2 = l.is_compound();
2644                    if a2 && l2 {
2645                        1 + (a.ref_frame == LAST_FRAME
2646                            || a.second_ref == LAST_FRAME
2647                            || l.ref_frame == LAST_FRAME
2648                            || l.second_ref == LAST_FRAME) as usize
2649                    } else if a2 || l2 {
2650                        let rfs = if !a2 { a.ref_frame } else { l.ref_frame };
2651                        let (crf1, crf2) = if a2 {
2652                            (a.ref_frame, a.second_ref)
2653                        } else {
2654                            (l.ref_frame, l.second_ref)
2655                        };
2656                        if rfs == LAST_FRAME {
2657                            3 + (crf1 == LAST_FRAME || crf2 == LAST_FRAME) as usize
2658                        } else {
2659                            (crf1 == LAST_FRAME || crf2 == LAST_FRAME) as usize
2660                        }
2661                    } else {
2662                        2 * (a.ref_frame == LAST_FRAME) as usize
2663                            + 2 * (l.ref_frame == LAST_FRAME) as usize
2664                    }
2665                }
2666            }
2667            (Some(e), None) | (None, Some(e)) => {
2668                if !e.is_inter {
2669                    2
2670                } else if !e.is_compound() {
2671                    4 * (e.ref_frame == LAST_FRAME) as usize
2672                } else {
2673                    1 + (e.ref_frame == LAST_FRAME || e.second_ref == LAST_FRAME) as usize
2674                }
2675            }
2676            (None, None) => 2,
2677        }
2678    }
2679
2680    /// `vp9_get_pred_context_single_ref_p2` (handles compound neighbors).
2681    fn single_ref_p2_context(&self, mi_row: usize, mi_col: usize) -> usize {
2682        let above = if mi_row > 0 {
2683            Some(&self.mi[(mi_row - 1) * self.mi_cols + mi_col])
2684        } else {
2685            None
2686        };
2687        let left = if self.left_available(mi_col) {
2688            Some(&self.mi[mi_row * self.mi_cols + (mi_col - 1)])
2689        } else {
2690            None
2691        };
2692        match (above, left) {
2693            (Some(a), Some(l)) => {
2694                let ai = !a.is_inter;
2695                let li = !l.is_inter;
2696                if ai && li {
2697                    2
2698                } else if ai || li {
2699                    let edge = if ai { l } else { a };
2700                    if !edge.is_compound() {
2701                        if edge.ref_frame == LAST_FRAME {
2702                            3
2703                        } else {
2704                            4 * (edge.ref_frame == GOLDEN_FRAME) as usize
2705                        }
2706                    } else {
2707                        1 + 2
2708                            * (edge.ref_frame == GOLDEN_FRAME || edge.second_ref == GOLDEN_FRAME)
2709                                as usize
2710                    }
2711                } else {
2712                    let a2 = a.is_compound();
2713                    let l2 = l.is_compound();
2714                    if a2 && l2 {
2715                        if a.ref_frame == l.ref_frame && a.second_ref == l.second_ref {
2716                            3 * (a.ref_frame == GOLDEN_FRAME
2717                                || a.second_ref == GOLDEN_FRAME
2718                                || l.ref_frame == GOLDEN_FRAME
2719                                || l.second_ref == GOLDEN_FRAME)
2720                                as usize
2721                        } else {
2722                            2
2723                        }
2724                    } else if a2 || l2 {
2725                        let rfs = if !a2 { a.ref_frame } else { l.ref_frame };
2726                        let (crf1, crf2) = if a2 {
2727                            (a.ref_frame, a.second_ref)
2728                        } else {
2729                            (l.ref_frame, l.second_ref)
2730                        };
2731                        if rfs == GOLDEN_FRAME {
2732                            3 + (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME) as usize
2733                        } else if rfs == ALTREF_FRAME {
2734                            (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME) as usize
2735                        } else {
2736                            1 + 2 * (crf1 == GOLDEN_FRAME || crf2 == GOLDEN_FRAME) as usize
2737                        }
2738                    } else if a.ref_frame == LAST_FRAME && l.ref_frame == LAST_FRAME {
2739                        3
2740                    } else if a.ref_frame == LAST_FRAME || l.ref_frame == LAST_FRAME {
2741                        let edge0 = if a.ref_frame == LAST_FRAME {
2742                            l.ref_frame
2743                        } else {
2744                            a.ref_frame
2745                        };
2746                        4 * (edge0 == GOLDEN_FRAME) as usize
2747                    } else {
2748                        2 * (a.ref_frame == GOLDEN_FRAME) as usize
2749                            + 2 * (l.ref_frame == GOLDEN_FRAME) as usize
2750                    }
2751                }
2752            }
2753            (Some(e), None) | (None, Some(e)) => {
2754                if !e.is_inter || (e.ref_frame == LAST_FRAME && !e.is_compound()) {
2755                    2
2756                } else if !e.is_compound() {
2757                    4 * (e.ref_frame == GOLDEN_FRAME) as usize
2758                } else {
2759                    3 * (e.ref_frame == GOLDEN_FRAME || e.second_ref == GOLDEN_FRAME) as usize
2760                }
2761            }
2762            (None, None) => 2,
2763        }
2764    }
2765
2766    /// `vp9_get_reference_mode_context` — compound vs single bit.
2767    fn comp_inter_context(&self, mi_row: usize, mi_col: usize) -> usize {
2768        let above = if mi_row > 0 {
2769            Some(&self.mi[(mi_row - 1) * self.mi_cols + mi_col])
2770        } else {
2771            None
2772        };
2773        let left = if self.left_available(mi_col) {
2774            Some(&self.mi[mi_row * self.mi_cols + (mi_col - 1)])
2775        } else {
2776            None
2777        };
2778        match (above, left) {
2779            (Some(a), Some(l)) => {
2780                if !a.is_compound() && !l.is_compound() {
2781                    (a.ref_frame == COMP_FIXED_REF) as usize
2782                        ^ (l.ref_frame == COMP_FIXED_REF) as usize
2783                } else if !a.is_compound() {
2784                    2 + (a.ref_frame == COMP_FIXED_REF || !a.is_inter) as usize
2785                } else if !l.is_compound() {
2786                    2 + (l.ref_frame == COMP_FIXED_REF || !l.is_inter) as usize
2787                } else {
2788                    4
2789                }
2790            }
2791            (Some(e), None) | (None, Some(e)) => {
2792                if !e.is_compound() {
2793                    (e.ref_frame == COMP_FIXED_REF) as usize
2794                } else {
2795                    3
2796                }
2797            }
2798            (None, None) => 1,
2799        }
2800    }
2801
2802    /// `vp9_get_pred_context_comp_ref_p` — variable ref LAST vs GOLDEN.
2803    fn comp_ref_context(&self, mi_row: usize, mi_col: usize) -> usize {
2804        // fix_ref_idx = sign_bias[ALTREF] = 1 → var_ref_idx = 0 (variable in ref_frame[0]).
2805        let above = if mi_row > 0 {
2806            Some(&self.mi[(mi_row - 1) * self.mi_cols + mi_col])
2807        } else {
2808            None
2809        };
2810        let left = if self.left_available(mi_col) {
2811            Some(&self.mi[mi_row * self.mi_cols + (mi_col - 1)])
2812        } else {
2813            None
2814        };
2815        let var_of = |m: &ResidualMi| -> i8 {
2816            if m.is_compound() {
2817                m.ref_frame // var at [0]
2818            } else {
2819                m.ref_frame
2820            }
2821        };
2822        match (above, left) {
2823            (Some(a), Some(l)) => {
2824                let ai = !a.is_inter;
2825                let li = !l.is_inter;
2826                if ai && li {
2827                    2
2828                } else if ai || li {
2829                    let edge = if ai { l } else { a };
2830                    if !edge.is_compound() {
2831                        1 + 2 * (edge.ref_frame != COMP_VAR_REF[1]) as usize
2832                    } else {
2833                        1 + 2 * (edge.ref_frame != COMP_VAR_REF[1]) as usize
2834                    }
2835                } else {
2836                    let a_sg = !a.is_compound();
2837                    let l_sg = !l.is_compound();
2838                    let vrfa = var_of(a);
2839                    let vrfl = var_of(l);
2840                    if vrfa == vrfl && COMP_VAR_REF[1] == vrfa {
2841                        0
2842                    } else if l_sg && a_sg {
2843                        if (vrfa == COMP_FIXED_REF && vrfl == COMP_VAR_REF[0])
2844                            || (vrfl == COMP_FIXED_REF && vrfa == COMP_VAR_REF[0])
2845                        {
2846                            4
2847                        } else if vrfa == vrfl {
2848                            3
2849                        } else {
2850                            1
2851                        }
2852                    } else if l_sg || a_sg {
2853                        let vrfc = if l_sg { vrfa } else { vrfl };
2854                        let rfs = if a_sg { vrfa } else { vrfl };
2855                        if vrfc == COMP_VAR_REF[1] && rfs != COMP_VAR_REF[1] {
2856                            1
2857                        } else if rfs == COMP_VAR_REF[1] && vrfc != COMP_VAR_REF[1] {
2858                            2
2859                        } else {
2860                            4
2861                        }
2862                    } else if vrfa == vrfl {
2863                        4
2864                    } else {
2865                        2
2866                    }
2867                }
2868            }
2869            (Some(e), None) | (None, Some(e)) => {
2870                if !e.is_inter {
2871                    2
2872                } else if e.is_compound() {
2873                    4 * (e.ref_frame != COMP_VAR_REF[1]) as usize
2874                } else {
2875                    3 * (e.ref_frame != COMP_VAR_REF[1]) as usize
2876                }
2877            }
2878            (None, None) => 2,
2879        }
2880    }
2881}
2882
2883/// Map inter mode to [`INTER_MODE_TREE`] leaf token (`INTER_OFFSET`).
2884fn inter_mode_token(mode: i8) -> i8 {
2885    match mode {
2886        NEARESTMV => INTER_OFFSET_NEARESTMV,
2887        NEARMV => INTER_OFFSET_NEARMV,
2888        ZEROMV => INTER_OFFSET_ZEROMV,
2889        NEWMV => INTER_OFFSET_NEWMV,
2890        _ => panic!("not an inter mode: {mode}"),
2891    }
2892}
2893
2894/// SAD of source vs average of two EIGHTTAP predictions.
2895fn sad_compound(
2896    src: &[u8],
2897    src_stride: usize,
2898    ref0: &[u8],
2899    ref0_stride: usize,
2900    ref1: &[u8],
2901    ref1_stride: usize,
2902    ref_w: usize,
2903    ref_h: usize,
2904    x: usize,
2905    y: usize,
2906    bw: usize,
2907    bh: usize,
2908    mv0: Mv,
2909    mv1: Mv,
2910) -> u64 {
2911    let mut a = vec![0u8; bw * bh];
2912    let mut b = vec![0u8; bw * bh];
2913    predict_inter(
2914        ref0,
2915        ref0_stride,
2916        ref_w,
2917        ref_h,
2918        x,
2919        y,
2920        bw,
2921        bh,
2922        mv0.row,
2923        mv0.col,
2924        false,
2925        InterpFilter::EightTap,
2926        &mut a,
2927    );
2928    predict_inter(
2929        ref1,
2930        ref1_stride,
2931        ref_w,
2932        ref_h,
2933        x,
2934        y,
2935        bw,
2936        bh,
2937        mv1.row,
2938        mv1.col,
2939        false,
2940        InterpFilter::EightTap,
2941        &mut b,
2942    );
2943    let mut sad = 0u64;
2944    for r in 0..bh {
2945        for c in 0..bw {
2946            let pred = ((u16::from(a[r * bw + c]) + u16::from(b[r * bw + c]) + 1) >> 1) as u8;
2947            let s = src[(y + r) * src_stride + (x + c)];
2948            sad += u64::from(s.abs_diff(pred));
2949        }
2950    }
2951    sad
2952}
2953
2954/// Prefer predicted modes when the searched MV matches a ref candidate.
2955fn pick_inter_mode(best: Mv, nearest: Mv, near: Mv) -> (Mv, i8) {
2956    if best == Mv::default() {
2957        (Mv::default(), ZEROMV)
2958    } else if best == nearest {
2959        (nearest, NEARESTMV)
2960    } else if best == near {
2961        (near, NEARMV)
2962    } else {
2963        (best, NEWMV)
2964    }
2965}
2966
2967/// `clamp_mv_ref` (`MV_BORDER = 16 << 3`); `bw_mi`/`bh_mi` are block size in MI units.
2968fn clamp_mv_ref(
2969    mv: Mv,
2970    mi_row: usize,
2971    mi_col: usize,
2972    mi_rows: usize,
2973    mi_cols: usize,
2974    bw_mi: usize,
2975    bh_mi: usize,
2976) -> Mv {
2977    const MV_BORDER: i32 = 16 << 3;
2978    const MI_SIZE: i32 = 8;
2979    let left = -(mi_col as i32 * MI_SIZE * 8) - MV_BORDER;
2980    let right = ((mi_cols as i32) - bw_mi as i32 - mi_col as i32) * MI_SIZE * 8 + MV_BORDER;
2981    let top = -(mi_row as i32 * MI_SIZE * 8) - MV_BORDER;
2982    let bottom = ((mi_rows as i32) - bh_mi as i32 - mi_row as i32) * MI_SIZE * 8 + MV_BORDER;
2983    Mv {
2984        row: (i32::from(mv.row)).clamp(top, bottom) as i16,
2985        col: (i32::from(mv.col)).clamp(left, right) as i16,
2986    }
2987}
2988
2989fn compressed_header_inter(ref_mode: RefMode) -> Vec<u8> {
2990    let mut e = BoolEncoder::new();
2991    e.put_literal(3, 2); // tx_mode base = ALLOW_32X32
2992    e.put_bit(true); // TX_MODE_SELECT
2993                     // tx_probs: p8x8 (2×1) + p16x16 (2×2) + p32x32 (2×3) = 12 no-updates
2994    for _ in 0..(2 + 2 * 2 + 2 * 3) {
2995        e.put_bool(DIFF_UPDATE_PROB, false);
2996    }
2997    e.put_bit(false); // TX_4X4 coef probs: no update
2998    e.put_bit(false); // TX_8X8 coef probs: no update
2999    e.put_bit(false); // TX_16X16 coef probs: no update
3000    e.put_bit(false); // TX_32X32 coef probs: no update
3001    for _ in 0..3 {
3002        e.put_bool(DIFF_UPDATE_PROB, false);
3003    }
3004    for _ in 0..(7 * 3) {
3005        e.put_bool(DIFF_UPDATE_PROB, false);
3006    }
3007    // switchable_interp_probs: 4 contexts × 2
3008    for _ in 0..(4 * 2) {
3009        e.put_bool(DIFF_UPDATE_PROB, false);
3010    }
3011    for _ in 0..4 {
3012        e.put_bool(DIFF_UPDATE_PROB, false);
3013    }
3014    // reference_mode (compound allowed: ALTREF sign-bias differs)
3015    match ref_mode {
3016        RefMode::Single => {
3017            e.put_bit(false);
3018            for _ in 0..(5 * 2) {
3019                e.put_bool(DIFF_UPDATE_PROB, false);
3020            }
3021        }
3022        RefMode::Compound => {
3023            e.put_bit(true);
3024            e.put_bit(false);
3025            for _ in 0..5 {
3026                e.put_bool(DIFF_UPDATE_PROB, false);
3027            }
3028        }
3029        RefMode::Select => {
3030            e.put_bit(true);
3031            e.put_bit(true);
3032            for _ in 0..5 {
3033                e.put_bool(DIFF_UPDATE_PROB, false);
3034            }
3035            for _ in 0..(5 * 2) {
3036                e.put_bool(DIFF_UPDATE_PROB, false);
3037            }
3038            for _ in 0..5 {
3039                e.put_bool(DIFF_UPDATE_PROB, false);
3040            }
3041        }
3042    }
3043    for _ in 0..(4 * 9) {
3044        e.put_bool(DIFF_UPDATE_PROB, false);
3045    }
3046    for _ in 0..(16 * 3) {
3047        e.put_bool(DIFF_UPDATE_PROB, false);
3048    }
3049    for _ in 0..nmv_update_count(false) {
3050        e.put_bool(DIFF_UPDATE_PROB, false);
3051    }
3052    e.finish()
3053}
3054
3055fn nmv_update_count(allow_hp: bool) -> usize {
3056    let mut n = 3 + 2 * (1 + 10 + 1 + 10) + 2 * (2 * 3 + 3);
3057    if allow_hp {
3058        n += 2 * (1 + 1);
3059    }
3060    n
3061}
3062
3063fn apply_loop_filter(recon: &mut Reconstruction, lf_mi: &[LfMi], mi_rows: usize, mi_cols: usize) {
3064    if FILTER_LEVEL == 0 {
3065        return;
3066    }
3067    let w = recon.width as usize;
3068    let h = recon.height as usize;
3069    let sb_w = w.div_ceil(64) * 64;
3070    let sb_h = h.div_ceil(64) * 64;
3071    let (cw, ch) = (w / 2, h / 2);
3072    let (sb_cw, sb_ch) = (sb_w / 2, sb_h / 2);
3073
3074    let mut y = vec![0u8; sb_w * sb_h];
3075    let mut u = vec![0u8; sb_cw * sb_ch];
3076    let mut v = vec![0u8; sb_cw * sb_ch];
3077    for row in 0..h {
3078        y[row * sb_w..row * sb_w + w].copy_from_slice(&recon.y[row * w..row * w + w]);
3079        for col in w..sb_w {
3080            y[row * sb_w + col] = recon.y[row * w + w - 1];
3081        }
3082    }
3083    for row in h..sb_h {
3084        y.copy_within((h - 1) * sb_w..(h - 1) * sb_w + sb_w, row * sb_w);
3085    }
3086    for row in 0..ch {
3087        u[row * sb_cw..row * sb_cw + cw].copy_from_slice(&recon.u[row * cw..row * cw + cw]);
3088        v[row * sb_cw..row * sb_cw + cw].copy_from_slice(&recon.v[row * cw..row * cw + cw]);
3089        for col in cw..sb_cw {
3090            u[row * sb_cw + col] = recon.u[row * cw + cw - 1];
3091            v[row * sb_cw + col] = recon.v[row * cw + cw - 1];
3092        }
3093    }
3094    for row in ch..sb_ch {
3095        u.copy_within((ch - 1) * sb_cw..(ch - 1) * sb_cw + sb_cw, row * sb_cw);
3096        v.copy_within((ch - 1) * sb_cw..(ch - 1) * sb_cw + sb_cw, row * sb_cw);
3097    }
3098
3099    loop_filter_frame(
3100        &mut y,
3101        sb_w,
3102        &mut u,
3103        &mut v,
3104        sb_cw,
3105        w,
3106        h,
3107        lf_mi,
3108        mi_rows,
3109        mi_cols,
3110        FILTER_LEVEL,
3111        FILTER_SHARPNESS,
3112    );
3113
3114    for row in 0..h {
3115        recon.y[row * w..row * w + w].copy_from_slice(&y[row * sb_w..row * sb_w + w]);
3116    }
3117    for row in 0..ch {
3118        recon.u[row * cw..row * cw + cw].copy_from_slice(&u[row * sb_cw..row * sb_cw + cw]);
3119        recon.v[row * cw..row * cw + cw].copy_from_slice(&v[row * sb_cw..row * sb_cw + cw]);
3120    }
3121}
3122
3123fn lf_mi_from_residual(mi: &[ResidualMi]) -> Vec<LfMi> {
3124    mi.iter()
3125        .map(|m| LfMi {
3126            skip: m.skip,
3127            is_inter: m.is_inter,
3128            tx_size_y: m.tx_size,
3129            bw_mi: (m.bw_px / 8) as u8,
3130            bh_mi: (m.bh_px / 8) as u8,
3131            bsize_idx: partition_ctx_index_wh(m.bw_px, m.bh_px),
3132            block_origin: m.block_origin,
3133            // Compound uses ref_frame[0] (variable ref) for LF level lookup.
3134            level: lf_level_for_mi(FILTER_LEVEL, m.ref_frame, m.mode),
3135        })
3136        .collect()
3137}
3138
3139fn segment_id_for_mi_col(mi_col: usize, mi_cols: usize) -> u8 {
3140    // Right half of the frame → segment 1 (ALT_Q); left half → segment 0.
3141    if mi_col >= mi_cols / 2 {
3142        1
3143    } else {
3144        0
3145    }
3146}
3147
3148fn qindex_for_segment(segment_id: u8) -> usize {
3149    if segment_id == 1 {
3150        (QINDEX as i32 + SEG1_ALT_Q_DELTA).clamp(0, MAXQ) as usize
3151    } else {
3152        QINDEX_USIZE
3153    }
3154}
3155
3156/// `vp9_write_tree` with `len = 3` — segment_id is the 3-bit path.
3157fn write_segment_id(e: &mut BoolEncoder, segment_id: u8) {
3158    let mut i: i8 = 0;
3159    let mut len = 3i32;
3160    let bits = segment_id as i32;
3161    while len > 0 {
3162        len -= 1;
3163        let bit = ((bits >> len) & 1) != 0;
3164        e.put_bool(MAX_PROB, bit);
3165        i = SEGMENT_TREE[i as usize + usize::from(bit)];
3166    }
3167}
3168
3169/// Uncompressed `segmentation_params`: map + ALT_Q on segment 1.
3170fn write_segmentation_params(w: &mut BitWriter) {
3171    w.write_bit(1); // segmentation_enabled
3172    w.write_bit(1); // update_map
3173    for _ in 0..SEG_TREE_PROBS {
3174        w.write_bit(0); // tree_probs → MAX_PROB
3175    }
3176    w.write_bit(0); // temporal_update = 0
3177    w.write_bit(1); // update_data
3178    w.write_bit(0); // abs_delta = 0 (delta coding)
3179    for seg in 0..MAX_SEGMENTS {
3180        for feat in 0..SEG_LVL_MAX {
3181            let active = seg == 1 && feat == SEG_LVL_ALT_Q;
3182            w.write_bit(u32::from(active));
3183            if active {
3184                // encode_unsigned_max(|delta|, MAXQ) → 8 bits, then sign.
3185                w.write_bits(SEG1_ALT_Q_DELTA.unsigned_abs(), 8);
3186                w.write_bit(0); // positive
3187            }
3188        }
3189    }
3190}
3191
3192fn write_uncompressed_inter_header(
3193    w: &mut BitWriter,
3194    width: u32,
3195    _height: u32,
3196    header_size: u32,
3197    refresh_frame_flags: u8,
3198    log2_tile_cols: u32,
3199) {
3200    w.write_bits(2, 2);
3201    w.write_bit(0);
3202    w.write_bit(0);
3203    w.write_bit(0);
3204    w.write_bit(1);
3205    w.write_bit(1);
3206    w.write_bit(0);
3207
3208    w.write_bits(0, 2);
3209    w.write_bits(refresh_frame_flags as u32, 8);
3210
3211    for i in 0..3u32 {
3212        w.write_bits(i, 3); // LAST→buf0, GOLDEN→buf1, ALTREF→buf2
3213                            // Differing ALTREF sign-bias enables compound (fixed=ALTREF, var=LAST/GOLDEN).
3214        w.write_bit(if i == 2 { 1 } else { 0 });
3215    }
3216
3217    w.write_bit(1); // use LAST for frame size
3218    w.write_bit(0); // render_size same
3219
3220    w.write_bit(0); // allow_high_precision_mv
3221    w.write_bit(1); // interp_filter = SWITCHABLE
3222
3223    w.write_bit(0); // refresh_frame_context
3224    w.write_bit(1); // frame_parallel_decoding_mode
3225    w.write_bits(0, 2); // frame_context_idx
3226
3227    w.write_bits(FILTER_LEVEL as u32, 6);
3228    w.write_bits(FILTER_SHARPNESS as u32, 3);
3229    // Mode/ref deltas enabled; no update — decoder keeps defaults from the
3230    // preceding keyframe's `vp9_setup_past_independence` ({1,0,-1,-1}/{0,0}).
3231    w.write_bit(1); // loop_filter_delta_enabled
3232    w.write_bit(0); // loop_filter_delta_update
3233
3234    w.write_bits(QINDEX, 8);
3235    w.write_bit(0);
3236    w.write_bit(0);
3237    w.write_bit(0);
3238
3239    write_segmentation_params(w);
3240
3241    write_tile_info(w, width, log2_tile_cols);
3242    w.write_bits(header_size, 16);
3243}
3244
3245/// libvpx `vp9_get_tile_n_bits` — returns (min_log2, max_log2) for tile columns.
3246fn tile_log2_bounds(width: u32) -> (u32, u32) {
3247    let mi_cols = width / 8;
3248    let sb_cols = mi_cols.div_ceil(8);
3249    let mut min_log2 = 0u32;
3250    while (MAX_TILE_WIDTH_SB << min_log2) < sb_cols {
3251        min_log2 += 1;
3252    }
3253    let mut max_log2 = 1u32;
3254    while (sb_cols >> max_log2) >= MIN_TILE_WIDTH_SB {
3255        max_log2 += 1;
3256    }
3257    max_log2 -= 1;
3258    (min_log2, max_log2)
3259}
3260
3261/// Prefer two tile columns when the frame is wide enough (`≥ 512` px → ≥8 SB cols).
3262fn choose_log2_tile_cols(width: u32) -> u32 {
3263    let (min_log2, max_log2) = tile_log2_bounds(width);
3264    if max_log2 >= 1 {
3265        1u32.max(min_log2).min(max_log2)
3266    } else {
3267        min_log2
3268    }
3269}
3270
3271/// libvpx `get_tile_offset` / `vp9_tile_set_col` — MI column range for one tile.
3272fn tile_mi_col_range(mi_cols: usize, log2_tile_cols: u32, tile_col: u32) -> (usize, usize) {
3273    let sb_cols = mi_cols.div_ceil(8);
3274    let start_sb = (tile_col as usize * sb_cols) >> log2_tile_cols;
3275    let end_sb = ((tile_col as usize + 1) * sb_cols) >> log2_tile_cols;
3276    let start = (start_sb * 8).min(mi_cols);
3277    let end = (end_sb * 8).min(mi_cols);
3278    (start, end)
3279}
3280
3281fn write_tile_info(w: &mut BitWriter, width: u32, log2_tile_cols: u32) {
3282    let (min_log2, max_log2) = tile_log2_bounds(width);
3283    debug_assert!(log2_tile_cols >= min_log2 && log2_tile_cols <= max_log2);
3284    // columns: `ones = log2 - min_log2` leading 1s, then a 0 if log2 < max.
3285    let mut ones = log2_tile_cols - min_log2;
3286    while ones > 0 {
3287        w.write_bit(1);
3288        ones -= 1;
3289    }
3290    if log2_tile_cols < max_log2 {
3291        w.write_bit(0);
3292    }
3293    w.write_bit(0); // log2_tile_rows = 0
3294}
3295
3296/// Pack independent tile bitstreams: BE32 size prefix on every tile but the last.
3297fn pack_tile_data(tiles: &[Vec<u8>]) -> Vec<u8> {
3298    let mut out = Vec::new();
3299    for (i, tile) in tiles.iter().enumerate() {
3300        if i + 1 < tiles.len() {
3301            out.extend_from_slice(&(tile.len() as u32).to_be_bytes());
3302        }
3303        out.extend_from_slice(tile);
3304    }
3305    out
3306}
3307
3308fn write_tree(e: &mut BoolEncoder, tree: &[i8], probs: &[u8], token: i8) {
3309    let path = tree_path(tree, 0, token).expect("token not in tree");
3310    for (node, bit) in path {
3311        e.put_bool(probs[node >> 1], bit);
3312    }
3313}
3314
3315fn tree_path(tree: &[i8], node: usize, token: i8) -> Option<Vec<(usize, bool)>> {
3316    for bit in 0..2 {
3317        let child = tree[node + bit];
3318        if child <= 0 {
3319            if -child == token {
3320                return Some(vec![(node, bit == 1)]);
3321            }
3322        } else if let Some(mut rest) = tree_path(tree, child as usize, token) {
3323            rest.insert(0, (node, bit == 1));
3324            return Some(rest);
3325        }
3326    }
3327    None
3328}
3329
3330#[cfg(test)]
3331mod tests {
3332    use super::*;
3333    use crate::hevc::Yuv420Frame;
3334    use crate::vp9::encoder::encode_intra_frame;
3335
3336    #[test]
3337    fn tile_col_range_splits_512_evenly() {
3338        // 512px → 64 MI cols → 8 SB cols → log2=1 → tiles [0,32) and [32,64).
3339        assert_eq!(choose_log2_tile_cols(512), 1);
3340        assert_eq!(tile_mi_col_range(64, 1, 0), (0, 32));
3341        assert_eq!(tile_mi_col_range(64, 1, 1), (32, 64));
3342        assert_eq!(choose_log2_tile_cols(64), 0);
3343        assert_eq!(choose_log2_tile_cols(80), 0);
3344    }
3345
3346    #[test]
3347    fn pack_tile_data_prefixes_non_last() {
3348        let packed = pack_tile_data(&[vec![1, 2, 3], vec![4, 5]]);
3349        assert_eq!(&packed[..4], &3u32.to_be_bytes());
3350        assert_eq!(&packed[4..], &[1, 2, 3, 4, 5]);
3351        assert_eq!(pack_tile_data(&[vec![9, 9]]), vec![9, 9]);
3352    }
3353
3354    #[test]
3355    fn segmentation_alt_q_raises_right_half_qindex() {
3356        assert_eq!(segment_id_for_mi_col(0, 8), 0);
3357        assert_eq!(segment_id_for_mi_col(3, 8), 0);
3358        assert_eq!(segment_id_for_mi_col(4, 8), 1);
3359        assert_eq!(qindex_for_segment(0), QINDEX_USIZE);
3360        assert_eq!(
3361            qindex_for_segment(1),
3362            (QINDEX as i32 + SEG1_ALT_Q_DELTA) as usize
3363        );
3364    }
3365
3366    #[test]
3367    fn compound_zeromv_recon_is_avg() {
3368        use crate::vp9::encoder::encode_intra_frame;
3369        let w = 64u32;
3370        let h = 64u32;
3371        let mut key_src = Yuv420Frame::new(w, h);
3372        for j in 0..h {
3373            for i in 0..w {
3374                key_src.y[(j * w + i) as usize] =
3375                    ((i.wrapping_mul(7) + j.wrapping_mul(11)) & 0xFF) as u8;
3376            }
3377        }
3378        let (cw, ch) = (w / 2, h / 2);
3379        for j in 0..ch {
3380            for i in 0..cw {
3381                key_src.u[(j * cw + i) as usize] = 128;
3382                key_src.v[(j * cw + i) as usize] = 128;
3383            }
3384        }
3385        let (_, key_recon) = encode_intra_frame(&key_src);
3386        let mut p1_src = Yuv420Frame::new(w, h);
3387        p1_src.u.copy_from_slice(&key_recon.u);
3388        p1_src.v.copy_from_slice(&key_recon.v);
3389        for j in 0..h as usize {
3390            for i in 0..w as usize {
3391                let sx = (i + 4).min(w as usize - 1);
3392                p1_src.y[j * w as usize + i] = key_recon.y[j * w as usize + sx];
3393            }
3394        }
3395        let (_, alt) = encode_inter_frame_refresh(&p1_src, &key_recon, 0x04);
3396        let mut p2_src = Yuv420Frame::new(w, h);
3397        for i in 0..key_recon.y.len() {
3398            p2_src.y[i] = ((u16::from(key_recon.y[i]) + u16::from(alt.y[i]) + 1) >> 1) as u8;
3399        }
3400        p2_src.u.copy_from_slice(&key_recon.u);
3401        p2_src.v.copy_from_slice(&key_recon.v);
3402        let (_, p2) = encode_inter_frame_compound(&p2_src, &key_recon, &key_recon, &alt);
3403        eprintln!(
3404            "key0={} alt0={} avg0={} recon0={}",
3405            key_recon.y[0], alt.y[0], p2_src.y[0], p2.y[0]
3406        );
3407        // Without LF, compound ZEROMV skip should equal avg. With LF, edges change.
3408        // Count how many mi are compound via a second encode peek — just check most pixels match avg before LF corners.
3409        let mut match_avg = 0usize;
3410        for i in 0..p2.y.len() {
3411            if p2.y[i] == p2_src.y[i] {
3412                match_avg += 1;
3413            }
3414        }
3415        eprintln!("pixels matching pre-LF avg src: {match_avg}/{}", p2.y.len());
3416        assert!(match_avg > p2.y.len() / 2);
3417    }
3418
3419    #[test]
3420    fn zeromv_skip_recon_equals_reference() {
3421        let mut f = Yuv420Frame::new(64, 64);
3422        for j in 0..64u32 {
3423            for i in 0..64u32 {
3424                f.y[(j * 64 + i) as usize] = ((i + j * 3) & 0xFF) as u8;
3425            }
3426        }
3427        let (_, key_recon) = encode_intra_frame(&f);
3428        let (bits, p_recon) = encode_inter_zeromv_skip(&key_recon);
3429        assert!(bits.len() > 12);
3430        // Post-LF recon: ZEROMV/skip still deblocks prediction edges.
3431        let mut expected = key_recon.clone();
3432        let lf_mi: Vec<LfMi> = (0..64)
3433            .map(|_| LfMi {
3434                skip: true,
3435                is_inter: true,
3436                tx_size_y: 1,
3437                bw_mi: 1,
3438                bh_mi: 1,
3439                bsize_idx: partition_ctx_index_wh(8, 8),
3440                block_origin: true,
3441                level: lf_level_for_mi(FILTER_LEVEL, LAST_FRAME, ZEROMV),
3442            })
3443            .collect();
3444        apply_loop_filter(&mut expected, &lf_mi, 8, 8);
3445        assert_eq!(p_recon.y, expected.y);
3446    }
3447
3448    #[test]
3449    fn newmv_skip_shifts_recon() {
3450        let mut f = Yuv420Frame::new(64, 64);
3451        for j in 0..64u32 {
3452            for i in 0..64u32 {
3453                f.y[(j * 64 + i) as usize] = ((i * 3 + j) & 0xFF) as u8;
3454            }
3455        }
3456        let (_, key_recon) = encode_intra_frame(&f);
3457        let (bits, p_recon) = encode_inter_newmv_skip(&key_recon, 0, 16);
3458        assert!(bits.len() > 12);
3459        let mut expected = motion_compensate(&key_recon, Mv { row: 0, col: 16 });
3460        let lf_mi: Vec<LfMi> = (0..64)
3461            .map(|_| LfMi {
3462                skip: true,
3463                is_inter: true,
3464                tx_size_y: 1,
3465                bw_mi: 1,
3466                bh_mi: 1,
3467                bsize_idx: partition_ctx_index_wh(8, 8),
3468                block_origin: true,
3469                level: lf_level_for_mi(FILTER_LEVEL, LAST_FRAME, NEWMV),
3470            })
3471            .collect();
3472        apply_loop_filter(&mut expected, &lf_mi, 8, 8);
3473        assert_eq!(p_recon.y, expected.y);
3474    }
3475
3476    #[test]
3477    fn newmv_halfpel_skip_uses_filter() {
3478        let mut f = Yuv420Frame::new(64, 64);
3479        for j in 0..64u32 {
3480            for i in 0..64u32 {
3481                f.y[(j * 64 + i) as usize] = (i * 4) as u8;
3482            }
3483        }
3484        let (_, key_recon) = encode_intra_frame(&f);
3485        let (bits, p_recon) = encode_inter_newmv_skip(&key_recon, 0, 4); // half-pel
3486        assert!(bits.len() > 12);
3487        // Pre-LF half-pel samples sit between neighbors; LF may nudge edges.
3488        let mc = motion_compensate(&key_recon, Mv { row: 0, col: 4 });
3489        let mut between = 0usize;
3490        let mut total = 0usize;
3491        for j in 8..56usize {
3492            for i in 8..55usize {
3493                let a = key_recon.y[j * 64 + i];
3494                let b = key_recon.y[j * 64 + i + 1];
3495                let p = mc.y[j * 64 + i];
3496                if a != b {
3497                    total += 1;
3498                    if p > a.min(b) && p < a.max(b) {
3499                        between += 1;
3500                    }
3501                }
3502            }
3503        }
3504        assert!(
3505            between * 2 > total,
3506            "half-pel MC should interpolate: {between}/{total}"
3507        );
3508        assert_ne!(p_recon.y, key_recon.y);
3509    }
3510
3511    #[test]
3512    fn residual_against_different_src_beats_skip_copy() {
3513        let mut key = Yuv420Frame::new(64, 64);
3514        key.y.fill(128);
3515        key.u.fill(128);
3516        key.v.fill(128);
3517        let (_, key_recon) = encode_intra_frame(&key);
3518
3519        let mut src = Yuv420Frame::new(64, 64);
3520        for j in 0..64u32 {
3521            for i in 0..64u32 {
3522                src.y[(j * 64 + i) as usize] = ((i * 5 + j * 3) & 0xFF) as u8;
3523            }
3524        }
3525        let (bits, recon) = encode_inter_residual(&src, &key_recon);
3526        assert!(
3527            bits.len() > 50,
3528            "expected residual bitstream, got {}",
3529            bits.len()
3530        );
3531        let mut err = 0u64;
3532        for (a, b) in src.y.iter().zip(&recon.y) {
3533            err += a.abs_diff(*b) as u64;
3534        }
3535        let copy_err: u64 = src.y.iter().map(|&x| x.abs_diff(128) as u64).sum();
3536        assert!(
3537            err < copy_err / 2,
3538            "residual err={err} should beat copy={copy_err}"
3539        );
3540    }
3541
3542    #[test]
3543    fn newmv_residual_beats_zeromv_on_shifted_src() {
3544        let mut key = Yuv420Frame::new(64, 64);
3545        for j in 0..64u32 {
3546            for i in 0..64u32 {
3547                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3548            }
3549        }
3550        let (_, key_recon) = encode_intra_frame(&key);
3551
3552        // Source ≈ reference shifted by +2 horizontally.
3553        let mut src = Yuv420Frame::new(64, 64);
3554        for j in 0..64usize {
3555            for i in 0..64usize {
3556                let sx = i.saturating_add(2).min(63);
3557                src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3558            }
3559        }
3560        for j in 0..32usize {
3561            for i in 0..32usize {
3562                let sx = i.saturating_add(1).min(31);
3563                src.u[j * 32 + i] = key_recon.u[j * 32 + sx];
3564                src.v[j * 32 + i] = key_recon.v[j * 32 + sx];
3565            }
3566        }
3567
3568        let (_, z_recon) = encode_inter_residual(&src, &key_recon);
3569        let (bits, n_recon) = encode_inter_newmv_residual(&src, &key_recon, 0, 16);
3570        assert!(bits.len() > 20);
3571
3572        let z_err: u64 = src
3573            .y
3574            .iter()
3575            .zip(&z_recon.y)
3576            .map(|(a, b)| a.abs_diff(*b) as u64)
3577            .sum();
3578        let n_err: u64 = src
3579            .y
3580            .iter()
3581            .zip(&n_recon.y)
3582            .map(|(a, b)| a.abs_diff(*b) as u64)
3583            .sum();
3584        assert!(
3585            n_err <= z_err,
3586            "NEWMV residual err={n_err} should beat ZEROMV err={z_err}"
3587        );
3588        assert!(
3589            n_err < 5000,
3590            "shifted content should nearly skip: err={n_err}"
3591        );
3592    }
3593
3594    #[test]
3595    fn me_frame_finds_mixed_block_mvs() {
3596        let mut key = Yuv420Frame::new(64, 64);
3597        for j in 0..64u32 {
3598            for i in 0..64u32 {
3599                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3600            }
3601        }
3602        let (_, key_recon) = encode_intra_frame(&key);
3603
3604        // Left half shifted +2 pel, right half unshifted.
3605        let mut src = Yuv420Frame::new(64, 64);
3606        src.u.copy_from_slice(&key_recon.u);
3607        src.v.copy_from_slice(&key_recon.v);
3608        for j in 0..64usize {
3609            for i in 0..64usize {
3610                let sx = if i < 32 {
3611                    i.saturating_add(2).min(63)
3612                } else {
3613                    i
3614                };
3615                src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3616            }
3617        }
3618
3619        let (_, z_recon) = encode_inter_residual(&src, &key_recon);
3620        let (bits, me_recon) = encode_inter_frame(&src, &key_recon);
3621        assert!(bits.len() > 12, "P-frame too small: {}", bits.len());
3622
3623        let z_err: u64 = src
3624            .y
3625            .iter()
3626            .zip(&z_recon.y)
3627            .map(|(a, b)| a.abs_diff(*b) as u64)
3628            .sum();
3629        let me_err: u64 = src
3630            .y
3631            .iter()
3632            .zip(&me_recon.y)
3633            .map(|(a, b)| a.abs_diff(*b) as u64)
3634            .sum();
3635        assert!(
3636            me_err < z_err / 2,
3637            "ME residual err={me_err} should beat global ZEROMV err={z_err}"
3638        );
3639        assert!(
3640            me_err < 800,
3641            "mixed-shift content should nearly skip: err={me_err}"
3642        );
3643    }
3644
3645    #[test]
3646    fn uniform_shift_uses_nearestmv() {
3647        let mut key = Yuv420Frame::new(64, 64);
3648        for j in 0..64u32 {
3649            for i in 0..64u32 {
3650                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3651            }
3652        }
3653        let (_, key_recon) = encode_intra_frame(&key);
3654        let mut src = Yuv420Frame::new(64, 64);
3655        for j in 0..64usize {
3656            for i in 0..64usize {
3657                let sx = i.saturating_add(2).min(63);
3658                src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3659            }
3660        }
3661        for j in 0..32usize {
3662            for i in 0..32usize {
3663                let sx = i.saturating_add(1).min(31);
3664                src.u[j * 32 + i] = key_recon.u[j * 32 + sx];
3665                src.v[j * 32 + i] = key_recon.v[j * 32 + sx];
3666            }
3667        }
3668
3669        let (new_bits, _) = encode_inter_newmv_residual(&src, &key_recon, 0, 16);
3670        let (me_bits, me_recon) = encode_inter_frame(&src, &key_recon);
3671        // Predicted modes should beat coding NEWMV on every block.
3672        assert!(
3673            me_bits.len() < new_bits.len(),
3674            "NEARESTMV path {} bytes should beat all-NEWMV {} bytes",
3675            me_bits.len(),
3676            new_bits.len()
3677        );
3678        let err: u64 = src
3679            .y
3680            .iter()
3681            .zip(&me_recon.y)
3682            .map(|(a, b)| a.abs_diff(*b) as u64)
3683            .sum();
3684        assert!(err < 500, "uniform shift should nearly skip: err={err}");
3685    }
3686
3687    #[test]
3688    fn uniform_shift_prefers_16x16_partition() {
3689        let mut key = Yuv420Frame::new(64, 64);
3690        for j in 0..64u32 {
3691            for i in 0..64u32 {
3692                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3693            }
3694        }
3695        let (_, key_recon) = encode_intra_frame(&key);
3696        let mut src = Yuv420Frame::new(64, 64);
3697        src.u.copy_from_slice(&key_recon.u);
3698        src.v.copy_from_slice(&key_recon.v);
3699        for j in 0..64usize {
3700            for i in 0..64usize {
3701                let sx = i.saturating_add(2).min(63);
3702                src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3703            }
3704        }
3705        let (bits, recon) = encode_inter_frame(&src, &key_recon);
3706        // With 16×16 NONE, a near-skip uniform P-frame should stay compact.
3707        assert!(
3708            bits.len() < 120,
3709            "expected compact 16×16-friendly bitstream, got {}",
3710            bits.len()
3711        );
3712        let err: u64 = src
3713            .y
3714            .iter()
3715            .zip(&recon.y)
3716            .map(|(a, b)| a.abs_diff(*b) as u64)
3717            .sum();
3718        assert!(err < 500, "err={err}");
3719    }
3720
3721    #[test]
3722    fn uniform_shift_prefers_32x32_partition() {
3723        let mut key = Yuv420Frame::new(64, 64);
3724        for j in 0..64u32 {
3725            for i in 0..64u32 {
3726                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3727            }
3728        }
3729        let (_, key_recon) = encode_intra_frame(&key);
3730        let mut src = Yuv420Frame::new(64, 64);
3731        src.u.copy_from_slice(&key_recon.u);
3732        src.v.copy_from_slice(&key_recon.v);
3733        for j in 0..64usize {
3734            for i in 0..64usize {
3735                let sx = i.saturating_add(2).min(63);
3736                src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3737            }
3738        }
3739        let (bits, recon) = encode_inter_frame(&src, &key_recon);
3740        // One/two 32×32 NONE blocks should stay very compact on uniform motion.
3741        assert!(
3742            bits.len() < 80,
3743            "expected compact 32×32-friendly bitstream, got {}",
3744            bits.len()
3745        );
3746        let err: u64 = src
3747            .y
3748            .iter()
3749            .zip(&recon.y)
3750            .map(|(a, b)| a.abs_diff(*b) as u64)
3751            .sum();
3752        assert!(err < 500, "err={err}");
3753    }
3754
3755    #[test]
3756    fn uniform_shift_prefers_64x64_partition() {
3757        let mut key = Yuv420Frame::new(64, 64);
3758        for j in 0..64u32 {
3759            for i in 0..64u32 {
3760                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3761            }
3762        }
3763        let (_, key_recon) = encode_intra_frame(&key);
3764        let mut src = Yuv420Frame::new(64, 64);
3765        src.u.copy_from_slice(&key_recon.u);
3766        src.v.copy_from_slice(&key_recon.v);
3767        for j in 0..64usize {
3768            for i in 0..64usize {
3769                let sx = i.saturating_add(2).min(63);
3770                src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3771            }
3772        }
3773        let (bits, recon) = encode_inter_frame(&src, &key_recon);
3774        // A single 64×64 NONE + NEWMV/skip should be tiny.
3775        assert!(
3776            bits.len() < 50,
3777            "expected compact 64×64 NONE bitstream, got {}",
3778            bits.len()
3779        );
3780        let err: u64 = src
3781            .y
3782            .iter()
3783            .zip(&recon.y)
3784            .map(|(a, b)| a.abs_diff(*b) as u64)
3785            .sum();
3786        assert!(err < 500, "err={err}");
3787    }
3788
3789    #[test]
3790    fn golden_beats_last_when_src_matches_key() {
3791        let mut key = Yuv420Frame::new(64, 64);
3792        for j in 0..64u32 {
3793            for i in 0..64u32 {
3794                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3795            }
3796        }
3797        let (_, key_recon) = encode_intra_frame(&key);
3798
3799        // P1: shift content → LAST becomes shifted recon.
3800        let mut p1_src = Yuv420Frame::new(64, 64);
3801        p1_src.u.copy_from_slice(&key_recon.u);
3802        p1_src.v.copy_from_slice(&key_recon.v);
3803        for j in 0..64usize {
3804            for i in 0..64usize {
3805                let sx = i.saturating_add(2).min(63);
3806                p1_src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3807            }
3808        }
3809        let (_, last) = encode_inter_frame(&p1_src, &key_recon);
3810
3811        // P2: source ≈ key again → GOLDEN (key) should beat LAST (shifted).
3812        let mut p2_src = Yuv420Frame::new(64, 64);
3813        p2_src.y.copy_from_slice(&key_recon.y);
3814        p2_src.u.copy_from_slice(&key_recon.u);
3815        p2_src.v.copy_from_slice(&key_recon.v);
3816
3817        let (_, only_last) = encode_inter_frame(&p2_src, &last);
3818        let (bits, with_golden) = encode_inter_frame_golden(&p2_src, &last, &key_recon);
3819        assert!(bits.len() > 12);
3820
3821        let last_err: u64 = p2_src
3822            .y
3823            .iter()
3824            .zip(&only_last.y)
3825            .map(|(a, b)| a.abs_diff(*b) as u64)
3826            .sum();
3827        let gold_err: u64 = p2_src
3828            .y
3829            .iter()
3830            .zip(&with_golden.y)
3831            .map(|(a, b)| a.abs_diff(*b) as u64)
3832            .sum();
3833        assert!(
3834            gold_err <= last_err,
3835            "golden err={gold_err} should beat last-only err={last_err}"
3836        );
3837        assert!(
3838            gold_err < 500,
3839            "key-matched src should nearly skip via GOLDEN: err={gold_err}"
3840        );
3841    }
3842
3843    #[test]
3844    fn altref_beats_last_when_src_matches_alt() {
3845        let mut key = Yuv420Frame::new(64, 64);
3846        for j in 0..64u32 {
3847            for i in 0..64u32 {
3848                key.y[(j * 64 + i) as usize] = ((i * 3 + j * 5) & 0xFF) as u8;
3849            }
3850        }
3851        let (_, key_recon) = encode_intra_frame(&key);
3852
3853        // P1 into ALTREF only (0x04): LAST/GOLDEN stay at key, ALTREF = shift.
3854        let mut p1_src = Yuv420Frame::new(64, 64);
3855        p1_src.u.copy_from_slice(&key_recon.u);
3856        p1_src.v.copy_from_slice(&key_recon.v);
3857        for j in 0..64usize {
3858            for i in 0..64usize {
3859                let sx = i.saturating_add(2).min(63);
3860                p1_src.y[j * 64 + i] = key_recon.y[j * 64 + sx];
3861            }
3862        }
3863        let (_, alt) = encode_inter_frame_refresh(&p1_src, &key_recon, 0x04);
3864
3865        // P2: source ≈ alt → ALTREF should beat LAST (= key).
3866        let mut p2_src = Yuv420Frame::new(64, 64);
3867        p2_src.y.copy_from_slice(&alt.y);
3868        p2_src.u.copy_from_slice(&alt.u);
3869        p2_src.v.copy_from_slice(&alt.v);
3870
3871        let (_, only_last) = encode_inter_frame(&p2_src, &key_recon);
3872        let (bits, with_alt) = encode_inter_frame_altref(&p2_src, &key_recon, &key_recon, &alt);
3873        assert!(bits.len() > 12);
3874
3875        let last_err: u64 = p2_src
3876            .y
3877            .iter()
3878            .zip(&only_last.y)
3879            .map(|(a, b)| a.abs_diff(*b) as u64)
3880            .sum();
3881        let alt_err: u64 = p2_src
3882            .y
3883            .iter()
3884            .zip(&with_alt.y)
3885            .map(|(a, b)| a.abs_diff(*b) as u64)
3886            .sum();
3887        assert!(
3888            alt_err <= last_err,
3889            "altref err={alt_err} should beat last-only err={last_err}"
3890        );
3891        assert!(
3892            alt_err < 500,
3893            "alt-matched src should nearly skip via ALTREF: err={alt_err}"
3894        );
3895    }
3896
3897    #[test]
3898    fn nmv_update_count_no_hp() {
3899        assert_eq!(nmv_update_count(false), 65);
3900        assert_eq!(nmv_update_count(true), 69);
3901    }
3902
3903    #[test]
3904    fn inter_mode_tree_paths() {
3905        assert_eq!(
3906            tree_path(&INTER_MODE_TREE, 0, INTER_OFFSET_ZEROMV).unwrap(),
3907            vec![(0, false)]
3908        );
3909        assert_eq!(
3910            tree_path(&INTER_MODE_TREE, 0, INTER_OFFSET_NEARESTMV).unwrap(),
3911            vec![(0, true), (2, false)]
3912        );
3913        assert_eq!(
3914            tree_path(&INTER_MODE_TREE, 0, INTER_OFFSET_NEARMV).unwrap(),
3915            vec![(0, true), (2, true), (4, false)]
3916        );
3917        assert_eq!(
3918            tree_path(&INTER_MODE_TREE, 0, INTER_OFFSET_NEWMV).unwrap(),
3919            vec![(0, true), (2, true), (4, true)]
3920        );
3921    }
3922
3923    #[test]
3924    fn pick_mode_prefers_predicted() {
3925        let nearest = Mv { row: 0, col: 16 };
3926        let near = Mv { row: 8, col: 0 };
3927        assert_eq!(pick_inter_mode(Mv::default(), nearest, near).1, ZEROMV);
3928        assert_eq!(pick_inter_mode(nearest, nearest, near).1, NEARESTMV);
3929        assert_eq!(pick_inter_mode(near, nearest, near).1, NEARMV);
3930        assert_eq!(
3931            pick_inter_mode(Mv { row: 0, col: 24 }, nearest, near).1,
3932            NEWMV
3933        );
3934    }
3935}