///|
priv struct IcoEntry {
width : Int32
height : Int32
bpp : Int32
size : Int32
offset : Int32
}
///|
fn parse_ico_dir(raw : Bytes) -> Array[IcoEntry] raise DecodeError {
if raw.length() < 6 ||
read_u16le(raw, 0) != 0 ||
(read_u16le(raw, 2) != 1 && read_u16le(raw, 2) != 2) {
raise InvalidSignature("not an ICO/CUR file")
}
let count = read_u16le(raw, 4)
if count == 0 {
raise CorruptData("ICO file has no images")
}
if raw.length() < 6 + count * 16 {
raise CorruptData("ICO directory truncated")
}
let entries : Array[IcoEntry] = []
for i in 0.. raw.length() - offset {
raise CorruptData("ICO image " + i.to_string() + " out of bounds")
}
entries.push({
width: if w == 0 {
256
} else {
w
},
height: if h == 0 {
256
} else {
h
},
bpp: read_u16le(raw, e + 6),
size,
offset,
})
}
entries
}
///|
/// Decode one ICO payload: an embedded PNG, or a headerless DIB whose height
/// covers the XOR (color) bitmap followed by the 1-bit AND (transparency)
/// mask.
fn decode_ico_payload(data : Bytes) -> ImageData raise DecodeError {
if is_png_signature(data) {
return decode_png(data)
}
if data.length() < 40 {
raise CorruptData("ICO bitmap too short")
}
let dib_size = read_u32le(data, 0).reinterpret_as_int()
if dib_size < 40 || dib_size > data.length() {
raise UnsupportedFeature(
"unsupported ICO DIB header size: " + dib_size.to_string(),
)
}
let width = read_i32le(data, 4)
let height = read_i32le(data, 8).abs() / 2
let bpp = read_u16le(data, 14)
let compression = read_u32le(data, 16).reinterpret_as_int()
let colors_used = read_u32le(data, 32).reinterpret_as_int()
check_decode_size(width, height)
let palette_len = if bpp <= 8 {
let max_entries = 1 << bpp
(if colors_used > 0 && colors_used < max_entries {
colors_used
} else {
max_entries
}) *
4
} else {
0
}
let masks_len = if compression == BI_BITFIELDS && dib_size == 40 {
12
} else {
0
}
let xor_offset = dib_size + masks_len + palette_len
// Wrap the DIB in a BMP file header with the height halved.
let bmp = FixedArray::make(14 + data.length(), b'\x00')
bmp[0] = b'\x42'
bmp[1] = b'\x4D'
write_u32le(bmp, 2, (14 + data.length()).reinterpret_as_uint())
write_u32le(bmp, 10, (14 + xor_offset).reinterpret_as_uint())
bmp.blit_from_bytes(14, data, 0, data.length())
write_u32le(bmp, 14 + 8, height.reinterpret_as_uint())
let img = decode_bmp(Bytes::from_array(bmp))
// decode_bmp validated bpp and that the XOR bitmap fits in `data`.
let xor_row = (width * bpp + 31) / 32 * 4
let and_offset = xor_offset + xor_row * height
// 32-bit bitmaps carry real alpha; the AND mask only matters when there
// is none (all alpha bytes zero, which decode_bmp treats as opaque).
let use_mask = if bpp == 32 {
let mut all_zero = true
for y in 0..
data.length().to_int64() {
return img
}
let out = img.data.to_fixedarray()
for y in 0..> 3)].to_int() >> (7 - (x & 7))) & 1) == 1 {
out[(y * width + x) * 4 + 3] = b'\x00'
}
}
}
{ width, height, data: Bytes::from_array(out), }
}
///|
/// Decode every image of an ICO / CUR file, in directory order.
pub fn decode_ico_all(raw : Bytes) -> Array[ImageData] raise DecodeError {
let images : Array[ImageData] = []
for e in parse_ico_dir(raw) {
images.push(decode_ico_payload(raw[e.offset:e.offset + e.size].to_owned()))
}
images
}
///|
/// Decode the best image of an ICO / CUR file: the largest one, preferring
/// higher bit depth among equal sizes.
pub fn decode_ico(raw : Bytes) -> ImageData raise DecodeError {
let entries = parse_ico_dir(raw)
let mut best = entries[0]
for e in entries {
let area = e.width * e.height
let best_area = best.width * best.height
if area > best_area || (area == best_area && e.bpp > best.bpp) {
best = e
}
}
decode_ico_payload(raw[best.offset:best.offset + best.size].to_owned())
}