use crate::object_handle::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::collections::BTreeMap;
use std::sync::{Arc, Mutex, MutexGuard, OnceLock};
type FilterWarningCallback = Box<dyn FnMut(&str, i32) -> PipelineResult<()> + 'static>;
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) 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";
fn map_pipeline_error(error: PipelineError) -> Error {
Error::Unsupported(error.into_string_lossy())
}
pub trait StreamFilter: 'static {
fn set_decode_params(&mut self, decode_params: &ObjectHandle) -> Result<bool> {
decode_params.try_is_null()
}
fn get_decode_pipeline<'a>(&mut self, next: PipelineRef<'a>)
-> Result<OwnedDecodePipeline<'a>>;
fn is_specialized_compression(&self) -> bool {
false
}
fn is_lossy_compression(&self) -> bool {
false
}
}
pub 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>,
}
#[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 {
#[cfg(test)]
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,
}
}
}
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 set_decode_params(&mut self, decode_params: &ObjectHandle) -> Result<bool> {
if decode_params.try_is_null()? {
return Ok(true);
}
let mut filterable = true;
for key in decode_params.try_get_keys()? {
let value = decode_params.try_get_key(&key)?;
let key = key.as_slice();
match key {
b"/Predictor" => {
let Some(_) = value.try_as_integer()? else {
filterable = false;
continue;
};
let predictor = value.try_get_int_value_as_int()?;
self.predictor = predictor;
if !((predictor == 1) || (predictor == 2) || (10..=15).contains(&predictor)) {
filterable = false;
}
}
b"/Columns" | b"/Colors" | b"/BitsPerComponent" => {
let Some(_) = value.try_as_integer()? else {
filterable = false;
continue;
};
let parameter = value.try_get_int_value_as_int()?;
match key {
b"/Columns" => self.columns = parameter,
b"/Colors" => self.colors = parameter,
_ => self.bits_per_component = parameter,
}
}
b"/EarlyChange" if self.lzw => {
let Some(_) = value.try_as_integer()? else {
filterable = false;
continue;
};
let early_change = value.try_get_int_value_as_int()?;
self.early_code_change = early_change == 1;
if !((early_change == 0) || (early_change == 1)) {
filterable = false;
}
}
_ => {}
}
}
if (self.predictor > 1) && (self.columns == 0) {
filterable = false;
}
Ok(filterable)
}
fn get_decode_pipeline<'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)?,
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))
}
}
impl FlateLzwStreamFilter {
fn set_warning_callback(&mut self, callback: FilterWarningCallback) {
self.warning_callback = Some(callback);
}
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 make_predictor_pipeline<'a>(
geometry: PredictorGeometry,
next: impl Into<PipelineRef<'a>>,
action: PredictorAction,
) -> Result<PipelineRef<'a>> {
let next = next.into();
let pipeline = match (geometry.kind, action) {
#[cfg(test)]
(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>,
#[cfg(test)]
(PredictorKind::Tiff, PredictorAction::Encode) => Box::new(
TiffPredictor::new(
"tiff encode",
next,
TiffPredictorAction::Encode,
geometry.columns,
geometry.colors,
geometry.bits_per_component,
)
.map_err(map_pipeline_error)?,
) as Box<dyn Pipeline + 'a>,
(PredictorKind::Tiff, PredictorAction::Decode) => Box::new(
TiffPredictor::new(
"tiff decode",
next,
TiffPredictorAction::Decode,
geometry.columns,
geometry.colors,
geometry.bits_per_component,
)
.map_err(map_pipeline_error)?,
) as Box<dyn Pipeline + 'a>,
};
Ok(PipelineRef::Owned(pipeline))
}
struct Ascii85StreamFilter;
impl StreamFilter for Ascii85StreamFilter {
fn get_decode_pipeline<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(Ascii85Decoder::new(
"ascii85 decode",
next,
))))
}
}
struct AsciiHexStreamFilter;
impl StreamFilter for AsciiHexStreamFilter {
fn get_decode_pipeline<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(AsciiHexDecoder::new(
"asciiHex decode",
next,
))))
}
}
struct RunLengthStreamFilter;
impl StreamFilter for RunLengthStreamFilter {
fn get_decode_pipeline<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(RunLength::new(
"runlength decode",
next,
RunLengthAction::Decode,
))))
}
fn is_specialized_compression(&self) -> bool {
true
}
}
struct DctStreamFilter;
impl StreamFilter for DctStreamFilter {
fn get_decode_pipeline<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::Stage(Box::new(PlDct::new(
"DCT decode",
next,
))))
}
fn is_specialized_compression(&self) -> bool {
true
}
fn is_lossy_compression(&self) -> bool {
true
}
}
struct CryptStreamFilter;
impl StreamFilter for CryptStreamFilter {
fn set_decode_params(&mut self, decode_params: &ObjectHandle) -> Result<bool> {
if decode_params.try_is_null()? {
return Ok(true);
}
let mut filterable = true;
for key in decode_params.try_get_keys()? {
let is_allowed_key = (key.as_slice() == b"/Type") || (key.as_slice() == b"/Name");
if is_allowed_key
&& (!decode_params.try_has_key(b"/Type")?
|| decode_params.try_is_dictionary_of_type(b"CryptFilterDecodeParms", b"")?)
{
} else {
filterable = false;
}
}
Ok(filterable)
}
fn get_decode_pipeline<'a>(
&mut self,
_next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
Ok(OwnedDecodePipeline::NoStage(_next))
}
}
pub(crate) trait RegisteredStreamFilter {
fn set_decode_params(&mut self, decode_params: &ObjectHandle) -> Result<bool>;
fn get_decode_pipeline<'a>(&mut self, next: PipelineRef<'a>)
-> Result<OwnedDecodePipeline<'a>>;
fn set_warning_callback(&mut self, _callback: FilterWarningCallback) {}
fn is_specialized_compression(&self) -> bool;
fn is_lossy_compression(&self) -> bool;
}
struct CustomStreamFilter {
inner: Box<dyn StreamFilter>,
}
impl RegisteredStreamFilter for CustomStreamFilter {
fn set_decode_params(&mut self, decode_params: &ObjectHandle) -> Result<bool> {
self.inner.set_decode_params(decode_params)
}
fn get_decode_pipeline<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
self.inner.get_decode_pipeline(next)
}
fn is_specialized_compression(&self) -> bool {
self.inner.is_specialized_compression()
}
fn is_lossy_compression(&self) -> bool {
self.inner.is_lossy_compression()
}
}
struct BuiltinStreamFilter<T> {
inner: T,
}
impl<T: StreamFilter> RegisteredStreamFilter for BuiltinStreamFilter<T> {
fn set_decode_params(&mut self, decode_params: &ObjectHandle) -> Result<bool> {
self.inner.set_decode_params(decode_params)
}
fn get_decode_pipeline<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
self.inner.get_decode_pipeline(next)
}
fn is_specialized_compression(&self) -> bool {
self.inner.is_specialized_compression()
}
fn is_lossy_compression(&self) -> bool {
self.inner.is_lossy_compression()
}
}
struct BuiltinFlateStreamFilter {
inner: FlateLzwStreamFilter,
}
impl RegisteredStreamFilter for BuiltinFlateStreamFilter {
fn set_decode_params(&mut self, decode_params: &ObjectHandle) -> Result<bool> {
self.inner.set_decode_params(decode_params)
}
fn get_decode_pipeline<'a>(
&mut self,
next: PipelineRef<'a>,
) -> Result<OwnedDecodePipeline<'a>> {
self.inner.get_decode_pipeline(next)
}
fn set_warning_callback(&mut self, callback: FilterWarningCallback) {
self.inner.set_warning_callback(callback);
}
fn is_specialized_compression(&self) -> bool {
self.inner.is_specialized_compression()
}
fn is_lossy_compression(&self) -> bool {
self.inner.is_lossy_compression()
}
}
type CustomFilterFactory = Arc<dyn Fn() -> Result<Box<dyn StreamFilter>> + Send + Sync + 'static>;
#[derive(Clone)]
enum FilterFactory {
Builtin(fn() -> Box<dyn RegisteredStreamFilter>),
Custom(CustomFilterFactory),
}
static FILTER_FACTORIES: OnceLock<Mutex<BTreeMap<Vec<u8>, FilterFactory>>> = OnceLock::new();
fn filter_factories() -> &'static Mutex<BTreeMap<Vec<u8>, FilterFactory>> {
FILTER_FACTORIES.get_or_init(|| {
Mutex::new(BTreeMap::from([
(
b"/Crypt".to_vec(),
FilterFactory::Builtin(|| {
Box::new(BuiltinStreamFilter {
inner: CryptStreamFilter,
})
}),
),
(
b"/FlateDecode".to_vec(),
FilterFactory::Builtin(|| {
Box::new(BuiltinFlateStreamFilter {
inner: FlateLzwStreamFilter::new(false),
})
}),
),
(
b"/LZWDecode".to_vec(),
FilterFactory::Builtin(|| {
Box::new(BuiltinFlateStreamFilter {
inner: FlateLzwStreamFilter::new(true),
})
}),
),
(
b"/ASCII85Decode".to_vec(),
FilterFactory::Builtin(|| {
Box::new(BuiltinStreamFilter {
inner: Ascii85StreamFilter,
})
}),
),
(
b"/ASCIIHexDecode".to_vec(),
FilterFactory::Builtin(|| {
Box::new(BuiltinStreamFilter {
inner: AsciiHexStreamFilter,
})
}),
),
(
b"/RunLengthDecode".to_vec(),
FilterFactory::Builtin(|| {
Box::new(BuiltinStreamFilter {
inner: RunLengthStreamFilter,
})
}),
),
(
b"/DCTDecode".to_vec(),
FilterFactory::Builtin(|| {
Box::new(BuiltinStreamFilter {
inner: DctStreamFilter,
})
}),
),
]))
})
}
fn registry_guard() -> MutexGuard<'static, BTreeMap<Vec<u8>, FilterFactory>> {
filter_factories()
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
pub fn register_stream_filter<F, S>(name: impl AsRef<[u8]>, factory: F)
where
F: Fn() -> Result<S> + Send + Sync + 'static,
S: StreamFilter + 'static,
{
let factory =
Arc::new(move || factory().map(|filter| Box::new(filter) as Box<dyn StreamFilter>));
let key = name.as_ref().to_vec();
let previous = {
let mut registry = registry_guard();
registry.insert(key, FilterFactory::Custom(factory))
};
drop(previous);
}
pub(crate) fn stream_filter_for(
filter_name: &[u8],
) -> Result<Option<Box<dyn RegisteredStreamFilter>>> {
let normalized = normalize_filter_name(filter_name);
let mut key = Vec::with_capacity(normalized.len() + 1);
key.push(b'/');
key.extend_from_slice(normalized);
let factory = registry_guard().get(&key).cloned();
match factory {
None => Ok(None),
Some(FilterFactory::Builtin(factory)) => Ok(Some(factory())),
Some(FilterFactory::Custom(factory)) => {
Ok(Some(Box::new(CustomStreamFilter { inner: factory()? })))
}
}
}
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)
}
#[cfg(test)]
fn predictor_encode_geometry(
filter_name: &[u8],
decode_params: &ObjectHandle,
) -> 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()
}
#[cfg(test)]
pub(crate) fn encode_predictor(
data: &[u8],
filter_name: &[u8],
decode_params: &ObjectHandle,
) -> Result<Vec<u8>> {
let Some(geometry) = predictor_encode_geometry(filter_name, decode_params)? else {
return Ok(data.to_vec());
};
encode_predictor_stage(data, geometry)
}
#[cfg(test)]
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)?;
predictor.write(data).map_err(map_pipeline_error)?;
predictor.finish().map_err(map_pipeline_error)?;
}
sink.take_buffer().map_err(map_pipeline_error)
}
#[cfg(test)]
mod tests {
use super::{FlateLzwStreamFilter, StreamFilter};
use crate::ObjectHandle;
#[test]
fn flate_filter_consumes_qpdf_canonical_slash_prefixed_keys() {
let mut filter = FlateLzwStreamFilter::new(false);
let params =
ObjectHandle::dictionary(vec![(b"/Predictor".to_vec(), ObjectHandle::integer(2))]);
assert!(filter.set_decode_params(¶ms).unwrap());
assert_eq!(filter.predictor, 2);
}
#[test]
fn flate_setter_rejects_non_integer_geometry_parameters() {
for key in [b"/Predictor".as_slice(), b"/Columns"] {
let params = ObjectHandle::dictionary(vec![(
key.to_vec(),
ObjectHandle::name(b"not-an-integer".to_vec()),
)]);
let mut filter = FlateLzwStreamFilter::new(false);
assert!(!filter.set_decode_params(¶ms).unwrap());
}
let params = ObjectHandle::dictionary(vec![(
b"/EarlyChange".to_vec(),
ObjectHandle::name(b"not-an-integer".to_vec()),
)]);
let mut filter = FlateLzwStreamFilter::new(true);
assert!(!filter.set_decode_params(¶ms).unwrap());
}
#[test]
fn flate_reader_preserves_canonical_key_matching_and_ignores_raw_unknown_keys() {
fn decode_params(key: &[u8]) -> ObjectHandle {
let params = ObjectHandle::dictionary(vec![]);
params
.replace_key(key, ObjectHandle::integer(2))
.expect("decode parameter dictionary is mutable");
params
}
let canonical = decode_params(b"/Predictor");
let raw = decode_params(b"Predictor");
let special_unknown = decode_params(b"/Predictor B");
let mut canonical_filter = FlateLzwStreamFilter::new(false);
assert!(canonical_filter.set_decode_params(&canonical).unwrap());
assert_eq!(canonical_filter.predictor, 2);
let mut raw_filter = FlateLzwStreamFilter::new(false);
assert!(raw_filter.set_decode_params(&raw).unwrap());
assert_eq!(raw_filter.predictor, 1);
let mut special_filter = FlateLzwStreamFilter::new(false);
assert!(special_filter.set_decode_params(&special_unknown).unwrap());
assert_eq!(special_filter.predictor, 1);
}
#[test]
fn flate_setter_warns_only_when_qpdf_reads_an_integer_parameter() {
let (huge, recorder) = crate::object_handle::warning_emission_tests::handle_resolving(
crate::object_handle::ObjectValue::Integer(i64::MAX),
);
let params = ObjectHandle::dictionary(vec![
(b"Columns".to_vec(), huge.clone()),
(b"Foo".to_vec(), huge.clone()),
(b"EarlyChange".to_vec(), huge),
]);
let mut filter = FlateLzwStreamFilter::new(false);
assert!(filter.set_decode_params(¶ms).unwrap());
assert_eq!(
crate::object_handle::warning_emission_tests::warnings(&recorder),
vec!["object 3 0: requested value of integer is too big; returning INT_MAX"]
);
}
#[test]
fn base_stream_filter_accepts_only_null_decode_parameters() {
let mut filter = super::AsciiHexStreamFilter;
assert!(filter.set_decode_params(&ObjectHandle::null()).unwrap());
assert!(!filter
.set_decode_params(&ObjectHandle::dictionary(vec![]))
.unwrap());
}
#[test]
fn crypt_reader_preserves_qpdf_name_and_type_validation() {
fn decode_params(entries: Vec<(Vec<u8>, ObjectHandle)>) -> ObjectHandle {
ObjectHandle::dictionary(entries)
}
let mut identity_filter = super::CryptStreamFilter;
let identity = decode_params(vec![(
b"/Name".to_vec(),
ObjectHandle::name(b"Identity".to_vec()),
)]);
assert!(identity_filter.set_decode_params(&identity).unwrap());
let mut valid_type_filter = super::CryptStreamFilter;
let valid_type = decode_params(vec![(
b"/Type".to_vec(),
ObjectHandle::name(b"CryptFilterDecodeParms".to_vec()),
)]);
assert!(valid_type_filter.set_decode_params(&valid_type).unwrap());
let mut unknown_key_filter = super::CryptStreamFilter;
let unknown_key = decode_params(vec![(b"/Foo".to_vec(), ObjectHandle::integer(1))]);
assert!(!unknown_key_filter.set_decode_params(&unknown_key).unwrap());
let mut invalid_type_filter = super::CryptStreamFilter;
let invalid_type = decode_params(vec![(
b"/Type".to_vec(),
ObjectHandle::name(b"Foo".to_vec()),
)]);
assert!(!invalid_type_filter
.set_decode_params(&invalid_type)
.unwrap());
let mut null_filter = super::CryptStreamFilter;
assert!(null_filter
.set_decode_params(&ObjectHandle::null())
.unwrap());
}
#[test]
fn crypt_setter_reads_a_non_dictionary_once_before_accepting_empty_keys() {
let (params, recorder) = crate::object_handle::warning_emission_tests::handle_resolving(
crate::object_handle::ObjectValue::Integer(1),
);
let mut filter = super::CryptStreamFilter;
assert!(filter.set_decode_params(¶ms).unwrap());
assert_eq!(
crate::object_handle::warning_emission_tests::warnings(&recorder),
vec![
"object 3 0: operation for dictionary attempted on object of type integer: treating as empty"
]
);
}
#[test]
fn lzw_reader_consumes_only_canonical_early_change_keys() {
fn decode_params(_filter_name: &[u8], key: &[u8], value: i64) -> ObjectHandle {
let params = ObjectHandle::dictionary(vec![]);
params
.replace_key(key, ObjectHandle::integer(value))
.expect("decode parameter dictionary is mutable");
params
}
for (value, expected_filterable, expected_early_change) in
[(0, true, false), (1, true, true), (2, false, false)]
{
let params = decode_params(b"LZWDecode", b"/EarlyChange", value);
let mut filter = FlateLzwStreamFilter::new(true);
assert_eq!(
filter.set_decode_params(¶ms).unwrap(),
expected_filterable
);
assert_eq!(filter.early_code_change, expected_early_change);
}
let raw = decode_params(b"LZWDecode", b"EarlyChange", 0);
let mut raw_filter = FlateLzwStreamFilter::new(true);
assert!(raw_filter.set_decode_params(&raw).unwrap());
assert!(raw_filter.early_code_change);
let flate = decode_params(b"FlateDecode", b"/EarlyChange", 0);
let mut flate_filter = FlateLzwStreamFilter::new(false);
assert!(flate_filter.set_decode_params(&flate).unwrap());
assert!(flate_filter.early_code_change);
}
#[test]
fn encode_predictor_uses_the_tiff_stream_filter_pipeline() {
let params = ObjectHandle::dictionary(vec![
(b"/Predictor".to_vec(), ObjectHandle::integer(2)),
(b"/Columns".to_vec(), ObjectHandle::integer(2)),
(b"/Colors".to_vec(), ObjectHandle::integer(1)),
(b"/BitsPerComponent".to_vec(), ObjectHandle::integer(8)),
]);
assert_eq!(
super::encode_predictor(&[10, 20], b"FlateDecode", ¶ms).unwrap(),
[10, 10]
);
}
#[test]
fn encode_predictor_leaves_unknown_filter_data_unchanged() {
assert_eq!(
super::encode_predictor(b"payload", b"UnknownFilter", &ObjectHandle::null()).unwrap(),
b"payload"
);
}
}