PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
M11: monochrome downsampling leaves halftones alone; bounds; an indexed tie under an inverting decode
Grzegorz Martensff8a07f28375
diff --git a/crates/optimize/src/images.rs b/crates/optimize/src/images.rsindex 4c20c1b3e..bb768551d 100644--- a/crates/optimize/src/images.rs+++ b/crates/optimize/src/images.rs@@ -565,7 +565,7 @@ fn one_component(doc: &Document, cs: &Object) -> bool {/// The samples of a black-and-white image, as rows of 1-bit samples each starting on a new byte,/// with its width and height, and whether they were packed from eight bits. Two kinds count:/// - one bit per pixel in one colour component, or an image mask, stored with no filter, with-/// general-purpose ones, or with CCITT fax last ([`Document::decoded_image`]);+/// general-purpose ones, or with CCITT fax last ([`Document::decoded_image_within`], no further than its rows can need);/// - with `eight_bit`, eight-bit grey whose every sample is 0 or 255. A decode array maps 0 and 255/// at eight bits as it maps 0 and 1 at one bit, so it stays. Left out: indexed images (their/// samples are palette indices) and a colour-key `/Mask` (its ranges are in eight-bit values).@@ -581,13 +581,14 @@ fn one_bit(doc: &Document, s: &Stream, eight_bit: bool) -> Option<(Vec<u8>, u32,let bits = d.int(b"BitsPerComponent");let mask = matches!(d.get(b"ImageMask"), Some(Object::Bool(true)));if (mask && bits.is_none_or(|b| b == 1)) || (bits == Some(1) && d.get(b"ColorSpace").is_some_and(|cs| one_component(doc, cs))) {- // A fax image through its decoder; any other no further than its rows can need.+ // No further than its rows can need: a fax image's code (the filters before its decoder+ // produce it) takes at most about a byte a pixel and each row's end, as redaction allows.let len = stride.checked_mul(hu)?;- let mut data = match s.filters().last() {- Some((pdfcraft_filters::Filter::CcittFax, _)) => doc.decoded_image(s),- _ => doc.with_direct_parms(s).decoded_within(allowance(len, h)?),- }- .ok()?;+ let max = match s.filters().last() {+ Some((pdfcraft_filters::Filter::CcittFax, _)) => wu.checked_mul(hu)?.checked_add(hu.checked_mul(4)?)?.checked_add(4096)?,+ _ => allowance(len, h)?,+ };+ let mut data = doc.decoded_image_within(s, max).ok()?;if data.len() < len {return None;}@@ -624,8 +625,9 @@ fn one_bit(doc: &Document, s: &Stream, eight_bit: bool) -> Option<(Vec<u8>, u32,/// Whether sample 1 is the dark one of the 1-bit image `d` describes, after its decode array/// (`[0 1]` when it has none of two numbers): the painted part of an image mask and black in grey/// decode to 0, and full ink in a separation (or a DeviceN of one colourant) to 1. An indexed image-/// says 0: its palette, not its decode array, says which entry is darker, and the palette isn't-/// read yet, so a tie goes to entry 0 whatever its colour.+/// says the sample that decodes to entry 0 (its decode array maps samples to entries, ISO 32000-2+/// §8.9.5.2): its palette says which entry is darker, and the palette isn't read yet, so a tie goes+/// to entry 0 whatever its colour.fn dark_is_one(doc: &Document, d: &Dict) -> bool {let number = |v: Option<&Object>| v.and_then(|v| doc.resolve(v).as_f64());let (d0, d1) = match d.get(b"Decode").map(|v| doc.resolve(v)).as_deref() {@@ -637,7 +639,6 @@ fn dark_is_one(doc: &Document, d: &Dict) -> bool {}match d.get(b"ColorSpace").map(|cs| doc.resolve(cs)).as_deref() {Some(Object::Array(a)) => match a.first().and_then(Object::as_name) {- Some(b"Indexed" | b"I") => false,Some(b"Separation" | b"DeviceN") => d1 > d0,_ => d1 < d0,},@@ -648,8 +649,9 @@ fn dark_is_one(doc: &Document, d: &Dict) -> bool {/// `w` × `h` 1-bit rows (each starting on a new byte) averaged down to `nw` × `nh`, no larger:/// each new pixel takes the sample that covers more of its area, and the dark one when the two tie/// (1 if `dark_is_one`, see [`dark_is_one`]), so a dark line half a new pixel wide stays. `None`-/// when the rows are short or the new size isn't smaller in both directions or empty.-pub(crate) fn downsample_bits(data: &[u8], w: u32, h: u32, nw: u32, nh: u32, dark_is_one: bool) -> Option<Vec<u8>> {+/// when the rows are short or the new size isn't smaller in both directions or empty. Also says+/// how many new pixels cover both samples.+pub(crate) fn downsample_bits(data: &[u8], w: u32, h: u32, nw: u32, nh: u32, dark_is_one: bool) -> Option<(Vec<u8>, u64)> {if nw == 0 || nh == 0 || nw > w || nh > h {return None;}@@ -662,6 +664,7 @@ pub(crate) fn downsample_bits(data: &[u8], w: u32, h: u32, nw: u32, nh: u32, darlet overlap = |a0: u64, a1: u64, b0: u64, b1: u64| a1.min(b1).saturating_sub(a0.max(b0));// Per source column, the area its 1 samples cover in the new row.let mut ones = vec![0u64; usize::try_from(w).ok()?];+ let mut mixed = 0u64;for j in 0..nh {ones.fill(0);let (y0, y1) = (j * h, (j + 1) * h);@@ -683,20 +686,23 @@ pub(crate) fn downsample_bits(data: &[u8], w: u32, h: u32, nw: u32, nh: u32, dar// Against what the 0 samples cover: covered is at most w·h, which can't overflow// (w·h < 2^64 for u32 sizes).let zeros = w * h - covered;+ mixed += u64::from(covered > 0 && zeros > 0);if covered > zeros || (dark_is_one && covered == zeros) {let i = usize::try_from(i).ok()?;*out_row.get_mut(i / 8)? |= 0x80 >> (i % 8);}}}- Some(out)+ Some((out, mixed))}/// A black-and-white image (see [`one_bit`]) resampled and stored again per `settings`, if that is/// smaller as stored; `ppi` is its effective resolution. Also says whether it was resampled.////// - **Resampled** ([`downsample_bits`]) when its resolution is above `above_ppi`, to `target_ppi`,-/// unless it has a soft mask, whose own size would then have to follow.+/// unless it has a soft mask, whose own size would then have to follow, or is a halftone or a+/// dither: most of its new pixels would cover both black and white, and taking the sample that+/// covers more would turn its tones solid (a 50% screen black, a 25% one white)./// - **Stored** as CCITT Group 4 with `CcittG4`, or as 1-bit Flate when that is smaller, which only/// a resampled image or one packed from eight bits may be: a 1-bit image that is only stored again/// becomes Group 4 or stays. With `Retain`, a resampled image keeps its kind of compression@@ -719,14 +725,31 @@ fn mono(doc: &Document, s: &Stream, ppi: f64, settings: &MonoSettings) -> Option}let (data, w, h, eight_bit) = one_bit(doc, s, !retain)?;let k = settings.target_ppi / ppi;+ // `downsample_bits` keeps a counter for each column: no more columns than a fax row may have,+ // so a hostile strip of 80 million can't make it 640 MB.+ let narrow = w <= pdfcraft_filters::MAX_CCITT_COLUMNS;// At most `w` × `h`, as k < 1: no overflow.- let (nw, nh) =- if downsample && k < 1.0 { (((f64::from(w) * k).round() as u32).max(1), ((f64::from(h) * k).round() as u32).max(1)) } else { (w, h) };- let resampled = (nw, nh) != (w, h);+ let (nw, nh) = if downsample && narrow && k < 1.0 {+ (((f64::from(w) * k).round() as u32).max(1), ((f64::from(h) * k).round() as u32).max(1))+ } else {+ (w, h)+ };+ let averaged = if (nw, nh) != (w, h) {+ let (out, mixed) = downsample_bits(&data, w, h, nw, nh, dark_is_one(doc, d))?;+ // A halftone or dither: most new pixels cover both samples. Text covers both only along+ // its edges.+ (mixed.saturating_mul(2) <= u64::from(nw) * u64::from(nh)).then_some(out)+ } else {+ None+ };+ let resampled = averaged.is_some();+ let (data, nw, nh) = match averaged {+ Some(out) => (out, nw, nh),+ None => (data, w, h),+ };if (retain || fax_alone) && !resampled {return None;}- let data = if resampled { downsample_bits(&data, w, h, nw, nh, dark_is_one(doc, d))? } else { data };let mut dict = d.clone();for key in [&b"Filter"[..], b"DecodeParms", b"Length", b"DL"] {dict.remove(key);@@ -931,18 +954,18 @@ mod downsample_tests {#[test]fn each_new_pixel_takes_the_sample_covering_more_of_it() {// 4 × 2 to 2 × 1: three 1s of four on the left, none on the right.- assert_eq!(downsample_bits(&[0b1100_0000, 0b1000_0000], 4, 2, 2, 1, false), Some(vec![0b1000_0000]));+ assert_eq!(downsample_bits(&[0b1100_0000, 0b1000_0000], 4, 2, 2, 1, false).map(|(out, _)| out), Some(vec![0b1000_0000]));// A tie gives the dark sample: 0, black in grey, so a black line half a new pixel wide// stays (the second of four white columns is black); a white one that thin on black doesn't.- assert_eq!(downsample_bits(&[0b1011_0000, 0b1011_0000], 4, 2, 2, 1, false), Some(vec![0b0100_0000]));- assert_eq!(downsample_bits(&[0b0100_0000, 0b0100_0000], 4, 2, 2, 1, false), Some(vec![0]));+ assert_eq!(downsample_bits(&[0b1011_0000, 0b1011_0000], 4, 2, 2, 1, false).map(|(out, _)| out), Some(vec![0b0100_0000]));+ assert_eq!(downsample_bits(&[0b0100_0000, 0b0100_0000], 4, 2, 2, 1, false).map(|(out, _)| out), Some(vec![0]));// With 1 the dark sample (an inverting decode array, a separation), that line is a 1.- assert_eq!(downsample_bits(&[0b0100_0000, 0b0100_0000], 4, 2, 2, 1, true), Some(vec![0b1000_0000]));- assert_eq!(downsample_bits(&[0b1011_0000, 0b1011_0000], 4, 2, 2, 1, true), Some(vec![0b1100_0000]));+ assert_eq!(downsample_bits(&[0b0100_0000, 0b0100_0000], 4, 2, 2, 1, true).map(|(out, _)| out), Some(vec![0b1000_0000]));+ assert_eq!(downsample_bits(&[0b1011_0000, 0b1011_0000], 4, 2, 2, 1, true).map(|(out, _)| out), Some(vec![0b1100_0000]));// The same size gives the same bits; padding bits are 0.- assert_eq!(downsample_bits(&[0b1010_1111], 3, 1, 3, 1, false), Some(vec![0b1010_0000]));+ assert_eq!(downsample_bits(&[0b1010_1111], 3, 1, 3, 1, false).map(|(out, _)| out), Some(vec![0b1010_0000]));// 3 to 2 across: the middle column counts half to each new one.- assert_eq!(downsample_bits(&[0b1100_0000], 3, 1, 2, 1, false), Some(vec![0b1000_0000]));+ assert_eq!(downsample_bits(&[0b1100_0000], 3, 1, 2, 1, false).map(|(out, _)| out), Some(vec![0b1000_0000]));}/// The dark sample: 0 in grey and of an image mask, 1 in a separation, each the other way round@@ -971,7 +994,7 @@ mod downsample_tests {(vec![separation.clone()], true),(vec![separation, inverted.clone()], false),(vec![indexed.clone()], false),- (vec![indexed, inverted], false),+ (vec![indexed, inverted], true),(vec![("ColorSpace", Object::name("DeviceGray")), ("Decode", Object::Array(vec![Object::name("x"), 0.into()]))], false),] {assert_eq!(dark_is_one(&doc, &image(&entries)), dark_one, "{entries:?}");@@ -980,11 +1003,11 @@ mod downsample_tests {#[test]fn what_it_cannot_resample_is_none() {- assert_eq!(downsample_bits(&[0; 2], 4, 2, 5, 1, false), None, "wider");- assert_eq!(downsample_bits(&[0; 2], 4, 2, 2, 3, false), None, "taller");- assert_eq!(downsample_bits(&[0; 2], 4, 2, 0, 1, false), None);- assert_eq!(downsample_bits(&[0; 1], 4, 2, 2, 1, false), None, "short rows");- assert_eq!(downsample_bits(&[], u32::MAX, u32::MAX, 1, 1, true), None);+ assert_eq!(downsample_bits(&[0; 2], 4, 2, 5, 1, false).map(|(out, _)| out), None, "wider");+ assert_eq!(downsample_bits(&[0; 2], 4, 2, 2, 3, false).map(|(out, _)| out), None, "taller");+ assert_eq!(downsample_bits(&[0; 2], 4, 2, 0, 1, false).map(|(out, _)| out), None);+ assert_eq!(downsample_bits(&[0; 1], 4, 2, 2, 1, false).map(|(out, _)| out), None, "short rows");+ assert_eq!(downsample_bits(&[], u32::MAX, u32::MAX, 1, 1, true).map(|(out, _)| out), None);}proptest::proptest! {@@ -1002,8 +1025,8 @@ mod downsample_tests {let (nw, nh) = (1 + (f64::from(w - 1) * nw_part) as u32, 1 + (f64::from(h - 1) * nh_part) as u32);let len = (w as usize).div_ceil(8) * h as usize;let data: Vec<u8> = seed.iter().cycle().take(len).copied().collect();- proptest::prop_assert_eq!(downsample_bits(&data, w, h, nw, nh, dark_one), Some(naive(&data, w, h, nw, nh, dark_one)));- let white = downsample_bits(&vec![0xFF; len], w, h, nw, nh, dark_one).unwrap();+ proptest::prop_assert_eq!(downsample_bits(&data, w, h, nw, nh, dark_one).map(|(out, _)| out), Some(naive(&data, w, h, nw, nh, dark_one)));+ let white = downsample_bits(&vec![0xFF; len], w, h, nw, nh, dark_one).map(|(out, _)| out).unwrap();proptest::prop_assert_eq!(white, naive(&vec![0xFF; len], w, h, nw, nh, dark_one));proptest::prop_assert!(naive(&vec![0xFF; len], w, h, nw, nh, dark_one).iter().any(|b| *b != 0));}diff --git a/crates/optimize/tests/optimize.rs b/crates/optimize/tests/optimize.rsindex ea2961513..4efe4072d 100644--- a/crates/optimize/tests/optimize.rs+++ b/crates/optimize/tests/optimize.rs@@ -929,6 +929,96 @@ fn black_and_white_images_above_450_ppi_are_averaged_down_to_300() {assert!(differ * 200 < before.len(), "{differ} of {} channel values differ visibly", before.len());}+/// Monochrome downsampling leaves a halftone or a dither at its resolution, as most new pixels+/// would cover both black and white and taking the sample covering more would turn its tones+/// solid: a 50% checkerboard, a 25% ordered dither and an error-diffused one, each at 600 ppi.+/// Text at 600 ppi, which covers both only along its edges, is averaged down. Rows no wider than+/// a fax row (`MAX_CCITT_COLUMNS`) are averaged down too, but not one column wider: the averaging+/// keeps a counter for each column.+#[test]+fn monochrome_downsampling_leaves_halftones_and_overwide_rows_at_their_resolution() {+ let (w, h) = (1200u32, 480u32);+ let stride = (w as usize).div_ceil(8);+ let pattern = |white: &dyn Fn(usize, usize) -> bool| {+ let mut data = vec![0u8; stride * h as usize];+ for y in 0..h as usize {+ for x in 0..w as usize {+ if white(x, y) {+ data[y * stride + x / 8] |= 0x80 >> (x % 8);+ }+ }+ }+ data+ };+ let diffused = dithered(w, h);+ let grey = [("BitsPerComponent", 1.into()), ("ColorSpace", Object::name("DeviceGray"))];+ let mut doc = Document::new_empty();+ let text = mono_image(&mut doc, w, h, &bilevel(w, h, false), None, &grey);+ let halftones =+ [pattern(&|x, y| (x + y) % 2 == 0), pattern(&|x, y| x % 2 == 1 || y % 2 == 1), pattern(&|x, y| diffused[y * w as usize + x] == 255)]+ .map(|data| mono_image(&mut doc, w, h, &data, None, &grey));+ // 144 × 57.6 pt is 600 ppi.+ let names = ["T", "A", "B", "C"];+ let content: String = (0..4).map(|i| format!("q 144 0 0 57.6 {} 600 cm /{} Do Q ", 6 + 150 * i, names[i])).collect();+ page(&mut doc, &names.into_iter().zip([text, halftones[0], halftones[1], halftones[2]]).collect::<Vec<_>>(), &content);+ optimize(&mut doc, &Settings::default()).unwrap();+ let size = |r: ObjRef| {+ let d = stream(&doc, r).dict;+ (d.int(b"Width"), d.int(b"Height"))+ };+ assert_eq!(size(text), (Some(600), Some(240)), "text");+ for (i, r) in halftones.iter().enumerate() {+ assert_eq!(size(*r), (Some(1200), Some(480)), "halftone {i}");+ }++ for (columns, resampled) in [(pdfcraft_filters::MAX_CCITT_COLUMNS, 1), (pdfcraft_filters::MAX_CCITT_COLUMNS + 1, 0)] {+ let mut doc = Document::new_empty();+ let white = vec![0xFF; (columns as usize).div_ceil(8) * 2];+ let img = mono_image(&mut doc, columns, 2, &white, None, &grey);+ // Far above 450 ppi both ways.+ page(&mut doc, &[("A", img)], "q 612 0 0 0.1 0 400 cm /A Do Q");+ let r = optimize(&mut doc, &Settings::default()).unwrap();+ assert_eq!(r.images_resampled, resampled, "{columns} columns: {r:?}");+ }+}++/// A fax image behind a decompression bomb is left alone: the filters before its decoder may+/// produce no more than a fax code of its size can take (about a byte a pixel), not the 1 GiB+/// limit. Here a Group 4 page at 600 ppi behind Flate, with four megabytes of zeros after its+/// code; without them it is averaged down.+#[test]+fn a_fax_image_behind_a_decompression_bomb_is_left_alone() {+ let (w, h) = (1200u32, 480u32);+ let g4 = pdfcraft_filters::encode_g4(&bilevel(w, h, false), w, h).unwrap();+ for padding in [0, 4 << 20] {+ let mut doc = Document::new_empty();+ let mut code = g4.clone();+ code.resize(g4.len() + padding, 0);+ let mut d = Dict::new();+ d.set(b"Subtype".to_vec(), Object::name("Image"));+ d.set(b"Width".to_vec(), Object::Int(w.into()));+ d.set(b"Height".to_vec(), Object::Int(h.into()));+ d.set(b"BitsPerComponent".to_vec(), Object::Int(1));+ d.set(b"ColorSpace".to_vec(), Object::name("DeviceGray"));+ d.set(b"Filter".to_vec(), Object::Array(vec![Object::name("FlateDecode"), Object::name("CCITTFaxDecode")]));+ let mut parms = Dict::new();+ parms.set(b"K".to_vec(), Object::Int(-1));+ parms.set(b"Columns".to_vec(), Object::Int(w.into()));+ d.set(b"DecodeParms".to_vec(), Object::Array(vec![Object::Null, Object::Dict(parms)]));+ let img = doc.add(Object::Stream(Stream::from_raw(d, pdfcraft_filters::encode_flate(&code))));+ // 144 × 57.6 pt is 600 ppi.+ page(&mut doc, &[("A", img)], "q 144 0 0 57.6 20 600 cm /A Do Q");+ let before = stream(&doc, img).raw;+ let r = optimize(&mut doc, &Settings::default()).unwrap();+ if padding == 0 {+ assert_eq!(r.images_resampled, 1, "{r:?}");+ } else {+ assert_eq!((r.images_resampled, r.images_recompressed), (0, 0), "{r:?}");+ assert_eq!(stream(&doc, img).raw, before);+ }+ }+}+#[test]fn settings_choose_what_happens() {let mut doc = Document::new_empty();