pltrs-codec 0.1.0

Self-contained compression and image codecs: DEFLATE/zlib, PNG/APNG, JPEG, TIFF, GIF and WebP, and an AVIF encoder
Documentation
use super::*;
use crate::test_util::{PillowFile, Rng, assert_decodes_like_pillow, mutate, pillow_bytes};
use crate::tiff::encode_rgba8;

/// Small files Pillow reads (made by the spec's TIFF writer): a label, the
/// size, the CRC-32 of the array matplotlib's `imread` returns for them,
/// and the file in base64.
const PILLOW: [PillowFile; 5] = [
    (
        "RGB LZW predictor BE",
        9,
        7,
        0x7E12_8248,
        "TU0AKgAAAOaAGkFsgkg8ShsCvt/u9rv4UukHOgOOwGumHPN5u5tncANkYCIGhh3vAEBcBBgFPB5u1+v4Fu54ilwsFxBNNAlkiIAhwMAJ0PoTiETvBvu8EhV2Ax8uN8txvCt4QEAAgCPDTAEr7dwVC4hFgSeTqegYAYSdrYCglcDjdb1EDbToFRwVFwwFzsA4ODYHcDqDoKDzhcQNEzSCbnAD3fadCKHF4oC4BdAeEz7BDtG7raoFCwVfonZoXcLpe4KgIIAuAiUxUFx+BwWAQQ8wQ3hcEgM9g60H4D3GHAcy3kA4CAAACgEAAAQAAAABAAAACQEBAAQAAAABAAAABwECAAMAAAADAAABZAEDAAMAAAABAAUAAAEGAAMAAAABAAIAAAERAAQAAAADAAABagEVAAMAAAABAAMAAAEWAAQAAAABAAAAAwEXAAQAAAADAAABdgE9AAMAAAABAAIAAAAAAAAACAAIAAgAAAAIAAAAZgAAAMQAAABdAAAAXgAAACE=",
    ),
    (
        "grey old-style LZW",
        9,
        7,
        0x8F4A_BAC6,
        "SUkqAFIAAAAA08hqxkwZNmLCat059evYN2nQggnSxIuas3rkoM2K9IhWsnrfxOnS9KiTLHDunGHTxYhRJ2bN5oGrpewSIFzi0sV7Vq0UoikBAQkAAAEEAAEAAAAJAAAAAQEEAAEAAAAHAAAAAgEDAAEAAAAIAAAAAwEDAAEAAAAFAAAABgEDAAEAAAABAAAAEQEEAAEAAAAIAAAAFQEDAAEAAAABAAAAFgEEAAEAAAAHAAAAFwEEAAEAAABKAAAAAAAAAA==",
    ),
    (
        "RGBA 16-bit associated tiles deflate",
        9,
        7,
        0xC15D_8FD1,
        "SUkqAB4CAAB42u3SO0vrcBjH8S4OR0XI4FKE4gUpkkWDeAMHFQcXh7RQ0alOBfcOLqWLHYqhKhQiEZcSlyqmDZYQjC2pbUL+SQi9JDg0hHqJl2Ip2c/pW8h2oJ838OX58UQiIyPVaiRCUV7vzw9FAeDzfXwAIEljYxwnSaK4tHRzI4q67vPxvK7zPAxnszxfKgWD19elEk1vbh4f07THpWjU4zGMaJQkp6be3kiS4yCo0eC4SsXv1/VKpdVaWKhWWy1N8/nKZU1T1bm5XE5Vi0UUvbgoFuPxxUWSjMfd9nH8zx9BwHGWHR5+fWXZWm10FIBaTZYRpNORZceZngbAcdptGLasdltVl5dfXlQ1l5uff3jI5VKpgwOSTKXc9jHM6316wrB8fnz89jafFwQYVhRBcJz19WLRcfr3G0arZVlbW8/PlsUwodDXF8Pg+Npao4HjGLa/f3+PYW77BDE0dHpKEBSFII+PFGWa/Z1Ns9NZXZWk/gIzM7Yty7q+sdH/AobZ3f39ZZhkMhxuNpP/7O1pWjLpvg9BJycEIUkrK1dXkgTA5CTLAtDrTUzwfK9nmih6d2eaNB0Klcs0LYrB4Pe3KKbTR0cApNOx2OFhsxmLue0XChCEooWCZfn9Z2eWZdsIcn5u293u7OzlZberKIFANqso9frOjijW65nM9rZhZDKJRDj8/p5IoGgg8PmJop6BgYGB/8xf/WgyaAALAAABBAABAAAACQAAAAEBBAABAAAABwAAAAIBAwAEAAAAqAIAAAMBAwABAAAACAAAAAYBAwABAAAAAgAAABUBAwABAAAABAAAAEIBBAABAAAAEAAAAEMBBAABAAAAEAAAAEQBBAABAAAACAAAAEUBBAABAAAAFQIAAFIBAwABAAAAAQAAAAAAAAAQABAAEAAQAA==",
    ),
    (
        "palette 4-bit packbits fill order 2",
        9,
        7,
        0xE973_1A4E,
        "SUkqACwAAABEgAiMpAJASIykDADARMwKiMQsygrAyCRiCsiEqmoGSEwqYgoLAAABBAABAAAACQAAAAEBBAABAAAABwAAAAIBAwABAAAABAAAAAMBAwABAAAABYAAAAYBAwABAAAAAwAAAAoBAwABAAAAAgAAABEBBAABAAAACAAAABUBAwABAAAAAQAAABYBBAABAAAABwAAABcBBAABAAAAJAAAAEABAwAwAAAAtgAAAAAAAAD1UCpDVqMugUoqS427GazHKVcM9fApFEFl6Zv4s/PePimcJenmt8bJbi1X0FzCq3Snp0vuGdx8v2xjy+gApNMz3ZBXoA5tDuyIMjdFrYjCF7RxVwK19FbMkqEzXAvcbas=",
    ),
    (
        "BigTIFF orientation 6",
        7,
        9,
        0xA5C0_1205,
        "SUkrAAgAAADOAAAAAAAAAGkLyLIa7c0f6MwOv8o3qNgfxMQsrcJVoLVDe3cA2aci5r8R1sco2N8yyNIfxdAqs8FTlII1p5oJybwK5dQMzc4z7vUjzeQs4tA427Mxt5Fcp48awLQVrsksz/U+wd8y2eJExrpY65o71o9bsZ0FjrIzvuAfxe46zM4k6dhCyrpP8Ixi14xZ0p0Rh8w5ns0hvPMcxOBTr7VYxcpV7JdszYBj17gRU+Iokukzk/Emm89UrdVKyqVG2Yhi51NU6gAKAAAAAAAAAAABBAABAAAAAAAAAAkAAAAAAAAAAQEEAAEAAAAAAAAABwAAAAAAAAACAQMAAwAAAAAAAAAIAAgACAAAAAMBAwABAAAAAAAAAAEAAAAAAAAABgEDAAEAAAAAAAAAAgAAAAAAAAARARAAAQAAAAAAAAAQAAAAAAAAABIBAwABAAAAAAAAAAYAAAAAAAAAFQEDAAEAAAAAAAAAAwAAAAAAAAAWAQQAAQAAAAAAAAAHAAAAAAAAABcBEAABAAAAAAAAAL0AAAAAAAAAAAAAAAAAAAA=",
    ),
];

