Skip to main content

threers_codec/decode/av1/
refmvs.rs

1//! Spatial and temporal motion-vector candidates (dav1d `src/refmvs.c`).
2//!
3//! dav1d keeps 35 rotating rows of 4x4 block info per superblock row; the
4//! reads only ever reach the current superblock row and the odd rows -1,
5//! -3, -5 above it, so a whole-frame array is equivalent and is used here.
6
7use 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    /// `[0]` = 0: intra; `[1]` = -1: not compound.
24    pub r: [i8; 2],
25    pub bs: u8,
26    /// 1 = globalmv+affine, 2 = newmv.
27    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    /// This frame's saved temporal MVs (8x8), `rp_stride` wide.
62    pub rp: Vec<TemporalBlock>,
63    pub rp_ref: [Option<Arc<Vec<TemporalBlock>>>; 7],
64    /// Projected temporal MVs for the current frame, whole frame.
65    pub rp_proj: Vec<TemporalBlock>,
66    pub rp_stride: usize,
67    /// 4x4 block info, whole frame (`r_stride` wide).
68    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    /// `dav1d_refmvs_init_frame`.
82    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        // Rows to the superblock-aligned height (blocks may overhang).
94        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    /// `splat_mv`.
171    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    /// `load_tmvs_c` (rows of 8x8 blocks `row_start8..row_end8`).
181    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    /// `save_tmvs_c` for 8x8 rows `row_start8..row_end8`, clipped to the frame.
261    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
529/// `add_compound_extended_candidate`: `same` is stack[base..base+2],
530/// `diff` stack[base+2..base+4].
531fn 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/// `dav1d_refmvs_find`: (candidate stack, count, context).
612#[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    // Temporal.
703    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    // Top/left.
748    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    // Secondary top and left edges (8x8 resolution).
755    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    // Sort (nearest, then secondary).
792    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}