Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

18.5 KB
Raw Blame
use super::*;
use build::{GLOBAL_MASK, Layer, Out, Spec, block, layer_info, resource, section};

mod build;
mod corpus;
mod damaged;
mod edits;

/// `luni` data as Photoshop writes it: the name's UTF-16 units after their
/// count, zero-padded to four bytes.
fn luni(name: &str) -> Vec<u8> {
    let mut out = Out::default();
    out.u32(name.encode_utf16().count() as u32);
    for unit in name.encode_utf16() {
        out.u16(unit);
    }
    let pad = pad4(out.0.len());
    out.bytes(&vec![0; pad]);
    out.0
}

/// A Photoshop record-level block (length counts the padding to four).
fn record_block(key: &[u8; 4], data: &[u8]) -> Vec<u8> {
    let padded = [data, &vec![0; pad4(data.len())]].concat();
    block(b"8BIM", key, false, &padded, &[], 0)
}

/// A Photoshop document-level block (padded to four after the length).
fn doc_block(key: &[u8; 4], data: &[u8], large: bool) -> Vec<u8> {
    let signature = if large { b"8B64" } else { b"8BIM" };
    block(signature, key, large, data, &vec![0; pad4(data.len())], 0)
}

/// An RGB file with `layers` (bottom first) and Photoshop's layout.
fn layered(layers: &[Layer], doc_blocks: &[u8]) -> Spec {
    let info = layer_info(layers.len() as i16, layers, false);
    Spec {
        layers: section(&info, pad4(info.len()), false, Some(&[]), doc_blocks),
        ..Spec::rgb()
    }
}

/// A layer whose layer info, alone, is one byte past a multiple of four.
fn odd_layer() -> Layer {
    let mut layer = Layer::new(b"ab");
    layer.channels[1].1.push(9);
    assert_eq!(layer_info(1, &[layer.clone()], false).len() % 4, 1);
    layer
}

fn round_trip(bytes: &[u8]) -> PsdFile {
    let file = read(bytes).unwrap();
    assert_eq!(write(&file), bytes, "written back differently");
    file
}

#[test]
fn reads_a_file_without_layers() {
    let resolution = [0, 72, 0, 0, 0, 1, 0, 1, 0, 72, 0, 0, 0, 1, 0, 1];
    let spec = Spec {
        resources: [
            resource(1005, b"", &resolution),
            resource(1039, b"icc", &[1, 2, 3]),
        ]
        .concat(),
        ..Spec::rgb()
    };
    let file = round_trip(&spec.bytes());
    assert_eq!(
        file.header,
        Header {
            version: 1,
            channels: 3,
            height: 2,
            width: 2,
            depth: 8,
            mode: 3,
        }
    );
    assert!(!file.header.is_psb());
    assert!(file.layers.is_empty());
    assert_eq!(file.resources.len(), 2);
    assert_eq!(file.resource(1005).unwrap().data, resolution);
    assert_eq!(file.resource(1039).unwrap().name, b"icc");
    assert_eq!(file.resource(1039).unwrap().data, [1, 2, 3]);
    assert_eq!(
        file.image,
        ImageData {
            compression: Compression::Raw,
            bytes: vec![10; 12],
        }
    );
}

#[test]
fn reads_layer_records_channels_and_blocks() {
    let mut top = Layer::new(b"Top");
    top.blend = *b"mul ";
    top.opacity = 128;
    top.clipping = 1;
    top.flags = 0x0a;
    top.filler = 7;
    top.rect = [-1, -2, 0, 0];
    top.rest = [
        record_block(b"luni", &luni("Top")),
        record_block(b"lyid", &[0, 0, 0, 2]),
    ]
    .concat();
    top.channels[1].1 = vec![0, 1, 0, 2, 1, 7];
    let bottom = Layer::new(b"Background");
    let spec = layered(&[bottom, top], &doc_block(b"Patt", &[], false));
    let file = round_trip(&spec.bytes());
    let records = &file.layers.info.records;
    assert_eq!(records.len(), 2);
    assert!(!file.layers.info.merged_alpha);
    assert_eq!(file.layers.global_mask, Some(Vec::new()));
    assert_eq!(file.layers.tagged.len(), 1);
    assert_eq!(&file.layers.tagged[0].key, b"Patt");
    assert_eq!(file.layers.tagged[0].padding, None);
    let top = &records[1];
    assert_eq!(top.name, b"Top");
    assert_eq!(top.name_padding, 0);
    assert_eq!(&top.blend, b"mul ");
    assert_eq!(
        (top.opacity, top.clipping, top.flags, top.filler),
        (128, 1, 0x0a, 7)
    );
    assert_eq!(top.rect(), IRect::new(-2, -1, 2, 1));
    assert_eq!(top.blend_ranges, [0, 0, 255, 255, 0, 0, 255, 255]);
    assert_eq!(top.mask, None);
    assert_eq!(top.block(b"luni").unwrap().data, luni("Top"));
    assert_eq!(top.block(b"lyid").unwrap().data, [0, 0, 0, 2]);
    assert!(top.tagged.iter().all(|b| b.padding.is_none()));
    assert!(top.extra_tail.is_empty());
    let ids: Vec<i16> = top.channels.iter().map(|c| c.id).collect();
    assert_eq!(ids, [-1, 0, 1, 2]);
    assert_eq!(top.channel(0).unwrap().compression, Compression::Rle);
    assert_eq!(top.channel(0).unwrap().bytes, [0, 2, 1, 7]);
    assert_eq!(top.channel(1).unwrap().compression, Compression::Raw);
    assert_eq!(top.channel(1).unwrap().bytes, [3, 4]);
    assert_eq!(records[0].name, b"Background");
    assert_eq!(records[0].name_padding, 1);
}

