Use craft-gainmap from craft-libs for gain map metadata and arithmetic

Use craft-gainmap from craft-libs for gain map metadata and arithmetic

* Use craft-heif from craft-libs; remove crates/heif

lightcraft-heif moved to craft-libs unchanged as craft-heif
(storytold/craft-libs#784), so PhotoCraft can share it. The layer table,
the heif CI step and the change triggers drop the local crate; a workspace
file change (which a craft-heif rev bump is) still runs the heif step.

* Pin craft-heif to the merge of storytold/craft-libs#794

* docs: the HEIF rows point at craft-heif, not the removed crates/heif

* Use craft-gainmap from craft-libs for gain map metadata and arithmetic

crates/codecs/src/gainmap.rs keeps the JPEG layout (encode_jpeg, read_jpeg,
is_gain_map_jpeg) and re-exports GainMapMeta, GainImage, GainMapOptions,
ISO_URN, compute and apply from craft-gainmap, which is this file's metadata
and arithmetic moved to craft-libs (storytold/craft-libs#904). The tests of
the moved code went with it.

* craft-heif's Options has a chroma field at this rev: keep the libheif upsampling LightCraft had

* raw: count the chunks a TIFF declares from its offsets table

craft-tiff builds at most one chunk descriptor per byte of file
(craft-libs#827), so a grid of tiles sharing one payload lists fewer
chunks than the image declares. Compare the offsets table, which is the
source of truth, so such a file reaches the byte-accounting check and is
refused for the data it actually holds.
This commit is contained in:
Dylan M. Taylor
2026-11-12 00:43:54 -05:00
committed by GitHub
parent 5a96dfc295
commit e4dd081dd4
29 changed files with 75 additions and 3366 deletions
Generated
+22 -12
View File
@@ -1199,6 +1199,23 @@ name = "craft-fonts-build"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
[[package]]
name = "craft-gainmap"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=430a908f68819bf23d14fe73ab9b18d8f4fd4e5d#430a908f68819bf23d14fe73ab9b18d8f4fd4e5d"
dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-heif"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=430a908f68819bf23d14fe73ab9b18d8f4fd4e5d#430a908f68819bf23d14fe73ab9b18d8f4fd4e5d"
dependencies = [
"heic-rs",
"rayon",
]
[[package]]
name = "craft-i18n"
version = "0.1.0"
@@ -1225,7 +1242,7 @@ dependencies = [
[[package]]
name = "craft-tiff"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=3b3104981bb3093904a12e44d6a3b41c6c4c39c8#3b3104981bb3093904a12e44d6a3b41c6c4c39c8"
source = "git+https://github.com/storytold/craft-libs?rev=430a908f68819bf23d14fe73ab9b18d8f4fd4e5d#430a908f68819bf23d14fe73ab9b18d8f4fd4e5d"
dependencies = [
"serde",
"thiserror 2.0.21",
@@ -3668,6 +3685,8 @@ version = "0.21.1"
dependencies = [
"avif-serialize",
"bytemuck",
"craft-gainmap",
"craft-heif",
"dhat",
"image",
"image-webp",
@@ -3677,7 +3696,6 @@ dependencies = [
"jxl-oxide",
"lightcraft-color",
"lightcraft-geom",
"lightcraft-heif",
"lightcraft-raster",
"lightcraft-testkit",
"moxcms 0.9.1",
@@ -3754,6 +3772,7 @@ dependencies = [
"ab_glyph",
"chrono",
"craft-docpath",
"craft-heif",
"craft-tiff",
"crc32fast",
"fs4",
@@ -3771,7 +3790,6 @@ dependencies = [
"lightcraft-geocode",
"lightcraft-geom",
"lightcraft-gpu",
"lightcraft-heif",
"lightcraft-lensdb",
"lightcraft-merge",
"lightcraft-meta",
@@ -3863,14 +3881,6 @@ dependencies = [
"wgpu",
]
[[package]]
name = "lightcraft-heif"
version = "0.21.1"
dependencies = [
"heic-rs",
"rayon",
]
[[package]]
name = "lightcraft-inpaint"
version = "0.21.1"
@@ -3919,9 +3929,9 @@ name = "lightcraft-meta"
version = "0.21.1"
dependencies = [
"chrono",
"craft-heif",
"craft-tiff",
"lightcraft-geom",
"lightcraft-heif",
"proptest",
"quick-xml 0.41.0",
"serde",
+5 -2
View File
@@ -17,6 +17,8 @@ craft-crw = { git = "https://github.com/storytold/craft-libs", rev = "f3b62ec61f
# craft-update: app-specific pretend versions apply to startup and manual checks.
craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "6e03f65bf45181db77ba6229716e6624db9eb25b", features = ["egui"] }
craft-window = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", features = ["egui"] }
# HDR gain maps: ISO 21496-1 and hdrgm metadata, compute and apply (moved from crates/codecs; craft-libs#904).
craft-gainmap = { git = "https://github.com/storytold/craft-libs", rev = "430a908f68819bf23d14fe73ab9b18d8f4fd4e5d" }
# internal
lightcraft-denoise-core = { path = "crates/denoise-core" }
lightcraft-denoise = { path = "crates/denoise", default-features = false }
@@ -27,7 +29,7 @@ lightcraft-wincolor = { path = "crates/wincolor" }
lightcraft-color = { path = "crates/color" }
lightcraft-raster = { path = "crates/raster" }
# TIFF/IFD: the shared reader and writer (moved from crates/tiff; craft-libs#783).
craft-tiff = { git = "https://github.com/storytold/craft-libs", rev = "3b3104981bb3093904a12e44d6a3b41c6c4c39c8" }
craft-tiff = { git = "https://github.com/storytold/craft-libs", rev = "430a908f68819bf23d14fe73ab9b18d8f4fd4e5d" }
lightcraft-raw = { path = "crates/raw" }
lightcraft-codecs = { path = "crates/codecs" }
lightcraft-meta = { path = "crates/meta" }
@@ -45,7 +47,8 @@ lightcraft-engine = { path = "crates/engine" }
lightcraft-ui-egui = { path = "crates/ui-egui" }
lightcraft-mcp = { path = "crates/mcp" }
lightcraft-fetch = { path = "crates/fetch" }
lightcraft-heif = { path = "crates/heif" }
# HEIC/HEIF: the shared decoder (moved from crates/heif; craft-libs#784).
craft-heif = { git = "https://github.com/storytold/craft-libs", rev = "430a908f68819bf23d14fe73ab9b18d8f4fd4e5d" }
lightcraft-segment = { path = "crates/segment" }
lightcraft-geocode = { path = "crates/geocode" }
lightcraft-slideshow = { path = "crates/slideshow" }
+1 -1
View File
@@ -37,6 +37,6 @@ rawnind-model = ["denoise", "lightcraft-engine/rawnind-model"]
# (open it in DHAT's viewer: allocation sites by bytes at the peak). Slows allocation-heavy work.
dhat-heap = ["dep:dhat"]
# Open HEIC/HEIF photos (the optional lightcraft-heif crate). Not default so distributors choose
# Open HEIC/HEIF photos (the optional craft-heif crate). Not default so distributors choose
# it (HEVC patents); build with `--features heif` to include it.
heif = ["lightcraft-codecs/heif"]
+1 -1
View File
@@ -77,7 +77,7 @@ web-sys = { workspace = true, features = [
] }
[features]
# Open HEIC/HEIF photos (the optional lightcraft-heif crate). Not default so distributors choose
# Open HEIC/HEIF photos (the optional craft-heif crate). Not default so distributors choose
# it (HEVC patents); build with `--features heif` to include it. On wasm32 panics abort, so
# heic-rs's `catch_unwind` guard does not apply there.
heif = ["lightcraft-codecs/heif"]
+1 -1
View File
@@ -13,7 +13,7 @@ workspace = true
default = ["denoise"]
denoise = ["lightcraft-engine/denoise"]
rawnind-model = ["denoise", "lightcraft-engine/rawnind-model"]
# Open HEIC/HEIF photos (the optional lightcraft-heif crate). Not default so distributors choose
# Open HEIC/HEIF photos (the optional craft-heif crate). Not default so distributors choose
# it (HEVC patents); build with `--features heif` to include it.
heif = ["lightcraft-codecs/heif"]
+5 -4
View File
@@ -12,7 +12,8 @@ workspace = true
lightcraft-geom = { workspace = true }
lightcraft-color = { workspace = true }
lightcraft-raster = { workspace = true }
lightcraft-heif = { workspace = true, optional = true }
craft-gainmap = { workspace = true }
craft-heif = { workspace = true, optional = true }
serde = { workspace = true }
bytemuck = { workspace = true }
thiserror = { workspace = true }
@@ -40,10 +41,10 @@ default = ["parallel", "jxl", "avif"]
parallel = ["dep:rayon", "lightcraft-raster/parallel", "jpeg-decoder/rayon"]
## JPEG XL decode (jxl-oxide) and, on native targets, encode (jixel); both pure Rust.
jxl = ["dep:jxl-oxide", "dep:jixel"]
# HEIC/HEIF decode via the optional lightcraft-heif crate (heic-rs, pure Rust). Off by default so
# HEIC/HEIF decode via the optional craft-heif crate (heic-rs, pure Rust). Off by default so
# distributors choose it at build time (HEVC patents are a distributor's call, same policy as
# PhotoCraft); `cargo xtask ci` clippies and tests it (`--features heif`), releases don't ship it yet.
heif = ["dep:lightcraft-heif"]
heif = ["dep:craft-heif"]
## AVIF encoding via ravif/rav1e (pure Rust, BSD). Native targets only; a no-op on wasm32.
avif = ["dep:ravif", "dep:rav1e", "dep:avif-serialize"]
@@ -54,7 +55,7 @@ lightcraft-testkit = { workspace = true }
jxl-oxide = { workspace = true }
proptest = { workspace = true }
# Lossless synthetic HEIC files for the `heif` feature's tests.
lightcraft-heif = { workspace = true, features = ["testdata"] }
craft-heif = { workspace = true, features = ["testdata"] }
[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
dhat = { workspace = true }
+1 -1
View File
@@ -54,7 +54,7 @@ CRW, MRW, X3F) are detected so the engine can route them to `lightcraft-raw`; `d
| PSD / PSB | merged composite: 8/16/32-bit gray, RGB, CMYK, indexed, duotone (as gray); raw/RLE | — | ICC (1039), EXIF (1058), XMP (1060); ZIP-compressed composite, Lab and 1-bit unsupported |
| JPEG XL | yes (jxl-oxide, feature `jxl`, default on) | yes (jixel, `encode_jxl`, feature `jxl`, native only): lossy VarDCT / lossless Modular, 8/16-bit, effort (fast / normal), progressive; HDR as 16-bit Rec. 2020 PQ | decode: enum colour → rendered straight to linear Rec.2020 (XYB via linear sRGB primaries); ICC → our ICC path; orientation applied by the decoder (reported as 1). Encode: lossy files declare an enum encoding (sRGB, Display P3, Rec. 2020 BT.709 curve, Rec. 2020 PQ), lossless ones embed the ICC profile; EXIF / XMP in `Exif` / `xml ` boxes |
| AVIF | **no** | yes (ravif/rav1e, native only, feature `avif`) | 8/10-bit sRGB, EXIF; no ICC in the muxer. HDR: `encode_avif_hdr` writes 10-bit BT.2020 PQ (SDR white at 203 cd/m², CICP `nclx` + `clli`) or HLG (`hlg_signal`, SDR white at 0.75) |
| HEIC/HEIF | yes with feature `heif` (lightcraft-heif: heic-rs + libheif-matching colour; 4:2:0/mono, 8–10-bit, grids, irot/imir/clap, ICC/nclx/VUI, EXIF/XMP, thumbnail item) | — | 4:2:2/4:4:4 (Canon/Sony HIF) unsupported |
| HEIC/HEIF | yes with feature `heif` (craft-heif: heic-rs + libheif-matching colour; 4:2:0/mono, 8–10-bit, grids, irot/imir/clap, ICC/nclx/VUI, EXIF/XMP, thumbnail item) | — | 4:2:2/4:4:4 (Canon/Sony HIF) unsupported |
| Gain map JPEG (HDR) | gain map found and decoded (`gainmap::read_jpeg`): ISO 21496-1 metadata, else Adobe `hdrgm` XMP | yes (`gainmap::encode_jpeg`) | CIPA DC-007 MPF index (gain map typed `0x050000`), ISO 21496-1 APP2 on both images, `hdrgm` + Container XMP for Android/Chrome, Apple `HDRGainMap`/`HDRToneMap` XMP; gain maps are never used as thumbnails |
## Colour
+9 -633
View File
@@ -1,547 +1,21 @@
//! Gain map HDR images (ISO 21496-1): an SDR base image plus a gain map that a decoder uses to
//! rebuild the HDR rendition, so the file looks right everywhere and lights up on HDR displays.
//! Gain map JPEGs (ISO 21496-1): an SDR base image plus a gain map that a decoder uses to rebuild
//! the HDR rendition, so the file looks right everywhere and lights up on HDR displays.
//!
//! The metadata formats and the arithmetic ([`compute`], [`apply`], [`GainMapMeta`]) are
//! `craft-gainmap`'s, re-exported here. This module lays the two images out in a JPEG:
//!
//! - [`compute`] measures a gain map from an SDR and an HDR rendition of the same picture (linear
//! light, same primaries). Measure it against the base *as written* (decoded from its 8-bit
//! codes), so quantisation in the base is handed back by the gain map.
//! - [`apply`] rebuilds the HDR rendition from a base and its gain map.
//! - [`encode_jpeg`] writes a gain map JPEG: the base with an MPF index (CIPA DC-007), the ISO
//! 21496-1 marker and Adobe/Google container XMP, followed by the gain map JPEG carrying the ISO
//! 21496-1 metadata, the Adobe `hdrgm` XMP (Android, Chrome) and Apple's description of the same
//! map (what survives an iMessage send).
//! - [`read_jpeg`] finds and decodes the gain map of a gain map JPEG (ours, cameras, Lightroom),
//! from its ISO 21496-1 metadata or, failing that, its `hdrgm` XMP.
//!
//! All gains are log2. A decoder recovers `log2(hdr + offset_hdr) − log2(sdr + offset_sdr)` as
//! `min + (max − min) · (code / 255)^(1 / gamma)`, scaled by a weight in 0..1 that depends on how
//! much headroom the display has between `base_headroom` and `alternate_headroom`.
pub use craft_gainmap::{GainImage, GainMapMeta, GainMapOptions, ISO_URN, apply, compute};
use crate::encode::{EncodeImage, EncodeMeta, Samples, jpeg_app_segments, xmp_segment};
use crate::{ChromaSubsampling, Error, Format, Result, jpeg, jpeg_par};
/// The ISO 21496-1 namespace that opens its APP2 payloads (NUL terminated).
pub const ISO_URN: &[u8] = b"urn:iso:std:iso:ts:21496:-1\0";
/// Fixed denominator for the metadata's rationals: one value per setting, byte-identical output.
const DENOMINATOR: u32 = 1_000_000;
/// Gain map parameters (ISO 21496-1 / Adobe `hdrgm`). Per-channel arrays repeat the first value
/// when the map is single-channel.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct GainMapMeta {
/// Three gain channels (R, G, B) instead of one luminance gain.
pub multichannel: bool,
/// The gain applies in the base image's colour space.
pub use_base_colour_space: bool,
/// log2 headroom at which the base is shown as is (0: an SDR base).
pub base_headroom: f32,
/// log2 headroom at which the gain map applies in full.
pub alternate_headroom: f32,
pub min: [f32; 3],
pub max: [f32; 3],
pub gamma: [f32; 3],
pub base_offset: [f32; 3],
pub alternate_offset: [f32; 3],
}
impl Default for GainMapMeta {
fn default() -> Self {
GainMapMeta {
multichannel: false,
use_base_colour_space: true,
base_headroom: 0.0,
alternate_headroom: 1.0,
min: [0.0; 3],
max: [1.0; 3],
gamma: [1.0; 3],
base_offset: [1.0 / 64.0; 3],
alternate_offset: [1.0 / 64.0; 3],
}
}
}
impl GainMapMeta {
fn channels(&self) -> usize {
if self.multichannel { 3 } else { 1 }
}
/// Usable by [`apply`]: finite, positive gammas, max ≥ min, headrooms in order.
pub fn is_valid(&self) -> bool {
let fin = |a: &[f32; 3]| a.iter().all(|v| v.is_finite());
fin(&self.min)
&& fin(&self.max)
&& fin(&self.gamma)
&& fin(&self.base_offset)
&& fin(&self.alternate_offset)
&& self.gamma.iter().all(|g| *g > 0.0)
&& self.min.iter().zip(&self.max).all(|(a, b)| b >= a)
&& self.base_headroom.is_finite()
&& self.alternate_headroom.is_finite()
&& self.alternate_headroom > self.base_headroom
}
/// The ISO 21496-1 APP2 payload of the gain map image, URN included.
pub fn to_iso(&self) -> Vec<u8> {
let mut p = ISO_URN.to_vec();
p.extend_from_slice(&0u16.to_be_bytes()); // minimum_version: readers gate on this
p.extend_from_slice(&0u16.to_be_bytes()); // writer_version
let mut flags = 0u8;
if self.multichannel {
flags |= FLAG_MULTICHANNEL;
}
if self.use_base_colour_space {
flags |= FLAG_BASE_COLOUR_SPACE;
}
p.push(flags);
let unsigned = |p: &mut Vec<u8>, v: f32| {
let n = (v as f64 * DENOMINATOR as f64).round().clamp(0.0, u32::MAX as f64) as u32;
p.extend_from_slice(&n.to_be_bytes());
p.extend_from_slice(&DENOMINATOR.to_be_bytes());
};
let signed = |p: &mut Vec<u8>, v: f32| {
let n = (v as f64 * DENOMINATOR as f64).round().clamp(i32::MIN as f64, i32::MAX as f64) as i32;
p.extend_from_slice(&n.to_be_bytes());
p.extend_from_slice(&DENOMINATOR.to_be_bytes());
};
unsigned(&mut p, self.base_headroom.max(0.0));
unsigned(&mut p, self.alternate_headroom.max(0.0));
for c in 0..self.channels() {
signed(&mut p, self.min[c]);
signed(&mut p, self.max[c]);
unsigned(&mut p, self.gamma[c]);
signed(&mut p, self.base_offset[c]);
signed(&mut p, self.alternate_offset[c]);
}
p
}
/// Parse an ISO 21496-1 payload (the bytes after [`ISO_URN`]). `None` for the versions-only
/// marker a primary image carries, unknown versions, a base that is the HDR rendition, or
/// values no decoder could use.
pub fn from_iso(p: &[u8]) -> Option<GainMapMeta> {
let mut r = Reader { b: p, at: 0 };
let min_version = r.u16()?;
let _writer_version = r.u16()?;
if min_version != 0 {
return None;
}
let flags = r.u8()?;
if flags & FLAG_BACKWARD != 0 {
return None;
}
let multichannel = flags & FLAG_MULTICHANNEL != 0;
let common = flags & FLAG_COMMON_DENOMINATOR != 0;
let common_d = if common { r.u32()? } else { 0 };
let unsigned = |r: &mut Reader| -> Option<f32> {
let n = r.u32()?;
let d = if common { common_d } else { r.u32()? };
(d != 0).then(|| (n as f64 / d as f64) as f32)
};
let signed = |r: &mut Reader| -> Option<f32> {
let n = r.u32()? as i32;
let d = if common { common_d } else { r.u32()? };
(d != 0).then(|| (n as f64 / d as f64) as f32)
};
let mut m = GainMapMeta {
multichannel,
use_base_colour_space: flags & FLAG_BASE_COLOUR_SPACE != 0,
base_headroom: unsigned(&mut r)?,
alternate_headroom: unsigned(&mut r)?,
..GainMapMeta::default()
};
for c in 0..m.channels() {
m.min[c] = signed(&mut r)?;
m.max[c] = signed(&mut r)?;
m.gamma[c] = unsigned(&mut r)?;
m.base_offset[c] = signed(&mut r)?;
m.alternate_offset[c] = signed(&mut r)?;
}
if !multichannel {
m.fill_from_first();
}
m.is_valid().then_some(m)
}
fn fill_from_first(&mut self) {
for a in [&mut self.min, &mut self.max, &mut self.gamma, &mut self.base_offset, &mut self.alternate_offset] {
a[1] = a[0];
a[2] = a[0];
}
}
/// The gain parameters from Adobe `hdrgm` XMP (the gain map image's packet), for files
/// without ISO 21496-1 metadata (the first Ultra HDR files). Attributes or `rdf:Seq` lists.
pub fn from_hdrgm_xmp(xmp: &str) -> Option<GainMapMeta> {
if !xmp.contains("hdrgm:") {
return None;
}
let base_rendition_hdr = xmp_values(xmp, "BaseRenditionIsHDR").is_some_and(|v| v.first().is_some_and(|s| s.eq_ignore_ascii_case("true")));
if base_rendition_hdr {
return None;
}
let get = |name: &str, default: f32| -> Option<([f32; 3], bool)> {
let Some(v) = xmp_values(xmp, name) else { return Some(([default; 3], false)) };
let f: Vec<f32> = v.iter().map(|s| s.trim().parse::<f32>().ok()).collect::<Option<_>>()?;
match f.as_slice() {
[a] => Some(([*a; 3], false)),
[a, b, c] => Some(([*a, *b, *c], true)),
_ => None,
}
};
let (max, m1) = get("GainMapMax", f32::NAN)?;
if max.iter().any(|v| v.is_nan()) {
return None; // the one required parameter
}
let (min, m2) = get("GainMapMin", 0.0)?;
let (gamma, m3) = get("Gamma", 1.0)?;
let (base_offset, m4) = get("OffsetSDR", 1.0 / 64.0)?;
let (alternate_offset, m5) = get("OffsetHDR", 1.0 / 64.0)?;
let (cap_min, _) = get("HDRCapacityMin", 0.0)?;
let max_gain = max.iter().copied().fold(f32::MIN, f32::max);
let (cap_max, _) = get("HDRCapacityMax", max_gain)?;
let m = GainMapMeta {
multichannel: m1 || m2 || m3 || m4 || m5,
use_base_colour_space: true,
base_headroom: cap_min[0].max(0.0),
alternate_headroom: cap_max[0],
min,
max,
gamma,
base_offset,
alternate_offset,
};
m.is_valid().then_some(m)
}
/// The gain map image's XMP: the Adobe `hdrgm` parameters (read by Android and Chrome, which
/// ignore the ISO payload) and Apple's description of the same map (what iMessage keeps).
pub fn to_gain_map_xmp(&self) -> String {
let names = ["GainMapMin", "GainMapMax", "Gamma", "OffsetSDR", "OffsetHDR"];
let values = [&self.min, &self.max, &self.gamma, &self.base_offset, &self.alternate_offset];
let uniform = |v: &[f32; 3]| !self.multichannel || (v[0] == v[1] && v[1] == v[2]);
let mut s = String::from(XMP_OPEN);
s.push_str(r#"<rdf:Description rdf:about="" xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/" hdrgm:Version="1.0""#);
s.push_str(&format!(r#" hdrgm:HDRCapacityMin="{}""#, num(self.base_headroom)));
s.push_str(&format!(r#" hdrgm:HDRCapacityMax="{}""#, num(self.alternate_headroom)));
s.push_str(r#" hdrgm:BaseRenditionIsHDR="False""#);
for (n, v) in names.iter().zip(values) {
if uniform(v) {
s.push_str(&format!(r#" hdrgm:{n}="{}""#, num(v[0])));
}
}
s.push('>');
// per-channel values are an rdf:Seq of three, not a comma list: readers parse each item
for (n, v) in names.iter().zip(values) {
if !uniform(v) {
s.push_str(&format!("<hdrgm:{n}><rdf:Seq>"));
for x in v {
s.push_str(&format!("<rdf:li>{}</rdf:li>", num(*x)));
}
s.push_str(&format!("</rdf:Seq></hdrgm:{n}>"));
}
}
s.push_str("</rdf:Description>");
s.push_str(&self.apple_description());
s.push_str(XMP_CLOSE);
s
}
/// Apple's own description of the map (`apdi`, `HDRGainMap`, `HDRToneMap` namespaces).
fn apple_description(&self) -> String {
// 'L008' (8-bit luminance) or '444f'; the stored map must really have that many channels
let format = if self.multichannel { 0x3434_3466u32 } else { 0x4C30_3038 };
let mut s = String::from(
r#"<rdf:Description rdf:about="" xmlns:apdi="http://ns.apple.com/pixeldatainfo/1.0/" xmlns:HDRGainMap="http://ns.apple.com/HDRGainMap/1.0/" xmlns:HDRToneMap="http://ns.apple.com/HDRToneMap/1.0/">"#,
);
s.push_str("<apdi:AuxiliaryImageType>urn:com:apple:photo:2020:aux:hdrgainmap</apdi:AuxiliaryImageType>");
s.push_str(&format!("<apdi:NativeFormat>{format}</apdi:NativeFormat><apdi:StoredFormat>{format}</apdi:StoredFormat>"));
s.push_str("<HDRGainMap:HDRGainMapVersion>131072</HDRGainMap:HDRGainMapVersion>");
// linear, not log2: the headroom multiplier itself
s.push_str(&format!("<HDRGainMap:HDRGainMapHeadroom>{}</HDRGainMap:HDRGainMapHeadroom>", num(self.alternate_headroom.exp2())));
s.push_str(&format!("<HDRToneMap:AlternateHeadroom>{}</HDRToneMap:AlternateHeadroom>", num(self.alternate_headroom)));
s.push_str("<HDRToneMap:ChannelMetadata><rdf:Seq>");
for c in 0..self.channels() {
s.push_str(&format!(
r#"<rdf:li rdf:parseType="Resource"><HDRToneMap:GainMapMin>{}</HDRToneMap:GainMapMin><HDRToneMap:GainMapMax>{}</HDRToneMap:GainMapMax><HDRToneMap:Gamma>{}</HDRToneMap:Gamma><HDRToneMap:BaseOffset>{}</HDRToneMap:BaseOffset><HDRToneMap:AlternateOffset>{}</HDRToneMap:AlternateOffset></rdf:li>"#,
num(self.min[c]),
num(self.max[c]),
num(self.gamma[c]),
num(self.base_offset[c]),
num(self.alternate_offset[c])
));
}
s.push_str("</rdf:Seq></HDRToneMap:ChannelMetadata>");
s.push_str(&format!("<HDRToneMap:BaseHeadroom>{}</HDRToneMap:BaseHeadroom>", num(self.base_headroom)));
s.push_str("<HDRToneMap:BaseColorIsWorkingColor>True</HDRToneMap:BaseColorIsWorkingColor><HDRToneMap:Version>1</HDRToneMap:Version>");
s.push_str("</rdf:Description>");
s
}
}
const FLAG_MULTICHANNEL: u8 = 0x80;
const FLAG_BASE_COLOUR_SPACE: u8 = 0x40;
const FLAG_COMMON_DENOMINATOR: u8 = 0x08;
const FLAG_BACKWARD: u8 = 0x04;
const XMP_OPEN: &str = "<?xpacket begin=\"\u{feff}\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?><x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">";
const XMP_CLOSE: &str = "</rdf:RDF></x:xmpmeta><?xpacket end=\"w\"?>";
/// A short decimal (up to 6 significant digits, no exponent for ordinary values).
fn num(v: f32) -> String {
if !v.is_finite() {
return "0".into();
}
let s = format!("{:.6}", v);
let s = s.trim_end_matches('0').trim_end_matches('.');
if s == "-0" || s.is_empty() { "0".into() } else { s.to_string() }
}
/// The values of `hdrgm:<name>`: an attribute (`name="v"`) or an element holding an `rdf:Seq`.
fn xmp_values(xmp: &str, name: &str) -> Option<Vec<String>> {
let attr = format!("hdrgm:{name}=");
if let Some(i) = xmp.find(&attr) {
let rest = xmp.get(i + attr.len()..)?;
let q = rest.chars().next()?;
if q == '"' || q == '\'' {
let body = rest.get(1..)?;
let end = body.find(q)?;
return Some(vec![body.get(..end)?.to_string()]);
}
}
let open = format!("<hdrgm:{name}>");
let close = format!("</hdrgm:{name}>");
let i = xmp.find(&open)?;
let body = xmp.get(i + open.len()..)?;
let body = body.get(..body.find(&close)?)?;
let mut out = Vec::new();
let mut rest = body;
while let Some(a) = rest.find("<rdf:li>") {
let after = rest.get(a + 8..)?;
let b = after.find("</rdf:li>")?;
out.push(after.get(..b)?.to_string());
rest = after.get(b..)?;
if out.len() > 3 {
return None;
}
}
if out.is_empty() {
// a plain element value
out.push(body.trim().to_string());
}
Some(out)
}
struct Reader<'a> {
b: &'a [u8],
at: usize,
}
impl Reader<'_> {
fn take<const N: usize>(&mut self) -> Option<[u8; N]> {
let s = self.b.get(self.at..self.at.checked_add(N)?)?;
self.at += N;
s.try_into().ok()
}
fn u8(&mut self) -> Option<u8> {
self.take::<1>().map(|a| a[0])
}
fn u16(&mut self) -> Option<u16> {
self.take().map(u16::from_be_bytes)
}
fn u32(&mut self) -> Option<u32> {
self.take().map(u32::from_be_bytes)
}
}
/// A gain map image: `channels` (1 or 3) interleaved 8-bit codes.
#[derive(Clone, Debug, PartialEq)]
pub struct GainImage {
pub width: usize,
pub height: usize,
pub channels: usize,
pub data: Vec<u8>,
}
impl GainImage {
/// Bilinear code of channel `c` at gain map coordinates (`x`, `y`) (pixel centres at +0.5).
fn sample(&self, x: f32, y: f32, c: usize) -> f32 {
let (w, h) = (self.width, self.height);
let fx = (x - 0.5).clamp(0.0, (w - 1) as f32);
let fy = (y - 0.5).clamp(0.0, (h - 1) as f32);
let (x0, y0) = (fx as usize, fy as usize);
let (x1, y1) = ((x0 + 1).min(w - 1), (y0 + 1).min(h - 1));
let (tx, ty) = (fx - x0 as f32, fy - y0 as f32);
let at = |x: usize, y: usize| self.data.get((y * w + x) * self.channels + c).copied().unwrap_or(0) as f32;
let a = at(x0, y0) + (at(x1, y0) - at(x0, y0)) * tx;
let b = at(x0, y1) + (at(x1, y1) - at(x0, y1)) * tx;
a + (b - a) * ty
}
}
/// How [`compute`] builds the map.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct GainMapOptions {
/// Downscale factor of the map (1, 2 or 4).
pub scale: usize,
/// Three gains (R, G, B) instead of one luminance gain. Apple's readers want a single
/// channel, so this is off by default.
pub multichannel: bool,
pub gamma: f32,
/// Offsets added to SDR and HDR before the ratio (keep blacks finite and noise quiet).
pub offset: f32,
}
impl Default for GainMapOptions {
fn default() -> Self {
GainMapOptions { scale: 2, multichannel: false, gamma: 1.0, offset: 1.0 / 64.0 }
}
}
/// Measure the gain map that turns `sdr` into `hdr` (both `width × height` linear RGB in the same
/// primaries; `luma` = that space's luminance weights).
pub fn compute(
sdr: &[[f32; 3]],
hdr: &[[f32; 3]],
width: usize,
height: usize,
luma: [f32; 3],
o: &GainMapOptions,
) -> Result<(GainImage, GainMapMeta)> {
let n = width.checked_mul(height).ok_or_else(|| Error::Encode("gain map: image too large".into()))?;
if n == 0 || sdr.len() < n || hdr.len() < n {
return Err(Error::Encode("gain map: SDR and HDR renditions must match the image size".into()));
}
if !(matches!(o.scale, 1 | 2 | 4) && o.gamma > 0.0 && o.gamma.is_finite() && o.offset > 0.0 && o.offset.is_finite()) {
return Err(Error::Encode("gain map: scale must be 1, 2 or 4, gamma and offset positive".into()));
}
let s = o.scale;
let (gw, gh) = (width.div_ceil(s), height.div_ceil(s));
let ch = if o.multichannel { 3 } else { 1 };
let y = |p: &[f32; 3]| luma[0] * p[0] + luma[1] * p[1] + luma[2] * p[2];
let ratio = |a: f32, b: f32| ((b.max(0.0) + o.offset) / (a.max(0.0) + o.offset)).log2();
// block means of the log gains
let mut gains = vec![0f32; gw * gh * ch];
let mut lo = [f32::MAX; 3];
let mut hi = [f32::MIN; 3];
for gy in 0..gh {
for gx in 0..gw {
let mut acc = [0f32; 3];
let mut count = 0f32;
for yy in gy * s..((gy + 1) * s).min(height) {
for xx in gx * s..((gx + 1) * s).min(width) {
let i = yy * width + xx;
let (Some(a), Some(b)) = (sdr.get(i), hdr.get(i)) else { continue };
if o.multichannel {
for c in 0..3 {
acc[c] += ratio(a[c], b[c]);
}
} else {
acc[0] += ratio(y(a), y(b));
}
count += 1.0;
}
}
for c in 0..ch {
let g = if count > 0.0 { acc[c] / count } else { 0.0 };
let g = if g.is_finite() { g } else { 0.0 };
gains[(gy * gw + gx) * ch + c] = g;
lo[c] = lo[c].min(g);
hi[c] = hi[c].max(g);
}
}
}
let mut m = GainMapMeta {
multichannel: o.multichannel,
gamma: [o.gamma; 3],
base_offset: [o.offset; 3],
alternate_offset: [o.offset; 3],
..GainMapMeta::default()
};
for c in 0..ch {
// the range always includes 0 (no change) so an SDR-only area encodes exactly
m.min[c] = lo[c].min(0.0);
m.max[c] = hi[c].max(m.min[c] + 1e-4);
}
if !o.multichannel {
m.fill_from_first();
}
m.base_headroom = 0.0;
m.alternate_headroom = m.max.iter().copied().fold(0.0f32, f32::max).max(1e-3);
let data = gains
.iter()
.enumerate()
.map(|(i, g)| {
let c = i % ch;
let norm = ((g - m.min[c]) / (m.max[c] - m.min[c])).clamp(0.0, 1.0);
(norm.powf(o.gamma) * 255.0).round() as u8
})
.collect();
Ok((GainImage { width: gw, height: gh, channels: ch, data }, m))
}
/// Rebuild the HDR rendition in place: `base` (`width × height` linear RGB) is replaced by the
/// rendition at `weight` (0 = the base, 1 = the full alternate rendition; a display with headroom
/// `H` uses `(H − base_headroom) / (alternate_headroom − base_headroom)`, clamped).
pub fn apply(base: &mut [[f32; 3]], width: usize, height: usize, gain: &GainImage, m: &GainMapMeta, weight: f32) -> Result<()> {
let n = width.checked_mul(height).ok_or_else(|| Error::Encode("gain map: image too large".into()))?;
if base.len() < n
|| gain.width == 0
|| gain.height == 0
|| !matches!(gain.channels, 1 | 3)
|| gain.data.len() < gain.width * gain.height * gain.channels
{
return Err(Error::Encode("gain map: base and gain map sizes don't match".into()));
}
if !m.is_valid() {
return Err(Error::Encode("gain map: unusable metadata".into()));
}
let weight = if weight.is_finite() { weight.clamp(0.0, 1.0) } else { 1.0 };
let (sx, sy) = (gain.width as f32 / width as f32, gain.height as f32 / height as f32);
let inv_gamma = m.gamma.map(|g| 1.0 / g);
for (i, p) in base.iter_mut().enumerate().take(n) {
let (x, y) = ((i % width) as f32 + 0.5, (i / width) as f32 + 0.5);
let (gx, gy) = (x * sx, y * sy);
let mut g = [0f32; 3];
for (c, gc) in g.iter_mut().enumerate() {
let src = if gain.channels == 3 { c } else { 0 };
let norm = (gain.sample(gx, gy, src) / 255.0).clamp(0.0, 1.0).powf(inv_gamma[c]);
*gc = m.min[c] + (m.max[c] - m.min[c]) * norm;
}
for c in 0..3 {
let v = (p[c] + m.base_offset[c]) * (g[c] * weight).exp2() - m.alternate_offset[c];
p[c] = v.max(0.0);
}
}
Ok(())
}
/// The primary image's container XMP: `hdrgm:Version` (marks the file as a gain map image for
/// Adobe/Google readers) and the Container directory naming the gain map and its length.
fn primary_description(gain_len: usize) -> String {
format!(
concat!(
r#"<rdf:Description rdf:about="" xmlns:Container="http://ns.google.com/photos/1.0/container/" xmlns:Item="http://ns.google.com/photos/1.0/container/item/" xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/" hdrgm:Version="1.0">"#,
r#"<Container:Directory><rdf:Seq>"#,
r#"<rdf:li rdf:parseType="Resource"><Container:Item Item:Semantic="Primary" Item:Mime="image/jpeg"/></rdf:li>"#,
r#"<rdf:li rdf:parseType="Resource"><Container:Item Item:Semantic="GainMap" Item:Mime="image/jpeg" Item:Length="{}"/></rdf:li>"#,
r#"</rdf:Seq></Container:Directory></rdf:Description>"#
),
gain_len
)
}
/// `xmp` with `description` added as another `rdf:Description` (a fresh packet when there is
/// none, or when it has no `rdf:RDF` to add to).
fn merge_xmp(xmp: Option<&str>, description: &str) -> String {
if let Some(x) = xmp
&& let Some(i) = x.rfind("</rdf:RDF>")
&& let (Some(a), Some(b)) = (x.get(..i), x.get(i..))
{
return format!("{a}{description}{b}");
}
format!("{XMP_OPEN}{description}{XMP_CLOSE}")
}
/// Offsets within the MPF payload (from "MPF\0"): the endian field, then the index IFD (3 tags).
const MPF_ENTRIES_FROM_ENDIAN: usize = 8 + 2 + 3 * 12 + 4;
@@ -598,11 +72,9 @@ pub fn encode_jpeg(base: &EncodeImage, gain: &GainImage, m: &GainMapMeta, qualit
let gain_segs = vec![(0xE1, xmp_segment(&m.to_gain_map_xmp())?), (0xE2, m.to_iso())];
let gain_jpeg = jpeg_par::encode(&gain.data, gain.width, gain.height, gain.channels, quality, ChromaSubsampling::S444, &gain_segs);
let xmp = merge_xmp(meta.xmp, &primary_description(gain_jpeg.len()));
let xmp = craft_gainmap::primary_xmp(meta.xmp, gain_jpeg.len());
let mut segs = jpeg_app_segments(&EncodeMeta { xmp: Some(&xmp), ..*meta })?;
let mut iso_marker = ISO_URN.to_vec();
iso_marker.extend_from_slice(&[0, 0, 0, 0]); // versions only: "this image has a gain map"
segs.push((0xE2, iso_marker));
segs.push((0xE2, craft_gainmap::primary_iso_marker()));
segs.push((0xE2, mpf_placeholder()));
let mut primary = jpeg_par::encode(data, w, h, base.channels as usize, quality, sub, &segs);
@@ -672,77 +144,6 @@ pub fn is_gain_map_jpeg(bytes: &[u8]) -> bool {
mod tests {
use super::*;
fn meta3() -> GainMapMeta {
GainMapMeta {
multichannel: true,
use_base_colour_space: true,
base_headroom: 0.0,
alternate_headroom: 2.5,
min: [-0.25, -0.5, 0.0],
max: [2.5, 2.25, 2.0],
gamma: [1.0, 1.25, 0.75],
base_offset: [0.015625; 3],
alternate_offset: [0.015625, 0.03125, 0.015625],
}
}
#[test]
fn iso_metadata_round_trips() {
for m in [GainMapMeta { alternate_headroom: 3.0, max: [3.0; 3], ..GainMapMeta::default() }, meta3()] {
let p = m.to_iso();
assert!(p.starts_with(ISO_URN));
let back = GainMapMeta::from_iso(&p[ISO_URN.len()..]).unwrap();
for (a, b) in [(back.min, m.min), (back.max, m.max), (back.gamma, m.gamma), (back.alternate_offset, m.alternate_offset)] {
for c in 0..3 {
assert!((a[c] - b[c]).abs() < 1e-6, "{a:?} {b:?}");
}
}
assert_eq!(back.multichannel, m.multichannel);
assert!((back.alternate_headroom - m.alternate_headroom).abs() < 1e-6);
}
}
#[test]
fn iso_common_denominator_and_rejections() {
// common-denominator form, single channel: d = 4, headrooms 0 and 2, min 0, max 2, gamma 1, offsets 0
let mut p = vec![0, 0, 0, 0, FLAG_COMMON_DENOMINATOR];
for v in [4u32, 0, 8, 0, 8, 4, 0, 0] {
p.extend_from_slice(&v.to_be_bytes());
}
let m = GainMapMeta::from_iso(&p).unwrap();
assert_eq!((m.alternate_headroom, m.max[2], m.gamma[1]), (2.0, 2.0, 1.0));
// versions only (a primary image's marker), unknown version, truncated, backward
assert!(GainMapMeta::from_iso(&[0, 0, 0, 0]).is_none());
assert!(GainMapMeta::from_iso(&[0, 1, 0, 0, 0]).is_none());
assert!(GainMapMeta::from_iso(&p[..p.len() - 1]).is_none());
let mut back = p.clone();
back[4] |= FLAG_BACKWARD;
assert!(GainMapMeta::from_iso(&back).is_none());
// a zero denominator is rejected, not divided by
let mut z = p.clone();
z[5..9].copy_from_slice(&0u32.to_be_bytes());
assert!(GainMapMeta::from_iso(&z).is_none());
}
#[test]
fn hdrgm_xmp_round_trips_including_per_channel_sequences() {
for m in [GainMapMeta { alternate_headroom: 2.0, max: [2.0; 3], ..GainMapMeta::default() }, meta3()] {
let x = m.to_gain_map_xmp();
assert!(x.contains("apdi:AuxiliaryImageType"));
if m.multichannel {
assert!(x.contains("<hdrgm:GainMapMax><rdf:Seq><rdf:li>2.5</rdf:li>"), "{x}");
}
let back = GainMapMeta::from_hdrgm_xmp(&x).unwrap();
assert_eq!(back.multichannel, m.multichannel);
for c in 0..3 {
assert!((back.max[c] - m.max[c]).abs() < 1e-5 && (back.gamma[c] - m.gamma[c]).abs() < 1e-5);
}
assert!((back.alternate_headroom - m.alternate_headroom).abs() < 1e-5);
}
assert!(GainMapMeta::from_hdrgm_xmp("<x hdrgm:Version=\"1.0\"/>").is_none(), "no GainMapMax");
assert!(GainMapMeta::from_hdrgm_xmp("hdrgm:GainMapMax=\"nope\"").is_none());
}
fn renditions(w: usize, h: usize) -> (Vec<[f32; 3]>, Vec<[f32; 3]>) {
// a ramp: SDR rolls off at 1, HDR keeps going to 6
let hdr: Vec<[f32; 3]> = (0..w * h)
@@ -765,31 +166,6 @@ mod tests {
(sdr, hdr)
}
#[test]
fn compute_then_apply_recovers_the_hdr_rendition() {
let (w, h) = (64, 8);
let (sdr, hdr) = renditions(w, h);
for multichannel in [false, true] {
let o = GainMapOptions { scale: 1, multichannel, ..GainMapOptions::default() };
let (g, m) = compute(&sdr, &hdr, w, h, [0.2126, 0.7152, 0.0722], &o).unwrap();
assert!(m.is_valid() && m.alternate_headroom > 1.0);
let mut out = sdr.clone();
apply(&mut out, w, h, &g, &m, 1.0).unwrap();
for (a, b) in out.iter().zip(&hdr) {
for c in 0..3 {
// 8-bit codes over the gain range: within ~2 % in linear light
assert!((a[c] - b[c]).abs() <= 0.03 * b[c] + 0.01, "{multichannel}: {a:?} vs {b:?}");
}
}
// weight 0 is the base
let mut base = sdr.clone();
apply(&mut base, w, h, &g, &m, 0.0).unwrap();
for (a, b) in base.iter().zip(&sdr) {
assert!((a[0] - b[0]).abs() < 1e-5);
}
}
}
#[test]
fn a_gain_map_wider_than_a_jpeg_allows_is_refused() {
let base = [0u8; 3];
+9 -9
View File
@@ -1,6 +1,6 @@
//! HEIF / HEIC (the iPhone and Mac photo format), read-only.
//!
//! Decoding lives in the optional `lightcraft-heif` crate (heic-rs, a pure-Rust HEVC
//! Decoding lives in the optional `craft-heif` crate (heic-rs, a pure-Rust HEVC
//! still-picture decoder, plus a libheif-matching colour conversion), enabled by this crate's
//! `heif` feature — off by default because HEVC is patent-encumbered and whether a build carries
//! an HEVC decoder is the distributor's call (the same policy as the sibling PhotoCraft). Without
@@ -35,10 +35,10 @@ pub(crate) fn header(_bytes: &[u8]) -> Result<(u32, u32, u16)> {
}
#[cfg(feature = "heif")]
fn err(e: lightcraft_heif::Error) -> Error {
fn err(e: craft_heif::Error) -> Error {
match e {
lightcraft_heif::Error::Unsupported(why) => Error::Unsupported(F, why),
lightcraft_heif::Error::Limit(m) | lightcraft_heif::Error::Malformed(m) => Error::Malformed(F, m),
craft_heif::Error::Unsupported(why) => Error::Unsupported(F, why),
craft_heif::Error::Limit(m) | craft_heif::Error::Malformed(m) => Error::Malformed(F, m),
}
}
@@ -46,24 +46,24 @@ fn err(e: lightcraft_heif::Error) -> Error {
/// alone: no picture is decoded.
#[cfg(feature = "heif")]
pub(crate) fn header(bytes: &[u8]) -> Result<(u32, u32, u16)> {
let info = lightcraft_heif::probe(bytes).map_err(err)?;
let info = craft_heif::probe(bytes).map_err(err)?;
Ok((info.width, info.height, 1))
}
#[cfg(feature = "heif")]
pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {
// The container alone: the declared size is checked before any pixel is decoded.
let info = lightcraft_heif::probe(bytes).map_err(err)?;
let info = craft_heif::probe(bytes).map_err(err)?;
if (info.width as u64).saturating_mul(info.height as u64) > opts.max_pixels {
return Err(Error::TooLarge(info.width as u64, info.height as u64));
}
let options = lightcraft_heif::Options { max_pixels: opts.max_pixels, apply_transforms: true };
let options = craft_heif::Options { max_pixels: opts.max_pixels, apply_transforms: true, ..craft_heif::Options::default() };
// A small decode (a thumbnail or a cataloguing probe) uses the file's own thumbnail image when
// it is at least as large as asked: iPhones store one of 320 × 240, and decoding it is a
// hundredth of the work of the 12 MP photo.
let thumb = match opts.max_size {
Some((mw, mh)) if mw > 0 && mh > 0 && mw.max(mh) < info.width.max(info.height) => {
lightcraft_heif::decode_thumbnail(bytes, mw.max(mh), &options).ok().flatten().filter(|t| {
craft_heif::decode_thumbnail(bytes, mw.max(mh), &options).ok().flatten().filter(|t| {
// Only a thumbnail of the same picture: same orientation and aspect within 1 %.
let aspect = |w: u32, h: u32| w as f64 / h.max(1) as f64;
(aspect(t.width, t.height) / aspect(info.width, info.height) - 1.0).abs() < 0.01
@@ -73,7 +73,7 @@ pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {
};
let mut decoded = match thumb {
Some(t) => t,
None => lightcraft_heif::decode(bytes, &options).map_err(err)?,
None => craft_heif::decode(bytes, &options).map_err(err)?,
};
let raw = Raw {
width: decoded.width as usize,
+2 -2
View File
@@ -1,9 +1,9 @@
//! HEIC/HEIF through the codec API (feature `heif`), on lossless synthetic files from
//! `lightcraft_heif::testdata`: an iPhone-like grid with a Display P3 profile, rotation, EXIF, a
//! `craft_heif::testdata`: an iPhone-like grid with a Display P3 profile, rotation, EXIF, a
//! thumbnail and an HDR gain map; `nclx`-only colour; 10-bit; and hostile input.
use craft_heif::testdata::{Prop, Spec, build};
use lightcraft_codecs::*;
use lightcraft_heif::testdata::{Prop, Spec, build};
fn grey(x: u32, y: u32) -> [u16; 3] {
[((x * 7 + y * 13) % 220 + 20) as u16, 128, 128]
+1 -1
View File
@@ -66,6 +66,6 @@ lightcraft-testkit = { workspace = true }
# HDR JPEG XL tests read the file's colour encoding
jxl-oxide = { workspace = true }
# Lossless synthetic HEIC files (the import test; decoded when the codecs' `heif` feature is on).
lightcraft-heif = { workspace = true, features = ["testdata"] }
craft-heif = { workspace = true, features = ["testdata"] }
libc = { workspace = true }
craft-tiff = { workspace = true }
+2 -2
View File
@@ -2820,7 +2820,7 @@ fn a_file_gone_since_the_import_review_is_not_imported() {
/// a JPEG. In a build without the codecs' `heif` feature it is reported as failed, saying why.
#[test]
fn heic_imports_as_a_normal_photo_or_says_why_not() {
use lightcraft_heif::testdata::{Prop, Spec, build};
use craft_heif::testdata::{Prop, Spec, build};
let src = temp_dir("heic");
let photo = |x: u32, y: u32| [((x * 7 + y * 13) % 200 + 30) as u16, 110, 150];
let p3 = lightcraft_codecs::icc::write_named(lightcraft_codecs::NamedSpace::DisplayP3);
@@ -2857,8 +2857,8 @@ fn heic_imports_as_a_normal_photo_or_says_why_not() {
/// writes as UTC: an iPhone photo landed five hours late and after 19:00 on the wrong day.
#[test]
fn a_heic_is_dated_by_its_exif_and_not_by_the_file() {
use craft_heif::testdata::{Spec, build};
use craft_tiff::{ByteOrder, IfdBuilder, TiffWriter, Value, tags as t};
use lightcraft_heif::testdata::{Spec, build};
let src = temp_dir("heic-capture-time");
let photo = |x: u32, y: u32| [((x * 7 + y * 13) % 200 + 30) as u16, 110, 150];
let mut exif = IfdBuilder::new();
-26
View File
@@ -1,26 +0,0 @@
[package]
name = "lightcraft-heif"
description = "Optional HEIF/HEIC still-image decoder for LightCraft (heic-rs for the container and HEVC, libheif-matching colour conversion, panic-guarded)"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
# Pure Rust, no unsafe. Pinned exactly: a young, single-owner crate that parses untrusted files;
# moving the pin is a reviewed change (re-run the heif tests and the codecs corpus tests).
# Mirrors PhotoCraft's photocraft-heif (same team, same decision): heic-rs was chosen over the
# other permissive candidates (heif-oxide's HEVC decoder, rust_h265, follows FFmpeg's (LGPL)
# code structure; gamut-heic has no HEVC decoder of its own).
heic-rs = { version = "=0.1.4", default-features = false, features = ["std"] }
# The tiles of a HEIC photo decode in parallel on native; wasm stays single-threaded.
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
heic-rs = { version = "=0.1.4", default-features = false, features = ["std", "parallel"] }
rayon = { workspace = true }
[features]
# `lightcraft_heif::testdata`: lossless synthetic HEIF files, for the tests of the crates above.
testdata = []
[lints]
workspace = true
-47
View File
@@ -1,47 +0,0 @@
# lightcraft-heif
The optional HEIF / HEIC decoder of LightCraft: iPhone and Mac photos. [`heic-rs`](https://github.com/tbraun96/heic-rs)
(pure Rust, no `unsafe`, MIT OR Apache-2.0, written from the H.265 / HEIF specifications) reads the
container and reconstructs the HEVC pictures; this crate turns them into 16-bit RGB itself so the
result matches libheif to within one code value:
- the colour description is the item's `colr nclx` (or its first tile's), else the HEVC VUI
(iPhones: full range), else the H.265 defaults; an unspecified matrix is BT.601. heic-rs alone
assumes BT.709 limited range, about 8 code values off on every iPhone photo;
- chroma is upsampled by nearest neighbour, or centred bilinear when a `clap` starts on an odd
pixel, as libheif does;
- `imir` axis 0 flips top and bottom, as libheif writes and reads it (heic-rs names it the other way);
- a grid's ICC profile may sit on its tiles.
Single pictures and grid-tiled photos, 4:2:0 and monochrome, 8- to 10-bit, alpha auxiliary images
(other auxiliary images — HDR gain maps, depth — are ignored), the container's rotation/mirror/crop,
ICC, EXIF and XMP, and the file's thumbnail item. 4:2:2 and 4:4:4 (Canon/Sony "HIF") are refused
with `Error::Unsupported`: heic-rs 0.1.1 loses sync on them. Read-only.
```rust
let info = lightcraft_heif::probe(&bytes)?; // size, depth, alpha: check limits first
let img = lightcraft_heif::decode(&bytes, &lightcraft_heif::Options::default())?;
// img.width, img.height, img.has_alpha, img.bit_depth, img.data (RGB/RGBA u16), img.colour, img.icc, img.exif, img.xmp
let thumb = lightcraft_heif::decode_thumbnail(&bytes, 256, &Default::default())?; // Option<Decoded>
```
Errors are `Error::Unsupported` (image sequences, overlays, 4:2:2/4:4:4, …), `Error::Limit` or
`Error::Malformed`. It never panics: every call into heic-rs runs under `catch_unwind`, and a panic
inside it (PhotoCraft's fuzzing found two in 0.1.1) becomes `Error::Malformed`.
Feature `testdata` exposes `lightcraft_heif::testdata`: lossless synthetic HEIF files (PCM-coded
32 × 32 HEVC pictures, grids, every property above) for the tests of the crates above.
## Why it is a separate, optional crate
- **A young decoder.** heic-rs is new and has a single maintainer. It is pinned exactly
(`=0.1.1`); moving the pin is a reviewed change (re-run the crate tests and
`cargo test -p lightcraft-codecs --features heif`). The other permissive candidates were
rejected: heif-oxide's HEVC decoder (rust_h265) follows FFmpeg's (LGPL) code structure, and
gamut-heic has no HEVC decoder of its own.
- **HEVC patents are a distributor's call.** `lightcraft-codecs` uses this crate only behind its
non-default `heif` feature; the apps forward it and the release packages enable it. Without it,
HEIC files are still recognised and opening one is a clear "HEIC/HEIF support isn't included in
this build" error — the same policy as PhotoCraft.
The crate depends on no other LightCraft crate; `codecs` → `heif` is the only edge between them.
-122
View File
@@ -1,122 +0,0 @@
//! Caps on the container's metadata boxes, counted before heic-rs touches the file.
//!
//! heic-rs 0.1.4 (pinned `=0.1.4`) has no aggregate work budget inside its container parsing:
//! every `ipma` association entry rescans the vector of already-seen item ids (quadratic in
//! the number of entries), and an `iloc` extent using construction method 2 reconstructs its
//! source item afresh for every extent that references it, with no shared cache. Legitimate
//! phone-photo metadata never comes near these caps — real corpora keep both well under a few
//! kilobytes — so anything above them is hostile or corrupt and is refused before the
//! countable CPU work happens.
//!
//! [`depth_boxes`] stops silently at structural blips: heic-rs's own parser reports those
//! better than this walk could, and an `ipma` box past the cap is caught wherever it parses.
use heic_rs::boxes::BoxIter;
use crate::Error;
/// The largest `ipma` box (item ↔ property associations) payload accepted, 64 KiB. An entry
/// costs at least 3 bytes, so this bounds heic-rs's per-entry rescan of earlier item ids to
/// ~21 000 entries ≈ 220 million comparisons: long enough to be annoying, never minutes.
const MAX_IPMA_BYTES: usize = 64 << 10;
/// The largest `iloc` box (item locations) payload accepted, 64 KiB. An extent costs at least
/// 12 bytes, so this bounds both the parse itself and how many extents a
/// construction-method-2 reconstruction chain can visit.
const MAX_ILOC_BYTES: usize = 64 << 10;
/// Falls through unless the container declares more `ipma` or `iloc` payload than a
/// legitimate phone photo ever does.
pub fn cap(bytes: &[u8]) -> Result<(), Error> {
let mut c = Census::default();
depth_boxes(&mut c, BoxIter::new(bytes), 0);
if c.ipma > MAX_IPMA_BYTES {
return Err(Error::Limit(format!("the image carries {} bytes of property associations, over the {MAX_IPMA_BYTES}-byte cap", c.ipma)));
}
if c.iloc > MAX_ILOC_BYTES {
return Err(Error::Limit(format!("the image carries {} bytes of item locations, over the {MAX_ILOC_BYTES}-byte cap", c.iloc)));
}
Ok(())
}
/// The metadata-box payload sizes seen so far.
#[derive(Default)]
struct Census {
ipma: usize,
iloc: usize,
}
/// Walks boxes, adding the payload sizes of those named in [`Census`].
///
/// Only `meta` and `iprp` (the two nesting boxes the metadata is built from) are descended
/// into, no deeper than that depth, so a nested-box trick can't hide a box from the count.
fn depth_boxes(c: &mut Census, boxes: BoxIter<'_>, depth: u32) {
if depth > 3 {
return;
}
for b in boxes {
// A structural error stops the walk; `heic_rs::probe` reports it properly afterwards.
let Ok(b) = b else { return };
if b.is(b"ipma") {
c.ipma = c.ipma.saturating_add(b.payload.len());
} else if b.is(b"iloc") {
c.iloc = c.iloc.saturating_add(b.payload.len());
} else if b.is(b"meta") {
// `meta` is a FullBox: version and flags sit between its header and its children.
if b.payload.len() >= 4 {
depth_boxes(c, BoxIter::new(&b.payload[4..]), depth + 1);
}
} else if b.is(b"iprp") {
depth_boxes(c, b.children(), depth + 1);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
/// Assembles ftyp + meta(version/flags + iprp(ipco, ipma)) by hand; only the structure
/// the census walks matters, no item is ever defined.
fn file_with(ipma_payload: &[u8]) -> Vec<u8> {
let mut out = b"\0\0\0\x18ftypheic\0\0\0\0mif1heic".to_vec();
let mut iprp = Vec::new();
iprp.extend(box_of(b"ipco", b""));
iprp.extend(box_of(b"ipma", ipma_payload));
let mut meta = vec![0u8, 0, 0, 0]; // version 0, flags 0
meta.extend(box_of(b"iprp", &iprp));
out.extend(box_of(b"meta", &meta));
out
}
fn box_of(kind: &[u8; 4], body: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(8 + body.len());
let size = u32::try_from(8 + body.len()).expect("test box fits in u32");
out.extend_from_slice(&size.to_be_bytes());
out.extend_from_slice(kind);
out.extend_from_slice(body);
out
}
#[test]
fn an_oversized_ipma_is_refused() {
// 40 000 entries of 6 bytes: 240 KiB of ipma, far over the cap, and quadratic if
// parsed (each entry rescans the earlier item ids in heic-rs 0.1.4).
let mut ipma = Vec::new();
for _ in 0..40_000u32 {
ipma.extend_from_slice(&[0u8, 0, 0, 0, 0, 0]);
}
let bytes = file_with(&ipma);
let r = crate::probe(&bytes).map(|_| ());
assert!(matches!(r, Err(Error::Limit(ref m)) if m.contains("associations")), "{r:?}");
}
#[test]
fn a_undersized_ipma_is_untouched_by_the_caps() {
// The same shape with a normal ipma (two entries): the caps pass, and whatever error
// follows must not come from them.
let bytes = file_with(&[0, 0, 4, 1, 1, 2, 0, 0]);
let r = crate::probe(&bytes);
assert!(!matches!(r, Err(Error::Limit(ref m)) if m.contains("cap")), "{r:?}");
}
}
-605
View File
@@ -1,605 +0,0 @@
//! `lightcraft-heif`: the optional HEIF / HEIC (iPhone and Mac photo) decoder.
//!
//! `heic-rs`, a pure-Rust HEIF container and HEVC still-picture decoder, reads the container and
//! reconstructs the coded pictures (bit-exact against libde265 on iPhone photos); this crate turns
//! them into RGB itself ([`ycc`]) so the colours match libheif: it honours the HEVC VUI's range
//! and matrix ([`vui`]) where heic-rs assumes BT.709 limited range, and upsamples chroma like
//! libheif. Single pictures and grid-tiled photos, 8- to 16-bit, monochrome, alpha auxiliary
//! images, ICC, EXIF and XMP. The API is plain data ([`Info`], [`Decoded`], [`Error`]) so the
//! crate knows nothing about the rest of LightCraft; `lightcraft-codecs` adapts it behind its
//! `heif` feature. Shares heic-rs and its regression fixtures with PhotoCraft's `photocraft-heif`.
//!
//! HEIF records orientation in the container (`irot`/`imir`, plus a `clap` crop), not in EXIF.
//! [`Options::apply_transforms`] applies them; with it off, the pixels come back as coded.
//! Auxiliary images other than alpha (HDR gain maps, depth maps) are ignored.
//!
//! Never panics: heic-rs is young, so every call into it runs under `catch_unwind` and a panic
//! inside it becomes [`Error::Malformed`].
#![forbid(unsafe_code)]
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
mod census;
mod orient;
/// Lossless synthetic HEIF files for tests, here and in the crates above (feature `testdata`).
#[cfg(any(test, feature = "testdata"))]
#[doc(hidden)]
pub mod testdata;
mod vui;
mod ycc;
use std::borrow::Cow;
use heic_rs::context::Context;
use heic_rs::hevc::Frame;
use heic_rs::props::ItemProps;
use heic_rs::props::colr::Range;
/// What a HEIF file declares, read from the container alone (no pixel is decoded).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Info {
/// Size after the container transforms (rotation, mirror, crop): what a viewer shows.
pub width: u32,
pub height: u32,
/// Size as coded, before the transforms.
pub coded_width: u32,
pub coded_height: u32,
/// The primary image has an alpha auxiliary image.
pub has_alpha: bool,
/// Bits per sample as coded (8 for most photos, 10 for HDR-capable ones).
pub bit_depth: u8,
}
/// Decode settings.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Options {
/// Refuse images with more pixels than this (checked before decoding).
pub max_pixels: u64,
/// Apply the container's rotation, mirror and crop (`irot`/`imir`/`clap`).
pub apply_transforms: bool,
}
impl Default for Options {
fn default() -> Self {
Options { max_pixels: 1 << 28, apply_transforms: true }
}
}
/// How the file describes its colour: the code points of ITU-T H.273, from the `colr` `nclx`
/// box, else the HEVC VUI, else the standard defaults (2 = unspecified, limited range).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Colour {
pub primaries: u16,
pub transfer: u16,
pub matrix: u16,
pub full_range: bool,
}
/// A decoded image: interleaved RGB or RGBA, 16 bits per sample whatever the coded depth,
/// row-major, no padding.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Decoded {
pub width: u32,
pub height: u32,
/// Four channels (RGBA) instead of three (RGB).
pub has_alpha: bool,
/// Bits per sample as coded.
pub bit_depth: u8,
pub data: Vec<u16>,
pub colour: Colour,
/// The primary image's ICC profile.
pub icc: Option<Vec<u8>>,
/// EXIF as a TIFF structure (without HEIF's offset header). Its Orientation tag only mirrors
/// what the container says; it is returned verbatim.
pub exif: Option<Vec<u8>>,
/// The XMP packet.
pub xmp: Option<String>,
}
/// Why a file could not be decoded.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error {
/// A valid file using something this decoder does not handle (image sequences, overlays…).
Unsupported(&'static str),
/// The image is larger than [`Options::max_pixels`] or holds an oversized box.
Limit(String),
/// Broken or truncated data (or a decoder bug, reported the same way).
Malformed(String),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::Unsupported(m) => write!(f, "unsupported HEIF: {m}"),
Error::Limit(m) => write!(f, "limit exceeded: {m}"),
Error::Malformed(m) => write!(f, "malformed HEIF: {m}"),
}
}
}
impl std::error::Error for Error {}
const SEQUENCE: &str = "this file holds an image sequence; only HEIF still images can be opened";
/// heic-rs 0.1.1 reconstructs 4:2:0 and monochrome pictures exactly but fails on the 4:2:2 and
/// 4:4:4 ones some cameras write (Canon and Sony "HIF"); those failures are reported as this.
const CHROMA_422_444: &str = "4:2:2 and 4:4:4 HEIF images (as some Canon and Sony cameras write) can't be decoded yet";
pub(crate) fn err(e: heic_rs::Error) -> Error {
match e {
heic_rs::Error::Unsupported(what) => Error::Unsupported(what),
// The primary item is neither an HEVC picture nor a grid of them.
heic_rs::Error::MissingBox("hvcC") => Error::Unsupported("the image is an overlay, an identity derivation or not HEVC-coded"),
heic_rs::Error::PixelLimit { .. } | heic_rs::Error::BoxTooLarge { .. } => Error::Limit(e.to_string()),
e => Error::Malformed(e.to_string()),
}
}
/// Runs `f`, turning a heic-rs panic into an error. Fuzzing in the sibling app found two
/// out-of-range slices in heic-rs 0.1.1 on malformed files: in its box parser (`boxes.rs:130`)
/// and during reconstruction (`hevc/decode/recon.rs:70`).
fn guarded<T>(f: impl FnOnce() -> Result<T, Error>) -> Result<T, Error> {
std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)).unwrap_or_else(|_| Err(Error::Malformed("the HEIF decoder failed on this file".into())))
}
/// Reads the container's declared size, depth and alpha without decoding pixels, so callers can
/// check their limits first. Also refuses a file cut short: every coded picture of the primary
/// image must lie within `bytes`.
pub fn probe(bytes: &[u8]) -> Result<Info, Error> {
guarded(|| probe_unguarded(bytes))
}
fn probe_unguarded(bytes: &[u8]) -> Result<Info, Error> {
census::cap(bytes)?;
// No `meta` box: no still image, only a `moov` image sequence (a video track).
let open_error = |e| match e {
heic_rs::Error::MissingBox("meta") => Error::Unsupported(SEQUENCE),
e => err(e),
};
let ctx = Context::open(bytes).map_err(open_error)?;
let id = ctx.meta.primary;
// heic-rs 0.1.4 caps the size of what it assembles, not the work: an item built from other
// items (`iloc` construction method 2) is rebuilt once per extent, so a chain of such items
// multiplies at every level while each result stays small. Count those visits from the
// `iloc` table before reconstructing anything: the primary item first (`heic_rs::probe` and
// `Context::grid` both rebuild its descriptor), then its alpha plane and, when that is a grid,
// its tiles, then every tile reference, repeats included.
let mut visits = 0_usize;
item_visits(&ctx, id, 0, &mut visits)?;
// `heic_rs::probe` reads an item without `ispe` from its parameter sets
check_item_parameter_sets(&ctx.props(id).map_err(err)?)?;
let info = heic_rs::probe(bytes).map_err(open_error)?;
let alpha = ctx.alpha_item(id).map_err(err)?;
if let Some(alpha) = alpha {
item_visits(&ctx, alpha, 0, &mut visits)?;
// an alpha plane may be a grid too: its tiles are rebuilt when it is decoded
if let Some((_, tiles)) = ctx.grid(alpha).map_err(err)? {
for &tile in tiles.iter().filter(|&&tile| tile != alpha) {
item_visits(&ctx, tile, 0, &mut visits)?;
}
}
}
let mut coded = match ctx.grid(id).map_err(err)? {
Some((_, tiles)) => tiles,
None => vec![id],
};
for &item in coded.iter().filter(|&&item| item != id) {
item_visits(&ctx, item, 0, &mut visits)?;
}
// A `dimg` listing may name the same tile more than once, and reconstructable items are
// moreover rebuilt for every extent that references them in heic-rs 0.1.4. For the size
// check each unique item counts once: the total reconstruction (all of it assembled from
// `bytes` by heic-rs) is held below one copy of the file, above which a repeat or chain
// wants more bytes than exist. Order doesn't matter here: this only checks that every
// tile's bytes lie in the file.
coded.sort_unstable();
coded.dedup();
let mut reconstructed = 0_usize;
for item in coded {
reconstructed = reconstructed.saturating_add(ctx.item_data(item).map_err(err)?.len());
if reconstructed > bytes.len() {
return Err(Error::Limit(format!(
"the container holds {reconstructed} bytes of item data, over the {} bytes of the file itself",
bytes.len()
)));
}
}
Ok(Info {
width: info.width,
height: info.height,
coded_width: info.coded_width,
coded_height: info.coded_height,
has_alpha: info.has_alpha,
bit_depth: info.bit_depth,
})
}
/// Most extent visits heic-rs may spend reconstructing the primary image's coded items; real
/// files need one per tile (plus a few for the rare derived item).
const MAX_ITEM_VISITS: usize = 4096;
/// Deepest chain of items built from items we follow (heic-rs refuses beyond eight itself).
const MAX_ITEM_CHAIN: u32 = 8;
/// Adds to `visits` the extents heic-rs would read to reconstruct `id`, following items built
/// from other items, and fails once that passes [`MAX_ITEM_VISITS`] or the chain is too deep.
fn item_visits(ctx: &Context<'_>, id: u32, depth: u32, visits: &mut usize) -> Result<(), Error> {
use heic_rs::meta::iloc::Construction;
if depth > MAX_ITEM_CHAIN {
return Err(Error::Limit(format!("items built from items nest deeper than {MAX_ITEM_CHAIN} levels")));
}
let Some(loc) = ctx.meta.location(id) else { return Ok(()) };
*visits = visits.saturating_add(loc.extents.len().max(1));
if *visits > MAX_ITEM_VISITS {
return Err(Error::Limit(format!("reconstructing the image takes over {MAX_ITEM_VISITS} item extent reads")));
}
if loc.construction == Construction::Item {
for e in &loc.extents {
if let Ok(source) = u32::try_from(e.index)
&& source != id
{
item_visits(ctx, source, depth + 1, visits)?;
}
}
}
Ok(())
}
/// Decodes the primary image, with its metadata.
pub fn decode(bytes: &[u8], options: &Options) -> Result<Decoded, Error> {
guarded(|| decode_unguarded(bytes, options))
}
/// Decodes the smallest thumbnail image the file carries whose long edge is at least
/// `min_edge`, if any (iPhones store one of about 320 × 240). Transforms are applied as for the
/// primary image; the metadata (and, when the thumbnail has no profile of its own, the ICC
/// profile) are the primary image's.
pub fn decode_thumbnail(bytes: &[u8], min_edge: u32, options: &Options) -> Result<Option<Decoded>, Error> {
guarded(|| {
let ctx = Context::open(bytes).map_err(err)?;
let primary = ctx.meta.primary;
let mut best: Option<(u32, u32)> = None;
// A thumbnail whose own reconstruction would cost too much is not a candidate; the visits
// of all the candidates share one budget.
let mut candidate_visits = 0_usize;
for r in ctx.meta.refs.iter().filter(|r| r.kind == heic_rs::meta::iref::RefKind::Thmb && r.to.contains(&primary)) {
if item_visits(&ctx, r.from, 0, &mut candidate_visits).is_err() {
continue;
}
let Ok(p) = ctx.props(r.from) else { continue };
if check_item_parameter_sets(&p).is_err() {
continue;
}
// A grid whose tile would fail the same check must not win and then fail in
// `decode_item`, with no fallback to a larger valid thumbnail.
let grid = match ctx.grid(r.from) {
Ok(grid) => grid,
// an unreadable grid fails in `decode_item` too: not a candidate
Err(_) => continue,
};
if let Some((_, tiles)) = grid {
let mut seen = std::collections::HashSet::new();
let tiles_ok = tiles.iter().filter(|t| seen.insert(**t)).all(|&t| {
item_visits(&ctx, t, 0, &mut candidate_visits).is_ok() && ctx.props(t).is_ok_and(|tp| check_item_parameter_sets(&tp).is_ok())
});
if !tiles_ok {
continue;
}
}
let Ok((w, h)) = ctx.coded_size(r.from, &p) else { continue };
let edge = w.max(h);
if edge >= min_edge && best.is_none_or(|(_, e)| edge < e) {
best = Some((r.from, edge));
}
}
let Some((id, _)) = best else { return Ok(None) };
// The same pre-scan as `probe`: the thumbnail's own descriptor and every tile reference
// are counted before heic-rs rebuilds any of them.
let mut visits = 0_usize;
item_visits(&ctx, id, 0, &mut visits)?;
if let Some((_, tiles)) = ctx.grid(id).map_err(err)? {
for &tile in &tiles {
item_visits(&ctx, tile, 0, &mut visits)?;
}
}
let mut decoded = decode_item(&ctx, id, options, false)?;
if decoded.icc.is_none() {
decoded.icc = item_icc(&ctx, primary);
}
(decoded.exif, decoded.xmp) = metadata(&ctx);
Ok(Some(decoded))
})
}
/// An item's ICC profile; a grid whose own properties carry none takes its first tile's (as on
/// some iPhones).
fn item_icc(ctx: &Context<'_>, id: u32) -> Option<Vec<u8>> {
let p = ctx.props(id).ok()?;
let icc = p.icc.or_else(|| {
let (_, tiles) = ctx.grid(id).ok()??;
ctx.props(*tiles.first()?).ok()?.icc
});
icc.map(<[u8]>::to_vec)
}
fn decode_unguarded(bytes: &[u8], options: &Options) -> Result<Decoded, Error> {
// Refuses sequences with a clear message before anything else is read.
probe_unguarded(bytes)?;
let ctx = Context::open(bytes).map_err(err)?;
let mut decoded = decode_item(&ctx, ctx.meta.primary, options, true)?;
let (exif, xmp) = metadata(&ctx);
decoded.exif = exif;
decoded.xmp = xmp;
Ok(decoded)
}
/// Decodes one image item (a coded picture or a grid of them) to RGB(A), alpha included when
/// `with_alpha` and the item has an alpha auxiliary image.
fn decode_item(ctx: &Context<'_>, id: u32, options: &Options, with_alpha: bool) -> Result<Decoded, Error> {
let p = ctx.props(id).map_err(err)?;
// heic-rs 0.1.4 keeps every associated transform and its [`orient::apply`] allocates the
// full picture again for each: a file could chain the repetition and multiply decode CPU
// without changing any checked size. Real files carry at most one `clap`, `irot` and
// `imir`, so refuse anything approaching [`MAX_TRANSFORMS`] (CodeRabbit #44).
if p.transforms.len() > MAX_TRANSFORMS {
return Err(Error::Limit(format!("the image carries {} transform properties, over the {MAX_TRANSFORMS}-property cap", p.transforms.len())));
}
let limit = options.max_pixels;
// The declared sizes are refused before anything is decoded or allocated (an item without
// `ispe` takes its size from its parameter sets, checked first).
check_item_parameter_sets(&p)?;
let (cw, ch) = ctx.coded_size(id, &p).map_err(err)?;
heic_rs::image::check_pixels(cw, ch, limit).map_err(err)?;
let (tw, th) = heic_rs::transform::transformed_size(cw, ch, &p.transforms).map_err(err)?;
heic_rs::image::check_pixels(tw, th, limit).map_err(err)?;
let coded = Coded::decode(ctx, id, &p, limit)?;
let planes = coded.planes()?;
let colour = colour(&p, &coded.first_props);
let signal = ycc::Signal { matrix: colour.matrix, full_range: colour.full_range };
let alpha_id = if with_alpha { ctx.alpha_item(id).map_err(err)? } else { None };
let (w, h) = planes.size();
// A grid's canvas dimensions come from its payload, not the checked `ispe` (CodeRabbit
// #48): check the real one, before [`ycc::to_rgb16`] allocates for it.
match (u32::try_from(w), u32::try_from(h)) {
(Ok(wu), Ok(hu)) => {
heic_rs::image::check_pixels(wu, hu, limit).map_err(err)?;
}
_ => return Err(Error::Limit(format!("the image canvas is {w}x{h}, beyond the {limit}-pixel limit"))),
}
let mode = if options.apply_transforms && orient::odd_crop(w, h, &p.transforms)? { ycc::Upsampling::Bilinear } else { ycc::Upsampling::Nearest };
let mut data = ycc::to_rgb16(&planes, signal, alpha_id.is_some(), mode)
.ok_or_else(|| Error::Malformed("the decoded pictures don't cover the image".into()))?;
if let Some(aux) = alpha_id {
let ap = ctx.props(aux).map_err(err)?;
let alpha = Coded::decode(ctx, aux, &ap, limit)?;
let alpha_planes = alpha.planes()?;
if alpha_planes.size() != (w, h) {
return Err(Error::Unsupported("an alpha image of a different size than the picture"));
}
ycc::put_alpha(&alpha_planes, &mut data).ok_or_else(|| Error::Malformed("the alpha image is incomplete".into()))?;
}
let bit_depth = planes.bit_depth();
let has_alpha = alpha_id.is_some();
let mut img = orient::Pixels { width: w, height: h, ch: if has_alpha { 4 } else { 3 }, data };
if options.apply_transforms {
img = orient::apply(img, &p.transforms)?;
}
Ok(Decoded {
width: u32::try_from(img.width).map_err(|_| Error::Limit("image too wide".into()))?,
height: u32::try_from(img.height).map_err(|_| Error::Limit("image too tall".into()))?,
has_alpha,
bit_depth,
data: img.data,
colour,
// A grid whose own properties carry no profile takes its tiles' (as on some iPhones).
icc: p.icc.or(coded.first_props.icc).map(<[u8]>::to_vec),
exif: None,
xmp: None,
})
}
/// How many times `max_pixels` the coded pictures of one item may hold together: a grid's tiles
/// cover its canvas rounded up to whole tiles, so legitimate grids sit near 1.
const GRID_BUDGET: u64 = 2;
/// The most transform properties (`clap`/`irot`/`imir`) one item may carry. Real files have at
/// most one of each, so anything approaching this is a reordered or hostile association list.
const MAX_TRANSFORMS: usize = 12;
/// The most parameter sets one `hvcC` may carry: one per id H.265 allows (16 VPS, 16 SPS, 64 PPS).
/// heic-rs 0.1.4 replaces a repeated id by scanning every set kept so far, so more sets (repeats,
/// or ids past the standard's range) only make that collection quadratic.
const MAX_PARAMETER_SETS: usize = 16 + 16 + 64;
/// Highest `pps_pic_parameter_set_id` H.265 allows (7.4.3.3.1).
const MAX_PPS_ID: u32 = 63;
/// Most tile columns and rows a picture may have: H.265's level limits (Table A.8, levels 6 to
/// 6.2). heic-rs 0.1.4 builds its tile tables by walking the tile boundaries for every coding tree
/// block, so its work grows with blocks × tiles; these keep that a small multiple of the blocks.
const MAX_TILE_COLS: u32 = 20;
const MAX_TILE_ROWS: u32 = 22;
/// Refuses parameter sets that would make heic-rs's set collection or tile tables cost far more
/// than the picture: too many sets, a PPS id out of range, or more tiles than any level allows.
fn check_parameter_sets(sets: &[&[u8]]) -> Result<(), Error> {
if sets.len() > MAX_PARAMETER_SETS {
return Err(Error::Limit(format!("the hvcC record carries {} parameter sets, over the {MAX_PARAMETER_SETS}-set cap", sets.len())));
}
let layouts = vui::pps_layouts(sets).ok_or_else(|| Error::Malformed("unreadable picture parameter set".into()))?;
for p in layouts {
if p.id > MAX_PPS_ID {
return Err(Error::Malformed(format!("picture parameter set id {} is out of range", p.id)));
}
if p.tile_cols > MAX_TILE_COLS || p.tile_rows > MAX_TILE_ROWS {
return Err(Error::Limit(format!(
"a picture of {} × {} tiles, over the {MAX_TILE_COLS} × {MAX_TILE_ROWS} H.265 allows",
p.tile_cols, p.tile_rows
)));
}
}
Ok(())
}
/// [`check_parameter_sets`] of a coded item's `hvcC`, if it has one.
fn check_item_parameter_sets(p: &ItemProps<'_>) -> Result<(), Error> {
p.hvcc.as_ref().map_or(Ok(()), |h| check_parameter_sets(&h.parameter_sets()))
}
/// The decoded pictures of an item: one, or a grid's tiles in `dimg` order.
struct Coded<'a> {
frames: Vec<Frame>,
grid: Option<heic_rs::grid::Grid>,
/// The properties of the first coded picture (the item itself, or the first tile): where the
/// HEVC configuration and its VUI live.
first_props: ItemProps<'a>,
/// A failed 4:2:2 / 4:4:4 picture, for the error message.
chroma_format: u8,
}
impl<'a> Coded<'a> {
fn decode(ctx: &Context<'a>, id: u32, p: &ItemProps<'a>, limit: u64) -> Result<Coded<'a>, Error> {
let (grid, ids) = match ctx.grid(id).map_err(err)? {
Some((g, tiles)) => (Some(g), tiles),
None => (None, vec![id]),
};
let first = *ids.first().ok_or_else(|| Error::Malformed("grid lists no tiles".into()))?;
let first_props = if first == id { p.clone() } else { ctx.props(first).map_err(err)? };
let chroma_format = first_props.hvcc.as_ref().map_or(1, |c| c.chroma_format);
// #1518: the decoder allocates each picture at its SPS's uncropped size, which a
// conformance window (or a slice picking another SPS) can make far larger than the
// declared one, and a grid holds all its tiles at once. Both are refused before decoding.
let mut total = 0u64;
// A grid may list one tile thousands of times: each distinct tile is read and checked
// once, so the work follows the file's items, not the grid's cell count.
let mut largest_of: std::collections::HashMap<u32, u64> = std::collections::HashMap::new();
for t in &ids {
if let Some(largest) = largest_of.get(t) {
total = total.saturating_add(*largest);
continue;
}
let tp = ctx.props(*t).map_err(err)?;
let hvcc = tp.hvcc.as_ref().ok_or(heic_rs::Error::MissingBox("hvcC")).map_err(err)?;
check_parameter_sets(&hvcc.parameter_sets())?;
let sizes = vui::coded_sizes(&hvcc.parameter_sets()).ok_or_else(|| Error::Malformed("unreadable sequence parameter set".into()))?;
let mut largest = 0u64;
for (w, h) in sizes {
heic_rs::image::check_pixels(w, h, limit).map_err(err)?;
largest = largest.max(u64::from(w) * u64::from(h));
}
largest_of.insert(*t, largest);
total = total.saturating_add(largest);
}
if total > limit.saturating_mul(GRID_BUDGET) {
return Err(Error::Limit(format!("the coded pictures hold {total} pixels, over the {limit}-pixel limit")));
}
let decode_one = |t: &u32| -> Result<Frame, Error> {
let tp = ctx.props(*t).map_err(err)?;
let hvcc = tp.hvcc.as_ref().ok_or(heic_rs::Error::MissingBox("hvcC")).map_err(err)?;
let data = ctx.item_data(*t).map_err(err)?;
let nals = hvcc.split_nals(&data).map_err(err)?;
let params = hvcc.parameter_sets();
if params.is_empty() {
return Err(Error::Malformed("hvcC carries no parameter sets".into()));
}
let frame = heic_rs::hevc::decode_still(&params, &nals).map_err(err)?;
frame.validate().map_err(err)?;
heic_rs::image::check_pixels(frame.width, frame.height, limit).map_err(err)?;
Ok(frame)
};
#[cfg(not(target_arch = "wasm32"))]
let frames: Result<Vec<Frame>, Error> = {
use rayon::prelude::*;
ids.par_iter().map(decode_one).collect()
};
#[cfg(target_arch = "wasm32")]
let frames: Result<Vec<Frame>, Error> = ids.iter().map(decode_one).collect();
let frames = frames.map_err(|e| match e {
Error::Malformed(_) if chroma_format >= 2 => Error::Unsupported(CHROMA_422_444),
e => e,
})?;
Ok(Coded { frames, grid, first_props, chroma_format })
}
fn planes(&self) -> Result<ycc::Planes<'_>, Error> {
match (&self.grid, self.frames.as_slice()) {
(Some(g), tiles) => heic_rs::grid::Mosaic::new(g, tiles).map(ycc::Planes::Grid).map_err(err),
(None, [frame]) => Ok(ycc::Planes::Picture(frame)),
(None, _) => Err(Error::Malformed(format!("expected one coded picture (chroma format {})", self.chroma_format))),
}
}
}
/// The colour description in force: `nclx` on the item (or, for a grid without one, on its
/// first tile), else the VUI of its (first) coded picture, else the H.265 defaults.
fn colour(p: &ItemProps<'_>, coded: &ItemProps<'_>) -> Colour {
if let Some(n) = p.nclx.or(coded.nclx) {
return Colour { primaries: n.primaries, transfer: n.transfer, matrix: n.matrix_code, full_range: n.range == Range::Full };
}
let s = coded.hvcc.as_ref().and_then(|c| vui::signal(&c.parameter_sets())).unwrap_or_default();
Colour { primaries: s.primaries.into(), transfer: s.transfer.into(), matrix: s.matrix.into(), full_range: s.full_range }
}
/// The primary image's EXIF (TIFF structure) and XMP packet. Metadata is a courtesy: a broken
/// metadata item never fails a decode whose pixels came out fine.
fn metadata(ctx: &Context<'_>) -> (Option<Vec<u8>>, Option<String>) {
let id = ctx.meta.primary;
// Metadata is best effort, so an item that would cost too much to rebuild is skipped, not an error.
let mut visits = 0_usize;
let cheap = |item: Option<u32>, visits: &mut usize| item.is_none_or(|item| item_visits(ctx, item, 0, visits).is_ok());
let exif = if cheap(ctx.exif_item(id), &mut visits) { ctx.exif(id).ok().flatten().map(<[u8]>::to_vec) } else { None };
let xmp_item = ctx.xmp_item(id).filter(|&x| cheap(Some(x), &mut visits));
let xmp = xmp_item.and_then(|x| ctx.item_data(x).ok()).and_then(|d| match d {
Cow::Borrowed(b) => String::from_utf8(b.to_vec()).ok(),
Cow::Owned(b) => String::from_utf8(b).ok(),
});
(exif, xmp.map(|x| x.trim_end_matches('\0').to_string()))
}
#[cfg(test)]
mod tests_synthetic;
#[cfg(test)]
mod tests {
use super::*;
/// Found by PhotoCraft's `decode_heif` fuzz target: a malformed box makes heic-rs 0.1.1 slice
/// out of range (`boxes.rs:130`). It must be an error, not a crash.
const HEIC_RS_BOX_PANIC: [u8; 72] = [
0x00, 0x00, 0x00, 0x24, 0x66, 0x74, 0x79, 0x70, 0x68, 0x65, 0x69, 0x63, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x69, 0x66, 0x31, 0x4d, 0x69, 0x50,
0x72, 0x6d, 0x69, 0x61, 0x66, 0x4d, 0x69, 0x48, 0x42, 0x72, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x65, 0x74, 0x61, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x75, 0x75, 0x69, 0x64, 0x00, 0x00, 0x00, 0x00, 0x03, 0x08, 0x08, 0x08, 0x00, 0x03, 0x01, 0x03, 0x70,
0x00, 0xa8, 0x00,
];
#[test]
fn a_heic_rs_panic_is_a_malformed_error() {
for apply_transforms in [true, false] {
let r = decode(&HEIC_RS_BOX_PANIC, &Options { apply_transforms, ..Default::default() });
assert!(matches!(r, Err(Error::Malformed(_))), "{r:?}");
}
}
#[test]
fn image_sequence_is_unsupported_with_a_clear_message() {
// An ftyp and nothing else: a HEIF image sequence would have a moov here instead of a meta.
let bytes = b"\0\0\0\x18ftypmsf1\0\0\0\0msf1hevc";
for r in [probe(bytes).map(|_| ()), decode(bytes, &Options::default()).map(|_| ())] {
assert!(matches!(&r, Err(Error::Unsupported(m)) if m.contains("sequence")), "{r:?}");
}
}
#[test]
fn garbage_is_an_error() {
for bytes in [&b""[..], b"\0\0\0\x18ftypheic\0\0\0\0mif1heic", &[0xFF; 64]] {
assert!(probe(bytes).is_err());
assert!(decode(bytes, &Options::default()).is_err());
assert!(decode_thumbnail(bytes, 1, &Options::default()).is_err());
}
}
#[test]
fn errors_display_their_kind() {
assert!(Error::Unsupported("x").to_string().contains("unsupported"));
assert!(Error::Limit("x".into()).to_string().contains("limit"));
assert!(Error::Malformed("x".into()).to_string().contains("malformed"));
}
}
-178
View File
@@ -1,178 +0,0 @@
//! The container's transformative properties (`clap` crop, `irot` rotation, `imir` mirror),
//! applied to interleaved 16-bit pixels in the order the file associates them.
//!
//! `imir` follows libheif, which writes and reads `axis = 0` as a flip about the horizontal axis
//! (top and bottom exchanged) and `axis = 1` as a left-right flip. heic-rs 0.1.1 names the coded
//! values the other way round (`Mirror::LeftRight` is `axis = 0`), so they are swapped here.
use heic_rs::props::Transform;
use heic_rs::props::simple::{Clap, Mirror, Rotation};
use crate::Error;
/// Interleaved samples, `ch` per pixel, row-major.
pub struct Pixels {
pub width: usize,
pub height: usize,
pub ch: usize,
pub data: Vec<u16>,
}
impl Pixels {
fn remap(&self, width: usize, height: usize, src: impl Fn(usize, usize) -> (usize, usize)) -> Pixels {
let ch = self.ch;
let mut data = vec![0u16; width * height * ch];
for (y, row) in data.chunks_exact_mut(width * ch).enumerate() {
for (x, px) in row.chunks_exact_mut(ch).enumerate() {
let (sx, sy) = src(x, y);
let i = (sy * self.width + sx) * ch;
if let Some(s) = self.data.get(i..i + ch) {
px.copy_from_slice(s);
}
}
}
Pixels { width, height, ch, data }
}
}
/// The rectangle `(left, top, width, height)` a `clap` selects from a `w` × `h` image. Its centre
/// is `((w - 1) / 2 + horizOff, (h - 1) / 2 + vertOff)`; a corner that falls between two pixels
/// is rounded as libheif does: left down, top up.
pub fn crop_rect(w: usize, h: usize, c: Clap) -> Result<(usize, usize, usize, usize), Error> {
let bad = || Error::Malformed("clap selects an impossible rectangle".into());
let size = |(n, d): (u32, u32)| (d != 0).then(|| n / d).ok_or_else(bad);
let (cw, ch) = (size(c.width)? as usize, size(c.height)? as usize);
if cw == 0 || ch == 0 || cw > w || ch > h {
return Err(bad());
}
// Twice the corner, so the half pixels of odd sizes stay exact.
let twice = |full: usize, cropped: usize, (n, d): (i32, u32)| -> Result<i64, Error> {
if d == 0 {
return Err(bad());
}
Ok((full - cropped) as i64 + (2 * i64::from(n)).div_euclid(i64::from(d)))
};
let left = twice(w, cw, c.horiz_off)?.div_euclid(2);
let top = (twice(h, ch, c.vert_off)? + 1).div_euclid(2);
let left = usize::try_from(left).map_err(|_| bad())?;
let top = usize::try_from(top).map_err(|_| bad())?;
if left + cw > w || top + ch > h {
return Err(bad());
}
Ok((left, top, cw, ch))
}
/// Whether a `clap` among `transforms` (applied to a `w` × `h` image) starts at an odd column
/// or row. libheif crops such images after upsampling their chroma bilinearly instead of with
/// its default nearest neighbour; [`crate::ycc`] follows it so the pixels match.
pub fn odd_crop(mut w: usize, mut h: usize, transforms: &[Transform]) -> Result<bool, Error> {
for t in transforms {
match *t {
Transform::Crop(c) => {
let (left, top, cw, ch) = crop_rect(w, h, c)?;
if left % 2 == 1 || top % 2 == 1 {
return Ok(true);
}
(w, h) = (cw, ch);
}
Transform::Rotate(Rotation::Ccw90 | Rotation::Ccw270) => (w, h) = (h, w),
_ => {}
}
}
Ok(false)
}
pub fn apply(mut img: Pixels, transforms: &[Transform]) -> Result<Pixels, Error> {
for t in transforms {
let (w, h) = (img.width, img.height);
img = match *t {
Transform::Crop(c) => {
let (left, top, cw, ch) = crop_rect(w, h, c)?;
img.remap(cw, ch, |x, y| (x + left, y + top))
}
// Counter-clockwise: the right column becomes the top row.
Transform::Rotate(Rotation::Ccw90) => img.remap(h, w, |x, y| (w - 1 - y, x)),
Transform::Rotate(Rotation::Ccw180) => img.remap(w, h, |x, y| (w - 1 - x, h - 1 - y)),
Transform::Rotate(Rotation::Ccw270) => img.remap(h, w, |x, y| (y, h - 1 - x)),
Transform::Rotate(Rotation::None) => img,
// `axis = 0` (heic-rs's `LeftRight`): top and bottom exchanged, as libheif reads it.
Transform::Mirror(Mirror::LeftRight) => img.remap(w, h, |x, y| (x, h - 1 - y)),
// `axis = 1`: left and right exchanged.
Transform::Mirror(Mirror::TopBottom) => img.remap(w, h, |x, y| (w - 1 - x, y)),
};
}
Ok(img)
}
#[cfg(test)]
mod tests {
use super::*;
/// 3×2, one channel: 1 2 3 / 4 5 6.
fn img() -> Pixels {
Pixels { width: 3, height: 2, ch: 1, data: vec![1, 2, 3, 4, 5, 6] }
}
fn run(t: Transform) -> (usize, usize, Vec<u16>) {
let p = apply(img(), &[t]).unwrap();
(p.width, p.height, p.data)
}
#[test]
fn rotations_are_counter_clockwise() {
assert_eq!(run(Transform::Rotate(Rotation::Ccw90)), (2, 3, vec![3, 6, 2, 5, 1, 4]));
assert_eq!(run(Transform::Rotate(Rotation::Ccw180)), (3, 2, vec![6, 5, 4, 3, 2, 1]));
assert_eq!(run(Transform::Rotate(Rotation::Ccw270)), (2, 3, vec![4, 1, 5, 2, 6, 3]));
assert_eq!(run(Transform::Rotate(Rotation::None)), (3, 2, vec![1, 2, 3, 4, 5, 6]));
}
#[test]
fn mirrors_follow_libheif() {
// axis 0 (heic-rs `LeftRight`) exchanges top and bottom; axis 1 left and right.
assert_eq!(run(Transform::Mirror(Mirror::LeftRight)), (3, 2, vec![4, 5, 6, 1, 2, 3]));
assert_eq!(run(Transform::Mirror(Mirror::TopBottom)), (3, 2, vec![3, 2, 1, 6, 5, 4]));
}
fn clap(w: u32, h: u32, ho: i32, vo: i32) -> Clap {
Clap { width: (w, 1), height: (h, 1), horiz_off: (ho, 1), vert_off: (vo, 1) }
}
#[test]
fn clap_corners_round_like_libheif() {
// Measured against libheif 1.23 on a 512 × 512 picture.
assert_eq!(crop_rect(512, 512, clap(301, 201, 0, 0)).unwrap(), (105, 156, 301, 201));
assert_eq!(crop_rect(512, 512, clap(300, 200, 0, 0)).unwrap(), (106, 156, 300, 200));
assert_eq!(crop_rect(512, 512, clap(301, 201, 37, -21)).unwrap(), (142, 135, 301, 201));
assert_eq!(crop_rect(512, 512, clap(301, 201, -3, 5)).unwrap(), (102, 161, 301, 201));
assert_eq!(crop_rect(512, 512, clap(300, 201, 0, 0)).unwrap(), (106, 156, 300, 201));
assert_eq!(crop_rect(1500, 1000, clap(1001, 701, 37, -21)).unwrap(), (286, 129, 1001, 701));
let p = apply(img(), &[Transform::Crop(clap(2, 1, 1, 0))]).unwrap();
// The half-pixel top rounds down a row.
assert_eq!((p.width, p.height, p.data), (2, 1, vec![5, 6]));
}
#[test]
fn impossible_claps_are_errors() {
for c in [
clap(0, 1, 0, 0),
clap(4, 1, 0, 0),
clap(3, 2, 1, 0),
clap(3, 2, 0, -1),
Clap { width: (1, 0), ..clap(1, 1, 0, 0) },
Clap { horiz_off: (0, 0), ..clap(1, 1, 0, 0) },
] {
assert!(crop_rect(3, 2, c).is_err(), "{c:?}");
}
assert!(apply(img(), &[Transform::Crop(clap(9, 9, 0, 0))]).is_err());
}
#[test]
fn odd_crops_are_detected_through_rotations() {
assert!(!odd_crop(512, 512, &[Transform::Crop(clap(300, 200, 0, 0))]).unwrap());
assert!(odd_crop(512, 512, &[Transform::Crop(clap(301, 200, 0, 0))]).unwrap());
// After a quarter turn the crop applies to a 200 × 300 image.
let t = [Transform::Crop(clap(300, 200, 0, 0)), Transform::Rotate(Rotation::Ccw90), Transform::Crop(clap(197, 300, 0, 0))];
assert!(odd_crop(512, 512, &t).unwrap());
assert!(!odd_crop(512, 512, &[Transform::Rotate(Rotation::Ccw90)]).unwrap());
}
}
-569
View File
@@ -1,569 +0,0 @@
//! Synthetic HEIF files for tests (feature `testdata`): lossless, so every decoded sample is known.
//!
//! Each coded picture is one 32 × 32 coding tree unit stored as PCM samples (H.265 7.3.8.7):
//! the bitstream carries the YCbCr values verbatim, so the decoder's HEVC stage reproduces them
//! exactly and a test checks everything after it (grid composition, colour, transforms,
//! metadata) against values it chose. The few CABAC bins around the PCM data are written with a
//! minimal arithmetic encoder (9.3.4.4). Larger images are grids of such pictures, which is how
//! iPhones store photos too (with 512 × 512 tiles).
//!
//! Not a general HEIF or HEVC writer: 4:2:0 or monochrome, 8 or 10 bits, a CTU per picture.
/// Side of every coded picture.
pub const TILE: u32 = 32;
/// YCbCr samples at a luma position (chroma is taken at even positions, 4:2:0).
pub type Sampler<'a> = &'a dyn Fn(u32, u32) -> [u16; 3];
/// A property of the primary image.
#[derive(Debug, Clone, PartialEq)]
pub enum Prop {
/// `colr` of type `prof`.
Icc(Vec<u8>),
/// `colr` of type `nclx`: primaries, transfer, matrix, full range.
Nclx(u16, u16, u16, bool),
/// `irot`: quarter turns counter-clockwise.
Irot(u8),
/// `imir` with this axis.
Imir(u8),
/// `clap`: width, height, horizontal and vertical offset (whole pixels).
Clap(u32, u32, i32, i32),
}
/// What [`build`] writes.
pub struct Spec<'a> {
/// Displayed (grid output) size, before transforms.
pub width: u32,
pub height: u32,
pub bit_depth: u8,
pub sample: Sampler<'a>,
/// Properties of the primary image, in association order.
pub props: Vec<Prop>,
/// EXIF as a TIFF structure (written with HEIF's 4-byte offset header).
pub exif: Option<Vec<u8>>,
/// An alpha auxiliary image (monochrome, full range).
pub alpha: Option<&'a dyn Fn(u32, u32) -> u16>,
/// A thumbnail item of half the size with these samples (in its own coordinates).
pub thumbnail: Option<Sampler<'a>>,
/// Auxiliary images of these types the decoder must ignore (HDR gain map, depth…).
pub ignored_aux: Vec<&'static str>,
/// When nonzero, the alpha image is instead a grid of `n` × `n` references to one alpha tile
/// (a hostile file: the same stored picture rebuilt for every reference).
pub alpha_tile_repeats: u8,
}
impl<'a> Spec<'a> {
pub fn new(width: u32, height: u32, sample: Sampler<'a>) -> Spec<'a> {
Spec {
width,
height,
bit_depth: 8,
sample,
props: Vec::new(),
exif: None,
alpha: None,
thumbnail: None,
ignored_aux: Vec::new(),
alpha_tile_repeats: 0,
}
}
}
#[derive(Default)]
struct Bits {
bytes: Vec<u8>,
n: usize,
}
impl Bits {
fn put(&mut self, v: u32, len: u32) {
for i in (0..len).rev() {
if self.n.is_multiple_of(8) {
self.bytes.push(0);
}
if (v >> i) & 1 == 1
&& let Some(b) = self.bytes.last_mut()
{
*b |= 0x80 >> (self.n % 8);
}
self.n += 1;
}
}
fn ue(&mut self, v: u32) {
let x = u64::from(v) + 1;
let len = 64 - x.leading_zeros();
self.put(0, len - 1);
self.put((x & 0xffff_ffff) as u32, len);
}
fn align_zero(&mut self) {
while !self.n.is_multiple_of(8) {
self.put(0, 1);
}
}
fn trailing(&mut self) {
self.put(1, 1);
self.align_zero();
}
}
/// The CABAC arithmetic encoder of H.265 9.3.4.4, for the bins these pictures need.
struct Cabac {
low: u32,
range: u32,
first: bool,
outstanding: u32,
}
impl Cabac {
fn new() -> Cabac {
Cabac { low: 0, range: 510, first: true, outstanding: 0 }
}
fn put_bit(&mut self, out: &mut Bits, b: u32) {
if self.first {
self.first = false;
} else {
out.put(b, 1);
}
while self.outstanding > 0 {
out.put(1 - b, 1);
self.outstanding -= 1;
}
}
fn renorm(&mut self, out: &mut Bits) {
while self.range < 256 {
if self.low < 256 {
self.put_bit(out, 0);
} else if self.low >= 512 {
self.low -= 512;
self.put_bit(out, 1);
} else {
self.low -= 256;
self.outstanding += 1;
}
self.range <<= 1;
self.low <<= 1;
}
}
/// `part_mode` = PART_2Nx2N: the most probable symbol of a fresh context (initValue 184 at
/// QP 26 gives pStateIdx 0, valMps 1), so the LPS range is `rangeTabLps[0][3]` = 240.
fn part_mode_2nx2n(&mut self, out: &mut Bits) {
let lps = [128, 176, 208, 240][((self.range >> 6) & 3) as usize];
self.range -= lps;
self.renorm(out);
}
/// A terminating bin equal to 1 (`pcm_flag`, `end_of_slice_segment_flag`), with the flush.
fn terminate_one(&mut self, out: &mut Bits) {
self.range -= 2;
self.low += self.range;
self.range = 2;
self.renorm(out);
self.put_bit(out, (self.low >> 9) & 1);
out.put(((self.low >> 7) & 3) | 1, 2);
}
}
fn nal(kind: u8, rbsp: &[u8]) -> Vec<u8> {
let mut out = vec![kind << 1, 1];
let mut zeros = 0;
for &b in rbsp {
if zeros >= 2 && b <= 3 {
out.push(3);
zeros = 0;
}
zeros = if b == 0 { zeros + 1 } else { 0 };
out.push(b);
}
out
}
fn profile_idc(bit_depth: u8, mono: bool) -> u32 {
match (bit_depth, mono) {
(_, true) => 4, // range extensions
(8, false) => 1,
_ => 2,
}
}
fn ptl(w: &mut Bits, idc: u32) {
w.put(0, 2);
w.put(0, 1);
w.put(idc, 5);
w.put(1 << (31 - idc), 32); // compatible with itself
w.put(0b1001, 4); // progressive, frame only
w.put(0, 22);
w.put(0, 21);
w.put(0, 1);
w.put(93, 8); // level 3.1
}
fn parameter_sets(bit_depth: u8, mono: bool) -> [Vec<u8>; 3] {
let idc = profile_idc(bit_depth, mono);
let bd = u32::from(bit_depth);
let mut v = Bits::default();
v.put(0, 4);
v.put(3, 2);
v.put(0, 6);
v.put(0, 3);
v.put(1, 1);
v.put(0xffff, 16);
ptl(&mut v, idc);
v.put(0, 1); // vps_sub_layer_ordering_info_present_flag
v.ue(0);
v.ue(0);
v.ue(0);
v.put(0, 6); // vps_max_layer_id
v.ue(0); // vps_num_layer_sets_minus1
v.put(0, 1); // vps_timing_info_present_flag
v.put(0, 1); // vps_extension_flag
v.trailing();
let mut s = Bits::default();
s.put(0, 4);
s.put(0, 3);
s.put(1, 1);
ptl(&mut s, idc);
s.ue(0);
s.ue(if mono { 0 } else { 1 });
s.ue(TILE);
s.ue(TILE);
s.put(0, 1); // conformance_window_flag
s.ue(bd - 8);
s.ue(bd - 8);
s.ue(4);
s.put(1, 1);
s.ue(0);
s.ue(0);
s.ue(0);
s.ue(2); // log2_min_luma_coding_block_size_minus3: 32
s.ue(0); // log2_diff_max_min_luma_coding_block_size: CTB 32
s.ue(0); // log2_min_luma_transform_block_size_minus2: 4
s.ue(3); // log2_diff_max_min_luma_transform_block_size: 32
s.ue(0);
s.ue(0);
s.put(0, 1); // scaling_list_enabled_flag
s.put(0, 1); // amp_enabled_flag
s.put(0, 1); // sample_adaptive_offset_enabled_flag
s.put(1, 1); // pcm_enabled_flag
s.put(bd - 1, 4); // pcm_sample_bit_depth_luma_minus1
s.put(bd - 1, 4); // pcm_sample_bit_depth_chroma_minus1
s.ue(2); // log2_min_pcm_luma_coding_block_size_minus3: 32
s.ue(0); // log2_diff_max_min_pcm_luma_coding_block_size
s.put(1, 1); // pcm_loop_filter_disabled_flag
s.ue(0); // num_short_term_ref_pic_sets
s.put(0, 1); // long_term_ref_pics_present_flag
s.put(0, 1); // sps_temporal_mvp_enabled_flag
s.put(0, 1); // strong_intra_smoothing_enabled_flag
s.put(0, 1); // vui_parameters_present_flag
s.put(0, 1); // sps_extension_present_flag
s.trailing();
let mut p = Bits::default();
p.ue(0);
p.ue(0);
p.put(0, 6); // dependent slices, output flag, 3 extra header bits, sign hiding
p.put(0, 1); // cabac_init_present_flag
p.ue(0);
p.ue(0);
p.ue(0); // init_qp_minus26 (se(0) is the same bits)
p.put(0, 3); // constrained intra, transform skip, cu_qp_delta
p.ue(0);
p.ue(0);
p.put(0, 1);
p.put(0, 2);
p.put(0, 1); // transquant_bypass_enabled_flag
p.put(0, 1); // tiles_enabled_flag
p.put(0, 1); // entropy_coding_sync_enabled_flag
p.put(0, 1); // pps_loop_filter_across_slices_enabled_flag
p.put(1, 1); // deblocking_filter_control_present_flag
p.put(0, 1); // deblocking_filter_override_enabled_flag
p.put(1, 1); // pps_deblocking_filter_disabled_flag
p.put(0, 1);
p.put(0, 1);
p.ue(0);
p.put(0, 1);
p.put(0, 1);
p.trailing();
[nal(32, &v.bytes), nal(33, &s.bytes), nal(34, &p.bytes)]
}
/// One coded 32 × 32 picture: the `hvcC` payload and the item data (length-prefixed NAL).
struct Coded {
hvcc: Vec<u8>,
data: Vec<u8>,
}
fn picture(bit_depth: u8, mono: bool, sample: &dyn Fn(u32, u32) -> [u16; 3]) -> Coded {
let bd = u32::from(bit_depth);
let mut w = Bits::default();
w.put(1, 1); // first_slice_segment_in_pic_flag
w.put(0, 1); // no_output_of_prior_pics_flag
w.ue(0);
w.ue(2); // I slice
w.ue(0); // slice_qp_delta, se(0)
w.trailing(); // byte_alignment()
let mut c = Cabac::new();
c.part_mode_2nx2n(&mut w);
c.terminate_one(&mut w); // pcm_flag
w.align_zero(); // pcm_alignment_zero_bit
for y in 0..TILE {
for x in 0..TILE {
w.put(u32::from(sample(x, y)[0]), bd);
}
}
if !mono {
for k in 1..3 {
for y in 0..TILE / 2 {
for x in 0..TILE / 2 {
w.put(u32::from(sample(2 * x, 2 * y)[k]), bd);
}
}
}
}
let mut c = Cabac::new();
c.terminate_one(&mut w); // end_of_slice_segment_flag (its flush ends in the stop bit)
w.align_zero();
let slice = nal(19, &w.bytes);
let sets = parameter_sets(bit_depth, mono);
let mut h = vec![1u8, profile_idc(bit_depth, mono) as u8];
h.extend_from_slice(&(1u32 << (31 - profile_idc(bit_depth, mono))).to_be_bytes());
h.extend_from_slice(&[
0x90,
0,
0,
0,
0,
0,
93,
0xf0,
0,
0xfc,
0xfc | u8::from(!mono),
0xf8 | (bit_depth - 8),
0xf8 | (bit_depth - 8),
0,
0,
0x0f,
3,
]);
for (kind, set) in [32u8, 33, 34].into_iter().zip(&sets) {
h.push(0x80 | kind);
h.extend_from_slice(&1u16.to_be_bytes());
h.extend_from_slice(&(set.len() as u16).to_be_bytes());
h.extend_from_slice(set);
}
let mut data = (slice.len() as u32).to_be_bytes().to_vec();
data.extend_from_slice(&slice);
Coded { hvcc: h, data }
}
fn bx(kind: &[u8; 4], payload: &[u8]) -> Vec<u8> {
let mut v = ((payload.len() + 8) as u32).to_be_bytes().to_vec();
v.extend_from_slice(kind);
v.extend_from_slice(payload);
v
}
fn full_box(kind: &[u8; 4], version: u8, payload: &[u8]) -> Vec<u8> {
let mut p = vec![version, 0, 0, 0];
p.extend_from_slice(payload);
bx(kind, &p)
}
struct Item {
id: u16,
kind: &'static [u8; 4],
data: Vec<u8>,
/// Indices (1-based) into the property list, with the essential flag.
props: Vec<(u8, bool)>,
/// Not an image of its own (a grid tile).
hidden: bool,
}
#[derive(Default)]
struct File {
items: Vec<Item>,
props: Vec<Vec<u8>>,
refs: Vec<(&'static [u8; 4], u16, Vec<u16>)>,
}
impl File {
fn prop(&mut self, b: Vec<u8>) -> u8 {
self.props.push(b);
self.props.len() as u8
}
fn add(&mut self, kind: &'static [u8; 4], data: Vec<u8>, props: Vec<(u8, bool)>) -> u16 {
let id = self.items.len() as u16 + 1;
self.items.push(Item { id, kind, data, props, hidden: false });
id
}
/// A coded image of `w` × `h` (a grid when larger than a tile); returns its item id.
fn image(&mut self, w: u32, h: u32, bit_depth: u8, mono: bool, sample: &dyn Fn(u32, u32) -> [u16; 3]) -> u16 {
let (cols, rows) = (w.div_ceil(TILE), h.div_ceil(TILE));
let ispe = |w: u32, h: u32| {
let mut p = w.to_be_bytes().to_vec();
p.extend_from_slice(&h.to_be_bytes());
full_box(b"ispe", 0, &p)
};
let mut hvcc_prop = None;
let tile_ispe = self.prop(ispe(TILE, TILE));
let mut tiles = Vec::new();
for r in 0..rows {
for c in 0..cols {
let coded = picture(bit_depth, mono, &|x, y| sample((c * TILE + x).min(w - 1), (r * TILE + y).min(h - 1)));
let hv = *hvcc_prop.get_or_insert_with(|| self.prop(bx(b"hvcC", &coded.hvcc)));
tiles.push(self.add(b"hvc1", coded.data, vec![(hv, true), (tile_ispe, false)]));
}
}
if let ([only], true) = (tiles.as_slice(), w == TILE && h == TILE) {
return *only;
}
for it in self.items.iter_mut().filter(|i| tiles.contains(&i.id)) {
it.hidden = true;
}
let mut g = vec![0u8, 0, (rows - 1) as u8, (cols - 1) as u8];
g.extend_from_slice(&(w as u16).to_be_bytes());
g.extend_from_slice(&(h as u16).to_be_bytes());
let grid_ispe = self.prop(ispe(w, h));
let id = self.add(b"grid", g, vec![(grid_ispe, false)]);
self.refs.push((b"dimg", id, tiles));
id
}
fn write(self, primary: u16) -> Vec<u8> {
let ftyp = bx(b"ftyp", b"heic\0\0\0\0mif1heic");
let mut hdlr = vec![0u8; 4];
hdlr.extend_from_slice(b"pict");
hdlr.extend_from_slice(&[0; 13]);
let hdlr = full_box(b"hdlr", 0, &hdlr);
let pitm = full_box(b"pitm", 0, &primary.to_be_bytes());
let mut iinf = (self.items.len() as u16).to_be_bytes().to_vec();
for it in &self.items {
let mut e = vec![2, 0, 0, u8::from(it.hidden)]; // version 2, flags
e.extend_from_slice(&it.id.to_be_bytes());
e.extend_from_slice(&[0, 0]);
e.extend_from_slice(it.kind);
e.push(0);
iinf.extend_from_slice(&bx(b"infe", &e));
}
let iinf = full_box(b"iinf", 0, &iinf);
let mut iref = Vec::new();
for (kind, from, to) in &self.refs {
let mut r = from.to_be_bytes().to_vec();
r.extend_from_slice(&(to.len() as u16).to_be_bytes());
for t in to {
r.extend_from_slice(&t.to_be_bytes());
}
iref.extend_from_slice(&bx(kind, &r));
}
let iref = full_box(b"iref", 0, &iref);
let ipco = bx(b"ipco", &self.props.concat());
let mut ipma = (self.items.iter().filter(|i| !i.props.is_empty()).count() as u32).to_be_bytes().to_vec();
for it in self.items.iter().filter(|i| !i.props.is_empty()) {
ipma.extend_from_slice(&it.id.to_be_bytes());
ipma.push(it.props.len() as u8);
ipma.extend(it.props.iter().map(|&(i, essential)| i | if essential { 0x80 } else { 0 }));
}
let iprp = bx(b"iprp", &[ipco, full_box(b"ipma", 0, &ipma)].concat());
let iloc = |base: u32| {
let mut l = vec![0x44, 0x00];
l.extend_from_slice(&(self.items.len() as u16).to_be_bytes());
let mut offset = base;
for it in &self.items {
l.extend_from_slice(&it.id.to_be_bytes());
l.extend_from_slice(&[0, 0, 0, 0, 0, 1]); // construction method 0, data ref 0, one extent
l.extend_from_slice(&offset.to_be_bytes());
l.extend_from_slice(&(it.data.len() as u32).to_be_bytes());
offset += it.data.len() as u32;
}
full_box(b"iloc", 1, &l)
};
let meta = |base| full_box(b"meta", 0, &[hdlr.clone(), pitm.clone(), iloc(base), iinf.clone(), iref.clone(), iprp.clone()].concat());
let start = (ftyp.len() + meta(0).len() + 8) as u32;
let mdat = bx(b"mdat", &self.items.iter().flat_map(|i| i.data.iter().copied()).collect::<Vec<u8>>());
[ftyp, meta(start), mdat].concat()
}
}
/// Writes the HEIF file `spec` describes.
pub fn build(spec: &Spec<'_>) -> Vec<u8> {
let mut f = File::default();
let primary = f.image(spec.width, spec.height, spec.bit_depth, false, spec.sample);
let mut assoc = Vec::new();
for p in &spec.props {
let b = match p {
Prop::Icc(icc) => bx(b"colr", &[b"prof".as_slice(), icc].concat()),
Prop::Nclx(pr, tc, mc, full) => {
let mut c = b"nclx".to_vec();
for v in [pr, tc, mc] {
c.extend_from_slice(&v.to_be_bytes());
}
c.push(if *full { 0x80 } else { 0 });
bx(b"colr", &c)
}
Prop::Irot(a) => bx(b"irot", &[a & 3]),
Prop::Imir(a) => bx(b"imir", &[a & 1]),
Prop::Clap(w, h, ho, vo) => {
let mut c = Vec::new();
for v in [*w as i32, 1, *h as i32, 1, *ho, 1, *vo, 1] {
c.extend_from_slice(&v.to_be_bytes());
}
bx(b"clap", &c)
}
};
assoc.push((f.prop(b), true, matches!(p, Prop::Clap(..))));
}
if let Some(it) = f.items.iter_mut().find(|i| i.id == primary) {
it.props.extend(assoc.iter().map(|&(i, e, _)| (i, e)));
}
if let Some(exif) = &spec.exif {
let id = f.add(b"Exif", [&[0u8, 0, 0, 0][..], exif].concat(), Vec::new());
f.refs.push((b"cdsc", id, vec![primary]));
}
let bd = spec.bit_depth;
let aux = |f: &mut File, urn: &str, sample: &dyn Fn(u32, u32) -> [u16; 3]| {
let id = f.image(spec.width, spec.height, bd, true, sample);
let auxc = f.prop(full_box(b"auxC", 0, &[urn.as_bytes(), &[0]].concat()));
if let Some(it) = f.items.iter_mut().find(|i| i.id == id) {
it.props.push((auxc, true));
}
f.refs.push((b"auxl", id, vec![primary]));
};
if let (Some(alpha), n @ 1..) = (spec.alpha, spec.alpha_tile_repeats) {
let tile = f.image(TILE, TILE, bd, true, &|x, y| [alpha(x, y), 0, 0]);
if let Some(it) = f.items.iter_mut().find(|i| i.id == tile) {
it.hidden = true;
}
let side = u32::from(n) * TILE;
let mut g = vec![0u8, 0, n - 1, n - 1];
g.extend_from_slice(&(side as u16).to_be_bytes());
g.extend_from_slice(&(side as u16).to_be_bytes());
let auxc = f.prop(full_box(b"auxC", 0, b"urn:mpeg:hevc:2015:auxid:1\0"));
let id = f.add(b"grid", g, vec![(auxc, true)]);
f.refs.push((b"dimg", id, vec![tile; usize::from(n) * usize::from(n)]));
f.refs.push((b"auxl", id, vec![primary]));
} else if let Some(alpha) = spec.alpha {
aux(&mut f, "urn:mpeg:hevc:2015:auxid:1", &|x, y| [alpha(x, y), 0, 0]);
}
for urn in &spec.ignored_aux {
aux(&mut f, urn, &|x, y| [((x + y) % 256) as u16, 0, 0]);
}
if let Some(sample) = spec.thumbnail {
// Half the size, with the primary image's colour and orientation (not its crop).
let id = f.image(spec.width / 2, spec.height / 2, spec.bit_depth, false, sample);
if let Some(it) = f.items.iter_mut().find(|i| i.id == id) {
it.props.extend(assoc.iter().filter(|a| !a.2).map(|&(i, e, _)| (i, e)));
}
f.refs.push((b"thmb", id, vec![primary]));
}
f.write(primary)
}
-214
View File
@@ -1,214 +0,0 @@
//! Decoding lossless synthetic HEIF files ([`crate::testdata`]): every expected sample is known.
use crate::testdata::{Prop, Spec, build};
use crate::{Error, Options, decode, decode_thumbnail, probe};
/// A luma value unique enough to identify its position; chroma neutral.
fn luma(x: u32, y: u32) -> u16 {
((x * 7 + y * 13) % 220 + 20) as u16
}
fn grey(x: u32, y: u32) -> [u16; 3] {
[luma(x, y), 128, 128]
}
const FULL_601: Prop = Prop::Nclx(1, 13, 6, true);
/// Decoded red channel at `(x, y)`, back in 8-bit code values.
fn at(d: &crate::Decoded, x: u32, y: u32) -> u16 {
let ch = if d.has_alpha { 4 } else { 3 };
d.data[((y * d.width + x) as usize) * ch] / 257
}
fn decoded(spec: &Spec) -> crate::Decoded {
decode(&build(spec), &Options::default()).unwrap()
}
#[test]
fn a_grid_reassembles_exactly() {
// 4 × 3 tiles of 32, cropped by the grid to 100 × 70.
let d = decoded(&Spec { props: vec![FULL_601], ..Spec::new(100, 70, &grey) });
assert_eq!((d.width, d.height, d.bit_depth, d.has_alpha), (100, 70, 8, false));
for y in 0..70 {
for x in 0..100 {
let px = &d.data[((y * 100 + x) * 3) as usize..][..3];
assert_eq!(px, [luma(x, y) * 257; 3], "({x}, {y})");
}
}
let info = probe(&build(&Spec::new(100, 70, &grey))).unwrap();
assert_eq!((info.width, info.height, info.coded_width, info.coded_height, info.bit_depth), (100, 70, 100, 70, 8));
}
#[test]
fn colour_follows_the_matrix_and_range() {
// BT.601 full range, a saturated orange: within one code value of the exact conversion.
let (y, cb, cr) = (150.0f32, 80.0, 190.0);
let s = |_: u32, _: u32| [y as u16, cb as u16, cr as u16];
let d = decoded(&Spec { props: vec![FULL_601], ..Spec::new(32, 32, &s) });
let (u, v) = (cb - 128.0, cr - 128.0);
let expected = [y + 1.402 * v, y - 0.344_136 * u - 0.714_136 * v, y + 1.772 * u].map(|c| c.clamp(0.0, 255.0));
for (got, want) in d.data[..3].iter().zip(expected) {
assert!((f32::from(*got) / 257.0 - want).abs() <= 1.0, "{:?} vs {expected:?}", &d.data[..3]);
}
assert_eq!(d.colour, crate::Colour { primaries: 1, transfer: 13, matrix: 6, full_range: true });
// No nclx and no VUI: the H.265 defaults, limited range (16 → black, 235 → white).
let ends = |x: u32, _: u32| [if x < 16 { 16 } else { 235 }, 128, 128];
let d = decoded(&Spec::new(32, 32, &ends));
assert!(!d.colour.full_range);
assert_eq!((d.data[0], d.data[20 * 3]), (0, 65535));
}
#[test]
fn ten_bit_samples_keep_their_precision() {
let s = |x: u32, y: u32| [(x * 31 + y) as u16 % 1024, 512, 512];
let d = decoded(&Spec { bit_depth: 10, props: vec![FULL_601], ..Spec::new(64, 32, &s) });
assert_eq!(d.bit_depth, 10);
for x in [0, 1, 5, 33, 63] {
let want = ((x * 31) % 1024) as f64 / 1023.0 * 65535.0;
assert!((f64::from(d.data[(x * 3) as usize]) - want).abs() <= 1.0, "x {x}");
}
}
#[test]
fn container_transforms_are_applied_like_libheif() {
let (w, h) = (70u32, 40u32);
let spec = |props: Vec<Prop>| Spec { props: [vec![FULL_601], props].concat(), ..Spec::new(w, h, &grey) };
// irot: counter-clockwise quarter turns.
let d = decoded(&spec(vec![Prop::Irot(1)]));
assert_eq!((d.width, d.height), (h, w));
assert_eq!(at(&d, 0, 0), luma(w - 1, 0)); // the right column becomes the top row
assert_eq!(at(&d, h - 1, w - 1), luma(0, h - 1));
let d = decoded(&spec(vec![Prop::Irot(2)]));
assert_eq!(at(&d, 0, 0), luma(w - 1, h - 1));
let d = decoded(&spec(vec![Prop::Irot(3)]));
assert_eq!(at(&d, 0, 0), luma(0, h - 1));
// imir: axis 0 exchanges top and bottom, axis 1 left and right (libheif's reading).
let d = decoded(&spec(vec![Prop::Imir(0)]));
assert_eq!((at(&d, 0, 0), at(&d, 5, 0)), (luma(0, h - 1), luma(5, h - 1)));
let d = decoded(&spec(vec![Prop::Imir(1)]));
assert_eq!((at(&d, 0, 0), at(&d, 0, 5)), (luma(w - 1, 0), luma(w - 1, 5)));
// clap: centred crop moved by its offsets; a half-pixel corner goes left and down.
let d = decoded(&spec(vec![Prop::Clap(31, 21, 3, -2)]));
assert_eq!((d.width, d.height), (31, 21));
// left = (70 - 31 + 6) / 2 = 22.5 → 22, top = (40 - 21 - 4) / 2 = 7.5 → 8
assert_eq!(at(&d, 0, 0), luma(22, 8));
// In association order: crop, then turn, then mirror.
let d = decoded(&spec(vec![Prop::Clap(30, 20, 0, 0), Prop::Irot(1), Prop::Imir(1)]));
assert_eq!((d.width, d.height), (20, 30));
// The crop is (20, 10) to (49, 29); the turn brings its bottom-right corner to the top-right,
// the left-right mirror to the top-left.
assert_eq!(at(&d, 0, 0), luma(49, 29));
let info = probe(&build(&spec(vec![Prop::Irot(1)]))).unwrap();
assert_eq!((info.width, info.height, info.coded_width, info.coded_height), (h, w, w, h));
// Transforms off: as coded.
let d = decode(&build(&spec(vec![Prop::Irot(1)])), &Options { apply_transforms: false, ..Default::default() }).unwrap();
assert_eq!((d.width, d.height, at(&d, 3, 2)), (w, h, luma(3, 2)));
}
#[test]
fn metadata_aux_images_and_thumbnails() {
let icc = b"not parsed here: carried verbatim".to_vec();
let exif = b"MM\0\x2a\0\0\0\x08\0\0".to_vec();
let spec = Spec {
props: vec![Prop::Icc(icc.clone()), FULL_601],
exif: Some(exif.clone()),
thumbnail: Some(&|_, _| [77, 128, 128]),
ignored_aux: vec!["urn:com:apple:photo:2020:aux:hdrgainmap", "urn:mpeg:hevc:2015:auxid:2"],
..Spec::new(64, 64, &grey)
};
let bytes = build(&spec);
let d = decode(&bytes, &Options::default()).unwrap();
assert_eq!((d.width, d.height, d.has_alpha), (64, 64, false));
assert_eq!(d.icc.as_deref(), Some(icc.as_slice()));
assert_eq!(d.exif.as_deref(), Some(exif.as_slice()));
let t = decode_thumbnail(&bytes, 32, &Options::default()).unwrap().unwrap();
assert_eq!((t.width, t.height, t.data[0]), (32, 32, 77 * 257));
assert_eq!(t.exif.as_deref(), Some(exif.as_slice()));
assert_eq!(t.icc.as_deref(), Some(icc.as_slice()));
assert!(decode_thumbnail(&bytes, 33, &Options::default()).unwrap().is_none());
}
#[test]
fn alpha_comes_from_its_auxiliary_image() {
let alpha = |x: u32, _: u32| (x * 4) as u16;
let d = decoded(&Spec { props: vec![FULL_601], alpha: Some(&alpha), ..Spec::new(64, 32, &grey) });
assert!(d.has_alpha);
assert_eq!(d.data.len(), 64 * 32 * 4);
assert_eq!((d.data[3], d.data[10 * 4 + 3]), (0, 40 * 257));
assert_eq!(d.data[..3], [luma(0, 0) * 257; 3]);
}
#[test]
fn an_alpha_grid_decodes_and_its_tile_references_share_the_visit_budget() {
let alpha = |x: u32, _: u32| (x * 4) as u16;
// a 2 × 2 alpha grid naming one tile four times: a valid file
let d = decoded(&Spec { alpha: Some(&alpha), alpha_tile_repeats: 2, ..Spec::new(64, 64, &grey) });
assert!(d.has_alpha);
assert_eq!((d.data[10 * 4 + 3], d.data[42 * 4 + 3]), (40 * 257, 40 * 257));
// 70 × 70 references to that tile: each would be rebuilt and decoded, so it is refused first
let bytes = build(&Spec { alpha: Some(&alpha), alpha_tile_repeats: 70, ..Spec::new(32, 32, &grey) });
for r in [probe(&bytes).map(|_| ()), decode(&bytes, &Options::default()).map(|_| ())] {
assert!(matches!(&r, Err(Error::Limit(m)) if m.contains("extent reads")), "{r:?}");
}
}
#[test]
fn limits_are_checked_before_decoding() {
let bytes = build(&Spec::new(96, 64, &grey));
let r = decode(&bytes, &Options { max_pixels: 96 * 64 - 1, ..Default::default() });
assert!(matches!(r, Err(Error::Limit(_))), "{r:?}");
}
/// #1518: a grid's tiles together are held to the pixel budget before any is decoded. A
/// 33 × 33 canvas fits 1089 pixels, but its four 32 × 32 tiles hold 4096: over twice the limit.
#[test]
fn grid_tiles_are_held_to_the_pixel_budget_together() {
let bytes = build(&Spec::new(33, 33, &grey));
let r = decode(&bytes, &Options { max_pixels: 33 * 33, ..Default::default() });
assert!(matches!(r, Err(Error::Limit(_))), "{r:?}");
let d = decode(&bytes, &Options { max_pixels: 2 * 32 * 32, ..Default::default() }).unwrap();
assert_eq!((d.width, d.height), (33, 33));
}
#[test]
fn truncated_and_corrupted_files_are_errors_not_panics() {
let bytes = build(&Spec { props: vec![FULL_601, Prop::Irot(1)], thumbnail: Some(&grey), ..Spec::new(64, 64, &grey) });
let full = decode(&bytes, &Options::default()).unwrap();
for cut in (0..bytes.len()).step_by(7) {
let b = &bytes[..cut];
// Cut inside the photo: an error. Cut in the trailing thumbnail: the whole photo.
if let (Ok(_), Ok(d)) = (probe(b), decode(b, &Options::default())) {
assert_eq!(d.data, full.data, "cut at {cut} of {}", bytes.len());
}
let _ = decode_thumbnail(b, 1, &Options::default());
}
// Flip bits all over the file: any outcome but a panic.
let mut state = 0x2545_f491_u32;
for _ in 0..400 {
let mut b = bytes.clone();
for _ in 0..3 {
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
let i = state as usize % b.len();
b[i] ^= 1 << (state % 8);
}
let _ = probe(&b);
let _ = decode(&b, &Options::default());
let _ = decode_thumbnail(&b, 1, &Options::default());
}
}
/// CodeRabbit #44: heic-rs keeps every associated transform and each one re-allocates the
/// whole picture, so 13 of them are over the [`crate::MAX_TRANSFORMS`] cap and refused.
#[test]
fn too_many_transform_properties_are_refused() {
let bytes = build(&Spec { props: std::iter::repeat_n(Prop::Irot(0), 13).collect(), ..Spec::new(32, 32, &grey) });
let r = decode(&bytes, &Options::default());
assert!(matches!(r, Err(Error::Limit(ref m)) if m.contains("transform")), "{r:?}");
// At the cap they're not: 12 identity rotations decode normally.
let bytes = build(&Spec { props: std::iter::repeat_n(Prop::Irot(0), 12).collect(), ..Spec::new(32, 32, &grey) });
let d = decode(&bytes, &Options::default()).unwrap();
assert_eq!((d.width, d.height), (32, 32));
}
-567
View File
@@ -1,567 +0,0 @@
//! The colour description in an HEVC sequence parameter set's VUI (Rec. ITU-T H.265, 7.3.2.2 and
//! Annex E): the fallback a HEIF reader uses when the item carries no `colr` box of type `nclx`.
//! iPhone photos are the common case: they label their colour with an ICC profile only and say in
//! the VUI that their YCbCr is full range.
//!
//! Only the syntax up to `matrix_coeffs` is read. Anything this parser can't follow returns `None`
//! and the caller falls back to the H.265 defaults; it never fails a decode.
/// What the VUI's `video_signal_type` says (H.265 E.3.1). Absent fields keep the defaults the
/// standard infers: limited range, every code point 2 ("unspecified").
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Signal {
pub full_range: bool,
pub primaries: u8,
pub transfer: u8,
pub matrix: u8,
}
impl Default for Signal {
fn default() -> Self {
Signal { full_range: false, primaries: 2, transfer: 2, matrix: 2 }
}
}
/// NAL unit type of a sequence parameter set.
const SPS_NUT: u8 = 33;
/// Reads the signal description from the SPS among `parameter_sets` (NAL units with their
/// two-byte header, as an `hvcC` record stores them). `None`: no SPS, or one this reader can't
/// follow; `Some(Signal::default())`: an SPS without VUI colour fields.
pub fn signal(parameter_sets: &[&[u8]]) -> Option<Signal> {
let sps = parameter_sets.iter().find(|n| n.first().is_some_and(|b| (b >> 1) & 0x3f == SPS_NUT))?;
parse_sps(&unescape(sps.get(2..)?))
}
/// The uncropped picture size (`pic_width/height_in_luma_samples`) of every SPS among
/// `parameter_sets`: what the decoder allocates before it applies the conformance window, so the
/// pixel budget is checked against it (heic-rs reports only the first SPS, cropped). `None`: an
/// SPS this reader can't follow.
pub fn coded_sizes(parameter_sets: &[&[u8]]) -> Option<Vec<(u32, u32)>> {
parameter_sets
.iter()
.filter(|n| n.first().is_some_and(|b| (b >> 1) & 0x3f == SPS_NUT))
.map(|sps| {
let rbsp = unescape(sps.get(2..)?);
let r = &mut Bits { data: &rbsp, pos: 0 };
sps_size(r).map(|(w, h, _)| (w, h))
})
.collect()
}
/// NAL unit type of a picture parameter set.
const PPS_NUT: u8 = 34;
/// What [`pps_layouts`] reads of a picture parameter set.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PpsLayout {
/// `pps_pic_parameter_set_id`.
pub id: u32,
/// `num_tile_columns_minus1 + 1` (1 without tiles).
pub tile_cols: u32,
/// `num_tile_rows_minus1 + 1` (1 without tiles).
pub tile_rows: u32,
}
/// The id and tile layout of every PPS among `parameter_sets`, read up to the tile counts
/// (H.265 7.3.2.3.1). `None`: a PPS this reader can't follow.
pub fn pps_layouts(parameter_sets: &[&[u8]]) -> Option<Vec<PpsLayout>> {
parameter_sets
.iter()
.filter(|n| n.first().is_some_and(|b| (b >> 1) & 0x3f == PPS_NUT))
.map(|pps| {
let rbsp = unescape(pps.get(2..)?);
pps_layout(&mut Bits { data: &rbsp, pos: 0 })
})
.collect()
}
fn pps_layout(r: &mut Bits) -> Option<PpsLayout> {
let id = r.ue()?; // pps_pic_parameter_set_id
r.ue()?; // pps_seq_parameter_set_id
// dependent slices, output flag, 3 extra slice header bits, sign hiding, cabac_init_present
r.skip(7)?;
r.ue()?; // num_ref_idx_l0_default_active_minus1
r.ue()?; // num_ref_idx_l1_default_active_minus1
r.se()?; // init_qp_minus26
r.skip(2)?; // constrained_intra_pred_flag, transform_skip_enabled_flag
if r.flag()? {
r.ue()?; // diff_cu_qp_delta_depth
}
r.se()?; // pps_cb_qp_offset
r.se()?; // pps_cr_qp_offset
// slice chroma qp offsets present, weighted pred, weighted bipred, transquant bypass
r.skip(4)?;
let tiles = r.flag()?; // tiles_enabled_flag
r.skip(1)?; // entropy_coding_sync_enabled_flag
let (tile_cols, tile_rows) = if tiles { (r.ue()?.checked_add(1)?, r.ue()?.checked_add(1)?) } else { (1, 1) };
Some(PpsLayout { id, tile_cols, tile_rows })
}
/// Reads an SPS up to and including the picture size, leaving `r` after it: width, height and
/// `sps_max_sub_layers_minus1`.
fn sps_size(r: &mut Bits) -> Option<(u32, u32, u32)> {
r.skip(4)?; // sps_video_parameter_set_id
let max_sub_layers_minus1 = r.u(3)?;
if max_sub_layers_minus1 > 6 {
return None;
}
r.skip(1)?; // sps_temporal_id_nesting_flag
profile_tier_level(r, max_sub_layers_minus1)?;
r.ue()?; // sps_seq_parameter_set_id
if r.ue()? == 3 {
r.skip(1)?; // separate_colour_plane_flag
}
let width = r.ue()?; // pic_width_in_luma_samples
let height = r.ue()?; // pic_height_in_luma_samples
Some((width, height, max_sub_layers_minus1))
}
/// Removes emulation prevention bytes (`00 00 03` → `00 00`).
fn unescape(nal: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(nal.len());
let mut zeros = 0usize;
for &b in nal {
if zeros >= 2 && b == 3 {
zeros = 0;
continue;
}
zeros = if b == 0 { zeros + 1 } else { 0 };
out.push(b);
}
out
}
struct Bits<'a> {
data: &'a [u8],
pos: usize,
}
impl Bits<'_> {
fn u(&mut self, n: u32) -> Option<u32> {
let mut v = 0u32;
for _ in 0..n {
let byte = *self.data.get(self.pos / 8)?;
v = (v << 1) | u32::from((byte >> (7 - self.pos % 8)) & 1);
self.pos += 1;
}
Some(v)
}
fn flag(&mut self) -> Option<bool> {
self.u(1).map(|b| b == 1)
}
fn skip(&mut self, n: usize) -> Option<()> {
self.pos = self.pos.checked_add(n)?;
(self.pos <= self.data.len().saturating_mul(8)).then_some(())
}
/// `ue(v)`; values past 32 bits are refused (no valid field here needs them).
fn ue(&mut self) -> Option<u32> {
let mut zeros = 0u32;
while !self.flag()? {
zeros += 1;
if zeros > 31 {
return None;
}
}
let rest = self.u(zeros)?;
((1u64 << zeros) - 1 + u64::from(rest)).try_into().ok()
}
fn se(&mut self) -> Option<()> {
self.ue().map(|_| ())
}
}
/// `profile_tier_level(1, max_sub_layers_minus1)` (7.3.3): only skipped.
fn profile_tier_level(r: &mut Bits, max_sub_layers_minus1: u32) -> Option<()> {
r.skip(88)?; // general profile space .. general_inbld/reserved flag
r.skip(8)?; // general_level_idc
let mut present = [(false, false); 8];
for p in present.iter_mut().take(max_sub_layers_minus1 as usize) {
*p = (r.flag()?, r.flag()?);
}
if max_sub_layers_minus1 > 0 {
r.skip(2 * (8 - max_sub_layers_minus1 as usize))?; // reserved_zero_2bits
}
for &(profile, level) in present.iter().take(max_sub_layers_minus1 as usize) {
if profile {
r.skip(88)?;
}
if level {
r.skip(8)?;
}
}
Some(())
}
/// `scaling_list_data()` (7.3.4): only skipped.
fn scaling_list_data(r: &mut Bits) -> Option<()> {
for size_id in 0..4u32 {
let step = if size_id == 3 { 3 } else { 1 };
for _ in (0..6).step_by(step) {
if !r.flag()? {
r.ue()?; // scaling_list_pred_matrix_id_delta
} else {
let coefs = 64.min(1 << (4 + (size_id << 1)));
if size_id > 1 {
r.se()?; // scaling_list_dc_coef_minus8
}
for _ in 0..coefs {
r.se()?; // scaling_list_delta_coef
}
}
}
}
Some(())
}
/// `st_ref_pic_set(idx)` (7.3.7) as it appears in an SPS; returns `NumDeltaPocs[idx]`.
fn st_ref_pic_set(r: &mut Bits, idx: usize, num_delta_pocs: &[u32]) -> Option<u32> {
if idx != 0 && r.flag()? {
// inter_ref_pic_set_prediction_flag: predicted from the previous set (in an SPS,
// delta_idx_minus1 is absent and RefRpsIdx = idx - 1).
r.skip(1)?; // delta_rps_sign
r.ue()?; // abs_delta_rps_minus1
let reference = *num_delta_pocs.get(idx - 1)?;
let mut count = 0u32;
for _ in 0..=reference {
let used = r.flag()?;
let kept = used || r.flag()?; // use_delta_flag when not used_by_curr_pic_flag
count += u32::from(kept);
}
return Some(count);
}
let negative = r.ue()?;
let positive = r.ue()?;
let total = negative.checked_add(positive)?;
if total > 32 {
return None; // at most 16 + 16 for any level
}
for _ in 0..total {
r.ue()?; // delta_poc_s*_minus1
r.skip(1)?; // used_by_curr_pic_s*_flag
}
Some(total)
}
fn parse_sps(rbsp: &[u8]) -> Option<Signal> {
let r = &mut Bits { data: rbsp, pos: 0 };
let (_, _, max_sub_layers_minus1) = sps_size(r)?;
parse_sps_parameters(r, max_sub_layers_minus1)?;
parse_vui(r)
}
fn parse_sps_parameters(r: &mut Bits<'_>, max_sub_layers_minus1: u32) -> Option<()> {
if r.flag()? {
for _ in 0..4 {
r.ue()?; // conf_win_*_offset
}
}
r.ue()?; // bit_depth_luma_minus8
r.ue()?; // bit_depth_chroma_minus8
let log2_max_poc_lsb = r.ue()?.checked_add(4)?;
if log2_max_poc_lsb > 16 {
return None;
}
let first = if r.flag()? { 0 } else { max_sub_layers_minus1 };
for _ in first..=max_sub_layers_minus1 {
r.ue()?; // sps_max_dec_pic_buffering_minus1
r.ue()?; // sps_max_num_reorder_pics
r.ue()?; // sps_max_latency_increase_plus1
}
for _ in 0..6 {
r.ue()?; // coding/transform block sizes, transform hierarchy depths
}
if r.flag()? && r.flag()? {
// scaling_list_enabled_flag, sps_scaling_list_data_present_flag
scaling_list_data(r)?;
}
r.skip(2)?; // amp_enabled_flag, sample_adaptive_offset_enabled_flag
if r.flag()? {
// pcm_enabled_flag
r.skip(8)?; // pcm sample bit depths
r.ue()?;
r.ue()?;
r.skip(1)?; // pcm_loop_filter_disabled_flag
}
let sets = r.ue()? as usize;
if sets > 64 {
return None;
}
let mut num_delta_pocs = Vec::with_capacity(sets);
for idx in 0..sets {
let n = st_ref_pic_set(r, idx, &num_delta_pocs)?;
num_delta_pocs.push(n);
}
if r.flag()? {
// long_term_ref_pics_present_flag
let n = r.ue()?;
if n > 32 {
return None;
}
for _ in 0..n {
r.skip(log2_max_poc_lsb as usize + 1)?; // lt_ref_pic_poc_lsb_sps, used_by_curr_pic_lt_sps_flag
}
}
r.skip(2)?; // sps_temporal_mvp_enabled_flag, strong_intra_smoothing_enabled_flag
Some(())
}
fn parse_vui(r: &mut Bits<'_>) -> Option<Signal> {
let mut signal = Signal::default();
if !r.flag()? {
return Some(signal); // no VUI
}
if r.flag()? && r.u(8)? == 255 {
// aspect_ratio_info_present_flag, aspect_ratio_idc == EXTENDED_SAR
r.skip(32)?;
}
if r.flag()? {
r.skip(1)?; // overscan_appropriate_flag
}
if r.flag()? {
// video_signal_type_present_flag
r.skip(3)?; // video_format
signal.full_range = r.flag()?;
if r.flag()? {
signal.primaries = r.u(8)? as u8;
signal.transfer = r.u(8)? as u8;
signal.matrix = r.u(8)? as u8;
}
}
Some(signal)
}
#[cfg(test)]
mod tests {
use super::*;
/// A bit writer for building parameter sets in tests.
#[derive(Default)]
pub(crate) struct Writer {
pub bits: Vec<bool>,
}
impl Writer {
pub fn u(&mut self, v: u32, n: u32) {
for i in (0..n).rev() {
self.bits.push(i < 32 && (v >> i) & 1 == 1);
}
}
pub fn ue(&mut self, v: u32) {
let x = u64::from(v) + 1;
let len = 64 - x.leading_zeros();
self.u(0, len - 1);
for i in (0..len).rev() {
self.bits.push((x >> i) & 1 == 1);
}
}
pub fn bytes(mut self) -> Vec<u8> {
self.bits.push(true); // rbsp_stop_one_bit
while !self.bits.len().is_multiple_of(8) {
self.bits.push(false);
}
self.bits.chunks(8).map(|c| c.iter().fold(0u8, |a, &b| (a << 1) | u8::from(b))).collect()
}
}
fn sps(vui: impl FnOnce(&mut Writer), st_sets: impl FnOnce(&mut Writer)) -> Vec<u8> {
let mut w = Writer::default();
w.u(0, 4);
w.u(1, 3); // one sub-layer above the base
w.u(1, 1);
w.u(0, 88);
w.u(93, 8);
w.u(0b11, 2); // sub-layer profile and level present
w.u(0, 2 * 7);
w.u(0, 88);
w.u(0, 8);
w.ue(0);
w.ue(1); // 4:2:0
w.ue(4032);
w.ue(3024);
w.u(1, 1); // conformance window
for _ in 0..4 {
w.ue(3);
}
w.ue(0);
w.ue(0);
w.ue(4);
w.u(1, 1);
for _ in 0..2 {
w.ue(1);
w.ue(0);
w.ue(0);
}
for v in [0, 3, 0, 3, 0, 0] {
w.ue(v);
}
w.u(1, 1); // scaling lists, with data
w.u(1, 1);
for size_id in 0..4u32 {
for _ in (0..6).step_by(if size_id == 3 { 3 } else { 1 }) {
w.u(1, 1);
if size_id > 1 {
w.ue(0);
}
for _ in 0..64.min(1 << (4 + (size_id << 1))) {
w.ue(0);
}
}
}
w.u(0, 2);
w.u(1, 1); // pcm
w.u(0x77, 8);
w.ue(0);
w.ue(1);
w.u(1, 1);
st_sets(&mut w);
w.u(1, 1); // long-term pictures
w.ue(1);
w.u(0, 8 + 1);
w.u(0, 2);
vui(&mut w);
let mut nal = vec![SPS_NUT << 1, 1];
// escape like a real NAL so `signal` has to unescape
let mut zeros = 0;
for b in w.bytes() {
if zeros >= 2 && b <= 3 {
nal.push(3);
zeros = 0;
}
zeros = if b == 0 { zeros + 1 } else { 0 };
nal.push(b);
}
nal
}
fn two_rps(w: &mut Writer) {
w.ue(2);
w.ue(1); // set 0: one negative picture
w.ue(0);
w.ue(0);
w.u(1, 1);
w.u(1, 1); // set 1: predicted from set 0
w.u(0, 1);
w.ue(0);
w.u(0, 1); // not used ...
w.u(1, 1); // ... but kept
w.u(1, 1);
}
#[test]
fn reads_full_range_and_matrix_from_the_vui() {
let nal = sps(
|w| {
w.u(1, 1); // vui present
w.u(1, 1);
w.u(255, 8);
w.u(0x0001_0001, 32);
w.u(1, 1);
w.u(0, 1);
w.u(1, 1); // video_signal_type_present_flag
w.u(5, 3);
w.u(1, 1); // full range
w.u(1, 1);
w.u(12, 8);
w.u(13, 8);
w.u(6, 8);
},
two_rps,
);
let s = signal(&[&[0x40, 1, 0xc], &nal, &[0x44, 1]]);
assert_eq!(s, Some(Signal { full_range: true, primaries: 12, transfer: 13, matrix: 6 }));
}
#[test]
fn absent_fields_take_the_standard_defaults() {
let no_vui = sps(|w| w.u(0, 1), |w| w.ue(0));
assert_eq!(signal(&[&no_vui]), Some(Signal::default()));
let range_only = sps(
|w| {
w.u(1, 1);
w.u(0, 2);
w.u(1, 1);
w.u(5, 3);
w.u(1, 1);
w.u(0, 1); // no colour description
},
|w| w.ue(0),
);
assert_eq!(signal(&[&range_only]), Some(Signal { full_range: true, ..Signal::default() }));
}
#[test]
fn missing_or_truncated_sps_is_none() {
assert_eq!(signal(&[]), None);
assert_eq!(signal(&[&[0x40, 1, 2, 3]]), None);
let nal = sps(|w| w.u(0, 1), |w| w.ue(0));
for cut in 2..nal.len() - 2 {
// never panics; most cuts are None
let _ = signal(&[nal.get(..cut).unwrap_or_default()]);
}
assert_eq!(signal(&[&[SPS_NUT << 1, 1, 0xff, 0xff, 0xff]]), None);
}
/// A PPS NAL as encoders write it, with `tiles` (columns, rows) when tiles are enabled.
fn pps(id: u32, cu_qp_delta: bool, tiles: Option<(u32, u32)>) -> Vec<u8> {
let mut w = Writer::default();
w.ue(id);
w.ue(0); // sps id
w.u(0, 7);
w.ue(0);
w.ue(0);
w.ue(3); // init_qp_minus26 = -2
w.u(0, 2);
w.u(u32::from(cu_qp_delta), 1);
if cu_qp_delta {
w.ue(1);
}
w.ue(1); // cb offset +1
w.ue(2); // cr offset -1
w.u(0, 4);
w.u(u32::from(tiles.is_some()), 1);
w.u(0, 1);
if let Some((c, r)) = tiles {
w.ue(c - 1);
w.ue(r - 1);
w.u(1, 1); // uniform spacing
w.u(1, 1);
}
w.u(0, 3);
[vec![PPS_NUT << 1, 1], w.bytes()].concat()
}
#[test]
fn reads_pps_ids_and_tile_counts() {
let plain = pps(5, true, None);
let tiled = pps(63, false, Some((4, 3)));
let sps_nal = sps(|w| w.u(0, 1), |w| w.ue(0));
assert_eq!(
pps_layouts(&[&sps_nal, &plain, &tiled]),
Some(vec![PpsLayout { id: 5, tile_cols: 1, tile_rows: 1 }, PpsLayout { id: 63, tile_cols: 4, tile_rows: 3 }])
);
assert_eq!(pps_layouts(&[&[PPS_NUT << 1, 1]]), None);
assert!(crate::check_parameter_sets(&[&sps_nal, &plain, &tiled]).is_ok());
assert!(crate::check_parameter_sets(&[&pps(0, false, Some((20, 22)))]).is_ok());
}
#[test]
fn refuses_parameter_sets_that_multiply_decoder_work() {
// a PPS id past 63: heic-rs would keep every distinct one and rescan them all for each
let r = crate::check_parameter_sets(&[&pps(64, false, None)]);
assert!(matches!(r, Err(crate::Error::Malformed(_))), "{r:?}");
// thousands of PPS records (even with valid, repeated ids): quadratic collection
let one = pps(1, false, None);
let many: Vec<&[u8]> = vec![&one; 5000];
assert!(matches!(crate::check_parameter_sets(&many), Err(crate::Error::Limit(_))));
// more tiles than any H.265 level allows: tile tables cost blocks × tiles
for (c, r) in [(21, 1), (1, 23), (1024, 1024)] {
let r = crate::check_parameter_sets(&[&pps(0, false, Some((c, r)))]);
assert!(matches!(r, Err(crate::Error::Limit(_))), "{r:?}");
}
}
}
-352
View File
@@ -1,352 +0,0 @@
//! YCbCr → RGB for decoded HEVC pictures, done here rather than in heic-rs so the result matches
//! libheif (the reference every HEIF tool is checked against) to within one code value:
//!
//! - **Which matrix and range.** The item's `colr` `nclx` box when there is one; otherwise the
//! HEVC VUI ([`crate::vui`]); otherwise the H.265 defaults (limited range). An unspecified matrix
//! is BT.601, as libheif reads it. heic-rs 0.1.1 ignores the VUI and assumes BT.709 limited
//! range for every file without `nclx`, which shifts every iPhone photo (full range, ICC only)
//! by about 8 code values.
//! - **Chroma upsampling.** Nearest neighbour (each chroma sample covers its 2×2 or 2×1 luma
//! block), as libheif does by default. libheif switches to a centred bilinear filter (weights
//! 9/3/3/1 sixteenths, in integers) when a `clap` crop starts at an odd column or row; so does
//! [`Upsampling::Bilinear`].
//!
//! The arithmetic is floating point and the result 16-bit, whatever the coded depth, so the
//! develop pipeline gets every bit the conversion produces.
use heic_rs::grid::Mosaic;
use heic_rs::hevc::{ChromaFormat, Frame};
/// The coded pictures one image is made of.
pub enum Planes<'a> {
Picture(&'a Frame),
Grid(Mosaic<'a>),
}
impl Planes<'_> {
pub fn size(&self) -> (usize, usize) {
match self {
Planes::Picture(f) => (f.width as usize, f.height as usize),
Planes::Grid(m) => (m.width() as usize, m.height() as usize),
}
}
pub fn bit_depth(&self) -> u8 {
match self {
Planes::Picture(f) => f.bit_depth,
Planes::Grid(m) => m.bit_depth(),
}
}
pub fn chroma(&self) -> ChromaFormat {
match self {
Planes::Picture(f) => f.chroma,
Planes::Grid(m) => m.chroma(),
}
}
fn chroma_width(&self) -> usize {
let (w, h) = self.size();
self.chroma().chroma_size(w as u32, h as u32).0 as usize
}
fn luma_row(&self, y: usize, dst: &mut [u16]) -> Option<()> {
match self {
Planes::Picture(f) => copy_row(&f.y, f.y_stride as usize, y, dst),
Planes::Grid(m) => m.luma_row(y, dst),
}
}
fn chroma_row(&self, cr: bool, r: usize, dst: &mut [u16]) -> Option<()> {
match self {
Planes::Picture(f) => copy_row(if cr { &f.cr } else { &f.cb }, f.c_stride as usize, r, dst),
Planes::Grid(m) => m.chroma_row(cr, r, dst),
}
}
}
fn copy_row(plane: &[u16], stride: usize, y: usize, dst: &mut [u16]) -> Option<()> {
let start = y.checked_mul(stride)?;
dst.copy_from_slice(plane.get(start..start.checked_add(dst.len())?)?);
Some(())
}
/// How the three coded channels map to R, G, B (H.273 `MatrixCoefficients`).
#[derive(Debug, Clone, Copy, PartialEq)]
enum Matrix {
/// 0: the channels are G, B, R.
Identity,
/// 8: YCgCo.
YCgCo,
/// Every Kr/Kb matrix: R = Y + `cr_r`·Cr, G = Y − `cb_g`·Cb − `cr_g`·Cr, B = Y + `cb_b`·Cb.
Kr { cr_r: f32, cb_g: f32, cr_g: f32, cb_b: f32 },
}
impl Matrix {
/// Unknown, reserved and unspecified codes are BT.601, like libheif.
fn from_code(code: u16) -> Matrix {
let (kr, kb) = match code {
0 => return Matrix::Identity,
8 => return Matrix::YCgCo,
1 => (0.2126, 0.0722),
4 => (0.30, 0.11),
7 => (0.212, 0.087),
// 10 (BT.2020 constant luminance) is approximated by its non-constant matrix.
9 | 10 => (0.2627, 0.0593),
_ => (0.299, 0.114),
};
let kg = 1.0 - kr - kb;
Matrix::Kr { cr_r: 2.0 * (1.0 - kr), cb_g: 2.0 * kb * (1.0 - kb) / kg, cr_g: 2.0 * kr * (1.0 - kr) / kg, cb_b: 2.0 * (1.0 - kb) }
}
}
/// How the samples are to be read: the matrix and the range.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Signal {
pub matrix: u16,
pub full_range: bool,
}
/// How subsampled chroma is brought to the luma resolution.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Upsampling {
Nearest,
/// Centred bilinear: chroma sits between its two luma columns (and rows for 4:2:0).
Bilinear,
}
/// One chroma row brought to the full width `w` of luma row `y`.
fn chroma_at(planes: &Planes<'_>, cr: bool, y: usize, w: usize, mode: Upsampling, buf: &mut [u16], next: &mut [u16]) -> Option<Vec<u16>> {
let chroma = planes.chroma();
let (xs, ys) = (chroma.x_shift(), chroma.y_shift());
let (wf, hf) = planes.size();
let rows = chroma.chroma_size(wf as u32, hf as u32).1 as usize;
let cy = y >> ys;
planes.chroma_row(cr, cy, buf)?;
let last = buf.len().checked_sub(1)?;
if mode == Upsampling::Nearest || xs == 0 {
return (0..w).map(|x| buf.get(x >> xs).copied()).collect();
}
// The nearer neighbour on each axis takes a quarter of the weight.
let ny = if ys == 0 {
cy
} else if y.is_multiple_of(2) {
cy.saturating_sub(1)
} else {
(cy + 1).min(rows.checked_sub(1)?)
};
planes.chroma_row(cr, ny, next)?;
(0..w)
.map(|x| {
let cx = x >> 1;
let nx = if x % 2 == 0 { cx.saturating_sub(1) } else { (cx + 1).min(last) };
let (a, an) = (u32::from(*buf.get(cx)?), u32::from(*buf.get(nx)?));
let v = if ys == 0 {
(3 * a + an + 2) >> 2
} else {
let (b, bn) = (u32::from(*next.get(cx)?), u32::from(*next.get(nx)?));
(9 * a + 3 * b + 3 * an + bn + 8) >> 4
};
u16::try_from(v).ok()
})
.collect()
}
/// Converts `planes` to interleaved 16-bit RGB, or RGBA with room left for alpha (filled with
/// 65535 here). `None` when the planes can't supply a row they promised (a malformed grid).
pub fn to_rgb16(planes: &Planes<'_>, signal: Signal, alpha: bool, mode: Upsampling) -> Option<Vec<u16>> {
let (w, h) = planes.size();
let ch = if alpha { 4 } else { 3 };
let bd = u32::from(planes.bit_depth());
if !(8..=16).contains(&bd) || w == 0 || h == 0 {
return None;
}
// The default caller limit is 2²8 pixels, at most four channels per pixel, so the largest
// legitimate `w·h·ch` is 2²30 samples. Anything more is a malformed or hostile canvas the
// decode path would have refused before calling here (CodeRabbit #48): refuse rather than
// ask for a multi-gigabuffer (or worse, over usize).
if w.checked_mul(h)?.checked_mul(ch)? > 1 << 30 {
return None;
}
let max = ((1u32 << bd) - 1) as f32;
let half = (1u32 << (bd - 1)) as f32;
let scale = (1u32 << (bd - 8)) as f32;
// Normalised Y = (v − y_off)·y_mul, Cb/Cr = (v − half)·c_mul.
let (y_off, y_mul, c_mul) =
if signal.full_range { (0.0, 1.0 / max, 1.0 / max) } else { (16.0 * scale, 1.0 / (219.0 * scale), 1.0 / (224.0 * scale)) };
let matrix = Matrix::from_code(signal.matrix);
let mono = planes.chroma() == ChromaFormat::Monochrome;
let cw = planes.chroma_width();
let mut out = vec![0u16; w.checked_mul(h)?.checked_mul(ch)?];
let row = |y: usize, dst: &mut [u16]| -> Option<()> {
let mut luma = vec![0u16; w];
planes.luma_row(y, &mut luma)?;
let (cb, cr) = if mono {
(Vec::new(), Vec::new())
} else {
let (mut buf, mut next) = (vec![0u16; cw], vec![0u16; cw]);
(chroma_at(planes, false, y, w, mode, &mut buf, &mut next)?, chroma_at(planes, true, y, w, mode, &mut buf, &mut next)?)
};
for (x, (px, &yv)) in dst.chunks_exact_mut(ch).zip(&luma).enumerate() {
let rgb = if mono {
let v = (f32::from(yv) - y_off) * y_mul;
[v, v, v]
} else {
let (u, v) = (f32::from(*cb.get(x)?), f32::from(*cr.get(x)?));
match matrix {
// G, B, R all read like luma.
Matrix::Identity => [(v - y_off) * y_mul, (f32::from(yv) - y_off) * y_mul, (u - y_off) * y_mul],
Matrix::YCgCo => {
let (yn, cg, co) = ((f32::from(yv) - y_off) * y_mul, (u - half) * c_mul, (v - half) * c_mul);
let t = yn - cg;
[t + co, yn + cg, t - co]
}
Matrix::Kr { cr_r, cb_g, cr_g, cb_b } => {
let (yn, u, v) = ((f32::from(yv) - y_off) * y_mul, (u - half) * c_mul, (v - half) * c_mul);
[yn + cr_r * v, yn - cb_g * u - cr_g * v, yn + cb_b * u]
}
}
};
for (o, c) in px.iter_mut().zip(rgb) {
*o = (c.clamp(0.0, 1.0) * 65535.0 + 0.5) as u16;
}
if alpha && let Some(a) = px.get_mut(3) {
*a = u16::MAX;
}
}
Some(())
};
let row_len = w * ch;
#[cfg(not(target_arch = "wasm32"))]
let ok = {
use rayon::prelude::*;
out.par_chunks_mut(row_len).enumerate().all(|(y, dst)| row(y, dst).is_some())
};
#[cfg(target_arch = "wasm32")]
let ok = out.chunks_mut(row_len).enumerate().all(|(y, dst)| row(y, dst).is_some());
ok.then_some(out)
}
/// Writes an alpha picture's luma, full range, into channel 3 of `rgba`.
pub fn put_alpha(planes: &Planes<'_>, rgba: &mut [u16]) -> Option<()> {
let (w, h) = planes.size();
let max = ((1u32 << u32::from(planes.bit_depth()).clamp(1, 16)) - 1) as f32;
let mut luma = vec![0u16; w];
for (y, row) in rgba.chunks_exact_mut(w * 4).enumerate().take(h) {
planes.luma_row(y, &mut luma)?;
for (px, &a) in row.as_chunks_mut::<4>().0.iter_mut().zip(&luma) {
let v = (f32::from(a) / max).clamp(0.0, 1.0);
px[3] = (v * 65535.0 + 0.5) as u16;
}
}
Some(())
}
#[cfg(test)]
mod tests {
use super::*;
fn frame(w: u32, h: u32, bd: u8, chroma: ChromaFormat, y: u16, cb: u16, cr: u16) -> Frame {
let (cw, chh) = chroma.chroma_size(w, h);
let n = (cw * chh) as usize;
Frame {
width: w,
height: h,
bit_depth: bd,
chroma,
y: vec![y; (w * h) as usize],
cb: vec![cb; n],
cr: vec![cr; n],
y_stride: w,
c_stride: cw,
}
}
fn rgb(f: &Frame, matrix: u16, full_range: bool) -> [u16; 3] {
let v = to_rgb16(&Planes::Picture(f), Signal { matrix, full_range }, false, Upsampling::Nearest).unwrap();
[v[0], v[1], v[2]]
}
#[test]
fn neutral_and_primaries_convert_exactly() {
// Full-range grey stays grey; limited-range black and white reach the ends.
assert_eq!(rgb(&frame(4, 4, 8, ChromaFormat::Yuv420, 128, 128, 128), 6, true), [128 * 257; 3]);
assert_eq!(rgb(&frame(4, 4, 8, ChromaFormat::Yuv420, 16, 128, 128), 1, false), [0; 3]);
assert_eq!(rgb(&frame(4, 4, 8, ChromaFormat::Yuv420, 235, 128, 128), 1, false), [65535; 3]);
assert_eq!(rgb(&frame(4, 4, 10, ChromaFormat::Yuv420, 940, 512, 512), 9, false), [65535; 3]);
// BT.601 full-range pure red: Y = 76.245, Cb = 84.97, Cr = 255.5 → (255, 0, 0) within rounding.
let red = rgb(&frame(2, 2, 8, ChromaFormat::Yuv444, 76, 85, 255), 6, true);
assert!(red[0] > 65000 && red[1] < 300 && red[2] < 300, "{red:?}");
// Identity: the channels are G, B, R.
assert_eq!(rgb(&frame(2, 2, 8, ChromaFormat::Yuv444, 10, 20, 30), 0, true), [30 * 257, 10 * 257, 20 * 257]);
// Monochrome.
assert_eq!(rgb(&frame(2, 2, 8, ChromaFormat::Monochrome, 51, 0, 0), 6, true), [51 * 257; 3]);
}
#[test]
fn chroma_is_nearest_neighbour() {
// 4:2:0, 4×2 luma, chroma 2×1: the left chroma sample covers columns 0–1 only.
let mut f = frame(4, 2, 8, ChromaFormat::Yuv420, 128, 128, 128);
f.cr = vec![200, 128];
let v = to_rgb16(&Planes::Picture(&f), Signal { matrix: 6, full_range: true }, false, Upsampling::Nearest).unwrap();
let red: Vec<u16> = v.chunks(3).map(|p| p[0]).collect();
assert!(red[0] == red[1] && red[1] == red[4] && red[0] > red[2] && red[2] == 128 * 257, "{red:?}");
}
#[test]
fn bilinear_chroma_is_centred_9_3_3_1() {
// 4:2:0, 4×4 luma, chroma 2×2 with one bright corner sample.
let mut f = frame(4, 4, 8, ChromaFormat::Yuv420, 128, 128, 128);
f.cr = vec![200, 128, 128, 128];
let p = Planes::Picture(&f);
let (mut buf, mut next) = (vec![0; 2], vec![0; 2]);
let rows: Vec<Vec<u16>> = (0..4).map(|y| chroma_at(&p, true, y, 4, Upsampling::Bilinear, &mut buf, &mut next).unwrap()).collect();
// Row 0 sits nearest chroma row 0 (and clamps upward); row 1 blends a quarter of row 1.
assert_eq!(rows[0], [200, 182, 146, 128]);
assert_eq!(rows[1], [182, 169, 142, 128]);
assert_eq!(rows[2], [146, 142, 133, 128]);
assert_eq!(rows[3], [128; 4]);
assert_eq!(chroma_at(&p, true, 1, 4, Upsampling::Nearest, &mut buf, &mut next).unwrap(), [200, 200, 128, 128]);
}
#[test]
fn alpha_and_bad_planes() {
let f = frame(2, 2, 8, ChromaFormat::Yuv420, 128, 128, 128);
let mut v = to_rgb16(&Planes::Picture(&f), Signal { matrix: 6, full_range: true }, true, Upsampling::Nearest).unwrap();
assert_eq!(v[3], 65535);
put_alpha(&Planes::Picture(&frame(2, 2, 8, ChromaFormat::Monochrome, 51, 0, 0)), &mut v).unwrap();
assert_eq!(v[3], 51 * 257);
let mut short = frame(4, 4, 8, ChromaFormat::Yuv420, 128, 128, 128);
short.y.truncate(5);
assert!(to_rgb16(&Planes::Picture(&short), Signal { matrix: 6, full_range: true }, false, Upsampling::Bilinear).is_none());
assert!(
to_rgb16(
&Planes::Picture(&frame(2, 2, 7, ChromaFormat::Yuv420, 0, 0, 0)),
Signal { matrix: 6, full_range: true },
false,
Upsampling::Nearest
)
.is_none()
);
}
/// CodeRabbit #48: a plane claiming 500 000 × 500 000 pixels must be refused without ever
/// allocating for it (before the cap this vec was never built; upper-bounding allocation
/// would have been a 7.5-gibabuffer or a panic instead of an error).
#[test]
fn an_oversized_canvas_is_refused_without_allocation() {
let f = Frame {
width: 500_000,
height: 500_000,
bit_depth: 8,
chroma: ChromaFormat::Yuv420,
y: vec![128],
cb: vec![128; 4],
cr: vec![128; 4],
y_stride: 0,
c_stride: 0,
};
assert!(to_rgb16(&Planes::Picture(&f), Signal { matrix: 6, full_range: true }, false, Upsampling::Nearest).is_none());
}
}
+1 -1
View File
@@ -17,6 +17,6 @@ chrono = { workspace = true }
[dev-dependencies]
# Lossless synthetic HEIC files: the HEIF item reader is proved against a real container writer.
lightcraft-heif = { workspace = true, features = ["testdata"] }
craft-heif = { workspace = true, features = ["testdata"] }
proptest = { workspace = true }
serde_json = { workspace = true }
+4 -4
View File
@@ -2,7 +2,7 @@
//! (box structure from ISO/IEC 14496-12, item model from ISO/IEC 23008-12).
//!
//! HEIC is what iPhones and Macs write. Its pixels need an HEVC decoder (the optional
//! `lightcraft-heif` crate), its metadata does not, so this reader is in every build: a HEIC
//! `craft-heif` crate), its metadata does not, so this reader is in every build: a HEIC
//! imports with its capture time, camera and lens whether or not the build can show the picture.
//!
//! The `meta` box holds an item information box (`iinf`, one `infe` per item) naming each item's
@@ -390,14 +390,14 @@ mod tests {
assert!(embedded(&lying).exif.is_none());
}
/// The real container writer of `lightcraft-heif`, so the reader is proved against the layout
/// The real container writer of `craft-heif`, so the reader is proved against the layout
/// a HEIF encoder produces and not only against this module's own test builder.
#[test]
fn a_synthetic_heif_file_carries_its_exif() {
let tiff = iphone_exif("2026:10:18 13:00:00", "-05:00");
let mut spec = lightcraft_heif::testdata::Spec::new(64, 64, &|x, _| [x as u16 * 4, 0, 0]);
let mut spec = craft_heif::testdata::Spec::new(64, 64, &|x, _| [x as u16 * 4, 0, 0]);
spec.exif = Some(tiff.clone());
let file = lightcraft_heif::testdata::build(&spec);
let file = craft_heif::testdata::build(&spec);
assert!(is_heif(&file));
assert_eq!(embedded(&file).exif.as_deref(), Some(tiff.as_slice()));
assert_eq!(crate::extract(&file).capture_time.map(|d| d.to_iso()).as_deref(), Some("2026-10-18T13:00:00-05:00"));
+5 -2
View File
@@ -51,8 +51,11 @@ pub fn check_image(data: &[u8], info: &ImageInfo) -> Result<usize> {
let (across, down) = info.grid();
let planes = if info.planar == 2 { cpp } else { 1 };
let expected = (across as usize).saturating_mul(down as usize).saturating_mul(planes);
if chunks.len() < expected {
return Err(RawError::Corrupt(format!("{} image data chunks, expected {expected}", chunks.len())));
// the offsets table says how many chunks the image declares: craft-tiff builds at most one
// descriptor per byte of file (craft-libs#827), so `chunks` may be shorter on a grid of tiles
// sharing one payload, and the bytes behind it are what the bounds below count.
if info.offsets.len() < expected {
return Err(RawError::Corrupt(format!("{} image data chunks, expected {expected}", info.offsets.len())));
}
// Tile sizes don't depend on the image size, and every tile is decoded at its nominal size and held until the copy:
// a grid of tiles no larger than the image covers less than twice its width and height, so more than four times
+2 -2
View File
@@ -19,7 +19,7 @@ import and export formats. Ours come from `crates/codecs/src/sniff.rs`, `crates/
| TIFF | ✅ 8/16/32-bit | ✅ 8/16-bit, LZW/ZIP | ✅ 1–64-bit integer, 16–64-bit float, bilevel, CCITT fax, WhiteIsZero | ✅ 8/16-bit, 32-bit float linear, none / LZW / ZIP | `crates/tiff`, `crates/codecs/src/tiff_codec.rs` |
| PNG | ✅ | ✅ | ✅ | ✅ | |
| PSD / PSB | ✅ (maximized-compatibility composite) | ✅ (Classic: PSD export, edit-in round trip) | ✅ merged composite | ⬜ (external-editor round trip writes 16-bit TIFF) | `crates/codecs/src/psd.rs` |
| HEIC / HEIF | ✅ | ⬜ (Classic) / HDR only | ✅ in every release build (`crates/heif`, heic-rs) | ⬜ | `heif` feature on by packaging scripts |
| HEIC / HEIF | ✅ | ⬜ (Classic) / HDR only | ✅ in every release build (`craft-heif` from craft-libs, heic-rs) | ⬜ | `heif` feature on by packaging scripts |
| AVIF | ✅ | ✅ (HDR) | ⬜ recognised, not decoded (no permissive pure-Rust AV1 decoder) | ✅ 8/10-bit, PQ HDR | |
| JPEG XL | ✅ | ✅ | ✅ (`jxl-oxide`) incl. DNG 1.7 JXL tiles | ✅ lossy / lossless, 8/16-bit, PQ HDR (`jixel`, native only; ⬜ web) | `crates/engine/src/tests/export.rs` |
| WebP | not in its document types | ⬜ | ✅ | ✅ | beyond target |
@@ -27,7 +27,7 @@ import and export formats. Ours come from `crates/codecs/src/sniff.rs`, `crates/
| DNG (from raw) | ✅ | ✅ incl. lossy, embedded original | ✅ | ✅ uncompressed, LJ92, Deflate or lossy (JPEG tiles, optional long edge); ⬜ embedded original | `crates/raw/src/dngwrite.rs` |
| Render to DNG (15.5) | — | ✅ | — | 🟡 export format "Rendered DNG" (linear float DNG, edit baked in); not yet added to the catalog | `crates/raw/src/dngwrite.rs` (`write_rendered_dng`) |
| Original + sidecar | — | ✅ | — | ✅ | |
| HDR gain map JPEG (ISO 21496-1) | ✅ | ✅ | ✅ (gain map read) | ✅ | `crates/codecs/src/gainmap.rs` |
| HDR gain map JPEG (ISO 21496-1) | ✅ | ✅ | ✅ (gain map read) | ✅ | `crates/codecs/src/gainmap.rs` (JPEG layout), `craft-gainmap` (metadata, compute, apply) |
| PQ / HLG HDR | ✅ | ✅ AVIF, JXL, TIFF | — | 🟡 PQ AVIF, PQ JPEG XL, float TIFF; no HLG | |
| Contact sheet / print PDF | — | ✅ (Print module: PDF / JPEG / printer) | — | 🟡 paginated contact-sheet PDF (A4 / Letter, 150 dpi, sRGB) | `crates/engine/src/contact_sheet.rs` |
| Video (MP4, MOV, AVCHD…) | ✅ playback, trim, edit | ✅ export | 🟡 catalogued (kind, duration) | ⬜ | see video gap |
File diff suppressed because one or more lines are too long
+1 -4
View File
@@ -286,10 +286,7 @@ pub(crate) fn cmd_ci(args: &[&str]) -> Result<(), String> {
let mut c = cargo();
c.args(["clippy", "-p", "lightcraft-codecs", "--features", "heif", "--all-targets", "--", "-D", "warnings"]);
run(c, "cargo clippy -p lightcraft-codecs --features heif --all-targets -- -D warnings")?;
test(
tests(&with_test_targets(&["-p", "lightcraft-codecs", "-p", "lightcraft-heif", "--features", "lightcraft-codecs/heif"])),
"heif",
)?;
test(tests(&with_test_targets(&["-p", "lightcraft-codecs", "--features", "lightcraft-codecs/heif"])), "heif")?;
// the engine's HEIC import test, with the decoder (the workspace run checks the error)
test(tests(&["-p", "lightcraft-engine", "--lib", "--features", "lightcraft-codecs/heif", "heic"]), "heif")
}),
+2 -2
View File
@@ -7,7 +7,7 @@
//! - fmt, layers, assets, roots: always (seconds);
//! - clippy on the whole workspace (check builds only; catches callers broken by an API change);
//! - the tests of the changed packages only (not their dependents);
//! - heif when `lightcraft-codecs` / `lightcraft-heif` changed;
//! - heif when `lightcraft-codecs` changed (or the workspace files, which pin craft-heif);
//! - parity when the tracker docs, a command/control crate, or a file's path changed (renames and
//! deletions: the tracker cites paths);
//! - the wasm check of the changed packages that must build for wasm32.
@@ -28,7 +28,7 @@ const WORKSPACE_WIDE_DIRS: &[&str] = &[".cargo/"];
/// Packages whose ids or paths the parity tracker cites (commands, develop controls, UI menus).
const PARITY_PACKAGES: &[&str] = &["lightcraft-engine", "lightcraft-develop", "lightcraft-ui-egui", "lightcraft-cli"];
const PARITY_DOCS: &[&str] = &["docs/parity-checklist.md", "docs/gaps.md"];
const HEIF_PACKAGES: &[&str] = &["lightcraft-codecs", "lightcraft-heif"];
const HEIF_PACKAGES: &[&str] = &["lightcraft-codecs"];
/// Files outside a package's directory that it compiles in (`include_str!` / `include_bytes!`,
/// a build script's `rerun-if-changed`): a change to one counts as a change to those packages.
/// An entry ending in `/` covers the directory. `embedded_files_are_mapped` keeps this complete.
-1
View File
@@ -42,7 +42,6 @@ pub const TABLE: &[(&str, Class)] = &[
("fetch", Class::Layer(0)),
("denoise-core", Class::Layer(1)),
("denoise", Class::Layer(1)),
("heif", Class::Layer(0)),
("raw", Class::Layer(1)),
("codecs", Class::Layer(1)),
("meta", Class::Layer(1)),