mirror of
https://github.com/storytold/pdfcraft.git
synced 2026-11-18 00:26:04 +00:00
M11: 6.2.10 reads blend modes only from graphics states, wants a device-independent /CS and a profiled intent, rereads shallower
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Pq7HyDBXygTf7jcqdsjcfn
This commit is contained in:
1 parent
0b2c452bb1
commit
52131ba093
3 files changed
+232
-130
No files matched your search
+23
-13
@@ -117,7 +117,7 @@ pub const WORDINGS: &[&str] = &[
|
||||
// The document as a whole.
|
||||
"The document is encrypted",
|
||||
"Device colour is used, but there is no PDF/A output intent",
|
||||
"Page {} has transparency but no blending colour space or PDF/A output intent",
|
||||
"Page {} has transparency but no device-independent blending colour space or PDF/A output intent",
|
||||
"A graphics state uses the blend mode {}, which ISO 32000-1 doesn't define",
|
||||
"DeviceCMYK is used: it needs a CMYK output intent (not added automatically)",
|
||||
"DeviceCMYK is used, but the PDF/A output intent isn't a CMYK profile",
|
||||
@@ -213,6 +213,19 @@ fn dict_of(o: &Object) -> Option<&Dict> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether the document has a PDF/A output intent whose `/DestOutputProfile` is a stream: one with
|
||||
/// a null or missing profile describes no colour, so it doesn't stand in for a blending colour
|
||||
/// space (6.2.10).
|
||||
fn pdfa_intent_has_profile(doc: &Document) -> bool {
|
||||
let cat = catalog(doc);
|
||||
let list = cat.get(b"OutputIntents").map(|o| doc.resolve(o)).and_then(|o| o.as_array().cloned()).unwrap_or_default();
|
||||
list.iter().any(|oi| {
|
||||
let oi = doc.resolve(oi);
|
||||
let Some(d) = oi.as_dict() else { return false };
|
||||
d.name(b"S") == Some(b"GTS_PDFA1") && d.get(b"DestOutputProfile").is_some_and(|p| matches!(&*doc.resolve(p), Object::Stream(_)))
|
||||
})
|
||||
}
|
||||
|
||||
fn has_pdfa_intent(doc: &Document) -> bool {
|
||||
pdfa_intent_profile(doc).is_some()
|
||||
}
|
||||
@@ -517,20 +530,17 @@ pub fn verify(doc: &Document, level: Level) -> Vec<Issue> {
|
||||
issue("6.5.2", "Page {} has additional actions", Some((i + 1).to_string()), Some(i), true);
|
||||
}
|
||||
}
|
||||
// 6.2.10: blend modes are those ISO 32000-1 defines.
|
||||
for (_, o) in &objs {
|
||||
for name in transparency::unknown_blend_modes(doc, o) {
|
||||
// 6.2.10: blend modes are those ISO 32000-1 defines, and without a PDF/A output intent (one with
|
||||
// a profile) a page with transparency names a blending colour space.
|
||||
let intent = pdfa_intent_has_profile(doc);
|
||||
for (i, p) in pages.iter().enumerate() {
|
||||
let painting = transparency::page_painting(doc, &p.dict);
|
||||
for name in painting.unknown_blend_modes {
|
||||
issue("6.2.10", "A graphics state uses the blend mode {}, which ISO 32000-1 doesn't define", Some(name), None, false);
|
||||
}
|
||||
}
|
||||
// 6.2.10: without a PDF/A output intent, a page with transparency names its blending colour
|
||||
// space.
|
||||
if !has_pdfa_intent(doc) {
|
||||
for (i, p) in pages.iter().enumerate() {
|
||||
if transparency::page_has_transparency(doc, &p.dict) && !transparency::page_names_blending_space(doc, &p.dict) {
|
||||
let n = Some((i + 1).to_string());
|
||||
issue("6.2.10", "Page {} has transparency but no blending colour space or PDF/A output intent", n, Some(i), false);
|
||||
}
|
||||
if painting.transparency && !intent && !transparency::page_names_blending_space(doc, &p.dict) {
|
||||
let n = Some((i + 1).to_string());
|
||||
issue("6.2.10", "Page {} has transparency but no device-independent blending colour space or PDF/A output intent", n, Some(i), false);
|
||||
}
|
||||
}
|
||||
check_objects(doc, level, &objs, &page_of, &mut issue);
|
||||
|
||||
@@ -513,7 +513,7 @@ endstream",
|
||||
}
|
||||
verify(&build(&objs, ""), Level::A2b).into_iter().filter(|i| i.clause == "6.2.10").map(|i| i.message).collect()
|
||||
};
|
||||
let said = ["Page 1 has transparency but no blending colour space or PDF/A output intent"];
|
||||
let said = ["Page 1 has transparency but no device-independent blending colour space or PDF/A output intent"];
|
||||
let form = |dict: &str| format!("<< /Type /XObject /Subtype /Form /BBox [0 0 10 10] {dict} /Length 0 >>\nstream\n\nendstream");
|
||||
let gs = |entries: &str| format!("/ExtGState << /G << {entries} >> >>");
|
||||
for (what, resources, extra) in [
|
||||
@@ -552,7 +552,11 @@ endstream",
|
||||
let extra: Vec<&str> = extra.iter().map(String::as_str).collect();
|
||||
assert_eq!(blending(false, "", &resources, &extra), said, "{what}");
|
||||
// A page group with a blending colour space, or a PDF/A output intent, satisfies the rule.
|
||||
assert!(blending(false, "/Group << /S /Transparency /CS /DeviceRGB >>", &resources, &extra).is_empty(), "{what}: page /CS");
|
||||
assert!(
|
||||
blending(false, "/Group << /S /Transparency /CS [/CalRGB << /WhitePoint [0.9505 1 1.089] >>] >>", &resources, &extra).is_empty(),
|
||||
"{what}: page /CS"
|
||||
);
|
||||
assert_eq!(blending(false, "/Group << /S /Transparency >>", &resources, &extra), said, "{what}: page group without /CS");
|
||||
assert!(blending(true, "", &resources, &extra).is_empty(), "{what}: output intent");
|
||||
}
|
||||
// Annotation appearances, as one stream or a dictionary of streams by state.
|
||||
@@ -595,7 +599,9 @@ endstream",
|
||||
#[test]
|
||||
fn blend_modes_are_the_ones_iso_32000_1_defines() {
|
||||
let modes = |resources: &str, extra: &[&str]| -> Vec<String> {
|
||||
let page = format!("<< /Type /Page /Parent 2 0 R /Group << /S /Transparency /CS /DeviceRGB >> /Resources << {resources} >> >>");
|
||||
let page = format!(
|
||||
"<< /Type /Page /Parent 2 0 R /Group << /S /Transparency /CS [/CalRGB << /WhitePoint [0.9505 1 1.089] >>] >> /Resources << {resources} >> >>"
|
||||
);
|
||||
let mut objs: Vec<&str> =
|
||||
vec!["<< /Type /Catalog /Pages 2 0 R >>", "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 200 200] >>", &page];
|
||||
objs.extend_from_slice(extra);
|
||||
@@ -608,3 +614,55 @@ fn blend_modes_are_the_ones_iso_32000_1_defines() {
|
||||
let all = "/Normal /Compatible /Multiply /Screen /Overlay /Darken /Lighten /ColorDodge /ColorBurn /HardLight /SoftLight /Difference /Exclusion /Hue /Saturation /Color /Luminosity";
|
||||
assert!(modes(&format!("/ExtGState << /G << /BM [{all}] >> >>"), &[]).is_empty());
|
||||
}
|
||||
|
||||
/// 6.2.10's blending colour space is one PDF/A accepts without an output intent: not null, and
|
||||
/// not a device space unless the page gives it a default (6.2.4.3). An output intent stands in
|
||||
/// for it only with a profile.
|
||||
#[test]
|
||||
fn a_blending_space_is_device_independent_and_an_intent_has_a_profile() {
|
||||
let page_said = ["Page 1 has transparency but no device-independent blending colour space or PDF/A output intent"];
|
||||
let check = |catalog_extra: &str, page_extra: &str, extra: &[&str]| -> Vec<String> {
|
||||
let catalog = format!("<< /Type /Catalog /Pages 2 0 R {catalog_extra} >>");
|
||||
let page = format!("<< /Type /Page /Parent 2 0 R {page_extra} >>");
|
||||
let mut objs: Vec<&str> = vec![&catalog, "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 200 200] >>", &page];
|
||||
objs.extend_from_slice(extra);
|
||||
verify(&build(&objs, ""), Level::A2b).into_iter().filter(|i| i.clause == "6.2.10").map(|i| i.message).collect()
|
||||
};
|
||||
let alpha = "/ExtGState << /G << /ca 0.5 >> >>";
|
||||
let page = |group: &str, colour_spaces: &str| format!("/Group << /S /Transparency {group} >> /Resources << {alpha} {colour_spaces} >>");
|
||||
assert_eq!(check("", &page("/CS null", ""), &[]), page_said, "a null /CS");
|
||||
assert_eq!(check("", &page("/CS 9 0 R", ""), &[]), page_said, "a /CS naming no object");
|
||||
for (device, default) in [("DeviceGray", "DefaultGray"), ("DeviceRGB", "DefaultRGB"), ("DeviceCMYK", "DefaultCMYK")] {
|
||||
assert_eq!(check("", &page(&format!("/CS /{device}"), ""), &[]), page_said, "{device}");
|
||||
let defaults = format!("/ColorSpace << /{default} [/CalRGB << /WhitePoint [0.9505 1 1.089] >>] >>");
|
||||
assert!(check("", &page(&format!("/CS /{device}"), &defaults), &[]).is_empty(), "{device} with {default}");
|
||||
}
|
||||
let intent = |profile: &str| format!("/OutputIntents [<< /Type /OutputIntent /S /GTS_PDFA1 /OutputConditionIdentifier (sRGB) {profile} >>]");
|
||||
let opaque_group = format!("/Resources << {alpha} >>");
|
||||
assert_eq!(check(&intent("/DestOutputProfile null"), &opaque_group, &[]), page_said, "a null profile");
|
||||
assert_eq!(check(&intent(""), &opaque_group, &[]), page_said, "no profile");
|
||||
assert!(check(&intent("/DestOutputProfile 4 0 R"), &opaque_group, &["<< /N 3 /Length 0 >>\nstream\n\nendstream"]).is_empty(), "a profile");
|
||||
// Private data is no graphics state: a /BM there is not a blend mode.
|
||||
assert!(check("/PieceInfo << /App << /Private << /BM /Bookkeeping >> >> >>", "", &[]).is_empty(), "/PieceInfo");
|
||||
}
|
||||
|
||||
/// A form XObject first reached at the depth limit, where its resources go unread, is read again
|
||||
/// when a shallower place names it, so what it holds is not missed.
|
||||
#[test]
|
||||
fn transparency_reached_first_too_deep_is_found_from_a_shallower_place() {
|
||||
let form = |dict: &str| format!("<< /Type /XObject /Subtype /Form /BBox [0 0 10 10] {dict} /Length 0 >>\nstream\n\nendstream");
|
||||
// A chain of 32 forms, objects 4 to 35, the last naming form 36, which holds a translucent
|
||||
// graphics state; the page names the chain first and form 36 after it.
|
||||
let mut objs: Vec<String> = vec![
|
||||
"<< /Type /Catalog /Pages 2 0 R >>".to_owned(),
|
||||
"<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 200 200] >>".to_owned(),
|
||||
"<< /Type /Page /Parent 2 0 R /Resources << /XObject << /A 4 0 R /B 36 0 R >> >> >>".to_owned(),
|
||||
];
|
||||
for n in 4..=35 {
|
||||
objs.push(form(&format!("/Resources << /XObject << /X {} 0 R >> >>", n + 1)));
|
||||
}
|
||||
objs.push(form("/Resources << /ExtGState << /G << /ca 0.5 >> >> >>"));
|
||||
let objs: Vec<&str> = objs.iter().map(String::as_str).collect();
|
||||
let said: Vec<String> = verify(&build(&objs, ""), Level::A2b).into_iter().filter(|i| i.clause == "6.2.10").map(|i| i.message).collect();
|
||||
assert_eq!(said, ["Page 1 has transparency but no device-independent blending colour space or PDF/A output intent"]);
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
//! PDF/A-2 6.2.10: a graphics state's blend mode is one ISO 32000-1 defines, and a page that
|
||||
//! contains transparency, in a file without a PDF/A output intent, names its blending colour
|
||||
//! space: its `/Group` dictionary has a `/CS` entry.
|
||||
//! space: its `/Group` dictionary has a `/CS` entry, which as any colour space in such a file is
|
||||
//! not a device space without a default (6.2.4.3).
|
||||
//!
|
||||
//! A page contains transparency when something its resources reach can paint transparently (ISO
|
||||
//! 32000-1 11.6.4.4 to 11.6.6): a graphics state with a constant alpha (`/CA`, `/ca`) below 1,
|
||||
@@ -8,9 +9,10 @@
|
||||
//! (`/SMask`, or `/SMaskInData` above 0); or a transparency group XObject. The resources looked
|
||||
//! through are the page's own, those of the form XObjects, tiling patterns and Type 3 fonts they
|
||||
//! hold, and those of the appearance streams of the page's annotations. Whether the content uses
|
||||
//! a resource is not asked: a resource a page holds is one it may paint with.
|
||||
//! a resource is not asked: a resource a page holds is one it may paint with. Blend modes are read
|
||||
//! from the same graphics states, so private data (`/PieceInfo`) is never taken for one.
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::collections::HashMap;
|
||||
|
||||
use pdfcraft_cos::{Dict, Document, ObjRef, Object};
|
||||
|
||||
@@ -19,132 +21,197 @@ use pdfcraft_cos::{Dict, Document, ObjRef, Object};
|
||||
const MAX_VISITS: usize = 4096;
|
||||
/// How deep resources nest (a form XObject in a form XObject, ...).
|
||||
const MAX_DEPTH: usize = 32;
|
||||
/// The resource categories that hold what a page paints with, read in this order.
|
||||
const CATEGORIES: [&[u8]; 4] = [b"ExtGState", b"XObject", b"Pattern", b"Font"];
|
||||
|
||||
/// Whether the page `page` contains transparency.
|
||||
pub(crate) fn page_has_transparency(doc: &Document, page: &Dict) -> bool {
|
||||
let mut walk = Walk { doc, seen: HashSet::new(), visits: 0 };
|
||||
if page.get(b"Resources").is_some_and(|r| walk.resources(r, 0)) {
|
||||
return true;
|
||||
}
|
||||
let Some(annots) = page.get(b"Annots").map(|a| doc.resolve(a)) else { return false };
|
||||
let Some(annots) = annots.as_array() else { return false };
|
||||
annots.iter().any(|a| {
|
||||
let a = doc.resolve(a);
|
||||
let Some(ap) = a.as_dict().and_then(|a| a.get(b"AP")).map(|ap| doc.resolve(ap)) else { return false };
|
||||
let Some(ap) = ap.as_dict() else { return false };
|
||||
// Each appearance (normal, rollover, down) is a stream, or a dictionary of streams by state.
|
||||
ap.iter().any(|(_, v)| match &*doc.resolve(v) {
|
||||
Object::Stream(_) => walk.xobject(v, 0),
|
||||
Object::Dict(states) => states.iter().any(|(_, s)| walk.xobject(s, 0)),
|
||||
_ => false,
|
||||
})
|
||||
})
|
||||
/// What the graphics a page's resources reach paint with.
|
||||
#[derive(Debug, Default)]
|
||||
pub(crate) struct Painting {
|
||||
/// Something paints transparently.
|
||||
pub(crate) transparency: bool,
|
||||
/// The blend modes graphics states name that ISO 32000-1 doesn't define.
|
||||
pub(crate) unknown_blend_modes: Vec<String>,
|
||||
}
|
||||
|
||||
/// Whether `page` names its blending colour space: a `/Group` dictionary with a `/CS` entry.
|
||||
/// What the page `page` paints with: its resources, and the appearance streams of its
|
||||
/// annotations.
|
||||
pub(crate) fn page_painting(doc: &Document, page: &Dict) -> Painting {
|
||||
let mut walk = Walk { doc, seen: HashMap::new(), visits: 0, found: Painting::default() };
|
||||
if let Some(r) = page.get(b"Resources") {
|
||||
walk.resources(r, 0);
|
||||
}
|
||||
let annots = page.get(b"Annots").map(|a| doc.resolve(a));
|
||||
for a in annots.as_deref().and_then(Object::as_array).into_iter().flatten() {
|
||||
let a = doc.resolve(a);
|
||||
let Some(ap) = a.as_dict().and_then(|a| a.get(b"AP")).map(|ap| doc.resolve(ap)) else { continue };
|
||||
let Some(ap) = ap.as_dict() else { continue };
|
||||
// Each appearance (normal, rollover, down) is a stream, or a dictionary of streams by state.
|
||||
for (_, v) in ap.iter() {
|
||||
match &*doc.resolve(v) {
|
||||
Object::Stream(_) => walk.xobject(v, 0),
|
||||
Object::Dict(states) => {
|
||||
for (_, s) in states.iter() {
|
||||
walk.xobject(s, 0);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
walk.found
|
||||
}
|
||||
|
||||
/// Whether `page` names a blending colour space PDF/A accepts without an output intent: its
|
||||
/// `/Group` has a `/CS` that is not null and not a device colour space, unless the page's
|
||||
/// resources give that device space a default (`DefaultGray`, `DefaultRGB`, `DefaultCMYK`), as
|
||||
/// PDF/A-2 6.2.4.3 asks of any device colour.
|
||||
pub(crate) fn page_names_blending_space(doc: &Document, page: &Dict) -> bool {
|
||||
page.get(b"Group").map(|g| doc.resolve(g)).is_some_and(|g| g.as_dict().is_some_and(|g| g.get(b"CS").is_some()))
|
||||
let group = page.get(b"Group").map(|g| doc.resolve(g));
|
||||
let Some(cs) = group.as_deref().and_then(Object::as_dict).and_then(|g| g.get(b"CS")).map(|c| doc.resolve(c)) else { return false };
|
||||
let default: &[u8] = match &*cs {
|
||||
Object::Null => return false,
|
||||
Object::Name(n) if n == b"DeviceGray" => b"DefaultGray",
|
||||
Object::Name(n) if n == b"DeviceRGB" => b"DefaultRGB",
|
||||
Object::Name(n) if n == b"DeviceCMYK" => b"DefaultCMYK",
|
||||
_ => return true,
|
||||
};
|
||||
let resources = page.get(b"Resources").map(|r| doc.resolve(r));
|
||||
let spaces = resources.as_deref().and_then(Object::as_dict).and_then(|r| r.get(b"ColorSpace")).map(|c| doc.resolve(c));
|
||||
spaces.as_deref().and_then(Object::as_dict).is_some_and(|s| s.get(default).is_some())
|
||||
}
|
||||
|
||||
struct Walk<'a> {
|
||||
doc: &'a Document,
|
||||
/// The indirect objects already read: each is looked at once, and a cycle ends there.
|
||||
seen: HashSet<ObjRef>,
|
||||
/// The indirect objects already read, each with the shallowest depth it was read at: an
|
||||
/// object is read again only from a shallower place, so a cycle ends and a deep first visit
|
||||
/// doesn't hide what a shallower one would read.
|
||||
seen: HashMap<ObjRef, usize>,
|
||||
visits: usize,
|
||||
found: Painting,
|
||||
}
|
||||
|
||||
impl Walk<'_> {
|
||||
/// Whether `o` may be read: within the budget, and an indirect object not read before.
|
||||
fn enter(&mut self, o: &Object) -> bool {
|
||||
if self.visits >= MAX_VISITS {
|
||||
/// Whether `o`, reached `depth` levels down, may be read: within the budget and the depth, and
|
||||
/// an indirect object not read before from as shallow a place.
|
||||
fn enter(&mut self, o: &Object, depth: usize) -> bool {
|
||||
if self.visits >= MAX_VISITS || depth > MAX_DEPTH {
|
||||
return false;
|
||||
}
|
||||
if let Object::Ref(r) = o {
|
||||
if self.seen.get(r).is_some_and(|&d| d <= depth) {
|
||||
return false;
|
||||
}
|
||||
self.seen.insert(*r, depth);
|
||||
}
|
||||
self.visits += 1;
|
||||
match o {
|
||||
Object::Ref(r) => self.seen.insert(*r),
|
||||
_ => true,
|
||||
true
|
||||
}
|
||||
|
||||
fn resources(&mut self, r: &Object, depth: usize) {
|
||||
if !self.enter(r, depth) {
|
||||
return;
|
||||
}
|
||||
let doc = self.doc;
|
||||
let Some(res) = doc.resolve(r).as_dict().cloned() else { return };
|
||||
for category in CATEGORIES {
|
||||
// Once the budget is spent nothing more is read, so nothing more is gathered either.
|
||||
if self.visits >= MAX_VISITS {
|
||||
return;
|
||||
}
|
||||
let entries: Vec<Object> = res
|
||||
.get(category)
|
||||
.map(|d| doc.resolve(d))
|
||||
.and_then(|d| d.as_dict().map(|d| d.iter().map(|(_, v)| v.clone()).collect()))
|
||||
.unwrap_or_default();
|
||||
for v in &entries {
|
||||
match category {
|
||||
b"ExtGState" => self.ext_gstate(v, depth),
|
||||
b"XObject" => self.xobject(v, depth),
|
||||
b"Pattern" => self.pattern(v, depth),
|
||||
_ => self.type3(v, depth),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn resources(&mut self, r: &Object, depth: usize) -> bool {
|
||||
if depth > MAX_DEPTH || !self.enter(r) {
|
||||
return false;
|
||||
/// A graphics state (ISO 32000-1 Table 58): whether it paints transparently, and the blend
|
||||
/// modes it names that ISO 32000-1 doesn't define.
|
||||
fn ext_gstate(&mut self, g: &Object, depth: usize) {
|
||||
if !self.enter(g, depth) {
|
||||
return;
|
||||
}
|
||||
let doc = self.doc;
|
||||
let Some(res) = doc.resolve(r).as_dict().cloned() else { return false };
|
||||
let entries = |key: &[u8]| -> Vec<Object> {
|
||||
res.get(key).map(|d| doc.resolve(d)).and_then(|d| d.as_dict().map(|d| d.iter().map(|(_, v)| v.clone()).collect())).unwrap_or_default()
|
||||
};
|
||||
entries(b"ExtGState").iter().any(|g| self.ext_gstate(g))
|
||||
|| entries(b"XObject").iter().any(|x| self.xobject(x, depth))
|
||||
|| entries(b"Pattern").iter().any(|p| self.pattern(p, depth))
|
||||
|| entries(b"Font").iter().any(|f| self.type3(f, depth))
|
||||
}
|
||||
|
||||
/// A graphics state that paints transparently (ISO 32000-1 Table 58).
|
||||
fn ext_gstate(&mut self, g: &Object) -> bool {
|
||||
if !self.enter(g) {
|
||||
return false;
|
||||
}
|
||||
let g = self.doc.resolve(g);
|
||||
let Some(g) = g.as_dict() else { return false };
|
||||
let doc = self.doc;
|
||||
let g = doc.resolve(g);
|
||||
let Some(g) = g.as_dict() else { return };
|
||||
let below_one = |key: &[u8]| g.get(key).and_then(|v| doc.resolve(v).as_f64()).is_some_and(|a| a < 1.0);
|
||||
let blend = g.get(b"BM").map(|b| doc.resolve(b)).is_some_and(|b| blends(doc, &b));
|
||||
let bm = g.get(b"BM").map(|b| doc.resolve(b));
|
||||
let blend = bm.as_deref().is_some_and(|b| blends(doc, b));
|
||||
let mask = g.get(b"SMask").map(|m| doc.resolve(m)).is_some_and(|m| !matches!(&*m, Object::Name(n) if n == b"None"));
|
||||
below_one(b"CA") || below_one(b"ca") || blend || mask
|
||||
self.found.transparency |= below_one(b"CA") || below_one(b"ca") || blend || mask;
|
||||
for name in bm.as_deref().map(|b| unknown_blend_modes(doc, b)).unwrap_or_default() {
|
||||
if !self.found.unknown_blend_modes.contains(&name) {
|
||||
self.found.unknown_blend_modes.push(name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An image with a soft mask, or a form XObject that is a transparency group or holds
|
||||
/// transparency in its resources.
|
||||
fn xobject(&mut self, x: &Object, depth: usize) -> bool {
|
||||
if !self.enter(x) {
|
||||
return false;
|
||||
fn xobject(&mut self, x: &Object, depth: usize) {
|
||||
if !self.enter(x, depth) {
|
||||
return;
|
||||
}
|
||||
let doc = self.doc;
|
||||
let x = doc.resolve(x);
|
||||
let Object::Stream(s) = &*x else { return false };
|
||||
let Object::Stream(s) = &*x else { return };
|
||||
let d = &s.dict;
|
||||
if d.name(b"Subtype") == Some(b"Image") {
|
||||
let soft_mask = d.get(b"SMask").is_some_and(|m| matches!(&*doc.resolve(m), Object::Stream(_)));
|
||||
let in_data = d.get(b"SMaskInData").and_then(|v| doc.resolve(v).as_int()).is_some_and(|v| v > 0);
|
||||
return soft_mask || in_data;
|
||||
self.found.transparency |= soft_mask || in_data;
|
||||
return;
|
||||
}
|
||||
let group = d.get(b"Group").map(|g| doc.resolve(g)).is_some_and(|g| g.as_dict().is_some_and(|g| g.name(b"S") == Some(b"Transparency")));
|
||||
group || d.get(b"Resources").is_some_and(|r| self.resources(r, depth + 1))
|
||||
self.found.transparency |= group;
|
||||
if let Some(r) = d.get(b"Resources") {
|
||||
self.resources(r, depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
/// A tiling pattern's resources, or a shading pattern's graphics state.
|
||||
fn pattern(&mut self, p: &Object, depth: usize) -> bool {
|
||||
if !self.enter(p) {
|
||||
return false;
|
||||
fn pattern(&mut self, p: &Object, depth: usize) {
|
||||
if !self.enter(p, depth) {
|
||||
return;
|
||||
}
|
||||
let doc = self.doc;
|
||||
let p = doc.resolve(p);
|
||||
let p = self.doc.resolve(p);
|
||||
let Some(d) = (match &*p {
|
||||
Object::Stream(s) => Some(&s.dict),
|
||||
Object::Dict(d) => Some(d),
|
||||
_ => None,
|
||||
}) else {
|
||||
return false;
|
||||
return;
|
||||
};
|
||||
let state = d.get(b"ExtGState").cloned();
|
||||
let resources = d.get(b"Resources").cloned();
|
||||
state.is_some_and(|g| self.ext_gstate(&g)) || resources.is_some_and(|r| self.resources(&r, depth + 1))
|
||||
if let Some(g) = d.get(b"ExtGState") {
|
||||
self.ext_gstate(g, depth + 1);
|
||||
}
|
||||
if let Some(r) = d.get(b"Resources") {
|
||||
self.resources(r, depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
/// A Type 3 font's resources, which its glyph procedures paint with.
|
||||
fn type3(&mut self, f: &Object, depth: usize) -> bool {
|
||||
if !self.enter(f) {
|
||||
return false;
|
||||
fn type3(&mut self, f: &Object, depth: usize) {
|
||||
if !self.enter(f, depth) {
|
||||
return;
|
||||
}
|
||||
let f = self.doc.resolve(f);
|
||||
let Some(d) = f.as_dict() else { return false };
|
||||
let Some(d) = f.as_dict() else { return };
|
||||
if d.name(b"Subtype") != Some(b"Type3") {
|
||||
return false;
|
||||
return;
|
||||
}
|
||||
if let Some(r) = d.get(b"Resources") {
|
||||
self.resources(r, depth + 1);
|
||||
}
|
||||
let resources = d.get(b"Resources").cloned();
|
||||
resources.is_some_and(|r| self.resources(&r, depth + 1))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -169,43 +236,10 @@ const BLEND_MODES: &[&[u8]] = &[
|
||||
b"Luminosity",
|
||||
];
|
||||
|
||||
/// The blend modes ISO 32000-1 doesn't define that the object `o` names in a `/BM` entry: its own,
|
||||
/// or one of a dictionary written inside it (a page's resources hold their graphics states
|
||||
/// directly), within [`MAX_DEPTH`].
|
||||
pub(crate) fn unknown_blend_modes(doc: &Document, o: &Object) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
blend_modes_within(doc, o, 0, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
fn blend_modes_within(doc: &Document, o: &Object, depth: usize, out: &mut Vec<String>) {
|
||||
if depth > MAX_DEPTH {
|
||||
return;
|
||||
}
|
||||
let d = match o {
|
||||
Object::Dict(d) => d,
|
||||
Object::Stream(s) => &s.dict,
|
||||
Object::Array(a) => {
|
||||
for v in a {
|
||||
blend_modes_within(doc, v, depth + 1, out);
|
||||
}
|
||||
return;
|
||||
}
|
||||
_ => return,
|
||||
};
|
||||
out.extend(unknown_in(doc, d));
|
||||
for (k, v) in d.iter() {
|
||||
if k != b"BM" {
|
||||
blend_modes_within(doc, v, depth + 1, out);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The names in a graphics state's `/BM` (a name, or an array of them) that are not blend modes
|
||||
/// ISO 32000-1 defines.
|
||||
fn unknown_in(doc: &Document, gs: &Dict) -> Vec<String> {
|
||||
let Some(bm) = gs.get(b"BM").map(|b| doc.resolve(b)) else { return Vec::new() };
|
||||
let names: Vec<Vec<u8>> = match &*bm {
|
||||
/// The names in a `/BM` value (a name, or an array of them) that are not blend modes ISO 32000-1
|
||||
/// defines.
|
||||
fn unknown_blend_modes(doc: &Document, bm: &Object) -> Vec<String> {
|
||||
let names: Vec<Vec<u8>> = match bm {
|
||||
Object::Name(n) => vec![n.clone()],
|
||||
Object::Array(a) => a.iter().filter_map(|m| doc.resolve(m).as_name().map(<[u8]>::to_vec)).collect(),
|
||||
_ => Vec::new(),
|
||||
|
||||
Reference in new issue
Block a user