engine: keep the image size checks and depth of main through the cutover

Remove Background and Color Mask check the image's size from its header
again before decoding ("an image of W × H pixels is too large to change"),
and Crop Image's trim and Remove Background read a file that can't hold
the pixels its header declares as unreadable, as on main. The test helper
reading Remove Background's output keeps 16-bit samples.

The HEIF and JPEG XL readers and their tests go back to main's (heic-rs and
jxl-oxide): the craft-heif and craft-jxl versions failed eight of their
tests (resolution axes after a quarter turn, the container's mirror and
crop, refusing a grid of cropped tiles, 16-bit samples, the decode
allowance). Moving them stays to do.
This commit is contained in:
FredApps
2026-11-16 03:33:57 +01:00
parent d2b8ebfd95
commit be428f3fcf
10 changed files with 1197 additions and 204 deletions
+10 -1
View File
@@ -41,7 +41,6 @@ craft-tiff = { git = "https://github.com/storytold/craft-libs", rev = "d6cd7836d
craft-psd = { git = "https://github.com/storytold/craft-libs", rev = "d6cd7836d364177661b0ae17f48a0805e83a5f32" }
craft-stream-codecs = { git = "https://github.com/storytold/craft-libs", rev = "d6cd7836d364177661b0ae17f48a0805e83a5f32" }
craft-jxl = { git = "https://github.com/storytold/craft-libs", rev = "d6cd7836d364177661b0ae17f48a0805e83a5f32" }
craft-heif = { git = "https://github.com/storytold/craft-libs", rev = "d6cd7836d364177661b0ae17f48a0805e83a5f32" }
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "e98299546f5c5c3c22388d16507f8b5e61a5f280", features = ["egui"] }
# internal
vectorcraft-geom = { path = "crates/geom" }
@@ -122,6 +121,16 @@ ruzstd = { version = "0.9.1", default-features = false, features = ["std"] }
# craft-stream-codecs' Group 3 rows with (vectorcraft-doc's and vectorcraft-engine's dev-dependencies).
tiff = "0.11"
zune-jpeg = "0.5"
# JPEG XL decoder (pure Rust, MIT OR Apache-2.0): File › Open and Place read `.jxl` images. It is
# built without its default `rayon` feature and decodes on one thread.
jxl-oxide = { version = "0.12.6", default-features = false }
# jxl-oxide's color conversions, run on colors after their alpha is divided out.
jxl-color = "0.11.0"
# jxl-oxide's buffer allocation error, told apart from other decoding errors.
jxl-grid = "0.6.2"
# Tests: a lossless JPEG XL encoder (pure Rust, MIT OR Apache-2.0 OR Zlib) for the `.jxl` test files.
zune-jpegxl = { version = "0.5.2", default-features = false, features = ["std"] }
zune-core = "0.5"
hayro-ccitt = "0.3"
jpeg-encoder = { version = "0.6", default-features = false, features = ["std"] }
# Substring search for the EPS reader's PostScript `search`.
+16 -3
View File
@@ -16,7 +16,7 @@ bundled-fonts = ["vectorcraft-text/bundled-fonts"]
# HEIC and HEIF images open and place, decoded by heic-rs (an HEVC decoder). A build without this
# feature still recognizes the files and refuses them with a message. The apps list it beside
# `bundled-fonts`.
heif = ["dep:craft-heif"]
heif = ["dep:heic-rs", "dep:rayon"]
[dependencies]
# Which paths stored in documents may be opened.
@@ -45,8 +45,11 @@ vectorcraft-js = { workspace = true }
vectorcraft-apischema = { workspace = true }
image = { workspace = true }
craft-image-codecs = { workspace = true }
craft-jxl = { workspace = true }
craft-heif = { workspace = true, optional = true }
jxl-oxide = { workspace = true }
jxl-color = { workspace = true }
jxl-grid = { workspace = true }
# Pure Rust, no unsafe; pinned at the version photocraft-heif uses.
heic-rs = { version = "=0.1.4", default-features = false, features = ["std"], optional = true }
flate2 = { workspace = true }
chrono = { workspace = true }
# The XML parts of Word documents placed as type (place/docx.rs).
@@ -69,7 +72,17 @@ rustix = { workspace = true, features = ["std", "process"] }
[target.'cfg(windows)'.dependencies]
same-file = "1.0.6"
# The tiles of a HEIC photo decode in parallel on native; wasm stays single-threaded.
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
heic-rs = { version = "=0.1.4", default-features = false, features = ["std", "parallel"], optional = true }
rayon = { version = "1.12", optional = true }
[dev-dependencies]
# JPEG XL files for the `.jxl` open and place tests.
zune-jpegxl = { workspace = true }
zune-core = { workspace = true }
# JPEG XL files for the import fuzz tests (tests/import_fuzz.rs).
craft-jxl = { workspace = true }
# vectorcraft-doc's Group 3 TIFF reader before craft-stream-codecs, the reference
# tests/group3_reference.rs compares it with.
hayro-ccitt = { workspace = true }
+34 -2
View File
@@ -448,14 +448,46 @@ pub(crate) fn clear(blob: &ImageBlob, settings: &Settings, mut kept: Option<&mut
Ok(Some(Cleared { blob: ImageBlob::png(png), width: w, height: h, cleared }))
}
/// The image's size and the bytes a pixel of it takes to change, read from its header: its
/// samples as decoded (bitmaps as 8-bit gray, palettes as RGB, or RGBA with a transparent entry),
/// those worked on and kept for the PNG, and the work. A header that gives only the size (one
/// whose file can't hold its pixels) counts the fewest: one 8-bit sample. `None` when the header
/// doesn't say.
fn header_pixels(bytes: &[u8]) -> Option<(u32, u32, u64)> {
use craft_image_codecs::RasterColorType as T;
let Some(i) = craft_image_codecs::inspect_raster(bytes).ok().flatten() else {
return vectorcraft_doc::header_size(bytes).map(|(w, h)| (w, h, 1 + 2 * 4 + WORK_BYTES));
};
let deep = i.bits_per_sample > 8 && i.color_type != T::Indexed;
let channels = match i.color_type {
T::Indexed => 3 + u64::from(i.transparent_index.is_some()),
T::Bitmap => 1,
_ => u64::from(i.channels.max(1)),
};
let samples = channels * if deep { 2 } else { 1 };
Some((i.width, i.height, samples + 2 * if deep { 8 } else { 4 } + WORK_BYTES))
}
/// `blob`'s pixels as straight RGBA, whether they were gray, and its ICC profile. An image that
/// can't be decoded or is too large to change is an error. The pixels are kept in `kept`, when it
/// is given, if a copy of them fits the decode allowance beside the work. Errors are command `cmd`'s.
fn decode(blob: &ImageBlob, kept: Option<&mut DecodedImages>, cmd: &str) -> Result<(Arc<Pixels>, bool, Option<Vec<u8>>)> {
// The file's pixels, those worked on (as many again for the PNG made of them) and the work,
// checked from the header before anything is decoded.
let too_large = |w: u32, h: u32, per_pixel: u64| {
u64::from(w).checked_mul(u64::from(h)).and_then(|n| n.checked_mul(per_pixel)).is_none_or(|n| n > MAX_RASTER_ALLOC)
};
let header = header_pixels(&blob.bytes);
if let Some((w, h, per_pixel)) = header
&& too_large(w, h, per_pixel)
{
return Err(bad(cmd, format!("an image of {w} × {h} pixels is too large to change")));
}
let mut opts = craft_image_codecs::DecodeOptions::default();
opts.limits.max_alloc = MAX_RASTER_ALLOC;
let img = craft_image_codecs::decode_with(&blob.bytes, &opts).map_err(|e| match e {
craft_image_codecs::CodecError::LimitExceeded(_) => bad(cmd, "the image is too large to change"),
// Within the allowance from its header: a file that can't hold the pixels it declares.
craft_image_codecs::CodecError::LimitExceeded(_) if header.is_none() => bad(cmd, "the image is too large to change"),
_ => bad(cmd, format!("the image's pixels can't be read: {e}")),
})?;
let (w, h) = img.dimensions();
@@ -463,7 +495,7 @@ fn decode(blob: &ImageBlob, kept: Option<&mut DecodedImages>, cmd: &str) -> Resu
let deep = img.sample_type() == craft_image_codecs::SampleType::U16;
let gray = matches!(img.layout(), craft_image_codecs::ChannelLayout::Gray | craft_image_codecs::ChannelLayout::GrayA);
let per_pixel = u64::from(img.layout().channels() as u32 * img.sample_type().bytes() as u32) + 2 * if deep { 8 } else { 4 } + WORK_BYTES;
if u64::from(w).checked_mul(u64::from(h)).and_then(|n| n.checked_mul(per_pixel)).is_none_or(|n| n > MAX_RASTER_ALLOC) {
if too_large(w, h, per_pixel) {
return Err(bad(cmd, format!("an image of {w} × {h} pixels is too large to change")));
}
#[cfg(test)]
@@ -99,6 +99,15 @@ fn pixels(s: &Session, id: NodeId) -> DynamicImage {
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(layout, craft_image_codecs::SampleType::U16) => {
let v = __cimg.to_u16_samples().unwrap();
match layout {
craft_image_codecs::ChannelLayout::Gray => image::DynamicImage::ImageLuma16(ImageBuffer::from_raw(__w, __h, v).unwrap()),
craft_image_codecs::ChannelLayout::GrayA => image::DynamicImage::ImageLumaA16(ImageBuffer::from_raw(__w, __h, v).unwrap()),
craft_image_codecs::ChannelLayout::Rgb => image::DynamicImage::ImageRgb16(ImageBuffer::from_raw(__w, __h, v).unwrap()),
_ => image::DynamicImage::ImageRgba16(ImageBuffer::from_raw(__w, __h, v).unwrap()),
}
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
+563 -51
View File
@@ -1,18 +1,20 @@
//! HEIC and HEIF images for File › Open and File › Place, decoded with `craft-heif` when the
//! engine's `heif` feature is on (the default). The image is bounded before decoding and converted
//! to RGBA for the common PNG storage path. A build without the feature still recognizes the files
//! and refuses them with a message.
//! HEIC and HEIF images for File › Open and File › Place, decoded with heic-rs when the engine's
//! `heif` feature is on (the default). The image is bounded before decoding and converted to RGBA
//! for the common PNG storage path. A build without the feature still recognizes the files and
//! refuses them with a message.
#[cfg(all(test, feature = "heif"))]
pub(super) use decoder::{active_sps, picture_bytes, sps_signal, sps_size};
#[cfg(feature = "heif")]
pub(super) use decoder::{decode, quarter_turned, with_exif};
/// The brands `craft-heif` reads: HEVC-coded images and image sequences (ISO/IEC 23008-12 annex
/// The brands heic-rs 0.1.4 reads: HEVC-coded images and image sequences (ISO/IEC 23008-12 annex
/// B) and the general image and sequence brands.
const BRANDS: [&[u8; 4]; 7] = [b"heic", b"heix", b"heim", b"heis", b"hevc", b"mif1", b"msf1"];
/// Recognize a HEIF file by its `ftyp` box: one of [`BRANDS`] as the major brand or a compatible
/// one, and no AVIF brand (`avif`, `avis`). The box is read as JP2 boxes are
/// ([`super::jp2read::boxes`]): ISO BMFF sizes, the 64-bit one included.
/// one, and no AVIF brand (`avif`, `avis`), as heic-rs refuses a file that lists one. The box is
/// read as JP2 boxes are ([`super::jp2read::boxes`]): ISO BMFF sizes, the 64-bit one included.
pub(super) fn is_heif(bytes: &[u8]) -> bool {
let Some((b"ftyp", ftyp)) = super::jp2read::boxes(bytes).next() else { return false };
let Some(major) = ftyp.get(..4).and_then(|b| <&[u8; 4]>::try_from(b).ok()) else { return false };
@@ -44,72 +46,582 @@ pub(super) fn with_exif<T>(_bytes: &[u8], _read: impl FnOnce(&[u8]) -> Option<T>
#[cfg(feature = "heif")]
mod decoder {
use craft_heif::{Colour, Error, Options};
use heic_rs::context::Context;
use heic_rs::{DecodeOptions, Error, MatrixCoefficients, Nclx, PixelLayout, Range};
/// The message for a file that isn't a readable HEIF image.
const UNREADABLE: &str = "the HEIC or HEIF file can't be read";
/// The message for an image kind that `craft-heif` does not handle.
/// The message for an image sequence, an overlay, an image that isn't HEVC-coded, a grid whose
/// tiles are cropped, turned or mirrored, or an HEVC coding tool the decoder doesn't implement.
const UNSUPPORTED: &str = "the HEIC or HEIF file holds a kind of image that can't be read";
/// Decode the primary image within `max_alloc` bytes, with the container's rotation, mirror,
/// Decode the primary image within `max_alloc` bytes, counting the decoder's planes, the RGBA
/// output and the copy that rotating or cropping makes, with the container's rotation, mirror
/// and crop applied. An embedded RGB ICC profile, or `nclx` Display P3 primaries with the sRGB
/// curve, is converted to sRGB; other `nclx` values are read as sRGB.
/// curve, is converted to sRGB; other `nclx` values are read as sRGB. A panic inside the
/// decoder is reported as an unreadable file.
pub(in super::super) fn decode(bytes: &[u8], max_alloc: u64) -> Result<image::RgbaImage, String> {
let refused = |e: Error| match e {
Error::Unsupported(_) => UNSUPPORTED.to_string(),
_ => UNREADABLE.to_string(),
};
let info = craft_heif::probe(bytes).map_err(refused)?;
let too_large = || format!("an image of {} × {} pixels is too large to draw", info.coded_width, info.coded_height);
let coded = u64::from(info.coded_width).checked_mul(u64::from(info.coded_height)).ok_or_else(too_large)?;
let shown = u64::from(info.width).checked_mul(u64::from(info.height)).ok_or_else(too_large)?;
if coded == 0 || shown == 0 || coded.checked_mul(17).is_none_or(|n| n > max_alloc) {
return Err(too_large());
}
let decoded = craft_heif::decode(bytes, &Options { max_pixels: max_alloc / 17, ..Options::default() }).map_err(|e| match e {
Error::Limit(_) => too_large(),
e => refused(e),
})?;
let channels = if decoded.has_alpha { 4usize } else { 3usize };
let profile = source_profile(decoded.icc.as_deref(), decoded.colour);
let to_u8 = |s: u16| ((u32::from(s) * 255 + 32767) / 65535) as u8;
let mut rgba = Vec::with_capacity(decoded.width as usize * decoded.height as usize * 4);
for px in decoded.data.chunks_exact(channels) {
let a = if decoded.has_alpha { to_u8(px[3]) } else { 255 };
let [r, g, b] = if let Some(profile) = profile.as_ref() {
let device = [px[0], px[1], px[2]].map(|v| f32::from(v) / 65535.0);
profile
.to_srgb_into(&device, vectorcraft_color::cms::Intent::RelativeColorimetric)
.map(|rgb| rgb.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8))
.unwrap_or_else(|| [to_u8(px[0]), to_u8(px[1]), to_u8(px[2])])
} else {
[to_u8(px[0]), to_u8(px[1]), to_u8(px[2])]
};
rgba.extend_from_slice(&[r, g, b, a]);
}
image::RgbaImage::from_raw(decoded.width, decoded.height, rgba).ok_or_else(|| UNREADABLE.into())
crate::guard::catch_panic(|| decode_unguarded(bytes, max_alloc)).unwrap_or_else(|_| Err(UNREADABLE.into()))
}
/// Whether the container's transforms swap width and height.
/// Whether the container's rotations of the primary image add up to an odd number of quarter
/// turns, so its width and height swap. The decoder applies every `irot` the item lists.
pub(in super::super) fn quarter_turned(bytes: &[u8]) -> bool {
craft_heif::probe(bytes).ok().is_some_and(|i| (i.width > i.height) != (i.coded_width > i.coded_height))
let turned = || {
let ctx = Context::open(bytes).ok()?;
let props = ctx.props(ctx.meta.primary).ok()?;
let quarters = props.transforms.iter().filter(|t| matches!(t, heic_rs::props::Transform::Rotate(r) if r.swaps_axes())).count();
Some(quarters % 2 == 1)
};
crate::guard::catch_panic(turned).ok().flatten().unwrap_or(false)
}
/// `read` of the primary image's EXIF block, a TIFF structure inside `bytes`, for its
/// resolution tags.
pub(in super::super) fn with_exif<T>(bytes: &[u8], read: impl FnOnce(&[u8]) -> Option<T>) -> Option<T> {
let (exif, _) = craft_heif::read_metadata(bytes).ok()?;
exif.as_deref().and_then(read)
let find = || {
let ctx = Context::open(bytes).ok()?;
ctx.exif(ctx.meta.primary).ok().flatten()
};
crate::guard::catch_panic(find).ok().flatten().and_then(read)
}
fn decode_unguarded(bytes: &[u8], max_alloc: u64) -> Result<image::RgbaImage, String> {
let refused = |e: Error| match e {
Error::Unsupported(_) | Error::MissingBox("hvcC" | "meta") => UNSUPPORTED.to_string(),
_ => UNREADABLE.to_string(),
};
let info = heic_rs::probe(bytes).map_err(refused)?;
let ctx = Context::open(bytes).map_err(refused)?;
if unsupported_items(&ctx).ok_or(UNREADABLE)? {
return Err(UNSUPPORTED.into());
}
// The stored size, before a crop: the size the decoder holds.
let too_large = || format!("an image of {} × {} pixels is too large to draw", info.coded_width, info.coded_height);
let declared = u64::from(info.coded_width).checked_mul(u64::from(info.coded_height)).ok_or_else(too_large)?;
// A grid is composed at the size its own data gives, which need not match `ispe`.
let grid = grid_pixels(&ctx).ok_or(UNREADABLE)?;
// A single picture is converted at the size its stream gives, which need not match `ispe`
// either.
let coded = declared.max(grid).max(stream_pixels(&ctx).ok_or(UNREADABLE)?);
let shown = u64::from(info.width).checked_mul(u64::from(info.height)).ok_or_else(too_large)?;
// The RGBA output, and a second RGBA image when the decoder rotates, mirrors or crops it,
// which is no larger than the first.
let output = coded.checked_mul(8).ok_or_else(too_large)?;
let pictures = picture_bytes_in(&ctx).ok_or(UNREADABLE)?;
// An alpha grid is composed into a frame of 16-bit planes (at most three samples a pixel),
// and so is the image's grid when it is decoded with a color description of its tiles or
// its stream. A single picture is converted in place.
let composed = if grid > 0 { coded.checked_mul(if info.has_alpha { 12 } else { 6 }).ok_or_else(too_large)? } else { 0 };
if coded == 0 || shown == 0 || output.checked_add(pictures).and_then(|n| n.checked_add(composed)).is_none_or(|n| n > max_alloc) {
return Err(too_large());
}
let max_pixels = max_alloc / 4;
let decoded = match tile_nclx(&ctx).or_else(|| stream_nclx(&ctx)) {
Some(nclx) => decode_with_nclx(&ctx, nclx, max_pixels),
None => heic_rs::decode(bytes, &DecodeOptions::default().with_layout(PixelLayout::Rgba8).with_max_pixels(Some(max_pixels))),
}
.map_err(|e| match e {
Error::PixelLimit { .. } | Error::BoxTooLarge { .. } => too_large(),
e => refused(e),
})?;
let mut img = image::RgbaImage::from_raw(decoded.width, decoded.height, decoded.data).ok_or(UNREADABLE)?;
if let Some(profile) = source_profile(&ctx) {
for pixel in img.pixels_mut() {
let [r, g, b, a] = pixel.0;
let device = [r, g, b].map(|v| f32::from(v) / 255.0);
if let Some(rgb) = profile.to_srgb_into(&device, vectorcraft_color::cms::Intent::RelativeColorimetric) {
let [r, g, b] = rgb.map(|v| (v * 255.0).round() as u8);
pixel.0 = [r, g, b, a];
}
}
}
Ok(img)
}
/// The primary image and its alpha image, when it has one.
fn primary_and_alpha(ctx: &Context<'_>) -> Option<impl Iterator<Item = u32>> {
let primary = ctx.meta.primary;
Some(std::iter::once(primary).chain(ctx.alpha_item(primary).ok()?))
}
/// Whether the primary image or its alpha image is neither an HEVC-coded item (`hvc1`, `hev1`)
/// nor a grid of them, or is a grid with a tile that carries a crop, rotation or mirror. heic-rs
/// 0.1.4 decodes any item with an `hvcC` whatever its type, and composes a grid from its tiles
/// as coded, without their transforms: an encoder that pads tiles smaller than its coding block
/// (64 × 64 for x265) and crops them back with `clap` gets the wrong pixels.
fn unsupported_items(ctx: &Context<'_>) -> Option<bool> {
let hevc = |id: u32| ctx.meta.item(id).is_some_and(|info| info.is_hevc());
for item in primary_and_alpha(ctx)? {
let Some((_, tiles)) = ctx.grid(item).ok()? else {
if !hevc(item) {
return Some(true);
}
continue;
};
for tile in tiles {
if !hevc(tile) || !ctx.props(tile).ok()?.transforms.is_empty() {
return Some(true);
}
}
}
Some(false)
}
/// The pixels of the larger of the primary image's grid and its alpha image's grid, at the
/// output size each grid gives; 0 when neither is a grid.
fn grid_pixels(ctx: &Context<'_>) -> Option<u64> {
let mut largest = 0u64;
for item in primary_and_alpha(ctx)? {
if let Some((grid, _)) = ctx.grid(item).ok()? {
largest = largest.max(u64::from(grid.output_width) * u64::from(grid.output_height));
}
}
Some(largest)
}
/// The pixels of the larger of the primary image and its alpha image when either is a single
/// picture, at the size of its largest sequence parameter set (before its conformance window);
/// 0 when both are grids. `None` when a size can't be read.
fn stream_pixels(ctx: &Context<'_>) -> Option<u64> {
let mut largest = 0u64;
for item in primary_and_alpha(ctx)? {
if ctx.grid(item).ok()?.is_some() {
continue;
}
// An item without `hvcC` isn't decoded: heic-rs refuses the file.
let Some(hvcc) = ctx.props(item).ok()?.hvcc else { continue };
for nal in hvcc.parameter_sets().into_iter().filter(|nal| nal_type(nal) == Some(SPS)) {
let (width, height, _) = sps_size(nal)?;
largest = largest.max(width.checked_mul(height)?);
}
}
Some(largest)
}
/// The first tile's `nclx` when the primary image is a grid without an `nclx` of its own and
/// its tiles carry one. heic-rs 0.1.4 converts a grid's samples to RGB with the grid item's
/// `nclx` alone, and with its BT.709 limited-range default when the grid has none
/// (tbraun96/heic-rs#6).
fn tile_nclx(ctx: &Context<'_>) -> Option<Nclx> {
let primary = ctx.meta.primary;
if ctx.props(primary).ok()?.nclx.is_some() {
return None;
}
let (_, tiles) = ctx.grid(primary).ok()??;
ctx.props(*tiles.first()?).ok()?.nclx
}
/// The color description in the HEVC stream's video usability information (ITU-T H.265
/// E.2.1) of the primary image, or of its grid's first tile, when neither carries an `nclx`
/// (a file whose only color box is an ICC profile, or one without a color box). heic-rs 0.1.4
/// reads only the container's `nclx` and otherwise converts with BT.709 limited range.
fn stream_nclx(ctx: &Context<'_>) -> Option<Nclx> {
let primary = ctx.meta.primary;
if ctx.props(primary).ok()?.nclx.is_some() {
return None;
}
let coded = match ctx.grid(primary).ok()? {
Some((_, tiles)) => *tiles.first()?,
None => primary,
};
let props = ctx.props(coded).ok()?;
if props.nclx.is_some() {
return None;
}
let hvcc = props.hvcc?;
let data = ctx.item_data(coded).ok()?;
let slices = hvcc.split_nals(&data).ok()?;
active_sps(&hvcc.parameter_sets(), &slices).and_then(sps_signal)
}
/// The SPS the first slice of `slices` uses: the one its PPS names (ITU-T H.265 7.4.3.3.1).
pub(in super::super) fn active_sps<'a>(parameter_sets: &[&'a [u8]], slices: &[&[u8]]) -> Option<&'a [u8]> {
let slice = slices.iter().find(|nal| nal_type(nal).is_some_and(|t| t < 32))?;
let bits = &mut Bits { data: &payload(slice), at: 0 };
// first_slice_segment_in_pic_flag, no_output_of_prior_pics_flag in an IRAP picture (types 16
// to 23), slice_pic_parameter_set_id.
bits.skip(1)?;
if nal_type(slice).is_some_and(|t| (16..=23).contains(&t)) {
bits.skip(1)?;
}
let pps_id = bits.exp_golomb()?;
// pps_pic_parameter_set_id, pps_seq_parameter_set_id.
let pps_ids = |nal: &[u8]| {
let bits = &mut Bits { data: &payload(nal), at: 0 };
Some((bits.exp_golomb()?, bits.exp_golomb()?))
};
let sps_id = parameter_sets.iter().filter(|nal| nal_type(nal) == Some(PPS)).find_map(|nal| pps_ids(nal).filter(|(id, _)| *id == pps_id))?.1;
let sps_ids = |nal: &[u8]| {
let rbsp = sps_payload(nal)?;
sps_head(&mut Bits { data: &rbsp, at: 0 }).map(|(_, id, ..)| id)
};
parameter_sets.iter().copied().find(|nal| sps_ids(nal) == Some(sps_id))
}
/// The primary image decoded as heic-rs 0.1.4 decodes it (a grid's tiles one after another),
/// with its samples converted to RGBA with `nclx`, the alpha image applied and the image's
/// rotation, mirror and crop applied.
fn decode_with_nclx(ctx: &Context<'_>, nclx: Nclx, max_pixels: u64) -> heic_rs::Result<heic_rs::Image> {
use heic_rs::hevc::Frame;
fn coded(ctx: &Context<'_>, id: u32) -> heic_rs::Result<Frame> {
let props = ctx.props(id)?;
let hvcc = props.hvcc.as_ref().ok_or(Error::MissingBox("hvcC"))?;
let data = ctx.item_data(id)?;
let frame = heic_rs::hevc::decode_still(&hvcc.parameter_sets(), &hvcc.split_nals(&data)?)?;
frame.validate()?;
Ok(frame)
}
fn item(ctx: &Context<'_>, id: u32, max_pixels: u64) -> heic_rs::Result<Frame> {
match ctx.grid(id)? {
Some((grid, tiles)) => {
// The tiles decode in parallel on native, as heic-rs's own decode does.
#[cfg(not(target_arch = "wasm32"))]
let frames = {
use rayon::prelude::*;
tiles.par_iter().map(|&t| coded(ctx, t)).collect::<heic_rs::Result<Vec<_>>>()?
};
#[cfg(target_arch = "wasm32")]
let frames = tiles.iter().map(|&t| coded(ctx, t)).collect::<heic_rs::Result<Vec<_>>>()?;
heic_rs::grid::compose(&grid, &frames, max_pixels)
}
None => coded(ctx, id),
}
}
let primary = ctx.meta.primary;
let props = ctx.props(primary)?;
let frame = item(ctx, primary, max_pixels)?;
let alpha = ctx.alpha_item(primary)?.map(|a| item(ctx, a, max_pixels)).transpose()?;
// `None`: rayon's global pool on native, where heic-rs is built with `parallel`.
let image = heic_rs::color::convert(&frame, alpha.as_ref(), nclx, PixelLayout::Rgba8, max_pixels, None)?;
heic_rs::transform::apply_all(image, &props.transforms)
}
/// The bytes heic-rs 0.1.4 allocates for the coded pictures of `bytes` it decodes (see
/// [`picture_bytes_in`]); `None` when they can't be read.
#[cfg(test)]
pub(in super::super) fn picture_bytes(bytes: &[u8]) -> Option<u64> {
picture_bytes_in(&Context::open(bytes).ok()?)
}
/// The bytes heic-rs 0.1.4 allocates for the coded pictures it decodes: the primary image's,
/// or each tile of its grid, and its alpha image's the same way. Each picture is sized by the
/// largest of its sequence parameter sets (the size the decoder allocates, rounded up to whole
/// 64-sample coding blocks), not by the container, and takes three sets of 16-bit planes: the
/// picture, a filtered copy and the frame returned. `None` when an item's sizes can't be read.
fn picture_bytes_in(ctx: &Context<'_>) -> Option<u64> {
let mut total = 0u64;
for item in primary_and_alpha(ctx)? {
let coded = match ctx.grid(item).ok()? {
Some((_, tiles)) => tiles,
None => vec![item],
};
for id in coded {
let props = ctx.props(id).ok()?;
// An item without `hvcC` isn't decoded: heic-rs refuses the file.
let Some(hvcc) = props.hvcc else { continue };
// The slices pick their SPS through the PPS, so the largest one is counted. Every
// SPS must be read.
let mut largest = None;
for nal in hvcc.parameter_sets().into_iter().filter(|nal| nal_type(nal) == Some(SPS)) {
let (width, height, chroma) = sps_size(nal)?;
let blocks = |n: u64| n.div_ceil(64) * 64;
// Bytes a sample position takes in one set of planes: luma and the two chroma
// planes.
let planes = match chroma {
0 => 2,
1 => 3,
2 => 4,
_ => 6,
};
let picture = blocks(width).checked_mul(blocks(height))?.checked_mul(planes * 3)?;
largest = largest.max(Some(picture));
}
total = total.checked_add(largest?)?;
}
}
Some(total)
}
/// The NAL unit type of an HEVC sequence parameter set.
const SPS: u8 = 33;
/// The type of an HEVC NAL unit, from its header.
fn nal_type(nal: &[u8]) -> Option<u8> {
nal.first().map(|b| (b >> 1) & 0x3f)
}
/// The NAL unit type of an HEVC picture parameter set.
const PPS: u8 = 34;
/// A NAL unit's payload, without its two-byte header and the emulation prevention bytes (the 03
/// of 00 00 03), up to its first 4,096 bytes.
fn payload(nal: &[u8]) -> Vec<u8> {
let mut rbsp = Vec::with_capacity(256);
let mut zeros = 0;
for &b in nal.get(2..).unwrap_or_default().iter().take(4096) {
if b == 3 && zeros >= 2 {
zeros = 0;
continue;
}
zeros = if b == 0 { zeros + 1 } else { 0 };
rbsp.push(b);
}
rbsp
}
/// An SPS NAL unit's [`payload`]; `None` for another NAL unit.
fn sps_payload(nal: &[u8]) -> Option<Vec<u8>> {
(nal_type(nal) == Some(SPS)).then(|| payload(nal))
}
/// The fields of an SPS (ITU-T H.265 7.3.2.2) up to the picture height:
/// `sps_max_sub_layers_minus1`, `sps_seq_parameter_set_id`, the width, the height and
/// `chroma_format_idc`.
fn sps_head(bits: &mut Bits<'_>) -> Option<(u64, u64, u64, u64, u64)> {
// sps_video_parameter_set_id, sps_max_sub_layers_minus1, sps_temporal_id_nesting_flag.
bits.skip(4)?;
let sub_layers = bits.read(3)?;
bits.skip(1)?;
// profile_tier_level (7.3.3): the general profile, tier and level, then the sub-layers'.
bits.skip(96)?;
let mut present = Vec::new();
for _ in 0..sub_layers {
present.push((bits.read(1)?, bits.read(1)?));
}
if sub_layers > 0 {
bits.skip(2 * (8 - sub_layers as usize))?;
}
for (profile, level) in present {
bits.skip(88 * profile as usize + 8 * level as usize)?;
}
let id = bits.exp_golomb()?;
let chroma = bits.exp_golomb()?;
if chroma == 3 {
bits.skip(1)?;
}
let width = bits.exp_golomb()?;
let height = bits.exp_golomb()?;
Some((sub_layers, id, width, height, chroma))
}
/// The picture width, height and `chroma_format_idc` of an HEVC sequence parameter set NAL
/// unit, before its conformance window; `None` for another NAL unit.
pub(in super::super) fn sps_size(nal: &[u8]) -> Option<(u64, u64, u64)> {
let rbsp = sps_payload(nal)?;
let (_, _, width, height, chroma) = sps_head(&mut Bits { data: &rbsp, at: 0 })?;
Some((width, height, chroma))
}
/// The video signal type of an HEVC sequence parameter set NAL unit's VUI (ITU-T H.265 E.2.1)
/// as an `nclx`: the full-range flag and, when the VUI describes them, the color primaries,
/// transfer characteristics and matrix coefficients (otherwise 2, unspecified). `None` when the
/// SPS has no VUI, the VUI has no video signal type, or the SPS can't be read that far.
pub(in super::super) fn sps_signal(nal: &[u8]) -> Option<Nclx> {
let rbsp = sps_payload(nal)?;
let bits = &mut Bits { data: &rbsp, at: 0 };
let (sub_layers, ..) = sps_head(bits)?;
skip_to_vui(bits, sub_layers)?;
// vui_parameters_present_flag, then aspect_ratio_info_present_flag (an Extended_SAR
// aspect_ratio_idc of 255 adds its 32-bit ratio) and overscan_info_present_flag.
if bits.read(1)? == 0 {
return None;
}
if bits.read(1)? == 1 && bits.read(8)? == 255 {
bits.skip(32)?;
}
if bits.read(1)? == 1 {
bits.skip(1)?;
}
// video_signal_type_present_flag: video_format, video_full_range_flag and the color
// description.
if bits.read(1)? == 0 {
return None;
}
bits.skip(3)?;
let range = if bits.read(1)? == 1 { Range::Full } else { Range::Limited };
let (primaries, transfer, matrix) = if bits.read(1)? == 1 { (bits.read(8)?, bits.read(8)?, bits.read(8)?) } else { (2, 2, 2) };
let code = |v: u64| u16::try_from(v).ok();
let matrix_code = code(matrix)?;
Some(Nclx { primaries: code(primaries)?, transfer: code(transfer)?, matrix: MatrixCoefficients::from_code(matrix_code), matrix_code, range })
}
/// Skips the fields of an SPS after [`sps_head`], up to `vui_parameters_present_flag`.
fn skip_to_vui(bits: &mut Bits<'_>, sub_layers: u64) -> Option<()> {
// conformance_window_flag and its four offsets.
if bits.read(1)? == 1 {
for _ in 0..4 {
bits.exp_golomb()?;
}
}
// bit_depth_luma_minus8, bit_depth_chroma_minus8.
bits.exp_golomb()?;
bits.exp_golomb()?;
let poc_bits = bits.exp_golomb()?.checked_add(4).filter(|&n| n <= 16)?;
// sps_sub_layer_ordering_info_present_flag, then three values for each sub-layer given.
let ordered = if bits.read(1)? == 1 { sub_layers + 1 } else { 1 };
for _ in 0..ordered * 3 {
bits.exp_golomb()?;
}
// The coding and transform block sizes and the transform hierarchy depths.
for _ in 0..6 {
bits.exp_golomb()?;
}
// scaling_list_enabled_flag, sps_scaling_list_data_present_flag.
if bits.read(1)? == 1 && bits.read(1)? == 1 {
skip_scaling_lists(bits)?;
}
// amp_enabled_flag, sample_adaptive_offset_enabled_flag.
bits.skip(2)?;
// pcm_enabled_flag: the PCM sample depths, block sizes and loop filter flag.
if bits.read(1)? == 1 {
bits.skip(8)?;
bits.exp_golomb()?;
bits.exp_golomb()?;
bits.skip(1)?;
}
skip_reference_picture_sets(bits)?;
// long_term_ref_pics_present_flag: each picture's POC bits and used flag.
if bits.read(1)? == 1 {
let count = bits.exp_golomb()?;
if count > 32 {
return None;
}
for _ in 0..count {
bits.skip(poc_bits as usize + 1)?;
}
}
// sps_temporal_mvp_enabled_flag, strong_intra_smoothing_enabled_flag.
bits.skip(2)
}
/// Skips `scaling_list_data()` (ITU-T H.265 7.3.4).
fn skip_scaling_lists(bits: &mut Bits<'_>) -> Option<()> {
for size in 0..4 {
// The 32 × 32 lists are given for matrices 0 and 3 only.
for _ in 0..if size == 3 { 2 } else { 6 } {
if bits.read(1)? == 0 {
// scaling_list_pred_matrix_id_delta.
bits.exp_golomb()?;
} else {
// scaling_list_dc_coef_minus8, then each scaling_list_delta_coef (se(v) codes,
// as long as ue(v) codes).
if size > 1 {
bits.exp_golomb()?;
}
for _ in 0..if size == 0 { 16 } else { 64 } {
bits.exp_golomb()?;
}
}
}
}
Some(())
}
/// Skips `num_short_term_ref_pic_sets` and each `st_ref_pic_set()` (ITU-T H.265 7.3.7) of an
/// SPS. A set predicted from the one before it has one or two flags for each of that set's
/// pictures and one more.
fn skip_reference_picture_sets(bits: &mut Bits<'_>) -> Option<()> {
let sets = bits.exp_golomb()?;
if sets > 64 {
return None;
}
// NumDeltaPocs of each set read so far.
let mut pictures: Vec<u64> = Vec::new();
for index in 0..sets {
let predicted = index != 0 && bits.read(1)? == 1;
let count = if predicted {
// delta_rps_sign, abs_delta_rps_minus1.
bits.skip(1)?;
bits.exp_golomb()?;
let mut count = 0;
for _ in 0..=*pictures.last()? {
// used_by_curr_pic_flag, and use_delta_flag when it is 0.
if bits.read(1)? == 1 || bits.read(1)? == 1 {
count += 1;
}
}
count
} else {
let (negative, positive) = (bits.exp_golomb()?, bits.exp_golomb()?);
if negative > 16 || positive > 16 {
return None;
}
// Each picture's delta_poc_s0_minus1 or delta_poc_s1_minus1 and its used flag.
for _ in 0..negative + positive {
bits.exp_golomb()?;
bits.skip(1)?;
}
negative + positive
};
pictures.push(count);
}
Some(())
}
/// A big-endian bit reader over an RBSP.
struct Bits<'a> {
data: &'a [u8],
at: usize,
}
impl Bits<'_> {
fn bit(&mut self) -> Option<u64> {
let byte = self.data.get(self.at / 8)?;
let bit = (byte >> (7 - self.at % 8)) & 1;
self.at += 1;
Some(u64::from(bit))
}
fn read(&mut self, n: u32) -> Option<u64> {
(0..n).try_fold(0u64, |v, _| Some(v << 1 | self.bit()?))
}
fn skip(&mut self, n: usize) -> Option<()> {
self.at = self.at.checked_add(n)?;
(self.at <= self.data.len() * 8).then_some(())
}
/// An unsigned Exp-Golomb code, ue(v), of at most 32 leading zeros.
fn exp_golomb(&mut self) -> Option<u64> {
let mut zeros = 0;
while self.bit()? == 0 {
zeros += 1;
if zeros > 32 {
return None;
}
}
Some((1u64 << zeros) - 1 + self.read(zeros)?)
}
}
/// `nclx` color primaries for Display P3 (SMPTE EG 432-1) and transfer characteristics for
/// the sRGB curve (IEC 61966-2-1), ITU-T H.273.
const P3_PRIMARIES: u16 = 12;
const SRGB_TRANSFER: u16 = 13;
fn source_profile(icc: Option<&[u8]>, colour: Colour) -> Option<vectorcraft_color::cms::IccProfile> {
/// The profile the decoded RGB values are in when it isn't sRGB: the primary item's RGB ICC
/// profile, else Display P3 when its `nclx` names P3 primaries with the sRGB curve. A grid
/// without its own `colr` takes its first tile's, as cameras write it on the tiles. A profile
/// that can't be read, or isn't RGB, is left out and the values are read as sRGB. Without any
/// `colr`, the HEVC stream's color description ([`stream_nclx`]) is read the same way.
fn source_profile(ctx: &Context<'_>) -> Option<vectorcraft_color::cms::IccProfile> {
use vectorcraft_color::cms::{self, IccProfile, ProfileKind};
if let Some(icc) = icc {
let id = ctx.meta.primary;
let own = ctx.props(id).ok()?;
let described = |p: &heic_rs::props::ItemProps<'_>| p.icc.is_some() || p.nclx.is_some();
let tile = || ctx.grid(id).ok().flatten().and_then(|(_, tiles)| tiles.first().and_then(|&t| ctx.props(t).ok())).filter(described);
let props = if described(&own) { Some(own) } else { tile() };
if let Some(icc) = props.as_ref().and_then(|p| p.icc) {
return IccProfile::from_bytes(None, icc).ok().filter(|p| p.kind == ProfileKind::Rgb);
}
(colour.primaries == P3_PRIMARIES && colour.transfer == SRGB_TRANSFER).then(|| cms::icc::builtin_rgb(cms::DISPLAY_P3)).flatten()
let nclx = match props {
Some(props) => props.nclx?,
None => stream_nclx(ctx)?,
};
(nclx.primaries == P3_PRIMARIES && nclx.transfer == SRGB_TRANSFER).then(|| cms::icc::builtin_rgb(cms::DISPLAY_P3)).flatten()
}
}
+201 -41
View File
@@ -1,15 +1,39 @@
//! Reading JPEG XL images (`.jxl`, ISO/IEC 18181) for File › Open and File › Place, with
//! `craft-jxl`: the bare codestream and the ISOBMFF container. The first frame of an animation is
//! read, with the orientation its header gives applied.
//! Reading JPEG XL images (`.jxl`, ISO/IEC 18181) for File › Open and File › Place, with the
//! jxl-oxide decoder: the bare codestream and the ISOBMFF container. The first frame of an
//! animation is read, with the orientation its header gives applied.
//!
//! Colors come back as sRGB whenever the decoder converts them without a color management
//! system: XYB-encoded images, every color space a JPEG XL header names, and embedded ICC
//! profiles that describe one of them. Any other image with an embedded RGB ICC profile comes
//! back with its samples as stored, as PNG and JPEG files with an embedded profile are drawn, and
//! with the profile. Gray images, and images whose profile is not an RGB one, are refused when the
//! decoder cannot convert their ICC profile. 16-bit and floating-point samples become 8 bits, alpha comes back straight,
//! and CMYK images are refused. The file is untrusted: the decoder is given only a container's
//! image boxes, the image's size is checked from its header before any pixels are decoded, and the
//! decoder's image buffers are capped.
use craft_jxl::{DecodeLimits, Error as JxlError, Layout};
use jxl_color::ColorTransform;
use jxl_oxide::color::{ColourEncoding, TransferFunction};
use jxl_oxide::{AllocTracker, ColorEncodingWithProfile, EnumColourEncoding, HdrType, InitializeResult, JxlImage, NullCms, RenderingIntent};
/// A bare JPEG XL codestream starts with these bytes.
const CODESTREAM: [u8; 2] = [0xff, 0x0a];
/// The signature box an ISOBMFF JPEG XL container starts with.
const CONTAINER: [u8; 12] = [0, 0, 0, 0x0c, b'J', b'X', b'L', b' ', 0x0d, 0x0a, 0x87, 0x0a];
/// Buffer allowance for container box filtering.
/// How many bytes the decoder is given first to read the header. Each later try gives it twice as
/// many bytes, and each try decodes the embedded ICC profile from its start again.
const HEAD: usize = 4096;
/// The most the decoder's buffers may take while it reads the header. Its `AllocTracker` counts the
/// image buffers only: an embedded ICC profile is decoded into buffers of its own, which jxl-color
/// limits to 256 MiB.
const HEADER_BUFFERS: usize = 16 << 20;
/// The most the decoder's buffers may take for the pixels: this many times the image's size as
/// RGBA, plus [`HEADER_BUFFERS`], and never more than the `max_alloc` of [`decode`], the limit the
/// `image` crate's decoders get in `raster_image`. The decoder keeps each channel as 32-bit
/// samples: a lossless 16-bit RGBA image of 1024 × 768 pixels took 12 times its size as RGBA.
const DECODER_BUFFERS: u64 = 16;
const TRUNCATED: &str = "the JPEG XL file is cut short";
/// Is `bytes` a JPEG XL image (a bare codestream or a container)?
pub fn is_jxl(bytes: &[u8]) -> bool {
@@ -22,48 +46,134 @@ pub(crate) fn oriented_resolution(ppi: Option<(f64, f64)>, orientation: u32) ->
}
/// The first frame of a JPEG XL image as straight RGBA, with the embedded ICC profile its colors
/// are in when they are not converted to sRGB, and the header orientation.
/// are in when they are not converted to sRGB ([`output_profile`]), and the header orientation.
/// Fails, without decoding the
/// pixels, when the image would take more than `max_alloc` bytes as RGBA. The image is also too
/// large to draw when the decoder's buffers for its pixels need more than they are allowed. A
/// container whose selected boxes exceed `max_alloc` or [`HEADER_BUFFERS`], whichever is greater,
/// is refused with "the JPEG XL container is too large to read".
pub fn decode(bytes: &[u8], max_alloc: u64) -> Result<(image::RgbaImage, Option<Vec<u8>>, u32), String> {
let pixel_boxes = pixel_boxes(bytes, max_alloc.max(HEADER_BUFFERS as u64))?;
let bytes = pixel_boxes.as_deref().unwrap_or(bytes);
let limits = DecodeLimits { max_pixels: max_alloc / 4, max_tracked_bytes: Some(max_alloc), max_input_bytes: usize::MAX };
let decoded = craft_jxl::decode(bytes, limits).map_err(|e| match e {
JxlError::PixelLimitExceeded { width, height, .. } => too_large(width, height),
JxlError::LimitExceeded(msg) => format!("an image is too large to draw: {msg}"),
JxlError::Unsupported(msg) if msg.contains("CMYK") => "CMYK JPEG XL images can't be read".into(),
other => unreadable(other),
})?;
let (w, h) = (decoded.width, decoded.height);
if u64::from(w).saturating_mul(u64::from(h)).saturating_mul(4) > max_alloc {
// The decoder reads the header first, with buffers for the header alone.
let (head, _) = header(bytes, HEADER_BUFFERS, None)?;
let (w, h) = (head.width(), head.height());
let rgba = u64::from(w) * u64::from(h) * 4;
if rgba > max_alloc {
return Err(too_large(w, h));
}
let profile = if !decoded.xyb_encoded && decoded.metadata.icc.as_deref() == Some(decoded.rendered_icc.as_slice()) {
if matches!(decoded.layout, Layout::Gray | Layout::GrayAlpha) {
return Err(unreadable("unsupported grayscale ICC profile"));
}
if decoded.rendered_icc.get(16..20) != Some(b"RGB ") {
return Err(unreadable("unsupported ICC profile color space"));
}
Some(decoded.rendered_icc)
} else {
None
};
let channels = decoded.layout.channels();
let gray = channels < 3;
let has_alpha = decoded.layout.has_alpha();
let mut out = image::RgbaImage::new(w, h);
for (dst, src) in out.as_chunks_mut::<4>().0.iter_mut().zip(decoded.pixels.chunks_exact(channels)) {
let a = if has_alpha { src[channels - 1].clamp(0.0, 1.0) } else { 1.0 };
let unpremul = |v: f32| if decoded.pixels_premultiplied && a > 0.0 { v / a } else { v };
let rgb = if gray {
let v = byte(unpremul(src[0]));
[v, v, v]
} else {
[byte(unpremul(src[0])), byte(unpremul(src[1])), byte(unpremul(src[2]))]
};
dst.copy_from_slice(&[rgb[0], rgb[1], rgb[2], byte(a)]);
if head.pixel_format().has_black() {
return Err("CMYK JPEG XL images can't be read".into());
}
Ok((out, profile, decoded.source_orientation))
// Then it reads the file again until the first frame is loaded, with buffers for the pixels.
let budget = rgba.saturating_mul(DECODER_BUFFERS).saturating_add(HEADER_BUFFERS as u64).min(max_alloc);
let budget = usize::try_from(budget).unwrap_or(usize::MAX);
let size = Some((w, h));
let (mut image, mut at) = header(bytes, budget, size)?;
let mut end = at;
while image.num_loaded_keyframes() == 0 {
if end == bytes.len() {
return Err(TRUNCATED.into());
}
end = end.saturating_mul(2).max(HEAD).min(bytes.len());
at += image.feed_bytes(&bytes[at..end]).map_err(|e| failed(e, size))?;
}
let metadata = &image.image_header().metadata;
let associated = metadata.alpha().and_then(|i| metadata.ec_info.get(i)).and_then(|ec| ec.alpha_associated()) == Some(true);
let intent = RenderingIntent::Relative;
let srgb = if metadata.grayscale() { EnumColourEncoding::gray_srgb(intent) } else { EnumColourEncoding::srgb(intent) };
let profile = output_profile(metadata.xyb_encoded, metadata.grayscale(), image.original_icc())?;
let orientation = metadata.orientation;
// Premultiplied colors are divided by alpha in the encoding they are stored in, and converted
// to sRGB after that. XYB-encoded images come from the decoder in linear sRGB (tone mapped when
// they are HDR), which the sRGB transfer curve alone turns into sRGB.
let (request, convert) = match (to_srgb_without_cms(metadata.xyb_encoded, image.original_icc()), associated) {
(false, _) => (None, None),
(true, false) => (Some(srgb), None),
(true, true) if metadata.xyb_encoded => (Some(EnumColourEncoding { tf: TransferFunction::Linear, ..srgb }), Some(ToSrgb::Curve)),
(true, true) => {
let stored = match (&metadata.colour_encoding, image.original_icc()) {
(ColourEncoding::Enum(e), _) => ColorEncodingWithProfile::new(e.clone()),
(_, Some(icc)) => ColorEncodingWithProfile::with_icc(icc).map_err(unreadable)?,
(_, None) => return Err(unreadable("no color encoding")),
};
let mut builder = ColorTransform::builder();
builder.from_pq(image.hdr_type() == Some(HdrType::Pq));
let to = ColorEncodingWithProfile::new(srgb);
let t = builder.build(&stored, &to, &metadata.opsin_inverse_matrix, &metadata.tone_mapping, &NullCms).map_err(unreadable)?;
(None, Some(ToSrgb::Transform(t)))
}
};
if let Some(encoding) = request {
image.request_color_encoding(encoding);
}
let render = image.render_frame(0).map_err(|e| failed(e, size))?;
let mut stream = render.stream();
let channels = stream.channels() as usize;
if !(1..=4).contains(&channels) {
return Err(unreadable(format!("{channels} channels")));
}
let mut out = image::RgbaImage::new(stream.width(), stream.height());
let width = out.width() as usize;
let mut row = vec![0f32; width * channels];
let mut colors = [vec![0f32; width], vec![0f32; width], vec![0f32; width]];
for line in out.chunks_exact_mut((width * 4).max(4)) {
if stream.write_to_buffer(&mut row) != row.len() {
return Err(TRUNCATED.into());
}
to_rgba(&row, channels, associated, convert.as_ref(), &mut colors, line)?;
}
Ok((out, profile, orientation))
}
/// How colors whose alpha was divided out become sRGB.
pub(crate) enum ToSrgb {
/// A conversion from the encoding the colors are stored in.
Transform(ColorTransform),
/// The sRGB transfer curve, for colors in linear sRGB.
Curve,
}
/// One row of samples, `channels` to a pixel (gray or RGB, then alpha when there are 2 or 4), as
/// straight RGBA bytes in `out`: colors divided by alpha when it is `associated`, then converted
/// with `convert`. `colors` holds a row of red, green and blue; a gray sample goes into all three,
/// as jxl-render's `clone_gray` does before its own conversions.
pub(crate) fn to_rgba(
row: &[f32],
channels: usize,
associated: bool,
convert: Option<&ToSrgb>,
colors: &mut [Vec<f32>; 3],
out: &mut [u8],
) -> Result<(), String> {
let alpha = |s: &[f32]| if matches!(channels, 2 | 4) { s.last().map_or(1.0, |a| a.clamp(0.0, 1.0)) } else { 1.0 };
let gray = channels < 3;
for (x, s) in row.chunks_exact(channels).enumerate() {
let a = alpha(s);
for (i, plane) in colors.iter_mut().enumerate() {
let v = s.get(if gray { 0 } else { i }).copied().unwrap_or(0.0);
if let Some(c) = plane.get_mut(x) {
*c = if associated && a > 0.0 { v / a } else { v };
}
}
}
// The conversion leaves gray in the first row when it gives one channel.
let gray = match convert {
Some(ToSrgb::Transform(t)) => {
let mut planes: Vec<&mut [f32]> = colors.iter_mut().map(Vec::as_mut_slice).collect();
t.run(&mut planes).map_err(unreadable)? < 3
}
Some(ToSrgb::Curve) => {
colors.iter_mut().flatten().for_each(|v| *v = if *v <= 0.003_130_8 { *v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 });
gray
}
None => gray,
};
for (x, (px, s)) in out.as_chunks_mut::<4>().0.iter_mut().zip(row.chunks_exact(channels)).enumerate() {
let c = |i: usize| colors.get(if gray { 0 } else { i }).and_then(|p| p.get(x)).copied().unwrap_or(0.0);
*px = [byte(c(0)), byte(c(1)), byte(c(2)), byte(alpha(s))];
}
Ok(())
}
/// A container's signature and the boxes the decoder reads pixels from (`ftyp`, `jxll`, `jxlc` and
@@ -100,6 +210,56 @@ pub(super) fn pixel_boxes(bytes: &[u8], max_copy: u64) -> Result<Option<Vec<u8>>
Ok(Some(out))
}
/// A decoder whose buffers may take `buffers` bytes, given as few of `bytes` as it needs to read
/// the header → (the decoder, how many bytes it took). `size` is the image's size when it is
/// known, for the error when the buffers need more ([`failed`]).
fn header(bytes: &[u8], buffers: usize, size: Option<(u32, u32)>) -> Result<(JxlImage, usize), String> {
let mut uninit = JxlImage::builder().alloc_tracker(AllocTracker::with_limit(buffers)).build_uninit();
let (mut at, mut end) = (0, 0usize);
loop {
end = end.saturating_mul(2).max(HEAD).min(bytes.len());
at += uninit.feed_bytes(&bytes[at..end]).map_err(|e| failed(e, size))?;
match uninit.try_init().map_err(|e| failed(e, size))? {
InitializeResult::Initialized(image) => return Ok((image, at)),
InitializeResult::NeedMoreData(_) if end == bytes.len() => return Err(TRUNCATED.into()),
InitializeResult::NeedMoreData(more) => uninit = more,
}
}
}
/// Does the decoder convert to sRGB without a color management system? It does for XYB-encoded
/// images and the color spaces a header names; for an embedded ICC profile, only when the profile
/// describes one of those.
fn to_srgb_without_cms(xyb: bool, icc: Option<&[u8]>) -> bool {
xyb || icc.is_none_or(|icc| ColorEncodingWithProfile::with_icc(icc).is_ok_and(|p| p.icc_profile().is_empty()))
}
/// The embedded RGB profile when the decoder leaves colors in it. Gray colors without a
/// conversion to sRGB cannot be stored as RGB without changing their profile, and neither can
/// colors left in a profile that is not an RGB one.
pub(crate) fn output_profile(xyb: bool, grayscale: bool, icc: Option<&[u8]>) -> Result<Option<Vec<u8>>, String> {
let converts = to_srgb_without_cms(xyb, icc);
if grayscale && !converts {
return Err(unreadable("unsupported grayscale ICC profile"));
}
if !converts && icc.and_then(|icc| icc.get(16..20)) != Some(b"RGB ") {
return Err(unreadable("unsupported ICC profile color space"));
}
Ok(icc.filter(|_| !converts).map(<[u8]>::to_vec))
}
/// The decoder's error `e` as a message. When the decoder's buffers needed more than they were
/// allowed and the image's `size` is known, the image is too large to draw. Otherwise the file
/// can't be read.
fn failed(e: Box<dyn std::error::Error + Send + Sync>, size: Option<(u32, u32)>) -> String {
let first: &(dyn std::error::Error + 'static) = &*e;
let out_of_memory = std::iter::successors(Some(first), |c| c.source()).any(|c| c.is::<jxl_grid::OutOfMemory>());
match size {
Some((w, h)) if out_of_memory => too_large(w, h),
_ => unreadable(e),
}
}
fn too_large(w: u32, h: u32) -> String {
format!("an image of {w} × {h} pixels is too large to draw")
}
+253 -42
View File
@@ -37,24 +37,7 @@ fn centers(side: u32) -> [(u32, u32); 4] {
#[cfg(feature = "heif")]
fn decoded(bytes: &[u8]) -> image::RgbaImage {
let raster = load::raster_image(bytes).unwrap();
craft_image_codecs::decode(&raster.blob.bytes)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8()
image::load_from_memory(&raster.blob.bytes).unwrap().to_rgba8()
}
#[cfg(feature = "heif")]
@@ -82,28 +65,7 @@ fn quadrants_open_and_place_as_their_pixels() {
assert_eq!(opened["format"], "heif", "{name}");
assert_eq!(s.doc().unwrap().doc.artboards[0].rect.size(), vectorcraft_geom::Size::new(32.0, 32.0));
let blob = s.doc().unwrap().doc.images.values().next().unwrap();
assert_quadrants(
&craft_image_codecs::decode(&blob.bytes)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8(),
32,
name,
);
assert_quadrants(&image::load_from_memory(&blob.bytes).unwrap().to_rgba8(), 32, name);
s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
let placed = s.execute("file.place", &json!({"name": name, "dataBase64": encoded})).unwrap();
assert_eq!(placed["format"], "heif", "{name}");
@@ -384,8 +346,8 @@ fn damaged_unsupported_and_oversized_files_are_refused() {
small[at + 4..at + 8].copy_from_slice(&32u32.to_be_bytes());
let refused = super::heifread::decode(&small, 64 * 64 * 17 - 1).map(|img| img.dimensions());
assert!(refused.as_ref().is_err_and(|e| e.contains("too large to draw")), "{refused:?}");
// A 128 × 128 grid of four 64 × 64 tiles.
let grid = 128 * 128 * 17;
// A 128 × 128 grid of four 64 × 64 tiles adds its composed frame, 128 × 128 × 6.
let grid = 128 * 128 * (8 + 6) + 4 * 64 * 64 * 9;
assert!(super::heifread::decode(GRID, grid).is_ok());
assert!(super::heifread::decode(GRID, grid - 1).unwrap_err().contains("too large to draw"));
// The grid's ispe (property 1) claims 16 × 16 pixels; its grid data still composes 128 × 128,
@@ -397,6 +359,255 @@ fn damaged_unsupported_and_oversized_files_are_refused() {
assert!(super::heifread::decode(&understated, grid - 1).unwrap_err().contains("too large to draw"));
}
/// Appends `value` as `n` bits, most significant first.
#[cfg(feature = "heif")]
fn put(bits: &mut Vec<bool>, value: u64, n: u32) {
bits.extend((0..n).rev().map(|i| i < 64 && value >> i & 1 == 1));
}
/// Appends `value` as an unsigned Exp-Golomb code.
#[cfg(feature = "heif")]
fn put_ue(bits: &mut Vec<bool>, value: u64) {
let len = 64 - (value + 1).leading_zeros();
put(bits, 0, len - 1);
put(bits, value + 1, len);
}
/// The fields of SPS 0 of `width` × `height` 4:2:0 samples with `sub_layers` sub-layers, each
/// with its profile and level, up to its height.
#[cfg(feature = "heif")]
fn sps_head(width: u64, height: u64, sub_layers: u64) -> Vec<bool> {
sps_head_with_id(width, height, sub_layers, 0)
}
/// [`sps_head`] for SPS `id`.
#[cfg(feature = "heif")]
fn sps_head_with_id(width: u64, height: u64, sub_layers: u64, id: u64) -> Vec<bool> {
let mut bits = Vec::new();
put(&mut bits, 0, 4);
put(&mut bits, sub_layers, 3);
put(&mut bits, 1, 1);
put(&mut bits, 0, 96);
for _ in 0..sub_layers {
put(&mut bits, 0b11, 2);
}
if sub_layers > 0 {
put(&mut bits, 0, 2 * (8 - sub_layers as u32));
}
for _ in 0..sub_layers {
put(&mut bits, 0, 88 + 8);
}
put_ue(&mut bits, id);
put_ue(&mut bits, 1);
put_ue(&mut bits, width);
put_ue(&mut bits, height);
bits
}
/// An SPS NAL unit of `bits` (see [`nal`]).
#[cfg(feature = "heif")]
fn sps_nal(bits: Vec<bool>) -> Vec<u8> {
nal(33, bits)
}
/// A NAL unit of type `kind` holding `bits`, with its stop bit, and emulation prevention bytes
/// inserted as a stream carries them.
#[cfg(feature = "heif")]
fn nal(kind: u8, mut bits: Vec<bool>) -> Vec<u8> {
put(&mut bits, 1, 1);
while !bits.len().is_multiple_of(8) {
bits.push(false);
}
let rbsp: Vec<u8> = bits.chunks(8).map(|b| b.iter().fold(0u8, |v, &bit| v << 1 | u8::from(bit))).collect();
let mut nal = vec![kind << 1, 1];
let mut zeros = 0;
for b in rbsp {
if zeros >= 2 && b <= 3 {
nal.push(3);
zeros = 0;
}
zeros = if b == 0 { zeros + 1 } else { 0 };
nal.push(b);
}
nal
}
#[cfg(feature = "heif")]
fn sps(width: u64, height: u64, sub_layers: u64) -> Vec<u8> {
sps_nal(sps_head(width, height, sub_layers))
}
/// A 64 × 64 SPS that uses every optional part before the VUI's video signal type: a conformance
/// window, sub-layer ordering for two sub-layers, explicit scaling lists, PCM, a reference picture
/// set predicted from another and a long-term picture, then an Extended_SAR aspect ratio and
/// overscan information. `signal` is the full-range flag and the color description, if any.
#[cfg(feature = "heif")]
fn sps_with_vui(signal: Option<(u64, Option<[u64; 3]>)>) -> Vec<u8> {
sps_with_vui_and_id(signal, 0)
}
/// [`sps_with_vui`] for SPS `id`.
#[cfg(feature = "heif")]
fn sps_with_vui_and_id(signal: Option<(u64, Option<[u64; 3]>)>, id: u64) -> Vec<u8> {
let mut bits = sps_head_with_id(64, 64, 1, id);
put(&mut bits, 1, 1);
for offset in [0, 2, 0, 2] {
put_ue(&mut bits, offset);
}
put_ue(&mut bits, 0);
put_ue(&mut bits, 0);
// 8 bits of picture order count.
put_ue(&mut bits, 4);
put(&mut bits, 1, 1);
for _ in 0..2 * 3 {
put_ue(&mut bits, 1);
}
for value in [0, 3, 0, 3, 1, 1] {
put_ue(&mut bits, value);
}
// Scaling lists: matrix 1 of each size given explicitly, the others copied.
put(&mut bits, 0b11, 2);
for size in 0..4 {
for matrix in 0..if size == 3 { 2 } else { 6 } {
if matrix == 1 {
put(&mut bits, 1, 1);
if size > 1 {
put_ue(&mut bits, 5);
}
for _ in 0..if size == 0 { 16 } else { 64 } {
put_ue(&mut bits, 3);
}
} else {
put(&mut bits, 0, 1);
put_ue(&mut bits, 0);
}
}
}
// AMP off, SAO on, PCM with its depths, block sizes and loop filter flag.
put(&mut bits, 0b01, 2);
put(&mut bits, 1, 1);
put(&mut bits, 0x77, 8);
put_ue(&mut bits, 0);
put_ue(&mut bits, 1);
put(&mut bits, 0, 1);
// Two short-term sets: one negative and one positive picture, then a set predicted from it
// with three entries (unused with use_delta_flag, used, unused).
put_ue(&mut bits, 2);
put_ue(&mut bits, 1);
put_ue(&mut bits, 1);
for _ in 0..2 {
put_ue(&mut bits, 0);
put(&mut bits, 1, 1);
}
put(&mut bits, 1, 1);
put(&mut bits, 0, 1);
put_ue(&mut bits, 0);
put(&mut bits, 0b01100, 5);
// One long-term picture: 8 bits of picture order count and its used flag.
put(&mut bits, 1, 1);
put_ue(&mut bits, 1);
put(&mut bits, 0xab, 8);
put(&mut bits, 1, 1);
put(&mut bits, 0b11, 2);
// VUI: Extended_SAR 1:1 and overscan information.
put(&mut bits, 1, 1);
put(&mut bits, 1, 1);
put(&mut bits, 255, 8);
put(&mut bits, 0x0001_0001, 32);
put(&mut bits, 1, 1);
put(&mut bits, 0, 1);
match signal {
Some((full, description)) => {
put(&mut bits, 1, 1);
put(&mut bits, 5, 3);
put(&mut bits, full, 1);
put(&mut bits, u64::from(description.is_some()), 1);
for code in description.into_iter().flatten() {
put(&mut bits, code, 8);
}
}
None => put(&mut bits, 0, 1),
}
// No chroma location, field or display window information, timing or restrictions.
put(&mut bits, 0, 8);
sps_nal(bits)
}
#[cfg(feature = "heif")]
#[test]
fn picture_sizes_come_from_the_sequence_parameter_sets() {
use super::heifread::{picture_bytes, sps_size};
for sub_layers in [0, 1, 6] {
for (w, h) in [(32, 32), (4032, 3024), (65535, 65535)] {
let nal = sps(w, h, sub_layers);
assert!(nal.windows(3).any(|w| w == [0, 0, 3]), "the profile's zeros need emulation prevention");
assert_eq!(sps_size(&nal), Some((w, h, 1)), "{w} × {h}, {sub_layers} sub-layers");
}
}
let mut vps = sps(32, 32, 0);
vps[0] = 32 << 1;
assert_eq!(sps_size(&vps), None);
assert_eq!(sps_size(&sps(32, 32, 0)[..8]), None);
// 4:2:0 is 3 bytes a sample position in each of three sets of planes, in 64-sample blocks.
assert_eq!(picture_bytes(QUADRANTS), Some(64 * 64 * 9));
assert_eq!(picture_bytes(GRID), Some(4 * 64 * 64 * 9));
assert!(picture_bytes(ALPHA).unwrap() > 64 * 64 * 9, "the alpha image is counted");
}
#[cfg(feature = "heif")]
#[test]
fn the_color_description_comes_from_the_streams_video_signal_type() {
use super::heifread::{sps_signal, sps_size};
use heic_rs::{MatrixCoefficients, Range};
let signal = |nal: &[u8]| sps_signal(nal).map(|n| (n.primaries, n.transfer, n.matrix, n.matrix_code, n.range));
let described = sps_with_vui(Some((1, Some([12, 13, 6]))));
assert_eq!(sps_size(&described), Some((64, 64, 1)));
assert_eq!(signal(&described), Some((12, 13, MatrixCoefficients::Bt601, 6, Range::Full)));
assert_eq!(signal(&sps_with_vui(Some((0, None)))), Some((2, 2, MatrixCoefficients::Unspecified, 2, Range::Limited)));
assert_eq!(signal(&sps_with_vui(None)), None);
assert_eq!(signal(&sps(64, 64, 0)), None, "cut short before its VUI");
// The ICC-only fixture's stream: heif-enc writes full-range BT.601.
let ctx = heic_rs::context::Context::open(TONES_P3_ICC_ONLY).unwrap();
let props = ctx.props(ctx.meta.primary).unwrap();
assert!(props.nclx.is_none() && props.icc.is_some());
let sets = props.hvcc.unwrap().parameter_sets();
let nal = sets.into_iter().find(|nal| nal[0] >> 1 & 0x3f == 33).unwrap();
assert_eq!(sps_signal(nal).map(|n| (n.matrix, n.range)), Some((MatrixCoefficients::Bt601, Range::Full)));
}
#[cfg(feature = "heif")]
#[test]
fn the_slices_picture_parameter_set_picks_the_sps() {
use super::heifread::{active_sps, sps_signal};
use heic_rs::Range;
let full = sps_with_vui_and_id(Some((1, Some([1, 13, 6]))), 0);
let limited = sps_with_vui_and_id(Some((0, Some([1, 13, 1]))), 1);
let pps = |id: u64, sps: u64| {
let mut bits = Vec::new();
put_ue(&mut bits, id);
put_ue(&mut bits, sps);
nal(34, bits)
};
// first_slice_segment_in_pic_flag, no_output_of_prior_pics_flag for an IDR picture (type 19),
// slice_pic_parameter_set_id.
let slice = |kind: u8, pps: u64| {
let mut bits = vec![true];
if kind == 19 {
bits.push(false);
}
put_ue(&mut bits, pps);
nal(kind, bits)
};
let (pps0, pps3) = (pps(0, 0), pps(3, 1));
let sets = [full.as_slice(), limited.as_slice(), pps0.as_slice(), pps3.as_slice()];
let (idr3, trail0, idr5) = (slice(19, 3), slice(1, 0), slice(19, 5));
assert_eq!(active_sps(&sets, &[&idr3]), Some(limited.as_slice()));
assert_eq!(active_sps(&sets, &[&trail0]), Some(full.as_slice()));
assert_eq!(active_sps(&sets, &[&idr5]), None, "no PPS 5");
assert_eq!(active_sps(&sets, &[&pps0]), None, "no slice");
assert_eq!(active_sps(&sets, &[&idr3]).and_then(sps_signal).map(|n| (n.matrix_code, n.range)), Some((1, Range::Limited)));
}
#[cfg(not(feature = "heif"))]
#[test]
fn a_build_without_the_decoder_refuses_heif_files_with_a_message() {
+100 -61
View File
@@ -1,39 +1,20 @@
//! Reading JPEG XL images: the bare codestream and the container, alpha, 16-bit samples, the size
//! check before decoding, and damaged files refused without a panic.
use craft_jxl::{EncodeOptions, ImageRef, Layout, Samples};
use serde_json::json;
use zune_core::bit_depth::BitDepth;
use zune_core::colorspace::ColorSpace;
use zune_core::options::EncoderOptions;
use super::jxlread::{decode, is_jxl, oriented_resolution, pixel_boxes};
use super::jxlread::{ToSrgb, decode, is_jxl, oriented_resolution, output_profile, pixel_boxes, to_rgba};
use super::*;
#[derive(Clone, Copy)]
enum BitDepth {
Eight,
Sixteen,
}
/// A lossless JPEG XL codestream of `w` × `h` pixels: `samples` in `layout`, 8-bit, or 16-bit in
/// A lossless JPEG XL codestream of `w` × `h` pixels: `samples` in `space`, 8-bit, or 16-bit in
/// native byte order.
fn jxl(w: usize, h: usize, layout: Layout, depth: BitDepth, samples: &[u8]) -> Vec<u8> {
let opts = EncodeOptions { lossless: true, ..EncodeOptions::default() };
match depth {
BitDepth::Eight => craft_jxl::encode(
&ImageRef { width: w as u32, height: h as u32, layout, samples: Samples::U8(samples) },
opts,
&craft_jxl::Metadata::default(),
)
.unwrap(),
BitDepth::Sixteen => {
let u16s: Vec<u16> = samples.as_chunks::<2>().0.iter().map(|c| u16::from_ne_bytes([c[0], c[1]])).collect();
craft_jxl::encode(
&ImageRef { width: w as u32, height: h as u32, layout, samples: Samples::U16(&u16s) },
opts,
&craft_jxl::Metadata::default(),
)
.unwrap()
}
}
fn jxl(w: usize, h: usize, space: ColorSpace, depth: BitDepth, samples: &[u8]) -> Vec<u8> {
let mut out = vec![];
zune_jpegxl::JxlSimpleEncoder::new(samples, EncoderOptions::new(w, h, space, depth)).encode(&mut out).unwrap();
out
}
/// `codestream` in the ISOBMFF container: the signature box, `ftyp` and a `jxlc` box holding it.
@@ -51,7 +32,7 @@ fn container(codestream: &[u8]) -> Vec<u8> {
const RGBA: [[u8; 4]; 6] = [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [200, 100, 50, 128], [9, 9, 9, 0], [77, 77, 77, 255]];
fn rgba8() -> Vec<u8> {
jxl(3, 2, Layout::Rgba, BitDepth::Eight, RGBA.as_flattened())
jxl(3, 2, ColorSpace::RGBA, BitDepth::Eight, RGBA.as_flattened())
}
fn b64(bytes: &[u8]) -> String {
@@ -64,27 +45,7 @@ fn stored_pixels(s: &Session) -> Vec<[u8; 4]> {
assert_eq!(doc.images.len(), 1);
let blob = doc.images.values().next().unwrap();
assert_eq!(blob.mime, "image/png", "stored as PNG");
craft_image_codecs::decode(&blob.bytes)
.map(|__cimg| {
let (__w, __h) = __cimg.dimensions();
match (__cimg.layout(), __cimg.sample_type()) {
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
}
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
}
})
.unwrap()
.to_rgba8()
.pixels()
.map(|p| p.0)
.collect()
image::load_from_memory(&blob.bytes).unwrap().to_rgba8().pixels().map(|p| p.0).collect()
}
#[test]
@@ -183,13 +144,13 @@ fn a_copied_jxl_file_pastes_as_its_image() {
fn sixteen_bit_samples_become_eight_bits() {
let rgb: [[u16; 3]; 4] = [[0x0000, 0x8080, 0xffff], [0x1234, 0x80ff, 0x7f00], [0xff00, 0x00ff, 0x4000], [0xc000, 0x0101, 0xfefe]];
let samples: Vec<u8> = rgb.as_flattened().iter().flat_map(|v| v.to_ne_bytes()).collect();
let f = jxl(2, 2, Layout::Rgb, BitDepth::Sixteen, &samples);
let f = jxl(2, 2, ColorSpace::RGB, BitDepth::Sixteen, &samples);
let to8 = |v: u16| (f64::from(v) / 65535.0 * 255.0).round() as u8;
let want: Vec<[u8; 4]> = rgb.iter().map(|p| [to8(p[0]), to8(p[1]), to8(p[2]), 255]).collect();
assert_eq!(decode(&f, 1 << 30).unwrap().0.pixels().map(|p| p.0).collect::<Vec<_>>(), want);
// Gray, 16 bits, in the container, opened as a document.
let gray: Vec<u8> = [0xffffu16, 0x8080, 0x0000, 0x4040].iter().flat_map(|v| v.to_ne_bytes()).collect();
let f = container(&jxl(2, 2, Layout::Gray, BitDepth::Sixteen, &gray));
let f = container(&jxl(2, 2, ColorSpace::Luma, BitDepth::Sixteen, &gray));
let mut s = Session::new();
s.execute("document.open", &json!({"name": "gray.jxl", "dataBase64": b64(&f)})).unwrap();
assert_eq!(stored_pixels(&s), [[255, 255, 255, 255], [128, 128, 128, 255], [0, 0, 0, 255], [64, 64, 64, 255]]);
@@ -231,16 +192,58 @@ fn an_image_too_large_is_refused_from_its_header() {
/// the image is too large to draw, as when its size alone is.
#[test]
fn an_image_whose_decoder_buffers_pass_the_allowance_is_too_large() {
assert!(decode(&rgba8(), 24).unwrap_err().contains("too large to draw"));
assert_eq!(decode(&rgba8(), 24).unwrap_err(), "an image of 3 × 2 pixels is too large to draw");
let gray: Vec<u8> = (0..64 * 64).map(|i| (i % 251) as u8).collect();
let f = container(&jxl(64, 64, Layout::Gray, BitDepth::Eight, &gray));
assert!(decode(&f, 64 * 64 * 4).unwrap_err().contains("too large to draw"));
let f = container(&jxl(64, 64, ColorSpace::Luma, BitDepth::Eight, &gray));
assert_eq!(decode(&f, 64 * 64 * 4).unwrap_err(), "an image of 64 × 64 pixels is too large to draw");
assert!(decode(&f, 1 << 20).is_ok());
// A file cut short is still reported as cut short or unreadable.
let e = decode(&f[..f.len() - 3], 1 << 20).unwrap_err();
assert!(!e.contains("too large"), "{e}");
}
/// Premultiplied colors are divided by their alpha before they are converted to sRGB: a linear
/// 0.25 at alpha 0.5 is a straight linear 0.5, which sRGB stores as 0.735 (188 of 255).
#[test]
fn associated_alpha_is_divided_out_before_the_color_conversion() {
use jxl_oxide::{ColorEncodingWithProfile, EnumColourEncoding, NullCms, RenderingIntent};
let srgb = EnumColourEncoding::srgb(RenderingIntent::Relative);
let linear = EnumColourEncoding { tf: jxl_oxide::color::TransferFunction::Linear, ..srgb.clone() };
let header = jxl_oxide::JxlImage::builder().read(&rgba8()[..]).unwrap();
let m = &header.image_header().metadata;
let to_srgb = ToSrgb::Transform(
jxl_color::ColorTransform::new(
&ColorEncodingWithProfile::new(linear),
&ColorEncodingWithProfile::new(srgb),
&m.opsin_inverse_matrix,
&m.tone_mapping,
&NullCms,
)
.unwrap(),
);
let mut colors = [vec![0.0; 2], vec![0.0; 2], vec![0.0; 2]];
let mut out = [0u8; 8];
for convert in [&to_srgb, &ToSrgb::Curve] {
to_rgba(&[0.25, 0.25, 0.25, 0.5, 0.0, 0.0, 0.0, 0.0], 4, true, Some(convert), &mut colors, &mut out).unwrap();
assert_eq!(out, [188, 188, 188, 128, 0, 0, 0, 0]);
// Straight alpha is left as it is.
to_rgba(&[0.25, 0.25, 0.25, 0.5, 1.0, 1.0, 1.0, 1.0], 4, false, Some(convert), &mut colors, &mut out).unwrap();
assert_eq!(out, [137, 137, 137, 128, 255, 255, 255, 255]);
}
// Gray with another white point converts through three channels and comes back as gray.
let gray_e = EnumColourEncoding {
white_point: jxl_oxide::color::WhitePoint::E,
tf: jxl_oxide::color::TransferFunction::Linear,
..EnumColourEncoding::gray_srgb(RenderingIntent::Relative)
};
let gray_srgb = ColorEncodingWithProfile::new(EnumColourEncoding::gray_srgb(RenderingIntent::Relative));
let to_gray =
jxl_color::ColorTransform::new(&ColorEncodingWithProfile::new(gray_e), &gray_srgb, &m.opsin_inverse_matrix, &m.tone_mapping, &NullCms)
.unwrap();
to_rgba(&[0.25, 0.5, 1.0, 1.0], 2, true, Some(&ToSrgb::Transform(to_gray)), &mut colors, &mut out).unwrap();
assert_eq!(out, [188, 188, 188, 128, 255, 255, 255, 255]);
}
/// A container's Exif and Brotli-compressed boxes are left out: an unreadable `brob` box before the
/// codestream doesn't stop the image from opening.
#[test]
@@ -258,17 +261,53 @@ fn metadata_boxes_are_not_read() {
assert_eq!(decode(&f, 1 << 30).unwrap().0.pixels().map(|p| p.0).collect::<Vec<_>>(), RGBA);
}
/// The PNG carries the profile, the pixels and the resolution.
/// Colors left in their embedded RGB profile keep it: the PNG they are stored in carries the
/// profile. Colors converted to sRGB, and a gray image's colors, which come back as RGB, are stored
/// without one.
#[test]
fn colors_left_in_their_icc_profile_keep_it() {
use image::ImageDecoder as _;
use jxl_oxide::{EnumColourEncoding, RenderingIntent};
// A profile jxl-color can't turn into a JPEG XL color space, so the decoder leaves the colors
// in it: the sRGB profile with the tag of its red curve renamed.
let unnamed = |encoding: &EnumColourEncoding, curve: &[u8; 4]| {
let mut icc = jxl_color::icc::colour_encoding_to_icc(encoding);
let count = u32::from_be_bytes(icc[128..132].try_into().unwrap()) as usize;
for at in (0..count).map(|i| 132 + 12 * i) {
if icc[at..at + 4] == curve[..] {
icc[at..at + 4].copy_from_slice(b"xTRC");
}
}
icc
};
let srgb = EnumColourEncoding::srgb(RenderingIntent::Relative);
let rgb = unnamed(&srgb, b"rTRC");
assert_ne!(rgb, jxl_color::icc::colour_encoding_to_icc(&srgb), "a tag renamed");
assert_eq!(output_profile(false, false, Some(&rgb)).unwrap(), Some(rgb.clone()));
assert_eq!(output_profile(true, false, Some(&rgb)).unwrap(), None, "XYB-encoded colors become sRGB");
assert_eq!(output_profile(false, false, Some(&jxl_color::icc::colour_encoding_to_icc(&srgb))).unwrap(), None, "converted to sRGB");
let gray = unnamed(&EnumColourEncoding::gray_srgb(RenderingIntent::Relative), b"kTRC");
assert!(!jxl_oxide::ColorEncodingWithProfile::with_icc(&gray).unwrap().icc_profile().is_empty());
assert_eq!(output_profile(false, true, Some(&gray)).unwrap_err(), "the JPEG XL file can't be read: unsupported grayscale ICC profile");
assert_eq!(
output_profile(false, true, Some(&jxl_color::icc::colour_encoding_to_icc(&EnumColourEncoding::gray_srgb(RenderingIntent::Relative))))
.unwrap(),
None
);
assert_eq!(output_profile(false, false, None).unwrap(), None);
// A color image left in a profile that is not an RGB one can't be stored as RGB.
let mut lab = rgb.clone();
lab[16..20].copy_from_slice(b"Lab ");
assert_eq!(output_profile(false, false, Some(&lab)).unwrap_err(), "the JPEG XL file can't be read: unsupported ICC profile color space");
assert_eq!(output_profile(true, false, Some(&lab)).unwrap(), None, "XYB-encoded colors become sRGB");
// The PNG carries the profile, the pixels and the resolution.
let img = image::RgbaImage::from_raw(2, 1, vec![200, 100, 50, 255, 9, 9, 9, 0]).unwrap();
let dummy_icc = vec![0u8; 128];
for icc in [Some(dummy_icc), None] {
for icc in [Some(rgb), None] {
let RasterImage { blob, width, height, .. } = super::load::as_png(img.clone(), icc.clone(), Some((144.0, 144.0))).unwrap();
assert_eq!((width, height), (2, 1));
let decoded = craft_image_codecs::decode(&blob.bytes).unwrap();
assert_eq!(decoded.icc, icc);
assert_eq!(decoded.data(), img.as_raw().as_slice());
let mut png = image::codecs::png::PngDecoder::new(std::io::Cursor::new(&blob.bytes[..])).unwrap();
assert_eq!(png.icc_profile().unwrap(), icc);
assert_eq!(image::DynamicImage::from_decoder(png).unwrap().to_rgba8(), img);
assert_eq!(super::ppi::resolution(&blob.bytes).map(|(x, y)| (x.round(), y.round())), Some((144.0, 144.0)));
}
}
+4 -2
View File
@@ -1103,7 +1103,8 @@ fn decode_rgba(c: &str, blob: &vectorcraft_doc::ImageBlob) -> Result<image::Rgba
// Print rasters run to gigabytes decoded: the same allowance opening them has.
// The image's size as RGBA, read from its header, is held to that allowance before anything
// is decoded (#1717).
if let Some((w, h)) = vectorcraft_doc::header_size(&blob.bytes)
let header = vectorcraft_doc::header_size(&blob.bytes);
if let Some((w, h)) = header
&& u64::from(w) * u64::from(h) > crate::cmd::fileio::MAX_RASTER_ALLOC / 4
{
return Err(bad(c, format!("an image of {w} × {h} pixels is too large to draw")));
@@ -1112,7 +1113,8 @@ fn decode_rgba(c: &str, blob: &vectorcraft_doc::ImageBlob) -> Result<image::Rgba
opts.limits.max_pixels = crate::cmd::fileio::MAX_RASTER_ALLOC / 4;
opts.limits.max_alloc = crate::cmd::fileio::MAX_RASTER_ALLOC;
let img = craft_image_codecs::decode_with(&blob.bytes, &opts).map_err(|e| match e {
craft_image_codecs::CodecError::LimitExceeded(_) => bad(c, "the image is too large to draw"),
// Within the allowance from its header: a file that can't hold the pixels it declares.
craft_image_codecs::CodecError::LimitExceeded(_) if header.is_none() => bad(c, "the image is too large to draw"),
_ => bad(c, format!("the image's pixels can't be read: {e}")),
})?;
let (w, h) = img.dimensions();
+7 -1
View File
@@ -367,7 +367,13 @@ pub(super) fn fax_settings(d: Option<&DictRef>) -> Res<CcittParams> {
}
// Group 4 below 0, one-dimensional Group 3 at 0, mixed Group 3 above (the row's tag bit says
// how it is coded, so any positive `K` reads the same); `as` saturates.
let k = if k < 0.0 { -1 } else if k == 0.0 { 0 } else { (k as i64).max(1) };
let k = if k < 0.0 {
-1
} else if k == 0.0 {
0
} else {
(k as i64).max(1)
};
Ok(CcittParams {
k,
columns: columns as i64,