1412 lines
52 KiB
Rust
1412 lines
52 KiB
Rust
//! Native implementation of the pinned `SkiaTextureCodec` behavior.
|
|
|
|
use crate::Error;
|
|
use crate::backend::{SKAlphaType, SKBitmap, SKColorType};
|
|
#[cfg(any(feature = "rust-skia", feature = "skia"))]
|
|
use libremetaverse_imaging::{DEFAULT_MAX_ENCODED_BYTES, DEFAULT_MAX_PIXELS};
|
|
use libremetaverse_imaging::{ManagedImage, ManagedImageImageChannels};
|
|
use libremetaverse_types::compat::ReadWrite;
|
|
#[cfg(any(feature = "rust-skia", feature = "skia"))]
|
|
use std::io::Read;
|
|
|
|
/// Optional Skia-backed decoder and format-neutral bitmap converter.
|
|
#[derive(Clone, Copy, Debug, Default)]
|
|
pub struct SkiaTextureCodec;
|
|
|
|
/// Pure-Rust alternative to [`SkiaTextureCodec`] with the same image boundary.
|
|
///
|
|
/// Enable the `rust-skia` feature to decode the common Skia codec formats
|
|
/// without a native library, build script, system package lookup, or download.
|
|
#[derive(Clone, Copy, Debug, Default)]
|
|
pub struct RustSkiaTextureCodec;
|
|
|
|
impl SkiaTextureCodec {
|
|
/// Creates the stateless codec adapter.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// This fixed compatibility constructor cannot fail.
|
|
pub const fn new() -> Result<Self, Error> {
|
|
Ok(Self)
|
|
}
|
|
|
|
/// Decodes a bounded compressed-image stream through Skia.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// With the `skia` feature, returns a typed argument, parse, or operation
|
|
/// error for oversized or malformed input and unsupported native output.
|
|
/// Without the feature it returns [`Error::InvalidOperation`].
|
|
pub fn decode(&self, mut stream: Box<dyn ReadWrite + Send>) -> Result<ManagedImage, Error> {
|
|
#[cfg(feature = "skia")]
|
|
{
|
|
let encoded = read_bounded(&mut stream)?;
|
|
decode_with_skia(&encoded)
|
|
}
|
|
#[cfg(not(feature = "skia"))]
|
|
{
|
|
let _ = &mut stream;
|
|
Err(Error::InvalidOperation)
|
|
}
|
|
}
|
|
|
|
/// Converts an owned mapped bitmap using the exact reference channel rules.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// Returns a typed error for invalid dimensions, storage, or an unsupported
|
|
/// fallback byte width.
|
|
#[allow(clippy::needless_pass_by_value)] // fixed mapped C# signature
|
|
pub fn to_managed_image(bitmap: SKBitmap) -> Result<ManagedImage, Error> {
|
|
bitmap_to_managed(&bitmap)
|
|
}
|
|
}
|
|
|
|
impl RustSkiaTextureCodec {
|
|
/// Creates the stateless pure-Rust codec adapter.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// This fixed compatibility constructor cannot fail.
|
|
pub const fn new() -> Result<Self, Error> {
|
|
Ok(Self)
|
|
}
|
|
|
|
/// Decodes a bounded stream with Rust-only BMP, GIF, ICO, JPEG, PNG,
|
|
/// WBMP, and WebP codecs.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// With `rust-skia`, returns [`Error::Argument`] for an input or decoded
|
|
/// canvas above the documented limits and [`Error::InvalidOperation`] for
|
|
/// malformed or unsupported images. Without the feature it returns
|
|
/// [`Error::InvalidOperation`].
|
|
pub fn decode(&self, mut stream: Box<dyn ReadWrite + Send>) -> Result<ManagedImage, Error> {
|
|
#[cfg(feature = "rust-skia")]
|
|
{
|
|
let encoded = read_bounded(&mut stream)?;
|
|
decode_with_rust_skia(&encoded)
|
|
}
|
|
#[cfg(not(feature = "rust-skia"))]
|
|
{
|
|
let _ = &mut stream;
|
|
Err(Error::InvalidOperation)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(any(feature = "rust-skia", feature = "skia"))]
|
|
fn read_bounded(stream: &mut (dyn ReadWrite + Send)) -> Result<Vec<u8>, Error> {
|
|
let mut encoded = Vec::new();
|
|
stream
|
|
.take((DEFAULT_MAX_ENCODED_BYTES + 1) as u64)
|
|
.read_to_end(&mut encoded)
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
if encoded.is_empty() {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
if encoded.len() > DEFAULT_MAX_ENCODED_BYTES {
|
|
return Err(Error::Argument);
|
|
}
|
|
Ok(encoded)
|
|
}
|
|
|
|
// Keeping the format branches together makes comparison with the pinned C#
|
|
// color switch auditable and prevents subtly different indexing paths.
|
|
#[allow(clippy::too_many_lines)]
|
|
fn bitmap_to_managed(bitmap: &SKBitmap) -> Result<ManagedImage, Error> {
|
|
let width = usize::try_from(bitmap.width()).map_err(|_| Error::Argument)?;
|
|
let height = usize::try_from(bitmap.height()).map_err(|_| Error::Argument)?;
|
|
let reference_step = bitmap.row_bytes() / width.max(1);
|
|
let channels = match bitmap.color_type() {
|
|
SKColorType::Rgb565 => ManagedImageImageChannels::COLOR,
|
|
SKColorType::Bgra8888
|
|
| SKColorType::Rgba8888
|
|
| SKColorType::Rgba1010102
|
|
| SKColorType::Bgra1010102 => {
|
|
ManagedImageImageChannels::COLOR | ManagedImageImageChannels::ALPHA
|
|
}
|
|
SKColorType::Gray8 => ManagedImageImageChannels::GRAY,
|
|
SKColorType::Alpha8 => ManagedImageImageChannels::ALPHA,
|
|
SKColorType::Other { .. } if reference_step == 1 => ManagedImageImageChannels::GRAY,
|
|
SKColorType::Other { .. } if reference_step == 3 => ManagedImageImageChannels::COLOR,
|
|
SKColorType::Other { .. } if reference_step == 4 => {
|
|
ManagedImageImageChannels::COLOR | ManagedImageImageChannels::ALPHA
|
|
}
|
|
SKColorType::Other { .. } => return Err(Error::InvalidOperation),
|
|
};
|
|
let mut image = ManagedImage::new(bitmap.width(), bitmap.height(), channels)?;
|
|
for y in 0..height {
|
|
let row = y.checked_mul(bitmap.row_bytes()).ok_or(Error::Argument)?;
|
|
for x in 0..width {
|
|
let pixel = y
|
|
.checked_mul(width)
|
|
.and_then(|offset| offset.checked_add(x))
|
|
.ok_or(Error::Argument)?;
|
|
match bitmap.color_type() {
|
|
SKColorType::Rgb565 => {
|
|
let offset = checked_offset(row, x, 2, bitmap.pixels().len())?;
|
|
let packed =
|
|
u16::from_le_bytes([bitmap.pixels()[offset], bitmap.pixels()[offset + 1]]);
|
|
image.red[pixel] = scale_bits(u32::from((packed >> 11) & 0x1f), 31);
|
|
image.green[pixel] = scale_bits(u32::from((packed >> 5) & 0x3f), 63);
|
|
image.blue[pixel] = scale_bits(u32::from(packed & 0x1f), 31);
|
|
}
|
|
SKColorType::Bgra8888 | SKColorType::Rgba8888 => {
|
|
let offset = checked_offset(row, x, reference_step, bitmap.pixels().len())?;
|
|
let source = &bitmap.pixels()[offset..offset + 4];
|
|
let (red, green, blue, alpha) = if bitmap.color_type() == SKColorType::Rgba8888
|
|
{
|
|
(source[0], source[1], source[2], source[3])
|
|
} else {
|
|
(source[2], source[1], source[0], source[3])
|
|
};
|
|
let (red, green, blue) =
|
|
normalize_8bit_alpha(red, green, blue, alpha, bitmap.alpha_type());
|
|
image.red[pixel] = red;
|
|
image.green[pixel] = green;
|
|
image.blue[pixel] = blue;
|
|
image.alpha[pixel] = alpha;
|
|
}
|
|
SKColorType::Rgba1010102 | SKColorType::Bgra1010102 => {
|
|
let offset = checked_offset(row, x, 4, bitmap.pixels().len())?;
|
|
let packed = u32::from_le_bytes(
|
|
bitmap.pixels()[offset..offset + 4]
|
|
.try_into()
|
|
.map_err(|_| Error::Argument)?,
|
|
);
|
|
let first = packed & 0x3ff;
|
|
let green = (packed >> 10) & 0x3ff;
|
|
let third = (packed >> 20) & 0x3ff;
|
|
let alpha = (packed >> 30) & 0x3;
|
|
let (red, blue) = if bitmap.color_type() == SKColorType::Rgba1010102 {
|
|
(first, third)
|
|
} else {
|
|
(third, first)
|
|
};
|
|
let (red, green, blue) =
|
|
normalize_10bit_alpha(red, green, blue, alpha, bitmap.alpha_type());
|
|
image.red[pixel] = scale_bits(red, 1023);
|
|
image.green[pixel] = scale_bits(green, 1023);
|
|
image.blue[pixel] = scale_bits(blue, 1023);
|
|
image.alpha[pixel] = u8::try_from(alpha * 85).map_err(|_| Error::Argument)?;
|
|
}
|
|
SKColorType::Gray8 => {
|
|
let offset = checked_offset(row, x, reference_step, bitmap.pixels().len())?;
|
|
image.red[pixel] = bitmap.pixels()[offset];
|
|
}
|
|
SKColorType::Alpha8 => {
|
|
let offset = checked_offset(row, x, reference_step, bitmap.pixels().len())?;
|
|
image.alpha[pixel] = bitmap.pixels()[offset];
|
|
}
|
|
SKColorType::Other { .. } => {
|
|
let offset = checked_offset(row, x, reference_step, bitmap.pixels().len())?;
|
|
match reference_step {
|
|
4 => {
|
|
let alpha = bitmap.pixels()[offset + 3];
|
|
let (red, green, blue) = normalize_8bit_alpha(
|
|
bitmap.pixels()[offset + 2],
|
|
bitmap.pixels()[offset + 1],
|
|
bitmap.pixels()[offset],
|
|
alpha,
|
|
bitmap.alpha_type(),
|
|
);
|
|
image.red[pixel] = red;
|
|
image.green[pixel] = green;
|
|
image.blue[pixel] = blue;
|
|
image.alpha[pixel] = alpha;
|
|
}
|
|
3 => {
|
|
image.blue[pixel] = bitmap.pixels()[offset];
|
|
image.green[pixel] = bitmap.pixels()[offset + 1];
|
|
image.red[pixel] = bitmap.pixels()[offset + 2];
|
|
}
|
|
1 => image.red[pixel] = bitmap.pixels()[offset],
|
|
_ => return Err(Error::InvalidOperation),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(image)
|
|
}
|
|
|
|
fn checked_offset(row: usize, x: usize, step: usize, length: usize) -> Result<usize, Error> {
|
|
let offset = x
|
|
.checked_mul(step)
|
|
.and_then(|offset| row.checked_add(offset))
|
|
.ok_or(Error::Argument)?;
|
|
offset
|
|
.checked_add(step)
|
|
.filter(|end| *end <= length)
|
|
.map(|_| offset)
|
|
.ok_or(Error::Argument)
|
|
}
|
|
|
|
fn scale_bits(value: u32, maximum: u32) -> u8 {
|
|
u8::try_from((value * 255 + maximum / 2) / maximum).unwrap_or(u8::MAX)
|
|
}
|
|
|
|
fn normalize_8bit_alpha(
|
|
red: u8,
|
|
green: u8,
|
|
blue: u8,
|
|
alpha: u8,
|
|
alpha_type: SKAlphaType,
|
|
) -> (u8, u8, u8) {
|
|
if alpha_type != SKAlphaType::Premul || alpha == u8::MAX {
|
|
return (red, green, blue);
|
|
}
|
|
if alpha == 0 {
|
|
return (0, 0, 0);
|
|
}
|
|
let normalize = |value: u8| {
|
|
u8::try_from((u32::from(value) * 255 + u32::from(alpha) / 2) / u32::from(alpha))
|
|
.unwrap_or(u8::MAX)
|
|
};
|
|
(normalize(red), normalize(green), normalize(blue))
|
|
}
|
|
|
|
fn normalize_10bit_alpha(
|
|
red: u32,
|
|
green: u32,
|
|
blue: u32,
|
|
alpha: u32,
|
|
alpha_type: SKAlphaType,
|
|
) -> (u32, u32, u32) {
|
|
if alpha_type != SKAlphaType::Premul || alpha == 3 {
|
|
return (red, green, blue);
|
|
}
|
|
if alpha == 0 {
|
|
return (0, 0, 0);
|
|
}
|
|
let normalize = |value: u32| (value * 3 + alpha / 2) / alpha;
|
|
(normalize(red), normalize(green), normalize(blue))
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn decode_with_rust_skia(encoded: &[u8]) -> Result<ManagedImage, Error> {
|
|
use skia_rs_codec::{ImageDecoder, ImageFormat};
|
|
|
|
let format = if wbmp_dimensions(encoded).is_ok() {
|
|
ImageFormat::Wbmp
|
|
} else {
|
|
ImageFormat::from_magic(encoded)
|
|
};
|
|
if format == ImageFormat::WebP {
|
|
return decode_webp_with_rust(encoded);
|
|
}
|
|
if !matches!(
|
|
format,
|
|
ImageFormat::Bmp
|
|
| ImageFormat::Gif
|
|
| ImageFormat::Ico
|
|
| ImageFormat::Jpeg
|
|
| ImageFormat::Png
|
|
| ImageFormat::Wbmp
|
|
) {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
|
|
let (width, height) = match format {
|
|
ImageFormat::Gif => gif_dimensions(encoded)?,
|
|
ImageFormat::Ico => ico_dimensions(encoded)?,
|
|
ImageFormat::Wbmp => wbmp_dimensions(encoded)?,
|
|
_ => skia_rs_codec::get_image_dimensions(encoded).map_err(|_| Error::InvalidOperation)?,
|
|
};
|
|
validate_dimensions(width, height)?;
|
|
|
|
let decoded = if format == ImageFormat::Wbmp {
|
|
skia_rs_codec::WbmpDecoder::new().decode_bytes(encoded)
|
|
} else {
|
|
skia_rs_codec::decode_image(encoded)
|
|
}
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
validate_dimensions(decoded.width(), decoded.height())?;
|
|
if decoded.width() != width || decoded.height() != height {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let width_usize = usize::try_from(width).map_err(|_| Error::Argument)?;
|
|
if decoded.row_bytes() != width_usize.checked_mul(4).ok_or(Error::Argument)? {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let source_pixels = decoded.peek_pixels().ok_or(Error::InvalidOperation)?;
|
|
let grayscale = match format {
|
|
ImageFormat::Jpeg => jpeg_is_grayscale(encoded)?,
|
|
ImageFormat::Png => encoded.get(25) == Some(&0),
|
|
ImageFormat::Wbmp => true,
|
|
_ => false,
|
|
};
|
|
let (row_bytes, color_type, alpha_type, pixels) = if grayscale {
|
|
let pixel_count = width_usize
|
|
.checked_mul(usize::try_from(height).map_err(|_| Error::Argument)?)
|
|
.ok_or(Error::Argument)?;
|
|
let mut gray = Vec::new();
|
|
gray.try_reserve_exact(pixel_count)
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
gray.extend(source_pixels.chunks_exact(4).map(|rgba| rgba[0]));
|
|
if gray.len() != pixel_count {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
(width_usize, SKColorType::Gray8, SKAlphaType::Opaque, gray)
|
|
} else {
|
|
let mut rgba = Vec::new();
|
|
rgba.try_reserve_exact(source_pixels.len())
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
rgba.extend_from_slice(source_pixels);
|
|
(
|
|
decoded.row_bytes(),
|
|
SKColorType::Rgba8888,
|
|
if decoded.is_opaque() {
|
|
SKAlphaType::Opaque
|
|
} else {
|
|
SKAlphaType::Unpremul
|
|
},
|
|
rgba,
|
|
)
|
|
};
|
|
let bitmap = SKBitmap::new(width, height, row_bytes, color_type, alpha_type, pixels)?;
|
|
bitmap_to_managed(&bitmap)
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn jpeg_is_grayscale(encoded: &[u8]) -> Result<bool, Error> {
|
|
let mut offset = 2;
|
|
while offset + 1 < encoded.len() {
|
|
if encoded[offset] != 0xff {
|
|
offset += 1;
|
|
continue;
|
|
}
|
|
let mut marker_offset = offset + 1;
|
|
while encoded.get(marker_offset) == Some(&0xff) {
|
|
marker_offset += 1;
|
|
}
|
|
let marker = *encoded.get(marker_offset).ok_or(Error::InvalidOperation)?;
|
|
if marker == 0 || marker == 1 || (0xd0..=0xd9).contains(&marker) {
|
|
offset = marker_offset + 1;
|
|
continue;
|
|
}
|
|
let length_bytes = encoded
|
|
.get(marker_offset + 1..marker_offset + 3)
|
|
.ok_or(Error::InvalidOperation)?;
|
|
let length = usize::from(u16::from_be_bytes(
|
|
length_bytes
|
|
.try_into()
|
|
.map_err(|_| Error::InvalidOperation)?,
|
|
));
|
|
if matches!(
|
|
marker,
|
|
0xc0..=0xc3 | 0xc5..=0xc7 | 0xc9..=0xcb | 0xcd..=0xcf
|
|
) {
|
|
let components = *encoded
|
|
.get(marker_offset + 8)
|
|
.ok_or(Error::InvalidOperation)?;
|
|
return match components {
|
|
1 => Ok(true),
|
|
3 => Ok(false),
|
|
_ => Err(Error::InvalidOperation),
|
|
};
|
|
}
|
|
if length < 2 {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
offset = marker_offset
|
|
.checked_add(1)
|
|
.and_then(|offset| offset.checked_add(length))
|
|
.ok_or(Error::InvalidOperation)?;
|
|
}
|
|
Err(Error::InvalidOperation)
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn gif_dimensions(encoded: &[u8]) -> Result<(i32, i32), Error> {
|
|
if encoded.len() < 13 || !(encoded.starts_with(b"GIF87a") || encoded.starts_with(b"GIF89a")) {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let canvas = (
|
|
i32::from(u16::from_le_bytes([encoded[6], encoded[7]])),
|
|
i32::from(u16::from_le_bytes([encoded[8], encoded[9]])),
|
|
);
|
|
validate_dimensions(canvas.0, canvas.1)?;
|
|
|
|
let global_table_bytes = if encoded[10] & 0x80 == 0 {
|
|
0
|
|
} else {
|
|
3_usize
|
|
.checked_mul(1_usize << (usize::from(encoded[10] & 0x07) + 1))
|
|
.ok_or(Error::InvalidOperation)?
|
|
};
|
|
let mut offset = 13_usize
|
|
.checked_add(global_table_bytes)
|
|
.filter(|offset| *offset <= encoded.len())
|
|
.ok_or(Error::InvalidOperation)?;
|
|
loop {
|
|
let marker = *encoded.get(offset).ok_or(Error::InvalidOperation)?;
|
|
offset += 1;
|
|
match marker {
|
|
0x2c => {
|
|
let end = offset.checked_add(9).ok_or(Error::InvalidOperation)?;
|
|
let descriptor = encoded.get(offset..end).ok_or(Error::InvalidOperation)?;
|
|
let frame_width = i32::from(u16::from_le_bytes([descriptor[4], descriptor[5]]));
|
|
let frame_height = i32::from(u16::from_le_bytes([descriptor[6], descriptor[7]]));
|
|
validate_dimensions(frame_width, frame_height)?;
|
|
return Ok(canvas);
|
|
}
|
|
0x21 => {
|
|
offset = offset.checked_add(1).ok_or(Error::InvalidOperation)?;
|
|
loop {
|
|
let length = *encoded.get(offset).ok_or(Error::InvalidOperation)?;
|
|
offset += 1;
|
|
if length == 0 {
|
|
break;
|
|
}
|
|
offset = offset
|
|
.checked_add(usize::from(length))
|
|
.filter(|offset| *offset <= encoded.len())
|
|
.ok_or(Error::InvalidOperation)?;
|
|
}
|
|
}
|
|
_ => return Err(Error::InvalidOperation),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn wbmp_dimensions(encoded: &[u8]) -> Result<(i32, i32), Error> {
|
|
if encoded.get(..2) != Some(&[0, 0]) {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let mut offset = 2;
|
|
let width =
|
|
i32::try_from(read_wbmp_integer(encoded, &mut offset)?).map_err(|_| Error::Argument)?;
|
|
let height =
|
|
i32::try_from(read_wbmp_integer(encoded, &mut offset)?).map_err(|_| Error::Argument)?;
|
|
validate_dimensions(width, height)?;
|
|
Ok((width, height))
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn read_wbmp_integer(encoded: &[u8], offset: &mut usize) -> Result<u32, Error> {
|
|
let mut value = 0_u32;
|
|
for _ in 0..5 {
|
|
let byte = *encoded.get(*offset).ok_or(Error::InvalidOperation)?;
|
|
*offset += 1;
|
|
value = value
|
|
.checked_shl(7)
|
|
.and_then(|value| value.checked_add(u32::from(byte & 0x7f)))
|
|
.ok_or(Error::InvalidOperation)?;
|
|
if byte & 0x80 == 0 {
|
|
return Ok(value);
|
|
}
|
|
}
|
|
Err(Error::InvalidOperation)
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn ico_dimensions(encoded: &[u8]) -> Result<(i32, i32), Error> {
|
|
if encoded.len() < 6 || encoded.get(..4) != Some(&[0, 0, 1, 0]) {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let count = usize::from(u16::from_le_bytes([encoded[4], encoded[5]]));
|
|
let mut best: Option<(u32, usize, usize)> = None;
|
|
for index in 0..count {
|
|
let offset = 6_usize
|
|
.checked_add(index.checked_mul(16).ok_or(Error::InvalidOperation)?)
|
|
.ok_or(Error::InvalidOperation)?;
|
|
let end = offset.checked_add(16).ok_or(Error::InvalidOperation)?;
|
|
let entry = encoded.get(offset..end).ok_or(Error::InvalidOperation)?;
|
|
let width = if entry[0] == 0 {
|
|
256
|
|
} else {
|
|
u32::from(entry[0])
|
|
};
|
|
let height = if entry[1] == 0 {
|
|
256
|
|
} else {
|
|
u32::from(entry[1])
|
|
};
|
|
let area = width.checked_mul(height).ok_or(Error::Argument)?;
|
|
let length = usize::try_from(u32::from_le_bytes(
|
|
entry[8..12]
|
|
.try_into()
|
|
.map_err(|_| Error::InvalidOperation)?,
|
|
))
|
|
.map_err(|_| Error::Argument)?;
|
|
let image_offset = usize::try_from(u32::from_le_bytes(
|
|
entry[12..16]
|
|
.try_into()
|
|
.map_err(|_| Error::InvalidOperation)?,
|
|
))
|
|
.map_err(|_| Error::Argument)?;
|
|
if best.is_none_or(|(best_area, _, _)| area > best_area) {
|
|
best = Some((area, image_offset, length));
|
|
}
|
|
}
|
|
let (_, offset, length) = best.ok_or(Error::InvalidOperation)?;
|
|
let end = offset.checked_add(length).ok_or(Error::Argument)?;
|
|
let image = encoded
|
|
.get(offset..end)
|
|
.filter(|image| !image.is_empty())
|
|
.ok_or(Error::InvalidOperation)?;
|
|
if image.starts_with(&[0x89, b'P', b'N', b'G']) {
|
|
return skia_rs_codec::get_image_dimensions(image).map_err(|_| Error::InvalidOperation);
|
|
}
|
|
if image.len() < 40 {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let header_size = u32::from_le_bytes(
|
|
image[0..4]
|
|
.try_into()
|
|
.map_err(|_| Error::InvalidOperation)?,
|
|
);
|
|
if header_size < 40 {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let width = i32::from_le_bytes(
|
|
image[4..8]
|
|
.try_into()
|
|
.map_err(|_| Error::InvalidOperation)?,
|
|
);
|
|
let stored_height = i32::from_le_bytes(
|
|
image[8..12]
|
|
.try_into()
|
|
.map_err(|_| Error::InvalidOperation)?,
|
|
);
|
|
if stored_height <= 0 || stored_height % 2 != 0 {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
Ok((width, stored_height / 2))
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn validate_dimensions(width: i32, height: i32) -> Result<(), Error> {
|
|
let width = usize::try_from(width).map_err(|_| Error::Argument)?;
|
|
let height = usize::try_from(height).map_err(|_| Error::Argument)?;
|
|
width
|
|
.checked_mul(height)
|
|
.filter(|pixels| *pixels > 0 && *pixels <= DEFAULT_MAX_PIXELS)
|
|
.map(|_| ())
|
|
.ok_or(Error::Argument)
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn decode_webp_with_rust(encoded: &[u8]) -> Result<ManagedImage, Error> {
|
|
use std::io::{BufReader, Cursor};
|
|
|
|
let reader = BufReader::new(Cursor::new(encoded));
|
|
let mut decoder = image_webp::WebPDecoder::new(reader).map_err(|_| Error::InvalidOperation)?;
|
|
let (width, height) = decoder.dimensions();
|
|
let animated = decoder.is_animated();
|
|
let width_i32 = i32::try_from(width).map_err(|_| Error::Argument)?;
|
|
let height_i32 = i32::try_from(height).map_err(|_| Error::Argument)?;
|
|
validate_dimensions(width_i32, height_i32)?;
|
|
decoder.set_memory_limit(DEFAULT_MAX_PIXELS * 16);
|
|
|
|
let output_size = decoder.output_buffer_size().ok_or(Error::Argument)?;
|
|
if output_size > DEFAULT_MAX_PIXELS * 4 {
|
|
return Err(Error::Argument);
|
|
}
|
|
let mut packed_pixels = Vec::new();
|
|
packed_pixels
|
|
.try_reserve_exact(output_size)
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
packed_pixels.resize(output_size, 0);
|
|
decoder
|
|
.read_image(&mut packed_pixels)
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
|
|
let has_alpha = decoder.has_alpha();
|
|
// image-webp 0.2 uses a divide-by-256 blend fast path for animated
|
|
// canvases. Its fully opaque nonzero samples are consequently one below
|
|
// Skia/libwebp's divide-by-255 result. Correct that bounded first-frame
|
|
// canvas here; partially transparent samples already use the same rounding
|
|
// as the compatibility backend.
|
|
if animated {
|
|
if has_alpha {
|
|
for rgba in packed_pixels.chunks_exact_mut(4) {
|
|
if rgba[3] == u8::MAX {
|
|
for channel in &mut rgba[..3] {
|
|
if *channel != 0 {
|
|
*channel = channel.saturating_add(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for channel in &mut packed_pixels {
|
|
if *channel != 0 {
|
|
*channel = channel.saturating_add(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let pixels = if has_alpha {
|
|
packed_pixels
|
|
} else {
|
|
let pixel_count = usize::try_from(width)
|
|
.ok()
|
|
.and_then(|width| {
|
|
usize::try_from(height)
|
|
.ok()
|
|
.and_then(|height| width.checked_mul(height))
|
|
})
|
|
.ok_or(Error::Argument)?;
|
|
let rgba_size = pixel_count.checked_mul(4).ok_or(Error::Argument)?;
|
|
let mut rgba = Vec::new();
|
|
rgba.try_reserve_exact(rgba_size)
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
for rgb in packed_pixels.chunks_exact(3) {
|
|
rgba.extend_from_slice(&[rgb[0], rgb[1], rgb[2], u8::MAX]);
|
|
}
|
|
if rgba.len() != rgba_size {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
rgba
|
|
};
|
|
let row_bytes = usize::try_from(width)
|
|
.map_err(|_| Error::Argument)?
|
|
.checked_mul(4)
|
|
.ok_or(Error::Argument)?;
|
|
let bitmap = SKBitmap::new(
|
|
width_i32,
|
|
height_i32,
|
|
row_bytes,
|
|
SKColorType::Rgba8888,
|
|
if has_alpha {
|
|
SKAlphaType::Unpremul
|
|
} else {
|
|
SKAlphaType::Opaque
|
|
},
|
|
pixels,
|
|
)?;
|
|
bitmap_to_managed(&bitmap)
|
|
}
|
|
|
|
#[cfg(feature = "skia")]
|
|
fn decode_with_skia(encoded: &[u8]) -> Result<ManagedImage, Error> {
|
|
use skia_safe::Data;
|
|
use skia_safe::codec::{Codec, Options, Result as CodecResult};
|
|
|
|
let mut codec = Codec::from_data(Data::new_copy(encoded)).ok_or(Error::InvalidOperation)?;
|
|
let source_info = codec.info();
|
|
let width = usize::try_from(source_info.width()).map_err(|_| Error::Argument)?;
|
|
let height = usize::try_from(source_info.height()).map_err(|_| Error::Argument)?;
|
|
width
|
|
.checked_mul(height)
|
|
.filter(|pixels| *pixels > 0 && *pixels <= DEFAULT_MAX_PIXELS)
|
|
.ok_or(Error::Argument)?;
|
|
// Match SKBitmap.Decode: decode into Skia's native alpha representation,
|
|
// then normalize premultiplied channels at the abstraction boundary.
|
|
let target_info = source_info.clone();
|
|
let row_bytes = target_info.min_row_bytes();
|
|
let length = target_info.compute_byte_size(row_bytes);
|
|
if length == usize::MAX || length > DEFAULT_MAX_PIXELS * 16 {
|
|
return Err(Error::Argument);
|
|
}
|
|
let mut pixels = Vec::new();
|
|
pixels
|
|
.try_reserve_exact(length)
|
|
.map_err(|_| Error::InvalidOperation)?;
|
|
pixels.resize(length, 0);
|
|
let result = codec.get_pixels_with_options(
|
|
&target_info,
|
|
&mut pixels,
|
|
row_bytes,
|
|
Some(&Options {
|
|
max_decode_memory: Some(DEFAULT_MAX_PIXELS * 16),
|
|
..Options::default()
|
|
}),
|
|
);
|
|
if result != CodecResult::Success {
|
|
return Err(Error::InvalidOperation);
|
|
}
|
|
let bitmap = SKBitmap::new(
|
|
source_info.width(),
|
|
source_info.height(),
|
|
row_bytes,
|
|
map_color_type(target_info.color_type(), target_info.bytes_per_pixel()),
|
|
map_alpha_type(target_info.alpha_type()),
|
|
pixels,
|
|
)?;
|
|
bitmap_to_managed(&bitmap)
|
|
}
|
|
|
|
#[cfg(feature = "skia")]
|
|
const fn map_color_type(color: skia_safe::ColorType, bytes_per_pixel: usize) -> SKColorType {
|
|
use skia_safe::ColorType;
|
|
match color {
|
|
ColorType::RGB565 => SKColorType::Rgb565,
|
|
ColorType::BGRA8888 => SKColorType::Bgra8888,
|
|
ColorType::RGBA8888 => SKColorType::Rgba8888,
|
|
ColorType::RGBA1010102 => SKColorType::Rgba1010102,
|
|
ColorType::BGRA1010102 => SKColorType::Bgra1010102,
|
|
ColorType::Gray8 => SKColorType::Gray8,
|
|
ColorType::Alpha8 => SKColorType::Alpha8,
|
|
_ => SKColorType::Other { bytes_per_pixel },
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "skia")]
|
|
const fn map_alpha_type(alpha: skia_safe::AlphaType) -> SKAlphaType {
|
|
use skia_safe::AlphaType;
|
|
match alpha {
|
|
AlphaType::Opaque => SKAlphaType::Opaque,
|
|
AlphaType::Premul => SKAlphaType::Premul,
|
|
AlphaType::Unpremul => SKAlphaType::Unpremul,
|
|
AlphaType::Unknown => SKAlphaType::Unknown,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn mapped_bitmap_formats_preserve_reference_channel_rules() {
|
|
let rgba = SKBitmap::new(
|
|
2,
|
|
1,
|
|
8,
|
|
SKColorType::Rgba8888,
|
|
SKAlphaType::Unpremul,
|
|
vec![1, 2, 3, 4, 5, 6, 7, 8],
|
|
)
|
|
.unwrap();
|
|
let image = SkiaTextureCodec::to_managed_image(rgba).unwrap();
|
|
assert_eq!(image.red, [1, 5]);
|
|
assert_eq!(image.green, [2, 6]);
|
|
assert_eq!(image.blue, [3, 7]);
|
|
assert_eq!(image.alpha, [4, 8]);
|
|
|
|
let rgb565 = SKBitmap::new(
|
|
3,
|
|
1,
|
|
6,
|
|
SKColorType::Rgb565,
|
|
SKAlphaType::Opaque,
|
|
vec![0x00, 0xf8, 0xe0, 0x07, 0x1f, 0x00],
|
|
)
|
|
.unwrap();
|
|
let image = SkiaTextureCodec::to_managed_image(rgb565).unwrap();
|
|
assert_eq!(image.red, [255, 0, 0]);
|
|
assert_eq!(image.green, [0, 255, 0]);
|
|
assert_eq!(image.blue, [0, 0, 255]);
|
|
|
|
// The reference fallback derives its byte width from rowBytes / width,
|
|
// even when the declared native format has a different packed width.
|
|
let padded_unknown = SKBitmap::new(
|
|
2,
|
|
1,
|
|
8,
|
|
SKColorType::Other { bytes_per_pixel: 3 },
|
|
SKAlphaType::Unpremul,
|
|
vec![3, 2, 1, 4, 7, 6, 5, 8],
|
|
)
|
|
.unwrap();
|
|
let image = SkiaTextureCodec::to_managed_image(padded_unknown).unwrap();
|
|
assert_eq!(
|
|
image.channels,
|
|
ManagedImageImageChannels::COLOR | ManagedImageImageChannels::ALPHA
|
|
);
|
|
assert_eq!(image.red, [1, 5]);
|
|
assert_eq!(image.green, [2, 6]);
|
|
assert_eq!(image.blue, [3, 7]);
|
|
assert_eq!(image.alpha, [4, 8]);
|
|
}
|
|
|
|
#[test]
|
|
fn grayscale_alpha_ten_bit_and_premul_are_converted() {
|
|
let gray = SKBitmap::new(
|
|
2,
|
|
1,
|
|
2,
|
|
SKColorType::Gray8,
|
|
SKAlphaType::Opaque,
|
|
vec![11, 239],
|
|
)
|
|
.unwrap();
|
|
let gray = SkiaTextureCodec::to_managed_image(gray).unwrap();
|
|
assert_eq!(gray.channels, ManagedImageImageChannels::GRAY);
|
|
assert_eq!(gray.red, [11, 239]);
|
|
|
|
let premul = SKBitmap::new(
|
|
1,
|
|
1,
|
|
4,
|
|
SKColorType::Bgra8888,
|
|
SKAlphaType::Premul,
|
|
vec![25, 50, 100, 128],
|
|
)
|
|
.unwrap();
|
|
let premul = SkiaTextureCodec::to_managed_image(premul).unwrap();
|
|
assert_eq!(premul.red, [199]);
|
|
assert_eq!(premul.green, [100]);
|
|
assert_eq!(premul.blue, [50]);
|
|
assert_eq!(premul.alpha, [128]);
|
|
|
|
let transparent_premul = SKBitmap::new(
|
|
1,
|
|
1,
|
|
4,
|
|
SKColorType::Rgba8888,
|
|
SKAlphaType::Premul,
|
|
vec![100, 50, 25, 0],
|
|
)
|
|
.unwrap();
|
|
let transparent_premul = SkiaTextureCodec::to_managed_image(transparent_premul).unwrap();
|
|
assert_eq!(transparent_premul.red, [0]);
|
|
assert_eq!(transparent_premul.green, [0]);
|
|
assert_eq!(transparent_premul.blue, [0]);
|
|
assert_eq!(transparent_premul.alpha, [0]);
|
|
|
|
let packed = 1023_u32 | (512 << 10) | (1 << 20) | (3 << 30);
|
|
let ten_bit = SKBitmap::new(
|
|
1,
|
|
1,
|
|
4,
|
|
SKColorType::Rgba1010102,
|
|
SKAlphaType::Unpremul,
|
|
packed.to_le_bytes().to_vec(),
|
|
)
|
|
.unwrap();
|
|
let ten_bit = SkiaTextureCodec::to_managed_image(ten_bit).unwrap();
|
|
assert_eq!(ten_bit.red, [255]);
|
|
assert_eq!(ten_bit.green, [128]);
|
|
assert_eq!(ten_bit.blue, [0]);
|
|
assert_eq!(ten_bit.alpha, [255]);
|
|
|
|
let packed = 1023_u32 | (512 << 10) | (1 << 20) | (2 << 30);
|
|
let ten_bit = SKBitmap::new(
|
|
1,
|
|
1,
|
|
4,
|
|
SKColorType::Bgra1010102,
|
|
SKAlphaType::Unpremul,
|
|
packed.to_le_bytes().to_vec(),
|
|
)
|
|
.unwrap();
|
|
let ten_bit = SkiaTextureCodec::to_managed_image(ten_bit).unwrap();
|
|
assert_eq!(ten_bit.red, [0]);
|
|
assert_eq!(ten_bit.green, [128]);
|
|
assert_eq!(ten_bit.blue, [255]);
|
|
assert_eq!(ten_bit.alpha, [170]);
|
|
}
|
|
|
|
#[test]
|
|
fn alpha_and_reference_fallback_layouts_are_converted_or_rejected() {
|
|
let alpha = SKBitmap::new(
|
|
2,
|
|
1,
|
|
2,
|
|
SKColorType::Alpha8,
|
|
SKAlphaType::Unpremul,
|
|
vec![17, 241],
|
|
)
|
|
.unwrap();
|
|
let alpha = SkiaTextureCodec::to_managed_image(alpha).unwrap();
|
|
assert_eq!(alpha.channels, ManagedImageImageChannels::ALPHA);
|
|
assert_eq!(alpha.alpha, [17, 241]);
|
|
|
|
let bgr = SKBitmap::new(
|
|
2,
|
|
1,
|
|
6,
|
|
SKColorType::Other { bytes_per_pixel: 3 },
|
|
SKAlphaType::Opaque,
|
|
vec![3, 2, 1, 6, 5, 4],
|
|
)
|
|
.unwrap();
|
|
let bgr = SkiaTextureCodec::to_managed_image(bgr).unwrap();
|
|
assert_eq!(bgr.channels, ManagedImageImageChannels::COLOR);
|
|
assert_eq!(bgr.red, [1, 4]);
|
|
assert_eq!(bgr.green, [2, 5]);
|
|
assert_eq!(bgr.blue, [3, 6]);
|
|
|
|
let gray = SKBitmap::new(
|
|
2,
|
|
1,
|
|
2,
|
|
SKColorType::Other { bytes_per_pixel: 1 },
|
|
SKAlphaType::Opaque,
|
|
vec![23, 229],
|
|
)
|
|
.unwrap();
|
|
let gray = SkiaTextureCodec::to_managed_image(gray).unwrap();
|
|
assert_eq!(gray.channels, ManagedImageImageChannels::GRAY);
|
|
assert_eq!(gray.red, [23, 229]);
|
|
|
|
let unsupported = SKBitmap::new(
|
|
1,
|
|
1,
|
|
2,
|
|
SKColorType::Other { bytes_per_pixel: 2 },
|
|
SKAlphaType::Opaque,
|
|
vec![0, 0],
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
SkiaTextureCodec::to_managed_image(unsupported),
|
|
Err(Error::InvalidOperation)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bitmap_bounds_and_feature_disabled_decode_fail_typed() {
|
|
assert_eq!(
|
|
SKBitmap::new(0, 1, 0, SKColorType::Gray8, SKAlphaType::Opaque, Vec::new(),),
|
|
Err(Error::Argument)
|
|
);
|
|
assert_eq!(
|
|
SKBitmap::new(
|
|
2,
|
|
2,
|
|
4,
|
|
SKColorType::Rgba8888,
|
|
SKAlphaType::Unpremul,
|
|
vec![0; 16],
|
|
),
|
|
Err(Error::Argument)
|
|
);
|
|
#[cfg(not(feature = "skia"))]
|
|
assert_eq!(
|
|
SkiaTextureCodec.decode(Box::new(std::io::Cursor::new(Vec::new()))),
|
|
Err(Error::InvalidOperation)
|
|
);
|
|
#[cfg(not(feature = "rust-skia"))]
|
|
assert_eq!(
|
|
RustSkiaTextureCodec.decode(Box::new(std::io::Cursor::new(Vec::new()))),
|
|
Err(Error::InvalidOperation)
|
|
);
|
|
}
|
|
|
|
#[cfg(any(feature = "rust-skia", feature = "skia"))]
|
|
fn hex_fixture(source: &str) -> Vec<u8> {
|
|
let digits: Vec<_> = source.bytes().filter(u8::is_ascii_hexdigit).collect();
|
|
assert_eq!(digits.len() % 2, 0, "fixture contains a partial byte");
|
|
digits
|
|
.chunks_exact(2)
|
|
.map(|pair| {
|
|
let high = (pair[0] as char).to_digit(16).expect("hex digit");
|
|
let low = (pair[1] as char).to_digit(16).expect("hex digit");
|
|
u8::try_from(high * 16 + low).expect("hex byte")
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
fn rust_decode(encoded: Vec<u8>) -> Result<ManagedImage, Error> {
|
|
RustSkiaTextureCodec.decode(Box::new(std::io::Cursor::new(encoded)))
|
|
}
|
|
|
|
#[cfg(any(feature = "rust-skia", feature = "skia"))]
|
|
fn checked_format_matrix() -> [(&'static str, &'static str, (i32, i32)); 19] {
|
|
[
|
|
(
|
|
"BMP 16-bit RGB555",
|
|
include_str!("../tests/fixtures/rgb555.bmp.hex"),
|
|
(2, 1),
|
|
),
|
|
(
|
|
"BMP 24-bit bottom-up",
|
|
include_str!("../tests/fixtures/bottom-up.bmp.hex"),
|
|
(8, 8),
|
|
),
|
|
(
|
|
"BMP 32-bit BGRX",
|
|
include_str!("../tests/fixtures/bgrx32.bmp.hex"),
|
|
(2, 1),
|
|
),
|
|
(
|
|
"GIF palette and frame offset",
|
|
include_str!("../tests/fixtures/palette-offset.gif.hex"),
|
|
(4, 2),
|
|
),
|
|
(
|
|
"ICO largest entry",
|
|
include_str!("../tests/fixtures/multi.ico.hex"),
|
|
(2, 2),
|
|
),
|
|
(
|
|
"JPEG baseline RGB",
|
|
include_str!("../tests/fixtures/baseline.jpg.hex"),
|
|
(8, 8),
|
|
),
|
|
(
|
|
"JPEG progressive grayscale",
|
|
include_str!("../tests/fixtures/progressive.jpg.hex"),
|
|
(128, 128),
|
|
),
|
|
(
|
|
"PNG grayscale",
|
|
include_str!("../tests/fixtures/gray.png.hex"),
|
|
(32, 32),
|
|
),
|
|
(
|
|
"PNG grayscale alpha",
|
|
include_str!("../tests/fixtures/gray-alpha.png.hex"),
|
|
(32, 32),
|
|
),
|
|
(
|
|
"PNG RGB",
|
|
include_str!("../tests/fixtures/rgb.png.hex"),
|
|
(32, 32),
|
|
),
|
|
(
|
|
"PNG RGBA",
|
|
include_str!("../tests/fixtures/rgba.png.hex"),
|
|
(32, 32),
|
|
),
|
|
(
|
|
"PNG straight alpha",
|
|
include_str!("../tests/fixtures/straight-alpha.png.hex"),
|
|
(1, 1),
|
|
),
|
|
(
|
|
"PNG interlaced palette",
|
|
include_str!("../tests/fixtures/interlaced-palette.png.hex"),
|
|
(32, 32),
|
|
),
|
|
(
|
|
"WBMP multibyte width",
|
|
include_str!("../tests/fixtures/multibyte.wbmp.hex"),
|
|
(130, 1),
|
|
),
|
|
(
|
|
"WBMP minimum-length image",
|
|
include_str!("../tests/fixtures/small.wbmp.hex"),
|
|
(2, 2),
|
|
),
|
|
(
|
|
"WebP lossless RGB",
|
|
include_str!("../tests/fixtures/rgb-lossless.webp.hex"),
|
|
(2, 2),
|
|
),
|
|
(
|
|
"WebP lossless alpha",
|
|
include_str!("../tests/fixtures/alpha.webp.hex"),
|
|
(1, 1),
|
|
),
|
|
(
|
|
"WebP lossy",
|
|
include_str!("../tests/fixtures/lossy-red.webp.hex"),
|
|
(8, 8),
|
|
),
|
|
(
|
|
"WebP animated first frame",
|
|
include_str!("../tests/fixtures/animated.webp.hex"),
|
|
(11, 29),
|
|
),
|
|
]
|
|
}
|
|
|
|
#[cfg(any(feature = "rust-skia", feature = "skia"))]
|
|
fn assert_checked_format_matrix(codec: &dyn libremetaverse_imaging::ITextureCodec) {
|
|
for (name, fixture, dimensions) in checked_format_matrix() {
|
|
let image = codec
|
|
.decode(Box::new(std::io::Cursor::new(hex_fixture(fixture))))
|
|
.unwrap_or_else(|error| panic!("{name} failed to decode: {error:?}"));
|
|
assert_eq!((image.width, image.height), dimensions, "{name}");
|
|
assert_eq!(
|
|
image.channels,
|
|
if matches!(
|
|
name,
|
|
"JPEG progressive grayscale"
|
|
| "PNG grayscale"
|
|
| "WBMP multibyte width"
|
|
| "WBMP minimum-length image"
|
|
) {
|
|
ManagedImageImageChannels::GRAY
|
|
} else {
|
|
ManagedImageImageChannels::COLOR | ManagedImageImageChannels::ALPHA
|
|
},
|
|
"{name}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
#[test]
|
|
fn rust_feature_decodes_the_checked_format_matrix() {
|
|
assert_checked_format_matrix(&RustSkiaTextureCodec);
|
|
}
|
|
|
|
#[cfg(feature = "skia")]
|
|
#[test]
|
|
fn native_feature_decodes_the_checked_format_matrix() {
|
|
assert_checked_format_matrix(&SkiaTextureCodec);
|
|
}
|
|
|
|
#[cfg(all(feature = "rust-skia", feature = "skia"))]
|
|
#[test]
|
|
fn native_and_rust_backends_match_the_shared_contract_matrix() {
|
|
fn assert_plane(name: &str, plane: &str, native: &[u8], rust: &[u8], tolerance: u8) {
|
|
assert_eq!(native.len(), rust.len(), "{name} {plane} length");
|
|
for (index, (&native, &rust)) in native.iter().zip(rust).enumerate() {
|
|
assert!(
|
|
native.abs_diff(rust) <= tolerance,
|
|
"{name} {plane}[{index}]: native={native}, rust={rust}, tolerance={tolerance}"
|
|
);
|
|
}
|
|
}
|
|
|
|
for (name, fixture, _) in checked_format_matrix() {
|
|
let bytes = hex_fixture(fixture);
|
|
let native = SkiaTextureCodec
|
|
.decode(Box::new(std::io::Cursor::new(bytes.clone())))
|
|
.unwrap_or_else(|error| panic!("native {name}: {error:?}"));
|
|
let rust = RustSkiaTextureCodec
|
|
.decode(Box::new(std::io::Cursor::new(bytes)))
|
|
.unwrap_or_else(|error| panic!("Rust {name}: {error:?}"));
|
|
assert_eq!(native.width, rust.width, "{name} width");
|
|
assert_eq!(native.height, rust.height, "{name} height");
|
|
assert_eq!(native.channels, rust.channels, "{name} channels");
|
|
let tolerance = if name.starts_with("JPEG") {
|
|
8
|
|
} else if name == "WebP lossy" {
|
|
10
|
|
} else {
|
|
0
|
|
};
|
|
assert_plane(name, "red", &native.red, &rust.red, tolerance);
|
|
assert_plane(name, "green", &native.green, &rust.green, tolerance);
|
|
assert_plane(name, "blue", &native.blue, &rust.blue, tolerance);
|
|
assert_plane(name, "alpha", &native.alpha, &rust.alpha, tolerance);
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
#[test]
|
|
fn rust_feature_preserves_canvas_orientation_selection_and_alpha() {
|
|
for fixture in [
|
|
include_str!("../tests/fixtures/two-by-two-bottom-up.bmp.hex"),
|
|
include_str!("../tests/fixtures/two-by-two-top-down.bmp.hex"),
|
|
] {
|
|
let bitmap = rust_decode(hex_fixture(fixture)).expect("oriented BMP");
|
|
assert_eq!(bitmap.red, [255, 0, 0, 255]);
|
|
assert_eq!(bitmap.green, [0, 255, 0, 255]);
|
|
assert_eq!(bitmap.blue, [0, 0, 255, 255]);
|
|
}
|
|
|
|
let gif = rust_decode(hex_fixture(include_str!(
|
|
"../tests/fixtures/palette-offset.gif.hex"
|
|
)))
|
|
.expect("GIF logical canvas");
|
|
assert_eq!((gif.width, gif.height), (4, 2));
|
|
|
|
let icon = rust_decode(hex_fixture(include_str!("../tests/fixtures/multi.ico.hex")))
|
|
.expect("largest ICO entry");
|
|
assert_eq!(icon.red, [255, 0, 0, 255]);
|
|
assert_eq!(icon.green, [0, 255, 0, 255]);
|
|
assert_eq!(icon.blue, [0, 0, 255, 255]);
|
|
|
|
let alpha = rust_decode(hex_fixture(include_str!(
|
|
"../tests/fixtures/alpha.webp.hex"
|
|
)))
|
|
.expect("alpha WebP");
|
|
assert_eq!(
|
|
(alpha.red[0], alpha.green[0], alpha.blue[0]),
|
|
(255, 255, 255)
|
|
);
|
|
assert!((127..=128).contains(&alpha.alpha[0]));
|
|
|
|
let lossy = rust_decode(hex_fixture(include_str!(
|
|
"../tests/fixtures/lossy-red.webp.hex"
|
|
)))
|
|
.expect("lossy WebP");
|
|
assert!(lossy.red.iter().all(|red| *red >= 245));
|
|
assert!(lossy.green.iter().all(|green| *green <= 10));
|
|
assert!(lossy.blue.iter().all(|blue| *blue <= 10));
|
|
assert!(lossy.alpha.iter().all(|alpha| *alpha == u8::MAX));
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
#[test]
|
|
fn rust_feature_rejects_invalid_truncated_and_oversized_input_without_panicking() {
|
|
for malformed in [Vec::new(), b"not an image".to_vec(), b"GIF89a".to_vec()] {
|
|
let result =
|
|
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| rust_decode(malformed)));
|
|
assert!(result.is_ok(), "malformed input panicked");
|
|
assert_eq!(result.expect("checked above"), Err(Error::InvalidOperation));
|
|
}
|
|
|
|
let mut pixel_bomb =
|
|
hex_fixture(include_str!("../tests/fixtures/interlaced-palette.png.hex"));
|
|
pixel_bomb[16..20].copy_from_slice(&4097_u32.to_be_bytes());
|
|
pixel_bomb[20..24].copy_from_slice(&4097_u32.to_be_bytes());
|
|
assert_eq!(rust_decode(pixel_bomb), Err(Error::Argument));
|
|
|
|
let mut gif_frame_bomb =
|
|
hex_fixture(include_str!("../tests/fixtures/palette-offset.gif.hex"));
|
|
let descriptor = gif_frame_bomb[109..]
|
|
.iter()
|
|
.position(|byte| *byte == 0x2c)
|
|
.map(|offset| offset + 109)
|
|
.expect("first GIF image descriptor");
|
|
gif_frame_bomb[descriptor + 5..descriptor + 7].copy_from_slice(&u16::MAX.to_le_bytes());
|
|
gif_frame_bomb[descriptor + 7..descriptor + 9].copy_from_slice(&u16::MAX.to_le_bytes());
|
|
assert_eq!(rust_decode(gif_frame_bomb), Err(Error::Argument));
|
|
|
|
let mut malformed_gif_palette =
|
|
hex_fixture(include_str!("../tests/fixtures/palette-offset.gif.hex"));
|
|
// Advertise a 256-entry global palette while retaining the fixture's
|
|
// much smaller checked table. Preflight must reject the missing table
|
|
// before the decoder can allocate or index palette storage.
|
|
malformed_gif_palette[10] = (malformed_gif_palette[10] & 0xf8) | 0x07;
|
|
assert_eq!(
|
|
rust_decode(malformed_gif_palette),
|
|
Err(Error::InvalidOperation)
|
|
);
|
|
|
|
let mut icon_embedded_bomb = hex_fixture(include_str!("../tests/fixtures/multi.ico.hex"));
|
|
icon_embedded_bomb[86..90].copy_from_slice(&4097_i32.to_le_bytes());
|
|
icon_embedded_bomb[90..94].copy_from_slice(&8194_i32.to_le_bytes());
|
|
assert_eq!(rust_decode(icon_embedded_bomb), Err(Error::Argument));
|
|
|
|
let over_limit = vec![0_u8; DEFAULT_MAX_ENCODED_BYTES + 1];
|
|
assert_eq!(rust_decode(over_limit), Err(Error::Argument));
|
|
|
|
for fixture in [
|
|
include_str!("../tests/fixtures/bottom-up.bmp.hex"),
|
|
include_str!("../tests/fixtures/palette-offset.gif.hex"),
|
|
include_str!("../tests/fixtures/multi.ico.hex"),
|
|
include_str!("../tests/fixtures/interlaced-palette.png.hex"),
|
|
include_str!("../tests/fixtures/alpha.webp.hex"),
|
|
] {
|
|
let mut bytes = hex_fixture(fixture);
|
|
bytes.truncate(bytes.len() / 2);
|
|
let result =
|
|
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| rust_decode(bytes)));
|
|
assert!(result.is_ok(), "truncated input panicked");
|
|
assert!(result.expect("checked above").is_err());
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
struct DropStream {
|
|
cursor: std::io::Cursor<Vec<u8>>,
|
|
drops: std::sync::Arc<std::sync::atomic::AtomicUsize>,
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
impl std::io::Read for DropStream {
|
|
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
|
|
std::io::Read::read(&mut self.cursor, buffer)
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
impl std::io::Write for DropStream {
|
|
fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
|
|
std::io::Write::write(&mut self.cursor, buffer)
|
|
}
|
|
|
|
fn flush(&mut self) -> std::io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
impl std::io::Seek for DropStream {
|
|
fn seek(&mut self, position: std::io::SeekFrom) -> std::io::Result<u64> {
|
|
std::io::Seek::seek(&mut self.cursor, position)
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
impl Drop for DropStream {
|
|
fn drop(&mut self) {
|
|
self.drops.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "rust-skia")]
|
|
#[test]
|
|
fn rust_feature_is_thread_safe_across_repeated_decode_and_drop() {
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
|
|
fn assert_texture_codec<T: libremetaverse_imaging::ITextureCodec + Send + Sync>() {}
|
|
assert_texture_codec::<RustSkiaTextureCodec>();
|
|
|
|
let codec = Arc::new(RustSkiaTextureCodec);
|
|
let png = Arc::new(hex_fixture(include_str!(
|
|
"../tests/fixtures/interlaced-palette.png.hex"
|
|
)));
|
|
let mut workers = Vec::new();
|
|
for _ in 0..8 {
|
|
let codec = Arc::clone(&codec);
|
|
let png = Arc::clone(&png);
|
|
workers.push(std::thread::spawn(move || {
|
|
for _ in 0..16 {
|
|
let image = codec
|
|
.decode(Box::new(std::io::Cursor::new((*png).clone())))
|
|
.expect("concurrent PNG decode");
|
|
assert_eq!((image.width, image.height), (32, 32));
|
|
let repeated = codec
|
|
.decode(Box::new(std::io::Cursor::new((*png).clone())))
|
|
.expect("repeated concurrent PNG decode");
|
|
assert_eq!(image, repeated);
|
|
}
|
|
}));
|
|
}
|
|
for worker in workers {
|
|
worker.join().expect("decoder worker did not panic");
|
|
}
|
|
|
|
let drops = Arc::new(AtomicUsize::new(0));
|
|
let stream = DropStream {
|
|
cursor: std::io::Cursor::new((*png).clone()),
|
|
drops: Arc::clone(&drops),
|
|
};
|
|
codec.decode(Box::new(stream)).expect("drop-probe decode");
|
|
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[cfg(feature = "skia")]
|
|
#[test]
|
|
fn feature_decodes_known_png_with_straight_alpha() {
|
|
const PNG: &[u8] = &[
|
|
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48,
|
|
0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00,
|
|
0x00, 0x1f, 0x15, 0xc4, 0x89, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x44, 0x41, 0x54, 0x78,
|
|
0x9c, 0x63, 0xf8, 0xcf, 0xc0, 0xf0, 0x1f, 0x00, 0x05, 0x00, 0x01, 0xff, 0x89, 0x99,
|
|
0x3d, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
|
|
];
|
|
let image = SkiaTextureCodec
|
|
.decode(Box::new(std::io::Cursor::new(PNG.to_vec())))
|
|
.expect("decode PNG");
|
|
assert_eq!((image.width, image.height), (1, 1));
|
|
assert_eq!(image.red, [255]);
|
|
assert_eq!(image.green, [0]);
|
|
assert_eq!(image.blue, [0]);
|
|
assert_eq!(image.alpha, [255]);
|
|
|
|
assert_eq!(
|
|
SkiaTextureCodec.decode(Box::new(std::io::Cursor::new(Vec::new()))),
|
|
Err(Error::InvalidOperation)
|
|
);
|
|
assert_eq!(
|
|
SkiaTextureCodec.decode(Box::new(std::io::Cursor::new(b"not an image".to_vec()))),
|
|
Err(Error::InvalidOperation)
|
|
);
|
|
}
|
|
|
|
#[cfg(feature = "skia")]
|
|
#[test]
|
|
fn feature_decodes_webp_from_the_cross_platform_cache_configuration() {
|
|
const WEBP: &[u8] = &[
|
|
0x52, 0x49, 0x46, 0x46, 0x1c, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50, 0x56, 0x50,
|
|
0x38, 0x4c, 0x0f, 0x00, 0x00, 0x00, 0x2f, 0x01, 0x40, 0x00, 0x00, 0x07, 0x10, 0xf5,
|
|
0x8f, 0xfe, 0x07, 0x22, 0xa2, 0xff, 0x01, 0x00,
|
|
];
|
|
let image = SkiaTextureCodec
|
|
.decode(Box::new(std::io::Cursor::new(WEBP.to_vec())))
|
|
.expect("decode WebP");
|
|
assert_eq!((image.width, image.height), (2, 2));
|
|
assert_eq!(image.red, [254; 4]);
|
|
assert_eq!(image.green, [0; 4]);
|
|
assert_eq!(image.blue, [0; 4]);
|
|
assert_eq!(image.alpha, [255; 4]);
|
|
}
|
|
}
|