rich_art/

graphics.rs

//! Shared pieces of the terminal graphics protocols: images fitted to an
//! exact number of cells, animation frames resampled for them, and the
//! overlay that draws an image over cells a line already holds.
//!
//! Kitty ([`crate::kitty`]), iTerm2 ([`crate::iterm`]) and inline Sixel
//! ([`crate::sixel::SixelArt::encode_inline`]) all start here: a protocol
//! image that must take exactly `cols × rows` cells is drawn from a raster of
//! exactly `cols × cell width` by `rows × cell height` pixels, so the
//! terminal never has to scale it and never lets it spill into the next cell.
//!
//! Requires the `image` feature.

use std::io::Cursor;
use std::time::Duration;

use image::codecs::gif::GifDecoder;
use image::codecs::png::PngDecoder;
use image::codecs::webp::WebPDecoder;
use image::imageops::FilterType;
use image::{AnimationDecoder, DynamicImage, Frame, ImageDecoder, ImageError, RgbaImage};

use crate::image_art::{ImageAnchor, ImageFit};

/// The size of one terminal cell in pixels.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct CellPixels {
    pub width: u32,
    pub height: u32,
}

impl CellPixels {
    /// The conventional guess when the terminal did not say: 8×16, the classic
    /// VGA cell (the same guess [`crate::sixel::DEFAULT_CELL_PX`] makes).
    pub const DEFAULT: CellPixels = CellPixels {
        width: 8,
        height: 16,
    };

    /// A cell size, each side at least 1 and at most 512 pixels.
    pub fn new(width: u32, height: u32) -> CellPixels {
        CellPixels {
            width: width.clamp(1, 512),
            height: height.clamp(1, 512),
        }
    }

    /// The pixel size of `cols × rows` cells.
    pub fn span(self, cols: usize, rows: usize) -> (u32, u32) {
        let cols = u32::try_from(cols.clamp(1, 4096)).unwrap_or(4096);
        let rows = u32::try_from(rows.clamp(1, 4096)).unwrap_or(4096);
        (self.width * cols, self.height * rows)
    }
}

impl Default for CellPixels {
    fn default() -> Self {
        CellPixels::DEFAULT
    }
}

/// `image` scaled to fit `cols × rows` cells of `cell` pixels, keeping its
/// aspect ratio, centred on a transparent canvas of exactly that size.
pub fn fit_to_cells(image: &DynamicImage, cols: usize, rows: usize, cell: CellPixels) -> RgbaImage {
    let (width, height) = cell.span(cols, rows);
    fit_to_pixels(image, width, height)
}

/// `image` scaled to fit `width × height` pixels, keeping its aspect ratio,
/// centred on a transparent canvas of exactly that size.
pub fn fit_to_pixels(image: &DynamicImage, width: u32, height: u32) -> RgbaImage {
    let (iw, ih) = (image.width().max(1), image.height().max(1));
    // The largest size of the same shape that fits.
    let scale = f64::min(width as f64 / iw as f64, height as f64 / ih as f64);
    let fw = ((iw as f64 * scale).round() as u32).clamp(1, width);
    let fh = ((ih as f64 * scale).round() as u32).clamp(1, height);
    let filter = if scale < 1.0 {
        FilterType::Lanczos3
    } else {
        // Upscaling a tiny icon: keep its pixels crisp.
        FilterType::Nearest
    };
    let scaled = image.resize_exact(fw, fh, filter).to_rgba8();
    let mut canvas = RgbaImage::new(width, height);
    let (x, y) = ((width - fw) / 2, (height - fh) / 2);
    image::imageops::overlay(&mut canvas, &scaled, x as i64, y as i64);
    canvas
}

