dymokomi/luce-psd
Source of release 0.6.1
## 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)