Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-psd

Source of release 0.6.1

0.6.1 / src / psd.lucb

## Photoshop documents read as layers: the header, then each layer record and
## its channel data (raw or PackBits), 8-bit RGB or grayscale, into one RGBA
## byte buffer per raster layer at the document's size (sRGB, straight alpha,
## top-down), a layer's user mask into one byte per pixel, and its group
## markers kept so the groups can be rebuilt; names come from the Unicode block
## when there is one. A document saved without layers (merged-only) reads as
## one layer from its composite image. Large documents (PSB, version 2) read
## too: their section and channel lengths are eight bytes, their row counts
## four. Depends only on the standard library; luce-image turns the buffers
## into pictures.
import memory

## The file is not a PSD this reader understands.
pub let invalid: ErrorCode = ErrorCode.package(330)
## The document is larger than this reader will hold.
pub let limit: ErrorCode = ErrorCode.package(331)

## What a layer record is: pixels, a group's own record (above its layers in
## the file), or the divider that ends a group (below them).
pub let layer_pixels: u8 = 0
pub let group_start: u8 = 1
pub let group_end: u8 = 2

## One layer read from a document, bottom-most first.
pub struct PsdLayer:
    pub var name: u8[]
    ## `width * height * 4` RGBA bytes at the document's size; empty for a group record.
    pub var pixels: u8[]
    ## The user mask, one byte per document pixel (0 hides, 255 reveals); empty without one.
    pub var mask: u8[]
    pub var mask_enabled: bool
    pub var visible: bool
    pub var opacity: f64
    ## The blend by luce-image's numbering (see `Layer.blend`).
    pub var blend: u32
    pub var clipped: bool
    pub var kind: u8

    pub func close():
        if self.name.length > 0:
            free(self.name) in memory.heap
        if self.pixels.length > 0:
            free(self.pixels) in memory.heap
        if self.mask.length > 0:
            free(self.mask) in memory.heap

pub struct Psd:
    pub var width: u32
    pub var height: u32
    pub var layers: PsdLayer[]
    pub var count: usize

    pub func close():
        for index in 0..<self.count:
            self.layers[index].close()
        if self.layers.length > 0:
            free(self.layers) in memory.heap
        self.count = 0

struct Reader:
    var data: const u8[]
    var at: usize
    ## A PSB (version 2): section and channel lengths are eight bytes, row counts four.
    var wide: bool

    func need(count: usize) -> !:
        if self.at + count > self.data.length:
            error(invalid, "the PSD file ends early")

    func byte() -> u8!:
        try self.need(1)
        self.at += 1
        return self.data[self.at - 1]

    func word() -> u16!:
        try self.need(2)
        let value = ((u16)self.data[self.at] << 8) | (u16)self.data[self.at + 1]
        self.at += 2
        return value

    func dword() -> u32!:
        try self.need(4)
        let value = ((u32)self.data[self.at] << 24) | ((u32)self.data[self.at + 1] << 16) | ((u32)self.data[self.at + 2] << 8) | (u32)self.data[self.at + 3]
        self.at += 4
        return value

    func qword() -> u64!:
        let high = (u64)(try self.dword())
        let low = (u64)(try self.dword())
        return (high << 32) | low

    ## A section or channel length: four bytes, eight in a PSB.
    func length() -> usize!:
        if self.wide:
            let value = try self.qword()
            if value > (u64)self.data.length:
                error(invalid, "a PSB length runs past the file")
            return (usize)value
        return (usize)(try self.dword())

    ## A PackBits row's byte count: two bytes, four in a PSB.
    func row_count() -> usize!:
        return (usize)(try self.dword()) if self.wide else (usize)(try self.word())

    func sdword() -> i64!:
        return (i64)(i32)(try self.dword())

    func skip(count: usize) -> !:
        try self.need(count)
        self.at += count

    func tag() -> u32!:
        return try self.dword()