/// `image` filling exactly `width × height` pixels the way `fit` says:
/// [`Contain`](ImageFit::Contain) (and [`Native`](ImageFit::Native)) as
/// [`fit_to_pixels`]; [`Cover`](ImageFit::Cover) scaled to cover the canvas
/// and cropped to it, keeping the part `anchor` names;
/// [`Stretch`](ImageFit::Stretch) scaled to it, ignoring the aspect ratio.
/// Alpha is kept. Downscaling uses Lanczos3, upscaling nearest-neighbour, so
/// a tiny source stays crisp.
pub fn fill_pixels(
    image: &DynamicImage,
    width: u32,
    height: u32,
    fit: ImageFit,
    anchor: ImageAnchor,
) -> RgbaImage {
    let (width, height) = (width.max(1), height.max(1));
    let (iw, ih) = (image.width().max(1), image.height().max(1));
    let filter = |scale: f64| {
        if scale < 1.0 {
            FilterType::Lanczos3
        } else {
            FilterType::Nearest
        }
    };
    match fit {
        ImageFit::Contain | ImageFit::Native => fit_to_pixels(image, width, height),
        ImageFit::Stretch => {
            let scale = f64::min(width as f64 / iw as f64, height as f64 / ih as f64);
            image.resize_exact(width, height, filter(scale)).to_rgba8()
        }
        ImageFit::Cover => {
            // The smallest size of the same shape that covers the canvas.
            let scale = f64::max(width as f64 / iw as f64, height as f64 / ih as f64);
            let rw = ((iw as f64 * scale).ceil() as u32).max(width);
            let rh = ((ih as f64 * scale).ceil() as u32).max(height);
            let x = match anchor {
                ImageAnchor::Left | ImageAnchor::TopLeft | ImageAnchor::BottomLeft => 0,
                ImageAnchor::Right | ImageAnchor::TopRight | ImageAnchor::BottomRight => rw - width,
                _ => (rw - width) / 2,
            };
            let y = match anchor {
                ImageAnchor::Top | ImageAnchor::TopLeft | ImageAnchor::TopRight => 0,
                ImageAnchor::Bottom | ImageAnchor::BottomLeft | ImageAnchor::BottomRight => {
                    rh - height
                }
                _ => (rh - height) / 2,
            };
            image
                .resize_exact(rw, rh, filter(scale))
                .crop_imm(x, y, width, height)
                .to_rgba8()
        }
    }
}

/// `image` with a play mark drawn into its pixels at its bottom-left: a dark
/// square with a white triangle, as video posters show one. Drawn into the
/// pixels, it shows through every protocol; cells drawn over a Sixel or
/// iTerm2 picture would be covered by it.
pub fn play_mark(image: &DynamicImage) -> DynamicImage {
    let mut out = image.to_rgba8();
    let (w, h) = out.dimensions();
    let side = (w.min(h) / 5).clamp(8, 96);
    let (x0, y0) = (0, h.saturating_sub(side));
    for y in y0..h {
        for x in x0..(x0 + side).min(w) {
            // The square, darkening what is under it.
            let pixel = out.get_pixel_mut(x, y);
            for c in 0..3 {
                pixel.0[c] = (u16::from(pixel.0[c]) * 2 / 10) as u8;
            }
            pixel.0[3] = 255;
            // The triangle, pointing right, in its middle half.
            let (u, v) = (
                f64::from(x - x0) / f64::from(side),
                f64::from(y - y0) / f64::from(side),
            );
            let tip = 0.75 - (v - 0.5).abs() * 1.0;
            if (0.3..=0.75).contains(&u) && (0.25..=0.75).contains(&v) && u <= 0.3 + tip - 0.25 {
                pixel.0 = [255, 255, 255, 255];
            }
        }
    }
    DynamicImage::ImageRgba8(out)
}

/// `image` with `transforms` applied (rotation, flips, brightness,
/// contrast, gamma, grayscale), keeping its alpha: the adjustments
/// [`ImageArt`](crate::ImageArt) makes before fitting, for callers that fit
/// themselves.
pub fn adjust(image: &DynamicImage, transforms: crate::ImageTransforms) -> DynamicImage {
    crate::transform::prepare(image, transforms, None).0
}

/// `image` sharpened with an unsharp mask of radius `sigma` pixels, leaving
/// differences below `threshold` (0–255) alone. Alpha is not touched.
pub fn sharpen(image: &RgbaImage, sigma: f32, threshold: i32) -> RgbaImage {
    let mut sharpened = image::imageops::unsharpen(image, sigma.max(0.1), threshold);
    for (out, source) in sharpened.pixels_mut().zip(image.pixels()) {
        out.0[3] = source.0[3];
    }
    sharpened
}