fn pillow(index: usize) -> Vec<u8> {
    pillow_bytes(&PILLOW[index])
}

/// A little-endian file of one strip, `data`, with the given `(tag, type,
/// values)` entries (sorted) followed by `StripOffsets` and
/// `StripByteCounts`.
fn file(entries: &[(u16, u16, &[u32])], data: &[u8]) -> Vec<u8> {
    file_with(entries, data, (STRIP_OFFSETS, STRIP_BYTE_COUNTS), 8)
}

/// A little-endian file of one strip or tile, `data`, with the given
/// entries followed by the offset and byte count tags `chunk_tags`, the
/// offset recorded being `offset` (`data` is at 8).
fn file_with(
    entries: &[(u16, u16, &[u32])],
    data: &[u8],
    chunk_tags: (u16, u16),
    offset: u32,
) -> Vec<u8> {
    let directory = 8 + data.len().next_multiple_of(2);
    let count = entries.len() + 2;
    let mut values_at = directory + 2 + 12 * count + 4;
    let mut out = b"II*\0".to_vec();
    out.extend_from_slice(&u32::try_from(directory).unwrap().to_le_bytes());
    out.extend_from_slice(data);
    out.resize(directory, 0);
    out.extend_from_slice(&u16::try_from(count).unwrap().to_le_bytes());
    let length = u32::try_from(data.len()).unwrap();
    let strip = [
        (chunk_tags.0, 4, vec![offset]),
        (chunk_tags.1, 4, vec![length]),
    ];
    let mut values = Vec::new();
    for (tag, kind, items) in entries
        .iter()
        .map(|&(tag, kind, items)| (tag, kind, items.to_vec()))
        .chain(strip)
    {
        let packed: Vec<u8> = items
            .iter()
            .flat_map(|&v| match kind {
                3 => u16::try_from(v).unwrap().to_le_bytes().to_vec(),
                _ => v.to_le_bytes().to_vec(),
            })
            .collect();
        out.extend_from_slice(&tag.to_le_bytes());
        out.extend_from_slice(&kind.to_le_bytes());
        out.extend_from_slice(&u32::try_from(items.len()).unwrap().to_le_bytes());
        if packed.len() <= 4 {
            out.extend_from_slice(&packed);
            out.resize(out.len() + 4 - packed.len(), 0);
        } else {
            out.extend_from_slice(&u32::try_from(values_at).unwrap().to_le_bytes());
            values_at += packed.len();
            values.extend_from_slice(&packed);
        }
    }
    out.extend_from_slice(&[0; 4]);
    out.extend_from_slice(&values);
    out
}

