use std::collections::BTreeMap;
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;
use crate::linearization::part1::{Part1Bytes, Part1Placeholders};
use crate::linearization::plan::LinearizationPlan;
use crate::linearization::renumber::RenumberMap;
use crate::writer::{effective_pdf_version, WriteOptions, QPDF_STATIC_ID};
use crate::{Dictionary, Object, ObjectRef, Pdf, Result, Stream};
#[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>,
}
#[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, renumber: &RenumberMap) -> Result<Object> {
match object {
Object::Reference(r) => match renumber.new_for_original(*r) {
Some(new_ref) => Ok(Object::Reference(new_ref)),
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, renumber)?);
}
Ok(Object::Array(renumbered))
}
Object::Dictionary(dict) => {
let mut new_dict = Dictionary::new();
for (key, value) in dict.iter() {
new_dict.insert(key, renumber_object(value, renumber)?);
}
Ok(Object::Dictionary(new_dict))
}
Object::Stream(stream) => {
let mut new_dict = Dictionary::new();
for (key, value) in stream.dict.iter() {
new_dict.insert(key, renumber_object(value, renumber)?);
}
Ok(Object::Stream(Stream::new(new_dict, stream.data.clone())))
}
_ => Ok(object.clone()),
}
}
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
}
#[allow(clippy::too_many_arguments)]
fn write_part1_xref_and_trailer(
bytes: &mut Vec<u8>,
param_dict_offset: usize,
param_dict_obj_number: u32,
total_object_count: u32,
catalog_new_ref: ObjectRef,
info_new_ref: Option<ObjectRef>,
options: &WriteOptions,
source_trailer: &Dictionary,
) -> (usize, std::ops::Range<usize>) {
let xref_offset = bytes.len();
bytes.extend_from_slice(format!("xref\n{param_dict_obj_number} 1\n").as_bytes());
bytes.extend_from_slice(format!("{:010} 00000 n \n", param_dict_offset).as_bytes());
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();
let pi_bytes = Object::String(QPDF_STATIC_ID.to_vec());
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(),
};
let id_array = Object::Array(vec![first_id, pi_bytes]);
bytes.extend_from_slice(b" /ID ");
id_array.write_pdf(bytes);
} else {
match source_trailer.get("ID") {
Some(id_obj) => {
bytes.extend_from_slice(b" /ID ");
id_obj.write_pdf(bytes);
}
None => {
}
}
}
bytes.extend_from_slice(b" >>");
bytes.extend_from_slice(b"\nstartxref\n0\n%%EOF\n");
(xref_offset, prev_value_start..prev_value_end)
}
fn write_main_xref_and_trailer(
bytes: &mut Vec<u8>,
xref_offsets: &BTreeMap<u32, usize>,
total_count: u32, catalog_new_ref: ObjectRef,
info_new_ref: Option<ObjectRef>,
) -> (usize, usize) {
let xref_start = bytes.len();
let xref_header = format!("xref\n0 {}\n", total_count);
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..total_count {
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"),
}
}
let mut trailer = Dictionary::new();
trailer.insert("Size", Object::Integer(i64::from(total_count)));
trailer.insert("Root", Object::Reference(catalog_new_ref));
if let Some(info_ref) = info_new_ref {
trailer.insert("Info", Object::Reference(info_ref));
}
bytes.extend_from_slice(b"trailer\n");
trailer.write_pdf(bytes);
bytes.extend_from_slice(format!("\nstartxref\n{}\n%%EOF\n", xref_start).as_bytes());
(xref_start, xref_first_entry_offset)
}
fn build_hint_stream_object(
new_ref: ObjectRef,
compressed_payload: &[u8],
shared_section_offset: usize,
) -> Object {
let compressed_len = compressed_payload.len();
let mut hint_dict = Dictionary::new();
hint_dict.insert("Length", Object::Integer(compressed_len as i64));
hint_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
hint_dict.insert("S", Object::Integer(shared_section_offset as i64));
let _ = new_ref; Object::Stream(Stream::new(hint_dict, compressed_payload.to_vec()))
}
#[allow(clippy::too_many_arguments, clippy::type_complexity)]
fn do_write_pass<R: Read + Seek>(
plan: &LinearizationPlan,
renumber: &RenumberMap,
pdf: &mut Pdf<R>,
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,
options: &WriteOptions,
source_trailer: &Dictionary,
) -> 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
)> {
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 (_p1_xref_offset, first_trailer_prev_range) = write_part1_xref_and_trailer(
&mut bytes,
param_dict_absolute_offset,
param_dict_obj_number,
total_count,
catalog_new_ref,
info_new_ref,
options,
source_trailer,
);
let hint_new_ref = ObjectRef::new(hint_stream_new_num, 0);
let hint_obj =
build_hint_stream_object(hint_new_ref, hint_compressed, hint_shared_section_offset);
let hint_stream_offset = append_object(&mut bytes, hint_new_ref, &hint_obj);
xref_offsets.insert(hint_stream_new_num, hint_stream_offset);
let hint_stream_obj_total_len = bytes.len() - hint_stream_offset;
for original_ref in &plan.part2_objects {
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(*original_ref)?;
let renumbered = renumber_object(&object, renumber)?;
let offset = append_object(&mut bytes, new_ref, &renumbered);
xref_offsets.insert(new_ref.number, offset);
}
for original_ref in &plan.part3_objects {
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(*original_ref)?;
let renumbered = renumber_object(&object, renumber)?;
let offset = append_object(&mut bytes, new_ref, &renumbered);
xref_offsets.insert(new_ref.number, offset);
}
let end_of_first_page_offset = bytes.len();
for original_ref in &plan.part4_objects() {
let Some(new_ref) = renumber.new_for_original(*original_ref) else {
return Err(crate::Error::Unsupported(format!(
"part4 object {} has no renumber entry",
original_ref
)));
};
let object = pdf.resolve(*original_ref)?;
let renumbered = renumber_object(&object, renumber)?;
let offset = append_object(&mut bytes, new_ref, &renumbered);
xref_offsets.insert(new_ref.number, offset);
}
let (last_xref_offset, last_xref_first_entry_offset) = write_main_xref_and_trailer(
&mut bytes,
&xref_offsets,
total_count,
catalog_new_ref,
info_new_ref,
);
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,
))
}
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
}
}
pub fn write_linearized<R: Read + Seek>(
plan: &LinearizationPlan,
renumber: &RenumberMap,
pdf: &mut Pdf<R>,
options: &WriteOptions,
) -> Result<LinearizedDocument> {
let eff_version = effective_pdf_version(pdf.version(), options, true);
let part1 = Part1Bytes::build(plan, renumber, eff_version);
let part1_placeholders = part1.placeholders.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 total_count: u32 = renumber.len() as u32 + 1;
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 po_table_initial = PageOffsetHintTable::from_plan(plan, renumber);
let so_table_initial = SharedObjectHintTable::from_plan(plan, renumber);
let hint_bytes_initial = encode_hint_stream(&po_table_initial, &so_table_initial)?;
let mut current_hint_compressed = hint_bytes_initial.compressed;
let mut current_hint_shared_s = hint_bytes_initial.shared_section_offset_in_uncompressed;
let source_trailer = pdf.trailer().clone();
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;
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,
) = do_write_pass(
plan,
renumber,
pdf,
&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,
options,
&source_trailer,
)?;
let byte_lengths = compute_byte_lengths(
&xref_offsets,
last_xref_offset,
hint_stream_new_num,
renumber.param_dict_ref().number,
);
let part3_byte_len: u64 = plan
.part3_objects
.iter()
.map(|orig| {
renumber
.new_for_original(*orig)
.and_then(|new_ref| byte_lengths.get(&new_ref.number).copied())
.unwrap_or(0) as u64
})
.sum();
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 per_page_byte_lengths: Vec<u64> = plan
.per_page_private_objects
.iter()
.enumerate()
.map(|(page_idx, privates)| {
let private_len: u64 = privates
.iter()
.map(|orig| {
renumber
.new_for_original(*orig)
.and_then(|new_ref| byte_lengths.get(&new_ref.number).copied())
.unwrap_or(0) as u64
})
.sum();
if page_idx == 0 {
private_len + part3_byte_len
} else {
private_len
}
})
.collect();
let mut po_table = PageOffsetHintTable::from_plan(plan, renumber);
let mut so_table = SharedObjectHintTable::from_plan(plan, renumber);
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);
po_table.header.least_page_length = least_pl;
po_table.header.bits_page_length_delta = bits_needed(max_pl.saturating_sub(least_pl));
for (i, &bl) in per_page_byte_lengths.iter().enumerate() {
if i < po_table.entries.len() {
po_table.entries[i].page_length_minus_least = bl.saturating_sub(least_pl);
}
}
}
if !plan.shared_hints.is_empty() {
let shared_section_lens: Vec<u64> = plan
.shared_hints
.iter()
.map(|h| -> Result<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));
if !plan.part4_other_pages_shared.is_empty() {
let first_part8_orig = plan.part4_other_pages_shared[0];
let first_part8_new_num = renumber
.new_for_original(first_part8_orig)
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"first Part-8 shared object {} has no renumber entry",
first_part8_orig
))
})?
.number;
let first_part8_off =
xref_offsets
.get(&first_part8_new_num)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"first Part-8 shared object (new #{}) has no probed offset",
first_part8_new_num
))
})?;
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 (i, _hint) in plan.shared_hints.iter().enumerate() {
if i < so_table.objects.len() {
so_table.objects[i].length_minus_least =
(shared_section_lens[i].saturating_sub(least)) as u32;
}
}
}
let new_hint_bytes = encode_hint_stream(&po_table, &so_table)?;
let new_compressed = new_hint_bytes.compressed;
let new_shared_s = new_hint_bytes.shared_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 = new_compressed.len() == current_hint_compressed.len();
current_hint_compressed = new_compressed;
current_hint_shared_s = new_shared_s;
if converged || iter == max_iters - 1 {
let (
bytes_final,
xref_offsets_final,
hint_off_final,
hint_len_final,
efp_final,
lxr_final,
lxr_first_final,
prev_range_final,
) = do_write_pass(
plan,
renumber,
pdf,
&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,
options,
&source_trailer,
)?;
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;
break;
}
}
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,
};
Ok(LinearizedDocument {
bytes: final_bytes,
offsets,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::plan::LinearizationPlan;
use crate::writer::WriteOptions;
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).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();
}
#[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).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_main_startxref_is_real_offset() {
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 main_value: usize = parse_startxref_value(last_sxref_pos);
let last_xref_pos = (0..bytes.len().saturating_sub(3))
.rev()
.find(|&i| {
&bytes[i..i + 4] == b"xref"
&& (i == 0 || bytes[i - 1].is_ascii_whitespace())
&& (i + 4 >= bytes.len() || bytes[i + 4].is_ascii_whitespace())
})
.expect("linearized output must contain at least one standalone xref keyword");
assert_eq!(
main_value, last_xref_pos,
"Part 6 main startxref ({main_value}) must equal the last xref keyword \
offset ({last_xref_pos})"
);
}
#[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");
}
#[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).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));
}
}