effindom-native-packaging 0.1.2

SDK-neutral native packaging primitives for EffinDOM applications
Documentation
use crate::{Error, IconRaster, IconRasterSet, Result};
use image::codecs::png::PngEncoder;
use image::{ExtendedColorType, ImageEncoder};
use std::path::PathBuf;

const WINDOWS_ICO_SIZES: &[u32] = &[16, 24, 32, 48, 64, 256];
const FAVICON_SIZES: &[u32] = &[16, 32, 48];
const LINUX_HICOLOR_SIZES: &[u32] = &[16, 24, 32, 48, 64, 128, 192, 256, 512];
const ICNS_CHUNKS: &[(u32, [u8; 4])] = &[
    (16, *b"icp4"),
    (32, *b"icp5"),
    (64, *b"icp6"),
    (128, *b"ic07"),
    (256, *b"ic08"),
    (512, *b"ic09"),
    (1024, *b"ic10"),
];

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct IconArtifact {
    pub relative_path: PathBuf,
    pub bytes: Vec<u8>,
}

pub fn encode_windows_ico(rasters: &IconRasterSet) -> Result<Vec<u8>> {
    encode_ico(rasters, WINDOWS_ICO_SIZES, |size| size == 256)
}

pub fn encode_browser_favicon(rasters: &IconRasterSet) -> Result<Vec<u8>> {
    encode_ico(rasters, FAVICON_SIZES, |_| false)
}

pub fn encode_macos_icns(rasters: &IconRasterSet) -> Result<Vec<u8>> {
    let mut chunks = Vec::with_capacity(ICNS_CHUNKS.len());
    let mut total_length = 8usize;
    for (size, chunk_type) in ICNS_CHUNKS {
        let png = encode_png(required_raster(rasters, *size)?)?;
        let chunk_length = 8usize
            .checked_add(png.len())
            .ok_or_else(|| encode_error("ICNS", "chunk length overflow"))?;
        total_length = total_length
            .checked_add(chunk_length)
            .ok_or_else(|| encode_error("ICNS", "container length overflow"))?;
        chunks.push((*chunk_type, chunk_length, png));
    }

    let mut output = Vec::with_capacity(total_length);
    output.extend_from_slice(b"icns");
    push_be_u32(&mut output, checked_u32(total_length, "ICNS container")?);
    for (chunk_type, chunk_length, png) in chunks {
        output.extend_from_slice(&chunk_type);
        push_be_u32(&mut output, checked_u32(chunk_length, "ICNS chunk")?);
        output.extend_from_slice(&png);
    }
    Ok(output)
}

pub fn encode_linux_hicolor(rasters: &IconRasterSet, icon_name: &str) -> Result<Vec<IconArtifact>> {
    validate_icon_name(icon_name)?;
    LINUX_HICOLOR_SIZES
        .iter()
        .map(|size| {
            let raster = required_raster(rasters, *size)?;
            Ok(IconArtifact {
                relative_path: PathBuf::from(format!("hicolor/{size}x{size}/apps/{icon_name}.png")),
                bytes: encode_png(raster)?,
            })
        })
        .collect()
}

fn encode_ico(
    rasters: &IconRasterSet,
    sizes: &[u32],
    use_png: impl Fn(u32) -> bool,
) -> Result<Vec<u8>> {
    let payloads = sizes
        .iter()
        .map(|size| {
            let raster = required_raster(rasters, *size)?;
            if use_png(*size) {
                encode_png(raster)
            } else {
                encode_dib(raster)
            }
        })
        .collect::<Result<Vec<_>>>()?;

    let directory_length = 6usize
        .checked_add(
            sizes
                .len()
                .checked_mul(16)
                .ok_or_else(|| encode_error("ICO", "directory length overflow"))?,
        )
        .ok_or_else(|| encode_error("ICO", "directory length overflow"))?;
    let total_length = payloads
        .iter()
        .try_fold(directory_length, |length, payload| {
            length
                .checked_add(payload.len())
                .ok_or_else(|| encode_error("ICO", "container length overflow"))
        })?;
    let mut output = Vec::with_capacity(total_length);
    push_le_u16(&mut output, 0);
    push_le_u16(&mut output, 1);
    push_le_u16(
        &mut output,
        u16::try_from(sizes.len()).map_err(|error| encode_error("ICO", error))?,
    );

    let mut offset = directory_length;
    for (size, payload) in sizes.iter().zip(&payloads) {
        output.push(if *size == 256 { 0 } else { *size as u8 });
        output.push(if *size == 256 { 0 } else { *size as u8 });
        output.push(0);
        output.push(0);
        push_le_u16(&mut output, 1);
        push_le_u16(&mut output, 32);
        push_le_u32(&mut output, checked_u32(payload.len(), "ICO payload")?);
        push_le_u32(&mut output, checked_u32(offset, "ICO payload offset")?);
        offset = offset
            .checked_add(payload.len())
            .ok_or_else(|| encode_error("ICO", "payload offset overflow"))?;
    }
    for payload in payloads {
        output.extend_from_slice(&payload);
    }
    Ok(output)
}

