use crate::resources::{remove_unreferenced_resources, RemoveUnreferencedResources};
use crate::{Object, ObjectRef, Pdf, Result};
use std::collections::BTreeSet;
use std::io::{Read, Seek};
pub fn prune_after_subset<R: Read + Seek>(
pdf: &mut Pdf<R>,
mode: RemoveUnreferencedResources,
) -> Result<()> {
if mode == RemoveUnreferencedResources::No {
return Ok(());
}
remove_unreferenced_resources(pdf, mode)?;
sweep_unreachable_objects(pdf)?;
Ok(())
}
pub(crate) fn sweep_unreachable_objects<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<usize> {
let root_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(0), };
let all_live = pdf.live_object_refs();
let trailer_refs = {
let trailer_clone = Object::Dictionary(pdf.trailer().clone());
let mut refs: Vec<ObjectRef> = Vec::new();
walk_refs(&trailer_clone, &mut refs);
refs
};
let reachable = collect_reachable(pdf, root_ref, trailer_refs)?;
let mut deleted = 0usize;
for obj_ref in all_live {
if !reachable.contains(&obj_ref) {
pdf.delete_object(obj_ref);
deleted += 1;
}
}
Ok(deleted)
}
fn collect_reachable<R: Read + Seek>(
pdf: &mut Pdf<R>,
start: ObjectRef,
extra_seeds: Vec<ObjectRef>,
) -> Result<BTreeSet<ObjectRef>> {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut queue: Vec<ObjectRef> = vec![start];
queue.extend(extra_seeds);
while let Some(current) = queue.pop() {
if current.number == 0 {
continue;
}
if !visited.insert(current) {
continue;
}
if let Some((objstm_ref, _)) = pdf.compressed_parent(current) {
queue.push(objstm_ref);
}
let obj = match pdf.resolve(current) {
Ok(o) => o,
Err(_) => continue,
};
walk_refs(&obj, &mut queue);
}
Ok(visited)
}
fn walk_refs(obj: &Object, queue: &mut Vec<ObjectRef>) {
match obj {
Object::Reference(r) => {
queue.push(*r);
}
Object::Array(arr) => {
for item in arr {
walk_refs(item, queue);
}
}
Object::Dictionary(dict) => {
for (_, val) in dict.iter() {
walk_refs(val, queue);
}
}
Object::Stream(stream) => {
for (_, val) in stream.dict.iter() {
walk_refs(val, queue);
}
}
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::check::check_reader;
use crate::page_tree_rebuild::rebuild_page_tree;
use crate::pages::page_refs;
use crate::writer::write_pdf;
use crate::{Object, ObjectRef, Pdf};
use std::collections::BTreeMap;
use std::io::Cursor;
fn build_two_page_distinct_fonts() -> Vec<u8> {
let c1 = b"BT /F1 12 Tf 10 10 Td (Page1) Tj ET";
let c2 = b"BT /F2 12 Tf 10 10 Td (Page2) Tj ET";
let mut out: Vec<u8> = b"%PDF-1.4\n".to_vec();
let mut offs: BTreeMap<u32, u64> = BTreeMap::new();
let objs: Vec<(u32, String)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".into()),
(2, "<< /Type /Pages /Kids [3 0 R 7 0 R] /Count 2 >>".into()),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Contents 4 0 R /Resources << /Font 5 0 R >> >>"
.into(),
),
(5, "<< /F1 6 0 R >>".into()),
(
6,
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".into(),
),
(
7,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Contents 8 0 R /Resources << /Font 9 0 R >> >>"
.into(),
),
(9, "<< /F2 10 0 R >>".into()),
(
10,
"<< /Type /Font /Subtype /Type1 /BaseFont /Courier >>".into(),
),
];
let stream_placeholder = [(4u32, c1.as_ref()), (8u32, c2.as_ref())];
for (n, s) in &objs {
if *n < 4 {
offs.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{s}\nendobj\n").as_bytes());
}
}
offs.insert(4, out.len() as u64);
out.extend_from_slice(format!("4 0 obj\n<< /Length {} >>\nstream\n", c1.len()).as_bytes());
out.extend_from_slice(c1);
out.extend_from_slice(b"\nendstream\nendobj\n");
for (n, s) in &objs {
if *n >= 5 && *n < 8 {
offs.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{s}\nendobj\n").as_bytes());
}
}
offs.insert(8, out.len() as u64);
out.extend_from_slice(format!("8 0 obj\n<< /Length {} >>\nstream\n", c2.len()).as_bytes());
out.extend_from_slice(c2);
out.extend_from_slice(b"\nendstream\nendobj\n");
for (n, s) in &objs {
if *n >= 9 {
offs.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{s}\nendobj\n").as_bytes());
}
}
let _ = stream_placeholder;
let xref_start = out.len() as u64;
let total = 11u32;
out.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for i in 1..total {
out.extend_from_slice(format!("{:010} 00000 n \n", offs[&i]).as_bytes());
}
out.extend_from_slice(
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
out
}
fn build_shared_resources_pdf() -> Vec<u8> {
let c1 = b"BT /F1 12 Tf 10 10 Td (P1) Tj ET";
let c2 = b"BT /F2 12 Tf 10 10 Td (P2) Tj ET";
let mut out: Vec<u8> = b"%PDF-1.4\n".to_vec();
let mut offs: BTreeMap<u32, u64> = BTreeMap::new();
let dicts: Vec<(u32, String)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".into()),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 2 >>".into()),
(
3,
"<< /Type /Pages /Parent 2 0 R /Kids [4 0 R 5 0 R] /Count 2 \
/Resources 6 0 R >>"
.into(),
),
(
4,
"<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] /Contents 7 0 R >>".into(),
),
(
5,
"<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] /Contents 8 0 R >>".into(),
),
(
6,
"<< /Font << \
/F1 << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >> \
/F2 << /Type /Font /Subtype /Type1 /BaseFont /Courier >> \
>> >>"
.into(),
),
];
for (n, s) in &dicts {
offs.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{s}\nendobj\n").as_bytes());
}
offs.insert(7, out.len() as u64);
out.extend_from_slice(format!("7 0 obj\n<< /Length {} >>\nstream\n", c1.len()).as_bytes());
out.extend_from_slice(c1);
out.extend_from_slice(b"\nendstream\nendobj\n");
offs.insert(8, out.len() as u64);
out.extend_from_slice(format!("8 0 obj\n<< /Length {} >>\nstream\n", c2.len()).as_bytes());
out.extend_from_slice(c2);
out.extend_from_slice(b"\nendstream\nendobj\n");
let xref_start = out.len() as u64;
let total = 9u32;
out.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for i in 1..total {
out.extend_from_slice(format!("{:010} 00000 n \n", offs[&i]).as_bytes());
}
out.extend_from_slice(
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
out
}
fn open(bytes: Vec<u8>) -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(bytes)).expect("PDF should parse")
}
fn is_live(pdf: &mut Pdf<Cursor<Vec<u8>>>, r: ObjectRef) -> bool {
pdf.live_object_refs().contains(&r)
}
#[test]
fn auto_drops_page2_objects_and_f2_font() {
let bytes = build_two_page_distinct_fonts();
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
assert!(
!is_live(&mut pdf, ObjectRef::new(7, 0)),
"page2 dict should be deleted"
);
assert!(
!is_live(&mut pdf, ObjectRef::new(8, 0)),
"page2 content should be deleted"
);
assert!(
!is_live(&mut pdf, ObjectRef::new(9, 0)),
"page2 /Font dict should be deleted"
);
assert!(
!is_live(&mut pdf, ObjectRef::new(10, 0)),
"font F2 should be deleted"
);
assert!(
is_live(&mut pdf, ObjectRef::new(5, 0)),
"font dict for page1 should survive"
);
assert!(
is_live(&mut pdf, ObjectRef::new(6, 0)),
"font F1 should survive"
);
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let report = check_reader(Cursor::new(out)).unwrap();
assert!(
report.valid,
"pruned PDF must be valid: {:?}",
report.diagnostics
);
}
#[test]
fn yes_drops_page2_objects_same_as_auto() {
let bytes = build_two_page_distinct_fonts();
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Yes).unwrap();
assert!(!is_live(&mut pdf, ObjectRef::new(7, 0)));
assert!(!is_live(&mut pdf, ObjectRef::new(10, 0)));
assert!(is_live(&mut pdf, ObjectRef::new(6, 0)));
}
#[test]
fn no_mode_preserves_all_objects() {
let bytes = build_two_page_distinct_fonts();
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::No).unwrap();
for n in 1u32..=10 {
assert!(
is_live(&mut pdf, ObjectRef::new(n, 0)),
"obj {n} should be live in No mode"
);
}
}
#[test]
fn shared_resources_survive_when_both_pages_retained() {
let bytes = build_shared_resources_pdf();
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(4, 0), ObjectRef::new(5, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
assert!(
!is_live(&mut pdf, ObjectRef::new(3, 0)),
"intermediate /Pages node (obj 3) must be GC'd after rebuild+prune"
);
assert!(
is_live(&mut pdf, ObjectRef::new(4, 0)),
"page1 must survive"
);
assert!(
is_live(&mut pdf, ObjectRef::new(5, 0)),
"page2 must survive"
);
assert!(
is_live(&mut pdf, ObjectRef::new(7, 0)),
"content stream 1 must survive"
);
assert!(
is_live(&mut pdf, ObjectRef::new(8, 0)),
"content stream 2 must survive"
);
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let report = check_reader(Cursor::new(out)).unwrap();
assert!(
report.valid,
"PDF with both pages should be valid after prune: {:?}",
report.diagnostics
);
}
#[test]
fn auto_extracts_page1_from_shared_resources_prunes_f2() {
let bytes = build_shared_resources_pdf();
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(4, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
assert!(
!is_live(&mut pdf, ObjectRef::new(3, 0)),
"intermediate /Pages node (obj 3) must be GC'd"
);
assert!(
!is_live(&mut pdf, ObjectRef::new(5, 0)),
"page2 must be GC'd"
);
assert!(
!is_live(&mut pdf, ObjectRef::new(8, 0)),
"page2 content must be GC'd"
);
assert!(
is_live(&mut pdf, ObjectRef::new(4, 0)),
"page1 must survive"
);
assert!(
is_live(&mut pdf, ObjectRef::new(7, 0)),
"page1 content must survive"
);
let page1 = match pdf.resolve(ObjectRef::new(4, 0)).unwrap() {
Object::Dictionary(d) => d,
other => panic!("page1 not a dict: {other:?}"),
};
let res_dict = match page1.get("Resources") {
Some(Object::Dictionary(d)) => d.clone(),
other => panic!("page1 /Resources not an inline dict: {other:?}"),
};
let font_dict = match res_dict.get("Font") {
Some(Object::Dictionary(d)) => d.clone(),
other => panic!("page1 /Font not a dict: {other:?}"),
};
let font_keys: Vec<String> = font_dict
.iter()
.map(|(k, _)| String::from_utf8(k.to_vec()).unwrap())
.collect();
assert!(
font_keys.contains(&"F1".to_string()),
"F1 must remain: {font_keys:?}"
);
assert!(
!font_keys.contains(&"F2".to_string()),
"F2 must be pruned: {font_keys:?}"
);
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let report = check_reader(Cursor::new(out)).unwrap();
assert!(
report.valid,
"pruned PDF must be valid: {:?}",
report.diagnostics
);
}
fn build_pdf_with_info() -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.4\n".to_vec();
let mut offs: BTreeMap<u32, u64> = BTreeMap::new();
let objs: Vec<(u32, &str)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Title (Test Document) /Author (Test Author) >>"),
];
for (n, s) in &objs {
offs.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{s}\nendobj\n").as_bytes());
}
let xref_start = out.len() as u64;
let total = 6u32;
out.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for i in 1..total {
out.extend_from_slice(format!("{:010} 00000 n \n", offs[&i]).as_bytes());
}
out.extend_from_slice(
format!(
"trailer\n<< /Size {total} /Root 1 0 R /Info 5 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
out
}
#[test]
fn trailer_info_object_survives_gc() {
let bytes = build_pdf_with_info();
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
assert!(
is_live(&mut pdf, ObjectRef::new(5, 0)),
"/Info object (trailer ref) must NOT be GC'd"
);
assert!(
!is_live(&mut pdf, ObjectRef::new(4, 0)),
"page 2 should be GC'd"
);
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let report = check_reader(Cursor::new(out)).unwrap();
assert!(
report.valid,
"pruned PDF with /Info must be valid: {:?}",
report.diagnostics
);
}
#[test]
fn round_trip_valid_after_prune() {
let bytes = build_two_page_distinct_fonts();
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
let mut out: Vec<u8> = Vec::new();
write_pdf(&mut pdf, &mut out).unwrap();
let mut pdf2 = Pdf::open(Cursor::new(out)).unwrap();
let refs = page_refs(&mut pdf2).unwrap();
assert_eq!(refs.len(), 1, "output should have exactly 1 page");
}
}