use super::resource_pruning::RemoveUnreferencedResources;
use crate::page_document_helper::PageDocumentHelper;
use crate::{Pdf, Result};
use std::io::{Read, Seek};
pub(crate) fn prune_after_subset<R: Read + Seek>(
pdf: &mut Pdf<R>,
mode: RemoveUnreferencedResources,
) -> Result<()> {
if mode == RemoveUnreferencedResources::No {
return Ok(());
}
PageDocumentHelper::new(pdf).remove_unreferenced_resources()?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::job::check_bytes_for_test;
use crate::pages::page_refs;
use crate::pages::tree_rebuild::rebuild_page_tree;
use crate::writer::write_qpdf_to_memory;
use crate::{ObjectHandle, ObjectRef, Pdf};
use std::collections::BTreeMap;
use std::io::{Cursor, Read, Seek};
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 >> \
/Secret (UNREFERENCED_PAGE2) >>"
.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 build_pdf_from_bodies(bodies: &[Vec<u8>]) -> Vec<u8> {
let mut out = b"%PDF-1.4\n".to_vec();
let mut offsets = Vec::with_capacity(bodies.len());
for (index, body) in bodies.iter().enumerate() {
let number = index + 1;
offsets.push(out.len() as u64);
out.extend_from_slice(format!("{number} 0 obj\n").as_bytes());
out.extend_from_slice(body);
out.extend_from_slice(b"\nendobj\n");
}
let xref_start = out.len() as u64;
let total = bodies.len() + 1;
out.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for offset in offsets {
out.extend_from_slice(format!("{offset:010} 00000 n \n").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 stream_body(data: &[u8]) -> Vec<u8> {
let mut body = format!("<< /Length {} >>\nstream\n", data.len()).into_bytes();
body.extend_from_slice(data);
body.extend_from_slice(b"\nendstream");
body
}
fn resource_category_keys<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
category: &str,
) -> Vec<String> {
let page: ObjectHandle = resolved_handle(pdf, page_ref);
assert!(
page.as_dictionary().is_some(),
"page should be a dictionary"
);
let resources = page.try_get_key(b"/Resources").unwrap();
resources.try_is_scalar().expect("resources should resolve");
assert!(
resources.as_dictionary().is_some(),
"page resources should be a dictionary or reference"
);
let category_key = format!("/{category}").into_bytes();
if !resources.try_has_key(&category_key).unwrap() {
return Vec::new();
}
let category = resources.try_get_key(&category_key).unwrap();
category
.try_is_scalar()
.expect("resource category should resolve");
category
.as_dictionary()
.expect("resolved resource category should be a dictionary")
.keys()
.map(|name| {
String::from_utf8(name.clone())
.expect("resource name is UTF-8")
.strip_prefix('/')
.unwrap_or_default()
.to_owned()
})
.collect()
}
fn resolved_handle<R: Read + Seek>(pdf: &mut Pdf<R>, object_ref: ObjectRef) -> ObjectHandle {
let handle = pdf.get_object_handle(object_ref);
handle.try_is_scalar().expect("resolve object");
handle
}
fn is_live(pdf: &mut Pdf<Cursor<Vec<u8>>>, r: ObjectRef) -> bool {
pdf.canonical_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)));
assert!(is_live(&mut pdf, ObjectRef::new(8, 0)));
assert!(is_live(&mut pdf, ObjectRef::new(9, 0)));
assert!(is_live(&mut pdf, ObjectRef::new(10, 0)));
assert_eq!(
resource_category_keys(&mut pdf, ObjectRef::new(3, 0), "Font"),
vec!["F1"],
"page1 must retain its used F1 resource"
);
assert!(
is_live(&mut pdf, ObjectRef::new(6, 0)),
"font F1 should survive"
);
let out = write_qpdf_to_memory(&mut pdf, |_| {}).unwrap();
assert!(
!out.windows(b"UNREFERENCED_PAGE2".len())
.any(|window| window == b"UNREFERENCED_PAGE2"),
"writer must omit the unreferenced page2 dictionary"
);
assert!(!out
.windows(b"/Courier".len())
.any(|window| window == b"/Courier"));
let mut written = Pdf::open(Cursor::new(out.clone())).unwrap();
assert_eq!(page_refs(&mut written).unwrap().len(), 1);
check_bytes_for_test(out).expect("canonical qpdf check should run");
}
#[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)));
let out = write_qpdf_to_memory(&mut pdf, |_| {}).unwrap();
assert!(!out
.windows(b"UNREFERENCED_PAGE2".len())
.any(|window| window == b"UNREFERENCED_PAGE2"));
assert!(!out
.windows(b"/Courier".len())
.any(|window| window == b"/Courier"));
}
#[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)));
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 out = write_qpdf_to_memory(&mut pdf, |_| {}).unwrap();
assert_eq!(
out.windows(b"/Type /Pages".len())
.filter(|window| *window == b"/Type /Pages")
.count(),
1,
"writer must omit the orphaned intermediate /Pages node"
);
let mut written = Pdf::open(Cursor::new(out.clone())).unwrap();
assert_eq!(page_refs(&mut written).unwrap().len(), 2);
check_bytes_for_test(out).expect("canonical qpdf check should run");
}
#[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)));
assert!(is_live(&mut pdf, ObjectRef::new(5, 0)));
assert!(is_live(&mut pdf, ObjectRef::new(8, 0)));
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 = resolved_handle(&mut pdf, ObjectRef::new(4, 0));
assert!(page1.as_dictionary().is_some(), "page1 not a dict");
let res_dict = page1.try_get_key(b"/Resources").unwrap();
res_dict.try_is_scalar().expect("resolve page1 resources");
assert!(
res_dict.as_dictionary().is_some(),
"page1 /Resources was not materialized directly"
);
let font_dict = res_dict.try_get_key(b"/Font").unwrap();
font_dict.try_is_scalar().expect("resolve page1 fonts");
let font_keys: Vec<String> = font_dict
.as_dictionary()
.expect("page1 /Font not a dict")
.keys()
.map(|k| {
String::from_utf8(k.clone())
.unwrap()
.strip_prefix('/')
.unwrap_or_default()
.to_owned()
})
.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 out = write_qpdf_to_memory(&mut pdf, |_| {}).unwrap();
let mut written = Pdf::open(Cursor::new(out.clone())).unwrap();
assert_eq!(page_refs(&mut written).unwrap().len(), 1);
assert_eq!(
out.windows(b"/Type /Pages".len())
.filter(|window| *window == b"/Type /Pages")
.count(),
1
);
assert!(!out.windows(b"/F2".len()).any(|window| window == b"/F2"));
check_bytes_for_test(out).expect("canonical qpdf check should run");
}
#[test]
fn malformed_page_does_not_materialize_indirect_resources_before_parse_gate() {
let bytes = build_pdf_from_bodies(&[
b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec(),
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources 5 0 R >>".to_vec(),
stream_body(b"[ /F1"),
b"<< /Font << /F1 << /Type /Font >> /F2 << /Type /Font >> >> >>".to_vec(),
]);
let mut pdf = open(bytes);
let page_ref = ObjectRef::new(3, 0);
let resources_ref = ObjectRef::new(5, 0);
rebuild_page_tree(&mut pdf, &[page_ref]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
let page = resolved_handle(&mut pdf, page_ref);
assert!(
page.as_dictionary().is_some(),
"selected page should remain a dictionary"
);
assert_eq!(
page.try_get_key(b"/Resources").unwrap().object_ref(),
Some(resources_ref),
"parse failure must leave the page's indirect /Resources ownership unchanged"
);
assert!(
is_live(&mut pdf, resources_ref),
"the untouched indirect /Resources object must remain reachable"
);
}
#[test]
fn resource_category_keys_resolves_indirect_holders() {
let bytes = build_pdf_from_bodies(&[
b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec(),
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 4 0 R >>".to_vec(),
b"<< /Font 5 0 R >>".to_vec(),
b"<< /F1 << /Type /Font >> >>".to_vec(),
]);
let mut pdf = open(bytes);
assert_eq!(
resource_category_keys(&mut pdf, ObjectRef::new(3, 0), "Font"),
vec!["F1"]
);
assert!(resource_category_keys(&mut pdf, ObjectRef::new(3, 0), "XObject").is_empty());
}
#[test]
fn shared_xobject_category_is_pruned_independently_per_page() {
let bytes = build_pdf_from_bodies(&[
b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
b"<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>".to_vec(),
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 7 0 R /Resources 5 0 R >>".to_vec(),
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 8 0 R /Resources 6 0 R >>".to_vec(),
b"<< /XObject 9 0 R >>".to_vec(),
b"<< /XObject 9 0 R >>".to_vec(),
stream_body(b"q /X1 Do Q"),
stream_body(b"q /X2 Do Q"),
b"<< /X1 10 0 R /X2 11 0 R >>".to_vec(),
b"<< /Type /XObject /Subtype /Image >>".to_vec(),
b"<< /Type /XObject /Subtype /Image >>".to_vec(),
]);
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0), ObjectRef::new(4, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
assert_eq!(
resource_category_keys(&mut pdf, ObjectRef::new(3, 0), "XObject"),
vec!["X1"],
"page 1 must prune the shared category against its own content"
);
assert_eq!(
resource_category_keys(&mut pdf, ObjectRef::new(4, 0), "XObject"),
vec!["X2"],
"page 2 must prune the shared category against its own content"
);
}
#[test]
fn subset_page_pruning_retains_non_font_and_non_xobject_categories() {
let bytes = build_pdf_from_bodies(&[
b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec(),
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources 5 0 R >>".to_vec(),
stream_body(b"BT /F1 12 Tf ET"),
b"<< /Font << /F1 << /Type /Font >> /UnusedFont << /Type /Font >> >> /XObject << /UnusedXObject << >> >> /ColorSpace << /UnusedColorSpace /DeviceRGB >> /Pattern << /UnusedPattern << >> >> /Shading << /UnusedShading << >> >> /ExtGState << /UnusedExtGState << >> >> /Properties << /UnusedProperties << >> >> >>".to_vec(),
]);
let mut pdf = open(bytes);
rebuild_page_tree(&mut pdf, &[ObjectRef::new(3, 0)]).unwrap();
prune_after_subset(&mut pdf, RemoveUnreferencedResources::Auto).unwrap();
assert_eq!(
resource_category_keys(&mut pdf, ObjectRef::new(3, 0), "Font"),
vec!["F1"],
"Font remains a qpdf page-copy pruning category"
);
assert!(
resource_category_keys(&mut pdf, ObjectRef::new(3, 0), "XObject").is_empty(),
"XObject remains a qpdf page-copy pruning category"
);
for category in [
"ColorSpace",
"Pattern",
"Shading",
"ExtGState",
"Properties",
] {
assert_eq!(
resource_category_keys(&mut pdf, ObjectRef::new(3, 0), category),
vec![format!("Unused{category}")],
"qpdf page-copy pruning must not remove /{category} entries"
);
}
}
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] \
/Secret (UNREFERENCED_PAGE2) >>",
),
(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)));
assert!(is_live(&mut pdf, ObjectRef::new(4, 0)));
let out = write_qpdf_to_memory(&mut pdf, |_| {}).unwrap();
assert!(!out
.windows(b"UNREFERENCED_PAGE2".len())
.any(|window| window == b"UNREFERENCED_PAGE2"));
let mut written = Pdf::open(Cursor::new(out.clone())).unwrap();
let info = written.trailer_key_handle(b"Info");
info.try_is_scalar().unwrap();
assert_eq!(
info.try_get_key(b"/Author").unwrap().as_string(),
Some(b"Test Author".to_vec())
);
assert_eq!(page_refs(&mut written).unwrap().len(), 1);
check_bytes_for_test(out).expect("canonical qpdf check should run");
}
#[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 out = write_qpdf_to_memory(&mut pdf, |_| {}).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");
}
}