use crate::{Object, ObjectRef, Pdf};
use std::collections::{BTreeMap, BTreeSet, VecDeque};
use std::io::{Read, Seek};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PageHintEntry {
pub page_ref: ObjectRef,
pub first_object_index: u32,
pub object_count: u32,
pub byte_length: u64,
}
impl PageHintEntry {
pub fn placeholder(page_ref: ObjectRef) -> Self {
Self {
page_ref,
first_object_index: 0,
object_count: 0,
byte_length: 0,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SharedObjectHintEntry {
pub object_ref: ObjectRef,
pub referencing_pages: Vec<u32>,
}
impl SharedObjectHintEntry {
pub fn new(object_ref: ObjectRef) -> Self {
Self {
object_ref,
referencing_pages: Vec::new(),
}
}
}
fn collect_direct_refs(obj: &Object, out: &mut Vec<ObjectRef>) {
match obj {
Object::Reference(r) => out.push(*r),
Object::Array(arr) => {
for elem in arr {
collect_direct_refs(elem, out);
}
}
Object::Dictionary(dict) => {
for (_k, v) in dict.iter() {
collect_direct_refs(v, out);
}
}
Object::Stream(s) => {
for (_k, v) in s.dict.iter() {
collect_direct_refs(v, out);
}
}
_ => {}
}
}
fn compute_closure<R: Read + Seek>(
pdf: &mut Pdf<R>,
root: ObjectRef,
) -> crate::Result<Vec<ObjectRef>> {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut order: Vec<ObjectRef> = Vec::new();
let mut queue: VecDeque<ObjectRef> = VecDeque::from([root]);
while let Some(current) = queue.pop_front() {
if !visited.insert(current) {
continue;
}
order.push(current);
let obj = pdf.resolve(current)?;
let is_pages_node = matches!(&obj, Object::Dictionary(d)
if matches!(d.get("Type"), Some(Object::Name(n)) if n.as_slice() == b"Pages"));
let is_page_leaf = matches!(&obj, Object::Dictionary(d)
if matches!(d.get("Type"), Some(Object::Name(n)) if n.as_slice() == b"Page"));
if is_pages_node || is_page_leaf {
if let Object::Dictionary(dict) = &obj {
for (k, v) in dict.iter() {
if k == b"Kids" {
continue;
}
if k == b"Parent" {
let mut to_visit: Vec<ObjectRef> = Vec::new();
let mut seen_parents: BTreeSet<ObjectRef> = BTreeSet::new();
collect_direct_refs(v, &mut to_visit);
while let Some(parent_ref) = to_visit.pop() {
if !seen_parents.insert(parent_ref) {
continue;
}
let Ok(Object::Dictionary(parent_dict)) = pdf.resolve(parent_ref)
else {
continue;
};
for (pk, pv) in parent_dict.iter() {
if pk == b"Kids" {
continue;
}
if pk == b"Parent" {
collect_direct_refs(pv, &mut to_visit);
continue;
}
let mut refs = Vec::new();
collect_direct_refs(pv, &mut refs);
for r in refs {
if !visited.contains(&r) {
queue.push_back(r);
}
}
}
}
continue;
}
let mut refs = Vec::new();
collect_direct_refs(v, &mut refs);
for r in refs {
if !visited.contains(&r) {
queue.push_back(r);
}
}
}
}
} else {
let mut refs = Vec::new();
collect_direct_refs(&obj, &mut refs);
for r in refs {
if !visited.contains(&r) {
queue.push_back(r);
}
}
}
}
Ok(order)
}
#[derive(Debug, Clone)]
pub struct LinearizationPlan {
pub part1_objects: Vec<ObjectRef>,
pub part2_objects: Vec<ObjectRef>,
pub part3_objects: Vec<ObjectRef>,
pub part4_other_pages_private: Vec<ObjectRef>,
pub part4_other_pages_shared: Vec<ObjectRef>,
pub part4_rest: Vec<ObjectRef>,
pub total_object_count: u32,
pub root_ref: Option<ObjectRef>,
pub pages_tree_ref: Option<ObjectRef>,
pub info_ref: Option<ObjectRef>,
pub page_hints: Vec<PageHintEntry>,
pub shared_hints: Vec<SharedObjectHintEntry>,
pub per_page_private_objects: Vec<Vec<ObjectRef>>,
}
impl LinearizationPlan {
pub fn from_pdf<R: Read + Seek>(pdf: &mut Pdf<R>) -> crate::Result<Self> {
let all_refs: Vec<ObjectRef> = pdf
.object_refs()
.into_iter()
.filter(|r| r.number != 0)
.collect();
let total_object_count = all_refs.len() as u32;
let root_ref = pdf.root_ref();
let info_ref = pdf.trailer().get_ref("Info");
let pages_tree_ref = root_ref
.and_then(|r| pdf.resolve(r).ok())
.and_then(|obj| match obj {
Object::Dictionary(d) => d.get_ref("Pages"),
_ => None,
});
let page_refs: Vec<ObjectRef> = crate::pages::page_refs(pdf)?;
let first_page_closure: Vec<ObjectRef> = if let Some(&first_page) = page_refs.first() {
compute_closure(pdf, first_page)?
} else {
Vec::new()
};
let first_page_set: BTreeSet<ObjectRef> = first_page_closure.iter().copied().collect();
let mut shared_page_indices: BTreeMap<ObjectRef, BTreeSet<u32>> = BTreeMap::new();
let mut all_referenced_pages: BTreeMap<ObjectRef, BTreeSet<u32>> = BTreeMap::new();
let mut other_page_closures: Vec<Vec<ObjectRef>> =
Vec::with_capacity(page_refs.len().saturating_sub(1));
for obj_ref in &first_page_closure {
all_referenced_pages
.entry(*obj_ref)
.or_default()
.insert(0u32);
}
for (page_idx, &page_ref) in page_refs.iter().enumerate().skip(1) {
let closure = compute_closure(pdf, page_ref)?;
for obj_ref in &closure {
if first_page_set.contains(obj_ref) {
shared_page_indices
.entry(*obj_ref)
.or_default()
.insert(page_idx as u32);
}
all_referenced_pages
.entry(*obj_ref)
.or_default()
.insert(page_idx as u32);
}
other_page_closures.push(closure);
}
let first_page_ref = page_refs.first().copied();
let mut part2_objects: Vec<ObjectRef> = Vec::new();
let mut part3_objects: Vec<ObjectRef> = Vec::new();
for obj_ref in &first_page_closure {
if Some(*obj_ref) == first_page_ref {
part2_objects.push(*obj_ref);
} else if shared_page_indices.contains_key(obj_ref) {
part3_objects.push(*obj_ref);
} else {
part2_objects.push(*obj_ref);
}
}
let moved: BTreeSet<ObjectRef> = part2_objects
.iter()
.chain(&part3_objects)
.copied()
.collect();
let part4_provisional: Vec<ObjectRef> = all_refs
.into_iter()
.filter(|r| !moved.contains(r))
.collect();
let mut page_hints: Vec<PageHintEntry> = page_refs
.iter()
.map(|&r| PageHintEntry::placeholder(r))
.collect();
let part2_set: BTreeSet<ObjectRef> = part2_objects.iter().copied().collect();
let part3_set: BTreeSet<ObjectRef> = part3_objects.iter().copied().collect();
let page0_private = part2_objects.clone();
if !page_hints.is_empty() {
page_hints[0].first_object_index = 0;
page_hints[0].object_count = (page0_private.len() + part3_objects.len()) as u32;
}
let mut per_page_private_objects: Vec<Vec<ObjectRef>> = Vec::with_capacity(page_refs.len());
per_page_private_objects.push(page0_private);
let mut all_closures: Vec<Vec<ObjectRef>> = Vec::with_capacity(page_refs.len());
all_closures.push(first_page_closure.clone());
all_closures.extend(other_page_closures.iter().cloned());
let mut page_reach: BTreeMap<ObjectRef, u32> = BTreeMap::new();
for closure in &all_closures {
let unique: BTreeSet<ObjectRef> = closure.iter().copied().collect();
for r in unique {
*page_reach.entry(r).or_insert(0) += 1;
}
}
for (i, closure) in other_page_closures.into_iter().enumerate() {
let page_idx = i + 1; let private: Vec<ObjectRef> = closure
.into_iter()
.filter(|r| {
!part2_set.contains(r)
&& !part3_set.contains(r)
&& page_reach.get(r).copied() == Some(1)
})
.collect();
if page_idx < page_hints.len() {
let count = private.len().max(1) as u32;
page_hints[page_idx].object_count = count;
}
per_page_private_objects.push(private);
}
let provisional_set: BTreeSet<ObjectRef> = part4_provisional.iter().copied().collect();
let mut part4_other_pages_private: Vec<ObjectRef> = Vec::new();
let mut part4_other_pages_shared: Vec<ObjectRef> = Vec::new();
let mut part4_rest: Vec<ObjectRef> = Vec::new();
let mut placed_private: BTreeSet<ObjectRef> = BTreeSet::new();
for privates in per_page_private_objects.iter().skip(1) {
for &r in privates {
if provisional_set.contains(&r) && placed_private.insert(r) {
part4_other_pages_private.push(r);
}
}
}
for &r in &part4_provisional {
if placed_private.contains(&r) {
continue;
}
let reach = page_reach.get(&r).copied().unwrap_or(0);
let in_first_page = first_page_set.contains(&r);
if in_first_page {
continue;
}
if reach >= 2 {
part4_other_pages_shared.push(r);
} else {
part4_rest.push(r);
}
}
debug_assert_eq!(
part4_other_pages_private.len() + part4_other_pages_shared.len() + part4_rest.len(),
part4_provisional.len(),
"Part-4 sub-partition must preserve membership"
);
let has_any_shared = !part3_objects.is_empty() || !part4_other_pages_shared.is_empty();
let shared_hints: Vec<SharedObjectHintEntry> = if !has_any_shared {
Vec::new()
} else {
let part2_entries = part2_objects.iter().map(|&obj_ref| SharedObjectHintEntry {
object_ref: obj_ref,
referencing_pages: vec![],
});
let part3_entries = part3_objects.iter().map(|&obj_ref| {
let pages: Vec<u32> = shared_page_indices
.get(&obj_ref)
.map(|s| s.iter().copied().collect())
.unwrap_or_default();
SharedObjectHintEntry {
object_ref: obj_ref,
referencing_pages: pages,
}
});
let part4_shared_entries = part4_other_pages_shared.iter().map(|&obj_ref| {
let pages: Vec<u32> = all_referenced_pages
.get(&obj_ref)
.map(|s| s.iter().copied().collect())
.unwrap_or_default();
SharedObjectHintEntry {
object_ref: obj_ref,
referencing_pages: pages,
}
});
part2_entries
.chain(part3_entries)
.chain(part4_shared_entries)
.collect()
};
Ok(Self {
part1_objects: Vec::new(),
part2_objects,
part3_objects,
part4_other_pages_private,
part4_other_pages_shared,
part4_rest,
total_object_count,
root_ref,
pages_tree_ref,
info_ref,
page_hints,
shared_hints,
per_page_private_objects,
})
}
pub fn part4_objects(&self) -> Vec<ObjectRef> {
self.part4_other_pages_private
.iter()
.chain(&self.part4_other_pages_shared)
.chain(&self.part4_rest)
.copied()
.collect()
}
pub fn all_assigned_refs(&self) -> BTreeSet<ObjectRef> {
self.part1_objects
.iter()
.chain(&self.part2_objects)
.chain(&self.part3_objects)
.chain(&self.part4_other_pages_private)
.chain(&self.part4_other_pages_shared)
.chain(&self.part4_rest)
.copied()
.collect()
}
pub fn parts_are_disjoint(&self) -> bool {
let mut seen = BTreeSet::new();
for r in self
.part1_objects
.iter()
.chain(&self.part2_objects)
.chain(&self.part3_objects)
.chain(&self.part4_other_pages_private)
.chain(&self.part4_other_pages_shared)
.chain(&self.part4_rest)
{
if !seen.insert(*r) {
return false;
}
}
true
}
}
impl Default for LinearizationPlan {
fn default() -> Self {
Self {
part1_objects: Vec::new(),
part2_objects: Vec::new(),
part3_objects: Vec::new(),
part4_other_pages_private: Vec::new(),
part4_other_pages_shared: Vec::new(),
part4_rest: Vec::new(),
total_object_count: 0,
root_ref: None,
pages_tree_ref: None,
info_ref: None,
page_hints: Vec::new(),
shared_hints: Vec::new(),
per_page_private_objects: Vec::new(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
fn tiny_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref_section = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref_section.as_bytes());
let trailer = format!(
"trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
xref_start,
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open_tiny_pdf() -> Pdf<Cursor<Vec<u8>>> {
let bytes = tiny_pdf_bytes();
Pdf::open(Cursor::new(bytes)).expect("tiny PDF should parse")
}
fn two_page_shared_font_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(
b"2 0 obj\n<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 5 0 R /Contents 6 0 R >>\nendobj\n");
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 5 0 R /Contents 7 0 R >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Font << /F1 8 0 R >> >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n<< /Length 5 >>\nstream\nBT ET\nendstream\nendobj\n");
let off7 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\n<< /Length 5 >>\nstream\nBT ET\nendstream\nendobj\n");
let off8 = pdf.len() as u64;
pdf.extend_from_slice(
b"8 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref_section = format!(
"xref\n0 9\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4, off5, off6, off7, off8,
);
pdf.extend_from_slice(xref_section.as_bytes());
let trailer = format!(
"trailer\n<< /Size 9 /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
xref_start,
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open_two_page_shared_font() -> Pdf<Cursor<Vec<u8>>> {
let bytes = two_page_shared_font_bytes();
Pdf::open(Cursor::new(bytes)).expect("two-page PDF should parse")
}
fn cycle_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 4 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /XObject << /ImA 5 0 R >> >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /SomeRef 6 0 R >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n<< /SomeRef 5 0 R >>\nendobj\n");
let xref_start = pdf.len() as u64;
let xref_section = format!(
"xref\n0 7\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4, off5, off6,
);
pdf.extend_from_slice(xref_section.as_bytes());
let trailer = format!(
"trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
xref_start,
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open_cycle_pdf() -> Pdf<Cursor<Vec<u8>>> {
let bytes = cycle_pdf_bytes();
Pdf::open(Cursor::new(bytes)).expect("cycle PDF should parse")
}
#[test]
fn from_pdf_does_not_panic() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).expect("plan construction must succeed");
assert!(plan.total_object_count > 0);
}
#[test]
fn plan_fields_accessible() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
assert_eq!(plan.root_ref, Some(ObjectRef::new(1, 0)));
assert_eq!(plan.page_hints.len(), 1);
assert_eq!(plan.page_hints[0].page_ref, ObjectRef::new(3, 0));
assert_eq!(plan.page_hints[0].first_object_index, 0);
assert_eq!(plan.page_hints[0].byte_length, 0); }
#[test]
fn single_page_part2_non_empty_part3_empty() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
assert!(
!plan.part2_objects.is_empty(),
"Part 2 must contain first-page objects"
);
assert!(
plan.part3_objects.is_empty(),
"Part 3 must be empty for a single-page document"
);
let page_ref = ObjectRef::new(3, 0);
assert!(
plan.part2_objects.contains(&page_ref),
"page dict must be in Part 2"
);
assert!(plan.part1_objects.is_empty());
assert!(plan.shared_hints.is_empty());
}
#[test]
fn part4_contains_only_remaining_objects() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
let part4_set: BTreeSet<_> = plan.part4_objects().into_iter().collect();
for r in &plan.part2_objects {
assert!(
!part4_set.contains(r),
"Part-2 object {r} must not appear in Part 4"
);
}
for r in &plan.part3_objects {
assert!(
!part4_set.contains(r),
"Part-3 object {r} must not appear in Part 4"
);
}
}
#[test]
fn parts_are_disjoint_after_closure() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
assert!(
plan.parts_are_disjoint(),
"object refs must appear in at most one part"
);
}
#[test]
fn two_page_shared_font_partitioned_correctly() {
let mut pdf = open_two_page_shared_font();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
let shared_ref_resources = ObjectRef::new(5, 0);
let shared_ref_font = ObjectRef::new(8, 0);
assert!(
plan.part3_objects.contains(&shared_ref_resources),
"shared Resources dict must be in Part 3"
);
assert!(
plan.part3_objects.contains(&shared_ref_font),
"shared Font must be in Part 3"
);
let page1_content = ObjectRef::new(6, 0);
assert!(
plan.part2_objects.contains(&page1_content),
"page-1-only content stream must be in Part 2"
);
let page2_content = ObjectRef::new(7, 0);
assert!(
plan.part4_objects().contains(&page2_content),
"page-2-only content stream must be in Part 4"
);
assert!(plan.parts_are_disjoint());
}
#[test]
fn shared_hints_reference_correct_pages() {
let mut pdf = open_two_page_shared_font();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
let part2_len = plan.part2_objects.len();
for hint in &plan.shared_hints[..part2_len] {
assert!(
hint.referencing_pages.is_empty(),
"part2 shared hint for {} must have empty referencing_pages",
hint.object_ref
);
}
for hint in &plan.shared_hints[part2_len..] {
assert!(
!hint.referencing_pages.contains(&0),
"part3 shared hint for {} must NOT reference page 0 (physical ownership via first-page section)",
hint.object_ref
);
assert!(
hint.referencing_pages.contains(&1),
"part3 shared hint for {} must reference page 1 (second page)",
hint.object_ref
);
}
}
#[test]
fn cycle_does_not_loop_forever() {
let mut pdf = open_cycle_pdf();
let plan =
LinearizationPlan::from_pdf(&mut pdf).expect("cycle PDF must not cause infinite loop");
assert!(!plan.part2_objects.is_empty(), "Part 2 must be non-empty");
assert!(plan.parts_are_disjoint());
let xobj_a = ObjectRef::new(5, 0);
let xobj_b = ObjectRef::new(6, 0);
let in_part2_a = plan.part2_objects.contains(&xobj_a);
let in_part2_b = plan.part2_objects.contains(&xobj_b);
assert!(in_part2_a, "XObject A must be in Part 2");
assert!(in_part2_b, "XObject B must be in Part 2");
}
#[test]
fn page1_hint_object_count_matches_part2_plus_part3() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
assert_eq!(
plan.page_hints[0].object_count,
(plan.part2_objects.len() + plan.part3_objects.len()) as u32,
"page-0 hint object_count must match Part-2 + Part-3 length (all objects in first-page section)"
);
}
#[test]
fn hint_table_inputs_well_formed_empty() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
for entry in &plan.page_hints {
assert_ne!(entry.page_ref.number, 0);
}
for entry in &plan.shared_hints {
assert_ne!(entry.object_ref.number, 0);
}
}
fn two_level_pages_inherited_resources_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(
b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 2 /Resources 6 0 R >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [4 0 R 5 0 R] /Count 2 >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n<< /Font << /F1 7 0 R >> >>\nendobj\n");
let off7 = pdf.len() as u64;
pdf.extend_from_slice(
b"7 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref_section = format!(
"xref\n0 8\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4, off5, off6, off7,
);
pdf.extend_from_slice(xref_section.as_bytes());
let trailer = format!(
"trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
xref_start,
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn multilevel_pages_inherited_resources_join_page_closure() {
let bytes = two_level_pages_inherited_resources_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("multi-level Pages PDF should parse");
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
let resources_ref = ObjectRef::new(6, 0);
let font_ref = ObjectRef::new(7, 0);
let all_refs = plan.all_assigned_refs();
assert!(
all_refs.contains(&resources_ref),
"inherited /Resources (6 0 R) must be reachable from page closures, \
not stranded outside every part"
);
assert!(
all_refs.contains(&font_ref),
"/Font (7 0 R) reached via inherited /Resources must be classified"
);
assert!(
plan.part3_objects.contains(&resources_ref),
"shared inherited /Resources must end up in Part 3"
);
assert!(
!plan.part4_rest.contains(&resources_ref),
"shared inherited /Resources must NOT end up in part4_rest"
);
}
fn three_page_shared_content_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(
b"2 0 obj\n<< /Type /Pages /Kids [3 0 R 4 0 R 5 0 R] /Count 3 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 7 0 R /Contents 6 0 R >>\nendobj\n");
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 7 0 R /Contents 8 0 R >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 7 0 R /Contents 8 0 R >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n<< /Length 5 >>\nstream\nBT ET\nendstream\nendobj\n");
let off7 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\n<< /Font << /F1 9 0 R >> >>\nendobj\n");
let off8 = pdf.len() as u64;
pdf.extend_from_slice(b"8 0 obj\n<< /Length 5 >>\nstream\nBT ET\nendstream\nendobj\n");
let off9 = pdf.len() as u64;
pdf.extend_from_slice(
b"9 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref_section = format!(
"xref\n0 10\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4, off5, off6, off7, off8, off9,
);
pdf.extend_from_slice(xref_section.as_bytes());
let trailer = format!(
"trailer\n<< /Size 10 /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
xref_start,
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn non_first_page_shared_objects_in_shared_hints() {
let bytes = three_page_shared_content_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("three-page PDF should parse");
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
let shared_content = ObjectRef::new(8, 0);
assert!(
plan.part4_other_pages_shared.contains(&shared_content),
"content stream shared by pages 2 and 3 must be in part4_other_pages_shared"
);
assert!(
!plan.part4_rest.contains(&shared_content),
"content stream shared by pages 2 and 3 must NOT be in part4_rest"
);
let in_shared_hints = plan
.shared_hints
.iter()
.any(|h| h.object_ref == shared_content);
assert!(
in_shared_hints,
"content stream shared by pages 2 and 3 must appear in shared_hints"
);
let hint = plan
.shared_hints
.iter()
.find(|h| h.object_ref == shared_content)
.unwrap();
assert!(
hint.referencing_pages.contains(&1),
"shared content stream must reference page 1 (0-based)"
);
assert!(
hint.referencing_pages.contains(&2),
"shared content stream must reference page 2 (0-based)"
);
assert!(
!hint.referencing_pages.contains(&0),
"shared content stream must NOT reference page 0 (not reachable from page 1)"
);
assert!(plan.parts_are_disjoint());
}
}