mod blocks;
mod header;
mod palettes;
mod symbol;
pub(crate) mod unity;
#[derive(Debug, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum CrunchError {
#[error("invalid crunch header: {0}")]
Header(&'static str),
#[error("truncated crunch bitstream")]
Truncated,
#[error("invalid crunch Huffman code")]
Huffman,
#[error("invalid crunch palette index")]
Palette,
#[error("uninitialized crunch block reference")]
Reference,
#[error("crunch Texture2D requires one face, got {0}")]
Faces(u8),
#[error("segmented crunch is unsupported")]
Segmented,
#[error(transparent)]
Charge(#[from] unityrs_core::limits::ChargeError),
}
const _: () = crate::send_sync::<CrunchError>();
type Result<T> = std::result::Result<T, CrunchError>;
use std::sync::Arc;
use unityrs_core::limits::{Meter, MeteredVec, heap_cost};
pub(crate) fn scratch(block_bytes: u64) -> u64 {
heap_cost(block_bytes)
+ heap_cost(65535 * 4) * 2
+ heap_cost(65535 * 2)
+ heap_cost(65535 * 8)
+ heap_cost(16383 * 2) * 8
+ heap_cost(16383)
}
fn block_work(size: (usize, usize), symbols: u64, meter: &Arc<Meter>) -> Result<()> {
let width = (size.0 as u64).div_ceil(4).div_ceil(2) * 2;
let height = (size.1 as u64).div_ceil(4).div_ceil(2) * 2;
meter.count_decode(width * height * (1 + symbols * 4))?;
Ok(())
}
fn palette_work(header: &header::Header, symbols: [u64; 4], meter: &Arc<Meter>) -> Result<()> {
meter.count_decode(
header
.palettes
.iter()
.zip(symbols)
.enumerate()
.filter(|(i, _)| *i < 2 || header.palettes[2].count != 0)
.map(|(_, (region, symbols))| region.count as u64 * symbols * 4)
.sum(),
)?;
Ok(())
}
pub(crate) fn unpack(
data: &[u8],
dxt5: bool,
size: (usize, usize),
level: usize,
meter: &Arc<Meter>,
) -> Result<MeteredVec<u8>> {
const ZEROS: [u8; 4096] = [0; 4096];
let (header, source, width, height) = prepare(data, dxt5, size, level)?;
let len = width
.div_ceil(4)
.checked_mul(height.div_ceil(4))
.and_then(|n| n.checked_mul(if dxt5 { 16 } else { 8 }))
.ok_or(CrunchError::Header("block buffer overflow"))?;
block_work((width, height), if dxt5 { 5 } else { 3 }, meter)?;
palette_work(&header, [6, 8, 2, 8], meter)?;
let models = blocks::Models::new(&header, data, meter)?;
let palettes = palettes::Palettes::new(&header, data, meter)?;
let mut out = MeteredVec::with_capacity(meter, len)?;
while out.len() < len {
let n = (len - out.len()).min(ZEROS.len());
out.extend_from_slice(
ZEROS
.get(..n)
.ok_or(CrunchError::Header("block fill size"))?,
)?;
}
blocks::unpack(
source,
dxt5,
width,
height,
&models,
&palettes,
out.as_mut_slice(),
)?;
Ok(out)
}
pub(crate) fn validate(data: &[u8], dxt5: bool, size: (usize, usize)) -> Result<()> {
prepare(data, dxt5, size, 0).map(|_| ())
}
fn prepare(
data: &[u8],
dxt5: bool,
size: (usize, usize),
level: usize,
) -> Result<(header::Header, &[u8], usize, usize)> {
let header = header::Header::parse(data)?;
let (source, width, height) = header.level(data, level)?;
if header.dxt5 != dxt5 {
return Err(CrunchError::Header("Texture2D/CRN format mismatch"));
}
if (width.div_ceil(4), height.div_ceil(4)) != (size.0.div_ceil(4), size.1.div_ceil(4)) {
return Err(CrunchError::Header("Texture2D/CRN block extent mismatch"));
}
if source.is_empty() {
return Err(CrunchError::Truncated);
}
Ok((header, source, width, height))
}
#[cfg(test)]
mod tests;