|tools.temporary.hand|zoomIn|zoomOut":"Cmd+Shift+X"|""(remove)|null(default)}?,"alternates":{"":["F3",…]|[](none)|null(default)}?,"reset":true|["",…]?,"removeConflicts":bool=true,"filter":str?,"list":bool=false,"importKys":"<.kys XML>"?,"useSet":""|""(defaults)?,"saveSet":""?,"deleteSet":""?,"sets":{"":{"shortcuts":{…},"alternateShortcuts":{…}}}?,"activeSet":""|""?,"exportKys":bool?,"summarize":bool|{"mac":bool}?}"##,
keyboard_shortcuts,
true
),
diff --git a/crates/engine/src/shortcut_sets.rs b/crates/engine/src/shortcut_sets.rs
new file mode 100644
index 0000000000..c5fc4993fe
--- /dev/null
+++ b/crates/engine/src/shortcut_sets.rs
@@ -0,0 +1,347 @@
+//! Edit › Keyboard Shortcuts › Set: named shortcut sets, as in Photoshop. The bindings in use
+//! stay in [`Preferences::shortcuts`] / [`Preferences::alternate_shortcuts`] (what dispatch
+//! reads); a set is a saved copy of them, `Preferences::shortcut_sets` keyed by name, and
+//! `Preferences::shortcut_set` names the one in use ("" for the defaults). The bindings differ
+//! from their set after an edit until it is saved ("modified", as Photoshop marks the set).
+//! A set saves to and loads from a `.kys` file (`crate::kys::write` / the import), and
+//! [`summarize`] writes the HTML table of Photoshop's Summarize button.
+//!
+//! `edit.keyboardShortcuts` takes the set parameters: `useSet` (load a set's bindings, before
+//! the call's other changes), then `saveSet` (save the bindings as they end up under a name and
+//! use it), `deleteSet`, `sets` (replace every saved set: the dialog's OK) and `activeSet`.
+
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+
+use crate::prefs::{Preferences, alternate_keys, normalize_shortcut};
+
+/// The built-in set's name: the default bindings.
+pub const DEFAULTS_NAME: &str = "PhotoCraft Defaults";
+/// Saved sets are small; the cap keeps a hostile settings file or call bounded.
+pub const MAX_SETS: usize = 64;
+/// Longest set name, in characters.
+pub const MAX_NAME: usize = 64;
+
+/// A saved set: the overrides of the default bindings, in the shape the preferences keep them.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct ShortcutSet {
+ /// Command id → main key; "" removes the default key.
+ pub shortcuts: BTreeMap,
+ /// Command id → further keys, replacing the defaults.
+ pub alternate_shortcuts: BTreeMap>,
+}
+
+impl ShortcutSet {
+ /// The bindings `p` uses now.
+ pub fn of(p: &Preferences) -> Self {
+ Self { shortcuts: p.shortcuts.clone(), alternate_shortcuts: p.alternate_shortcuts.clone() }
+ }
+
+ /// Use this set's bindings in `p`.
+ pub fn load_into(&self, p: &mut Preferences) {
+ p.shortcuts = self.shortcuts.clone();
+ p.alternate_shortcuts = self.alternate_shortcuts.clone();
+ }
+
+ /// Check every key (a set from a call or a hand-edited file must not hold garbage).
+ fn validate(&self) -> Result<(), String> {
+ for (id, k) in &self.shortcuts {
+ if !k.is_empty() && normalize_shortcut(k).is_none() {
+ return Err(format!("`{k}` for `{id}` is not a valid shortcut (e.g. Cmd+Shift+N, F7)"));
+ }
+ }
+ for (id, keys) in &self.alternate_shortcuts {
+ alternate_keys(&json!(keys)).map_err(|e| format!("`{id}`: {e}"))?;
+ }
+ Ok(())
+ }
+}
+
+/// A set name as given, trimmed; an error for an empty, overlong or reserved name.
+pub fn set_name(name: &str) -> Result {
+ let n = name.trim();
+ if n.is_empty() {
+ return Err("a set needs a name".into());
+ }
+ if n.chars().count() > MAX_NAME {
+ return Err(format!("a set name is at most {MAX_NAME} characters"));
+ }
+ if n.chars().any(char::is_control) {
+ return Err("a set name can't contain control characters".into());
+ }
+ if n.eq_ignore_ascii_case(DEFAULTS_NAME) {
+ return Err(format!("`{DEFAULTS_NAME}` is the built-in set"));
+ }
+ Ok(n.to_string())
+}
+
+/// The saved copy of the set in use: `None` for the defaults (or a set that no longer exists).
+fn saved(p: &Preferences) -> Option<&ShortcutSet> {
+ p.shortcut_sets.get(&p.shortcut_set)
+}
+
+/// Do the bindings differ from the set in use?
+pub fn modified(p: &Preferences) -> bool {
+ let now = ShortcutSet::of(p);
+ match saved(p) {
+ Some(s) => *s != now,
+ None => now != ShortcutSet::default(),
+ }
+}
+
+/// Before the call's binding changes: `useSet` loads a set ("" or [`DEFAULTS_NAME`]: the
+/// defaults) and makes it the one in use. Returns whether it changed anything.
+pub fn load(next: &mut Preferences, p: &Value) -> Result {
+ let Some(v) = p.get("useSet") else { return Ok(false) };
+ let name = v.as_str().ok_or("`useSet` is a set name")?.trim();
+ if name.is_empty() || name.eq_ignore_ascii_case(DEFAULTS_NAME) {
+ ShortcutSet::default().load_into(next);
+ next.shortcut_set = String::new();
+ } else {
+ let set = next.shortcut_sets.get(name).cloned().ok_or_else(|| format!("no shortcut set named `{name}`"))?;
+ set.load_into(next);
+ next.shortcut_set = name.to_string();
+ }
+ Ok(true)
+}
+
+/// After the call's binding changes: `sets` (replace every saved set), `deleteSet`, `saveSet`
+/// (save the bindings under a name and use it) and `activeSet`. Returns whether it changed
+/// anything.
+pub fn store(next: &mut Preferences, p: &Value) -> Result {
+ let mut changed = false;
+ if let Some(v) = p.get("sets") {
+ let obj = v.as_object().ok_or("`sets` maps set names to {shortcuts, alternateShortcuts}")?;
+ if obj.len() > MAX_SETS {
+ return Err(format!("at most {MAX_SETS} shortcut sets"));
+ }
+ let mut sets = BTreeMap::new();
+ for (name, s) in obj {
+ let name = set_name(name)?;
+ let set: ShortcutSet = serde_json::from_value(s.clone()).map_err(|e| format!("set `{name}`: {e}"))?;
+ set.validate().map_err(|e| format!("set `{name}`: {e}"))?;
+ sets.insert(name, set);
+ }
+ next.shortcut_sets = sets;
+ changed = true;
+ }
+ if let Some(v) = p.get("deleteSet") {
+ let name = v.as_str().ok_or("`deleteSet` is a set name")?.trim();
+ if next.shortcut_sets.remove(name).is_none() {
+ return Err(format!("no shortcut set named `{name}`"));
+ }
+ if next.shortcut_set == name {
+ next.shortcut_set = String::new();
+ }
+ changed = true;
+ }
+ if let Some(v) = p.get("saveSet") {
+ let name = set_name(v.as_str().ok_or("`saveSet` is a set name")?)?;
+ if !next.shortcut_sets.contains_key(&name) && next.shortcut_sets.len() >= MAX_SETS {
+ return Err(format!("at most {MAX_SETS} shortcut sets"));
+ }
+ next.shortcut_sets.insert(name.clone(), ShortcutSet::of(next));
+ next.shortcut_set = name;
+ changed = true;
+ }
+ if let Some(v) = p.get("activeSet") {
+ let name = v.as_str().ok_or("`activeSet` is a set name")?.trim();
+ if name.is_empty() || name.eq_ignore_ascii_case(DEFAULTS_NAME) {
+ next.shortcut_set = String::new();
+ } else if next.shortcut_sets.contains_key(name) {
+ next.shortcut_set = name.to_string();
+ } else {
+ return Err(format!("no shortcut set named `{name}`"));
+ }
+ changed = true;
+ }
+ Ok(changed)
+}
+
+/// The sets, the one in use and whether the bindings differ from it, for the command's reply.
+pub fn describe(p: &Preferences) -> Value {
+ json!({
+ "sets": p.shortcut_sets.keys().collect::>(),
+ "activeSet": if saved(p).is_some() { p.shortcut_set.as_str() } else { "" },
+ "defaultsName": DEFAULTS_NAME,
+ "modified": modified(p),
+ })
+}
+
+/// A key as the Summarize table shows it on `mac` (⌘ spelled Cmd, ⌥ Option) or elsewhere
+/// (Ctrl, Alt).
+fn key_label(sc: &str, mac: bool) -> String {
+ let Some(n) = normalize_shortcut(sc) else { return sc.to_string() };
+ // `Cmd++` splits into an empty part before the key, which joins back as `++`.
+ let mut parts: Vec<&str> = Vec::new();
+ for part in n.split('+') {
+ let shown = match (part, mac) {
+ ("Ctrl", true) => "Control",
+ ("Cmd", false) | ("Ctrl", false) => "Ctrl",
+ ("Alt", true) => "Option",
+ (p, _) => p,
+ };
+ // Off the Mac, ⌘ and Control are both Ctrl: say it once.
+ if shown == "Ctrl" && parts.contains(&"Ctrl") {
+ continue;
+ }
+ parts.push(shown);
+ }
+ parts.join("+")
+}
+
+fn html_escape(s: &str) -> String {
+ s.replace('&', "&").replace('<', "<").replace('>', ">").replace('"', """)
+}
+
+/// A Summarize row: a command's label and its keys, the main one first.
+pub type Row = (String, Vec);
+/// A Summarize section: its title and rows.
+pub type Section = (String, Vec);
+
+/// Photoshop's Summarize: an HTML page listing every command with a key, by section
+/// (`sections` in display order: section title, then (command label, keys with the main one
+/// first)). Commands without a key are left out.
+pub fn summarize(set: &str, sections: &[Section], mac: bool) -> String {
+ let mut out = String::new();
+ out.push_str("\n");
+ out.push_str(&html_escape(set));
+ out.push_str("\n\n\n");
+ out.push_str(&html_escape(set));
+ out.push_str("
\n");
+ for (title, rows) in sections {
+ let rows: Vec<&Row> = rows.iter().filter(|(_, keys)| !keys.is_empty()).collect();
+ if rows.is_empty() {
+ continue;
+ }
+ out.push_str("");
+ out.push_str(&html_escape(title));
+ out.push_str("
\n| Command | Shortcut |
|---|
\n");
+ for (label, keys) in rows {
+ let keys: Vec = keys.iter().map(|k| html_escape(&key_label(k, mac))).collect();
+ out.push_str("| ");
+ out.push_str(&html_escape(label));
+ out.push_str(" | ");
+ out.push_str(&keys.join(", "));
+ out.push_str(" |
\n");
+ }
+ out.push_str("
\n");
+ }
+ out.push_str("\n");
+ out
+}
+
+/// Every engine command (and temporary tool) with a key under the bindings of `p`: (id,
+/// label, top-level menu, keys with the main one first). The app's dialog adds the commands
+/// only the shell knows (View › Zoom In, the tools).
+pub fn bound(p: &Preferences) -> Vec<(String, String, String, Vec)> {
+ let temporary = crate::prefs::TEMPORARY_TOOLS.iter().map(|t| (t.0, t.1, "Tools", Some(t.2)));
+ crate::command_specs()
+ .iter()
+ .map(|c| (c.id, c.label, c.menu.first().copied().unwrap_or("Other"), c.shortcut))
+ .chain(temporary)
+ .filter_map(|(id, label, menu, def)| {
+ let main = p.shortcut(id, def);
+ let mut keys: Vec = main.and_then(normalize_shortcut).into_iter().collect();
+ keys.extend(p.alternates(id, main));
+ (!keys.is_empty()).then(|| (id.to_string(), label.to_string(), menu.to_string(), keys))
+ })
+ .collect()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn prefs() -> Preferences {
+ Preferences::default()
+ }
+
+ #[test]
+ fn save_use_modify_and_delete_a_set() {
+ let mut p = prefs();
+ assert!(!modified(&p));
+ p.shortcuts.insert("edit.copy".into(), "F9".into());
+ assert!(modified(&p), "an edit to the defaults");
+ assert!(store(&mut p, &json!({"saveSet": " Mine "})).unwrap());
+ assert_eq!((p.shortcut_set.as_str(), modified(&p)), ("Mine", false));
+ p.shortcuts.insert("edit.cut".into(), "F8".into());
+ assert!(modified(&p));
+ // Back to the defaults, then to the saved set as it was saved.
+ assert!(load(&mut p, &json!({"useSet": ""})).unwrap());
+ assert!(p.shortcuts.is_empty() && p.shortcut_set.is_empty() && !modified(&p));
+ load(&mut p, &json!({"useSet": "Mine"})).unwrap();
+ assert_eq!(p.shortcuts.get("edit.copy").map(String::as_str), Some("F9"));
+ assert_eq!(p.shortcuts.get("edit.cut"), None, "the unsaved edit isn't in the set");
+ assert_eq!(describe(&p)["sets"], json!(["Mine"]));
+ // Deleting the set in use falls back to the defaults' name; the bindings stay.
+ store(&mut p, &json!({"deleteSet": "Mine"})).unwrap();
+ assert!(p.shortcut_sets.is_empty() && p.shortcut_set.is_empty());
+ assert_eq!(describe(&p)["activeSet"], "");
+ assert!(modified(&p), "F9 differs from the defaults");
+ }
+
+ #[test]
+ fn bad_names_sets_and_params_are_errors() {
+ let mut p = prefs();
+ for name in ["", " ", "PhotoCraft defaults", "a\u{7}b", &"x".repeat(65)] {
+ assert!(store(&mut p, &json!({"saveSet": name})).is_err(), "{name:?}");
+ }
+ assert!(load(&mut p, &json!({"useSet": "Nope"})).is_err());
+ assert!(load(&mut p, &json!({"useSet": 3})).is_err());
+ assert!(store(&mut p, &json!({"deleteSet": "Nope"})).is_err());
+ assert!(store(&mut p, &json!({"activeSet": "Nope"})).is_err());
+ assert!(store(&mut p, &json!({"sets": []})).is_err());
+ assert!(store(&mut p, &json!({"sets": {"A": {"shortcuts": {"edit.copy": "Cmd+Shift+Ctrl"}}}})).is_err(), "no key");
+ let nine: Vec = (1..=9).map(|i| format!("F{i}")).collect();
+ assert!(store(&mut p, &json!({"sets": {"A": {"alternateShortcuts": {"edit.copy": nine}}}})).is_err());
+ assert!(store(&mut p, &json!({"sets": {"A": {"shortcuts": 5}}})).is_err());
+ let many: serde_json::Map = (0..=MAX_SETS).map(|i| (format!("S{i}"), json!({}))).collect();
+ assert!(store(&mut p, &json!({ "sets": many })).is_err());
+ for i in 0..MAX_SETS {
+ store(&mut p, &json!({"saveSet": format!("S{i}")})).unwrap();
+ }
+ assert!(store(&mut p, &json!({"saveSet": "One more"})).is_err());
+ assert!(store(&mut p, &json!({"saveSet": "S3"})).is_ok(), "saving over a set is fine at the cap");
+ }
+
+ #[test]
+ fn sets_replace_all_and_active_set_follows() {
+ let mut p = prefs();
+ store(&mut p, &json!({"sets": {"A": {"shortcuts": {"edit.copy": "F9"}}, "B": {}}, "activeSet": "A"})).unwrap();
+ assert_eq!(p.shortcut_set, "A");
+ assert!(modified(&p), "activeSet names the set; it doesn't load it");
+ load(&mut p, &json!({"useSet": "A"})).unwrap();
+ assert!(!modified(&p));
+ store(&mut p, &json!({"activeSet": "PhotoCraft Defaults"})).unwrap();
+ assert_eq!(p.shortcut_set, "");
+ }
+
+ #[test]
+ fn summarize_lists_bound_commands_by_section_for_each_platform() {
+ let sections = vec![
+ ("Edit".to_string(), vec![("Copy".to_string(), vec!["Cmd+C".to_string(), "F3".to_string()]), ("Unbound".to_string(), vec![])]),
+ ("Empty".to_string(), vec![("Nothing".to_string(), vec![])]),
+ ("Filter ".to_string(), vec![("Gaussian Blur & more".to_string(), vec!["Ctrl+Alt+Cmd+G".to_string()])]),
+ ];
+ let mac = summarize("My ", §ions, true);
+ assert!(mac.contains("My <Set>") && mac.contains("Copy | Cmd+C, F3 | "), "{mac}");
+ assert!(mac.contains("Cmd+Control+Option+G") && mac.contains("Gaussian Blur & more") && mac.contains("Filter <x>"), "{mac}");
+ assert!(!mac.contains("Unbound") && !mac.contains("Empty"), "{mac}");
+ let pc = summarize("S", §ions, false);
+ assert!(pc.contains("Ctrl+C, F3 | ") && pc.contains("Ctrl+Alt+G"), "{pc}");
+ assert_eq!(key_label("Cmd++", true), "Cmd++");
+ }
+
+ #[test]
+ fn bound_lists_main_keys_then_alternates() {
+ let p = prefs();
+ let b = bound(&p);
+ let copy = b.iter().find(|(id, ..)| id == "edit.copy").expect("Copy has keys");
+ assert_eq!(copy.3, vec!["Cmd+C".to_string(), "F3".to_string()]);
+ assert!(b.iter().any(|(id, ..)| id == "tools.temporary.hand"));
+ }
+}
diff --git a/crates/engine/src/smart_cmds.rs b/crates/engine/src/smart_cmds.rs
index 649a154419..e2c1cf2bfa 100644
--- a/crates/engine/src/smart_cmds.rs
+++ b/crates/engine/src/smart_cmds.rs
@@ -298,40 +298,6 @@ fn blend_surfaces(base: &Surface, top: &Surface, mode: BlendMode, opacity: f32)
out
}
-/// Mixes `filtered` over `base` through the filter mask (premultiplied, any channel layout).
-fn mask_mix(base: &Surface, filtered: &Surface, mask: &LayerMask) -> Surface {
- let fmt = base.format();
- let area = base.content_bounds().union(&filtered.content_bounds());
- let mut out = filtered.clone();
- if area.is_empty() {
- return out;
- }
- let n = fmt.channels();
- let (b, f) = (base.read_region(area), filtered.read_region(area));
- let mut k = Vec::new();
- mask.values_into(area, &mut k);
- let mut o = vec![0.0f32; b.len()];
- for (i, ((bp, fp), op)) in b.chunks_exact(n).zip(f.chunks_exact(n)).zip(o.chunks_exact_mut(n)).enumerate() {
- let m = k.get(i).copied().unwrap_or(1.0).clamp(0.0, 1.0);
- if !fmt.alpha {
- for c in 0..n {
- op[c] = bp[c] + (fp[c] - bp[c]) * m;
- }
- continue;
- }
- let a = n - 1;
- let oa = bp[a] + (fp[a] - bp[a]) * m;
- op[a] = oa;
- for c in 0..a {
- let pm = bp[c] * bp[a] + (fp[c] * fp[a] - bp[c] * bp[a]) * m;
- op[c] = if oa > 0.0 { (pm / oa).clamp(0.0, 1.0) } else { 0.0 };
- }
- }
- out.write_region(area, &o);
- out.prune();
- out
-}
-
/// Runs the smart filter stack on the placed (unfiltered) content.
pub fn apply_smart_filters(placed: &Surface, sm: &SmartObject, canvas: Rect) -> Surface {
if !sm.filters_enabled || !sm.smart_filters.iter().any(|f| f.visible) {
@@ -344,7 +310,7 @@ pub fn apply_smart_filters(placed: &Surface, sm: &SmartObject, canvas: Rect) ->
cur = apply_smart_filter(f, &cur, canvas, extent);
}
match sm.filter_mask.as_ref().filter(|m| m.enabled) {
- Some(m) => mask_mix(placed, &cur, m),
+ Some(m) => photocraft_compose::filter_mask::mix(placed, &cur, m),
None => cur,
}
}
@@ -449,7 +415,7 @@ fn render_in(doc: &Document, sm: &SmartObject, ctx: &JobCtx) -> Result mask_mix(&placed()?.surface, &cur.surface, m),
+ Some(m) => photocraft_compose::filter_mask::mix(&placed()?.surface, &cur.surface, m),
None => cur.surface,
}))
}
diff --git a/crates/engine/src/timeline_cmds.rs b/crates/engine/src/timeline_cmds.rs
index 197c8e9ccc..9baa077608 100644
--- a/crates/engine/src/timeline_cmds.rs
+++ b/crates/engine/src/timeline_cmds.rs
@@ -12,7 +12,7 @@ use crate::{EngineError, Result, Session};
/// Longest timeline, in frames: every frame becomes a surface in a new video layer and a file in
/// Render Video, so `duration` is capped well before it can exhaust memory or overflow (#1009).
-const MAX_DURATION: usize = 1_000_000;
+pub(crate) const MAX_DURATION: usize = 1_000_000;
/// Highest frame rate; larger values only come from mistakes and become `inf` as `f32` (#1009).
const MAX_FPS: f32 = 1000.0;
diff --git a/crates/engine/src/video_cmds.rs b/crates/engine/src/video_cmds.rs
index 2a9f8ae8b4..6fb9ab4574 100644
--- a/crates/engine/src/video_cmds.rs
+++ b/crates/engine/src/video_cmds.rs
@@ -11,6 +11,10 @@ use serde_json::{Value, json};
use crate::commands::CommandSpec;
use crate::{EngineError, Result, Session};
+/// Maximum dense RGBA staging pixels in one animated GIF frame. A GIF also keeps the
+/// quantised frame and palette while rendering, so the document canvas limit is not enough.
+const MAX_GIF_FRAME_PIXELS: u64 = 64 << 20;
+
/// Set every video layer's displayed content to its frame at the playhead.
pub fn sync(doc: &mut Document) {
let cur = doc.timeline.as_ref().map_or(0, |t| t.current);
@@ -416,6 +420,10 @@ pub fn render_video_with(
let mut base = (*st.doc).clone();
store(&mut base);
let frames = base.timeline.as_ref().map_or(1, |t| t.duration).max(1);
+ // Loaded timelines bypass the duration validation used by timeline.create/setProps.
+ if frames > crate::timeline_cmds::MAX_DURATION {
+ return Err(EngineError::Other(format!("the timeline is {frames} frames; Render Video is limited to {} frames", crate::timeline_cmds::MAX_DURATION)));
+ }
let fps = base.timeline.as_ref().map_or(30.0, |t| t.fps).max(1.0);
let stem = base.name.rsplit_once('.').map_or(base.name.as_str(), |(a, _)| a).to_string();
let fmt = base.pixel_format();
@@ -429,6 +437,11 @@ pub fn render_video_with(
// Animated GIF: one file, every frame quantised to its own palette.
if format.eq_ignore_ascii_case("gif") {
+ // The whole canvas is staged as f32 RGBA for each frame; reject over-budget
+ // dimensions before an infallible allocation can abort the process.
+ if (w as u64) * (h as u64) > MAX_GIF_FRAME_PIXELS {
+ return Err(EngineError::Other(format!("{w} × {h} is too large to render as an animated GIF (limit {MAX_GIF_FRAME_PIXELS} pixels per frame)")));
+ }
let delay = (100.0 / fps).round().clamp(1.0, 65535.0) as u16;
let mut gframes = Vec::with_capacity(frames);
for f in 0..frames {
diff --git a/crates/engine/src/video_cmds/tests.rs b/crates/engine/src/video_cmds/tests.rs
index 22d639d49b..c16c7f8e39 100644
--- a/crates/engine/src/video_cmds/tests.rs
+++ b/crates/engine/src/video_cmds/tests.rs
@@ -498,3 +498,25 @@ fn grow_duration_never_shrinks_and_keeps_the_work_area_valid() {
grow_duration(&mut t, 12);
assert_eq!((t.work_start, t.work_end, t.duration), (0, 6, 12));
}
+
+#[test]
+fn render_video_rejects_a_loaded_timeline_past_the_frame_cap() {
+ let mut s = session();
+ let mut doc = (*s.active().unwrap().doc).clone();
+ doc.timeline = Some(Timeline::new(usize::MAX, 30.0));
+ {
+ let st = s.active_mut().unwrap();
+ st.doc = std::sync::Arc::new(doc);
+ st.revision += 1;
+ }
+ let err = s.execute("file.export.renderVideo", json!({"dir": tmpdir("overlong"), "format": "gif"})).unwrap_err();
+ assert!(err.to_string().contains("limited to"), "{err}");
+}
+
+#[test]
+fn render_video_rejects_gif_frames_too_large_to_stage() {
+ let mut s = Session::new();
+ s.execute("file.new", json!({"width": 9000, "height": 8000})).unwrap();
+ let err = s.execute("file.export.renderVideo", json!({"dir": tmpdir("large-gif"), "format": "gif"})).unwrap_err();
+ assert!(err.to_string().contains("too large"), "{err}");
+}
diff --git a/crates/engine/tests/clipping_semantics.rs b/crates/engine/tests/clipping_semantics.rs
new file mode 100644
index 0000000000..1a4aa562a7
--- /dev/null
+++ b/crates/engine/tests/clipping_semantics.rs
@@ -0,0 +1,75 @@
+//! Clip groups through Release Clipping Mask, Merge Down, Merge Layers and Delete Hidden Layers,
+//! as in Photoshop (layers audit L2). The stack: Background, B, C1*, C2* (C1 and C2 clipped to B).
+
+use photocraft_engine::Session;
+use serde_json::json;
+
+fn stack() -> (Session, [u64; 3]) {
+ let mut s = Session::new();
+ s.execute("file.new", json!({"width": 32, "height": 32, "background": "white"})).unwrap();
+ let mut ids = [0u64; 3];
+ for (i, color) in ["#ff0000", "#00ff00", "#0000ff"].iter().enumerate() {
+ ids[i] = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+ s.execute("select.rect", json!({"x": 4 * i, "y": 4, "width": 12, "height": 12})).unwrap();
+ s.execute("edit.fill", json!({"color": color})).unwrap();
+ s.execute("select.deselect", json!({})).unwrap();
+ }
+ for c in &ids[1..] {
+ s.execute("layer.setProps", json!({"layer": c, "clipped": true})).unwrap();
+ }
+ (s, ids)
+}
+
+fn clipped(s: &Session, id: u64) -> bool {
+ s.active().unwrap().doc.layer(photocraft_doc::LayerId(id)).unwrap().clipped
+}
+
+#[test]
+fn releasing_a_middle_layer_releases_the_ones_above_it() {
+ let (mut s, [_, c1, c2]) = stack();
+ let r = s.execute("layer.releaseClippingMask", json!({"layer": c1})).unwrap();
+ assert!(!clipped(&s, c1) && !clipped(&s, c2), "C2 isn't left clipped to the released C1: {r}");
+ // Releasing the top one leaves the one below it alone.
+ let (mut s, [_, c1, c2]) = stack();
+ s.execute("layer.releaseClippingMask", json!({"layer": c2})).unwrap();
+ assert!(clipped(&s, c1) && !clipped(&s, c2));
+}
+
+#[test]
+fn merging_clipped_layers_keeps_the_result_clipped() {
+ let (mut s, [_, c1, c2]) = stack();
+ s.execute("layer.select", json!({"layer": c2})).unwrap();
+ let r = s.execute("layer.mergeDown", json!({})).unwrap();
+ let merged = r["layer"].as_u64().unwrap_or(c1);
+ assert!(clipped(&s, merged), "C2 merged down into C1 stays clipped to B");
+ let (mut s, [_, c1, c2]) = stack();
+ s.execute("layer.select", json!({"layer": c1})).unwrap();
+ s.execute("layer.select", json!({"layer": c2, "mode": "add"})).unwrap();
+ let r = s.execute("layer.mergeLayers", json!({})).unwrap();
+ assert!(clipped(&s, r["layer"].as_u64().unwrap()), "C1 + C2 merged stay clipped");
+ // Clipped layers of two chains (Background, B, C1*, E, D*: C1 clipped to B, D to E) merge
+ // into an ordinary layer: kept clipped at D's slot, C1's pixels would clip to E.
+ let (mut s, [_, c1, e]) = stack();
+ s.execute("layer.setProps", json!({"layer": e, "clipped": false})).unwrap();
+ let d = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+ s.execute("edit.fill", json!({"color": "#808080"})).unwrap();
+ s.execute("layer.setProps", json!({"layer": d, "clipped": true})).unwrap();
+ s.execute("layer.select", json!({"layer": c1})).unwrap();
+ s.execute("layer.select", json!({"layer": d, "mode": "add"})).unwrap();
+ let r = s.execute("layer.mergeLayers", json!({})).unwrap();
+ assert!(!clipped(&s, r["layer"].as_u64().unwrap()), "C1 + D come from two clip chains");
+ // Merging the base with its clipped layers gives an ordinary layer.
+ let (mut s, [b, _, c2]) = stack();
+ s.execute("layer.select", json!({"layer": b})).unwrap();
+ s.execute("layer.select", json!({"layer": c2, "mode": "add"})).unwrap();
+ let r = s.execute("layer.mergeLayers", json!({})).unwrap();
+ assert!(!clipped(&s, r["layer"].as_u64().unwrap()));
+}
+
+#[test]
+fn deleting_a_hidden_base_releases_its_clipped_layers() {
+ let (mut s, [b, c1, c2]) = stack();
+ s.execute("layer.setProps", json!({"layer": b, "visible": false})).unwrap();
+ s.execute("layer.delete.hiddenLayers", json!({})).unwrap();
+ assert!(!clipped(&s, c1) && !clipped(&s, c2), "they don't clip to the layer below the deleted base");
+}
diff --git a/crates/engine/tests/duplicate_variables.rs b/crates/engine/tests/duplicate_variables.rs
new file mode 100644
index 0000000000..48d197b51e
--- /dev/null
+++ b/crates/engine/tests/duplicate_variables.rs
@@ -0,0 +1,146 @@
+//! Variable definitions must continue targeting their layers after a copied document gets
+//! fresh ids (#4969), and a merged-only copy must not keep bindings to discarded layers.
+
+use photocraft_doc::{Document, Layer, LayerContent, LayerId, Size, TextLayer};
+use photocraft_engine::Session;
+use serde_json::json;
+
+fn scene() -> (Session, LayerId, LayerId, LayerId) {
+ let mut s = Session::new();
+ s.execute("file.new", json!({"width": 64, "height": 48})).unwrap();
+ let ids = s
+ .edit("setup", |doc, _| {
+ let fmt = doc.pixel_format();
+ let mut photo = Layer::raster("photo", fmt);
+ photo.surface_mut().unwrap().fill_rect(photocraft_geom::Rect::new(0, 0, 64, 48), &photocraft_raster::from_rgba(&fmt, [0.5, 0.5, 0.5, 1.0]));
+ let badge = Layer::raster("badge", fmt);
+ let title = Layer::new("title", LayerContent::Text(TextLayer { text: "Old".into(), ..Default::default() }));
+ let (p, b, t) = (photo.id, badge.id, title.id);
+ doc.layers.push(photo);
+ doc.layers.push(badge);
+ doc.layers.push(title);
+ Ok((p, b, t))
+ })
+ .unwrap();
+ (s, ids.0, ids.1, ids.2)
+}
+
+fn red_png(dir: &str) -> String {
+ let doc = Document::with_background(
+ "red",
+ Size::new(4, 4),
+ photocraft_doc::ColorMode::Rgb,
+ photocraft_doc::SampleType::U8,
+ photocraft_doc::Color::rgb(1.0, 0.0, 0.0),
+ );
+ let bytes = photocraft_io::export(&doc, "png", &photocraft_io::ExportOptions::default()).unwrap().bytes;
+ let path = format!("{dir}/replacement.png");
+ std::fs::write(&path, bytes).unwrap();
+ path
+}
+
+fn copied_layer(s: &Session, name: &str) -> LayerId {
+ s.active().unwrap().doc.walk().into_iter().find(|(_, _, l)| l.name == name).unwrap().2.id
+}
+
+fn define_all(s: &mut Session, photo: LayerId, badge: LayerId, title: LayerId, png: &str) {
+ s.execute(
+ "image.variables.define",
+ json!({"defs": [
+ {"name": "showBadge", "layer": badge.0, "type": "visibility"},
+ {"name": "headline", "layer": title.0, "type": "textReplacement"},
+ {"name": "photo", "layer": photo.0, "type": "pixelReplacement", "method": "conform"},
+ ]}),
+ )
+ .unwrap();
+ s.execute(
+ "image.variables.dataSets",
+ json!({"dataSets": [
+ {"name": "A", "values": [
+ {"variable": "showBadge", "kind": "visibility", "value": false},
+ {"variable": "headline", "kind": "text", "value": "Hello"},
+ {"variable": "photo", "kind": "pixels", "value": png},
+ ]},
+ ]}),
+ )
+ .unwrap();
+}
+
+#[test]
+fn duplicated_documents_keep_variables_targeting_the_copied_layers() {
+ let dir = std::env::temp_dir().join(format!("pc-dup-vars-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let png = red_png(&dir.to_string_lossy());
+
+ for command in ["image.duplicate", "history.newDocument"] {
+ let (mut s, photo, badge, title) = scene();
+ define_all(&mut s, photo, badge, title, &png);
+ s.execute(command, json!({})).unwrap();
+
+ let doc = &s.active().unwrap().doc;
+ let new_photo = copied_layer(&s, "photo");
+ let new_badge = copied_layer(&s, "badge");
+ let new_title = copied_layer(&s, "title");
+ assert_ne!(new_photo, photo, "{command}: layers must get new identities");
+ let targets: Vec = doc.variables.defs.iter().map(|d| d.layer).collect();
+ assert_eq!(targets, vec![new_badge, new_title, new_photo], "{command}: variable defs follow their layers");
+
+ let r = s.execute("image.applyDataSet", json!({"name": "A"})).unwrap();
+ assert_eq!(r["applied"], "A");
+ let doc = &s.active().unwrap().doc;
+ assert!(!doc.layer(new_badge).unwrap().visible, "{command}: visibility drives the copy");
+ match &doc.layer(new_title).unwrap().content {
+ LayerContent::Text(t) => assert_eq!(t.text, "Hello", "{command}: text drives the copy"),
+ _ => panic!("not a text layer"),
+ }
+ let px = doc.layer(new_photo).unwrap().surface().unwrap().pixel(0, 0);
+ assert!(px[0] > 0.9 && px[1] < 0.1, "{command}: pixel replacement drives the copy: {px:?}");
+
+ // The source document still targets its own layers and is untouched.
+ s.set_active(0);
+ let src = &s.active().unwrap().doc;
+ let src_targets: Vec = src.variables.defs.iter().map(|d| d.layer).collect();
+ assert_eq!(src_targets, vec![badge, title, photo], "{command}: source defs untouched");
+ assert!(src.layer(badge).unwrap().visible);
+ assert!(src.layer(photo).unwrap().surface().unwrap().pixel(0, 0)[0] < 0.9);
+ }
+}
+
+#[test]
+fn dangling_variable_targets_stay_dangling_after_duplication() {
+ let (mut s, photo, badge, title) = scene();
+ define_all(&mut s, photo, badge, title, "unused.png");
+ // A def may already refer to a deleted layer before duplication.
+ let missing = LayerId(u64::MAX);
+ s.edit("Break one def", |doc, _| {
+ doc.variables.defs.iter_mut().find(|d| d.name == "showBadge").unwrap().layer = missing;
+ Ok(())
+ })
+ .unwrap();
+ s.execute("image.duplicate", json!({})).unwrap();
+
+ let doc = &s.active().unwrap().doc;
+ let def = doc.variables.defs.iter().find(|d| d.name == "showBadge").unwrap();
+ assert_eq!(def.layer, missing, "a deleted target must not be rewritten to an unrelated new id");
+ let photo_def = doc.variables.defs.iter().find(|d| d.name == "photo").unwrap();
+ assert_eq!(photo_def.layer, copied_layer(&s, "photo"), "live targets still remap");
+}
+
+#[test]
+fn merged_only_duplicate_does_not_carry_variables_for_removed_layers() {
+ let dir = std::env::temp_dir().join(format!("pc-dup-vars-merged-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let png = red_png(&dir.to_string_lossy());
+ let (mut s, photo, badge, title) = scene();
+ define_all(&mut s, photo, badge, title, &png);
+
+ s.execute("image.duplicate", json!({"mergedOnly": true})).unwrap();
+ let d = &s.active().unwrap().doc;
+ assert_eq!(d.layers.len(), 1, "merged-only copy is a single composite layer");
+ assert!(d.variables.defs.is_empty(), "old variables cannot address discarded layers");
+ assert!(d.variables.data_sets.is_empty());
+ assert_eq!(d.variables.active, None);
+
+ s.set_active(0);
+ assert_eq!(s.active().unwrap().doc.variables.defs.len(), 3, "original variables are preserved");
+}
diff --git a/crates/engine/tests/shortcut_sets.rs b/crates/engine/tests/shortcut_sets.rs
new file mode 100644
index 0000000000..c00e6a069d
--- /dev/null
+++ b/crates/engine/tests/shortcut_sets.rs
@@ -0,0 +1,60 @@
+//! Edit › Keyboard Shortcuts › Set through `edit.keyboardShortcuts`: save, switch, delete,
+//! export to `.kys` and back, Summarize, and bad params as errors.
+
+use photocraft_engine::Session;
+use serde_json::{Value, json};
+
+fn ks(s: &mut Session, p: Value) -> Value {
+ s.execute("edit.keyboardShortcuts", p).expect("edit.keyboardShortcuts")
+}
+
+#[test]
+fn a_set_saves_switches_exports_and_imports_back() {
+ let mut s = Session::new();
+ let r = ks(&mut s, json!({}));
+ assert_eq!((r["activeSet"].as_str(), r["modified"].as_bool(), r["defaultsName"].as_str()), (Some(""), Some(false), Some("PhotoCraft Defaults")));
+ // Edit, then save the bindings as they end up after this call's edits.
+ let r = ks(&mut s, json!({"set": {"edit.copy": "F9"}, "alternates": {"edit.copy": []}, "saveSet": "Mine"}));
+ assert_eq!((r["activeSet"].as_str(), r["modified"].as_bool(), r["sets"].clone()), (Some("Mine"), Some(false), json!(["Mine"])));
+ // Export the set, go back to the defaults, then import the file: the bindings return.
+ let xml = ks(&mut s, json!({"exportKys": true}))["kys"].as_str().expect("kys").to_string();
+ assert!(xml.contains("KeyboardCustomization/Mine=Mine") && xml.contains("pc-id=\"edit.copy\">F9
"), "{xml}");
+ let r = ks(&mut s, json!({"useSet": ""}));
+ assert_eq!((r["overrides"].clone(), r["activeSet"].as_str()), (json!({}), Some("")));
+ let r = ks(&mut s, json!({"reset": true, "importKys": xml}));
+ assert_eq!(r["overrides"]["edit.copy"], "F9");
+ assert_eq!(r["alternateOverrides"]["edit.copy"], json!([]), "Copy's F3 stays removed");
+ assert_eq!(r["modified"], true, "imported over the defaults");
+ // Switch back to the saved set; a later unsaved edit marks it modified.
+ ks(&mut s, json!({"useSet": "Mine"}));
+ let r = ks(&mut s, json!({"set": {"edit.cut": "F8"}}));
+ assert_eq!((r["activeSet"].as_str(), r["modified"].as_bool()), (Some("Mine"), Some(true)));
+ // Summarize lists what's bound, per platform.
+ let html = ks(&mut s, json!({"summarize": {"mac": false}}))["html"].as_str().expect("html").to_string();
+ assert!(html.contains("Mine") && html.contains("Copy | F9 | ") && html.contains("Cut | F8"), "{html}");
+ // Delete the set in use: the defaults' name, the bindings kept.
+ let r = ks(&mut s, json!({"deleteSet": "Mine"}));
+ assert_eq!((r["sets"].clone(), r["activeSet"].as_str(), r["overrides"]["edit.copy"].as_str()), (json!([]), Some(""), Some("F9")));
+}
+
+#[test]
+fn bad_set_params_change_nothing() {
+ let mut s = Session::new();
+ ks(&mut s, json!({"saveSet": "Keep"}));
+ let before = s.prefs().clone();
+ for p in [
+ json!({"useSet": "Missing"}),
+ json!({"useSet": 7}),
+ json!({"saveSet": ""}),
+ json!({"saveSet": "PhotoCraft Defaults"}),
+ json!({"deleteSet": "Missing"}),
+ json!({"activeSet": "Missing"}),
+ json!({"sets": "nope"}),
+ json!({"sets": {"A": {"shortcuts": {"edit.copy": "Cmd+Shift+Ctrl"}}}}),
+ // A bad key elsewhere in the call keeps the set from being saved too.
+ json!({"set": {"edit.copy": "Cmd+Shift+Ctrl"}, "saveSet": "New"}),
+ ] {
+ assert!(s.execute("edit.keyboardShortcuts", p.clone()).is_err(), "{p}");
+ assert_eq!(s.prefs(), &before, "{p} changed the preferences");
+ }
+}
diff --git a/crates/engine/tests/smart_psd.rs b/crates/engine/tests/smart_psd.rs
index f7b86048b9..2586f24cc9 100644
--- a/crates/engine/tests/smart_psd.rs
+++ b/crates/engine/tests/smart_psd.rs
@@ -615,3 +615,58 @@ fn cs2_plld_only_smart_object_saves_its_new_transform() {
}
assert!(photocraft_engine::smart_cmds::contents_of(&again, photocraft_doc::LayerId(aid)).is_ok(), "the contents are available");
}
+
+/// Photoshop stores a smart object's filtered pixels without its filter mask and mixes the
+/// unfiltered ones back in through the mask (`compose::filter_mask`): the layer record we write
+/// holds the filtered pixels wherever the mask shows any of the filter, and opening the file
+/// mixes them back to what the document showed.
+#[test]
+fn a_soft_filter_mask_is_stored_the_way_photoshop_stores_it() {
+ use photocraft_doc::LayerMask;
+ use photocraft_raster::Surface;
+ let mut s = session(8);
+ s.execute("layer.smartObjects.convertToSmartObject", json!({})).unwrap();
+ s.execute("filter.blur.gaussianBlur", json!({"radius": 4})).unwrap();
+ let id = s.active().unwrap().active_layer.unwrap();
+ // A mask ramping from hiding the blur (left) to showing it (right).
+ s.edit("mask", |doc, _| {
+ let snapshot = doc.clone();
+ let l = doc.layer_mut(id).unwrap();
+ let LayerContent::Smart(sm) = &mut l.content else { panic!("smart") };
+ let mut m = LayerMask::reveal_all();
+ m.surface = Surface::new(photocraft_color::PixelFormat::GRAY8);
+ let r = Rect::new(0, 0, W, H);
+ m.surface.write_region(r, &(0..H).flat_map(|_| (0..W).map(|x| x as f32 / (W - 1) as f32)).collect::>());
+ sm.filter_mask = Some(m);
+ refresh_layer(&snapshot, l).map(|_| ())
+ })
+ .unwrap();
+ let doc = s.active().unwrap().doc.clone();
+ let (_, sm) = smart(&doc);
+ let mixed = sm.cache.clone().unwrap();
+ // The same smart object with the mask switched off: filtered everywhere.
+ let mut unmasked = sm.clone();
+ unmasked.filter_mask.as_mut().unwrap().enabled = false;
+ let filtered = photocraft_engine::smart_cmds::render(&doc, &unmasked).unwrap().unwrap();
+
+ let out = photocraft_io::export(&doc, "psd", &Default::default()).unwrap();
+ let file = photocraft_psd::PsdFile::from_bytes(&out.bytes).unwrap();
+ let name = doc.layer(id).unwrap().name.clone();
+ let record = (0..file.layers().len()).filter_map(|i| file.layer(i)).find(|l| l.name() == name).unwrap();
+ let img = record.rgba8().unwrap();
+ // A column where the mask shows about half the blur, over opaque content.
+ let (x, y) = (W / 2, 20);
+ let at = (((y - img.top) as u32 * img.width + (x - img.left) as u32) * 4) as usize;
+ let stored = &img.data[at..at + 4];
+ let want = filtered.pixel(x, y);
+ let half = mixed.pixel(x, y);
+ let gap = (0..3).map(|c| (want[c] - half[c]).abs()).fold(0.0f32, f32::max);
+ assert!(gap > 3.0 / 255.0, "the mask's mix must show at ({x}, {y}) for this test to mean anything");
+ for c in 0..3 {
+ assert!((f32::from(stored[c]) / 255.0 - want[c]).abs() <= 1.5 / 255.0, "channel {c}: stored {stored:?}, filtered {want:?}, mixed {half:?}");
+ }
+ // Opening the file mixes the unfiltered pixels back in: it shows what the document showed.
+ let back = photocraft_io::import("x.psd", &out.bytes).unwrap().document;
+ let d = max_diff(&photocraft_compose::flatten(&back).px, &photocraft_compose::flatten(&doc).px);
+ assert!(d <= 2.0 / 255.0, "re-opened differs by {d}");
+}
diff --git a/crates/engine/tests/style_and_align.rs b/crates/engine/tests/style_and_align.rs
new file mode 100644
index 0000000000..ad17330507
--- /dev/null
+++ b/crates/engine/tests/style_and_align.rs
@@ -0,0 +1,99 @@
+//! Copy / Paste Layer Style carries the whole style, Blending Options included (Blend If and the
+//! channel restrictions); align with an active selection aligns to it however many layers are
+//! selected (layers audit L2).
+
+use photocraft_engine::Session;
+use serde_json::json;
+
+fn layer(s: &Session, id: u64) -> photocraft_doc::Layer {
+ s.active().unwrap().doc.layer(photocraft_doc::LayerId(id)).unwrap().clone()
+}
+
+fn new_doc(s: &mut Session, mode: &str) -> (u64, u64) {
+ s.execute("file.new", json!({"width": 64, "height": 64, "mode": mode, "background": "white"})).unwrap();
+ let a = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+ let b = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+ (a, b)
+}
+
+#[test]
+fn paste_layer_style_carries_blend_if_and_channels() {
+ let mut s = Session::new();
+ let (a, b) = new_doc(&mut s, "rgb");
+ s.execute(
+ "layer.layerStyle.blendingOptions",
+ json!({"layer": a, "blendIf": [{"channel": "gray", "underlying": [0, 128]}, {"channel": "red", "thisLayer": [10, 200]}]}),
+ )
+ .unwrap();
+ s.execute("layer.setProps", json!({"layer": a, "channels": [true, false, true]})).unwrap();
+ s.execute("layer.layerStyle.copyLayerStyle", json!({"layer": a})).unwrap();
+ s.execute("layer.layerStyle.pasteLayerStyle", json!({"layer": b})).unwrap();
+ let (la, lb) = (layer(&s, a), layer(&s, b));
+ assert_eq!(lb.blend_if, la.blend_if, "Blend If, Gray and channel ranges");
+ assert_eq!(lb.excluded_channels, la.excluded_channels, "the unchecked G channel");
+ // Into a CMYK document: only the Gray range carries over; channels reset to all.
+ let (c, _) = new_doc(&mut s, "cmyk");
+ s.execute("layer.layerStyle.pasteLayerStyle", json!({"layer": c})).unwrap();
+ let lc = layer(&s, c);
+ assert_eq!(lc.blend_if.get(0), la.blend_if.get(0));
+ assert_eq!(lc.blend_if.ranges.len(), 1, "no RGB channel range on CMYK");
+ assert_eq!(lc.excluded_channels, 0);
+}
+
+#[test]
+fn paste_layer_style_into_another_mode_keeps_blend_if_normalised() {
+ // A full Gray range and only a Red range: in CMYK nothing is left, so it is the default
+ // (which compares equal, so the paste isn't seen as a Blend If change).
+ let mut s = Session::new();
+ let (a, _) = new_doc(&mut s, "rgb");
+ s.execute("layer.layerStyle.blendingOptions", json!({"layer": a, "blendIf": [{"channel": "red", "thisLayer": [10, 200]}]})).unwrap();
+ s.execute("layer.layerStyle.copyLayerStyle", json!({"layer": a})).unwrap();
+ let (c, _) = new_doc(&mut s, "cmyk");
+ s.execute("layer.layerStyle.pasteLayerStyle", json!({"layer": c})).unwrap();
+ assert_eq!(layer(&s, c).blend_if, photocraft_doc::BlendIf::default());
+}
+
+#[test]
+fn paste_layer_style_on_several_layers_is_one_undo_step() {
+ // 16-bit, onto a pixel layer and a group: one History step, and one Undo restores both.
+ let mut s = Session::new();
+ s.execute("file.new", json!({"width": 64, "height": 64, "depth": 16, "background": "white"})).unwrap();
+ let a = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+ s.execute("layer.layerStyle.blendingOptions", json!({"layer": a, "blendIf": [{"channel": "gray", "underlying": [0, 128]}]})).unwrap();
+ s.execute("layer.setProps", json!({"layer": a, "fill": 0.5, "blend": "multiply"})).unwrap();
+ s.execute("layer.layerStyle.copyLayerStyle", json!({"layer": a})).unwrap();
+ let b = s.execute("layer.new.layer", json!({})).unwrap()["layer"].as_u64().unwrap();
+ let g = s.execute("layer.new.group", json!({})).unwrap()["layer"].as_u64().unwrap();
+ let before = (layer(&s, b), layer(&s, g));
+ s.execute("layer.select", json!({"layer": b})).unwrap();
+ s.execute("layer.select", json!({"layer": g, "mode": "add"})).unwrap();
+ s.execute("layer.layerStyle.pasteLayerStyle", json!({})).unwrap();
+ let la = layer(&s, a);
+ for id in [b, g] {
+ let l = layer(&s, id);
+ assert_eq!((l.blend_if.clone(), l.fill_opacity, l.blend), (la.blend_if.clone(), la.fill_opacity, la.blend), "layer {id}");
+ }
+ s.execute("edit.undo", json!({})).unwrap();
+ let after = (layer(&s, b), layer(&s, g));
+ assert_eq!((after.0.blend_if, after.0.blend, after.1.blend_if, after.1.blend), (before.0.blend_if, before.0.blend, before.1.blend_if, before.1.blend));
+ assert_eq!((after.0.fill_opacity, after.1.fill_opacity), (before.0.fill_opacity, before.1.fill_opacity));
+}
+
+#[test]
+fn several_layers_align_to_an_active_selection() {
+ let mut s = Session::new();
+ let (a, b) = new_doc(&mut s, "rgb");
+ for (id, x) in [(a, 4), (b, 30)] {
+ s.execute("layer.select", json!({"layer": id})).unwrap();
+ s.execute("select.rect", json!({"x": x, "y": 10, "width": 8, "height": 8})).unwrap();
+ s.execute("edit.fill", json!({"color": "#ff0000"})).unwrap();
+ }
+ s.execute("select.rect", json!({"x": 40, "y": 40, "width": 20, "height": 20})).unwrap();
+ s.execute("layer.select", json!({"layer": a})).unwrap();
+ s.execute("layer.select", json!({"layer": b, "mode": "add"})).unwrap();
+ s.execute("layer.align.leftEdges", json!({})).unwrap();
+ for id in [a, b] {
+ let x0 = layer(&s, id).surface().unwrap().content_bounds().x0;
+ assert_eq!(x0, 40, "layer {id} aligned to the selection's left edge");
+ }
+}
diff --git a/crates/format/Cargo.toml b/crates/format/Cargo.toml
index 45d7a4ccf3..113d9ba026 100644
--- a/crates/format/Cargo.toml
+++ b/crates/format/Cargo.toml
@@ -22,7 +22,7 @@ flate2 = { workspace = true }
# Same IEEE CRC-32 the ZIP container needs; already in Cargo.lock through flate2.
crc32fast = "1.5"
blake3 = { version = "1.8", default-features = false, features = ["pure"] }
-ruzstd = "0.9"
+ruzstd = "0.9.1"
# Unix directory cleanup uses no-follow descriptor-relative operations; the same
# dependency provides the plain-fsync fallback on Apple file systems.
diff --git a/crates/format/src/convert.rs b/crates/format/src/convert.rs
index 51d6183baa..95d45fafb9 100644
--- a/crates/format/src/convert.rs
+++ b/crates/format/src/convert.rs
@@ -617,6 +617,15 @@ impl Loader<'_> {
}
}
}
+ // Variable targets follow their layers through id remapping; a dangling one keeps a
+ // non-colliding placeholder so it stays a missing-layer skip rather than driving an
+ // unrelated layer (#4969). With preserved ids the map is the identity and defs stay as saved.
+ let mut variables = m.variables.clone();
+ if !self.preserve_ids {
+ for vd in &mut variables.defs {
+ vd.layer = self.id_map.get(&vd.layer.0).copied().unwrap_or(LayerId(u64::MAX - vd.layer.0.min(u64::MAX / 2)));
+ }
+ }
let id = if self.preserve_ids { DocId(m.id) } else { DocId::fresh() };
Ok(Document {
id,
@@ -641,7 +650,7 @@ impl Loader<'_> {
patterns,
color_table: m.color_table.clone(),
duotone: m.duotone.clone(),
- variables: m.variables.clone(),
+ variables,
timeline: m.timeline.clone(),
file_encoding: m.file_encoding,
layer_comps,
diff --git a/crates/format/tests/roundtrip.rs b/crates/format/tests/roundtrip.rs
index 8b74a00c4b..f78e93947e 100644
--- a/crates/format/tests/roundtrip.rs
+++ b/crates/format/tests/roundtrip.rs
@@ -5,7 +5,7 @@ use common::*;
use photocraft_color::{ColorMode, SampleType};
use photocraft_doc::text::{CharStyle, ParagraphStyle, TextRun};
use photocraft_doc::text_styles::{CharacterStyleDef, ParagraphStyleDef};
-use photocraft_doc::{Document, Layer, LayerContent, LayerId, Slice, TextLayer};
+use photocraft_doc::{Document, Layer, LayerContent, LayerId, Slice, TextLayer, VarKind, VariableDef};
use photocraft_format::*;
use photocraft_raster::Rgba8Image;
@@ -729,3 +729,25 @@ fn a_non_finite_float_is_refused_at_save_rather_than_breaking_every_later_load()
let back = load_from_bytes(&save_to_bytes(&doc, &SaveOptions::default()).unwrap()).unwrap();
assert_eq!(back, doc);
}
+
+#[test]
+fn variables_follow_layer_id_remapping() {
+ let mut doc = rich_doc(ColorMode::Rgb, SampleType::U8);
+ let id_of = |d: &Document, name: &str| d.walk().into_iter().find(|(_, _, l)| l.name == name).unwrap().2.id;
+ doc.variables.defs = vec![
+ VariableDef { name: "head".into(), layer: id_of(&doc, "Paint"), kind: VarKind::TextReplacement },
+ VariableDef { name: "badge".into(), layer: id_of(&doc, "Inner"), kind: VarKind::Visibility },
+ VariableDef { name: "gone".into(), layer: LayerId(u64::MAX), kind: VarKind::Visibility },
+ ];
+ let bytes = save_to_bytes(&doc, &SaveOptions::default()).unwrap();
+ // Preserved ids keep every definition exactly as saved, dangling ones included.
+ assert_eq!(load_from_bytes(&bytes).unwrap(), doc);
+ // Remapped ids carry the definitions to the copied layers; a dangling target stays
+ // dangling and must not collide with a live layer (#4969).
+ let back = load_from_bytes_with(&bytes, &LoadOptions { preserve_ids: false, ..Default::default() }).unwrap();
+ let defs = &back.variables.defs;
+ assert_eq!(defs.iter().find(|d| d.name == "head").unwrap().layer, id_of(&back, "Paint"));
+ assert_eq!(defs.iter().find(|d| d.name == "badge").unwrap().layer, id_of(&back, "Inner"));
+ let gone = defs.iter().find(|d| d.name == "gone").unwrap().layer;
+ assert!(back.walk().into_iter().all(|(_, _, l)| l.id != gone), "dangling target must not address a live layer");
+}
diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index 1a6b60fca3..0e76736013 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -46,7 +46,12 @@ impl Rect {
Self { x0, y0, x1, y1 }
}
pub fn from_xywh(x: i32, y: i32, w: u32, h: u32) -> Self {
- Self::new(x, y, x.saturating_add(w as i32), y.saturating_add(h as i32))
+ // Widen before adding: `w as i32` wraps negative for widths above `i32::MAX`, which
+ // would turn the far edge backwards (an empty, inverted rect) instead of clamping it
+ // to `i32::MAX` the way `saturating_add` alone would suggest.
+ let x1 = (i64::from(x) + i64::from(w)).min(i64::from(i32::MAX)) as i32;
+ let y1 = (i64::from(y) + i64::from(h)).min(i64::from(i32::MAX)) as i32;
+ Self::new(x, y, x1, y1)
}
pub fn from_size(size: Size) -> Self {
Self::from_xywh(0, 0, size.width, size.height)
@@ -117,7 +122,9 @@ impl TileCoord {
Self::new(x.div_euclid(TILE_SIZE), y.div_euclid(TILE_SIZE))
}
pub fn rect(&self) -> Rect {
- Rect::from_xywh(self.tx * TILE_SIZE, self.ty * TILE_SIZE, TILE_SIZE as u32, TILE_SIZE as u32)
+ // `tx`/`ty` can come from a file (this type is deserialized), so saturate instead of
+ // overflowing (a debug-build panic / release-build wrap) on extreme coordinates.
+ Rect::from_xywh(self.tx.saturating_mul(TILE_SIZE), self.ty.saturating_mul(TILE_SIZE), TILE_SIZE as u32, TILE_SIZE as u32)
}
}
@@ -258,6 +265,25 @@ mod tests {
assert_eq!(grown.y0, i32::MIN);
}
+ #[test]
+ fn from_xywh_clamps_huge_sizes_instead_of_wrapping() {
+ // Widths above `i32::MAX` used to wrap negative through `w as i32`, producing an
+ // empty inverted rect instead of clamping the far edge to `i32::MAX`.
+ assert_eq!(Rect::from_xywh(0, 0, u32::MAX, 10), Rect::new(0, 0, i32::MAX, 10));
+ assert_eq!(Rect::from_xywh(-100, 5, u32::MAX, u32::MAX), Rect::new(-100, 5, i32::MAX, i32::MAX));
+ assert_eq!(Rect::from_xywh(10, 20, i32::MAX as u32 + 1, 40).width(), i32::MAX as u32 - 10);
+ // Ordinary sizes are unchanged.
+ assert_eq!(Rect::from_xywh(10, 20, 30, 40), Rect::new(10, 20, 40, 60));
+ }
+
+ #[test]
+ fn tile_rect_saturates_on_extreme_coords() {
+ // Tile coords are deserialized from files; `tx * TILE_SIZE` used to overflow.
+ let r = TileCoord::new(i32::MAX, i32::MIN).rect();
+ assert_eq!((r.x0, r.y0), (i32::MAX, i32::MIN));
+ assert_eq!(TileCoord::new(2, -3).rect(), Rect::new(512, -768, 768, -512));
+ }
+
#[test]
fn width_and_height_do_not_overflow_on_extreme_edges() {
// Inverted extreme rect: empty, so 0 (x1 - x0 used to overflow and panic).
diff --git a/crates/gpu/src/fx.rs b/crates/gpu/src/fx.rs
index 2149aaa412..01e147d51a 100644
--- a/crates/gpu/src/fx.rs
+++ b/crates/gpu/src/fx.rs
@@ -579,10 +579,12 @@ pub(crate) fn paste(shape: &mut [f32], region: Rect, r: Rect, v: &[f32]) {
// ---------------------------------------------------------------------------------------------
// Shape identity and damage
-pub(crate) type Tiles = HashMap>;
+/// A shape source's tiles by address: a [`std::sync::Weak`] reserves the address (so a new tile
+/// can't reuse it and pass for unchanged) without keeping the pixels alive (#4530).
+pub(crate) type Tiles = HashMap>;
pub(crate) fn snapshot(s: &Surface) -> Tiles {
- s.tiles().map(|(c, t)| (*c, t.clone())).collect()
+ s.tiles().map(|(c, t)| (*c, Arc::downgrade(t))).collect()
}
/// Union of the tiles that differ between `old` and `s`.
@@ -590,7 +592,7 @@ pub(crate) fn damage(old: &Tiles, s: &Surface) -> Rect {
let mut d = Rect::EMPTY;
let mut add = |r: Rect| d = if d.is_empty() { r } else { d.union(&r) };
for (c, t) in s.tiles() {
- if old.get(c).is_none_or(|o| !Arc::ptr_eq(o, t)) {
+ if old.get(c).is_none_or(|o| !std::ptr::eq(o.as_ptr(), Arc::as_ptr(t))) {
add(c.rect());
}
}
@@ -642,39 +644,42 @@ pub(crate) fn shape_key(layer: &Layer, canvas: Rect) -> u64 {
h.finish()
}
-/// Deep identity of a group (children, their pixels by tile pointer, settings).
-pub(crate) fn group_key(layer: &Layer, light: &GlobalLight) -> u64 {
- fn surface_fp(s: &Surface, h: &mut std::collections::hash_map::DefaultHasher) {
+/// Deep identity of a group (children, their pixels by tile pointer, settings). `pin` sees every
+/// tile hashed, so a cache entry can reserve their addresses (see [`Tiles`]).
+pub(crate) fn group_key(layer: &Layer, light: &GlobalLight, pin: &mut dyn FnMut(&Arc)) -> u64 {
+ type Pin<'a> = &'a mut dyn FnMut(&Arc);
+ fn surface_fp(s: &Surface, h: &mut std::collections::hash_map::DefaultHasher, pin: Pin) {
format!("{:?}{:?}", s.format(), s.default_pixel()).hash(h);
for (c, t) in s.tiles() {
+ pin(t);
(c.tx, c.ty, Arc::as_ptr(t) as usize).hash(h);
}
}
- fn walk(l: &Layer, h: &mut std::collections::hash_map::DefaultHasher) {
+ fn walk(l: &Layer, h: &mut std::collections::hash_map::DefaultHasher, pin: Pin) {
l.id.0.hash(h);
(l.visible, l.clipped, l.opacity.to_bits(), l.fill_opacity.to_bits(), format!("{:?}", l.blend)).hash(h);
match &l.content {
LayerContent::Group(g) => {
for c in &g.children {
- walk(c, h);
+ walk(c, h, pin);
}
}
LayerContent::Fill(f) => {
format!("{f:?}").hash(h);
if let Some(c) = &l.fill_cache {
- surface_fp(&c.surface, h);
+ surface_fp(&c.surface, h, pin);
}
}
LayerContent::Adjustment(a) => format!("{a:?}").hash(h),
_ => {
if let Some(s) = l.surface() {
- surface_fp(s, h);
+ surface_fp(s, h, pin);
}
}
}
if let Some(m) = &l.mask {
(m.enabled, m.density.to_bits(), m.feather.to_bits()).hash(h);
- surface_fp(&m.surface, h);
+ surface_fp(&m.surface, h, pin);
}
format!("{:?}{:?}", l.vector_mask, l.effects).hash(h);
h.write_u8(0xfe);
@@ -684,14 +689,14 @@ pub(crate) fn group_key(layer: &Layer, light: &GlobalLight) -> u64 {
match &layer.content {
LayerContent::Group(g) => {
for c in &g.children {
- walk(c, &mut h);
+ walk(c, &mut h, pin);
}
if let Some(m) = &layer.mask {
(m.enabled, m.density.to_bits(), m.feather.to_bits()).hash(&mut h);
- surface_fp(&m.surface, &mut h);
+ surface_fp(&m.surface, &mut h, pin);
}
}
- _ => walk(layer, &mut h),
+ _ => walk(layer, &mut h, pin),
}
h.finish()
}
@@ -874,4 +879,39 @@ mod tests {
let shadow = program(&Effect::DropShadow(s), &light, false);
assert!(shadow.fields.iter().any(|(k, _)| *k == FieldKind::StrokeOutside), "the shadow spread keeps the chamfer: {:?}", shadow.fields);
}
+
+ /// Cached shapes and group keys reserve tile addresses without keeping pixels (#4530):
+ /// damage still tells a replaced tile from an unchanged one, and a dropped tile's pixels
+ /// are freed although the entry remembers it.
+ #[test]
+ fn shape_tiles_and_group_pins_hold_addresses_not_pixels() {
+ use photocraft_color::{ColorMode, PixelFormat, SampleType};
+ let fmt = PixelFormat::new(ColorMode::Rgb, SampleType::U8, true);
+ let mut s = Surface::new(fmt);
+ // A ramp, so no two tiles share their pixels.
+ for x in 0..600 {
+ let v = x as f32 / 600.0;
+ s.fill_rect(Rect::new(x, 0, x + 1, 300), &[v, 0.2, 0.9, 1.0]);
+ }
+ let first = s.tiles().find(|(c, _)| c.tx == 0 && c.ty == 0).map(|(_, t)| t.clone()).unwrap();
+ assert_eq!(Arc::strong_count(&first), 2);
+ let old = snapshot(&s);
+ assert_eq!(Arc::strong_count(&first), 2, "the snapshot adds no strong reference");
+ assert!(damage(&old, &s).is_empty());
+ s.fill_rect(Rect::new(0, 0, 4, 4), &[0.0, 0.0, 0.0, 1.0]);
+ let origin = s.tiles().map(|(c, _)| *c).find(|c| c.tx == 0 && c.ty == 0).unwrap();
+ assert_eq!(damage(&old, &s), origin.rect(), "only the edited tile");
+ drop(first);
+ assert!(old.values().any(|w| w.strong_count() == 0), "the replaced tile's pixels are freed");
+
+ let child = Layer::new("c", LayerContent::Raster(s));
+ let n = child.surface().map_or(0, |s| s.tile_count());
+ let group = Layer::group("g", vec![child]);
+ let mut pins = Vec::new();
+ let key = group_key(&group, &GlobalLight::default(), &mut |t| pins.push(Arc::downgrade(t)));
+ assert_eq!(key, group_key(&group, &GlobalLight::default(), &mut |_| {}), "pinning doesn't change the key");
+ assert_eq!(pins.len(), n);
+ drop(group);
+ assert!(pins.iter().all(|w| w.strong_count() == 0), "a group's pins keep none of its pixels");
+ }
}
diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rs
index de6ca3e56e..8f8839b9bd 100644
--- a/crates/gpu/src/lib.rs
+++ b/crates/gpu/src/lib.rs
@@ -49,7 +49,7 @@ use std::sync::Arc;
use photocraft_color::{PixelFormat, SampleType};
use photocraft_compose::effects::FieldKind;
-use photocraft_doc::{DocId, Document, Layer, LayerContent, LayerId, Pattern};
+use photocraft_doc::{DocId, Document, LayerContent, LayerId, Pattern};
use photocraft_geom::{Rect, TILE_SIZE, TileCoord};
use photocraft_raster::{Surface, Tile};
@@ -303,8 +303,8 @@ struct FxEntry {
shape_key: u64,
/// Tiles the shape was rendered from (content, mask): damage is their difference.
tiles: [Option; 2],
- /// Groups: a clone pinning the tile pointers `shape_key` hashes.
- _pin: Option,
+ /// Groups: the tiles `shape_key` hashes, by address only (see [`fx::Tiles`]).
+ _pin: Vec>,
/// The shape on the CPU (distance fields are computed from it) and on the GPU.
shape_cpu: Vec,
shape: Tex,
@@ -1719,7 +1719,7 @@ impl Compositor {
let layer = f.layer;
let canvas = doc.bounds();
let is_group = matches!(layer.content, LayerContent::Group(_));
- let shape_key = if is_group { fx::group_key(layer, &doc.global_light) } else { fx::shape_key(layer, canvas) };
+ let shape_key = if is_group { fx::group_key(layer, &doc.global_light, &mut |_| {}) } else { fx::shape_key(layer, canvas) };
let (content_src, mask_src) = if is_group { (None, None) } else { fx::shape_sources(layer) };
let frame = self.frame;
let (rw, rh) = (region.width(), region.height());
@@ -1767,7 +1767,13 @@ impl Compositor {
region,
shape_key,
tiles: [None, None],
- _pin: is_group.then(|| layer.clone()),
+ _pin: if is_group {
+ let mut pin = Vec::new();
+ fx::group_key(layer, &doc.global_light, &mut |t| pin.push(Arc::downgrade(t)));
+ pin
+ } else {
+ Vec::new()
+ },
shape_cpu: vec![0.0; n],
shape,
fields: HashMap::new(),
diff --git a/crates/heif/src/lib.rs b/crates/heif/src/lib.rs
index ae3aff5a74..7c88fc1b9c 100644
--- a/crates/heif/src/lib.rs
+++ b/crates/heif/src/lib.rs
@@ -5,6 +5,9 @@
//! EXIF and XMP. Its API is plain data ([`Info`], [`Decoded`], [`Error`]) so the crate knows
//! nothing about the rest of PhotoCraft; `photocraft-codecs` adapts it behind its `heif` feature.
//!
+//! A grid's ICC profile is inherited from its tiles when the grid item itself carries no `colr`,
+//! which is how phone cameras write it: see [`icc_for_item`].
+//!
//! HEIF records orientation in the container (`irot`/`imir`, plus a `clap` crop), not in EXIF.
//! [`Options::apply_transforms`] applies them; with it off, the pixels come back as coded.
//!
@@ -163,7 +166,7 @@ fn metadata(bytes: &[u8]) -> (Option>, Option>, Option)
return (None, None, None);
};
let id = ctx.meta.primary;
- let icc = ctx.props(id).ok().and_then(|p| ctx.icc(&p).map(<[u8]>::to_vec));
+ let icc = icc_for_item(&ctx, id);
let exif = ctx.exif(id).ok().flatten().map(<[u8]>::to_vec);
let xmp = ctx.xmp_item(id).and_then(|x| ctx.item_data(x).ok()).and_then(|d| match d {
Cow::Borrowed(b) => String::from_utf8(b.to_vec()).ok(),
@@ -172,6 +175,28 @@ fn metadata(bytes: &[u8]) -> (Option>, Option>, Option)
(icc, exif, xmp.map(|x| x.trim_end_matches('\0').to_string()))
}
+/// The ICC profile describing `item`, inherited from the coded tiles when the item itself carries
+/// none.
+///
+/// `colr` is optional on a `grid` derivation, and phone cameras write it on the tiles instead: a
+/// OnePlus 11 photograph carries one `prof` (Display P3) on each of its 48 `hvc1` tiles and
+/// nothing on the grid. Asking the primary item alone therefore loses the profile and the photo
+/// opens as if it were sRGB. The tiles are what the mosaic is composed from, so their profile is
+/// the composed image's profile.
+///
+/// heic-rs resolves `nclx` from the primary item in the same way and has the same gap
+/// (tbraun96/heic-rs#6). The sample range cannot be recovered here as well: `DecodeOptions` has no
+/// override for it, so that half has to be fixed upstream.
+fn icc_for_item(ctx: &heic_rs::context::Context<'_>, item: u32) -> Option> {
+ let own = ctx.props(item).ok().and_then(|p| ctx.icc(&p).map(<[u8]>::to_vec));
+ if own.is_some() {
+ return own;
+ }
+ // `Ok(None)` is a coded picture rather than a derivation: no tiles to inherit from.
+ let (_, tiles) = ctx.grid(item).ok()??;
+ tiles.iter().find_map(|&t| ctx.props(t).ok().and_then(|p| ctx.icc(&p).map(<[u8]>::to_vec)))
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -215,4 +240,200 @@ mod tests {
assert!(Error::Limit("x".into()).to_string().contains("limit"));
assert!(Error::Malformed("x".into()).to_string().contains("malformed"));
}
+
+ // A grid whose colour description lives on its tiles, not on the grid item.
+ //
+ // The fixtures below are synthetic containers with no coded data at all: resolving a profile
+ // never decodes a pixel. Each test first asserts the fixture is the shape it claims to be, so
+ // a mistake in the builder cannot look like a passing fix.
+
+ /// Stands in for a profile. `colr` hands its payload back without parsing it.
+ const TILE_ICC: &[u8] = b"tile-profile";
+ const GRID_ICC: &[u8] = b"grid-profile";
+
+ const GRID_ID: u16 = 1;
+ const PICTURE_ID: u16 = 2;
+
+ fn bx(kind: &[u8; 4], payload: &[u8]) -> Vec {
+ let mut v = u32::try_from(payload.len() + 8).unwrap().to_be_bytes().to_vec();
+ v.extend_from_slice(kind);
+ v.extend_from_slice(payload);
+ v
+ }
+
+ /// A box whose first four payload bytes are a version and 24 bits of flags.
+ fn full(kind: &[u8; 4], version: u8, payload: &[u8]) -> Vec {
+ let mut p = vec![version, 0, 0, 0];
+ p.extend_from_slice(payload);
+ bx(kind, &p)
+ }
+
+ fn hdlr() -> Vec {
+ let mut p = vec![0; 4];
+ p.extend_from_slice(b"pict");
+ p.extend_from_slice(&[0; 12]);
+ p.push(0);
+ full(b"hdlr", 0, &p)
+ }
+
+ fn infe(id: u16, item_type: &[u8; 4]) -> Vec {
+ let mut p = id.to_be_bytes().to_vec();
+ p.extend_from_slice(&0u16.to_be_bytes());
+ p.extend_from_slice(item_type);
+ p.push(0);
+ full(b"infe", 2, &p)
+ }
+
+ fn iref_dimg(from: u16, to: u16) -> Vec {
+ let mut p = from.to_be_bytes().to_vec();
+ p.extend_from_slice(&1u16.to_be_bytes());
+ p.extend_from_slice(&to.to_be_bytes());
+ full(b"iref", 0, &bx(b"dimg", &p))
+ }
+
+ fn colr_prof(icc: &[u8]) -> Vec {
+ let mut p = b"prof".to_vec();
+ p.extend_from_slice(icc);
+ bx(b"colr", &p)
+ }
+
+ fn ispe(w: u32, h: u32) -> Vec {
+ let mut p = w.to_be_bytes().to_vec();
+ p.extend_from_slice(&h.to_be_bytes());
+ full(b"ispe", 0, &p)
+ }
+
+ fn ipma(entries: &[(u16, &[u8])]) -> Vec {
+ let mut p = u32::try_from(entries.len()).unwrap().to_be_bytes().to_vec();
+ for (item, assoc) in entries {
+ p.extend_from_slice(&item.to_be_bytes());
+ p.push(u8::try_from(assoc.len()).unwrap());
+ p.extend_from_slice(assoc);
+ }
+ full(b"ipma", 0, &p)
+ }
+
+ /// `item`'s bytes live in `idat` (construction method 1) at offset 0.
+ fn iloc_in_idat(item: u16, length: u32) -> Vec {
+ let mut p = vec![0x44, 0x00];
+ p.extend_from_slice(&1u16.to_be_bytes());
+ p.extend_from_slice(&item.to_be_bytes());
+ p.extend_from_slice(&1u16.to_be_bytes());
+ p.extend_from_slice(&0u16.to_be_bytes());
+ p.extend_from_slice(&1u16.to_be_bytes());
+ p.extend_from_slice(&0u32.to_be_bytes());
+ p.extend_from_slice(&length.to_be_bytes());
+ full(b"iloc", 1, &p)
+ }
+
+ fn file(meta: &[u8]) -> Vec {
+ let mut ftyp = b"heic".to_vec();
+ ftyp.extend_from_slice(&0u32.to_be_bytes());
+ ftyp.extend_from_slice(b"mif1heic");
+ let mut out = bx(b"ftyp", &ftyp);
+ out.extend_from_slice(&full(b"meta", 0, meta));
+ out
+ }
+
+ /// A 1x1 64x64 grid, with `grid_icc` on the grid item and `tile_icc` on its single tile.
+ ///
+ /// `ipco` children are numbered from 1 in file order; an association byte's top bit marks the
+ /// property essential, as macOS writes it.
+ fn grid_file(grid_icc: Option<&[u8]>, tile_icc: Option<&[u8]>) -> Vec {
+ let mut ipco = ispe(64, 64);
+ let (mut grid_assoc, mut tile_assoc, mut index) = (vec![0x81], vec![0x81], 1u8);
+ if let Some(icc) = grid_icc {
+ index += 1;
+ ipco.extend_from_slice(&colr_prof(icc));
+ grid_assoc.push(0x80 | index);
+ }
+ if let Some(icc) = tile_icc {
+ index += 1;
+ ipco.extend_from_slice(&colr_prof(icc));
+ tile_assoc.push(0x80 | index);
+ }
+ let mut iprp = bx(b"ipco", &ipco);
+ iprp.extend_from_slice(&ipma(&[(GRID_ID, grid_assoc.as_slice()), (PICTURE_ID, tile_assoc.as_slice())]));
+
+ let mut items = 2u16.to_be_bytes().to_vec();
+ items.extend_from_slice(&infe(GRID_ID, b"grid"));
+ items.extend_from_slice(&infe(PICTURE_ID, b"hvc1"));
+
+ // Version 0, flags 0, one row, one column, 64x64 output.
+ const DESCRIPTOR: &[u8] = &[0, 0, 0, 0, 0, 64, 0, 64];
+
+ let mut meta = hdlr();
+ meta.extend_from_slice(&full(b"pitm", 0, &GRID_ID.to_be_bytes()));
+ meta.extend_from_slice(&full(b"iinf", 0, &items));
+ meta.extend_from_slice(&iref_dimg(GRID_ID, PICTURE_ID));
+ meta.extend_from_slice(&bx(b"iprp", &iprp));
+ meta.extend_from_slice(&bx(b"idat", DESCRIPTOR));
+ meta.extend_from_slice(&iloc_in_idat(GRID_ID, u32::try_from(DESCRIPTOR.len()).unwrap()));
+ file(&meta)
+ }
+
+ /// One coded picture rather than a derivation, with `icc` on the item itself.
+ fn picture_file(icc: Option<&[u8]>) -> Vec {
+ let mut ipco = ispe(64, 64);
+ let mut assoc = vec![0x81];
+ if let Some(icc) = icc {
+ ipco.extend_from_slice(&colr_prof(icc));
+ assoc.push(0x82);
+ }
+ let mut iprp = bx(b"ipco", &ipco);
+ iprp.extend_from_slice(&ipma(&[(PICTURE_ID, assoc.as_slice())]));
+
+ let mut items = 1u16.to_be_bytes().to_vec();
+ items.extend_from_slice(&infe(PICTURE_ID, b"hvc1"));
+
+ let mut meta = hdlr();
+ meta.extend_from_slice(&full(b"pitm", 0, &PICTURE_ID.to_be_bytes()));
+ meta.extend_from_slice(&full(b"iinf", 0, &items));
+ meta.extend_from_slice(&bx(b"iprp", &iprp));
+ file(&meta)
+ }
+
+ fn ctx_of(bytes: &[u8]) -> heic_rs::context::Context<'_> {
+ heic_rs::context::Context::open(bytes).expect("the synthetic container must parse")
+ }
+
+ #[test]
+ fn a_grid_inherits_its_tiles_icc_profile() {
+ let bytes = grid_file(None, Some(TILE_ICC));
+ let ctx = ctx_of(&bytes);
+ let primary = ctx.meta.primary;
+ assert_eq!(primary, u32::from(GRID_ID));
+ let (grid, tiles) = ctx.grid(primary).unwrap().expect("a grid derivation");
+ assert_eq!((grid.rows, grid.columns, tiles.len()), (1, 1, 1));
+ assert!(ctx.icc(&ctx.props(primary).unwrap()).is_none(), "the grid item carries no colr of its own");
+ assert_eq!(ctx.icc(&ctx.props(tiles[0]).unwrap()), Some(TILE_ICC), "the tile carries the profile");
+
+ assert_eq!(icc_for_item(&ctx, primary).as_deref(), Some(TILE_ICC));
+ }
+
+ #[test]
+ fn a_grids_own_profile_wins_over_its_tiles() {
+ let bytes = grid_file(Some(GRID_ICC), Some(TILE_ICC));
+ let ctx = ctx_of(&bytes);
+ assert_eq!(icc_for_item(&ctx, ctx.meta.primary).as_deref(), Some(GRID_ICC));
+ }
+
+ #[test]
+ fn an_unlabelled_grid_has_no_profile() {
+ let bytes = grid_file(None, None);
+ let ctx = ctx_of(&bytes);
+ assert_eq!(icc_for_item(&ctx, ctx.meta.primary), None);
+ }
+
+ #[test]
+ fn a_coded_picture_resolves_its_own_profile() {
+ let labelled = picture_file(Some(GRID_ICC));
+ let ctx = ctx_of(&labelled);
+ assert!(ctx.grid(ctx.meta.primary).unwrap().is_none(), "not a derivation");
+ assert_eq!(icc_for_item(&ctx, ctx.meta.primary).as_deref(), Some(GRID_ICC));
+
+ let bare = picture_file(None);
+ let ctx = ctx_of(&bare);
+ assert_eq!(icc_for_item(&ctx, ctx.meta.primary), None);
+ }
}
diff --git a/crates/io/src/flat.rs b/crates/io/src/flat.rs
index 54fe96090d..f61c28a40b 100644
--- a/crates/io/src/flat.rs
+++ b/crates/io/src/flat.rs
@@ -206,6 +206,7 @@ pub(crate) fn image_to_document(name: &str, img: &Image) -> Result (ColorMode::Grayscale, ChannelLayout::GrayA),
ChannelLayout::Rgb | ChannelLayout::Rgba => (ColorMode::Rgb, ChannelLayout::Rgba),
ChannelLayout::Cmyk | ChannelLayout::CmykA => (ColorMode::Cmyk, ChannelLayout::CmykA),
+ ChannelLayout::Lab | ChannelLayout::LabA => (ColorMode::Lab, ChannelLayout::LabA),
};
let (depth, csample) = match img.sample_type() {
CSample::U8 => (SampleType::U8, CSample::U8),
@@ -249,6 +250,7 @@ pub(crate) fn image_surface(img: &Image, target_layout: ChannelLayout, csample:
let mode = match target_layout {
ChannelLayout::Gray | ChannelLayout::GrayA => ColorMode::Grayscale,
ChannelLayout::Cmyk | ChannelLayout::CmykA => ColorMode::Cmyk,
+ ChannelLayout::Lab | ChannelLayout::LabA => ColorMode::Lab,
_ => ColorMode::Rgb,
};
let depth = match csample {
@@ -301,6 +303,8 @@ pub(crate) fn layout_for(mode: ColorMode, alpha: bool) -> ChannelLayout {
(ColorMode::Grayscale, true) => ChannelLayout::GrayA,
(ColorMode::Cmyk, false) => ChannelLayout::Cmyk,
(ColorMode::Cmyk, true) => ChannelLayout::CmykA,
+ (ColorMode::Lab, false) => ChannelLayout::Lab,
+ (ColorMode::Lab, true) => ChannelLayout::LabA,
(_, false) => ChannelLayout::Rgb,
(_, true) => ChannelLayout::Rgba,
}
@@ -316,18 +320,19 @@ pub(crate) fn csample(s: SampleType) -> CSample {
/// Renders the document to a flat codec image (native pixels when possible).
pub fn document_to_image(doc: &Document, warnings: &mut Vec) -> Result {
- document_to_image_for(doc, warnings, true)
+ document_to_image_for(doc, warnings, true, false)
}
-fn document_to_image_for(doc: &Document, warnings: &mut Vec, cmyk_target: bool) -> Result {
+/// `cmyk_target` / `lab_target`: the format stores CMYK / Lab pixels.
+fn document_to_image_for(doc: &Document, warnings: &mut Vec, cmyk_target: bool, lab_target: bool) -> Result {
let (w, h) = (doc.size.width, doc.size.height);
let canvas = doc.bounds();
let fmt = doc.pixel_format();
let n = (w as usize) * (h as usize);
- // Lab has no flat-format layout here: Lab documents always go through the composite, which
- // flattens nothing when there is a single plain layer.
+ // A Lab document keeps its pixels only for a format that stores Lab (TIFF); for the others it
+ // goes through the sRGB composite, which flattens nothing when there is a single plain layer.
let single = single_layer(doc);
- let native = single.filter(|_| fmt.mode != ColorMode::Lab);
+ let native = single.filter(|_| fmt.mode != ColorMode::Lab || lab_target);
let mut icc = doc.icc_profile.as_ref().map(|i| i.to_vec());
let img = if let Some(s) = native {
// Native path: keep model and depth. The surface's encoded samples are the codec's raw
@@ -526,7 +531,8 @@ pub(crate) fn export_flat_with(doc: &Document, format: Format, opts: &ExportOpti
}
let mut warnings = Vec::new();
let cmyk_target = format.caps().layouts.iter().any(|layout| layout.is_cmyk());
- let mut img = document_to_image_for(doc, &mut warnings, cmyk_target)?;
+ let lab_target = format.caps().layouts.iter().any(|layout| layout.is_lab());
+ let mut img = document_to_image_for(doc, &mut warnings, cmyk_target, lab_target)?;
ctl.check().map_err(|_| IoError::Cancelled)?;
ctl.progress(composite_share(format));
if opts.xmp == XmpEmbed::None {
diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs
index 49e4bb60e2..a620ddcf33 100644
--- a/crates/io/src/lib.rs
+++ b/crates/io/src/lib.rs
@@ -51,6 +51,7 @@ mod multichannel_map;
mod ora;
pub use ora::losses as ora_losses;
pub mod pattern_map;
+pub mod pdf;
mod pdn;
pub mod pixels;
mod psd_export;
@@ -273,13 +274,14 @@ fn import_stages(name: &str, bytes: &[u8], ctl: &photocraft_raster::Interrupt, m
return Ok(ImportResult { document: photocraft_format::load_from_bytes(bytes)?, warnings: Vec::new(), source_read_only: false, preview_only: false });
}
if is_psd(bytes) {
- let file = PsdFile::from_bytes(bytes)?;
+ // A merged image the import reads is decoded with the parse: a ZIP one is inflated once.
+ let (file, merged) = PsdFile::from_bytes_and_merged(bytes, |f| psd_import::check_group_depth(f).is_ok() && psd_import::merged_needed(f))?;
// Nesting past the document model's cap could never be saved; reject the file with the
// actionable limit.
psd_import::check_group_depth(&file)?;
ctl.check().map_err(|_| IoError::Cancelled)?;
ctl.progress(0.05);
- let (mut document, warnings) = psd_import::psd_to_document_with(&file, ctl).ok_or(IoError::Cancelled)?;
+ let (mut document, warnings) = psd_import::psd_to_document_decoded(&file, ctl, merged).ok_or(IoError::Cancelled)?;
document.name = name.to_string();
text_import::prepare(&mut document);
return Ok(ImportResult { document, warnings, source_read_only: false, preview_only: false });
@@ -390,6 +392,9 @@ fn export_stages(doc: &Document, name_or_ext: &str, opts: &ExportOptions, ctl: &
if ext == "ora" {
return ora::export(doc);
}
+ if ext == "pdf" {
+ return pdf::export(doc);
+ }
if ext == photocraft_format::EXTENSION {
let doc = named_for_file(doc, name_or_ext);
let thumbnail = Some(photocraft_compose::thumbnail(doc.as_ref(), 256));
diff --git a/crates/io/src/pattern_map.rs b/crates/io/src/pattern_map.rs
index 4f570bf847..bd84d9aeb1 100644
--- a/crates/io/src/pattern_map.rs
+++ b/crates/io/src/pattern_map.rs
@@ -9,7 +9,7 @@ use std::sync::Arc;
use photocraft_color::{ColorMode, PixelFormat, SampleType};
use photocraft_doc::{Document, Pattern};
use photocraft_geom::Rect;
-use photocraft_psd::patterns::{PsdPattern, block_key, mode_channels, parse_pattern_block, write_pattern_block};
+use photocraft_psd::patterns::{PatternBudget, PsdPattern, block_key, mode_channels, parse_pattern_block_with, write_pattern_block};
use photocraft_raster::Surface;
use crate::pixels::{deinterleave, interleave, max_sample, psd_depth, sample_for_depth, zero_sample};
@@ -110,13 +110,15 @@ pub fn to_psd(p: &Pattern) -> PsdPattern {
}
}
-/// Patterns decoded from the document's raw pattern blocks (malformed blocks are skipped).
+/// Patterns decoded from the document's raw pattern blocks (malformed blocks are skipped). All
+/// blocks share one memory budget, so repeating a block can't multiply it.
pub fn from_global_blocks(doc: &Document) -> Vec {
+ let mut budget = PatternBudget::default();
doc.metadata
.psd_global_blocks
.iter()
.filter(|(_, k, _)| PATTERN_KEYS.contains(k))
- .filter_map(|(_, _, d)| parse_pattern_block(d).ok())
+ .filter_map(|(_, _, d)| parse_pattern_block_with(d, &mut budget).ok())
.flatten()
.filter_map(|p| from_psd(&p))
.collect()
diff --git a/crates/io/src/pdf.rs b/crates/io/src/pdf.rs
new file mode 100644
index 0000000000..4f992bc8fd
--- /dev/null
+++ b/crates/io/src/pdf.rs
@@ -0,0 +1,219 @@
+//! The PDF writer (ISO 32000-1 basics): one raster page per file.
+//!
+//! A small, self-contained writer used by two paths: File › Save a Copy / Save As › PDF (#3401)
+//! through [`export`], and File › Print through [`print_pdf`] (called by the engine, which adds
+//! paper geometry, printer marks and labels around the image). One page holds a
+//! Flate-compressed image XObject, optional printer marks as vector operators and optional
+//! Helvetica text; an embedded ICC profile rides in an ICCBased colour space. Multi-page PDF,
+//! layer-preserving PDF and PDF import stay open (FILE-215-10).
+
+use std::io::Write as _;
+
+use photocraft_color::{ColorMode, PixelFormat};
+use photocraft_doc::Document;
+
+use crate::{ExportResult, IoError};
+
+/// The image placed on a page: 8-bit interleaved samples, 1 (gray), 3 (RGB) or 4 (CMYK,
+/// 1 = full ink), with the profile it was authored in if any.
+pub struct PrintImage {
+ pub width: u32,
+ pub height: u32,
+ pub channels: usize,
+ pub data: Vec,
+ pub icc: Option>,
+}
+
+/// Printer marks around the image.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Marks {
+ pub corner_crop: bool,
+ pub center_crop: bool,
+ pub registration: bool,
+}
+
+/// One page: paper (pt), image box (pt, origin bottom-left), marks and texts.
+pub struct PrintPage {
+ pub paper: (f64, f64),
+ pub image: PrintImage,
+ pub rect: (f64, f64, f64, f64),
+ pub marks: Marks,
+ pub description: Option,
+ pub label: Option,
+}
+
+fn pdf_string(s: &str) -> String {
+ let mut o = String::from("(");
+ for c in s.chars() {
+ match c {
+ '(' | ')' | '\\' => {
+ o.push('\\');
+ o.push(c);
+ }
+ c if c.is_ascii() && !c.is_ascii_control() => o.push(c),
+ _ => o.push('?'),
+ }
+ }
+ o.push(')');
+ o
+}
+
+fn deflate(data: &[u8]) -> Vec {
+ // Fast: print PDFs are transient and large; level 1 is ~4× quicker than the default.
+ let mut e = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::fast());
+ let _ = e.write_all(data);
+ e.finish().unwrap_or_default()
+}
+
+/// Vector marks around `(x, y, w, h)`.
+fn marks_ops(m: Marks, (x, y, w, h): (f64, f64, f64, f64)) -> String {
+ let mut s = String::from("q 0 G 0.3 w\n");
+ let (gap, len) = (6.0, 18.0);
+ let line = |s: &mut String, x0: f64, y0: f64, x1: f64, y1: f64| s.push_str(&format!("{x0:.2} {y0:.2} m {x1:.2} {y1:.2} l S\n"));
+ if m.corner_crop {
+ for (cx, cy, dx, dy) in [(x, y, -1.0, -1.0), (x + w, y, 1.0, -1.0), (x, y + h, -1.0, 1.0), (x + w, y + h, 1.0, 1.0)] {
+ line(&mut s, cx + dx * gap, cy, cx + dx * (gap + len), cy);
+ line(&mut s, cx, cy + dy * gap, cx, cy + dy * (gap + len));
+ }
+ }
+ if m.center_crop {
+ let (mx, my) = (x + w / 2.0, y + h / 2.0);
+ line(&mut s, mx, y - gap, mx, y - gap - len);
+ line(&mut s, mx, y + h + gap, mx, y + h + gap + len);
+ line(&mut s, x - gap, my, x - gap - len, my);
+ line(&mut s, x + w + gap, my, x + w + gap + len, my);
+ }
+ if m.registration {
+ let r = 5.0;
+ let off = gap + len / 2.0;
+ for (cx, cy) in [(x + w / 2.0, y - off), (x + w / 2.0, y + h + off), (x - off, y + h / 2.0), (x + w + off, y + h / 2.0)] {
+ // Circle (four Béziers) plus crosshair.
+ let k = 0.5523 * r;
+ s.push_str(&format!(
+ "{:.2} {cy:.2} m {:.2} {:.2} {:.2} {:.2} {cx:.2} {:.2} c {:.2} {:.2} {:.2} {:.2} {:.2} {cy:.2} c {:.2} {:.2} {:.2} {:.2} {cx:.2} {:.2} c {:.2} {:.2} {:.2} {:.2} {:.2} {cy:.2} c S\n",
+ cx + r, cx + r, cy + k, cx + k, cy + r, cy + r, cx - k, cy + r, cx - r, cy + k, cx - r, cx - r, cy - k, cx - k, cy - r, cy - r, cx + k, cy - r, cx + r, cy - k, cx + r
+ ));
+ line(&mut s, cx - r * 1.6, cy, cx + r * 1.6, cy);
+ line(&mut s, cx, cy - r * 1.6, cx, cy + r * 1.6);
+ }
+ }
+ s.push_str("Q\n");
+ s
+}
+
+/// A one-page PDF.
+pub fn print_pdf(page: &PrintPage) -> Vec {
+ let mut out: Vec = b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n".to_vec();
+ let mut offsets: Vec = Vec::new();
+ let mut obj = |out: &mut Vec, body: &[u8]| {
+ offsets.push(out.len());
+ out.extend_from_slice(format!("{} 0 obj\n", offsets.len()).as_bytes());
+ out.extend_from_slice(body);
+ out.extend_from_slice(b"\nendobj\n");
+ };
+ let img = &page.image;
+ let (pw, ph) = page.paper;
+ let (x, y, w, h) = page.rect;
+ // 1 catalog, 2 pages, 3 page, 4 contents, 5 image, 6 font, 7 ICC (optional).
+ obj(&mut out, b"<< /Type /Catalog /Pages 2 0 R >>");
+ obj(&mut out, b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>");
+ obj(
+ &mut out,
+ format!(
+ "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {pw:.2} {ph:.2}] /Resources << /XObject << /Im0 5 0 R >> /Font << /F1 6 0 R >> >> /Contents 4 0 R >>"
+ )
+ .as_bytes(),
+ );
+ // An explicit white page, so every viewer (and rasteriser) shows paper, not transparency.
+ let mut content = format!("q 1 g 0 0 {pw:.2} {ph:.2} re f Q\nq {w:.3} 0 0 {h:.3} {x:.3} {y:.3} cm /Im0 Do Q\n");
+ content.push_str(&marks_ops(page.marks, page.rect));
+ let any_marks = page.marks.corner_crop || page.marks.center_crop || page.marks.registration;
+ let pad = if any_marks { 30.0 } else { 6.0 };
+ if let Some(l) = page.label.as_deref().filter(|l| !l.is_empty()) {
+ content.push_str(&format!("BT /F1 8 Tf 0 g {:.2} {:.2} Td {} Tj ET\n", x, y + h + pad, pdf_string(l)));
+ }
+ if let Some(d) = page.description.as_deref().filter(|d| !d.is_empty()) {
+ content.push_str(&format!("BT /F1 8 Tf 0 g {:.2} {:.2} Td {} Tj ET\n", x, y - pad - 8.0, pdf_string(d)));
+ }
+ let c = deflate(content.as_bytes());
+ let mut body = format!("<< /Length {} /Filter /FlateDecode >>\nstream\n", c.len()).into_bytes();
+ body.extend_from_slice(&c);
+ body.extend_from_slice(b"\nendstream");
+ obj(&mut out, &body);
+ let device = match img.channels {
+ 1 => "/DeviceGray",
+ 4 => "/DeviceCMYK",
+ _ => "/DeviceRGB",
+ };
+ let cs = if img.icc.is_some() { "[/ICCBased 7 0 R]".to_string() } else { device.to_string() };
+ let z = deflate(&img.data);
+ let mut body = format!(
+ "<< /Type /XObject /Subtype /Image /Width {} /Height {} /ColorSpace {cs} /BitsPerComponent 8 /Filter /FlateDecode /Length {} >>\nstream\n",
+ img.width,
+ img.height,
+ z.len()
+ )
+ .into_bytes();
+ body.extend_from_slice(&z);
+ body.extend_from_slice(b"\nendstream");
+ obj(&mut out, &body);
+ obj(&mut out, b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");
+ if let Some(icc) = &img.icc {
+ let z = deflate(icc);
+ let mut body = format!("<< /N {} /Alternate {device} /Filter /FlateDecode /Length {} >>\nstream\n", img.channels, z.len()).into_bytes();
+ body.extend_from_slice(&z);
+ body.extend_from_slice(b"\nendstream");
+ obj(&mut out, &body);
+ }
+ let xref = out.len();
+ out.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", offsets.len() + 1).as_bytes());
+ for o in &offsets {
+ out.extend_from_slice(format!("{o:010} 00000 n \n").as_bytes());
+ }
+ out.extend_from_slice(format!("trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n", offsets.len() + 1).as_bytes());
+ out
+}
+
+/// File › Save As / Save a Copy › PDF (#3401): the flattened document, at its print size
+/// (pixels ÷ resolution × 72 pt), as a one-page PDF. Layers and transparency are dropped — the
+/// warning says so — and the embedded profile travels with the image.
+pub fn export(doc: &Document) -> std::result::Result {
+ let (w, h) = (usize::try_from(doc.size.width).unwrap_or(0), usize::try_from(doc.size.height).unwrap_or(0));
+ if w == 0 || h == 0 {
+ return Err(IoError::Unsupported("PDF needs a document with non-zero width and height; nothing was written".into()));
+ }
+ let device = match doc.mode {
+ ColorMode::Rgb => 3,
+ ColorMode::Grayscale => 1,
+ ColorMode::Cmyk => 4,
+ m => return Err(IoError::Unsupported(format!("PDF saves RGB, Grayscale and CMYK documents; {m:?} needs converting to RGB first (Image > Mode)"))),
+ };
+ let fmt = doc.pixel_format();
+ let n = fmt.channels().max(1);
+ let canvas = photocraft_geom::Rect::new(0, 0, w as i32, h as i32);
+ let surface = photocraft_compose::flatten_to_surface(doc, PixelFormat::new(fmt.mode, fmt.sample, true), None);
+ let values = surface.read_region(canvas);
+ let to8 = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
+ // Straight alpha, composited here over paper: white in RGB/Gray (1 = full light), zero ink
+ // in CMYK (0 = paper).
+ let paper = if doc.mode == ColorMode::Cmyk { 0.0 } else { 1.0 };
+ let mut data = Vec::with_capacity((w * h).saturating_mul(device));
+ for px in values.chunks(n) {
+ let a = px.last().copied().unwrap_or(1.0).clamp(0.0, 1.0);
+ for v in px.iter().take(device) {
+ data.push(to8(v * a + paper * (1.0 - a)));
+ }
+ }
+ let image = PrintImage { width: doc.size.width, height: doc.size.height, channels: device, data, icc: doc.icc_profile.as_ref().map(|p| p.to_vec()) };
+ let dpi = f64::from(doc.resolution_dpi.max(1.0));
+ let (pw, ph) = (f64::from(doc.size.width) * 72.0 / dpi, f64::from(doc.size.height) * 72.0 / dpi);
+ let page = PrintPage { paper: (pw, ph), image, rect: (0.0, 0.0, pw, ph), marks: Marks::default(), description: None, label: None };
+ let mut warnings = vec!["PDF was saved flattened: layers, masks-as-editable and transparency are not preserved (#3401)".into()];
+ if !doc.metadata.text.is_empty() {
+ warnings.push("free-form text metadata is not supported by PDF; it will be dropped".into());
+ }
+ Ok(ExportResult { bytes: print_pdf(&page), warnings })
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/io/src/pdf/tests.rs b/crates/io/src/pdf/tests.rs
new file mode 100644
index 0000000000..1807b7adc0
--- /dev/null
+++ b/crates/io/src/pdf/tests.rs
@@ -0,0 +1,131 @@
+//! PDF export: structure, pixel oracle, colour modes and refusal paths.
+
+use super::*;
+use photocraft_color::{PixelFormat, SampleType};
+use photocraft_doc::{Layer, LayerContent, Size};
+use photocraft_geom::Rect;
+use photocraft_raster::Surface;
+
+fn solid(fmt: PixelFormat, x0: i32, y0: i32, x1: i32, y1: i32, px: &[f32]) -> Surface {
+ let mut s = Surface::new(fmt);
+ let (w, h) = ((x1 - x0) as usize, (y1 - y0) as usize);
+ let data: Vec = px.iter().copied().cycle().take(w * h * px.len()).collect();
+ s.write_region(Rect::from_xywh(x0, y0, w as u32, h as u32), &data);
+ s
+}
+
+/// The opaque paper colour of `mode`, with alpha.
+fn paper(mode: ColorMode) -> Vec {
+ match mode {
+ ColorMode::Grayscale => vec![1.0, 1.0],
+ ColorMode::Cmyk => vec![0.0, 0.0, 0.0, 0.0, 1.0],
+ _ => vec![1.0, 1.0, 1.0, 1.0],
+ }
+}
+
+fn doc(mode: ColorMode) -> Document {
+ let fmt = PixelFormat::new(mode, SampleType::F32, true);
+ let bg = paper(mode);
+ let mut d = Document::new("t.pdf", Size { width: 4, height: 2 }, mode, SampleType::F32);
+ d.layers = vec![Layer::new("Paper", LayerContent::Raster(solid(fmt, 0, 0, 4, 2, &bg)))];
+ d
+}
+
+/// The bytes of the stream following `marker` (e.g. "/Subtype /Image"), inflated.
+fn stream_after(pdf: &[u8], marker: &str) -> Vec {
+ let at = pdf.windows(marker.len()).position(|w| w == marker.as_bytes()).expect("marker");
+ let body = &pdf[at..];
+ let len_at = body.windows(8).position(|w| w == b"/Length ").expect("length") + 8;
+ let len_end = body[len_at..].iter().position(|b| !b.is_ascii_digit()).expect("length end");
+ let len: usize = std::str::from_utf8(&body[len_at..len_at + len_end]).unwrap().parse().unwrap();
+ let start = body.windows(7).position(|w| w == b"stream\n").expect("stream") + 7;
+ let mut out = Vec::new();
+ std::io::Read::read_to_end(&mut flate2::read::ZlibDecoder::new(&body[start..start + len]), &mut out).unwrap();
+ out
+}
+
+fn has(pdf: &[u8], needle: &str) -> bool {
+ pdf.windows(needle.len()).any(|w| w == needle.as_bytes())
+}
+
+fn check_structure(pdf: &[u8]) {
+ assert!(pdf.starts_with(b"%PDF-1."), "PDF header");
+ assert!(pdf.ends_with(b"%%EOF\n"), "EOF marker");
+ let start = pdf.windows(9).rposition(|w| w == b"startxref").unwrap() + 9;
+ let off: usize = std::str::from_utf8(&pdf[start..]).unwrap().split_whitespace().next().unwrap().parse().unwrap();
+ assert_eq!(&pdf[off..off + 4], b"xref", "startxref points at the xref table");
+ // Every xref offset really precedes its `n 0 obj` header. The xref/trailer region is pure
+ // ASCII, so it is safe to decode just that slice.
+ let table = std::str::from_utf8(&pdf[off..]).unwrap().lines().collect::>();
+ let count: usize = table[1].split_whitespace().nth(1).unwrap().parse().unwrap();
+ for (i, line) in table.iter().skip(3).take(count - 1).enumerate() {
+ let o: usize = line[..10].parse().unwrap();
+ let want = format!("{} 0 obj", i + 1);
+ assert_eq!(&pdf[o..o + want.len()], want.as_bytes(), "xref offset for object {}", i + 1);
+ }
+}
+
+#[test]
+fn a_flat_rgb_document_saves_as_one_page_pdf() {
+ let d = doc(ColorMode::Rgb);
+ let out = export(&d).unwrap();
+ let pdf = &out.bytes;
+ check_structure(pdf);
+ assert!(has(pdf, "/MediaBox [0 0 4.00 2.00]"), "page = image size at 72 pt/in");
+ assert!(has(pdf, "/Width 4 /Height 2 /ColorSpace /DeviceRGB"), "RGB is DeviceRGB");
+ assert_eq!(stream_after(pdf, "/Subtype /Image"), vec![255u8; 4 * 2 * 3], "the white paper, 8-bit");
+ assert!(out.warnings.iter().any(|w| w.contains("flattened")), "layers are not preserved");
+ // Through the general dispatch as well.
+ let via = crate::export(&d, "out.pdf", &crate::ExportOptions::default()).unwrap();
+ assert_eq!(via.bytes, *pdf);
+}
+
+#[test]
+fn layers_composite_over_white_before_the_page() {
+ let mut d = doc(ColorMode::Rgb);
+ let fmt = PixelFormat::new(ColorMode::Rgb, SampleType::F32, true);
+ d.layers.push(Layer::new("Half red", LayerContent::Raster(solid(fmt, 1, 0, 3, 2, &[1.0, 0.0, 0.0, 0.5]))));
+ let out = export(&d).unwrap();
+ let img = stream_after(&out.bytes, "/Subtype /Image");
+ // Pixels 1-2 of row 0: 0.5 red over white = (1.0, 0.5, 0.5); elsewhere plain white.
+ assert_eq!(&img[3..6], &[255, 128, 128], "the blend lands: {:?}", &img[3..6]);
+ assert_eq!(&img[0..3], &[255, 255, 255]);
+}
+
+#[test]
+fn greyscale_and_cmyk_pages_keep_their_channels() {
+ let g = export(&doc(ColorMode::Grayscale)).unwrap();
+ assert!(has(&g.bytes, "/ColorSpace /DeviceGray"), "gray is DeviceGray");
+ assert_eq!(stream_after(&g.bytes, "/Subtype /Image"), vec![255; 4 * 2], "one sample per pixel");
+ let c = export(&doc(ColorMode::Cmyk)).unwrap();
+ assert!(has(&c.bytes, "/ColorSpace /DeviceCMYK"), "cmyk is DeviceCMYK");
+ assert_eq!(stream_after(&c.bytes, "/Subtype /Image"), vec![0; 4 * 2 * 4], "zero ink over the whole page");
+}
+
+#[test]
+fn the_page_measures_at_the_document_resolution() {
+ let mut d = doc(ColorMode::Rgb);
+ d.size = Size { width: 300, height: 150 };
+ let fmt = PixelFormat::new(ColorMode::Rgb, SampleType::F32, true);
+ d.layers = vec![Layer::new("Paper", LayerContent::Raster(solid(fmt, 0, 0, 300, 150, &[1.0, 1.0, 1.0, 1.0])))];
+ d.resolution_dpi = 300.0;
+ let out = export(&d).unwrap();
+ assert!(has(&out.bytes, "/MediaBox [0 0 72.00 36.00]"), "300 px at 300 dpi is one inch");
+}
+
+#[test]
+fn an_embedded_profile_travels_as_iccbased() {
+ let mut d = doc(ColorMode::Rgb);
+ d.icc_profile = Some(std::sync::Arc::new(vec![1, 2, 3, 4, 5, 6, 7, 8]));
+ let out = export(&d).unwrap();
+ assert!(has(&out.bytes, "[/ICCBased 7 0 R]"), "the image refers to the profile");
+ assert_eq!(stream_after(&out.bytes, "/N 3 /Alternate"), vec![1, 2, 3, 4, 5, 6, 7, 8], "the profile bytes survive");
+}
+
+#[test]
+fn other_modes_are_refused_with_an_actionable_error() {
+ let d = doc(ColorMode::Lab);
+ let e = export(&d).unwrap_err().to_string();
+ assert!(e.contains("RGB") && e.contains("Mode"), "{e}");
+ assert!(crate::export(&d, "x.pdf", &crate::ExportOptions::default()).is_err());
+}
diff --git a/crates/io/src/psd_export.rs b/crates/io/src/psd_export.rs
index 47861dbcc3..8ba30d83c4 100644
--- a/crates/io/src/psd_export.rs
+++ b/crates/io/src/psd_export.rs
@@ -164,6 +164,14 @@ struct SmartOut {
keep_fx: std::collections::HashSet,
/// Regenerated `FEid` items.
new_fx: Vec,
+ /// The unfiltered pixels of each smart object whose filter mask shows: its layer record holds
+ /// the filtered pixels without the mask, as Photoshop's do (`compose::filter_mask`).
+ unfiltered: std::collections::HashMap,
+}
+
+/// Whether a smart object's filter mask shows: enabled over at least one visible, enabled filter.
+fn masked(sm: &photocraft_doc::SmartObject) -> bool {
+ sm.filter_mask.as_ref().is_some_and(|m| m.enabled) && sm.filters_enabled && sm.smart_filters.iter().any(|f| f.visible)
}
/// `FEid` data padded to 4 bytes inside the block length: Photoshop counts the padding in the
@@ -760,6 +768,12 @@ impl Ex {
}
if !stack.filters.is_empty() {
self.smart.keep_fx.insert(t.placed.clone());
+ if masked(sm) {
+ let fmt = self.fmt;
+ if let Some(u) = self.smart.old_fx.iter().find(|i| i.id == t.placed).and_then(|i| crate::smart_map::unfiltered_from_item(i, fmt)) {
+ self.smart.unfiltered.insert(l.id, u);
+ }
+ }
}
return;
}
@@ -795,7 +809,14 @@ impl Ex {
None => photocraft_algo::warp::place_source(&img, img_bounds, &sm.transform, sm.warp.as_ref()),
};
match unfiltered {
- Ok(unfiltered) => crate::smart_map::feid_item(&placed, &unfiltered, sm.filter_mask.as_ref(), bounds, self.fmt),
+ Ok(unfiltered) => {
+ let item = crate::smart_map::feid_item(&placed, &unfiltered, sm.filter_mask.as_ref(), bounds, self.fmt);
+ if item.is_some() && masked(sm) {
+ let u = if unfiltered.format() == self.fmt { unfiltered } else { unfiltered.convert(self.fmt) };
+ self.smart.unfiltered.insert(l.id, u);
+ }
+ item
+ }
Err(e) => {
warnings.push(format!("smart filter mask was not re-rendered for PSD export ({e})"));
None
@@ -1072,7 +1093,12 @@ impl Ex {
self.records.push(r);
}
LayerContent::Smart(sm) => {
- let r = self.record(l, extra, sm.cache.as_ref());
+ // Photoshop's record holds the filtered pixels without the filter mask.
+ let unmixed = match (self.smart.unfiltered.get(&l.id), sm.cache.as_ref(), sm.filter_mask.as_ref()) {
+ (Some(u), Some(c), Some(m)) if masked(sm) => Some(photocraft_compose::filter_mask::unmix(u, c, m)),
+ _ => None,
+ };
+ let r = self.record(l, extra, unmixed.as_ref().or(sm.cache.as_ref()));
self.records.push(r);
}
}
@@ -1746,9 +1772,13 @@ fn document_to_psd_nested(doc: &Document, opts: &PsdExportOptions, depth: u32, c
resources.push(version_info_resource(real_merged));
let has_layers = !ex.records.is_empty();
+ // Photoshop writes a merged-transparency marker (`Mtrn`, `Mt16`, `Mt32`) before the layer
+ // block, and won't open a file whose `Lr32` comes first (#5068): the layer block goes right
+ // after the last kept marker, else first.
+ let index = global_blocks.iter().rposition(|b| matches!(&b.key, b"Mtrn" | b"Mt16" | b"Mt32")).map_or(0, |i| i + 1);
let placement = match (has_layers, sample) {
- (true, SampleType::U16) => LayerInfoPlacement::GlobalBlock { index: 0, signature: *b"8BIM", key: *b"Lr16", padding: None },
- (true, SampleType::F32) => LayerInfoPlacement::GlobalBlock { index: 0, signature: *b"8BIM", key: *b"Lr32", padding: None },
+ (true, SampleType::U16) => LayerInfoPlacement::GlobalBlock { index, signature: *b"8BIM", key: *b"Lr16", padding: None },
+ (true, SampleType::F32) => LayerInfoPlacement::GlobalBlock { index, signature: *b"8BIM", key: *b"Lr32", padding: None },
_ => LayerInfoPlacement::Section,
};
let records = std::mem::take(&mut ex.records);
@@ -1865,6 +1895,31 @@ mod tests {
assert_eq!(unique, reloaded_ids);
}
+ /// #5068: Photoshop won't open a file whose `Lr32` comes before the `Mt32` marker it keeps for
+ /// a 32-bit document's merged transparency (verified in Photoshop 2026 on psd-tools'
+ /// `transparentbg.psd` re-saved both ways). The layer block follows a kept marker.
+ #[test]
+ fn layer_block_follows_a_kept_merged_transparency_marker() {
+ for (depth, key, marker) in [(SampleType::F32, *b"Lr32", *b"Mt32"), (SampleType::U16, *b"Lr16", *b"Mt16"), (SampleType::F32, *b"Lr32", *b"Mtrn")] {
+ let mut doc = Document::new("t", photocraft_geom::Size::new(8, 6), ColorMode::Rgb, depth);
+ let mut s = Surface::new(doc.pixel_format());
+ s.fill_rect(photocraft_geom::Rect::new(1, 1, 5, 4), &[0.5, 0.2, 0.9, 1.0]);
+ doc.layers.push(Layer::new("Layer 1", LayerContent::Raster(s)));
+ doc.metadata.psd_global_blocks = vec![(*b"8BIM", *b"Patt", std::sync::Arc::new(Vec::new())), (*b"8BIM", marker, std::sync::Arc::new(Vec::new()))];
+ let saved = PsdFile::from_bytes(&document_to_psd(&doc).to_bytes().unwrap()).unwrap();
+ let LayerInfoPlacement::GlobalBlock { index, key: written, .. } = saved.layer_info_placement else { panic!("{depth:?}: a global layer block") };
+ assert_eq!(written, key);
+ let at = saved.global_blocks.iter().position(|b| b.key == marker).expect("the marker is kept");
+ assert!(at < index, "{depth:?}: {marker:?} at {at}, the layer block at {index}");
+ }
+ // Without a marker the layer block stays first.
+ let mut doc = Document::new("t", photocraft_geom::Size::new(8, 6), ColorMode::Rgb, SampleType::F32);
+ doc.layers.push(Layer::new("Layer 1", LayerContent::Raster(Surface::new(doc.pixel_format()))));
+ doc.metadata.psd_global_blocks = vec![(*b"8BIM", *b"Patt", std::sync::Arc::new(Vec::new()))];
+ let saved = PsdFile::from_bytes(&document_to_psd(&doc).to_bytes().unwrap()).unwrap();
+ assert!(matches!(saved.layer_info_placement, LayerInfoPlacement::GlobalBlock { index: 0, .. }));
+ }
+
#[test]
fn unreadable_lr16_warns_on_import_and_is_not_saved_twice() {
// #2700: a 16-bit file whose Lr16 block claims five layers but holds none.
diff --git a/crates/io/src/psd_import.rs b/crates/io/src/psd_import.rs
index 94c4ea9932..c20c1b7fe7 100644
--- a/crates/io/src/psd_import.rs
+++ b/crates/io/src/psd_import.rs
@@ -403,12 +403,26 @@ impl Ctx<'_> {
Some(p) if !stack.filters.is_empty() => self.filter_mask(&p.placed, &stack, &name),
_ => None,
};
+ // Photoshop stores the filtered pixels without the filter mask and mixes the unfiltered
+ // ones (`FEid`) back in through it; our smart objects hold the mixed result.
+ let stored = self.record_surface(rec, &name);
+ let shown = stack.enabled && stack.filters.iter().any(|f| f.visible);
+ let cache = match (&placed, filter_mask.as_ref().filter(|m| m.enabled && shown)) {
+ (Some(p), Some(m)) => {
+ let unfiltered = self.filter_effects.iter().find(|i| i.id == p.placed).and_then(|i| crate::smart_map::unfiltered_from_item(i, self.fmt));
+ match unfiltered {
+ Some(u) => photocraft_compose::filter_mask::mix(&u, &stored, m),
+ None => stored,
+ }
+ }
+ _ => stored,
+ };
LayerContent::Smart(SmartObject {
contents_id,
source: SmartSource::Linked { path: id },
transform,
smart_filters: stack.filters,
- cache: Some(self.record_surface(rec, &name)),
+ cache: Some(cache),
psd_raw: principal(k),
filters_enabled: stack.enabled,
filter_mask,
@@ -737,6 +751,26 @@ pub fn psd_to_document(file: &PsdFile) -> (Document, Vec) {
/// [`psd_to_document`] for a background open: checks `ctl` per layer record and reports
/// progress. `None` when cancelled.
pub fn psd_to_document_with(file: &PsdFile, ctl: &photocraft_raster::Interrupt) -> Option<(Document, Vec)> {
+ psd_to_document_decoded(file, ctl, None)
+}
+
+/// Whether the import reads the merged composite: for a flattened or multichannel file (it *is*
+/// the image), a file without layers, or extra alpha/spot channels behind the colour ones.
+pub(crate) fn merged_needed(file: &PsdFile) -> bool {
+ let h = &file.header;
+ let mode = doc_mode(h.color_mode).unwrap_or(ColorMode::Rgb);
+ // A layered mode is its own pixel format, so these are the document's colour channels.
+ let layered = matches!(mode, ColorMode::Grayscale | ColorMode::Rgb | ColorMode::Cmyk | ColorMode::Lab) && h.depth != 1;
+ !layered || file.layers().is_empty() || usize::from(h.channels) > mode.color_channels() + usize::from(file.merged_has_alpha())
+}
+
+/// [`psd_to_document_with`] with the merged image already decoded (by
+/// [`PsdFile::from_bytes_and_merged`] with [`merged_needed`]), so it is not decoded again.
+pub(crate) fn psd_to_document_decoded(
+ file: &PsdFile,
+ ctl: &photocraft_raster::Interrupt,
+ decoded: Option>>,
+) -> Option<(Document, Vec)> {
let h = &file.header;
let mut warnings = Vec::new();
let mode = doc_mode(h.color_mode).unwrap_or_else(|| {
@@ -859,9 +893,8 @@ pub fn psd_to_document_with(file: &PsdFile, ctl: &photocraft_raster::Interrupt)
// multichannel file (it *is* the image), or extra alpha/spot channels behind the colour
// ones. A normal layered Photoshop save carries a merged composite nobody reads - roughly
// half the file's bytes, decoded and thrown away on every open before this.
- let extra = usize::from(h.channels) > cc + usize::from(file.merged_has_alpha());
- let merged = if !layered || file.layers().is_empty() || extra {
- let m = file.decode_merged();
+ let merged = if merged_needed(file) {
+ let m = decoded.unwrap_or_else(|| file.decode_merged());
if ctl.cancelled() {
return None;
}
diff --git a/crates/io/src/smart_map.rs b/crates/io/src/smart_map.rs
index 6eeda61a13..3de336e16c 100644
--- a/crates/io/src/smart_map.rs
+++ b/crates/io/src/smart_map.rs
@@ -886,6 +886,45 @@ pub fn mask_from_item(item: &FilterEffectsItem, sample: SampleType, stack: &Filt
Ok(Some(LayerMask { surface, enabled: stack.mask_enabled, linked: stack.mask_linked, density: 1.0, feather: 0.0 }))
}
+/// The unfiltered placed pixels of an `FEid` item (the inverse of [`feid_item`]), in `fmt`: colour
+/// channels from slot 0, transparency from the last slot (opaque without it). `None` when the
+/// item has no colour planes, its depth isn't `fmt`'s, or a plane doesn't decode.
+pub fn unfiltered_from_item(item: &FilterEffectsItem, fmt: PixelFormat) -> Option |