EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Footage: follow stored footage paths only on this computer or the project's share
aiongg816ca95800c6
diff --git a/Cargo.lock b/Cargo.lockindex 3b70881e7..1ca52ebaf 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -968,6 +968,10 @@ dependencies = ["libc",]+[[package]]+name = "craft-docpath"+version = "0.1.0"+[[package]]name = "craft-pdf"version = "0.1.0"@@ -1245,6 +1249,7 @@ dependencies = [name = "effectcraft-engine"version = "0.10.0"dependencies = [+ "craft-docpath","effectcraft-color","effectcraft-effects","effectcraft-geom",@@ -1418,6 +1423,7 @@ dependencies = [name = "effectcraft-lottie"version = "0.10.0"dependencies = [+ "craft-docpath","effectcraft-color","effectcraft-effects","effectcraft-keyframe",@@ -1435,6 +1441,7 @@ dependencies = [name = "effectcraft-media"version = "0.10.0"dependencies = [+ "craft-docpath","effectcraft-model","effectcraft-pdf","effectcraft-project",diff --git a/Cargo.toml b/Cargo.tomlindex 2eba79883..479421acb 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -12,6 +12,7 @@ repository = "https://github.com/storytold/effectcraft"[workspace.dependencies]craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "ca50d63b773c99f96e75c77ce5a1d21e7c9cda0d", version = "=0.1.0", default-features = false, features = ["read"] }+craft-docpath = { path = "../secfix-craft-libs/crates/docpath" }# internaleffectcraft-time = { path = "crates/time" }effectcraft-geom = { path = "crates/geom" }diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.tomlindex 68e761ab0..0e26cca58 100644--- a/crates/engine/Cargo.toml+++ b/crates/engine/Cargo.toml@@ -10,6 +10,7 @@ rust-version.workspace = trueworkspace = true[dependencies]+craft-docpath = { workspace = true }effectcraft-time = { workspace = true }effectcraft-geom = { workspace = true }effectcraft-color = { workspace = true }diff --git a/crates/engine/src/commands/align_data.rs b/crates/engine/src/commands/align_data.rsindex 1f18de5f2..097bddc22 100644--- a/crates/engine/src/commands/align_data.rs+++ b/crates/engine/src/commands/align_data.rs@@ -182,7 +182,7 @@ fn run(s: &mut Session, p: &Value) -> Result<Value> {let video = match p.get("videoStart").filter(|v| v.as_str() != Some("")) {Some(v) => parse_stamp(v, fps).ok_or_else(|| bad(c, "videoStart: ISO 8601 date-time, hh:mm:ss, timecode or seconds"))?,None => {- let (created, _, _) = crate::media_browser::file_dates(&footage.path);+ let (created, _, _) = if footage.missing { (None, None, None) } else { crate::media_browser::file_dates(&footage.path) };Stamp { secs: created.ok_or_else(|| bad(c, "the footage has no recording time; pass `videoStart`"))? as f64, dated: true }}};diff --git a/crates/engine/src/commands/edit.rs b/crates/engine/src/commands/edit.rsindex 42a2baea1..422728ea3 100644--- a/crates/engine/src/commands/edit.rs+++ b/crates/engine/src/commands/edit.rs@@ -828,7 +828,9 @@ pub(crate) fn openable_original(path: &str) -> std::result::Result<(), String> {}fn edit_original(s: &mut Session, _: &Value) -> Result<Value> {- let path = original_path(s).ok_or_else(|| super::bad("edit.editOriginal", "select a footage item or layer"))?;+ let stored = original_path(s).ok_or_else(|| super::bad("edit.editOriginal", "select a footage item or layer"))?;+ let path = s.stored_path(&stored).map_err(|why| super::bad("edit.editOriginal", crate::doc_path::refusal(&stored, why)))?;+ let path = path.to_string_lossy();openable_original(&path).map_err(|e| super::bad("edit.editOriginal", e))?;let url = super::layer_menu::file_url(&path);s.events.push(crate::Event::OpenUrl(url.clone()));diff --git a/crates/engine/src/commands/file.rs b/crates/engine/src/commands/file.rsindex 501d15482..760c1f223 100644--- a/crates/engine/src/commands/file.rs+++ b/crates/engine/src/commands/file.rs@@ -18,7 +18,10 @@ fn new_project(s: &mut Session, _: &Value) -> Result<Value> {if s.prefs.project.use_template && !tpl.is_empty() {let bytes = s.services.read_file(&tpl).map_err(|e| EngineError::Other(format!("cannot read the new project template {tpl}: {e}")))?;let text = String::from_utf8(bytes).map_err(|_| EngineError::Other("the new project template is not a project file".into()))?;- s.replace_project(Project::from_json(&text)?, None);+ let mut proj = Project::from_json(&text)?;+ crate::doc_path::resolve_footage(&mut proj, Some(&tpl));+ s.replace_project(proj, None);+ s.stored_paths.add(&s.project, Some(&tpl));s.update_sentinel();return Ok(json!({"template": tpl}));}@@ -45,8 +48,12 @@ pub(crate) fn open(s: &mut Session, p: &Value) -> Result<Value> {let text = if crate::xml_project::is_xml(&text) { crate::xml_project::from_xml(&text).map_err(EngineError::Other)? } else { text };let (mut proj, repaired) =Project::from_json_repaired(&text).map_err(|e| EngineError::Other(format!("{path} is not a project EffectCraft can open: {e}")))?;- resolve_relative_footage(&mut proj, path, s.services.as_ref());+ // Footage saved with a relative path (imported by the CLI or an agent as `clip.mp4`, or+ // written by hand) is found next to the project file, as After Effects looks for footage+ // relative to the project (#652).+ let refused = crate::doc_path::resolve_footage(&mut proj, Some(path));s.replace_project(proj, Some(path.to_string()));+ s.stored_paths.add(&s.project, Some(path));s.restore_view(&effectcraft_project::saved_view(&text));s.note_project_path(path);// Values past the limits (a corrupt or hostile file) were brought within them (#788).@@ -56,6 +63,10 @@ pub(crate) fn open(s: &mut Session, p: &Value) -> Result<Value> {let more = if more > 0 { format!(" and {more} more") } else { String::new() };s.toast(format!("This project had values outside EffectCraft's limits, corrected when it opened: {shown}{more}."));}+ if let Some((_, first, why)) = refused.first() {+ let n = refused.len();+ s.toast(format!("{n} footage item{} marked missing: {}.", if n == 1 { "" } else { "s" }, crate::doc_path::refusal(first, *why)));+ }// Written by a newer EffectCraft: what this version doesn't know would be lost on saving.let saved_by = effectcraft_project::saved_by(&text);if let Some(v) = saved_by.as_deref().filter(|v| effectcraft_project::is_newer_version(v, effectcraft_project::APP_VERSION)) {@@ -72,28 +83,6 @@ pub(crate) fn open(s: &mut Session, p: &Value) -> Result<Value> {Ok(json!({"path": path, "savedBy": saved_by, "repaired": repaired}))}-/// Footage saved with a relative path (imported by the CLI or an agent as `clip.mp4`, or written-/// by hand) is found next to the project file, as After Effects looks for footage relative to-/// the project. It used to be looked up from the working directory: the CLI started in the-/// project's folder found it, the desktop app (started from the Finder, Explorer or a launcher,-/// in another folder) showed and rendered nothing (#652). A path that exists from the working-/// directory is kept.-fn resolve_relative_footage(p: &mut Project, project_path: &str, services: &dyn crate::Services) {- use std::path::Path;- let Some(dir) = Path::new(project_path).parent().filter(|d| !d.as_os_str().is_empty()) else { return };- let beside = |f: &str| dir.join(f).to_string_lossy().to_string();- for item in p.items.values_mut() {- let ItemKind::Footage(f) = &mut item.kind else { continue };- if f.path.is_empty() || !Path::new(&f.path).is_relative() || services.exists(&f.path) || !services.exists(&beside(&f.path)) {- continue;- }- f.path = beside(&f.path);- for frame in f.sequence.iter_mut().filter(|q| Path::new(q.as_str()).is_relative()) {- *frame = beside(frame);- }- }-}-/// The project file's text for `path`: `.ecproj` JSON, or XML for `.ecprojx` / `.xml` (a/// project opened from an XML copy saves as XML again). Fails, writing nothing, when the project/// wouldn't read back.@@ -459,6 +448,7 @@ fn add_footage(s: &mut Session, pending: PendingImport, probed: Vec<std::result:// media layer keys frames by path): a fresh import reads it again (#1070).for f in &found {s.forget_decoded(&f.footage);+ s.stored_paths.allow(&f.footage);}s.edit("Import", None, |proj, st| {let mut selection = made;diff --git a/crates/engine/src/commands/file_more.rs b/crates/engine/src/commands/file_more.rsindex 346f8392a..74a86e1d8 100644--- a/crates/engine/src/commands/file_more.rs+++ b/crates/engine/src/commands/file_more.rs@@ -855,12 +855,15 @@ fn replace_footage(s: &mut Session, p: &Value) -> Result<Value> {// Replacing a missing file relinks the other missing files that moved with it (as After Effects// does when you locate one).let moved = match s.project.item(item).map(|it| &it.kind) {- Some(ItemKind::Footage(previous)) if previous.missing || !s.services.exists(&previous.path) => {+ Some(ItemKind::Footage(previous)) if previous.missing || !s.stored_paths.exists(s.services.as_ref(), &previous.path) => {super::relink_moved::moved_with(s, item, &previous.path, &path)}_ => vec![],};let relinked: Vec<u64> = moved.iter().map(|(id, _)| id.0).collect();+ for nf in std::iter::once(&f).chain(moved.iter().map(|(_, nf)| nf)) {+ s.stored_paths.allow(nf);+ }s.edit("Replace Footage", None, |proj, _| {let it = proj.item_mut(item).ok_or_else(|| bad("file.replaceFootage", "no such item"))?;it.name = name;@@ -946,7 +949,7 @@ fn reveal_in_finder(s: &mut Session, p: &Value) -> Result<Value> {Some(ItemKind::Footage(f)) if !f.path.is_empty() => f.path.clone(),_ => return Err(bad("file.revealInFinder", "the item is not a file")),};- let url = super::layer_menu::folder_url(&path);+ let url = super::layer_menu::reveal_url(s, &path).map_err(|e| bad("file.revealInFinder", e))?;s.events.push(crate::Event::OpenUrl(url.clone()));Ok(json!({"url": url}))}diff --git a/crates/engine/src/commands/import_project.rs b/crates/engine/src/commands/import_project.rsindex f0474ee82..af37771a8 100644--- a/crates/engine/src/commands/import_project.rs+++ b/crates/engine/src/commands/import_project.rs@@ -27,40 +27,24 @@ fn read_project(s: &Session, path: &str) -> Result<(Project, Option<String>)> {Ok((project, effectcraft_project::saved_by(&text)))}-/// Footage paths relative to the imported project's folder become absolute when the file is-/// there; returns the footage paths that are missing.-fn resolve_footage(s: &Session, project: &mut Project, dir: &std::path::Path) -> Vec<String> {+/// Footage paths stored in the imported project are resolved against its file+/// ([`crate::doc_path::resolve_footage`]): relative ones become paths beside it, and items whose+/// path is not followed are marked missing. Returns the footage paths that are missing, as stored.+fn resolve_footage(s: &Session, project: &mut Project, path: &str) -> Vec<String> {+ let stored: std::collections::HashMap<ItemId, String> =+ project.items.values().filter_map(|i| if let ItemKind::Footage(f) = &i.kind { Some((i.id, f.path.clone())) } else { None }).collect();+ let refused = crate::doc_path::resolve_footage(project, Some(path));let services = s.services.clone();- let resolve = |raw: &mut String| -> bool {- if raw.is_empty() || services.exists(raw) {- return true;- }- if std::path::Path::new(raw.as_str()).is_absolute() {- return false;- }- let joined = dir.join(raw.as_str()).to_string_lossy().to_string();- if services.exists(&joined) {- *raw = joined;- true- } else {- false- }- };- let mut missing = vec![];- for it in project.items.values_mut() {- if let ItemKind::Footage(f) = &mut it.kind {- if f.sequence.is_empty() {- if !resolve(&mut f.path) {- missing.push(f.path.clone());- }- } else {- let mut all = true;- for frame in &mut f.sequence {- all &= resolve(frame);- }- if !all {- missing.push(f.path.clone());- }+ let exists = |p: &String| p.is_empty() || services.exists(p);+ let mut missing: Vec<String> = refused.iter().map(|(_, p, _)| p.clone()).collect();+ for it in project.items.values() {+ if let ItemKind::Footage(f) = &it.kind {+ if refused.iter().any(|(id, _, _)| *id == it.id) {+ continue;+ }+ let present = if f.sequence.is_empty() { exists(&f.path) } else { f.sequence.iter().all(exists) };+ if !present {+ missing.push(stored.get(&it.id).cloned().unwrap_or_else(|| f.path.clone()));}}}@@ -79,8 +63,8 @@ fn import_project(s: &mut Session, p: &Value) -> Result<Value> {let (mut sub, saved_by) = read_project(s, &path)?;crate::upgrade_effects(&mut sub);let file = std::path::Path::new(&path);- let dir = file.parent().map(|d| d.to_path_buf()).unwrap_or_default();- let missing = resolve_footage(s, &mut sub, &dir);+ let missing = resolve_footage(s, &mut sub, &path);+ s.stored_paths.add(&sub, Some(&path));// The imported project's own render queue stays behind (as for templates).let base = s.project.next_id;if sub.next_id.checked_add(base).is_none() {diff --git a/crates/engine/src/commands/layer_menu.rs b/crates/engine/src/commands/layer_menu.rsindex 83a1510ac..9cac80412 100644--- a/crates/engine/src/commands/layer_menu.rs+++ b/crates/engine/src/commands/layer_menu.rs@@ -677,6 +677,54 @@ pub(crate) fn folder_url(path: &str) -> String {file_url(&dir)}+/// Extensions of folders that macOS opens as an app, plug-in or other bundle rather than showing+/// their contents.+const BUNDLE_EXTENSIONS: &[&str] = &[+ "app",+ "appex",+ "bundle",+ "component",+ "dext",+ "driver",+ "framework",+ "kext",+ "mdimporter",+ "mpkg",+ "osax",+ "pkg",+ "plugin",+ "prefpane",+ "qlgenerator",+ "saver",+ "service",+ "systemextension",+ "vst",+ "vst3",+ "wdgt",+ "workflow",+ "xpc",+];++/// Whether the system file manager would open folder `dir` as something other than a folder: a+/// bundle (`Tool.app`), or a Windows folder with a `{CLSID}` extension.+fn opens_as_bundle(dir: &std::path::Path) -> bool {+ let ext = dir.extension().and_then(|e| e.to_str()).unwrap_or_default().to_ascii_lowercase();+ ext.starts_with('{') || BUNDLE_EXTENSIONS.contains(&ext.as_str())+}++/// The folder of the footage file `stored` (a path stored in the project) as a `file://` URL for+/// Reveal in Finder. A path that is not followed ([`crate::doc_path`]), or a folder that is not a+/// plain folder after following links, is refused.+pub(crate) fn reveal_url(s: &Session, stored: &str) -> std::result::Result<String, String> {+ let path = s.stored_path(stored).map_err(|why| crate::doc_path::refusal(stored, why))?;+ let dir = path.parent().filter(|d| !d.as_os_str().is_empty()).ok_or_else(|| format!("{stored} is not in a folder"))?;+ let real = std::fs::canonicalize(dir).map_err(|e| format!("cannot show the folder of {stored}: {e}"))?;+ if !real.is_dir() || opens_as_bundle(dir) || opens_as_bundle(&real) {+ return Err(format!("the folder of {stored} is not a plain folder"));+ }+ Ok(file_url(&dir.to_string_lossy()))+}+/// `path` as a `file://` URL: backslashes become `/`, a Windows drive path gets the third slash/// (`file:///C:/…`), and every byte that isn't a plain path character is percent-encoded (spaces,/// `#`, `%`, `?`, non-ASCII as UTF-8), so the URL names exactly this file.@@ -700,7 +748,7 @@ fn reveal_in_finder(s: &mut Session, p: &Value) -> Result<Value> {Some(effectcraft_project::ItemKind::Footage(f)) if !f.path.is_empty() => f.path.clone(),_ => return Err(bad("layer.revealInFinder", "the layer's source is not a file")),};- let url = folder_url(&path);+ let url = reveal_url(s, &path).map_err(|e| bad("layer.revealInFinder", e))?;s.events.push(crate::Event::OpenUrl(url.clone()));Ok(json!({"url": url}))}@@ -892,4 +940,27 @@ mod tests {fn folder_url_names_the_containing_folder() {assert_eq!(folder_url("/media/My Clips/a.mov"), "file:///media/My%20Clips");}++ /// Reveal in Finder shows plain folders only: a bundle the system would open as an app, or a+ /// link to one, is refused.+ #[test]+ fn reveal_refuses_folders_that_open_as_apps() {+ let d = std::env::temp_dir().join(format!("ec-reveal-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&d);+ for f in ["Clips", "Tool.app", "Shell.{20D04FE0-3AEA-1069-A2D8-08002B30309D}"] {+ std::fs::create_dir_all(d.join(f)).unwrap();+ }+ let s = crate::Session::default();+ let reveal = |folder: &str| super::reveal_url(&s, &d.join(folder).join("a.mov").to_string_lossy());+ assert_eq!(reveal("Clips"), Ok(super::file_url(&d.join("Clips").to_string_lossy())));+ assert!(reveal("Tool.app").is_err());+ assert!(reveal("Shell.{20D04FE0-3AEA-1069-A2D8-08002B30309D}").is_err());+ assert!(reveal("Gone").is_err());+ #[cfg(unix)]+ {+ std::os::unix::fs::symlink(d.join("Tool.app"), d.join("Footage")).unwrap();+ assert!(reveal("Footage").is_err(), "a link to a bundle");+ }+ let _ = std::fs::remove_dir_all(&d);+ }}diff --git a/crates/engine/src/commands/relink.rs b/crates/engine/src/commands/relink.rsindex 1c095ddac..2d7c2ea13 100644--- a/crates/engine/src/commands/relink.rs+++ b/crates/engine/src/commands/relink.rs@@ -81,12 +81,13 @@ fn run(s: &mut Session, p: &Value) -> Result<Value> {}let importer = s.importer.clone().ok_or_else(|| bad(COMMAND, "media import is not available in this build"))?;let services = s.services.clone();+ let stored = s.stored_paths.clone();let missing: Vec<(ItemId, Footage)> = s.project.items.values().filter_map(|item| match &item.kind {- ItemKind::Footage(f) if !f.path.is_empty() && !services.exists(&f.path) => Some((item.id, f.clone())),+ ItemKind::Footage(f) if !f.path.is_empty() && !stored.exists(services.as_ref(), &f.path) => Some((item.id, f.clone())),_ => None,}).collect();@@ -149,7 +150,8 @@ fn run(s: &mut Session, p: &Value) -> Result<Value> {// A background search must not overwrite edits made while it was running.for (id, old, new) in &updates {if s.project.item(*id).is_none_or(|i| !matches!(&i.kind, ItemKind::Footage(f) if f == old))- || services.exists(&old.path) || !services.exists(&new.path)+ || stored.exists(services.as_ref(), &old.path)+ || !services.exists(&new.path)|| (new.kind == FootageKind::Sequence && new.sequence.iter().any(|p| !services.exists(p))){return Err(bad(COMMAND, "footage changed during search; run the search again"));@@ -157,6 +159,9 @@ fn run(s: &mut Session, p: &Value) -> Result<Value> {}let matched = updates.len();if !dry_run && !updates.is_empty() {+ for (_, _, new) in &updates {+ s.stored_paths.allow(new);+ }s.edit("Relink Missing Footage", None, |project, _| {for (id, _, new) in updates {if let Some(item) = project.item_mut(id) {diff --git a/crates/engine/src/commands/relink_moved.rs b/crates/engine/src/commands/relink_moved.rsindex ef64a4235..ecc531bc2 100644--- a/crates/engine/src/commands/relink_moved.rs+++ b/crates/engine/src/commands/relink_moved.rs@@ -91,8 +91,8 @@ fn moved_footage(footage: &Footage, f: impl Fn(&str) -> Option<String>) -> OptioSome(nf)}-fn present(s: &dyn Services, f: &Footage) -> bool {- !f.path.is_empty() && s.exists(&f.path)+fn present(s: &dyn Services, stored: &crate::doc_path::StoredPaths, f: &Footage) -> bool {+ stored.exists(s, &f.path)}/// Footage items whose file is gone (flagged by the footage check, or not there now).@@ -101,7 +101,7 @@ fn missing_items(s: &Session) -> Vec<(ItemId, Footage)> {.items.values().filter_map(|i| match &i.kind {- ItemKind::Footage(f) if f.kind != FootageKind::Data && !f.path.is_empty() && (f.missing || !present(s.services.as_ref(), f)) => {+ ItemKind::Footage(f) if f.kind != FootageKind::Data && !f.path.is_empty() && (f.missing || !present(s.services.as_ref(), &s.stored_paths, f)) => {Some((i.id, f.clone()))}_ => None,@@ -146,6 +146,9 @@ fn apply(s: &mut Session, label: &str, found: Vec<(ItemId, Footage)>) -> Result<return Ok(json!({"relinked": [], "stillMissing": missing_items(s).len()}));}let ids: Vec<u64> = found.iter().map(|(id, _)| id.0).collect();+ for (_, nf) in &found {+ s.stored_paths.allow(nf);+ }s.edit(label, None, |proj: &mut Project, _| {for (id, nf) in found {if let Some(it) = proj.item_mut(id) {@@ -175,7 +178,7 @@ pub(crate) fn moved_with(s: &Session, item: ItemId, old_path: &str, new_path: &sif id == item {continue;}- let same_place = moved_footage(&f, |q| remap(q, &old_root, &new_root)).filter(|nf| present(services.as_ref(), nf));+ let same_place = moved_footage(&f, |q| remap(q, &old_root, &new_root)).filter(|nf| present(services.as_ref(), &s.stored_paths, nf));let same_folder = || {let dir = new_dir.as_deref()?;let dir_parts = parts(dir);@@ -183,7 +186,7 @@ pub(crate) fn moved_with(s: &Session, item: ItemId, old_path: &str, new_path: &slet old_dir: Vec<&str> = parts(&f.path).get(..old_dir_len)?.to_vec();moved_footage(&f, |q| remap(q, &old_dir, dir).or_else(|| Some(join(dir, &[file_name(q)])))).filter(|nf| {// Only frames in that one folder (a name match, not a guess deeper down).- present(services.as_ref(), nf) && parts(&nf.path).len() == dir_parts.len() + 1+ present(services.as_ref(), &s.stored_paths, nf) && parts(&nf.path).len() == dir_parts.len() + 1})};if let Some(nf) = same_place.or_else(same_folder) {diff --git a/crates/engine/src/doc_path.rs b/crates/engine/src/doc_path.rsnew file mode 100644index 000000000..c7416a8ce--- /dev/null+++ b/crates/engine/src/doc_path.rs@@ -0,0 +1,158 @@+//! Footage paths stored in a document (the project file, an imported project, the New Project+//! template) reach the file system only through [`resolve`]: a relative path is taken from the+//! document's folder, and only local files, or files on the network share the document itself is+//! on, are followed (see `craft_docpath`).+//!+//! Loading a document resolves its footage paths once ([`resolve_footage`]): followed paths are+//! replaced by the resolved path, and an item with a refused path is marked missing, so the media+//! layer never reads it. The session then remembers which paths came from which document+//! ([`StoredPaths`]); the footage check, the changed-on-disk scan, Reload Footage, Relink, Edit+//! Original and Reveal in Finder follow a path only through it. Paths the user imports or relinks+//! in this session are followed as given.++use std::collections::HashMap;+use std::fmt;+use std::path::{Path, PathBuf};+use std::sync::Arc;++pub use craft_docpath::Refused;+use effectcraft_project::{Footage, ItemId, ItemKind, Project};++/// Why a stored path is not followed.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum NotFollowed {+ /// The path is not a local file, or is not on the project's own share.+ Refused(Refused),+ /// The path is relative and the project has no folder to take it from.+ NoProjectFolder,+}++impl fmt::Display for NotFollowed {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ match self {+ Self::Refused(r) => r.fmt(f),+ Self::NoProjectFolder => f.write_str("the path is relative and the project has not been saved"),+ }+ }+}++impl std::error::Error for NotFollowed {}++/// The file to open for `stored`, a footage path or `file:` URL stored in the project saved at+/// `project` (`None` for a project without a file), or why it is not followed. A relative+/// `project` is taken from the working directory, where it was opened from.+pub fn resolve(stored: &str, project: Option<&str>) -> Result<PathBuf, NotFollowed> {+ let project = project.filter(|p| !p.is_empty()).map(|p| {+ let p = Path::new(p);+ std::path::absolute(p).unwrap_or_else(|_| p.to_path_buf())+ });+ let path = craft_docpath::resolve(stored, project.as_deref()).map_err(NotFollowed::Refused)?;+ // A path that is still relative would be taken from the working directory, which the+ // project does not choose.+ if path.is_relative() {+ return Err(NotFollowed::NoProjectFolder);+ }+ Ok(path)+}++/// The paths of `f` (its file and every frame of an image sequence) resolved against the document+/// saved at `document`, or why one of them is not followed.+fn footage_paths(f: &Footage, document: Option<&str>) -> Result<(String, Vec<String>), (String, NotFollowed)> {+ let one = |q: &String| -> Result<String, (String, NotFollowed)> {+ if q.is_empty() {+ return Ok(String::new());+ }+ resolve(q, document).map(|p| p.to_string_lossy().into_owned()).map_err(|why| (q.clone(), why))+ };+ Ok((one(&f.path)?, f.sequence.iter().map(one).collect::<Result<_, _>>()?))+}++fn paths_of(f: &Footage) -> impl Iterator<Item = &String> {+ std::iter::once(&f.path).chain(&f.sequence).filter(|q| !q.is_empty())+}++/// Footage paths that came from a document, with the path of that document (`None`: one without+/// a file). Any other path was chosen in this session and is followed as given.+#[derive(Clone, Debug, Default)]+pub struct StoredPaths(Arc<HashMap<String, Option<String>>>);++impl StoredPaths {+ /// Record the footage paths of `p`, loaded from the document at `document`. A path already+ /// recorded keeps the document it came from first.+ pub(crate) fn add(&mut self, p: &Project, document: Option<&str>) {+ let map = Arc::make_mut(&mut self.0);+ for item in p.items.values() {+ if let ItemKind::Footage(f) = &item.kind {+ for q in paths_of(f) {+ map.entry(q.clone()).or_insert_with(|| document.map(str::to_string));+ }+ }+ }+ }++ /// The user chose the files of `f` in this session (import, relink, Replace Footage): follow+ /// them as given from now on.+ pub(crate) fn allow(&mut self, f: &Footage) {+ if paths_of(f).any(|q| self.0.contains_key(q)) {+ let map = Arc::make_mut(&mut self.0);+ for q in paths_of(f) {+ map.remove(q);+ }+ }+ }++ /// The file to open for footage path `path`.+ pub fn follow(&self, path: &str) -> Result<PathBuf, NotFollowed> {+ match self.0.get(path) {+ Some(document) => resolve(path, document.as_deref()),+ None => Ok(PathBuf::from(path)),+ }+ }++ /// Whether the file at footage path `path` exists. A path that is not followed is not looked+ /// for.+ pub(crate) fn exists(&self, services: &dyn crate::Services, path: &str) -> bool {+ !path.is_empty() && self.follow(path).is_ok_and(|p| p.to_str().is_some_and(|p| services.exists(p)))+ }++ /// Whether every file of `f` is followed, or the first that is not and why.+ pub(crate) fn check(&self, f: &Footage) -> Result<(), (String, NotFollowed)> {+ paths_of(f).try_for_each(|q| self.follow(q).map(|_| ()).map_err(|why| (q.clone(), why)))+ }+}++/// Resolve the footage paths stored in `p`, the project saved at `project`: followed paths are+/// replaced by the file they resolve to, and an item with a path that is not followed is marked+/// missing. Returns those items with the refused path and why.+pub(crate) fn resolve_footage(p: &mut Project, project: Option<&str>) -> Vec<(ItemId, String, NotFollowed)> {+ let mut refused = vec![];+ for item in p.items.values_mut() {+ let ItemKind::Footage(f) = &mut item.kind else { continue };+ match footage_paths(f, project) {+ Ok((path, sequence)) => {+ f.path = path;+ f.sequence = sequence;+ }+ Err((path, why)) => {+ f.missing = true;+ refused.push((item.id, path, why));+ }+ }+ }+ refused+}++/// The message for footage whose stored path is not followed.+pub(crate) fn refusal(stored: &str, why: NotFollowed) -> String {+ format!("the footage file {stored} is not opened: {why}")+}++impl crate::Session {+ /// The file to open for footage path `stored` in this session's project.+ pub fn stored_path(&self, stored: &str) -> Result<PathBuf, NotFollowed> {+ self.stored_paths.follow(stored)+ }+}++#[cfg(test)]+mod tests;diff --git a/crates/engine/src/doc_path/tests.rs b/crates/engine/src/doc_path/tests.rsnew file mode 100644index 000000000..b8dcbc190--- /dev/null+++ b/crates/engine/src/doc_path/tests.rs@@ -0,0 +1,153 @@+use std::sync::{Arc, Mutex};++use effectcraft_project::{Footage, ItemId, ItemKind};+use serde_json::json;++use crate::{Event, Services, Session};++/// File access that records every path it is asked about.+#[derive(Default)]+struct Recording(Mutex<Vec<String>>);++impl Recording {+ fn note(&self, path: &str) {+ self.0.lock().unwrap().push(path.to_string());+ }+}++impl Services for Recording {+ fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {+ self.note(path);+ std::fs::read(path)+ }+ fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {+ std::fs::write(path, data)+ }+ fn exists(&self, path: &str) -> bool {+ self.note(path);+ std::path::Path::new(path).exists()+ }+ fn stamp(&self, path: &str) -> Option<(u64, u128)> {+ self.note(path);+ let meta = std::fs::metadata(path).ok()?;+ Some((meta.len(), meta.modified().ok()?.duration_since(std::time::UNIX_EPOCH).ok()?.as_nanos()))+ }+}++/// Probes every file as a still.+struct Stills;++impl crate::Importer for Stills {+ fn probe(&self, path: &str) -> Result<Footage, String> {+ if !std::path::Path::new(path).is_file() {+ return Err(format!("{path}: no such file"));+ }+ Ok(Footage { path: path.into(), kind: effectcraft_project::FootageKind::Still, width: 64, height: 32, has_video: true, ..Default::default() })+ }+}++fn footage_id(s: &Session, name: &str) -> ItemId {+ s.project.items.values().find(|i| i.name == name).unwrap().id+}++fn footage<'a>(s: &'a Session, name: &str) -> &'a Footage {+ match &s.project.item(footage_id(s, name)).unwrap().kind {+ ItemKind::Footage(f) => f,+ _ => panic!("{name} is not footage"),+ }+}++/// Footage paths to other computers stored in a project are never looked at: not on open, by+/// the footage check, by the changed-on-disk scan, by Edit Original or by Reveal in Finder. A+/// relative path is taken from the project's folder, and a file the user imports in this session+/// is used as given until the project is saved and opened again.+#[test]+fn footage_on_other_computers_is_never_looked_at() {+ let root = std::env::temp_dir().join(format!("ec-doc-path-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&root);+ let dir = root.join("job");+ std::fs::create_dir_all(&dir).unwrap();+ std::fs::create_dir_all(root.join("media")).unwrap();+ std::fs::write(dir.join("clip.png"), b"x").unwrap();+ std::fs::write(root.join("media").join("far.png"), b"x").unwrap();+ let mut stored = vec![("unc", r"\\192.0.2.1\share\x.png".to_string()), ("url", "file://192.0.2.1/s/x.png".to_string()), ("beside", "clip.png".to_string())];+ // Linux reads `//tmp/…/far.png` as the local file: a sink that skipped the check would find it.+ if cfg!(unix) {+ stored.push(("slashes", format!("/{}", root.join("media").join("far.png").display())));+ }+ let mut s = Session::default();+ for (name, path) in &stored {+ let f = Footage { path: path.clone(), width: 64, height: 48, has_video: true, ..Default::default() };+ Arc::make_mut(&mut s.project).add_item(name, crate::color::Label::None, None, ItemKind::Footage(f));+ }+ let project = dir.join("p.ecproj");+ s.execute("file.saveAs", json!({"path": project.to_string_lossy()})).unwrap();++ let rec = Arc::new(Recording::default());+ let mut o = Session { services: rec.clone(), ..Default::default() };+ o.execute("file.open", json!({"path": project.to_string_lossy()})).unwrap();+ for (name, _) in &stored {+ assert_eq!(footage(&o, name).missing, *name != "beside", "{name}");+ }+ assert_eq!(std::path::Path::new(&footage(&o, "beside").path), dir.join("clip.png"));+ let r = o.execute("footage.check", json!({"wait": true})).unwrap();+ assert_eq!(r["missing"].as_u64(), Some(stored.len() as u64 - 1), "{r}");+ o.execute("footage.reloadChanged", json!({})).unwrap();+ o.drain_events();+ for (name, _) in &stored {+ o.state.project_selection = vec![footage_id(&o, name)];+ let opened = o.execute("edit.editOriginal", json!({}));+ let revealed = o.execute("file.revealInFinder", json!({}));+ assert_eq!((opened.is_ok(), revealed.is_ok()), (*name == "beside", *name == "beside"), "{name}: {opened:?} {revealed:?}");+ }+ let urls: Vec<String> = o.drain_events().into_iter().filter_map(|e| if let Event::OpenUrl(u) = e { Some(u) } else { None }).collect();+ assert_eq!(urls.len(), 2, "{urls:?}");++ let seen = rec.0.lock().unwrap().clone();+ assert!(seen.iter().any(|p| std::path::Path::new(p) == dir.join("clip.png")), "{seen:?}");+ // Only files in the temporary folder (the project's folder, where moved footage is looked for).+ let local = root.to_string_lossy().into_owned();+ for p in &seen {+ assert!(p.starts_with(&local), "looked at {p}");+ }++ // Chosen in this session, the same file is followed as given (as a file on a NAS would be)…+ #[cfg(unix)]+ {+ let far = stored.iter().find(|(n, _)| *n == "slashes").unwrap().1.clone();+ o.importer = Some(Arc::new(Stills));+ o.execute("file.import", json!({"paths": [far.clone()]})).unwrap();+ let imported = |s: &Session| -> Vec<ItemId> {+ s.project.items.values().filter(|i| matches!(&i.kind, ItemKind::Footage(f) if f.path == far)).map(|i| i.id).collect()+ };+ let id = *imported(&o).iter().find(|id| matches!(&o.project.item(**id).unwrap().kind, ItemKind::Footage(f) if !f.missing)).unwrap();+ o.state.project_selection = vec![id];+ o.execute("edit.editOriginal", json!({})).unwrap();+ o.execute("file.revealInFinder", json!({})).unwrap();+ assert!(o.execute("footage.check", json!({"wait": true, "items": [id.0]})).unwrap()["missing"] == 0);+ // …and is a stored path again once the project is saved and opened.+ o.execute("file.save", json!({})).unwrap();+ let mut q = Session::default();+ q.execute("file.open", json!({"path": project.to_string_lossy()})).unwrap();+ let ids = imported(&q);+ assert_eq!(ids.len(), 2);+ for id in ids {+ assert!(matches!(&q.project.item(id).unwrap().kind, ItemKind::Footage(f) if f.missing));+ q.state.project_selection = vec![id];+ assert!(q.execute("edit.editOriginal", json!({})).is_err());+ assert!(q.execute("file.revealInFinder", json!({})).is_err());+ }+ }+ let _ = std::fs::remove_dir_all(&root);+}++#[test]+fn stored_paths_resolve_against_the_project() {+ let doc = std::env::temp_dir().join("art").join("intro.ecproj");+ let doc = doc.to_str().unwrap();+ assert_eq!(super::resolve("clip.mov", Some(doc)), Ok(std::env::temp_dir().join("art").join("clip.mov")));+ assert_eq!(super::resolve("clip.mov", None), Err(super::NotFollowed::NoProjectFolder));+ assert_eq!(super::resolve(r"\\192.0.2.1\share\x.mov", Some(doc)), Err(super::NotFollowed::Refused(super::Refused::Network)));+ #[cfg(windows)]+ assert!(super::resolve(r"\\server\share\x.mov", Some(r"\\SERVER\share\job\intro.ecproj")).is_ok());+}diff --git a/crates/engine/src/footage_check.rs b/crates/engine/src/footage_check.rsindex adfb17683..6bb803f0d 100644--- a/crates/engine/src/footage_check.rs+++ b/crates/engine/src/footage_check.rs@@ -31,10 +31,6 @@ enum Found {Moved(Box<Footage>),}-fn exists(s: &dyn crate::Services, path: &str) -> bool {- !path.is_empty() && s.exists(path)-}-/// Start the check (all footage, or `items`). `wait` runs it to completion first (always on/// wasm32); the result is then `{checked, missing, probed}`.pub fn start(s: &mut Session, items: Option<Vec<ItemId>>, wait: bool) -> crate::Result<Value> {@@ -54,6 +50,7 @@ pub fn start(s: &mut Session, items: Option<Vec<ItemId>>, wait: bool) -> crate::let services = s.services.clone();let importer = s.importer.clone();let rate = s.sequence_rate();+ let stored = s.stored_paths.clone();let project_dir = s.path.as_deref().and_then(crate::commands::relink_moved::project_dir);let n = jobs.len();s.spawn_task("footageCheck", format!("Checking footage ({n} items)"), wait, move |ctl| {@@ -64,13 +61,17 @@ pub fn start(s: &mut Session, items: Option<Vec<ItemId>>, wait: bool) -> crate::return Err(crate::render_queue::CANCELLED.into());}let f = &j.footage;- let present = if f.sequence.is_empty() {- exists(services.as_ref(), &f.path)- } else {- // A sequence is there while any of its frames is (missing frames render as- // placeholders, as in After Effects).- exists(services.as_ref(), &f.path) || f.sequence.iter().any(|p| exists(services.as_ref(), p))- };+ // A path that is not followed is never looked for (the item stays missing).+ let followed = stored.check(f).is_ok();+ let exists = |p: &str| stored.exists(services.as_ref(), p);+ let present = followed+ && if f.sequence.is_empty() {+ exists(&f.path)+ } else {+ // A sequence is there while any of its frames is (missing frames render as+ // placeholders, as in After Effects).+ exists(&f.path) || f.sequence.iter().any(|p| exists(p))+ };// Moved with the project: the same place under the project's folder.if !present&& let Some(dir) = &project_dir@@ -233,9 +234,10 @@ mod tests {let mut paths: Vec<String> =o.project.items.values().filter_map(|i| if let ItemKind::Footage(f) = &i.kind { Some(f.path.clone()) } else { None }).collect();paths.sort();- // Windows joins the stored "media/..." onto the project's folder and leaves a path with mixed- // separators; `Path` equality compares components, so both spellings are the same file.- let mut expected = ["/nonexistent/ec/abs.png", clip.to_str().unwrap(), "media/ec-relative-gone.png"];+ // `Path` equality compares components, so `/` and `\` spell the same file on Windows.+ let abs = crate::doc_path::resolve("/nonexistent/ec/abs.png", path.to_str()).unwrap();+ let gone = dir.join("media").join("ec-relative-gone.png");+ let mut expected = [abs.to_str().unwrap(), clip.to_str().unwrap(), gone.to_str().unwrap()];expected.sort();assert_eq!(paths.len(), expected.len(), "{paths:?}");for (got, want) in paths.iter().zip(expected) {diff --git a/crates/engine/src/footage_reload.rs b/crates/engine/src/footage_reload.rsindex ca51069a4..fa12b27aa 100644--- a/crates/engine/src/footage_reload.rs+++ b/crates/engine/src/footage_reload.rs@@ -32,12 +32,13 @@ pub type Scan = Arc<Mutex<Option<Vec<(String, Option<Stamp>)>>>>;/// The files footage items read: each item's file and every frame of an image sequence. Image/// sequences count only with Automatically Reload Footage set to All Footage (After Effects'/// default, Non-Sequence Footage, leaves them alone: thousands of frames on a share add up).+/// Items with a stored path that is not followed ([`crate::doc_path`]) are not watched.fn watched(s: &Session) -> BTreeSet<String> {let sequences = s.prefs.import.auto_reload_footage == "all";let mut paths = BTreeSet::new();for it in s.project.items.values() {if let ItemKind::Footage(f) = &it.kind {- if !f.sequence.is_empty() && !sequences {+ if (!f.sequence.is_empty() && !sequences) || s.stored_paths.check(f).is_err() {continue;}if !f.path.is_empty() {@@ -136,8 +137,10 @@ fn reload(s: &mut Session, ids: &[ItemId], undoable: bool) -> crate::Result<(usilet mut failed = BTreeSet::new();for i in ids {if let Some(ItemKind::Footage(f)) = s.project.item(*i).map(|x| &x.kind) {- // Probed the way it imports by default, so a sequence is found as one.- let nf = match s.probe_footage(&f.path) {+ // Probed the way it imports by default, so a sequence is found as one. A path that+ // is not followed is not read.+ let probed = s.stored_paths.check(f).map_err(|(p, why)| crate::doc_path::refusal(&p, why)).and_then(|_| s.probe_footage(&f.path));+ let nf = match probed {Ok(p) => refreshed(s, f, p),Err(_) if undoable => Footage { missing: true, ..f.clone() },Err(_) => {diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 96e09b57a..a5b016b74 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -15,6 +15,7 @@ pub mod camera_track;pub mod commands;pub mod config;pub mod demo;+pub mod doc_path;pub mod footage_check;pub mod footage_reload;pub mod guard;@@ -508,6 +509,8 @@ pub struct Session {/// event loop (the desktop app) turn this on; headless sessions run `footage.check` when/// they want it.pub check_footage_on_open: bool,+ /// Footage paths that came from a document, with that document ([`doc_path`]).+ pub stored_paths: doc_path::StoredPaths,/// Each footage file's size and modification time when last seen (Settings ▸ Import ▸/// Reload Footage Changed on Disk, [`footage_reload`]).pub footage_stamps: std::collections::HashMap<String, footage_reload::Stamp>,@@ -608,6 +611,7 @@ impl Default for Session {next_task_id: 1,learn: None,check_footage_on_open: false,+ stored_paths: Default::default(),footage_stamps: Default::default(),footage_scan: None,script_calls: ScriptCalls::default(),@@ -1128,6 +1132,7 @@ impl Session {job.wait();}self.render_job = None;+ self.stored_paths = Default::default();self.stop_track();self.track_job = None;self.stop_mask_track();diff --git a/crates/engine/src/media_browser.rs b/crates/engine/src/media_browser.rsindex b394ad937..d22875f17 100644--- a/crates/engine/src/media_browser.rs+++ b/crates/engine/src/media_browser.rs@@ -306,7 +306,7 @@ fn kind_name(k: FootageKind) -> &'static str {/// Metadata of footage (the fields the Metadata panel lists).pub fn footage_metadata(f: &Footage) -> Value {- let (created, modified, size) = file_dates(f.sequence.first().map(String::as_str).unwrap_or(&f.path));+ let (created, modified, size) = if f.missing { (None, None, None) } else { file_dates(f.sequence.first().map(String::as_str).unwrap_or(&f.path)) };json!({"path": f.path,"kind": kind_name(f.kind),diff --git a/crates/engine/src/offload.rs b/crates/engine/src/offload.rsindex bd1fec8a3..ad2c0cde0 100644--- a/crates/engine/src/offload.rs+++ b/crates/engine/src/offload.rs@@ -310,13 +310,15 @@ pub fn next_id() -> u64 {NEXT_ID.fetch_add(1, Ordering::Relaxed)}-/// Footage files a project reads (paths, sequence frames).+/// Footage files a project reads (paths, sequence frames; missing items read none).pub fn footage_files(p: &Project) -> Vec<String> {let mut v: Vec<String> = p.items.values().filter_map(|i| match &i.kind {- ItemKind::Footage(f) if !f.path.is_empty() => Some(std::iter::once(f.path.clone()).chain(f.sequence.iter().cloned()).collect::<Vec<_>>()),+ ItemKind::Footage(f) if !f.path.is_empty() && !f.missing => {+ Some(std::iter::once(f.path.clone()).chain(f.sequence.iter().cloned()).collect::<Vec<_>>())+ }_ => None,}).flatten()diff --git a/crates/engine/src/tests_import_project.rs b/crates/engine/src/tests_import_project.rsindex 6aa52b411..cbc161c9c 100644--- a/crates/engine/src/tests_import_project.rs+++ b/crates/engine/src/tests_import_project.rs@@ -113,7 +113,7 @@ fn import_project_merges_with_fresh_ids_and_one_undo() {// A relative footage path resolves next to the imported project; a missing one is reported.let data = t.project.items.values().find(|i| i.name == "data.json").unwrap();let ItemKind::Footage(f) = &data.kind else { panic!("footage") };- assert_eq!(std::path::Path::new(&f.path), dir.join("data.json"));+ assert_eq!(std::fs::canonicalize(&f.path).unwrap(), std::fs::canonicalize(dir.join("data.json")).unwrap());assert_eq!(r["missingMedia"], json!(["/offline/gone.mov"]));// One undo step removes all of it; redo brings it back.diff --git a/crates/lottie/Cargo.toml b/crates/lottie/Cargo.tomlindex ec71de403..a9f64b3ba 100644--- a/crates/lottie/Cargo.toml+++ b/crates/lottie/Cargo.toml@@ -10,6 +10,7 @@ rust-version.workspace = trueworkspace = true[dependencies]+craft-docpath = { workspace = true }effectcraft-time = { workspace = true }effectcraft-color = { workspace = true }effectcraft-keyframe = { workspace = true }diff --git a/crates/lottie/src/import.rs b/crates/lottie/src/import.rsindex 0fb1bfebc..7730017d8 100644--- a/crates/lottie/src/import.rs+++ b/crates/lottie/src/import.rs@@ -88,6 +88,21 @@ impl Ctx<'_> {}}+/// The file an external image asset (`u` + `p`) names, taken from `base_dir`, the folder of the+/// Lottie file. Only local files, or files on the network share the Lottie file is on, are+/// imported (see `craft_docpath`).+fn external_image(stored: &str, base_dir: &str) -> Result<String, String> {+ let doc = (!base_dir.is_empty()).then(|| {+ let doc = std::path::Path::new(base_dir).join("lottie.json");+ std::path::absolute(&doc).unwrap_or(doc)+ });+ match craft_docpath::resolve(stored, doc.as_deref()) {+ Ok(path) if path.is_absolute() => Ok(path.to_string_lossy().into_owned()),+ Ok(_) => Err(format!("{stored} is relative and the Lottie file's folder is not known")),+ Err(why) => Err(format!("{stored}: {why}")),+ }+}+/// Import a Lottie document (JSON or a stored `.lottie` archive) into `project` as a new/// composition. `store` saves embedded images and returns the file path to use;/// `base_dir` resolves external image references.@@ -145,8 +160,13 @@ pub fn import((cx.store)(&ImportedImage { id: id.to_string(), name: nm.clone(), bytes: data, ext: ext.into() })} else {let u = s(a, "u").unwrap_or("");- let rel = format!("{u}{p}");- Some(if rel.starts_with('/') || cx.base_dir.is_empty() { rel } else { format!("{}/{rel}", cx.base_dir.trim_end_matches('/')) })+ match external_image(&format!("{u}{p}"), cx.base_dir) {+ Ok(path) => Some(path),+ Err(why) => {+ cx.im.warn(format!("image asset `{id}` is not imported: {why}"));+ continue;+ }+ }};let Some(path) = path else {cx.im.warn(format!("image asset `{id}` could not be stored"));diff --git a/crates/lottie/src/tests.rs b/crates/lottie/src/tests.rsindex 19aac0f9d..e819c0239 100644--- a/crates/lottie/src/tests.rs+++ b/crates/lottie/src/tests.rs@@ -806,3 +806,26 @@ fn extreme_enum_numbers_do_not_overflow() {let mut q = Project::default();import(&mut q, doc.to_string().as_bytes(), "x", "", &mut |_| None).unwrap();}++/// External image assets are taken from the Lottie file's folder; one on another computer is not+/// imported.+#[test]+fn external_images_are_local_or_skipped() {+ let base = std::env::temp_dir().join("ec-lottie-anim");+ let mut assets = vec![+ serde_json::json!({"id": "near", "u": "images/", "p": "a.png", "w": 1, "h": 1}),+ serde_json::json!({"id": "unc", "u": "", "p": r"\\192.0.2.1\share\x.png", "w": 1, "h": 1}),+ serde_json::json!({"id": "url", "u": "file://192.0.2.1/s/", "p": "x.png", "w": 1, "h": 1}),+ ];+ // `u` + `p` is `//tmp/…/a.png`, which Linux reads as a local file.+ if cfg!(unix) {+ assets.push(serde_json::json!({"id": "slashes", "u": "/", "p": base.join("a.png").to_string_lossy(), "w": 1, "h": 1}));+ }+ let doc = serde_json::json!({"w": 10, "h": 10, "fr": 30, "ip": 0, "op": 30, "assets": assets, "layers": []});+ let mut q = Project::default();+ let r = import(&mut q, doc.to_string().as_bytes(), "x", &base.to_string_lossy(), &mut |_| None).unwrap();+ let paths: Vec<String> = q.items.values().filter_map(|i| if let ItemKind::Footage(f) = &i.kind { Some(f.path.clone()) } else { None }).collect();+ assert_eq!(paths.len(), 1, "{paths:?}");+ assert_eq!(std::path::Path::new(&paths[0]), base.join("images").join("a.png"));+ assert_eq!(r.warnings.iter().filter(|w| w.contains("is not imported")).count(), assets.len() - 1, "{:?}", r.warnings);+}diff --git a/crates/media/Cargo.toml b/crates/media/Cargo.tomlindex bb47dccb0..0ef01d831 100644--- a/crates/media/Cargo.toml+++ b/crates/media/Cargo.toml@@ -10,6 +10,7 @@ rust-version.workspace = trueworkspace = true[dependencies]+craft-docpath = { workspace = true }effectcraft-time = { workspace = true }effectcraft-project = { workspace = true }effectcraft-raster = { workspace = true }diff --git a/crates/media/src/pool.rs b/crates/media/src/pool.rsindex 98c707108..9a8ec5c28 100644--- a/crates/media/src/pool.rs+++ b/crates/media/src/pool.rs@@ -557,9 +557,9 @@ impl Inner {return m.clone();}let loaded = self.read(path).map_err(|e| e.to_string()).and_then(|bytes| {- let dir = std::path::Path::new(path).parent().map(|d| d.to_path_buf()).unwrap_or_default();+ // Files the model names are read only when local or on the model's own network share.let resolve = |uri: &str| -> Option<Vec<u8>> {- let p = dir.join(uri);+ let p = craft_docpath::resolve(uri, Some(std::path::Path::new(path))).ok().filter(|p| p.is_absolute())?;self.read(&p.to_string_lossy()).ok().map(|b| b.to_vec())};effectcraft_model::load(path, &bytes, &resolve).map_err(|e| e.to_string())@@ -1140,4 +1140,27 @@ mod tests {assert_eq!(px(&f, FloatCurve::Srgb), srgb);assert_eq!(px(&f, FloatCurve::Gamma24), g24);}++ /// A model's material library is read beside it; one named by a path to another computer+ /// is not read.+ #[test]+ fn model_files_on_other_computers_are_not_read() {+ let dir = std::env::temp_dir().join(format!("ec-model-files-{}", std::process::id()));+ std::fs::create_dir_all(&dir).unwrap();+ std::fs::write(dir.join("red.mtl"), "newmtl red\nKd 1 0 0\n").unwrap();+ let pool = MediaPool::new();+ let red = |name: &str, mtl: &str| {+ let path = dir.join(name);+ std::fs::write(&path, format!("mtllib {mtl}\nv 0 0 0\nv 1 0 0\nv 0 1 0\nusemtl red\nf 1 2 3\n")).unwrap();+ let model = pool.inner.model(&path.to_string_lossy()).unwrap();+ model.materials.iter().any(|m| m.base_color[..3] == [1.0, 0.0, 0.0])+ };+ assert!(red("beside.obj", "red.mtl"));+ assert!(!red("unc.obj", r"\\192.0.2.1\share\red.mtl"));+ assert!(!red("url.obj", "file://192.0.2.1/s/red.mtl"));+ // Linux reads `//dir/red.mtl` as the local file.+ #[cfg(unix)]+ assert!(!red("slashes.obj", &format!("/{}", dir.join("red.mtl").display())));+ let _ = std::fs::remove_dir_all(&dir);+ }}diff --git a/crates/ui-egui/src/panels/project.rs b/crates/ui-egui/src/panels/project.rsindex 76309a5d0..c4e9894c4 100644--- a/crates/ui-egui/src/panels/project.rs+++ b/crates/ui-egui/src/panels/project.rs@@ -57,10 +57,10 @@ pub fn fmt_size(bytes: u64) -> String {}}-/// Footage file size on disk (comps, solids and folders have none).+/// Footage file size on disk (comps, solids, folders and missing footage have none).fn file_size(it: &Item) -> Option<u64> {match &it.kind {- ItemKind::Footage(f) => std::fs::metadata(&f.path).ok().map(|m| m.len()),+ ItemKind::Footage(f) if !f.missing => std::fs::metadata(&f.path).ok().map(|m| m.len()),_ => None,}}diff --git a/crates/ui-egui/src/panels/waveform.rs b/crates/ui-egui/src/panels/waveform.rsindex 6fc42ed3f..4e355f951 100644--- a/crates/ui-egui/src/panels/waveform.rs+++ b/crates/ui-egui/src/panels/waveform.rs@@ -54,7 +54,7 @@ pub fn summary(app: &EffectcraftApp, ctx: &egui::Context, item: ItemId) -> Optio.name("ec-waveform".into()).spawn(move || {use effectcraft_engine::media_cache;- let file = cache.and_then(|d| media_cache::peaks_path(&d, &f.path, BINS_PER_SEC));+ let file = cache.filter(|_| !f.missing).and_then(|d| media_cache::peaks_path(&d, &f.path, BINS_PER_SEC));let peaks = match file.as_deref().and_then(media_cache::load_peaks) {Some(p) => p,None => {