diff --git a/crates/engine/src/cmd/fileio/psdlayers.rs b/crates/engine/src/cmd/fileio/psdlayers.rs index 598f75ff04..3779b72745 100644 --- a/crates/engine/src/cmd/fileio/psdlayers.rs +++ b/crates/engine/src/cmd/fileio/psdlayers.rs @@ -43,8 +43,9 @@ //! groups nest at most [`MAX_DEPTH`] deep (layers deeper than a document may nest merge into the //! group around them, with a warning), each layer's pixels, like the canvases one step of a //! merge holds together, must fit the memory allowed, and all the pixels decoded and the canvases -//! the merges make must fit [`TOTAL_DECODED`] times that. What the merges that can't be made, or -//! that a hidden layer would need, decoded and made is counted apart, against the same limit. +//! the merges make must fit [`TOTAL_DECODED`] times that. A merge being tried may take that much +//! past what was read before it. What the merges that aren't made, or that a hidden layer would +//! need, decoded and made is counted apart, against the same limit. use std::cell::Cell; use std::sync::Arc; @@ -849,6 +850,9 @@ struct Builder<'a, F> { /// Those bytes that merges not made, and merges a hidden layer would need, took: given back to /// `spent` and counted here instead, against the same limit. wasted: Cell, + /// `spent` when the innermost merge being tried began: until it is made or given up, it may + /// spend the whole allowance past that (see [`Self::spend`]). + trial: Cell, /// The layers whose pixels were read so far (each time they were). painted: Cell, /// What each group gave when drawn alone without reading any layer's pixels (nothing, or a @@ -872,16 +876,30 @@ impl [f32; 3]> Builder<'_, F> { } /// Count `bytes` of decoded pixels, or of a canvas a merge makes, against the whole import's - /// allowance, [`TOTAL_DECODED`] times the memory allowed for one image. + /// allowance, [`TOTAL_DECODED`] times the memory allowed for one image. While a merge is tried + /// (see [`Self::try_from_here`]), only what it spent counts against the allowance. fn spend(&self, bytes: u64) -> Result<(), String> { let total = self.spent.get().saturating_add(bytes); self.spent.set(total); - if total > self.max_alloc.saturating_mul(TOTAL_DECODED) { + if total.saturating_sub(self.trial.get()) > self.max_alloc.saturating_mul(TOTAL_DECODED) { return Err("the PSD file's layers take more memory to read than allowed".into()); } Ok(()) } + /// Start trying a merge that may not be made: what it spends counts against the whole + /// allowance, however much was spent before it. Gives what [`Self::tried`] takes back. + fn try_from_here(&self) -> u64 { + self.trial.replace(self.spent.get()) + } + + /// End the merge tried since [`Self::try_from_here`] gave `outer`. A merge that is `made` keeps + /// what it spent, which must then fit the allowance with what was spent before it. + fn tried(&self, outer: u64, made: bool) -> Result<(), String> { + self.trial.set(outer); + if made { self.spend(0) } else { Ok(()) } + } + /// Move the bytes spent since `spent` was the count to [`Self::wasted`], which has an allowance /// of its own as large: what a merge that isn't made decoded doesn't take the room for reading /// the layers apart. @@ -1030,7 +1048,10 @@ impl [f32; 3]> Builder<'_, F> { u.base = true; } let spent = self.spent.get(); - if !unclipped && self.clip(&mut out, b, &body, i, &name, blend, opacity)? { + let outer = self.try_from_here(); + let made = !unclipped && self.clip(&mut out, b, &body, i, &name, blend, opacity)?; + self.tried(outer, made)?; + if made { continue; } self.refund(spent)?; @@ -1275,10 +1296,19 @@ impl [f32; 3]> Builder<'_, F> { } let mut out: Vec> = vec![]; for mut u in self.units(items, keep_hidden)? { + // A hidden layer in a mode VectorCraft lacks would need the merge for its mode: it is left + // out without being drawn. + if !u.visible && matches!(u.blend, Blend::Other(_)) { + self.skip(u.record); + continue; + } if self.knocks(&u, &out, level)? { let saved = self.saved(); let noted = self.noted_so_far(); - match self.knock(&out, &u)? { + let outer = self.try_from_here(); + let knocked = self.knock(&out, &u)?; + self.tried(outer, u.visible && matches!(knocked, Knocked::Merged(_)))?; + match knocked { // A hidden layer that would need the merge is left out, and nothing its drawing // counted is counted. Knocked::Merged(_) | Knocked::TooLarge if !u.visible => { @@ -1297,8 +1327,14 @@ impl [f32; 3]> Builder<'_, F> { continue; } // Nothing below it, or nothing of its own, to knock out: it comes in as a layer, - // with the hidden layers its drawing left out (see `kept`). - Knocked::Nothing => {} + // with the hidden layers its drawing left out (see `kept`). What its drawing + // read is read again when it comes in. A hidden one may still be left out by a + // later merge: what its drawing counted is counted when it comes in instead. + Knocked::Nothing if !u.visible => { + self.restore(saved)?; + self.unnote(noted); + } + Knocked::Nothing => self.refund(saved.spent)?, Knocked::TooLarge => { self.restore(saved)?; self.unknock(u.record); @@ -1309,13 +1345,9 @@ impl [f32; 3]> Builder<'_, F> { out.push(u); continue; }; - // A hidden layer that would need the merge is left out. - if !u.visible { - self.skip(u.record); - continue; - } // A merge that can't be made counts nothing its groups would have counted. let saved = self.saved(); + let outer = self.try_from_here(); let made = match out.as_mut_slice() { // Onto the previous merge alone: composited onto its canvas, in place. [prev] if prev.is_merge() => { @@ -1343,6 +1375,7 @@ impl [f32; 3]> Builder<'_, F> { None => false, }, }; + self.tried(outer, made)?; if made { if !self.notes.merged.contains(&other.label()) { self.notes.merged.push(other.label()); @@ -1465,6 +1498,10 @@ impl [f32; 3]> Builder<'_, F> { Drawn::Canvas(c) if c.px.iter().all(|p| p[3] <= 0.0) => return Ok(Knocked::Nothing), Drawn::Canvas(c) => c, }; + // At 0 fill, beside every layer below it, it cuts nothing: no canvas for them is needed. + if fill <= 0.0 && self.beside(below, &k)? { + return Ok(Knocked::Nothing); + } // The layer's canvas is held while the units below are drawn. let bytes = 16 * k.px.len() as u64; self.held = self.held.saturating_add(bytes); @@ -1499,6 +1536,41 @@ impl [f32; 3]> Builder<'_, F> { Ok(acc.map_or(Knocked::Nothing, Knocked::Merged)) } + /// Do the pixels `knock` paints lie outside the bounds of every visible unit `below`? Only the + /// bounds of layers and of merged canvases are known without drawing them: with a group below, + /// `false`. + fn beside(&self, below: &[Unit<'_>], knock: &Canvas) -> Result { + let width = knock.width.max(1); + let mut painted: Option<[i64; 4]> = None; + for (k, _) in knock.px.iter().enumerate().filter(|(_, p)| p[3] > 0.0) { + let (x, y) = (knock.left + (k % width) as i64, knock.top + (k / width) as i64); + painted = Some(painted.map_or([x, y, x + 1, y + 1], |[l, t, r, b]| [l.min(x), t.min(y), r.max(x + 1), b.max(y + 1)])); + } + let Some([left, top, right, bottom]) = painted else { return Ok(true) }; + for u in below.iter().filter(|u| u.visible) { + let [l, t, r, b] = match &u.body { + Body::Merged(c) => [c.left, c.top, c.left + c.width as i64, c.top + c.height as i64], + Body::Layer(i) => { + let rec = self.record(*i)?; + match rec.content { + Content::Adjustment => continue, + Content::Solid(Some(_)) if rec.color_over_canvas() => [0, 0, i64::from(self.h.width), i64::from(self.h.height)], + _ => { + let (w, h) = rec.bounds.size(); + let (l, t) = (i64::from(rec.bounds.left), i64::from(rec.bounds.top)); + [l, t, l + w as i64, t + h as i64] + } + } + } + Body::Group(..) => return Ok(false), + }; + if l < right && left < r && t < bottom && top < b { + return Ok(false); + } + } + Ok(true) + } + /// The bytes a merge step may still take: the memory allowed, less the copies of what is below /// the pass-through groups being merged. fn room(&self) -> u64 { @@ -1948,6 +2020,7 @@ pub(super) fn import( kept: vec![false; records.len()], spent: Cell::new(0), wasted: Cell::new(0), + trial: Cell::new(0), painted: Cell::new(0), blank: vec![None; records.len()], laid_blank: vec![false; records.len()], diff --git a/crates/engine/src/cmd/fileio/tests_psdlayers.rs b/crates/engine/src/cmd/fileio/tests_psdlayers.rs index c5be312153..d197658c20 100644 --- a/crates/engine/src/cmd/fileio/tests_psdlayers.rs +++ b/crates/engine/src/cmd/fileio/tests_psdlayers.rs @@ -807,13 +807,26 @@ fn knockouts_that_change_nothing_keep_the_layers_apart() { group_end(), lower(255), group_end(), - words, + words.clone(), L { hidden: true, ..layer("Inner", [0, 0, 2, 2], [0, 0, 255, 255]) }, L { hidden: true, ..knockout(group("Cut", b"norm"), 1, 255) }, group("Group", b"norm"), ]; let (s, r) = open(&file(4, 4, &layers, 8, false, false), json!({"hiddenLayers": true})); assert_eq!((inner(&s), &r["warnings"]), (vec!["Lower".to_string()], &json!([HIDDEN_1])), "{r}"); + // One whose layer mask hides all of it needs no merge, but a knockout above it merges the layers + // and leaves it out: it is counted once, without its type layer. + let layers = [ + group_end(), + lower(255), + group_end(), + words, + L { hidden: true, mask: Some(([0, 0, 2, 2], 0, 0, vec![0; 4])), ..knockout(group("Masked", b"norm"), 1, 255) }, + cut(0, 255), + group("Group", b"norm"), + ]; + let (s, r) = open(&file(4, 4, &layers, 8, false, false), json!({"hiddenLayers": true})); + assert_eq!((inner(&s), &r["warnings"]), (vec!["Lower + Cut".to_string()], &json!([HIDDEN_1])), "{r}"); } /// With hidden layers asked for, the hidden layers of a group drawn for a knockout or a clip that @@ -870,14 +883,18 @@ fn a_knockout_merge_past_the_memory_allowed_leaves_the_layers_apart() { let (doc, warnings) = psdlayers::import(&f, false, 1 << 20, cms).unwrap().unwrap(); assert_eq!(names(&doc), ["Lower + Cut"]); assert!(warnings.is_empty(), "{warnings:?}"); - let (doc, warnings) = psdlayers::import(&stack([2, 2, 4, 4]), false, 1 << 20, cms).unwrap().unwrap(); - assert_eq!(names(&doc), ["Lower", "Cut"]); - assert!(warnings.is_empty(), "{warnings:?}"); + for max_alloc in [128, 1 << 20] { + let (doc, warnings) = psdlayers::import(&stack([2, 2, 4, 4]), false, max_alloc, cms).unwrap().unwrap(); + assert_eq!(names(&doc), ["Lower", "Cut"], "{max_alloc}"); + assert!(warnings.is_empty(), "{max_alloc}: {warnings:?}"); + } } /// A knockout merge that can't be made leaves the import the whole allowance for reading the layers /// apart: here the merge decodes 22 layers over one another before the layer beside them makes its -/// canvas too large, which used up nearly all of eight times 64 KiB. +/// canvas too large, which used up nearly all of eight times 64 KiB. The merge has that allowance +/// also after five layers below the group were read, and a knockout at 0 fill over 22 transparent +/// layers, which cuts no paint after they are drawn, leaves the same room. #[test] fn a_knockout_merge_not_made_leaves_room_to_read_the_layers() { let cms = |c: [f32; 4]| [c[0], c[1], c[2]]; @@ -888,6 +905,33 @@ fn a_knockout_merge_not_made_leaves_room_to_read_the_layers() { let (doc, warnings) = psdlayers::import(&file(96, 32, &layers, 8, false, false), false, 64 << 10, cms).unwrap().unwrap(); assert_eq!(doc.layers[0].children().unwrap().len(), 24, "{warnings:?}"); assert_eq!(warnings, ["the knockout of 1 layer wasn't applied"]); + let mut after_five = vec![layer("Outside", [0, 0, 32, 32], [0, 0, 0, 255]); 5]; + after_five.extend(layers); + let (doc, warnings) = psdlayers::import(&file(96, 32, &after_five, 8, false, false), false, 64 << 10, cms).unwrap().unwrap(); + assert_eq!((doc.layers.len(), doc.layers[5].children().unwrap().len()), (6, 24), "{warnings:?}"); + assert_eq!(warnings, ["the knockout of 1 layer wasn't applied"]); + let mut layers = vec![group_end()]; + layers.extend((0..22).map(|_| layer("Lower", [0, 0, 32, 32], [255, 0, 0, 0]))); + layers.extend([knockout(layer("Cut", [0, 0, 32, 32], [0, 0, 255, 255]), 1, 0), group("Group", b"norm")]); + let (doc, warnings) = psdlayers::import(&file(32, 32, &layers, 8, false, false), false, 64 << 10, cms).unwrap().unwrap(); + assert_eq!(doc.layers[0].children().unwrap().len(), 23, "{warnings:?}"); + assert!(warnings.is_empty(), "{warnings:?}"); +} + +/// A hidden knockout in a mode VectorCraft lacks is left out without being drawn, hidden layers +/// asked for: here its pixels are larger than the memory allowed for one image. +#[test] +fn a_hidden_knockout_in_a_mode_vectorcraft_lacks_is_left_out_unread() { + let cms = |c: [f32; 4]| [c[0], c[1], c[2]]; + let layers = [ + group_end(), + layer("Lower", [0, 0, 2, 2], [255, 0, 0, 255]), + L { hidden: true, blend: b"diss", ..knockout(layer("Cut", [0, 0, 8, 8], [0, 0, 255, 255]), 1, 255) }, + group("Group", b"norm"), + ]; + let (doc, warnings) = psdlayers::import(&file(8, 8, &layers, 8, false, false), true, 128, cms).unwrap().unwrap(); + assert_eq!(doc.layers[0].children().unwrap().iter().map(|c| name(c)).collect::>(), ["Lower"]); + assert_eq!(warnings, [HIDDEN_1]); } /// A Dissolve knockout at part opacity clears each pixel below it fully or not at all, at the share diff --git a/docs/mcp.md b/docs/mcp.md index e641490062..a71a4d6943 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -9928,7 +9928,9 @@ The rest are VectorCraft's own rules: Each layer's pixels must fit the memory allowed for one image, and the pixels of all the layers and masks, with the canvases the merges make, must together fit eight times that; a file past either limit opens as its merged image, -with a warning. The pixels and canvases of merges that aren't made count against a second limit of the same size. The +with a warning. A merge being tried may use the whole of that limit beyond what was read before it. The pixels and +canvases of merges that aren't made, including knockouts that turn out to cut nothing, then count against a second +limit of the same size instead. The canvases one step of a merge holds at once must also fit the memory allowed for one image; when they don't, the layer that needed the merge comes in alone, with a warning: in the Normal mode, as a layer of its own instead of clipped, or without its knockout. diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 14bf39612f..ca57638462 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -2141,7 +2141,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur EPS export and EPS Save make each file's PNG thumbnail from its TIFF preview, averaging the preview's pixels down to the thumbnail's size on white, instead of drawing the document a second time; a file without a preview still draws its thumbnail (`crates/engine/src/cmd/fileio/tests_eps.rs`). - Targa files (`.tga`, `.vda`, `.icb`, `.vst`) open, place linked or embedded, relink and update at their pixel size: color-mapped, true-color and black-and-white, raw or run-length encoded, in any of the four row orders. The image descriptor's attribute bits and the extension area's Attributes Type decide the transparency: a file with no attribute bits, or with attribute data the Attributes Type calls undefined, opens opaque; with one bit, a 16-bit true-color pixel takes that bit as its alpha, and a color-mapped pixel takes the bit of the 16-bit color map entry it indexes; premultiplied colors are divided by their alpha. Open and Place recognize a Targa file by its extension, and `clipboard.importImage` and Glass's Load Texture… by its header; a Targa file copied in a file manager pastes as a bitmap (`crates/engine/src/cmd/fileio/tests_tiffbmp.rs`, `crates/engine/src/tests/links.rs`). - BMP files named `.dib` or `.rle` (run-length encoded bitmaps included), Photoshop files named `.pdd` and PNG files named `.pns` open and place, linked or embedded, as BMP, PSD and PNG files, in any letter case: the Open and Place dialogs list them with their format, the Links panel names their format, and Edit Original opens them. Exports write only `.bmp`, `.psd` and `.png` (`crates/engine/src/cmd/fileio/tests_tiffbmp.rs`, `crates/engine/src/cmd/fileio/tests_psdread.rs`, `crates/engine/src/tests/links.rs`). - - File › Open converts a PSD or PSB file's layers to objects, keeping the layer structure, merging clipped layers into one layer, merging a layer that uses a Knockout option with the layers below it, and leaving out hidden layers that would need a merge, as [PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html) describes for the option that converts layers to objects; hidden layers come in with `hiddenLayers`, as Import Hidden Layers brings them in, and `layers: false` opens the merged image. VectorCraft's own rules: each layer becomes a layer holding its pixels with its name, visibility, opacity and blend mode, groups become layers of sublayers, layers in Dissolve, Linear Burn, Linear Dodge, Vivid Light, Linear Light, Pin Light, Hard Mix, Subtract, Divide, Darker Color and Lighter Color are merged with the layers below, layer masks become opacity masks, fill opacity multiplies the opacity (in a layer that others are clipped to, it fades only that layer's own pixels), a Knockout value of 1 is read as a shallow knockout and applied to a layer or group inside a group, which is merged with the layers below it in that group (its pixels clear them to transparency, it is drawn there at its fill opacity, and its opacity fades the result; in a pass-through group only when it and the layers below it are in the Normal mode; a knockout at 0 opacity, or at 0 fill where it covers none of their painted pixels, isn't merged for the knockout), and adjustment layers, layer effects, vector masks and the other knockouts (top-level layers, clipped layers, layers that others are clipped to, pass-through groups with layers in other modes, other Knockout values, and merges that need more memory than allowed) aren't applied and are counted in the warnings. 8-, 16- and 32-bit files, PSB, raw, PackBits and zipped channels (`crates/engine/src/cmd/fileio/tests_psdlayers.rs`). + - File › Open converts a PSD or PSB file's layers to objects, keeping the layer structure, merging clipped layers into one layer, merging a layer that uses a Knockout option with the layers below it, and leaving out hidden layers that would need a merge, as [PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html) describes for the option that converts layers to objects; hidden layers come in with `hiddenLayers`, as Import Hidden Layers brings them in, and `layers: false` opens the merged image. VectorCraft's own rules: each layer becomes a layer holding its pixels with its name, visibility, opacity and blend mode, groups become layers of sublayers, layers in Dissolve, Linear Burn, Linear Dodge, Vivid Light, Linear Light, Pin Light, Hard Mix, Subtract, Divide, Darker Color and Lighter Color are merged with the layers below, layer masks become opacity masks, fill opacity multiplies the opacity (in a layer that others are clipped to, it fades only that layer's own pixels), a Knockout value of 1 is read as a shallow knockout and applied to a layer or group inside a group, which is merged with the visible layers below it in that group (its pixels clear them to transparency, it is drawn there at its fill opacity, and its opacity fades the result; in a pass-through group only when it and the visible layers below it are in the Normal mode; a knockout at 0 opacity, or at 0 fill where it covers none of their painted pixels, isn't merged for the knockout), and adjustment layers, layer effects, vector masks and the other knockouts (top-level layers, clipped layers, layers that others are clipped to, pass-through groups with layers in other modes, other Knockout values, and merges that need more memory than allowed) aren't applied and are counted in the warnings. 8-, 16- and 32-bit files, PSB, raw, PackBits and zipped channels (`crates/engine/src/cmd/fileio/tests_psdlayers.rs`). - File › Open of a PSD or PSB file with two or more layers, and File › Place of one without Link, show PSD Import Options: Convert Layers to Objects with Import Hidden Layers, or Flatten Layers to a Single Image, the options [PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html) describes for a file that is opened or embedded. A file placed with Link shows its flat image and isn't asked about. `file.place` takes `layers` and `hiddenLayers`, and `document.psdInfo` counts a file's layers without opening it. VectorCraft's own rules: placed layers come in as one group named after the file, a layer as an image and a layer group as a group, at the place the merged image would take and clipped to the canvas when layers reach past it; the dialog asks from two layers up and starts from the choices made last. Layer comps aren't read (`crates/engine/src/cmd/fileio/tests_psdlayers.rs`, `crates/ui-egui/src/dialogs/psd_import.rs`). - A PSD or PSB file's clipping path, the saved path that image resource 2999 names in the [PSD file format specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), clips its merged image on File › Place and on File › Open of the merged image, as [PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html) describes for a file imported as one flattened image. The image comes in a clip group whose clipping path has no paint and uses the even-odd rule, and the path can be edited or released. `links.update` and `links.relink` give the clip group the clipping path the new file names, or leave a plain group when it names none, and files that name no clipping path come in as before (`crates/engine/src/cmd/fileio/tests_psdread.rs`). - Import Slices: File › Open of a PSD or PSB file with slices, and File › Place of one without Link, bring its slices in as user slices, as [PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html) describes for a file that is opened or embedded; PSD Import Options offers Import Slices for such a file. `document.open` and `file.place` take `importSlices`, and `document.psdInfo` counts the slices. The slices are read from image resource 1050 in version 6 and in the descriptor of versions 7 and 8, as the [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/) describes it. VectorCraft's own rules: Import Slices applies to Convert Layers to Objects and to Flatten Layers to a Single Image alike, and makes the dialog ask for a file with fewer than two layers; placed slices move and scale with the art in the same undo step; each slice keeps its name, type, link, target, message, alternative text, cell text and background color; slices the file generated automatically, and slices wholly outside the canvas, are left out; slices that can't be read are left out with a warning while the art comes in; with Show Import Options off, a PSD file is placed with the PSD Import Options chosen last, and on, each PSD file of the place cursor asks for them (`crates/engine/src/cmd/fileio/tests_psdslices.rs`, `crates/ui-egui/src/dialogs/psd_import.rs`).