use std::collections::{BTreeSet, HashSet};
use std::io::{Read, Seek};
use crate::object_handle::{ObjectHandle, ObjectHandleIdentity};
use crate::ObjectRef;
use crate::{Error, Pdf, Result};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PreparedPages {
pub root: PageTreeRoot,
pub pages: Vec<ObjectRef>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PageTreeRoot {
Indirect(ObjectRef),
Direct {
catalog: ObjectRef,
},
DirectCatalog,
}
pub fn prepare_for_optimization<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<Option<PreparedPages>> {
prepare_for_optimization_with_max_depth(pdf, crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH)
}
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, max_depth)
}
fn prepare_for_optimization_canonical<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: usize,
) -> Result<Option<PreparedPages>> {
if max_depth == crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH {
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.is_null() {
return Ok(None);
}
let catalog = pdf.resolve_handle(&root_candidate)?;
if catalog.try_as_dictionary()?.is_none() {
return Ok(None);
}
let mut pages = catalog.try_get_key(b"/Pages")?;
let mut seen_parent: BTreeSet<ObjectRef> = 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_ref) = pages.object_ref() {
!seen_parent.insert(object_ref)
} else {
!seen_parent_direct.insert(pages.identity_key())
};
if repeated {
break;
}
if pages.try_as_dictionary()?.is_none() {
break;
}
if !pages.try_has_key(b"/Parent")? {
break;
}
let parent = pages.try_get_key(b"/Parent")?;
if parent.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())?;
pdf.mark_object_handle_dirty(&catalog)?;
}
let has_kids = pages.try_has_key(b"/Kids")?;
if pages.try_as_dictionary()?.is_none() {
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.object_ref() {
Some(object_ref) => PageTreeRoot::Indirect(object_ref),
None => match catalog.object_ref() {
Some(catalog_ref) => PageTreeRoot::Direct {
catalog: catalog_ref,
},
None => PageTreeRoot::DirectCatalog,
},
};
let prepared = PreparedPages {
root,
pages: state.pages,
};
if max_depth == crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH {
pdf.cache_page_list(&prepared);
}
Ok(Some(prepared))
}
struct CanonicalRepairState {
seen: BTreeSet<ObjectRef>,
visited: BTreeSet<ObjectRef>,
visited_direct: HashSet<ObjectHandleIdentity>,
pages: Vec<ObjectRef>,
}
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: usize,
) -> Result<()> {
if depth >= max_depth {
let location = node
.object_ref()
.map_or_else(|| "direct /Pages node".to_owned(), |r| r.to_string());
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {max_depth} at {location}"
)));
}
if let Some(object_ref) = node.object_ref() {
if !state.visited.insert(object_ref) {
return Err(Error::Unsupported(format!(
"page tree cycle detected at {object_ref}"
)));
}
} else if !state.visited_direct.insert(node.identity_key()) {
return Err(Error::Unsupported(
"page tree cycle detected at direct /Pages node".to_owned(),
));
}
node.try_dereference()?;
if node.try_as_dictionary()?.is_none() || !node.try_has_key(b"/Kids")? {
return Ok(()); }
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(pdf, &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(());
};
for index in 0..kid_count {
let Some(mut kid) = kids.try_array_item(index)? else {
continue;
};
if kid.try_has_key(b"/Kids")? {
repair_page_tree_handle(pdf, kid, state, depth + 1, media_box, max_depth)?;
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(
pdf,
&kid,
b"/MediaBox",
ObjectHandle::array(vec![
ObjectHandle::integer(0),
ObjectHandle::integer(0),
ObjectHandle::integer(612),
ObjectHandle::integer(792),
]),
)?; }
if kid.is_direct() {
node.warn_if_possible(
format!("kid {index} (from 0) is direct; converting to indirect").as_str(),
)?; kid = promote_page_handle(pdf, kid)?;
let promoted_ref = kid
.object_ref()
.expect("promote_page_handle returns an indirect handle");
state.seen.insert(promoted_ref);
kids.set_array_item(index, kid.clone())?;
pdf.mark_object_handle_dirty(&kids)?;
} else if let Some(object_ref) = kid.object_ref() {
if !state.seen.insert(object_ref) {
node.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_ref = kid
.object_ref()
.expect("promote_page_handle returns an indirect handle");
state.seen.insert(copied_ref);
kids.set_array_item(index, kid.clone())?;
pdf.mark_object_handle_dirty(&kids)?;
}
}
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(pdf, &kid, b"/Type", ObjectHandle::name(b"Page".to_vec()))?;
}
let page_ref = kid
.object_ref()
.expect("every qpdf page-tree leaf is indirect after repair");
state.pages.push(page_ref);
}
Ok(())
}
fn promote_page_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: ObjectHandle,
) -> Result<ObjectHandle> {
let promoted = pdf.make_indirect_from_object_handle(handle)?;
pdf.mark_object_handle_dirty(&promoted)?;
Ok(promoted)
}
fn replace_handle_key<R: Read + Seek>(
pdf: &mut Pdf<R>,
holder: &ObjectHandle,
key: &[u8],
value: ObjectHandle,
) -> Result<()> {
holder.replace_key(key, value)?;
pdf.mark_object_handle_dirty(holder)
}
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)
}