PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
M11: the optimizer stores eight-bit black-and-white grey images at one bit
Grzegorz Martens3d6e11ecdb7f
diff --git a/crates/optimize/src/images.rs b/crates/optimize/src/images.rsindex 57e583a07..33e60256e 100644--- a/crates/optimize/src/images.rs+++ b/crates/optimize/src/images.rs@@ -604,6 +604,59 @@ fn mono(doc: &Document, s: &Stream, compression: MonoCompression) -> Option<Stre(crate::stored_len(&new)? < crate::stored_len(s)?).then_some(new)}+/// An eight-bit grey image whose every sample is 0 or 255, stored at one bit per pixel and then as+/// `compression` asks (see [`mono`]), if that is smaller as stored. Lossless: a decode array maps+/// 0 and 255 at eight bits as it maps 0 and 1 at one bit, so it stays. Left alone: indexed images+/// (their samples are palette indices), a colour-key `/Mask` (its ranges are in eight-bit values),+/// and everything when `compression` is Retain.+fn bilevel_grey(doc: &Document, s: &Stream, compression: MonoCompression) -> Option<Stream> {+ if compression == MonoCompression::Retain {+ return None;+ }+ let d = &s.dict;+ let indexed = |cs: &Object| match &*doc.resolve(cs) {+ Object::Array(a) => matches!(a.first().and_then(Object::as_name), Some(b"Indexed" | b"I")),+ _ => false,+ };+ let colour_key = d.get(b"Mask").is_some_and(|m| doc.resolve(m).as_array().is_some());+ if d.int(b"BitsPerComponent") != Some(8)+ || matches!(d.get(b"ImageMask"), Some(Object::Bool(true)))+ || colour_key+ || !d.get(b"ColorSpace").is_some_and(|cs| one_component(doc, cs) && !indexed(cs))+ {+ return None;+ }+ // Through u32 first, as everywhere here, so the product can't overflow.+ let (w, h) = (u32::try_from(d.int(b"Width")?).ok()?, u32::try_from(d.int(b"Height")?).ok()?);+ if w == 0 || h == 0 || u64::from(w) * u64::from(h) > MAX_PIXELS {+ return None;+ }+ let (w, h) = (usize::try_from(w).ok()?, usize::try_from(h).ok()?);+ let samples = s.decoded().ok()?;+ let samples = samples.get(..w.checked_mul(h)?)?;+ let stride = w.div_ceil(8);+ let mut packed = vec![0u8; stride.checked_mul(h)?];+ for (i, v) in samples.iter().enumerate() {+ match v {+ 0 => {}+ 255 => {+ if let Some(b) = packed.get_mut((i / w) * stride + (i % w) / 8) {+ *b |= 0x80 >> (i % w % 8);+ }+ }+ _ => return None,+ }+ }+ let mut one_bit = d.clone();+ for k in [&b"Filter"[..], b"DecodeParms", b"Length", b"DL"] {+ one_bit.remove(k);+ }+ one_bit.set(b"BitsPerComponent".to_vec(), Object::Int(1));+ let one_bit = Stream::flate(one_bit, &packed);+ let best = mono(doc, &one_bit, compression).unwrap_or(one_bit);+ (crate::stored_len(&best)? < crate::stored_len(s)?).then_some(best)+}+pub(crate) fn run(doc: &mut Document,pages: &[ObjRef],@@ -630,7 +683,7 @@ pub(crate) fn run(let obj = doc.get(r);let Object::Stream(s) = &*obj else { continue };report.images += 1;- if let Some(new) = mono(doc, s, settings.mono) {+ if let Some(new) = mono(doc, s, settings.mono).or_else(|| bilevel_grey(doc, s, settings.mono)) {report.image_bytes_before += s.raw.len();report.image_bytes_after += new.raw.len();report.images_recompressed += 1;diff --git a/crates/optimize/tests/optimize.rs b/crates/optimize/tests/optimize.rsindex 3fce1dadb..8993c598f 100644--- a/crates/optimize/tests/optimize.rs+++ b/crates/optimize/tests/optimize.rs@@ -588,6 +588,76 @@ fn images_whose_data_decodes_far_past_their_samples_are_left_alone() {assert!(stream(&doc, eight_bit).dict.int(b"Width").is_some_and(|nw| nw < i64::from(w)), "8-bit hex text in lines: resampled");}+/// Eight-bit samples (0 or 255) from rows of one-bit ones.+fn eight_bit(bits: &[u8], w: u32, h: u32) -> Vec<u8> {+ let stride = (w as usize).div_ceil(8);+ (0..h as usize).flat_map(|y| (0..w as usize).map(move |x| if bits[y * stride + x / 8] & (0x80 >> (x % 8)) != 0 { 255 } else { 0 })).collect()+}++/// Eight-bit grey images of only black and white (as some scanners and converters write scans)+/// become one-bit Group 4, losslessly: the page looks the same, an inverting decode array+/// included. Not touched by this: a grey image with any other shade, an indexed image (its samples+/// are palette indices), one masked by colour key, and everything with `mono: Retain`.+#[test]+fn eight_bit_black_and_white_images_become_one_bit() {+ let mut doc = Document::new_empty();+ let (w, h) = (1200, 480);+ let grey = eight_bit(&bilevel(w, h, false), w, h);+ let image = |doc: &mut Document, data: &[u8], entries: &[(&str, Object)]| {+ let mut d = Dict::new();+ d.set(b"Type".to_vec(), Object::name("XObject"));+ d.set(b"Subtype".to_vec(), Object::name("Image"));+ d.set(b"Width".to_vec(), Object::Int(w as i64));+ d.set(b"Height".to_vec(), Object::Int(h as i64));+ d.set(b"BitsPerComponent".to_vec(), Object::Int(8));+ for (k, v) in entries {+ d.set(k.as_bytes().to_vec(), v.clone());+ }+ doc.add(Object::Stream(Stream::flate(d, data)))+ };+ let gray_cs = ("ColorSpace", Object::name("DeviceGray"));+ let plain = image(&mut doc, &grey, std::slice::from_ref(&gray_cs));+ let decode = Object::Array(vec![1.into(), 0.into()]);+ let inverted = image(&mut doc, &grey, &[gray_cs.clone(), ("Decode", decode.clone())]);+ let mut shaded = grey.clone();+ shaded[1000] = 128;+ let shade = image(&mut doc, &shaded, std::slice::from_ref(&gray_cs));+ let palette = Object::Array(vec![+ Object::name("Indexed"),+ Object::name("DeviceGray"),+ 255.into(),+ Object::String(pdfcraft_cos::PdfString::literal((0..=255u8).rev().collect::<Vec<_>>())),+ ]);+ let indexed = image(&mut doc, &grey, &[("ColorSpace", palette)]);+ let keyed = image(&mut doc, &grey, &[gray_cs, ("Mask", Object::Array(vec![0.into(), 0.into()]))]);+ page(+ &mut doc,+ &[("A", plain), ("B", inverted), ("C", shade), ("D", indexed), ("E", keyed)],+ "q 300 0 0 120 20 660 cm /A Do Q q 300 0 0 120 320 660 cm /B Do Q q 300 0 0 120 20 520 cm /C Do Q \+ q 300 0 0 120 320 520 cm /D Do Q q 300 0 0 120 20 380 cm /E Do Q",+ );+ let before = render(&doc);+ let raw = |doc: &Document, r: ObjRef| stream(doc, r).raw;+ // Grey settings that leave grey images alone, so only this conversion acts.+ let keep = ImageSettings { downsample: false, target_ppi: 150.0, above_ppi: 225.0, compression: Compression::Retain };+ let settings = Settings { gray: keep, ..Settings::default() };++ let mut kept = doc.clone();+ let r = optimize(&mut kept, &Settings { mono: MonoCompression::Retain, ..settings.clone() }).unwrap();+ assert_eq!(r.images_recompressed, 0, "Retain keeps every image as it is");++ let untouched = [shade, indexed, keyed].map(|r| raw(&doc, r));+ let r = optimize(&mut doc, &settings).unwrap();+ assert_eq!(r.images_recompressed, 2);+ for i in [plain, inverted] {+ let s = stream(&doc, i);+ assert_eq!((s.dict.int(b"BitsPerComponent"), s.dict.name(b"Filter")), (Some(1), Some(&b"CCITTFaxDecode"[..])));+ }+ assert_eq!(stream(&doc, inverted).dict.get(b"Decode"), Some(&decode), "the decode array stays");+ assert_eq!([shade, indexed, keyed].map(|r| raw(&doc, r)), untouched);+ assert!(render(&doc) == before, "the page looks the same");+}+#[test]fn settings_choose_what_happens() {let mut doc = Document::new_empty();