mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 01:18:43 +00:00
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
174 lines
9.6 KiB
Rust
174 lines
9.6 KiB
Rust
//! 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, ¶ms).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");
|
||
}
|