use crate::object_handle::{legacy_dictionary_key, ObjectHandle};
use crate::pipeline::ascii85_decoder::Ascii85Decoder;
use crate::pipeline::ascii_hex::AsciiHexDecoder;
use crate::pipeline::buffer::Buffer;
use crate::pipeline::dct::PlDct;
use crate::pipeline::flate::{Flate, FlateAction, DEFAULT_OUT_BUFFER_SIZE};
use crate::pipeline::lzw::LzwDecoder;
use crate::pipeline::png_filter::{PngFilter, PngFilterAction};
use crate::pipeline::run_length::{RunLength, RunLengthAction};
use crate::pipeline::tiff_predictor::{TiffPredictor, TiffPredictorAction};
use crate::pipeline::{Pipeline, PipelineError, PipelineRef, PipelineResult};
use crate::{Error, Result};
use std::cell::Cell;
use std::collections::BTreeMap;
use std::rc::Rc;
pub(crate) const DECODE_OUTPUT_LIMIT_PREFIX: &str = "decoded output exceeds configured limit of";
pub(crate) const CRYPT_STAGE_UNSUPPORTED: &str = "unsupported stream filter: Crypt";
type FilterWarningCallback = Box<dyn FnMut(&str, i32) -> PipelineResult<()> + 'static>;
#[derive(Debug, PartialEq)]
pub(crate) enum DecodeParams {
Absent,
Present(Vec<(Vec<u8>, ParamValue)>),
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) enum ParamValue {
Int(i32),
Name(Vec<u8>),
Other,
}
impl DecodeParams {
pub(crate) fn is_absent(&self) -> bool {
matches!(self, Self::Absent)
}
pub(crate) fn entries(&self) -> &[(Vec<u8>, ParamValue)] {
match self {
Self::Absent => &[],
Self::Present(entries) => entries,
}
}
}
#[derive(Debug, PartialEq)]
pub(crate) struct FilterSpec {
pub(crate) name: Vec<u8>,
pub(crate) decode_params: DecodeParams,
}
impl FilterSpec {
pub(crate) fn normalized_name(&self) -> &[u8] {
normalize_filter_name(&self.name)
}
}
pub(crate) fn normalize_filter_name(name: &[u8]) -> &[u8] {
match name {
b"Fl" => b"FlateDecode",
b"LZW" => b"LZWDecode",
b"A85" => b"ASCII85Decode",
b"AHx" => b"ASCIIHexDecode",
b"RL" => b"RunLengthDecode",
b"CCF" => b"CCITTFaxDecode",
b"DCT" => b"DCTDecode",
name => name,
}
}
pub(crate) fn passthrough_codec_label(filter_name: &[u8]) -> Option<&'static str> {
match filter_name {
b"DCTDecode" => Some("DCTDecode"),
b"JBIG2Decode" => Some("JBIG2Decode"),
b"JPXDecode" => Some("JPXDecode"),
b"CCITTFaxDecode" => Some("CCITTFaxDecode"),
_ => None,
}
}
pub(crate) fn is_decoded_filter(filter_name: &[u8]) -> bool {
filter_name != b"Crypt" && stream_filter_for(filter_name).is_some()
}
pub(crate) fn undecodable_filter_error(filter_name: &[u8]) -> Error {
if let Some(label) = passthrough_codec_label(filter_name) {
return Error::Unsupported(format!(
"passthrough codec {label}: image/binary stream data is not decoded by flpdf (preserved verbatim)"
));
}
Error::Unsupported(format!(
"unsupported stream filter: {}",
std::str::from_utf8(filter_name).unwrap_or("<binary>")
))
}
pub(crate) fn validate_filter_factories<'a, I>(names: I) -> Result<()>
where
I: IntoIterator<Item = &'a [u8]>,
{
for name in names {
let normalized = normalize_filter_name(name);
if stream_filter_for(normalized).is_none() {
return Err(undecodable_filter_error(normalized));
}
}
Ok(())
}
pub(crate) const FILTER_TYPE_ERROR: &str = "stream filter type is not name or array";
pub(crate) const DECODE_PARMS_LENGTH_ERROR: &str =
"stream /DecodeParms length is inconsistent with filters";
pub(crate) fn validate_filter_chain_count(count: usize, maximum: Option<usize>) -> Result<()> {
if let Some(maximum) = maximum.filter(|maximum| count > *maximum) {
return Err(Error::Unsupported(format!(
"filter chain length {count} exceeds maximum of {maximum}"
)));
}
Ok(())
}
pub(crate) fn decode_filter_specs_from_handle(
filter: &ObjectHandle,
decode_params: &ObjectHandle,
max_filter_chain: Option<usize>,
) -> Result<Vec<FilterSpec>> {
let names: Vec<Vec<u8>> = if filter.try_is_null()? {
return Ok(Vec::new());
} else if let Some(name) = filter.try_as_name()? {
vec![name]
} else if let Some(count) = filter.try_array_len()? {
validate_filter_chain_count(count, max_filter_chain)?;
filter
.try_as_array()?
.into_iter()
.flatten()
.map(|item| {
item.try_as_name()?
.ok_or_else(|| Error::Unsupported(FILTER_TYPE_ERROR.to_string()))
})
.collect::<Result<_>>()?
} else {
return Err(Error::Unsupported(FILTER_TYPE_ERROR.to_string()));
};
if names.is_empty() {
return Ok(Vec::new());
}
validate_filter_factories(names.iter().map(Vec::as_slice))?;
let params: Vec<DecodeParams> = if decode_params.try_is_null()? {
absent_params(names.len())
} else if let Some(count) = decode_params.try_array_len()? {
if count == 0 {
absent_params(names.len())
} else {
if count != names.len() {
return Err(Error::Unsupported(DECODE_PARMS_LENGTH_ERROR.to_string()));
}
decode_params
.try_as_array()?
.into_iter()
.flatten()
.zip(&names)
.map(|(item, name)| decode_params_from_handle(&item, name))
.collect::<Result<_>>()?
}
} else {
replicated_decode_params(decode_params, &names)?
};
validate_filter_chain_count(names.len(), max_filter_chain)?;
Ok(names
.into_iter()
.zip(params)
.map(|(name, decode_params)| FilterSpec {
name,
decode_params,
})
.collect())
}
fn absent_params(count: usize) -> Vec<DecodeParams> {
(0..count).map(|_| DecodeParams::Absent).collect()
}
fn replicated_decode_params(params: &ObjectHandle, names: &[Vec<u8>]) -> Result<Vec<DecodeParams>> {
let entries = names
.iter()
.any(|name| !filter_reads_decode_params(name))
.then(|| params.try_as_dictionary())
.transpose()?;
names
.iter()
.map(|name| {
if filter_reads_decode_params(name) {
decode_params_from_consuming_handle(params, name)
} else {
decode_params_from_entries(
entries.as_ref().and_then(|entries| entries.as_ref()),
name,
)
}
})
.collect()
}
fn filter_reads_decode_params(filter_name: &[u8]) -> bool {
if is_crypt_filter(filter_name) {
return true;
}
stream_filter_for(normalize_filter_name(filter_name))
.is_some_and(|filter| filter.reads_decode_params())
}
fn is_crypt_filter(filter_name: &[u8]) -> bool {
normalize_filter_name(filter_name) == b"Crypt"
}
pub(crate) fn decode_params_from_handle(
params: &ObjectHandle,
filter_name: &[u8],
) -> Result<DecodeParams> {
if params.try_is_null()? {
return Ok(DecodeParams::Absent);
}
if filter_reads_decode_params(filter_name) {
return decode_params_from_consuming_handle(params, filter_name);
}
decode_params_from_entries(params.try_as_dictionary()?.as_ref(), filter_name)
}
fn decode_params_from_consuming_handle(
params: &ObjectHandle,
filter_name: &[u8],
) -> Result<DecodeParams> {
let crypt_stage = is_crypt_filter(filter_name);
let mut retained = Vec::new();
for key in params.try_get_keys()? {
let logical_key = legacy_dictionary_key(&key);
if !retains_decode_param_key(logical_key, crypt_stage) {
continue;
}
let value = params.try_get_key(&key)?;
let keeps_name = keeps_crypt_name_payload(logical_key, crypt_stage);
let consumes_integer = consumes_integer_decode_param_key(logical_key, filter_name);
retained.push((
logical_key.to_vec(),
param_value_from_handle(&value, keeps_name, consumes_integer)?,
));
}
Ok(DecodeParams::Present(retained))
}
fn decode_params_from_entries(
entries: Option<&BTreeMap<Vec<u8>, ObjectHandle>>,
filter_name: &[u8],
) -> Result<DecodeParams> {
let Some(entries) = entries else {
return Ok(DecodeParams::Present(Vec::new()));
};
let crypt_stage = is_crypt_filter(filter_name);
let retained = entries
.iter()
.filter(|(key, _)| retains_decode_param_key(legacy_dictionary_key(key), crypt_stage))
.map(|(key, value)| {
let logical_key = legacy_dictionary_key(key);
(logical_key.to_vec(), param_value_without_resolving(value))
})
.collect();
Ok(DecodeParams::Present(retained))
}
fn consumes_integer_decode_param_key(key: &[u8], filter_name: &[u8]) -> bool {
if is_crypt_filter(filter_name) {
return false;
}
match key {
b"Predictor" | b"Columns" | b"Colors" | b"BitsPerComponent" => true,
b"EarlyChange" => normalize_filter_name(filter_name) == b"LZWDecode",
_ => false,
}
}
fn param_value_from_handle(
value: &ObjectHandle,
keeps_name: bool,
consumes_integer: bool,
) -> Result<ParamValue> {
if let Some(int) = value.try_as_integer()? {
let int = if consumes_integer {
clamp_handle_value_to_i32(int, value)?
} else {
clamp_to_i32(int)
};
return Ok(ParamValue::Int(int));
}
Ok(match value.try_as_name()? {
Some(name) if keeps_name => ParamValue::Name(name),
_ => ParamValue::Other,
})
}
fn param_value_without_resolving(value: &ObjectHandle) -> ParamValue {
match value.as_integer() {
Some(int) => ParamValue::Int(clamp_to_i32(int)),
None => ParamValue::Other,
}
}
struct OutputBuffer {
data: Vec<u8>,
max_output: Option<usize>,
cleanup_data_start: Option<usize>,
finish_phase: Rc<Cell<bool>>,
output_position: Rc<Cell<usize>>,
}
impl OutputBuffer {
fn new(max_output: Option<usize>) -> Self {
Self {
data: Vec::new(),
max_output,
cleanup_data_start: None,
finish_phase: Rc::new(Cell::new(false)),
output_position: Rc::new(Cell::new(0)),
}
}
fn finish_phase(&self) -> Rc<Cell<bool>> {
Rc::clone(&self.finish_phase)
}
fn output_position(&self) -> Rc<Cell<usize>> {
Rc::clone(&self.output_position)
}
fn cleanup_data_start(&self) -> usize {
self.cleanup_data_start.unwrap_or(self.data.len())
}
}
impl Pipeline for OutputBuffer {
fn identifier(&self) -> &str {
"stream data buffer"
}
fn write(&mut self, data: &[u8]) -> PipelineResult<()> {
if self.finish_phase.get() && self.cleanup_data_start.is_none() {
self.cleanup_data_start = Some(self.data.len());
}
if let Some(limit) = self.max_output {
let remaining = limit.saturating_sub(self.data.len());
if data.len() > remaining {
self.data.extend_from_slice(&data[..remaining]);
self.output_position.set(self.data.len());
return Err(PipelineError::runtime(format!(
"{DECODE_OUTPUT_LIMIT_PREFIX} {limit} bytes"
)));
}
}
self.data.extend_from_slice(data);
self.output_position.set(self.data.len());
Ok(())
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
fn map_pipeline_error(error: PipelineError) -> Error {
Error::Unsupported(error.into_string_lossy())
}
pub(crate) struct FilterDecodeOutcome {
pub(crate) data: Vec<u8>,
pub(crate) cleanup_data_start: usize,
pub(crate) error: Option<FilterDecodeError>,
}
pub(crate) struct FilterDecodeError {
pub(crate) error: Error,
pub(crate) during_write: bool,
pub(crate) output_offset: usize,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum FilterDecodePhase {
Write,
Finish,
}
struct StagePipelineError {
error: PipelineError,
during_write: bool,
output_offset: usize,
}
fn write_and_finish(
stage: &mut dyn Pipeline,
data: &[u8],
finish_phase: Option<&Cell<bool>>,
output_position: &Cell<usize>,
) -> Option<StagePipelineError> {
if let Some(finish_phase) = finish_phase {
finish_phase.set(false);
}
match stage.write(data) {
Ok(()) => {
if let Some(finish_phase) = finish_phase {
finish_phase.set(true);
}
stage.finish().err().map(|error| StagePipelineError {
error,
during_write: false,
output_offset: output_position.get(),
})
}
Err(error) => {
let output_offset = output_position.get();
if let Some(finish_phase) = finish_phase {
finish_phase.set(true);
}
let _ = stage.finish();
Some(StagePipelineError {
error,
during_write: true,
output_offset,
})
}
}
}
fn map_stage_error(error: StagePipelineError) -> FilterDecodeError {
FilterDecodeError {
error: map_pipeline_error(error.error),
during_write: error.during_write,
output_offset: error.output_offset,
}
}
pub(crate) trait StreamFilter {
fn set_decode_params(&mut self, decode_params: &DecodeParams) -> bool {
decode_params.is_absent()
}
fn reads_decode_params(&self) -> bool {
false
}
fn preflight_decode_pipeline(&self) -> Result<()> {
Ok(())
}
fn set_tiff_memory_limit(&mut self, _limit: Option<usize>) {}
fn decode_pipeline_owned<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>>;
fn set_warning_callback(&mut self, _callback: FilterWarningCallback) {}
fn pipe_decode_recovering(
&mut self,
data: &[u8],
max_output: Option<usize>,
warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
) -> Result<FilterDecodeOutcome>;
fn is_specialized_compression(&self) -> bool {
false
}
fn is_lossy_compression(&self) -> bool {
false
}
}
pub(crate) enum OwnedDecodePipeline<'a> {
Stage(Box<dyn Pipeline + 'a>),
NoStage(PipelineRef<'a>),
}
struct FlateLzwStreamFilter {
lzw: bool,
predictor: i32,
columns: i32,
colors: i32,
bits_per_component: i32,
early_code_change: bool,
warning_callback: Option<FilterWarningCallback>,
tiff_max_memory: Option<usize>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum PredictorKind {
Png,
Tiff,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct PredictorGeometry {
kind: PredictorKind,
columns: u32,
colors: u32,
bits_per_component: u32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum PredictorAction {
Encode,
Decode,
}
impl FlateLzwStreamFilter {
fn new(lzw: bool) -> Self {
Self {
lzw,
predictor: 1,
columns: 1,
colors: 1,
bits_per_component: 8,
early_code_change: true,
warning_callback: None,
tiff_max_memory: None,
}
}
}
const RETAINED_DECODE_PARAM_KEYS: [&[u8]; 5] = [
b"BitsPerComponent",
b"Colors",
b"Columns",
b"EarlyChange",
b"Predictor",
];
const CRYPT_NAME_PAYLOAD_DECODE_PARAM_KEYS: [&[u8]; 2] = [b"Name", b"Type"];
fn retains_decode_param_key(key: &[u8], crypt_stage: bool) -> bool {
crypt_stage || RETAINED_DECODE_PARAM_KEYS.contains(&key)
}
fn keeps_crypt_name_payload(key: &[u8], crypt_stage: bool) -> bool {
crypt_stage && CRYPT_NAME_PAYLOAD_DECODE_PARAM_KEYS.contains(&key)
}
fn clamp_to_i32(value: i64) -> i32 {
value.clamp(i64::from(i32::MIN), i64::from(i32::MAX)) as i32
}
fn clamp_handle_value_to_i32(value: i64, handle: &ObjectHandle) -> Result<i32> {
if value < i64::from(i32::MIN) {
handle.warn_if_possible("requested value of integer is too small; returning INT_MIN")?;
} else if value > i64::from(i32::MAX) {
handle.warn_if_possible("requested value of integer is too big; returning INT_MAX")?;
}
Ok(clamp_to_i32(value))
}
fn to_uint(value: i32) -> Result<u32> {
u32::try_from(value).map_err(|_| {
Error::Unsupported(format!(
"integer out of range converting {value} from a 4-byte signed type to a 4-byte unsigned type"
))
})
}
impl StreamFilter for FlateLzwStreamFilter {
fn reads_decode_params(&self) -> bool {
true
}
fn set_decode_params(&mut self, decode_params: &DecodeParams) -> bool {
if decode_params.is_absent() {
return true;
}
let mut filterable = true;
for (key, value) in decode_params.entries() {
let key = key.as_slice();
match key {
b"Predictor" => match *value {
ParamValue::Int(predictor) => {
self.predictor = predictor;
if !((predictor == 1) || (predictor == 2) || (10..=15).contains(&predictor))
{
filterable = false;
}
}
ParamValue::Name(_) | ParamValue::Other => filterable = false,
},
b"Columns" | b"Colors" | b"BitsPerComponent" => match *value {
ParamValue::Int(parameter) => match key {
b"Columns" => self.columns = parameter,
b"Colors" => self.colors = parameter,
_ => self.bits_per_component = parameter,
},
ParamValue::Name(_) | ParamValue::Other => filterable = false,
},
b"EarlyChange" if self.lzw => match *value {
ParamValue::Int(early_change) => {
self.early_code_change = early_change == 1;
if !((early_change == 0) || (early_change == 1)) {
filterable = false;
}
}
ParamValue::Name(_) | ParamValue::Other => filterable = false,
},
_ => {}
}
}
if (self.predictor > 1) && (self.columns == 0) {
filterable = false;
}
filterable
}
fn set_warning_callback(&mut self, callback: FilterWarningCallback) {
self.warning_callback = Some(callback);
}
fn preflight_decode_pipeline(&self) -> Result<()> {
if let Some(geometry) = self.decode_predictor_geometry()? {
let mut sink = OutputBuffer::new(None);
let _predictor = make_predictor_pipeline(
geometry,
&mut sink,
PredictorAction::Decode,
self.tiff_max_memory,
)?;
}
Ok(())
}
fn set_tiff_memory_limit(&mut self, limit: Option<usize>) {
self.tiff_max_memory = limit;
}
fn decode_pipeline_owned<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
let next: PipelineRef<'a> = match self.decode_predictor_geometry()? {
Some(geometry) => make_predictor_pipeline(
geometry,
next,
PredictorAction::Decode,
self.tiff_max_memory,
)?,
None => next,
};
let stage: Box<dyn Pipeline + 'a> = if self.lzw {
Box::new(LzwDecoder::new("lzw decode", next, self.early_code_change))
} else {
let mut flate = Flate::new(
"stream inflate",
next,
FlateAction::Inflate,
DEFAULT_OUT_BUFFER_SIZE,
)
.map_err(map_pipeline_error)?;
if let Some(callback) = self.warning_callback.take() {
flate.set_warn_callback(callback);
}
Box::new(flate)
};
Ok(OwnedDecodePipeline::Stage(stage))
}
fn pipe_decode_recovering(
&mut self,
data: &[u8],
max_output: Option<usize>,
warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
) -> Result<FilterDecodeOutcome> {
let geometry = self.decode_predictor_geometry()?;
let mut sink = OutputBuffer::new(max_output);
let finish_phase = sink.finish_phase();
let output_position = sink.output_position();
let error = match geometry {
Some(geometry) => {
let mut predictor = make_predictor_pipeline(
geometry,
&mut sink,
PredictorAction::Decode,
self.tiff_max_memory,
)?;
let phase = Some(finish_phase.as_ref());
self.pipe_codec(&mut predictor, data, warn, phase, &output_position)?
}
None => {
self.pipe_codec(&mut sink, data, warn, Some(&finish_phase), &output_position)?
}
};
Ok(FilterDecodeOutcome {
cleanup_data_start: sink.cleanup_data_start(),
data: sink.data,
error,
})
}
}
impl FlateLzwStreamFilter {
fn decode_predictor_geometry(&self) -> Result<Option<PredictorGeometry>> {
let kind = if (10..=15).contains(&self.predictor) {
Some(PredictorKind::Png)
} else if self.predictor == 2 {
Some(PredictorKind::Tiff)
} else {
None
};
kind.map(|kind| {
Ok(PredictorGeometry {
kind,
columns: to_uint(self.columns)?,
colors: to_uint(self.colors)?,
bits_per_component: to_uint(self.bits_per_component)?,
})
})
.transpose()
}
fn pipe_codec(
&self,
next: &mut dyn Pipeline,
data: &[u8],
warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
finish_phase: Option<&Cell<bool>>,
output_position: &Cell<usize>,
) -> Result<Option<FilterDecodeError>> {
let error = if self.lzw {
let mut stage = LzwDecoder::new("lzw decode", next, self.early_code_change);
write_and_finish(&mut stage, data, finish_phase, output_position)
} else {
let mut stage = Flate::new(
"stream inflate",
next,
FlateAction::Inflate,
DEFAULT_OUT_BUFFER_SIZE,
)
.map_err(map_pipeline_error)?;
stage.set_warn_callback(|message, code| {
let phase = filter_decode_phase(finish_phase);
warn(message, code, output_position.get(), phase)
});
write_and_finish(&mut stage, data, finish_phase, output_position)
};
Ok(error.map(map_stage_error))
}
}
fn make_predictor_pipeline<'a>(
geometry: PredictorGeometry,
next: impl Into<PipelineRef<'a>>,
action: PredictorAction,
tiff_max_memory: Option<usize>,
) -> Result<PipelineRef<'a>> {
let next = next.into();
let pipeline = match (geometry.kind, action) {
(PredictorKind::Png, PredictorAction::Encode) => Box::new(
PngFilter::new(
"png encode",
next,
PngFilterAction::Encode,
geometry.columns,
geometry.colors,
geometry.bits_per_component,
)
.map_err(map_pipeline_error)?,
) as Box<dyn Pipeline + 'a>,
(PredictorKind::Png, PredictorAction::Decode) => Box::new(
PngFilter::new(
"png decode",
next,
PngFilterAction::Decode,
geometry.columns,
geometry.colors,
geometry.bits_per_component,
)
.map_err(map_pipeline_error)?,
) as Box<dyn Pipeline + 'a>,
(PredictorKind::Tiff, PredictorAction::Encode) => Box::new(
TiffPredictor::new_with_memory_limit(
"tiff encode",
next,
TiffPredictorAction::Encode,
geometry.columns,
geometry.colors,
geometry.bits_per_component,
tiff_max_memory,
)
.map_err(map_pipeline_error)?,
) as Box<dyn Pipeline + 'a>,
(PredictorKind::Tiff, PredictorAction::Decode) => Box::new(
TiffPredictor::new_with_memory_limit(
"tiff decode",
next,
TiffPredictorAction::Decode,
geometry.columns,
geometry.colors,
geometry.bits_per_component,
tiff_max_memory,
)
.map_err(map_pipeline_error)?,
) as Box<dyn Pipeline + 'a>,
};
Ok(PipelineRef::Owned(pipeline))
}
fn filter_decode_phase(finish_phase: Option<&Cell<bool>>) -> FilterDecodePhase {
if finish_phase.is_some_and(Cell::get) {
FilterDecodePhase::Finish
} else {
FilterDecodePhase::Write
}
}
struct Ascii85StreamFilter;
impl StreamFilter for Ascii85StreamFilter {
fn decode_pipeline_owned<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(Ascii85Decoder::new(
"ascii85 decode",
next,
))))
}
fn pipe_decode_recovering(
&mut self,
data: &[u8],
max_output: Option<usize>,
_warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
) -> Result<FilterDecodeOutcome> {
decode_ascii85(data, max_output)
}
}
struct AsciiHexStreamFilter;
impl StreamFilter for AsciiHexStreamFilter {
fn decode_pipeline_owned<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(AsciiHexDecoder::new(
"asciiHex decode",
next,
))))
}
fn pipe_decode_recovering(
&mut self,
data: &[u8],
max_output: Option<usize>,
_warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
) -> Result<FilterDecodeOutcome> {
decode_ascii_hex(data, max_output)
}
}
struct RunLengthStreamFilter;
impl StreamFilter for RunLengthStreamFilter {
fn decode_pipeline_owned<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(RunLength::new(
"runlength decode",
next,
RunLengthAction::Decode,
))))
}
fn pipe_decode_recovering(
&mut self,
data: &[u8],
max_output: Option<usize>,
_warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
) -> Result<FilterDecodeOutcome> {
decode_run_length(data, max_output)
}
fn is_specialized_compression(&self) -> bool {
true
}
}
struct DctStreamFilter;
impl StreamFilter for DctStreamFilter {
fn decode_pipeline_owned<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(PlDct::new(
"DCT decode",
next,
))))
}
fn pipe_decode_recovering(
&mut self,
data: &[u8],
max_output: Option<usize>,
_warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
) -> Result<FilterDecodeOutcome> {
let mut sink = OutputBuffer::new(max_output);
let finish_phase = sink.finish_phase();
let output_position = sink.output_position();
let error = {
let mut stage = PlDct::new("DCT decode", &mut sink).with_max_output(max_output);
write_and_finish(
&mut stage,
data,
Some(finish_phase.as_ref()),
&output_position,
)
.map(map_stage_error)
};
let cleanup_data_start = sink.cleanup_data_start();
Ok(FilterDecodeOutcome {
data: sink.data,
cleanup_data_start,
error,
})
}
fn is_specialized_compression(&self) -> bool {
true
}
fn is_lossy_compression(&self) -> bool {
true
}
}
struct CryptStreamFilter;
fn crypt_params_type_entry(decode_params: &DecodeParams) -> Option<&ParamValue> {
decode_params
.entries()
.iter()
.find(|(key, _)| key.as_slice() == b"Type")
.map(|(_, value)| value)
}
fn crypt_params_have_type(type_entry: Option<&ParamValue>) -> bool {
type_entry.is_some()
}
fn crypt_params_are_dictionary_of_type(type_entry: Option<&ParamValue>) -> bool {
matches!(type_entry, Some(ParamValue::Name(name)) if name.as_slice() == b"CryptFilterDecodeParms")
}
impl StreamFilter for CryptStreamFilter {
fn reads_decode_params(&self) -> bool {
true
}
fn set_decode_params(&mut self, decode_params: &DecodeParams) -> bool {
if decode_params.is_absent() {
return true;
}
let type_entry = crypt_params_type_entry(decode_params);
let mut filterable = true;
for (key, _) in decode_params.entries() {
if ((key.as_slice() == b"Type") || (key.as_slice() == b"Name"))
&& ((!crypt_params_have_type(type_entry))
|| crypt_params_are_dictionary_of_type(type_entry))
{
} else {
filterable = false;
}
}
filterable
}
fn decode_pipeline_owned<'a>(
&mut self,
_next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::NoStage(_next))
}
fn pipe_decode_recovering(
&mut self,
_data: &[u8],
_max_output: Option<usize>,
_warn: &mut dyn FnMut(&str, i32, usize, FilterDecodePhase) -> PipelineResult<()>,
) -> Result<FilterDecodeOutcome> {
Err(Error::Unsupported(CRYPT_STAGE_UNSUPPORTED.to_string()))
}
}
pub(crate) fn stream_filter_for(filter_name: &[u8]) -> Option<Box<dyn StreamFilter>> {
match filter_name {
b"Crypt" => Some(Box::new(CryptStreamFilter)),
b"FlateDecode" => Some(Box::new(FlateLzwStreamFilter::new(false))),
b"LZWDecode" => Some(Box::new(FlateLzwStreamFilter::new(true))),
b"ASCII85Decode" => Some(Box::new(Ascii85StreamFilter)),
b"ASCIIHexDecode" => Some(Box::new(AsciiHexStreamFilter)),
b"RunLengthDecode" => Some(Box::new(RunLengthStreamFilter)),
b"DCTDecode" => Some(Box::new(DctStreamFilter)),
_ => None,
}
}
fn decode_ascii85(data: &[u8], max_output: Option<usize>) -> Result<FilterDecodeOutcome> {
let mut sink = OutputBuffer::new(max_output);
let finish_phase = sink.finish_phase();
let output_position = sink.output_position();
let error = {
let mut stage = Ascii85Decoder::new("ascii85 decode", &mut sink);
write_and_finish(&mut stage, data, Some(&finish_phase), &output_position)
.map(map_stage_error)
};
Ok(FilterDecodeOutcome {
cleanup_data_start: sink.cleanup_data_start(),
data: sink.data,
error,
})
}
fn decode_ascii_hex(data: &[u8], max_output: Option<usize>) -> Result<FilterDecodeOutcome> {
let mut sink = OutputBuffer::new(max_output);
let finish_phase = sink.finish_phase();
let output_position = sink.output_position();
let error = {
let mut stage = AsciiHexDecoder::new("asciiHex decode", &mut sink);
write_and_finish(&mut stage, data, Some(&finish_phase), &output_position)
.map(map_stage_error)
};
Ok(FilterDecodeOutcome {
cleanup_data_start: sink.cleanup_data_start(),
data: sink.data,
error,
})
}
fn decode_run_length(data: &[u8], max_output: Option<usize>) -> Result<FilterDecodeOutcome> {
let mut sink = OutputBuffer::new(max_output);
let finish_phase = sink.finish_phase();
let output_position = sink.output_position();
let error = {
let mut stage = RunLength::new("runlength decode", &mut sink, RunLengthAction::Decode);
write_and_finish(&mut stage, data, Some(&finish_phase), &output_position)
.map(map_stage_error)
};
Ok(FilterDecodeOutcome {
cleanup_data_start: sink.cleanup_data_start(),
data: sink.data,
error,
})
}
pub(crate) fn encode_flate(data: &[u8]) -> Result<Vec<u8>> {
let mut sink = Buffer::new("stream data buffer", None);
{
let mut flate = Flate::new(
"compress stream",
&mut sink,
FlateAction::Deflate,
DEFAULT_OUT_BUFFER_SIZE,
)
.map_err(map_pipeline_error)?;
flate.write(data).map_err(map_pipeline_error)?;
flate.finish().map_err(map_pipeline_error)?;
}
sink.take_buffer().map_err(map_pipeline_error)
}
fn predictor_encode_geometry(
filter_name: &[u8],
decode_params: &DecodeParams,
) -> Result<Option<PredictorGeometry>> {
if !matches!(filter_name, b"FlateDecode" | b"LZWDecode") {
let Some(mut filter) = stream_filter_for(filter_name) else {
return Ok(None);
};
if !filter.set_decode_params(decode_params) {
return Err(Error::Unsupported(format!(
"stream filter {} does not support supplied /DecodeParms",
String::from_utf8_lossy(filter_name)
)));
}
return Ok(None);
}
let mut filter = FlateLzwStreamFilter::new(filter_name == b"LZWDecode");
if !filter.set_decode_params(decode_params) {
return Err(Error::Unsupported(format!(
"stream filter {} does not support supplied /DecodeParms",
String::from_utf8_lossy(filter_name)
)));
}
filter.decode_predictor_geometry()
}
pub(crate) fn encode_predictor(
data: &[u8],
filter_name: &[u8],
decode_params: &DecodeParams,
) -> Result<Vec<u8>> {
let Some(geometry) = predictor_encode_geometry(filter_name, decode_params)? else {
return Ok(data.to_vec());
};
encode_predictor_stage(data, geometry)
}
fn encode_predictor_stage(data: &[u8], geometry: PredictorGeometry) -> Result<Vec<u8>> {
let mut sink = Buffer::new("stream data buffer", None);
{
let mut predictor =
make_predictor_pipeline(geometry, &mut sink, PredictorAction::Encode, None)?;
predictor.write(data).map_err(map_pipeline_error)?;
predictor.finish().map_err(map_pipeline_error)?;
}
sink.take_buffer().map_err(map_pipeline_error)
}
pub(crate) fn encode_run_length(data: &[u8]) -> Result<Vec<u8>> {
let mut sink = Buffer::new("stream data buffer", None);
{
let mut stage = RunLength::new("compress stream", &mut sink, RunLengthAction::Encode);
stage.write(data).map_err(map_pipeline_error)?;
stage.finish().map_err(map_pipeline_error)?;
}
sink.take_buffer().map_err(map_pipeline_error)
}
#[cfg(test)]
mod tests {
use super::{DecodeParams, FlateLzwStreamFilter, ParamValue, StreamFilter};
use crate::pipeline::test_support::RecordingSink;
use crate::pipeline::PipelineRef;
fn wide_tiff_decode_params() -> DecodeParams {
DecodeParams::Present(vec![
(b"Predictor".to_vec(), ParamValue::Int(2)),
(b"Columns".to_vec(), ParamValue::Int(536_870_911)),
(b"Colors".to_vec(), ParamValue::Int(1)),
(b"BitsPerComponent".to_vec(), ParamValue::Int(8)),
])
}
fn wide_tiff_filter() -> FlateLzwStreamFilter {
let mut filter = FlateLzwStreamFilter::new(false);
assert!(filter.set_decode_params(&wide_tiff_decode_params()));
filter.set_tiff_memory_limit(Some(1 << 20));
filter
}
#[test]
fn owned_decode_pipeline_applies_tiff_memory_limit_before_codec_construction() {
let mut filter = wide_tiff_filter();
let mut sink = RecordingSink::new(&[], &[]);
let result = filter.decode_pipeline_owned(PipelineRef::from(&mut sink));
assert!(result.is_err());
let error = result.err().unwrap();
assert!(error
.to_string()
.contains("TIFFPredictor memory limit exceeded"));
}
#[test]
fn recovering_decode_pipeline_applies_tiff_memory_limit_before_codec_writes() {
let mut filter = wide_tiff_filter();
let result = filter.pipe_decode_recovering(&[], None, &mut |_, _, _, _| Ok(()));
assert!(result.is_err());
let error = result.err().unwrap();
assert!(error
.to_string()
.contains("TIFFPredictor memory limit exceeded"));
}
#[test]
fn encode_predictor_uses_the_tiff_stream_filter_pipeline() {
let params = DecodeParams::Present(vec![
(b"Predictor".to_vec(), ParamValue::Int(2)),
(b"Columns".to_vec(), ParamValue::Int(2)),
(b"Colors".to_vec(), ParamValue::Int(1)),
(b"BitsPerComponent".to_vec(), ParamValue::Int(8)),
]);
assert_eq!(
super::encode_predictor(&[10, 20], b"FlateDecode", ¶ms).unwrap(),
[10, 10]
);
}
}