use std::collections::{BTreeSet, HashSet};
use std::io::{Read, Seek};
use crate::object_handle::{ObjectHandle, ObjectHandleIdentity};
use crate::qpdf_obj_gen::QpdfObjGen;
use crate::ObjectRef;
use crate::{Error, Pdf, QpdfErrorCode, QpdfExc, Result};
#[derive(Debug, Clone)]
pub struct PreparedPages {
pub root: PageTreeRoot,
pub pages: Vec<ObjectHandle>,
}
#[derive(Debug, Clone)]
pub enum PageTreeRoot {
Indirect(ObjectHandle),
Direct {
catalog: ObjectHandle,
},
DirectCatalog,
}
pub fn prepare_for_optimization<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<Option<PreparedPages>> {
prepare_for_optimization_canonical(pdf, None)
}
pub(crate) fn prepare_for_optimization_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: usize,
) -> Result<Option<PreparedPages>> {
prepare_for_optimization_canonical(pdf, Some(max_depth))
}
fn prepare_for_optimization_canonical<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: Option<usize>,
) -> Result<Option<PreparedPages>> {
if max_depth.is_none() {
if let Some(cached) = pdf.cached_page_list() {
pdf.mark_get_all_pages_called();
return Ok(Some(cached));
}
} else {
pdf.invalidate_page_list_cache();
}
pdf.mark_get_all_pages_called();
let root_candidate = pdf.trailer_key_handle(b"Root");
if root_candidate.try_is_null()? {
return Ok(None);
}
root_candidate.try_dereference()?;
if !root_candidate.try_is_dictionary()? {
return Ok(None);
}
let catalog = root_candidate;
let mut pages = catalog.try_get_key(b"/Pages")?;
let mut seen_parent: BTreeSet<QpdfObjGen> = BTreeSet::new();
#[allow(
clippy::mutable_key_type,
reason = "identity key compares only Rc pointer identity and retains the slot deliberately"
)]
let mut seen_parent_direct: HashSet<ObjectHandleIdentity> = HashSet::new();
let mut changed_pages = false;
let mut warned = false;
loop {
let repeated = if let Some(object_gen) = pages
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
!seen_parent.insert(object_gen)
} else {
!seen_parent_direct.insert(pages.identity_key())
};
if repeated {
break;
}
if !pages.try_is_dictionary()? {
break;
}
if !pages.try_has_key(b"/Parent")? {
break;
}
let parent = pages.try_get_key(b"/Parent")?;
if parent.try_is_null()? {
break; }
if !warned {
catalog.warn_if_possible(
"document page tree root (root -> /Pages) doesn't point to the root of the page tree; attempting to correct",
)?; warned = true;
}
pages = parent;
changed_pages = true;
}
if changed_pages {
catalog.replace_key(b"/Pages", pages.clone())?;
}
let has_kids = pages.try_has_key(b"/Kids")?;
if !pages.try_is_dictionary()? {
return Ok(None);
}
let mut state = CanonicalRepairState {
seen: BTreeSet::new(),
visited: BTreeSet::new(),
visited_direct: HashSet::new(),
pages: Vec::new(),
};
if has_kids {
repair_page_tree_handle(pdf, pages.clone(), &mut state, 0, false, max_depth)?;
}
let root = match pages
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
Some(_) => PageTreeRoot::Indirect(pages.clone()),
None if catalog.is_indirect() => PageTreeRoot::Direct {
catalog: catalog.clone(),
},
None => PageTreeRoot::DirectCatalog,
};
let prepared = PreparedPages {
root,
pages: state.pages,
};
if max_depth.is_none() {
pdf.cache_page_list(&prepared);
}
Ok(Some(prepared))
}
struct CanonicalRepairState {
seen: BTreeSet<QpdfObjGen>,
visited: BTreeSet<QpdfObjGen>,
visited_direct: HashSet<ObjectHandleIdentity>,
pages: Vec<ObjectHandle>,
}
struct RepairFrame {
node: ObjectHandle,
kids: ObjectHandle,
next_kid: usize,
kid_count: usize,
depth: usize,
inherited_media_box: bool,
}
fn repair_page_tree_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: ObjectHandle,
state: &mut CanonicalRepairState,
depth: usize,
inherited_media_box: bool,
max_depth: Option<usize>,
) -> Result<()> {
let Some(frame) =
repair_page_tree_frame(pdf, node, state, depth, inherited_media_box, max_depth)?
else {
return Ok(());
};
let mut frames = vec![frame];
while let Some(frame) = frames.last_mut() {
if frame.next_kid >= frame.kid_count {
frames.pop();
continue;
}
let index = frame.next_kid;
frame.next_kid += 1;
let parent = frame.node.clone();
let kids = frame.kids.clone();
let frame_depth = frame.depth;
let media_box = frame.inherited_media_box;
let Some(mut kid) = kids.try_array_item(index)? else {
continue;
};
if kid.try_has_key(b"/Kids")? {
if let Some(child) =
repair_page_tree_frame(pdf, kid, state, frame_depth + 1, media_box, max_depth)?
{
frames.push(child);
}
continue;
}
if !media_box && !is_rectangle_handle(&kid.try_get_key(b"/MediaBox")?)? {
kid.warn_if_possible(
format!("kid {index} (from 0) MediaBox is undefined; setting to letter / ANSI A")
.as_str(),
)?; replace_handle_key(
&kid,
b"/MediaBox",
ObjectHandle::array(vec![
ObjectHandle::integer(0),
ObjectHandle::integer(0),
ObjectHandle::integer(612),
ObjectHandle::integer(792),
]),
)?; }
if kid.is_direct() {
parent.warn_if_possible(
format!("kid {index} (from 0) is direct; converting to indirect").as_str(),
)?; kid = promote_page_handle(pdf, kid)?;
let promoted_object_gen = kid
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| {
Error::Internal("promoted page lost its indirect identity".to_owned())
})?;
state.seen.insert(promoted_object_gen);
kids.set_array_item(index, kid.clone())?;
} else if let Some(object_gen) = kid
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
if !state.seen.insert(object_gen) {
parent.warn_if_possible(
format!(
"kid {index} (from 0) appears more than once in the pages tree; creating a new page object as a copy"
)
.as_str(),
)?; let copied = kid.shallow_copy()?;
kid = promote_page_handle(pdf, copied)?;
let copied_object_gen = kid
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| {
Error::Internal("copied page lost its indirect identity".to_owned())
})?;
state.seen.insert(copied_object_gen);
kids.set_array_item(index, kid.clone())?;
}
}
if !kid.try_is_dictionary_of_type(b"Page", b"")? {
kid.warn_if_possible("/Type key should be /Page but is not; overriding")?;
replace_handle_key(&kid, b"/Type", ObjectHandle::name(b"Page".to_vec()))?;
}
let page_object_gen = kid
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect());
page_object_gen.ok_or_else(|| {
Error::Internal("page-tree leaf lost its indirect identity".to_owned())
})?;
state.pages.push(kid.clone());
}
Ok(())
}
fn repair_page_tree_frame<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: ObjectHandle,
state: &mut CanonicalRepairState,
depth: usize,
inherited_media_box: bool,
max_depth: Option<usize>,
) -> Result<Option<RepairFrame>> {
if max_depth.is_some_and(|max_depth| depth >= max_depth) {
let location = node
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.map_or_else(
|| "direct /Pages node".to_owned(),
|object_gen| format!("{} {}", object_gen.get_obj(), object_gen.get_gen()),
);
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {} at {location}",
max_depth.expect("checked above")
)));
}
if let Some(object_gen) = node
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
if !state.visited.insert(object_gen) {
return Err(page_tree_cycle_error(pdf));
}
} else if !state.visited_direct.insert(node.identity_key()) {
return Err(page_tree_cycle_error(pdf)); }
node.try_dereference()?;
if !node.try_is_dictionary()? || !node.try_has_key(b"/Kids")? {
return Ok(None); }
if !node.try_is_dictionary_of_type(b"Pages", b"")? {
node.warn_if_possible("/Type key should be /Pages but is not; overriding")?;
replace_handle_key(&node, b"/Type", ObjectHandle::name(b"Pages".to_vec()))?;
}
let media_box = if inherited_media_box {
true
} else {
is_rectangle_handle(&node.try_get_key(b"/MediaBox")?)?
};
let kids = node.try_get_key(b"/Kids")?;
let Some(kid_count) = kids.try_array_len()? else {
let type_name = kids.type_name()?;
kids.warn_if_possible(
format!(
"operation for array attempted on object of type {}: treating as empty",
type_name
)
.as_str(),
)?; return Ok(None);
};
Ok(Some(RepairFrame {
node,
kids,
next_kid: 0,
kid_count,
depth,
inherited_media_box: media_box,
}))
}
pub(crate) fn page_tree_cycle_error<R: Read + Seek>(pdf: &Pdf<R>) -> Error {
Error::QpdfExc(QpdfExc::new(
QpdfErrorCode::Pages,
pdf.input_source_description(),
pdf.resolver.last_object_description(),
0,
b"Loop detected in /Pages structure (getAllPages)",
))
}
fn promote_page_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: ObjectHandle,
) -> Result<ObjectHandle> {
let promoted = pdf.make_indirect_from_object_handle(handle)?;
Ok(promoted)
}
pub(crate) fn page_ref_from_handle(handle: &ObjectHandle) -> Result<ObjectRef> {
let object_gen = handle
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| Error::Unsupported("page handle has no indirect identity".to_owned()))?;
object_gen.to_object_ref().ok_or_else(|| {
Error::Unsupported(format!(
"page object {} {} cannot be represented as a valid ObjectRef",
object_gen.get_obj(),
object_gen.get_gen()
))
})
}
impl PreparedPages {
pub(crate) fn page_refs(self) -> Result<Vec<ObjectRef>> {
self.pages.iter().map(page_ref_from_handle).collect()
}
}
fn replace_handle_key(holder: &ObjectHandle, key: &[u8], value: ObjectHandle) -> Result<()> {
holder.replace_key(key, value)?;
Ok(())
}
fn is_rectangle_handle(value: &ObjectHandle) -> Result<bool> {
let Some(length) = value.try_array_len()? else {
return Ok(false);
};
if length != 4 {
return Ok(false);
}
for index in 0..length {
let Some(item) = value.try_array_item(index)? else {
return Ok(false);
};
if item.try_as_integer()?.is_none() {
item.try_dereference()?;
if item.as_real().is_none() {
return Ok(false);
}
}
}
Ok(true)
}
#[cfg(test)]
mod tests {
use super::prepare_for_optimization;
use super::prepare_for_optimization_with_max_depth;
use crate::object_handle::ObjectValue;
use crate::{ObjectHandle, Pdf};
use std::io::Cursor;
#[test]
fn direct_pages_root_depth_error_keeps_its_explicit_location() {
let mut bytes = b"%PDF-1.4\n".to_vec();
let object_offset = bytes.len();
bytes.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages << /Type /Pages /Kids [] /Count 0 >> >>\nendobj\n",
);
let xref_offset = bytes.len();
bytes.extend_from_slice(
format!("xref\n0 2\n0000000000 65535 f \n{object_offset:010} 00000 n \n").as_bytes(),
);
bytes.extend_from_slice(
format!("trailer\n<< /Size 2 /Root 1 0 R >>\nstartxref\n{xref_offset}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("direct-pages fixture should open");
let error = prepare_for_optimization_with_max_depth(&mut pdf, 0)
.expect_err("the explicit depth bound should stop at the direct root");
assert!(error.to_string().contains("direct /Pages node"));
}
#[test]
fn prepared_pages_keeps_a_raw_page_identity_live() {
let mut pdf = Pdf::empty().expect("empty PDF should open");
let catalog = pdf.root_handle().expect("empty PDF has a catalog");
let pages = catalog
.try_get_key(b"/Pages")
.expect("catalog has a page-tree root");
let raw_page = pdf.get_object_handle_by_raw_identity(3, 65_535);
raw_page.set_resolved(ObjectValue::Dictionary(
[
(b"/Type".to_vec(), ObjectHandle::name(b"Page".to_vec())),
(
b"/MediaBox".to_vec(),
ObjectHandle::array(vec![
ObjectHandle::integer(0),
ObjectHandle::integer(0),
ObjectHandle::integer(612),
ObjectHandle::integer(792),
]),
),
]
.into_iter()
.collect(),
));
pages
.replace_key(b"/Kids", ObjectHandle::array(vec![raw_page.clone()]))
.expect("replace page-tree kids");
pages
.replace_key(b"/Count", ObjectHandle::integer(1))
.expect("replace page count");
let prepared = prepare_for_optimization(&mut pdf)
.expect("raw page identity must not fail during canonical repair")
.expect("the empty document has a page tree");
assert_eq!(prepared.pages.len(), 1);
assert_eq!(prepared.pages[0].qpdf_obj_gen(), raw_page.qpdf_obj_gen());
assert_eq!(prepared.pages[0].object_ref(), None);
crate::optimization::inherited_attrs::push(&mut pdf, &prepared, true, false)
.expect("raw page identity must survive inherited-attribute push");
crate::optimization::Optimization::optimize(
&mut pdf,
&std::collections::BTreeMap::new(),
true,
|_, _| Ok(0),
)
.expect("raw page identity must survive qpdf optimization traversal");
}
}