use crate::object_copy::{copy_objects, rewrite_refs};
use crate::page_closure::extend_page_object_closure;
use crate::page_label_document_helper::merge_adjacent_ranges;
use crate::page_rotate::resolve_inherited_rotate_with_max_depth;
use crate::page_tree_rebuild::resolve_inherited_raw;
use crate::pages::{
page_refs, resolve_inherited_resources_with_max_depth, DEFAULT_MAX_PAGE_TREE_DEPTH,
};
use crate::subset_prune::sweep_unreachable_objects;
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek};
pub(crate) struct InheritedAttrs {
pub(crate) resources: Option<Dictionary>,
pub(crate) rotate: i32,
pub(crate) mediabox: Option<Object>,
pub(crate) cropbox: Option<Object>,
}
impl InheritedAttrs {
pub(crate) fn resolve<R: Read + Seek>(
source: &mut Pdf<R>,
page_ref: ObjectRef,
depth: usize,
) -> Result<Self> {
Ok(InheritedAttrs {
resources: resolve_inherited_resources_with_max_depth(source, page_ref, depth)?,
rotate: resolve_inherited_rotate_with_max_depth(source, page_ref, depth)?,
mediabox: resolve_inherited_raw(source, page_ref, "MediaBox", depth)?,
cropbox: resolve_inherited_raw(source, page_ref, "CropBox", depth)?,
})
}
}
pub fn extract_pages<R: Read + Seek>(
source: &mut Pdf<R>,
page_indices: &[usize],
) -> Result<Pdf<Cursor<Vec<u8>>>> {
if page_indices.is_empty() {
return Err(Error::Unsupported("empty page selection".to_string()));
}
let all_pages = page_refs(source)?;
let mut selected: Vec<ObjectRef> = Vec::with_capacity(page_indices.len());
for &idx in page_indices {
let page_ref = *all_pages.get(idx).ok_or_else(|| {
Error::Unsupported(format!(
"page index {idx} out of range (document has {} pages)",
all_pages.len()
))
})?;
selected.push(page_ref);
}
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut unique: Vec<ObjectRef> = Vec::with_capacity(selected.len());
for &page_ref in &selected {
if seen.insert(page_ref) {
unique.push(page_ref);
}
}
let depth = DEFAULT_MAX_PAGE_TREE_DEPTH;
let mut inherited: Vec<InheritedAttrs> = Vec::with_capacity(unique.len());
for &page_ref in &unique {
inherited.push(InheritedAttrs::resolve(source, page_ref, depth)?);
}
let mut closure: BTreeSet<ObjectRef> = BTreeSet::new();
for &page_ref in &unique {
extend_page_object_closure(source, page_ref, &mut closure)?;
}
let mut target = Pdf::open_mem_owned(minimal_target_bytes())?;
let map = copy_objects(source, &mut target, &closure)?;
null_copied_removed_pages(&mut target, &all_pages, &seen, &map);
let pages_root_ref = target_pages_root(&mut target)?;
let mut copied_unique: Vec<ObjectRef> = Vec::with_capacity(unique.len());
for (&src_ref, attrs) in unique.iter().zip(inherited) {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("extracted page missing from copy map"))?;
materialize_leaf(&mut target, copied_page_ref, attrs, &map, pages_root_ref)?;
copied_unique.push(copied_page_ref);
}
{
let mut source_labels = source.page_labels();
if source_labels.has_page_labels()? {
let src_indices: Vec<i64> = page_indices.iter().map(|&i| i as i64).collect();
let entries = source_labels.labels_for_selection(&src_indices, 0)?;
let folded = merge_adjacent_ranges(entries);
target.page_labels().write_reconstructed_labels(&folded)?;
}
}
let mut kids: Vec<ObjectRef> = Vec::with_capacity(selected.len());
let mut used: BTreeSet<ObjectRef> = BTreeSet::new();
append_selection_kids(&mut target, &selected, &map, &mut used, &mut kids)?;
let mut root = resolve_dict(
&mut target,
pages_root_ref,
"target /Pages is not a dictionary",
)?;
root.insert(
"Kids",
Object::Array(kids.iter().map(|&r| Object::Reference(r)).collect()),
);
root.insert("Count", Object::Integer(kids.len() as i64));
target.set_object(pages_root_ref, Object::Dictionary(root));
sweep_unreachable_objects(&mut target)?;
Ok(target)
}
pub(crate) fn null_copied_removed_pages<R: Read + Seek>(
target: &mut Pdf<R>,
all_pages: &[ObjectRef],
selected: &BTreeSet<ObjectRef>,
map: &BTreeMap<ObjectRef, ObjectRef>,
) {
for source_page in all_pages {
if !selected.contains(source_page) {
if let Some(&copied_page) = map.get(source_page) {
target.set_object(copied_page, Object::Null);
}
}
}
}
pub fn extract_page<R: Read + Seek>(
source: &mut Pdf<R>,
page_index: usize,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
extract_pages(source, &[page_index])
}
pub(crate) fn materialize_leaf(
target: &mut Pdf<Cursor<Vec<u8>>>,
copied_page_ref: ObjectRef,
attrs: InheritedAttrs,
map: &std::collections::BTreeMap<ObjectRef, ObjectRef>,
pages_root_ref: ObjectRef,
) -> Result<()> {
let mut leaf = resolve_dict(target, copied_page_ref, "copied page is not a dictionary")?;
if !has_own(&leaf, "Resources") {
if let Some(res) = attrs.resources {
let mut value = Object::Dictionary(res);
rewrite_refs(&mut value, 0, map)?;
leaf.insert("Resources", value);
}
}
if !has_own(&leaf, "MediaBox") {
if let Some(mut mb) = attrs.mediabox {
rewrite_refs(&mut mb, 0, map)?;
leaf.insert("MediaBox", mb);
} }
if !has_own(&leaf, "CropBox") {
if let Some(mut cb) = attrs.cropbox {
rewrite_refs(&mut cb, 0, map)?;
leaf.insert("CropBox", cb);
}
}
if !has_own(&leaf, "Rotate") {
leaf.insert("Rotate", Object::Integer(attrs.rotate as i64));
}
leaf.insert("Parent", Object::Reference(pages_root_ref));
target.set_object(copied_page_ref, Object::Dictionary(leaf));
Ok(())
}
pub(crate) fn append_selection_kids(
target: &mut Pdf<Cursor<Vec<u8>>>,
selected: &[ObjectRef],
map: &std::collections::BTreeMap<ObjectRef, ObjectRef>,
used: &mut BTreeSet<ObjectRef>,
kids: &mut Vec<ObjectRef>,
) -> Result<()> {
let mut next_num: u32 = target
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
for &src_ref in selected {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("extracted page missing from copy map"))?;
let kid = if used.insert(copied_page_ref) {
copied_page_ref
} else {
next_num = next_num.checked_add(1).ok_or_else(|| {
Error::Unsupported(
"page extract: object-number overflow allocating duplicate page".to_string(),
)
})?;
let clone_ref = ObjectRef::new(next_num, 0);
let dict = resolve_dict(target, copied_page_ref, "copied page is not a dictionary")?; target.set_object(clone_ref, Object::Dictionary(dict));
clone_ref
};
kids.push(kid);
}
Ok(())
}
pub(crate) fn minimal_target_bytes() -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let off1 = out.len() as u64;
out.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = out.len() as u64;
out.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [] /Count 0 >>\nendobj\n");
let xref_start = out.len() as u64;
out.extend_from_slice(
format!("xref\n0 3\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n")
.as_bytes(),
);
out.extend_from_slice(
format!("trailer\n<< /Size 3 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
out
}
pub(crate) fn target_pages_root(target: &mut Pdf<Cursor<Vec<u8>>>) -> Result<ObjectRef> {
let catalog_ref = target.root_ref().ok_or(Error::Missing("/Root"))?;
let catalog = resolve_dict(target, catalog_ref, "/Root is not a dictionary")?;
catalog
.get("Pages")
.and_then(|o| match o {
Object::Reference(r) => Some(*r),
_ => None,
})
.ok_or(Error::Missing("/Pages"))
}
pub(crate) fn resolve_dict(
target: &mut Pdf<Cursor<Vec<u8>>>,
r: ObjectRef,
ctx: &'static str,
) -> Result<Dictionary> {
match target.resolve(r)? {
Object::Dictionary(d) => Ok(d),
_ => Err(Error::Missing(ctx)),
}
}
fn has_own(dict: &Dictionary, key: &str) -> bool {
!matches!(dict.get(key), None | Some(Object::Null))
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::BTreeMap;
fn build_pdf(objects: &[(u32, &str)], root: u32) -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let mut offsets: BTreeMap<u32, u64> = BTreeMap::new();
let max = objects.iter().map(|(n, _)| *n).max().unwrap_or(0);
for (n, body) in objects {
offsets.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = out.len() as u64;
let size = max + 1;
out.extend_from_slice(format!("xref\n0 {size}\n").as_bytes());
out.extend_from_slice(b"0000000000 65535 f \n");
for n in 1..=max {
match offsets.get(&n) {
Some(off) => out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes()),
None => out.extend_from_slice(b"0000000000 65535 f \n"),
}
}
out.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root {root} 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
out
}
#[test]
fn resolve_dict_errors_on_non_dictionary() {
let bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [] /Count 0 >>"),
(3, "42"),
],
1,
);
let mut pdf = Pdf::open_mem_owned(bytes).unwrap();
let err = resolve_dict(&mut pdf, ObjectRef::new(3, 0), "not a dict")
.expect_err("resolving an integer as a dict must error");
assert!(matches!(err, Error::Missing("not a dict")), "got {err:?}");
}
#[test]
fn target_pages_root_errors_when_pages_is_not_a_reference() {
let bytes = build_pdf(
&[(
1,
"<< /Type /Catalog /Pages << /Type /Pages /Kids [] /Count 0 >> >>",
)],
1,
);
let mut pdf = Pdf::open_mem_owned(bytes).unwrap();
let err = target_pages_root(&mut pdf).expect_err("inline /Pages must error");
assert!(matches!(err, Error::Missing("/Pages")), "got {err:?}");
}
}