Merge main preserving Unicode and vector regression modules

This commit is contained in:
FredApps committed 2026-11-18 18:34:41 +01:00
commit 450d21647c
9 files changed
+290 -314

No files matched your search

-12
View File
@@ -114,18 +114,6 @@ impl Descriptor {
}
}
pub(crate) fn read_unicode(r: &mut Reader) -> Result<String> {
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 };
+28 -32
View File
@@ -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<f64> {
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()),
}
}
+6 -21
View File
@@ -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<u8>) -> 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 {
+23
View File
@@ -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(_))));
}
+101
View File
@@ -0,0 +1,101 @@
use super::*;
type Block = ([u8; 4], Vec<u8>);
fn i16s(prefix: &[u8], values: &[i16]) -> Vec<u8> {
let mut bytes = prefix.to_vec();
bytes.extend(values.iter().flat_map(|v| v.to_be_bytes()));
bytes
}
fn exposure(values: [f32; 3]) -> Vec<u8> {
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<Block>) -> Option<Adjustment> {
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));
}
}
+86
View File
@@ -0,0 +1,86 @@
use super::*;
fn record(units: &[u16]) -> Vec<u8> {
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<Vec<u8>>) -> 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");
}
}