Skip to content

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.rs
index 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.rs
index 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.rs
index 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 Settings
discard_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.rs
index 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_image
assert_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.rs
index 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")));
}
}