mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 14:06:09 +00:00
888 lines
43 KiB
Rust
888 lines
43 KiB
Rust
//! Images in the PDF: the document's images as the Compression settings say (resampled above a
|
||
//! resolution, compressed with ZIP or JPEG) and converted as the Output settings say
|
||
//! ([`Pixels`]), and pixels the writer makes itself (freeform gradients).
|
||
//!
|
||
//! Every image is classified as the settings are split: colour, greyscale (a grey colour type) or
|
||
//! monochrome (greyscale that is only black and white). An image already as asked (not resampled,
|
||
//! a JPEG kept as JPEG or another kept lossless) is embedded as it is; the others are decoded,
|
||
//! resampled and encoded again. JPEG needs opaque pixels: images with transparency stay lossless.
|
||
//! A gray or RGB image that carries a profile the Output settings convert from ([`ToSrgb`]) is
|
||
//! always decoded: its pixels are converted to sRGB and written without the profile, at 16 bits a
|
||
//! sample when it has them and is otherwise kept as it is; a JPEG kept as JPEG whose samples the
|
||
//! conversion leaves unchanged (an sRGB profile) keeps its JPEG data. A black-and-white image whose
|
||
//! converted levels are grey is compressed as greyscale. A colour image the Output settings also
|
||
//! convert to their destination ([`Pixels`]) goes from its profile to sRGB, then to the
|
||
//! destination, and so does one converted from its profile to an RGB destination whose untagged
|
||
//! images keep their numbers (Preserve Numbers); a grey one keeps its profile there, as grey
|
||
//! pixels are not converted.
|
||
//!
|
||
//! CMYK images ([`ImageBlob::cmyk`]) stay CMYK: a CMYK JPEG already as asked is embedded as it is
|
||
//! when its numbers are kept; the others' ink amounts are resampled, converted when the Output
|
||
//! settings convert CMYK colours ([`CmykPixels`]) and compressed again. CMYK JPEGs hold Adobe's
|
||
//! inverted samples, which the PDF writer's Decode array undoes. A CMYK image whose numbers are
|
||
//! kept carries the CMYK profile it is given ([`cmyk_icc`]), whether it is embedded as it is or
|
||
//! written again; without one it is untagged, a JPEG's own `ICC_PROFILE` segments included.
|
||
//! With Don't Include Profiles set ([`SourceProfiles::Remove`], [`CmykTag::Removed`]), a JPEG
|
||
//! embedded as it is loses its `ICC_PROFILE` segments, its other segments and compressed samples
|
||
//! unchanged.
|
||
|
||
use std::io::Cursor;
|
||
use std::sync::Arc;
|
||
|
||
use craft_pdf::write::backend as krilla;
|
||
use image::imageops::FilterType;
|
||
use image::{DynamicImage, ExtendedColorType, ImageDecoder, ImageFormat, ImageReader};
|
||
use krilla::image::{BitsPerComponent, CustomImage, Image, ImageColorspace};
|
||
|
||
use vectorcraft_color::cms::{IccProfile, Intent};
|
||
use vectorcraft_doc::ImageBlob;
|
||
use vectorcraft_doc::cmyk::{Inks, jpeg_components};
|
||
use vectorcraft_doc::resample::{Resample, premultiply, resized, unpremultiply};
|
||
|
||
use crate::output::{CmykPixels, Pixels};
|
||
use crate::{CompressionSettings, Downsample, ImageCodec, JpegQuality, MonoCodec};
|
||
|
||
/// Raw pixels: colour samples (RGB, grey or CMYK) and an optional alpha channel, of 8 bits a
|
||
/// sample or of 16 (big-endian), with the ICC profile the colour samples are in, if any.
|
||
#[derive(Clone, Hash)]
|
||
struct Raw {
|
||
color: Arc<Vec<u8>>,
|
||
alpha: Option<Arc<Vec<u8>>>,
|
||
width: u32,
|
||
height: u32,
|
||
space: ImageColorspace,
|
||
bits: BitsPerComponent,
|
||
icc: Option<Arc<Vec<u8>>>,
|
||
}
|
||
|
||
impl CustomImage for Raw {
|
||
fn color_channel(&self) -> &[u8] {
|
||
&self.color
|
||
}
|
||
|
||
fn alpha_channel(&self) -> Option<&[u8]> {
|
||
self.alpha.as_deref().map(Vec::as_slice)
|
||
}
|
||
|
||
fn bits_per_component(&self) -> BitsPerComponent {
|
||
self.bits
|
||
}
|
||
|
||
fn size(&self) -> (u32, u32) {
|
||
(self.width, self.height)
|
||
}
|
||
|
||
fn icc_profile(&self) -> Option<&[u8]> {
|
||
self.icc.as_deref().map(Vec::as_slice)
|
||
}
|
||
|
||
fn color_space(&self) -> ImageColorspace {
|
||
self.space
|
||
}
|
||
}
|
||
|
||
/// `icc` when it is a well-formed profile ([`valid_icc`]) of the colour space `space` names: `GRAY`
|
||
/// for grey samples, `RGB ` for RGB ones. `None` for other profiles and spaces.
|
||
fn icc_for(icc: Option<Vec<u8>>, space: ImageColorspace) -> Option<Arc<Vec<u8>>> {
|
||
let want = match space {
|
||
ImageColorspace::Luma => *b"GRAY",
|
||
ImageColorspace::Rgb => *b"RGB ",
|
||
ImageColorspace::Cmyk | ImageColorspace::DeviceN => return None,
|
||
};
|
||
icc.filter(|icc| valid_icc(icc, want)).map(Arc::new)
|
||
}
|
||
|
||
/// The ICC profile image `bytes` carries: a TIFF's tag 34675 (read by the TIFF decoder itself, up
|
||
/// to 16 MiB), another format's as its decoder reads it. `None` without one.
|
||
pub(crate) fn source_icc(bytes: &[u8]) -> Option<Vec<u8>> {
|
||
let reader = ImageReader::new(Cursor::new(bytes)).with_guessed_format().ok()?;
|
||
if reader.format() == Some(ImageFormat::Tiff) {
|
||
return vectorcraft_doc::cmyk::tiff_icc_profile(bytes);
|
||
}
|
||
let mut decoder = reader.into_decoder().ok()?;
|
||
decoder.icc_profile().ok().flatten().filter(|icc| !icc.is_empty())
|
||
}
|
||
|
||
/// A `width` × `height` image of straight (not premultiplied) RGBA pixels, written as RGB (as
|
||
/// CMYK when `pixels` converts to CMYK), or as grey when every pixel is grey, with an alpha
|
||
/// channel only when some pixel isn't opaque. With an RGB `icc` profile, pixels that `pixels`
|
||
/// doesn't convert stay RGB and carry it; a grey one tags grey pixels. `interpolate` asks viewers
|
||
/// to smooth it when enlarged (PDF/A forbids it). `None` when `rgba` doesn't hold that many pixels.
|
||
fn from_rgba(rgba: &[u8], width: u32, height: u32, interpolate: bool, pixels: Option<&Pixels>, icc: Option<Vec<u8>>) -> Option<Image> {
|
||
let px = rgba.as_chunks::<4>().0;
|
||
if px.len() as u64 != width as u64 * height as u64 || px.is_empty() {
|
||
return None;
|
||
}
|
||
let rgb_icc = pixels.is_none() && icc.as_deref().is_some_and(|icc| valid_icc(icc, *b"RGB "));
|
||
let (color, space) = if neutral(rgba) && !rgb_icc {
|
||
(px.iter().map(|p| p[0]).collect(), ImageColorspace::Luma)
|
||
} else if let Some(cmyk) = pixels.and_then(|p| p.cmyk(rgba)) {
|
||
(cmyk, ImageColorspace::Cmyk)
|
||
} else {
|
||
(px.iter().flat_map(|p| [p[0], p[1], p[2]]).collect(), ImageColorspace::Rgb)
|
||
};
|
||
let icc = icc_for(icc.filter(|_| pixels.is_none()), space);
|
||
let alpha = px.iter().any(|p| p[3] < 255).then(|| Arc::new(px.iter().map(|p| p[3]).collect()));
|
||
Image::from_custom(Raw { color: Arc::new(color), alpha, width, height, space, bits: BitsPerComponent::Eight, icc }, interpolate).ok()
|
||
}
|
||
|
||
/// Decoded image `img` written losslessly as it is: grey or RGB samples (other kinds as RGB), with
|
||
/// an alpha channel only when some pixel isn't opaque, at 16 bits a sample when it has more than 8
|
||
/// and `sixteen_bit` allows it (PDF 1.5 and later), else at 8; tagged with ICC profile `icc` when
|
||
/// that is a profile of the samples' colour space (`GRAY` or `RGB `). `None` when it has no pixels.
|
||
pub(crate) fn from_decoded(img: DynamicImage, icc: Option<Vec<u8>>, interpolate: bool, sixteen_bit: bool) -> Option<Image> {
|
||
let (width, height) = (img.width(), img.height());
|
||
if width == 0 || height == 0 {
|
||
return None;
|
||
}
|
||
let kind = img.color();
|
||
let space = if kind.has_color() { ImageColorspace::Rgb } else { ImageColorspace::Luma };
|
||
let n = if kind.has_color() { 3 } else { 1 };
|
||
let deep = sixteen_bit && kind.bits_per_pixel() > 8 * u16::from(kind.channel_count());
|
||
let (color, alpha, bits) = if deep {
|
||
let s = if kind.has_color() { img.into_rgba16().into_raw() } else { img.into_luma_alpha16().into_raw() };
|
||
let px = s.chunks_exact(n + 1);
|
||
let color = px.clone().flat_map(|p| p[..n].iter().flat_map(|v| v.to_be_bytes())).collect();
|
||
let alpha = (kind.has_alpha() && px.clone().any(|p| p[n] < u16::MAX)).then(|| px.flat_map(|p| p[n].to_be_bytes()).collect());
|
||
(color, alpha, BitsPerComponent::Sixteen)
|
||
} else {
|
||
let s = if kind.has_color() { img.into_rgba8().into_raw() } else { img.into_luma_alpha8().into_raw() };
|
||
let px = s.chunks_exact(n + 1);
|
||
let color = px.clone().flat_map(|p| p[..n].iter().copied()).collect();
|
||
let alpha = (kind.has_alpha() && px.clone().any(|p| p[n] < u8::MAX)).then(|| px.map(|p| p[n]).collect());
|
||
(color, alpha, BitsPerComponent::Eight)
|
||
};
|
||
let raw = Raw { color: Arc::new(color), alpha: alpha.map(Arc::new), width, height, space, bits, icc: icc_for(icc, space) };
|
||
Image::from_custom(raw, interpolate).ok()
|
||
}
|
||
|
||
/// Image `bytes` decoded within [`limits`], with the ICC profile it carries ([`source_icc`]) when
|
||
/// `profiles` keeps it ([`SourceProfiles::Keep`]), as [`from_decoded`] writes it. `None` when it
|
||
/// can't be decoded.
|
||
pub(crate) fn decoded_image(bytes: &[u8], interpolate: bool, sixteen_bit: bool, profiles: SourceProfiles) -> Option<Image> {
|
||
from_decoded(decoded(bytes)?, (profiles == SourceProfiles::Keep).then(|| source_icc(bytes)).flatten(), interpolate, sixteen_bit)
|
||
}
|
||
|
||
/// Are all of the RGBA pixels `rgba` grey?
|
||
fn neutral(rgba: &[u8]) -> bool {
|
||
rgba.as_chunks::<4>().0.iter().all(|p| p[0] == p[1] && p[1] == p[2])
|
||
}
|
||
|
||
/// Colour `samples` (grey, RGB, or CMYK ink amounts, as `space` says) with an optional `alpha`
|
||
/// channel, written losslessly, tagged with ICC profile `icc` when given.
|
||
fn lossless(
|
||
samples: Vec<u8>,
|
||
alpha: Option<Vec<u8>>,
|
||
space: ImageColorspace,
|
||
width: u32,
|
||
height: u32,
|
||
interpolate: bool,
|
||
icc: Option<&[u8]>,
|
||
) -> Option<Image> {
|
||
let icc = icc.map(|icc| Arc::new(icc.to_vec()));
|
||
let raw = Raw { color: Arc::new(samples), alpha: alpha.map(Arc::new), width, height, space, bits: BitsPerComponent::Eight, icc };
|
||
Image::from_custom(raw, interpolate).ok()
|
||
}
|
||
|
||
/// Most pixels an image may have to be embedded: twice what the app reads (64 million), so every image
|
||
/// it holds is still written.
|
||
pub(crate) const MAX_EMBED_PIXELS: u64 = 1 << 27;
|
||
|
||
/// The most bytes an ICC profile carried by an image is written or read with (16 MiB).
|
||
pub(crate) const MAX_ICC: usize = 16 << 20;
|
||
|
||
/// The CMYK ICC profile image `blob` carries ([`ImageBlob::cmyk_icc_profile`]), when it is one a
|
||
/// CMYK image can be tagged with ([`valid_icc`]). `None` for other images and other profiles.
|
||
pub(crate) fn cmyk_icc(blob: &ImageBlob) -> Option<Vec<u8>> {
|
||
blob.cmyk_icc_profile().filter(|icc| valid_icc(icc, *b"CMYK"))
|
||
}
|
||
|
||
/// Is `icc` a profile an image of colour space `space` (`GRAY`, `RGB ` or `CMYK`) can be tagged
|
||
/// with: at most [`MAX_ICC`] bytes, the size its header declares, the `acsp` signature, an input,
|
||
/// display, output or colour space profile of `space` colours, and a tag table whose tags lie
|
||
/// within it?
|
||
pub(crate) fn valid_icc(icc: &[u8], space: [u8; 4]) -> bool {
|
||
let be = |at: usize| icc.get(at..at + 4).and_then(|b| b.try_into().ok()).map(u32::from_be_bytes);
|
||
let fits = |at: u32, len: u32| u64::from(at) + u64::from(len) <= icc.len() as u64;
|
||
if icc.len() > MAX_ICC || be(0).and_then(|n| usize::try_from(n).ok()) != Some(icc.len()) {
|
||
return false;
|
||
}
|
||
let class = icc.get(12..16);
|
||
if icc.get(36..40) != Some(b"acsp".as_slice())
|
||
|| icc.get(16..20) != Some(space.as_slice())
|
||
|| ![b"scnr", b"mntr", b"prtr", b"spac"].iter().any(|c| class == Some(c.as_slice()))
|
||
{
|
||
return false;
|
||
}
|
||
let Some(count) = be(128) else { return false };
|
||
if !fits(132, count.saturating_mul(12)) {
|
||
return false;
|
||
}
|
||
(0..count as usize).all(|i| {
|
||
let at = 132 + i * 12;
|
||
matches!((be(at + 4), be(at + 8)), (Some(offset), Some(len)) if fits(offset, len))
|
||
})
|
||
}
|
||
|
||
/// [`from_rgba`] of pixels converted by `pixels` (when given).
|
||
pub(crate) fn from_rgba_in(mut rgba: Vec<u8>, width: u32, height: u32, interpolate: bool, pixels: Option<&Pixels>) -> Option<Image> {
|
||
if let Some(p) = pixels {
|
||
p.rgb_in_place(&mut rgba);
|
||
}
|
||
from_rgba(&rgba, width, height, interpolate, pixels, None)
|
||
}
|
||
|
||
/// A `width` × `height` image of CMYK ink amounts `inks` (four bytes a pixel), converted by
|
||
/// `convert` (when given), with straight `alpha` (one byte a pixel) carried only when some pixel
|
||
/// isn't opaque. `None` when the buffers don't hold that many pixels.
|
||
pub(crate) fn from_inks(inks: Vec<u8>, alpha: Vec<u8>, width: u32, height: u32, interpolate: bool, convert: Option<&CmykPixels>) -> Option<Image> {
|
||
let pixels = u64::from(width) * u64::from(height);
|
||
if pixels == 0 || inks.len() as u64 != pixels * 4 || alpha.len() as u64 != pixels {
|
||
return None;
|
||
}
|
||
let alpha = alpha.iter().any(|a| *a < 255).then_some(alpha);
|
||
let (samples, space) = match convert {
|
||
Some(p) => p.convert(&inks),
|
||
None => (inks, ImageColorspace::Cmyk),
|
||
};
|
||
lossless(samples, alpha, space, width, height, interpolate, None)
|
||
}
|
||
|
||
/// The kinds of images the Compression section has settings for.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
enum Kind {
|
||
Color,
|
||
Gray,
|
||
Mono,
|
||
}
|
||
|
||
/// How an image's pixels are compressed in the file.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
enum Codec {
|
||
/// JPEG images stay JPEG (at this quality when they are resampled); the others are lossless.
|
||
Auto(u8),
|
||
Zip,
|
||
Jpeg(u8),
|
||
}
|
||
|
||
/// The settings for one kind of image.
|
||
struct Rule {
|
||
downsample: Downsample,
|
||
/// Target resolution, and the resolution above which images are resampled (ppi).
|
||
ppi: f64,
|
||
above: f64,
|
||
codec: Codec,
|
||
/// Why the codec differs from the one asked for (that one isn't available).
|
||
instead: Option<&'static str>,
|
||
}
|
||
|
||
const UNCOMPRESSED: &str = "uncompressed images are not written: images are compressed with ZIP";
|
||
const CMYK_KEPT: &str = "a CMYK image couldn't be decoded: it is written as it is, not resampled or converted";
|
||
const CMYK_RGB: &str = "a CMYK image couldn't be decoded in CMYK: it is written in RGB";
|
||
|
||
/// JPEG quality (1–100) of a quality setting.
|
||
fn quality(q: JpegQuality) -> u8 {
|
||
match q {
|
||
JpegQuality::Minimum => 10,
|
||
JpegQuality::Low => 30,
|
||
JpegQuality::Medium => 55,
|
||
JpegQuality::High => 80,
|
||
JpegQuality::Maximum => 95,
|
||
}
|
||
}
|
||
|
||
fn rule(c: &CompressionSettings, kind: Kind) -> Rule {
|
||
if kind == Kind::Mono {
|
||
let m = &c.mono;
|
||
let instead = match m.compression {
|
||
MonoCodec::Zip => None,
|
||
MonoCodec::None => Some(UNCOMPRESSED),
|
||
MonoCodec::CcittG3 | MonoCodec::CcittG4 => Some("CCITT compression is not supported: monochrome images are compressed with ZIP"),
|
||
MonoCodec::RunLength => Some("Run Length compression is not supported: monochrome images are compressed with ZIP"),
|
||
};
|
||
return Rule { downsample: m.downsample, ppi: m.ppi, above: m.above_ppi, codec: Codec::Zip, instead };
|
||
}
|
||
let i = if kind == Kind::Color { &c.color } else { &c.gray };
|
||
let (codec, instead) = match i.compression {
|
||
ImageCodec::Auto => (Codec::Auto(quality(i.quality)), None),
|
||
ImageCodec::Zip => (Codec::Zip, None),
|
||
ImageCodec::Jpeg => (Codec::Jpeg(quality(i.quality)), None),
|
||
ImageCodec::None => (Codec::Zip, Some(UNCOMPRESSED)),
|
||
ImageCodec::Jpeg2000 => (Codec::Zip, Some("JPEG 2000 compression is not supported: those images are compressed with ZIP")),
|
||
};
|
||
Rule { downsample: i.downsample, ppi: i.ppi, above: i.above_ppi, codec, instead }
|
||
}
|
||
|
||
/// What [`recode`] makes of an image.
|
||
pub(crate) struct Recoded {
|
||
/// The image to write; `None` keeps the source image as it is.
|
||
pub image: Option<Image>,
|
||
/// Set when the image isn't compressed as asked.
|
||
pub warning: Option<&'static str>,
|
||
/// Set when the image's colors are converted to the destination without its ICC profile,
|
||
/// which can't be read.
|
||
pub note: Option<&'static str>,
|
||
/// Set when the colors were to be converted but the image couldn't be decoded within the
|
||
/// allowance or written with them: the source image, kept as it is, would be in its own colors.
|
||
pub unconverted: bool,
|
||
}
|
||
|
||
/// How [`recode`] converts a gray or RGB image that carries an ICC profile to sRGB
|
||
/// ([`crate::output::ColorOut::image_srgb_intent`]): the destination when it is sRGB, else the
|
||
/// step before the image's [`Pixels`] conversion.
|
||
#[derive(Clone, Copy)]
|
||
pub(crate) struct ToSrgb<'a> {
|
||
/// The rendering intent of the conversion.
|
||
pub intent: Intent,
|
||
/// 16-bit samples may be written (PDF 1.5 and later).
|
||
pub sixteen_bit: bool,
|
||
/// The colour output whose [`crate::output::ColorOut::tagged_pixels`] then convert a colour
|
||
/// image converted from its profile, when other colour images are not converted (`recode`'s
|
||
/// `convert`): to an RGB destination whose untagged images keep their numbers (Preserve
|
||
/// Numbers). Its table is built when the first such image needs it.
|
||
pub then: Option<&'a crate::output::ColorOut>,
|
||
/// Gray images are converted too: with an sRGB destination
|
||
/// ([`crate::output::ColorOut::converts_grey_images`]). In the others they keep their profile.
|
||
pub grey: bool,
|
||
}
|
||
|
||
/// What happens to the ICC profile a gray or RGB image carries
|
||
/// ([`crate::output::ColorOut::source_profiles`]).
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
pub(crate) enum SourceProfiles {
|
||
/// The image keeps a well-formed gray or RGB profile ([`valid_icc`]).
|
||
Keep,
|
||
/// The image is untagged; a JPEG embedded as it is keeps its data unchanged (PDF/X-1a).
|
||
Untag,
|
||
/// The image is untagged and a JPEG embedded as it is loses its `ICC_PROFILE` segments, its
|
||
/// other segments and compressed samples unchanged (Don't Include Profiles).
|
||
Remove,
|
||
}
|
||
|
||
/// The CMYK profile [`recode_cmyk`] tags a CMYK image that keeps its numbers with.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
pub(crate) enum CmykTag<'a> {
|
||
/// This profile ([`cmyk_icc`]).
|
||
Profile(&'a [u8]),
|
||
/// None; a JPEG embedded as it is keeps its data unchanged.
|
||
Untagged,
|
||
/// None, and a JPEG embedded as it is loses its `ICC_PROFILE` segments, its other segments
|
||
/// and compressed samples unchanged (Don't Include Profiles).
|
||
Removed,
|
||
}
|
||
|
||
impl<'a> CmykTag<'a> {
|
||
/// The profile the image is tagged with.
|
||
fn icc(self) -> Option<&'a [u8]> {
|
||
match self {
|
||
Self::Profile(icc) => Some(icc),
|
||
Self::Untagged | Self::Removed => None,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// JPEG `bytes` as they are embedded: without their `ICC_PROFILE` segments with `remove`
|
||
/// ([`vectorcraft_doc::cmyk::jpeg_without_icc`]). `None` when those can't be taken out.
|
||
pub(crate) fn jpeg_data(bytes: &[u8], remove: bool) -> Option<Vec<u8>> {
|
||
if remove { vectorcraft_doc::cmyk::jpeg_without_icc(bytes) } else { Some(bytes.to_vec()) }
|
||
}
|
||
|
||
/// The ICC profile image `bytes` carries ([`source_icc`]), when it is a well-formed profile of
|
||
/// colour space `space` (`GRAY` or `RGB `, [`valid_icc`]): `None` without one, `Some(None)` when
|
||
/// the CMS can't read it.
|
||
fn source_profile(bytes: &[u8], space: [u8; 4]) -> Option<Option<IccProfile>> {
|
||
let icc = source_icc(bytes).filter(|icc| valid_icc(icc, space))?;
|
||
Some(IccProfile::from_bytes(None, &icc).ok())
|
||
}
|
||
|
||
const UNCONVERTED: &str = "an image's ICC profile couldn't be read: the image keeps it and is not converted to sRGB";
|
||
const CONVERTED_AS_SRGB: &str = "an image's ICC profile couldn't be read: its colors are converted to the destination as sRGB";
|
||
|
||
const UNDECODED: &str = "an image couldn't be decoded and is not converted to sRGB";
|
||
|
||
/// `img` converted from ICC profile `p` to sRGB with `intent`: at 16 bits a sample when it has
|
||
/// more than 8, else at 8, with its alpha; and whether any sample changed. A grey image stays grey, each level as the sRGB grey it converts to. `None` when the
|
||
/// pixels can't be converted.
|
||
fn into_srgb(img: DynamicImage, p: &IccProfile, intent: Intent) -> Option<(DynamicImage, bool)> {
|
||
let kind = img.color();
|
||
let deep = kind.bits_per_pixel() > 8 * u16::from(kind.channel_count());
|
||
let to8 = |v: f32| v.round() as u8;
|
||
let to16 = |v: f32| v.round() as u16;
|
||
Some(match (kind.has_color(), deep) {
|
||
(true, true) => {
|
||
let mut s = img.into_rgba16();
|
||
let changed = convert_samples(&mut s, 3, p, intent, 65_535.0, to16)?;
|
||
(DynamicImage::ImageRgba16(s), changed)
|
||
}
|
||
(true, false) => {
|
||
let mut s = img.into_rgba8();
|
||
let changed = convert_samples(&mut s, 3, p, intent, 255.0, to8)?;
|
||
(DynamicImage::ImageRgba8(s), changed)
|
||
}
|
||
(false, true) => {
|
||
let mut s = img.into_luma_alpha16();
|
||
let changed = convert_samples(&mut s, 1, p, intent, 65_535.0, to16)?;
|
||
(DynamicImage::ImageLumaA16(s), changed)
|
||
}
|
||
(false, false) => {
|
||
let mut s = img.into_luma_alpha8();
|
||
let changed = convert_samples(&mut s, 1, p, intent, 255.0, to8)?;
|
||
(DynamicImage::ImageLumaA8(s), changed)
|
||
}
|
||
})
|
||
}
|
||
|
||
/// Convert the `n` colour samples (1: grey, 3: RGB) of each pixel of `samples` (followed by an
|
||
/// alpha sample each, which is left as it is) from ICC profile `p` to sRGB with `intent`, a run of
|
||
/// pixels at a time; `max` is a sample's largest value, `back` turns a value of 0 to `max` into a
|
||
/// sample. Grey pixels take the mean of the sRGB values. Whether any sample changed; `None` when
|
||
/// the transform fails.
|
||
fn convert_samples<T: Copy + PartialEq + Into<f32>>(
|
||
samples: &mut [T],
|
||
n: usize,
|
||
p: &IccProfile,
|
||
intent: Intent,
|
||
max: f32,
|
||
back: impl Fn(f32) -> T,
|
||
) -> Option<bool> {
|
||
const RUN: usize = 4096;
|
||
let mut src = Vec::with_capacity(RUN * n);
|
||
let mut dst = vec![0.0f32; RUN * 3];
|
||
let mut changed = false;
|
||
for run in samples.chunks_mut(RUN * (n + 1)) {
|
||
src.clear();
|
||
src.extend(run.chunks_exact(n + 1).flat_map(|px| px.iter().take(n).map(|v| (*v).into() / max)));
|
||
let out = dst.get_mut(..src.len() / n * 3)?;
|
||
p.to_srgb_pixels(&src, out, intent)?;
|
||
for (px, rgb) in run.chunks_exact_mut(n + 1).zip(out.as_chunks::<3>().0) {
|
||
let grey = [rgb.iter().sum::<f32>() / 3.0];
|
||
let values: &[f32] = if n == 1 { &grey } else { rgb };
|
||
for (v, c) in px.iter_mut().zip(values) {
|
||
let new = back(c * max);
|
||
changed |= new != *v;
|
||
*v = new;
|
||
}
|
||
}
|
||
}
|
||
Some(changed)
|
||
}
|
||
|
||
/// Is `img` (a grey image) only black and white?
|
||
fn bilevel(img: &DynamicImage) -> bool {
|
||
img.to_luma_alpha8().pixels().all(|p| p[0] == 0 || p[0] == 255)
|
||
}
|
||
|
||
/// The size `r` gives an image of `w` × `h` pixels placed `size` points wide and high: a side
|
||
/// whose resolution is above the threshold goes down to the target resolution.
|
||
fn sized(r: &Rule, (w, h): (u32, u32), size: (f64, f64)) -> (u32, u32) {
|
||
let ppi = |px: u32, pt: f64| px as f64 * 72.0 / pt.abs();
|
||
let (px, py) = (ppi(w, size.0), ppi(h, size.1));
|
||
let resample = r.downsample != Downsample::None && [px, py].iter().any(|p| p.is_finite() && *p > r.above);
|
||
let side = |n: u32, p: f64| if resample && p.is_finite() && p > r.ppi { ((n as f64 * r.ppi / p).round() as u32).clamp(1, n) } else { n };
|
||
(side(w, px), side(h, py))
|
||
}
|
||
|
||
/// Is an image of `dims` pixels placed `size` points already as `r` asks: not resampled, and
|
||
/// lossless or (`jpeg`) a JPEG kept as JPEG?
|
||
fn kept(r: &Rule, dims: (u32, u32), size: (f64, f64), jpeg: bool) -> bool {
|
||
sized(r, dims, size) == dims
|
||
&& match r.codec {
|
||
Codec::Auto(_) => true,
|
||
Codec::Zip => !jpeg,
|
||
Codec::Jpeg(_) => jpeg,
|
||
}
|
||
}
|
||
|
||
/// The JPEG quality `r` compresses an image with (`jpeg`: it is a JPEG); `None`: lossless.
|
||
fn jpeg_quality(r: &Rule, jpeg: bool) -> Option<u8> {
|
||
match r.codec {
|
||
Codec::Jpeg(q) => Some(q),
|
||
Codec::Auto(q) if jpeg => Some(q),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// How `r` resamples an image.
|
||
fn resampling(r: &Rule) -> Resample {
|
||
match r.downsample {
|
||
Downsample::Average => Resample::Average,
|
||
Downsample::Subsample => Resample::Filter(FilterType::Nearest),
|
||
Downsample::Bicubic | Downsample::None => Resample::Filter(FilterType::CatmullRom),
|
||
}
|
||
}
|
||
|
||
/// `img` resampled to `w` × `h` pixels as `r` says, the colors of an image with alpha weighted by
|
||
/// it ([`resized`]).
|
||
fn resample(img: DynamicImage, r: &Rule, (w, h): (u32, u32)) -> DynamicImage {
|
||
resized(img, w, h, resampling(r))
|
||
}
|
||
|
||
/// The four channels of `img` resampled to `w` × `h` pixels as `r` says, each on its own.
|
||
fn resample_channels(img: DynamicImage, r: &Rule, (w, h): (u32, u32)) -> DynamicImage {
|
||
if (w, h) == (img.width(), img.height()) {
|
||
return img;
|
||
}
|
||
match resampling(r) {
|
||
Resample::Average => img.thumbnail_exact(w, h),
|
||
Resample::Filter(f) => img.resize_exact(w, h, f),
|
||
}
|
||
}
|
||
|
||
/// Encoded image `bytes` placed `size` points wide and high, as the Compression settings `c` ask:
|
||
/// resampled when its resolution is above the threshold, compressed with ZIP or JPEG, its colours
|
||
/// converted by `convert` (colour images). Pixels that keep their colours keep the ICC profile
|
||
/// they carry when `profiles` keeps it ([`SourceProfiles::Keep`]); with `to_srgb`, pixels in a
|
||
/// gray or RGB profile other than sRGB are converted from it to sRGB instead ([`ToSrgb`]), and
|
||
/// colour ones then by `convert`, or without it by the conversion `to_srgb` gives
|
||
/// ([`ToSrgb::then`]); grey ones keep their profile unless the destination is sRGB
|
||
/// ([`ToSrgb::grey`]). `interpolate` lets viewers smooth it. An image that can't be decoded is
|
||
/// kept as it is, with a warning when its pixels were to be converted to sRGB. When `convert`
|
||
/// was to convert its colors, it is [`Recoded::unconverted`] if its header can't be read (it may
|
||
/// be in color) or its pixels are beyond the decode allowance; a color image whose pixel data
|
||
/// can't be read is not.
|
||
pub(crate) fn recode(
|
||
bytes: &[u8],
|
||
size: (f64, f64),
|
||
c: &CompressionSettings,
|
||
interpolate: bool,
|
||
convert: Option<&Pixels>,
|
||
profiles: SourceProfiles,
|
||
to_srgb: Option<ToSrgb>,
|
||
) -> Recoded {
|
||
let keep = Recoded { image: None, warning: None, note: None, unconverted: convert.is_some() };
|
||
let Ok(reader) = ImageReader::new(Cursor::new(bytes)).with_guessed_format() else { return keep };
|
||
let jpeg = reader.format() == Some(ImageFormat::Jpeg);
|
||
let Ok(mut decoder) = reader.into_decoder() else { return keep };
|
||
let dims = decoder.dimensions();
|
||
use ExtendedColorType as T;
|
||
let grey = matches!(decoder.original_color_type(), T::L1 | T::La1 | T::L2 | T::La2 | T::L4 | T::La4 | T::L8 | T::La8 | T::L16 | T::La16);
|
||
// Pixels in a profile they are converted from are decoded, whatever the Compression settings.
|
||
// Grey pixels keep their profile unless the destination is sRGB ([`ToSrgb::grey`]).
|
||
let then = to_srgb.and_then(|t| t.then);
|
||
let to_srgb = to_srgb.filter(|t| !grey || t.grey);
|
||
// Converted to the destination as sRGB, as before, when the profile can't be read.
|
||
let mut note = None;
|
||
let source = match to_srgb.and_then(|t| Some((source_profile(bytes, if grey { *b"GRAY" } else { *b"RGB " })?, t))) {
|
||
Some((Some(p), t)) => Some((p, t)),
|
||
Some((None, _)) if convert.is_some() => {
|
||
note = Some(CONVERTED_AS_SRGB);
|
||
None
|
||
}
|
||
Some((None, _)) => return Recoded { image: None, warning: Some(UNCONVERTED), note: None, unconverted: false },
|
||
None => None,
|
||
};
|
||
// Pixels that can't be decoded are kept as they are, with a warning when they were to be
|
||
// converted.
|
||
let keep = if source.is_some() { Recoded { warning: Some(UNDECODED), ..keep } } else { keep };
|
||
// What the header declares is decoded within the image allowance, not whatever it asks for.
|
||
// Grey pixels aren't converted.
|
||
if decoder.set_limits(limits()).is_err() {
|
||
return Recoded { unconverted: convert.is_some() && !grey, ..keep };
|
||
}
|
||
let (mut kind, pixels) = if grey {
|
||
// Only the pixels tell monochrome images from greyscale ones: decoded unless both keep it.
|
||
let (g, m) = (rule(c, Kind::Gray), rule(c, Kind::Mono));
|
||
if source.is_none() && kept(&g, dims, size, jpeg) && kept(&m, dims, size, jpeg) && g.instead == m.instead {
|
||
return Recoded { image: None, warning: g.instead, note: None, unconverted: false };
|
||
}
|
||
// Grey pixels aren't converted.
|
||
let Ok(img) = DynamicImage::from_decoder(decoder) else { return Recoded { unconverted: false, ..keep } };
|
||
(if bilevel(&img) { Kind::Mono } else { Kind::Gray }, Some(img))
|
||
} else {
|
||
(Kind::Color, None)
|
||
};
|
||
let mut rule = rule(c, kind);
|
||
let convert = convert.filter(|_| kind == Kind::Color);
|
||
if kept(&rule, dims, size, jpeg) && convert.is_none() && source.is_none() {
|
||
return Recoded { image: None, warning: rule.instead, note: None, unconverted: false };
|
||
}
|
||
// Pixels that can't be read can't be written in their own colors either; ones beyond the
|
||
// allowance can.
|
||
let mut img = match pixels.map_or_else(|| decoded_within(bytes), Ok) {
|
||
Ok(img) => img,
|
||
Err(limited) => return Recoded { unconverted: limited && convert.is_some(), ..keep },
|
||
};
|
||
// Converted from its profile: then by `convert`, else by the conversion `to_srgb` gives.
|
||
let mut from_profile = false;
|
||
if let Some((p, t)) = &source {
|
||
let srgb = match into_srgb(img, p, t.intent) {
|
||
Some(s) => Some(s),
|
||
None if convert.is_some() => {
|
||
// Converted to the destination as sRGB: decoded again (a colour image), as the
|
||
// conversion took the pixels.
|
||
note = Some(CONVERTED_AS_SRGB);
|
||
None
|
||
}
|
||
None => return Recoded { image: None, warning: Some(UNCONVERTED), note: None, unconverted: false },
|
||
};
|
||
img = match srgb {
|
||
Some((srgb, changed)) => {
|
||
// The converted levels of a black-and-white image may be grey.
|
||
if kind == Kind::Mono && !bilevel(&srgb) {
|
||
(kind, rule) = (Kind::Gray, self::rule(c, Kind::Gray));
|
||
}
|
||
from_profile = true;
|
||
// Written as it is only when nothing converts it further.
|
||
let as_is = kept(&rule, dims, size, jpeg) && convert.is_none() && then.is_none();
|
||
// A JPEG kept as JPEG whose samples the conversion leaves unchanged (an sRGB
|
||
// profile): its JPEG data, without the profile (and, with `Remove`, without its
|
||
// segments: encoded again when those can't be taken out).
|
||
if !changed
|
||
&& as_is
|
||
&& jpeg
|
||
&& let Some(data) = jpeg_data(bytes, profiles == SourceProfiles::Remove)
|
||
{
|
||
let image = Image::from_jpeg_with_icc(data.into(), None, interpolate).ok();
|
||
return Recoded { image, warning: rule.instead, note: None, unconverted: false };
|
||
}
|
||
// Not resampled and lossless: written at its own depth.
|
||
if as_is && jpeg_quality(&rule, jpeg).is_none() {
|
||
let image = from_decoded(srgb, None, interpolate, t.sixteen_bit);
|
||
return Recoded { image, warning: rule.instead, note: None, unconverted: false };
|
||
}
|
||
srgb
|
||
}
|
||
None => match decoded_within(bytes) {
|
||
Ok(img) => img,
|
||
Err(limited) => return Recoded { unconverted: limited && convert.is_some(), ..keep },
|
||
},
|
||
};
|
||
}
|
||
let convert = if from_profile { convert.or_else(|| then.and_then(crate::output::ColorOut::tagged_pixels)) } else { convert };
|
||
// Pixels that keep their colours keep the profile they are in; converted ones are in the
|
||
// destination's.
|
||
let want = if kind == Kind::Color { *b"RGB " } else { *b"GRAY" };
|
||
let keeps = profiles == SourceProfiles::Keep && convert.is_none() && source.is_none();
|
||
let icc = keeps.then(|| source_icc(bytes)).flatten().filter(|icc| valid_icc(icc, want));
|
||
let rgb_icc = icc.is_some() && kind == Kind::Color;
|
||
let mut rgba = resample(img, &rule, sized(&rule, dims, size)).into_rgba8();
|
||
if kind == Kind::Mono {
|
||
// Resampling greys the edges: back to black and white.
|
||
for p in rgba.pixels_mut() {
|
||
let v = if p[0] >= 128 { 255 } else { 0 };
|
||
(p[0], p[1], p[2]) = (v, v, v);
|
||
}
|
||
}
|
||
if let Some(p) = convert {
|
||
p.rgb_in_place(&mut rgba);
|
||
}
|
||
let (width, height) = rgba.dimensions();
|
||
let opaque = rgba.pixels().all(|p| p[3] == 255);
|
||
let jpeg = jpeg_quality(&rule, jpeg).filter(|_| opaque).and_then(|q| {
|
||
// Grey pixels stay grey, unless they keep an RGB profile; colour ones go to CMYK when the
|
||
// output converts to CMYK.
|
||
let grey = kind != Kind::Color || (neutral(&rgba) && !rgb_icc);
|
||
let (samples, space) = match convert.filter(|_| !grey).and_then(|p| p.cmyk(&rgba)) {
|
||
Some(cmyk) => (cmyk, ImageColorspace::Cmyk),
|
||
None if grey => (rgba.pixels().map(|p| p[0]).collect(), ImageColorspace::Luma),
|
||
None => (rgba.pixels().flat_map(|p| [p[0], p[1], p[2]]).collect(), ImageColorspace::Rgb),
|
||
};
|
||
let icc = icc_for(icc.clone(), space);
|
||
to_jpeg(&samples, space, width, height, q, interpolate, icc.as_deref().map(Vec::as_slice))
|
||
});
|
||
let image = jpeg.or_else(|| from_rgba(rgba.as_raw(), width, height, interpolate, convert, icc));
|
||
let unconverted = image.is_none() && convert.is_some();
|
||
Recoded { image, warning: rule.instead, note, unconverted }
|
||
}
|
||
|
||
/// A colorized image's coverage (one sample a pixel, `w` × `h`, see
|
||
/// [`ImageBlob::coverage`]) placed `size` points wide and high, resampled as the Compression
|
||
/// settings `c` ask for monochrome images (when every sample is 0 or 255) or grayscale ones.
|
||
pub(crate) fn coverage_sized(w: u32, h: u32, cover: Vec<u8>, size: (f64, f64), c: &CompressionSettings) -> Option<(u32, u32, Vec<u8>)> {
|
||
let mono = cover.iter().all(|v| *v == 0 || *v == 255);
|
||
let rule = rule(c, if mono { Kind::Mono } else { Kind::Gray });
|
||
let to = sized(&rule, (w, h), size);
|
||
if to == (w, h) {
|
||
return Some((w, h, cover));
|
||
}
|
||
let img = DynamicImage::ImageLuma8(image::GrayImage::from_raw(w, h, cover)?);
|
||
let mut out = resample(img, &rule, to).into_luma8();
|
||
if mono {
|
||
// Resampling greys the edges: back to covered and not.
|
||
for p in out.pixels_mut() {
|
||
p[0] = if p[0] >= 128 { 255 } else { 0 };
|
||
}
|
||
}
|
||
let (w, h) = out.dimensions();
|
||
Some((w, h, out.into_raw()))
|
||
}
|
||
|
||
/// [`recode`] of CMYK image `blob` ([`ImageBlob::cmyk`]): a JPEG already as asked is kept as it
|
||
/// is when its numbers are (`convert` is `None`); otherwise its ink amounts are resampled,
|
||
/// converted by `convert` and compressed again. With `alpha` (one sample a pixel, see
|
||
/// [`mask_alpha`]) the image is lossless and carries it as its soft mask; `None` then when its
|
||
/// inks can't be read. When its numbers are kept, the image is tagged as `tag` says, and is
|
||
/// untagged without a profile; converted pixels are never tagged with it.
|
||
/// With `convert`, an image whose inks can't be read or written is [`Recoded::unconverted`].
|
||
pub(crate) fn recode_cmyk(
|
||
blob: &ImageBlob,
|
||
size: (f64, f64),
|
||
c: &CompressionSettings,
|
||
interpolate: bool,
|
||
convert: Option<&CmykPixels>,
|
||
alpha: Option<Vec<u8>>,
|
||
tag: CmykTag<'_>,
|
||
) -> Recoded {
|
||
let rule = rule(c, Kind::Color);
|
||
let jpeg = jpeg_components(&blob.bytes).is_some();
|
||
let icc = tag.icc().filter(|_| convert.is_none());
|
||
if jpeg && convert.is_none() && alpha.is_none() {
|
||
let dims = ImageReader::new(Cursor::new(blob.bytes.as_slice())).with_guessed_format().ok().and_then(|r| r.into_dimensions().ok());
|
||
// The JPEG data as it is (without its `ICC_PROFILE` segments with `CmykTag::Removed`: its
|
||
// inks are encoded again when those can't be taken out), tagged with `icc` rather than
|
||
// with its own segments; one larger than [`MAX_EMBED_PIXELS`] is not written.
|
||
if let Some((w, h)) = dims.filter(|d| kept(&rule, *d, size, true))
|
||
&& let Some(data) = jpeg_data(&blob.bytes, tag == CmykTag::Removed)
|
||
{
|
||
let image = (u64::from(w) * u64::from(h) <= MAX_EMBED_PIXELS)
|
||
.then(|| Image::from_jpeg_with_icc(data.into(), icc.map(|i| i.to_vec().into()), interpolate).ok())
|
||
.flatten();
|
||
return Recoded { image, warning: rule.instead, note: None, unconverted: false };
|
||
}
|
||
}
|
||
// Inks that can't be read can't be converted: the image is not to be kept as it is.
|
||
let unconverted = Recoded { image: None, warning: None, note: None, unconverted: true };
|
||
let Some(inks) = blob.cmyk() else {
|
||
if convert.is_some() {
|
||
return unconverted;
|
||
}
|
||
return Recoded { image: None, warning: Some(if jpeg { CMYK_KEPT } else { CMYK_RGB }), note: None, unconverted: false };
|
||
};
|
||
let (width, height) = sized(&rule, (inks.width, inks.height), size);
|
||
let (inks, alpha) = match resampled_inks(inks, alpha, &rule, (width, height)) {
|
||
Ok(r) => r,
|
||
Err(_) if convert.is_some() => return unconverted,
|
||
Err(warning) => return Recoded { image: None, warning, note: None, unconverted: false },
|
||
};
|
||
let (samples, space) = match convert {
|
||
Some(p) => p.convert(&inks),
|
||
None => (inks, ImageColorspace::Cmyk),
|
||
};
|
||
// JPEG needs opaque pixels.
|
||
let image = jpeg_quality(&rule, jpeg).filter(|_| alpha.is_none()).and_then(|q| to_jpeg(&samples, space, width, height, q, interpolate, icc));
|
||
let image = image.or_else(|| lossless(samples, alpha, space, width, height, interpolate, icc));
|
||
let unconverted = image.is_none() && convert.is_some();
|
||
Recoded { image, warning: rule.instead, note: None, unconverted }
|
||
}
|
||
|
||
/// Ink amounts (four bytes a pixel) and their alpha (one byte a pixel), if any.
|
||
type InksAndAlpha = (Vec<u8>, Option<Vec<u8>>);
|
||
|
||
/// Ink amounts `inks` and their `alpha` (one sample a pixel) resampled to `to` as `r` says. The
|
||
/// inks under clear pixels don't count where neighbors blend: they are multiplied by the alpha
|
||
/// before resampling and divided by the resampled alpha after. `Err` with the warning when they
|
||
/// can't be read.
|
||
fn resampled_inks(inks: Inks, alpha: Option<Vec<u8>>, r: &Rule, to: (u32, u32)) -> Result<InksAndAlpha, Option<&'static str>> {
|
||
let dims = (inks.width, inks.height);
|
||
let weighted = to != dims && resampling(r) != Resample::Filter(FilterType::Nearest);
|
||
let mut data = inks.data;
|
||
let alpha = match alpha.map(|a| image::GrayImage::from_raw(dims.0, dims.1, a)) {
|
||
Some(Some(a)) => {
|
||
if weighted {
|
||
premultiply(&mut data, a.as_raw());
|
||
}
|
||
Some(resample(DynamicImage::ImageLuma8(a), r, to).into_luma8().into_raw())
|
||
}
|
||
Some(None) => return Err(None),
|
||
None => None,
|
||
};
|
||
// The four inks resample as the four channels of an RGBA image do, each on its own.
|
||
let img = image::RgbaImage::from_raw(dims.0, dims.1, data).ok_or(Some(CMYK_RGB))?;
|
||
let mut inks = resample_channels(DynamicImage::ImageRgba8(img), r, to).into_rgba8().into_raw();
|
||
if let Some(a) = alpha.as_deref().filter(|_| weighted) {
|
||
unpremultiply(&mut inks, a);
|
||
}
|
||
Ok((inks, alpha))
|
||
}
|
||
|
||
/// The most one image read here may allocate (bytes), as the image reader allows by default.
|
||
const MAX_DECODE: u64 = 512 << 20;
|
||
|
||
/// The decoder limits of an image read here: [`MAX_DECODE`] bytes.
|
||
fn limits() -> image::Limits {
|
||
let mut l = image::Limits::default();
|
||
l.max_alloc = Some(MAX_DECODE);
|
||
l
|
||
}
|
||
|
||
/// `bytes` decoded within [`limits`]: an image whose header asks for more is not decoded.
|
||
fn decoded(bytes: &[u8]) -> Option<DynamicImage> {
|
||
decoded_within(bytes).ok()
|
||
}
|
||
|
||
/// `bytes` decoded like [`decoded`]; on failure, whether the decoder stopped at [`limits`]
|
||
/// (`true`) rather than at data it can't read (`false`).
|
||
fn decoded_within(bytes: &[u8]) -> Result<DynamicImage, bool> {
|
||
let mut r = ImageReader::new(Cursor::new(bytes)).with_guessed_format().map_err(|_| false)?;
|
||
r.limits(limits());
|
||
r.decode().map_err(|e| matches!(e, image::ImageError::Limits(_)))
|
||
}
|
||
|
||
/// The alpha an opacity mask whose art is greyscale image `blob` alone gives the image of
|
||
/// `width` × `height` pixels it covers pixel for pixel: the mask's luminance, over black where the
|
||
/// mask image is transparent when it clips (`clip`), else over white. `None` when `blob` isn't
|
||
/// that many pixels or isn't grey (the luminance of colours is the soft mask's to work out).
|
||
pub(crate) fn mask_alpha(blob: &ImageBlob, width: u32, height: u32, clip: bool) -> Option<Vec<u8>> {
|
||
if blob.is_cmyk() {
|
||
return None;
|
||
}
|
||
// The size from the header first: a mask of another size, or too large to hold as RGBA, is
|
||
// not decoded at all.
|
||
let reader = ImageReader::new(Cursor::new(blob.bytes.as_slice())).with_guessed_format().ok()?;
|
||
if reader.into_dimensions().ok()? != (width, height) || u64::from(width) * u64::from(height) * 4 > MAX_DECODE {
|
||
return None;
|
||
}
|
||
let img = decoded(&blob.bytes)?.into_rgba8();
|
||
if img.dimensions() != (width, height) || !neutral(img.as_raw()) {
|
||
return None;
|
||
}
|
||
let back = if clip { 0 } else { 255 };
|
||
Some(img.pixels().map(|p| ((u32::from(p[0]) * u32::from(p[3]) + back * (255 - u32::from(p[3])) + 127) / 255) as u8).collect())
|
||
}
|
||
|
||
/// Opaque colour `samples` (grey, RGB, or CMYK ink amounts, as `space` says) as a JPEG at
|
||
/// `quality`, tagged with ICC profile `icc` when given. CMYK JPEGs hold Adobe's inverted samples,
|
||
/// which the PDF writer's Decode array undoes.
|
||
fn to_jpeg(samples: &[u8], space: ImageColorspace, width: u32, height: u32, quality: u8, interpolate: bool, icc: Option<&[u8]>) -> Option<Image> {
|
||
let mut out = Vec::new();
|
||
match space {
|
||
ImageColorspace::Cmyk => {
|
||
let (w, h) = (u16::try_from(width).ok()?, u16::try_from(height).ok()?);
|
||
jpeg_encoder::Encoder::new(&mut out, quality).encode(samples, w, h, jpeg_encoder::ColorType::Cmyk).ok()?;
|
||
}
|
||
ImageColorspace::Rgb | ImageColorspace::Luma => {
|
||
let t = if space == ImageColorspace::Rgb { ExtendedColorType::Rgb8 } else { ExtendedColorType::L8 };
|
||
let mut encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut out, quality);
|
||
if let Some(icc) = icc {
|
||
image::ImageEncoder::set_icc_profile(&mut encoder, icc.to_vec()).ok()?;
|
||
}
|
||
encoder.encode(samples, width, height, t).ok()?;
|
||
}
|
||
ImageColorspace::DeviceN => return None,
|
||
}
|
||
Image::from_jpeg_with_icc(out.into(), icc.map(|i| i.to_vec().into()), interpolate).ok()
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
/// The inks of a CMYK image with alpha, resampled, keep the amounts of the opaque pixels: the
|
||
/// inks under the clear pixels beside them don't thin them out.
|
||
#[test]
|
||
fn resampled_inks_keep_the_amounts_beside_clear_pixels() {
|
||
let data = [[40, 80, 120, 160], [0, 0, 0, 0]].repeat(8).concat();
|
||
let alpha = [255, 0].repeat(8);
|
||
for method in ["average", "bicubic"] {
|
||
let c: CompressionSettings = serde_json::from_value(serde_json::json!({"color": {"downsample": method}})).unwrap();
|
||
let inks = Inks::new(16, 1, data.clone()).unwrap();
|
||
let (inks, alpha) = resampled_inks(inks, Some(alpha.clone()), &rule(&c, Kind::Color), (4, 1)).unwrap();
|
||
let alpha = alpha.unwrap();
|
||
let m = |c: u8, a: u8| (u16::from(c) * u16::from(a) / 255) as u8;
|
||
for (p, &a) in inks.as_chunks::<4>().0.iter().zip(&alpha) {
|
||
assert!(a > 0 && p.iter().zip([40, 80, 120, 160]).all(|(&c, want)| m(c, a).abs_diff(m(want, a)) <= 1), "{method}: {p:?} at {a}");
|
||
}
|
||
}
|
||
}
|
||
}
|