1use 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#[derive(Clone, Copy, PartialEq, Eq)]
40enum RefMode {
41 Single,
43 Compound,
45 Select,
47}
48
49const 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;
88const 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;
96const SEGMENT_TREE: [i8; 14] = [2, 4, 6, 8, 10, 12, 0, -1, -2, -3, -4, -5, -6, -7];
98const FILTER_LEVEL: u8 = 10;
100const FILTER_SHARPNESS: u8 = 0;
101
102#[derive(Clone, Copy)]
103enum EntPlane {
104 Y,
105 U,
106 V,
107}
108
109macro_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
163macro_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 x: usize,
229 y: usize,
230 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
292pub fn encode_inter_zeromv_skip(reference: &Reconstruction) -> (Vec<u8>, Reconstruction) {
294 encode_inter_skip(reference, Mv { row: 0, col: 0 }, false)
295}
296
297pub 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
319pub 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
355pub 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
373pub 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
398pub 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
426pub 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
451pub 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
526pub 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, 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 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#[derive(Clone, Copy)]
1023struct ResidualMi {
1024 skip: bool,
1025 is_inter: bool,
1026 ref_frame: i8,
1027 second_ref: i8,
1029 mode: i8,
1030 mv: Mv,
1031 mv1: Mv,
1032 bw_px: u32,
1033 bh_px: u32,
1034 block_origin: bool,
1036 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 fn comp_ref_context(&self, mi_row: usize, mi_col: usize) -> usize {
2804 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 } 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
2883fn 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
2894fn 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
2954fn 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
2967fn 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); e.put_bit(true); for _ in 0..(2 + 2 * 2 + 2 * 3) {
2995 e.put_bool(DIFF_UPDATE_PROB, false);
2996 }
2997 e.put_bit(false); e.put_bit(false); e.put_bit(false); e.put_bit(false); 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 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 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 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 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
3156fn 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
3169fn write_segmentation_params(w: &mut BitWriter) {
3171 w.write_bit(1); w.write_bit(1); for _ in 0..SEG_TREE_PROBS {
3174 w.write_bit(0); }
3176 w.write_bit(0); w.write_bit(1); w.write_bit(0); 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 w.write_bits(SEG1_ALT_Q_DELTA.unsigned_abs(), 8);
3186 w.write_bit(0); }
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); w.write_bit(if i == 2 { 1 } else { 0 });
3215 }
3216
3217 w.write_bit(1); w.write_bit(0); w.write_bit(0); w.write_bit(1); w.write_bit(0); w.write_bit(1); w.write_bits(0, 2); w.write_bits(FILTER_LEVEL as u32, 6);
3228 w.write_bits(FILTER_SHARPNESS as u32, 3);
3229 w.write_bit(1); w.write_bit(0); 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
3245fn 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
3261fn 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
3271fn 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 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); }
3295
3296fn 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 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 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 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); assert!(bits.len() > 12);
3487 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 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 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 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 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 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 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 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 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 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 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}