1use std::sync::Arc;
8
9use super::env::{fix_mv_precision, get_gmv_2d, Mv};
10use super::intra_edge::EDGE_I444_TOP_HAS_RIGHT;
11use super::obu::{get_poc_diff, FrameHeader, SeqHeader, WM_TRANSLATION};
12use super::tables::BLOCK_DIMENSIONS;
13
14#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
15pub struct TemporalBlock {
16 pub mv: Mv,
17 pub r: i8,
18}
19
20#[derive(Clone, Copy, PartialEq, Eq, Debug)]
21pub struct RefmvsBlock {
22 pub mv: [Mv; 2],
23 pub r: [i8; 2],
25 pub bs: u8,
26 pub mf: u8,
28}
29
30impl Default for RefmvsBlock {
31 fn default() -> Self {
32 RefmvsBlock {
33 mv: [Mv::ZERO; 2],
34 r: [0, -1],
35 bs: 0,
36 mf: 0,
37 }
38 }
39}
40
41#[derive(Clone, Copy, Default, Debug)]
42pub struct RefmvsCandidate {
43 pub mv: [Mv; 2],
44 pub weight: i32,
45}
46
47#[derive(Clone)]
48pub struct RefmvsFrame {
49 pub iw4: i32,
50 pub ih4: i32,
51 pub iw8: i32,
52 pub ih8: i32,
53 pub use_ref_frame_mvs: bool,
54 pub sign_bias: [u8; 7],
55 pub mfmv_sign: [u8; 7],
56 pub pocdiff: [i8; 7],
57 pub mfmv_ref: [u8; 3],
58 pub mfmv_ref2cur: [i32; 3],
59 pub mfmv_ref2ref: [[i32; 7]; 3],
60 pub n_mfmvs: usize,
61 pub rp: Vec<TemporalBlock>,
63 pub rp_ref: [Option<Arc<Vec<TemporalBlock>>>; 7],
64 pub rp_proj: Vec<TemporalBlock>,
66 pub rp_stride: usize,
67 pub r: Vec<RefmvsBlock>,
69 pub r_stride: usize,
70}
71
72#[derive(Clone)]
73pub struct RefmvsTile {
74 pub col_start: i32,
75 pub col_end: i32,
76 pub row_start: i32,
77 pub row_end: i32,
78}
79
80impl RefmvsFrame {
81 pub fn new(
83 seq: &SeqHeader,
84 hdr: &FrameHeader,
85 ref_poc: &[u32; 7],
86 ref_ref_poc: &[[u32; 7]; 7],
87 rp_ref: [Option<Arc<Vec<TemporalBlock>>>; 7],
88 ) -> Self {
89 let rp_stride = (((hdr.width[0] + 127) & !127) >> 3) as usize;
90 let iw8 = (hdr.width[0] + 7) >> 3;
91 let ih8 = (hdr.height + 7) >> 3;
92 let sb = 16 << seq.sb128 as i32;
93 let r_rows = (((ih8 * 2 + sb - 1) / sb) * sb) as usize;
95 let mut rf = RefmvsFrame {
96 iw4: iw8 << 1,
97 ih4: ih8 << 1,
98 iw8,
99 ih8,
100 use_ref_frame_mvs: false,
101 sign_bias: [0; 7],
102 mfmv_sign: [0; 7],
103 pocdiff: [0; 7],
104 mfmv_ref: [0; 3],
105 mfmv_ref2cur: [0; 3],
106 mfmv_ref2ref: [[0; 7]; 3],
107 n_mfmvs: 0,
108 rp: vec![TemporalBlock::default(); rp_stride * (r_rows / 2 + 1)],
109 rp_ref,
110 rp_proj: vec![TemporalBlock::default(); rp_stride * (r_rows / 2 + 1)],
111 rp_stride,
112 r: vec![RefmvsBlock::default(); rp_stride * 2 * r_rows],
113 r_stride: rp_stride * 2,
114 };
115 let nb = seq.order_hint_n_bits;
116 let poc = hdr.frame_offset as i32;
117 for i in 0..7 {
118 let d = get_poc_diff(nb, ref_poc[i] as i32, poc);
119 rf.sign_bias[i] = (d > 0) as u8;
120 rf.mfmv_sign[i] = (d < 0) as u8;
121 rf.pocdiff[i] = get_poc_diff(nb, poc, ref_poc[i] as i32).clamp(-31, 31) as i8;
122 }
123 if hdr.use_ref_frame_mvs && nb != 0 {
124 let mut total = 2;
125 let rr = &rf.rp_ref;
126 let mut refs = Vec::new();
127 if rr[0].is_some() && ref_ref_poc[0][6] != ref_poc[3] {
128 refs.push(0u8);
129 total = 3;
130 }
131 if rr[4].is_some() && get_poc_diff(nb, ref_poc[4] as i32, poc) > 0 {
132 refs.push(4);
133 }
134 if rr[5].is_some() && get_poc_diff(nb, ref_poc[5] as i32, poc) > 0 {
135 refs.push(5);
136 }
137 if refs.len() < total && rr[6].is_some() && get_poc_diff(nb, ref_poc[6] as i32, poc) > 0
138 {
139 refs.push(6);
140 }
141 if refs.len() < total && rr[1].is_some() {
142 refs.push(1);
143 }
144 rf.n_mfmvs = refs.len();
145 for (n, &m) in refs.iter().enumerate() {
146 rf.mfmv_ref[n] = m;
147 let rpoc = ref_poc[m as usize] as i32;
148 let diff1 = get_poc_diff(nb, rpoc, poc);
149 if diff1.abs() > 31 {
150 rf.mfmv_ref2cur[n] = i32::MIN;
151 } else {
152 rf.mfmv_ref2cur[n] = if m < 4 { -diff1 } else { diff1 };
153 for k in 0..7 {
154 let rrpoc = ref_ref_poc[m as usize][k] as i32;
155 let diff2 = get_poc_diff(nb, rpoc, rrpoc);
156 rf.mfmv_ref2ref[n][k] = if diff2 as u32 > 31 { 0 } else { diff2 };
157 }
158 }
159 }
160 }
161 rf.use_ref_frame_mvs = rf.n_mfmvs > 0;
162 rf
163 }
164
165 #[inline]
166 pub fn blk(&self, y4: i32, x4: i32) -> &RefmvsBlock {
167 &self.r[y4 as usize * self.r_stride + x4 as usize]
168 }
169
170 pub fn splat(&mut self, b: &RefmvsBlock, by4: i32, bx4: i32, bw4: i32, bh4: i32) {
172 for y in 0..bh4 {
173 let o = (by4 + y) as usize * self.r_stride + bx4 as usize;
174 for v in &mut self.r[o..o + bw4 as usize] {
175 *v = *b;
176 }
177 }
178 }
179
180 pub fn load_tmvs(&mut self, col_start8: i32, col_end8: i32, row_start8: i32, row_end8: i32) {
182 let row_end8 = row_end8.min(self.ih8);
183 let col_start8i = (col_start8 - 8).max(0);
184 let col_end8i = (col_end8 + 8).min(self.iw8);
185 let stride = self.rp_stride;
186 for y in row_start8..row_end8 {
187 for x in col_start8..col_end8 {
188 self.rp_proj[y as usize * stride + x as usize].mv = Mv::INVALID;
189 }
190 }
191 for n in 0..self.n_mfmvs {
192 let ref2cur = self.mfmv_ref2cur[n];
193 if ref2cur == i32::MIN {
194 continue;
195 }
196 let r = self.mfmv_ref[n] as usize;
197 let ref_sign = r as i32 - 4;
198 let rp_ref = self.rp_ref[r].clone().unwrap();
199 for y in row_start8..row_end8 {
200 let y_sb_align = y & !7;
201 let y_proj_start = y_sb_align.max(row_start8);
202 let y_proj_end = (y_sb_align + 8).min(row_end8);
203 let row = &rp_ref[y as usize * stride..];
204 let mut x = col_start8i;
205 while x < col_end8i {
206 let mut rb = x as usize;
207 let b_ref = row[rb].r;
208 if b_ref == 0 {
209 x += 1;
210 continue;
211 }
212 let ref2ref = self.mfmv_ref2ref[n][b_ref as usize - 1];
213 if ref2ref == 0 {
214 x += 1;
215 continue;
216 }
217 let b_mv = row[rb].mv;
218 let off = mv_projection(b_mv, ref2cur, ref2ref);
219 let sgn = |v: i32, s: i32| if s < 0 { -v } else { v };
220 let mut pos_x = x + sgn((off.x as i32).abs() >> 6, off.x as i32 ^ ref_sign);
221 let pos_y = y + sgn((off.y as i32).abs() >> 6, off.y as i32 ^ ref_sign);
222 if pos_y >= y_proj_start && pos_y < y_proj_end {
223 let pos = pos_y as usize * stride;
224 loop {
225 let x_sb_align = x & !7;
226 if pos_x >= (x_sb_align - 8).max(col_start8)
227 && pos_x < (x_sb_align + 16).min(col_end8)
228 {
229 let t = &mut self.rp_proj[pos + pos_x as usize];
230 t.mv = row[rb].mv;
231 t.r = ref2ref as i8;
232 }
233 x += 1;
234 if x >= col_end8i {
235 break;
236 }
237 rb += 1;
238 if row[rb].r != b_ref || row[rb].mv != b_mv {
239 break;
240 }
241 pos_x += 1;
242 }
243 } else {
244 loop {
245 x += 1;
246 if x >= col_end8i {
247 break;
248 }
249 rb += 1;
250 if row[rb].r != b_ref || row[rb].mv != b_mv {
251 break;
252 }
253 }
254 }
255 }
256 }
257 }
258 }
259
260 pub fn save_tmvs(&mut self, col_start8: i32, col_end8: i32, row_start8: i32, row_end8: i32) {
262 let row_end8 = row_end8.min(self.ih8);
263 let col_end8 = col_end8.min(self.iw8);
264 for y in row_start8..row_end8 {
265 let b = (y as usize * 2 + 1) * self.r_stride;
266 let rp = y as usize * self.rp_stride;
267 let mut x = col_start8;
268 while x < col_end8 {
269 let c = self.r[b + x as usize * 2 + 1];
270 let bw8 = (BLOCK_DIMENSIONS[c.bs as usize][0] as i32 + 1) >> 1;
271 let ok = |k: usize| {
272 c.r[k] > 0
273 && self.mfmv_sign[c.r[k] as usize - 1] != 0
274 && ((c.mv[k].y as i32).abs() | (c.mv[k].x as i32).abs()) < 4096
275 };
276 let t = if ok(1) {
277 TemporalBlock {
278 mv: c.mv[1],
279 r: c.r[1],
280 }
281 } else if ok(0) {
282 TemporalBlock {
283 mv: c.mv[0],
284 r: c.r[0],
285 }
286 } else {
287 TemporalBlock { mv: Mv::ZERO, r: 0 }
288 };
289 for _ in 0..bw8 {
290 self.rp[rp + x as usize] = t;
291 x += 1;
292 }
293 }
294 }
295 }
296}
297
298fn mv_projection(mv: Mv, num: i32, den: i32) -> Mv {
299 const DIV_MULT: [u16; 32] = [
300 0, 16384, 8192, 5461, 4096, 3276, 2730, 2340, 2048, 1820, 1638, 1489, 1365, 1260, 1170,
301 1092, 1024, 963, 910, 862, 819, 780, 744, 712, 682, 655, 630, 606, 585, 564, 546, 528,
302 ];
303 let frac = num * DIV_MULT[den as usize] as i32;
304 let y = mv.y as i32 * frac;
305 let x = mv.x as i32 * frac;
306 Mv {
307 y: ((y + 8192 + (y >> 31)) >> 14).clamp(-0x3fff, 0x3fff) as i16,
308 x: ((x + 8192 + (x >> 31)) >> 14).clamp(-0x3fff, 0x3fff) as i16,
309 }
310}
311
312struct Find<'a> {
313 stack: [RefmvsCandidate; 9],
314 cnt: usize,
315 r: [i8; 2],
316 gmv: [Mv; 2],
317 have_newmv: bool,
318 rf: &'a RefmvsFrame,
319}
320
321impl Find<'_> {
322 fn add_spatial(&mut self, weight: i32, b: &RefmvsBlock, row_match: &mut bool, newmv: bool) {
323 if b.mv[0] == Mv::INVALID {
324 return;
325 }
326 let gmv = self.gmv;
327 if self.r[1] == -1 {
328 for n in 0..2 {
329 if b.r[n] == self.r[0] {
330 let cand = if b.mf & 1 != 0 && gmv[0] != Mv::INVALID {
331 gmv[0]
332 } else {
333 b.mv[n]
334 };
335 *row_match = true;
336 if newmv {
337 self.have_newmv |= b.mf >> 1 != 0;
338 }
339 let last = self.cnt;
340 for m in 0..last {
341 if self.stack[m].mv[0] == cand {
342 self.stack[m].weight += weight;
343 return;
344 }
345 }
346 if last < 8 {
347 self.stack[last].mv[0] = cand;
348 self.stack[last].weight = weight;
349 self.cnt = last + 1;
350 }
351 return;
352 }
353 }
354 } else if b.r == self.r {
355 let cand = [
356 if b.mf & 1 != 0 && gmv[0] != Mv::INVALID {
357 gmv[0]
358 } else {
359 b.mv[0]
360 },
361 if b.mf & 1 != 0 && gmv[1] != Mv::INVALID {
362 gmv[1]
363 } else {
364 b.mv[1]
365 },
366 ];
367 *row_match = true;
368 if newmv {
369 self.have_newmv |= b.mf >> 1 != 0;
370 }
371 let last = self.cnt;
372 for n in 0..last {
373 if self.stack[n].mv == cand {
374 self.stack[n].weight += weight;
375 return;
376 }
377 }
378 if last < 8 {
379 self.stack[last].mv = cand;
380 self.stack[last].weight = weight;
381 self.cnt = last + 1;
382 }
383 }
384 }
385
386 #[allow(clippy::too_many_arguments)]
387 fn scan_row(
388 &mut self,
389 y4: i32,
390 x4: i32,
391 bw4: i32,
392 w4: i32,
393 max_rows: i32,
394 step: i32,
395 m: &mut bool,
396 newmv: bool,
397 ) -> u32 {
398 let rf = self.rf;
399 let first = *rf.blk(y4, x4);
400 let fdim = BLOCK_DIMENSIONS[first.bs as usize];
401 let cand_bw4 = fdim[0] as i32;
402 let mut len = step.max(bw4.min(cand_bw4));
403 if bw4 <= cand_bw4 {
404 let weight = if bw4 == 1 {
405 2
406 } else {
407 2.max((2 * max_rows).min(fdim[1] as i32))
408 };
409 self.add_spatial(len * weight, &first, m, newmv);
410 return (weight >> 1) as u32;
411 }
412 let mut x = 0;
413 let mut cand = first;
414 loop {
415 self.add_spatial(len * 2, &cand, m, newmv);
416 x += len;
417 if x >= w4 {
418 return 1;
419 }
420 cand = *rf.blk(y4, x4 + x);
421 len = step.max(BLOCK_DIMENSIONS[cand.bs as usize][0] as i32);
422 }
423 }
424
425 #[allow(clippy::too_many_arguments)]
426 fn scan_col(
427 &mut self,
428 y4: i32,
429 x4: i32,
430 bh4: i32,
431 h4: i32,
432 max_cols: i32,
433 step: i32,
434 m: &mut bool,
435 newmv: bool,
436 ) -> u32 {
437 let rf = self.rf;
438 let first = *rf.blk(y4, x4);
439 let fdim = BLOCK_DIMENSIONS[first.bs as usize];
440 let cand_bh4 = fdim[1] as i32;
441 let mut len = step.max(bh4.min(cand_bh4));
442 if bh4 <= cand_bh4 {
443 let weight = if bh4 == 1 {
444 2
445 } else {
446 2.max((2 * max_cols).min(fdim[0] as i32))
447 };
448 self.add_spatial(len * weight, &first, m, newmv);
449 return (weight >> 1) as u32;
450 }
451 let mut y = 0;
452 let mut cand = first;
453 loop {
454 self.add_spatial(len * 2, &cand, m, newmv);
455 y += len;
456 if y >= h4 {
457 return 1;
458 }
459 cand = *rf.blk(y4 + y, x4);
460 len = step.max(BLOCK_DIMENSIONS[cand.bs as usize][1] as i32);
461 }
462 }
463
464 fn add_temporal(
465 &mut self,
466 hdr: &FrameHeader,
467 rb: &TemporalBlock,
468 globalmv_ctx: Option<&mut i32>,
469 tgmv: &[Mv; 2],
470 ) {
471 if rb.mv == Mv::INVALID {
472 return;
473 }
474 let rf = self.rf;
475 let mut mv = mv_projection(
476 rb.mv,
477 rf.pocdiff[self.r[0] as usize - 1] as i32,
478 rb.r as i32,
479 );
480 fix_mv_precision(hdr, &mut mv);
481 let last = self.cnt;
482 if self.r[1] == -1 {
483 if let Some(g) = globalmv_ctx {
484 *g = (((mv.x as i32 - tgmv[0].x as i32).abs()
485 | (mv.y as i32 - tgmv[0].y as i32).abs())
486 >= 16) as i32;
487 }
488 for n in 0..last {
489 if self.stack[n].mv[0] == mv {
490 self.stack[n].weight += 2;
491 return;
492 }
493 }
494 if last < 8 {
495 self.stack[last].mv[0] = mv;
496 self.stack[last].weight = 2;
497 self.cnt = last + 1;
498 }
499 } else {
500 let mut mv1 = mv_projection(
501 rb.mv,
502 rf.pocdiff[self.r[1] as usize - 1] as i32,
503 rb.r as i32,
504 );
505 fix_mv_precision(hdr, &mut mv1);
506 let p = [mv, mv1];
507 for n in 0..last {
508 if self.stack[n].mv == p {
509 self.stack[n].weight += 2;
510 return;
511 }
512 }
513 if last < 8 {
514 self.stack[last].mv = p;
515 self.stack[last].weight = 2;
516 self.cnt = last + 1;
517 }
518 }
519 }
520}
521
522fn neg(m: Mv) -> Mv {
523 Mv {
524 y: m.y.wrapping_neg(),
525 x: m.x.wrapping_neg(),
526 }
527}
528
529fn add_compound_extended(
532 st: &mut [RefmvsCandidate; 9],
533 base: usize,
534 cnt: &mut [usize; 4],
535 c: &RefmvsBlock,
536 s0: u8,
537 s1: u8,
538 r: [i8; 2],
539 sign_bias: &[u8; 7],
540) {
541 for n in 0..2 {
542 let cr = c.r[n];
543 if cr <= 0 {
544 break;
545 }
546 let mut m = c.mv[n];
547 let sb = sign_bias[cr as usize - 1];
548 if cr == r[0] {
549 if cnt[0] < 2 {
550 st[base + cnt[0]].mv[0] = m;
551 cnt[0] += 1;
552 }
553 if cnt[3] < 2 {
554 if s1 ^ sb != 0 {
555 m = neg(m);
556 }
557 st[base + 2 + cnt[3]].mv[1] = m;
558 cnt[3] += 1;
559 }
560 } else if cr == r[1] {
561 if cnt[1] < 2 {
562 st[base + cnt[1]].mv[1] = m;
563 cnt[1] += 1;
564 }
565 if cnt[2] < 2 {
566 if s0 ^ sb != 0 {
567 m = neg(m);
568 }
569 st[base + 2 + cnt[2]].mv[0] = m;
570 cnt[2] += 1;
571 }
572 } else {
573 let im = neg(m);
574 if cnt[2] < 2 {
575 st[base + 2 + cnt[2]].mv[0] = if s0 ^ sb != 0 { im } else { m };
576 cnt[2] += 1;
577 }
578 if cnt[3] < 2 {
579 st[base + 2 + cnt[3]].mv[1] = if s1 ^ sb != 0 { im } else { m };
580 cnt[3] += 1;
581 }
582 }
583 }
584}
585
586fn add_single_extended(
587 st: &mut [RefmvsCandidate; 9],
588 cnt: &mut usize,
589 c: &RefmvsBlock,
590 sign: u8,
591 sign_bias: &[u8; 7],
592) {
593 for n in 0..2 {
594 let cr = c.r[n];
595 if cr <= 0 {
596 break;
597 }
598 let mut m = c.mv[n];
599 if sign ^ sign_bias[cr as usize - 1] != 0 {
600 m = neg(m);
601 }
602 let last = *cnt;
603 if !(0..last).any(|k| st[k].mv[0] == m) {
604 st[last].mv[0] = m;
605 st[last].weight = 2;
606 *cnt = last + 1;
607 }
608 }
609}
610
611#[allow(clippy::too_many_arguments)]
613pub fn find(
614 rf: &RefmvsFrame,
615 hdr: &FrameHeader,
616 rt: &RefmvsTile,
617 r: [i8; 2],
618 bs: usize,
619 edge_flags: u8,
620 by4: i32,
621 bx4: i32,
622) -> ([RefmvsCandidate; 8], usize, i32) {
623 let b_dim = BLOCK_DIMENSIONS[bs];
624 let bw4 = b_dim[0] as i32;
625 let w4 = bw4.min(16).min(rt.col_end - bx4);
626 let bh4 = b_dim[1] as i32;
627 let h4 = bh4.min(16).min(rt.row_end - by4);
628 let mut gmv = [Mv::INVALID; 2];
629 let mut tgmv = [Mv::ZERO; 2];
630 if r[0] > 0 {
631 let g = &hdr.gmv[r[0] as usize - 1];
632 tgmv[0] = get_gmv_2d(g, bx4, by4, bw4, bh4, hdr);
633 gmv[0] = if g.typ > WM_TRANSLATION {
634 tgmv[0]
635 } else {
636 Mv::INVALID
637 };
638 }
639 if r[1] > 0 {
640 let g = &hdr.gmv[r[1] as usize - 1];
641 tgmv[1] = get_gmv_2d(g, bx4, by4, bw4, bh4, hdr);
642 gmv[1] = if g.typ > WM_TRANSLATION {
643 tgmv[1]
644 } else {
645 Mv::INVALID
646 };
647 }
648 let mut f = Find {
649 stack: [RefmvsCandidate::default(); 9],
650 cnt: 0,
651 r,
652 gmv,
653 have_newmv: false,
654 rf,
655 };
656
657 let (mut have_col_mvs, mut have_row_mvs) = (false, false);
658 let mut max_rows = 0;
659 let mut n_rows = !0u32;
660 if by4 > rt.row_start {
661 max_rows = ((by4 - rt.row_start + 1) >> 1).min(2 + (bh4 > 1) as i32);
662 n_rows = f.scan_row(
663 by4 - 1,
664 bx4,
665 bw4,
666 w4,
667 max_rows,
668 if bw4 >= 16 { 4 } else { 1 },
669 &mut have_row_mvs,
670 true,
671 );
672 }
673 let mut max_cols = 0;
674 let mut n_cols = !0u32;
675 if bx4 > rt.col_start {
676 max_cols = ((bx4 - rt.col_start + 1) >> 1).min(2 + (bw4 > 1) as i32);
677 n_cols = f.scan_col(
678 by4,
679 bx4 - 1,
680 bh4,
681 h4,
682 max_cols,
683 if bh4 >= 16 { 4 } else { 1 },
684 &mut have_col_mvs,
685 true,
686 );
687 }
688 if n_rows != !0
689 && edge_flags & EDGE_I444_TOP_HAS_RIGHT != 0
690 && bw4.max(bh4) <= 16
691 && bw4 + bx4 < rt.col_end
692 {
693 let b = *rf.blk(by4 - 1, bx4 + bw4);
694 f.add_spatial(4, &b, &mut have_row_mvs, true);
695 }
696 let nearest_match = have_col_mvs as i32 + have_row_mvs as i32;
697 let nearest_cnt = f.cnt;
698 for c in f.stack.iter_mut().take(nearest_cnt) {
699 c.weight += 640;
700 }
701
702 let mut globalmv_ctx = hdr.use_ref_frame_mvs as i32;
704 if rf.use_ref_frame_mvs {
705 let stride = rf.rp_stride as i32;
706 let (by8, bx8) = (by4 >> 1, bx4 >> 1);
707 let rbi = by8 * stride + bx8;
708 let step_h = if bw4 >= 16 { 2 } else { 1 };
709 let step_v = if bh4 >= 16 { 2 } else { 1 };
710 let w8 = ((w4 + 1) >> 1).min(8);
711 let h8 = ((h4 + 1) >> 1).min(8);
712 let mut y = 0;
713 while y < h8 {
714 let mut x = 0;
715 while x < w8 {
716 let rb = rf.rp_proj[(rbi + y * stride + x) as usize];
717 if x == 0 && y == 0 {
718 f.add_temporal(hdr, &rb, Some(&mut globalmv_ctx), &tgmv);
719 } else {
720 f.add_temporal(hdr, &rb, None, &tgmv);
721 }
722 x += step_h;
723 }
724 y += step_v;
725 }
726 if bw4.min(bh4) >= 2 && bw4.max(bh4) < 16 {
727 let (bh8, bw8) = (bh4 >> 1, bw4 >> 1);
728 let rb = rbi + bh8 * stride;
729 let has_bottom = by8 + bh8 < (rt.row_end >> 1).min((by8 & !7) + 8);
730 if has_bottom && bx8 > (rt.col_start >> 1).max(bx8 & !7) {
731 let t = rf.rp_proj[(rb - 1) as usize];
732 f.add_temporal(hdr, &t, None, &tgmv);
733 }
734 if bx8 + bw8 < (rt.col_end >> 1).min((bx8 & !7) + 8) {
735 if has_bottom {
736 let t = rf.rp_proj[(rb + bw8) as usize];
737 f.add_temporal(hdr, &t, None, &tgmv);
738 }
739 if by8 + bh8 - 1 < (rt.row_end >> 1).min((by8 & !7) + 8) {
740 let t = rf.rp_proj[(rb + bw8 - stride) as usize];
741 f.add_temporal(hdr, &t, None, &tgmv);
742 }
743 }
744 }
745 }
746
747 let mut dummy = false;
749 if n_rows != !0 && n_cols != !0 {
750 let b = *rf.blk(by4 - 1, bx4 - 1);
751 f.add_spatial(4, &b, &mut have_row_mvs, false);
752 }
753 let _ = &mut dummy;
754 for n in 2..=3u32 {
756 if n > n_rows && n as i32 <= max_rows {
757 let y4 = by4 - (by4 & 31) + (((by4 & 31) - 2 * n as i32 + 1) | 1);
758 n_rows = n_rows.wrapping_add(f.scan_row(
759 y4,
760 bx4 | 1,
761 bw4,
762 w4,
763 1 + max_rows - n as i32,
764 if bw4 >= 16 { 4 } else { 2 },
765 &mut have_row_mvs,
766 false,
767 ));
768 }
769 if n > n_cols && n as i32 <= max_cols {
770 let y4 = by4 - (by4 & 31) + ((by4 & 31) | 1);
771 n_cols = n_cols.wrapping_add(f.scan_col(
772 y4,
773 (bx4 - n as i32 * 2 + 1) | 1,
774 bh4,
775 h4,
776 1 + max_cols - n as i32,
777 if bh4 >= 16 { 4 } else { 2 },
778 &mut have_col_mvs,
779 false,
780 ));
781 }
782 }
783 let ref_match_count = have_col_mvs as i32 + have_row_mvs as i32;
784 let have_newmv = f.have_newmv as i32;
785 let (refmv_ctx, newmv_ctx) = match nearest_match {
786 0 => (ref_match_count.min(2), (ref_match_count > 0) as i32),
787 1 => ((ref_match_count * 3).min(4), 3 - have_newmv),
788 _ => (5, 5 - have_newmv),
789 };
790
791 let mut len = nearest_cnt;
793 while len > 0 {
794 let mut last = 0;
795 for n in 1..len {
796 if f.stack[n - 1].weight < f.stack[n].weight {
797 f.stack.swap(n - 1, n);
798 last = n;
799 }
800 }
801 len = last;
802 }
803 len = f.cnt;
804 while len > nearest_cnt {
805 let mut last = nearest_cnt;
806 for n in nearest_cnt + 1..len {
807 if f.stack[n - 1].weight < f.stack[n].weight {
808 f.stack.swap(n - 1, n);
809 last = n;
810 }
811 }
812 len = last;
813 }
814
815 let mut cnt = f.cnt;
816 let mut st = f.stack;
817 let clamp_bounds = (
818 -(bx4 + bw4 + 4) * 4 * 8,
819 (rf.iw4 - bx4 + 4) * 4 * 8,
820 -(by4 + bh4 + 4) * 4 * 8,
821 (rf.ih4 - by4 + 4) * 4 * 8,
822 );
823 let clampmv = |m: &mut Mv| {
824 let (l, rr, t, b) = clamp_bounds;
825 m.x = (m.x as i32).clamp(l, rr) as i16;
826 m.y = (m.y as i32).clamp(t, b) as i16;
827 };
828 let ctx = if r[1] > 0 {
829 if cnt < 2 {
830 let s0 = rf.sign_bias[r[0] as usize - 1];
831 let s1 = rf.sign_bias[r[1] as usize - 1];
832 let sz4 = w4.min(h4);
833 let base = cnt;
834 let mut sc = [0usize; 4];
835 if n_rows != !0 {
836 let mut x = 0;
837 while x < sz4 {
838 let c = *rf.blk(by4 - 1, bx4 + x);
839 add_compound_extended(&mut st, base, &mut sc, &c, s0, s1, r, &rf.sign_bias);
840 x += BLOCK_DIMENSIONS[c.bs as usize][0] as i32;
841 }
842 }
843 if n_cols != !0 {
844 let mut y = 0;
845 while y < sz4 {
846 let c = *rf.blk(by4 + y, bx4 - 1);
847 add_compound_extended(&mut st, base, &mut sc, &c, s0, s1, r, &rf.sign_bias);
848 y += BLOCK_DIMENSIONS[c.bs as usize][1] as i32;
849 }
850 }
851 for n in 0..2 {
852 let mut m = sc[n];
853 if m >= 2 {
854 continue;
855 }
856 let l = sc[2 + n];
857 if l != 0 {
858 st[base + m].mv[n] = st[base + 2].mv[n];
859 m += 1;
860 if m == 2 {
861 continue;
862 }
863 if l == 2 {
864 st[base + 1].mv[n] = st[base + 3].mv[n];
865 continue;
866 }
867 }
868 loop {
869 st[base + m].mv[n] = tgmv[n];
870 m += 1;
871 if m >= 2 {
872 break;
873 }
874 }
875 }
876 let mut n = cnt;
877 if n == 1 && st[0].mv == st[base].mv {
878 st[1].mv = st[2].mv;
879 }
880 loop {
881 st[n].weight = 2;
882 n += 1;
883 if n >= 2 {
884 break;
885 }
886 }
887 cnt = 2;
888 }
889 for c in st.iter_mut().take(cnt) {
890 clampmv(&mut c.mv[0]);
891 clampmv(&mut c.mv[1]);
892 }
893 match refmv_ctx >> 1 {
894 0 => newmv_ctx.min(1),
895 1 => 1 + newmv_ctx.min(3),
896 _ => (3 + newmv_ctx).clamp(4, 7),
897 }
898 } else {
899 if cnt < 2 && r[0] > 0 {
900 let sign = rf.sign_bias[r[0] as usize - 1];
901 let sz4 = w4.min(h4);
902 if n_rows != !0 {
903 let mut x = 0;
904 while x < sz4 && cnt < 2 {
905 let c = *rf.blk(by4 - 1, bx4 + x);
906 add_single_extended(&mut st, &mut cnt, &c, sign, &rf.sign_bias);
907 x += BLOCK_DIMENSIONS[c.bs as usize][0] as i32;
908 }
909 }
910 if n_cols != !0 {
911 let mut y = 0;
912 while y < sz4 && cnt < 2 {
913 let c = *rf.blk(by4 + y, bx4 - 1);
914 add_single_extended(&mut st, &mut cnt, &c, sign, &rf.sign_bias);
915 y += BLOCK_DIMENSIONS[c.bs as usize][1] as i32;
916 }
917 }
918 }
919 for c in st.iter_mut().take(cnt) {
920 clampmv(&mut c.mv[0]);
921 }
922 for c in st.iter_mut().take(2).skip(cnt) {
923 c.mv[0] = tgmv[0];
924 }
925 (refmv_ctx << 4) | (globalmv_ctx << 3) | newmv_ctx
926 };
927 let mut out = [RefmvsCandidate::default(); 8];
928 out.copy_from_slice(&st[..8]);
929 (out, cnt, ctx)
930}