PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
Merge PR #4181: M11: PDF Optimizer Clean Up stores LZW streams with Flate
aionggaedf339fb85a
diff --cc crates/automation/src/lib.rsindex 842f6eb73,df91b8902..bf4c55083--- a/crates/automation/src/lib.rs+++ b/crates/automation/src/lib.rs@@@ -1260,7 -1226,7 +1260,8 @@@ impl Automation("discard_tags", &mut settings.discard_tags),("discard_print_settings", &mut settings.discard_print_settings),("flate_unencoded", &mut settings.flate_unencoded),+ ("object_streams", &mut settings.object_streams),+ ("lzw_to_flate", &mut settings.lzw_to_flate),("remove_invalid_links", &mut settings.remove_invalid_links),("remove_unreferenced_dests", &mut settings.remove_unreferenced_dests),] {diff --cc crates/automation/src/tools.rsindex 32eadd640,70a028c13..92c6ea12d--- a/crates/automation/src/tools.rs+++ b/crates/automation/src/tools.rs@@@ -1375,7 -1359,7 +1375,7 @@@ pub fn tools() -> Vec<ToolDef>.with(schema(json!({ "doc": doc() }), &["doc"])),t("doc_open_revision", "Open a revision", "Open saved revision `revision` (1 = the oldest) of a document as a new, unsaved document, to see the file as it was then.").with(schema(json!({ "doc": doc(), "revision": { "type": "integer", "minimum": 1 } }), &["doc", "revision"])),- t("doc_optimize", "Optimize PDF", "Write an optimized copy to `path` (Acrobat's PDF Optimizer). preset: standard (default; Reduce File Size's choices) or mobile (images to 96 ppi above 144, JPEG high quality); the options below change it. compatibility: retain (default; keeps the document's version, or 1.5 when object streams are written), 1.4, 1.5, 1.6, 1.7 or 2.0. merge_fragments (default true) first puts a page picture drawn as many stacked image strips (as some PDF printers write it) back together into one image, so it can be resampled (merged_images, fragments_merged). color / gray: { downsample, ppi, above_ppi, compression: jpeg|zip|retain, quality 1–100 } (defaults: downsample to 150 ppi above 225, JPEG 60). Images are measured where pages draw them and replaced only when smaller. discard_*: thumbnails (default true), alternate_images (true), tags, print_settings; flate_unencoded (true); object_streams (default true; always off for 1.4); remove_invalid_links and remove_unreferenced_dests (true); images and forms the pages list but never draw are always dropped (unused_xobjects). discard: Remove Hidden Information categories (metadata, attachments, comments, form-fields, hidden-text, hidden-layers, bookmarks, links-actions-scripts, private-data). Signed documents are refused. The open document is unchanged.")- t("doc_optimize", "Optimize PDF", "Write an optimized copy to `path` (Acrobat's PDF Optimizer). preset: standard (default; Reduce File Size's choices) or mobile (images to 96 ppi above 144, JPEG high quality); the options below change it. merge_fragments (default true) first puts a page picture drawn as many stacked image strips (as some PDF printers write it) back together into one image, so it can be resampled (merged_images, fragments_merged). color / gray: { downsample, ppi, above_ppi, compression: jpeg|zip|retain, quality 1–100 } (defaults: downsample to 150 ppi above 225, JPEG 60). Images are measured where pages draw them and replaced only when smaller. discard_*: thumbnails (default true), alternate_images (true), tags, print_settings; flate_unencoded (true); lzw_to_flate (true) decodes LZW streams and stores them with Flate instead, leaving any it cannot decode unchanged (lzw_streams counts the streams converted); remove_invalid_links and remove_unreferenced_dests (true); images and forms the pages list but never draw are always dropped (unused_xobjects). discard: Remove Hidden Information categories (metadata, attachments, comments, form-fields, hidden-text, hidden-layers, bookmarks, links-actions-scripts, private-data). Signed documents are refused. The open document is unchanged.")++ t("doc_optimize", "Optimize PDF", "Write an optimized copy to `path` (Acrobat's PDF Optimizer). preset: standard (default; Reduce File Size's choices) or mobile (images to 96 ppi above 144, JPEG high quality); the options below change it. compatibility: retain (default; keeps the document's version, or 1.5 when object streams are written), 1.4, 1.5, 1.6, 1.7 or 2.0. merge_fragments (default true) first puts a page picture drawn as many stacked image strips (as some PDF printers write it) back together into one image, so it can be resampled (merged_images, fragments_merged). color / gray: { downsample, ppi, above_ppi, compression: jpeg|zip|retain, quality 1–100 } (defaults: downsample to 150 ppi above 225, JPEG 60). Images are measured where pages draw them and replaced only when smaller. discard_*: thumbnails (default true), alternate_images (true), tags, print_settings; flate_unencoded (true); object_streams (default true; always off for 1.4); lzw_to_flate (true) decodes LZW streams and stores them with Flate instead, leaving any it cannot decode unchanged (lzw_streams counts the streams converted); remove_invalid_links and remove_unreferenced_dests (true); images and forms the pages list but never draw are always dropped (unused_xobjects). discard: Remove Hidden Information categories (metadata, attachments, comments, form-fields, hidden-text, hidden-layers, bookmarks, links-actions-scripts, private-data). Signed documents are refused. The open document is unchanged.").cmd("optimize.advanced").with(schema(json!({@@@ -1391,7 -1374,7 +1391,8 @@@"discard_tags": { "type": "boolean" },"discard_print_settings": { "type": "boolean" },"flate_unencoded": { "type": "boolean" },+ "object_streams": { "type": "boolean" },+ "lzw_to_flate": { "type": "boolean" },"remove_invalid_links": { "type": "boolean" },"remove_unreferenced_dests": { "type": "boolean" },"discard": { "type": "array", "items": { "type": "string" } },diff --cc crates/optimize/src/lib.rsindex 917787e2c,5c3155485..e2bc2cf50--- a/crates/optimize/src/lib.rs+++ b/crates/optimize/src/lib.rs@@@ -152,9 -101,8 +153,11 @@@ pub struct Settings/// Flate-compress streams stored without a filter, and strip a redundant outer ASCII85 or/// ASCIIHex layer from streams that have one.pub flate_unencoded: bool,+ /// Clean Up: pack non-stream objects into compressed object streams with a cross-reference+ /// stream (PDF 1.5+, §7.5.7–7.5.8). Always off when `compatibility` is [`Compatibility::Pdf1_4`].+ pub object_streams: bool,+ /// Clean Up: decode LZW-compressed streams and store them with Flate instead.+ pub lzw_to_flate: bool,/// Clean Up: remove links (and bookmark destinations) that point nowhere.pub remove_invalid_links: bool,/// Clean Up: remove named destinations nothing refers to.@@@ -182,7 -121,7 +185,8 @@@ impl Default for Settingsdiscard_tags: false,discard_print_settings: false,flate_unencoded: true,+ object_streams: true,+ lzw_to_flate: true,remove_invalid_links: true,remove_unreferenced_dests: true,}diff --cc crates/optimize/tests/optimize.rsindex 581925150,e78571c1e..8802ef351--- a/crates/optimize/tests/optimize.rs+++ b/crates/optimize/tests/optimize.rs@@@ -3,9 -3,8 +3,10 @@@use std::sync::Arc;use pdfcraft_cos::{Dict, Document, ObjRef, Object, SaveOptions, Stream, write_full};+ use pdfcraft_filters::{Filter, Params};-use pdfcraft_optimize::{Compression, ImageSettings, Settings, SpaceCategory, audit_space, effective_resolutions, optimize};+use pdfcraft_optimize::{+ Compatibility, Compression, ImageSettings, OptimizeError, Settings, SpaceCategory, audit_space, effective_resolutions, optimize,+};fn image(doc: &mut Document, w: u32, h: u32, n: usize, jpeg: bool, smask: Option<ObjRef>) -> ObjRef {// A smooth gradient with a little texture (photo-like).@@@ -1239,44 -1099,213 +1240,255 @@@ fn a_hostile_soft_mask_leaves_its_imageassert_eq!(stream(&doc, mask), hostile);}+#[test]+fn indirectly_referenced_destination_is_kept() {+ // A link's /Dest can be an indirect reference to the name string, not the string itself. Reduce+ // File Size read the name only from a direct string, so it deleted a destination the link still+ // used, silently breaking the link.+ let mut doc = Document::new_empty();+ let p = page(&mut doc, &[], "BT ET");+ let s = |t: &str| Object::String(pdfcraft_cos::PdfString::literal(t.as_bytes().to_vec()));+ // A link whose /Dest is `ref -> "target"`, and an unused destination for contrast.+ let name_ref = Object::Ref(doc.add(s("target")));+ let mut link = Dict::new();+ link.set(b"Type".to_vec(), Object::name("Annot"));+ link.set(b"Subtype".to_vec(), Object::name("Link"));+ link.set(b"Rect".to_vec(), Object::Array(vec![0.into(), 0.into(), 10.into(), 10.into()]));+ link.set(b"Dest".to_vec(), name_ref);+ let link = Object::Ref(doc.add(Object::Dict(link)));+ doc.update_dict(p, |d| d.set(b"Annots".to_vec(), Object::Array(vec![link]))).unwrap();+ let fit = Object::Array(vec![Object::Ref(p), Object::name("Fit")]);+ let mut tree = Dict::new();+ tree.set(b"Names".to_vec(), Object::Array(vec![s("target"), fit.clone(), s("unused"), fit]));+ let tree = doc.add(Object::Dict(tree));+ let mut names = Dict::new();+ names.set(b"Dests".to_vec(), Object::Ref(tree));+ let root = doc.root().unwrap();+ doc.update_dict(root, |c| c.set(b"Names".to_vec(), Object::Dict(names))).unwrap();+ let report = optimize(&mut doc, &Settings::default()).unwrap();+ // Only "unused" is removed; the indirectly-referenced "target" is kept.+ assert_eq!(report.unreferenced_dests, 1);+ let left = named_dest_keys(&doc);+ assert!(left.contains(&b"target".to_vec()), "indirectly referenced destination was kept: {left:?}");+ assert!(!left.contains(&b"unused".to_vec()));+}++/// The keys in the catalog's /Names /Dests name tree (one level, as the optimizer writes it).+fn named_dest_keys(doc: &Document) -> Vec<Vec<u8>> {+ let cat = doc.get(doc.root().unwrap()).as_dict().cloned().unwrap();+ let names = doc.resolve(cat.get(b"Names").unwrap()).as_dict().cloned().unwrap();+ let tree = doc.resolve(names.get(b"Dests").unwrap()).as_dict().cloned().unwrap();+ let arr = doc.resolve(tree.get(b"Names").unwrap()).as_array().cloned().unwrap();+ arr.chunks(2).filter_map(|c| doc.resolve(&c[0]).as_string().map(|s| s.bytes.clone())).collect()+}+++ /// Page content long enough for LZW codes to grow past 9 bits, where `EarlyChange` matters.+ fn lzw_ops() -> Vec<u8> {+ (0..300).flat_map(|i| format!("{} {} m {} {} l S\n", i % 97, i * 7 % 389, i * 13 % 612, i * 31 % 792).into_bytes()).collect()+ }++ fn lzw(data: &[u8], params: &Params) -> Vec<u8> {+ pdfcraft_filters::encode(&Filter::Lzw, params, data).unwrap()+ }++ /// `params` as a `/DecodeParms` dictionary, only the entries that differ from the defaults.+ fn decode_parms(p: &Params) -> Dict {+ let mut d = Dict::new();+ for (k, v, default) in [+ (&b"Predictor"[..], p.predictor, 1),+ (b"Colors", p.colors, 1),+ (b"BitsPerComponent", p.bits_per_component, 8),+ (b"Columns", p.columns, 1),+ (b"EarlyChange", p.early_change, 1),+ ] {+ if v != default {+ d.set(k.to_vec(), Object::Int(v));+ }+ }+ d+ }++ /// A 64 × 48 RGB image, LZW-encoded with `params`.+ fn lzw_image(doc: &mut Document, params: &Params) -> (ObjRef, Vec<u8>) {+ let (w, h) = (64u32, 48u32);+ let px: Vec<u8> = (0..w * h).flat_map(|i| [(i % w * 4) as u8, (i / w * 5) as u8, ((i % w + i / w) * 2) as u8]).collect();+ 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.into()));+ d.set(b"Height".to_vec(), Object::Int(h.into()));+ d.set(b"BitsPerComponent".to_vec(), Object::Int(8));+ d.set(b"ColorSpace".to_vec(), Object::name("DeviceRGB"));+ d.set(b"Filter".to_vec(), Object::name("LZWDecode"));+ d.set(b"DecodeParms".to_vec(), Object::Dict(decode_parms(params)));+ (doc.add(Object::Stream(Stream::from_raw(d, lzw(&px, params)))), px)+ }++ /// Settings that leave images to the clean-up: no resampling, no recompression.+ fn clean_up_only() -> Settings {+ let keep = ImageSettings { downsample: false, compression: Compression::Retain, ..ImageSettings::REDUCE };+ Settings { color: keep, gray: keep, ..Settings::default() }+ }++ #[test]+ fn lzw_streams_become_flate_and_decode_to_the_same_bytes() {+ let ops = lzw_ops();+ let early = Params::default();+ let late = Params { early_change: 0, ..Params::default() };+ let png = Params { predictor: 15, colors: 3, columns: 64, ..Params::default() };+ let png_late = Params { early_change: 0, ..png.clone() };+ let mut doc = Document::new_empty();+ let content = |doc: &mut Document, p: &Params| {+ let mut d = Dict::new();+ d.set(b"Filter".to_vec(), Object::name("LZWDecode"));+ if *p != Params::default() {+ d.set(b"DecodeParms".to_vec(), Object::Dict(decode_parms(p)));+ }+ doc.add(Object::Stream(Stream::from_raw(d, lzw(&ops, p))))+ };+ let c_early = content(&mut doc, &early);+ let c_late = content(&mut doc, &late);+ let (img, px) = lzw_image(&mut doc, &png);+ let (img_late, _) = lzw_image(&mut doc, &png_late);+ page(&mut doc, &[("Im", img), ("Im2", img_late)], "q 64 0 0 48 72 600 cm /Im Do Q q 64 0 0 48 172 600 cm /Im2 Do Q");+ let pg = pdfcraft_annot::page_refs(&doc).unwrap()[0];+ doc.update_dict(pg, |d| {+ d.set(b"Contents".to_vec(), Object::Array(vec![Object::Ref(c_early), Object::Ref(c_late), d.get(b"Contents").unwrap().clone()]))+ })+ .unwrap();+ // Each LZW stream reads as its own data before, so a decoder ignoring EarlyChange fails here.+ assert_eq!((stream(&doc, c_early).decoded_strict().unwrap(), stream(&doc, c_late).decoded_strict().unwrap()), (ops.clone(), ops.clone()));+ assert!(lzw(&ops, &early) != lzw(&ops, &late), "the two code widths differ on this data");++ let r = optimize(&mut doc, &clean_up_only()).unwrap();+ assert_eq!(r.lzw_streams, 4, "{r:?}");+ for (label, at, data) in+ [("content", c_early, &ops), ("content, EarlyChange 0", c_late, &ops), ("image", img, &px), ("image, EarlyChange 0", img_late, &px)]+ {+ let after = stream(&doc, at);+ assert_eq!(after.dict.get(b"Filter"), Some(&Object::name("FlateDecode")), "{label}");+ assert_eq!(&after.decoded_strict().unwrap(), data, "{label}");+ let parms = after.dict.get(b"DecodeParms").and_then(Object::as_dict);+ assert!(parms.is_none_or(|p| !p.contains(b"EarlyChange")), "{label}: EarlyChange is LZW's alone");+ }+ // The image keeps its PNG predictor, now applied under Flate.+ let parms = stream(&doc, img).dict.get(b"DecodeParms").and_then(Object::as_dict).cloned().unwrap();+ assert_eq!((parms.int(b"Predictor"), parms.int(b"Colors"), parms.int(b"Columns")), (Some(15), Some(3), Some(64)));+ assert!(!stream(&doc, c_late).dict.contains(b"DecodeParms"), "nothing left to say for the content stream");+ }++ #[test]+ fn a_page_drawn_from_lzw_streams_renders_the_same_after_conversion() {+ let png = Params { predictor: 12, colors: 3, columns: 64, early_change: 0, ..Params::default() };+ let mut doc = Document::new_empty();+ let (img, _) = lzw_image(&mut doc, &png);+ let pg = page(&mut doc, &[("Im", img)], "");+ let ops = b"0.2 0.5 0.8 rg 36 36 300 200 re f q 256 0 0 192 72 400 cm /Im Do Q\n".repeat(4);+ let mut d = Dict::new();+ d.set(b"Filter".to_vec(), Object::name("LZWDecode"));+ d.set(b"DecodeParms".to_vec(), Object::Dict(decode_parms(&Params { early_change: 0, ..Params::default() })));+ let c = doc.add(Object::Stream(Stream::from_raw(d, lzw(&ops, &Params { early_change: 0, ..Params::default() }))));+ doc.update_dict(pg, |p| p.set(b"Contents".to_vec(), Object::Ref(c))).unwrap();+ let render = |doc: &Document| {+ let bytes = write_full(doc, &SaveOptions::default()).unwrap();+ let mut r = pdfcraft_render::PageRenderer::new(Arc::new(bytes), pdfcraft_render::RenderConfig::default());+ let out = r.render(pdfcraft_render::RenderRequest { page: 0, scale: 1.0, ..Default::default() });+ assert!(out.error.is_none(), "{:?}", out.error);+ out.rgba+ };+ let before = render(&doc);+ // The picture and the rectangle are drawn: the page is not blank.+ assert!(before.chunks(4).any(|p| p[..3] != [255, 255, 255]));+ let r = optimize(&mut doc, &clean_up_only()).unwrap();+ assert_eq!(r.lzw_streams, 2, "{r:?}");+ assert_eq!(stream(&doc, c).dict.name(b"Filter"), Some(&b"FlateDecode"[..]));+ assert!(render(&doc) == before, "the page renders pixel for pixel as before");+ }++ #[test]+ fn lzw_inside_a_filter_chain_is_replaced_and_the_other_stages_kept() {+ let ops = lzw_ops();+ let inner = lzw(&ops, &Params::default());+ // An ASCII85 layer outside the LZW goes with it; a JPEG inside it stays encoded as it was.+ let (mut doc, c) = with_content(filtered(&["ASCII85Decode", "LZWDecode"], ascii85(&inner)));+ let photo = image(&mut doc, 40, 30, 3, true, None);+ let jpeg = stream(&doc, photo).raw.to_vec();+ let mut picture = filtered(&["LZWDecode", "DCTDecode"], lzw(&jpeg, &Params::default()));+ picture.dict.set(b"DecodeParms".to_vec(), Object::Array(vec![Object::Null, Object::Null]));+ let pic = doc.add(Object::Stream(picture));+ // An ASCII85 layer over LZW with a PNG predictor: the predictor's parameters move to the one+ // Flate filter left, without EarlyChange.+ let rows: Vec<u8> = (0..40 * 30).map(|i| (i % 40 * 3 + i / 40) as u8).collect();+ let png = Params { predictor: 12, columns: 40, early_change: 0, ..Params::default() };+ let mut predicted = filtered(&["ASCII85Decode", "LZWDecode"], ascii85(&lzw(&rows, &png)));+ predicted.dict.set(b"DecodeParms".to_vec(), Object::Array(vec![Object::Null, Object::Dict(decode_parms(&png))]));+ let pred = doc.add(Object::Stream(predicted));+ let r = optimize(&mut doc, &clean_up_only()).unwrap();+ assert_eq!(r.lzw_streams, 3, "{r:?}");+ let after = stream(&doc, pred);+ assert_eq!(after.dict.get(b"Filter"), Some(&Object::name("FlateDecode")));+ let parms = after.dict.get(b"DecodeParms").and_then(Object::as_dict).cloned().unwrap();+ assert_eq!((parms.int(b"Predictor"), parms.int(b"Columns"), parms.contains(b"EarlyChange")), (Some(12), Some(40), false));+ assert_eq!(after.decoded_strict().unwrap(), rows);+ let after = stream(&doc, c);+ assert_eq!(after.dict.get(b"Filter"), Some(&Object::name("FlateDecode")));+ assert_eq!(after.decoded_strict().unwrap(), ops);+ let after = stream(&doc, pic);+ assert_eq!(after.dict.get(b"Filter"), Some(&Object::Array(vec![Object::name("FlateDecode"), Object::name("DCTDecode")])));+ assert!(!after.dict.contains(b"DecodeParms"), "all null: dropped");+ let inside = pdfcraft_filters::decode(&[(Filter::Flate, Params::default())], &after.raw, 1 << 20).unwrap();+ assert_eq!(inside, jpeg, "the JPEG bytes are kept exactly");+ }++ #[test]+ fn lzw_streams_that_cannot_be_read_or_are_not_asked_for_stay_unchanged() {+ let ops = lzw_ops();+ let good = lzw(&ops, &Params::default());+ // 9-bit codes 511 after a literal: past the table, corrupt.+ let corrupt = vec![0x80, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];+ assert!(filtered(&["LZWDecode"], corrupt.clone()).decoded_strict().is_err());+ let mut bad_predictor = filtered(&["LZWDecode"], good.clone());+ let mut parms = Dict::new();+ parms.set(b"Predictor".to_vec(), Object::Int(12));+ parms.set(b"Columns".to_vec(), Object::Int(7));+ bad_predictor.dict.set(b"DecodeParms".to_vec(), Object::Dict(parms));+ let mut indirect_parms = filtered(&["LZWDecode"], good.clone());+ indirect_parms.dict.set(b"DecodeParms".to_vec(), Object::Ref(ObjRef { num: 999, generation: 0 }));+ // Columns the reader can't take as an integer: read as the default 1 here, so the data is+ // predicted with one column and decodes, but a viewer resolving the value would use another.+ let one_column = Params { predictor: 12, ..Params::default() };+ let odd_columns = |columns: Object| {+ let mut s = filtered(&["LZWDecode"], lzw(&ops, &one_column));+ let mut parms = Dict::new();+ parms.set(b"Predictor".to_vec(), Object::Int(12));+ parms.set(b"Columns".to_vec(), columns);+ s.dict.set(b"DecodeParms".to_vec(), Object::Dict(parms));+ s+ };+ assert_eq!(odd_columns(Object::Real(12.5)).decoded_strict().unwrap(), ops, "read with one column");+ let mut objstm = filtered(&["LZWDecode"], good.clone());+ objstm.dict.set(b"Type".to_vec(), Object::name("ObjStm"));+ let mut external = filtered(&["LZWDecode"], good.clone());+ external.dict.set(b"F".to_vec(), Object::String(pdfcraft_cos::PdfString::literal(b"data.bin".to_vec())));+ let cases = [+ ("corrupt LZW", filtered(&["LZWDecode"], corrupt), Settings::default()),+ ("corrupt under a PNG predictor", bad_predictor, Settings::default()),+ ("indirect DecodeParms", indirect_parms, Settings::default()),+ ("external file", external, Settings::default()),+ ("object stream, rewritten on save", objstm, Settings::default()),+ ("Columns by reference", odd_columns(Object::Ref(ObjRef { num: 9, generation: 0 })), Settings::default()),+ ("Columns not an integer", odd_columns(Object::Real(12.5)), Settings::default()),+ ("crypt filter", filtered(&["Crypt", "LZWDecode"], good.clone()), Settings::default()),+ ("option off", filtered(&["LZWDecode"], good.clone()), Settings { lzw_to_flate: false, ..Settings::default() }),+ ];+ for (label, s, settings) in cases {+ let (mut doc, c) = with_content(s.clone());+ let r = optimize(&mut doc, &settings).unwrap();+ assert_eq!(r.lzw_streams, 0, "{label}");+ assert_eq!(stream(&doc, c), s, "{label}");+ }+ // The same data, readable and asked for, is converted: the cases above fail for their reason.+ let (mut doc, c) = with_content(filtered(&["LZWDecode"], good));+ assert_eq!(optimize(&mut doc, &Settings::default()).unwrap().lzw_streams, 1);+ assert_eq!(stream(&doc, c).decoded_strict().unwrap(), ops);+ }diff --cc crates/ui-egui/src/optimize_ui.rsindex 9660b0a92,362811f26..6662bf997--- a/crates/ui-egui/src/optimize_ui.rs+++ b/crates/ui-egui/src/optimize_ui.rs@@@ -230,18 -219,10 +230,19 @@@ pub(crate) fn body(ui: &mut egui::Ui, d}OptimizeTab::CleanUp => {ui.add(widgets::checkbox(&mut s.flate_unencoded, tl!("Use Flate to encode streams that are not encoded")));+ ui.add(widgets::checkbox(&mut s.lzw_to_flate, tl!("In streams that use LZW encoding, use Flate instead")));ui.add(widgets::checkbox(&mut s.remove_invalid_links, tl!("Remove invalid links and bookmarks")));ui.add(widgets::checkbox(&mut s.remove_unreferenced_dests, tl!("Remove unreferenced named destinations")));- ui.add_enabled(false, widgets::checkbox(&mut true, tl!("Compress document structure (object streams)")));+ let mut object_streams = s.effective_object_streams();+ if ui+ .add_enabled(+ s.compatibility != Compatibility::Pdf1_4,+ widgets::checkbox(&mut object_streams, tl!("Compress document structure (object streams)")),+ )+ .changed()+ {+ s.object_streams = object_streams;+ }ui.add_enabled(false, widgets::checkbox(&mut true, tl!("Remove unused objects and merge identical ones")));}}