From 810fd60f8351c526bb85e61511984b9bb944cd2a Mon Sep 17 00:00:00 2001 From: ldm0 Date: Thu, 15 Oct 2026 05:50:03 +0800 Subject: [PATCH] feat(image): preserve native raster color profiles and precision --- Cargo.lock | 2 + moli-image/Cargo.toml | 4 +- moli-image/src/budget.rs | 4 + moli-image/src/color.rs | 323 ++++++++++++++++++ moli-image/src/color_tests.rs | 215 ++++++++++++ moli-image/src/jpeg.rs | 104 +++++- moli-image/src/lib.rs | 13 +- moli-image/src/png.rs | 203 +++++++++-- moli-image/src/raster.rs | 117 +++++-- .../color_profiles/Adobe-RGB-FF0000FF.png | Bin 0 -> 562 bytes .../color_profiles/Display-P3-BB0000CC.png | Bin 0 -> 620 bytes .../Display-P3-BBBC00000000CCCC.png | Bin 0 -> 605 bytes .../color_profiles/Display-P3-FF0000FF.png | Bin 0 -> 607 bytes .../color_profiles/Generic-CMYK-FF000000.jpg | Bin 0 -> 55590 bytes .../tests/data/color_profiles/LICENSE-WPT.md | 11 + .../tests/data/color_profiles/README.md | 15 + .../data/color_profiles/sRGB-BB0000FF.png | Bin 0 -> 230 bytes .../context_bootstrap/canvas/image_bitmap.rs | 54 +-- .../canvas/image_bitmap/options.rs | 12 +- .../context_bootstrap/canvas/image_source.rs | 24 +- .../src/context_bootstrap/canvas/pixels.rs | 45 +++ .../context_host/image_resources/css.rs | 9 +- .../context_host/image_resources/decode.rs | 19 +- .../context_host/image_resources/mod.rs | 2 +- .../context_host/image_resources/state.rs | 78 ++++- .../src/script_vm/tests/canvas_image_color.js | 35 ++ .../src/script_vm/tests/canvas_image_color.rs | 36 ++ moli-renderer-v8/src/script_vm/tests/mod.rs | 1 + 28 files changed, 1210 insertions(+), 116 deletions(-) create mode 100644 moli-image/src/color.rs create mode 100644 moli-image/src/color_tests.rs create mode 100644 moli-image/tests/data/color_profiles/Adobe-RGB-FF0000FF.png create mode 100644 moli-image/tests/data/color_profiles/Display-P3-BB0000CC.png create mode 100644 moli-image/tests/data/color_profiles/Display-P3-BBBC00000000CCCC.png create mode 100644 moli-image/tests/data/color_profiles/Display-P3-FF0000FF.png create mode 100644 moli-image/tests/data/color_profiles/Generic-CMYK-FF000000.jpg create mode 100644 moli-image/tests/data/color_profiles/LICENSE-WPT.md create mode 100644 moli-image/tests/data/color_profiles/README.md create mode 100644 moli-image/tests/data/color_profiles/sRGB-BB0000FF.png create mode 100644 moli-renderer-v8/src/script_vm/tests/canvas_image_color.js create mode 100644 moli-renderer-v8/src/script_vm/tests/canvas_image_color.rs diff --git a/Cargo.lock b/Cargo.lock index 676c263b134..07dbb8f7171 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3071,9 +3071,11 @@ dependencies = [ name = "moli-image" version = "0.1.0" dependencies = [ + "color", "image", "jpeg-decoder", "jpeg-encoder", + "moxcms", "png", "thiserror", "usvg", diff --git a/moli-image/Cargo.toml b/moli-image/Cargo.toml index aff13e20c17..3ba3b93a766 100644 --- a/moli-image/Cargo.toml +++ b/moli-image/Cargo.toml @@ -5,9 +5,11 @@ edition = "2024" license = "MIT OR Apache-2.0" [dependencies] -image = { version = "0.25.10", default-features = false, features = ["gif", "webp", "bmp"] } +color = "0.3.3" +image = { version = "0.25.10", default-features = false, features = ["bmp", "gif", "webp"] } jpeg-decoder = "0.3" jpeg-encoder = "0.6" +moxcms = { version = "0.8.1", features = ["extended_range"] } png = "0.18" thiserror = "2.0.17" usvg = { version = "=0.48.1", default-features = true } diff --git a/moli-image/src/budget.rs b/moli-image/src/budget.rs index 6d68f1cb88e..4f8b27caac7 100644 --- a/moli-image/src/budget.rs +++ b/moli-image/src/budget.rs @@ -6,3 +6,7 @@ pub const MAX_ENCODED_IMAGE_BYTES: usize = 128 * 1024 * 1024; /// Paint independently bounds transient raster allocations. This codec limit /// also protects network image decode. pub const MAX_DECODED_RGBA_BYTES: usize = 128 * 1024 * 1024; + +/// Maximum retained layout surface, full precision colors and unconverted source +/// samples for one image. Renderer owners also impose an aggregate image budget. +pub(crate) const MAX_DECODED_COLOR_BYTES: usize = 256 * 1024 * 1024; diff --git a/moli-image/src/color.rs b/moli-image/src/color.rs new file mode 100644 index 00000000000..a30eb4d6017 --- /dev/null +++ b/moli-image/src/color.rs @@ -0,0 +1,323 @@ +//! Image colors retain extended sRGB until a consumer chooses its output gamut. + +use ::color::ColorSpace; +use moxcms::{ColorProfile, DataColorSpace, Layout, RenderingIntent, TransformOptions}; + +use crate::{RgbaImage, RgbaImageError, budget::MAX_DECODED_COLOR_BYTES}; + +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub enum RasterColorPrecision { + #[default] + Unorm8, + Float32, +} + +impl RasterColorPrecision { + pub(crate) fn retained_bytes_per_pixel(self) -> usize { + match self { + Self::Unorm8 => 4, + // Layout, full precision colors and up to 16-bit unconverted samples. + Self::Float32 => 4 + 4 * size_of::() + 4 * size_of::(), + } + } +} + +/// Straight-alpha extended sRGB, without clipping to an RGBA8 layout surface. +#[derive(Clone, Debug, PartialEq)] +pub struct ColorManagedRasterImage { + pub width: u32, + pub height: u32, + pub rgba: Vec, + pub unconverted: Option, +} + +#[derive(Clone, Debug, PartialEq)] +pub enum UnconvertedRasterPixels { + Unorm8(Vec), + Unorm16(Vec), +} + +#[derive(Debug, thiserror::Error)] +pub enum ColorDecodeError { + #[error(transparent)] + InvalidOutput(#[from] RgbaImageError), + #[error("unable to allocate decoded image colors")] + Allocation, + #[error("image color transformation failed: {0}")] + Transformation(#[from] moxcms::CmsError), +} + +pub(crate) enum ColorSamples { + U8(Vec), + U16(Vec), +} + +impl ColorSamples { + fn len(&self) -> usize { + match self { + Self::U8(values) => values.len(), + Self::U16(values) => values.len(), + } + } + + fn sample(&self, index: usize) -> f32 { + match self { + Self::U8(values) => f32::from(values[index]) / 255.0, + Self::U16(values) => f32::from(values[index]) / 65535.0, + } + } +} + +pub(crate) struct RawColorImage { + pub width: u32, + pub height: u32, + pub samples: ColorSamples, + pub layout: Layout, + pub profile: Option, + pub cmyk: bool, +} + +pub(crate) type DecodedColorPixels = (RgbaImage, Option); + +impl RawColorImage { + pub(crate) fn finish( + self, + convert_profile: bool, + ) -> Result { + let length = crate::rgba::checked_rgba_len(self.width, self.height)?; + let count = length / 4; + let channels = if self.cmyk { + 4 + } else { + match self.layout { + Layout::Rgb => 3, + Layout::Rgba => 4, + Layout::Gray => 1, + Layout::GrayAlpha => 2, + _ => unreachable!("only decoded RGB, gray and CMYK images are admitted"), + } + }; + if self.samples.len() != count * channels { + return Err(RgbaImageError::InvalidBufferLength { + expected: count * channels, + actual: self.samples.len(), + } + .into()); + } + let transform = self + .profile + .as_ref() + .filter(|profile| { + convert_profile + && match profile.color_space { + DataColorSpace::Cmyk => self.cmyk, + DataColorSpace::Rgb => !self.cmyk && channels >= 3, + DataColorSpace::Gray => channels <= 2, + _ => false, + } + }) + .and_then(|profile| { + // Unsupported or malformed profiles do not make valid pixels fail + // to load. The untagged fallback still handles CMYK and gray. + // ICC parametric TRCs extend their linear toe to negative + // inputs. Canvas uses the sign-preserving CSS transfer curve. + // Keep CMS output linear, then use the native CSS color space + // conversion without clipping wide-gamut negative components. + let mut destination = ColorProfile::new_srgb(); + let linear = moxcms::ToneReprCurve::Parametric(vec![1.0, 1.0, 0.0, 1.0, 0.0]); + destination.red_trc = Some(linear.clone()); + destination.green_trc = Some(linear.clone()); + destination.blue_trc = Some(linear); + destination.cicp = None; + profile + .create_transform_f32( + self.layout, + &destination, + Layout::Rgba, + TransformOptions { + rendering_intent: RenderingIntent::RelativeColorimetric, + prefer_fixed_point: false, + allow_extended_range_rgb_xyz: true, + ..Default::default() + }, + ) + .ok() + }); + if transform.is_none() + && let ColorSamples::U8(samples) = self.samples + { + // Ordinary RGBA keeps its existing zero-copy path. Untagged RGB + // and gray also need no floating-point CMS scratch buffers. + let rgba = if self.cmyk { + samples + .as_chunks::<4>() + .0 + .iter() + .flat_map(|ink| { + let black = 255 - u16::from(ink[3]); + let color = + |sample: u8| (((255 - u16::from(sample)) * black + 127) / 255) as u8; + [color(ink[0]), color(ink[1]), color(ink[2]), 255] + }) + .collect() + } else { + match self.layout { + Layout::Rgba => samples, + Layout::Rgb => samples + .as_chunks::<3>() + .0 + .iter() + .flat_map(|p| [p[0], p[1], p[2], 255]) + .collect(), + Layout::Gray => samples.into_iter().flat_map(|v| [v, v, v, 255]).collect(), + Layout::GrayAlpha => samples + .as_chunks::<2>() + .0 + .iter() + .flat_map(|p| [p[0], p[0], p[0], p[1]]) + .collect(), + _ => unreachable!("decoded image layout"), + } + }; + return Ok((RgbaImage::try_new(self.width, self.height, rgba)?, None)); + } + let retain_precision = transform.is_some() || matches!(self.samples, ColorSamples::U16(_)); + let precision = if retain_precision { + RasterColorPrecision::Float32 + } else { + RasterColorPrecision::Unorm8 + }; + let retained = count * precision.retained_bytes_per_pixel(); + if retained > MAX_DECODED_COLOR_BYTES { + return Err(RgbaImageError::BufferBudgetExceeded { + width: self.width, + height: self.height, + required: retained, + max: MAX_DECODED_COLOR_BYTES, + } + .into()); + } + let mut rgba = Vec::new(); + rgba.try_reserve_exact(length) + .map_err(|_| ColorDecodeError::Allocation)?; + let mut managed = retain_precision.then(Vec::new); + if let Some(values) = &mut managed { + values + .try_reserve_exact(length) + .map_err(|_| ColorDecodeError::Allocation)?; + } + let mut unconverted = if transform.is_some() { + if matches!(self.samples, ColorSamples::U16(_)) { + Some(UnconvertedRasterPixels::Unorm16(Vec::new())) + } else { + Some(UnconvertedRasterPixels::Unorm8(Vec::new())) + } + } else { + None + }; + match &mut unconverted { + Some(UnconvertedRasterPixels::Unorm8(values)) => values + .try_reserve_exact(length) + .map_err(|_| ColorDecodeError::Allocation)?, + Some(UnconvertedRasterPixels::Unorm16(values)) => values + .try_reserve_exact(length) + .map_err(|_| ColorDecodeError::Allocation)?, + None => {} + } + // CMS transforms have no inter-pixel state. Fixed scratch buffers keep + // a very wide image from allocating another full floating-point row. + let mut input = [0.0_f32; 4096]; + let mut output = [0.0_f32; 4096]; + for first in (0..count).step_by(1024) { + let pixels = (count - first).min(1024); + for (index, sample) in input[..pixels * channels].iter_mut().enumerate() { + *sample = self.samples.sample(first * channels + index); + } + if let Some(unconverted) = &mut unconverted { + for source in input[..pixels * channels].chunks_exact(channels) { + let alpha = if !self.cmyk && self.layout.has_alpha() { + source[channels - 1] + } else { + 1.0 + }; + let raw = if self.cmyk { + let black = 1.0 - source[3]; + [ + (1.0 - source[0]) * black, + (1.0 - source[1]) * black, + (1.0 - source[2]) * black, + alpha, + ] + } else if channels <= 2 { + [source[0], source[0], source[0], alpha] + } else { + [source[0], source[1], source[2], alpha] + }; + match unconverted { + UnconvertedRasterPixels::Unorm8(values) => { + values.extend(raw.map(|v| (v * 255.0).round() as u8)) + } + UnconvertedRasterPixels::Unorm16(values) => { + values.extend(raw.map(|v| (v * 65535.0).round() as u16)) + } + } + } + } + if let Some(transform) = &transform { + transform.transform(&input[..pixels * channels], &mut output[..pixels * 4])?; + for pixel in output[..pixels * 4].as_chunks_mut::<4>().0 { + let encoded = ::color::Srgb::from_linear_srgb([pixel[0], pixel[1], pixel[2]]); + pixel[..3].copy_from_slice(&encoded); + } + } else { + for (source, target) in input[..pixels * channels] + .chunks_exact(channels) + .zip(output[..pixels * 4].as_chunks_mut::<4>().0) + { + if self.cmyk { + let black = 1.0 - source[3]; + target.copy_from_slice(&[ + (1.0 - source[0]) * black, + (1.0 - source[1]) * black, + (1.0 - source[2]) * black, + 1.0, + ]); + } else if channels <= 2 { + target[..3].fill(source[0]); + } else { + target[..3].copy_from_slice(&source[..3]); + } + } + } + for (source, target) in input[..pixels * channels] + .chunks_exact(channels) + .zip(output[..pixels * 4].as_chunks_mut::<4>().0) + { + // A CMYK K sample is ink, never an alpha channel. + target[3] = if !self.cmyk && self.layout.has_alpha() { + source[channels - 1] + } else { + 1.0 + }; + rgba.extend( + target + .iter() + .map(|value| (value.clamp(0.0, 1.0) * 255.0).round() as u8), + ); + } + if let Some(values) = &mut managed { + values.extend_from_slice(&output[..pixels * 4]); + } + } + let image = RgbaImage::try_new(self.width, self.height, rgba)?; + Ok(( + image, + managed.map(|rgba| ColorManagedRasterImage { + width: self.width, + height: self.height, + rgba, + unconverted, + }), + )) + } +} diff --git a/moli-image/src/color_tests.rs b/moli-image/src/color_tests.rs new file mode 100644 index 00000000000..fa1e413a21e --- /dev/null +++ b/moli-image/src/color_tests.rs @@ -0,0 +1,215 @@ +use std::borrow::Cow; + +use crate::*; + +const P3: &[u8] = include_bytes!("../tests/data/color_profiles/Display-P3-FF0000FF.png"); +const P3_ALPHA: &[u8] = include_bytes!("../tests/data/color_profiles/Display-P3-BB0000CC.png"); +const P3_16: &[u8] = include_bytes!("../tests/data/color_profiles/Display-P3-BBBC00000000CCCC.png"); + +fn png_with_info(info: ::png::Info<'_>, pixels: &[u8]) -> Vec { + let mut bytes = Vec::new(); + let cicp = info.coding_independent_code_points; + let mut writer = ::png::Encoder::with_info(&mut bytes, info) + .unwrap() + .write_header() + .unwrap(); + // png 0.18 reads cICP but its header encoder does not emit this field. + if let Some(cicp) = cicp { + writer + .write_chunk( + ::png::chunk::cICP, + &[ + cicp.color_primaries, + cicp.transfer_function, + cicp.matrix_coefficients, + u8::from(cicp.is_video_full_range_image), + ], + ) + .unwrap(); + } + writer.write_image_data(pixels).unwrap(); + writer.finish().unwrap(); + bytes +} + +#[test] +fn image_profiles_preserve_extended_gamut_alpha_and_unconverted_samples() { + let srgb = decode_raster_image(include_bytes!( + "../tests/data/color_profiles/sRGB-BB0000FF.png" + )) + .unwrap(); + assert_eq!(&srgb.image.rgba[..4], &[187, 0, 0, 255]); + let adobe = decode_raster_image(include_bytes!( + "../tests/data/color_profiles/Adobe-RGB-FF0000FF.png" + )) + .unwrap(); + assert!(adobe.color_managed.unwrap().rgba[0] > 1.0); + let red = decode_raster_image(P3).unwrap(); + let native = red.color_managed.unwrap(); + assert!(native.rgba[0] > 1.0); + assert!(native.rgba[1] < 0.0 && native.rgba[2] < 0.0); + for (actual, expected) in native.rgba[..3].iter().zip([1.0931, -0.2267, -0.1501]) { + assert!( + (actual - expected).abs() < 0.002, + "extended sRGB {:?}", + &native.rgba[..3] + ); + } + assert_eq!(native.rgba[3], 1.0); + assert_eq!(&red.image.rgba[..4], &[255, 0, 0, 255]); + for bytes in [P3_ALPHA, P3_16] { + let decoded = decode_raster_image(bytes).unwrap(); + assert_eq!(&decoded.image.rgba[..4], &[205, 0, 0, 204]); + let native = decoded.color_managed.unwrap(); + assert!((native.rgba[3] - 0.8).abs() < 0.0001); + assert!(native.unconverted.is_some()); + let raw = decode_raster_image_with_color_conversion(bytes, ColorProfileConversion::Ignore) + .unwrap(); + assert_eq!(&raw.image.rgba[..4], &[187, 0, 0, 204]); + assert!( + probe_raster_image(bytes).unwrap().decoded_byte_len() >= 4 * (4 + 4 * size_of::()) + ); + } +} + +#[test] +fn image_profile_lut_converts_cmyk_inks_without_treating_black_as_alpha() { + let bytes = include_bytes!("../tests/data/color_profiles/Generic-CMYK-FF000000.jpg"); + let decoded = decode_raster_image(bytes).unwrap(); + for (actual, expected) in decoded.image.rgba[..4].iter().zip([0_u8, 163, 218, 255]) { + assert!( + actual.abs_diff(expected) <= 2, + "actual {:?}", + &decoded.image.rgba[..4] + ); + } + assert_eq!(decoded.color_managed.unwrap().rgba[3], 1.0); + let raw = + decode_raster_image_with_color_conversion(bytes, ColorProfileConversion::Ignore).unwrap(); + // JPEG quantization leaves 254 in the cyan sample of this fixture. + let inks = jpeg_decoder::Decoder::new(std::io::Cursor::new(bytes)) + .decode() + .unwrap(); + assert_eq!(&inks[..4], &[254, 0, 0, 0]); + assert_eq!(&raw.image.rgba[..4], &[1, 255, 255, 255]); +} + +#[test] +fn image_png_sixteen_bit_samples_keep_low_bits_and_straight_alpha() { + let mut info = ::png::Info::with_size(1, 1); + info.color_type = ::png::ColorType::Rgba; + info.bit_depth = ::png::BitDepth::Sixteen; + let values = [0x1234_u16, 0x5678, 0x9abc, 0xdef0]; + let bytes = png_with_info( + info, + &values + .into_iter() + .flat_map(u16::to_be_bytes) + .collect::>(), + ); + let decoded = decode_raster_image(&bytes).unwrap(); + let native = decoded.color_managed.unwrap(); + for (actual, value) in native.rgba.into_iter().zip(values) { + assert!((actual - f32::from(value) / 65535.0).abs() < 0.000001); + } +} + +#[test] +fn image_png_gamma_applies_to_gray_colors_without_changing_alpha() { + let mut info = ::png::Info::with_size(1, 1); + info.color_type = ::png::ColorType::GrayscaleAlpha; + info.bit_depth = ::png::BitDepth::Eight; + info.source_gamma = Some(::png::ScaledFloat::new(1.0)); + let bytes = png_with_info(info, &[128, 64]); + let reader = ::png::Decoder::new(std::io::Cursor::new(&bytes)) + .read_info() + .unwrap(); + assert_eq!( + reader.info().gama_chunk.map(::png::ScaledFloat::into_value), + Some(1.0) + ); + let decoded = decode_raster_image(&bytes).unwrap(); + assert_eq!(&decoded.image.rgba[..4], &[188, 188, 188, 64]); + + let raw = + decode_raster_image_with_color_conversion(&bytes, ColorProfileConversion::Ignore).unwrap(); + assert_eq!(&raw.image.rgba[..4], &[128, 128, 128, 64]); +} + +#[test] +fn image_invalid_icc_profiles_leave_valid_png_pixels_readable() { + let mut info = ::png::Info::with_size(1, 1); + info.color_type = ::png::ColorType::Rgba; + info.bit_depth = ::png::BitDepth::Eight; + info.icc_profile = Some(Cow::Borrowed(b"invalid ICC profile")); + let bytes = png_with_info(info, &[23, 74, 145, 211]); + let decoded = decode_raster_image(&bytes).unwrap(); + assert_eq!(&decoded.image.rgba[..4], &[23, 74, 145, 211]); + assert!(decoded.color_managed.is_none()); +} + +#[test] +fn image_png_cicp_takes_precedence_over_icc_and_converts_neutral_gray() { + let mut info = ::png::Info::with_size(1, 1); + info.color_type = ::png::ColorType::Rgba; + info.bit_depth = ::png::BitDepth::Eight; + info.icc_profile = Some(Cow::Owned( + moxcms::ColorProfile::new_srgb().encode().unwrap(), + )); + info.coding_independent_code_points = Some(::png::CodingIndependentCodePoints { + color_primaries: 12, + transfer_function: 13, + matrix_coefficients: 0, + is_video_full_range_image: true, + }); + let red = decode_raster_image(&png_with_info(info, &[255, 0, 0, 255])) + .unwrap() + .color_managed + .unwrap(); + assert!(red.rgba[0] > 1.0 && red.rgba[1] < 0.0); + let mut info = ::png::Info::with_size(1, 1); + info.color_type = ::png::ColorType::GrayscaleAlpha; + info.bit_depth = ::png::BitDepth::Eight; + info.coding_independent_code_points = Some(::png::CodingIndependentCodePoints { + color_primaries: 1, + transfer_function: 8, + matrix_coefficients: 0, + is_video_full_range_image: true, + }); + let gray = decode_raster_image(&png_with_info(info, &[128, 64])).unwrap(); + assert_eq!(&gray.image.rgba[..4], &[188, 188, 188, 64]); +} + +#[test] +fn image_jpeg_late_icc_cannot_bypass_color_plane_admission() { + let image = RgbaImage::try_new(1, 1, vec![155, 27, 26, 255]).unwrap(); + let bytes = encode_jpeg(&image, 100).unwrap().bytes; + let profile = moxcms::ColorProfile::new_display_p3().encode().unwrap(); + let mut payload = b"ICC_PROFILE\0\x01\x01".to_vec(); + payload.extend(profile); + let mut marker = vec![0xff, 0xe2]; + marker.extend(u16::try_from(payload.len() + 2).unwrap().to_be_bytes()); + marker.extend(payload); + assert_eq!(&bytes[bytes.len() - 2..], &[0xff, 0xd9]); + let mut late = bytes.clone(); + late.splice(late.len() - 2..late.len() - 2, marker.iter().copied()); + let mut decoder = jpeg_decoder::Decoder::new(std::io::Cursor::new(&late)); + decoder.decode().unwrap(); + assert!(decoder.icc_profile().is_some()); + let decoded = decode_raster_image(&late).unwrap(); + assert_eq!( + decoded.metadata.color_precision, + RasterColorPrecision::Unorm8 + ); + assert!(decoded.color_managed.is_none()); + assert_eq!(decoded.image, decode_raster_image(&bytes).unwrap().image); + + let mut header = bytes; + header.splice(2..2, marker); + let decoded = decode_raster_image(&header).unwrap(); + assert_eq!( + decoded.metadata.color_precision, + RasterColorPrecision::Float32 + ); + assert!(decoded.color_managed.is_some()); +} diff --git a/moli-image/src/jpeg.rs b/moli-image/src/jpeg.rs index a8825e2a107..3e06bcac36c 100644 --- a/moli-image/src/jpeg.rs +++ b/moli-image/src/jpeg.rs @@ -38,6 +38,8 @@ pub enum JpegDecodeError { UnsupportedPixelFormat { format: &'static str }, #[error(transparent)] InvalidOutput(#[from] RgbaImageError), + #[error(transparent)] + Color(#[from] crate::ColorDecodeError), } pub fn encode_jpeg(image: &RgbaImage, quality: u8) -> Result { @@ -75,39 +77,111 @@ pub fn encode_jpeg(image: &RgbaImage, quality: u8) -> Result Result { + decode_jpeg_colors(bytes, true).map(|(image, _)| image) +} + +pub(crate) fn decode_jpeg_colors( + bytes: &[u8], + convert_profile: bool, +) -> Result { + use crate::color::{ColorSamples, RawColorImage}; let mut decoder = jpeg_decoder::Decoder::new(Cursor::new(bytes)); decoder.set_max_decoding_buffer_size(MAX_DECODED_RGBA_BYTES); let decoded = decoder.decode()?; let info = decoder.info().ok_or(JpegDecodeError::MissingImageInfo)?; - let rgba = match info.pixel_format { - jpeg_decoder::PixelFormat::L8 => decoded - .into_iter() - .flat_map(|value| [value, value, value, 255]) - .collect(), - jpeg_decoder::PixelFormat::RGB24 => decoded - .as_chunks::<3>() - .0 - .iter() - .flat_map(|pixel| [pixel[0], pixel[1], pixel[2], 255]) - .collect(), + // Use the same admission condition as the metadata probe. The decoder + // collects APP2 markers even after scan data; a late-only profile must not + // materialize color planes that the resource owner could not reserve. + let profile = if has_icc_header(bytes) { + decoder + .icc_profile() + .and_then(|bytes| moxcms::ColorProfile::new_from_slice(&bytes).ok()) + } else { + None + }; + let (layout, samples, cmyk) = match info.pixel_format { + jpeg_decoder::PixelFormat::L8 => (moxcms::Layout::Gray, ColorSamples::U8(decoded), false), + jpeg_decoder::PixelFormat::RGB24 => (moxcms::Layout::Rgb, ColorSamples::U8(decoded), false), jpeg_decoder::PixelFormat::L16 => { return Err(JpegDecodeError::UnsupportedPixelFormat { format: "L16" }); } jpeg_decoder::PixelFormat::CMYK32 => { - return Err(JpegDecodeError::UnsupportedPixelFormat { format: "CMYK32" }); + (moxcms::Layout::Rgba, ColorSamples::U8(decoded), true) } }; - RgbaImage::try_new(u32::from(info.width), u32::from(info.height), rgba).map_err(Into::into) + Ok(RawColorImage { + width: u32::from(info.width), + height: u32::from(info.height), + samples, + layout, + profile, + cmyk, + } + .finish(convert_profile)?) } -pub(crate) fn jpeg_dimensions(bytes: &[u8]) -> Result<(u32, u32), JpegDecodeError> { +pub(crate) fn jpeg_metadata( + bytes: &[u8], +) -> Result<(u32, u32, crate::RasterColorPrecision), JpegDecodeError> { let mut decoder = jpeg_decoder::Decoder::new(Cursor::new(bytes)); decoder.set_max_decoding_buffer_size(MAX_DECODED_RGBA_BYTES); decoder.read_info()?; let info = decoder.info().ok_or(JpegDecodeError::MissingImageInfo)?; let dimensions = (u32::from(info.width), u32::from(info.height)); crate::rgba::checked_rgba_len(dimensions.0, dimensions.1)?; - Ok(dimensions) + let high_precision = matches!( + info.pixel_format, + jpeg_decoder::PixelFormat::L16 | jpeg_decoder::PixelFormat::CMYK32 + ) || has_icc_header(bytes); + Ok(( + dimensions.0, + dimensions.1, + if high_precision { + crate::RasterColorPrecision::Float32 + } else { + crate::RasterColorPrecision::Unorm8 + }, + )) +} + +fn has_icc_header(bytes: &[u8]) -> bool { + let mut remaining = bytes.get(2..).unwrap_or_default(); + while let Some(marker) = remaining.strip_prefix(&[0xff]) { + let Some((&kind, tail)) = marker.split_first() else { + return false; + }; + if kind == 0xff { + remaining = marker; + continue; + } + if kind == 0xda || kind == 0xd9 { + break; + } + if kind == 0x01 || (0xd0..=0xd8).contains(&kind) { + remaining = tail; + continue; + } + let Some(length) = tail + .get(..2) + .map(|value| usize::from(u16::from_be_bytes([value[0], value[1]]))) + else { + return false; + }; + if length < 2 { + return false; + } + let Some(segment) = tail.get(2..length) else { + return false; + }; + if kind == 0xe2 && segment.starts_with(b"ICC_PROFILE\0") { + return true; + } + let Some(next) = tail.get(length..) else { + return false; + }; + remaining = next; + } + false } #[cfg(test)] diff --git a/moli-image/src/lib.rs b/moli-image/src/lib.rs index e0d8b24882a..e63e892ec01 100644 --- a/moli-image/src/lib.rs +++ b/moli-image/src/lib.rs @@ -6,6 +6,9 @@ mod bounded; mod budget; +mod color; +#[cfg(test)] +mod color_tests; mod jpeg; mod png; mod raster; @@ -13,15 +16,19 @@ mod rgba; mod svg; pub use budget::{MAX_DECODED_RGBA_BYTES, MAX_ENCODED_IMAGE_BYTES}; +pub use color::{ + ColorDecodeError, ColorManagedRasterImage, RasterColorPrecision, UnconvertedRasterPixels, +}; pub use jpeg::{EncodedJpeg, JpegDecodeError, JpegEncodeError, decode_jpeg, encode_jpeg}; pub use png::{ EncodedPng, PngDecodeError, PngEncodeError, PngEncodeOptions, decode_png, encode_png, encode_png_rgba8, encode_png_rgba8_with_options, encode_png_with_options, }; pub use raster::{ - DecodedRasterImage, RasterDecodeError, RasterImageFormat, RasterImageMetadata, - decode_raster_image, decode_raster_image_with_metadata, probe_raster_image, - raster_image_dimensions, supports_image_mime_essence, + ColorProfileConversion, DecodedRasterImage, RasterDecodeError, RasterImageFormat, + RasterImageMetadata, decode_raster_image, decode_raster_image_with_color_conversion, + decode_raster_image_with_metadata, probe_raster_image, raster_image_dimensions, + supports_image_mime_essence, }; pub use rgba::{RgbaImage, RgbaImageError}; pub use svg::{ diff --git a/moli-image/src/png.rs b/moli-image/src/png.rs index bedeaba6041..0230d0b1017 100644 --- a/moli-image/src/png.rs +++ b/moli-image/src/png.rs @@ -34,6 +34,8 @@ pub enum PngDecodeError { Decoding(#[from] png::DecodingError), #[error(transparent)] InvalidOutput(#[from] RgbaImageError), + #[error(transparent)] + Color(#[from] crate::ColorDecodeError), #[error("PNG decoder produced unsupported color type {color_type:?}")] UnsupportedColorType { color_type: png::ColorType }, } @@ -109,51 +111,91 @@ pub fn encode_png_rgba8_with_options( } pub fn decode_png(bytes: &[u8]) -> Result { + decode_png_colors(bytes, true).map(|(image, _)| image) +} + +pub(crate) fn decode_png_colors( + bytes: &[u8], + convert_profile: bool, +) -> Result { + use crate::color::{ColorSamples, RawColorImage}; let mut decoder = png::Decoder::new_with_limits( Cursor::new(bytes), png::Limits { bytes: MAX_DECODED_RGBA_BYTES, }, ); - decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16); + decoder.set_transformations(png::Transformations::EXPAND); let mut reader = decoder.read_info()?; let (width, height) = (reader.info().width, reader.info().height); checked_rgba_len(width, height)?; - let output_buffer_size = reader + let cicp = cicp_profile(reader.info()); + let expand_gray = cicp.is_some(); + let profile = cicp.or_else(|| color_profile(reader.info())); + let size = reader .output_buffer_size() .ok_or(RgbaImageError::BufferLengthOverflow { width, height })?; - let mut decoded = vec![0; output_buffer_size]; + let mut decoded = vec![0; size]; let output = reader.next_frame(&mut decoded)?; decoded.truncate(output.buffer_size()); - - let rgba = match output.color_type { - png::ColorType::Rgba => decoded, - png::ColorType::Rgb => decoded - .as_chunks::<3>() - .0 - .iter() - .flat_map(|pixel| [pixel[0], pixel[1], pixel[2], 255]) - .collect(), - png::ColorType::Grayscale => decoded - .into_iter() - .flat_map(|value| [value, value, value, 255]) - .collect(), - png::ColorType::GrayscaleAlpha => decoded - .as_chunks::<2>() - .0 - .iter() - .flat_map(|pixel| [pixel[0], pixel[0], pixel[0], pixel[1]]) - .collect(), - png::ColorType::Indexed => { - return Err(PngDecodeError::UnsupportedColorType { - color_type: output.color_type, - }); + let mut layout = match output.color_type { + png::ColorType::Rgb => moxcms::Layout::Rgb, + png::ColorType::Rgba => moxcms::Layout::Rgba, + png::ColorType::Grayscale => moxcms::Layout::Gray, + png::ColorType::GrayscaleAlpha => moxcms::Layout::GrayAlpha, + color_type @ png::ColorType::Indexed => { + return Err(PngDecodeError::UnsupportedColorType { color_type }); } }; - RgbaImage::try_new(output.width, output.height, rgba).map_err(Into::into) + let mut samples = if output.bit_depth == png::BitDepth::Sixteen { + ColorSamples::U16( + decoded + .as_chunks::<2>() + .0 + .iter() + .map(|value| u16::from_be_bytes(*value)) + .collect(), + ) + } else { + ColorSamples::U8(decoded) + }; + if expand_gray && matches!(layout, moxcms::Layout::Gray | moxcms::Layout::GrayAlpha) { + // cICP describes RGB colorimetry even when PNG stores neutral gray. + let channels = if layout == moxcms::Layout::GrayAlpha { + 2 + } else { + 1 + }; + samples = match samples { + ColorSamples::U8(values) => ColorSamples::U8( + values + .chunks_exact(channels) + .flat_map(|p| [p[0], p[0], p[0], if channels == 2 { p[1] } else { 255 }]) + .collect(), + ), + ColorSamples::U16(values) => ColorSamples::U16( + values + .chunks_exact(channels) + .flat_map(|p| [p[0], p[0], p[0], if channels == 2 { p[1] } else { 65535 }]) + .collect(), + ), + }; + layout = moxcms::Layout::Rgba; + } + Ok(RawColorImage { + width, + height, + samples, + layout, + profile, + cmyk: false, + } + .finish(convert_profile)?) } -pub(crate) fn png_dimensions(bytes: &[u8]) -> Result<(u32, u32), PngDecodeError> { +pub(crate) fn png_metadata( + bytes: &[u8], +) -> Result<(u32, u32, crate::RasterColorPrecision), PngDecodeError> { let decoder = png::Decoder::new_with_limits( Cursor::new(bytes), png::Limits { @@ -161,9 +203,108 @@ pub(crate) fn png_dimensions(bytes: &[u8]) -> Result<(u32, u32), PngDecodeError> }, ); let reader = decoder.read_info()?; - let dimensions = (reader.info().width, reader.info().height); - checked_rgba_len(dimensions.0, dimensions.1)?; - Ok(dimensions) + let info = reader.info(); + checked_rgba_len(info.width, info.height)?; + let high_precision = info.bit_depth == png::BitDepth::Sixteen + || info.icc_profile.is_some() + || info.coding_independent_code_points.is_some() + || (info.srgb.is_none() && (info.gama_chunk.is_some() || info.chrm_chunk.is_some())); + Ok(( + info.width, + info.height, + if high_precision { + crate::RasterColorPrecision::Float32 + } else { + crate::RasterColorPrecision::Unorm8 + }, + )) +} + +fn cicp_profile(info: &png::Info<'_>) -> Option { + if let Some(cicp) = info.coding_independent_code_points + && cicp.matrix_coefficients == 0 + && cicp.is_video_full_range_image + && let (Ok(color_primaries), Ok(transfer_characteristics), Ok(matrix_coefficients)) = ( + moxcms::CicpColorPrimaries::try_from(cicp.color_primaries), + moxcms::TransferCharacteristics::try_from(cicp.transfer_function), + moxcms::MatrixCoefficients::try_from(cicp.matrix_coefficients), + ) + && moxcms::ColorPrimaries::try_from(color_primaries).is_ok() + && moxcms::ToneReprCurve::try_from(transfer_characteristics).is_ok() + { + return Some(moxcms::ColorProfile::new_from_cicp(moxcms::CicpProfile { + color_primaries, + transfer_characteristics, + matrix_coefficients, + full_range: true, + })); + } + None +} + +fn color_profile(info: &png::Info<'_>) -> Option { + use moxcms::{Chromaticity, ColorPrimaries, ColorProfile, ToneReprCurve, XyY}; + if let Some(profile) = info + .icc_profile + .as_deref() + .and_then(|bytes| ColorProfile::new_from_slice(bytes).ok()) + { + return Some(profile); + } + if info.srgb.is_some() || (info.gama_chunk.is_none() && info.chrm_chunk.is_none()) { + return None; + } + let gray = matches!( + info.color_type, + png::ColorType::Grayscale | png::ColorType::GrayscaleAlpha + ); + let mut profile = if gray { + let mut profile = ColorProfile::new_gray_with_gamma(1.0); + profile.gray_trc = ColorProfile::new_srgb().red_trc; + profile + } else { + ColorProfile::new_srgb() + }; + profile.cicp = None; + if let Some(gamma) = info + .gama_chunk + .map(png::ScaledFloat::into_value) + .filter(|gamma| *gamma > 0.0) + { + let curve = ToneReprCurve::Parametric(vec![1.0 / gamma]); + if gray { + profile.gray_trc = Some(curve); + } else { + profile.red_trc = Some(curve.clone()); + profile.green_trc = Some(curve.clone()); + profile.blue_trc = Some(curve); + } + } + if !gray && let Some(chroma) = info.chrm_chunk { + let point = |(x, y): (png::ScaledFloat, png::ScaledFloat)| { + Chromaticity::new(x.into_value(), y.into_value()) + }; + let white = point(chroma.white); + if white.y > 0.0 + && [chroma.red, chroma.green, chroma.blue] + .iter() + .all(|(_, y)| y.into_value() > 0.0) + { + let white = XyY::new(f64::from(white.x), f64::from(white.y), 1.0); + let primaries = ColorPrimaries { + red: point(chroma.red), + green: point(chroma.green), + blue: point(chroma.blue), + }; + if ColorProfile::colorants_matrix(white, primaries) + .determinant() + .is_some_and(|value| value.is_finite()) + { + profile.update_rgb_colorimetry(white, primaries); + } + } + } + Some(profile) } #[cfg(test)] diff --git a/moli-image/src/raster.rs b/moli-image/src/raster.rs index 0e40ef820c5..714f95af3e7 100644 --- a/moli-image/src/raster.rs +++ b/moli-image/src/raster.rs @@ -1,10 +1,12 @@ use std::io::{BufReader, Cursor}; -use image::{ImageFormat, ImageReader, Limits}; +use image::{DynamicImage, ImageDecoder, ImageFormat, ImageReader, Limits}; use crate::{ - JpegDecodeError, MAX_DECODED_RGBA_BYTES, MAX_ENCODED_IMAGE_BYTES, PngDecodeError, RgbaImage, - RgbaImageError, decode_jpeg, decode_png, jpeg::jpeg_dimensions, png::png_dimensions, + ColorManagedRasterImage, JpegDecodeError, MAX_DECODED_RGBA_BYTES, MAX_ENCODED_IMAGE_BYTES, + PngDecodeError, RasterColorPrecision, RgbaImage, RgbaImageError, + jpeg::{decode_jpeg_colors, jpeg_metadata}, + png::{decode_png_colors, png_metadata}, }; /// Static raster formats admitted by the HTML image pipeline. @@ -55,20 +57,30 @@ pub struct RasterImageMetadata { pub format: RasterImageFormat, pub width: u32, pub height: u32, + pub color_precision: RasterColorPrecision, } impl RasterImageMetadata { - /// Returns the validated RGBA8 allocation required by this image. + /// Retained layout pixels plus any high precision Canvas colors. pub fn decoded_byte_len(self) -> usize { - crate::rgba::checked_rgba_len(self.width, self.height) - .expect("raster metadata is validated before construction") + let rgba = crate::rgba::checked_rgba_len(self.width, self.height) + .expect("raster metadata is validated before construction"); + rgba / 4 * self.color_precision.retained_bytes_per_pixel() } } -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq)] pub struct DecodedRasterImage { pub metadata: RasterImageMetadata, pub image: RgbaImage, + pub color_managed: Option, +} + +#[derive(Clone, Copy, Default)] +pub enum ColorProfileConversion { + #[default] + Apply, + Ignore, } #[derive(Debug, thiserror::Error)] @@ -102,6 +114,8 @@ pub enum RasterDecodeError { }, #[error(transparent)] InvalidOutput(#[from] RgbaImageError), + #[error(transparent)] + Color(#[from] crate::ColorDecodeError), } pub fn probe_raster_image(bytes: &[u8]) -> Result { @@ -109,23 +123,43 @@ pub fn probe_raster_image(bytes: &[u8]) -> Result png_dimensions(bytes)?, - RasterImageFormat::Jpeg => jpeg_dimensions(bytes)?, + let (width, height, color_precision) = match admitted { + RasterImageFormat::Png => png_metadata(bytes)?, + RasterImageFormat::Jpeg => jpeg_metadata(bytes)?, RasterImageFormat::Gif | RasterImageFormat::WebP | RasterImageFormat::Bmp => { let mut reader = ImageReader::with_format(BufReader::new(Cursor::new(bytes)), format); reader.limits(decode_limits()); - reader - .into_dimensions() + let mut decoder = reader.into_decoder().map_err(RasterDecodeError::Metadata)?; + let (width, height) = decoder.dimensions(); + let color_precision = if decoder + .icc_profile() .map_err(RasterDecodeError::Metadata)? + .is_some() + { + RasterColorPrecision::Float32 + } else { + RasterColorPrecision::Unorm8 + }; + (width, height, color_precision) } }; - crate::rgba::checked_rgba_len(width, height)?; - Ok(RasterImageMetadata { + let metadata = RasterImageMetadata { format: admitted, width, height, - }) + color_precision, + }; + crate::rgba::checked_rgba_len(width, height)?; + if metadata.decoded_byte_len() > crate::budget::MAX_DECODED_COLOR_BYTES { + return Err(RgbaImageError::BufferBudgetExceeded { + width, + height, + required: metadata.decoded_byte_len(), + max: crate::budget::MAX_DECODED_COLOR_BYTES, + } + .into()); + } + Ok(metadata) } /// Reads encoded raster dimensions without allocating or decoding an RGBA surface. @@ -143,17 +177,33 @@ pub fn decode_raster_image(bytes: &[u8]) -> Result Result { + decode_raster(bytes, probe_raster_image(bytes)?, conversion) +} + /// Decodes pixels after a caller has already probed the same immutable byte /// buffer. This lets resource owners reserve aggregate decoded-byte budget /// before allocating RGBA without parsing metadata a second time. pub fn decode_raster_image_with_metadata( bytes: &[u8], metadata: RasterImageMetadata, +) -> Result { + decode_raster(bytes, metadata, ColorProfileConversion::Apply) +} + +fn decode_raster( + bytes: &[u8], + metadata: RasterImageMetadata, + conversion: ColorProfileConversion, ) -> Result { check_encoded_budget(bytes)?; - let image = match metadata.format { - RasterImageFormat::Png => decode_png(bytes)?, - RasterImageFormat::Jpeg => decode_jpeg(bytes)?, + let convert_profile = matches!(conversion, ColorProfileConversion::Apply); + let (image, color_managed) = match metadata.format { + RasterImageFormat::Png => decode_png_colors(bytes, convert_profile)?, + RasterImageFormat::Jpeg => decode_jpeg_colors(bytes, convert_profile)?, format @ (RasterImageFormat::Gif | RasterImageFormat::WebP | RasterImageFormat::Bmp) => { let image_format = match format { RasterImageFormat::Gif => ImageFormat::Gif, @@ -164,11 +214,25 @@ pub fn decode_raster_image_with_metadata( let mut reader = ImageReader::with_format(BufReader::new(Cursor::new(bytes)), image_format); reader.limits(decode_limits()); - let decoded = reader - .decode() + let mut decoder = reader + .into_decoder() + .map_err(|source| RasterDecodeError::Image { format, source })?; + let profile = decoder + .icc_profile() + .map_err(|source| RasterDecodeError::Image { format, source })? + .and_then(|bytes| moxcms::ColorProfile::new_from_slice(&bytes).ok()); + let decoded = DynamicImage::from_decoder(decoder) .map_err(|source| RasterDecodeError::Image { format, source })?; let rgba = decoded.into_rgba8(); - RgbaImage::try_new(rgba.width(), rgba.height(), rgba.into_raw())? + crate::color::RawColorImage { + width: rgba.width(), + height: rgba.height(), + samples: crate::color::ColorSamples::U8(rgba.into_raw()), + layout: moxcms::Layout::Rgba, + profile, + cmyk: false, + } + .finish(convert_profile)? } }; if (image.width, image.height) != (metadata.width, metadata.height) { @@ -179,7 +243,11 @@ pub fn decode_raster_image_with_metadata( actual_height: image.height, }); } - Ok(DecodedRasterImage { metadata, image }) + Ok(DecodedRasterImage { + metadata, + image, + color_managed, + }) } fn check_encoded_budget(bytes: &[u8]) -> Result<(), RasterDecodeError> { @@ -223,6 +291,7 @@ mod tests { format: RasterImageFormat::Png, width: 2, height: 2, + color_precision: RasterColorPrecision::Unorm8, } ); assert_eq!(raster_image_dimensions(&encoded.bytes).unwrap(), (2, 2)); @@ -314,6 +383,7 @@ mod tests { format: RasterImageFormat::Bmp, width: 2, height: 2, + color_precision: RasterColorPrecision::Unorm8, } ); assert_eq!(metadata.decoded_byte_len(), 16); @@ -388,6 +458,7 @@ mod tests { format: RasterImageFormat::Jpeg, width: 2, height: 2, + color_precision: RasterColorPrecision::Unorm8, } ); let decoded_jpeg = decode_raster_image(&jpeg.bytes).unwrap(); @@ -403,6 +474,7 @@ mod tests { format: RasterImageFormat::Gif, width: 1, height: 1, + color_precision: RasterColorPrecision::Unorm8, } ); let decoded_gif = decode_raster_image(gif).unwrap(); @@ -418,6 +490,7 @@ mod tests { format: RasterImageFormat::WebP, width: 2, height: 2, + color_precision: RasterColorPrecision::Unorm8, } ); assert_eq!(decode_raster_image(&webp).unwrap().image, sample()); diff --git a/moli-image/tests/data/color_profiles/Adobe-RGB-FF0000FF.png b/moli-image/tests/data/color_profiles/Adobe-RGB-FF0000FF.png new file mode 100644 index 0000000000000000000000000000000000000000..3222c5e26f3259761fae589ae0c0df20289ecd1d GIT binary patch literal 562 zcmeAS@N?(olHy`uVBq!ia0vp^Od!n23?w}&=BG0-Fe+v`I|pPYCo?c;OiWHlFe)f1 zEJ_thNH}p;Ta&A(JgB3iCn#b6fddB*oK-lJa3*2yjF^}Q5&{nnGq6@!+;8 zo0~vwq3oUtj2kB_yir#u6TBeo@J)QeuM&gVoy<9WExOD})0c!byh$xMr@uny zl+SsMKm#KKgMb2`lm1?z9P4!SJkRQeeK_NNPG9SUzL$=tFXO7#9sE2jid>G0%Mvp( zGZ%U;+Rw=pVB-)mpZVa!(;8)Lifs%hm%63~s3}i2Otd@HV=2VL^UqsSBI2LI5uYka z39%Oj1|R%gJ61{>8F0KXHh43enc?vIfPA4#Wfy^ArjYCrEal|aUB>72|ykT1Eac$IwB3>7$fx*+& K&t;ucLK6Tqud-19 literal 0 HcmV?d00001 diff --git a/moli-image/tests/data/color_profiles/Display-P3-BB0000CC.png b/moli-image/tests/data/color_profiles/Display-P3-BB0000CC.png new file mode 100644 index 0000000000000000000000000000000000000000..2036aeae25ff79f0e9be1e1dfe3e249662f55ff6 GIT binary patch literal 620 zcmeAS@N?(olHy`uVBq!ia0vp^Od!n23?w}&=BG0-F#2UWI|pPYCo?c;OiWHl2=dg? zIFXo`kZ|IxwkB6mc~D13Pf$Yri35Bsdw7y~xH?ZBW$j~Rv~y79F_03i*?sH)$0GgL zO=qlBO}Bb(jXQ8XY1xOX-RoUu8(dw?ux`qgM=1(_**k(Kb9Z@3NJs=XHK%(PCGdCHQoDGeFV|1_OibmmKs5UYEF#!{_{XR5DXYDh>*%rZ7; zI3%;^SFwVHj^xpE3P)zWH#WHO?mrOZwamC)$JW;CFgM0pFiA>`ho|Wd50848n2MNc zQ|pYz8JfDijSnvuv9aCrU}Jm8?O=QHXy!4ugi1F#bvCwZ)&Kw3hXDg>{+R14Ba#1H&(%P{RubhEf9t zhF1v;3|2E37{m+a>Xn*opa^40kYDhbOD17|L7XIScNfP0 zOuF}g9QG1VUsv|0oXl)$0{${ge}FsHj6)2}tc)$J49&C+46FHK%(PCGdCHQoDGeFV|1_OibmmKs5UYEF#!{_{XR5DXYDh>*%rZ7; zI3%;^SFwVHj^xpE3P)zWH#WHO?mrOZwamC)$JW;CFgM0pFiA>`ho|Wd50848n2MNc zQ|pYz8JfDijSnvuv9aCrU}Jm8?O=QHXy!4ugi1F#bvCwZ)&Kw3hXDg>{+R14Ba#1H&(%P{RubhEf9t zhF1v;3|2E37{m+a>Tu5%v;KUsv|0oXl)$0{${ge}F>b zo-U3d9M_ZY>}_vsYhp;x8glbfGSez?Ymhh*uM5<`;OXk;vd$@? F2>?;h+FJks literal 0 HcmV?d00001 diff --git a/moli-image/tests/data/color_profiles/Display-P3-FF0000FF.png b/moli-image/tests/data/color_profiles/Display-P3-FF0000FF.png new file mode 100644 index 0000000000000000000000000000000000000000..7b6d4a6150d4bd909119c2ad01c51e6dce9d56f2 GIT binary patch literal 607 zcmeAS@N?(olHy`uVBq!ia0vp^Od!n23?w}&=BG0-F#2UWI|pPYCo?c;OiWHl2=dg? zIFXo`kZ|IxwkB6mc~D13Pf$Yri35Bsdw7y~xH?ZBW$j~Rv~y79F_03i*?sH)$0GgL zO=qlBO}Bb(jXQ8XY1xOX-RoUu8(dw?ux`qgM=1(_**k(Kb9Z@3NJs=XHK%(PCGdCHQoDGeFV|1_OibmmKs5UYEF#!{_{XR5DXYDh>*%rZ7; zI3%;^SFwVHj^xpE3P)zWH#WHO?mrOZwamC)$JW;CFgM0pFiA>`ho|Wd50848n2MNc zQ|pYz8JfDijSnvuv9aCrU}Jm8?O=QHXy!4ugi1F#bvCwZ)&Kw3hXDg>{+R14Ba#1H&(%P{RubhEf9t zhF1v;3|2E37{m+a>cn=#4T-G%W#lkPnrhrPtp*OmP# zCo`LxfWHjWAD|GAr;B3<$914f5`a7w21a!gbx=gBmbgZgq$HN4S|t~y0x1R~10zFS z14~^4;}8QgD`N{QLo;my11kfA%&E^OqG-s?PsvQH#H~T%M7%Cg1B0ilpUXO@geCxC COVQT= literal 0 HcmV?d00001 diff --git a/moli-image/tests/data/color_profiles/Generic-CMYK-FF000000.jpg b/moli-image/tests/data/color_profiles/Generic-CMYK-FF000000.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32f3b691e2c896f8d0b9318e6e59810a48585e76 GIT binary patch literal 55590 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
24`eFGh~@q4lgV(2k zF1?P4l+w~f0Ze8gJ_UIba9b3(hlJv&Owg_1pA`j{0I+>i! zQ{y=?krucF?}>3OVeX2-9@3aKGE>gcqggYSGMKpLj;PJ1d_|Y4RdKb%msyjPNkx-! zIu><>!_6V%vaTIeluA)7W!T}&U?h>FV`*nN(PTs~Y32b%UnR<=3^$aXj3h>>=%B;Q zH5#dlT7178UL|Oy3_p~95>DJFqZ4*>_^zJ6sHXSJu~mXm!U#j@55tLPWb{G5InkgG z)u_4sQgRh<7BgaMBB+djZ~^McLATTJ`8cvCg09lBa*;@llkzYL7l@uLaVtffixGRm z#44RE6Uo$=AP@1-0N0&iZzkEZQKrgdR%&#qKqp5HX;1@msx2+o$E7n7ad${qp>icW zlNgDMg=jDv?n;H~Y~|GW^$(%StjX4oDds&&JR5D zXYREnMy^K(PMMhti1fZL6bY;}ok1s({Ufov1Cfgv^Ke4n z6j9&Tr6PforiYO6eBW@UVIX-i9Xk{cZwedlX$rve;?yKEKH4`tcqgB$Nv96QV;fEL zJyip&bkx)%czmjNXzX@=uqKr|6iaO~qwlGD5iejL2VF0MZI8ig)6l7LXzw7rCX2ii z!-_N#`g%RU{}tquk$+J3kidp9^On@&_lmEyLW>96LY804nYNBGmbjUjIxz z`#?E3A#E8Fmt=+cF%D2z_vf*W4Ps@pyodxSocpt(j#v5mCz*58iGyR&tp#&wTAv@00fl#cHqrTNxcQQt*jxC^wKlIUG2k0k3It@|`MA>1g z9-;PO_3jGj&1LpRkOa(#zt~>FSH+tV^#{C8v(E35O4w9=7 zVLs0M%r*F>J2&M`M|}z0AMFjA*CBm3BG1FP-*!%Y;TpT=8H#xGm_OYeh+hT6yI^fD zCj7+l{Bzf%N%vIPJBIoSHh-oznAi!2=3wHF9iM;h`f$SiG~~IDc*ku1!7IVcPAD=5 zlYZ>@?q|*~$6X)m?x&D<+U6g<5**k8#b;ykuM_@{$iOHWG)NF8p)L}xC6V0}RzVZr z$B0)rIf9c0PQo~8Bgm@+xrd|{($x1*@g*h>V}ge9AjWmz+!dVNO)wQC^EDiKj+h0+ zkWnpws_mG3372-_!hDkb4wQWgr}J<^M4~<<+=?1Cn6@30=Mvnvz|kkrP!1Xp;EWee zv>?$7XlNUz&LM=az=w~)sVp?kLqi@o*9@o5BeAWhF&h`Z8T{}O_$&iHU%Ck6C__<>L%zrLLVc+eowLXl5JD%%$lM znb0_GL}`tn6+0z2P|_Jn+(PklDE1Yd8lw^sDuz?xJ~DKN)K8JhCQ_P3axbXCQF0(m zW-&6^OU7;y;gh7XkyK`p{Bv?@gd8`CVU!r?B{H{�es@fzZoI;W_zin0yo>rVxCz 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 literal 0 HcmV?d00001 diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs index 4f39371682d..cefde5f60d2 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs @@ -92,7 +92,7 @@ pub(crate) fn create_image_bitmap_callback<'s>( // detach the source. No V8 handles or live DOM state cross the task boundary. let (input, exception) = { v8::tc_scope!(let tc, scope); - let input = snapshot_bitmap_source(tc, source); + let input = snapshot_bitmap_source(tc, source, parameters.options.color_conversion()); let exception = tc.exception(); if exception.is_some() { tc.reset(); @@ -119,26 +119,31 @@ pub(crate) fn create_image_bitmap_callback<'s>( BitmapInput::Pixels(image) => { producer.send(parameters.apply(image)); } - BitmapInput::Blob(bytes) => { - let decode = move || { - let result = moli_image::decode_raster_image(&bytes) - .map_err(|_| BitmapRejection::InvalidState) - .and_then(|decoded| { - CanvasImage::rgba8( - decoded.image.width, - decoded.image.height, - decoded.image.rgba, - ) - .ok_or(BitmapRejection::InvalidState) - }) - .and_then(|image| parameters.apply(image)); - producer.send(result); - }; - if let Ok(handle) = tokio::runtime::Handle::try_current() { - handle.spawn_blocking(decode); - } else { - std::thread::spawn(decode); - } + BitmapInput::Blob(data) => { + data.read_all(Box::new(move |bytes| { + let decode = move || { + let result = bytes + .map_err(|_| BitmapRejection::InvalidState) + .and_then(|bytes| { + moli_image::decode_raster_image_with_color_conversion( + &bytes, + parameters.options.color_conversion(), + ) + .map_err(|_| BitmapRejection::InvalidState) + }) + .and_then(|decoded| { + CanvasImage::from_decoded_raster(decoded) + .ok_or(BitmapRejection::InvalidState) + }) + .and_then(|image| parameters.apply(image)); + producer.send(result); + }; + if let Ok(handle) = tokio::runtime::Handle::try_current() { + handle.spawn_blocking(decode); + } else { + std::thread::spawn(decode); + } + })); } } } @@ -217,22 +222,23 @@ struct BitmapCropArgs<'s> { } enum BitmapInput { - Blob(Vec), + Blob(moli_file_api::BlobData), Pixels(CanvasImage), } fn snapshot_bitmap_source<'s>( scope: &mut v8::PinScope<'s, '_>, source: v8::Local<'s, v8::Object>, + conversion: moli_image::ColorProfileConversion, ) -> Option { let source = moli_webapi_declare::web_api_object_target(scope, source)?; if web_api_interfaces::Blob::is_instance(scope, source) { - return crate::blob::blob_bytes_from_object(scope, source).map(BitmapInput::Blob); + return crate::blob::blob_data_from_object(scope, source).map(BitmapInput::Blob); } let image = if web_api_interfaces::ImageData::is_instance(scope, source) { crate::context_bootstrap::image_data::image_data_pixel_snapshot(scope, source)? } else { - super::image_source::image_source_image(scope, source)? + super::image_source::image_source_image_with_conversion(scope, source, conversion)? }; if image.pixels.width() == 0 || image.pixels.height() == 0 { return None; diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs index ac43e911ec4..6a05da1ab39 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs @@ -71,10 +71,9 @@ impl ResizeQuality { #[derive(Default, webidl::WebIdlDictionary)] #[webidl(prefix = "ImageBitmapOptions")] pub(super) struct BitmapOptions { - // The raster backend leaves color profiles unconverted in both modes. // Members are declared in Web IDL's observable lexicographic read order. #[webidl(name = "colorSpaceConversion", converter = "enum", default = ColorSpaceConversion::Default)] - _color_space_conversion: ColorSpaceConversion, + color_space_conversion: ColorSpaceConversion, #[webidl(converter = "enum", default = ImageOrientation::FromImage)] image_orientation: ImageOrientation, #[webidl(converter = "enum", default = PremultiplyAlpha::Default)] @@ -87,6 +86,15 @@ pub(super) struct BitmapOptions { pub(super) resize_width: Option, } +impl BitmapOptions { + pub(super) fn color_conversion(&self) -> moli_image::ColorProfileConversion { + match self.color_space_conversion { + ColorSpaceConversion::Default => moli_image::ColorProfileConversion::Apply, + ColorSpaceConversion::None => moli_image::ColorProfileConversion::Ignore, + } + } +} + pub(super) struct BitmapParameters { pub(super) crop: Option<[i32; 4]>, pub(super) options: BitmapOptions, diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/image_source.rs b/moli-renderer-v8/src/context_bootstrap/canvas/image_source.rs index aa934e89a90..e01bb8b929a 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/image_source.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/image_source.rs @@ -46,6 +46,14 @@ pub(in crate::context_bootstrap) fn image_source_pixels<'s>( pub(super) fn image_source_image<'s>( scope: &mut v8::PinScope<'s, '_>, source: v8::Local<'s, v8::Object>, +) -> Option { + image_source_image_with_conversion(scope, source, moli_image::ColorProfileConversion::Apply) +} + +pub(super) fn image_source_image_with_conversion<'s>( + scope: &mut v8::PinScope<'s, '_>, + source: v8::Local<'s, v8::Object>, + conversion: moli_image::ColorProfileConversion, ) -> Option { if web_api_interfaces::VideoFrame::is_instance(scope, source) { let (bytes, width, height) = super::super::video_frame::rendered_pixels(scope, source)?; @@ -66,10 +74,18 @@ pub(super) fn image_source_image<'s>( .ok()?; let host = unsafe { &*host }; match host.raster_image_for_canvas(handle) { - Ok(Some(pixels)) => Some( - CanvasImage::rgba8(pixels.width, pixels.height, pixels.rgba.clone())? - .with_origin_clean(host.image_resource_origin_clean(handle)?), - ), + Ok(Some(pixels)) => { + let image = if let Some(managed) = pixels.color_managed { + CanvasImage::from_color_managed(&managed, conversion) + } else { + CanvasImage::rgba8( + pixels.srgb.width, + pixels.srgb.height, + pixels.srgb.rgba.clone(), + ) + }?; + Some(image.with_origin_clean(host.image_resource_origin_clean(handle)?)) + } Ok(None) => None, Err(_) => { throw_dom_exception_value( diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/pixels.rs b/moli-renderer-v8/src/context_bootstrap/canvas/pixels.rs index 78d9b6322f2..b29c788c334 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/pixels.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/pixels.rs @@ -25,6 +25,51 @@ impl CanvasImage { }) } + pub(super) fn from_decoded_raster(decoded: moli_image::DecodedRasterImage) -> Option { + if let Some(managed) = decoded.color_managed { + Self::from_color_managed(&managed, moli_image::ColorProfileConversion::Apply) + } else { + Self::rgba8( + decoded.image.width, + decoded.image.height, + decoded.image.rgba, + ) + } + } + + pub(super) fn from_color_managed( + image: &moli_image::ColorManagedRasterImage, + conversion: moli_image::ColorProfileConversion, + ) -> Option { + if matches!(conversion, moli_image::ColorProfileConversion::Ignore) + && let Some(moli_image::UnconvertedRasterPixels::Unorm8(rgba)) = &image.unconverted + { + return Self::rgba8(image.width, image.height, rgba.clone()); + } + let mut bytes = Vec::new(); + bytes + .try_reserve_exact(moli_canvas::byte_len(image.width, image.height)?.checked_mul(2)?) + .ok()?; + if matches!(conversion, moli_image::ColorProfileConversion::Ignore) + && let Some(moli_image::UnconvertedRasterPixels::Unorm16(rgba)) = &image.unconverted + { + for value in rgba { + bytes.extend_from_slice( + &half::f16::from_f32(f32::from(*value) / 65535.0).to_ne_bytes(), + ); + } + } else { + for value in &image.rgba { + bytes.extend_from_slice(&half::f16::from_f32(*value).to_ne_bytes()); + } + } + Some(Self { + pixels: PixelBuffer::new(image.width, image.height, PixelFormat::Float16, bytes)?, + color_space: ImageDataColorSpace::Srgb, + origin_clean: true, + }) + } + pub(in crate::context_bootstrap) fn from_view( view: v8::Local<'_, v8::ArrayBufferView>, width: u32, diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs index 058f6ef601b..d32c06deb1d 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs @@ -331,9 +331,10 @@ mod tests { fn ready_red_pixel() -> ReadyDecodedImage { let budget = super::super::budget::SharedImageResourceBudget::default(); ReadyDecodedImage { - content: DecodedImageContent::Raster(Arc::new( - moli_image::RgbaImage::try_new(1, 1, vec![255, 0, 0, 255]).unwrap(), - )), + content: DecodedImageContent::Raster(super::super::decode::RasterImagePixels { + srgb: Arc::new(moli_image::RgbaImage::try_new(1, 1, vec![255, 0, 0, 255]).unwrap()), + color_managed: None, + }), decoded_bytes_permit: budget.reserve_decoded(4).unwrap(), } } @@ -345,6 +346,7 @@ mod tests { CssImageResourceStore::new(ReadyImageResourceIndex::default(), generation.clone()); let descriptor = ImageResponseDescriptor::raster(moli_image::RasterImageMetadata { format: moli_image::RasterImageFormat::Png, + color_precision: moli_image::RasterColorPrecision::Unorm8, width: 1, height: 1, }); @@ -376,6 +378,7 @@ mod tests { let url = "https://example.test/shared.png"; let descriptor = ImageResponseDescriptor::raster(moli_image::RasterImageMetadata { format: moli_image::RasterImageFormat::Png, + color_precision: moli_image::RasterColorPrecision::Unorm8, width: 1, height: 1, }); diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/decode.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/decode.rs index e50a20d5a0e..14b0cd06f23 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/decode.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/decode.rs @@ -55,10 +55,25 @@ pub(super) struct ReadyDecodedImage { } pub(super) enum DecodedImageContent { - Raster(Arc), + Raster(RasterImagePixels), Svg(Arc), } +#[derive(Clone)] +pub(crate) struct RasterImagePixels { + pub(crate) srgb: Arc, + pub(crate) color_managed: Option>, +} + +impl From for RasterImagePixels { + fn from(decoded: moli_image::DecodedRasterImage) -> Self { + Self { + srgb: Arc::new(decoded.image), + color_managed: decoded.color_managed.map(Arc::new), + } + } +} + pub(super) enum ImageDecodeResult { Ready(ReadyDecodedImage), Failed(String), @@ -281,7 +296,7 @@ fn decode_image( ImageDecodeMetadata::Raster(metadata) => { let decoded = moli_image::decode_raster_image_with_metadata(snapshot, metadata) .map_err(|error| error.to_string())?; - DecodedImageContent::Raster(Arc::new(decoded.image)) + DecodedImageContent::Raster(decoded.into()) } ImageDecodeMetadata::Svg(metadata) => { let decoded = moli_image::decode_svg_image_with_metadata(snapshot, metadata) diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs index 273e2c59f8f..33054da9107 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs @@ -188,7 +188,7 @@ impl super::PageScriptHost { pub(crate) fn raster_image_for_canvas( &self, element: DomHandle, - ) -> Result>, state::CanvasImageReadError> { + ) -> Result, state::CanvasImageReadError> { let selected = crate::native_bridge::element::image_selected_request_key(self, element); if self .image_resources diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs index b5ef0149023..a5c8c46e8bb 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs @@ -10,7 +10,7 @@ use super::{ ImageResourceRequestIdentity, ImageResponseDescriptor, budget::ImageDecodedBytesPermit, css::CssImageResourceStore, - decode::{DecodedImageContent, ImageDecodeCoordinator, ReadyDecodedImage}, + decode::{DecodedImageContent, ImageDecodeCoordinator, RasterImagePixels, ReadyDecodedImage}, preload::{ScannedImagePreloadStore, SharedScannedImagePreloadLoad}, }; use crate::document_runtime::DomHandle; @@ -60,7 +60,7 @@ enum ImageResourceState { pub(super) struct ReadyImageResource { pub(super) descriptor: ImageResponseDescriptor, pub(super) density: f64, - pub(super) pixels: Option>, + pub(super) pixels: Option, pub(super) svg: Option>, pub(super) canvas_source: Option, pub(super) _decoded_bytes_permit: Option, @@ -78,6 +78,10 @@ pub(crate) struct CanvasImageReadError; impl ReadyImageResource { pub(super) fn raster_pixels(&self) -> Option> { + self.raster_source().map(|source| source.srgb) + } + + fn raster_source(&self) -> Option { self.pixels.clone().or_else(|| { let ready = self.canvas_source.as_ref()?.decoded.get()?; match &ready.content { @@ -399,7 +403,7 @@ impl ImageResourceStore { pub(super) fn raster_for_canvas( &self, element: DomHandle, - ) -> Result>, CanvasImageReadError> { + ) -> Result, CanvasImageReadError> { let Some(slot) = self.slots.get(&element) else { return Ok(None); }; @@ -409,7 +413,7 @@ impl ImageResourceStore { let Some(resource) = slot.current_ready() else { return Ok(None); }; - if let Some(pixels) = resource.raster_pixels() { + if let Some(pixels) = resource.raster_source() { return Ok(Some(pixels)); } let Some(source) = resource.canvas_source.as_ref() else { @@ -424,7 +428,7 @@ impl ImageResourceStore { })?; let _ = source.decoded.set(decoded); self.visual_generation.bump(); - Ok(resource.raster_pixels()) + Ok(resource.raster_source()) } pub(super) fn is_ready(&self, element: DomHandle) -> bool { @@ -577,6 +581,7 @@ mod tests { .raster_for_canvas(same_document.element) .unwrap() .unwrap() + .srgb .rgba, [255, 0, 0, 255] ); @@ -601,6 +606,7 @@ mod tests { .raster_for_canvas(other_document.element) .unwrap() .unwrap() + .srgb .rgba, [0, 255, 0, 255] ); @@ -610,11 +616,64 @@ mod tests { .raster_for_canvas(first.element) .unwrap() .unwrap() + .srgb .rgba, [255, 0, 0, 255] ); } + #[test] + fn profiled_image_budget_admission_cache_and_retirement_cover_all_color_planes() { + let bytes = include_bytes!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../moli-image/tests/data/color_profiles/Display-P3-FF0000FF.png" + )); + let metadata = moli_image::probe_raster_image(bytes).unwrap(); + let retained = metadata.decoded_byte_len(); + let mut store = ImageResourceStore::default(); + let budget = store.decode.budget_for_test(); + let identity = image_identity(20, 1, "https://images.test/profile.png"); + let manager = moli_parkable_image::ParkableImageManager::new( + None, + moli_parkable_image::ParkableImagePolicy::default(), + ); + store.begin(identity.clone(), false); + assert!(store.complete_metadata( + &identity, + ImageResponseDescriptor::raster(metadata), + manager.from_frozen_bytes(bytes.to_vec()) + )); + let blocked = budget + .reserve_decoded(super::super::budget::MAX_RETAINED_IMAGE_DECODED_BYTES - retained + 1) + .unwrap(); + assert!(store.raster_for_canvas(identity.element).is_err()); + drop(blocked); + assert_eq!(budget.counters(), (0, 0, 0)); + + let first = store.raster_for_canvas(identity.element).unwrap().unwrap(); + let again = store.raster_for_canvas(identity.element).unwrap().unwrap(); + assert!(Arc::ptr_eq(&first.srgb, &again.srgb)); + assert!(Arc::ptr_eq( + first.color_managed.as_ref().unwrap(), + again.color_managed.as_ref().unwrap() + )); + assert_eq!(budget.counters(), (0, 0, retained)); + let same_document = image_identity(21, 2, identity.request_key.url()); + store.begin(same_document.clone(), false); + let shared = store + .raster_for_canvas(same_document.element) + .unwrap() + .unwrap(); + assert!(Arc::ptr_eq( + first.color_managed.as_ref().unwrap(), + shared.color_managed.as_ref().unwrap() + )); + assert_eq!(budget.counters(), (0, 0, retained)); + drop((first, again, shared)); + assert_eq!(store.retire_document(identity.document_handle), 2); + assert_eq!(budget.counters(), (0, 0, 0)); + } + #[test] fn canvas_demand_shares_one_decode_and_releases_its_owner_budget() { let mut store = ImageResourceStore::default(); @@ -633,11 +692,11 @@ mod tests { assert_eq!(budget.counters(), (0, 0, 0)); let before = store.visual_generation(); let first = store.raster_for_canvas(identity.element).unwrap().unwrap(); - assert_eq!(first.rgba, [0, 255, 0, 255]); + assert_eq!(first.srgb.rgba, [0, 255, 0, 255]); assert_eq!(budget.counters(), (0, 0, 4)); assert_eq!(store.visual_generation(), before + 1); let again = store.raster_for_canvas(identity.element).unwrap().unwrap(); - assert!(Arc::ptr_eq(&first, &again)); + assert!(Arc::ptr_eq(&first.srgb, &again.srgb)); assert_eq!(store.visual_generation(), before + 1); assert!( store @@ -649,7 +708,7 @@ mod tests { let other = image_identity(11, 2, identity.request_key.url()); store.begin(other.clone(), false); let shared = store.raster_for_canvas(other.element).unwrap().unwrap(); - assert!(Arc::ptr_eq(&first, &shared)); + assert!(Arc::ptr_eq(&first.srgb, &shared.srgb)); assert_eq!(budget.counters(), (0, 0, 4)); drop((first, again, shared)); assert!(store.retire_element(identity.element)); @@ -681,6 +740,7 @@ mod tests { .raster_for_canvas(first.element) .unwrap() .unwrap() + .srgb .rgba, [0, 255, 0, 255] ); @@ -694,6 +754,7 @@ mod tests { .raster_for_canvas(first.element) .unwrap() .unwrap() + .srgb .rgba, [0, 255, 0, 255] ); @@ -706,6 +767,7 @@ mod tests { .raster_for_canvas(first.element) .unwrap() .unwrap() + .srgb .rgba, [0, 0, 255, 255] ); diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_image_color.js b/moli-renderer-v8/src/script_vm/tests/canvas_image_color.js new file mode 100644 index 00000000000..6b3313a4be0 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/canvas_image_color.js @@ -0,0 +1,35 @@ +async function probe(bytes) { + const rows = []; + const blob = new Blob([new Uint8Array(bytes)], {type: 'image/png'}); + const image = new Image(); + const ready = new Promise((resolve, reject) => { image.onload = resolve; image.onerror = reject; }); + image.src = 'data:image/png;base64,' + btoa(String.fromCharCode(...bytes)); + await ready; + const seed = await createImageBitmap(image); + for (const [sourceName, source] of [['image', image], ['blob', blob], ['bitmap', seed]]) { + for (const conversion of ['default', 'none']) { + const bitmap = await createImageBitmap(source, {colorSpaceConversion: conversion}); + for (const kind of ['element', 'offscreen']) { + for (const colorSpace of ['srgb', 'display-p3']) { + for (const paint of ['drawImage', 'pattern']) { + const canvas = kind === 'element' ? document.createElement('canvas') : new OffscreenCanvas(2, 2); + canvas.width = canvas.height = 2; + const context = canvas.getContext('2d', {colorSpace}); + context.imageSmoothingEnabled = false; + if (paint === 'drawImage') context.drawImage(bitmap, 0, 0); + else { context.fillStyle = context.createPattern(bitmap, 'repeat'); context.fillRect(0, 0, 2, 2); } + const converted = conversion === 'default' || sourceName === 'bitmap'; + const expected = converted ? (colorSpace === 'srgb' ? [205, 0, 0, 204] : [187, 0, 0, 204]) + : (colorSpace === 'srgb' ? [187, 0, 0, 204] : [171, 35, 23, 204]); + const actual = Array.from(context.getImageData(0, 0, 1, 1, {colorSpace}).data); + rows.push({name: [sourceName, conversion, kind, colorSpace, paint].join('/'), expected, actual, + passed: actual.every((value, i) => Math.abs(value - expected[i]) <= 2)}); + } + } + } + bitmap.close(); + } + } + seed.close(); + return rows; +} diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_image_color.rs b/moli-renderer-v8/src/script_vm/tests/canvas_image_color.rs new file mode 100644 index 00000000000..55d92d795b7 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/canvas_image_color.rs @@ -0,0 +1,36 @@ +use super::*; +use std::time::{Duration, Instant}; + +#[tokio::test(flavor = "current_thread")] +async fn canvas_image_profiles_preserve_gamut_and_bitmap_color_conversion_options() { + let bytes = include_bytes!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../moli-image/tests/data/color_profiles/Display-P3-BB0000CC.png" + )); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://canvas-image-color.test/"); + vm.eval(&format!("const probe={}; probe({bytes:?}).then(rows => globalThis.__imageColors=rows, error => globalThis.__imageColors=String(error));",include_str!("canvas_image_color.js"))).unwrap(); + let deadline = Instant::now() + Duration::from_secs(15); + while vm.eval("typeof __imageColors").unwrap() == "undefined" { + vm.run_one_oldest_ready_page_task_executor_turn(&loader) + .await + .unwrap(); + assert!( + Instant::now() < deadline, + "image color conversion timed out" + ); + tokio::time::sleep(Duration::from_millis(1)).await; + } + assert_eq!( + vm.eval("Array.isArray(__imageColors)").unwrap(), + "true", + "{}", + vm.eval("JSON.stringify(__imageColors)").unwrap() + ); + assert_eq!(vm.eval("__imageColors.length").unwrap(), "48"); + assert_eq!( + vm.eval("JSON.stringify(__imageColors.filter(row=>!row.passed))") + .unwrap(), + "[]" + ); +} diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index d8f0d5a1a9b..1e42c660416 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -2310,6 +2310,7 @@ mod canvas_drawing_state; mod canvas_fill_rect; mod canvas_gradients; mod canvas_hdr_pixels; +mod canvas_image_color; mod canvas_image_proxies; mod canvas_paths; mod canvas_transfer_to_image_bitmap;