## The four-character blend keys as luce-image blend numbers.
func blend_of(key: u32) -> u32:
    let keys: u32[26] = [0x6e6f726d, 0x6461726b, 0x6d756c20, 0x69646976, 0x6c62726e, 0x6c697465, 0x7363726e, 0x64697620, 0x6c646467, 0x6f766572,
                         0x734c6974, 0x684c6974, 0x764c6974, 0x6c4c6974, 0x704c6974, 0x684d6978, 0x64696666, 0x736d7564, 0x66737562, 0x66646976,
                         0x68756520, 0x73617420, 0x636f6c72, 0x6c756d20, 0x646b436c, 0x6c67436c]
    for index in 0..<(usize)26:
        if keys[index] == key:
            return (u32)index
    return 0

## The additional-layer-information keys whose length is eight bytes in a PSB.
func wide_key(key: u32) -> bool:
    let keys: u32[13] = [0x4c4d736b, 0x4c723136, 0x4c723332, 0x4c617972, 0x4d743136, 0x4d743332, 0x4d74726e, 0x416c7068, 0x464d736b, 0x6c6e6b32, 0x46456964, 0x46584964, 0x50785344]
    for candidate in keys:
        if candidate == key:
            return true
    return false

struct ChannelInfo:
    var id: i64
    var length: usize

## A layer record's rectangles and mask settings, kept for its channel data.
struct Record:
    var top: i64
    var left: i64
    var bottom: i64
    var right: i64
    var mask_top: i64
    var mask_left: i64
    var mask_bottom: i64
    var mask_right: i64
    var mask_default: u8
    var channels: usize

## Parse `data`, a whole PSD or PSB file.
pub func parse(data: const u8[]) -> Psd!:
    var reader = Reader(data = data, at = 0, wide = false)
    if (try reader.tag()) != 0x38425053:
        error(invalid, "not a Photoshop document (no 8BPS signature)")
    let version = try reader.word()
    if version != 1 and version != 2:
        error(invalid, "only PSD (version 1) and PSB (version 2) files are read")
    reader.wide = version == 2
    try reader.skip(6)
    let channels = (usize)(try reader.word())
    let height = try reader.dword()
    let width = try reader.dword()
    let depth = try reader.word()
    let mode = try reader.word()
    let largest: u32 = 300000 if reader.wide else 30000
    if width == 0 or height == 0 or width > largest or height > largest:
        error(invalid, "the PSD dimensions are out of range")
    if depth != 8:
        error(invalid, "only 8-bit PSD files are read")
    if mode != 3 and mode != 1:
        error(invalid, "only RGB and grayscale PSD files are read")
    if (usize)width * (usize)height > 268435456:
        error(limit, "the PSD is too large")
    try reader.skip((usize)(try reader.dword()))
    try reader.skip((usize)(try reader.dword()))
    var psd = Psd(width = width, height = height, count = 0)
    errdefer psd.close()
    let mask_info_length = try reader.length()
    let mask_info_end = reader.at + mask_info_length
    try reader.need(mask_info_length)
    if mask_info_length > 0:
        try read_layers(&reader, &psd, mode)
    reader.at = mask_info_end
    # Merged-only: no layers, so the composite image at the end is the picture.
    if psd.count == 0:
        try read_composite(&reader, &psd, mode, channels)
    return psd

