diff --git a/crates/jpeg/src/app14.rs b/crates/jpeg/src/app14.rs new file mode 100644 index 000000000..99ddabac1 --- /dev/null +++ b/crates/jpeg/src/app14.rs @@ -0,0 +1,40 @@ +//! Adobe APP14 transform inspection for JPEG samples. + +/// Read the Adobe APP14 transform byte needed for RGB/CMYK JPEG interpretation. +pub fn adobe_transform(jpeg: &[u8]) -> Option { + let mut at = 2usize; + if jpeg.get(..2) != Some(&[0xFF, 0xD8]) { + return None; + } + while at + 1 < jpeg.len() && jpeg[at] == 0xFF { + let marker = jpeg[at + 1]; + if marker == 0xDA { + return None; + } + let len = usize::from(u16::from_be_bytes([*jpeg.get(at + 2)?, *jpeg.get(at + 3)?])); + if len < 2 { + return None; + } + let end = at.checked_add(2 + len)?; + let segment = jpeg.get(at + 4..end)?; + if marker == 0xEE && segment.get(..5) == Some(b"Adobe") { + return segment.get(11).copied(); + } + at = end; + } + None +} + +#[cfg(test)] +mod tests { + use super::adobe_transform; + #[test] + fn reads_adobe_transform_and_rejects_truncated_segments() { + let mut jpeg = vec![0xff, 0xd8, 0xff, 0xee, 0, 14]; + jpeg.extend_from_slice(b"Adobe\0\x64\0\0\0\0\x02"); + assert_eq!(adobe_transform(&jpeg), Some(2)); + assert_eq!(adobe_transform(&jpeg[..jpeg.len() - 1]), None); + assert_eq!(adobe_transform(&[0xff, 0xd8, 0xff, 0xda]), None); + assert_eq!(adobe_transform(&[0xff, 0xd8, 0xff, 0xee, 0, 1]), None); + } +} diff --git a/crates/jpeg/src/lib.rs b/crates/jpeg/src/lib.rs index 50e1bd625..23434fdd0 100644 --- a/crates/jpeg/src/lib.rs +++ b/crates/jpeg/src/lib.rs @@ -1706,3 +1706,9 @@ mod tests; /// Baseline JPEG encoder (8-bit, Huffman-coded sequential DCT). mod encode; pub use encode::{ChromaSubsampling, EncodeError, encode_baseline}; + +mod app14; +pub use app14::adobe_transform; + +mod rgba; +pub use rgba::{UnsupportedComponents, to_rgba8}; diff --git a/crates/jpeg/src/rgba.rs b/crates/jpeg/src/rgba.rs new file mode 100644 index 000000000..495c5141f --- /dev/null +++ b/crates/jpeg/src/rgba.rs @@ -0,0 +1,44 @@ +//! Conversion of decoded 8-bit JPEG samples to opaque RGBA. + +/// The JPEG component count is not supported by the RGBA conversion. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct UnsupportedComponents(pub u8); + +/// Convert grayscale, RGB or CMYK samples to opaque RGBA, ignoring incomplete trailing pixels. +pub fn to_rgba8(samples: &[u8], components: u8) -> Result, UnsupportedComponents> { + let mut rgba = Vec::with_capacity(samples.len().saturating_mul(4)); + match components { + 1 => { + for &gray in samples { + rgba.extend_from_slice(&[gray, gray, gray, 255]); + } + } + 3 => { + for rgb in samples.as_chunks::<3>().0 { + rgba.extend_from_slice(&[rgb[0], rgb[1], rgb[2], 255]); + } + } + 4 => { + for cmyk in samples.as_chunks::<4>().0 { + let (c, m, y, k) = (u16::from(cmyk[0]), u16::from(cmyk[1]), u16::from(cmyk[2]), u16::from(cmyk[3])); + let rgb = [((255 - c) * (255 - k) / 255) as u8, ((255 - m) * (255 - k) / 255) as u8, ((255 - y) * (255 - k) / 255) as u8]; + rgba.extend_from_slice(&[rgb[0], rgb[1], rgb[2], 255]); + } + } + n => return Err(UnsupportedComponents(n)), + } + Ok(rgba) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn gray_rgb_and_cmyk_conversion_matches_integer_rules() -> Result<(), UnsupportedComponents> { + assert_eq!(to_rgba8(&[12], 1)?, [12, 12, 12, 255]); + assert_eq!(to_rgba8(&[1, 2, 3, 4], 3)?, [1, 2, 3, 255]); + assert_eq!(to_rgba8(&[0, 255, 128, 0], 4)?, [255, 0, 127, 255]); + assert_eq!(to_rgba8(&[], 2), Err(UnsupportedComponents(2))); + Ok(()) + } +}