Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Export placed greyscale TIFFs as DeviceGray (#1426)

HEOJUNFOd49343f132f0
diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rs
index 4e7627e9e..e773896af 100644
--- a/crates/pdf/src/export.rs
+++ b/crates/pdf/src/export.rs
@@ -1635,6 +1635,21 @@ fn is_rgb_icc(icc: &[u8]) -> bool {
icc.get(16..20) == Some(b"RGB ".as_slice())
}
+/// Whether an ICC profile describes grey.
+fn is_grey_icc(icc: &[u8]) -> bool {
+ icc.get(16..20) == Some(b"GRAY".as_slice())
+}
+
+/// Whether `data` decodes to grey (with or without alpha), read from its header.
+fn is_grey(data: &[u8]) -> bool {
+ use image::ImageDecoder;
+ image::ImageReader::new(std::io::Cursor::new(data))
+ .with_guessed_format()
+ .ok()
+ .and_then(|r| r.into_decoder().ok())
+ .is_some_and(|dec| !dec.color_type().has_color())
+}
+
/// A JPEG, passed through. With `tag_rgb`, a JPEG keeps its own profile, and one without gets
/// sRGB. krilla uses a profile only when its channels match the JPEG's, so a grey or CMYK JPEG
/// without a profile stays DeviceGray or DeviceCMYK.
@@ -1674,6 +1689,10 @@ fn lossless(data: &Arc<Vec<u8>>, fmt: Option<image::ImageFormat>, mode: RasterMo
_ => None,
};
direct.or_else(|| {
+ // A grey TIFF, BMP… stays DeviceGray, as a grey PNG or JPEG does (#1426).
+ if let Some(grey) = GreyImage::new(data) {
+ return Image::from_custom(grey, i).ok();
+ }
// TIFF, BMP, PSD composites… and, with `tag_rgb`, untagged RGB.
if mode.tag_rgb {
return SrgbImage::new(rgba).and_then(|img| Image::from_custom(img, i).ok());
@@ -1728,6 +1747,61 @@ impl krilla::image::CustomImage for SrgbImage {
}
}
+/// A grey raster as a DeviceGray image (ICCBased when the file has a grey profile of its own), so
+/// a page that only holds black prints as black, not as RGB.
+#[derive(Clone, Hash)]
+struct GreyImage {
+ grey: Arc<Vec<u8>>,
+ /// Only when some pixel is not opaque.
+ alpha: Option<Arc<Vec<u8>>>,
+ size: (u32, u32),
+ icc: Option<Arc<Vec<u8>>>,
+}
+
+impl GreyImage {
+ /// `None` when `data` isn't grey or can't be decoded.
+ fn new(data: &[u8]) -> Option<Self> {
+ if !is_grey(data) {
+ return None;
+ }
+ let img = image::load_from_memory(data).ok()?.to_luma_alpha8();
+ let size = img.dimensions();
+ let pixels = usize::try_from(size.0).ok()?.checked_mul(usize::try_from(size.1).ok()?)?;
+ if pixels == 0 {
+ return None;
+ }
+ let (mut grey, mut alpha) = (Vec::with_capacity(pixels), Vec::with_capacity(pixels));
+ for p in img.pixels() {
+ grey.push(p.0[0]);
+ alpha.push(p.0[1]);
+ }
+ let alpha = alpha.iter().any(|a| *a < 255).then(|| Arc::new(alpha));
+ let icc = embedded_icc(data).filter(|p| is_grey_icc(p)).map(Arc::new);
+ Some(Self { grey: Arc::new(grey), alpha, size, icc })
+ }
+}
+
+impl krilla::image::CustomImage for GreyImage {
+ fn color_channel(&self) -> &[u8] {
+ &self.grey
+ }
+ fn alpha_channel(&self) -> Option<&[u8]> {
+ self.alpha.as_deref().map(Vec::as_slice)
+ }
+ fn bits_per_component(&self) -> krilla::image::BitsPerComponent {
+ krilla::image::BitsPerComponent::Eight
+ }
+ fn size(&self) -> (u32, u32) {
+ self.size
+ }
+ fn icc_profile(&self) -> Option<&[u8]> {
+ self.icc.as_deref().map(Vec::as_slice)
+ }
+ fn color_space(&self) -> krilla::image::ImageColorspace {
+ krilla::image::ImageColorspace::Luma
+ }
+}
+
/// A CMYK raster as a krilla image: its samples are written unchanged as DeviceCMYK, like a
/// CMYK JPEG's. An embedded ICC profile is left out, as it is for JPEGs: the inks are meant for
/// the output intent's press, and tagging them with another CMYK profile would let a RIP
@@ -1774,11 +1848,18 @@ fn recompress(data: &[u8], mode: RasterMode) -> Option<Image> {
if img.color().has_alpha() && img.to_rgba8().pixels().any(|p| p[3] < 255) {
return None;
}
- let rgb = img.to_rgb8();
let mut buf = Vec::new();
let enc = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut buf, 90);
- image::ImageEncoder::write_image(enc, rgb.as_raw(), rgb.width(), rgb.height(), image::ExtendedColorType::Rgb8).ok()?;
- jpeg(buf.into(), || embedded_icc(data).filter(|p| is_rgb_icc(p)), mode)
+ // A grey image stays a grey JPEG (#1426).
+ let grey = !img.color().has_color();
+ if grey {
+ let l = img.to_luma8();
+ image::ImageEncoder::write_image(enc, l.as_raw(), l.width(), l.height(), image::ExtendedColorType::L8).ok()?;
+ } else {
+ let rgb = img.to_rgb8();
+ image::ImageEncoder::write_image(enc, rgb.as_raw(), rgb.width(), rgb.height(), image::ExtendedColorType::Rgb8).ok()?;
+ }
+ jpeg(buf.into(), || embedded_icc(data).filter(|p| if grey { is_grey_icc(p) } else { is_rgb_icc(p) }), mode)
}
#[cfg(test)]
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index ee02e2190..39f472ffc 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -340,6 +340,26 @@ fn cmyk_tiff_keeps_its_inks() {
}
}
+/// A placed greyscale TIFF went into PDFs as DeviceRGB, unlike a greyscale PNG or JPEG (#1426):
+/// a page holding only a black-and-white scan declared colour.
+#[test]
+fn grey_tiff_exports_as_device_gray() {
+ let px: Vec<u8> = vec![0, 64, 128, 255, 255, 128, 64, 0];
+ let mut tif = Vec::new();
+ tiff::encoder::TiffEncoder::new(std::io::Cursor::new(&mut tif)).unwrap().write_image::<tiff::encoder::colortype::Gray8>(4, 2, &px).unwrap();
+ let mut d = doc_with_text("x");
+ place(&mut d, tif, (4, 2));
+ for standard in [Standard::None, Standard::PdfX4] {
+ let r = export_pdf_with_report(&d, &Cache::new(), &PdfOptions { standard, ..Default::default() }).unwrap();
+ assert!(r.warnings.is_empty(), "{standard:?}: {:?}", r.warnings);
+ assert_eq!(image_xobjects(&r.bytes), vec![("DeviceGray".to_string(), px.clone())], "{standard:?}");
+ }
+ // Recompressed, it stays a grey JPEG.
+ let r = export_pdf_with_report(&d, &Cache::new(), &PdfOptions { compress_images: true, compress: false, ..Default::default() }).unwrap();
+ let s = String::from_utf8_lossy(&r.bytes);
+ assert!(s.contains("/DCTDecode") && s.contains("/DeviceGray") && !s.contains("/DeviceRGB"), "a grey JPEG");
+}
+
/// An 8×8 raster encoded as `fmt`; `alpha` gives it a transparent corner.
fn raster(fmt: image::ImageFormat, alpha: bool) -> Vec<u8> {
let img =