## The layer section: every record, then every layer's channel data.
func read_layers(reader: Reader*, psd: Psd*, mode: u16) -> !:
    let layer_info_length = try reader.length()
    if layer_info_length == 0:
        return
    let signed = (i64)(i16)(try reader.word())
    let count = (usize)(signed if signed >= 0 else -signed)
    if count > 4096:
        error(limit, "too many layers")
    psd.layers = try new PsdLayer[count] --- in memory.heap
    var records = try new Record[count] --- in memory.heap
    defer free(records) in memory.heap
    var infos = try new ChannelInfo[count * 8] --- in memory.heap
    defer free(infos) in memory.heap
    var no_bytes: u8[]
    for index in 0..<count:
        var record = Record(top = try reader.sdword(), left = try reader.sdword(), bottom = try reader.sdword(), right = try reader.sdword(),
                            mask_top = 0, mask_left = 0, mask_bottom = 0, mask_right = 0, mask_default = 0, channels = 0)
        record.channels = (usize)(try reader.word())
        if record.channels > 8:
            error(invalid, "a layer has more than eight channels")
        var has_mask = false
        for channel in 0..<record.channels:
            let id = (i64)(i16)(try reader.word())
            infos[index * 8 + channel] = ChannelInfo(id = id, length = try reader.length())
            if id == -2:
                has_mask = true
        if (try reader.tag()) != 0x3842494d:
            error(invalid, "a layer record lacks its 8BIM signature")
        let blend = blend_of(try reader.tag())
        let opacity = (f64)(try reader.byte()) / 255.0
        let clipping = try reader.byte()
        let flags = try reader.byte()
        _ = try reader.byte()
        let extra_length = (usize)(try reader.dword())
        let extra_end = reader.at + extra_length
        try reader.need(extra_length)
        # The layer mask's rectangle, default color and whether it is disabled.
        let mask_length = (usize)(try reader.dword())
        let mask_end = reader.at + mask_length
        var mask_enabled = true
        if mask_length >= 18:
            record.mask_top = try reader.sdword()
            record.mask_left = try reader.sdword()
            record.mask_bottom = try reader.sdword()
            record.mask_right = try reader.sdword()
            record.mask_default = try reader.byte()
            mask_enabled = ((try reader.byte()) & 2) == 0
        reader.at = mask_end
        try reader.skip((usize)(try reader.dword()))
        let name_length = (usize)(try reader.byte())
        let name_start = reader.at
        try reader.skip(name_length)
        # The Pascal name is padded so the record is a multiple of four bytes.
        try reader.skip((4 - (name_length + 1) % 4) % 4)
        var name = try new u8[name_length] --- in memory.heap
        memory.copy(name, reader.data[name_start..], name_length)
        var kind = layer_pixels
        while reader.at + 12 <= extra_end:
            let signature = try reader.tag()
            if signature != 0x3842494d and signature != 0x38423634:
                break
            let key = try reader.tag()
            let length = try reader.length() if reader.wide and wide_key(key) else (usize)(try reader.dword())
            let block_end = reader.at + length
            if block_end > extra_end:
                break
            if key == 0x6c756e69 and length >= 4:
                # luni: a UTF-16BE name; the plain characters read as bytes.
                let characters = (usize)(try reader.dword())
                if characters * 2 + 4 <= length:
                    free(name) in memory.heap
                    name = try new u8[characters] --- in memory.heap
                    for character in 0..<characters:
                        let code = try reader.word()
                        name[character] = (u8)code if code < 128 else 63
            elif key == 0x6c736374 and length >= 4:
                # lsct: 1 or 2 is a group's own record, 3 the divider ending it.
                let section = try reader.dword()
                if section == 1 or section == 2:
                    kind = group_start
                elif section == 3:
                    kind = group_end
            reader.at = block_end + (length % 2)
        reader.at = extra_end
        records[index] = record
        psd.layers[index] = PsdLayer(name = name, pixels = no_bytes, mask = no_bytes, mask_enabled = mask_enabled and has_mask, visible = (flags & 2) == 0,
                                     opacity = opacity, blend = blend, clipped = clipping != 0, kind = kind)
        psd.count = index + 1
    for index in 0..<count:
        try read_channels(reader, psd, index, records[index], infos[index * 8..<index * 8 + 8], mode)