#[test]
fn large_documents_widen_lengths() {
    let mut layer = Layer::new(b"Layer 1");
    layer.rest = record_block(b"luni", &luni("Layer 1"));
    let info = layer_info(1, &[layer], true);
    let blocks = [
        doc_block(b"Patt", &[], false),
        // Photoshop CS6 signs some 64-bit blocks `8BIM`.
        block(b"8BIM", b"lnk2", true, &[1, 2, 3, 4], &[], 0),
        doc_block(b"FMsk", &[0; 12], true),
        doc_block(b"cinf", &[9; 6], true),
    ]
    .concat();
    let spec = Spec {
        psb: true,
        layers: section(&info, pad4(info.len()), true, Some(&[]), &blocks),
        // RLE with 32-bit row counts: two rows of each of three channels.
        image: [&[0, 1][..], &[0, 0, 0, 2].repeat(6), &[0xff, 9].repeat(6)].concat(),
        ..Spec::rgb()
    };
    let file = round_trip(&spec.bytes());
    assert!(file.header.is_psb());
    let keys: Vec<&[u8; 4]> = file.layers.tagged.iter().map(|b| &b.key).collect();
    assert_eq!(keys, [b"Patt", b"lnk2", b"FMsk", b"cinf"]);
    let lnk2 = file.layers.block(b"lnk2").unwrap();
    assert_eq!(lnk2.data, [1, 2, 3, 4]);
    // Kept as it was, rather than re-signed `8B64` as a new block would be.
    assert_eq!(lnk2.padding, Some(Vec::new()));
    assert_eq!(file.layers.block(b"FMsk").unwrap().padding, None);
    assert_eq!(file.layers.block(b"cinf").unwrap().data, [9; 6]);
    let record = &file.layers.info.records[0];
    assert_eq!(record.block(b"luni").unwrap().data, luni("Layer 1"));
    assert_eq!(record.channel(2).unwrap().bytes, [5, 6]);
    assert_eq!(file.image.compression, Compression::Rle);
}

/// A 16-bit file as Photoshop writes it: no layers in the section, all of
/// them in an `Lr16` block (unpadded inside, padded to four outside).
fn high_bit(depth: u16, psb: bool) -> Vec<u8> {
    let key = if depth == 16 { b"Lr16" } else { b"Lr32" };
    let samples = 2 * usize::from(depth / 8);
    let mut layer = Layer::new(b"L");
    layer.channels = vec![
        (-1, [&[0, 0][..], &vec![255; samples]].concat()),
        (0, vec![0, 1, 0, 3, 1, 1, 2]),
    ];
    layer.rest = record_block(b"luni", &luni("L"));
    let info = layer_info(1, &[layer], psb);
    assert_eq!(info.len() % 2, 1);
    let layers = if psb {
        doc_block(key, &info, true)
    } else {
        block(b"8BIM", key, false, &info, &vec![0; pad4(info.len())], 0)
    };
    let blocks = [layers, doc_block(b"LMsk", &[0; 14], psb)].concat();
    Spec {
        psb,
        depth,
        channels: 1,
        mode: 1,
        layers: section(&[], 0, psb, Some(&[]), &blocks),
        image: [&[0, 0][..], &vec![9; 4 * usize::from(depth / 8)]].concat(),
        ..Spec::rgb()
    }
    .bytes()
}

