Merge branch 'worktree-agent-ae879257b39393c25'

# Conflicts:
#	docs/parity.md

crates/ui-egui/src/frames.rs

@@ -7,6 +7,11 @@
 //! wasm32 has no threads: jobs wait in the same priority queue and [`Frames::pump`] renders them
 //! on the UI thread between egui frames, within a time budget.
 //!
+//! With the disk cache on (Settings ▸ Media & Disk Cache), every CPU-rendered frame is also
+//! written to disk under a content key (the comp's content hash, frame, scale, view and render
+//! options), and a job first looks there: frames survive restarts and project reopenings. The
+//! timeline shows disk-only frames as a blue cache bar.
+//!
 //! With Mercury GPU Acceleration (a [`Gpu`] on egui-wgpu's device and the project's renderer set
 //! to the GPU) frames stay on the GPU: the compositor writes an RGBA8 texture that the viewer
 //! registers with egui-wgpu and draws directly; pixels are read back only when something needs
@@ -16,6 +21,7 @@ use std::collections::{HashMap, HashSet, VecDeque};
 use std::sync::{Arc, Mutex};
 
 use effectcraft_engine::project::{ItemId, Project};
+use effectcraft_engine::render::disk_cache::{self, DiskCache};
 use effectcraft_engine::render::{ExprHost, FootageSource, LayerCache, RenderOpts, Renderer};
 use effectcraft_engine::time::Tick;
 use effectcraft_gpu::{DisplayFrame, Gpu};
@@ -122,6 +128,37 @@ pub struct RenderSource {
     /// Show Channel / exposure / region-of-interest drawing read the CPU frame texture, so GPU
     /// frames are read back (the compositing still runs on the GPU).
     pub gpu_display: bool,
+    /// The persistent disk cache, when enabled.
+    pub disk: Option<Arc<DiskCache>>,
+}
+
+/// Content keys of (project revision, comp), computed once per revision.
+type ContentKeys = Arc<Mutex<HashMap<(u64, u64), u128>>>;
+
+fn content_key(keys: &ContentKeys, project: &Project, revision: u64, comp: u64) -> u128 {
+    if let Some(k) = keys.lock().ok().and_then(|m| m.get(&(revision, comp)).copied()) {
+        return k;
+    }
+    let k = disk_cache::comp_content_key(project, ItemId(comp));
+    if let Ok(mut m) = keys.lock() {
+        if m.len() > 256 {
+            m.clear();
+        }
+        m.insert((revision, comp), k);
+    }
+    k
+}
+
+fn opts_hash(o: &RenderOpts) -> u64 {
+    let mut h = disk_cache::Hash128::default();
+    h.write(format!("{o:?}").as_bytes());
+    h.finish() as u64
+}
+
+/// Disk key of a viewer frame (render options included: region of interest, draft…).
+fn frame_disk_key(keys: &ContentKeys, project: &Project, key: &FrameKey, opts_hash: u64) -> u128 {
+    let content = content_key(keys, project, key.revision, key.comp);
+    disk_cache::frame_key(content, key.frame, key.scale, key.view ^ opts_hash)
 }
 
 pub struct Frames {
@@ -135,6 +172,7 @@ pub struct Frames {
     ctx: Option<egui::Context>,
     /// Render time of the last viewer (urgent) frame in ms, for the Info panel / perf readout.
     pub last_ms: Arc<Mutex<f64>>,
+    content_keys: ContentKeys,
 }
 
 impl Default for Frames {
@@ -149,6 +187,7 @@ impl Default for Frames {
             pool: rayon::ThreadPoolBuilder::new().num_threads(threads).thread_name(|i| format!("ec-frame-{i}")).build().expect("frame pool"),
             ctx: None,
             last_ms: Arc::new(Mutex::new(0.0)),
+            content_keys: Arc::default(),
         }
     }
 }
@@ -195,6 +234,21 @@ impl Frames {
         v
     }
 