#[test]
fn pillow_files_decode_exactly() {
    assert_decodes_like_pillow(&PILLOW, decode);
}

#[test]
fn encoder_output_round_trips() {
    let pixels: Vec<u8> = (0..5 * 3 * 4).map(|i| (i * 11 % 256) as u8).collect();
    let image = decode(&encode_rgba8(5, 3, &pixels, 96.0).unwrap()).unwrap();
    assert_eq!((image.width(), image.height()), (5, 3));
    assert_eq!(
        image.pixels(),
        &Pixels::Rgba(pixels.as_chunks::<4>().0.to_vec())
    );
}

#[test]
fn hand_built_layouts() {
    let gray16 = file(
        &[
            (256, 4, &[2]),
            (257, 4, &[1]),
            (258, 3, &[16]),
            (262, 3, &[1]),
        ],
        &[0x34, 0x12, 0xFF, 0x00],
    );
    assert_eq!(
        decode(&gray16).unwrap().pixels(),
        &Pixels::Gray16(vec![0x1234, 0xFF])
    );
    // White is zero, bits reversed: 0b0000_0101 reads 0b1010_0000.
    let bilevel = file(
        &[
            (256, 4, &[3]),
            (257, 4, &[1]),
            (258, 3, &[1]),
            (262, 3, &[0]),
            (266, 3, &[2]),
        ],
        &[0b0000_0101],
    );
    assert_eq!(
        decode(&bilevel).unwrap().pixels(),
        &Pixels::Bilevel(vec![0, 255, 0])
    );
    let palette = file(
        &[
            (256, 4, &[2]),
            (257, 4, &[1]),
            (258, 3, &[1]),
            (262, 3, &[3]),
            (320, 3, &[0x1000, 0xFFFF, 0x2000, 0, 0x3000, 0x0100]),
        ],
        &[0b0100_0000],
    );
    let Pixels::Indexed { palette, indices } = decode(&palette).unwrap().into_pixels() else {
        panic!("a palette image");
    };
    assert_eq!(indices, [0, 1]);
    assert_eq!(palette.colors(), [[0x10, 0x20, 0x30], [0xFF, 0, 1]]);
}