#[test]
fn high_bit_layers_come_from_their_block() {
    for (depth, psb) in [(16, false), (16, true), (32, false), (32, true)] {
        let key = if depth == 16 { *b"Lr16" } else { *b"Lr32" };
        let bytes = high_bit(depth, psb);
        let mut file = round_trip(&bytes);
        assert_eq!(file.layers.info_key, Some(key));
        assert_eq!(file.layers.info_padding, 0);
        assert_eq!(file.layers.info.records.len(), 1);
        assert_eq!(file.layers.info.records[0].name, b"L");
        let marker = file.layers.block(&key).unwrap();
        assert!(marker.data.is_empty());
        assert_eq!(marker.padding, None);
        // A changed layer list goes back into the block.
        let copy = file.layers.info.records[0].clone();
        file.layers.info.records.push(copy);
        let again = read(&write(&file)).unwrap();
        assert_eq!(again.layers.info_key, Some(key));
        assert_eq!(again.layers.info.records.len(), 2);
        assert_eq!(again.layers.tagged.len(), 2);
        assert_eq!(again.layers.info, file.layers.info);
    }
}

#[test]
fn layer_info_blocks_that_do_not_parse_stay_blocks() {
    let blocks = doc_block(b"Lr32", &[0, 5, 1], false);
    let spec = Spec {
        depth: 32,
        layers: section(&[], 0, false, Some(&[]), &blocks),
        ..Spec::rgb()
    };
    let file = round_trip(&spec.bytes());
    assert_eq!(file.layers.info_key, None);
    assert_eq!(file.layers.block(b"Lr32").unwrap().data, [0, 5, 1]);
}

#[test]
fn groups_are_records_with_section_blocks() {
    let mut end = Layer::new(b"</Layer group>");
    end.rect = [0; 4];
    end.channels = vec![
        (-1, vec![0, 0]),
        (0, vec![0, 0]),
        (1, vec![0, 0]),
        (2, vec![0, 0]),
    ];
    end.flags = 0x18;
    end.rest = record_block(b"lsct", &[0, 0, 0, 3]);
    let mut group = Layer::new(b"Group 1");
    group.rect = [0; 4];
    group.channels = end.channels.clone();
    group.blend = *b"pass";
    group.flags = 0x18;
    group.rest = [
        record_block(b"luni", &luni("Group 1")),
        record_block(b"lsct", &[&[0, 0, 0, 1][..], b"8BIM", b"pass"].concat()),
    ]
    .concat();
    let file = round_trip(&layered(&[end, Layer::new(b"inside"), group], &[]).bytes());
    let records = &file.layers.info.records;
    let kinds: Vec<&[u8]> = records
        .iter()
        .map(|r| r.block(b"lsct").map_or(&[][..], |b| &b.data[..4]))
        .collect();
    assert_eq!(kinds, [&[0, 0, 0, 3][..], &[], &[0, 0, 0, 1]]);
    assert!(records[0].rect().is_empty() && records[2].rect().is_empty());
    assert!(
        records[2]
            .channels
            .iter()
            .all(|c| c.bytes.is_empty() && c.compression == Compression::Raw)
    );
    assert_eq!(&records[2].blend, b"pass");
}

#[test]
fn a_negative_layer_count_marks_merged_transparency() {
    let info = layer_info(-1, &[Layer::new(b"a")], false);
    let spec = Spec {
        channels: 4,
        layers: section(&info, pad4(info.len()), false, Some(&GLOBAL_MASK), &[]),
        image: [&[0, 0][..], &[10; 16]].concat(),
        ..Spec::rgb()
    };
    let file = round_trip(&spec.bytes());
    assert!(file.layers.info.merged_alpha);
    assert_eq!(file.layers.global_mask.as_deref(), Some(&GLOBAL_MASK[..]));
}

/// Mask data: the rectangle, default color, and flags, then `rest`.
fn mask_bytes(flags: u8, rest: &[u8]) -> Vec<u8> {
    let mut out = Out::default();
    out.i32(1)
        .i32(2)
        .i32(3)
        .i32(4)
        .u8(255)
        .u8(flags)
        .bytes(rest);
    out.0
}

