use std::borrow::Cow;
use std::io::Read;
use super::asset::Result;
#[derive(Clone, Debug)]
pub enum Image {
Rgba8(image::RgbaImage),
Compressed(CompressedImage),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CompressedFormat {
Bc7,
}
#[derive(Clone, Debug)]
pub struct CompressedImage {
pub format: CompressedFormat,
pub width: u32,
pub height: u32,
pub levels: Vec<Vec<u8>>,
}
const BLOCK: u32 = 4;
const BLOCK_BYTES: usize = 16;
impl Image {
pub(crate) fn size(&self) -> [u32; 2] {
match self {
Self::Rgba8(image) => [image.width(), image.height()],
Self::Compressed(image) => [image.width, image.height],
}
}
pub(crate) fn texels(&self) -> Cow<'_, image::RgbaImage> {
match self {
Self::Rgba8(image) => Cow::Borrowed(image),
Self::Compressed(image) => Cow::Owned(image.decode_level_0()),
}
}
}
impl CompressedImage {
pub fn from_ktx2(bytes: &[u8]) -> Result<Self> {
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
}
other => {
return Err(format!("KTX2 format {other:?} is not supported; store BC7").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 levels = reader
.levels()
.enumerate()
.map(|(index, level)| match header.supercompression_scheme {
None => Ok(level.data.to_vec()),
Some(ktx2::SupercompressionScheme::Zstandard) => {
let mut decoded = Vec::new();
ruzstd::decoding::StreamingDecoder::new(level.data)
.map_err(|error| error.to_string())
.and_then(|mut decoder| {
decoder
.read_to_end(&mut decoded)
.map_err(|error| error.to_string())
})
.map_err(|error| format!("KTX2 level {index}: {error}"))?;
Ok(decoded)
}
Some(other) => Err(format!(
"KTX2 supercompression {other:?} is not supported; use Zstandard or none"
)
.into()),
})
.collect::<Result<Vec<_>>>()?;
Ok(Self {
format,
width: header.pixel_width,
height: header.pixel_height.max(1),
levels,
})
}
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.is_multiple_of(BLOCK)
&& self.height.is_multiple_of(BLOCK)
&& (1..=full).contains(&self.levels.len())
&& self
.levels
.iter()
.enumerate()
.all(|(level, bytes)| bytes.len() == self.level_bytes(level))
}
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),
}
}
}
texels
}
}