mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-18 08:15:29 +00:00
craft-image-codecs: wrap a clipboard DIB as a BMP (dib_to_bmp, dib_layout) (#2062)
* image-codecs: wrap a clipboard DIB as a BMP (#778) Add bmp_probe::dib_to_bmp (prepend the 14-byte file header, pixel offset from the header with saturating arithmetic, try_reserve for the output) and bmp_probe::dib_layout (V4/V5 alpha-mask BI_RGB becomes BI_BITFIELDS, mask copy after the header). Both are ported from WordCraft's crates/geom/src/picture.rs so it can drop its local copies. Tests compare byte-for-byte with the originals over crafted DIBs and every prefix, and decode wrapped results. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * image-codecs: fix DIB offsets for V2/V3 bitfields and ambiguous mask copies (#778) - dib_to_bmp no longer adds 12 appended-mask bytes to the pixel offset for 52- and 56-byte BI_BITFIELDS headers, which carry their masks inside the header; the decoder reads the pixels at bfOffBits, so the offset was 12 bytes too far. - dib_layout treats 12 bytes after the header that equal the masks as an existing copy only when more bytes follow than the pixels need, so an exact-length DIB whose pixels equal the masks gets its copy inserted. - dib_layout reserves the 12 bytes before changing compression or masks, so a failed reservation returns the DIB unchanged; the mask bytes are a [u8; 12] array, not a heap copy. The differential tests against the WordCraft originals now exclude exactly the 52/56-byte bitfields offset and the exact-length payload cases, and assert the new behaviour for them. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
3e82d1719c
commit
93dac78c93
1 file changed
+442
@@ -1,5 +1,7 @@
|
||||
//! Header-only BMP dimensions and pixel-data coverage, without allocating a canvas.
|
||||
|
||||
use crate::error::CodecError;
|
||||
|
||||
/// Recognize a BMP file header with a supported DIB header kind.
|
||||
///
|
||||
/// This is a format-routing check, not full validation: dimensions and pixel data may still
|
||||
@@ -13,6 +15,115 @@ pub fn is_supported_header(b: &[u8]) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Wrap a DIB (a BMP without its 14-byte `BITMAPFILEHEADER`, as the Windows clipboard holds one
|
||||
/// for `CF_DIB` and `CF_DIBV5`) as a BMP file the decoders here read. The pixel offset is computed
|
||||
/// from the header with saturating arithmetic, so a hostile header cannot overflow; whether the
|
||||
/// pixel data exists is left to the decoder. Apply [`dib_layout`] first for clipboard DIBs.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// Returns [`CodecError::LimitExceeded`] when the output (`dib.len() + 14` bytes) cannot be allocated.
|
||||
pub fn dib_to_bmp(dib: &[u8]) -> Result<Vec<u8>, CodecError> {
|
||||
let u16_at = |at: usize| dib.get(at..at + 2).and_then(|b| b.try_into().ok()).map(u16::from_le_bytes);
|
||||
let u32_at = |at: usize| dib.get(at..at + 4).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes);
|
||||
let bi_size = u32_at(0).unwrap_or(40);
|
||||
let offset = if bi_size == 12 {
|
||||
let bpp = u16_at(10).unwrap_or(24);
|
||||
let palette = if bpp <= 8 { (1u32 << bpp) * 3 } else { 0 };
|
||||
14 + bi_size + palette
|
||||
} else {
|
||||
let bpp = u16_at(14).unwrap_or(24);
|
||||
let compression = u32_at(16).unwrap_or(0);
|
||||
let clr_used = u32_at(32).unwrap_or(0);
|
||||
let palette_entries = if clr_used != 0 {
|
||||
clr_used
|
||||
} else if bpp <= 8 {
|
||||
1u32 << bpp
|
||||
} else {
|
||||
0
|
||||
};
|
||||
// The masks of a 52- or 56-byte (V2/V3) header are inside the header; only the other
|
||||
// header kinds carry them as 12 further bytes before the pixels.
|
||||
let masks = if compression == 3 && bi_size >= 40 && !matches!(bi_size, 52 | 56) { 12 } else { 0 };
|
||||
14u32.saturating_add(bi_size).saturating_add(masks).saturating_add(palette_entries.saturating_mul(4))
|
||||
};
|
||||
let total = dib.len().saturating_add(14);
|
||||
let file_size = u32::try_from(total).unwrap_or(u32::MAX);
|
||||
let mut bmp = Vec::new();
|
||||
bmp.try_reserve_exact(total).map_err(|_| CodecError::LimitExceeded(format!("a {total}-byte BMP")))?;
|
||||
bmp.extend_from_slice(b"BM");
|
||||
bmp.extend_from_slice(&file_size.to_le_bytes());
|
||||
bmp.extend_from_slice(&[0u8; 4]);
|
||||
bmp.extend_from_slice(&offset.to_le_bytes());
|
||||
bmp.extend_from_slice(dib);
|
||||
Ok(bmp)
|
||||
}
|
||||
|
||||
/// Put a clipboard DIB with a V4 or V5 header (108 bytes or more) in the layout the decoder reads.
|
||||
/// A 32-bit one whose alpha mask is set but whose compression says `BI_RGB` is marked
|
||||
/// `BI_BITFIELDS` (with the usual colour masks when it gives none), so its alpha is kept as
|
||||
/// Windows programs mean it; arboard makes the same change. Bit fields then need the colour masks
|
||||
/// after the header too, where Windows puts a copy and the decoder skips them; a DIB without that
|
||||
/// copy gets it. Any other DIB comes back unchanged, as does one whose 12 extra bytes cannot be
|
||||
/// allocated.
|
||||
pub fn dib_layout(mut dib: Vec<u8>) -> Vec<u8> {
|
||||
let u32_at = |d: &[u8], at: usize| d.get(at..at + 4).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes);
|
||||
let Some(size) = u32_at(&dib, 0).filter(|&s| s >= 108).and_then(|s| usize::try_from(s).ok()) else { return dib };
|
||||
let put = |d: &mut Vec<u8>, at: usize, v: u32| {
|
||||
if let Some(b) = d.get_mut(at..at + 4) {
|
||||
b.copy_from_slice(&v.to_le_bytes());
|
||||
}
|
||||
};
|
||||
// Decide everything first and mutate only after the 12-byte reservation succeeded, so a failed
|
||||
// allocation returns the DIB unchanged.
|
||||
let promote = dib.get(14..16) == Some(&[32, 0]) && u32_at(&dib, 16) == Some(0) && u32_at(&dib, 52) == Some(0xFF00_0000);
|
||||
let default_masks = promote && (40..52).step_by(4).all(|at| u32_at(&dib, at) == Some(0));
|
||||
let mut masks = dib.get(40..52).and_then(|b| <[u8; 12]>::try_from(b).ok());
|
||||
if default_masks {
|
||||
let mut m = [0u8; 12];
|
||||
m[0..4].copy_from_slice(&0x00FF_0000u32.to_le_bytes());
|
||||
m[4..8].copy_from_slice(&0x0000_FF00u32.to_le_bytes());
|
||||
m[8..12].copy_from_slice(&0x0000_00FFu32.to_le_bytes());
|
||||
masks = Some(m);
|
||||
}
|
||||
let bitfields = promote || u32_at(&dib, 16) == Some(3);
|
||||
// Bytes equal to the masks right after the header are a copy only when more bytes follow than
|
||||
// the pixels need; otherwise they are the pixels (e.g. a 3x1 V5 DIB with pixels equal to the masks).
|
||||
let has_copy = |m: &[u8; 12]| {
|
||||
dib.get(size..size.saturating_add(12)) == Some(m.as_slice()) && pixel_bytes(&dib).is_none_or(|need| dib.len().saturating_sub(size) > need)
|
||||
};
|
||||
let insert = match masks {
|
||||
Some(m) if bitfields && size <= dib.len() && !has_copy(&m) => Some(m),
|
||||
_ => None,
|
||||
};
|
||||
if insert.is_some() && dib.try_reserve(12).is_err() {
|
||||
return dib;
|
||||
}
|
||||
if promote {
|
||||
put(&mut dib, 16, 3);
|
||||
if default_masks {
|
||||
put(&mut dib, 40, 0x00FF_0000);
|
||||
put(&mut dib, 44, 0x0000_FF00);
|
||||
put(&mut dib, 48, 0x0000_00FF);
|
||||
}
|
||||
}
|
||||
if let Some(m) = insert {
|
||||
dib.splice(size..size, m);
|
||||
}
|
||||
dib
|
||||
}
|
||||
|
||||
/// Bytes of pixel rows (4-byte aligned stride) the info-header dimensions of `dib` call for, or
|
||||
/// `None` when width, height or bit count cannot be read.
|
||||
fn pixel_bytes(dib: &[u8]) -> Option<usize> {
|
||||
let i32_at = |at: usize| dib.get(at..at + 4).and_then(|b| b.try_into().ok()).map(i32::from_le_bytes);
|
||||
let w = u64::try_from(i32_at(4)?).ok()?;
|
||||
let h = u64::from(i32_at(8)?.unsigned_abs());
|
||||
let bpp = u64::from(u16::from_le_bytes(dib.get(14..16)?.try_into().ok()?));
|
||||
let stride = w.checked_mul(bpp)?.div_ceil(32).checked_mul(4)?;
|
||||
usize::try_from(stride.checked_mul(h)?).ok()
|
||||
}
|
||||
|
||||
/// Coverage of the declared pixel array. Row byte counts include row padding; RLE coverage
|
||||
/// counts the pixels drawn by commands and may be smaller than the canvas.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
@@ -174,4 +285,335 @@ mod tests {
|
||||
b[0] = b'X';
|
||||
assert!(!is_supported_header(&b));
|
||||
}
|
||||
|
||||
// The WordCraft originals, kept verbatim as the oracle.
|
||||
fn oracle_dib_to_bmp(dib: &[u8]) -> Vec<u8> {
|
||||
let u16_at = |at: usize| dib.get(at..at + 2).and_then(|b| b.try_into().ok()).map(u16::from_le_bytes);
|
||||
let u32_at = |at: usize| dib.get(at..at + 4).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes);
|
||||
let bi_size = u32_at(0).unwrap_or(40);
|
||||
let offset = if bi_size == 12 {
|
||||
let bpp = u16_at(10).unwrap_or(24);
|
||||
let palette = if bpp <= 8 { (1u32 << bpp) * 3 } else { 0 };
|
||||
14 + bi_size + palette
|
||||
} else {
|
||||
let bpp = u16_at(14).unwrap_or(24);
|
||||
let compression = u32_at(16).unwrap_or(0);
|
||||
let clr_used = u32_at(32).unwrap_or(0);
|
||||
let palette_entries = if clr_used != 0 {
|
||||
clr_used
|
||||
} else if bpp <= 8 {
|
||||
1u32 << bpp
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let masks = if compression == 3 && bi_size >= 40 { 12 } else { 0 };
|
||||
14u32.saturating_add(bi_size).saturating_add(masks).saturating_add(palette_entries.saturating_mul(4))
|
||||
};
|
||||
let file_size = u32::try_from(14 + dib.len()).unwrap_or(u32::MAX);
|
||||
let mut bmp = Vec::with_capacity(14 + dib.len());
|
||||
bmp.extend_from_slice(b"BM");
|
||||
bmp.extend_from_slice(&file_size.to_le_bytes());
|
||||
bmp.extend_from_slice(&[0u8; 4]);
|
||||
bmp.extend_from_slice(&offset.to_le_bytes());
|
||||
bmp.extend_from_slice(dib);
|
||||
bmp
|
||||
}
|
||||
|
||||
fn oracle_dib_layout(mut dib: Vec<u8>) -> Vec<u8> {
|
||||
let u32_at = |d: &[u8], at: usize| d.get(at..at + 4).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes);
|
||||
let Some(size) = u32_at(&dib, 0).filter(|&s| s >= 108).and_then(|s| usize::try_from(s).ok()) else { return dib };
|
||||
let put = |d: &mut Vec<u8>, at: usize, v: u32| {
|
||||
if let Some(b) = d.get_mut(at..at + 4) {
|
||||
b.copy_from_slice(&v.to_le_bytes());
|
||||
}
|
||||
};
|
||||
if dib.get(14..16) == Some(&[32, 0]) && u32_at(&dib, 16) == Some(0) && u32_at(&dib, 52) == Some(0xFF00_0000) {
|
||||
put(&mut dib, 16, 3);
|
||||
if (40..52).step_by(4).all(|at| u32_at(&dib, at) == Some(0)) {
|
||||
put(&mut dib, 40, 0x00FF_0000);
|
||||
put(&mut dib, 44, 0x0000_FF00);
|
||||
put(&mut dib, 48, 0x0000_00FF);
|
||||
}
|
||||
}
|
||||
if u32_at(&dib, 16) == Some(3)
|
||||
&& size <= dib.len()
|
||||
&& let Some(masks) = dib.get(40..52).map(<[u8]>::to_vec)
|
||||
&& dib.get(size..size + 12) != Some(masks.as_slice())
|
||||
{
|
||||
dib.splice(size..size, masks);
|
||||
}
|
||||
dib
|
||||
}
|
||||
|
||||
fn core(bpp: u16) -> Vec<u8> {
|
||||
let mut d = Vec::new();
|
||||
d.extend_from_slice(&12u32.to_le_bytes());
|
||||
d.extend_from_slice(&2u16.to_le_bytes());
|
||||
d.extend_from_slice(&2u16.to_le_bytes());
|
||||
d.extend_from_slice(&1u16.to_le_bytes());
|
||||
d.extend_from_slice(&bpp.to_le_bytes());
|
||||
d.resize(12 + 64, 7);
|
||||
d
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn info(size: u32, bpp: u16, comp: u32, clr_used: u32, masks: [u32; 4], tail: usize) -> Vec<u8> {
|
||||
let mut d = vec![0u8; size.clamp(40, 124) as usize];
|
||||
d[0..4].copy_from_slice(&size.to_le_bytes());
|
||||
d[4..8].copy_from_slice(&2i32.to_le_bytes());
|
||||
d[8..12].copy_from_slice(&2i32.to_le_bytes());
|
||||
d[12..14].copy_from_slice(&1u16.to_le_bytes());
|
||||
d[14..16].copy_from_slice(&bpp.to_le_bytes());
|
||||
d[16..20].copy_from_slice(&comp.to_le_bytes());
|
||||
d[32..36].copy_from_slice(&clr_used.to_le_bytes());
|
||||
for (i, m) in masks.iter().enumerate() {
|
||||
if let Some(b) = d.get_mut(40 + 4 * i..44 + 4 * i) {
|
||||
b.copy_from_slice(&m.to_le_bytes());
|
||||
}
|
||||
}
|
||||
d.extend((0..tail).map(|i| (i * 31 + 5) as u8));
|
||||
d
|
||||
}
|
||||
|
||||
fn corpus() -> Vec<Vec<u8>> {
|
||||
let mut v = Vec::new();
|
||||
for bpp in [1, 4, 8, 24, 0, 99] {
|
||||
v.push(core(bpp));
|
||||
}
|
||||
for bpp in [1u16, 4, 8, 16, 24, 32, 0, 255] {
|
||||
for clr in [0u32, 1, 5, 256, u32::MAX] {
|
||||
v.push(info(40, bpp, 0, clr, [0; 4], 40));
|
||||
}
|
||||
}
|
||||
for (size, comp, masks) in [
|
||||
(40, 3, [0xFF0000, 0xFF00, 0xFF, 0]),
|
||||
(40, 3, [0; 4]),
|
||||
(52, 3, [0xFF0000, 0xFF00, 0xFF, 0]),
|
||||
(108, 3, [0xFF0000, 0xFF00, 0xFF, 0xFF00_0000]),
|
||||
(108, 0, [0xFF0000, 0xFF00, 0xFF, 0xFF00_0000]),
|
||||
(108, 0, [0, 0, 0, 0xFF00_0000]),
|
||||
(108, 0, [0; 4]),
|
||||
(124, 3, [0xFF0000, 0xFF00, 0xFF, 0xFF00_0000]),
|
||||
(124, 0, [0, 0, 0, 0xFF00_0000]),
|
||||
(124, 0, [1, 0, 0, 0xFF00_0000]),
|
||||
(124, 0, [0xFF0000, 0xFF00, 0xFF, 0]),
|
||||
(124, 1, [0, 0, 0, 0xFF00_0000]),
|
||||
(124, 3, [1, 2, 3, 4]),
|
||||
(0, 0, [0; 4]),
|
||||
(12, 0, [0; 4]),
|
||||
(u32::MAX, 3, [0; 4]),
|
||||
(u32::MAX, 0, [0; 4]),
|
||||
(200, 3, [9; 4]),
|
||||
] {
|
||||
for bpp in [8u16, 16, 32] {
|
||||
for clr in [0u32, 2, u32::MAX] {
|
||||
v.push(info(size, bpp, comp, clr, masks, 48));
|
||||
}
|
||||
}
|
||||
}
|
||||
// 52/56-byte bitfields headers with and without a pixel tail, and 3x1 V5 DIBs.
|
||||
for size in [52, 56] {
|
||||
v.push(info(size, 32, 3, 0, [0xFF0000, 0xFF00, 0xFF, 0xFF00_0000], 4));
|
||||
v.push(info(size, 32, 3, 0, [0xFF0000, 0xFF00, 0xFF, 0xFF00_0000], 0));
|
||||
}
|
||||
v.push(v5_3x1(false));
|
||||
v.push(v5_3x1(true));
|
||||
v
|
||||
}
|
||||
|
||||
/// 3x1 32-bit V5 BI_BITFIELDS whose three pixels equal the colour masks; with `copy` the DIB
|
||||
/// also holds the real 12-byte mask copy before the pixels.
|
||||
fn v5_3x1(copy: bool) -> Vec<u8> {
|
||||
let masks = [0x00FF_0000u32, 0x0000_FF00, 0x0000_00FF];
|
||||
let mut d = info(124, 32, 3, 0, [masks[0], masks[1], masks[2], 0xFF00_0000], 0);
|
||||
d[4..8].copy_from_slice(&3i32.to_le_bytes());
|
||||
d[8..12].copy_from_slice(&1i32.to_le_bytes());
|
||||
for _ in 0..usize::from(copy) + 1 {
|
||||
for m in masks {
|
||||
d.extend_from_slice(&m.to_le_bytes());
|
||||
}
|
||||
}
|
||||
d
|
||||
}
|
||||
|
||||
fn dib_u32(d: &[u8], at: usize) -> Option<u32> {
|
||||
d.get(at..at + 4).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes)
|
||||
}
|
||||
|
||||
/// Fixed case 1: a 52- or 56-byte BI_BITFIELDS header holds its masks itself, so `dib_to_bmp`
|
||||
/// no longer adds the 12 appended-mask bytes the WordCraft original added to the pixel offset.
|
||||
fn bmp_offset_fixed(dib: &[u8]) -> bool {
|
||||
matches!(dib_u32(dib, 0).unwrap_or(40), 52 | 56) && dib_u32(dib, 16) == Some(3)
|
||||
}
|
||||
|
||||
/// Fixed case 2: the original read 12 pixel bytes equal to the masks (exact-length payload) as a
|
||||
/// mask copy and inserted nothing. Returns the corrected output when `cut` is such a case.
|
||||
fn exact_length_fixed(cut: &[u8]) -> Option<Vec<u8>> {
|
||||
let o = oracle_dib_layout(cut.to_vec());
|
||||
let size = usize::try_from(dib_u32(&o, 0).filter(|&s| s >= 108)?).ok()?;
|
||||
let need = pixel_bytes(&o)?;
|
||||
let same = o.len() == cut.len()
|
||||
&& dib_u32(&o, 16) == Some(3)
|
||||
&& size <= o.len()
|
||||
&& o.get(size..size + 12).is_some()
|
||||
&& o.get(size..size + 12) == o.get(40..52)
|
||||
&& o.len() - size <= need;
|
||||
if !same {
|
||||
return None;
|
||||
}
|
||||
let mut want = o.clone();
|
||||
want.splice(size..size, o[40..52].to_vec());
|
||||
Some(want)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dib_helpers_match_the_wordcraft_originals_byte_for_byte() {
|
||||
let (mut total, mut offset_cases, mut exact_cases) = (0usize, 0usize, 0usize);
|
||||
for dib in corpus() {
|
||||
for n in 0..=dib.len() {
|
||||
let cut = &dib[..n];
|
||||
total += 1;
|
||||
let fixed_layout = exact_length_fixed(cut);
|
||||
match &fixed_layout {
|
||||
Some(want) => {
|
||||
exact_cases += 1;
|
||||
assert_eq!(&dib_layout(cut.to_vec()), want, "exact-length layout len {n}");
|
||||
}
|
||||
None => assert_eq!(dib_layout(cut.to_vec()), oracle_dib_layout(cut.to_vec()), "layout len {n}"),
|
||||
}
|
||||
if bmp_offset_fixed(cut) {
|
||||
offset_cases += 1;
|
||||
let (new, old) = (dib_to_bmp(cut).unwrap(), oracle_dib_to_bmp(cut));
|
||||
assert_eq!(new[..10], old[..10]);
|
||||
assert_eq!(new[14..], old[14..]);
|
||||
let (a, b) = (dib_u32(&new, 10).unwrap(), dib_u32(&old, 10).unwrap());
|
||||
assert_eq!(a.saturating_add(12), b, "offset len {n}");
|
||||
} else {
|
||||
assert_eq!(dib_to_bmp(cut).unwrap(), oracle_dib_to_bmp(cut), "bmp len {n}");
|
||||
}
|
||||
let both = dib_layout(cut.to_vec());
|
||||
let old_both = oracle_dib_layout(cut.to_vec());
|
||||
if fixed_layout.is_none() && !bmp_offset_fixed(&both) {
|
||||
assert_eq!(dib_to_bmp(&both).unwrap(), oracle_dib_to_bmp(&old_both));
|
||||
}
|
||||
}
|
||||
}
|
||||
eprintln!("corpus cases {total}: 52/56-byte bitfields offset {offset_cases}, exact-length payload {exact_cases}");
|
||||
assert!(offset_cases > 0 && exact_cases > 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dib_helpers_survive_pseudo_random_bytes() {
|
||||
let mut x = 0x9E37_79B9_7F4A_7C15u64;
|
||||
for len in 0..300usize {
|
||||
let d: Vec<u8> = (0..len)
|
||||
.map(|_| {
|
||||
x ^= x << 13;
|
||||
x ^= x >> 7;
|
||||
x ^= x << 17;
|
||||
x as u8
|
||||
})
|
||||
.collect();
|
||||
let laid = dib_layout(d.clone());
|
||||
if exact_length_fixed(&d).is_none() && !bmp_offset_fixed(&laid) {
|
||||
assert_eq!(dib_to_bmp(&laid).unwrap(), oracle_dib_to_bmp(&oracle_dib_layout(d)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn huge_palette_count_saturates_the_offset() {
|
||||
let b = dib_to_bmp(&info(40, 8, 0, u32::MAX, [0; 4], 8)).unwrap();
|
||||
assert_eq!(u32::from_le_bytes([b[10], b[11], b[12], b[13]]), u32::MAX);
|
||||
let b = dib_to_bmp(&info(u32::MAX, 8, 3, u32::MAX, [0; 4], 8)).unwrap();
|
||||
assert_eq!(u32::from_le_bytes([b[10], b[11], b[12], b[13]]), u32::MAX);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrapped_dibs_decode_and_keep_alpha() {
|
||||
// 2x2 32-bit V5, BI_RGB with an alpha mask, bottom-up BGRA pixels.
|
||||
let mut d = info(124, 32, 0, 0, [0, 0, 0, 0xFF00_0000], 0);
|
||||
let px = [[1u8, 2, 3, 255], [4, 5, 6, 128], [7, 8, 9, 64], [10, 11, 12, 0]];
|
||||
for p in px {
|
||||
d.extend_from_slice(&p);
|
||||
}
|
||||
let bmp = dib_to_bmp(&dib_layout(d)).unwrap();
|
||||
let img = crate::decode(&bmp).unwrap();
|
||||
let alphas: Vec<u16> = img.to_rgba8().chunks(4).map(|p| u16::from(p[3])).collect();
|
||||
assert_eq!(alphas, [64, 0, 255, 128]);
|
||||
// 24-bit plain DIB and a 12-byte core 8-bit one open too.
|
||||
let mut d = info(40, 24, 0, 0, [0; 4], 0);
|
||||
d.extend_from_slice(&[0, 0, 255, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
||||
assert!(crate::decode(&dib_to_bmp(&d).unwrap()).is_ok());
|
||||
let mut c = core(8);
|
||||
c.truncate(12);
|
||||
c.extend((0..256 * 3).map(|i| i as u8));
|
||||
c.extend_from_slice(&[0, 1, 0, 0, 2, 3, 0, 0]);
|
||||
assert!(crate::decode(&dib_to_bmp(&c).unwrap()).is_ok());
|
||||
}
|
||||
|
||||
/// 1x1 32-bit BI_BITFIELDS DIB, one pixel B=10 G=20 R=30 A=128, with the given header size.
|
||||
fn one_pixel(size: u32) -> Vec<u8> {
|
||||
let mut d = info(size, 32, 3, 0, [0xFF0000, 0xFF00, 0xFF, 0xFF00_0000], 0);
|
||||
d[4..8].copy_from_slice(&1i32.to_le_bytes());
|
||||
d[8..12].copy_from_slice(&1i32.to_le_bytes());
|
||||
if size == 40 {
|
||||
for m in [0xFF0000u32, 0xFF00, 0xFF] {
|
||||
d.extend_from_slice(&m.to_le_bytes());
|
||||
}
|
||||
}
|
||||
d.extend_from_slice(&[10, 20, 30, 128]);
|
||||
d
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bitfields_pixel_offset_for_each_header_size_decodes() {
|
||||
for size in [40u32, 52, 56] {
|
||||
let bmp = dib_to_bmp(&one_pixel(size)).unwrap();
|
||||
let off = 14 + size + if size == 40 { 12 } else { 0 };
|
||||
assert_eq!(dib_u32(&bmp, 10), Some(off), "offset for {size}");
|
||||
let img = crate::decode(&bmp).unwrap_or_else(|e| panic!("{size}-byte header: {e:?}"));
|
||||
let rgba = img.to_rgba8();
|
||||
assert_eq!(&rgba[..3], &[30, 20, 10], "size {size}");
|
||||
if size == 56 {
|
||||
assert_eq!(rgba[3], 128);
|
||||
}
|
||||
}
|
||||
// V5: the header's masks, a copy inserted by `dib_layout`, then the pixel.
|
||||
let bmp = dib_to_bmp(&dib_layout(one_pixel(124))).unwrap();
|
||||
assert_eq!(&crate::decode(&bmp).unwrap().to_rgba8()[..4], &[30, 20, 10, 128]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exact_length_pixels_equal_to_the_masks_are_not_a_mask_copy() {
|
||||
let d = v5_3x1(false);
|
||||
let laid = dib_layout(d.clone());
|
||||
assert_eq!(laid.len(), d.len() + 12);
|
||||
assert_eq!(laid[124..136], d[40..52]);
|
||||
assert_eq!(oracle_dib_layout(d).len(), laid.len() - 12, "the original skipped the insertion");
|
||||
let img = crate::decode(&dib_to_bmp(&laid).unwrap()).unwrap().to_rgba8();
|
||||
assert_eq!(img.len(), 12);
|
||||
// pixel 0 is 0x00FF0000 (blue 0, green 0, red 255 under the masks).
|
||||
assert_eq!(&img[..3], &[255, 0, 0]);
|
||||
// A real copy followed by the pixels is left alone.
|
||||
let real = v5_3x1(true);
|
||||
assert_eq!(dib_layout(real.clone()), real);
|
||||
assert!(crate::decode(&dib_to_bmp(&real).unwrap()).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn layout_decides_before_it_mutates() {
|
||||
// BI_RGB V5 with an alpha mask and no colour masks: promoted and given a copy together.
|
||||
let mut d = info(124, 32, 0, 0, [0, 0, 0, 0xFF00_0000], 16);
|
||||
d[4..8].copy_from_slice(&2i32.to_le_bytes());
|
||||
let laid = dib_layout(d.clone());
|
||||
assert_eq!(laid.len(), d.len() + 12);
|
||||
assert_eq!(dib_u32(&laid, 16), Some(3));
|
||||
// Unreadable dimensions keep the byte-equality rule.
|
||||
let mut odd = info(108, 32, 3, 0, [1, 2, 3, 0], 0);
|
||||
odd[4..8].copy_from_slice(&(-1i32).to_le_bytes());
|
||||
let copy = odd[40..52].to_vec();
|
||||
odd.extend_from_slice(©);
|
||||
assert_eq!(dib_layout(odd.clone()), odd);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user