#[test]
fn mask_data_comes_in_three_shapes() {
    let real = [3u8, 0, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7, 0, 0, 0, 8];
    let params_bytes = [
        15u8, 200, 64, 4, 0, 0, 0, 0, 0, 0, 100, 63, 240, 0, 0, 0, 0, 0, 0,
    ];
    let params = MaskParams {
        user_density: Some(200),
        user_feather: Some(2.5),
        vector_density: Some(100),
        vector_feather: Some(1.0),
    };
    let real_mask = RealMask {
        flags: 3,
        default_color: 0,
        rect: [5, 6, 7, 8],
    };
    let cases = [
        // A lone mask: 18 bytes and two of padding.
        (mask_bytes(2, &[0, 0]), false, None, None),
        // With the real user mask (and its channel): 36 bytes.
        (mask_bytes(0, &real), true, Some(real_mask), None),
        // Parameters as long as a real mask, but no real-mask channel.
        (mask_bytes(0x10, &params_bytes), false, None, Some(params)),
        // Both: the real mask first.
        (
            mask_bytes(0x10, &[&real[..], &params_bytes].concat()),
            true,
            Some(real_mask),
            Some(params),
        ),
        // A single parameter: no padding past 20 bytes.
        (
            mask_bytes(0x10, &[1, 9]),
            false,
            None,
            Some(MaskParams {
                user_density: Some(9),
                ..MaskParams::default()
            }),
        ),
    ];
    for (bytes, real_channel, real, params) in cases {
        let mut layer = Layer::new(b"m");
        layer.mask = bytes;
        layer.channels.push((-2, vec![0, 0, 1]));
        if real_channel {
            layer.channels.push((-3, vec![0, 0, 2]));
        }
        let file = round_trip(&layered(&[layer], &[]).bytes());
        let mask = file.layers.info.records[0].mask.clone().unwrap();
        assert_eq!(mask.rect, [1, 2, 3, 4]);
        assert_eq!(mask.default_color, 255);
        assert_eq!(mask.real, real);
        assert_eq!(mask.params, params);
    }
}

#[test]
fn names_padded_otherwise_write_back_as_they_were() {
    // (name, padding in the file, what `name_padding` holds)
    for (name, padding, kept) in [
        (&b"ab"[..], 1, 1),
        (b"ab", 0, 4),
        (b"abcd", 1, 5),
        (b"abc", 4, 8),
        (b"", 3, 3),
    ] {
        let mut layer = Layer::new(name);
        layer.name_padding = padding;
        layer.rest = record_block(b"lyid", &[0, 0, 0, 1]);
        let file = round_trip(&layered(&[layer], &[]).bytes());
        let record = &file.layers.info.records[0];
        assert_eq!(record.name, name);
        assert_eq!(record.name_padding, kept);
        assert_eq!(record.tagged.len(), 1);
    }
}

#[test]
fn block_padding_other_writers_used_is_kept() {
    let mut layer = Layer::new(b"x");
    layer.rest = [
        // An odd length, unpadded (the next signature follows at once).
        block(b"8BIM", b"lnsr", false, &[1, 2, 3], &[], 0),
        // Padding to two after the length, as some writers do.
        block(b"8BIM", b"lyid", false, &[1, 2], &[0, 0], 0),
        // Padding counted to two only.
        block(b"8BIM", b"clbl", false, &[1, 0], &[], 0),
        // Stray bytes before the next block.
        block(b"8BIM", b"infx", false, &[1, 2, 3, 4], &[0, 7], 0),
        record_block(b"knko", &[0]),
    ]
    .concat();
    let doc = [
        doc_block(b"Patt", &[1, 2, 3, 4, 5], false),
        // Zeros between blocks.
        block(b"8BIM", b"Txt2", false, &[1], &[0; 9], 0),
        // Padding counted in the length, as ag-psd writes.
        block(b"8BIM", b"FMsk", false, &[1, 2], &[0, 0], 2),
    ]
    .concat();
    let file = round_trip(&layered(&[layer], &doc).bytes());
    let record = &file.layers.info.records[0];
    let paddings: Vec<Option<Vec<u8>>> = record.tagged.iter().map(|b| b.padding.clone()).collect();
    assert_eq!(
        paddings,
        [
            Some(vec![]),
            Some(vec![0, 0]),
            Some(vec![]),
            Some(vec![0, 7]),
            None
        ]
    );
    assert_eq!(record.block(b"lnsr").unwrap().data, [1, 2, 3]);
    let doc_paddings: Vec<Option<Vec<u8>>> = file
        .layers
        .tagged
        .iter()
        .map(|b| b.padding.clone())
        .collect();
    assert_eq!(doc_paddings, [None, Some(vec![0; 9]), None]);
    assert_eq!(file.layers.block(b"FMsk").unwrap().data, [1, 2, 0, 0]);
}

