use crate::object_copy::{copy_objects, rewrite_refs};
use crate::page_closure::page_object_closure;
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::io::{Cursor, Read, Seek};
pub fn extract_page<R: Read + Seek>(
source: &mut Pdf<R>,
page_index: usize,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
let all_pages = page_refs(source)?;
let page_ref = *all_pages.get(page_index).ok_or_else(|| {
Error::Unsupported(format!(
"page index {page_index} out of range (document has {} pages)",
all_pages.len()
))
})?;
let depth = DEFAULT_MAX_PAGE_TREE_DEPTH;
let inherited_resources = resolve_inherited_resources_with_max_depth(source, page_ref, depth)?;
let inherited_rotate = resolve_inherited_rotate_with_max_depth(source, page_ref, depth)?;
let inherited_mediabox = resolve_inherited_raw(source, page_ref, "MediaBox", depth)?;
let inherited_cropbox = resolve_inherited_raw(source, page_ref, "CropBox", depth)?;
let closure = page_object_closure(source, page_ref)?;
let mut target = Pdf::open_mem_owned(minimal_target_bytes())?;
let map = copy_objects(source, &mut target, &closure)?;
let copied_page_ref = *map
.get(&page_ref)
.ok_or(Error::Missing("extracted page missing from copy map"))?;
let pages_root_ref = target_pages_root(&mut target)?;
let mut leaf = resolve_dict(
&mut target,
copied_page_ref,
"copied page is not a dictionary",
)?;
if !has_own(&leaf, "Resources") {
if let Some(res) = inherited_resources {
let mut value = Object::Dictionary(res);
rewrite_refs(&mut value, &map);
leaf.insert("Resources", value);
}
}
if !has_own(&leaf, "MediaBox") {
if let Some(mut mb) = inherited_mediabox {
rewrite_refs(&mut mb, &map);
leaf.insert("MediaBox", mb);
}
}
if !has_own(&leaf, "CropBox") {
if let Some(mut cb) = inherited_cropbox {
rewrite_refs(&mut cb, &map);
leaf.insert("CropBox", cb);
}
}
if !has_own(&leaf, "Rotate") {
leaf.insert("Rotate", Object::Integer(inherited_rotate as i64));
}
leaf.insert("Parent", Object::Reference(pages_root_ref));
target.set_object(copied_page_ref, Object::Dictionary(leaf));
let mut root = resolve_dict(
&mut target,
pages_root_ref,
"target /Pages is not a dictionary",
)?;
root.insert(
"Kids",
Object::Array(vec![Object::Reference(copied_page_ref)]),
);
root.insert("Count", Object::Integer(1));
target.set_object(pages_root_ref, Object::Dictionary(root));
sweep_unreachable_objects(&mut target)?;
Ok(target)
}
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
}
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"))
}
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:?}");
}
}