perf: faster effects, expressions, text, caches, movie reading, project open, export and UI playback

Cargo.toml

@@ -71,6 +71,7 @@ image = { version = "0.25", default-features = false, features = ["png", "jpeg"]
 
 # media codecs + containers: FilmCraft's pure-Rust crates, pinned to a revision (plan/adr/0001).
 # Only `crates/media`, `crates/export` and `crates/interchange` may depend on these.
+# Header-only probing of standalone audio files (the same build FilmCraft decodes them with; MPL-2.0).
 filmcraft-codecs = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
 filmcraft-media = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
 filmcraft-frame = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }

apps/effectcraft/src/native_menu.rs

@@ -2,16 +2,17 @@
 //! [`effectcraft_ui_egui::native_menu`]'s spec of the engine's After Effects menu tree.
 //!
 //! Each frame [`NativeBar::update`] runs menu activations (the same command ids as the in-window
-//! bar), and when [`native_menu::state_key`] changed it rebuilds the spec and pushes labels,
-//! enabled and check state into the existing items; a structural change (Open Recent, a new
-//! shortcut preset) rebuilds the menu. Settings ▸ Appearance ▸ Use In-Window Menu Bar on macOS
+//! bar), and when [`native_menu::state_key`] changed (at most every
+//! [`native_menu::MENU_REFRESH_INTERVAL`]) it rebuilds the spec and, when that differs, pushes
+//! labels, enabled and check state into the existing items; a structural change (Open Recent, a
+//! new shortcut preset) rebuilds the menu. Settings ▸ Appearance ▸ Use In-Window Menu Bar on macOS
 //! swaps back to the in-window bar.
 
 use std::collections::HashMap;
 use std::sync::mpsc::{Receiver, channel};
 
 use effectcraft_ui_egui::EffectcraftApp;
-use effectcraft_ui_egui::native_menu::{self, NativeMenu, NativeNode, Role};
+use effectcraft_ui_egui::native_menu::{self, MenuPacer, NativeMenu, NativeNode, Pace, Role};
 use muda::{CheckMenuItem, Menu, MenuEvent, PredefinedMenuItem, Submenu};
 
 /// The `muda` accelerator for a spec accelerator string.
@@ -24,7 +25,7 @@ pub struct NativeBar {
     items: HashMap<String, CheckMenuItem>,
     spec: NativeMenu,
     structure: u64,
-    state: Option<u64>,
+    pacer: MenuPacer,
     events: Receiver<MenuEvent>,
     /// The in-window-bar setting last applied (None: not yet).
     in_window: Option<bool>,
@@ -38,7 +39,7 @@ impl NativeBar {
             let _ = tx.send(e);
             ctx.request_repaint();
         }));
-        NativeBar { menu: None, items: HashMap::new(), spec: NativeMenu::default(), structure: 0, state: None, events: rx, in_window: None }
+        NativeBar { menu: None, items: HashMap::new(), spec: NativeMenu::default(), structure: 0, pacer: MenuPacer::default(), events: rx, in_window: None }
     }
 
     /// Run activations and keep the native menu in step with the app (call once per frame).
@@ -53,7 +54,7 @@ impl NativeBar {
                 }
                 self.items.clear();
             } else {
-                self.state = None;
+                self.pacer.reset();
                 self.structure = 0;
             }
         }
@@ -62,22 +63,33 @@ impl NativeBar {
                 log::warn!("menu: {err}");
             }
             // Check items toggle themselves when clicked: resync with the app.
-            self.state = None;
+            self.pacer.reset();
         }
         if in_window {
             return;
         }
