EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Merge pull request #1134 from vangel76/psd-simplify-dedupe
Brandon Thomasa55af3b23519
diff --cc crates/psd/src/lib.rsindex 64ee35679,3375f2699..d99b558b5--- a/crates/psd/src/lib.rs+++ b/crates/psd/src/lib.rs@@@ -710,9 -683,9 +695,9 @@@ impl Psdlet _ty = r.u32()?;let mut t = [0.0; 8];for v in &mut t {- *v = r.f64()?;+ *v = r.f64_finite()?;}- l.smart_object = Some(SmartObject { uuid, quad: [[t[0], t[1]], [t[2], t[3]], [t[4], t[5]], [t[6], t[7]]], size: None, warp: None });+ l.smart_object = Some(SmartObject { uuid, quad: placed::quad_from(t), size: None, warp: None });}b"vmsk" | b"vsms" => {let _ver = r.u32()?;diff --cc crates/psd/src/tests.rsindex 852594e02,5871c1a17..a09313830--- a/crates/psd/src/tests.rs+++ b/crates/psd/src/tests.rs@@@ -253,101 -253,85 +253,184 @@@ fn huge_layer_bounds_error_instead_of_aassert!(matches!(p.layer_pixels(0, false), Err(Error::Unsupported(_))));}+/// `n` groups nested in each other, each holding one pixel layer (file order: bottom first).+fn nested_groups_doc(n: usize) -> WDoc {+ let mut d = WDoc::new(4, 4);+ for _ in 0..n {+ d.layers.push(WLayer::group_end());+ }+ for i in 0..n {+ d.layers.push(WLayer::solid(&format!("L{i}"), Rect::new(0, 0, 1, 1), [1.0; 4]));+ d.layers.push(WLayer::group(&format!("G{i}"), true, *b"norm"));+ }+ d+}++fn depth_of(nodes: &[Node]) -> usize {+ nodes.iter().map(|n| if let Node::Group { children, .. } = n { 1 + depth_of(children) } else { 0 }).max().unwrap_or(0)+}++fn layer_indices(nodes: &[Node], out: &mut Vec<usize>) {+ for n in nodes {+ match n {+ Node::Layer(i) => out.push(*i),+ Node::Group { layer, children } => {+ out.push(*layer);+ layer_indices(children, out);+ }+ }+ }+}++#[test]+fn deeply_nested_groups_are_flattened_at_the_depth_limit() {+ assert_eq!(MAX_GROUP_DEPTH, 64);+ let n = 70;+ let p = Psd::parse(write(&nested_groups_doc(n))).unwrap();+ let (t, flattened) = p.tree_report();+ assert_eq!(depth_of(&t), MAX_GROUP_DEPTH);+ assert_eq!(flattened, 6);+ // No layer or group record is lost, each appears exactly once (dividers are not nodes).+ let mut seen = vec![];+ layer_indices(&t, &mut seen);+ seen.sort_unstable();+ assert_eq!(seen, (n..p.layers.len()).collect::<Vec<_>>());+ // At the limit nothing is flattened.+ let (t, flattened) = Psd::parse(write(&nested_groups_doc(MAX_GROUP_DEPTH))).unwrap().tree_report();+ assert_eq!((depth_of(&t), flattened), (MAX_GROUP_DEPTH, 0));+}++#[test]+fn thousands_of_nested_groups_do_not_overflow_a_small_stack() {+ let bytes = write(&nested_groups_doc(5000));+ let h = std::thread::Builder::new()+ .stack_size(2 << 20)+ .spawn(move || {+ let p = Psd::parse(bytes).unwrap();+ let t = p.tree();+ let c = t.clone();+ assert_eq!(t, c);+ let (_, flattened) = p.tree_report();+ drop(t);+ drop(c);+ flattened+ })+ .unwrap();+ assert_eq!(h.join().unwrap(), 5000 - MAX_GROUP_DEPTH);+}++#[test]+fn non_finite_transform_and_exposure_values_are_dropped() {+ let mut d = WDoc::new(16, 16);+ d.layers = vec![+ WLayer::empty("Title", vec![text_block("x", [f64::NAN, f64::INFINITY], "Inter", 12.0, [0.0; 3], 0)]),+ WLayer::empty("Exp", vec![exposure_block(f32::NAN, f32::INFINITY, f32::NEG_INFINITY)]),+ ];+ let p = Psd::parse(write(&d)).unwrap();+ let t = p.layers[0].text.as_ref().unwrap();+ assert!(t.transform.iter().all(|v| v.is_finite()));+ assert_eq!(t.transform, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);+ assert_eq!(p.layers[1].adjustment, Some(Adjustment::Exposure { exposure: 0.0, offset: 0.0, gamma: 1.0 }));+}++#[test]+fn non_finite_32_bit_samples_become_finite() {+ let mut d = WDoc::new(4, 4);+ d.depth = 32;+ d.layers = vec![WLayer::solid("L", Rect::new(0, 0, 4, 4), [0.5, 0.5, 0.5, 1.0])];+ let p = Psd::parse(write(&d)).unwrap();+ let raw: Vec<u8> = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, 0.25].iter().flat_map(|v| v.to_be_bytes()).collect();+ let s = p.samples(&raw, 4, 1);+ assert_eq!(s, vec![0.0, 1.0, 0.0, 0.25]);+ assert!(p.to_rgb(&[Some(s.clone()), Some(s.clone()), Some(s)], 1).iter().all(|v| v.is_finite()));+}++#[test]+fn rect_new_near_i32_max_saturates() {+ let r = Rect::new(i32::MAX, i32::MAX, 1, i32::MAX);+ assert_eq!((r.right, r.bottom), (i32::MAX, i32::MAX));+ assert!(r.is_empty());+}+++ /// A ZIP plane body for the decoder: the plane delta-coded per row when `predict`.+ fn zip_body(raw: &[u8], w: usize, depth: u16, predict: bool) -> Vec<u8> {+ if !predict {+ return raw.to_vec();+ }+ let mut out = raw.to_vec();+ let bps = usize::from(depth / 8);+ for row in out.chunks_exact_mut(w * bps) {+ if depth == 16 {+ let mut prev = 0u16;+ for c in row.as_chunks_mut::<2>().0 {+ let x = u16::from_be_bytes([c[0], c[1]]);+ c.copy_from_slice(&x.wrapping_sub(prev).to_be_bytes());+ prev = x;+ }+ } else {+ for i in (1..row.len()).rev() {+ row[i] = row[i].wrapping_sub(row[i - 1]);+ }+ }+ }+ out+ }++ /// The same document with every channel and the merged image re-encoded as ZIP (`comp` 2) or+ /// ZIP with prediction (3), appended to the file data.+ fn rezip(p: &Psd, comp: u16) -> Psd {+ let mut z = p.clone();+ let mut data = p.data.to_vec();+ let (depth, predict) = (p.depth, comp == 3);+ let deflate = |body: &[u8]| {+ let mut v = comp.to_be_bytes().to_vec();+ v.extend(miniz_oxide::deflate::compress_to_vec_zlib(body, 6));+ v+ };+ for (l, zl) in p.layers.iter().zip(&mut z.layers) {+ for (c, zc) in l.channels.iter().zip(&mut zl.channels) {+ let w = if c.id == -2 { l.mask.map_or(0, |m| m.rect.width() as usize) } else { l.rect.width() as usize };+ let raw = &p.data[c.offset + 2..c.offset + c.len];+ zc.offset = data.len();+ data.extend(deflate(&zip_body(raw, w, depth, predict)));+ zc.len = data.len() - zc.offset;+ }+ }+ // The merged image: one ZIP stream holding all planes.+ let (w, h) = (p.width as usize, p.height as usize);+ let plane = w * h * usize::from(depth / 8);+ let mut all = vec![];+ for c in 0..usize::from(p.channels) {+ let at = p.merged_offset + 2 + c * plane;+ all.extend(zip_body(&p.data[at..at + plane], w, depth, predict));+ }+ z.merged_offset = data.len();+ data.extend(deflate(&all));+ z.data = data.into();+ z+ }++ #[test]+ fn zip_channels_decode_like_raw_ones() {+ for depth in [8, 16] {+ let raw = Psd::parse(write(&doc_with_layers(depth, ColorMode::Rgb, false))).unwrap();+ for comp in [2, 3] {+ let zip = rezip(&raw, comp);+ assert_eq!(zip.composite().unwrap().data, raw.composite().unwrap().data, "composite {depth} bit, compression {comp}");+ for (i, canvas) in [(0, true), (0, false), (1, false), (2, false), (2, true)] {+ let (want, got) = (raw.layer_pixels(i, canvas).unwrap(), zip.layer_pixels(i, canvas).unwrap());+ assert_eq!(got.data, want.data, "layer {i} canvas {canvas}, {depth} bit, compression {comp}");+ }+ }+ }+ }++ #[test]+ fn rle_composite_matches_the_raw_one() {+ for depth in [8, 16] {+ let raw = Psd::parse(write(&doc_with_layers(depth, ColorMode::Rgb, false))).unwrap();+ let rle = Psd::parse(write(&doc_with_layers(depth, ColorMode::Rgb, true))).unwrap();+ assert_eq!(rle.composite().unwrap().data, raw.composite().unwrap().data, "{depth} bit");+ assert_eq!(rle.layer_pixels(2, true).unwrap().data, raw.layer_pixels(2, true).unwrap().data, "{depth} bit");+ }+ }