## One layer's channel data into its pixels and, when it has one, its mask.
func read_channels(reader: Reader*, psd: Psd*, index: usize, record: Record, infos: const ChannelInfo[], mode: u16) -> !:
    let width = (usize)psd.width
    let height = (usize)psd.height
    let layer = &psd.layers[index]
    let grouping = layer.kind != layer_pixels
    let layer_width = (usize)(record.right - record.left) if record.right > record.left else 0
    let layer_height = (usize)(record.bottom - record.top) if record.bottom > record.top else 0
    let mask_width = (usize)(record.mask_right - record.mask_left) if record.mask_right > record.mask_left else 0
    let mask_height = (usize)(record.mask_bottom - record.mask_top) if record.mask_bottom > record.mask_top else 0
    var pixels: u8[]
    if not grouping:
        pixels = try new u8[width * height * 4] --- in memory.heap
        for at in 0..<pixels.length:
            pixels[at] = 0
    var has_alpha = false
    for channel in 0..<record.channels:
        if infos[channel].id == -1:
            has_alpha = true
    for channel in 0..<record.channels:
        let info = infos[channel]
        let channel_end = reader.at + info.length
        try reader.need(info.length)
        let id = info.id
        let masked = id == -2 and mask_width * mask_height > 0
        let wanted = masked or (not grouping and layer_width * layer_height > 0 and ((id >= 0 and id <= 2) or id == -1))
        if not wanted:
            reader.at = channel_end
            continue
        let plane_width = mask_width if masked else layer_width
        let plane_height = mask_height if masked else layer_height
        let plane = try new u8[plane_width * plane_height] --- in memory.heap
        defer free(plane) in memory.heap
        let compression = try reader.word()
        if compression == 0:
            try reader.need(plane.length)
            memory.copy(plane, reader.data[reader.at..], plane.length)
            reader.at += plane.length
        elif compression == 1:
            try unpack_rle(reader, plane, plane_width, plane_height)
        else:
            error(invalid, "a PSD layer uses an unsupported compression")
        if masked:
            # Outside its rectangle the mask is its default color.
            layer.mask = try new u8[width * height] --- in memory.heap
            for at in 0..<layer.mask.length:
                layer.mask[at] = record.mask_default
            for y in 0..<plane_height:
                let document_y = record.mask_top + (i64)y
                if document_y < 0 or document_y >= (i64)height:
                    continue
                for x in 0..<plane_width:
                    let document_x = record.mask_left + (i64)x
                    if document_x >= 0 and document_x < (i64)width:
                        layer.mask[(usize)document_y * width + (usize)document_x] = plane[y * plane_width + x]
        else:
            let target: usize = (usize)id if id >= 0 else 3
            for y in 0..<layer_height:
                let document_y = record.top + (i64)y
                if document_y < 0 or document_y >= (i64)height:
                    continue
                for x in 0..<layer_width:
                    let document_x = record.left + (i64)x
                    if document_x < 0 or document_x >= (i64)width:
                        continue
                    let value = plane[y * layer_width + x]
                    let offset = ((usize)document_y * width + (usize)document_x) * 4
                    if mode == 1 and id == 0:
                        pixels[offset] = value
                        pixels[offset + 1] = value
                        pixels[offset + 2] = value
                    else:
                        pixels[offset + target] = value
        reader.at = channel_end
    if grouping:
        return
    # Opaque unless an alpha channel says otherwise.
    if not has_alpha:
        for y in 0..<layer_height:
            let document_y = record.top + (i64)y
            if document_y < 0 or document_y >= (i64)height:
                continue
            for x in 0..<layer_width:
                let document_x = record.left + (i64)x
                if document_x >= 0 and document_x < (i64)width:
                    pixels[((usize)document_y * width + (usize)document_x) * 4 + 3] = 255
    layer.pixels = pixels

## A merged-only document's composite image: one layer, "Background".
func read_composite(reader: Reader*, psd: Psd*, mode: u16, channels: usize) -> !:
    let width = (usize)psd.width
    let height = (usize)psd.height
    let colors: usize = 3 if mode == 3 else 1
    let planes = channels if channels < colors + 1 else colors + 1
    if planes < colors:
        error(invalid, "the composite image lacks its color channels")
    let compression = try reader.word()
    let pixels = try new u8[width * height * 4] --- in memory.heap
    errdefer free(pixels) in memory.heap
    for at in 0..<pixels.length:
        pixels[at] = 255
    let plane = try new u8[width * height] --- in memory.heap
    defer free(plane) in memory.heap
    # PackBits keeps every channel's row counts first, then the rows.
    let counts_at = reader.at
    if compression == 1:
        try reader.skip(channels * height * (4 if reader.wide else 2))
    for channel in 0..<planes:
        if compression == 0:
            try reader.need(plane.length)
            memory.copy(plane, reader.data[reader.at..], plane.length)
            reader.at += plane.length
        elif compression == 1:
            try unpack_rows(reader, plane, width, height, counts_at, channel * height)
        else:
            error(invalid, "the composite image uses an unsupported compression")
        for at in 0..<width * height:
            if colors == 1 and channel == 0:
                # Grayscale: the one plane is every color channel.
                pixels[at * 4] = plane[at]
                pixels[at * 4 + 1] = plane[at]
                pixels[at * 4 + 2] = plane[at]
            elif channel < colors:
                pixels[at * 4 + channel] = plane[at]
            else:
                pixels[at * 4 + 3] = plane[at]
    psd.layers = try new PsdLayer[1] --- in memory.heap
    var name = try new u8[10] --- in memory.heap
    memory.copy(name, b"Background", 10)
    var no_bytes: u8[]
    psd.layers[0] = PsdLayer(name = name, pixels = pixels, mask = no_bytes, mask_enabled = false, visible = true, opacity = 1.0, blend = 0, clipped = false, kind = layer_pixels)
    psd.count = 1

