use crate::linearization::renumber::RenumberMap;
use crate::object::MAX_INLINE_DEPTH;
use crate::writer::object_streams::{
collect_indirect_objstm_length_refs, eligibility_context, is_eligible_for_objstm,
ObjectStreamMode, PlannerConfig,
};
use crate::{Object, ObjectRef, Pdf, Result};
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, depth: usize, out: &mut Vec<ObjectRef>) -> Result<()> {
if depth > MAX_INLINE_DEPTH {
return Err(crate::Error::Unsupported(format!(
"linearization plan: inline object nesting exceeds maximum of {MAX_INLINE_DEPTH}"
)));
}
match obj {
Object::Reference(r) => out.push(*r),
Object::Array(arr) => {
for elem in arr {
collect_direct_refs(elem, depth + 1, out)?;
}
}
Object::Dictionary(dict) => {
for (_k, v) in dict.iter() {
collect_direct_refs(v, depth + 1, out)?;
}
}
Object::Stream(s) => {
for (k, v) in s.dict.iter() {
if k == b"Length" {
continue;
}
collect_direct_refs(v, depth + 1, out)?;
}
}
_ => {}
}
Ok(())
}
fn collect_direct_refs_with_context(
obj: &Object,
depth: usize,
in_array: bool,
out: &mut Vec<(ObjectRef, bool)>,
) -> Result<()> {
if depth > MAX_INLINE_DEPTH {
return Err(crate::Error::Unsupported(format!(
"linearization plan: inline object nesting exceeds maximum of {MAX_INLINE_DEPTH}"
)));
}
match obj {
Object::Reference(r) => out.push((*r, in_array)),
Object::Array(arr) => {
for elem in arr {
collect_direct_refs_with_context(elem, depth + 1, true, out)?;
}
}
Object::Dictionary(dict) => {
for (_k, v) in dict.iter() {
collect_direct_refs_with_context(v, depth + 1, false, out)?;
}
}
Object::Stream(s) => {
for (k, v) in s.dict.iter() {
if k == b"Length" {
continue;
}
collect_direct_refs_with_context(v, depth + 1, false, out)?;
}
}
_ => {}
}
Ok(())
}
fn is_page_tree_node(obj: &Object) -> bool {
matches!(obj, Object::Dictionary(d)
if matches!(d.get("Type"), Some(Object::Name(n))
if n.as_slice() == b"Pages" || n.as_slice() == b"Page"))
}
fn compute_closure<R: Read + Seek>(
pdf: &mut Pdf<R>,
root: ObjectRef,
live: &BTreeSet<ObjectRef>,
resurrectable: &BTreeSet<ObjectRef>,
) -> crate::Result<Vec<ObjectRef>> {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut order: Vec<ObjectRef> = Vec::new();
let mut queue: VecDeque<(ObjectRef, bool)> = VecDeque::from([(root, false)]);
let mut deferred_resurrect: BTreeSet<ObjectRef> = BTreeSet::new();
let mut seen_as_array: BTreeSet<ObjectRef> = BTreeSet::new();
let admits_body_object = |r: ObjectRef| -> bool { r.number != 0 && live.contains(&r) };
while let Some((current, via_array)) = queue.pop_front() {
if !visited.insert(current) {
continue;
}
if resurrectable.contains(¤t) {
if via_array || seen_as_array.contains(¤t) {
order.push(current);
} else {
deferred_resurrect.insert(current);
}
continue;
}
if !admits_body_object(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 Some(dict) = obj.as_dict() {
if is_page_leaf {
if let Some(resources) = dict.get("Resources") {
let mut seeds: Vec<(ObjectRef, bool)> = Vec::new();
collect_direct_refs_with_context(resources, 0, false, &mut seeds)?;
for &(r, va) in &seeds {
if va {
seen_as_array.insert(r); }
}
let mut stack: Vec<(ObjectRef, bool)> = seeds.into_iter().rev().collect();
while let Some((r, via_array)) = stack.pop() {
if !visited.insert(r) {
continue;
}
if resurrectable.contains(&r) {
if via_array || seen_as_array.contains(&r) {
order.push(r);
} else {
deferred_resurrect.insert(r);
} continue;
}
if !admits_body_object(r) {
continue;
}
let child = pdf.resolve(r)?;
if is_page_tree_node(&child) {
continue;
}
order.push(r);
let mut child_refs: Vec<(ObjectRef, bool)> = Vec::new();
collect_direct_refs_with_context(&child, 0, false, &mut child_refs)?;
for cr in child_refs.into_iter().rev() {
if cr.1 {
seen_as_array.insert(cr.0);
}
if !visited.contains(&cr.0) {
stack.push(cr);
}
}
}
}
} let mut refs_raw: Vec<(ObjectRef, bool)> = Vec::new();
for (k, v) in dict.iter() {
if k == b"Kids" {
continue;
}
if k == b"Thumb" {
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, 0, &mut to_visit)?;
while let Some(parent_ref) = to_visit.pop() {
if !seen_parents.insert(parent_ref) {
continue;
}
let parent_dict = match pdf.resolve_borrowed(parent_ref)? {
Object::Dictionary(dict) => dict,
Object::Reference(r) => {
to_visit.push(*r);
continue;
}
_ => continue,
};
for (pk, pv) in parent_dict.iter() {
if pk == b"Kids" {
continue;
}
if pk == b"Parent" {
collect_direct_refs(pv, 0, &mut to_visit)?;
continue;
}
let mut refs: Vec<(ObjectRef, bool)> = Vec::new();
collect_direct_refs_with_context(pv, 0, false, &mut refs)?;
for (r, va) in refs {
if va {
seen_as_array.insert(r); }
if !visited.contains(&r) {
queue.push_back((r, va));
}
}
}
}
continue;
}
collect_direct_refs_with_context(v, 0, false, &mut refs_raw)?;
}
for &(r, va) in &refs_raw {
if va {
seen_as_array.insert(r);
}
}
refs_raw.sort_by_key(|(r, _)| r.number);
for (r, va) in refs_raw {
if !visited.contains(&r) {
queue.push_back((r, va));
}
}
}
} else {
let mut refs: Vec<(ObjectRef, bool)> = Vec::new();
collect_direct_refs_with_context(&obj, 0, false, &mut refs)?;
for &(r, va) in &refs {
if va {
seen_as_array.insert(r);
}
}
refs.sort_by_key(|(r, _)| r.number);
for (r, va) in refs {
if !visited.contains(&r) {
queue.push_back((r, va));
}
}
}
}
if order.len() > 1 {
order[1..].sort_by_key(|r| r.number);
}
for r in deferred_resurrect {
if seen_as_array.contains(&r) {
let tail_pos = order[1..].partition_point(|existing| existing.number < r.number);
order.insert(1 + tail_pos, r);
} }
Ok(order)
}
#[derive(Debug, Clone)]
pub(crate) struct LinearizationRoutingUsers {
first_page: BTreeSet<ObjectRef>,
thumbnails: BTreeSet<ObjectRef>,
outlines: BTreeSet<ObjectRef>,
outlines_in_first_page: bool,
open_document: BTreeSet<ObjectRef>,
document_other: BTreeSet<ObjectRef>,
}
#[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>>,
pub all_referenced_pages: BTreeMap<ObjectRef, BTreeSet<u32>>,
pub(crate) outline_first_page_members: Vec<ObjectRef>,
pub(crate) part9_outline_objects: Vec<ObjectRef>,
pub(crate) part6_outline_objects: Vec<ObjectRef>,
pub part4_open_document_plain: Vec<ObjectRef>,
pub(crate) routing_users: Option<LinearizationRoutingUsers>,
pub(crate) removed_refs: BTreeSet<ObjectRef>,
pub(crate) object_stream_mode: crate::writer::ObjectStreamMode,
}
impl LinearizationPlan {
pub fn from_pdf<R: Read + Seek>(
pdf: &mut Pdf<R>,
use_generate_objstm: bool,
) -> crate::Result<Self> {
let mode = if use_generate_objstm {
crate::writer::ObjectStreamMode::Generate
} else {
crate::writer::ObjectStreamMode::Disable
};
Self::from_pdf_with_object_stream_mode(pdf, mode)
}
pub fn from_pdf_with_object_stream_mode<R: Read + Seek>(
pdf: &mut Pdf<R>,
object_stream_mode: crate::writer::ObjectStreamMode,
) -> crate::Result<Self> {
let use_generate_objstm = matches!(
object_stream_mode,
crate::writer::ObjectStreamMode::Generate
);
crate::linearization::inherited_attrs::push_inherited_attributes_to_pages(pdf)?;
let reachable = crate::rewrite_renumber::reachable_object_set(pdf, true)?;
let object_refs = pdf.object_refs();
let mut all_refs: Vec<ObjectRef> = Vec::with_capacity(object_refs.len());
for r in object_refs {
if r.number == 0 {
continue;
}
if crate::writer::is_source_structural_container(pdf.resolve_borrowed(r)?) {
continue;
}
if !reachable.contains(&r) {
continue;
}
all_refs.push(r);
}
let source_had_compressed_objects =
pdf.source_xref_entries()
.iter()
.any(|(_reference, offset)| {
matches!(offset, crate::xref::XrefOffset::Compressed { .. })
});
let operation_removes_stale_generations = use_generate_objstm
|| (matches!(
object_stream_mode,
crate::writer::ObjectStreamMode::Preserve
) && source_had_compressed_objects);
let removed_refs = if operation_removes_stale_generations {
crate::writer::object_streams::compressible_objgens_qpdf_plan(pdf)?.removed_refs
} else {
BTreeSet::new()
};
all_refs.retain(|reference| !removed_refs.contains(reference));
let resurrectable =
crate::rewrite_renumber::resurrectable_null_refs_excluding(pdf, &removed_refs)?;
let mut resurrected: Vec<ObjectRef> = resurrectable
.iter()
.filter(|r| all_refs.binary_search(r).is_err())
.copied()
.collect();
if !resurrected.is_empty() {
all_refs.append(&mut resurrected);
all_refs.sort();
}
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_borrowed(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 live: BTreeSet<ObjectRef> = pdf.live_object_refs().into_iter().collect();
let page_tree = page_tree_node_refs(pdf)?;
let page_object_users = page_object_users(pdf, &page_refs)?;
let mut all_referenced_pages: BTreeMap<ObjectRef, BTreeSet<u32>> = BTreeMap::new();
for (page_idx, users) in page_object_users.page.iter().enumerate() {
for &object_ref in users {
all_referenced_pages
.entry(object_ref)
.or_default()
.insert(page_idx as u32);
}
}
let first_page_users = page_object_users.page.first().cloned().unwrap_or_default();
let open_document_set = open_document_set_with_context(pdf, &page_tree)?;
let all_outline_refs = outlines_set_with_context(pdf, &page_tree)?;
let document_other_set = document_other_set_with_context(pdf, &page_tree)?;
let elig_ctx = if use_generate_objstm {
Some(eligibility_context(pdf)?)
} else {
None
};
let mut first_page_closure: Vec<ObjectRef> = if let Some(&first_page) = page_refs.first() {
compute_closure(pdf, first_page, &live, &resurrectable)?
} else {
Vec::new()
};
if let Some(users) = page_object_users.page.first() {
first_page_closure.retain(|object_ref| users.contains(object_ref));
}
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 other_page_closures: Vec<Vec<ObjectRef>> =
Vec::with_capacity(page_refs.len().saturating_sub(1));
for (page_idx, &page_ref) in page_refs.iter().enumerate().skip(1) {
let mut closure = compute_closure(pdf, page_ref, &live, &resurrectable)?;
closure.retain(|object_ref| page_object_users.page[page_idx].contains(object_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);
}
}
other_page_closures.push(closure);
}
let thumbnail_user_set = page_object_users.thumbnail_set();
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 all_outline_refs.contains(obj_ref) || open_document_set.contains(obj_ref) {
continue;
}
if Some(*obj_ref) == first_page_ref {
part2_objects.push(*obj_ref);
} else if shared_page_indices.contains_key(obj_ref)
|| document_other_set.contains(obj_ref)
|| thumbnail_user_set.contains(obj_ref)
{
part3_objects.push(*obj_ref);
} else {
part2_objects.push(*obj_ref);
}
}
part3_objects.sort_unstable_by_key(|r| r.number);
part2_objects.sort_unstable_by_key(|r| (Some(*r) != first_page_ref, r.number));
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| {
if part2_set.contains(r) || part3_set.contains(r) {
return false;
}
if open_document_set.contains(r) {
return false;
}
if all_outline_refs.contains(r) {
return false;
}
if document_other_set.contains(r) {
return false;
}
if thumbnail_user_set.contains(r) {
return false;
}
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 part4_open_document_plain: 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;
}
if all_outline_refs.contains(&r) {
part4_rest.push(r);
continue;
}
let reach = page_reach.get(&r).copied().unwrap_or(0);
let in_first_page = first_page_set.contains(&r) && !open_document_set.contains(&r);
if in_first_page {
continue;
}
if open_document_set.contains(&r) {
if let Some(ctx) = elig_ctx.as_ref() {
let obj = pdf.resolve_borrowed(r)?;
if is_eligible_for_objstm(r, obj, ctx) {
part4_rest.push(r);
} else {
part4_open_document_plain.push(r);
}
} else {
part4_open_document_plain.push(r);
}
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_open_document_plain.len(),
part4_provisional.len(),
"Part-4 sub-partition must preserve membership"
);
part4_open_document_plain.sort_unstable();
let outlines_in_first_page = outlines_in_first_page_predicate(pdf)?;
let outline_root_ref: Option<ObjectRef> = pdf
.root_ref()
.and_then(|r| pdf.resolve_borrowed(r).ok()?.as_dict()?.get_ref("Outlines"));
let extract_outlines = |src: &[ObjectRef]| -> Vec<ObjectRef> {
let mut v: Vec<ObjectRef> = src
.iter()
.filter(|r| all_outline_refs.contains(r))
.copied()
.collect();
if let Some(root) = outline_root_ref {
if let Some(pos) = v.iter().position(|&r| r == root) {
v[..=pos].rotate_right(1);
}
}
v
};
let (part6_outline_objects, part9_outline_objects): (Vec<ObjectRef>, Vec<ObjectRef>) =
if outlines_in_first_page {
(extract_outlines(&part4_rest), vec![])
} else {
(vec![], extract_outlines(&part4_rest))
};
let outline_extract_set: BTreeSet<ObjectRef> = part6_outline_objects
.iter()
.chain(&part9_outline_objects)
.copied()
.collect();
part4_rest.retain(|r| !outline_extract_set.contains(r));
if outlines_in_first_page && !page_hints.is_empty() {
page_hints[0].object_count += part6_outline_objects.len() as u32;
}
let outline_first_page_members: Vec<ObjectRef> = if outlines_in_first_page {
part6_outline_objects.clone()
} else {
vec![]
};
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 outline_entries =
outline_first_page_members
.iter()
.map(|&obj_ref| SharedObjectHintEntry {
object_ref: obj_ref,
referencing_pages: vec![],
});
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,
}
});
let shared_hints: Vec<SharedObjectHintEntry> = part2_entries
.chain(part3_entries)
.chain(outline_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,
part4_open_document_plain,
total_object_count,
root_ref,
pages_tree_ref,
info_ref,
page_hints,
shared_hints,
per_page_private_objects,
all_referenced_pages,
outline_first_page_members,
part9_outline_objects,
part6_outline_objects,
object_stream_mode,
removed_refs,
routing_users: Some(LinearizationRoutingUsers {
first_page: first_page_users,
thumbnails: thumbnail_user_set,
outlines: all_outline_refs,
outlines_in_first_page,
open_document: open_document_set,
document_other: document_other_set,
}),
})
}
pub fn part4_objects(&self) -> Vec<ObjectRef> {
self.part4_other_pages_private
.iter()
.chain(&self.part4_other_pages_shared)
.chain(&self.part9_outline_objects)
.chain(&self.part4_rest)
.copied()
.collect()
}
pub(crate) fn part8_container_nums(
&self,
member_to_container: &BTreeMap<ObjectRef, (u32, u32)>,
) -> BTreeSet<u32> {
let first_page: BTreeSet<ObjectRef> = self
.part2_objects
.iter()
.chain(&self.part3_objects)
.copied()
.collect();
let part4_shared: BTreeSet<ObjectRef> =
self.part4_other_pages_shared.iter().copied().collect();
let mut all_containers: BTreeSet<u32> = BTreeSet::new();
let mut container_pages: BTreeMap<u32, BTreeSet<u32>> = BTreeMap::new();
let mut has_first_page_member: BTreeSet<u32> = BTreeSet::new();
let mut has_shared_member: BTreeSet<u32> = BTreeSet::new();
for (member, &(cnum, _)) in member_to_container {
all_containers.insert(cnum);
if first_page.contains(member) {
has_first_page_member.insert(cnum);
}
if part4_shared.contains(member) {
has_shared_member.insert(cnum);
}
if let Some(pages) = self.all_referenced_pages.get(member) {
container_pages
.entry(cnum)
.or_default()
.extend(pages.iter().copied().filter(|&p| p != 0));
}
}
all_containers
.into_iter()
.filter(|cnum| {
!has_first_page_member.contains(cnum)
&& (has_shared_member.contains(cnum)
|| container_pages.get(cnum).is_some_and(|p| p.len() >= 2))
})
.collect()
}
pub(crate) fn rest_container_nums(
&self,
member_to_container: &BTreeMap<ObjectRef, (u32, u32)>,
) -> BTreeSet<u32> {
self.part9_outline_objects
.iter()
.filter_map(|member| member_to_container.get(member).map(|&(cnum, _)| cnum))
.collect()
}
pub(crate) fn canonical_shared_hints(
&self,
member_to_container: &BTreeMap<ObjectRef, (u32, u32)>,
renumber: &RenumberMap,
second_half_container_nums: &BTreeSet<u32>,
open_document_container_nums: &BTreeSet<u32>,
) -> Vec<SharedObjectHintEntry> {
if member_to_container.is_empty() {
return self.shared_hints.clone();
}
let first_page_input = self.part2_objects.len()
+ self.part3_objects.len()
+ self.outline_first_page_members.len();
let rest_container_nums = self.rest_container_nums(member_to_container);
let mut container_pos: BTreeMap<u32, usize> = BTreeMap::new();
let mut out: Vec<SharedObjectHintEntry> = Vec::with_capacity(self.shared_hints.len());
let mut first_page_out_end: Option<usize> = None;
for (input_idx, entry) in self.shared_hints.iter().enumerate() {
if input_idx == first_page_input {
first_page_out_end = Some(out.len());
}
match member_to_container.get(&entry.object_ref) {
Some(&(container_num, _idx)) => {
if open_document_container_nums.contains(&container_num) {
continue;
}
if input_idx < first_page_input
&& second_half_container_nums.contains(&container_num)
{
continue;
}
if input_idx >= first_page_input && rest_container_nums.contains(&container_num)
{
continue;
}
if let Some(&pos) = container_pos.get(&container_num) {
let merged: &mut Vec<u32> = &mut out[pos].referencing_pages;
for &p in &entry.referencing_pages {
if let Err(insert_at) = merged.binary_search(&p) {
merged.insert(insert_at, p);
}
}
} else {
let mut pages = entry.referencing_pages.clone();
pages.sort_unstable();
pages.dedup();
container_pos.insert(container_num, out.len());
out.push(SharedObjectHintEntry {
object_ref: ObjectRef::new(container_num, u16::MAX),
referencing_pages: pages,
});
}
}
None => out.push(entry.clone()),
}
}
let boundary = first_page_out_end.unwrap_or(out.len());
let new_number = |e: &SharedObjectHintEntry| -> u32 {
if e.object_ref.generation == u16::MAX {
e.object_ref.number
} else {
renumber
.new_for_original(e.object_ref)
.map_or(u32::MAX, |r| r.number)
}
};
out[..boundary].sort_unstable_by_key(&new_number);
for cnum in self.part8_container_nums(member_to_container) {
if !container_pos.contains_key(&cnum)
&& !open_document_container_nums.contains(&cnum)
&& !rest_container_nums.contains(&cnum)
{
out.push(SharedObjectHintEntry {
object_ref: ObjectRef::new(cnum, u16::MAX),
referencing_pages: Vec::new(), });
}
}
out[boundary..].sort_unstable_by_key(&new_number);
if !self.all_referenced_pages.is_empty() {
let mut container_members: BTreeMap<u32, Vec<ObjectRef>> = BTreeMap::new();
for (&member, &(cnum, _)) in member_to_container {
container_members.entry(cnum).or_default().push(member);
}
let pages_excluding_first = |refs: &mut dyn Iterator<Item = ObjectRef>| -> Vec<u32> {
let mut pages: BTreeSet<u32> = BTreeSet::new();
for r in refs {
if let Some(ps) = self.all_referenced_pages.get(&r) {
pages.extend(ps.iter().copied().filter(|&p| p != 0));
}
}
pages.into_iter().collect()
};
for entry in &mut out {
entry.referencing_pages = if entry.object_ref.generation == u16::MAX {
let members = container_members
.get(&entry.object_ref.number)
.cloned()
.unwrap_or_default();
pages_excluding_first(&mut members.into_iter())
} else {
pages_excluding_first(&mut std::iter::once(entry.object_ref))
};
}
}
out
}
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(crate) fn renumber_assigned_refs(&self) -> BTreeSet<ObjectRef> {
self.part2_objects
.iter()
.chain(&self.part3_objects)
.chain(&self.part4_other_pages_private)
.chain(&self.part4_other_pages_shared)
.chain(&self.part4_rest)
.chain(&self.part6_outline_objects)
.chain(&self.part9_outline_objects)
.chain(&self.part4_open_document_plain)
.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.part6_outline_objects)
.chain(&self.part9_outline_objects)
.chain(&self.part4_rest)
.chain(&self.part4_open_document_plain)
{
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(),
part4_open_document_plain: 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(),
all_referenced_pages: BTreeMap::new(),
outline_first_page_members: Vec::new(),
part9_outline_objects: Vec::new(),
part6_outline_objects: Vec::new(),
routing_users: None,
removed_refs: BTreeSet::new(),
object_stream_mode: crate::writer::ObjectStreamMode::Disable,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(crate) struct ObjStmBatchPlan {
pub(crate) open_document_batches: Vec<Vec<ObjectRef>>,
pub(crate) part3_batches: Vec<Vec<ObjectRef>>,
pub(crate) part4_batches: Vec<RoutedObjStmBatch>,
}
#[allow(dead_code)]
impl LinearizationPlan {
pub(crate) fn objstm_batches<R: Read + Seek>(
&self,
pdf: &mut Pdf<R>,
config: &PlannerConfig,
) -> crate::Result<ObjStmBatchPlan> {
if config.mode == ObjectStreamMode::Disable {
return Ok(ObjStmBatchPlan::default());
}
let routing_users = self.routing_users.as_ref().ok_or_else(|| {
crate::Error::Unsupported(
"linearization plan: missing object-user routing snapshot".to_string(),
)
})?;
let ctx = eligibility_context(pdf)?;
let length_exclusions = collect_indirect_objstm_length_refs(pdf)?;
let plan = match config.mode {
ObjectStreamMode::Disable => unreachable!(),
ObjectStreamMode::Generate => {
self.objstm_batches_generate(pdf, config, &ctx, &length_exclusions, routing_users)?
}
ObjectStreamMode::Preserve => {
self.objstm_batches_preserve(pdf, config, &ctx, &length_exclusions, routing_users)?
}
};
Ok(plan)
}
fn objstm_batches_generate<R: Read + Seek>(
&self,
pdf: &mut Pdf<R>,
_config: &PlannerConfig,
_ctx: &crate::writer::object_streams::EligibilityContext,
_length_exclusions: &BTreeSet<ObjectRef>,
routing_users: &LinearizationRoutingUsers,
) -> crate::Result<ObjStmBatchPlan> {
let assigned = self.renumber_assigned_refs();
let containers = objstm_membership_linearized(pdf, &assigned)?;
let routes =
route_objstm_containers(routing_users, &self.all_referenced_pages, &containers);
let mut open_document_batches: Vec<Vec<ObjectRef>> = Vec::new();
let mut part3_private: Vec<Vec<ObjectRef>> = Vec::new();
let mut part3_shared: Vec<Vec<ObjectRef>> = Vec::new();
let mut part3_outlines: Vec<Vec<ObjectRef>> = Vec::new();
let mut part4_private: Vec<RoutedObjStmBatch> = Vec::new();
let mut part4_shared: Vec<RoutedObjStmBatch> = Vec::new();
let mut part4_rest: Vec<RoutedObjStmBatch> = Vec::new();
for (mut members, route) in containers.into_iter().zip(routes) {
members.sort_unstable_by_key(|r| r.number);
push_routed_objstm_batch(
members,
route,
None,
&mut open_document_batches,
&mut part3_private,
&mut part3_shared,
&mut part3_outlines,
&mut part4_private,
&mut part4_shared,
&mut part4_rest,
);
}
let mut part4_batches = part4_private;
part4_batches.extend(part4_shared);
part4_batches.extend(part4_rest);
let mut part3_batches = part3_private;
part3_batches.extend(part3_shared);
part3_batches.extend(part3_outlines);
Ok(ObjStmBatchPlan {
open_document_batches,
part3_batches,
part4_batches,
})
}
fn objstm_batches_preserve<R: Read + Seek>(
&self,
pdf: &mut Pdf<R>,
_config: &PlannerConfig,
ctx: &crate::writer::object_streams::EligibilityContext,
length_exclusions: &BTreeSet<ObjectRef>,
routing_users: &LinearizationRoutingUsers,
) -> crate::Result<ObjStmBatchPlan> {
use crate::XrefOffset;
let entries = pdf.source_xref_entries();
let mut groups: BTreeMap<u32, Vec<(u32, ObjectRef)>> = BTreeMap::new();
for (obj_ref, offset) in &entries {
if let XrefOffset::Compressed { stream, index } = offset {
groups.entry(*stream).or_default().push((*index, *obj_ref));
}
}
let assigned = self.renumber_assigned_refs();
let page_dicts: BTreeSet<ObjectRef> = crate::pages::page_refs(pdf)?.into_iter().collect();
let catalog = self.root_ref;
let mut containers: Vec<Vec<ObjectRef>> = Vec::new();
let mut source_container_numbers: Vec<u32> = Vec::new();
for (container_num, mut members) in groups {
members.sort_by_key(|(idx, _)| *idx);
let mut surviving = Vec::new();
for (_idx, obj_ref) in members {
if page_dicts.contains(&obj_ref) || Some(obj_ref) == catalog {
continue;
}
if length_exclusions.contains(&obj_ref) || !assigned.contains(&obj_ref) {
continue;
}
let eligible = {
let obj = pdf.resolve_borrowed(obj_ref)?;
is_eligible_for_objstm(obj_ref, obj, ctx)
};
if eligible && !crate::writer::object_streams::is_qpdf_signature_dict(pdf, obj_ref)?
{
surviving.push(obj_ref);
}
}
if !surviving.is_empty() {
source_container_numbers.push(container_num);
containers.push(surviving);
}
}
let routes =
route_objstm_containers(routing_users, &self.all_referenced_pages, &containers);
let mut open_document_batches = Vec::new();
let mut part3_private = Vec::new();
let mut part3_shared = Vec::new();
let mut part3_outlines = Vec::new();
let mut part4_private = Vec::new();
let mut part4_shared = Vec::new();
let mut part4_rest = Vec::new();
for ((members, route), source_container_number) in containers
.into_iter()
.zip(routes)
.zip(source_container_numbers)
{
push_routed_objstm_batch(
members,
route,
Some(source_container_number),
&mut open_document_batches,
&mut part3_private,
&mut part3_shared,
&mut part3_outlines,
&mut part4_private,
&mut part4_shared,
&mut part4_rest,
);
}
let mut part3_batches = part3_private;
part3_batches.extend(part3_shared);
part3_batches.extend(part3_outlines);
let mut part4_batches = part4_private;
part4_batches.extend(part4_shared);
part4_batches.extend(part4_rest);
Ok(ObjStmBatchPlan {
open_document_batches,
part3_batches,
part4_batches,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ContainerPart {
OpenDocument,
FirstPagePrivate,
FirstPageShared,
FirstPageOutlines,
OtherPagePrivate,
OtherPageShared,
Rest,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct RoutedObjStmBatch {
pub(crate) members: Vec<ObjectRef>,
pub(crate) route: ContainerPart,
pub(crate) source_container_number: Option<u32>,
}
#[allow(clippy::too_many_arguments)]
fn push_routed_objstm_batch(
members: Vec<ObjectRef>,
route: ContainerPart,
source_container_number: Option<u32>,
open_document_batches: &mut Vec<Vec<ObjectRef>>,
part3_private: &mut Vec<Vec<ObjectRef>>,
part3_shared: &mut Vec<Vec<ObjectRef>>,
part3_outlines: &mut Vec<Vec<ObjectRef>>,
part4_private: &mut Vec<RoutedObjStmBatch>,
part4_shared: &mut Vec<RoutedObjStmBatch>,
part4_rest: &mut Vec<RoutedObjStmBatch>,
) {
match route {
ContainerPart::OpenDocument => open_document_batches.push(members),
ContainerPart::FirstPagePrivate => part3_private.push(members),
ContainerPart::FirstPageShared => part3_shared.push(members),
ContainerPart::FirstPageOutlines => part3_outlines.push(members),
ContainerPart::OtherPagePrivate => part4_private.push(RoutedObjStmBatch {
members,
route,
source_container_number,
}),
ContainerPart::OtherPageShared => part4_shared.push(RoutedObjStmBatch {
members,
route,
source_container_number,
}),
ContainerPart::Rest => part4_rest.push(RoutedObjStmBatch {
members,
route,
source_container_number,
}),
}
}
impl std::ops::Deref for RoutedObjStmBatch {
type Target = [ObjectRef];
fn deref(&self) -> &Self::Target {
&self.members
}
}
pub(crate) fn objstm_membership_linearized<R: Read + Seek>(
pdf: &mut Pdf<R>,
assigned: &BTreeSet<ObjectRef>,
) -> crate::Result<Vec<Vec<ObjectRef>>> {
let mut eligible = crate::writer::object_streams::compressible_objgens(pdf)?;
eligible.retain(|r| assigned.contains(r));
let streams = crate::writer::object_streams::even_split_into_streams(&eligible);
let mut erase: BTreeSet<ObjectRef> = crate::pages::page_refs(pdf)?.into_iter().collect();
if let Some(root) = pdf.root_ref() {
erase.insert(root);
}
Ok(streams
.into_iter()
.map(|stream| {
stream
.into_iter()
.filter(|r| !erase.contains(r))
.collect::<Vec<ObjectRef>>()
})
.filter(|container| !container.is_empty())
.collect())
}
const OPEN_DOCUMENT_CATALOG_KEYS: [&[u8]; 5] = [
b"ViewerPreferences",
b"PageMode",
b"Threads",
b"OpenAction",
b"AcroForm",
];
#[cfg_attr(not(test), allow(dead_code))]
fn open_document_set<R: Read + Seek>(pdf: &mut Pdf<R>) -> crate::Result<BTreeSet<ObjectRef>> {
let page_tree = page_tree_node_refs(pdf)?;
open_document_set_with_context(pdf, &page_tree)
}
fn open_document_set_with_context<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_tree: &BTreeSet<ObjectRef>,
) -> crate::Result<BTreeSet<ObjectRef>> {
let mut seeds: Vec<(ObjectRef, bool)> = Vec::new();
if let Some(enc) = pdf.trailer().get("Encrypt") {
collect_direct_refs_with_context(enc, 0, false, &mut seeds)?;
}
let catalog = pdf
.root_ref()
.map(|root| pdf.resolve_borrowed(root))
.transpose()?;
if let Some(Object::Dictionary(catalog)) = catalog {
for key in OPEN_DOCUMENT_CATALOG_KEYS {
if let Some(v) = catalog.get(key) {
collect_direct_refs_with_context(v, 0, false, &mut seeds)?;
}
}
}
closure_from_seeds(pdf, seeds, page_tree)
}
#[cfg_attr(not(test), allow(dead_code))]
fn document_other_set<R: Read + Seek>(pdf: &mut Pdf<R>) -> crate::Result<BTreeSet<ObjectRef>> {
let page_tree = page_tree_node_refs(pdf)?;
document_other_set_with_context(pdf, &page_tree)
}
fn document_other_set_with_context<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_tree: &BTreeSet<ObjectRef>,
) -> crate::Result<BTreeSet<ObjectRef>> {
let mut seeds: Vec<(ObjectRef, bool)> = Vec::new();
{
let trailer = pdf.trailer();
for (key, v) in trailer.iter() {
if key != b"Root" && key != b"Encrypt" {
collect_direct_refs_with_context(v, 0, false, &mut seeds)?;
}
}
}
let catalog = pdf
.root_ref()
.map(|root| pdf.resolve_borrowed(root))
.transpose()?;
if let Some(Object::Dictionary(catalog)) = catalog {
for (key, v) in catalog.iter() {
if !OPEN_DOCUMENT_CATALOG_KEYS.contains(&key) && key != b"Outlines" {
collect_direct_refs_with_context(v, 0, false, &mut seeds)?;
}
}
}
closure_from_seeds(pdf, seeds, page_tree)
}
const INHERITABLE_PAGE_KEYS: [&[u8]; 4] = [b"MediaBox", b"CropBox", b"Resources", b"Rotate"];
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum PageObjectUser {
Page,
Thumbnail,
}
#[derive(Debug, Default)]
struct PageObjectUsers {
page: Vec<BTreeSet<ObjectRef>>,
thumbnail: Vec<BTreeSet<ObjectRef>>,
}
impl PageObjectUsers {
fn thumbnail_set(&self) -> BTreeSet<ObjectRef> {
self.thumbnail
.iter()
.flat_map(|users| users.iter().copied())
.collect()
}
}
fn page_dictionary_for_user_traversal<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> crate::Result<crate::Dictionary> {
let Object::Dictionary(page) = pdf.resolve(page_ref)? else {
return Err(crate::Error::Unsupported(format!(
"linearization plan: page {page_ref} is not a dictionary"
)));
};
Ok(page)
}
fn page_object_users<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_refs: &[ObjectRef],
) -> crate::Result<PageObjectUsers> {
let mut result = PageObjectUsers {
page: Vec::with_capacity(page_refs.len()),
thumbnail: Vec::with_capacity(page_refs.len()),
};
for &page_ref in page_refs {
let page_dict = page_dictionary_for_user_traversal(pdf, page_ref)?;
let mut visited = BTreeSet::from([page_ref]);
let mut page_users = BTreeSet::new();
let mut thumbnail_users = BTreeSet::new();
page_users.insert(page_ref);
let mut stack = vec![(
Object::Dictionary(page_dict),
PageObjectUser::Page,
true,
false,
0usize,
)];
while let Some((object, user, top, via_array, depth)) = stack.pop() {
if depth > MAX_INLINE_DEPTH {
return Err(crate::Error::Unsupported(format!(
"linearization plan: inline object nesting exceeds maximum of {MAX_INLINE_DEPTH}"
)));
}
match object {
Object::Reference(object_ref) => {
let users = match user {
PageObjectUser::Page => &mut page_users,
PageObjectUser::Thumbnail => &mut thumbnail_users,
};
if crate::qpdf_null::value_is_null(pdf, &Object::Reference(object_ref))? {
if !visited.insert(object_ref) {
continue;
}
if via_array && object_ref.number > 0 {
users.insert(object_ref);
}
continue;
}
let resolved = pdf.resolve(object_ref)?;
let is_page = matches!(&resolved, Object::Dictionary(dict)
if matches!(dict.get("Type"), Some(Object::Name(name))
if name.as_slice() == b"Page"));
if is_page && !top {
continue;
}
if !visited.insert(object_ref) {
continue;
}
users.insert(object_ref);
stack.push((resolved, user, top, false, 0));
}
Object::Array(items) => {
for item in items.into_iter().rev() {
stack.push((item, user, false, true, depth + 1));
}
}
Object::Dictionary(dict) => {
let is_page = matches!(dict.get("Type"), Some(Object::Name(name))
if name.as_slice() == b"Page");
if is_page && !top {
continue;
}
let mut children = Vec::new();
let entries = crate::qpdf_null::snapshot_entries(&dict, false);
for (key, value) in crate::qpdf_null::visible_entries(pdf, entries)? {
if is_page && key == b"Parent" {
continue;
}
let child_user = if is_page && key == b"Thumb" {
PageObjectUser::Thumbnail
} else {
user
};
children.push((value, child_user));
}
for (value, child_user) in children.into_iter().rev() {
stack.push((value, child_user, false, false, depth + 1));
}
}
Object::Stream(stream) => {
let mut children = Vec::new();
let entries = crate::qpdf_null::snapshot_entries(&stream.dict, true);
for (_key, value) in crate::qpdf_null::visible_entries(pdf, entries)? {
children.push(value);
}
for value in children.into_iter().rev() {
stack.push((value, user, false, false, depth + 1));
}
}
Object::Null
| Object::Boolean(_)
| Object::Integer(_)
| Object::Real(_)
| Object::RealLiteral { .. }
| Object::Name(_)
| Object::String(_) => {}
}
}
result.page.push(page_users);
result.thumbnail.push(thumbnail_users);
}
Ok(result)
}
fn page_tree_node_refs<R: Read + Seek>(pdf: &mut Pdf<R>) -> crate::Result<BTreeSet<ObjectRef>> {
let mut out: BTreeSet<ObjectRef> = BTreeSet::new();
let pages_ref = match pdf
.root_ref()
.map(|root| pdf.resolve_borrowed(root))
.transpose()?
{
Some(Object::Dictionary(d)) => d.get_ref("Pages"),
_ => None,
};
let Some(pages_ref) = pages_ref else {
return Ok(out);
};
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut queue: VecDeque<ObjectRef> = VecDeque::new();
queue.push_back(pages_ref);
while let Some(r) = queue.pop_front() {
if !visited.insert(r) {
continue;
}
let Object::Dictionary(d) = pdf.resolve_borrowed(r)? else {
continue;
};
if !matches!(d.get("Type"), Some(Object::Name(n)) if n.as_slice() == b"Pages") {
continue;
}
out.insert(r);
if let Some(kids) = d.get("Kids") {
let mut kid_refs = Vec::new();
collect_direct_refs(kids, 0, &mut kid_refs)?;
for kr in kid_refs {
if !visited.contains(&kr) {
queue.push_back(kr);
}
}
}
}
Ok(out)
}
fn closure_from_seeds<R: Read + Seek>(
pdf: &mut Pdf<R>,
seeds: Vec<(ObjectRef, bool)>,
page_tree: &BTreeSet<ObjectRef>,
) -> crate::Result<BTreeSet<ObjectRef>> {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut out: BTreeSet<ObjectRef> = BTreeSet::new();
let mut queue: VecDeque<(ObjectRef, bool)> = seeds.into();
while let Some((r, via_array)) = queue.pop_front() {
if crate::qpdf_null::value_is_null(pdf, &Object::Reference(r))? {
if via_array && r.number > 0 {
out.insert(r);
}
continue;
}
if !visited.insert(r) {
continue;
}
let obj = pdf.resolve(r)?;
let mut children: Vec<(ObjectRef, bool)> = Vec::new();
match &obj {
Object::Dictionary(d) if matches!(d.get("Type"), Some(Object::Name(n)) if n.as_slice() == b"Page") =>
{
continue;
}
Object::Dictionary(d) if page_tree.contains(&r) => {
for (k, v) in d.iter() {
if !INHERITABLE_PAGE_KEYS.contains(&k) {
collect_direct_refs_with_context(v, 0, false, &mut children)?;
}
}
}
_ => collect_direct_refs_with_context(&obj, 0, false, &mut children)?,
}
out.insert(r);
for (cr, via_array) in children {
if !visited.contains(&cr) {
queue.push_back((cr, via_array));
}
}
}
Ok(out)
}
pub(crate) fn outlines_set<R: Read + Seek>(pdf: &mut Pdf<R>) -> crate::Result<BTreeSet<ObjectRef>> {
let page_tree = page_tree_node_refs(pdf)?;
outlines_set_with_context(pdf, &page_tree)
}
fn outlines_set_with_context<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_tree: &BTreeSet<ObjectRef>,
) -> crate::Result<BTreeSet<ObjectRef>> {
let mut seeds: Vec<(ObjectRef, bool)> = Vec::new();
let catalog = pdf
.root_ref()
.map(|root| pdf.resolve_borrowed(root))
.transpose()?;
if let Some(Object::Dictionary(catalog)) = catalog {
if let Some(v) = catalog.get("Outlines") {
collect_direct_refs_with_context(v, 0, false, &mut seeds)?;
}
}
closure_from_seeds(pdf, seeds, page_tree)
}
fn outlines_in_first_page_predicate<R: Read + Seek>(pdf: &mut Pdf<R>) -> crate::Result<bool> {
let Some(root) = pdf.root_ref() else {
return Ok(false); };
let Object::Dictionary(cat) = pdf.resolve(root)? else {
return Ok(false); };
if cat.get("Outlines").is_none() {
return Ok(false);
}
match cat.get("PageMode") {
Some(Object::Name(n)) => Ok(n == b"UseOutlines"),
Some(Object::Reference(r)) => {
let r = *r;
Ok(matches!(pdf.resolve(r)?, Object::Name(n) if n == b"UseOutlines"))
}
_ => Ok(false),
}
}
pub(crate) fn route_objstm_containers(
users: &LinearizationRoutingUsers,
referenced_pages: &BTreeMap<ObjectRef, BTreeSet<u32>>,
containers: &[Vec<ObjectRef>],
) -> Vec<ContainerPart> {
containers
.iter()
.map(|members| {
if members.iter().any(|m| users.outlines.contains(m)) {
return if users.outlines_in_first_page {
ContainerPart::FirstPageOutlines
} else {
ContainerPart::Rest
};
}
if members.iter().any(|m| users.open_document.contains(m)) {
return ContainerPart::OpenDocument;
}
if members.iter().any(|m| users.first_page.contains(m)) {
let has_other_page = members.iter().any(|member| {
referenced_pages
.get(member)
.is_some_and(|pages| pages.iter().any(|&page| page != 0))
});
let has_document_other = members.iter().any(|m| users.document_other.contains(m));
let has_thumbnail = members.iter().any(|m| users.thumbnails.contains(m));
return if has_other_page || has_document_other || has_thumbnail {
ContainerPart::FirstPageShared
} else {
ContainerPart::FirstPagePrivate
};
}
let mut other_pages: BTreeSet<u32> = BTreeSet::new();
for m in members {
if let Some(pages) = referenced_pages.get(m) {
other_pages.extend(pages.iter().copied().filter(|&p| p != 0));
}
}
match other_pages.len() {
0 => ContainerPart::Rest,
1 if members
.iter()
.any(|m| users.document_other.contains(m) || users.thumbnails.contains(m)) =>
{
ContainerPart::Rest
}
1 => ContainerPart::OtherPagePrivate,
_ => ContainerPart::OtherPageShared,
}
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::object::MAX_INLINE_DEPTH;
use std::io::Cursor;
fn route_with_plan(
plan: &LinearizationPlan,
containers: &[Vec<ObjectRef>],
) -> Vec<ContainerPart> {
route_objstm_containers(
plan.routing_users
.as_ref()
.expect("test plan must have routing users"),
&plan.all_referenced_pages,
containers,
)
}
#[test]
fn null_visible_generate_container_routes_to_rest() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/null-visible-matrix.pdf");
let mut pdf =
Pdf::open(std::io::BufReader::new(std::fs::File::open(path).unwrap())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let assigned = plan.renumber_assigned_refs();
let containers = objstm_membership_linearized(&mut pdf, &assigned).unwrap();
let routes = route_with_plan(&plan, &containers);
let users = plan.routing_users.as_ref().unwrap();
assert_eq!(
routes,
vec![ContainerPart::Rest],
"containers={containers:?}, first_page={:?}, document_other={:?}, pages={:?}",
users.first_page,
users.document_other,
plan.all_referenced_pages,
);
}
fn nested_arrays(depth: usize) -> Object {
let mut o = Object::Null;
for _ in 0..depth {
o = Object::Array(vec![o]);
}
o
}
#[test]
fn collect_direct_refs_errors_on_excessive_nesting() {
let mut out = Vec::new();
let err = collect_direct_refs(&nested_arrays(MAX_INLINE_DEPTH + 5), 0, &mut out);
assert!(matches!(err, Err(crate::Error::Unsupported(_))));
}
#[test]
fn collect_direct_refs_accepts_nesting_up_to_the_limit() {
let mut out = Vec::new();
let mut o = Object::Array(vec![Object::Reference(ObjectRef::new(4, 0))]);
for _ in 0..(MAX_INLINE_DEPTH - 1) {
o = Object::Array(vec![o]);
}
collect_direct_refs(&o, 0, &mut out).unwrap();
assert_eq!(out, vec![ObjectRef::new(4, 0)]);
}
#[test]
fn collect_direct_refs_with_context_errors_on_excessive_nesting() {
let mut out = Vec::new();
let err = collect_direct_refs_with_context(
&nested_arrays(MAX_INLINE_DEPTH + 5),
0,
false,
&mut out,
);
assert!(matches!(err, Err(crate::Error::Unsupported(_))));
}
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 two_page_shared_font_outline_ref_bytes(use_outlines: bool) -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
if use_outlines {
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Outlines 9 0 R /PageMode /UseOutlines >>\nendobj\n");
} else {
pdf.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Outlines 9 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 off9 = pdf.len() as u64;
pdf.extend_from_slice(
b"9 0 obj\n<< /Type /Outlines /First 10 0 R /Last 10 0 R /Count 1 >>\nendobj\n",
);
let off10 = pdf.len() as u64;
pdf.extend_from_slice(
b"10 0 obj\n<< /Title (Item) /Parent 9 0 R /Extra 8 0 R >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref_section = format!(
"xref\n0 11\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n\
{off6:010} 00000 n \n\
{off7:010} 00000 n \n\
{off8:010} 00000 n \n\
{off9:010} 00000 n \n\
{off10:010} 00000 n \n",
);
pdf.extend_from_slice(xref_section.as_bytes());
let trailer =
format!("trailer\n<< /Size 11 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n",);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open_two_page_shared_font_outline_ref() -> Pdf<Cursor<Vec<u8>>> {
let bytes = two_page_shared_font_outline_ref_bytes(false);
Pdf::open(Cursor::new(bytes)).expect("two-page outline-ref PDF should parse")
}
fn open_two_page_shared_font_outline_ref_use_outlines() -> Pdf<Cursor<Vec<u8>>> {
let bytes = two_page_shared_font_outline_ref_bytes(true);
Pdf::open(Cursor::new(bytes)).expect("two-page UseOutlines outline-ref 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, false).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, false).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, false).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_eq!(
plan.shared_hints.len(),
plan.part2_objects.len(),
"shared_hints must contain all part2 objects for single-page PDF"
);
for hint in &plan.shared_hints {
assert!(
plan.part2_objects.contains(&hint.object_ref),
"single-page shared_hint {:?} must be a Part-2 object",
hint.object_ref
);
assert!(
hint.referencing_pages.is_empty(),
"Part-2 shared hint must have empty referencing_pages (page 0 owns by layout)"
);
}
}
fn catalog_firstpage_shared_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0u64; 7];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(&mut pdf, 1, "<< /Type /Catalog /Pages 2 0 R /Ref2 5 0 R >>");
push(&mut pdf, 2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>");
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Font 4 0 R >> /Contents 6 0 R >>",
);
push(&mut pdf, 4, "<< /F1 5 0 R >>");
push(
&mut pdf,
5,
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
);
push(&mut pdf, 6, "<< /Length 2 >>\nstream\nBT\nendstream");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 7\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn document_other_ref_routes_first_page_object_to_part3() {
let mut pdf = Pdf::open(Cursor::new(catalog_firstpage_shared_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let font = ObjectRef::new(5, 0); assert!(
plan.part3_objects.contains(&font),
"Font reached via Catalog /Ref2 must be Part 3 (lc_first_page_shared); part3={:?}",
plan.part3_objects
);
assert!(
!plan.part2_objects.contains(&font),
"the shared Font must not also be in Part 2"
);
for r in [
ObjectRef::new(3, 0),
ObjectRef::new(4, 0),
ObjectRef::new(6, 0),
] {
assert!(
plan.part2_objects.contains(&r),
"first-page-private object {r:?} must be in Part 2"
);
}
}
fn thumb_first_page_shared_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0u64; 8];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(&mut pdf, 1, "<< /Type /Catalog /Pages 2 0 R >>");
push(
&mut pdf,
2,
"<< /Type /Pages /Count 2 /Kids [3 0 R 4 0 R] >>",
);
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /XObject << /Im0 5 0 R >> >> /Contents 6 0 R >>",
);
push(
&mut pdf,
4,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Contents 7 0 R /Thumb 5 0 R >>",
);
push(
&mut pdf,
5,
"<< /Type /XObject /Subtype /Image /Width 1 /Height 1 \
/ColorSpace /DeviceGray /BitsPerComponent 8 /Length 1 >>\nstream\nA\nendstream",
);
push(&mut pdf, 6, "<< /Length 2 >>\nstream\nBT\nendstream");
push(&mut pdf, 7, "<< /Length 2 >>\nstream\nBT\nendstream");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 8\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn direct_thumb_descendant_first_page_shared_pdf_bytes() -> Vec<u8> {
let mut bytes = thumb_first_page_shared_pdf_bytes();
let indirect = b"/Thumb 5 0 R";
let direct = b"/Thumb << /Image 5 0 R >>";
let offset = bytes
.windows(indirect.len())
.position(|window| window == indirect)
.expect("base fixture must contain indirect /Thumb");
bytes.splice(offset..offset + indirect.len(), direct.iter().copied());
let xref_offset = bytes
.windows(b"xref\n".len())
.position(|window| window == b"xref\n")
.expect("base fixture must contain xref");
let objects = bytes[..xref_offset].to_vec();
let mut rebuilt = objects;
let mut offsets = [0u64; 8];
for (number, object_offset) in offsets.iter_mut().enumerate().skip(1) {
let marker = format!("{number} 0 obj\n");
*object_offset = rebuilt
.windows(marker.len())
.position(|window| window == marker.as_bytes())
.expect("fixture object must exist") as u64;
}
let new_xref_offset = rebuilt.len() as u64;
rebuilt.extend_from_slice(b"xref\n0 8\n0000000000 65535 f \n");
for offset in offsets.iter().skip(1) {
rebuilt.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
rebuilt.extend_from_slice(
format!("trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{new_xref_offset}\n%%EOF\n")
.as_bytes(),
);
rebuilt
}
fn thumb_before_ordinary_first_edge_wins_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0u64; 6];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(&mut pdf, 1, "<< /Type /Catalog /Pages 2 0 R >>");
push(&mut pdf, 2, "<< /Type /Pages /Count 1 /Kids [3 0 R] >>");
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Contents 4 0 R /Thumb 5 0 R /Zzz 5 0 R >>",
);
push(&mut pdf, 4, "<< /Length 2 >>\nstream\nBT\nendstream");
push(&mut pdf, 5, "<< /Marker /thumbnail-first >>");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 6\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn direct_thumb_descendant_routes_first_page_object_to_part3() {
let mut pdf = Pdf::open(Cursor::new(
direct_thumb_descendant_first_page_shared_pdf_bytes(),
))
.unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let image = ObjectRef::new(5, 0);
assert!(
plan.part3_objects.contains(&image),
"direct /Thumb descendant must add an ou_thumb user; part2={:?} part3={:?}",
plan.part2_objects,
plan.part3_objects
);
assert!(!plan.part2_objects.contains(&image));
}
#[test]
fn thumb_before_later_ordinary_edge_keeps_object_out_of_first_page() {
let mut pdf = Pdf::open(Cursor::new(
thumb_before_ordinary_first_edge_wins_pdf_bytes(),
))
.unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let thumbnail = ObjectRef::new(5, 0);
assert!(
plan.part4_rest.contains(&thumbnail),
"/Thumb wins before /Zzz, so the thumbnail-only object belongs to part 9; \
part2={:?} part3={:?} part4_rest={:?}",
plan.part2_objects,
plan.part3_objects,
plan.part4_rest
);
assert!(!plan.part2_objects.contains(&thumbnail));
assert!(!plan.part3_objects.contains(&thumbnail));
assert_eq!(plan.page_hints[0].object_count, 2);
}
#[test]
fn thumb_target_that_is_first_page_object_is_part3_shared() {
let mut pdf = Pdf::open(Cursor::new(thumb_first_page_shared_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let x = ObjectRef::new(5, 0);
assert!(
plan.part3_objects.contains(&x),
"X (first-page object that is also page1's /Thumb) must be Part 3 \
(lc_first_page_shared); part2={:?} part3={:?}",
plan.part2_objects,
plan.part3_objects
);
assert!(
!plan.part2_objects.contains(&x),
"shared X must not also be Part 2"
);
}
fn self_thumb_first_page_private_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0u64; 8];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(&mut pdf, 1, "<< /Type /Catalog /Pages 2 0 R >>");
push(
&mut pdf,
2,
"<< /Type /Pages /Count 2 /Kids [3 0 R 4 0 R] >>",
);
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /XObject << /Im0 5 0 R >> >> /Contents 6 0 R /Thumb 5 0 R >>",
);
push(
&mut pdf,
4,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 7 0 R >>",
);
push(
&mut pdf,
5,
"<< /Type /XObject /Subtype /Image /Width 1 /Height 1 \
/ColorSpace /DeviceGray /BitsPerComponent 8 /Length 1 >>\nstream\nA\nendstream",
);
push(&mut pdf, 6, "<< /Length 2 >>\nstream\nBT\nendstream");
push(&mut pdf, 7, "<< /Length 2 >>\nstream\nBT\nendstream");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 8\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn self_thumb_first_page_object_stays_part2_private() {
let mut pdf = Pdf::open(Cursor::new(self_thumb_first_page_private_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let x = ObjectRef::new(5, 0);
assert!(
plan.part2_objects.contains(&x),
"self-thumb X must stay Part 2 (private)"
);
assert!(
!plan.part3_objects.contains(&x),
"self-thumb X must NOT be Part 3"
);
}
fn two_page_catalog_otherpage_other_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0u64; 9];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &[u8]| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n").as_bytes());
pdf.extend_from_slice(body);
pdf.extend_from_slice(b"\nendobj\n");
};
push(
&mut pdf,
1,
b"<< /Type /Catalog /Pages 2 0 R /Ref2 6 0 R >>",
);
push(
&mut pdf,
2,
b"<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>",
);
push(&mut pdf, 3, b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 5 0 R >> >> /Contents 7 0 R >>");
push(&mut pdf, 4, b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F2 6 0 R >> >> /Contents 8 0 R >>");
push(
&mut pdf,
5,
b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Name /F1 >>",
);
push(
&mut pdf,
6,
b"<< /Type /Font /Subtype /Type1 /BaseFont /Times-Roman /Name /F2 >>",
);
push(&mut pdf, 7, b"<< /Length 5 >>\nstream\nBT ET\nendstream");
push(&mut pdf, 8, b"<< /Length 5 >>\nstream\nBT ET\nendstream");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 9\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 9 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn document_other_ref_routes_other_page_object_to_part9() {
let mut pdf = Pdf::open(Cursor::new(two_page_catalog_otherpage_other_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let font = ObjectRef::new(6, 0);
assert!(
plan.part4_rest.contains(&font),
"others>0 other-page object must be part4_rest (part9 / lc_other); \
part4_rest={:?}",
plan.part4_rest
);
assert!(
!plan.part4_other_pages_private.contains(&font),
"others>0 other-page object must NOT be part7 (other_pages_private); \
part4_other_pages_private={:?}",
plan.part4_other_pages_private
);
let page2_content = ObjectRef::new(8, 0);
assert!(
plan.part4_other_pages_private.contains(&page2_content),
"page-2-private content (others==0) must remain part7"
);
assert_eq!(
plan.page_hints[1].object_count, 2,
"page 2 object_count must exclude the others>0 font (page dict + content)"
);
}
#[test]
fn part4_contains_only_remaining_objects() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).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, false).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, false).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 outline_referenced_shared_font_routes_to_outline_section_not_first_page() {
let mut pdf = open_two_page_shared_font_outline_ref();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let font = ObjectRef::new(8, 0);
let outline_root = ObjectRef::new(9, 0);
let outline_item = ObjectRef::new(10, 0);
assert!(
plan.part9_outline_objects.contains(&font),
"outline-referenced font must be in part9_outline_objects, got {:?}",
plan.part9_outline_objects
);
assert!(
!plan.part2_objects.contains(&font) && !plan.part3_objects.contains(&font),
"outline-referenced font must be peeled out of the first-page section"
);
assert!(
!plan.part4_other_pages_private.contains(&font),
"outline-referenced font must not be captured as other-page-private"
);
assert_eq!(
plan.part9_outline_objects,
vec![outline_root, font, outline_item],
"outline order must be [root] ++ ascending source number"
);
assert!(plan.parts_are_disjoint());
}
#[test]
fn outline_referenced_shared_font_routes_to_part6_under_use_outlines() {
let mut pdf = open_two_page_shared_font_outline_ref_use_outlines();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let font = ObjectRef::new(8, 0);
let outline_root = ObjectRef::new(9, 0);
let outline_item = ObjectRef::new(10, 0);
assert!(
plan.part6_outline_objects.contains(&font),
"UseOutlines: outline-referenced font must be in part6_outline_objects, got {:?}",
plan.part6_outline_objects
);
assert!(
plan.part9_outline_objects.is_empty(),
"UseOutlines: part9 outlines must be empty"
);
assert_eq!(
plan.part6_outline_objects,
vec![outline_root, font, outline_item],
"UseOutlines outline order must be [root] ++ ascending source number"
);
assert!(
!plan.part2_objects.contains(&font) && !plan.part3_objects.contains(&font),
"outline-referenced font must be peeled out of the first-page section"
);
let expected_page0 = (plan.part2_objects.len()
+ plan.part3_objects.len()
+ plan.part6_outline_objects.len()) as u32;
assert_eq!(
plan.page_hints[0].object_count, expected_page0,
"page-0 object_count must include the part6 outline objects"
);
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, false).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, false)
.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");
}
fn resources_duplicate_ref_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 << /A 4 0 R /B 4 0 R >> >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Font /Helvetica >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(
format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n {off3:010} 00000 n \n{off4:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn resources_crosslink_page_tree_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 << /Bad 2 0 R >> >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(
format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n {off3:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn resources_subtree_dedups_duplicate_ref() {
let mut pdf = Pdf::open(Cursor::new(resources_duplicate_ref_pdf_bytes()))
.expect("duplicate-ref PDF must parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
assert!(plan.parts_are_disjoint());
let res = ObjectRef::new(4, 0);
assert!(
plan.part2_objects.contains(&res),
"the resource object must be in the first-page section exactly once"
);
assert_eq!(
plan.part2_objects.iter().filter(|r| **r == res).count(),
1,
"duplicate /Resources ref must not duplicate the object in Part 2"
);
}
#[test]
fn resources_subtree_stops_at_page_tree_crosslink() {
let mut pdf = Pdf::open(Cursor::new(resources_crosslink_page_tree_pdf_bytes()))
.expect("crosslink PDF must parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
assert!(plan.parts_are_disjoint());
assert!(
plan.part2_objects.contains(&ObjectRef::new(3, 0)),
"the page leaf must anchor the first-page section"
);
let pages_node = ObjectRef::new(2, 0);
assert!(
!plan.part2_objects.contains(&pages_node) && !plan.part3_objects.contains(&pages_node),
"the cross-linked /Pages node must not be pulled into the first-page section"
);
}
#[test]
fn objstm_batches_generate_routes_page_tree_crosslink_user_to_first_half() {
let mut pdf = Pdf::open(Cursor::new(resources_crosslink_page_tree_pdf_bytes()))
.expect("crosslink PDF must parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, true).expect("plan");
let pages_node = ObjectRef::new(2, 0);
let batch_plan = plan
.objstm_batches(&mut pdf, &generate_config())
.expect("Generate mode must succeed");
assert!(
batch_plan
.part3_batches
.iter()
.any(|batch| batch.contains(&pages_node)),
"qpdf's page-object user traversal gives the cross-linked /Pages node \
a first-page user, so its generated ObjStm must route to the first half"
);
assert!(
batch_plan
.part4_batches
.iter()
.all(|batch| !batch.contains(&pages_node)),
"the cross-linked /Pages node must not be routed to the second half"
);
}
#[test]
fn page1_hint_object_count_matches_part2_plus_part3() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).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, false).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, false).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"
);
}
#[test]
fn from_pdf_push_step_is_idempotent_across_two_calls() {
let bytes = two_level_pages_inherited_resources_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("multi-level Pages PDF should parse");
let first = LinearizationPlan::from_pdf(&mut pdf, false).expect("first plan");
let count_after_first = pdf.object_refs().len();
let second = LinearizationPlan::from_pdf(&mut pdf, false).expect("second plan");
let count_after_second = pdf.object_refs().len();
assert_eq!(
count_after_first, count_after_second,
"a second from_pdf call on the same Pdf must not mint any new object"
);
assert_eq!(
first.all_assigned_refs(),
second.all_assigned_refs(),
"a second from_pdf call must produce the same set of assigned refs"
);
}
fn page_parent_resolve_error_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 4 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Length 9 >>\nstream\nab\nendstream\nendobj\n");
let xref_start = pdf.len() as u64;
let xref_section = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4,
);
pdf.extend_from_slice(xref_section.as_bytes());
let trailer = format!(
"trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{}\n%%EOF\n",
xref_start,
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn from_pdf_propagates_parent_chain_resolve_error() {
let bytes = page_parent_resolve_error_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("fixture xref/trailer must parse");
let result = LinearizationPlan::from_pdf(&mut pdf, false);
assert!(
result.is_err(),
"from_pdf must propagate a /Parent-chain resolve error, got Ok"
);
}
fn reference_chain_parent_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 4 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n5 0 R\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Type /Pages /Resources 6 0 R >>\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 from_pdf_ignores_reference_chain_leaf_parent_for_page_users() {
let bytes = reference_chain_parent_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("fixture must parse");
pdf.set_object(
ObjectRef::new(4, 0),
Object::Reference(ObjectRef::new(5, 0)),
);
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let resources_ref = ObjectRef::new(6, 0);
let font_ref = ObjectRef::new(7, 0);
assert!(
!plan.part2_objects.contains(&resources_ref)
&& !plan.part3_objects.contains(&resources_ref),
"detached /Resources reached only through leaf /Parent must not be a page user"
);
assert!(
!plan.part2_objects.contains(&font_ref) && !plan.part3_objects.contains(&font_ref),
"a font below detached /Resources must not be a page user"
);
}
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, false).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());
}
fn generate_config() -> PlannerConfig {
PlannerConfig {
mode: ObjectStreamMode::Generate,
batch_size_cap: std::num::NonZeroUsize::new(100).unwrap(),
}
}
fn preserve_config() -> PlannerConfig {
PlannerConfig {
mode: ObjectStreamMode::Preserve,
batch_size_cap: std::num::NonZeroUsize::new(100).unwrap(),
}
}
fn disable_config() -> PlannerConfig {
PlannerConfig {
mode: ObjectStreamMode::Disable,
batch_size_cap: std::num::NonZeroUsize::new(100).unwrap(),
}
}
#[test]
fn objstm_batches_disable_yields_empty_plan() {
let bytes = three_page_shared_content_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &disable_config()).unwrap();
assert!(
batch_plan.part3_batches.is_empty(),
"Disable must produce no part3 batches"
);
assert!(
batch_plan.part4_batches.is_empty(),
"Disable must produce no part4 batches"
);
}
#[test]
fn objstm_batches_generate_rejects_missing_routing_snapshot() {
let bytes = three_page_shared_content_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let err = LinearizationPlan::default()
.objstm_batches(&mut pdf, &generate_config())
.expect_err("hand-built Generate plan must require a routing snapshot");
assert!(matches!(
err,
crate::Error::Unsupported(ref message)
if message == "linearization plan: missing object-user routing snapshot"
));
}
#[test]
fn objstm_batches_default_disable_succeeds_without_routing_snapshot() {
let bytes = three_page_shared_content_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let batch_plan = LinearizationPlan::default()
.objstm_batches(&mut pdf, &disable_config())
.expect("hand-built Disable plan must not require a routing snapshot");
assert!(batch_plan.part3_batches.is_empty());
assert!(batch_plan.part4_batches.is_empty());
}
#[test]
fn objstm_batches_default_preserve_rejects_missing_routing_snapshot() {
let bytes = three_page_shared_content_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let err = LinearizationPlan::default()
.objstm_batches(&mut pdf, &preserve_config())
.expect_err("hand-built Preserve plan must require a routing snapshot");
assert!(matches!(
err,
crate::Error::Unsupported(ref message)
if message == "linearization plan: missing object-user routing snapshot"
));
}
#[test]
fn objstm_batches_generate_assigns_part3_and_part4() {
let bytes = three_page_shared_content_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &generate_config()).unwrap();
let all_part3_batched: std::collections::BTreeSet<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
let all_part4_batched: std::collections::BTreeSet<ObjectRef> = batch_plan
.part4_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
let resources_ref = ObjectRef::new(7, 0);
assert!(
all_part3_batched.contains(&resources_ref),
"Part-3 Resources dict 7 0 R must be packed into part3_batches"
);
let pages_tree = plan.pages_tree_ref.expect("fixture has a /Pages tree");
assert!(
all_part3_batched.contains(&pages_tree),
"the /Pages tree ({pages_tree}) must be folded into the first-half batch"
);
let catalog = plan.root_ref.expect("fixture has a /Catalog");
assert!(
!all_part3_batched.contains(&catalog) && !all_part4_batched.contains(&catalog),
"the /Catalog ({catalog}) must stay standalone (in no batch)"
);
assert!(
!all_part4_batched.contains(&resources_ref),
"Part-3 object 7 0 R must never be misrouted into part4_batches"
);
let shared_content = ObjectRef::new(8, 0);
assert!(
!all_part3_batched.contains(&shared_content),
"stream 8 0 R must NOT be in part3_batches"
);
assert!(
!all_part4_batched.contains(&shared_content),
"stream 8 0 R must NOT be in part4_batches (streams are ineligible)"
);
let intersection: Vec<_> = all_part3_batched.intersection(&all_part4_batched).collect();
assert!(
intersection.is_empty(),
"part3_batches and part4_batches must be disjoint; overlap: {intersection:?}"
);
}
#[test]
fn objstm_batches_generate_never_places_part2_in_batches() {
let bytes = three_page_shared_content_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &generate_config()).unwrap();
let part2_set: std::collections::BTreeSet<ObjectRef> =
plan.part2_objects.iter().copied().collect();
let all_batched: Vec<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.chain(
batch_plan
.part4_batches
.iter()
.flat_map(|b| b.members.iter().copied()),
)
.collect();
for r in &all_batched {
assert!(
!part2_set.contains(r),
"part2 object {r} must never appear in any ObjStm batch"
);
}
}
#[test]
fn objstm_batches_two_page_generate_part2_not_in_batches() {
let bytes = two_page_shared_font_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &generate_config()).unwrap();
let part2_set: std::collections::BTreeSet<ObjectRef> =
plan.part2_objects.iter().copied().collect();
let all_batched: Vec<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.chain(
batch_plan
.part4_batches
.iter()
.flat_map(|b| b.members.iter().copied()),
)
.collect();
for r in &all_batched {
assert!(
!part2_set.contains(r),
"part2 object {r} must never appear in any ObjStm batch (two-page fixture)"
);
}
}
#[test]
fn objstm_batches_generate_excludes_ineligible_objects() {
let bytes = two_page_shared_font_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &generate_config()).unwrap();
let all_batched: std::collections::BTreeSet<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.chain(
batch_plan
.part4_batches
.iter()
.flat_map(|b| b.members.iter().copied()),
)
.collect();
let page1_content = ObjectRef::new(6, 0);
assert!(
!all_batched.contains(&page1_content),
"stream 6 0 R (page-1 content, part2) must not be in any batch"
);
let page2_content = ObjectRef::new(7, 0);
assert!(
!all_batched.contains(&page2_content),
"stream 7 0 R (page-2 content, part4) must not be in any batch"
);
}
#[test]
fn objstm_batches_preserve_no_source_objstms_yields_empty_plan() {
let bytes = two_page_shared_font_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &preserve_config()).unwrap();
assert!(
batch_plan.part3_batches.is_empty(),
"Preserve with no source ObjStms must produce no part3 batches (no fall-through to Generate)"
);
assert!(
batch_plan.part4_batches.is_empty(),
"Preserve with no source ObjStms must produce no part4 batches"
);
}
fn build_objstm_payload_plan(members: &[(u32, &[u8])]) -> (Vec<u8>, usize) {
use flate2::write::ZlibEncoder;
use flate2::Compression;
use std::io::Write;
let mut header = String::new();
let mut body = Vec::new();
for (index, (number, object_data)) in members.iter().enumerate() {
let offset = body.len();
header.push_str(&format!("{} {} ", number, offset));
body.extend_from_slice(object_data);
if index + 1 < members.len() {
body.push(b'\n');
}
}
let mut decoded = Vec::new();
decoded.extend_from_slice(header.as_bytes());
decoded.extend_from_slice(&body);
let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());
enc.write_all(&decoded).unwrap();
let encoded = enc.finish().unwrap();
(encoded, header.len())
}
fn append_u24_be_plan(bytes: &mut Vec<u8>, value: u32) {
let b = value.to_be_bytes();
bytes.extend_from_slice(&b[1..]);
}
fn append_xref_entry_plan(entries: &mut Vec<u8>, entry_type: u8, field1: u32, field2: u8) {
entries.push(entry_type);
append_u24_be_plan(entries, field1);
entries.push(field2);
}
fn two_page_two_objstm_pdf_bytes() -> Vec<u8> {
let mut bytes = b"%PDF-1.5\n".to_vec();
let catalog_offset = bytes.len() as u32;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let objstm1_members: &[(u32, &[u8])] = &[
(2, b"<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>"),
(
3,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 5 0 R >>",
),
(
5,
b"<< /Font << /F1 << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >> >> >>",
),
];
let (stream1_data, first1) = build_objstm_payload_plan(objstm1_members);
let n1 = objstm1_members.len() as u32;
let objstm1_offset = bytes.len() as u32;
bytes.extend_from_slice(
format!(
"7 0 obj\n<< /Type /ObjStm /N {n1} /First {first1} /Length {} /Filter /FlateDecode >>\nstream\n",
stream1_data.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&stream1_data);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
let objstm2_members: &[(u32, &[u8])] = &[
(
4,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources 5 0 R >>",
),
(6, b"<< /Type /XRef >>"),
];
let (stream2_data, first2) = build_objstm_payload_plan(objstm2_members);
let n2 = objstm2_members.len() as u32;
let objstm2_offset = bytes.len() as u32;
bytes.extend_from_slice(
format!(
"8 0 obj\n<< /Type /ObjStm /N {n2} /First {first2} /Length {} /Filter /FlateDecode >>\nstream\n",
stream2_data.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&stream2_data);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
let xref_offset = bytes.len() as u32;
let mut xref_entries: Vec<u8> = Vec::new();
append_xref_entry_plan(&mut xref_entries, 0, 0, 0);
append_xref_entry_plan(&mut xref_entries, 1, catalog_offset, 0);
append_xref_entry_plan(&mut xref_entries, 2, 7, 0);
append_xref_entry_plan(&mut xref_entries, 2, 7, 1);
append_xref_entry_plan(&mut xref_entries, 2, 8, 0);
append_xref_entry_plan(&mut xref_entries, 2, 7, 2);
append_xref_entry_plan(&mut xref_entries, 2, 8, 1);
append_xref_entry_plan(&mut xref_entries, 1, objstm1_offset, 0);
append_xref_entry_plan(&mut xref_entries, 1, objstm2_offset, 0);
append_xref_entry_plan(&mut xref_entries, 1, xref_offset, 0);
bytes.extend_from_slice(
format!(
"9 0 obj\n<< /Type /XRef /Size 10 /Root 1 0 R /W [1 3 1] /Index [0 10] /Length {} >>\nstream\n",
xref_entries.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&xref_entries);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
bytes
}
fn resources_crosslink_page_tree_objstm_pdf_bytes() -> Vec<u8> {
let mut bytes = b"%PDF-1.5\n".to_vec();
let catalog_offset = bytes.len() as u32;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let page_offset = bytes.len() as u32;
bytes.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Bad 2 0 R >> >>\nendobj\n",
);
let objstm_members: &[(u32, &[u8])] = &[(2, b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>")];
let (stream_data, first) = build_objstm_payload_plan(objstm_members);
let objstm_offset = bytes.len() as u32;
bytes.extend_from_slice(
format!(
"4 0 obj\n<< /Type /ObjStm /N 1 /First {first} /Length {} \
/Filter /FlateDecode >>\nstream\n",
stream_data.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&stream_data);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
let xref_offset = bytes.len() as u32;
let mut xref_entries = Vec::new();
append_xref_entry_plan(&mut xref_entries, 0, 0, 0);
append_xref_entry_plan(&mut xref_entries, 1, catalog_offset, 0);
append_xref_entry_plan(&mut xref_entries, 2, 4, 0);
append_xref_entry_plan(&mut xref_entries, 1, page_offset, 0);
append_xref_entry_plan(&mut xref_entries, 1, objstm_offset, 0);
append_xref_entry_plan(&mut xref_entries, 1, xref_offset, 0);
bytes.extend_from_slice(
format!(
"5 0 obj\n<< /Type /XRef /Size 6 /Root 1 0 R /W [1 3 1] \
/Index [0 6] /Length {} >>\nstream\n",
xref_entries.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&xref_entries);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
bytes
}
#[test]
fn objstm_batches_preserve_routes_page_tree_crosslink_user_to_first_half() {
let bytes = resources_crosslink_page_tree_objstm_pdf_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("crosslink ObjStm PDF should parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let pages_node = ObjectRef::new(2, 0);
let batch_plan = plan
.objstm_batches(&mut pdf, &preserve_config())
.expect("Preserve mode must succeed");
assert!(
batch_plan
.part3_batches
.iter()
.any(|batch| batch.contains(&pages_node)),
"qpdf's page-object user traversal gives the cross-linked /Pages node \
a first-page user, so its preserved ObjStm must route to the first half"
);
assert!(
batch_plan
.part4_batches
.iter()
.all(|batch| !batch.contains(&pages_node)),
"the cross-linked /Pages node must not be routed to the second half"
);
}
#[test]
fn objstm_batches_preserve_source_objstm_grouping_and_union_route() {
let bytes = two_page_two_objstm_pdf_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("two-ObjStm PDF should parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let page1_ref = ObjectRef::new(3, 0);
assert!(
plan.part2_objects.contains(&page1_ref),
"page 1 dict (3 0 R) must be in Part 2"
);
let resources_ref = ObjectRef::new(5, 0);
assert!(
plan.part3_objects.contains(&resources_ref),
"shared Resources dict (5 0 R) must be in Part 3"
);
let page2_ref = ObjectRef::new(4, 0);
assert!(
plan.part4_objects().contains(&page2_ref),
"page 2 dict (4 0 R) must be in Part 4"
);
let batch_plan = plan
.objstm_batches(&mut pdf, &preserve_config())
.expect("Preserve mode must succeed");
let all_part3_batched: BTreeSet<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
let all_part4_batched: BTreeSet<ObjectRef> = batch_plan
.part4_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
assert!(
!all_part3_batched.contains(&page1_ref) && !all_part4_batched.contains(&page1_ref),
"first-page dictionary {page1_ref} must remain standalone"
);
assert!(
!all_part3_batched.contains(&page2_ref) && !all_part4_batched.contains(&page2_ref),
"other-page dictionary {page2_ref} must remain standalone"
);
let ineligible_ref = ObjectRef::new(6, 0);
assert!(
!all_part3_batched.contains(&ineligible_ref),
"ineligible /Type /XRef dict (6 0 R) must not appear in part3_batches"
);
assert!(
!all_part4_batched.contains(&ineligible_ref),
"ineligible /Type /XRef dict (6 0 R) must not appear in part4_batches"
);
assert!(
all_part3_batched.contains(&resources_ref),
"Part-3 Resources dict 5 0 R must be packed into part3_batches"
);
assert!(
!all_part4_batched.contains(&resources_ref),
"Part-3 object 5 0 R must NOT be misrouted into part4_batches"
);
let pages_ref = ObjectRef::new(2, 0);
assert!(
all_part3_batched.contains(&pages_ref),
"the /Pages tree (2 0 R) must be routed into part3_batches"
);
assert!(
!all_part4_batched.contains(&pages_ref),
"the /Pages tree (2 0 R) must NOT remain in part4_batches"
);
assert!(
batch_plan
.part3_batches
.iter()
.any(|batch| batch.contains(&pages_ref) && batch.contains(&resources_ref)),
"source ObjStm members 2 0 R and 5 0 R must remain in one first-half batch"
);
let catalog_ref = plan.root_ref.expect("fixture has a /Catalog");
assert!(
!all_part3_batched.contains(&catalog_ref) && !all_part4_batched.contains(&catalog_ref),
"the /Catalog ({catalog_ref}) must stay standalone (in no batch)"
);
let overlap: Vec<ObjectRef> = all_part3_batched
.intersection(&all_part4_batched)
.copied()
.collect();
assert!(
overlap.is_empty(),
"part3_batches and part4_batches must be disjoint; overlap: {overlap:?}"
);
use crate::writer::object_streams::{eligibility_context, is_eligible_for_objstm};
let ctx = eligibility_context(&mut pdf).unwrap();
for r in all_part3_batched.iter().chain(all_part4_batched.iter()) {
let obj = pdf.resolve_borrowed(*r).unwrap();
assert!(
is_eligible_for_objstm(*r, obj, &ctx),
"batched object {r} must be eligible for ObjStm"
);
}
let part3_set: BTreeSet<ObjectRef> = plan.part3_objects.iter().copied().collect();
let part4_set: BTreeSet<ObjectRef> = plan
.part4_other_pages_private
.iter()
.chain(&plan.part4_other_pages_shared)
.chain(&plan.part4_rest)
.copied()
.collect();
for r in all_part3_batched.iter().chain(all_part4_batched.iter()) {
assert!(
part3_set.contains(r) || part4_set.contains(r),
"batched object {r} has no linearization-plan slot \
(not in Part-3 or Part-4) — would break ObjStmLayout::build"
);
}
}
#[test]
fn objstm_batches_preserve_ignores_generate_cap() {
let bytes = two_page_two_objstm_pdf_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("two-ObjStm PDF should parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let cap1_config = PlannerConfig {
mode: crate::writer::object_streams::ObjectStreamMode::Preserve,
batch_size_cap: std::num::NonZeroUsize::new(1).unwrap(),
};
let batch_plan = plan
.objstm_batches(&mut pdf, &cap1_config)
.expect("Preserve with cap=1 must succeed");
assert!(
batch_plan.part3_batches.iter().any(|batch| {
batch.contains(&ObjectRef::new(2, 0))
&& batch.contains(&ObjectRef::new(5, 0))
&& batch.len() == 2
}),
"cap=1 must not split source ObjStm 7: {:?}",
batch_plan.part3_batches
);
let all_batched: BTreeSet<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.chain(
batch_plan
.part4_batches
.iter()
.flat_map(|b| b.members.iter().copied()),
)
.collect();
let resources_ref = ObjectRef::new(5, 0);
let pages_ref = ObjectRef::new(2, 0);
let page2_ref = ObjectRef::new(4, 0);
assert!(
!batch_plan.part3_batches.is_empty(),
"Part-3 (5 0 R) is packed into the first-half ObjStm; part3_batches must be non-empty"
);
assert!(
all_batched.contains(&resources_ref),
"Part-3 Resources dict 5 0 R must be batched (packed into the first-half ObjStm)"
);
assert!(
all_batched.contains(&pages_ref),
"2 0 R (/Pages tree, routed to the first-half batch) must be batched even with cap=1"
);
assert!(
!all_batched.contains(&page2_ref),
"page dictionary 4 0 R must be removed from preserved ObjStms"
);
}
fn objstm_two_part4_members_pdf_bytes() -> Vec<u8> {
let mut bytes = b"%PDF-1.5\n".to_vec();
let catalog_offset = bytes.len() as u32;
bytes.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Aux [10 0 R 11 0 R] >>\nendobj\n",
);
let pages_offset = bytes.len() as u32;
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let page1_offset = bytes.len() as u32;
bytes.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let objstm_members: &[(u32, &[u8])] =
&[(10, b"<< /Marker 10 >>"), (11, b"<< /Marker 11 >>")];
let (stream_data, first) = build_objstm_payload_plan(objstm_members);
let n = objstm_members.len() as u32;
let objstm_offset = bytes.len() as u32;
bytes.extend_from_slice(
format!(
"7 0 obj\n<< /Type /ObjStm /N {n} /First {first} /Length {} /Filter /FlateDecode >>\nstream\n",
stream_data.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&stream_data);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
let xref_offset = bytes.len() as u32;
let mut xref_entries: Vec<u8> = Vec::new();
append_xref_entry_plan(&mut xref_entries, 0, 0, 0); append_xref_entry_plan(&mut xref_entries, 1, catalog_offset, 0); append_xref_entry_plan(&mut xref_entries, 1, pages_offset, 0); append_xref_entry_plan(&mut xref_entries, 1, page1_offset, 0); for _ in 4..=6 {
append_xref_entry_plan(&mut xref_entries, 0, 0, 0); }
append_xref_entry_plan(&mut xref_entries, 1, objstm_offset, 0); for _ in 8..=9 {
append_xref_entry_plan(&mut xref_entries, 0, 0, 0); }
append_xref_entry_plan(&mut xref_entries, 2, 7, 0); append_xref_entry_plan(&mut xref_entries, 2, 7, 1); append_xref_entry_plan(&mut xref_entries, 1, xref_offset, 0);
bytes.extend_from_slice(
format!(
"12 0 obj\n<< /Type /XRef /Size 13 /Root 1 0 R /W [1 3 1] /Index [0 13] /Length {} >>\nstream\n",
xref_entries.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&xref_entries);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
bytes
}
#[test]
fn objstm_batches_preserve_cap_never_splits_source_container() {
let bytes = objstm_two_part4_members_pdf_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("fixture should parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let m10 = ObjectRef::new(10, 0);
let m11 = ObjectRef::new(11, 0);
let part4: BTreeSet<ObjectRef> = plan
.part4_other_pages_private
.iter()
.chain(&plan.part4_other_pages_shared)
.chain(&plan.part4_rest)
.copied()
.collect();
assert!(
part4.contains(&m10) && part4.contains(&m11),
"fixture invariant: 10 0 R and 11 0 R must both be Part-4"
);
let cap1 = PlannerConfig {
mode: crate::writer::object_streams::ObjectStreamMode::Preserve,
batch_size_cap: std::num::NonZeroUsize::new(1).unwrap(),
};
let bp1 = plan
.objstm_batches(&mut pdf, &cap1)
.expect("Preserve cap=1 must succeed");
let b10 = bp1.part4_batches.iter().position(|b| b.contains(&m10));
let b11 = bp1.part4_batches.iter().position(|b| b.contains(&m11));
assert!(
b10.is_some() && b11.is_some(),
"both members must be batched at cap=1; part4_batches={:?}",
bp1.part4_batches
);
assert_eq!(
b10, b11,
"cap=1 must not split 10 0 R and 11 0 R from their source ObjStm"
);
let cap2 = PlannerConfig {
mode: crate::writer::object_streams::ObjectStreamMode::Preserve,
batch_size_cap: std::num::NonZeroUsize::new(2).unwrap(),
};
let bp2 = plan
.objstm_batches(&mut pdf, &cap2)
.expect("Preserve cap=2 must succeed");
let same_batch = bp2
.part4_batches
.iter()
.any(|b| b.contains(&m10) && b.contains(&m11));
assert!(
same_batch,
"cap=2: 10 0 R and 11 0 R must share one batch; part4_batches={:?}",
bp2.part4_batches
);
assert_eq!(
bp1, bp2,
"Preserve source-container membership must be independent of planner cap"
);
}
#[test]
fn objstm_batches_generate_cross_part_placement() {
let bytes = two_page_shared_font_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &generate_config()).unwrap();
let all_part3_batched: std::collections::BTreeSet<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
let all_part4_batched: std::collections::BTreeSet<ObjectRef> = batch_plan
.part4_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
let part3_set: std::collections::BTreeSet<ObjectRef> =
plan.part3_objects.iter().copied().collect();
let pages_tree = plan
.pages_tree_ref
.expect("two-page fixture has a /Pages tree");
for r in &all_part3_batched {
assert!(
part3_set.contains(r) || *r == pages_tree,
"object {r} in part3_batches must be a Part-3 object or the folded /Pages tree"
);
}
assert!(
all_part3_batched.contains(&pages_tree),
"the /Pages tree ({pages_tree}) must be folded into the first-half batch"
);
let catalog = plan.root_ref.expect("fixture has a /Catalog");
for r in &all_part4_batched {
assert!(
!part3_set.contains(r),
"part3 object {r} must not appear in part4_batches"
);
assert_ne!(
*r, pages_tree,
"the /Pages tree must not remain in part4_batches"
);
assert_ne!(
*r, catalog,
"the /Catalog must stay standalone, not in part4_batches"
);
}
}
#[test]
fn objstm_batches_generate_keeps_catalog_standalone_single_page() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let batch_plan = plan.objstm_batches(&mut pdf, &generate_config()).unwrap();
assert!(
batch_plan.part3_batches.is_empty(),
"single-page document has no first-page shared objects (no Part-3 batch)"
);
let all_part3_batched: std::collections::BTreeSet<ObjectRef> = batch_plan
.part3_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
let all_part4_batched: std::collections::BTreeSet<ObjectRef> = batch_plan
.part4_batches
.iter()
.flat_map(|b| b.iter().copied())
.collect();
let catalog = plan.root_ref.expect("fixture has a /Catalog");
assert!(
!all_part3_batched.contains(&catalog) && !all_part4_batched.contains(&catalog),
"the /Catalog ({catalog}) must stay standalone (in no ObjStm batch), \
even when there is no first-half Part-3 batch"
);
let pages_tree = ObjectRef::new(2, 0);
assert!(
all_part4_batched.contains(&pages_tree),
"the /Pages tree (2 0 R) must remain in part4_batches when there is \
no first-half batch to fold it into"
);
}
#[test]
fn canonical_shared_hints_folds_members_and_unions_pages() {
let page = ObjectRef::new(3, 0);
let content = ObjectRef::new(9, 0);
let font_dict = ObjectRef::new(1, 0);
let font = ObjectRef::new(2, 0);
let plan = LinearizationPlan {
part2_objects: vec![page, content],
part3_objects: vec![font_dict, font],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: page,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: content,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: font_dict,
referencing_pages: vec![1],
},
SharedObjectHintEntry {
object_ref: font,
referencing_pages: vec![2],
},
],
..Default::default()
};
let mut m2c: BTreeMap<ObjectRef, (u32, u32)> = BTreeMap::new();
m2c.insert(font_dict, (12, 0));
m2c.insert(font, (12, 1));
let renumber = RenumberMap::from_plan(&plan);
let folded =
plan.canonical_shared_hints(&m2c, &renumber, &Default::default(), &Default::default());
assert_eq!(
folded.len(),
3,
"members must fold into one container entry"
);
assert_eq!(folded[0].object_ref, page);
assert_eq!(folded[1].object_ref, content);
assert_eq!(folded[2].object_ref, ObjectRef::new(12, u16::MAX));
assert_eq!(
folded[2].referencing_pages,
vec![1, 2],
"container entry must union both members' referencing pages"
);
}
#[test]
fn canonical_shared_hints_missing_renumber_entry_sorts_last_without_panic() {
let page = ObjectRef::new(3, 0);
let missing = ObjectRef::new(0, 0);
let font_dict = ObjectRef::new(1, 0);
let plan = LinearizationPlan {
part2_objects: vec![page, missing],
part3_objects: vec![font_dict],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: missing,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: page,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: font_dict,
referencing_pages: vec![1],
},
],
..Default::default()
};
let mut m2c: BTreeMap<ObjectRef, (u32, u32)> = BTreeMap::new();
m2c.insert(font_dict, (12, 0));
let mut renumber = RenumberMap::from_plan(&plan);
renumber.place_objstm_members_per_half(
&[],
&[vec![font_dict]],
&[],
&[],
&Default::default(),
&Default::default(),
);
assert!(
renumber.new_for_original(missing).is_none(),
"ObjStm relocation must drop object number 0 from the renumber map"
);
let folded =
plan.canonical_shared_hints(&m2c, &renumber, &Default::default(), &Default::default());
assert_eq!(folded.len(), 3);
assert_eq!(folded[0].object_ref, page);
assert_eq!(folded[1].object_ref, ObjectRef::new(12, u16::MAX));
assert_eq!(folded[2].object_ref, missing);
}
#[test]
fn canonical_shared_hints_empty_map_is_identity() {
let page = ObjectRef::new(3, 0);
let plan = LinearizationPlan {
part2_objects: vec![page],
shared_hints: vec![SharedObjectHintEntry {
object_ref: page,
referencing_pages: vec![],
}],
..Default::default()
};
let renumber = RenumberMap::from_plan(&plan);
let folded = plan.canonical_shared_hints(
&BTreeMap::new(),
&renumber,
&Default::default(),
&Default::default(),
);
assert_eq!(folded, plan.shared_hints);
}
#[test]
fn canonical_shared_hints_orders_first_page_and_keeps_part8_last() {
let page = ObjectRef::new(8, 0);
let content = ObjectRef::new(9, 0);
let image = ObjectRef::new(10, 0);
let font_dict = ObjectRef::new(1, 0);
let other_shared = ObjectRef::new(7, 0);
let plan = LinearizationPlan {
part2_objects: vec![page, content, image],
part3_objects: vec![font_dict],
part4_other_pages_shared: vec![other_shared],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: page,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: content,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: font_dict,
referencing_pages: vec![1],
},
SharedObjectHintEntry {
object_ref: image,
referencing_pages: vec![1],
},
SharedObjectHintEntry {
object_ref: other_shared,
referencing_pages: vec![2],
},
],
..Default::default()
};
let mut m2c: BTreeMap<ObjectRef, (u32, u32)> = BTreeMap::new();
m2c.insert(font_dict, (11, 0));
let renumber = RenumberMap::from_plan(&plan);
let folded =
plan.canonical_shared_hints(&m2c, &renumber, &Default::default(), &Default::default());
assert_eq!(folded.len(), 5, "only the eligible member folds");
assert_eq!(folded[0].object_ref, page);
assert_eq!(folded[1].object_ref, content);
assert_eq!(folded[2].object_ref, image);
assert_eq!(folded[3].object_ref, ObjectRef::new(11, u16::MAX));
assert_eq!(folded[4].object_ref, other_shared);
}
#[test]
fn canonical_shared_hints_skips_second_half_container_in_first_page_section() {
let page = ObjectRef::new(3, 0);
let content = ObjectRef::new(9, 0);
let font_dict = ObjectRef::new(1, 0);
let plan = LinearizationPlan {
part2_objects: vec![page, content],
part3_objects: vec![font_dict],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: page,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: content,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: font_dict,
referencing_pages: vec![1],
},
],
..Default::default()
};
let mut m2c: BTreeMap<ObjectRef, (u32, u32)> = BTreeMap::new();
m2c.insert(font_dict, (20, 0));
let mut second_half: BTreeSet<u32> = BTreeSet::new();
second_half.insert(20);
let renumber = RenumberMap::from_plan(&plan);
let folded =
plan.canonical_shared_hints(&m2c, &renumber, &second_half, &Default::default());
assert_eq!(
folded.len(),
2,
"second-half container must be excluded from first-page section"
);
assert_eq!(folded[0].object_ref, page);
assert_eq!(folded[1].object_ref, content);
assert!(
folded
.iter()
.all(|e| e.object_ref != ObjectRef::new(20, u16::MAX)),
"container 20 sentinel must not appear"
);
}
#[test]
fn canonical_shared_hints_skips_open_document_container_in_first_page_section() {
let page = ObjectRef::new(3, 0);
let content = ObjectRef::new(9, 0);
let font_dict = ObjectRef::new(1, 0);
let plan = LinearizationPlan {
part2_objects: vec![page, content],
part3_objects: vec![font_dict],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: page,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: content,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: font_dict,
referencing_pages: vec![1],
},
],
..Default::default()
};
let mut m2c: BTreeMap<ObjectRef, (u32, u32)> = BTreeMap::new();
m2c.insert(font_dict, (30, 0));
let mut open_doc: BTreeSet<u32> = BTreeSet::new();
open_doc.insert(30);
let renumber = RenumberMap::from_plan(&plan);
let folded = plan.canonical_shared_hints(&m2c, &renumber, &Default::default(), &open_doc);
assert_eq!(
folded.len(),
2,
"open-document container must be excluded from first-page section"
);
assert_eq!(folded[0].object_ref, page);
assert_eq!(folded[1].object_ref, content);
assert!(
folded
.iter()
.all(|e| e.object_ref != ObjectRef::new(30, u16::MAX)),
"container 30 sentinel must not appear"
);
}
#[test]
fn canonical_shared_hints_skips_part9_outline_container_in_part8_section() {
let fp_priv = ObjectRef::new(2, 0);
let outline = ObjectRef::new(6, 0);
let shared_a = ObjectRef::new(7, 0);
let shared_b = ObjectRef::new(8, 0);
let plan = LinearizationPlan {
part3_objects: vec![fp_priv],
part4_other_pages_shared: vec![shared_a, shared_b],
part9_outline_objects: vec![outline],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: fp_priv,
referencing_pages: vec![],
},
SharedObjectHintEntry {
object_ref: shared_a,
referencing_pages: vec![1],
},
SharedObjectHintEntry {
object_ref: shared_b,
referencing_pages: vec![2],
},
],
..Default::default()
};
let mut m2c: BTreeMap<ObjectRef, (u32, u32)> = BTreeMap::new();
m2c.insert(fp_priv, (20, 0));
m2c.insert(outline, (20, 1));
m2c.insert(shared_a, (20, 2));
m2c.insert(shared_b, (21, 0));
let mut second_half: BTreeSet<u32> = BTreeSet::new();
second_half.insert(20);
second_half.insert(21);
let renumber = RenumberMap::from_plan(&plan);
let folded =
plan.canonical_shared_hints(&m2c, &renumber, &second_half, &Default::default());
assert!(
folded
.iter()
.all(|e| e.object_ref != ObjectRef::new(20, u16::MAX)),
"part9 outline-routed container 20 must be skipped in the Part-8 section"
);
let b_entry = folded
.iter()
.find(|e| e.object_ref == ObjectRef::new(21, u16::MAX))
.expect("legitimate part8 container 21 must be kept");
assert_eq!(
b_entry.referencing_pages,
vec![2],
"part8 container 21 must keep its folded referencing page (not be \
dropped and re-added empty by a naive second_half-wide skip)"
);
}
#[test]
fn canonical_shared_hints_part9_container_not_re_added_by_part8_enumeration() {
let outline = ObjectRef::new(6, 0);
let shared_a = ObjectRef::new(7, 0);
let plan = LinearizationPlan {
part4_other_pages_shared: vec![shared_a],
part9_outline_objects: vec![outline],
shared_hints: vec![SharedObjectHintEntry {
object_ref: shared_a,
referencing_pages: vec![1, 2],
}],
..Default::default()
};
let mut m2c: BTreeMap<ObjectRef, (u32, u32)> = BTreeMap::new();
m2c.insert(outline, (20, 0));
m2c.insert(shared_a, (20, 1));
let mut second_half: BTreeSet<u32> = BTreeSet::new();
second_half.insert(20);
let renumber = RenumberMap::from_plan(&plan);
let folded =
plan.canonical_shared_hints(&m2c, &renumber, &second_half, &Default::default());
assert!(
plan.part8_container_nums(&m2c).contains(&20),
"precondition: part8_container_nums would otherwise re-add container 20"
);
assert!(
folded
.iter()
.all(|e| e.object_ref != ObjectRef::new(20, u16::MAX)),
"part9 container 20 (no first-page member) must not be re-added by the \
part8 enumeration tail"
);
}
fn assemble_classic_pdf(bodies: Vec<(u32, String)>, info_obj: u32, max_obj: u32) -> Vec<u8> {
let mut bodies = bodies;
bodies.sort_by_key(|(n, _)| *n);
let mut pdf: Vec<u8> = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n%\xe2\xe3\xcf\xd3\n");
let mut offsets: BTreeMap<u32, u64> = BTreeMap::new();
for (n, body) in &bodies {
offsets.insert(*n, pdf.len() as u64);
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = pdf.len() as u64;
let size = max_obj + 1;
let mut xref = format!("xref\n0 {size}\n0000000000 65535 f \n");
for n in 1..size {
xref.push_str(&format!("{:010} 00000 n \n", offsets[&n]));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root 1 0 R /Info {info_obj} 0 R >>\n\
startxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
pdf
}
fn mixed_shared_pdf_bytes(s: u32, p: u32) -> Vec<u8> {
let shared0 = 6u32;
let p1only0 = shared0 + s;
let c0 = p1only0 + p;
let c1 = c0 + 1;
let shared_res: String = (0..s)
.map(|i| format!("/S{} {} 0 R", i + 1, shared0 + i))
.collect::<Vec<_>>()
.join(" ");
let p1_extra: String = (0..p)
.map(|i| format!("/P{} {} 0 R", i + 1, p1only0 + i))
.collect::<Vec<_>>()
.join(" ");
let mut bodies: Vec<(u32, String)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()),
(2, "<< /Type /Pages /Count 2 /Kids [ 3 0 R 4 0 R ] >>".to_string()),
(5, "<< /Producer (flpdf-g6hb mixed fixture) >>".to_string()),
(3, format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << {shared_res} >> >> /Contents {c0} 0 R >>"
)),
(4, format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << {shared_res} {p1_extra} >> >> /Contents {c1} 0 R >>"
)),
];
for i in 0..s {
let n = shared0 + i;
bodies.push((
n,
format!(
"<< /Type /Font /Subtype /Type1 /BaseFont /S{} /Mark {n} >>",
i + 1
),
));
}
for i in 0..p {
let n = p1only0 + i;
bodies.push((
n,
format!(
"<< /Type /Font /Subtype /Type1 /BaseFont /P{} /Mark {n} >>",
i + 1
),
));
}
for (cnum, label) in [(c0, "Page0"), (c1, "Page1")] {
let stream = format!("BT /S1 12 Tf 72 720 Td ({label}) Tj ET");
bodies.push((
cnum,
format!(
"<< /Length {} >>\nstream\n{stream}\nendstream",
stream.len()
),
));
}
assemble_classic_pdf(bodies, 5, c1)
}
fn three_page_shared_pdf_bytes(p0: u32, g: u32) -> Vec<u8> {
let p0_0 = 7u32;
let g0 = p0_0 + p0;
let c0 = g0 + g;
let c1 = c0 + 1;
let c2 = c1 + 1;
let p0_res: String = (0..p0)
.map(|i| format!("/A{} {} 0 R", i + 1, p0_0 + i))
.collect::<Vec<_>>()
.join(" ");
let g_res: String = (0..g)
.map(|i| format!("/G{} {} 0 R", i + 1, g0 + i))
.collect::<Vec<_>>()
.join(" ");
let mut bodies: Vec<(u32, String)> = vec![
(1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()),
(2, "<< /Type /Pages /Count 3 /Kids [ 3 0 R 4 0 R 5 0 R ] >>".to_string()),
(6, "<< /Producer (flpdf-g6hb three-page shared fixture) >>".to_string()),
(3, format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << {p0_res} >> >> /Contents {c0} 0 R >>"
)),
(4, format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << {g_res} >> >> /Contents {c1} 0 R >>"
)),
(5, format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << {g_res} >> >> /Contents {c2} 0 R >>"
)),
];
for i in 0..p0 {
let n = p0_0 + i;
bodies.push((
n,
format!(
"<< /Type /Font /Subtype /Type1 /BaseFont /A{} /Mark {n} >>",
i + 1
),
));
}
for i in 0..g {
let n = g0 + i;
bodies.push((
n,
format!(
"<< /Type /Font /Subtype /Type1 /BaseFont /G{} /Mark {n} >>",
i + 1
),
));
}
for (cnum, label) in [(c0, "Page0"), (c1, "Page1"), (c2, "Page2")] {
let stream = format!("BT /A1 12 Tf 72 720 Td ({label}) Tj ET");
bodies.push((
cnum,
format!(
"<< /Length {} >>\nstream\n{stream}\nendstream",
stream.len()
),
));
}
assemble_classic_pdf(bodies, 6, c2)
}
#[test]
fn linearized_membership_even_splits_then_erases_page_dicts_and_root() {
let mut pdf = Pdf::open(Cursor::new(mixed_shared_pdf_bytes(60, 70))).unwrap();
let assigned = LinearizationPlan::from_pdf(&mut pdf, true)
.unwrap()
.renumber_assigned_refs();
let containers = objstm_membership_linearized(&mut pdf, &assigned).unwrap();
assert_eq!(
containers.len(),
2,
"135 eligible => 2 even-split containers"
);
assert_eq!(
containers[0].len(),
65,
"stream 0 loses Catalog+Page0+Page1"
);
assert_eq!(containers[1].len(), 67, "stream 1 untouched by the erasure");
let root = pdf.root_ref().unwrap();
let pages: BTreeSet<ObjectRef> = crate::pages::page_refs(&mut pdf)
.unwrap()
.into_iter()
.collect();
for c in &containers {
for m in c {
assert!(*m != root && !pages.contains(m), "{m:?} must be erased");
}
}
}
#[test]
fn linearized_routes_mixed_shared_first_page_then_other_page_private() {
let mut pdf = Pdf::open(Cursor::new(mixed_shared_pdf_bytes(60, 70))).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let assigned = plan.renumber_assigned_refs();
let containers = objstm_membership_linearized(&mut pdf, &assigned).unwrap();
let routes = route_with_plan(&plan, &containers);
assert_eq!(
routes,
vec![
ContainerPart::FirstPageShared,
ContainerPart::OtherPagePrivate
]
);
}
#[test]
fn linearized_routes_three_page_shared_first_page_then_other_page_shared() {
let mut pdf = Pdf::open(Cursor::new(three_page_shared_pdf_bytes(2, 120))).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let assigned = plan.renumber_assigned_refs();
let containers = objstm_membership_linearized(&mut pdf, &assigned).unwrap();
let routes = route_with_plan(&plan, &containers);
assert_eq!(
routes,
vec![
ContainerPart::FirstPageShared,
ContainerPart::OtherPageShared
]
);
}
#[test]
fn route_objstm_containers_distinguishes_first_page_private_and_shared() {
let mut pdf = Pdf::open(Cursor::new(thumb_first_page_shared_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let routes = route_with_plan(
&plan,
&[vec![ObjectRef::new(6, 0)], vec![ObjectRef::new(5, 0)]],
);
assert_eq!(
routes,
vec![
ContainerPart::FirstPagePrivate,
ContainerPart::FirstPageShared,
]
);
}
#[test]
fn from_pdf_retains_routing_users_consistent_with_page_map() {
let mut pdf = Pdf::open(Cursor::new(thumb_first_page_shared_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let users = plan
.routing_users
.as_ref()
.expect("from_pdf must retain object-user routing data");
let page_zero: BTreeSet<ObjectRef> = plan
.all_referenced_pages
.iter()
.filter_map(|(&object_ref, pages)| pages.contains(&0).then_some(object_ref))
.collect();
assert_eq!(users.first_page, page_zero);
assert!(
users.thumbnails.contains(&ObjectRef::new(5, 0)),
"the fixture's /Thumb target must retain a thumbnail user"
);
assert!(
users.first_page.contains(&ObjectRef::new(6, 0)),
"the fixture's first-page-private object must retain page 0"
);
}
#[test]
fn route_objstm_containers_keeps_same_page_self_thumb_private() {
let mut pdf = Pdf::open(Cursor::new(self_thumb_first_page_private_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let routes = route_with_plan(&plan, &[vec![ObjectRef::new(5, 0)]]);
assert_eq!(routes, vec![ContainerPart::FirstPagePrivate]);
}
#[test]
fn route_objstm_containers_follows_direct_thumb_descendants() {
let mut pdf = Pdf::open(Cursor::new(
direct_thumb_descendant_first_page_shared_pdf_bytes(),
))
.unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let routes = route_with_plan(&plan, &[vec![ObjectRef::new(5, 0)]]);
assert_eq!(routes, vec![ContainerPart::FirstPageShared]);
}
#[test]
fn route_objstm_containers_honors_thumb_first_edge_wins() {
let mut pdf = Pdf::open(Cursor::new(
thumb_before_ordinary_first_edge_wins_pdf_bytes(),
))
.unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let routes = route_with_plan(&plan, &[vec![ObjectRef::new(5, 0)]]);
assert_eq!(routes, vec![ContainerPart::Rest]);
}
#[test]
fn route_objstm_containers_demotes_one_other_page_plus_thumbnail_to_rest() {
let mut pdf =
Pdf::open(Cursor::new(one_other_page_plus_thumbnail_user_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let routes = route_with_plan(&plan, &[vec![ObjectRef::new(6, 0)]]);
assert_eq!(
routes,
vec![ContainerPart::Rest],
"one non-first page user plus one thumbnail user is qpdf Part 9"
);
}
#[test]
fn linearized_routes_trailer_only_container_to_rest() {
let mut pdf = Pdf::open(Cursor::new(mixed_shared_pdf_bytes(60, 70))).unwrap();
let info_ref = pdf.trailer().get_ref("Info").unwrap();
let synthetic = vec![vec![info_ref]];
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let routes = route_with_plan(&plan, &synthetic);
assert_eq!(routes, vec![ContainerPart::Rest]);
}
fn one_other_page_plus_thumbnail_user_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offsets = [0u64; 7];
let mut push = |number: usize, body: &[u8]| {
offsets[number] = pdf.len() as u64;
pdf.extend_from_slice(format!("{number} 0 obj\n").as_bytes());
pdf.extend_from_slice(body);
pdf.extend_from_slice(b"\nendobj\n");
};
push(1, b"<< /Type /Catalog /Pages 2 0 R >>");
push(2, b"<< /Type /Pages /Count 3 /Kids [3 0 R 4 0 R 5 0 R] >>");
push(
3,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
push(
4,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Font << /F1 6 0 R >> >> >>",
);
push(
5,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Thumb << /Image 6 0 R >> >>",
);
push(6, b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
for offset in offsets.iter().skip(1) {
pdf.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn two_page_otherpage_others_and_private_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0u64; 9];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &[u8]| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n").as_bytes());
pdf.extend_from_slice(body);
pdf.extend_from_slice(b"\nendobj\n");
};
push(
&mut pdf,
1,
b"<< /Type /Catalog /Pages 2 0 R /Ref2 6 0 R >>",
);
push(
&mut pdf,
2,
b"<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>",
);
push(
&mut pdf,
3,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 7 0 R >>",
);
push(&mut pdf, 4, b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /FA 5 0 R /FB 6 0 R >> >> /Contents 8 0 R >>");
push(
&mut pdf,
5,
b"<< /Type /Font /Subtype /Type1 /BaseFont /Courier /Name /FA >>",
);
push(
&mut pdf,
6,
b"<< /Type /Font /Subtype /Type1 /BaseFont /Times-Roman /Name /FB >>",
);
push(&mut pdf, 7, b"<< /Length 5 >>\nstream\nBT ET\nendstream");
push(&mut pdf, 8, b"<< /Length 5 >>\nstream\nBT ET\nendstream");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 9\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 9 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn generate_route_others_gate_demotes_other_page_container_to_rest() {
let mut pdf =
Pdf::open(Cursor::new(two_page_otherpage_others_and_private_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let fa = ObjectRef::new(5, 0); let fb = ObjectRef::new(6, 0);
let routes = route_with_plan(&plan, &[vec![fa]]);
assert_eq!(
routes,
vec![ContainerPart::OtherPagePrivate],
"others==0 other-page container is lc_other_page_private (part7)"
);
let routes = route_with_plan(&plan, &[vec![fb], vec![fa, fb]]);
assert_eq!(
routes,
vec![ContainerPart::Rest, ContainerPart::Rest],
"any document-`others` member (Catalog /Ref2) demotes part7 to part9"
);
let assigned = plan.renumber_assigned_refs();
let containers = objstm_membership_linearized(&mut pdf, &assigned).unwrap();
assert_eq!(
containers.len(),
1,
"3 eligible => a single even-split container"
);
let routes = route_with_plan(&plan, &containers);
assert_eq!(
routes,
vec![ContainerPart::Rest],
"the {{Pages, FA, FB}} container is lc_other (part9); containers={containers:?}"
);
}
fn open_action_page_dest_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n");
let mut offs = [0u64; 7];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(
&mut pdf,
1,
"<< /Type /Catalog /OpenAction 5 0 R /Pages 2 0 R >>",
);
push(&mut pdf, 2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>");
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
push(&mut pdf, 4, "<< /A 6 0 R /B 6 0 R >>");
push(
&mut pdf,
5,
"<< /Type /Action /S /GoTo /D [3 0 R /Fit] /Next 4 0 R >>",
);
push(&mut pdf, 6, "<< /Leaf true >>");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 7\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn open_document_set_stops_at_page_and_dedups() {
let mut pdf = Pdf::open(Cursor::new(open_action_page_dest_pdf_bytes())).unwrap();
let set = open_document_set(&mut pdf).unwrap();
let r = |n: u32| ObjectRef::new(n, 0);
assert_eq!(
set,
[r(4), r(5), r(6)].into_iter().collect::<BTreeSet<_>>(),
"open-document set = {{action, /Next dict, leaf}}; page leaf dropped"
);
}
fn document_other_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n");
let mut offs = [0u64; 14];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(
&mut pdf,
1,
"<< /Type /Catalog /Pages 2 0 R /Outlines 7 0 R /OpenAction 8 0 R \
/Names 4 0 R /Custom 5 0 R /Fake 12 0 R >>",
);
push(
&mut pdf,
2,
"<< /Type /Pages /Kids [3 0 R] /Count 1 /Resources << /Inh 10 0 R >> /Ext 11 0 R >>",
);
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
push(&mut pdf, 4, "<< /X 6 0 R >>"); push(&mut pdf, 5, "<< /A 6 0 R /B 6 0 R >>"); push(&mut pdf, 6, "<< /Leaf true >>");
push(&mut pdf, 7, "<< /Type /Outlines >>"); push(&mut pdf, 8, "<< /Type /Action /S /GoTo /D [3 0 R /Fit] >>"); push(&mut pdf, 9, "<< /Producer (x) >>"); push(&mut pdf, 10, "<< /InheritedResource true >>"); push(&mut pdf, 11, "<< /CustomExtension true >>"); push(
&mut pdf,
12,
"<< /Type /Pages /Resources << /FakeRes 13 0 R >> >>",
);
push(&mut pdf, 13, "<< /NotStripped true >>");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 14\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!(
"trailer\n<< /Size 14 /Root 1 0 R /Info 9 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
pdf
}
#[test]
fn document_other_set_excludes_doc_keys_and_stops_at_page() {
let mut pdf = Pdf::open(Cursor::new(document_other_pdf_bytes())).unwrap();
let set = document_other_set(&mut pdf).unwrap();
let r = |n: u32| ObjectRef::new(n, 0);
assert_eq!(
set,
[r(2), r(4), r(5), r(6), r(9), r(11), r(12), r(13)]
.into_iter()
.collect::<BTreeSet<_>>(),
"others = {{/Names, /Custom, /Info, page-tree node + custom /Ext, \
out-of-tree /Pages + its /Resources}}; inherited /Resources (10), \
page leaf (3), and doc keys excluded"
);
}
fn outlines_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n");
let mut offs = [0u64; 7];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(
&mut pdf,
1,
"<< /Type /Catalog /Outlines 5 0 R /Pages 2 0 R >>",
);
push(&mut pdf, 2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>");
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
push(&mut pdf, 4, "<< /Unused true >>");
push(
&mut pdf,
5,
"<< /Type /Outlines /First 6 0 R /Last 6 0 R /Count 1 >>",
);
push(&mut pdf, 6, "<< /Title (Item) /Parent 5 0 R >>");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 7\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn outlines_set_collects_outline_tree_and_excludes_pages() {
let mut pdf = Pdf::open(Cursor::new(outlines_pdf_bytes())).unwrap();
let set = outlines_set(&mut pdf).unwrap();
let r = |n: u32| ObjectRef::new(n, 0);
assert_eq!(
set,
[r(5), r(6)].into_iter().collect::<BTreeSet<_>>(),
"outlines set = {{outline dict, item}}; pages tree excluded"
);
}
#[test]
fn outlines_set_empty_when_no_outlines() {
let mut pdf = Pdf::open(Cursor::new(two_page_shared_font_bytes())).unwrap();
assert!(outlines_set(&mut pdf).unwrap().is_empty());
}
#[test]
fn outlines_set_empty_for_non_dictionary_catalog() {
let mut pdf = Pdf::open(Cursor::new(non_dictionary_root_pdf_bytes())).unwrap();
assert!(outlines_set(&mut pdf).unwrap().is_empty());
}
fn outlines_pdf_bytes_with_page_mode(mode: &[u8]) -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n");
let mut offs = [0u64; 7];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &[u8]| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n").as_bytes());
pdf.extend_from_slice(body);
pdf.extend_from_slice(b"\nendobj\n");
};
let catalog = format!(
"<< /Type /Catalog /PageMode /{} /Outlines 5 0 R /Pages 2 0 R >>",
std::str::from_utf8(mode).unwrap()
);
push(&mut pdf, 1, catalog.as_bytes());
push(&mut pdf, 2, b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>");
push(
&mut pdf,
3,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
push(&mut pdf, 4, b"<< /Unused true >>");
push(
&mut pdf,
5,
b"<< /Type /Outlines /First 6 0 R /Last 6 0 R /Count 1 >>",
);
push(&mut pdf, 6, b"<< /Title (Item) /Parent 5 0 R >>");
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 7\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn outlines_in_first_page_predicate_true_when_use_outlines_and_outlines_present() {
let mut pdf = Pdf::open(Cursor::new(outlines_pdf_bytes_with_page_mode(
b"UseOutlines",
)))
.unwrap();
assert!(
outlines_in_first_page_predicate(&mut pdf).unwrap(),
"/PageMode /UseOutlines + /Outlines => predicate must be true"
);
}
#[test]
fn outlines_in_first_page_predicate_false_without_page_mode() {
let mut pdf = Pdf::open(Cursor::new(outlines_pdf_bytes())).unwrap();
assert!(
!outlines_in_first_page_predicate(&mut pdf).unwrap(),
"/Outlines with no /PageMode => predicate must be false"
);
}
#[test]
fn outlines_in_first_page_predicate_false_when_page_mode_not_use_outlines() {
let mut pdf = Pdf::open(Cursor::new(outlines_pdf_bytes_with_page_mode(
b"FullScreen",
)))
.unwrap();
assert!(
!outlines_in_first_page_predicate(&mut pdf).unwrap(),
"/PageMode /FullScreen (not UseOutlines) => predicate must be false"
);
}
#[test]
fn outlines_in_first_page_predicate_false_when_no_outlines() {
let mut pdf = Pdf::open(Cursor::new(two_page_shared_font_bytes())).unwrap();
assert!(
!outlines_in_first_page_predicate(&mut pdf).unwrap(),
"catalog without /Outlines => predicate must be false"
);
}
#[test]
fn linearized_routes_open_document_container_before_page_categories() {
let mut pdf = Pdf::open(Cursor::new(open_action_page_dest_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let synthetic = vec![vec![ObjectRef::new(3, 0), ObjectRef::new(5, 0)]];
let routes = route_with_plan(&plan, &synthetic);
assert_eq!(routes, vec![ContainerPart::OpenDocument]);
}
#[test]
fn route_objstm_containers_outlines_first_page_routes_to_first_page() {
let mut pdf = Pdf::open(Cursor::new(outlines_pdf_bytes_with_page_mode(
b"UseOutlines",
)))
.unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let outline_ref = ObjectRef::new(5, 0); let synthetic = vec![vec![outline_ref]];
let routes = route_with_plan(&plan, &synthetic);
assert_eq!(
routes,
vec![ContainerPart::FirstPageOutlines],
"outline container must route to FirstPageOutlines when /PageMode /UseOutlines"
);
}
#[test]
fn route_objstm_containers_outlines_no_use_outlines_routes_to_rest() {
let mut pdf = Pdf::open(Cursor::new(outlines_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let outline_ref = ObjectRef::new(5, 0); let synthetic = vec![vec![outline_ref]];
let routes = route_with_plan(&plan, &synthetic);
assert_eq!(
routes,
vec![ContainerPart::Rest],
"outline container must route to Rest when no /PageMode /UseOutlines"
);
}
fn non_dictionary_root_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n");
let mut offs = [0u64; 4];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(&mut pdf, 1, "42"); push(&mut pdf, 2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>");
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 4\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn open_document_set_empty_for_non_dictionary_catalog() {
let mut pdf = Pdf::open(Cursor::new(non_dictionary_root_pdf_bytes())).unwrap();
let set = open_document_set(&mut pdf).unwrap();
assert!(
set.is_empty(),
"a non-dictionary catalog must yield no open-document objects, got {set:?}"
);
}
#[test]
fn document_other_set_empty_for_non_dictionary_catalog() {
let mut pdf = Pdf::open(Cursor::new(non_dictionary_root_pdf_bytes())).unwrap();
let set = document_other_set(&mut pdf).unwrap();
assert!(
set.is_empty(),
"a non-dictionary catalog must yield no document-other objects, got {set:?}"
);
}
fn nested_page_tree_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n");
let mut offs = [0u64; 6];
let mut push = |pdf: &mut Vec<u8>, n: usize, body: &str| {
offs[n] = pdf.len() as u64;
pdf.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
};
push(&mut pdf, 1, "<< /Type /Catalog /Pages 2 0 R >>");
push(
&mut pdf,
2,
"<< /Type /Pages /Kids [3 0 R 4 0 R 4 0 R 5 0 R] /Count 1 >>",
);
push(
&mut pdf,
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>",
);
push(&mut pdf, 4, "<< /Type /Pages /Parent 2 0 R /Count 0 >>"); push(&mut pdf, 5, "42"); let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 6\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn page_tree_node_refs_collects_interior_pages_only() {
let mut pdf = Pdf::open(Cursor::new(nested_page_tree_pdf_bytes())).unwrap();
let set = page_tree_node_refs(&mut pdf).unwrap();
let r = |n: u32| ObjectRef::new(n, 0);
assert_eq!(
set,
[r(2), r(4)].into_iter().collect::<BTreeSet<_>>(),
"page tree = interior /Pages nodes only (leaf + non-dict kid excluded)"
);
}
#[test]
fn page_tree_node_refs_empty_for_non_dictionary_catalog() {
let mut pdf = Pdf::open(Cursor::new(non_dictionary_root_pdf_bytes())).unwrap();
assert!(page_tree_node_refs(&mut pdf).unwrap().is_empty());
}
fn od_indirect_length_pdf_bytes() -> Vec<u8> {
let bodies: &[(u32, &[u8])] = &[
(1, b"<< /Type /Catalog /Pages 2 0 R /OpenAction 5 0 R >>"),
(2, b"<< /Type /Pages /Count 1 /Kids [ 3 0 R ] >>"),
(
3,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>",
),
(4, b"<< /Length 5 >>\nstream\nBT ET\nendstream"),
(5, b"<< /Type /Action /S /JavaScript /JS 6 0 R >>"),
(
6,
b"<< /Length 7 0 R >>\nstream\napp.alert('hi');\nendstream",
),
(7, b"16"),
];
let mut out: Vec<u8> = b"%PDF-1.7\n%\xe2\xe3\xcf\xd3\n".to_vec();
let total = bodies.len() as u32 + 1;
let mut offsets = vec![0usize; total as usize];
for (num, body) in bodies {
offsets[*num as usize] = out.len();
out.extend_from_slice(format!("{num} 0 obj\n").as_bytes());
out.extend_from_slice(body);
out.extend_from_slice(b"\nendobj\n");
}
let xref_start = out.len();
out.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for off in offsets.iter().skip(1) {
out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
out.extend_from_slice(format!("trailer\n<< /Size {total} /Root 1 0 R >>\n").as_bytes());
out.extend_from_slice(format!("startxref\n{xref_start}\n%%EOF\n").as_bytes());
out
}
#[test]
fn generate_plan_drops_orphan_indirect_length_holder_and_writes() {
let bytes = od_indirect_length_pdf_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes.clone())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
assert!(
!plan.all_assigned_refs().contains(&ObjectRef::new(7, 0)),
"orphaned /Length holder must not be assigned to any linearization part"
);
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = Pdf::open(Cursor::new(bytes)).unwrap();
let opts = crate::WriteOptions {
object_streams: crate::ObjectStreamMode::Generate,
deterministic_id: true,
newline_before_endstream: crate::NewlineBeforeEndstream::Never,
..Default::default()
};
let mut doc =
crate::linearization::writer::write_linearized(&plan, &renumber, &mut pdf2, &opts)
.expect("linearized write must succeed with the orphan holder dropped");
doc.back_patch().expect("back-patch must succeed");
let out = doc.bytes;
assert!(
!out.windows(b"/Length 7 0 R".len())
.any(|w| w == b"/Length 7 0 R"),
"the OD stream's /Length must be direct-ized, not left as an indirect ref"
);
}
fn page2_contents_indirect_length_pdf_bytes() -> Vec<u8> {
let bodies: &[(u32, &[u8])] = &[
(1, b"<< /Type /Catalog /Pages 2 0 R >>"),
(2, b"<< /Type /Pages /Count 2 /Kids [ 3 0 R 4 0 R ] >>"),
(
3,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 5 0 R /Resources << >> >>",
),
(
4,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 6 0 R /Resources << >> >>",
),
(5, b"<< /Length 5 >>\nstream\nBT ET\nendstream"),
(6, b"<< /Length 7 0 R >>\nstream\nBT ET\nendstream"),
(7, b"5"),
];
let mut out: Vec<u8> = b"%PDF-1.7\n%\xe2\xe3\xcf\xd3\n".to_vec();
let total = bodies.len() as u32 + 1;
let mut offsets = vec![0usize; total as usize];
for (num, body) in bodies {
offsets[*num as usize] = out.len();
out.extend_from_slice(format!("{num} 0 obj\n").as_bytes());
out.extend_from_slice(body);
out.extend_from_slice(b"\nendobj\n");
}
let xref_start = out.len();
out.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for off in offsets.iter().skip(1) {
out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
out.extend_from_slice(format!("trailer\n<< /Size {total} /Root 1 0 R >>\n").as_bytes());
out.extend_from_slice(format!("startxref\n{xref_start}\n%%EOF\n").as_bytes());
out
}
#[test]
fn generate_plan_drops_orphan_length_holder_reached_via_later_page_closure() {
let mut pdf = Pdf::open(Cursor::new(page2_contents_indirect_length_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
assert!(
!plan.all_assigned_refs().contains(&ObjectRef::new(7, 0)),
"a page-reachable orphaned /Length holder must not be assigned to any part"
);
}
#[test]
fn non_generate_plan_also_drops_orphan_indirect_length_holder() {
let mut pdf = Pdf::open(Cursor::new(od_indirect_length_pdf_bytes())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
assert!(
!plan.all_assigned_refs().contains(&ObjectRef::new(7, 0)),
"orphaned /Length holder must be dropped in non-generate mode too"
);
}
fn missing_trailer_info_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 = format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 100 /Root 1 0 R /Info 99 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn info_and_missing_junk_pdf_bytes(n: u32) -> Vec<u8> {
let mut junk = String::new();
for i in 0..n {
junk.push_str(&format!("/J{i} {} 0 R ", 10 + i));
}
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 off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Producer (flpdf-test) >>\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 110 /Root 1 0 R /Info 4 0 R {junk}>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn write_linearized_generate(bytes: &[u8]) -> Vec<u8> {
let mut pdf = Pdf::open(Cursor::new(bytes.to_vec())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let renumber = RenumberMap::from_plan(&plan);
let opts = crate::WriteOptions {
object_streams: crate::ObjectStreamMode::Generate,
deterministic_id: true,
newline_before_endstream: crate::NewlineBeforeEndstream::Never,
..Default::default()
};
let mut doc =
crate::linearization::writer::write_linearized(&plan, &renumber, &mut pdf, &opts)
.expect("linearized generate write must not panic on unplanned refs");
doc.back_patch().expect("back-patch must succeed");
doc.bytes
}
#[test]
fn objstm_batches_generate_drops_missing_trailer_only_ref() {
let bytes = missing_trailer_info_pdf_bytes();
let mut pdf = Pdf::open(Cursor::new(bytes.clone())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, true).unwrap();
let missing = ObjectRef::new(99, 0);
assert!(
!plan.renumber_assigned_refs().contains(&missing),
"missing /Info 99 0 R must not receive a renumber slot"
);
let batch_plan = plan.objstm_batches(&mut pdf, &generate_config()).unwrap();
assert!(
!batch_plan
.open_document_batches
.iter()
.chain(&batch_plan.part3_batches)
.map(Vec::as_slice)
.chain(
batch_plan
.part4_batches
.iter()
.map(|batch| batch.members.as_slice()),
)
.any(|batch| batch.contains(&missing)),
"missing /Info 99 0 R must not be batched into a generated ObjStm"
);
write_linearized_generate(&bytes);
}
#[test]
fn objstm_membership_keeps_real_members_together_despite_missing_refs() {
let mut pdf = Pdf::open(Cursor::new(info_and_missing_junk_pdf_bytes(100))).unwrap();
let assigned = LinearizationPlan::from_pdf(&mut pdf, true)
.unwrap()
.renumber_assigned_refs();
let containers = objstm_membership_linearized(&mut pdf, &assigned).unwrap();
let info = ObjectRef::new(4, 0);
let pages = ObjectRef::new(2, 0);
assert_eq!(
containers.len(),
1,
"missing /Junk refs must not split the two real members across containers"
);
let members = &containers[0];
assert!(
members.contains(&info) && members.contains(&pages),
"the single container must hold both real members (/Info + /Pages)"
);
assert!(
!members.iter().any(|r| (10..110).contains(&r.number)),
"no missing /Junk ref may survive into membership"
);
}
}