refactor(hevc): split prediction_unit into merge, AMVP and store helpers (S3776)

crates/av1/src/cdef.rs

@@ -45,7 +45,7 @@ fn cdef_block(fs: &FrameState, out: &mut FrameBuf, r: usize, c: usize, idx: usiz
     let var_str = if (var >> 6) != 0 { (31 - ((var >> 6) as u32).leading_zeros()).min(12) as i32 } else { 0 };
     pri = if var != 0 { (pri * (4 + var_str) + 8) >> 4 } else { 0 };
     let damping = cp.damping as i32 + coeff_shift as i32;
-    filter(fs, out, 0, (r, c), (pri, sec), damping, dir);
+    filter(fs, out, 0, r, c, pri, sec, damping, dir);
     if fs.num_planes == 1 {
         return true;
     }
@@ -53,8 +53,8 @@ fn cdef_block(fs: &FrameState, out: &mut FrameBuf, r: usize, c: usize, idx: usiz
     let sec = (cp.uv_sec[idx] << coeff_shift) as i32;
     let dir = if pri == 0 { 0 } else { CDEF_UV_DIR[fs.ssx][fs.ssy][y_dir] as usize };
     let damping = cp.damping as i32 + coeff_shift as i32 - 1;
-    filter(fs, out, 1, (r, c), (pri, sec), damping, dir);
-    filter(fs, out, 2, (r, c), (pri, sec), damping, dir);
+    filter(fs, out, 1, r, c, pri, sec, damping, dir);
+    filter(fs, out, 2, r, c, pri, sec, damping, dir);
     true
 }
 
@@ -124,74 +124,33 @@ fn constrain(diff: i32, threshold: i32, adj: u32) -> i32 {
     if diff < 0 { -mag } else { mag }
 }
 
-/// Tap offsets, weights and strengths of one block.
-struct Taps {
-    pri: i32,
-    sec: i32,
-    pri_adj: u32,
-    sec_adj: u32,
-    pri_off: [isize; 2],
-    sec_off: [[isize; 2]; 2],
-    pri_taps: [i32; 2],
-    sec_taps: [i32; 2],
-}
-
-impl Taps {
-    fn new(coeff_shift: u32, (pri, sec): (i32, i32), damping: i32, dir: usize) -> Taps {
-        let pri_tap = ((pri >> coeff_shift) & 1) as usize;
-        let off = |d: usize, k: usize| CDEF_DIRECTIONS[d][k][0] as isize * PAD_STRIDE as isize + CDEF_DIRECTIONS[d][k][1] as isize;
-        let pri_off = [off(dir, 0), off(dir, 1)];
-        let d_lo = (dir + 6) & 7;
-        let d_hi = (dir + 2) & 7;
-        let sec_off = [[off(d_lo, 0), off(d_hi, 0)], [off(d_lo, 1), off(d_hi, 1)]];
-        let pri_taps = [CDEF_PRI_TAPS[pri_tap][0] as i32, CDEF_PRI_TAPS[pri_tap][1] as i32];
-        let sec_taps = [CDEF_SEC_TAPS[pri_tap][0] as i32, CDEF_SEC_TAPS[pri_tap][1] as i32];
-        let adj = |t: i32| if t == 0 { 0 } else { (damping - (31 - (t as u32).leading_zeros()) as i32).max(0) as u32 };
-        Taps { pri, sec, pri_adj: adj(pri), sec_adj: adj(sec), pri_off, sec_off, pri_taps, sec_taps }
+#[allow(clippy::too_many_arguments)]
+fn filter(fs: &FrameState, out: &mut FrameBuf, plane: usize, r: usize, c: usize, pri: i32, sec: i32, damping: i32, dir: usize) {
+    if pri == 0 && sec == 0 {
+        // Every tap contributes 0 and the clamp to [min, max] keeps x: CdefFrame = CurrFrame.
+        return;
     }
-
-    /// The 12 (offset, weight, strength, adjustment) taps in filtering order.
-    fn tap_list(&self) -> [(isize, i32, i32, u32); 12] {
-        let mut taps = [(0isize, 0i32, 0i32, 0u32); 12];
-        let mut n = 0;
-        for k in 0..2 {
-            for sign in [-1isize, 1] {
-                taps[n] = (sign * self.pri_off[k], self.pri_taps[k], self.pri, self.pri_adj);
-                taps[n + 1] = (sign * self.sec_off[k][0], self.sec_taps[k], self.sec, self.sec_adj);
-                taps[n + 2] = (sign * self.sec_off[k][1], self.sec_taps[k], self.sec, self.sec_adj);
-                n += 3;
-            }
-        }
-        taps
-    }
-}
-
-/// Position and size of a block within its plane.
-#[derive(Clone, Copy)]
-struct BlockRect {
-    x0: usize,
-    y0: usize,
-    w: usize,
-    h: usize,
-}
-
-/// The block with two samples of padding on every side, plus whether every sample is available
-/// (CdefAvailable: its 4x4 block is inside the frame).
-fn padded_block(fs: &FrameState, plane: usize, src: &Plane, rect: BlockRect) -> ([i32; PAD_STRIDE * PAD_STRIDE], bool) {
+    let coeff_shift = fs.bit_depth - 8;
     let (sub_x, sub_y) = if plane > 0 { (fs.ssx, fs.ssy) } else { (0, 0) };
+    let x0 = (c * 4) >> sub_x;
+    let y0 = (r * 4) >> sub_y;
+    let w = 8 >> sub_x;
+    let h = 8 >> sub_y;
+    let src = &fs.cur.planes[plane];
     let (mi_rows, mi_cols) = (fs.fh.mi_rows as isize, fs.fh.mi_cols as isize);
+    // CdefAvailable per sample: its 4x4 block is inside the frame.
     let mut buf = [CDEF_NA; PAD_STRIDE * PAD_STRIDE];
     let mut all_avail = true;
-    for i in 0..rect.h + 4 {
-        let y = (rect.y0 + i) as isize - 2;
+    for i in 0..h + 4 {
+        let y = (y0 + i) as isize - 2;
         let cand_r = (y << sub_y) >> 2;
         if y < 0 || cand_r >= mi_rows {
             all_avail = false;
             continue;
         }
         let row = src.row(y as usize);
-        for j in 0..rect.w + 4 {
-            let x = (rect.x0 + j) as isize - 2;
+        for j in 0..w + 4 {
+            let x = (x0 + j) as isize - 2;
             let cand_c = (x << sub_x) >> 2;
             if x >= 0 && cand_c < mi_cols {
                 buf[i * PAD_STRIDE + j] = row[x as usize] as i32;
@@ -200,70 +159,70 @@ fn padded_block(fs: &FrameState, plane: usize, src: &Plane, rect: BlockRect) ->
             }
         }
     }
-    (buf, all_avail)
-}
-
-/// Filters one sample whose taps may be unavailable (CDEF_NA).
-fn filter_sample(buf: &[i32; PAD_STRIDE * PAD_STRIDE], taps: &Taps, ci: isize, x: i32) -> u16 {
-    let mut sum = 0i32;
-    let mut max = x;
-    let mut min = x;
-    for k in 0..2 {
-        for sign in [-1isize, 1] {
-            let p = buf[(ci + sign * taps.pri_off[k]) as usize];
-            if p != CDEF_NA {
-                if taps.pri != 0 {
-                    sum += taps.pri_taps[k] * constrain(p - x, taps.pri, taps.pri_adj);
-                }
-                max = max.max(p);
-                min = min.min(p);
-            }
-            for s in 0..2 {
-                let q = buf[(ci + sign * taps.sec_off[k][s]) as usize];
-                if q != CDEF_NA {
-                    if taps.sec != 0 {
-                        sum += taps.sec_taps[k] * constrain(q - x, taps.sec, taps.sec_adj);
-                    }
-                    max = max.max(q);
-                    min = min.min(q);
-                }
-            }
-        }
-    }
-    (x + ((8 + sum - (sum < 0) as i32) >> 4)).clamp(min, max) as u16
-}
-
-fn filter(fs: &FrameState, out: &mut FrameBuf, plane: usize, (r, c): (usize, usize), strengths: (i32, i32), damping: i32, dir: usize) {
-    let (pri, sec) = strengths;
-    if pri == 0 && sec == 0 {
-        // Every tap contributes 0 and the clamp to [min, max] keeps x: CdefFrame = CurrFrame.
-        return;
-    }
-    let coeff_shift = fs.bit_depth - 8;
-    let (sub_x, sub_y) = if plane > 0 { (fs.ssx, fs.ssy) } else { (0, 0) };
-    let rect = BlockRect { x0: (c * 4) >> sub_x, y0: (r * 4) >> sub_y, w: 8 >> sub_x, h: 8 >> sub_y };
-    let src = &fs.cur.planes[plane];
-    let (buf, all_avail) = padded_block(fs, plane, src, rect);
-    let taps = Taps::new(coeff_shift, strengths, damping, dir);
+    let pri_tap = ((pri >> coeff_shift) & 1) as usize;
+    let off = |d: usize, k: usize| CDEF_DIRECTIONS[d][k][0] as isize * PAD_STRIDE as isize + CDEF_DIRECTIONS[d][k][1] as isize;
+    let pri_off = [off(dir, 0), off(dir, 1)];
+    let d_lo = (dir + 6) & 7;
+    let d_hi = (dir + 2) & 7;
+    let sec_off = [[off(d_lo, 0), off(d_hi, 0)], [off(d_lo, 1), off(d_hi, 1)]];
+    let pri_taps = [CDEF_PRI_TAPS[pri_tap][0] as i32, CDEF_PRI_TAPS[pri_tap][1] as i32];
+    let sec_taps = [CDEF_SEC_TAPS[pri_tap][0] as i32, CDEF_SEC_TAPS[pri_tap][1] as i32];
+    let adj = |t: i32| if t == 0 { 0 } else { (damping - (31 - (t as u32).leading_zeros()) as i32).max(0) as u32 };
+    let (pri_adj, sec_adj) = (adj(pri), adj(sec));
     let dst = &mut out.planes[plane];
     if all_avail {
         // Every tap is available: whole rows at a time (constrain() with threshold 0 is 0).
-        let list = taps.tap_list();
-        let rows = (rect.y0, rect.x0, rect.h);
-        match rect.w {
-            8 => filter_rows::<8>(&buf, &list, dst, rows),
-            _ => filter_rows::<4>(&buf, &list, dst, rows),
+        let mut taps = [(0isize, 0i32, 0i32, 0u32); 12];
+        let mut n = 0;
+        for k in 0..2 {
+            for sign in [-1isize, 1] {
+                taps[n] = (sign * pri_off[k], pri_taps[k], pri, pri_adj);
+                taps[n + 1] = (sign * sec_off[k][0], sec_taps[k], sec, sec_adj);
+                taps[n + 2] = (sign * sec_off[k][1], sec_taps[k], sec, sec_adj);
+                n += 3;
+            }
+        }
+        let rows = (y0, x0, h);
+        match w {
+            8 => filter_rows::<8>(&buf, &taps, dst, rows),
+            _ => filter_rows::<4>(&buf, &taps, dst, rows),
         }
         return;
     }
-    for i in 0..rect.h {
+    for i in 0..h {
         // The centre sample is read even where CdefAvailable is 0 (8x8 blocks straddling an odd
         // MiRows / MiCols edge).
-        let srow = &src.row(rect.y0 + i)[rect.x0..rect.x0 + rect.w];
-        let drow = &mut dst.row_mut(rect.y0 + i)[rect.x0..rect.x0 + rect.w];
-        for j in 0..rect.w {
+        let srow = &src.row(y0 + i)[x0..x0 + w];
+        let drow = &mut dst.row_mut(y0 + i)[x0..x0 + w];
+        for j in 0..w {
             let ci = ((i + 2) * PAD_STRIDE + j + 2) as isize;
-            drow[j] = filter_sample(&buf, &taps, ci, srow[j] as i32);
+            let x = srow[j] as i32;
+            let mut sum = 0i32;
+            let mut max = x;
+            let mut min = x;
+            for k in 0..2 {
+                for sign in [-1isize, 1] {
+                    let p = buf[(ci + sign * pri_off[k]) as usize];
+                    if p != CDEF_NA {
+                        if pri != 0 {
+                            sum += pri_taps[k] * constrain(p - x, pri, pri_adj);
+                        }
+                        max = max.max(p);
+                        min = min.min(p);
+                    }
+                    for s in 0..2 {
+                        let q = buf[(ci + sign * sec_off[k][s]) as usize];
+                        if q != CDEF_NA {
+                            if sec != 0 {
+                                sum += sec_taps[k] * constrain(q - x, sec, sec_adj);
+                            }
+                            max = max.max(q);
+                            min = min.min(q);
+                        }
+                    }
+                }
+            }
+            drow[j] = (x + ((8 + sum - (sum < 0) as i32) >> 4)).clamp(min, max) as u16;
         }
     }
 }

crates/av1/src/restoration.rs

@@ -73,70 +73,57 @@ impl LrCtx<'_> {
     }
 }
 
-/// Position and size of a (at most 4x4) restoration block within its plane.
-#[derive(Clone, Copy)]
-struct LrBlock {
-    x: i32,
-    y: i32,
-    w: i32,
-    h: i32,
-}
-
 /// Loop restoration (7.17): returns LrFrame given UpscaledCurrFrame and UpscaledCdefFrame.
 pub(crate) fn loop_restoration(fs: &FrameState, cur: &FrameBuf, cdef: &FrameBuf) -> FrameBuf {
+    let fh = &fs.fh;
     let mut lr = cdef.clone();
+    let up_w = fh.upscaled_width as i32;
+    let fr_h = fh.frame_height as i32;
+    let bd = fs.bit_depth;
     for plane in 0..fs.num_planes {
-        if fs.fh.lr.frame_restoration_type[plane] == RESTORE_NONE as u8 {
+        let rtype_frame = fh.lr.frame_restoration_type[plane];
+        if rtype_frame == RESTORE_NONE as u8 {
             continue;
         }
-        restore_plane(fs, cur, cdef, &mut lr.planes[plane], plane);
+        let (sub_x, sub_y) = if plane > 0 { (fs.ssx as i32, fs.ssy as i32) } else { (0, 0) };
+        let unit_size = fh.lr.loop_restoration_size[plane] as i32;
+        let unit_rows = fs.lr_unit_rows[plane] as i32;
+        let unit_cols = fs.lr_unit_cols[plane] as i32;
+        let plane_end_x = ((up_w + sub_x) >> sub_x) - 1;
+        let plane_end_y = ((fr_h + sub_y) >> sub_y) - 1;
+        let mut row = 0;
+        while row * 4 < fr_h {
+            let luma_y = row * 4;
+            let stripe_num = (luma_y + 8) / 64;
+            let stripe_start_y = (-8 + stripe_num * 64) >> sub_y;
+            let stripe_end_y = stripe_start_y + (64 >> sub_y) - 1;
+            let ctx = LrCtx { cur: &cur.planes[plane], cdef: &cdef.planes[plane], plane_end_x, plane_end_y, stripe_start_y, stripe_end_y };
+            let unit_row = (unit_rows - 1).min(((row * 4 + 8) >> sub_y) / unit_size);
+            let mut col = 0;
+            while col * 4 < up_w {
+                let unit_col = (unit_cols - 1).min(((col * 4) >> sub_x) / unit_size);
+                let x = (col * 4) >> sub_x;
+                let y = (row * 4) >> sub_y;
+                let w = (4 >> sub_x).min(plane_end_x - x + 1);
+                let h = (4 >> sub_y).min(plane_end_y - y + 1);
+                if w > 0 && h > 0 {
+                    let ui = (unit_row * unit_cols + unit_col) as usize;
+                    match fs.lr.lr_type[plane][ui] {
+                        t if t == RESTORE_WIENER as u8 => wiener(fs, &ctx, &mut lr.planes[plane], plane, ui, x, y, w, h, bd),
+                        t if t == RESTORE_SGRPROJ as u8 => self_guided(fs, &ctx, &mut lr.planes[plane], plane, ui, x, y, w, h, bd),
+                        _ => {}
+                    }
+                }
+                col += 1;
+            }
+            row += 1;
+        }
     }
     lr
 }
 
-fn restore_plane(fs: &FrameState, cur: &FrameBuf, cdef: &FrameBuf, out: &mut Plane, plane: usize) {
-    let fh = &fs.fh;
-    let up_w = fh.upscaled_width as i32;
-    let fr_h = fh.frame_height as i32;
-    let bd = fs.bit_depth;
-    let (sub_x, sub_y) = if plane > 0 { (fs.ssx as i32, fs.ssy as i32) } else { (0, 0) };
-    let unit_size = fh.lr.loop_restoration_size[plane] as i32;
-    let unit_rows = fs.lr_unit_rows[plane] as i32;
-    let unit_cols = fs.lr_unit_cols[plane] as i32;
-    let plane_end_x = ((up_w + sub_x) >> sub_x) - 1;
-    let plane_end_y = ((fr_h + sub_y) >> sub_y) - 1;
-    let mut row = 0;
-    while row * 4 < fr_h {
-        let luma_y = row * 4;
-        let stripe_num = (luma_y + 8) / 64;
-        let stripe_start_y = (-8 + stripe_num * 64) >> sub_y;
-        let stripe_end_y = stripe_start_y + (64 >> sub_y) - 1;
-        let ctx = LrCtx { cur: &cur.planes[plane], cdef: &cdef.planes[plane], plane_end_x, plane_end_y, stripe_start_y, stripe_end_y };
-        let unit_row = (unit_rows - 1).min(((row * 4 + 8) >> sub_y) / unit_size);
-        let mut col = 0;
-        while col * 4 < up_w {
-            let unit_col = (unit_cols - 1).min(((col * 4) >> sub_x) / unit_size);
-            let x = (col * 4) >> sub_x;
-            let y = (row * 4) >> sub_y;
-            let w = (4 >> sub_x).min(plane_end_x - x + 1);
-            let h = (4 >> sub_y).min(plane_end_y - y + 1);
-            if w > 0 && h > 0 {
-                let ui = (unit_row * unit_cols + unit_col) as usize;
-                let blk = LrBlock { x, y, w, h };
-                match fs.lr.lr_type[plane][ui] {
-                    t if t == RESTORE_WIENER as u8 => wiener(fs, &ctx, out, (plane, ui), blk, bd),
-                    t if t == RESTORE_SGRPROJ as u8 => self_guided(fs, &ctx, out, (plane, ui), blk, bd),
-                    _ => {}
-                }
-            }
-            col += 1;
-        }
-        row += 1;
-    }
-}
-
-fn wiener(fs: &FrameState, ctx: &LrCtx, out: &mut Plane, (plane, ui): (usize, usize), blk: LrBlock, bd: u32) {
-    let LrBlock { x, y, w, h } = blk;
+#[allow(clippy::too_many_arguments)]
+fn wiener(fs: &FrameState, ctx: &LrCtx, out: &mut Plane, plane: usize, ui: usize, x: i32, y: i32, w: i32, h: i32, bd: u32) {
     let round0: u32 = if bd == 12 { 5 } else { 3 };
     let round1: u32 = if bd == 12 { 9 } else { 11 };
     let coef = &fs.lr.lr_wiener[plane][ui];
@@ -179,13 +166,13 @@ fn wiener(fs: &FrameState, ctx: &LrCtx, out: &mut Plane, (plane, ui): (usize, us
     }
 }
 
-fn self_guided(fs: &FrameState, ctx: &LrCtx, out: &mut Plane, (plane, ui): (usize, usize), blk: LrBlock, bd: u32) {
-    let LrBlock { x, y, w, h } = blk;
+#[allow(clippy::too_many_arguments)]
+fn self_guided(fs: &FrameState, ctx: &LrCtx, out: &mut Plane, plane: usize, ui: usize, x: i32, y: i32, w: i32, h: i32, bd: u32) {
     let set = fs.lr.lr_sgr_set[plane][ui] as usize;
     let mut flt0 = [[0i32; 4]; 4];
     let mut flt1 = [[0i32; 4]; 4];
-    box_filter(ctx, blk, (set, 0), bd, &mut flt0);
-    box_filter(ctx, blk, (set, 1), bd, &mut flt1);
+    box_filter(ctx, x, y, w, h, set, 0, bd, &mut flt0);
+    box_filter(ctx, x, y, w, h, set, 1, bd, &mut flt1);
     let xqd = fs.lr.lr_sgr_xqd[plane][ui];
     let w0 = xqd[0] as i32;
     let w1 = xqd[1] as i32;
@@ -211,56 +198,8 @@ fn round2_64(x: i64, n: u32) -> i64 {
     if n == 0 { x } else { (x + (1i64 << (n - 1))) >> n }
 }
 
-/// Box sums of the samples within `r` of (x, y): (sum of squares, sum).
-fn box_sums(ctx: &LrCtx, x: i32, y: i32, r: i32) -> (i64, i64) {
-    let mut a = 0i64;
-    let mut b = 0i64;
-    for dy in -r..=r {
-        for dx in -r..=r {
-            let c = ctx.sample(x + dx, y + dy) as i64;
-            a += c * c;
-            b += c;
-        }
-    }
-    (a, b)
-}
-
-/// Self-guided filter constants of one pass.
-struct SgrConsts {
-    n: i64,
-    s: i64,
-    one_over_n: i64,
-}
-
-/// (A, B) coefficients of one sample from its box sums.
-fn sgr_coefficients(a: i64, b: i64, k: &SgrConsts, bd: u32) -> (i64, i64) {
-    let a = round2_64(a, 2 * (bd - 8));
-    let d = round2_64(b, bd - 8);
-    let p = (a * k.n - d * d).max(0);
-    let z = round2_64(p * k.s, SGRPROJ_MTABLE_BITS as u32);
-    let a2 = if z >= 255 {
-        256
-    } else if z == 0 {
-        1
-    } else {
-        ((z << SGRPROJ_SGR_BITS) + z / 2) / (z + 1)
-    };
-    let b2 = ((1i64 << SGRPROJ_SGR_BITS) - a2) * b * k.one_over_n;
-    (a2, round2_64(b2, SGRPROJ_RECIP_BITS as u32))
-}
-
-fn box_weight(pass: usize, i: i32, dx: i32, dy: i32) -> i64 {
-    if pass == 0 {
-        if ((i + dy) & 1) != 0 { if dx == 0 { 6 } else { 5 } } else { 0 }
-    } else if dx == 0 || dy == 0 {
-        4
-    } else {
-        3
-    }
-}
-
-fn box_filter(ctx: &LrCtx, blk: LrBlock, (set, pass): (usize, usize), bd: u32, f: &mut [[i32; 4]; 4]) {
-    let LrBlock { x, y, w, h } = blk;
+#[allow(clippy::too_many_arguments)]
+fn box_filter(ctx: &LrCtx, x: i32, y: i32, w: i32, h: i32, set: usize, pass: usize, bd: u32, f: &mut [[i32; 4]; 4]) {
     let r = SGR_PARAMS[set][pass * 2] as i32;
     if r == 0 {
         return;
@@ -268,15 +207,35 @@ fn box_filter(ctx: &LrCtx, blk: LrBlock, (set, pass): (usize, usize), bd: u32, f
     let eps = SGR_PARAMS[set][pass * 2 + 1] as i64;
     let n = ((2 * r + 1) * (2 * r + 1)) as i64;
     let n2e = n * n * eps;
-    let k = SgrConsts { n, s: ((1i64 << SGRPROJ_MTABLE_BITS) + n2e / 2) / n2e, one_over_n: ((1i64 << SGRPROJ_RECIP_BITS) + n / 2) / n };
+    let s = ((1i64 << SGRPROJ_MTABLE_BITS) + n2e / 2) / n2e;
+    let one_over_n = ((1i64 << SGRPROJ_RECIP_BITS) + n / 2) / n;
     let mut a_arr = [[0i64; 6]; 6];
     let mut b_arr = [[0i64; 6]; 6];
     for i in -1..h + 1 {
         for j in -1..w + 1 {
-            let (a, b) = box_sums(ctx, x + j, y + i, r);
-            let (a2, b2) = sgr_coefficients(a, b, &k, bd);
+            let mut a = 0i64;
+            let mut b = 0i64;
+            for dy in -r..=r {
+                for dx in -r..=r {
+                    let c = ctx.sample(x + j + dx, y + i + dy) as i64;
+                    a += c * c;
+                    b += c;
+                }
+            }
+            let a = round2_64(a, 2 * (bd - 8));
+            let d = round2_64(b, bd - 8);
+            let p = (a * n - d * d).max(0);
+            let z = round2_64(p * s, SGRPROJ_MTABLE_BITS as u32);
+            let a2 = if z >= 255 {
+                256
+            } else if z == 0 {
+                1
+            } else {
+                ((z << SGRPROJ_SGR_BITS) + z / 2) / (z + 1)
+            };
+            let b2 = ((1i64 << SGRPROJ_SGR_BITS) - a2) * b * one_over_n;
             a_arr[(i + 1) as usize][(j + 1) as usize] = a2;
-            b_arr[(i + 1) as usize][(j + 1) as usize] = b2;
+            b_arr[(i + 1) as usize][(j + 1) as usize] = round2_64(b2, SGRPROJ_RECIP_BITS as u32);
         }
     }
     for i in 0..h {
@@ -286,7 +245,13 @@ fn box_filter(ctx: &LrCtx, blk: LrBlock, (set, pass): (usize, usize), bd: u32, f
             let mut b = 0i64;
             for dy in -1..=1i32 {
                 for dx in -1..=1i32 {
-                    let weight = box_weight(pass, i, dx, dy);
+                    let weight = if pass == 0 {
+                        if ((i + dy) & 1) != 0 { if dx == 0 { 6 } else { 5 } } else { 0 }
+                    } else if dx == 0 || dy == 0 {
+                        4
+                    } else {
+                        3
+                    };
                     a += weight * a_arr[(i + dy + 1) as usize][(j + dx + 1) as usize];
                     b += weight * b_arr[(i + dy + 1) as usize][(j + dx + 1) as usize];
                 }

crates/av1/src/transform.rs

@@ -165,15 +165,6 @@ pub(crate) fn inverse_dct<T: Lane>(t: &mut [T], n: u32, r: u32) {
     for i in 0..len {
         t[i] = copy[brev(n, i)];
     }
-    inverse_dct_stage1(t, n, r);
-    inverse_dct_stage2(t, n, r);
-    inverse_dct_stage3(t, n, r);
-    inverse_dct_stage4(t, n, r);
-    inverse_dct_stage5(t, n, r);
-    inverse_dct_stage6(t, n, r);
-}
-
-fn inverse_dct_stage1<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n == 6 {
         for i in 0..16 {
             bf(t, 32 + i, 63 - i, 63 - 4 * brev(4, i) as i32, false);
@@ -199,9 +190,6 @@ fn inverse_dct_stage1<T: Lane>(t: &mut [T], n: u32, r: u32) {
             hd(t, 16 + 2 * i, 17 + 2 * i, i & 1 == 1, r);
         }
     }
-}
-
-fn inverse_dct_stage2<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n == 6 {
         for i in 0..4 {
             for j in 0..2 {
@@ -233,9 +221,6 @@ fn inverse_dct_stage2<T: Lane>(t: &mut [T], n: u32, r: u32) {
             }
         }
     }
-}
-
-fn inverse_dct_stage3<T: Lane>(t: &mut [T], n: u32, r: u32) {
     for i in 0..2 {
         bf(t, 2 * i, 2 * i + 1, 32 + 16 * i as i32, i == 0);
     }
@@ -263,9 +248,6 @@ fn inverse_dct_stage3<T: Lane>(t: &mut [T], n: u32, r: u32) {
             }
         }
     }
-}
-
-fn inverse_dct_stage4<T: Lane>(t: &mut [T], n: u32, r: u32) {
     for i in 0..2 {
         hd(t, i, 3 - i, false, r);
     }
@@ -291,9 +273,6 @@ fn inverse_dct_stage4<T: Lane>(t: &mut [T], n: u32, r: u32) {
             }
         }
     }
-}
-
-fn inverse_dct_stage5<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n >= 3 {
         for i in 0..4 {
             hd(t, i, 7 - i, false, r);
@@ -321,9 +300,6 @@ fn inverse_dct_stage5<T: Lane>(t: &mut [T], n: u32, r: u32) {
             hd(t, i, 15 - i, false, r);
         }
     }
-}
-
-fn inverse_dct_stage6<T: Lane>(t: &mut [T], n: u32, r: u32) {
     if n >= 5 {
         for i in 0..4 {
             bf(t, 27 - i, 20 + i, 32, true);
@@ -555,9 +531,10 @@ pub(crate) fn inverse_transform_2d(dequant: &[i32], residual: &mut [i32], tx_sz:
     let col_clamp = (bit_depth + 6).max(16);
     let rk = row_kind(tx_type);
     let ck = col_kind(tx_type);
+    let mut t = [0i32; 64];
     let rect2 = log2w.abs_diff(log2h) == 1;
-    let p = Tx2d { w, h, log2w, log2h, row_shift, col_shift, row_clamp, col_clamp, rk, ck, rect2 };
     if !lossless && bit_depth <= 10 {
+        let p = Tx2d { w, h, log2w, log2h, row_shift, col_shift, row_clamp, col_clamp, rk, ck, rect2 };
         if w >= 8 && h >= 8 {
             transform_lanes::<8>(dequant, residual, &p);
         } else {
@@ -565,13 +542,6 @@ pub(crate) fn inverse_transform_2d(dequant: &[i32], residual: &mut [i32], tx_sz:
         }
         return;
     }
-    scalar_row_pass(dequant, residual, &p, lossless);
-    scalar_col_pass(residual, &p, lossless);
-}
-
-fn scalar_row_pass(dequant: &[i32], residual: &mut [i32], p: &Tx2d, lossless: bool) {
-    let (w, h, log2w, row_shift, row_clamp, col_clamp, rk, rect2) = (p.w, p.h, p.log2w, p.row_shift, p.row_clamp, p.col_clamp, p.rk, p.rect2);
-    let mut t = [0i32; 64];
     let in_w = w.min(32);
     for i in 0..h {
         // Every 1D transform maps an all-zero row to zeros (each step is linear with
@@ -602,11 +572,6 @@ fn scalar_row_pass(dequant: &[i32], residual: &mut [i32], p: &Tx2d, lossless: bo
             residual[i * w + j] = round2(t[j], row_shift).clamp(lo, hi);
         }
     }
-}
-
-fn scalar_col_pass(residual: &mut [i32], p: &Tx2d, lossless: bool) {
-    let (w, h, log2h, col_shift, col_clamp, ck) = (p.w, p.h, p.log2h, p.col_shift, p.col_clamp, p.ck);
-    let mut t = [0i32; 64];
     for j in 0..w {
         for i in 0..h {
             t[i] = residual[i * w + j];
@@ -652,16 +617,11 @@ fn transform_1d<T: Lane>(t: &mut [T], kind: Kind1d, n: u32, r: u32) {
 /// The 2D inverse transform with `L` rows (row pass) or columns (column pass) at a time;
 /// bit-identical to the one-at-a-time process for bit depths up to 10.
 fn transform_lanes<const L: usize>(dequant: &[i32], residual: &mut [i32], p: &Tx2d) {
-    let mut t = [[0i32; L]; 64];
-    lanes_row_pass(dequant, residual, p, &mut t);
-    lanes_col_pass(residual, p, &mut t);
-}
-
-fn lanes_row_pass<const L: usize>(dequant: &[i32], residual: &mut [i32], p: &Tx2d, t: &mut [[i32; L]; 64]) {
     let (w, h) = (p.w, p.h);
     let in_w = w.min(32);
     let lo = -(1i32 << (p.col_clamp - 1));
     let hi = (1i32 << (p.col_clamp - 1)) - 1;
+    let mut t = [[0i32; L]; 64];
     let mut i0 = 0;
     while i0 < h {
         // Rows without coefficients (and rows 32..63) transform to zeros.
@@ -689,10 +649,6 @@ fn lanes_row_pass<const L: usize>(dequant: &[i32], residual: &mut [i32], p: &Tx2
         }
         i0 += L;
     }
-}
-
-fn lanes_col_pass<const L: usize>(residual: &mut [i32], p: &Tx2d, t: &mut [[i32; L]; 64]) {
-    let (w, h) = (p.w, p.h);
     let mut j0 = 0;
     while j0 < w {
         for i in 0..h {

crates/engine/src/cmd/shape.rs

@@ -5,7 +5,7 @@ use std::collections::HashMap;
 
 use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
 use deckcraft_model::style::{Dash, Glow, Gradient, GradientShape, GradientStop, LineEnd, PatternFill, PictureFill, PictureMode, Reflection, Shadow};
-use deckcraft_model::{ColorRef, Effects, Fill, Geom, Line, ShapeId, ShapeStyle};
+use deckcraft_model::{ColorRef, Effects, Fill, Geom, Line, ShapeStyle};
 use serde_json::{Value, json};
 
 use super::{
@@ -556,102 +556,81 @@ fn edit_group_appearance(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut
     edit_shapes(s, p, cmd, |sh| apply(sh, 0, &f))
 }
 
-/// The fill a `shape.fill` request sets: `Some(None)` clears it, `Some(Some(_))` sets it, and `None`
-/// leaves it as it is.
-fn requested_fill(s: &mut Session, p: &Value) -> Result<Option<Option<Fill>>> {
-    if bool_or(p, "reset", false) {
-        return Ok(Some(None));
-    }
-    if bool_or(p, "none", false) {
-        return Ok(Some(Some(Fill::None)));
-    }
-    if let Some(c) = color_param(p, "color") {
-        return Ok(Some(Some(Fill::solid(c))));
-    }
-    if let Some(g) = p.get("gradient") {
-        let gradient = gradient_param(g).ok_or_else(|| bad("shape.fill", "gradient needs at least two `stops`: [[0, \"#fff\"], [1, \"#000\"]]"))?;
-        return Ok(Some(Some(Fill::Gradient(gradient))));
-    }
-    if let Some(pt) = p.get("pattern") {
-        return Ok(Some(Some(Fill::Pattern(PatternFill {
+fn fill(s: &mut Session, p: &Value) -> Result<Value> {
+    let new_fill: Option<Option<Fill>> = if bool_or(p, "reset", false) {
+        Some(None)
+    } else if bool_or(p, "none", false) {
+        Some(Some(Fill::None))
+    } else if let Some(c) = color_param(p, "color") {
+        Some(Some(Fill::solid(c)))
+    } else if let Some(g) = p.get("gradient") {
+        Some(Some(Fill::Gradient(
+            gradient_param(g).ok_or_else(|| bad("shape.fill", "gradient needs at least two `stops`: [[0, \"#fff\"], [1, \"#000\"]]"))?,
+        )))
+    } else if let Some(pt) = p.get("pattern") {
+        Some(Some(Fill::Pattern(PatternFill {
             preset: pt.get("preset").and_then(Value::as_str).unwrap_or("pct50").to_string(),
             fg: pt.get("fg").and_then(color_value).unwrap_or(ColorRef::scheme(SchemeSlot::Accent1)),
             bg: pt.get("bg").and_then(color_value).unwrap_or(ColorRef::scheme(SchemeSlot::Bg1)),
-        }))));
-    }
-    if p.get("picture").is_some() {
+        })))
+    } else if p.get("picture").is_some() {
         let (name, bytes) = super::insert::media_bytes(&with_param(p, "data", p.get("picture").cloned().unwrap_or_default()), "shape.fill")?;
         let ct = super::insert::content_type(&name, &bytes);
         let media = s.edit(|doc, _| doc.add_media(&name, ct, bytes).ok_or_else(|| bad("shape.fill", NO_ID_SPACE)))?;
-        return Ok(Some(Some(Fill::Picture(PictureFill { media, ..Default::default() }))));
-    }
-    Ok(None)
-}
-
-/// The effective fill of each targeted shape, for a transparency change on an inherited (style) fill.
-fn inherited_fills(s: &Session, p: &Value) -> Result<HashMap<ShapeId, Option<Fill>>> {
-    let st = s.doc()?;
-    let ctx = super::text::ctx_for(&st.doc, &st.selection);
-    let mut fills = HashMap::new();
-    for id in targets(s, p)? {
-        if let Some(sh) = st.shape(id) {
-            deckcraft_model::walk(std::slice::from_ref(sh), &mut |sh, _| {
-                let fill = ctx.as_ref().and_then(|c| {
-                    let (f, ph) = deckcraft_model::resolve::fill(c, sh);
-                    f.map(|f| match f {
-                        Fill::Solid { color } => Fill::solid(ColorRef::rgb(c.color(&color, ph))),
-                        other => other,
-                    })
-                });
-                fills.insert(sh.id, fill);
-            });
-        }
-    }
-    Ok(fills)
-}
-
-/// Applies a `shape.fill` request to one shape: the fill, then its picture options, then transparency.
-fn apply_fill(
-    sh: &mut deckcraft_model::Shape,
-    new_fill: Option<&Option<Fill>>,
-    pic_props: Option<&Value>,
-    transparency: Option<f64>,
-    inherited: &HashMap<ShapeId, Option<Fill>>,
-) -> Result<()> {
-    if let Some(f) = new_fill {
-        sh.fill.clone_from(f);
-    }
-    if let (Some(pp), Some(Fill::Picture(pf))) = (pic_props, sh.fill.as_mut()) {
-        picture_props(pf, pp);
-    }
-    if let (Some(t), Some(Fill::Picture(pf))) = (transparency, sh.fill.as_mut()) {
-        let a = 1.0 - t.clamp(0.0, 1.0);
-        pf.alpha = (a < 1.0).then_some(a);
-        return Ok(());
-    }
-    if let Some(t) = transparency {
-        let base = sh.fill.clone().or_else(|| inherited.get(&sh.id).cloned().flatten());
-        if let Some(Fill::Solid { mut color }) = base {
-            color.mods.retain(|m| !matches!(m, ColorTransform::Alpha(_)));
-            if t > 0.0 {
-                color.mods.push(ColorTransform::Alpha(((1.0 - t.clamp(0.0, 1.0)) * 100_000.0).round() as i32));
-            }
-            sh.fill = Some(Fill::Solid { color });
-        }
-    }
-    Ok(())
-}
-
-fn fill(s: &mut Session, p: &Value) -> Result<Value> {
-    let new_fill = requested_fill(s, p)?;
+        Some(Some(Fill::Picture(PictureFill { media, ..Default::default() })))
+    } else {
+        None
+    };
     let transparency = f64_param(p, "transparency");
     let pic_props = p.get("pictureProps").filter(|v| v.is_object());
     if new_fill.is_none() && transparency.is_none() && pic_props.is_none() {
         return Err(bad("shape.fill", "give `color`, `none`, `gradient`, `pattern`, `picture`, `pictureProps`, `transparency` or `reset`"));
     }
     // Transparency on an inherited (style) fill needs the effective colour.
-    let inherited = inherited_fills(s, p)?;
-    edit_group_appearance(s, p, "shape.fill", |sh| apply_fill(sh, new_fill.as_ref(), pic_props, transparency, &inherited))
+    let st = s.doc()?;
+    let ctx_fill = {
+        let ctx = super::text::ctx_for(&st.doc, &st.selection);
+        let mut fills = HashMap::new();
+        for id in targets(s, p)? {
+            if let Some(sh) = st.shape(id) {
+                deckcraft_model::walk(std::slice::from_ref(sh), &mut |sh, _| {
+                    let fill = ctx.as_ref().and_then(|c| {
+                        let (f, ph) = deckcraft_model::resolve::fill(c, sh);
+                        f.map(|f| match f {
+                            Fill::Solid { color } => Fill::solid(ColorRef::rgb(c.color(&color, ph))),
+                            other => other,
+                        })
+                    });
+                    fills.insert(sh.id, fill);
+                });
+            }
+        }
+        fills
+    };
+    edit_group_appearance(s, p, "shape.fill", |sh| {
+        if let Some(f) = &new_fill {
+            sh.fill.clone_from(f);
+        }
+        if let (Some(pp), Some(Fill::Picture(pf))) = (pic_props, sh.fill.as_mut()) {
+            picture_props(pf, pp);
+        }
+        if let (Some(t), Some(Fill::Picture(pf))) = (transparency, sh.fill.as_mut()) {
+            let a = 1.0 - t.clamp(0.0, 1.0);
+            pf.alpha = (a < 1.0).then_some(a);
+            return Ok(());
+        }
+        if let Some(t) = transparency {
+            let base = sh.fill.clone().or_else(|| ctx_fill.get(&sh.id).cloned().flatten());
+            if let Some(Fill::Solid { mut color }) = base {
+                color.mods.retain(|m| !matches!(m, ColorTransform::Alpha(_)));
+                if t > 0.0 {
+                    color.mods.push(ColorTransform::Alpha(((1.0 - t.clamp(0.0, 1.0)) * 100_000.0).round() as i32));
+                }
+                sh.fill = Some(Fill::Solid { color });
+            }
+        }
+        Ok(())
+    })
 }
 
 /// Applies Format Shape ▸ Picture or texture fill options to a picture fill.

crates/format/src/rtf.rs

@@ -126,216 +126,155 @@ fn advance(rtf: &str, i: usize, n: usize) -> usize {
     if rtf.is_char_boundary(i + n) { i + n } else { i + rtf.get(i..).and_then(|r| r.chars().next()).map_or(1, char::len_utf8) }
 }
 
-/// Group state: whether the text is being skipped, and the `\uc` fallback count.
-#[derive(Clone, Copy)]
-struct St {
-    skip: bool,
-    uc: usize,
-}
-
-/// Parser state for [`rtf_to_outline`]: the cursor, the group stack and the outline so far.
-struct Outline<'a> {
-    rtf: &'a str,
-    b: &'a [u8],
-    i: usize,
-    stack: Vec<St>,
-    st: St,
-    level: Option<u32>,
-    indent: i64,
-    pending_skip: usize,
-    line: String,
-    out: String,
-}
-
 /// Read an RTF outline into tab-indented outline text: a paragraph's outline level (or its left
 /// indent in 0.25" steps) becomes its number of tabs.
 pub fn rtf_to_outline(rtf: &str) -> String {
-    let mut p = Outline {
-        rtf,
-        b: rtf.as_bytes(),
-        i: 0,
-        stack: vec![],
-        st: St { skip: false, uc: 1 },
-        level: None,
-        indent: 0,
-        pending_skip: 0,
-        line: String::new(),
-        out: String::new(),
+    #[derive(Clone, Copy)]
+    struct St {
+        skip: bool,
+        uc: usize,
+    }
+    let b = rtf.as_bytes();
+    let mut stack: Vec<St> = vec![];
+    let mut st = St { skip: false, uc: 1 };
+    let (mut level, mut indent): (Option<u32>, i64) = (None, 0);
+    let mut line = String::new();
+    let mut out = String::new();
+    let mut pending_skip = 0usize;
+    let mut i = 0;
+    let flush = |line: &mut String, level: Option<u32>, indent: i64, out: &mut String| {
+        let text = line.trim();
+        if !text.is_empty() {
+            let n = level.map(|l| l as i64).unwrap_or(indent.saturating_add(180) / 360).clamp(0, 9) as usize;
+            out.push_str(&"\t".repeat(n));
+            out.push_str(text);
+            out.push('\n');
+        }
+        line.clear();
     };
-    p.run();
-    p.flush();
-    finish_surrogates(p.out)
-}
-
-impl Outline<'_> {
-    fn run(&mut self) {
-        while self.i < self.b.len() {
-            match self.b[self.i] {
-                b'{' => self.open_group(),
-                b'}' => self.close_group(),
-                b'\\' => {
-                    self.i += 1;
-                    if !self.escape() {
-                        break;
+    while i < b.len() {
+        let c = b[i];
+        match c {
+            b'{' => {
+                stack.push(st);
+                i += 1;
+                // `{\*\dest …}`: an ignorable destination.
+                if b[i..].starts_with(b"\\*") {
+                    st.skip = true;
+                }
+            }
+            b'}' => {
+                st = stack.pop().unwrap_or(St { skip: false, uc: 1 });
+                i += 1;
+            }
+            b'\\' => {
+                i += 1;
+                let Some(&n) = b.get(i) else { break };
+                if n.is_ascii_alphabetic() {
+                    let s = i;
+                    while i < b.len() && b[i].is_ascii_alphabetic() {
+                        i += 1;
+                    }
+                    let word = &rtf[s..i];
+                    let ns = i;
+                    if i < b.len() && (b[i] == b'-' || b[i].is_ascii_digit()) {
+                        i += 1;
+                        while i < b.len() && b[i].is_ascii_digit() {
+                            i += 1;
+                        }
+                    }
+                    let arg: Option<i64> = rtf[ns..i].parse().ok();
+                    if i < b.len() && b[i] == b' ' {
+                        i += 1;
+                    }
+                    if pending_skip > 0 {
+                        pending_skip -= 1;
+                        continue;
+                    }
+                    if SKIP.contains(&word) {
+                        st.skip = true;
+                    }
+                    if st.skip {
+                        continue;
+                    }
+                    match word {
+                        "par" => {
+                            flush(&mut line, level, indent, &mut out);
+                        }
+                        "pard" => {
+                            level = None;
+                            indent = 0;
+                        }
+                        "outlinelevel" => level = arg.map(|a| a.clamp(0, 9) as u32),
+                        "li" => indent = arg.unwrap_or(0),
+                        "tab" | "line" => line.push(' '),
+                        "uc" => st.uc = arg.unwrap_or(1).clamp(0, 8) as usize,
+                        "u" => {
+                            let v = arg.unwrap_or(0);
+                            // RTF writes UTF-16 units as signed 16-bit values.
+                            push_utf16(&mut line, (v & 0xffff) as u32);
+                            pending_skip = 0;
+                            // Skip the fallback characters.
+                            let mut k = st.uc;
+                            while k > 0 && i < b.len() {
+                                if b[i] == b'\\' && b.get(i + 1) == Some(&b'\'') {
+                                    i = advance(rtf, i, 4);
+                                } else if b[i] == b'{' || b[i] == b'}' || b[i] == b'\\' {
+                                    break;
+                                } else {
+                                    i = advance(rtf, i, 1);
+                                }
+                                k -= 1;
+                            }
+                        }
+                        "emdash" => line.push('—'),
+                        "endash" => line.push('–'),
+                        "bullet" => line.push('•'),
+                        "lquote" => line.push('‘'),
+                        "rquote" => line.push('’'),
+                        "ldblquote" => line.push('“'),
+                        "rdblquote" => line.push('”'),
+                        _ => {}
+                    }
+                } else if n == b'\'' {
+                    let hex = rtf.get(i + 1..i + 3).filter(|h| h.bytes().all(|b| b.is_ascii_hexdigit())).and_then(|h| u8::from_str_radix(h, 16).ok());
+                    i = advance(rtf, i, 3);
+                    if !st.skip
+                        && let Some(h) = hex
+                        && h != 0
+                    {
+                        line.push(cp1252(h));
+                    }
+                } else {
+                    i += 1;
+                    if st.skip {
+                        continue;
+                    }
+                    match n {
+                        b'\\' | b'{' | b'}' => line.push(n as char),
+                        b'~' => line.push('\u{a0}'),
+                        b'_' => line.push('\u{2011}'),
+                        b'\n' | b'\r' => flush(&mut line, level, indent, &mut out),
+                        _ => {}
                     }
                 }
-                b'\r' | b'\n' => self.i += 1,
-                _ => self.text(),
+            }
+            b'\r' | b'\n' => i += 1,
+            _ => {
+                let s = i;
+                while i < b.len() && !matches!(b[i], b'{' | b'}' | b'\\' | b'\r' | b'\n') {
+                    i += 1;
+                }
+                if !st.skip
+                    && let Some(t) = rtf.get(s..i)
+                {
+                    line.push_str(&t.replace('\u{0}', ""));
+                }
             }
         }
     }
-
-    /// `{`: push the group; `{\*\dest …}` is an ignorable destination.
-    fn open_group(&mut self) {
-        self.stack.push(self.st);
-        self.i += 1;
-        if self.b[self.i..].starts_with(b"\\*") {
-            self.st.skip = true;
-        }
-    }
-
-    fn close_group(&mut self) {
-        self.st = self.stack.pop().unwrap_or(St { skip: false, uc: 1 });
-        self.i += 1;
-    }
-
-    /// The character after a backslash: a control word, a hex escape or a symbol. False at the
-    /// end of the input.
-    fn escape(&mut self) -> bool {
-        let Some(&n) = self.b.get(self.i) else { return false };
-        if n.is_ascii_alphabetic() {
-            self.control_word();
-        } else if n == b'\'' {
-            self.hex_escape();
-        } else {
-            self.symbol(n);
-        }
-        true
-    }
-
-    fn control_word(&mut self) {
-        let rtf = self.rtf;
-        let s = self.i;
-        while self.i < self.b.len() && self.b[self.i].is_ascii_alphabetic() {
-            self.i += 1;
-        }
-        let word = &rtf[s..self.i];
-        let ns = self.i;
-        if self.i < self.b.len() && (self.b[self.i] == b'-' || self.b[self.i].is_ascii_digit()) {
-            self.i += 1;
-            while self.i < self.b.len() && self.b[self.i].is_ascii_digit() {
-                self.i += 1;
-            }
-        }
-        let arg: Option<i64> = rtf[ns..self.i].parse().ok();
-        if self.i < self.b.len() && self.b[self.i] == b' ' {
-            self.i += 1;
-        }
-        if self.pending_skip > 0 {
-            self.pending_skip -= 1;
-            return;
-        }
-        if SKIP.contains(&word) {
-            self.st.skip = true;
-        }
-        if !self.st.skip {
-            self.apply(word, arg);
-        }
-    }
-
-    fn apply(&mut self, word: &str, arg: Option<i64>) {
-        match word {
-            "par" => self.flush(),
-            "pard" => {
-                self.level = None;
-                self.indent = 0;
-            }
-            "outlinelevel" => self.level = arg.map(|a| a.clamp(0, 9) as u32),
-            "li" => self.indent = arg.unwrap_or(0),
-            "tab" | "line" => self.line.push(' '),
-            "uc" => self.st.uc = arg.unwrap_or(1).clamp(0, 8) as usize,
-            "u" => self.unicode(arg.unwrap_or(0)),
-            "emdash" => self.line.push('—'),
-            "endash" => self.line.push('–'),
-            "bullet" => self.line.push('•'),
-            "lquote" => self.line.push('‘'),
-            "rquote" => self.line.push('’'),
-            "ldblquote" => self.line.push('“'),
-            "rdblquote" => self.line.push('”'),
-            _ => {}
-        }
-    }
-
-    /// `\uN`: one UTF-16 unit, then the `\uc` fallback characters, which are skipped.
-    fn unicode(&mut self, v: i64) {
-        // RTF writes UTF-16 units as signed 16-bit values.
-        push_utf16(&mut self.line, (v & 0xffff) as u32);
-        self.pending_skip = 0;
-        let mut k = self.st.uc;
-        while k > 0 && self.i < self.b.len() {
-            if self.b[self.i] == b'\\' && self.b.get(self.i + 1) == Some(&b'\'') {
-                self.i = advance(self.rtf, self.i, 4);
-            } else if matches!(self.b[self.i], b'{' | b'}' | b'\\') {
-                break;
-            } else {
-                self.i = advance(self.rtf, self.i, 1);
-            }
-            k -= 1;
-        }
-    }
-
-    /// `\'hh`: one cp1252 byte.
-    fn hex_escape(&mut self) {
-        let hex =
-            self.rtf.get(self.i + 1..self.i + 3).filter(|h| h.bytes().all(|b| b.is_ascii_hexdigit())).and_then(|h| u8::from_str_radix(h, 16).ok());
-        self.i = advance(self.rtf, self.i, 3);
-        if !self.st.skip
-            && let Some(h) = hex
-            && h != 0
-        {
-            self.line.push(cp1252(h));
-        }
-    }
-
-    /// A one-character control symbol (`\\`, `\{`, `\~`, ...).
-    fn symbol(&mut self, n: u8) {
-        self.i += 1;
-        if self.st.skip {
-            return;
-        }
-        match n {
-            b'\\' | b'{' | b'}' => self.line.push(n as char),
-            b'~' => self.line.push('\u{a0}'),
-            b'_' => self.line.push('\u{2011}'),
-            b'\n' | b'\r' => self.flush(),
-            _ => {}
-        }
-    }
-
-    /// Plain text up to the next special character.
-    fn text(&mut self) {
-        let s = self.i;
-        while self.i < self.b.len() && !matches!(self.b[self.i], b'{' | b'}' | b'\\' | b'\r' | b'\n') {
-            self.i += 1;
-        }
-        if !self.st.skip
-            && let Some(t) = self.rtf.get(s..self.i)
-        {
-            self.line.push_str(&t.replace('\u{0}', ""));
-        }
-    }
-
-    /// Ends the current line: a non-empty line becomes one outline entry, indented by its level.
-    fn flush(&mut self) {
-        let text = self.line.trim();
-        if !text.is_empty() {
-            let n = self.level.map(|l| l as i64).unwrap_or(self.indent.saturating_add(180) / 360).clamp(0, 9) as usize;
-            self.out.push_str(&"\t".repeat(n));
-            self.out.push_str(text);
-            self.out.push('\n');
-        }
-        self.line.clear();
-    }
+    flush(&mut line, level, indent, &mut out);
+    finish_surrogates(out)
 }
 
 /// Push a UTF-16 unit; surrogate halves are parked as private markers (NUL plus four hex digits)

crates/h264/src/dpb.rs

@@ -204,48 +204,6 @@ impl Dpb {
         entry_lists
     }
 
-    /// picNumLXNoWrap (8-34, 8-35) of a short-term modification from the predictor `pred`, and the
-    /// picNum it selects.
-    fn short_term_pic_nums(pred: i32, idc: u32, value: u32, curr_pic_num: i32, max_pic_num: i32) -> (i32, i32) {
-        let d = value as i32 + 1;
-        let no_wrap = if idc == 0 {
-            if pred - d < 0 { pred - d + max_pic_num } else { pred - d }
-        } else if pred + d >= max_pic_num {
-            pred + d - max_pic_num
-        } else {
-            pred + d
-        };
-        let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap };
-        (no_wrap, pn)
-    }
-
-    /// Puts `target` at `ref_idx` and shifts the rest of the list up, then drops the later entries
-    /// that repeat it (8.2.4.3.1, 8.2.4.3.2) and keeps the list `n` long.
-    fn insert_ref<'a>(list: &mut Vec<Option<&'a DpbEntry>>, ref_idx: usize, n: usize, target: &'a DpbEntry, is_long: bool) {
-        for c in (ref_idx + 1..=n).rev() {
-            list[c] = list[c - 1];
-        }
-        list[ref_idx] = Some(target);
-        let mut nidx = ref_idx + 1;
-        for c in ref_idx + 1..=n {
-            let keep = match list[c] {
-                None => true,
-                Some(e) => {
-                    if is_long {
-                        !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx)
-                    } else {
-                        !(e.mark == RefMark::Short && std::ptr::eq(e, target))
-                    }
-                }
-            };
-            if keep {
-                list[nidx] = list[c];
-                nidx += 1;
-            }
-        }
-        list.truncate(n);
-    }
-
     /// Reference picture list modification (8.2.4.3) of one list; `n` is num_ref_idx_active.
     fn modify_ref_list<'a>(
         list: &mut Vec<Option<&'a DpbEntry>>,
@@ -265,8 +223,16 @@ impl Dpb {
             list.push(None); // temporarily one longer
             let (target, is_long): (Option<&DpbEntry>, bool) = match m.idc {
                 0 | 1 => {
-                    let (no_wrap, pn) = Self::short_term_pic_nums(pred, m.idc, m.value, curr_pic_num, max_pic_num);
+                    let d = m.value as i32 + 1;
+                    let no_wrap = if m.idc == 0 {
+                        if pred - d < 0 { pred - d + max_pic_num } else { pred - d }
+                    } else if pred + d >= max_pic_num {
+                        pred + d - max_pic_num
+                    } else {
+                        pred + d
+                    };
                     pred = no_wrap;
+                    let pn = if no_wrap > curr_pic_num { no_wrap - max_pic_num } else { no_wrap };
                     (short.iter().copied().find(|e| Self::frame_num_wrap(e, cur_fn, max_frame_num) == pn), false)
                 }
                 2 => (long.iter().copied().find(|e| e.long_term_frame_idx == m.value), true),
@@ -278,8 +244,29 @@ impl Dpb {
                 ref_idx += 1;
                 continue;
             };
-            Self::insert_ref(list, ref_idx, n, target, is_long);
+            for c in (ref_idx + 1..=n).rev() {
+                list[c] = list[c - 1];
+            }
+            list[ref_idx] = Some(target);
             ref_idx += 1;
+            let mut nidx = ref_idx;
+            for c in ref_idx..=n {
+                let keep = match list[c] {
+                    None => true,
+                    Some(e) => {
+                        if is_long {
+                            !(e.mark == RefMark::Long && e.long_term_frame_idx == target.long_term_frame_idx)
+                        } else {
+                            !(e.mark == RefMark::Short && std::ptr::eq(e, target))
+                        }
+                    }
+                };
+                if keep {
+                    list[nidx] = list[c];
+                    nidx += 1;
+                }
+            }
+            list.truncate(n);
         }
         Ok(())
     }

crates/h264/src/params.rs

@@ -575,7 +575,7 @@ impl Pps {
         ensure!(sps_id < 32, "seq_parameter_set_id out of range");
         let sps = spss
             .get(sps_id as usize)
-            .and_then(Option::as_ref)
+            .and_then(|s| s.as_ref())
             .ok_or_else(|| crate::Error::MissingParameterSet(format!("SPS {sps_id} for PPS {id}")))?;
         let entropy_coding_mode = r.read_flag()?;
         let bottom_field_pic_order_in_frame_present = r.read_flag()?;

crates/hevc/src/mvpred.rs

@@ -74,39 +74,16 @@ 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 (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 PbGeom { xc, yc, ncb, xp: xp0, yp: yp0, w: w0, h: h0, part_idx: part_idx0 } = 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() };
@@ -153,11 +130,10 @@ impl<'a> SliceDecoder<'a> {
             list[n] = self.mv_at(pb2.0, pb2.1);
             n += 1;
         }
-        (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> {
+        if merge_idx < n {
+            return self.finish_merge(list[merge_idx], w0, h0);
+        }
+        // temporal candidate
         let mut col = MvField::default();
         let mut col_avail = false;
         if let Some(mv) = self.temporal(xp, yp, w, h, 0, 0) {
@@ -172,28 +148,30 @@ impl<'a> SliceDecoder<'a> {
             col.ref_idx[1] = 0;
             col_avail = true;
         }
-        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 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)
         let num_orig = cands.len();
-        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]] });
+        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;
             }
-            comb += 1;
         }
-    }
-
-    /// 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) {
+        if merge_idx < cands.len() {
+            return self.finish_merge(cands[merge_idx], w0, h0);
+        }
+        // zero candidates (8.5.3.2.5)
         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 {
@@ -201,6 +179,7 @@ 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/hevc/src/slicedec.rs

@@ -277,30 +277,6 @@ pub struct SliceDecoder<'a> {
     pub ctb_y: i32,
 }
 
-/// Scaling process (8.6.3): dequantises the top-left `max_x` × `max_y` coefficients of the `n` × `n`
-/// block `coeffs` with scaling matrix `m` (flat when `None`).
-fn dequantize(coeffs: &mut [i32], n: usize, (max_x, max_y): (usize, usize), m: Option<&[u8]>, scale: i64, round: i64, bd_shift: u32) {
-    for y in 0..=max_y {
-        for x in 0..=max_x {
-            let v = coeffs[y * n + x];
-            if v != 0 {
-                let f = m.map_or(16, |m| m[y * n + x] as i64);
-                coeffs[y * n + x] = ((v as i64 * f * scale + round) >> bd_shift).clamp(-32768, 32767) as i32;
-            }
-        }
-    }
-}
-
-/// Adds the `n` × `n` residual `coeffs` to the samples of `plane` at (x0, y0), clipped to 0..=`max`.
-fn add_residual(plane: &mut [u16], stride: usize, (x0, y0): (usize, usize), n: usize, coeffs: &[i32], max: i32) {
-    for y in 0..n {
-        let row = &mut plane[(y0 + y) * stride + x0..][..n];
-        for (x, s) in row.iter_mut().enumerate() {
-            *s = (*s as i32 + coeffs[y * n + x]).clamp(0, max) as u16;
-        }
-    }
-}
-
 impl<'a> SliceDecoder<'a> {
     #[inline(always)]
     fn dd(&mut self, ctx: usize) -> u32 {
@@ -1355,7 +1331,15 @@ impl<'a> SliceDecoder<'a> {
                 }
                 _ => None,
             };
-            dequantize(coeffs, n, (max_x, max_y), m, scale, round, bd_shift);
+            for y in 0..=max_y {
+                for x in 0..=max_x {
+                    let v = coeffs[y * n + x];
+                    if v != 0 {
+                        let f = m.map_or(16, |m| m[y * n + x] as i64);
+                        coeffs[y * n + x] = ((v as i64 * f * scale + round) >> bd_shift).clamp(-32768, 32767) as i32;
+                    }
+                }
+            }
             let bd_shift = 20 - bd;
             if ts {
                 transform::transform_skip(coeffs, n, bd_shift);
@@ -1371,7 +1355,12 @@ impl<'a> SliceDecoder<'a> {
         let _ = dc_only;
         let (stride, max) = (if c == 0 { self.pic.width } else { self.pic.cwidth }, (1i32 << bd) - 1);
         let plane = &mut self.pic.planes[c];
-        add_residual(plane, stride, (x0 as usize, y0 as usize), n, coeffs, max);
+        for y in 0..n {
+            let row = &mut plane[(y0 as usize + y) * stride + x0 as usize..][..n];
+            for (x, s) in row.iter_mut().enumerate() {
+                *s = (*s as i32 + coeffs[y * n + x]).clamp(0, max) as u16;
+            }
+        }
         Ok(())
     }
 

crates/model/src/chart.rs

@@ -802,7 +802,6 @@ impl Chart {
 /// The (min, max, major unit) of an axis over the data range [lo, hi]: `fmin`/`fmax`/`major`
 /// where the chart fixes them; otherwise Office's automatic limits, rounded out to the smallest
 /// 1-2-5 unit giving at most `max_intervals` intervals:
-/// The data range [lo, hi] an axis covers, clamped to ±1e100; (0, 1) without finite values.
 ///
 /// - **Maximum:** `hi + (hi − lo)/20` (with `headroom`), rounded up to the unit.
 /// - **Minimum:** zero when every value is ≥ 0 and `lo` is below 5/6 of `hi`; otherwise
@@ -810,14 +809,22 @@ impl Chart {
 ///   near them.
 /// - All-negative values mirror this: the axis ends at zero when `hi` is above 5/6 of `lo`.
 ///   Mixed signs get headroom at both ends.
-fn axis_data_range(lo: f64, hi: f64) -> (f64, f64) {
-    if lo.is_finite() && hi.is_finite() { (lo.min(hi).clamp(-1e100, 1e100), lo.max(hi).clamp(-1e100, 1e100)) } else { (0.0, 1.0) }
-}
-
-/// Office's automatic (min, max) of the data range [lo, hi]. "How chart axis limits are determined",
-/// as Jon Peltier summarises it: 5 % of the data range past the data, and zero when the values don't
-/// sit within the top sixth of their largest magnitude. A single value is measured from zero.
-fn auto_limits(lo: f64, hi: f64, headroom: bool) -> (f64, f64) {
+pub fn axis_scale(
+    lo: f64,
+    hi: f64,
+    fmin: Option<f64>,
+    fmax: Option<f64>,
+    major: Option<f64>,
+    max_intervals: usize,
+    headroom: bool,
+) -> (f64, f64, f64) {
+    // Values past ±1e100 aren't axis values; clamping keeps the arithmetic finite.
+    let fin = |v: Option<f64>| v.filter(|v| v.is_finite()).map(|v| v.clamp(-1e100, 1e100));
+    let (fmin, fmax) = (fin(fmin), fin(fmax));
+    let (lo, hi) = if lo.is_finite() && hi.is_finite() { (lo.min(hi).clamp(-1e100, 1e100), lo.max(hi).clamp(-1e100, 1e100)) } else { (0.0, 1.0) };
+    // Office's automatic limits ("How chart axis limits are determined", as Jon Peltier
+    // summarises it): 5 % of the data range past the data, and zero when the values don't
+    // sit within the top sixth of their largest magnitude. A single value is measured from zero.
     let flat = hi - lo <= 1e-12 * lo.abs().max(hi.abs());
     let pad = if !headroom {
         0.0
@@ -828,23 +835,21 @@ fn auto_limits(lo: f64, hi: f64, headroom: bool) -> (f64, f64) {
     };
     let auto_lo = if lo >= 0.0 && (flat || lo < hi * 5.0 / 6.0) { 0.0 } else { lo - pad };
     let auto_hi = if hi <= 0.0 && (flat || hi > lo * 5.0 / 6.0) { 0.0 } else { hi + pad };
-    (auto_lo, auto_hi)
-}
-
-/// The ends of a span too small to show: with one fixed limit on the far side of the data, the
-/// automatic end gives way; otherwise the span is one `unit` wide.
-fn flat_span_ends(fmin: Option<f64>, fmax: Option<f64>, lo: f64, hi: f64, unit: f64) -> (f64, f64) {
-    match (fmin, fmax) {
-        (None, Some(_)) => (if hi > 0.0 { 0.0 } else { hi - hi.abs().max(unit) }, hi),
-        (Some(_), None) if lo < 0.0 => (lo, 0.0),
-        _ => (lo, lo + unit),
+    let mut lo = fmin.unwrap_or(auto_lo);
+    let mut hi = fmax.unwrap_or(auto_hi);
+    let mag = lo.abs().max(hi.abs());
+    // Relative to the data's magnitude, so tiny values don't count as flat; all-zero falls back to 1.
+    let unit = if mag == 0.0 { 1.0 } else { mag };
+    if hi - lo <= 1e-12 * mag {
+        // A fixed limit on the far side of the data: the automatic end gives way.
+        match (fmin, fmax) {
+            (None, Some(_)) => lo = if hi > 0.0 { 0.0 } else { hi - hi.abs().max(unit) },
+            (Some(_), None) if lo < 0.0 => hi = 0.0,
+            _ => hi = lo + unit,
+        }
     }
-}
-
-/// The major step: `major` when it gives at most 1000 intervals, else the smallest 1-2-5 step
-/// that fits `n` intervals over [lo, hi].
-fn axis_step(major: Option<f64>, lo: f64, hi: f64, n: f64, unit: f64) -> f64 {
-    match major.filter(|m| *m > 0.0 && (hi - lo) / m <= 1000.0) {
+    let n = max_intervals.clamp(1, 50) as f64;
+    let step = match fin(major).filter(|m| *m > 0.0 && (hi - lo) / m <= 1000.0) {
         Some(m) => m,
         None => {
             let mut step = 10f64.powf(((hi - lo) / n).log10().floor());
@@ -860,32 +865,7 @@ fn axis_step(major: Option<f64>, lo: f64, hi: f64, n: f64, unit: f64) -> f64 {
             }
             step
         }
-    }
-}
-
-pub fn axis_scale(
-    lo: f64,
-    hi: f64,
-    fmin: Option<f64>,
-    fmax: Option<f64>,
-    major: Option<f64>,
-    max_intervals: usize,
-    headroom: bool,
-) -> (f64, f64, f64) {
-    // Values past ±1e100 aren't axis values; clamping keeps the arithmetic finite.
-    let fin = |v: Option<f64>| v.filter(|v| v.is_finite()).map(|v| v.clamp(-1e100, 1e100));
-    let (fmin, fmax) = (fin(fmin), fin(fmax));
-    let (lo, hi) = axis_data_range(lo, hi);
-    let (auto_lo, auto_hi) = auto_limits(lo, hi, headroom);
-    let (mut lo, mut hi) = (fmin.unwrap_or(auto_lo), fmax.unwrap_or(auto_hi));
-    let mag = lo.abs().max(hi.abs());
-    // Relative to the data's magnitude, so tiny values don't count as flat; all-zero falls back to 1.
-    let unit = if mag == 0.0 { 1.0 } else { mag };
-    if hi - lo <= 1e-12 * mag {
-        (lo, hi) = flat_span_ends(fmin, fmax, lo, hi, unit);
-    }
-    let n = max_intervals.clamp(1, 50) as f64;
-    let step = axis_step(fin(major), lo, hi, n, unit);
+    };
     let min = fmin.unwrap_or((lo / step + 1e-9).floor() * step);
     let max = fmax.unwrap_or((hi / step - 1e-9).ceil() * step).max(min + step);
     (min, max, step)

crates/pptx/src/read/dml.rs

@@ -576,44 +576,6 @@ pub fn text_body(imp: &mut Imp, part: &Part, tx: &El) -> TextBody {
 
 const MAX_PARAGRAPH_RUNS: usize = 10_000;
 
-/// The run properties of `e`'s `rPr` child, or the defaults.
-fn run_props(imp: &mut Imp, part: &Part, e: &El) -> RunProps {
-    e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default()
-}
-
-/// Appends the runs of an `a:r` text, where a vertical tab or line feed is a line break, as it
-/// lays out and as export writes it.
-fn push_text_runs(para: &mut Paragraph, props: RunProps, text: &str) {
-    for (i, piece) in text.split(['\u{b}', '\n']).enumerate() {
-        if para.runs.len() >= MAX_PARAGRAPH_RUNS {
-            break;
-        }
-        if i > 0 {
-            para.runs.push(Run { text: String::new(), props: props.clone(), kind: RunKind::Break });
-        }
-        if !piece.is_empty() {
-            if para.runs.len() >= MAX_PARAGRAPH_RUNS {
-                break;
-            }
-            para.runs.push(Run { text: piece.to_string(), props: props.clone(), kind: RunKind::Text });
-        }
-    }
-}
-
-/// Appends an Office Math (a14:m) run: its plain text and its OMML.
-fn push_math_run(para: &mut Paragraph, part: &Part, e: &El) {
-    if para.runs.len() < MAX_PARAGRAPH_RUNS {
-        let mut text = String::new();
-        let mut ts = vec![];
-        e.find_all("t", &mut ts);
-        for t in ts {
-            text.push_str(&t.text());
-        }
-        let omml = e.elements().map(|c| part.keep_inner(c)).collect::<String>();
-        para.runs.push(Run { text, props: RunProps::default(), kind: RunKind::Math { omml } });
-    }
-}
-
 pub fn paragraph(imp: &mut Imp, part: &Part, p: &El) -> Paragraph {
     let mut para = Paragraph::default();
     for e in p.elements() {
@@ -627,24 +589,50 @@ pub fn paragraph(imp: &mut Imp, part: &Part, p: &El) -> Paragraph {
                 }
             }
             "r" => {
-                let props = run_props(imp, part, e);
+                let props = e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default();
                 let text: String = e.child("t").map(|t| t.text()).unwrap_or_default();
-                push_text_runs(&mut para, props, &text);
+                // A vertical tab or line feed inside text is a line break, as it lays out and as export writes it.
+                for (i, piece) in text.split(['\u{b}', '\n']).enumerate() {
+                    if para.runs.len() >= MAX_PARAGRAPH_RUNS {
+                        break;
+                    }
+                    if i > 0 {
+                        para.runs.push(Run { text: String::new(), props: props.clone(), kind: RunKind::Break });
+                    }
+                    if !piece.is_empty() {
+                        if para.runs.len() >= MAX_PARAGRAPH_RUNS {
+                            break;
+                        }
+                        para.runs.push(Run { text: piece.to_string(), props: props.clone(), kind: RunKind::Text });
+                    }
+                }
             }
             "br" => {
                 if para.runs.len() < MAX_PARAGRAPH_RUNS {
-                    let props = run_props(imp, part, e);
+                    let props = e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default();
                     para.runs.push(Run { text: String::new(), props, kind: RunKind::Break });
                 }
             }
             "fld" => {
                 if para.runs.len() < MAX_PARAGRAPH_RUNS {
-                    let props = run_props(imp, part, e);
+                    let props = e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default();
                     let text = e.child("t").map(|t| t.text()).unwrap_or_default();
                     para.runs.push(Run { text, props, kind: RunKind::Field { field: e.attr("type").unwrap_or("").to_string() } });
                 }
             }
-            "m" => push_math_run(&mut para, part, e),
+            "m" => {
+                if para.runs.len() < MAX_PARAGRAPH_RUNS {
+                    // Office Math (a14:m) — keep the OMML and its plain text.
+                    let mut text = String::new();
+                    let mut ts = vec![];
+                    e.find_all("t", &mut ts);
+                    for t in ts {
+                        text.push_str(&t.text());
+                    }
+                    let omml = e.elements().map(|c| part.keep_inner(c)).collect::<String>();
+                    para.runs.push(Run { text, props: RunProps::default(), kind: RunKind::Math { omml } });
+                }
+            }
             "endParaRPr" => para.end_props = rpr(imp, part, e),
             _ => {}
         }

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) {