## PackBits rows: a byte count per row (two bytes, four in a PSB), then runs.
func unpack_rle(reader: Reader*, plane: u8[], width: usize, height: usize) -> !:
    let counts_start = reader.at
    try reader.skip(height * (4 if reader.wide else 2))
    try unpack_rows(reader, plane, width, height, counts_start, 0)

## The rows of one plane, their byte counts in the table at `counts_at` from
## entry `first`, their data at the reader.
func unpack_rows(reader: Reader*, plane: u8[], width: usize, height: usize, counts_at: usize, first: usize) -> !:
    let size: usize = 4 if reader.wide else 2
    var offset: usize = 0
    for row in 0..<height:
        let entry = counts_at + (first + row) * size
        var row_length: usize = 0
        for byte in 0..<size:
            row_length = (row_length << 8) | (usize)reader.data[entry + byte]
        let row_end = reader.at + row_length
        try reader.need(row_length)
        var written: usize = 0
        while reader.at < row_end and written < width:
            let header = (i64)(i8)(try reader.byte())
            if header >= 0:
                let run = (usize)header + 1
                try reader.need(run)
                for index in 0..<run:
                    if written < width:
                        plane[offset + written] = reader.data[reader.at + index]
                        written += 1
                reader.at += run
            elif header != -128:
                let run = (usize)(1 - header)
                let value = try reader.byte()
                for _ in 0..<run:
                    if written < width:
                        plane[offset + written] = value
                        written += 1
        reader.at = row_end
        offset += width

## Append `values` to `bytes` at `*at`, for tests.
func put(bytes: u8[], at: usize*, values: const u8[]):
    for value in values:
        bytes[*at] = value
        *at += 1