/// Make every pixel fully opaque or fully transparent: alpha below `cutoff`
/// becomes a transparent black pixel, the rest opaque. GIF and most
/// protocols draw transparency this way, so deciding it once, here, keeps
/// every frame's edges the same.
pub fn threshold_alpha(image: &mut RgbaImage, cutoff: u8) {
    for pixel in image.pixels_mut() {
        if pixel.0[3] < cutoff {
            pixel.0 = [0, 0, 0, 0];
        } else {
            pixel.0[3] = 255;
        }
    }
}

/// Reduce `image` to `mode`'s palette with `dither`, as
/// [`ImageArt`](crate::ImageArt) does its final raster. Transparent pixels
/// (alpha under half) stay transparent and take no diffused error; the rest
/// become opaque palette colours. [`ImageColorMode::TrueColor`] leaves the
/// image as it is.
pub fn reduce_colors(
    image: &mut RgbaImage,
    mode: crate::ImageColorMode,
    dither: crate::Dither,
    distance: crate::ColorDistance,
) {
    let clear: Vec<bool> = image.pixels().map(|pixel| pixel.0[3] < 128).collect();
    if crate::image_color::preprocess(image, mode, dither, distance, Some(&clear)).is_none() {
        return;
    }
    for (pixel, clear) in image.pixels_mut().zip(clear) {
        if clear {
            pixel.0 = [0, 0, 0, 0];
        }
    }
}

/// One frame of an animation, as a full canvas, and how long it shows.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AnimationFrame {
    pub image: RgbaImage,
    pub delay: Duration,
}

/// Bounds on decoding and resampling an animation.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FrameBudget {
    /// Decoded bytes all frames may take together, at canvas size.
    pub max_bytes: usize,
    /// Frames kept at most; later frames are dropped.
    pub max_frames: usize,
    /// The shortest time a frame shows: faster frames are merged into the
    /// next, so an animation never repaints faster than this.
    pub min_delay: Duration,
}

impl Default for FrameBudget {
    fn default() -> Self {
        FrameBudget {
            max_bytes: 64 * 1024 * 1024,
            max_frames: 256,
            // 25 frames a second.
            min_delay: Duration::from_millis(40),
        }
    }
}

/// A browser's substitute for a GIF's "as fast as you can" delay of zero.
const ZERO_DELAY: Duration = Duration::from_millis(100);

fn over_budget() -> ImageError {
    ImageError::Limits(image::error::LimitError::from_kind(
        image::error::LimitErrorKind::InsufficientMemory,
    ))
}

/// A still image's one frame, decoded only if its canvas fits
/// `budget.max_bytes` (four bytes a pixel), as each animation frame must.
fn still_frame(
    decoder: impl image::ImageDecoder,
    budget: FrameBudget,
) -> Result<Vec<AnimationFrame>, ImageError> {
    let (width, height) = decoder.dimensions();
    let size = (width as usize)
        .checked_mul(height as usize)
        .and_then(|pixels| pixels.checked_mul(4))
        .ok_or_else(over_budget)?;
    if size > budget.max_bytes {
        return Err(over_budget());
    }
    let image = DynamicImage::from_decoder(decoder)?.to_rgba8();
    Ok(vec![AnimationFrame {
        image,
        delay: ZERO_DELAY,
    }])
}

/// Whether `bytes` start like a WebP file: a RIFF container of form `WEBP`.
pub(crate) fn is_webp(bytes: &[u8]) -> bool {
    bytes.len() >= 12 && bytes.starts_with(b"RIFF") && &bytes[8..12] == b"WEBP"
}

