1 use nihav_core::frame::NASimpleVideoFrame;
2 use nihav_codec_support::codecs::{MV, ZERO_MV};
3 use nihav_codec_support::data::GenericCache;
5 use super::pic_ref::FrameMBInfo;
8 #[derive(Clone,Copy,Debug,PartialEq)]
15 #[derive(Clone,Copy,Debug,PartialEq)]
19 Intra16x16(u8, u8, u8),
38 pub fn is_intra(self) -> bool {
39 matches!(self, MBType::Intra4x4 | MBType::Intra8x8 | MBType::Intra16x16(_, _, _) | MBType::PCM)
41 pub fn is_intra16x16(self) -> bool {
42 matches!(self, MBType::Intra16x16(_, _, _))
44 pub fn is_skip(self) -> bool {
45 matches!(self, MBType::PSkip | MBType::BSkip)
47 pub fn is_4x4(self) -> bool { self.num_parts() == 4 }
48 pub fn is_l0(self, part: usize) -> bool {
50 MBType::B16x16(mode) => mode == BMode::L0,
51 MBType::B16x8(mode0, mode1) | MBType::B8x16(mode0, mode1) => {
58 MBType::Direct | MBType::BSkip => false,
62 pub fn is_l1(self, part: usize) -> bool {
64 MBType::B16x16(mode) => mode == BMode::L1,
65 MBType::B16x8(mode0, mode1) | MBType::B8x16(mode0, mode1) => {
75 pub fn num_parts(self) -> usize {
77 MBType::Intra4x4 | MBType::Intra8x8 | MBType::Intra16x16(_, _, _) | MBType::PCM |
79 MBType::Direct | MBType::BSkip
84 MBType::P16x8 | MBType::P8x16 |
85 MBType::B16x8(_, _) | MBType::B8x16(_, _)
90 pub fn size(self) -> (usize, usize) {
94 MBType::Intra16x16(_, _, _) |
102 MBType::P16x8 | MBType::B16x8(_, _) => (16, 8),
103 MBType::P8x16 | MBType::B8x16(_, _) => (8, 16),
109 impl Default for MBType {
110 fn default() -> Self { MBType::Intra4x4 }
113 #[derive(Clone,Copy,Debug,PartialEq)]
127 pub fn num_parts(self) -> usize {
129 SubMBType::P8x8 | SubMBType::Direct8x8 | SubMBType::B8x8(_) => 1,
130 SubMBType::P4x4 | SubMBType::B4x4(_) => 4,
134 pub fn size(self) -> (usize, usize) {
136 SubMBType::P8x8 | SubMBType::Direct8x8 | SubMBType::B8x8(_) => (8, 8),
137 SubMBType::P8x4 | SubMBType::B8x4(_) => (8, 4),
138 SubMBType::P4x8 | SubMBType::B4x8(_) => (4, 8),
139 SubMBType::P4x4 | SubMBType::B4x4(_) => (4, 4),
142 pub fn is_l0(self) -> bool {
144 SubMBType::B8x8(mode) | SubMBType::B8x4(mode) |
145 SubMBType::B4x8(mode) | SubMBType::B4x4(mode) => {
151 pub fn is_l1(self) -> bool {
153 SubMBType::B8x8(mode) | SubMBType::B8x4(mode) |
154 SubMBType::B4x8(mode) | SubMBType::B4x4(mode) => {
162 impl Default for SubMBType {
163 fn default() -> Self { SubMBType::Direct8x8 }
167 #[derive(Clone,Copy,Debug,PartialEq)]
168 pub enum CompactMBType {
192 pub fn is_intra(self) -> bool {
193 matches!(self, CompactMBType::Intra4x4 | CompactMBType::Intra8x8 | CompactMBType::Intra16x16)
195 pub fn is_intra16orpcm(self) -> bool {
196 matches!(self, CompactMBType::Intra16x16 | CompactMBType::PCM)
198 pub fn is_skip(self) -> bool {
199 matches!(self, CompactMBType::PSkip | CompactMBType::BSkip)
201 pub fn is_direct(self) -> bool {
202 matches!(self, CompactMBType::BSkip | CompactMBType::Direct | CompactMBType::None)
204 pub fn is_inter(self) -> bool {
205 !self.is_intra() && !self.is_skip() && self != CompactMBType::PCM
207 pub fn is_16x16_ref(self) -> bool {
209 CompactMBType::Intra4x4 |
210 CompactMBType::Intra8x8 |
211 CompactMBType::Intra16x16 |
213 CompactMBType::P16x16 |
214 CompactMBType::B16x16)
218 impl Default for CompactMBType {
219 fn default() -> Self { CompactMBType::None }
222 impl From<MBType> for CompactMBType {
223 fn from(mbtype: MBType) -> Self {
225 MBType::Intra4x4 => CompactMBType::Intra4x4,
226 MBType::Intra8x8 => CompactMBType::Intra8x8,
227 MBType::Intra16x16(_, _, _) => CompactMBType::Intra16x16,
228 MBType::PCM => CompactMBType::PCM,
229 MBType::P16x16 => CompactMBType::P16x16,
230 MBType::P16x8 => CompactMBType::P16x8,
231 MBType::P8x16 => CompactMBType::P8x16,
232 MBType::P8x8 => CompactMBType::P8x8,
233 MBType::P8x8Ref0 => CompactMBType::P8x8Ref0,
234 MBType::PSkip => CompactMBType::PSkip,
235 MBType::Direct => CompactMBType::Direct,
236 MBType::B16x16(_) => CompactMBType::B16x16,
237 MBType::B16x8(_, _) => CompactMBType::B16x8,
238 MBType::B8x16(_, _) => CompactMBType::B8x16,
239 MBType::B8x8 => CompactMBType::B8x8,
240 MBType::BSkip => CompactMBType::BSkip,
246 #[derive(Clone,Copy,Debug,PartialEq)]
247 pub enum IntraPredMode {
261 pub fn is_none(self) -> bool { self == IntraPredMode::None }
262 pub fn into_pred_idx(self) -> i8 {
271 impl Default for IntraPredMode {
272 fn default() -> Self { IntraPredMode::None }
275 impl From<u8> for IntraPredMode {
276 fn from(val: u8) -> Self {
278 0 => IntraPredMode::Vertical,
279 1 => IntraPredMode::Horizontal,
280 2 => IntraPredMode::DC,
281 3 => IntraPredMode::DiagDownLeft,
282 4 => IntraPredMode::DiagDownRight,
283 5 => IntraPredMode::VerRight,
284 6 => IntraPredMode::HorDown,
285 7 => IntraPredMode::VerLeft,
286 8 => IntraPredMode::HorUp,
287 _ => IntraPredMode::None,
292 impl From<IntraPredMode> for u8 {
293 fn from(val: IntraPredMode) -> Self {
295 IntraPredMode::Vertical => 0,
296 IntraPredMode::Horizontal => 1,
297 IntraPredMode::DC => 2,
298 IntraPredMode::DiagDownLeft => 3,
299 IntraPredMode::DiagDownRight => 4,
300 IntraPredMode::VerRight => 5,
301 IntraPredMode::HorDown => 6,
302 IntraPredMode::VerLeft => 7,
303 IntraPredMode::HorUp => 8,
309 pub const MISSING_POC: u16 = 0xFFFF;
311 #[derive(Clone,Copy,Debug)]
316 pub const MISSING_REF: PicRef = PicRef { ref_idx: 0xFF };
317 pub const INVALID_REF: PicRef = PicRef { ref_idx: 0xFE };
318 pub const ZERO_REF: PicRef = PicRef { ref_idx: 0 };
319 const DIRECT_FLAG: u8 = 0x40;
322 pub fn new(ref_idx: u8) -> Self {
325 pub fn not_avail(self) -> bool {
326 self == MISSING_REF || self == INVALID_REF
328 pub fn index(self) -> usize { (self.ref_idx & !DIRECT_FLAG) as usize }
329 pub fn is_direct(self) -> bool { (self.ref_idx & DIRECT_FLAG) != 0 }
330 pub fn set_direct(&mut self) { self.ref_idx |= DIRECT_FLAG; }
331 fn min_pos(self, other: Self) -> Self {
332 match (self.not_avail(), other.not_avail()) {
333 (true, true) => self,
334 (false, true) => self,
335 (true, false) => other,
336 (false, false) => PicRef::new((self.ref_idx & !DIRECT_FLAG).min(other.ref_idx & !DIRECT_FLAG)),
341 impl Default for PicRef {
342 fn default() -> Self { MISSING_REF }
345 impl PartialEq for PicRef {
346 fn eq(&self, other: &Self) -> bool {
347 (self.ref_idx | DIRECT_FLAG) == (other.ref_idx | DIRECT_FLAG)
351 impl std::fmt::Display for PicRef {
352 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
353 if *self == MISSING_REF {
355 } else if *self == INVALID_REF {
358 write!(f, "{}", self.ref_idx & !DIRECT_FLAG)
363 #[derive(Clone,Copy,Default)]
365 pub mb_type: CompactMBType,
367 pub coded_flags: u32,
372 pub transform_8x8: bool,
375 pub fn blk4_to_blk8(blk4: usize) -> usize {
376 const MAP: [usize; 16] = [ 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3 ];
380 #[derive(Clone,Copy)]
381 pub struct Blk8Data {
382 pub ref_idx: [PicRef; 2],
383 pub ncoded_c: [u8; 2],
386 impl Default for Blk8Data {
387 fn default() -> Self {
389 ref_idx: [MISSING_REF; 2],
395 #[derive(Clone,Copy,Default)]
396 pub struct Blk4Data {
398 pub ipred: IntraPredMode,
403 pub struct SliceState {
410 pub mb: GenericCache<MBData>,
411 pub blk8: GenericCache<Blk8Data>,
412 pub blk4: GenericCache<Blk4Data>,
414 pub deblock: [u8; 16],
419 pub top_line_y: Vec<u8>,
420 pub left_y: [u8; 17], // first element is top-left
421 pub top_line_c: [Vec<u8>; 2],
422 pub left_c: [[u8; 9]; 2],
425 const BLK4_TO_D8: [usize; 16] = [ 0, 0, 3, 3, 0, 0, 3, 3, 12, 12, 15, 15, 12, 12, 15, 15 ];
428 pub fn new() -> Self {
435 mb: GenericCache::new(0, 0, MBData::default()),
436 blk8: GenericCache::new(0, 0, Blk8Data::default()),
437 blk4: GenericCache::new(0, 0, Blk4Data::default()),
444 top_line_y: Vec::new(),
446 top_line_c: [Vec::new(), Vec::new()],
450 pub fn reset(&mut self, mb_w: usize, mb_h: usize, mb_pos: usize) {
453 self.mb_start = mb_pos;
455 self.mb_x = mb_pos % mb_w;
456 self.mb_y = mb_pos / mb_w;
461 self.mb = GenericCache::new(1, mb_w + 2, MBData::default());
462 self.blk8 = GenericCache::new(2, mb_w * 2 + 2, Blk8Data::default());
463 self.blk4 = GenericCache::new(4, mb_w * 4 + 2, Blk4Data::default());
465 self.has_top = false;
466 self.has_left = false;
468 self.top_line_y.resize(mb_w * 16 + 1, 0x80);
469 self.top_line_c[0].resize(mb_w * 8 + 1, 0x80);
470 self.top_line_c[1].resize(mb_w * 8 + 1, 0x80);
471 self.left_y = [0x80; 17];
472 self.left_c = [[0x80; 9]; 2];
474 pub fn save_ipred_context(&mut self, frm: &NASimpleVideoFrame<u8>) {
475 let dstoff = self.mb_x * 16;
476 let srcoff = frm.offset[0] + self.mb_x * 16 + self.mb_y * 16 * frm.stride[0];
477 self.left_y[0] = self.top_line_y[dstoff + 15];
478 self.top_line_y[dstoff..][..16].copy_from_slice(&frm.data[srcoff + frm.stride[0] * 15..][..16]);
479 for (dst, src) in self.left_y[1..].iter_mut().zip(frm.data[srcoff..].chunks(frm.stride[0])) {
483 let cstride = frm.stride[chroma + 1];
484 let dstoff = self.mb_x * 8;
485 let srcoff = frm.offset[chroma + 1] + self.mb_x * 8 + self.mb_y * 8 * cstride;
486 self.left_c[chroma][0] = self.top_line_c[chroma][dstoff + 7];
487 self.top_line_c[chroma][dstoff..][..8].copy_from_slice(&frm.data[srcoff + cstride * 7..][..8]);
488 for (dst, src) in self.left_c[chroma][1..].iter_mut().zip(frm.data[srcoff..].chunks(cstride)) {
493 pub fn fill_deblock(&mut self, frefs: &FrameRefs, deblock_mode: u8, is_s: bool) {
494 if deblock_mode == 1 {
498 self.deblock = [0; 16];
500 let tx8x8 = self.get_cur_mb().transform_8x8;
502 let cur_intra = self.get_cur_mb().mb_type.is_intra();
503 let left_intra = self.get_left_mb().mb_type.is_intra();
504 let mut top_intra = self.get_top_mb().mb_type.is_intra();
506 let can_do_top = y != 0 || (self.mb_y != 0 && (self.has_top || deblock_mode != 2));
507 if can_do_top && (!tx8x8 || (y & 1) == 0) {
508 if is_s || cur_intra || top_intra {
509 let val = if y == 0 { 0x40 } else { 0x30 };
510 for el in self.deblock[y * 4..][..4].iter_mut() { *el |= val; }
513 let blk4 = x + y * 4;
514 let blk8 = x / 2 + (y / 2) * 2;
515 if self.get_cur_blk4(blk4).ncoded != 0 || self.get_top_blk4(blk4).ncoded != 0 {
516 self.deblock[y * 4 + x] |= 0x20;
518 let cur_mv = self.get_cur_blk4(blk4).mv;
519 let top_mv = self.get_top_blk4(blk4).mv;
520 let cur_ref = self.get_cur_blk8(blk8).ref_idx;
521 let top_ref = if (y & 1) == 0 { self.get_top_blk8(blk8).ref_idx } else { cur_ref };
522 if mvdiff4(cur_mv[0], top_mv[0]) || mvdiff4(cur_mv[1], top_mv[1]) || !frefs.cmp_refs(cur_ref, top_ref) {
523 self.deblock[y * 4 + x] |= 0x10;
529 let mut lleft_intra = left_intra;
531 let skip_8 = tx8x8 && (x & 1) != 0;
532 let can_do_left = x > 0 || self.has_left || (self.mb_x != 0 && deblock_mode != 2);
536 let blk4 = x + y * 4;
537 let blk8 = x / 2 + (y / 2) * 2;
539 } else if is_s || cur_intra || lleft_intra {
540 self.deblock[y * 4 + x] |= if x == 0 { 4 } else { 3 };
541 } else if self.get_cur_blk4(blk4).ncoded != 0 || self.get_left_blk4(blk4).ncoded != 0 {
542 self.deblock[y * 4 + x] |= 2;
544 let cur_mv = self.get_cur_blk4(blk4).mv;
545 let left_mv = self.get_left_blk4(blk4).mv;
546 let cur_ref = self.get_cur_blk8(blk8).ref_idx;
547 let left_ref = if (x & 1) == 0 { self.get_left_blk8(blk8).ref_idx } else { cur_ref };
548 if mvdiff4(cur_mv[0], left_mv[0]) || mvdiff4(cur_mv[1], left_mv[1]) || !frefs.cmp_refs(cur_ref, left_ref) {
549 self.deblock[y * 4 + x] |= 1;
552 lleft_intra = cur_intra;
554 top_intra = cur_intra;
557 pub fn next_mb(&mut self) {
559 self.has_left = true;
560 if self.mb_x == self.mb_w {
563 self.mb.update_row();
564 self.blk8.update_row();
565 self.blk4.update_row();
567 self.has_left = false;
569 self.has_top = self.mb_x + self.mb_y * self.mb_w >= self.mb_start + self.mb_w;
571 pub fn get_cur_mb_idx(&self) -> usize { self.mb.xpos + self.mb_x }
572 pub fn get_cur_blk8_idx(&self, blk_no: usize) -> usize {
573 self.blk8.xpos + self.mb_x * 2 + (blk_no & 1) + (blk_no >> 1) * self.blk8.stride
575 pub fn get_cur_blk4_idx(&self, blk_no: usize) -> usize {
576 self.blk4.xpos + self.mb_x * 4 + (blk_no & 3) + (blk_no >> 2) * self.blk4.stride
578 pub fn get_cur_mb(&mut self) -> &mut MBData {
579 let idx = self.get_cur_mb_idx();
580 &mut self.mb.data[idx]
582 pub fn get_left_mb(&self) -> &MBData {
583 &self.mb.data[self.get_cur_mb_idx() - 1]
585 pub fn get_top_mb(&self) -> &MBData {
586 &self.mb.data[self.get_cur_mb_idx() - self.mb.stride]
588 pub fn get_cur_blk8(&mut self, blk_no: usize) -> &mut Blk8Data {
589 let idx = self.get_cur_blk8_idx(blk_no);
590 &mut self.blk8.data[idx]
592 pub fn get_left_blk8(&self, blk_no: usize) -> &Blk8Data {
593 &self.blk8.data[self.get_cur_blk8_idx(blk_no) - 1]
595 pub fn get_top_blk8(&self, blk_no: usize) -> &Blk8Data {
596 &self.blk8.data[self.get_cur_blk8_idx(blk_no) - self.blk8.stride]
598 pub fn get_cur_blk4(&mut self, blk_no: usize) -> &mut Blk4Data {
599 let idx = self.get_cur_blk4_idx(blk_no);
600 &mut self.blk4.data[idx]
602 pub fn get_left_blk4(&self, blk_no: usize) -> &Blk4Data {
603 &self.blk4.data[self.get_cur_blk4_idx(blk_no) - 1]
605 pub fn get_top_blk4(&self, blk_no: usize) -> &Blk4Data {
606 &self.blk4.data[self.get_cur_blk4_idx(blk_no) - self.blk4.stride]
609 pub fn apply_to_blk8<F: (Fn(&mut Blk8Data))>(&mut self, f: F) {
610 let start = self.get_cur_blk8_idx(0);
611 for row in self.blk8.data[start..].chunks_mut(self.blk8.stride).take(2) {
612 for el in row[..2].iter_mut() {
617 pub fn apply_to_blk4<F: (Fn(&mut Blk4Data))>(&mut self, f: F) {
618 let start = self.get_cur_blk4_idx(0);
619 for row in self.blk4.data[start..].chunks_mut(self.blk4.stride).take(4) {
620 for el in row[..4].iter_mut() {
626 pub fn fill_ipred(&mut self, imode: IntraPredMode) {
627 self.apply_to_blk4(|blk| blk.ipred = imode);
629 pub fn fill_ncoded(&mut self, nc: u8) {
630 self.apply_to_blk4(|blk| blk.ncoded = nc);
631 self.apply_to_blk8(|blk| blk.ncoded_c = [nc; 2]);
633 pub fn reset_mb_mv(&mut self) {
634 self.apply_to_blk8(|blk| blk.ref_idx = [INVALID_REF; 2]);
637 pub fn get_mv_ctx(&self, xoff: usize, yoff: usize, ref_l: usize) -> (usize, usize) {
638 let blk_no = xoff / 4 + yoff;
639 let mv_a = self.get_left_blk4(blk_no).mvd[ref_l];
640 let mv_b = self.get_top_blk4(blk_no).mvd[ref_l];
641 let mv = mv_a + mv_b;
642 let ctx0 = if mv.x < 3 { 0 } else if mv.x <= 32 { 1 } else { 2 };
643 let ctx1 = if mv.y < 3 { 0 } else if mv.y <= 32 { 1 } else { 2 };
646 pub fn get_mv_ref_ctx(&self, xoff: usize, yoff: usize, ref_l: usize) -> usize {
647 let blk_no = xoff / 8 + (yoff / 8) * 2;
649 let left_ref = self.get_left_blk8(blk_no).ref_idx[ref_l];
650 let top_ref = self.get_top_blk8(blk_no).ref_idx[ref_l];
651 if !left_ref.not_avail() && !left_ref.is_direct() && left_ref.index() > 0 {
654 if !top_ref.not_avail() && !top_ref.is_direct() && top_ref.index() > 0 {
659 #[allow(clippy::if_same_then_else)]
660 pub fn predict(&mut self, xpos: usize, ypos: usize, bw: usize, bh: usize, ref_l: usize, diff_mv: MV, ref_idx: PicRef) {
661 let midx = self.get_cur_blk4_idx(0) + xpos / 4 + ypos / 4 * self.blk4.stride;
662 let ridx = self.get_cur_blk8_idx(0) + xpos / 8 + ypos / 8 * self.blk8.stride;
663 let ridx_c = self.get_cur_blk8_idx(0) + (xpos + bw) / 8 + ypos / 8 * self.blk8.stride - if (ypos & 4) == 0 { self.blk8.stride } else { 0 };
665 let mv_a = self.blk4.data[midx - 1].mv[ref_l];
666 let mv_b = self.blk4.data[midx - self.blk4.stride].mv[ref_l];
667 let mut mv_c = self.blk4.data[midx - self.blk4.stride + bw / 4].mv[ref_l];
669 let rx = if (xpos & 4) != 0 { 0 } else { 1 };
670 let ry = if (ypos & 4) != 0 { 0 } else { self.blk8.stride };
671 let ref_a = self.blk8.data[ridx - rx].ref_idx[ref_l];
672 let ref_b = self.blk8.data[ridx - ry].ref_idx[ref_l];
673 let mut ref_c = self.blk8.data[ridx_c].ref_idx[ref_l];
675 if ref_c == MISSING_REF || (((xpos + bw) & 4) == 0 && (ypos & 4) != 0) {
676 mv_c = self.blk4.data[midx - self.blk4.stride - 1].mv[ref_l];
677 ref_c = self.blk8.data[ridx - rx - ry].ref_idx[ref_l];
680 let pred_mv = if bw == 16 && bh == 8 && ypos == 0 && ref_b == ref_idx {
682 } else if bw == 16 && bh == 8 && ypos != 0 && ref_a == ref_idx {
684 } else if bw == 8 && bh == 16 && xpos == 0 && ref_a == ref_idx {
686 } else if bw == 8 && bh == 16 && xpos != 0 && ref_c == ref_idx {
688 } else if ref_b == MISSING_REF && ref_c == MISSING_REF {
691 let count = ((ref_a == ref_idx) as u8) + ((ref_b == ref_idx) as u8) + ((ref_c == ref_idx) as u8);
693 if ref_a == ref_idx {
695 } else if ref_b == ref_idx {
701 MV::pred(mv_a, mv_b, mv_c)
705 let mv = pred_mv + diff_mv;
706 self.fill_mv (xpos, ypos, bw, bh, ref_l, mv);
707 self.fill_ref(xpos, ypos, bw, bh, ref_l, ref_idx);
709 pub fn predict_pskip(&mut self) {
710 let midx = self.get_cur_blk4_idx(0);
711 let ridx = self.get_cur_blk8_idx(0);
713 let mv_a = self.blk4.data[midx - 1].mv[0];
714 let mv_b = self.blk4.data[midx - self.blk4.stride].mv[0];
715 let mut mv_c = self.blk4.data[midx - self.blk4.stride + 4].mv[0];
717 let ref_a = self.blk8.data[ridx - 1].ref_idx[0];
718 let ref_b = self.blk8.data[ridx - self.blk8.stride].ref_idx[0];
719 let mut ref_c = self.blk8.data[ridx - self.blk8.stride + 2].ref_idx[0];
721 if ref_c == MISSING_REF {
722 mv_c = self.blk4.data[midx - self.blk4.stride - 1].mv[0];
723 ref_c = self.blk8.data[ridx - self.blk8.stride - 1].ref_idx[0];
726 let ref_idx = ZERO_REF;
727 let mv = if ref_a == MISSING_REF || ref_b == MISSING_REF || (ref_a == ZERO_REF && mv_a == ZERO_MV) || (ref_b == ZERO_REF && mv_b == ZERO_MV) {
730 let count = ((ref_a == ref_idx) as u8) + ((ref_b == ref_idx) as u8) + ((ref_c == ref_idx) as u8);
732 if ref_a == ref_idx {
734 } else if ref_b == ref_idx {
740 MV::pred(mv_a, mv_b, mv_c)
744 self.fill_mv (0, 0, 16, 16, 0, mv);
745 self.fill_ref(0, 0, 16, 16, 0, ref_idx);
747 pub fn predict_direct_mb(&mut self, frame_refs: &FrameRefs, temporal_mv: bool, direct_8x8: bool, cur_id: u16) {
748 let (col_mb, r1_poc, r1_long) = frame_refs.get_colocated_info(self.mb_x, self.mb_y);
751 let (mv0, ref0, mv1, ref1) = self.get_direct_mv(frame_refs, &col_mb, r1_poc, r1_long, temporal_mv, cur_id, BLK4_TO_D8[blk4]);
752 self.get_cur_blk4(blk4).mv = [mv0, mv1];
753 self.get_cur_blk8(blk4_to_blk8(blk4)).ref_idx = [ref0, ref1];
755 } else if col_mb.mb_type.is_16x16_ref() || !temporal_mv {
756 let (mv0, ref0, mv1, ref1) = self.get_direct_mv(frame_refs, &col_mb, r1_poc, r1_long, temporal_mv, cur_id, 0);
757 self.apply_to_blk4(|blk4| blk4.mv = [mv0, mv1]);
758 self.apply_to_blk8(|blk8| blk8.ref_idx = [ref0, ref1]);
761 let (mv0, ref0, mv1, ref1) = self.get_direct_mv(frame_refs, &col_mb, r1_poc, r1_long, temporal_mv, cur_id, blk4);
762 self.get_cur_blk4(blk4).mv = [mv0, mv1];
763 self.get_cur_blk8(blk4_to_blk8(blk4)).ref_idx = [ref0, ref1];
767 pub fn predict_direct_sub(&mut self, frame_refs: &FrameRefs, temporal_mv: bool, direct8x8: bool, cur_id: u16, blk4: usize) {
768 let src_blk = if !direct8x8 { blk4 } else { BLK4_TO_D8[blk4] };
769 let (mbi, r1_poc, r1_long) = frame_refs.get_colocated_info(self.mb_x, self.mb_y);
770 let (mv0, ref0, mv1, ref1) = self.get_direct_mv(frame_refs, &mbi, r1_poc, r1_long, temporal_mv, cur_id, src_blk);
771 self.get_cur_blk4(blk4).mv = [mv0, mv1];
772 self.get_cur_blk8(blk4_to_blk8(blk4)).ref_idx = [ref0, ref1];
774 #[allow(clippy::nonminimal_bool)]
775 pub fn get_direct_mv(&self, frame_refs: &FrameRefs, mbi: &FrameMBInfo, r1_poc: u16, r1_long: bool, temporal_mv: bool, cur_id: u16, blk4: usize) -> (MV, PicRef, MV, PicRef) {
776 let blk8 = blk4_to_blk8(blk4);
777 let (col_mv, r0_poc, col_idx) = if mbi.ref_poc[blk8] == [MISSING_POC; 2] {
778 (ZERO_MV, MISSING_POC, MISSING_REF)
779 } else if mbi.ref_poc[blk8][0] != MISSING_POC {
780 (mbi.mv[blk4][0], mbi.ref_poc[blk8][0], mbi.ref_idx[blk8][0])
782 (mbi.mv[blk4][1], mbi.ref_poc[blk8][1], mbi.ref_idx[blk8][1])
784 let (col_ref, r0_long) = frame_refs.map_ref0(r0_poc);
786 let td = (i32::from(r1_poc) - i32::from(r0_poc)).max(-128).min(127);
787 if r0_long || td == 0 {
788 (col_mv, col_ref, ZERO_MV, ZERO_REF)
790 let tx = (16384 + (td / 2).abs()) / td;
791 let tb = (i32::from(cur_id) - i32::from(r0_poc)).max(-128).min(127);
792 let scale = ((tb * tx + 32) >> 6).max(-1024).min(1023);
794 x: ((i32::from(col_mv.x) * scale + 128) >> 8) as i16,
795 y: ((i32::from(col_mv.y) * scale + 128) >> 8) as i16,
797 let mv1 = mv0 - col_mv;
798 (mv0, col_ref, mv1, ZERO_REF)
801 let blk4 = 0; // we generate the same MV prediction for the whole MB
802 let blk8 = blk4_to_blk8(blk4);
803 let midx = self.get_cur_blk4_idx(blk4);
804 let ridx = self.get_cur_blk8_idx(blk8);
805 let ridx_c = self.get_cur_blk8_idx(blk8) + 16 / 8 - self.blk8.stride;
807 let mv_a = self.blk4.data[midx - 1].mv;
808 let mv_b = self.blk4.data[midx - self.blk4.stride].mv;
809 let mut mv_c = self.blk4.data[midx - self.blk4.stride + 16 / 4].mv;
811 let ref_a = self.blk8.data[ridx - 1].ref_idx;
812 let ref_b = self.blk8.data[ridx - self.blk8.stride].ref_idx;
813 let mut ref_c = self.blk8.data[ridx_c].ref_idx;
815 if ref_c == [MISSING_REF; 2] {
816 mv_c = self.blk4.data[midx - self.blk4.stride - 1].mv;
817 ref_c = self.blk8.data[ridx - self.blk8.stride - 1].ref_idx;
819 let mut refs = [INVALID_REF; 2];
820 for cur_ref in [ref_a, ref_b, ref_c].iter() {
821 refs[0] = refs[0].min_pos(cur_ref[0]);
822 refs[1] = refs[1].min_pos(cur_ref[1]);
824 if refs == [INVALID_REF; 2] {
825 return (ZERO_MV, ZERO_REF, ZERO_MV, ZERO_REF);
828 let mut col_zero = true;
829 if r1_long || col_idx != ZERO_REF {
832 if col_mv.x.abs() > 1 || col_mv.y.abs() > 1 {
835 let mut mvs = [ZERO_MV; 2];
837 if mbi.mb_type.is_intra() || (!refs[ref_l].not_avail() && !(refs[ref_l] == ZERO_REF && col_zero)) {
838 let ref_idx = refs[ref_l];
839 mvs[ref_l] = if ref_b[ref_l] == MISSING_REF && ref_c[ref_l] == MISSING_REF {
842 let count = ((ref_a[ref_l] == ref_idx) as u8) + ((ref_b[ref_l] == ref_idx) as u8) + ((ref_c[ref_l] == ref_idx) as u8);
844 if ref_a[ref_l] == ref_idx {
846 } else if ref_b[ref_l] == ref_idx {
852 MV::pred(mv_a[ref_l], mv_b[ref_l], mv_c[ref_l])
857 (mvs[0], refs[0], mvs[1], refs[1])
860 pub fn fill_mv(&mut self, xpos: usize, ypos: usize, bw: usize, bh: usize, ref_l: usize, mv: MV) {
861 let start = self.get_cur_blk4_idx(0) + xpos / 4 + ypos / 4 * self.blk4.stride;
862 for row in self.blk4.data[start..].chunks_mut(self.blk4.stride).take(bh / 4) {
863 for blk in row[..bw / 4].iter_mut() {
868 pub fn fill_mvd(&mut self, xpos: usize, ypos: usize, bw: usize, bh: usize, ref_l: usize, mv: MV) {
869 let mvd = MV{ x: mv.x.abs().min(128), y: mv.y.abs().min(128) };
870 let start = self.get_cur_blk4_idx(0) + xpos / 4 + ypos / 4 * self.blk4.stride;
871 for row in self.blk4.data[start..].chunks_mut(self.blk4.stride).take(bh / 4) {
872 for blk in row[..bw / 4].iter_mut() {
873 blk.mvd[ref_l] = mvd;
877 pub fn fill_ref(&mut self, xpos: usize, ypos: usize, bw: usize, bh: usize, ref_l: usize, ref_idx: PicRef) {
878 let start = self.get_cur_blk8_idx(0) + xpos / 8 + ypos / 8 * self.blk8.stride;
879 if bw < 8 || bh < 8 {
880 self.blk8.data[start].ref_idx[ref_l] = ref_idx;
882 for row in self.blk8.data[start..].chunks_mut(self.blk8.stride).take(bh / 8) {
883 for blk in row[..bw / 8].iter_mut() {
884 blk.ref_idx[ref_l] = ref_idx;
891 fn mvdiff4(mv1: MV, mv2: MV) -> bool {
893 (mv.x.abs() >= 4) || (mv.y.abs() >= 4)