refactor(hevc): split derive_merge into spatial, temporal, combined and zero stages (S3776)

crates/hevc/src/mvpred.rs

@@ -74,16 +74,39 @@ impl<'a> SliceDecoder<'a> {
 
     /// Merge mode motion (8.5.3.2.2).
     pub fn derive_merge(&self, g: PbGeom, part: PartMode, merge_idx: usize) -> MvField {
-        let PbGeom { xc, yc, ncb, xp: xp0, yp: yp0, w: w0, h: h0, part_idx: part_idx0 } = g;
+        let (w0, h0) = (g.w, g.h);
+        // With a parallel merge level above 4x4, an 8x8 coding block shares one candidate set.
+        let g = if self.pps.log2_parallel_merge_level > 2 && g.ncb == 8 {
+            PbGeom { xp: g.xc, yp: g.yc, w: g.ncb, h: g.ncb, part_idx: 0, ..g }
+        } else {
+            g
+        };
+        let max = self.sh.max_num_merge_cand as usize;
+        let (list, n) = self.spatial_merge_candidates(&g, part);
+        if merge_idx < n {
+            return self.finish_merge(list[merge_idx], w0, h0);
+        }
+        let mut cands: Vec<MvField> = list[..n].to_vec();
+        cands.extend(self.temporal_merge_candidate(g.xp, g.yp, g.w, g.h));
+        if merge_idx < cands.len() {
+            return self.finish_merge(cands[merge_idx], w0, h0);
+        }
+        self.combined_merge_candidates(&mut cands, max);
+        if merge_idx < cands.len() {
+            return self.finish_merge(cands[merge_idx], w0, h0);
+        }
+        self.zero_merge_candidates(&mut cands, merge_idx);
+        self.finish_merge(cands[merge_idx], w0, h0)
+    }
+
+    /// The spatial candidates A1, B1, B0, A0 and B2 (8.5.3.2.3): the candidates, and how many.
+    fn spatial_merge_candidates(&self, g: &PbGeom, part: PartMode) -> ([MvField; 5], usize) {
+        let PbGeom { xp, yp, w, h, part_idx, .. } = *g;
         let pml = self.pps.log2_parallel_merge_level;
-        let (xp, yp, w, h, part_idx) = if pml > 2 && ncb == 8 { (xc, yc, ncb, ncb, 0) } else { (xp0, yp0, w0, h0, part_idx0) };
-        let g = PbGeom { xc, yc, ncb, xp, yp, w, h, part_idx };
         let same_mer = |xn: i32, yn: i32| (xp >> pml) == (xn >> pml) && (yp >> pml) == (yn >> pml);
-        let avail = |xn: i32, yn: i32| self.pb_avail(&g, xn, yn) && !same_mer(xn, yn);
+        let avail = |xn: i32, yn: i32| self.pb_avail(g, xn, yn) && !same_mer(xn, yn);
         let mut list: [MvField; 5] = [MvField::default(); 5];
         let mut n = 0;
-        let max = self.sh.max_num_merge_cand as usize;
-        // spatial candidates (8.5.3.2.3)
         let pa1 = (xp - 1, yp + h - 1);
         let av_a1 = avail(pa1.0, pa1.1) && !(matches!(part, PartMode::PNx2N | PartMode::PnLx2N | PartMode::PnRx2N) && part_idx == 1);
         let m_a1 = if av_a1 { self.mv_at(pa1.0, pa1.1) } else { MvField::default() };
@@ -130,10 +153,11 @@ impl<'a> SliceDecoder<'a> {
             list[n] = self.mv_at(pb2.0, pb2.1);
             n += 1;
         }
-        if merge_idx < n {
-            return self.finish_merge(list[merge_idx], w0, h0);
-        }
-        // temporal candidate
+        (list, n)
+    }
+
+    /// The temporal candidate (8.5.3.2.8): list 0 from the collocated picture, and list 1 for B slices.
+    fn temporal_merge_candidate(&self, xp: i32, yp: i32, w: i32, h: i32) -> Option<MvField> {
         let mut col = MvField::default();
         let mut col_avail = false;
         if let Some(mv) = self.temporal(xp, yp, w, h, 0, 0) {
@@ -148,30 +172,28 @@ impl<'a> SliceDecoder<'a> {
             col.ref_idx[1] = 0;
             col_avail = true;
         }
-        let mut cands: Vec<MvField> = list[..n].to_vec();
-        if col_avail {
-            cands.push(col);
-        }
-        if merge_idx < cands.len() {
-            return self.finish_merge(cands[merge_idx], w0, h0);
-        }
-        // combined bi-predictive candidates (8.5.3.2.4)
+        col_avail.then_some(col)
+    }
+
+    /// Combined bi-predictive candidates (8.5.3.2.4) from pairs of the original candidates.
+    fn combined_merge_candidates(&self, cands: &mut Vec<MvField>, max: usize) {
         let num_orig = cands.len();
-        if self.sh.is_b() && num_orig > 1 && num_orig < max {
-            let mut comb = 0;
-            while comb < num_orig * (num_orig - 1) && cands.len() < max {
-                let (i0, i1) = COMB[comb];
-                let (c0, c1) = (cands[i0], cands[i1]);
-                if c0.pred(0) && c1.pred(1) && (self.ref_pic(0, c0.ref_idx[0]).poc != self.ref_pic(1, c1.ref_idx[1]).poc || c0.mv[0] != c1.mv[1]) {
-                    cands.push(MvField { mv: [c0.mv[0], c1.mv[1]], ref_idx: [c0.ref_idx[0], c1.ref_idx[1]] });
-                }
-                comb += 1;
+        if !(self.sh.is_b() && num_orig > 1 && num_orig < max) {
+            return;
+        }
+        let mut comb = 0;
+        while comb < num_orig * (num_orig - 1) && cands.len() < max {
+            let (i0, i1) = COMB[comb];
+            let (c0, c1) = (cands[i0], cands[i1]);
+            if c0.pred(0) && c1.pred(1) && (self.ref_pic(0, c0.ref_idx[0]).poc != self.ref_pic(1, c1.ref_idx[1]).poc || c0.mv[0] != c1.mv[1]) {
+                cands.push(MvField { mv: [c0.mv[0], c1.mv[1]], ref_idx: [c0.ref_idx[0], c1.ref_idx[1]] });
             }
+            comb += 1;
         }
-        if merge_idx < cands.len() {
-            return self.finish_merge(cands[merge_idx], w0, h0);
-        }
-        // zero candidates (8.5.3.2.5)
+    }
+
+    /// Zero candidates (8.5.3.2.5) up to and including `merge_idx`.
+    fn zero_merge_candidates(&self, cands: &mut Vec<MvField>, merge_idx: usize) {
         let num_ref = if self.sh.is_b() { self.sh.num_ref_idx[0].min(self.sh.num_ref_idx[1]) } else { self.sh.num_ref_idx[0] } as usize;
         let mut zero_idx = 0;
         while cands.len() <= merge_idx {
@@ -179,7 +201,6 @@ impl<'a> SliceDecoder<'a> {
             cands.push(MvField { mv: [[0; 2]; 2], ref_idx: [r, if self.sh.is_b() { r } else { -1 }] });
             zero_idx += 1;
         }
-        self.finish_merge(cands[merge_idx], w0, h0)
     }
 
     fn finish_merge(&self, mut f: MvField, w: i32, h: i32) -> MvField {

crates/ui-egui/src/show.rs

@@ -739,19 +739,84 @@ fn keyboard(ctx: &egui::Context, show: &mut Show, doc: &Presentation, now: f64,
     let mut keep = true;
     let mut actions = vec![];
     for (k, m) in keys {
-        let handled = if grid_open(show, presenter) && !matches!(k, egui::Key::Escape | egui::Key::Minus) {
+        use egui::Key::*;
+        let presenter_grid = presenter && show.presenter_grid;
+        let grid_open = if presenter { show.presenter_grid } else { show.grid };
+        if grid_open && !matches!(k, Escape | Minus) {
             // See All Slides takes no other keys until a slide is chosen.
-            if k == egui::Key::G && plain(m) {
-                close_grid(show, presenter);
-                true
+            if k == G && plain(m) {
+                if presenter_grid {
+                    show.presenter_grid = false;
+                } else {
+                    show.grid = false;
+                }
             } else {
-                false
+                continue;
             }
         } else {
-            navigation_key(show, doc, k, m, presenter, &mut keep, &mut actions) || tool_key(show, k, m, now, presenter)
-        };
-        if !handled {
-            continue;
+            match k {
+                Escape | Minus => {
+                    let cancelled = k == Escape && show.clear_goto();
+                    if !cancelled && !show.back_out(presenter) {
+                        keep = false;
+                    }
+                }
+                ArrowRight | ArrowDown | Space | PageDown | N => {
+                    if show.ended {
+                        keep = false;
+                    } else {
+                        actions.push(show.state.next(doc));
+                    }
+                }
+                Enter => {
+                    if !show.goto.is_empty() {
+                        if let Some(i) = show.take_goto()
+                            && i < doc.slides.len()
+                        {
+                            actions.push(show.state.goto(doc, i));
+                        }
+                    } else if show.ended {
+                        keep = false;
+                    } else {
+                        actions.push(show.state.next(doc));
+                    }
+                }
+                Backspace if !show.goto.is_empty() => {
+                    show.goto.pop();
+                }
+                ArrowLeft | ArrowUp | Backspace | PageUp | P if !(k == P && m.command) => {
+                    show.ended = false;
+                    actions.push(show.state.prev(doc));
+                }
+                P if m.command => show.set_pen(!show.pen),
+                L if m.command => show.set_laser(!show.laser),
+                A if m.command => show.arrow(),
+                Home => {
+                    if let Some(i) = show.state.first_index(doc) {
+                        actions.push(show.state.goto(doc, i));
+                    }
+                }
+                End => {
+                    if let Some(i) = show.state.last_index(doc) {
+                        actions.push(show.state.goto(doc, i));
+                    }
+                }
+                B | Period => toggle_blank(show, Color32::BLACK),
+                W | Comma => toggle_blank(show, Color32::WHITE),
+                E => show.strokes.clear(),
+                G if plain(m) => show.open_grid(presenter),
+                Z if plain(m) => show.zoom_key(),
+                T if plain(m) => show.timer.toggle(now),
+                R if plain(m) => show.timer.reset(now),
+                OpenBracket if plain(m) => show.nudge_notes(-NOTES_STEP),
+                CloseBracket if plain(m) => show.nudge_notes(NOTES_STEP),
+                Num0 | Num1 | Num2 | Num3 | Num4 | Num5 | Num6 | Num7 | Num8 | Num9 => {
+                    if let Some(d) = k.name().chars().next() {
+                        show.push_slide_number(d, now);
+                    }
+                }
+                _ => continue,
+            }
         }
         // The same key must not also activate a focused presenter button or be handled again
         // by an embedded presenter viewport.
@@ -766,111 +831,6 @@ fn keyboard(ctx: &egui::Context, show: &mut Show, doc: &Presentation, now: f64,
     keep
 }
 
-/// Whether the grid that the presenter key G opens is showing in this viewport.
-fn grid_open(show: &Show, presenter: bool) -> bool {
-    if presenter { show.presenter_grid } else { show.grid }
-}
-
-/// Closes the grid that G opens in this viewport.
-fn close_grid(show: &mut Show, presenter: bool) {
-    if presenter && show.presenter_grid {
-        show.presenter_grid = false;
-    } else {
-        show.grid = false;
-    }
-}
-
-/// Keys that move through the show or end it. False when `k` isn't one of them.
-fn navigation_key(
-    show: &mut Show,
-    doc: &Presentation,
-    k: egui::Key,
-    m: egui::Modifiers,
-    presenter: bool,
-    keep: &mut bool,
-    actions: &mut Vec<ShowAction>,
-) -> bool {
-    use egui::Key::*;
-    match k {
-        Escape | Minus => {
-            let cancelled = k == Escape && show.clear_goto();
-            if !cancelled && !show.back_out(presenter) {
-                *keep = false;
-            }
-        }
-        ArrowRight | ArrowDown | Space | PageDown | N => {
-            if show.ended {
-                *keep = false;
-            } else {
-                actions.push(show.state.next(doc));
-            }
-        }
-        Enter => {
-            if !show.goto.is_empty() {
-                if let Some(i) = show.take_goto()
-                    && i < doc.slides.len()
-                {
-                    actions.push(show.state.goto(doc, i));
-                }
-            } else if show.ended {
-                *keep = false;
-            } else {
-                actions.push(show.state.next(doc));
-            }
-        }
-        Backspace if !show.goto.is_empty() => {
-            show.goto.pop();
-        }
-        ArrowLeft | ArrowUp | Backspace | PageUp => {
-            show.ended = false;
-            actions.push(show.state.prev(doc));
-        }
-        P if m.command => show.set_pen(!show.pen),
-        P => {
-            show.ended = false;
-            actions.push(show.state.prev(doc));
-        }
-        Home => {
-            if let Some(i) = show.state.first_index(doc) {
-                actions.push(show.state.goto(doc, i));
-            }
-        }
-        End => {
-            if let Some(i) = show.state.last_index(doc) {
-                actions.push(show.state.goto(doc, i));
-            }
-        }
-        _ => return false,
-    }
-    true
-}
-
-/// Pen, laser, blanking, zoom, the timer, note size and typed slide numbers. False when `k`
-/// isn't one of them.
-fn tool_key(show: &mut Show, k: egui::Key, m: egui::Modifiers, now: f64, presenter: bool) -> bool {
-    use egui::Key::*;
-    match k {
-        L if m.command => show.set_laser(!show.laser),
-        A if m.command => show.arrow(),
-        B | Period => toggle_blank(show, Color32::BLACK),
-        W | Comma => toggle_blank(show, Color32::WHITE),
-        E => show.strokes.clear(),
-        G if plain(m) => show.open_grid(presenter),
-        Z if plain(m) => show.zoom_key(),
-        T if plain(m) => show.timer.toggle(now),
-        R if plain(m) => show.timer.reset(now),
-        OpenBracket if plain(m) => show.nudge_notes(-NOTES_STEP),
-        CloseBracket if plain(m) => show.nudge_notes(NOTES_STEP),
-        Num0 | Num1 | Num2 | Num3 | Num4 | Num5 | Num6 | Num7 | Num8 | Num9 => {
-            if let Some(d) = k.name().chars().next() {
-                show.push_slide_number(d, now);
-            }
-        }
-        _ => return false,
-    }
-    true
-}
-
 /// Draw and advance the active show, handling hidden frames, timing, input, transitions, and
 /// presenter/reading presentation.
 pub fn ui(app: &mut SlideApp, ui: &mut Ui) {