use std::collections::{BTreeMap, BTreeSet};
use std::num::NonZeroUsize;
use super::eligibility::{
collect_indirect_objstm_length_refs, compressible_objgens_qpdf_plan, eligibility_context,
even_split_into_streams_with_cap, is_eligible_for_objstm_handle, EligibilityContext,
};
use crate::writer::WriterOptions;
use crate::ObjectRef;
use crate::XrefEntry;
#[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,
}
impl Default for PlannerConfig {
fn default() -> Self {
Self {
mode: ObjectStreamMode::Preserve,
batch_size_cap: DEFAULT_BATCH_SIZE_CAP,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(crate) struct PackingPlan {
pub batches: Vec<Vec<ObjectRef>>,
pub removed_refs: BTreeSet<ObjectRef>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum ObjectStreamGroup {
SourceBacked {
source: ObjectRef,
members: Vec<ObjectRef>,
},
Synthetic { members: Vec<ObjectRef> },
}
impl ObjectStreamGroup {
pub(crate) fn members(&self) -> &[ObjectRef] {
match self {
Self::SourceBacked { members, .. } | Self::Synthetic { members } => members,
}
}
pub(crate) fn members_mut(&mut self) -> &mut Vec<ObjectRef> {
match self {
Self::SourceBacked { members, .. } | Self::Synthetic { 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) fn planner_config_from_options(options: &WriterOptions) -> PlannerConfig {
PlannerConfig {
mode: options.object_streams,
batch_size_cap: DEFAULT_BATCH_SIZE_CAP,
}
}
pub(crate) fn plan_object_streams_with_reachability<R: std::io::Read + std::io::Seek>(
pdf: &mut crate::Pdf<R>,
config: &PlannerConfig,
reachable: Option<&BTreeSet<ObjectRef>>,
) -> crate::Result<PackingPlan> {
if config.mode == ObjectStreamMode::Disable {
return Ok(PackingPlan::default());
}
let ctx = eligibility_context(pdf)?;
let length_exclusions = collect_indirect_objstm_length_refs(pdf)?;
match config.mode {
ObjectStreamMode::Disable => {
unreachable!() }
ObjectStreamMode::Preserve => plan_preserve(pdf, &ctx, &length_exclusions),
ObjectStreamMode::Generate => plan_generate(pdf, config, &length_exclusions, reachable),
}
}
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>>,
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::page_refs(pdf)?.into_iter().collect()
} else {
BTreeSet::new()
};
for batch in batches.iter_mut() {
batch.retain(|member| root != Some(*member) && !page_refs.contains(member));
}
batches.retain(|batch| !batch.is_empty());
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> {
let ctx = eligibility_context(pdf)?;
let length_exclusions = collect_indirect_objstm_length_refs(pdf)?;
let compressible = (!preserve_unreferenced)
.then(|| compressible_objgens_qpdf_plan(pdf))
.transpose()?;
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, entry) in pdf.source_xref_entries() {
if let XrefEntry::Compressed { stream, .. } = entry {
by_container
.entry(ObjectRef::new(stream, 0))
.or_default()
.push(member);
}
}
let mut groups = Vec::new();
for (source, members) in by_container {
let mut retained = Vec::new();
for member in members {
if length_exclusions.contains(&member)
|| (!preserve_unreferenced && !eligible.contains(&member))
{
continue;
}
let eligible_for_objstm = {
let object = pdf.get_object_handle(member);
is_eligible_for_objstm_handle(member, &object, &ctx)?
};
if eligible_for_objstm {
retained.push(member);
}
}
retained.sort_unstable_by_key(|member| (member.number, member.generation));
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(),
})
}
fn plan_preserve<R: std::io::Read + std::io::Seek>(
pdf: &mut crate::Pdf<R>,
ctx: &EligibilityContext,
length_exclusions: &BTreeSet<ObjectRef>,
) -> crate::Result<PackingPlan> {
let entries = pdf.source_xref_entries();
let mut groups: BTreeMap<u32, Vec<(u32, ObjectRef)>> = BTreeMap::new();
for (obj_ref, offset) in &entries {
if let XrefEntry::Compressed { stream, index } = offset {
groups.entry(*stream).or_default().push((*index, *obj_ref));
}
}
let mut batches: Vec<Vec<ObjectRef>> = Vec::new();
for (_container_num, mut members) in groups {
members.sort_by_key(|(idx, _)| *idx);
let mut eligible: Vec<ObjectRef> = Vec::new();
for (_idx, obj_ref) in members {
if length_exclusions.contains(&obj_ref) {
continue;
}
let eligible_for_objstm = {
let obj = pdf.get_object_handle(obj_ref);
is_eligible_for_objstm_handle(obj_ref, &obj, ctx)?
};
if !eligible_for_objstm {
continue;
}
eligible.push(obj_ref);
}
if !eligible.is_empty() {
batches.push(eligible);
}
}
Ok(PackingPlan {
batches,
removed_refs: BTreeSet::new(),
})
}
fn plan_generate<R: std::io::Read + std::io::Seek>(
pdf: &mut crate::Pdf<R>,
config: &PlannerConfig,
length_exclusions: &BTreeSet<ObjectRef>,
reachable: Option<&BTreeSet<ObjectRef>>,
) -> crate::Result<PackingPlan> {
let mut compressible = compressible_objgens_qpdf_plan(pdf)?;
compressible.eligible.retain(|member| {
!length_exclusions.contains(member)
&& reachable.is_none_or(|reachable| reachable.contains(member))
});
let batches = even_split_into_streams_with_cap(&compressible.eligible, config.batch_size_cap);
Ok(PackingPlan {
batches,
removed_refs: compressible.removed_refs,
})
}