diff --git a/Cargo.lock b/Cargo.lock index c709630a5..92dc7b239 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1463,7 +1463,7 @@ dependencies = [ [[package]] name = "craft-psd" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=8ea89705a5e345001833d259c7c719f2cc08dcec#8ea89705a5e345001833d259c7c719f2cc08dcec" +source = "git+https://github.com/storytold/craft-libs?rev=62f7a7e4777d9b60f55a18a8865c73bb12297f38#62f7a7e4777d9b60f55a18a8865c73bb12297f38" dependencies = [ "encoding_rs", "flate2", diff --git a/Cargo.toml b/Cargo.toml index edb23ee02..81d390d38 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,7 +21,7 @@ craft-dpx = { version = "0.1.0", git = "https://github.com/storytold/craft-libs" craft-ps = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "808730f49b9637b7909fe2ae56f9d63fdb100cae", default-features = false, features = ["read"] } craft-exr = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } craft-gif = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } -craft-psd = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "8ea89705a5e345001833d259c7c719f2cc08dcec" } +craft-psd = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "62f7a7e4777d9b60f55a18a8865c73bb12297f38" } craft-svg = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "77686f24fe8665c21369f1b593f4d65a973e2a45" } craft-webp = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } craft-lottie = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" } diff --git a/crates/psd/src/descriptor.rs b/crates/psd/src/descriptor.rs index 37e7cb94b..63efce100 100644 --- a/crates/psd/src/descriptor.rs +++ b/crates/psd/src/descriptor.rs @@ -127,7 +127,7 @@ pub fn read_descriptor(r: &mut Reader) -> Result { Ok(from_craft_descriptor(d)) } -fn desc_err(e: craft_psd::PsdError) -> Error { +pub(crate) fn desc_err(e: craft_psd::PsdError) -> Error { match e { craft_psd::PsdError::UnexpectedEof { .. } => Error::Truncated, craft_psd::PsdError::Unsupported(s) => Error::Unsupported(s), @@ -143,7 +143,7 @@ fn unit_str(u: &[u8; 4]) -> String { String::from_utf8_lossy(u).into_owned() } -fn from_craft_descriptor(d: craft_psd::descriptor::Descriptor) -> Descriptor { +pub(crate) fn from_craft_descriptor(d: craft_psd::descriptor::Descriptor) -> Descriptor { Descriptor { class_name: d.name.to_string_lossy(), class_id: id_str(&d.class_id), diff --git a/crates/psd/src/parse.rs b/crates/psd/src/parse.rs index 6d6c452e4..160c034b6 100644 --- a/crates/psd/src/parse.rs +++ b/crates/psd/src/parse.rs @@ -168,29 +168,26 @@ impl Psd { } } b"lsct" | b"lsdk" => { - l.section = match r.u32()? { - 1 => Section::OpenFolder, - 2 => Section::ClosedFolder, - 3 => Section::Divider, + use craft_psd::tagged::{SectionDivider, SectionType}; + let divider = SectionDivider::from_bytes_recovering_blend(b).map_err(|e| error(&e))?; + l.section = match divider.kind { + SectionType::OpenFolder => Section::OpenFolder, + SectionType::ClosedFolder => Section::ClosedFolder, + SectionType::BoundingDivider => Section::Divider, _ => Section::Layer, }; - if b.len() >= 12 && &b[4..8] == b"8BIM" { - l.blend.copy_from_slice(&b[8..12]); + if let Some(blend) = divider.blend_mode { + l.blend = blend.key(); } } b"TySh" => { - let _ver = r.u16()?; - let mut t = [0.0; 6]; - for v in &mut t { - *v = r.f64()?; - } + let prefix = craft_psd::text::TypeLayerPrefix::from_bytes_with_limits(b, descriptor::PARSE_LIMITS).map_err(descriptor::desc_err)?; + let mut t = prefix.transform; // A transform with NaN/inf is unusable: fall back to the identity. if t.iter().any(|v| !v.is_finite()) { t = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]; } - let _text_ver = r.u16()?; - let _desc_ver = r.u32()?; - let d = descriptor::read_descriptor(&mut r)?; + let d = descriptor::from_craft_descriptor(prefix.descriptor); let text = d.text("Txt ").unwrap_or_default().replace("\r\n", "\n").replace('\r', "\n"); let text = text.strip_suffix('\n').map(str::to_string).unwrap_or(text); let style = d.raw("EngineData").map(|e| engine_data::text_style(&engine_data::parse_lossy(e))).unwrap_or_default(); diff --git a/crates/psd/src/tests.rs b/crates/psd/src/tests.rs index 06846c865..e72c334a4 100644 --- a/crates/psd/src/tests.rs +++ b/crates/psd/src/tests.rs @@ -6,7 +6,9 @@ mod fixed_adjustments; mod integration; mod opt; mod scalar_blocks; +mod section_divider; mod shared_corpus; +mod tysh_prefix; mod unicode_name; mod vector_records; diff --git a/crates/psd/src/tests/section_divider.rs b/crates/psd/src/tests/section_divider.rs new file mode 100644 index 000000000..ec208383b --- /dev/null +++ b/crates/psd/src/tests/section_divider.rs @@ -0,0 +1,53 @@ +use super::*; + +fn parse_section_blocks(blocks: Vec<([u8; 4], Vec)>) -> (Section, [u8; 4]) { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty("Section", blocks).with_blend(b"mul ")]; + let layer = Psd::parse(write(&doc)).unwrap().layers.remove(0); + (layer.section, layer.blend) +} + +#[test] +fn section_prefixes_and_invalid_optional_signatures_preserve_prior_state() { + let full = [0, 0, 0, 2, b'8', b'B', b'I', b'M', b'z', b'z', b'z', b'z', 0, 0, 0, 7, 255]; + for key in [*b"lsct", *b"lsdk"] { + for len in 0..=17 { + let data = full[..len].to_vec(); + assert_eq!( + parse_section_blocks(vec![(key, data.clone())]), + (if len < 4 { Section::Layer } else { Section::ClosedFolder }, if len < 12 { *b"mul " } else { *b"zzzz" }), + "{key:?} length {len}" + ); + let previous = vec![0, 0, 0, 1, b'8', b'B', b'I', b'M', b's', b'c', b'r', b'n']; + let other = if key == *b"lsct" { *b"lsdk" } else { *b"lsct" }; + assert_eq!( + parse_section_blocks(vec![(other, previous), (key, data.clone())]), + (if len < 4 { Section::OpenFolder } else { Section::ClosedFolder }, if len < 12 { *b"scrn" } else { *b"zzzz" }), + ); + if len >= 12 { + let mut bad = data; + bad[4..8].copy_from_slice(b"nope"); + assert_eq!(parse_section_blocks(vec![(key, bad)]), (Section::ClosedFolder, *b"mul ")); + } + } + } +} + +#[test] +fn section_unknown_kinds_and_sequential_keys_keep_blend_until_replaced() { + for kind in [0u32, 1, 2, 3, 99, u32::MAX] { + let expected = match kind { + 1 => Section::OpenFolder, + 2 => Section::ClosedFolder, + 3 => Section::Divider, + _ => Section::Layer, + }; + for keys in [[*b"lsct", *b"lsdk"], [*b"lsdk", *b"lsct"]] { + let previous = vec![0, 0, 0, 1, b'8', b'B', b'I', b'M', b'z', b'z', b'z', b'z']; + let mut bad = kind.to_be_bytes().to_vec(); + bad.extend_from_slice(b"nopepass"); + bad.extend_from_slice(&7u32.to_be_bytes()); + assert_eq!(parse_section_blocks(vec![(keys[0], previous), (keys[1], bad)]), (expected, *b"zzzz")); + } + } +} diff --git a/crates/psd/src/tests/tysh_prefix.rs b/crates/psd/src/tests/tysh_prefix.rs new file mode 100644 index 000000000..027a21cbb --- /dev/null +++ b/crates/psd/src/tests/tysh_prefix.rs @@ -0,0 +1,115 @@ +use super::*; +use craft_psd::descriptor::{Class, Descriptor as SharedDescriptor, Id, ReferenceItem, UnicodeString, Value}; + +fn block(transform: [f64; 6], descriptor: SharedDescriptor) -> Vec { + let mut b = 999u16.to_be_bytes().to_vec(); + b.extend(transform.into_iter().flat_map(f64::to_be_bytes)); + b.extend(999u16.to_be_bytes()); + b.extend(999u32.to_be_bytes()); + b.extend(descriptor.to_bytes()); + b +} + +fn text_descriptor(text: &str) -> SharedDescriptor { + SharedDescriptor::new("TxLr").with("Txt ", Value::Text(UnicodeString::new(text))) +} + +fn parse_text(blocks: Vec>) -> Option { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty("Text", blocks.into_iter().map(|b| (*b"TySh", b)).collect())]; + Psd::parse(write(&doc)).unwrap().layers.remove(0).text +} + +#[test] +fn text_prefix_recovers_suffixes_and_repeated_blocks_without_changing_text_policy() { + let transform = [2.0, 0.0, 0.0, 3.0, 4.0, 5.0]; + let data = block(transform, text_descriptor("a\r\nb\rc\n\n")); + let expected = TextInfo { text: "a\nb\nc\n".into(), transform, ..Default::default() }; + for suffix in [vec![], vec![255], vec![0; 6], vec![255; 40]] { + let mut b = data.clone(); + b.extend(suffix); + assert_eq!(parse_text(vec![b]), Some(expected.clone())); + } + for cut in 0..data.len() { + assert_eq!(parse_text(vec![data[..cut].to_vec()]), None, "cut {cut}"); + assert_eq!(parse_text(vec![data.clone(), data[..cut].to_vec()]), Some(expected.clone())); + } + let last = block(transform, text_descriptor("last")); + assert_eq!(parse_text(vec![data, last]).unwrap().text, "last"); + for index in 0..6 { + for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] { + let mut t = transform; + t[index] = bad; + assert_eq!(parse_text(vec![block(t, text_descriptor("x"))]).unwrap().transform, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]); + } + } +} + +#[test] +fn text_prefix_preserves_descriptor_normalization_and_bounds_precedence() { + let bounds = SharedDescriptor::new("bounds") + .with("Left", Value::Double(f64::NAN)) + .with("Top ", Value::UnitFloat { unit: *b"#Pnt", value: f64::INFINITY }) + .with("Rght", Value::Double(20.0)) + .with("Btom", Value::Double(10.0)); + let d = text_descriptor("x").with("bounds", Value::Descriptor(bounds.clone())); + assert_eq!(parse_text(vec![block([1.0; 6], d)]).unwrap().bounds, Some([0.0, 0.0, 20.0, 10.0])); + let d = text_descriptor("x") + .with("bounds", Value::Descriptor(SharedDescriptor::new("bounds").with("Left", Value::Double(1.0)))) + .with("boundingBox", Value::Descriptor(bounds.clone())); + assert_eq!(parse_text(vec![block([1.0; 6], d)]).unwrap().bounds, None); + let d = text_descriptor("x").with("boundingBox", Value::Descriptor(bounds)); + assert_eq!(parse_text(vec![block([1.0; 6], d)]).unwrap().bounds, Some([0.0, 0.0, 20.0, 10.0])); + + let class = Class { name: UnicodeString::new("named"), class_id: Id::Str(b"abcd".to_vec()) }; + let d = text_descriptor("x") + .with("ref ", Value::Reference(vec![ReferenceItem::Identifier { class: class.clone(), id: 7 }])) + .with("cls ", Value::Class(class.clone())) + .with("nums", Value::UnitFloats { unit: *b"#Pxl", values: vec![f64::NEG_INFINITY, 2.0] }); + let raw = craft_psd::text::TypeLayerPrefix::from_bytes_with_limits(&block([1.0; 6], d), descriptor::PARSE_LIMITS).unwrap(); + let converted = descriptor::from_craft_descriptor(raw.descriptor); + assert_eq!(converted.class_id, "TxLr"); + assert_eq!(converted.items[1].1, descriptor::DValue::Reference(vec![descriptor::RefItem::IdentifierWithClass(class, 7)])); + assert_eq!(converted.items[2].1, descriptor::DValue::Class("named".into(), "abcd".into())); + assert_eq!(converted.items[3].1, descriptor::DValue::UnitFloats("#Pxl".into(), vec![0.0, 2.0])); +} + +#[test] +fn text_prefix_enforces_effect_descriptor_count_limit_before_reading_items() { + let mut data = block([1.0; 6], SharedDescriptor::new("TxLr")); + let end = data.len(); + data[end - 4..].copy_from_slice(&100_001u32.to_be_bytes()); + let err = craft_psd::text::TypeLayerPrefix::from_bytes_with_limits(&data, descriptor::PARSE_LIMITS).unwrap_err(); + assert!(matches!(descriptor::desc_err(err), Error::Invalid(_) | Error::Unsupported(_))); + assert_eq!(parse_text(vec![data]), None); +} + +#[test] +fn text_prefix_reads_independent_raw_header_and_text_descriptor() { + let mut data = vec![0, 9]; + for value in [1.0f64, 0.0, 0.0, 1.0, 12.0, -3.0] { + data.extend(value.to_be_bytes()); + } + // Ignored text/descriptor versions; empty class name, code class, one text item. + data.extend([0, 8, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0]); + data.extend(b"TxLr"); + data.extend(1u32.to_be_bytes()); + data.extend(0u32.to_be_bytes()); + data.extend(b"Txt TEXT"); + data.extend(4u32.to_be_bytes()); + data.extend([0, 65, 0, 13, 0, 10, 0, 66]); + let t = parse_text(vec![data]).unwrap(); + assert_eq!(t.text, "A\nB"); + assert_eq!(t.transform, [1.0, 0.0, 0.0, 1.0, 12.0, -3.0]); +} + +#[test] +fn text_prefix_keeps_first_engine_style() { + let engine = craft_psd::engine_data::minimal("x", "Courier", 24.0, [0.2, 0.4, 0.6], 1); + let d = text_descriptor("x").with("EngineData", Value::RawData(engine)); + let style = parse_text(vec![block([1.0; 6], d)]).unwrap().style; + assert_eq!(style.font.as_deref(), Some("Courier")); + assert_eq!(style.size, Some(24.0)); + assert_eq!(style.color, Some([0.2, 0.4, 0.6])); + assert_eq!(style.justification, Some(1)); +}