Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust
26.7 KB
Raw Blame
use anyhow::{Context, Result, anyhow, bail};
use flate2::Compression;
use flate2::read::ZlibDecoder;
use flate2::write::ZlibEncoder;
use std::io::{Read, Write};

const MAGIC: u16 = 0xA5E0;
const FRAME_MAGIC: u16 = 0xF1FA;
const HEADER: usize = 128;
const OLD_PALETTE: u16 = 0x0004;
const LAYER: u16 = 0x2004;
const CEL: u16 = 0x2005;
const PROFILE: u16 = 0x2007;
const TAGS: u16 = 0x2018;
const PALETTE: u16 = 0x2019;
const SLICE: u16 = 0x2022;
const TILESET: u16 = 0x2023;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Colour {
    pub rgba: [u8; 4],
    pub name: String,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Layer {
    pub name: String,
    pub visible: bool,
    pub group: bool,
    pub tilemap: bool,
    pub level: u16,
    pub blend: u16,
    pub opacity: u8,
    pub reference: bool,
    pub background: bool,
}

impl Layer {
    pub fn image(name: &str, level: u16) -> Self {
        Self {
            name: name.to_string(),
            visible: true,
            group: false,
            tilemap: false,
            level,
            blend: 0,
            opacity: 255,
            reference: false,
            background: false,
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Picture {
    Pixels { width: u16, height: u16, rgba: Vec<u8> },
    Link(u16),
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Cel {
    pub layer: u16,
    pub frame: u16,
    pub x: i16,
    pub y: i16,
    pub opacity: u8,
    pub picture: Picture,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Tag {
    pub name: String,
    pub from: u16,
    pub to: u16,
    pub direction: u8,
    pub repeat: u16,
}

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Sprite {
    pub width: u16,
    pub height: u16,
    pub palette: Vec<Colour>,
    pub layers: Vec<Layer>,
    pub durations: Vec<u16>,
    pub cels: Vec<Cel>,
    pub tags: Vec<Tag>,
    pub notes: Vec<String>,
}

struct Reader<'a> {
    bytes: &'a [u8],
    at: usize,
}

impl<'a> Reader<'a> {
    fn take(&mut self, count: usize) -> Result<&'a [u8]> {
        let end = self
            .at
            .checked_add(count)
            .filter(|end| *end <= self.bytes.len())
            .ok_or_else(|| anyhow!("the file ends early, at byte {}", self.bytes.len()))?;
        let part = &self.bytes[self.at..end];
        self.at = end;
        Ok(part)
    }

    fn byte(&mut self) -> Result<u8> {
        Ok(self.take(1)?[0])
    }

    fn word(&mut self) -> Result<u16> {
        let b = self.take(2)?;
        Ok(u16::from_le_bytes([b[0], b[1]]))
    }

    fn short(&mut self) -> Result<i16> {
        Ok(self.word()? as i16)
    }

    fn dword(&mut self) -> Result<u32> {
        let b = self.take(4)?;
        Ok(u32::from_le_bytes([b[0], b[1], b[2], b[3]]))
    }

    fn string(&mut self) -> Result<String> {
        let length = self.word()? as usize;
        Ok(String::from_utf8_lossy(self.take(length)?).to_string())
    }

    fn rest(&mut self) -> &'a [u8] {
        let part = &self.bytes[self.at..];
        self.at = self.bytes.len();
        part
    }
}

struct RawCel {
    layer: u16,
    frame: u16,
    x: i16,
    y: i16,
    opacity: u8,
    width: u16,
    height: u16,
    data: Option<Vec<u8>>,
    link: u16,
}

fn inflate(data: &[u8], wanted: usize) -> Result<Vec<u8>> {
    let mut out = Vec::with_capacity(wanted);
    ZlibDecoder::new(data)
        .take(wanted as u64 + 1)
        .read_to_end(&mut out)
        .context("a cel's compressed pixels do not unpack")?;
    if out.len() != wanted {
        bail!("a cel unpacks to {} bytes, not the {wanted} its size needs", out.len());
    }
    Ok(out)
}

fn deflate(data: &[u8]) -> Result<Vec<u8>> {
    let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
    encoder.write_all(data)?;
    Ok(encoder.finish()?)
}

fn layer_chunk(data: &[u8], flags: u32) -> Result<Layer> {
    let mut r = Reader { bytes: data, at: 0 };
    let bits = r.word()?;
    let kind = r.word()?;
    let level = r.word()?;
    r.take(4)?;
    let blend = r.word()?;
    let opacity = r.byte()?;
    r.take(3)?;
    let name = r.string()?;
    let own_look = kind != 1 || flags & 2 != 0;
    Ok(Layer {
        name,
        visible: bits & 1 != 0,
        group: kind == 1,
        tilemap: kind == 2,
        level,
        blend: match own_look {
            true => blend,
            false => 0,
        },
        opacity: match own_look && (flags & 1 != 0 || kind == 1) {
            true => opacity,
            false => 255,
        },
        reference: bits & 64 != 0,
        background: bits & 8 != 0,
    })
}

fn cel_chunk(data: &[u8], frame: u16, bytes_per_pixel: usize) -> Result<Option<RawCel>> {
    let mut r = Reader { bytes: data, at: 0 };
    let layer = r.word()?;
    let (x, y) = (r.short()?, r.short()?);
    let opacity = r.byte()?;
    let kind = r.word()?;
    r.take(7)?;
    let plain = |width, height, data, link| RawCel {
        layer,
        frame,
        x,
        y,
        opacity,
        width,
        height,
        data,
        link,
    };
    match kind {
        0 => {
            let (width, height) = (r.word()?, r.word()?);
            let pixels = r.take(width as usize * height as usize * bytes_per_pixel)?;
            Ok(Some(plain(width, height, Some(pixels.to_vec()), 0)))
        }
        1 => Ok(Some(plain(0, 0, None, r.word()?))),
        2 => {
            let (width, height) = (r.word()?, r.word()?);
            let pixels = inflate(r.rest(), width as usize * height as usize * bytes_per_pixel)?;
            Ok(Some(plain(width, height, Some(pixels), 0)))
        }
        _ => Ok(None),
    }
}

fn palette_chunk(data: &[u8], palette: &mut Vec<Colour>) -> Result<()> {
    let mut r = Reader { bytes: data, at: 0 };
    let size = r.dword()? as usize;
    let (first, last) = (r.dword()? as usize, r.dword()? as usize);
    r.take(8)?;
    if size > 1 << 16 || last >= 1 << 16 {
        bail!("the palette says it holds {size} colours");
    }
    palette.resize(
        size.max(last + 1),
        Colour {
            rgba: [0, 0, 0, 255],
            name: String::new(),
        },
    );
    (first..=last).try_for_each(|at| {
        let named = r.word()? & 1 != 0;
        let c = r.take(4)?;
        palette[at] = Colour {
            rgba: [c[0], c[1], c[2], c[3]],
            name: match named {
                true => r.string()?,
                false => String::new(),
            },
        };
        Ok::<_, anyhow::Error>(())
    })?;
    palette.truncate(size);
    Ok(())
}

fn old_palette_chunk(data: &[u8], palette: &mut Vec<Colour>) -> Result<()> {
    let mut r = Reader { bytes: data, at: 0 };
    let packets = r.word()?;
    let mut at = 0usize;
    (0..packets).try_for_each(|_| {
        at += r.byte()? as usize;
        let count = match r.byte()? {
            0 => 256,
            n => n as usize,
        };
        (0..count).try_for_each(|_| {
            let c = r.take(3)?;
            if palette.len() <= at {
                palette.resize(
                    at + 1,
                    Colour {
                        rgba: [0, 0, 0, 255],
                        name: String::new(),
                    },
                );
            }
            palette[at].rgba = [c[0], c[1], c[2], 255];
            at += 1;
            Ok::<_, anyhow::Error>(())
        })
    })
}

fn tags_chunk(data: &[u8]) -> Result<Vec<Tag>> {
    let mut r = Reader { bytes: data, at: 0 };
    let count = r.word()?;
    r.take(8)?;
    (0..count)
        .map(|_| {
            let (from, to) = (r.word()?, r.word()?);
            let direction = r.byte()?;
            let repeat = r.word()?;
            r.take(10)?;
            Ok(Tag {
                name: r.string()?,
                from,
                to,
                direction,
                repeat,
            })
        })
        .collect()
}

fn to_rgba(raw: &[u8], depth: u16, palette: &[Colour], clear: Option<u8>) -> Vec<u8> {
    match depth {
        32 => raw.to_vec(),
        16 => raw
            .as_chunks::<2>()
            .0
            .iter()
            .flat_map(|p| [p[0], p[0], p[0], p[1]])
            .collect(),
        _ => raw
            .iter()
            .flat_map(|index| match (Some(*index) == clear, palette.get(*index as usize)) {
                (false, Some(colour)) => colour.rgba,
                _ => [0, 0, 0, 0],
            })
            .collect(),
    }
}

pub fn is_aseprite(bytes: &[u8]) -> bool {
    bytes.len() >= HEADER && u16::from_le_bytes([bytes[4], bytes[5]]) == MAGIC
}

pub fn read(bytes: &[u8]) -> Result<Sprite> {
    if !is_aseprite(bytes) {
        bail!("this is not an Aseprite file (.aseprite or .ase)");
    }
    let mut r = Reader { bytes, at: 6 };
    let frames = r.word()?;
    let (width, height) = (r.word()?, r.word()?);
    let depth = r.word()?;
    if ![8, 16, 32].contains(&depth) {
        bail!("the file has {depth} bits per pixel: Aseprite files have 8, 16 or 32");
    }
    let flags = r.dword()?;
    let speed = r.word()?;
    r.take(8)?;
    let transparent = r.byte()?;
    r.at = HEADER;
    let bytes_per_pixel = depth as usize / 8;
    let mut sprite = Sprite {
        width,
        height,
        ..Sprite::default()
    };
    let mut raw: Vec<RawCel> = Vec::new();
    let mut old_palette: Vec<Colour> = Vec::new();
    let mut dropped: Vec<&str> = Vec::new();
    (0..frames).try_for_each(|frame| {
        let start = r.at;
        let size = r.dword()? as usize;
        if r.word()? != FRAME_MAGIC {
            bail!("frame {frame} does not start where the file says it does");
        }
        let old_count = r.word()? as u32;
        let duration = r.word()?;
        r.take(2)?;
        let new_count = r.dword()?;
        let chunks = match new_count {
            0 => old_count,
            n => n,
        };
        sprite.durations.push(match duration {
            0 => speed.max(1),
            d => d,
        });
        (0..chunks).try_for_each(|_| {
            let chunk_start = r.at;
            let chunk_size = r.dword()? as usize;
            let kind = r.word()?;
            if chunk_size < 6 {
                bail!("a chunk in frame {frame} has no size");
            }
            let data = r.take(chunk_size - 6)?;
            match kind {
                LAYER => sprite.layers.push(layer_chunk(data, flags)?),
                CEL => match cel_chunk(data, frame, bytes_per_pixel)? {
                    Some(cel) => raw.push(cel),
                    None => dropped.push("tilemap cels"),
                },
                PALETTE if frame == 0 || sprite.palette.is_empty() => palette_chunk(data, &mut sprite.palette)?,
                PALETTE => dropped.push("palette changes after the first frame"),
                OLD_PALETTE if frame == 0 => old_palette_chunk(data, &mut old_palette)?,
                TAGS => sprite.tags.extend(tags_chunk(data)?),
                SLICE => dropped.push("slices"),
                TILESET => dropped.push("tilesets"),
                _ => {}
            }
            r.at = chunk_start + chunk_size;
            Ok(())
        })?;
        if size >= 16 {
            r.at = start + size;
        }
        Ok(())
    })?;
    if sprite.palette.is_empty() {
        sprite.palette = old_palette;
    }
    sprite.cels = raw
        .into_iter()
        .filter(|cel| (cel.layer as usize) < sprite.layers.len())
        .map(|cel| {
            let background = sprite.layers[cel.layer as usize].background;
            let clear = (depth == 8 && !background).then_some(transparent);
            Cel {
                layer: cel.layer,
                frame: cel.frame,
                x: cel.x,
                y: cel.y,
                opacity: cel.opacity,
                picture: match &cel.data {
                    Some(data) => Picture::Pixels {
                        width: cel.width,
                        height: cel.height,
                        rgba: to_rgba(data, depth, &sprite.palette, clear),
                    },
                    None => Picture::Link(cel.link),
                },
            }
        })
        .collect();
    if sprite.layers.iter().any(|l| l.tilemap) {
        dropped.push("tilemap layers");
    }
    dropped.sort_unstable();
    dropped.dedup();
    sprite.notes = dropped.into_iter().map(String::from).collect();
    Ok(sprite)
}

fn put_string(out: &mut Vec<u8>, text: &str) {
    let bytes = &text.as_bytes()[..text.len().min(u16::MAX as usize)];
    out.extend_from_slice(&(bytes.len() as u16).to_le_bytes());
    out.extend_from_slice(bytes);
}

fn chunk(kind: u16, data: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(data.len() + 6);
    out.extend_from_slice(&(data.len() as u32 + 6).to_le_bytes());
    out.extend_from_slice(&kind.to_le_bytes());
    out.extend_from_slice(data);
    out
}

fn profile_out() -> Vec<u8> {
    let mut data = Vec::new();
    data.extend_from_slice(&1u16.to_le_bytes());
    data.extend_from_slice(&[0; 14]);
    chunk(PROFILE, &data)
}

fn palette_out(palette: &[Colour]) -> Vec<u8> {
    let mut data = Vec::new();
    data.extend_from_slice(&(palette.len() as u32).to_le_bytes());
    data.extend_from_slice(&0u32.to_le_bytes());
    data.extend_from_slice(&(palette.len() as u32 - 1).to_le_bytes());
    data.extend_from_slice(&[0; 8]);
    palette.iter().for_each(|colour| {
        data.extend_from_slice(&(!colour.name.is_empty() as u16).to_le_bytes());
        data.extend_from_slice(&colour.rgba);
        if !colour.name.is_empty() {
            put_string(&mut data, &colour.name);
        }
    });
    chunk(PALETTE, &data)
}

fn layer_out(layer: &Layer) -> Vec<u8> {
    let bits = (layer.visible as u16) | 2 | ((layer.background as u16) << 3) | ((layer.reference as u16) << 6);
    let mut data = Vec::new();
    data.extend_from_slice(&bits.to_le_bytes());
    data.extend_from_slice(&(layer.group as u16).to_le_bytes());
    data.extend_from_slice(&layer.level.to_le_bytes());
    data.extend_from_slice(&[0; 4]);
    data.extend_from_slice(&layer.blend.to_le_bytes());
    data.push(layer.opacity);
    data.extend_from_slice(&[0; 3]);
    put_string(&mut data, &layer.name);
    chunk(LAYER, &data)
}

fn tags_out(tags: &[Tag]) -> Vec<u8> {
    let mut data = Vec::new();
    data.extend_from_slice(&(tags.len() as u16).to_le_bytes());
    data.extend_from_slice(&[0; 8]);
    tags.iter().for_each(|tag| {
        data.extend_from_slice(&tag.from.to_le_bytes());
        data.extend_from_slice(&tag.to.to_le_bytes());
        data.push(tag.direction);
        data.extend_from_slice(&tag.repeat.to_le_bytes());
        data.extend_from_slice(&[0; 10]);
        put_string(&mut data, &tag.name);
    });
    chunk(TAGS, &data)
}

fn cel_out(cel: &Cel) -> Result<Vec<u8>> {
    let mut data = Vec::new();
    data.extend_from_slice(&cel.layer.to_le_bytes());
    data.extend_from_slice(&cel.x.to_le_bytes());
    data.extend_from_slice(&cel.y.to_le_bytes());
    data.push(cel.opacity);
    match &cel.picture {
        Picture::Link(frame) => {
            data.extend_from_slice(&1u16.to_le_bytes());
            data.extend_from_slice(&[0; 7]);
            data.extend_from_slice(&frame.to_le_bytes());
        }
        Picture::Pixels { width, height, rgba } => {
            if rgba.len() != *width as usize * *height as usize * 4 {
                bail!("a cel of {width}x{height} holds {} bytes", rgba.len());
            }
            data.extend_from_slice(&2u16.to_le_bytes());
            data.extend_from_slice(&[0; 7]);
            data.extend_from_slice(&width.to_le_bytes());
            data.extend_from_slice(&height.to_le_bytes());
            data.extend_from_slice(&deflate(rgba)?);
        }
    }
    Ok(chunk(CEL, &data))
}

pub fn write(sprite: &Sprite) -> Result<Vec<u8>> {
    if sprite.durations.is_empty() || sprite.durations.len() > u16::MAX as usize {
        bail!(
            "an Aseprite file holds 1 to 65535 frames, not {}",
            sprite.durations.len()
        );
    }
    if sprite.width == 0 || sprite.height == 0 {
        bail!("an Aseprite file needs a size");
    }
    if sprite.layers.len() > u16::MAX as usize || sprite.palette.len() > 1 << 16 {
        bail!("too many layers or colours for an Aseprite file");
    }
    let frames = sprite
        .durations
        .iter()
        .enumerate()
        .map(|(frame, duration)| {
            let first: Vec<Vec<u8>> = match frame {
                0 => std::iter::once(profile_out())
                    .chain((!sprite.palette.is_empty()).then(|| palette_out(&sprite.palette)))
                    .chain(sprite.layers.iter().map(layer_out))
                    .chain((!sprite.tags.is_empty()).then(|| tags_out(&sprite.tags)))
                    .collect(),
                _ => Vec::new(),
            };
            let cels = sprite
                .cels
                .iter()
                .filter(|cel| cel.frame as usize == frame)
                .map(cel_out)
                .collect::<Result<Vec<_>>>()?;
            let chunks: Vec<Vec<u8>> = first.into_iter().chain(cels).collect();
            let size = 16 + chunks.iter().map(Vec::len).sum::<usize>();
            let mut out = Vec::with_capacity(size);
            out.extend_from_slice(&(size as u32).to_le_bytes());
            out.extend_from_slice(&FRAME_MAGIC.to_le_bytes());
            out.extend_from_slice(&(chunks.len().min(0xFFFF) as u16).to_le_bytes());
            out.extend_from_slice(&duration.to_le_bytes());
            out.extend_from_slice(&[0; 2]);
            out.extend_from_slice(&(chunks.len() as u32).to_le_bytes());
            chunks.iter().for_each(|c| out.extend_from_slice(c));
            Ok(out)
        })
        .collect::<Result<Vec<_>>>()?;
    let size = HEADER + frames.iter().map(Vec::len).sum::<usize>();
    let mut out = Vec::with_capacity(size);
    out.extend_from_slice(&(size as u32).to_le_bytes());
    out.extend_from_slice(&MAGIC.to_le_bytes());
    out.extend_from_slice(&(sprite.durations.len() as u16).to_le_bytes());
    out.extend_from_slice(&sprite.width.to_le_bytes());
    out.extend_from_slice(&sprite.height.to_le_bytes());
    out.extend_from_slice(&32u16.to_le_bytes());
    out.extend_from_slice(&3u32.to_le_bytes());
    out.extend_from_slice(&sprite.durations[0].to_le_bytes());
    out.extend_from_slice(&[0; 8]);
    out.extend_from_slice(&[0; 4]);
    out.extend_from_slice(&(sprite.palette.len().min(u16::MAX as usize) as u16).to_le_bytes());
    out.extend_from_slice(&[1, 1]);
    out.extend_from_slice(&0i16.to_le_bytes());
    out.extend_from_slice(&0i16.to_le_bytes());
    out.extend_from_slice(&16u16.to_le_bytes());
    out.extend_from_slice(&16u16.to_le_bytes());
    out.resize(HEADER, 0);
    frames.iter().for_each(|f| out.extend_from_slice(f));
    Ok(out)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn sample() -> Sprite {
        let red = [0xef, 0x23, 0x3c, 255];
        let ink = [0x22, 0x22, 0x3b, 255];
        let square = |colour: [u8; 4]| -> Vec<u8> {
            (0..6)
                .flat_map(|i| if i == 5 { [0, 0, 0, 0] } else { colour })
                .collect()
        };
        Sprite {
            width: 16,
            height: 12,
            palette: vec![
                Colour {
                    rgba: ink,
                    name: "ink".into(),
                },
                Colour {
                    rgba: red,
                    name: String::new(),
                },
            ],
            layers: vec![
                Layer::image("ground", 0),
                Layer {
                    group: true,
                    opacity: 200,
                    ..Layer::image("hero", 0)
                },
                Layer {
                    blend: 1,
                    opacity: 128,
                    visible: false,
                    ..Layer::image("shade ✦", 1)
                },
            ],
            durations: vec![100, 150, 100],
            cels: vec![
                Cel {
                    layer: 0,
                    frame: 0,
                    x: 2,
                    y: -1,
                    opacity: 255,
                    picture: Picture::Pixels {
                        width: 3,
                        height: 2,
                        rgba: square(ink),
                    },
                },
                Cel {
                    layer: 2,
                    frame: 0,
                    x: 4,
                    y: 5,
                    opacity: 90,
                    picture: Picture::Pixels {
                        width: 2,
                        height: 3,
                        rgba: square(red),
                    },
                },
                Cel {
                    layer: 0,
                    frame: 1,
                    x: 2,
                    y: -1,
                    opacity: 255,
                    picture: Picture::Link(0),
                },
                Cel {
                    layer: 2,
                    frame: 2,
                    x: 0,
                    y: 0,
                    opacity: 255,
                    picture: Picture::Pixels {
                        width: 1,
                        height: 1,
                        rgba: red.to_vec(),
                    },
                },
            ],
            tags: vec![
                Tag {
                    name: "idle".into(),
                    from: 0,
                    to: 1,
                    direction: 0,
                    repeat: 0,
                },
                Tag {
                    name: "blink".into(),
                    from: 2,
                    to: 2,
                    direction: 2,
                    repeat: 3,
                },
            ],
            notes: Vec::new(),
        }
    }

    #[test]
    fn a_sprite_written_and_read_back_is_the_same_sprite() {
        let sprite = sample();
        let bytes = write(&sprite).unwrap();
        assert!(is_aseprite(&bytes));
        assert_eq!(
            u32::from_le_bytes(bytes[0..4].try_into().unwrap()) as usize,
            bytes.len()
        );
        assert_eq!(u16::from_le_bytes([bytes[6], bytes[7]]), 3);
        assert_eq!(u16::from_le_bytes([bytes[12], bytes[13]]), 32);
        assert_eq!(read(&bytes).unwrap(), sprite);
        assert!(
            read(&bytes[..bytes.len() - 9])
                .unwrap_err()
                .to_string()
                .contains("ends early")
        );
        assert!(
            read(b"GIF89a")
                .unwrap_err()
                .to_string()
                .contains("not an Aseprite file")
        );
        assert!(
            write(&Sprite {
                durations: Vec::new(),
                ..sample()
            })
            .is_err()
        );
    }

    fn by_hand(depth: u16, flags: u32, transparent: u8, chunks: &[Vec<u8>]) -> Vec<u8> {
        let size = 16 + chunks.iter().map(Vec::len).sum::<usize>();
        let mut out = Vec::new();
        out.extend_from_slice(&((HEADER + size) as u32).to_le_bytes());
        out.extend_from_slice(&MAGIC.to_le_bytes());
        out.extend_from_slice(&1u16.to_le_bytes());
        out.extend_from_slice(&4u16.to_le_bytes());
        out.extend_from_slice(&2u16.to_le_bytes());
        out.extend_from_slice(&depth.to_le_bytes());
        out.extend_from_slice(&flags.to_le_bytes());
        out.extend_from_slice(&125u16.to_le_bytes());
        out.extend_from_slice(&[0; 8]);
        out.push(transparent);
        out.resize(HEADER, 0);
        out.extend_from_slice(&(size as u32).to_le_bytes());
        out.extend_from_slice(&FRAME_MAGIC.to_le_bytes());
        out.extend_from_slice(&(chunks.len() as u16).to_le_bytes());
        out.extend_from_slice(&[0; 8]);
        chunks.iter().for_each(|c| out.extend_from_slice(c));
        out
    }

    fn raw_cel(layer: u16, pixels: &[u8], width: u16, height: u16) -> Vec<u8> {
        let mut data = Vec::new();
        data.extend_from_slice(&layer.to_le_bytes());
        data.extend_from_slice(&[0; 4]);
        data.push(255);
        data.extend_from_slice(&0u16.to_le_bytes());
        data.extend_from_slice(&[0; 7]);
        data.extend_from_slice(&width.to_le_bytes());
        data.extend_from_slice(&height.to_le_bytes());
        data.extend_from_slice(pixels);
        chunk(CEL, &data)
    }

    #[test]
    fn indexed_and_grey_files_with_old_chunk_counts_and_raw_cels_are_read() {
        let palette = [
            Colour {
                rgba: [255, 0, 255, 255],
                name: String::new(),
            },
            Colour {
                rgba: [10, 20, 30, 255],
                name: "night".into(),
            },
            Colour {
                rgba: [200, 210, 220, 128],
                name: String::new(),
            },
        ];
        let back = Layer {
            background: true,
            ..Layer::image("back", 0)
        };
        let indexed = by_hand(
            8,
            1,
            0,
            &[
                palette_out(&palette),
                layer_out(&back),
                layer_out(&Layer::image("top", 0)),
                raw_cel(0, &[0, 1, 2, 9], 4, 1),
                raw_cel(1, &[0, 1, 2, 9], 4, 1),
            ],
        );
        let sprite = read(&indexed).unwrap();
        assert_eq!(
            sprite.durations,
            [125],
            "a frame without a duration takes the file's speed"
        );
        assert_eq!(sprite.palette, palette);
        let pixels = |at: usize| match &sprite.cels[at].picture {
            Picture::Pixels { rgba, .. } => rgba.clone(),
            Picture::Link(_) => panic!("a link"),
        };
        assert_eq!(
            pixels(0),
            [255, 0, 255, 255, 10, 20, 30, 255, 200, 210, 220, 128, 0, 0, 0, 0],
            "on the background layer index 0 is a colour; an index past the palette is clear"
        );
        assert_eq!(pixels(1)[..4], [0, 0, 0, 0], "elsewhere the transparent index is clear");
        let grey = by_hand(
            16,
            0,
            0,
            &[
                layer_out(&Layer {
                    opacity: 40,
                    ..Layer::image("g", 0)
                }),
                raw_cel(0, &[7, 255, 90, 128], 2, 1),
            ],
        );
        let sprite = read(&grey).unwrap();
        assert_eq!(
            sprite.layers[0].opacity, 255,
            "without the flag a layer's opacity is not valid"
        );
        assert_eq!(
            sprite.cels[0].picture,
            Picture::Pixels {
                width: 2,
                height: 1,
                rgba: vec![7, 7, 7, 255, 90, 90, 90, 128]
            }
        );
        let mut old = Vec::new();
        old.extend_from_slice(&1u16.to_le_bytes());
        old.extend_from_slice(&[0, 2, 1, 2, 3, 4, 5, 6]);
        let sprite = read(&by_hand(32, 1, 0, &[chunk(OLD_PALETTE, &old), chunk(SLICE, &[0; 4])])).unwrap();
        let colours: Vec<[u8; 4]> = sprite.palette.iter().map(|c| c.rgba).collect();
        assert_eq!(colours, [[1, 2, 3, 255], [4, 5, 6, 255]]);
        assert_eq!(sprite.notes, ["slices"]);
    }
}