fn encode_dib(raster: &IconRaster) -> Result<Vec<u8>> {
    validate_raster(raster)?;
    let size = raster.size as usize;
    let xor_length = size
        .checked_mul(size)
        .and_then(|pixels| pixels.checked_mul(4))
        .ok_or_else(|| encode_error("DIB", "pixel length overflow"))?;
    let mask_stride = size
        .checked_add(31)
        .map(|bits| (bits / 32) * 4)
        .ok_or_else(|| encode_error("DIB", "mask stride overflow"))?;
    let mask_length = mask_stride
        .checked_mul(size)
        .ok_or_else(|| encode_error("DIB", "mask length overflow"))?;
    let capacity = 40usize
        .checked_add(xor_length)
        .and_then(|length| length.checked_add(mask_length))
        .ok_or_else(|| encode_error("DIB", "payload length overflow"))?;
    let mut output = Vec::with_capacity(capacity);

    push_le_u32(&mut output, 40);
    push_le_i32(&mut output, raster.size as i32);
    push_le_i32(&mut output, (raster.size * 2) as i32);
    push_le_u16(&mut output, 1);
    push_le_u16(&mut output, 32);
    push_le_u32(&mut output, 0);
    push_le_u32(&mut output, checked_u32(xor_length, "DIB pixels")?);
    push_le_i32(&mut output, 0);
    push_le_i32(&mut output, 0);
    push_le_u32(&mut output, 0);
    push_le_u32(&mut output, 0);

    for y in (0..size).rev() {
        for x in 0..size {
            let offset = (y * size + x) * 4;
            let rgba = &raster.rgba8[offset..offset + 4];
            output.extend_from_slice(&[rgba[2], rgba[1], rgba[0], rgba[3]]);
        }
    }

    let mut mask_row = vec![0u8; mask_stride];
    for y in (0..size).rev() {
        mask_row.fill(0);
        for x in 0..size {
            let alpha = raster.rgba8[(y * size + x) * 4 + 3];
            if alpha == 0 {
                mask_row[x / 8] |= 1 << (7 - (x % 8));
            }
        }
        output.extend_from_slice(&mask_row);
    }
    Ok(output)
}

pub(crate) fn encode_png(raster: &IconRaster) -> Result<Vec<u8>> {
    validate_raster(raster)?;
    let mut output = Vec::new();
    PngEncoder::new(&mut output)
        .write_image(
            &raster.rgba8,
            raster.size,
            raster.size,
            ExtendedColorType::Rgba8,
        )
        .map_err(|error| encode_error("PNG", error))?;
    Ok(output)
}

fn required_raster(rasters: &IconRasterSet, size: u32) -> Result<&IconRaster> {
    let raster = rasters.get(size).ok_or(Error::MissingIconRaster(size))?;
    validate_raster(raster)?;
    Ok(raster)
}

fn validate_raster(raster: &IconRaster) -> Result<()> {
    let expected = (raster.size as usize)
        .checked_mul(raster.size as usize)
        .and_then(|pixels| pixels.checked_mul(4))
        .ok_or_else(|| encode_error("icon raster", "byte length overflow"))?;
    if raster.rgba8.len() != expected {
        return Err(Error::InvalidIconRasterData {
            size: raster.size,
            expected,
            actual: raster.rgba8.len(),
        });
    }
    Ok(())
}

fn validate_icon_name(icon_name: &str) -> Result<()> {
    if icon_name.is_empty()
        || icon_name.starts_with('.')
        || !icon_name
            .bytes()
            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b'_'))
    {
        return Err(Error::InvalidIconName(icon_name.to_owned()));
    }
    Ok(())
}

fn checked_u32(value: usize, context: &'static str) -> Result<u32> {
    u32::try_from(value).map_err(|error| encode_error(context, error))
}

fn encode_error(format: &'static str, message: impl std::fmt::Display) -> Error {
    Error::EncodeIcon {
        format,
        message: message.to_string(),
    }
}

fn push_le_u16(output: &mut Vec<u8>, value: u16) {
    output.extend_from_slice(&value.to_le_bytes());
}

fn push_le_u32(output: &mut Vec<u8>, value: u32) {
    output.extend_from_slice(&value.to_le_bytes());
}

fn push_le_i32(output: &mut Vec<u8>, value: i32) {
    output.extend_from_slice(&value.to_le_bytes());
}

fn push_be_u32(output: &mut Vec<u8>, value: u32) {
    output.extend_from_slice(&value.to_be_bytes());
}