mirror of
https://github.com/storytold/pdfcraft.git
synced 2026-11-18 04:57:05 +00:00
Merge #4393: M2: an Indexed image with a short lookup table or an out-of-range hival is drawn as most readers draw it, and one with no table is skipped with a warning (view.render-pages)
# Conflicts: # vendor/README.md
This commit is contained in:
@@ -440,6 +440,12 @@ pub(crate) fn render(args: &[String]) -> Result<(), CliError> {
|
||||
let _ =
|
||||
writeln!(std::io::stderr().lock(), "warning: page {page}: a colour that could not be computed was painted in a fallback colour");
|
||||
}
|
||||
pdfcraft_render::RenderWarning::MalformedIndexedImage => {
|
||||
let _ = writeln!(
|
||||
std::io::stderr().lock(),
|
||||
"warning: page {page}: an image with a malformed Indexed colour table may be drawn wrongly or not at all"
|
||||
);
|
||||
}
|
||||
pdfcraft_render::RenderWarning::Type3WidthsMissing => {
|
||||
let _ = writeln!(
|
||||
std::io::stderr().lock(),
|
||||
|
||||
@@ -414,6 +414,7 @@ fn render_warning_text(warning: pdfcraft_render::RenderWarning) -> &'static str
|
||||
match warning {
|
||||
RenderWarning::ContentTruncated => "content past the page's safety budget was skipped",
|
||||
RenderWarning::ColourFallback => "a colour that could not be computed was painted in a fallback colour",
|
||||
RenderWarning::MalformedIndexedImage => "an image with a malformed Indexed colour table may be drawn wrongly or not at all",
|
||||
RenderWarning::Type3WidthsMissing => "a Type 3 font has no /Widths; its glyphs were spaced by the widths their glyph procedures give",
|
||||
}
|
||||
}
|
||||
|
||||
@@ -96,6 +96,33 @@ fn a_clean_page_renders_to_the_png_alone() {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
/// An image whose Indexed lookup table is too short (ISO 32000-2 §8.6.6.3) is drawn recovered, and
|
||||
/// `page_render` says so in the words `pdfcraft-cli render` prints.
|
||||
#[test]
|
||||
fn page_render_reports_a_recovered_malformed_indexed_image() {
|
||||
let dir = std::env::temp_dir().join(format!("pdfcraft-render-warnings-indexed-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let content = "q 200 0 0 200 0 0 cm /Im Do Q";
|
||||
// hival 7 over DeviceRGB needs 24 bytes; the table holds 6.
|
||||
let pdf = format!(
|
||||
"%PDF-1.7\n1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n\
|
||||
2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n\
|
||||
3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Resources << /XObject << /Im 5 0 R >> >> /Contents 4 0 R >> endobj\n\
|
||||
4 0 obj << /Length {} >> stream\n{content}\nendstream endobj\n\
|
||||
5 0 obj << /Type /XObject /Subtype /Image /Width 2 /Height 1 /BitsPerComponent 8 /ColorSpace [/Indexed /DeviceRGB 7 <FF0000 00FF00>] /Filter /ASCIIHexDecode /Length 5 >> stream\n0001>\nendstream endobj\n\
|
||||
trailer << /Root 1 0 R >>\n%%EOF",
|
||||
content.len()
|
||||
);
|
||||
std::fs::write(dir.join("indexed.pdf"), pdf).unwrap();
|
||||
let mut a = Automation::new().with_root(&dir).unwrap();
|
||||
let doc = open(&mut a, "indexed.pdf");
|
||||
let out = a.call("page_render", &json!({ "doc": doc, "page": 1, "dpi": 72 })).unwrap();
|
||||
let Some(Content::Json(report)) = out.get(1) else { panic!("expected the warnings as JSON: {out:?}") };
|
||||
assert_eq!(report["warnings"], json!(["an image with a malformed Indexed colour table may be drawn wrongly or not at all"]));
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
/// Over MCP the warnings are a text block after the image and the call's `structuredContent`.
|
||||
#[cfg(feature = "mcp")]
|
||||
#[test]
|
||||
|
||||
@@ -270,6 +270,13 @@ pub enum RenderWarning {
|
||||
/// A colour could not be computed (a colour space that cannot be read, or a Separation or
|
||||
/// DeviceN tint transform that cannot be evaluated) and was painted in a fallback colour.
|
||||
ColourFallback,
|
||||
/// An image's `/Indexed` colour space is malformed (ISO 32000-2 §8.6.6.3), so the image may be
|
||||
/// drawn wrongly or not at all. It is drawn recovered when it can be: indices past a lookup
|
||||
/// table shorter than m × (hival + 1) bytes in black, a `hival` past 255 taken as 255, a real
|
||||
/// one truncated, or (a `hival` below zero or not a number) the image in DeviceGray. With no
|
||||
/// lookup table at all (missing, not a string or a stream, or a stream that does not decode)
|
||||
/// it is not drawn. Reported once per page however many images it affects.
|
||||
MalformedIndexedImage,
|
||||
/// A Type 3 font without the `/Widths` it requires (ISO 32000-2 Table 110) was used; its
|
||||
/// glyphs were spaced by the widths their glyph procedures give.
|
||||
Type3WidthsMissing,
|
||||
@@ -477,10 +484,12 @@ fn warning_settings(settings: &InterpreterSettings, warnings: Arc<Mutex<Vec<Rend
|
||||
InterpreterSettings {
|
||||
warning_sink: Arc::new(move |warning| {
|
||||
// Nested forms, Type 3 glyphs and patterns are interpreted again and each reports the
|
||||
// exhausted budget, or the colours that fell back: once per page is enough.
|
||||
// exhausted budget, or the colours that fell back, and several images can share one
|
||||
// malformed colour space: each warning is recorded once per page.
|
||||
let warning = match warning {
|
||||
InterpreterWarning::ContentTruncated => RenderWarning::ContentTruncated,
|
||||
InterpreterWarning::ColorFallback => RenderWarning::ColourFallback,
|
||||
InterpreterWarning::MalformedIndexedImage => RenderWarning::MalformedIndexedImage,
|
||||
InterpreterWarning::Type3WidthsMissing => RenderWarning::Type3WidthsMissing,
|
||||
InterpreterWarning::UnsupportedFont | InterpreterWarning::ImageDecodeFailure => return,
|
||||
};
|
||||
|
||||
@@ -9282,6 +9282,10 @@ fn an_averaged_down_soft_mask_follows_its_samples_and_its_drawn_size() {
|
||||
// ICC profiles whose stream dictionaries are the same (vendored hayro-interpret patch 48).
|
||||
mod icc_profile_cache;
|
||||
|
||||
// An Indexed resource named by many inline images reads its lookup once (vendored
|
||||
// hayro-interpret patch 80).
|
||||
mod indexed_lookup_cache;
|
||||
|
||||
// A Type 3 glyph shown again decodes its procedure once (vendored hayro-interpret patch 87).
|
||||
mod type3_proc_cache;
|
||||
|
||||
|
||||
@@ -0,0 +1,75 @@
|
||||
//! An `/Indexed` colour space named by a resource is built once, and its lookup table read
|
||||
//! once, however many inline images name it (vendored hayro-interpret patch 80). An earlier
|
||||
//! version of the patch checked the table again before every inline image, decoding a lookup
|
||||
//! stream once per image outside the colour-space cache.
|
||||
|
||||
use super::image_cache_pdf;
|
||||
|
||||
/// A page that draws `count` 2 × 1 inline images in the resource colour space `/P`, an Indexed
|
||||
/// space over DeviceRGB with `hival` whose lookup is stream object 5 holding `table`.
|
||||
fn page(count: usize, hival: u8, table: &[u8]) -> Vec<u8> {
|
||||
let image = "q 20 0 0 20 0 0 cm BI /W 2 /H 1 /BPC 8 /CS /P /F /AHx ID 0001> EI Q";
|
||||
let content = vec![image; count].join("\n");
|
||||
let resources = format!("<< /ColorSpace << /P [/Indexed /DeviceRGB {hival} 5 0 R] >> >>");
|
||||
let dict = format!("<< /Length {} >>", table.len());
|
||||
image_cache_pdf(&content, &resources, &[(&dict, table)])
|
||||
}
|
||||
|
||||
fn lookup_reads(pdf: Vec<u8>) -> [usize; 2] {
|
||||
use hayro::hayro_interpret::font::Glyph;
|
||||
use hayro::hayro_interpret::hayro_syntax::Pdf;
|
||||
use hayro::hayro_interpret::{
|
||||
BlendMode, ClipPath, Context, Device, GlyphDrawMode, Image, InterpreterCache, InterpreterSettings, Paint, PathDrawMode, SoftMask,
|
||||
TransformExt, interpret_page,
|
||||
};
|
||||
use kurbo::{Affine, BezPath, Rect};
|
||||
use std::sync::Arc;
|
||||
|
||||
/// Draws nothing: only the colour spaces the page reads matter here.
|
||||
struct Nothing;
|
||||
impl<'a> Device<'a> for Nothing {
|
||||
fn set_soft_mask(&mut self, _: Option<SoftMask<'a>>) {}
|
||||
fn set_blend_mode(&mut self, _: BlendMode) {}
|
||||
fn draw_path(&mut self, _: &BezPath, _: Affine, _: &Paint<'a>, _: &PathDrawMode) {}
|
||||
fn push_clip_path(&mut self, _: &ClipPath) {}
|
||||
fn push_transparency_group(&mut self, _: f32, _: Option<SoftMask<'a>>, _: BlendMode) {}
|
||||
fn draw_glyph(&mut self, _: &Glyph<'a>, _: Affine, _: Affine, _: &Paint<'a>, _: &GlyphDrawMode) {}
|
||||
fn draw_image(&mut self, _: Image<'a, '_>, _: Affine) {}
|
||||
fn pop_clip_path(&mut self) {}
|
||||
fn pop_transparency_group(&mut self) {}
|
||||
}
|
||||
|
||||
let pdf = Pdf::new(Arc::new(pdf)).expect("parses");
|
||||
let page = &pdf.pages()[0];
|
||||
let cache = InterpreterCache::new();
|
||||
[(); 2].map(|()| {
|
||||
let initial = page.initial_transform(true).to_kurbo();
|
||||
let mut ctx = Context::new(initial, Rect::new(0.0, 0.0, 130.0, 70.0), &cache, page.xref(), InterpreterSettings::default());
|
||||
interpret_page(page, &mut ctx, &mut Nothing);
|
||||
cache.indexed_lookup_reads()
|
||||
})
|
||||
}
|
||||
|
||||
/// Twenty inline images naming one resource read its lookup stream once, in the first render
|
||||
/// and none in a second render through the same cache: for a full table, and for a short one
|
||||
/// that is padded (whose images an earlier version of the patch checked, and skipped, one by
|
||||
/// one).
|
||||
#[test]
|
||||
fn inline_images_naming_one_indexed_resource_read_its_lookup_once() {
|
||||
let full = page(20, 1, b"\xFF\x00\x00\x00\xFF\x00");
|
||||
assert_eq!(lookup_reads(full), [1, 1], "a full table: read once, then cached");
|
||||
let short = page(20, 7, b"\xFF\x00\x00\x00\xFF\x00");
|
||||
assert_eq!(lookup_reads(short), [1, 1], "a short table: read once, then cached");
|
||||
}
|
||||
|
||||
/// Two Indexed resources whose arrays differ (`/P` names object 5, `/Q` object 6) are two
|
||||
/// spaces: each is built, and its table read, once, and neither stands in for the other.
|
||||
#[test]
|
||||
fn two_indexed_resources_are_cached_apart() {
|
||||
let image = |name: &str| format!("q 20 0 0 20 0 0 cm BI /W 2 /H 1 /BPC 8 /CS /{name} /F /AHx ID 0001> EI Q");
|
||||
let content = [image("P"), image("Q"), image("P"), image("Q")].join("\n");
|
||||
let resources = "<< /ColorSpace << /P [/Indexed /DeviceRGB 1 5 0 R] /Q [/Indexed /DeviceRGB 1 6 0 R] >> >>";
|
||||
let (red_green, blue_white): (&[u8], &[u8]) = (b"\xFF\x00\x00\x00\xFF\x00", b"\x00\x00\xFF\xFF\xFF\xFF");
|
||||
let pdf = image_cache_pdf(&content, resources, &[("<< /Length 6 >>", red_green), ("<< /Length 6 >>", blue_white)]);
|
||||
assert_eq!(lookup_reads(pdf), [2, 2], "each table read once");
|
||||
}
|
||||
@@ -0,0 +1,458 @@
|
||||
//! An `/Indexed` image whose colour space breaks ISO 32000-2 §8.6.6.3 (a lookup table shorter
|
||||
//! than m × (hival + 1) bytes, or a `hival` past 255 or with a fraction) is drawn as most
|
||||
//! readers draw it, and the render reports `RenderWarning::MalformedIndexedImage`:
|
||||
//! - a short table keeps the entries it holds in full, and an index past them is drawn black,
|
||||
//! whatever the base space;
|
||||
//! - a `hival` past 255 is taken as 255;
|
||||
//! - a real `hival` is truncated toward zero.
|
||||
//!
|
||||
//! An image whose lookup is missing, `null`, neither a string nor a stream, or a stream that
|
||||
//! does not decode is not drawn, and is reported. A `hival` that is negative or not a number
|
||||
//! keeps the upstream handling (the image falls back to DeviceGray), and is reported too.
|
||||
//! Upstream fell back to DeviceGray for every one of these, painting the indices as near-black
|
||||
//! grey levels, even those whose entries were present.
|
||||
//!
|
||||
//! The images are 8 × 1, samples 0 to 7, each column 25 px wide on a 200 × 200 page (the layout
|
||||
//! of the seven cases A to G a reviewer compared across readers on #4393).
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use pdfcraft_render::{PageRenderer, RenderConfig, RenderRequest, RenderWarning, RenderedPage, RequestKind};
|
||||
|
||||
/// The eight entries the tests' tables hold, in order.
|
||||
const TABLE: &str = "FF0000 00FF00 0000FF FFFF00 FF00FF 00FFFF 808080 000000";
|
||||
const COLOURS: [[u8; 3]; 8] = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0], [255, 0, 255], [0, 255, 255], [128, 128, 128], [0, 0, 0]];
|
||||
const BLACK: [u8; 3] = [0, 0, 0];
|
||||
const WHITE: [u8; 3] = [255, 255, 255];
|
||||
const DRAW_IMAGE: &str = "q 200 0 0 200 0 0 cm /Im Do Q";
|
||||
const MALFORMED: [RenderWarning; 1] = [RenderWarning::MalformedIndexedImage];
|
||||
|
||||
/// The first `n` hex entries of `TABLE`.
|
||||
fn entries(n: usize) -> String {
|
||||
TABLE.split(' ').take(n).collect::<Vec<_>>().join(" ")
|
||||
}
|
||||
|
||||
/// A 200 × 200 page whose `/Im` image is eight samples wide (indices 0 to 7) and covers the
|
||||
/// page, with `/P` naming `colour_space` as a resource. `extra` objects are numbered from 6.
|
||||
fn pdf(colour_space: &str, content: &str, extra: &[&[u8]]) -> Vec<u8> {
|
||||
pdf_with_resource("P", colour_space, content, extra)
|
||||
}
|
||||
|
||||
/// As `pdf`, with the colour space resource named `resource` rather than `/P`.
|
||||
fn pdf_with_resource(resource: &str, colour_space: &str, content: &str, extra: &[&[u8]]) -> Vec<u8> {
|
||||
pdf_with_resources(resource, colour_space, "", content, extra)
|
||||
}
|
||||
|
||||
/// As `pdf_with_resource`, with `more` entries in the page's resource dictionary.
|
||||
fn pdf_with_resources(resource: &str, colour_space: &str, more: &str, content: &str, extra: &[&[u8]]) -> Vec<u8> {
|
||||
let mut objs: Vec<Vec<u8>> = vec![
|
||||
b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
|
||||
b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec(),
|
||||
format!(
|
||||
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Contents 4 0 R \
|
||||
/Resources << /XObject << /Im 5 0 R >> /ColorSpace << /{resource} {colour_space} >> {more} >> >>"
|
||||
)
|
||||
.into_bytes(),
|
||||
format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len()).into_bytes(),
|
||||
format!(
|
||||
"<< /Type /XObject /Subtype /Image /Width 8 /Height 1 /BitsPerComponent 8 \
|
||||
/ColorSpace {colour_space} /Filter /ASCIIHexDecode /Length 17 >>\nstream\n0001020304050607>\nendstream"
|
||||
)
|
||||
.into_bytes(),
|
||||
];
|
||||
objs.extend(extra.iter().map(|o| o.to_vec()));
|
||||
let mut out = b"%PDF-1.7\n".to_vec();
|
||||
let mut offsets = Vec::new();
|
||||
for (i, body) in objs.iter().enumerate() {
|
||||
offsets.push(out.len());
|
||||
out.extend_from_slice(format!("{} 0 obj\n", i + 1).as_bytes());
|
||||
out.extend_from_slice(body);
|
||||
out.extend_from_slice(b"\nendobj\n");
|
||||
}
|
||||
let xref = out.len();
|
||||
let size = objs.len() + 1;
|
||||
out.extend_from_slice(format!("xref\n0 {size}\n0000000000 65535 f \n").as_bytes());
|
||||
for off in offsets {
|
||||
out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
|
||||
}
|
||||
out.extend_from_slice(format!("trailer\n<< /Size {size} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes());
|
||||
out
|
||||
}
|
||||
|
||||
fn render(bytes: Vec<u8>) -> RenderedPage {
|
||||
let page = PageRenderer::new(Arc::new(bytes), RenderConfig::default()).render(RenderRequest {
|
||||
page: 0,
|
||||
kind: RequestKind::Pixels,
|
||||
tile: None,
|
||||
scale: 1.0,
|
||||
tag: 0,
|
||||
preview: false,
|
||||
});
|
||||
assert!(page.error.is_none(), "{:?}", page.error);
|
||||
assert_eq!((page.width, page.height), (200, 200));
|
||||
page
|
||||
}
|
||||
|
||||
/// The centre pixel of each of the eight columns (indices 0 to 7), RGB.
|
||||
fn columns(page: &RenderedPage) -> [[u8; 3]; 8] {
|
||||
std::array::from_fn(|i| {
|
||||
let at = (100 * page.width as usize + 12 + 25 * i) * 4;
|
||||
let px = page.rgba.get(at..at + 3).expect("pixel inside the page");
|
||||
[px[0], px[1], px[2]]
|
||||
})
|
||||
}
|
||||
|
||||
/// The first `n` of `COLOURS`, then black: a table of `n` entries.
|
||||
fn padded(n: usize) -> [[u8; 3]; 8] {
|
||||
std::array::from_fn(|i| if i < n { COLOURS[i] } else { BLACK })
|
||||
}
|
||||
|
||||
/// Index `i` drawn as the grey level `i` / 255: the DeviceGray fallback.
|
||||
fn grey_fallback() -> [[u8; 3]; 8] {
|
||||
std::array::from_fn(|i| [i as u8; 3])
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn assert_page(colour_space: &str, extra: &[&[u8]], want: [[u8; 3]; 8], warned: bool) {
|
||||
let page = render(pdf(colour_space, DRAW_IMAGE, extra));
|
||||
assert_eq!(columns(&page), want, "{colour_space}: the columns");
|
||||
let want_warnings: &[RenderWarning] = if warned { &MALFORMED } else { &[] };
|
||||
assert_eq!(page.warnings, want_warnings, "{colour_space}: the warnings");
|
||||
}
|
||||
|
||||
/// Case A: a full table draws its eight colours, with no warning.
|
||||
#[test]
|
||||
fn a_full_table_draws_its_colours() {
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 7 <{TABLE}>]"), &[], COLOURS, false);
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 7.0 <{TABLE}>]"), &[], COLOURS, false);
|
||||
}
|
||||
|
||||
/// Cases B and F: a short table keeps the entries it holds, and an index past them is black.
|
||||
#[test]
|
||||
fn a_short_table_draws_its_entries_and_black_past_them() {
|
||||
// B: hival 7 needs 24 bytes; 6 are given. Indices 0 and 1 used to draw black.
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 7 <{}>]", entries(2)), &[], padded(2), true);
|
||||
// F: one entry short.
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 7 <{}>]", entries(7)), &[], padded(7), true);
|
||||
// One byte short: entry 1 is incomplete, so it is not held; indices past hival take it.
|
||||
let mut want = [BLACK; 8];
|
||||
want[0] = COLOURS[0];
|
||||
assert_page("[/Indexed /DeviceRGB 1 <FF0000 00FF>]", &[], want, true);
|
||||
}
|
||||
|
||||
/// The base space for each of the short-table tests below, with its two-entry table, and the
|
||||
/// stream objects it needs (numbered from 6).
|
||||
fn short_table_in(base: &str, table: &str) -> String {
|
||||
format!("[/Indexed {base} 7 <{table}>]")
|
||||
}
|
||||
|
||||
/// A short table over `base`: the two entries it holds draw as they do with a full table (the
|
||||
/// rest of which is white, never drawn black by a reader), and every index past them is black.
|
||||
/// Zero bytes would be white in DeviceCMYK, Separation and DeviceN, and blue in Lab.
|
||||
#[track_caller]
|
||||
fn assert_black_past_the_table(base: &str, two: &str, white: &str, extra: &[&[u8]]) {
|
||||
let full = render(pdf(&short_table_in(base, &format!("{two} {}", white.repeat(6))), DRAW_IMAGE, extra));
|
||||
assert!(full.warnings.is_empty(), "{base}: {:?}", full.warnings);
|
||||
let full = columns(&full);
|
||||
assert!(full[..2].iter().all(|c| *c != BLACK && *c != WHITE), "{base}: the two entries have colour: {full:?}");
|
||||
let page = render(pdf(&short_table_in(base, two), DRAW_IMAGE, extra));
|
||||
assert_eq!(page.warnings, MALFORMED, "{base}");
|
||||
let mut want = [BLACK; 8];
|
||||
want[..2].copy_from_slice(&full[..2]);
|
||||
assert_eq!(columns(&page), want, "{base}: entries 2 to 7 are black");
|
||||
}
|
||||
|
||||
/// DeviceGray: zero is black here, so a zero-padded table drew the same (a guard).
|
||||
#[test]
|
||||
fn indices_past_a_short_table_are_black_over_device_gray() {
|
||||
assert_black_past_the_table("/DeviceGray", "40 80", "FF ", &[]);
|
||||
}
|
||||
|
||||
/// DeviceCMYK: a zero entry would be white (no ink).
|
||||
#[test]
|
||||
fn indices_past_a_short_table_are_black_over_device_cmyk() {
|
||||
assert_black_past_the_table("/DeviceCMYK", "FF000000 00FF0000", "00000000 ", &[]);
|
||||
}
|
||||
|
||||
/// Lab: a zero entry would be L* 0 with a* and b* at the bottom of their ranges, blue.
|
||||
#[test]
|
||||
fn indices_past_a_short_table_are_black_over_lab() {
|
||||
assert_black_past_the_table("[/Lab << /WhitePoint [0.9505 1 1.089] /Range [-128 127 -128 127] >>]", "80FF80 8080FF", "FF8080 ", &[]);
|
||||
}
|
||||
|
||||
/// Separation (a spot orange: tint 1 is orange in DeviceCMYK): a zero entry would be tint 0,
|
||||
/// white.
|
||||
#[test]
|
||||
fn indices_past_a_short_table_are_black_over_separation() {
|
||||
assert_black_past_the_table(
|
||||
"[/Separation /Orange /DeviceCMYK << /FunctionType 2 /Domain [0 1] /C0 [0 0 0 0] /C1 [0 0.5 1 0] /N 1 >>]",
|
||||
"FF 80",
|
||||
"00 ",
|
||||
&[],
|
||||
);
|
||||
}
|
||||
|
||||
/// DeviceN (cyan and magenta, mapped onto DeviceCMYK by a Type 4 function): a zero entry would
|
||||
/// be white.
|
||||
#[test]
|
||||
fn indices_past_a_short_table_are_black_over_device_n() {
|
||||
let tint: &[u8] = b"<< /FunctionType 4 /Domain [0 1 0 1] /Range [0 1 0 1 0 1 0 1] /Length 9 >>\nstream\n{ 0 0 }\nendstream";
|
||||
assert_black_past_the_table("[/DeviceN [/Cyan /Magenta] /DeviceCMYK 6 0 R]", "FF00 00FF", "0000 ", &[tint]);
|
||||
}
|
||||
|
||||
/// ICCBased with four components and no usable profile, drawn in its /Alternate DeviceCMYK: a
|
||||
/// zero entry would be white.
|
||||
#[test]
|
||||
fn indices_past_a_short_table_are_black_over_icc_based_with_four_components() {
|
||||
let profile: &[u8] = b"<< /N 4 /Alternate /DeviceCMYK /Length 4 >>\nstream\nJUNK\nendstream";
|
||||
assert_black_past_the_table("[/ICCBased 6 0 R]", "FF000000 00FF0000", "00000000 ", &[profile]);
|
||||
}
|
||||
|
||||
/// Case C: an index past `hival` takes the nearest entry (ISO 32000-2 §8.6.6.3: "shall be
|
||||
/// adjusted to the nearest value within that range"); a table longer than needed is fine.
|
||||
#[test]
|
||||
fn an_index_past_hival_takes_the_last_entry() {
|
||||
let mut want = COLOURS;
|
||||
want[4..].fill(COLOURS[3]);
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 3 <{TABLE}>]"), &[], want, false);
|
||||
}
|
||||
|
||||
/// Case D: a `hival` past 255 is taken as 255, and the table padded to 256 entries.
|
||||
#[test]
|
||||
fn a_hival_past_255_is_clamped() {
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 300 <{TABLE}>]"), &[], COLOURS, true);
|
||||
// With a table long enough for 301 entries, the clamp alone is reported.
|
||||
let long = format!("<{TABLE}{}>", "00".repeat(3 * 293));
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 300 {long}]"), &[], COLOURS, true);
|
||||
// 256, one past.
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 256 <{TABLE}{}>]", "00".repeat(3 * 249)), &[], COLOURS, true);
|
||||
// 255, the largest, with a full table draws without a warning.
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 255 <{TABLE}{}>]", "00".repeat(3 * 248)), &[], COLOURS, false);
|
||||
}
|
||||
|
||||
/// Case E: a real `hival` is truncated toward zero, as hayro read it before patch (80).
|
||||
#[test]
|
||||
fn a_real_hival_is_truncated() {
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 7.5 <{TABLE}>]"), &[], COLOURS, true);
|
||||
// 6.9 is 6, not 7: index 7 takes entry 6.
|
||||
let mut want = COLOURS;
|
||||
want[7] = COLOURS[6];
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 6.9 <{TABLE}>]"), &[], want, true);
|
||||
// -0.5 is 0 (toward zero; a real above -1 truncates to 0): every index takes entry 0.
|
||||
assert_page(&format!("[/Indexed /DeviceRGB -0.5 <{TABLE}>]"), &[], [COLOURS[0]; 8], true);
|
||||
// 255.5 is 255; 255.0 written as a real is the integer 255.
|
||||
let full = format!("<{TABLE}{}>", "00".repeat(3 * 248));
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 255.5 {full}]"), &[], COLOURS, true);
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 255.0 {full}]"), &[], COLOURS, false);
|
||||
}
|
||||
|
||||
/// Case G: inline images, named through the resources or given in place, are recovered too, and
|
||||
/// skipped when the space has no table.
|
||||
#[test]
|
||||
fn inline_images_with_a_short_table_are_recovered_too() {
|
||||
let inline = |cs: &str| format!("q 200 0 0 200 0 0 cm BI /W 8 /H 1 /BPC 8 /CS {cs} /F /AHx ID 0001020304050607> EI Q");
|
||||
let short = format!("[/Indexed /DeviceRGB 7 <{}>]", entries(2));
|
||||
// Named through the page's resources.
|
||||
let page = render(pdf_with_resource("CS0", &short, &inline("/CS0"), &[]));
|
||||
assert_eq!(columns(&page), padded(2));
|
||||
assert_eq!(page.warnings, MALFORMED);
|
||||
// Given in place, with the inline abbreviations.
|
||||
let page = render(pdf("/DeviceRGB", &inline(&format!("[/I /RGB 7 <{}>]", entries(2))), &[]));
|
||||
assert_eq!(columns(&page), padded(2));
|
||||
assert_eq!(page.warnings, MALFORMED);
|
||||
// A `hival` with no reading falls back and is reported, named or in place.
|
||||
let page = render(pdf(&format!("[/Indexed /DeviceRGB -1 <{TABLE}>]"), &inline("/P"), &[]));
|
||||
assert_eq!((columns(&page), page.warnings), (grey_fallback(), MALFORMED.to_vec()));
|
||||
let page = render(pdf("/DeviceRGB", &inline(&format!("[/I /RGB -1 <{TABLE}>]")), &[]));
|
||||
assert_eq!((columns(&page), page.warnings), (grey_fallback(), MALFORMED.to_vec()));
|
||||
// No table: not drawn, named or in place.
|
||||
let page = render(pdf("[/Indexed /DeviceRGB 7 null]", &inline("/P"), &[]));
|
||||
assert_eq!((columns(&page), page.warnings), ([WHITE; 8], MALFORMED.to_vec()));
|
||||
let page = render(pdf("/DeviceRGB", &inline("[/I /RGB 7]"), &[]));
|
||||
assert_eq!((columns(&page), page.warnings), ([WHITE; 8], MALFORMED.to_vec()));
|
||||
// A well-formed one draws without a warning.
|
||||
let page = render(pdf(&format!("[/Indexed /DeviceRGB 7 <{TABLE}>]"), &inline("/P"), &[]));
|
||||
assert_eq!(columns(&page), COLOURS);
|
||||
assert!(page.warnings.is_empty(), "{:?}", page.warnings);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_inline_device_space_name_ignores_a_resource_of_the_same_name() {
|
||||
// ISO 32000-2 §8.6.8 (the CS operator): the device colour space names never refer to
|
||||
// resources in the ColorSpace subdictionary, so a malformed Indexed resource that shares the
|
||||
// name (here the inline abbreviation `/RGB`, and `/DeviceRGB`) is not used.
|
||||
let data: String = TABLE.split(' ').collect();
|
||||
for (resource, cs) in [("RGB", "/RGB"), ("DeviceRGB", "/DeviceRGB")] {
|
||||
let content = format!("q 200 0 0 200 0 0 cm BI /W 8 /H 1 /BPC 8 /CS {cs} /F /AHx ID {data}> EI Q");
|
||||
let page = render(pdf_with_resource(resource, "[/Indexed /DeviceRGB 7 <FF0000 00FF00>]", &content, &[]));
|
||||
assert_eq!(columns(&page), COLOURS, "{cs}: the device space draws");
|
||||
assert!(page.warnings.is_empty(), "{cs}: {:?}", page.warnings);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_page_with_several_malformed_images_reports_the_warning_once() {
|
||||
let content = format!("{DRAW_IMAGE} {DRAW_IMAGE} 0 0 1 rg 0 0 10 10 re f");
|
||||
let page = render(pdf(&format!("[/Indexed /DeviceRGB 7 <{}>]", entries(2)), &content, &[]));
|
||||
assert_eq!(page.warnings, MALFORMED);
|
||||
assert_eq!(columns(&page), padded(2));
|
||||
let at = (195 * page.width as usize + 5) * 4;
|
||||
assert_eq!(page.rgba.get(at..at + 3), Some(&[0u8, 0, 255][..]), "content after the images still draws");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_lookup_string_given_by_reference_is_read() {
|
||||
// A lookup is a byte string or a stream (ISO 32000-2 §8.6.6.3), and either may be indirect.
|
||||
// A string by reference used to be missed: trying it as a stream consumed the reference.
|
||||
let full = format!("<{TABLE}>");
|
||||
assert_page("[/Indexed /DeviceRGB 7 6 0 R]", &[full.as_bytes()], COLOURS, false);
|
||||
let short = format!("<{}>", entries(2));
|
||||
assert_page("[/Indexed /DeviceRGB 7 6 0 R]", &[short.as_bytes()], padded(2), true);
|
||||
// Something that is neither a string nor a stream is no table: the image is not drawn.
|
||||
assert_page("[/Indexed /DeviceRGB 7 6 0 R]", &[b"42"], [WHITE; 8], true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_table_size_holds_at_the_bounds_of_hival_and_the_base() {
|
||||
// Four components (DeviceCMYK): hival 1 needs 8 bytes. With 7, entry 1 is incomplete, so it
|
||||
// is not held: index 1, and the indices past hival that take it, are black.
|
||||
let full = render(pdf("[/Indexed /DeviceCMYK 1 <FF000000 00FF0000>]", DRAW_IMAGE, &[]));
|
||||
assert!(full.warnings.is_empty(), "{:?}", full.warnings);
|
||||
assert_ne!(columns(&full)[0], WHITE, "the image is drawn");
|
||||
let short = render(pdf("[/Indexed /DeviceCMYK 1 <FF000000 00FF00>]", DRAW_IMAGE, &[]));
|
||||
assert_eq!(short.warnings, MALFORMED);
|
||||
let mut want = [BLACK; 8];
|
||||
want[0] = columns(&full)[0];
|
||||
assert_eq!(columns(&short), want);
|
||||
// One component (DeviceGray): hival 0 needs one byte; an empty table holds no entry.
|
||||
assert_page("[/Indexed /DeviceGray 0 <80>]", &[], [[128; 3]; 8], false);
|
||||
assert_page("[/Indexed /DeviceGray 0 <>]", &[], [BLACK; 8], true);
|
||||
// hival 255 over DeviceRGB needs 768 bytes: 767 is one short.
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 255 <{TABLE}{}>]", "00".repeat(3 * 248 - 1)), &[], COLOURS, true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hival_that_would_overflow_a_size_is_clamped_without_panicking() {
|
||||
// Values whose (hival + 1) × components would overflow a 32-bit or 64-bit size, or that do
|
||||
// not fit an integer at all, are taken as 255.
|
||||
for hival in ["4294967295", "4294967296", "18446744073709551615", "99999999999999999999999"] {
|
||||
assert_page(&format!("[/Indexed /DeviceRGB {hival} <{}>]", entries(2)), &[], padded(2), true);
|
||||
}
|
||||
}
|
||||
|
||||
/// A `hival` that is negative or not a number has no reading to recover: the image keeps the
|
||||
/// upstream handling (it falls back to DeviceGray), and the warning is still reported.
|
||||
#[test]
|
||||
fn a_negative_or_non_numeric_hival_falls_back_with_a_warning() {
|
||||
for hival in ["-1", "-1.5", "-2147483649", "/One", "null"] {
|
||||
assert_page(&format!("[/Indexed /DeviceRGB {hival} <{TABLE}>]"), &[], grey_fallback(), true);
|
||||
}
|
||||
}
|
||||
|
||||
/// An empty string is a table that holds no entry: every index is black.
|
||||
#[test]
|
||||
fn an_empty_table_draws_black() {
|
||||
for lookup in ["<>", "()"] {
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 1 {lookup}]"), &[], padded(0), true);
|
||||
}
|
||||
}
|
||||
|
||||
/// A lookup that is missing, `null` or a number is no table at all: the image is not drawn (the
|
||||
/// page stays white), and the warning is reported.
|
||||
#[test]
|
||||
fn a_missing_lookup_skips_the_image() {
|
||||
for lookup in ["", "null", "42"] {
|
||||
assert_page(&format!("[/Indexed /DeviceRGB 7 {lookup}]"), &[], [WHITE; 8], true);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_lookup_stream_is_measured_after_decoding() {
|
||||
let short: &[u8] = b"<< /Length 14 /Filter /ASCIIHexDecode >>\nstream\nFF0000 00FF00>\nendstream";
|
||||
assert_page("[/Indexed /DeviceRGB 7 6 0 R]", &[short], padded(2), true);
|
||||
let mut want = [COLOURS[1]; 8];
|
||||
want[0] = COLOURS[0];
|
||||
assert_page("[/Indexed /DeviceRGB 1 6 0 R]", &[short], want, false);
|
||||
// An empty stream decodes to an empty table, which holds no entry.
|
||||
let empty: &[u8] = b"<< /Length 0 >>\nstream\n\nendstream";
|
||||
assert_page("[/Indexed /DeviceRGB 1 6 0 R]", &[empty], padded(0), true);
|
||||
}
|
||||
|
||||
/// A stream that does not decode is no table: the image is not drawn, and is reported.
|
||||
#[test]
|
||||
fn a_lookup_stream_that_cannot_be_decoded_skips_the_image() {
|
||||
for broken in [
|
||||
&b"<< /Length 12 /Filter /FlateDecode >>\nstream\nnot deflated\nendstream"[..],
|
||||
b"<< /Length 6 /Filter /FlateDecode >>\nstream\nnot-zl\nendstream",
|
||||
] {
|
||||
assert_page("[/Indexed /DeviceRGB 7 6 0 R]", &[broken], [WHITE; 8], true);
|
||||
}
|
||||
}
|
||||
|
||||
/// An Indexed space whose base cannot be read keeps the upstream handling (DeviceGray), whatever
|
||||
/// its `hival`; only a `hival` with no reading is reported.
|
||||
#[test]
|
||||
fn an_unreadable_base_keeps_its_fallback() {
|
||||
for (hival, warned) in [("1", false), ("300", false), ("-1", true)] {
|
||||
assert_page(&format!("[/Indexed /NoSuchSpace {hival} <{TABLE}>]"), &[], grey_fallback(), warned);
|
||||
}
|
||||
}
|
||||
|
||||
/// A fill or stroke colour set in such a space (`cs`, `sc`, `CS`, `SC`) draws through the same
|
||||
/// recovered table, and the recovery is reported as `ColourFallback`, as the upstream DeviceGray
|
||||
/// fallback was.
|
||||
#[test]
|
||||
fn a_fill_or_stroke_colour_in_a_short_table_is_recovered_and_reported() {
|
||||
let fill = |index: u8| format!("/P cs {index} sc 0 0 200 200 re f");
|
||||
let short = format!("[/Indexed /DeviceRGB 7 <{}>]", entries(2));
|
||||
let page = render(pdf(&short, &fill(1), &[]));
|
||||
assert_eq!(columns(&page)[0], COLOURS[1], "entry 1 is green");
|
||||
assert_eq!(page.warnings, vec![RenderWarning::ColourFallback]);
|
||||
let page = render(pdf(&short, &fill(5), &[]));
|
||||
assert_eq!(columns(&page)[0], BLACK, "entry 5 is past the table");
|
||||
// Over DeviceCMYK too, where a zero entry would be white.
|
||||
let cmyk = "[/Indexed /DeviceCMYK 7 <FF000000 00FF0000>]";
|
||||
let page = render(pdf(cmyk, &fill(5), &[]));
|
||||
assert_eq!(columns(&page)[0], BLACK, "DeviceCMYK entry 5 is past the table");
|
||||
// A stroke colour (`CS`, `SC`) the same way.
|
||||
let page = render(pdf(&short, "/P CS 1 SC 20 w 0 100 m 200 100 l S", &[]));
|
||||
assert_eq!(columns(&page)[0], COLOURS[1], "the stroke is green");
|
||||
assert_eq!(page.warnings, vec![RenderWarning::ColourFallback]);
|
||||
let page = render(pdf(&format!("[/Indexed /DeviceRGB 7 <{TABLE}>]"), &fill(1), &[]));
|
||||
assert_eq!(columns(&page)[0], COLOURS[1]);
|
||||
assert!(page.warnings.is_empty(), "{:?}", page.warnings);
|
||||
}
|
||||
|
||||
/// A fill colour in an Indexed space with no lookup table keeps the upstream fallback: DeviceGray,
|
||||
/// reported as `ColourFallback` (tint 1 is white, over a red fill).
|
||||
#[test]
|
||||
fn a_fill_colour_in_a_space_with_no_table_keeps_the_fallback() {
|
||||
for lookup in ["", "null"] {
|
||||
let content = "1 0 0 rg 0 0 200 200 re f /P cs 1 sc 0 0 200 200 re f";
|
||||
let page = render(pdf(&format!("[/Indexed /DeviceRGB 7 {lookup}]"), content, &[]));
|
||||
assert_eq!(columns(&page)[0], WHITE, "{lookup:?}: DeviceGray 1");
|
||||
assert_eq!(page.warnings, vec![RenderWarning::ColourFallback], "{lookup:?}");
|
||||
// A stroke colour the same way.
|
||||
let content = "1 0 0 rg 0 0 200 200 re f /P CS 1 SC 20 w 0 100 m 200 100 l S";
|
||||
let page = render(pdf(&format!("[/Indexed /DeviceRGB 7 {lookup}]"), content, &[]));
|
||||
assert_eq!(columns(&page)[0], WHITE, "{lookup:?}: a DeviceGray 1 stroke");
|
||||
assert_eq!(page.warnings, vec![RenderWarning::ColourFallback], "{lookup:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Only images and the colour operators handle a space with no table: anything else reads it as
|
||||
/// upstream did, as a space that cannot be read. A shading in one is not drawn.
|
||||
#[test]
|
||||
fn a_shading_in_a_space_with_no_table_is_not_drawn() {
|
||||
let shading = |cs: &str| {
|
||||
format!(
|
||||
"/Shading << /Sh << /ShadingType 2 /ColorSpace {cs} /Coords [0 0 200 0] \
|
||||
/Function << /FunctionType 2 /Domain [0 1] /C0 [0] /C1 [1] /N 1 >> /Extend [true true] >> >>"
|
||||
)
|
||||
};
|
||||
let page = render(pdf_with_resources("P", "/DeviceRGB", &shading("[/Indexed /DeviceRGB 1 null]"), "/Sh sh", &[]));
|
||||
assert_eq!(columns(&page), [WHITE; 8]);
|
||||
// The same shading with a table draws.
|
||||
let page = render(pdf_with_resources("P", "/DeviceRGB", &shading("[/Indexed /DeviceRGB 1 <FF0000 00FF00>]"), "/Sh sh", &[]));
|
||||
assert_ne!(columns(&page), [WHITE; 8]);
|
||||
}
|
||||
@@ -3,6 +3,7 @@
|
||||
mod cid_cff_unusable_font_dict;
|
||||
mod cid_fallback_query;
|
||||
mod fill_stroke_knockout;
|
||||
mod indexed_lookup;
|
||||
mod inline_image_ei;
|
||||
mod jbig2_invariants;
|
||||
mod knockout_backdrop;
|
||||
|
||||
Vendored
+1
-1
File diff suppressed because one or more lines are too long
Vendored
+21
-3
@@ -10,9 +10,10 @@ use std::sync::{Arc, Mutex};
|
||||
|
||||
type CacheMap = HashMap<u128, Option<Box<dyn Any + Send + Sync>>>;
|
||||
/// The objects read from a document, by key. PdfCraft patch (48): the second field counts the
|
||||
/// ICC profiles read through it ([`Cache::icc_profile_reads`]).
|
||||
/// ICC profiles read through it ([`Cache::icc_profile_reads`]). PdfCraft patch (80): the third
|
||||
/// counts the `/Indexed` lookup tables read ([`Cache::indexed_lookup_reads`]).
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct Cache(Arc<Mutex<CacheMap>>, Arc<AtomicUsize>);
|
||||
pub(crate) struct Cache(Arc<Mutex<CacheMap>>, Arc<AtomicUsize>, Arc<AtomicUsize>);
|
||||
impl Default for Cache {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
@@ -21,7 +22,11 @@ impl Default for Cache {
|
||||
|
||||
impl Cache {
|
||||
pub(crate) fn new() -> Self {
|
||||
Self(Arc::new(Mutex::new(HashMap::new())), Arc::default())
|
||||
Self(
|
||||
Arc::new(Mutex::new(HashMap::new())),
|
||||
Arc::default(),
|
||||
Arc::default(),
|
||||
)
|
||||
}
|
||||
|
||||
/// PdfCraft patch (48): count one ICC profile read, the colour space of an `/ICCBased`
|
||||
@@ -35,6 +40,17 @@ impl Cache {
|
||||
self.1.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): count one `/Indexed` lookup table read (a stream decoded or a
|
||||
/// string copied).
|
||||
pub(crate) fn count_indexed_lookup_read(&self) {
|
||||
self.2.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): how many `/Indexed` lookup tables were read through this cache.
|
||||
pub(crate) fn indexed_lookup_reads(&self) -> usize {
|
||||
self.2.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
pub(crate) fn get_or_insert_with<T: Clone + Send + Sync + 'static>(
|
||||
&self,
|
||||
id: u128,
|
||||
@@ -142,6 +158,7 @@ fn warning_bit(warning: InterpreterWarning) -> u8 {
|
||||
InterpreterWarning::ContentTruncated => 4,
|
||||
InterpreterWarning::ColorFallback => 8,
|
||||
InterpreterWarning::Type3WidthsMissing => 16,
|
||||
InterpreterWarning::MalformedIndexedImage => 32,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -153,6 +170,7 @@ fn warnings_in(bits: u8) -> impl Iterator<Item = InterpreterWarning> {
|
||||
InterpreterWarning::ContentTruncated,
|
||||
InterpreterWarning::ColorFallback,
|
||||
InterpreterWarning::Type3WidthsMissing,
|
||||
InterpreterWarning::MalformedIndexedImage,
|
||||
]
|
||||
.into_iter()
|
||||
.filter(move |warning| bits & warning_bit(*warning) != 0)
|
||||
|
||||
Vendored
+160
-30
@@ -258,7 +258,7 @@ impl ColorSpaceType {
|
||||
return Some(Self::Lab(Lab::new(&lab_dict)?));
|
||||
}
|
||||
INDEXED | I => {
|
||||
return Some(Self::Indexed(Indexed::new(&color_array, cache, depth)?));
|
||||
return Some(Self::Indexed(Indexed::new(&color_array, cache, depth, false)?));
|
||||
}
|
||||
SEPARATION => {
|
||||
return Some(Self::Separation(Separation::new(&color_array, cache, depth)?));
|
||||
@@ -312,6 +312,22 @@ impl ColorSpace {
|
||||
Some(Self(Arc::new(ColorSpaceType::new(object, cache, depth)?)))
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): as `new`, except that an `/Indexed` space with no lookup table is
|
||||
/// built (marked tableless) rather than unreadable, for the image and colour operators to
|
||||
/// handle it (see `Indexed::new`). Every other space is read as by `new`.
|
||||
pub(crate) fn new_allowing_tableless(object: Object<'_>, cache: &Cache) -> Option<Self> {
|
||||
if let Object::Array(array) = &object
|
||||
&& array
|
||||
.flex_iter()
|
||||
.next::<Name<'_>>()
|
||||
.is_some_and(|family| matches!(family.deref(), INDEXED | I))
|
||||
{
|
||||
return Indexed::new(array, cache, 0, true)
|
||||
.map(|indexed| Self(Arc::new(ColorSpaceType::Indexed(indexed))));
|
||||
}
|
||||
Self::new(object, cache)
|
||||
}
|
||||
|
||||
/// Create a new color space from the name.
|
||||
pub(crate) fn new_from_name(name: &Name<'_>) -> Option<Self> {
|
||||
ColorSpaceType::new_from_name(name).map(|c| Self(Arc::new(c)))
|
||||
@@ -354,6 +370,18 @@ impl ColorSpace {
|
||||
matches!(self.0.as_ref(), ColorSpaceType::Indexed(_))
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): whether this is an indexed colour space that broke ISO 32000-2
|
||||
/// §8.6.6.3 and was recovered (see `Indexed::new`).
|
||||
pub(crate) fn is_recovered_indexed(&self) -> bool {
|
||||
matches!(self.0.as_ref(), ColorSpaceType::Indexed(i) if i.recovered && !i.tableless)
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): whether this is an indexed colour space with no lookup table (see
|
||||
/// `Indexed::new`), which only `ColorSpace::new_allowing_tableless` builds.
|
||||
pub(crate) fn is_tableless_indexed(&self) -> bool {
|
||||
matches!(self.0.as_ref(), ColorSpaceType::Indexed(i) if i.tableless)
|
||||
}
|
||||
|
||||
/// Get the default decode array for the color space.
|
||||
pub(crate) fn default_decode_arr(&self, n: f32) -> SmallVec<[(f32, f32); 4]> {
|
||||
match self.0.as_ref() {
|
||||
@@ -1003,55 +1031,144 @@ impl ToRgb for Lab {
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct Indexed {
|
||||
/// `hival + 1` entries of the base's component count each; entries from `present` on are
|
||||
/// zeros and are drawn black (see `convert_f32`).
|
||||
values: Vec<Vec<f32>>,
|
||||
hival: u8,
|
||||
base: Box<ColorSpace>,
|
||||
/// PdfCraft patch (80): how many entries the lookup table holds in full (at most
|
||||
/// `hival + 1`). An index at or past it is drawn black.
|
||||
present: usize,
|
||||
/// PdfCraft patch (80): the space broke ISO 32000-2 §8.6.6.3 and was recovered (see
|
||||
/// `Indexed::new`).
|
||||
recovered: bool,
|
||||
/// PdfCraft patch (80): the space has no lookup table at all (see `Indexed::new`).
|
||||
tableless: bool,
|
||||
}
|
||||
|
||||
impl Indexed {
|
||||
fn new(array: &Array<'_>, cache: &Cache, depth: u32) -> Option<Self> {
|
||||
/// PdfCraft patch (80): ISO 32000-2 §8.6.6.3 says `hival` "shall be an integer" no greater
|
||||
/// than 255 and the lookup table "shall be m × (hival + 1) bytes long", but not how a reader
|
||||
/// recovers when a file breaks this. Most readers draw such a space, and so does this:
|
||||
/// - a real `hival` is truncated toward zero (upstream read it so too);
|
||||
/// - a `hival` past 255 is taken as 255;
|
||||
/// - a lookup table shorter than m × (hival + 1) bytes keeps the entries it holds in full,
|
||||
/// and an index past them is drawn black, after conversion, whatever the base space (zero
|
||||
/// bytes would be white in DeviceCMYK, Separation and DeviceN, and blue in Lab).
|
||||
///
|
||||
/// Any of these sets `recovered`, which the drawing paths report. A `hival` below zero (once
|
||||
/// truncated), or not a number, has no reading: the space cannot be read, as upstream, and
|
||||
/// `has_unusable_hival` lets the image path report it.
|
||||
///
|
||||
/// A lookup that is missing, or neither a string nor a stream that decodes, is no table at
|
||||
/// all. Upstream could not read such a space either. With `allow_tableless` it is built,
|
||||
/// marked `tableless`, so that the image path can skip the image with a warning and the
|
||||
/// colour operators can fall back as upstream; without it, it is `None` as upstream.
|
||||
fn new(array: &Array<'_>, cache: &Cache, depth: u32, allow_tableless: bool) -> Option<Self> {
|
||||
let mut iter = array.flex_iter();
|
||||
// Skip name
|
||||
let _ = iter.next::<Name<'_>>()?;
|
||||
let base_color_space = ColorSpace::within(iter.next::<Object<'_>>()?, cache, depth + 1)?;
|
||||
let hival = iter.next::<u32>()?.min(u8::MAX as u32) as u8;
|
||||
let (hival, hival_recovered) = indexed_hival(iter.next::<object::Number>()?)?;
|
||||
|
||||
let values = {
|
||||
// PdfCraft patch (71): read once, as whichever it is. A failed read as a stream leaves
|
||||
// a direct string in place but uses up a reference, so a table in an indirect string
|
||||
// was lost, and the space with it.
|
||||
let data = match iter.next::<Object<'_>>()? {
|
||||
Object::Stream(s) => s.decoded().ok()?,
|
||||
Object::String(s) => Cow::Owned(s.to_vec()),
|
||||
_ => return None,
|
||||
};
|
||||
// At most 255 components (a `u8`), and at most 256 entries.
|
||||
let num_components = usize::from(base_color_space.num_components());
|
||||
let entries = usize::from(hival) + 1;
|
||||
|
||||
let num_components = base_color_space.num_components();
|
||||
|
||||
let mut byte_iter = data.iter().copied();
|
||||
|
||||
let mut vals = vec![];
|
||||
for _ in 0..=hival {
|
||||
let mut temp = vec![];
|
||||
|
||||
for _ in 0..num_components {
|
||||
temp.push(byte_iter.next()? as f32 / 255.0);
|
||||
}
|
||||
|
||||
vals.push(temp);
|
||||
}
|
||||
|
||||
vals
|
||||
};
|
||||
// PdfCraft patch (80): read once and then by type, so a string lookup given by an
|
||||
// indirect reference is found (a failed stream read had already consumed the
|
||||
// reference).
|
||||
let data = iter
|
||||
.next::<Object<'_>>()
|
||||
.and_then(|o| indexed_lookup(o, cache));
|
||||
let tableless = data.is_none();
|
||||
if tableless && !allow_tableless {
|
||||
return None;
|
||||
}
|
||||
let data: &[u8] = data.as_deref().unwrap_or_default();
|
||||
let present = data
|
||||
.len()
|
||||
.checked_div(num_components)
|
||||
.unwrap_or(0)
|
||||
.min(entries);
|
||||
let mut bytes = data.iter().copied();
|
||||
let values: Vec<Vec<f32>> = (0..entries)
|
||||
.map(|entry| {
|
||||
(0..num_components)
|
||||
.map(|_| {
|
||||
if entry < present {
|
||||
f32::from(bytes.next().unwrap_or(0)) / 255.0
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.collect();
|
||||
|
||||
Some(Self {
|
||||
values,
|
||||
hival,
|
||||
base: Box::new(base_color_space),
|
||||
present,
|
||||
recovered: hival_recovered || present < entries,
|
||||
tableless,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): an Indexed space's `hival` (ISO 32000-2 §8.6.6.3) as drawn, and whether
|
||||
/// it had to be recovered: a real is truncated toward zero and a value past 255 is taken as 255.
|
||||
/// `None` for a value below zero once truncated, or one that is not finite.
|
||||
fn indexed_hival(number: object::Number) -> Option<(u8, bool)> {
|
||||
let value = number.as_f64();
|
||||
let whole = value.trunc();
|
||||
// NaN fails this test too.
|
||||
if !(whole >= 0.0 && whole.is_finite()) {
|
||||
return None;
|
||||
}
|
||||
let clamped = whole.min(f64::from(u8::MAX));
|
||||
// `clamped` is a whole number in 0..=255, so the cast is exact.
|
||||
Some((clamped as u8, clamped != value))
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): whether `object` is an `/Indexed` colour space array whose `hival` has no
|
||||
/// reading (below zero, or not a number), which `Indexed::new` cannot recover. Reads the array's
|
||||
/// first and third entries only; the lookup table is not touched.
|
||||
pub(crate) fn has_unusable_hival(object: &Object<'_>) -> bool {
|
||||
let Object::Array(array) = object else {
|
||||
return false;
|
||||
};
|
||||
let mut iter = array.flex_iter();
|
||||
if !iter
|
||||
.next::<Name<'_>>()
|
||||
.is_some_and(|family| matches!(family.deref(), INDEXED | I))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let _base = iter.next::<Object<'_>>();
|
||||
iter.next::<object::Number>()
|
||||
.and_then(indexed_hival)
|
||||
.is_none()
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): an Indexed space's lookup table, a byte string or a stream (ISO 32000-2
|
||||
/// §8.6.6.3), with a stream's filters applied. `None` for any other object or a stream that
|
||||
/// cannot be decoded. A stream that decodes to nothing although it holds data counts as one that
|
||||
/// cannot be decoded: the Flate decoder recovers what it can from a broken stream, and here
|
||||
/// recovered nothing. Each call is counted on `cache` (`Cache::indexed_lookup_reads`).
|
||||
fn indexed_lookup<'a>(lookup: Object<'a>, cache: &Cache) -> Option<Cow<'a, [u8]>> {
|
||||
cache.count_indexed_lookup_read();
|
||||
match lookup {
|
||||
Object::Stream(s) => s
|
||||
.decoded()
|
||||
.ok()
|
||||
.filter(|d| !d.is_empty() || s.raw_data().is_empty()),
|
||||
Object::String(s) => Some(Cow::Owned(s.to_vec())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
impl ToRgb for Indexed {
|
||||
fn convert_f32(&self, input: &[f32], output: &mut [u8], _: bool) -> Option<()> {
|
||||
let mut indexed = vec![0.0; input.len() * self.base.num_components() as usize];
|
||||
@@ -1065,7 +1182,20 @@ impl ToRgb for Indexed {
|
||||
output.copy_from_slice(&self.values[idx]);
|
||||
}
|
||||
|
||||
self.base.convert_f32(&indexed, output, true)
|
||||
self.base.convert_f32(&indexed, output, true)?;
|
||||
|
||||
// PdfCraft patch (80): an index past the entries the table holds is drawn black, in
|
||||
// whatever space the base is (see `Indexed::new`).
|
||||
if self.present <= usize::from(self.hival) {
|
||||
for (input, rgb) in input.iter().copied().zip(output.chunks_exact_mut(3)) {
|
||||
let idx = (input.clamp(0.0, self.hival as f32) + 0.5) as usize;
|
||||
if idx >= self.present {
|
||||
rgb.fill(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+13
-1
@@ -220,6 +220,13 @@ impl<'a> InterpreterCache<'a> {
|
||||
pub fn icc_profile_reads(&self) -> usize {
|
||||
self.object_cache.icc_profile_reads()
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): how many `/Indexed` lookup tables were read through this cache, for
|
||||
/// diagnostics and tests. A colour space named by a resource is built, and its table read,
|
||||
/// once however many images or colours use it.
|
||||
pub fn indexed_lookup_reads(&self) -> usize {
|
||||
self.object_cache.indexed_lookup_reads()
|
||||
}
|
||||
}
|
||||
|
||||
/// A per-page interpretation context that borrows shared data from an [`InterpreterCache`].
|
||||
@@ -565,6 +572,8 @@ impl<'a> Context<'a> {
|
||||
self.get_mut().ctm *= transform;
|
||||
}
|
||||
|
||||
/// PdfCraft patch (80): an `/Indexed` resource with no lookup table is built, marked
|
||||
/// tableless, for the image and colour operators to handle (see `Indexed::new`).
|
||||
pub(crate) fn get_color_space(
|
||||
&mut self,
|
||||
resources: &Resources<'_>,
|
||||
@@ -574,7 +583,10 @@ impl<'a> Context<'a> {
|
||||
self.interpreter_cache
|
||||
.object_cache
|
||||
.get_or_insert_with(cs_object.cache_key(), || {
|
||||
ColorSpace::new(cs_object.clone(), &self.interpreter_cache.object_cache)
|
||||
ColorSpace::new_allowing_tableless(
|
||||
cs_object.clone(),
|
||||
&self.interpreter_cache.object_cache,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
+39
@@ -166,6 +166,11 @@ pub enum InterpreterWarning {
|
||||
/// read, or a Separation or DeviceN tint transform that cannot be evaluated) and was painted
|
||||
/// in a fallback colour. Reported at most once per content stream.
|
||||
ColorFallback,
|
||||
/// PdfCraft patch (80): an image's `/Indexed` colour space is malformed (ISO 32000-2
|
||||
/// §8.6.6.3). The image was drawn recovered (indices past a short lookup table in black, a
|
||||
/// `hival` past 255 taken as 255, a real one truncated), or, with a `hival` below zero or not a
|
||||
/// number, in DeviceGray; with no lookup table at all it was not drawn.
|
||||
MalformedIndexedImage,
|
||||
/// PdfCraft patch (90): a Type 3 font without `/Widths` (or `/FirstChar`/`/LastChar`),
|
||||
/// which ISO 32000-2 Table 110 requires, was selected; its glyphs advance by the widths
|
||||
/// their glyph procedures set with `d0`/`d1`. Reported each time such a font is selected.
|
||||
@@ -695,11 +700,19 @@ fn interpret_window<'a>(
|
||||
// PdfCraft patch (38): see `named_color_space`.
|
||||
// PdfCraft patch (55): a space that cannot be read is drawn in DeviceGray, as
|
||||
// before, and the fallback is reported.
|
||||
// PdfCraft patch (80): an Indexed space with no lookup table counts as one that
|
||||
// cannot be read, as upstream.
|
||||
let cs = named_color_space(c.0, resources, &defaults, context)
|
||||
.filter(|cs| !cs.is_tableless_indexed())
|
||||
.unwrap_or_else(|| {
|
||||
crate::color::note_color_fallback();
|
||||
ColorSpace::device_gray()
|
||||
});
|
||||
// PdfCraft patch (80): so is an Indexed space drawn recovered (indices past a
|
||||
// short table drawn black, a `hival` clamped or truncated; see `Indexed::new`).
|
||||
if cs.is_recovered_indexed() {
|
||||
crate::color::note_color_fallback();
|
||||
}
|
||||
|
||||
if !cs.is_pattern() {
|
||||
context.get_mut().graphics_state.stroke_pattern = None;
|
||||
@@ -711,11 +724,19 @@ fn interpret_window<'a>(
|
||||
// PdfCraft patch (38): see `named_color_space`.
|
||||
// PdfCraft patch (55): a space that cannot be read is drawn in DeviceGray, as
|
||||
// before, and the fallback is reported.
|
||||
// PdfCraft patch (80): an Indexed space with no lookup table counts as one that
|
||||
// cannot be read, as upstream.
|
||||
let cs = named_color_space(c.0, resources, &defaults, context)
|
||||
.filter(|cs| !cs.is_tableless_indexed())
|
||||
.unwrap_or_else(|| {
|
||||
crate::color::note_color_fallback();
|
||||
ColorSpace::device_gray()
|
||||
});
|
||||
// PdfCraft patch (80): so is an Indexed space drawn recovered (indices past a
|
||||
// short table drawn black, a `hival` clamped or truncated; see `Indexed::new`).
|
||||
if cs.is_recovered_indexed() {
|
||||
crate::color::note_color_fallback();
|
||||
}
|
||||
|
||||
if !cs.is_pattern() {
|
||||
context.get_mut().graphics_state.non_stroke_pattern = None;
|
||||
@@ -971,6 +992,24 @@ fn interpret_window<'a>(
|
||||
let warning_sink = context.settings.warning_sink.clone();
|
||||
let transfer_function = context.get().graphics_state.transfer_function.clone();
|
||||
let cache = context.interpreter_cache.object_cache.clone();
|
||||
// PdfCraft patch (80): an inline image naming a resource colour space that is an
|
||||
// Indexed space whose `hival` has no reading is reported, as `ImageXObject::new`
|
||||
// reports one given in place; the image falls back as upstream. Only the array's
|
||||
// name and `hival` are read here, never its lookup table: a recovered space is
|
||||
// reported by `ImageXObject::new` from the space it builds through the resource
|
||||
// cache. A device space name (or its inline abbreviation) never refers to a
|
||||
// resource (ISO 32000-2 §8.6.8), and `ImageXObject::new` takes it first, so a
|
||||
// resource of that name is not consulted.
|
||||
let inline_dict = i.0.dict();
|
||||
if inline_dict
|
||||
.get::<hayro_syntax::object::Name<'_>>(hayro_syntax::object::dict::keys::CS)
|
||||
.or_else(|| inline_dict.get::<hayro_syntax::object::Name<'_>>(hayro_syntax::object::dict::keys::COLORSPACE))
|
||||
.filter(|name| ColorSpace::new_from_name(name).is_none())
|
||||
.and_then(|name| resources.get_color_space(&name))
|
||||
.is_some_and(|cs| crate::color::has_unusable_hival(&cs))
|
||||
{
|
||||
warning_sink(InterpreterWarning::MalformedIndexedImage);
|
||||
}
|
||||
// PdfCraft patch: inline images are not cached (see `DecodedImageKey`).
|
||||
// PdfCraft patch (38): an inline image in a device space, named directly or by a
|
||||
// resource, draws in its default.
|
||||
|
||||
+29
-1
@@ -526,6 +526,7 @@ impl<'a> ImageXObject<'a> {
|
||||
is_mask |= is_stencil_mask;
|
||||
|
||||
let mut default_space = None;
|
||||
let mut malformed_indexed = false;
|
||||
let image_cs = if is_mask {
|
||||
// Masks are always single-channel.
|
||||
Some(ColorSpace::device_gray())
|
||||
@@ -543,9 +544,14 @@ impl<'a> ImageXObject<'a> {
|
||||
default_space = Some(key);
|
||||
Some(space)
|
||||
} else {
|
||||
// PdfCraft patch (80): an Indexed space given in place whose `hival` has no
|
||||
// reading cannot be built and falls back below, as upstream; it is reported.
|
||||
malformed_indexed = cs_obj
|
||||
.as_ref()
|
||||
.is_some_and(crate::color::has_unusable_hival);
|
||||
cs_obj
|
||||
.clone()
|
||||
.and_then(|c| ColorSpace::new(c, cache))
|
||||
.and_then(|c| ColorSpace::new_allowing_tableless(c, cache))
|
||||
// Inline images can also refer to color spaces by name.
|
||||
.or_else(|| {
|
||||
cs_obj
|
||||
@@ -554,6 +560,24 @@ impl<'a> ImageXObject<'a> {
|
||||
})
|
||||
}
|
||||
};
|
||||
// PdfCraft patch (80): an Indexed space that ISO 32000-2 §8.6.6.3 rules out (a short
|
||||
// lookup table, a `hival` past 255 or with a fraction) is drawn recovered (see
|
||||
// `Indexed::new`), and reported. The check asks the space that was built, so it reads
|
||||
// no lookup table of its own (an inline image naming a resource builds it once, through
|
||||
// the resource cache).
|
||||
malformed_indexed |= image_cs
|
||||
.as_ref()
|
||||
.is_some_and(ColorSpace::is_recovered_indexed);
|
||||
// PdfCraft patch (80): an Indexed space with no lookup table at all (missing, or not a
|
||||
// string or a stream that decodes) leaves nothing to draw: the image is skipped, and
|
||||
// reported. Upstream drew it in DeviceGray.
|
||||
if image_cs
|
||||
.as_ref()
|
||||
.is_some_and(ColorSpace::is_tableless_indexed)
|
||||
{
|
||||
warning_sink(InterpreterWarning::MalformedIndexedImage);
|
||||
return None;
|
||||
}
|
||||
|
||||
let interpolate = dict
|
||||
.get::<bool>(I)
|
||||
@@ -567,6 +591,10 @@ impl<'a> ImageXObject<'a> {
|
||||
return None;
|
||||
}
|
||||
|
||||
if malformed_indexed {
|
||||
warning_sink(InterpreterWarning::MalformedIndexedImage);
|
||||
}
|
||||
|
||||
Some(Self {
|
||||
width,
|
||||
cache: cache.clone(),
|
||||
|
||||
Reference in New Issue
Block a user