#[derive(Clone, Copy)]
pub struct IconImage<'a> {
pub side: u32,
pub argb: &'a [u32],
}
impl<'a> IconImage<'a> {
pub fn new(side: u32, argb: &'a [u32]) -> Option<IconImage<'a>> {
if side == 0 || argb.len() != (side as usize) * (side as usize) { return None; }
Some(IconImage { side, argb })
}
pub fn to_owned(&self) -> OwnedIcon { OwnedIcon { side: self.side, argb: self.argb.to_vec() } }
}
#[derive(Clone)]
pub struct OwnedIcon {
pub side: u32,
pub argb: Vec<u32>,
}
impl OwnedIcon {
pub fn as_image(&self) -> IconImage<'_> { IconImage { side: self.side, argb: &self.argb } }
}
pub fn own_set(images: &[IconImage]) -> Vec<OwnedIcon> {
let mut v: Vec<OwnedIcon> = images.iter()
.filter(|i| i.side > 0 && i.argb.len() == (i.side as usize) * (i.side as usize))
.map(|i| i.to_owned())
.collect();
v.sort_by(|a, b| b.side.cmp(&a.side));
v
}
fn crc32(data: &[u8]) -> u32 {
let mut c: u32 = 0xffff_ffff;
for &b in data {
c ^= b as u32;
for _ in 0..8 { c = if c & 1 != 0 { (c >> 1) ^ 0xEDB8_8320 } else { c >> 1 }; }
}
!c
}
fn adler32(data: &[u8]) -> u32 {
let (mut a, mut b) = (1u32, 0u32);
for chunk in data.chunks(5552) {
for &x in chunk { a += x as u32; b += a; }
a %= 65521; b %= 65521;
}
(b << 16) | a
}
fn chunk(out: &mut Vec<u8>, ty: &[u8; 4], data: &[u8]) {
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
let start = out.len();
out.extend_from_slice(ty);
out.extend_from_slice(data);
let crc = crc32(&out[start..]);
out.extend_from_slice(&crc.to_be_bytes());
}
struct Bits { out: Vec<u8>, acc: u32, n: u32 }
impl Bits {
fn new() -> Bits { Bits { out: Vec::new(), acc: 0, n: 0 } }
fn put(&mut self, v: u32, len: u32) {
self.acc |= v << self.n;
self.n += len;
while self.n >= 8 { self.out.push(self.acc as u8); self.acc >>= 8; self.n -= 8; }
}
fn code(&mut self, v: u32, len: u32) {
let mut r = 0u32;
for i in 0..len { r |= ((v >> i) & 1) << (len - 1 - i); }
self.put(r, len);
}
fn flush(&mut self) { if self.n > 0 { self.out.push(self.acc as u8); self.acc = 0; self.n = 0; } }
}
const LEN_BASE: [u16; 29] = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
const LEN_EXTRA: [u32; 29] = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
const DIST_BASE: [u16; 30] = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
const DIST_EXTRA: [u32; 30] = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
fn fixed_lit(sym: u32) -> (u32, u32) {
match sym {
0..=143 => (0x30 + sym, 8),
144..=255 => (0x190 + sym - 144, 9),
256..=279 => (sym - 256, 7),
_ => (0xc0 + sym - 280, 8),
}
}
fn deflate(data: &[u8]) -> Vec<u8> {
const HASH_BITS: usize = 15;
const WINDOW: usize = 32768;
let mut head = vec![u32::MAX; 1 << HASH_BITS];
let mut b = Bits::new();
b.put(1, 1); b.put(1, 2);
let h3 = |d: &[u8], i: usize| -> usize {
let v = (d[i] as u32) << 16 | (d[i + 1] as u32) << 8 | d[i + 2] as u32;
((v.wrapping_mul(0x9E37_79B1)) >> (32 - HASH_BITS)) as usize
};
let mut i = 0usize;
while i < data.len() {
let mut best_len = 0usize;
let mut best_dist = 0usize;
if i + 3 <= data.len() {
let hv = h3(data, i);
let cand = head[hv];
head[hv] = i as u32;
if cand != u32::MAX {
let c = cand as usize;
let dist = i - c;
if dist <= WINDOW && dist > 0 {
let max = (data.len() - i).min(258);
let mut l = 0usize;
while l < max && data[c + l] == data[i + l] { l += 1; }
if l >= 3 { best_len = l; best_dist = dist; }
}
}
}
if best_len >= 3 {
let li = LEN_BASE.iter().rposition(|&v| v as usize <= best_len).unwrap();
let (c, n) = fixed_lit(257 + li as u32);
b.code(c, n);
b.put((best_len - LEN_BASE[li] as usize) as u32, LEN_EXTRA[li]);
let di = DIST_BASE.iter().rposition(|&v| v as usize <= best_dist).unwrap();
b.code(di as u32, 5); b.put((best_dist - DIST_BASE[di] as usize) as u32, DIST_EXTRA[di]);
for k in (i + 1)..(i + best_len).min(data.len().saturating_sub(2)) { head[h3(data, k)] = k as u32; }
i += best_len;
} else {
let (c, n) = fixed_lit(data[i] as u32);
b.code(c, n);
i += 1;
}
}
let (c, n) = fixed_lit(256); b.code(c, n);
b.flush();
b.out
}
pub fn encode_png(img: &IconImage) -> Vec<u8> {
let side = img.side as usize;
let mut raw = Vec::with_capacity(side * (side * 4 + 1));
for y in 0..side {
raw.push(1);
for x in 0..side {
let p = img.argb[y * side + x];
let cur = [(p >> 16) as u8, (p >> 8) as u8, p as u8, (p >> 24) as u8];
let left = if x == 0 { [0u8; 4] } else {
let q = img.argb[y * side + x - 1];
[(q >> 16) as u8, (q >> 8) as u8, q as u8, (q >> 24) as u8]
};
for k in 0..4 { raw.push(cur[k].wrapping_sub(left[k])); }
}
}
let mut z = vec![0x78, 0x01]; z.extend_from_slice(&deflate(&raw));
z.extend_from_slice(&adler32(&raw).to_be_bytes());
let mut ihdr = Vec::with_capacity(13);
ihdr.extend_from_slice(&(img.side).to_be_bytes());
ihdr.extend_from_slice(&(img.side).to_be_bytes());
ihdr.extend_from_slice(&[8, 6, 0, 0, 0]);
let mut out = Vec::with_capacity(z.len() + 64);
out.extend_from_slice(&[0x89, b'P', b'N', b'G', 0x0d, 0x0a, 0x1a, 0x0a]);
chunk(&mut out, b"IHDR", &ihdr);
chunk(&mut out, b"IDAT", &z);
chunk(&mut out, b"IEND", &[]);
out
}
fn icns_type(side: u32) -> Option<&'static [u8; 4]> {
Some(match side {
16 => b"icp4",
32 => b"icp5",
64 => b"icp6",
128 => b"ic07",
256 => b"ic08",
512 => b"ic09",
1024 => b"ic10",
_ => return None,
})
}
pub fn encode_icns(images: &[OwnedIcon]) -> Vec<u8> {
let mut body = Vec::new();
for img in images {
let Some(ty) = icns_type(img.side) else { continue };
let png = encode_png(&img.as_image());
body.extend_from_slice(ty);
body.extend_from_slice(&((png.len() + 8) as u32).to_be_bytes());
body.extend_from_slice(&png);
}
if body.is_empty() { return Vec::new(); }
let mut out = Vec::with_capacity(body.len() + 8);
out.extend_from_slice(b"icns");
out.extend_from_slice(&((body.len() + 8) as u32).to_be_bytes());
out.extend_from_slice(&body);
out
}
pub fn placeholder(side: u32, rgb: u32) -> OwnedIcon {
let n = side as f64;
let r = n / 5.0; let half = n / 2.0;
let mut argb = vec![0u32; (side as usize) * (side as usize)];
for y in 0..side {
for x in 0..side {
let qx = (x as f64 + 0.5 - half).abs() - (half - r);
let qy = (y as f64 + 0.5 - half).abs() - (half - r);
let outside = (qx.max(0.0).powi(2) + qy.max(0.0).powi(2)).sqrt();
let inside = qx.max(qy).min(0.0);
let d = outside + inside - r;
let a = ((0.5 - d).clamp(0.0, 1.0) * 255.0).round() as u32;
argb[(y * side + x) as usize] = (a << 24) | (rgb & 0x00ff_ffff);
}
}
OwnedIcon { side, argb }
}