test "a two-layer PSD with raw and RLE channels parses into positioned pictures":
    # A 4×3 RGB document: a red opaque layer over all of it, then a 2×1 green
    # layer with alpha at (1, 1), RLE-compressed, hidden, multiply.
    var bytes: u8[512]
    var at: usize = 0
    put(bytes, &at, [0x38, 0x42, 0x50, 0x53, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 4, 0, 8, 0, 3])
    put(bytes, &at, [0, 0, 0, 0, 0, 0, 0, 0])
    let mask_info_at = at
    put(bytes, &at, [0, 0, 0, 0, 0, 0, 0, 0, 0, 2])
    # Layer 1: red, rect 0,0,3,4, three channels of 12 raw bytes (+2 for compression).
    put(bytes, &at, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 3])
    put(bytes, &at, [0, 0, 0, 0, 0, 14, 0, 1, 0, 0, 0, 14, 0, 2, 0, 0, 0, 14])
    put(bytes, &at, [0x38, 0x42, 0x49, 0x4d, 0x6e, 0x6f, 0x72, 0x6d, 255, 0, 0, 0])
    put(bytes, &at, [0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0x52, 0x65, 0x64])
    # Layer 2: green with alpha, rect 1,1,2,3; channels -1, 0, 1, 2 RLE (2 + 2 + 3 bytes each).
    put(bytes, &at, [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 4])
    put(bytes, &at, [0xff, 0xff, 0, 0, 0, 7, 0, 0, 0, 0, 0, 7, 0, 1, 0, 0, 0, 7, 0, 2, 0, 0, 0, 7])
    put(bytes, &at, [0x38, 0x42, 0x49, 0x4d, 0x6d, 0x75, 0x6c, 0x20, 128, 1, 2, 0])
    put(bytes, &at, [0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0x44, 0x6f, 0x74])
    # Channel data: layer 1 raw planes.
    for channel in 0..<(usize)3:
        put(bytes, &at, [0, 0])
        for _ in 0..<(usize)12:
            put(bytes, &at, [255 if channel == 0 else 0])
    # Layer 2 RLE: one row of two pixels, "literal run of 2".
    for channel in 0..<(usize)4:
        put(bytes, &at, [0, 1, 0, 3, 1])
        let value: u8 = 255 if channel == 0 or channel == 2 else 0
        put(bytes, &at, [value, value])
    let total = at - mask_info_at - 4
    bytes[mask_info_at] = (u8)(total >> 24)
    bytes[mask_info_at + 1] = (u8)(total >> 16)
    bytes[mask_info_at + 2] = (u8)(total >> 8)
    bytes[mask_info_at + 3] = (u8)total
    let inner = total - 4
    bytes[mask_info_at + 4] = (u8)(inner >> 24)
    bytes[mask_info_at + 5] = (u8)(inner >> 16)
    bytes[mask_info_at + 6] = (u8)(inner >> 8)
    bytes[mask_info_at + 7] = (u8)inner
    var psd = try parse(bytes[..<at])
    defer psd.close()
    assert(psd.width == 4 and psd.height == 3 and psd.count == 2)
    assert((str)psd.layers[0].name == "Red" and psd.layers[0].visible and psd.layers[0].blend == 0)
    assert((str)psd.layers[1].name == "Dot" and not psd.layers[1].visible and psd.layers[1].blend == 2 and psd.layers[1].clipped)
    let red = psd.layers[0].pixels
    assert(red.length == 4 * 3 * 4 and red[(2 * 4 + 3) * 4] == 255 and red[(2 * 4 + 3) * 4 + 1] == 0 and red[(2 * 4 + 3) * 4 + 3] == 255)
    let dot = psd.layers[1].pixels
    assert(dot[(1 * 4 + 1) * 4 + 1] == 255 and dot[(1 * 4 + 1) * 4] == 0 and dot[(1 * 4 + 1) * 4 + 3] == 255)
    assert(dot[3] == 0)
    var rejected = false
    _ = parse(bytes[..<10]) catch failure:
        assert(failure.code == invalid)
        rejected = true
        recover Psd(width = 0, height = 0, count = 0)
    assert(rejected)

test "a group's records and a layer's mask come through; a merged-only document reads its composite":
    # Bottom-first: the divider ending the group, a 2×2 red layer with a mask
    # showing its top row only, then the group's own record.
    let grouped: u8[280] = [56, 66, 80, 83, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 2, 0, 8, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 242, 0, 0, 0, 238, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 66, 73, 77, 110, 111, 114, 109, 255, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 66, 73, 77, 108, 115, 99, 116, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 4, 0, 0, 0, 0, 0, 6, 0, 1, 0, 0, 0, 6, 0, 2, 0, 0, 0, 6, 255, 254, 0, 0, 0, 4, 56, 66, 73, 77, 110, 111, 114, 109, 255, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 75, 105, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 66, 73, 77, 110, 111, 114, 109, 255, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 3, 71, 114, 112, 56, 66, 73, 77, 108, 115, 99, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255]
    var psd = try parse(grouped[..<grouped.length])
    defer psd.close()
    assert(psd.count == 3 and psd.layers[0].kind == group_end and psd.layers[2].kind == group_start)
    assert((str)psd.layers[2].name == "Grp" and psd.layers[2].pixels.length == 0)
    let kid = psd.layers[1]
    assert((str)kid.name == "Kid" and kid.kind == layer_pixels and kid.pixels[0] == 255 and kid.pixels[3] == 255)
    assert(kid.mask.length == 4 and kid.mask[0] == 255 and kid.mask[1] == 255 and kid.mask[2] == 0 and kid.mask[3] == 0 and kid.mask_enabled)
    # No layers: the composite is one layer, Background.
    let merged: u8[52] = [56, 66, 80, 83, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 2, 0, 8, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]
    var flat = try parse(merged[..<merged.length])
    defer flat.close()
    assert(flat.count == 1 and (str)flat.layers[0].name == "Background")
    let pixels = flat.layers[0].pixels
    assert(pixels[0] == 10 and pixels[1] == 50 and pixels[2] == 90 and pixels[3] == 255 and pixels[12] == 40)