Files
photocraft/crates/engine/tests/it/svg_smart_object.rs
T
Khawar Zamman Wani 123b2032c4 Web build: Place runs a slice per frame, so a large PNG no longer freezes the page (#10164, rebased onto main)
The remaining commits of the stack, applied on top of the squash-merged #10147:

- PNG decodes in resumable steps of rows (PngDecodeRows, shared with decode_rows)
- PNG imports as a document in resumable steps (io PngImport, text metadata and
  document build in bounded steps)
- Jobs can run a slice at a time where there are no threads (StepWork,
  cooperative sessions, Session::poll_jobs)
- Place decodes, flattens and resizes in slices (PlaceSteps), reading a path
  and keeping the frame, memory gate and typed memory-budget errors main has
- The web build places dropped and picked files a slice per frame, with a
  bounded place inbox
- A measurement of the stepped place; docs for jobs without threads
2026-11-06 08:51:17 +05:30

174 lines
9.6 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! An SVG placed as a smart object is a vector smart object: it is rasterised at its placement
//! scale (sharp at 10×, where a 20×10 px raster would blur), re-rendered when the placement
//! changes, and its contents open as shape layers.
use photocraft_doc::LayerContent;
use photocraft_engine::Session;
use photocraft_geom::Rect;
use serde_json::json;
const SVG: &str = "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"10\">\
<rect width=\"20\" height=\"10\" fill=\"#ff0000\"/>\
<rect x=\"0\" y=\"4\" width=\"20\" height=\"0.5\" fill=\"#000000\"/>\
</svg>";
fn alpha(s: &photocraft_raster::Surface, x: i32, y: i32) -> f32 {
let px = s.read_region(Rect::new(x, y, x + 1, y + 1));
*px.last().unwrap()
}
fn red(s: &photocraft_raster::Surface, x: i32, y: i32) -> f32 {
let px = s.read_region(Rect::new(x, y, x + 1, y + 1));
px[0]
}
#[test]
fn placed_svg_is_sharp_at_its_placement_scale_and_opens_as_shapes() {
let mut s = Session::new();
s.execute("file.new", json!({"width": 400, "height": 400, "background": "white"})).unwrap();
let r = photocraft_engine::file_cmds::place_bytes(&mut s, "logo.svg", SVG.as_bytes().to_vec(), None, &json!({"scale": 1000})).unwrap();
assert_eq!(r["bounds"], json!([100.0, 150.0, 300.0, 250.0]), "{r}");
let doc = s.active().unwrap().doc.clone();
let layer = doc.layers.last().unwrap();
let LayerContent::Smart(sm) = &layer.content else { panic!("{}", layer.content.kind_name()) };
let surf = layer.surface().expect("rendered");
// A pixel-exact edge at the top of the 200 × 100 placement, not a bicubic ramp.
assert!(alpha(surf, 200, 148) < 0.01 && alpha(surf, 200, 151) > 0.99, "{} {}", alpha(surf, 200, 148), alpha(surf, 200, 151));
// The half-unit black line is a crisp 5 px band (rows 190..195) rather than a faint smear.
assert!(red(surf, 200, 192) < 0.02, "black inside the line: {}", red(surf, 200, 192));
assert!(red(surf, 200, 187) > 0.98 && red(surf, 200, 198) > 0.98, "red just outside it");
assert!(red(surf, 200, 189) > 0.9 || red(surf, 200, 189) < 0.1, "edge rows are not half-covered");
// Edit Contents on this smart object: the embedded source opens as shape layers.
let photocraft_doc::SmartSource::Embedded { file_name, bytes } = &sm.source else { panic!("embedded") };
let inner = photocraft_engine::smart_cmds::decode_source(file_name, bytes).unwrap();
assert_eq!(inner.layers.len(), 2);
assert!(inner.layers.iter().all(|l| matches!(l.content, LayerContent::Shape(_))));
}
#[test]
fn re_placing_at_another_scale_re_renders_the_vector_source() {
let mut s = Session::new();
s.execute("file.new", json!({"width": 300, "height": 300, "background": "white"})).unwrap();
photocraft_engine::file_cmds::place_bytes(&mut s, "logo.svg", SVG.as_bytes().to_vec(), None, &json!({"scale": 100})).unwrap();
let doc = s.active().unwrap().doc.clone();
let layer = doc.layers.last().unwrap();
let LayerContent::Smart(sm) = &layer.content else { panic!() };
let mut big = sm.clone();
let [a, b, c, d, _, _] = big.transform.m;
big.transform.m = [a * 12.0, b * 12.0, c * 12.0, d * 12.0, 30.0, 30.0];
let surf = photocraft_engine::smart_cmds::render(&doc, &big).unwrap().expect("source available");
// 20 × 10 units at 12× from (30, 30): a hard edge at x = 270 and the thin line at rows 78..84.
assert!(alpha(&surf, 268, 60) > 0.99 && alpha(&surf, 271, 60) < 0.01);
assert!(red(&surf, 150, 81) < 0.02 && red(&surf, 150, 75) > 0.98 && red(&surf, 150, 87) > 0.98);
}
/// A `.pcraft` opens from its cached pixels and parses an embedded SVG source only on a later
/// edit. A source whose DTD entity hides 20 000 nested groups from the depth check used to open
/// clean and then overflow the stack on Image Size or a PSD save; both are an error or a fallback
/// now. Run on a 2 MB stack, as the app's import and command threads are.
#[test]
fn a_pcraft_smart_object_with_a_hostile_svg_does_not_abort_a_later_edit() {
let deep = format!("{}{}", "<g>".repeat(20_000), "</g>".repeat(20_000));
let hostile = format!("<!DOCTYPE svg [<!ENTITY a \"{deep}\">]><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"10\">&a;</svg>");
std::thread::Builder::new()
.stack_size(2 * 1024 * 1024)
.spawn(move || {
let mut s = Session::new();
s.execute("file.new", json!({"width": 100, "height": 100, "background": "white"})).unwrap();
photocraft_engine::file_cmds::place_bytes(&mut s, "logo.svg", SVG.as_bytes().to_vec(), None, &json!({"scale": 100})).unwrap();
let mut doc = (*s.active().unwrap().doc).clone();
let LayerContent::Smart(sm) = &mut doc.layers.last_mut().unwrap().content else { panic!("smart object") };
sm.source = photocraft_doc::SmartSource::Embedded { file_name: "logo.svg".into(), bytes: std::sync::Arc::new(hostile.into_bytes()) };
let carrier = photocraft_format::save_to_bytes(&doc, &photocraft_format::SaveOptions::default()).unwrap();
photocraft_engine::file_cmds::open_bytes_as(&mut s, "carrier.pcraft", &carrier, None, None).unwrap();
let _ = s.execute("image.imageSize", json!({"width": 50, "height": 50}));
let dir = tempfile::tempdir().unwrap();
let _ = s.execute("file.saveACopy", json!({"path": dir.path().join("copy.psd").to_string_lossy()}));
})
.unwrap()
.join()
.unwrap();
}
/// Placed through a background job, an SVG is rendered at its placement scale on the worker and
/// lands exactly as the inline place does: still sharp, not a resampled raster.
#[test]
fn an_svg_placed_as_a_job_is_as_sharp_as_the_inline_place() {
use photocraft_engine::jobs::Started;
let dir = std::env::temp_dir().join(format!("photocraft-svg-place-job-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("logo.svg");
std::fs::write(&path, SVG).unwrap();
let params = json!({"path": path.to_string_lossy(), "scale": 1000});
let new_doc = || {
let mut s = Session::new();
s.execute("file.new", json!({"width": 400, "height": 400, "background": "white"})).unwrap();
s
};
let mut inline = new_doc();
let want = inline.execute("file.placeEmbedded", params.clone()).unwrap();
let mut s = new_doc();
let Started::Job(id) = s.start("file.placeEmbedded", params).unwrap() else { panic!("expected a background job") };
let mut got = s.wait_job(id).unwrap();
// Layer ids come from a counter shared by every session: the rest of the result must match.
let mut want = want;
assert!(got.as_object_mut().and_then(|o| o.remove("layer")).is_some() && want.as_object_mut().and_then(|o| o.remove("layer")).is_some());
assert_eq!(got, want);
assert_eq!(got["bounds"], json!([100.0, 150.0, 300.0, 250.0]), "{got}");
let doc = s.active().unwrap().doc.clone();
let layer = doc.layers.last().unwrap();
assert!(matches!(layer.content, LayerContent::Smart(_)));
let surf = layer.surface().expect("rendered");
assert!(alpha(surf, 200, 148) < 0.01 && alpha(surf, 200, 151) > 0.99, "a pixel-exact top edge");
assert!(red(surf, 200, 192) < 0.02, "the thin line is a crisp band: {}", red(surf, 200, 192));
assert!(red(surf, 200, 187) > 0.98 && red(surf, 200, 198) > 0.98);
let region = Rect::new(90, 140, 310, 260);
let inline_doc = inline.active().unwrap().doc.clone();
assert_eq!(surf.read_region(region), inline_doc.layers.last().unwrap().surface().unwrap().read_region(region), "same pixels as the inline place");
}
/// With no worker threads (the web build) an SVG place is stepped a poll at a time, and renders
/// at its placement scale like the inline place does.
#[test]
fn an_svg_placed_in_steps_is_as_sharp_as_the_inline_place() {
use photocraft_engine::jobs::{JobOutcome, Started};
let params = json!({"scale": 1000});
let new_doc = || {
let mut s = Session::new();
s.execute("file.new", json!({"width": 400, "height": 400, "background": "white"})).unwrap();
s
};
let mut inline = new_doc();
let want = photocraft_engine::file_cmds::place_bytes(&mut inline, "logo.svg", SVG.as_bytes().to_vec(), None, &params).unwrap();
let mut s = new_doc();
s.set_cooperative_jobs(true);
s.set_job_step_budget(std::time::Duration::ZERO);
let Started::Job(id) = s.start_place_bytes("logo.svg", SVG.as_bytes().to_vec(), None, params).unwrap() else { panic!("expected a job") };
let mut polls = 0;
let event = loop {
polls += 1;
assert!(polls < 1000, "the place never ended");
if let Some(e) = s.poll_jobs().into_iter().find(|e| e.id == id) {
break e;
}
};
assert!(polls > 1, "{polls}");
let JobOutcome::Done(mut got) = event.outcome else { panic!("{:?}", event.outcome) };
let mut want = want;
assert!(got.as_object_mut().and_then(|o| o.remove("layer")).is_some() && want.as_object_mut().and_then(|o| o.remove("layer")).is_some());
assert_eq!(got, want);
let doc = s.active().unwrap().doc.clone();
let layer = doc.layers.last().unwrap();
assert!(matches!(layer.content, LayerContent::Smart(_)));
let surf = layer.surface().expect("rendered");
assert!(alpha(surf, 200, 148) < 0.01 && alpha(surf, 200, 151) > 0.99, "a pixel-exact top edge");
assert!(red(surf, 200, 192) < 0.02, "the thin line is a crisp band: {}", red(surf, 200, 192));
let region = Rect::new(90, 140, 310, 260);
let inline_doc = inline.active().unwrap().doc.clone();
assert_eq!(surf.read_region(region), inline_doc.layers.last().unwrap().surface().unwrap().read_region(region), "same pixels as the inline place");
}