mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 20:25:02 +00:00
Merge pull request #1774 from vangel76/perf/dds-bc45-1766
DDS textures: normal maps and grayscale maps save compressed (BC5/BC4), and DDS saves and opens faster
This commit is contained in:
Generated
+8
@@ -1559,6 +1559,13 @@ dependencies = [
|
||||
"proptest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-dds"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"rayon",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-deckcraft-format"
|
||||
version = "0.1.0"
|
||||
@@ -2060,6 +2067,7 @@ name = "craft-image-codecs"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"avif-serialize",
|
||||
"craft-dds",
|
||||
"craft-heif",
|
||||
"craft-jpeg",
|
||||
"craft-media-testkit",
|
||||
|
||||
@@ -145,6 +145,7 @@ craft-print = { path = "crates/print" }
|
||||
craft-proof = { path = "crates/proof" }
|
||||
craft-raster-codecs = { path = "crates/raster-codecs" }
|
||||
craft-image-codecs = { path = "crates/image-codecs" }
|
||||
craft-dds = { path = "crates/dds" }
|
||||
craft-psd = { path = "crates/psd" }
|
||||
craft-pst = { path = "crates/pst" }
|
||||
craft-quit = { path = "crates/quit" }
|
||||
|
||||
@@ -89,6 +89,11 @@ See the [release notes](CHANGELOG.md) for included functionality and known limit
|
||||
black and white levels and as-shot white balance. The complete derivation record (plan, sources
|
||||
log, scripts, verification) is in `crates/crw/clean-room/`. Colour stays in each app.
|
||||
- [`craft-csv`](crates/csv/README.md): delimited text (CSV, TSV) and SYLK: encoding detection (UTF-8, UTF-16, Windows-1252 or Windows-1256), delimiter sniffing, a record parser with a cap on fields per record, field quoting for writers, and a SYLK (`.slk`) reader with R1C1 formulas rewritten to A1.
|
||||
- [`craft-dds`](crates/dds/README.md): DirectDraw Surface (DDS) textures, read and written: the
|
||||
top mip level of uncompressed, BC1 to BC3 (DXT1/3/5) and BC4/BC5 (grayscale data and normal
|
||||
maps) textures, legacy and DX10 headers, and our own block encoder with optional mip chains. No dependencies (rayon behind `parallel`), so an
|
||||
app that only exports textures needn't take the whole `craft-image-codecs` codec set and its
|
||||
licences; `craft-image-codecs` reads and writes DDS through it.
|
||||
- [`craft-dialogs`](crates/dialogs/README.md): native file and message dialogs that never block
|
||||
the event loop: queued requests shown at the end of the frame and answered on a later frame,
|
||||
free-standing Open and Folder panels and Save sheets on macOS, case-insensitive filters. What
|
||||
@@ -249,7 +254,7 @@ See the [release notes](CHANGELOG.md) for included functionality and known limit
|
||||
encoder, from PhotoCraft; includes a frame probe for routing. Metadata interpretation stays in
|
||||
each app.
|
||||
- [`craft-raster-codecs`](crates/raster-codecs/README.md): small raster formats, one module each,
|
||||
from PhotoCraft: DDS (BC1 to BC3, read and write), DICOM, FITS (read and write), IFF/ILBM (read
|
||||
from PhotoCraft: DDS (BC1 to BC3 read and write, BC4 and BC5 read), DICOM, FITS (read and write), IFF/ILBM (read
|
||||
and write), PCX, PNM/PAM/PFM (read and write) and XPM, into one flat image type. Bounded and
|
||||
panic-free on hostile input. Colour, orientation and the document mapping stay in each app.
|
||||
- [`craft-kiwi`](crates/kiwi/README.md): clean-room decoder and encoder for the kiwi binary schema
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
[package]
|
||||
name = "craft-dds"
|
||||
description = "DirectDraw Surface (DDS) textures: uncompressed and BC1-BC5 block compression, read and write, without dependencies"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
rust-version.workspace = true
|
||||
repository.workspace = true
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
|
||||
[features]
|
||||
default = []
|
||||
# Encode and decode rows of blocks (and mip levels) on several threads.
|
||||
parallel = ["dep:rayon"]
|
||||
|
||||
[dependencies]
|
||||
rayon = { workspace = true, optional = true }
|
||||
@@ -0,0 +1,52 @@
|
||||
# craft-dds
|
||||
|
||||
DirectDraw Surface (DDS) textures, after Microsoft's public DDS and block-compression
|
||||
documentation, with no dependencies. `craft-image-codecs` reads and writes DDS through this
|
||||
crate and re-exports its `DdsCompression` and `DdsOptions`; an app that only needs DDS (a texture
|
||||
exporter, say) can depend on it alone and leave out the other codecs and their licences.
|
||||
|
||||
```toml
|
||||
craft-dds = { git = "https://github.com/storytold/craft-libs", rev = "<commit>" }
|
||||
```
|
||||
|
||||
| | Read | Write |
|
||||
|---|---|---|
|
||||
| Uncompressed | 8, 16, 24 or 32 bits per pixel described by channel masks, RGB or luminance, with or without alpha; padded rows (`DDSD_PITCH`) | BGRA, BGRX, luminance, luminance with alpha |
|
||||
| Block-compressed | BC1, BC2, BC3 (DXT1, DXT3, DXT5); unsigned BC4 (ATI1, BC4U, DXGI 79 and 80) and BC5 (ATI2, BC5U, DXGI 82 and 83) | BC1, BC2, BC3, BC4, BC5 |
|
||||
| Headers | legacy and DX10 | legacy; DX10 for BC4 and BC5 |
|
||||
| Mip levels | the top level only | optional full chain, box-filtered |
|
||||
|
||||
Cubemaps, texture arrays, volume textures, premultiplied-alpha textures (DXT2/DXT4, or DX10 alpha mode 2), signed (SNORM) BC4/BC5 and
|
||||
the other DXGI formats (BC6H, BC7, float) are refused with `DdsError::Unsupported` rather than read
|
||||
in part.
|
||||
|
||||
Pixels are 8 bits per channel, interleaved and top row first, in one of four `Layout`s (`Gray`,
|
||||
`GrayA`, `Rgb`, `Rgba`). BC1 to BC3 are written from RGBA, BC4 from gray and BC5 from RGB
|
||||
(`DdsCompression::layout` names it). BC4 reads back as gray. BC5 stores red and green only, so it
|
||||
reads back as RGB with blue 0: for a tangent-space normal map, X and Y, with Z left to the
|
||||
renderer. ATI2 files are read as Microsoft's tools read them (red in the first block), not with
|
||||
the two blocks swapped as FFmpeg does.
|
||||
|
||||
```rust
|
||||
use craft_dds::{DdsCompression, DdsOptions, Layout, Texture};
|
||||
|
||||
let pixels = [10, 20, 30, 255].repeat(6 * 5);
|
||||
let file = craft_dds::encode(6, 5, Layout::Rgba, &pixels, DdsOptions { compression: DdsCompression::Bc1, mipmaps: true })?;
|
||||
// The header first: the size and layout are known before anything is allocated.
|
||||
let texture = Texture::parse(&file)?;
|
||||
assert_eq!((texture.width(), texture.height(), texture.layout()), (6, 5, Layout::Rgba));
|
||||
let decoded = texture.decode()?;
|
||||
```
|
||||
|
||||
`Texture::parse` requires a complete header and nonzero dimensions. `Texture::decode` bounds its output buffer to 1 GiB; use `decode_with_limit(max_bytes)` for an explicit per-buffer budget. Allocation is fallible. This is not a total process memory limit. The `craft-image-codecs` adapter forwards its own existing `Limits::max_alloc` instead of imposing the standalone default.
|
||||
|
||||
The block encoder is our own: RGB565 endpoints fitted along each block's principal axis and
|
||||
refined by least squares, indices picked against the palette the reader decodes; BC1 turns texels
|
||||
under half opacity into its transparent black, and BC3, BC4 and BC5 pick whichever mode of their
|
||||
value blocks fits. The block functions don't depend on the DDS header, so other containers of
|
||||
the same blocks can share them.
|
||||
|
||||
## Features
|
||||
|
||||
- `parallel`: encodes and decodes rows of blocks (and mip levels) on several threads with rayon.
|
||||
`craft-image-codecs` turns it on for native targets.
|
||||
@@ -1,6 +1,10 @@
|
||||
//! BC1, BC2 and BC3 (DXT1, DXT3, DXT5) blocks, after Microsoft's public block compression
|
||||
//! BC1 to BC5 (DXT1, DXT3, DXT5, ATI1, ATI2) blocks, after Microsoft's public block compression
|
||||
//! documentation ("Block Compression (Direct3D 10)" and "Texture Block Compression in Direct3D
|
||||
//! 11"): the palettes the DDS reader decodes with, and the block encoder the DDS writer uses.
|
||||
//! 11"): the block decoders and the block encoder the DDS reader and writer use. Nothing here
|
||||
//! knows about DDS headers, so other containers of the same blocks can use it.
|
||||
//!
|
||||
//! BC4 is one block of 16 single-channel values, the same block BC3 stores its alpha in; BC5 is
|
||||
//! two of them, red then green. [`value_block`] and [`decode_values`] serve all three.
|
||||
//!
|
||||
//! The encoder fits a block's colours with two RGB565 endpoints along their principal axis,
|
||||
//! refines them by least squares, and scores every candidate against the exact palette the
|
||||
@@ -35,7 +39,7 @@ pub(crate) fn colour_palette(c0: u16, c1: u16, four: bool) -> [[u8; 4]; 4] {
|
||||
}
|
||||
}
|
||||
|
||||
/// A BC3 alpha block's eight values: six interpolated at sevenths when `a0 > a1`, else four
|
||||
/// A value block's eight values: six interpolated at sevenths when `a0 > a1`, else four
|
||||
/// interpolated at fifths followed by 0 and 255.
|
||||
pub(crate) fn alpha_palette(a0: u8, a1: u8) -> [u8; 8] {
|
||||
let (a0, a1) = (u32::from(a0), u32::from(a1));
|
||||
@@ -54,6 +58,32 @@ pub(crate) fn alpha_palette(a0: u8, a1: u8) -> [u8; 8] {
|
||||
palette.map(|v| v as u8)
|
||||
}
|
||||
|
||||
/// A colour block's 16 texels as RGBA. BC2 and BC3 colour blocks always have four colours
|
||||
/// (`one_bit_alpha` false); only BC1's `c0 <= c1` order selects three colours and transparent
|
||||
/// black. Missing bytes read as 0.
|
||||
pub(crate) fn decode_colour(block: &[u8], one_bit_alpha: bool) -> Block {
|
||||
let byte = |i: usize| block.get(i).copied().unwrap_or(0);
|
||||
let (c0, c1) = (u16::from_le_bytes([byte(0), byte(1)]), u16::from_le_bytes([byte(2), byte(3)]));
|
||||
let palette = colour_palette(c0, c1, c0 > c1 || !one_bit_alpha);
|
||||
let indices = u32::from_le_bytes([byte(4), byte(5), byte(6), byte(7)]);
|
||||
std::array::from_fn(|t| palette[(indices >> (2 * t)) as usize & 3])
|
||||
}
|
||||
|
||||
/// BC2's alpha: four explicit bits per texel.
|
||||
pub(crate) fn decode_bc2_alpha(block: &[u8]) -> [u8; 16] {
|
||||
let bits = u64::from_le_bytes(std::array::from_fn(|i| block.get(i).copied().unwrap_or(0)));
|
||||
std::array::from_fn(|t| ((bits >> (4 * t)) & 0xf) as u8 * 17)
|
||||
}
|
||||
|
||||
/// A value block (BC3's alpha, BC4, either half of BC5): two endpoints and a 3-bit index per
|
||||
/// texel into eight values, or into six plus 0 and 255 when `a0 <= a1`. Missing bytes read as 0.
|
||||
pub(crate) fn decode_values(block: &[u8]) -> [u8; 16] {
|
||||
let byte = |i: usize| block.get(i).copied().unwrap_or(0);
|
||||
let palette = alpha_palette(byte(0), byte(1));
|
||||
let bits = u64::from_le_bytes([byte(2), byte(3), byte(4), byte(5), byte(6), byte(7), 0, 0]);
|
||||
std::array::from_fn(|t| palette[((bits >> (3 * t)) & 7) as usize])
|
||||
}
|
||||
|
||||
/// A BC1 block. Texels under half opacity become BC1's transparent black, which needs the
|
||||
/// three-colour mode; an opaque block takes whichever mode fits its colours better.
|
||||
pub(crate) fn encode_bc1(block: &Block, inside: Mask) -> [u8; 8] {
|
||||
@@ -69,7 +99,8 @@ pub(crate) fn encode_bc2(block: &Block, inside: Mask) -> [u8; 16] {
|
||||
|
||||
/// A BC3 block: an interpolated alpha block, then a four-colour block.
|
||||
pub(crate) fn encode_bc3(block: &Block, inside: Mask) -> [u8; 16] {
|
||||
join(alpha_block(block, inside), colour_block(block, inside, 0, false))
|
||||
let alphas = std::array::from_fn(|t| block[t][3]);
|
||||
join(value_block(&alphas, inside), colour_block(block, inside, 0, false))
|
||||
}
|
||||
|
||||
fn join(a: [u8; 8], b: [u8; 8]) -> [u8; 16] {
|
||||
@@ -92,21 +123,56 @@ fn to565(c: [f32; 3]) -> u16 {
|
||||
}
|
||||
|
||||
fn distance(a: &[u8; 4], b: &[u8; 4]) -> u32 {
|
||||
(0..3).map(|i| u32::from(a[i].abs_diff(b[i])).pow(2)).sum()
|
||||
let d = |i: usize| u32::from(a[i].abs_diff(b[i])).pow(2);
|
||||
d(0) + d(1) + d(2)
|
||||
}
|
||||
|
||||
/// The index of the first of `palette`'s entries nearest by `distance`, and that distance: the
|
||||
/// entry `Iterator::min_by_key` picks, found without the iterator (a texel equal to an entry
|
||||
/// stops the search, as no later entry can be nearer and an equal one doesn't win).
|
||||
fn nearest<T>(palette: &[T], distance: impl Fn(&T) -> u32) -> (usize, u32) {
|
||||
let mut best = (0, u32::MAX);
|
||||
for (i, p) in palette.iter().enumerate() {
|
||||
let d = distance(p);
|
||||
if d < best.1 {
|
||||
best = (i, d);
|
||||
if d == 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if palette.is_empty() { (0, 0) } else { best }
|
||||
}
|
||||
|
||||
/// A colour block (endpoints, then 2-bit indices) for the `opaque` texels' colours, with the
|
||||
/// `transparent` ones on BC1's transparent index. `bc1` allows the three-colour mode; BC2 and
|
||||
/// BC3 always decode four colours.
|
||||
fn colour_block(block: &Block, opaque: Mask, transparent: Mask, bc1: bool) -> [u8; 8] {
|
||||
let colours: Vec<[f32; 3]> = block.iter().enumerate().filter(|(t, _)| opaque >> t & 1 != 0).map(|(_, texel)| rgb_of(texel)).collect();
|
||||
if colours.is_empty() {
|
||||
// The opaque texels' colours in texel order, on the stack (after storytold/photocraft#10669,
|
||||
// which took the per-block allocations out of PhotoCraft's copy of this encoder).
|
||||
let mut buffer = [[0f32; 3]; 16];
|
||||
let mut n = 0;
|
||||
for (t, texel) in block.iter().enumerate() {
|
||||
if opaque >> t & 1 != 0
|
||||
&& let Some(slot) = buffer.get_mut(n)
|
||||
{
|
||||
*slot = rgb_of(texel);
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
let colours = buffer.get(..n).unwrap_or_default();
|
||||
let Some((first, rest)) = colours.split_first() else {
|
||||
// Nothing visible: every texel on the transparent index (or index 0 of black).
|
||||
let indices = if transparent != 0 { u32::MAX } else { 0 };
|
||||
return pack(0, 0, indices);
|
||||
}
|
||||
let (lo, hi) = principal_endpoints(&colours);
|
||||
let mut candidates = vec![(to565(lo), to565(hi))];
|
||||
};
|
||||
// One colour has no axis: `principal_endpoints` returns that colour (their mean) for both
|
||||
// ends, so it is skipped. Everything after it runs as for any block.
|
||||
let (lo, hi) = if rest.iter().all(|c| c == first) { (*first, *first) } else { principal_endpoints(colours) };
|
||||
let mut candidate = (to565(lo), to565(hi));
|
||||
// The endpoint pairs fitted so far: at most one per round.
|
||||
let mut fitted = [candidate; 3];
|
||||
let mut count = 1;
|
||||
let modes: &[bool] = if transparent != 0 {
|
||||
&[false]
|
||||
} else if bc1 {
|
||||
@@ -118,22 +184,30 @@ fn colour_block(block: &Block, opaque: Mask, transparent: Mask, bc1: bool) -> [u
|
||||
// Each refinement starts from the best block so far: its indices give the least-squares
|
||||
// endpoints, which become one more candidate.
|
||||
for round in 0..3 {
|
||||
for &(e0, e1) in &candidates {
|
||||
for &four in modes {
|
||||
let (bytes, error) = fit(block, opaque, transparent, e0, e1, four);
|
||||
if best.is_none_or(|(e, _)| error < e) {
|
||||
best = Some((error, bytes));
|
||||
}
|
||||
let (e0, e1) = candidate;
|
||||
for &four in modes {
|
||||
let (bytes, error) = fit(block, opaque, transparent, e0, e1, four);
|
||||
if best.is_none_or(|(e, _)| error < e) {
|
||||
best = Some((error, bytes));
|
||||
}
|
||||
}
|
||||
let Some((error, bytes)) = best else { break };
|
||||
if error == 0 || round == 2 {
|
||||
break;
|
||||
}
|
||||
candidates = least_squares(block, opaque, &bytes).into_iter().collect();
|
||||
if candidates.is_empty() {
|
||||
let Some(next) = least_squares(block, opaque, &bytes) else { break };
|
||||
// A pair fitted before (in either order: `fit` orders the endpoints itself) fits the same
|
||||
// again and can't beat the best block, which then gives the same pair again: the rounds
|
||||
// left would change nothing.
|
||||
let seen = fitted.get(..count).unwrap_or_default();
|
||||
if seen.iter().any(|&(a, b)| (a, b) == next || (b, a) == next) {
|
||||
break;
|
||||
}
|
||||
if let Some(slot) = fitted.get_mut(count) {
|
||||
*slot = next;
|
||||
count += 1;
|
||||
}
|
||||
candidate = next;
|
||||
}
|
||||
best.map_or([0; 8], |(_, bytes)| bytes)
|
||||
}
|
||||
@@ -151,7 +225,7 @@ fn fit(block: &Block, opaque: Mask, transparent: Mask, e0: u16, e1: u16, four: b
|
||||
let index = if transparent >> t & 1 != 0 {
|
||||
3
|
||||
} else if opaque >> t & 1 != 0 {
|
||||
let (i, d) = palette.iter().take(choices).enumerate().map(|(i, p)| (i, distance(texel, p))).min_by_key(|&(_, d)| d).unwrap_or((0, 0));
|
||||
let (i, d) = nearest(palette.get(..choices).unwrap_or_default(), |p| distance(texel, p));
|
||||
error += d;
|
||||
i as u32
|
||||
} else {
|
||||
@@ -191,7 +265,14 @@ fn principal_endpoints(colours: &[[f32; 3]]) -> ([f32; 3], [f32; 3]) {
|
||||
if !len.is_normal() {
|
||||
break;
|
||||
}
|
||||
axis = next.map(|v| v / len);
|
||||
let normalised = next.map(|v| v / len);
|
||||
// A step that returns the same axis, bit for bit, returns it on every later step too:
|
||||
// stopping there gives the very axis the remaining steps would. Kept only if timing
|
||||
// shows the comparison pays for itself.
|
||||
if normalised.map(f32::to_bits) == axis.map(f32::to_bits) {
|
||||
break;
|
||||
}
|
||||
axis = normalised;
|
||||
}
|
||||
axis
|
||||
};
|
||||
@@ -248,29 +329,39 @@ fn least_squares(block: &Block, opaque: Mask, bytes: &[u8; 8]) -> Option<(u16, u
|
||||
Some((to565(e0), to565(e1)))
|
||||
}
|
||||
|
||||
/// A BC3 alpha block: whichever of the two modes (eight values between the extremes, or six
|
||||
/// between the extremes other than 0 and 255, plus exact 0 and 255) fits better.
|
||||
fn alpha_block(block: &Block, inside: Mask) -> [u8; 8] {
|
||||
let alphas = || block.iter().enumerate().filter(move |(t, _)| inside >> t & 1 != 0).map(|(_, texel)| texel[3]);
|
||||
let range =
|
||||
|values: &mut dyn Iterator<Item = u8>| values.fold(None, |r: Option<(u8, u8)>, a| Some(r.map_or((a, a), |(lo, hi)| (lo.min(a), hi.max(a)))));
|
||||
let (lo, hi) = range(&mut alphas()).unwrap_or((0, 0));
|
||||
/// A block of 16 single-channel values (BC3's alpha, BC4, either half of BC5): whichever of the two modes
|
||||
/// (eight values between the extremes, or six between the extremes other than 0 and 255, plus
|
||||
/// exact 0 and 255) fits better. Only the values of `inside` count.
|
||||
pub(crate) fn value_block(values: &[u8; 16], inside: Mask) -> [u8; 8] {
|
||||
// Both ranges in one pass: of all values, and of those other than 0 and 255.
|
||||
let mut all: Option<(u8, u8)> = None;
|
||||
let mut mid = all;
|
||||
let widen = |r: Option<(u8, u8)>, v: u8| Some(r.map_or((v, v), |(lo, hi)| (lo.min(v), hi.max(v))));
|
||||
for (t, &v) in values.iter().enumerate() {
|
||||
if inside >> t & 1 != 0 {
|
||||
all = widen(all, v);
|
||||
if !matches!(v, 0 | 255) {
|
||||
mid = widen(mid, v);
|
||||
}
|
||||
}
|
||||
}
|
||||
let (lo, hi) = all.unwrap_or((0, 0));
|
||||
// Eight values need a0 > a1; equal ends fall to the six-value mode, which starts with a0 too.
|
||||
let eight = alpha_fit(block, inside, hi, lo);
|
||||
let (mid_lo, mid_hi) = range(&mut alphas().filter(|a| !matches!(a, 0 | 255))).unwrap_or((0, 0));
|
||||
let six = alpha_fit(block, inside, mid_lo, mid_hi);
|
||||
let eight = value_fit(values, inside, hi, lo);
|
||||
let (mid_lo, mid_hi) = mid.unwrap_or((0, 0));
|
||||
let six = value_fit(values, inside, mid_lo, mid_hi);
|
||||
if six.1 < eight.1 { six.0 } else { eight.0 }
|
||||
}
|
||||
|
||||
fn alpha_fit(block: &Block, inside: Mask, a0: u8, a1: u8) -> ([u8; 8], u32) {
|
||||
fn value_fit(values: &[u8; 16], inside: Mask, a0: u8, a1: u8) -> ([u8; 8], u32) {
|
||||
let palette = alpha_palette(a0, a1);
|
||||
let mut bits = 0u64;
|
||||
let mut error = 0u32;
|
||||
for (t, texel) in block.iter().enumerate() {
|
||||
for (t, &v) in values.iter().enumerate() {
|
||||
if inside >> t & 1 == 0 {
|
||||
continue;
|
||||
}
|
||||
let (i, d) = palette.iter().enumerate().map(|(i, &p)| (i, u32::from(p.abs_diff(texel[3])).pow(2))).min_by_key(|&(_, d)| d).unwrap_or((0, 0));
|
||||
let (i, d) = nearest(&palette, |&p| u32::from(p.abs_diff(v)).pow(2));
|
||||
error += d;
|
||||
bits |= (i as u64) << (3 * t);
|
||||
}
|
||||
@@ -282,13 +373,6 @@ fn alpha_fit(block: &Block, inside: Mask, a0: u8, a1: u8) -> ([u8; 8], u32) {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn decode_colour(bytes: &[u8; 8], bc1: bool) -> Block {
|
||||
let (c0, c1) = (u16::from_le_bytes([bytes[0], bytes[1]]), u16::from_le_bytes([bytes[2], bytes[3]]));
|
||||
let palette = colour_palette(c0, c1, c0 > c1 || !bc1);
|
||||
let indices = u32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]);
|
||||
std::array::from_fn(|t| palette[(indices >> (2 * t)) as usize & 3])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn solid_blocks_land_on_the_nearest_565_colour() {
|
||||
for colour in [[0, 0, 0, 255], [255, 255, 255, 255], [12, 200, 77, 255]] {
|
||||
@@ -333,7 +417,7 @@ mod tests {
|
||||
fn alpha_blocks_pick_the_mode_that_keeps_0_and_255() {
|
||||
// 0, 255 and a cluster in between: the six-value mode stores 0 and 255 exactly.
|
||||
let block: Block = std::array::from_fn(|t| [0, 0, 0, [0, 255, 100, 110][t % 4]]);
|
||||
let bytes = alpha_block(&block, u16::MAX);
|
||||
let bytes = value_block(&block.map(|t| t[3]), u16::MAX);
|
||||
assert!(bytes[0] <= bytes[1], "six-value mode");
|
||||
let palette = alpha_palette(bytes[0], bytes[1]);
|
||||
let bits = u64::from_le_bytes([bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], 0, 0]);
|
||||
@@ -358,6 +442,48 @@ mod tests {
|
||||
assert!(ours < bounding_box, "{ours} vs the bounding box's {bounding_box}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn value_blocks_decode_the_frozen_vectors() {
|
||||
// Eight-value mode (a0 = 200 > a1 = 50), every index 0.
|
||||
assert_eq!(decode_values(&[0xc8, 0x32, 0, 0, 0, 0, 0, 0]), [200; 16]);
|
||||
// Six-value mode (a0 = 10 <= a1 = 250), every index 1.
|
||||
assert_eq!(decode_values(&[0x0a, 0xfa, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24]), [250; 16]);
|
||||
// Six-value mode's indices 6 and 7 are 0 and 255 whatever the endpoints.
|
||||
let bits: u64 = (0..16).fold(0, |b, t| b | (6 + (t % 2)) << (3 * t));
|
||||
let b = bits.to_le_bytes();
|
||||
let got = decode_values(&[10, 250, b[0], b[1], b[2], b[3], b[4], b[5]]);
|
||||
assert_eq!(got, std::array::from_fn(|t| if t % 2 == 0 { 0 } else { 255 }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn value_blocks_round_trip_ramps_and_solids() {
|
||||
for values in [[200u8; 16], [0; 16], [255; 16], std::array::from_fn(|t| (t * 17) as u8), std::array::from_fn(|t| 100 + t as u8)] {
|
||||
let back = decode_values(&value_block(&values, u16::MAX));
|
||||
let worst = values.iter().zip(back).map(|(a, b)| a.abs_diff(b)).max().unwrap_or(0);
|
||||
// Within half a step of either mode: 255 / 7 apart in the eight-value mode, about
|
||||
// 221 / 5 in the six-value one.
|
||||
assert!(worst <= 23, "{values:?} -> {back:?}");
|
||||
}
|
||||
assert_eq!(decode_values(&value_block(&[200; 16], u16::MAX)), [200; 16]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nearest_picks_what_min_by_key_picks() {
|
||||
// Ties (equal entries, entries equally far on both sides) and exact hits included.
|
||||
let mut seed = 0x2545_f491u32;
|
||||
for _ in 0..2000 {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 17;
|
||||
seed ^= seed << 5;
|
||||
let palette = [seed as u8 & 0xf0, (seed >> 8) as u8 & 0xf0, (seed >> 16) as u8 & 0xf0, (seed >> 24) as u8 & 0xf0];
|
||||
let v = (seed >> 4) as u8 & 0xf8;
|
||||
let d = |p: &u8| u32::from(p.abs_diff(v)).pow(2);
|
||||
let want = palette.iter().enumerate().map(|(i, p)| (i, d(p))).min_by_key(|&(_, d)| d).unwrap();
|
||||
assert_eq!(nearest(&palette, d), want, "{palette:?} {v}");
|
||||
}
|
||||
assert_eq!(nearest::<u8>(&[], |_| 7), (0, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn texels_outside_the_image_are_ignored() {
|
||||
// Only the top-left texel is inside: its colour alone decides the endpoints.
|
||||
@@ -0,0 +1,983 @@
|
||||
//! DirectDraw Surface (DDS) textures, after Microsoft's public DDS documentation ("DDS",
|
||||
//! "DDS_HEADER", "DDS_PIXELFORMAT", "DDS_HEADER_DXT10").
|
||||
//!
|
||||
//! Reading: the top mip level of a 2D texture, either uncompressed (8 to 32 bits per pixel
|
||||
//! described by channel masks, RGB or luminance) or block-compressed BC1/BC2/BC3
|
||||
//! (DXT1/DXT3/DXT5) or unsigned BC4/BC5 (ATI1/ATI2), with or without the DX10 header. BC4 opens
|
||||
//! as gray and BC5 as RGB with blue 0: BC5 stores only red and green, and a normal map's Z is
|
||||
//! left for the caller to reconstruct. Cubemaps, texture arrays and volume textures are refused
|
||||
//! rather than flattened to one face or slice, and signed (SNORM) BC4/BC5 is refused too.
|
||||
//!
|
||||
//! Writing: a 2D texture, uncompressed (BGRA or BGRX, luminance with or without alpha),
|
||||
//! BC1/BC2/BC3 or BC4/BC5, optionally with its full mip chain. The legacy header describes all
|
||||
//! but BC4 and BC5, which are written with the DX10 header (`BC4_UNORM`, `BC5_UNORM`): their
|
||||
//! legacy FourCCs are vendor names that programs read differently (ATI2's two blocks are swapped
|
||||
//! by some). BC6H, BC7 and sRGB formats aren't written.
|
||||
//!
|
||||
//! Pixels are 8 bits per channel, interleaved, top row first, in one of the [`Layout`]s. The
|
||||
//! crate has no dependencies; the `parallel` feature encodes and decodes rows of blocks (and mip
|
||||
//! levels) on several threads with rayon.
|
||||
//!
|
||||
//! ```
|
||||
//! use craft_dds::{DdsCompression, DdsOptions, Layout};
|
||||
//!
|
||||
//! let pixels = [10, 20, 30, 255].repeat(6 * 5);
|
||||
//! let options = DdsOptions { compression: DdsCompression::Bc1, mipmaps: true };
|
||||
//! let file = craft_dds::encode(6, 5, Layout::Rgba, &pixels, options)?;
|
||||
//! let texture = craft_dds::Texture::parse(&file)?;
|
||||
//! assert_eq!((texture.width(), texture.height(), texture.layout()), (6, 5, Layout::Rgba));
|
||||
//! assert_eq!(texture.decode()?.len(), 6 * 5 * 4);
|
||||
//! # Ok::<(), craft_dds::DdsError>(())
|
||||
//! ```
|
||||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||||
|
||||
mod bc;
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::fmt;
|
||||
|
||||
use bc::{Block, Mask};
|
||||
|
||||
/// The channels of a pixel, 8 bits each, in this order.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Layout {
|
||||
Gray,
|
||||
/// Gray, then straight (not premultiplied) alpha.
|
||||
GrayA,
|
||||
Rgb,
|
||||
/// Red, green, blue, then straight alpha.
|
||||
Rgba,
|
||||
}
|
||||
|
||||
impl Layout {
|
||||
/// Samples per pixel.
|
||||
pub fn channels(self) -> usize {
|
||||
match self {
|
||||
Layout::Gray => 1,
|
||||
Layout::GrayA => 2,
|
||||
Layout::Rgb => 3,
|
||||
Layout::Rgba => 4,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Why a texture could not be read or written. More kinds may be added, so a `match` on it needs
|
||||
/// a wildcard arm.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
#[non_exhaustive]
|
||||
pub enum DdsError {
|
||||
/// The file is damaged or not a DDS file.
|
||||
Malformed(String),
|
||||
/// A valid texture in a form this crate doesn't read (a cubemap, an array, a compression it
|
||||
/// doesn't decode).
|
||||
Unsupported(String),
|
||||
/// The pixels can't be written with the options given.
|
||||
Encode(String),
|
||||
/// An output buffer of this many bytes could not be allocated.
|
||||
Alloc(usize),
|
||||
/// The decoded output exceeds the caller-selected per-buffer byte limit.
|
||||
LimitExceeded { required: usize, limit: u64 },
|
||||
}
|
||||
|
||||
impl fmt::Display for DdsError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
DdsError::Malformed(reason) => write!(f, "malformed DDS: {reason}"),
|
||||
DdsError::Unsupported(reason) => write!(f, "unsupported DDS: {reason}"),
|
||||
DdsError::Encode(reason) => write!(f, "DDS encode failed: {reason}"),
|
||||
DdsError::Alloc(len) => write!(f, "cannot allocate {len} bytes for the texture"),
|
||||
DdsError::LimitExceeded { required, limit } => write!(f, "decoded texture requires {required} bytes, exceeding limit {limit}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for DdsError {}
|
||||
|
||||
/// How a DDS texture stores its pixels. More compressions may be added, so a `match` on it needs
|
||||
/// a wildcard arm.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||||
#[non_exhaustive]
|
||||
pub enum DdsCompression {
|
||||
/// Uncompressed, 8 bits per channel: BGRA (BGRX without alpha), or luminance with or
|
||||
/// without alpha for grayscale. Lossless.
|
||||
#[default]
|
||||
None,
|
||||
/// BC1 (DXT1): 4 bits per pixel. Alpha is on or off: texels under half opacity become
|
||||
/// transparent black.
|
||||
Bc1,
|
||||
/// BC2 (DXT3): 8 bits per pixel, with 4 bits of explicit alpha per texel.
|
||||
Bc2,
|
||||
/// BC3 (DXT5): 8 bits per pixel, with smooth interpolated alpha.
|
||||
Bc3,
|
||||
/// BC4 (ATI1): 4 bits per pixel, one channel: gray, for roughness, metallic, height or
|
||||
/// ambient-occlusion maps. Written from gray pixels.
|
||||
Bc4,
|
||||
/// BC5 (ATI2): 8 bits per pixel, two channels: red and green, for tangent-space normal maps
|
||||
/// (X and Y; Z is reconstructed by the renderer). Written from RGB pixels, blue dropped.
|
||||
Bc5,
|
||||
}
|
||||
|
||||
impl DdsCompression {
|
||||
pub const ALL: [DdsCompression; 6] =
|
||||
[DdsCompression::None, DdsCompression::Bc1, DdsCompression::Bc2, DdsCompression::Bc3, DdsCompression::Bc4, DdsCompression::Bc5];
|
||||
|
||||
/// The name scripts and the CLI use: `none`, `bc1`, `bc2`, `bc3`, `bc4` or `bc5`.
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
DdsCompression::None => "none",
|
||||
DdsCompression::Bc1 => "bc1",
|
||||
DdsCompression::Bc2 => "bc2",
|
||||
DdsCompression::Bc3 => "bc3",
|
||||
DdsCompression::Bc4 => "bc4",
|
||||
DdsCompression::Bc5 => "bc5",
|
||||
}
|
||||
}
|
||||
|
||||
/// [`Self::name`] back to a compression, also taking the DXT and ATI names (`dxt1`, `dxt3`,
|
||||
/// `dxt5`, `ati1`, `ati2`), in any case. Anything else is `None`.
|
||||
pub fn from_name(name: &str) -> Option<Self> {
|
||||
match name.to_ascii_lowercase().as_str() {
|
||||
"none" => Some(DdsCompression::None),
|
||||
"bc1" | "dxt1" => Some(DdsCompression::Bc1),
|
||||
"bc2" | "dxt3" => Some(DdsCompression::Bc2),
|
||||
"bc3" | "dxt5" => Some(DdsCompression::Bc3),
|
||||
"bc4" | "ati1" => Some(DdsCompression::Bc4),
|
||||
"bc5" | "ati2" => Some(DdsCompression::Bc5),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The pixel layout the compression is written from: gray for BC4, RGB for BC5, RGBA for
|
||||
/// the other block compressions. `None` for uncompressed textures, which take every layout.
|
||||
pub fn layout(self) -> Option<Layout> {
|
||||
match self {
|
||||
DdsCompression::None => None,
|
||||
DdsCompression::Bc4 => Some(Layout::Gray),
|
||||
DdsCompression::Bc5 => Some(Layout::Rgb),
|
||||
DdsCompression::Bc1 | DdsCompression::Bc2 | DdsCompression::Bc3 => Some(Layout::Rgba),
|
||||
}
|
||||
}
|
||||
|
||||
/// A block compression (lossy), not uncompressed pixels.
|
||||
pub fn is_block(self) -> bool {
|
||||
self != DdsCompression::None
|
||||
}
|
||||
}
|
||||
|
||||
/// What a DDS file is written with.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||||
pub struct DdsOptions {
|
||||
pub compression: DdsCompression,
|
||||
/// Write the full mip chain down to 1×1, each level a box filter of the one above.
|
||||
pub mipmaps: bool,
|
||||
}
|
||||
|
||||
/// `DDS ` plus the 124-byte DDS_HEADER.
|
||||
const HEADER: usize = 128;
|
||||
/// DDS_HEADER_DXT10, present when the FourCC is `DX10`.
|
||||
const DX10_HEADER: usize = 20;
|
||||
|
||||
const DDSD_DEPTH: u32 = 0x80_0000;
|
||||
const DDPF_ALPHAPIXELS: u32 = 0x1;
|
||||
const DDPF_FOURCC: u32 = 0x4;
|
||||
const DDPF_RGB: u32 = 0x40;
|
||||
const DDPF_LUMINANCE: u32 = 0x2_0000;
|
||||
const DDSCAPS2_CUBEMAP: u32 = 0x200;
|
||||
const DDSCAPS2_CUBEMAP_FACES: u32 = 0xfc00;
|
||||
const DDSCAPS2_VOLUME: u32 = 0x20_0000;
|
||||
const DIMENSION_TEXTURE2D: u32 = 3;
|
||||
const MISC_TEXTURECUBE: u32 = 0x4;
|
||||
|
||||
fn bad(reason: impl fmt::Display) -> DdsError {
|
||||
DdsError::Malformed(reason.to_string())
|
||||
}
|
||||
fn unsupported(reason: impl Into<String>) -> DdsError {
|
||||
DdsError::Unsupported(reason.into())
|
||||
}
|
||||
fn le32(b: &[u8], at: usize) -> Result<u32, DdsError> {
|
||||
let bytes = b.get(at..at + 4).and_then(|s| <[u8; 4]>::try_from(s).ok()).ok_or_else(|| bad("truncated header"))?;
|
||||
Ok(u32::from_le_bytes(bytes))
|
||||
}
|
||||
|
||||
/// Whether the header declares more than the one image a reader takes: further mip levels,
|
||||
/// cubemap faces, volume slices or array textures, even without their presence flags.
|
||||
pub fn has_additional_images(bytes: &[u8]) -> Result<bool, DdsError> {
|
||||
let depth = le32(bytes, 24)?;
|
||||
let mips = le32(bytes, 28)?;
|
||||
let faces = (le32(bytes, 112)? & DDSCAPS2_CUBEMAP_FACES).count_ones();
|
||||
let dx10 = le32(bytes, 80)? & DDPF_FOURCC != 0 && bytes.get(84..88) == Some(b"DX10");
|
||||
let (cube, array) = if dx10 { (le32(bytes, 136)? & MISC_TEXTURECUBE != 0, le32(bytes, 140)?) } else { (false, 0) };
|
||||
Ok(depth > 1 || mips > 1 || faces > 1 || cube || array > 1)
|
||||
}
|
||||
|
||||
/// A FourCC as text when it is printable, else as the number legacy writers store there.
|
||||
fn fourcc_name(fourcc: u32) -> String {
|
||||
let bytes = fourcc.to_le_bytes();
|
||||
if bytes.iter().all(|c| c.is_ascii_graphic() || *c == b' ') { bytes.iter().map(|&c| char::from(c)).collect() } else { fourcc.to_string() }
|
||||
}
|
||||
|
||||
/// One channel of an uncompressed pixel: where it sits and its largest value.
|
||||
#[derive(Clone, Copy)]
|
||||
struct Field {
|
||||
shift: u32,
|
||||
max: u32,
|
||||
}
|
||||
|
||||
impl Field {
|
||||
/// `None` for an empty mask; an error for one with gaps or wider than the pixel.
|
||||
fn new(mask: u32, bits: u32) -> Result<Option<Field>, DdsError> {
|
||||
if mask == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
let shift = mask.trailing_zeros();
|
||||
let max = mask >> shift;
|
||||
if max & max.wrapping_add(1) != 0 || (bits < 32 && mask >> bits != 0) {
|
||||
return Err(bad(format!("channel mask {mask:#x} is not a contiguous field of a {bits}-bit pixel")));
|
||||
}
|
||||
Ok(Some(Field { shift, max }))
|
||||
}
|
||||
|
||||
fn get(self, pixel: u32) -> u8 {
|
||||
let v = u64::from((pixel >> self.shift) & self.max);
|
||||
let max = u64::from(self.max);
|
||||
((v * 255 + max / 2) / max) as u8
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum Encoding {
|
||||
/// Uncompressed: bytes per pixel, then red (or luminance), green, blue and alpha.
|
||||
Masks {
|
||||
bytes: usize,
|
||||
gray: bool,
|
||||
fields: [Option<Field>; 4],
|
||||
},
|
||||
Bc1,
|
||||
Bc2,
|
||||
Bc3,
|
||||
/// One value block: gray.
|
||||
Bc4,
|
||||
/// Two value blocks: red, then green.
|
||||
Bc5,
|
||||
}
|
||||
|
||||
impl Encoding {
|
||||
fn masks(bits: u32, masks: [u32; 4], gray: bool) -> Result<Encoding, DdsError> {
|
||||
if !matches!(bits, 8 | 16 | 24 | 32) {
|
||||
return Err(bad(format!("{bits} bits per pixel is not 8, 16, 24 or 32")));
|
||||
}
|
||||
let mut fields = [None; 4];
|
||||
for (field, mask) in fields.iter_mut().zip(masks) {
|
||||
*field = Field::new(mask, bits)?;
|
||||
}
|
||||
let colour = if gray { fields[0].is_some() } else { fields[..3].iter().any(Option::is_some) };
|
||||
if !colour {
|
||||
return Err(bad("the pixel format has no colour channel masks"));
|
||||
}
|
||||
Ok(Encoding::Masks { bytes: bits as usize / 8, gray, fields })
|
||||
}
|
||||
|
||||
fn layout(&self) -> Layout {
|
||||
match self {
|
||||
Encoding::Masks { gray: true, fields, .. } if fields[3].is_some() => Layout::GrayA,
|
||||
Encoding::Masks { gray: true, .. } => Layout::Gray,
|
||||
Encoding::Masks { fields, .. } if fields[3].is_none() => Layout::Rgb,
|
||||
Encoding::Bc4 => Layout::Gray,
|
||||
Encoding::Bc5 => Layout::Rgb,
|
||||
_ => Layout::Rgba,
|
||||
}
|
||||
}
|
||||
|
||||
/// Bytes per 4×4 block; 0 for uncompressed pixels.
|
||||
fn block_size(&self) -> usize {
|
||||
match self {
|
||||
Encoding::Masks { .. } => 0,
|
||||
Encoding::Bc1 | Encoding::Bc4 => 8,
|
||||
Encoding::Bc2 | Encoding::Bc3 | Encoding::Bc5 => 16,
|
||||
}
|
||||
}
|
||||
|
||||
/// Stored row stride and byte size of the top mip level (block rows for BC).
|
||||
fn level_layout(&self, width: u32, height: u32, pitch: Option<u32>) -> Result<(usize, usize), DdsError> {
|
||||
let overflow = || bad("pixel data size overflow");
|
||||
let (w, h) = (usize::try_from(width).map_err(|_| overflow())?, usize::try_from(height).map_err(|_| overflow())?);
|
||||
let (row_bytes, rows) = match self {
|
||||
Encoding::Masks { bytes, .. } => {
|
||||
let packed = w.checked_mul(*bytes).ok_or_else(overflow)?;
|
||||
let row_bytes = match pitch {
|
||||
Some(pitch) => usize::try_from(pitch).map_err(|_| overflow())?,
|
||||
None => packed,
|
||||
};
|
||||
if row_bytes < packed {
|
||||
return Err(bad(format!("row pitch {row_bytes} is smaller than the {packed}-byte pixel row")));
|
||||
}
|
||||
(row_bytes, h)
|
||||
}
|
||||
Encoding::Bc1 | Encoding::Bc2 | Encoding::Bc3 | Encoding::Bc4 | Encoding::Bc5 => {
|
||||
(w.div_ceil(4).checked_mul(self.block_size()).ok_or_else(overflow)?, h.div_ceil(4))
|
||||
}
|
||||
};
|
||||
let size = row_bytes.checked_mul(rows).ok_or_else(overflow)?;
|
||||
Ok((row_bytes, size))
|
||||
}
|
||||
}
|
||||
|
||||
/// The legacy pixel format: a FourCC, or channel masks.
|
||||
fn legacy_encoding(b: &[u8]) -> Result<Encoding, DdsError> {
|
||||
let (flags, fourcc, bits) = (le32(b, 80)?, le32(b, 84)?, le32(b, 88)?);
|
||||
let alpha = if flags & DDPF_ALPHAPIXELS != 0 { le32(b, 104)? } else { 0 };
|
||||
if flags & DDPF_FOURCC != 0 {
|
||||
return match &fourcc.to_le_bytes() {
|
||||
b"DXT1" => Ok(Encoding::Bc1),
|
||||
b"DXT3" => Ok(Encoding::Bc2),
|
||||
b"DXT5" => Ok(Encoding::Bc3),
|
||||
// Microsoft's mapping (DirectXTex reads ATI2 as BC5_UNORM, as Pillow does): red in
|
||||
// the first block, green in the second. FFmpeg's reader swaps the two blocks of
|
||||
// ATI2, after the old ATI 3Dc tools; this reader doesn't.
|
||||
b"ATI1" | b"BC4U" => Ok(Encoding::Bc4),
|
||||
b"ATI2" | b"BC5U" => Ok(Encoding::Bc5),
|
||||
b"BC4S" | b"BC5S" => Err(unsupported(format!("signed (SNORM) `{}` textures are not supported", fourcc_name(fourcc)))),
|
||||
b"DXT2" | b"DXT4" => Err(unsupported("premultiplied-alpha DXT2/DXT4 textures are not supported")),
|
||||
_ => Err(unsupported(format!("compression `{}` is not supported (DXT1, DXT3, DXT5, ATI1/BC4U and ATI2/BC5U are)", fourcc_name(fourcc)))),
|
||||
};
|
||||
}
|
||||
if flags & DDPF_RGB != 0 {
|
||||
return Encoding::masks(bits, [le32(b, 92)?, le32(b, 96)?, le32(b, 100)?, alpha], false);
|
||||
}
|
||||
if flags & DDPF_LUMINANCE != 0 {
|
||||
return Encoding::masks(bits, [le32(b, 92)?, 0, 0, alpha], true);
|
||||
}
|
||||
Err(unsupported(format!("pixel format flags {flags:#x} are not RGB, luminance or a supported compression")))
|
||||
}
|
||||
|
||||
/// The DX10 header's DXGI format, refusing anything but a single 2D texture.
|
||||
fn dx10_encoding(b: &[u8]) -> Result<Encoding, DdsError> {
|
||||
let (dxgi, dimension, misc, array) = (le32(b, HEADER)?, le32(b, HEADER + 4)?, le32(b, HEADER + 8)?, le32(b, HEADER + 12)?);
|
||||
if misc & MISC_TEXTURECUBE != 0 {
|
||||
return Err(unsupported("cubemaps are not supported"));
|
||||
}
|
||||
if dimension != DIMENSION_TEXTURE2D {
|
||||
return Err(unsupported(format!("only 2D textures are supported (resource dimension {dimension})")));
|
||||
}
|
||||
if array > 1 {
|
||||
return Err(unsupported(format!("texture arrays are not supported ({array} textures)")));
|
||||
}
|
||||
// miscFlags2 bits 0-2 are the alpha mode; 2 is premultiplied. Only the formats with a real
|
||||
// alpha channel are affected, and the legacy path refuses their DXT2/DXT4 equivalents too.
|
||||
if le32(b, HEADER + 16)? & 0x7 == 2 && matches!(dxgi, 27..=29 | 73..=78 | 87 | 90 | 91) {
|
||||
return Err(unsupported(format!("premultiplied-alpha DX10 textures are not supported (DXGI format {dxgi})")));
|
||||
}
|
||||
const RGBA: [u32; 4] = [0xff, 0xff00, 0xff_0000, 0xff00_0000];
|
||||
const BGRA: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0xff00_0000];
|
||||
const BGRX: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0];
|
||||
match dxgi {
|
||||
27..=29 => Encoding::masks(32, RGBA, false),
|
||||
87 | 90 | 91 => Encoding::masks(32, BGRA, false),
|
||||
88 | 92 | 93 => Encoding::masks(32, BGRX, false),
|
||||
70..=72 => Ok(Encoding::Bc1),
|
||||
73..=75 => Ok(Encoding::Bc2),
|
||||
76..=78 => Ok(Encoding::Bc3),
|
||||
// Typeless, then UNORM: a typeless texture's view is unsigned unless a program says
|
||||
// otherwise, and Pillow writes BC5 as typeless.
|
||||
79 | 80 => Ok(Encoding::Bc4),
|
||||
82 | 83 => Ok(Encoding::Bc5),
|
||||
81 | 84 => Err(unsupported(format!("signed (SNORM) BC4 and BC5 textures are not supported (DXGI format {dxgi})"))),
|
||||
_ => Err(unsupported(format!("DXGI format {dxgi} is not supported (BC1 to BC5 and 8-bit RGBA or BGRA are)"))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Default per-buffer decoded output budget (1 GiB). This is not a total process memory budget.
|
||||
pub const DEFAULT_MAX_DECODE_BYTES: u64 = 1024 * 1024 * 1024;
|
||||
|
||||
/// A DDS file whose header has been read: its size and pixel layout are known before
|
||||
/// [`Texture::decode`] allocates anything, so a caller can check them against its limits.
|
||||
pub struct Texture<'a> {
|
||||
bytes: &'a [u8],
|
||||
flags: u32,
|
||||
width: u32,
|
||||
height: u32,
|
||||
encoding: Encoding,
|
||||
/// Where the top level's pixel data starts.
|
||||
start: usize,
|
||||
}
|
||||
|
||||
impl<'a> Texture<'a> {
|
||||
/// Reads the header, refusing what [`Texture::decode`] can't read.
|
||||
pub fn parse(b: &'a [u8]) -> Result<Texture<'a>, DdsError> {
|
||||
if !b.starts_with(b"DDS ") {
|
||||
return Err(bad("missing the `DDS ` signature"));
|
||||
}
|
||||
if le32(b, 4)? != 124 {
|
||||
return Err(bad("header size is not 124"));
|
||||
}
|
||||
let (flags, height, width, depth, caps2) = (le32(b, 8)?, le32(b, 12)?, le32(b, 16)?, le32(b, 24)?, le32(b, 112)?);
|
||||
if caps2 & DDSCAPS2_CUBEMAP != 0 {
|
||||
return Err(unsupported("cubemaps are not supported"));
|
||||
}
|
||||
if caps2 & DDSCAPS2_VOLUME != 0 || (flags & DDSD_DEPTH != 0 && depth > 1) {
|
||||
return Err(unsupported("volume textures are not supported"));
|
||||
}
|
||||
let dx10 = le32(b, 80)? & DDPF_FOURCC != 0 && &le32(b, 84)?.to_le_bytes() == b"DX10";
|
||||
let (encoding, start) = if dx10 { (dx10_encoding(b)?, HEADER + DX10_HEADER) } else { (legacy_encoding(b)?, HEADER) };
|
||||
if b.len() < start {
|
||||
return Err(bad("truncated header"));
|
||||
}
|
||||
if width == 0 || height == 0 {
|
||||
return Err(bad("texture dimensions must be nonzero"));
|
||||
}
|
||||
Ok(Texture { bytes: b, flags, width, height, encoding, start })
|
||||
}
|
||||
|
||||
pub fn width(&self) -> u32 {
|
||||
self.width
|
||||
}
|
||||
|
||||
pub fn height(&self) -> u32 {
|
||||
self.height
|
||||
}
|
||||
|
||||
/// The layout [`Texture::decode`] returns.
|
||||
pub fn layout(&self) -> Layout {
|
||||
self.encoding.layout()
|
||||
}
|
||||
|
||||
/// The top mip level's pixels in [`Texture::layout`], bounded by [`DEFAULT_MAX_DECODE_BYTES`].
|
||||
pub fn decode(&self) -> Result<Vec<u8>, DdsError> {
|
||||
self.decode_with_limit(DEFAULT_MAX_DECODE_BYTES)
|
||||
}
|
||||
|
||||
/// Decode with an explicit per-buffer output byte budget; allocation remains fallible.
|
||||
pub fn decode_with_limit(&self, max_bytes: u64) -> Result<Vec<u8>, DdsError> {
|
||||
let (b, flags, encoding) = (self.bytes, self.flags, self.encoding);
|
||||
let (width, height) = (self.width, self.height);
|
||||
// The same header field is a total level size for BC, but a row stride when DDSD_PITCH is set.
|
||||
let pitch = if flags & DDSD_PITCH != 0 { Some(le32(b, 20)?) } else { None };
|
||||
let (row_pitch, size) = encoding.level_layout(width, height, pitch)?;
|
||||
let (w, h) = (width as usize, height as usize);
|
||||
let channels = encoding.layout().channels();
|
||||
let row_size = w.checked_mul(channels).ok_or_else(|| bad("pixel size overflow"))?;
|
||||
let total = row_size.checked_mul(h).ok_or_else(|| bad("pixel size overflow"))?;
|
||||
if total as u64 > max_bytes {
|
||||
return Err(DdsError::LimitExceeded { required: total, limit: max_bytes });
|
||||
}
|
||||
let data = b.get(self.start..).and_then(|d| d.get(..size)).ok_or_else(|| bad(format!("truncated pixel data: {size} bytes needed")))?;
|
||||
let mut pixels = alloc_zeroed(total)?;
|
||||
match encoding {
|
||||
Encoding::Masks { bytes, gray, fields } => decode_masks(Masks { bytes, gray, fields }, data, row_pitch, &mut pixels, row_size),
|
||||
Encoding::Bc1 | Encoding::Bc2 | Encoding::Bc3 | Encoding::Bc4 | Encoding::Bc5 => {
|
||||
decode_blocks(encoding, data, (w, channels), &mut pixels)
|
||||
}
|
||||
}
|
||||
Ok(pixels)
|
||||
}
|
||||
}
|
||||
|
||||
/// An uncompressed pixel format: bytes per pixel, luminance or RGB, and the red (or
|
||||
/// luminance), green, blue and alpha fields.
|
||||
struct Masks {
|
||||
bytes: usize,
|
||||
gray: bool,
|
||||
fields: [Option<Field>; 4],
|
||||
}
|
||||
|
||||
/// Uncompressed rows `row_pitch` apart into `pixels` (rows of `row_size` bytes), one row of
|
||||
/// pixels per task.
|
||||
fn decode_masks(m: Masks, data: &[u8], row_pitch: usize, pixels: &mut [u8], row_size: usize) {
|
||||
let Masks { bytes, gray, fields } = m;
|
||||
let channels = if gray { 1 + usize::from(fields[3].is_some()) } else { 3 + usize::from(fields[3].is_some()) };
|
||||
// The field each output channel comes from.
|
||||
let picks = if gray { [0, 3, 0, 0] } else { [0, 1, 2, 3] };
|
||||
// An 8-bit field on a byte boundary scales to itself, so when every channel is one (or
|
||||
// absent, and 0) the pixels are a byte shuffle: the byte each channel copies.
|
||||
let mut at: [Option<usize>; 4] = [None; 4];
|
||||
let mut whole_bytes = true;
|
||||
for (slot, &pick) in at.iter_mut().zip(&picks).take(channels) {
|
||||
match fields.get(pick).copied().flatten() {
|
||||
None => {}
|
||||
Some(f) if f.max == 255 && f.shift % 8 == 0 => *slot = Some(f.shift as usize / 8),
|
||||
Some(_) => whole_bytes = false,
|
||||
}
|
||||
}
|
||||
// Four bytes to four channels, each present: RGBA, BGRA and the like.
|
||||
let four = (whole_bytes && bytes == 4 && channels == 4 && at.iter().all(Option::is_some)).then(|| at.map(|i| i.unwrap_or(0) & 3));
|
||||
rows(pixels, row_size, |y, dst_row| {
|
||||
// Stop at the output width, leaving any stored row padding unread.
|
||||
let src_row = data.get(y * row_pitch..).unwrap_or_default();
|
||||
if let Some(order) = four {
|
||||
let (src, dst) = (src_row.as_chunks::<4>().0, dst_row.as_chunks_mut::<4>().0);
|
||||
if order == [0, 1, 2, 3] {
|
||||
for (d, s) in dst.iter_mut().zip(src) {
|
||||
*d = *s;
|
||||
}
|
||||
} else {
|
||||
for (d, s) in dst.iter_mut().zip(src) {
|
||||
*d = order.map(|i| s[i]);
|
||||
}
|
||||
}
|
||||
} else if whole_bytes {
|
||||
for (src, dst) in src_row.chunks_exact(bytes).zip(dst_row.chunks_exact_mut(channels)) {
|
||||
for (v, i) in dst.iter_mut().zip(at) {
|
||||
*v = i.and_then(|i| src.get(i)).copied().unwrap_or(0);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (src, dst) in src_row.chunks_exact(bytes).zip(dst_row.chunks_exact_mut(channels)) {
|
||||
let pixel = src.iter().rev().fold(0u32, |v, &byte| v << 8 | u32::from(byte));
|
||||
let channel = |i: usize| fields[i].map_or(0, |f| f.get(pixel));
|
||||
let values = if gray { [channel(0), channel(3), 0, 0] } else { [channel(0), channel(1), channel(2), channel(3)] };
|
||||
dst.copy_from_slice(&values[..channels]);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Block-compressed data into `pixels` of `width` × `channels` bytes a row, one row of blocks
|
||||
/// per task. Blocks wholly inside the image copy whole rows of texels; only those on the right
|
||||
/// edge check each texel.
|
||||
fn decode_blocks(encoding: Encoding, data: &[u8], (width, channels): (usize, usize), pixels: &mut [u8]) {
|
||||
let block_size = encoding.block_size().max(1);
|
||||
let blocks_x = width.div_ceil(4);
|
||||
let row_size = width * channels;
|
||||
rows(pixels, row_size.saturating_mul(4), |by, band| {
|
||||
let src = data.get(by * blocks_x * block_size..).unwrap_or_default();
|
||||
for (bx, block) in src.chunks_exact(block_size).take(blocks_x).enumerate() {
|
||||
let second = block.get(8..).unwrap_or_default();
|
||||
let texels = match encoding {
|
||||
Encoding::Bc1 => bc::decode_colour(block, true),
|
||||
Encoding::Bc2 => with_alpha(bc::decode_colour(second, false), bc::decode_bc2_alpha(block)),
|
||||
Encoding::Bc4 => values(&[bc::decode_values(block)]),
|
||||
Encoding::Bc5 => values(&[bc::decode_values(block), bc::decode_values(second)]),
|
||||
_ => with_alpha(bc::decode_colour(second, false), bc::decode_values(block)),
|
||||
};
|
||||
let x0 = bx * 4;
|
||||
// The band holds the block's rows that lie inside the image (fewer than four in the
|
||||
// last band of a height that isn't a multiple of four).
|
||||
for (line, row) in band.chunks_exact_mut(row_size).zip(texels.as_chunks::<4>().0) {
|
||||
if x0 + 4 <= width && channels == 4 {
|
||||
if let Some(dst) = line.get_mut(x0 * 4..x0 * 4 + 16) {
|
||||
dst.copy_from_slice(row.as_flattened());
|
||||
}
|
||||
} else {
|
||||
let dst = line.get_mut(x0 * channels..).unwrap_or_default();
|
||||
for (d, texel) in dst.chunks_exact_mut(channels).zip(row) {
|
||||
d.copy_from_slice(texel.get(..channels).unwrap_or_default());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Texels whose first channels are `channels`' values, the rest 0: gray for BC4, red and green
|
||||
/// (and blue 0) for BC5.
|
||||
fn values(channels: &[[u8; 16]]) -> [[u8; 4]; 16] {
|
||||
std::array::from_fn(|t| std::array::from_fn(|c| channels.get(c).map_or(0, |v| v[t])))
|
||||
}
|
||||
|
||||
fn with_alpha(mut texels: [[u8; 4]; 16], alpha: [u8; 16]) -> [[u8; 4]; 16] {
|
||||
for (texel, a) in texels.iter_mut().zip(alpha) {
|
||||
texel[3] = a;
|
||||
}
|
||||
texels
|
||||
}
|
||||
|
||||
const DDSD_CAPS: u32 = 0x1;
|
||||
const DDSD_HEIGHT: u32 = 0x2;
|
||||
const DDSD_WIDTH: u32 = 0x4;
|
||||
const DDSD_PITCH: u32 = 0x8;
|
||||
const DDSD_PIXELFORMAT: u32 = 0x1000;
|
||||
const DDSD_MIPMAPCOUNT: u32 = 0x2_0000;
|
||||
const DDSD_LINEARSIZE: u32 = 0x8_0000;
|
||||
const DDSCAPS_COMPLEX: u32 = 0x8;
|
||||
const DDSCAPS_TEXTURE: u32 = 0x1000;
|
||||
const DDSCAPS_MIPMAP: u32 = 0x40_0000;
|
||||
const DXGI_BC4_UNORM: u32 = 80;
|
||||
const DXGI_BC5_UNORM: u32 = 83;
|
||||
|
||||
fn encode_err(reason: impl fmt::Display) -> DdsError {
|
||||
DdsError::Encode(reason.to_string())
|
||||
}
|
||||
|
||||
/// A zeroed buffer of `len` bytes, or [`DdsError::Alloc`] when it can't be reserved.
|
||||
fn alloc_zeroed(len: usize) -> Result<Vec<u8>, DdsError> {
|
||||
let mut v = Vec::new();
|
||||
v.try_reserve_exact(len).map_err(|_| DdsError::Alloc(len))?;
|
||||
v.resize(len, 0);
|
||||
Ok(v)
|
||||
}
|
||||
|
||||
/// How a written texture stores its pixels.
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum Store {
|
||||
/// 8-bit luminance.
|
||||
Luminance,
|
||||
/// 8-bit luminance, then 8-bit alpha.
|
||||
LuminanceAlpha,
|
||||
/// Blue, green, red and an unused byte (written as 255, so a reader that takes it for
|
||||
/// alpha still sees an opaque texture).
|
||||
Bgrx,
|
||||
Bgra,
|
||||
Bc1,
|
||||
Bc2,
|
||||
Bc3,
|
||||
Bc4,
|
||||
Bc5,
|
||||
}
|
||||
|
||||
impl Store {
|
||||
/// The storage for pixels of `layout`. Block compressions take their
|
||||
/// [`DdsCompression::layout`] only.
|
||||
fn new(compression: DdsCompression, layout: Layout) -> Result<Store, DdsError> {
|
||||
Ok(match (compression, layout) {
|
||||
(DdsCompression::None, Layout::Gray) => Store::Luminance,
|
||||
(DdsCompression::None, Layout::GrayA) => Store::LuminanceAlpha,
|
||||
(DdsCompression::None, Layout::Rgb) => Store::Bgrx,
|
||||
(DdsCompression::None, Layout::Rgba) => Store::Bgra,
|
||||
(DdsCompression::Bc1, Layout::Rgba) => Store::Bc1,
|
||||
(DdsCompression::Bc2, Layout::Rgba) => Store::Bc2,
|
||||
(DdsCompression::Bc3, Layout::Rgba) => Store::Bc3,
|
||||
(DdsCompression::Bc4, Layout::Gray) => Store::Bc4,
|
||||
(DdsCompression::Bc5, Layout::Rgb) => Store::Bc5,
|
||||
(_, layout) => return Err(encode_err(format!("{layout:?} pixels can't be written as `{}`", compression.name()))),
|
||||
})
|
||||
}
|
||||
|
||||
/// Bytes per pixel, or per 4×4 block for a block compression.
|
||||
fn unit(self) -> usize {
|
||||
match self {
|
||||
Store::Luminance => 1,
|
||||
Store::LuminanceAlpha => 2,
|
||||
Store::Bgrx | Store::Bgra => 4,
|
||||
Store::Bc1 | Store::Bc4 => 8,
|
||||
Store::Bc2 | Store::Bc3 | Store::Bc5 => 16,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_block(self) -> bool {
|
||||
matches!(self, Store::Bc1 | Store::Bc2 | Store::Bc3 | Store::Bc4 | Store::Bc5)
|
||||
}
|
||||
|
||||
/// The DXGI format of the DX10 header, for the formats the legacy header can't name.
|
||||
fn dxgi(self) -> Option<u32> {
|
||||
match self {
|
||||
Store::Bc4 => Some(DXGI_BC4_UNORM),
|
||||
Store::Bc5 => Some(DXGI_BC5_UNORM),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Bytes of one row of pixels (or of 4×4 blocks) of a level `width` wide.
|
||||
fn row_bytes(self, width: usize) -> Option<usize> {
|
||||
if self.is_block() { width.div_ceil(4).checked_mul(self.unit()) } else { width.checked_mul(self.unit()) }
|
||||
}
|
||||
|
||||
fn level_bytes(self, width: usize, height: usize) -> Option<usize> {
|
||||
let rows = if self.is_block() { height.div_ceil(4) } else { height };
|
||||
self.row_bytes(width)?.checked_mul(rows)
|
||||
}
|
||||
|
||||
/// DDS_PIXELFORMAT: flags, FourCC, bits per pixel and the red, green, blue and alpha masks.
|
||||
fn pixel_format(self) -> (u32, [u8; 4], u32, [u32; 4]) {
|
||||
match self {
|
||||
Store::Luminance => (DDPF_LUMINANCE, [0; 4], 8, [0xff, 0, 0, 0]),
|
||||
Store::LuminanceAlpha => (DDPF_LUMINANCE | DDPF_ALPHAPIXELS, [0; 4], 16, [0xff, 0, 0, 0xff00]),
|
||||
Store::Bgrx => (DDPF_RGB, [0; 4], 32, [0xff_0000, 0xff00, 0xff, 0]),
|
||||
Store::Bgra => (DDPF_RGB | DDPF_ALPHAPIXELS, [0; 4], 32, [0xff_0000, 0xff00, 0xff, 0xff00_0000]),
|
||||
Store::Bc1 => (DDPF_FOURCC, *b"DXT1", 0, [0; 4]),
|
||||
Store::Bc2 => (DDPF_FOURCC, *b"DXT3", 0, [0; 4]),
|
||||
Store::Bc3 => (DDPF_FOURCC, *b"DXT5", 0, [0; 4]),
|
||||
Store::Bc4 | Store::Bc5 => (DDPF_FOURCC, *b"DX10", 0, [0; 4]),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Levels in a full mip chain: the larger side halves down to 1.
|
||||
fn mip_levels(width: u32, height: u32) -> u32 {
|
||||
32 - width.max(height).max(1).leading_zeros()
|
||||
}
|
||||
|
||||
fn half((w, h): (usize, usize)) -> (usize, usize) {
|
||||
((w / 2).max(1), (h / 2).max(1))
|
||||
}
|
||||
|
||||
/// A DDS file of `width` × `height` `pixels` in `layout`, interleaved and top row first.
|
||||
/// Block compressions take the layout [`DdsCompression::layout`] names (RGBA for BC1 to BC3,
|
||||
/// gray for BC4, RGB for BC5); uncompressed textures take every layout.
|
||||
pub fn encode(width: u32, height: u32, layout: Layout, pixels: &[u8], options: DdsOptions) -> Result<Vec<u8>, DdsError> {
|
||||
if width == 0 || height == 0 {
|
||||
return Err(encode_err("texture dimensions must be nonzero"));
|
||||
}
|
||||
let store = Store::new(options.compression, layout)?;
|
||||
let expected = (width as usize).checked_mul(height as usize).and_then(|n| n.checked_mul(layout.channels()));
|
||||
if expected != Some(pixels.len()) {
|
||||
return Err(encode_err(format!("{} bytes of pixels for a {width}x{height} {layout:?} texture", pixels.len())));
|
||||
}
|
||||
let levels = if options.mipmaps { mip_levels(width, height) } else { 1 };
|
||||
let top = (width as usize, height as usize);
|
||||
// Every level's size, checked before anything is allocated.
|
||||
let mut sizes = Vec::new();
|
||||
let mut size = top;
|
||||
for _ in 0..levels {
|
||||
sizes.push(store.level_bytes(size.0, size.1).ok_or_else(|| encode_err("texture size overflow"))?);
|
||||
size = half(size);
|
||||
}
|
||||
let head = if store.dxgi().is_some() { HEADER + DX10_HEADER } else { HEADER };
|
||||
let total = sizes.iter().try_fold(head, |total, &s| total.checked_add(s)).ok_or_else(|| encode_err("texture size overflow"))?;
|
||||
let header = header(width, height, store, levels, sizes.first().copied().unwrap_or(0))?;
|
||||
let mut out = alloc_zeroed(total)?;
|
||||
let (Some(dst), Some(src)) = (out.get_mut(..head), header.get(..head)) else {
|
||||
return Err(encode_err("output buffer too small"));
|
||||
};
|
||||
dst.copy_from_slice(src);
|
||||
|
||||
let channels = layout.channels();
|
||||
let mut level = Cow::Borrowed(pixels);
|
||||
let (mut size, mut at) = (top, head);
|
||||
for (i, &bytes) in sizes.iter().enumerate() {
|
||||
let dst = out.get_mut(at..at + bytes).ok_or_else(|| encode_err("output buffer too small"))?;
|
||||
write_level(store, &level, size, dst)?;
|
||||
at += bytes;
|
||||
if i + 1 < sizes.len() {
|
||||
let next = half(size);
|
||||
level = Cow::Owned(downsample(&level, size, next, channels)?);
|
||||
size = next;
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The `DDS ` signature, DDS_HEADER and, for a format only DXGI names, DDS_HEADER_DXT10 (the
|
||||
/// caller keeps the first [`HEADER`] bytes otherwise). `top` is the top level's size in bytes.
|
||||
fn header(width: u32, height: u32, store: Store, levels: u32, top: usize) -> Result<[u8; HEADER + DX10_HEADER], DdsError> {
|
||||
let mut b = [0u8; HEADER + DX10_HEADER];
|
||||
let mut put = |at: usize, v: u32| {
|
||||
if let Some(d) = b.get_mut(at..at + 4) {
|
||||
d.copy_from_slice(&v.to_le_bytes());
|
||||
}
|
||||
};
|
||||
// Uncompressed: the pitch of one row. Compressed: the whole top level (its "linear size").
|
||||
let (size_flag, pitch_or_size) = if store.is_block() { (DDSD_LINEARSIZE, Some(top)) } else { (DDSD_PITCH, store.row_bytes(width as usize)) };
|
||||
let pitch_or_size = pitch_or_size
|
||||
.and_then(|v| u32::try_from(v).ok())
|
||||
.ok_or_else(|| encode_err(format!("a {width}x{height} level is too large for a DDS header")))?;
|
||||
let mipmapped = levels > 1;
|
||||
put(4, 124);
|
||||
put(8, DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | size_flag | if mipmapped { DDSD_MIPMAPCOUNT } else { 0 });
|
||||
put(12, height);
|
||||
put(16, width);
|
||||
put(20, pitch_or_size);
|
||||
put(28, levels);
|
||||
let (flags, fourcc, bits, masks) = store.pixel_format();
|
||||
put(76, 32);
|
||||
put(80, flags);
|
||||
put(84, u32::from_le_bytes(fourcc));
|
||||
put(88, bits);
|
||||
for (i, mask) in masks.into_iter().enumerate() {
|
||||
put(92 + 4 * i, mask);
|
||||
}
|
||||
put(108, DDSCAPS_TEXTURE | if mipmapped { DDSCAPS_COMPLEX | DDSCAPS_MIPMAP } else { 0 });
|
||||
if let Some(dxgi) = store.dxgi() {
|
||||
// One 2D texture, no misc flags, alpha mode unknown (the formats have no alpha).
|
||||
put(HEADER, dxgi);
|
||||
put(HEADER + 4, DIMENSION_TEXTURE2D);
|
||||
put(HEADER + 12, 1);
|
||||
}
|
||||
b[..4].copy_from_slice(b"DDS ");
|
||||
Ok(b)
|
||||
}
|
||||
|
||||
/// Runs `f` on each `len`-byte row of `out` with its index, in parallel with the `parallel`
|
||||
/// feature.
|
||||
fn rows(out: &mut [u8], len: usize, f: impl Fn(usize, &mut [u8]) + Send + Sync) {
|
||||
#[cfg(feature = "parallel")]
|
||||
{
|
||||
use rayon::prelude::*;
|
||||
out.par_chunks_mut(len.max(1)).enumerate().for_each(|(i, row)| f(i, row));
|
||||
}
|
||||
#[cfg(not(feature = "parallel"))]
|
||||
for (i, row) in out.chunks_mut(len.max(1)).enumerate() {
|
||||
f(i, row);
|
||||
}
|
||||
}
|
||||
|
||||
/// Writes one level of `width` × `height` pixels (in the image's layout) into `dst`.
|
||||
fn write_level(store: Store, pixels: &[u8], (width, height): (usize, usize), dst: &mut [u8]) -> Result<(), DdsError> {
|
||||
let row_bytes = store.row_bytes(width).ok_or_else(|| encode_err("texture size overflow"))?;
|
||||
match store {
|
||||
Store::Luminance | Store::LuminanceAlpha => {
|
||||
// The image's gray (and alpha) samples, in the same order.
|
||||
let src = pixels.get(..dst.len()).ok_or_else(|| encode_err("the level is smaller than its size"))?;
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
Store::Bgrx | Store::Bgra => {
|
||||
let channels = if store == Store::Bgra { 4 } else { 3 };
|
||||
rows(dst, row_bytes, |y, row| {
|
||||
let src = pixels.get(y * width * channels..).unwrap_or_default();
|
||||
for (d, s) in row.as_chunks_mut::<4>().0.iter_mut().zip(src.chunks_exact(channels)) {
|
||||
let byte = |i: usize| s.get(i).copied().unwrap_or(255);
|
||||
*d = [byte(2), byte(1), byte(0), byte(3)];
|
||||
}
|
||||
});
|
||||
}
|
||||
Store::Bc1 | Store::Bc2 | Store::Bc3 => {
|
||||
let (texels, _) = pixels.as_chunks::<4>();
|
||||
rows(dst, row_bytes, |by, row| {
|
||||
for (bx, d) in row.chunks_exact_mut(store.unit()).enumerate() {
|
||||
let (block, inside) = gather(texels, (width, height), bx, by);
|
||||
let encoded: &[u8] = match store {
|
||||
Store::Bc1 => &bc::encode_bc1(&block, inside),
|
||||
Store::Bc2 => &bc::encode_bc2(&block, inside),
|
||||
_ => &bc::encode_bc3(&block, inside),
|
||||
};
|
||||
for (d, s) in d.iter_mut().zip(encoded) {
|
||||
*d = *s;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
Store::Bc4 | Store::Bc5 => {
|
||||
// BC4: the gray channel; BC5: red, then green, of RGB pixels.
|
||||
let channels = if store == Store::Bc4 { 1 } else { 3 };
|
||||
rows(dst, row_bytes, |by, row| {
|
||||
for (bx, d) in row.chunks_exact_mut(store.unit()).enumerate() {
|
||||
for (c, d) in d.as_chunks_mut::<8>().0.iter_mut().enumerate() {
|
||||
let (values, inside) = gather_channel(pixels, (width, height), channels, c, (bx, by));
|
||||
*d = bc::value_block(&values, inside);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Channel `c` of block (`bx`, `by`) of pixels with `channels` channels, and which of its texels
|
||||
/// lie inside the image.
|
||||
fn gather_channel(pixels: &[u8], (width, height): (usize, usize), channels: usize, c: usize, (bx, by): (usize, usize)) -> ([u8; 16], Mask) {
|
||||
let mut values = [0u8; 16];
|
||||
let mut inside: Mask = 0;
|
||||
for (t, v) in values.iter_mut().enumerate() {
|
||||
let (x, y) = (bx * 4 + t % 4, by * 4 + t / 4);
|
||||
if x < width
|
||||
&& y < height
|
||||
&& let Some(&p) = pixels.get((y * width + x) * channels + c)
|
||||
{
|
||||
*v = p;
|
||||
inside |= 1 << t;
|
||||
}
|
||||
}
|
||||
(values, inside)
|
||||
}
|
||||
|
||||
/// Block (`bx`, `by`)'s texels, and which of them lie inside the image.
|
||||
fn gather(texels: &[[u8; 4]], (width, height): (usize, usize), bx: usize, by: usize) -> (Block, Mask) {
|
||||
let mut block = [[0u8; 4]; 16];
|
||||
// A block wholly inside the image: four rows of four texels.
|
||||
let (x0, y0) = (bx * 4, by * 4);
|
||||
if x0 + 4 <= width && y0 + 4 <= height {
|
||||
let mut copied = 0;
|
||||
for (ty, row) in block.as_chunks_mut::<4>().0.iter_mut().enumerate() {
|
||||
if let Some(src) = texels.get((y0 + ty) * width + x0..).and_then(|s| s.first_chunk::<4>()) {
|
||||
*row = *src;
|
||||
copied += 1;
|
||||
}
|
||||
}
|
||||
if copied == 4 {
|
||||
return (block, Mask::MAX);
|
||||
}
|
||||
}
|
||||
let mut inside: Mask = 0;
|
||||
for (t, texel) in block.iter_mut().enumerate() {
|
||||
let (x, y) = (bx * 4 + t % 4, by * 4 + t / 4);
|
||||
if x < width
|
||||
&& y < height
|
||||
&& let Some(p) = texels.get(y * width + x)
|
||||
{
|
||||
*texel = *p;
|
||||
inside |= 1 << t;
|
||||
}
|
||||
}
|
||||
(block, inside)
|
||||
}
|
||||
|
||||
/// The next mip level: each pixel the average of the 2×2 pixels it covers, or of 2×3, 3×2 or
|
||||
/// 3×3 along the last column and row of an odd-sized level, so no pixel is dropped.
|
||||
fn downsample(src: &[u8], (w, h): (usize, usize), (nw, nh): (usize, usize), channels: usize) -> Result<Vec<u8>, DdsError> {
|
||||
let len = nw.checked_mul(nh).and_then(|n| n.checked_mul(channels)).ok_or_else(|| encode_err("mip level size overflow"))?;
|
||||
let mut dst = alloc_zeroed(len)?;
|
||||
let span = |i: usize, n: usize, size: usize| 2 * i..=if i + 1 == n { size.saturating_sub(1) } else { 2 * i + 1 };
|
||||
let ch = channels.max(1);
|
||||
let line = w * ch;
|
||||
rows(&mut dst, nw * channels, |y, row| {
|
||||
let ys = span(y, nh, h);
|
||||
// Every pixel but those of the last column and row averages exactly 2×2: the same sum
|
||||
// and rounding as below, from two source rows read in step.
|
||||
let mut edge = 0;
|
||||
if y + 1 < nh
|
||||
&& let (Some(r0), Some(r1)) = (src.get(2 * y * line..(2 * y + 1) * line), src.get((2 * y + 1) * line..(2 * y + 2) * line))
|
||||
{
|
||||
let interior = nw.saturating_sub(1);
|
||||
for ((px, a), b) in row.chunks_exact_mut(ch).zip(r0.chunks_exact(2 * ch)).zip(r1.chunks_exact(2 * ch)).take(interior) {
|
||||
for (c, v) in px.iter_mut().enumerate() {
|
||||
let sum = u32::from(a[c]) + u32::from(a[ch + c]) + u32::from(b[c]) + u32::from(b[ch + c]);
|
||||
*v = ((sum + 2) / 4) as u8;
|
||||
}
|
||||
}
|
||||
edge = interior;
|
||||
}
|
||||
for (x, px) in row.chunks_exact_mut(ch).enumerate().skip(edge) {
|
||||
let xs = span(x, nw, w);
|
||||
for (c, v) in px.iter_mut().enumerate() {
|
||||
let (mut sum, mut n) = (0u32, 0u32);
|
||||
for sy in ys.clone() {
|
||||
for sx in xs.clone() {
|
||||
if let Some(&s) = src.get((sy * w + sx) * channels + c) {
|
||||
sum += u32::from(s);
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
*v = ((sum + n / 2) / n.max(1)) as u8;
|
||||
}
|
||||
}
|
||||
});
|
||||
Ok(dst)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_pixel_buffer_of_the_wrong_size_is_refused() {
|
||||
let options = DdsOptions::default();
|
||||
assert!(matches!(encode(2, 2, Layout::Rgb, &[0; 11], options), Err(DdsError::Encode(_))));
|
||||
assert!(matches!(encode(2, 2, Layout::Rgb, &[0; 13], options), Err(DdsError::Encode(_))));
|
||||
assert!(encode(2, 2, Layout::Rgb, &[0; 12], options).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn block_compressions_take_their_layout_only() {
|
||||
let options = DdsOptions { compression: DdsCompression::Bc3, mipmaps: false };
|
||||
assert_eq!(encode(1, 1, Layout::Rgb, &[1, 2, 3], options), Err(DdsError::Encode("Rgb pixels can't be written as `bc3`".into())));
|
||||
for compression in DdsCompression::ALL {
|
||||
for layout in [Layout::Gray, Layout::GrayA, Layout::Rgb, Layout::Rgba] {
|
||||
let options = DdsOptions { compression, mipmaps: false };
|
||||
let written = encode(1, 1, layout, &[9; 4][..layout.channels()], options);
|
||||
let takes = compression.layout().is_none_or(|l| l == layout);
|
||||
assert_eq!(written.is_ok(), takes, "{compression:?} from {layout:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_header_is_read_before_the_pixels() {
|
||||
// A header that promises more pixel data than the file holds: its size and layout are
|
||||
// known, and only decoding fails.
|
||||
let file = encode(8, 8, Layout::Gray, &[7; 64], DdsOptions::default()).unwrap();
|
||||
let texture = Texture::parse(&file[..HEADER + 10]).unwrap();
|
||||
assert_eq!((texture.width(), texture.height(), texture.layout()), (8, 8, Layout::Gray));
|
||||
assert!(matches!(texture.decode(), Err(DdsError::Malformed(_))));
|
||||
assert_eq!(Texture::parse(&file).and_then(|t| t.decode()), Ok(vec![7; 64]));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
use craft_dds::{DdsCompression, DdsOptions, Layout, Texture, encode};
|
||||
#[test]
|
||||
fn metadata_requires_a_complete_header() {
|
||||
for (compression, layout, channels, header) in [(DdsCompression::None, Layout::Gray, 1, 128), (DdsCompression::Bc4, Layout::Gray, 1, 148)] {
|
||||
let data = encode(4, 4, layout, &vec![7; 16 * channels], DdsOptions { compression, mipmaps: false }).unwrap();
|
||||
for n in 0..header {
|
||||
assert!(Texture::parse(&data[..n]).is_err(), "accepted {n}/{header} header bytes");
|
||||
}
|
||||
assert!(Texture::parse(&data[..header]).is_ok());
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn empty_dimensions_are_not_textures() {
|
||||
for (w, h) in [(0, 0), (0, 4), (4, 0)] {
|
||||
assert!(encode(w, h, Layout::Gray, &[], DdsOptions::default()).is_err(), "encoded {w}x{h}");
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn decoded_output_respects_explicit_budget() {
|
||||
let data = encode(4, 4, Layout::Rgba, &[7; 64], DdsOptions { compression: DdsCompression::Bc1, mipmaps: false }).unwrap();
|
||||
let texture = Texture::parse(&data).unwrap();
|
||||
assert!(matches!(texture.decode_with_limit(63), Err(craft_dds::DdsError::LimitExceeded { required: 64, limit: 63 })));
|
||||
assert_eq!(texture.decode_with_limit(64).unwrap().len(), 64);
|
||||
assert_eq!(texture.decode().unwrap(), texture.decode_with_limit(u64::MAX).unwrap());
|
||||
}
|
||||
#[test]
|
||||
fn parse_rejects_empty_dimensions() {
|
||||
let valid = encode(1, 1, Layout::Gray, &[7], DdsOptions::default()).unwrap();
|
||||
for (w, h) in [(0u32, 0u32), (0, 4), (4, 0)] {
|
||||
let mut data = valid.clone();
|
||||
data[12..16].copy_from_slice(&h.to_le_bytes());
|
||||
data[16..20].copy_from_slice(&w.to_le_bytes());
|
||||
assert!(Texture::parse(&data).is_err());
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn default_budget_rejects_oversized_header_before_payload_or_allocation() {
|
||||
let mut data = encode(1, 1, Layout::Gray, &[7], DdsOptions::default()).unwrap();
|
||||
data.truncate(128);
|
||||
data[12..16].copy_from_slice(&65536u32.to_le_bytes());
|
||||
data[16..20].copy_from_slice(&32768u32.to_le_bytes());
|
||||
data[20..24].copy_from_slice(&32768u32.to_le_bytes());
|
||||
let texture = Texture::parse(&data).unwrap();
|
||||
assert!(matches!(texture.decode(), Err(craft_dds::DdsError::LimitExceeded { limit: craft_dds::DEFAULT_MAX_DECODE_BYTES, .. })));
|
||||
assert!(matches!(texture.decode_with_limit(u64::MAX), Err(craft_dds::DdsError::Malformed(_))));
|
||||
}
|
||||
@@ -24,6 +24,7 @@ heif = ["dep:craft-heif"]
|
||||
avif-decode = ["dep:craft-video", "craft-video/av1-decode"]
|
||||
|
||||
[dependencies]
|
||||
craft-dds = { workspace = true }
|
||||
crc32fast = "1.5"
|
||||
thiserror = { workspace = true }
|
||||
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "tiff", "gif", "bmp", "tga", "ico", "qoi", "hdr"] }
|
||||
@@ -48,6 +49,8 @@ avif-serialize = { version = "0.8", optional = true }
|
||||
hayro-jpeg2000 = { version = "=0.3.5", default-features = false, features = ["std", "simd"] }
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
||||
# DDS encodes rows of blocks on several threads, as the other parallel codecs here do on native targets.
|
||||
craft-dds = { workspace = true, features = ["parallel"] }
|
||||
rayon = { workspace = true }
|
||||
craft-video = { workspace = true, optional = true }
|
||||
exr = { version = "1.73", default-features = false, features = ["rayon"] }
|
||||
|
||||
@@ -46,7 +46,7 @@ craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "<
|
||||
| BMP | yes | yes | U8 | RGB, RGBA | yes | no | no | no | yes (header pixels per metre) | no | no | `image` |
|
||||
| TGA | yes | yes | U8 | Gray, GrayA, RGB, RGBA | yes | no | no | no | no | no | no | `image` (read) / built in (RLE write, one scanline per packet) |
|
||||
| ICO | yes | yes | U8 | RGBA (at most 256×256) | yes | no | no | no | no | no | no | `image` |
|
||||
| DDS | yes | yes | U8 | Gray, GrayA, RGB, RGBA | yes | no | no | no | no | no | yes (BC1–BC3, when `EncodeOptions::dds` asks for one) | built in |
|
||||
| DDS | yes | yes | U8 | Gray, GrayA, RGB, RGBA | yes | no | no | no | no | no | yes (BC1–BC5, when `EncodeOptions::dds` asks for one) | [`craft-dds`](../dds/README.md) |
|
||||
| Netpbm (PBM/PGM/PPM/PAM/PFM) | yes | yes | U8, U16, F32 (float: PFM gray/RGB only) | all six (PAM `CMYK`/`CMYK_ALPHA`) | yes (PAM) | no | no | no | no | no | no | built in |
|
||||
| QOI | yes | yes | U8 | RGB, RGBA | yes | no | no | no | no | no | no | `image` |
|
||||
| OpenEXR | yes | yes | F16, F32 | Y, YA, RGB, RGBA | yes | no | no | no | no | no | no | `exr` |
|
||||
@@ -95,20 +95,29 @@ embedded table (and a PNG's transparent entry) so `photocraft-io` can open them
|
||||
Reading remains in the separate #2868 PR. The `ASYMMETRIC_EXCEPTIONS`
|
||||
entry stays until import is merged.
|
||||
|
||||
* **DDS.** The top mip level of a 2D texture: uncompressed pixels described by channel masks
|
||||
(8, 16, 24 or 32 bits, RGB or luminance, with or without alpha) or BC1/BC2/BC3 (DXT1/DXT3/DXT5),
|
||||
with the legacy header or the DX10 one. Uncompressed row padding follows the header's
|
||||
`DDSD_PITCH` stride; without that flag, rows are tightly packed. Everything opens as U8; the
|
||||
other mip levels are ignored. Cubemaps, texture arrays, volume textures, premultiplied DXT2/DXT4 and other formats
|
||||
(BC4–BC7, float) are refused with `CodecError::Unsupported`. Writing (`EncodeOptions::dds`) makes
|
||||
a 2D texture with the legacy header: uncompressed by default (BGRA, BGRX, or luminance with or
|
||||
without alpha, so it reads back exactly), or BC1/BC2/BC3. The block encoder is our own, from
|
||||
* **DDS** (through [`craft-dds`](../dds/README.md), whose `DdsCompression` and `DdsOptions` are
|
||||
re-exported). The top mip level of a 2D texture: uncompressed pixels described by channel masks
|
||||
(8, 16, 24 or 32 bits, RGB or luminance, with or without alpha), BC1/BC2/BC3 (DXT1/DXT3/DXT5) or
|
||||
unsigned BC4/BC5 (ATI1/ATI2, BC4U/BC5U, DXGI 79, 80, 82 and 83), with the legacy header or the
|
||||
DX10 one. BC4 opens as Gray and BC5 as RGB with blue 0 (BC5 stores only red and green; a normal
|
||||
map's Z is not reconstructed). ATI2 is read as Microsoft reads it, red in the first block.
|
||||
Uncompressed row padding follows the header's `DDSD_PITCH` stride; without that flag, rows are
|
||||
tightly packed. Everything opens as U8; the other mip levels are ignored. Cubemaps, texture
|
||||
arrays, volume textures, premultiplied-alpha textures (DXT2/DXT4, or DX10 alpha mode 2), signed (SNORM) BC4/BC5 and other formats
|
||||
(BC6H, BC7, float) are refused with `CodecError::Unsupported`. Writing (`EncodeOptions::dds`)
|
||||
makes a 2D texture: uncompressed by default (BGRA, BGRX, or luminance with or without alpha, so
|
||||
it reads back exactly), BC1/BC2/BC3 (from RGBA) with the legacy header, or BC4 (from gray, for
|
||||
roughness, height and other single-channel maps) and BC5 (from RGB, blue dropped, for normal
|
||||
maps) with the DX10 header (`BC4_UNORM`, `BC5_UNORM`). The plan converts other layouts to what
|
||||
the compression stores, so `fidelity_warnings` reports colour to gray for BC4 and dropped alpha
|
||||
for both; BC5's dropped blue comes under `LossyCompression`. The block encoder is our own, from
|
||||
Microsoft's public block-compression documentation: RGB565 endpoints fitted along each block's
|
||||
principal axis and refined by least squares, indices picked against the palette the reader
|
||||
decodes; BC1 turns texels under half opacity into its transparent black, and BC3 picks
|
||||
whichever alpha mode fits. `mipmaps` adds the full chain down to 1×1, each level a box filter
|
||||
of the one above (the last column and row of an odd-sized level average three pixels, so none
|
||||
is dropped). Cubemaps, arrays, BC4–BC7 and sRGB (DX10-only) formats aren't written.
|
||||
decodes; BC1 turns texels under half opacity into its transparent black, and BC3, BC4 and BC5
|
||||
pick whichever mode of their value blocks fits. `mipmaps` adds the full chain down to 1×1, each
|
||||
level a box filter of the one above (the last column and row of an odd-sized level average
|
||||
three pixels, so none is dropped). Cubemaps, arrays, BC6H, BC7 and sRGB (DX10-only) formats
|
||||
aren't written.
|
||||
|
||||
* **FITS.** The image in the primary HDU, or the first `IMAGE` extension, is read; `NAXIS3 = 3`
|
||||
opens as RGB and any other plane count opens the first plane with `DecodeWarning::MorePages`.
|
||||
|
||||
@@ -3,7 +3,6 @@ pub(crate) mod avif;
|
||||
pub(crate) mod avif_decode;
|
||||
pub(crate) mod bmp;
|
||||
pub(crate) mod dds;
|
||||
pub(crate) mod dds_bc;
|
||||
pub(crate) mod deep_exr;
|
||||
pub(crate) mod dicom;
|
||||
pub(crate) mod dpx;
|
||||
|
||||
@@ -1,557 +1,60 @@
|
||||
//! DirectDraw Surface (DDS) textures, after Microsoft's public DDS documentation ("DDS",
|
||||
//! "DDS_HEADER", "DDS_PIXELFORMAT", "DDS_HEADER_DXT10").
|
||||
//!
|
||||
//! Reading: the top mip level of a 2D texture, either uncompressed (8 to 32 bits per pixel
|
||||
//! described by channel masks, RGB or luminance) or block-compressed BC1/BC2/BC3
|
||||
//! (DXT1/DXT3/DXT5), with or without the DX10 header. Cubemaps, texture arrays and volume
|
||||
//! textures are refused rather than flattened to one face or slice.
|
||||
//!
|
||||
//! Writing: a 2D texture, uncompressed (BGRA or BGRX, luminance with or without alpha) or
|
||||
//! BC1/BC2/BC3, optionally with its full mip chain. The legacy header describes all of these,
|
||||
//! so no DX10 header is written; formats only DXGI can name (BC4–BC7, sRGB) aren't written.
|
||||
//! DirectDraw Surface (DDS) textures through [`craft_dds`]: its errors and pixel layouts mapped
|
||||
//! onto this crate's, and the decoder's size checked against [`Limits`] before it allocates.
|
||||
|
||||
use std::borrow::Cow;
|
||||
|
||||
use super::dds_bc::{self, Block, Mask};
|
||||
use crate::SampleType;
|
||||
use crate::error::CodecError;
|
||||
use crate::fidelity::Plan;
|
||||
use crate::format::Format;
|
||||
use crate::image::{ChannelLayout, Image};
|
||||
use crate::options::{DdsCompression, EncodeOptions, Limits};
|
||||
use crate::options::{EncodeOptions, Limits};
|
||||
use craft_dds::{DdsError, Layout, Texture};
|
||||
|
||||
/// `DDS ` plus the 124-byte DDS_HEADER.
|
||||
const HEADER: usize = 128;
|
||||
/// DDS_HEADER_DXT10, present when the FourCC is `DX10`.
|
||||
const DX10_HEADER: usize = 20;
|
||||
|
||||
const DDSD_DEPTH: u32 = 0x80_0000;
|
||||
const DDPF_ALPHAPIXELS: u32 = 0x1;
|
||||
const DDPF_FOURCC: u32 = 0x4;
|
||||
const DDPF_RGB: u32 = 0x40;
|
||||
const DDPF_LUMINANCE: u32 = 0x2_0000;
|
||||
const DDSCAPS2_CUBEMAP: u32 = 0x200;
|
||||
const DDSCAPS2_CUBEMAP_FACES: u32 = 0xfc00;
|
||||
const DDSCAPS2_VOLUME: u32 = 0x20_0000;
|
||||
const DIMENSION_TEXTURE2D: u32 = 3;
|
||||
const MISC_TEXTURECUBE: u32 = 0x4;
|
||||
|
||||
fn bad(reason: impl std::fmt::Display) -> CodecError {
|
||||
CodecError::malformed(Format::Dds, reason)
|
||||
fn error(e: DdsError) -> CodecError {
|
||||
match e {
|
||||
DdsError::Malformed(reason) => CodecError::malformed(Format::Dds, reason),
|
||||
DdsError::Unsupported(reason) => CodecError::unsupported(Format::Dds, reason),
|
||||
DdsError::Encode(reason) => CodecError::encode(Format::Dds, reason),
|
||||
DdsError::Alloc(len) => CodecError::LimitExceeded(format!("cannot allocate {len} elements for the image")),
|
||||
DdsError::LimitExceeded { required, limit } => {
|
||||
CodecError::LimitExceeded(format!("decoded texture requires {required} bytes, exceeding limit {limit}"))
|
||||
}
|
||||
other => CodecError::malformed(Format::Dds, other),
|
||||
}
|
||||
}
|
||||
fn unsupported(reason: impl Into<String>) -> CodecError {
|
||||
CodecError::unsupported(Format::Dds, reason)
|
||||
}
|
||||
fn le32(b: &[u8], at: usize) -> Result<u32, CodecError> {
|
||||
let bytes = b.get(at..at + 4).and_then(|s| <[u8; 4]>::try_from(s).ok()).ok_or_else(|| bad("truncated header"))?;
|
||||
Ok(u32::from_le_bytes(bytes))
|
||||
|
||||
pub(crate) fn channel_layout(layout: Layout) -> ChannelLayout {
|
||||
match layout {
|
||||
Layout::Gray => ChannelLayout::Gray,
|
||||
Layout::GrayA => ChannelLayout::GrayA,
|
||||
Layout::Rgb => ChannelLayout::Rgb,
|
||||
Layout::Rgba => ChannelLayout::Rgba,
|
||||
}
|
||||
}
|
||||
|
||||
/// Header-declared extra subresources cannot survive a single-image rewrite, even without presence flags.
|
||||
pub(crate) fn has_additional_images(bytes: &[u8]) -> Result<bool, CodecError> {
|
||||
let depth = le32(bytes, 24)?;
|
||||
let mips = le32(bytes, 28)?;
|
||||
let faces = (le32(bytes, 112)? & DDSCAPS2_CUBEMAP_FACES).count_ones();
|
||||
let dx10 = le32(bytes, 80)? & DDPF_FOURCC != 0 && bytes.get(84..88) == Some(b"DX10");
|
||||
let (cube, array) = if dx10 { (le32(bytes, 136)? & MISC_TEXTURECUBE != 0, le32(bytes, 140)?) } else { (false, 0) };
|
||||
Ok(depth > 1 || mips > 1 || faces > 1 || cube || array > 1)
|
||||
}
|
||||
|
||||
/// A FourCC as text when it is printable, else as the number legacy writers store there.
|
||||
fn fourcc_name(fourcc: u32) -> String {
|
||||
let bytes = fourcc.to_le_bytes();
|
||||
if bytes.iter().all(|c| c.is_ascii_graphic() || *c == b' ') { bytes.iter().map(|&c| char::from(c)).collect() } else { fourcc.to_string() }
|
||||
}
|
||||
|
||||
/// One channel of an uncompressed pixel: where it sits and its largest value.
|
||||
#[derive(Clone, Copy)]
|
||||
struct Field {
|
||||
shift: u32,
|
||||
max: u32,
|
||||
}
|
||||
|
||||
impl Field {
|
||||
/// `None` for an empty mask; an error for one with gaps or wider than the pixel.
|
||||
fn new(mask: u32, bits: u32) -> Result<Option<Field>, CodecError> {
|
||||
if mask == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
let shift = mask.trailing_zeros();
|
||||
let max = mask >> shift;
|
||||
if max & max.wrapping_add(1) != 0 || (bits < 32 && mask >> bits != 0) {
|
||||
return Err(bad(format!("channel mask {mask:#x} is not a contiguous field of a {bits}-bit pixel")));
|
||||
}
|
||||
Ok(Some(Field { shift, max }))
|
||||
}
|
||||
|
||||
fn get(self, pixel: u32) -> u8 {
|
||||
let v = u64::from((pixel >> self.shift) & self.max);
|
||||
let max = u64::from(self.max);
|
||||
((v * 255 + max / 2) / max) as u8
|
||||
}
|
||||
}
|
||||
|
||||
enum Encoding {
|
||||
/// Uncompressed: bytes per pixel, then red (or luminance), green, blue and alpha.
|
||||
Masks {
|
||||
bytes: usize,
|
||||
gray: bool,
|
||||
fields: [Option<Field>; 4],
|
||||
},
|
||||
Bc1,
|
||||
Bc2,
|
||||
Bc3,
|
||||
}
|
||||
|
||||
impl Encoding {
|
||||
fn masks(bits: u32, masks: [u32; 4], gray: bool) -> Result<Encoding, CodecError> {
|
||||
if !matches!(bits, 8 | 16 | 24 | 32) {
|
||||
return Err(bad(format!("{bits} bits per pixel is not 8, 16, 24 or 32")));
|
||||
}
|
||||
let mut fields = [None; 4];
|
||||
for (field, mask) in fields.iter_mut().zip(masks) {
|
||||
*field = Field::new(mask, bits)?;
|
||||
}
|
||||
let colour = if gray { fields[0].is_some() } else { fields[..3].iter().any(Option::is_some) };
|
||||
if !colour {
|
||||
return Err(bad("the pixel format has no colour channel masks"));
|
||||
}
|
||||
Ok(Encoding::Masks { bytes: bits as usize / 8, gray, fields })
|
||||
}
|
||||
|
||||
fn layout(&self) -> ChannelLayout {
|
||||
match self {
|
||||
Encoding::Masks { gray: true, fields, .. } if fields[3].is_some() => ChannelLayout::GrayA,
|
||||
Encoding::Masks { gray: true, .. } => ChannelLayout::Gray,
|
||||
Encoding::Masks { fields, .. } if fields[3].is_none() => ChannelLayout::Rgb,
|
||||
_ => ChannelLayout::Rgba,
|
||||
}
|
||||
}
|
||||
|
||||
/// Stored row stride and byte size of the top mip level (block rows for BC).
|
||||
fn level_layout(&self, width: u32, height: u32, pitch: Option<u32>) -> Result<(usize, usize), CodecError> {
|
||||
let overflow = || bad("pixel data size overflow");
|
||||
let (w, h) = (usize::try_from(width).map_err(|_| overflow())?, usize::try_from(height).map_err(|_| overflow())?);
|
||||
let (row_bytes, rows) = match self {
|
||||
Encoding::Masks { bytes, .. } => {
|
||||
let packed = w.checked_mul(*bytes).ok_or_else(overflow)?;
|
||||
let row_bytes = match pitch {
|
||||
Some(pitch) => usize::try_from(pitch).map_err(|_| overflow())?,
|
||||
None => packed,
|
||||
};
|
||||
if row_bytes < packed {
|
||||
return Err(bad(format!("row pitch {row_bytes} is smaller than the {packed}-byte pixel row")));
|
||||
}
|
||||
(row_bytes, h)
|
||||
}
|
||||
Encoding::Bc1 | Encoding::Bc2 | Encoding::Bc3 => {
|
||||
let block = if matches!(self, Encoding::Bc1) { 8 } else { 16 };
|
||||
(w.div_ceil(4).checked_mul(block).ok_or_else(overflow)?, h.div_ceil(4))
|
||||
}
|
||||
};
|
||||
let size = row_bytes.checked_mul(rows).ok_or_else(overflow)?;
|
||||
Ok((row_bytes, size))
|
||||
}
|
||||
}
|
||||
|
||||
/// The legacy pixel format: a FourCC, or channel masks.
|
||||
fn legacy_encoding(b: &[u8]) -> Result<Encoding, CodecError> {
|
||||
let (flags, fourcc, bits) = (le32(b, 80)?, le32(b, 84)?, le32(b, 88)?);
|
||||
let alpha = if flags & DDPF_ALPHAPIXELS != 0 { le32(b, 104)? } else { 0 };
|
||||
if flags & DDPF_FOURCC != 0 {
|
||||
return match &fourcc.to_le_bytes() {
|
||||
b"DXT1" => Ok(Encoding::Bc1),
|
||||
b"DXT3" => Ok(Encoding::Bc2),
|
||||
b"DXT5" => Ok(Encoding::Bc3),
|
||||
b"DXT2" | b"DXT4" => Err(unsupported("premultiplied-alpha DXT2/DXT4 textures are not supported")),
|
||||
_ => Err(unsupported(format!("compression `{}` is not supported (DXT1, DXT3 and DXT5 are)", fourcc_name(fourcc)))),
|
||||
};
|
||||
}
|
||||
if flags & DDPF_RGB != 0 {
|
||||
return Encoding::masks(bits, [le32(b, 92)?, le32(b, 96)?, le32(b, 100)?, alpha], false);
|
||||
}
|
||||
if flags & DDPF_LUMINANCE != 0 {
|
||||
return Encoding::masks(bits, [le32(b, 92)?, 0, 0, alpha], true);
|
||||
}
|
||||
Err(unsupported(format!("pixel format flags {flags:#x} are not RGB, luminance or a supported compression")))
|
||||
}
|
||||
|
||||
/// The DX10 header's DXGI format, refusing anything but a single 2D texture.
|
||||
fn dx10_encoding(b: &[u8]) -> Result<Encoding, CodecError> {
|
||||
let (dxgi, dimension, misc, array) = (le32(b, HEADER)?, le32(b, HEADER + 4)?, le32(b, HEADER + 8)?, le32(b, HEADER + 12)?);
|
||||
if misc & MISC_TEXTURECUBE != 0 {
|
||||
return Err(unsupported("cubemaps are not supported"));
|
||||
}
|
||||
if dimension != DIMENSION_TEXTURE2D {
|
||||
return Err(unsupported(format!("only 2D textures are supported (resource dimension {dimension})")));
|
||||
}
|
||||
if array > 1 {
|
||||
return Err(unsupported(format!("texture arrays are not supported ({array} textures)")));
|
||||
}
|
||||
const RGBA: [u32; 4] = [0xff, 0xff00, 0xff_0000, 0xff00_0000];
|
||||
const BGRA: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0xff00_0000];
|
||||
const BGRX: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0];
|
||||
match dxgi {
|
||||
27..=29 => Encoding::masks(32, RGBA, false),
|
||||
87 | 90 | 91 => Encoding::masks(32, BGRA, false),
|
||||
88 | 92 | 93 => Encoding::masks(32, BGRX, false),
|
||||
70..=72 => Ok(Encoding::Bc1),
|
||||
73..=75 => Ok(Encoding::Bc2),
|
||||
76..=78 => Ok(Encoding::Bc3),
|
||||
_ => Err(unsupported(format!("DXGI format {dxgi} is not supported (BC1, BC2, BC3 and 8-bit RGBA or BGRA are)"))),
|
||||
}
|
||||
craft_dds::has_additional_images(bytes).map_err(error)
|
||||
}
|
||||
|
||||
pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
|
||||
if !b.starts_with(b"DDS ") {
|
||||
return Err(bad("missing the `DDS ` signature"));
|
||||
}
|
||||
if le32(b, 4)? != 124 {
|
||||
return Err(bad("header size is not 124"));
|
||||
}
|
||||
let (flags, height, width, depth, caps2) = (le32(b, 8)?, le32(b, 12)?, le32(b, 16)?, le32(b, 24)?, le32(b, 112)?);
|
||||
if caps2 & DDSCAPS2_CUBEMAP != 0 {
|
||||
return Err(unsupported("cubemaps are not supported"));
|
||||
}
|
||||
if caps2 & DDSCAPS2_VOLUME != 0 || (flags & DDSD_DEPTH != 0 && depth > 1) {
|
||||
return Err(unsupported("volume textures are not supported"));
|
||||
}
|
||||
let dx10 = le32(b, 80)? & DDPF_FOURCC != 0 && &le32(b, 84)?.to_le_bytes() == b"DX10";
|
||||
let (encoding, start) = if dx10 { (dx10_encoding(b)?, HEADER + DX10_HEADER) } else { (legacy_encoding(b)?, HEADER) };
|
||||
let layout = encoding.layout();
|
||||
limits.check(width, height, layout, SampleType::U8)?;
|
||||
// The same header field is a total level size for BC, but a row stride when DDSD_PITCH is set.
|
||||
let pitch = if flags & DDSD_PITCH != 0 { Some(le32(b, 20)?) } else { None };
|
||||
let (row_pitch, size) = encoding.level_layout(width, height, pitch)?;
|
||||
let data = b.get(start..).and_then(|d| d.get(..size)).ok_or_else(|| bad(format!("truncated pixel data: {size} bytes needed")))?;
|
||||
let (w, h) = (width as usize, height as usize);
|
||||
let channels = layout.channels();
|
||||
let row_size = w.checked_mul(channels).ok_or_else(|| bad("pixel size overflow"))?;
|
||||
let total = row_size.checked_mul(h).ok_or_else(|| bad("pixel size overflow"))?;
|
||||
let mut pixels = vec![0u8; total];
|
||||
match encoding {
|
||||
Encoding::Masks { bytes, gray, fields } => {
|
||||
for (src_row, dst_row) in data.chunks_exact(row_pitch).zip(pixels.chunks_exact_mut(row_size)) {
|
||||
// Stop at the output width, leaving any stored row padding unread.
|
||||
for (src, dst) in src_row.chunks_exact(bytes).zip(dst_row.chunks_exact_mut(channels)) {
|
||||
let pixel = src.iter().rev().fold(0u32, |v, &byte| v << 8 | u32::from(byte));
|
||||
let channel = |i: usize| fields[i].map_or(0, |f| f.get(pixel));
|
||||
let values = if gray { [channel(0), channel(3), 0, 0] } else { [channel(0), channel(1), channel(2), channel(3)] };
|
||||
dst.copy_from_slice(&values[..channels]);
|
||||
}
|
||||
}
|
||||
}
|
||||
Encoding::Bc1 | Encoding::Bc2 | Encoding::Bc3 => {
|
||||
let block_size = if matches!(encoding, Encoding::Bc1) { 8 } else { 16 };
|
||||
let blocks_x = w.div_ceil(4);
|
||||
for (i, block) in data.chunks_exact(block_size).enumerate() {
|
||||
let texels = match encoding {
|
||||
Encoding::Bc1 => bc1(block, true),
|
||||
Encoding::Bc2 => with_alpha(bc1(block.get(8..).unwrap_or_default(), false), bc2_alpha(block)),
|
||||
_ => with_alpha(bc1(block.get(8..).unwrap_or_default(), false), bc3_alpha(block)),
|
||||
};
|
||||
let (bx, by) = ((i % blocks_x) * 4, (i / blocks_x) * 4);
|
||||
for (t, texel) in texels.iter().enumerate() {
|
||||
let (x, y) = (bx + t % 4, by + t / 4);
|
||||
if x < w && y < h {
|
||||
let at = (y * w + x) * 4;
|
||||
if let Some(dst) = pixels.get_mut(at..at + 4) {
|
||||
dst.copy_from_slice(texel);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Image::from_u8(width, height, layout, pixels)
|
||||
}
|
||||
|
||||
/// A BC1 colour block. BC2 and BC3 colour blocks always have four colours; only BC1's
|
||||
/// `c0 <= c1` order selects three colours and transparent black.
|
||||
fn bc1(block: &[u8], one_bit_alpha: bool) -> [[u8; 4]; 16] {
|
||||
let byte = |i: usize| block.get(i).copied().unwrap_or(0);
|
||||
let (c0, c1) = (u16::from_le_bytes([byte(0), byte(1)]), u16::from_le_bytes([byte(2), byte(3)]));
|
||||
let palette = dds_bc::colour_palette(c0, c1, c0 > c1 || !one_bit_alpha);
|
||||
let indices = u32::from_le_bytes([byte(4), byte(5), byte(6), byte(7)]);
|
||||
std::array::from_fn(|t| palette[(indices >> (2 * t)) as usize & 3])
|
||||
}
|
||||
|
||||
/// BC2: four explicit bits of alpha per texel.
|
||||
fn bc2_alpha(block: &[u8]) -> [u8; 16] {
|
||||
let bits = u64::from_le_bytes(std::array::from_fn(|i| block.get(i).copied().unwrap_or(0)));
|
||||
std::array::from_fn(|t| ((bits >> (4 * t)) & 0xf) as u8 * 17)
|
||||
}
|
||||
|
||||
/// BC3: two alpha endpoints and a 3-bit index per texel into eight values, or into six plus
|
||||
/// 0 and 255 when `a0 <= a1`.
|
||||
fn bc3_alpha(block: &[u8]) -> [u8; 16] {
|
||||
let byte = |i: usize| block.get(i).copied().unwrap_or(0);
|
||||
let palette = dds_bc::alpha_palette(byte(0), byte(1));
|
||||
let bits = u64::from_le_bytes([byte(2), byte(3), byte(4), byte(5), byte(6), byte(7), 0, 0]);
|
||||
std::array::from_fn(|t| palette[((bits >> (3 * t)) & 7) as usize])
|
||||
}
|
||||
|
||||
fn with_alpha(mut texels: [[u8; 4]; 16], alpha: [u8; 16]) -> [[u8; 4]; 16] {
|
||||
for (texel, a) in texels.iter_mut().zip(alpha) {
|
||||
texel[3] = a;
|
||||
}
|
||||
texels
|
||||
}
|
||||
|
||||
const DDSD_CAPS: u32 = 0x1;
|
||||
const DDSD_HEIGHT: u32 = 0x2;
|
||||
const DDSD_WIDTH: u32 = 0x4;
|
||||
const DDSD_PITCH: u32 = 0x8;
|
||||
const DDSD_PIXELFORMAT: u32 = 0x1000;
|
||||
const DDSD_MIPMAPCOUNT: u32 = 0x2_0000;
|
||||
const DDSD_LINEARSIZE: u32 = 0x8_0000;
|
||||
const DDSCAPS_COMPLEX: u32 = 0x8;
|
||||
const DDSCAPS_TEXTURE: u32 = 0x1000;
|
||||
const DDSCAPS_MIPMAP: u32 = 0x40_0000;
|
||||
|
||||
fn encode_err(reason: impl std::fmt::Display) -> CodecError {
|
||||
CodecError::encode(Format::Dds, reason)
|
||||
}
|
||||
|
||||
/// How a written texture stores its pixels.
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum Store {
|
||||
/// 8-bit luminance.
|
||||
Luminance,
|
||||
/// 8-bit luminance, then 8-bit alpha.
|
||||
LuminanceAlpha,
|
||||
/// Blue, green, red and an unused byte (written as 255, so a reader that takes it for
|
||||
/// alpha still sees an opaque texture).
|
||||
Bgrx,
|
||||
Bgra,
|
||||
Bc1,
|
||||
Bc2,
|
||||
Bc3,
|
||||
}
|
||||
|
||||
impl Store {
|
||||
/// The storage for an image of `layout`, as [`crate::fidelity::plan`] chose it.
|
||||
fn new(compression: DdsCompression, layout: ChannelLayout) -> Result<Store, CodecError> {
|
||||
Ok(match (compression, layout) {
|
||||
(DdsCompression::None, ChannelLayout::Gray) => Store::Luminance,
|
||||
(DdsCompression::None, ChannelLayout::GrayA) => Store::LuminanceAlpha,
|
||||
(DdsCompression::None, ChannelLayout::Rgb) => Store::Bgrx,
|
||||
(DdsCompression::None, ChannelLayout::Rgba) => Store::Bgra,
|
||||
(DdsCompression::Bc1, ChannelLayout::Rgba) => Store::Bc1,
|
||||
(DdsCompression::Bc2, ChannelLayout::Rgba) => Store::Bc2,
|
||||
(DdsCompression::Bc3, ChannelLayout::Rgba) => Store::Bc3,
|
||||
(_, layout) => return Err(encode_err(format!("{layout:?} pixels can't be written as `{}`", compression.name()))),
|
||||
})
|
||||
}
|
||||
|
||||
/// Bytes per pixel, or per 4×4 block for a block compression.
|
||||
fn unit(self) -> usize {
|
||||
match self {
|
||||
Store::Luminance => 1,
|
||||
Store::LuminanceAlpha => 2,
|
||||
Store::Bgrx | Store::Bgra => 4,
|
||||
Store::Bc1 => 8,
|
||||
Store::Bc2 | Store::Bc3 => 16,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_block(self) -> bool {
|
||||
matches!(self, Store::Bc1 | Store::Bc2 | Store::Bc3)
|
||||
}
|
||||
|
||||
/// Bytes of one row of pixels (or of 4×4 blocks) of a level `width` wide.
|
||||
fn row_bytes(self, width: usize) -> Option<usize> {
|
||||
if self.is_block() { width.div_ceil(4).checked_mul(self.unit()) } else { width.checked_mul(self.unit()) }
|
||||
}
|
||||
|
||||
fn level_bytes(self, width: usize, height: usize) -> Option<usize> {
|
||||
let rows = if self.is_block() { height.div_ceil(4) } else { height };
|
||||
self.row_bytes(width)?.checked_mul(rows)
|
||||
}
|
||||
|
||||
/// DDS_PIXELFORMAT: flags, FourCC, bits per pixel and the red, green, blue and alpha masks.
|
||||
fn pixel_format(self) -> (u32, [u8; 4], u32, [u32; 4]) {
|
||||
match self {
|
||||
Store::Luminance => (DDPF_LUMINANCE, [0; 4], 8, [0xff, 0, 0, 0]),
|
||||
Store::LuminanceAlpha => (DDPF_LUMINANCE | DDPF_ALPHAPIXELS, [0; 4], 16, [0xff, 0, 0, 0xff00]),
|
||||
Store::Bgrx => (DDPF_RGB, [0; 4], 32, [0xff_0000, 0xff00, 0xff, 0]),
|
||||
Store::Bgra => (DDPF_RGB | DDPF_ALPHAPIXELS, [0; 4], 32, [0xff_0000, 0xff00, 0xff, 0xff00_0000]),
|
||||
Store::Bc1 => (DDPF_FOURCC, *b"DXT1", 0, [0; 4]),
|
||||
Store::Bc2 => (DDPF_FOURCC, *b"DXT3", 0, [0; 4]),
|
||||
Store::Bc3 => (DDPF_FOURCC, *b"DXT5", 0, [0; 4]),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Levels in a full mip chain: the larger side halves down to 1.
|
||||
fn mip_levels(width: u32, height: u32) -> u32 {
|
||||
32 - width.max(height).max(1).leading_zeros()
|
||||
}
|
||||
|
||||
fn half((w, h): (usize, usize)) -> (usize, usize) {
|
||||
((w / 2).max(1), (h / 2).max(1))
|
||||
let texture = Texture::parse(b).map_err(error)?;
|
||||
let layout = channel_layout(texture.layout());
|
||||
limits.check(texture.width(), texture.height(), layout, SampleType::U8)?;
|
||||
let pixels = texture.decode_with_limit(limits.max_alloc).map_err(error)?;
|
||||
Image::from_u8(texture.width(), texture.height(), layout, pixels)
|
||||
}
|
||||
|
||||
pub(crate) fn encode(image: &Image, plan: Plan, opts: &EncodeOptions) -> Result<Vec<u8>, CodecError> {
|
||||
let img = image.converted(plan.layout, SampleType::U8);
|
||||
let pixels = img.as_u8().ok_or_else(|| encode_err("the image was not converted to 8 bits per channel"))?;
|
||||
let store = Store::new(opts.dds.compression, img.layout())?;
|
||||
let (width, height) = img.dimensions();
|
||||
let levels = if opts.dds.mipmaps { mip_levels(width, height) } else { 1 };
|
||||
let top = (width as usize, height as usize);
|
||||
// Every level's size, checked before anything is allocated.
|
||||
let mut sizes = Vec::new();
|
||||
let mut size = top;
|
||||
for _ in 0..levels {
|
||||
sizes.push(store.level_bytes(size.0, size.1).ok_or_else(|| encode_err("texture size overflow"))?);
|
||||
size = half(size);
|
||||
}
|
||||
let total = sizes.iter().try_fold(HEADER, |total, &s| total.checked_add(s)).ok_or_else(|| encode_err("texture size overflow"))?;
|
||||
let header = header(width, height, store, levels, sizes.first().copied().unwrap_or(0))?;
|
||||
let mut out = crate::options::alloc_zeroed::<u8>(total)?;
|
||||
out.get_mut(..HEADER).ok_or_else(|| encode_err("output buffer too small"))?.copy_from_slice(&header);
|
||||
|
||||
let channels = img.layout().channels();
|
||||
let mut level = Cow::Borrowed(pixels);
|
||||
let (mut size, mut at) = (top, HEADER);
|
||||
for (i, &bytes) in sizes.iter().enumerate() {
|
||||
let dst = out.get_mut(at..at + bytes).ok_or_else(|| encode_err("output buffer too small"))?;
|
||||
write_level(store, &level, size, dst)?;
|
||||
at += bytes;
|
||||
if i + 1 < sizes.len() {
|
||||
let next = half(size);
|
||||
level = Cow::Owned(downsample(&level, size, next, channels)?);
|
||||
size = next;
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The `DDS ` signature and DDS_HEADER. `top` is the top level's size in bytes.
|
||||
fn header(width: u32, height: u32, store: Store, levels: u32, top: usize) -> Result<[u8; HEADER], CodecError> {
|
||||
let mut b = [0u8; HEADER];
|
||||
let mut put = |at: usize, v: u32| {
|
||||
if let Some(d) = b.get_mut(at..at + 4) {
|
||||
d.copy_from_slice(&v.to_le_bytes());
|
||||
}
|
||||
let pixels = img.as_u8().ok_or_else(|| CodecError::encode(Format::Dds, "the image was not converted to 8 bits per channel"))?;
|
||||
let layout = match img.layout() {
|
||||
ChannelLayout::Gray => Layout::Gray,
|
||||
ChannelLayout::GrayA => Layout::GrayA,
|
||||
ChannelLayout::Rgb => Layout::Rgb,
|
||||
ChannelLayout::Rgba => Layout::Rgba,
|
||||
// `fidelity::plan` only picks the four layouts above for DDS.
|
||||
other => return Err(CodecError::encode(Format::Dds, format!("{other:?} pixels can't be written as `{}`", opts.dds.compression.name()))),
|
||||
};
|
||||
// Uncompressed: the pitch of one row. Compressed: the whole top level (its "linear size").
|
||||
let (size_flag, pitch_or_size) = if store.is_block() { (DDSD_LINEARSIZE, Some(top)) } else { (DDSD_PITCH, store.row_bytes(width as usize)) };
|
||||
let pitch_or_size = pitch_or_size
|
||||
.and_then(|v| u32::try_from(v).ok())
|
||||
.ok_or_else(|| encode_err(format!("a {width}x{height} level is too large for a DDS header")))?;
|
||||
let mipmapped = levels > 1;
|
||||
put(4, 124);
|
||||
put(8, DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | size_flag | if mipmapped { DDSD_MIPMAPCOUNT } else { 0 });
|
||||
put(12, height);
|
||||
put(16, width);
|
||||
put(20, pitch_or_size);
|
||||
put(28, levels);
|
||||
let (flags, fourcc, bits, masks) = store.pixel_format();
|
||||
put(76, 32);
|
||||
put(80, flags);
|
||||
put(84, u32::from_le_bytes(fourcc));
|
||||
put(88, bits);
|
||||
for (i, mask) in masks.into_iter().enumerate() {
|
||||
put(92 + 4 * i, mask);
|
||||
}
|
||||
put(108, DDSCAPS_TEXTURE | if mipmapped { DDSCAPS_COMPLEX | DDSCAPS_MIPMAP } else { 0 });
|
||||
b[..4].copy_from_slice(b"DDS ");
|
||||
Ok(b)
|
||||
}
|
||||
|
||||
/// Runs `f` on each `len`-byte row of `out` with its index, in parallel on native targets.
|
||||
fn rows(out: &mut [u8], len: usize, f: impl Fn(usize, &mut [u8]) + Send + Sync) {
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
{
|
||||
use rayon::prelude::*;
|
||||
out.par_chunks_mut(len.max(1)).enumerate().for_each(|(i, row)| f(i, row));
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
for (i, row) in out.chunks_mut(len.max(1)).enumerate() {
|
||||
f(i, row);
|
||||
}
|
||||
}
|
||||
|
||||
/// Writes one level of `width` × `height` pixels (in the image's layout) into `dst`.
|
||||
fn write_level(store: Store, pixels: &[u8], (width, height): (usize, usize), dst: &mut [u8]) -> Result<(), CodecError> {
|
||||
let row_bytes = store.row_bytes(width).ok_or_else(|| encode_err("texture size overflow"))?;
|
||||
match store {
|
||||
Store::Luminance | Store::LuminanceAlpha => {
|
||||
// The image's gray (and alpha) samples, in the same order.
|
||||
let src = pixels.get(..dst.len()).ok_or_else(|| encode_err("the level is smaller than its size"))?;
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
Store::Bgrx | Store::Bgra => {
|
||||
let channels = if store == Store::Bgra { 4 } else { 3 };
|
||||
rows(dst, row_bytes, |y, row| {
|
||||
let src = pixels.get(y * width * channels..).unwrap_or_default();
|
||||
for (d, s) in row.as_chunks_mut::<4>().0.iter_mut().zip(src.chunks_exact(channels)) {
|
||||
let byte = |i: usize| s.get(i).copied().unwrap_or(255);
|
||||
*d = [byte(2), byte(1), byte(0), byte(3)];
|
||||
}
|
||||
});
|
||||
}
|
||||
Store::Bc1 | Store::Bc2 | Store::Bc3 => {
|
||||
let (texels, _) = pixels.as_chunks::<4>();
|
||||
rows(dst, row_bytes, |by, row| {
|
||||
for (bx, d) in row.chunks_exact_mut(store.unit()).enumerate() {
|
||||
let (block, inside) = gather(texels, (width, height), bx, by);
|
||||
let encoded: &[u8] = match store {
|
||||
Store::Bc1 => &dds_bc::encode_bc1(&block, inside),
|
||||
Store::Bc2 => &dds_bc::encode_bc2(&block, inside),
|
||||
_ => &dds_bc::encode_bc3(&block, inside),
|
||||
};
|
||||
for (d, s) in d.iter_mut().zip(encoded) {
|
||||
*d = *s;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Block (`bx`, `by`)'s texels, and which of them lie inside the image.
|
||||
fn gather(texels: &[[u8; 4]], (width, height): (usize, usize), bx: usize, by: usize) -> (Block, Mask) {
|
||||
let mut block = [[0u8; 4]; 16];
|
||||
let mut inside: Mask = 0;
|
||||
for (t, texel) in block.iter_mut().enumerate() {
|
||||
let (x, y) = (bx * 4 + t % 4, by * 4 + t / 4);
|
||||
if x < width
|
||||
&& y < height
|
||||
&& let Some(p) = texels.get(y * width + x)
|
||||
{
|
||||
*texel = *p;
|
||||
inside |= 1 << t;
|
||||
}
|
||||
}
|
||||
(block, inside)
|
||||
}
|
||||
|
||||
/// The next mip level: each pixel the average of the 2×2 pixels it covers, or of 2×3, 3×2 or
|
||||
/// 3×3 along the last column and row of an odd-sized level, so no pixel is dropped.
|
||||
fn downsample(src: &[u8], (w, h): (usize, usize), (nw, nh): (usize, usize), channels: usize) -> Result<Vec<u8>, CodecError> {
|
||||
let len = nw.checked_mul(nh).and_then(|n| n.checked_mul(channels)).ok_or_else(|| encode_err("mip level size overflow"))?;
|
||||
let mut dst = crate::options::alloc_zeroed::<u8>(len)?;
|
||||
let span = |i: usize, n: usize, size: usize| 2 * i..=if i + 1 == n { size.saturating_sub(1) } else { 2 * i + 1 };
|
||||
rows(&mut dst, nw * channels, |y, row| {
|
||||
let ys = span(y, nh, h);
|
||||
for (x, px) in row.chunks_exact_mut(channels.max(1)).enumerate() {
|
||||
let xs = span(x, nw, w);
|
||||
for (c, v) in px.iter_mut().enumerate() {
|
||||
let (mut sum, mut n) = (0u32, 0u32);
|
||||
for sy in ys.clone() {
|
||||
for sx in xs.clone() {
|
||||
if let Some(&s) = src.get((sy * w + sx) * channels + c) {
|
||||
sum += u32::from(s);
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
*v = ((sum + n / 2) / n.max(1)) as u8;
|
||||
}
|
||||
}
|
||||
});
|
||||
Ok(dst)
|
||||
let (width, height) = img.dimensions();
|
||||
craft_dds::encode(width, height, layout, pixels, opts.dds).map_err(error)
|
||||
}
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
use std::fmt;
|
||||
|
||||
use crate::codecs::dpx;
|
||||
use crate::codecs::{dds, dpx};
|
||||
use crate::format::{Format, caps};
|
||||
use crate::image::{ChannelLayout, Image, SampleType};
|
||||
use crate::options::{DdsCompression, EncodeOptions};
|
||||
@@ -45,7 +45,8 @@ pub enum FidelityWarning {
|
||||
ColorToGray,
|
||||
/// The image will be quantized to a 256-colour palette.
|
||||
PaletteQuantized,
|
||||
/// The format's encoder is lossy.
|
||||
/// The format's encoder is lossy. DDS BC5 also keeps only red and green: blue is dropped and
|
||||
/// reads back as 0 (for a normal map, the renderer rebuilds Z from X and Y).
|
||||
LossyCompression,
|
||||
IccDropped,
|
||||
ExifDropped,
|
||||
@@ -175,8 +176,12 @@ pub(crate) fn plan(image: &Image, format: Format, opts: &EncodeOptions) -> Plan
|
||||
},
|
||||
// CIELab has no float form: float Lab is written with 16 bits.
|
||||
Format::Tiff if layout.is_lab() && sample.is_float() => Plan { layout: pick_layout(layout, c.layouts, c.alpha), sample: SampleType::U16 },
|
||||
// A block-compressed DDS stores RGBA whatever the source; uncompressed keeps gray and RGB.
|
||||
Format::Dds if opts.dds.compression.is_block() => Plan { layout: ChannelLayout::Rgba, sample: SampleType::U8 },
|
||||
// A block-compressed DDS stores what its compression holds whatever the source: gray for
|
||||
// BC4, red and green for BC5 (written from RGB, blue dropped), RGBA for BC1 to BC3.
|
||||
// Uncompressed keeps gray and RGB.
|
||||
Format::Dds if opts.dds.compression.is_block() => {
|
||||
Plan { layout: opts.dds.compression.layout().map_or(ChannelLayout::Rgba, dds::channel_layout), sample: SampleType::U8 }
|
||||
}
|
||||
_ => Plan { layout: pick_layout(layout, c.layouts, c.alpha), sample: pick_sample(sample, c.depths) },
|
||||
}
|
||||
}
|
||||
|
||||
@@ -19,7 +19,7 @@ pub enum Format {
|
||||
Pcx,
|
||||
/// X PixMap icons (XPM2 plain text and XPM3 C-string arrays).
|
||||
Xpm,
|
||||
/// DirectDraw Surface: a 2D texture, uncompressed or BC1–BC3. Reading takes the top mip
|
||||
/// DirectDraw Surface: a 2D texture, uncompressed or BC1–BC5. Reading takes the top mip
|
||||
/// level; writing can add the full mip chain ([`crate::DdsOptions`]).
|
||||
Dds,
|
||||
Qoi,
|
||||
|
||||
@@ -235,60 +235,8 @@ impl DpxBits {
|
||||
}
|
||||
}
|
||||
|
||||
/// How a DDS texture stores its pixels.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||||
pub enum DdsCompression {
|
||||
/// Uncompressed, 8 bits per channel: BGRA (BGRX without alpha), or luminance with or
|
||||
/// without alpha for grayscale. Lossless.
|
||||
#[default]
|
||||
None,
|
||||
/// BC1 (DXT1): 4 bits per pixel. Alpha is on or off: texels under half opacity become
|
||||
/// transparent black.
|
||||
Bc1,
|
||||
/// BC2 (DXT3): 8 bits per pixel, with 4 bits of explicit alpha per texel.
|
||||
Bc2,
|
||||
/// BC3 (DXT5): 8 bits per pixel, with smooth interpolated alpha.
|
||||
Bc3,
|
||||
}
|
||||
|
||||
impl DdsCompression {
|
||||
pub const ALL: [DdsCompression; 4] = [DdsCompression::None, DdsCompression::Bc1, DdsCompression::Bc2, DdsCompression::Bc3];
|
||||
|
||||
/// The name scripts and the CLI use: `none`, `bc1`, `bc2` or `bc3`.
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
DdsCompression::None => "none",
|
||||
DdsCompression::Bc1 => "bc1",
|
||||
DdsCompression::Bc2 => "bc2",
|
||||
DdsCompression::Bc3 => "bc3",
|
||||
}
|
||||
}
|
||||
|
||||
/// [`Self::name`] back to a compression, also taking the DXT names (`dxt1`, `dxt3`,
|
||||
/// `dxt5`), in any case. Anything else is `None`.
|
||||
pub fn from_name(name: &str) -> Option<Self> {
|
||||
match name.to_ascii_lowercase().as_str() {
|
||||
"none" => Some(DdsCompression::None),
|
||||
"bc1" | "dxt1" => Some(DdsCompression::Bc1),
|
||||
"bc2" | "dxt3" => Some(DdsCompression::Bc2),
|
||||
"bc3" | "dxt5" => Some(DdsCompression::Bc3),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// A block compression (lossy), not uncompressed pixels.
|
||||
pub fn is_block(self) -> bool {
|
||||
self != DdsCompression::None
|
||||
}
|
||||
}
|
||||
|
||||
/// What a DDS file is written with.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||||
pub struct DdsOptions {
|
||||
pub compression: DdsCompression,
|
||||
/// Write the full mip chain down to 1×1, each level a box filter of the one above.
|
||||
pub mipmaps: bool,
|
||||
}
|
||||
/// How a DDS texture stores its pixels and whether it carries a mip chain, from [`craft_dds`].
|
||||
pub use craft_dds::{DdsCompression, DdsOptions};
|
||||
|
||||
/// The longer side, in pixels, at which a TIFF image pyramid stops: the last level written is
|
||||
/// the first one no longer than this ([`EncodeOptions::tiff_pyramid`]).
|
||||
|
||||
@@ -318,10 +318,112 @@ fn refuses_cubemaps_arrays_and_volumes() {
|
||||
unsupported(&dx10(4, 4, 71, 3, 0, 6), "array");
|
||||
unsupported(&dx10(4, 4, 71, 4, 0, 1), "2D");
|
||||
unsupported(&dx10(4, 4, 98, 3, 0, 1), "98"); // BC7_UNORM
|
||||
unsupported(&compressed(4, 4, b"ATI2"), "ATI2");
|
||||
unsupported(&compressed(4, 4, b"ATI3"), "ATI3");
|
||||
unsupported(&compressed(4, 4, b"DXT2"), "premultiplied");
|
||||
}
|
||||
|
||||
/// A BC4 block of 200 everywhere (eight-value mode, a0 = 200 > a1 = 50, every index 0).
|
||||
const BC4_200: [u8; 8] = [0xc8, 0x32, 0, 0, 0, 0, 0, 0];
|
||||
/// A value block of 250 everywhere (six-value mode, a0 = 10 <= a1 = 250, every index 1).
|
||||
const VALUES_250: [u8; 8] = [0x0a, 0xfa, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24];
|
||||
|
||||
/// A DX10 file of one 1x1 level of `dxgi` with DDS_ALPHA_MODE `alpha_mode` (miscFlags2) and zeroed pixel data.
|
||||
fn dx10_alpha_mode(dxgi: u32, alpha_mode: u32) -> Vec<u8> {
|
||||
let mut b = dx10(1, 1, dxgi, 3, 0, 1);
|
||||
let n = b.len();
|
||||
b[n - 4..].copy_from_slice(&alpha_mode.to_le_bytes());
|
||||
b.extend([0u8; 16]);
|
||||
b
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_premultiplied_alpha_dx10_textures() {
|
||||
// RGBA, BGRA (typeless, UNORM, sRGB) and BC2/BC3: alpha mode 2 is premultiplied, like DXT2/DXT4.
|
||||
for dxgi in [27, 28, 29, 87, 90, 91, 73, 74, 75, 76, 77, 78] {
|
||||
match decode_as(Format::Dds, &dx10_alpha_mode(dxgi, 2)) {
|
||||
Err(CodecError::Unsupported { reason, .. }) => assert!(reason.contains("premultiplied"), "{dxgi}: {reason}"),
|
||||
other => panic!("DXGI {dxgi}: {:?}", other.map(|_| ())),
|
||||
}
|
||||
}
|
||||
// Straight, unknown, opaque and custom alpha modes, and formats without alpha, still decode.
|
||||
for dxgi in [28, 87, 74, 77] {
|
||||
for mode in [0, 1, 3, 4] {
|
||||
assert!(decode_as(Format::Dds, &dx10_alpha_mode(dxgi, mode)).is_ok(), "{dxgi} mode {mode}");
|
||||
}
|
||||
}
|
||||
for dxgi in [88, 71, 80, 83] {
|
||||
assert!(decode_as(Format::Dds, &dx10_alpha_mode(dxgi, 2)).is_ok(), "{dxgi}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decodes_bc4_as_gray_from_every_name() {
|
||||
// 5×3: two blocks across, one down; the second block's texels outside the image are dropped.
|
||||
let blocks = [BC4_200, BC4_200].concat();
|
||||
let mut files = vec![];
|
||||
for fourcc in [b"ATI1", b"BC4U"] {
|
||||
let mut b = compressed(5, 3, fourcc);
|
||||
b.extend(&blocks);
|
||||
files.push((String::from_utf8_lossy(fourcc).into_owned(), b));
|
||||
}
|
||||
for dxgi in [79, 80] {
|
||||
let mut b = dx10(5, 3, dxgi, 3, 0, 1); // BC4_TYPELESS, BC4_UNORM
|
||||
b.extend(&blocks);
|
||||
files.push((format!("DXGI {dxgi}"), b));
|
||||
}
|
||||
for (name, b) in files {
|
||||
let im = decode(&b).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
assert_eq!((im.dimensions(), im.layout()), ((5, 3), ChannelLayout::Gray), "{name}");
|
||||
assert_eq!(im.data(), &[200; 15], "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn decodes_bc5_as_red_and_green_with_blue_zero() {
|
||||
let block = [BC4_200, VALUES_250].concat();
|
||||
let mut files = vec![];
|
||||
// ATI2 is BC5 as Microsoft reads it: red in the first block, not swapped as FFmpeg does.
|
||||
for fourcc in [b"ATI2", b"BC5U"] {
|
||||
let mut b = compressed(3, 2, fourcc);
|
||||
b.extend(&block);
|
||||
files.push((String::from_utf8_lossy(fourcc).into_owned(), b));
|
||||
}
|
||||
// BC5_TYPELESS (what Pillow writes) and BC5_UNORM.
|
||||
for dxgi in [82, 83] {
|
||||
let mut b = dx10(3, 2, dxgi, 3, 0, 1);
|
||||
b.extend(&block);
|
||||
files.push((format!("DXGI {dxgi}"), b));
|
||||
}
|
||||
for (name, b) in files {
|
||||
let im = decode(&b).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
assert_eq!((im.dimensions(), im.layout()), ((3, 2), ChannelLayout::Rgb), "{name}");
|
||||
assert!(im.data().chunks(3).all(|p| p == [200, 250, 0]), "{name}: {:?}", &im.data()[..3]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_signed_bc4_and_bc5() {
|
||||
for mut b in [compressed(4, 4, b"BC4S"), compressed(4, 4, b"BC5S"), dx10(4, 4, 81, 3, 0, 1), dx10(4, 4, 84, 3, 0, 1)] {
|
||||
b.extend([0; 16]);
|
||||
match decode_as(Format::Dds, &b) {
|
||||
Err(CodecError::Unsupported { reason, .. }) => assert!(reason.contains("SNORM"), "{reason}"),
|
||||
other => panic!("{other:?}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn truncated_bc4_and_bc5_data_is_refused() {
|
||||
let mut b = dx10(5, 5, 83, 3, 0, 1); // four 16-byte blocks
|
||||
b.extend([0x5a; 64]);
|
||||
assert!(decode(&b).is_ok());
|
||||
assert!(matches!(decode_as(Format::Dds, &b[..b.len() - 1]), Err(CodecError::Malformed { .. })));
|
||||
let mut b = compressed(5, 5, b"ATI1"); // four 8-byte blocks
|
||||
b.extend([0x5a; 32]);
|
||||
assert!(decode(&b).is_ok());
|
||||
assert!(matches!(decode_as(Format::Dds, &b[..b.len() - 1]), Err(CodecError::Malformed { .. })));
|
||||
}
|
||||
|
||||
/// Face declarations matter even when the general cube flag is absent; padding does not.
|
||||
#[test]
|
||||
fn source_probe_distinguishes_extra_faces_from_single_images_and_padding() {
|
||||
|
||||
@@ -0,0 +1,520 @@
|
||||
//! Byte-for-byte oracle for the DDS reader and writer: SHA-256 digests of what the writer makes
|
||||
//! for uncompressed, BC1, BC2 and BC3 textures, with and without mip chains, from deterministic
|
||||
//! synthetic images, and of what the reader decodes from those files and from hand-built files
|
||||
//! in the other stored layouts. The digests were taken from the code before the block encoder and
|
||||
//! decoder were sped up; any change to them is a change of output.
|
||||
//!
|
||||
//! On a mismatch the test prints every digest it computed in the form of [`PINNED`], so a new
|
||||
//! table can be pasted in once a change of output is intended.
|
||||
|
||||
use craft_image_codecs::{ChannelLayout, DdsCompression, DdsOptions, EncodeOptions, Format, Image, decode, encode};
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
/// `(case, SHA-256)`, taken from the code before the speed-ups.
|
||||
const PINNED: &[(&str, &str)] = &[
|
||||
("Rgba-517x389-none-mips0-encode", "e2aee5dcc86cc36e9735cb75e61852324210960092bfb2f2aec6cee9ba54ad16"),
|
||||
("Rgba-517x389-none-mips0-decode", "e0d9e319f260fa29481495313cfa8c3d224a27ad311e7aabd32f7cda8dfb81d2"),
|
||||
("Rgba-517x389-none-mips1-encode", "7611e8174d32962c9643e8f3208b8f30eba2cb85cfe16538c4321e419f3a98ce"),
|
||||
("Rgba-517x389-none-mips1-decode", "e0d9e319f260fa29481495313cfa8c3d224a27ad311e7aabd32f7cda8dfb81d2"),
|
||||
("Rgba-517x389-bc1-mips0-encode", "b6883d729a1eebbdc96176c9264754378d4f7f6bc19d355a12419c0ccfd3ac2a"),
|
||||
("Rgba-517x389-bc1-mips0-decode", "e23704d5f72ba4f2c63d815d5bff3d4c79433fa38122e1e21f1003fa1b12476a"),
|
||||
("Rgba-517x389-bc1-mips1-encode", "554ed42ba6b7c206f779324670629538d8ce12d85ef495ad36954aae2b952917"),
|
||||
("Rgba-517x389-bc1-mips1-decode", "e23704d5f72ba4f2c63d815d5bff3d4c79433fa38122e1e21f1003fa1b12476a"),
|
||||
("Rgba-517x389-bc2-mips0-encode", "473f389b464d2f74b05d44ab2d8c31d4d4cd64648d389e4fe27c27491003821b"),
|
||||
("Rgba-517x389-bc2-mips0-decode", "9d81c15d7f5f0dbc897063726fac6e2f3863818346e1c878326c22ed332ae328"),
|
||||
("Rgba-517x389-bc2-mips1-encode", "1eb8c1a73cb4e6965c60a5ca4322fb66f071cad7439d97d77dbea1a46231724a"),
|
||||
("Rgba-517x389-bc2-mips1-decode", "9d81c15d7f5f0dbc897063726fac6e2f3863818346e1c878326c22ed332ae328"),
|
||||
("Rgba-517x389-bc3-mips0-encode", "0b133915d5ac0376f8b4425cb2dd4a1ace609cf7c1d635be0ff46a37529363e2"),
|
||||
("Rgba-517x389-bc3-mips0-decode", "9c5aeecab34af4c04dd603cf5c379060e6615c07df05ae4e93058bca13a61bc9"),
|
||||
("Rgba-517x389-bc3-mips1-encode", "130e5657e870ee5c03bcfcc2c5e2befbc8a67fc0df1b7e7b71dbb67cc3f0b5e7"),
|
||||
("Rgba-517x389-bc3-mips1-decode", "9c5aeecab34af4c04dd603cf5c379060e6615c07df05ae4e93058bca13a61bc9"),
|
||||
("Rgb-517x389-none-mips0-encode", "6df9ec01a5ae0a8e0fe3b563a7ff670477446682cadd21c24ca5e0cff2b41ed8"),
|
||||
("Rgb-517x389-none-mips0-decode", "7f181edc81e2e38d56c2ed5c81edf480d52caa746e0bef90f0070e171ead89d1"),
|
||||
("Rgb-517x389-none-mips1-encode", "5a48af2cfa7d48455fe49105fc5d0173c6f4fd8187483af923f0af2fbf0af9ef"),
|
||||
("Rgb-517x389-none-mips1-decode", "7f181edc81e2e38d56c2ed5c81edf480d52caa746e0bef90f0070e171ead89d1"),
|
||||
("Rgb-517x389-bc1-mips0-encode", "1e8bf3d0ba485d0892ce771698868bf7029d2c4e63057f327ae3ab39bc57cd4a"),
|
||||
("Rgb-517x389-bc1-mips0-decode", "96feb4a7a3b7416ebc0d5e42271a9d6304131e6cbed25f745d3eef6a40279f8d"),
|
||||
("Rgb-517x389-bc1-mips1-encode", "76f866a8bbb0b3cad335c604cba97d173d01dcbfff4c8930a1d8af7c60924494"),
|
||||
("Rgb-517x389-bc1-mips1-decode", "96feb4a7a3b7416ebc0d5e42271a9d6304131e6cbed25f745d3eef6a40279f8d"),
|
||||
("Rgb-517x389-bc2-mips0-encode", "a8eaab96cf9c6f7926526069ed71f5df8c7f7d43f3ef40a85f1403639c09ac97"),
|
||||
("Rgb-517x389-bc2-mips0-decode", "8e00407a44922477b8d7c05b371f05c18ac3471095990b44aba438bf39db57b2"),
|
||||
("Rgb-517x389-bc2-mips1-encode", "d6fee09087b9a4c9a055051e7aa212a9a0a3b2660e1dfa49697c6fc9754a9aae"),
|
||||
("Rgb-517x389-bc2-mips1-decode", "8e00407a44922477b8d7c05b371f05c18ac3471095990b44aba438bf39db57b2"),
|
||||
("Rgb-517x389-bc3-mips0-encode", "2e177ad42c89f6662ebf2b834b691e10bfaea32a565b740e1bd48c7e4b39cb68"),
|
||||
("Rgb-517x389-bc3-mips0-decode", "8e00407a44922477b8d7c05b371f05c18ac3471095990b44aba438bf39db57b2"),
|
||||
("Rgb-517x389-bc3-mips1-encode", "0b53960adcf0844b47ed5927862901c95fb632af4e85cd94b5ceae59eccd78cd"),
|
||||
("Rgb-517x389-bc3-mips1-decode", "8e00407a44922477b8d7c05b371f05c18ac3471095990b44aba438bf39db57b2"),
|
||||
("GrayA-517x389-none-mips0-encode", "3f8e56201cb76990b3e25b62631666ac113a5340877acd57cdcb1c229127d3f4"),
|
||||
("GrayA-517x389-none-mips0-decode", "43503ba84a7d7579b1ebbe6ba522146f5e63f0116f8dd0eba095364cfba37c5d"),
|
||||
("GrayA-517x389-none-mips1-encode", "6282214743c82e3f74f2347c859ecfd79447cfbc87a2016a238e714f2d150b87"),
|
||||
("GrayA-517x389-none-mips1-decode", "43503ba84a7d7579b1ebbe6ba522146f5e63f0116f8dd0eba095364cfba37c5d"),
|
||||
("GrayA-517x389-bc1-mips0-encode", "32d7065b40986561349f0d76db148b1b62afedb1ce8be6a4e0b209c60c9d861f"),
|
||||
("GrayA-517x389-bc1-mips0-decode", "1cc1cbd355033b5674cc1000b879d4dc8cbb4b53b8dd38d90d8b439550e2be7c"),
|
||||
("GrayA-517x389-bc1-mips1-encode", "4b5e5c9db8ec9847b55e0c51b2e1c1cb41bb277517ef5a7bf59ace7581a7696a"),
|
||||
("GrayA-517x389-bc1-mips1-decode", "1cc1cbd355033b5674cc1000b879d4dc8cbb4b53b8dd38d90d8b439550e2be7c"),
|
||||
("GrayA-517x389-bc2-mips0-encode", "91fd37653f090668328d8feff0407c5998ef2ab96d220bd49e311faf7d768e00"),
|
||||
("GrayA-517x389-bc2-mips0-decode", "ac73339602e5062f78cf76694bde0a4ca538b355170eb424f0bd1cf7d2c12096"),
|
||||
("GrayA-517x389-bc2-mips1-encode", "05d77863968b0086ddf4a1c21ccbc8e1f2d9638ed4dffd114107a1d793ea3311"),
|
||||
("GrayA-517x389-bc2-mips1-decode", "ac73339602e5062f78cf76694bde0a4ca538b355170eb424f0bd1cf7d2c12096"),
|
||||
("GrayA-517x389-bc3-mips0-encode", "bb4057b77e0fa2959d6e79b77ff67090c9dd4d08f3c105b57ebbaea214ffc8c7"),
|
||||
("GrayA-517x389-bc3-mips0-decode", "fdcbd158c32404d09cf1ee38005b2870882e620bcd67c77332d492d07099d665"),
|
||||
("GrayA-517x389-bc3-mips1-encode", "65b2021ea2a385b349d2a6f3a44305e3655f35f3bee39fba5d177bb8c7a5d66a"),
|
||||
("GrayA-517x389-bc3-mips1-decode", "fdcbd158c32404d09cf1ee38005b2870882e620bcd67c77332d492d07099d665"),
|
||||
("Gray-517x389-none-mips0-encode", "fc6cf28e9220780d752ac3be0c9b9bf75412dbea4a54ab603577f78000f235d3"),
|
||||
("Gray-517x389-none-mips0-decode", "13df79103435da32999dff6deac57b02a872aef3fe7dafe580625a554258db30"),
|
||||
("Gray-517x389-none-mips1-encode", "e6f1bb2eb28353a1ead1b72e6e0c78f9490f9e933ee2fe464044ba2804d0a595"),
|
||||
("Gray-517x389-none-mips1-decode", "13df79103435da32999dff6deac57b02a872aef3fe7dafe580625a554258db30"),
|
||||
("Gray-517x389-bc1-mips0-encode", "ba3b1a2567ff1571dfb855b7c5ff8e2da276eb80f5f97db0fae661449bb51822"),
|
||||
("Gray-517x389-bc1-mips0-decode", "7df1ebd46f395e515af2763a0bf7189072a64f20ff811973098ea109df1ed832"),
|
||||
("Gray-517x389-bc1-mips1-encode", "e34896e52b393aa3035e641b43881df1a25ae4aa6261c9bdca34889ec42ea6ac"),
|
||||
("Gray-517x389-bc1-mips1-decode", "7df1ebd46f395e515af2763a0bf7189072a64f20ff811973098ea109df1ed832"),
|
||||
("Gray-517x389-bc2-mips0-encode", "2ebe06ad3ca05dc993a60c58dbae1d36c56516147176b4799648f534e9318b3a"),
|
||||
("Gray-517x389-bc2-mips0-decode", "2adde466f9a4c2c4905d50490bbed4cd5c4de0e3b951d63028702f7ab51d7927"),
|
||||
("Gray-517x389-bc2-mips1-encode", "8730c500b41e9b628cab1c789b2e2a2e4a4ad0350b6c3faaca5e3acd8b423ca7"),
|
||||
("Gray-517x389-bc2-mips1-decode", "2adde466f9a4c2c4905d50490bbed4cd5c4de0e3b951d63028702f7ab51d7927"),
|
||||
("Gray-517x389-bc3-mips0-encode", "e8b62246e29504bbbc92f1c5344846577232e2c12f5c6ab6fae68199bbcf5c3a"),
|
||||
("Gray-517x389-bc3-mips0-decode", "2adde466f9a4c2c4905d50490bbed4cd5c4de0e3b951d63028702f7ab51d7927"),
|
||||
("Gray-517x389-bc3-mips1-encode", "2b1122c5091c8a62c897fa4a133b2a21d19ec14a3ec2c5e0d4855570824e6211"),
|
||||
("Gray-517x389-bc3-mips1-decode", "2adde466f9a4c2c4905d50490bbed4cd5c4de0e3b951d63028702f7ab51d7927"),
|
||||
("Rgba-1x1-none-mips0-encode", "c059322936202ed846ae95243325c1756b3ca2734a310b9b58e957e7f6ecb65c"),
|
||||
("Rgba-1x1-none-mips0-decode", "ac6d8249b868a4df487ad3d4bc2bffa4ec32afed5bb89bcb916dc390872c00a4"),
|
||||
("Rgba-1x1-none-mips1-encode", "c059322936202ed846ae95243325c1756b3ca2734a310b9b58e957e7f6ecb65c"),
|
||||
("Rgba-1x1-none-mips1-decode", "ac6d8249b868a4df487ad3d4bc2bffa4ec32afed5bb89bcb916dc390872c00a4"),
|
||||
("Rgba-1x1-bc1-mips0-encode", "b128a04da98b6d855fd98c6908f9ba47d0acf2e79c1b39d0cf3e5787ee52b23c"),
|
||||
("Rgba-1x1-bc1-mips0-decode", "2c1567f9329e7d7046ebcba26c8b66a872a36d2140c47be6d8ee3fd1bdc7aa26"),
|
||||
("Rgba-1x1-bc1-mips1-encode", "b128a04da98b6d855fd98c6908f9ba47d0acf2e79c1b39d0cf3e5787ee52b23c"),
|
||||
("Rgba-1x1-bc1-mips1-decode", "2c1567f9329e7d7046ebcba26c8b66a872a36d2140c47be6d8ee3fd1bdc7aa26"),
|
||||
("Rgba-1x1-bc2-mips0-encode", "d53707f0da90291d459df619c204c09d0e5537b96055b7c5a7eebb164965a30c"),
|
||||
("Rgba-1x1-bc2-mips0-decode", "e41eb1f8866a8a844c5627ec9e119ea9b5b2c2afb62c2cc40d0b3463e191181f"),
|
||||
("Rgba-1x1-bc2-mips1-encode", "d53707f0da90291d459df619c204c09d0e5537b96055b7c5a7eebb164965a30c"),
|
||||
("Rgba-1x1-bc2-mips1-decode", "e41eb1f8866a8a844c5627ec9e119ea9b5b2c2afb62c2cc40d0b3463e191181f"),
|
||||
("Rgba-1x1-bc3-mips0-encode", "b7a5261aeaa590ee27d74e1ec40688cebfd95a8b32bad510dcf4889659bced99"),
|
||||
("Rgba-1x1-bc3-mips0-decode", "ac6d8249b868a4df487ad3d4bc2bffa4ec32afed5bb89bcb916dc390872c00a4"),
|
||||
("Rgba-1x1-bc3-mips1-encode", "b7a5261aeaa590ee27d74e1ec40688cebfd95a8b32bad510dcf4889659bced99"),
|
||||
("Rgba-1x1-bc3-mips1-decode", "ac6d8249b868a4df487ad3d4bc2bffa4ec32afed5bb89bcb916dc390872c00a4"),
|
||||
("Gray-1x1-none-mips0-encode", "9acce63d02641780f46268c15cb62bdf84b68edc091801d02f62d8840b90e76f"),
|
||||
("Gray-1x1-none-mips0-decode", "5ef973abd913579530066461f86da91115474c93b5a6cf1b73327feeb3650b83"),
|
||||
("Gray-1x1-none-mips1-encode", "9acce63d02641780f46268c15cb62bdf84b68edc091801d02f62d8840b90e76f"),
|
||||
("Gray-1x1-none-mips1-decode", "5ef973abd913579530066461f86da91115474c93b5a6cf1b73327feeb3650b83"),
|
||||
("Gray-1x1-bc1-mips0-encode", "ffec653603d347468446a15fe4101fda9cb34efb48dc69a8d0f403ce2e2fd9d7"),
|
||||
("Gray-1x1-bc1-mips0-decode", "bf04357a38e992a2513e373d00f664b687669a14e1405a2d1b95fb0de6e9a89b"),
|
||||
("Gray-1x1-bc1-mips1-encode", "ffec653603d347468446a15fe4101fda9cb34efb48dc69a8d0f403ce2e2fd9d7"),
|
||||
("Gray-1x1-bc1-mips1-decode", "bf04357a38e992a2513e373d00f664b687669a14e1405a2d1b95fb0de6e9a89b"),
|
||||
("Gray-1x1-bc2-mips0-encode", "3c36aac2c17a7aad99b2c1fa0f4e5b256a9b4421c38406f61961b09c64290178"),
|
||||
("Gray-1x1-bc2-mips0-decode", "bf04357a38e992a2513e373d00f664b687669a14e1405a2d1b95fb0de6e9a89b"),
|
||||
("Gray-1x1-bc2-mips1-encode", "3c36aac2c17a7aad99b2c1fa0f4e5b256a9b4421c38406f61961b09c64290178"),
|
||||
("Gray-1x1-bc2-mips1-decode", "bf04357a38e992a2513e373d00f664b687669a14e1405a2d1b95fb0de6e9a89b"),
|
||||
("Gray-1x1-bc3-mips0-encode", "73704fca801476ab72bf69b80a395de711e9a3fa4f476ce5481ae3858f844922"),
|
||||
("Gray-1x1-bc3-mips0-decode", "bf04357a38e992a2513e373d00f664b687669a14e1405a2d1b95fb0de6e9a89b"),
|
||||
("Gray-1x1-bc3-mips1-encode", "73704fca801476ab72bf69b80a395de711e9a3fa4f476ce5481ae3858f844922"),
|
||||
("Gray-1x1-bc3-mips1-decode", "bf04357a38e992a2513e373d00f664b687669a14e1405a2d1b95fb0de6e9a89b"),
|
||||
("Rgba-2x3-none-mips0-encode", "1f641b8e1cc01924b0d1a06d2d81ad22c759b44a4f640a83ba6339446e13fc6c"),
|
||||
("Rgba-2x3-none-mips0-decode", "af815e7ba5ce6369171335ae94e553524db701f94d152b903f220ee64b9373a6"),
|
||||
("Rgba-2x3-none-mips1-encode", "9be390b308b0961125828ca53894a87101983eafaf54e3c7e3da7b1f992fb518"),
|
||||
("Rgba-2x3-none-mips1-decode", "af815e7ba5ce6369171335ae94e553524db701f94d152b903f220ee64b9373a6"),
|
||||
("Rgba-2x3-bc1-mips0-encode", "743a3d25313924d68732ab399ed92c8e3f693ef26a415a12532918b80db085c4"),
|
||||
("Rgba-2x3-bc1-mips0-decode", "570f9feaf2d322a568b2a87ca652aa0606ff96cde281e24d247d071a9dc4e827"),
|
||||
("Rgba-2x3-bc1-mips1-encode", "711b0088c7c8083760921c3620d9d1adc02d47b5c3b0eb9e674d974fd1d6d641"),
|
||||
("Rgba-2x3-bc1-mips1-decode", "570f9feaf2d322a568b2a87ca652aa0606ff96cde281e24d247d071a9dc4e827"),
|
||||
("Rgba-2x3-bc2-mips0-encode", "b4facaf715dd8208fe02961fb99584b58c219117a99f2b1d15d10a556a9e5251"),
|
||||
("Rgba-2x3-bc2-mips0-decode", "66112c3066ef59936784fa938c26eb0e86772da586442237de5336c48558afbe"),
|
||||
("Rgba-2x3-bc2-mips1-encode", "cad117a2ddd6fe91876efd1dd0b80da0b393f3af21209efc3c1b0f165606a129"),
|
||||
("Rgba-2x3-bc2-mips1-decode", "66112c3066ef59936784fa938c26eb0e86772da586442237de5336c48558afbe"),
|
||||
("Rgba-2x3-bc3-mips0-encode", "b68ced41c6b33037f08b74c492da5688e9d80555c5843f9f323a74d7c86e114e"),
|
||||
("Rgba-2x3-bc3-mips0-decode", "051b60ea47094987d71180aeaa00b3f1b5427429e54812ea28b40f8e945044c8"),
|
||||
("Rgba-2x3-bc3-mips1-encode", "88e0fd6d04c896880d03731d6df1528f22290c1738b303eb2b09fe84d7882a64"),
|
||||
("Rgba-2x3-bc3-mips1-decode", "051b60ea47094987d71180aeaa00b3f1b5427429e54812ea28b40f8e945044c8"),
|
||||
("Gray-2x3-none-mips0-encode", "7e9d26894ca9a800b93f5dae0e5b58b18a6cbcaea56eacc657aba40a1933c476"),
|
||||
("Gray-2x3-none-mips0-decode", "d21c9cddccb970575eba36093410245f0a0fb15049fc96311874191f868de0d5"),
|
||||
("Gray-2x3-none-mips1-encode", "d2ee41ea49462e1d7be568cfcbf867c6395646710ba321c2dac9db319294bb5e"),
|
||||
("Gray-2x3-none-mips1-decode", "d21c9cddccb970575eba36093410245f0a0fb15049fc96311874191f868de0d5"),
|
||||
("Gray-2x3-bc1-mips0-encode", "000d5d9121042f7b88411d8e08a548a2c804b8b4b73b40bf317cff61899a5445"),
|
||||
("Gray-2x3-bc1-mips0-decode", "1a8f46dd535383398fbeebe5fdfca9bb256fa3b3a7b8552af34b67b09865e89d"),
|
||||
("Gray-2x3-bc1-mips1-encode", "07346ec09eb8d9b489e7dd50bd73851342205594ac985544bfe58b6bda73b21b"),
|
||||
("Gray-2x3-bc1-mips1-decode", "1a8f46dd535383398fbeebe5fdfca9bb256fa3b3a7b8552af34b67b09865e89d"),
|
||||
("Gray-2x3-bc2-mips0-encode", "5db43dcd4adec962a7a12c6f8da8bf05d3dc2e3d608ca3fa341e36b43c218c3d"),
|
||||
("Gray-2x3-bc2-mips0-decode", "afabd75898a95baac868e9e14905c2d89e90767750217e4c9ac84b1caeef41bc"),
|
||||
("Gray-2x3-bc2-mips1-encode", "3effae05c47854dfb5f20ed12e2c1588236464f17fbf5dd13e61958e5097a796"),
|
||||
("Gray-2x3-bc2-mips1-decode", "afabd75898a95baac868e9e14905c2d89e90767750217e4c9ac84b1caeef41bc"),
|
||||
("Gray-2x3-bc3-mips0-encode", "11c48dce5b7545cf3eafd1f01fc6b977b13cb7c7e8f2ef7ea1406a8f04b86cf9"),
|
||||
("Gray-2x3-bc3-mips0-decode", "afabd75898a95baac868e9e14905c2d89e90767750217e4c9ac84b1caeef41bc"),
|
||||
("Gray-2x3-bc3-mips1-encode", "6b7540afc583554e70f4131b4a0d8648eed65100293ab9b7060afcbd33751e64"),
|
||||
("Gray-2x3-bc3-mips1-decode", "afabd75898a95baac868e9e14905c2d89e90767750217e4c9ac84b1caeef41bc"),
|
||||
("Rgba-3x2-none-mips0-encode", "e821c1620e4e53588908268da45702924911ed756f3257cb0a21727748b736a6"),
|
||||
("Rgba-3x2-none-mips0-decode", "d4583449852070512fa3cb16c5132834ccee2f9dd3a6c0d6c8fa5bbbc2935e8d"),
|
||||
("Rgba-3x2-none-mips1-encode", "f79a699612ef8d8347a5e83af2fd9ee915eda35388bc86b4243b265f988fc3d8"),
|
||||
("Rgba-3x2-none-mips1-decode", "d4583449852070512fa3cb16c5132834ccee2f9dd3a6c0d6c8fa5bbbc2935e8d"),
|
||||
("Rgba-3x2-bc1-mips0-encode", "1c106b532f6afc132538b2bb2c1eb9e6bb075a448d19b6af2c67b4c31415e3b2"),
|
||||
("Rgba-3x2-bc1-mips0-decode", "f0e63ce55598b6c58c601a5cf3415522113181a08bc28f4d8cd499d160352cdd"),
|
||||
("Rgba-3x2-bc1-mips1-encode", "23d86eba138f7c4492f9955dd0a29eb1a675d69f1e612b54e783837d9414cb14"),
|
||||
("Rgba-3x2-bc1-mips1-decode", "f0e63ce55598b6c58c601a5cf3415522113181a08bc28f4d8cd499d160352cdd"),
|
||||
("Rgba-3x2-bc2-mips0-encode", "74a68d7b1cc0173f1e8a6e0f6101ffa010757df0434fcf5636db808ca20b341e"),
|
||||
("Rgba-3x2-bc2-mips0-decode", "bc63bba15c1bbe19cdef66535870c7dfeeae26a4686557e1530ae64a2b2253a5"),
|
||||
("Rgba-3x2-bc2-mips1-encode", "d28d7a4a7ee17d0f58f27ebef8d682a7fed42778a60e09186af523198a2f3562"),
|
||||
("Rgba-3x2-bc2-mips1-decode", "bc63bba15c1bbe19cdef66535870c7dfeeae26a4686557e1530ae64a2b2253a5"),
|
||||
("Rgba-3x2-bc3-mips0-encode", "fa0a02ba9822a007f1654d618b5225332f3934e5f07c51f8ca474e26658e2c45"),
|
||||
("Rgba-3x2-bc3-mips0-decode", "ee0221751e1d96bf76552df65a7e54d7711f834cf0431fd17a3a6542473b4ceb"),
|
||||
("Rgba-3x2-bc3-mips1-encode", "3a3c51f596a82ae666c6157da4266c3330e8e2e0744947e0ce663deb66e67ad6"),
|
||||
("Rgba-3x2-bc3-mips1-decode", "ee0221751e1d96bf76552df65a7e54d7711f834cf0431fd17a3a6542473b4ceb"),
|
||||
("Gray-3x2-none-mips0-encode", "6e1e49ee238e40108f1e934946b0d2498eb97f6824a82d4d71011759a58b83a4"),
|
||||
("Gray-3x2-none-mips0-decode", "e333fde639747f66aa4d74dbeae648566d6735ecc47de220e07b9da351e1bf37"),
|
||||
("Gray-3x2-none-mips1-encode", "906e16afa18db0290bec758a1a124de7a99255871344d462f797db54dbd30b4b"),
|
||||
("Gray-3x2-none-mips1-decode", "e333fde639747f66aa4d74dbeae648566d6735ecc47de220e07b9da351e1bf37"),
|
||||
("Gray-3x2-bc1-mips0-encode", "df204b170cd24f0375772d65b4f0548a824a4602c453cf891c9cc4aafc4b32ad"),
|
||||
("Gray-3x2-bc1-mips0-decode", "869a8202b3721a8d2bf232e75e9a91a271cf2ebad85c8df6a5260cb9c9b6b1ab"),
|
||||
("Gray-3x2-bc1-mips1-encode", "d06f38b5c40156888fe2ea04343f46d4753a80f83f63d80b3fd7ce82c5d7fe94"),
|
||||
("Gray-3x2-bc1-mips1-decode", "869a8202b3721a8d2bf232e75e9a91a271cf2ebad85c8df6a5260cb9c9b6b1ab"),
|
||||
("Gray-3x2-bc2-mips0-encode", "1832e5006137ae1583d34ba1bfab9c7b85f55791996f7cdf21ed799f3939c4f4"),
|
||||
("Gray-3x2-bc2-mips0-decode", "869a8202b3721a8d2bf232e75e9a91a271cf2ebad85c8df6a5260cb9c9b6b1ab"),
|
||||
("Gray-3x2-bc2-mips1-encode", "41d49c9cce6cbbdf1676033a9233ed774f339d92e8159d1d1b0cbc8503cfe72b"),
|
||||
("Gray-3x2-bc2-mips1-decode", "869a8202b3721a8d2bf232e75e9a91a271cf2ebad85c8df6a5260cb9c9b6b1ab"),
|
||||
("Gray-3x2-bc3-mips0-encode", "377e3d02919641d634bbe02cadb513237fcd90f540b8769c5e2a214d5ccf05e4"),
|
||||
("Gray-3x2-bc3-mips0-decode", "869a8202b3721a8d2bf232e75e9a91a271cf2ebad85c8df6a5260cb9c9b6b1ab"),
|
||||
("Gray-3x2-bc3-mips1-encode", "70b03c1901946a24abf34c60dd7bd9cc124df43a251a82622c15d56b0e2b2588"),
|
||||
("Gray-3x2-bc3-mips1-decode", "869a8202b3721a8d2bf232e75e9a91a271cf2ebad85c8df6a5260cb9c9b6b1ab"),
|
||||
("Rgba-5x5-none-mips0-encode", "be7677f4c86d5f3c0ba75ec04d36bcfd708bca44c9f6720c4b7494c290014491"),
|
||||
("Rgba-5x5-none-mips0-decode", "00dc5f1020a7de3a3bc5ee21e7a767d09dab9c9831e840290277af90d1e1e3be"),
|
||||
("Rgba-5x5-none-mips1-encode", "284c04f628c256ba546815e46df2b837ee997d90834b8a0f095f20e17ba36102"),
|
||||
("Rgba-5x5-none-mips1-decode", "00dc5f1020a7de3a3bc5ee21e7a767d09dab9c9831e840290277af90d1e1e3be"),
|
||||
("Rgba-5x5-bc1-mips0-encode", "a5350786ccbd004a88ca541c0d4d7cdf313f71fec9485a45acd380f318846435"),
|
||||
("Rgba-5x5-bc1-mips0-decode", "26559d0fc43534fad7318b66672ef9de924b6408b2528c00cb6be76a56a94654"),
|
||||
("Rgba-5x5-bc1-mips1-encode", "67e06000b2ee88a6e8e749b20ee6ec0016d294f2fba57e9773aea3a7addd1883"),
|
||||
("Rgba-5x5-bc1-mips1-decode", "26559d0fc43534fad7318b66672ef9de924b6408b2528c00cb6be76a56a94654"),
|
||||
("Rgba-5x5-bc2-mips0-encode", "6cf909177531b9ed88be4ffd031055a7b1cbcfab0c6082ca33913720d631f834"),
|
||||
("Rgba-5x5-bc2-mips0-decode", "060ad06944e973f57c866137f9bd8c903a4edd30af275f9ee92fadff54a0a4bb"),
|
||||
("Rgba-5x5-bc2-mips1-encode", "0590d1aa5b074abb89262432a3b6b5c3ff12edca0d454069dadfe20be690e727"),
|
||||
("Rgba-5x5-bc2-mips1-decode", "060ad06944e973f57c866137f9bd8c903a4edd30af275f9ee92fadff54a0a4bb"),
|
||||
("Rgba-5x5-bc3-mips0-encode", "8d24e90ef90f819353e1bbbb1ab1163463dbdf8d9aaeb89b3acbc8cf2d3dd625"),
|
||||
("Rgba-5x5-bc3-mips0-decode", "d3238486581875abcd37dfbe03e8fbea7aa4fcadb1fef866899deafb67ac38f9"),
|
||||
("Rgba-5x5-bc3-mips1-encode", "2c331cbc46a45536bc1ae50cff9a692bae969748aebfa13e93c0269055ad5031"),
|
||||
("Rgba-5x5-bc3-mips1-decode", "d3238486581875abcd37dfbe03e8fbea7aa4fcadb1fef866899deafb67ac38f9"),
|
||||
("Gray-5x5-none-mips0-encode", "8527392cacb17a19b3e1c0f7cbe05ea4abd7fba93a7952d30967047a2e317f3b"),
|
||||
("Gray-5x5-none-mips0-decode", "70193f4748cd97b7676693076afe2f1c20afa0dc37b4eb89ff3752114a0e0321"),
|
||||
("Gray-5x5-none-mips1-encode", "6c5bd6095bbed4d39c15a6b50dcb5da8d5da48aabf696d2fbfcaf9bd1954c69d"),
|
||||
("Gray-5x5-none-mips1-decode", "70193f4748cd97b7676693076afe2f1c20afa0dc37b4eb89ff3752114a0e0321"),
|
||||
("Gray-5x5-bc1-mips0-encode", "fc7740ff5a801fdcc82e645d25240b44899a64117e70d739c8cba1c17c5a0841"),
|
||||
("Gray-5x5-bc1-mips0-decode", "65a82c1c1048d612c3b5e947603206571f088d1348e6acc42b9e2c014121e227"),
|
||||
("Gray-5x5-bc1-mips1-encode", "3953cd92035a27902d5feaf61ba11b4696c8593fb139fbdb6fda0167ac6d7a58"),
|
||||
("Gray-5x5-bc1-mips1-decode", "65a82c1c1048d612c3b5e947603206571f088d1348e6acc42b9e2c014121e227"),
|
||||
("Gray-5x5-bc2-mips0-encode", "4b2c26f66303f83c35c4f0ca8e306afbde35cfac5e9986cb6dc2ab33696a21c1"),
|
||||
("Gray-5x5-bc2-mips0-decode", "65a82c1c1048d612c3b5e947603206571f088d1348e6acc42b9e2c014121e227"),
|
||||
("Gray-5x5-bc2-mips1-encode", "047e4d8df50b60f8936e8da938b7c62217da128aaf88a25a9384aa69a3701ce9"),
|
||||
("Gray-5x5-bc2-mips1-decode", "65a82c1c1048d612c3b5e947603206571f088d1348e6acc42b9e2c014121e227"),
|
||||
("Gray-5x5-bc3-mips0-encode", "9c31c80f1e254a0e590927faf77fe88007d01c93d7a99280b7d632c4d680a8c4"),
|
||||
("Gray-5x5-bc3-mips0-decode", "65a82c1c1048d612c3b5e947603206571f088d1348e6acc42b9e2c014121e227"),
|
||||
("Gray-5x5-bc3-mips1-encode", "e046981ea9208a3da3cabbb6dd3f3f439db09d8713e6594e099bd7a3ebcd50dc"),
|
||||
("Gray-5x5-bc3-mips1-decode", "65a82c1c1048d612c3b5e947603206571f088d1348e6acc42b9e2c014121e227"),
|
||||
("Rgba-1x9-none-mips0-encode", "94676df714a0e07fd91981b3f9795da76df174319d551573bf62a7324ceae4fb"),
|
||||
("Rgba-1x9-none-mips0-decode", "dbcf64981f64ab690faa081bf7a90405bc9710ca5789f2bbf63d643469d1dd78"),
|
||||
("Rgba-1x9-none-mips1-encode", "2614a6ecc2aa845cab81819cd8bcd8b84624d693df6979cba3df91e100f27361"),
|
||||
("Rgba-1x9-none-mips1-decode", "dbcf64981f64ab690faa081bf7a90405bc9710ca5789f2bbf63d643469d1dd78"),
|
||||
("Rgba-1x9-bc1-mips0-encode", "b7f1466fcebfb73bd6e3b6288d3a8adde258fd9801c694fd44d0f92fbde26c61"),
|
||||
("Rgba-1x9-bc1-mips0-decode", "7d3471a56c9ca5332bccb8943e9d5a01105e0ddfd432b403e77841137f927787"),
|
||||
("Rgba-1x9-bc1-mips1-encode", "4c7c22ba8e2653f31cd9114857d8ba63db6ac180507e40e8c567b61b9c6781d9"),
|
||||
("Rgba-1x9-bc1-mips1-decode", "7d3471a56c9ca5332bccb8943e9d5a01105e0ddfd432b403e77841137f927787"),
|
||||
("Rgba-1x9-bc2-mips0-encode", "9dc6e68ae27d0709f8859d6efa0dfc4028d9fbba2cc0aef106973c998417f5d1"),
|
||||
("Rgba-1x9-bc2-mips0-decode", "c9dd7bf6d44932b599eeb73b54c6f778880db038768110b005f1886f6993e1db"),
|
||||
("Rgba-1x9-bc2-mips1-encode", "5ca6d64da612af3b9018cefa50e98cb9097c2eb3dbda8f862571057ba02d4312"),
|
||||
("Rgba-1x9-bc2-mips1-decode", "c9dd7bf6d44932b599eeb73b54c6f778880db038768110b005f1886f6993e1db"),
|
||||
("Rgba-1x9-bc3-mips0-encode", "f1d5194773bea0b427702900c928d6829f35cbfd32ec0e76b3ee882670597a81"),
|
||||
("Rgba-1x9-bc3-mips0-decode", "feda0633d1e41776c56257893bbe2be5317f57bb771152e1a4336558c16c013c"),
|
||||
("Rgba-1x9-bc3-mips1-encode", "4faa40254411822689f7d6b356c447e58f89a00ea05de3f7c43253164d83823c"),
|
||||
("Rgba-1x9-bc3-mips1-decode", "feda0633d1e41776c56257893bbe2be5317f57bb771152e1a4336558c16c013c"),
|
||||
("Gray-1x9-none-mips0-encode", "deb41e75756b10819d44b9840171a088a5d0169f56962a055939131986b7ebd1"),
|
||||
("Gray-1x9-none-mips0-decode", "2713191d6e180f74fa7825564575abcf7cc40c34f09c2cb8ccd4d2b02a675bb0"),
|
||||
("Gray-1x9-none-mips1-encode", "2d0f36be14a693e7c0380d70841d56cc857e4b81d1a4acbd94eeb18fca0c9216"),
|
||||
("Gray-1x9-none-mips1-decode", "2713191d6e180f74fa7825564575abcf7cc40c34f09c2cb8ccd4d2b02a675bb0"),
|
||||
("Gray-1x9-bc1-mips0-encode", "0723a0ecd94984d4a24890abc427611135b5add4c8ced0cd570867abe49217df"),
|
||||
("Gray-1x9-bc1-mips0-decode", "dcac5ac2d759bc4166ec0d061863f6bf9a34a03a382ac1d88ebdec3e750ecf3e"),
|
||||
("Gray-1x9-bc1-mips1-encode", "b1c38854773fde2bf2fc6e0c13ea5d8f6c92a19c1cb7af5c2986851522f2c5c2"),
|
||||
("Gray-1x9-bc1-mips1-decode", "dcac5ac2d759bc4166ec0d061863f6bf9a34a03a382ac1d88ebdec3e750ecf3e"),
|
||||
("Gray-1x9-bc2-mips0-encode", "b55d775f6f6029fa6d58ea4bea1abeaed349478665874ae2d5a53be14389c595"),
|
||||
("Gray-1x9-bc2-mips0-decode", "dcac5ac2d759bc4166ec0d061863f6bf9a34a03a382ac1d88ebdec3e750ecf3e"),
|
||||
("Gray-1x9-bc2-mips1-encode", "2e90ad054e173a392042126fd8674516fd8dc928c098238f92b7d434181a5895"),
|
||||
("Gray-1x9-bc2-mips1-decode", "dcac5ac2d759bc4166ec0d061863f6bf9a34a03a382ac1d88ebdec3e750ecf3e"),
|
||||
("Gray-1x9-bc3-mips0-encode", "3316e2f5db9bccd337b9dfede5d8c7a4555a645939682f4fc323e746722ef850"),
|
||||
("Gray-1x9-bc3-mips0-decode", "dcac5ac2d759bc4166ec0d061863f6bf9a34a03a382ac1d88ebdec3e750ecf3e"),
|
||||
("Gray-1x9-bc3-mips1-encode", "0ce9b894539c7e6d22531884a6e352aef26fc899ccf97d8a86878f6f5a68d969"),
|
||||
("Gray-1x9-bc3-mips1-decode", "dcac5ac2d759bc4166ec0d061863f6bf9a34a03a382ac1d88ebdec3e750ecf3e"),
|
||||
("Rgba-9x1-none-mips0-encode", "29bc4ef0ce9120982b331bf34a460a75f7c086b630ea6710ddd907b01125cc30"),
|
||||
("Rgba-9x1-none-mips0-decode", "666aa0014607ab13b7141c423c1fb137bda8a5c92973b3252c0556247383d80b"),
|
||||
("Rgba-9x1-none-mips1-encode", "455e7e2173deb612b28ac2ea2cacaf66c740150b3702e2d027bf51dc1123217f"),
|
||||
("Rgba-9x1-none-mips1-decode", "666aa0014607ab13b7141c423c1fb137bda8a5c92973b3252c0556247383d80b"),
|
||||
("Rgba-9x1-bc1-mips0-encode", "8e21b90879f2768fe0341375245b42a1645bc776ef88f81d700cd7e4f538ece3"),
|
||||
("Rgba-9x1-bc1-mips0-decode", "f6b1a1af12998d9db067870ff988d9b527df09ebfbe6a06710474247155655a8"),
|
||||
("Rgba-9x1-bc1-mips1-encode", "034c32c5a3025a72161e02ea5422ead0253490df2abf37030a048c93a301b386"),
|
||||
("Rgba-9x1-bc1-mips1-decode", "f6b1a1af12998d9db067870ff988d9b527df09ebfbe6a06710474247155655a8"),
|
||||
("Rgba-9x1-bc2-mips0-encode", "7d9fbf241277124a62bd0bc466e687d915435cbc083cf0f228694546b612f75e"),
|
||||
("Rgba-9x1-bc2-mips0-decode", "5360be17f525cac699135d57837231fbeb993a906c0f7efbffea6c18da4bb9b4"),
|
||||
("Rgba-9x1-bc2-mips1-encode", "c7fb6cb488b40b0d08f9958d8d19e3e3f8ac19ce96cd67f99b4bf6d65fb7b0fa"),
|
||||
("Rgba-9x1-bc2-mips1-decode", "5360be17f525cac699135d57837231fbeb993a906c0f7efbffea6c18da4bb9b4"),
|
||||
("Rgba-9x1-bc3-mips0-encode", "1e9ad28a5057cd576ad5f47625ccbdd836e683fd321428ac30760a15753a3b0e"),
|
||||
("Rgba-9x1-bc3-mips0-decode", "a367950e128431e9c0728de32358905486a9f53efef56827cf8f7fa71c9382af"),
|
||||
("Rgba-9x1-bc3-mips1-encode", "0f36472c2a24a64e07893879b60a1fc15e492038a669a4fdf0f586942ff7d197"),
|
||||
("Rgba-9x1-bc3-mips1-decode", "a367950e128431e9c0728de32358905486a9f53efef56827cf8f7fa71c9382af"),
|
||||
("Gray-9x1-none-mips0-encode", "4d65e2aad9e331cfc4edf2c0aaa58673c7ba90f1ad37cfa9c6a31095976ebc0a"),
|
||||
("Gray-9x1-none-mips0-decode", "105c3ae0c54915506d98a823112f37182f15e2cbed571b5161c4dfa1007575b5"),
|
||||
("Gray-9x1-none-mips1-encode", "0943b2616b8800af4415b53893ea301f1020e062b20f37095f1be9653a31e9bd"),
|
||||
("Gray-9x1-none-mips1-decode", "105c3ae0c54915506d98a823112f37182f15e2cbed571b5161c4dfa1007575b5"),
|
||||
("Gray-9x1-bc1-mips0-encode", "2c41ef37fc366203a20e1970feecdc8b619659215412a916221ccaa2b273430e"),
|
||||
("Gray-9x1-bc1-mips0-decode", "afd18b30efff0e3eb4b59cf01dcbbb06691c3af6028596f8de9efdf370ea915a"),
|
||||
("Gray-9x1-bc1-mips1-encode", "d2de0189a1e7a6a70f9a5d4ea7c7a53e064b7d1511f9b183a8dc31268ddb6ac6"),
|
||||
("Gray-9x1-bc1-mips1-decode", "afd18b30efff0e3eb4b59cf01dcbbb06691c3af6028596f8de9efdf370ea915a"),
|
||||
("Gray-9x1-bc2-mips0-encode", "766180145e22838dc950a136791fb350d51821e39c58270be394357228462fc1"),
|
||||
("Gray-9x1-bc2-mips0-decode", "afd18b30efff0e3eb4b59cf01dcbbb06691c3af6028596f8de9efdf370ea915a"),
|
||||
("Gray-9x1-bc2-mips1-encode", "476abc493a613766ad73fdc6a89ab765a68677ef6623370472dfea2e3d531847"),
|
||||
("Gray-9x1-bc2-mips1-decode", "afd18b30efff0e3eb4b59cf01dcbbb06691c3af6028596f8de9efdf370ea915a"),
|
||||
("Gray-9x1-bc3-mips0-encode", "b2f6f7f90bd0530857b272a6b39ac60e20ff2c65f5c0f71de543276d48fc5a30"),
|
||||
("Gray-9x1-bc3-mips0-decode", "afd18b30efff0e3eb4b59cf01dcbbb06691c3af6028596f8de9efdf370ea915a"),
|
||||
("Gray-9x1-bc3-mips1-encode", "4376a76e8467759cd485d2241c6e1553b6d49e6eb2f83a466d71ca68754776cd"),
|
||||
("Gray-9x1-bc3-mips1-decode", "afd18b30efff0e3eb4b59cf01dcbbb06691c3af6028596f8de9efdf370ea915a"),
|
||||
("Rgba-6x13-none-mips0-encode", "f603fdcab8e987e1f4b023ec68a14d8c03808952fe429338669977f33131c5a8"),
|
||||
("Rgba-6x13-none-mips0-decode", "35c18e04c37154e00ba7a544476335c4e234d8390803eb8f370351551652e49c"),
|
||||
("Rgba-6x13-none-mips1-encode", "5254f124be9189174a400affb9192419d6350f6f3361d24cf417ea42c8d33411"),
|
||||
("Rgba-6x13-none-mips1-decode", "35c18e04c37154e00ba7a544476335c4e234d8390803eb8f370351551652e49c"),
|
||||
("Rgba-6x13-bc1-mips0-encode", "f1b5e39e9a7308be64aa3531cfd487116a4e7f3ea309b694292c9738721ac872"),
|
||||
("Rgba-6x13-bc1-mips0-decode", "0a63216b434cd9b24807ea58c6d63888d68e84fa4834a34a8068f7fbf054449d"),
|
||||
("Rgba-6x13-bc1-mips1-encode", "13e5b50aa32a32d3dc71d75426c773bb36b191bd97c16c6f2ee0d76f4ee4f54b"),
|
||||
("Rgba-6x13-bc1-mips1-decode", "0a63216b434cd9b24807ea58c6d63888d68e84fa4834a34a8068f7fbf054449d"),
|
||||
("Rgba-6x13-bc2-mips0-encode", "0e0f5815d03c6ec3b8d58715beacdbe67a3dde10bf3f3b635425dc93073dbb4d"),
|
||||
("Rgba-6x13-bc2-mips0-decode", "14d744c8aff8c596f409a6a5c7599bca6479e8e084aa63d99660a44bfe55be6e"),
|
||||
("Rgba-6x13-bc2-mips1-encode", "4d007cb53697f394feb540a4745818c1f8a9df4a47819eac38b2102039e9421c"),
|
||||
("Rgba-6x13-bc2-mips1-decode", "14d744c8aff8c596f409a6a5c7599bca6479e8e084aa63d99660a44bfe55be6e"),
|
||||
("Rgba-6x13-bc3-mips0-encode", "db7fc9607849f169b3e1a7a8e100a7515bdce53ff4f1db7a5fbb6cfc1d1b8162"),
|
||||
("Rgba-6x13-bc3-mips0-decode", "33ba59f2acc8ab6877b8474a4b2cf063a0ae54b4a27afc64fde51313ba4ca6bc"),
|
||||
("Rgba-6x13-bc3-mips1-encode", "c985feb0187e7ac21aa829e25c5e5fe08970c58e10aaf71b96416a7969c55e68"),
|
||||
("Rgba-6x13-bc3-mips1-decode", "33ba59f2acc8ab6877b8474a4b2cf063a0ae54b4a27afc64fde51313ba4ca6bc"),
|
||||
("Gray-6x13-none-mips0-encode", "f63bb759c82a74584022a92fa9dfb64f36f3709446e279157942bafef6edc9b9"),
|
||||
("Gray-6x13-none-mips0-decode", "71201dd954c691aff18dab0a886cb7f10c15dbb33fca26dcc9f1047d28382190"),
|
||||
("Gray-6x13-none-mips1-encode", "435bedffe3efccd86a63533671dd55c7cdc982ea176383adb7e56c4745d38d28"),
|
||||
("Gray-6x13-none-mips1-decode", "71201dd954c691aff18dab0a886cb7f10c15dbb33fca26dcc9f1047d28382190"),
|
||||
("Gray-6x13-bc1-mips0-encode", "f8cb01936384bbff861cbebfd7149753b31f185b52de437e03074102b1056abf"),
|
||||
("Gray-6x13-bc1-mips0-decode", "48669b49d5aec2ab69c120c938838ba206d4e2d589399d2bccf0df5580b48194"),
|
||||
("Gray-6x13-bc1-mips1-encode", "f09c7c8bc3def200c72ed32545de294bbcb5436dbc46e249e5d5d2b8ac987a64"),
|
||||
("Gray-6x13-bc1-mips1-decode", "48669b49d5aec2ab69c120c938838ba206d4e2d589399d2bccf0df5580b48194"),
|
||||
("Gray-6x13-bc2-mips0-encode", "a2b00acf35735c638e07c7468dd8d5ab3405a8d69c653cf95a369538168b8e85"),
|
||||
("Gray-6x13-bc2-mips0-decode", "48669b49d5aec2ab69c120c938838ba206d4e2d589399d2bccf0df5580b48194"),
|
||||
("Gray-6x13-bc2-mips1-encode", "40769615b4e3117ade50c33e69a51a3f2f1601018c49ea216971955bed74b2ea"),
|
||||
("Gray-6x13-bc2-mips1-decode", "48669b49d5aec2ab69c120c938838ba206d4e2d589399d2bccf0df5580b48194"),
|
||||
("Gray-6x13-bc3-mips0-encode", "a429bc2f9725fb23f84ac6bff8bd6a1faaf0ab2808912515069b90c002bbf460"),
|
||||
("Gray-6x13-bc3-mips0-decode", "48669b49d5aec2ab69c120c938838ba206d4e2d589399d2bccf0df5580b48194"),
|
||||
("Gray-6x13-bc3-mips1-encode", "df1d533175cc807a8474701fe4cbdecd694fadd03082d506be50d8716e3e138f"),
|
||||
("Gray-6x13-bc3-mips1-decode", "48669b49d5aec2ab69c120c938838ba206d4e2d589399d2bccf0df5580b48194"),
|
||||
("dx10-rgba8-decode", "154284a9d25eef84bb2ee0b8b1c2d3cd95149dbae9a61cbe0ddb0f4e59cd1482"),
|
||||
("dx10-bgra8-decode", "ec571c9b54af06a0e63fed4b8b00a878d634f62297e72a22372c38fec561b08f"),
|
||||
("dx10-bgrx8-decode", "1e9e7678fcd37dcb5c61047cadac102a2053c9d738fab17c55d9d4af573aea99"),
|
||||
("legacy-rgba8-decode", "387f6d2b46545aa0188614c6c407a4c7498f065f3124964b92992a304c4e997d"),
|
||||
("legacy-bgra8-padded-decode", "5d4a59bd952afd03eb206aa2e3eaeb652d1d6abd1bf2ada8d8bc67e153fd0b3b"),
|
||||
("legacy-rgb24-decode", "0d33d20540b8d8714fb2f50193505188a60a743edbca6729806210a990bcebb7"),
|
||||
("legacy-rgb565-decode", "e0529a28e87837cea810bee99263a4d3c1ec99bfa6547bff583fc5848b7319e9"),
|
||||
("legacy-argb4444-decode", "0cf215d8c21faeff39c8b4e37acb8a72c69a873b7d132746c66c2f4a6277d58a"),
|
||||
("legacy-l8-padded-decode", "0c72254df5d58d8a1b4c62d1da03548c10a058dab179d7486a1e1c394a4b1cee"),
|
||||
("legacy-l8a8-decode", "066ff8e0a187094a1feb4bdc57e1cb8a99bc6ed3d69647c87c9d54a093b6815a"),
|
||||
("legacy-dxt1-noise-decode", "78d4ec7cec69249f8b065667eb66a23b23e82a6b7ab167043539976ae874c433"),
|
||||
("legacy-dxt3-noise-decode", "2dae7a8abe345ca37af54ad56e65dcb8a6fc1837f233cc81b5693b0b547babc8"),
|
||||
("legacy-dxt5-noise-decode", "5a6edeb62a5d6043a474de25da0611a550cf81716a8960dbf57feaebddf7d950"),
|
||||
("dx10-bc1-noise-decode", "5c6ea27a01ccb2a1ab3badea75551a9d3209a0176335871186362cc7e1923ead"),
|
||||
("dx10-bc3-noise-decode", "9c5376a1d714471d575344920380755e40f5be6cd4cb54add5b982d833276823"),
|
||||
];
|
||||
|
||||
/// The compressions the digests cover, listed here rather than taken from `DdsCompression::ALL`
|
||||
/// so a compression added later doesn't change the set.
|
||||
const COMPRESSIONS: [DdsCompression; 4] = [DdsCompression::None, DdsCompression::Bc1, DdsCompression::Bc2, DdsCompression::Bc3];
|
||||
|
||||
/// A 64-bit LCG (Knuth's MMIX constants) with a fixed seed: the same noise on every run.
|
||||
struct Lcg(u64);
|
||||
|
||||
impl Lcg {
|
||||
fn next(&mut self) -> u8 {
|
||||
self.0 = self.0.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1_442_695_040_888_963_407);
|
||||
(self.0 >> 33) as u8
|
||||
}
|
||||
}
|
||||
|
||||
/// An RGBA test picture in four vertical bands: smooth ramps with mid alpha, noise in every
|
||||
/// channel, flat 8×8 tiles of a few colours (whole blocks of one colour, opaque), and a band
|
||||
/// where alpha jumps between 0, 255 and in-between values over gentle colour.
|
||||
fn picture(w: u32, h: u32, seed: u64) -> Vec<u8> {
|
||||
let mut rng = Lcg(seed);
|
||||
let tiles: [[u8; 4]; 5] = [[12, 200, 77, 255], [255, 255, 255, 255], [0, 0, 0, 255], [255, 0, 255, 255], [90, 91, 92, 255]];
|
||||
let band = w.div_ceil(4).max(1);
|
||||
let mut data = Vec::with_capacity(w as usize * h as usize * 4);
|
||||
for y in 0..h {
|
||||
for x in 0..w {
|
||||
let noise = [rng.next(), rng.next(), rng.next(), rng.next()];
|
||||
let px = match x / band {
|
||||
0 => [(x * 2) as u8, (y * 3) as u8, (x + y) as u8, (64 + y % 128) as u8],
|
||||
1 => noise,
|
||||
2 => tiles[((x / 8 + y / 8) % 5) as usize],
|
||||
_ => {
|
||||
let alpha = match (x / 3 + y / 5) % 4 {
|
||||
0 => 0,
|
||||
1 => 255,
|
||||
2 => 128,
|
||||
_ => noise[3],
|
||||
};
|
||||
[(y % 256) as u8, 128, (255 - y % 256) as u8, alpha]
|
||||
}
|
||||
};
|
||||
data.extend(px);
|
||||
}
|
||||
}
|
||||
data
|
||||
}
|
||||
|
||||
/// The picture in `layout`, its channels picked from the RGBA picture without any conversion
|
||||
/// formula: gray is red, and gray's alpha is alpha.
|
||||
fn image(w: u32, h: u32, layout: ChannelLayout, seed: u64) -> Image {
|
||||
let rgba = picture(w, h, seed);
|
||||
let data = rgba
|
||||
.as_chunks::<4>()
|
||||
.0
|
||||
.iter()
|
||||
.flat_map(|p| match layout {
|
||||
ChannelLayout::Gray => vec![p[0]],
|
||||
ChannelLayout::GrayA => vec![p[0], p[3]],
|
||||
ChannelLayout::Rgb => vec![p[0], p[1], p[2]],
|
||||
_ => p.to_vec(),
|
||||
})
|
||||
.collect();
|
||||
Image::from_u8(w, h, layout, data).unwrap()
|
||||
}
|
||||
|
||||
fn sha256_hex(bytes: &[u8]) -> String {
|
||||
Sha256::digest(bytes).iter().map(|b| format!("{b:02x}")).collect()
|
||||
}
|
||||
|
||||
/// A decoded image's digest: its size and layout, then its samples.
|
||||
fn image_digest(img: &Image) -> String {
|
||||
let mut h = Sha256::new();
|
||||
h.update(img.width().to_le_bytes());
|
||||
h.update(img.height().to_le_bytes());
|
||||
h.update(format!("{:?}", img.layout()).as_bytes());
|
||||
h.update(img.data());
|
||||
h.finalize().iter().map(|b| format!("{b:02x}")).collect()
|
||||
}
|
||||
|
||||
const DDPF_ALPHAPIXELS: u32 = 0x1;
|
||||
const DDPF_FOURCC: u32 = 0x4;
|
||||
const DDPF_RGB: u32 = 0x40;
|
||||
const DDPF_LUMINANCE: u32 = 0x2_0000;
|
||||
const DDSD_PITCH: u32 = 0x8;
|
||||
|
||||
/// A DDS_HEADER for a single-level 2D texture, with `pitch` set (and flagged) when given.
|
||||
fn header(width: u32, height: u32, pf_flags: u32, fourcc: &[u8; 4], bits: u32, masks: [u32; 4], pitch: Option<u32>) -> Vec<u8> {
|
||||
let mut b = vec![0u8; 128];
|
||||
b[0..4].copy_from_slice(b"DDS ");
|
||||
let mut put = |at: usize, v: u32| b[at..at + 4].copy_from_slice(&v.to_le_bytes());
|
||||
put(4, 124);
|
||||
put(8, 0x1007 | if pitch.is_some() { DDSD_PITCH } else { 0 });
|
||||
put(12, height);
|
||||
put(16, width);
|
||||
put(20, pitch.unwrap_or(0));
|
||||
put(76, 32);
|
||||
put(80, pf_flags);
|
||||
put(88, bits);
|
||||
for (i, m) in masks.into_iter().enumerate() {
|
||||
put(92 + 4 * i, m);
|
||||
}
|
||||
put(108, 0x1000);
|
||||
b[84..88].copy_from_slice(fourcc);
|
||||
b
|
||||
}
|
||||
|
||||
/// A DX10 texture header for DXGI format `dxgi`.
|
||||
fn dx10(width: u32, height: u32, dxgi: u32) -> Vec<u8> {
|
||||
let mut b = header(width, height, DDPF_FOURCC, b"DX10", 0, [0; 4], None);
|
||||
for v in [dxgi, 3, 0, 1, 0] {
|
||||
b.extend(v.to_le_bytes());
|
||||
}
|
||||
b
|
||||
}
|
||||
|
||||
/// `len` bytes of noise.
|
||||
fn noise(len: usize, seed: u64) -> Vec<u8> {
|
||||
let mut rng = Lcg(seed);
|
||||
(0..len).map(|_| rng.next()).collect()
|
||||
}
|
||||
|
||||
/// Hand-built files in the layouts the writer never makes: RGBA and BGRA through the DX10
|
||||
/// header, padded rows, 24- and 16-bit masks, and block data of pure noise (which reaches BC1's
|
||||
/// three-colour mode and BC3's six-value mode as often as their other modes).
|
||||
fn foreign_files() -> Vec<(String, Vec<u8>)> {
|
||||
let (w, h) = (37u32, 23u32);
|
||||
let px = (w * h) as usize;
|
||||
let blocks = (w.div_ceil(4) * h.div_ceil(4)) as usize;
|
||||
let mut files = Vec::new();
|
||||
let mut add = |name: &str, mut head: Vec<u8>, body: Vec<u8>| {
|
||||
head.extend(body);
|
||||
files.push((name.to_string(), head));
|
||||
};
|
||||
add("dx10-rgba8", dx10(w, h, 28), noise(px * 4, 1));
|
||||
add("dx10-bgra8", dx10(w, h, 87), noise(px * 4, 2));
|
||||
add("dx10-bgrx8", dx10(w, h, 88), noise(px * 4, 3));
|
||||
add("legacy-rgba8", header(w, h, DDPF_RGB | DDPF_ALPHAPIXELS, &[0; 4], 32, [0xff, 0xff00, 0xff_0000, 0xff00_0000], None), noise(px * 4, 4));
|
||||
add(
|
||||
"legacy-bgra8-padded",
|
||||
header(w, h, DDPF_RGB | DDPF_ALPHAPIXELS, &[0; 4], 32, [0xff_0000, 0xff00, 0xff, 0xff00_0000], Some(w * 4 + 12)),
|
||||
noise((w * 4 + 12) as usize * h as usize, 5),
|
||||
);
|
||||
add("legacy-rgb24", header(w, h, DDPF_RGB, &[0; 4], 24, [0xff_0000, 0xff00, 0xff, 0], None), noise(px * 3, 6));
|
||||
add("legacy-rgb565", header(w, h, DDPF_RGB, &[0; 4], 16, [0xf800, 0x07e0, 0x001f, 0], None), noise(px * 2, 7));
|
||||
add("legacy-argb4444", header(w, h, DDPF_RGB | DDPF_ALPHAPIXELS, &[0; 4], 16, [0x0f00, 0x00f0, 0x000f, 0xf000], None), noise(px * 2, 8));
|
||||
add("legacy-l8-padded", header(w, h, DDPF_LUMINANCE, &[0; 4], 8, [0xff, 0, 0, 0], Some(w + 3)), noise((w + 3) as usize * h as usize, 9));
|
||||
add("legacy-l8a8", header(w, h, DDPF_LUMINANCE | DDPF_ALPHAPIXELS, &[0; 4], 16, [0xff, 0, 0, 0xff00], None), noise(px * 2, 10));
|
||||
add("legacy-dxt1-noise", header(w, h, DDPF_FOURCC, b"DXT1", 0, [0; 4], None), noise(blocks * 8, 11));
|
||||
add("legacy-dxt3-noise", header(w, h, DDPF_FOURCC, b"DXT3", 0, [0; 4], None), noise(blocks * 16, 12));
|
||||
add("legacy-dxt5-noise", header(w, h, DDPF_FOURCC, b"DXT5", 0, [0; 4], None), noise(blocks * 16, 13));
|
||||
add("dx10-bc1-noise", dx10(w, h, 71), noise(blocks * 8, 14));
|
||||
add("dx10-bc3-noise", dx10(w, h, 77), noise(blocks * 16, 15));
|
||||
files
|
||||
}
|
||||
|
||||
/// Every case and its digest, in a fixed order.
|
||||
fn digests() -> Vec<(String, String)> {
|
||||
let mut out = Vec::new();
|
||||
// Odd sizes, the sub-block sizes and the one-pixel strips whose mip chains reach the
|
||||
// downsampler's edge spans in only one direction.
|
||||
let sizes = [(517u32, 389u32), (1, 1), (2, 3), (3, 2), (5, 5), (1, 9), (9, 1), (6, 13)];
|
||||
let layouts = [ChannelLayout::Rgba, ChannelLayout::Rgb, ChannelLayout::GrayA, ChannelLayout::Gray];
|
||||
for (i, &(w, h)) in sizes.iter().enumerate() {
|
||||
for layout in layouts {
|
||||
// The large picture in every layout; the small ones in RGBA and gray.
|
||||
if i > 0 && !matches!(layout, ChannelLayout::Rgba | ChannelLayout::Gray) {
|
||||
continue;
|
||||
}
|
||||
let img = image(w, h, layout, 0x5eed + i as u64);
|
||||
for compression in COMPRESSIONS {
|
||||
for mipmaps in [false, true] {
|
||||
let name = format!("{layout:?}-{w}x{h}-{}-mips{}", compression.name(), u8::from(mipmaps));
|
||||
let opts = EncodeOptions { dds: DdsOptions { compression, mipmaps }, ..Default::default() };
|
||||
let file = encode(&img, Format::Dds, &opts).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
out.push((format!("{name}-encode"), sha256_hex(&file)));
|
||||
let back = decode(&file).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
out.push((format!("{name}-decode"), image_digest(&back)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (name, file) in foreign_files() {
|
||||
let back = decode(&file).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
out.push((format!("{name}-decode"), image_digest(&back)));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dds_output_matches_the_pinned_digests() {
|
||||
let got = digests();
|
||||
let pinned = |name: &str| PINNED.iter().find(|(n, _)| *n == name).map(|(_, d)| *d);
|
||||
let mismatched: Vec<&str> = got.iter().filter(|(name, digest)| pinned(name) != Some(digest.as_str())).map(|(n, _)| n.as_str()).collect();
|
||||
let stale: Vec<&str> = PINNED.iter().filter(|(n, _)| !got.iter().any(|(g, _)| g == n)).map(|(n, _)| *n).collect();
|
||||
if !mismatched.is_empty() || !stale.is_empty() {
|
||||
eprintln!("const PINNED: &[(&str, &str)] = &[");
|
||||
for (name, digest) in &got {
|
||||
eprintln!(" (\"{name}\", \"{digest}\"),");
|
||||
}
|
||||
eprintln!("];");
|
||||
panic!("{} digests differ or are new: {mismatched:?}; {} pinned cases are gone: {stale:?}", mismatched.len(), stale.len());
|
||||
}
|
||||
}
|
||||
@@ -16,6 +16,8 @@ const DDPF_ALPHAPIXELS: u32 = 0x1;
|
||||
const DDPF_FOURCC: u32 = 0x4;
|
||||
const DDPF_RGB: u32 = 0x40;
|
||||
const DDPF_LUMINANCE: u32 = 0x2_0000;
|
||||
const DXGI_BC4_UNORM: u32 = 80;
|
||||
const DXGI_BC5_UNORM: u32 = 83;
|
||||
|
||||
const BLOCKS: [DdsCompression; 3] = [DdsCompression::Bc1, DdsCompression::Bc2, DdsCompression::Bc3];
|
||||
|
||||
@@ -80,11 +82,21 @@ fn psnr(a: &Image, b: &Image) -> f64 {
|
||||
if mse == 0.0 { f64::INFINITY } else { 10.0 * (255.0f64.powi(2) / mse).log10() }
|
||||
}
|
||||
|
||||
/// Whether a written texture has the DX10 header after the legacy one.
|
||||
fn has_dx10(file: &[u8]) -> bool {
|
||||
le32(file, 80) & DDPF_FOURCC != 0 && &file[84..88] == b"DX10"
|
||||
}
|
||||
|
||||
/// Bytes of the headers before the first level.
|
||||
fn head(file: &[u8]) -> usize {
|
||||
if has_dx10(file) { 148 } else { 128 }
|
||||
}
|
||||
|
||||
/// Bytes of one level as a reader computes them from the header's pixel format.
|
||||
fn level_bytes(file: &[u8], w: usize, h: usize) -> usize {
|
||||
if le32(file, 80) & DDPF_FOURCC != 0 {
|
||||
let block = if &file[84..88] == b"DXT1" { 8 } else { 16 };
|
||||
w.div_ceil(4) * h.div_ceil(4) * block
|
||||
let eight = &file[84..88] == b"DXT1" || (has_dx10(file) && le32(file, 128) == DXGI_BC4_UNORM);
|
||||
w.div_ceil(4) * h.div_ceil(4) * if eight { 8 } else { 16 }
|
||||
} else {
|
||||
w * h * le32(file, 88) as usize / 8
|
||||
}
|
||||
@@ -94,9 +106,9 @@ fn level_bytes(file: &[u8], w: usize, h: usize) -> usize {
|
||||
fn level(file: &[u8], i: u32) -> Image {
|
||||
let (w, h) = (le32(file, 16) as usize, le32(file, 12) as usize);
|
||||
let size = |i: u32| ((w >> i).max(1), (h >> i).max(1));
|
||||
let start = 128 + (0..i).map(|j| level_bytes(file, size(j).0, size(j).1)).sum::<usize>();
|
||||
let start = head(file) + (0..i).map(|j| level_bytes(file, size(j).0, size(j).1)).sum::<usize>();
|
||||
let (lw, lh) = size(i);
|
||||
let mut b = file[..128].to_vec();
|
||||
let mut b = file[..head(file)].to_vec();
|
||||
b[12..16].copy_from_slice(&(lh as u32).to_le_bytes());
|
||||
b[16..20].copy_from_slice(&(lw as u32).to_le_bytes());
|
||||
b[28..32].copy_from_slice(&1u32.to_le_bytes());
|
||||
@@ -338,15 +350,122 @@ fn fidelity_warnings_follow_the_compression() {
|
||||
}
|
||||
assert!(warns(DdsCompression::Bc1).contains(&FidelityWarning::AlphaBinarized));
|
||||
assert!(!warns(DdsCompression::Bc3).contains(&FidelityWarning::AlphaBinarized));
|
||||
// BC4 is gray and BC5 has no alpha: translucent colour loses what they don't hold.
|
||||
let bc4 = warns(DdsCompression::Bc4);
|
||||
for w in [FidelityWarning::LossyCompression, FidelityWarning::ColorToGray, FidelityWarning::AlphaDiscarded] {
|
||||
assert!(bc4.contains(&w), "BC4: {w:?} missing from {bc4:?}");
|
||||
}
|
||||
let bc5 = warns(DdsCompression::Bc5);
|
||||
assert!(bc5.contains(&FidelityWarning::LossyCompression) && bc5.contains(&FidelityWarning::AlphaDiscarded), "{bc5:?}");
|
||||
assert!(!bc5.contains(&FidelityWarning::ColorToGray) && !bc5.contains(&FidelityWarning::AlphaBinarized), "{bc5:?}");
|
||||
// A gray map written as BC4 loses only to the compression.
|
||||
let gray = ramp(8, 8, ChannelLayout::Gray);
|
||||
assert_eq!(fidelity_warnings_with(&gray, Format::Dds, &opts(DdsCompression::Bc4, false)), [FidelityWarning::LossyCompression]);
|
||||
}
|
||||
|
||||
/// The largest difference in channel `c` between two images of `channels` channels.
|
||||
fn max_diff(a: &Image, b: &Image, channels: usize, c: usize) -> u8 {
|
||||
a.data().chunks(channels).zip(b.data().chunks(channels)).map(|(x, y)| x[c].abs_diff(y[c])).max().unwrap_or(0)
|
||||
}
|
||||
|
||||
/// `gradient`'s red as gray, or its red, green and blue.
|
||||
fn gradient_as(w: u32, h: u32, layout: ChannelLayout) -> Image {
|
||||
let rgba = gradient(w, h);
|
||||
let data = rgba.data().chunks(4).flat_map(|p| if layout == ChannelLayout::Gray { vec![p[0]] } else { p[..3].to_vec() }).collect();
|
||||
Image::from_u8(w, h, layout, data).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bc4_and_bc5_are_written_with_the_dx10_header() {
|
||||
for (compression, dxgi, block, layout) in
|
||||
[(DdsCompression::Bc4, DXGI_BC4_UNORM, 8, ChannelLayout::Gray), (DdsCompression::Bc5, DXGI_BC5_UNORM, 16, ChannelLayout::Rgb)]
|
||||
{
|
||||
for (w, h) in [(1, 1), (2, 2), (5, 3), (33, 17)] {
|
||||
let img = ramp(w, h, layout);
|
||||
let b = encode(&img, Format::Dds, &opts(compression, false)).unwrap();
|
||||
let linear = w.div_ceil(4) * h.div_ceil(4) * block;
|
||||
assert_eq!(&b[84..88], b"DX10");
|
||||
assert_eq!((le32(&b, 80), le32(&b, 88)), (DDPF_FOURCC, 0));
|
||||
assert_eq!(le32(&b, 8), REQUIRED | DDSD_LINEARSIZE, "linear size, not pitch");
|
||||
assert_eq!(le32(&b, 20), linear, "{compression:?} {w}x{h}: the top level's size");
|
||||
// DXGI format, a 2D texture, no misc flags, one texture, alpha mode unknown.
|
||||
assert_eq!([le32(&b, 128), le32(&b, 132), le32(&b, 136), le32(&b, 140), le32(&b, 144)], [dxgi, 3, 0, 1, 0]);
|
||||
assert_eq!(b.len(), 148 + linear as usize);
|
||||
assert!(!craft_image_codecs::has_unretained_source_data(&b).unwrap());
|
||||
let back = decode(&b).unwrap();
|
||||
assert_eq!((back.dimensions(), back.layout()), ((w, h), layout), "{compression:?} {w}x{h}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bc4_and_bc5_error_on_gradients_is_bounded() {
|
||||
// Each block of the gradient spans 12 levels in a channel: eight values (or six and the
|
||||
// extremes) are under two levels apart.
|
||||
let gray = gradient_as(64, 64, ChannelLayout::Gray);
|
||||
let back = decode(&encode(&gray, Format::Dds, &opts(DdsCompression::Bc4, false)).unwrap()).unwrap();
|
||||
assert_eq!(back.layout(), ChannelLayout::Gray);
|
||||
let err = max_diff(&gray, &back, 1, 0);
|
||||
assert!(err <= 2, "BC4 off by {err}");
|
||||
|
||||
let rgb = gradient_as(64, 64, ChannelLayout::Rgb);
|
||||
let back = decode(&encode(&rgb, Format::Dds, &opts(DdsCompression::Bc5, false)).unwrap()).unwrap();
|
||||
assert_eq!(back.layout(), ChannelLayout::Rgb);
|
||||
let (red, green) = (max_diff(&rgb, &back, 3, 0), max_diff(&rgb, &back, 3, 1));
|
||||
assert!(red <= 2 && green <= 2, "BC5 red off by {red}, green by {green}");
|
||||
assert!(back.data().chunks(3).all(|p| p[2] == 0), "BC5 has no blue");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bc4_and_bc5_take_any_source_layout() {
|
||||
// RGBA to BC4 goes through gray; to BC5 through RGB, dropping alpha and then blue.
|
||||
let img = gradient(9, 7);
|
||||
for (compression, layout) in [(DdsCompression::Bc4, ChannelLayout::Gray), (DdsCompression::Bc5, ChannelLayout::Rgb)] {
|
||||
let back = decode(&encode(&img, Format::Dds, &opts(compression, true)).unwrap()).unwrap();
|
||||
let want = img.convert(layout, img.sample_type());
|
||||
let ch = layout.channels();
|
||||
assert_eq!((back.dimensions(), back.layout()), ((9, 7), layout));
|
||||
for c in 0..ch.min(2) {
|
||||
let err = max_diff(&want, &back, ch, c);
|
||||
assert!(err <= 8, "{compression:?} channel {c} off by {err}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bc4_and_bc5_mip_chains_follow_the_box_filter() {
|
||||
for (compression, layout, block) in [(DdsCompression::Bc4, ChannelLayout::Gray, 8), (DdsCompression::Bc5, ChannelLayout::Rgb, 16)] {
|
||||
let img = gradient_as(12, 6, layout);
|
||||
let b = encode(&img, Format::Dds, &opts(compression, true)).unwrap();
|
||||
// 12×6, 6×3, 3×1, 1×1: 3×2, 2×1, 1 and 1 blocks after both headers.
|
||||
assert_eq!(le32(&b, 28), 4);
|
||||
assert_eq!(le32(&b, 8), REQUIRED | DDSD_LINEARSIZE | DDSD_MIPMAPCOUNT);
|
||||
assert_eq!(b.len(), 148 + (6 + 2 + 1 + 1) * block);
|
||||
let mut want = img.clone();
|
||||
for i in 0..4 {
|
||||
let got = level(&b, i);
|
||||
assert_eq!((got.dimensions(), got.layout()), (want.dimensions(), layout), "{compression:?} level {i}");
|
||||
for c in 0..layout.channels().min(2) {
|
||||
// Smaller levels are steeper (8, then 16 levels a pixel), so a block's values
|
||||
// sit up to a few levels off its palette.
|
||||
let err = max_diff(&want, &got, layout.channels(), c);
|
||||
assert!(err <= 4, "{compression:?} level {i} channel {c} off by {err}");
|
||||
}
|
||||
want = box_filter(&want);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn compression_names_round_trip() {
|
||||
assert_eq!(DdsCompression::ALL.len(), 6);
|
||||
for c in DdsCompression::ALL {
|
||||
assert_eq!(DdsCompression::from_name(c.name()), Some(c));
|
||||
}
|
||||
assert_eq!(DdsCompression::from_name("DXT5"), Some(DdsCompression::Bc3));
|
||||
assert_eq!(DdsCompression::from_name("dxt1"), Some(DdsCompression::Bc1));
|
||||
assert_eq!(DdsCompression::from_name("ATI1"), Some(DdsCompression::Bc4));
|
||||
assert_eq!(DdsCompression::from_name("ati2"), Some(DdsCompression::Bc5));
|
||||
for bad in ["", "bc7", "dxt2", "uncompressed "] {
|
||||
assert_eq!(DdsCompression::from_name(bad), None, "{bad:?}");
|
||||
}
|
||||
@@ -360,6 +479,18 @@ fn compression_names_round_trip() {
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn dds_encode_timings_on_30_mp() {
|
||||
let img = texture_30_mp();
|
||||
for compression in DdsCompression::ALL {
|
||||
for mipmaps in [false, true] {
|
||||
let t = std::time::Instant::now();
|
||||
let b = encode(&img, Format::Dds, &opts(compression, mipmaps)).unwrap();
|
||||
eprintln!("{compression:?} mipmaps={mipmaps}: {:.0} ms, {} MB", t.elapsed().as_secs_f64() * 1e3, b.len() >> 20);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A synthetic ~30 MP RGBA texture (6336×4752): gentle ramps with a little noise.
|
||||
fn texture_30_mp() -> Image {
|
||||
let (w, h) = (6336u32, 4752u32);
|
||||
let mut s = 0x1234_5678u32;
|
||||
let mut data = Vec::with_capacity(w as usize * h as usize * 4);
|
||||
@@ -371,12 +502,28 @@ fn dds_encode_timings_on_30_mp() {
|
||||
data.extend([(x / 25 + y / 19) as u8, (x / 31) as u8 ^ (s as u8 & 3), (y / 23) as u8, (255 - x / 25) as u8]);
|
||||
}
|
||||
}
|
||||
let img = Image::from_u8(w, h, ChannelLayout::Rgba, data).unwrap();
|
||||
Image::from_u8(w, h, ChannelLayout::Rgba, data).unwrap()
|
||||
}
|
||||
|
||||
/// Decode timings of the same texture written with each compression: the best of five runs, so
|
||||
/// one slow run doesn't decide. Ignored by default; run in release:
|
||||
///
|
||||
/// ```sh
|
||||
/// cargo test --release -p craft-image-codecs --test it -- dds_write:: --ignored --nocapture
|
||||
/// ```
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn dds_decode_timings_on_30_mp() {
|
||||
let img = texture_30_mp();
|
||||
for compression in DdsCompression::ALL {
|
||||
for mipmaps in [false, true] {
|
||||
let b = encode(&img, Format::Dds, &opts(compression, false)).unwrap();
|
||||
let mut best = f64::INFINITY;
|
||||
for _ in 0..5 {
|
||||
let t = std::time::Instant::now();
|
||||
let b = encode(&img, Format::Dds, &opts(compression, mipmaps)).unwrap();
|
||||
eprintln!("{compression:?} mipmaps={mipmaps}: {:.0} ms, {} MB", t.elapsed().as_secs_f64() * 1e3, b.len() >> 20);
|
||||
let back = decode(&b).unwrap();
|
||||
best = best.min(t.elapsed().as_secs_f64());
|
||||
assert_eq!(back.dimensions(), img.dimensions());
|
||||
}
|
||||
eprintln!("{compression:?} decode: {:.0} ms, {} MB", best * 1e3, b.len() >> 20);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,6 +4,7 @@ mod bmp_resolution;
|
||||
mod camera_raw;
|
||||
mod common;
|
||||
mod dds;
|
||||
mod dds_oracle;
|
||||
mod dds_write;
|
||||
mod decode_warnings;
|
||||
mod deep_exr;
|
||||
|
||||
@@ -11,7 +11,7 @@ craft-raster-codecs = { git = "https://github.com/storytold/craft-libs", rev = "
|
||||
|
||||
| Module | Format | Read | Write |
|
||||
|---|---|---|---|
|
||||
| `dds` | DirectDraw Surface: uncompressed masks, luminance, BC1/BC2/BC3 (DXT1/3/5), legacy and DX10 headers; top mip level | yes | uncompressed and BC1-BC3, optional mip chain |
|
||||
| `dds` | DirectDraw Surface: uncompressed masks, luminance, BC1/BC2/BC3 (DXT1/3/5), unsigned BC4/BC5 (ATI1/2, as gray and as RGB with blue 0), legacy and DX10 headers; top mip level | yes | uncompressed and BC1-BC3, optional mip chain |
|
||||
| `dicom` | DICOM Part 10, uncompressed transfer syntaxes: MONOCHROME1/2, RGB, YBR_FULL, 8 and 16 bits | yes | no |
|
||||
| `fits` | FITS primary HDU or first `IMAGE` extension, every `BITPIX`, `BSCALE`/`BZERO`, header cards as text | yes | gray or RGB; 8-bit, 16-bit, float |
|
||||
| `iff` | IFF ILBM (1 to 8 planes with a palette, 24 planes, mask plane or transparent colour) and PBM, stored or ByteRun1; HAM and EHB are refused | yes | 24-plane ILBM with an optional mask plane |
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
//!
|
||||
//! | Module | Format | Read | Write |
|
||||
//! |---|---|---|---|
|
||||
//! | [`dds`] | DirectDraw Surface: uncompressed masks, BC1-BC3 (DXT1/3/5), the DX10 header | yes | yes |
|
||||
//! | [`dds`] | DirectDraw Surface: uncompressed masks, BC1-BC5 (DXT1/3/5, ATI1/2), the DX10 header | yes | yes (uncompressed, BC1-BC3) |
|
||||
//! | [`dicom`] | DICOM Part 10, uncompressed native pixel data | yes | no |
|
||||
//! | [`fits`] | FITS primary and image-extension HDUs | yes | yes |
|
||||
//! | [`iff`] | IFF ILBM (palette or 24-bit planes, masks) and PBM | yes | yes (24-plane ILBM) |
|
||||
|
||||
@@ -320,7 +320,8 @@ fn refuses_cubemaps_arrays_and_volumes() {
|
||||
unsupported(&dx10(4, 4, 71, 3, 0, 6), "array");
|
||||
unsupported(&dx10(4, 4, 71, 4, 0, 1), "2D");
|
||||
unsupported(&dx10(4, 4, 98, 3, 0, 1), "98"); // BC7_UNORM
|
||||
unsupported(&compressed(4, 4, b"ATI2"), "ATI2");
|
||||
unsupported(&compressed(4, 4, b"ATI3"), "ATI3");
|
||||
unsupported(&compressed(4, 4, b"BC5S"), "SNORM");
|
||||
unsupported(&compressed(4, 4, b"DXT2"), "premultiplied");
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user