#[test]
fn unsupported_files_are_refused() {
    let base: [(u16, u16, &[u32]); 3] = [(256, 4, &[1]), (257, 4, &[1]), (262, 3, &[1])];
    let with = |extra: (u16, u16, &'static [u32])| {
        let mut entries = base.to_vec();
        entries.push(extra);
        entries.sort_by_key(|e| e.0);
        decode(&file(&entries, &[0]))
    };
    assert_eq!(
        with((259, 3, &[7])),
        Err(DecodeError::UnsupportedCompression(7))
    );
    assert_eq!(
        with((284, 3, &[2])),
        Err(DecodeError::UnsupportedPlanarConfiguration)
    );
    assert_eq!(with((258, 3, &[32])), Err(DecodeError::UnsupportedLayout));
    assert_eq!(with((277, 3, &[7])), Err(DecodeError::UnsupportedLayout));
    assert!(with((258, 3, &[8])).is_ok());
    let no_width = file(&[(257, 4, &[1]), (262, 3, &[1])], &[0]);
    assert_eq!(decode(&no_width), Err(DecodeError::MissingTag(256)));
    let lzw_4bit_predictor = file(
        &[
            (256, 4, &[2]),
            (257, 4, &[1]),
            (258, 3, &[4]),
            (259, 3, &[5]),
            (262, 3, &[1]),
            (317, 3, &[2]),
        ],
        &[0x80],
    );
    assert_eq!(
        decode(&lzw_4bit_predictor),
        Err(DecodeError::UnsupportedPredictor(2))
    );
    assert_eq!(decode(b"II*\0"), Err(DecodeError::NotTiff));
    assert_eq!(decode(b"MM\0*\0\0\0\0"), Err(DecodeError::NoImage));
}

#[test]
fn huge_declared_sizes_are_refused_before_allocating() {
    let huge = file(
        &[(256, 4, &[65_535]), (257, 4, &[65_535]), (262, 3, &[1])],
        &[0],
    );
    assert!(matches!(decode(&huge), Err(DecodeError::TooLarge { .. })));
    let packed = file(
        &[
            (256, 4, &[100_000]),
            (257, 4, &[1000]),
            (258, 3, &[8]),
            (259, 3, &[32_773]),
            (262, 3, &[1]),
        ],
        &[0x81, 0],
    );
    assert!(matches!(decode(&packed), Err(DecodeError::TooLarge { .. })));
    let tiles = file_with(
        &[
            (256, 4, &[1]),
            (257, 4, &[1]),
            (258, 3, &[8]),
            (259, 3, &[8]),
            (262, 3, &[1]),
            (322, 4, &[1 << 30]),
            (323, 4, &[1 << 30]),
        ],
        &[0],
        (TILE_OFFSETS, TILE_BYTE_COUNTS),
        8,
    );
    assert_eq!(
        decode(&tiles),
        Err(DecodeError::CorruptData),
        "a tile of 2^60 bytes"
    );
    let gray = [
        (256, 4, &[4][..]),
        (257, 4, &[4]),
        (258, 3, &[8]),
        (262, 3, &[1]),
    ];
    let far = file_with(&gray, &[0; 16], (STRIP_OFFSETS, STRIP_BYTE_COUNTS), 1 << 20);
    assert_eq!(decode(&far), Err(DecodeError::Truncated));
    let at_end = file_with(&gray, &[0; 16], (STRIP_OFFSETS, STRIP_BYTE_COUNTS), 120);
    assert_eq!(decode(&at_end), Err(DecodeError::Truncated));
}

#[test]
fn truncations_and_corruptions_never_panic() {
    let mut rng = Rng::new(23);
    for index in 0..PILLOW.len() {
        let data = pillow(index);
        for len in 0..data.len() {
            let _ = decode(&data[..len]);
        }
    }
    for round in 0..4000 {
        let data = pillow(round % PILLOW.len());
        let _ = decode(&mutate(&data, &mut rng));
    }
}