/// Decode an animated GIF, APNG or animated WebP into full-canvas frames
/// under `budget`. A still PNG or WebP decodes to one frame. Frames past
/// `budget.max_frames` are dropped; decoding stops with an error when the
/// frames so far take more than `budget.max_bytes`, and a still image whose
/// canvas alone takes more is refused before it is decoded.
pub fn decode_animation(
    bytes: &[u8],
    budget: FrameBudget,
) -> Result<Vec<AnimationFrame>, ImageError> {
    let frames: Box<dyn Iterator<Item = Result<Frame, ImageError>>> = if bytes.starts_with(b"GIF8")
    {
        let mut decoder = GifDecoder::new(Cursor::new(bytes))?;
        decoder.set_limits(image::Limits::default())?;
        Box::new(decoder.into_frames())
    } else if is_webp(bytes) {
        let mut decoder = WebPDecoder::new(Cursor::new(bytes))?;
        decoder.set_limits(image::Limits::default())?;
        if decoder.has_animation() {
            Box::new(decoder.into_frames())
        } else {
            return still_frame(decoder, budget);
        }
    } else {
        let mut decoder = PngDecoder::new(Cursor::new(bytes))?;
        decoder.set_limits(image::Limits::default())?;
        if decoder.is_apng()? {
            Box::new(decoder.apng()?.into_frames())
        } else {
            return still_frame(decoder, budget);
        }
    };
    let mut used = 0usize;
    let mut out = Vec::new();
    for frame in frames.take(budget.max_frames.max(1)) {
        let frame = frame?;
        let (numer, denom) = frame.delay().numer_denom_ms();
        let millis = numer.checked_div(denom).unwrap_or(0);
        let buffer = frame.into_buffer();
        let size = (buffer.width() as usize)
            .checked_mul(buffer.height() as usize)
            .and_then(|pixels| pixels.checked_mul(4))
            .ok_or_else(over_budget)?;
        used = used.checked_add(size).ok_or_else(over_budget)?;
        if used > budget.max_bytes {
            return Err(over_budget());
        }
        out.push(AnimationFrame {
            image: buffer,
            delay: if millis == 0 {
                ZERO_DELAY
            } else {
                Duration::from_millis(u64::from(millis))
            },
        });
    }
    Ok(out)
}

/// `frames` fitted to `width × height` pixels, then deduplicated (a frame
/// equal to the one before it only lengthens that one) and rate-limited (a
/// frame shorter than `budget.min_delay` is merged into the next). The
/// result always holds at least one frame when `frames` does.
pub fn resample(
    frames: &[AnimationFrame],
    width: u32,
    height: u32,
    budget: FrameBudget,
) -> Vec<AnimationFrame> {
    let mut out: Vec<AnimationFrame> = Vec::new();
    // Time owed by frames that were too short to show on their own.
    let mut carried = Duration::ZERO;
    for (index, frame) in frames.iter().enumerate() {
        let delay = frame.delay + carried;
        let last = index + 1 == frames.len();
        if delay < budget.min_delay && !last {
            carried = delay;
            continue;
        }
        carried = Duration::ZERO;
        let image = fit_to_pixels(
            &DynamicImage::ImageRgba8(frame.image.clone()),
            width,
            height,
        );
        match out.last_mut() {
            Some(previous) if previous.image == image => previous.delay += delay,
            _ => out.push(AnimationFrame { image, delay }),
        }
    }
    out
}

/// `image` as PNG bytes.
pub fn encode_png(image: &RgbaImage) -> Option<Vec<u8>> {
    let mut out = Vec::new();
    DynamicImage::ImageRgba8(image.clone())
        .write_to(&mut Cursor::new(&mut out), image::ImageFormat::Png)
        .ok()?;
    Some(out)
}

/// `frames` as an animated GIF that loops forever, or `None` when there is
/// nothing to encode.
pub fn encode_gif(frames: &[AnimationFrame]) -> Option<Vec<u8>> {
    use image::codecs::gif::{GifEncoder, Repeat};
    if frames.is_empty() {
        return None;
    }
    let mut out = Vec::new();
    {
        let mut encoder = GifEncoder::new_with_speed(&mut out, 10);
        encoder.set_repeat(Repeat::Infinite).ok()?;
        let frames = frames.iter().map(|frame| {
            let millis = u32::try_from(frame.delay.as_millis()).unwrap_or(u32::MAX);
            Frame::from_parts(
                frame.image.clone(),
                0,
                0,
                image::Delay::from_numer_denom_ms(millis, 1),
            )
        });
        encoder.encode_frames(frames).ok()?;
    }
    Some(out)
}

