svg: SVG import decodes its images through craft-image-codecs

The decoding File › Open, Place and the renderer share moves to
vectorcraft-doc (decode.rs: decode_image, decoded_layout), and SVG
import's images read through it: the size from the header against the
allowance first, then the pixels as stored with the profile the file
embeds (a TIFF's still read by the TIFF reader).

decoded_pixels_are_those_the_image_crate_read compares PNG, GIF, WebP,
TIFF and BMP at each depth the image crate writes with its pixels, and
JPEG within two steps.
This commit is contained in:
FredApps
2026-11-16 06:06:34 +01:00
parent 3590f96ba9
commit 48d4afe4ec
6 changed files with 139 additions and 102 deletions
+79
View File
@@ -0,0 +1,79 @@
//! Images decoded through craft-image-codecs as the image crate gave them (#778): the renderer,
//! File › Open and Place, and SVG import read their pixels with [`decode_image`], and size them
//! from their header with [`decoded_layout`].
/// `bytes` decoded as `format` within `allowance` bytes, the pixels as stored (not turned
/// upright) and as the image crate gave them ([`dynamic`]), with the ICC profile the file embeds.
/// The renderer, File › Open and Place, and SVG import read images with it.
pub fn decode_image(
format: craft_image_codecs::Format,
bytes: &[u8],
allowance: u64,
) -> Result<(image::DynamicImage, Option<Vec<u8>>), craft_image_codecs::CodecError> {
let opts = craft_image_codecs::DecodeOptions {
limits: craft_image_codecs::Limits { max_width: u32::MAX, max_height: u32::MAX, max_pixels: u64::MAX, max_alloc: allowance },
keep_orientation: true,
};
let mut img = craft_image_codecs::decode_as_with(format, bytes, &opts)?;
let icc = img.icc.take();
let img = dynamic(img).ok_or_else(|| craft_image_codecs::CodecError::InvalidImage("the decoded samples don't fit the image".into()))?;
Ok((img, icc))
}
/// A decoded image as the image crate's: 8- and 16-bit gray, gray and alpha, RGB and RGBA as they
/// are, 32-bit float RGB and RGBA as they are, anything else as 8-bit RGBA.
fn dynamic(img: craft_image_codecs::Image) -> Option<image::DynamicImage> {
use craft_image_codecs::{ChannelLayout as L, SampleType as S};
use image::{DynamicImage as D, ImageBuffer as B};
let (w, h) = img.dimensions();
Some(match (img.layout(), img.sample_type()) {
(L::Gray, S::U8) => D::ImageLuma8(B::from_raw(w, h, img.into_data())?),
(L::GrayA, S::U8) => D::ImageLumaA8(B::from_raw(w, h, img.into_data())?),
(L::Rgb, S::U8) => D::ImageRgb8(B::from_raw(w, h, img.into_data())?),
(L::Rgba, S::U8) => D::ImageRgba8(B::from_raw(w, h, img.into_data())?),
(layout @ (L::Gray | L::GrayA | L::Rgb | L::Rgba), S::U16) => {
let v = img.to_u16_samples()?;
match layout {
L::Gray => D::ImageLuma16(B::from_raw(w, h, v)?),
L::GrayA => D::ImageLumaA16(B::from_raw(w, h, v)?),
L::Rgb => D::ImageRgb16(B::from_raw(w, h, v)?),
_ => D::ImageRgba16(B::from_raw(w, h, v)?),
}
}
_ => D::ImageRgba8(B::from_raw(w, h, img.to_rgba8())?),
})
}
/// The image's size and the bytes a pixel of it takes decoded ([`decode_as`]), read from its
/// header: palettes as RGB (RGBA with a transparent entry; GIF frames always RGBA), bitmaps as 8-bit
/// gray, 16-bit samples as two bytes. A PNG whose header alone is there is read from its `IHDR`;
/// a format whose header says only its size (TGA, ICO and the like) counts RGBA.
pub fn decoded_layout(bytes: &[u8], format: craft_image_codecs::Format) -> Option<(u32, u32, u64)> {
use craft_image_codecs::{Format as F, RasterColorType as T};
if let Some(i) = craft_image_codecs::inspect_raster(bytes).ok().flatten() {
let deep = i.bits_per_sample > 8 && i.color_type != T::Indexed;
let channels = match i.color_type {
_ if format == F::Gif => 4,
T::Indexed => 3 + u64::from(i.transparent_index.is_some()),
T::Bitmap => 1,
_ => u64::from(i.channels.max(1)),
};
return Some((i.width, i.height, channels * if deep { 2 } else { 1 }));
}
if format != F::Png {
return crate::header_size(bytes).map(|(w, h)| (w, h, 4));
}
if bytes.get(12..16)? != b"IHDR" {
return None;
}
let be = |at: usize| Some(u32::from_be_bytes(bytes.get(at..at + 4)?.try_into().ok()?));
let (depth, color) = (*bytes.get(24)?, *bytes.get(25)?);
let channels: u64 = match color {
0 => 1,
2 | 3 => 3,
4 => 2,
6 => 4,
_ => return None,
};
Some((be(16)?, be(20)?, channels * if depth == 16 { 2 } else { 1 }))
}
+1
View File
@@ -14,6 +14,7 @@ pub mod cmyk;
pub mod color_mask;
pub mod compound_shape;
pub mod corners;
pub mod decode;
pub mod depth;
pub mod dimension;
pub mod graph;
+5 -5
View File
@@ -163,10 +163,10 @@ fn image_format(f: craft_image_codecs::Format) -> Option<&'static Format> {
}
/// The image's size and the bytes a pixel of it takes decoded, from its header
/// ([`vectorcraft_render::decoded_layout`]), for bytes in a format craft-image-codecs tells.
/// ([`vectorcraft_doc::decode::decoded_layout`]), for bytes in a format craft-image-codecs tells.
fn header_layout(bytes: &[u8]) -> Option<(craft_image_codecs::Format, u32, u32, u64)> {
let format = craft_image_codecs::detect(bytes)?;
let (w, h, per_pixel) = vectorcraft_render::decoded_layout(bytes, format)?;
let (w, h, per_pixel) = vectorcraft_doc::decode::decoded_layout(bytes, format)?;
Some((format, w, h, per_pixel))
}
@@ -1026,12 +1026,12 @@ pub fn raster_image(bytes: &[u8]) -> Result<RasterImage> {
// A Targa file's size is read from its header, which no signature points a probe at.
let tga = || (kind == craft_image_codecs::Format::Tga).then(|| super::tgaread::size(bytes)).flatten().map(|(w, h)| (w, h, 4));
let (w, h, per_pixel) =
vectorcraft_render::decoded_layout(bytes, kind).or_else(tga).ok_or_else(|| err("the image's size can't be read"))?;
vectorcraft_doc::decode::decoded_layout(bytes, kind).or_else(tga).ok_or_else(|| err("the image's size can't be read"))?;
let pixels = u64::from(w) * u64::from(h);
if pixels.saturating_mul(per_pixel) > MAX_RASTER_ALLOC || pixels * 4 > MAX_RASTER_ALLOC {
return Err(err(format!("an image of {w} × {h} pixels is too large to draw")));
}
let (img, profile) = vectorcraft_render::decode_image(kind, bytes, MAX_RASTER_ALLOC).map_err(err)?;
let (img, profile) = vectorcraft_doc::decode::decode_image(kind, bytes, MAX_RASTER_ALLOC).map_err(err)?;
// A profile the decoder can't read leaves the image without one. A TIFF's profile is
// read by the TIFF reader, as before.
icc = match f.id {
@@ -1111,7 +1111,7 @@ pub fn texture_image(bytes: &[u8]) -> Result<String> {
}
None => {
let kind = craft_image_codecs::detect(&blob.bytes).ok_or_else(|| err("the image can't be read as a texture"))?;
let img = vectorcraft_render::decode_image(kind, &blob.bytes, MAX_RASTER_ALLOC).map_err(err)?.0.to_rgba8();
let img = vectorcraft_doc::decode::decode_image(kind, &blob.bytes, MAX_RASTER_ALLOC).map_err(err)?.0.to_rgba8();
LoadedTexture::from_rgba(img.width(), img.height(), img.as_raw())
}
};
+1 -1
View File
@@ -20,7 +20,7 @@ mod ink;
mod live;
mod lru;
mod paint;
pub use paint::{decode_failures, decode_image, decoded_layout, image_decodes, reduced_size};
pub use paint::{decode_failures, image_decodes, reduced_size};
mod pattern;
pub mod placed_document;
pub mod proof;
+4 -80
View File
@@ -190,83 +190,7 @@ fn drawn_format(bytes: &[u8]) -> Option<craft_image_codecs::Format> {
/// `bytes` decoded as `format` within `allowance` bytes: the pixels as stored, not turned upright,
/// as the image crate gave them.
fn decode_as(format: craft_image_codecs::Format, bytes: &[u8], allowance: u64) -> Result<image::DynamicImage, craft_image_codecs::CodecError> {
decode_image(format, bytes, allowance).map(|(img, _)| img)
}
/// `bytes` decoded as `format` within `allowance` bytes, the pixels as stored (not turned
/// upright) and as the image crate gave them ([`dynamic`]), with the ICC profile the file embeds.
/// File › Open and Place read images with it as the renderer does.
pub fn decode_image(
format: craft_image_codecs::Format,
bytes: &[u8],
allowance: u64,
) -> Result<(image::DynamicImage, Option<Vec<u8>>), craft_image_codecs::CodecError> {
let opts = craft_image_codecs::DecodeOptions {
limits: craft_image_codecs::Limits { max_width: u32::MAX, max_height: u32::MAX, max_pixels: u64::MAX, max_alloc: allowance },
keep_orientation: true,
};
let mut img = craft_image_codecs::decode_as_with(format, bytes, &opts)?;
let icc = img.icc.take();
let img = dynamic(img).ok_or_else(|| craft_image_codecs::CodecError::InvalidImage("the decoded samples don't fit the image".into()))?;
Ok((img, icc))
}
/// A decoded image as the image crate's: 8- and 16-bit gray, gray and alpha, RGB and RGBA as they
/// are, 32-bit float RGB and RGBA as they are, anything else as 8-bit RGBA.
fn dynamic(img: craft_image_codecs::Image) -> Option<image::DynamicImage> {
use craft_image_codecs::{ChannelLayout as L, SampleType as S};
use image::{DynamicImage as D, ImageBuffer as B};
let (w, h) = img.dimensions();
Some(match (img.layout(), img.sample_type()) {
(L::Gray, S::U8) => D::ImageLuma8(B::from_raw(w, h, img.into_data())?),
(L::GrayA, S::U8) => D::ImageLumaA8(B::from_raw(w, h, img.into_data())?),
(L::Rgb, S::U8) => D::ImageRgb8(B::from_raw(w, h, img.into_data())?),
(L::Rgba, S::U8) => D::ImageRgba8(B::from_raw(w, h, img.into_data())?),
(layout @ (L::Gray | L::GrayA | L::Rgb | L::Rgba), S::U16) => {
let v = img.to_u16_samples()?;
match layout {
L::Gray => D::ImageLuma16(B::from_raw(w, h, v)?),
L::GrayA => D::ImageLumaA16(B::from_raw(w, h, v)?),
L::Rgb => D::ImageRgb16(B::from_raw(w, h, v)?),
_ => D::ImageRgba16(B::from_raw(w, h, v)?),
}
}
_ => D::ImageRgba8(B::from_raw(w, h, img.to_rgba8())?),
})
}
/// The image's size and the bytes a pixel of it takes decoded ([`decode_as`]), read from its
/// header: palettes as RGB (RGBA with a transparent entry; GIF frames always RGBA), bitmaps as 8-bit
/// gray, 16-bit samples as two bytes. A PNG whose header alone is there is read from its `IHDR`;
/// a format whose header says only its size (TGA, ICO and the like) counts RGBA.
pub fn decoded_layout(bytes: &[u8], format: craft_image_codecs::Format) -> Option<(u32, u32, u64)> {
use craft_image_codecs::{Format as F, RasterColorType as T};
if let Some(i) = craft_image_codecs::inspect_raster(bytes).ok().flatten() {
let deep = i.bits_per_sample > 8 && i.color_type != T::Indexed;
let channels = match i.color_type {
_ if format == F::Gif => 4,
T::Indexed => 3 + u64::from(i.transparent_index.is_some()),
T::Bitmap => 1,
_ => u64::from(i.channels.max(1)),
};
return Some((i.width, i.height, channels * if deep { 2 } else { 1 }));
}
if format != F::Png {
return vectorcraft_doc::header_size(bytes).map(|(w, h)| (w, h, 4));
}
if bytes.get(12..16)? != b"IHDR" {
return None;
}
let be = |at: usize| Some(u32::from_be_bytes(bytes.get(at..at + 4)?.try_into().ok()?));
let (depth, color) = (*bytes.get(24)?, *bytes.get(25)?);
let channels: u64 = match color {
0 => 1,
2 | 3 => 3,
4 => 2,
6 => 4,
_ => return None,
};
Some((be(16)?, be(20)?, channels * if depth == 16 { 2 } else { 1 }))
vectorcraft_doc::decode::decode_image(format, bytes, allowance).map(|(img, _)| img)
}
/// `bytes` decoded within [`MAX_DECODE_ALLOC`], counted as RGBA: the image's size is read from its
@@ -293,8 +217,8 @@ fn decode_in_room(bytes: &[u8]) -> Result<image::DynamicImage, (DecodeError, Und
}
// Within the allowance as RGBA and as decoded, a limit the decoder meets is a file that can't
// hold the pixels its header declares: they can't be read.
let samples_fit =
decoded_layout(bytes, format).is_some_and(|(_, _, per_pixel)| (u64::from(w) * u64::from(h)).saturating_mul(per_pixel) <= allowance);
let samples_fit = vectorcraft_doc::decode::decoded_layout(bytes, format)
.is_some_and(|(_, _, per_pixel)| (u64::from(w) * u64::from(h)).saturating_mul(per_pixel) <= allowance);
decode_as(format, bytes, allowance).map_err(|e| match e {
craft_image_codecs::CodecError::LimitExceeded(m) if !samples_fit => (DecodeError::Limit(m), Undecoded::Unreadable),
e => unreadable(e.to_string()),
@@ -360,7 +284,7 @@ struct Reduction {
fn reduction(bytes: &[u8], allowance: u64) -> Option<Reduction> {
use craft_image_codecs::Format as F;
let format = drawn_format(bytes).filter(|f| matches!(f, F::Png | F::Jpeg | F::Gif | F::WebP))?;
let (w, h, per_pixel) = decoded_layout(bytes, format)?;
let (w, h, per_pixel) = vectorcraft_doc::decode::decoded_layout(bytes, format)?;
let pixels = u64::from(w) * u64::from(h);
let total_bytes = pixels.saturating_mul(per_pixel);
// An image of more pixels than the allowance has bytes (four times what it holds as RGBA) is
+49 -16
View File
@@ -939,25 +939,17 @@ fn png_takes_icc(img: &image::DynamicImage, icc: &[u8]) -> bool {
/// can read (a TIFF's read by [`vectorcraft_doc::cmyk::tiff_icc_profile`]); `None` when they
/// can't be.
fn decoded(bytes: &[u8], format: image::ImageFormat) -> Option<(image::DynamicImage, Option<Vec<u8>>)> {
use image::ImageDecoder as _;
let max = vectorcraft_doc::MAX_RASTER_ALLOC;
let mut reader = image::ImageReader::new(std::io::Cursor::new(bytes)).with_guessed_format().ok()?;
if reader.format().is_none() {
reader.set_format(format);
}
let mut limits = image::Limits::default();
limits.max_alloc = Some(max);
reader.limits(limits);
let tiff = reader.format() == Some(image::ImageFormat::Tiff);
let mut decoder = reader.into_decoder().ok()?;
let (w, h) = decoder.dimensions();
if decoder.total_bytes() > max || u64::from(w) * u64::from(h) * 4 > max {
let kind = craft_image_codecs::detect(bytes).or_else(|| format.extensions_str().iter().find_map(|e| craft_image_codecs::from_extension(e)))?;
let (w, h, per_pixel) = vectorcraft_doc::decode::decoded_layout(bytes, kind)?;
let pixels = u64::from(w) * u64::from(h);
if pixels.saturating_mul(per_pixel) > max || pixels * 4 > max {
return None;
}
// The image decoder reads a TIFF's tags within the size of its pixels, so a small TIFF's
// profile is read by the TIFF decoder itself.
let icc = if tiff { vectorcraft_doc::cmyk::tiff_icc_profile(bytes) } else { decoder.icc_profile().ok().flatten() };
Some((image::DynamicImage::from_decoder(decoder).ok()?, icc))
let (img, icc) = vectorcraft_doc::decode::decode_image(kind, bytes, max).ok()?;
// A TIFF's profile is read by the TIFF reader, as before.
let icc = if kind == craft_image_codecs::Format::Tiff { vectorcraft_doc::cmyk::tiff_icc_profile(bytes) } else { icc };
Some((img, icc))
}
/// The pixels of TIFF `bytes`, as stored, read as Open and Place read them: a TIFF with extra
@@ -1507,4 +1499,45 @@ mod tests {
)]
);
}
/// SVG import's pixels through craft-image-codecs (#778) are those the image crate decoded:
/// the same layout and samples for PNG, GIF, WebP, TIFF and BMP at each depth the image
/// crate writes, and JPEG samples within two steps.
#[test]
fn decoded_pixels_are_those_the_image_crate_read() {
use image::{DynamicImage as D, ImageFormat as F};
let rgba =
image::RgbaImage::from_fn(9, 5, |x, y| image::Rgba([(x * 29) as u8, (y * 47) as u8, ((x + 2 * y) * 9) as u8, 255 - (x * y * 6) as u8]));
let deep = image::ImageBuffer::<image::Rgba<u16>, _>::from_fn(9, 5, |x, y| {
image::Rgba([(x * 7_001) as u16, (y * 12_007) as u16, 5, 65_535 - (x * y) as u16])
});
let images = [
D::ImageRgba8(rgba.clone()),
D::ImageRgb8(D::ImageRgba8(rgba.clone()).to_rgb8()),
D::ImageLuma8(D::ImageRgba8(rgba.clone()).to_luma8()),
D::ImageLumaA8(D::ImageRgba8(rgba).to_luma_alpha8()),
D::ImageRgba16(deep.clone()),
D::ImageLuma16(D::ImageRgba16(deep).to_luma16()),
];
let mut checked = 0;
for img in &images {
for f in [F::Png, F::Gif, F::WebP, F::Tiff, F::Bmp, F::Jpeg] {
let mut bytes = Vec::new();
if img.write_to(&mut std::io::Cursor::new(&mut bytes), f).is_err() {
continue;
}
let what = format!("{f:?} {:?}", img.color());
let want = image::load_from_memory_with_format(&bytes, f).unwrap();
let (got, _) = super::decoded(&bytes, f).unwrap_or_else(|| panic!("{what}"));
let tolerance = if f == F::Jpeg { 2 * 257 } else { 0 };
if f != F::Jpeg {
assert_eq!(got.color(), want.color(), "{what}");
}
let worst = got.to_rgba16().as_raw().iter().zip(want.to_rgba16().as_raw()).map(|(a, b)| a.abs_diff(*b)).max();
assert!(worst.is_some_and(|w| w <= tolerance), "{what}: {worst:?}");
checked += 1;
}
}
assert!(checked >= 20, "{checked}");
}
}