#[test]
fn lengths_that_run_into_the_next_block_are_realigned() {
    let mut layer = Layer::new(b"x");
    layer.rest = [
        // Counts two bytes of padding it never wrote.
        block(b"8BIM", b"lnsr", false, &[1, 2], &[], 2),
        record_block(b"lyid", &[0, 0, 0, 9]),
    ]
    .concat();
    let file = read(&layered(&[layer], &[]).bytes()).unwrap();
    let record = &file.layers.info.records[0];
    assert_eq!(record.block(b"lnsr").unwrap().data, [1, 2]);
    assert_eq!(record.block(b"lyid").unwrap().data, [0, 0, 0, 9]);
}

#[test]
fn bytes_that_are_not_blocks_are_kept() {
    let mut layer = Layer::new(b"x");
    layer.rest = [record_block(b"lyid", &[0, 0, 0, 1]), vec![1, 2, 3]].concat();
    let doc = [doc_block(b"Patt", &[], false), b"junk".to_vec()].concat();
    let file = round_trip(&layered(&[layer], &doc).bytes());
    assert_eq!(file.layers.info.records[0].extra_tail, [1, 2, 3]);
    assert_eq!(file.layers.tail, b"junk");
}

#[test]
fn layer_info_padded_otherwise_writes_back_as_it_was() {
    let info = layer_info(1, &[odd_layer()], false);
    let to_two = info.len() % 2;
    let cases = [
        // Photoshop: to four.
        (pad4(info.len()), Some(&[][..]), pad4(info.len())),
        // To two only.
        (to_two, Some(&[]), to_two + 4),
        // None at all, nothing after it (SAI).
        (0, None, 4),
        // More than needed.
        (pad4(info.len()) + 4, Some(&[]), pad4(info.len()) + 8),
    ];
    for (padding, global_mask, kept) in cases {
        let spec = Spec {
            layers: section(&info, padding, false, global_mask, &[]),
            ..Spec::rgb()
        };
        let file = round_trip(&spec.bytes());
        assert_eq!(file.layers.info_padding, kept);
        assert_eq!(file.layers.global_mask.is_some(), global_mask.is_some());
    }
}

#[test]
fn empty_layer_info_with_a_count_writes_back() {
    let spec = Spec {
        layers: section(&[0, 0], 2, false, Some(&[]), &[]),
        ..Spec::rgb()
    };
    let file = round_trip(&spec.bytes());
    assert!(file.layers.info.records.is_empty());
}

#[test]
fn resources_keep_names_signatures_and_odd_lengths() {
    let mut odd = resource(1033, b"", &[1, 2, 3]);
    odd[..4].copy_from_slice(b"MeSa");
    let resources = [
        odd,
        resource(1039, b"x", &[]),
        resource(4000, b"name", &[7; 5]),
    ]
    .concat();
    let spec = Spec {
        resources,
        ..Spec::rgb()
    };
    let file = round_trip(&spec.bytes());
    assert_eq!(&file.resources[0].signature, b"MeSa");
    assert_eq!(file.resources[0].data, [1, 2, 3]);
    assert_eq!(file.resources[1].name, b"x");
    assert_eq!(file.resources[2].data, [7; 5]);
}

#[test]
fn channels_without_data_read_as_empty() {
    let mut layer = Layer::new(b"group end");
    layer.rect = [0; 4];
    layer.channels = vec![(-1, vec![0, 0]), (0, vec![0, 1])];
    let file = round_trip(&layered(&[layer], &[]).bytes());
    let record = &file.layers.info.records[0];
    assert!(record.rect().is_empty());
    assert_eq!(record.channels[0].compression, Compression::Raw);
    assert!(record.channels[0].bytes.is_empty());
    assert_eq!(record.channels[1].compression, Compression::Rle);
}

#[test]
fn reversed_or_huge_rectangles_stay_in_range() {
    let mut record = read(&layered(&[Layer::new(b"a")], &[]).bytes())
        .unwrap()
        .layers
        .info
        .records
        .remove(0);
    record.rect = [10, 10, 0, 0];
    assert!(record.rect().is_empty());
    record.rect = [i32::MIN, i32::MIN, i32::MAX, i32::MAX];
    let rect = record.rect();
    assert_eq!((rect.x, rect.y), (i32::MIN, i32::MIN));
    assert!(rect.w > 0 && rect.h > 0);
}