use std::borrow::Cow;
use crate::object_handle::ObjectHandle;
use crate::pipeline::{PipelineError, PipelineResult};
use crate::stream_filter::{
decode_filter_specs_from_handle, encode_flate, encode_run_length,
is_decoded_filter as stream_is_decoded_filter,
passthrough_codec_label as stream_passthrough_codec_label, stream_filter_for,
undecodable_filter_error, DecodeParams, FilterDecodePhase, FilterSpec, CRYPT_STAGE_UNSUPPORTED,
};
use crate::{Error, Result};
const MAX_FILTER_CHAIN_LEN: usize = 16;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct StreamFilterCapabilities {
pub(crate) specialized_compression: bool,
pub(crate) lossy_compression: bool,
}
pub(crate) fn stream_filter_capabilities(
stream_dict: &ObjectHandle,
) -> Option<StreamFilterCapabilities> {
let filter = stream_dict.try_get_key(b"/Filter").ok()?;
let decode_params = stream_dict.try_get_key(b"/DecodeParms").ok()?;
let specs =
decode_filter_specs_from_handle(&filter, &decode_params, Some(MAX_FILTER_CHAIN_LEN))
.ok()?;
let mut capabilities = StreamFilterCapabilities::default();
for spec in specs {
let mut filter = stream_filter_for(spec.normalized_name())?;
if !filter.set_decode_params(&spec.decode_params) {
return None;
}
capabilities.specialized_compression |= filter.is_specialized_compression();
capabilities.lossy_compression |= filter.is_lossy_compression();
}
Some(capabilities)
}
pub fn passthrough_codec_label(filter_name: &[u8]) -> Option<&'static str> {
stream_passthrough_codec_label(filter_name)
}
pub fn is_decoded_filter(filter_name: &[u8]) -> bool {
stream_is_decoded_filter(filter_name)
}
pub fn decode_stream_data(stream_dict: &ObjectHandle, stream_data: &[u8]) -> Result<Vec<u8>> {
decode_stream_data_with_limits_and_warnings(
stream_dict,
stream_data,
DecodeLimits::default(),
&mut reject_decode_warning,
)
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct StreamDecodeWarning {
pub message: String,
pub code: i32,
}
#[derive(Debug)]
pub enum StreamDecodeEvent {
Data(Vec<u8>),
Warning(StreamDecodeWarning),
Error(Error),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum DataEventMode {
Record,
Suppress,
}
impl DataEventMode {
fn push(self, events: &mut Vec<StreamDecodeEvent>, data: &[u8]) {
if self == Self::Record && !data.is_empty() {
events.push(StreamDecodeEvent::Data(data.to_vec()));
}
}
}
#[derive(Debug)]
pub struct StreamDecodeOutcome {
pub data: Vec<u8>,
pub events: Vec<StreamDecodeEvent>,
}
pub fn decode_stream_data_recovering(
stream_dict: &ObjectHandle,
stream_data: &[u8],
) -> Result<StreamDecodeOutcome> {
decode_stream_data_recovering_with_limits(stream_dict, stream_data, DecodeLimits::default())
}
pub fn decode_stream_data_recovering_with_limits(
stream_dict: &ObjectHandle,
stream_data: &[u8],
limits: DecodeLimits,
) -> Result<StreamDecodeOutcome> {
decode_stream_data_recovering_from_handle(stream_dict, stream_data, limits)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct DecodeLimits {
pub max_output: Option<usize>,
pub max_tiff_memory: Option<usize>,
pub max_filter_chain: Option<usize>,
}
impl Default for DecodeLimits {
fn default() -> Self {
Self {
max_output: None,
max_tiff_memory: None,
max_filter_chain: Some(MAX_FILTER_CHAIN_LEN),
}
}
}
fn reject_decode_warning(message: &str, code: i32) -> PipelineResult<()> {
Err(PipelineError::runtime(format!(
"stream inflate: {message} (zlib error {code})"
)))
}
pub(crate) fn decode_stream_data_with_limits_and_warnings(
stream_dict: &ObjectHandle,
stream_data: &[u8],
limits: DecodeLimits,
warn: &mut dyn FnMut(&str, i32) -> PipelineResult<()>,
) -> Result<Vec<u8>> {
let outcome = decode_stream_data_from_handle_with_mode(
stream_dict,
stream_data,
limits,
DataEventMode::Suppress,
)?;
replay_strict_decode_outcome(outcome, warn)
}
fn replay_strict_decode_outcome(
outcome: StreamDecodeOutcome,
warn: &mut dyn FnMut(&str, i32) -> PipelineResult<()>,
) -> Result<Vec<u8>> {
let mut first_error = None;
for event in outcome.events {
let event_error = replay_strict_decode_event(event, warn);
if first_error.is_none() {
first_error = event_error;
}
}
match first_error {
Some(error) => Err(error),
None => Ok(outcome.data),
}
}
fn replay_strict_decode_event(
event: StreamDecodeEvent,
warn: &mut dyn FnMut(&str, i32) -> PipelineResult<()>,
) -> Option<Error> {
match event {
StreamDecodeEvent::Data(_) => None,
StreamDecodeEvent::Warning(warning) => warn(&warning.message, warning.code)
.err()
.map(|error| Error::Unsupported(error.into_string_lossy())),
StreamDecodeEvent::Error(error) => Some(error),
}
}
pub fn encode_stream_data(stream_dict: &ObjectHandle, stream_data: &[u8]) -> Result<Vec<u8>> {
encode_stream_data_from_handle(stream_dict, stream_data)
}
pub(crate) fn encode_stream_data_from_handle(
stream_dict: &ObjectHandle,
stream_data: &[u8],
) -> Result<Vec<u8>> {
let filter = stream_dict.try_get_key(b"/Filter")?;
let decode_params = stream_dict.try_get_key(b"/DecodeParms")?;
let specs = decode_filter_specs_from_handle(&filter, &decode_params, None)?;
encode_stream_data_from_specs(specs, stream_data)
}
fn reject_crypt_stage(_decode_params: &DecodeParams, _data: &[u8]) -> Result<Vec<u8>> {
Err(Error::Unsupported(CRYPT_STAGE_UNSUPPORTED.to_string()))
}
pub(crate) fn decode_stream_data_from_handle(
stream_dict: &ObjectHandle,
stream_data: &[u8],
limits: DecodeLimits,
) -> Result<Vec<u8>> {
let outcome = decode_stream_data_from_handle_with_mode(
stream_dict,
stream_data,
limits,
DataEventMode::Suppress,
)?;
replay_strict_decode_outcome(outcome, &mut reject_decode_warning)
}
pub(crate) fn decode_stream_data_recovering_from_handle(
stream_dict: &ObjectHandle,
stream_data: &[u8],
limits: DecodeLimits,
) -> Result<StreamDecodeOutcome> {
decode_stream_data_from_handle_with_mode(
stream_dict,
stream_data,
limits,
DataEventMode::Record,
)
}
fn decode_stream_data_from_handle_with_mode(
stream_dict: &ObjectHandle,
stream_data: &[u8],
limits: DecodeLimits,
data_events: DataEventMode,
) -> Result<StreamDecodeOutcome> {
let filter = stream_dict.try_get_key(b"/Filter")?;
let decode_params = stream_dict.try_get_key(b"/DecodeParms")?;
let specs = decode_filter_specs_from_handle(&filter, &decode_params, limits.max_filter_chain)?;
decode_prepared_specs(
specs,
stream_data,
limits,
data_events,
&mut reject_crypt_stage,
)
}
type CryptProvider<'a> = &'a mut dyn FnMut(&DecodeParams, &[u8]) -> Result<Vec<u8>>;
fn decode_prepared_specs(
specs: Vec<FilterSpec>,
stream_data: &[u8],
limits: DecodeLimits,
data_events: DataEventMode,
decrypt_crypt: CryptProvider<'_>,
) -> Result<StreamDecodeOutcome> {
let prepared = prepare_decode_filters(specs, limits.max_tiff_memory)?;
let stage_count = prepared.len();
let mut decoded = Cow::Borrowed(stream_data);
let mut events = Vec::new();
let mut pending_events = Vec::new();
let mut pending_data_boundary: Option<PendingDataBoundary> = None;
let mut has_runtime_error = false;
for (stage_index, mut stage) in prepared.into_iter().enumerate() {
let is_last_stage = stage_index + 1 == stage_count;
let next = match &mut stage.stage {
PreparedStage::Crypt => {
let data = decrypt_crypt(&stage.spec.decode_params, decoded.as_ref())?;
append_final_crypt_events(
is_last_stage,
&mut events,
&data,
data_events,
pending_data_boundary,
&mut pending_events,
);
data
}
PreparedStage::Codec { adapter } => {
let mut next_pending_data_boundary = pending_data_boundary.map(|boundary| {
let prefix_data = &decoded[..boundary.0];
let prefix = decode_codec_prefix(&stage.spec, prefix_data, limits);
let input_end = if boundary.1 {
prefix.data.len()
} else {
prefix.cleanup_data_start
};
PendingDataBoundary(input_end, boundary.1)
});
let mut stage_warnings = Vec::new();
let outcome = adapter.pipe_decode_recovering(
decoded.as_ref(),
limits.max_output,
&mut |message, code, output_offset, phase| {
let ordinal = stage_warnings.len();
stage_warnings.push(PositionedDecodeEvent::local(
output_offset,
phase,
ordinal,
StreamDecodeEvent::Warning(StreamDecodeWarning {
message: message.to_string(),
code,
}),
));
Ok(())
},
)?;
if let Some(stage_error) = outcome.error {
if has_runtime_error {
if is_last_stage {
let mut markers = stage_warnings;
if let Some(PendingDataBoundary(boundary, after_finish)) =
next_pending_data_boundary
{
markers.extend(position_pending_events(
boundary,
after_finish,
std::mem::take(&mut pending_events),
));
}
append_positioned_events(
&mut events,
&outcome.data,
data_events,
markers,
);
} else {
append_plain_events(&mut events, stage_warnings);
}
} else {
has_runtime_error = true;
let error_phase = if stage_error.during_write {
FilterDecodePhase::Write
} else {
FilterDecodePhase::Finish
};
let error_offset = stage_error.output_offset;
let error_ordinal = stage_warnings.len();
stage_warnings.push(PositionedDecodeEvent::local(
error_offset,
error_phase,
error_ordinal,
StreamDecodeEvent::Error(stage_error.error),
));
if !is_last_stage {
next_pending_data_boundary =
Some(PendingDataBoundary(error_offset, !stage_error.during_write));
pending_events.extend(positioned_into_plain_events(stage_warnings));
} else {
if let Some(PendingDataBoundary(boundary, after_finish)) =
next_pending_data_boundary
{
stage_warnings.extend(position_pending_events(
boundary,
after_finish,
std::mem::take(&mut pending_events),
));
}
append_positioned_events(
&mut events,
&outcome.data,
data_events,
stage_warnings,
);
}
}
} else {
if is_last_stage {
let mut markers = stage_warnings;
if let Some(PendingDataBoundary(boundary, after_finish)) =
next_pending_data_boundary
{
markers.extend(position_pending_events(
boundary,
after_finish,
std::mem::take(&mut pending_events),
));
}
append_positioned_events(&mut events, &outcome.data, data_events, markers);
} else if !stage_warnings.is_empty() {
let boundary = stage_warnings[0].offset;
pending_events.extend(positioned_into_plain_events(stage_warnings));
next_pending_data_boundary = Some(PendingDataBoundary(boundary, false));
}
}
if !is_last_stage && (has_runtime_error || next_pending_data_boundary.is_some()) {
pending_data_boundary = next_pending_data_boundary;
}
outcome.data
}
};
decoded = Cow::Owned(next);
}
let data = decoded.into_owned();
if stage_count == 0 {
data_events.push(&mut events, &data);
}
Ok(StreamDecodeOutcome { data, events })
}
enum PreparedStage {
Crypt,
Codec {
adapter: Box<dyn crate::stream_filter::StreamFilter>,
},
}
struct PreparedDecodeFilter {
spec: FilterSpec,
stage: PreparedStage,
}
fn prepare_decode_filters(
specs: Vec<FilterSpec>,
max_tiff_memory: Option<usize>,
) -> Result<Vec<PreparedDecodeFilter>> {
let mut prepared = Vec::with_capacity(specs.len());
for spec in specs {
let filter_name = spec.normalized_name();
if filter_name == b"Crypt" {
prepared.push(PreparedDecodeFilter {
spec,
stage: PreparedStage::Crypt,
});
continue;
}
let Some(mut adapter) = stream_filter_for(filter_name) else {
return Err(undecodable_filter_error(filter_name));
};
if !adapter.set_decode_params(&spec.decode_params) {
return Err(Error::Unsupported(format!(
"stream filter {} does not support supplied /DecodeParms",
String::from_utf8_lossy(filter_name)
)));
}
adapter.set_tiff_memory_limit(max_tiff_memory);
prepared.push(PreparedDecodeFilter {
spec,
stage: PreparedStage::Codec { adapter },
});
}
for stage in prepared.iter().rev() {
if let PreparedStage::Codec { adapter } = &stage.stage {
adapter.preflight_decode_pipeline()?;
}
}
Ok(prepared)
}
#[derive(Clone, Copy)]
struct PendingDataBoundary(usize, bool);
struct PositionedDecodeEvent {
offset: usize,
barrier: u8,
ordinal: usize,
event: StreamDecodeEvent,
}
fn append_final_crypt_events(
is_last_stage: bool,
events: &mut Vec<StreamDecodeEvent>,
data: &[u8],
data_events: DataEventMode,
pending_data_boundary: Option<PendingDataBoundary>,
pending_events: &mut Vec<StreamDecodeEvent>,
) {
if !is_last_stage {
return;
}
let mut markers = Vec::new();
if let Some(PendingDataBoundary(boundary, after_finish)) = pending_data_boundary {
markers.extend(position_pending_events(
boundary,
after_finish,
std::mem::take(pending_events),
));
}
append_positioned_events(events, data, data_events, markers);
}
impl PositionedDecodeEvent {
fn local(
offset: usize,
phase: FilterDecodePhase,
ordinal: usize,
event: StreamDecodeEvent,
) -> Self {
let barrier = match phase {
FilterDecodePhase::Write => 1,
FilterDecodePhase::Finish => 2,
};
Self {
offset,
barrier,
ordinal,
event,
}
}
}
fn position_pending_events(
offset: usize,
after_finish: bool,
events: Vec<StreamDecodeEvent>,
) -> impl Iterator<Item = PositionedDecodeEvent> {
let barrier = if after_finish { 3 } else { 0 };
events
.into_iter()
.enumerate()
.map(move |(ordinal, event)| PositionedDecodeEvent {
offset,
barrier,
ordinal,
event,
})
}
fn sort_positioned_events(events: &mut [PositionedDecodeEvent]) {
events.sort_by_key(|event| (event.offset, event.barrier, event.ordinal));
}
fn positioned_into_plain_events(
mut events: Vec<PositionedDecodeEvent>,
) -> impl Iterator<Item = StreamDecodeEvent> {
sort_positioned_events(&mut events);
events.into_iter().map(|event| event.event)
}
fn append_plain_events(output: &mut Vec<StreamDecodeEvent>, events: Vec<PositionedDecodeEvent>) {
output.extend(positioned_into_plain_events(events));
}
fn append_positioned_events(
output: &mut Vec<StreamDecodeEvent>,
data: &[u8],
data_events: DataEventMode,
mut events: Vec<PositionedDecodeEvent>,
) {
sort_positioned_events(&mut events);
let mut data_start = 0;
for event in events {
let offset = event.offset.min(data.len()).max(data_start);
data_events.push(output, &data[data_start..offset]);
output.push(event.event);
data_start = offset;
}
data_events.push(output, &data[data_start..]);
}
fn decode_codec_prefix(
spec: &FilterSpec,
data: &[u8],
limits: DecodeLimits,
) -> crate::stream_filter::FilterDecodeOutcome {
let filter_name = spec.normalized_name();
let mut adapter =
stream_filter_for(filter_name).expect("a prepared codec has a registered prefix decoder");
let applied = adapter.set_decode_params(&spec.decode_params);
debug_assert!(applied);
adapter.set_tiff_memory_limit(limits.max_tiff_memory);
adapter
.pipe_decode_recovering(data, limits.max_output, &mut |_, _, _, _| Ok(()))
.expect("preflighted codec prefix pipeline is infallible")
}
fn encode_stream_data_from_specs(specs: Vec<FilterSpec>, stream_data: &[u8]) -> Result<Vec<u8>> {
let mut encoded = stream_data.to_vec();
for spec in specs.into_iter().rev() {
let after_predictor =
apply_encode_params(spec.normalized_name(), &spec.decode_params, &encoded)?;
encoded = if spec.normalized_name() == b"FlateDecode" {
encode_flate(&after_predictor)?
} else {
apply_single_filter_encode(spec.normalized_name(), &after_predictor)
.map_err(Error::Unsupported)?
};
}
Ok(encoded)
}
fn apply_encode_params(
filter_name: &[u8],
decode_params: &DecodeParams,
stream_data: &[u8],
) -> Result<Vec<u8>> {
crate::stream_filter::encode_predictor(stream_data, filter_name, decode_params)
}
fn apply_single_filter_encode(
filter_name: &[u8],
stream_data: &[u8],
) -> std::result::Result<Vec<u8>, String> {
if filter_name == b"ASCII85Decode" {
return Err(
"ASCII85Encode is not supported: qpdf provides an ASCII85 decoder but no encoder"
.to_string(),
);
}
if filter_name == b"ASCIIHexDecode" {
return Err(
"ASCIIHexEncode is not supported: qpdf provides an ASCIIHex decoder but no encoder"
.to_string(),
);
}
if filter_name == b"RunLengthDecode" {
return encode_run_length(stream_data).map_err(|error| error.to_string());
}
if filter_name == b"LZWDecode" {
return Err(
"LZWEncode is not supported: flpdf writes stream compression as FlateDecode only \
(qpdf has no LZW encoder either)"
.to_string(),
);
}
if let Some(label) = passthrough_codec_label(filter_name) {
return Err(format!(
"encode not supported for passthrough codec {label}: \
image/binary streams are preserved verbatim by flpdf"
));
}
Err(format!(
"unsupported stream filter: {}",
std::str::from_utf8(filter_name).unwrap_or("<binary>"),
))
}