-        let key = native_menu::state_key(app);
-        if self.state == Some(key) && self.menu.is_some() {
+        // While a button is held (a drag edits on every frame, each a new revision) the menu,
+        // which can't be opened meanwhile, catches up on release.
+        if self.menu.is_some() && self.pacer.applied() && ctx.input(|i| i.pointer.any_down()) {
             return;
         }
-        self.state = Some(key);
+        if self.menu.is_none() {
+            self.pacer.reset();
+        }
+        match self.pacer.check(native_menu::state_key(app), ctx.input(|i| i.time)) {
+            Pace::Current => return,
+            Pace::Later(wait) => {
+                ctx.request_repaint_after(std::time::Duration::try_from_secs_f64(wait).unwrap_or_default());
+                return;
+            }
+            Pace::Now => {}
+        }
         let spec = native_menu::build(app);
         let structure = spec.structure();
         if self.menu.is_none() || structure != self.structure {
             self.install(&spec);
             self.structure = structure;
-        } else {
+        } else if spec != self.spec {
             self.refresh(&spec);
         }
         self.spec = spec;

crates/effects/src/blur2.rs

@@ -301,6 +301,14 @@ pub fn camera_lens_plain(ctx: &EffectCtx) -> bool {
     ctx.params.f("irisProperties/diffractionFringe") <= 0.0 && ctx.params.get("blurMap/blurMapLayer").and_then(|v| v.as_layer()).is_none()
 }
 
+/// Camera Lens Blur iris spans `(dy, x_left, x_right)` and their pixel counts.
+struct Iris {
+    outer: Vec<(i64, i64, i64)>,
+    inner: Vec<(i64, i64, i64)>,
+    no: f64,
+    ni: f64,
+}
+
 fn camera_lens_blur(ctx: &EffectCtx, mut b: Buf) -> Buf {
     let r = ctx.params.f("blurRadius").max(0.0) * b.scale;
     if r < 0.5 {
@@ -406,7 +414,9 @@ fn camera_lens_blur(ctx: &EffectCtx, mut b: Buf) -> Buf {
     // 0 = an even disc, 100 = a natural halo, 500 = all of it in the ring.
     let fringe = (ctx.params.f("irisProperties/diffractionFringe") / 500.0).clamp(0.0, 1.0);
     let (w_in, w_ring) = (1.0 - fringe, 1.0 + 4.0 * fringe);
-    let iris = |radius: f64| -> (Vec<(i64, i64, i64)>, Vec<(i64, i64, i64)>) {
+    let count = |s: &[(i64, i64, i64)]| s.iter().map(|(_, l, r)| (r - l + 1) as f64).sum::<f64>();
+    // The outer and inner (fringe) iris spans of a radius, with their pixel counts summed once.
+    let iris = |radius: f64| -> Iris {
         let stretch = |mut s: Vec<(i64, i64, i64)>| {
             if aspect > 0.0 && (aspect - 1.0).abs() > 1e-6 {
                 for v in s.iter_mut() {
@@ -422,18 +432,18 @@ fn camera_lens_blur(ctx: &EffectCtx, mut b: Buf) -> Buf {
         } else {
             vec![]
         };
-        (outer, inner)
+        let (no, ni) = (count(&outer), count(&inner));
+        Iris { outer, inner, no, ni }
     };
-    let count = |s: &[(i64, i64, i64)]| s.iter().map(|(_, l, r)| (r - l + 1) as f64).sum::<f64>();
     // One blurred pixel with the given iris.
-    let blur_px = |sp: &(Vec<(i64, i64, i64)>, Vec<(i64, i64, i64)>), x: usize, y: usize| -> [f32; 4] {
-        let (outer, inner) = sp;
+    let blur_px = |sp: &Iris, x: usize, y: usize| -> [f32; 4] {
+        let Iris { outer, inner, no, ni } = sp;
+        let (no, ni) = (*no, *ni);
         let acc = if inner.is_empty() {
-            let n = count(outer).max(1.0);
+            let n = no.max(1.0);
             span_sum(outer, x, y).map(|v| v / n)
         } else {
             let (so, si) = (span_sum(outer, x, y), span_sum(inner, x, y));
-            let (no, ni) = (count(outer), count(inner));
             let norm = (w_in * ni + w_ring * (no - ni)).max(1e-9);
             std::array::from_fn(|c| (w_in * si[c] + w_ring * (so[c] - si[c])) / norm)
         };