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:
bflatastic
2026-11-09 18:17:39 +07:00
14 changed files with 845 additions and 37 deletions
+6
View File
@@ -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(),
+1
View File
@@ -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]
+10 -1
View File
@@ -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,
};
+4
View File
@@ -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");
}
+458
View File
@@ -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]);
}
+1
View File
@@ -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;
+1 -1
View File
File diff suppressed because one or more lines are too long
+21 -3
View File
@@ -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)
+160 -30
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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(),