use std::borrow::Cow;
use super::asset::Result;
use super::load_budget::{Budget, DEFAULT_LOAD_BYTES, LoadBudget, MAX_IMAGE_SIDE};
#[derive(Clone, Debug)]
pub enum Image {
Rgba8(image::RgbaImage),
Compressed(CompressedImage),
Rgba8Mips(Rgba8MipChain),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CompressedFormat {
Bc7,
Etc2Rgba8,
Astc4x4,
}
#[derive(Clone, Debug)]
pub struct CompressedImage {
pub format: CompressedFormat,
pub width: u32,
pub height: u32,
pub levels: Vec<Vec<u8>>,
pub decoded_level_0: Option<image::RgbaImage>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ImageError {
InvalidDimensions,
BudgetExceeded,
}
impl std::fmt::Display for ImageError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::InvalidDimensions => "image sides must be between 1 and 16384 texels",
Self::BudgetExceeded => "prepared mip chains exceed the load budget or addressable filtering allocation; split or resize the image",
})
}
}
impl std::error::Error for ImageError {}
#[derive(Clone, Debug)]
pub struct Rgba8MipChain {
color: Vec<image::RgbaImage>,
data: Vec<image::RgbaImage>,
}
impl Rgba8MipChain {
pub fn new(image: image::RgbaImage) -> std::result::Result<Self, ImageError> {
check_mip_allocation(image.dimensions(), DEFAULT_LOAD_BYTES, isize::MAX as u64)?;
Ok(Self {
color: rgba8_levels(&image, true),
data: rgba8_levels(&image, false),
})
}
pub fn levels(&self, srgb: bool) -> &[image::RgbaImage] {
if srgb { &self.color } else { &self.data }
}
}
fn check_mip_allocation(
(width, height): (u32, u32),
budget: u64,
allocation_max: u64,
) -> std::result::Result<(), ImageError> {
if width == 0 || height == 0 || width.max(height) > MAX_IMAGE_SIDE {
return Err(ImageError::InvalidDimensions);
}
let mut retained = 0u64;
let (mut w, mut h) = (width, height);
loop {
retained = retained
.checked_add(u64::from(w) * u64::from(h) * 8)
.ok_or(ImageError::BudgetExceeded)?;
if w == 1 && h == 1 {
break;
}
w = (w / 2).max(1);
h = (h / 2).max(1);
}
let scratch = if width.max(height) > 1 {
u64::from(width) * u64::from(height) * 16
} else {
0
};
if retained > budget || scratch > allocation_max {
return Err(ImageError::BudgetExceeded);
}
Ok(())
}
pub(crate) fn rgba8_levels(image: &image::RgbaImage, srgb: bool) -> Vec<image::RgbaImage> {
let mut levels = vec![image.clone()];
while levels
.last()
.unwrap()
.width()
.max(levels.last().unwrap().height())
> 1
{
let mip = levels.last().unwrap();
let mut linear = image::Rgba32FImage::new(mip.width(), mip.height());
for (to, from) in linear.pixels_mut().zip(mip.pixels()) {
for c in 0..4 {
let x = from[c] as f32 / 255.0;
to[c] = if srgb && c < 3 {
super::srgb::to_linear(x)
} else {
x
};
}
}
let small = image::imageops::resize(
&linear,
(mip.width() / 2).max(1),
(mip.height() / 2).max(1),
image::imageops::FilterType::Triangle,
);
let mut mip = image::RgbaImage::new(small.width(), small.height());
for (to, from) in mip.pixels_mut().zip(small.pixels()) {
for c in 0..4 {
let x = if srgb && c < 3 {
super::srgb::from_linear(from[c])
} else {
from[c]
};
to[c] = (x.clamp(0.0, 1.0) * 255.0).round() as u8;
}
}
levels.push(mip);
}
levels
}
const BLOCK: u32 = 4;
const BLOCK_BYTES: usize = 16;
fn check_ktx2_dfd(bytes: &[u8]) -> Result<()> {
let raw = bytes
.get(..ktx2::Header::LENGTH)
.ok_or("invalid KTX2 file: truncated header")?;
let header = ktx2::Header::from_bytes(raw.try_into()?)
.map_err(|error| format!("invalid KTX2 file: {error}"))?;
let index = header.index;
let end = index
.dfd_byte_offset
.checked_add(index.dfd_byte_length)
.ok_or("invalid KTX2 data format descriptor: range overflow")?;
let descriptor = bytes
.get(index.dfd_byte_offset as usize..end as usize)
.ok_or("invalid KTX2 data format descriptor: truncated section")?;
let mut blocks = descriptor
.get(4..)
.ok_or("invalid KTX2 data format descriptor: truncated size")?;
while !blocks.is_empty() {
let header = blocks
.get(..ktx2::dfd::BlockHeader::LENGTH)
.ok_or("invalid KTX2 data format descriptor: truncated block header")?;
let size = u16::from_le_bytes(header[6..8].try_into()?) as usize;
if size < ktx2::dfd::BlockHeader::LENGTH {
return Err(
"invalid KTX2 data format descriptor: block shorter than its header".into(),
);
}
let block = blocks
.get(..size)
.ok_or("invalid KTX2 data format descriptor: truncated block")?;
if header[..6] == ktx2::dfd::BlockHeader::BASIC.as_bytes(0)[..6] {
let dimensions = block
.get(12..16)
.ok_or("invalid KTX2 data format descriptor: truncated dimensions")?;
if dimensions.contains(&0xff) {
return Err(
"invalid KTX2 data format descriptor: unsupported texel-block dimension".into(),
);
}
}
blocks = &blocks[size..];
}
Ok(())
}
impl Image {
pub(super) fn charge_bytes(&self, budget: &mut Budget) -> Result<()> {
match self {
Self::Rgba8(image) => budget.charge(image.as_raw().len() as u64),
Self::Rgba8Mips(image) => {
for level in image.color.iter().chain(&image.data) {
budget.charge(level.as_raw().len() as u64)?;
}
Ok(())
}
Self::Compressed(image) => {
for level in &image.levels {
budget.charge(level.len() as u64)?;
}
if let Some(decoded) = &image.decoded_level_0 {
budget.charge(decoded.as_raw().len() as u64)?;
}
Ok(())
}
}
}
pub(crate) fn size(&self) -> [u32; 2] {
match self {
Self::Rgba8(image) => [image.width(), image.height()],
Self::Rgba8Mips(image) => [
image.levels(false)[0].width(),
image.levels(false)[0].height(),
],
Self::Compressed(image) => [image.width, image.height],
}
}
pub(crate) fn texels(&self) -> Option<Cow<'_, image::RgbaImage>> {
Some(match self {
Self::Rgba8(image) => Cow::Borrowed(image),
Self::Rgba8Mips(image) => Cow::Borrowed(&image.levels(false)[0]),
Self::Compressed(image) => match &image.decoded_level_0 {
Some(texels) => Cow::Borrowed(texels),
None if image.format == CompressedFormat::Bc7 => Cow::Owned(image.decode_level_0()),
None => return None,
},
})
}
}
impl CompressedImage {
pub fn from_ktx2(bytes: &[u8]) -> Result<Self> {
Self::from_ktx2_with_budget(bytes, LoadBudget::default())
}
pub fn from_ktx2_with_budget(bytes: &[u8], budget: LoadBudget) -> Result<Self> {
Budget::source(budget).charge(bytes.len() as u64)?;
Self::read_ktx2(bytes, &mut Budget::decoded(budget))
}
pub fn from_ktx2_with_decoded_level_0(bytes: &[u8], decoded: image::RgbaImage) -> Result<Self> {
Self::from_ktx2_with_decoded_level_0_and_budget(bytes, decoded, LoadBudget::default())
}
pub fn from_ktx2_with_decoded_level_0_and_budget(
bytes: &[u8],
decoded: image::RgbaImage,
budget: LoadBudget,
) -> Result<Self> {
Budget::source(budget).charge(bytes.len() as u64)?;
Self::read_ktx2_with_decoded(bytes, Some(decoded), &mut Budget::decoded(budget))
}
fn read_ktx2(bytes: &[u8], budget: &mut Budget) -> Result<Self> {
Self::read_ktx2_with_decoded(bytes, None, budget)
}
fn read_ktx2_with_decoded(
bytes: &[u8],
decoded_level_0: Option<image::RgbaImage>,
budget: &mut Budget,
) -> Result<Self> {
check_ktx2_dfd(bytes)?;
let reader =
ktx2::Reader::new(bytes).map_err(|error| format!("invalid KTX2 file: {error}"))?;
let header = reader.header();
let format = match header.format {
Some(ktx2::Format::BC7_UNORM_BLOCK | ktx2::Format::BC7_SRGB_BLOCK) => {
CompressedFormat::Bc7
}
Some(
ktx2::Format::ETC2_R8G8B8A8_UNORM_BLOCK | ktx2::Format::ETC2_R8G8B8A8_SRGB_BLOCK,
) => CompressedFormat::Etc2Rgba8,
Some(ktx2::Format::ASTC_4x4_UNORM_BLOCK | ktx2::Format::ASTC_4x4_SRGB_BLOCK) => {
CompressedFormat::Astc4x4
}
other => {
return Err(format!(
"KTX2 format {other:?} is not supported; store BC7, ETC2 RGBA8 or ASTC LDR 4x4"
)
.into());
}
};
if header.pixel_depth > 1 || header.layer_count > 1 || header.face_count != 1 {
return Err("a KTX2 material image must be one 2D image".into());
}
if header.level_count == 0 {
return Err("the KTX2 file asks for generated mips; store its mip chain".into());
}
let mut image = Self {
format,
width: header.pixel_width,
height: header.pixel_height.max(1),
levels: Vec::new(),
decoded_level_0,
};
let full = 32 - image.width.max(image.height).leading_zeros();
if image.width == 0
|| image.width > MAX_IMAGE_SIDE
|| image.height > MAX_IMAGE_SIDE
|| !image.width.is_multiple_of(BLOCK)
|| !image.height.is_multiple_of(BLOCK)
|| header.level_count > full
{
return Err(format!("invalid KTX2 dimensions or mip count; store block-aligned sides no larger than {MAX_IMAGE_SIDE} and at most a full mip chain").into());
}
if !image.companion_is_valid() {
return Err("BC7 must have no decoded companion; any ETC2/ASTC decoded level 0 must match the compressed dimensions".into());
}
if let Some(decoded) = &image.decoded_level_0 {
budget.charge(decoded.as_raw().len() as u64)?;
}
for (index, level) in reader.levels().enumerate() {
let expected = image.level_bytes(index);
if level.uncompressed_byte_length != expected as u64 {
return Err(format!(
"KTX2 level {index} declares {} decoded bytes; expected {expected}",
level.uncompressed_byte_length
)
.into());
}
budget.charge(expected as u64)?;
}
image.levels = reader
.levels()
.enumerate()
.map(|(index, level)| {
let expected = image.level_bytes(index);
let decoded = match header.supercompression_scheme {
None => {
if level.data.len() != expected {
return Err(format!(
"KTX2 level {index} has {} bytes; expected {expected}",
level.data.len()
)
.into());
}
level.data.to_vec()
}
Some(ktx2::SupercompressionScheme::Zstandard) => {
let mut decoded = Vec::new();
crate::content::zstandard::decompress(
level.data,
expected + 1,
&mut decoded,
)
.map_err(|error| format!("KTX2 level {index}: {error}"))?;
decoded
}
Some(other) => return Err(format!(
"KTX2 supercompression {other:?} is not supported; use Zstandard or none"
)
.into()),
};
if decoded.len() != expected {
return Err(format!(
"KTX2 level {index} decoded to {} bytes; expected {expected}",
decoded.len()
)
.into());
}
Ok(decoded)
})
.collect::<Result<Vec<_>>>()?;
Ok(image)
}
pub(crate) fn level_bytes(&self, level: usize) -> usize {
let side = |size: u32| (size >> level).max(1).div_ceil(BLOCK) as usize;
side(self.width) * side(self.height) * BLOCK_BYTES
}
pub(crate) fn is_valid(&self) -> bool {
let full = (32 - self.width.max(self.height).leading_zeros()) as usize;
self.width > 0
&& self.height > 0
&& self.companion_is_valid()
&& self.width.is_multiple_of(BLOCK)
&& self.height.is_multiple_of(BLOCK)
&& self.width <= MAX_IMAGE_SIDE
&& self.height <= MAX_IMAGE_SIDE
&& (1..=full).contains(&self.levels.len())
&& self
.levels
.iter()
.enumerate()
.all(|(level, bytes)| bytes.len() == self.level_bytes(level))
}
fn companion_is_valid(&self) -> bool {
match (self.format, &self.decoded_level_0) {
(_, None) => true,
(CompressedFormat::Etc2Rgba8 | CompressedFormat::Astc4x4, Some(decoded)) => {
decoded.dimensions() == (self.width, self.height)
}
_ => false,
}
}
fn decode_level_0(&self) -> image::RgbaImage {
let mut texels = image::RgbaImage::new(self.width, self.height);
let pitch = self.width as usize * 4;
let blocks_wide = (self.width / BLOCK) as usize;
let rows = texels.chunks_exact_mut(pitch * BLOCK as usize);
for (blocks, row) in self.levels[0]
.chunks_exact(blocks_wide * BLOCK_BYTES)
.zip(rows)
{
for (column, block) in blocks.chunks_exact(BLOCK_BYTES).enumerate() {
let at = column * BLOCK as usize * 4;
match self.format {
CompressedFormat::Bc7 => bcdec_rs::bc7(block, &mut row[at..], pitch),
_ => unreachable!("browser formats require a predecoded companion"),
}
}
}
texels
}
}
#[cfg(all(test, target_arch = "wasm32"))]
#[allow(dead_code)]
#[path = "../../tests/fixtures/ktx2_writer.rs"]
mod ktx2_writer;
#[cfg(test)]
mod tests {
#[cfg(target_arch = "wasm32")]
use super::ktx2_writer::ktx2;
use super::*;
#[cfg(not(target_arch = "wasm32"))]
use crate::test_support::ktx2;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn explicit_ktx2_budgets_cover_source_chain_and_companion() {
for zstd in [false, true] {
let levels = vec![vec![11; 16], vec![22; 16]];
let file = ktx2(ktx2::Format::BC7_UNORM_BLOCK, [4; 2], &levels, zstd);
let bytes = file.len() as u64;
let error = CompressedImage::from_ktx2_with_budget(
&file,
LoadBudget::new(bytes - 1, 32).unwrap(),
)
.unwrap_err()
.to_string();
assert!(
error.contains("source load budget")
&& error.contains(&format!("requested {bytes} bytes")),
"{error}"
);
let error =
CompressedImage::from_ktx2_with_budget(&file, LoadBudget::new(bytes, 31).unwrap())
.unwrap_err()
.to_string();
assert!(
error.contains("decoded load budget") && error.contains("limit 31 bytes"),
"{error}"
);
let image =
CompressedImage::from_ktx2_with_budget(&file, LoadBudget::new(bytes, 32).unwrap())
.unwrap();
assert_eq!(image.levels, levels);
let file = ktx2(
ktx2::Format::ASTC_4x4_UNORM_BLOCK,
[4; 2],
&[vec![7; 16]],
zstd,
);
let companion = image::RgbaImage::from_pixel(4, 4, image::Rgba([20, 30, 40, 255]));
let error = CompressedImage::from_ktx2_with_decoded_level_0_and_budget(
&file,
companion.clone(),
LoadBudget::new(file.len() as u64, 79).unwrap(),
)
.unwrap_err()
.to_string();
assert!(
error.contains("decoded load budget") && error.contains("limit 79 bytes"),
"{error}"
);
let image = CompressedImage::from_ktx2_with_decoded_level_0_and_budget(
&file,
companion.clone(),
LoadBudget::new(file.len() as u64, 80).unwrap(),
)
.unwrap();
assert_eq!(image.decoded_level_0.as_ref(), Some(&companion));
}
}
#[wasm_bindgen_test(unsupported = test)]
fn raised_ktx2_budgets_never_relax_structure_validation() {
let budget = LoadBudget::new(isize::MAX as u64, isize::MAX as u64).unwrap();
let file = ktx2(
ktx2::Format::BC7_UNORM_BLOCK,
[16388, 4],
&[vec![0; 16]],
false,
);
let error = CompressedImage::from_ktx2_with_budget(&file, budget)
.unwrap_err()
.to_string();
assert!(error.contains("dimensions"), "{error}");
let mut file = ktx2(ktx2::Format::BC7_UNORM_BLOCK, [4; 2], &[vec![0; 16]], false);
let decoded_at = ktx2::Header::LENGTH + 16;
file[decoded_at..decoded_at + 8].copy_from_slice(&u64::MAX.to_le_bytes());
let error = CompressedImage::from_ktx2_with_budget(&file, budget)
.unwrap_err()
.to_string();
assert!(
error.contains("declares 18446744073709551615 decoded bytes; expected 16"),
"{error}"
);
}
#[wasm_bindgen_test(unsupported = test)]
fn mip_expansion_is_preflighted_without_allocating_images() {
assert_eq!(
check_mip_allocation((2, 2), 39, u64::MAX),
Err(ImageError::BudgetExceeded)
);
assert_eq!(
check_mip_allocation((2, 2), 40, 63),
Err(ImageError::BudgetExceeded)
);
assert_eq!(check_mip_allocation((2, 2), 40, 64), Ok(()));
assert_eq!(
check_mip_allocation((16384, 16384), 1 << 30, u32::MAX as u64),
Err(ImageError::BudgetExceeded)
);
assert_eq!(
check_mip_allocation((16384, 16384), 4 << 30, 4 << 30),
Ok(())
);
assert_eq!(
check_mip_allocation((16385, 1), u64::MAX, u64::MAX),
Err(ImageError::InvalidDimensions)
);
}
#[wasm_bindgen_test(unsupported = test)]
fn prepared_rgba_mips_filter_colour_and_data_separately() {
fn send<T: Send>() {}
send::<Rgba8MipChain>();
send::<ImageError>();
assert!(Rgba8MipChain::new(image::RgbaImage::new(0, 4)).is_err());
assert!(Rgba8MipChain::new(image::RgbaImage::new(16385, 1)).is_err());
let source =
image::RgbaImage::from_fn(2, 1, |x, _| image::Rgba([if x == 0 { 0 } else { 255 }; 4]));
let prepared = Rgba8MipChain::new(source.clone()).unwrap();
assert_eq!(prepared.levels(true)[0], source);
assert_eq!(prepared.levels(false)[0], source);
assert_eq!(prepared.levels(false)[1].get_pixel(0, 0).0, [128; 4]);
assert_eq!(
prepared.levels(true)[1].get_pixel(0, 0).0,
[188, 188, 188, 128]
);
let odd = Rgba8MipChain::new(image::RgbaImage::new(7, 5)).unwrap();
assert_eq!(
odd.levels(false)
.iter()
.map(|m| m.dimensions())
.collect::<Vec<_>>(),
[(7, 5), (3, 2), (1, 1)]
);
}
#[wasm_bindgen_test(unsupported = test)]
fn browser_compressed_levels_allow_optional_budgeted_matching_companions() {
for format in [
ktx2::Format::ETC2_R8G8B8A8_UNORM_BLOCK,
ktx2::Format::ASTC_4x4_SRGB_BLOCK,
] {
for zstd in [false, true] {
let levels = vec![vec![0xff; 16], vec![0; 16], vec![42; 16]];
let file = ktx2(format, [4; 2], &levels, zstd);
let raster = CompressedImage::from_ktx2(&file).unwrap();
assert_eq!(raster.levels, levels);
assert!(raster.decoded_level_0.is_none());
assert!(raster.is_valid());
assert!(Image::Compressed(raster).texels().is_none());
let decoded = image::RgbaImage::from_pixel(4, 4, image::Rgba([20, 60, 100, 128]));
let image = CompressedImage::from_ktx2_with_decoded_level_0(&file, decoded.clone())
.unwrap();
assert_eq!(image.levels, levels);
assert_eq!(image.decoded_level_0.as_ref(), Some(&decoded));
assert!(image.is_valid());
assert_eq!(
Image::Compressed(image).texels().unwrap().as_ref(),
&decoded
);
let wrong = image::RgbaImage::new(8, 4);
assert!(CompressedImage::from_ktx2_with_decoded_level_0(&file, wrong).is_err());
let error = CompressedImage::read_ktx2_with_decoded(
&file,
Some(decoded),
&mut Budget::new(111, "decoded"),
)
.unwrap_err();
assert!(error.to_string().contains("budget"));
}
}
let file = ktx2(ktx2::Format::BC7_UNORM_BLOCK, [4; 2], &[vec![0; 16]], false);
assert!(
CompressedImage::from_ktx2_with_decoded_level_0(&file, image::RgbaImage::new(4, 4))
.is_err()
);
}
#[wasm_bindgen_test(unsupported = test)]
fn hostile_astc_payloads_are_stored_without_cpu_decoding() {
let mut seed = 17u64;
for _ in 0..256 {
let mut block = vec![0; 16];
for byte in &mut block {
seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1);
*byte = (seed >> 32) as u8;
}
let file = ktx2(
ktx2::Format::ASTC_4x4_UNORM_BLOCK,
[4; 2],
&[block.clone()],
false,
);
let decoded = image::RgbaImage::new(4, 4);
let loaded =
CompressedImage::from_ktx2_with_decoded_level_0(&file, decoded.clone()).unwrap();
assert_eq!(loaded.levels[0], block);
assert_eq!(
Image::Compressed(loaded).texels().unwrap().as_ref(),
&decoded
);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn ktx2_invalid_descriptor_dimensions_return_an_error() {
let valid = ktx2(ktx2::Format::BC7_UNORM_BLOCK, [4; 2], &[vec![0; 16]], false);
assert!(CompressedImage::from_ktx2(&valid).is_ok());
let dfd = u32::from_le_bytes(valid[48..52].try_into().unwrap()) as usize;
for axis in 0..4 {
let mut file = valid.clone();
file[dfd + 16 + axis] = 0xff;
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(error.contains("data format descriptor"), "{error}");
}
}
#[wasm_bindgen_test(unsupported = test)]
fn ktx2_zstandard_output_is_bounded_by_the_expected_size() {
let mut file = ktx2(
ktx2::Format::BC7_UNORM_BLOCK,
[4; 2],
&[vec![0; 65536]],
true,
);
file[96..104].copy_from_slice(&16u64.to_le_bytes());
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(error.contains("level 0: output limit exceeded"), "{error}");
let short = ktx2(ktx2::Format::BC7_UNORM_BLOCK, [4; 2], &[vec![0; 15]], true);
let mut short = short;
short[96..104].copy_from_slice(&16u64.to_le_bytes());
let error = CompressedImage::from_ktx2(&short).unwrap_err().to_string();
assert!(
error.contains("decoded to 15 bytes; expected 16"),
"{error}"
);
}
#[wasm_bindgen_test(unsupported = test)]
fn ktx2_large_zstandard_window_does_not_allocate_before_output_refusal() {
let frame = [0x28, 0xb5, 0x2f, 0xfd, 0x00, 0xa0, 0x03, 0x00, 0x10, 42];
let file = with_frame([4; 2], 16, &frame);
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(
error.contains("level 0") && error.contains("output limit exceeded"),
"{error}"
);
let mut output = Vec::new();
assert_eq!(
crate::content::zstandard::decompress(&frame, 17, &mut output),
Err(crate::content::zstandard::Error::OutputLimit)
);
assert_eq!(output.capacity(), 0);
}
#[wasm_bindgen_test(unsupported = test)]
fn ktx2_malformed_sequence_expansion_is_refused_before_output() {
let frame = [
0x28, 0xb5, 0x2f, 0xfd, 0x00, 0x38, 0x6d, 0x00, 0x00, 0x10, b'A', b'A', 2, 0x54, 1, 0, 52, 0xff, 0xff, 0xff, 0xff, 1, ];
let file = with_frame([512; 2], 262144, &frame);
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(error.contains("Block_Maximum_Size"), "{error}");
let mut output = Vec::new();
assert!(matches!(
crate::content::zstandard::decompress(&frame, 262144, &mut output),
Err(crate::content::zstandard::Error::Corrupt(
"block regenerates more than Block_Maximum_Size"
))
));
assert_eq!(output.capacity(), 0);
}
#[wasm_bindgen_test(unsupported = test)]
fn ktx2_malformed_literal_expansion_is_refused_before_scratch_growth() {
let frame = [
0x28, 0xb5, 0x2f, 0xfd, 0x00, 0x38, 0x2d, 0,
0, 0xfd, 0xff, 0x3f, b'A', 0, ];
let file = with_frame([512; 2], 262144, &frame);
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(error.contains("literals larger than a block"), "{error}");
}
fn with_frame(size: [u32; 2], expected: u64, frame: &[u8]) -> Vec<u8> {
let mut file = ktx2(ktx2::Format::BC7_UNORM_BLOCK, size, &[vec![0; 16]], true);
let at = u64::from_le_bytes(file[80..88].try_into().unwrap()) as usize;
file[88..96].copy_from_slice(&(frame.len() as u64).to_le_bytes());
file[96..104].copy_from_slice(&expected.to_le_bytes());
file.truncate(at);
file.extend_from_slice(frame);
file
}
#[wasm_bindgen_test(unsupported = test)]
fn ktx2_charges_the_whole_chain_before_decompressing() {
let mut file = ktx2(
ktx2::Format::BC7_UNORM_BLOCK,
[4; 2],
&[vec![0; 16], vec![0; 16]],
true,
);
let at = u64::from_le_bytes(file[80..88].try_into().unwrap()) as usize;
file[at] = 0; let error = CompressedImage::read_ktx2(&file, &mut Budget::new(24, "decoded"))
.unwrap_err()
.to_string();
assert!(error.contains("budget"), "{error}");
}
#[wasm_bindgen_test(unsupported = test)]
fn ktx2_rejects_invalid_shapes_and_level_sizes_during_load() {
for size in [[3, 4], [20000, 20000], [u32::MAX; 2]] {
let file = ktx2(ktx2::Format::BC7_UNORM_BLOCK, size, &[vec![0; 16]], true);
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(error.contains("dimensions"), "{error}");
}
let file = ktx2(
ktx2::Format::BC7_UNORM_BLOCK,
[4; 2],
&vec![vec![0; 16]; 4],
false,
);
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(error.contains("mip count"), "{error}");
for zstd in [false, true] {
let file = ktx2(ktx2::Format::BC7_UNORM_BLOCK, [4; 2], &[vec![0; 15]], zstd);
let error = CompressedImage::from_ktx2(&file).unwrap_err().to_string();
assert!(
error.contains("declares 15 decoded bytes; expected 16"),
"{error}"
);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn a_game_built_image_past_the_side_bound_is_invalid() {
let image = CompressedImage {
format: CompressedFormat::Bc7,
decoded_level_0: None,
width: 65536,
height: 65536,
levels: vec![vec![0; 16]],
};
assert!(!image.is_valid());
}
}