use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use crate::linearization::hint_page::{bits_needed, PageOffsetHintTable};
use crate::linearization::hint_shared::SharedObjectHintTable;
use crate::linearization::hint_stream::{encode_hint_stream, OutlineHintTable};
use crate::linearization::part1::{Part1Bytes, Part1Placeholders};
use crate::linearization::plan::LinearizationPlan;
use crate::linearization::renumber::{ObjStmRelocation, RenumberMap};
use crate::linearization::xref_stream;
use crate::object::MAX_INLINE_DEPTH;
use crate::writer::object_streams::{
emit_objstm_body_from_resolved, planner_config_from_options, wrap_objstm_body,
};
use crate::writer::{
apply_stream_compress_policy, effective_pdf_version, effective_stream_policy, is_lone_flate,
write_stream_to_buf_qpdf_order, CompressStreams, NewlineBeforeEndstream, WriteOptions,
QPDF_STATIC_ID,
};
use crate::{Dictionary, Object, ObjectRef, Pdf, Result, Stream};
#[derive(Debug, Clone)]
struct ObjStmContainer {
container_new_num: u32,
members: Vec<(ObjectRef, ObjectRef)>,
}
#[derive(Debug, Clone, Default)]
struct ObjStmLayout {
open_document: Vec<ObjStmContainer>,
part3: Vec<ObjStmContainer>,
part4: Vec<ObjStmContainer>,
member_to_container: BTreeMap<ObjectRef, (u32, u32)>,
}
impl ObjStmLayout {
fn is_empty(&self) -> bool {
self.open_document.is_empty() && self.part3.is_empty() && self.part4.is_empty()
}
fn resolve_batches<R: Read + Seek>(
plan: &LinearizationPlan,
pdf: &mut Pdf<R>,
options: &WriteOptions,
) -> Result<crate::linearization::plan::ObjStmBatchPlan> {
let config = planner_config_from_options(options);
let batch_plan = plan.objstm_batches(pdf, &config)?;
let page_dicts: std::collections::BTreeSet<ObjectRef> =
crate::pages::page_refs(pdf)?.into_iter().collect();
let filter_batches = |batches: Vec<Vec<ObjectRef>>| -> Vec<Vec<ObjectRef>> {
batches
.into_iter()
.filter_map(|batch| {
let kept: Vec<ObjectRef> = batch
.into_iter()
.filter(|r| !page_dicts.contains(r))
.collect();
if kept.is_empty() {
None
} else {
Some(kept)
}
})
.collect()
};
Ok(crate::linearization::plan::ObjStmBatchPlan {
open_document_batches: filter_batches(batch_plan.open_document_batches),
part3_batches: filter_batches(batch_plan.part3_batches),
part4_batches: filter_batches(batch_plan.part4_batches),
})
}
fn build_from_batches(
batch_plan: &crate::linearization::plan::ObjStmBatchPlan,
container_numbers: &[u32],
renumber: &RenumberMap,
) -> Result<Self> {
if batch_plan.open_document_batches.is_empty()
&& batch_plan.part3_batches.is_empty()
&& batch_plan.part4_batches.is_empty()
{
return Ok(Self::default());
}
let mut member_to_container = BTreeMap::new();
let take = |batches: &[Vec<ObjectRef>],
out: &mut Vec<ObjStmContainer>,
map: &mut BTreeMap<ObjectRef, (u32, u32)>,
container_iter: &mut std::vec::IntoIter<u32>|
-> Result<()> {
for batch in batches {
if batch.is_empty() {
continue;
}
let container_new_num = container_iter.next().ok_or_else(|| {
crate::Error::Unsupported(
"linearization writer: ObjStm container-number stream exhausted \
(renumber relocation / batch-plan inconsistency)"
.to_string(),
)
})?;
let mut members = Vec::with_capacity(batch.len());
for (idx, &orig) in batch.iter().enumerate() {
let new_ref = renumber.new_for_original(orig).ok_or_else(|| {
crate::Error::Unsupported(format!(
"linearization writer: ObjStm member {orig} has no renumber \
entry (planner / renumber inconsistency)"
))
})?;
map.insert(orig, (container_new_num, idx as u32));
members.push((orig, new_ref));
}
out.push(ObjStmContainer {
container_new_num,
members,
});
}
Ok(())
};
let container_numbers_vec: Vec<u32> = container_numbers.to_vec();
let mut container_iter = container_numbers_vec.into_iter();
let mut open_document = Vec::new();
let mut part3 = Vec::new();
let mut part4 = Vec::new();
take(
&batch_plan.open_document_batches,
&mut open_document,
&mut member_to_container,
&mut container_iter,
)?;
take(
&batch_plan.part3_batches,
&mut part3,
&mut member_to_container,
&mut container_iter,
)?;
take(
&batch_plan.part4_batches,
&mut part4,
&mut member_to_container,
&mut container_iter,
)?;
let _ = container_iter;
Ok(Self {
open_document,
part3,
part4,
member_to_container,
})
}
}
fn append_objstm_container_object<R: Read + Seek>(
bytes: &mut Vec<u8>,
container: &ObjStmContainer,
renumber: &RenumberMap,
pdf: &mut Pdf<R>,
live: &BTreeSet<ObjectRef>,
) -> Result<usize> {
let mut resolved: Vec<(ObjectRef, Object)> = Vec::with_capacity(container.members.len());
for &(orig, new_ref) in &container.members {
let object = pdf.resolve_borrowed(orig)?;
let renumbered = renumber_object(object, 0, renumber, live)?;
resolved.push((new_ref, renumbered));
}
let body = emit_objstm_body_from_resolved(&resolved)?;
let stream = wrap_objstm_body(&body, crate::writer::CompressStreams::Yes)?;
let offset = bytes.len();
use std::io::Write as _;
let _ = write!(
bytes,
"{} 0 obj\n<< /Type /ObjStm /Length {} /Filter /FlateDecode /N {} /First {} >>\nstream\n",
container.container_new_num,
stream.data.len(),
body.n_members,
body.first_offset,
);
bytes.extend_from_slice(&stream.data);
bytes.extend_from_slice(b"endstream\nendobj\n");
Ok(offset)
}
#[derive(Debug, Clone)]
pub struct LinearizedOffsets {
pub file_length: usize,
pub hint_stream_offset: usize,
pub hint_stream_length: usize,
pub first_page_object_new_num: u32,
pub end_of_first_page_offset: usize,
pub last_xref_keyword_offset: usize,
pub last_xref_offset: usize,
pub page_count: u32,
pub part1_placeholders: Part1Placeholders,
pub xref_offsets: BTreeMap<u32, usize>,
pub first_trailer_prev_range: std::ops::Range<usize>,
pub dict_writable_region: std::ops::Range<usize>,
}
#[derive(Debug)]
pub struct LinearizedDocument {
pub bytes: Vec<u8>,
pub offsets: LinearizedOffsets,
}
pub(crate) const PREV_PLACEHOLDER_WIDTH: usize = 22;
fn renumber_object(
object: &Object,
depth: usize,
renumber: &RenumberMap,
live: &BTreeSet<ObjectRef>,
) -> Result<Object> {
if depth > MAX_INLINE_DEPTH {
return Err(crate::Error::Unsupported(format!(
"linearization writer: inline object nesting exceeds maximum of {MAX_INLINE_DEPTH}"
)));
}
match object {
Object::Reference(r) => match renumber.new_for_original(*r) {
Some(new_ref) => Ok(Object::Reference(new_ref)),
None if is_null_resolving_ref(*r, live) => {
Ok(Object::Null)
}
None => Err(crate::Error::Unsupported(format!(
"linearization writer: reference {r} has no entry in RenumberMap \
(planner / renumber inconsistency — would emit mixed old/new \
object numbers)"
))),
},
Object::Array(elements) => {
let mut renumbered = Vec::with_capacity(elements.len());
for e in elements {
renumbered.push(renumber_object(e, depth + 1, renumber, live)?);
}
Ok(Object::Array(renumbered))
}
Object::Dictionary(dict) => {
let mut new_dict = Dictionary::new();
for (key, value) in dict.iter() {
if is_null_resolving_value(value, live) {
continue;
}
new_dict.insert(key, renumber_object(value, depth + 1, renumber, live)?);
}
Ok(Object::Dictionary(new_dict))
}
Object::Stream(stream) => {
let mut new_dict = Dictionary::new();
for (key, value) in stream.dict.iter() {
let dropped_length_holder = key == b"Length"
&& matches!(value, Object::Reference(r) if renumber.new_for_original(*r).is_none());
if dropped_length_holder {
new_dict.insert(key, Object::Integer(stream.data.len() as i64));
} else if is_null_resolving_value(value, live) {
continue;
} else {
new_dict.insert(key, renumber_object(value, depth + 1, renumber, live)?);
}
}
Ok(Object::Stream(Stream::new(new_dict, stream.data.clone())))
}
_ => Ok(object.clone()),
}
}
fn is_null_resolving_ref(r: ObjectRef, live: &BTreeSet<ObjectRef>) -> bool {
r.number == 0 || !live.contains(&r)
}
fn is_null_resolving_value(value: &Object, live: &BTreeSet<ObjectRef>) -> bool {
matches!(value, Object::Reference(r) if is_null_resolving_ref(*r, live))
}
fn append_object(bytes: &mut Vec<u8>, new_ref: ObjectRef, object: &Object) -> usize {
let offset = bytes.len();
bytes.extend_from_slice(format!("{} {} obj\n", new_ref.number, new_ref.generation).as_bytes());
object.write_pdf(bytes);
bytes.extend_from_slice(b"\nendobj\n");
offset
}
fn append_body_object(
bytes: &mut Vec<u8>,
new_ref: ObjectRef,
object: &Object,
options: &WriteOptions,
) -> usize {
let Object::Stream(stream) = object else {
return append_object(bytes, new_ref, object);
};
let Some(policy) = effective_stream_policy(options) else {
return append_object(bytes, new_ref, object);
};
let source_filter_is_lone_flate = is_lone_flate(stream.dict.get("Filter"));
if matches!(policy, CompressStreams::Yes)
&& source_filter_is_lone_flate
&& !options.recompress_flate
&& stream.dict.get("F").is_none()
{
let offset = bytes.len();
bytes.extend_from_slice(
format!("{} {} obj\n", new_ref.number, new_ref.generation).as_bytes(),
);
let mut dict = stream.dict.clone();
let len = i64::try_from(stream.data.len()).unwrap_or(i64::MAX);
dict.insert("Length", Object::Integer(len));
crate::writer::write_preserved_stream(bytes, &dict, &stream.data);
bytes.extend_from_slice(b"\nendobj\n");
return offset;
}
let reencoded = apply_stream_compress_policy(stream, policy);
let Object::Stream(ref s) = reencoded else {
unreachable!("apply_stream_compress_policy always returns Object::Stream")
};
let offset = bytes.len();
bytes.extend_from_slice(format!("{} {} obj\n", new_ref.number, new_ref.generation).as_bytes());
let refiltered = matches!(policy, CompressStreams::Yes)
&& !source_filter_is_lone_flate
&& is_lone_flate(s.dict.get("Filter"));
write_stream_to_buf_qpdf_order(bytes, s, NewlineBeforeEndstream::Never, refiltered);
bytes.extend_from_slice(b"\nendobj\n");
offset
}
const CLASSIC_XREF_ENTRY_WIDTH: usize = 20;
struct Part1XrefPatch {
start_num: u32,
count: u32,
data_range: std::ops::Range<usize>,
}
#[allow(clippy::too_many_arguments)]
fn write_part1_xref_and_trailer(
bytes: &mut Vec<u8>,
param_dict_obj_number: u32,
total_object_count: u32,
first_page_count: u32,
catalog_new_ref: ObjectRef,
info_new_ref: Option<ObjectRef>,
source_trailer: &Dictionary,
id_writer: Option<crate::object::ReborrowableIdWriter>,
) -> (usize, std::ops::Range<usize>, Part1XrefPatch) {
bytes.push(b'\n');
let xref_offset = bytes.len();
bytes.extend_from_slice(
format!("xref\n{param_dict_obj_number} {first_page_count}\n").as_bytes(),
);
let data_start = bytes.len();
bytes.resize(
data_start + (first_page_count as usize) * CLASSIC_XREF_ENTRY_WIDTH,
b' ',
);
let data_end = bytes.len();
let patch = Part1XrefPatch {
start_num: param_dict_obj_number,
count: first_page_count,
data_range: data_start..data_end,
};
bytes.extend_from_slice(b"trailer << ");
if let Some(info_ref) = info_new_ref {
bytes.extend_from_slice(
format!("/Info {} {} R ", info_ref.number, info_ref.generation).as_bytes(),
);
}
bytes.extend_from_slice(
format!(
"/Root {} {} R ",
catalog_new_ref.number, catalog_new_ref.generation
)
.as_bytes(),
);
bytes.extend_from_slice(format!("/Size {} ", total_object_count).as_bytes());
bytes.extend_from_slice(b"/Prev ");
let prev_value_start = bytes.len();
let placeholder = format!("{:<PREV_PLACEHOLDER_WIDTH$}", 0);
bytes.extend_from_slice(placeholder.as_bytes());
let prev_value_end = bytes.len();
if let Some(id_obj) = source_trailer.get("ID") {
bytes.extend_from_slice(b"/ID ");
match id_writer {
Some(write_id) => write_id(bytes),
None => crate::object::write_id_style_value(bytes, id_obj),
}
}
bytes.extend_from_slice(b" >>");
bytes.extend_from_slice(b"\nstartxref\n0\n%%EOF\n");
(xref_offset, prev_value_start..prev_value_end, patch)
}
fn patch_part1_xref(
bytes: &mut [u8],
patch: &Part1XrefPatch,
xref_offsets: &BTreeMap<u32, usize>,
) -> Result<()> {
if patch.data_range.end > bytes.len() {
return Err(crate::Error::Unsupported(
"Part-1 xref patch range out of bounds".to_string(),
));
}
let mut data = Vec::with_capacity(patch.count as usize * CLASSIC_XREF_ENTRY_WIDTH);
for number in patch.start_num..patch.start_num + patch.count {
let offset = xref_offsets.get(&number).copied().ok_or_else(|| {
crate::Error::Unsupported(format!(
"Part-1 xref: covered object {number} has no offset (planner / writer \
inconsistency — would emit a free entry for a live first-page object)"
))
})?;
data.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
if data.len() != patch.data_range.len() {
return Err(crate::Error::Unsupported(format!(
"Part-1 xref payload length drift: encoded {} bytes, reserved {}",
data.len(),
patch.data_range.len()
)));
}
bytes[patch.data_range.clone()].copy_from_slice(&data);
Ok(())
}
fn write_main_xref_and_trailer(
bytes: &mut Vec<u8>,
xref_offsets: &BTreeMap<u32, usize>,
param_slot: u32, first_page_xref_offset: usize,
source_trailer: &Dictionary,
id_writer: Option<crate::object::ReborrowableIdWriter>,
) -> (usize, usize) {
let xref_start = bytes.len();
let xref_header = format!("xref\n0 {}\n", param_slot);
bytes.extend_from_slice(xref_header.as_bytes());
let xref_first_entry_offset = bytes.len();
bytes.extend_from_slice(b"0000000000 65535 f \n");
for number in 1..param_slot {
match xref_offsets.get(&number) {
Some(offset) => {
bytes.extend_from_slice(format!("{:010} 00000 n \n", offset).as_bytes())
}
None => bytes.extend_from_slice(b"0000000000 65535 f \n"),
}
}
bytes.extend_from_slice(b"trailer << ");
bytes.extend_from_slice(format!("/Size {} ", param_slot).as_bytes());
if let Some(id_obj) = source_trailer.get("ID") {
bytes.extend_from_slice(b"/ID ");
match id_writer {
Some(write_id) => write_id(bytes),
None => crate::object::write_id_style_value(bytes, id_obj),
}
bytes.extend_from_slice(b" ");
}
bytes.extend_from_slice(b">>");
bytes.extend_from_slice(format!("\nstartxref\n{}\n%%EOF\n", first_page_xref_offset).as_bytes());
(xref_start, xref_first_entry_offset)
}
struct FirstPageXrefPatch {
first_xref_num: u32,
index_start: u32,
index_count: u32,
region: std::ops::Range<usize>,
catalog_new_ref: ObjectRef,
info_new_ref: Option<ObjectRef>,
size: u32,
id: Option<(Vec<u8>, Vec<u8>)>,
max_id: u32,
max_ostream_index: u64,
}
fn finalize_linearized_id(
options: &WriteOptions,
source_trailer: &Dictionary,
det_id_source_id0: Option<&[u8]>,
) -> Object {
let pi_bytes = Object::String(QPDF_STATIC_ID.to_vec());
if options.deterministic_id {
let len0 = det_id_source_id0.map(<[u8]>::len).unwrap_or(16);
Object::Array(vec![
Object::String(vec![0u8; len0]),
Object::String(vec![0u8; 16]),
])
} else if options.static_id {
let first_id = match source_trailer.get("ID") {
Some(Object::Array(values))
if values.len() == 2 && matches!(values[0], Object::String(_)) =>
{
values[0].clone()
}
_ => pi_bytes.clone(),
};
Object::Array(vec![first_id, pi_bytes])
} else {
crate::writer::random_id_array(source_trailer.get("ID"))
}
}
fn split_xref_common_id(source_trailer: &Dictionary) -> Option<Object> {
source_trailer.get("ID").cloned()
}
fn patch_linearized_deterministic_id(
bytes: &mut [u8],
id_ranges: &[std::ops::Range<usize>],
id0: &[u8],
id1: &[u8; 16],
) {
use crate::writer::{deterministic_id_array_len, write_deterministic_id_array};
let len = deterministic_id_array_len(id0.len());
let mut placeholder = Vec::with_capacity(len);
write_deterministic_id_array(&mut placeholder, &vec![0u8; id0.len()], &[0u8; 16]);
let mut final_id = Vec::with_capacity(len);
write_deterministic_id_array(&mut final_id, id0, id1);
for range in id_ranges {
let start = range.start.min(bytes.len());
let end = range.end.min(bytes.len());
let mut patched = 0usize;
let mut i = start;
while i + len <= end {
if &bytes[i..i + len] == placeholder.as_slice() {
bytes[i..i + len].copy_from_slice(&final_id);
patched += 1;
i += len;
} else {
i += 1;
}
}
debug_assert_eq!(
patched, 1,
"each /ID section must contain exactly one deterministic /ID placeholder \
(0 or >1 indicates a linearization writer bug)"
);
}
}
#[allow(clippy::too_many_arguments)]
fn write_first_page_xref_stream(
bytes: &mut Vec<u8>,
relocation: &ObjStmRelocation,
total_count: u32, catalog_new_ref: ObjectRef,
info_new_ref: Option<ObjectRef>,
source_trailer: &Dictionary,
max_ostream_index: u64,
) -> Result<FirstPageXrefPatch> {
let final_size = total_count;
let first_xref_num = relocation.first_xref_slot;
let index_start = relocation.second_half_count;
let index_count = final_size.checked_sub(index_start).ok_or_else(|| {
crate::Error::Unsupported(
"first-page xref /Index underflow (second-half count exceeds /Size)".to_string(),
)
})?;
let max_id = final_size.saturating_sub(1);
let id = xref_id_bytes(source_trailer);
let obj_ref = ObjectRef::new(first_xref_num, 0);
let region_len = {
let dict = xref_stream::XrefStreamDict {
widths: xref_stream::first_pass_widths(max_id, max_ostream_index, 0),
index: Some((index_start, index_count)),
info: info_new_ref,
root: Some(catalog_new_ref),
size: final_size,
prev: Some(0),
id: id.as_ref().map(|(a, b)| (a.as_slice(), b.as_slice())),
};
xref_stream::first_pass_region_len(obj_ref, &dict, index_count as usize)
};
bytes.push(b'\n');
let obj_offset = bytes.len();
bytes.resize(obj_offset + region_len, b' ');
bytes.push(b'\n');
Ok(FirstPageXrefPatch {
first_xref_num,
index_start,
index_count,
region: obj_offset..obj_offset + region_len,
catalog_new_ref,
info_new_ref,
size: final_size,
id,
max_id,
max_ostream_index,
})
}
fn xref_id_bytes(source_trailer: &Dictionary) -> Option<(Vec<u8>, Vec<u8>)> {
match split_xref_common_id(source_trailer)? {
Object::Array(a) if a.len() == 2 => match (&a[0], &a[1]) {
(Object::String(s0), Object::String(s1)) => Some((s0.clone(), s1.clone())),
_ => None, },
_ => None, }
}
fn patch_first_page_xref(
bytes: &mut [u8],
patch: &FirstPageXrefPatch,
xref_offsets: &BTreeMap<u32, usize>,
member_new: &BTreeMap<u32, (u32, u32)>,
main_xref_offset: usize,
hint_length: usize,
pass1: bool,
) -> Result<()> {
let mut offs = xref_offsets.clone();
offs.insert(patch.first_xref_num, patch.region.start);
let (widths, payload, prev) = if pass1 {
let pass1_offs: BTreeMap<u32, usize> = offs
.iter()
.filter(|(_, &off)| off <= patch.region.start)
.map(|(&n, &off)| (n, off))
.collect();
let entries = xref_stream::build_entries(
&pass1_offs,
&BTreeMap::new(),
patch.index_start,
patch.index_count,
);
let widths = xref_stream::first_pass_widths(patch.max_id, patch.max_ostream_index, 0);
let payload = xref_stream::encode_payload_uncompressed(&entries, widths);
(widths, payload, 0u64)
} else {
let entries =
xref_stream::build_entries(&offs, member_new, patch.index_start, patch.index_count);
let widths = xref_stream::second_pass_widths(
xref_stream::max_entry_offset(&entries),
hint_length as u64,
patch.max_id,
patch.max_ostream_index,
);
let payload = xref_stream::encode_payload(&entries, widths);
(widths, payload, main_xref_offset as u64)
};
let dict = xref_stream::XrefStreamDict {
widths,
index: Some((patch.index_start, patch.index_count)),
info: patch.info_new_ref,
root: Some(patch.catalog_new_ref),
size: patch.size,
prev: Some(prev),
id: patch.id.as_ref().map(|(a, b)| (a.as_slice(), b.as_slice())),
};
let region = xref_stream::write_padded_region(
ObjectRef::new(patch.first_xref_num, 0),
&dict,
&payload,
patch.region.len(),
)?; if patch.region.end > bytes.len() {
return Err(crate::Error::Unsupported(
"first-page xref patch range out of bounds".to_string(),
));
}
bytes[patch.region.clone()].copy_from_slice(®ion);
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn write_main_xref_stream_and_trailer(
bytes: &mut Vec<u8>,
xref_offsets: &BTreeMap<u32, usize>,
member_new: &BTreeMap<u32, (u32, u32)>,
relocation: &ObjStmRelocation,
total_count: u32, source_trailer: &Dictionary,
first_page_obj_offset: usize,
max_ostream_index: u64,
pass1: bool,
) -> Result<(usize, usize)> {
let final_size = total_count;
let first_xref_num = relocation.first_xref_slot;
let main_xref_num = relocation.main_xref_slot;
let max_id = final_size.saturating_sub(1);
let id = xref_id_bytes(source_trailer);
let main_count = relocation.second_half_count;
let main_xref_offset = bytes.len();
let mut offs2 = xref_offsets.clone();
offs2.insert(first_xref_num, first_page_obj_offset);
offs2.insert(main_xref_num, main_xref_offset);
let entries = xref_stream::build_entries(&offs2, member_new, 0, main_count);
let widths = xref_stream::second_pass_widths(
xref_stream::max_entry_offset(&entries),
0,
max_id,
max_ostream_index,
);
let payload = if pass1 {
xref_stream::encode_payload_uncompressed(&entries, widths)
} else {
xref_stream::encode_payload(&entries, widths)
};
let dict = xref_stream::XrefStreamDict {
widths,
index: None,
info: None,
root: None,
size: main_count,
prev: None,
id: id.as_ref().map(|(a, b)| (a.as_slice(), b.as_slice())),
};
let main_obj_ref = ObjectRef::new(main_xref_num, 0);
let region_len = {
let p1_dict = xref_stream::XrefStreamDict {
widths,
index: None,
info: None,
root: None,
size: main_count,
prev: None,
id: id.as_ref().map(|(a, b)| (a.as_slice(), b.as_slice())),
};
xref_stream::first_pass_region_len(main_obj_ref, &p1_dict, main_count as usize)
};
let region = xref_stream::write_padded_region(main_obj_ref, &dict, &payload, region_len)?;
bytes.extend_from_slice(®ion);
bytes.push(b'\n');
bytes.extend_from_slice(format!("startxref\n{first_page_obj_offset}\n%%EOF\n").as_bytes());
Ok((main_xref_offset, main_xref_offset))
}
fn hint_stream_dict_prefix(
shared_section_offset: usize,
outline_section_offset: Option<usize>,
payload_len: usize,
) -> String {
let outline_key = match outline_section_offset {
Some(o) => format!(" /O {o}"),
None => String::new(),
};
format!("<< /Filter /FlateDecode /S {shared_section_offset}{outline_key} /Length {payload_len} >>\nstream\n")
}
fn hint_stream_convergence_len(
compressed_payload: &[u8],
shared_section_offset: usize,
outline_section_offset: Option<usize>,
) -> usize {
hint_stream_dict_prefix(
shared_section_offset,
outline_section_offset,
compressed_payload.len(),
)
.len()
+ compressed_payload.len()
+ usize::from(compressed_payload.last() != Some(&b'\n'))
}
fn append_hint_stream_object(
bytes: &mut Vec<u8>,
new_ref: ObjectRef,
compressed_payload: &[u8],
shared_section_offset: usize,
outline_section_offset: Option<usize>,
) -> usize {
let offset = bytes.len();
bytes.extend_from_slice(format!("{} {} obj\n", new_ref.number, new_ref.generation).as_bytes());
bytes.extend_from_slice(
hint_stream_dict_prefix(
shared_section_offset,
outline_section_offset,
compressed_payload.len(),
)
.as_bytes(),
);
bytes.extend_from_slice(compressed_payload);
if compressed_payload.last() != Some(&b'\n') {
bytes.extend_from_slice(b"\n");
}
bytes.extend_from_slice(b"endstream\nendobj\n");
offset
}
struct OutlineHintInfo {
first_object: u32,
nobjects: u32,
}
fn compute_outline_hint_info<R: Read + Seek>(
pdf: &mut Pdf<R>,
renumber: &RenumberMap,
objstm_layout: &ObjStmLayout,
) -> Result<Option<OutlineHintInfo>> {
let outlines = crate::linearization::plan::outlines_set(pdf)?;
if outlines.is_empty() {
return Ok(None);
}
let outlines_ref = pdf.root_ref().and_then(|r| match pdf.resolve_borrowed(r) {
Ok(Object::Dictionary(d)) => d.get_ref("Outlines"),
_ => None, });
let Some(outlines_ref) = outlines_ref else {
return Ok(None); };
let unit_of = |r: ObjectRef| -> Option<u32> {
match objstm_layout.member_to_container.get(&r) {
Some(&(container_num, _)) => Some(container_num),
None => renumber.new_for_original(r).map(|nr| nr.number),
}
};
let units: std::collections::BTreeSet<u32> =
outlines.iter().filter_map(|&r| unit_of(r)).collect();
let Some(first_object) = unit_of(outlines_ref) else {
return Ok(None); };
Ok(Some(OutlineHintInfo {
first_object,
nobjects: units.len() as u32,
}))
}
fn build_outline_hint_table(
info: &OutlineHintInfo,
xref_offsets: &BTreeMap<u32, usize>,
byte_lengths: &BTreeMap<u32, usize>,
hint_stream_obj_total_len: usize,
) -> Result<OutlineHintTable> {
let first_off = xref_offsets
.get(&info.first_object)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"outline hint: first outline unit (#{}) has no probed offset",
info.first_object
))
})?;
let adjusted_offset = first_off
.checked_sub(hint_stream_obj_total_len)
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"outline hint: first unit offset ({first_off}) is less than the hint \
stream length ({hint_stream_obj_total_len})"
))
})?;
let first_object_offset = u32::try_from(adjusted_offset).map_err(|_| {
crate::Error::Unsupported(format!(
"outline hint: adjusted first unit offset ({adjusted_offset}) exceeds the \
32-bit Outlines Hint Table field"
))
})?;
let group_length: u64 = (info.first_object as u64
..info.first_object as u64 + info.nobjects as u64)
.map(|n| byte_lengths.get(&(n as u32)).copied().unwrap_or(0) as u64)
.sum();
Ok(OutlineHintTable {
first_object: info.first_object,
first_object_offset,
nobjects: info.nobjects,
group_length: group_length as u32,
})
}
fn build_pass1_part1(part1: &Part1Bytes) -> Part1Bytes {
const EMPTY_DICT: &[u8] = b"<< >>\nendobj\n";
let mut pass1 = part1.clone();
let region = part1.dict_writable_region.clone();
debug_assert!(region.len() >= EMPTY_DICT.len());
let mut replacement = Vec::with_capacity(region.len());
replacement.extend_from_slice(EMPTY_DICT);
replacement.resize(region.len(), b' ');
pass1.bytes[region].copy_from_slice(&replacement);
pass1
}
#[allow(clippy::too_many_arguments, clippy::type_complexity)]
fn do_write_pass<R: Read + Seek>(
plan: &LinearizationPlan,
renumber: &RenumberMap,
pdf: &mut Pdf<R>,
live: &BTreeSet<ObjectRef>,
part1: &Part1Bytes,
catalog_new_ref: ObjectRef,
hint_stream_new_num: u32,
total_count: u32,
info_new_ref: Option<ObjectRef>,
_first_page_object_new_num: u32,
hint_compressed: &[u8],
hint_shared_section_offset: usize,
hint_outline_section_offset: Option<usize>,
source_trailer: &Dictionary,
objstm_layout: &ObjStmLayout,
relocation: &ObjStmRelocation,
options: &WriteOptions,
pass1_digest: bool,
mut id_writer: Option<crate::object::ReborrowableIdWriter>,
) -> Result<(
Vec<u8>,
BTreeMap<u32, usize>,
usize, // hint_stream_offset
usize, // hint_stream_obj_total_len
usize, // end_of_first_page_offset
usize, // last_xref_offset (xref keyword position)
usize, // last_xref_first_entry_offset (= /T value per qpdf's convention)
std::ops::Range<usize>, // first_trailer_prev_range
Vec<std::ops::Range<usize>>, // id_ranges: absolute spans of every /ID-bearing section
)> {
let mut bytes: Vec<u8> = Vec::new();
let mut xref_offsets: BTreeMap<u32, usize> = BTreeMap::new();
let param_dict_obj_number = renumber.param_dict_ref().number;
let param_dict_absolute_offset = part1.obj1_offset;
bytes.extend_from_slice(&part1.bytes);
xref_offsets.insert(param_dict_obj_number, param_dict_absolute_offset);
let mut member_new: BTreeMap<u32, (u32, u32)> = BTreeMap::new();
for container in objstm_layout
.open_document
.iter()
.chain(&objstm_layout.part3)
.chain(&objstm_layout.part4)
{
for (idx, &(_orig, new_ref)) in container.members.iter().enumerate() {
member_new.insert(new_ref.number, (container.container_new_num, idx as u32));
}
}
let max_ostream_index: u64 = member_new
.values()
.map(|&(_, idx)| u64::from(idx))
.max()
.unwrap_or(0);
let mut first_page_xref_patch: Option<FirstPageXrefPatch> = None;
let mut part1_classic_xref_offset: usize = 0;
let mut part1_xref_patch: Option<Part1XrefPatch> = None;
let mut id_ranges: Vec<std::ops::Range<usize>> = Vec::new();
let first_trailer_prev_range = if objstm_layout.is_empty() {
let first_page_count = total_count
.checked_sub(param_dict_obj_number)
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"linearization writer: param-dict object number ({param_dict_obj_number}) \
exceeds /Size ({total_count}) — cannot size the first-page xref subsection"
))
})?;
let section_start = bytes.len();
let (p1_xref_offset, range, patch) = write_part1_xref_and_trailer(
&mut bytes,
param_dict_obj_number,
total_count,
first_page_count,
catalog_new_ref,
info_new_ref,
source_trailer,
id_writer.as_deref_mut(),
);
part1_classic_xref_offset = p1_xref_offset;
part1_xref_patch = Some(patch);
id_ranges.push(section_start..bytes.len());
range
} else {
let section_start = bytes.len();
let patch = write_first_page_xref_stream(
&mut bytes,
relocation,
total_count,
catalog_new_ref,
info_new_ref,
source_trailer,
max_ostream_index,
)?;
id_ranges.push(section_start..bytes.len());
first_page_xref_patch = Some(patch);
0..0
};
let mut catalog_emitted_early = false;
if let Some(catalog_orig) = plan.root_ref {
debug_assert!(
!objstm_layout
.member_to_container
.contains_key(&catalog_orig),
"planner invariant: /Catalog is never an ObjStm member"
);
let object = pdf.resolve_borrowed(catalog_orig)?;
let renumbered = renumber_object(object, 0, renumber, live)?;
let offset = append_body_object(&mut bytes, catalog_new_ref, &renumbered, options);
xref_offsets.insert(catalog_new_ref.number, offset);
catalog_emitted_early = true;
}
for original_ref in &plan.part4_open_document_plain {
let Some(new_ref) = renumber.new_for_original(*original_ref) else {
return Err(crate::Error::Unsupported(
"part4_open_document_plain ref missing from renumber map".into(),
));
};
let object = pdf.resolve_borrowed(*original_ref)?;
let renumbered = renumber_object(object, 0, renumber, live)?;
let offset = append_body_object(&mut bytes, new_ref, &renumbered, options);
xref_offsets.insert(new_ref.number, offset);
}
for container in &objstm_layout.open_document {
let offset = append_objstm_container_object(&mut bytes, container, renumber, pdf, live)?;
xref_offsets.insert(container.container_new_num, offset);
}
let hint_new_ref = ObjectRef::new(hint_stream_new_num, 0);
let hint_stream_offset = bytes.len();
if !pass1_digest {
let emitted_offset = append_hint_stream_object(
&mut bytes,
hint_new_ref,
hint_compressed,
hint_shared_section_offset,
hint_outline_section_offset,
);
debug_assert_eq!(emitted_offset, hint_stream_offset);
xref_offsets.insert(hint_stream_new_num, emitted_offset);
}
let hint_stream_obj_total_len = bytes.len() - hint_stream_offset;
for original_ref in &plan.part2_objects {
if objstm_layout.member_to_container.contains_key(original_ref) {
continue;
}
if catalog_emitted_early && plan.root_ref == Some(*original_ref) {
continue;
}
let Some(new_ref) = renumber.new_for_original(*original_ref) else {
return Err(crate::Error::Unsupported(format!(
"part2 object {} has no renumber entry",
original_ref
)));
};
let object = pdf.resolve_borrowed(*original_ref)?;
let renumbered = renumber_object(object, 0, renumber, live)?;
let offset = append_body_object(&mut bytes, new_ref, &renumbered, options);
xref_offsets.insert(new_ref.number, offset);
}
for original_ref in &plan.part3_objects {
if objstm_layout.member_to_container.contains_key(original_ref) {
continue;
}
if catalog_emitted_early && plan.root_ref == Some(*original_ref) {
continue;
}
let Some(new_ref) = renumber.new_for_original(*original_ref) else {
return Err(crate::Error::Unsupported(format!(
"part3 object {} has no renumber entry",
original_ref
)));
};
let object = pdf.resolve_borrowed(*original_ref)?;
let renumbered = renumber_object(object, 0, renumber, live)?;
let offset = append_body_object(&mut bytes, new_ref, &renumbered, options);
xref_offsets.insert(new_ref.number, offset);
}
for container in &objstm_layout.part3 {
let offset = append_objstm_container_object(&mut bytes, container, renumber, pdf, live)?;
xref_offsets.insert(container.container_new_num, offset);
}
for original_ref in &plan.part6_outline_objects {
if objstm_layout.member_to_container.contains_key(original_ref) {
continue; }
let Some(new_ref) = renumber.new_for_original(*original_ref) else {
return Err(crate::Error::Unsupported(format!(
"part6 outline object {} has no renumber entry",
original_ref
)));
};
let object = pdf.resolve_borrowed(*original_ref)?;
let renumbered = renumber_object(object, 0, renumber, live)?;
let offset = append_body_object(&mut bytes, new_ref, &renumbered, options);
xref_offsets.insert(new_ref.number, offset);
}
let end_of_first_page_offset = bytes.len();
enum Part4Emit<'a> {
Plain(ObjectRef),
Container(&'a ObjStmContainer),
}
let mut part4_emits: Vec<(u32, Part4Emit)> = Vec::new();
for original_ref in plan.part4_objects() {
if objstm_layout
.member_to_container
.contains_key(&original_ref)
{
continue;
}
if catalog_emitted_early && plan.root_ref == Some(original_ref) {
continue;
}
let Some(new_ref) = renumber.new_for_original(original_ref) else {
return Err(crate::Error::Unsupported(format!(
"part4 object {original_ref} has no renumber entry"
)));
};
part4_emits.push((new_ref.number, Part4Emit::Plain(original_ref)));
}
for container in &objstm_layout.part4 {
part4_emits.push((container.container_new_num, Part4Emit::Container(container)));
}
part4_emits.sort_by_key(|(number, _)| *number);
for (_, emit) in &part4_emits {
match emit {
Part4Emit::Plain(original_ref) => {
let new_ref = renumber
.new_for_original(*original_ref)
.expect("part4 plain object renumber entry checked above");
let object = pdf.resolve_borrowed(*original_ref)?;
let renumbered = renumber_object(object, 0, renumber, live)?;
let offset = append_body_object(&mut bytes, new_ref, &renumbered, options);
xref_offsets.insert(new_ref.number, offset);
}
Part4Emit::Container(container) => {
let offset =
append_objstm_container_object(&mut bytes, container, renumber, pdf, live)?;
xref_offsets.insert(container.container_new_num, offset);
}
}
}
let (last_xref_offset, last_xref_first_entry_offset) = if objstm_layout.is_empty() {
let main_section_start = bytes.len();
let result = write_main_xref_and_trailer(
&mut bytes,
&xref_offsets,
param_dict_obj_number,
part1_classic_xref_offset,
source_trailer,
id_writer,
);
id_ranges.push(main_section_start..bytes.len());
let patch = part1_xref_patch
.as_ref()
.ok_or_else(|| {
crate::Error::Unsupported(
"linearization writer: classic path produced no Part-1 xref patch \
(internal invariant violated)"
.to_string(),
)
})?;
if pass1_digest {
let zero_offsets: BTreeMap<u32, usize> = (patch.start_num
..patch.start_num + patch.count)
.map(|n| (n, 0usize))
.collect();
patch_part1_xref(&mut bytes, patch, &zero_offsets)?;
} else {
patch_part1_xref(&mut bytes, patch, &xref_offsets)?;
}
result
} else {
let patch = first_page_xref_patch.as_ref().ok_or_else(|| {
crate::Error::Unsupported(
"linearization writer: ObjStm path produced no first-page xref patch \
(internal invariant violated)"
.to_string(),
)
})?;
let first_page_obj_offset = patch.region.start;
debug_assert!(
first_page_obj_offset < end_of_first_page_offset,
"first-page xref stream offset ({first_page_obj_offset}) must be before \
/E ({end_of_first_page_offset}) — linearization boundary violated"
);
let main_section_start = bytes.len();
let result = write_main_xref_stream_and_trailer(
&mut bytes,
&xref_offsets,
&member_new,
relocation,
total_count,
source_trailer,
first_page_obj_offset,
max_ostream_index,
pass1_digest,
)?;
id_ranges.push(main_section_start..bytes.len());
patch_first_page_xref(
&mut bytes,
patch,
&xref_offsets,
&member_new,
result.0,
hint_stream_obj_total_len,
pass1_digest,
)?;
result
};
Ok((
bytes,
xref_offsets,
hint_stream_offset,
hint_stream_obj_total_len,
end_of_first_page_offset,
last_xref_offset,
last_xref_first_entry_offset,
first_trailer_prev_range,
id_ranges,
))
}
fn compute_byte_lengths(
xref_offsets: &BTreeMap<u32, usize>,
last_xref_offset: usize,
hint_stream_new_num: u32,
param_dict_new_num: u32,
) -> BTreeMap<u32, usize> {
let mut sorted: Vec<(usize, u32)> = xref_offsets
.iter()
.filter(|(&num, _)| num != param_dict_new_num)
.map(|(&num, &off)| (off, num))
.collect();
sorted.sort_unstable();
let mut lengths: BTreeMap<u32, usize> = BTreeMap::new();
for (idx, &(off, num)) in sorted.iter().enumerate() {
if num == hint_stream_new_num {
continue;
}
let next_off = if idx + 1 < sorted.len() {
sorted[idx + 1].0
} else {
last_xref_offset
};
lengths.insert(num, next_off.saturating_sub(off));
}
lengths
}
#[allow(dead_code)]
fn adjusted_offset(off: usize, hint_offset: usize, hint_length: usize) -> usize {
if off >= hint_offset {
off + hint_length
} else {
off
}
}
fn second_half_container_anchors(
plan: &LinearizationPlan,
part4_batches: &[Vec<ObjectRef>],
) -> Vec<Option<ObjectRef>> {
let member_set: BTreeSet<ObjectRef> = part4_batches.iter().flatten().copied().collect();
let mut plain_ranked: Vec<(ObjectRef, (u8, usize))> = Vec::new();
for (i, privates) in plan.per_page_private_objects.iter().enumerate().skip(1) {
for &r in privates {
if !member_set.contains(&r) {
plain_ranked.push((r, (0, i)));
}
}
}
for &r in &plan.part4_other_pages_shared {
if !member_set.contains(&r) {
plain_ranked.push((r, (1, 0)));
}
}
for &r in &plan.part4_rest {
if !member_set.contains(&r) {
plain_ranked.push((r, (2, 0)));
}
}
let page_private_sets: Vec<BTreeSet<ObjectRef>> = plan
.per_page_private_objects
.iter()
.map(|v| v.iter().copied().collect())
.collect();
let shared_set: BTreeSet<ObjectRef> = plan.part4_other_pages_shared.iter().copied().collect();
let rest_set: BTreeSet<ObjectRef> = plan.part4_rest.iter().copied().collect();
part4_batches
.iter()
.map(|batch| {
if batch.is_empty() {
return None; }
let mut pages: BTreeSet<usize> = BTreeSet::new();
let mut shared = false;
let mut rest = false;
for &m in batch {
if shared_set.contains(&m) {
shared = true;
} else if let Some(i) =
(1..page_private_sets.len()).find(|&i| page_private_sets[i].contains(&m))
{
pages.insert(i);
} else if rest_set.contains(&m) {
rest = true;
}
}
let batch_rank: (u8, usize) = if shared || pages.len() >= 2 {
(1, 0) } else if let Some(&i) = pages.iter().next().filter(|_| !rest) {
(0, i)
} else if rest {
(2, 0) } else {
return None; };
plain_ranked
.iter()
.rfind(|(_, rank)| *rank <= batch_rank)
.map(|(r, _)| *r)
})
.collect()
}
pub fn write_linearized<R: Read + Seek>(
plan: &LinearizationPlan,
renumber: &RenumberMap,
pdf: &mut Pdf<R>,
options: &WriteOptions,
) -> Result<LinearizedDocument> {
if options.deterministic_id && options.static_id {
return Err(crate::Error::Unsupported(
"deterministic_id and static_id are mutually exclusive".to_string(),
));
}
let encrypting = options.encrypt.is_some() || options.copy_encryption.is_some();
if options.deterministic_id && encrypting {
return Err(crate::Error::Unsupported(
"the deterministic-id option is incompatible with encrypted output files".to_string(),
));
}
crate::linearization::inherited_attrs::push_inherited_attributes_to_pages(pdf)?;
let live: BTreeSet<ObjectRef> = pdf.live_object_refs().into_iter().collect();
let rebuilt_plan;
let rebuilt_renumber;
let suppressed_options;
let (plan, renumber, options) = if crate::writer::force_version_below_1_5(options)
&& !matches!(
options.object_streams,
crate::writer::ObjectStreamMode::Disable
) {
rebuilt_plan = LinearizationPlan::from_pdf(pdf, false)?;
rebuilt_renumber = RenumberMap::from_plan(&rebuilt_plan);
suppressed_options = WriteOptions {
object_streams: crate::writer::ObjectStreamMode::Disable,
..options.clone()
};
(&rebuilt_plan, &rebuilt_renumber, &suppressed_options)
} else {
(plan, renumber, options)
};
let resolved_batch_plan = ObjStmLayout::resolve_batches(plan, pdf, options)?;
let mut local_renumber = renumber.clone();
let second_half_anchors =
second_half_container_anchors(plan, &resolved_batch_plan.part4_batches);
let part4_member_set: BTreeSet<ObjectRef> = resolved_batch_plan
.part4_batches
.iter()
.flatten()
.copied()
.collect();
let second_half_post_plain: BTreeSet<ObjectRef> = plan
.part4_rest
.iter()
.chain(&plan.part9_outline_objects)
.copied()
.filter(|r| {
!part4_member_set.contains(r)
&& Some(*r) != plan.pages_tree_ref
&& Some(*r) != plan.info_ref
})
.collect();
let first_half_member_set: BTreeSet<ObjectRef> = resolved_batch_plan
.open_document_batches
.iter()
.chain(&resolved_batch_plan.part3_batches)
.flatten()
.copied()
.collect();
let first_half_post_plain: BTreeSet<ObjectRef> = plan
.part6_outline_objects
.iter()
.copied()
.filter(|r| !first_half_member_set.contains(r))
.collect();
let relocation = local_renumber.place_objstm_members_per_half(
&resolved_batch_plan.open_document_batches,
&resolved_batch_plan.part3_batches,
&resolved_batch_plan.part4_batches,
&second_half_anchors,
&second_half_post_plain,
&first_half_post_plain,
);
let container_numbers = relocation.container_numbers.clone();
let renumber: &RenumberMap = &local_renumber;
let emits_object_streams = !resolved_batch_plan.open_document_batches.is_empty()
|| !resolved_batch_plan.part3_batches.is_empty()
|| !resolved_batch_plan.part4_batches.is_empty();
let eff_version = effective_pdf_version(pdf.version(), options, true, emits_object_streams);
let part1 = Part1Bytes::build(plan, renumber, eff_version);
let part1_placeholders = part1.placeholders.clone();
let part1_dict_region = part1.dict_writable_region.clone();
let catalog_orig = plan.root_ref.ok_or_else(|| {
crate::Error::Unsupported(
"linearization writer: plan.root_ref is None — \
cannot determine catalog reference for the trailer"
.to_string(),
)
})?;
let catalog_new_ref: ObjectRef = renumber.new_for_original(catalog_orig).ok_or_else(|| {
crate::Error::Unsupported(format!(
"linearization writer: catalog {catalog_orig} is not in RenumberMap \
(planner / renumber inconsistency)"
))
})?;
let hint_stream_new_num: u32 = renumber.hint_stream_slot();
let objstm_layout =
ObjStmLayout::build_from_batches(&resolved_batch_plan, &container_numbers, renumber)?;
let container_shared_rank: std::collections::BTreeMap<u32, u32> = match options.object_streams {
crate::writer::ObjectStreamMode::Preserve => objstm_layout
.part3
.iter()
.enumerate()
.map(|(i, c)| (c.container_new_num, i as u32))
.collect(),
_ => {
use crate::linearization::plan::objstm_membership_linearized;
let assigned = plan.renumber_assigned_refs();
let membership = objstm_membership_linearized(pdf, &assigned)?;
let mut rank = std::collections::BTreeMap::new();
for (split_index, members) in membership.iter().enumerate() {
let first = *members
.first()
.expect("objstm_membership_linearized never yields an empty container");
if let Some(&(container_num, _)) = objstm_layout.member_to_container.get(&first) {
rank.insert(container_num, split_index as u32);
}
}
rank
}
};
let total_count: u32 = renumber
.len()
.checked_add(1)
.and_then(|n| u32::try_from(n).ok())
.ok_or_else(|| {
crate::Error::Unsupported(
"linearization writer: /Size overflows u32 (too many objects / \
ObjStm containers)"
.to_string(),
)
})?;
let info_new_ref: Option<ObjectRef> = pdf
.trailer()
.get_ref("Info")
.and_then(|orig| renumber.new_for_original(orig));
let first_page_object_new_num: u32 = {
let first_page_hint = plan.page_hints.first().ok_or_else(|| {
crate::Error::Unsupported(
"linearization plan has no page hints (empty document?)".to_string(),
)
})?;
renumber
.new_for_original(first_page_hint.page_ref)
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"first-page page_ref {} has no renumber entry",
first_page_hint.page_ref,
))
})?
.number
};
let second_half_container_nums: std::collections::BTreeSet<u32> = objstm_layout
.part4
.iter()
.map(|c| c.container_new_num)
.collect();
let open_document_container_nums: std::collections::BTreeSet<u32> = objstm_layout
.open_document
.iter()
.map(|c| c.container_new_num)
.collect();
let po_table_initial = PageOffsetHintTable::from_plan(
plan,
renumber,
&objstm_layout.member_to_container,
&container_shared_rank,
&second_half_container_nums,
&open_document_container_nums,
);
let so_table_initial = SharedObjectHintTable::from_plan(
plan,
renumber,
&objstm_layout.member_to_container,
&second_half_container_nums,
&open_document_container_nums,
);
let outline_info = compute_outline_hint_info(pdf, renumber, &objstm_layout)?;
let outline_initial = outline_info.as_ref().map(|i| OutlineHintTable {
first_object: i.first_object,
first_object_offset: 0,
nobjects: i.nobjects,
group_length: 0,
});
let oi = outline_initial.as_ref();
let hint_bytes_initial = encode_hint_stream(&po_table_initial, &so_table_initial, oi)?;
let mut current_hint_compressed = hint_bytes_initial.compressed;
let mut current_hint_shared_s = hint_bytes_initial.shared_section_offset_in_uncompressed;
let mut current_hint_outline_o = hint_bytes_initial.outline_section_offset_in_uncompressed;
let mut source_trailer = pdf.trailer().clone();
let (det_id_source_id0, det_id_info_suffix): (Option<Vec<u8>>, Vec<u8>) =
if options.deterministic_id {
let id0 = crate::writer::source_permanent_id(&source_trailer);
let suffix = crate::writer::deterministic_id_info_suffix(pdf);
(id0, suffix)
} else {
(None, Vec::new())
};
let finalized_id =
finalize_linearized_id(options, &source_trailer, det_id_source_id0.as_deref());
source_trailer.insert("ID", finalized_id);
let source_trailer = source_trailer;
let classic_det_id: Option<(Vec<u8>, [u8; 16])> = if options.deterministic_id {
let pass1_part1 = build_pass1_part1(&part1);
let (pass1_bytes, ..) = do_write_pass(
plan,
renumber,
pdf,
&live,
&pass1_part1,
catalog_new_ref,
hint_stream_new_num,
total_count,
info_new_ref,
first_page_object_new_num,
&[],
0,
None,
&source_trailer,
&objstm_layout,
&relocation,
options,
true,
None,
)?; Some(crate::writer::compute_deterministic_id(
&pass1_bytes,
pass1_bytes.len() - 1,
&det_id_info_suffix,
det_id_source_id0.as_deref(),
))
} else {
None
};
let max_iters = 3;
let mut final_bytes: Vec<u8> = Vec::new();
let mut final_xref_offsets: BTreeMap<u32, usize> = BTreeMap::new();
let mut final_hint_stream_offset: usize = 0;
let mut final_hint_stream_obj_total_len: usize = 0;
let mut final_end_of_first_page_offset: usize = 0;
let mut final_last_xref_keyword_offset: usize = 0;
let mut final_last_xref_first_entry_offset: usize = 0;
let mut final_first_trailer_prev_range: std::ops::Range<usize> = 0..0;
let mut final_id_ranges: Vec<std::ops::Range<usize>> = Vec::new();
for iter in 0..max_iters {
let (
bytes,
xref_offsets,
hint_stream_offset,
hint_stream_obj_total_len,
end_of_first_page_offset,
last_xref_offset,
last_xref_first_entry_offset,
_probe_prev_range,
_probe_id_ranges,
) = do_write_pass(
plan,
renumber,
pdf,
&live,
&part1,
catalog_new_ref,
hint_stream_new_num,
total_count,
info_new_ref,
first_page_object_new_num,
¤t_hint_compressed,
current_hint_shared_s,
current_hint_outline_o,
&source_trailer,
&objstm_layout,
&relocation,
options,
false,
None,
)?;
let byte_lengths = compute_byte_lengths(
&xref_offsets,
last_xref_offset,
hint_stream_new_num,
renumber.param_dict_ref().number,
);
let part3_plain_len: u64 = plan
.part3_objects
.iter()
.filter(|orig| !objstm_layout.member_to_container.contains_key(orig))
.map(|orig| {
renumber
.new_for_original(*orig)
.and_then(|new_ref| byte_lengths.get(&new_ref.number).copied())
.unwrap_or(0) as u64
})
.sum();
let part3_container_len: u64 = objstm_layout
.part3
.iter()
.map(|c| byte_lengths.get(&c.container_new_num).copied().unwrap_or(0) as u64)
.sum();
let part3_byte_len: u64 = part3_plain_len + part3_container_len;
if plan.per_page_private_objects.len() != plan.page_hints.len() {
return Err(crate::Error::Unsupported(format!(
"linearization writer: per_page_private_objects length ({}) does not \
match page_hints length ({}) — plan invariant violated",
plan.per_page_private_objects.len(),
plan.page_hints.len()
)));
}
let non_page_owned = crate::linearization::hint_page::non_page_owned_containers(
plan,
&objstm_layout.member_to_container,
);
let plain_byte_len = |orig: &ObjectRef| -> u64 {
renumber
.new_for_original(*orig)
.and_then(|new_ref| byte_lengths.get(&new_ref.number).copied())
.unwrap_or(0) as u64
};
let per_page_byte_lengths: Vec<u64> = plan
.per_page_private_objects
.iter()
.enumerate()
.map(|(page_idx, privates)| {
if page_idx == 0 {
let part2_len: u64 = privates.iter().map(plain_byte_len).sum();
let part6_plain_len: u64 = plan
.part6_outline_objects
.iter()
.filter(|orig| !objstm_layout.member_to_container.contains_key(*orig))
.map(plain_byte_len)
.sum();
part2_len + part3_byte_len + part6_plain_len
} else {
let mut len = 0u64;
let mut containers: std::collections::BTreeSet<u32> =
std::collections::BTreeSet::new();
for orig in privates {
match objstm_layout.member_to_container.get(orig) {
Some(&(container_num, _)) => {
if !non_page_owned.contains(&container_num) {
containers.insert(container_num);
}
}
None => len += plain_byte_len(orig),
}
}
len + containers
.iter()
.map(|c| byte_lengths.get(c).copied().unwrap_or(0) as u64)
.sum::<u64>()
}
})
.collect();
let mut po_table = PageOffsetHintTable::from_plan(
plan,
renumber,
&objstm_layout.member_to_container,
&container_shared_rank,
&second_half_container_nums,
&open_document_container_nums,
);
let mut so_table = SharedObjectHintTable::from_plan(
plan,
renumber,
&objstm_layout.member_to_container,
&second_half_container_nums,
&open_document_container_nums,
);
po_table.header.location_of_first_page = hint_stream_offset as u64;
if !per_page_byte_lengths.is_empty() {
let least_pl = per_page_byte_lengths.iter().copied().min().unwrap_or(0);
let max_pl = per_page_byte_lengths.iter().copied().max().unwrap_or(0);
let bits_delta_pl = bits_needed(max_pl.saturating_sub(least_pl));
po_table.header.least_page_length = least_pl;
po_table.header.bits_page_length_delta = bits_delta_pl;
po_table.header.least_content_length = least_pl;
po_table.header.bits_content_length_delta = bits_delta_pl;
for (entry, &bl) in po_table
.entries
.iter_mut()
.zip(per_page_byte_lengths.iter())
{
let delta = bl.saturating_sub(least_pl);
entry.page_length_minus_least = delta;
entry.content_stream_length = delta;
}
}
if !plan.shared_hints.is_empty() {
let folded_shared = plan.canonical_shared_hints(
&objstm_layout.member_to_container,
renumber,
&second_half_container_nums,
&open_document_container_nums,
);
let shared_section_lens: Vec<u64> =
folded_shared
.iter()
.map(|h| -> Result<u64> {
if h.object_ref.generation == u16::MAX {
let len = byte_lengths.get(&h.object_ref.number).copied().ok_or_else(
|| {
crate::Error::Unsupported(format!(
"shared hint container (new #{}) has no probed byte length",
h.object_ref.number
))
},
)?;
return Ok(len as u64);
}
let new_ref = renumber.new_for_original(h.object_ref).ok_or_else(|| {
crate::Error::Unsupported(format!(
"shared hint object {} has no renumber entry",
h.object_ref
))
})?;
let len = byte_lengths.get(&new_ref.number).copied().ok_or_else(|| {
crate::Error::Unsupported(format!(
"shared hint object {} (new #{}) has no probed byte length",
h.object_ref, new_ref.number
))
})?;
Ok(len as u64)
})
.collect::<Result<Vec<_>>>()?;
let least = shared_section_lens.iter().copied().min().unwrap_or(0);
let max = shared_section_lens.iter().copied().max().unwrap_or(0);
so_table.header.least_length = least;
so_table.header.bits_length_delta = bits_needed(max.saturating_sub(least));
let first_part8_lookup_num = so_table.header.first_object_number;
if first_part8_lookup_num != 0 {
let first_part8_off = xref_offsets
.get(&first_part8_lookup_num)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"first Part-8 shared object (lookup #{first_part8_lookup_num}) \
has no probed offset"
))
})?;
so_table.header.location = first_part8_off
.checked_sub(hint_stream_obj_total_len)
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"linearization layout mismatch: first Part-8 shared object offset \
({first_part8_off}) is less than hint stream length \
({hint_stream_obj_total_len}); cannot compute shared-hint location"
))
})? as u64;
}
for (obj, &len) in so_table.objects.iter_mut().zip(&shared_section_lens) {
obj.length_minus_least = (len.saturating_sub(least)) as u32;
}
}
let outline_table = outline_info
.as_ref()
.map(|info| {
build_outline_hint_table(
info,
&xref_offsets,
&byte_lengths,
hint_stream_obj_total_len,
)
})
.transpose()?;
let new_hint_bytes = encode_hint_stream(&po_table, &so_table, outline_table.as_ref())?;
let new_compressed = new_hint_bytes.compressed;
let new_shared_s = new_hint_bytes.shared_section_offset_in_uncompressed;
let new_outline_o = new_hint_bytes.outline_section_offset_in_uncompressed;
final_xref_offsets = xref_offsets.clone();
final_hint_stream_offset = hint_stream_offset;
final_hint_stream_obj_total_len = hint_stream_obj_total_len;
final_end_of_first_page_offset = end_of_first_page_offset;
final_last_xref_keyword_offset = last_xref_offset;
final_last_xref_first_entry_offset = last_xref_first_entry_offset;
final_bytes = bytes;
let converged = hint_stream_convergence_len(&new_compressed, new_shared_s, new_outline_o)
== hint_stream_convergence_len(
¤t_hint_compressed,
current_hint_shared_s,
current_hint_outline_o,
);
current_hint_compressed = new_compressed;
current_hint_shared_s = new_shared_s;
current_hint_outline_o = new_outline_o;
if !converged && iter == max_iters - 1 {
return Err(crate::Error::Unsupported(format!(
"linearization writer: hint stream length did not converge \
within {max_iters} iterations (ObjStm-bearing layout = {}); \
refusing to emit a file with an inconsistent Page Offset \
Hint Table",
!objstm_layout.is_empty()
)));
}
if converged || iter == max_iters - 1 {
let mut det_id_closure;
let id_writer: Option<crate::object::TrailerIdWriter> = match &classic_det_id {
Some((id0, id1)) => {
let id0 = id0.clone();
let id1 = *id1;
det_id_closure = move |out: &mut Vec<u8>| {
crate::writer::write_deterministic_id_array(out, &id0, &id1)
};
Some(&mut det_id_closure)
}
None => None,
};
let (
bytes_final,
xref_offsets_final,
hint_off_final,
hint_len_final,
efp_final,
lxr_final,
lxr_first_final,
prev_range_final,
id_ranges_final,
) = do_write_pass(
plan,
renumber,
pdf,
&live,
&part1,
catalog_new_ref,
hint_stream_new_num,
total_count,
info_new_ref,
first_page_object_new_num,
¤t_hint_compressed,
current_hint_shared_s,
current_hint_outline_o,
&source_trailer,
&objstm_layout,
&relocation,
options,
false,
id_writer,
)?;
final_bytes = bytes_final;
final_xref_offsets = xref_offsets_final;
final_hint_stream_offset = hint_off_final;
final_hint_stream_obj_total_len = hint_len_final;
final_end_of_first_page_offset = efp_final;
final_last_xref_keyword_offset = lxr_final;
final_last_xref_first_entry_offset = lxr_first_final;
final_first_trailer_prev_range = prev_range_final;
final_id_ranges = id_ranges_final;
break;
}
}
if let (false, Some((id0, id1))) = (objstm_layout.is_empty(), &classic_det_id) {
patch_linearized_deterministic_id(&mut final_bytes, &final_id_ranges, id0, id1);
}
let file_length = final_bytes.len();
let page_count = plan.page_hints.len() as u32;
let offsets = LinearizedOffsets {
file_length,
hint_stream_offset: final_hint_stream_offset,
hint_stream_length: final_hint_stream_obj_total_len,
first_page_object_new_num,
end_of_first_page_offset: final_end_of_first_page_offset,
last_xref_keyword_offset: final_last_xref_keyword_offset,
last_xref_offset: final_last_xref_first_entry_offset.saturating_sub(1),
page_count,
part1_placeholders,
xref_offsets: final_xref_offsets,
first_trailer_prev_range: final_first_trailer_prev_range,
dict_writable_region: part1_dict_region,
};
Ok(LinearizedDocument {
bytes: final_bytes,
offsets,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::plan::LinearizationPlan;
use crate::object::MAX_INLINE_DEPTH;
use crate::writer::{WriteOptions, DETERMINISTIC_ID_ARRAY_LEN};
use crate::Pdf;
use std::io::Cursor;
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 = 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.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>>> {
Pdf::open(Cursor::new(tiny_pdf_bytes())).expect("tiny PDF should parse")
}
fn build_linearized() -> LinearizedDocument {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = open_tiny_pdf();
write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default())
.expect("write_linearized")
}
#[test]
fn write_linearized_succeeds() {
let _doc = build_linearized();
}
fn deep_pages_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let depth = crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH + 1;
let leaf_num = 2 + depth as u32;
let mut offsets: Vec<u64> = Vec::with_capacity(1 + depth + 1);
offsets.push(pdf.len() as u64);
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
for level in 0..depth {
let this_num = 2 + level as u32;
let next_ref = if level + 1 == depth {
leaf_num
} else {
this_num + 1
};
offsets.push(pdf.len() as u64);
pdf.extend_from_slice(
format!(
"{this_num} 0 obj\n<< /Type /Pages /Kids [{next_ref} 0 R] /Count 1 >>\nendobj\n"
)
.as_bytes(),
);
}
offsets.push(pdf.len() as u64);
pdf.extend_from_slice(
format!(
"{leaf_num} 0 obj\n<< /Type /Page /Parent {} 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
leaf_num - 1
)
.as_bytes(),
);
let total = offsets.len() + 1; let xref_start = pdf.len() as u64;
pdf.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
pdf.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn write_linearized_propagates_excessive_depth_error() {
let mut plan_pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut plan_pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let mut deep_pdf =
Pdf::open(Cursor::new(deep_pages_pdf_bytes())).expect("deep fixture parses");
let result = write_linearized(&plan, &renumber, &mut deep_pdf, &WriteOptions::default());
let is_depth_overflow = matches!(
&result,
Err(crate::Error::Unsupported(msg)) if msg.contains("page tree depth exceeds maximum of")
);
assert!(
is_depth_overflow,
"write_linearized must surface a too-deep /Pages tree as a \
depth-overflow Error::Unsupported, got: {result:?}"
);
}
#[test]
fn output_starts_with_pdf_header() {
let doc = build_linearized();
assert!(
doc.bytes.starts_with(b"%PDF-"),
"linearized output must start with %PDF-"
);
}
#[test]
fn output_contains_linearized_marker() {
let doc = build_linearized();
let needle = b"/Linearized 1";
assert!(
doc.bytes.windows(needle.len()).any(|w| w == needle),
"output must contain '/Linearized 1'"
);
}
#[test]
fn output_contains_xref_twice() {
let doc = build_linearized();
let needle = b"xref";
let count = doc
.bytes
.windows(needle.len())
.filter(|w| *w == needle)
.count();
assert!(
count >= 2,
"linearized PDF must have at least 2 xref sections, found {count}"
);
}
#[test]
fn file_length_matches_bytes_len() {
let doc = build_linearized();
assert_eq!(
doc.offsets.file_length,
doc.bytes.len(),
"file_length must equal bytes.len()"
);
}
#[test]
fn hint_stream_offset_after_part1() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let part1_len = Part1Bytes::build(&plan, &renumber, "1.4").byte_length();
let mut pdf2 = open_tiny_pdf();
let doc =
write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default()).expect("write");
assert!(
doc.offsets.hint_stream_offset >= part1_len,
"hint stream must come after Part 1 (Part 1 len={part1_len}, hint offset={})",
doc.offsets.hint_stream_offset
);
}
#[test]
fn end_of_first_page_after_hint_stream() {
let doc = build_linearized();
assert!(
doc.offsets.end_of_first_page_offset > doc.offsets.hint_stream_offset,
"/E must be after the hint stream"
);
}
#[test]
fn last_xref_offset_after_body() {
let doc = build_linearized();
assert!(
doc.offsets.last_xref_offset > doc.offsets.end_of_first_page_offset,
"/T (last xref) must be after the first-page section"
);
assert!(
doc.offsets.last_xref_offset < doc.offsets.file_length,
"/T must be within the file"
);
}
#[test]
fn page_count_is_one() {
let doc = build_linearized();
assert_eq!(
doc.offsets.page_count, 1,
"single-page fixture must report page_count = 1"
);
}
#[test]
fn xref_offsets_param_dict_is_at_byte_fifteen() {
let doc = build_linearized();
let param_dict_off = doc
.offsets
.xref_offsets
.values()
.copied()
.min()
.unwrap_or(usize::MAX);
assert_eq!(
param_dict_off, 15,
"the param dict (first object physically) must start at byte 15 \
(after %PDF-1.x and the binary marker)"
);
}
#[test]
fn xref_offsets_contains_hint_stream() {
let doc = build_linearized();
let hint_num = doc.offsets.xref_offsets.keys().copied().max().unwrap_or(0);
assert!(
hint_num >= 2,
"hint stream new number must be at least 2, got {hint_num}"
);
assert!(
doc.offsets.xref_offsets.contains_key(&hint_num),
"xref_offsets must contain hint stream entry"
);
}
#[test]
fn part1_placeholders_valid() {
let doc = build_linearized();
assert!(
doc.offsets.part1_placeholders.all_valid(),
"part1_placeholders must all be width-10 and disjoint"
);
}
#[test]
fn xref_offsets_point_to_obj_headers() {
let doc = build_linearized();
for (num, &offset) in &doc.offsets.xref_offsets {
let expected = format!("{num} 0 obj");
let window = &doc.bytes[offset..offset + expected.len()];
assert_eq!(
window,
expected.as_bytes(),
"offset for object {num} does not point to '{expected}'"
);
}
}
#[test]
fn part1_startxref_is_zero_and_final_startxref_points_at_first_page_xref() {
let doc = build_linearized();
let bytes = &doc.bytes;
let parse_startxref_value = |pos: usize| -> usize {
let needle = b"startxref\n";
let value_start = pos + needle.len();
let value_end = bytes[value_start..]
.iter()
.position(|&b| b == b'\n')
.map(|p| value_start + p)
.expect("startxref value must be terminated by newline");
let s = std::str::from_utf8(&bytes[value_start..value_end])
.expect("startxref value is UTF-8");
s.trim().parse().expect("startxref value must be decimal")
};
let needle = b"startxref\n";
let first_sxref_pos = bytes
.windows(needle.len())
.position(|w| w == needle)
.expect("linearized output must contain at least one startxref");
let part1_value: usize = parse_startxref_value(first_sxref_pos);
assert_eq!(
part1_value, 0,
"Part 1 first trailer startxref must be 0 (qpdf linearized convention), \
got {part1_value}"
);
let last_sxref_pos = bytes
.windows(needle.len())
.rposition(|w| w == needle)
.expect("linearized output must contain at least two startxref");
let final_value: usize = parse_startxref_value(last_sxref_pos);
let is_standalone_xref = |i: usize| -> bool {
&bytes[i..i + 4] == b"xref"
&& (i == 0 || bytes[i - 1].is_ascii_whitespace())
&& (i + 4 >= bytes.len() || bytes[i + 4].is_ascii_whitespace())
};
let first_xref_pos = (0..bytes.len().saturating_sub(3))
.find(|&i| is_standalone_xref(i))
.expect("linearized output must contain at least one standalone xref keyword");
let last_xref_pos = (0..bytes.len().saturating_sub(3))
.rev()
.find(|&i| is_standalone_xref(i))
.expect("linearized output must contain at least one standalone xref keyword");
assert!(
first_xref_pos < last_xref_pos,
"first-page xref ({first_xref_pos}) must precede the main xref ({last_xref_pos})"
);
assert_eq!(
final_value, first_xref_pos,
"final startxref ({final_value}) must equal the FIRST-PAGE xref keyword \
offset ({first_xref_pos}) — qpdf classic linearized layout"
);
}
#[test]
fn patch_part1_xref_fills_classic_entries_for_covered_objects() {
let count = 3u32;
let block = vec![b' '; count as usize * CLASSIC_XREF_ENTRY_WIDTH];
let mut bytes = block.clone();
let patch = Part1XrefPatch {
start_num: 3,
count,
data_range: 0..bytes.len(),
};
let mut offs = BTreeMap::new();
offs.insert(3, 15usize);
offs.insert(4, 533usize);
offs.insert(5, 601usize);
patch_part1_xref(&mut bytes, &patch, &offs).expect("happy path patches in place");
let expected = b"0000000015 00000 n \n0000000533 00000 n \n0000000601 00000 n \n";
assert_eq!(
&bytes[..],
&expected[..],
"entries must be 20-byte classic rows"
);
}
#[test]
fn patch_part1_xref_errors_when_a_covered_object_has_no_offset() {
let count = 2u32;
let mut bytes = vec![b' '; count as usize * CLASSIC_XREF_ENTRY_WIDTH];
let patch = Part1XrefPatch {
start_num: 3,
count,
data_range: 0..bytes.len(),
};
let mut offs = BTreeMap::new();
offs.insert(3, 15usize);
let err = patch_part1_xref(&mut bytes, &patch, &offs)
.expect_err("missing covered-object offset must be rejected");
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("has no offset")),
"expected a 'has no offset' Unsupported error, got {err:?}"
);
}
#[test]
fn patch_part1_xref_errors_on_out_of_bounds_range() {
let mut bytes = vec![b' '; 20];
let patch = Part1XrefPatch {
start_num: 3,
count: 2,
data_range: 0..40,
};
let offs = BTreeMap::new();
let err = patch_part1_xref(&mut bytes, &patch, &offs)
.expect_err("out-of-bounds patch range must be rejected");
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("out of bounds")),
"expected an 'out of bounds' Unsupported error, got {err:?}"
);
}
#[test]
fn patch_part1_xref_errors_on_payload_length_drift() {
let mut bytes = vec![b' '; 21];
let patch = Part1XrefPatch {
start_num: 3,
count: 2,
data_range: 0..21,
};
let mut offs = BTreeMap::new();
offs.insert(3, 15usize);
offs.insert(4, 533usize);
let err = patch_part1_xref(&mut bytes, &patch, &offs)
.expect_err("payload length drift must be rejected");
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("length drift")),
"expected a 'length drift' Unsupported error, got {err:?}"
);
}
#[test]
fn linearized_output_is_parseable() {
let doc = build_linearized();
Pdf::open(Cursor::new(doc.bytes))
.expect("linearized output must be parseable by Pdf::open");
}
fn catalog_backref_pdf_bytes() -> Vec<u8> {
let content = b"BT /F1 12 Tf 72 700 Td (hi) Tj ET\n";
let mut pdf: Vec<u8> = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0usize; 6];
offs[1] = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offs[2] = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
offs[3] = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> /X 1 0 R >>\nendobj\n",
);
offs[4] = pdf.len();
pdf.extend_from_slice(
format!("4 0 obj\n<< /Length {} >>\nstream\n", content.len()).as_bytes(),
);
pdf.extend_from_slice(content);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
offs[5] = pdf.len();
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref = pdf.len();
pdf.extend_from_slice(b"xref\n0 6\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
pdf.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes(),
);
pdf
}
#[test]
fn catalog_reachable_from_first_page_emitted_once() {
let mut pdf =
Pdf::open(Cursor::new(catalog_backref_pdf_bytes())).expect("backref PDF must parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
assert!(
plan.part2_objects.contains(&ObjectRef::new(1, 0)),
"test precondition: the catalog must land in part2 (page-0 private)"
);
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 =
Pdf::open(Cursor::new(catalog_backref_pdf_bytes())).expect("backref PDF must parse");
let mut doc = write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default())
.expect("write_linearized");
doc.back_patch().expect("back_patch");
let needle = b"/Type /Catalog";
let count = doc
.bytes
.windows(needle.len())
.filter(|w| *w == needle)
.count();
assert_eq!(
count, 1,
"catalog must be emitted exactly once, found {count}"
);
Pdf::open(Cursor::new(doc.bytes)).expect("output must be parseable");
}
fn catalog_backref_two_page_pdf_bytes() -> Vec<u8> {
let content = b"BT /F1 12 Tf 72 700 Td (hi) Tj ET\n";
let mut pdf: Vec<u8> = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = [0usize; 8];
offs[1] = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offs[2] = pdf.len();
pdf.extend_from_slice(
b"2 0 obj\n<< /Type /Pages /Kids [3 0 R 6 0 R] /Count 2 >>\nendobj\n",
);
offs[3] = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> /X 1 0 R >>\nendobj\n",
);
offs[4] = pdf.len();
pdf.extend_from_slice(
format!("4 0 obj\n<< /Length {} >>\nstream\n", content.len()).as_bytes(),
);
pdf.extend_from_slice(content);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
offs[5] = pdf.len();
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
offs[6] = pdf.len();
pdf.extend_from_slice(
b"6 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Contents 7 0 R /Resources << /Font << /F1 5 0 R >> >> /X 1 0 R >>\nendobj\n",
);
offs[7] = pdf.len();
pdf.extend_from_slice(
format!("7 0 obj\n<< /Length {} >>\nstream\n", content.len()).as_bytes(),
);
pdf.extend_from_slice(content);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
let xref = pdf.len();
pdf.extend_from_slice(b"xref\n0 8\n0000000000 65535 f \n");
for off in offs.iter().skip(1) {
pdf.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes(),
);
pdf
}
#[test]
fn shared_catalog_in_part3_emitted_once() {
let mut pdf = Pdf::open(Cursor::new(catalog_backref_two_page_pdf_bytes()))
.expect("two-page backref PDF must parse");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
assert!(
plan.part3_objects.contains(&ObjectRef::new(1, 0)),
"test precondition: the shared catalog must land in part3"
);
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = Pdf::open(Cursor::new(catalog_backref_two_page_pdf_bytes()))
.expect("two-page backref PDF must parse");
let mut doc = write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default())
.expect("write_linearized");
doc.back_patch().expect("back_patch");
let needle = b"/Type /Catalog";
let count = doc
.bytes
.windows(needle.len())
.filter(|w| *w == needle)
.count();
assert_eq!(
count, 1,
"shared catalog must be emitted exactly once, found {count}"
);
Pdf::open(Cursor::new(doc.bytes)).expect("output must be parseable");
}
fn linearize_deterministic(source_bytes: &[u8]) -> Vec<u8> {
linearize_deterministic_mode(source_bytes, crate::writer::ObjectStreamMode::default())
}
fn linearize_deterministic_mode(
source_bytes: &[u8],
object_streams: crate::writer::ObjectStreamMode,
) -> Vec<u8> {
let use_generate = object_streams == crate::writer::ObjectStreamMode::Generate;
let mut pdf = Pdf::open(Cursor::new(source_bytes.to_vec())).expect("source parses");
let plan = LinearizationPlan::from_pdf(&mut pdf, use_generate).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let opts = WriteOptions {
deterministic_id: true,
object_streams,
..WriteOptions::default()
};
let mut pdf2 = Pdf::open(Cursor::new(source_bytes.to_vec())).expect("source parses");
let mut doc = write_linearized(&plan, &renumber, &mut pdf2, &opts)
.expect("deterministic-id linearize must succeed");
doc.back_patch().expect("back_patch must succeed");
doc.bytes
}
const ID0_HEX: std::ops::Range<usize> = 2..34;
const ID1_HEX: std::ops::Range<usize> = 36..68;
fn collect_id_arrays(bytes: &[u8]) -> Vec<Vec<u8>> {
let needle = b"/ID [";
let mut out = Vec::new();
let mut i = 0usize;
while i + needle.len() <= bytes.len() {
if &bytes[i..i + needle.len()] == needle {
let open = i + needle.len() - 1; let close = bytes[open..]
.iter()
.position(|&b| b == b']')
.map(|p| open + p + 1)
.unwrap_or(bytes.len());
out.push(bytes[open..close].to_vec());
i = close;
} else {
i += 1;
}
}
out
}
fn first_id_array(bytes: &[u8]) -> Vec<u8> {
collect_id_arrays(bytes)
.into_iter()
.next()
.expect("output must contain an /ID array")
}
fn tiny_pdf_with(id_entry: &str, info_obj: Option<&str>) -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = Vec::new();
offs.push(pdf.len() as u64);
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offs.push(pdf.len() as u64);
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
offs.push(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 mut info_ref_entry = String::new();
if let Some(info) = info_obj {
offs.push(pdf.len() as u64);
pdf.extend_from_slice(format!("4 0 obj\n{info}\nendobj\n").as_bytes());
info_ref_entry = " /Info 4 0 R".to_string();
}
let size = offs.len() + 1;
let xref_start = pdf.len() as u64;
let mut xref = format!("xref\n0 {size}\n0000000000 65535 f \n");
for off in &offs {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!(
"trailer\n<< /Size {size} /Root 1 0 R{info_ref_entry} {id_entry} >>\nstartxref\n{xref_start}\n%%EOF\n",
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn deterministic_id_linearized_is_self_stable() {
let src = tiny_pdf_bytes();
let a = linearize_deterministic(&src);
let b = linearize_deterministic(&src);
assert_eq!(
a, b,
"deterministic-id linearized output must be byte-identical across runs"
);
Pdf::open(Cursor::new(a.clone())).expect("deterministic-id output must reparse");
crate::linearization::check_linearization_bytes(&a)
.expect("deterministic-id linearized output must pass the linearization checker");
}
#[test]
fn deterministic_id_linearized_all_ids_match() {
let out = linearize_deterministic_mode(
&tiny_pdf_bytes(),
crate::writer::ObjectStreamMode::Generate,
);
let ids = collect_id_arrays(&out);
assert_eq!(
ids.len(),
2,
"xref-stream linearized output must carry /ID in both the \
first-page and main xref-stream dicts"
);
let first = &ids[0];
assert!(
ids.iter().all(|id| id == first),
"every /ID site in one linearized file must be byte-equal: {ids:?}"
);
assert_eq!(first.len(), DETERMINISTIC_ID_ARRAY_LEN);
assert_ne!(
first, b"[<00000000000000000000000000000000><00000000000000000000000000000000>]",
"placeholder must be patched"
);
crate::linearization::check_linearization_bytes(&out).expect(
"deterministic-id xref-stream linearized output must pass the linearization checker",
);
}
fn tiny_pdf_with_placeholder_in_content() -> Vec<u8> {
let placeholder = b"[<00000000000000000000000000000000><00000000000000000000000000000000>]";
assert_eq!(placeholder.len(), DETERMINISTIC_ID_ARRAY_LEN);
let mut content = Vec::new();
content.extend_from_slice(b"BT /F1 12 Tf (");
content.extend_from_slice(placeholder);
content.extend_from_slice(b") Tj ET\n");
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let mut offs = Vec::new();
offs.push(pdf.len() as u64);
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offs.push(pdf.len() as u64);
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
offs.push(pdf.len() as u64);
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>\nendobj\n",
);
offs.push(pdf.len() as u64);
pdf.extend_from_slice(
format!("4 0 obj\n<< /Length {} >>\nstream\n", content.len()).as_bytes(),
);
pdf.extend_from_slice(&content);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
let size = offs.len() + 1;
let xref_start = pdf.len() as u64;
let mut xref = format!("xref\n0 {size}\n0000000000 65535 f \n");
for off in &offs {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size {size} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n",);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn deterministic_id_linearized_does_not_clobber_body_placeholder() {
let placeholder: &[u8] =
b"[<00000000000000000000000000000000><00000000000000000000000000000000>]";
let src = tiny_pdf_with_placeholder_in_content();
assert!(
src.windows(placeholder.len()).any(|w| w == placeholder),
"test fixture must embed the placeholder in body content"
);
let out = linearize_with(&src, |o| {
o.deterministic_id = true;
o.compress_streams = crate::writer::CompressStreams::No;
});
assert!(
out.windows(placeholder.len()).any(|w| w == placeholder),
"body content placeholder must be preserved, not mistaken for /ID"
);
let ids = collect_id_arrays(&out);
assert!(!ids.is_empty(), "output must carry at least one /ID array");
let first = &ids[0];
assert!(
ids.iter().all(|id| id == first),
"every /ID site must be byte-equal: {ids:?}"
);
assert_eq!(first.len(), DETERMINISTIC_ID_ARRAY_LEN);
assert_ne!(
first.as_slice(),
placeholder,
"/ID must be patched away from the all-zero placeholder"
);
let out2 = linearize_with(&src, |o| {
o.deterministic_id = true;
o.compress_streams = crate::writer::CompressStreams::No;
});
assert_eq!(out, out2, "output must be byte-identical across runs");
crate::linearization::check_linearization_bytes(&out)
.expect("output must pass the linearization checker");
}
#[test]
fn linearized_compress_mode_refilters_body_stream() {
let raw_content: &[u8] =
b"[<00000000000000000000000000000000><00000000000000000000000000000000>]";
let src = tiny_pdf_with_placeholder_in_content();
let out = linearize_with(&src, |o| o.deterministic_id = true);
assert!(
!out.windows(raw_content.len()).any(|w| w == raw_content),
"compress mode must re-encode the body stream, dropping the raw literal"
);
let dict_marker: &[u8] = b"/Filter /FlateDecode >>\nstream\n";
assert!(
out.windows(dict_marker.len()).any(|w| w == dict_marker),
"compress mode must emit a re-filtered /FlateDecode content stream \
in qpdf key order"
);
crate::linearization::check_linearization_bytes(&out)
.expect("compress-mode linearized output must pass the checker");
let mut reopened = Pdf::open(Cursor::new(out.clone())).expect("output must reparse");
let refs = reopened.live_object_refs();
let decoded_any_match = refs.into_iter().any(|r| {
reopened
.resolve(r)
.ok()
.and_then(|o| o.into_stream())
.and_then(|stream| {
crate::filters::decode_stream_data(&stream.dict, &stream.data).ok()
})
.map(|d| d.windows(raw_content.len()).any(|w| w == raw_content))
.unwrap_or(false)
});
assert!(
decoded_any_match,
"the re-encoded content stream must decode back to the original payload"
);
}
#[test]
fn linearized_preserve_mode_emits_body_stream_verbatim() {
let raw_content: &[u8] =
b"[<00000000000000000000000000000000><00000000000000000000000000000000>]";
let src = tiny_pdf_with_placeholder_in_content();
let out = linearize_with(&src, |o| {
o.deterministic_id = true;
o.stream_data = Some(crate::writer::StreamDataMode::Preserve);
});
assert!(
out.windows(raw_content.len()).any(|w| w == raw_content),
"preserve mode must emit the body content stream payload verbatim"
);
crate::linearization::check_linearization_bytes(&out)
.expect("preserve-mode linearized output must pass the checker");
}
fn tiny_pdf_with_external_file_lone_flate_stream(payload: &[u8]) -> Vec<u8> {
let mut enc_dict = Dictionary::new();
enc_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let compressed =
crate::filters::encode_stream_data(&enc_dict, payload).expect("flate encode");
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.5\n");
let mut offs = Vec::new();
offs.push(pdf.len() as u64);
pdf.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Metadata 5 0 R >>\nendobj\n",
);
offs.push(pdf.len() as u64);
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
offs.push(pdf.len() as u64);
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>\nendobj\n",
);
offs.push(pdf.len() as u64);
let content: &[u8] = b"BT /F1 12 Tf (hi) Tj ET\n";
pdf.extend_from_slice(
format!("4 0 obj\n<< /Length {} >>\nstream\n", content.len()).as_bytes(),
);
pdf.extend_from_slice(content);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
offs.push(pdf.len() as u64);
let stream_header = format!(
"5 0 obj\n<< /Filter /FlateDecode /F (external.bin) /FFilter /FlateDecode \
/FDecodeParms << /Predictor 1 >> /Length {} >>\nstream\n",
compressed.len()
);
pdf.extend_from_slice(stream_header.as_bytes());
pdf.extend_from_slice(&compressed);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
let size = offs.len() + 1;
let xref_start = pdf.len() as u64;
let mut xref = format!("xref\n0 {size}\n0000000000 65535 f \n");
for off in &offs {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size {size} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn linearized_compress_mode_reencodes_external_file_lone_flate_stream() {
let payload: &[u8] = b"flpdf linearized external-file lone-flate exclusion payload";
let src = tiny_pdf_with_external_file_lone_flate_stream(payload);
let out = linearize_with(&src, |o| o.deterministic_id = true);
crate::linearization::check_linearization_bytes(&out)
.expect("output must pass the linearization checker");
let mut reopened = Pdf::open(Cursor::new(out)).expect("output must reparse");
let refs = reopened.live_object_refs();
let stream = refs
.into_iter()
.find_map(|r| {
let stream = reopened.resolve(r).ok()?.into_stream()?;
let decoded =
crate::filters::decode_stream_data(&stream.dict, &stream.data).ok()?;
decoded
.windows(payload.len())
.any(|w| w == payload)
.then_some(stream)
})
.expect(
"the external-file stream's decoded payload must be embedded in the output \
(proving it was re-encoded, not preserved verbatim)",
);
for key in ["F", "FFilter", "FDecodeParms"] {
assert!(
stream.dict.get(key).is_none(),
"re-encoded external-file stream must not carry /{key}"
);
}
assert!(
is_lone_flate(stream.dict.get("Filter")),
"re-encoded external-file stream must declare a lone /FlateDecode filter"
);
}
#[test]
fn deterministic_id_linearized_xref_stream_is_self_stable() {
let src = tiny_pdf_bytes();
let a = linearize_deterministic_mode(&src, crate::writer::ObjectStreamMode::Generate);
let b = linearize_deterministic_mode(&src, crate::writer::ObjectStreamMode::Generate);
assert_eq!(a, b, "xref-stream deterministic-id output must be stable");
}
#[test]
fn deterministic_id_linearized_depends_on_content() {
let out_a = linearize_deterministic(&tiny_pdf_bytes());
let mut alt = tiny_pdf_bytes();
let from = b"[0 0 612 792]";
let to = b"[0 0 200 200]";
let pos = alt
.windows(from.len())
.position(|w| w == from)
.expect("MediaBox present");
alt[pos..pos + from.len()].copy_from_slice(to);
let out_b = linearize_deterministic(&alt);
assert_ne!(
first_id_array(&out_a),
first_id_array(&out_b),
"different content must yield a different deterministic /ID"
);
}
#[test]
fn deterministic_id_linearized_preserves_source_permanent_id() {
let id_entry =
"/ID [<0102030405060708090a0b0c0d0e0f10> <ffffffffffffffffffffffffffffffff>]";
let out = linearize_deterministic(&tiny_pdf_with(id_entry, None));
let id = first_id_array(&out);
assert_eq!(
&id[ID0_HEX], b"0102030405060708090a0b0c0d0e0f10",
"source /ID[0] must be preserved as the permanent identifier"
);
assert_ne!(&id[ID0_HEX], &id[ID1_HEX], "changing /ID must differ");
}
#[test]
fn deterministic_id_linearized_preserves_non_16_byte_source_id() {
let id_entry = format!("/ID [<{}><{}>]", "aa".repeat(20), "bb".repeat(16));
let out = linearize_deterministic(&tiny_pdf_with(&id_entry, None));
let id = first_id_array(&out);
let id_str = String::from_utf8_lossy(&id);
let lt0 = id.iter().position(|&b| b == b'<').expect("id0 opening '<'");
let gt0 = id[lt0..]
.iter()
.position(|&b| b == b'>')
.map(|p| lt0 + p)
.expect("id0 closing '>'");
let id0_hex = &id[lt0 + 1..gt0];
let lt1 = id[gt0..]
.iter()
.position(|&b| b == b'<')
.map(|p| gt0 + p)
.expect("id1 opening '<'");
let gt1 = id[lt1..]
.iter()
.position(|&b| b == b'>')
.map(|p| lt1 + p)
.expect("id1 closing '>'");
let id1_hex = &id[lt1 + 1..gt1];
assert_eq!(
id0_hex,
"aa".repeat(20).as_bytes(),
"linearized /ID[0] must be the 20-byte source id preserved verbatim; got {id_str:?}"
);
assert_eq!(
id1_hex.len(),
32,
"linearized /ID[1] must be a 16-byte (32 hex) digest; got {id_str:?}"
);
assert_ne!(
id0_hex, id1_hex,
"linearized /ID[0] and /ID[1] must differ; got {id_str:?}"
);
}
#[test]
fn deterministic_id_linearized_id0_equals_id1_without_source_id() {
let out = linearize_deterministic(&tiny_pdf_with("/ID []", None));
let id = first_id_array(&out);
assert_eq!(
&id[ID0_HEX], &id[ID1_HEX],
"without a source /ID[0], /ID[0] must equal /ID[1]"
);
}
#[test]
fn deterministic_id_linearized_info_seed_changes_id() {
let with_info =
linearize_deterministic(&tiny_pdf_with("/ID []", Some("<< /Producer (alpha) >>")));
let with_other =
linearize_deterministic(&tiny_pdf_with("/ID []", Some("<< /Producer (bravo) >>")));
assert_ne!(
first_id_array(&with_info),
first_id_array(&with_other),
"/Info string values must feed the deterministic /ID seed"
);
}
#[test]
fn deterministic_id_linearized_no_info_boundary() {
let a = linearize_deterministic(&tiny_pdf_with("/ID []", None));
let b = linearize_deterministic(&tiny_pdf_with("/ID []", None));
assert_eq!(a, b, "no-/Info input must still be self-stable");
let id = first_id_array(&a);
assert_eq!(id.len(), DETERMINISTIC_ID_ARRAY_LEN);
}
#[test]
fn first_page_object_new_num_matches_xref_offsets() {
let doc = build_linearized();
let num = doc.offsets.first_page_object_new_num;
assert!(
doc.offsets.xref_offsets.contains_key(&num),
"first_page_object_new_num ({num}) must be present in xref_offsets"
);
let offset = doc.offsets.xref_offsets[&num];
let expected = format!("{num} 0 obj");
let window = &doc.bytes[offset..offset + expected.len()];
assert_eq!(
window,
expected.as_bytes(),
"offset for first_page_object_new_num ({num}) must point to '{expected}'"
);
}
#[test]
fn first_page_object_new_num_equals_renumber_of_page_ref() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let expected_num = renumber
.new_for_original(plan.page_hints[0].page_ref)
.expect("page_hints[0].page_ref must have a renumber entry")
.number;
let mut pdf2 = open_tiny_pdf();
let doc = write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default())
.expect("write_linearized");
assert_eq!(
doc.offsets.first_page_object_new_num,
expected_num,
"first_page_object_new_num must equal renumber.new_for_original(page_hints[0].page_ref)"
);
}
#[test]
fn compute_byte_lengths_uses_dynamic_param_dict_slot() {
let mut offs: BTreeMap<u32, usize> = BTreeMap::new();
offs.insert(1, 100);
offs.insert(3, 10);
offs.insert(5, 50);
offs.insert(6, 200);
let lengths = compute_byte_lengths(&offs, 400, 5, 3);
assert!(!lengths.contains_key(&3));
assert_eq!(lengths.get(&1).copied(), Some(100));
assert_eq!(lengths.get(&6).copied(), Some(200));
}
fn nested_arrays(depth: usize) -> Object {
let mut o = Object::Null;
for _ in 0..depth {
o = Object::Array(vec![o]);
}
o
}
#[test]
fn renumber_object_errors_on_excessive_nesting() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let live = BTreeSet::new();
let err = renumber_object(&nested_arrays(MAX_INLINE_DEPTH + 5), 0, &renumber, &live);
assert!(matches!(err, Err(crate::Error::Unsupported(_))));
}
#[test]
fn renumber_object_accepts_nesting_up_to_the_limit() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let original = ObjectRef::new(1, 0);
let expected = renumber
.new_for_original(original)
.expect("catalog must have a renumber entry");
let mut obj = Object::Array(vec![Object::Reference(original)]);
for _ in 0..(MAX_INLINE_DEPTH - 1) {
obj = Object::Array(vec![obj]);
}
let live = BTreeSet::new();
let out =
renumber_object(&obj, 0, &renumber, &live).expect("in-limit nesting must succeed");
let mut cur = &out;
loop {
match cur {
Object::Array(items) if items.len() == 1 => cur = &items[0],
other => {
assert_eq!(other, &Object::Reference(expected));
break;
}
}
}
}
#[test]
fn renumber_object_errors_on_live_ref_absent_from_map() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let ghost = ObjectRef::new(99, 0);
assert!(
renumber.new_for_original(ghost).is_none(),
"test premise: ghost is not in the map"
);
let mut live = BTreeSet::new();
live.insert(ghost); let obj = Object::Array(vec![Object::Reference(ghost)]);
let err = renumber_object(&obj, 0, &renumber, &live);
assert!(
matches!(err, Err(crate::Error::Unsupported(_))),
"a live, unmapped reference must error, got {err:?}"
);
}
#[test]
fn renumber_object_inlines_null_for_missing_ref_in_array() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let missing = ObjectRef::new(99, 0);
let live = BTreeSet::new(); let obj = Object::Array(vec![Object::Reference(missing)]);
let out = renumber_object(&obj, 0, &renumber, &live);
assert!(
matches!(&out, Ok(Object::Array(items)) if matches!(items.as_slice(), [Object::Null])),
"missing-xref array element must inline null, got {out:?}"
);
}
fn linearize_with(source_bytes: &[u8], configure: impl FnOnce(&mut WriteOptions)) -> Vec<u8> {
let mut pdf = Pdf::open(Cursor::new(source_bytes.to_vec())).expect("source parses");
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let mut opts = WriteOptions::default();
configure(&mut opts);
let mut pdf2 = Pdf::open(Cursor::new(source_bytes.to_vec())).expect("source parses");
let mut doc =
write_linearized(&plan, &renumber, &mut pdf2, &opts).expect("write_linearized");
doc.back_patch().expect("back_patch must succeed");
doc.bytes
}
#[test]
fn deterministic_id_linearized_classic_main_trailer_has_id() {
let out = linearize_deterministic(&tiny_pdf_bytes());
let ids = collect_id_arrays(&out);
assert_eq!(
ids.len(),
2,
"classic-table linearized output must carry /ID in both the \
Part-1 and main trailers, got {ids:?}"
);
let first = &ids[0];
assert!(
ids.iter().all(|id| id == first),
"every /ID site in one linearized file must be byte-equal: {ids:?}"
);
assert_eq!(first.len(), DETERMINISTIC_ID_ARRAY_LEN);
let reopened = Pdf::open(Cursor::new(out.clone())).expect("output must reparse");
let trailer_id = reopened
.trailer()
.get("ID")
.expect("main trailer must carry /ID after linearize --deterministic-id");
let mut serialized = Vec::new();
crate::object::write_id_style_value(&mut serialized, trailer_id);
assert_eq!(
serialized.as_slice(),
first.as_slice(),
"reader-visible main-trailer /ID must equal the Part-1 trailer /ID"
);
crate::linearization::check_linearization_bytes(&out)
.expect("output must pass the linearization checker");
}
#[test]
fn deterministic_id_linearized_classic_direct_writes_no_placeholder() {
let placeholder: &[u8] =
b"[<00000000000000000000000000000000><00000000000000000000000000000000>]";
let out = linearize_deterministic(&tiny_pdf_bytes());
assert!(
!out.windows(placeholder.len()).any(|w| w == placeholder),
"classic deterministic-id output must never emit the all-zero /ID \
placeholder (it direct-writes the real identifier)"
);
let ids = collect_id_arrays(&out);
assert_eq!(
ids.len(),
2,
"classic path emits /ID in the Part-1 and main trailers, got {ids:?}"
);
let first = &ids[0];
assert!(
ids.iter().all(|id| id == first),
"every /ID site must be byte-equal: {ids:?}"
);
assert_eq!(first.len(), DETERMINISTIC_ID_ARRAY_LEN);
assert_ne!(
first.as_slice(),
placeholder,
"the emitted /ID must be the real digest, not the placeholder"
);
let again = linearize_deterministic(&tiny_pdf_bytes());
assert_eq!(out, again, "deterministic output must be byte-stable");
crate::linearization::check_linearization_bytes(&out)
.expect("output must pass the linearization checker");
}
#[test]
fn static_id_linearized_main_trailer_visible_to_reader() {
let out = linearize_with(&tiny_pdf_bytes(), |o| o.static_id = true);
let reopened = Pdf::open(Cursor::new(out.clone())).expect("output must reparse");
assert!(
reopened.trailer().get("ID").is_some(),
"static-id linearized output must carry /ID in the reader-visible main trailer"
);
crate::linearization::check_linearization_bytes(&out)
.expect("static-id linearized output must pass the linearization checker");
}
#[test]
fn deterministic_id_linearized_rejects_encrypt() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let opts = WriteOptions {
deterministic_id: true,
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
b"user".to_vec(),
b"owner".to_vec(),
)),
..WriteOptions::default()
};
let mut pdf2 = open_tiny_pdf();
let err = write_linearized(&plan, &renumber, &mut pdf2, &opts).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m)
if m == "the deterministic-id option is incompatible with encrypted output files"),
"got {err:?}"
);
}
#[test]
fn deterministic_id_linearized_rejects_static_id() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let opts = WriteOptions {
deterministic_id: true,
static_id: true,
..WriteOptions::default()
};
let mut pdf2 = open_tiny_pdf();
let err = write_linearized(&plan, &renumber, &mut pdf2, &opts).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m)
if m == "deterministic_id and static_id are mutually exclusive"),
"got {err:?}"
);
}
#[test]
fn deterministic_id_linearized_rejects_copy_encryption() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let opts = WriteOptions {
deterministic_id: true,
copy_encryption: Some(crate::encrypt_setup::CopyEncryptionSource {
encrypt_dict: Dictionary::new(),
file_key: Vec::new(),
id0: Vec::new(),
object_key_alg: crate::ObjectKeyAlg::Aes,
}),
..WriteOptions::default()
};
let mut pdf2 = open_tiny_pdf();
let err = write_linearized(&plan, &renumber, &mut pdf2, &opts).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m)
if m == "the deterministic-id option is incompatible with encrypted output files"),
"got {err:?}"
);
}
#[test]
fn deterministic_id_linearized_without_encryption_succeeds() {
let mut pdf = open_tiny_pdf();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).expect("plan");
let renumber = RenumberMap::from_plan(&plan);
let opts = WriteOptions {
deterministic_id: true,
..WriteOptions::default()
};
let mut pdf2 = open_tiny_pdf();
write_linearized(&plan, &renumber, &mut pdf2, &opts)
.expect("deterministic-id without encryption must succeed");
}
#[test]
fn append_hint_stream_object_emits_qpdf_key_order() {
let payload = vec![0u8; 53];
let mut bytes = Vec::new();
let offset =
append_hint_stream_object(&mut bytes, ObjectRef::new(9, 0), &payload, 46, None);
assert_eq!(offset, 0, "emitter returns its start offset");
let mut expected = Vec::new();
expected
.extend_from_slice(b"9 0 obj\n<< /Filter /FlateDecode /S 46 /Length 53 >>\nstream\n");
expected.extend_from_slice(&payload);
expected.extend_from_slice(b"\nendstream\nendobj\n");
assert_eq!(bytes, expected, "hint-stream object framing + key order");
}
#[test]
fn build_outline_hint_table_uses_adjusted_offset_and_consecutive_lengths() {
let info = OutlineHintInfo {
first_object: 3,
nobjects: 2,
};
let xref_offsets = BTreeMap::from([(3u32, 500usize), (4u32, 560usize)]);
let byte_lengths = BTreeMap::from([(3u32, 60usize), (4u32, 70usize), (5u32, 999usize)]);
let table = build_outline_hint_table(&info, &xref_offsets, &byte_lengths, 144).unwrap();
assert_eq!(table.first_object, 3);
assert_eq!(table.first_object_offset, 500 - 144);
assert_eq!(table.nobjects, 2);
assert_eq!(table.group_length, 60 + 70);
}
#[test]
fn build_outline_hint_table_errors_when_first_unit_has_no_probed_offset() {
let info = OutlineHintInfo {
first_object: 7,
nobjects: 1,
};
let err =
build_outline_hint_table(&info, &BTreeMap::new(), &BTreeMap::new(), 144).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("no probed offset")),
"expected 'no probed offset' Unsupported error, got {err:?}"
);
}
#[test]
fn build_outline_hint_table_errors_when_offset_below_hint_stream_length() {
let info = OutlineHintInfo {
first_object: 3,
nobjects: 1,
};
let xref_offsets = BTreeMap::from([(3u32, 100usize)]);
let err =
build_outline_hint_table(&info, &xref_offsets, &BTreeMap::new(), 144).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("less than the hint")),
"expected 'less than the hint stream length' Unsupported error, got {err:?}"
);
}
#[test]
fn build_outline_hint_table_missing_byte_length_counts_as_zero() {
let info = OutlineHintInfo {
first_object: 10,
nobjects: 3,
};
let xref_offsets = BTreeMap::from([(10u32, 1000usize)]);
let byte_lengths = BTreeMap::from([(10u32, 40usize), (12u32, 5usize)]); let table = build_outline_hint_table(&info, &xref_offsets, &byte_lengths, 200).unwrap();
assert_eq!(table.first_object_offset, 1000 - 200);
assert_eq!(table.group_length, 45);
}
#[test]
#[cfg(target_pointer_width = "64")]
fn build_outline_hint_table_errors_when_offset_exceeds_32_bits() {
let info = OutlineHintInfo {
first_object: 3,
nobjects: 1,
};
let huge = (u32::MAX as usize) + 100; let xref_offsets = BTreeMap::from([(3u32, huge)]);
let err = build_outline_hint_table(&info, &xref_offsets, &BTreeMap::new(), 0).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("exceeds the")),
"expected 'exceeds the 32-bit ...' Unsupported error, got {err:?}"
);
}
}