+    /// Frames of (revision, comp, scale) in the disk cache but not in RAM — the blue cache bar.
+    /// `opts` are the viewer's render options (part of the disk key).
+    pub fn disk_frames(&self, src: &RenderSource, revision: u64, comp: u64, scale: u32, view: u64, frames: i64, opts: &RenderOpts) -> Vec<i64> {
+        let Some(dc) = &src.disk else { return vec![] };
+        let ram: HashSet<i64> = self.cached_frames(revision, comp, scale).into_iter().collect();
+        let oh = opts_hash(opts);
+        (0..frames.clamp(0, 100_000))
+            .filter(|f| !ram.contains(f))
+            .filter(|f| {
+                let key = FrameKey { revision, comp, frame: *f, scale, view };
+                dc.contains(disk_cache::Kind::Frame, frame_disk_key(&self.content_keys, &src.project, &key, oh))
+            })
+            .collect()
+    }
+
     /// Change the RAM preview cache budget (Settings ▸ Memory & CPU), evicting the oldest
     /// frames when it shrinks.
     pub fn set_budget(&self, bytes: usize) {
@@ -278,7 +332,14 @@ impl Frames {
     }
 
     fn worker(&self) -> Worker {
-        Worker { queue: self.queue.clone(), cache: self.cache.clone(), inflight: self.inflight.clone(), ctx: self.ctx.clone(), last: self.last_ms.clone() }
+        Worker {
+            queue: self.queue.clone(),
+            cache: self.cache.clone(),
+            inflight: self.inflight.clone(),
+            ctx: self.ctx.clone(),
+            last: self.last_ms.clone(),
+            content_keys: self.content_keys.clone(),
+        }
     }
 
     /// Render queued frames on this thread, most important first, until the queue is empty or
@@ -306,12 +367,13 @@ struct Worker {
     inflight: Arc<Mutex<HashSet<FrameKey>>>,
     ctx: Option<egui::Context>,
     last: Arc<Mutex<f64>>,
+    content_keys: ContentKeys,
 }
 
 impl Worker {
     /// Render the queued job that matters most right now. `false` when the queue was empty.
     fn run_next(&self) -> bool {
-        let Worker { queue, cache, inflight, ctx, last } = self;
+        let Worker { queue, cache, inflight, ctx, last, content_keys } = self;
         let job = {
             let Ok(mut q) = queue.lock() else { return false };
             // Urgent first (newest), then prefetch in request order.
@@ -325,19 +387,18 @@ impl Worker {
             job
         };
         let t0 = web_time::Instant::now();
-        let mut r = Renderer::new(&job.src.project, job.src.footage.as_ref(), job.opts);
-        r.expr = job.src.expr.as_deref();
-        r.cache = Some(&job.src.layer_cache);
-        r.accel = job.src.gpu.as_ref().map(|g| g as &dyn effectcraft_engine::render::Accelerator);
-        // The GPU leaves the frame in a texture for the viewer; otherwise (Software Only, no
-        // adapter, or a frame the GPU cannot finish here) the CPU renders it.
-        let gpu_frame = match (&job.src.gpu, r.active_accel()) {
-            (Some(g), Some(_)) if job.src.gpu_display => g.render_display(&r, job.comp, job.t),
-            _ => None,
-        };
-        let ci = match gpu_frame {
-            Some(f) => FrameImage::Gpu(Arc::new(f)),
-            None => FrameImage::Cpu(Arc::new(to_color_image(&r.comp_frame(job.comp, job.t)))),
+        let disk = job.src.disk.as_ref().map(|dc| (dc.clone(), frame_disk_key(content_keys, &job.src.project, &job.key, opts_hash(&job.opts))));
+        let from_disk = disk.as_ref().and_then(|(dc, k)| dc.get_frame(*k));
+        let ci = match from_disk {
+            Some(f) => FrameImage::Cpu(Arc::new(egui::ColorImage::from_rgba_premultiplied([f.width as usize, f.height as usize], &f.rgba))),
+            None => {
+                let ci = self.render_job(&job);
+                if let (Some((dc, k)), FrameImage::Cpu(img)) = (&disk, &ci) {
+                    let rgba: Vec<u8> = img.pixels.iter().flat_map(|c| c.to_array()).collect();
+                    dc.put_frame(*k, img.size[0] as u32, img.size[1] as u32, &rgba);
+                }
+                ci
+            }
         };
         if job.urgent
             && let Ok(mut l) = last.lock()
@@ -361,6 +422,23 @@ impl Worker {
         }
         true
     }
+
+    fn render_job(&self, job: &Job) -> FrameImage {
+        let mut r = Renderer::new(&job.src.project, job.src.footage.as_ref(), job.opts);
+        r.expr = job.src.expr.as_deref();
+        r.cache = Some(&job.src.layer_cache);
+        r.accel = job.src.gpu.as_ref().map(|g| g as &dyn effectcraft_engine::render::Accelerator);
+        // The GPU leaves the frame in a texture for the viewer; otherwise (Software Only, no
+        // adapter, or a frame the GPU cannot finish here) the CPU renders it.
+        let gpu_frame = match (&job.src.gpu, r.active_accel()) {
+            (Some(g), Some(_)) if job.src.gpu_display => g.render_display(&r, job.comp, job.t),
+            _ => None,
+        };
+        match gpu_frame {
+            Some(f) => FrameImage::Gpu(Arc::new(f)),
+            None => FrameImage::Cpu(Arc::new(to_color_image(&r.comp_frame(job.comp, job.t)))),
+        }
+    }
 }
 
 struct Job {

crates/ui-egui/src/lib.rs

@@ -324,6 +324,7 @@ impl EffectcraftApp {
             layer_cache: self.session.layer_cache.clone(),
             gpu: self.gpu.clone(),
             gpu_display: false,
+            disk: self.session.disk_cache.clone(),
         }
     }
 
@@ -421,13 +422,11 @@ impl EffectcraftApp {
         self.request_frame_with(comp, frame, scale, true);
     }
 
-    fn request_frame_with(&self, comp: ItemId, frame: i64, scale: f64, urgent: bool) {
-        let Some(c) = self.session.project.comp(comp) else { return };
-        let key = self.frame_key(comp, frame, scale);
-        let t = c.frame_rate.tick_of(frame);
+    /// Render options of viewer frames of `comp` at `scale`.
+    pub fn frame_opts(&self, comp: ItemId, scale: f64) -> RenderOpts {
         let (draft, _) = self.session.state.viewer.fast_previews.render(self.ui.viewer.interacting);
         let roi = self.session.state.region_of_interest.filter(|_| self.session.active_comp_id() == Some(comp));
-        let opts = RenderOpts {
+        RenderOpts {
             scale,
             motion_blur: true,
             guides: true,
@@ -435,7 +434,14 @@ impl EffectcraftApp {
             view: self.session.view_camera(comp),
             roi,
             backend: effectcraft_engine::render::Backend::Auto,
-        };
+        }
+    }
+
+    fn request_frame_with(&self, comp: ItemId, frame: i64, scale: f64, urgent: bool) {
+        let Some(c) = self.session.project.comp(comp) else { return };
+        let key = self.frame_key(comp, frame, scale);
+        let t = c.frame_rate.tick_of(frame);
+        let opts = self.frame_opts(comp, scale);
         if urgent {
             self.frames.request_urgent(&self.render_source(), key, comp, t, opts);
         } else {

crates/ui-egui/src/menus.rs

@@ -802,7 +802,7 @@ fn file_dialog(app: &mut EffectcraftApp, id: &str, params: &Value) -> Option<Res
             let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `paths`)".into())) };
             let paths = f(&[
                 "mp4", "mov", "m4v", "mkv", "webm", "png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "wav", "aif", "aiff", "mp3", "flac",
-                "ogg", "opus", "svg", "gltf", "glb", "obj",
+                "ogg", "opus", "svg", "psd", "psb", "gltf", "glb", "obj",
             ]);
             match (paths.is_empty(), key) {
                 (true, _) => None,
@@ -825,6 +825,10 @@ fn file_dialog(app: &mut EffectcraftApp, id: &str, params: &Value) -> Option<Res
     };
     let Some(v) = picked else { return Some(Ok(Value::Null)) };
     p.insert(key.to_string(), v);
+    // Photoshop files ask how to import them first.
+    if id == "file.import" && crate::panels::dialogs::open_form(app, id, &Value::Object(p.clone())) {
+        return Some(Ok(json!({"dialog": id})));
+    }
     // Save (untitled) becomes Save As.
     let id = if id == "file.save" { "file.saveAs" } else { id };
     let r = app.session.execute(id, Value::Object(p)).map_err(|e| e.to_string());

crates/ui-egui/src/panels/forms.rs

@@ -108,6 +108,16 @@ fn has(p: &Value, keys: &[&str]) -> bool {
 }
 
 /// If `id` is a dialog command invoked without its parameters, open its form and return true.
+/// The import includes a Photoshop document.
+fn is_layered(p: &Value) -> bool {
+    let psd = |v: &Value| v.as_str().is_some_and(|s| matches!(s.rsplit('.').next().map(str::to_ascii_lowercase).as_deref(), Some("psd" | "psb")));
+    match p.get("paths").or(p.get("path")) {
+        Some(Value::Array(a)) => a.iter().any(psd),
+        Some(v) => psd(v),
+        None => false,
+    }
+}
+
 pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
     let s = &app.session;
     let comp = s.active_comp();
@@ -116,6 +126,16 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
     let lt = layer.map(|l| l.layer_time(t)).unwrap_or(t);
     let base = p.clone();
     let (title, fields): (String, Vec<Field>) = match id {
+        // Photoshop files: Import Kind (Footage / Composition / – Retain Layer Sizes).
+        "file.import" if !has(p, &["importAs"]) && is_layered(p) => (
+            "Import Photoshop File".into(),
+            vec![Field::choice(
+                "importAs",
+                "Import Kind",
+                &[("Footage", json!("footage")), ("Composition", json!("composition")), ("Composition - Retain Layer Sizes", json!("compositionLayerSizes"))],
+                1,
+            )],
+        ),
         "layer.setTransform" if !has(p, &["value"]) => {
             let prop = p.get("prop").and_then(Value::as_str).unwrap_or("position");
             let cur = layer.and_then(|l| l.transform()).and_then(|tr| tr.get(if prop == "anchorPoint" { "anchor" } else { prop })).map(|pr| pr.value_at(lt));

crates/ui-egui/src/panels/render_queue.rs

@@ -108,7 +108,7 @@ fn output_menu(it: &RenderQueueItem, available: &[OutputFormat]) -> Vec<(String,
                 v.push((mark(o.bitrate_kbps == kbps, &format!("Bitrate: {} Mbps", kbps / 1000)), json!({"bitrate": kbps})));
             }
         }
-        OutputFormat::JpegSequence => {
+        OutputFormat::JpegSequence | OutputFormat::WebM => {
             v.push(("-".into(), Value::Null));
             for q in [60u8, 80, 90, 100] {
                 v.push((mark(o.quality == q, &format!("Quality: {q}")), json!({"quality": q})));

crates/ui-egui/src/panels/timeline.rs

@@ -849,6 +849,31 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     if let Some((a, b)) = run {
         draw_run(a, b);
     }
+    // Disk-cached frames not in RAM (blue), like After Effects.
+    if app.session.disk_cache.is_some() {
+        let frames = comp.frame_rate.frame_at(comp.duration);
+        let opts = app.frame_opts(cid, scale_key as f64 / 1000.0);
+        let disk = app.frames.disk_frames(&app.render_source(), app.session.revision, cid.0, scale_key, app.view_hash(cid), frames, &opts);
+        let draw_blue = |a: i64, b: i64| {
+            let x0 = tm.x(a as f64 * fd);
+            let x1 = tm.x((b + 1) as f64 * fd);
+            p.rect_filled(Rect::from_min_max(pos2(x0, cy0), pos2(x1, cy0 + 2.5)), 0.0, t.cache_blue);
+        };
+        let mut run: Option<(i64, i64)> = None;
+        for f in disk {
+            run = match run {
+                Some((a, b)) if f == b + 1 => Some((a, f)),
+                Some((a, b)) => {
+                    draw_blue(a, b);
+                    Some((f, f))
+                }
+                None => Some((f, f)),
+            };
+        }
+        if let Some((a, b)) = run {
+            draw_blue(a, b);
+        }
+    }
     // Ticks + labels.
     // Label spacing in whole frames (AE: `00:15f`-style seconds:frames labels).
     let fps_i = fr.as_f64().round().max(1.0) as i64;

crates/ui-egui/src/theme.rs

@@ -60,6 +60,8 @@ pub struct Tokens {
     pub cti: Color32,
     pub work_area: Color32,
     pub cache_green: Color32,
+    /// Timeline cache bar for frames held in the disk cache (not in RAM).
+    pub cache_blue: Color32,
     pub keyframe: Color32,
     pub keyframe_selected: Color32,
     pub pasteboard: Color32,
@@ -108,6 +110,7 @@ impl Tokens {
             cti: Color32::from_rgb(0x2d, 0x8c, 0xeb),
             work_area: Color32::from_rgb(0x4a, 0x4a, 0x4a),
             cache_green: Color32::from_rgb(0x3c, 0xa6, 0x4c),
+            cache_blue: Color32::from_rgb(0x3a, 0x6f, 0xd8),
             keyframe: Color32::from_rgb(0xa8, 0xa8, 0xa8),
             keyframe_selected: Color32::from_rgb(0x3d, 0x8f, 0xf5),
             pasteboard: Color32::from_rgb(0x1a, 0x1a, 0x1a),