Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Merge pull request #1131 from vangel76/fix-psd-nonfinite-and-panic-paths

Brandon Thomase02c60c08af4
diff --cc crates/psd/src/tests.rs
index 1097ec58c,10cb870d4..852594e02
--- a/crates/psd/src/tests.rs
+++ b/crates/psd/src/tests.rs
@@@ -253,68 -253,35 +253,101 @@@ fn huge_layer_bounds_error_instead_of_a
assert!(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());
+ }