use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use std::num::NonZeroUsize;
#[cfg(test)]
use super::eligibility::even_split_into_streams_with_cap;
use super::eligibility::{
compressible_objgens_qpdf_plan, eligibility_context, is_eligible_for_objstm_handle,
};
use crate::writer::WriterOptions;
use crate::ObjectRef;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ObjectStreamMode {
#[default]
Preserve,
Disable,
Generate,
}
pub(crate) const DEFAULT_BATCH_SIZE_CAP: NonZeroUsize = match NonZeroUsize::new(100) {
Some(n) => n,
None => unreachable!(),
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PlannerConfig {
pub mode: ObjectStreamMode,
pub batch_size_cap: NonZeroUsize,
pub preserve_unreferenced_objects: bool,
}
impl Default for PlannerConfig {
fn default() -> Self {
Self {
mode: ObjectStreamMode::Preserve,
batch_size_cap: DEFAULT_BATCH_SIZE_CAP,
preserve_unreferenced_objects: false,
}
}
}
#[cfg(test)]
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(crate) struct PackingPlan {
pub batches: Vec<Vec<ObjectRef>>,
pub source_containers: Vec<Option<ObjectRef>>,
pub removed_refs: BTreeSet<ObjectRef>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum ObjectStreamGroup {
SourceBacked {
source: ObjectRef,
members: Vec<ObjectRef>,
},
Generated {
source: ObjectRef,
members: Vec<ObjectRef>,
},
}
impl ObjectStreamGroup {
#[cfg(test)]
pub(crate) fn members(&self) -> &[ObjectRef] {
match self {
Self::SourceBacked { members, .. } | Self::Generated { members, .. } => members,
}
}
#[cfg(test)]
pub(crate) fn members_mut(&mut self) -> &mut Vec<ObjectRef> {
match self {
Self::SourceBacked { members, .. } | Self::Generated { members, .. } => members,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(crate) struct ObjectStreamPlan {
pub(crate) groups: Vec<ObjectStreamGroup>,
pub(crate) removed_refs: BTreeSet<ObjectRef>,
pub(crate) source_membership_present: bool,
}
pub(crate) fn planner_config_from_options(options: &WriterOptions) -> PlannerConfig {
PlannerConfig {
mode: options.object_streams,
batch_size_cap: DEFAULT_BATCH_SIZE_CAP,
preserve_unreferenced_objects: options.preserve_unreferenced_objects,
}
}
#[cfg(test)]
pub(crate) fn plan_object_streams_with_reachability_and_source_membership<
R: std::io::Read + std::io::Seek,
>(
pdf: &mut crate::Pdf<R>,
config: &PlannerConfig,
reachable: Option<&BTreeSet<ObjectRef>>,
source_membership_snapshot: Option<&BTreeMap<u32, u32>>,
generated_snapshot: Option<&super::CompressiblePlan>,
) -> crate::Result<PackingPlan> {
if config.mode == ObjectStreamMode::Disable {
return Ok(PackingPlan::default());
}
match config.mode {
ObjectStreamMode::Disable => {
unreachable!() }
ObjectStreamMode::Preserve => {
let source_plan = if let Some(snapshot) = source_membership_snapshot {
plan_qpdf_preserve_object_streams_with_source_membership(
pdf,
config.preserve_unreferenced_objects,
Some(snapshot),
)? } else {
plan_qpdf_preserve_object_streams_with_unreferenced(
pdf,
config.preserve_unreferenced_objects,
)? }; let mut batches = Vec::with_capacity(source_plan.groups.len());
let mut source_containers = Vec::with_capacity(source_plan.groups.len());
for group in source_plan.groups {
match group {
ObjectStreamGroup::SourceBacked { source, members } => {
source_containers.push(Some(source));
batches.push(members);
}
ObjectStreamGroup::Generated { .. } => {
return Err(crate::Error::Internal(
"Preserve planner returned a generated ObjStm group".to_string(),
)); }
}
}
Ok(PackingPlan {
batches,
source_containers,
removed_refs: source_plan.removed_refs,
})
}
ObjectStreamMode::Generate => plan_generate(pdf, config, reachable, generated_snapshot),
}
}
pub(crate) fn filter_objstm_batches_for_output<R: std::io::Read + std::io::Seek>(
pdf: &mut crate::Pdf<R>,
batches: &mut Vec<Vec<ObjectRef>>,
source_containers: &mut Vec<Option<ObjectRef>>,
output_linearized: bool,
output_encrypted: bool,
) -> crate::Result<()> {
let root = (output_linearized || output_encrypted)
.then(|| pdf.root_ref())
.flatten();
let page_refs: BTreeSet<ObjectRef> = if output_linearized {
crate::pages::repair::prepare_for_optimization(pdf)?
.map(|prepared| {
prepared
.pages
.into_iter()
.filter_map(|page| page.object_ref())
.collect()
})
.unwrap_or_default()
} else {
BTreeSet::new()
};
let mut retained_batches = Vec::with_capacity(batches.len());
let mut retained_sources = Vec::with_capacity(source_containers.len());
for (mut batch, source) in batches.drain(..).zip(source_containers.drain(..)) {
batch.retain(|member| root != Some(*member) && !page_refs.contains(member));
if !batch.is_empty() {
retained_batches.push(batch);
retained_sources.push(source);
}
}
*batches = retained_batches;
*source_containers = retained_sources;
Ok(())
}
pub(crate) fn filter_preserve_object_stream_plan_for_output<R: std::io::Read + std::io::Seek>(
pdf: &mut crate::Pdf<R>,
plan: &mut ObjectStreamPlan,
output_linearized: bool,
output_encrypted: bool,
) -> crate::Result<()> {
let mut batches = Vec::with_capacity(plan.groups.len());
let mut source_containers = Vec::with_capacity(plan.groups.len());
for group in plan.groups.drain(..) {
match group {
ObjectStreamGroup::SourceBacked { source, members } => {
batches.push(members);
source_containers.push(Some(source));
}
ObjectStreamGroup::Generated { source, .. } => {
return Err(crate::Error::Internal(format!(
"Preserve plan contains generated ObjStm source {source}"
)));
} }
}
filter_objstm_batches_for_output(
pdf,
&mut batches,
&mut source_containers,
output_linearized,
output_encrypted,
)?; plan.groups = batches
.into_iter()
.zip(source_containers)
.map(|(members, source)| ObjectStreamGroup::SourceBacked {
source: source.expect("Preserve source container must be present"),
members,
})
.collect();
Ok(())
}
pub(crate) fn plan_qpdf_preserve_object_streams_with_unreferenced<
R: std::io::Read + std::io::Seek,
>(
pdf: &mut crate::Pdf<R>,
preserve_unreferenced: bool,
) -> crate::Result<ObjectStreamPlan> {
plan_qpdf_preserve_object_streams_with_source_membership(pdf, preserve_unreferenced, None)
}
pub(crate) fn plan_qpdf_preserve_object_streams_with_source_membership<
R: std::io::Read + std::io::Seek,
>(
pdf: &mut crate::Pdf<R>,
preserve_unreferenced: bool,
source_membership_snapshot: Option<&BTreeMap<u32, u32>>,
) -> crate::Result<ObjectStreamPlan> {
let source_membership = source_membership_snapshot.cloned().unwrap_or_else(|| {
let mut source_membership = BTreeMap::new();
pdf.get_object_stream_data(&mut source_membership);
source_membership
});
if source_membership.is_empty() {
return Ok(ObjectStreamPlan::default());
}
let compressible = (!preserve_unreferenced)
.then(|| compressible_objgens_qpdf_plan(pdf))
.transpose()?;
let ctx = eligibility_context(pdf)?;
let eligible: BTreeSet<ObjectRef> = compressible
.as_ref()
.map(|plan| plan.eligible.iter().copied().collect())
.unwrap_or_default();
let mut by_container: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
for (member, stream) in source_membership {
by_container
.entry(ObjectRef::new(stream, 0))
.or_default()
.push(ObjectRef::new(member, 0));
}
let mut groups = Vec::new();
for (source, members) in by_container {
let mut retained = Vec::new();
for member in members {
if !preserve_unreferenced && !eligible.contains(&member) {
continue;
}
let retain = if preserve_unreferenced {
true
} else {
let object = pdf.get_object_handle(member);
is_eligible_for_objstm_handle(member, &object, &ctx)?
};
if retain {
retained.push(member);
}
}
sort_source_backed_members_qpdf_order(pdf, &mut retained);
if !retained.is_empty() {
groups.push(ObjectStreamGroup::SourceBacked {
source,
members: retained,
});
}
}
Ok(ObjectStreamPlan {
groups,
removed_refs: compressible
.map(|plan| plan.removed_refs)
.unwrap_or_default(),
source_membership_present: true,
})
}
#[cfg(test)]
fn plan_generate<R: std::io::Read + std::io::Seek>(
pdf: &mut crate::Pdf<R>,
config: &PlannerConfig,
reachable: Option<&BTreeSet<ObjectRef>>,
generated_snapshot: Option<&super::CompressiblePlan>,
) -> crate::Result<PackingPlan> {
let mut compressible = if let Some(snapshot) = generated_snapshot {
snapshot.clone()
} else {
compressible_objgens_qpdf_plan(pdf)?
};
compressible
.eligible
.retain(|member| reachable.is_none_or(|reachable| reachable.contains(member)));
let batches = even_split_into_streams_with_cap(&compressible.eligible, config.batch_size_cap);
let source_containers = vec![None; batches.len()];
Ok(PackingPlan {
batches,
source_containers,
removed_refs: compressible.removed_refs,
})
}
#[cfg(test)]
fn sort_compressible_for_writer_order<R: Read + Seek + 'static>(
pdf: &crate::Pdf<R>,
eligible: &mut [ObjectRef],
) {
if pdf.writer_object_order.is_some() {
eligible.sort_unstable_by_key(|object_ref| pdf.writer_object_order_key(*object_ref));
} }
pub(crate) fn sort_source_backed_members_qpdf_order<R: Read + Seek>(
pdf: &crate::Pdf<R>,
members: &mut [ObjectRef],
) {
if pdf.writer_object_order.is_some() {
members.sort_unstable_by_key(|object_ref| pdf.writer_object_order_key(*object_ref));
} else {
members.sort_unstable_by_key(|object_ref| (object_ref.number, object_ref.generation));
}
}
#[cfg(test)]
mod tests {
use super::{
filter_objstm_batches_for_output,
plan_object_streams_with_reachability_and_source_membership,
sort_compressible_for_writer_order, ObjectStreamMode, PlannerConfig,
DEFAULT_BATCH_SIZE_CAP,
};
use crate::pdf::WriterObjectOrderKey;
use crate::{ObjectRef, Pdf};
use std::collections::BTreeMap;
use std::io::Cursor;
#[test]
fn planner_config_default_uses_qpdf_defaults() {
let config = PlannerConfig::default();
assert_eq!(config.mode, ObjectStreamMode::Preserve);
assert_eq!(config.batch_size_cap, DEFAULT_BATCH_SIZE_CAP);
assert!(!config.preserve_unreferenced_objects);
}
#[test]
fn generated_merge_members_use_primary_then_foreign_writer_order() {
let mut pdf = crate::Pdf::empty().expect("create merge target");
let primary = ObjectRef::new(17, 0);
let foreign = ObjectRef::new(3, 0);
let mut order = BTreeMap::new();
order.insert(primary, WriterObjectOrderKey::primary(ObjectRef::new(4, 0)));
order.insert(foreign, WriterObjectOrderKey::foreign(ObjectRef::new(2, 0)));
pdf.set_writer_object_order(order);
let mut eligible = vec![foreign, primary];
sort_compressible_for_writer_order(&pdf, &mut eligible);
assert_eq!(eligible, [primary, foreign]);
}
#[test]
fn preserve_plan_keeps_qpdf_source_container_identity() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../../../tests/fixtures/compat/three-page-objstm.pdf").to_vec(),
))
.expect("open ObjStm fixture");
let config = PlannerConfig::default();
let plan = plan_object_streams_with_reachability_and_source_membership(
&mut pdf, &config, None, None, None,
)
.expect("build Preserve plan");
assert_eq!(
plan.source_containers,
vec![Some(ObjectRef::new(1, 0))],
"specialized Preserve must carry the source ObjStm identity from qpdf's map"
);
}
#[test]
fn linearized_output_filter_prepares_the_page_cache_before_filtering() {
let mut pdf = Pdf::open_mem_owned(
include_bytes!("../../../../../tests/fixtures/compat/one-page.pdf").to_vec(),
)
.expect("open one-page fixture");
let mut batches = vec![vec![ObjectRef::new(3, 0)]];
let mut source_containers = vec![None];
filter_objstm_batches_for_output(
&mut pdf,
&mut batches,
&mut source_containers,
true,
false,
)
.expect("filter page dictionary from linearized batch");
assert!(batches.is_empty());
assert!(source_containers.is_empty());
assert!(pdf.cached_page_list().is_some());
}
}