DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
PDF: PDF/X-4 flags device RGB under its CMYK output intent
EthanSuquet873d2930178e
diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rsindex a4e60c3c9..d98f7a4c7 100644--- a/crates/pdf/src/export.rs+++ b/crates/pdf/src/export.rs@@ -207,11 +207,9 @@ pub fn export_pdf_with_report(doc: &Document, cache: &Cache, opts: &PdfOptions)// Transparency blends in the document's blend space: CMYK for print (and always in PDF/X).let mut warnings = ex.warnings;if !ex.rgb_only && (doc.settings.blend_space == designcraft_doc::BlendSpace::Cmyk || opts.standard == Standard::PdfX4) {+ // The rewrite matches krilla's exact output; in PDF/X-4, `check_pdfx4` reports any+ // group that got past it, with its page.crate::pdfx::cmyk_group_spaces(&mut bytes);- // The rewrite matches krilla's exact output; say so if a group got past it.- if opts.standard == Standard::PdfX4 && crate::pdfx::has_rgb_groups(&bytes) {- warnings.push("PDF/X-4: some transparency groups still blend in RGB".into());- }}// Form fields (Buttons and Forms) and, for interactive PDF, video and sound; not in PDF/X.let fields = crate::forms::collect(doc, &sheets);diff --git a/crates/pdf/src/pdfx.rs b/crates/pdf/src/pdfx.rsindex df05552a0..ad3a140ce 100644--- a/crates/pdf/src/pdfx.rs+++ b/crates/pdf/src/pdfx.rs@@ -2,6 +2,12 @@//! information and XMP, written as an incremental update of krilla's PDF 1.6 output; and a//! check of the requirements this exporter is responsible for.+use std::collections::HashSet;++use hayro_syntax::content::UntypedIter;+use hayro_syntax::object::{Array, Dict, Name, Object, ObjectIdentifier, Stream};+use hayro_syntax::page::Resources;+use crate::transitions::{find, int_after, object, rfind};/// Escape a PDF literal string.@@ -187,7 +193,8 @@ fn dictionary_ranges(pdf: &[u8]) -> Option<Vec<std::ops::Range<usize>>> {Some(out)}-/// PDF/X-4 checks on an exported file: what's missing (empty = passes these checks).+/// PDF/X-4 checks on an exported file: what's missing or not allowed, device RGB under the CMYK+/// output intent included (empty = passes these checks).pub fn check_pdfx4(pdf: &[u8]) -> Vec<String> {let mut issues = Vec::new();let text = String::from_utf8_lossy(pdf);@@ -217,5 +224,445 @@ pub fn check_pdfx4(pdf: &[u8]) -> Vec<String> {if text.contains("/Subtype/Type3") {issues.push("Type 3 fonts aren't allowed".into());}+ issues.extend(device_rgb(pdf));issues}++/// Device-dependent RGB under a CMYK output intent. PDF/X-4 (ISO 15930-7) lets RGB in only when+/// it is colour-managed: ICCBased RGB, or DeviceRGB remapped by a `DefaultRGB` colour space in the+/// resources. DeviceCMYK and DeviceGray are the output intent's own device values, so they stay.+/// This walks every page's content, the images, forms, patterns, shadings and soft masks it uses,+/// and the transparency groups, and reports each kind of device RGB it finds with the pages it is+/// on. Nothing is reported when the file has no CMYK PDF/X output intent.+fn device_rgb(pdf: &[u8]) -> Vec<String> {+ let Ok(file) = hayro_syntax::Pdf::new(pdf.to_vec()) else {+ return vec!["the file couldn't be read to check its colour spaces".into()];+ };+ if !cmyk_output_intent(&file) {+ return Vec::new();+ }+ let mut found: Vec<(String, Vec<usize>)> = Vec::new();+ for (i, page) in file.pages().iter().enumerate() {+ let mut scan = RgbScan::default();+ let res = page.resources();+ if let Some(group) = page.raw().get::<Dict<'_>>(b"Group") {+ scan.group(&group, res);+ }+ if let Some(content) = page.page_stream() {+ scan.content(content, res, 0);+ }+ for what in scan.found {+ match found.iter_mut().find(|(w, _)| *w == what) {+ Some((_, pages)) => pages.push(i + 1),+ None => found.push((what, vec![i + 1])),+ }+ }+ }+ found+ .into_iter()+ .map(|(what, pages)| {+ let list: Vec<String> = pages.iter().take(10).map(|p| p.to_string()).collect();+ let more = if pages.len() > 10 { ", …" } else { "" };+ let s = if pages.len() == 1 { "" } else { "s" };+ format!("{what} on page{s} {}{more}: under a CMYK output intent RGB needs an ICC profile", list.join(", "))+ })+ .collect()+}++/// Whether the file's PDF/X output intent has a four-channel (CMYK) destination profile.+fn cmyk_output_intent(file: &hayro_syntax::Pdf) -> bool {+ let xref = file.xref();+ let Some(catalog) = xref.get::<Dict<'_>>(xref.root_id()) else { return false };+ let Some(intents) = catalog.get::<Array<'_>>(b"OutputIntents") else { return false };+ intents.iter::<Dict<'_>>().any(|oi| {+ oi.get::<Name<'_>>(b"S").is_some_and(|s| s.as_ref() == b"GTS_PDFX")+ && oi.get::<Stream<'_>>(b"DestOutputProfile").and_then(|p| p.dict().get::<i32>(b"N")) == Some(4)+ })+}++/// Whether a colour space is device RGB: `/DeviceRGB` (`/RGB` in inline images), or an+/// `/Indexed` space over it.+fn is_device_rgb(cs: &Object<'_>) -> bool {+ match cs {+ Object::Name(n) => matches!(n.as_ref(), b"DeviceRGB" | b"RGB"),+ Object::Array(a) => {+ let mut items = a.iter::<Object<'_>>();+ match items.next() {+ Some(Object::Name(n)) if matches!(n.as_ref(), b"Indexed" | b"I") => {+ // The base space is a name or a (non-indexed) array; no deeper nesting.+ matches!(items.next(), Some(Object::Name(b)) if matches!(b.as_ref(), b"DeviceRGB" | b"RGB"))+ }+ _ => false,+ }+ }+ _ => false,+ }+}++/// How deep forms, patterns and soft masks may nest before the walk stops.+const MAX_DEPTH: usize = 16;++/// What one page uses in device RGB, in the order found.+#[derive(Default)]+struct RgbScan {+ found: Vec<String>,+ /// Forms, images and patterns already looked at on this page.+ seen: HashSet<ObjectIdentifier>,+}++impl RgbScan {+ fn add(&mut self, what: String) {+ if !self.found.contains(&what) {+ self.found.push(what);+ }+ }++ /// `DefaultRGB` in scope makes DeviceRGB colour-managed.+ fn managed(res: &Resources<'_>) -> bool {+ res.get_color_space(&Name::new_unescaped(b"DefaultRGB")).is_some()+ }++ /// A content stream (a page's or a form's) with its resources.+ fn content(&mut self, data: &[u8], res: &Resources<'_>, depth: usize) {+ if depth > MAX_DEPTH {+ return;+ }+ let managed = Self::managed(res);+ let mut ops = UntypedIter::new(data);+ while let Some(op) = ops.next() {+ let operator: &[u8] = op.operator;+ let last = op.operands().last().cloned();+ let name = || last.clone().and_then(Object::into_name);+ match operator {+ b"rg" | b"RG" if !managed => self.add("RGB fills or strokes".into()),+ b"cs" | b"CS" if !managed => {+ let rgb = name().is_some_and(|n| n.as_ref() == b"DeviceRGB" || res.get_color_space(&n).is_some_and(|cs| is_device_rgb(&cs)));+ if rgb {+ self.add("RGB fills or strokes".into());+ }+ }+ b"sh" => {+ if let Some(sh) = name().and_then(|n| res.get_shading(&n)) {+ self.shading(sh, managed);+ }+ }+ b"scn" | b"SCN" => {+ if let Some(p) = name().and_then(|n| res.get_pattern(&n)) {+ self.pattern(p, res, managed, depth);+ }+ }+ b"gs" => {+ let mask = name().and_then(|n| res.get_ext_g_state(&n)).and_then(|gs| gs.get::<Dict<'_>>(b"SMask"));+ if let Some(form) = mask.and_then(|m| m.get::<Stream<'_>>(b"G")) {+ self.form(&form, res, depth);+ }+ }+ b"Do" => {+ if let Some(xo) = name().and_then(|n| res.get_x_object(&n)) {+ match xo.dict().get::<Name<'_>>(b"Subtype").as_deref() {+ Some(b"Image") => self.image(&xo, managed),+ Some(b"Form") => self.form(&xo, res, depth),+ _ => {}+ }+ }+ }+ b"BI" | b"EI" if !managed => {+ if let Some(Object::Stream(img)) = last {+ let cs = img.dict().get::<Object<'_>>(b"CS").or_else(|| img.dict().get::<Object<'_>>(b"ColorSpace"));+ let cs = match cs {+ Some(Object::Name(n))+ if !matches!(n.as_ref(), b"DeviceRGB" | b"RGB" | b"G" | b"DeviceGray" | b"CMYK" | b"DeviceCMYK") =>+ {+ res.get_color_space(&n)+ }+ cs => cs,+ };+ if cs.is_some_and(|cs| is_device_rgb(&cs)) {+ self.add("an RGB inline image".into());+ }+ }+ }+ _ => {}+ }+ }+ }++ fn image(&mut self, img: &Stream<'_>, managed: bool) {+ let id = img.obj_id();+ if managed || !self.seen.insert(id) || img.dict().get::<bool>(b"ImageMask") == Some(true) {+ return;+ }+ if img.dict().get::<Object<'_>>(b"ColorSpace").is_some_and(|cs| is_device_rgb(&cs)) {+ let (w, h) = (img.dict().get::<i32>(b"Width").unwrap_or(0), img.dict().get::<i32>(b"Height").unwrap_or(0));+ self.add(format!("an RGB image (object {}, {w} × {h} px)", id.obj_number));+ }+ }++ /// A form XObject (placed PDF page, group, soft mask): its group, then its content.+ fn form(&mut self, form: &Stream<'_>, parent: &Resources<'_>, depth: usize) {+ if depth >= MAX_DEPTH || !self.seen.insert(form.obj_id()) {+ return;+ }+ let res = Resources::from_parent(form.dict().get::<Dict<'_>>(b"Resources").unwrap_or_default(), parent.clone());+ if let Some(group) = form.dict().get::<Dict<'_>>(b"Group") {+ self.group(&group, &res);+ }+ if let Ok(data) = form.decoded() {+ self.content(&data, &res, depth + 1);+ }+ }++ fn group(&mut self, group: &Dict<'_>, res: &Resources<'_>) {+ if !Self::managed(res) && group.get::<Object<'_>>(b"CS").is_some_and(|cs| is_device_rgb(&cs)) {+ self.add("a transparency group blending in RGB".into());+ }+ }++ /// A shading dictionary or stream (gradients).+ fn shading(&mut self, sh: Object<'_>, managed: bool) {+ let dict = match sh {+ Object::Dict(d) => d,+ Object::Stream(s) => s.dict().clone(),+ _ => return,+ };+ if !managed && dict.get::<Object<'_>>(b"ColorSpace").is_some_and(|cs| is_device_rgb(&cs)) {+ self.add("RGB gradients".into());+ }+ }++ /// A shading pattern (its shading) or a tiling pattern (its cell, like a form).+ fn pattern(&mut self, p: Object<'_>, res: &Resources<'_>, managed: bool, depth: usize) {+ match p {+ Object::Dict(d) => {+ if let Some(sh) = d.get::<Object<'_>>(b"Shading") {+ self.shading(sh, managed);+ }+ }+ Object::Stream(s) => self.form(&s, res, depth),+ _ => {}+ }+ }+}++#[cfg(test)]+mod tests {+ use std::sync::Arc;++ use designcraft_color::{Color, Swatch};+ use designcraft_compose::Cache;+ use designcraft_doc::build::NewDocument;+ use designcraft_doc::{Asset, AssetId, Content, Document, Fill, Fitting, Graphic, Item, ItemId, Shape, SpreadRef};+ use designcraft_geom::{Affine, Rect};+ use hayro_syntax::object::{Name, Object};+ use image::{ExtendedColorType, ImageEncoder};++ use crate::{ExportReport, PdfOptions, Standard, check_pdfx4, export_pdf_with_report};++ fn place(d: &mut Document, name: &str, data: Vec<u8>, size: (f64, f64), at: (f64, f64)) {+ let asset = AssetId(d.alloc());+ let mime = designcraft_images::mime(&data).into();+ let pixels = designcraft_images::pixel_size(&data);+ d.assets.insert(asset, Arc::new(Asset { id: asset, name: name.into(), mime, link: None, data: data.into(), pixels, page: 0 }));+ let lid = d.default_layer();+ let id = ItemId(d.alloc());+ let r = Rect::new(at.0, at.1, at.0 + 100.0, at.1 + 50.0);+ let mut it = Item::new(id, lid, Shape::Rectangle, designcraft_geom::shapes::rectangle(r));+ it.content = Content::Graphic(Graphic {+ asset,+ size,+ xf: Affine::translate(at) * Affine::scale(100.0 / size.0),+ auto_fit: Fitting::FillProportionally,+ fit_align: 4,+ crop: [0.0; 4],+ });+ d.insert_item(SpreadRef::Doc(0), it, None).unwrap();+ }++ fn add_box(d: &mut Document, r: Rect, swatch: &str) {+ let lid = d.default_layer();+ let mut b = Item::new(ItemId(d.alloc()), lid, Shape::Rectangle, designcraft_geom::shapes::rectangle(r));+ b.fill = Fill::swatch(swatch);+ d.insert_item(SpreadRef::Doc(0), b, None).unwrap();+ }++ /// A 4 × 2 PNG: red RGB or mid grey, optionally carrying an ICC profile.+ fn png(gray: bool, icc: Option<Vec<u8>>) -> Vec<u8> {+ let mut b = Vec::new();+ let mut enc = image::codecs::png::PngEncoder::new(&mut b);+ if let Some(p) = icc {+ enc.set_icc_profile(p).unwrap();+ }+ let (px, ty) = if gray { (vec![128u8; 8], ExtendedColorType::L8) } else { ([255u8, 0, 0].repeat(8), ExtendedColorType::Rgb8) };+ enc.write_image(&px, 4, 2, ty).unwrap();+ b+ }++ /// The header of an ICC v2.1 RGB display profile: what a PDF writer reads to tag an image+ /// `/ICCBased` (the check looks at the colour space, not at the profile's tables).+ fn rgb_icc() -> Vec<u8> {+ let mut p = vec![0u8; 132];+ p[..4].copy_from_slice(&132u32.to_be_bytes());+ p[8] = 2;+ p[9] = 0x10;+ p[12..16].copy_from_slice(b"mntr");+ p[16..20].copy_from_slice(b"RGB ");+ p[20..24].copy_from_slice(b"XYZ ");+ p[36..40].copy_from_slice(b"acsp");+ p+ }++ /// A 4 × 2 CMYK image (100% K) as krilla writes it.+ #[derive(Clone, Hash)]+ struct CmykImage(Vec<u8>);++ impl krilla::image::CustomImage for CmykImage {+ fn color_channel(&self) -> &[u8] {+ &self.0+ }+ fn alpha_channel(&self) -> Option<&[u8]> {+ None+ }+ fn bits_per_component(&self) -> krilla::image::BitsPerComponent {+ krilla::image::BitsPerComponent::Eight+ }+ fn size(&self) -> (u32, u32) {+ (4, 2)+ }+ fn icc_profile(&self) -> Option<&[u8]> {+ None+ }+ fn color_space(&self) -> krilla::image::ImageColorspace {+ krilla::image::ImageColorspace::Cmyk+ }+ }++ /// A one-page PDF 1.6 holding a CMYK image, as another app would hand over a placed graphic.+ fn pdf_with_cmyk_image() -> Vec<u8> {+ let configuration = krilla::configure::ConfigurationBuilder::new().with_version(krilla::configure::PdfVersion::Pdf16).finish().unwrap();+ let mut pdf = krilla::Document::new_with(krilla::SerializeSettings { configuration, ..Default::default() });+ let size = krilla::geom::Size::from_wh(100.0, 50.0).unwrap();+ let mut page = pdf.start_page_with(krilla::page::PageSettings::new(size));+ let mut s = page.surface();+ let img = krilla::image::Image::from_custom(CmykImage([0u8, 0, 0, 255].repeat(8)), false).unwrap();+ s.draw_image(img, size);+ s.finish();+ page.finish();+ pdf.finish().unwrap()+ }++ fn x4(d: &Document) -> ExportReport {+ export_pdf_with_report(d, &Cache::new(), &PdfOptions { standard: Standard::PdfX4, ..Default::default() }).unwrap()+ }++ /// The `/ColorSpace` of every image XObject: a name, or `[` for an array (ICCBased, Indexed…).+ fn image_spaces(bytes: &[u8]) -> Vec<String> {+ let pdf = hayro_syntax::Pdf::new(bytes.to_vec()).unwrap();+ let mut out: Vec<String> = pdf+ .objects()+ .into_iter()+ .filter_map(|o| o.into_stream())+ .filter(|s| s.dict().get::<Name>(b"Subtype").is_some_and(|n| n.as_str() == "Image") && s.dict().get::<bool>(b"ImageMask").is_none())+ .filter_map(|s| match s.dict().get::<Object>(b"ColorSpace")? {+ Object::Name(n) => Some(n.as_str().to_string()),+ Object::Array(a) => a.iter::<Name>().next().map(|n| format!("[{}", n.as_str())),+ _ => None,+ })+ .collect();+ out.sort();+ out+ }++ /// A placed RGB PNG went into PDF/X-4 as DeviceRGB under the CMYK output intent with no+ /// warning (#35's fallback).+ #[test]+ fn device_rgb_image_is_flagged() {+ let mut d = Document::new(&NewDocument::default());+ place(&mut d, "photo.png", png(false, None), (4.0, 2.0), (72.0, 72.0));+ let r = x4(&d);+ assert_eq!(image_spaces(&r.bytes), ["DeviceRGB"]);+ let rgb: Vec<&String> = r.warnings.iter().filter(|w| w.contains("RGB")).collect();+ assert_eq!(rgb.len(), 1, "{:?}", r.warnings);+ assert!(rgb[0].starts_with("PDF/X-4: an RGB image (object ") && rgb[0].contains("4 × 2 px) on page 1:"), "{}", rgb[0]);+ // Without a PDF/X output intent there is nothing to check RGB against.+ let plain = export_pdf_with_report(&d, &Cache::new(), &PdfOptions::default()).unwrap();+ assert!(!check_pdfx4(&plain.bytes).iter().any(|i| i.contains("RGB")));+ }++ /// CMYK and grey are the output intent's own values and ICC-tagged RGB is colour-managed:+ /// none of them is flagged, whether placed directly or inside a placed PDF.+ #[test]+ fn cmyk_grey_and_icc_rgb_pass() {+ let mut d = Document::new(&NewDocument::default());+ add_box(&mut d, Rect::new(36.0, 400.0, 136.0, 500.0), "C=100 M=0 Y=0 K=0");+ place(&mut d, "grey.png", png(true, None), (4.0, 2.0), (72.0, 72.0));+ place(&mut d, "tagged.png", png(false, Some(rgb_icc())), (4.0, 2.0), (72.0, 172.0));+ place(&mut d, "logo.pdf", pdf_with_cmyk_image(), (100.0, 50.0), (72.0, 272.0));+ let r = x4(&d);+ assert_eq!(image_spaces(&r.bytes), ["DeviceCMYK", "DeviceGray", "[ICCBased"]);+ assert!(r.warnings.is_empty(), "{:?}", r.warnings);+ }++ /// RGB swatches paint in DeviceRGB.+ #[test]+ fn device_rgb_fills_are_flagged() {+ let mut d = Document::new(&NewDocument { pages: 2, ..NewDocument::default() });+ d.swatches.push(Swatch::color("Brand Red", Color::rgb(0.9, 0.1, 0.1)));+ add_box(&mut d, Rect::new(36.0, 400.0, 136.0, 500.0), "Brand Red");+ let r = x4(&d);+ assert_eq!(r.warnings, ["PDF/X-4: RGB fills or strokes on page 1: under a CMYK output intent RGB needs an ICC profile"]);+ }++ /// A minimal PDF with a CMYK (N 4) PDF/X output intent and one page with `entries` (its+ /// resources, a group…) and `content`.+ fn tiny_pdf(entries: &str, content: &str) -> Vec<u8> {+ let objects = [+ "<</Type/Catalog/Pages 2 0 R/OutputIntents[<</Type/OutputIntent/S/GTS_PDFX/DestOutputProfile 4 0 R>>]>>".to_string(),+ "<</Type/Pages/Kids[3 0 R]/Count 1>>".to_string(),+ format!("<</Type/Page/Parent 2 0 R/MediaBox[0 0 100 100]{entries}/Contents 5 0 R>>"),+ "<</N 4/Length 0>>\nstream\n\nendstream".to_string(),+ format!("<</Length {}>>\nstream\n{content}\nendstream", content.len()),+ "<</N 3/Length 0>>\nstream\n\nendstream".to_string(),+ ];+ let mut out = b"%PDF-1.6\n".to_vec();+ let mut offsets = Vec::new();+ for (i, o) in objects.iter().enumerate() {+ offsets.push(out.len());+ out.extend_from_slice(format!("{} 0 obj\n{o}\nendobj\n", i + 1).as_bytes());+ }+ let xref = out.len();+ out.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f\r\n", objects.len() + 1).as_bytes());+ for off in offsets {+ out.extend_from_slice(format!("{off:010} 00000 n\r\n").as_bytes());+ }+ out.extend_from_slice(format!("trailer\n<</Size {}/Root 1 0 R>>\nstartxref\n{xref}\n%%EOF\n", objects.len() + 1).as_bytes());+ out+ }++ /// DeviceRGB is allowed when a `DefaultRGB` colour space makes it colour-managed.+ #[test]+ fn default_rgb_makes_device_rgb_managed() {+ let rgb = |i: &String| i.contains("RGB");+ let content = "1 0 0 rg 0 0 10 10 re f /DeviceRGB CS 0 0 1 SC 0 0 m 10 10 l S";+ let bare = check_pdfx4(&tiny_pdf("/Resources<<>>", content));+ assert_eq!(bare.iter().filter(|i| rgb(i)).count(), 1, "{bare:?}");+ let managed = check_pdfx4(&tiny_pdf("/Resources<</ColorSpace<</DefaultRGB[/ICCBased 6 0 R]>>>>", content));+ assert!(!managed.iter().any(rgb), "{managed:?}");+ // CMYK and grey need no default space.+ let cmyk = check_pdfx4(&tiny_pdf("/Resources<<>>", "0 0 0 1 k 0 0 10 10 re f 0.5 G 0 0 m 10 10 l S"));+ assert!(!cmyk.iter().any(rgb), "{cmyk:?}");+ }++ /// An RGB blending space on the page group and an RGB inline image are device RGB too.+ #[test]+ fn rgb_groups_and_inline_images_are_flagged() {+ let group = check_pdfx4(&tiny_pdf("/Resources<<>>/Group<</S/Transparency/CS/DeviceRGB>>", "0 0 0 1 k"));+ assert!(+ group.iter().any(|i| i == "a transparency group blending in RGB on page 1: under a CMYK output intent RGB needs an ICC profile"),+ "{group:?}"+ );+ let inline = check_pdfx4(&tiny_pdf("/Resources<<>>", "q BI /W 1 /H 1 /CS /RGB /BPC 8 /F /AHx ID ff0000> EI Q"));+ assert!(inline.iter().any(|i| i.starts_with("an RGB inline image on page 1")), "{inline:?}");+ let grey = check_pdfx4(&tiny_pdf("/Resources<<>>", "q BI /W 1 /H 1 /CS /G /BPC 8 /F /AHx ID 80> EI Q"));+ assert!(!grey.iter().any(|i| i.contains("RGB")), "{grey:?}");+ }+}