Merge remote-tracking branch 'origin/main' into fix/png-bounded-row-stream

This commit is contained in:
Dylan M. Taylor
2026-11-15 02:40:59 +00:00
31 changed files with 1285 additions and 4314 deletions
Generated
+1 -1
View File
@@ -2430,7 +2430,6 @@ dependencies = [
"base64 0.23.1",
"craft-image-codecs",
"image",
"rayon",
"thiserror 2.0.21",
]
@@ -2732,6 +2731,7 @@ version = "0.1.0"
dependencies = [
"craft-media",
"craft-media-testkit",
"rav1e",
"rayon",
"thiserror 2.0.21",
]
+22 -13
View File
@@ -1,5 +1,5 @@
//! ZSoft PCX (Paintbrush) reader: strictly bounded scanline RLE, 16/256-colour
//! palettes and 8-bit three-plane RGB. Read-only: modern saves should use PNG.
//! palettes, 8-bit RGB and four-plane RGBA. Read-only: modern saves should use PNG.
use crate::SampleType;
use crate::error::CodecError;
@@ -19,7 +19,7 @@ fn le16(b: &[u8], i: usize) -> u16 {
/// PCX lacks a strong magic number. Require plausible complete header fields before
/// identifying it, rather than classifying every file starting with 0x0a as PCX.
pub(crate) fn looks_like_pcx(b: &[u8]) -> bool {
if b.len() < HEADER || b[0] != 0x0a || !matches!(b[1], 0 | 2 | 3 | 5) || b[2] != 1 {
if b.len() < HEADER || b[0] != 0x0a || !matches!(b[1], 0 | 2..=5) || b[2] != 1 {
return false;
}
let bits = b[3];
@@ -31,7 +31,12 @@ pub(crate) fn looks_like_pcx(b: &[u8]) -> bool {
}
let width = u32::from(x1 - x0) + 1;
let min_stride = (width * u32::from(bits)).div_ceil(8);
stride >= min_stride && stride > 0 && (bits != 8 || matches!(planes, 1 | 3)) && (bits == 8 || u32::from(bits) * u32::from(planes) <= 4)
stride >= min_stride && stride > 0 && (bits != 8 || matches!(planes, 1 | 3 | 4)) && (bits == 8 || u32::from(bits) * u32::from(planes) <= 4)
}
/// The dimensions declared by a plausible PCX header, without decoding its pixels.
pub(crate) fn dimensions(b: &[u8]) -> Option<(u32, u32)> {
looks_like_pcx(b).then(|| (u32::from(le16(b, 8) - le16(b, 4)) + 1, u32::from(le16(b, 10) - le16(b, 6)) + 1))
}
/// Read one compressed scanline, including all planes. RLE packets never cross a scanline.
@@ -61,11 +66,12 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
if !looks_like_pcx(b) {
return Err(bad("invalid PCX header or unsupported pixel layout"));
}
let (w, h) = (u32::from(le16(b, 8) - le16(b, 4)) + 1, u32::from(le16(b, 10) - le16(b, 6)) + 1);
limits.check(w, h, ChannelLayout::Rgb, SampleType::U8)?;
let (w, h) = dimensions(b).ok_or_else(|| bad("invalid PCX header or unsupported pixel layout"))?;
let layout = if b[3] == 8 && b[65] == 4 { ChannelLayout::Rgba } else { ChannelLayout::Rgb };
limits.check(w, h, layout, SampleType::U8)?;
let (bits, planes, stride) = (usize::from(b[3]), usize::from(b[65]), usize::from(le16(b, 66)));
let row_len = stride.checked_mul(planes).ok_or_else(|| bad("row size overflow"))?;
let total = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(3)).ok_or_else(|| bad("pixel size overflow"))?;
let total = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(layout.channels())).ok_or_else(|| bad("pixel size overflow"))?;
// The last 769 bytes are the optional VGA palette for 8-bit indexed images.
let vga = bits == 8 && planes == 1 && b.len() >= HEADER + 769 && b[b.len() - 769] == 0x0c;
if bits == 8 && planes == 1 && !vga && le16(b, 68) != 2 {
@@ -102,8 +108,10 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
for y in 0..h as usize {
read_row(&b[..image_end], &mut p, &mut row)?;
for x in 0..width {
let rgb = if bits == 8 && planes == 3 {
[row[x], row[stride + x], row[2 * stride + x]]
let rgba = if bits == 8 && planes == 4 {
[row[x], row[stride + x], row[2 * stride + x], row[3 * stride + x]]
} else if bits == 8 && planes == 3 {
[row[x], row[stride + x], row[2 * stride + x], 255]
} else {
let index = if bits == 8 {
usize::from(row[x])
@@ -118,19 +126,20 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
};
if vga {
let o = image_end + 1 + index * 3;
[b[o], b[o + 1], b[o + 2]]
[b[o], b[o + 1], b[o + 2], 255]
} else if bits == 8 {
let g = index as u8;
[g, g, g] // palette-info 2: gray scale
[g, g, g, 255] // palette-info 2: gray scale
} else {
let o = 16 + index * 3;
[b[o], b[o + 1], b[o + 2]]
[b[o], b[o + 1], b[o + 2], 255]
}
};
pixels[(y * width + x) * 3..(y * width + x + 1) * 3].copy_from_slice(&rgb);
let start = (y * width + x) * layout.channels();
pixels[start..start + layout.channels()].copy_from_slice(&rgba[..layout.channels()]);
}
}
let mut image = Image::from_u8(w, h, ChannelLayout::Rgb, pixels)?;
let mut image = Image::from_u8(w, h, layout, pixels)?;
let (xdpi, ydpi) = (le16(b, 12), le16(b, 14));
if xdpi > 0 && ydpi > 0 {
image.meta.dpi = Some((f32::from(xdpi), f32::from(ydpi)));
+11 -1
View File
@@ -96,7 +96,7 @@ fn channel(hex: &str) -> Option<u8> {
Some(((v * 255 + max / 2) / max) as u8)
}
fn named(name: &str) -> Option<[u8; 3]> {
pub(crate) fn named(name: &str) -> Option<[u8; 3]> {
let s = name.to_ascii_lowercase().replace([' ', '-', '_'], "");
// XPM imports X11 names, whose RGB values differ from CSS for names
// such as gray, maroon and purple. Keep these exact rather than guessing.
@@ -114,6 +114,16 @@ fn named(name: &str) -> Option<[u8; 3]> {
})
}
/// Exact, normalized X11 lookup for consumers that need table membership rather
/// than XPM's additional aliases and normalization rules.
pub(crate) fn exact_x11_name(name: &str) -> Option<[u8; 3]> {
if name.is_empty() || name.len() > 64 || !name.bytes().all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit()) {
return None;
}
let index = x11_colors::X11_COLORS.binary_search_by_key(&name, |(entry, _)| *entry).ok()?;
Some(x11_colors::X11_COLORS.get(index)?.1)
}
fn color(name: &str) -> Option<[u8; 4]> {
if name.eq_ignore_ascii_case("none") {
return Some([0, 0, 0, 0]);
+11
View File
@@ -237,6 +237,17 @@ pub fn jpeg_info(bytes: &[u8]) -> Option<JpegInfo> {
jpeg::info(bytes)
}
/// PCX's dimensions are available from its fixed-size header without decoding the RLE rows.
pub fn pcx_dimensions(bytes: &[u8]) -> Option<(u32, u32)> {
codecs::pcx::dimensions(bytes)
}
/// The X11 color-name lookup used by XPM files, expressed as normalized sRGB.
pub fn xpm_named_color_rgb(name: &str) -> Option<[f32; 3]> {
let rgb = codecs::xpm::exact_x11_name(name)?;
Some(rgb.map(|channel| f32::from(channel) / 255.0))
}
/// The colour table of a GIF's first frame (its Local Color Table, else the Global one) and the
/// entry its Graphic Control Extension makes transparent, read without decoding pixels.
pub fn gif_palette(bytes: &[u8]) -> Option<(Vec<[u8; 3]>, Option<u8>)> {
+5 -1
View File
@@ -32,6 +32,10 @@ impl Default for Limits {
}
impl Limits {
/// Construct explicit bounds for a caller-owned format adapter.
pub const fn new(max_width: u32, max_height: u32, max_pixels: u64, max_alloc: u64) -> Self {
Limits { max_width, max_height, max_pixels, max_alloc }
}
/// For a decoder that writes a band of rows at a time into the document's tiles instead of
/// one buffer (TIFF, #8169): the largest document size, 300,000 px a side, on 64-bit
/// targets, with `max_alloc` bounding each group of bands. 32-bit targets keep the
@@ -85,7 +89,7 @@ impl Limits {
/// never beats `max_ratio`:1. Called before the output buffer is allocated, so a
/// header-only hostile file cannot make the decoder reserve gigabytes. A fixed 1 MiB of
/// slack keeps tiny images and headers with large metadata unaffected.
pub(crate) fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> {
pub fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> {
let capacity = (file_len as u64).saturating_mul(max_ratio).saturating_add(1 << 20);
if declared_bytes > capacity {
return Err(CodecError::LimitExceeded(format!("a {file_len} byte file cannot hold {declared_bytes} bytes of image data")));
-4
View File
@@ -15,7 +15,3 @@ base64 = "0.23"
craft-image-codecs = { workspace = true }
thiserror = { workspace = true }
image = { version = "0.25", default-features = false }
# The DDS encoder compresses rows of blocks in parallel on native; wasm stays single-threaded.
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
rayon = { workspace = true }
+6 -10
View File
@@ -1,12 +1,9 @@
# craft-raster-codecs
Small raster image formats for the Craft apps, from PhotoCraft's `photocraft-codecs`: one module
per format, one implementation of each. Decoders take untrusted bytes and `Limits`, check the
declared size before allocating, and never panic. No `unsafe`; it builds for
`wasm32-unknown-unknown`. The `common` RGBA image facade delegates PNG/JPEG/BMP/GIF/TIFF/WebP
decoding and PNG/JPEG encoding to [`craft-image-codecs`](../image-codecs/README.md), the shared
depth- and metadata-preserving codec implementation. Other dependencies are `thiserror`, and
`rayon` on native targets (the DDS encoder compresses rows of blocks in parallel).
Compatibility facade for the small raster-format modules in older Craft app versions. The
format readers and writers are implemented once in [`craft-image-codecs`](../image-codecs/README.md);
these modules forward calls and adapt the older `Image` and `Limits` types. The `common` RGBA
image facade also delegates to that crate.
```toml
craft-raster-codecs = { git = "https://github.com/storytold/craft-libs", rev = "<commit>" }
@@ -37,9 +34,8 @@ assert_eq!(image.data(), &[0, 255]);
let bytes = pnm::encode(&image)?;
```
Each module has a `looks_like_*` (or `is_dicom`) sniffer for the format's signature. `dds` and
`fits` also have `has_additional_images`, which says without decoding whether a file holds
more than the one image `decode` returns (cube faces, array slices, further HDUs).
The module sniffers and the `dds`/`fits` additional-image queries forward to shared detection and
metadata inspection in `craft-image-codecs`.
`xpm::x11_color_rgb` also looks up exact normalized X11 names as RGB channels in `0..=1`.
It accepts only 1–64 lowercase ASCII letters or digits, without normalization, XPM-only aliases,
+79
View File
@@ -0,0 +1,79 @@
//! Compatibility between this crate's small-format facade and the canonical image codec model.
use crate::{ChannelLayout, CodecError, DecodeWarning, Image, Limits, SampleType};
use craft_image_codecs::{DecodeOptions, Format, Metadata};
pub(crate) fn format(format: Format, bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
let shared_limits = craft_image_codecs::Limits::new(limits.max_width, limits.max_height, limits.max_pixels, limits.max_alloc);
let options = DecodeOptions { limits: shared_limits, ..DecodeOptions::default() };
let image = craft_image_codecs::decode_as_with(format, bytes, &options).map_err(from_shared_error)?;
from_shared_image(image)
}
pub(crate) fn shared_image(image: &Image) -> Result<craft_image_codecs::Image, CodecError> {
let layout = match image.layout() {
ChannelLayout::Gray => craft_image_codecs::ChannelLayout::Gray,
ChannelLayout::GrayA => craft_image_codecs::ChannelLayout::GrayA,
ChannelLayout::Rgb => craft_image_codecs::ChannelLayout::Rgb,
ChannelLayout::Rgba => craft_image_codecs::ChannelLayout::Rgba,
ChannelLayout::Cmyk => craft_image_codecs::ChannelLayout::Cmyk,
ChannelLayout::CmykA => craft_image_codecs::ChannelLayout::CmykA,
};
let sample = match image.sample_type() {
SampleType::U8 => craft_image_codecs::SampleType::U8,
SampleType::U16 => craft_image_codecs::SampleType::U16,
SampleType::F32 => craft_image_codecs::SampleType::F32,
};
let meta = Metadata { dpi: image.dpi, text: image.text.clone(), ..Metadata::default() };
craft_image_codecs::Image::from_raw(image.width(), image.height(), layout, sample, image.data().to_vec())
.map(|image| image.with_meta(meta))
.map_err(from_shared_error)
}
fn from_shared_image(image: craft_image_codecs::Image) -> Result<Image, CodecError> {
let layout = match image.layout() {
craft_image_codecs::ChannelLayout::Gray => ChannelLayout::Gray,
craft_image_codecs::ChannelLayout::GrayA => ChannelLayout::GrayA,
craft_image_codecs::ChannelLayout::Rgb => ChannelLayout::Rgb,
craft_image_codecs::ChannelLayout::Rgba => ChannelLayout::Rgba,
craft_image_codecs::ChannelLayout::Cmyk => ChannelLayout::Cmyk,
craft_image_codecs::ChannelLayout::CmykA => ChannelLayout::CmykA,
_ => return Err(CodecError::InvalidImage(format!("unsupported small-codec layout {:?}", image.layout()))),
};
let sample = match image.sample_type() {
craft_image_codecs::SampleType::U8 => SampleType::U8,
craft_image_codecs::SampleType::U16 => SampleType::U16,
craft_image_codecs::SampleType::F32 => SampleType::F32,
_ => return Err(CodecError::InvalidImage(format!("unsupported small-codec sample type {:?}", image.sample_type()))),
};
let mut out = Image::from_raw(image.width(), image.height(), layout, sample, image.data().to_vec())?;
out.dpi = image.meta.dpi;
out.text = image.meta.text;
out.warnings = image
.warnings
.into_iter()
.filter_map(|warning| match warning {
craft_image_codecs::DecodeWarning::MorePages { total } | craft_image_codecs::DecodeWarning::MoreParts { total } => {
Some(DecodeWarning::MorePages { total })
}
_ => None,
})
.collect();
Ok(out)
}
pub(crate) fn from_shared_error(error: craft_image_codecs::CodecError) -> CodecError {
match error {
craft_image_codecs::CodecError::UnknownFormat => CodecError::unsupported("image", "unrecognized image format"),
craft_image_codecs::CodecError::Unsupported { format, reason } => CodecError::unsupported(format.name(), reason),
craft_image_codecs::CodecError::Malformed { format, message } => CodecError::malformed(format.name(), message),
craft_image_codecs::CodecError::LimitExceeded(message) => CodecError::LimitExceeded(message),
craft_image_codecs::CodecError::Encode { format, message } => CodecError::Encode { format: format.name(), message },
craft_image_codecs::CodecError::InvalidImage(message) => CodecError::InvalidImage(message),
}
}
pub(crate) fn encode(image: &Image, format: Format, options: &craft_image_codecs::EncodeOptions) -> Result<Vec<u8>, CodecError> {
let image = shared_image(image)?;
craft_image_codecs::encode(&image, format, options).map_err(from_shared_error)
}
+40 -581
View File
@@ -1,616 +1,75 @@
//! 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.
//! DDS compatibility facade; implementation and BC block codecs live in craft-image-codecs.
use crate::{CodecError, Image, Limits, SampleType, bridge};
use craft_image_codecs::Format;
use std::borrow::Cow;
use crate::dds_bc::{self, Block, Mask};
use crate::{ChannelLayout, CodecError, Image, Limits, SampleType};
/// `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("DDS", reason)
pub fn looks_like_dds(bytes: &[u8]) -> bool {
craft_image_codecs::detect(bytes) == Some(Format::Dds)
}
fn unsupported(reason: impl Into<String>) -> CodecError {
CodecError::unsupported("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))
}
/// The `DDS ` magic.
pub fn looks_like_dds(b: &[u8]) -> bool {
b.starts_with(b"DDS ")
}
/// Header-declared extra subresources cannot survive a single-image rewrite, even without presence flags.
pub 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)
craft_image_codecs::has_unretained_source_data(bytes).map_err(bridge::from_shared_error)
}
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
bridge::format(Format::Dds, bytes, limits)
}
/// 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)"))),
}
}
pub 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("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`.
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))
}
/// 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 const ALL: [Self; 4] = [Self::None, Self::Bc1, Self::Bc2, Self::Bc3];
pub fn name(self) -> &'static str {
match self {
DdsCompression::None => "none",
DdsCompression::Bc1 => "bc1",
DdsCompression::Bc2 => "bc2",
DdsCompression::Bc3 => "bc3",
Self::None => "none",
Self::Bc1 => "bc1",
Self::Bc2 => "bc2",
Self::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" => Some(Self::None),
"bc1" | "dxt1" => Some(Self::Bc1),
"bc2" | "dxt3" => Some(Self::Bc2),
"bc3" | "dxt5" => Some(Self::Bc3),
_ => None,
}
}
/// A block compression (lossy), not uncompressed pixels.
pub fn is_block(self) -> bool {
self != DdsCompression::None
self != Self::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,
}
/// Writes `img` (8 bits per channel) as a DDS texture. Uncompressed stores gray, gray with
/// alpha, RGB and RGBA; the block compressions take RGBA only.
pub fn encode(img: &Image, opts: DdsOptions) -> Result<Vec<u8>, CodecError> {
if img.sample_type() != SampleType::U8 {
return Err(encode_err("DDS is written at 8 bits per channel"));
pub fn encode(image: &Image, options: DdsOptions) -> Result<Vec<u8>, CodecError> {
if image.sample_type() != SampleType::U8 {
return Err(CodecError::encode("DDS", "DDS is written at 8 bits per channel"));
}
let pixels = img.data();
let store = Store::new(opts.compression, img.layout())?;
let (width, height) = (img.width(), img.height());
let levels = if opts.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::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());
}
// BC storage encodes RGBA blocks. The generic image API can plan a
// conversion from other layouts, but this compatibility facade accepts
// only layouts its former writer stored directly.
let allowed = if options.compression.is_block() {
image.layout() == crate::ChannelLayout::Rgba
} else {
matches!(image.layout(), crate::ChannelLayout::Gray | crate::ChannelLayout::GrayA | crate::ChannelLayout::Rgb | crate::ChannelLayout::Rgba)
};
// 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);
if !allowed {
return Err(CodecError::encode("DDS", format!("{:?} pixels can't be written as `{}`", image.layout(), options.compression.name())));
}
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::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 compression = match options.compression {
DdsCompression::None => craft_image_codecs::DdsCompression::None,
DdsCompression::Bc1 => craft_image_codecs::DdsCompression::Bc1,
DdsCompression::Bc2 => craft_image_codecs::DdsCompression::Bc2,
DdsCompression::Bc3 => craft_image_codecs::DdsCompression::Bc3,
};
let opts =
craft_image_codecs::EncodeOptions { dds: craft_image_codecs::DdsOptions { compression, mipmaps: options.mipmaps }, ..Default::default() };
bridge::encode(image, Format::Dds, &opts)
}
-369
View File
@@ -1,369 +0,0 @@
//! BC1, BC2 and BC3 (DXT1, DXT3, DXT5) 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.
//!
//! 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
//! reader rebuilds, so the indices it picks are the best ones for what a decoder shows.
/// The 16 texels of a 4×4 block, row by row, as RGBA.
pub(crate) type Block = [[u8; 4]; 16];
/// Bit `t` set for each texel `t` of a block that counts: edge blocks of a texture whose size is
/// not a multiple of four have texels outside the image.
pub(crate) type Mask = u16;
pub(crate) fn rgb565(c: u16) -> [u8; 3] {
let scale = |v: u16, max: u16| ((u32::from(v) * 255 + u32::from(max) / 2) / u32::from(max)) as u8;
[scale(c >> 11, 31), scale((c >> 5) & 63, 63), scale(c & 31, 31)]
}
/// The colours a colour block's indices select. Four-colour mode (BC1 with `c0 > c1`, and every
/// BC2 and BC3 block) adds two colours at thirds; three-colour mode adds the midpoint and
/// transparent black.
pub(crate) fn colour_palette(c0: u16, c1: u16, four: bool) -> [[u8; 4]; 4] {
let (a, b) = (rgb565(c0), rgb565(c1));
let mix = |wa: u32, wb: u32| {
let d = wa + wb;
let at = |i: usize| ((wa * u32::from(a[i]) + wb * u32::from(b[i]) + d / 2) / d) as u8;
[at(0), at(1), at(2), 255]
};
if four {
[[a[0], a[1], a[2], 255], [b[0], b[1], b[2], 255], mix(2, 1), mix(1, 2)]
} else {
[[a[0], a[1], a[2], 255], [b[0], b[1], b[2], 255], mix(1, 1), [0; 4]]
}
}
/// A BC3 alpha 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));
let mut palette = [a0, a1, 0, 0, 0, 0, 0, 255];
if a0 > a1 {
for (k, v) in palette.iter_mut().enumerate().skip(2) {
let k = k as u32;
*v = ((8 - k) * a0 + (k - 1) * a1 + 3) / 7;
}
} else {
for (k, v) in palette.iter_mut().enumerate().take(6).skip(2) {
let k = k as u32;
*v = ((6 - k) * a0 + (k - 1) * a1 + 2) / 5;
}
}
palette.map(|v| v as u8)
}
/// 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] {
let transparent = select(block, inside, |t| t[3] < 128);
colour_block(block, inside & !transparent, transparent, true)
}
/// A BC2 block: four bits of alpha per texel, then a four-colour block.
pub(crate) fn encode_bc2(block: &Block, inside: Mask) -> [u8; 16] {
let bits = block.iter().enumerate().fold(0u64, |bits, (t, texel)| bits | ((u64::from(texel[3]) * 15 + 127) / 255) << (4 * t));
join(bits.to_le_bytes(), colour_block(block, inside, 0, false))
}
/// 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))
}
fn join(a: [u8; 8], b: [u8; 8]) -> [u8; 16] {
std::array::from_fn(|i| if i < 8 { a.get(i) } else { b.get(i - 8) }.copied().unwrap_or(0))
}
/// The texels of `inside` for which `f` holds.
fn select(block: &Block, inside: Mask, f: impl Fn(&[u8; 4]) -> bool) -> Mask {
block.iter().enumerate().filter(|(t, texel)| inside >> t & 1 != 0 && f(texel)).fold(0, |m, (t, _)| m | 1 << t)
}
fn rgb_of(texel: &[u8; 4]) -> [f32; 3] {
[f32::from(texel[0]), f32::from(texel[1]), f32::from(texel[2])]
}
/// RGB565 of a colour, rounding each channel to the nearest level.
fn to565(c: [f32; 3]) -> u16 {
let q = |v: f32, max: f32| (v.clamp(0.0, 255.0) * max / 255.0).round() as u16;
q(c[0], 31.0) << 11 | q(c[1], 63.0) << 5 | q(c[2], 31.0)
}
fn distance(a: &[u8; 4], b: &[u8; 4]) -> u32 {
(0..3).map(|i| u32::from(a[i].abs_diff(b[i])).pow(2)).sum()
}
/// 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() {
// 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))];
let modes: &[bool] = if transparent != 0 {
&[false]
} else if bc1 {
&[true, false]
} else {
&[true]
};
let mut best: Option<(u32, [u8; 8])> = None;
// 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 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() {
break;
}
}
best.map_or([0; 8], |(_, bytes)| bytes)
}
/// Orders endpoints `e0`, `e1` for the mode (`c0 > c1` for four colours, `c0 <= c1` for three)
/// and picks each texel's nearest palette colour. Returns the block and its squared error.
fn fit(block: &Block, opaque: Mask, transparent: Mask, e0: u16, e1: u16, four: bool) -> ([u8; 8], u32) {
let (c0, c1) = if four == (e0 >= e1) { (e0, e1) } else { (e1, e0) };
// Equal endpoints can't be in four-colour order; the palette is then one colour either way.
let palette = colour_palette(c0, c1, four && c0 > c1);
let choices = if four && c0 > c1 { 4 } else { 3 };
let mut indices = 0u32;
let mut error = 0u32;
for (t, texel) in block.iter().enumerate() {
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));
error += d;
i as u32
} else {
0
};
indices |= index << (2 * t);
}
(pack(c0, c1, indices), error)
}
fn pack(c0: u16, c1: u16, indices: u32) -> [u8; 8] {
let (c0, c1, i) = (c0.to_le_bytes(), c1.to_le_bytes(), indices.to_le_bytes());
[c0[0], c0[1], c1[0], c1[1], i[0], i[1], i[2], i[3]]
}
/// The ends of the colours' spread along their principal axis (the covariance's dominant
/// eigenvector, by power iteration), clamped to the RGB cube.
fn principal_endpoints(colours: &[[f32; 3]]) -> ([f32; 3], [f32; 3]) {
let n = colours.len().max(1) as f32;
let mean = [0, 1, 2].map(|i| colours.iter().map(|c| c[i]).sum::<f32>() / n);
let mut cov = [[0f32; 3]; 3];
for c in colours {
let d = [c[0] - mean[0], c[1] - mean[1], c[2] - mean[2]];
for (i, row) in cov.iter_mut().enumerate() {
for (j, v) in row.iter_mut().enumerate() {
*v += d[i] * d[j];
}
}
}
let times = |a: [f32; 3]| [0, 1, 2].map(|i| cov[i][0] * a[0] + cov[i][1] * a[1] + cov[i][2] * a[2]);
let iterate = |start: usize| {
let mut axis = [0f32; 3];
axis[start] = 1.0;
for _ in 0..8 {
let next = times(axis);
let len = next.iter().map(|v| v * v).sum::<f32>().sqrt();
if !len.is_normal() {
break;
}
axis = next.map(|v| v / len);
}
axis
};
// From each channel's axis, keeping the one the colours spread along most: a channel that
// varies on its own is already an eigenvector, so a single start there would never leave it
// even when the others vary more together.
let spread = |a: [f32; 3]| times(a).iter().zip(a).map(|(x, y)| x * y).sum::<f32>();
let axis = [0, 1, 2].map(iterate).into_iter().max_by(|&a, &b| spread(a).total_cmp(&spread(b))).unwrap_or([1.0, 0.0, 0.0]);
let along = |c: &[f32; 3]| (c[0] - mean[0]) * axis[0] + (c[1] - mean[1]) * axis[1] + (c[2] - mean[2]) * axis[2];
let (lo, hi) = colours.iter().map(along).fold((f32::MAX, f32::MIN), |(lo, hi), t| (lo.min(t), hi.max(t)));
let at = |t: f32| [0, 1, 2].map(|i| (mean[i] + t * axis[i]).clamp(0.0, 255.0));
if lo > hi { (mean, mean) } else { (at(lo), at(hi)) }
}
/// The endpoints that minimise the squared error for the indices `bytes` already chose: each
/// texel's index fixes its weights between the endpoints, giving 2×2 normal equations per
/// channel. `None` when the indices don't constrain both endpoints.
fn least_squares(block: &Block, opaque: Mask, bytes: &[u8; 8]) -> Option<(u16, u16)> {
let (c0, c1) = (u16::from_le_bytes([bytes[0], bytes[1]]), u16::from_le_bytes([bytes[2], bytes[3]]));
let indices = u32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]);
let four = c0 > c1;
// How much of c0 each index holds.
let weight = |i: u32| match (four, i) {
(_, 0) => Some(1.0f32),
(_, 1) => Some(0.0),
(true, 2) => Some(2.0 / 3.0),
(true, _) => Some(1.0 / 3.0),
(false, 2) => Some(0.5),
(false, _) => None,
};
let (mut aa, mut ab, mut bb) = (0f32, 0f32, 0f32);
let (mut ax, mut bx) = ([0f32; 3], [0f32; 3]);
for (t, texel) in block.iter().enumerate() {
if opaque >> t & 1 == 0 {
continue;
}
let Some(a) = weight(indices >> (2 * t) & 3) else { continue };
let b = 1.0 - a;
let c = rgb_of(texel);
aa += a * a;
ab += a * b;
bb += b * b;
for ((x0, x1), v) in ax.iter_mut().zip(bx.iter_mut()).zip(c) {
*x0 += a * v;
*x1 += b * v;
}
}
let det = aa * bb - ab * ab;
if det.abs() < 1e-3 {
return None;
}
let e0 = [0, 1, 2].map(|i| (ax[i] * bb - bx[i] * ab) / det);
let e1 = [0, 1, 2].map(|i| (bx[i] * aa - ax[i] * ab) / det);
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));
// 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);
if six.1 < eight.1 { six.0 } else { eight.0 }
}
fn alpha_fit(block: &Block, 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() {
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));
error += d;
bits |= (i as u64) << (3 * t);
}
let b = bits.to_le_bytes();
([a0, a1, b[0], b[1], b[2], b[3], b[4], b[5]], error)
}
#[cfg(test)]
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]] {
let block = [colour; 16];
let out = decode_colour(&encode_bc1(&block, u16::MAX), true);
for texel in out {
assert!(texel.iter().zip(colour).all(|(a, b)| a.abs_diff(b) <= 4), "{texel:?} for {colour:?}");
}
}
}
#[test]
fn two_colour_blocks_are_exact_when_the_colours_are_565() {
let (a, b) = ([255, 0, 0, 255], [0, 0, 255, 255]);
let block: Block = std::array::from_fn(|t| if t % 3 == 0 { a } else { b });
for bc1 in [true, false] {
let bytes = if bc1 { encode_bc1(&block, u16::MAX) } else { colour_block(&block, u16::MAX, 0, false) };
assert_eq!(decode_colour(&bytes, bc1), block);
}
}
#[test]
fn bc1_punches_through_texels_under_half_alpha() {
let block: Block = std::array::from_fn(|t| if t < 8 { [200, 100, 50, 255] } else { [9, 9, 9, 127] });
let bytes = encode_bc1(&block, u16::MAX);
let (c0, c1) = (u16::from_le_bytes([bytes[0], bytes[1]]), u16::from_le_bytes([bytes[2], bytes[3]]));
assert!(c0 <= c1, "three-colour mode");
let out = decode_colour(&bytes, true);
assert!(out[..8].iter().all(|t| t[3] == 255) && out[8..].iter().all(|t| *t == [0; 4]), "{out:?}");
}
#[test]
fn four_colour_blocks_keep_c0_above_c1() {
// A ramp needs all four colours; BC2 and BC3 blocks must not rely on the order, but
// older decoders read c0 <= c1 as three colours, so the encoder never writes that.
let block: Block = std::array::from_fn(|t| [(t * 16) as u8, 0, 0, 255]);
let bytes = colour_block(&block, u16::MAX, 0, false);
assert!(u16::from_le_bytes([bytes[0], bytes[1]]) > u16::from_le_bytes([bytes[2], bytes[3]]));
}
#[test]
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);
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]);
for (t, texel) in block.iter().enumerate() {
let got = palette[(bits >> (3 * t)) as usize & 7];
assert!(got.abs_diff(texel[3]) <= 2, "texel {t}: {got} for {}", texel[3]);
}
}
#[test]
fn the_principal_axis_is_found_when_one_channel_varies_on_its_own() {
// Red alternates on its own (variance 64); green and blue alternate together (variance 49
// each, 98 along their shared axis), uncorrelated with red. Starting on red alone would
// keep red's axis and flatten green and blue; the block must do better than its bounding box.
let block: Block = std::array::from_fn(|t| {
let gb = if (t / 2) % 2 == 0 { 121 } else { 135 };
[if t % 2 == 0 { 120 } else { 136 }, gb, gb, 255]
});
let error = |bytes: &[u8; 8]| decode_colour(bytes, false).iter().zip(&block).map(|(a, b)| distance(a, b)).sum::<u32>();
let (_, bounding_box) = fit(&block, u16::MAX, 0, to565([120.0, 121.0, 121.0]), to565([136.0, 135.0, 135.0]), true);
let ours = error(&colour_block(&block, u16::MAX, 0, false));
assert!(ours < bounding_box, "{ours} vs the bounding box's {bounding_box}");
}
#[test]
fn texels_outside_the_image_are_ignored() {
// Only the top-left texel is inside: its colour alone decides the endpoints.
let mut block: Block = [[0, 255, 0, 255]; 16];
block[0] = [255, 0, 255, 255];
let out = decode_colour(&encode_bc1(&block, 1), true);
assert_eq!(out[0], [255, 0, 255, 255]);
}
}
+7 -523
View File
@@ -1,526 +1,10 @@
//! DICOM (medical imaging) reader, uncompressed transfer syntaxes only.
//!
//! Supports what a viewer needs from a single-frame image: MONOCHROME1/2 (gray) and RGB or
//! YBR_FULL, 8- and 16-bit samples, interleaved or planar, both byte orders and explicit or
//! implicit VR. Undefined-length sequences outside the pixel data are skipped (clinical files
//! contain them); compressed transfer syntaxes, encapsulated pixel data and other photometric
//! interpretations are refused with a clear error. Read-only in this crate.
//! DICOM compatibility facade; implementation and detection live in craft-image-codecs.
use crate::{CodecError, Image, Limits, bridge};
use craft_image_codecs::Format;
use std::collections::HashMap;
use crate::{ChannelLayout, CodecError, Image, Limits, SampleType};
const F: &str = "DICOM";
const PREAMBLE: usize = 132; // 128 zero bytes + "DICM"
const UNDEFINED: u32 = 0xFFFF_FFFF;
fn bad(msg: impl std::fmt::Display) -> CodecError {
CodecError::malformed(F, msg)
pub fn is_dicom(bytes: &[u8]) -> bool {
craft_image_codecs::detect(bytes) == Some(Format::Dicom)
}
/// A DICOM file begins with a 128-byte preamble and the `DICM` magic.
pub fn is_dicom(b: &[u8]) -> bool {
b.get(128..132) == Some(b"DICM")
}
#[derive(Clone, Copy)]
struct Endian {
big: bool,
}
/// The transfer syntax: byte order and whether value representations are explicit.
#[derive(Clone, Copy)]
struct Syntax {
endian: Endian,
explicit: bool,
}
/// The value representations whose length field is 2 reserved bytes + `u32` in explicit VR.
fn long_vr(vr: &[u8]) -> bool {
matches!(vr, b"OB" | b"OW" | b"OF" | b"SQ" | b"UT" | b"UN" | b"OD" | b"OL" | b"OV" | b"UC" | b"UR")
}
/// A cursor over the byte stream.
struct Cur<'a> {
b: &'a [u8],
pos: usize,
big: bool,
}
impl<'a> Cur<'a> {
fn take(&mut self, n: usize) -> Option<&'a [u8]> {
let s = self.b.get(self.pos..self.pos.checked_add(n)?)?;
self.pos += n;
Some(s)
}
fn u16(&mut self) -> Option<u16> {
let c = self.take(2)?;
Some(if self.big { u16::from_be_bytes([c[0], c[1]]) } else { u16::from_le_bytes([c[0], c[1]]) })
}
fn u32(&mut self) -> Option<u32> {
let c = self.take(4)?;
Some(if self.big { u32::from_be_bytes([c[0], c[1], c[2], c[3]]) } else { u32::from_le_bytes([c[0], c[1], c[2], c[3]]) })
}
/// Skip `len` bytes, refusing to run past the buffer.
fn skip(&mut self, len: usize) -> Result<(), CodecError> {
self.pos = self.pos.checked_add(len).filter(|p| *p <= self.b.len()).ok_or_else(|| bad("a value runs past the end of the file"))?;
Ok(())
}
}
/// Read one element's tag and value length, leaving the cursor at the value. Item and delimiter
/// tags (group `FFFE`) carry a `u32` length with no VR even under explicit VR.
fn read_header(c: &mut Cur, syn: &Syntax) -> Result<(u16, u16, [u8; 2], u32), CodecError> {
let group = c.u16().ok_or_else(|| bad("truncated element tag"))?;
let elem = c.u16().ok_or_else(|| bad("truncated element tag"))?;
let (vr, len) = if group == 0xFFFE {
([0, 0], c.u32().ok_or_else(|| bad("truncated item length"))?)
} else if syn.explicit {
let vr = c.take(2).ok_or_else(|| bad("truncated VR"))?;
let v = [vr[0], vr[1]];
let len = if long_vr(&v) {
c.take(2).ok_or_else(|| bad("truncated VR"))?; // reserved
c.u32().ok_or_else(|| bad("truncated length"))?
} else {
u32::from(c.u16().ok_or_else(|| bad("truncated length"))?)
};
(v, len)
} else {
([0, 0], c.u32().ok_or_else(|| bad("truncated length"))?)
};
Ok((group, elem, vr, len))
}
/// Skip an undefined-length sequence, ending just after its `FFFE,E0DD` delimiter. Nesting is
/// tracked through undefined-length items and nested sequences; everything else is skipped by
/// its length. Returns the position after the delimiter.
fn skip_undefined(c: &mut Cur, syn: &Syntax) -> Result<(), CodecError> {
let mut depth = 1u32;
while depth > 0 {
let (group, elem, _, len) = read_header(c, syn)?;
// Item (E00D) and sequence (E0DD) delimiters close one undefined length; they carry no
// content of their own.
if group == 0xFFFE && matches!(elem, 0xE00D | 0xE0DD) {
depth -= 1;
continue;
}
if len == UNDEFINED {
depth += 1;
} else {
c.skip(len as usize)?;
}
}
Ok(())
}
/// Walk the elements from `start`, calling `f` with each `(group, element, value)`. An
/// undefined-length sequence outside the pixel data is skipped; encapsulated (undefined-length)
/// pixel data is refused. Returns the number of bytes walked.
fn elements(b: &[u8], start: usize, syn: &Syntax, mut f: impl FnMut(u16, u16, &Elem) -> Result<(), CodecError>) -> Result<usize, CodecError> {
let mut c = Cur { b, pos: start, big: syn.endian.big };
loop {
if c.pos >= b.len() {
return Ok(c.pos - start);
}
let (group, elem, vr, len) = read_header(&mut c, syn)?;
if len == UNDEFINED {
if (group, elem) == (0x7FE0, 0x0010) {
return Err(CodecError::unsupported(F, "encapsulated (compressed) pixel data"));
}
skip_undefined(&mut c, syn)?;
continue;
}
let len = len as usize;
let start = c.pos;
if b.len() < start.saturating_add(len) {
return Err(bad("an element value runs past the end of the file"));
}
f(group, elem, &Elem { vr, start, len })?;
c.pos = start + len;
}
}
/// A parsed element: its VR and the byte range of its value.
struct Elem {
vr: [u8; 2],
start: usize,
len: usize,
}
fn u16_val(b: &[u8], e: &Elem, big: bool) -> Option<u16> {
let c = b.get(e.start..e.start.checked_add(2)?)?;
Some(if big { u16::from_be_bytes([c[0], c[1]]) } else { u16::from_le_bytes([c[0], c[1]]) })
}
/// The transfer syntax (byte order and explicit/implicit VR) and the data-set start. The file
/// meta group is always explicit VR little-endian; the data set follows its `(0002,0010)`
/// TransferSyntaxUID.
fn transfer_syntax(b: &[u8]) -> Result<(Syntax, usize), CodecError> {
let meta = Syntax { endian: Endian { big: false }, explicit: true };
let mut ts: Option<String> = None;
let mut data_start = b.len();
let mut c = Cur { b, pos: PREAMBLE, big: false };
while c.pos + 8 <= b.len() {
let save = c.pos;
let (group, elem, _, len) = read_header(&mut c, &meta)?;
if group != 0x0002 {
// A non-meta group begins the data set.
data_start = save;
break;
}
if len == UNDEFINED {
return Err(CodecError::unsupported(F, "undefined-length meta element"));
}
let start = c.pos;
if b.len() < start.saturating_add(len as usize) {
return Err(bad("a meta element runs past the end of the file"));
}
if elem == 0x0010 {
ts = Some(String::from_utf8_lossy(&b[start..start + len as usize]).trim_end_matches(['\0', ' ']).to_string());
}
c.pos = start + len as usize;
}
let syn = match ts.as_deref() {
Some("1.2.840.10008.1.2") => Syntax { endian: Endian { big: false }, explicit: false },
Some("1.2.840.10008.1.2.1") => Syntax { endian: Endian { big: false }, explicit: true },
Some("1.2.840.10008.1.2.2") => Syntax { endian: Endian { big: true }, explicit: true },
Some(other) => return Err(CodecError::unsupported(F, format!("transfer syntax {other} (only uncompressed is read)"))),
// No meta: the historical default is implicit VR little-endian.
None => Syntax { endian: Endian { big: false }, explicit: false },
};
Ok((syn, data_start))
}
pub fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
if !is_dicom(b) {
return Err(bad("not a DICOM file (no DICM magic)"));
}
let (syn, start) = transfer_syntax(b)?;
let mut tags: HashMap<(u16, u16), Elem> = HashMap::new();
elements(b, start, &syn, |g, e, el| {
// Later duplicates must not silently override the first (DICOM forbids duplicates).
tags.entry((g, e)).or_insert_with(|| Elem { vr: el.vr, start: el.start, len: el.len });
Ok(())
})?;
let big = syn.endian.big;
let get_u16 = |tag: (u16, u16)| tags.get(&tag).and_then(|e| u16_val(b, e, big));
let rows = u32::from(get_u16((0x0028, 0x0010)).ok_or_else(|| bad("missing Rows (0028,0010)"))?);
let cols = u32::from(get_u16((0x0028, 0x0011)).ok_or_else(|| bad("missing Columns (0028,0011)"))?);
let samples = u32::from(get_u16((0x0028, 0x0002)).unwrap_or(1));
let bits = get_u16((0x0028, 0x0100)).ok_or_else(|| bad("missing BitsAllocated (0028,0100)"))?;
let bits_stored = get_u16((0x0028, 0x0101)).unwrap_or(bits);
let high_bit = get_u16((0x0028, 0x0102)).unwrap_or(bits_stored.saturating_sub(1));
if u32::from(high_bit) >= u32::from(bits) {
return Err(bad("HighBit is outside the allocated bits"));
}
let signed = get_u16((0x0028, 0x0103)).unwrap_or(0) == 1;
let planar = get_u16((0x0028, 0x0006)).unwrap_or(0);
let photometric = tags
.get(&(0x0028, 0x0004))
.and_then(|e| b.get(e.start..e.start.checked_add(e.len)?))
.map(|v| String::from_utf8_lossy(v).trim_end_matches(['\0', ' ']).to_string())
.ok_or_else(|| bad("missing PhotometricInterpretation (0028,0004)"))?;
let pixel = tags.get(&(0x7FE0, 0x0010)).ok_or_else(|| CodecError::unsupported(F, "no pixel data (7FE0,0010)"))?;
if !matches!(bits, 8 | 16) || !matches!(bits_stored, 1..=16) {
return Err(CodecError::unsupported(F, format!("{bits}-bit allocated / {bits_stored}-bit stored samples")));
}
let mono = matches!(photometric.as_str(), "MONOCHROME1" | "MONOCHROME2");
let rgb = photometric == "RGB";
let ybr = photometric == "YBR_FULL";
if !(mono || rgb || ybr) {
return Err(CodecError::unsupported(F, format!("photometric interpretation {photometric}")));
}
// Mono stores one sample; RGB and YBR_FULL store three. Any other count would index past the
// pixel data, so it is refused rather than misread.
let want_samples = if mono { 1 } else { 3 };
if samples != want_samples {
return Err(CodecError::unsupported(F, format!("{samples} samples per pixel with {photometric}")));
}
if ybr && bits != 8 {
return Err(CodecError::unsupported(F, format!("{bits}-bit {photometric} (8-bit only)")));
}
let layout = if mono { ChannelLayout::Gray } else { ChannelLayout::Rgb };
let out_sample = if bits == 8 { SampleType::U8 } else { SampleType::U16 };
limits.check(cols, rows, layout, out_sample)?;
let pixels = (cols as usize).checked_mul(rows as usize).ok_or_else(|| CodecError::LimitExceeded("image too large".into()))?;
let n = pixels.checked_mul(samples as usize).ok_or_else(|| CodecError::LimitExceeded("image too large".into()))?;
let bytes_per = if bits == 16 { 2usize } else { 1 };
let need = n.checked_mul(bytes_per).ok_or_else(|| CodecError::LimitExceeded("pixel data too large".into()))?;
let data = b
.get(pixel.start..pixel.start.checked_add(need).ok_or_else(|| CodecError::LimitExceeded("pixel data too large".into()))?)
.ok_or_else(|| bad("pixel data is truncated"))?;
let out_channels = layout.channels();
let out_len =
pixels.checked_mul(out_channels).and_then(|k| k.checked_mul(bytes_per)).ok_or_else(|| CodecError::LimitExceeded("image too large".into()))?;
let mut out = Vec::new();
out.try_reserve_exact(out_len).map_err(|_| CodecError::LimitExceeded("cannot allocate the image".into()))?;
// Raw sample of channel `ch` at pixel `p`, honouring the planar configuration.
let sample_at = |p: usize, ch: usize| -> Option<u32> {
let idx = if planar == 1 { ch.checked_mul(pixels)?.checked_add(p)? } else { p.checked_mul(samples as usize)?.checked_add(ch)? };
let off = idx.checked_mul(bytes_per)?;
if bits == 16 {
let c = data.get(off..off.checked_add(2)?)?;
Some(if big { u16::from_be_bytes([c[0], c[1]]) } else { u16::from_le_bytes([c[0], c[1]]) }.into())
} else {
Some(u32::from(*data.get(off)?))
}
};
let stored_max = f64::from((1u32 << bits_stored) - 1);
// Extract the `bits_stored` samples (the least significant one at `high_bit`) and scale to
// [0, 1]; signed values are shifted up by half a range first. `high_bit` is 1-based here.
let shift = (u32::from(high_bit) + 1).saturating_sub(u32::from(bits_stored));
let mask = (1u32 << bits_stored) - 1;
let half = 1u32 << (bits_stored - 1);
let norm = move |raw: u32| -> f64 {
let v = (raw >> shift) & mask;
// Signed: flip the sign bit to map [-2^(b-1), 2^(b-1)-1] onto [0, 2^b-1].
let v = if signed { v ^ half } else { v };
(f64::from(v) / stored_max).clamp(0.0, 1.0)
};
let q = |x: f64| -> u16 { (x * 65535.0).round() as u16 };
let push = |out: &mut Vec<u8>, x: f64| {
if bits == 8 {
out.push((x * 255.0).round() as u8);
} else {
out.extend_from_slice(&q(x).to_ne_bytes());
}
};
for p in 0..pixels {
let s = |ch: usize| sample_at(p, ch).ok_or_else(|| bad("pixel data is shorter than the image"));
if mono {
let x = norm(s(0)?);
push(&mut out, if photometric == "MONOCHROME1" { 1.0 - x } else { x });
} else if rgb {
for ch in 0..3 {
push(&mut out, norm(s(ch)?));
}
} else {
// YBR_FULL (8-bit): BT.601 full-range to RGB.
let y = f64::from(s(0)?);
let cb = f64::from(s(1)?) - 128.0;
let cr = f64::from(s(2)?) - 128.0;
let r = (y + 1.402 * cr).clamp(0.0, 255.0);
let g = (y - 0.344_136 * cb - 0.714_136 * cr).clamp(0.0, 255.0);
let bl = (y + 1.772 * cb).clamp(0.0, 255.0);
for v in [r, g, bl] {
push(&mut out, v / 255.0);
}
}
}
Image::from_raw(cols, rows, layout, out_sample, out)
}
#[cfg(test)]
mod tests {
use super::*;
/// Build the file meta group (explicit VR little-endian), including the given extra
/// `(element, ascii)` pairs before the TransferSyntaxUID.
fn meta(b: &mut Vec<u8>, ts: &str, extra: &[(u16, &str)]) {
let ui = |e: u16, v: &str, b: &mut Vec<u8>| {
let mut s = v.as_bytes().to_vec();
if s.len() % 2 == 1 {
s.push(0);
}
b.extend_from_slice(&0x0002u16.to_le_bytes());
b.extend_from_slice(&e.to_le_bytes());
b.extend_from_slice(b"UI");
b.extend_from_slice(&(s.len() as u16).to_le_bytes());
b.extend_from_slice(&s);
};
for (e, v) in extra {
ui(*e, v, b);
}
ui(0x0010, ts, b);
}
fn us(b: &mut Vec<u8>, g: u16, e: u16, v: u16, explicit: bool) {
b.extend_from_slice(&g.to_le_bytes());
b.extend_from_slice(&e.to_le_bytes());
if explicit {
b.extend_from_slice(b"US");
b.extend_from_slice(&2u16.to_le_bytes());
} else {
b.extend_from_slice(&2u32.to_le_bytes());
}
b.extend_from_slice(&v.to_le_bytes());
}
fn cs(b: &mut Vec<u8>, g: u16, e: u16, v: &str, explicit: bool) {
let mut s = v.as_bytes().to_vec();
if s.len() % 2 == 1 {
s.push(0);
}
b.extend_from_slice(&g.to_le_bytes());
b.extend_from_slice(&e.to_le_bytes());
if explicit {
b.extend_from_slice(b"CS");
b.extend_from_slice(&(s.len() as u16).to_le_bytes());
} else {
b.extend_from_slice(&(s.len() as u32).to_le_bytes());
}
b.extend_from_slice(&s);
}
/// A DICOM with the given transfer syntax UID and data-set encoding.
#[allow(clippy::too_many_arguments)]
fn synth(
ts: &str,
explicit: bool,
big: bool,
planar: u16,
rows: u16,
cols: u16,
samples: u16,
bits: u16,
photometric: &str,
pixels: &[u8],
) -> Vec<u8> {
let mut b = vec![0u8; 128];
b.extend_from_slice(b"DICM");
// One extra meta element before the syntax, so a reader that only looks at the last
// group-0002 element takes the wrong one.
meta(&mut b, ts, &[(0x0002, "1.2.840.10008.5.1.4.1.1.7")]);
let _ = big;
us(&mut b, 0x0028, 0x0010, rows, explicit);
us(&mut b, 0x0028, 0x0011, cols, explicit);
us(&mut b, 0x0028, 0x0002, samples, explicit);
us(&mut b, 0x0028, 0x0006, planar, explicit);
cs(&mut b, 0x0028, 0x0004, photometric, explicit);
us(&mut b, 0x0028, 0x0100, bits, explicit);
us(&mut b, 0x0028, 0x0101, bits, explicit);
us(&mut b, 0x0028, 0x0102, bits - 1, explicit);
us(&mut b, 0x0028, 0x0103, 0, explicit);
b.extend_from_slice(&0x7FE0u16.to_le_bytes());
b.extend_from_slice(&0x0010u16.to_le_bytes());
if explicit {
b.extend_from_slice(b"OB");
b.extend_from_slice(&0u16.to_le_bytes());
}
b.extend_from_slice(&(pixels.len() as u32).to_le_bytes());
b.extend_from_slice(pixels);
b
}
#[test]
fn decodes_8bit_monochrome() {
let b = synth("1.2.840.10008.1.2.1", true, false, 0, 2, 2, 1, 8, "MONOCHROME2", &[0, 51, 102, 255]);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!((img.width(), img.height(), img.layout(), img.sample_type()), (2, 2, ChannelLayout::Gray, SampleType::U8));
assert_eq!(img.data(), &[0, 51, 102, 255]);
}
#[test]
fn decodes_16bit_monochrome_and_scales() {
let px: Vec<u8> = [0u16, 32768, 65535].iter().flat_map(|v| v.to_le_bytes()).collect();
let b = synth("1.2.840.10008.1.2.1", true, false, 0, 3, 1, 1, 16, "MONOCHROME2", &px);
let img = decode(&b, &Limits::default()).unwrap();
let v = img.to_u16_samples().unwrap();
assert_eq!(v[0], 0);
assert!((i32::from(v[1]) - 32768).abs() <= 1);
assert_eq!(v[2], 65535);
}
#[test]
fn monochrome1_is_inverted() {
let b = synth("1.2.840.10008.1.2.1", true, false, 0, 2, 1, 1, 8, "MONOCHROME1", &[0, 255]);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.data(), &[255, 0]);
}
#[test]
fn decodes_rgb_interleaved_and_planar() {
// 2 pixels: (10,20,30) and (40,50,60).
let interleaved = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 2, 3, 8, "RGB", &[10, 20, 30, 40, 50, 60]);
let img = decode(&interleaved, &Limits::default()).unwrap();
assert_eq!((img.layout(), img.data()), (ChannelLayout::Rgb, &[10u8, 20, 30, 40, 50, 60][..]));
// Planar 0: R plane, then G, then B.
let planar = synth("1.2.840.10008.1.2.1", true, false, 1, 1, 2, 3, 8, "RGB", &[10, 40, 20, 50, 30, 60]);
let img = decode(&planar, &Limits::default()).unwrap();
assert_eq!(img.data(), &[10, 20, 30, 40, 50, 60]);
}
#[test]
fn decodes_ybr_full_to_rgb() {
// White (Y=128, Cb=Cr=128) stays neutral grey.
let b = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 1, 3, 8, "YBR_FULL", &[128, 128, 128]);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.layout(), ChannelLayout::Rgb);
let d = img.data();
assert!(d[0].abs_diff(d[1]) <= 1 && d[1].abs_diff(d[2]) <= 1, "{d:?}");
}
#[test]
fn decodes_implicit_vr() {
let b = synth("1.2.840.10008.1.2", false, false, 0, 2, 2, 1, 8, "MONOCHROME2", &[0, 51, 102, 255]);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.layout(), ChannelLayout::Gray);
assert_eq!(img.data(), &[0, 51, 102, 255]);
}
#[test]
fn skips_an_undefined_length_sequence_outside_the_pixel_data() {
// Insert an undefined-length SQ (0008,2218) with one item, then a defined-length one,
// before the pixel data: the reader must skip both and still decode the image.
let mut b = vec![0u8; 128];
b.extend_from_slice(b"DICM");
meta(&mut b, "1.2.840.10008.1.2.1", &[]);
for (g, e, v) in [
(0x0028, 0x0010, 1u16),
(0x0028, 0x0011, 1),
(0x0028, 0x0002, 1),
(0x0028, 0x0100, 8),
(0x0028, 0x0101, 8),
(0x0028, 0x0102, 7),
(0x0028, 0x0103, 0),
] {
us(&mut b, g, e, v, true);
}
cs(&mut b, 0x0028, 0x0004, "MONOCHROME2", true);
// Undefined-length sequence (0008,2211), one undefined-length item containing a nested
// defined-length sequence, then the delimiters.
b.extend_from_slice(&[0x08, 0x00, 0x11, 0x22, b'S', b'Q', 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF]);
b.extend_from_slice(&[0xFE, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF]); // item, undefined
b.extend_from_slice(&[0x08, 0x00, 0x55, 0x22, b'S', b'Q', 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 1, 2, 3, 4]); // nested, defined
b.extend_from_slice(&[0xFE, 0xFF, 0x0D, 0xE0, 0x00, 0x00, 0x00, 0x00]); // item delimitation
b.extend_from_slice(&[0xFE, 0xFF, 0xDD, 0xE0, 0x00, 0x00, 0x00, 0x00]); // sequence delimitation
// Pixel data (defined length).
b.extend_from_slice(&0x7FE0u16.to_le_bytes());
b.extend_from_slice(&0x0010u16.to_le_bytes());
b.extend_from_slice(b"OB");
b.extend_from_slice(&0u16.to_le_bytes());
b.extend_from_slice(&1u32.to_le_bytes());
b.push(200);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.data(), &[200]);
}
#[test]
fn truncated_and_bad_is_error_not_panic() {
let b = synth("1.2.840.10008.1.2.1", true, false, 0, 2, 2, 1, 8, "MONOCHROME2", &[0, 1, 2, 3]);
for cut in [0, 4, 128, 132, 140, b.len() - 1] {
assert!(decode(&b[..cut.min(b.len())], &Limits::default()).is_err(), "cut {cut}");
}
assert!(decode(b"not dicom", &Limits::default()).is_err());
}
#[test]
fn high_bit_outside_the_allocated_bits_is_an_error_not_a_panic() {
let mut b = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 1, 1, 8, "MONOCHROME2", &[7]);
let tag = [0x28, 0x00, 0x02, 0x01, b'U', b'S', 0x02, 0x00];
let at = b.windows(tag.len()).position(|w| w == tag).unwrap() + tag.len();
b[at..at + 2].copy_from_slice(&200u16.to_le_bytes());
assert!(decode(&b, &Limits::default()).is_err());
}
#[test]
fn rejects_compressed_transfer_syntax() {
let mut b = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 1, 1, 8, "MONOCHROME2", &[0]);
let uncompressed = b"1.2.840.10008.1.2.1\0";
let compressed = b"1.2.840.10008.1.2.4\0"; // same length, a compressed family
let at = b.windows(uncompressed.len()).position(|w| w == uncompressed).expect("transfer syntax in the fixture");
b[at..at + compressed.len()].copy_from_slice(compressed);
assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. })));
}
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
bridge::format(Format::Dicom, bytes, limits)
}
+11 -849
View File
@@ -1,857 +1,19 @@
//! FITS (Flexible Image Transport System, FITS Standard 4.0), implemented here: the image in the
//! primary HDU, or the first `IMAGE` extension when the primary HDU holds no data.
//!
//! Reading:
//!
//! * `BITPIX` 8, 16, 32, 64, -32 and -64, with `BSCALE`/`BZERO` and integer `BLANK`.
//! * `NAXIS3 = 3` opens as RGB (the planes are R, G, B); any other plane count opens the first
//! plane as gray with [`crate::DecodeWarning::MorePages`].
//! * Rows are stored bottom-to-top, as the standard's convention has it (Siril, DS9, Astropy),
//! unless `ROWORDER = 'TOP-DOWN'`.
//! * Physical values that fit (unsigned 8-bit, or integers in 0..=65535 such as a camera's
//! `BITPIX = 16`, `BZERO = 32768`) are kept exactly as U8/U16. Everything else becomes F32:
//! values up to 2 are taken as already normalised (Siril, PixInsight), larger ones are scaled by
//! 65535 when they fit in it (DeepSkyStacker, most stackers) and by the maximum otherwise. NaN
//! and blank pixels read as 0.
//! * The other header cards are kept as text: `KEY` → value (strings unquoted), `COMMENT` and
//! `HISTORY` by their text, `HIERARCH` keywords by their long name. Long strings continued
//! on `CONTINUE` cards are joined.
//!
//! Writing: gray or RGB, U8 (`BITPIX = 8`), U16 (`BITPIX = 16`, `BZERO = 32768`) or F32
//! (`BITPIX = -32`, 0..1), bottom-to-top with `ROWORDER = 'BOTTOM-UP'`, plus the text cards
//! (strings longer than one card on `CONTINUE` cards).
//! Tile-compressed files (fpack `ZIMAGE` tables) are recognised and refused.
//! FITS compatibility facade; implementation lives in craft-image-codecs.
use crate::{CodecError, Image, Limits, bridge};
use craft_image_codecs::Format;
use std::collections::HashMap;
use crate::{ChannelLayout, CodecError, DecodeWarning, Image, Limits, SampleType};
const F: &str = "FITS";
const BLOCK: usize = 2880;
const CARD: usize = 80;
/// Most HDUs walked looking for an image; FITS files from cameras and stackers hold a handful.
const MAX_HDUS: usize = 1000;
/// Keywords that describe the data layout. They are written from the image, never copied from
/// (or kept as) text metadata: after decoding they no longer describe the pixels.
const STRUCTURAL: &[&str] = &[
"SIMPLE", "BITPIX", "NAXIS", "EXTEND", "BZERO", "BSCALE", "BLANK", "END", "XTENSION", "PCOUNT", "GCOUNT", "ROWORDER", "CHECKSUM", "DATASUM",
"DATAMIN", "DATAMAX", "ZIMAGE",
];
fn err(msg: impl std::fmt::Display) -> CodecError {
CodecError::malformed(F, msg)
pub fn looks_like_fits(bytes: &[u8]) -> bool {
craft_image_codecs::detect(bytes) == Some(Format::Fits)
}
#[derive(Debug, Clone, PartialEq)]
enum Value {
/// A quoted string, unescaped, trailing blanks removed.
Str(String),
/// Anything else (number, logical, complex) as written.
Raw(String),
}
#[derive(Debug, Clone)]
struct Card {
key: String,
/// `None` for commentary cards (`COMMENT`, `HISTORY`, blank keyword).
value: Option<Value>,
/// The text of a commentary card.
text: String,
/// A `HIERARCH` keyword (`key` holds its long name).
hierarch: bool,
}
fn parse_value(field: &str) -> Value {
let t = field.trim_start();
if let Some(rest) = t.strip_prefix('\'') {
let mut s = String::new();
let mut chars = rest.chars().peekable();
while let Some(c) = chars.next() {
if c == '\'' {
if chars.peek() == Some(&'\'') {
chars.next();
s.push('\'');
} else {
break;
}
} else {
s.push(c);
}
}
Value::Str(s.trim_end().to_string())
} else {
Value::Raw(t.split('/').next().unwrap_or("").trim().to_string())
}
}
fn parse_card(raw: &[u8]) -> Card {
// Header bytes are ASCII 32–126 by the standard; anything else is replaced, never trusted.
let s: String = raw.iter().map(|&b| if (32..=126).contains(&b) { b as char } else { '?' }).collect();
let key_field = s.get(..8).unwrap_or(&s).trim_end().to_string();
if key_field == "HIERARCH" {
let rest = s.get(9..).unwrap_or("");
if let Some((k, v)) = rest.split_once('=') {
return Card { key: k.trim().to_string(), value: Some(parse_value(v)), text: String::new(), hierarch: true };
}
}
if s.get(8..10) == Some("= ") {
let v = parse_value(s.get(10..).unwrap_or(""));
return Card { key: key_field, value: Some(v), text: String::new(), hierarch: false };
}
Card { key: key_field, value: None, text: s.get(8..).unwrap_or("").trim_end().to_string(), hierarch: false }
}
struct Header {
cards: Vec<Card>,
/// First-occurrence index of each non-HIERARCH keyword, so `get` is O(1). The card
/// count and the number of looked-up keywords (NAXIS1..NAXISn) are both file-controlled,
/// so a linear scan per lookup lets a crafted header multiply commentary cards by axis
/// count into quadratic work.
index: HashMap<String, usize>,
/// Offset of the data unit.
data_start: usize,
}
impl Header {
fn get(&self, key: &str) -> Option<&Value> {
let c = &self.cards[*self.index.get(key)?];
c.value.as_ref()
}
fn int(&self, key: &str) -> Option<i64> {
match self.get(key)? {
Value::Raw(r) => r.parse::<i64>().ok().or_else(|| self.float(key).filter(|f| f.fract() == 0.0 && f.abs() < 9.0e15).map(|f| f as i64)),
Value::Str(_) => None,
}
}
fn float(&self, key: &str) -> Option<f64> {
match self.get(key)? {
// Fortran-style `D` exponents are allowed in FITS.
Value::Raw(r) => r.replace(['D', 'd'], "E").parse::<f64>().ok().filter(|f| f.is_finite()),
Value::Str(_) => None,
}
}
fn logical(&self, key: &str) -> bool {
matches!(self.get(key), Some(Value::Raw(r)) if r == "T")
}
fn string(&self, key: &str) -> Option<&str> {
match self.get(key)? {
Value::Str(s) => Some(s.trim()),
Value::Raw(_) => None,
}
}
}
fn parse_header(b: &[u8], start: usize) -> Result<Header, CodecError> {
let mut cards = Vec::new();
let mut pos = start;
loop {
let raw = b.get(pos..pos.checked_add(CARD).ok_or_else(|| err("header too long"))?).ok_or_else(|| err("header ends before END"))?;
pos += CARD;
if raw.starts_with(b"END") && raw.get(3..).is_some_and(|r| r.iter().all(|&c| c == b' ')) {
break;
}
let card = parse_card(raw);
// Long strings (FITS 4.0 section 4.2.1.2): a string ending in '&' goes on in the next
// `CONTINUE` record. An orphaned `CONTINUE` stays a card of its own (commentary).
if let Some(Card { value: Some(Value::Str(s)), .. }) = cards.last_mut()
&& s.ends_with('&')
&& card.key == "CONTINUE"
&& card.text.starts_with(" ")
&& let Value::Str(more) = parse_value(&card.text)
{
s.pop();
s.push_str(&more);
continue;
}
cards.push(card);
}
let data_start = pos.div_ceil(BLOCK).checked_mul(BLOCK).ok_or_else(|| err("header too long"))?;
// Index each non-HIERARCH keyword to its first occurrence, matching the previous
// `find(|c| !c.hierarch && c.key == key)` lookup while making `get` O(1).
let mut index = HashMap::with_capacity(cards.len());
for (i, c) in cards.iter().enumerate() {
if !c.hierarch {
index.entry(c.key.clone()).or_insert(i);
}
}
Ok(Header { cards, index, data_start })
}
/// The axis lengths (`NAXIS1`, `NAXIS2`, …).
fn axes(h: &Header) -> Result<Vec<u64>, CodecError> {
let n = h.int("NAXIS").ok_or_else(|| err("missing NAXIS"))?;
if !(0..=999).contains(&n) {
return Err(err(format!("invalid NAXIS {n}")));
}
(1..=n)
.map(|i| h.int(&format!("NAXIS{i}")).and_then(|v| u64::try_from(v).ok()).ok_or_else(|| err(format!("missing or negative NAXIS{i}"))))
.collect()
}
/// Bytes in the data unit (before padding to a block).
fn data_len(h: &Header, bitpix: i64) -> Result<u64, CodecError> {
let ax = axes(h)?;
if ax.is_empty() {
return Ok(0);
}
let pcount = u64::try_from(h.int("PCOUNT").unwrap_or(0)).map_err(|_| err("negative PCOUNT"))?;
let gcount = u64::try_from(h.int("GCOUNT").unwrap_or(1)).map_err(|_| err("negative GCOUNT"))?;
let elems = ax.iter().try_fold(1u64, |a, &n| a.checked_mul(n)).ok_or_else(|| err("data size overflows"))?;
elems
.checked_add(pcount)
.and_then(|v| v.checked_mul(gcount))
.and_then(|v| v.checked_mul(bitpix.unsigned_abs() / 8))
.ok_or_else(|| err("data size overflows"))
}
/// A primary header's first card, `SIMPLE =`.
pub fn looks_like_fits(b: &[u8]) -> bool {
b.starts_with(b"SIMPLE =")
}
/// Inspect every HDU without decoding pixels: one gray plane or three RGB planes are retained,
/// while other cubes, image extensions, tables and other data-bearing HDUs cannot survive a flat save.
/// Incomplete or over-limit walks fail closed rather than treating an unchecked suffix as safe.
pub fn has_additional_images(bytes: &[u8]) -> Result<bool, CodecError> {
let mut start = 0;
let mut image_seen = false;
for index in 0..MAX_HDUS {
let h = parse_header(bytes, start)?;
if index == 0 && h.get("SIMPLE").is_none() {
return Err(err("missing SIMPLE"));
}
let ax = axes(&h)?;
let size = data_len(&h, h.int("BITPIX").unwrap_or(8))?;
let image_hdu = index == 0 || h.string("XTENSION") == Some("IMAGE");
if h.logical("ZIMAGE") {
return Ok(true);
}
if !image_hdu && size > 0 {
return Ok(true);
}
// An image HDU with a zero axis has no data (FITS 4.0, NAXISn) and holds no image, like
// the empty primary: `find_image` skips it too.
if image_hdu && size > 0 && ax.len() >= 2 && ax[..2].iter().all(|n| *n > 0) {
let planes = ax.iter().skip(2).try_fold(1u64, |n, axis| n.checked_mul(*axis)).ok_or_else(|| err("plane count overflows"))?;
let retained = planes == 1 || (ax.get(2) == Some(&3) && planes == 3);
if image_seen || !retained || h.int("GCOUNT").unwrap_or(1) > 1 || h.int("PCOUNT").unwrap_or(0) > 0 {
return Ok(true);
}
image_seen = true;
} else if size > 0 {
return Ok(true);
}
let padded = size.div_ceil(BLOCK as u64).checked_mul(BLOCK as u64).ok_or_else(|| err("data size overflows"))?;
let next = usize::try_from(padded).ok().and_then(|size| h.data_start.checked_add(size)).ok_or_else(|| err("data size overflows"))?;
if next > bytes.len() {
return Err(err("truncated HDU data"));
}
if next == bytes.len() {
return Ok(false);
}
start = next;
}
Err(err("too many HDUs to inspect every source image"))
craft_image_codecs::has_unretained_source_data(bytes).map_err(bridge::from_shared_error)
}
/// Whether an HDU with these axes stores pixels: at least two axes and none of them zero (FITS 4.0,
/// NAXISn: a zero axis means no data follow the header).
fn holds_pixels(ax: &[u64]) -> bool {
ax.len() >= 2 && ax.iter().all(|n| *n > 0)
}
/// Finds the image HDU: the primary one when it holds pixels, else the first `IMAGE` extension
/// that does. Returns its header and the primary header (for its descriptive cards).
fn find_image(b: &[u8]) -> Result<(Header, Option<Header>), CodecError> {
let primary = parse_header(b, 0)?;
if primary.get("SIMPLE").is_none() {
return Err(err("missing SIMPLE"));
}
if holds_pixels(&axes(&primary)?) {
return Ok((primary, None));
}
let mut compressed = false;
let mut cur_start = primary.data_start;
let mut cur_len = data_len(&primary, primary.int("BITPIX").unwrap_or(8))?;
for _ in 0..MAX_HDUS {
let next = usize::try_from(cur_len.div_ceil(BLOCK as u64).saturating_mul(BLOCK as u64))
.ok()
.and_then(|l| cur_start.checked_add(l))
.ok_or_else(|| err("data size overflows"))?;
if next >= b.len() {
break;
}
let h = parse_header(b, next)?;
let kind = h.string("XTENSION").unwrap_or("").to_string();
if kind == "IMAGE" && holds_pixels(&axes(&h)?) {
return Ok((h, Some(primary)));
}
if kind == "BINTABLE" && h.logical("ZIMAGE") {
compressed = true;
}
cur_len = data_len(&h, h.int("BITPIX").unwrap_or(8))?;
cur_start = h.data_start;
}
if compressed {
return Err(CodecError::unsupported(F, "tile-compressed FITS (fpack) is not supported; decompress it with funpack first"));
}
Err(err("the file holds no image"))
}
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
let (h, primary) = find_image(bytes)?;
let bitpix = h.int("BITPIX").ok_or_else(|| err("missing BITPIX"))?;
if !matches!(bitpix, 8 | 16 | 32 | 64 | -32 | -64) {
return Err(err(format!("invalid BITPIX {bitpix}")));
}
let ax = axes(&h)?;
let (Some(&w), Some(&hgt)) = (ax.first(), ax.get(1)) else { return Err(err("the image has fewer than two axes")) };
let w = u32::try_from(w).map_err(|_| CodecError::LimitExceeded(format!("width {w}")))?;
let hgt = u32::try_from(hgt).map_err(|_| CodecError::LimitExceeded(format!("height {hgt}")))?;
let planes = ax.iter().skip(2).try_fold(1u64, |a, &n| a.checked_mul(n)).ok_or_else(|| err("too many planes"))?;
let (layout, nplanes) = if ax.get(2) == Some(&3) && planes == 3 { (ChannelLayout::Rgb, 3usize) } else { (ChannelLayout::Gray, 1) };
let bscale = h.float("BSCALE").unwrap_or(1.0);
let bzero = h.float("BZERO").unwrap_or(0.0);
let blank = if bitpix > 0 { h.int("BLANK") } else { None };
let integral = bscale == 1.0 && bzero.fract() == 0.0;
let candidate = match bitpix {
8 if integral && bzero == 0.0 => SampleType::U8,
8 | 16 if integral => SampleType::U16,
_ => SampleType::F32,
};
limits.check(w, hgt, layout, candidate)?;
let bps = (bitpix.unsigned_abs() / 8) as usize;
let plane_len = (w as usize).checked_mul(hgt as usize).ok_or_else(|| CodecError::LimitExceeded(format!("{w}x{hgt} does not fit in memory")))?;
let n = plane_len.checked_mul(nplanes).ok_or_else(|| CodecError::LimitExceeded("image does not fit in memory".into()))?;
let need = n.checked_mul(bps).and_then(|l| l.checked_add(h.data_start)).ok_or_else(|| err("data size overflows"))?;
let data = bytes.get(h.data_start..need).ok_or_else(|| err("truncated data"))?;
// Physical value of sample `i` (planar order); `None` for a blank or NaN pixel.
let physical = |i: usize| -> Option<f64> {
let s = data.get(i * bps..(i + 1) * bps)?;
let raw = match bitpix {
8 => s.first().map(|&v| v as i64)?,
16 => i16::from_be_bytes([s[0], s[1]]) as i64,
32 => i32::from_be_bytes([s[0], s[1], s[2], s[3]]) as i64,
64 => i64::from_be_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]),
-32 => return Some(f32::from_be_bytes([s[0], s[1], s[2], s[3]]) as f64 * bscale + bzero).filter(|v| v.is_finite()),
_ => return Some(f64::from_be_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]) * bscale + bzero).filter(|v| v.is_finite()),
};
if blank == Some(raw) {
return None;
}
Some(raw as f64 * bscale + bzero)
};
let top_down = h.string("ROWORDER").is_some_and(|r| r.eq_ignore_ascii_case("TOP-DOWN"));
let (wu, hu) = (w as usize, hgt as usize);
// Planar, bottom-up (by default) → interleaved, top-down.
let dest = |i: usize| -> usize {
let (p, rem) = (i / plane_len, i % plane_len);
let (y, x) = (rem / wu, rem % wu);
let y = if top_down { y } else { hu - 1 - y };
(y * wu + x) * nplanes + p
};
let mut img = match candidate {
SampleType::U8 => {
let mut out = vec![0u8; n];
for i in 0..n {
out[dest(i)] = physical(i).unwrap_or(0.0) as u8;
}
Image::from_u8(w, hgt, layout, out)?
}
_ => {
let mut out16 = if candidate == SampleType::U16 { Some(vec![0u16; n]) } else { None };
if let Some(out) = out16.as_mut() {
for i in 0..n {
let v = physical(i).unwrap_or(0.0);
if !(0.0..=65535.0).contains(&v) {
// Signed data with negative values: fall back to float.
out16 = None;
break;
}
out[dest(i)] = v as u16;
}
}
match out16 {
Some(out) => Image::from_u16(w, hgt, layout, &out)?,
None => {
let max = (0..n).filter_map(physical).fold(0.0f64, f64::max);
let white = if max <= 2.0 {
1.0
} else if max <= 65535.0 {
65535.0
} else {
max
};
let mut out = vec![0f32; n];
for i in 0..n {
out[dest(i)] = (physical(i).unwrap_or(0.0) / white) as f32;
}
Image::from_f32(w, hgt, layout, &out)?
}
}
}
};
if planes > nplanes as u64 {
img.warnings.push(DecodeWarning::MorePages { total: u32::try_from(planes).ok() });
}
let mut text = Vec::new();
for c in primary.iter().flat_map(|p| p.cards.iter()).chain(h.cards.iter()) {
if !c.hierarch && (STRUCTURAL.contains(&c.key.as_str()) || is_naxis(&c.key)) {
continue;
}
let entry = match &c.value {
Some(Value::Str(s) | Value::Raw(s)) => (c.key.clone(), s.clone()),
None if c.key.is_empty() && c.text.trim().is_empty() => continue,
None => (if c.key.is_empty() { "COMMENT".to_string() } else { c.key.clone() }, c.text.trim().to_string()),
};
text.push(entry);
}
img.text = text;
Ok(img)
bridge::format(Format::Fits, bytes, limits)
}
fn is_naxis(key: &str) -> bool {
key.strip_prefix("NAXIS").is_some_and(|d| d.chars().all(|c| c.is_ascii_digit()))
}
/// A standard keyword: 1–8 characters from `A-Z 0-9 _ -`.
fn standard_key(key: &str) -> bool {
(1..=8).contains(&key.len()) && key.bytes().all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || b == b'_' || b == b'-')
}
fn ascii(s: &str) -> String {
s.chars().map(|c| if (' '..='~').contains(&c) { c } else { '?' }).collect()
}
/// A FITS literal (number or logical) that can be written unquoted.
fn literal(v: &str) -> bool {
v == "T"
|| v == "F"
|| (v.replace(['D', 'd'], "E").parse::<f64>().is_ok_and(|f| f.is_finite()) && v.bytes().all(|b| b"0123456789+-.EeDd".contains(&b)))
}
fn quoted(v: &str, room: usize) -> String {
let mut s = String::from("'");
for c in ascii(v).chars() {
let add = if c == '\'' { 2 } else { 1 };
// Keep room for the closing quote.
if s.len() + add + 1 > room {
break;
}
s.push(c);
if c == '\'' {
s.push('\'');
}
pub fn encode(image: &Image) -> Result<Vec<u8>, CodecError> {
if !matches!(image.layout(), crate::ChannelLayout::Gray | crate::ChannelLayout::Rgb) {
return Err(CodecError::encode("FITS", format!("FITS cannot store {:?}", image.layout())));
}
// Strings are at least eight characters inside the quotes.
while s.len() < 9 {
s.push(' ');
}
s.push('\'');
s
}
struct Writer {
out: Vec<u8>,
}
impl Writer {
fn card(&mut self, text: &str) {
let mut c: Vec<u8> = ascii(text).into_bytes();
c.truncate(CARD);
c.resize(CARD, b' ');
self.out.extend_from_slice(&c);
}
fn value(&mut self, key: &str, v: &str) {
if literal(v) {
self.card(&format!("{key:<8}= {v:>20}"));
return;
}
// A string too long for one card goes on in `CONTINUE` cards, every piece but the last
// ending in '&' (FITS 4.0 section 4.2.1.2). A doubled quote is never split, and trailing
// blanks (not significant) are dropped so none are kept before an '&'.
let escaped = ascii(v).trim_end().replace('\'', "''");
let mut rest = escaped.as_str();
let mut head = format!("{key:<8}= ");
while rest.len() > CARD - 12 {
let cut = CARD - 13 - rest.get(..CARD - 13).unwrap_or("").bytes().rev().take_while(|&b| b == b'\'').count() % 2;
let (piece, tail) = rest.split_at_checked(cut).unwrap_or((rest, ""));
self.card(&format!("{head}'{piece}&'"));
head = "CONTINUE ".to_string();
rest = tail;
}
self.card(&format!("{head}'{rest:<8}'"));
}
fn commentary(&mut self, key: &str, text: &str) {
let chars: Vec<char> = ascii(text).chars().collect();
if chars.is_empty() {
self.card(key);
}
for chunk in chars.chunks(CARD - 8) {
self.card(&format!("{key:<8}{}", chunk.iter().collect::<String>()));
}
}
fn text(&mut self, key: &str, v: &str) {
let upper = key.to_ascii_uppercase();
if matches!(upper.as_str(), "COMMENT" | "HISTORY") {
self.commentary(&upper, v);
} else if standard_key(key) {
// `CONTINUE` only ever carries a string's continuation, written by `value`.
if !STRUCTURAL.contains(&key) && !is_naxis(key) && key != "CONTINUE" {
self.value(key, v);
}
} else {
// Long or mixed-case names (`Description`, `Software`): the HIERARCH convention,
// when the card fits, else a comment.
let name = ascii(key);
let head = format!("HIERARCH {name} = ");
let fits_key = !name.contains('=') && !name.trim().is_empty();
let body = if literal(v) { v.to_string() } else { quoted(v, CARD.saturating_sub(head.len())) };
if fits_key && head.len() + body.len() <= CARD && (literal(v) || body.ends_with('\'')) && quoted_whole(v, &body) {
self.card(&format!("{head}{body}"));
} else {
self.commentary("COMMENT", &format!("{key} = {v}"));
}
}
}
}
/// `body` holds all of `v` (it was not cut short to fit the card).
fn quoted_whole(v: &str, body: &str) -> bool {
literal(v) || body.trim_matches('\'').trim_end().replace("''", "'") == ascii(v).trim_end()
}
/// Writes `img` (gray or RGB; 8-bit, 16-bit or float) as a single-HDU FITS file, with
/// `img.text` as header cards.
pub fn encode(img: &Image) -> Result<Vec<u8>, CodecError> {
let (w, h) = (img.width(), img.height());
let layout = img.layout();
let nc = match layout {
ChannelLayout::Gray => 1,
ChannelLayout::Rgb => 3,
l => return Err(CodecError::encode(F, format!("FITS cannot store {l:?}"))),
};
let bitpix = match img.sample_type() {
SampleType::U8 => 8,
SampleType::U16 => 16,
SampleType::F32 => -32,
};
let mut wr = Writer { out: Vec::new() };
wr.value("SIMPLE", "T");
wr.value("BITPIX", &bitpix.to_string());
wr.value("NAXIS", if nc == 3 { "3" } else { "2" });
wr.value("NAXIS1", &w.to_string());
wr.value("NAXIS2", &h.to_string());
if nc == 3 {
wr.value("NAXIS3", "3");
}
if bitpix == 16 {
wr.value("BZERO", "32768");
wr.value("BSCALE", "1");
}
wr.value("ROWORDER", "BOTTOM-UP");
for (k, v) in &img.text {
wr.text(k, v);
}
wr.card("END");
let mut out = wr.out;
out.resize(out.len().div_ceil(BLOCK) * BLOCK, b' ');
// Planar, bottom row first.
let (wu, hu) = (w as usize, h as usize);
let idx = |p: usize, y: usize, x: usize| ((hu - 1 - y) * wu + x) * nc + p;
match bitpix {
8 => {
let d = img.data();
for p in 0..nc {
for y in 0..hu {
for x in 0..wu {
out.push(d[idx(p, y, x)]);
}
}
}
}
16 => {
let d = img.to_u16_samples().unwrap_or_default();
for p in 0..nc {
for y in 0..hu {
for x in 0..wu {
out.extend_from_slice(&((d[idx(p, y, x)] as i32 - 32768) as i16).to_be_bytes());
}
}
}
}
_ => {
let d = img.to_f32_samples().unwrap_or_default();
for p in 0..nc {
for y in 0..hu {
for x in 0..wu {
// 0..1 as documented: a value above 2 would make readers (ours too)
// take the data as ADU and scale it by 65535. NaN is written as 0.
let v = d[idx(p, y, x)];
let v = if v.is_nan() { 0.0 } else { v.clamp(0.0, 1.0) };
out.extend_from_slice(&v.to_be_bytes());
}
}
}
}
}
out.resize(out.len().div_ceil(BLOCK) * BLOCK, 0);
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
fn header(cards: &[&str]) -> Vec<u8> {
let mut w = Writer { out: Vec::new() };
for c in cards {
w.card(c);
}
w.card("END");
let mut out = w.out;
out.resize(out.len().div_ceil(BLOCK) * BLOCK, b' ');
out
}
#[test]
fn continue_strings_decode() {
let mut b = header(&[
"SIMPLE = T",
"BITPIX = 8",
"NAXIS = 2",
"NAXIS1 = 1",
"NAXIS2 = 1",
"OBJECT = 'aaa&'",
"CONTINUE 'bbb&' / a comment",
"CONTINUE '&'",
"CONTINUE ''",
"OBSERVER= 'R&'",
"COMMENT hi",
"CONTINUE 'orphan'",
]);
b.push(0);
let img = decode(&b, &Limits::default()).unwrap();
let text = [("OBJECT", "aaabbb"), ("OBSERVER", "R&"), ("COMMENT", "hi"), ("CONTINUE", "'orphan'")];
assert_eq!(img.text, text.map(|(k, v)| (k.to_string(), v.to_string())));
}
#[test]
fn continue_strings_round_trip() {
for value in ["a".repeat(100), format!("{}' {}", "a".repeat(65), "b".repeat(100)), "'".repeat(100), "a".repeat(68)] {
let mut img = Image::from_u8(1, 1, ChannelLayout::Gray, vec![0]).unwrap();
img.text = vec![("OBJECT".into(), value.clone()), ("CONTINUE".into(), "orphan".into())];
let b = encode(&img).unwrap();
assert!(!b.chunks(CARD).any(|c| c.starts_with(b"CONTINUE=")));
let decoded = decode(&b, &Limits::default()).unwrap();
assert_eq!(decoded.text, vec![("OBJECT".into(), value)]);
}
}
#[test]
fn camera_u16_with_bzero_reads_exactly_and_bottom_up() {
let mut b = header(&[
"SIMPLE = T",
"BITPIX = 16",
"NAXIS = 2",
"NAXIS1 = 2",
"NAXIS2 = 2",
"BZERO = 32768",
"OBJECT = 'M 31 '",
"EXPTIME = 300.0 / seconds",
]);
for v in [0u16, 1000, 40000, 65535] {
b.extend_from_slice(&((v as i32 - 32768) as i16).to_be_bytes());
}
b.resize(b.len().div_ceil(BLOCK) * BLOCK, 0);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.sample_type(), SampleType::U16);
// The first stored row is the bottom one.
assert_eq!(img.to_u16_samples().unwrap(), vec![40000, 65535, 0, 1000]);
assert!(img.text.contains(&("OBJECT".into(), "M 31".into())));
assert!(img.text.contains(&("EXPTIME".into(), "300.0".into())));
assert!(!img.text.iter().any(|(k, _)| k == "BZERO" || k == "NAXIS1"));
}
#[test]
fn roworder_top_down_is_honoured() {
let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 2", "ROWORDER= 'TOP-DOWN'"]);
b.extend_from_slice(&[10, 20]);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.data(), &[10, 20]);
}
#[test]
fn stacked_float_in_adu_is_scaled_by_65535() {
let mut b = header(&["SIMPLE = T", "BITPIX = -32", "NAXIS = 2", "NAXIS1 = 2", "NAXIS2 = 1"]);
for v in [65535.0f32, f32::NAN] {
b.extend_from_slice(&v.to_be_bytes());
}
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.to_f32_samples().unwrap(), vec![1.0, 0.0]);
}
#[test]
fn hdr_float_saves_clamped_and_reopens_as_saved() {
// One value above 2 used to make the reader scale everything by 65535 (all black).
let img = Image::from_f32(2, 1, ChannelLayout::Gray, &[0.5, 3.0]).unwrap();
let bytes = encode(&img).unwrap();
let back = decode(&bytes, &Limits::default()).unwrap().to_f32_samples().unwrap();
assert!((back[0] - 0.5).abs() < 1e-6, "{back:?}");
assert!((back[1] - 1.0).abs() < 1e-6, "{back:?}");
}
#[test]
fn signed_negative_data_falls_back_to_float() {
let mut b = header(&["SIMPLE = T", "BITPIX = 16", "NAXIS = 2", "NAXIS1 = 2", "NAXIS2 = 1"]);
for v in [-100i16, 1000] {
b.extend_from_slice(&v.to_be_bytes());
}
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.sample_type(), SampleType::F32);
}
#[test]
fn image_extension_after_empty_primary() {
let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0", "EXTEND = T", "TELESCOP= 'Seestar S50'"]);
b.extend(header(&["XTENSION= 'IMAGE '", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 1", "PCOUNT = 0", "GCOUNT = 1"]));
b.push(42);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.data(), &[42]);
assert!(img.text.contains(&("TELESCOP".into(), "Seestar S50".into())));
}
/// A zero axis (`NAXIS3 = 0`) means the HDU has no data: it is neither the opened image nor
/// an additional one that a flat save would discard.
#[test]
fn zero_axis_image_hdus_are_empty() {
let empty = |primary: bool| {
let first = if primary { "SIMPLE = T" } else { "XTENSION= 'IMAGE '" };
header(&[first, "BITPIX = 8", "NAXIS = 3", "NAXIS1 = 1", "NAXIS2 = 1", "NAXIS3 = 0", "PCOUNT = 0", "GCOUNT = 1"])
};
let image = || {
let mut b = header(&["XTENSION= 'IMAGE '", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 1", "PCOUNT = 0", "GCOUNT = 1"]);
b.push(42);
b.resize(b.len().div_ceil(BLOCK) * BLOCK, 0);
b
};
let mut after_empty_primary = empty(true);
after_empty_primary.extend(image());
let mut after_empty_extension = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0", "EXTEND = T"]);
after_empty_extension.extend(empty(false));
after_empty_extension.extend(image());
let mut before_empty_extension = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0", "EXTEND = T"]);
before_empty_extension.extend(image());
before_empty_extension.extend(empty(false));
for b in [&after_empty_primary, &after_empty_extension, &before_empty_extension] {
assert!(!has_additional_images(b).unwrap());
assert_eq!(decode(b, &Limits::default()).unwrap().data(), &[42]);
}
// Only empty HDUs: nothing to open, nothing to lose.
assert!(!has_additional_images(&empty(true)).unwrap());
assert!(decode(&empty(true), &Limits::default()).is_err());
// A second non-empty image is still additional data.
let mut two = after_empty_primary.clone();
two.extend(image());
assert!(has_additional_images(&two).unwrap());
}
#[test]
fn fpack_is_refused_as_unsupported() {
let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0"]);
b.extend(header(&["XTENSION= 'BINTABLE'", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 0", "NAXIS2 = 0", "ZIMAGE = T"]));
b.extend(header(&["XTENSION= 'BINTABLE'", "BITPIX = 8", "NAXIS = 1", "NAXIS1 = 0"]));
assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. })));
}
/// Hostile headers: absurd or negative axes, bad BITPIX, overflowing sizes, missing END,
/// a long chain of empty HDUs and declared data past the end all error, never panic or
/// allocate the declared size.
#[test]
fn hostile_headers_error_without_panicking() {
let base = ["SIMPLE = T", "BITPIX = 16"];
let cases: &[&[&str]] = &[
&["NAXIS = 2", "NAXIS1 = 4294967296", "NAXIS2 = 1"],
&["NAXIS = 2", "NAXIS1 = -5", "NAXIS2 = 1"],
&["NAXIS = 2", "NAXIS1 = 2000000", "NAXIS2 = 2000000"],
&["NAXIS = 3", "NAXIS1 = 65536", "NAXIS2 = 65536", "NAXIS3 = 9223372036854775807"],
&["NAXIS = 1000"],
&["NAXIS = -1"],
&["NAXIS = 2", "NAXIS1 = 0", "NAXIS2 = 0"],
&["NAXIS = 2", "NAXIS1 = 1.5D300", "NAXIS2 = 1"],
&["NAXIS = 2"],
&["NAXIS = 2", "NAXIS1 = 100", "NAXIS2 = 100"],
];
for extra in cases {
let cards: Vec<&str> = base.iter().chain(extra.iter()).copied().collect();
let b = header(&cards);
assert!(decode(&b, &Limits::default()).is_err(), "{extra:?}");
}
for bitpix in ["0", "7", "-16", "128", "'X'"] {
let card = format!("BITPIX = {bitpix}");
let b = header(&["SIMPLE = T", &card, "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 1"]);
assert!(decode(&b, &Limits::default()).is_err(), "BITPIX {bitpix}");
}
// No END card: the header runs off the end of the file.
let mut w = Writer { out: Vec::new() };
for c in ["SIMPLE = T", "BITPIX = 8", "NAXIS = 2"] {
w.card(c);
}
assert!(decode(&w.out, &Limits::default()).is_err());
// An empty primary followed by many empty extensions: bounded walk, then "no image".
let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0"]);
for _ in 0..(MAX_HDUS + 5) {
b.extend(header(&["XTENSION= 'IMAGE '", "BITPIX = 8", "NAXIS = 0"]));
}
assert!(decode(&b, &Limits::default()).is_err());
// An extension whose declared data size overflows.
let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0"]);
b.extend(header(&[
"XTENSION= 'BINTABLE'",
"BITPIX = 64",
"NAXIS = 2",
"NAXIS1 = 9223372036854775807",
"NAXIS2 = 4",
"PCOUNT = 0",
"GCOUNT = 1",
]));
assert!(decode(&b, &Limits::default()).is_err());
}
#[test]
fn extra_planes_warn() {
let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 3", "NAXIS1 = 1", "NAXIS2 = 1", "NAXIS3 = 4"]);
b.extend_from_slice(&[1, 2, 3, 4]);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.layout(), ChannelLayout::Gray);
assert_eq!(img.warnings, vec![DecodeWarning::MorePages { total: Some(4) }]);
}
#[test]
fn strings_with_quotes_and_hierarch_round_trip() {
let mut w = Writer { out: Vec::new() };
w.text("OBSERVER", "O'Brien");
w.text("Software", "craft 1.0");
w.text("HISTORY", "stacked");
let cards: Vec<Card> = w.out.chunks(CARD).map(parse_card).collect();
assert_eq!(cards[0].value, Some(Value::Str("O'Brien".into())));
assert!(cards[1].hierarch && cards[1].key == "Software");
assert_eq!(cards[1].value, Some(Value::Str("craft 1.0".into())));
assert_eq!((cards[2].key.as_str(), cards[2].text.as_str()), ("HISTORY", "stacked"));
}
bridge::encode(image, Format::Fits, &Default::default())
}
+11 -533
View File
@@ -1,538 +1,16 @@
//! Amiga IFF/ILBM reader and writer (EA "Interchange File Format", "InterLeaved BitMap" and the
//! chunky "PBM " variant). Written from the published IFF/ILBM layout: a `FORM` chunk of four-byte
//! chunks (`BMHD` bitmap header, `CMAP` palette, `CAMG` Amiga viewport mode, `BODY` pixel data).
//!
//! Read: 1–8 bitplanes with a palette (or a gray ramp when there is none) with masking 0/1/2, and
//! 24-bitplane "deep" ILBMs (8 planes each of red, green and blue, least significant bit first,
//! no palette) with masking 0/1, both stored (0) and ByteRun1/PackBits (1) compressed. Anything
//! else is a clear `Unsupported`/`Malformed` error, never a panic.
//!
//! Write: a 24-bitplane ILBM, ByteRun1 compressed one plane row at a time, with a mask plane
//! (masking 1) when the image has alpha. The mask plane is one bit per pixel: alpha of 128 or
//! more is opaque.
//! IFF/ILBM compatibility facade; implementation lives in craft-image-codecs.
use crate::{CodecError, Image, Limits, bridge};
use craft_image_codecs::Format;
use crate::{ChannelLayout, CodecError, Image, Limits, SampleType};
const F: &str = "IFF";
fn bad(msg: impl std::fmt::Display) -> CodecError {
CodecError::malformed(F, msg)
pub fn looks_like_iff(bytes: &[u8]) -> bool {
craft_image_codecs::detect(bytes) == Some(Format::Iff)
}
fn unsupported(msg: impl Into<String>) -> CodecError {
CodecError::unsupported(F, msg)
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
bridge::format(Format::Iff, bytes, limits)
}
fn be32(b: &[u8], at: usize) -> Option<u32> {
let s = b.get(at..at.checked_add(4)?)?.try_into().ok()?;
Some(u32::from_be_bytes(s))
}
fn be16(b: &[u8], at: usize) -> Option<u16> {
let s = b.get(at..at.checked_add(2)?)?.try_into().ok()?;
Some(u16::from_be_bytes(s))
}
/// `FORM` + a bitmap type (`ILBM` interleaved, `PBM ` chunky) at offset 8.
pub fn looks_like_iff(b: &[u8]) -> bool {
b.get(0..4) == Some(b"FORM") && matches!(b.get(8..12), Some(b"ILBM" | b"PBM "))
}
/// Bitplanes of a "deep" ILBM: red, green and blue, 8 each, least significant bit first.
const DEEP_PLANES: u8 = 24;
/// The bitmap header fields decoding needs.
struct Header {
width: u32,
height: u32,
planes: u8,
masking: u8,
compression: u8,
transparent: u16,
/// `PBM ` stores one palette index per byte, padded to even row lengths.
chunky: bool,
}
/// One four-byte chunk's id and byte range.
struct Chunk<'a> {
id: [u8; 4],
data: &'a [u8],
}
/// Walk the `FORM`'s chunks from offset 12 to `end` (the form length), stopping at the first
/// malformed length so a hostile file can't run past the buffer.
fn chunks(b: &[u8]) -> impl Iterator<Item = Chunk<'_>> {
let end = be32(b, 4).map_or(b.len(), |n| (n as usize).saturating_add(8).min(b.len()));
let mut pos = 12usize;
std::iter::from_fn(move || {
if pos + 8 > end {
return None;
}
let id = b.get(pos..pos + 4)?.try_into().ok()?;
let len = be32(b, pos + 4)? as usize;
let start = pos + 8;
let data = b.get(start..start.checked_add(len)?)?;
// Chunks are padded to an even length.
pos = start.checked_add(len)?.checked_add(len & 1)?;
Some(Chunk { id, data })
})
}
fn parse_header(b: &[u8], chunky: bool) -> Result<Header, CodecError> {
let bmhd = chunks(b).find(|c| &c.id == b"BMHD").ok_or_else(|| bad("no BMHD chunk"))?;
let d = bmhd.data;
if d.len() < 20 {
return Err(bad("BMHD chunk is too short"));
pub fn encode(image: &Image) -> Result<Vec<u8>, CodecError> {
if !matches!(image.layout(), crate::ChannelLayout::Rgb | crate::ChannelLayout::Rgba) || image.sample_type() != crate::SampleType::U8 {
return Err(CodecError::encode("IFF", "ILBM writer stores 8-bit RGB pixels with optional alpha"));
}
let width = u32::from(be16(d, 0).ok_or_else(|| bad("BMHD width"))?);
let height = u32::from(be16(d, 2).ok_or_else(|| bad("BMHD height"))?);
let planes = *d.get(8).ok_or_else(|| bad("BMHD planes"))?;
let masking = *d.get(9).ok_or_else(|| bad("BMHD masking"))?;
let compression = *d.get(10).ok_or_else(|| bad("BMHD compression"))?;
if width == 0 || height == 0 {
return Err(bad("zero-sized bitmap"));
}
if !(1..=8).contains(&planes) && planes != DEEP_PLANES {
return Err(unsupported(format!("{planes} bitplanes (1–8 with a palette, or 24)")));
}
if masking > 2 {
return Err(unsupported(format!("masking {masking}")));
}
if planes == DEEP_PLANES && masking == 2 {
return Err(unsupported("a transparent color in a 24-bitplane ILBM"));
}
if compression > 1 {
return Err(unsupported(format!("compression {compression} (only stored and ByteRun1)")));
}
if chunky && (planes != 8 || masking == 1) {
return Err(unsupported("PBM requires 8-bit indices without a mask plane"));
}
let transparent = be16(d, 12).ok_or_else(|| bad("BMHD transparent colour"))?;
Ok(Header { width, height, planes, masking, compression, transparent, chunky })
}
/// ByteRun1 / PackBits decode of one plane row into `out`; returns the bytes consumed. A `0x80`
/// control byte is a no-op, as the layout specifies.
fn unpack_byte_run1(src: &[u8], out: &mut [u8]) -> Result<usize, CodecError> {
let (mut i, mut o) = (0usize, 0usize);
while o < out.len() {
let n = *src.get(i).ok_or_else(|| bad("truncated ByteRun1 data"))? as i8;
i += 1;
if n >= 0 {
let count = n as usize + 1;
let lit = src.get(i..i.checked_add(count).ok_or_else(|| bad("ByteRun1 overflow"))?).ok_or_else(|| bad("truncated ByteRun1 run"))?;
if count > out.len() - o {
return Err(bad("ByteRun1 run crosses the plane row"));
}
out[o..o + count].copy_from_slice(lit);
i += count;
o += count;
} else if n != -128 {
let count = (1 - n as i32) as usize;
let value = *src.get(i).ok_or_else(|| bad("truncated ByteRun1 repeat"))?;
i += 1;
if count > out.len() - o {
return Err(bad("ByteRun1 repeat crosses the plane row"));
}
out[o..o + count].fill(value);
o += count;
}
}
Ok(i)
}
pub fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
if !looks_like_iff(b) {
return Err(bad("not an IFF/ILBM file (no FORM ... ILBM)"));
}
let h = parse_header(b, b.get(8..12) == Some(b"PBM "))?;
if let Some(camg) = chunks(b).find(|c| &c.id == b"CAMG") {
let mode = be32(camg.data, 0).ok_or_else(|| bad("short CAMG chunk"))?;
if mode & (0x80 | 0x800) != 0 {
return Err(unsupported("EHB and HAM viewport modes"));
}
}
let layout = if h.masking == 0 { ChannelLayout::Rgb } else { ChannelLayout::Rgba };
limits.check(h.width, h.height, layout, SampleType::U8)?;
// Palette: three bytes per colour; missing entries read as black.
let cmap = chunks(b).find(|c| &c.id == b"CMAP").map(|c| c.data).filter(|p| !p.is_empty());
let colors = 1usize << h.planes;
let palette = |idx: usize| -> [u8; 3] {
if let Some(p) = cmap {
p.get(idx * 3..idx * 3 + 3).map(|c| [c[0], c[1], c[2]]).unwrap_or([0; 3])
} else {
let v = ((idx as u32 * 255) / (colors as u32 - 1).max(1)) as u8;
[v, v, v]
}
};
let body = chunks(b).find(|c| &c.id == b"BODY").map(|c| c.data).ok_or_else(|| bad("no BODY chunk"))?;
let (w, hh) = (h.width as usize, h.height as usize);
// Each plane row is stored as a whole number of 16-bit words.
let plane_row = if h.chunky { w.div_ceil(2) * 2 } else { w.div_ceil(16) * 2 };
// A masking type 1 bitmap carries one extra (mask) plane per row.
let rows_planes: usize = if h.chunky { 1 } else { usize::from(h.planes) + usize::from(h.masking == 1) };
// Decode every stored plane row up front, then recombine.
let total_rows = hh.checked_mul(rows_planes).ok_or_else(|| CodecError::LimitExceeded("bitmap too large".into()))?;
let total_bytes = total_rows.checked_mul(plane_row).ok_or_else(|| CodecError::LimitExceeded("bitmap too large".into()))?;
if total_bytes as u64 > limits.max_alloc {
return Err(CodecError::LimitExceeded("bitmap storage exceeds max_alloc".into()));
}
Limits::check_plausible(total_bytes as u64, body.len(), if h.compression == 0 { 1 } else { 128 })?;
let mut stored = crate::alloc_zeroed::<u8>(total_bytes)?;
let mut cursor = 0usize;
for row in stored.chunks_mut(plane_row.max(1)).take(total_rows) {
match h.compression {
0 => {
let src =
body.get(cursor..cursor.checked_add(plane_row).ok_or_else(|| bad("BODY overflow"))?).ok_or_else(|| bad("truncated BODY data"))?;
let n = row.len().min(src.len());
row[..n].copy_from_slice(&src[..n]);
cursor += plane_row;
}
_ => {
let tail = body.get(cursor..).ok_or_else(|| bad("truncated BODY data"))?;
cursor += unpack_byte_run1(tail, row)?;
}
}
}
let mut out = Vec::new();
out.try_reserve_exact(w.saturating_mul(hh).saturating_mul(layout.channels()))
.map_err(|_| CodecError::LimitExceeded("cannot allocate the image".into()))?;
let planes = usize::from(h.planes);
for y in 0..hh {
for x in 0..w {
let index = if h.chunky {
usize::from(*stored.get(y * plane_row + x).ok_or_else(|| bad("PBM pixel outside BODY"))?)
} else {
(0..planes).filter(|&p| bit_at(&stored, (y * rows_planes + p) * plane_row, x)).fold(0usize, |acc, p| acc | (1 << p))
};
let c = if h.planes == DEEP_PLANES { [index as u8, (index >> 8) as u8, (index >> 16) as u8] } else { palette(index) };
out.extend_from_slice(&c);
if h.masking != 0 {
let opaque =
if h.masking == 1 { bit_at(&stored, (y * rows_planes + planes) * plane_row, x) } else { index != usize::from(h.transparent) };
out.push(if opaque { 255 } else { 0 });
}
}
}
Image::from_u8(h.width, h.height, layout, out)
}
/// The bit for pixel `x` of a stored plane row at `base` (bits run MSB-first).
fn bit_at(stored: &[u8], base: usize, x: usize) -> bool {
stored.get(base + x / 8).is_some_and(|byte| byte & (0x80 >> (x % 8)) != 0)
}
/// ByteRun1 / PackBits encode of one plane row, appended to `out`: three or more equal bytes
/// become a repeat (at most 128), everything else literal runs (at most 128 bytes).
fn pack_byte_run1(row: &[u8], out: &mut Vec<u8>) {
let mut i = 0usize;
while let Some(&value) = row.get(i) {
let repeat = row[i..].iter().take(128).take_while(|&&b| b == value).count();
if repeat >= 3 {
out.push((1 - repeat as i32) as i8 as u8);
out.push(value);
i += repeat;
continue;
}
let start = i;
while i < row.len() && i - start < 128 {
if row.get(i..i + 3).is_some_and(|r| r[0] == r[1] && r[1] == r[2]) {
break;
}
i += 1;
}
out.push((i - start - 1) as u8);
out.extend_from_slice(&row[start..i]);
}
}
fn push_chunk(out: &mut Vec<u8>, id: &[u8; 4], data: &[u8]) -> Result<(), CodecError> {
let len = u32::try_from(data.len()).map_err(|_| CodecError::encode(F, "chunk too large for an IFF file (4 GiB)"))?;
out.extend_from_slice(id);
out.extend_from_slice(&len.to_be_bytes());
out.extend_from_slice(data);
// Chunks are padded to an even length.
if data.len() % 2 == 1 {
out.push(0);
}
Ok(())
}
/// Writes a 24-bitplane `FORM ILBM`: `BMHD` then a ByteRun1-compressed `BODY`, each row stored as
/// the red, green and blue planes (least significant bit first) and, for RGBA, a mask plane.
pub fn encode(img: &Image) -> Result<Vec<u8>, CodecError> {
let enc = |msg: String| CodecError::encode(F, msg);
let masked = match img.layout() {
ChannelLayout::Rgb => false,
ChannelLayout::Rgba => true,
l => return Err(enc(format!("IFF/ILBM cannot store {l:?}"))),
};
if img.sample_type() != SampleType::U8 {
return Err(enc(format!("IFF/ILBM cannot store {:?} samples", img.sample_type())));
}
let (w, h) = (img.width(), img.height());
let (Ok(w16), Ok(h16)) = (u16::try_from(w), u16::try_from(h)) else {
return Err(enc("IFF/ILBM stores at most 65535 × 65535 pixels".into()));
};
let (w, ch) = (w as usize, img.layout().channels());
let data = img.data();
let row_len = w.checked_mul(ch).ok_or_else(|| enc("image too large".into()))?;
if data.len() != row_len.checked_mul(h as usize).ok_or_else(|| enc("image too large".into()))? {
return Err(enc("the image has the wrong number of samples".into()));
}
let planes = usize::from(DEEP_PLANES) + usize::from(masked);
let mut plane_row = vec![0u8; w.div_ceil(16) * 2];
let mut body = Vec::new();
for px in data.chunks_exact(row_len.max(1)) {
for plane in 0..planes {
plane_row.fill(0);
for (x, p) in px.chunks_exact(ch).enumerate() {
let on = if plane == usize::from(DEEP_PLANES) { p[3] >= 128 } else { (p[plane / 8] >> (plane % 8)) & 1 == 1 };
if on {
plane_row[x / 8] |= 0x80 >> (x % 8);
}
}
pack_byte_run1(&plane_row, &mut body);
}
}
let mut bmhd = Vec::with_capacity(20);
bmhd.extend_from_slice(&w16.to_be_bytes());
bmhd.extend_from_slice(&h16.to_be_bytes());
bmhd.extend_from_slice(&[0, 0, 0, 0]); // x/y origin
bmhd.push(DEEP_PLANES);
bmhd.push(u8::from(masked)); // masking: 1 = a mask plane follows the color planes
bmhd.push(1); // ByteRun1
bmhd.push(0); // pad
bmhd.extend_from_slice(&[0, 0]); // transparent color (unused)
bmhd.extend_from_slice(&[1, 1]); // square pixels
bmhd.extend_from_slice(&w16.to_be_bytes()); // page size
bmhd.extend_from_slice(&h16.to_be_bytes());
let mut out = b"FORM".to_vec();
out.extend_from_slice(&[0; 4]); // patched below
out.extend_from_slice(b"ILBM");
push_chunk(&mut out, b"BMHD", &bmhd)?;
push_chunk(&mut out, b"BODY", &body)?;
let form_len = u32::try_from(out.len() - 8).map_err(|_| enc("image too large for an IFF file (4 GiB)".into()))?;
out[4..8].copy_from_slice(&form_len.to_be_bytes());
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
/// A `FORM ILBM` with a `BMHD`, `CMAP` and `BODY`. `planes` plane rows per row,
/// `compression` 0 (stored) or 1 (ByteRun1), MSB-first.
fn ilbm(w: u16, h: u16, planes: u8, palette: &[[u8; 3]], compression: u8, body: &[u8]) -> Vec<u8> {
let mut b = b"FORM".to_vec();
b.extend_from_slice(&0u32.to_be_bytes()); // patched below
b.extend_from_slice(b"ILBM");
// BMHD (20 bytes)
b.extend_from_slice(b"BMHD");
b.extend_from_slice(&20u32.to_be_bytes());
b.extend_from_slice(&w.to_be_bytes());
b.extend_from_slice(&h.to_be_bytes());
b.extend_from_slice(&[0, 0, 0, 0]); // x/y origin
b.push(planes);
b.push(0); // masking
b.push(compression);
b.push(0); // pad
b.extend_from_slice(&[0, 0]); // transparent colour
b.extend_from_slice(&[1, 1]); // aspect
b.extend_from_slice(&[0, 0, 0, 0]); // page size
// CMAP
b.extend_from_slice(b"CMAP");
b.extend_from_slice(&((palette.len() * 3) as u32).to_be_bytes());
for c in palette {
b.extend_from_slice(c);
}
if palette.len() % 2 == 1 {
b.push(0);
}
// BODY
b.extend_from_slice(b"BODY");
b.extend_from_slice(&(body.len() as u32).to_be_bytes());
b.extend_from_slice(body);
if body.len() % 2 == 1 {
b.push(0);
}
let size = (b.len() - 8) as u32;
b[4..8].copy_from_slice(&size.to_be_bytes());
b
}
#[test]
fn reads_a_stored_two_plane_bitmap() {
// 2×1, 2 planes: pixel 0 index 0 (plane bits 0,0), pixel 1 index 3 (bits 1,1).
// Plane 0 = 0b0100_0000, plane 1 = 0b0100_0000, each padded to 2 bytes.
let body = [0b0100_0000, 0, 0b0100_0000, 0];
let pal = [[10, 20, 30], [40, 50, 60], [70, 80, 90], [100, 110, 120]];
let b = ilbm(2, 1, 2, &pal, 0, &body);
assert!(looks_like_iff(&b));
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!((img.width(), img.height(), img.layout()), (2, 1, ChannelLayout::Rgb));
assert_eq!(img.data(), &[10, 20, 30, 100, 110, 120]);
}
#[test]
fn reads_byte_run1_compressed_rows() {
// Same image, ByteRun1: literal run of two bytes (0x01) then the two plane bytes each row.
let body = [0x01, 0b0100_0000, 0, 0x01, 0b0100_0000, 0];
let pal = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [250, 251, 252]];
let b = ilbm(2, 1, 2, &pal, 1, &body);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.data(), &[1, 2, 3, 250, 251, 252]);
}
#[test]
fn no_palette_falls_back_to_a_grey_ramp() {
// 2×1, 1 plane, no CMAP: indices 0 and 1 → black and white.
let body = [0b0100_0000, 0];
let b = ilbm(2, 1, 1, &[], 0, &body);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.data(), &[0, 0, 0, 255, 255, 255]);
}
#[test]
fn pbm_reads_chunky_indices_with_odd_width_padding() {
let pal = [[10, 20, 30], [40, 50, 60], [70, 80, 90]];
for (compression, body) in [(0, vec![2, 0, 1, 255, 1, 2, 0, 255]), (1, vec![3, 2, 0, 1, 255, 3, 1, 2, 0, 255])] {
let mut b = ilbm(3, 2, 8, &pal, compression, &body);
b[8..12].copy_from_slice(b"PBM ");
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.data(), &[70, 80, 90, 10, 20, 30, 40, 50, 60, 40, 50, 60, 70, 80, 90, 10, 20, 30]);
}
}
#[test]
fn transparency_uses_the_mask_plane_or_transparent_index() {
for masking in [1, 2] {
let mut b = ilbm(2, 1, 1, &[[10, 20, 30], [40, 50, 60]], 0, if masking == 1 { &[0x40, 0, 0x40, 0] } else { &[0x40, 0] });
b[29] = masking;
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!(img.layout(), ChannelLayout::Rgba);
assert_eq!(img.data(), &[10, 20, 30, 0, 40, 50, 60, 255]);
}
let mut b = ilbm(2, 1, 8, &[[10, 20, 30], [40, 50, 60]], 0, &[0, 1]);
b[8..12].copy_from_slice(b"PBM ");
b[29] = 2;
b[32..34].copy_from_slice(&1u16.to_be_bytes());
assert_eq!(decode(&b, &Limits::default()).unwrap().data(), &[10, 20, 30, 255, 40, 50, 60, 0]);
}
#[test]
fn rejects_ham_and_ehb_instead_of_returning_wrong_colours() {
for mode in [0x80u32, 0x800] {
let mut b = ilbm(1, 1, 1, &[], 0, &[0, 0]);
b.extend_from_slice(b"CAMG");
b.extend_from_slice(&4u32.to_be_bytes());
b.extend_from_slice(&mode.to_be_bytes());
let len = (b.len() - 8) as u32;
b[4..8].copy_from_slice(&len.to_be_bytes());
assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. })));
}
}
#[test]
fn missing_palette_entries_are_black() {
let b = ilbm(1, 1, 2, &[[10, 20, 30]], 0, &[0x80, 0, 0x80, 0]);
assert_eq!(decode(&b, &Limits::default()).unwrap().data(), &[0, 0, 0]);
}
#[test]
fn reads_a_stored_24_plane_bitmap() {
// 2×1: pixel 0 = (1, 0, 128), pixel 1 = (0, 255, 0). Each plane row is 2 bytes; red bit 0
// has pixel 0 set, green bits 0–7 have pixel 1 set, blue bit 7 has pixel 0 set.
let mut body = Vec::new();
for plane in 0..24 {
let byte = match plane {
0 | 23 => 0x80,
8..=15 => 0x40,
_ => 0,
};
body.extend_from_slice(&[byte, 0]);
}
let b = ilbm(2, 1, 24, &[], 0, &body);
let img = decode(&b, &Limits::default()).unwrap();
assert_eq!((img.width(), img.height(), img.layout()), (2, 1, ChannelLayout::Rgb));
assert_eq!(img.data(), &[1, 0, 128, 0, 255, 0]);
}
#[test]
fn writes_24_plane_byte_run1_that_reads_back_exactly() {
// 37 pixels wide: three plane-row words, the last one partly padding.
let (w, h) = (37u32, 3u32);
let data: Vec<u8> = (0..w * h * 3).map(|i| (i * 7 % 256) as u8).collect();
let img = Image::from_u8(w, h, ChannelLayout::Rgb, data.clone()).unwrap();
let bytes = encode(&img).unwrap();
assert!(looks_like_iff(&bytes));
assert_eq!(be32(&bytes, 4).unwrap() as usize, bytes.len() - 8, "FORM length");
let h = parse_header(&bytes, false).unwrap();
assert_eq!((h.width, h.height, h.planes, h.masking, h.compression), (37, 3, 24, 0, 1));
assert!(chunks(&bytes).all(|c| &c.id != b"CMAP"), "a deep ILBM has no palette");
let back = decode(&bytes, &Limits::default()).unwrap();
assert_eq!(back.layout(), ChannelLayout::Rgb);
assert_eq!(back.data(), &data[..]);
}
#[test]
fn alpha_is_written_as_a_mask_plane() {
let data = [10, 20, 30, 0, 40, 50, 60, 127, 70, 80, 90, 128, 1, 2, 3, 255];
let img = Image::from_u8(4, 1, ChannelLayout::Rgba, data.to_vec()).unwrap();
let bytes = encode(&img).unwrap();
assert_eq!(parse_header(&bytes, false).unwrap().masking, 1);
let back = decode(&bytes, &Limits::default()).unwrap();
assert_eq!(back.layout(), ChannelLayout::Rgba);
assert_eq!(back.data(), &[10, 20, 30, 0, 40, 50, 60, 0, 70, 80, 90, 255, 1, 2, 3, 255]);
}
#[test]
fn byte_run1_round_trips_runs_literals_and_long_rows() {
let mut rows: Vec<Vec<u8>> = vec![vec![], vec![5], vec![5, 5], vec![5, 5, 5], vec![1, 2, 2, 2, 3], vec![9; 300]];
rows.push((0..300).map(|i| (i % 251) as u8).collect());
rows.push([vec![1, 2], vec![7; 129], vec![3]].concat());
for row in rows {
let mut packed = Vec::new();
pack_byte_run1(&row, &mut packed);
let mut back = vec![0; row.len()];
assert_eq!(unpack_byte_run1(&packed, &mut back).unwrap(), packed.len(), "{row:?}");
assert_eq!(back, row);
}
// A long repeat packs into two-byte runs.
let mut packed = Vec::new();
pack_byte_run1(&[0; 256], &mut packed);
assert_eq!(packed, [0x81, 0, 0x81, 0]);
}
#[test]
fn rejects_what_ilbm_cannot_store() {
let gray = Image::from_u8(1, 1, ChannelLayout::Gray, vec![0]).unwrap();
assert!(encode(&gray).is_err());
let wide = Image::from_u8(65536, 1, ChannelLayout::Rgb, vec![0; 65536 * 3]).unwrap();
assert!(encode(&wide).is_err());
// A transparent color index has no meaning without a palette.
let mut b = ilbm(1, 1, 24, &[], 0, &[0; 48]);
b[29] = 2;
assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. })));
}
#[test]
fn hostile_input_errors_not_panics() {
// Truncations of a valid file never panic.
let body = [0b0100_0000, 0, 0b0100_0000, 0];
let full = ilbm(2, 1, 2, &[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], 0, &body);
for cut in [0, 4, 8, 12, 40, full.len() - 1] {
assert!(decode(&full[..cut.min(full.len())], &Limits::default()).is_err(), "cut {cut}");
}
// Too many planes is unsupported.
let bad = ilbm(1, 1, 9, &[], 0, &[0, 0]);
assert!(matches!(decode(&bad, &Limits::default()), Err(CodecError::Unsupported { .. })));
}
bridge::encode(image, Format::Iff, &Default::default())
}
+19 -34
View File
@@ -18,10 +18,10 @@
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
mod bridge;
/// Common bounded decoding and PNG/JPEG encoding for common image formats.
pub mod common;
pub mod dds;
mod dds_bc;
pub mod dicom;
pub mod fits;
pub mod iff;
@@ -215,47 +215,32 @@ impl Limits {
/// Validates declared dimensions for an output buffer of the given layout and sample type.
pub fn check(&self, width: u32, height: u32, layout: ChannelLayout, sample: SampleType) -> Result<(), CodecError> {
if width == 0 || height == 0 {
return Err(CodecError::InvalidImage(format!("zero-sized image {width}x{height}")));
}
if width > self.max_width || height > self.max_height {
return Err(CodecError::LimitExceeded(format!("dimensions {width}x{height} exceed max {}x{}", self.max_width, self.max_height)));
}
let pixels = width as u64 * height as u64;
if pixels > self.max_pixels {
return Err(CodecError::LimitExceeded(format!("{pixels} pixels exceed max {}", self.max_pixels)));
}
let bytes = pixels.saturating_mul((layout.channels() * sample.bytes()) as u64);
if bytes > self.max_alloc {
return Err(CodecError::LimitExceeded(format!("{bytes} bytes exceed max_alloc {}", self.max_alloc)));
}
if usize::try_from(bytes).is_err() {
return Err(CodecError::LimitExceeded(format!("{bytes} bytes do not fit in memory")));
}
Ok(())
let layout = match layout {
ChannelLayout::Gray => craft_image_codecs::ChannelLayout::Gray,
ChannelLayout::GrayA => craft_image_codecs::ChannelLayout::GrayA,
ChannelLayout::Rgb => craft_image_codecs::ChannelLayout::Rgb,
ChannelLayout::Rgba => craft_image_codecs::ChannelLayout::Rgba,
ChannelLayout::Cmyk => craft_image_codecs::ChannelLayout::Cmyk,
ChannelLayout::CmykA => craft_image_codecs::ChannelLayout::CmykA,
};
let sample = match sample {
SampleType::U8 => craft_image_codecs::SampleType::U8,
SampleType::U16 => craft_image_codecs::SampleType::U16,
SampleType::F32 => craft_image_codecs::SampleType::F32,
};
craft_image_codecs::Limits::new(self.max_width, self.max_height, self.max_pixels, self.max_alloc)
.check(width, height, layout, sample)
.map_err(crate::bridge::from_shared_error)
}
/// Decompression-bomb guard for formats that compress: refuses a file too small to hold
/// `declared_bytes` of stored image data when the compression never beats `max_ratio`:1.
/// Called before the output buffer is allocated. 1 MiB of slack leaves tiny images alone.
pub(crate) fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> {
let capacity = (file_len as u64).saturating_mul(max_ratio).saturating_add(1 << 20);
if declared_bytes > capacity {
return Err(CodecError::LimitExceeded(format!("a {file_len} byte file cannot hold {declared_bytes} bytes of image data")));
}
Ok(())
pub fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> {
craft_image_codecs::Limits::check_plausible(declared_bytes, file_len, max_ratio).map_err(crate::bridge::from_shared_error)
}
}
/// A zero-filled buffer of `len` elements, allocated fallibly: an allocation failure is
/// [`CodecError::LimitExceeded`] instead of an abort.
pub(crate) fn alloc_zeroed<T: Copy + Default>(len: usize) -> Result<Vec<T>, CodecError> {
let mut v = Vec::new();
v.try_reserve_exact(len).map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {len} elements for the image")))?;
v.resize(len, T::default());
Ok(v)
}
#[cfg(test)]
mod tests {
use super::*;
+9 -140
View File
@@ -1,144 +1,13 @@
//! ZSoft PCX (Paintbrush) reader: strictly bounded scanline RLE, 16/256-colour
//! palettes, 8-bit three-plane RGB and four-plane RGBA. Read-only: modern saves should use PNG.
//! PCX compatibility facade; implementation and header probing live in craft-image-codecs.
use crate::{CodecError, Image, Limits, bridge};
use craft_image_codecs::Format;
use crate::{ChannelLayout, CodecError, Image, Limits, SampleType};
const HEADER: usize = 128;
fn bad(reason: impl std::fmt::Display) -> CodecError {
CodecError::malformed("PCX", reason)
pub fn looks_like_pcx(bytes: &[u8]) -> bool {
craft_image_codecs::detect(bytes) == Some(Format::Pcx)
}
fn le16(b: &[u8], i: usize) -> u16 {
u16::from_le_bytes([b[i], b[i + 1]])
pub fn dimensions(bytes: &[u8]) -> Option<(u32, u32)> {
craft_image_codecs::pcx_dimensions(bytes)
}
/// PCX lacks a strong magic number. Require plausible complete header fields before
/// identifying it, rather than classifying every file starting with 0x0a as PCX.
pub fn looks_like_pcx(b: &[u8]) -> bool {
if b.len() < HEADER || b[0] != 0x0a || !matches!(b[1], 0 | 2..=5) || b[2] != 1 {
return false;
}
let bits = b[3];
let planes = b[65];
let stride = u32::from(le16(b, 66));
let (x0, y0, x1, y1) = (le16(b, 4), le16(b, 6), le16(b, 8), le16(b, 10));
if x1 < x0 || y1 < y0 || !matches!(bits, 1 | 2 | 4 | 8) || !(1..=4).contains(&planes) {
return false;
}
let width = u32::from(x1 - x0) + 1;
let min_stride = (width * u32::from(bits)).div_ceil(8);
stride >= min_stride && stride > 0 && (bits != 8 || matches!(planes, 1 | 3 | 4)) && (bits == 8 || u32::from(bits) * u32::from(planes) <= 4)
}
/// Read one compressed scanline, including all planes. RLE packets never cross a scanline.
fn read_row(b: &[u8], pos: &mut usize, out: &mut [u8]) -> Result<(), CodecError> {
let mut n = 0;
while n < out.len() {
let code = *b.get(*pos).ok_or_else(|| bad("truncated pixel RLE"))?;
*pos += 1;
let (count, value) = if code >= 0xc0 {
let count = usize::from(code & 0x3f);
let value = *b.get(*pos).ok_or_else(|| bad("truncated RLE packet"))?;
*pos += 1;
(count, value)
} else {
(1, code)
};
if count == 0 || count > out.len() - n {
return Err(bad("RLE packet crosses a scanline or has zero length"));
}
out[n..n + count].fill(value);
n += count;
}
Ok(())
}
/// The pixel size a PCX header declares, without decoding; `None` when [`looks_like_pcx`] is false.
pub fn dimensions(b: &[u8]) -> Option<(u32, u32)> {
looks_like_pcx(b).then(|| (u32::from(le16(b, 8) - le16(b, 4)) + 1, u32::from(le16(b, 10) - le16(b, 6)) + 1))
}
/// Decodes to 8-bit RGB, or RGBA for four 8-bit planes (red, green, blue, alpha).
pub fn decode(b: &[u8], limits: &Limits) -> Result<Image, CodecError> {
let (w, h) = dimensions(b).ok_or_else(|| bad("invalid PCX header or unsupported pixel layout"))?;
let (bits, planes, stride) = (usize::from(b[3]), usize::from(b[65]), usize::from(le16(b, 66)));
let layout = if bits == 8 && planes == 4 { ChannelLayout::Rgba } else { ChannelLayout::Rgb };
let ch = layout.channels();
limits.check(w, h, layout, SampleType::U8)?;
let row_len = stride.checked_mul(planes).ok_or_else(|| bad("row size overflow"))?;
let total = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(ch)).ok_or_else(|| bad("pixel size overflow"))?;
// The last 769 bytes are the optional VGA palette for 8-bit indexed images.
let vga = bits == 8 && planes == 1 && b.len() >= HEADER + 769 && b[b.len() - 769] == 0x0c;
if bits == 8 && planes == 1 && !vga && le16(b, 68) != 2 {
return Err(bad("8-bit indexed PCX has no 256-colour palette"));
}
let image_end = if vga { b.len() - 769 } else { b.len() };
// A 63-byte RLE packet takes 2 bytes; a trailing remainder of 1 byte below 0xC0
// can be encoded as a 1-byte literal, while any larger remainder takes at least 2 bytes.
// Because RLE packets may span planes within a scanline (`row_len`), compute the
// minimum encoded bytes across the full scanline (`row_len`) and multiply by `h`.
// Reject inputs that cannot possibly contain all scanlines before allocating
// the decoded image buffer.
let min_packets = (row_len / 63)
.checked_mul(2)
.and_then(|n| {
n.checked_add(match row_len % 63 {
0 => 0,
1 => 1,
_ => 2,
})
})
.ok_or_else(|| bad("compressed row size overflow"))?;
let min_encoded = min_packets.checked_mul(h as usize).ok_or_else(|| bad("compressed image size overflow"))?;
let encoded_len = image_end.saturating_sub(HEADER);
if encoded_len < min_encoded {
return Err(bad("PCX pixel data is too short for the declared image"));
}
let mut row = vec![0u8; row_len];
let mut pixels = Vec::new();
pixels.try_reserve_exact(total).map_err(|_| bad("PCX pixel buffer is too large"))?;
pixels.resize(total, 0);
let mut p = HEADER;
let width = w as usize;
for y in 0..h as usize {
read_row(&b[..image_end], &mut p, &mut row)?;
for x in 0..width {
let at = (y * width + x) * ch;
let rgb = if bits == 8 && planes >= 3 {
if planes == 4 {
pixels[at + 3] = row[3 * stride + x];
}
[row[x], row[stride + x], row[2 * stride + x]]
} else {
let index = if bits == 8 {
usize::from(row[x])
} else {
let bit = x * bits;
let shift = 8 - bits - (bit % 8);
let mask = (1usize << bits) - 1;
(0..planes).fold(0usize, |v, plane| {
let sample = (usize::from(row[plane * stride + bit / 8]) >> shift) & mask;
v | sample << (plane * bits)
})
};
if vga {
let o = image_end + 1 + index * 3;
[b[o], b[o + 1], b[o + 2]]
} else if bits == 8 {
let g = index as u8;
[g, g, g] // palette-info 2: gray scale
} else {
let o = 16 + index * 3;
[b[o], b[o + 1], b[o + 2]]
}
};
pixels[at..at + 3].copy_from_slice(&rgb);
}
}
let mut image = Image::from_u8(w, h, layout, pixels)?;
let (xdpi, ydpi) = (le16(b, 12), le16(b, 14));
if xdpi > 0 && ydpi > 0 {
image.dpi = Some((f32::from(xdpi), f32::from(ydpi)));
}
Ok(image)
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
bridge::format(Format::Pcx, bytes, limits)
}
+12 -351
View File
@@ -1,357 +1,18 @@
//! Netpbm family, implemented here: P1–P6 (PBM/PGM/PPM, ASCII and binary),
//! P7 (PAM, including the common `CMYK`/`CMYK_ALPHA` tuple types) and PFM
//! (`PF` colour / `Pf` gray float).
//!
//! Writing picks the subtype from the image: float → PFM (gray/RGB), gray
//! → P5, RGB → P6, anything with alpha or CMYK → P7.
//! Netpbm compatibility facade; implementation and bounds live in craft-image-codecs.
use crate::{CodecError, Image, Limits, bridge};
use craft_image_codecs::Format;
use crate::{ChannelLayout, CodecError, Image, Limits, SampleType};
const F: &str = "PNM";
fn err(msg: impl std::fmt::Display) -> CodecError {
CodecError::malformed(F, msg)
pub fn looks_like_pnm(bytes: &[u8]) -> bool {
craft_image_codecs::detect(bytes) == Some(Format::Pnm)
}
struct Reader<'a> {
b: &'a [u8],
pos: usize,
}
impl<'a> Reader<'a> {
fn skip_ws_and_comments(&mut self) {
while self.pos < self.b.len() {
let c = self.b[self.pos];
if c == b'#' {
while self.pos < self.b.len() && self.b[self.pos] != b'\n' && self.b[self.pos] != b'\r' {
self.pos += 1;
}
} else if c.is_ascii_whitespace() {
self.pos += 1;
} else {
break;
}
}
}
fn token(&mut self) -> Result<&'a [u8], CodecError> {
self.skip_ws_and_comments();
let start = self.pos;
while self.pos < self.b.len() && !self.b[self.pos].is_ascii_whitespace() && self.b[self.pos] != b'#' {
self.pos += 1;
}
if start == self.pos {
return Err(err("unexpected end of header"));
}
Ok(&self.b[start..self.pos])
}
fn uint(&mut self) -> Result<u32, CodecError> {
let t = self.token()?;
std::str::from_utf8(t).ok().and_then(|s| s.parse::<u32>().ok()).ok_or_else(|| err("invalid integer in header"))
}
/// Consume the single whitespace byte that separates header and raster.
fn single_ws(&mut self) -> Result<(), CodecError> {
match self.b.get(self.pos) {
Some(c) if c.is_ascii_whitespace() => {
self.pos += 1;
Ok(())
}
_ => Err(err("missing whitespace after header")),
}
}
/// PAM ends its header with an LF-terminated line, unlike P4–P6's single separator.
fn pam_endhdr(&mut self) -> Result<(), CodecError> {
while let Some(&c) = self.b.get(self.pos) {
self.pos += 1;
if c == b'\n' {
// Stop at the first LF: whitespace and '#' after it are raster bytes.
return Ok(());
}
if !c.is_ascii_whitespace() {
return Err(err("unexpected data after PAM ENDHDR"));
}
}
Err(err("unterminated PAM ENDHDR line"))
}
fn rest(&self) -> &'a [u8] {
&self.b[self.pos.min(self.b.len())..]
}
}
fn sample_for_maxval(maxval: u32) -> Result<SampleType, CodecError> {
match maxval {
1..=255 => Ok(SampleType::U8),
256..=65535 => Ok(SampleType::U16),
_ => Err(err(format!("invalid maxval {maxval}"))),
}
}
/// The decoded raster, built straight in the output representation. It is the only buffer sized
/// by the header, so `Limits::check` on the output budgets all of it: no wider scratch buffer
/// (such as one `u32` per sample) sits beside it.
struct Samples {
maxval: u32,
sample: SampleType,
bytes: Vec<u8>,
}
impl Samples {
/// Reserve room for `cap` samples (callers bound `cap` by the file length where the header
/// alone could overstate it).
fn with_capacity(maxval: u32, cap: usize) -> Result<Self, CodecError> {
let sample = sample_for_maxval(maxval)?;
let len = cap.checked_mul(sample.bytes()).ok_or_else(|| CodecError::LimitExceeded(format!("{cap} samples do not fit in memory")))?;
let mut bytes = Vec::new();
bytes.try_reserve_exact(len).map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {len} bytes for the image")))?;
Ok(Samples { maxval, sample, bytes })
}
/// Append one raw value in `[0, maxval]`, rescaled to the full range of the output sample.
fn push(&mut self, v: u32) -> Result<(), CodecError> {
let m = self.maxval;
if v > m {
return Err(err("sample exceeds maxval"));
}
match (self.sample, m) {
(SampleType::U8, 255) => self.bytes.push(v as u8),
(SampleType::U8, m) => self.bytes.push(((v * 255 + m / 2) / m) as u8),
(_, 65535) => self.bytes.extend_from_slice(&(v as u16).to_ne_bytes()),
(_, m) => self.bytes.extend_from_slice(&(((v as u64 * 65535 + m as u64 / 2) / m as u64) as u16).to_ne_bytes()),
}
Ok(())
}
fn into_image(self, w: u32, h: u32, layout: ChannelLayout) -> Result<Image, CodecError> {
Image::from_raw(w, h, layout, self.sample, self.bytes)
}
}
/// `w × h × channels` samples. `Limits::none()` lets any header through, so the product is
/// checked here rather than trusted to the limits.
fn sample_count(w: u32, h: u32, channels: usize) -> Result<usize, CodecError> {
(w as usize)
.checked_mul(h as usize)
.and_then(|p| p.checked_mul(channels))
.ok_or_else(|| CodecError::LimitExceeded(format!("{w}x{h}x{channels} samples do not fit in memory")))
}
fn read_binary(data: &[u8], n: usize, maxval: u32) -> Result<Samples, CodecError> {
let mut out = Samples::with_capacity(maxval, n)?;
if maxval < 256 {
let Some(raw) = data.get(..n) else {
return Err(err("truncated raster"));
};
for &v in raw {
out.push(v as u32)?;
}
} else {
let Some(raw) = n.checked_mul(2).and_then(|len| data.get(..len)) else {
return Err(err("truncated raster"));
};
for c in raw.as_chunks::<2>().0 {
out.push(u16::from_be_bytes(*c) as u32)?;
}
}
Ok(out)
}
/// `P1`..`P7`, `PF` or `Pf` followed by white space.
pub fn looks_like_pnm(b: &[u8]) -> bool {
matches!(b, [b'P', b'1'..=b'7' | b'F' | b'f', s, ..] if s.is_ascii_whitespace())
}
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
if bytes.len() < 2 || bytes[0] != b'P' {
return Err(err("not a Netpbm file"));
}
let kind = bytes[1];
let mut r = Reader { b: bytes, pos: 2 };
match kind {
b'1' | b'4' => {
let (w, h) = (r.uint()?, r.uint()?);
limits.check(w, h, ChannelLayout::Gray, SampleType::U8)?;
let n = sample_count(w, h, 1)?;
let mut px;
if kind == b'4' {
r.single_ws()?;
let row = (w as usize).div_ceil(8);
let data = r.rest();
if row.checked_mul(h as usize).is_none_or(|len| data.len() < len) {
return Err(err("truncated raster"));
}
px = Vec::with_capacity(n);
for y in 0..h as usize {
for x in 0..w as usize {
let bit = (data[y * row + x / 8] >> (7 - x % 8)) & 1;
px.push(if bit == 1 { 0 } else { 255 });
}
}
} else {
// Each ASCII pixel takes at least a byte, so the file bounds the reservation.
px = Vec::with_capacity(n.min(r.rest().len()));
while px.len() < n {
r.skip_ws_and_comments();
match r.b.get(r.pos) {
Some(b'0') => px.push(255),
Some(b'1') => px.push(0),
Some(_) => return Err(err("invalid PBM digit")),
None => return Err(err("truncated raster")),
}
r.pos += 1;
}
}
Image::from_u8(w, h, ChannelLayout::Gray, px)
}
b'2' | b'3' | b'5' | b'6' => {
let (w, h, maxval) = (r.uint()?, r.uint()?, r.uint()?);
let layout = if matches!(kind, b'2' | b'5') { ChannelLayout::Gray } else { ChannelLayout::Rgb };
limits.check(w, h, layout, sample_for_maxval(maxval)?)?;
let n = sample_count(w, h, layout.channels())?;
let samples = if matches!(kind, b'5' | b'6') {
r.single_ws()?;
read_binary(r.rest(), n, maxval)?
} else {
// Each ASCII sample is a digit and a separator (the last may lack one), so the
// file, not the header, bounds the reservation.
let mut v = Samples::with_capacity(maxval, n.min(r.rest().len() / 2 + 1))?;
for _ in 0..n {
v.push(r.uint()?)?;
}
v
};
samples.into_image(w, h, layout)
}
b'7' => decode_pam(&mut r, limits),
b'F' | b'f' => {
let layout = if kind == b'F' { ChannelLayout::Rgb } else { ChannelLayout::Gray };
let (w, h) = (r.uint()?, r.uint()?);
let scale: f32 = std::str::from_utf8(r.token()?)
.ok()
.and_then(|s| s.parse().ok())
.filter(|s: &f32| s.is_finite() && *s != 0.0)
.ok_or_else(|| err("invalid PFM scale"))?;
r.single_ws()?;
limits.check(w, h, layout, SampleType::F32)?;
let nc = layout.channels();
let row = w as usize * nc;
let data = r.rest();
if sample_count(w, h, nc)?.checked_mul(4).is_none_or(|len| data.len() < len) {
return Err(err("truncated raster"));
}
let le = scale < 0.0;
// Write native-endian bytes straight into the output buffer: a separate `Vec<f32>`
// would double the budgeted allocation.
let row_bytes = row * 4;
let mut out = vec![0u8; row_bytes * h as usize];
for (y, src) in data.chunks_exact(row_bytes).take(h as usize).enumerate() {
// PFM rows are stored bottom-to-top.
let dst_start = (h as usize - 1 - y) * row_bytes;
let Some(dst) = out.get_mut(dst_start..dst_start + row_bytes) else {
return Err(err("truncated raster"));
};
for (d, s) in dst.as_chunks_mut::<4>().0.iter_mut().zip(src.as_chunks::<4>().0) {
let v = if le { f32::from_le_bytes(*s) } else { f32::from_be_bytes(*s) };
*d = v.to_ne_bytes();
}
}
Image::from_raw(w, h, layout, SampleType::F32, out)
}
_ => Err(err("unknown Netpbm subtype")),
}
bridge::format(Format::Pnm, bytes, limits)
}
fn decode_pam(r: &mut Reader<'_>, limits: &Limits) -> Result<Image, CodecError> {
let (mut w, mut h, mut depth, mut maxval) = (None, None, None, None);
let mut tupltype = String::new();
loop {
let tok = r.token()?;
match tok {
b"WIDTH" => w = Some(r.uint()?),
b"HEIGHT" => h = Some(r.uint()?),
b"DEPTH" => depth = Some(r.uint()?),
b"MAXVAL" => maxval = Some(r.uint()?),
b"TUPLTYPE" => {
let t = r.token()?;
if !tupltype.is_empty() {
tupltype.push(' ');
}
tupltype.push_str(std::str::from_utf8(t).map_err(|_| err("bad TUPLTYPE"))?);
}
b"ENDHDR" => break,
_ => return Err(err("unknown PAM header field")),
}
pub fn encode(image: &Image) -> Result<Vec<u8>, CodecError> {
// PFM has only gray and RGB tuples. Preserve this facade's contract that
// unsupported layouts are refused instead of silently dropping alpha.
if image.sample_type() == crate::SampleType::F32 && !matches!(image.layout(), crate::ChannelLayout::Gray | crate::ChannelLayout::Rgb) {
return Err(CodecError::encode("PNM", format!("PFM cannot store {:?}", image.layout())));
}
r.pam_endhdr()?;
let (w, h, depth, maxval) = match (w, h, depth, maxval) {
(Some(a), Some(b), Some(c), Some(d)) => (a, b, c, d),
_ => return Err(err("incomplete PAM header")),
};
let layout = match (tupltype.as_str(), depth) {
("BLACKANDWHITE" | "GRAYSCALE", 1) | ("", 1) => ChannelLayout::Gray,
("BLACKANDWHITE_ALPHA" | "GRAYSCALE_ALPHA", 2) | ("", 2) => ChannelLayout::GrayA,
("RGB", 3) | ("", 3) => ChannelLayout::Rgb,
("RGB_ALPHA", 4) | ("", 4) => ChannelLayout::Rgba,
("CMYK", 4) => ChannelLayout::Cmyk,
("CMYK_ALPHA", 5) => ChannelLayout::CmykA,
(t, d) => {
return Err(CodecError::unsupported(F, format!("PAM tuple type {t:?} with depth {d}")));
}
};
limits.check(w, h, layout, sample_for_maxval(maxval)?)?;
let n = sample_count(w, h, layout.channels())?;
read_binary(r.rest(), n, maxval)?.into_image(w, h, layout)
}
/// Writes `img` as PGM/PPM (gray, RGB), PAM (alpha, CMYK) or PFM (float gray, RGB).
pub fn encode(img: &Image) -> Result<Vec<u8>, CodecError> {
let (w, h) = (img.width(), img.height());
let layout = img.layout();
let mut out = Vec::new();
match img.sample_type() {
SampleType::F32 => {
let tag = match layout {
ChannelLayout::Gray => "Pf",
ChannelLayout::Rgb => "PF",
l => return Err(CodecError::encode(F, format!("PFM cannot store {l:?}"))),
};
out.extend_from_slice(format!("{tag}\n{w} {h}\n-1.0\n").as_bytes());
let s = img.to_f32_samples().unwrap_or_default();
let row = w as usize * layout.channels();
for y in (0..h as usize).rev() {
for v in &s[y * row..(y + 1) * row] {
out.extend_from_slice(&v.to_le_bytes());
}
}
}
sample @ (SampleType::U8 | SampleType::U16) => {
let maxval = if sample == SampleType::U8 { 255 } else { 65535 };
match layout {
ChannelLayout::Gray => out.extend_from_slice(format!("P5\n{w} {h}\n{maxval}\n").as_bytes()),
ChannelLayout::Rgb => out.extend_from_slice(format!("P6\n{w} {h}\n{maxval}\n").as_bytes()),
l => {
let t = match l {
ChannelLayout::GrayA => "GRAYSCALE_ALPHA",
ChannelLayout::Rgba => "RGB_ALPHA",
ChannelLayout::Cmyk => "CMYK",
_ => "CMYK_ALPHA",
};
out.extend_from_slice(
format!("P7\nWIDTH {w}\nHEIGHT {h}\nDEPTH {}\nMAXVAL {maxval}\nTUPLTYPE {t}\nENDHDR\n", l.channels()).as_bytes(),
);
}
}
if sample == SampleType::U8 {
out.extend_from_slice(img.data());
} else {
for v in img.to_u16_samples().unwrap_or_default() {
out.extend_from_slice(&v.to_be_bytes());
}
}
}
}
Ok(out)
bridge::encode(image, Format::Pnm, &Default::default())
}
+7 -237
View File
@@ -1,243 +1,13 @@
//! X PixMap reader for XPM2 plain-text icons and XPM3 C-source icon arrays.
//! Supports transparency (None), RGB hex at 4/8/16 bits per channel and
//! common X11 colour names. Does not execute C code.
//! XPM compatibility facade; implementation and color-name data live in craft-image-codecs.
use crate::{CodecError, Image, Limits, bridge};
use craft_image_codecs::Format;
use std::collections::HashMap;
mod x11_colors;
use crate::{ChannelLayout, CodecError, Image, Limits, SampleType};
const MAX_SOURCE: usize = 256 << 20;
const MAX_COLOURS: usize = 65_536;
const MAX_CPP: usize = 8;
fn bad(msg: impl std::fmt::Display) -> CodecError {
CodecError::malformed("XPM", msg)
}
/// Extract C string literals without treating quoted text or // in a string as a comment.
/// XPM uses one literal for the header, each palette entry and each row.
fn c_strings(bytes: &[u8]) -> Result<Vec<Vec<u8>>, CodecError> {
let mut lines = Vec::new();
let mut i = 0usize;
while i < bytes.len() {
if bytes[i..].starts_with(b"/*") {
let tail = &bytes[i + 2..];
let Some(end) = tail.windows(2).position(|p| p == b"*/") else { return Err(bad("unterminated C comment")) };
i += end + 4;
} else if bytes[i..].starts_with(b"//") {
i += bytes[i..].iter().position(|&c| c == b'\n').unwrap_or(bytes.len() - i);
} else if bytes[i] == b'"' {
i += 1;
let mut s = Vec::new();
let mut closed = false;
while i < bytes.len() {
let c = bytes[i];
i += 1;
match c {
b'"' => {
closed = true;
break;
}
b'\\' => {
let next = *bytes.get(i).ok_or_else(|| bad("truncated C escape"))?;
i += 1;
s.push(match next {
b'n' => b'\n',
b'r' => b'\r',
b't' => b'\t',
b'0' => 0,
_ => next, // quoted backslash or quote
});
}
_ => s.push(c),
}
}
if !closed {
return Err(bad("unterminated XPM string"));
}
lines.push(s);
} else {
i += 1;
}
}
Ok(lines)
}
/// Extract XPM2's plain-text lines without trimming pixel rows: leading and
/// trailing spaces can be palette keys, and physical CRLF is not image data.
fn xpm2_lines(bytes: &[u8]) -> Result<Vec<Vec<u8>>, CodecError> {
let mut input = bytes.split(|&b| b == b'\n');
let header = input.next().ok_or_else(|| bad("missing XPM2 marker"))?;
if header.strip_suffix(b"\r").unwrap_or(header) != b"! XPM2" {
return Err(bad("not an XPM2 image"));
}
let mut lines = Vec::new();
for raw in input {
let line = raw.strip_suffix(b"\r").unwrap_or(raw);
// The header may be preceded by comments and blank lines. After the
// header, a leading '!' is allowed as a palette key or pixel value.
if lines.is_empty() && (line.is_empty() || line.starts_with(b"!")) {
continue;
}
lines.push(line.to_vec());
}
Ok(lines)
}
fn channel(hex: &str) -> Option<u8> {
let v = u32::from_str_radix(hex, 16).ok()?;
let max = (1u32 << (hex.len() * 4)) - 1;
Some(((v * 255 + max / 2) / max) as u8)
}
fn named(name: &str) -> Option<[u8; 3]> {
let s = name.to_ascii_lowercase().replace([' ', '-', '_'], "");
// XPM imports X11 names, whose RGB values differ from CSS for names
// such as gray, maroon and purple. Keep these exact rather than guessing.
if let Ok(index) = x11_colors::X11_COLORS.binary_search_by_key(&s.as_str(), |(name, _)| *name) {
return Some(x11_colors::X11_COLORS[index].1);
}
// Retain useful web color aliases not present in the X11 database.
Some(match s.as_str() {
"silver" => [192, 192, 192],
"olive" => [128, 128, 0],
"teal" => [0, 128, 128],
"fuchsia" => [255, 0, 255],
"navyblue" => [0, 0, 128],
_ => return None,
})
}
/// Look up an exact normalized X11 color name as RGB channels in `0..=1`.
///
/// Names must contain 1–64 bytes of lowercase ASCII letters or digits. Unknown names,
/// unnormalized names and XPM-only aliases return `None`; this does not parse hex colors
/// or transparency. Values are the stored X11 bytes divided by 255, without CSS overrides
/// or color-space conversion. XPM decoding retains its own normalization and alias policy.
pub fn x11_color_rgb(name: &str) -> Option<[f32; 3]> {
// Bound work on untrusted names before searching the shared table, without allocating.
if name.is_empty() || name.len() > 64 || !name.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit()) {
return None;
}
let index = x11_colors::X11_COLORS.binary_search_by_key(&name, |(entry, _)| *entry).ok()?;
let (_, rgb) = x11_colors::X11_COLORS.get(index)?;
Some(rgb.map(|channel| f32::from(channel) / 255.0))
craft_image_codecs::xpm_named_color_rgb(name)
}
fn color(name: &str) -> Option<[u8; 4]> {
if name.eq_ignore_ascii_case("none") {
return Some([0, 0, 0, 0]);
}
let rgb = if let Some(hex) = name.strip_prefix('#') {
// UTF-8 byte lengths can match a supported hex width while slicing would panic.
// `from_str_radix` would also take a leading `+`: accept hex digits only.
if !hex.bytes().all(|b| b.is_ascii_hexdigit()) {
return None;
}
let digits = match hex.len() {
3 => 1,
6 => 2,
12 => 4,
_ => return None,
};
let rgb = (0..3).map(|i| channel(&hex[i * digits..(i + 1) * digits])).collect::<Option<Vec<_>>>()?;
[rgb[0], rgb[1], rgb[2]]
} else {
named(name)?
};
Some([rgb[0], rgb[1], rgb[2], 255])
pub fn looks_like_xpm(bytes: &[u8]) -> bool {
craft_image_codecs::detect(bytes) == Some(Format::Xpm)
}
/// The XPM3 comment or the XPM2 first line.
pub fn looks_like_xpm(b: &[u8]) -> bool {
b.starts_with(b"/* XPM */") || b.starts_with(b"! XPM2\n") || b.starts_with(b"! XPM2\r\n")
}
pub fn decode(bytes: &[u8], limits: &Limits) -> Result<Image, CodecError> {
if bytes.len() > MAX_SOURCE {
return Err(CodecError::LimitExceeded("XPM source exceeds 256 MiB".into()));
}
let lines = if bytes.starts_with(b"/* XPM */") {
c_strings(bytes)?
} else if bytes.starts_with(b"! XPM2\n") || bytes.starts_with(b"! XPM2\r\n") {
xpm2_lines(bytes)?
} else {
return Err(bad("not an XPM2/XPM3 image"));
};
decode_lines(&lines, limits)
}
fn decode_lines(lines: &[Vec<u8>], limits: &Limits) -> Result<Image, CodecError> {
let header = lines.first().ok_or_else(|| bad("missing image header"))?;
let parts = std::str::from_utf8(header).map_err(|_| bad("non-UTF-8 XPM header"))?;
let mut parts = parts.split_ascii_whitespace();
let number = |key: &str, s: Option<&str>| -> Result<usize, CodecError> {
s.ok_or_else(|| bad(format!("missing {key}")))?.parse::<usize>().map_err(|_| bad(format!("invalid {key}")))
};
let width = number("width", parts.next())?;
let height = number("height", parts.next())?;
let colours = number("palette size", parts.next())?;
let cpp = number("chars per pixel", parts.next())?;
if width == 0 || height == 0 || colours == 0 || colours > MAX_COLOURS || !(1..=MAX_CPP).contains(&cpp) {
return Err(bad("invalid XPM dimensions, palette size or chars per pixel"));
}
let (w, h) = (u32::try_from(width).map_err(|_| bad("width overflow"))?, u32::try_from(height).map_err(|_| bad("height overflow"))?);
limits.check(w, h, ChannelLayout::Rgba, SampleType::U8)?;
let required = 1usize.checked_add(colours).and_then(|n| n.checked_add(height)).ok_or_else(|| bad("row count overflow"))?;
if lines.len() < required {
return Err(bad("truncated palette or image rows"));
}
let mut palette = HashMap::<Vec<u8>, [u8; 4]>::with_capacity(colours);
for line in &lines[1..1 + colours] {
if line.len() < cpp {
return Err(bad("truncated colour key"));
}
let fields = std::str::from_utf8(&line[cpp..]).map_err(|_| bad("invalid colour name"))?;
// XPM priority is colour, gray, four-level gray, then monochrome,
// regardless of the order of keys in the palette entry.
let terms: Vec<&str> = fields.split_ascii_whitespace().collect();
let mut picked: Option<(u8, String)> = None;
let mut i = 0;
while i < terms.len() {
let priority = match terms[i] {
"c" => 4,
"g" => 3,
"g4" => 2,
"m" => 1,
_ => 0, // Symbolic names ('s') are not colour values.
};
let start = i + 1;
i = start;
while i < terms.len() && !matches!(terms[i], "c" | "g" | "g4" | "m" | "s") {
i += 1;
}
if priority > 0 && i > start && picked.as_ref().is_none_or(|(current, _)| priority > *current) {
picked = Some((priority, terms[start..i].join(" ")));
}
}
let value = picked.as_ref().and_then(|(_, name)| color(name)).ok_or_else(|| bad("unsupported or missing XPM colour"))?;
if palette.insert(line[..cpp].to_vec(), value).is_some() {
return Err(bad("duplicate XPM palette key"));
}
}
let row_len = width.checked_mul(cpp).ok_or_else(|| bad("row byte count overflow"))?;
// Validate all source rows before reserving the decoded RGBA image. A malformed
// short row must not be able to make a large header-sized allocation first.
if lines[1 + colours..required].iter().any(|line| line.len() != row_len) {
return Err(bad("XPM row has the wrong width"));
}
let total = width.checked_mul(height).and_then(|n| n.checked_mul(4)).ok_or_else(|| bad("pixel size overflow"))?;
let mut pixels = Vec::new();
pixels.try_reserve_exact(total).map_err(|_| bad("XPM pixel buffer is too large"))?;
pixels.resize(total, 0);
for (y, line) in lines[1 + colours..required].iter().enumerate() {
for x in 0..width {
let key = &line[x * cpp..(x + 1) * cpp];
let rgba = palette.get(key).ok_or_else(|| bad("unknown palette key"))?;
pixels[(y * width + x) * 4..(y * width + x + 1) * 4].copy_from_slice(rgba);
}
}
Image::from_u8(w, h, ChannelLayout::Rgba, pixels)
bridge::format(Format::Xpm, bytes, limits)
}
-666
View File
@@ -1,666 +0,0 @@
//! X11 color-name database (X.Org rgb.txt) normalized to lowercase without
//! spaces, underscores, or hyphens. RGB values are *X11* values, not CSS values.
//! Source: <https://cgit.freedesktop.org/xorg/app/rgb/tree/rgb.txt>
//! License: MIT (X.Org Foundation), see the upstream app/rgb COPYING file.
//! Aliases differing only in case or spaces have been collapsed.
//! Keep sorted: decoder uses binary search without allocation per candidate.
pub(super) const X11_COLORS: &[(&str, [u8; 3])] = &[
("aliceblue", [240, 248, 255]),
("antiquewhite", [250, 235, 215]),
("antiquewhite1", [255, 239, 219]),
("antiquewhite2", [238, 223, 204]),
("antiquewhite3", [205, 192, 176]),
("antiquewhite4", [139, 131, 120]),
("aquamarine", [127, 255, 212]),
("aquamarine1", [127, 255, 212]),
("aquamarine2", [118, 238, 198]),
("aquamarine3", [102, 205, 170]),
("aquamarine4", [69, 139, 116]),
("azure", [240, 255, 255]),
("azure1", [240, 255, 255]),
("azure2", [224, 238, 238]),
("azure3", [193, 205, 205]),
("azure4", [131, 139, 139]),
("beige", [245, 245, 220]),
("bisque", [255, 228, 196]),
("bisque1", [255, 228, 196]),
("bisque2", [238, 213, 183]),
("bisque3", [205, 183, 158]),
("bisque4", [139, 125, 107]),
("black", [0, 0, 0]),
("blanchedalmond", [255, 235, 205]),
("blue", [0, 0, 255]),
("blue1", [0, 0, 255]),
("blue2", [0, 0, 238]),
("blue3", [0, 0, 205]),
("blue4", [0, 0, 139]),
("blueviolet", [138, 43, 226]),
("brown", [165, 42, 42]),
("brown1", [255, 64, 64]),
("brown2", [238, 59, 59]),
("brown3", [205, 51, 51]),
("brown4", [139, 35, 35]),
("burlywood", [222, 184, 135]),
("burlywood1", [255, 211, 155]),
("burlywood2", [238, 197, 145]),
("burlywood3", [205, 170, 125]),
("burlywood4", [139, 115, 85]),
("cadetblue", [95, 158, 160]),
("cadetblue1", [152, 245, 255]),
("cadetblue2", [142, 229, 238]),
("cadetblue3", [122, 197, 205]),
("cadetblue4", [83, 134, 139]),
("chartreuse", [127, 255, 0]),
("chartreuse1", [127, 255, 0]),
("chartreuse2", [118, 238, 0]),
("chartreuse3", [102, 205, 0]),
("chartreuse4", [69, 139, 0]),
("chocolate", [210, 105, 30]),
("chocolate1", [255, 127, 36]),
("chocolate2", [238, 118, 33]),
("chocolate3", [205, 102, 29]),
("chocolate4", [139, 69, 19]),
("coral", [255, 127, 80]),
("coral1", [255, 114, 86]),
("coral2", [238, 106, 80]),
("coral3", [205, 91, 69]),
("coral4", [139, 62, 47]),
("cornflowerblue", [100, 149, 237]),
("cornsilk", [255, 248, 220]),
("cornsilk1", [255, 248, 220]),
("cornsilk2", [238, 232, 205]),
("cornsilk3", [205, 200, 177]),
("cornsilk4", [139, 136, 120]),
("cyan", [0, 255, 255]),
("cyan1", [0, 255, 255]),
("cyan2", [0, 238, 238]),
("cyan3", [0, 205, 205]),
("cyan4", [0, 139, 139]),
("darkblue", [0, 0, 139]),
("darkcyan", [0, 139, 139]),
("darkgoldenrod", [184, 134, 11]),
("darkgoldenrod1", [255, 185, 15]),
("darkgoldenrod2", [238, 173, 14]),
("darkgoldenrod3", [205, 149, 12]),
("darkgoldenrod4", [139, 101, 8]),
("darkgray", [169, 169, 169]),
("darkgreen", [0, 100, 0]),
("darkgrey", [169, 169, 169]),
("darkkhaki", [189, 183, 107]),
("darkmagenta", [139, 0, 139]),
("darkolivegreen", [85, 107, 47]),
("darkolivegreen1", [202, 255, 112]),
("darkolivegreen2", [188, 238, 104]),
("darkolivegreen3", [162, 205, 90]),
("darkolivegreen4", [110, 139, 61]),
("darkorange", [255, 140, 0]),
("darkorange1", [255, 127, 0]),
("darkorange2", [238, 118, 0]),
("darkorange3", [205, 102, 0]),
("darkorange4", [139, 69, 0]),
("darkorchid", [153, 50, 204]),
("darkorchid1", [191, 62, 255]),
("darkorchid2", [178, 58, 238]),
("darkorchid3", [154, 50, 205]),
("darkorchid4", [104, 34, 139]),
("darkred", [139, 0, 0]),
("darksalmon", [233, 150, 122]),
("darkseagreen", [143, 188, 143]),
("darkseagreen1", [193, 255, 193]),
("darkseagreen2", [180, 238, 180]),
("darkseagreen3", [155, 205, 155]),
("darkseagreen4", [105, 139, 105]),
("darkslateblue", [72, 61, 139]),
("darkslategray", [47, 79, 79]),
("darkslategray1", [151, 255, 255]),
("darkslategray2", [141, 238, 238]),
("darkslategray3", [121, 205, 205]),
("darkslategray4", [82, 139, 139]),
("darkslategrey", [47, 79, 79]),
("darkturquoise", [0, 206, 209]),
("darkviolet", [148, 0, 211]),
("deeppink", [255, 20, 147]),
("deeppink1", [255, 20, 147]),
("deeppink2", [238, 18, 137]),
("deeppink3", [205, 16, 118]),
("deeppink4", [139, 10, 80]),
("deepskyblue", [0, 191, 255]),
("deepskyblue1", [0, 191, 255]),
("deepskyblue2", [0, 178, 238]),
("deepskyblue3", [0, 154, 205]),
("deepskyblue4", [0, 104, 139]),
("dimgray", [105, 105, 105]),
("dimgrey", [105, 105, 105]),
("dodgerblue", [30, 144, 255]),
("dodgerblue1", [30, 144, 255]),
("dodgerblue2", [28, 134, 238]),
("dodgerblue3", [24, 116, 205]),
("dodgerblue4", [16, 78, 139]),
("firebrick", [178, 34, 34]),
("firebrick1", [255, 48, 48]),
("firebrick2", [238, 44, 44]),
("firebrick3", [205, 38, 38]),
("firebrick4", [139, 26, 26]),
("floralwhite", [255, 250, 240]),
("forestgreen", [34, 139, 34]),
("gainsboro", [220, 220, 220]),
("ghostwhite", [248, 248, 255]),
("gold", [255, 215, 0]),
("gold1", [255, 215, 0]),
("gold2", [238, 201, 0]),
("gold3", [205, 173, 0]),
("gold4", [139, 117, 0]),
("goldenrod", [218, 165, 32]),
("goldenrod1", [255, 193, 37]),
("goldenrod2", [238, 180, 34]),
("goldenrod3", [205, 155, 29]),
("goldenrod4", [139, 105, 20]),
("gray", [190, 190, 190]),
("gray0", [0, 0, 0]),
("gray1", [3, 3, 3]),
("gray10", [26, 26, 26]),
("gray100", [255, 255, 255]),
("gray11", [28, 28, 28]),
("gray12", [31, 31, 31]),
("gray13", [33, 33, 33]),
("gray14", [36, 36, 36]),
("gray15", [38, 38, 38]),
("gray16", [41, 41, 41]),
("gray17", [43, 43, 43]),
("gray18", [46, 46, 46]),
("gray19", [48, 48, 48]),
("gray2", [5, 5, 5]),
("gray20", [51, 51, 51]),
("gray21", [54, 54, 54]),
("gray22", [56, 56, 56]),
("gray23", [59, 59, 59]),
("gray24", [61, 61, 61]),
("gray25", [64, 64, 64]),
("gray26", [66, 66, 66]),
("gray27", [69, 69, 69]),
("gray28", [71, 71, 71]),
("gray29", [74, 74, 74]),
("gray3", [8, 8, 8]),
("gray30", [77, 77, 77]),
("gray31", [79, 79, 79]),
("gray32", [82, 82, 82]),
("gray33", [84, 84, 84]),
("gray34", [87, 87, 87]),
("gray35", [89, 89, 89]),
("gray36", [92, 92, 92]),
("gray37", [94, 94, 94]),
("gray38", [97, 97, 97]),
("gray39", [99, 99, 99]),
("gray4", [10, 10, 10]),
("gray40", [102, 102, 102]),
("gray41", [105, 105, 105]),
("gray42", [107, 107, 107]),
("gray43", [110, 110, 110]),
("gray44", [112, 112, 112]),
("gray45", [115, 115, 115]),
("gray46", [117, 117, 117]),
("gray47", [120, 120, 120]),
("gray48", [122, 122, 122]),
("gray49", [125, 125, 125]),
("gray5", [13, 13, 13]),
("gray50", [127, 127, 127]),
("gray51", [130, 130, 130]),
("gray52", [133, 133, 133]),
("gray53", [135, 135, 135]),
("gray54", [138, 138, 138]),
("gray55", [140, 140, 140]),
("gray56", [143, 143, 143]),
("gray57", [145, 145, 145]),
("gray58", [148, 148, 148]),
("gray59", [150, 150, 150]),
("gray6", [15, 15, 15]),
("gray60", [153, 153, 153]),
("gray61", [156, 156, 156]),
("gray62", [158, 158, 158]),
("gray63", [161, 161, 161]),
("gray64", [163, 163, 163]),
("gray65", [166, 166, 166]),
("gray66", [168, 168, 168]),
("gray67", [171, 171, 171]),
("gray68", [173, 173, 173]),
("gray69", [176, 176, 176]),
("gray7", [18, 18, 18]),
("gray70", [179, 179, 179]),
("gray71", [181, 181, 181]),
("gray72", [184, 184, 184]),
("gray73", [186, 186, 186]),
("gray74", [189, 189, 189]),
("gray75", [191, 191, 191]),
("gray76", [194, 194, 194]),
("gray77", [196, 196, 196]),
("gray78", [199, 199, 199]),
("gray79", [201, 201, 201]),
("gray8", [20, 20, 20]),
("gray80", [204, 204, 204]),
("gray81", [207, 207, 207]),
("gray82", [209, 209, 209]),
("gray83", [212, 212, 212]),
("gray84", [214, 214, 214]),
("gray85", [217, 217, 217]),
("gray86", [219, 219, 219]),
("gray87", [222, 222, 222]),
("gray88", [224, 224, 224]),
("gray89", [227, 227, 227]),
("gray9", [23, 23, 23]),
("gray90", [229, 229, 229]),
("gray91", [232, 232, 232]),
("gray92", [235, 235, 235]),
("gray93", [237, 237, 237]),
("gray94", [240, 240, 240]),
("gray95", [242, 242, 242]),
("gray96", [245, 245, 245]),
("gray97", [247, 247, 247]),
("gray98", [250, 250, 250]),
("gray99", [252, 252, 252]),
("green", [0, 255, 0]),
("green1", [0, 255, 0]),
("green2", [0, 238, 0]),
("green3", [0, 205, 0]),
("green4", [0, 139, 0]),
("greenyellow", [173, 255, 47]),
("grey", [190, 190, 190]),
("grey0", [0, 0, 0]),
("grey1", [3, 3, 3]),
("grey10", [26, 26, 26]),
("grey100", [255, 255, 255]),
("grey11", [28, 28, 28]),
("grey12", [31, 31, 31]),
("grey13", [33, 33, 33]),
("grey14", [36, 36, 36]),
("grey15", [38, 38, 38]),
("grey16", [41, 41, 41]),
("grey17", [43, 43, 43]),
("grey18", [46, 46, 46]),
("grey19", [48, 48, 48]),
("grey2", [5, 5, 5]),
("grey20", [51, 51, 51]),
("grey21", [54, 54, 54]),
("grey22", [56, 56, 56]),
("grey23", [59, 59, 59]),
("grey24", [61, 61, 61]),
("grey25", [64, 64, 64]),
("grey26", [66, 66, 66]),
("grey27", [69, 69, 69]),
("grey28", [71, 71, 71]),
("grey29", [74, 74, 74]),
("grey3", [8, 8, 8]),
("grey30", [77, 77, 77]),
("grey31", [79, 79, 79]),
("grey32", [82, 82, 82]),
("grey33", [84, 84, 84]),
("grey34", [87, 87, 87]),
("grey35", [89, 89, 89]),
("grey36", [92, 92, 92]),
("grey37", [94, 94, 94]),
("grey38", [97, 97, 97]),
("grey39", [99, 99, 99]),
("grey4", [10, 10, 10]),
("grey40", [102, 102, 102]),
("grey41", [105, 105, 105]),
("grey42", [107, 107, 107]),
("grey43", [110, 110, 110]),
("grey44", [112, 112, 112]),
("grey45", [115, 115, 115]),
("grey46", [117, 117, 117]),
("grey47", [120, 120, 120]),
("grey48", [122, 122, 122]),
("grey49", [125, 125, 125]),
("grey5", [13, 13, 13]),
("grey50", [127, 127, 127]),
("grey51", [130, 130, 130]),
("grey52", [133, 133, 133]),
("grey53", [135, 135, 135]),
("grey54", [138, 138, 138]),
("grey55", [140, 140, 140]),
("grey56", [143, 143, 143]),
("grey57", [145, 145, 145]),
("grey58", [148, 148, 148]),
("grey59", [150, 150, 150]),
("grey6", [15, 15, 15]),
("grey60", [153, 153, 153]),
("grey61", [156, 156, 156]),
("grey62", [158, 158, 158]),
("grey63", [161, 161, 161]),
("grey64", [163, 163, 163]),
("grey65", [166, 166, 166]),
("grey66", [168, 168, 168]),
("grey67", [171, 171, 171]),
("grey68", [173, 173, 173]),
("grey69", [176, 176, 176]),
("grey7", [18, 18, 18]),
("grey70", [179, 179, 179]),
("grey71", [181, 181, 181]),
("grey72", [184, 184, 184]),
("grey73", [186, 186, 186]),
("grey74", [189, 189, 189]),
("grey75", [191, 191, 191]),
("grey76", [194, 194, 194]),
("grey77", [196, 196, 196]),
("grey78", [199, 199, 199]),
("grey79", [201, 201, 201]),
("grey8", [20, 20, 20]),
("grey80", [204, 204, 204]),
("grey81", [207, 207, 207]),
("grey82", [209, 209, 209]),
("grey83", [212, 212, 212]),
("grey84", [214, 214, 214]),
("grey85", [217, 217, 217]),
("grey86", [219, 219, 219]),
("grey87", [222, 222, 222]),
("grey88", [224, 224, 224]),
("grey89", [227, 227, 227]),
("grey9", [23, 23, 23]),
("grey90", [229, 229, 229]),
("grey91", [232, 232, 232]),
("grey92", [235, 235, 235]),
("grey93", [237, 237, 237]),
("grey94", [240, 240, 240]),
("grey95", [242, 242, 242]),
("grey96", [245, 245, 245]),
("grey97", [247, 247, 247]),
("grey98", [250, 250, 250]),
("grey99", [252, 252, 252]),
("honeydew", [240, 255, 240]),
("honeydew1", [240, 255, 240]),
("honeydew2", [224, 238, 224]),
("honeydew3", [193, 205, 193]),
("honeydew4", [131, 139, 131]),
("hotpink", [255, 105, 180]),
("hotpink1", [255, 110, 180]),
("hotpink2", [238, 106, 167]),
("hotpink3", [205, 96, 144]),
("hotpink4", [139, 58, 98]),
("indianred", [205, 92, 92]),
("indianred1", [255, 106, 106]),
("indianred2", [238, 99, 99]),
("indianred3", [205, 85, 85]),
("indianred4", [139, 58, 58]),
("ivory", [255, 255, 240]),
("ivory1", [255, 255, 240]),
("ivory2", [238, 238, 224]),
("ivory3", [205, 205, 193]),
("ivory4", [139, 139, 131]),
("khaki", [240, 230, 140]),
("khaki1", [255, 246, 143]),
("khaki2", [238, 230, 133]),
("khaki3", [205, 198, 115]),
("khaki4", [139, 134, 78]),
("lavender", [230, 230, 250]),
("lavenderblush", [255, 240, 245]),
("lavenderblush1", [255, 240, 245]),
("lavenderblush2", [238, 224, 229]),
("lavenderblush3", [205, 193, 197]),
("lavenderblush4", [139, 131, 134]),
("lawngreen", [124, 252, 0]),
("lemonchiffon", [255, 250, 205]),
("lemonchiffon1", [255, 250, 205]),
("lemonchiffon2", [238, 233, 191]),
("lemonchiffon3", [205, 201, 165]),
("lemonchiffon4", [139, 137, 112]),
("lightblue", [173, 216, 230]),
("lightblue1", [191, 239, 255]),
("lightblue2", [178, 223, 238]),
("lightblue3", [154, 192, 205]),
("lightblue4", [104, 131, 139]),
("lightcoral", [240, 128, 128]),
("lightcyan", [224, 255, 255]),
("lightcyan1", [224, 255, 255]),
("lightcyan2", [209, 238, 238]),
("lightcyan3", [180, 205, 205]),
("lightcyan4", [122, 139, 139]),
("lightgoldenrod", [238, 221, 130]),
("lightgoldenrod1", [255, 236, 139]),
("lightgoldenrod2", [238, 220, 130]),
("lightgoldenrod3", [205, 190, 112]),
("lightgoldenrod4", [139, 129, 76]),
("lightgoldenrodyellow", [250, 250, 210]),
("lightgray", [211, 211, 211]),
("lightgreen", [144, 238, 144]),
("lightgrey", [211, 211, 211]),
("lightpink", [255, 182, 193]),
("lightpink1", [255, 174, 185]),
("lightpink2", [238, 162, 173]),
("lightpink3", [205, 140, 149]),
("lightpink4", [139, 95, 101]),
("lightsalmon", [255, 160, 122]),
("lightsalmon1", [255, 160, 122]),
("lightsalmon2", [238, 149, 114]),
("lightsalmon3", [205, 129, 98]),
("lightsalmon4", [139, 87, 66]),
("lightseagreen", [32, 178, 170]),
("lightskyblue", [135, 206, 250]),
("lightskyblue1", [176, 226, 255]),
("lightskyblue2", [164, 211, 238]),
("lightskyblue3", [141, 182, 205]),
("lightskyblue4", [96, 123, 139]),
("lightslateblue", [132, 112, 255]),
("lightslategray", [119, 136, 153]),
("lightslategrey", [119, 136, 153]),
("lightsteelblue", [176, 196, 222]),
("lightsteelblue1", [202, 225, 255]),
("lightsteelblue2", [188, 210, 238]),
("lightsteelblue3", [162, 181, 205]),
("lightsteelblue4", [110, 123, 139]),
("lightyellow", [255, 255, 224]),
("lightyellow1", [255, 255, 224]),
("lightyellow2", [238, 238, 209]),
("lightyellow3", [205, 205, 180]),
("lightyellow4", [139, 139, 122]),
("limegreen", [50, 205, 50]),
("linen", [250, 240, 230]),
("magenta", [255, 0, 255]),
("magenta1", [255, 0, 255]),
("magenta2", [238, 0, 238]),
("magenta3", [205, 0, 205]),
("magenta4", [139, 0, 139]),
("maroon", [176, 48, 96]),
("maroon1", [255, 52, 179]),
("maroon2", [238, 48, 167]),
("maroon3", [205, 41, 144]),
("maroon4", [139, 28, 98]),
("mediumaquamarine", [102, 205, 170]),
("mediumblue", [0, 0, 205]),
("mediumorchid", [186, 85, 211]),
("mediumorchid1", [224, 102, 255]),
("mediumorchid2", [209, 95, 238]),
("mediumorchid3", [180, 82, 205]),
("mediumorchid4", [122, 55, 139]),
("mediumpurple", [147, 112, 219]),
("mediumpurple1", [171, 130, 255]),
("mediumpurple2", [159, 121, 238]),
("mediumpurple3", [137, 104, 205]),
("mediumpurple4", [93, 71, 139]),
("mediumseagreen", [60, 179, 113]),
("mediumslateblue", [123, 104, 238]),
("mediumspringgreen", [0, 250, 154]),
("mediumturquoise", [72, 209, 204]),
("mediumvioletred", [199, 21, 133]),
("midnightblue", [25, 25, 112]),
("mintcream", [245, 255, 250]),
("mistyrose", [255, 228, 225]),
("mistyrose1", [255, 228, 225]),
("mistyrose2", [238, 213, 210]),
("mistyrose3", [205, 183, 181]),
("mistyrose4", [139, 125, 123]),
("moccasin", [255, 228, 181]),
("navajowhite", [255, 222, 173]),
("navajowhite1", [255, 222, 173]),
("navajowhite2", [238, 207, 161]),
("navajowhite3", [205, 179, 139]),
("navajowhite4", [139, 121, 94]),
("navy", [0, 0, 128]),
("navyblue", [0, 0, 128]),
("oldlace", [253, 245, 230]),
("olivedrab", [107, 142, 35]),
("olivedrab1", [192, 255, 62]),
("olivedrab2", [179, 238, 58]),
("olivedrab3", [154, 205, 50]),
("olivedrab4", [105, 139, 34]),
("orange", [255, 165, 0]),
("orange1", [255, 165, 0]),
("orange2", [238, 154, 0]),
("orange3", [205, 133, 0]),
("orange4", [139, 90, 0]),
("orangered", [255, 69, 0]),
("orangered1", [255, 69, 0]),
("orangered2", [238, 64, 0]),
("orangered3", [205, 55, 0]),
("orangered4", [139, 37, 0]),
("orchid", [218, 112, 214]),
("orchid1", [255, 131, 250]),
("orchid2", [238, 122, 233]),
("orchid3", [205, 105, 201]),
("orchid4", [139, 71, 137]),
("palegoldenrod", [238, 232, 170]),
("palegreen", [152, 251, 152]),
("palegreen1", [154, 255, 154]),
("palegreen2", [144, 238, 144]),
("palegreen3", [124, 205, 124]),
("palegreen4", [84, 139, 84]),
("paleturquoise", [175, 238, 238]),
("paleturquoise1", [187, 255, 255]),
("paleturquoise2", [174, 238, 238]),
("paleturquoise3", [150, 205, 205]),
("paleturquoise4", [102, 139, 139]),
("palevioletred", [219, 112, 147]),
("palevioletred1", [255, 130, 171]),
("palevioletred2", [238, 121, 159]),
("palevioletred3", [205, 104, 137]),
("palevioletred4", [139, 71, 93]),
("papayawhip", [255, 239, 213]),
("peachpuff", [255, 218, 185]),
("peachpuff1", [255, 218, 185]),
("peachpuff2", [238, 203, 173]),
("peachpuff3", [205, 175, 149]),
("peachpuff4", [139, 119, 101]),
("peru", [205, 133, 63]),
("pink", [255, 192, 203]),
("pink1", [255, 181, 197]),
("pink2", [238, 169, 184]),
("pink3", [205, 145, 158]),
("pink4", [139, 99, 108]),
("plum", [221, 160, 221]),
("plum1", [255, 187, 255]),
("plum2", [238, 174, 238]),
("plum3", [205, 150, 205]),
("plum4", [139, 102, 139]),
("powderblue", [176, 224, 230]),
("purple", [160, 32, 240]),
("purple1", [155, 48, 255]),
("purple2", [145, 44, 238]),
("purple3", [125, 38, 205]),
("purple4", [85, 26, 139]),
("red", [255, 0, 0]),
("red1", [255, 0, 0]),
("red2", [238, 0, 0]),
("red3", [205, 0, 0]),
("red4", [139, 0, 0]),
("rosybrown", [188, 143, 143]),
("rosybrown1", [255, 193, 193]),
("rosybrown2", [238, 180, 180]),
("rosybrown3", [205, 155, 155]),
("rosybrown4", [139, 105, 105]),
("royalblue", [65, 105, 225]),
("royalblue1", [72, 118, 255]),
("royalblue2", [67, 110, 238]),
("royalblue3", [58, 95, 205]),
("royalblue4", [39, 64, 139]),
("saddlebrown", [139, 69, 19]),
("salmon", [250, 128, 114]),
("salmon1", [255, 140, 105]),
("salmon2", [238, 130, 98]),
("salmon3", [205, 112, 84]),
("salmon4", [139, 76, 57]),
("sandybrown", [244, 164, 96]),
("seagreen", [46, 139, 87]),
("seagreen1", [84, 255, 159]),
("seagreen2", [78, 238, 148]),
("seagreen3", [67, 205, 128]),
("seagreen4", [46, 139, 87]),
("seashell", [255, 245, 238]),
("seashell1", [255, 245, 238]),
("seashell2", [238, 229, 222]),
("seashell3", [205, 197, 191]),
("seashell4", [139, 134, 130]),
("sienna", [160, 82, 45]),
("sienna1", [255, 130, 71]),
("sienna2", [238, 121, 66]),
("sienna3", [205, 104, 57]),
("sienna4", [139, 71, 38]),
("skyblue", [135, 206, 235]),
("skyblue1", [135, 206, 255]),
("skyblue2", [126, 192, 238]),
("skyblue3", [108, 166, 205]),
("skyblue4", [74, 112, 139]),
("slateblue", [106, 90, 205]),
("slateblue1", [131, 111, 255]),
("slateblue2", [122, 103, 238]),
("slateblue3", [105, 89, 205]),
("slateblue4", [71, 60, 139]),
("slategray", [112, 128, 144]),
("slategray1", [198, 226, 255]),
("slategray2", [185, 211, 238]),
("slategray3", [159, 182, 205]),
("slategray4", [108, 123, 139]),
("slategrey", [112, 128, 144]),
("snow", [255, 250, 250]),
("snow1", [255, 250, 250]),
("snow2", [238, 233, 233]),
("snow3", [205, 201, 201]),
("snow4", [139, 137, 137]),
("springgreen", [0, 255, 127]),
("springgreen1", [0, 255, 127]),
("springgreen2", [0, 238, 118]),
("springgreen3", [0, 205, 102]),
("springgreen4", [0, 139, 69]),
("steelblue", [70, 130, 180]),
("steelblue1", [99, 184, 255]),
("steelblue2", [92, 172, 238]),
("steelblue3", [79, 148, 205]),
("steelblue4", [54, 100, 139]),
("tan", [210, 180, 140]),
("tan1", [255, 165, 79]),
("tan2", [238, 154, 73]),
("tan3", [205, 133, 63]),
("tan4", [139, 90, 43]),
("thistle", [216, 191, 216]),
("thistle1", [255, 225, 255]),
("thistle2", [238, 210, 238]),
("thistle3", [205, 181, 205]),
("thistle4", [139, 123, 139]),
("tomato", [255, 99, 71]),
("tomato1", [255, 99, 71]),
("tomato2", [238, 92, 66]),
("tomato3", [205, 79, 57]),
("tomato4", [139, 54, 38]),
("turquoise", [64, 224, 208]),
("turquoise1", [0, 245, 255]),
("turquoise2", [0, 229, 238]),
("turquoise3", [0, 197, 205]),
("turquoise4", [0, 134, 139]),
("violet", [238, 130, 238]),
("violetred", [208, 32, 144]),
("violetred1", [255, 62, 150]),
("violetred2", [238, 58, 140]),
("violetred3", [205, 50, 120]),
("violetred4", [139, 34, 82]),
("wheat", [245, 222, 179]),
("wheat1", [255, 231, 186]),
("wheat2", [238, 216, 174]),
("wheat3", [205, 186, 150]),
("wheat4", [139, 126, 102]),
("white", [255, 255, 255]),
("whitesmoke", [245, 245, 245]),
("yellow", [255, 255, 0]),
("yellow1", [255, 255, 0]),
("yellow2", [238, 238, 0]),
("yellow3", [205, 205, 0]),
("yellow4", [139, 139, 0]),
("yellowgreen", [154, 205, 50]),
];
@@ -0,0 +1,46 @@
//! The compatibility facade must retain its policy while sharing the codec implementation.
use craft_raster_codecs::{ChannelLayout, CodecError, Image, Limits, SampleType, dds, fits, iff, pnm, xpm};
#[test]
fn facade_refuses_conversions_the_generic_encoder_can_plan() {
for layout in [ChannelLayout::GrayA, ChannelLayout::Rgba, ChannelLayout::Cmyk, ChannelLayout::CmykA] {
let image = Image::from_f32(1, 1, layout, &vec![0.5; layout.channels()]).unwrap();
assert!(matches!(pnm::encode(&image), Err(CodecError::Encode { .. })));
assert!(matches!(fits::encode(&image), Err(CodecError::Encode { .. })));
}
for layout in [ChannelLayout::Gray, ChannelLayout::GrayA, ChannelLayout::Rgb, ChannelLayout::Cmyk, ChannelLayout::CmykA] {
let image = Image::from_u8(1, 1, layout, vec![127; layout.channels()]).unwrap();
for compression in [dds::DdsCompression::Bc1, dds::DdsCompression::Bc2, dds::DdsCompression::Bc3] {
assert!(matches!(dds::encode(&image, dds::DdsOptions { compression, mipmaps: false }), Err(CodecError::Encode { .. })));
}
}
for layout in [ChannelLayout::Rgb, ChannelLayout::Rgba] {
let image = Image::from_u16(1, 1, layout, &vec![32768; layout.channels()]).unwrap();
assert!(matches!(iff::encode(&image), Err(CodecError::Encode { .. })));
assert!(matches!(dds::encode(&image, dds::DdsOptions::default()), Err(CodecError::Encode { .. })));
}
}
#[test]
fn fits_facade_keeps_metadata_samples_and_explicit_limits() {
let mut image = Image::from_u16(2, 1, ChannelLayout::Gray, &[0, 65535]).unwrap();
image.text.push(("OBJECT".into(), "shared codec".into()));
let bytes = fits::encode(&image).unwrap();
let decoded = fits::decode(&bytes, &Limits::default()).unwrap();
assert_eq!(decoded.sample_type(), SampleType::U16);
assert_eq!(decoded.data(), image.data());
assert!(decoded.text.contains(&("OBJECT".into(), "shared codec".into())));
for limits in
[Limits { max_width: 1, ..Limits::default() }, Limits { max_pixels: 1, ..Limits::default() }, Limits { max_alloc: 3, ..Limits::default() }]
{
assert!(matches!(fits::decode(&bytes, &limits), Err(CodecError::LimitExceeded(_))));
}
}
#[test]
fn x11_table_lookup_does_not_adopt_xpm_aliases_or_normalization() {
assert_eq!(xpm::x11_color_rgb("red"), Some([1.0, 0.0, 0.0]));
for name in ["Red", "light blue", "light-blue", "light_blue", "none", "transparent", ""] {
assert_eq!(xpm::x11_color_rgb(name), None, "{name}");
}
}
+1
View File
@@ -170,6 +170,7 @@ fn scene(ui: &mut egui::Ui, ours: bool) {
}
fn render(ours: bool, hover: Option<&str>, open: Option<&str>) -> image::RgbaImage {
let _gpu = crate::gpu_test_lock();
// Two of the combo boxes have no label: the scene compares looks, not names.
let mut h = Harness::builder().with_size(egui::vec2(480.0, 700.0)).with_accessibility_check(false).build_ui(move |ui| scene(ui, ours));
h.run();
+11
View File
@@ -27,3 +27,14 @@ pub mod text;
pub mod theme;
pub use combo::ComboBox;
/// Lets one unit test at a time hold a wgpu renderer. Each renderer creates its own Vulkan instance
/// and device. When one test uses its device while a test on another thread creates or destroys
/// one, the Vulkan loader now and then crashes the test binary with SIGSEGV. Take the lock before
/// building the harness (`let _gpu = crate::gpu_test_lock();`), so it is released after the harness
/// is dropped. A test that failed while holding it does not block the others.
#[cfg(test)]
pub(crate) fn gpu_test_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
+1
View File
@@ -123,6 +123,7 @@ mod tests {
#[test]
fn selected_tab_erases_a_baseline_centered_on_its_bottom_edge() {
let _gpu = crate::gpu_test_lock();
let mut h = egui_kittest::Harness::builder().with_size(Vec2::new(120.0, 80.0)).wgpu().build_ui(|ui| {
ui.painter().rect_filled(ui.max_rect(), 0.0, Color32::WHITE);
let rect = Rect::from_min_size(egui::pos2(10.0, 10.0), Vec2::new(100.0, 26.0));
+16
View File
@@ -9,6 +9,7 @@
mod fixtures;
use std::path::PathBuf;
use std::sync::{Mutex, MutexGuard, PoisonError};
use egui::{Color32, Context, Event, FullOutput, Modifiers, PointerButton, Pos2, RawInput, Rect, Response, TextureId, Ui};
use egui_kittest::{TestRenderer, wgpu::WgpuTestRenderer};
@@ -28,6 +29,17 @@ struct Capture {
meshes: Option<Vec<Mesh>>,
}
/// Lets one test at a time hold a wgpu renderer. Each renderer creates its own Vulkan instance and
/// device. When one test uses its device while a test on another thread creates or destroys one,
/// the Vulkan loader now and then crashes the test binary with SIGSEGV.
static GPU_LOCK: Mutex<()> = Mutex::new(());
/// Take this before creating a renderer (`let _gpu = gpu_lock();`), so it is released after the
/// renderer is dropped. A test that failed while holding it does not block the others.
fn gpu_lock() -> MutexGuard<'static, ()> {
GPU_LOCK.lock().unwrap_or_else(PoisonError::into_inner)
}
fn context(theme: Theme, scale: f32) -> Context {
let ctx = Context::default();
ctx.set_theme(theme.egui());
@@ -184,6 +196,7 @@ impl Artifacts {
#[test]
fn rendered_controls_match_independent_reference_pixels_and_meshes() {
let _gpu = gpu_lock();
let mut renderer = WgpuTestRenderer::new();
let mut artifacts = Artifacts::new("controls");
let mut count = 0;
@@ -213,6 +226,7 @@ fn rendered_controls_match_independent_reference_pixels_and_meshes() {
#[test]
fn visual_comparisons_detect_color_spacing_and_stroke_mutations() {
let _gpu = gpu_lock();
let mut renderer = WgpuTestRenderer::new();
let mut artifacts = Artifacts::new("negative-controls");
let mut count = 0;
@@ -241,6 +255,7 @@ fn toolbar_fitting_matches_literal_group_and_overflow_positions() {
use craft_ui::layout::fit_toolbar;
use egui::{Align, Layout, Stroke, StrokeKind, UiBuilder, pos2, vec2};
let _gpu = gpu_lock();
let mut renderer = WgpuTestRenderer::new();
let mut artifacts = Artifacts::new("toolbar");
let mut count = 0;
@@ -295,6 +310,7 @@ fn widget_palette_renders_all_five_states_with_existing_borders_and_expansion()
use craft_ui::theme::WidgetPalette;
use egui::{CornerRadius, Stroke, StrokeKind, pos2, vec2};
let _gpu = gpu_lock();
let mut renderer = WgpuTestRenderer::new();
let mut artifacts = Artifacts::new("widget-palette");
for theme in [Theme::Light, Theme::Dark] {
+5
View File
@@ -52,6 +52,8 @@ vp9-encode = ["craft-media/isobmff"]
av1 = ["av1-decode", "av1-encode"]
av1-decode = []
av1-encode = ["craft-media/isobmff"]
# Tiled AV1 fallback for frames that exceed the clean-room encoder's single-tile limits.
av1-large-encode = ["av1-encode", "dep:rav1e"]
# Decode and encode across worker threads (rayon) in the codecs that support it.
threads = ["dep:rayon"]
@@ -60,6 +62,9 @@ craft-media = { workspace = true }
thiserror = { workspace = true }
rayon = { workspace = true, optional = true }
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
rav1e = { version = "0.8", default-features = false, optional = true }
[dev-dependencies]
craft-media-testkit = { workspace = true }
# The AVI muxer, for the MPEG-4 Part 2 encoder's end-to-end test.
+1 -1
View File
@@ -27,5 +27,5 @@ No codec feature is on by default.
| `h264` | [`h264`](src/h264/decode/README.md) | ITU-T H.264 / AVC: decoder (`h264-decode` alone) and encoder (`h264-encode` alone) |
| `hevc` | [`hevc`](src/hevc/decode/README.md) | ITU-T H.265 / HEVC: decoder (`hevc-decode` alone) and encoder (`hevc-encode` alone) |
| `vp9` | [`vp9`](src/vp9/decode/README.md) | VP9: decoder (`vp9-decode` alone) and encoder (`vp9-encode` alone) |
| `av1` | [`av1`](src/av1/decode/README.md) | AV1 (AOMedia Video 1): decoder (`av1-decode` alone) and encoder (`av1-encode` alone) |
| `av1` | [`av1`](src/av1/decode/README.md) | AV1 (AOMedia Video 1): decoder (`av1-decode` alone) and clean-room encoder (`av1-encode`); tiled rav1e fallback for large frames (`av1-large-encode`) |
| `threads` | — | Multi-threaded slice/row parallelism via `rayon` |
+9
View File
@@ -3,6 +3,15 @@
Clean-room, pure-Rust AV1 encoder for MP4 / WebM export (layer L0, `std` only,
no `unsafe`, builds for `wasm32-unknown-unknown`).
## Large frame fallback
The optional `av1-large-encode` feature exposes `LargeEncoder`, a tiled rav1e-backed encoder for
8-bit 4:2:0 frames up to 8192 samples per side. Use it when the clean-room `Encoder`'s one-tile
limits (4096 samples per side and 2304 superblocks) would reject the frame. It supports constant
quantizer rate control and emits one low-latency packet per input frame. The fallback is native
only; the clean-room encoder remains available without the feature and supports 8- and 10-bit
input.
## What is implemented
- **Stream**: Main profile (`seq_profile` 0), 4:2:0, 8 or 10 bit, the configured colour description (BT.709 by default),
+155
View File
@@ -0,0 +1,155 @@
//! Tiled AV1 encoding for frames outside the clean-room encoder's single-tile limits.
use super::{EncoderConfig, Error, Frame, Packet, RateControl};
use rav1e::prelude::{
ChromaSampling, ColorDescription, ColorPrimaries, Config, Context, EncoderConfig as Rav1eConfig, FrameParameters, FrameType, FrameTypeOverride,
MatrixCoefficients, PixelRange, Rational, TransferCharacteristics,
};
/// Tiled AV1 encoder used when a frame is too large for [`super::Encoder`].
pub struct LargeEncoder {
ctx: Context<u8>,
width: usize,
height: usize,
seq_header: Option<Vec<u8>>,
}
impl LargeEncoder {
/// Creates a tiled 8-bit 4:2:0 encoder for dimensions up to 8192 samples per side.
pub fn new(cfg: &EncoderConfig) -> Result<Self, Error> {
Self::with_speed(cfg, 6)
}
/// Creates the tiled encoder with a rav1e speed preset from 1 (slower) to 10 (faster).
pub fn with_speed(cfg: &EncoderConfig, speed: u8) -> Result<Self, Error> {
if cfg.width < 16 || cfg.height < 16 || cfg.width > 8192 || cfg.height > 8192 {
return Err(Error::InvalidConfig("large AV1 frame dimensions must be 16..=8192".into()));
}
if cfg.bit_depth != 8 || cfg.fps_num == 0 || cfg.fps_den == 0 {
return Err(Error::InvalidConfig("large AV1 encoding requires 8-bit input and a valid frame rate".into()));
}
let RateControl::ConstantQ(quality) = cfg.rate else {
return Err(Error::InvalidConfig("large AV1 encoding currently supports constant quantizer rate control".into()));
};
let mut ec = Rav1eConfig::with_speed_preset(speed.clamp(1, 10));
ec.width = cfg.width as usize;
ec.height = cfg.height as usize;
ec.time_base = Rational::new(u64::from(cfg.fps_den), u64::from(cfg.fps_num));
ec.bit_depth = 8;
ec.chroma_sampling = ChromaSampling::Cs420;
ec.pixel_range = if cfg.full_range { PixelRange::Full } else { PixelRange::Limited };
ec.color_description = Some(ColorDescription {
color_primaries: ColorPrimaries::BT709,
transfer_characteristics: TransferCharacteristics::BT709,
matrix_coefficients: MatrixCoefficients::BT709,
});
ec.low_latency = true;
ec.quantizer = quality.max(1) as usize;
ec.min_quantizer = ec.quantizer.min(255) as u8;
ec.min_key_frame_interval = 1;
ec.max_key_frame_interval = cfg.keyint.clamp(1, 120) as u64;
ec.tiles = std::thread::available_parallelism().map_or(4, |n| n.get()).clamp(2, 16);
let ctx = Config::new().with_encoder_config(ec).new_context().map_err(|e| Error::InvalidConfig(format!("rav1e: {e}")))?;
Ok(Self { ctx, width: cfg.width as usize, height: cfg.height as usize, seq_header: None })
}
/// Encodes one frame. The frame planes must match the configured 4:2:0 dimensions.
pub fn encode_with_key(&mut self, frame: &Frame<'_>, force_key: bool) -> Result<Packet, Error> {
if frame.y_stride < self.width
|| frame.uv_stride < self.width / 2
|| frame.y.len() < frame.y_stride.saturating_mul(self.height)
|| frame.u.len() < frame.uv_stride.saturating_mul(self.height / 2)
|| frame.v.len() < frame.uv_stride.saturating_mul(self.height / 2)
{
return Err(Error::InvalidFrame("plane dimensions or strides do not match the configured frame".into()));
}
let mut input = self.ctx.new_frame();
copy_plane(&mut input.planes[0], frame.y, frame.y_stride, self.width, self.height)?;
copy_plane(&mut input.planes[1], frame.u, frame.uv_stride, self.width / 2, self.height / 2)?;
copy_plane(&mut input.planes[2], frame.v, frame.uv_stride, self.width / 2, self.height / 2)?;
let params =
FrameParameters { frame_type_override: if force_key { FrameTypeOverride::Key } else { FrameTypeOverride::No }, ..Default::default() };
self.ctx.send_frame((input, params)).map_err(|e| Error::InvalidFrame(format!("rav1e: {e}")))?;
loop {
match self.ctx.receive_packet() {
Ok(packet) => {
let (data, seq) = sample_data(&packet.data)?;
if self.seq_header.is_none() {
self.seq_header = seq;
}
return Ok(Packet { data, keyframe: packet.frame_type == FrameType::KEY });
}
Err(rav1e::prelude::EncoderStatus::Encoded) => continue,
Err(rav1e::prelude::EncoderStatus::NeedMoreData | rav1e::prelude::EncoderStatus::LimitReached) => {
return Err(Error::InvalidFrame("rav1e did not emit a low-latency frame".into()));
}
Err(e) => return Err(Error::InvalidFrame(format!("rav1e: {e}"))),
}
}
}
/// Returns the AV1 configuration record after the first frame has been encoded.
pub fn av1c(&self) -> Option<Vec<u8>> {
self.seq_header.as_ref().map(|obu| {
let mut config = vec![0x81, 31, 0x0c, 0];
config.extend_from_slice(obu);
config
})
}
}
fn copy_plane(plane: &mut rav1e::prelude::Plane<u8>, source: &[u16], stride: usize, width: usize, height: usize) -> Result<(), Error> {
let mut packed = Vec::with_capacity(width * height);
for row in 0..height {
let start = row * stride;
let pixels = &source[start..start + width];
if pixels.iter().any(|&value| value > u8::MAX as u16) {
return Err(Error::InvalidFrame("8-bit AV1 samples must be in 0..=255".into()));
}
packed.extend(pixels.iter().map(|&value| value as u8));
}
plane.copy_from_raw_u8(&packed, width, 1);
Ok(())
}
fn sample_data(data: &[u8]) -> Result<(Vec<u8>, Option<Vec<u8>>), Error> {
let mut pos = 0usize;
let mut sample = Vec::with_capacity(data.len());
let mut sequence = None;
while pos < data.len() {
let start = pos;
let header = data[pos];
if header & 0x80 != 0 {
return Err(Error::InvalidFrame("rav1e emitted an invalid OBU".into()));
}
let kind = (header >> 3) & 0x0f;
pos += 1 + usize::from(header & 0x04 != 0);
let end = if header & 0x02 != 0 {
let mut size = 0usize;
let mut shift = 0usize;
loop {
let byte = *data.get(pos).ok_or_else(|| Error::InvalidFrame("truncated OBU size".into()))?;
pos += 1;
size |= usize::from(byte & 0x7f).checked_shl(shift as u32).ok_or_else(|| Error::InvalidFrame("OBU size overflow".into()))?;
if byte & 0x80 == 0 {
break;
}
shift += 7;
if shift >= usize::BITS as usize {
return Err(Error::InvalidFrame("OBU size overflow".into()));
}
}
pos.checked_add(size).filter(|end| *end <= data.len()).ok_or_else(|| Error::InvalidFrame("OBU exceeds packet bounds".into()))?
} else {
data.len()
};
if kind == 1 && sequence.is_none() {
sequence = Some(data[start..end].to_vec());
}
if kind != 2 && kind != 15 {
sample.extend_from_slice(&data[start..end]);
}
pos = end;
}
Ok((sample, sequence))
}
+5
View File
@@ -20,6 +20,11 @@ mod tables;
mod transform;
mod writer;
#[cfg(all(feature = "av1-large-encode", not(target_arch = "wasm32")))]
mod large;
#[cfg(all(feature = "av1-large-encode", not(target_arch = "wasm32")))]
pub use large::LargeEncoder;
use bitw::obu;
use craft_media::bitstream::BitWriter;
use craft_media::isobmff::Av1Config;
+4
View File
@@ -27,6 +27,10 @@ use std::collections::HashMap;
pub mod document;
/// XFL's edge-attribute grammar, independent of any consuming application's geometry types.
pub mod edges;
/// Borrowed views of native XFL media library records.
pub mod media;
/// Borrowed views of native XFL shape and style elements.
pub mod shape;
/// Largest single entry inflated (bytes).
pub const MAX_ENTRY: usize = 256 * 1024 * 1024;
+190
View File
@@ -0,0 +1,190 @@
//! Borrowed views of XFL's bitmap, sound, and video library-item records.
//!
//! These views expose native XFL metadata and archive member names. Decoding those bytes and
//! mapping the records into an application's media model remain consumer responsibilities.
use crate::shape::XflElement;
/// Archive member named by a library item's native `href` attribute.
pub fn library_member(href: &str) -> String {
format!("LIBRARY/{href}")
}
/// Archive member named by an XFL item's native `*DataHRef` attribute.
pub fn data_member(href: &str) -> String {
format!("bin/{href}")
}
/// A packaged `./...` external video source, normalized to ZIP's slash separators.
pub fn packaged_external_member(path: &str) -> Option<String> {
path.strip_prefix("./").map(|path| path.replace('\\', "/"))
}
/// Media library records in an XFL document, in source order.
#[derive(Clone, Copy, Debug)]
pub struct Catalog<'a, E: XflElement> {
media: Option<&'a E>,
}
impl<'a, E: XflElement> Catalog<'a, E> {
pub fn new(document: &'a E) -> Self {
Self { media: document.child("media") }
}
pub fn bitmaps(&self) -> impl Iterator<Item = Bitmap<'a, E>> + 'a {
let media = self.media;
media.into_iter().flat_map(|media| media.elements_named("DOMBitmapItem")).map(|element| Bitmap { element })
}
pub fn sounds(&self) -> impl Iterator<Item = Sound<'a, E>> + 'a {
let media = self.media;
media.into_iter().flat_map(|media| media.elements_named("DOMSoundItem")).map(|element| Sound { element })
}
pub fn videos(&self) -> impl Iterator<Item = Video<'a, E>> + 'a {
let media = self.media;
media.into_iter().flat_map(|media| media.elements_named("DOMVideoItem")).map(|element| Video { element })
}
}
/// Native bitmap library metadata.
#[derive(Clone, Copy, Debug)]
pub struct Bitmap<'a, E: XflElement> {
element: &'a E,
}
impl<'a, E: XflElement> Bitmap<'a, E> {
pub fn name(&self) -> Option<&'a str> {
self.element.attr("name")
}
pub fn href(&self) -> Option<&'a str> {
self.element.attr("href")
}
pub fn data_href(&self) -> Option<&'a str> {
self.element.attr("bitmapDataHRef")
}
pub fn allow_smoothing(&self) -> Option<bool> {
self.element.attr("allowSmoothing").map(|value| value.trim() == "true")
}
}
/// Native sound library metadata.
#[derive(Clone, Copy, Debug)]
pub struct Sound<'a, E: XflElement> {
element: &'a E,
}
impl<'a, E: XflElement> Sound<'a, E> {
pub fn name(&self) -> Option<&'a str> {
self.element.attr("name")
}
pub fn href(&self) -> Option<&'a str> {
self.element.attr("href")
}
pub fn data_href(&self) -> Option<&'a str> {
self.element.attr("soundDataHRef")
}
}
/// Native video library metadata.
#[derive(Clone, Copy, Debug)]
pub struct Video<'a, E: XflElement> {
element: &'a E,
}
impl<'a, E: XflElement> Video<'a, E> {
pub fn name(&self) -> Option<&'a str> {
self.element.attr("name")
}
pub fn href(&self) -> Option<&'a str> {
self.element.attr("href")
}
pub fn external_path(&self) -> Option<&'a str> {
self.element.attr("sourceExternalFilepath")
}
pub fn data_href(&self) -> Option<&'a str> {
self.element.attr("videoDataHRef")
}
pub fn length(&self) -> Option<f32> {
number(self.element, "length")
}
pub fn frame_count(&self) -> Option<f32> {
number(self.element, "frameCount")
}
pub fn frames_per_second(&self) -> Option<f32> {
number(self.element, "fps")
}
}
fn number(element: &impl XflElement, name: &str) -> Option<f32> {
element.attr(name)?.trim().parse::<f32>().ok().filter(|value| value.is_finite())
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(source: &[u8]) -> craft_xml::El {
craft_xml::Options::default().parse(source).unwrap()
}
#[test]
fn reads_native_media_metadata_in_order_and_ignores_other_records() {
let root = parse(
br#"<DOMDocument><media>
<DOMBitmapItem name="folder/a" href="a.png" bitmapDataHRef="Bitmap 1" allowSmoothing="false"/>
<DOMSoundItem name="s" href="s.wav" soundDataHRef="Sound 1"/>
<DOMVideoItem name="v" sourceExternalFilepath="./LIBRARY/v.flv" videoDataHRef="Video 1" length="3.5" frameCount="70" fps="20"/>
<Other name="ignored"/>
<DOMBitmapItem name="b"/>
</media></DOMDocument>"#,
);
let catalog = Catalog::new(&root);
let bitmaps: Vec<_> = catalog.bitmaps().collect();
assert_eq!(bitmaps.len(), 2);
assert_eq!(bitmaps[0].name(), Some("folder/a"));
assert_eq!(bitmaps[0].href(), Some("a.png"));
assert_eq!(bitmaps[0].data_href(), Some("Bitmap 1"));
assert_eq!(bitmaps[0].allow_smoothing(), Some(false));
assert_eq!(
catalog.sounds().next().map(|item| (item.name(), item.href(), item.data_href())),
Some((Some("s"), Some("s.wav"), Some("Sound 1")))
);
let video = catalog.videos().next().expect("video record");
assert_eq!(video.external_path(), Some("./LIBRARY/v.flv"));
assert_eq!(video.data_href(), Some("Video 1"));
assert_eq!(video.length(), Some(3.5));
assert_eq!(video.frame_count(), Some(70.0));
assert_eq!(video.frames_per_second(), Some(20.0));
}
#[test]
fn missing_or_invalid_media_metadata_stays_optional() {
let root = parse(br#"<DOMDocument><media><DOMVideoItem name="v" length="NaN" fps="?"/></media></DOMDocument>"#);
let video = Catalog::new(&root).videos().next().expect("video record");
assert_eq!(video.name(), Some("v"));
assert_eq!(video.length(), None);
assert_eq!(video.frames_per_second(), None);
let empty = parse(b"<DOMDocument/>");
assert_eq!(Catalog::new(&empty).bitmaps().count(), 0);
}
#[test]
fn native_media_references_resolve_to_the_legacy_archive_members() {
assert_eq!(library_member("folder/a.png"), "LIBRARY/folder/a.png");
assert_eq!(data_member("Bitmap 1"), "bin/Bitmap 1");
assert_eq!(packaged_external_member("./LIBRARY\\v.flv").as_deref(), Some("LIBRARY/v.flv"));
assert_eq!(packaged_external_member("/outside/v.flv"), None);
}
}
+590
View File
@@ -0,0 +1,590 @@
//! Borrowed views of native XFL shape and style elements.
//!
//! These views recognize XFL's element names and attribute grammar without depending on an
//! application's geometry, paint, or animation types. They work with `craft_xml::El` and with
//! compatible borrowed element adapters implemented by consumers.
use crate::edges::{self, Segment};
/// An element source used by the borrowed XFL schema views.
///
/// Consumers with an existing XML facade can implement this small interface and use the same
/// XFL parser without converting or reparsing their tree. Attribute lookup must return the last
/// occurrence when an XML document repeats an attribute, matching the native XFL reader's
/// historical behavior.
pub trait XflElement {
/// Iterator type for direct child elements.
type Elements<'a>: Iterator<Item = &'a Self>
where
Self: 'a;
/// The element's local name, with any namespace prefix removed.
fn local_name(&self) -> &str;
/// The last attribute with this exact name.
fn attr(&self, name: &str) -> Option<&str>;
/// Direct child elements in document order.
fn elements(&self) -> Self::Elements<'_>;
/// The first direct child whose local name matches.
fn child(&self, name: &str) -> Option<&Self> {
self.elements().find(|element| element.local_name() == name)
}
/// Direct children whose local name matches, in document order.
fn elements_named<'a>(&'a self, name: &'a str) -> impl Iterator<Item = &'a Self> + 'a {
self.elements().filter(move |element| element.local_name() == name)
}
}
/// Direct child elements of `craft_xml::El`, used by its `XflElement` implementation.
pub struct XmlElements<'a> {
nodes: std::slice::Iter<'a, craft_xml::Node>,
}
impl<'a> Iterator for XmlElements<'a> {
type Item = &'a craft_xml::El;
fn next(&mut self) -> Option<Self::Item> {
self.nodes.find_map(|node| match node {
craft_xml::Node::El(element) => Some(element),
_ => None,
})
}
}
impl XflElement for craft_xml::El {
type Elements<'a> = XmlElements<'a>;
fn local_name(&self) -> &str {
self.name.rsplit(':').next().unwrap_or(&self.name)
}
fn attr(&self, name: &str) -> Option<&str> {
self.attrs.iter().rev().find(|(key, _)| key == name).map(|(_, value)| value.as_str())
}
fn elements(&self) -> Self::Elements<'_> {
XmlElements { nodes: self.children.iter() }
}
}
/// XFL matrix coefficients, in the native units stored in XML.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Matrix {
pub a: f32,
pub b: f32,
pub c: f32,
pub d: f32,
pub tx: f32,
pub ty: f32,
}
/// A color encoded by an XFL color attribute and its optional alpha attribute.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Color {
pub rgb: u32,
pub alpha: f32,
}
impl Matrix {
/// The matrix used when an XFL element omits its transform.
pub const IDENTITY: Matrix = Matrix { a: 1.0, b: 0.0, c: 0.0, d: 1.0, tx: 0.0, ty: 0.0 };
}
fn number(element: &impl XflElement, name: &str) -> Option<f32> {
element.attr(name)?.trim().parse::<f32>().ok().filter(|value| value.is_finite())
}
fn integer(element: &impl XflElement, name: &str) -> Option<u32> {
element.attr(name)?.trim().parse::<u32>().ok()
}
fn boolean(element: &impl XflElement, name: &str) -> Option<bool> {
element.attr(name).map(|value| value.trim() == "true")
}
/// Parses XFL's hexadecimal color and alpha attributes. Missing or malformed colors use black;
/// missing, malformed, or non-finite alpha uses full opacity, matching the legacy importer.
pub fn color(element: &impl XflElement, color_attribute: &str, alpha_attribute: &str) -> Color {
let rgb = element.attr(color_attribute).and_then(|value| u32::from_str_radix(value.trim().trim_start_matches('#'), 16).ok()).unwrap_or(0);
let alpha = number(element, alpha_attribute).unwrap_or(1.0).clamp(0.0, 1.0);
Color { rgb, alpha }
}
/// Reads the native `<matrix><Matrix .../></matrix>` transform.
///
/// Each absent, malformed, or non-finite coefficient uses its identity default independently.
/// This preserves the prior AniCraft reader's `Element::f32` behavior, including retaining other
/// valid coefficients when one coefficient is invalid.
pub fn matrix(element: &impl XflElement) -> Matrix {
let Some(matrix) = element.child("matrix").and_then(|wrapper| wrapper.child("Matrix")) else {
return Matrix::IDENTITY;
};
Matrix {
a: number(matrix, "a").unwrap_or(1.0),
b: number(matrix, "b").unwrap_or(0.0),
c: number(matrix, "c").unwrap_or(0.0),
d: number(matrix, "d").unwrap_or(1.0),
tx: number(matrix, "tx").unwrap_or(0.0),
ty: number(matrix, "ty").unwrap_or(0.0),
}
}
/// A native `DOMShape` or drawing shape and its XFL style tables.
#[derive(Clone, Copy, Debug)]
pub struct Shape<'a, E: XflElement> {
element: &'a E,
}
/// Kind of native drawable primitive stored in XFL.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PrimitiveKind {
Rectangle,
Oval,
}
/// Native rectangle or oval object, including its native style definitions.
#[derive(Clone, Copy, Debug)]
pub struct Primitive<'a, E: XflElement> {
element: &'a E,
kind: PrimitiveKind,
}
impl<'a, E: XflElement> Primitive<'a, E> {
/// Views a supported native primitive by its local element name.
pub fn new(element: &'a E) -> Option<Self> {
let kind = match element.local_name() {
"DOMRectangleObject" => PrimitiveKind::Rectangle,
"DOMOvalObject" => PrimitiveKind::Oval,
_ => return None,
};
Some(Self { element, kind })
}
pub fn kind(&self) -> PrimitiveKind {
self.kind
}
pub fn x(&self) -> Option<f32> {
number(self.element, "x")
}
pub fn y(&self) -> Option<f32> {
number(self.element, "y")
}
pub fn width(&self) -> Option<f32> {
number(self.element, "objectWidth")
}
pub fn height(&self) -> Option<f32> {
number(self.element, "objectHeight")
}
pub fn top_left_radius(&self) -> Option<f32> {
number(self.element, "topLeftRadius")
}
pub fn matrix(&self) -> Matrix {
matrix(self.element)
}
pub fn fill(&self) -> Option<Fill<'_, E>> {
self.element.child("fill")?.elements().next().map(|element| Fill { element })
}
pub fn stroke(&self) -> Option<Stroke<'_, E>> {
self.element.child("stroke")?.elements().next().map(|element| Stroke { element })
}
}
impl<'a, E: XflElement> Shape<'a, E> {
/// Views an element as an XFL shape when its local name is `DOMShape`.
pub fn new(element: &'a E) -> Option<Self> {
(element.local_name() == "DOMShape").then_some(Self { element })
}
/// Native shape transform.
pub fn matrix(&self) -> Matrix {
matrix(self.element)
}
/// Whether Animate stores the shape as a drawing object.
pub fn is_drawing_object(&self) -> Option<bool> {
boolean(self.element, "isDrawingObject")
}
/// Fill styles, preserving their native order and index values.
pub fn fills(&self) -> impl Iterator<Item = FillStyle<'_, E>> + '_ {
self.element.child("fills").into_iter().flat_map(|table| table.elements()).map(|element| FillStyle { element })
}
/// Stroke styles, preserving their native order and index values.
pub fn strokes(&self) -> impl Iterator<Item = StrokeStyle<'_, E>> + '_ {
self.element.child("strokes").into_iter().flat_map(|table| table.elements()).map(|element| StrokeStyle { element })
}
/// Native edge records, preserving malformed and unknown data for consumer policy.
pub fn edges(&self) -> impl Iterator<Item = Edge<'_, E>> + '_ {
self.element.child("edges").into_iter().flat_map(|table| table.elements_named("Edge")).map(|element| Edge { element })
}
}
/// A native `FillStyle` entry.
#[derive(Clone, Copy, Debug)]
pub struct FillStyle<'a, E: XflElement> {
element: &'a E,
}
impl<'a, E: XflElement> FillStyle<'a, E> {
pub fn index(&self) -> Option<u32> {
integer(self.element, "index")
}
/// The first native definition element inside this table entry.
pub fn definition(&self) -> Option<Fill<'_, E>> {
self.element.elements().next().map(|element| Fill { element })
}
}
/// Native fill definitions understood by XFL.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FillKind {
SolidColor,
LinearGradient,
RadialGradient,
Bitmap,
Other,
}
/// A native XFL fill definition.
#[derive(Clone, Copy, Debug)]
pub struct Fill<'a, E: XflElement> {
element: &'a E,
}
impl<'a, E: XflElement> Fill<'a, E> {
/// Views any native fill-definition element, including fills nested in primitives or strokes.
pub fn new(element: &'a E) -> Self {
Self { element }
}
/// Underlying native definition element for consumers that map it into application types.
pub fn element(&self) -> &'a E {
self.element
}
pub fn kind(&self) -> FillKind {
match self.element.local_name() {
"SolidColor" => FillKind::SolidColor,
"LinearGradient" => FillKind::LinearGradient,
"RadialGradient" => FillKind::RadialGradient,
"BitmapFill" => FillKind::Bitmap,
_ => FillKind::Other,
}
}
pub fn color(&self) -> Option<&str> {
self.element.attr("color")
}
pub fn color_value(&self) -> Color {
color(self.element, "color", "alpha")
}
pub fn alpha(&self) -> Option<f32> {
number(self.element, "alpha")
}
pub fn matrix(&self) -> Matrix {
matrix(self.element)
}
pub fn spread_method(&self) -> Option<&str> {
self.element.attr("spreadMethod")
}
pub fn interpolation_method(&self) -> Option<&str> {
self.element.attr("interpolationMethod")
}
pub fn focal_point_ratio(&self) -> Option<f32> {
number(self.element, "focalPointRatio")
}
pub fn bitmap_path(&self) -> Option<&str> {
self.element.attr("bitmapPath")
}
pub fn bitmap_is_clipped(&self) -> Option<bool> {
boolean(self.element, "bitmapIsClipped")
}
/// Gradient entries, preserving source order and raw native ratios.
pub fn gradient_entries(&self) -> impl Iterator<Item = GradientEntry<'_, E>> + '_ {
self.element.elements_named("GradientEntry").map(|element| GradientEntry { element })
}
}
/// A native gradient ramp entry.
#[derive(Clone, Copy, Debug)]
pub struct GradientEntry<'a, E: XflElement> {
element: &'a E,
}
impl<E: XflElement> GradientEntry<'_, E> {
pub fn ratio(&self) -> Option<f32> {
number(self.element, "ratio")
}
pub fn color(&self) -> Option<&str> {
self.element.attr("color")
}
pub fn color_value(&self) -> Color {
color(self.element, "color", "alpha")
}
pub fn alpha(&self) -> Option<f32> {
number(self.element, "alpha")
}
}
/// Native stroke definitions understood by XFL.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum StrokeKind {
Solid,
Dashed,
Dotted,
Ragged,
Stipple,
Hatched,
Other,
}
/// A native `StrokeStyle` table entry.
#[derive(Clone, Copy, Debug)]
pub struct StrokeStyle<'a, E: XflElement> {
element: &'a E,
}
impl<'a, E: XflElement> StrokeStyle<'a, E> {
pub fn index(&self) -> Option<u32> {
integer(self.element, "index")
}
/// The first native definition element inside this table entry.
pub fn definition(&self) -> Option<Stroke<'_, E>> {
self.element.elements().next().map(|element| Stroke { element })
}
}
/// A native XFL stroke definition.
#[derive(Clone, Copy, Debug)]
pub struct Stroke<'a, E: XflElement> {
element: &'a E,
}
impl<'a, E: XflElement> Stroke<'a, E> {
/// Views a native stroke-definition element.
pub fn new(element: &'a E) -> Self {
Self { element }
}
/// Underlying native definition element for consumers that map it into application types.
pub fn element(&self) -> &'a E {
self.element
}
pub fn kind(&self) -> StrokeKind {
match self.element.local_name() {
"SolidStroke" => StrokeKind::Solid,
"DashedStroke" => StrokeKind::Dashed,
"DottedStroke" => StrokeKind::Dotted,
"RaggedStroke" => StrokeKind::Ragged,
"StippleStroke" => StrokeKind::Stipple,
"HatchedStroke" => StrokeKind::Hatched,
_ => StrokeKind::Other,
}
}
pub fn weight(&self) -> Option<f32> {
number(self.element, "weight")
}
pub fn caps(&self) -> Option<&str> {
self.element.attr("caps")
}
pub fn joints(&self) -> Option<&str> {
self.element.attr("joints")
}
pub fn miter_limit(&self) -> Option<f32> {
number(self.element, "miterLimit")
}
pub fn dash1(&self) -> Option<f32> {
number(self.element, "dash1")
}
pub fn dash2(&self) -> Option<f32> {
number(self.element, "dash2")
}
pub fn dot_space(&self) -> Option<f32> {
number(self.element, "dotSpace")
}
/// The first fill definition nested in the stroke.
pub fn fill(&self) -> Option<Fill<'_, E>> {
self.element.child("fill")?.elements().next().map(|element| Fill { element })
}
}
/// A native `<Edge>` record and its style indices.
#[derive(Clone, Copy, Debug)]
pub struct Edge<'a, E: XflElement> {
element: &'a E,
}
impl<E: XflElement> Edge<'_, E> {
pub fn fill_style0(&self) -> Option<u32> {
integer(self.element, "fillStyle0")
}
pub fn fill_style1(&self) -> Option<u32> {
integer(self.element, "fillStyle1")
}
pub fn stroke_style(&self) -> Option<u32> {
integer(self.element, "strokeStyle")
}
pub fn encoded_segments(&self) -> Option<&str> {
self.element.attr("edges")
}
/// Parsed XFL path segments, using the shared bounded edge grammar.
pub fn segments(&self) -> Vec<Segment> {
self.encoded_segments().map(edges::parse_edge_segments).unwrap_or_default()
}
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(source: &[u8]) -> craft_xml::El {
craft_xml::Options::default().parse(source).unwrap()
}
#[test]
fn reads_prefixed_shape_fill_stroke_and_edge_schema() {
let root = parse(br##"<x:DOMShape xmlns:x="urn:xfl" isDrawingObject="false">
<x:matrix><x:Matrix a="2" tx="12"/></x:matrix>
<x:fills><x:FillStyle index="1"><x:LinearGradient spreadMethod="reflect" interpolationMethod="linearRGB">
<x:GradientEntry ratio="0" color="#102030"/><x:GradientEntry ratio="255" color="#ffffff" alpha=".5"/>
</x:LinearGradient></x:FillStyle><x:FillStyle index="2"><x:BitmapFill bitmapPath="Library/a.png" bitmapIsClipped="true"/></x:FillStyle></x:fills>
<x:strokes><x:StrokeStyle index="3"><x:DashedStroke weight="2" dash1="8" dash2="3" caps="square" joints="miter" miterLimit="7"><x:fill><x:SolidColor color="#abcdef"/></x:fill></x:DashedStroke></x:StrokeStyle></x:strokes>
<x:edges><x:Edge fillStyle0="2" fillStyle1="1" strokeStyle="3" edges="!0 0|200 0"/></x:edges>
</x:DOMShape>"##);
let shape = Shape::new(&root).unwrap();
assert_eq!(shape.matrix(), Matrix { a: 2.0, b: 0.0, c: 0.0, d: 1.0, tx: 12.0, ty: 0.0 });
assert_eq!(shape.is_drawing_object(), Some(false));
let fills: Vec<_> = shape.fills().collect();
assert_eq!(fills.iter().map(FillStyle::index).collect::<Vec<_>>(), [Some(1), Some(2)]);
let gradient = fills[0].definition().unwrap();
assert_eq!(gradient.kind(), FillKind::LinearGradient);
assert_eq!(gradient.spread_method(), Some("reflect"));
assert_eq!(gradient.interpolation_method(), Some("linearRGB"));
assert_eq!(gradient.gradient_entries().map(|entry| entry.ratio()).collect::<Vec<_>>(), [Some(0.0), Some(255.0)]);
let bitmap = fills[1].definition().unwrap();
assert_eq!(bitmap.kind(), FillKind::Bitmap);
assert_eq!(bitmap.bitmap_path(), Some("Library/a.png"));
assert_eq!(bitmap.bitmap_is_clipped(), Some(true));
let stroke_style = shape.strokes().next().unwrap();
let stroke = stroke_style.definition().unwrap();
assert_eq!(stroke.kind(), StrokeKind::Dashed);
assert_eq!(stroke.weight(), Some(2.0));
assert_eq!((stroke.dash1(), stroke.dash2()), (Some(8.0), Some(3.0)));
assert_eq!(stroke.fill().unwrap().color(), Some("#abcdef"));
let color = stroke.fill().unwrap().color_value();
assert_eq!(color, Color { rgb: 0xabcdef, alpha: 1.0 });
let edge = shape.edges().next().unwrap();
assert_eq!((edge.fill_style0(), edge.fill_style1(), edge.stroke_style()), (Some(2), Some(1), Some(3)));
assert_eq!(edge.segments().len(), 1);
}
#[test]
fn duplicate_attributes_use_last_value_and_invalid_numbers_are_absent() {
let root = parse(b"<DOMShape isDrawingObject='false' isDrawingObject='true'><matrix><Matrix a='NaN' tx='12'/></matrix><fills><FillStyle index='1' index='4'><SolidColor alpha='Infinity'/></FillStyle></fills></DOMShape>");
let shape = Shape::new(&root).unwrap();
assert_eq!(shape.is_drawing_object(), Some(true));
assert_eq!(shape.matrix(), Matrix { tx: 12.0, ..Matrix::IDENTITY });
let fill = shape.fills().next().unwrap();
assert_eq!(fill.index(), Some(4));
let fill = fill.definition().unwrap();
assert_eq!(fill.alpha(), None);
assert_eq!(fill.color_value(), Color { rgb: 0, alpha: 1.0 });
}
#[test]
fn style_table_views_keep_the_legacy_first_child_and_index_behavior() {
let root = parse(b"<DOMShape><fills><LegacyFill index='5'><SolidColor color='#123456'/></LegacyFill></fills><strokes><LegacyStroke index='6'><SolidStroke weight='2'/></LegacyStroke></strokes></DOMShape>");
let shape = Shape::new(&root).unwrap();
let fill_style = shape.fills().next().unwrap();
assert_eq!(fill_style.index(), Some(5));
assert_eq!(fill_style.definition().map(|fill| fill.kind()), Some(FillKind::SolidColor));
let stroke_style = shape.strokes().next().unwrap();
assert_eq!(stroke_style.index(), Some(6));
assert_eq!(stroke_style.definition().map(|stroke| stroke.kind()), Some(StrokeKind::Solid));
}
#[test]
fn an_application_element_adapter_can_use_the_same_views() {
#[derive(Debug)]
struct AppElement {
name: String,
attrs: Vec<(String, String)>,
children: Vec<AppElement>,
}
impl XflElement for AppElement {
type Elements<'a> = std::slice::Iter<'a, AppElement>;
fn local_name(&self) -> &str {
self.name.rsplit(':').next().unwrap_or(&self.name)
}
fn attr(&self, name: &str) -> Option<&str> {
self.attrs.iter().rev().find(|(key, _)| key == name).map(|(_, value)| value.as_str())
}
fn elements(&self) -> Self::Elements<'_> {
self.children.iter()
}
}
let app = AppElement { name: "x:DOMShape".into(), attrs: vec![("isDrawingObject".into(), "true".into())], children: Vec::new() };
assert_eq!(Shape::new(&app).unwrap().is_drawing_object(), Some(true));
}
#[test]
fn reads_native_rectangle_and_oval_geometry_and_styles() {
let root = parse(br##"<DOMRectangleObject x="-2" y="3" objectWidth="20" objectHeight="10" topLeftRadius="4"><matrix><Matrix tx="7"/></matrix><fill><SolidColor color="#123456"/></fill><stroke><DashedStroke weight="2" dash1="5" dash2="3"/></stroke></DOMRectangleObject>"##);
let primitive = Primitive::new(&root).unwrap();
assert_eq!(primitive.kind(), PrimitiveKind::Rectangle);
assert_eq!(
(primitive.x(), primitive.y(), primitive.width(), primitive.height(), primitive.top_left_radius()),
(Some(-2.0), Some(3.0), Some(20.0), Some(10.0), Some(4.0))
);
assert_eq!(primitive.matrix().tx, 7.0);
assert_eq!(primitive.fill().unwrap().kind(), FillKind::SolidColor);
assert_eq!(primitive.stroke().unwrap().kind(), StrokeKind::Dashed);
let oval = parse(b"<DOMOvalObject objectWidth='10' objectHeight='8'/>");
assert_eq!(Primitive::new(&oval).unwrap().kind(), PrimitiveKind::Oval);
assert!(Primitive::new(&parse(b"<DOMShape/>")).is_none());
}
}