const BASE64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/// Standard base64 with padding, as every graphics protocol wants it.
pub fn base64(bytes: &[u8]) -> String {
    let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
    for chunk in bytes.chunks(3) {
        let b = [
            chunk[0],
            chunk.get(1).copied().unwrap_or(0),
            chunk.get(2).copied().unwrap_or(0),
        ];
        let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
        out.push(BASE64[(n >> 18) as usize & 63] as char);
        out.push(BASE64[(n >> 12) as usize & 63] as char);
        out.push(if chunk.len() > 1 {
            BASE64[(n >> 6) as usize & 63] as char
        } else {
            '='
        });
        out.push(if chunk.len() > 2 {
            BASE64[n as usize & 63] as char
        } else {
            '='
        });
    }
    out
}

/// Save the cursor (DECSC).
pub const SAVE_CURSOR: &str = "\x1b7";
/// Restore the cursor (DECRC).
pub const RESTORE_CURSOR: &str = "\x1b8";

/// The two escapes that draw `image` (an escape that draws at the cursor and
/// may move it) over `cols` cells a line is about to print: write the first,
/// then the cells, then the second. The cursor is saved before the cells,
/// restored to draw the image over them, and restored again then moved
/// forward past them, so wherever the protocol leaves the cursor the line
/// continues right after the cells.
pub fn overlay(image: &str, cols: usize) -> (String, String) {
    let mut after = String::with_capacity(image.len() + 16);
    after.push_str(RESTORE_CURSOR);
    after.push_str(image);
    after.push_str(RESTORE_CURSOR);
    if cols > 0 {
        after.push_str(&format!("\x1b[{cols}C"));
    }
    (SAVE_CURSOR.to_string(), after)
}

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

    #[test]
    fn base64_matches_the_rfc_vectors() {
        for (input, expected) in [
            ("", ""),
            ("f", "Zg=="),
            ("fo", "Zm8="),
            ("foo", "Zm9v"),
            ("foob", "Zm9vYg=="),
            ("fooba", "Zm9vYmE="),
            ("foobar", "Zm9vYmFy"),
        ] {
            assert_eq!(base64(input.as_bytes()), expected);
        }
    }

    #[test]
    fn fitting_gives_the_exact_canvas_and_centres() {
        let image = DynamicImage::ImageRgba8(RgbaImage::from_pixel(4, 4, Rgba([255, 0, 0, 255])));
        let fitted = fit_to_cells(&image, 2, 1, CellPixels::new(8, 16));
        assert_eq!(fitted.dimensions(), (16, 16));
        let wide = fit_to_pixels(&image, 32, 16);
        assert_eq!(wide.dimensions(), (32, 16));
        // A square in a 2:1 box: transparent margins left and right.
        assert_eq!(wide.get_pixel(0, 8).0[3], 0);
        assert_eq!(wide.get_pixel(16, 8).0, [255, 0, 0, 255]);
    }

    #[test]
    fn cover_crops_to_the_anchor_and_stretch_fills() {
        // A 4x2 image: left half red, right half blue.
        let image = DynamicImage::ImageRgba8(RgbaImage::from_fn(4, 2, |x, _| {
            if x < 2 {
                Rgba([255, 0, 0, 255])
            } else {
                Rgba([0, 0, 255, 255])
            }
        }));
        let left = fill_pixels(&image, 2, 2, ImageFit::Cover, ImageAnchor::Left);
        assert_eq!(left.dimensions(), (2, 2));
        assert!(left.pixels().all(|p| p.0 == [255, 0, 0, 255]));
        let right = fill_pixels(&image, 2, 2, ImageFit::Cover, ImageAnchor::Right);
        assert!(right.pixels().all(|p| p.0 == [0, 0, 255, 255]));
        let stretched = fill_pixels(&image, 8, 8, ImageFit::Stretch, ImageAnchor::Center);
        assert_eq!(stretched.dimensions(), (8, 8));
        assert!(stretched.pixels().all(|p| p.0[3] == 255));
        // Contain leaves transparent margins.
        let contained = fill_pixels(&image, 4, 4, ImageFit::Contain, ImageAnchor::Center);
        assert_eq!(contained.get_pixel(0, 0).0[3], 0);
    }

    #[test]
    fn adjustments_sharpening_and_alpha_keep_transparency() {
        let mut image = RgbaImage::from_pixel(3, 3, Rgba([100, 100, 100, 255]));
        image.put_pixel(1, 1, Rgba([200, 200, 200, 255]));
        image.put_pixel(0, 0, Rgba([50, 50, 50, 10]));
        let contrasted = adjust(
            &DynamicImage::ImageRgba8(image.clone()),
            crate::ImageTransforms {
                contrast: 2.0,
                ..Default::default()
            },
        )
        .to_rgba8();
        assert!(contrasted.get_pixel(1, 1).0[0] > 200);
        assert_eq!(contrasted.get_pixel(0, 0).0[3], 10);
        let sharp = sharpen(&image, 1.0, 0);
        assert!(sharp.get_pixel(1, 1).0[0] >= 200);
        assert_eq!(sharp.get_pixel(0, 0).0[3], 10);
        let mut binary = image.clone();
        threshold_alpha(&mut binary, 128);
        assert_eq!(binary.get_pixel(0, 0).0, [0, 0, 0, 0]);
        assert_eq!(binary.get_pixel(1, 1).0[3], 255);
        let mut reduced = binary.clone();
        reduce_colors(
            &mut reduced,
            crate::ImageColorMode::Ansi16,
            crate::Dither::None,
            crate::ColorDistance::Rgb,
        );
        assert_eq!(reduced.get_pixel(0, 0).0, [0, 0, 0, 0]);
        assert_eq!(reduced.get_pixel(1, 1).0[3], 255);
    }

    #[test]
    fn resampling_dedupes_and_rate_limits() {
        let red = RgbaImage::from_pixel(2, 2, Rgba([255, 0, 0, 255]));
        let blue = RgbaImage::from_pixel(2, 2, Rgba([0, 0, 255, 255]));
        let frame = |image: &RgbaImage, ms| AnimationFrame {
            image: image.clone(),
            delay: Duration::from_millis(ms),
        };
        let frames = [
            frame(&red, 100),
            frame(&red, 100),
            frame(&blue, 10),
            frame(&red, 50),
        ];
        let out = resample(&frames, 4, 4, FrameBudget::default());
        // red 200ms; blue's 10ms is carried into the red that follows it.
        assert_eq!(out.len(), 1);
        assert_eq!(out[0].delay, Duration::from_millis(260));
        let frames = [frame(&red, 100), frame(&blue, 100)];
        assert_eq!(resample(&frames, 4, 4, FrameBudget::default()).len(), 2);
    }

    #[test]
    fn overlay_saves_restores_and_steps_past_the_cells() {
        let (before, after) = overlay("IMG", 2);
        assert_eq!(before, "\x1b7");
        assert_eq!(after, "\x1b8IMG\x1b8\x1b[2C");
    }

    #[test]
    fn a_play_mark_is_drawn_into_the_pixels() {
        let poster = DynamicImage::ImageRgba8(RgbaImage::from_pixel(
            100,
            50,
            image::Rgba([200, 100, 50, 255]),
        ));
        let marked = play_mark(&poster).to_rgba8();
        // Its top right is untouched; its bottom left is darkened, with
        // white in the middle of the mark.
        assert_eq!(marked.get_pixel(99, 0).0, [200, 100, 50, 255]);
        assert_eq!(marked.get_pixel(0, 49).0, [40, 20, 10, 255]);
        assert_eq!(marked.get_pixel(4, 45).0, [255, 255, 255, 255]);
        assert_eq!(marked.dimensions(), (100, 50));
    }

    #[test]
    fn gif_round_trips_through_the_decoder() {
        let red = RgbaImage::from_pixel(2, 2, Rgba([255, 0, 0, 255]));
        let blue = RgbaImage::from_pixel(2, 2, Rgba([0, 0, 255, 255]));
        let frames = vec![
            AnimationFrame {
                image: red,
                delay: Duration::from_millis(100),
            },
            AnimationFrame {
                image: blue,
                delay: Duration::from_millis(200),
            },
        ];
        let gif = encode_gif(&frames).expect("encodes");
        let decoded = decode_animation(&gif, FrameBudget::default()).expect("decodes");
        assert_eq!(decoded.len(), 2);
        assert_eq!(decoded[1].delay, Duration::from_millis(200));
        let png = encode_png(&frames[0].image).expect("png");
        assert_eq!(
            decode_animation(&png, FrameBudget::default())
                .unwrap()
                .len(),
            1
        );
    }
}