diff --git a/Cargo.lock b/Cargo.lock index 23938a75a..c709630a5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1195,6 +1195,15 @@ name = "craft-aep" version = "0.1.0" source = "git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87#5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87" +[[package]] +name = "craft-audio" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=30596f73c5ef851ba3dad9cf145669f391e2eb0d#30596f73c5ef851ba3dad9cf145669f391e2eb0d" +dependencies = [ + "craft-media 0.1.0 (git+https://github.com/storytold/craft-libs?rev=30596f73c5ef851ba3dad9cf145669f391e2eb0d)", + "thiserror 2.0.21", +] + [[package]] name = "craft-audio" version = "0.1.0" @@ -1369,6 +1378,11 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-media" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=30596f73c5ef851ba3dad9cf145669f391e2eb0d#30596f73c5ef851ba3dad9cf145669f391e2eb0d" + [[package]] name = "craft-media" version = "0.1.0" @@ -2240,6 +2254,7 @@ dependencies = [ name = "effectcraft-media" version = "0.24.1" dependencies = [ + "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=30596f73c5ef851ba3dad9cf145669f391e2eb0d)", "craft-audio 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", "craft-docpath", "craft-dpx 0.1.0 (git+https://github.com/storytold/craft-libs?rev=5a7a63a21dd03dd1a2bc6c308a3a6ce818caae87)", diff --git a/crates/media/Cargo.toml b/crates/media/Cargo.toml index ff98229cb..40b67e8a5 100644 --- a/crates/media/Cargo.toml +++ b/crates/media/Cargo.toml @@ -10,6 +10,7 @@ rust-version.workspace = true workspace = true [dependencies] +craft-audio-markers = { package = "craft-audio", version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "30596f73c5ef851ba3dad9cf145669f391e2eb0d", default-features = false } craft-docpath = { workspace = true } effectcraft-time = { workspace = true } effectcraft-color = { workspace = true } diff --git a/crates/media/src/wav_markers.rs b/crates/media/src/wav_markers.rs index ca40824b6..bc198d1b7 100644 --- a/crates/media/src/wav_markers.rs +++ b/crates/media/src/wav_markers.rs @@ -1,266 +1,37 @@ -//! Markers a WAV file carries, read from its RIFF chunks. -//! -//! Two encodings are read and merged: -//! - **Cue points** (the standard): a `cue ` chunk with one point per marker, named by `labl` (or -//! `note`) sub-chunks of a `LIST` `adtl` chunk, and given a length by `ltxt`. -//! - **XMP** (Adobe's tools): an `_PMX` chunk holding an XMP packet whose `xmpDM:markers` list has -//! one entry per marker (`xmpDM:startTime`, `xmpDM:duration`, `xmpDM:name`), counted in frames -//! of `xmpDM:frameRate` (`f44100` for samples at 44.1 kHz). -//! -//! RF64 files (WAVs over 4 GB) carry a `0xFFFFFFFF` size for a chunk too big for 32 bits and give its real size in a -//! `ds64` chunk; those sizes are resolved so the chunks after the audio are still found. -//! -//! The file is untrusted input: every read is bounds-checked, sizes use checked arithmetic, and -//! the number of markers, of `adtl` sub-chunks looked at and the size of the XMP packet are capped. - -use std::collections::{HashMap, HashSet}; - +//! WAV cue/adtl/RF64/XMP metadata is parsed by craft-audio; timeline policy remains here. +use craft_audio_markers::wav_markers as shared; use effectcraft_color::Label; use effectcraft_project::Marker; use effectcraft_time::Tick; +use std::collections::HashSet; -/// Most markers read from one file. -pub const MAX_MARKERS: usize = 10_000; -/// Largest XMP packet read (bytes). -const MAX_XMP: usize = 4 << 20; -/// Most `adtl` sub-chunks (`labl`, `note`, `ltxt`) looked at in one file: a few per cue point is plenty. +pub use shared::MAX_MARKERS; +#[cfg(test)] const MAX_ADTL_RECORDS: usize = 4 * MAX_MARKERS; -/// Most entries read from an RF64 file's `ds64` size table. -const MAX_DS64_TABLE: usize = 1_024; - -fn u32_at(b: &[u8], at: usize) -> Option { - let s = b.get(at..at.checked_add(4)?)?; - Some(u32::from_le_bytes(s.try_into().ok()?)) -} - -fn u64_at(b: &[u8], at: usize) -> Option { - let s = b.get(at..at.checked_add(8)?)?; - Some(u64::from_le_bytes(s.try_into().ok()?)) -} - -/// The text of a NUL-terminated label (the rest of the chunk), lossily decoded. -fn label(b: &[u8]) -> String { - let end = b.iter().position(|&c| c == 0).unwrap_or(b.len()); - String::from_utf8_lossy(b.get(..end).unwrap_or_default()).trim().to_string() -} fn secs(frames: f64, rate: f64) -> Tick { if rate > 0.0 && frames.is_finite() { Tick::from_seconds_f64((frames / rate).max(0.0)) } else { Tick::ZERO } } -/// Whether `bytes` start a RIFF/WAVE file. -pub fn is_wav(bytes: &[u8]) -> bool { - matches!(bytes.get(0..4), Some(b"RIFF" | b"RF64")) && bytes.get(8..12) == Some(b"WAVE") -} - -/// The sizes an RF64 file's `ds64` chunk gives for chunks too big for the 32-bit size field. -struct Ds64 { - /// The `data` chunk's size. - data: u64, - /// Other chunks: `(id, size)`. - table: Vec<([u8; 4], u64)>, -} - -impl Ds64 { - /// The real size of chunk `id`, when the file says. - fn size_of(&self, id: &[u8; 4]) -> Option { - if id == b"data" { Some(self.data) } else { self.table.iter().find(|(t, _)| t == id).map(|(_, size)| *size) } - } -} - -/// The `ds64` chunk of an RF64 file (`RF64`, size, `WAVE`, then `ds64`); `None` for any other file or one whose -/// `ds64` doesn't fit. -fn ds64(bytes: &[u8]) -> Option { - if bytes.get(0..4) != Some(b"RF64") || bytes.get(12..16) != Some(b"ds64") { - return None; - } - let size = usize::try_from(u32_at(bytes, 16)?).ok()?; - let body = bytes.get(20..20usize.checked_add(size)?)?; - // riff size (8), data size (8), sample count (8), table length (4), then `(id, size)` entries of 12 bytes - let data = u64_at(body, 8)?; - let entries = usize::try_from(u32_at(body, 24)?).ok()?; - let mut table = Vec::new(); - for i in 0..entries.min(MAX_DS64_TABLE) { - let at = 28usize.checked_add(i.checked_mul(12)?)?; - let id = <[u8; 4]>::try_from(body.get(at..at.checked_add(4)?)?).ok()?; - table.push((id, u64_at(body, at + 4)?)); - } - Some(Ds64 { data, table }) -} - -/// The chunks of a WAVE file as `(id, body)`, stopping at the first one that doesn't fit. -fn chunks(bytes: &[u8]) -> Vec<([u8; 4], &[u8])> { - let big = ds64(bytes); - let mut out = Vec::new(); - let mut at = 12usize; - while let Some(head) = bytes.get(at..at.saturating_add(8)) { - let (Ok(id), Some(field)) = (<[u8; 4]>::try_from(&head[..4]), u32_at(head, 4)) else { break }; - // In an RF64 file a size field of 0xFFFFFFFF stands for the size `ds64` gives. - let size = match &big { - Some(d) if field == u32::MAX => d.size_of(&id).unwrap_or(u64::from(field)), - _ => u64::from(field), - }; - let start = at.saturating_add(8); - let Some(end) = usize::try_from(size).ok().and_then(|n| start.checked_add(n)) else { break }; - let Some(body) = bytes.get(start..end) else { break }; - out.push((id, body)); - // Chunks are padded to an even size. - at = end.saturating_add(end & 1); - } - out -} - -/// The markers `bytes` carry, in time order (empty for anything that isn't a WAV with markers). +/// File markers in timeline order, deduplicated after the app's existing Tick quantization. pub fn read(bytes: &[u8]) -> Vec { - if !is_wav(bytes) { - return Vec::new(); - } - let chunks = chunks(bytes); - let rate = chunks.iter().find(|(id, _)| id == b"fmt ").and_then(|(_, b)| u32_at(b, 4)).map_or(0.0, f64::from); - let mut out = cue_markers(&chunks, rate); - if let Some((_, xmp)) = chunks.iter().find(|(id, _)| id == b"_PMX") { - // Tools that write both encodings repeat each marker. - let mut seen: HashSet<(String, Tick)> = out.iter().map(|o| (o.comment.clone(), o.time)).collect(); - for m in xmp_markers(xmp, rate) { - if seen.insert((m.comment.clone(), m.time)) { - out.push(m); - } + let metadata = shared::read(bytes); + let map = |m: shared::Marker| Marker { + time: secs(m.start, m.rate), + duration: secs(m.duration, m.rate), + comment: m.name, + label: Label::None, + ..Default::default() + }; + let mut out: Vec<_> = metadata.cue.into_iter().map(map).collect(); + let mut seen: HashSet<(String, Tick)> = out.iter().map(|m| (m.comment.clone(), m.time)).collect(); + for marker in metadata.xmp.into_iter().map(map) { + if seen.insert((marker.comment.clone(), marker.time)) { + out.push(marker); } } out.truncate(MAX_MARKERS); - out.sort_by_key(|m| m.time); - out -} - -/// Cue points named and sized by the `adtl` list. -fn cue_markers(chunks: &[([u8; 4], &[u8])], rate: f64) -> Vec { - let Some((_, cue)) = chunks.iter().find(|(id, _)| id == b"cue ") else { return Vec::new() }; - let count = (u32_at(cue, 0).unwrap_or(0) as usize).min(MAX_MARKERS); - // The cue points first: `(id, offset in samples)`. - let mut points = Vec::new(); - for i in 0..count { - let Some(point) = cue.get(4usize.saturating_add(i.saturating_mul(24))..) else { break }; - let (Some(id), Some(offset)) = (u32_at(point, 0), u32_at(point, 20)) else { break }; - points.push((id, offset)); - } - // Only the names and lengths of those ids are kept, so a hostile `adtl` list cannot grow them past the cue count, - // and each record is a lookup, not a scan. - let wanted: HashSet = points.iter().map(|(id, _)| *id).collect(); - let mut names: HashMap = HashMap::new(); - let mut lengths: HashMap = HashMap::new(); - let mut records = 0usize; - 'lists: for (_, list) in chunks.iter().filter(|(id, b)| id == b"LIST" && b.get(0..4) == Some(b"adtl")) { - let mut at = 4usize; - while let Some(head) = list.get(at..at.saturating_add(8)) { - let (Ok(id), Some(size)) = (<[u8; 4]>::try_from(&head[..4]), u32_at(head, 4)) else { break }; - let start = at.saturating_add(8); - let Some(end) = start.checked_add(size as usize) else { break }; - let Some(body) = list.get(start..end) else { break }; - records += 1; - if records > MAX_ADTL_RECORDS { - break 'lists; - } - if let Some(cue_id) = u32_at(body, 0).filter(|c| wanted.contains(c)) { - match &id { - // A `labl` is the name; a `note` only when there is none. - b"labl" => { - names.insert(cue_id, label(body.get(4..).unwrap_or_default())); - } - b"note" => { - names.entry(cue_id).or_insert_with(|| label(body.get(4..).unwrap_or_default())); - } - // The first `ltxt` of a cue point gives its length. - b"ltxt" => { - lengths.entry(cue_id).or_insert_with(|| u32_at(body, 4).unwrap_or(0)); - } - _ => {} - } - } - at = end.saturating_add(end & 1); - } - } - points - .into_iter() - .map(|(id, offset)| { - let comment = names.get(&id).cloned().unwrap_or_default(); - let length = lengths.get(&id).copied().unwrap_or(0); - Marker { time: secs(f64::from(offset), rate), duration: secs(f64::from(length), rate), comment, label: Label::None, ..Default::default() } - }) - .collect() -} - -/// The text of `name` in an XMP entry, as an attribute (`name="v"`) or an element -/// (`v`). -fn xmp_value(entry: &str, name: &str) -> Option { - let attr = format!("{name}=\""); - if let Some(i) = entry.find(&attr) { - let rest = entry.get(i + attr.len()..)?; - return Some(unescape(rest.get(..rest.find('"')?)?)); - } - let open = format!("<{name}>"); - let i = entry.find(&open)?; - let rest = entry.get(i + open.len()..)?; - Some(unescape(rest.get(..rest.find('<')?)?)) -} - -fn unescape(s: &str) -> String { - let mut out = String::with_capacity(s.len()); - let mut rest = s; - while let Some(i) = rest.find('&') { - out.push_str(rest.get(..i).unwrap_or_default()); - let tail = rest.get(i..).unwrap_or_default(); - let Some(semi) = tail.find(';').filter(|&n| n <= 10) else { - out.push('&'); - rest = tail.get(1..).unwrap_or_default(); - continue; - }; - let ent = tail.get(1..semi).unwrap_or_default(); - match ent { - "amp" => out.push('&'), - "lt" => out.push('<'), - "gt" => out.push('>'), - "quot" => out.push('"'), - "apos" => out.push('\''), - _ => { - let code = ent.strip_prefix("#x").and_then(|h| u32::from_str_radix(h, 16).ok()).or_else(|| ent.strip_prefix('#').and_then(|d| d.parse().ok())); - match code.and_then(char::from_u32) { - Some(c) => out.push(c), - None => out.push_str(tail.get(..=semi).unwrap_or_default()), - } - } - } - rest = tail.get(semi + 1..).unwrap_or_default(); - } - out.push_str(rest); - out.trim().to_string() -} - -/// A frame rate as XMP writes it: `f44100`, or `f30000s1001` (rate over scale). -fn xmp_rate(text: &str) -> Option { - let t = text.trim().strip_prefix('f')?; - let (num, den) = t.split_once('s').unwrap_or((t, "1")); - let (n, d): (f64, f64) = (num.parse().ok()?, den.parse().ok()?); - (n > 0.0 && d > 0.0).then_some(n / d) -} - -/// The markers of an XMP packet's `xmpDM:markers` entries. -fn xmp_markers(packet: &[u8], file_rate: f64) -> Vec { - let text = String::from_utf8_lossy(packet.get(..packet.len().min(MAX_XMP)).unwrap_or_default()); - let mut out = Vec::new(); - // The frame rate belongs to the track an entry follows. - let mut rate = file_rate; - for entry in text.split("().ok()) else { continue }; - let length = xmp_value(entry, "xmpDM:duration").and_then(|v| v.trim().parse::().ok()).unwrap_or(0.0); - let comment = xmp_value(entry, "xmpDM:name").unwrap_or_default(); - out.push(Marker { time: secs(start, rate), duration: secs(length, rate), comment, label: Label::None, ..Default::default() }); - if out.len() >= MAX_MARKERS { - break; - } - } + out.sort_by_key(|marker| marker.time); out } @@ -324,6 +95,16 @@ mod tests { chunk(b"LIST", &b) } + #[test] + fn shared_sources_deduplicate_after_app_tick_quantization() { + let xmp = br#""#; + let file = wav(&[fmt(44100), cue(&[(1, 0)]), adtl(&[labl(b"labl", 1, "Same")]), chunk(b"_PMX", xmp)]); + let markers = read(&file); + assert_eq!(markers.len(), 1); + assert_eq!(markers[0].time, Tick::ZERO); + assert_eq!(markers[0].comment, "Same"); + } + #[test] fn cue_points_are_named_by_the_adtl_list_and_timed_in_samples() { let file = wav(&[ diff --git a/crates/psd/src/descriptor.rs b/crates/psd/src/descriptor.rs index 56d75e7b3..37e7cb94b 100644 --- a/crates/psd/src/descriptor.rs +++ b/crates/psd/src/descriptor.rs @@ -114,18 +114,6 @@ impl Descriptor { } } -pub(crate) fn read_unicode(r: &mut Reader) -> Result { - let n = r.u32()? as usize; - let mut v = Vec::with_capacity(n.min(r.remaining() / 2)); - for _ in 0..n { - v.push(r.u16()?); - } - while v.last() == Some(&0) { - v.pop(); - } - Ok(String::from_utf16_lossy(&v)) -} - /// Preserve the application parser's per-container limits in the shared parser. pub(crate) const PARSE_LIMITS: craft_psd::descriptor::ParseLimits = craft_psd::descriptor::ParseLimits { max_descriptor_items: 100_000, max_list_items: 1_000_000 }; diff --git a/crates/psd/src/parse.rs b/crates/psd/src/parse.rs index d8993b7b9..ecfc0dc60 100644 --- a/crates/psd/src/parse.rs +++ b/crates/psd/src/parse.rs @@ -144,7 +144,13 @@ impl Psd { let mut r = Reader::new(b); match key { b"luni" => { - let name = descriptor::read_unicode(&mut r)?; + // Shared framing rejects truncated counts/payloads before allocation. Only + // the first record belongs to this block; UTF-16 repair and naming stay local. + let units = craft_psd::unicode_names::records(b).next().ok_or(Error::Truncated)?; + let mut name: String = char::decode_utf16(units.as_chunks::<2>().0.iter().map(|v| u16::from_be_bytes(*v))) + .map(|v| v.unwrap_or(char::REPLACEMENT_CHARACTER)) + .collect(); + name.truncate(name.trim_end_matches('\0').len()); if !name.is_empty() { l.name = name; } @@ -193,11 +199,14 @@ impl Psd { l.fill = d.color("Clr "); } b"nvrt" => l.adjustment = Some(Adjustment::Invert), - b"brit" => { - let brightness = r.i16()? as f64; - let contrast = r.i16()? as f64; - if l.adjustment.is_none() { - l.adjustment = Some(Adjustment::BrightnessContrast { brightness, contrast, legacy: true }); + b"brit" | b"hue2" | b"hue " | b"levl" | b"expA" => { + if let Some(adjustment) = craft_psd::adjust::Adjustment::from_block(key, b) { + let adjustment = adjustment.map_err(|e| error(&e))?; + // Photoshop can write brit beside CgEd: retain Effect's first-only + // brit policy while other complete typed blocks replace prior values. + if key != b"brit" || l.adjustment.is_none() { + l.adjustment = Some(from_shared_adjustment(adjustment)); + } } } b"CgEd" => { @@ -209,32 +218,6 @@ impl Psd { legacy: d.bool("useLegacy").unwrap_or(false), }); } - b"hue2" | b"hue " => { - let _ver = r.u16()?; - let colorize = r.u8()? != 0; - r.skip(1)?; - let ch = (r.i16()? as f64, r.i16()? as f64, r.i16()? as f64); - let m = (r.i16()? as f64, r.i16()? as f64, r.i16()? as f64); - let (hue, saturation, lightness) = if colorize { ch } else { m }; - l.adjustment = Some(Adjustment::HueSaturation { hue, saturation, lightness, colorize }); - } - b"levl" => { - let _ver = r.u16()?; - let (ib, iw, ob, ow, g) = (r.i16()?, r.i16()?, r.i16()?, r.i16()?, r.i16()?); - l.adjustment = - Some(Adjustment::Levels { in_black: ib as f64, in_white: iw as f64, gamma: g as f64 / 100.0, out_black: ob as f64, out_white: ow as f64 }); - } - b"expA" => { - let _ver = r.u16()?; - let mut finite = |default: f64| -> Result { - let v = f64::from(r.f32()?); - Ok(if v.is_finite() { v } else { default }) - }; - let exposure = finite(0.0)?; - let offset = finite(0.0)?; - let gamma = finite(1.0)?; - l.adjustment = Some(Adjustment::Exposure { exposure, offset, gamma }); - } b"curv" | b"blnc" | b"post" | b"thrs" | b"selc" | b"mixr" | b"phfl" | b"vibA" | b"blwh" | b"grdm" | b"clrL" if l.adjustment.is_none() => { l.adjustment = Some(Adjustment::Other(String::from_utf8_lossy(key).into_owned())); } @@ -507,3 +490,16 @@ fn error(e: &craft_psd::PsdError) -> Error { fn mac_roman_string(b: &[u8]) -> String { b.iter().map(|&b| if b < 0x80 { b as char } else { super::read::mac_roman(b) }).collect() } + +/// App representation only; binary field framing belongs to craft-psd. +fn from_shared_adjustment(value: craft_psd::adjust::Adjustment) -> Adjustment { + use craft_psd::adjust::Adjustment as Shared; + match value { + Shared::Invert => Adjustment::Invert, + Shared::BrightnessContrast { brightness, contrast, legacy } => Adjustment::BrightnessContrast { brightness, contrast, legacy }, + Shared::HueSaturation { hue, saturation, lightness, colorize } => Adjustment::HueSaturation { hue, saturation, lightness, colorize }, + Shared::Levels { in_black, in_white, gamma, out_black, out_white } => Adjustment::Levels { in_black, in_white, gamma, out_black, out_white }, + Shared::Exposure { exposure, offset, gamma } => Adjustment::Exposure { exposure, offset, gamma }, + Shared::Other(key) => Adjustment::Other(String::from_utf8_lossy(&key).into_owned()), + } +} diff --git a/crates/psd/src/pixels.rs b/crates/psd/src/pixels.rs index f9b7ca6f3..8ce6f2d63 100644 --- a/crates/psd/src/pixels.rs +++ b/crates/psd/src/pixels.rs @@ -472,27 +472,12 @@ enum PlaneStream { /// PackBits decoding of one row (appends exactly `row` bytes, zero-padded). pub(crate) fn unpack_bits(src: &[u8], row: usize, out: &mut Vec) -> Result<()> { - let start = out.len(); - let mut i = 0; - while i < src.len() && out.len() - start < row { - let n = src[i] as i8; - i += 1; - // A packet is written only up to the row's end, so the reserved plane never grows. - let room = row - (out.len() - start); - if n >= 0 { - let k = n as usize + 1; - let s = src.get(i..i + k).ok_or(Error::Truncated)?; - out.extend_from_slice(&s[..k.min(room)]); - i += k; - } else if n != -128 { - let k = (1 - n as isize) as usize; - let v = *src.get(i).ok_or(Error::Truncated)?; - out.extend(std::iter::repeat_n(v, k.min(room))); - i += 1; - } - } - out.resize(start + row, 0); - Ok(()) + // The production caller already charges/reserves the complete plane in Budget. + // Keep the shared recovery API bounded to this row; never relax the app budget. + craft_psd::compression::packbits::decode_padded_into(src, row, row, out).map_err(|error| match error { + craft_psd::PsdError::Decompress(_) => Error::Truncated, + other => Error::Invalid(other.to_string()), + }) } pub(crate) fn srgb_encode(v: f32) -> f32 { diff --git a/crates/psd/src/tests.rs b/crates/psd/src/tests.rs index 8c1e211a9..f5a12d7f3 100644 --- a/crates/psd/src/tests.rs +++ b/crates/psd/src/tests.rs @@ -2,9 +2,11 @@ use super::write::*; use super::*; use crate::pixels::srgb_encode; +mod fixed_adjustments; mod integration; mod opt; mod shared_corpus; +mod unicode_name; mod vector_records; fn gradient(w: u32, h: u32) -> Vec<[f32; 4]> { @@ -596,3 +598,24 @@ fn written_32_bit_color_samples_keep_their_range() { let q = |x: f32| (x.clamp(0.0, 1.0) * 255.0).round() / 255.0; assert_eq!(p8.composite().expect("composite").data[0], [q(2.0), q(-0.5), q(0.25), q(1.5)]); } + +#[test] +fn shared_packbits_keeps_padded_rows_and_truncated_packet_errors() { + let mut out = vec![42]; + unpack_bits(&[0, 7], 3, &mut out).unwrap(); + assert_eq!(out, [42, 7, 0, 0]); + unpack_bits(&[128], 2, &mut out).unwrap(); + assert_eq!(out, [42, 7, 0, 0, 0, 0]); + assert_eq!(unpack_bits(&[3, 1], 1, &mut vec![]), Err(Error::Truncated)); + assert_eq!(unpack_bits(&[255], 1, &mut vec![]), Err(Error::Truncated)); + let mut row = vec![]; + unpack_bits(&[0, 9, 255], 1, &mut row).unwrap(); + assert_eq!(row, [9]); +} + +#[test] +fn shared_packbits_reports_row_limits_as_invalid_not_truncated() { + // The shared recovery decoder refuses a row beyond its decoded-size limit. That refusal + // is a limit, not truncated PackBits data, so the wrapper must not report it as one. + assert!(matches!(unpack_bits(&[], usize::MAX, &mut Vec::new()), Err(Error::Invalid(_)))); +} diff --git a/crates/psd/src/tests/fixed_adjustments.rs b/crates/psd/src/tests/fixed_adjustments.rs new file mode 100644 index 000000000..223e973d3 --- /dev/null +++ b/crates/psd/src/tests/fixed_adjustments.rs @@ -0,0 +1,101 @@ +use super::*; + +type Block = ([u8; 4], Vec); + +fn i16s(prefix: &[u8], values: &[i16]) -> Vec { + let mut bytes = prefix.to_vec(); + bytes.extend(values.iter().flat_map(|v| v.to_be_bytes())); + bytes +} + +fn exposure(values: [f32; 3]) -> Vec { + let mut bytes = vec![0xff, 0xfe]; // Versions are intentionally not rejected. + bytes.extend(values.iter().flat_map(|v| v.to_be_bytes())); + bytes +} + +fn parse_adjustment(blocks: Vec) -> Option { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty("adjustment", blocks)]; + Psd::parse(write(&doc)).unwrap().layers.remove(0).adjustment +} + +fn cases() -> Vec<(Block, Adjustment)> { + let mut cases = vec![ + ((*b"brit", i16s(&[], &[i16::MIN, i16::MAX])), Adjustment::BrightnessContrast { brightness: -32768.0, contrast: 32767.0, legacy: true }), + ( + (*b"levl", i16s(&[0xff, 0xfe], &[i16::MIN, i16::MAX, -12, 300, -250])), + Adjustment::Levels { in_black: -32768.0, in_white: 32767.0, gamma: -2.5, out_black: -12.0, out_white: 300.0 }, + ), + ((*b"expA", exposure([-1.5, 2.25, 0.125])), Adjustment::Exposure { exposure: -1.5, offset: 2.25, gamma: 0.125 }), + ]; + for key in [*b"hue2", *b"hue "] { + for flag in [0, 1, 255] { + let values = if flag == 0 { [100.0, -200.0, 300.0] } else { [-32768.0, 32767.0, -4.0] }; + cases.push(( + (key, i16s(&[0xff, 0xfe, flag, 0xa5], &[i16::MIN, i16::MAX, -4, 100, -200, 300])), + Adjustment::HueSaturation { hue: values[0], saturation: values[1], lightness: values[2], colorize: flag != 0 }, + )); + } + } + cases +} + +#[test] +fn fixed_adjustments_preserve_fields_truncation_and_trailing_bytes() { + for ((key, bytes), expected) in cases() { + for end in 0..bytes.len() { + assert_eq!(parse_adjustment(vec![(key, bytes[..end].to_vec())]), None, "{key:?} prefix {end}"); + assert_eq!(parse_adjustment(vec![(*b"nvrt", vec![]), (key, bytes[..end].to_vec())]), Some(Adjustment::Invert)); + } + for tail in [vec![], vec![0xff], vec![0; 20]] { + let mut data = bytes.clone(); + data.extend(tail); + assert_eq!(parse_adjustment(vec![(key, data)]), Some(expected.clone()), "{key:?}"); + } + let after_invert = if key == *b"brit" { Adjustment::Invert } else { expected }; + assert_eq!(parse_adjustment(vec![(*b"nvrt", vec![]), (key, bytes)]), Some(after_invert)); + } +} + +#[test] +fn exposure_nonfinite_values_use_each_fields_original_default() { + for value in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] { + for axis in 0..3 { + let mut values = [-1.5, 2.25, 0.125]; + values[axis] = value; + let mut expected = [-1.5, 2.25, 0.125]; + expected[axis] = [0.0, 0.0, 1.0][axis]; + assert_eq!( + parse_adjustment(vec![(*b"expA", exposure(values))]), + Some(Adjustment::Exposure { exposure: expected[0], offset: expected[1], gamma: expected[2] }) + ); + } + } + let Some(Adjustment::Exposure { exposure: e, offset, gamma }) = parse_adjustment(vec![(*b"expA", exposure([-0.0; 3]))]) else { + panic!("exposure missing"); + }; + assert!(e.is_sign_negative() && offset.is_sign_negative() && gamma.is_sign_negative()); +} + +#[test] +fn fixed_adjustments_keep_brit_descriptor_and_other_block_precedence() { + let brit = (*b"brit", i16s(&[], &[10, 20])); + let mut cged = 16u32.to_be_bytes().to_vec(); + crate::descriptor::write_descriptor( + &mut cged, + &Descriptor::new("brightnessContrast").with("Brgh", DValue::Double(30.0)).with("Cntr", DValue::Double(-40.0)).with("useLegacy", DValue::Bool(false)), + ); + let modern = Adjustment::BrightnessContrast { brightness: 30.0, contrast: -40.0, legacy: false }; + for blocks in [vec![brit.clone(), (*b"CgEd", cged.clone())], vec![(*b"CgEd", cged), brit.clone()]] { + assert_eq!(parse_adjustment(blocks), Some(modern.clone())); + } + assert_eq!(parse_adjustment(vec![(*b"curv", vec![]), brit.clone()]), Some(Adjustment::Other("curv".into()))); + assert_eq!( + parse_adjustment(vec![brit.clone(), (*b"curv", vec![]), (*b"brit", i16s(&[], &[50, 60]))]), + Some(Adjustment::BrightnessContrast { brightness: 10.0, contrast: 20.0, legacy: true }) + ); + for ((key, data), expected) in cases().into_iter().filter(|((key, _), _)| key != b"brit") { + assert_eq!(parse_adjustment(vec![(*b"curv", vec![]), brit.clone(), (key, data), (*b"curv", vec![]), brit.clone()]), Some(expected)); + } +} diff --git a/crates/psd/src/tests/unicode_name.rs b/crates/psd/src/tests/unicode_name.rs new file mode 100644 index 000000000..8785b1a49 --- /dev/null +++ b/crates/psd/src/tests/unicode_name.rs @@ -0,0 +1,86 @@ +use super::*; + +fn record(units: &[u16]) -> Vec { + let mut bytes = (units.len() as u32).to_be_bytes().to_vec(); + bytes.extend(units.iter().flat_map(|v| v.to_be_bytes())); + bytes +} + +fn parse_name(blocks: Vec>) -> String { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty("Fallback", blocks.into_iter().map(|b| (*b"luni", b)).collect())]; + Psd::parse(write(&doc)).unwrap().layers.remove(0).name +} + +#[test] +fn unicode_names_preserve_lossy_utf16_and_trailing_nul_policy() { + for (units, expected) in [ + (vec![], "Fallback"), + (vec![0, 0], "Fallback"), + (vec![65], "A"), + (vec![65, 0, 0], "A"), + (vec![0, 65, 0, 66, 0], "\0A\0B"), + (vec![0x00e4, 0xd83d, 0xde00], "\u{e4}\u{1f600}"), + (vec![0xd800, 65, 0xdc00, 0], "\u{fffd}A\u{fffd}"), + (vec![0xd800, 0], "\u{fffd}"), + (vec![0xd800, 0xd83d, 0xde00, 0xdc00], "\u{fffd}\u{1f600}\u{fffd}"), + ] { + assert_eq!(parse_name(vec![record(&units)]), expected, "{units:?}"); + } +} + +#[test] +fn unicode_name_uses_first_complete_record_and_recovers_in_block_order() { + let first = record(&[65]); + let mut combined = first.clone(); + combined.extend(record(&[66])); + combined.extend([0xff, 0]); + assert_eq!(parse_name(vec![combined]), "A"); + let mut empty_then_name = record(&[]); + empty_then_name.extend(record(&[66])); + assert_eq!(parse_name(vec![empty_then_name]), "Fallback"); + for suffix in [vec![], vec![0xff], vec![0, 0, 0], vec![0xff; 8]] { + let mut bytes = first.clone(); + bytes.extend(suffix); + assert_eq!(parse_name(vec![bytes]), "A"); + } + let mut malformed = vec![vec![], vec![0], vec![0, 0], vec![0, 0, 0], vec![0, 0, 0, 1], vec![0, 0, 0, 1, 0]]; + malformed.push([2u32.to_be_bytes().as_slice(), &[0, 65, 0]].concat()); + malformed.push(u32::MAX.to_be_bytes().to_vec()); + for bad in malformed { + assert_eq!(parse_name(vec![bad.clone()]), "Fallback"); + assert_eq!(parse_name(vec![first.clone(), bad.clone(), record(&[0, 0])]), "A"); + assert_eq!(parse_name(vec![bad, record(&[66])]), "B"); + } + assert_eq!(parse_name(vec![first, record(&[66])]), "B"); +} + +#[test] +fn unicode_layer_name_writer_keeps_code_unit_count_without_added_terminator() { + for name in ["", "A", "\u{e4}\u{1f600}", "A\0", "\0B\0"] { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty(name, vec![])]; + let bytes = write(&doc); + let file = craft_psd::PsdFile::from_bytes(&bytes).unwrap(); + let block = file.layer_info.as_ref().unwrap().layers[0].block(b"luni").unwrap(); + let units: Vec<_> = name.encode_utf16().collect(); + assert_eq!(block.data, record(&units)); + } +} + +#[test] +fn missing_empty_or_malformed_unicode_name_keeps_pascal_name() { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty("Generated Unicode name", vec![])]; + let bytes = write(&doc); + for payload in [None, Some(vec![]), Some(record(&[])), Some(record(&[0, 0])), Some(vec![0, 0, 0, 1, 0]), Some(u32::MAX.to_be_bytes().to_vec())] { + let mut file = craft_psd::PsdFile::from_bytes(&bytes).unwrap(); + let layer = &mut file.layer_info.as_mut().unwrap().layers[0]; + layer.name = b"Pascal".to_vec(); + layer.blocks.retain(|b| b.key != *b"luni"); + if let Some(data) = payload { + layer.blocks.push(craft_psd::tagged::TaggedBlock::new(*b"luni", data)); + } + assert_eq!(Psd::parse(file.to_bytes().unwrap()).unwrap().layers[0].name, "Pascal"); + } +}