From 62e09222f1499e0c0e71ef5a1c3208fe127ab5b0 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 12 Nov 2026 21:16:46 +0100 Subject: [PATCH 001/382] craft-video: AV1 decoding about 1.7x as fast with many threads Port of storytold/Filmcraft#4542 (the code moved here). Frames start as soon as the reference rows they read are done (row wavefront across frames), parsing is split from reconstruction, and there is one frame worker per thread. Output is bit-identical; single-thread speed is unchanged. Co-Authored-By: Claude Sonnet 5.5 --- crates/video/src/av1/decode/README.md | 54 +- crates/video/src/av1/decode/cdef.rs | 30 +- crates/video/src/av1/decode/decoder.rs | 1154 +++++++++++++++-- crates/video/src/av1/decode/frame.rs | 166 +++ crates/video/src/av1/decode/inter.rs | 29 +- crates/video/src/av1/decode/postfilter.rs | 160 ++- crates/video/src/av1/decode/restoration.rs | 14 +- crates/video/src/av1/decode/state.rs | 29 +- crates/video/src/av1/decode/tile.rs | 314 ++++- crates/video/src/av1/decode/tile/coeffs.rs | 52 + crates/video/src/av1/decode/tile/predict.rs | 23 +- crates/video/tests/av1_decode/fuzz_hostile.rs | 70 +- crates/video/tests/av1_decode/main.rs | 1 + crates/video/tests/av1_decode/wavefront.rs | 93 ++ 14 files changed, 1992 insertions(+), 197 deletions(-) create mode 100644 crates/video/tests/av1_decode/wavefront.rs diff --git a/crates/video/src/av1/decode/README.md b/crates/video/src/av1/decode/README.md index 1518df92c..e1b8e4732 100644 --- a/crates/video/src/av1/decode/README.md +++ b/crates/video/src/av1/decode/README.md @@ -73,11 +73,17 @@ with libdav1d: **bit-exact** on all 6 fixtures. `Decoder::new()` uses all cores (`Decoder::with_threads(1)` decodes on the calling thread; on wasm32, or without the default `threads` feature, everything runs on the calling thread). Headers are parsed in order; each frame is -then decoded by a frame worker once the reference frames it reads are finished, so independent -frames (hierarchical GOP layers) decode concurrently; tiles of a frame decode in parallel into -private buffers that are merged afterwards; the in-loop filters (deblocking, CDEF, loop -restoration) each run in parallel bands of 64 rows (`postfilter.rs` explains why the bands are -independent). Results never depend on scheduling (the oracle tests compare 1 thread, many threads +then decoded by a frame worker. With worker threads it first reads the symbols of all its tiles, +which needs only the parse results of its references (CDFs, segment ids, saved motion vectors), +publishes its own, and then reconstructs from the recorded blocks. Frames with several tiles +read the symbols of their tiles in parallel (one after another with intra block copy). A frame reconstructs superblock row by superblock +row (that row of every tile), each row waiting only for the reference rows its motion vectors +reach (row wavefront), and the in-loop filters (deblocking, CDEF, loop restoration) follow a few +64-row bands behind and publish each final band for the frames predicting from it +(`decoder.rs` and `postfilter.rs` give the dependency rules). Super-resolution frames wait for +their whole references and filter the whole frame. There is one frame worker per thread (at most +16), and the frames in flight are bounded by their size. Independent frames (hierarchical GOP +layers) decode concurrently. Results never depend on scheduling (the oracle tests compare 1 thread, many threads and libdav1d). With frame threads, pictures may be returned by a later `decode_pts` call or by `flush`; each carries the `pts` of the temporal unit that showed it. @@ -130,6 +136,44 @@ motion vectors nor CDFs reach another frame — skip deblocking, CDEF and loop r (super-resolution still runs, it sets the output size) and are flagged `Picture::draft`. In SVT-AV1's hierarchical GOPs that is the top layer, half of the frames. +Frame threading on a Ryzen 7800X3D (8 cores / 16 threads, release `examples/av1_av1dec`, median of 7 +alternating runs against Filmcraft `6909e461`, 2026-11-08), wall time for the whole file: + +| Fixture | Threads | Before | After | Speed-up | +|---|---|---|---|---| +| `perf_1080p_gop` (60 frames) | 1 | 69.2 fps | 69.1 fps | 1.00x | +| `perf_1080p_gop` | 16 | 159.6 fps | 227.3 fps | 1.42x | +| `perf_2160p_gop` (30 frames) | 1 | 17.9 fps | 17.8 fps | 1.00x | +| `perf_2160p_gop` | 16 | 40.2 fps | 57.7 fps | 1.43x | + +Peak RSS at 16 threads goes from 278 to 365 MB (1080p) and from 1031 to 1217 MB (2160p, +18%): +every frame in flight holds its parse record and its final samples are kept in 64-row bands. + +With one frame worker per thread, the row wavefront for frames with several tiles and parse +waits limited to what parsing reads (same machine, median of 5 alternating runs, 2026-11-08): + +| Fixture | Threads | Before (`6909e461`) | After | Speed-up | Peak RSS before / after | +|---|---|---|---|---|---| +| `perf_1080p_gop` | 4 | 95.7 fps | 185.2 fps | 1.94x | 148 / 236 MB | +| `perf_1080p_gop` | 16 | 155.0 fps | 259.7 fps | 1.68x | 274 / 560 MB | +| `perf_2160p_gop` | 4 | 23.6 fps | 47.1 fps | 2.00x | 512 / 798 MB | +| `perf_2160p_gop` | 16 | 39.9 fps | 65.8 fps | 1.65x | 994 / 1353 MB | +| `perf_1080p_gop_tiles` (4x2 tiles) | 16 | 186.3 fps | 237.2 fps | 1.27x | 328 / 617 MB | +| SVT-AV1 2160p, 4x2 tiles (30 frames) | 16 | 57.1 fps | 70.8 fps | 1.24x | 1197 / 1502 MB | + +Known limitations of the frame threading (the output is the same in every case, only the +overlap is smaller): + +- A frame whose parse record would pass 32 bytes per luma sample of a tile (pathological streams: + tiny blocks, large palettes, every coefficient coded), or that cannot reserve its record from + the decoder-wide budget of 1 GiB shared by the frames in flight, is decoded again in one pass. +- A superblock row using local warped motion, global motion beyond translation or a scaled + reference waits for the whole reference instead of the rows its motion vectors reach. +- Super-resolution frames do not use the row wavefront: they wait for their whole references + and filter the whole frame. +- The tile columns of a superblock row are reconstructed one after another on the frame's worker + (their symbols are still read in parallel). + ## Limits Frames beyond the AV1 level 6.x limits (Annex A: at most 16384 wide, 8704 high and 35 651 584 luma samples diff --git a/crates/video/src/av1/decode/cdef.rs b/crates/video/src/av1/decode/cdef.rs index edd119292..05eb0a2a7 100644 --- a/crates/video/src/av1/decode/cdef.rs +++ b/crates/video/src/av1/decode/cdef.rs @@ -10,19 +10,33 @@ use crate::av1::decode::state::FrameState; /// equals CurrFrame). Bands of 64 luma rows (whole 64x64 filter blocks) are filtered in /// parallel: every block reads only CurrFrame and writes only its own samples. pub(crate) fn apply(fs: &FrameState, pool: &Pool) -> Option { + if !active(fs) { + return None; + } + let mut out = fs.cur.clone(); + let ranges = bands(pool, fs.fh.mi_rows as usize * 4); + filter_bands(fs, pool, out.row_bands(&ranges), &ranges); + Some(out) +} + +/// Whether CDEF filters any block of the frame (it reads only parse results). +pub(crate) fn active(fs: &FrameState) -> bool { let fh = &fs.fh; if fh.coded_lossless || fh.allow_intrabc || !fs.seq.enable_cdef { - return None; + return false; } let (mi_rows, mi_cols) = (fh.mi_rows as usize, fh.mi_cols as usize); let fb_rows = mi_rows.div_ceil(16); let fb_cols = mi_cols.div_ceil(16); - if !(0..fb_rows).any(|fr| (0..fb_cols).any(|fc| fb_skip_mask(fs, fr * 16, fc * 16).is_some())) { - return None; - } - let mut out = fs.cur.clone(); - let ranges = bands(pool, mi_rows * 4); - let mut planes = out.row_bands(&ranges); + (0..fb_rows).any(|fr| (0..fb_cols).any(|fc| fb_skip_mask(fs, fr * 16, fc * 16).is_some())) +} + +/// Filter the bands `planes` covering luma rows `ranges` (whole 64x64 filter block rows), which +/// hold CurrFrame; reads CurrFrame up to 2 rows beyond each band. +pub(crate) fn filter_bands(fs: &FrameState, pool: &Pool, mut planes: Vec<[RowBand; 3]>, ranges: &[(usize, usize)]) { + let (mi_rows, mi_cols) = (fs.fh.mi_rows as usize, fs.fh.mi_cols as usize); + let fb_rows = mi_rows.div_ceil(16); + let fb_cols = mi_cols.div_ceil(16); pool.map_mut(&mut planes, |b, band| { let (start, end) = ranges[b]; let mut buf = [0i16; BUF_LEN]; @@ -34,8 +48,6 @@ pub(crate) fn apply(fs: &FrameState, pool: &Pool) -> Option { } } }); - drop(planes); - Some(out) } /// The filtered 8x8 blocks of the 64x64 filter block at (r, c): bit `(i << 3) | j` is set for diff --git a/crates/video/src/av1/decode/decoder.rs b/crates/video/src/av1/decode/decoder.rs index 3fb1f1326..dc9caf74b 100644 --- a/crates/video/src/av1/decode/decoder.rs +++ b/crates/video/src/av1/decode/decoder.rs @@ -2,31 +2,37 @@ //! (7.20), show-existing-frame and output (7.18). //! //! Threading: headers are parsed in order on the calling thread; each frame then becomes a job -//! that waits for the reference frames it uses and decodes on a frame worker thread, so frames -//! that do not depend on each other decode concurrently. Within a frame, tiles and the -//! post-filter row bands run on a shared worker pool. Every result depends only on finished -//! reference frames, so the output is identical whatever the scheduling. Shown pictures are -//! returned in order; with frame threads they can come out of a later `decode` call (or -//! `flush`), each carrying the `pts` of the temporal unit that showed it. +//! on a frame worker thread. A job first reads the symbols of its tiles (parse), which needs +//! only the parse results of its references (CDFs, segment ids, saved motion vectors), and +//! publishes its own; it then reconstructs. A frame is reconstructed superblock row by +//! superblock row (that row of every tile), each row waiting only for the reference rows its +//! motion vectors reach, with the in-loop filters following a few bands behind and every final +//! band published for the frames that predict from it (row wavefront); super-resolution frames +//! wait for their whole references. So a frame can parse while its references are still being reconstructed, and reconstruct +//! while their bottom is still being filtered. Within a frame, tiles and the post-filter row +//! bands run on a shared worker pool; waits happen only on frame worker threads. Every result +//! depends only on final reference data, so the output is identical whatever the scheduling. +//! Shown pictures are returned in order; with frame threads they can come out of a later +//! `decode` call (or `flush`), each carrying the `pts` of the temporal unit that showed it. use std::collections::VecDeque; use std::sync::{Arc, Condvar, Mutex}; use crate::av1::decode::bits::{BitReader, leb128}; use crate::av1::decode::cdf::Cdfs; -use crate::av1::decode::frame::FrameBuf; +use crate::av1::decode::frame::{BandFrame, FrameBuf, PlaneRef}; use crate::av1::decode::header::{ ColorConfig, FilmGrainParams, FrameHeader, HeaderState, LoopFilterDeltas, RefInfo, SegmentationFeatures, SequenceHeader, default_gm_params, }; use crate::av1::decode::par::Pool; use crate::av1::decode::spec_tables::{ - ALTREF_FRAME, ALTREF2_FRAME, BWDREF_FRAME, DEFAULT_INTRA_FRAME_Y_MODE_CDF, DIV_MULT, GOLDEN_FRAME, INTRA_FRAME, INTRA_ONLY_FRAME, KEY_FRAME, - LAST_FRAME, LAST2_FRAME, MAX_FRAME_DISTANCE, MAX_OFFSET_HEIGHT, MAX_OFFSET_WIDTH, MFMV_STACK_SIZE, NUM_REF_FRAMES, PRIMARY_REF_NONE, - REFMVS_LIMIT, REFS_PER_FRAME, + ALTREF_FRAME, ALTREF2_FRAME, BWDREF_FRAME, DEFAULT_INTRA_FRAME_Y_MODE_CDF, DIV_MULT, GLOBAL_GLOBALMV, GLOBALMV, GOLDEN_FRAME, INTRA_FRAME, + INTRA_ONLY_FRAME, KEY_FRAME, LAST_FRAME, LAST2_FRAME, LOCALWARP, MAX_FRAME_DISTANCE, MAX_OFFSET_HEIGHT, MAX_OFFSET_WIDTH, MFMV_STACK_SIZE, + NUM_REF_FRAMES, PRIMARY_REF_NONE, REFMVS_LIMIT, REFS_PER_FRAME, TRANSLATION, }; use crate::av1::decode::state::{FrameShared, FrameState, TileState}; use crate::av1::decode::stats::{DecodeStats, Stage, Timer}; -use crate::av1::decode::tile::TileDecoder; +use crate::av1::decode::tile::{Pass, TileDecoder, TileRecord}; use crate::av1::decode::{Error, Picture, Result}; /// Largest accepted frame: the AV1 level 6.x limits (Annex A: MaxHSize 16384, MaxVSize 8704, MaxPicSize @@ -49,22 +55,156 @@ const OBU_FRAME_T: u32 = 6; const OBU_REDUNDANT_FRAME_HEADER_T: u32 = 7; const OBU_TILE_LIST_T: u32 = 8; -/// A stored reference frame (FrameStore plus the saved per-frame state). +/// The samples of a stored reference frame (FrameStore), after every in-loop filter: a whole +/// buffer (decoding on one thread) or the bands published while decoding (with worker threads). pub(crate) struct RefFrame { pub buf: FrameBuf, - pub cdfs: Box, + pub bands: Option>, + pub num_planes: usize, pub bit_depth: u8, pub subsampling_x: u8, pub subsampling_y: u8, + pub color: (u8, u8, u8, bool), +} + +impl RefFrame { + pub fn plane(&self, p: usize) -> PlaneRef<'_> { + match &self.bands { + Some(b) => PlaneRef::Bands(&b.planes[p]), + None => PlaneRef::Whole(&self.buf.planes[p]), + } + } +} + +/// The saved per-frame state that later frames read while parsing (CDFs, segment ids and the +/// motion vectors for motion field estimation). It depends only on the frame's symbols, so it +/// is published as soon as the tiles are decoded, before the in-loop filters run. +pub(crate) struct Parsed { + pub cdfs: Box, pub segment_ids: Vec, pub mi_cols: usize, pub mi_rows: usize, - pub color: (u8, u8, u8, bool), - /// SavedRefFrames / SavedMvs (MfRefFrames / MfMvs of 7.19), mi units. + /// SavedRefFrames / SavedMvs (MfRefFrames / MfMvs of 7.19) at the odd row and column of + /// every 8x8 block, the only positions the projection reads. pub saved_ref_frames: Vec, pub saved_mvs: Vec<[i32; 2]>, } +/// How many luma rows of a frame are final (every in-loop filter applied), or that the frame +/// failed. Rows only ever grow; a failure wakes every waiter with an error. +pub(crate) struct Progress { + state: Mutex, + cv: Condvar, +} + +#[derive(Clone, Copy, Default)] +struct ProgressState { + rows: usize, + failed: bool, +} + +impl Progress { + fn new() -> Progress { + Progress { state: Mutex::new(ProgressState::default()), cv: Condvar::new() } + } + + /// Rows [0, rows) are final. A smaller value than already published is ignored. + pub fn publish(&self, rows: usize) { + #[cfg(test)] + tests::jitter(); + let mut g = self.state.lock().unwrap_or_else(|e| e.into_inner()); + if rows > g.rows { + g.rows = rows; + self.cv.notify_all(); + } + } + + /// The frame will publish no more rows. + pub fn fail(&self) { + let mut g = self.state.lock().unwrap_or_else(|e| e.into_inner()); + g.failed = true; + self.cv.notify_all(); + } + + /// Rows published so far. + #[cfg(test)] + fn rows(&self) -> usize { + self.state.lock().map(|g| g.rows).unwrap_or(0) + } + + /// Blocks until rows [0, rows) are final; an error when the frame failed first. + pub fn wait(&self, rows: usize) -> Result<()> { + #[cfg(test)] + tests::jitter(); + let mut g = self.state.lock().unwrap_or_else(|e| e.into_inner()); + loop { + if g.rows >= rows { + return Ok(()); + } + if g.failed { + return Err(Error::Invalid("reference frame failed to decode")); + } + g = self.cv.wait(g).unwrap_or_else(|e| e.into_inner()); + } + } +} + +/// Everything a decoding frame publishes for the frames that reference it and for the output: +/// its parse results, its final rows (bands, then the row progress) and the finished frame. The +/// parse results and the frame are set exactly once and the progress ends complete or failed, +/// also when decoding fails, so no waiter blocks forever. +pub(crate) struct FrameSlot { + parsed: Slot>, + pub progress: Progress, + /// The final samples, published band by band before the progress covers them (with + /// worker threads). + pub bands: Arc, + frame: Slot>, +} + +impl FrameSlot { + fn new(bands: BandFrame) -> Arc { + Arc::new(FrameSlot { parsed: Slot::new_plain(), progress: Progress::new(), bands: Arc::new(bands), frame: Slot::new_plain() }) + } + + /// The finished frame. + fn wait(&self) -> Result> { + self.frame.wait() + } + + fn is_set(&self) -> bool { + self.frame.is_set() + } + + /// The frame's parse results (available before its samples are final). + fn wait_parsed(&self) -> Result> { + self.parsed.wait() + } + + /// Publish the parse results (ignored when already set). + fn set_parsed(&self, v: Result>) { + self.parsed.set_once(v); + } + + /// Publish the finished frame: every row is final. On an error, the parse results (when + /// not yet published) and the progress fail too. + fn finish(&self, v: Result>, rows: usize) { + match &v { + Ok(_) => {} + Err(e) => { + self.parsed.set_once(Err(e.clone())); + } + } + let ok = v.is_ok(); + self.frame.set(v); + if ok { + self.progress.publish(rows); + } else { + self.progress.fail(); + } + } +} + /// A value produced by a decoding job, waited for by later jobs and by the output. pub(crate) struct Slot { value: Mutex>>, @@ -73,7 +213,11 @@ pub(crate) struct Slot { impl Slot { fn new() -> Arc> { - Arc::new(Slot { value: Mutex::new(None), cv: Condvar::new() }) + Arc::new(Slot::new_plain()) + } + + fn new_plain() -> Slot { + Slot { value: Mutex::new(None), cv: Condvar::new() } } fn set(&self, v: Result) { @@ -82,6 +226,15 @@ impl Slot { self.cv.notify_all(); } + /// [`Slot::set`] unless a value is already there. + fn set_once(&self, v: Result) { + let mut g = self.value.lock().unwrap_or_else(|e| e.into_inner()); + if g.is_none() { + *g = Some(v); + self.cv.notify_all(); + } + } + fn is_set(&self) -> bool { self.value.lock().map(|g| g.is_some()).unwrap_or(true) } @@ -108,8 +261,6 @@ impl Slot { } } -type FrameSlot = Slot>; - /// Everything needed to decode one frame, captured when its header is parsed. struct FrameJob { seq: SequenceHeader, @@ -130,6 +281,15 @@ struct FrameJob { draft: bool, #[cfg(test)] force_panic: bool, + /// Panic in the row wavefront at the first superblock row from this one after which rows + /// are published (tests). + #[cfg(test)] + panic_at_row: Option, + /// Overrides [`RECORD_BYTES_PER_SAMPLE`] (tests). + #[cfg(test)] + record_limit: Option, + /// The decoder's parse record budget. + record_budget: Arc, } /// A shown picture in output order. @@ -251,6 +411,8 @@ pub struct Decoder { draft: bool, stats: Arc>, pool: Pool, + /// Parse record bytes all frames in flight may hold together. + record_budget: Arc, #[cfg(all(feature = "threads", not(target_arch = "wasm32")))] workers: Option, /// Frames submitted to the workers and not known to be finished (oldest first). @@ -265,6 +427,14 @@ pub struct Decoder { /// Make every frame job panic (tests of the worker panic handling). #[cfg(test)] force_panic: bool, + /// (frame number, superblock row): that frame panics in the row wavefront after that row, + /// once it has published rows that later frames may already be using (tests). + #[cfg(test)] + panic_at_row: Option<(usize, usize)>, + #[cfg(test)] + record_limit: Option, + #[cfg(test)] + frame_number: usize, } fn default_threads() -> usize { @@ -278,10 +448,25 @@ fn default_threads() -> usize { } } -/// Frames decoded concurrently with `threads` threads (each in-flight 1080p frame holds a few -/// tens of MB of state). +/// Frame worker threads with `threads` threads. A frame worker spends most of its time waiting +/// for the parse results and rows of its references, so there is one per thread (at least two, +/// at most [`MAX_FRAME_THREADS`]); the memory is bounded by `in_flight_limit` instead. fn frame_threads(threads: usize) -> usize { - if threads <= 1 { 1 } else { threads.div_ceil(2).clamp(2, 8) } + if threads <= 1 { 1 } else { threads.clamp(2, MAX_FRAME_THREADS) } +} + +const MAX_FRAME_THREADS: usize = 16; + +/// Luma samples of the frames in flight (each in-flight frame holds its state, parse record and +/// samples, roughly 10 bytes per luma sample): ten 2160p frames. +#[cfg(all(feature = "threads", not(target_arch = "wasm32")))] +const IN_FLIGHT_SAMPLES: usize = 10 * 3840 * 2160; + +/// Frames submitted to the frame workers that may be unfinished: two more than the workers, +/// fewer for large frames (at least four). +#[cfg(all(feature = "threads", not(target_arch = "wasm32")))] +fn in_flight_limit(frame_threads: usize, luma_samples: usize) -> usize { + (frame_threads + 2).min((IN_FLIGHT_SAMPLES / luma_samples.max(1)).max(4)) } impl Default for Decoder { @@ -379,6 +564,7 @@ impl Decoder { draft: false, stats, pool, + record_budget: Arc::new(crate::av1::decode::tile::RecordBudget::new(RECORD_BUDGET_BYTES)), #[cfg(all(feature = "threads", not(target_arch = "wasm32")))] workers, in_flight: VecDeque::new(), @@ -388,6 +574,12 @@ impl Decoder { pts: 0, #[cfg(test)] force_panic: false, + #[cfg(test)] + panic_at_row: None, + #[cfg(test)] + record_limit: None, + #[cfg(test)] + frame_number: 0, } } @@ -655,6 +847,13 @@ impl Decoder { let picture = fh.show_frame.then(Slot::new); let draft = self.draft && fh.show_frame && fh.refresh_frame_flags == 0; let tile_count = fh.tile_info.cols.checked_mul(fh.tile_info.rows).ok_or(Error::Invalid("tile count overflows"))?; + let slot = FrameSlot::new(BandFrame::new( + fh.upscaled_width as usize, + fh.frame_height as usize, + seq.color.num_planes, + seq.color.subsampling_x as usize, + seq.color.subsampling_y as usize, + )); self.pending = Some(Box::new(FrameJob { seq, fh, @@ -662,14 +861,23 @@ impl Decoder { ref_info: self.refs.clone(), tiles: Vec::new(), tile_covered: vec![false; tile_count], - slot: Slot::new(), + slot, picture, pts: self.pts, apply_film_grain: self.apply_film_grain, draft, #[cfg(test)] force_panic: self.force_panic, + #[cfg(test)] + panic_at_row: self.panic_at_row.filter(|&(f, _)| f == self.frame_number).map(|(_, r)| r), + #[cfg(test)] + record_limit: self.record_limit, + record_budget: self.record_budget.clone(), })); + #[cfg(test)] + { + self.frame_number += 1; + } Ok(None) } @@ -767,6 +975,8 @@ impl Decoder { .clone() .map(|p| Output::Decoded(p, picture_bytes(job.fh.upscaled_width as usize, job.fh.frame_height as usize, &job.seq.color))); #[cfg(all(feature = "threads", not(target_arch = "wasm32")))] + let fh_samples = (fh.upscaled_width as usize).max(fh.frame_width as usize) * fh.frame_height as usize; + #[cfg(all(feature = "threads", not(target_arch = "wasm32")))] if let Some(w) = &self.workers && let Some(tx) = &w.tx { @@ -775,7 +985,8 @@ impl Decoder { Ok(()) => { self.in_flight.push_back(slot); // Bound the frames in flight (memory): wait for the oldest. - while self.in_flight.len() > self.max_in_flight { + let limit = in_flight_limit(w.handles.len(), fh_samples); + while self.in_flight.len() > limit { let Some(s) = self.in_flight.pop_front() else { break }; let _ = s.wait(); } @@ -796,18 +1007,19 @@ impl Decoder { fn run_job(job: FrameJob, pool: &Pool, stats: &Mutex) { let mut st = DecodeStats::default(); let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| decode_frame(&job, pool, &mut st))); + let rows = job.fh.frame_height as usize; match res.unwrap_or(Err(Error::Invalid("decoder panicked"))) { Ok((rf, pic)) => { if let Some(ps) = &job.picture { ps.set(pic.ok_or(Error::Invalid("shown frame without picture"))); } - job.slot.set(Ok(rf)); + job.slot.finish(Ok(rf), rows); } Err(e) => { if let Some(ps) = &job.picture { ps.set(Err(e.clone())); } - job.slot.set(Err(e)); + job.slot.finish(Err(e), rows); } } if let Ok(mut s) = stats.lock() { @@ -832,71 +1044,191 @@ fn decode_frame(job: &FrameJob, pool: &Pool, stats: &mut DecodeStats) -> Result< if fh.primary_ref_frame != PRIMARY_REF_NONE { used[fh.ref_frame_idx[fh.primary_ref_frame]] = true; } - let mut refs: [Option>; NUM_REF_FRAMES] = Default::default(); - for i in 0..NUM_REF_FRAMES { - if used[i] { - let slot = job.refs[i].as_ref().ok_or(Error::Invalid("missing reference frame"))?; - refs[i] = Some(slot.wait()?); + // Prediction reads the reference planes with this frame's chroma format. + if !fh.frame_is_intra { + for i in 0..NUM_REF_FRAMES { + let Some(slot) = job.refs[i].as_ref().filter(|_| used[i]) else { continue }; + let b = &slot.bands; + let c = &seq.color; + if b.num_planes != c.num_planes || b.subsampling_x != c.subsampling_x as usize || b.subsampling_y != c.subsampling_y as usize { + return Err(Error::Invalid("reference frame has another chroma format")); + } } } - let t = Timer::start(); - let mut fs = FrameState::new(seq, fh); - fs.refs = refs; - fs.ref_info = job.ref_info.clone(); + // Parse dependencies first, then the samples. Parsing reads the CDFs and segment ids of + // the primary reference frame, and the saved motion vectors of the inter references only + // with use_ref_frame_mvs; the parse results of the other references are not waited for + // (their failures still fail this frame through the waits for their samples below). + let mut parse_deps = [false; NUM_REF_FRAMES]; if fh.primary_ref_frame != PRIMARY_REF_NONE { - // load_previous_segment_ids( ) - let (mi_cols, mi_rows) = (fs.mi.cols, fs.mi.rows); - let sh = &mut fs.sh; - if let Some(rf) = &sh.refs[fh.ref_frame_idx[fh.primary_ref_frame]] - && fh.seg.enabled - && rf.mi_cols == mi_cols - && rf.mi_rows == mi_rows - { - sh.prev_segment_ids.copy_from_slice(&rf.segment_ids); - } + parse_deps[fh.ref_frame_idx[fh.primary_ref_frame]] = true; } if fh.use_ref_frame_mvs { - motion_field_estimation(&mut fs); + for i in 0..REFS_PER_FRAME { + parse_deps[fh.ref_frame_idx[i]] = true; + } } - let mut cdfs = if fh.primary_ref_frame == PRIMARY_REF_NONE { - Cdfs::new(fh.quant.base_q_idx) - } else { - let rf = fs.refs[fh.ref_frame_idx[fh.primary_ref_frame]].as_ref().ok_or(Error::Invalid("primary reference frame missing"))?; - let mut c = rf.cdfs.clone(); - c.clear_counts(); - c + let mut parsed: [Option>; NUM_REF_FRAMES] = Default::default(); + for i in 0..NUM_REF_FRAMES { + if parse_deps[i] { + let slot = job.refs[i].as_ref().ok_or(Error::Invalid("missing reference frame"))?; + parsed[i] = Some(slot.wait_parsed()?); + } + } + // The samples of the references predicted from (inter frames only). + let wait_samples = || -> Result<[Option>; NUM_REF_FRAMES]> { + let mut refs: [Option>; NUM_REF_FRAMES] = Default::default(); + if !fh.frame_is_intra { + for i in 0..NUM_REF_FRAMES { + if used[i] { + let slot = job.refs[i].as_ref().ok_or(Error::Invalid("missing reference frame"))?; + slot.progress.wait(job.ref_info[i].frame_height as usize)?; + refs[i] = Some(slot.wait()?); + } + } + } + Ok(refs) }; + // With worker threads, the symbols of every tile are read first, so the parse results + // (which the next frames need before they can read their own symbols) are published + // before reconstruction, and parsing does not wait for the reference samples; on one + // thread each block is reconstructed as it is read. + let split = pool.is_parallel(); + // The frame state before tile decoding (with the reference samples when `with_refs`). + let setup = |with_refs: bool| -> Result<(FrameState, Box)> { + let mut fs = FrameState::new(seq, fh); + if with_refs { + fs.refs = wait_samples()?; + } + fs.parsed = parsed.clone(); + fs.ref_info = job.ref_info.clone(); + if fh.primary_ref_frame != PRIMARY_REF_NONE { + // load_previous_segment_ids( ) + let (mi_cols, mi_rows) = (fs.mi.cols, fs.mi.rows); + let sh = &mut fs.sh; + if let Some(rf) = &sh.parsed[fh.ref_frame_idx[fh.primary_ref_frame]] + && fh.seg.enabled + && rf.mi_cols == mi_cols + && rf.mi_rows == mi_rows + { + sh.prev_segment_ids.copy_from_slice(&rf.segment_ids); + } + } + if fh.use_ref_frame_mvs { + motion_field_estimation(&mut fs); + } + let cdfs = if fh.primary_ref_frame == PRIMARY_REF_NONE { + Cdfs::new(fh.quant.base_q_idx) + } else { + let rf = fs.parsed[fh.ref_frame_idx[fh.primary_ref_frame]].as_ref().ok_or(Error::Invalid("primary reference frame missing"))?; + let mut c = rf.cdfs.clone(); + c.clear_counts(); + c + }; + Ok((fs, cdfs)) + }; + let t = Timer::start(); + let (mut fs, mut cdfs) = setup(!split)?; stats.add(Stage::Setup, t.secs()); let t = Timer::start(); - let saved = decode_tiles(pool, &mut fs, &cdfs, &job.tiles)?; + // Time spent waiting for reference samples is not decoding time. + let mut waited = 0.0; + #[cfg(not(test))] + let record_limit = RECORD_BYTES_PER_SAMPLE; + #[cfg(test)] + let record_limit = job.record_limit.unwrap_or(RECORD_BYTES_PER_SAMPLE); + let mut tiles = parse_tiles(pool, &mut fs, &cdfs, &job.tiles, if split { Pass::Parse } else { Pass::Full }, record_limit, &job.record_budget)?; + // A frame whose record would take too much memory (pathological streams) is decoded again + // in one pass, as on one thread. + let one_pass = split && tiles.records.iter().any(|(_, r)| r.over_limit()); + if one_pass { + // The fallback starts again from the tile data: release the records first. + drop(tiles); + let wait = Timer::start(); + (fs, cdfs) = setup(true)?; + waited = wait.secs(); + tiles = parse_tiles(pool, &mut fs, &cdfs, &job.tiles, Pass::Full, record_limit, &job.record_budget)?; + } stats.tiles += job.tiles.len() as u64; - stats.add(Stage::Tiles, t.secs()); if !fh.disable_frame_end_update_cdf - && let Some(s) = saved + && let Some(s) = tiles.saved.take() { cdfs = s; } - crate::av1::decode::postfilter::apply(&mut fs, stats, pool, job.draft); + if split && !one_pass { + if tiles.whole { + if let Some(state) = tiles.states.pop() { + fs.put_tile_state(state); + job.slot.set_parsed(Ok(Arc::new(parse_results(&fs, cdfs)))); + tiles.states.push(fs.take_tile_state()); + } + } else { + for state in &tiles.states { + fs.merge_tile_modes(state); + } + job.slot.set_parsed(Ok(Arc::new(parse_results(&fs, cdfs)))); + } + if !fh.use_superres { + if !tiles.whole { + // The tiles were parsed into private buffers, merged into the frame above: + // reconstruct them in the frame's own buffers. + tiles.states.clear(); + tiles.states.push(fs.take_tile_state()); + tiles.whole = true; + } + // Reconstruct superblock row by superblock row (every tile of the row), each + // waiting only for the reference rows it reads, with the in-loop filters following + // behind. + waited = reconstruct_wavefront(job, pool, &mut fs, &mut tiles, stats)?; + } else { + let wait = Timer::start(); + fs.refs = wait_samples()?; + waited = wait.secs(); + reconstruct_tiles(pool, &fs.sh, &mut tiles)?; + tiles.finish(&mut fs); + let f = Timer::start(); + if fh.use_superres { + crate::av1::decode::postfilter::apply(&mut fs, stats, pool, job.draft); + publish_bands(&job.slot, &fs.cur, 0, usize::MAX, fh.frame_height as usize); + } else { + let mut pipe = crate::av1::decode::postfilter::Pipeline::new(&fs, job.draft); + let done = pipe.advance(&mut fs, stats, pool, usize::MAX); + publish_final(&job.slot, done, fh.frame_height as usize); + } + waited += f.secs(); + } + } else { + tiles.finish(&mut fs); + job.slot.set_parsed(Ok(Arc::new(parse_results(&fs, cdfs)))); + } + stats.add(Stage::Tiles, t.secs() - waited); + if !split || one_pass { + crate::av1::decode::postfilter::apply(&mut fs, stats, pool, job.draft); + } + if one_pass { + publish_bands(&job.slot, &fs.cur, 0, usize::MAX, fh.frame_height as usize); + } + if split { + // A frame using a reference only for its parse results (an intra frame's CDFs) still + // fails with it, as it does on one thread. + for i in 0..NUM_REF_FRAMES { + if used[i] { + job.refs[i].as_ref().ok_or(Error::Invalid("missing reference frame"))?.wait()?; + } + } + } stats.draft_frames += job.draft as u64; let t = Timer::start(); stats.frames += 1; - if fh.seg.enabled && !fh.seg.update_map { - let prev = std::mem::take(&mut fs.prev_segment_ids); - fs.mi.segment_id.copy_from_slice(&prev); - } - let (mf_refs, mf_mvs) = motion_vector_storage(&fs); let rf = Arc::new(RefFrame { - buf: std::mem::take(&mut fs.cur), - cdfs, + // With worker threads the samples are in the published bands. + buf: if split { FrameBuf::default() } else { std::mem::take(&mut fs.cur) }, + bands: split.then(|| job.slot.bands.clone()), + num_planes: seq.color.num_planes, bit_depth: seq.color.bit_depth, subsampling_x: seq.color.subsampling_x, subsampling_y: seq.color.subsampling_y, - segment_ids: std::mem::take(&mut fs.mi.segment_id), - mi_cols: fs.mi.cols, - mi_rows: fs.mi.rows, color: (seq.color.color_primaries, seq.color.transfer_characteristics, seq.color.matrix_coefficients, seq.color.color_range), - saved_ref_frames: mf_refs, - saved_mvs: mf_mvs, }); // job.picture is None for a shown frame refused for its size (see tile_group) let pic = job.picture.is_some().then(|| { @@ -908,16 +1240,256 @@ fn decode_frame(job: &FrameJob, pool: &Pool, stats: &mut DecodeStats) -> Result< Ok((rf, pic)) } -/// Decode the tiles of a frame (tile number, data), in parallel when several; returns the final -/// CDFs of tile context_update_tile_id. -fn decode_tiles(pool: &Pool, fs: &mut FrameState, cdfs: &Cdfs, tiles: &[(usize, Vec)]) -> Result>> { +/// Publish bands [from, to) copied from the final samples `src`, and the row progress they make +/// final. +fn publish_bands(slot: &FrameSlot, src: &FrameBuf, from: usize, to: usize, height: usize) { + let to = to.min(slot.bands.bands()); + for b in from..to { + slot.bands.publish(b, src); + } + slot.progress.publish((to << crate::av1::decode::frame::BAND_LOG2).min(height)); +} + +/// Publish the bands that became final (in order, following those published before) and the +/// row progress they make final. +fn publish_final(slot: &FrameSlot, bands: crate::av1::decode::postfilter::FinalBands, height: usize) { + let mut end = None; + for (b, planes) in bands { + slot.bands.publish_owned(b, planes); + end = Some(b + 1); + } + if let Some(end) = end { + slot.progress.publish((end << crate::av1::decode::frame::BAND_LOG2).min(height)); + } +} + +/// Extra luma rows waited for below what a motion vector reaches: the 8-tap filters read 4 +/// rows below a block, chroma positions round, and the vertical sub-sample phase adds one. +const ROW_WAIT_MARGIN: usize = 16; + +/// The rows of each reference slot that reconstructing the blocks `blocks` (a superblock row +/// and the row above it, whose motion overlapped block motion compensation can reuse) reads, +/// for blocks ending at luma row `bottom`: their reach plus a margin, or everything +/// (`usize::MAX`) for warped motion and scaled references, whose reach is not bounded by the +/// motion vector. +fn rows_needed( + fh: &FrameHeader, + ref_info: &[RefInfo; NUM_REF_FRAMES], + blocks: impl Iterator, + bottom: usize, +) -> [usize; NUM_REF_FRAMES] { + let mut need = [0usize; NUM_REF_FRAMES]; + let mut used = [false; NUM_REF_FRAMES]; + let mut warp = false; + let global = (LAST_FRAME..=ALTREF_FRAME).any(|r| fh.gm_type[r] as usize > TRANSLATION); + for b in blocks { + if !b.inter { + continue; + } + if b.motion_mode as usize == LOCALWARP || (global && (b.y_mode == GLOBALMV || b.y_mode == GLOBAL_GLOBALMV)) { + warp = true; + } + let bottom = bottom.max((b.mi_row + b.bh4) * 4); + for list in 0..2 { + let rf = b.ref_frame[list]; + if rf <= INTRA_FRAME as i8 { + continue; + } + let Some(&i) = fh.ref_frame_idx.get(rf as usize - LAST_FRAME) else { continue }; + used[i] = true; + let ri = &ref_info[i]; + if ri.upscaled_width != fh.frame_width || ri.frame_height != fh.frame_height { + need[i] = usize::MAX; + continue; + } + let down = (b.mv[list][0].max(0) as usize).div_ceil(8); + need[i] = need[i].max(bottom.saturating_add(down).saturating_add(ROW_WAIT_MARGIN)); + } + } + if warp { + for i in 0..NUM_REF_FRAMES { + if used[i] { + need[i] = usize::MAX; + } + } + } + need +} + +/// Reconstructed luma rows between two runs of the in-loop filter pipeline in +/// [`reconstruct_wavefront`] (finer steps publish rows sooner, coarser ones filter more bands in +/// parallel). +const FILTER_STEP_ROWS: usize = 128; + +/// Reconstruct a frame superblock row by superblock row (row wavefront): before each row, wait +/// only for the reference rows it reads; then reconstruct that row in every tile it crosses +/// (tiles share no prediction context, so the order of the tiles within a row does not matter) +/// and run the in-loop filters on what that allows, publishing the bands that became final. +/// `tiles` holds the whole frame's buffers. Returns the seconds spent waiting for references +/// and filtering (not tile decoding). +fn reconstruct_wavefront(job: &FrameJob, pool: &Pool, fs: &mut FrameState, tiles: &mut FrameTiles, stats: &mut DecodeStats) -> Result { + let fh = &job.fh; + let mut other = 0.0; + let ti = fh.tile_info.clone(); + let Some(state) = tiles.states.pop() else { + return Err(Error::Invalid("no tile to reconstruct")); + }; + // The record of every tile, by tile number. + let mut recs: Vec> = (0..ti.rows * ti.cols).map(|_| None).collect(); + for (num, rec) in std::mem::take(&mut tiles.records) { + *recs.get_mut(num).ok_or(Error::Invalid("tile number out of range"))? = Some(rec); + } + let mut used = [false; NUM_REF_FRAMES]; + if !fh.frame_is_intra { + for i in 0..REFS_PER_FRAME { + used[fh.ref_frame_idx[i]] = true; + } + } + for i in 0..NUM_REF_FRAMES { + if used[i] { + let slot = job.refs[i].as_ref().ok_or(Error::Invalid("missing reference frame"))?; + fs.ref_rows[i] = Some(slot.bands.clone()); + } + } + fs.put_tile_state(state); + let mut pipe = crate::av1::decode::postfilter::Pipeline::new(fs, job.draft); + let sb4 = if job.seq.use_128x128_superblock { 32 } else { 16 }; + let mi_rows = fh.mi_rows as usize; + let sb_rows = mi_rows.div_ceil(sb4); + let mut bufs = (crate::av1::decode::tile::Buffers::new(), Cdfs::new(fh.quant.base_q_idx)); + let mut filtered = 0; + let mut tile_row = 0; + for row in 0..sb_rows { + // Tile rows start on superblock rows. + while tile_row + 1 < ti.rows && row * sb4 >= ti.mi_row_starts[tile_row + 1] as usize { + tile_row += 1; + } + let local = (row * sb4).saturating_sub(ti.mi_row_starts[tile_row] as usize) / sb4; + let w = Timer::start(); + if !fh.frame_is_intra { + let mut need = [0usize; NUM_REF_FRAMES]; + for col in 0..ti.cols { + let Some(rec) = &recs[tile_row * ti.cols + col] else { continue }; + let width = (ti.mi_col_starts[col + 1] as usize).min(fh.mi_cols as usize).saturating_sub(ti.mi_col_starts[col] as usize); + let n = rows_needed(fh, &job.ref_info, rec.row_blocks(width.div_ceil(sb4), local.saturating_sub(1), local + 1), (row + 1) * sb4 * 4); + for i in 0..NUM_REF_FRAMES { + need[i] = need[i].max(n[i]); + } + } + for i in 0..NUM_REF_FRAMES { + if used[i] && need[i] > 0 { + let slot = job.refs[i].as_ref().ok_or(Error::Invalid("missing reference frame"))?; + slot.progress.wait(need[i].min(job.ref_info[i].frame_height as usize))?; + } + } + } + other += w.secs(); + let mut t = fs.take_tile_state(); + let mut res = Ok(()); + for col in 0..ti.cols { + let Some(rec) = recs[tile_row * ti.cols + col].as_mut() else { continue }; + let (b, cdf) = bufs; + let mut td = TileDecoder::with_buffers(&fs.sh, &mut t, &[], cdf, tile_row, col, b); + td.pass = Pass::Reconstruct; + td.record = std::mem::take(rec); + res = td.reconstruct_sb_rows(1); + *rec = std::mem::take(&mut td.record); + bufs = td.into_buffers(); + if res.is_err() { + break; + } + } + fs.put_tile_state(t); + res?; + let f = Timer::start(); + let recon_rows = ((row + 1) * sb4 * 4).min(mi_rows * 4); + // Filter in steps of a few bands, so the bands of a step run in parallel. + if recon_rows >= filtered + FILTER_STEP_ROWS || recon_rows == mi_rows * 4 { + filtered = recon_rows; + let done = pipe.advance(fs, stats, pool, recon_rows); + publish_final(&job.slot, done, fh.frame_height as usize); + } + other += f.secs(); + #[cfg(test)] + assert!( + !(job.panic_at_row.is_some_and(|r| row >= r) && job.slot.progress.rows() > 0), + "forced panic in the row wavefront after publishing rows" + ); + } + // A reference that failed after publishing the rows used here still fails this frame, as + // it does when frames are decoded one after another. + for i in 0..NUM_REF_FRAMES { + if used[i] { + let slot = job.refs[i].as_ref().ok_or(Error::Invalid("missing reference frame"))?; + slot.wait()?; + } + } + Ok(other) +} + +/// Most bytes a tile's parse record may take per luma sample of the tile. Typical streams need +/// a fraction of this; past it (pathological streams: tiny blocks, large palettes, every +/// coefficient coded) the frame is decoded in one pass instead, so memory stays bounded. +const RECORD_BYTES_PER_SAMPLE: usize = 32; + +/// Most parse record bytes all frames of a decoder hold at once. Past it, the frames that +/// cannot reserve more are decoded in one pass, so the frames in flight together stay bounded +/// too (typical streams need a few bytes per luma sample: under 100 MB for a 2160p frame). +const RECORD_BUDGET_BYTES: usize = 1 << 30; + +/// The tiles of a frame between parsing and reconstruction. +struct FrameTiles { + /// One state per tile (decoded in parallel into private buffers), or one for the whole + /// frame (tiles one after another). + states: Vec, + /// Per tile: (tile number, record of [`Pass::Parse`]). + records: Vec<(usize, TileRecord)>, + /// The final CDFs of tile context_update_tile_id. + saved: Option>, + /// `states` holds the frame's own buffers (taken with [`FrameState::take_tile_state`]). + whole: bool, +} + +impl FrameTiles { + /// Move the tile buffers (mode info, filter parameters and, after reconstruction, the + /// samples) into the frame. + fn finish(self, fs: &mut FrameState) { + if self.whole { + if let Some(t) = self.states.into_iter().next() { + fs.put_tile_state(t); + } + } else { + for t in &self.states { + fs.merge_tile_state(t); + } + } + } +} + +/// Run `pass` (Full or Parse) over the tiles of a frame. +/// `record_limit`: most record bytes per luma sample of a tile (see [`RECORD_BYTES_PER_SAMPLE`]). +/// `budget`: the decoder-wide budget the records are reserved from. +fn parse_tiles( + pool: &Pool, + fs: &mut FrameState, + cdfs: &Cdfs, + tiles: &[(usize, Vec)], + pass: Pass, + record_limit: usize, + budget: &Arc, +) -> Result { let ti = fs.fh.tile_info.clone(); let ctx_tile = ti.context_update_tile_id as usize; - let run = |sh: &FrameShared, t: &mut TileState, num: usize, data: &[u8]| -> Result>> { + let run = |sh: &FrameShared, t: &mut TileState, num: usize, data: &[u8]| -> Result<(Option>, TileRecord)> { t.intra_frame_y_mode_cdf = DEFAULT_INTRA_FRAME_Y_MODE_CDF; let mut td = TileDecoder::new(sh, t, data, Box::new(cdfs.clone()), num / ti.cols, num % ti.cols); + td.pass = pass; + let (rows, cols) = (td.mi_row_end.saturating_sub(td.mi_row_start), td.mi_col_end.saturating_sub(td.mi_col_start)); + td.record.limit = rows.saturating_mul(cols).saturating_mul(16 * record_limit); + td.record.budget = Some(budget.clone()); td.decode_tile()?; - Ok((num == ctx_tile).then_some(td.cdf)) + let rec = std::mem::take(&mut td.record); + Ok(((num == ctx_tile).then_some(td.cdf), rec)) }; // Intra block copy reads the current frame through the tile's own buffer: keep whole-frame // buffers (tiles one after another) for it. @@ -933,42 +1505,75 @@ fn decode_tiles(pool: &Pool, fs: &mut FrameState, cdfs: &Cdfs, tiles: &[(usize, .collect(); let sh = &fs.sh; let results = pool.map_mut(&mut states, |i, t| run(sh, t, tiles[i].0, &tiles[i].1)); - for t in &states { - fs.merge_tile_state(t); - } let mut saved = None; - for r in results { - if let Some(c) = r? { - saved = Some(c); + let mut records = Vec::with_capacity(tiles.len()); + for (r, (num, _)) in results.into_iter().zip(tiles) { + let (c, rec) = r?; + if c.is_some() { + saved = c; } + records.push((*num, rec)); } - return Ok(saved); + return Ok(FrameTiles { states, records, saved, whole: false }); } let mut t = fs.take_tile_state(); let mut saved = None; + let mut records = Vec::with_capacity(tiles.len()); let mut res = Ok(()); for (num, data) in tiles { match run(&fs.sh, &mut t, *num, data) { - Ok(Some(c)) => saved = Some(c), - Ok(None) => {} + Ok((c, rec)) => { + if c.is_some() { + saved = c; + } + records.push((*num, rec)); + } Err(e) => { res = Err(e); break; } } } - fs.put_tile_state(t); - res.map(|_| saved) + if let Err(e) = res { + fs.put_tile_state(t); + return Err(e); + } + Ok(FrameTiles { states: vec![t], records, saved, whole: true }) +} + +/// Reconstruct parsed tiles (in parallel when each has its own state). +fn reconstruct_tiles(pool: &Pool, fs: &FrameShared, tiles: &mut FrameTiles) -> Result<()> { + let ti = fs.fh.tile_info.clone(); + let run = |t: &mut TileState, num: usize, rec: TileRecord| -> Result<()> { + let mut td = TileDecoder::new(fs, t, &[], Cdfs::new(fs.fh.quant.base_q_idx), num / ti.cols, num % ti.cols); + td.pass = Pass::Reconstruct; + td.record = rec; + td.decode_tile() + }; + let records = std::mem::take(&mut tiles.records); + if !tiles.whole { + let mut items: Vec<(&mut TileState, Option<(usize, TileRecord)>)> = tiles.states.iter_mut().zip(records.into_iter().map(Some)).collect(); + let results = pool.map_mut(&mut items, |_, (t, rec)| match rec.take() { + Some((num, rec)) => run(t, num, rec), + None => Ok(()), + }); + return results.into_iter().collect(); + } + let Some(t) = tiles.states.first_mut() else { return Ok(()) }; + for (num, rec) in records { + run(t, num, rec)?; + } + Ok(()) } fn output_picture(seq: &SequenceHeader, rf: &RefFrame, w: usize, h: usize, grain: &FilmGrainParams, apply_film_grain: bool, pts: i64) -> Picture { let ssx = rf.subsampling_x as usize; let ssy = rf.subsampling_y as usize; - let num_planes = rf.buf.num_planes; + let num_planes = rf.num_planes; let mut planes: [Vec; 3] = Default::default(); for p in 0..num_planes { let (pw, ph) = if p == 0 { (w, h) } else { ((w + ssx) >> ssx, (h + ssy) >> ssy) }; - let src = &rf.buf.planes[p]; + let src = rf.plane(p); let mut v = Vec::with_capacity(pw * ph); for y in 0..ph { v.extend_from_slice(&src.row(y)[..pw]); @@ -996,25 +1601,40 @@ fn output_picture(seq: &SequenceHeader, rf: &RefFrame, w: usize, h: usize, grain pic } -/// Motion field motion vector storage process (7.19): (MfRefFrames, MfMvs). +/// What later frames read from this one while parsing: the final CDFs, the segment ids (the +/// previous frame's when the map is not updated) and the stored motion vectors (7.19). The +/// in-loop filters read the decoded segment ids, so the frame's own map is left alone. +fn parse_results(fs: &FrameState, cdfs: Box) -> Parsed { + let fh = &fs.fh; + let segment_ids = if fh.seg.enabled && !fh.seg.update_map { fs.prev_segment_ids.clone() } else { fs.mi.segment_id.clone() }; + let (saved_ref_frames, saved_mvs) = motion_vector_storage(fs); + Parsed { cdfs, segment_ids, mi_cols: fs.mi.cols, mi_rows: fs.mi.rows, saved_ref_frames, saved_mvs } +} + +/// Motion field motion vector storage process (7.19): (MfRefFrames, MfMvs), kept only where +/// the projection process (7.9.2) reads them, the odd row and column of every 8x8 block +/// (index `y8 * (MiCols >> 1) + x8`). fn motion_vector_storage(fs: &FrameState) -> (Vec, Vec<[i32; 2]>) { let mi = &fs.mi; - let n = mi.rows * mi.cols; - let mut refs = vec![-1i8; n]; - let mut mvs = vec![[0i32; 2]; n]; let fh = &fs.fh; - for i in 0..n { - for list in 0..2 { - let r = mi.ref_frame[i][list]; - if r > INTRA_FRAME as i8 { - let ref_idx = fh.ref_frame_idx[r as usize - LAST_FRAME]; - let dist = crate::av1::decode::header::relative_dist(&fs.seq, fs.ref_info[ref_idx].order_hint, fh.order_hint); - if dist < 0 { - let m = mi.mv[i][list]; - let (row, col) = (m.row as i32, m.col as i32); - if row.abs() <= REFMVS_LIMIT as i32 && col.abs() <= REFMVS_LIMIT as i32 { - refs[i] = r; - mvs[i] = [row, col]; + let (mi_cols, w8, h8) = (fh.mi_cols as usize, fh.mi_cols as usize >> 1, fh.mi_rows as usize >> 1); + let mut refs = vec![-1i8; w8 * h8]; + let mut mvs = vec![[0i32; 2]; w8 * h8]; + for y8 in 0..h8 { + for x8 in 0..w8 { + let (i, o) = ((2 * y8 + 1) * mi_cols + 2 * x8 + 1, y8 * w8 + x8); + for list in 0..2 { + let r = mi.ref_frame[i][list]; + if r > INTRA_FRAME as i8 { + let ref_idx = fh.ref_frame_idx[r as usize - LAST_FRAME]; + let dist = crate::av1::decode::header::relative_dist(&fs.seq, fs.ref_info[ref_idx].order_hint, fh.order_hint); + if dist < 0 { + let m = mi.mv[i][list]; + let (row, col) = (m.row as i32, m.col as i32); + if row.abs() <= REFMVS_LIMIT as i32 && col.abs() <= REFMVS_LIMIT as i32 { + refs[o] = r; + mvs[o] = [row, col]; + } } } } @@ -1072,7 +1692,7 @@ fn project_pos(v8: i32, delta: i32, dst_sign: i32, max8: i32, max_off8: i32) -> /// Projection process (7.9.2). fn project(fs: &mut FrameState, src: usize, dst_sign: i32) -> bool { - let FrameShared { seq, fh, refs, ref_info, motion_field, .. } = &mut fs.sh; + let FrameShared { seq, fh, parsed, ref_info, motion_field, .. } = &mut fs.sh; let src_idx = fh.ref_frame_idx[src - LAST_FRAME]; let w8 = fh.mi_cols as i32 >> 1; let h8 = fh.mi_rows as i32 >> 1; @@ -1080,20 +1700,18 @@ fn project(fs: &mut FrameState, src: usize, dst_sign: i32) -> bool { if ri.mi_rows != fh.mi_rows || ri.mi_cols != fh.mi_cols || ri.frame_type == INTRA_ONLY_FRAME as u8 || ri.frame_type == KEY_FRAME as u8 { return false; } - let Some(rf) = &refs[src_idx] else { return false }; + let Some(rf) = &parsed[src_idx] else { return false }; let rd = |a: u32, b: u32| crate::av1::decode::header::relative_dist(seq, a, b); - let mi_cols = fh.mi_cols as usize; for y8 in 0..h8 { for x8 in 0..w8 { - let row = (2 * y8 + 1) as usize; - let col = (2 * x8 + 1) as usize; - let src_ref = rf.saved_ref_frames[row * mi_cols + col]; + let at = (y8 * w8 + x8) as usize; + let src_ref = rf.saved_ref_frames[at]; if src_ref > INTRA_FRAME as i8 { let ref_to_cur = rd(fh.order_hints[src], fh.order_hint); let ref_offset = rd(fh.order_hints[src], ri.saved_order_hints[src_ref as usize]); let pos_valid = ref_to_cur.abs() <= MAX_FRAME_DISTANCE as i32 && ref_offset.abs() <= MAX_FRAME_DISTANCE as i32 && ref_offset > 0; if pos_valid { - let mv = rf.saved_mvs[row * mi_cols + col]; + let mv = rf.saved_mvs[at]; let proj = get_mv_projection(mv, ref_to_cur * dst_sign, ref_offset); let py = project_pos(y8, proj[0], dst_sign, h8, MAX_OFFSET_HEIGHT as i32); let px = project_pos(x8, proj[1], dst_sign, w8, MAX_OFFSET_WIDTH as i32); @@ -1125,13 +1743,18 @@ mod tests { ref_info: Default::default(), tiles: Vec::new(), tile_covered: vec![false; 3], - slot: Slot::new(), + slot: FrameSlot::new(BandFrame::new(0, 0, 1, 0, 0)), picture: None, pts: 0, apply_film_grain: false, draft: false, #[cfg(test)] force_panic: false, + #[cfg(test)] + panic_at_row: None, + #[cfg(test)] + record_limit: None, + record_budget: decoder.record_budget.clone(), })); decoder } @@ -1278,6 +1901,317 @@ mod tests { assert!(frame_size_allowed(1, 1)); } + /// Random short sleeps in row progress publishing and waiting, to shake out scheduling + /// orders a quiet machine never produces (enabled by [`JitterGuard`]). + static JITTER: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0); + + pub(super) fn jitter() { + use std::cell::Cell; + use std::sync::atomic::Ordering; + if JITTER.load(Ordering::Relaxed) == 0 { + return; + } + static SEED: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0x2545_f491_4f6c_dd1d); + thread_local!(static RNG: Cell = Cell::new(SEED.fetch_add(0x9e37_79b9_7f4a_7c15, Ordering::Relaxed) | 1)); + let r = RNG.with(|c| { + let mut x = c.get(); + x ^= x << 13; + x ^= x >> 7; + x ^= x << 17; + c.set(x); + x + }); + match r % 4 { + 0 => std::thread::yield_now(), + 1 => std::thread::sleep(std::time::Duration::from_micros(r % 300)), + _ => {} + } + } + + struct JitterGuard; + impl JitterGuard { + fn on() -> JitterGuard { + JITTER.fetch_add(1, std::sync::atomic::Ordering::SeqCst); + JitterGuard + } + } + impl Drop for JitterGuard { + fn drop(&mut self) { + JITTER.fetch_sub(1, std::sync::atomic::Ordering::SeqCst); + } + } + + /// Inter test streams made with ffmpeg / SVT-AV1 (None, reported, without them): several + /// superblock rows and hierarchical references; odd size; super-resolution; 2x2 tiles. + const STREAMS: [(&str, &str, &str); 4] = [ + ("wavefront_unit_352x288", "testsrc2=size=352x288:rate=25", "-preset 8 -crf 35"), + ("wavefront_unit_odd", "testsrc2=size=203x117:rate=25,noise=alls=15:allf=t", "-preset 8 -crf 40"), + ("wavefront_unit_superres", "testsrc2=size=416x240:rate=25", "-preset 8 -crf 35 -svtav1-params superres-mode=1:superres-denom=12"), + ("wavefront_unit_tiles", "mandelbrot=size=650x370:rate=25", "-preset 8 -crf 32 -svtav1-params tile-columns=1:tile-rows=1"), + ]; + + fn inter_stream((name, src, args): (&str, &str, &str)) -> Option>> { + let ff = craft_media_testkit::ffmpeg_or_skip("av1 wavefront")?; + if !craft_media_testkit::ffmpeg_has_encoder(&ff, "libsvtav1") { + craft_media_testkit::skip_test("av1 wavefront", "this ffmpeg has no libsvtav1 encoder"); + return None; + } + let out = craft_media_testkit::fixtures_dir("av1").join(format!("{name}.ivf")); + let path = craft_media_testkit::fixtures::generate(&out, |tmp| { + std::process::Command::new(&ff) + .args([ + "-hide_banner", + "-loglevel", + "error", + "-y", + "-f", + "lavfi", + "-i", + src, + "-frames:v", + "16", + "-pix_fmt", + "yuv420p", + "-c:v", + "libsvtav1", + ]) + .args(args.split_whitespace()) + .args(["-f", "ivf"]) + .arg(tmp) + .stdin(std::process::Stdio::null()) + .status() + .is_ok_and(|s| s.success()) + }); + let path = path.unwrap_or_else(|| panic!("ffmpeg has libsvtav1 but could not encode {name}")); + let d = std::fs::read(&path).unwrap_or_else(|e| panic!("read {}: {e}", path.display())); + let mut pos = usize::from(u16::from_le_bytes([d[6], d[7]])); + let mut out = Vec::new(); + while let Some(h) = d.get(pos..pos + 12) { + let n = u32::from_le_bytes([h[0], h[1], h[2], h[3]]) as usize; + pos += 12; + out.push(d[pos..pos + n].to_vec()); + pos += n; + } + assert_eq!(out.len(), 16, "{name}: temporal units"); + Some(out) + } + + /// Decode `tus` with `dec`: (pictures, errors). + fn decode_tus(mut dec: Decoder, tus: &[Vec]) -> (Vec, usize) { + let (mut pics, mut errors) = (Vec::new(), 0); + for (i, tu) in tus.iter().enumerate() { + match dec.decode_pts(tu, i as i64) { + Ok(p) => pics.extend(p), + Err(_) => errors += 1, + } + } + match dec.flush_result() { + Ok(p) => pics.extend(p), + Err(_) => errors += 1, + } + (pics, errors) + } + + #[test] + fn jittered_wavefront_gives_the_single_thread_pictures() { + for stream in STREAMS { + let Some(tus) = inter_stream(stream) else { return }; + let name = stream.0; + let (want, errors) = decode_tus(Decoder::with_threads(1), &tus); + assert_eq!(errors, 0, "{name}"); + let _jitter = JitterGuard::on(); + for threads in [2, 3, 5, 8] { + for round in 0..2 { + let tus = tus.clone(); + let (got, errors) = within_a_minute(move || decode_tus(Decoder::with_threads(threads), &tus)); + assert_eq!(errors, 0, "{name}: threads {threads} round {round}"); + assert!(got == want, "{name}: threads {threads} round {round}: pictures differ"); + } + } + } + } + + #[test] + fn frames_over_the_record_limit_decode_in_one_pass() { + for stream in [STREAMS[0], STREAMS[3]] { + let Some(tus) = inter_stream(stream) else { return }; + let name = stream.0; + let (want, _) = decode_tus(Decoder::with_threads(1), &tus); + for (threads, limit) in [(3, 0), (8, 0), (8, 1)] { + let tus = tus.clone(); + let (got, errors) = within_a_minute(move || { + let mut dec = Decoder::with_threads(threads); + dec.record_limit = Some(limit); + decode_tus(dec, &tus) + }); + assert_eq!(errors, 0, "{name}: threads {threads}, limit {limit}"); + assert!(got == want, "{name}: threads {threads}, limit {limit}: pictures differ"); + } + } + } + + #[test] + fn the_parse_records_of_all_frames_stay_within_the_decoder_budget() { + for stream in [STREAMS[0], STREAMS[3]] { + let Some(tus) = inter_stream(stream) else { return }; + let name = stream.0; + let (want, _) = decode_tus(Decoder::with_threads(1), &tus); + // Room for about one frame's records: the other frames in flight decode in one pass. + for (threads, budget) in [(3, 0), (8, 3 << 20), (16, 1 << 20)] { + let tus = tus.clone(); + let b = Arc::new(crate::av1::decode::tile::RecordBudget::new(budget)); + let mut dec = Decoder::with_threads(threads); + dec.record_budget = b.clone(); + let (got, errors) = within_a_minute(move || decode_tus(dec, &tus)); + assert_eq!(errors, 0, "{name}: threads {threads}, budget {budget}"); + assert!(got == want, "{name}: threads {threads}, budget {budget}: pictures differ"); + assert!(b.peak.load(std::sync::atomic::Ordering::Acquire) <= budget, "{name}: threads {threads}: over the budget"); + assert_eq!(b.used(), 0, "{name}: threads {threads}: records not released"); + } + } + } + + #[cfg(all(feature = "threads", not(target_arch = "wasm32")))] + #[test] + fn a_reference_panicking_after_publishing_rows_fails_without_a_hang() { + let Some(tus) = inter_stream(STREAMS[0]) else { return }; + let _jitter = JitterGuard::on(); + // Frame 1 is the first inter frame; later frames predict from it. + for threads in [2, 3, 8] { + for frame in [0, 1, 2] { + let tus = tus.clone(); + let (pics, errors) = within_a_minute(move || { + let mut dec = Decoder::with_threads(threads); + dec.panic_at_row = Some((frame, 1)); + decode_tus(dec, &tus) + }); + assert!(errors > 0, "threads {threads}, frame {frame}: the panic was not reported ({} pictures)", pics.len()); + } + } + } + + #[test] + fn dropping_a_busy_decoder_does_not_hang() { + let Some(tus) = inter_stream(STREAMS[0]) else { return }; + for threads in [2, 3, 8, 16] { + for cut in [1, 3, tus.len() / 2] { + let tus = tus.clone(); + within_a_minute(move || { + let mut dec = Decoder::with_threads(threads); + for (i, tu) in tus.iter().take(cut).enumerate() { + let _ = dec.decode_pts(tu, i as i64); + } + drop(dec); + }); + } + } + } + + #[test] + fn a_flush_mid_stream_keeps_the_pictures() { + let Some(tus) = inter_stream(STREAMS[0]) else { return }; + let (want, _) = decode_tus(Decoder::with_threads(1), &tus); + for threads in [2, 8] { + for cut in [2, 5, tus.len() / 2] { + let tus = tus.clone(); + let got = within_a_minute(move || { + let mut dec = Decoder::with_threads(threads); + let mut pics = Vec::new(); + for (i, tu) in tus.iter().enumerate() { + if i == cut { + pics.extend(dec.flush_result().expect("flush")); + } + pics.extend(dec.decode_pts(tu, i as i64).expect("decode")); + } + pics.extend(dec.flush_result().expect("flush")); + pics + }); + assert!(got == want, "threads {threads}, flush before unit {cut}"); + } + } + } + + #[test] + fn progress_wakes_every_waiter_with_the_rows_or_the_failure() { + let p = Arc::new(Progress::new()); + let waiters: Vec<_> = (1..=8) + .map(|k| { + let p = p.clone(); + std::thread::spawn(move || p.wait(k * 10)) + }) + .collect(); + p.publish(40); + p.publish(20); // never goes back + assert_eq!(p.wait(40), Ok(())); + p.fail(); + let res: Vec<_> = waiters.into_iter().map(|w| w.join().expect("waiter")).collect(); + assert!(res[..4].iter().all(|r| r.is_ok()), "{res:?}"); + assert!(res[4..].iter().all(|r| r.is_err()), "{res:?}"); + assert_eq!(p.wait(40), Ok(()), "rows published before a failure stay readable"); + } + + #[test] + fn a_failed_frame_keeps_its_published_parse_results() { + let slot = FrameSlot::new(BandFrame::new(16, 16, 1, 0, 0)); + let parsed = Parsed { cdfs: Cdfs::new(0), segment_ids: vec![], mi_cols: 4, mi_rows: 4, saved_ref_frames: vec![], saved_mvs: vec![] }; + slot.set_parsed(Ok(Arc::new(parsed))); + slot.finish(Err(Error::Invalid("x")), 16); + assert!(slot.wait_parsed().is_ok()); + assert!(slot.wait().is_err()); + assert!(slot.progress.wait(1).is_err()); + // A frame failing before its parse results: every waiter gets the error. + let slot = FrameSlot::new(BandFrame::new(16, 16, 1, 0, 0)); + slot.finish(Err(Error::Invalid("y")), 16); + assert!(slot.wait_parsed().is_err()); + } + + fn motion(mi_row: usize, bh4: usize, ref_frame: [i8; 2], mv: [[i32; 2]; 2]) -> crate::av1::decode::tile::BlockMotion { + crate::av1::decode::tile::BlockMotion { + mi_row, + bh4, + inter: true, + ref_frame, + mv, + motion_mode: 0, + y_mode: crate::av1::decode::spec_tables::NEARESTMV, + } + } + + #[test] + fn rows_needed_follow_the_motion_vectors() { + let mut fh = FrameHeader { frame_width: 64, upscaled_width: 64, frame_height: 256, ..Default::default() }; + fh.ref_frame_idx = [0, 1, 2, 3, 4, 5, 6]; + let mut ri: [RefInfo; NUM_REF_FRAMES] = Default::default(); + for r in ri.iter_mut() { + (r.upscaled_width, r.frame_height) = (64, 256); + } + let none = [[0; 2]; 2]; + // 41/8 rows down rounds up to 6; upward motion needs only the block's own rows. + let need = rows_needed(&fh, &ri, [motion(0, 16, [1, -1], [[41, 0], [0, 0]]), motion(0, 16, [2, 3], [[-80, 0], [7, 0]])].into_iter(), 64); + assert_eq!(need[0], 64 + 6 + ROW_WAIT_MARGIN); + assert_eq!(need[1], 64 + ROW_WAIT_MARGIN); + assert_eq!(need[2], 64 + 1 + ROW_WAIT_MARGIN); + assert_eq!(need[3], 0); + // Intra blocks and intra block copy read no reference. + let intra = crate::av1::decode::tile::BlockMotion { inter: false, ..motion(0, 16, [1, -1], none) }; + assert_eq!(rows_needed(&fh, &ri, [intra].into_iter(), 64), [0; NUM_REF_FRAMES]); + // Blocks reaching below the superblock row count from their own bottom. + assert_eq!(rows_needed(&fh, &ri, [motion(12, 8, [1, -1], none)].into_iter(), 64)[0], 80 + ROW_WAIT_MARGIN); + // Local warp: the whole of every reference the rows use. + let warp = + crate::av1::decode::tile::BlockMotion { motion_mode: crate::av1::decode::spec_tables::LOCALWARP as u8, ..motion(0, 16, [1, -1], none) }; + let need = rows_needed(&fh, &ri, [warp, motion(0, 16, [2, -1], none)].into_iter(), 64); + assert_eq!((need[0], need[1], need[2]), (usize::MAX, usize::MAX, 0)); + // Global motion beyond translation for GLOBALMV blocks. + fh.gm_type[3] = (TRANSLATION + 1) as u8; + let global = crate::av1::decode::tile::BlockMotion { y_mode: GLOBALMV, ..motion(0, 16, [1, -1], none) }; + assert_eq!(rows_needed(&fh, &ri, [global].into_iter(), 64)[0], usize::MAX); + fh.gm_type[3] = 0; + // A scaled reference. + ri[0].frame_height = 128; + assert_eq!(rows_needed(&fh, &ri, [motion(0, 16, [1, -1], none)].into_iter(), 64)[0], usize::MAX); + } + #[test] fn frames_beyond_the_limits_are_refused() { assert!(!frame_size_allowed(16384, 2177)); // one row over MaxPicSize diff --git a/crates/video/src/av1/decode/frame.rs b/crates/video/src/av1/decode/frame.rs index d0432e2a8..e28ca89e9 100644 --- a/crates/video/src/av1/decode/frame.rs +++ b/crates/video/src/av1/decode/frame.rs @@ -197,6 +197,50 @@ impl FrameBuf { } } + /// Copy luma rows [y0, y1) (chroma rows scaled down; clipped to the stored rows) of `src`, a + /// frame of the same geometry. + pub fn copy_rows_from(&mut self, src: &FrameBuf, y0: usize, y1: usize) { + for p in 0..self.num_planes { + let sy = if p == 0 { 0 } else { self.subsampling_y }; + let (d, s) = (&mut self.planes[p], &src.planes[p]); + if d.stride != s.stride { + continue; + } + let a = (y0 >> sy).min(d.rows).min(s.rows) * d.stride; + let b = (y1 >> sy).min(d.rows).min(s.rows) * d.stride; + if let (Some(dst), Some(src)) = (d.data.get_mut(a..b), s.data.get(a..b)) { + dst.copy_from_slice(src); + } + } + } + + /// Copies of luma rows [y0, y1) (chroma rows scaled down; clipped to the stored rows), one + /// plane region each. + pub fn rows_copy(&self, y0: usize, y1: usize) -> [Plane; 3] { + std::array::from_fn(|p| { + if p >= self.num_planes { + return Plane::default(); + } + let sy = if p == 0 { 0 } else { self.subsampling_y }; + let s = &self.planes[p]; + let (a, b) = ((y0 >> sy).min(s.rows), (y1 >> sy).min(s.rows)); + let mut out = Plane::region(0, a, s.stride, b - a); + if let Some(src) = s.data.get(a * s.stride..b * s.stride) { + out.data.copy_from_slice(src); + } + out + }) + } + + /// A frame of this geometry (samples not copied: zero). + pub fn same_geometry(&self) -> FrameBuf { + let planes = std::array::from_fn(|p| { + let pl = &self.planes[p]; + Plane { data: zeroed(pl.data.len()), stride: pl.stride, rows: pl.rows, ox: pl.ox, oy: pl.oy } + }); + FrameBuf { planes, ..*self } + } + /// [`Plane::row_bands`] of all three planes for ranges of luma rows (chroma rows scaled /// down): element `i` holds the bands of range `i`. pub fn row_bands(&mut self, luma: &[(usize, usize)]) -> Vec<[RowBand<'_>; 3]> { @@ -208,6 +252,128 @@ impl FrameBuf { } } +/// Luma rows per published band of a [`BandFrame`] (log2). +pub const BAND_LOG2: u32 = 6; + +/// One plane of a frame's final samples, published band by band while the rest of the frame +/// is still being decoded (see [`BandFrame`]). A band is written once and then only read. +pub struct BandPlane { + bands: Vec>, + stride: usize, + rows: usize, + log2: u32, + /// Returned for rows of a band that is not published: zeros instead of a panic. Readers wait + /// for the row progress first and references of another chroma format are refused, so + /// this only happens through a scheduling bug. + missing: Box<[u16]>, +} + +impl BandPlane { + fn new(stride: usize, rows: usize, log2: u32) -> BandPlane { + let n = rows.div_ceil(1 << log2); + BandPlane { bands: (0..n).map(|_| std::sync::OnceLock::new()).collect(), stride, rows, log2, missing: vec![0; stride].into_boxed_slice() } + } + + /// Row `y` (`stride` samples) of a published band. + #[inline(always)] + pub fn row(&self, y: usize) -> &[u16] { + let o = (y & ((1 << self.log2) - 1)) * self.stride; + match self.bands.get(y >> self.log2).and_then(|b| b.get()).and_then(|b| b.data.get(o..o + self.stride)) { + Some(r) => r, + None => { + debug_assert!(false, "row {y} read before its band was published"); + &self.missing + } + } + } + + /// Publish band `band` copied from the rows of the whole plane `src` (same geometry); a + /// band is published once. + fn publish(&self, band: usize, src: &Plane) { + let y0 = band << self.log2; + let y1 = ((band + 1) << self.log2).min(self.rows); + let mut p = Plane::region(0, y0, self.stride, y1.saturating_sub(y0)); + let w = self.stride.min(src.stride); + for (y, out) in (y0..y1).zip(p.data.chunks_exact_mut(self.stride.max(1))) { + if let Some(r) = src.data.get(y * src.stride..y * src.stride + w) { + out[..w].copy_from_slice(r); + } + } + self.publish_owned(band, p); + } + + /// Publish band `band` as `p`, whose rows start at the band's first row (stride `stride`; + /// rows past the band are ignored). + fn publish_owned(&self, band: usize, p: Plane) { + if let Some(slot) = self.bands.get(band) + && p.stride == self.stride + { + let _ = slot.set(p); + } + } +} + +/// A frame's final samples (every in-loop filter applied) in bands of 64 luma rows, so later +/// frames can predict from the top of a reference while its bottom is still being decoded. +/// Each band is published once, before the frame's row progress says it is final. +pub struct BandFrame { + pub planes: [BandPlane; 3], + pub num_planes: usize, + pub subsampling_x: usize, + pub subsampling_y: usize, +} + +impl BandFrame { + /// Bands for the visible rows of a `width` x `height` frame stored like [`FrameBuf::new`]. + pub fn new(width: usize, height: usize, num_planes: usize, subsampling_x: usize, subsampling_y: usize) -> BandFrame { + let aw = width.div_ceil(128) * 128 + 160; + let planes = std::array::from_fn(|p| { + if p >= num_planes { + return BandPlane::new(0, 0, BAND_LOG2); + } + let (sx, sy) = if p == 0 { (0, 0) } else { (subsampling_x, subsampling_y) }; + BandPlane::new(aw >> sx, (height + sy) >> sy, BAND_LOG2 - sy as u32) + }); + BandFrame { planes, num_planes, subsampling_x, subsampling_y } + } + + /// Number of bands (of 64 luma rows). + pub fn bands(&self) -> usize { + self.planes[0].bands.len() + } + + /// Publish luma band `band` (and the chroma rows it covers) copied from `src`. + pub fn publish(&self, band: usize, src: &FrameBuf) { + for p in 0..self.num_planes { + self.planes[p].publish(band, &src.planes[p]); + } + } + + /// Publish luma band `band` from per-plane buffers starting at the band's first row. + pub fn publish_owned(&self, band: usize, planes: [Plane; 3]) { + for (p, pl) in planes.into_iter().enumerate().take(self.num_planes) { + self.planes[p].publish_owned(band, pl); + } + } +} + +/// A plane to predict from: a whole stored plane or the published bands of a reference. +#[derive(Clone, Copy)] +pub enum PlaneRef<'a> { + Whole(&'a Plane), + Bands(&'a BandPlane), +} + +impl<'a> PlaneRef<'a> { + #[inline(always)] + pub fn row(&self, y: usize) -> &'a [u16] { + match *self { + PlaneRef::Whole(p) => p.row(y), + PlaneRef::Bands(b) => b.row(y), + } + } +} + /// A motion vector (row, col) in 1/8 sample units. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub struct Mv { diff --git a/crates/video/src/av1/decode/inter.rs b/crates/video/src/av1/decode/inter.rs index 8b40717a3..8d80e96b0 100644 --- a/crates/video/src/av1/decode/inter.rs +++ b/crates/video/src/av1/decode/inter.rs @@ -3,7 +3,7 @@ use std::sync::OnceLock; -use crate::av1::decode::frame::Plane; +use crate::av1::decode::frame::{Plane, PlaneRef}; use crate::av1::decode::mvpred::round2_signed64; use crate::av1::decode::spec_tables::{ BLOCK_8X8, BLOCK_SIZES, COMPOUND_AVERAGE, COMPOUND_DIFFWTD, COMPOUND_DISTANCE, COMPOUND_INTRA, COMPOUND_WEDGE, DIV_LUT, DIV_LUT_BITS, @@ -227,12 +227,9 @@ impl TileDecoder<'_, '_> { (start_x as i32, start_y as i32, step_x as i32, step_y as i32) } - fn ref_plane(&self, ref_idx: i32, plane: usize) -> &Plane { + fn ref_plane(&self, ref_idx: i32, plane: usize) -> PlaneRef<'_> { // A missing reference (rejected earlier for valid streams) predicts from the current frame. - match usize::try_from(ref_idx).ok().and_then(|i| self.fs.refs.get(i)).and_then(|r| r.as_ref()) { - Some(r) => &r.buf.planes[plane], - None => &self.t.cur.planes[plane], - } + self.fs.ref_samples(ref_idx, plane).unwrap_or(PlaneRef::Whole(&self.t.cur.planes[plane])) } /// Block inter prediction process (7.11.3.4) into `pred` (stride PRED_STRIDE); `tmp` holds @@ -512,12 +509,12 @@ impl TileDecoder<'_, '_> { return false; } let fs = self.fs; - let Some(r) = usize::try_from(ref_idx).ok().and_then(|i| fs.refs.get(i)).and_then(|r| r.as_ref()) else { + let Some(refp) = fs.ref_samples(ref_idx, plane) else { return false; }; let dims = self.ref_plane_dims(ref_idx, plane); let max = ((1u32 << fs.bit_depth) - 1) as u16; - copy_fullpel(&r.buf.planes[plane], dims, McBlock { x: sx, y: sy, w, h }, &mut self.t.cur.planes[plane], (x, y), max); + copy_fullpel(refp, dims, McBlock { x: sx, y: sy, w, h }, &mut self.t.cur.planes[plane], (x, y), max); true } @@ -763,7 +760,7 @@ impl TileDecoder<'_, '_> { /// Unscaled single-reference prediction at a whole-sample position: both filter phases are the /// identity and Round2(128 * Round2(128 * v, InterRound0), InterRound1) == v for every bit /// depth, so the prediction is the (clamped) reference sample. -fn copy_fullpel(refp: &Plane, (last_x, last_y): (i32, i32), src_blk: McBlock, dst: &mut Plane, (dx, dy): (usize, usize), max: u16) { +fn copy_fullpel(refp: PlaneRef, (last_x, last_y): (i32, i32), src_blk: McBlock, dst: &mut Plane, (dx, dy): (usize, usize), max: u16) { let McBlock { x, y, w, h } = src_blk; let x0 = x >> 10; let y0 = y >> 10; @@ -831,7 +828,7 @@ fn vpass(rows: &[i32], vf: &[i16; 8], out: &mut [i32], half: i32 /// Block inter prediction without reference scaling: every column / row uses the same filter /// phase, so the filters run over whole rows (bit-identical to the per-sample process). fn mc_unscaled( - refp: &Plane, + refp: PlaneRef, (last_x, last_y): (i32, i32), blk: McBlock, (hf, vf): (&[i16; 8], &[i16; 8]), @@ -982,9 +979,17 @@ mod tests { [(0, 0), (-5, -3), (7, 9), (last_x - w as i32 / 2, last_y - h as i32 / 2), (last_x + 3, last_y + 2), (-(w as i32) - 4, 3)] { let (x, y) = ((px << 10) | 32, (py << 10) | 32); - mc_unscaled(&refp, (last_x, last_y), McBlock { x, y, w, h }, (&IDENTITY_TAPS, &IDENTITY_TAPS), rnd, &mut pred, &mut tmp); + mc_unscaled( + PlaneRef::Whole(&refp), + (last_x, last_y), + McBlock { x, y, w, h }, + (&IDENTITY_TAPS, &IDENTITY_TAPS), + rnd, + &mut pred, + &mut tmp, + ); let mut dst = Plane::new(w + 3, h); - copy_fullpel(&refp, (last_x, last_y), McBlock { x, y, w, h }, &mut dst, (3, 0), max); + copy_fullpel(PlaneRef::Whole(&refp), (last_x, last_y), McBlock { x, y, w, h }, &mut dst, (3, 0), max); for i in 0..h { for j in 0..w { let want = spec_phase0(&refp, (last_x, last_y), (px, py), (j, i), (w * 3 + h) % SUBPEL_FILTERS.len(), rnd) diff --git a/crates/video/src/av1/decode/postfilter.rs b/crates/video/src/av1/decode/postfilter.rs index 6304fdfb6..aa9c2e3ea 100644 --- a/crates/video/src/av1/decode/postfilter.rs +++ b/crates/video/src/av1/decode/postfilter.rs @@ -1,7 +1,7 @@ //! In-loop post filters run by decode_frame_wrapup: loop filter (7.14), CDEF (7.15), //! super-resolution upscaling (7.16) and loop restoration (7.17). -use crate::av1::decode::frame::RowBand; +use crate::av1::decode::frame::{FrameBuf, Plane, RowBand}; use crate::av1::decode::spec_tables::{ GLOBAL_GLOBALMV, GLOBALMV, INTRA_FRAME, MAX_LOOP_FILTER, NEARESTMV, NUM_4X4_BLOCKS_HIGH, NUM_4X4_BLOCKS_WIDE, SEG_LVL_ALT_LF_Y_V, TX_HEIGHT, TX_WIDTH, @@ -48,6 +48,121 @@ pub(crate) fn apply(fs: &mut FrameState, stats: &mut DecodeStats, pool: &crate:: stats.add(Stage::Restoration, t.lap()); } +/// The in-loop filters run band by band behind reconstruction (row wavefront): each stage of a +/// band starts once the stage before has finished the band below it, which bounds what the +/// stage reads beyond the band (the loop filter changes up to 7 rows above a band and intra +/// prediction of the next superblock row reads the unfiltered row above it; CDEF reads 2 rows +/// and loop restoration 3 rows beyond a band). Bands are 64 luma rows. The result is the same +/// as running each filter over the whole frame. Super-resolution frames use [`apply`]. +/// +/// The last active stage writes each band into its own buffers, which are handed out as the +/// band's final samples without a copy. +pub(crate) struct Pipeline { + bands: Vec<(usize, usize)>, + /// Luma rows of the coded frame (mi_rows * 4). + rows: usize, + lf_on: bool, + cdef_on: bool, + lr_on: bool, + /// Bands finished by each stage. + lf: usize, + cdef: usize, + lr: usize, + pending: [Vec; 3], + /// CdefFrame when loop restoration reads it. + cdef_out: Option, +} + +/// Final bands from [`Pipeline::advance`]: (band, its samples starting at the band's first row). +pub(crate) type FinalBands = Vec<(usize, [Plane; 3])>; + +impl Pipeline { + pub fn new(fs: &FrameState, draft: bool) -> Pipeline { + let rows = fs.fh.mi_rows as usize * 4; + let n = rows.div_ceil(BAND_ROWS).max(1); + let bands = (0..n).map(|b| (b * BAND_ROWS, if b + 1 == n { usize::MAX } else { (b + 1) * BAND_ROWS })).collect(); + let lvl = fs.fh.lf.level; + let cdef_on = !draft && crate::av1::decode::cdef::active(fs); + let lr_on = fs.fh.lr.uses_lr && !draft; + let cdef_out = (cdef_on && lr_on).then(|| fs.cur.same_geometry()); + Pipeline { + bands, + rows, + lf_on: (lvl[0] != 0 || lvl[1] != 0) && !draft, + cdef_on, + lr_on, + lf: 0, + cdef: 0, + lr: 0, + pending: Default::default(), + cdef_out, + } + } + + /// Filter what luma rows [0, `recon_rows`) of reconstructed samples allow (everything once + /// they cover the frame); returns the bands whose samples became final. + pub fn advance(&mut self, fs: &mut FrameState, stats: &mut DecodeStats, pool: &crate::av1::decode::par::Pool, recon_rows: usize) -> FinalBands { + let n = self.bands.len(); + let all = recon_rows >= self.rows; + let mut out = FinalBands::new(); + let mut t = Timer::start(); + // The loop filter of a band waits for the band below it to be reconstructed. + let lf_to = if all { n } else { (recon_rows / BAND_ROWS).saturating_sub(1) }; + if lf_to > self.lf { + if self.lf_on { + loop_filter_bands(fs, pool, &self.bands, self.lf..lf_to, &mut self.pending); + } + self.lf = lf_to; + } + stats.add(Stage::LoopFilter, t.lap()); + let cdef_to = if all { n } else { self.lf.saturating_sub(1) }; + if cdef_to > self.cdef { + let r = &self.bands[self.cdef..cdef_to]; + if self.cdef_on { + if let Some(cdef) = &mut self.cdef_out { + cdef.copy_rows_from(&fs.cur, r[0].0, r[r.len() - 1].1); + crate::av1::decode::cdef::filter_bands(fs, pool, cdef.row_bands(r), r); + } else { + let mut own: Vec<[Plane; 3]> = r.iter().map(|&(a, b)| fs.cur.rows_copy(a, b)).collect(); + crate::av1::decode::cdef::filter_bands(fs, pool, own_bands(&mut own), r); + out.extend((self.cdef..cdef_to).zip(own)); + } + } else if !self.lr_on { + // The loop filter is the last stage: the band is final once the band below it + // is filtered. + out.extend((self.cdef..cdef_to).zip(r.iter().map(|&(a, b)| fs.cur.rows_copy(a, b)))); + } + self.cdef = cdef_to; + } + stats.add(Stage::Cdef, t.lap()); + let lr_to = if all { n } else { self.cdef.saturating_sub(1) }; + if self.lr_on && lr_to > self.lr { + let r = &self.bands[self.lr..lr_to]; + let cdef = self.cdef_out.as_ref().unwrap_or(&fs.cur); + let mut own: Vec<[Plane; 3]> = r.iter().map(|&(a, b)| cdef.rows_copy(a, b)).collect(); + crate::av1::decode::restoration::restore_bands(fs, &fs.cur, cdef, own_bands(&mut own), pool, r); + out.extend((self.lr..lr_to).zip(own)); + self.lr = lr_to; + } + stats.add(Stage::Restoration, t.lap()); + out + } +} + +/// Row bands over per-band buffers made by [`FrameBuf::rows_copy`]. +fn own_bands(own: &mut [[Plane; 3]]) -> Vec<[RowBand<'_>; 3]> { + fn band(p: &mut Plane) -> RowBand<'_> { + let (stride, y0) = (p.stride.max(1), p.oy); + RowBand { data: p.data.as_mut_slice(), stride, y0 } + } + own.iter_mut() + .map(|planes| { + let [a, b, c] = planes; + [band(a), band(b), band(c)] + }) + .collect() +} + // --------------------------------------------------------------------------------------------- // Loop filter (7.14) @@ -69,23 +184,40 @@ const LF_MARGIN: usize = 8; /// written back; the band above never touches them. fn loop_filter(fs: &mut FrameState, pool: &crate::av1::decode::par::Pool) { let luma = bands(pool, fs.fh.mi_rows as usize * 4); + loop_filter_bands(fs, pool, &luma, 0..luma.len(), &mut Default::default()); +} + +/// The loop filter on bands `range` of `all` (the frame's bands). The bands above the range +/// are filtered already: `pending` holds the unfiltered rows above the first band of the range +/// (empty for band 0), saved before the band above was filtered, and is set to those of the +/// band after the range. +fn loop_filter_bands( + fs: &mut FrameState, + pool: &crate::av1::decode::par::Pool, + all: &[(usize, usize)], + range: std::ops::Range, + pending: &mut [Vec; 3], +) { + let Some(luma) = all.get(range.clone()) else { return }; let planes: Vec = (0..fs.num_planes).filter(|&p| p == 0 || fs.fh.lf.level[1 + p] != 0).collect(); let mut cur = std::mem::take(&mut fs.cur); let f: &FrameState = fs; - // Unfiltered copies of the rows above each band but the first. - let margins: Vec<[Vec; 3]> = luma - .iter() - .map(|&(start, _)| { - std::array::from_fn(|p| { - let sub_y = if p == 0 { 0 } else { f.ssy }; - let pl = &cur.planes[p]; - let (y0, y1) = ((start.saturating_sub(LF_MARGIN)) >> sub_y, start >> sub_y); - let rows = pl.data.get(y0 * pl.stride..y1 * pl.stride); - if start == 0 || !planes.contains(&p) { Vec::new() } else { rows.map(<[u16]>::to_vec).unwrap_or_default() } - }) + // Unfiltered copies of the rows above a band (none above the first). + let margin = |cur: &crate::av1::decode::frame::FrameBuf, start: usize| -> [Vec; 3] { + std::array::from_fn(|p| { + let sub_y = if p == 0 { 0 } else { f.ssy }; + let pl = &cur.planes[p]; + let (y0, y1) = ((start.saturating_sub(LF_MARGIN)) >> sub_y, start >> sub_y); + let rows = pl.data.get(y0 * pl.stride..y1 * pl.stride); + if start == 0 || !planes.contains(&p) { Vec::new() } else { rows.map(<[u16]>::to_vec).unwrap_or_default() } }) - .collect(); - let mut bands: Vec<([RowBand; 3], [Vec; 3])> = cur.row_bands(&luma).into_iter().zip(margins).collect(); + }; + let margins: Vec<[Vec; 3]> = + luma.iter().enumerate().map(|(i, &(start, _))| if i == 0 { std::mem::take(pending) } else { margin(&cur, start) }).collect(); + if let Some(&(next, _)) = all.get(range.end) { + *pending = margin(&cur, next); + } + let mut bands: Vec<([RowBand; 3], [Vec; 3])> = cur.row_bands(luma).into_iter().zip(margins).collect(); let changed = pool.map_mut(&mut bands, |b, (band, margin)| { let mut changed: [Vec<(usize, u16)>; 3] = Default::default(); for &p in &planes { diff --git a/crates/video/src/av1/decode/restoration.rs b/crates/video/src/av1/decode/restoration.rs index efc5a751f..d252f7b06 100644 --- a/crates/video/src/av1/decode/restoration.rs +++ b/crates/video/src/av1/decode/restoration.rs @@ -70,10 +70,16 @@ struct LrPlane<'a> { /// Bands of 64 luma rows are restored in parallel: every unit reads only the two input frames /// and writes only its own samples. pub(crate) fn loop_restoration(fs: &FrameState, cur: &FrameBuf, cdef: &FrameBuf, pool: &Pool) -> FrameBuf { - let fh = &fs.fh; let mut lr = cdef.clone(); - let ranges = bands(pool, fh.frame_height as usize); - let mut planes = lr.row_bands(&ranges); + let ranges = bands(pool, fs.fh.frame_height as usize); + restore_bands(fs, cur, cdef, lr.row_bands(&ranges), pool, &ranges); + lr +} + +/// Restore the bands `planes` covering luma rows `ranges`, which hold UpscaledCdefFrame; reads +/// both inputs up to 3 rows beyond each band. +pub(crate) fn restore_bands(fs: &FrameState, cur: &FrameBuf, cdef: &FrameBuf, mut planes: Vec<[RowBand; 3]>, pool: &Pool, ranges: &[(usize, usize)]) { + let fh = &fs.fh; pool.map_mut(&mut planes, |b, band| { let (start, end) = ranges[b]; let mut scratch = Scratch::default(); @@ -100,8 +106,6 @@ pub(crate) fn loop_restoration(fs: &FrameState, cur: &FrameBuf, cdef: &FrameBuf, p.restore(out, start >> sub_y, end >> sub_y, &mut scratch); } }); - drop(planes); - lr } /// Row buffers reused across stripes. diff --git a/crates/video/src/av1/decode/state.rs b/crates/video/src/av1/decode/state.rs index df2e2d682..e0e5a8522 100644 --- a/crates/video/src/av1/decode/state.rs +++ b/crates/video/src/av1/decode/state.rs @@ -6,8 +6,8 @@ //! with several, each tile decodes into private buffers covering its area (tiles never read //! outside themselves), which are then copied into the frame. -use crate::av1::decode::decoder::RefFrame; -use crate::av1::decode::frame::{FrameBuf, MiInfo}; +use crate::av1::decode::decoder::{Parsed, RefFrame}; +use crate::av1::decode::frame::{BandFrame, FrameBuf, MiInfo, PlaneRef}; use crate::av1::decode::header::{FrameHeader, RefInfo, SequenceHeader}; use crate::av1::decode::spec_tables::{DEFAULT_INTRA_FRAME_Y_MODE_CDF, NUM_REF_FRAMES, RESTORE_NONE, SUBSAMPLED_SIZE}; use std::ops::{Deref, DerefMut}; @@ -26,6 +26,11 @@ pub(crate) struct FrameShared { pub cdef_cols: usize, /// Reference slots (FrameStore and saved state) used by this frame. pub refs: [Option>; NUM_REF_FRAMES], + /// Parse results (CDFs, segment ids, saved motion vectors) of the same slots. + pub parsed: [Option>; NUM_REF_FRAMES], + /// The published bands of references that are still being decoded (row wavefront): read + /// only below the row progress that was waited for. + pub ref_rows: [Option>; NUM_REF_FRAMES], pub ref_info: [RefInfo; NUM_REF_FRAMES], /// MotionFieldMvs[ ref ][ y8 * w8 + x8 ] (7.9); empty when unused. pub motion_field: [Vec<[i32; 2]>; 8], @@ -34,6 +39,16 @@ pub(crate) struct FrameShared { } impl FrameShared { + /// The samples of reference slot `ref_idx` to predict from (None for a missing reference). + #[inline] + pub fn ref_samples(&self, ref_idx: i32, plane: usize) -> Option> { + let i = usize::try_from(ref_idx).ok()?; + if let Some(b) = self.ref_rows.get(i)?.as_ref() { + return b.planes.get(plane).map(PlaneRef::Bands); + } + self.refs.get(i)?.as_ref().map(|r| r.plane(plane)) + } + pub fn plane_residual_size(&self, subsize: usize, plane: usize) -> usize { let sx = if plane > 0 { self.ssx } else { 0 }; let sy = if plane > 0 { self.ssy } else { 0 }; @@ -210,6 +225,8 @@ impl FrameState { lr_unit_cols, cdef_cols, refs: Default::default(), + parsed: Default::default(), + ref_rows: Default::default(), ref_info: Default::default(), motion_field: Default::default(), prev_segment_ids: vec![0; mi_cols * mi_rows], @@ -276,6 +293,14 @@ impl FrameState { pub fn merge_tile_state(&mut self, t: &TileState) { for p in 0..self.num_planes { t.cur.planes[p].copy_into(&mut self.cur.planes[p]); + } + self.merge_tile_modes(t); + } + + /// Copy a tile's private buffers except the samples (after parsing, before reconstruction) + /// into the frame. + pub fn merge_tile_modes(&mut self, t: &TileState) { + for p in 0..self.num_planes { t.lf_tx_size[p].copy_into(&mut self.lf_tx_size[p]); for &u in &t.lr_written[p] { self.lr.lr_type[p][u] = t.lr.lr_type[p][u]; diff --git a/crates/video/src/av1/decode/tile.rs b/crates/video/src/av1/decode/tile.rs index 16d59ed3a..2572f9d21 100644 --- a/crates/video/src/av1/decode/tile.rs +++ b/crates/video/src/av1/decode/tile.rs @@ -94,6 +94,191 @@ pub(crate) struct Block { pub local_warp_params: [i32; 6], } +/// What a tile decoder does with the blocks it visits. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub(crate) enum Pass { + /// Read the symbols and reconstruct each block right away (single-threaded decoding). + Full, + /// Read the symbols only, recording what reconstruction needs in a [`TileRecord`]. + Parse, + /// Reconstruct from a [`TileRecord`], reading no symbols. + Reconstruct, +} + +/// The per-block values reconstruction needs beyond the mode info (which is final after +/// parsing): the block variables as parsed, its quantizer index and the warp samples / palette +/// color maps when used. +#[derive(Clone)] +pub(crate) struct BlockRecord { + b: Block, + current_q_index: i32, + warp_samples: Option>, + color_maps: Option, Vec)>>, +} + +/// A parsed tile: its blocks in decoding order, how many of them each superblock holds and the +/// coefficients of every coded transform block as a stream of +/// `eob, tx_type, count, (position, value) * count` (only non-zero values). +#[derive(Default)] +pub(crate) struct TileRecord { + blocks: Vec, + sb_blocks: Vec, + coeffs: Vec, + /// Read positions while reconstructing. + next_block: usize, + next_coeff: usize, + next_sb: usize, + next_sb_row: usize, + /// Bytes recorded and the most allowed. + pub bytes: usize, + pub limit: usize, + /// The decoder-wide budget the recorded bytes are reserved from, and how much is reserved. + pub budget: Option>, + reserved: usize, +} + +impl Drop for TileRecord { + fn drop(&mut self) { + if let Some(b) = &self.budget { + b.release(self.reserved); + } + } +} + +/// The parse record bytes all frames of a decoder may hold at once (frames in flight decode in +/// one pass once it is used up). +pub(crate) struct RecordBudget { + used: std::sync::atomic::AtomicUsize, + max: usize, + /// Most bytes ever reserved at once (tests). + #[cfg(test)] + pub peak: std::sync::atomic::AtomicUsize, +} + +/// Bytes reserved from a [`RecordBudget`] at a time. +const RESERVE_STEP: usize = 1 << 20; + +impl RecordBudget { + pub fn new(max: usize) -> RecordBudget { + RecordBudget { + used: Default::default(), + max, + #[cfg(test)] + peak: Default::default(), + } + } + + /// Reserve `n` bytes; false (nothing reserved) if that would go over the budget. + fn reserve(&self, n: usize) -> bool { + use std::sync::atomic::Ordering; + let ok = self.used.try_update(Ordering::AcqRel, Ordering::Acquire, |u| u.checked_add(n).filter(|&v| v <= self.max)).is_ok(); + #[cfg(test)] + if ok { + self.peak.fetch_max(self.used.load(Ordering::Acquire), Ordering::AcqRel); + } + ok + } + + fn release(&self, n: usize) { + self.used.fetch_sub(n, std::sync::atomic::Ordering::AcqRel); + } + + /// Bytes reserved now (tests). + #[cfg(test)] + pub fn used(&self) -> usize { + self.used.load(std::sync::atomic::Ordering::Acquire) + } +} + +/// The motion of a recorded block (what a reference row wait depends on). +pub(crate) struct BlockMotion { + pub mi_row: usize, + pub bh4: usize, + /// Inter prediction from reference frames (not intra block copy). + pub inter: bool, + pub ref_frame: [i8; 2], + /// Mv[ list ] (row, col) in 1/8 samples. + pub mv: [[i32; 2]; 2], + pub motion_mode: u8, + pub y_mode: usize, +} + +impl TileRecord { + /// Whether recording stopped at [`TileRecord::limit`] (the record is unusable). + pub fn over_limit(&self) -> bool { + self.bytes > self.limit + } + + /// Account for `n` more recorded bytes; false once over the limit (nothing more is kept). + fn grow(&mut self, n: usize) -> bool { + self.bytes = self.bytes.saturating_add(n); + if self.bytes > self.limit { + return false; + } + if self.bytes > self.reserved + && let Some(b) = &self.budget + { + let step = (self.bytes - self.reserved).max(RESERVE_STEP); + if !b.reserve(step) { + // The decoder-wide budget is used up: this frame is decoded in one pass. + self.limit = 0; + return false; + } + self.reserved += step; + } + true + } + /// The recorded blocks of superblock rows [first, end), for a tile `sbs_per_row` superblocks wide. + pub fn row_blocks(&self, sbs_per_row: usize, first: usize, end: usize) -> impl Iterator + '_ { + let start: usize = self.sb_blocks.iter().take(first * sbs_per_row).map(|&n| n as usize).sum(); + let count: usize = self.sb_blocks.iter().skip(first * sbs_per_row).take((end - first) * sbs_per_row).map(|&n| n as usize).sum(); + self.blocks.iter().skip(start).take(count).map(|r| BlockMotion { + mi_row: r.b.mi_row, + bh4: r.b.bh4, + inter: r.b.is_inter && !r.b.use_intrabc, + ref_frame: r.b.ref_frame, + mv: r.b.mv_i, + motion_mode: r.b.motion_mode, + y_mode: r.b.y_mode, + }) + } + + fn next_coeff(&mut self) -> Result { + let v = *self.coeffs.get(self.next_coeff).ok_or(crate::av1::decode::Error::Invalid("coefficient record exhausted"))?; + self.next_coeff += 1; + Ok(v) + } +} + +/// The work buffers of a [`TileDecoder`] (`quant` all zero between transform blocks). +pub(crate) struct Buffers { + quant: Vec, + dequant: Vec, + residual: Vec, + color_map_y: Vec, + color_map_uv: Vec, + pred_buf: [Vec; 2], + mask: Vec, + mc_tmp: Vec, + levels: Vec, +} + +impl Buffers { + pub fn new() -> Buffers { + Buffers { + quant: vec![0; 1024], + dequant: vec![0; 64 * 64], + residual: vec![0; 64 * 64], + color_map_y: vec![0; 64 * 64], + color_map_uv: vec![0; 64 * 64], + pred_buf: [vec![0; 128 * 128], vec![0; 128 * 128]], + mask: vec![0; 128 * 128], + mc_tmp: vec![0; (2 * 128 + 8) * 128], + levels: vec![0; (32 + TX_PAD) * (32 + TX_PAD)], + } + } +} + /// Decoder for one tile. pub(crate) struct TileDecoder<'a, 'f> { pub fs: &'f FrameShared, @@ -128,6 +313,9 @@ pub(crate) struct TileDecoder<'a, 'f> { pub mc_tmp: Vec, /// Coefficient levels of the current transform block, padded (see TX_PAD). levels: Vec, + pub pass: Pass, + /// Written by [`Pass::Parse`], read by [`Pass::Reconstruct`]. + pub record: TileRecord, } const SB_MAX: usize = 32; // superblock size in 4x4 units (128 / 4) @@ -141,6 +329,21 @@ fn block_height(bs: usize) -> usize { impl<'a, 'f> TileDecoder<'a, 'f> { pub fn new(fs: &'f FrameShared, t: &'f mut TileState, data: &'a [u8], cdf: Box, tile_row: usize, tile_col: usize) -> Self { + Self::with_buffers(fs, t, data, cdf, tile_row, tile_col, Buffers::new()) + } + + /// [`TileDecoder::new`] reusing the work buffers of an earlier decoder of the same frame + /// (see [`TileDecoder::into_buffers`]). + pub fn with_buffers( + fs: &'f FrameShared, + t: &'f mut TileState, + data: &'a [u8], + cdf: Box, + tile_row: usize, + tile_col: usize, + bufs: Buffers, + ) -> Self { + let Buffers { quant, dequant, residual, color_map_y, color_map_uv, pred_buf, mask, mc_tmp, levels } = bufs; let ti = &fs.fh.tile_info; let (rs, re) = (ti.mi_row_starts[tile_row] as usize, ti.mi_row_starts[tile_row + 1] as usize); let (cs, ce) = (ti.mi_col_starts[tile_col] as usize, ti.mi_col_starts[tile_col + 1] as usize); @@ -164,19 +367,27 @@ impl<'a, 'f> TileDecoder<'a, 'f> { b: Block::default(), mvs: Default::default(), nb: Default::default(), - quant: vec![0; 1024], - dequant: vec![0; 64 * 64], - residual: vec![0; 64 * 64], - color_map_y: vec![0; 64 * 64], - color_map_uv: vec![0; 64 * 64], + quant, + dequant, + residual, + color_map_y, + color_map_uv, plane_tx_type: 0, - pred_buf: [vec![0; 128 * 128], vec![0; 128 * 128]], - mask: vec![0; 128 * 128], - mc_tmp: vec![0; (2 * 128 + 8) * 128], - levels: vec![0; (32 + TX_PAD) * (32 + TX_PAD)], + pred_buf, + mask, + mc_tmp, + levels, + pass: Pass::Full, + record: TileRecord::default(), } } + /// The work buffers and CDFs, for [`TileDecoder::with_buffers`]. + pub fn into_buffers(self) -> (Buffers, Box) { + let TileDecoder { quant, dequant, residual, color_map_y, color_map_uv, pred_buf, mask, mc_tmp, levels, cdf, .. } = self; + (Buffers { quant, dequant, residual, color_map_y, color_map_uv, pred_buf, mask, mc_tmp, levels }, cdf) + } + fn seq(&self) -> &SequenceHeader { &self.fs.seq } @@ -189,8 +400,11 @@ impl<'a, 'f> TileDecoder<'a, 'f> { c >= self.mi_col_start as isize && c < self.mi_col_end as isize && r >= self.mi_row_start as isize && r < self.mi_row_end as isize } - /// decode_tile( ) + /// decode_tile( ), or its reconstruction from [`TileDecoder::record`] in [`Pass::Reconstruct`]. pub fn decode_tile(&mut self) -> Result<()> { + if self.pass == Pass::Reconstruct { + return self.reconstruct_tile(); + } // clear_above_context( ) let t = &mut *self.t; for p in 0..3 { @@ -223,7 +437,11 @@ impl<'a, 'f> TileDecoder<'a, 'f> { self.clear_cdef(r, c); self.clear_block_decoded_flags(r, c, sb4); self.read_lr(r, c, sb_size); + let before = self.record.blocks.len(); self.decode_partition(r, c, sb_size)?; + if self.pass == Pass::Parse { + self.record.sb_blocks.push((self.record.blocks.len() - before) as u32); + } c += sb4; } r += sb4; @@ -231,6 +449,76 @@ impl<'a, 'f> TileDecoder<'a, 'f> { Ok(()) } + /// The reconstruction half of decode_tile( ): the superblocks in the same order, each block + /// predicted and reconstructed from its record. + fn reconstruct_tile(&mut self) -> Result<()> { + self.reconstruct_sb_rows(usize::MAX) + } + + /// Reconstruct the next `rows` superblock rows of the tile (the record keeps the position). + pub fn reconstruct_sb_rows(&mut self, rows: usize) -> Result<()> { + let sb4 = if self.seq().use_128x128_superblock { 32 } else { 16 }; + let mut r = self.mi_row_start + self.record.next_sb_row * sb4; + let mut done = 0; + while r < self.mi_row_end && done < rows { + let mut c = self.mi_col_start; + while c < self.mi_col_end { + self.clear_block_decoded_flags(r, c, sb4); + let n = *self.record.sb_blocks.get(self.record.next_sb).ok_or(crate::av1::decode::Error::Invalid("block record exhausted"))?; + self.record.next_sb += 1; + for _ in 0..n { + self.reconstruct_block()?; + } + c += sb4; + } + r += sb4; + done += 1; + self.record.next_sb_row += 1; + } + Ok(()) + } + + fn reconstruct_block(&mut self) -> Result<()> { + let rec = self.record.blocks.get(self.record.next_block).ok_or(crate::av1::decode::Error::Invalid("block record exhausted"))?; + self.record.next_block += 1; + self.b = rec.b.clone(); + self.current_q_index = rec.current_q_index; + if let Some(w) = &rec.warp_samples { + self.mvs.num_samples = w.0; + self.mvs.cand_list = w.1; + } + if let Some(maps) = &rec.color_maps { + if let Some(d) = self.color_map_y.get_mut(..maps.0.len()) { + d.copy_from_slice(&maps.0); + } + if let Some(d) = self.color_map_uv.get_mut(..maps.1.len()) { + d.copy_from_slice(&maps.1); + } + } + self.compute_prediction()?; + self.residual() + } + + /// Records the block for [`Pass::Reconstruct`] (its variables as parsed). + fn record_block(&mut self) { + let b = &self.b; + // The rows of the color maps (stride 64) the block's palette prediction reads. + let map_rows = |n: usize, h: usize| if n > 0 { (h + 2).min(64) * 64 } else { 0 }; + let rows_y = map_rows(b.palette_size_y, block_height(b.mi_size)); + let rows_uv = map_rows(b.palette_size_uv, block_height(b.mi_size) >> self.fs.ssy); + let size = std::mem::size_of::() + + rows_y + + rows_uv + + if b.motion_mode as usize == crate::av1::decode::spec_tables::LOCALWARP { 160 } else { 0 }; + if !self.record.grow(size) { + return; + } + let warp_samples = + (b.motion_mode as usize == crate::av1::decode::spec_tables::LOCALWARP).then(|| Box::new((self.mvs.num_samples, self.mvs.cand_list))); + let color_maps = (rows_y + rows_uv > 0).then(|| Box::new((self.color_map_y[..rows_y].to_vec(), self.color_map_uv[..rows_uv].to_vec()))); + self.record.blocks.push(BlockRecord { b: b.clone(), current_q_index: self.current_q_index, warp_samples, color_maps }); + } + fn clear_cdef(&mut self, r: usize, c: usize) { let t = &mut *self.t; t.set_cdef_idx(r, c, -1); @@ -461,7 +749,11 @@ impl<'a, 'f> TileDecoder<'a, 'f> { } } } - self.compute_prediction()?; + if self.pass == Pass::Parse { + self.record_block(); + } else { + self.compute_prediction()?; + } self.residual()?; let b = &self.b; let delta_lf = self.delta_lf; diff --git a/crates/video/src/av1/decode/tile/coeffs.rs b/crates/video/src/av1/decode/tile/coeffs.rs index 6a704f8ac..df358e68d 100644 --- a/crates/video/src/av1/decode/tile/coeffs.rs +++ b/crates/video/src/av1/decode/tile/coeffs.rs @@ -459,6 +459,58 @@ impl<'a, 'f> TileDecoder<'a, 'f> { } } + /// Moves the coefficients `coeffs` left in `quant` into the record (leaving `quant` zero, as + /// reconstruction does). + pub(super) fn record_coeffs(&mut self, eob: usize, tx_sz: usize) { + let scan = self.get_scan(tx_sz); + let scan = scan.get(..eob).unwrap_or(scan); + if !self.record.grow(4 * (3 + 2 * scan.len())) { + // Over the limit: the record is dropped (the frame is decoded again in one pass); + // `quant` must still be left zero. + for &pos in scan { + if let Some(q) = self.quant.get_mut(pos as usize) { + *q = 0; + } + } + return; + } + let rec = &mut self.record.coeffs; + rec.push(eob as i32); + if eob == 0 { + return; + } + rec.push(self.plane_tx_type as i32); + let count_at = rec.len(); + rec.push(0); + let mut count = 0; + for &pos in scan { + let v = std::mem::take(&mut self.quant[pos as usize]); + if v != 0 { + rec.push(pos as i32); + rec.push(v); + count += 1; + } + } + rec[count_at] = count; + } + + /// The next transform block's coefficients from the record into `quant` (and its type); + /// returns its eob. + pub(super) fn replay_coeffs(&mut self) -> crate::av1::decode::Result { + let eob = self.record.next_coeff()?; + if eob <= 0 { + return Ok(0); + } + self.plane_tx_type = usize::try_from(self.record.next_coeff()?).map_err(|_| crate::av1::decode::Error::Invalid("coefficient record"))?; + let count = self.record.next_coeff()?; + for _ in 0..count { + let pos = self.record.next_coeff()? as usize; + let v = self.record.next_coeff()?; + *self.quant.get_mut(pos).ok_or(crate::av1::decode::Error::Invalid("coefficient record"))? = v; + } + Ok(eob as usize) + } + /// Reconstruct process (7.12.3). pub(super) fn reconstruct(&mut self, plane: usize, x: usize, y: usize, tx_sz: usize, dc_only: bool) { // dqDenom (7.12.3) is 1, 2 or 4 and the dividend is non-negative. diff --git a/crates/video/src/av1/decode/tile/predict.rs b/crates/video/src/av1/decode/tile/predict.rs index b1a53f399..244be62c6 100644 --- a/crates/video/src/av1/decode/tile/predict.rs +++ b/crates/video/src/av1/decode/tile/predict.rs @@ -213,7 +213,8 @@ impl<'a, 'f> TileDecoder<'a, 'f> { if start_x >= max_x || start_y >= max_y { return Ok(()); } - if !self.b.is_inter { + let parse_only = self.pass == super::Pass::Parse; + if !self.b.is_inter && !parse_only { let palette = if plane == 0 { self.b.palette_size_y } else { self.b.palette_size_uv }; if palette > 0 { self.predict_palette(plane, start_x, start_y, x, y, tx_sz); @@ -266,9 +267,23 @@ impl<'a, 'f> TileDecoder<'a, 'f> { } } if !self.b.skip { - let eob = self.coeffs(plane, start_x, start_y, tx_sz); - if eob > 0 { - self.reconstruct(plane, start_x, start_y, tx_sz, eob == 1); + match self.pass { + super::Pass::Full => { + let eob = self.coeffs(plane, start_x, start_y, tx_sz); + if eob > 0 { + self.reconstruct(plane, start_x, start_y, tx_sz, eob == 1); + } + } + super::Pass::Parse => { + let eob = self.coeffs(plane, start_x, start_y, tx_sz); + self.record_coeffs(eob, tx_sz); + } + super::Pass::Reconstruct => { + let eob = self.replay_coeffs()?; + if eob > 0 { + self.reconstruct(plane, start_x, start_y, tx_sz, eob == 1); + } + } } } for i in 0..step_y { diff --git a/crates/video/tests/av1_decode/fuzz_hostile.rs b/crates/video/tests/av1_decode/fuzz_hostile.rs index 05dbbe126..31cb66073 100644 --- a/crates/video/tests/av1_decode/fuzz_hostile.rs +++ b/crates/video/tests/av1_decode/fuzz_hostile.rs @@ -1,7 +1,6 @@ //! Hostile-input robustness: truncation, header-region sweeps and random mutation of small //! ffmpeg-generated AV1 streams (frame by frame) must never panic or run away. Skips without ffmpeg. -use std::panic::{AssertUnwindSafe, catch_unwind}; use std::process::{Command, Stdio}; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -20,8 +19,15 @@ impl Rng { } } -/// (name, encoder args, pix_fmt) -const SEEDS: &[(&str, &str, &str)] = &[("av1_fz_default", "-c:v libsvtav1 -g 4", "yuv420p"), ("av1_fz_10bit", "-c:v libsvtav1 -g 6", "yuv420p10le")]; +// Seeds are at least 64x64: SVT-AV1 before 3.0 (the Ubuntu runners have 2.3) refuses a source under 64 lines. +/// (name, encoder args, pix_fmt, size, decoder thread counts) +const SEEDS: &[(&str, &str, &str, &str, &[usize])] = &[ + ("av1_fz_default", "-c:v libsvtav1 -g 4", "yuv420p", "64x64", &[1, 3]), + ("av1_fz_10bit", "-c:v libsvtav1 -g 6", "yuv420p10le", "64x64", &[1, 3]), + // Several superblock rows, so corrupt references meet frames already predicting from their + // top rows (row wavefront with frame threads). + ("av1_fz_rows", "-c:v libsvtav1 -g 6", "yuv420p", "64x136", &[1, 8]), +]; fn ivf_frames(data: &[u8]) -> Vec> { let mut out = Vec::new(); @@ -37,14 +43,13 @@ fn ivf_frames(data: &[u8]) -> Vec> { out } -// Seeds are 64x64: SVT-AV1 before 3.0 (the Ubuntu runners have 2.3) refuses a source under 64 lines. -fn make(ff: &std::path::Path, name: &str, args: &str, pix: &str) -> Option>> { +fn make(ff: &std::path::Path, name: &str, args: &str, pix: &str, size: &str) -> Option>> { let out = craft_media_testkit::fixtures_dir("av1").join(format!("{name}.ivf")); let p = craft_media_testkit::fixtures::generate(&out, |tmp| { let a: Vec<&str> = args.split_whitespace().collect(); matches!( Command::new(ff) - .args(["-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i", "testsrc2=size=64x64:rate=25", "-frames:v", "6", "-pix_fmt", pix]) + .args(["-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i", &format!("testsrc2=size={size}:rate=25"), "-frames:v", "6", "-pix_fmt", pix]) .args(a) .args(["-f", "ivf"]) .arg(tmp) @@ -69,20 +74,29 @@ fn count_panics() { }); } -fn run_all(frames: &[Vec], label: &str) { +fn run_all(frames: &[Vec], threads: &[usize], label: &str) { craft_media_testkit::set_progress(label); count_panics(); let before = PANICS.load(Ordering::SeqCst); - let res = catch_unwind(AssertUnwindSafe(|| { - for threads in [1, 3] { - let mut dec = Decoder::with_threads(threads); - for (i, f) in frames.iter().enumerate() { - let _ = dec.decode_pts(f, i as i64); - } - let _ = dec.flush_result(); - } - })); - assert!(res.is_ok() && PANICS.load(Ordering::SeqCst) == before, "panic: {label}"); + // Every thread count decodes the stream at the same time, each on a thread of its own. + let ok = std::thread::scope(|s| { + let runs: Vec<_> = threads + .iter() + .map(|&threads| { + s.spawn(move || { + let mut dec = Decoder::with_threads(threads); + for (i, f) in frames.iter().enumerate() { + let _ = dec.decode_pts(f, i as i64); + } + let _ = dec.flush_result(); + }) + }) + .collect(); + // Join every run (no short cut), then check them all. + let joined: Vec = runs.into_iter().map(|r| r.join().is_ok()).collect(); + joined.into_iter().all(|ok| ok) + }); + assert!(ok && PANICS.load(Ordering::SeqCst) == before, "panic: {label}"); } /// Random-mutation rounds per seed (raise with FILMCRAFT_FUZZ_ITERS for a long hunt). @@ -95,17 +109,23 @@ const DEADLINE_SECS: u64 = 600; #[test] fn hostile_streams_never_panic() { - craft_media_testkit::with_deadline(DEADLINE_SECS, sweep); + craft_media_testkit::with_deadline(DEADLINE_SECS, || sweep(&SEEDS[..2])); } -fn sweep() { +/// The seed with several superblock rows, in a test of its own so it runs beside the others. +#[test] +fn hostile_streams_with_superblock_rows_never_panic() { + craft_media_testkit::with_deadline(DEADLINE_SECS, || sweep(&SEEDS[2..])); +} + +fn sweep(seeds: &[(&str, &str, &str, &str, &[usize])]) { let Some(ff) = craft_media_testkit::ffmpeg_or_skip("AV1 fuzz") else { return }; - for &(name, args, pix) in SEEDS { + for &(name, args, pix, size, threads) in seeds { if !craft_media_testkit::ffmpeg_has_encoder(&ff, "libsvtav1") { craft_media_testkit::skip_test("AV1 fuzz", &format!("this ffmpeg has no libsvtav1 encoder (seed {name})")); continue; } - let Some(seed) = make(&ff, name, args, pix) else { + let Some(seed) = make(&ff, name, args, pix, size) else { panic!("ffmpeg has libsvtav1 but could not encode the {name} seed"); }; if seed.is_empty() { @@ -118,7 +138,7 @@ fn sweep() { for n in (0..len).step_by((len / 200).max(1)) { let mut d = seed.clone(); d[fi].truncate(n); - run_all(&d, &format!("{name} frame {fi} truncate {n}")); + run_all(&d, threads, &format!("{name} frame {fi} truncate {n}")); } } // header region of every frame: every byte to a few values, every bit @@ -127,12 +147,12 @@ fn sweep() { for v in [0u8, 0xff, 0x80, 0x01, 0x7f] { let mut d = seed.clone(); d[fi][p] = v; - run_all(&d, &format!("{name} frame {fi} byte {p}={v:#x}")); + run_all(&d, threads, &format!("{name} frame {fi} byte {p}={v:#x}")); } for b in 0..8 { let mut d = seed.clone(); d[fi][p] ^= 1 << b; - run_all(&d, &format!("{name} frame {fi} flip {p}.{b}")); + run_all(&d, threads, &format!("{name} frame {fi} flip {p}.{b}")); } } } @@ -151,7 +171,7 @@ fn sweep() { d[fi][p] = rng.next() as u8; } } - run_all(&d, &format!("{name} random {i}")); + run_all(&d, threads, &format!("{name} random {i}")); } } } diff --git a/crates/video/tests/av1_decode/main.rs b/crates/video/tests/av1_decode/main.rs index 50c3939f6..76a5adfcf 100644 --- a/crates/video/tests/av1_decode/main.rs +++ b/crates/video/tests/av1_decode/main.rs @@ -9,3 +9,4 @@ mod hostile_dims; mod oracle_inter; mod oracle_intra; mod perf; +mod wavefront; diff --git a/crates/video/tests/av1_decode/wavefront.rs b/crates/video/tests/av1_decode/wavefront.rs new file mode 100644 index 000000000..725b02544 --- /dev/null +++ b/crates/video/tests/av1_decode/wavefront.rs @@ -0,0 +1,93 @@ +//! Stress tests of the frame threading (parse / reconstruct split and the row wavefront across +//! frames): every thread count gives the single-thread pictures, run after run, and dropping +//! or flushing a busy decoder never hangs. A hang fails the test through the deadline. + +use crate::common; +use common::*; +use craft_video::av1::decode::{Decoder, Picture}; + +/// A GOP with many superblock rows (the wavefront has rows to overlap), hierarchical +/// references and motion reaching across rows. +fn spec() -> Spec { + Spec::new("wavefront_640x480", "testsrc2=s=640x480:r=25,rotate=a=t*0.5:c=black", 24, "yuv420p", &["-preset", "8", "-crf", "38"]) +} + +/// Seconds a test may take before it counts as a hang (override: FILMCRAFT_HOSTILE_TIMEOUT_SECS). +const DEADLINE_SECS: u64 = 300; + +fn decode(tus: &[Vec], threads: usize) -> Vec { + let mut dec = Decoder::with_threads(threads); + let mut pics = Vec::new(); + for (i, tu) in tus.iter().enumerate() { + pics.extend(dec.decode_pts(tu, i as i64).unwrap_or_else(|e| panic!("threads {threads}, unit {i}: {e}"))); + } + pics.extend(dec.flush_result().unwrap_or_else(|e| panic!("threads {threads}, flush: {e}"))); + pics +} + +#[test] +fn every_thread_count_gives_the_single_thread_pictures_repeatedly() { + let Some(ff) = ffmpeg() else { return }; + let tus = ivf_frames(&make(&ff, &spec())); + craft_media_testkit::with_deadline(DEADLINE_SECS, move || { + let want = decode(&tus, 1); + assert_eq!(want.len(), 24); + for threads in [2, 3, 4, 5, 8, 16] { + for round in 0..4 { + assert!(decode(&tus, threads) == want, "threads {threads}, round {round}: pictures differ"); + } + } + }); +} + +/// 128x128 superblocks in two tile columns (libaom), with motion field estimation: the +/// wavefront over the superblock rows of every tile column. +fn spec_sb128_tiles() -> Spec { + let enc = ["-cpu-used", "8", "-crf", "40", "-tile-columns", "1", "-lag-in-frames", "16", "-aom-params", "sb-size=128:enable-ref-frame-mvs=1"]; + Spec::new("wavefront_sb128_tiles", "testsrc2=s=640x400:r=25,rotate=a=t*0.5:c=black", 16, "yuv420p", &enc).encoder("libaom-av1") +} + +#[test] +fn superblocks_of_128_in_tile_columns_give_the_single_thread_pictures() { + let Some(ff) = ffmpeg_libaom() else { return }; + let tus = ivf_frames(&make(&ff, &spec_sb128_tiles())); + craft_media_testkit::with_deadline(DEADLINE_SECS, move || { + let want = decode(&tus, 1); + assert_eq!(want.len(), 16); + for threads in [2, 3, 4, 8, 16] { + for round in 0..2 { + assert!(decode(&tus, threads) == want, "threads {threads}, round {round}: pictures differ"); + } + } + }); +} + +#[test] +fn dropping_or_flushing_a_busy_decoder_never_hangs() { + let Some(ff) = ffmpeg() else { return }; + let tus = ivf_frames(&make(&ff, &spec())); + craft_media_testkit::with_deadline(DEADLINE_SECS, move || { + let want = decode(&tus, 1); + for threads in [2, 3, 8, 16] { + for cut in [1, 2, 7, 12, 23] { + // Dropped with frames in flight (no flush). + let mut dec = Decoder::with_threads(threads); + for (i, tu) in tus.iter().take(cut).enumerate() { + dec.decode_pts(tu, i as i64).expect("decode"); + } + drop(dec); + // Flushed mid-stream (as before a seek), then continued: the same pictures. + let mut dec = Decoder::with_threads(threads); + let mut pics = Vec::new(); + for (i, tu) in tus.iter().enumerate() { + if i == cut { + pics.extend(dec.flush_result().expect("flush")); + } + pics.extend(dec.decode_pts(tu, i as i64).expect("decode")); + } + pics.extend(dec.flush_result().expect("flush")); + assert!(pics == want, "threads {threads}, flush before unit {cut}: pictures differ"); + } + } + }); +} From c25999c8a48ab1065f4191d992dc6b916f59a4b8 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 12 Nov 2026 21:51:12 +0100 Subject: [PATCH 002/382] hevc decode: dequantise while decoding residuals, table-driven sig_coeff contexts Each coefficient is scaled (8.6.3) as it is decoded and stored in a list of (index, value) instead of a separate pass over the bounding box. Only the coefficient bounding box is cleared before the list is scattered into it. DC-only blocks add the inverse-DC constant straight to the prediction. sig_coeff_flag ctxInc comes from a per-sub-block table, last_sb / last_pos from inverse scan tables. Merge candidates use the fixed five-entry list instead of a Vec. Same change as storytold/Filmcraft#3188 (residual part), ported onto craft-video. Co-Authored-By: Claude Sonnet 5.5 --- crates/video/src/hevc/decode/mvpred.rs | 33 ++- crates/video/src/hevc/decode/slicedec.rs | 32 ++- .../hevc/decode/slicedec/transform_tree.rs | 194 +++++++++--------- crates/video/src/hevc/decode/tables.rs | 79 ++++++- 4 files changed, 224 insertions(+), 114 deletions(-) diff --git a/crates/video/src/hevc/decode/mvpred.rs b/crates/video/src/hevc/decode/mvpred.rs index 962bbaa8c..9abbe33aa 100644 --- a/crates/video/src/hevc/decode/mvpred.rs +++ b/crates/video/src/hevc/decode/mvpred.rs @@ -152,38 +152,35 @@ impl<'a, S: crate::hevc::decode::picture::Sample> SliceDecoder<'a, S> { col.ref_idx[1] = 0; col_avail = true; } - let mut cands: Vec = list[..n].to_vec(); if col_avail { - cands.push(col); + list[n] = col; + n += 1; } - if merge_idx < cands.len() { - return self.finish_merge(cands[merge_idx], w0, h0); + if merge_idx < n { + return self.finish_merge(list[merge_idx], w0, h0); } // combined bi-predictive candidates (8.5.3.2.4) - let num_orig = cands.len(); + let num_orig = n; if self.sh.is_b() && num_orig > 1 && num_orig < max { let mut comb = 0; - while comb < num_orig * (num_orig - 1) && cands.len() < max { + while comb < num_orig * (num_orig - 1) && n < max { let (i0, i1) = COMB[comb]; - let (c0, c1) = (cands[i0], cands[i1]); + let (c0, c1) = (list[i0], list[i1]); if c0.pred(0) && c1.pred(1) && (self.ref_pic(0, c0.ref_idx[0]).poc != self.ref_pic(1, c1.ref_idx[1]).poc || c0.mv[0] != c1.mv[1]) { - cands.push(MvField { mv: [c0.mv[0], c1.mv[1]], ref_idx: [c0.ref_idx[0], c1.ref_idx[1]] }); + list[n] = MvField { mv: [c0.mv[0], c1.mv[1]], ref_idx: [c0.ref_idx[0], c1.ref_idx[1]] }; + n += 1; } comb += 1; } } - if merge_idx < cands.len() { - return self.finish_merge(cands[merge_idx], w0, h0); + if merge_idx < n { + return self.finish_merge(list[merge_idx], w0, h0); } - // zero candidates (8.5.3.2.5) + // zero candidates (8.5.3.2.5): candidate merge_idx is the (merge_idx - n)-th one let num_ref = if self.sh.is_b() { self.sh.num_ref_idx[0].min(self.sh.num_ref_idx[1]) } else { self.sh.num_ref_idx[0] } as usize; - let mut zero_idx = 0; - while cands.len() <= merge_idx { - let r = if zero_idx < num_ref { zero_idx as i8 } else { 0 }; - cands.push(MvField { mv: [[0; 2]; 2], ref_idx: [r, if self.sh.is_b() { r } else { -1 }] }); - zero_idx += 1; - } - self.finish_merge(cands[merge_idx], w0, h0) + let zero_idx = merge_idx - n; + let r = if zero_idx < num_ref { zero_idx as i8 } else { 0 }; + self.finish_merge(MvField { mv: [[0; 2]; 2], ref_idx: [r, if self.sh.is_b() { r } else { -1 }] }, w0, h0) } fn finish_merge(&self, mut f: MvField, w: i32, h: i32) -> MvField { diff --git a/crates/video/src/hevc/decode/slicedec.rs b/crates/video/src/hevc/decode/slicedec.rs index 102b74719..8ebaeafb1 100644 --- a/crates/video/src/hevc/decode/slicedec.rs +++ b/crates/video/src/hevc/decode/slicedec.rs @@ -16,7 +16,7 @@ use crate::hevc::decode::spec_tables::{ INTRA_CHROMA, LAST_X_PREFIX, LAST_Y_PREFIX, MERGE_FLAG, MERGE_IDX, MVP_FLAG, PART_MODE, PRED_MODE, PREV_INTRA_LUMA, REF_IDX, RQT_ROOT_CBF, SAO_MERGE, SAO_TYPE, SIG_COEFF, SPLIT_CU, SPLIT_TRANSFORM, TRANSFORM_SKIP, }; -use crate::hevc::decode::tables::{CTX_IDX_MAP, INTRA_CHROMA_MODE_422, LEVEL_SCALE, SCAN_4, qpc, scan_order}; +use crate::hevc::decode::tables::{INTRA_CHROMA_MODE_422, LEVEL_SCALE, SCAN_4, SIG_CTX, qpc, scan_order, scan_pos}; use crate::hevc::decode::transform; use std::sync::Arc; @@ -340,6 +340,8 @@ pub struct SliceDecoder<'a, S> { pub cu_part: PartMode, // scratch pub coeffs: Vec, + /// Scaled non-zero coefficients of the current transform block: (index in `coeffs`, value). + pub nz: Vec<(u16, i32)>, pub pred0: Vec, pub pred1: Vec, pub mc: crate::hevc::decode::inter::McScratch, @@ -461,6 +463,7 @@ impl<'a, S: Sample> SliceDecoder<'a, S> { intra_split: false, cu_part: PartMode::P2Nx2N, coeffs: vec![0; 32 * 32], + nz: vec![(0, 0); 32 * 32], pred0: vec![0; 64 * 64], pred1: vec![0; 64 * 64], mc: Default::default(), @@ -632,3 +635,30 @@ impl<'a, S: Sample> SliceDecoder<'a, S> { Ok(()) } } + +#[cfg(test)] +mod tests { + use crate::hevc::decode::transform; + + /// `reconstruct` clears only the coefficient bounding box, so the inverse transform must not + /// read the stale values left outside it by the previous block. + #[test] + fn inverse_transform_reads_only_the_coefficient_box() { + for &(n, dst) in &[(4usize, true), (4, false), (8, false), (16, false), (32, false)] { + for (max_x, max_y) in [(0, 1), (1, 0), (2, 3), (n / 2, 1), (n - 1, 0), (n - 1, n - 1)] { + let (mut clean, mut stale) = (vec![0i32; n * n], vec![0i32; n * n]); + for (i, (c, s)) in clean.iter_mut().zip(stale.iter_mut()).enumerate() { + let (x, y) = (i % n, i / n); + *s = 12345 - i as i32; + if x <= max_x && y <= max_y { + *c = (i as i32 * 37) % 201 - 100; + *s = *c; + } + } + transform::inverse_transform(&mut clean, n, dst, max_x, max_y, 12); + transform::inverse_transform(&mut stale, n, dst, max_x, max_y, 12); + assert_eq!(clean, stale, "n {n} dst {dst} box ({max_x}, {max_y})"); + } + } + } +} diff --git a/crates/video/src/hevc/decode/slicedec/transform_tree.rs b/crates/video/src/hevc/decode/slicedec/transform_tree.rs index 8512c341a..aa099a957 100644 --- a/crates/video/src/hevc/decode/slicedec/transform_tree.rs +++ b/crates/video/src/hevc/decode/slicedec/transform_tree.rs @@ -1,7 +1,7 @@ use super::{ - CBF_CHROMA, CBF_LUMA, CODED_SUB_BLOCK, CTX_IDX_MAP, CU_QP_DELTA_ABS, ChromaFormat, E_TU_H, E_TU_V, F_CBF, F_INTRA, GT1, GT2, LAST_X_PREFIX, - LAST_Y_PREFIX, LEVEL_SCALE, PartMode, Result, SCAN_4, SIG_COEFF, SPLIT_TRANSFORM, Sample, SliceDecoder, TRANSFORM_SKIP, ensure, for_runs, intra, - scan_order, transform, + CBF_CHROMA, CBF_LUMA, CODED_SUB_BLOCK, CU_QP_DELTA_ABS, ChromaFormat, E_TU_H, E_TU_V, F_CBF, F_INTRA, GT1, GT2, LAST_X_PREFIX, LAST_Y_PREFIX, + LEVEL_SCALE, PartMode, Result, SCAN_4, SIG_COEFF, SIG_CTX, SPLIT_TRANSFORM, Sample, SliceDecoder, TRANSFORM_SKIP, ensure, for_runs, intra, + scan_order, scan_pos, transform, }; /// Significant scan positions of one sub-block, in decoding (descending) order. @@ -44,54 +44,26 @@ struct GreaterFlags { g1ctx: u32, } -/// sigCtx increment of sig_coeff_flag (9.3.4.2.5) for the position `(xp, yp)` inside the sub-block. -fn sig_ctx_inc(p: &SigMapParams, (xp, yp): (usize, usize)) -> usize { - let (xc, yc) = (p.xs * 4 + xp, p.ys * 4 + yp); +/// sigCtx increments (9.3.4.2.5) of the 16 scan positions of one sub-block. +fn sig_ctx_table(p: &SigMapParams) -> [u8; 16] { if p.log2 == 2 { - return CTX_IDX_MAP[(yc << 2) + xc] as usize; + return SIG_CTX[p.scan_idx][4]; } - if xc + yc == 0 { - return 0; - } - let mut s = match p.prev_csbf { - 0 => { - if xp + yp == 0 { - 2 - } else if xp + yp < 3 { - 1 - } else { - 0 - } - } - 1 => { - if yp == 0 { - 2 - } else if yp == 1 { - 1 - } else { - 0 - } - } - 2 => { - if xp == 0 { - 2 - } else if xp == 1 { - 1 - } else { - 0 - } - } - _ => 2, - }; - if p.c == 0 { - if p.xs + p.ys > 0 { - s += 3; - } - s += if p.log2 == 3 { if p.scan_idx == 0 { 9 } else { 15 } } else { 21 }; + let off = if p.c == 0 { + (if p.xs + p.ys > 0 { 3 } else { 0 }) + if p.log2 == 3 { if p.scan_idx == 0 { 9 } else { 15 } } else { 21 } + } else if p.log2 == 3 { + 9 } else { - s += if p.log2 == 3 { 9 } else { 12 }; + 12 + }; + let mut t = SIG_CTX[p.scan_idx][p.prev_csbf as usize]; + for v in t.iter_mut() { + *v += off; } - s + if p.xs + p.ys == 0 { + t[0] = 0; + } + t } /// A node of the transform tree: the block at (`x0`, `y0`) of size 2^`log2`, its parent's origin @@ -333,14 +305,13 @@ impl<'a, S: Sample> SliceDecoder<'a, S> { /// sig_coeff_flag decoding of one coded sub-block, appending the significant scan positions /// (descending) to `list`. fn read_sig_map(&mut self, p: &SigMapParams, list: &mut SigList) { - let pos_scan = &SCAN_4[p.scan_idx]; let c_off_sig = if p.c == 0 { 0 } else { 27 }; + let ctx_tab = sig_ctx_table(p); let mut infer_dc = p.infer_dc; let mut np = p.start; while np >= 0 { - let (xp, yp) = (pos_scan[np as usize].0 as usize, pos_scan[np as usize].1 as usize); if np > 0 || !infer_dc { - let sig_ctx = sig_ctx_inc(p, (xp, yp)); + let sig_ctx = ctx_tab[np as usize] as usize; if self.c.decode_decision(SIG_COEFF + c_off_sig + sig_ctx) == 1 { list.push(np as u8); infer_dc = false; @@ -438,9 +409,23 @@ impl<'a, S: Sample> SliceDecoder<'a, S> { let sb_scan = scan_order(log2sb, scan_idx); let pos_scan = &SCAN_4[scan_idx]; let sb_w = 1usize << log2sb; - let last_sb = sb_scan.iter().position(|&(x, y)| x as u32 == lx >> 2 && y as u32 == ly >> 2).unwrap_or(0); - let last_pos = pos_scan.iter().position(|&(x, y)| x as u32 == lx & 3 && y as u32 == ly & 3).unwrap_or(0); - self.coeffs[..n * n].fill(0); + let last_sb = scan_pos(log2sb, scan_idx, lx >> 2, ly >> 2); + let last_pos = scan_pos(2, scan_idx, lx & 3, ly & 3); + // scaling (8.6.3), applied as each coefficient is decoded + let bd = if c == 0 { self.pic.bd_y } else { self.pic.bd_c }; + let bd_shift = bd + log2 - 5; + let round = 1i64 << (bd_shift - 1); + let scale = (LEVEL_SCALE[(qp % 6) as usize] as i64) << (qp / 6); + let matrix = match &self.pic.scaling { + Some(s) if !bypass && !(ts && n > 4) => { + let size_id = (log2 - 2) as usize; + let matrix_id = if self.cu_intra { c } else { 3 + c }; + Some((s.clone(), size_id * 6 + matrix_id)) + } + _ => None, + }; + let m: Option<&[u8]> = matrix.as_ref().map(|(s, i)| &s[*i][..]); + let mut nnz = 0; let mut csbf = [0u8; 64]; let mut prev_g1: Option = None; let sdh = self.pps.sign_data_hiding && !bypass; @@ -485,12 +470,18 @@ impl<'a, S: Sample> SliceDecoder<'a, S> { for k in 0..list.n { let np = list.pos[k] as usize; let (xc, yc) = (xs * 4 + pos_scan[np].0 as usize, ys * 4 + pos_scan[np].1 as usize); - self.coeffs[yc * n + xc] = values[k]; + let mut v = values[k]; + if !bypass { + let f = m.map_or(16, |m| m[yc * n + xc] as i64); + v = ((v as i64 * f * scale + round) >> bd_shift).clamp(-32768, 32767) as i32; + } + self.nz[nnz] = ((yc * n + xc) as u16, v); + nnz += 1; max_x = max_x.max(xc); max_y = max_y.max(yc); } } - self.reconstruct((x0, y0), log2, c, qp, ts, (max_x, max_y)) + self.reconstruct((x0, y0), log2, c, ts, nnz, (max_x, max_y)) } fn coeff_abs_level_remaining(&mut self, rice: u32) -> Result { @@ -508,55 +499,70 @@ impl<'a, S: Sample> SliceDecoder<'a, S> { } } - /// Scaling, transform and addition to the prediction. - fn reconstruct(&mut self, (x0, y0): (i32, i32), log2: u32, c: usize, qp: i32, ts: bool, (max_x, max_y): (usize, usize)) -> Result<()> { + /// Transform of the scaled coefficients `nz[..nnz]` and addition to the prediction. + fn reconstruct(&mut self, (x0, y0): (i32, i32), log2: u32, c: usize, ts: bool, nnz: usize, (max_x, max_y): (usize, usize)) -> Result<()> { let n = 1usize << log2; let bd = if c == 0 { self.pic.bd_y } else { self.pic.bd_c }; - let coeffs = &mut self.coeffs[..n * n]; - let mut dc_only = false; - if !self.cu_transquant_bypass { - // scaling (8.6.3) - let bd_shift = bd + log2 - 5; - let round = 1i64 << (bd_shift - 1); - let scale = (LEVEL_SCALE[(qp % 6) as usize] as i64) << (qp / 6); - let m: Option<&[u8]> = match &self.pic.scaling { - Some(s) if !(ts && n > 4) => { - let size_id = (log2 - 2) as usize; - let matrix_id = if self.cu_intra { c } else { 3 + c }; - Some(&s[size_id * 6 + matrix_id]) - } - _ => None, - }; - for y in 0..=max_y { - for x in 0..=max_x { - let v = coeffs[y * n + x]; - if v != 0 { - let f = m.map_or(16, |m| m[y * n + x] as i64); - coeffs[y * n + x] = ((v as i64 * f * scale + round) >> bd_shift).clamp(-32768, 32767) as i32; - } - } + let bypass = self.cu_transquant_bypass; + let dst = self.cu_intra && c == 0 && n == 4; + let (stride, max) = (if c == 0 { self.pic.width } else { self.pic.cwidth }, (1i32 << bd) - 1); + let off = y0 as usize * stride + x0 as usize; + let plane = &mut self.pic.planes[c]; + let bd_shift = 20 - bd; + if !bypass && !ts && max_x == 0 && max_y == 0 && !dst { + let v = transform::inverse_dc(self.nz[0].1, bd_shift); + match n { + 4 => add_dc::(plane, off, stride, v, max), + 8 => add_dc::(plane, off, stride, v, max), + 16 => add_dc::(plane, off, stride, v, max), + _ => add_dc::(plane, off, stride, v, max), } - let bd_shift = 20 - bd; + return Ok(()); + } + // the inverse transform reads only the bounding box of the coefficients + let coeffs = &mut self.coeffs[..n * n]; + if bypass || ts { + coeffs.fill(0); + } else { + for row in coeffs.chunks_exact_mut(n).take(max_y + 1) { + row[..=max_x].fill(0); + } + } + for &(p, v) in &self.nz[..nnz] { + coeffs[p as usize] = v; + } + if !bypass { if ts { transform::transform_skip(coeffs, n, bd_shift); - } else if max_x == 0 && max_y == 0 && !(self.cu_intra && c == 0 && n == 4) { - let v = transform::inverse_dc(coeffs[0], bd_shift); - coeffs.fill(v); - dc_only = true; } else { - let dst = self.cu_intra && c == 0 && n == 4; transform::inverse_transform(coeffs, n, dst, max_x, max_y, bd_shift); } } - let _ = dc_only; - let (stride, max) = (if c == 0 { self.pic.width } else { self.pic.cwidth }, (1i32 << bd) - 1); - let plane = &mut self.pic.planes[c]; - for y in 0..n { - let row = &mut plane[(y0 as usize + y) * stride + x0 as usize..][..n]; - for (x, s) in row.iter_mut().enumerate() { - *s = S::from_i32((s.to_i32() + coeffs[y * n + x]).clamp(0, max)); - } + match n { + 4 => add_residual::(plane, off, stride, coeffs, max), + 8 => add_residual::(plane, off, stride, coeffs, max), + 16 => add_residual::(plane, off, stride, coeffs, max), + _ => add_residual::(plane, off, stride, coeffs, max), } Ok(()) } } + +#[inline(always)] +fn add_residual(plane: &mut [S], off: usize, stride: usize, res: &[i32], max: i32) { + for (y, r) in res.as_chunks::().0.iter().take(N).enumerate() { + let row = &mut plane[off + y * stride..][..N]; + for (s, &d) in row.iter_mut().zip(r) { + *s = S::from_i32((s.to_i32() + d).max(0).min(max)); + } + } +} + +#[inline(always)] +fn add_dc(plane: &mut [S], off: usize, stride: usize, v: i32, max: i32) { + for y in 0..N { + for s in &mut plane[off + y * stride..][..N] { + *s = S::from_i32((s.to_i32() + v).max(0).min(max)); + } + } +} diff --git a/crates/video/src/hevc/decode/tables.rs b/crates/video/src/hevc/decode/tables.rs index 7e20bd99e..1c9c39c44 100644 --- a/crates/video/src/hevc/decode/tables.rs +++ b/crates/video/src/hevc/decode/tables.rs @@ -51,6 +51,72 @@ pub fn scan_order(log2: u32, scan_idx: usize) -> &'static [(u8, u8)] { } } +/// Inverse of a scan of an `N x N` block: scan position at `[y * N + x]`. +const fn inverse(scan: [(u8, u8); L], n: usize) -> [u8; L] { + let mut out = [0u8; L]; + let mut i = 0; + while i < L { + out[scan[i].1 as usize * n + scan[i].0 as usize] = i as u8; + i += 1; + } + out +} + +static INV_SCAN_1: [[u8; 1]; 3] = [[0], [0], [0]]; +static INV_SCAN_2: [[u8; 4]; 3] = [inverse(diag::<4>(2), 2), inverse(hv::<4>(2, false), 2), inverse(hv::<4>(2, true), 2)]; +static INV_SCAN_4: [[u8; 16]; 3] = [inverse(diag::<16>(4), 4), inverse(hv::<16>(4, false), 4), inverse(hv::<16>(4, true), 4)]; +static INV_SCAN_8: [[u8; 64]; 3] = [inverse(diag::<64>(8), 8), inverse(hv::<64>(8, false), 8), inverse(hv::<64>(8, true), 8)]; + +/// Position of (x, y) in ScanOrder[log2BlockSize][scanIdx] (log2BlockSize 0..=3). +#[inline] +pub fn scan_pos(log2: u32, scan_idx: usize, x: u32, y: u32) -> usize { + let i = ((y << log2) + x) as usize; + (match log2 { + 0 => INV_SCAN_1[scan_idx][i], + 1 => INV_SCAN_2[scan_idx][i], + 2 => INV_SCAN_4[scan_idx][i], + _ => INV_SCAN_8[scan_idx][i], + }) as usize +} + +/// sig_coeff_flag ctxInc (9.3.4.2.5) by scan position n inside a 4x4 sub-block, `[scanIdx][k][n]`: +/// k = prevCsbf (0..=3) gives sigCtx of blocks larger than 4x4 before the position and size +/// offsets; k = 4 gives ctxIdxMap of 4x4 blocks. +pub static SIG_CTX: [[[u8; 16]; 5]; 3] = [sig_ctx(diag::<16>(4)), sig_ctx(hv::<16>(4, false)), sig_ctx(hv::<16>(4, true))]; + +const fn sig_ctx(scan: [(u8, u8); 16]) -> [[u8; 16]; 5] { + let mut out = [[0u8; 16]; 5]; + let mut n = 0; + while n < 16 { + let (x, y) = (scan[n].0, scan[n].1); + out[0][n] = if x + y == 0 { + 2 + } else if x + y < 3 { + 1 + } else { + 0 + }; + out[1][n] = if y == 0 { + 2 + } else if y == 1 { + 1 + } else { + 0 + }; + out[2][n] = if x == 0 { + 2 + } else if x == 1 { + 1 + } else { + 0 + }; + out[3][n] = 2; + out[4][n] = CTX_IDX_MAP[(y as usize) * 4 + x as usize]; + n += 1; + } + out +} + /// Up-right diagonal scan for log2 size 2 or 3. pub fn scan_diag(log2: u32) -> &'static [(u8, u8)] { scan_order(log2, 0) @@ -81,7 +147,7 @@ pub fn qpc(qpi: i32, chroma_array_type_1: bool) -> i32 { } /// Table 9-50 ctxIdxMap for 4x4 sig_coeff_flag contexts. -pub static CTX_IDX_MAP: [u8; 16] = [0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8]; +pub const CTX_IDX_MAP: [u8; 16] = [0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8]; /// levelScale (8-309). pub static LEVEL_SCALE: [i32; 6] = [40, 45, 51, 57, 64, 72]; @@ -137,6 +203,17 @@ mod tests { assert_eq!(SCAN_4[1][1], (1, 0)); } + #[test] + fn scan_pos_inverts_scan_order() { + for log2 in 0..4 { + for scan_idx in 0..3 { + for (i, &(x, y)) in scan_order(log2, scan_idx).iter().enumerate() { + assert_eq!(scan_pos(log2, scan_idx, x as u32, y as u32), i); + } + } + } + } + #[test] fn dct_matrix_properties() { // rows are nearly orthogonal with norm ~ 64^2 * 32 From 45ddc4ffa6243c5509ef34c8b5260acdcc90b645 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 12 Nov 2026 22:05:44 +0100 Subject: [PATCH 003/382] mpegts: a repeated PAT or PMT packet is not appended to the section in progress The scan fed every PAT and PMT packet to the section parser, so a packet sent twice (same continuity counter and payload, H.222.0 2.4.3.3) appended its payload to the section being collected. PAT and PMT packets now go through a per-PID repeat guard first, like the elementary stream packets; a packet that signals a discontinuity is never taken for a repeat. The rest of storytold/Filmcraft#1438 is already in craft-media (#993). Co-Authored-By: Claude Sonnet 5.5 --- crates/media/src/mpegts/tests.rs | 17 +++++++++++++++++ crates/media/src/mpegts/ts.rs | 8 ++++++++ 2 files changed, 25 insertions(+) diff --git a/crates/media/src/mpegts/tests.rs b/crates/media/src/mpegts/tests.rs index 0215680ad..b9cb1af3b 100644 --- a/crates/media/src/mpegts/tests.rs +++ b/crates/media/src/mpegts/tests.rs @@ -791,6 +791,23 @@ fn scrambled_packet_is_skipped_with_a_warning() { assert!(total(&f) < total(&base)); } +#[test] +fn repeated_pat_and_pmt_packets_are_dropped_before_the_section_parser() { + let clean = audio_ts(2); + let first = |pid: u16| { + (0..clean.len() / 188).map(|i| i * 188).find(|&o| (((clean[o + 1] & 0x1F) as u16) << 8 | clean[o + 2] as u16) == pid).expect("packet exists") + }; + let mut dup = clean.clone(); + for pid in [0x100, 0] { + let o = first(pid); + let copy = dup[o..o + 188].to_vec(); + dup.splice(o + 188..o + 188, copy); + } + let f = open(&dup).unwrap(); + assert!(f.warnings.iter().any(|w| w.contains("2 duplicate packet(s) dropped")), "{:?}", f.warnings); + assert!(!f.warnings.iter().any(|w| w.contains("continuity") || w.contains("CRC")), "{:?}", f.warnings); +} + #[test] fn duplicate_packet_is_dropped_but_a_different_payload_with_the_same_counter_is_kept() { let clean = audio_ts(6); diff --git a/crates/media/src/mpegts/ts.rs b/crates/media/src/mpegts/ts.rs index a4c01a986..1d28bb736 100644 --- a/crates/media/src/mpegts/ts.rs +++ b/crates/media/src/mpegts/ts.rs @@ -497,6 +497,7 @@ pub(crate) fn scan(src: &S, packet_size: usize, sync_off let mut warnings: Vec = Vec::new(); let mut pat = Psi::default(); let mut pmt = PmtState::default(); + let mut psi_dup: HashMap = HashMap::new(); let mut es: HashMap = HashMap::new(); let mut order: Vec = Vec::new(); // one timestamp unwrapper for the program: its streams share one clock, so a stream whose @@ -560,6 +561,13 @@ pub(crate) fn scan(src: &S, packet_size: usize, sync_off } continue; } + if pk.pid == 0 || Some(pk.pid) == pmt.pmt_pid { + // a repeated packet would append its payload to the section in progress + if psi_dup.entry(pk.pid).or_default().is_dup(&pk) { + duplicates += 1; + continue; + } + } if pk.pid == 0 { feed_pat(&pk, &mut pat, &mut pmt, &mut crc_errors); continue; From 81bf3feb39a3304a9d9bb30025ad208ffd158602 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 12 Nov 2026 22:09:46 +0100 Subject: [PATCH 004/382] mxf: CinemaDNG in MXF (frame-wrapped DNG pictures), read and write The demuxer identifies CinemaDNG from the CinemaDNG container labels, the registered MXF-GC TIFF/EP container and picture coding labels, a 42h picture element type, or a TIFF header with the DNGVersion tag at the start of the essence. The writer produces OP1a files with frame-wrapped DNG pictures, the provisional container label, element type 42h and an RGBA descriptor (no coding label); OP-Atom is refused because it is clip-wrapped here. Same change as the crates/mxf part of storytold/Filmcraft#1078, ported onto craft-media. Co-Authored-By: Claude Sonnet 5.5 --- crates/media/README.md | 11 +++- crates/media/src/mxf/essence.rs | 81 ++++++++++++++++++++++++++-- crates/media/src/mxf/file.rs | 8 ++- crates/media/src/mxf/mod.rs | 5 +- crates/media/src/mxf/write.rs | 54 ++++++++++++++++--- crates/media/src/mxf/write/labels.rs | 4 ++ crates/media/src/mxf/write/tests.rs | 50 +++++++++++++++++ 7 files changed, 198 insertions(+), 15 deletions(-) diff --git a/crates/media/README.md b/crates/media/README.md index 387ab8cdd..48c930d1b 100644 --- a/crates/media/README.md +++ b/crates/media/README.md @@ -614,6 +614,7 @@ Implemented from the SMPTE documents (editions used): | SMPTE ST 386 | 2004 | D-10 (IMX) mapping: container label, sound element type | | SMPTE ST 2019-4 | 2009 | VC-3 (DNxHD / DNxHR) mapping | | SMPTE RDD 44 | 2017 | Apple ProRes mapping | +| Adobe CinemaDNG Image Data Format Specification | 1.0.0.0 (September 2009), §7 | CinemaDNG in MXF: frame-wrapped DNG picture elements (element type 42h), the essence container labels for CFA / LinearRaw content, RGBA descriptor; the labels are the specification's **provisional** values from Adobe's experimental range (byte 9 = 0Fh), not SMPTE-registered | | SMPTE RP 224 / RP 210 | registers | labels: data definitions, picture coding, essence containers, operational patterns; property labels of the primer pack (writer) | | SMPTE ST 330 | 2011 | basic UMIDs of the written packages | @@ -655,7 +656,10 @@ let pcm = mxf.read_pcm(&file, a, 48_000, 1920)?; // planar f32, sample-exact orders by the bitstream (the AVC picture order counts). - **Codecs.** From the picture essence coding label, then the essence container label, then the essence bytes: AVC / AVC-Intra, VC-3, ProRes (profile from the label), MPEG-2, - MPEG-4 visual, JPEG 2000, DV, uncompressed. + MPEG-4 visual, JPEG 2000, DV, uncompressed, CinemaDNG (the CinemaDNG container labels, the + registered MXF-GC TIFF/EP container and TIFF/EP picture coding labels, a 42h picture element + type, or a TIFF header with the DNGVersion tag at the start of the essence; the DNG pictures + themselves are developed by `craft-raw`). - **Sound.** PCM chunks (frame- or clip-wrapped) with sample counts; `read_pcm` decodes little-endian 8/16/24/32-bit PCM (wave / AES3 descriptors) and ST 331 AES3 elements (D-10). - **Timecode.** The material package timecode component (start frame count, rounded base, @@ -728,7 +732,10 @@ w.finish()?; element types 0x0C / 0x0D), ProRes (RDD 44: coding label profile byte, container `02 1C`), AVC byte stream (ST 381-3: container `02 10 60`, coding label from `profile_idc`; Annex B access units with in-band SPS / PPS — the AVC sub-descriptor is not written), Broadcast Wave PCM - (ST 382: container `02 06 01/02`, element types 0x01 / 0x02). + (ST 382: container `02 06 01/02`, element types 0x01 / 0x02), CinemaDNG (frame-wrapped DNG + datasets, element type 0x42, the provisional container label `0F 0A 0D 0B 02 7F 01/02 00`, an + RGBA descriptor with pixel layout and reference levels of the decoded 16-bit RGB picture and no + coding label; OP-Atom is refused because it is clip-wrapped here and DNG datasets cannot be). - `write_opatom_pcm(&OpAtomPcm, &[i32])` builds a complete in-memory OP-Atom PCM file (AAF media consolidation); `encode_pcm` interleaves planar f32 as little-endian PCM. diff --git a/crates/media/src/mxf/essence.rs b/crates/media/src/mxf/essence.rs index 27f893dc5..2c0d1ef7e 100644 --- a/crates/media/src/mxf/essence.rs +++ b/crates/media/src/mxf/essence.rs @@ -27,6 +27,9 @@ pub enum Codec { Dv, /// Uncompressed pictures (ST 384). Uncompressed, + /// CinemaDNG: one DNG (TIFF) dataset per frame-wrapped picture element (CinemaDNG Image Data + /// Format Specification §7), or TIFF/EP pictures under the registered MXF-GC TIFF/EP labels. + CinemaDng, /// Linear PCM, little-endian (Broadcast Wave and AES3 descriptors, ST 382). Pcm, /// 8-channel AES3 element data (ST 331, D-10 sound). @@ -46,13 +49,14 @@ impl Codec { Codec::Jpeg2000 => "JPEG 2000", Codec::Dv => "DV", Codec::Uncompressed => "Uncompressed", + Codec::CinemaDng => "CinemaDNG", Codec::Pcm => "PCM", Codec::Aes3Element => "AES3 PCM", Codec::Unknown => "unknown", } } /// The crate-wide identifier: VC-3 is [`CodecId::Dnxhd`], PCM and AES3 element data are - /// [`CodecId::Pcm`]; JPEG 2000, DV and uncompressed pictures have no identifier. + /// [`CodecId::Pcm`]; JPEG 2000, DV, uncompressed and CinemaDNG pictures have no identifier. /// /// [`CodecId::Dnxhd`]: crate::CodecId::Dnxhd /// [`CodecId::Pcm`]: crate::CodecId::Pcm @@ -65,15 +69,35 @@ impl Codec { Codec::Mpeg2 => Id::Mpeg2Video, Codec::Mpeg4Visual => Id::Mpeg4Video, Codec::Pcm | Codec::Aes3Element => Id::Pcm, - Codec::Jpeg2000 | Codec::Dv | Codec::Uncompressed | Codec::Unknown => Id::Unknown, + Codec::Jpeg2000 | Codec::Dv | Codec::Uncompressed | Codec::CinemaDng | Codec::Unknown => Id::Unknown, } } /// Every picture is coded independently. pub fn intra_only(&self) -> bool { - matches!(self, Codec::Avc { intra: true } | Codec::Vc3 | Codec::ProRes { .. } | Codec::Jpeg2000 | Codec::Dv | Codec::Uncompressed) + matches!( + self, + Codec::Avc { intra: true } | Codec::Vc3 | Codec::ProRes { .. } | Codec::Jpeg2000 | Codec::Dv | Codec::Uncompressed | Codec::CinemaDng + ) } } +/// The CinemaDNG essence container labels (CinemaDNG Image Data Format Specification 1.0.0.0, +/// §7.2.1): provisional, unregistered labels from Adobe's experimental range (byte 9 = 0F h), +/// `…0F 0A 0D 0B 02 7F cc 00` with content kind `cc` 01 (CFA) or 02 (LinearRaw). +pub const CINEMADNG_CONTAINER_PREFIX: [u8; 6] = [0x0F, 0x0A, 0x0D, 0x0B, 0x02, 0x7F]; + +/// Element type (byte 15 of the picture element key) of a frame-wrapped CinemaDNG picture: the +/// "TIFF" type of ST 331 (CinemaDNG specification §7.1.1.2). +pub const CINEMADNG_ELEMENT_TYPE: u8 = 0x42; + +/// Whether `ul` is a CinemaDNG essence container label (CFA or LinearRaw content), or the +/// registered MXF-GC TIFF/EP container (`…0D 01 03 01 02 14 ww 00`, RP 224). +pub fn is_cinemadng_container(ul: &Ul) -> bool { + ul.is_smpte() + && (ul.item_starts_with(&CINEMADNG_CONTAINER_PREFIX) && matches!(ul.0[14], 0x01 | 0x02) + || ul.item_starts_with(&[0x0D, 0x01, 0x03, 0x01, 0x02, 0x14])) +} + /// Identify a picture codec from the picture essence coding label and the essence container label. pub fn identify_picture(coding: Option
    , container: Option
      , mpeg_descriptor: bool) -> Codec { if let Some(c) = coding.filter(Ul::is_smpte) { @@ -81,6 +105,9 @@ pub fn identify_picture(coding: Option
        , container: Option
          , mpeg_descript // 04 01 02 02 .. : compressed picture coding if b[8..12] == [0x04, 0x01, 0x02, 0x02] { match (b[12], b[13]) { + // TIFF/EP Profile 2 picture coding (RP 224: 03 02 01 01 uncompressed CFA … 04 + // compressed LinearRaw), the coding of DNG pictures + (0x03, 0x02) if b[14] == 0x01 => return Codec::CinemaDng, // 01: MPEG compression (ISO/IEC 13818-2 profiles, 14496-2, 14496-10) (0x01, 0x01..=0x1F) => return Codec::Mpeg2, (0x01, 0x20..=0x2F) => return Codec::Mpeg4Visual, @@ -99,6 +126,9 @@ pub fn identify_picture(coding: Option
            , container: Option
              , mpeg_descript return Codec::Uncompressed; } } + if container.is_some_and(|c| is_cinemadng_container(&c)) { + return Codec::CinemaDng; + } if let Some(c) = container.filter(Ul::is_smpte) && c.item_starts_with(&[0x0D, 0x01, 0x03, 0x01, 0x02]) { @@ -117,8 +147,30 @@ pub fn identify_picture(coding: Option
                , container: Option
                  , mpeg_descript if mpeg_descriptor { Codec::Mpeg2 } else { Codec::Unknown } } +/// DNG evidence in the leading bytes of a TIFF: a TIFF 6.0 §2 header whose first IFD, when it lies +/// within `b`, holds the DNGVersion tag (DNG 1.x §2, tag 50706). A plain TIFF has no such tag. +fn is_dng(b: &[u8]) -> bool { + let le = match b.get(..4) { + Some(h) if h == b"II*\0" => true, + Some(h) if h == b"MM\0*" => false, + _ => return false, + }; + let u16_at = |o: usize| b.get(o..o + 2).map(|v| if le { u16::from_le_bytes([v[0], v[1]]) } else { u16::from_be_bytes([v[0], v[1]]) }); + let Some(ifd) = b.get(4..8).map(|v| if le { u32::from_le_bytes([v[0], v[1], v[2], v[3]]) } else { u32::from_be_bytes([v[0], v[1], v[2], v[3]]) }) + else { + return false; + }; + let Some(count) = usize::try_from(ifd).ok().and_then(|o| u16_at(o).map(|n| (o, n))) else { + return false; + }; + (0..usize::from(count.1)).any(|i| u16_at(count.0 + 2 + i * 12) == Some(50706)) +} + /// Identify a picture codec from the first bytes of an essence element. pub fn sniff_picture(b: &[u8]) -> Option { + if is_dng(b) { + return Some(Codec::CinemaDng); + } if b.len() >= 8 && &b[4..8] == b"icpf" { return Some(Codec::ProRes { profile: None }); } @@ -367,6 +419,20 @@ mod tests { assert_eq!(identify_picture(None, None, false), Codec::Unknown); } + #[test] + fn identifies_cinemadng() { + // CinemaDNG specification §7.2.1: CFA and LinearRaw containers (any registry version byte) + let adobe = |kind: u8| Ul([0x06, 0x0E, 0x2B, 0x34, 0x04, 0x01, 0x01, 0x01, 0x0F, 0x0A, 0x0D, 0x0B, 0x02, 0x7F, kind, 0x00]); + assert_eq!(identify_picture(None, Some(adobe(1)), false), Codec::CinemaDng); + assert_eq!(identify_picture(None, Some(adobe(2)), false), Codec::CinemaDng); + assert_eq!(identify_picture(None, Some(adobe(3)), false), Codec::Unknown); + // RP 224: MXF-GC frame-wrapped TIFF/EP container, TIFF/EP picture coding + assert_eq!(identify_picture(None, Some(ul(&[0x0D, 1, 3, 1, 2, 0x14, 1])), false), Codec::CinemaDng); + assert_eq!(identify_picture(Some(ul(&[4, 1, 2, 2, 3, 2, 1, 3])), None, false), Codec::CinemaDng); + assert!(Codec::CinemaDng.intra_only()); + assert_eq!(Codec::CinemaDng.name(), "CinemaDNG"); + } + #[test] fn sniffs_essence() { assert_eq!(sniff_picture(&[0, 0, 0, 1, 0x09, 0x10]), Some(Codec::Avc { intra: false })); @@ -374,6 +440,15 @@ mod tests { assert_eq!(sniff_picture(&[0, 0, 2, 0x80, 1]), Some(Codec::Vc3)); assert_eq!(sniff_picture(&[0, 0, 0, 9, b'i', b'c', b'p', b'f']), Some(Codec::ProRes { profile: None })); assert_eq!(sniff_picture(&[1, 2, 3]), None); + // a TIFF header alone is not DNG; an IFD0 with the DNGVersion tag (50706 = 0xC612) is + let tiff_le = |tag: u16| [b"II*\0\x08\0\0\0\x01\0".as_slice(), &tag.to_le_bytes(), &[1, 0, 4, 0, 0, 0, 1, 4, 0, 0], &[0; 8]].concat(); + let tiff_be = |tag: u16| [b"MM\0*\0\0\0\x08\0\x01".as_slice(), &tag.to_be_bytes(), &[0, 1, 0, 0, 0, 4, 1, 4, 0, 0], &[0; 8]].concat(); + assert_eq!(sniff_picture(&tiff_le(0xC612)), Some(Codec::CinemaDng)); + assert_eq!(sniff_picture(&tiff_be(0xC612)), Some(Codec::CinemaDng)); + assert_eq!(sniff_picture(&tiff_le(0x0100)), None); + assert_eq!(sniff_picture(&tiff_be(0x0100)), None); + assert_eq!(sniff_picture(b"II*\0\x08\0\0\0"), None); + assert_eq!(sniff_picture(b"II*\0"), None); } #[test] diff --git a/crates/media/src/mxf/file.rs b/crates/media/src/mxf/file.rs index 15d847c7d..9064bcb83 100644 --- a/crates/media/src/mxf/file.rs +++ b/crates/media/src/mxf/file.rs @@ -910,7 +910,7 @@ fn build_track( } // A wrong or missing label: trust the essence bytes. if let Some(first) = elements.first() { - let head = read_upto(src, first.value_offset, 64)?; + let head = read_upto(src, first.value_offset, 4096)?; if let Some(sniffed) = sniff_picture(&head) { let agree = std::mem::discriminant(&sniffed) == std::mem::discriminant(&codec); if !agree && !matches!(codec, Codec::Avc { intra: true }) { @@ -918,6 +918,12 @@ fn build_track( } } } + // CinemaDNG §7.1.1.2: a "TIFF" picture element type names DNG pictures + if codec == Codec::Unknown + && elements.first().is_some_and(|e| e.key.0[12] == 0x15 && e.key.0[14] == super::essence::CINEMADNG_ELEMENT_TYPE) + { + codec = Codec::CinemaDng; + } t.codec = codec; t.picture = Some(pi); build_pictures(src, &mut t, elements, index, warnings)?; diff --git a/crates/media/src/mxf/mod.rs b/crates/media/src/mxf/mod.rs index ca0e8f918..56de637c7 100644 --- a/crates/media/src/mxf/mod.rs +++ b/crates/media/src/mxf/mod.rs @@ -2,7 +2,8 @@ //! ST 377-1 (file format: KLV, partitions, primer pack, header metadata, index tables, random //! index pack), ST 378 (OP1a), ST 390 (OP-Atom), ST 379-1/2 (generic container), ST 381-1 (MPEG //! video mapping), ST 381-3 (AVC mapping), ST 382 (AES3 / Broadcast Wave audio mapping), ST 331 -//! (AES3 element data, D-10 sound), ST 2019-4 (VC-3 mapping) and RDD 44 (ProRes mapping). +//! (AES3 element data, D-10 sound), ST 2019-4 (VC-3 mapping), RDD 44 (ProRes mapping) and the CinemaDNG +//! specification's MXF mapping (frame-wrapped DNG pictures). //! //! [`open`] walks the file's KLV packets (keys and lengths only; essence payloads are never read //! while opening), parses the partition packs, the primer pack and header metadata of the most @@ -32,7 +33,7 @@ mod meta; pub mod write; pub use crate::source::{ByteSource, ReadSeekSource}; -pub use essence::{Codec, PictureInfo, SoundFormat, SoundInfo, aes3_element_samples, decode_pcm}; +pub use essence::{CINEMADNG_CONTAINER_PREFIX, CINEMADNG_ELEMENT_TYPE, Codec, PictureInfo, SoundFormat, SoundInfo, aes3_element_samples, decode_pcm}; pub use file::{Chunk, EssenceTrack, MxfFile, OperationalPattern, Partition, PartitionKind, Sample, Timecode, TrackKind, Wrapping, open}; pub use index::{IndexEntry, IndexSegment}; pub use klv::{Rational, Ul}; diff --git a/crates/media/src/mxf/write.rs b/crates/media/src/mxf/write.rs index 9fb6bfea2..42abf846f 100644 --- a/crates/media/src/mxf/write.rs +++ b/crates/media/src/mxf/write.rs @@ -107,6 +107,10 @@ pub enum PictureCoding { ProRes { profile: u8 }, /// H.264 / AVC Annex B byte stream; `profile_idc` from the SPS (66, 77, 100, …). Avc { profile_idc: u8, intra: bool }, + /// CinemaDNG: one DNG dataset per picture (CinemaDNG specification §7), frame-wrapped only, + /// with an RGBA descriptor of the decoded 16-bit RGB image. `linear_raw`: the pictures are + /// LinearRaw (PhotometricInterpretation 34892) rather than CFA (32803). + CinemaDng { linear_raw: bool }, } impl PictureCoding { @@ -116,9 +120,10 @@ impl PictureCoding { _ => true, } } - /// Picture essence coding label. - fn coding_label(&self) -> [u8; 16] { - match *self { + /// Picture essence coding label (None: CinemaDNG, which has no registered one, §7.2.2.2). + fn coding_label(&self) -> Option<[u8; 16]> { + Some(match *self { + PictureCoding::CinemaDng { .. } => return None, PictureCoding::Vc3 { cid } => { let code = if (1235..=1234 + 0x7F).contains(&cid) { (cid - 1234) as u8 } else { 0 }; [0x06, 0x0E, 0x2B, 0x34, 0x04, 0x01, 0x01, 0x0A, 0x04, 0x01, 0x02, 0x02, 0x71, code, 0x00, 0x00] @@ -145,7 +150,7 @@ impl PictureCoding { }; [0x06, 0x0E, 0x2B, 0x34, 0x04, 0x01, 0x01, 0x0A, 0x04, 0x01, 0x02, 0x02, 0x01, b13, b14, 0x01] } - } + }) } /// (essence container label, element type) for frame or clip wrapping. fn container(&self, clip: bool) -> ([u8; 16], u8) { @@ -154,6 +159,12 @@ impl PictureCoding { PictureCoding::Vc3 { .. } => (essence_container(0x0A, 0x11, w, 0x00), if clip { 0x0D } else { 0x0C }), PictureCoding::ProRes { .. } => (essence_container(0x0D, 0x1C, w, 0x00), if clip { 0x18 } else { 0x17 }), PictureCoding::Avc { .. } => (essence_container(0x0A, 0x10, 0x60, w), if clip { 0x16 } else { 0x15 }), + // CinemaDNG §7.2.1 (provisional label) and §7.1.1.2 (element type 42h); always frame + // wrapped (`MxfWriter::new` refuses clip wrapping) + PictureCoding::CinemaDng { linear_raw } => ( + [0x06, 0x0E, 0x2B, 0x34, 0x04, 0x01, 0x01, 0x01, 0x0F, 0x0A, 0x0D, 0x0B, 0x02, 0x7F, if *linear_raw { 0x02 } else { 0x01 }, 0x00], + 0x42, + ), } } } @@ -202,6 +213,8 @@ impl PictureDesc { if matches!(cid, 1235 | 1241 | 1250 | 1256 | 1270 | 1271) { 10 } else { 8 }, if matches!(cid, 1256 | 1270) { (1, 1) } else { (2, 1) }, ), + // §7.2.2.3: the decoded image is described as 16 bits per component + PictureCoding::CinemaDng { .. } => (16, (1, 1)), }; PictureDesc { coding, @@ -589,6 +602,19 @@ impl MxfWriter { return Err(io::Error::new(io::ErrorKind::InvalidInput, "invalid PCM sound description")); } let clip = cfg.pattern == Pattern::OpAtom; + if clip && matches!(cfg.picture.as_ref().map(|p| p.coding), Some(PictureCoding::CinemaDng { .. })) { + // CinemaDNG §7.1.1: a TIFF dataset has no length field, so DNG pictures can't be clip wrapped + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "CinemaDNG pictures are frame wrapped only (this writer's OP-Atom is clip wrapped)", + )); + } + if let Some(p) = &cfg.picture { + // CinemaDNG §7.2.2.3 fixes the decoded image at 16 bits per component + if matches!(p.coding, PictureCoding::CinemaDng { .. }) && p.depth != 16 { + return Err(io::Error::new(io::ErrorKind::InvalidInput, "CinemaDNG pictures are described at 16 bits per component")); + } + } let mut tracks = Vec::new(); let mut id = cfg.first_track_id.max(2); if let Some(p) = &cfg.picture { @@ -985,7 +1011,8 @@ impl MxfWriter { TrackKind::Picture => { // Picture tracks exist only with a picture configuration. let Some(p) = cfg.picture.as_ref() else { continue }; - let mut s = Set::new(0x28, uid); + let rgba = matches!(p.coding, PictureCoding::CinemaDng { .. }); + let mut s = Set::new(if rgba { 0x29 } else { 0x28 }, uid); if multiple { s.u32(0x3006, t.id); } @@ -1020,8 +1047,21 @@ impl MxfWriter { // field dominance: the temporally first field (1 top, 2 bottom) s.u8(0x3212, if p.bottom_field_first { 2 } else { 1 }); } - s.p(0x3201, &p.coding.coding_label()) - .p(0x3210, &tcl) + if let Some(label) = p.coding.coding_label() { + s.p(0x3201, &label); + } + if rgba { + // RGBA descriptor (ST 377-1 G.2.40): pixel layout R, G, B of 16 bits each and + // the component reference levels. CinemaDNG §7.2.2.3 fixes the decoded + // image at 16 bits; `MxfWriter::new` rejects any other `PictureDesc::depth`. + let mut layout = [0u8; 16]; + layout[..6].copy_from_slice(&[b'R', 16, b'G', 16, b'B', 16]); + let max = u32::from(u16::MAX); + s.p(0x3401, &layout).u32(0x3406, max).u32(0x3407, 0); + s.write(&mut out); + continue; + } + s.p(0x3210, &tcl) .p(0x321A, &ce) .p(0x3219, &cp) .u32(0x3301, depth) diff --git a/crates/media/src/mxf/write/labels.rs b/crates/media/src/mxf/write/labels.rs index eb8fbc040..12f62c7fd 100644 --- a/crates/media/src/mxf/write/labels.rs +++ b/crates/media/src/mxf/write/labels.rs @@ -120,6 +120,10 @@ pub const PRIMER: &[(u16, [u8; 16])] = &[ (0x3304, ul(&[0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x05, 0x03, 0x03])), (0x3305, ul(&[0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x05, 0x03, 0x04])), (0x3306, ul(&[0x01, 0x01, 0x01, 0x02, 0x04, 0x01, 0x05, 0x03, 0x05])), + // RGBA picture essence descriptor (ST 377-1; RP 210): PixelLayout, ComponentMaxRef, ComponentMinRef + (0x3401, ul(&[0x01, 0x01, 0x01, 0x02, 0x04, 0x01, 0x05, 0x03, 0x06])), + (0x3406, ul(&[0x01, 0x01, 0x01, 0x05, 0x04, 0x01, 0x05, 0x03, 0x0B])), + (0x3407, ul(&[0x01, 0x01, 0x01, 0x05, 0x04, 0x01, 0x05, 0x03, 0x0C])), (0x3D03, ul(&[0x01, 0x01, 0x01, 0x05, 0x04, 0x02, 0x03, 0x01, 0x01, 0x01])), (0x3D02, ul(&[0x01, 0x01, 0x01, 0x04, 0x04, 0x02, 0x03, 0x01, 0x04])), (0x3D07, ul(&[0x01, 0x01, 0x01, 0x05, 0x04, 0x02, 0x01, 0x01, 0x04])), diff --git a/crates/media/src/mxf/write/tests.rs b/crates/media/src/mxf/write/tests.rs index 91574fec7..eac50a0e9 100644 --- a/crates/media/src/mxf/write/tests.rs +++ b/crates/media/src/mxf/write/tests.rs @@ -401,6 +401,56 @@ fn long_pcm_reads_backed_by_the_file_are_not_capped() { assert!(m.read_pcm(&f, 0, 0, frames + (1 << 24)).is_err()); } +/// A TIFF-headed stand-in for a DNG dataset (the demuxer only carries the bytes). +fn dng_like(i: usize) -> Vec { + let mut v = b"II*\0\x08\0\0\0".to_vec(); + v.extend(std::iter::repeat_n(i as u8 ^ 0x33, 300 + 11 * i)); + v +} + +#[test] +fn cinemadng_op1a_reads_back() { + for linear_raw in [false, true] { + let mut cfg = op1a_config(Rational::new(24, 1), PictureCoding::CinemaDng { linear_raw }); + cfg.sound.truncate(1); + let mut w = MxfWriter::new(Cursor::new(Vec::new()), cfg).unwrap(); + for i in 0..6 { + w.push_picture(&dng_like(i), FrameInfo::intra()).unwrap(); + w.push_sound(0, &pcm16(i * 2000, 2000)).unwrap(); + } + let f = w.finish().unwrap().into_inner(); + // CinemaDNG §7.1.1.2: picture element key 06.0E.2B.34.01.02.01.01.0D.01.03.01.15.01.42.01 + let key = [0x06, 0x0E, 0x2B, 0x34, 0x01, 0x02, 0x01, 0x01, 0x0D, 0x01, 0x03, 0x01, 0x15, 0x01, 0x42, 0x01]; + assert_eq!(f.windows(16).filter(|k| *k == key).count(), 6); + // §7.2.1: the essence container label of the content kind + let ec = [0x06, 0x0E, 0x2B, 0x34, 0x04, 0x01, 0x01, 0x01, 0x0F, 0x0A, 0x0D, 0x0B, 0x02, 0x7F, if linear_raw { 2 } else { 1 }, 0x00]; + assert!(f.windows(16).any(|k| k == ec)); + let m = open(&f).unwrap(); + assert!(m.warnings.is_empty(), "{:?}", m.warnings); + let v = m.track_of_kind(TrackKind::Picture).unwrap(); + let t = &m.tracks[v]; + assert_eq!(t.codec, Codec::CinemaDng); + assert_eq!(t.wrapping, Wrapping::Frame); + assert_eq!(t.samples.len(), 6); + let p = t.picture.as_ref().unwrap(); + assert!(p.rgba, "RGBA picture essence descriptor (§7.2.2)"); + assert_eq!((p.frame_width(), p.frame_height()), (64, 36)); + assert!(p.picture_coding.is_none()); + for i in 0..6 { + assert!(t.samples[i].key); + assert_eq!(m.read_sample(&f, v, i).unwrap(), dng_like(i)); + } + assert_eq!(m.timecode.unwrap().format(), "01:02:30:00"); + } +} + +#[test] +fn cinemadng_is_never_clip_wrapped() { + let mut cfg = WriterConfig::new(Pattern::OpAtom, Rational::new(24, 1), PackageIds::from_seed("t", "T")); + cfg.picture = Some(PictureDesc::new(PictureCoding::CinemaDng { linear_raw: false }, 64, 36)); + assert!(MxfWriter::new(Cursor::new(Vec::new()), cfg).is_err()); +} + /// One `push_sound` of a long clip must not cost more than the clip itself: draining the buffered /// PCM from the front for every edit unit made this quadratic (about 16 s for 10 minutes). #[test] From 9541787aa9666adeb71abf3d8c05ef28316178dc Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 12 Nov 2026 22:17:58 +0100 Subject: [PATCH 005/382] hevc: simplify scaling-list condition for clippy nonminimal_bool Co-Authored-By: Claude Sonnet 5.5 --- crates/video/src/hevc/decode/slicedec/transform_tree.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/video/src/hevc/decode/slicedec/transform_tree.rs b/crates/video/src/hevc/decode/slicedec/transform_tree.rs index aa099a957..1ffaebbff 100644 --- a/crates/video/src/hevc/decode/slicedec/transform_tree.rs +++ b/crates/video/src/hevc/decode/slicedec/transform_tree.rs @@ -417,7 +417,7 @@ impl<'a, S: Sample> SliceDecoder<'a, S> { let round = 1i64 << (bd_shift - 1); let scale = (LEVEL_SCALE[(qp % 6) as usize] as i64) << (qp / 6); let matrix = match &self.pic.scaling { - Some(s) if !bypass && !(ts && n > 4) => { + Some(s) if !(bypass || (ts && n > 4)) => { let size_id = (log2 - 2) as usize; let matrix_id = if self.cu_intra { c } else { 3 + c }; Some((s.clone(), size_id * 6 + matrix_id)) From 756def2bc6211909afcd894fc6c10c55c695d42c Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 12 Nov 2026 23:18:51 +0100 Subject: [PATCH 006/382] mxf: checked end offset for the TIFF u16 read in DNG sniffing Co-Authored-By: Claude Sonnet 5.5 --- crates/media/src/mxf/essence.rs | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/crates/media/src/mxf/essence.rs b/crates/media/src/mxf/essence.rs index 2c0d1ef7e..74818e0e8 100644 --- a/crates/media/src/mxf/essence.rs +++ b/crates/media/src/mxf/essence.rs @@ -147,6 +147,14 @@ pub fn identify_picture(coding: Option
                    , container: Option
                      , mpeg_descript if mpeg_descriptor { Codec::Mpeg2 } else { Codec::Unknown } } +/// Read a TIFF `u16` at offset `o`. The end offset is computed with checked arithmetic, so an +/// untrusted offset near `usize::MAX` (a 32-bit target with IFD offset `0xFFFF_FFFF`) is +/// out of bounds instead of overflowing. +fn tiff_u16(b: &[u8], le: bool, o: usize) -> Option { + let v = b.get(o..o.checked_add(2)?)?; + Some(if le { u16::from_le_bytes([v[0], v[1]]) } else { u16::from_be_bytes([v[0], v[1]]) }) +} + /// DNG evidence in the leading bytes of a TIFF: a TIFF 6.0 §2 header whose first IFD, when it lies /// within `b`, holds the DNGVersion tag (DNG 1.x §2, tag 50706). A plain TIFF has no such tag. fn is_dng(b: &[u8]) -> bool { @@ -155,7 +163,7 @@ fn is_dng(b: &[u8]) -> bool { Some(h) if h == b"MM\0*" => false, _ => return false, }; - let u16_at = |o: usize| b.get(o..o + 2).map(|v| if le { u16::from_le_bytes([v[0], v[1]]) } else { u16::from_be_bytes([v[0], v[1]]) }); + let u16_at = |o: usize| tiff_u16(b, le, o); let Some(ifd) = b.get(4..8).map(|v| if le { u32::from_le_bytes([v[0], v[1], v[2], v[3]]) } else { u32::from_be_bytes([v[0], v[1], v[2], v[3]]) }) else { return false; @@ -419,6 +427,15 @@ mod tests { assert_eq!(identify_picture(None, None, false), Codec::Unknown); } + #[test] + fn tiff_offset_near_usize_max_is_out_of_bounds() { + let b = [0x49, 0x49, 0x2A, 0x00, 0xFF, 0xFF, 0xFF, 0xFF]; + assert_eq!(tiff_u16(&b, true, usize::MAX), None); + assert_eq!(tiff_u16(&b, true, usize::MAX - 1), None); + assert_eq!(tiff_u16(&b, true, 0), Some(0x4949)); + assert!(!is_dng(&b)); + } + #[test] fn identifies_cinemadng() { // CinemaDNG specification §7.2.1: CFA and LinearRaw containers (any registry version byte) From 1bdaa7aff32035ca09a178d296b082a53366b3b7 Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Thu, 12 Nov 2026 23:23:02 -0500 Subject: [PATCH 007/382] craft-xlsx: the XLSB function table, with the numbers 0x17C-0x1E4 (port of gridcraft#3810) [MS-XLSB]'s Ftab (2.5.98.10) continues the [MS-XLS] table from 0x17C: the cube functions, the old Analysis ToolPak functions, IFERROR, COUNTIFS, SUMIFS and AVERAGEIF(S). Excel writes these by number in .xlsb (PtgFunc / PtgFuncVar) where .xls calls them by name, so an XLSB formula decoder needs them. Generated from the spec with the same argument-count rule as the existing entries. Ported from storytold/gridcraft#3810 (issue gridcraft#3806). There the entries were appended to GridCraft's .xls table, which is now craft-xls's. Here the table is craft-xlsx's own (xlsb/ftab.rs): craft-xls's 0-379, which match GridCraft's table before the PR, then the PR's entries. The two formats follow separate specifications and develop separately; they can share a table later if both readers settle on one. The PR's table checks come along. Its decoding checks (IFERROR, SUMIFS by number) go with the decoder in the next commit, and its check that every new name is a GridCraft function stays in GridCraft. --- crates/xlsx/src/xlsb.rs | 2 + crates/xlsx/src/xlsb/ftab.rs | 516 +++++++++++++++++++++++++++++++++++ 2 files changed, 518 insertions(+) create mode 100644 crates/xlsx/src/xlsb/ftab.rs diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index dbff61dd7..542fd580c 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -2,6 +2,8 @@ //! their records. Saved values only: formulas are token streams that are not decoded, and //! styles are not read. A record that does not parse fails the read. +mod ftab; + use std::sync::Arc; use craft_opc::{ContentTypes, Rels}; diff --git a/crates/xlsx/src/xlsb/ftab.rs b/crates/xlsx/src/xlsb/ftab.rs new file mode 100644 index 000000000..c6b59092a --- /dev/null +++ b/crates/xlsx/src/xlsb/ftab.rs @@ -0,0 +1,516 @@ +//! The XLSB function table ([MS-XLSB] 2.5.98.10, `Ftab`): the functions a `PtgFunc` or +//! `PtgFuncVar` token calls by number. Up to 379 (0x17B) it is the table of [MS-XLS] 2.5.198.17, +//! which craft-xls also carries. The entries from 380 (0x17C) on are the rest of the XLSB table: +//! XLSB files call these functions by number, where `.xls` files call them by name. Kept apart from +//! craft-xls's copy: the two formats follow separate specifications. + +/// (iftab, name, fixed argument count or -1 when the function takes a variable number of +/// arguments), sorted by number. +const FTAB: &[(u16, &str, i8)] = &[ + (0, "COUNT", -1), + (1, "IF", -1), + (2, "ISNA", 1), + (3, "ISERROR", 1), + (4, "SUM", -1), + (5, "AVERAGE", -1), + (6, "MIN", -1), + (7, "MAX", -1), + (8, "ROW", -1), + (9, "COLUMN", -1), + (10, "NA", 0), + (11, "NPV", -1), + (12, "STDEV", -1), + (13, "DOLLAR", -1), + (14, "FIXED", -1), + (15, "SIN", 1), + (16, "COS", 1), + (17, "TAN", 1), + (18, "ATAN", 1), + (19, "PI", 0), + (20, "SQRT", 1), + (21, "EXP", 1), + (22, "LN", 1), + (23, "LOG10", 1), + (24, "ABS", 1), + (25, "INT", 1), + (26, "SIGN", 1), + (27, "ROUND", 2), + (28, "LOOKUP", -1), + (29, "INDEX", -1), + (30, "REPT", 2), + (31, "MID", 3), + (32, "LEN", 1), + (33, "VALUE", 1), + (34, "TRUE", 0), + (35, "FALSE", 0), + (36, "AND", -1), + (37, "OR", -1), + (38, "NOT", 1), + (39, "MOD", 2), + (40, "DCOUNT", 3), + (41, "DSUM", 3), + (42, "DAVERAGE", 3), + (43, "DMIN", 3), + (44, "DMAX", 3), + (45, "DSTDEV", 3), + (46, "VAR", -1), + (47, "DVAR", 3), + (48, "TEXT", 2), + (49, "LINEST", -1), + (50, "TREND", -1), + (51, "LOGEST", -1), + (52, "GROWTH", -1), + (53, "GOTO", 1), + (54, "HALT", -1), + (55, "RETURN", -1), + (56, "PV", -1), + (57, "FV", -1), + (58, "NPER", -1), + (59, "PMT", -1), + (60, "RATE", -1), + (61, "MIRR", 3), + (62, "IRR", -1), + (63, "RAND", 0), + (64, "MATCH", -1), + (65, "DATE", 3), + (66, "TIME", 3), + (67, "DAY", 1), + (68, "MONTH", 1), + (69, "YEAR", 1), + (70, "WEEKDAY", -1), + (71, "HOUR", 1), + (72, "MINUTE", 1), + (73, "SECOND", 1), + (74, "NOW", 0), + (75, "AREAS", 1), + (76, "ROWS", 1), + (77, "COLUMNS", 1), + (78, "OFFSET", -1), + (79, "ABSREF", 2), + (80, "RELREF", 2), + (81, "ARGUMENT", -1), + (82, "SEARCH", -1), + (83, "TRANSPOSE", 1), + (84, "ERROR", -1), + (85, "STEP", 0), + (86, "TYPE", 1), + (87, "ECHO", -1), + (88, "SET.NAME", -1), + (89, "CALLER", 0), + (90, "DEREF", 1), + (91, "WINDOWS", -1), + (92, "SERIES", -1), + (93, "DOCUMENTS", -1), + (94, "ACTIVE.CELL", 0), + (95, "SELECTION", 0), + (96, "RESULT", -1), + (97, "ATAN2", 2), + (98, "ASIN", 1), + (99, "ACOS", 1), + (100, "CHOOSE", -1), + (101, "HLOOKUP", -1), + (102, "VLOOKUP", -1), + (103, "LINKS", -1), + (104, "INPUT", -1), + (105, "ISREF", 1), + (106, "GET.FORMULA", 1), + (107, "GET.NAME", -1), + (108, "SET.VALUE", 2), + (109, "LOG", -1), + (110, "EXEC", -1), + (111, "CHAR", 1), + (112, "LOWER", 1), + (113, "UPPER", 1), + (114, "PROPER", 1), + (115, "LEFT", -1), + (116, "RIGHT", -1), + (117, "EXACT", 2), + (118, "TRIM", 1), + (119, "REPLACE", 4), + (120, "SUBSTITUTE", -1), + (121, "CODE", 1), + (122, "NAMES", -1), + (123, "DIRECTORY", -1), + (124, "FIND", -1), + (125, "CELL", -1), + (126, "ISERR", 1), + (127, "ISTEXT", 1), + (128, "ISNUMBER", 1), + (129, "ISBLANK", 1), + (130, "T", 1), + (131, "N", 1), + (132, "FOPEN", -1), + (133, "FCLOSE", 1), + (134, "FSIZE", 1), + (135, "FREADLN", 1), + (136, "FREAD", 2), + (137, "FWRITELN", 2), + (138, "FWRITE", 2), + (139, "FPOS", -1), + (140, "DATEVALUE", 1), + (141, "TIMEVALUE", 1), + (142, "SLN", 3), + (143, "SYD", 4), + (144, "DDB", -1), + (145, "GET.DEF", -1), + (146, "REFTEXT", -1), + (147, "TEXTREF", -1), + (148, "INDIRECT", -1), + (149, "REGISTER", -1), + (150, "CALL", -1), + (151, "ADD.BAR", -1), + (152, "ADD.MENU", -1), + (153, "ADD.COMMAND", -1), + (154, "ENABLE.COMMAND", -1), + (155, "CHECK.COMMAND", -1), + (156, "RENAME.COMMAND", -1), + (157, "SHOW.BAR", -1), + (158, "DELETE.MENU", -1), + (159, "DELETE.COMMAND", -1), + (160, "GET.CHART.ITEM", -1), + (161, "DIALOG.BOX", 1), + (162, "CLEAN", 1), + (163, "MDETERM", 1), + (164, "MINVERSE", 1), + (165, "MMULT", 2), + (166, "FILES", -1), + (167, "IPMT", -1), + (168, "PPMT", -1), + (169, "COUNTA", -1), + (170, "CANCEL.KEY", -1), + (171, "FOR", -1), + (172, "WHILE", 1), + (173, "BREAK", 0), + (174, "NEXT", 0), + (175, "INITIATE", 2), + (176, "REQUEST", 2), + (177, "POKE", 3), + (178, "EXECUTE", 2), + (179, "TERMINATE", 1), + (180, "RESTART", -1), + (181, "HELP", -1), + (182, "GET.BAR", -1), + (183, "PRODUCT", -1), + (184, "FACT", 1), + (185, "GET.CELL", -1), + (186, "GET.WORKSPACE", 1), + (187, "GET.WINDOW", -1), + (188, "GET.DOCUMENT", -1), + (189, "DPRODUCT", 3), + (190, "ISNONTEXT", 1), + (191, "GET.NOTE", -1), + (192, "NOTE", -1), + (193, "STDEVP", -1), + (194, "VARP", -1), + (195, "DSTDEVP", 3), + (196, "DVARP", 3), + (197, "TRUNC", -1), + (198, "ISLOGICAL", 1), + (199, "DCOUNTA", 3), + (200, "DELETE.BAR", 1), + (201, "UNREGISTER", 1), + (204, "USDOLLAR", -1), + (205, "FINDB", -1), + (206, "SEARCHB", -1), + (207, "REPLACEB", 4), + (208, "LEFTB", -1), + (209, "RIGHTB", -1), + (210, "MIDB", 3), + (211, "LENB", 1), + (212, "ROUNDUP", 2), + (213, "ROUNDDOWN", 2), + (214, "ASC", 1), + (215, "DBCS", 1), + (216, "RANK", -1), + (219, "ADDRESS", -1), + (220, "DAYS360", -1), + (221, "TODAY", 0), + (222, "VDB", -1), + (223, "ELSE", 0), + (224, "ELSE.IF", 1), + (225, "END.IF", 0), + (226, "FOR.CELL", -1), + (227, "MEDIAN", -1), + (228, "SUMPRODUCT", -1), + (229, "SINH", 1), + (230, "COSH", 1), + (231, "TANH", 1), + (232, "ASINH", 1), + (233, "ACOSH", 1), + (234, "ATANH", 1), + (235, "DGET", 3), + (236, "CREATE.OBJECT", -1), + (237, "VOLATILE", -1), + (238, "LAST.ERROR", 0), + (239, "CUSTOM.UNDO", -1), + (240, "CUSTOM.REPEAT", -1), + (241, "FORMULA.CONVERT", -1), + (242, "GET.LINK.INFO", -1), + (243, "TEXT.BOX", -1), + (244, "INFO", 1), + (245, "GROUP", 0), + (246, "GET.OBJECT", -1), + (247, "DB", -1), + (248, "PAUSE", -1), + (251, "RESUME", -1), + (252, "FREQUENCY", 2), + (253, "ADD.TOOLBAR", -1), + (254, "DELETE.TOOLBAR", 1), + (256, "RESET.TOOLBAR", 1), + (257, "EVALUATE", 1), + (258, "GET.TOOLBAR", -1), + (259, "GET.TOOL", -1), + (260, "SPELLING.CHECK", -1), + (261, "ERROR.TYPE", 1), + (262, "APP.TITLE", -1), + (263, "WINDOW.TITLE", -1), + (264, "SAVE.TOOLBAR", -1), + (265, "ENABLE.TOOL", 3), + (266, "PRESS.TOOL", 3), + (267, "REGISTER.ID", -1), + (268, "GET.WORKBOOK", -1), + (269, "AVEDEV", -1), + (270, "BETADIST", -1), + (271, "GAMMALN", 1), + (272, "BETAINV", -1), + (273, "BINOMDIST", 4), + (274, "CHIDIST", 2), + (275, "CHIINV", 2), + (276, "COMBIN", 2), + (277, "CONFIDENCE", 3), + (278, "CRITBINOM", 3), + (279, "EVEN", 1), + (280, "EXPONDIST", 3), + (281, "FDIST", 3), + (282, "FINV", 3), + (283, "FISHER", 1), + (284, "FISHERINV", 1), + (285, "FLOOR", 2), + (286, "GAMMADIST", 4), + (287, "GAMMAINV", 3), + (288, "CEILING", 2), + (289, "HYPGEOMDIST", 4), + (290, "LOGNORMDIST", 3), + (291, "LOGINV", 3), + (292, "NEGBINOMDIST", 3), + (293, "NORMDIST", 4), + (294, "NORMSDIST", 1), + (295, "NORMINV", 3), + (296, "NORMSINV", 1), + (297, "STANDARDIZE", 3), + (298, "ODD", 1), + (299, "PERMUT", 2), + (300, "POISSON", 3), + (301, "TDIST", 3), + (302, "WEIBULL", 4), + (303, "SUMXMY2", 2), + (304, "SUMX2MY2", 2), + (305, "SUMX2PY2", 2), + (306, "CHITEST", 2), + (307, "CORREL", 2), + (308, "COVAR", 2), + (309, "FORECAST", 3), + (310, "FTEST", 2), + (311, "INTERCEPT", 2), + (312, "PEARSON", 2), + (313, "RSQ", 2), + (314, "STEYX", 2), + (315, "SLOPE", 2), + (316, "TTEST", 4), + (317, "PROB", -1), + (318, "DEVSQ", -1), + (319, "GEOMEAN", -1), + (320, "HARMEAN", -1), + (321, "SUMSQ", -1), + (322, "KURT", -1), + (323, "SKEW", -1), + (324, "ZTEST", -1), + (325, "LARGE", 2), + (326, "SMALL", 2), + (327, "QUARTILE", 2), + (328, "PERCENTILE", 2), + (329, "PERCENTRANK", -1), + (330, "MODE", -1), + (331, "TRIMMEAN", 2), + (332, "TINV", 2), + (334, "MOVIE.COMMAND", -1), + (335, "GET.MOVIE", -1), + (336, "CONCATENATE", -1), + (337, "POWER", 2), + (338, "PIVOT.ADD.DATA", -1), + (339, "GET.PIVOT.TABLE", -1), + (340, "GET.PIVOT.FIELD", -1), + (341, "GET.PIVOT.ITEM", -1), + (342, "RADIANS", 1), + (343, "DEGREES", 1), + (344, "SUBTOTAL", -1), + (345, "SUMIF", -1), + (346, "COUNTIF", 2), + (347, "COUNTBLANK", 1), + (348, "SCENARIO.GET", -1), + (349, "OPTIONS.LISTS.GET", 1), + (350, "ISPMT", 4), + (351, "DATEDIF", 3), + (352, "DATESTRING", 1), + (353, "NUMBERSTRING", 2), + (354, "ROMAN", -1), + (355, "OPEN.DIALOG", -1), + (356, "SAVE.DIALOG", -1), + (357, "VIEW.GET", -1), + (358, "GETPIVOTDATA", -1), + (359, "HYPERLINK", -1), + (360, "PHONETIC", 1), + (361, "AVERAGEA", -1), + (362, "MAXA", -1), + (363, "MINA", -1), + (364, "STDEVPA", -1), + (365, "VARPA", -1), + (366, "STDEVA", -1), + (367, "VARA", -1), + (368, "BAHTTEXT", 1), + (369, "THAIDAYOFWEEK", 1), + (370, "THAIDIGIT", 1), + (371, "THAIMONTHOFYEAR", 1), + (372, "THAINUMSOUND", 1), + (373, "THAINUMSTRING", 1), + (374, "THAISTRINGLENGTH", 1), + (375, "ISTHAIDIGIT", 1), + (376, "ROUNDBAHTDOWN", 1), + (377, "ROUNDBAHTUP", 1), + (378, "THAIYEAR", 1), + (379, "RTD", -1), + (380, "CUBEVALUE", -1), + (381, "CUBEMEMBER", -1), + (382, "CUBEMEMBERPROPERTY", 3), + (383, "CUBERANKEDMEMBER", -1), + (384, "HEX2BIN", -1), + (385, "HEX2DEC", 1), + (386, "HEX2OCT", -1), + (387, "DEC2BIN", -1), + (388, "DEC2HEX", -1), + (389, "DEC2OCT", -1), + (390, "OCT2BIN", -1), + (391, "OCT2HEX", -1), + (392, "OCT2DEC", 1), + (393, "BIN2DEC", 1), + (394, "BIN2OCT", -1), + (395, "BIN2HEX", -1), + (396, "IMSUB", 2), + (397, "IMDIV", 2), + (398, "IMPOWER", 2), + (399, "IMABS", 1), + (400, "IMSQRT", 1), + (401, "IMLN", 1), + (402, "IMLOG2", 1), + (403, "IMLOG10", 1), + (404, "IMSIN", 1), + (405, "IMCOS", 1), + (406, "IMEXP", 1), + (407, "IMARGUMENT", 1), + (408, "IMCONJUGATE", 1), + (409, "IMAGINARY", 1), + (410, "IMREAL", 1), + (411, "COMPLEX", -1), + (412, "IMSUM", -1), + (413, "IMPRODUCT", -1), + (414, "SERIESSUM", 4), + (415, "FACTDOUBLE", 1), + (416, "SQRTPI", 1), + (417, "QUOTIENT", 2), + (418, "DELTA", -1), + (419, "GESTEP", -1), + (420, "ISEVEN", 1), + (421, "ISODD", 1), + (422, "MROUND", 2), + (423, "ERF", -1), + (424, "ERFC", 1), + (425, "BESSELJ", 2), + (426, "BESSELK", 2), + (427, "BESSELY", 2), + (428, "BESSELI", 2), + (429, "XIRR", -1), + (430, "XNPV", 3), + (431, "PRICEMAT", -1), + (432, "YIELDMAT", -1), + (433, "INTRATE", -1), + (434, "RECEIVED", -1), + (435, "DISC", -1), + (436, "PRICEDISC", -1), + (437, "YIELDDISC", -1), + (438, "TBILLEQ", 3), + (439, "TBILLPRICE", 3), + (440, "TBILLYIELD", 3), + (441, "PRICE", -1), + (442, "YIELD", -1), + (443, "DOLLARDE", 2), + (444, "DOLLARFR", 2), + (445, "NOMINAL", 2), + (446, "EFFECT", 2), + (447, "CUMPRINC", 6), + (448, "CUMIPMT", 6), + (449, "EDATE", 2), + (450, "EOMONTH", 2), + (451, "YEARFRAC", -1), + (452, "COUPDAYBS", -1), + (453, "COUPDAYS", -1), + (454, "COUPDAYSNC", -1), + (455, "COUPNCD", -1), + (456, "COUPNUM", -1), + (457, "COUPPCD", -1), + (458, "DURATION", -1), + (459, "MDURATION", -1), + (460, "ODDLPRICE", -1), + (461, "ODDLYIELD", -1), + (462, "ODDFPRICE", -1), + (463, "ODDFYIELD", -1), + (464, "RANDBETWEEN", 2), + (465, "WEEKNUM", -1), + (466, "AMORDEGRC", -1), + (467, "AMORLINC", -1), + (469, "ACCRINT", -1), + (470, "ACCRINTM", -1), + (471, "WORKDAY", -1), + (472, "NETWORKDAYS", -1), + (473, "GCD", -1), + (474, "MULTINOMIAL", -1), + (475, "LCM", -1), + (476, "FVSCHEDULE", 2), + (477, "CUBEKPIMEMBER", -1), + (478, "CUBESET", -1), + (479, "CUBESETCOUNT", 1), + (480, "IFERROR", 2), + (481, "COUNTIFS", -1), + (482, "SUMIFS", -1), + (483, "AVERAGEIF", -1), + (484, "AVERAGEIFS", -1), +]; + +/// The function a `PtgFunc` or `PtgFuncVar` calls: its name and fixed argument count (-1 when it +/// takes a variable number). `None` for a number the table doesn't assign. +// The formula decoder calls it. +#[allow(dead_code)] +pub(super) fn function(iftab: u16) -> Option<(&'static str, i8)> { + FTAB.binary_search_by_key(&iftab, |(i, _, _)| *i).ok().and_then(|i| FTAB.get(i)).map(|(_, n, a)| (*n, *a)) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn xlsb_function_numbers() { + // `function` binary-searches the table: sorted, each number once. + assert!(FTAB.windows(2).all(|w| w[0].0 < w[1].0)); + // The [MS-XLS] part, unchanged. + assert_eq!(function(0), Some(("COUNT", -1))); + assert_eq!(function(379), Some(("RTD", -1))); + // [MS-XLSB] 2.5.98.10 continues the table from 0x17C. Excel writes these by number in + // XLSB: PtgFunc for a fixed argument count, PtgFuncVar otherwise. + assert_eq!(function(0x17C), Some(("CUBEVALUE", -1))); + assert_eq!(function(449), Some(("EDATE", 2))); + assert_eq!(function(480), Some(("IFERROR", 2))); + assert_eq!(function(482), Some(("SUMIFS", -1))); + assert_eq!(function(0x1D4), None, "unassigned"); + assert_eq!(function(0x1E5), None); + } +} From 787b3e44f49541b2b34bad86b296edb6f1aa6b5e Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Thu, 12 Nov 2026 23:29:29 -0500 Subject: [PATCH 008/382] craft-xlsx: read cell formulas from .xlsb files (port of gridcraft#3818) A BIFF12 decoder for cell formulas (xlsb/formula.rs), separate from craft-xls's BIFF8 one because nearly every operand differs (32-bit rows, 14-bit columns, UTF-16 strings, its own array-constant codes, newer functions called through hidden names). It reads references, 3-D references, constants, array constants, functions by number (xlsb/ftab.rs) and newer functions through Excel's hidden _xlfn. names. A formula cell's CellFormula holds the text as an .xlsx file holds it (`_xlfn.CONCAT`, `_xlpm.x`, no implicit `@`), and a BrtCellMeta before a cell gives it cell_metadata, as `cm` does. Reverse-Polish tokens group by order alone, so the decoded tree gets the parentheses its text needs from operator precedence; Excel's own text is unchanged. A chain of string constants joined with & prints as one flat chain. What a formula refers to must be readable too, so shared, array and data-table forms, user defined names (XLSB names aren't read yet), table references, external links and PY(index, ...) (code stored elsewhere in the package) keep only their saved results, with a warning saying why. So does a formula past Limits::binary_formula_text (128 MiB of text over the workbook). The workbook's links and names are optional: if they can't be read, the file opens with values only, as before, and a warning says so. Ported from storytold/gridcraft#3818 (issue gridcraft#3806), with its two review fixes (grouping by precedence, the flat & chain). Changed from the GridCraft PR: - The tree and its A1 printer (xlsb/expr.rs) are a copy of craft-xls's expr.rs, with BinOp::precedence added; the decoder's stack and depth guards are copies of craft-xls's. The PR used GridCraft's formula crate and shared these with GridCraft's .xls decoder. - No fmla::from_file, implicit `@`, parse check or Python-cell adoption: those are GridCraft's reading of the text, not the file's. A single-cell dynamic-array formula is read (with its cell metadata) instead of being kept as its value; the PR left dynamic arrays to the next PR. - The links are read with the workbook part and kept by Package for its sheets. Its tests come along in tests/xlsb.rs, with the expected text in the file's spelling. Checked against Excel: of the formulas in a workbook Excel saved both as .xlsb and as .xlsx, every one this reads (26) has the text of the .xlsx; the other 12 are the kinds above. --- crates/xlsx/src/lib.rs | 5 + crates/xlsx/src/package.rs | 15 +- crates/xlsx/src/xlsb.rs | 158 +++++++++- crates/xlsx/src/xlsb/expr.rs | 345 ++++++++++++++++++++ crates/xlsx/src/xlsb/formula.rs | 538 ++++++++++++++++++++++++++++++++ crates/xlsx/src/xlsb/ftab.rs | 2 - crates/xlsx/tests/common/mod.rs | 19 +- crates/xlsx/tests/xlsb.rs | 267 ++++++++++++++++ 8 files changed, 1329 insertions(+), 20 deletions(-) create mode 100644 crates/xlsx/src/xlsb/expr.rs create mode 100644 crates/xlsx/src/xlsb/formula.rs diff --git a/crates/xlsx/src/lib.rs b/crates/xlsx/src/lib.rs index b0771d366..5a64ae0ab 100644 --- a/crates/xlsx/src/lib.rs +++ b/crates/xlsx/src/lib.rs @@ -145,6 +145,10 @@ pub struct Limits { pub binary_cells: usize, /// Bytes of decoded text (shared and inline strings) in a binary workbook, over all its parts. pub binary_text: usize, + /// Bytes of decoded formula text in a binary workbook, over all its sheets. A cell formula + /// may hold 16 KB of tokens, so without a total a million cells of long formulas would cost + /// gigabytes; past it, formulas keep their saved results (the file still opens). + pub binary_formula_text: usize, } impl Default for Limits { @@ -156,6 +160,7 @@ impl Default for Limits { binary_records: 40_000_000, binary_cells: 4_000_000, binary_text: 256 << 20, + binary_formula_text: 128 << 20, } } } diff --git a/crates/xlsx/src/package.rs b/crates/xlsx/src/package.rs index 1c133d0ad..8f2c5efc6 100644 --- a/crates/xlsx/src/package.rs +++ b/crates/xlsx/src/package.rs @@ -29,6 +29,9 @@ pub struct Package<'a> { binary: Option, workbook_rels: Option, budget: xlsb::Budget, + /// What a binary workbook's formulas refer to, once its workbook part is read: `Some(None)` + /// when that couldn't be read (every formula keeps its saved result). + binary_links: Option>, /// Shared strings in a binary workbook, once counted: a cell's index is checked against it. binary_strings: Option, } @@ -67,6 +70,7 @@ impl<'a> Package<'a> { binary, workbook_rels: None, budget: xlsb::Budget::default(), + binary_links: None, binary_strings: None, }) } @@ -145,7 +149,9 @@ impl<'a> Package<'a> { if self.binary.is_some() { let bytes = self.required(&self.workbook_part.clone())?; let rels = self.workbook_rels()?; - return xlsb::workbook(&bytes, &rels, &self.limits, &self.budget, &mut self.warnings); + let (wb, links) = xlsb::workbook(&bytes, &rels, &self.limits, &self.budget, &mut self.warnings)?; + self.binary_links = Some(links); + return Ok(wb); } let options = self.xml_options(); let root = match self.opc.read_xml(&self.workbook_part, &options)? { @@ -234,8 +240,13 @@ impl<'a> Package<'a> { Some(n) => n, None => self.shared_strings()?.len(), }; + // Formulas name sheets and functions through the workbook part. + if self.binary_links.is_none() { + self.workbook()?; + } let bytes = self.required(&part)?; - let mut sheet = xlsb::worksheet(&bytes, strings, &self.limits, &self.budget, &mut self.warnings, &mut each)?; + let links = self.binary_links.as_ref().and_then(Option::as_ref); + let mut sheet = xlsb::worksheet(&bytes, strings, links, &self.limits, &self.budget, &mut self.warnings, &mut each)?; sheet.part = part; return Ok(sheet); } diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index 542fd580c..aedbae5ab 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -1,7 +1,10 @@ //! Binary workbooks ([MS-XLSB]): the workbook part, shared strings and worksheet cells, from -//! their records. Saved values only: formulas are token streams that are not decoded, and -//! styles are not read. A record that does not parse fails the read. +//! their records. Cell formulas are decoded from their tokens ([`formula`]) into the text an +//! `.xlsx` file holds; one that can't be keeps only its saved result, with a warning saying why. +//! Styles are not read. A record that does not parse fails the read. +mod expr; +mod formula; mod ftab; use std::sync::Arc; @@ -9,10 +12,12 @@ use std::sync::Arc; use craft_opc::{ContentTypes, Rels}; use craft_sheet::{CellError, CellRef, MAX_COLS, MAX_ROWS, Range, Visibility}; -use crate::sheet::{Cell, CellValue, Row, SheetPart}; +use crate::sheet::{Cell, CellFormula, CellValue, Row, SheetPart}; use crate::strings::StringItem; use crate::workbook::{SheetEntry, SheetKind, Workbook}; use crate::{Error, Limits, Warnings}; +pub(crate) use formula::Links; +use formula::{Book, Name, Xti}; pub(crate) const MAIN: &str = "application/vnd.ms-excel.main"; const BINARY_MAIN: &str = "application/vnd.ms-excel.sheet.binary.macroEnabled.main"; @@ -22,6 +27,9 @@ pub(crate) const STRINGS: &str = "application/vnd.ms-excel.sharedStrings"; const MAX_SHEETS: usize = 1024; /// Most merged ranges in one worksheet. const MAX_MERGES: usize = 100_000; +/// Defined names (Excel's hidden ones for newer functions included) read at most; past it, the +/// workbook's formulas keep their saved results. +const MAX_NAMES: usize = 65_536; pub(crate) fn invalid(msg: impl Into) -> Error { Error::Invalid(format!("XLSB: {}", msg.into())) @@ -43,9 +51,21 @@ pub(crate) struct Budget { cells: std::cell::Cell, text: std::cell::Cell, records: std::cell::Cell, + formula_text: std::cell::Cell, } impl Budget { + /// Charges a decoded formula's text if it fits [`Limits::binary_formula_text`]; a formula + /// that doesn't keeps its saved result. + fn try_formula_text(&self, len: usize, limits: &Limits) -> bool { + let total = self.formula_text.get().saturating_add(len); + let fits = total <= limits.binary_formula_text; + if fits { + self.formula_text.set(total); + } + fits + } + fn text(&self, len: usize, limits: &Limits) -> Result<(), Error> { self.text.set(self.text.get().saturating_add(len)); if self.text.get() > limits.binary_text { @@ -97,6 +117,9 @@ impl<'a> Bytes<'a> { fn u32(&mut self) -> Result { Ok(u32::from_le_bytes(self.take(4)?.try_into().map_err(|_| invalid("truncated u32"))?)) } + fn i32(&mut self) -> Result { + Ok(i32::from_le_bytes(self.take(4)?.try_into().map_err(|_| invalid("truncated i32"))?)) + } fn f64(&mut self) -> Result { let n = f64::from_le_bytes(self.take(8)?.try_into().map_err(|_| invalid("truncated number"))?); @@ -224,10 +247,19 @@ impl<'a, 'l> Records<'a, 'l> { } /// The workbook part: BrtBeginBook, BrtWbProp, the BrtBundleSh list. -pub(crate) fn workbook(bytes: &[u8], rels: &Rels, limits: &Limits, budget: &Budget, warnings: &mut Warnings) -> Result { +/// The workbook part, and the tables its formulas refer to ([`Links`]): `None` when those can't +/// be read, so that the workbook still opens, with every formula kept as its saved result. +pub(crate) fn workbook( + bytes: &[u8], + rels: &Rels, + limits: &Limits, + budget: &Budget, + warnings: &mut Warnings, +) -> Result<(Workbook, Option), Error> { let mut records = Records::new(bytes, limits, budget); records.first(131, warnings)?; let mut wb = Workbook::default(); + let mut links = Some(Links::default()); let mut bundle = false; let mut bundle_seen = false; while let Some((id, payload)) = records.next(warnings)? { @@ -241,7 +273,17 @@ pub(crate) fn workbook(bytes: &[u8], rels: &Rels, limits: &Limits, budget: &Budg if wb.sheets.is_empty() { return Err(invalid("no supported worksheets")); } - return Ok(wb); + if links.is_none() { + warnings.warn("XLSB: the workbook's sheet links or names could not be read; formulas keep their saved results"); + } + return Ok((wb, links)); + } + 39 | 355 | 357 | 358 | 362 | 667 => { + if let Some(l) = links.as_mut() + && link_record(id, payload, l).is_err() + { + links = None; + } } 143 => { if bundle_seen { @@ -289,6 +331,10 @@ pub(crate) fn workbook(bytes: &[u8], rels: &Rels, limits: &Limits, budget: &Budg return Err(invalid("worksheet relationship is null")); } warnings.warn("XLSB module sheets were skipped"); + // Formulas name sheets by their place in this list, skipped sheets included. + if let Some(l) = links.as_mut() { + l.sheets.push(None); + } continue; }; let rel = rels.by_id(&rel_id).ok_or_else(|| invalid("worksheet relationship is missing"))?; @@ -299,6 +345,10 @@ pub(crate) fn workbook(bytes: &[u8], rels: &Rels, limits: &Limits, budget: &Budg if let SheetKind::Other(_) = kind { return Err(invalid("unknown sheet relationship type")); } + // Only a worksheet has cells a formula can refer to. + if let Some(l) = links.as_mut() { + l.sheets.push((kind == SheetKind::Worksheet).then(|| name.clone())); + } wb.sheets.push(SheetEntry { name, sheet_id, visibility, rel_id, kind, part: Some(rel.target.clone()) }); } _ => {} @@ -307,6 +357,48 @@ pub(crate) fn workbook(bytes: &[u8], rels: &Rels, limits: &Limits, budget: &Budg Err(invalid("missing workbook end record")) } +/// A supporting link (`BrtSupSelf`, `BrtSupSame`, `BrtSupAddin`, `BrtSupBookSrc`), the sheet links +/// (`BrtExternSheet`) or a defined name (`BrtName`), added to `links`. +fn link_record(id: u16, payload: &[u8], links: &mut Links) -> Result<(), Error> { + let mut b = Bytes::new(payload); + match id { + 357 | 358 | 667 => { + b.finish()?; + links.books.push(match id { + 357 => Book::This, + 358 => Book::Same, + _ => Book::Addin, + }); + } + 355 => links.books.push(Book::External), + 362 => { + // [MS-XLSB] 2.4.672: cXti "MUST be less than 65536" (PtgRef3d's ixti is 16 bits). + let count = b.u32()?; + if count >= 65_536 || !links.xti.is_empty() { + return Err(invalid("invalid sheet link list")); + } + for _ in 0..count { + let book = b.u32()?; + let (first, last) = (b.i32()?, b.i32()?); + links.xti.push(Xti { book, first, last }); + } + b.finish()?; + } + _ => { + // BrtName ([MS-XLSB] 2.4.718): flags, chKey, itab, then the name; the formula and the + // rest aren't needed to call a function or tell a name from one. + if links.names.len() >= MAX_NAMES { + return Err(invalid("too many defined names")); + } + let flags = b.u32()?; + b.take(5)?; + let text = b.text(255)?; + links.names.push(Name { text, future: flags & (1 << 17) != 0 }); + } + } + Ok(()) +} + /// A `RichStr`: the text; formatting and phonetic runs are skipped. fn rich_string(b: &mut Bytes<'_>) -> Result { let flags = b.u8()?; @@ -397,17 +489,37 @@ fn boolean(b: &mut Bytes<'_>) -> Result { } } -/// The formula after a cell's saved result: checked for framing, not decoded. -fn skip_formula(b: &mut Bytes<'_>) -> Result<(), Error> { +/// The `grbitFlags` and `CellParsedFormula` after a formula cell's value: its tokens (`rgce`) +/// and their extra data (`rgcb`). The flags' only bit, `fAlwaysCalc`, is the calculator's to know. +fn cell_formula<'a>(b: &mut Bytes<'a>) -> Result<(&'a [u8], &'a [u8]), Error> { b.take(2)?; let cce = b.u32()?; if !(1..=16384).contains(&cce) { return Err(invalid("invalid formula token length")); } - b.take(cce as usize)?; + let rgce = b.take(cce as usize)?; let extra = b.u32()?; - b.take(extra as usize)?; - Ok(()) + let rgcb = b.take(extra as usize)?; + Ok((rgce, rgcb)) +} + +/// A formula's text, or `None` (with a warning saying why) for one that keeps its saved result: +/// the workbook's links couldn't be read, the tokens can't be decoded, or the formula text +/// allowance is spent. +fn decode_formula(rgce: &[u8], rgcb: &[u8], links: Option<&Links>, limits: &Limits, budget: &Budget, warnings: &mut Warnings) -> Option { + let links = links?; + let text = match formula::decode(rgce, rgcb, links) { + Ok(e) => expr::print(&e), + Err(formula::Unsupported(why)) => { + warnings.warn(format!("XLSB: some formulas were kept as their saved results ({why})")); + return None; + } + }; + if !budget.try_formula_text(text.len(), limits) { + warnings.warn("XLSB: some formulas were kept as their saved results (more formula text than the limits allow)"); + return None; + } + Some(text) } fn value(id: u16, b: &mut Bytes<'_>, strings: usize, limits: &Limits, budget: &Budget) -> Result { @@ -444,16 +556,16 @@ fn value(id: u16, b: &mut Bytes<'_>, strings: usize, limits: &Limits, budget: &B } _ => return Err(invalid("unsupported cell record")), }; - if (8..=11).contains(&id) { - skip_formula(b)?; - } Ok(value) } /// A worksheet part: rows (BrtRowHdr) and cells inside BrtBeginSheetData, merged cells after. +/// Formulas refer to the workbook's `links`; with none, each keeps its saved result. +#[allow(clippy::too_many_arguments)] pub(crate) fn worksheet( bytes: &[u8], strings: usize, + links: Option<&Links>, limits: &Limits, budget: &Budget, warnings: &mut Warnings, @@ -466,9 +578,18 @@ pub(crate) fn worksheet( let mut data_seen = false; let mut row: Option = None; let mut col = None; + // BrtCellMeta applies to the cell record that follows it (a dynamic-array formula), as `cm` + // does in `.xlsx`: a one-based index into the metadata part's cell metadata. + let mut meta: Option = None; while let Some((id, payload)) = records.next(warnings)? { let mut b = Bytes::new(payload); + let cell_metadata = meta.take(); match id { + 49 => { + let icmb = b.i32()?; + b.finish()?; + meta = u32::try_from(icmb).ok().filter(|&i| i >= 1); + } 130 => { if data || !data_seen { return Err(invalid("incomplete worksheet data")); @@ -527,7 +648,14 @@ pub(crate) fn worksheet( } let style = b.u32()?; let value = value(id, &mut b, strings, limits, budget)?; - b.finish()?; + let formula = if (8..=11).contains(&id) { + let (rgce, rgcb) = cell_formula(&mut b)?; + b.finish()?; + decode_formula(rgce, rgcb, links, limits, budget, warnings).map(|text| CellFormula { text, ..CellFormula::default() }) + } else { + b.finish()?; + None + }; if value != CellValue::Empty { budget.cell(limits)?; } @@ -536,6 +664,8 @@ pub(crate) fn worksheet( style: style & 0x00FF_FFFF, phonetic: style & 0x0100_0000 != 0, value, + formula, + cell_metadata, ..Cell::default() }); col = Some(c); diff --git a/crates/xlsx/src/xlsb/expr.rs b/crates/xlsx/src/xlsb/expr.rs new file mode 100644 index 000000000..3dd643a6a --- /dev/null +++ b/crates/xlsx/src/xlsb/expr.rs @@ -0,0 +1,345 @@ +//! The expression tree an XLSB formula decodes to, and its A1 formula text (without `=`), in the +//! file's spelling (`_xlfn.` and `_xlpm.` names as written). A copy of craft-xls's: the two +//! readers follow separate specifications, and can share one tree when both settle. + +use std::fmt::Write; +use std::sync::Arc; + +use craft_sheet::{CellError, push_col, quote_sheet, sheet_needs_quotes}; + +/// One end of a reference, with `$` anchors. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct Anchor { + pub row: u32, + pub col: u32, + pub row_abs: bool, + pub col_abs: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum RefKind { + Cell(Anchor), + Range(Anchor, Anchor), + /// Whole rows `3:5` as (row, absolute) pairs. + Rows(u32, bool, u32, bool), + /// Whole columns `A:C`. + Cols(u32, bool, u32, bool), +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum SheetSel { + /// Unqualified: the formula's own sheet. + Current, + Named(String), + /// 3-D span `Sheet1:Sheet3`. + Span(String, String), +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Reference { + pub sheet: SheetSel, + pub kind: RefKind, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum UnOp { + Neg, + Plus, + Percent, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum BinOp { + Add, + Sub, + Mul, + Div, + Pow, + Concat, + Eq, + Ne, + Lt, + Gt, + Le, + Ge, + /// `:` between two references. + Range, + /// `,` inside parentheses. + Union, + /// A space between two references. + Intersect, +} + +impl BinOp { + /// How tightly the operator binds, as formula text is read: `:` 90, space 85, `,` 80, `^` 50, + /// `*` `/` 40, `+` `-` 30, `&` 20, comparisons 10. + pub(crate) fn precedence(self) -> u8 { + match self { + BinOp::Range => 90, + BinOp::Intersect => 85, + BinOp::Union => 80, + BinOp::Pow => 50, + BinOp::Mul | BinOp::Div => 40, + BinOp::Add | BinOp::Sub => 30, + BinOp::Concat => 20, + BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Gt | BinOp::Le | BinOp::Ge => 10, + } + } + + fn symbol(self) -> &'static str { + match self { + BinOp::Add => "+", + BinOp::Sub => "-", + BinOp::Mul => "*", + BinOp::Div => "/", + BinOp::Pow => "^", + BinOp::Concat => "&", + BinOp::Eq => "=", + BinOp::Ne => "<>", + BinOp::Lt => "<", + BinOp::Gt => ">", + BinOp::Le => "<=", + BinOp::Ge => ">=", + BinOp::Range => ":", + BinOp::Union => ",", + BinOp::Intersect => " ", + } + } +} + +/// A formula's syntax tree. The decoder bounds its depth, so printing and dropping it recurse +/// safely. +#[derive(Debug, PartialEq)] +pub(crate) enum Expr { + Number(f64), + Text(Arc), + Bool(bool), + Error(CellError), + /// Array constant `{1,2;3,4}` (rows of literals). + Array(Vec>), + Ref(Reference), + /// A defined name. + Name(String), + Unary(UnOp, Box), + Binary(BinOp, Box, Box), + Call(String, Vec), + /// An omitted argument. + Missing, + Paren(Box), +} + +fn push_anchor(s: &mut String, a: &Anchor) { + if a.col_abs { + s.push('$'); + } + push_col(s, a.col); + if a.row_abs { + s.push('$'); + } + let _ = write!(s, "{}", u64::from(a.row) + 1); +} + +fn push_reference(s: &mut String, r: &Reference) { + match &r.sheet { + SheetSel::Current => {} + SheetSel::Named(n) => { + s.push_str("e_sheet(n)); + s.push('!'); + } + SheetSel::Span(a, b) => { + let joined = format!("{a}:{b}"); + if sheet_needs_quotes(a) || sheet_needs_quotes(b) { + let _ = write!(s, "'{}'!", joined.replace('\'', "''")); + } else { + let _ = write!(s, "{joined}!"); + } + } + } + let dollar = |abs: bool| if abs { "$" } else { "" }; + match &r.kind { + RefKind::Cell(a) => push_anchor(s, a), + RefKind::Range(a, b) => { + push_anchor(s, a); + s.push(':'); + push_anchor(s, b); + } + RefKind::Rows(r0, a0, r1, a1) => { + let _ = write!(s, "{}{}:{}{}", dollar(*a0), u64::from(*r0) + 1, dollar(*a1), u64::from(*r1) + 1); + } + RefKind::Cols(c0, a0, c1, a1) => { + s.push_str(dollar(*a0)); + push_col(s, *c0); + s.push(':'); + s.push_str(dollar(*a1)); + push_col(s, *c1); + } + } +} + +/// Removes trailing zeros (and a trailing point) from a decimal string. +fn trim_decimal(s: &str) -> String { + if s.contains('.') { + let t = s.trim_end_matches('0').trim_end_matches('.'); + if t == "-0" { "0".into() } else { t.to_string() } + } else { + s.to_string() + } +} + +/// Scientific text like `1.23456789012346E+15` with up to `sig` significant digits. +fn sci_text(n: f64, sig: usize) -> String { + let s = format!("{:.*e}", sig.saturating_sub(1), n); + let Some((mant, exp)) = s.split_once('e') else { return s }; + let mant = trim_decimal(mant); + let e: i32 = exp.parse().unwrap_or(0); + format!("{}E{}{:02}", mant, if e < 0 { '-' } else { '+' }, e.abs()) +} + +/// A number as a formula spells it: up to 15 significant digits, scientific for very large or +/// very small magnitudes. +pub(crate) fn number_to_text(n: f64) -> String { + if n == 0.0 || !n.is_finite() { + return "0".into(); + } + let a = n.abs(); + if !(1e-9..1e15).contains(&a) && a.round() != a || a >= 1e15 { + return sci_text(n, 15); + } + // A value just below 1e15 can round up to 1e15 at 15 significant digits. + if format!("{a:.14e}").parse::().is_ok_and(|r| r >= 1e15) { + return sci_text(n, 15); + } + let mag = a.log10().floor() as i32; + let decimals = (14 - mag).clamp(0, 30) as usize; + trim_decimal(&format!("{n:.decimals$}")) +} + +fn number(n: f64) -> String { + let text = number_to_text(n); + // 15 significant digits can round past f64::MAX, which no longer parses. + if text.parse::().is_ok_and(f64::is_finite) { + return text; + } + let exact = format!("{n:E}"); + match exact.split_once('E') { + Some((m, e)) if !e.starts_with('-') => format!("{m}E+{e}"), + _ => exact, + } +} + +/// Splits a sheet-qualified name at its last `!` outside brackets. +fn sheet_split(n: &str) -> Option<(&str, &str)> { + let mut depth = 0usize; + let mut escaped = false; + let mut at = None; + for (i, c) in n.char_indices() { + if escaped { + escaped = false; + continue; + } + match c { + '\'' if depth > 0 => escaped = true, + '[' => depth = depth.saturating_add(1), + ']' => depth = depth.saturating_sub(1), + '!' if depth == 0 => at = Some(i), + _ => {} + } + } + at.and_then(|i| Some((n.get(..i)?, n.get(i + 1..)?))) +} + +/// Prints an expression in A1 notation. +pub(crate) fn print(e: &Expr) -> String { + let mut s = String::new(); + write_expr(&mut s, e); + s +} + +fn write_args(s: &mut String, args: &[Expr], sep: char) { + for (i, a) in args.iter().enumerate() { + if i > 0 { + s.push(sep); + } + write_expr(s, a); + } +} + +fn write_expr(s: &mut String, e: &Expr) { + match e { + Expr::Number(n) => s.push_str(&number(*n)), + Expr::Text(t) => { + s.push('"'); + s.push_str(&t.replace('"', "\"\"")); + s.push('"'); + } + Expr::Bool(b) => s.push_str(if *b { "TRUE" } else { "FALSE" }), + Expr::Error(err) => s.push_str(err.as_str()), + Expr::Array(rows) => { + s.push('{'); + for (ri, row) in rows.iter().enumerate() { + if ri > 0 { + s.push(';'); + } + write_args(s, row, ','); + } + s.push('}'); + } + Expr::Ref(r) => push_reference(s, r), + Expr::Name(n) => match sheet_split(n) { + // A sheet-qualified name holds the bare sheet name (`My Sheet!Total`): quote it so it parses back. + Some((sheet, name)) => { + s.push_str("e_sheet(sheet)); + s.push('!'); + s.push_str(name); + } + None => s.push_str(n), + }, + Expr::Unary(UnOp::Neg, x) => { + s.push('-'); + write_expr(s, x); + } + Expr::Unary(UnOp::Plus, x) => { + s.push('+'); + write_expr(s, x); + } + Expr::Unary(UnOp::Percent, x) => { + write_expr(s, x); + s.push('%'); + } + Expr::Binary(op, a, b) => { + write_expr(s, a); + s.push_str(op.symbol()); + write_expr(s, b); + } + Expr::Call(name, args) => { + s.push_str(name); + s.push('('); + write_args(s, args, ','); + s.push(')'); + } + Expr::Missing => {} + Expr::Paren(x) => { + s.push('('); + write_expr(s, x); + s.push(')'); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn numbers_print_with_fifteen_significant_digits() { + assert_eq!(number_to_text(1.0), "1"); + assert_eq!(number_to_text(-2.5), "-2.5"); + assert_eq!(number_to_text(0.1 + 0.2), "0.3"); + assert_eq!(number_to_text(123456789012345.0), "123456789012345"); + assert_eq!(number_to_text(1e15), "1E+15"); + assert_eq!(number_to_text(1234567890123456.0), "1.23456789012346E+15"); + assert_eq!(number_to_text(0.0001), "0.0001"); + assert_eq!(number_to_text(1e-10), "1E-10"); + assert!(number(f64::MAX).parse::().is_ok_and(f64::is_finite)); + } +} diff --git a/crates/xlsx/src/xlsb/formula.rs b/crates/xlsx/src/xlsb/formula.rs new file mode 100644 index 000000000..bed0adcd0 --- /dev/null +++ b/crates/xlsx/src/xlsb/formula.rs @@ -0,0 +1,538 @@ +//! BIFF12 parsed formulas ([MS-XLSB] 2.2.2, 2.5.98): reverse-Polish `Ptg` tokens back to an +//! expression tree, for cell formulas. The tokens are BIFF8's, but nearly every operand differs +//! (32-bit rows, 14-bit columns, UTF-16 strings, its own array-constant codes, newer functions +//! called through hidden names), so this is its own decoder, with its own function table +//! ([`super::ftab`]) and its own copies of craft-xls's depth guards and limits. Anything outside the +//! token set it knows is reported as unsupported, and the caller keeps the cell's cached value. +//! So is a formula that needs something the reader doesn't read: a user's defined name (XLSB +//! names are not read yet) or Python code stored outside the cell. +//! +//! Names keep their file spelling (`_xlfn.CONCAT`, `_xlpm.x`), as `.xlsx` formula text has them. + +use std::sync::Arc; + +use craft_sheet::{CellError, MAX_COLS, MAX_ROWS}; + +use super::expr::{Anchor, BinOp, Expr, RefKind, Reference, SheetSel, UnOp}; +use super::ftab::function; + +/// Formula token bytes decoded at most (a cell formula holds at most 16,384). +pub(super) const MAX_RGCE: usize = 16 * 1024; +/// Values in one array constant at most. +const MAX_ARRAY: usize = 65_536; + +/// Why a formula could not be turned back into text. +#[derive(Debug, PartialEq)] +pub(super) struct Unsupported(pub &'static str); + +/// Expression nesting at most: deeper trees would overflow the stack when printed or dropped (a +/// hostile file can chain thousands of PtgParen tokens). +const MAX_DEPTH: usize = 256; + +/// Operand stack entries: an expression and its nesting depth. +type Stack = Vec<(Expr, usize)>; + +/// Pops an operand, recording its depth in `kids` (the deepest operand this token consumed). +fn pop(stack: &mut Stack, kids: &mut usize) -> Result { + let (e, d) = stack.pop().ok_or(Unsupported("malformed formula (operand missing)"))?; + *kids = (*kids).max(d); + Ok(e) +} + +fn pop_n(stack: &mut Stack, n: usize, kids: &mut usize) -> Result, Unsupported> { + let at = stack.len().checked_sub(n).ok_or(Unsupported("malformed formula (argument missing)"))?; + let popped = stack.split_off(at); + *kids = popped.iter().map(|(_, d)| *d).fold(*kids, usize::max); + Ok(popped.into_iter().map(|(e, _)| e).collect()) +} + +/// Pushes the result of a token one level above the operands it consumed. +fn push(stack: &mut Stack, kids: usize, e: Expr) -> Result<(), Unsupported> { + let depth = kids.saturating_add(1); + if depth > MAX_DEPTH { + return Err(Unsupported("formula nested too deeply")); + } + stack.push((e, depth)); + Ok(()) +} + +/// An error constant's code ([MS-XLSB] 2.5.98.21, `BErr`). +fn error_code(code: u8) -> Option { + Some(match code { + 0x00 => CellError::Null, + 0x07 => CellError::Div0, + 0x0F => CellError::Value, + 0x17 => CellError::Ref, + 0x1D => CellError::Name, + 0x24 => CellError::Num, + 0x2A => CellError::NA, + 0x2B => CellError::GettingData, + _ => return None, + }) +} + +/// A supporting link record ([MS-XLSB] 2.2.7.3), in the order of the workbook's externals block. +#[derive(Clone, Copy, Debug, PartialEq)] +pub(super) enum Book { + /// `BrtSupSelf`: this workbook. + This, + /// `BrtSupSame`: the caller's sheet (macro sheets and names only). + Same, + /// `BrtSupAddin`: add-in functions. + Addin, + /// `BrtSupBookSrc`: another workbook, DDE or OLE. Never followed. + External, +} + +/// Xti ([MS-XLSB] 2.5.173): a supporting link and a range of its sheets. +#[derive(Clone, Copy, Debug)] +pub(super) struct Xti { + pub book: u32, + pub first: i32, + pub last: i32, +} + +/// A `BrtName` as far as cell formulas need it. +#[derive(Clone, Debug)] +pub(super) struct Name { + /// The name as written (`_xlfn.CONCAT`, `_xlpm.x`, `Rate`). + pub text: String, + /// `fFutureFunction`: a hidden name standing for a function newer than the file format. + pub future: bool, +} + +/// Workbook-level tables formulas refer to. +#[derive(Default)] +pub(crate) struct Links { + /// Every sheet's name in `BrtBundleSh` order, `None` for sheets the reader skips or that hold + /// no cells (chart, dialog and macro sheets). + pub(super) sheets: Vec>, + /// Every `BrtName`, in order: `PtgName` indexes them from 1. + pub(super) names: Vec, + pub(super) books: Vec, + pub(super) xti: Vec, +} + +/// Whether a name stands for a LET parameter (`_xlpm.x`), which only the formula itself defines. +fn is_param(name: &str) -> bool { + name.get(..6).is_some_and(|p| p.eq_ignore_ascii_case("_xlpm.")) +} + +impl Links { + /// The sheets a 3-D reference names, or `None` for a deleted sheet (the reference is `#REF!`). + fn sheet_sel(&self, ixti: u16) -> Result, Unsupported> { + let x = self.xti.get(usize::from(ixti)).ok_or(Unsupported("reference to a missing sheet link"))?; + match usize::try_from(x.book).ok().and_then(|b| self.books.get(b)) { + Some(Book::This) => {} + Some(Book::External) => return Err(Unsupported("references to other workbooks (external links)")), + Some(_) => return Err(Unsupported("references through add-in or same-sheet links")), + None => return Err(Unsupported("reference to a missing workbook link")), + } + // -1: "the first sheet in the reference cannot be found" (a deleted sheet). + if x.first == -1 || x.last == -1 { + return Ok(None); + } + // -2 (the whole workbook) is for names, not cell references. + let (Ok(first), Ok(last)) = (usize::try_from(x.first), usize::try_from(x.last)) else { + return Err(Unsupported("reference to a missing sheet")); + }; + // A span takes every sheet between its ends, so a skipped one anywhere in it changes + // what the reference means. + let span = self.sheets.get(first..=last).filter(|s| !s.is_empty()).ok_or(Unsupported("reference to a missing sheet"))?; + if span.iter().any(Option::is_none) { + return Err(Unsupported("references to sheets the reader skips")); + } + let (Some(Some(a)), Some(Some(b))) = (span.first(), span.last()) else { + return Err(Unsupported("reference to a missing sheet")); + }; + Ok(Some(if first == last { SheetSel::Named(a.clone()) } else { SheetSel::Span(a.clone(), b.clone()) })) + } +} + +struct Bytes<'a> { + b: &'a [u8], + pos: usize, +} + +const TRUNC: Unsupported = Unsupported("truncated formula"); + +impl Bytes<'_> { + fn take(&mut self, n: usize) -> Result<&[u8], Unsupported> { + let s = self.b.get(self.pos..self.pos.checked_add(n).ok_or(TRUNC)?).ok_or(TRUNC)?; + self.pos += n; + Ok(s) + } + fn u8(&mut self) -> Result { + self.take(1)?.first().copied().ok_or(TRUNC) + } + fn u16(&mut self) -> Result { + let s: [u8; 2] = self.take(2)?.try_into().map_err(|_| TRUNC)?; + Ok(u16::from_le_bytes(s)) + } + fn u32(&mut self) -> Result { + let s: [u8; 4] = self.take(4)?.try_into().map_err(|_| TRUNC)?; + Ok(u32::from_le_bytes(s)) + } + fn f64(&mut self) -> Result { + let s: [u8; 8] = self.take(8)?.try_into().map_err(|_| TRUNC)?; + let n = f64::from_le_bytes(s); + if !n.is_finite() { + return Err(Unsupported("invalid number constant")); + } + Ok(n) + } + /// `cch` UTF-16 code units; unpaired surrogates are refused, not replaced. + fn chars(&mut self, cch: usize) -> Result { + let units = self.take(cch.checked_mul(2).ok_or(TRUNC)?)?.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)); + char::decode_utf16(units).collect::>().map_err(|_| Unsupported("invalid text constant")) + } +} + +/// The last row and column of the grid: a range from 0 to these is a whole column or row. +const LAST_ROW: u32 = MAX_ROWS - 1; +const LAST_COL: u32 = MAX_COLS - 1; + +/// RgceLoc ([MS-XLSB] 2.5.98.91): a row and a `ColRelShort` (14-bit column, then the +/// column-relative and row-relative flags). In a cell formula the coordinates are absolute +/// whatever the flags say; the flags only decide where `$` goes. +fn anchor(row: u32, col: u16) -> Result { + let c = u32::from(col & 0x3FFF); + if row > LAST_ROW || c > LAST_COL { + return Err(Unsupported("reference outside the grid")); + } + Ok(Anchor { row, col: c, row_abs: col & 0x8000 == 0, col_abs: col & 0x4000 == 0 }) +} + +/// RgceArea: a range spanning every row (or column) is a whole-column (row) reference. +fn area(r0: u32, r1: u32, c0: u16, c1: u16) -> Result { + let (a, b) = (anchor(r0, c0)?, anchor(r1, c1)?); + Ok(if a.row == 0 && b.row == LAST_ROW { + RefKind::Cols(a.col, a.col_abs, b.col, b.col_abs) + } else if a.col == 0 && b.col == LAST_COL { + RefKind::Rows(a.row, a.row_abs, b.row, b.row_abs) + } else { + RefKind::Range(a, b) + }) +} + +fn reference(sheet: Option, kind: RefKind) -> Expr { + match sheet { + Some(sheet) => Expr::Ref(Reference { sheet, kind }), + None => Expr::Error(CellError::Ref), + } +} + +/// Decodes a cell formula's `rgce` (tokens) with its `rgcb` (extra data for array constants and +/// cached areas). Returns the expression, with names in their file spelling, or why it can't be +/// represented. +pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links) -> Result { + if rgce.len() > MAX_RGCE { + return Err(Unsupported("formula too long")); + } + let mut t = Bytes { b: rgce, pos: 0 }; + let mut extra = Bytes { b: rgcb, pos: 0 }; + let mut stack: Stack = Vec::new(); + while t.pos < rgce.len() { + let ptg = t.u8()?; + let mut kids = 0usize; + // Operand classes (reference / value / array) share one token number. + let id = if ptg & 0x60 != 0 { 0x20 | (ptg & 0x1F) } else { ptg }; + match id { + 0x03..=0x11 => { + let op = match id { + 0x03 => BinOp::Add, + 0x04 => BinOp::Sub, + 0x05 => BinOp::Mul, + 0x06 => BinOp::Div, + 0x07 => BinOp::Pow, + 0x08 => BinOp::Concat, + 0x09 => BinOp::Lt, + 0x0A => BinOp::Le, + 0x0B => BinOp::Eq, + 0x0C => BinOp::Ge, + 0x0D => BinOp::Gt, + 0x0E => BinOp::Ne, + 0x0F => BinOp::Intersect, + 0x10 => BinOp::Union, + _ => BinOp::Range, + }; + let b = pop(&mut stack, &mut kids)?; + let a = pop(&mut stack, &mut kids)?; + push(&mut stack, kids, Expr::Binary(op, Box::new(a), Box::new(b)))?; + } + 0x12..=0x14 => { + let op = match id { + 0x12 => UnOp::Plus, + 0x13 => UnOp::Neg, + _ => UnOp::Percent, + }; + let x = pop(&mut stack, &mut kids)?; + push(&mut stack, kids, Expr::Unary(op, Box::new(x)))?; + } + 0x15 => { + let x = pop(&mut stack, &mut kids)?; + push(&mut stack, kids, Expr::Paren(Box::new(x)))?; + } + 0x16 => push(&mut stack, kids, Expr::Missing)?, + // PtgStr: cch (u16, at most 255) and always UTF-16, unlike BIFF8. + 0x17 => { + let cch = usize::from(t.u16()?); + if cch > 255 { + return Err(Unsupported("text constant too long")); + } + push(&mut stack, kids, Expr::Text(Arc::from(t.chars(cch)?)))?; + } + 0x19 => { + let kind = t.u8()?; + if kind & 0x04 != 0 { + // PtgAttrChoose: jump table of cOffset + 1 entries. + let n = usize::from(t.u16()?) + 1; + t.take(n * 2)?; + } else { + t.take(2)?; + } + if kind & 0x10 != 0 { + // PtgAttrSum: SUM of the single operand. + let x = pop(&mut stack, &mut kids)?; + push(&mut stack, kids, Expr::Call("SUM".into(), vec![x]))?; + } + // Semi (volatile), If, Goto, Space, Baxcel: no effect on the expression. + } + 0x1C => { + let e = t.u8()?; + push(&mut stack, kids, Expr::Error(error_code(e).ok_or(Unsupported("unknown error constant"))?))?; + } + 0x1D => push(&mut stack, kids, Expr::Bool(t.u8()? != 0))?, + 0x1E => push(&mut stack, kids, Expr::Number(f64::from(t.u16()?)))?, + 0x1F => { + let n = t.f64()?; + push(&mut stack, kids, Expr::Number(n))?; + } + 0x20 => { + // PtgArray: 14 unused bytes (Excel leaves junk in them); the values are in rgcb. + t.take(14)?; + push(&mut stack, kids, array_constant(&mut extra)?)?; + } + 0x21 => { + let iftab = t.u16()?; + let (name, args) = function(iftab).ok_or(Unsupported("unknown function"))?; + let n = usize::try_from(args).map_err(|_| Unsupported("unknown function argument count"))?; + let args = pop_n(&mut stack, n, &mut kids)?; + push(&mut stack, kids, Expr::Call(name.to_string(), args))?; + } + 0x22 => { + let n = usize::from(t.u8()?); + let tab = t.u16()?; + if tab & 0x8000 != 0 { + return Err(Unsupported("macro sheet commands")); + } + let mut args = pop_n(&mut stack, n, &mut kids)?; + if tab & 0x7FFF == 0x00FF { + // A function called by name (a newer function, add-in or LAMBDA): the name + // comes first, as a PtgName to a hidden `_xlfn.` name for a newer function. + if args.is_empty() { + return Err(Unsupported("malformed function call")); + } + let name = match args.remove(0) { + Expr::Name(n) => n, + _ => return Err(Unsupported("function call through an expression")), + }; + // `PY(index, …)` runs a script stored elsewhere in the package, which this + // import doesn't read. `PY("code", …)` carries its code and becomes a Python cell. + let py = name.rsplit('.').next().is_some_and(|n| n.eq_ignore_ascii_case("PY")); + if py && !args.first().is_some_and(literal_text) { + return Err(Unsupported("Python code stored outside the cell")); + } + push(&mut stack, kids, Expr::Call(name, args))?; + } else { + let (name, _) = function(tab & 0x7FFF).ok_or(Unsupported("unknown function"))?; + push(&mut stack, kids, Expr::Call(name.to_string(), args))?; + } + } + 0x23 => { + // PtgName: a 1-based index into every BrtName, hidden ones included. + let i = usize::try_from(t.u32()?).ok().and_then(|i| i.checked_sub(1)); + let name = i.and_then(|i| links.names.get(i)).ok_or(Unsupported("reference to a missing defined name"))?; + // Defined names are not imported from XLSB yet: a cell using one would calculate + // to #NAME?, so it keeps its saved result. Newer functions and LET parameters are + // hidden names that the formula text itself defines. + if !name.future && !is_param(&name.text) { + return Err(Unsupported("defined names")); + } + push(&mut stack, kids, Expr::Name(name.text.clone()))?; + } + 0x24 => { + let (r, c) = (t.u32()?, t.u16()?); + push(&mut stack, kids, Expr::Ref(Reference { sheet: SheetSel::Current, kind: RefKind::Cell(anchor(r, c)?) }))?; + } + 0x25 => { + let (r0, r1, c0, c1) = (t.u32()?, t.u32()?, t.u16()?, t.u16()?); + push(&mut stack, kids, Expr::Ref(Reference { sheet: SheetSel::Current, kind: area(r0, r1, c0, c1)? }))?; + } + 0x26 => { + // PtgMemArea: a cache of the sub-expression that follows. Its rgcb entry + // (PtgExtraMem) is a count and 16 bytes per cached area: skip both. + t.take(6)?; + let n = usize::try_from(extra.u32()?).map_err(|_| TRUNC)?; + extra.take(n.checked_mul(16).ok_or(TRUNC)?)?; + } + // PtgMemErr, PtgMemNoMem: 6 bytes; PtgMemFunc: 2. The sub-expression follows them. + 0x27 | 0x28 => { + t.take(6)?; + } + 0x29 => { + t.take(2)?; + } + 0x2A => { + t.take(6)?; + push(&mut stack, kids, Expr::Error(CellError::Ref))?; + } + 0x2B => { + t.take(12)?; + push(&mut stack, kids, Expr::Error(CellError::Ref))?; + } + 0x39 => return Err(Unsupported("names in other workbooks or on other sheets")), + 0x3A => { + let ixti = t.u16()?; + let (r, c) = (t.u32()?, t.u16()?); + let kind = RefKind::Cell(anchor(r, c)?); + push(&mut stack, kids, reference(links.sheet_sel(ixti)?, kind))?; + } + 0x3B => { + let ixti = t.u16()?; + let (r0, r1, c0, c1) = (t.u32()?, t.u32()?, t.u16()?, t.u16()?); + let kind = area(r0, r1, c0, c1)?; + push(&mut stack, kids, reference(links.sheet_sel(ixti)?, kind))?; + } + 0x3C | 0x3D => { + let ixti = t.u16()?; + t.take(if id == 0x3C { 6 } else { 12 })?; + // The sheet link must still be one the reader follows: an external #REF! stays cached. + links.sheet_sel(ixti)?; + push(&mut stack, kids, Expr::Error(CellError::Ref))?; + } + 0x01 => return Err(Unsupported("the shared or array formula form")), + 0x02 => return Err(Unsupported("what-if data tables")), + 0x18 => return Err(Unsupported("structured table references")), + 0x2C | 0x2D => return Err(Unsupported("relative references in a cell formula")), + _ => return Err(Unsupported("unknown formula token")), + } + if stack.len() > MAX_RGCE { + return Err(Unsupported("formula too complex")); + } + } + let (e, _) = stack.pop().ok_or(Unsupported("malformed formula (operand missing)"))?; + if !stack.is_empty() { + return Err(Unsupported("malformed formula (unused operands)")); + } + Ok(grouped(e, false)) +} + +/// Text written out in the formula: a string, or strings joined with `&` (how Python code +/// longer than a string constant is written). +fn literal_text(e: &Expr) -> bool { + match e { + Expr::Text(_) => true, + Expr::Binary(BinOp::Concat, a, b) => literal_text(a) && literal_text(b), + _ => false, + } +} + +/// How tightly an expression binds when printed, as the formula parser reads it: binary +/// operators by [`BinOp::precedence`], prefix `+`/`-` at 60 and `%` at 70 (`-2^2` is `(-2)^2`); +/// anything else is one operand. +fn binding(e: &Expr) -> u8 { + match e { + Expr::Binary(op, ..) => op.precedence(), + Expr::Unary(UnOp::Neg | UnOp::Plus, _) => 60, + Expr::Unary(UnOp::Percent, _) => 70, + _ => u8::MAX, + } +} + +/// The strings of a [`literal_text`] chain, left to right. +fn flatten_texts(e: Expr, out: &mut Vec) { + match e { + Expr::Binary(BinOp::Concat, a, b) => { + flatten_texts(*a, out); + flatten_texts(*b, out); + } + text => out.push(text), + } +} + +fn paren(e: Expr) -> Expr { + Expr::Paren(Box::new(e)) +} + +/// The tree with the parentheses its text needs to mean the same. Tokens are reverse Polish, so +/// grouping lives in their order: Excel adds `PtgParen` wherever its text has parentheses, but +/// `1 2 + 3 *` (another writer's, or a crafted file's) would print as `1+2*3`. Binary operators +/// are left-associative; a union in a function's arguments needs parentheses of its own. +/// Recursion follows the decoded tree, which `push` bounds at `MAX_DEPTH` levels. +fn grouped(e: Expr, in_args: bool) -> Expr { + match e { + // Strings joined with `&` are written as one flat chain, however their tokens nest: `&` + // is associative, and `PY("…"&"…")` is read as Python code only in that form. + e @ Expr::Binary(BinOp::Concat, ..) if literal_text(&e) => { + let mut texts = vec![]; + flatten_texts(e, &mut texts); + let mut texts = texts.into_iter(); + let first = texts.next().unwrap_or(Expr::Missing); + texts.fold(first, |a, b| Expr::Binary(BinOp::Concat, Box::new(a), Box::new(b))) + } + Expr::Binary(op, a, b) => { + let (a, b) = (grouped(*a, in_args), grouped(*b, in_args)); + let a = if binding(&a) < op.precedence() { paren(a) } else { a }; + let b = if binding(&b) <= op.precedence() { paren(b) } else { b }; + let e = Expr::Binary(op, Box::new(a), Box::new(b)); + if in_args && op == BinOp::Union { paren(e) } else { e } + } + Expr::Unary(op, x) => { + let x = grouped(*x, in_args); + // Each of `+`, `-` and `%` takes an operand that binds at least as tightly as a sign. The + // parser reads `-1%` as `-(1%)`, Excel's tokens as `(-1)%`: the same value, so a sign + // under `%` keeps Excel's spelling. + let needs = binding(&x) < 60; + Expr::Unary(op, Box::new(if needs { paren(x) } else { x })) + } + Expr::Paren(x) => paren(grouped(*x, false)), + Expr::Call(name, args) => Expr::Call(name, args.into_iter().map(|a| grouped(a, true)).collect()), + other => other, + } +} + +/// PtgExtraArray ([MS-XLSB] 2.5.98.41): row and column counts, then `SerAr` values in row-major +/// order. The type codes are not BIFF8's: 0x00 is a number here, not a missing value. +fn array_constant(b: &mut Bytes<'_>) -> Result { + let rows = usize::try_from(b.u32()?).map_err(|_| TRUNC)?; + let cols = usize::try_from(b.u32()?).map_err(|_| TRUNC)?; + if rows == 0 || cols == 0 || rows.saturating_mul(cols) > MAX_ARRAY { + return Err(Unsupported("array constant too large or empty")); + } + let mut out = Vec::with_capacity(rows); + for _ in 0..rows { + let mut row = Vec::with_capacity(cols); + for _ in 0..cols { + row.push(match b.u8()? { + 0x00 => Expr::Number(b.f64()?), + 0x01 => { + let cch = usize::from(b.u16()?); + if cch > 255 { + return Err(Unsupported("text constant too long")); + } + Expr::Text(Arc::from(b.chars(cch)?)) + } + 0x02 => Expr::Bool(b.u8()? != 0), + 0x04 => { + let e = b.u8()?; + b.take(3)?; + Expr::Error(error_code(e).ok_or(Unsupported("unknown error constant"))?) + } + _ => return Err(Unsupported("unknown array constant value")), + }); + } + out.push(row); + } + Ok(Expr::Array(out)) +} diff --git a/crates/xlsx/src/xlsb/ftab.rs b/crates/xlsx/src/xlsb/ftab.rs index c6b59092a..87f369519 100644 --- a/crates/xlsx/src/xlsb/ftab.rs +++ b/crates/xlsx/src/xlsb/ftab.rs @@ -487,8 +487,6 @@ const FTAB: &[(u16, &str, i8)] = &[ /// The function a `PtgFunc` or `PtgFuncVar` calls: its name and fixed argument count (-1 when it /// takes a variable number). `None` for a number the table doesn't assign. -// The formula decoder calls it. -#[allow(dead_code)] pub(super) fn function(iftab: u16) -> Option<(&'static str, i8)> { FTAB.binary_search_by_key(&iftab, |(i, _, _)| *i).ok().and_then(|i| FTAB.get(i)).map(|(_, n, a)| (*n, *a)) } diff --git a/crates/xlsx/tests/common/mod.rs b/crates/xlsx/tests/common/mod.rs index 59d3d8372..30703b3cd 100644 --- a/crates/xlsx/tests/common/mod.rs +++ b/crates/xlsx/tests/common/mod.rs @@ -3,12 +3,15 @@ use std::collections::BTreeMap; -use craft_xlsx::{CellRef, Error, Limits, Package, Range, SheetKind, Value, Visibility}; +use craft_xlsx::{CellFormula, CellRef, Error, Limits, Package, Range, SheetKind, Value, Visibility}; pub struct Sheet { pub name: String, pub visibility: Visibility, pub cells: BTreeMap, + /// Every cell's formula, and its cell metadata index (`cm`), where it has one. + pub formulas: BTreeMap, + pub cell_metadata: BTreeMap, pub merges: Vec, } @@ -16,6 +19,11 @@ impl Sheet { pub fn value(&self, at: CellRef) -> Value { self.cells.get(&at).cloned().unwrap_or_default() } + + /// The formula text at `at`, if the cell has a formula. + pub fn formula(&self, at: CellRef) -> Option<&str> { + self.formulas.get(&at).map(|f| f.text.as_str()) + } } pub struct Book { @@ -37,8 +45,15 @@ pub fn read_with(bytes: &[u8], limits: &Limits) -> Result { continue; } let mut cells = BTreeMap::new(); + let (mut formulas, mut cell_metadata) = (BTreeMap::new(), BTreeMap::new()); let part = p.sheet(e, |row| { for c in row.cells { + if let Some(f) = c.formula { + formulas.insert(c.at, f); + } + if let Some(m) = c.cell_metadata { + cell_metadata.insert(c.at, m); + } let v = c.value.resolve(&strings, wb.date_1904); if !v.is_empty() { cells.insert(c.at, v); @@ -46,7 +61,7 @@ pub fn read_with(bytes: &[u8], limits: &Limits) -> Result { } Ok(()) })?; - book.sheets.push(Sheet { name: e.name.clone(), visibility: e.visibility, cells, merges: part.merges }); + book.sheets.push(Sheet { name: e.name.clone(), visibility: e.visibility, cells, formulas, cell_metadata, merges: part.merges }); } book.warnings = p.warnings().to_vec(); Ok(book) diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index cef6d9cbe..42c27158b 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -442,3 +442,270 @@ fn phonetic_runs_use_documented_size_and_tolerate_padding() { } assert!(read(&file(&worksheet(&[row(0), cell(62, 0, &phonetic(2, 12))].concat(), &[]))).is_err()); } + +/// A formula cell (`BrtFmlaNum`, cached 0) with its own tokens and extra data. +fn formula_cell(col: u32, rgce: &[u8], rgcb: &[u8]) -> Vec { + let mut data = col.to_le_bytes().to_vec(); + data.extend([0; 4]); + data.extend(0f64.to_le_bytes()); + data.extend([0; 2]); + data.extend((rgce.len() as u32).to_le_bytes()); + data.extend(rgce); + data.extend((rgcb.len() as u32).to_le_bytes()); + data.extend(rgcb); + record(9, &data) +} + +fn name(flags: u32, text: &str) -> Vec { + let mut data = flags.to_le_bytes().to_vec(); + data.push(0); + data.extend(u32::MAX.to_le_bytes()); // Workbook scope. + data.extend(wide(text)); + data.extend([2, 0, 0, 0, 0x1c, 0x1d, 0, 0, 0, 0]); // Formula `#NAME?`, no extra data. + data.extend(u32::MAX.to_le_bytes()); // No comment. + record(39, &data) +} + +/// `book(false)` with a supporting-link block and defined names, as Excel writes them: this +/// workbook, then another; sheet links Data, Hidden, Data:Hidden, a deleted sheet and the other +/// workbook; hidden names for CONCAT, LET and a LET parameter, then the user name Rate. +fn book_with_links(extern_sheet: &[u8]) -> Vec { + let plain = book(false); + let end = record(132, &[]); + let mut out = plain[..plain.len() - end.len()].to_vec(); + out.extend(record(353, &[])); + out.extend(record(357, &[])); + out.extend(record(355, &wide("rId9"))); + out.extend(record(362, extern_sheet)); + out.extend(record(354, &[])); + const FUTURE: u32 = 0x0002_000b; + out.extend(name(FUTURE, "_xlfn.CONCAT")); + out.extend(name(FUTURE, "_xlfn.LET")); + out.extend(name(0x0002_0019, "_xlpm.x")); + out.extend(name(0, "Rate")); + out.extend(end); + out +} + +fn xti() -> Vec { + let mut out = 5u32.to_le_bytes().to_vec(); + for (book, first, last) in [(0u32, 0i32, 0i32), (0, 1, 1), (0, 0, 1), (0, -1, -1), (1, 0, 0)] { + out.extend(book.to_le_bytes()); + out.extend(first.to_le_bytes()); + out.extend(last.to_le_bytes()); + } + out +} + +fn loc(row: u32, col: u16) -> Vec { + [&row.to_le_bytes()[..], &col.to_le_bytes()].concat() +} + +/// Relative row and column flags of a `ColRelShort`. +const REL: u16 = 0xC000; + +fn warned(wb: &common::Book, why: &str) -> bool { + wb.warnings.iter().any(|w| w.contains("kept as their saved results") && w.contains(why)) +} + +#[test] +fn cell_formulas_are_read_in_their_xlsx_spelling() { + let ref3d = |ixti: u16, row: u32, col: u16| [&[0x5Au8][..], &ixti.to_le_bytes(), &loc(row, col)].concat(); + let cells: Vec<(u32, Vec, Vec)> = vec![ + (1, [&[0x44u8][..], &loc(0, REL), &[0x1E, 2, 0, 0x05]].concat(), vec![]), + (2, [&[0x25u8][..], &0u32.to_le_bytes(), &1u32.to_le_bytes(), &0u16.to_le_bytes(), &REL.to_le_bytes(), &[0x19, 0x10, 0, 0]].concat(), vec![]), + (3, ref3d(1, 1, 1 | REL), vec![]), + ( + 4, + [ + &[0x3Bu8][..], + &2u16.to_le_bytes(), + &0u32.to_le_bytes(), + &0xFFFFFu32.to_le_bytes(), + &REL.to_le_bytes(), + &REL.to_le_bytes(), + &[0x19, 0x10, 0, 0], + ] + .concat(), + vec![], + ), + (5, [&[0x23u8, 1, 0, 0, 0][..], &[0x17, 1, 0, b'a', 0], &[0x17, 1, 0, b'b', 0], &[0x42, 3, 0xFF, 0]].concat(), vec![]), + (6, vec![0x1E, 1, 0, 0x1E, 0, 0, 0x06, 0x1E, 2, 0, 0x41, 0xE0, 0x01], vec![]), + ( + 7, + [&[0x60u8][..], &[0xAB; 14]].concat(), + [&2u32.to_le_bytes()[..], &2u32.to_le_bytes(), &[0], &1f64.to_le_bytes(), &[1, 1, 0, b'x', 0], &[2, 1], &[4, 0x2A, 0, 0, 0]].concat(), + ), + ( + 8, + [&[0x23u8, 2, 0, 0, 0][..], &[0x23, 3, 0, 0, 0, 0x1E, 1, 0], &[0x23, 3, 0, 0, 0, 0x1E, 1, 0, 0x03], &[0x42, 4, 0xFF, 0]].concat(), + vec![], + ), + (9, ref3d(3, 0, 0), vec![]), + (10, [&[0x25u8][..], &0u32.to_le_bytes(), &1u32.to_le_bytes(), &REL.to_le_bytes(), &REL.to_le_bytes(), &[0x41, 20, 0]].concat(), vec![]), + // Kept as their saved results: + (11, vec![0x43, 4, 0, 0, 0, 0x1E, 2, 0, 0x05], vec![]), + (12, ref3d(4, 0, REL), vec![]), + (13, vec![0x01, 0, 0, 0, 0], vec![0, 0, 0, 0]), + ]; + let mut data = row(0); + data.extend(cell(5, 0, &3.0f64.to_le_bytes())); + for (col, rgce, rgcb) in &cells { + data.extend(formula_cell(*col, rgce, rgcb)); + } + data.extend(record(49, &1u32.to_le_bytes())); // BrtCellMeta: the next formula is a dynamic array. + data.extend(formula_cell(14, &[0x1E, 1, 0], &[])); + data.extend(formula_cell(15, &[0x18, 0x19, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], &[])); // A table reference. + let wb = read(&package(&book_with_links(&xti()), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + let sheet = &wb.sheets[0]; + let got: Vec<_> = (1..=15).map(|c| sheet.formula(CellRef::new(0, c))).collect(); + // As an `.xlsx` file holds them: names in their file spelling (`_xlfn.`, `_xlpm.`), and no + // implicit `@`, which is how a calculator reads a legacy formula, not how the file spells it. + let want = [ + Some("A1*2"), + Some("SUM($A$1:A2)"), + Some("Hidden!B2"), + Some("SUM(Data:Hidden!A:A)"), + Some("_xlfn.CONCAT(\"a\",\"b\")"), + Some("IFERROR(1/0,2)"), + Some("{1,\"x\";TRUE,#N/A}"), + Some("_xlfn.LET(_xlpm.x,1,_xlpm.x+1)"), + Some("#REF!"), + Some("SQRT(A1:A2)"), + None, + None, + None, + // A BrtCellMeta before a cell gives it cell metadata, as `cm` does in .xlsx. + Some("1"), + None, + ]; + assert_eq!(got, want); + assert!(sheet.formulas.values().all(|f| f.kind == craft_xlsx::FormulaKind::Normal)); + assert_eq!(sheet.cell_metadata.iter().collect::>(), [(&CellRef::new(0, 14), &1)]); + // Every formula cell keeps its saved result as its value. + assert!((1..=15).all(|c| sheet.value(CellRef::new(0, c)) == Value::Number(0.0))); + for why in ["defined names", "other workbooks", "the shared or array formula form", "structured table references"] { + assert!(warned(&wb, why), "{why}: {:?}", wb.warnings); + } +} + +#[test] +fn unreadable_links_keep_every_formula_as_its_value() { + // A sheet-link count past the spec's limit, and a truncated list: the file opens as it did + // before formulas were read, with values only. + let mut truncated = xti(); + truncated.truncate(20); + for extern_sheet in [70_000u32.to_le_bytes().to_vec(), truncated] { + let data = [row(0), formula_cell(0, &[0x1E, 1, 0], &[])].concat(); + let wb = read(&package(&book_with_links(&extern_sheet), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), None); + assert_eq!(wb.sheets[0].value(CellRef::new(0, 0)), Value::Number(0.0)); + assert!(wb.warnings.iter().any(|w| w.contains("could not be read")), "{:?}", wb.warnings); + } +} + +#[test] +fn formula_grouping_follows_token_order() { + // Reverse-Polish tokens group by their order alone. Excel writes PtgParen wherever its text + // has parentheses, but another writer need not: the text gets the ones it needs to mean the + // same, and no more. + let a = |row: u32| [&[0x24u8][..], &loc(row, REL)].concat(); + let int = |n: u8| vec![0x1E, n, 0]; + let cases: Vec<(Vec, &str)> = vec![ + ([int(1), int(2), vec![0x03], int(3), vec![0x05]].concat(), "(1+2)*3"), + ([int(1), int(2), int(3), vec![0x04, 0x04]].concat(), "1-(2-3)"), + ([int(1), int(2), vec![0x04], int(3), vec![0x04]].concat(), "1-2-3"), + ([int(2), vec![0x13], int(2), vec![0x07]].concat(), "-2^2"), + ([int(2), int(2), vec![0x07, 0x13]].concat(), "-(2^2)"), + // Excel's tokens for its own `-1%`: the parser groups it the other way, to the same value. + ([int(1), vec![0x13, 0x14]].concat(), "-1%"), + ([int(1), int(2), vec![0x03, 0x14]].concat(), "(1+2)%"), + ([a(0), a(1), vec![0x10], vec![0x19, 0x10, 0, 0]].concat(), "SUM((A1,A2))"), + ([int(1), int(2), vec![0x03, 0x15], int(3), vec![0x05]].concat(), "(1+2)*3"), + ]; + let data: Vec = + [row(0)].into_iter().chain(cases.iter().enumerate().map(|(i, (rgce, _))| formula_cell(i as u32, rgce, &[]))).flatten().collect(); + let wb = read(&package(&book_with_links(&xti()), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + for (i, (_, want)) in cases.iter().enumerate() { + assert_eq!(wb.sheets[0].formula(CellRef::new(0, i as u32)), Some(*want)); + } +} + +#[test] +fn functions_past_0x17b_are_called_by_number() { + // [MS-XLSB] 2.5.98.10's numbers past the .xls table: IFERROR (PtgFunc) and SUMIFS (PtgFuncVar). + let sumifs = [&[0x1Eu8, 1, 0][..], &[0x1E, 2, 0], &[0x17, 2, 0, b'>', 0, b'0', 0], &[0x42, 3, 0xE2, 0x01]].concat(); + let data = [row(0), formula_cell(0, &[0x1E, 1, 0, 0x1E, 2, 0, 0x41, 0xE0, 0x01], &[]), formula_cell(1, &sumifs, &[])].concat(); + let wb = read(&package(&book_with_links(&xti()), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), Some("IFERROR(1,2)")); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 1)), Some("SUMIFS(1,2,\">0\")")); +} + +#[test] +fn hostile_formula_tokens_keep_the_saved_result() { + let mut deep = vec![0x1E, 1, 0]; + deep.resize(16384, 0x15); // Thousands of parentheses: refused by the depth guard. + let empty_array = [&[0x60u8][..], &[0; 14]].concat(); + let bad: Vec<(Vec, Vec)> = vec![ + (vec![0x1E, 1], vec![]), // Truncated PtgInt. + (vec![0x17, 1, 0, 0x00, 0xD8], vec![]), // Unpaired surrogate. + (vec![0x17, 0, 1], vec![]), // Text constant over 255. + ([&[0x24u8][..], &loc(1_048_576, 0)].concat(), vec![]), // Row past the grid. + (empty_array.clone(), vec![0; 8]), // Empty array constant. + (empty_array, vec![0xFF; 8]), // Huge one. + (vec![0x1E, 1, 0, 0x1E, 2, 0], vec![]), // Unused operand. + (vec![0x21, 0xD4, 0x01], vec![]), // Unassigned function number. + (vec![0x2C, 0, 0, 0, 0, 0, 0], vec![]), // PtgRefN outside a shared formula. + (vec![0x23, 0xFF, 0xFF, 0xFF, 0xFF], vec![]), // Name index past the list. + ([&[0x5Au8][..], &9u16.to_le_bytes(), &loc(0, 0)].concat(), vec![]), // Missing sheet link. + (deep, vec![]), + ]; + for (rgce, rgcb) in bad { + let data = [row(0), formula_cell(0, &rgce, &rgcb)].concat(); + let wb = read(&package(&book_with_links(&xti()), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), None, "{rgce:?}"); + assert_eq!(wb.sheets[0].value(CellRef::new(0, 0)), Value::Number(0.0)); + } +} + +#[test] +fn python_formulas_need_their_code_in_the_cell() { + // `PY("code", 0)` carries its code; `PY(0, 0)` names a script elsewhere in the package, which + // the reader doesn't read, and keeps its saved result. + let mut book = book_with_links(&xti()); + let end = record(132, &[]); + book.truncate(book.len() - end.len()); + book.extend(name(0x0002_000b, "_xlfn._xlws.PY")); + book.extend(end); + let py = |arg: &[u8]| [&[0x23u8, 5, 0, 0, 0][..], arg, &[0x1E, 0, 0, 0x42, 3, 0xFF, 0]].concat(); + // Code longer than one string constant is written as constants joined with `&`. + let joined = [&[0x17u8, 1, 0, b'1', 0][..], &[0x17, 2, 0, b'+', 0, b'1', 0], &[0x08]].concat(); + // The same strings nested to the right, `"1"&("+"&"1")` by token order: still one flat chain. + let nested = [&[0x17u8, 1, 0, b'1', 0][..], &[0x17, 1, 0, b'+', 0], &[0x17, 1, 0, b'1', 0], &[0x08, 0x08]].concat(); + let data = [ + row(0), + formula_cell(0, &py(&[0x17, 1, 0, b'1', 0]), &[]), + formula_cell(1, &py(&[0x1E, 0, 0]), &[]), + formula_cell(2, &py(&joined), &[]), + formula_cell(3, &py(&nested), &[]), + ] + .concat(); + let wb = read(&package(&book, &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + let formula = |c| wb.sheets[0].formula(CellRef::new(0, c)); + assert_eq!(formula(0), Some("_xlfn._xlws.PY(\"1\",0)")); + assert_eq!(formula(1), None); + assert_eq!(formula(2), Some("_xlfn._xlws.PY(\"1\"&\"+1\",0)")); + assert_eq!(formula(3), Some("_xlfn._xlws.PY(\"1\"&\"+\"&\"1\",0)")); + assert!(warned(&wb, "Python code stored outside"), "{:?}", wb.warnings); +} + +#[test] +fn formula_text_past_the_allowance_keeps_the_saved_result() { + // `1` takes the last byte of a one-byte allowance; the next formula doesn't fit. + let data = [row(0), formula_cell(0, &[0x1E, 1, 0], &[]), formula_cell(1, &[0x1E, 1, 0], &[])].concat(); + let limits = Limits { binary_formula_text: 1, ..Limits::default() }; + let wb = read_with(&package(&book_with_links(&xti()), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES), &limits).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), Some("1")); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 1)), None); + assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); +} From 734ade8cd988f95c318c788e810a07b86f3bc880 Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Thu, 12 Nov 2026 23:34:15 -0500 Subject: [PATCH 009/382] craft-xlsx: read shared, array and dynamic-array formulas from .xlsb files (port of gridcraft#3821) A cell whose tokens are only PtgExp (row) + PtgExtraCol (column) belongs to the shared or array formula starting there; its first cell is followed by BrtShrFmla or BrtArrFmla. - Shared formulas: each cell's copy is decoded from the shared tokens at its own cell, as [MS-XLSB] defines it (PtgRefN/PtgAreaN offsets, wrapping around the grid). Every cell of the group gets FormulaKind::Shared, its own text and the group's index (`si`, counted per sheet); the first also gets the group's range. Its first cell is the first that uses it, anywhere in its range. Copies are charged to the formula text allowance before they are decoded, so a long formula shared by a million cells stops costing once the allowance is spent. - Ctrl+Shift+Enter and dynamic arrays: the first cell gets FormulaKind::Array with its range; a dynamic one also has its cell metadata (BrtCellMeta, which now also holds across a BrtValueMeta written in between), as `cm` marks it in .xlsx. The other cells of an array keep their cached values and have no formula, as in .xlsx. - A record that can't be read leaves its range as values and never fails the file, with a warning; so does a first cell with no formula record after it. Ported from storytold/gridcraft#3821 (issue gridcraft#3806), with its review fixes (each copy decoded at its own cell; a shared formula may start inside its range). Changed from the GridCraft PR: - In .xlsx a shared formula's other cells have empty text. Here they have their own decoded text (and CellFormula's doc says so), because that is exact where shifting the first cell's text is not, as the PR's review found. - Clearing an array's other cells for recalculation, marking dynamic arrays to spill, and the check against GridCraft's parser's 8,192-character limit are GridCraft's reading, not the file's: the cells keep what the file holds. That test becomes one that a copy may be longer than its first cell. The PR's tests come along in tests/xlsb.rs, with craft-xlsx's model in the expectations. Checked against Excel: in a workbook Excel saved both as .xlsb and as .xlsx, every formula this reads (33, shared, array and dynamic ones included) has the .xlsx text, kind and range; the other 5 use tables, an external link or defined names. --- crates/xlsx/src/sheet.rs | 6 +- crates/xlsx/src/xlsb.rs | 210 ++++++++++++++++++++++++++++++-- crates/xlsx/src/xlsb/formula.rs | 51 +++++++- crates/xlsx/tests/xlsb.rs | 170 +++++++++++++++++++++++++- 4 files changed, 415 insertions(+), 22 deletions(-) diff --git a/crates/xlsx/src/sheet.rs b/crates/xlsx/src/sheet.rs index 243430f8e..2691764d5 100644 --- a/crates/xlsx/src/sheet.rs +++ b/crates/xlsx/src/sheet.rs @@ -113,8 +113,10 @@ pub enum FormulaKind { #[derive(Clone, Debug, Default, PartialEq)] pub struct CellFormula { pub kind: FormulaKind, - /// The formula as the file spells it (`_xlfn.` prefixes and all), trimmed. Empty for a - /// cell that shares the formula of its group's first cell. + /// The formula as the file spells it (`_xlfn.` prefixes and all), trimmed. In `.xlsx`, empty + /// for a cell that shares the formula of its group's first cell. A binary workbook (`.xlsb`) + /// stores a shared formula's tokens once, so every cell of the group gets its own text, + /// decoded at the cell. pub text: String, /// `si`: the shared formula group. pub shared_index: Option, diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index aedbae5ab..dfea974b6 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -7,17 +7,18 @@ mod expr; mod formula; mod ftab; +use std::collections::HashMap; use std::sync::Arc; use craft_opc::{ContentTypes, Rels}; use craft_sheet::{CellError, CellRef, MAX_COLS, MAX_ROWS, Range, Visibility}; -use crate::sheet::{Cell, CellFormula, CellValue, Row, SheetPart}; +use crate::sheet::{Cell, CellFormula, CellValue, FormulaKind, Row, SheetPart}; use crate::strings::StringItem; use crate::workbook::{SheetEntry, SheetKind, Workbook}; use crate::{Error, Limits, Warnings}; pub(crate) use formula::Links; -use formula::{Book, Name, Xti}; +use formula::{Book, Mode, Name, Xti}; pub(crate) const MAIN: &str = "application/vnd.ms-excel.main"; const BINARY_MAIN: &str = "application/vnd.ms-excel.sheet.binary.macroEnabled.main"; @@ -57,6 +58,11 @@ pub(crate) struct Budget { impl Budget { /// Charges a decoded formula's text if it fits [`Limits::binary_formula_text`]; a formula /// that doesn't keeps its saved result. + /// Whether formula text of `len` bytes would still fit, without charging it. + fn formula_text_fits(&self, len: usize, limits: &Limits) -> bool { + self.formula_text.get().saturating_add(len) <= limits.binary_formula_text + } + fn try_formula_text(&self, len: usize, limits: &Limits) -> bool { let total = self.formula_text.get().saturating_add(len); let fits = total <= limits.binary_formula_text; @@ -506,22 +512,178 @@ fn cell_formula<'a>(b: &mut Bytes<'a>) -> Result<(&'a [u8], &'a [u8]), Error> { /// A formula's text, or `None` (with a warning saying why) for one that keeps its saved result: /// the workbook's links couldn't be read, the tokens can't be decoded, or the formula text /// allowance is spent. -fn decode_formula(rgce: &[u8], rgcb: &[u8], links: Option<&Links>, limits: &Limits, budget: &Budget, warnings: &mut Warnings) -> Option { +fn decode_formula( + rgce: &[u8], + rgcb: &[u8], + mode: Mode, + links: Option<&Links>, + limits: &Limits, + budget: &Budget, + warnings: &mut Warnings, +) -> Option { let links = links?; - let text = match formula::decode(rgce, rgcb, links) { + let text = match formula::decode(rgce, rgcb, links, mode) { Ok(e) => expr::print(&e), Err(formula::Unsupported(why)) => { - warnings.warn(format!("XLSB: some formulas were kept as their saved results ({why})")); + kept(warnings, why); return None; } }; if !budget.try_formula_text(text.len(), limits) { - warnings.warn("XLSB: some formulas were kept as their saved results (more formula text than the limits allow)"); + kept(warnings, "more formula text than the limits allow"); return None; } Some(text) } +/// Warns, once per reason, that formulas were kept as their saved results. +fn kept(warnings: &mut Warnings, why: &str) { + warnings.warn(format!("XLSB: some formulas were kept as their saved results ({why})")); +} + +/// A `BrtShrFmla`: the cells it may cover, its tokens, its first cell's text length (what a copy +/// is expected to cost) and the group's index (`si`). +struct SharedFormula { + range: Range, + rgce: Vec, + rgcb: Vec, + len: usize, + si: u32, +} + +/// A formula cell whose tokens are only `PtgExp`: part of a shared or array formula. +enum Part { + /// The first cell: its formula is the `BrtShrFmla` or `BrtArrFmla` record that follows. + First, + /// Another cell of the formula whose first cell is this. + Of(CellRef), +} + +/// `PtgExp` ([MS-XLSB] 2.5.98.40) with its `PtgExtraCol`: the first cell of the shared or array +/// formula this cell belongs to. BIFF12 keeps only the row in the token and the column in rgcb. +fn part_of(rgce: &[u8], rgcb: &[u8], at: CellRef) -> Option> { + let (&ptg, row) = rgce.split_first()?; + if ptg != 0x01 { + return None; + } + let (Ok(row), Ok(col)) = (<[u8; 4]>::try_from(row), <[u8; 4]>::try_from(rgcb)) else { + return Some(Err("malformed shared or array formula references")); + }; + let first = CellRef::new(u32::from_le_bytes(row), u32::from_le_bytes(col)); + Some(Ok(if first == at { Part::First } else { Part::Of(first) })) +} + +/// One sheet's shared and array formulas, by first cell, as the reader meets them. `None` when +/// the formula keeps its values (so its other cells keep theirs). +#[derive(Default)] +struct RangeFormulas { + shared: HashMap>>, + arrays: HashMap>, +} + +impl RangeFormulas { + /// The formula of another cell `at` of the shared or array formula starting at `first`. A + /// shared formula's copy is decoded from the shared tokens at its own cell, as [MS-XLSB] + /// defines it (relative offsets wrap around the grid), and checked like any formula: its text + /// may be longer than the first cell's. That length estimates its cost, and a copy that can't + /// fit isn't decoded at all, so a long formula shared by a million cells stops costing once + /// the allowance is spent. An array formula's other cells have none, as in `.xlsx`. + fn follower( + &self, + at: CellRef, + first: CellRef, + links: Option<&Links>, + limits: &Limits, + budget: &Budget, + warnings: &mut Warnings, + ) -> Option { + if let Some(shared) = self.shared.get(&first) { + let sh = shared.as_ref()?; + if !sh.range.contains(at) { + kept(warnings, "malformed shared or array formula references"); + return None; + } + if !budget.formula_text_fits(sh.len, limits) { + kept(warnings, "more formula text than the limits allow"); + return None; + } + let text = decode_formula(&sh.rgce, &sh.rgcb, Mode::Shared(at), links, limits, budget, warnings)?; + return Some(CellFormula { kind: FormulaKind::Shared, text, shared_index: Some(sh.si), ..CellFormula::default() }); + } + match self.arrays.get(&first) { + Some(Some(range)) if range.contains(at) => {} + Some(Some(_)) => kept(warnings, "malformed shared or array formula references"), + Some(None) => {} + None => kept(warnings, "a shared or array formula that is missing from the file"), + } + None + } + + /// `BrtShrFmla` (427) or `BrtArrFmla` (426) right after the first cell `first` of its range: + /// the formula that cell keeps, recorded for the range's other cells. A record that can't be + /// read leaves the whole range as values; it never fails the file, as these records were + /// skipped before formulas were read. + #[allow(clippy::too_many_arguments)] + fn range_formula( + &mut self, + id: u16, + payload: &[u8], + first: CellRef, + links: Option<&Links>, + limits: &Limits, + budget: &Budget, + warnings: &mut Warnings, + ) -> Option { + let read = |b: &mut Bytes<'_>| -> Result<(Range, Vec, Vec), Error> { + let (r0, r1, c0, c1) = (b.u32()?, b.u32()?, b.u32()?, b.u32()?); + if id == 426 { + b.u8()?; // Only fAlwaysCalc, the calculator's to know. + } + let cce = b.u32()?; + if !(1..=16384).contains(&cce) { + return Err(invalid("invalid formula token length")); + } + let rgce = b.take(cce as usize)?.to_vec(); + let cb = b.u32()?; + let rgcb = b.take(cb as usize)?.to_vec(); + if r0 > r1 || c0 > c1 || r1 >= MAX_ROWS || c1 >= MAX_COLS { + return Err(invalid("invalid formula range")); + } + let range = Range::new(CellRef::new(r0, c0), CellRef::new(r1, c1)); + // An array formula's first cell is its range's top-left one. A shared formula's is the + // first cell that uses it, which need not be: the top-left cell may not share it. + let start_ok = if id == 427 { range.contains(first) } else { range.first == first }; + if !start_ok { + return Err(invalid("invalid formula range")); + } + Ok((range, rgce, rgcb)) + }; + let mut b = Bytes::new(payload); + let Ok((range, rgce, rgcb)) = read(&mut b).and_then(|r| b.finish().map(|()| r)) else { + kept(warnings, "malformed shared or array formulas"); + self.shared.insert(first, None); + self.arrays.insert(first, None); + return None; + }; + if id == 427 { + let text = decode_formula(&rgce, &rgcb, Mode::Shared(first), links, limits, budget, warnings); + let si = u32::try_from(self.shared.len()).unwrap_or(u32::MAX); + let shared = text.as_ref().map(|t| Arc::new(SharedFormula { range, rgce, rgcb, len: t.len(), si })); + self.shared.insert(first, shared); + return text.map(|text| CellFormula { + kind: FormulaKind::Shared, + text, + shared_index: Some(si), + range: Some(range), + ..CellFormula::default() + }); + } + let text = decode_formula(&rgce, &rgcb, Mode::Cell, links, limits, budget, warnings); + self.arrays.insert(first, text.as_ref().map(|_| range)); + text.map(|text| CellFormula { kind: FormulaKind::Array, text, range: Some(range), ..CellFormula::default() }) + } +} + fn value(id: u16, b: &mut Bytes<'_>, strings: usize, limits: &Limits, budget: &Budget) -> Result { let value = match id { 1 => CellValue::Empty, @@ -579,11 +741,25 @@ pub(crate) fn worksheet( let mut row: Option = None; let mut col = None; // BrtCellMeta applies to the cell record that follows it (a dynamic-array formula), as `cm` - // does in `.xlsx`: a one-based index into the metadata part's cell metadata. + // does in `.xlsx`: a one-based index into the metadata part's cell metadata. Excel may write + // the cell's BrtValueMeta (a rich value, such as a spill error) in between. let mut meta: Option = None; + let mut ranges = RangeFormulas::default(); + // The first cell of a shared or array formula, waiting for the record holding the formula. + let mut first: Option = None; while let Some((id, payload)) = records.next(warnings)? { let mut b = Bytes::new(payload); - let cell_metadata = meta.take(); + let cell_metadata = if id == 50 { meta } else { meta.take() }; + if let Some(at) = first.take() { + if matches!(id, 426 | 427) { + let f = ranges.range_formula(id, payload, at, links, limits, budget, warnings); + if let Some(cell) = row.as_mut().and_then(|r| r.cells.last_mut()).filter(|c| c.at == at) { + cell.formula = f; + } + continue; + } + kept(warnings, "a shared or array formula that is missing from the file"); + } match id { 49 => { let icmb = b.i32()?; @@ -648,10 +824,24 @@ pub(crate) fn worksheet( } let style = b.u32()?; let value = value(id, &mut b, strings, limits, budget)?; + let at = CellRef::new(current.index, c); let formula = if (8..=11).contains(&id) { let (rgce, rgcb) = cell_formula(&mut b)?; b.finish()?; - decode_formula(rgce, rgcb, links, limits, budget, warnings).map(|text| CellFormula { text, ..CellFormula::default() }) + match part_of(rgce, rgcb, at) { + None => decode_formula(rgce, rgcb, Mode::Cell, links, limits, budget, warnings) + .map(|text| CellFormula { text, ..CellFormula::default() }), + Some(Ok(Part::First)) => { + first = links.map(|_| at); + None + } + Some(Ok(Part::Of(start))) if links.is_some() => ranges.follower(at, start, links, limits, budget, warnings), + Some(Ok(Part::Of(_))) => None, + Some(Err(why)) => { + kept(warnings, why); + None + } + } } else { b.finish()?; None @@ -660,7 +850,7 @@ pub(crate) fn worksheet( budget.cell(limits)?; } current.cells.push(Cell { - at: CellRef::new(current.index, c), + at, style: style & 0x00FF_FFFF, phonetic: style & 0x0100_0000 != 0, value, diff --git a/crates/xlsx/src/xlsb/formula.rs b/crates/xlsx/src/xlsb/formula.rs index bed0adcd0..53b02f8a1 100644 --- a/crates/xlsx/src/xlsb/formula.rs +++ b/crates/xlsx/src/xlsb/formula.rs @@ -11,7 +11,7 @@ use std::sync::Arc; -use craft_sheet::{CellError, MAX_COLS, MAX_ROWS}; +use craft_sheet::{CellError, CellRef, MAX_COLS, MAX_ROWS}; use super::expr::{Anchor, BinOp, Expr, RefKind, Reference, SheetSel, UnOp}; use super::ftab::function; @@ -192,6 +192,14 @@ impl Bytes<'_> { const LAST_ROW: u32 = MAX_ROWS - 1; const LAST_COL: u32 = MAX_COLS - 1; +/// Where a formula lives: a cell formula's references hold coordinates; a shared formula's +/// relative tokens (`PtgRefN`, `PtgAreaN`) hold offsets from the shared formula's first cell. +#[derive(Clone, Copy, PartialEq)] +pub(super) enum Mode { + Cell, + Shared(CellRef), +} + /// RgceLoc ([MS-XLSB] 2.5.98.91): a row and a `ColRelShort` (14-bit column, then the /// column-relative and row-relative flags). In a cell formula the coordinates are absolute /// whatever the flags say; the flags only decide where `$` goes. @@ -203,9 +211,29 @@ fn anchor(row: u32, col: u16) -> Result { Ok(Anchor { row, col: c, row_abs: col & 0x8000 == 0, col_abs: col & 0x4000 == 0 }) } +/// RgceLocRel ([MS-XLSB] 2.5.98.92), in a shared formula: a relative row or column is an offset +/// from `base`, wrapping around the grid (1,048,576 rows, 16,384 columns), as Excel adds them. +/// An absolute one is a coordinate. +fn relative_anchor(row: u32, col: u16, base: CellRef) -> Result { + let (row_rel, col_rel) = (col & 0x8000 != 0, col & 0x4000 != 0); + let r = if row_rel { base.row.wrapping_add(row) % MAX_ROWS } else { row }; + let c = if col_rel { (base.col + u32::from(col & 0x3FFF)) % MAX_COLS } else { u32::from(col & 0x3FFF) }; + anchor(r, (c as u16) | (col & 0xC000)) +} + +fn loc(row: u32, col: u16, mode: Mode) -> Result { + match mode { + Mode::Cell => anchor(row, col), + Mode::Shared(base) => relative_anchor(row, col, base), + } +} + /// RgceArea: a range spanning every row (or column) is a whole-column (row) reference. fn area(r0: u32, r1: u32, c0: u16, c1: u16) -> Result { - let (a, b) = (anchor(r0, c0)?, anchor(r1, c1)?); + area_of(anchor(r0, c0)?, anchor(r1, c1)?) +} + +fn area_of(a: Anchor, b: Anchor) -> Result { Ok(if a.row == 0 && b.row == LAST_ROW { RefKind::Cols(a.col, a.col_abs, b.col, b.col_abs) } else if a.col == 0 && b.col == LAST_COL { @@ -222,10 +250,11 @@ fn reference(sheet: Option, kind: RefKind) -> Expr { } } -/// Decodes a cell formula's `rgce` (tokens) with its `rgcb` (extra data for array constants and +/// Decodes a formula's `rgce` (tokens) with its `rgcb` (extra data for array constants and /// cached areas). Returns the expression, with names in their file spelling, or why it can't be -/// represented. -pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links) -> Result { +/// represented. A shared formula's tokens are decoded once for each of its cells +/// (`Mode::Shared` with that cell), whose relative references are offsets from it. +pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Result { if rgce.len() > MAX_RGCE { return Err(Unsupported("formula too long")); } @@ -414,7 +443,17 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links) -> Result return Err(Unsupported("the shared or array formula form")), 0x02 => return Err(Unsupported("what-if data tables")), 0x18 => return Err(Unsupported("structured table references")), - 0x2C | 0x2D => return Err(Unsupported("relative references in a cell formula")), + 0x2C => { + let Mode::Shared(_) = mode else { return Err(Unsupported("relative references in a cell formula")) }; + let (r, c) = (t.u32()?, t.u16()?); + push(&mut stack, kids, Expr::Ref(Reference { sheet: SheetSel::Current, kind: RefKind::Cell(loc(r, c, mode)?) }))?; + } + 0x2D => { + let Mode::Shared(_) = mode else { return Err(Unsupported("relative references in a cell formula")) }; + let (r0, r1, c0, c1) = (t.u32()?, t.u32()?, t.u16()?, t.u16()?); + let kind = area_of(loc(r0, c0, mode)?, loc(r1, c1, mode)?)?; + push(&mut stack, kids, Expr::Ref(Reference { sheet: SheetSel::Current, kind }))?; + } _ => return Err(Unsupported("unknown formula token")), } if stack.len() > MAX_RGCE { diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index 42c27158b..d2b03dbbd 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -5,7 +5,7 @@ mod common; use common::{read, read_with}; use craft_xlsx::testing::zip; -use craft_xlsx::{CellError, CellRef, Error, Limits, Range, SheetKind, Value, Visibility, is_xlsb}; +use craft_xlsx::{CellError, CellRef, Error, FormulaKind, Limits, Range, SheetKind, Value, Visibility, is_xlsb}; const ROOT: &str = r#""#; const RELS: &str = r#""#; @@ -546,7 +546,7 @@ fn cell_formulas_are_read_in_their_xlsx_spelling() { // Kept as their saved results: (11, vec![0x43, 4, 0, 0, 0, 0x1E, 2, 0, 0x05], vec![]), (12, ref3d(4, 0, REL), vec![]), - (13, vec![0x01, 0, 0, 0, 0], vec![0, 0, 0, 0]), + (13, vec![0x01, 0, 0, 0, 0], vec![0, 0, 0, 0]), // Part of a shared formula at A1 that isn't one. ]; let mut data = row(0); data.extend(cell(5, 0, &3.0f64.to_le_bytes())); @@ -580,11 +580,11 @@ fn cell_formulas_are_read_in_their_xlsx_spelling() { None, ]; assert_eq!(got, want); - assert!(sheet.formulas.values().all(|f| f.kind == craft_xlsx::FormulaKind::Normal)); + assert!(sheet.formulas.values().all(|f| f.kind == FormulaKind::Normal)); assert_eq!(sheet.cell_metadata.iter().collect::>(), [(&CellRef::new(0, 14), &1)]); // Every formula cell keeps its saved result as its value. assert!((1..=15).all(|c| sheet.value(CellRef::new(0, c)) == Value::Number(0.0))); - for why in ["defined names", "other workbooks", "the shared or array formula form", "structured table references"] { + for why in ["defined names", "other workbooks", "missing from the file", "structured table references"] { assert!(warned(&wb, why), "{why}: {:?}", wb.warnings); } } @@ -709,3 +709,165 @@ fn formula_text_past_the_allowance_keeps_the_saved_result() { assert_eq!(wb.sheets[0].formula(CellRef::new(0, 1)), None); assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); } + +fn range_formula(id: u16, (r0, c0, r1, c1): (u32, u32, u32, u32), rgce: &[u8]) -> Vec { + let mut data = vec![]; + for n in [r0, r1, c0, c1] { + data.extend(n.to_le_bytes()); + } + if id == 426 { + data.push(0x08); // The flags Excel writes for an ordinary array. + } + data.extend((rgce.len() as u32).to_le_bytes()); + data.extend(rgce); + data.extend(0u32.to_le_bytes()); + record(id, &data) +} + +/// A cell of the shared or array formula whose first cell is `row`, `col` (PtgExp + PtgExtraCol). +fn part(col: u32, (row, first_col): (u32, u32)) -> Vec { + formula_cell(col, &[&[0x01u8][..], &row.to_le_bytes()].concat(), &first_col.to_le_bytes()) +} + +fn ref_n(row: i32, col: u16) -> Vec { + [&[0x4Cu8][..], &row.to_le_bytes(), &col.to_le_bytes()].concat() +} + +fn at(a1: &str) -> CellRef { + CellRef::parse(a1).unwrap() +} + +#[test] +fn shared_array_and_dynamic_formulas_read_as_from_xlsx() { + // As Excel writes them: C1:C3 share `A1*10` (PtgRefN, column offset -2 as 16382); D1:E2 + // share `$A1+A$1`; F1:F2 hold the Ctrl+Shift+Enter array {=A1:A2*2}; G1 spills `=A1:A2`. + let area = [&[0x45u8][..], &0u32.to_le_bytes(), &1u32.to_le_bytes(), &REL.to_le_bytes(), &REL.to_le_bytes()].concat(); + let mut data = row(0); + data.extend(cell(5, 0, &1.0f64.to_le_bytes())); + data.extend(part(2, (0, 2))); + data.extend(range_formula(427, (0, 2, 2, 2), &[ref_n(0, 16382 | REL), vec![0x1E, 10, 0, 0x05]].concat())); + data.extend(part(3, (0, 3))); + data.extend(range_formula(427, (0, 3, 1, 4), &[ref_n(0, 0x8000), ref_n(0, 16381 | 0x4000), vec![0x03]].concat())); + data.extend(part(4, (0, 3))); + data.extend(part(5, (0, 5))); + data.extend(range_formula(426, (0, 5, 1, 5), &[area.clone(), vec![0x1E, 2, 0, 0x05]].concat())); + data.extend(record(49, &1u32.to_le_bytes())); + data.extend(record(50, &1u32.to_le_bytes())); // BrtValueMeta in between, as Excel writes for a spill error. + data.extend(part(6, (0, 6))); + data.extend(range_formula(426, (0, 6, 1, 6), &area)); + data.extend(row(1)); + data.extend(cell(5, 0, &2.0f64.to_le_bytes())); + for (col, first) in [(2, (0, 2)), (3, (0, 3)), (4, (0, 3)), (5, (0, 5)), (6, (0, 6))] { + data.extend(part(col, first)); + } + data.extend(row(2)); + data.extend(part(2, (0, 2))); + let wb = read(&file(&worksheet(&data, &[]))).unwrap(); + let sheet = &wb.sheets[0]; + let formula = |a: &str| sheet.formulas.get(&at(a)); + // Each cell of a shared formula has its own text, decoded at the cell: the first with the + // group's range, all with its index. + for (a, want, si) in [ + ("C1", "A1*10", 0), + ("C2", "A2*10", 0), + ("C3", "A3*10", 0), + ("D1", "$A1+A$1", 1), + ("E1", "$A1+B$1", 1), + ("D2", "$A2+A$1", 1), + ("E2", "$A2+B$1", 1), + ] { + let f = formula(a).unwrap_or_else(|| panic!("{a}")); + assert_eq!((f.kind, f.text.as_str(), f.shared_index), (FormulaKind::Shared, want, Some(si)), "{a}"); + } + assert_eq!(formula("C1").and_then(|f| f.range), Range::parse("C1:C3")); + assert_eq!(formula("D1").and_then(|f| f.range), Range::parse("D1:E2")); + assert_eq!(formula("C2").and_then(|f| f.range), None); + // An array formula's first cell has it, with its range; a dynamic array's has its cell + // metadata too, as `cm` in .xlsx, though Excel wrote a BrtValueMeta in between. + let f1 = formula("F1").unwrap(); + assert_eq!((f1.kind, f1.text.as_str(), f1.range), (FormulaKind::Array, "A1:A2*2", Range::parse("F1:F2"))); + let g1 = formula("G1").unwrap(); + assert_eq!((g1.kind, g1.text.as_str(), g1.range), (FormulaKind::Array, "A1:A2", Range::parse("G1:G2"))); + assert_eq!(sheet.cell_metadata.get(&at("G1")), Some(&1)); + assert_eq!(sheet.cell_metadata.get(&at("F1")), None); + // Their other cells have no formula and keep their saved results, as in .xlsx. + for a in ["F2", "G2"] { + assert!(formula(a).is_none(), "{a}"); + assert_eq!(sheet.value(at(a)), Value::Number(0.0), "{a}"); + } + assert!(!wb.warnings.iter().any(|w| w.contains("kept as their saved results")), "{:?}", wb.warnings); +} + +#[test] +fn unreadable_shared_formulas_keep_their_values() { + // A shared formula with an unsupported token, a range that doesn't start at its first cell, + // a truncated record, and a first cell with no formula record after it: every cell of each + // keeps its saved result, and the file opens. + let unknown = range_formula(427, (0, 0, 1, 0), &[0xFF]); + let wrong_start = range_formula(427, (0, 1, 1, 1), &[0x1E, 1, 0]); + // A well-framed record whose payload stops before rgcb's length. + let short: Vec = [&[0u8; 4][..], &1u32.to_le_bytes(), &[0; 8], &3u32.to_le_bytes(), &[0x1E, 1, 0]].concat(); + let truncated = record(427, &short); + for after_first in [unknown, wrong_start, truncated, cell(5, 1, &1.0f64.to_le_bytes())] { + let data = [row(0), part(0, (0, 0)), after_first, row(1), part(0, (0, 0))].concat(); + let wb = read(&file(&worksheet(&data, &[]))).unwrap(); + for r in [0, 1] { + assert_eq!(wb.sheets[0].formula(CellRef::new(r, 0)), None); + assert_eq!(wb.sheets[0].value(CellRef::new(r, 0)), Value::Number(0.0)); + } + assert!(wb.warnings.iter().any(|w| w.contains("kept as their saved results")), "{:?}", wb.warnings); + } +} + +#[test] +fn shared_formulas_wrap_and_may_start_inside_their_range() { + // `=` the cell to the left (column offset -1, written 16383), shared over A1:B2 from B1: A1 + // isn't part of it. In column A the offset wraps around the grid, as [MS-XLSB] defines it. + let left = ref_n(0, 16383 | REL); + let data = [ + row(0), + cell(5, 0, &1.0f64.to_le_bytes()), + part(1, (0, 1)), + range_formula(427, (0, 0, 1, 1), &left), + row(1), + part(0, (0, 1)), + part(1, (0, 1)), + ] + .concat(); + let wb = read(&file(&worksheet(&data, &[]))).unwrap(); + let text = |a: &str| wb.sheets[0].formula(at(a)); + assert_eq!((text("A1"), text("B1"), text("A2"), text("B2")), (None, Some("A1"), Some("XFD2"), Some("A2"))); + assert!(!wb.warnings.iter().any(|w| w.contains("kept as their saved results")), "{:?}", wb.warnings); +} + +#[test] +fn a_shared_formula_copy_may_be_longer_than_its_first_cell() { + // SUM of nine SUMs of 255 references to the cell on the left: about 6,900 characters at B9, + // over 18,000 at B999999, where each `A9` is `A999999`. Each copy has its own text. + let mut rgce = vec![]; + for _ in 0..9 { + for _ in 0..255 { + rgce.extend(ref_n(0, 16383 | REL)); + } + rgce.extend([0x22, 255, 4, 0]); + } + rgce.extend([0x22, 9, 4, 0]); + let data = [row(8), part(1, (8, 1)), range_formula(427, (8, 1, 999_998, 1), &rgce), row(999_998), part(1, (8, 1))].concat(); + let wb = read(&file(&worksheet(&data, &[]))).unwrap(); + let (b9, last) = (wb.sheets[0].formula(at("B9")).unwrap(), wb.sheets[0].formula(at("B999999")).unwrap()); + assert!(b9.len() < 8192 && last.len() > 18_000, "{} {}", b9.len(), last.len()); + assert!(last.starts_with("SUM(SUM(A999999,A999999"), "{}", &last[..40]); +} + +#[test] +fn shared_formula_copies_are_charged_before_they_are_made() { + // A1:A3 share `1+1` (3 bytes); with 6 bytes allowed, the first cell and one copy fit, and the + // last copy keeps its value without being decoded. + let one_plus_one = [0x1E, 1, 0, 0x1E, 1, 0, 0x03]; + let data = [row(0), part(0, (0, 0)), range_formula(427, (0, 0, 2, 0), &one_plus_one), row(1), part(0, (0, 0)), row(2), part(0, (0, 0))].concat(); + let limits = Limits { binary_formula_text: 6, ..Limits::default() }; + let wb = read_with(&file(&worksheet(&data, &[])), &limits).unwrap(); + let got: Vec<_> = (0..3).map(|r| wb.sheets[0].formula(CellRef::new(r, 0))).collect(); + assert_eq!(got, [Some("1+1"), Some("1+1"), None]); + assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); +} From 1f5f1f0f5143c312650c972bae48961414906b00 Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Thu, 12 Nov 2026 23:36:18 -0500 Subject: [PATCH 010/382] craft-xlsx: a shared formula stops decoding copies once one is kept as its value From gridcraft#3821's review (CodeRabbit, still open there): a shared formula's copies are checked against the formula text allowance with the first cell's length, which a copy can exceed. A copy that was decoded and printed, then kept as its value because it didn't fit, or because it couldn't be decoded, charged nothing, so a file with many cells of one long shared formula could repeat that work for each of them. The PR's case was GridCraft's 8,192-character rejection, which isn't here; the allowance and decode failures are the same path. After one such copy the group keeps every later copy as its value without decoding it, so a group costs at most one wasted decode. A new test shows a later copy that would have fit kept as its value; it fails without this commit. --- crates/xlsx/src/xlsb.rs | 13 ++++++++++--- crates/xlsx/tests/xlsb.rs | 14 ++++++++++++++ 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index dfea974b6..d0bf980c9 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -589,7 +589,7 @@ impl RangeFormulas { /// fit isn't decoded at all, so a long formula shared by a million cells stops costing once /// the allowance is spent. An array formula's other cells have none, as in `.xlsx`. fn follower( - &self, + &mut self, at: CellRef, first: CellRef, links: Option<&Links>, @@ -598,7 +598,7 @@ impl RangeFormulas { warnings: &mut Warnings, ) -> Option { if let Some(shared) = self.shared.get(&first) { - let sh = shared.as_ref()?; + let sh = shared.clone()?; if !sh.range.contains(at) { kept(warnings, "malformed shared or array formula references"); return None; @@ -607,7 +607,14 @@ impl RangeFormulas { kept(warnings, "more formula text than the limits allow"); return None; } - let text = decode_formula(&sh.rgce, &sh.rgcb, Mode::Shared(at), links, limits, budget, warnings)?; + let Some(text) = decode_formula(&sh.rgce, &sh.rgcb, Mode::Shared(at), links, limits, budget, warnings) else { + // A copy that was decoded but kept as its value charged nothing: one past the + // allowance (it may be longer than the first cell's estimate) or one that can't be + // decoded. The group's later copies would fail the same way, so they keep their + // values without being decoded: a group costs at most one wasted decode. + self.shared.insert(first, None); + return None; + }; return Some(CellFormula { kind: FormulaKind::Shared, text, shared_index: Some(sh.si), ..CellFormula::default() }); } match self.arrays.get(&first) { diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index d2b03dbbd..3f1c51b7f 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -871,3 +871,17 @@ fn shared_formula_copies_are_charged_before_they_are_made() { assert_eq!(got, [Some("1+1"), Some("1+1"), None]); assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); } + +#[test] +fn a_shared_formula_stops_decoding_copies_once_one_is_kept_as_its_value() { + // A1:Z2 share `=` the cell to the right. A1 is `B1` (2 bytes), Z1's copy is `AA1` (3): it + // passes the estimate from the first cell but not the allowance, after being decoded. The + // group's later copies keep their values without being decoded, though B2's (`C2`) would fit. + let right = ref_n(0, 1 | REL); + let data = [row(0), part(0, (0, 0)), range_formula(427, (0, 0, 1, 25), &right), part(25, (0, 0)), row(1), part(1, (0, 0))].concat(); + let limits = Limits { binary_formula_text: 4, ..Limits::default() }; + let wb = read_with(&file(&worksheet(&data, &[])), &limits).unwrap(); + let text = |a: &str| wb.sheets[0].formula(at(a)); + assert_eq!((text("A1"), text("Z1"), text("B2")), (Some("B1"), None, None)); + assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); +} From 20050077adcd794cfef32805f73de6191069962d Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Thu, 12 Nov 2026 23:36:47 -0500 Subject: [PATCH 011/382] craft-xlsx: the README describes formulas in binary workbooks They were "token streams that are not decoded". The README now says what the decoder gives (text in the file's spelling, shared and array kinds and ranges, cell metadata, each shared copy's own text), what keeps its saved result and why, that the function table and printer are this crate's own, and the binary_formula_text limit with the decoder's fixed bounds. --- crates/xlsx/README.md | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/crates/xlsx/README.md b/crates/xlsx/README.md index 3d3808ad3..1dc30574d 100644 --- a/crates/xlsx/README.md +++ b/crates/xlsx/README.md @@ -83,9 +83,15 @@ for new pictures (`vm = i + 1`) and the `XLDAPR` dynamic-array metadata (`cm = 1 The parts this crate writes use the transitional namespaces; a strict file's kept parts stay as they were. A binary workbook is not written. -A binary workbook gives the same `Workbook`, strings, rows and merged cells, with saved values -only: its formulas are token streams that are not decoded, and its styles are not read (each -cell keeps its format index). +A binary workbook gives the same `Workbook`, strings, rows and merged cells. Its styles are not +read (each cell keeps its format index). Its cell formulas are decoded from their tokens into the +text an `.xlsx` file holds (`_xlfn.` and `_xlpm.` names as written, no implicit `@`), with +`FormulaKind::Shared` or `FormulaKind::Array` and their ranges, and `BrtCellMeta` as the cell +metadata index. Every cell of a shared formula gets its own text, decoded at the cell, since the +file keeps the tokens once. A formula whose decoding needs something the reader does not read +keeps only its saved result, with a warning saying why: user defined names, table references, +other workbooks, Python code stored outside the cell, data tables. The XLSB function table +(`xlsb/ftab.rs`) and the expression printer are this crate's own, apart from `craft-xls`'s. ## Hostile input @@ -94,7 +100,9 @@ cell keeps its format index). string and what is left of a part, not a sheet's length. - `Limits.binary_records`, `binary_cells`, `binary_text`: a binary workbook, over all its parts (40 million records, 4 million cells and as many shared strings, 256 MiB of text, as - `craft-xls` allows). Fixed caps: 1024 sheets, 100,000 merged ranges per sheet, 64 nested + `craft-xls` allows). `binary_formula_text`: decoded formula text over the workbook (128 MiB); + past it, formulas keep their saved results. A formula's tokens are bounded at 16 KB, its + nesting at 256 levels and an array constant at 65,536 values. Fixed caps: 1024 sheets, 100,000 merged ranges per sheet, 64 nested extension blocks. - Cells and rows outside the 1,048,576 × 16,384 grid are dropped and counted. From 79b4fd014497d72305aa2ff7e2802127d42e37fa Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Fri, 13 Nov 2026 00:04:32 -0500 Subject: [PATCH 012/382] craft-xlsx: review fixes: CONVERT, shared formula tokens borrowed, cell metadata with its formula From the first review round: - 468 (0x1D4) is CONVERT, with 3 arguments. [MS-XLSB]'s Ftab table has no row for it, though its grammar lists convert-params among the fixed-argument functions; Excel writes =CONVERT(1,"m","ft") in .xlsb as a PtgFunc calling 0x1D4 (observed in Excel). It was the only unassigned number from 0x17C to 0x1E4. The module doc says it isn't the specification's row. - A BrtShrFmla's tokens and extra data are borrowed from the worksheet part instead of copied: a record may claim up to 256 MiB, and each shared formula is kept for the rest of the sheet, so the copies could cost as much again as the part. BrtArrFmla's are used at once and borrowed too. - A formula record's cell metadata goes with its formula: when the formula is kept as its value (tokens the reader can't decode, an unreadable BrtArrFmla), the cell loses its `cm`, which would otherwise mark a dynamic-array formula that isn't there. A value cell keeps its cell metadata, as the file has it. The CONVERT and cell-metadata tests fail without this commit. The Excel-saved workbook still reads with all 33 formulas as in its .xlsx. --- crates/xlsx/src/xlsb.rs | 46 +++++++++++++++++++++++------------- crates/xlsx/src/xlsb/ftab.rs | 9 ++++++- crates/xlsx/tests/xlsb.rs | 33 ++++++++++++++++++++++++++ 3 files changed, 71 insertions(+), 17 deletions(-) diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index d0bf980c9..d46c2ea20 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -542,11 +542,14 @@ fn kept(warnings: &mut Warnings, why: &str) { } /// A `BrtShrFmla`: the cells it may cover, its tokens, its first cell's text length (what a copy -/// is expected to cost) and the group's index (`si`). -struct SharedFormula { +/// is expected to cost) and the group's index (`si`). The tokens are borrowed from the worksheet +/// part, which outlives the sheet's read: a record can be up to 256 MiB, and copying every +/// shared formula's would cost as much again as the part. +#[derive(Clone, Copy)] +struct SharedFormula<'a> { range: Range, - rgce: Vec, - rgcb: Vec, + rgce: &'a [u8], + rgcb: &'a [u8], len: usize, si: u32, } @@ -576,12 +579,12 @@ fn part_of(rgce: &[u8], rgcb: &[u8], at: CellRef) -> Option>>, +struct RangeFormulas<'a> { + shared: HashMap>>, arrays: HashMap>, } -impl RangeFormulas { +impl<'a> RangeFormulas<'a> { /// The formula of another cell `at` of the shared or array formula starting at `first`. A /// shared formula's copy is decoded from the shared tokens at its own cell, as [MS-XLSB] /// defines it (relative offsets wrap around the grid), and checked like any formula: its text @@ -598,7 +601,7 @@ impl RangeFormulas { warnings: &mut Warnings, ) -> Option { if let Some(shared) = self.shared.get(&first) { - let sh = shared.clone()?; + let sh = (*shared)?; if !sh.range.contains(at) { kept(warnings, "malformed shared or array formula references"); return None; @@ -607,7 +610,7 @@ impl RangeFormulas { kept(warnings, "more formula text than the limits allow"); return None; } - let Some(text) = decode_formula(&sh.rgce, &sh.rgcb, Mode::Shared(at), links, limits, budget, warnings) else { + let Some(text) = decode_formula(sh.rgce, sh.rgcb, Mode::Shared(at), links, limits, budget, warnings) else { // A copy that was decoded but kept as its value charged nothing: one past the // allowance (it may be longer than the first cell's estimate) or one that can't be // decoded. The group's later copies would fail the same way, so they keep their @@ -634,14 +637,14 @@ impl RangeFormulas { fn range_formula( &mut self, id: u16, - payload: &[u8], + payload: &'a [u8], first: CellRef, links: Option<&Links>, limits: &Limits, budget: &Budget, warnings: &mut Warnings, ) -> Option { - let read = |b: &mut Bytes<'_>| -> Result<(Range, Vec, Vec), Error> { + let read = |b: &mut Bytes<'a>| -> Result<(Range, &'a [u8], &'a [u8]), Error> { let (r0, r1, c0, c1) = (b.u32()?, b.u32()?, b.u32()?, b.u32()?); if id == 426 { b.u8()?; // Only fAlwaysCalc, the calculator's to know. @@ -650,9 +653,9 @@ impl RangeFormulas { if !(1..=16384).contains(&cce) { return Err(invalid("invalid formula token length")); } - let rgce = b.take(cce as usize)?.to_vec(); + let rgce = b.take(cce as usize)?; let cb = b.u32()?; - let rgcb = b.take(cb as usize)?.to_vec(); + let rgcb = b.take(cb as usize)?; if r0 > r1 || c0 > c1 || r1 >= MAX_ROWS || c1 >= MAX_COLS { return Err(invalid("invalid formula range")); } @@ -673,9 +676,9 @@ impl RangeFormulas { return None; }; if id == 427 { - let text = decode_formula(&rgce, &rgcb, Mode::Shared(first), links, limits, budget, warnings); + let text = decode_formula(rgce, rgcb, Mode::Shared(first), links, limits, budget, warnings); let si = u32::try_from(self.shared.len()).unwrap_or(u32::MAX); - let shared = text.as_ref().map(|t| Arc::new(SharedFormula { range, rgce, rgcb, len: t.len(), si })); + let shared = text.as_ref().map(|t| SharedFormula { range, rgce, rgcb, len: t.len(), si }); self.shared.insert(first, shared); return text.map(|text| CellFormula { kind: FormulaKind::Shared, @@ -685,7 +688,7 @@ impl RangeFormulas { ..CellFormula::default() }); } - let text = decode_formula(&rgce, &rgcb, Mode::Cell, links, limits, budget, warnings); + let text = decode_formula(rgce, rgcb, Mode::Cell, links, limits, budget, warnings); self.arrays.insert(first, text.as_ref().map(|_| range)); text.map(|text| CellFormula { kind: FormulaKind::Array, text, range: Some(range), ..CellFormula::default() }) } @@ -761,6 +764,11 @@ pub(crate) fn worksheet( if matches!(id, 426 | 427) { let f = ranges.range_formula(id, payload, at, links, limits, budget, warnings); if let Some(cell) = row.as_mut().and_then(|r| r.cells.last_mut()).filter(|c| c.at == at) { + // A dynamic array's cell metadata describes its formula: with none kept, the + // cell is a value, and `cm` on it would mark a formula that isn't there. + if f.is_none() { + cell.cell_metadata = None; + } cell.formula = f; } continue; @@ -856,6 +864,12 @@ pub(crate) fn worksheet( if value != CellValue::Empty { budget.cell(limits)?; } + // A formula record's cell metadata describes its formula (a dynamic array), so a + // formula kept as its value drops it; the first cell of a shared or array formula + // keeps it until its formula record is read. Other cells keep theirs as the file + // has it. + let formula_kept = !(8..=11).contains(&id) || formula.is_some() || first == Some(at); + let cell_metadata = cell_metadata.filter(|_| formula_kept); current.cells.push(Cell { at, style: style & 0x00FF_FFFF, diff --git a/crates/xlsx/src/xlsb/ftab.rs b/crates/xlsx/src/xlsb/ftab.rs index 87f369519..efd6e4426 100644 --- a/crates/xlsx/src/xlsb/ftab.rs +++ b/crates/xlsx/src/xlsb/ftab.rs @@ -3,6 +3,10 @@ //! which craft-xls also carries. The entries from 380 (0x17C) on are the rest of the XLSB table: //! XLSB files call these functions by number, where `.xls` files call them by name. Kept apart from //! craft-xls's copy: the two formats follow separate specifications. +//! +//! One entry is not in the specification's table: 468 (0x1D4) is CONVERT. The table has no row +//! for it, but its grammar lists `convert-params` among the fixed-argument functions, and Excel +//! writes `=CONVERT(1,"m","ft")` in `.xlsb` as a `PtgFunc` calling 0x1D4. /// (iftab, name, fixed argument count or -1 when the function takes a variable number of /// arguments), sorted by number. @@ -467,6 +471,7 @@ const FTAB: &[(u16, &str, i8)] = &[ (465, "WEEKNUM", -1), (466, "AMORDEGRC", -1), (467, "AMORLINC", -1), + (468, "CONVERT", 3), (469, "ACCRINT", -1), (470, "ACCRINTM", -1), (471, "WORKDAY", -1), @@ -508,7 +513,9 @@ mod tests { assert_eq!(function(449), Some(("EDATE", 2))); assert_eq!(function(480), Some(("IFERROR", 2))); assert_eq!(function(482), Some(("SUMIFS", -1))); - assert_eq!(function(0x1D4), None, "unassigned"); + // Not in the specification's table, but what Excel writes for CONVERT. + assert_eq!(function(0x1D4), Some(("CONVERT", 3))); + assert_eq!(function(0x17B), Some(("RTD", -1))); assert_eq!(function(0x1E5), None); } } diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index 3f1c51b7f..518ca5214 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -885,3 +885,36 @@ fn a_shared_formula_stops_decoding_copies_once_one_is_kept_as_its_value() { assert_eq!((text("A1"), text("Z1"), text("B2")), (Some("B1"), None, None)); assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); } + +#[test] +fn convert_is_called_by_its_number_as_excel_writes_it() { + // Excel's tokens for `=CONVERT(1,"m","ft")` in .xlsb: PtgFunc 0x1D4, which the + // specification's Ftab table leaves out. + let rgce = [0x1E, 0x01, 0x00, 0x17, 0x01, 0x00, 0x6D, 0x00, 0x17, 0x02, 0x00, 0x66, 0x00, 0x74, 0x00, 0x41, 0xD4, 0x01]; + let wb = read(&file(&worksheet(&[row(0), formula_cell(0, &rgce, &[])].concat(), &[]))).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), Some("CONVERT(1,\"m\",\"ft\")")); +} + +#[test] +fn a_dynamic_array_kept_as_its_value_has_no_cell_metadata() { + let meta = record(49, &1u32.to_le_bytes()); + let table_ref = [0x18, 0x19, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]; + let data = [ + row(0), + // A1: a dynamic-array formula the reader can't decode (a table reference). + meta.clone(), + formula_cell(0, &table_ref, &[]), + // B1:B2: a dynamic array whose BrtArrFmla holds an unknown token. + meta.clone(), + part(1, (0, 1)), + range_formula(426, (0, 1, 1, 1), &[0xFF]), + // C1: a value with cell metadata keeps it, as the file has it. + meta, + cell(5, 2, &1.0f64.to_le_bytes()), + ] + .concat(); + let wb = read(&file(&worksheet(&data, &[]))).unwrap(); + let sheet = &wb.sheets[0]; + assert_eq!((sheet.formula(at("A1")), sheet.formula(at("B1"))), (None, None)); + assert_eq!(sheet.cell_metadata.iter().collect::>(), [(&at("C1"), &1)]); +} From 7aedc1de73d5fe3e2a771696ddd5401abf665d63 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 06:42:41 -0500 Subject: [PATCH 013/382] Share small raster format implementations --- crates/image-codecs/src/codecs/pcx.rs | 35 +- crates/image-codecs/src/codecs/xpm.rs | 2 +- crates/image-codecs/src/lib.rs | 14 + crates/image-codecs/src/options.rs | 6 +- crates/raster-codecs/Cargo.toml | 3 - crates/raster-codecs/README.md | 16 +- crates/raster-codecs/src/bridge.rs | 79 ++ crates/raster-codecs/src/dds.rs | 612 +-------------- crates/raster-codecs/src/dds_bc.rs | 369 --------- crates/raster-codecs/src/dicom.rs | 530 +------------ crates/raster-codecs/src/fits.rs | 859 +-------------------- crates/raster-codecs/src/iff.rs | 543 +------------ crates/raster-codecs/src/lib.rs | 53 +- crates/raster-codecs/src/pcx.rs | 149 +--- crates/raster-codecs/src/pnm.rs | 360 +-------- crates/raster-codecs/src/xpm.rs | 244 +----- crates/raster-codecs/src/xpm/x11_colors.rs | 666 ---------------- 17 files changed, 225 insertions(+), 4315 deletions(-) create mode 100644 crates/raster-codecs/src/bridge.rs delete mode 100644 crates/raster-codecs/src/dds_bc.rs delete mode 100644 crates/raster-codecs/src/xpm/x11_colors.rs diff --git a/crates/image-codecs/src/codecs/pcx.rs b/crates/image-codecs/src/codecs/pcx.rs index 48dbf1169..bf1b2eee6 100644 --- a/crates/image-codecs/src/codecs/pcx.rs +++ b/crates/image-codecs/src/codecs/pcx.rs @@ -1,5 +1,5 @@ //! ZSoft PCX (Paintbrush) reader: strictly bounded scanline RLE, 16/256-colour -//! palettes and 8-bit three-plane RGB. Read-only: modern saves should use PNG. +//! palettes, 8-bit RGB and four-plane RGBA. Read-only: modern saves should use PNG. use crate::SampleType; use crate::error::CodecError; @@ -19,7 +19,7 @@ fn le16(b: &[u8], i: usize) -> u16 { /// PCX lacks a strong magic number. Require plausible complete header fields before /// identifying it, rather than classifying every file starting with 0x0a as PCX. pub(crate) fn looks_like_pcx(b: &[u8]) -> bool { - if b.len() < HEADER || b[0] != 0x0a || !matches!(b[1], 0 | 2 | 3 | 5) || b[2] != 1 { + if b.len() < HEADER || b[0] != 0x0a || !matches!(b[1], 0 | 2..=5) || b[2] != 1 { return false; } let bits = b[3]; @@ -31,7 +31,12 @@ pub(crate) fn looks_like_pcx(b: &[u8]) -> bool { } let width = u32::from(x1 - x0) + 1; let min_stride = (width * u32::from(bits)).div_ceil(8); - stride >= min_stride && stride > 0 && (bits != 8 || matches!(planes, 1 | 3)) && (bits == 8 || u32::from(bits) * u32::from(planes) <= 4) + stride >= min_stride && stride > 0 && (bits != 8 || matches!(planes, 1 | 3 | 4)) && (bits == 8 || u32::from(bits) * u32::from(planes) <= 4) +} + +/// The dimensions declared by a plausible PCX header, without decoding its pixels. +pub(crate) fn dimensions(b: &[u8]) -> Option<(u32, u32)> { + looks_like_pcx(b).then(|| (u32::from(le16(b, 8) - le16(b, 4)) + 1, u32::from(le16(b, 10) - le16(b, 6)) + 1)) } /// Read one compressed scanline, including all planes. RLE packets never cross a scanline. @@ -61,11 +66,12 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { if !looks_like_pcx(b) { return Err(bad("invalid PCX header or unsupported pixel layout")); } - let (w, h) = (u32::from(le16(b, 8) - le16(b, 4)) + 1, u32::from(le16(b, 10) - le16(b, 6)) + 1); - limits.check(w, h, ChannelLayout::Rgb, SampleType::U8)?; + let (w, h) = dimensions(b).ok_or_else(|| bad("invalid PCX header or unsupported pixel layout"))?; + let layout = if b[3] == 8 && b[65] == 4 { ChannelLayout::Rgba } else { ChannelLayout::Rgb }; + limits.check(w, h, layout, SampleType::U8)?; let (bits, planes, stride) = (usize::from(b[3]), usize::from(b[65]), usize::from(le16(b, 66))); let row_len = stride.checked_mul(planes).ok_or_else(|| bad("row size overflow"))?; - let total = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(3)).ok_or_else(|| bad("pixel size overflow"))?; + let total = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(layout.channels())).ok_or_else(|| bad("pixel size overflow"))?; // The last 769 bytes are the optional VGA palette for 8-bit indexed images. let vga = bits == 8 && planes == 1 && b.len() >= HEADER + 769 && b[b.len() - 769] == 0x0c; if bits == 8 && planes == 1 && !vga && le16(b, 68) != 2 { @@ -102,8 +108,10 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { for y in 0..h as usize { read_row(&b[..image_end], &mut p, &mut row)?; for x in 0..width { - let rgb = if bits == 8 && planes == 3 { - [row[x], row[stride + x], row[2 * stride + x]] + let rgba = if bits == 8 && planes == 4 { + [row[x], row[stride + x], row[2 * stride + x], row[3 * stride + x]] + } else if bits == 8 && planes == 3 { + [row[x], row[stride + x], row[2 * stride + x], 255] } else { let index = if bits == 8 { usize::from(row[x]) @@ -118,19 +126,20 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { }; if vga { let o = image_end + 1 + index * 3; - [b[o], b[o + 1], b[o + 2]] + [b[o], b[o + 1], b[o + 2], 255] } else if bits == 8 { let g = index as u8; - [g, g, g] // palette-info 2: gray scale + [g, g, g, 255] // palette-info 2: gray scale } else { let o = 16 + index * 3; - [b[o], b[o + 1], b[o + 2]] + [b[o], b[o + 1], b[o + 2], 255] } }; - pixels[(y * width + x) * 3..(y * width + x + 1) * 3].copy_from_slice(&rgb); + let start = (y * width + x) * layout.channels(); + pixels[start..start + layout.channels()].copy_from_slice(&rgba[..layout.channels()]); } } - let mut image = Image::from_u8(w, h, ChannelLayout::Rgb, pixels)?; + let mut image = Image::from_u8(w, h, layout, pixels)?; let (xdpi, ydpi) = (le16(b, 12), le16(b, 14)); if xdpi > 0 && ydpi > 0 { image.meta.dpi = Some((f32::from(xdpi), f32::from(ydpi))); diff --git a/crates/image-codecs/src/codecs/xpm.rs b/crates/image-codecs/src/codecs/xpm.rs index c20f3c58e..2dbd867c9 100644 --- a/crates/image-codecs/src/codecs/xpm.rs +++ b/crates/image-codecs/src/codecs/xpm.rs @@ -96,7 +96,7 @@ fn channel(hex: &str) -> Option { Some(((v * 255 + max / 2) / max) as u8) } -fn named(name: &str) -> Option<[u8; 3]> { +pub(crate) fn named(name: &str) -> Option<[u8; 3]> { let s = name.to_ascii_lowercase().replace([' ', '-', '_'], ""); // XPM imports X11 names, whose RGB values differ from CSS for names // such as gray, maroon and purple. Keep these exact rather than guessing. diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index e02c438ec..8085ca44e 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -211,6 +211,20 @@ pub fn probe_size(bytes: &[u8]) -> Result<(u32, u32), CodecError> { Ok(if (5..=8).contains(&o) { (h, w) } else { (w, h) }) } +/// PCX's dimensions are available from its fixed-size header without decoding the RLE rows. +pub fn pcx_dimensions(bytes: &[u8]) -> Option<(u32, u32)> { + codecs::pcx::dimensions(bytes) +} + +/// The X11 color-name lookup used by XPM files, expressed as normalized sRGB. +pub fn xpm_named_color_rgb(name: &str) -> Option<[f32; 3]> { + if name.is_empty() || name.len() > 64 || !name.bytes().all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit()) { + return None; + } + let rgb = codecs::xpm::named(name)?; + Some(rgb.map(|channel| f32::from(channel) / 255.0)) +} + /// The colour table of a GIF's first frame (its Local Color Table, else the Global one) and the /// entry its Graphic Control Extension makes transparent, read without decoding pixels. pub fn gif_palette(bytes: &[u8]) -> Option<(Vec<[u8; 3]>, Option)> { diff --git a/crates/image-codecs/src/options.rs b/crates/image-codecs/src/options.rs index 9674b4edf..5dd0ac985 100644 --- a/crates/image-codecs/src/options.rs +++ b/crates/image-codecs/src/options.rs @@ -32,6 +32,10 @@ impl Default for Limits { } impl Limits { + /// Construct explicit bounds for a caller-owned format adapter. + pub const fn new(max_width: u32, max_height: u32, max_pixels: u64, max_alloc: u64) -> Self { + Limits { max_width, max_height, max_pixels, max_alloc } + } /// For a decoder that writes a band of rows at a time into the document's tiles instead of /// one buffer (TIFF, #8169): the largest document size, 300,000 px a side, on 64-bit /// targets, with `max_alloc` bounding each group of bands. 32-bit targets keep the @@ -85,7 +89,7 @@ impl Limits { /// never beats `max_ratio`:1. Called before the output buffer is allocated, so a /// header-only hostile file cannot make the decoder reserve gigabytes. A fixed 1 MiB of /// slack keeps tiny images and headers with large metadata unaffected. - pub(crate) fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> { + pub fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> { let capacity = (file_len as u64).saturating_mul(max_ratio).saturating_add(1 << 20); if declared_bytes > capacity { return Err(CodecError::LimitExceeded(format!("a {file_len} byte file cannot hold {declared_bytes} bytes of image data"))); diff --git a/crates/raster-codecs/Cargo.toml b/crates/raster-codecs/Cargo.toml index 002012b80..a29cda403 100644 --- a/crates/raster-codecs/Cargo.toml +++ b/crates/raster-codecs/Cargo.toml @@ -16,6 +16,3 @@ craft-image-codecs = { workspace = true } thiserror = { workspace = true } image = { version = "0.25", default-features = false } -# The DDS encoder compresses rows of blocks in parallel on native; wasm stays single-threaded. -[target.'cfg(not(target_arch = "wasm32"))'.dependencies] -rayon = { workspace = true } diff --git a/crates/raster-codecs/README.md b/crates/raster-codecs/README.md index 6735769ae..907e73763 100644 --- a/crates/raster-codecs/README.md +++ b/crates/raster-codecs/README.md @@ -1,12 +1,9 @@ # craft-raster-codecs -Small raster image formats for the Craft apps, from PhotoCraft's `photocraft-codecs`: one module -per format, one implementation of each. Decoders take untrusted bytes and `Limits`, check the -declared size before allocating, and never panic. No `unsafe`; it builds for -`wasm32-unknown-unknown`. The `common` RGBA image facade delegates PNG/JPEG/BMP/GIF/TIFF/WebP -decoding and PNG/JPEG encoding to [`craft-image-codecs`](../image-codecs/README.md), the shared -depth- and metadata-preserving codec implementation. Other dependencies are `thiserror`, and -`rayon` on native targets (the DDS encoder compresses rows of blocks in parallel). +Compatibility facade for the small raster-format modules in older Craft app versions. The +format readers and writers are implemented once in [`craft-image-codecs`](../image-codecs/README.md); +these modules forward calls and adapt the older `Image` and `Limits` types. The `common` RGBA +image facade also delegates to that crate. ```toml craft-raster-codecs = { git = "https://github.com/storytold/craft-libs", rev = "" } @@ -37,9 +34,8 @@ assert_eq!(image.data(), &[0, 255]); let bytes = pnm::encode(&image)?; ``` -Each module has a `looks_like_*` (or `is_dicom`) sniffer for the format's signature. `dds` and -`fits` also have `has_additional_images`, which says without decoding whether a file holds -more than the one image `decode` returns (cube faces, array slices, further HDUs). +The module sniffers and the `dds`/`fits` additional-image queries forward to shared detection and +metadata inspection in `craft-image-codecs`. `xpm::x11_color_rgb` also looks up exact normalized X11 names as RGB channels in `0..=1`. It accepts only 1–64 lowercase ASCII letters or digits, without normalization, XPM-only aliases, diff --git a/crates/raster-codecs/src/bridge.rs b/crates/raster-codecs/src/bridge.rs new file mode 100644 index 000000000..a1bd061db --- /dev/null +++ b/crates/raster-codecs/src/bridge.rs @@ -0,0 +1,79 @@ +//! Compatibility between this crate's small-format facade and the canonical image codec model. + +use crate::{ChannelLayout, CodecError, DecodeWarning, Image, Limits, SampleType}; +use craft_image_codecs::{DecodeOptions, Format, Metadata}; + +pub(crate) fn format(format: Format, bytes: &[u8], limits: &Limits) -> Result { + let shared_limits = craft_image_codecs::Limits::new(limits.max_width, limits.max_height, limits.max_pixels, limits.max_alloc); + let options = DecodeOptions { limits: shared_limits, ..DecodeOptions::default() }; + let image = craft_image_codecs::decode_as_with(format, bytes, &options).map_err(from_shared_error)?; + from_shared_image(image) +} + +pub(crate) fn shared_image(image: &Image) -> Result { + let layout = match image.layout() { + ChannelLayout::Gray => craft_image_codecs::ChannelLayout::Gray, + ChannelLayout::GrayA => craft_image_codecs::ChannelLayout::GrayA, + ChannelLayout::Rgb => craft_image_codecs::ChannelLayout::Rgb, + ChannelLayout::Rgba => craft_image_codecs::ChannelLayout::Rgba, + ChannelLayout::Cmyk => craft_image_codecs::ChannelLayout::Cmyk, + ChannelLayout::CmykA => craft_image_codecs::ChannelLayout::CmykA, + }; + let sample = match image.sample_type() { + SampleType::U8 => craft_image_codecs::SampleType::U8, + SampleType::U16 => craft_image_codecs::SampleType::U16, + SampleType::F32 => craft_image_codecs::SampleType::F32, + }; + let meta = Metadata { dpi: image.dpi, text: image.text.clone(), ..Metadata::default() }; + craft_image_codecs::Image::from_raw(image.width(), image.height(), layout, sample, image.data().to_vec()) + .map(|image| image.with_meta(meta)) + .map_err(from_shared_error) +} + +fn from_shared_image(image: craft_image_codecs::Image) -> Result { + let layout = match image.layout() { + craft_image_codecs::ChannelLayout::Gray => ChannelLayout::Gray, + craft_image_codecs::ChannelLayout::GrayA => ChannelLayout::GrayA, + craft_image_codecs::ChannelLayout::Rgb => ChannelLayout::Rgb, + craft_image_codecs::ChannelLayout::Rgba => ChannelLayout::Rgba, + craft_image_codecs::ChannelLayout::Cmyk => ChannelLayout::Cmyk, + craft_image_codecs::ChannelLayout::CmykA => ChannelLayout::CmykA, + _ => return Err(CodecError::InvalidImage(format!("unsupported small-codec layout {:?}", image.layout()))), + }; + let sample = match image.sample_type() { + craft_image_codecs::SampleType::U8 => SampleType::U8, + craft_image_codecs::SampleType::U16 => SampleType::U16, + craft_image_codecs::SampleType::F32 => SampleType::F32, + _ => return Err(CodecError::InvalidImage(format!("unsupported small-codec sample type {:?}", image.sample_type()))), + }; + let mut out = Image::from_raw(image.width(), image.height(), layout, sample, image.data().to_vec())?; + out.dpi = image.meta.dpi; + out.text = image.meta.text; + out.warnings = image + .warnings + .into_iter() + .filter_map(|warning| match warning { + craft_image_codecs::DecodeWarning::MorePages { total } | craft_image_codecs::DecodeWarning::MoreParts { total } => { + Some(DecodeWarning::MorePages { total }) + } + _ => None, + }) + .collect(); + Ok(out) +} + +pub(crate) fn from_shared_error(error: craft_image_codecs::CodecError) -> CodecError { + match error { + craft_image_codecs::CodecError::UnknownFormat => CodecError::unsupported("image", "unrecognized image format"), + craft_image_codecs::CodecError::Unsupported { format, reason } => CodecError::unsupported(format.name(), reason), + craft_image_codecs::CodecError::Malformed { format, message } => CodecError::malformed(format.name(), message), + craft_image_codecs::CodecError::LimitExceeded(message) => CodecError::LimitExceeded(message), + craft_image_codecs::CodecError::Encode { format, message } => CodecError::Encode { format: format.name(), message }, + craft_image_codecs::CodecError::InvalidImage(message) => CodecError::InvalidImage(message), + } +} + +pub(crate) fn encode(image: &Image, format: Format, options: &craft_image_codecs::EncodeOptions) -> Result, CodecError> { + let image = shared_image(image)?; + craft_image_codecs::encode(&image, format, options).map_err(from_shared_error) +} diff --git a/crates/raster-codecs/src/dds.rs b/crates/raster-codecs/src/dds.rs index 1249cb5b7..789028fb4 100644 --- a/crates/raster-codecs/src/dds.rs +++ b/crates/raster-codecs/src/dds.rs @@ -1,616 +1,64 @@ -//! DirectDraw Surface (DDS) textures, after Microsoft's public DDS documentation ("DDS", -//! "DDS_HEADER", "DDS_PIXELFORMAT", "DDS_HEADER_DXT10"). -//! -//! Reading: the top mip level of a 2D texture, either uncompressed (8 to 32 bits per pixel -//! described by channel masks, RGB or luminance) or block-compressed BC1/BC2/BC3 -//! (DXT1/DXT3/DXT5), with or without the DX10 header. Cubemaps, texture arrays and volume -//! textures are refused rather than flattened to one face or slice. -//! -//! Writing: a 2D texture, uncompressed (BGRA or BGRX, luminance with or without alpha) or -//! BC1/BC2/BC3, optionally with its full mip chain. The legacy header describes all of these, -//! so no DX10 header is written; formats only DXGI can name (BC4–BC7, sRGB) aren't written. +//! DDS compatibility facade; implementation and BC block codecs live in craft-image-codecs. +use crate::{CodecError, Image, Limits, SampleType, bridge}; +use craft_image_codecs::Format; -use std::borrow::Cow; - -use crate::dds_bc::{self, Block, Mask}; -use crate::{ChannelLayout, CodecError, Image, Limits, SampleType}; - -/// `DDS ` plus the 124-byte DDS_HEADER. -const HEADER: usize = 128; -/// DDS_HEADER_DXT10, present when the FourCC is `DX10`. -const DX10_HEADER: usize = 20; - -const DDSD_DEPTH: u32 = 0x80_0000; -const DDPF_ALPHAPIXELS: u32 = 0x1; -const DDPF_FOURCC: u32 = 0x4; -const DDPF_RGB: u32 = 0x40; -const DDPF_LUMINANCE: u32 = 0x2_0000; -const DDSCAPS2_CUBEMAP: u32 = 0x200; -const DDSCAPS2_CUBEMAP_FACES: u32 = 0xfc00; -const DDSCAPS2_VOLUME: u32 = 0x20_0000; -const DIMENSION_TEXTURE2D: u32 = 3; -const MISC_TEXTURECUBE: u32 = 0x4; - -fn bad(reason: impl std::fmt::Display) -> CodecError { - CodecError::malformed("DDS", reason) +pub fn looks_like_dds(bytes: &[u8]) -> bool { + craft_image_codecs::detect(bytes) == Some(Format::Dds) } -fn unsupported(reason: impl Into) -> CodecError { - CodecError::unsupported("DDS", reason) -} -fn le32(b: &[u8], at: usize) -> Result { - let bytes = b.get(at..at + 4).and_then(|s| <[u8; 4]>::try_from(s).ok()).ok_or_else(|| bad("truncated header"))?; - Ok(u32::from_le_bytes(bytes)) -} - -/// The `DDS ` magic. -pub fn looks_like_dds(b: &[u8]) -> bool { - b.starts_with(b"DDS ") -} - -/// Header-declared extra subresources cannot survive a single-image rewrite, even without presence flags. pub fn has_additional_images(bytes: &[u8]) -> Result { - let depth = le32(bytes, 24)?; - let mips = le32(bytes, 28)?; - let faces = (le32(bytes, 112)? & DDSCAPS2_CUBEMAP_FACES).count_ones(); - let dx10 = le32(bytes, 80)? & DDPF_FOURCC != 0 && bytes.get(84..88) == Some(b"DX10"); - let (cube, array) = if dx10 { (le32(bytes, 136)? & MISC_TEXTURECUBE != 0, le32(bytes, 140)?) } else { (false, 0) }; - Ok(depth > 1 || mips > 1 || faces > 1 || cube || array > 1) + craft_image_codecs::has_unretained_source_data(bytes).map_err(bridge::from_shared_error) +} +pub fn decode(bytes: &[u8], limits: &Limits) -> Result { + bridge::format(Format::Dds, bytes, limits) } -/// A FourCC as text when it is printable, else as the number legacy writers store there. -fn fourcc_name(fourcc: u32) -> String { - let bytes = fourcc.to_le_bytes(); - if bytes.iter().all(|c| c.is_ascii_graphic() || *c == b' ') { bytes.iter().map(|&c| char::from(c)).collect() } else { fourcc.to_string() } -} - -/// One channel of an uncompressed pixel: where it sits and its largest value. -#[derive(Clone, Copy)] -struct Field { - shift: u32, - max: u32, -} - -impl Field { - /// `None` for an empty mask; an error for one with gaps or wider than the pixel. - fn new(mask: u32, bits: u32) -> Result, CodecError> { - if mask == 0 { - return Ok(None); - } - let shift = mask.trailing_zeros(); - let max = mask >> shift; - if max & max.wrapping_add(1) != 0 || (bits < 32 && mask >> bits != 0) { - return Err(bad(format!("channel mask {mask:#x} is not a contiguous field of a {bits}-bit pixel"))); - } - Ok(Some(Field { shift, max })) - } - - fn get(self, pixel: u32) -> u8 { - let v = u64::from((pixel >> self.shift) & self.max); - let max = u64::from(self.max); - ((v * 255 + max / 2) / max) as u8 - } -} - -enum Encoding { - /// Uncompressed: bytes per pixel, then red (or luminance), green, blue and alpha. - Masks { - bytes: usize, - gray: bool, - fields: [Option; 4], - }, - Bc1, - Bc2, - Bc3, -} - -impl Encoding { - fn masks(bits: u32, masks: [u32; 4], gray: bool) -> Result { - if !matches!(bits, 8 | 16 | 24 | 32) { - return Err(bad(format!("{bits} bits per pixel is not 8, 16, 24 or 32"))); - } - let mut fields = [None; 4]; - for (field, mask) in fields.iter_mut().zip(masks) { - *field = Field::new(mask, bits)?; - } - let colour = if gray { fields[0].is_some() } else { fields[..3].iter().any(Option::is_some) }; - if !colour { - return Err(bad("the pixel format has no colour channel masks")); - } - Ok(Encoding::Masks { bytes: bits as usize / 8, gray, fields }) - } - - fn layout(&self) -> ChannelLayout { - match self { - Encoding::Masks { gray: true, fields, .. } if fields[3].is_some() => ChannelLayout::GrayA, - Encoding::Masks { gray: true, .. } => ChannelLayout::Gray, - Encoding::Masks { fields, .. } if fields[3].is_none() => ChannelLayout::Rgb, - _ => ChannelLayout::Rgba, - } - } - - /// Stored row stride and byte size of the top mip level (block rows for BC). - fn level_layout(&self, width: u32, height: u32, pitch: Option) -> Result<(usize, usize), CodecError> { - let overflow = || bad("pixel data size overflow"); - let (w, h) = (usize::try_from(width).map_err(|_| overflow())?, usize::try_from(height).map_err(|_| overflow())?); - let (row_bytes, rows) = match self { - Encoding::Masks { bytes, .. } => { - let packed = w.checked_mul(*bytes).ok_or_else(overflow)?; - let row_bytes = match pitch { - Some(pitch) => usize::try_from(pitch).map_err(|_| overflow())?, - None => packed, - }; - if row_bytes < packed { - return Err(bad(format!("row pitch {row_bytes} is smaller than the {packed}-byte pixel row"))); - } - (row_bytes, h) - } - Encoding::Bc1 | Encoding::Bc2 | Encoding::Bc3 => { - let block = if matches!(self, Encoding::Bc1) { 8 } else { 16 }; - (w.div_ceil(4).checked_mul(block).ok_or_else(overflow)?, h.div_ceil(4)) - } - }; - let size = row_bytes.checked_mul(rows).ok_or_else(overflow)?; - Ok((row_bytes, size)) - } -} - -/// The legacy pixel format: a FourCC, or channel masks. -fn legacy_encoding(b: &[u8]) -> Result { - let (flags, fourcc, bits) = (le32(b, 80)?, le32(b, 84)?, le32(b, 88)?); - let alpha = if flags & DDPF_ALPHAPIXELS != 0 { le32(b, 104)? } else { 0 }; - if flags & DDPF_FOURCC != 0 { - return match &fourcc.to_le_bytes() { - b"DXT1" => Ok(Encoding::Bc1), - b"DXT3" => Ok(Encoding::Bc2), - b"DXT5" => Ok(Encoding::Bc3), - b"DXT2" | b"DXT4" => Err(unsupported("premultiplied-alpha DXT2/DXT4 textures are not supported")), - _ => Err(unsupported(format!("compression `{}` is not supported (DXT1, DXT3 and DXT5 are)", fourcc_name(fourcc)))), - }; - } - if flags & DDPF_RGB != 0 { - return Encoding::masks(bits, [le32(b, 92)?, le32(b, 96)?, le32(b, 100)?, alpha], false); - } - if flags & DDPF_LUMINANCE != 0 { - return Encoding::masks(bits, [le32(b, 92)?, 0, 0, alpha], true); - } - Err(unsupported(format!("pixel format flags {flags:#x} are not RGB, luminance or a supported compression"))) -} - -/// The DX10 header's DXGI format, refusing anything but a single 2D texture. -fn dx10_encoding(b: &[u8]) -> Result { - let (dxgi, dimension, misc, array) = (le32(b, HEADER)?, le32(b, HEADER + 4)?, le32(b, HEADER + 8)?, le32(b, HEADER + 12)?); - if misc & MISC_TEXTURECUBE != 0 { - return Err(unsupported("cubemaps are not supported")); - } - if dimension != DIMENSION_TEXTURE2D { - return Err(unsupported(format!("only 2D textures are supported (resource dimension {dimension})"))); - } - if array > 1 { - return Err(unsupported(format!("texture arrays are not supported ({array} textures)"))); - } - const RGBA: [u32; 4] = [0xff, 0xff00, 0xff_0000, 0xff00_0000]; - const BGRA: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0xff00_0000]; - const BGRX: [u32; 4] = [0xff_0000, 0xff00, 0xff, 0]; - match dxgi { - 27..=29 => Encoding::masks(32, RGBA, false), - 87 | 90 | 91 => Encoding::masks(32, BGRA, false), - 88 | 92 | 93 => Encoding::masks(32, BGRX, false), - 70..=72 => Ok(Encoding::Bc1), - 73..=75 => Ok(Encoding::Bc2), - 76..=78 => Ok(Encoding::Bc3), - _ => Err(unsupported(format!("DXGI format {dxgi} is not supported (BC1, BC2, BC3 and 8-bit RGBA or BGRA are)"))), - } -} - -pub fn decode(b: &[u8], limits: &Limits) -> Result { - if !b.starts_with(b"DDS ") { - return Err(bad("missing the `DDS ` signature")); - } - if le32(b, 4)? != 124 { - return Err(bad("header size is not 124")); - } - let (flags, height, width, depth, caps2) = (le32(b, 8)?, le32(b, 12)?, le32(b, 16)?, le32(b, 24)?, le32(b, 112)?); - if caps2 & DDSCAPS2_CUBEMAP != 0 { - return Err(unsupported("cubemaps are not supported")); - } - if caps2 & DDSCAPS2_VOLUME != 0 || (flags & DDSD_DEPTH != 0 && depth > 1) { - return Err(unsupported("volume textures are not supported")); - } - let dx10 = le32(b, 80)? & DDPF_FOURCC != 0 && &le32(b, 84)?.to_le_bytes() == b"DX10"; - let (encoding, start) = if dx10 { (dx10_encoding(b)?, HEADER + DX10_HEADER) } else { (legacy_encoding(b)?, HEADER) }; - let layout = encoding.layout(); - limits.check(width, height, layout, SampleType::U8)?; - // The same header field is a total level size for BC, but a row stride when DDSD_PITCH is set. - let pitch = if flags & DDSD_PITCH != 0 { Some(le32(b, 20)?) } else { None }; - let (row_pitch, size) = encoding.level_layout(width, height, pitch)?; - let data = b.get(start..).and_then(|d| d.get(..size)).ok_or_else(|| bad(format!("truncated pixel data: {size} bytes needed")))?; - let (w, h) = (width as usize, height as usize); - let channels = layout.channels(); - let row_size = w.checked_mul(channels).ok_or_else(|| bad("pixel size overflow"))?; - let total = row_size.checked_mul(h).ok_or_else(|| bad("pixel size overflow"))?; - let mut pixels = vec![0u8; total]; - match encoding { - Encoding::Masks { bytes, gray, fields } => { - for (src_row, dst_row) in data.chunks_exact(row_pitch).zip(pixels.chunks_exact_mut(row_size)) { - // Stop at the output width, leaving any stored row padding unread. - for (src, dst) in src_row.chunks_exact(bytes).zip(dst_row.chunks_exact_mut(channels)) { - let pixel = src.iter().rev().fold(0u32, |v, &byte| v << 8 | u32::from(byte)); - let channel = |i: usize| fields[i].map_or(0, |f| f.get(pixel)); - let values = if gray { [channel(0), channel(3), 0, 0] } else { [channel(0), channel(1), channel(2), channel(3)] }; - dst.copy_from_slice(&values[..channels]); - } - } - } - Encoding::Bc1 | Encoding::Bc2 | Encoding::Bc3 => { - let block_size = if matches!(encoding, Encoding::Bc1) { 8 } else { 16 }; - let blocks_x = w.div_ceil(4); - for (i, block) in data.chunks_exact(block_size).enumerate() { - let texels = match encoding { - Encoding::Bc1 => bc1(block, true), - Encoding::Bc2 => with_alpha(bc1(block.get(8..).unwrap_or_default(), false), bc2_alpha(block)), - _ => with_alpha(bc1(block.get(8..).unwrap_or_default(), false), bc3_alpha(block)), - }; - let (bx, by) = ((i % blocks_x) * 4, (i / blocks_x) * 4); - for (t, texel) in texels.iter().enumerate() { - let (x, y) = (bx + t % 4, by + t / 4); - if x < w && y < h { - let at = (y * w + x) * 4; - if let Some(dst) = pixels.get_mut(at..at + 4) { - dst.copy_from_slice(texel); - } - } - } - } - } - } - Image::from_u8(width, height, layout, pixels) -} - -/// A BC1 colour block. BC2 and BC3 colour blocks always have four colours; only BC1's -/// `c0 <= c1` order selects three colours and transparent black. -fn bc1(block: &[u8], one_bit_alpha: bool) -> [[u8; 4]; 16] { - let byte = |i: usize| block.get(i).copied().unwrap_or(0); - let (c0, c1) = (u16::from_le_bytes([byte(0), byte(1)]), u16::from_le_bytes([byte(2), byte(3)])); - let palette = dds_bc::colour_palette(c0, c1, c0 > c1 || !one_bit_alpha); - let indices = u32::from_le_bytes([byte(4), byte(5), byte(6), byte(7)]); - std::array::from_fn(|t| palette[(indices >> (2 * t)) as usize & 3]) -} - -/// BC2: four explicit bits of alpha per texel. -fn bc2_alpha(block: &[u8]) -> [u8; 16] { - let bits = u64::from_le_bytes(std::array::from_fn(|i| block.get(i).copied().unwrap_or(0))); - std::array::from_fn(|t| ((bits >> (4 * t)) & 0xf) as u8 * 17) -} - -/// BC3: two alpha endpoints and a 3-bit index per texel into eight values, or into six plus -/// 0 and 255 when `a0 <= a1`. -fn bc3_alpha(block: &[u8]) -> [u8; 16] { - let byte = |i: usize| block.get(i).copied().unwrap_or(0); - let palette = dds_bc::alpha_palette(byte(0), byte(1)); - let bits = u64::from_le_bytes([byte(2), byte(3), byte(4), byte(5), byte(6), byte(7), 0, 0]); - std::array::from_fn(|t| palette[((bits >> (3 * t)) & 7) as usize]) -} - -fn with_alpha(mut texels: [[u8; 4]; 16], alpha: [u8; 16]) -> [[u8; 4]; 16] { - for (texel, a) in texels.iter_mut().zip(alpha) { - texel[3] = a; - } - texels -} - -const DDSD_CAPS: u32 = 0x1; -const DDSD_HEIGHT: u32 = 0x2; -const DDSD_WIDTH: u32 = 0x4; -const DDSD_PITCH: u32 = 0x8; -const DDSD_PIXELFORMAT: u32 = 0x1000; -const DDSD_MIPMAPCOUNT: u32 = 0x2_0000; -const DDSD_LINEARSIZE: u32 = 0x8_0000; -const DDSCAPS_COMPLEX: u32 = 0x8; -const DDSCAPS_TEXTURE: u32 = 0x1000; -const DDSCAPS_MIPMAP: u32 = 0x40_0000; - -fn encode_err(reason: impl std::fmt::Display) -> CodecError { - CodecError::encode("DDS", reason) -} - -/// How a written texture stores its pixels. -#[derive(Clone, Copy, PartialEq, Eq)] -enum Store { - /// 8-bit luminance. - Luminance, - /// 8-bit luminance, then 8-bit alpha. - LuminanceAlpha, - /// Blue, green, red and an unused byte (written as 255, so a reader that takes it for - /// alpha still sees an opaque texture). - Bgrx, - Bgra, - Bc1, - Bc2, - Bc3, -} - -impl Store { - /// The storage for an image of `layout`. - fn new(compression: DdsCompression, layout: ChannelLayout) -> Result { - Ok(match (compression, layout) { - (DdsCompression::None, ChannelLayout::Gray) => Store::Luminance, - (DdsCompression::None, ChannelLayout::GrayA) => Store::LuminanceAlpha, - (DdsCompression::None, ChannelLayout::Rgb) => Store::Bgrx, - (DdsCompression::None, ChannelLayout::Rgba) => Store::Bgra, - (DdsCompression::Bc1, ChannelLayout::Rgba) => Store::Bc1, - (DdsCompression::Bc2, ChannelLayout::Rgba) => Store::Bc2, - (DdsCompression::Bc3, ChannelLayout::Rgba) => Store::Bc3, - (_, layout) => return Err(encode_err(format!("{layout:?} pixels can't be written as `{}`", compression.name()))), - }) - } - - /// Bytes per pixel, or per 4×4 block for a block compression. - fn unit(self) -> usize { - match self { - Store::Luminance => 1, - Store::LuminanceAlpha => 2, - Store::Bgrx | Store::Bgra => 4, - Store::Bc1 => 8, - Store::Bc2 | Store::Bc3 => 16, - } - } - - fn is_block(self) -> bool { - matches!(self, Store::Bc1 | Store::Bc2 | Store::Bc3) - } - - /// Bytes of one row of pixels (or of 4×4 blocks) of a level `width` wide. - fn row_bytes(self, width: usize) -> Option { - if self.is_block() { width.div_ceil(4).checked_mul(self.unit()) } else { width.checked_mul(self.unit()) } - } - - fn level_bytes(self, width: usize, height: usize) -> Option { - let rows = if self.is_block() { height.div_ceil(4) } else { height }; - self.row_bytes(width)?.checked_mul(rows) - } - - /// DDS_PIXELFORMAT: flags, FourCC, bits per pixel and the red, green, blue and alpha masks. - fn pixel_format(self) -> (u32, [u8; 4], u32, [u32; 4]) { - match self { - Store::Luminance => (DDPF_LUMINANCE, [0; 4], 8, [0xff, 0, 0, 0]), - Store::LuminanceAlpha => (DDPF_LUMINANCE | DDPF_ALPHAPIXELS, [0; 4], 16, [0xff, 0, 0, 0xff00]), - Store::Bgrx => (DDPF_RGB, [0; 4], 32, [0xff_0000, 0xff00, 0xff, 0]), - Store::Bgra => (DDPF_RGB | DDPF_ALPHAPIXELS, [0; 4], 32, [0xff_0000, 0xff00, 0xff, 0xff00_0000]), - Store::Bc1 => (DDPF_FOURCC, *b"DXT1", 0, [0; 4]), - Store::Bc2 => (DDPF_FOURCC, *b"DXT3", 0, [0; 4]), - Store::Bc3 => (DDPF_FOURCC, *b"DXT5", 0, [0; 4]), - } - } -} - -/// Levels in a full mip chain: the larger side halves down to 1. -fn mip_levels(width: u32, height: u32) -> u32 { - 32 - width.max(height).max(1).leading_zeros() -} - -fn half((w, h): (usize, usize)) -> (usize, usize) { - ((w / 2).max(1), (h / 2).max(1)) -} - -/// How a DDS texture stores its pixels. #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub enum DdsCompression { - /// Uncompressed, 8 bits per channel: BGRA (BGRX without alpha), or luminance with or - /// without alpha for grayscale. Lossless. #[default] None, - /// BC1 (DXT1): 4 bits per pixel. Alpha is on or off: texels under half opacity become - /// transparent black. Bc1, - /// BC2 (DXT3): 8 bits per pixel, with 4 bits of explicit alpha per texel. Bc2, - /// BC3 (DXT5): 8 bits per pixel, with smooth interpolated alpha. Bc3, } - impl DdsCompression { - pub const ALL: [DdsCompression; 4] = [DdsCompression::None, DdsCompression::Bc1, DdsCompression::Bc2, DdsCompression::Bc3]; - - /// The name scripts and the CLI use: `none`, `bc1`, `bc2` or `bc3`. + pub const ALL: [Self; 4] = [Self::None, Self::Bc1, Self::Bc2, Self::Bc3]; pub fn name(self) -> &'static str { match self { - DdsCompression::None => "none", - DdsCompression::Bc1 => "bc1", - DdsCompression::Bc2 => "bc2", - DdsCompression::Bc3 => "bc3", + Self::None => "none", + Self::Bc1 => "bc1", + Self::Bc2 => "bc2", + Self::Bc3 => "bc3", } } - - /// [`Self::name`] back to a compression, also taking the DXT names (`dxt1`, `dxt3`, - /// `dxt5`), in any case. Anything else is `None`. pub fn from_name(name: &str) -> Option { match name.to_ascii_lowercase().as_str() { - "none" => Some(DdsCompression::None), - "bc1" | "dxt1" => Some(DdsCompression::Bc1), - "bc2" | "dxt3" => Some(DdsCompression::Bc2), - "bc3" | "dxt5" => Some(DdsCompression::Bc3), + "none" => Some(Self::None), + "bc1" | "dxt1" => Some(Self::Bc1), + "bc2" | "dxt3" => Some(Self::Bc2), + "bc3" | "dxt5" => Some(Self::Bc3), _ => None, } } - - /// A block compression (lossy), not uncompressed pixels. pub fn is_block(self) -> bool { - self != DdsCompression::None + self != Self::None } } - -/// What a DDS file is written with. #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] pub struct DdsOptions { pub compression: DdsCompression, - /// Write the full mip chain down to 1×1, each level a box filter of the one above. pub mipmaps: bool, } - -/// Writes `img` (8 bits per channel) as a DDS texture. Uncompressed stores gray, gray with -/// alpha, RGB and RGBA; the block compressions take RGBA only. -pub fn encode(img: &Image, opts: DdsOptions) -> Result, CodecError> { - if img.sample_type() != SampleType::U8 { - return Err(encode_err("DDS is written at 8 bits per channel")); +pub fn encode(image: &Image, options: DdsOptions) -> Result, CodecError> { + if image.sample_type() != SampleType::U8 { + return Err(CodecError::encode("DDS", "DDS is written at 8 bits per channel")); } - let pixels = img.data(); - let store = Store::new(opts.compression, img.layout())?; - let (width, height) = (img.width(), img.height()); - let levels = if opts.mipmaps { mip_levels(width, height) } else { 1 }; - let top = (width as usize, height as usize); - // Every level's size, checked before anything is allocated. - let mut sizes = Vec::new(); - let mut size = top; - for _ in 0..levels { - sizes.push(store.level_bytes(size.0, size.1).ok_or_else(|| encode_err("texture size overflow"))?); - size = half(size); - } - let total = sizes.iter().try_fold(HEADER, |total, &s| total.checked_add(s)).ok_or_else(|| encode_err("texture size overflow"))?; - let header = header(width, height, store, levels, sizes.first().copied().unwrap_or(0))?; - let mut out = crate::alloc_zeroed::(total)?; - out.get_mut(..HEADER).ok_or_else(|| encode_err("output buffer too small"))?.copy_from_slice(&header); - - let channels = img.layout().channels(); - let mut level = Cow::Borrowed(pixels); - let (mut size, mut at) = (top, HEADER); - for (i, &bytes) in sizes.iter().enumerate() { - let dst = out.get_mut(at..at + bytes).ok_or_else(|| encode_err("output buffer too small"))?; - write_level(store, &level, size, dst)?; - at += bytes; - if i + 1 < sizes.len() { - let next = half(size); - level = Cow::Owned(downsample(&level, size, next, channels)?); - size = next; - } - } - Ok(out) -} - -/// The `DDS ` signature and DDS_HEADER. `top` is the top level's size in bytes. -fn header(width: u32, height: u32, store: Store, levels: u32, top: usize) -> Result<[u8; HEADER], CodecError> { - let mut b = [0u8; HEADER]; - let mut put = |at: usize, v: u32| { - if let Some(d) = b.get_mut(at..at + 4) { - d.copy_from_slice(&v.to_le_bytes()); - } + let compression = match options.compression { + DdsCompression::None => craft_image_codecs::DdsCompression::None, + DdsCompression::Bc1 => craft_image_codecs::DdsCompression::Bc1, + DdsCompression::Bc2 => craft_image_codecs::DdsCompression::Bc2, + DdsCompression::Bc3 => craft_image_codecs::DdsCompression::Bc3, }; - // Uncompressed: the pitch of one row. Compressed: the whole top level (its "linear size"). - let (size_flag, pitch_or_size) = if store.is_block() { (DDSD_LINEARSIZE, Some(top)) } else { (DDSD_PITCH, store.row_bytes(width as usize)) }; - let pitch_or_size = pitch_or_size - .and_then(|v| u32::try_from(v).ok()) - .ok_or_else(|| encode_err(format!("a {width}x{height} level is too large for a DDS header")))?; - let mipmapped = levels > 1; - put(4, 124); - put(8, DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | size_flag | if mipmapped { DDSD_MIPMAPCOUNT } else { 0 }); - put(12, height); - put(16, width); - put(20, pitch_or_size); - put(28, levels); - let (flags, fourcc, bits, masks) = store.pixel_format(); - put(76, 32); - put(80, flags); - put(84, u32::from_le_bytes(fourcc)); - put(88, bits); - for (i, mask) in masks.into_iter().enumerate() { - put(92 + 4 * i, mask); - } - put(108, DDSCAPS_TEXTURE | if mipmapped { DDSCAPS_COMPLEX | DDSCAPS_MIPMAP } else { 0 }); - b[..4].copy_from_slice(b"DDS "); - Ok(b) -} - -/// Runs `f` on each `len`-byte row of `out` with its index, in parallel on native targets. -fn rows(out: &mut [u8], len: usize, f: impl Fn(usize, &mut [u8]) + Send + Sync) { - #[cfg(not(target_arch = "wasm32"))] - { - use rayon::prelude::*; - out.par_chunks_mut(len.max(1)).enumerate().for_each(|(i, row)| f(i, row)); - } - #[cfg(target_arch = "wasm32")] - for (i, row) in out.chunks_mut(len.max(1)).enumerate() { - f(i, row); - } -} - -/// Writes one level of `width` × `height` pixels (in the image's layout) into `dst`. -fn write_level(store: Store, pixels: &[u8], (width, height): (usize, usize), dst: &mut [u8]) -> Result<(), CodecError> { - let row_bytes = store.row_bytes(width).ok_or_else(|| encode_err("texture size overflow"))?; - match store { - Store::Luminance | Store::LuminanceAlpha => { - // The image's gray (and alpha) samples, in the same order. - let src = pixels.get(..dst.len()).ok_or_else(|| encode_err("the level is smaller than its size"))?; - dst.copy_from_slice(src); - } - Store::Bgrx | Store::Bgra => { - let channels = if store == Store::Bgra { 4 } else { 3 }; - rows(dst, row_bytes, |y, row| { - let src = pixels.get(y * width * channels..).unwrap_or_default(); - for (d, s) in row.as_chunks_mut::<4>().0.iter_mut().zip(src.chunks_exact(channels)) { - let byte = |i: usize| s.get(i).copied().unwrap_or(255); - *d = [byte(2), byte(1), byte(0), byte(3)]; - } - }); - } - Store::Bc1 | Store::Bc2 | Store::Bc3 => { - let (texels, _) = pixels.as_chunks::<4>(); - rows(dst, row_bytes, |by, row| { - for (bx, d) in row.chunks_exact_mut(store.unit()).enumerate() { - let (block, inside) = gather(texels, (width, height), bx, by); - let encoded: &[u8] = match store { - Store::Bc1 => &dds_bc::encode_bc1(&block, inside), - Store::Bc2 => &dds_bc::encode_bc2(&block, inside), - _ => &dds_bc::encode_bc3(&block, inside), - }; - for (d, s) in d.iter_mut().zip(encoded) { - *d = *s; - } - } - }); - } - } - Ok(()) -} - -/// Block (`bx`, `by`)'s texels, and which of them lie inside the image. -fn gather(texels: &[[u8; 4]], (width, height): (usize, usize), bx: usize, by: usize) -> (Block, Mask) { - let mut block = [[0u8; 4]; 16]; - let mut inside: Mask = 0; - for (t, texel) in block.iter_mut().enumerate() { - let (x, y) = (bx * 4 + t % 4, by * 4 + t / 4); - if x < width - && y < height - && let Some(p) = texels.get(y * width + x) - { - *texel = *p; - inside |= 1 << t; - } - } - (block, inside) -} - -/// The next mip level: each pixel the average of the 2×2 pixels it covers, or of 2×3, 3×2 or -/// 3×3 along the last column and row of an odd-sized level, so no pixel is dropped. -fn downsample(src: &[u8], (w, h): (usize, usize), (nw, nh): (usize, usize), channels: usize) -> Result, CodecError> { - let len = nw.checked_mul(nh).and_then(|n| n.checked_mul(channels)).ok_or_else(|| encode_err("mip level size overflow"))?; - let mut dst = crate::alloc_zeroed::(len)?; - let span = |i: usize, n: usize, size: usize| 2 * i..=if i + 1 == n { size.saturating_sub(1) } else { 2 * i + 1 }; - rows(&mut dst, nw * channels, |y, row| { - let ys = span(y, nh, h); - for (x, px) in row.chunks_exact_mut(channels.max(1)).enumerate() { - let xs = span(x, nw, w); - for (c, v) in px.iter_mut().enumerate() { - let (mut sum, mut n) = (0u32, 0u32); - for sy in ys.clone() { - for sx in xs.clone() { - if let Some(&s) = src.get((sy * w + sx) * channels + c) { - sum += u32::from(s); - n += 1; - } - } - } - *v = ((sum + n / 2) / n.max(1)) as u8; - } - } - }); - Ok(dst) + let opts = + craft_image_codecs::EncodeOptions { dds: craft_image_codecs::DdsOptions { compression, mipmaps: options.mipmaps }, ..Default::default() }; + bridge::encode(image, Format::Dds, &opts) } diff --git a/crates/raster-codecs/src/dds_bc.rs b/crates/raster-codecs/src/dds_bc.rs deleted file mode 100644 index df60e462c..000000000 --- a/crates/raster-codecs/src/dds_bc.rs +++ /dev/null @@ -1,369 +0,0 @@ -//! BC1, BC2 and BC3 (DXT1, DXT3, DXT5) blocks, after Microsoft's public block compression -//! documentation ("Block Compression (Direct3D 10)" and "Texture Block Compression in Direct3D -//! 11"): the palettes the DDS reader decodes with, and the block encoder the DDS writer uses. -//! -//! The encoder fits a block's colours with two RGB565 endpoints along their principal axis, -//! refines them by least squares, and scores every candidate against the exact palette the -//! reader rebuilds, so the indices it picks are the best ones for what a decoder shows. - -/// The 16 texels of a 4×4 block, row by row, as RGBA. -pub(crate) type Block = [[u8; 4]; 16]; - -/// Bit `t` set for each texel `t` of a block that counts: edge blocks of a texture whose size is -/// not a multiple of four have texels outside the image. -pub(crate) type Mask = u16; - -pub(crate) fn rgb565(c: u16) -> [u8; 3] { - let scale = |v: u16, max: u16| ((u32::from(v) * 255 + u32::from(max) / 2) / u32::from(max)) as u8; - [scale(c >> 11, 31), scale((c >> 5) & 63, 63), scale(c & 31, 31)] -} - -/// The colours a colour block's indices select. Four-colour mode (BC1 with `c0 > c1`, and every -/// BC2 and BC3 block) adds two colours at thirds; three-colour mode adds the midpoint and -/// transparent black. -pub(crate) fn colour_palette(c0: u16, c1: u16, four: bool) -> [[u8; 4]; 4] { - let (a, b) = (rgb565(c0), rgb565(c1)); - let mix = |wa: u32, wb: u32| { - let d = wa + wb; - let at = |i: usize| ((wa * u32::from(a[i]) + wb * u32::from(b[i]) + d / 2) / d) as u8; - [at(0), at(1), at(2), 255] - }; - if four { - [[a[0], a[1], a[2], 255], [b[0], b[1], b[2], 255], mix(2, 1), mix(1, 2)] - } else { - [[a[0], a[1], a[2], 255], [b[0], b[1], b[2], 255], mix(1, 1), [0; 4]] - } -} - -/// A BC3 alpha block's eight values: six interpolated at sevenths when `a0 > a1`, else four -/// interpolated at fifths followed by 0 and 255. -pub(crate) fn alpha_palette(a0: u8, a1: u8) -> [u8; 8] { - let (a0, a1) = (u32::from(a0), u32::from(a1)); - let mut palette = [a0, a1, 0, 0, 0, 0, 0, 255]; - if a0 > a1 { - for (k, v) in palette.iter_mut().enumerate().skip(2) { - let k = k as u32; - *v = ((8 - k) * a0 + (k - 1) * a1 + 3) / 7; - } - } else { - for (k, v) in palette.iter_mut().enumerate().take(6).skip(2) { - let k = k as u32; - *v = ((6 - k) * a0 + (k - 1) * a1 + 2) / 5; - } - } - palette.map(|v| v as u8) -} - -/// A BC1 block. Texels under half opacity become BC1's transparent black, which needs the -/// three-colour mode; an opaque block takes whichever mode fits its colours better. -pub(crate) fn encode_bc1(block: &Block, inside: Mask) -> [u8; 8] { - let transparent = select(block, inside, |t| t[3] < 128); - colour_block(block, inside & !transparent, transparent, true) -} - -/// A BC2 block: four bits of alpha per texel, then a four-colour block. -pub(crate) fn encode_bc2(block: &Block, inside: Mask) -> [u8; 16] { - let bits = block.iter().enumerate().fold(0u64, |bits, (t, texel)| bits | ((u64::from(texel[3]) * 15 + 127) / 255) << (4 * t)); - join(bits.to_le_bytes(), colour_block(block, inside, 0, false)) -} - -/// A BC3 block: an interpolated alpha block, then a four-colour block. -pub(crate) fn encode_bc3(block: &Block, inside: Mask) -> [u8; 16] { - join(alpha_block(block, inside), colour_block(block, inside, 0, false)) -} - -fn join(a: [u8; 8], b: [u8; 8]) -> [u8; 16] { - std::array::from_fn(|i| if i < 8 { a.get(i) } else { b.get(i - 8) }.copied().unwrap_or(0)) -} - -/// The texels of `inside` for which `f` holds. -fn select(block: &Block, inside: Mask, f: impl Fn(&[u8; 4]) -> bool) -> Mask { - block.iter().enumerate().filter(|(t, texel)| inside >> t & 1 != 0 && f(texel)).fold(0, |m, (t, _)| m | 1 << t) -} - -fn rgb_of(texel: &[u8; 4]) -> [f32; 3] { - [f32::from(texel[0]), f32::from(texel[1]), f32::from(texel[2])] -} - -/// RGB565 of a colour, rounding each channel to the nearest level. -fn to565(c: [f32; 3]) -> u16 { - let q = |v: f32, max: f32| (v.clamp(0.0, 255.0) * max / 255.0).round() as u16; - q(c[0], 31.0) << 11 | q(c[1], 63.0) << 5 | q(c[2], 31.0) -} - -fn distance(a: &[u8; 4], b: &[u8; 4]) -> u32 { - (0..3).map(|i| u32::from(a[i].abs_diff(b[i])).pow(2)).sum() -} - -/// A colour block (endpoints, then 2-bit indices) for the `opaque` texels' colours, with the -/// `transparent` ones on BC1's transparent index. `bc1` allows the three-colour mode; BC2 and -/// BC3 always decode four colours. -fn colour_block(block: &Block, opaque: Mask, transparent: Mask, bc1: bool) -> [u8; 8] { - let colours: Vec<[f32; 3]> = block.iter().enumerate().filter(|(t, _)| opaque >> t & 1 != 0).map(|(_, texel)| rgb_of(texel)).collect(); - if colours.is_empty() { - // Nothing visible: every texel on the transparent index (or index 0 of black). - let indices = if transparent != 0 { u32::MAX } else { 0 }; - return pack(0, 0, indices); - } - let (lo, hi) = principal_endpoints(&colours); - let mut candidates = vec![(to565(lo), to565(hi))]; - let modes: &[bool] = if transparent != 0 { - &[false] - } else if bc1 { - &[true, false] - } else { - &[true] - }; - let mut best: Option<(u32, [u8; 8])> = None; - // Each refinement starts from the best block so far: its indices give the least-squares - // endpoints, which become one more candidate. - for round in 0..3 { - for &(e0, e1) in &candidates { - for &four in modes { - let (bytes, error) = fit(block, opaque, transparent, e0, e1, four); - if best.is_none_or(|(e, _)| error < e) { - best = Some((error, bytes)); - } - } - } - let Some((error, bytes)) = best else { break }; - if error == 0 || round == 2 { - break; - } - candidates = least_squares(block, opaque, &bytes).into_iter().collect(); - if candidates.is_empty() { - break; - } - } - best.map_or([0; 8], |(_, bytes)| bytes) -} - -/// Orders endpoints `e0`, `e1` for the mode (`c0 > c1` for four colours, `c0 <= c1` for three) -/// and picks each texel's nearest palette colour. Returns the block and its squared error. -fn fit(block: &Block, opaque: Mask, transparent: Mask, e0: u16, e1: u16, four: bool) -> ([u8; 8], u32) { - let (c0, c1) = if four == (e0 >= e1) { (e0, e1) } else { (e1, e0) }; - // Equal endpoints can't be in four-colour order; the palette is then one colour either way. - let palette = colour_palette(c0, c1, four && c0 > c1); - let choices = if four && c0 > c1 { 4 } else { 3 }; - let mut indices = 0u32; - let mut error = 0u32; - for (t, texel) in block.iter().enumerate() { - let index = if transparent >> t & 1 != 0 { - 3 - } else if opaque >> t & 1 != 0 { - let (i, d) = palette.iter().take(choices).enumerate().map(|(i, p)| (i, distance(texel, p))).min_by_key(|&(_, d)| d).unwrap_or((0, 0)); - error += d; - i as u32 - } else { - 0 - }; - indices |= index << (2 * t); - } - (pack(c0, c1, indices), error) -} - -fn pack(c0: u16, c1: u16, indices: u32) -> [u8; 8] { - let (c0, c1, i) = (c0.to_le_bytes(), c1.to_le_bytes(), indices.to_le_bytes()); - [c0[0], c0[1], c1[0], c1[1], i[0], i[1], i[2], i[3]] -} - -/// The ends of the colours' spread along their principal axis (the covariance's dominant -/// eigenvector, by power iteration), clamped to the RGB cube. -fn principal_endpoints(colours: &[[f32; 3]]) -> ([f32; 3], [f32; 3]) { - let n = colours.len().max(1) as f32; - let mean = [0, 1, 2].map(|i| colours.iter().map(|c| c[i]).sum::() / n); - let mut cov = [[0f32; 3]; 3]; - for c in colours { - let d = [c[0] - mean[0], c[1] - mean[1], c[2] - mean[2]]; - for (i, row) in cov.iter_mut().enumerate() { - for (j, v) in row.iter_mut().enumerate() { - *v += d[i] * d[j]; - } - } - } - let times = |a: [f32; 3]| [0, 1, 2].map(|i| cov[i][0] * a[0] + cov[i][1] * a[1] + cov[i][2] * a[2]); - let iterate = |start: usize| { - let mut axis = [0f32; 3]; - axis[start] = 1.0; - for _ in 0..8 { - let next = times(axis); - let len = next.iter().map(|v| v * v).sum::().sqrt(); - if !len.is_normal() { - break; - } - axis = next.map(|v| v / len); - } - axis - }; - // From each channel's axis, keeping the one the colours spread along most: a channel that - // varies on its own is already an eigenvector, so a single start there would never leave it - // even when the others vary more together. - let spread = |a: [f32; 3]| times(a).iter().zip(a).map(|(x, y)| x * y).sum::(); - let axis = [0, 1, 2].map(iterate).into_iter().max_by(|&a, &b| spread(a).total_cmp(&spread(b))).unwrap_or([1.0, 0.0, 0.0]); - let along = |c: &[f32; 3]| (c[0] - mean[0]) * axis[0] + (c[1] - mean[1]) * axis[1] + (c[2] - mean[2]) * axis[2]; - let (lo, hi) = colours.iter().map(along).fold((f32::MAX, f32::MIN), |(lo, hi), t| (lo.min(t), hi.max(t))); - let at = |t: f32| [0, 1, 2].map(|i| (mean[i] + t * axis[i]).clamp(0.0, 255.0)); - if lo > hi { (mean, mean) } else { (at(lo), at(hi)) } -} - -/// The endpoints that minimise the squared error for the indices `bytes` already chose: each -/// texel's index fixes its weights between the endpoints, giving 2×2 normal equations per -/// channel. `None` when the indices don't constrain both endpoints. -fn least_squares(block: &Block, opaque: Mask, bytes: &[u8; 8]) -> Option<(u16, u16)> { - let (c0, c1) = (u16::from_le_bytes([bytes[0], bytes[1]]), u16::from_le_bytes([bytes[2], bytes[3]])); - let indices = u32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]); - let four = c0 > c1; - // How much of c0 each index holds. - let weight = |i: u32| match (four, i) { - (_, 0) => Some(1.0f32), - (_, 1) => Some(0.0), - (true, 2) => Some(2.0 / 3.0), - (true, _) => Some(1.0 / 3.0), - (false, 2) => Some(0.5), - (false, _) => None, - }; - let (mut aa, mut ab, mut bb) = (0f32, 0f32, 0f32); - let (mut ax, mut bx) = ([0f32; 3], [0f32; 3]); - for (t, texel) in block.iter().enumerate() { - if opaque >> t & 1 == 0 { - continue; - } - let Some(a) = weight(indices >> (2 * t) & 3) else { continue }; - let b = 1.0 - a; - let c = rgb_of(texel); - aa += a * a; - ab += a * b; - bb += b * b; - for ((x0, x1), v) in ax.iter_mut().zip(bx.iter_mut()).zip(c) { - *x0 += a * v; - *x1 += b * v; - } - } - let det = aa * bb - ab * ab; - if det.abs() < 1e-3 { - return None; - } - let e0 = [0, 1, 2].map(|i| (ax[i] * bb - bx[i] * ab) / det); - let e1 = [0, 1, 2].map(|i| (bx[i] * aa - ax[i] * ab) / det); - Some((to565(e0), to565(e1))) -} - -/// A BC3 alpha block: whichever of the two modes (eight values between the extremes, or six -/// between the extremes other than 0 and 255, plus exact 0 and 255) fits better. -fn alpha_block(block: &Block, inside: Mask) -> [u8; 8] { - let alphas = || block.iter().enumerate().filter(move |(t, _)| inside >> t & 1 != 0).map(|(_, texel)| texel[3]); - let range = - |values: &mut dyn Iterator| values.fold(None, |r: Option<(u8, u8)>, a| Some(r.map_or((a, a), |(lo, hi)| (lo.min(a), hi.max(a))))); - let (lo, hi) = range(&mut alphas()).unwrap_or((0, 0)); - // Eight values need a0 > a1; equal ends fall to the six-value mode, which starts with a0 too. - let eight = alpha_fit(block, inside, hi, lo); - let (mid_lo, mid_hi) = range(&mut alphas().filter(|a| !matches!(a, 0 | 255))).unwrap_or((0, 0)); - let six = alpha_fit(block, inside, mid_lo, mid_hi); - if six.1 < eight.1 { six.0 } else { eight.0 } -} - -fn alpha_fit(block: &Block, inside: Mask, a0: u8, a1: u8) -> ([u8; 8], u32) { - let palette = alpha_palette(a0, a1); - let mut bits = 0u64; - let mut error = 0u32; - for (t, texel) in block.iter().enumerate() { - if inside >> t & 1 == 0 { - continue; - } - let (i, d) = palette.iter().enumerate().map(|(i, &p)| (i, u32::from(p.abs_diff(texel[3])).pow(2))).min_by_key(|&(_, d)| d).unwrap_or((0, 0)); - error += d; - bits |= (i as u64) << (3 * t); - } - let b = bits.to_le_bytes(); - ([a0, a1, b[0], b[1], b[2], b[3], b[4], b[5]], error) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn decode_colour(bytes: &[u8; 8], bc1: bool) -> Block { - let (c0, c1) = (u16::from_le_bytes([bytes[0], bytes[1]]), u16::from_le_bytes([bytes[2], bytes[3]])); - let palette = colour_palette(c0, c1, c0 > c1 || !bc1); - let indices = u32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]); - std::array::from_fn(|t| palette[(indices >> (2 * t)) as usize & 3]) - } - - #[test] - fn solid_blocks_land_on_the_nearest_565_colour() { - for colour in [[0, 0, 0, 255], [255, 255, 255, 255], [12, 200, 77, 255]] { - let block = [colour; 16]; - let out = decode_colour(&encode_bc1(&block, u16::MAX), true); - for texel in out { - assert!(texel.iter().zip(colour).all(|(a, b)| a.abs_diff(b) <= 4), "{texel:?} for {colour:?}"); - } - } - } - - #[test] - fn two_colour_blocks_are_exact_when_the_colours_are_565() { - let (a, b) = ([255, 0, 0, 255], [0, 0, 255, 255]); - let block: Block = std::array::from_fn(|t| if t % 3 == 0 { a } else { b }); - for bc1 in [true, false] { - let bytes = if bc1 { encode_bc1(&block, u16::MAX) } else { colour_block(&block, u16::MAX, 0, false) }; - assert_eq!(decode_colour(&bytes, bc1), block); - } - } - - #[test] - fn bc1_punches_through_texels_under_half_alpha() { - let block: Block = std::array::from_fn(|t| if t < 8 { [200, 100, 50, 255] } else { [9, 9, 9, 127] }); - let bytes = encode_bc1(&block, u16::MAX); - let (c0, c1) = (u16::from_le_bytes([bytes[0], bytes[1]]), u16::from_le_bytes([bytes[2], bytes[3]])); - assert!(c0 <= c1, "three-colour mode"); - let out = decode_colour(&bytes, true); - assert!(out[..8].iter().all(|t| t[3] == 255) && out[8..].iter().all(|t| *t == [0; 4]), "{out:?}"); - } - - #[test] - fn four_colour_blocks_keep_c0_above_c1() { - // A ramp needs all four colours; BC2 and BC3 blocks must not rely on the order, but - // older decoders read c0 <= c1 as three colours, so the encoder never writes that. - let block: Block = std::array::from_fn(|t| [(t * 16) as u8, 0, 0, 255]); - let bytes = colour_block(&block, u16::MAX, 0, false); - assert!(u16::from_le_bytes([bytes[0], bytes[1]]) > u16::from_le_bytes([bytes[2], bytes[3]])); - } - - #[test] - fn alpha_blocks_pick_the_mode_that_keeps_0_and_255() { - // 0, 255 and a cluster in between: the six-value mode stores 0 and 255 exactly. - let block: Block = std::array::from_fn(|t| [0, 0, 0, [0, 255, 100, 110][t % 4]]); - let bytes = alpha_block(&block, u16::MAX); - assert!(bytes[0] <= bytes[1], "six-value mode"); - let palette = alpha_palette(bytes[0], bytes[1]); - let bits = u64::from_le_bytes([bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], 0, 0]); - for (t, texel) in block.iter().enumerate() { - let got = palette[(bits >> (3 * t)) as usize & 7]; - assert!(got.abs_diff(texel[3]) <= 2, "texel {t}: {got} for {}", texel[3]); - } - } - - #[test] - fn the_principal_axis_is_found_when_one_channel_varies_on_its_own() { - // Red alternates on its own (variance 64); green and blue alternate together (variance 49 - // each, 98 along their shared axis), uncorrelated with red. Starting on red alone would - // keep red's axis and flatten green and blue; the block must do better than its bounding box. - let block: Block = std::array::from_fn(|t| { - let gb = if (t / 2) % 2 == 0 { 121 } else { 135 }; - [if t % 2 == 0 { 120 } else { 136 }, gb, gb, 255] - }); - let error = |bytes: &[u8; 8]| decode_colour(bytes, false).iter().zip(&block).map(|(a, b)| distance(a, b)).sum::(); - let (_, bounding_box) = fit(&block, u16::MAX, 0, to565([120.0, 121.0, 121.0]), to565([136.0, 135.0, 135.0]), true); - let ours = error(&colour_block(&block, u16::MAX, 0, false)); - assert!(ours < bounding_box, "{ours} vs the bounding box's {bounding_box}"); - } - - #[test] - fn texels_outside_the_image_are_ignored() { - // Only the top-left texel is inside: its colour alone decides the endpoints. - let mut block: Block = [[0, 255, 0, 255]; 16]; - block[0] = [255, 0, 255, 255]; - let out = decode_colour(&encode_bc1(&block, 1), true); - assert_eq!(out[0], [255, 0, 255, 255]); - } -} diff --git a/crates/raster-codecs/src/dicom.rs b/crates/raster-codecs/src/dicom.rs index 31f99839f..ee6c73208 100644 --- a/crates/raster-codecs/src/dicom.rs +++ b/crates/raster-codecs/src/dicom.rs @@ -1,526 +1,10 @@ -//! DICOM (medical imaging) reader, uncompressed transfer syntaxes only. -//! -//! Supports what a viewer needs from a single-frame image: MONOCHROME1/2 (gray) and RGB or -//! YBR_FULL, 8- and 16-bit samples, interleaved or planar, both byte orders and explicit or -//! implicit VR. Undefined-length sequences outside the pixel data are skipped (clinical files -//! contain them); compressed transfer syntaxes, encapsulated pixel data and other photometric -//! interpretations are refused with a clear error. Read-only in this crate. +//! DICOM compatibility facade; implementation and detection live in craft-image-codecs. +use crate::{CodecError, Image, Limits, bridge}; +use craft_image_codecs::Format; -use std::collections::HashMap; - -use crate::{ChannelLayout, CodecError, Image, Limits, SampleType}; - -const F: &str = "DICOM"; -const PREAMBLE: usize = 132; // 128 zero bytes + "DICM" -const UNDEFINED: u32 = 0xFFFF_FFFF; - -fn bad(msg: impl std::fmt::Display) -> CodecError { - CodecError::malformed(F, msg) +pub fn is_dicom(bytes: &[u8]) -> bool { + craft_image_codecs::detect(bytes) == Some(Format::Dicom) } - -/// A DICOM file begins with a 128-byte preamble and the `DICM` magic. -pub fn is_dicom(b: &[u8]) -> bool { - b.get(128..132) == Some(b"DICM") -} - -#[derive(Clone, Copy)] -struct Endian { - big: bool, -} - -/// The transfer syntax: byte order and whether value representations are explicit. -#[derive(Clone, Copy)] -struct Syntax { - endian: Endian, - explicit: bool, -} - -/// The value representations whose length field is 2 reserved bytes + `u32` in explicit VR. -fn long_vr(vr: &[u8]) -> bool { - matches!(vr, b"OB" | b"OW" | b"OF" | b"SQ" | b"UT" | b"UN" | b"OD" | b"OL" | b"OV" | b"UC" | b"UR") -} - -/// A cursor over the byte stream. -struct Cur<'a> { - b: &'a [u8], - pos: usize, - big: bool, -} - -impl<'a> Cur<'a> { - fn take(&mut self, n: usize) -> Option<&'a [u8]> { - let s = self.b.get(self.pos..self.pos.checked_add(n)?)?; - self.pos += n; - Some(s) - } - fn u16(&mut self) -> Option { - let c = self.take(2)?; - Some(if self.big { u16::from_be_bytes([c[0], c[1]]) } else { u16::from_le_bytes([c[0], c[1]]) }) - } - fn u32(&mut self) -> Option { - let c = self.take(4)?; - Some(if self.big { u32::from_be_bytes([c[0], c[1], c[2], c[3]]) } else { u32::from_le_bytes([c[0], c[1], c[2], c[3]]) }) - } - /// Skip `len` bytes, refusing to run past the buffer. - fn skip(&mut self, len: usize) -> Result<(), CodecError> { - self.pos = self.pos.checked_add(len).filter(|p| *p <= self.b.len()).ok_or_else(|| bad("a value runs past the end of the file"))?; - Ok(()) - } -} - -/// Read one element's tag and value length, leaving the cursor at the value. Item and delimiter -/// tags (group `FFFE`) carry a `u32` length with no VR even under explicit VR. -fn read_header(c: &mut Cur, syn: &Syntax) -> Result<(u16, u16, [u8; 2], u32), CodecError> { - let group = c.u16().ok_or_else(|| bad("truncated element tag"))?; - let elem = c.u16().ok_or_else(|| bad("truncated element tag"))?; - let (vr, len) = if group == 0xFFFE { - ([0, 0], c.u32().ok_or_else(|| bad("truncated item length"))?) - } else if syn.explicit { - let vr = c.take(2).ok_or_else(|| bad("truncated VR"))?; - let v = [vr[0], vr[1]]; - let len = if long_vr(&v) { - c.take(2).ok_or_else(|| bad("truncated VR"))?; // reserved - c.u32().ok_or_else(|| bad("truncated length"))? - } else { - u32::from(c.u16().ok_or_else(|| bad("truncated length"))?) - }; - (v, len) - } else { - ([0, 0], c.u32().ok_or_else(|| bad("truncated length"))?) - }; - Ok((group, elem, vr, len)) -} - -/// Skip an undefined-length sequence, ending just after its `FFFE,E0DD` delimiter. Nesting is -/// tracked through undefined-length items and nested sequences; everything else is skipped by -/// its length. Returns the position after the delimiter. -fn skip_undefined(c: &mut Cur, syn: &Syntax) -> Result<(), CodecError> { - let mut depth = 1u32; - while depth > 0 { - let (group, elem, _, len) = read_header(c, syn)?; - // Item (E00D) and sequence (E0DD) delimiters close one undefined length; they carry no - // content of their own. - if group == 0xFFFE && matches!(elem, 0xE00D | 0xE0DD) { - depth -= 1; - continue; - } - if len == UNDEFINED { - depth += 1; - } else { - c.skip(len as usize)?; - } - } - Ok(()) -} - -/// Walk the elements from `start`, calling `f` with each `(group, element, value)`. An -/// undefined-length sequence outside the pixel data is skipped; encapsulated (undefined-length) -/// pixel data is refused. Returns the number of bytes walked. -fn elements(b: &[u8], start: usize, syn: &Syntax, mut f: impl FnMut(u16, u16, &Elem) -> Result<(), CodecError>) -> Result { - let mut c = Cur { b, pos: start, big: syn.endian.big }; - loop { - if c.pos >= b.len() { - return Ok(c.pos - start); - } - let (group, elem, vr, len) = read_header(&mut c, syn)?; - if len == UNDEFINED { - if (group, elem) == (0x7FE0, 0x0010) { - return Err(CodecError::unsupported(F, "encapsulated (compressed) pixel data")); - } - skip_undefined(&mut c, syn)?; - continue; - } - let len = len as usize; - let start = c.pos; - if b.len() < start.saturating_add(len) { - return Err(bad("an element value runs past the end of the file")); - } - f(group, elem, &Elem { vr, start, len })?; - c.pos = start + len; - } -} - -/// A parsed element: its VR and the byte range of its value. -struct Elem { - vr: [u8; 2], - start: usize, - len: usize, -} - -fn u16_val(b: &[u8], e: &Elem, big: bool) -> Option { - let c = b.get(e.start..e.start.checked_add(2)?)?; - Some(if big { u16::from_be_bytes([c[0], c[1]]) } else { u16::from_le_bytes([c[0], c[1]]) }) -} - -/// The transfer syntax (byte order and explicit/implicit VR) and the data-set start. The file -/// meta group is always explicit VR little-endian; the data set follows its `(0002,0010)` -/// TransferSyntaxUID. -fn transfer_syntax(b: &[u8]) -> Result<(Syntax, usize), CodecError> { - let meta = Syntax { endian: Endian { big: false }, explicit: true }; - let mut ts: Option = None; - let mut data_start = b.len(); - let mut c = Cur { b, pos: PREAMBLE, big: false }; - while c.pos + 8 <= b.len() { - let save = c.pos; - let (group, elem, _, len) = read_header(&mut c, &meta)?; - if group != 0x0002 { - // A non-meta group begins the data set. - data_start = save; - break; - } - if len == UNDEFINED { - return Err(CodecError::unsupported(F, "undefined-length meta element")); - } - let start = c.pos; - if b.len() < start.saturating_add(len as usize) { - return Err(bad("a meta element runs past the end of the file")); - } - if elem == 0x0010 { - ts = Some(String::from_utf8_lossy(&b[start..start + len as usize]).trim_end_matches(['\0', ' ']).to_string()); - } - c.pos = start + len as usize; - } - let syn = match ts.as_deref() { - Some("1.2.840.10008.1.2") => Syntax { endian: Endian { big: false }, explicit: false }, - Some("1.2.840.10008.1.2.1") => Syntax { endian: Endian { big: false }, explicit: true }, - Some("1.2.840.10008.1.2.2") => Syntax { endian: Endian { big: true }, explicit: true }, - Some(other) => return Err(CodecError::unsupported(F, format!("transfer syntax {other} (only uncompressed is read)"))), - // No meta: the historical default is implicit VR little-endian. - None => Syntax { endian: Endian { big: false }, explicit: false }, - }; - Ok((syn, data_start)) -} - -pub fn decode(b: &[u8], limits: &Limits) -> Result { - if !is_dicom(b) { - return Err(bad("not a DICOM file (no DICM magic)")); - } - let (syn, start) = transfer_syntax(b)?; - let mut tags: HashMap<(u16, u16), Elem> = HashMap::new(); - elements(b, start, &syn, |g, e, el| { - // Later duplicates must not silently override the first (DICOM forbids duplicates). - tags.entry((g, e)).or_insert_with(|| Elem { vr: el.vr, start: el.start, len: el.len }); - Ok(()) - })?; - let big = syn.endian.big; - let get_u16 = |tag: (u16, u16)| tags.get(&tag).and_then(|e| u16_val(b, e, big)); - let rows = u32::from(get_u16((0x0028, 0x0010)).ok_or_else(|| bad("missing Rows (0028,0010)"))?); - let cols = u32::from(get_u16((0x0028, 0x0011)).ok_or_else(|| bad("missing Columns (0028,0011)"))?); - let samples = u32::from(get_u16((0x0028, 0x0002)).unwrap_or(1)); - let bits = get_u16((0x0028, 0x0100)).ok_or_else(|| bad("missing BitsAllocated (0028,0100)"))?; - let bits_stored = get_u16((0x0028, 0x0101)).unwrap_or(bits); - let high_bit = get_u16((0x0028, 0x0102)).unwrap_or(bits_stored.saturating_sub(1)); - if u32::from(high_bit) >= u32::from(bits) { - return Err(bad("HighBit is outside the allocated bits")); - } - let signed = get_u16((0x0028, 0x0103)).unwrap_or(0) == 1; - let planar = get_u16((0x0028, 0x0006)).unwrap_or(0); - let photometric = tags - .get(&(0x0028, 0x0004)) - .and_then(|e| b.get(e.start..e.start.checked_add(e.len)?)) - .map(|v| String::from_utf8_lossy(v).trim_end_matches(['\0', ' ']).to_string()) - .ok_or_else(|| bad("missing PhotometricInterpretation (0028,0004)"))?; - let pixel = tags.get(&(0x7FE0, 0x0010)).ok_or_else(|| CodecError::unsupported(F, "no pixel data (7FE0,0010)"))?; - if !matches!(bits, 8 | 16) || !matches!(bits_stored, 1..=16) { - return Err(CodecError::unsupported(F, format!("{bits}-bit allocated / {bits_stored}-bit stored samples"))); - } - let mono = matches!(photometric.as_str(), "MONOCHROME1" | "MONOCHROME2"); - let rgb = photometric == "RGB"; - let ybr = photometric == "YBR_FULL"; - if !(mono || rgb || ybr) { - return Err(CodecError::unsupported(F, format!("photometric interpretation {photometric}"))); - } - // Mono stores one sample; RGB and YBR_FULL store three. Any other count would index past the - // pixel data, so it is refused rather than misread. - let want_samples = if mono { 1 } else { 3 }; - if samples != want_samples { - return Err(CodecError::unsupported(F, format!("{samples} samples per pixel with {photometric}"))); - } - if ybr && bits != 8 { - return Err(CodecError::unsupported(F, format!("{bits}-bit {photometric} (8-bit only)"))); - } - let layout = if mono { ChannelLayout::Gray } else { ChannelLayout::Rgb }; - let out_sample = if bits == 8 { SampleType::U8 } else { SampleType::U16 }; - limits.check(cols, rows, layout, out_sample)?; - - let pixels = (cols as usize).checked_mul(rows as usize).ok_or_else(|| CodecError::LimitExceeded("image too large".into()))?; - let n = pixels.checked_mul(samples as usize).ok_or_else(|| CodecError::LimitExceeded("image too large".into()))?; - let bytes_per = if bits == 16 { 2usize } else { 1 }; - let need = n.checked_mul(bytes_per).ok_or_else(|| CodecError::LimitExceeded("pixel data too large".into()))?; - let data = b - .get(pixel.start..pixel.start.checked_add(need).ok_or_else(|| CodecError::LimitExceeded("pixel data too large".into()))?) - .ok_or_else(|| bad("pixel data is truncated"))?; - let out_channels = layout.channels(); - let out_len = - pixels.checked_mul(out_channels).and_then(|k| k.checked_mul(bytes_per)).ok_or_else(|| CodecError::LimitExceeded("image too large".into()))?; - let mut out = Vec::new(); - out.try_reserve_exact(out_len).map_err(|_| CodecError::LimitExceeded("cannot allocate the image".into()))?; - // Raw sample of channel `ch` at pixel `p`, honouring the planar configuration. - let sample_at = |p: usize, ch: usize| -> Option { - let idx = if planar == 1 { ch.checked_mul(pixels)?.checked_add(p)? } else { p.checked_mul(samples as usize)?.checked_add(ch)? }; - let off = idx.checked_mul(bytes_per)?; - if bits == 16 { - let c = data.get(off..off.checked_add(2)?)?; - Some(if big { u16::from_be_bytes([c[0], c[1]]) } else { u16::from_le_bytes([c[0], c[1]]) }.into()) - } else { - Some(u32::from(*data.get(off)?)) - } - }; - let stored_max = f64::from((1u32 << bits_stored) - 1); - // Extract the `bits_stored` samples (the least significant one at `high_bit`) and scale to - // [0, 1]; signed values are shifted up by half a range first. `high_bit` is 1-based here. - let shift = (u32::from(high_bit) + 1).saturating_sub(u32::from(bits_stored)); - let mask = (1u32 << bits_stored) - 1; - let half = 1u32 << (bits_stored - 1); - let norm = move |raw: u32| -> f64 { - let v = (raw >> shift) & mask; - // Signed: flip the sign bit to map [-2^(b-1), 2^(b-1)-1] onto [0, 2^b-1]. - let v = if signed { v ^ half } else { v }; - (f64::from(v) / stored_max).clamp(0.0, 1.0) - }; - let q = |x: f64| -> u16 { (x * 65535.0).round() as u16 }; - let push = |out: &mut Vec, x: f64| { - if bits == 8 { - out.push((x * 255.0).round() as u8); - } else { - out.extend_from_slice(&q(x).to_ne_bytes()); - } - }; - for p in 0..pixels { - let s = |ch: usize| sample_at(p, ch).ok_or_else(|| bad("pixel data is shorter than the image")); - if mono { - let x = norm(s(0)?); - push(&mut out, if photometric == "MONOCHROME1" { 1.0 - x } else { x }); - } else if rgb { - for ch in 0..3 { - push(&mut out, norm(s(ch)?)); - } - } else { - // YBR_FULL (8-bit): BT.601 full-range to RGB. - let y = f64::from(s(0)?); - let cb = f64::from(s(1)?) - 128.0; - let cr = f64::from(s(2)?) - 128.0; - let r = (y + 1.402 * cr).clamp(0.0, 255.0); - let g = (y - 0.344_136 * cb - 0.714_136 * cr).clamp(0.0, 255.0); - let bl = (y + 1.772 * cb).clamp(0.0, 255.0); - for v in [r, g, bl] { - push(&mut out, v / 255.0); - } - } - } - Image::from_raw(cols, rows, layout, out_sample, out) -} - -#[cfg(test)] -mod tests { - use super::*; - - /// Build the file meta group (explicit VR little-endian), including the given extra - /// `(element, ascii)` pairs before the TransferSyntaxUID. - fn meta(b: &mut Vec, ts: &str, extra: &[(u16, &str)]) { - let ui = |e: u16, v: &str, b: &mut Vec| { - let mut s = v.as_bytes().to_vec(); - if s.len() % 2 == 1 { - s.push(0); - } - b.extend_from_slice(&0x0002u16.to_le_bytes()); - b.extend_from_slice(&e.to_le_bytes()); - b.extend_from_slice(b"UI"); - b.extend_from_slice(&(s.len() as u16).to_le_bytes()); - b.extend_from_slice(&s); - }; - for (e, v) in extra { - ui(*e, v, b); - } - ui(0x0010, ts, b); - } - - fn us(b: &mut Vec, g: u16, e: u16, v: u16, explicit: bool) { - b.extend_from_slice(&g.to_le_bytes()); - b.extend_from_slice(&e.to_le_bytes()); - if explicit { - b.extend_from_slice(b"US"); - b.extend_from_slice(&2u16.to_le_bytes()); - } else { - b.extend_from_slice(&2u32.to_le_bytes()); - } - b.extend_from_slice(&v.to_le_bytes()); - } - - fn cs(b: &mut Vec, g: u16, e: u16, v: &str, explicit: bool) { - let mut s = v.as_bytes().to_vec(); - if s.len() % 2 == 1 { - s.push(0); - } - b.extend_from_slice(&g.to_le_bytes()); - b.extend_from_slice(&e.to_le_bytes()); - if explicit { - b.extend_from_slice(b"CS"); - b.extend_from_slice(&(s.len() as u16).to_le_bytes()); - } else { - b.extend_from_slice(&(s.len() as u32).to_le_bytes()); - } - b.extend_from_slice(&s); - } - - /// A DICOM with the given transfer syntax UID and data-set encoding. - #[allow(clippy::too_many_arguments)] - fn synth( - ts: &str, - explicit: bool, - big: bool, - planar: u16, - rows: u16, - cols: u16, - samples: u16, - bits: u16, - photometric: &str, - pixels: &[u8], - ) -> Vec { - let mut b = vec![0u8; 128]; - b.extend_from_slice(b"DICM"); - // One extra meta element before the syntax, so a reader that only looks at the last - // group-0002 element takes the wrong one. - meta(&mut b, ts, &[(0x0002, "1.2.840.10008.5.1.4.1.1.7")]); - let _ = big; - us(&mut b, 0x0028, 0x0010, rows, explicit); - us(&mut b, 0x0028, 0x0011, cols, explicit); - us(&mut b, 0x0028, 0x0002, samples, explicit); - us(&mut b, 0x0028, 0x0006, planar, explicit); - cs(&mut b, 0x0028, 0x0004, photometric, explicit); - us(&mut b, 0x0028, 0x0100, bits, explicit); - us(&mut b, 0x0028, 0x0101, bits, explicit); - us(&mut b, 0x0028, 0x0102, bits - 1, explicit); - us(&mut b, 0x0028, 0x0103, 0, explicit); - b.extend_from_slice(&0x7FE0u16.to_le_bytes()); - b.extend_from_slice(&0x0010u16.to_le_bytes()); - if explicit { - b.extend_from_slice(b"OB"); - b.extend_from_slice(&0u16.to_le_bytes()); - } - b.extend_from_slice(&(pixels.len() as u32).to_le_bytes()); - b.extend_from_slice(pixels); - b - } - - #[test] - fn decodes_8bit_monochrome() { - let b = synth("1.2.840.10008.1.2.1", true, false, 0, 2, 2, 1, 8, "MONOCHROME2", &[0, 51, 102, 255]); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!((img.width(), img.height(), img.layout(), img.sample_type()), (2, 2, ChannelLayout::Gray, SampleType::U8)); - assert_eq!(img.data(), &[0, 51, 102, 255]); - } - - #[test] - fn decodes_16bit_monochrome_and_scales() { - let px: Vec = [0u16, 32768, 65535].iter().flat_map(|v| v.to_le_bytes()).collect(); - let b = synth("1.2.840.10008.1.2.1", true, false, 0, 3, 1, 1, 16, "MONOCHROME2", &px); - let img = decode(&b, &Limits::default()).unwrap(); - let v = img.to_u16_samples().unwrap(); - assert_eq!(v[0], 0); - assert!((i32::from(v[1]) - 32768).abs() <= 1); - assert_eq!(v[2], 65535); - } - - #[test] - fn monochrome1_is_inverted() { - let b = synth("1.2.840.10008.1.2.1", true, false, 0, 2, 1, 1, 8, "MONOCHROME1", &[0, 255]); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[255, 0]); - } - - #[test] - fn decodes_rgb_interleaved_and_planar() { - // 2 pixels: (10,20,30) and (40,50,60). - let interleaved = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 2, 3, 8, "RGB", &[10, 20, 30, 40, 50, 60]); - let img = decode(&interleaved, &Limits::default()).unwrap(); - assert_eq!((img.layout(), img.data()), (ChannelLayout::Rgb, &[10u8, 20, 30, 40, 50, 60][..])); - // Planar 0: R plane, then G, then B. - let planar = synth("1.2.840.10008.1.2.1", true, false, 1, 1, 2, 3, 8, "RGB", &[10, 40, 20, 50, 30, 60]); - let img = decode(&planar, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[10, 20, 30, 40, 50, 60]); - } - - #[test] - fn decodes_ybr_full_to_rgb() { - // White (Y=128, Cb=Cr=128) stays neutral grey. - let b = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 1, 3, 8, "YBR_FULL", &[128, 128, 128]); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.layout(), ChannelLayout::Rgb); - let d = img.data(); - assert!(d[0].abs_diff(d[1]) <= 1 && d[1].abs_diff(d[2]) <= 1, "{d:?}"); - } - - #[test] - fn decodes_implicit_vr() { - let b = synth("1.2.840.10008.1.2", false, false, 0, 2, 2, 1, 8, "MONOCHROME2", &[0, 51, 102, 255]); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.layout(), ChannelLayout::Gray); - assert_eq!(img.data(), &[0, 51, 102, 255]); - } - - #[test] - fn skips_an_undefined_length_sequence_outside_the_pixel_data() { - // Insert an undefined-length SQ (0008,2218) with one item, then a defined-length one, - // before the pixel data: the reader must skip both and still decode the image. - let mut b = vec![0u8; 128]; - b.extend_from_slice(b"DICM"); - meta(&mut b, "1.2.840.10008.1.2.1", &[]); - for (g, e, v) in [ - (0x0028, 0x0010, 1u16), - (0x0028, 0x0011, 1), - (0x0028, 0x0002, 1), - (0x0028, 0x0100, 8), - (0x0028, 0x0101, 8), - (0x0028, 0x0102, 7), - (0x0028, 0x0103, 0), - ] { - us(&mut b, g, e, v, true); - } - cs(&mut b, 0x0028, 0x0004, "MONOCHROME2", true); - // Undefined-length sequence (0008,2211), one undefined-length item containing a nested - // defined-length sequence, then the delimiters. - b.extend_from_slice(&[0x08, 0x00, 0x11, 0x22, b'S', b'Q', 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF]); - b.extend_from_slice(&[0xFE, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF]); // item, undefined - b.extend_from_slice(&[0x08, 0x00, 0x55, 0x22, b'S', b'Q', 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 1, 2, 3, 4]); // nested, defined - b.extend_from_slice(&[0xFE, 0xFF, 0x0D, 0xE0, 0x00, 0x00, 0x00, 0x00]); // item delimitation - b.extend_from_slice(&[0xFE, 0xFF, 0xDD, 0xE0, 0x00, 0x00, 0x00, 0x00]); // sequence delimitation - // Pixel data (defined length). - b.extend_from_slice(&0x7FE0u16.to_le_bytes()); - b.extend_from_slice(&0x0010u16.to_le_bytes()); - b.extend_from_slice(b"OB"); - b.extend_from_slice(&0u16.to_le_bytes()); - b.extend_from_slice(&1u32.to_le_bytes()); - b.push(200); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[200]); - } - - #[test] - fn truncated_and_bad_is_error_not_panic() { - let b = synth("1.2.840.10008.1.2.1", true, false, 0, 2, 2, 1, 8, "MONOCHROME2", &[0, 1, 2, 3]); - for cut in [0, 4, 128, 132, 140, b.len() - 1] { - assert!(decode(&b[..cut.min(b.len())], &Limits::default()).is_err(), "cut {cut}"); - } - assert!(decode(b"not dicom", &Limits::default()).is_err()); - } - - #[test] - fn high_bit_outside_the_allocated_bits_is_an_error_not_a_panic() { - let mut b = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 1, 1, 8, "MONOCHROME2", &[7]); - let tag = [0x28, 0x00, 0x02, 0x01, b'U', b'S', 0x02, 0x00]; - let at = b.windows(tag.len()).position(|w| w == tag).unwrap() + tag.len(); - b[at..at + 2].copy_from_slice(&200u16.to_le_bytes()); - assert!(decode(&b, &Limits::default()).is_err()); - } - - #[test] - fn rejects_compressed_transfer_syntax() { - let mut b = synth("1.2.840.10008.1.2.1", true, false, 0, 1, 1, 1, 8, "MONOCHROME2", &[0]); - let uncompressed = b"1.2.840.10008.1.2.1\0"; - let compressed = b"1.2.840.10008.1.2.4\0"; // same length, a compressed family - let at = b.windows(uncompressed.len()).position(|w| w == uncompressed).expect("transfer syntax in the fixture"); - b[at..at + compressed.len()].copy_from_slice(compressed); - assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. }))); - } +pub fn decode(bytes: &[u8], limits: &Limits) -> Result { + bridge::format(Format::Dicom, bytes, limits) } diff --git a/crates/raster-codecs/src/fits.rs b/crates/raster-codecs/src/fits.rs index 0d05c0fa1..4a662ab6e 100644 --- a/crates/raster-codecs/src/fits.rs +++ b/crates/raster-codecs/src/fits.rs @@ -1,857 +1,16 @@ -//! FITS (Flexible Image Transport System, FITS Standard 4.0), implemented here: the image in the -//! primary HDU, or the first `IMAGE` extension when the primary HDU holds no data. -//! -//! Reading: -//! -//! * `BITPIX` 8, 16, 32, 64, -32 and -64, with `BSCALE`/`BZERO` and integer `BLANK`. -//! * `NAXIS3 = 3` opens as RGB (the planes are R, G, B); any other plane count opens the first -//! plane as gray with [`crate::DecodeWarning::MorePages`]. -//! * Rows are stored bottom-to-top, as the standard's convention has it (Siril, DS9, Astropy), -//! unless `ROWORDER = 'TOP-DOWN'`. -//! * Physical values that fit (unsigned 8-bit, or integers in 0..=65535 such as a camera's -//! `BITPIX = 16`, `BZERO = 32768`) are kept exactly as U8/U16. Everything else becomes F32: -//! values up to 2 are taken as already normalised (Siril, PixInsight), larger ones are scaled by -//! 65535 when they fit in it (DeepSkyStacker, most stackers) and by the maximum otherwise. NaN -//! and blank pixels read as 0. -//! * The other header cards are kept as text: `KEY` → value (strings unquoted), `COMMENT` and -//! `HISTORY` by their text, `HIERARCH` keywords by their long name. Long strings continued -//! on `CONTINUE` cards are joined. -//! -//! Writing: gray or RGB, U8 (`BITPIX = 8`), U16 (`BITPIX = 16`, `BZERO = 32768`) or F32 -//! (`BITPIX = -32`, 0..1), bottom-to-top with `ROWORDER = 'BOTTOM-UP'`, plus the text cards -//! (strings longer than one card on `CONTINUE` cards). -//! Tile-compressed files (fpack `ZIMAGE` tables) are recognised and refused. +//! FITS compatibility facade; implementation lives in craft-image-codecs. +use crate::{CodecError, Image, Limits, bridge}; +use craft_image_codecs::Format; -use std::collections::HashMap; - -use crate::{ChannelLayout, CodecError, DecodeWarning, Image, Limits, SampleType}; - -const F: &str = "FITS"; -const BLOCK: usize = 2880; -const CARD: usize = 80; -/// Most HDUs walked looking for an image; FITS files from cameras and stackers hold a handful. -const MAX_HDUS: usize = 1000; - -/// Keywords that describe the data layout. They are written from the image, never copied from -/// (or kept as) text metadata: after decoding they no longer describe the pixels. -const STRUCTURAL: &[&str] = &[ - "SIMPLE", "BITPIX", "NAXIS", "EXTEND", "BZERO", "BSCALE", "BLANK", "END", "XTENSION", "PCOUNT", "GCOUNT", "ROWORDER", "CHECKSUM", "DATASUM", - "DATAMIN", "DATAMAX", "ZIMAGE", -]; - -fn err(msg: impl std::fmt::Display) -> CodecError { - CodecError::malformed(F, msg) +pub fn looks_like_fits(bytes: &[u8]) -> bool { + craft_image_codecs::detect(bytes) == Some(Format::Fits) } - -#[derive(Debug, Clone, PartialEq)] -enum Value { - /// A quoted string, unescaped, trailing blanks removed. - Str(String), - /// Anything else (number, logical, complex) as written. - Raw(String), -} - -#[derive(Debug, Clone)] -struct Card { - key: String, - /// `None` for commentary cards (`COMMENT`, `HISTORY`, blank keyword). - value: Option, - /// The text of a commentary card. - text: String, - /// A `HIERARCH` keyword (`key` holds its long name). - hierarch: bool, -} - -fn parse_value(field: &str) -> Value { - let t = field.trim_start(); - if let Some(rest) = t.strip_prefix('\'') { - let mut s = String::new(); - let mut chars = rest.chars().peekable(); - while let Some(c) = chars.next() { - if c == '\'' { - if chars.peek() == Some(&'\'') { - chars.next(); - s.push('\''); - } else { - break; - } - } else { - s.push(c); - } - } - Value::Str(s.trim_end().to_string()) - } else { - Value::Raw(t.split('/').next().unwrap_or("").trim().to_string()) - } -} - -fn parse_card(raw: &[u8]) -> Card { - // Header bytes are ASCII 32–126 by the standard; anything else is replaced, never trusted. - let s: String = raw.iter().map(|&b| if (32..=126).contains(&b) { b as char } else { '?' }).collect(); - let key_field = s.get(..8).unwrap_or(&s).trim_end().to_string(); - if key_field == "HIERARCH" { - let rest = s.get(9..).unwrap_or(""); - if let Some((k, v)) = rest.split_once('=') { - return Card { key: k.trim().to_string(), value: Some(parse_value(v)), text: String::new(), hierarch: true }; - } - } - if s.get(8..10) == Some("= ") { - let v = parse_value(s.get(10..).unwrap_or("")); - return Card { key: key_field, value: Some(v), text: String::new(), hierarch: false }; - } - Card { key: key_field, value: None, text: s.get(8..).unwrap_or("").trim_end().to_string(), hierarch: false } -} - -struct Header { - cards: Vec, - /// First-occurrence index of each non-HIERARCH keyword, so `get` is O(1). The card - /// count and the number of looked-up keywords (NAXIS1..NAXISn) are both file-controlled, - /// so a linear scan per lookup lets a crafted header multiply commentary cards by axis - /// count into quadratic work. - index: HashMap, - /// Offset of the data unit. - data_start: usize, -} - -impl Header { - fn get(&self, key: &str) -> Option<&Value> { - let c = &self.cards[*self.index.get(key)?]; - c.value.as_ref() - } - - fn int(&self, key: &str) -> Option { - match self.get(key)? { - Value::Raw(r) => r.parse::().ok().or_else(|| self.float(key).filter(|f| f.fract() == 0.0 && f.abs() < 9.0e15).map(|f| f as i64)), - Value::Str(_) => None, - } - } - - fn float(&self, key: &str) -> Option { - match self.get(key)? { - // Fortran-style `D` exponents are allowed in FITS. - Value::Raw(r) => r.replace(['D', 'd'], "E").parse::().ok().filter(|f| f.is_finite()), - Value::Str(_) => None, - } - } - - fn logical(&self, key: &str) -> bool { - matches!(self.get(key), Some(Value::Raw(r)) if r == "T") - } - - fn string(&self, key: &str) -> Option<&str> { - match self.get(key)? { - Value::Str(s) => Some(s.trim()), - Value::Raw(_) => None, - } - } -} - -fn parse_header(b: &[u8], start: usize) -> Result { - let mut cards = Vec::new(); - let mut pos = start; - loop { - let raw = b.get(pos..pos.checked_add(CARD).ok_or_else(|| err("header too long"))?).ok_or_else(|| err("header ends before END"))?; - pos += CARD; - if raw.starts_with(b"END") && raw.get(3..).is_some_and(|r| r.iter().all(|&c| c == b' ')) { - break; - } - let card = parse_card(raw); - // Long strings (FITS 4.0 section 4.2.1.2): a string ending in '&' goes on in the next - // `CONTINUE` record. An orphaned `CONTINUE` stays a card of its own (commentary). - if let Some(Card { value: Some(Value::Str(s)), .. }) = cards.last_mut() - && s.ends_with('&') - && card.key == "CONTINUE" - && card.text.starts_with(" ") - && let Value::Str(more) = parse_value(&card.text) - { - s.pop(); - s.push_str(&more); - continue; - } - cards.push(card); - } - let data_start = pos.div_ceil(BLOCK).checked_mul(BLOCK).ok_or_else(|| err("header too long"))?; - // Index each non-HIERARCH keyword to its first occurrence, matching the previous - // `find(|c| !c.hierarch && c.key == key)` lookup while making `get` O(1). - let mut index = HashMap::with_capacity(cards.len()); - for (i, c) in cards.iter().enumerate() { - if !c.hierarch { - index.entry(c.key.clone()).or_insert(i); - } - } - Ok(Header { cards, index, data_start }) -} - -/// The axis lengths (`NAXIS1`, `NAXIS2`, …). -fn axes(h: &Header) -> Result, CodecError> { - let n = h.int("NAXIS").ok_or_else(|| err("missing NAXIS"))?; - if !(0..=999).contains(&n) { - return Err(err(format!("invalid NAXIS {n}"))); - } - (1..=n) - .map(|i| h.int(&format!("NAXIS{i}")).and_then(|v| u64::try_from(v).ok()).ok_or_else(|| err(format!("missing or negative NAXIS{i}")))) - .collect() -} - -/// Bytes in the data unit (before padding to a block). -fn data_len(h: &Header, bitpix: i64) -> Result { - let ax = axes(h)?; - if ax.is_empty() { - return Ok(0); - } - let pcount = u64::try_from(h.int("PCOUNT").unwrap_or(0)).map_err(|_| err("negative PCOUNT"))?; - let gcount = u64::try_from(h.int("GCOUNT").unwrap_or(1)).map_err(|_| err("negative GCOUNT"))?; - let elems = ax.iter().try_fold(1u64, |a, &n| a.checked_mul(n)).ok_or_else(|| err("data size overflows"))?; - elems - .checked_add(pcount) - .and_then(|v| v.checked_mul(gcount)) - .and_then(|v| v.checked_mul(bitpix.unsigned_abs() / 8)) - .ok_or_else(|| err("data size overflows")) -} - -/// A primary header's first card, `SIMPLE =`. -pub fn looks_like_fits(b: &[u8]) -> bool { - b.starts_with(b"SIMPLE =") -} - -/// Inspect every HDU without decoding pixels: one gray plane or three RGB planes are retained, -/// while other cubes, image extensions, tables and other data-bearing HDUs cannot survive a flat save. -/// Incomplete or over-limit walks fail closed rather than treating an unchecked suffix as safe. pub fn has_additional_images(bytes: &[u8]) -> Result { - let mut start = 0; - let mut image_seen = false; - for index in 0..MAX_HDUS { - let h = parse_header(bytes, start)?; - if index == 0 && h.get("SIMPLE").is_none() { - return Err(err("missing SIMPLE")); - } - let ax = axes(&h)?; - let size = data_len(&h, h.int("BITPIX").unwrap_or(8))?; - let image_hdu = index == 0 || h.string("XTENSION") == Some("IMAGE"); - if h.logical("ZIMAGE") { - return Ok(true); - } - if !image_hdu && size > 0 { - return Ok(true); - } - // An image HDU with a zero axis has no data (FITS 4.0, NAXISn) and holds no image, like - // the empty primary: `find_image` skips it too. - if image_hdu && size > 0 && ax.len() >= 2 && ax[..2].iter().all(|n| *n > 0) { - let planes = ax.iter().skip(2).try_fold(1u64, |n, axis| n.checked_mul(*axis)).ok_or_else(|| err("plane count overflows"))?; - let retained = planes == 1 || (ax.get(2) == Some(&3) && planes == 3); - if image_seen || !retained || h.int("GCOUNT").unwrap_or(1) > 1 || h.int("PCOUNT").unwrap_or(0) > 0 { - return Ok(true); - } - image_seen = true; - } else if size > 0 { - return Ok(true); - } - let padded = size.div_ceil(BLOCK as u64).checked_mul(BLOCK as u64).ok_or_else(|| err("data size overflows"))?; - let next = usize::try_from(padded).ok().and_then(|size| h.data_start.checked_add(size)).ok_or_else(|| err("data size overflows"))?; - if next > bytes.len() { - return Err(err("truncated HDU data")); - } - if next == bytes.len() { - return Ok(false); - } - start = next; - } - Err(err("too many HDUs to inspect every source image")) + craft_image_codecs::has_unretained_source_data(bytes).map_err(bridge::from_shared_error) } - -/// Whether an HDU with these axes stores pixels: at least two axes and none of them zero (FITS 4.0, -/// NAXISn: a zero axis means no data follow the header). -fn holds_pixels(ax: &[u64]) -> bool { - ax.len() >= 2 && ax.iter().all(|n| *n > 0) -} - -/// Finds the image HDU: the primary one when it holds pixels, else the first `IMAGE` extension -/// that does. Returns its header and the primary header (for its descriptive cards). -fn find_image(b: &[u8]) -> Result<(Header, Option
                      ), CodecError> { - let primary = parse_header(b, 0)?; - if primary.get("SIMPLE").is_none() { - return Err(err("missing SIMPLE")); - } - if holds_pixels(&axes(&primary)?) { - return Ok((primary, None)); - } - let mut compressed = false; - let mut cur_start = primary.data_start; - let mut cur_len = data_len(&primary, primary.int("BITPIX").unwrap_or(8))?; - for _ in 0..MAX_HDUS { - let next = usize::try_from(cur_len.div_ceil(BLOCK as u64).saturating_mul(BLOCK as u64)) - .ok() - .and_then(|l| cur_start.checked_add(l)) - .ok_or_else(|| err("data size overflows"))?; - if next >= b.len() { - break; - } - let h = parse_header(b, next)?; - let kind = h.string("XTENSION").unwrap_or("").to_string(); - if kind == "IMAGE" && holds_pixels(&axes(&h)?) { - return Ok((h, Some(primary))); - } - if kind == "BINTABLE" && h.logical("ZIMAGE") { - compressed = true; - } - cur_len = data_len(&h, h.int("BITPIX").unwrap_or(8))?; - cur_start = h.data_start; - } - if compressed { - return Err(CodecError::unsupported(F, "tile-compressed FITS (fpack) is not supported; decompress it with funpack first")); - } - Err(err("the file holds no image")) -} - pub fn decode(bytes: &[u8], limits: &Limits) -> Result { - let (h, primary) = find_image(bytes)?; - let bitpix = h.int("BITPIX").ok_or_else(|| err("missing BITPIX"))?; - if !matches!(bitpix, 8 | 16 | 32 | 64 | -32 | -64) { - return Err(err(format!("invalid BITPIX {bitpix}"))); - } - let ax = axes(&h)?; - let (Some(&w), Some(&hgt)) = (ax.first(), ax.get(1)) else { return Err(err("the image has fewer than two axes")) }; - let w = u32::try_from(w).map_err(|_| CodecError::LimitExceeded(format!("width {w}")))?; - let hgt = u32::try_from(hgt).map_err(|_| CodecError::LimitExceeded(format!("height {hgt}")))?; - let planes = ax.iter().skip(2).try_fold(1u64, |a, &n| a.checked_mul(n)).ok_or_else(|| err("too many planes"))?; - let (layout, nplanes) = if ax.get(2) == Some(&3) && planes == 3 { (ChannelLayout::Rgb, 3usize) } else { (ChannelLayout::Gray, 1) }; - - let bscale = h.float("BSCALE").unwrap_or(1.0); - let bzero = h.float("BZERO").unwrap_or(0.0); - let blank = if bitpix > 0 { h.int("BLANK") } else { None }; - let integral = bscale == 1.0 && bzero.fract() == 0.0; - let candidate = match bitpix { - 8 if integral && bzero == 0.0 => SampleType::U8, - 8 | 16 if integral => SampleType::U16, - _ => SampleType::F32, - }; - limits.check(w, hgt, layout, candidate)?; - - let bps = (bitpix.unsigned_abs() / 8) as usize; - let plane_len = (w as usize).checked_mul(hgt as usize).ok_or_else(|| CodecError::LimitExceeded(format!("{w}x{hgt} does not fit in memory")))?; - let n = plane_len.checked_mul(nplanes).ok_or_else(|| CodecError::LimitExceeded("image does not fit in memory".into()))?; - let need = n.checked_mul(bps).and_then(|l| l.checked_add(h.data_start)).ok_or_else(|| err("data size overflows"))?; - let data = bytes.get(h.data_start..need).ok_or_else(|| err("truncated data"))?; - - // Physical value of sample `i` (planar order); `None` for a blank or NaN pixel. - let physical = |i: usize| -> Option { - let s = data.get(i * bps..(i + 1) * bps)?; - let raw = match bitpix { - 8 => s.first().map(|&v| v as i64)?, - 16 => i16::from_be_bytes([s[0], s[1]]) as i64, - 32 => i32::from_be_bytes([s[0], s[1], s[2], s[3]]) as i64, - 64 => i64::from_be_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]), - -32 => return Some(f32::from_be_bytes([s[0], s[1], s[2], s[3]]) as f64 * bscale + bzero).filter(|v| v.is_finite()), - _ => return Some(f64::from_be_bytes([s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]]) * bscale + bzero).filter(|v| v.is_finite()), - }; - if blank == Some(raw) { - return None; - } - Some(raw as f64 * bscale + bzero) - }; - - let top_down = h.string("ROWORDER").is_some_and(|r| r.eq_ignore_ascii_case("TOP-DOWN")); - let (wu, hu) = (w as usize, hgt as usize); - // Planar, bottom-up (by default) → interleaved, top-down. - let dest = |i: usize| -> usize { - let (p, rem) = (i / plane_len, i % plane_len); - let (y, x) = (rem / wu, rem % wu); - let y = if top_down { y } else { hu - 1 - y }; - (y * wu + x) * nplanes + p - }; - - let mut img = match candidate { - SampleType::U8 => { - let mut out = vec![0u8; n]; - for i in 0..n { - out[dest(i)] = physical(i).unwrap_or(0.0) as u8; - } - Image::from_u8(w, hgt, layout, out)? - } - _ => { - let mut out16 = if candidate == SampleType::U16 { Some(vec![0u16; n]) } else { None }; - if let Some(out) = out16.as_mut() { - for i in 0..n { - let v = physical(i).unwrap_or(0.0); - if !(0.0..=65535.0).contains(&v) { - // Signed data with negative values: fall back to float. - out16 = None; - break; - } - out[dest(i)] = v as u16; - } - } - match out16 { - Some(out) => Image::from_u16(w, hgt, layout, &out)?, - None => { - let max = (0..n).filter_map(physical).fold(0.0f64, f64::max); - let white = if max <= 2.0 { - 1.0 - } else if max <= 65535.0 { - 65535.0 - } else { - max - }; - let mut out = vec![0f32; n]; - for i in 0..n { - out[dest(i)] = (physical(i).unwrap_or(0.0) / white) as f32; - } - Image::from_f32(w, hgt, layout, &out)? - } - } - } - }; - - if planes > nplanes as u64 { - img.warnings.push(DecodeWarning::MorePages { total: u32::try_from(planes).ok() }); - } - let mut text = Vec::new(); - for c in primary.iter().flat_map(|p| p.cards.iter()).chain(h.cards.iter()) { - if !c.hierarch && (STRUCTURAL.contains(&c.key.as_str()) || is_naxis(&c.key)) { - continue; - } - let entry = match &c.value { - Some(Value::Str(s) | Value::Raw(s)) => (c.key.clone(), s.clone()), - None if c.key.is_empty() && c.text.trim().is_empty() => continue, - None => (if c.key.is_empty() { "COMMENT".to_string() } else { c.key.clone() }, c.text.trim().to_string()), - }; - text.push(entry); - } - img.text = text; - Ok(img) + bridge::format(Format::Fits, bytes, limits) } - -fn is_naxis(key: &str) -> bool { - key.strip_prefix("NAXIS").is_some_and(|d| d.chars().all(|c| c.is_ascii_digit())) -} - -/// A standard keyword: 1–8 characters from `A-Z 0-9 _ -`. -fn standard_key(key: &str) -> bool { - (1..=8).contains(&key.len()) && key.bytes().all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || b == b'_' || b == b'-') -} - -fn ascii(s: &str) -> String { - s.chars().map(|c| if (' '..='~').contains(&c) { c } else { '?' }).collect() -} - -/// A FITS literal (number or logical) that can be written unquoted. -fn literal(v: &str) -> bool { - v == "T" - || v == "F" - || (v.replace(['D', 'd'], "E").parse::().is_ok_and(|f| f.is_finite()) && v.bytes().all(|b| b"0123456789+-.EeDd".contains(&b))) -} - -fn quoted(v: &str, room: usize) -> String { - let mut s = String::from("'"); - for c in ascii(v).chars() { - let add = if c == '\'' { 2 } else { 1 }; - // Keep room for the closing quote. - if s.len() + add + 1 > room { - break; - } - s.push(c); - if c == '\'' { - s.push('\''); - } - } - // Strings are at least eight characters inside the quotes. - while s.len() < 9 { - s.push(' '); - } - s.push('\''); - s -} - -struct Writer { - out: Vec, -} - -impl Writer { - fn card(&mut self, text: &str) { - let mut c: Vec = ascii(text).into_bytes(); - c.truncate(CARD); - c.resize(CARD, b' '); - self.out.extend_from_slice(&c); - } - - fn value(&mut self, key: &str, v: &str) { - if literal(v) { - self.card(&format!("{key:<8}= {v:>20}")); - return; - } - // A string too long for one card goes on in `CONTINUE` cards, every piece but the last - // ending in '&' (FITS 4.0 section 4.2.1.2). A doubled quote is never split, and trailing - // blanks (not significant) are dropped so none are kept before an '&'. - let escaped = ascii(v).trim_end().replace('\'', "''"); - let mut rest = escaped.as_str(); - let mut head = format!("{key:<8}= "); - while rest.len() > CARD - 12 { - let cut = CARD - 13 - rest.get(..CARD - 13).unwrap_or("").bytes().rev().take_while(|&b| b == b'\'').count() % 2; - let (piece, tail) = rest.split_at_checked(cut).unwrap_or((rest, "")); - self.card(&format!("{head}'{piece}&'")); - head = "CONTINUE ".to_string(); - rest = tail; - } - self.card(&format!("{head}'{rest:<8}'")); - } - - fn commentary(&mut self, key: &str, text: &str) { - let chars: Vec = ascii(text).chars().collect(); - if chars.is_empty() { - self.card(key); - } - for chunk in chars.chunks(CARD - 8) { - self.card(&format!("{key:<8}{}", chunk.iter().collect::())); - } - } - - fn text(&mut self, key: &str, v: &str) { - let upper = key.to_ascii_uppercase(); - if matches!(upper.as_str(), "COMMENT" | "HISTORY") { - self.commentary(&upper, v); - } else if standard_key(key) { - // `CONTINUE` only ever carries a string's continuation, written by `value`. - if !STRUCTURAL.contains(&key) && !is_naxis(key) && key != "CONTINUE" { - self.value(key, v); - } - } else { - // Long or mixed-case names (`Description`, `Software`): the HIERARCH convention, - // when the card fits, else a comment. - let name = ascii(key); - let head = format!("HIERARCH {name} = "); - let fits_key = !name.contains('=') && !name.trim().is_empty(); - let body = if literal(v) { v.to_string() } else { quoted(v, CARD.saturating_sub(head.len())) }; - if fits_key && head.len() + body.len() <= CARD && (literal(v) || body.ends_with('\'')) && quoted_whole(v, &body) { - self.card(&format!("{head}{body}")); - } else { - self.commentary("COMMENT", &format!("{key} = {v}")); - } - } - } -} - -/// `body` holds all of `v` (it was not cut short to fit the card). -fn quoted_whole(v: &str, body: &str) -> bool { - literal(v) || body.trim_matches('\'').trim_end().replace("''", "'") == ascii(v).trim_end() -} - -/// Writes `img` (gray or RGB; 8-bit, 16-bit or float) as a single-HDU FITS file, with -/// `img.text` as header cards. -pub fn encode(img: &Image) -> Result, CodecError> { - let (w, h) = (img.width(), img.height()); - let layout = img.layout(); - let nc = match layout { - ChannelLayout::Gray => 1, - ChannelLayout::Rgb => 3, - l => return Err(CodecError::encode(F, format!("FITS cannot store {l:?}"))), - }; - let bitpix = match img.sample_type() { - SampleType::U8 => 8, - SampleType::U16 => 16, - SampleType::F32 => -32, - }; - let mut wr = Writer { out: Vec::new() }; - wr.value("SIMPLE", "T"); - wr.value("BITPIX", &bitpix.to_string()); - wr.value("NAXIS", if nc == 3 { "3" } else { "2" }); - wr.value("NAXIS1", &w.to_string()); - wr.value("NAXIS2", &h.to_string()); - if nc == 3 { - wr.value("NAXIS3", "3"); - } - if bitpix == 16 { - wr.value("BZERO", "32768"); - wr.value("BSCALE", "1"); - } - wr.value("ROWORDER", "BOTTOM-UP"); - for (k, v) in &img.text { - wr.text(k, v); - } - wr.card("END"); - let mut out = wr.out; - out.resize(out.len().div_ceil(BLOCK) * BLOCK, b' '); - - // Planar, bottom row first. - let (wu, hu) = (w as usize, h as usize); - let idx = |p: usize, y: usize, x: usize| ((hu - 1 - y) * wu + x) * nc + p; - match bitpix { - 8 => { - let d = img.data(); - for p in 0..nc { - for y in 0..hu { - for x in 0..wu { - out.push(d[idx(p, y, x)]); - } - } - } - } - 16 => { - let d = img.to_u16_samples().unwrap_or_default(); - for p in 0..nc { - for y in 0..hu { - for x in 0..wu { - out.extend_from_slice(&((d[idx(p, y, x)] as i32 - 32768) as i16).to_be_bytes()); - } - } - } - } - _ => { - let d = img.to_f32_samples().unwrap_or_default(); - for p in 0..nc { - for y in 0..hu { - for x in 0..wu { - // 0..1 as documented: a value above 2 would make readers (ours too) - // take the data as ADU and scale it by 65535. NaN is written as 0. - let v = d[idx(p, y, x)]; - let v = if v.is_nan() { 0.0 } else { v.clamp(0.0, 1.0) }; - out.extend_from_slice(&v.to_be_bytes()); - } - } - } - } - } - out.resize(out.len().div_ceil(BLOCK) * BLOCK, 0); - Ok(out) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn header(cards: &[&str]) -> Vec { - let mut w = Writer { out: Vec::new() }; - for c in cards { - w.card(c); - } - w.card("END"); - let mut out = w.out; - out.resize(out.len().div_ceil(BLOCK) * BLOCK, b' '); - out - } - - #[test] - fn continue_strings_decode() { - let mut b = header(&[ - "SIMPLE = T", - "BITPIX = 8", - "NAXIS = 2", - "NAXIS1 = 1", - "NAXIS2 = 1", - "OBJECT = 'aaa&'", - "CONTINUE 'bbb&' / a comment", - "CONTINUE '&'", - "CONTINUE ''", - "OBSERVER= 'R&'", - "COMMENT hi", - "CONTINUE 'orphan'", - ]); - b.push(0); - let img = decode(&b, &Limits::default()).unwrap(); - let text = [("OBJECT", "aaabbb"), ("OBSERVER", "R&"), ("COMMENT", "hi"), ("CONTINUE", "'orphan'")]; - assert_eq!(img.text, text.map(|(k, v)| (k.to_string(), v.to_string()))); - } - - #[test] - fn continue_strings_round_trip() { - for value in ["a".repeat(100), format!("{}' {}", "a".repeat(65), "b".repeat(100)), "'".repeat(100), "a".repeat(68)] { - let mut img = Image::from_u8(1, 1, ChannelLayout::Gray, vec![0]).unwrap(); - img.text = vec![("OBJECT".into(), value.clone()), ("CONTINUE".into(), "orphan".into())]; - let b = encode(&img).unwrap(); - assert!(!b.chunks(CARD).any(|c| c.starts_with(b"CONTINUE="))); - let decoded = decode(&b, &Limits::default()).unwrap(); - assert_eq!(decoded.text, vec![("OBJECT".into(), value)]); - } - } - - #[test] - fn camera_u16_with_bzero_reads_exactly_and_bottom_up() { - let mut b = header(&[ - "SIMPLE = T", - "BITPIX = 16", - "NAXIS = 2", - "NAXIS1 = 2", - "NAXIS2 = 2", - "BZERO = 32768", - "OBJECT = 'M 31 '", - "EXPTIME = 300.0 / seconds", - ]); - for v in [0u16, 1000, 40000, 65535] { - b.extend_from_slice(&((v as i32 - 32768) as i16).to_be_bytes()); - } - b.resize(b.len().div_ceil(BLOCK) * BLOCK, 0); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.sample_type(), SampleType::U16); - // The first stored row is the bottom one. - assert_eq!(img.to_u16_samples().unwrap(), vec![40000, 65535, 0, 1000]); - assert!(img.text.contains(&("OBJECT".into(), "M 31".into()))); - assert!(img.text.contains(&("EXPTIME".into(), "300.0".into()))); - assert!(!img.text.iter().any(|(k, _)| k == "BZERO" || k == "NAXIS1")); - } - - #[test] - fn roworder_top_down_is_honoured() { - let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 2", "ROWORDER= 'TOP-DOWN'"]); - b.extend_from_slice(&[10, 20]); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[10, 20]); - } - - #[test] - fn stacked_float_in_adu_is_scaled_by_65535() { - let mut b = header(&["SIMPLE = T", "BITPIX = -32", "NAXIS = 2", "NAXIS1 = 2", "NAXIS2 = 1"]); - for v in [65535.0f32, f32::NAN] { - b.extend_from_slice(&v.to_be_bytes()); - } - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.to_f32_samples().unwrap(), vec![1.0, 0.0]); - } - - #[test] - fn hdr_float_saves_clamped_and_reopens_as_saved() { - // One value above 2 used to make the reader scale everything by 65535 (all black). - let img = Image::from_f32(2, 1, ChannelLayout::Gray, &[0.5, 3.0]).unwrap(); - let bytes = encode(&img).unwrap(); - let back = decode(&bytes, &Limits::default()).unwrap().to_f32_samples().unwrap(); - assert!((back[0] - 0.5).abs() < 1e-6, "{back:?}"); - assert!((back[1] - 1.0).abs() < 1e-6, "{back:?}"); - } - - #[test] - fn signed_negative_data_falls_back_to_float() { - let mut b = header(&["SIMPLE = T", "BITPIX = 16", "NAXIS = 2", "NAXIS1 = 2", "NAXIS2 = 1"]); - for v in [-100i16, 1000] { - b.extend_from_slice(&v.to_be_bytes()); - } - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.sample_type(), SampleType::F32); - } - - #[test] - fn image_extension_after_empty_primary() { - let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0", "EXTEND = T", "TELESCOP= 'Seestar S50'"]); - b.extend(header(&["XTENSION= 'IMAGE '", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 1", "PCOUNT = 0", "GCOUNT = 1"])); - b.push(42); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[42]); - assert!(img.text.contains(&("TELESCOP".into(), "Seestar S50".into()))); - } - - /// A zero axis (`NAXIS3 = 0`) means the HDU has no data: it is neither the opened image nor - /// an additional one that a flat save would discard. - #[test] - fn zero_axis_image_hdus_are_empty() { - let empty = |primary: bool| { - let first = if primary { "SIMPLE = T" } else { "XTENSION= 'IMAGE '" }; - header(&[first, "BITPIX = 8", "NAXIS = 3", "NAXIS1 = 1", "NAXIS2 = 1", "NAXIS3 = 0", "PCOUNT = 0", "GCOUNT = 1"]) - }; - let image = || { - let mut b = header(&["XTENSION= 'IMAGE '", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 1", "PCOUNT = 0", "GCOUNT = 1"]); - b.push(42); - b.resize(b.len().div_ceil(BLOCK) * BLOCK, 0); - b - }; - let mut after_empty_primary = empty(true); - after_empty_primary.extend(image()); - let mut after_empty_extension = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0", "EXTEND = T"]); - after_empty_extension.extend(empty(false)); - after_empty_extension.extend(image()); - let mut before_empty_extension = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0", "EXTEND = T"]); - before_empty_extension.extend(image()); - before_empty_extension.extend(empty(false)); - for b in [&after_empty_primary, &after_empty_extension, &before_empty_extension] { - assert!(!has_additional_images(b).unwrap()); - assert_eq!(decode(b, &Limits::default()).unwrap().data(), &[42]); - } - // Only empty HDUs: nothing to open, nothing to lose. - assert!(!has_additional_images(&empty(true)).unwrap()); - assert!(decode(&empty(true), &Limits::default()).is_err()); - // A second non-empty image is still additional data. - let mut two = after_empty_primary.clone(); - two.extend(image()); - assert!(has_additional_images(&two).unwrap()); - } - - #[test] - fn fpack_is_refused_as_unsupported() { - let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0"]); - b.extend(header(&["XTENSION= 'BINTABLE'", "BITPIX = 8", "NAXIS = 2", "NAXIS1 = 0", "NAXIS2 = 0", "ZIMAGE = T"])); - b.extend(header(&["XTENSION= 'BINTABLE'", "BITPIX = 8", "NAXIS = 1", "NAXIS1 = 0"])); - assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. }))); - } - - /// Hostile headers: absurd or negative axes, bad BITPIX, overflowing sizes, missing END, - /// a long chain of empty HDUs and declared data past the end all error, never panic or - /// allocate the declared size. - #[test] - fn hostile_headers_error_without_panicking() { - let base = ["SIMPLE = T", "BITPIX = 16"]; - let cases: &[&[&str]] = &[ - &["NAXIS = 2", "NAXIS1 = 4294967296", "NAXIS2 = 1"], - &["NAXIS = 2", "NAXIS1 = -5", "NAXIS2 = 1"], - &["NAXIS = 2", "NAXIS1 = 2000000", "NAXIS2 = 2000000"], - &["NAXIS = 3", "NAXIS1 = 65536", "NAXIS2 = 65536", "NAXIS3 = 9223372036854775807"], - &["NAXIS = 1000"], - &["NAXIS = -1"], - &["NAXIS = 2", "NAXIS1 = 0", "NAXIS2 = 0"], - &["NAXIS = 2", "NAXIS1 = 1.5D300", "NAXIS2 = 1"], - &["NAXIS = 2"], - &["NAXIS = 2", "NAXIS1 = 100", "NAXIS2 = 100"], - ]; - for extra in cases { - let cards: Vec<&str> = base.iter().chain(extra.iter()).copied().collect(); - let b = header(&cards); - assert!(decode(&b, &Limits::default()).is_err(), "{extra:?}"); - } - for bitpix in ["0", "7", "-16", "128", "'X'"] { - let card = format!("BITPIX = {bitpix}"); - let b = header(&["SIMPLE = T", &card, "NAXIS = 2", "NAXIS1 = 1", "NAXIS2 = 1"]); - assert!(decode(&b, &Limits::default()).is_err(), "BITPIX {bitpix}"); - } - // No END card: the header runs off the end of the file. - let mut w = Writer { out: Vec::new() }; - for c in ["SIMPLE = T", "BITPIX = 8", "NAXIS = 2"] { - w.card(c); - } - assert!(decode(&w.out, &Limits::default()).is_err()); - // An empty primary followed by many empty extensions: bounded walk, then "no image". - let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0"]); - for _ in 0..(MAX_HDUS + 5) { - b.extend(header(&["XTENSION= 'IMAGE '", "BITPIX = 8", "NAXIS = 0"])); - } - assert!(decode(&b, &Limits::default()).is_err()); - // An extension whose declared data size overflows. - let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 0"]); - b.extend(header(&[ - "XTENSION= 'BINTABLE'", - "BITPIX = 64", - "NAXIS = 2", - "NAXIS1 = 9223372036854775807", - "NAXIS2 = 4", - "PCOUNT = 0", - "GCOUNT = 1", - ])); - assert!(decode(&b, &Limits::default()).is_err()); - } - - #[test] - fn extra_planes_warn() { - let mut b = header(&["SIMPLE = T", "BITPIX = 8", "NAXIS = 3", "NAXIS1 = 1", "NAXIS2 = 1", "NAXIS3 = 4"]); - b.extend_from_slice(&[1, 2, 3, 4]); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.layout(), ChannelLayout::Gray); - assert_eq!(img.warnings, vec![DecodeWarning::MorePages { total: Some(4) }]); - } - - #[test] - fn strings_with_quotes_and_hierarch_round_trip() { - let mut w = Writer { out: Vec::new() }; - w.text("OBSERVER", "O'Brien"); - w.text("Software", "craft 1.0"); - w.text("HISTORY", "stacked"); - let cards: Vec = w.out.chunks(CARD).map(parse_card).collect(); - assert_eq!(cards[0].value, Some(Value::Str("O'Brien".into()))); - assert!(cards[1].hierarch && cards[1].key == "Software"); - assert_eq!(cards[1].value, Some(Value::Str("craft 1.0".into()))); - assert_eq!((cards[2].key.as_str(), cards[2].text.as_str()), ("HISTORY", "stacked")); - } +pub fn encode(image: &Image) -> Result, CodecError> { + bridge::encode(image, Format::Fits, &Default::default()) } diff --git a/crates/raster-codecs/src/iff.rs b/crates/raster-codecs/src/iff.rs index 087ae5046..282617e21 100644 --- a/crates/raster-codecs/src/iff.rs +++ b/crates/raster-codecs/src/iff.rs @@ -1,538 +1,13 @@ -//! Amiga IFF/ILBM reader and writer (EA "Interchange File Format", "InterLeaved BitMap" and the -//! chunky "PBM " variant). Written from the published IFF/ILBM layout: a `FORM` chunk of four-byte -//! chunks (`BMHD` bitmap header, `CMAP` palette, `CAMG` Amiga viewport mode, `BODY` pixel data). -//! -//! Read: 1–8 bitplanes with a palette (or a gray ramp when there is none) with masking 0/1/2, and -//! 24-bitplane "deep" ILBMs (8 planes each of red, green and blue, least significant bit first, -//! no palette) with masking 0/1, both stored (0) and ByteRun1/PackBits (1) compressed. Anything -//! else is a clear `Unsupported`/`Malformed` error, never a panic. -//! -//! Write: a 24-bitplane ILBM, ByteRun1 compressed one plane row at a time, with a mask plane -//! (masking 1) when the image has alpha. The mask plane is one bit per pixel: alpha of 128 or -//! more is opaque. +//! IFF/ILBM compatibility facade; implementation lives in craft-image-codecs. +use crate::{CodecError, Image, Limits, bridge}; +use craft_image_codecs::Format; -use crate::{ChannelLayout, CodecError, Image, Limits, SampleType}; - -const F: &str = "IFF"; - -fn bad(msg: impl std::fmt::Display) -> CodecError { - CodecError::malformed(F, msg) +pub fn looks_like_iff(bytes: &[u8]) -> bool { + craft_image_codecs::detect(bytes) == Some(Format::Iff) } - -fn unsupported(msg: impl Into) -> CodecError { - CodecError::unsupported(F, msg) +pub fn decode(bytes: &[u8], limits: &Limits) -> Result { + bridge::format(Format::Iff, bytes, limits) } - -fn be32(b: &[u8], at: usize) -> Option { - let s = b.get(at..at.checked_add(4)?)?.try_into().ok()?; - Some(u32::from_be_bytes(s)) -} - -fn be16(b: &[u8], at: usize) -> Option { - let s = b.get(at..at.checked_add(2)?)?.try_into().ok()?; - Some(u16::from_be_bytes(s)) -} - -/// `FORM` + a bitmap type (`ILBM` interleaved, `PBM ` chunky) at offset 8. -pub fn looks_like_iff(b: &[u8]) -> bool { - b.get(0..4) == Some(b"FORM") && matches!(b.get(8..12), Some(b"ILBM" | b"PBM ")) -} - -/// Bitplanes of a "deep" ILBM: red, green and blue, 8 each, least significant bit first. -const DEEP_PLANES: u8 = 24; - -/// The bitmap header fields decoding needs. -struct Header { - width: u32, - height: u32, - planes: u8, - masking: u8, - compression: u8, - transparent: u16, - /// `PBM ` stores one palette index per byte, padded to even row lengths. - chunky: bool, -} - -/// One four-byte chunk's id and byte range. -struct Chunk<'a> { - id: [u8; 4], - data: &'a [u8], -} - -/// Walk the `FORM`'s chunks from offset 12 to `end` (the form length), stopping at the first -/// malformed length so a hostile file can't run past the buffer. -fn chunks(b: &[u8]) -> impl Iterator> { - let end = be32(b, 4).map_or(b.len(), |n| (n as usize).saturating_add(8).min(b.len())); - let mut pos = 12usize; - std::iter::from_fn(move || { - if pos + 8 > end { - return None; - } - let id = b.get(pos..pos + 4)?.try_into().ok()?; - let len = be32(b, pos + 4)? as usize; - let start = pos + 8; - let data = b.get(start..start.checked_add(len)?)?; - // Chunks are padded to an even length. - pos = start.checked_add(len)?.checked_add(len & 1)?; - Some(Chunk { id, data }) - }) -} - -fn parse_header(b: &[u8], chunky: bool) -> Result { - let bmhd = chunks(b).find(|c| &c.id == b"BMHD").ok_or_else(|| bad("no BMHD chunk"))?; - let d = bmhd.data; - if d.len() < 20 { - return Err(bad("BMHD chunk is too short")); - } - let width = u32::from(be16(d, 0).ok_or_else(|| bad("BMHD width"))?); - let height = u32::from(be16(d, 2).ok_or_else(|| bad("BMHD height"))?); - let planes = *d.get(8).ok_or_else(|| bad("BMHD planes"))?; - let masking = *d.get(9).ok_or_else(|| bad("BMHD masking"))?; - let compression = *d.get(10).ok_or_else(|| bad("BMHD compression"))?; - if width == 0 || height == 0 { - return Err(bad("zero-sized bitmap")); - } - if !(1..=8).contains(&planes) && planes != DEEP_PLANES { - return Err(unsupported(format!("{planes} bitplanes (1–8 with a palette, or 24)"))); - } - if masking > 2 { - return Err(unsupported(format!("masking {masking}"))); - } - if planes == DEEP_PLANES && masking == 2 { - return Err(unsupported("a transparent color in a 24-bitplane ILBM")); - } - if compression > 1 { - return Err(unsupported(format!("compression {compression} (only stored and ByteRun1)"))); - } - if chunky && (planes != 8 || masking == 1) { - return Err(unsupported("PBM requires 8-bit indices without a mask plane")); - } - let transparent = be16(d, 12).ok_or_else(|| bad("BMHD transparent colour"))?; - Ok(Header { width, height, planes, masking, compression, transparent, chunky }) -} - -/// ByteRun1 / PackBits decode of one plane row into `out`; returns the bytes consumed. A `0x80` -/// control byte is a no-op, as the layout specifies. -fn unpack_byte_run1(src: &[u8], out: &mut [u8]) -> Result { - let (mut i, mut o) = (0usize, 0usize); - while o < out.len() { - let n = *src.get(i).ok_or_else(|| bad("truncated ByteRun1 data"))? as i8; - i += 1; - if n >= 0 { - let count = n as usize + 1; - let lit = src.get(i..i.checked_add(count).ok_or_else(|| bad("ByteRun1 overflow"))?).ok_or_else(|| bad("truncated ByteRun1 run"))?; - if count > out.len() - o { - return Err(bad("ByteRun1 run crosses the plane row")); - } - out[o..o + count].copy_from_slice(lit); - i += count; - o += count; - } else if n != -128 { - let count = (1 - n as i32) as usize; - let value = *src.get(i).ok_or_else(|| bad("truncated ByteRun1 repeat"))?; - i += 1; - if count > out.len() - o { - return Err(bad("ByteRun1 repeat crosses the plane row")); - } - out[o..o + count].fill(value); - o += count; - } - } - Ok(i) -} - -pub fn decode(b: &[u8], limits: &Limits) -> Result { - if !looks_like_iff(b) { - return Err(bad("not an IFF/ILBM file (no FORM ... ILBM)")); - } - let h = parse_header(b, b.get(8..12) == Some(b"PBM "))?; - if let Some(camg) = chunks(b).find(|c| &c.id == b"CAMG") { - let mode = be32(camg.data, 0).ok_or_else(|| bad("short CAMG chunk"))?; - if mode & (0x80 | 0x800) != 0 { - return Err(unsupported("EHB and HAM viewport modes")); - } - } - let layout = if h.masking == 0 { ChannelLayout::Rgb } else { ChannelLayout::Rgba }; - limits.check(h.width, h.height, layout, SampleType::U8)?; - - // Palette: three bytes per colour; missing entries read as black. - let cmap = chunks(b).find(|c| &c.id == b"CMAP").map(|c| c.data).filter(|p| !p.is_empty()); - let colors = 1usize << h.planes; - let palette = |idx: usize| -> [u8; 3] { - if let Some(p) = cmap { - p.get(idx * 3..idx * 3 + 3).map(|c| [c[0], c[1], c[2]]).unwrap_or([0; 3]) - } else { - let v = ((idx as u32 * 255) / (colors as u32 - 1).max(1)) as u8; - [v, v, v] - } - }; - - let body = chunks(b).find(|c| &c.id == b"BODY").map(|c| c.data).ok_or_else(|| bad("no BODY chunk"))?; - let (w, hh) = (h.width as usize, h.height as usize); - // Each plane row is stored as a whole number of 16-bit words. - let plane_row = if h.chunky { w.div_ceil(2) * 2 } else { w.div_ceil(16) * 2 }; - // A masking type 1 bitmap carries one extra (mask) plane per row. - let rows_planes: usize = if h.chunky { 1 } else { usize::from(h.planes) + usize::from(h.masking == 1) }; - - // Decode every stored plane row up front, then recombine. - let total_rows = hh.checked_mul(rows_planes).ok_or_else(|| CodecError::LimitExceeded("bitmap too large".into()))?; - let total_bytes = total_rows.checked_mul(plane_row).ok_or_else(|| CodecError::LimitExceeded("bitmap too large".into()))?; - if total_bytes as u64 > limits.max_alloc { - return Err(CodecError::LimitExceeded("bitmap storage exceeds max_alloc".into())); - } - Limits::check_plausible(total_bytes as u64, body.len(), if h.compression == 0 { 1 } else { 128 })?; - let mut stored = crate::alloc_zeroed::(total_bytes)?; - let mut cursor = 0usize; - for row in stored.chunks_mut(plane_row.max(1)).take(total_rows) { - match h.compression { - 0 => { - let src = - body.get(cursor..cursor.checked_add(plane_row).ok_or_else(|| bad("BODY overflow"))?).ok_or_else(|| bad("truncated BODY data"))?; - let n = row.len().min(src.len()); - row[..n].copy_from_slice(&src[..n]); - cursor += plane_row; - } - _ => { - let tail = body.get(cursor..).ok_or_else(|| bad("truncated BODY data"))?; - cursor += unpack_byte_run1(tail, row)?; - } - } - } - - let mut out = Vec::new(); - out.try_reserve_exact(w.saturating_mul(hh).saturating_mul(layout.channels())) - .map_err(|_| CodecError::LimitExceeded("cannot allocate the image".into()))?; - let planes = usize::from(h.planes); - for y in 0..hh { - for x in 0..w { - let index = if h.chunky { - usize::from(*stored.get(y * plane_row + x).ok_or_else(|| bad("PBM pixel outside BODY"))?) - } else { - (0..planes).filter(|&p| bit_at(&stored, (y * rows_planes + p) * plane_row, x)).fold(0usize, |acc, p| acc | (1 << p)) - }; - let c = if h.planes == DEEP_PLANES { [index as u8, (index >> 8) as u8, (index >> 16) as u8] } else { palette(index) }; - out.extend_from_slice(&c); - if h.masking != 0 { - let opaque = - if h.masking == 1 { bit_at(&stored, (y * rows_planes + planes) * plane_row, x) } else { index != usize::from(h.transparent) }; - out.push(if opaque { 255 } else { 0 }); - } - } - } - Image::from_u8(h.width, h.height, layout, out) -} - -/// The bit for pixel `x` of a stored plane row at `base` (bits run MSB-first). -fn bit_at(stored: &[u8], base: usize, x: usize) -> bool { - stored.get(base + x / 8).is_some_and(|byte| byte & (0x80 >> (x % 8)) != 0) -} - -/// ByteRun1 / PackBits encode of one plane row, appended to `out`: three or more equal bytes -/// become a repeat (at most 128), everything else literal runs (at most 128 bytes). -fn pack_byte_run1(row: &[u8], out: &mut Vec) { - let mut i = 0usize; - while let Some(&value) = row.get(i) { - let repeat = row[i..].iter().take(128).take_while(|&&b| b == value).count(); - if repeat >= 3 { - out.push((1 - repeat as i32) as i8 as u8); - out.push(value); - i += repeat; - continue; - } - let start = i; - while i < row.len() && i - start < 128 { - if row.get(i..i + 3).is_some_and(|r| r[0] == r[1] && r[1] == r[2]) { - break; - } - i += 1; - } - out.push((i - start - 1) as u8); - out.extend_from_slice(&row[start..i]); - } -} - -fn push_chunk(out: &mut Vec, id: &[u8; 4], data: &[u8]) -> Result<(), CodecError> { - let len = u32::try_from(data.len()).map_err(|_| CodecError::encode(F, "chunk too large for an IFF file (4 GiB)"))?; - out.extend_from_slice(id); - out.extend_from_slice(&len.to_be_bytes()); - out.extend_from_slice(data); - // Chunks are padded to an even length. - if data.len() % 2 == 1 { - out.push(0); - } - Ok(()) -} - -/// Writes a 24-bitplane `FORM ILBM`: `BMHD` then a ByteRun1-compressed `BODY`, each row stored as -/// the red, green and blue planes (least significant bit first) and, for RGBA, a mask plane. -pub fn encode(img: &Image) -> Result, CodecError> { - let enc = |msg: String| CodecError::encode(F, msg); - let masked = match img.layout() { - ChannelLayout::Rgb => false, - ChannelLayout::Rgba => true, - l => return Err(enc(format!("IFF/ILBM cannot store {l:?}"))), - }; - if img.sample_type() != SampleType::U8 { - return Err(enc(format!("IFF/ILBM cannot store {:?} samples", img.sample_type()))); - } - let (w, h) = (img.width(), img.height()); - let (Ok(w16), Ok(h16)) = (u16::try_from(w), u16::try_from(h)) else { - return Err(enc("IFF/ILBM stores at most 65535 × 65535 pixels".into())); - }; - let (w, ch) = (w as usize, img.layout().channels()); - let data = img.data(); - let row_len = w.checked_mul(ch).ok_or_else(|| enc("image too large".into()))?; - if data.len() != row_len.checked_mul(h as usize).ok_or_else(|| enc("image too large".into()))? { - return Err(enc("the image has the wrong number of samples".into())); - } - let planes = usize::from(DEEP_PLANES) + usize::from(masked); - let mut plane_row = vec![0u8; w.div_ceil(16) * 2]; - let mut body = Vec::new(); - for px in data.chunks_exact(row_len.max(1)) { - for plane in 0..planes { - plane_row.fill(0); - for (x, p) in px.chunks_exact(ch).enumerate() { - let on = if plane == usize::from(DEEP_PLANES) { p[3] >= 128 } else { (p[plane / 8] >> (plane % 8)) & 1 == 1 }; - if on { - plane_row[x / 8] |= 0x80 >> (x % 8); - } - } - pack_byte_run1(&plane_row, &mut body); - } - } - - let mut bmhd = Vec::with_capacity(20); - bmhd.extend_from_slice(&w16.to_be_bytes()); - bmhd.extend_from_slice(&h16.to_be_bytes()); - bmhd.extend_from_slice(&[0, 0, 0, 0]); // x/y origin - bmhd.push(DEEP_PLANES); - bmhd.push(u8::from(masked)); // masking: 1 = a mask plane follows the color planes - bmhd.push(1); // ByteRun1 - bmhd.push(0); // pad - bmhd.extend_from_slice(&[0, 0]); // transparent color (unused) - bmhd.extend_from_slice(&[1, 1]); // square pixels - bmhd.extend_from_slice(&w16.to_be_bytes()); // page size - bmhd.extend_from_slice(&h16.to_be_bytes()); - - let mut out = b"FORM".to_vec(); - out.extend_from_slice(&[0; 4]); // patched below - out.extend_from_slice(b"ILBM"); - push_chunk(&mut out, b"BMHD", &bmhd)?; - push_chunk(&mut out, b"BODY", &body)?; - let form_len = u32::try_from(out.len() - 8).map_err(|_| enc("image too large for an IFF file (4 GiB)".into()))?; - out[4..8].copy_from_slice(&form_len.to_be_bytes()); - Ok(out) -} - -#[cfg(test)] -mod tests { - use super::*; - - /// A `FORM ILBM` with a `BMHD`, `CMAP` and `BODY`. `planes` plane rows per row, - /// `compression` 0 (stored) or 1 (ByteRun1), MSB-first. - fn ilbm(w: u16, h: u16, planes: u8, palette: &[[u8; 3]], compression: u8, body: &[u8]) -> Vec { - let mut b = b"FORM".to_vec(); - b.extend_from_slice(&0u32.to_be_bytes()); // patched below - b.extend_from_slice(b"ILBM"); - // BMHD (20 bytes) - b.extend_from_slice(b"BMHD"); - b.extend_from_slice(&20u32.to_be_bytes()); - b.extend_from_slice(&w.to_be_bytes()); - b.extend_from_slice(&h.to_be_bytes()); - b.extend_from_slice(&[0, 0, 0, 0]); // x/y origin - b.push(planes); - b.push(0); // masking - b.push(compression); - b.push(0); // pad - b.extend_from_slice(&[0, 0]); // transparent colour - b.extend_from_slice(&[1, 1]); // aspect - b.extend_from_slice(&[0, 0, 0, 0]); // page size - // CMAP - b.extend_from_slice(b"CMAP"); - b.extend_from_slice(&((palette.len() * 3) as u32).to_be_bytes()); - for c in palette { - b.extend_from_slice(c); - } - if palette.len() % 2 == 1 { - b.push(0); - } - // BODY - b.extend_from_slice(b"BODY"); - b.extend_from_slice(&(body.len() as u32).to_be_bytes()); - b.extend_from_slice(body); - if body.len() % 2 == 1 { - b.push(0); - } - let size = (b.len() - 8) as u32; - b[4..8].copy_from_slice(&size.to_be_bytes()); - b - } - - #[test] - fn reads_a_stored_two_plane_bitmap() { - // 2×1, 2 planes: pixel 0 index 0 (plane bits 0,0), pixel 1 index 3 (bits 1,1). - // Plane 0 = 0b0100_0000, plane 1 = 0b0100_0000, each padded to 2 bytes. - let body = [0b0100_0000, 0, 0b0100_0000, 0]; - let pal = [[10, 20, 30], [40, 50, 60], [70, 80, 90], [100, 110, 120]]; - let b = ilbm(2, 1, 2, &pal, 0, &body); - assert!(looks_like_iff(&b)); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!((img.width(), img.height(), img.layout()), (2, 1, ChannelLayout::Rgb)); - assert_eq!(img.data(), &[10, 20, 30, 100, 110, 120]); - } - - #[test] - fn reads_byte_run1_compressed_rows() { - // Same image, ByteRun1: literal run of two bytes (0x01) then the two plane bytes each row. - let body = [0x01, 0b0100_0000, 0, 0x01, 0b0100_0000, 0]; - let pal = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [250, 251, 252]]; - let b = ilbm(2, 1, 2, &pal, 1, &body); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[1, 2, 3, 250, 251, 252]); - } - - #[test] - fn no_palette_falls_back_to_a_grey_ramp() { - // 2×1, 1 plane, no CMAP: indices 0 and 1 → black and white. - let body = [0b0100_0000, 0]; - let b = ilbm(2, 1, 1, &[], 0, &body); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[0, 0, 0, 255, 255, 255]); - } - - #[test] - fn pbm_reads_chunky_indices_with_odd_width_padding() { - let pal = [[10, 20, 30], [40, 50, 60], [70, 80, 90]]; - for (compression, body) in [(0, vec![2, 0, 1, 255, 1, 2, 0, 255]), (1, vec![3, 2, 0, 1, 255, 3, 1, 2, 0, 255])] { - let mut b = ilbm(3, 2, 8, &pal, compression, &body); - b[8..12].copy_from_slice(b"PBM "); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.data(), &[70, 80, 90, 10, 20, 30, 40, 50, 60, 40, 50, 60, 70, 80, 90, 10, 20, 30]); - } - } - - #[test] - fn transparency_uses_the_mask_plane_or_transparent_index() { - for masking in [1, 2] { - let mut b = ilbm(2, 1, 1, &[[10, 20, 30], [40, 50, 60]], 0, if masking == 1 { &[0x40, 0, 0x40, 0] } else { &[0x40, 0] }); - b[29] = masking; - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!(img.layout(), ChannelLayout::Rgba); - assert_eq!(img.data(), &[10, 20, 30, 0, 40, 50, 60, 255]); - } - let mut b = ilbm(2, 1, 8, &[[10, 20, 30], [40, 50, 60]], 0, &[0, 1]); - b[8..12].copy_from_slice(b"PBM "); - b[29] = 2; - b[32..34].copy_from_slice(&1u16.to_be_bytes()); - assert_eq!(decode(&b, &Limits::default()).unwrap().data(), &[10, 20, 30, 255, 40, 50, 60, 0]); - } - - #[test] - fn rejects_ham_and_ehb_instead_of_returning_wrong_colours() { - for mode in [0x80u32, 0x800] { - let mut b = ilbm(1, 1, 1, &[], 0, &[0, 0]); - b.extend_from_slice(b"CAMG"); - b.extend_from_slice(&4u32.to_be_bytes()); - b.extend_from_slice(&mode.to_be_bytes()); - let len = (b.len() - 8) as u32; - b[4..8].copy_from_slice(&len.to_be_bytes()); - assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. }))); - } - } - - #[test] - fn missing_palette_entries_are_black() { - let b = ilbm(1, 1, 2, &[[10, 20, 30]], 0, &[0x80, 0, 0x80, 0]); - assert_eq!(decode(&b, &Limits::default()).unwrap().data(), &[0, 0, 0]); - } - - #[test] - fn reads_a_stored_24_plane_bitmap() { - // 2×1: pixel 0 = (1, 0, 128), pixel 1 = (0, 255, 0). Each plane row is 2 bytes; red bit 0 - // has pixel 0 set, green bits 0–7 have pixel 1 set, blue bit 7 has pixel 0 set. - let mut body = Vec::new(); - for plane in 0..24 { - let byte = match plane { - 0 | 23 => 0x80, - 8..=15 => 0x40, - _ => 0, - }; - body.extend_from_slice(&[byte, 0]); - } - let b = ilbm(2, 1, 24, &[], 0, &body); - let img = decode(&b, &Limits::default()).unwrap(); - assert_eq!((img.width(), img.height(), img.layout()), (2, 1, ChannelLayout::Rgb)); - assert_eq!(img.data(), &[1, 0, 128, 0, 255, 0]); - } - - #[test] - fn writes_24_plane_byte_run1_that_reads_back_exactly() { - // 37 pixels wide: three plane-row words, the last one partly padding. - let (w, h) = (37u32, 3u32); - let data: Vec = (0..w * h * 3).map(|i| (i * 7 % 256) as u8).collect(); - let img = Image::from_u8(w, h, ChannelLayout::Rgb, data.clone()).unwrap(); - let bytes = encode(&img).unwrap(); - assert!(looks_like_iff(&bytes)); - assert_eq!(be32(&bytes, 4).unwrap() as usize, bytes.len() - 8, "FORM length"); - let h = parse_header(&bytes, false).unwrap(); - assert_eq!((h.width, h.height, h.planes, h.masking, h.compression), (37, 3, 24, 0, 1)); - assert!(chunks(&bytes).all(|c| &c.id != b"CMAP"), "a deep ILBM has no palette"); - let back = decode(&bytes, &Limits::default()).unwrap(); - assert_eq!(back.layout(), ChannelLayout::Rgb); - assert_eq!(back.data(), &data[..]); - } - - #[test] - fn alpha_is_written_as_a_mask_plane() { - let data = [10, 20, 30, 0, 40, 50, 60, 127, 70, 80, 90, 128, 1, 2, 3, 255]; - let img = Image::from_u8(4, 1, ChannelLayout::Rgba, data.to_vec()).unwrap(); - let bytes = encode(&img).unwrap(); - assert_eq!(parse_header(&bytes, false).unwrap().masking, 1); - let back = decode(&bytes, &Limits::default()).unwrap(); - assert_eq!(back.layout(), ChannelLayout::Rgba); - assert_eq!(back.data(), &[10, 20, 30, 0, 40, 50, 60, 0, 70, 80, 90, 255, 1, 2, 3, 255]); - } - - #[test] - fn byte_run1_round_trips_runs_literals_and_long_rows() { - let mut rows: Vec> = vec![vec![], vec![5], vec![5, 5], vec![5, 5, 5], vec![1, 2, 2, 2, 3], vec![9; 300]]; - rows.push((0..300).map(|i| (i % 251) as u8).collect()); - rows.push([vec![1, 2], vec![7; 129], vec![3]].concat()); - for row in rows { - let mut packed = Vec::new(); - pack_byte_run1(&row, &mut packed); - let mut back = vec![0; row.len()]; - assert_eq!(unpack_byte_run1(&packed, &mut back).unwrap(), packed.len(), "{row:?}"); - assert_eq!(back, row); - } - // A long repeat packs into two-byte runs. - let mut packed = Vec::new(); - pack_byte_run1(&[0; 256], &mut packed); - assert_eq!(packed, [0x81, 0, 0x81, 0]); - } - - #[test] - fn rejects_what_ilbm_cannot_store() { - let gray = Image::from_u8(1, 1, ChannelLayout::Gray, vec![0]).unwrap(); - assert!(encode(&gray).is_err()); - let wide = Image::from_u8(65536, 1, ChannelLayout::Rgb, vec![0; 65536 * 3]).unwrap(); - assert!(encode(&wide).is_err()); - // A transparent color index has no meaning without a palette. - let mut b = ilbm(1, 1, 24, &[], 0, &[0; 48]); - b[29] = 2; - assert!(matches!(decode(&b, &Limits::default()), Err(CodecError::Unsupported { .. }))); - } - - #[test] - fn hostile_input_errors_not_panics() { - // Truncations of a valid file never panic. - let body = [0b0100_0000, 0, 0b0100_0000, 0]; - let full = ilbm(2, 1, 2, &[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], 0, &body); - for cut in [0, 4, 8, 12, 40, full.len() - 1] { - assert!(decode(&full[..cut.min(full.len())], &Limits::default()).is_err(), "cut {cut}"); - } - // Too many planes is unsupported. - let bad = ilbm(1, 1, 9, &[], 0, &[0, 0]); - assert!(matches!(decode(&bad, &Limits::default()), Err(CodecError::Unsupported { .. }))); - } +pub fn encode(image: &Image) -> Result, CodecError> { + bridge::encode(image, Format::Iff, &Default::default()) } diff --git a/crates/raster-codecs/src/lib.rs b/crates/raster-codecs/src/lib.rs index 5b335a30c..7e705da99 100644 --- a/crates/raster-codecs/src/lib.rs +++ b/crates/raster-codecs/src/lib.rs @@ -18,10 +18,10 @@ #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +mod bridge; /// Common bounded decoding and PNG/JPEG encoding for common image formats. pub mod common; pub mod dds; -mod dds_bc; pub mod dicom; pub mod fits; pub mod iff; @@ -215,47 +215,32 @@ impl Limits { /// Validates declared dimensions for an output buffer of the given layout and sample type. pub fn check(&self, width: u32, height: u32, layout: ChannelLayout, sample: SampleType) -> Result<(), CodecError> { - if width == 0 || height == 0 { - return Err(CodecError::InvalidImage(format!("zero-sized image {width}x{height}"))); - } - if width > self.max_width || height > self.max_height { - return Err(CodecError::LimitExceeded(format!("dimensions {width}x{height} exceed max {}x{}", self.max_width, self.max_height))); - } - let pixels = width as u64 * height as u64; - if pixels > self.max_pixels { - return Err(CodecError::LimitExceeded(format!("{pixels} pixels exceed max {}", self.max_pixels))); - } - let bytes = pixels.saturating_mul((layout.channels() * sample.bytes()) as u64); - if bytes > self.max_alloc { - return Err(CodecError::LimitExceeded(format!("{bytes} bytes exceed max_alloc {}", self.max_alloc))); - } - if usize::try_from(bytes).is_err() { - return Err(CodecError::LimitExceeded(format!("{bytes} bytes do not fit in memory"))); - } - Ok(()) + let layout = match layout { + ChannelLayout::Gray => craft_image_codecs::ChannelLayout::Gray, + ChannelLayout::GrayA => craft_image_codecs::ChannelLayout::GrayA, + ChannelLayout::Rgb => craft_image_codecs::ChannelLayout::Rgb, + ChannelLayout::Rgba => craft_image_codecs::ChannelLayout::Rgba, + ChannelLayout::Cmyk => craft_image_codecs::ChannelLayout::Cmyk, + ChannelLayout::CmykA => craft_image_codecs::ChannelLayout::CmykA, + }; + let sample = match sample { + SampleType::U8 => craft_image_codecs::SampleType::U8, + SampleType::U16 => craft_image_codecs::SampleType::U16, + SampleType::F32 => craft_image_codecs::SampleType::F32, + }; + craft_image_codecs::Limits::new(self.max_width, self.max_height, self.max_pixels, self.max_alloc) + .check(width, height, layout, sample) + .map_err(crate::bridge::from_shared_error) } /// Decompression-bomb guard for formats that compress: refuses a file too small to hold /// `declared_bytes` of stored image data when the compression never beats `max_ratio`:1. /// Called before the output buffer is allocated. 1 MiB of slack leaves tiny images alone. - pub(crate) fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> { - let capacity = (file_len as u64).saturating_mul(max_ratio).saturating_add(1 << 20); - if declared_bytes > capacity { - return Err(CodecError::LimitExceeded(format!("a {file_len} byte file cannot hold {declared_bytes} bytes of image data"))); - } - Ok(()) + pub fn check_plausible(declared_bytes: u64, file_len: usize, max_ratio: u64) -> Result<(), CodecError> { + craft_image_codecs::Limits::check_plausible(declared_bytes, file_len, max_ratio).map_err(crate::bridge::from_shared_error) } } -/// A zero-filled buffer of `len` elements, allocated fallibly: an allocation failure is -/// [`CodecError::LimitExceeded`] instead of an abort. -pub(crate) fn alloc_zeroed(len: usize) -> Result, CodecError> { - let mut v = Vec::new(); - v.try_reserve_exact(len).map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {len} elements for the image")))?; - v.resize(len, T::default()); - Ok(v) -} - #[cfg(test)] mod tests { use super::*; diff --git a/crates/raster-codecs/src/pcx.rs b/crates/raster-codecs/src/pcx.rs index 00117bcf1..61c476511 100644 --- a/crates/raster-codecs/src/pcx.rs +++ b/crates/raster-codecs/src/pcx.rs @@ -1,144 +1,13 @@ -//! ZSoft PCX (Paintbrush) reader: strictly bounded scanline RLE, 16/256-colour -//! palettes, 8-bit three-plane RGB and four-plane RGBA. Read-only: modern saves should use PNG. +//! PCX compatibility facade; implementation and header probing live in craft-image-codecs. +use crate::{CodecError, Image, Limits, bridge}; +use craft_image_codecs::Format; -use crate::{ChannelLayout, CodecError, Image, Limits, SampleType}; - -const HEADER: usize = 128; - -fn bad(reason: impl std::fmt::Display) -> CodecError { - CodecError::malformed("PCX", reason) +pub fn looks_like_pcx(bytes: &[u8]) -> bool { + craft_image_codecs::detect(bytes) == Some(Format::Pcx) } -fn le16(b: &[u8], i: usize) -> u16 { - u16::from_le_bytes([b[i], b[i + 1]]) +pub fn dimensions(bytes: &[u8]) -> Option<(u32, u32)> { + craft_image_codecs::pcx_dimensions(bytes) } - -/// PCX lacks a strong magic number. Require plausible complete header fields before -/// identifying it, rather than classifying every file starting with 0x0a as PCX. -pub fn looks_like_pcx(b: &[u8]) -> bool { - if b.len() < HEADER || b[0] != 0x0a || !matches!(b[1], 0 | 2..=5) || b[2] != 1 { - return false; - } - let bits = b[3]; - let planes = b[65]; - let stride = u32::from(le16(b, 66)); - let (x0, y0, x1, y1) = (le16(b, 4), le16(b, 6), le16(b, 8), le16(b, 10)); - if x1 < x0 || y1 < y0 || !matches!(bits, 1 | 2 | 4 | 8) || !(1..=4).contains(&planes) { - return false; - } - let width = u32::from(x1 - x0) + 1; - let min_stride = (width * u32::from(bits)).div_ceil(8); - stride >= min_stride && stride > 0 && (bits != 8 || matches!(planes, 1 | 3 | 4)) && (bits == 8 || u32::from(bits) * u32::from(planes) <= 4) -} - -/// Read one compressed scanline, including all planes. RLE packets never cross a scanline. -fn read_row(b: &[u8], pos: &mut usize, out: &mut [u8]) -> Result<(), CodecError> { - let mut n = 0; - while n < out.len() { - let code = *b.get(*pos).ok_or_else(|| bad("truncated pixel RLE"))?; - *pos += 1; - let (count, value) = if code >= 0xc0 { - let count = usize::from(code & 0x3f); - let value = *b.get(*pos).ok_or_else(|| bad("truncated RLE packet"))?; - *pos += 1; - (count, value) - } else { - (1, code) - }; - if count == 0 || count > out.len() - n { - return Err(bad("RLE packet crosses a scanline or has zero length")); - } - out[n..n + count].fill(value); - n += count; - } - Ok(()) -} - -/// The pixel size a PCX header declares, without decoding; `None` when [`looks_like_pcx`] is false. -pub fn dimensions(b: &[u8]) -> Option<(u32, u32)> { - looks_like_pcx(b).then(|| (u32::from(le16(b, 8) - le16(b, 4)) + 1, u32::from(le16(b, 10) - le16(b, 6)) + 1)) -} - -/// Decodes to 8-bit RGB, or RGBA for four 8-bit planes (red, green, blue, alpha). -pub fn decode(b: &[u8], limits: &Limits) -> Result { - let (w, h) = dimensions(b).ok_or_else(|| bad("invalid PCX header or unsupported pixel layout"))?; - let (bits, planes, stride) = (usize::from(b[3]), usize::from(b[65]), usize::from(le16(b, 66))); - let layout = if bits == 8 && planes == 4 { ChannelLayout::Rgba } else { ChannelLayout::Rgb }; - let ch = layout.channels(); - limits.check(w, h, layout, SampleType::U8)?; - let row_len = stride.checked_mul(planes).ok_or_else(|| bad("row size overflow"))?; - let total = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(ch)).ok_or_else(|| bad("pixel size overflow"))?; - // The last 769 bytes are the optional VGA palette for 8-bit indexed images. - let vga = bits == 8 && planes == 1 && b.len() >= HEADER + 769 && b[b.len() - 769] == 0x0c; - if bits == 8 && planes == 1 && !vga && le16(b, 68) != 2 { - return Err(bad("8-bit indexed PCX has no 256-colour palette")); - } - let image_end = if vga { b.len() - 769 } else { b.len() }; - // A 63-byte RLE packet takes 2 bytes; a trailing remainder of 1 byte below 0xC0 - // can be encoded as a 1-byte literal, while any larger remainder takes at least 2 bytes. - // Because RLE packets may span planes within a scanline (`row_len`), compute the - // minimum encoded bytes across the full scanline (`row_len`) and multiply by `h`. - // Reject inputs that cannot possibly contain all scanlines before allocating - // the decoded image buffer. - let min_packets = (row_len / 63) - .checked_mul(2) - .and_then(|n| { - n.checked_add(match row_len % 63 { - 0 => 0, - 1 => 1, - _ => 2, - }) - }) - .ok_or_else(|| bad("compressed row size overflow"))?; - let min_encoded = min_packets.checked_mul(h as usize).ok_or_else(|| bad("compressed image size overflow"))?; - let encoded_len = image_end.saturating_sub(HEADER); - if encoded_len < min_encoded { - return Err(bad("PCX pixel data is too short for the declared image")); - } - let mut row = vec![0u8; row_len]; - let mut pixels = Vec::new(); - pixels.try_reserve_exact(total).map_err(|_| bad("PCX pixel buffer is too large"))?; - pixels.resize(total, 0); - let mut p = HEADER; - let width = w as usize; - for y in 0..h as usize { - read_row(&b[..image_end], &mut p, &mut row)?; - for x in 0..width { - let at = (y * width + x) * ch; - let rgb = if bits == 8 && planes >= 3 { - if planes == 4 { - pixels[at + 3] = row[3 * stride + x]; - } - [row[x], row[stride + x], row[2 * stride + x]] - } else { - let index = if bits == 8 { - usize::from(row[x]) - } else { - let bit = x * bits; - let shift = 8 - bits - (bit % 8); - let mask = (1usize << bits) - 1; - (0..planes).fold(0usize, |v, plane| { - let sample = (usize::from(row[plane * stride + bit / 8]) >> shift) & mask; - v | sample << (plane * bits) - }) - }; - if vga { - let o = image_end + 1 + index * 3; - [b[o], b[o + 1], b[o + 2]] - } else if bits == 8 { - let g = index as u8; - [g, g, g] // palette-info 2: gray scale - } else { - let o = 16 + index * 3; - [b[o], b[o + 1], b[o + 2]] - } - }; - pixels[at..at + 3].copy_from_slice(&rgb); - } - } - let mut image = Image::from_u8(w, h, layout, pixels)?; - let (xdpi, ydpi) = (le16(b, 12), le16(b, 14)); - if xdpi > 0 && ydpi > 0 { - image.dpi = Some((f32::from(xdpi), f32::from(ydpi))); - } - Ok(image) +pub fn decode(bytes: &[u8], limits: &Limits) -> Result { + bridge::format(Format::Pcx, bytes, limits) } diff --git a/crates/raster-codecs/src/pnm.rs b/crates/raster-codecs/src/pnm.rs index 6ef140902..834e6508a 100644 --- a/crates/raster-codecs/src/pnm.rs +++ b/crates/raster-codecs/src/pnm.rs @@ -1,357 +1,13 @@ -//! Netpbm family, implemented here: P1–P6 (PBM/PGM/PPM, ASCII and binary), -//! P7 (PAM, including the common `CMYK`/`CMYK_ALPHA` tuple types) and PFM -//! (`PF` colour / `Pf` gray float). -//! -//! Writing picks the subtype from the image: float → PFM (gray/RGB), gray -//! → P5, RGB → P6, anything with alpha or CMYK → P7. +//! Netpbm compatibility facade; implementation and bounds live in craft-image-codecs. +use crate::{CodecError, Image, Limits, bridge}; +use craft_image_codecs::Format; -use crate::{ChannelLayout, CodecError, Image, Limits, SampleType}; - -const F: &str = "PNM"; - -fn err(msg: impl std::fmt::Display) -> CodecError { - CodecError::malformed(F, msg) +pub fn looks_like_pnm(bytes: &[u8]) -> bool { + craft_image_codecs::detect(bytes) == Some(Format::Pnm) } - -struct Reader<'a> { - b: &'a [u8], - pos: usize, -} - -impl<'a> Reader<'a> { - fn skip_ws_and_comments(&mut self) { - while self.pos < self.b.len() { - let c = self.b[self.pos]; - if c == b'#' { - while self.pos < self.b.len() && self.b[self.pos] != b'\n' && self.b[self.pos] != b'\r' { - self.pos += 1; - } - } else if c.is_ascii_whitespace() { - self.pos += 1; - } else { - break; - } - } - } - - fn token(&mut self) -> Result<&'a [u8], CodecError> { - self.skip_ws_and_comments(); - let start = self.pos; - while self.pos < self.b.len() && !self.b[self.pos].is_ascii_whitespace() && self.b[self.pos] != b'#' { - self.pos += 1; - } - if start == self.pos { - return Err(err("unexpected end of header")); - } - Ok(&self.b[start..self.pos]) - } - - fn uint(&mut self) -> Result { - let t = self.token()?; - std::str::from_utf8(t).ok().and_then(|s| s.parse::().ok()).ok_or_else(|| err("invalid integer in header")) - } - - /// Consume the single whitespace byte that separates header and raster. - fn single_ws(&mut self) -> Result<(), CodecError> { - match self.b.get(self.pos) { - Some(c) if c.is_ascii_whitespace() => { - self.pos += 1; - Ok(()) - } - _ => Err(err("missing whitespace after header")), - } - } - - /// PAM ends its header with an LF-terminated line, unlike P4–P6's single separator. - fn pam_endhdr(&mut self) -> Result<(), CodecError> { - while let Some(&c) = self.b.get(self.pos) { - self.pos += 1; - if c == b'\n' { - // Stop at the first LF: whitespace and '#' after it are raster bytes. - return Ok(()); - } - if !c.is_ascii_whitespace() { - return Err(err("unexpected data after PAM ENDHDR")); - } - } - Err(err("unterminated PAM ENDHDR line")) - } - - fn rest(&self) -> &'a [u8] { - &self.b[self.pos.min(self.b.len())..] - } -} - -fn sample_for_maxval(maxval: u32) -> Result { - match maxval { - 1..=255 => Ok(SampleType::U8), - 256..=65535 => Ok(SampleType::U16), - _ => Err(err(format!("invalid maxval {maxval}"))), - } -} - -/// The decoded raster, built straight in the output representation. It is the only buffer sized -/// by the header, so `Limits::check` on the output budgets all of it: no wider scratch buffer -/// (such as one `u32` per sample) sits beside it. -struct Samples { - maxval: u32, - sample: SampleType, - bytes: Vec, -} - -impl Samples { - /// Reserve room for `cap` samples (callers bound `cap` by the file length where the header - /// alone could overstate it). - fn with_capacity(maxval: u32, cap: usize) -> Result { - let sample = sample_for_maxval(maxval)?; - let len = cap.checked_mul(sample.bytes()).ok_or_else(|| CodecError::LimitExceeded(format!("{cap} samples do not fit in memory")))?; - let mut bytes = Vec::new(); - bytes.try_reserve_exact(len).map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {len} bytes for the image")))?; - Ok(Samples { maxval, sample, bytes }) - } - - /// Append one raw value in `[0, maxval]`, rescaled to the full range of the output sample. - fn push(&mut self, v: u32) -> Result<(), CodecError> { - let m = self.maxval; - if v > m { - return Err(err("sample exceeds maxval")); - } - match (self.sample, m) { - (SampleType::U8, 255) => self.bytes.push(v as u8), - (SampleType::U8, m) => self.bytes.push(((v * 255 + m / 2) / m) as u8), - (_, 65535) => self.bytes.extend_from_slice(&(v as u16).to_ne_bytes()), - (_, m) => self.bytes.extend_from_slice(&(((v as u64 * 65535 + m as u64 / 2) / m as u64) as u16).to_ne_bytes()), - } - Ok(()) - } - - fn into_image(self, w: u32, h: u32, layout: ChannelLayout) -> Result { - Image::from_raw(w, h, layout, self.sample, self.bytes) - } -} - -/// `w × h × channels` samples. `Limits::none()` lets any header through, so the product is -/// checked here rather than trusted to the limits. -fn sample_count(w: u32, h: u32, channels: usize) -> Result { - (w as usize) - .checked_mul(h as usize) - .and_then(|p| p.checked_mul(channels)) - .ok_or_else(|| CodecError::LimitExceeded(format!("{w}x{h}x{channels} samples do not fit in memory"))) -} - -fn read_binary(data: &[u8], n: usize, maxval: u32) -> Result { - let mut out = Samples::with_capacity(maxval, n)?; - if maxval < 256 { - let Some(raw) = data.get(..n) else { - return Err(err("truncated raster")); - }; - for &v in raw { - out.push(v as u32)?; - } - } else { - let Some(raw) = n.checked_mul(2).and_then(|len| data.get(..len)) else { - return Err(err("truncated raster")); - }; - for c in raw.as_chunks::<2>().0 { - out.push(u16::from_be_bytes(*c) as u32)?; - } - } - Ok(out) -} - -/// `P1`..`P7`, `PF` or `Pf` followed by white space. -pub fn looks_like_pnm(b: &[u8]) -> bool { - matches!(b, [b'P', b'1'..=b'7' | b'F' | b'f', s, ..] if s.is_ascii_whitespace()) -} - pub fn decode(bytes: &[u8], limits: &Limits) -> Result { - if bytes.len() < 2 || bytes[0] != b'P' { - return Err(err("not a Netpbm file")); - } - let kind = bytes[1]; - let mut r = Reader { b: bytes, pos: 2 }; - match kind { - b'1' | b'4' => { - let (w, h) = (r.uint()?, r.uint()?); - limits.check(w, h, ChannelLayout::Gray, SampleType::U8)?; - let n = sample_count(w, h, 1)?; - let mut px; - if kind == b'4' { - r.single_ws()?; - let row = (w as usize).div_ceil(8); - let data = r.rest(); - if row.checked_mul(h as usize).is_none_or(|len| data.len() < len) { - return Err(err("truncated raster")); - } - px = Vec::with_capacity(n); - for y in 0..h as usize { - for x in 0..w as usize { - let bit = (data[y * row + x / 8] >> (7 - x % 8)) & 1; - px.push(if bit == 1 { 0 } else { 255 }); - } - } - } else { - // Each ASCII pixel takes at least a byte, so the file bounds the reservation. - px = Vec::with_capacity(n.min(r.rest().len())); - while px.len() < n { - r.skip_ws_and_comments(); - match r.b.get(r.pos) { - Some(b'0') => px.push(255), - Some(b'1') => px.push(0), - Some(_) => return Err(err("invalid PBM digit")), - None => return Err(err("truncated raster")), - } - r.pos += 1; - } - } - Image::from_u8(w, h, ChannelLayout::Gray, px) - } - b'2' | b'3' | b'5' | b'6' => { - let (w, h, maxval) = (r.uint()?, r.uint()?, r.uint()?); - let layout = if matches!(kind, b'2' | b'5') { ChannelLayout::Gray } else { ChannelLayout::Rgb }; - limits.check(w, h, layout, sample_for_maxval(maxval)?)?; - let n = sample_count(w, h, layout.channels())?; - let samples = if matches!(kind, b'5' | b'6') { - r.single_ws()?; - read_binary(r.rest(), n, maxval)? - } else { - // Each ASCII sample is a digit and a separator (the last may lack one), so the - // file, not the header, bounds the reservation. - let mut v = Samples::with_capacity(maxval, n.min(r.rest().len() / 2 + 1))?; - for _ in 0..n { - v.push(r.uint()?)?; - } - v - }; - samples.into_image(w, h, layout) - } - b'7' => decode_pam(&mut r, limits), - b'F' | b'f' => { - let layout = if kind == b'F' { ChannelLayout::Rgb } else { ChannelLayout::Gray }; - let (w, h) = (r.uint()?, r.uint()?); - let scale: f32 = std::str::from_utf8(r.token()?) - .ok() - .and_then(|s| s.parse().ok()) - .filter(|s: &f32| s.is_finite() && *s != 0.0) - .ok_or_else(|| err("invalid PFM scale"))?; - r.single_ws()?; - limits.check(w, h, layout, SampleType::F32)?; - let nc = layout.channels(); - let row = w as usize * nc; - let data = r.rest(); - if sample_count(w, h, nc)?.checked_mul(4).is_none_or(|len| data.len() < len) { - return Err(err("truncated raster")); - } - let le = scale < 0.0; - // Write native-endian bytes straight into the output buffer: a separate `Vec` - // would double the budgeted allocation. - let row_bytes = row * 4; - let mut out = vec![0u8; row_bytes * h as usize]; - for (y, src) in data.chunks_exact(row_bytes).take(h as usize).enumerate() { - // PFM rows are stored bottom-to-top. - let dst_start = (h as usize - 1 - y) * row_bytes; - let Some(dst) = out.get_mut(dst_start..dst_start + row_bytes) else { - return Err(err("truncated raster")); - }; - for (d, s) in dst.as_chunks_mut::<4>().0.iter_mut().zip(src.as_chunks::<4>().0) { - let v = if le { f32::from_le_bytes(*s) } else { f32::from_be_bytes(*s) }; - *d = v.to_ne_bytes(); - } - } - Image::from_raw(w, h, layout, SampleType::F32, out) - } - _ => Err(err("unknown Netpbm subtype")), - } + bridge::format(Format::Pnm, bytes, limits) } - -fn decode_pam(r: &mut Reader<'_>, limits: &Limits) -> Result { - let (mut w, mut h, mut depth, mut maxval) = (None, None, None, None); - let mut tupltype = String::new(); - loop { - let tok = r.token()?; - match tok { - b"WIDTH" => w = Some(r.uint()?), - b"HEIGHT" => h = Some(r.uint()?), - b"DEPTH" => depth = Some(r.uint()?), - b"MAXVAL" => maxval = Some(r.uint()?), - b"TUPLTYPE" => { - let t = r.token()?; - if !tupltype.is_empty() { - tupltype.push(' '); - } - tupltype.push_str(std::str::from_utf8(t).map_err(|_| err("bad TUPLTYPE"))?); - } - b"ENDHDR" => break, - _ => return Err(err("unknown PAM header field")), - } - } - r.pam_endhdr()?; - let (w, h, depth, maxval) = match (w, h, depth, maxval) { - (Some(a), Some(b), Some(c), Some(d)) => (a, b, c, d), - _ => return Err(err("incomplete PAM header")), - }; - let layout = match (tupltype.as_str(), depth) { - ("BLACKANDWHITE" | "GRAYSCALE", 1) | ("", 1) => ChannelLayout::Gray, - ("BLACKANDWHITE_ALPHA" | "GRAYSCALE_ALPHA", 2) | ("", 2) => ChannelLayout::GrayA, - ("RGB", 3) | ("", 3) => ChannelLayout::Rgb, - ("RGB_ALPHA", 4) | ("", 4) => ChannelLayout::Rgba, - ("CMYK", 4) => ChannelLayout::Cmyk, - ("CMYK_ALPHA", 5) => ChannelLayout::CmykA, - (t, d) => { - return Err(CodecError::unsupported(F, format!("PAM tuple type {t:?} with depth {d}"))); - } - }; - limits.check(w, h, layout, sample_for_maxval(maxval)?)?; - let n = sample_count(w, h, layout.channels())?; - read_binary(r.rest(), n, maxval)?.into_image(w, h, layout) -} - -/// Writes `img` as PGM/PPM (gray, RGB), PAM (alpha, CMYK) or PFM (float gray, RGB). -pub fn encode(img: &Image) -> Result, CodecError> { - let (w, h) = (img.width(), img.height()); - let layout = img.layout(); - let mut out = Vec::new(); - match img.sample_type() { - SampleType::F32 => { - let tag = match layout { - ChannelLayout::Gray => "Pf", - ChannelLayout::Rgb => "PF", - l => return Err(CodecError::encode(F, format!("PFM cannot store {l:?}"))), - }; - out.extend_from_slice(format!("{tag}\n{w} {h}\n-1.0\n").as_bytes()); - let s = img.to_f32_samples().unwrap_or_default(); - let row = w as usize * layout.channels(); - for y in (0..h as usize).rev() { - for v in &s[y * row..(y + 1) * row] { - out.extend_from_slice(&v.to_le_bytes()); - } - } - } - sample @ (SampleType::U8 | SampleType::U16) => { - let maxval = if sample == SampleType::U8 { 255 } else { 65535 }; - match layout { - ChannelLayout::Gray => out.extend_from_slice(format!("P5\n{w} {h}\n{maxval}\n").as_bytes()), - ChannelLayout::Rgb => out.extend_from_slice(format!("P6\n{w} {h}\n{maxval}\n").as_bytes()), - l => { - let t = match l { - ChannelLayout::GrayA => "GRAYSCALE_ALPHA", - ChannelLayout::Rgba => "RGB_ALPHA", - ChannelLayout::Cmyk => "CMYK", - _ => "CMYK_ALPHA", - }; - out.extend_from_slice( - format!("P7\nWIDTH {w}\nHEIGHT {h}\nDEPTH {}\nMAXVAL {maxval}\nTUPLTYPE {t}\nENDHDR\n", l.channels()).as_bytes(), - ); - } - } - if sample == SampleType::U8 { - out.extend_from_slice(img.data()); - } else { - for v in img.to_u16_samples().unwrap_or_default() { - out.extend_from_slice(&v.to_be_bytes()); - } - } - } - } - Ok(out) +pub fn encode(image: &Image) -> Result, CodecError> { + bridge::encode(image, Format::Pnm, &Default::default()) } diff --git a/crates/raster-codecs/src/xpm.rs b/crates/raster-codecs/src/xpm.rs index 05d93cd75..2d49a2d63 100644 --- a/crates/raster-codecs/src/xpm.rs +++ b/crates/raster-codecs/src/xpm.rs @@ -1,243 +1,13 @@ -//! X PixMap reader for XPM2 plain-text icons and XPM3 C-source icon arrays. -//! Supports transparency (None), RGB hex at 4/8/16 bits per channel and -//! common X11 colour names. Does not execute C code. +//! XPM compatibility facade; implementation and color-name data live in craft-image-codecs. +use crate::{CodecError, Image, Limits, bridge}; +use craft_image_codecs::Format; -use std::collections::HashMap; - -mod x11_colors; - -use crate::{ChannelLayout, CodecError, Image, Limits, SampleType}; - -const MAX_SOURCE: usize = 256 << 20; -const MAX_COLOURS: usize = 65_536; -const MAX_CPP: usize = 8; - -fn bad(msg: impl std::fmt::Display) -> CodecError { - CodecError::malformed("XPM", msg) -} - -/// Extract C string literals without treating quoted text or // in a string as a comment. -/// XPM uses one literal for the header, each palette entry and each row. -fn c_strings(bytes: &[u8]) -> Result>, CodecError> { - let mut lines = Vec::new(); - let mut i = 0usize; - while i < bytes.len() { - if bytes[i..].starts_with(b"/*") { - let tail = &bytes[i + 2..]; - let Some(end) = tail.windows(2).position(|p| p == b"*/") else { return Err(bad("unterminated C comment")) }; - i += end + 4; - } else if bytes[i..].starts_with(b"//") { - i += bytes[i..].iter().position(|&c| c == b'\n').unwrap_or(bytes.len() - i); - } else if bytes[i] == b'"' { - i += 1; - let mut s = Vec::new(); - let mut closed = false; - while i < bytes.len() { - let c = bytes[i]; - i += 1; - match c { - b'"' => { - closed = true; - break; - } - b'\\' => { - let next = *bytes.get(i).ok_or_else(|| bad("truncated C escape"))?; - i += 1; - s.push(match next { - b'n' => b'\n', - b'r' => b'\r', - b't' => b'\t', - b'0' => 0, - _ => next, // quoted backslash or quote - }); - } - _ => s.push(c), - } - } - if !closed { - return Err(bad("unterminated XPM string")); - } - lines.push(s); - } else { - i += 1; - } - } - Ok(lines) -} - -/// Extract XPM2's plain-text lines without trimming pixel rows: leading and -/// trailing spaces can be palette keys, and physical CRLF is not image data. -fn xpm2_lines(bytes: &[u8]) -> Result>, CodecError> { - let mut input = bytes.split(|&b| b == b'\n'); - let header = input.next().ok_or_else(|| bad("missing XPM2 marker"))?; - if header.strip_suffix(b"\r").unwrap_or(header) != b"! XPM2" { - return Err(bad("not an XPM2 image")); - } - let mut lines = Vec::new(); - for raw in input { - let line = raw.strip_suffix(b"\r").unwrap_or(raw); - // The header may be preceded by comments and blank lines. After the - // header, a leading '!' is allowed as a palette key or pixel value. - if lines.is_empty() && (line.is_empty() || line.starts_with(b"!")) { - continue; - } - lines.push(line.to_vec()); - } - Ok(lines) -} - -fn channel(hex: &str) -> Option { - let v = u32::from_str_radix(hex, 16).ok()?; - let max = (1u32 << (hex.len() * 4)) - 1; - Some(((v * 255 + max / 2) / max) as u8) -} - -fn named(name: &str) -> Option<[u8; 3]> { - let s = name.to_ascii_lowercase().replace([' ', '-', '_'], ""); - // XPM imports X11 names, whose RGB values differ from CSS for names - // such as gray, maroon and purple. Keep these exact rather than guessing. - if let Ok(index) = x11_colors::X11_COLORS.binary_search_by_key(&s.as_str(), |(name, _)| *name) { - return Some(x11_colors::X11_COLORS[index].1); - } - // Retain useful web color aliases not present in the X11 database. - Some(match s.as_str() { - "silver" => [192, 192, 192], - "olive" => [128, 128, 0], - "teal" => [0, 128, 128], - "fuchsia" => [255, 0, 255], - "navyblue" => [0, 0, 128], - _ => return None, - }) -} - -/// Look up an exact normalized X11 color name as RGB channels in `0..=1`. -/// -/// Names must contain 1–64 bytes of lowercase ASCII letters or digits. Unknown names, -/// unnormalized names and XPM-only aliases return `None`; this does not parse hex colors -/// or transparency. Values are the stored X11 bytes divided by 255, without CSS overrides -/// or color-space conversion. XPM decoding retains its own normalization and alias policy. pub fn x11_color_rgb(name: &str) -> Option<[f32; 3]> { - // Bound work on untrusted names before searching the shared table, without allocating. - if name.is_empty() || name.len() > 64 || !name.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit()) { - return None; - } - let index = x11_colors::X11_COLORS.binary_search_by_key(&name, |(entry, _)| *entry).ok()?; - let (_, rgb) = x11_colors::X11_COLORS.get(index)?; - Some(rgb.map(|channel| f32::from(channel) / 255.0)) + craft_image_codecs::xpm_named_color_rgb(name) } - -fn color(name: &str) -> Option<[u8; 4]> { - if name.eq_ignore_ascii_case("none") { - return Some([0, 0, 0, 0]); - } - let rgb = if let Some(hex) = name.strip_prefix('#') { - // UTF-8 byte lengths can match a supported hex width while slicing would panic. - // `from_str_radix` would also take a leading `+`: accept hex digits only. - if !hex.bytes().all(|b| b.is_ascii_hexdigit()) { - return None; - } - let digits = match hex.len() { - 3 => 1, - 6 => 2, - 12 => 4, - _ => return None, - }; - let rgb = (0..3).map(|i| channel(&hex[i * digits..(i + 1) * digits])).collect::>>()?; - [rgb[0], rgb[1], rgb[2]] - } else { - named(name)? - }; - Some([rgb[0], rgb[1], rgb[2], 255]) +pub fn looks_like_xpm(bytes: &[u8]) -> bool { + craft_image_codecs::detect(bytes) == Some(Format::Xpm) } - -/// The XPM3 comment or the XPM2 first line. -pub fn looks_like_xpm(b: &[u8]) -> bool { - b.starts_with(b"/* XPM */") || b.starts_with(b"! XPM2\n") || b.starts_with(b"! XPM2\r\n") -} - pub fn decode(bytes: &[u8], limits: &Limits) -> Result { - if bytes.len() > MAX_SOURCE { - return Err(CodecError::LimitExceeded("XPM source exceeds 256 MiB".into())); - } - let lines = if bytes.starts_with(b"/* XPM */") { - c_strings(bytes)? - } else if bytes.starts_with(b"! XPM2\n") || bytes.starts_with(b"! XPM2\r\n") { - xpm2_lines(bytes)? - } else { - return Err(bad("not an XPM2/XPM3 image")); - }; - decode_lines(&lines, limits) -} - -fn decode_lines(lines: &[Vec], limits: &Limits) -> Result { - let header = lines.first().ok_or_else(|| bad("missing image header"))?; - let parts = std::str::from_utf8(header).map_err(|_| bad("non-UTF-8 XPM header"))?; - let mut parts = parts.split_ascii_whitespace(); - let number = |key: &str, s: Option<&str>| -> Result { - s.ok_or_else(|| bad(format!("missing {key}")))?.parse::().map_err(|_| bad(format!("invalid {key}"))) - }; - let width = number("width", parts.next())?; - let height = number("height", parts.next())?; - let colours = number("palette size", parts.next())?; - let cpp = number("chars per pixel", parts.next())?; - if width == 0 || height == 0 || colours == 0 || colours > MAX_COLOURS || !(1..=MAX_CPP).contains(&cpp) { - return Err(bad("invalid XPM dimensions, palette size or chars per pixel")); - } - let (w, h) = (u32::try_from(width).map_err(|_| bad("width overflow"))?, u32::try_from(height).map_err(|_| bad("height overflow"))?); - limits.check(w, h, ChannelLayout::Rgba, SampleType::U8)?; - let required = 1usize.checked_add(colours).and_then(|n| n.checked_add(height)).ok_or_else(|| bad("row count overflow"))?; - if lines.len() < required { - return Err(bad("truncated palette or image rows")); - } - let mut palette = HashMap::, [u8; 4]>::with_capacity(colours); - for line in &lines[1..1 + colours] { - if line.len() < cpp { - return Err(bad("truncated colour key")); - } - let fields = std::str::from_utf8(&line[cpp..]).map_err(|_| bad("invalid colour name"))?; - // XPM priority is colour, gray, four-level gray, then monochrome, - // regardless of the order of keys in the palette entry. - let terms: Vec<&str> = fields.split_ascii_whitespace().collect(); - let mut picked: Option<(u8, String)> = None; - let mut i = 0; - while i < terms.len() { - let priority = match terms[i] { - "c" => 4, - "g" => 3, - "g4" => 2, - "m" => 1, - _ => 0, // Symbolic names ('s') are not colour values. - }; - let start = i + 1; - i = start; - while i < terms.len() && !matches!(terms[i], "c" | "g" | "g4" | "m" | "s") { - i += 1; - } - if priority > 0 && i > start && picked.as_ref().is_none_or(|(current, _)| priority > *current) { - picked = Some((priority, terms[start..i].join(" "))); - } - } - let value = picked.as_ref().and_then(|(_, name)| color(name)).ok_or_else(|| bad("unsupported or missing XPM colour"))?; - if palette.insert(line[..cpp].to_vec(), value).is_some() { - return Err(bad("duplicate XPM palette key")); - } - } - let row_len = width.checked_mul(cpp).ok_or_else(|| bad("row byte count overflow"))?; - // Validate all source rows before reserving the decoded RGBA image. A malformed - // short row must not be able to make a large header-sized allocation first. - if lines[1 + colours..required].iter().any(|line| line.len() != row_len) { - return Err(bad("XPM row has the wrong width")); - } - let total = width.checked_mul(height).and_then(|n| n.checked_mul(4)).ok_or_else(|| bad("pixel size overflow"))?; - let mut pixels = Vec::new(); - pixels.try_reserve_exact(total).map_err(|_| bad("XPM pixel buffer is too large"))?; - pixels.resize(total, 0); - for (y, line) in lines[1 + colours..required].iter().enumerate() { - for x in 0..width { - let key = &line[x * cpp..(x + 1) * cpp]; - let rgba = palette.get(key).ok_or_else(|| bad("unknown palette key"))?; - pixels[(y * width + x) * 4..(y * width + x + 1) * 4].copy_from_slice(rgba); - } - } - Image::from_u8(w, h, ChannelLayout::Rgba, pixels) + bridge::format(Format::Xpm, bytes, limits) } diff --git a/crates/raster-codecs/src/xpm/x11_colors.rs b/crates/raster-codecs/src/xpm/x11_colors.rs deleted file mode 100644 index 31986999a..000000000 --- a/crates/raster-codecs/src/xpm/x11_colors.rs +++ /dev/null @@ -1,666 +0,0 @@ -//! X11 color-name database (X.Org rgb.txt) normalized to lowercase without -//! spaces, underscores, or hyphens. RGB values are *X11* values, not CSS values. -//! Source: -//! License: MIT (X.Org Foundation), see the upstream app/rgb COPYING file. -//! Aliases differing only in case or spaces have been collapsed. -//! Keep sorted: decoder uses binary search without allocation per candidate. - -pub(super) const X11_COLORS: &[(&str, [u8; 3])] = &[ - ("aliceblue", [240, 248, 255]), - ("antiquewhite", [250, 235, 215]), - ("antiquewhite1", [255, 239, 219]), - ("antiquewhite2", [238, 223, 204]), - ("antiquewhite3", [205, 192, 176]), - ("antiquewhite4", [139, 131, 120]), - ("aquamarine", [127, 255, 212]), - ("aquamarine1", [127, 255, 212]), - ("aquamarine2", [118, 238, 198]), - ("aquamarine3", [102, 205, 170]), - ("aquamarine4", [69, 139, 116]), - ("azure", [240, 255, 255]), - ("azure1", [240, 255, 255]), - ("azure2", [224, 238, 238]), - ("azure3", [193, 205, 205]), - ("azure4", [131, 139, 139]), - ("beige", [245, 245, 220]), - ("bisque", [255, 228, 196]), - ("bisque1", [255, 228, 196]), - ("bisque2", [238, 213, 183]), - ("bisque3", [205, 183, 158]), - ("bisque4", [139, 125, 107]), - ("black", [0, 0, 0]), - ("blanchedalmond", [255, 235, 205]), - ("blue", [0, 0, 255]), - ("blue1", [0, 0, 255]), - ("blue2", [0, 0, 238]), - ("blue3", [0, 0, 205]), - ("blue4", [0, 0, 139]), - ("blueviolet", [138, 43, 226]), - ("brown", [165, 42, 42]), - ("brown1", [255, 64, 64]), - ("brown2", [238, 59, 59]), - ("brown3", [205, 51, 51]), - ("brown4", [139, 35, 35]), - ("burlywood", [222, 184, 135]), - ("burlywood1", [255, 211, 155]), - ("burlywood2", [238, 197, 145]), - ("burlywood3", [205, 170, 125]), - ("burlywood4", [139, 115, 85]), - ("cadetblue", [95, 158, 160]), - ("cadetblue1", [152, 245, 255]), - ("cadetblue2", [142, 229, 238]), - ("cadetblue3", [122, 197, 205]), - ("cadetblue4", [83, 134, 139]), - ("chartreuse", [127, 255, 0]), - ("chartreuse1", [127, 255, 0]), - ("chartreuse2", [118, 238, 0]), - ("chartreuse3", [102, 205, 0]), - ("chartreuse4", [69, 139, 0]), - ("chocolate", [210, 105, 30]), - ("chocolate1", [255, 127, 36]), - ("chocolate2", [238, 118, 33]), - ("chocolate3", [205, 102, 29]), - ("chocolate4", [139, 69, 19]), - ("coral", [255, 127, 80]), - ("coral1", [255, 114, 86]), - ("coral2", [238, 106, 80]), - ("coral3", [205, 91, 69]), - ("coral4", [139, 62, 47]), - ("cornflowerblue", [100, 149, 237]), - ("cornsilk", [255, 248, 220]), - ("cornsilk1", [255, 248, 220]), - ("cornsilk2", [238, 232, 205]), - ("cornsilk3", [205, 200, 177]), - ("cornsilk4", [139, 136, 120]), - ("cyan", [0, 255, 255]), - ("cyan1", [0, 255, 255]), - ("cyan2", [0, 238, 238]), - ("cyan3", [0, 205, 205]), - ("cyan4", [0, 139, 139]), - ("darkblue", [0, 0, 139]), - ("darkcyan", [0, 139, 139]), - ("darkgoldenrod", [184, 134, 11]), - ("darkgoldenrod1", [255, 185, 15]), - ("darkgoldenrod2", [238, 173, 14]), - ("darkgoldenrod3", [205, 149, 12]), - ("darkgoldenrod4", [139, 101, 8]), - ("darkgray", [169, 169, 169]), - ("darkgreen", [0, 100, 0]), - ("darkgrey", [169, 169, 169]), - ("darkkhaki", [189, 183, 107]), - ("darkmagenta", [139, 0, 139]), - ("darkolivegreen", [85, 107, 47]), - ("darkolivegreen1", [202, 255, 112]), - ("darkolivegreen2", [188, 238, 104]), - ("darkolivegreen3", [162, 205, 90]), - ("darkolivegreen4", [110, 139, 61]), - ("darkorange", [255, 140, 0]), - ("darkorange1", [255, 127, 0]), - ("darkorange2", [238, 118, 0]), - ("darkorange3", [205, 102, 0]), - ("darkorange4", [139, 69, 0]), - ("darkorchid", [153, 50, 204]), - ("darkorchid1", [191, 62, 255]), - ("darkorchid2", [178, 58, 238]), - ("darkorchid3", [154, 50, 205]), - ("darkorchid4", [104, 34, 139]), - ("darkred", [139, 0, 0]), - ("darksalmon", [233, 150, 122]), - ("darkseagreen", [143, 188, 143]), - ("darkseagreen1", [193, 255, 193]), - ("darkseagreen2", [180, 238, 180]), - ("darkseagreen3", [155, 205, 155]), - ("darkseagreen4", [105, 139, 105]), - ("darkslateblue", [72, 61, 139]), - ("darkslategray", [47, 79, 79]), - ("darkslategray1", [151, 255, 255]), - ("darkslategray2", [141, 238, 238]), - ("darkslategray3", [121, 205, 205]), - ("darkslategray4", [82, 139, 139]), - ("darkslategrey", [47, 79, 79]), - ("darkturquoise", [0, 206, 209]), - ("darkviolet", [148, 0, 211]), - ("deeppink", [255, 20, 147]), - ("deeppink1", [255, 20, 147]), - ("deeppink2", [238, 18, 137]), - ("deeppink3", [205, 16, 118]), - ("deeppink4", [139, 10, 80]), - ("deepskyblue", [0, 191, 255]), - ("deepskyblue1", [0, 191, 255]), - ("deepskyblue2", [0, 178, 238]), - ("deepskyblue3", [0, 154, 205]), - ("deepskyblue4", [0, 104, 139]), - ("dimgray", [105, 105, 105]), - ("dimgrey", [105, 105, 105]), - ("dodgerblue", [30, 144, 255]), - ("dodgerblue1", [30, 144, 255]), - ("dodgerblue2", [28, 134, 238]), - ("dodgerblue3", [24, 116, 205]), - ("dodgerblue4", [16, 78, 139]), - ("firebrick", [178, 34, 34]), - ("firebrick1", [255, 48, 48]), - ("firebrick2", [238, 44, 44]), - ("firebrick3", [205, 38, 38]), - ("firebrick4", [139, 26, 26]), - ("floralwhite", [255, 250, 240]), - ("forestgreen", [34, 139, 34]), - ("gainsboro", [220, 220, 220]), - ("ghostwhite", [248, 248, 255]), - ("gold", [255, 215, 0]), - ("gold1", [255, 215, 0]), - ("gold2", [238, 201, 0]), - ("gold3", [205, 173, 0]), - ("gold4", [139, 117, 0]), - ("goldenrod", [218, 165, 32]), - ("goldenrod1", [255, 193, 37]), - ("goldenrod2", [238, 180, 34]), - ("goldenrod3", [205, 155, 29]), - ("goldenrod4", [139, 105, 20]), - ("gray", [190, 190, 190]), - ("gray0", [0, 0, 0]), - ("gray1", [3, 3, 3]), - ("gray10", [26, 26, 26]), - ("gray100", [255, 255, 255]), - ("gray11", [28, 28, 28]), - ("gray12", [31, 31, 31]), - ("gray13", [33, 33, 33]), - ("gray14", [36, 36, 36]), - ("gray15", [38, 38, 38]), - ("gray16", [41, 41, 41]), - ("gray17", [43, 43, 43]), - ("gray18", [46, 46, 46]), - ("gray19", [48, 48, 48]), - ("gray2", [5, 5, 5]), - ("gray20", [51, 51, 51]), - ("gray21", [54, 54, 54]), - ("gray22", [56, 56, 56]), - ("gray23", [59, 59, 59]), - ("gray24", [61, 61, 61]), - ("gray25", [64, 64, 64]), - ("gray26", [66, 66, 66]), - ("gray27", [69, 69, 69]), - ("gray28", [71, 71, 71]), - ("gray29", [74, 74, 74]), - ("gray3", [8, 8, 8]), - ("gray30", [77, 77, 77]), - ("gray31", [79, 79, 79]), - ("gray32", [82, 82, 82]), - ("gray33", [84, 84, 84]), - ("gray34", [87, 87, 87]), - ("gray35", [89, 89, 89]), - ("gray36", [92, 92, 92]), - ("gray37", [94, 94, 94]), - ("gray38", [97, 97, 97]), - ("gray39", [99, 99, 99]), - ("gray4", [10, 10, 10]), - ("gray40", [102, 102, 102]), - ("gray41", [105, 105, 105]), - ("gray42", [107, 107, 107]), - ("gray43", [110, 110, 110]), - ("gray44", [112, 112, 112]), - ("gray45", [115, 115, 115]), - ("gray46", [117, 117, 117]), - ("gray47", [120, 120, 120]), - ("gray48", [122, 122, 122]), - ("gray49", [125, 125, 125]), - ("gray5", [13, 13, 13]), - ("gray50", [127, 127, 127]), - ("gray51", [130, 130, 130]), - ("gray52", [133, 133, 133]), - ("gray53", [135, 135, 135]), - ("gray54", [138, 138, 138]), - ("gray55", [140, 140, 140]), - ("gray56", [143, 143, 143]), - ("gray57", [145, 145, 145]), - ("gray58", [148, 148, 148]), - ("gray59", [150, 150, 150]), - ("gray6", [15, 15, 15]), - ("gray60", [153, 153, 153]), - ("gray61", [156, 156, 156]), - ("gray62", [158, 158, 158]), - ("gray63", [161, 161, 161]), - ("gray64", [163, 163, 163]), - ("gray65", [166, 166, 166]), - ("gray66", [168, 168, 168]), - ("gray67", [171, 171, 171]), - ("gray68", [173, 173, 173]), - ("gray69", [176, 176, 176]), - ("gray7", [18, 18, 18]), - ("gray70", [179, 179, 179]), - ("gray71", [181, 181, 181]), - ("gray72", [184, 184, 184]), - ("gray73", [186, 186, 186]), - ("gray74", [189, 189, 189]), - ("gray75", [191, 191, 191]), - ("gray76", [194, 194, 194]), - ("gray77", [196, 196, 196]), - ("gray78", [199, 199, 199]), - ("gray79", [201, 201, 201]), - ("gray8", [20, 20, 20]), - ("gray80", [204, 204, 204]), - ("gray81", [207, 207, 207]), - ("gray82", [209, 209, 209]), - ("gray83", [212, 212, 212]), - ("gray84", [214, 214, 214]), - ("gray85", [217, 217, 217]), - ("gray86", [219, 219, 219]), - ("gray87", [222, 222, 222]), - ("gray88", [224, 224, 224]), - ("gray89", [227, 227, 227]), - ("gray9", [23, 23, 23]), - ("gray90", [229, 229, 229]), - ("gray91", [232, 232, 232]), - ("gray92", [235, 235, 235]), - ("gray93", [237, 237, 237]), - ("gray94", [240, 240, 240]), - ("gray95", [242, 242, 242]), - ("gray96", [245, 245, 245]), - ("gray97", [247, 247, 247]), - ("gray98", [250, 250, 250]), - ("gray99", [252, 252, 252]), - ("green", [0, 255, 0]), - ("green1", [0, 255, 0]), - ("green2", [0, 238, 0]), - ("green3", [0, 205, 0]), - ("green4", [0, 139, 0]), - ("greenyellow", [173, 255, 47]), - ("grey", [190, 190, 190]), - ("grey0", [0, 0, 0]), - ("grey1", [3, 3, 3]), - ("grey10", [26, 26, 26]), - ("grey100", [255, 255, 255]), - ("grey11", [28, 28, 28]), - ("grey12", [31, 31, 31]), - ("grey13", [33, 33, 33]), - ("grey14", [36, 36, 36]), - ("grey15", [38, 38, 38]), - ("grey16", [41, 41, 41]), - ("grey17", [43, 43, 43]), - ("grey18", [46, 46, 46]), - ("grey19", [48, 48, 48]), - ("grey2", [5, 5, 5]), - ("grey20", [51, 51, 51]), - ("grey21", [54, 54, 54]), - ("grey22", [56, 56, 56]), - ("grey23", [59, 59, 59]), - ("grey24", [61, 61, 61]), - ("grey25", [64, 64, 64]), - ("grey26", [66, 66, 66]), - ("grey27", [69, 69, 69]), - ("grey28", [71, 71, 71]), - ("grey29", [74, 74, 74]), - ("grey3", [8, 8, 8]), - ("grey30", [77, 77, 77]), - ("grey31", [79, 79, 79]), - ("grey32", [82, 82, 82]), - ("grey33", [84, 84, 84]), - ("grey34", [87, 87, 87]), - ("grey35", [89, 89, 89]), - ("grey36", [92, 92, 92]), - ("grey37", [94, 94, 94]), - ("grey38", [97, 97, 97]), - ("grey39", [99, 99, 99]), - ("grey4", [10, 10, 10]), - ("grey40", [102, 102, 102]), - ("grey41", [105, 105, 105]), - ("grey42", [107, 107, 107]), - ("grey43", [110, 110, 110]), - ("grey44", [112, 112, 112]), - ("grey45", [115, 115, 115]), - ("grey46", [117, 117, 117]), - ("grey47", [120, 120, 120]), - ("grey48", [122, 122, 122]), - ("grey49", [125, 125, 125]), - ("grey5", [13, 13, 13]), - ("grey50", [127, 127, 127]), - ("grey51", [130, 130, 130]), - ("grey52", [133, 133, 133]), - ("grey53", [135, 135, 135]), - ("grey54", [138, 138, 138]), - ("grey55", [140, 140, 140]), - ("grey56", [143, 143, 143]), - ("grey57", [145, 145, 145]), - ("grey58", [148, 148, 148]), - ("grey59", [150, 150, 150]), - ("grey6", [15, 15, 15]), - ("grey60", [153, 153, 153]), - ("grey61", [156, 156, 156]), - ("grey62", [158, 158, 158]), - ("grey63", [161, 161, 161]), - ("grey64", [163, 163, 163]), - ("grey65", [166, 166, 166]), - ("grey66", [168, 168, 168]), - ("grey67", [171, 171, 171]), - ("grey68", [173, 173, 173]), - ("grey69", [176, 176, 176]), - ("grey7", [18, 18, 18]), - ("grey70", [179, 179, 179]), - ("grey71", [181, 181, 181]), - ("grey72", [184, 184, 184]), - ("grey73", [186, 186, 186]), - ("grey74", [189, 189, 189]), - ("grey75", [191, 191, 191]), - ("grey76", [194, 194, 194]), - ("grey77", [196, 196, 196]), - ("grey78", [199, 199, 199]), - ("grey79", [201, 201, 201]), - ("grey8", [20, 20, 20]), - ("grey80", [204, 204, 204]), - ("grey81", [207, 207, 207]), - ("grey82", [209, 209, 209]), - ("grey83", [212, 212, 212]), - ("grey84", [214, 214, 214]), - ("grey85", [217, 217, 217]), - ("grey86", [219, 219, 219]), - ("grey87", [222, 222, 222]), - ("grey88", [224, 224, 224]), - ("grey89", [227, 227, 227]), - ("grey9", [23, 23, 23]), - ("grey90", [229, 229, 229]), - ("grey91", [232, 232, 232]), - ("grey92", [235, 235, 235]), - ("grey93", [237, 237, 237]), - ("grey94", [240, 240, 240]), - ("grey95", [242, 242, 242]), - ("grey96", [245, 245, 245]), - ("grey97", [247, 247, 247]), - ("grey98", [250, 250, 250]), - ("grey99", [252, 252, 252]), - ("honeydew", [240, 255, 240]), - ("honeydew1", [240, 255, 240]), - ("honeydew2", [224, 238, 224]), - ("honeydew3", [193, 205, 193]), - ("honeydew4", [131, 139, 131]), - ("hotpink", [255, 105, 180]), - ("hotpink1", [255, 110, 180]), - ("hotpink2", [238, 106, 167]), - ("hotpink3", [205, 96, 144]), - ("hotpink4", [139, 58, 98]), - ("indianred", [205, 92, 92]), - ("indianred1", [255, 106, 106]), - ("indianred2", [238, 99, 99]), - ("indianred3", [205, 85, 85]), - ("indianred4", [139, 58, 58]), - ("ivory", [255, 255, 240]), - ("ivory1", [255, 255, 240]), - ("ivory2", [238, 238, 224]), - ("ivory3", [205, 205, 193]), - ("ivory4", [139, 139, 131]), - ("khaki", [240, 230, 140]), - ("khaki1", [255, 246, 143]), - ("khaki2", [238, 230, 133]), - ("khaki3", [205, 198, 115]), - ("khaki4", [139, 134, 78]), - ("lavender", [230, 230, 250]), - ("lavenderblush", [255, 240, 245]), - ("lavenderblush1", [255, 240, 245]), - ("lavenderblush2", [238, 224, 229]), - ("lavenderblush3", [205, 193, 197]), - ("lavenderblush4", [139, 131, 134]), - ("lawngreen", [124, 252, 0]), - ("lemonchiffon", [255, 250, 205]), - ("lemonchiffon1", [255, 250, 205]), - ("lemonchiffon2", [238, 233, 191]), - ("lemonchiffon3", [205, 201, 165]), - ("lemonchiffon4", [139, 137, 112]), - ("lightblue", [173, 216, 230]), - ("lightblue1", [191, 239, 255]), - ("lightblue2", [178, 223, 238]), - ("lightblue3", [154, 192, 205]), - ("lightblue4", [104, 131, 139]), - ("lightcoral", [240, 128, 128]), - ("lightcyan", [224, 255, 255]), - ("lightcyan1", [224, 255, 255]), - ("lightcyan2", [209, 238, 238]), - ("lightcyan3", [180, 205, 205]), - ("lightcyan4", [122, 139, 139]), - ("lightgoldenrod", [238, 221, 130]), - ("lightgoldenrod1", [255, 236, 139]), - ("lightgoldenrod2", [238, 220, 130]), - ("lightgoldenrod3", [205, 190, 112]), - ("lightgoldenrod4", [139, 129, 76]), - ("lightgoldenrodyellow", [250, 250, 210]), - ("lightgray", [211, 211, 211]), - ("lightgreen", [144, 238, 144]), - ("lightgrey", [211, 211, 211]), - ("lightpink", [255, 182, 193]), - ("lightpink1", [255, 174, 185]), - ("lightpink2", [238, 162, 173]), - ("lightpink3", [205, 140, 149]), - ("lightpink4", [139, 95, 101]), - ("lightsalmon", [255, 160, 122]), - ("lightsalmon1", [255, 160, 122]), - ("lightsalmon2", [238, 149, 114]), - ("lightsalmon3", [205, 129, 98]), - ("lightsalmon4", [139, 87, 66]), - ("lightseagreen", [32, 178, 170]), - ("lightskyblue", [135, 206, 250]), - ("lightskyblue1", [176, 226, 255]), - ("lightskyblue2", [164, 211, 238]), - ("lightskyblue3", [141, 182, 205]), - ("lightskyblue4", [96, 123, 139]), - ("lightslateblue", [132, 112, 255]), - ("lightslategray", [119, 136, 153]), - ("lightslategrey", [119, 136, 153]), - ("lightsteelblue", [176, 196, 222]), - ("lightsteelblue1", [202, 225, 255]), - ("lightsteelblue2", [188, 210, 238]), - ("lightsteelblue3", [162, 181, 205]), - ("lightsteelblue4", [110, 123, 139]), - ("lightyellow", [255, 255, 224]), - ("lightyellow1", [255, 255, 224]), - ("lightyellow2", [238, 238, 209]), - ("lightyellow3", [205, 205, 180]), - ("lightyellow4", [139, 139, 122]), - ("limegreen", [50, 205, 50]), - ("linen", [250, 240, 230]), - ("magenta", [255, 0, 255]), - ("magenta1", [255, 0, 255]), - ("magenta2", [238, 0, 238]), - ("magenta3", [205, 0, 205]), - ("magenta4", [139, 0, 139]), - ("maroon", [176, 48, 96]), - ("maroon1", [255, 52, 179]), - ("maroon2", [238, 48, 167]), - ("maroon3", [205, 41, 144]), - ("maroon4", [139, 28, 98]), - ("mediumaquamarine", [102, 205, 170]), - ("mediumblue", [0, 0, 205]), - ("mediumorchid", [186, 85, 211]), - ("mediumorchid1", [224, 102, 255]), - ("mediumorchid2", [209, 95, 238]), - ("mediumorchid3", [180, 82, 205]), - ("mediumorchid4", [122, 55, 139]), - ("mediumpurple", [147, 112, 219]), - ("mediumpurple1", [171, 130, 255]), - ("mediumpurple2", [159, 121, 238]), - ("mediumpurple3", [137, 104, 205]), - ("mediumpurple4", [93, 71, 139]), - ("mediumseagreen", [60, 179, 113]), - ("mediumslateblue", [123, 104, 238]), - ("mediumspringgreen", [0, 250, 154]), - ("mediumturquoise", [72, 209, 204]), - ("mediumvioletred", [199, 21, 133]), - ("midnightblue", [25, 25, 112]), - ("mintcream", [245, 255, 250]), - ("mistyrose", [255, 228, 225]), - ("mistyrose1", [255, 228, 225]), - ("mistyrose2", [238, 213, 210]), - ("mistyrose3", [205, 183, 181]), - ("mistyrose4", [139, 125, 123]), - ("moccasin", [255, 228, 181]), - ("navajowhite", [255, 222, 173]), - ("navajowhite1", [255, 222, 173]), - ("navajowhite2", [238, 207, 161]), - ("navajowhite3", [205, 179, 139]), - ("navajowhite4", [139, 121, 94]), - ("navy", [0, 0, 128]), - ("navyblue", [0, 0, 128]), - ("oldlace", [253, 245, 230]), - ("olivedrab", [107, 142, 35]), - ("olivedrab1", [192, 255, 62]), - ("olivedrab2", [179, 238, 58]), - ("olivedrab3", [154, 205, 50]), - ("olivedrab4", [105, 139, 34]), - ("orange", [255, 165, 0]), - ("orange1", [255, 165, 0]), - ("orange2", [238, 154, 0]), - ("orange3", [205, 133, 0]), - ("orange4", [139, 90, 0]), - ("orangered", [255, 69, 0]), - ("orangered1", [255, 69, 0]), - ("orangered2", [238, 64, 0]), - ("orangered3", [205, 55, 0]), - ("orangered4", [139, 37, 0]), - ("orchid", [218, 112, 214]), - ("orchid1", [255, 131, 250]), - ("orchid2", [238, 122, 233]), - ("orchid3", [205, 105, 201]), - ("orchid4", [139, 71, 137]), - ("palegoldenrod", [238, 232, 170]), - ("palegreen", [152, 251, 152]), - ("palegreen1", [154, 255, 154]), - ("palegreen2", [144, 238, 144]), - ("palegreen3", [124, 205, 124]), - ("palegreen4", [84, 139, 84]), - ("paleturquoise", [175, 238, 238]), - ("paleturquoise1", [187, 255, 255]), - ("paleturquoise2", [174, 238, 238]), - ("paleturquoise3", [150, 205, 205]), - ("paleturquoise4", [102, 139, 139]), - ("palevioletred", [219, 112, 147]), - ("palevioletred1", [255, 130, 171]), - ("palevioletred2", [238, 121, 159]), - ("palevioletred3", [205, 104, 137]), - ("palevioletred4", [139, 71, 93]), - ("papayawhip", [255, 239, 213]), - ("peachpuff", [255, 218, 185]), - ("peachpuff1", [255, 218, 185]), - ("peachpuff2", [238, 203, 173]), - ("peachpuff3", [205, 175, 149]), - ("peachpuff4", [139, 119, 101]), - ("peru", [205, 133, 63]), - ("pink", [255, 192, 203]), - ("pink1", [255, 181, 197]), - ("pink2", [238, 169, 184]), - ("pink3", [205, 145, 158]), - ("pink4", [139, 99, 108]), - ("plum", [221, 160, 221]), - ("plum1", [255, 187, 255]), - ("plum2", [238, 174, 238]), - ("plum3", [205, 150, 205]), - ("plum4", [139, 102, 139]), - ("powderblue", [176, 224, 230]), - ("purple", [160, 32, 240]), - ("purple1", [155, 48, 255]), - ("purple2", [145, 44, 238]), - ("purple3", [125, 38, 205]), - ("purple4", [85, 26, 139]), - ("red", [255, 0, 0]), - ("red1", [255, 0, 0]), - ("red2", [238, 0, 0]), - ("red3", [205, 0, 0]), - ("red4", [139, 0, 0]), - ("rosybrown", [188, 143, 143]), - ("rosybrown1", [255, 193, 193]), - ("rosybrown2", [238, 180, 180]), - ("rosybrown3", [205, 155, 155]), - ("rosybrown4", [139, 105, 105]), - ("royalblue", [65, 105, 225]), - ("royalblue1", [72, 118, 255]), - ("royalblue2", [67, 110, 238]), - ("royalblue3", [58, 95, 205]), - ("royalblue4", [39, 64, 139]), - ("saddlebrown", [139, 69, 19]), - ("salmon", [250, 128, 114]), - ("salmon1", [255, 140, 105]), - ("salmon2", [238, 130, 98]), - ("salmon3", [205, 112, 84]), - ("salmon4", [139, 76, 57]), - ("sandybrown", [244, 164, 96]), - ("seagreen", [46, 139, 87]), - ("seagreen1", [84, 255, 159]), - ("seagreen2", [78, 238, 148]), - ("seagreen3", [67, 205, 128]), - ("seagreen4", [46, 139, 87]), - ("seashell", [255, 245, 238]), - ("seashell1", [255, 245, 238]), - ("seashell2", [238, 229, 222]), - ("seashell3", [205, 197, 191]), - ("seashell4", [139, 134, 130]), - ("sienna", [160, 82, 45]), - ("sienna1", [255, 130, 71]), - ("sienna2", [238, 121, 66]), - ("sienna3", [205, 104, 57]), - ("sienna4", [139, 71, 38]), - ("skyblue", [135, 206, 235]), - ("skyblue1", [135, 206, 255]), - ("skyblue2", [126, 192, 238]), - ("skyblue3", [108, 166, 205]), - ("skyblue4", [74, 112, 139]), - ("slateblue", [106, 90, 205]), - ("slateblue1", [131, 111, 255]), - ("slateblue2", [122, 103, 238]), - ("slateblue3", [105, 89, 205]), - ("slateblue4", [71, 60, 139]), - ("slategray", [112, 128, 144]), - ("slategray1", [198, 226, 255]), - ("slategray2", [185, 211, 238]), - ("slategray3", [159, 182, 205]), - ("slategray4", [108, 123, 139]), - ("slategrey", [112, 128, 144]), - ("snow", [255, 250, 250]), - ("snow1", [255, 250, 250]), - ("snow2", [238, 233, 233]), - ("snow3", [205, 201, 201]), - ("snow4", [139, 137, 137]), - ("springgreen", [0, 255, 127]), - ("springgreen1", [0, 255, 127]), - ("springgreen2", [0, 238, 118]), - ("springgreen3", [0, 205, 102]), - ("springgreen4", [0, 139, 69]), - ("steelblue", [70, 130, 180]), - ("steelblue1", [99, 184, 255]), - ("steelblue2", [92, 172, 238]), - ("steelblue3", [79, 148, 205]), - ("steelblue4", [54, 100, 139]), - ("tan", [210, 180, 140]), - ("tan1", [255, 165, 79]), - ("tan2", [238, 154, 73]), - ("tan3", [205, 133, 63]), - ("tan4", [139, 90, 43]), - ("thistle", [216, 191, 216]), - ("thistle1", [255, 225, 255]), - ("thistle2", [238, 210, 238]), - ("thistle3", [205, 181, 205]), - ("thistle4", [139, 123, 139]), - ("tomato", [255, 99, 71]), - ("tomato1", [255, 99, 71]), - ("tomato2", [238, 92, 66]), - ("tomato3", [205, 79, 57]), - ("tomato4", [139, 54, 38]), - ("turquoise", [64, 224, 208]), - ("turquoise1", [0, 245, 255]), - ("turquoise2", [0, 229, 238]), - ("turquoise3", [0, 197, 205]), - ("turquoise4", [0, 134, 139]), - ("violet", [238, 130, 238]), - ("violetred", [208, 32, 144]), - ("violetred1", [255, 62, 150]), - ("violetred2", [238, 58, 140]), - ("violetred3", [205, 50, 120]), - ("violetred4", [139, 34, 82]), - ("wheat", [245, 222, 179]), - ("wheat1", [255, 231, 186]), - ("wheat2", [238, 216, 174]), - ("wheat3", [205, 186, 150]), - ("wheat4", [139, 126, 102]), - ("white", [255, 255, 255]), - ("whitesmoke", [245, 245, 245]), - ("yellow", [255, 255, 0]), - ("yellow1", [255, 255, 0]), - ("yellow2", [238, 238, 0]), - ("yellow3", [205, 205, 0]), - ("yellow4", [139, 139, 0]), - ("yellowgreen", [154, 205, 50]), -]; From 4e4e9338d9e6610775eb47e00b0139330da8780b Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 06:45:26 -0500 Subject: [PATCH 014/382] Update lockfile after raster facade cleanup --- Cargo.lock | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9a8abed4c..0bc90ee3d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2284,7 +2284,6 @@ dependencies = [ "base64 0.23.1", "craft-image-codecs", "image", - "rayon", "thiserror 2.0.21", ] @@ -4941,17 +4940,17 @@ version = "0.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "65b27460c2c92b037f3f94c538ed9a3342f3fdf923606781629ccb35f82d042a" -[[package]] -name = "indd" -version = "0.1.0" -source = "git+https://github.com/storytold/indd-utils?rev=7f3060e5bce78d21ea70e0d5eacb96edce15dfbe#7f3060e5bce78d21ea70e0d5eacb96edce15dfbe" - [[package]] name = "imgref" version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e44b0a4eaa4c82f441d50a963f2d5f05a787240aeee097597033e72accfd22f" +[[package]] +name = "indd" +version = "0.1.0" +source = "git+https://github.com/storytold/indd-utils?rev=7f3060e5bce78d21ea70e0d5eacb96edce15dfbe#7f3060e5bce78d21ea70e0d5eacb96edce15dfbe" + [[package]] name = "indexmap" version = "2.14.2" From 1d52e89405ff9237c53f34584ff97fef8decc611 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 07:11:11 -0500 Subject: [PATCH 015/382] Share raster metadata parsing with craft-metadata --- Cargo.lock | 1 + crates/image-codecs/Cargo.toml | 1 + crates/image-codecs/src/codecs/tiff/bands.rs | 35 +- crates/image-codecs/src/exif_color.rs | 68 +-- crates/image-codecs/src/orientation.rs | 231 +------- crates/image-codecs/src/resolution.rs | 578 +------------------ 6 files changed, 38 insertions(+), 876 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0bc90ee3d..9702836da 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1758,6 +1758,7 @@ version = "0.1.0" dependencies = [ "craft-heif", "craft-jpeg", + "craft-metadata", "exr", "flate2", "half", diff --git a/crates/image-codecs/Cargo.toml b/crates/image-codecs/Cargo.toml index 30f7f7046..b893c347a 100644 --- a/crates/image-codecs/Cargo.toml +++ b/crates/image-codecs/Cargo.toml @@ -30,6 +30,7 @@ zune-jpeg = "0.5" zune-core = "0.5" jpeg-encoder = "0.6" craft-jpeg = { workspace = true } +craft-metadata = { workspace = true } zune-jpegxl = { version = "=0.5.2", default-features = false, features = ["std"] } craft-heif = { workspace = true, optional = true } diff --git a/crates/image-codecs/src/codecs/tiff/bands.rs b/crates/image-codecs/src/codecs/tiff/bands.rs index 093f90efd..117c95ded 100644 --- a/crates/image-codecs/src/codecs/tiff/bands.rs +++ b/crates/image-codecs/src/codecs/tiff/bands.rs @@ -230,16 +230,7 @@ fn decode_band( } continue; } - if pref.len > lay.scratch_cap { - return Err(CodecError::LimitExceeded(format!("a {} byte strip or tile", pref.len))); - } - if scratch.len() < pref.len { - scratch - .try_reserve_exact(pref.len - scratch.len()) - .map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {} bytes for a strip or tile", pref.len)))?; - scratch.resize(pref.len, 0); - } - let buf = scratch.get_mut(..pref.len).ok_or_else(|| err("scratch buffer"))?; + let buf = chunk_scratch(lay, scratch, pref.len)?; match dec.read_chunk_bytes(chunk, buf) { Ok(()) => tally.decoded += 1, Err(e) if is_eof(&e) => { @@ -284,6 +275,19 @@ fn deposit_extras(lay: &Layout, src: &[u8], dst: &mut [u8], n: usize, x0: usize) } } +fn chunk_scratch<'a>(lay: &Layout, scratch: &'a mut Vec, len: usize) -> Result<&'a mut [u8], CodecError> { + if len > lay.scratch_cap { + return Err(CodecError::LimitExceeded(format!("a {} byte strip or tile", len))); + } + if scratch.len() < len { + scratch + .try_reserve_exact(len - scratch.len()) + .map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {} bytes for a strip or tile", len)))?; + scratch.resize(len, 0); + } + scratch.get_mut(..len).ok_or_else(|| err("scratch buffer")) +} + /// Planar files store each extra sample as its own plane. Read those planes into `extra`. fn read_planar_extras( lay: &Layout, @@ -310,16 +314,7 @@ fn read_planar_extras( .ok_or_else(|| err("chunk index out of range"))?; let pref = dec.image_chunk_buffer_layout(chunk).map_err(map_err)?; let stride = pref.row_stride.map(|s| s.get()).ok_or_else(|| err("empty chunk row"))?; - if pref.len > lay.scratch_cap { - return Err(CodecError::LimitExceeded(format!("a {} byte strip or tile", pref.len))); - } - if scratch.len() < pref.len { - scratch - .try_reserve_exact(pref.len - scratch.len()) - .map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {} bytes for a strip or tile", pref.len)))?; - scratch.resize(pref.len, 0); - } - let buf = scratch.get_mut(..pref.len).ok_or_else(|| err("scratch buffer"))?; + let buf = chunk_scratch(lay, scratch, pref.len)?; match dec.read_chunk_bytes(chunk, buf) { Ok(()) => tally.decoded += 1, Err(e) if is_eof(&e) => { diff --git a/crates/image-codecs/src/exif_color.rs b/crates/image-codecs/src/exif_color.rs index 4259bb15c..8a35907ff 100644 --- a/crates/image-codecs/src/exif_color.rs +++ b/crates/image-codecs/src/exif_color.rs @@ -1,70 +1,16 @@ -//! The EXIF ColorSpace tag (0xA001, in the Exif sub-IFD that IFD0's tag 0x8769 points to): -//! 1 = sRGB, 0xFFFF = uncalibrated (EXIF 2.3, §4.6.5). -//! -//! Cameras write it instead of an ICC profile. Photoshop opens a file with no embedded profile but -//! ColorSpace = sRGB as sRGB, unless Preferences › File Handling › Ignore EXIF Profile Tag is on. -//! Anything malformed, truncated or missing reads as no tag. +//! Shared EXIF ColorSpace tag parsing. -use crate::orientation::{Order, ifd0_entries, tiff_body}; - -/// IFD0's pointer to the Exif sub-IFD. -const TAG_EXIF_IFD: u16 = 0x8769; -/// The ColorSpace tag in the Exif sub-IFD. -const TAG_COLOR_SPACE: u16 = 0xA001; -const TYPE_SHORT: u16 = 3; -const TYPE_LONG: u16 = 4; -/// TIFF type 13: an IFD offset (some writers use it for sub-IFD pointers). -const TYPE_IFD: u16 = 13; -/// Bytes per classic TIFF IFD entry; EXIF is never BigTIFF. -const ENTRY: usize = 12; -/// No IFD can start inside the 8-byte TIFF header. -const HEADER: usize = 8; - -/// The ColorSpace value meaning sRGB. -pub const EXIF_COLOR_SPACE_SRGB: u16 = 1; - -/// The EXIF ColorSpace value of a TIFF-structured block (an EXIF payload with or without the -/// `Exif\0\0` prefix), or `None` when it has none or it is malformed. -pub fn exif_color_space(exif: &[u8]) -> Option { - let b = tiff_body(exif); - let (order, first, count, entry_bytes, big_tiff) = ifd0_entries(b)?; - if big_tiff { - return None; - } - let ptr = find(order, b, first, count, entry_bytes, TAG_EXIF_IFD)?; - if !matches!(order.u16(b, ptr.checked_add(2)?)?, TYPE_LONG | TYPE_IFD) || order.u32(b, ptr.checked_add(4)?)? != 1 { - return None; - } - let ifd = usize::try_from(order.u32(b, ptr.checked_add(8)?)?).ok()?; - if ifd < HEADER { - return None; - } - let n = usize::from(order.u16(b, ifd)?); - let first = ifd.checked_add(2)?; - // The whole table must be present. - if first.checked_add(n.checked_mul(ENTRY)?)? > b.len() { - return None; - } - let e = find(order, b, first, n, ENTRY, TAG_COLOR_SPACE)?; - if order.u32(b, e.checked_add(4)?)? != 1 { - return None; - } - match order.u16(b, e.checked_add(2)?)? { - TYPE_SHORT => order.u16(b, e.checked_add(8)?), - TYPE_LONG => u16::try_from(order.u32(b, e.checked_add(8)?)?).ok(), - _ => None, - } -} - -/// Offset of the first entry tagged `tag` in the IFD whose `count` entries start at `first`. -fn find(order: Order, b: &[u8], first: usize, count: usize, entry_bytes: usize, tag: u16) -> Option { - (0..count).filter_map(|i| first.checked_add(i.checked_mul(entry_bytes)?)).find(|&e| order.u16(b, e) == Some(tag)) -} +pub use craft_metadata::edit::{EXIF_COLOR_SPACE_SRGB, exif_color_space}; #[cfg(test)] mod tests { use super::*; + const TAG_EXIF_IFD: u16 = 0x8769; + const TAG_COLOR_SPACE: u16 = 0xA001; + const TYPE_SHORT: u16 = 3; + const TYPE_LONG: u16 = 4; + /// A little- or big-endian EXIF block: IFD0 holding only the Exif pointer, then an Exif IFD /// holding `entries` (tag, type, count, value). fn exif(big_endian: bool, entries: &[(u16, u16, u32, u32)]) -> Vec { diff --git a/crates/image-codecs/src/orientation.rs b/crates/image-codecs/src/orientation.rs index f77e6691f..2db0de75f 100644 --- a/crates/image-codecs/src/orientation.rs +++ b/crates/image-codecs/src/orientation.rs @@ -1,232 +1,15 @@ -//! EXIF / TIFF orientation (tag 274): reading it, applying it to the pixels, -//! and rewriting it to 1 ("top-left", upright) once the pixels are upright. -//! -//! Decoders apply the orientation by default (like Photoshop and every photo -//! viewer), so a document is always edited upright. Encoders then write -//! Orientation = 1, so a viewer never rotates the already-upright pixels a -//! second time. -//! -//! Orientation values (TIFF 6.0, EXIF 2.3): 1 = upright, 2 = mirrored, 3 = -//! rotated 180°, 4 = flipped vertically, 5 = transposed, 6 = needs a 90° -//! clockwise turn, 7 = transverse, 8 = needs a 90° counter-clockwise turn. -//! Anything malformed, truncated or out of range reads as 1: an IFD0 that -//! starts inside the 8-byte header or is cut off before its next-IFD pointer, -//! or an Orientation entry that is not exactly one SHORT or LONG (the spec says -//! SHORT, but some cameras and tools write LONG). When IFD0 holds -//! several Orientation entries the first one wins (like libexif). - -use std::borrow::Cow; +//! EXIF orientation transforms for decoded images. Byte-level EXIF/XMP inspection and edits are +//! shared with `craft-metadata`. use crate::error::CodecError; use crate::image::Image; +use std::borrow::Cow; -/// The TIFF/EXIF Orientation tag. -const TAG_ORIENTATION: u16 = 274; -/// Field types accepted for the Orientation tag: SHORT (the spec) and LONG -/// (written by some cameras and tools). -const TYPE_SHORT: u16 = 3; -const TYPE_LONG: u16 = 4; -/// Bytes per IFD entry. -const ENTRY: usize = 12; -/// The TIFF header is 8 bytes, so no IFD can start before it. -const HEADER: usize = 8; -/// BigTIFF uses a 16-byte header, 20-byte entries, and 8-byte offsets. -const BIG_ENTRY: usize = 20; -const BIG_HEADER: usize = 16; +pub use craft_metadata::edit::{exif_orientation, upright_exif, upright_xmp}; -/// Byte order of a TIFF structure. -#[derive(Clone, Copy)] -pub(crate) enum Order { - Little, - Big, -} - -impl Order { - pub(crate) fn u16(self, b: &[u8], at: usize) -> Option { - let s: [u8; 2] = b.get(at..at.checked_add(2)?)?.try_into().ok()?; - Some(match self { - Order::Little => u16::from_le_bytes(s), - Order::Big => u16::from_be_bytes(s), - }) - } - - pub(crate) fn u32(self, b: &[u8], at: usize) -> Option { - let s: [u8; 4] = b.get(at..at.checked_add(4)?)?.try_into().ok()?; - Some(match self { - Order::Little => u32::from_le_bytes(s), - Order::Big => u32::from_be_bytes(s), - }) - } - - pub(crate) fn u64(self, b: &[u8], at: usize) -> Option { - let s: [u8; 8] = b.get(at..at.checked_add(8)?)?.try_into().ok()?; - Some(match self { - Order::Little => u64::from_le_bytes(s), - Order::Big => u64::from_be_bytes(s), - }) - } -} - -/// The TIFF payload of an EXIF block (a JPEG-style `Exif\0\0` prefix is skipped). -pub(crate) fn tiff_body(b: &[u8]) -> &[u8] { - b.strip_prefix(b"Exif\0\0").unwrap_or(b) -} - -/// IFD0 of a TIFF structure: byte order, entry layout, and entry offsets. -/// -/// The full table and next-IFD pointer must be present, and IFD0 must start -/// after the corresponding TIFF or BigTIFF header. -pub(crate) fn ifd0_entries(b: &[u8]) -> Option<(Order, usize, usize, usize, bool)> { - let (order, big_tiff) = match b.get(0..4)? { - [b'I', b'I', 42, 0] => (Order::Little, false), - [b'M', b'M', 0, 42] => (Order::Big, false), - [b'I', b'I', 43, 0] => (Order::Little, true), - [b'M', b'M', 0, 43] => (Order::Big, true), - _ => return None, - }; - let (ifd, count_bytes, entry_bytes, next_ifd_bytes, header) = if big_tiff { - if order.u16(b, 4)? != 8 || order.u16(b, 6)? != 0 { - return None; - } - (usize::try_from(order.u64(b, 8)?).ok()?, 8usize, BIG_ENTRY, 8usize, BIG_HEADER) - } else { - (usize::try_from(order.u32(b, 4)?).ok()?, 2usize, ENTRY, 4usize, HEADER) - }; - if ifd < header { - return None; - } - let count = if big_tiff { usize::try_from(order.u64(b, ifd)?).ok()? } else { usize::from(order.u16(b, ifd)?) }; - let first = ifd.checked_add(count_bytes)?; - let next_ifd = first.checked_add(count.checked_mul(entry_bytes)?)?; - if next_ifd.checked_add(next_ifd_bytes)? > b.len() { - return None; - } - // In bounds: every entry ends at or before `next_ifd`. - Some((order, first, count, entry_bytes, big_tiff)) -} - -/// A well-formed Orientation entry's value: where it sits and its field type. -#[derive(Clone, Copy)] -struct Value { - at: usize, - ty: u16, -} - -impl Value { - /// The stored value (a SHORT or LONG, left-justified in the 4-byte field). - fn read(self, order: Order, b: &[u8]) -> Option { - match self.ty { - TYPE_SHORT => order.u16(b, self.at).map(u32::from), - _ => order.u32(b, self.at), - } - } - - /// 1 in this entry's own type, width and byte order. - fn one(self, order: Order) -> Vec { - match (self.ty, order) { - (TYPE_SHORT, Order::Little) => 1u16.to_le_bytes().to_vec(), - (TYPE_SHORT, Order::Big) => 1u16.to_be_bytes().to_vec(), - (_, Order::Little) => 1u32.to_le_bytes().to_vec(), - (_, Order::Big) => 1u32.to_be_bytes().to_vec(), - } - } -} - -/// The value of the entry at `e` if it is a well-formed Orientation entry: -/// exactly one SHORT or LONG. -fn orientation_value(order: Order, b: &[u8], e: usize, big_tiff: bool) -> Option { - let count = if big_tiff { order.u64(b, e.checked_add(4)?)? } else { u64::from(order.u32(b, e.checked_add(4)?)?) }; - if order.u16(b, e)? != TAG_ORIENTATION || count != 1 { - return None; - } - let ty = order.u16(b, e.checked_add(2)?)?; - let value_offset = if big_tiff { 12 } else { 8 }; - matches!(ty, TYPE_SHORT | TYPE_LONG).then_some(Value { at: e.checked_add(value_offset)?, ty }) -} - -/// Locates the Orientation value in IFD0. -/// -/// The **first** Orientation entry wins (like libexif and Photoshop); if that -/// one is malformed (count ≠ 1, or neither SHORT nor LONG) the tag is ignored, -/// even when a later duplicate is well formed. -fn find_entry(b: &[u8]) -> Option<(Order, Value)> { - let (order, first, count, entry_bytes, big_tiff) = ifd0_entries(b)?; - let e = (0..count).filter_map(|i| first.checked_add(i.checked_mul(entry_bytes)?)).find(|&e| order.u16(b, e) == Some(TAG_ORIENTATION))?; - Some((order, orientation_value(order, b, e, big_tiff)?)) -} - -/// The orientation (1–8) recorded in a TIFF-structured block: an EXIF payload -/// (with or without the `Exif\0\0` prefix) or a whole TIFF file. Missing, -/// malformed or out-of-range values give 1. -pub fn exif_orientation(exif: &[u8]) -> u16 { - let b = tiff_body(exif); - find_entry(b).and_then(|(order, v)| v.read(order, b)).and_then(|v| u16::try_from(v).ok()).filter(|v| (1..=8).contains(v)).unwrap_or(1) -} - -/// `exif` with its Orientation rewritten to 1, borrowed when there is nothing -/// to change (no well-formed tag, already 1, or unparseable). -/// -/// Only the value bytes of each well-formed Orientation entry change, written -/// as 1 in the entry's existing type and width (SHORT or LONG); every other -/// byte (other tags, their offset-based values, sub-IFDs) is kept as is. -/// Well-formed duplicates are all set to 1, so a reader that lets a later -/// duplicate win cannot rotate the upright pixels either. -pub fn upright_exif(exif: &[u8]) -> Cow<'_, [u8]> { - let body = tiff_body(exif); - let prefix = exif.len() - body.len(); - let Some((order, first, count, entry_bytes, big_tiff)) = ifd0_entries(body) else { - return Cow::Borrowed(exif); - }; - let values: Vec = (0..count) - .filter_map(|i| first.checked_add(i.checked_mul(entry_bytes)?)) - .filter_map(|e| orientation_value(order, body, e, big_tiff)) - .collect(); - if values.iter().all(|v| v.read(order, body) == Some(1)) { - return Cow::Borrowed(exif); - } - let mut out = exif.to_vec(); - for v in values { - let one = v.one(order); - let slot = prefix.checked_add(v.at).and_then(|at| out.get_mut(at..at.checked_add(one.len())?)); - if let Some(slot) = slot { - slot.copy_from_slice(&one); - } - } - Cow::Owned(out) -} - -/// `xmp` with any `tiff:Orientation` (attribute or element form) set to 1, -/// borrowed when there is nothing to change. -pub fn upright_xmp(xmp: &str) -> Cow<'_, str> { - const KEY: &str = "tiff:Orientation"; - if !xmp.contains(KEY) { - return Cow::Borrowed(xmp); - } - let mut out = String::with_capacity(xmp.len()); - let mut rest = xmp; - let mut changed = false; - while let Some(i) = rest.find(KEY) { - let (head, tail) = rest.split_at(i + KEY.len()); - out.push_str(head); - rest = tail; - // `tiff:Orientation="6"`, `tiff:Orientation='6'` or `6<`. - let open = rest.char_indices().take_while(|&(_, c)| c.is_ascii_whitespace() || matches!(c, '=' | '"' | '\'' | '>')).last(); - let Some((at, c)) = open else { continue }; - if !matches!(c, '"' | '\'' | '>') { - continue; - } - let start = at + 1; - let digits = rest.get(start..).map_or(0, |s| s.bytes().take_while(u8::is_ascii_digit).count()); - if digits == 0 || rest.get(start..start + digits) == Some("1") { - continue; - } - out.push_str(rest.get(..start).unwrap_or_default()); - out.push('1'); - rest = rest.get(start + digits..).unwrap_or_default(); - changed = true; - } - out.push_str(rest); - if changed { Cow::Owned(out) } else { Cow::Borrowed(xmp) } +/// TIFF payload of an EXIF block (a JPEG-style `Exif\0\0` prefix is skipped). +pub(crate) fn tiff_body(bytes: &[u8]) -> &[u8] { + bytes.strip_prefix(b"Exif\0\0").unwrap_or(bytes) } /// Source pixel index for output pixel `(0, y2)` and the step per output column, for diff --git a/crates/image-codecs/src/resolution.rs b/crates/image-codecs/src/resolution.rs index a787cacbc..54e6759a0 100644 --- a/crates/image-codecs/src/resolution.rs +++ b/crates/image-codecs/src/resolution.rs @@ -1,575 +1,11 @@ -//! Image resolution (pixels per inch) recorded in metadata blocks: EXIF / TIFF IFD0 -//! (XResolution 282, YResolution 283, ResolutionUnit 296), XMP (`tiff:XResolution`, -//! `tiff:YResolution`, `tiff:ResolutionUnit`) and Photoshop's image resource -//! ResolutionInfo (`8BIM` resource 0x03ED); reading them, and rewriting the EXIF and XMP -//! copies on export so they agree with the resolution the file is written at. -//! -//! Implemented from TIFF 6.0 (section 8, "Baseline fields": XResolution / YResolution are -//! RATIONAL, ResolutionUnit is SHORT, 1 = no absolute unit, 2 = inch, 3 = centimetre, -//! default 2), EXIF 2.3 (same tags in the 0th IFD, same default) and the Adobe Photoshop File -//! Formats Specification (ResolutionInfo: Fixed 16.16 hRes in pixels per inch, then the -//! display units; the vertical resolution likewise). -//! -//! **Precedence** when a file carries several, as Photoshop resolves them: Photoshop's own -//! ResolutionInfo, then the XMP `tiff:` properties, then EXIF, and only then the format's own -//! density field when it is the generic JFIF one (see the JPEG decoder). JFIF density is last -//! because cameras record the real resolution in EXIF while many tools and libraries write a -//! default JFIF density of 72 (or a bare aspect ratio) without knowing it; Photoshop shows a -//! camera JPEG at its EXIF resolution whatever its JFIF header says. Formats whose own field is -//! written deliberately (PNG `pHYs`, TIFF tags) keep it first; the metadata blocks only fill in -//! when it is missing. -//! -//! Everything read here is untrusted: offsets and counts are bounds-checked, both byte orders -//! and BigTIFF-style EXIF are handled, and anything malformed reads as "no resolution" rather -//! than as a wrong one. +//! Shared EXIF/XMP/Photoshop resolution parsing and edits. -use std::borrow::Cow; +pub use craft_metadata::edit::{ + exif_resolution, exif_with_pixel_size, exif_with_resolution, exif_with_resolution_adding_missing, export_exif, + export_exif_adding_missing_resolution, export_xmp, photoshop_resolution, resolution, xmp_resolution, xmp_with_resolution, +}; -use crate::orientation::{Order, ifd0_entries, tiff_body, upright_exif, upright_xmp}; - -const TAG_X_RESOLUTION: u16 = 282; -const TAG_Y_RESOLUTION: u16 = 283; -const TAG_RESOLUTION_UNIT: u16 = 296; -const TYPE_SHORT: u16 = 3; -const TYPE_RATIONAL: u16 = 5; -const CM_PER_INCH: f64 = 2.54; -/// Photoshop's ResolutionInfo image resource. -const RESOLUTION_INFO: u16 = 0x03ED; -/// Resolutions above this (pixels per inch) are treated as damage, not data. -const MAX_PPI: f64 = 1_000_000.0; -/// Two resolutions this close (pixels per inch) are the same. -const SAME_PPI: f64 = 1e-3; - -/// A usable resolution pair, or `None`. -fn ppi_pair(x: f64, y: f64) -> Option<(f32, f32)> { - let ok = |v: f64| v.is_finite() && v > 0.0 && v <= MAX_PPI; - (ok(x) && ok(y)).then_some((x as f32, y as f32)) -} - -fn same(a: (f32, f32), b: (f32, f32)) -> bool { - (f64::from(a.0) - f64::from(b.0)).abs() < SAME_PPI && (f64::from(a.1) - f64::from(b.1)).abs() < SAME_PPI -} - -/// `ppi` as a TIFF RATIONAL: a whole number over 1 when it is one, else over 1000. -fn rational(ppi: f32) -> (u32, u32) { - let p = f64::from(ppi); - if (p - p.round()).abs() < SAME_PPI { (p.round() as u32, 1) } else { ((p * 1000.0).round() as u32, 1000) } -} - -/// One of the three resolution entries of IFD0. -#[derive(Clone, Copy)] -struct Field { - /// Offset of the 12- (BigTIFF: 20-) byte entry. - entry: usize, - tag: u16, - ty: u16, - count: u64, - /// Where the value bytes are, when the type is one we read and they lie inside the block. - value: Option, -} - -impl Field { - fn short(&self, order: Order, b: &[u8]) -> Option { - (self.ty == TYPE_SHORT && self.count == 1).then_some(())?; - order.u16(b, self.value?) - } - - fn rational(&self, order: Order, b: &[u8]) -> Option { - (self.ty == TYPE_RATIONAL && self.count == 1).then_some(())?; - let at = self.value?; - let (n, d) = (order.u32(b, at)?, order.u32(b, at.checked_add(4)?)?); - (d != 0).then(|| f64::from(n) / f64::from(d)) - } -} - -/// IFD0's resolution entries. -struct Ifd0 { - order: Order, - big: bool, - first: usize, - count: usize, - entry_bytes: usize, - fields: Vec, -} - -impl Ifd0 { - fn parse(b: &[u8]) -> Option { - let (order, first, count, entry_bytes, big) = ifd0_entries(b)?; - let mut fields = Vec::new(); - for i in 0..count { - let e = first.checked_add(i.checked_mul(entry_bytes)?)?; - let tag = order.u16(b, e)?; - if !matches!(tag, TAG_X_RESOLUTION | TAG_Y_RESOLUTION | TAG_RESOLUTION_UNIT) { - continue; - } - let ty = order.u16(b, e.checked_add(2)?)?; - let count = if big { order.u64(b, e.checked_add(4)?)? } else { u64::from(order.u32(b, e.checked_add(4)?)?) }; - let value = value_at(order, b, e, big, ty, count); - fields.push(Field { entry: e, tag, ty, count, value }); - } - Some(Ifd0 { order, big, first, count, entry_bytes, fields }) - } - - fn first_of(&self, tag: u16) -> Option<&Field> { - self.fields.iter().find(|f| f.tag == tag) - } -} - -/// Where an entry's SHORT or RATIONAL value bytes are: inline in the entry when they fit, -/// else at the offset it holds. `None` for other types or when they leave the block. -fn value_at(order: Order, b: &[u8], e: usize, big: bool, ty: u16, count: u64) -> Option { - let size = match ty { - TYPE_SHORT => 2u64, - TYPE_RATIONAL => 8, - _ => return None, - } - .checked_mul(count)?; - let (field, inline) = if big { (e.checked_add(12)?, 8) } else { (e.checked_add(8)?, 4) }; - let at = if size <= inline { - field - } else if big { - usize::try_from(order.u64(b, field)?).ok()? - } else { - usize::try_from(order.u32(b, field)?).ok()? - }; - (at.checked_add(usize::try_from(size).ok()?)? <= b.len()).then_some(at) -} - -/// The resolution (pixels per inch, horizontal and vertical) recorded in IFD0 of an EXIF block -/// (with or without the JPEG `Exif\0\0` prefix) or a TIFF structure. -/// -/// Both XResolution and YResolution must be one RATIONAL each with a non-zero denominator. -/// ResolutionUnit 2 (inch, also when the tag is absent) is used as is, 3 (centimetre) is -/// converted; 1 (no absolute unit), any other value or a malformed unit entry gives `None`. -/// The first of duplicated entries wins. -pub fn exif_resolution(exif: &[u8]) -> Option<(f32, f32)> { - let b = tiff_body(exif); - let ifd = Ifd0::parse(b)?; - let unit = match ifd.first_of(TAG_RESOLUTION_UNIT) { - None => 2, - Some(f) => f.short(ifd.order, b)?, - }; - let scale = match unit { - 2 => 1.0, - 3 => CM_PER_INCH, - _ => return None, - }; - let x = ifd.first_of(TAG_X_RESOLUTION)?.rational(ifd.order, b)?; - let y = ifd.first_of(TAG_Y_RESOLUTION)?.rational(ifd.order, b)?; - ppi_pair(x * scale, y * scale) -} - -/// `exif` with its IFD0 resolution set to `ppi` (pixels per inch), borrowed when it has no -/// resolution entries, already records that resolution, or cannot be parsed. -/// -/// Existing well-formed XResolution / YResolution (one RATIONAL) entries are rewritten in place, -/// and every well-formed ResolutionUnit (one SHORT) becomes 2 (inch). Malformed entries are -/// removed from IFD0 instead, so no stale value survives; all other bytes are kept. -pub fn exif_with_resolution(exif: &[u8], ppi: (f32, f32)) -> Cow<'_, [u8]> { - exif_with_resolution_inner(exif, ppi, false) -} - -/// Like [`exif_with_resolution`], but adds X/Y resolution tags when a valid IFD0 has none. -/// Existing TIFF data stays in place, so its offsets remain valid. Used by CMYK JPEG, which -/// cannot carry a JFIF density marker. -pub(crate) fn exif_with_resolution_adding_missing(exif: &[u8], ppi: (f32, f32)) -> Cow<'_, [u8]> { - exif_with_resolution_inner(exif, ppi, true) -} - -/// Rewrite valid IFD0 resolution tags and optionally append tags that are missing or malformed. -fn exif_with_resolution_inner(exif: &[u8], ppi: (f32, f32), add_missing: bool) -> Cow<'_, [u8]> { - if ppi_pair(f64::from(ppi.0), f64::from(ppi.1)).is_none() { - return Cow::Borrowed(exif); - } - if exif.is_empty() { - if !add_missing { - return Cow::Borrowed(exif); - } - // An image with DPI but no source EXIF still needs a valid EXIF block when the output - // format cannot carry resolution in its own header (CMYK JPEG has no valid JFIF marker). - return Cow::Owned(exif_with_resolution_inner(b"II*\0\x08\0\0\0\0\0\0\0\0\0\0", ppi, true).into_owned()); - } - let body = tiff_body(exif); - let prefix = exif.len() - body.len(); - let Some(ifd) = Ifd0::parse(body) else { return Cow::Borrowed(exif) }; - if exif_resolution(body).is_some_and(|r| same(r, ppi)) { - return Cow::Borrowed(exif); - } - let missing_xy = ifd.first_of(TAG_X_RESOLUTION).and_then(|f| f.rational(ifd.order, body)).is_none() - || ifd.first_of(TAG_Y_RESOLUTION).and_then(|f| f.rational(ifd.order, body)).is_none(); - if add_missing && missing_xy { - let Some(body) = append_resolution_ifd(body, &ifd, ppi) else { return Cow::Borrowed(exif) }; - let mut full = exif.get(..prefix).unwrap_or_default().to_vec(); - full.extend_from_slice(&body); - return Cow::Owned(full); - } - if ifd.fields.is_empty() { - return Cow::Borrowed(exif); - } - let order = ifd.order; - let mut out = body.to_vec(); - let mut removed = Vec::new(); - for f in &ifd.fields { - let bytes = match f.tag { - TAG_RESOLUTION_UNIT if f.short(order, body).is_some() => put_u16(order, 2).to_vec(), - TAG_X_RESOLUTION | TAG_Y_RESOLUTION if f.rational(order, body).is_some() => { - let (n, d) = rational(if f.tag == TAG_X_RESOLUTION { ppi.0 } else { ppi.1 }); - [put_u32(order, n), put_u32(order, d)].concat() - } - _ => { - removed.push(f.entry); - continue; - } - }; - let slot = f.value.and_then(|at| out.get_mut(at..at.checked_add(bytes.len())?)); - match slot { - Some(slot) => slot.copy_from_slice(&bytes), - None => removed.push(f.entry), - } - } - if !removed.is_empty() { - remove_entries(&mut out, &ifd, &removed); - } - let mut full = exif.get(..prefix).unwrap_or_default().to_vec(); - full.extend_from_slice(&out); - if full == exif { Cow::Borrowed(exif) } else { Cow::Owned(full) } -} - -/// Append a replacement IFD0 with fresh resolution tags. Every other entry keeps its original -/// bytes and offsets, since the TIFF block's existing data remains where it was. -fn append_resolution_ifd(body: &[u8], ifd: &Ifd0, ppi: (f32, f32)) -> Option> { - let (count_bytes, next_bytes, alignment) = if ifd.big { (8usize, 8usize, 8usize) } else { (2usize, 4usize, 2usize) }; - let mut entries = Vec::with_capacity(ifd.count.saturating_add(3)); - for index in 0..ifd.count { - let entry = ifd.first.checked_add(index.checked_mul(ifd.entry_bytes)?)?; - let tag = ifd.order.u16(body, entry)?; - if matches!(tag, TAG_X_RESOLUTION | TAG_Y_RESOLUTION | TAG_RESOLUTION_UNIT) { - continue; - } - entries.push((tag, body.get(entry..entry.checked_add(ifd.entry_bytes)?)?.to_vec())); - } - let count = entries.len().checked_add(3)?; - if !ifd.big && count > usize::from(u16::MAX) { - return None; - } - - let new_ifd = align_up(body.len(), alignment)?; - let table_end = new_ifd.checked_add(count_bytes)?.checked_add(count.checked_mul(ifd.entry_bytes)?)?; - let next_at = ifd.first.checked_add(ifd.count.checked_mul(ifd.entry_bytes)?)?; - let next_ifd = body.get(next_at..next_at.checked_add(next_bytes)?)?; - let rational_at = align_up(table_end.checked_add(next_bytes)?, if ifd.big { 8 } else { 4 })?; - let y_rational_at = rational_at.checked_add(8)?; - if !ifd.big && (new_ifd > u32::MAX as usize || y_rational_at.checked_add(8)? > u32::MAX as usize) { - return None; - } - - entries.push((TAG_X_RESOLUTION, resolution_entry(ifd.order, ifd.big, TAG_X_RESOLUTION, u64::try_from(rational_at).ok()?)?)); - entries.push((TAG_Y_RESOLUTION, resolution_entry(ifd.order, ifd.big, TAG_Y_RESOLUTION, u64::try_from(y_rational_at).ok()?)?)); - entries.push((TAG_RESOLUTION_UNIT, resolution_entry(ifd.order, ifd.big, TAG_RESOLUTION_UNIT, 2)?)); - entries.sort_by_key(|(tag, _)| *tag); - - let mut out = body.to_vec(); - out.resize(new_ifd, 0); - if ifd.big { - out.extend_from_slice(&put_u64(ifd.order, count as u64)); - } else { - out.extend_from_slice(&put_u16(ifd.order, count as u16)); - } - for (_, entry) in entries { - out.extend_from_slice(&entry); - } - out.extend_from_slice(next_ifd); - out.resize(rational_at, 0); - let (xn, xd) = rational(ppi.0); - let (yn, yd) = rational(ppi.1); - out.extend_from_slice(&put_u32(ifd.order, xn)); - out.extend_from_slice(&put_u32(ifd.order, xd)); - out.extend_from_slice(&put_u32(ifd.order, yn)); - out.extend_from_slice(&put_u32(ifd.order, yd)); - - let offset_at: usize = if ifd.big { 8 } else { 4 }; - if ifd.big { - out.get_mut(offset_at..offset_at.checked_add(8)?)?.copy_from_slice(&put_u64(ifd.order, new_ifd as u64)); - } else { - out.get_mut(offset_at..offset_at.checked_add(4)?)?.copy_from_slice(&put_u32(ifd.order, u32::try_from(new_ifd).ok()?)); - } - Some(out) -} - -/// One IFD entry. Rational fields store an offset; the SHORT unit is inline. -fn resolution_entry(order: Order, big: bool, tag: u16, value: u64) -> Option> { - let entry_bytes = if big { 20 } else { 12 }; - let count_at = 4; - let value_at = if big { 12 } else { 8 }; - let mut entry = vec![0; entry_bytes]; - entry.get_mut(..2)?.copy_from_slice(&put_u16(order, tag)); - entry.get_mut(2..4)?.copy_from_slice(&put_u16(order, if tag == TAG_RESOLUTION_UNIT { TYPE_SHORT } else { TYPE_RATIONAL })); - if big { - entry.get_mut(count_at..count_at + 8)?.copy_from_slice(&put_u64(order, 1)); - if tag == TAG_RESOLUTION_UNIT { - entry.get_mut(value_at..value_at + 2)?.copy_from_slice(&put_u16(order, value as u16)); - } else { - entry.get_mut(value_at..value_at + 8)?.copy_from_slice(&put_u64(order, value)); - } - } else { - entry.get_mut(count_at..count_at + 4)?.copy_from_slice(&put_u32(order, 1)); - if tag == TAG_RESOLUTION_UNIT { - entry.get_mut(value_at..value_at + 2)?.copy_from_slice(&put_u16(order, value as u16)); - } else { - entry.get_mut(value_at..value_at + 4)?.copy_from_slice(&put_u32(order, u32::try_from(value).ok()?)); - } - } - Some(entry) -} - -/// Round `value` up to the next `alignment` boundary, returning `None` on overflow. -fn align_up(value: usize, alignment: usize) -> Option { - value.checked_add((alignment - value % alignment) % alignment) -} - -fn put_u16(order: Order, v: u16) -> [u8; 2] { - match order { - Order::Little => v.to_le_bytes(), - Order::Big => v.to_be_bytes(), - } -} - -fn put_u32(order: Order, v: u32) -> [u8; 4] { - match order { - Order::Little => v.to_le_bytes(), - Order::Big => v.to_be_bytes(), - } -} - -fn put_u64(order: Order, v: u64) -> [u8; 8] { - match order { - Order::Little => v.to_le_bytes(), - Order::Big => v.to_be_bytes(), - } -} - -/// Removes the IFD0 entries at offsets `removed` (see [`exif_with_resolution`]). -fn remove_entries(b: &mut [u8], ifd: &Ifd0, removed: &[usize]) { - let eb = ifd.entry_bytes; - let next_bytes = if ifd.big { 8 } else { 4 }; - let count_bytes = if ifd.big { 8 } else { 2 }; - let Some(table_end) = ifd.count.checked_mul(eb).and_then(|n| ifd.first.checked_add(n)) else { return }; - let Some(old) = b.get(ifd.first..table_end.saturating_add(next_bytes)).map(<[u8]>::to_vec) else { return }; - let mut table = Vec::with_capacity(old.len()); - let mut kept = 0usize; - for (i, entry) in old.chunks_exact(eb).take(ifd.count).enumerate() { - if !removed.contains(&(ifd.first + i * eb)) { - table.extend_from_slice(entry); - kept += 1; - } - } - table.extend_from_slice(old.get(ifd.count * eb..).unwrap_or_default()); - table.resize(old.len(), 0); - let count: Vec = if ifd.big { put_u64(ifd.order, kept as u64).to_vec() } else { put_u16(ifd.order, kept as u16).to_vec() }; - let Some(count_at) = ifd.first.checked_sub(count_bytes) else { return }; - if let Some(slot) = b.get_mut(count_at..ifd.first) { - slot.copy_from_slice(&count); - } - if let Some(slot) = b.get_mut(ifd.first..ifd.first + table.len()) { - slot.copy_from_slice(&table); - } -} - -/// The resolution in a Photoshop image resource block (a sequence of `8BIM` resources, as in a -/// JPEG's APP13 "Photoshop 3.0" segment or TIFF tag 34377): its ResolutionInfo (0x03ED), whose -/// Fixed 16.16 hRes / vRes are pixels per inch whatever display unit follows them. -pub fn photoshop_resolution(resources: &[u8]) -> Option<(f32, f32)> { - let be16 = |at: usize| resources.get(at..at.checked_add(2)?).map(|s| u16::from_be_bytes([s[0], s[1]])); - let be32 = |at: usize| resources.get(at..at.checked_add(4)?).map(|s| u32::from_be_bytes([s[0], s[1], s[2], s[3]])); - let mut i = 0usize; - while i < resources.len() { - let signature = resources.get(i..i.checked_add(4)?)?; - let id = be16(i.checked_add(4)?)?; - // Pascal name: length byte plus text, padded to an even size. - let name_len = usize::from(*resources.get(i.checked_add(6)?)?); - let name = (name_len + 1).next_multiple_of(2); - let size_at = i.checked_add(6)?.checked_add(name)?; - let size = usize::try_from(be32(size_at)?).ok()?; - let data = size_at.checked_add(4)?; - if signature == b"8BIM" && id == RESOLUTION_INFO { - let info = resources.get(data..data.checked_add(size)?)?; - if info.len() < 16 { - return None; - } - let fixed = |at: usize| be32(data + at).map(|v| f64::from(v) / 65536.0); - return ppi_pair(fixed(0)?, fixed(8)?); - } - i = data.checked_add(size)?.checked_add(size % 2)?; - } - None -} - -/// The text ranges of every value of XMP property `key` (`key="v"`, `key='v'` or -/// `v`), in order. -fn xmp_values(xmp: &str, key: &str) -> Vec<(usize, usize)> { - let mut out = Vec::new(); - let mut from = 0; - while let Some(k) = xmp.get(from..).and_then(|s| s.find(key)).map(|k| k + from) { - from = k + key.len(); - // An attribute or an opening tag of exactly this name (not ``, not `xkey`). - if !xmp.get(..k).and_then(|h| h.chars().next_back()).is_some_and(|c| c == '<' || c.is_ascii_whitespace()) { - continue; - } - let rest = xmp.get(from..).unwrap_or_default(); - let after_key = rest.trim_start(); - let (value, close) = if let Some(r) = after_key.strip_prefix('=') { - let r = r.trim_start(); - match r.chars().next() { - Some(q @ ('"' | '\'')) => (r.get(1..).unwrap_or_default(), q), - _ => continue, - } - } else if let Some(r) = rest.strip_prefix('>') { - (r, '<') - } else { - continue; - }; - let start = xmp.len() - value.len(); - // Advance past this value before searching for the next key. Without this, `from` - // only moved past the key text, so property-like text repeated inside an unrelated - // attribute re-ran this full-suffix `find(close)` for every occurrence, which is - // quadratic in the packet size. A missing close means the value is unterminated, so - // no later value can parse either; stop scanning in that case. - let Some(len) = value.find(close) else { break }; - out.push((start, start + len)); - from = start + len + close.len_utf8(); - } - out -} - -/// An XMP rational (`300/1`) or plain number. -fn xmp_number(s: &str) -> Option { - let s = s.trim(); - match s.split_once('/') { - Some((n, d)) => { - let (n, d) = (n.trim().parse::().ok()?, d.trim().parse::().ok()?); - (d != 0.0).then(|| n / d) - } - None => s.parse().ok(), - } -} - -const XMP_X: &str = "tiff:XResolution"; -const XMP_Y: &str = "tiff:YResolution"; -const XMP_UNIT: &str = "tiff:ResolutionUnit"; - -/// The resolution (pixels per inch) in an XMP packet's `tiff:XResolution` / `tiff:YResolution` -/// (with `tiff:ResolutionUnit`, 2 when absent, 3 converted from centimetres), or `None`. -pub fn xmp_resolution(xmp: &str) -> Option<(f32, f32)> { - let first = |key: &str| xmp_values(xmp, key).first().and_then(|&(a, b)| xmp.get(a..b)); - let unit = match first(XMP_UNIT) { - None => 2.0, - Some(u) => xmp_number(u)?, - }; - let scale = if unit == 2.0 { - 1.0 - } else if unit == 3.0 { - CM_PER_INCH - } else { - return None; - }; - ppi_pair(xmp_number(first(XMP_X)?)? * scale, xmp_number(first(XMP_Y)?)? * scale) -} - -/// `xmp` with its `tiff:` resolution properties set to `ppi` (and the unit to 2, inch), -/// borrowed when it has none or already says so. -pub fn xmp_with_resolution(xmp: &str, ppi: (f32, f32)) -> Cow<'_, str> { - if ppi_pair(f64::from(ppi.0), f64::from(ppi.1)).is_none() || xmp_resolution(xmp).is_some_and(|r| same(r, ppi)) { - return Cow::Borrowed(xmp); - } - let text = |v: f32| { - let (n, d) = rational(v); - format!("{n}/{d}") - }; - let mut edits: Vec<(usize, usize, String)> = Vec::new(); - for (key, value) in [(XMP_X, text(ppi.0)), (XMP_Y, text(ppi.1)), (XMP_UNIT, "2".to_owned())] { - edits.extend(xmp_values(xmp, key).into_iter().map(|(a, b)| (a, b, value.clone()))); - } - if edits.is_empty() { - return Cow::Borrowed(xmp); - } - edits.sort_by_key(|e| e.0); - let mut out = String::with_capacity(xmp.len() + 16); - let mut at = 0; - for (a, b, v) in edits { - // Overlapping ranges can only come from malformed markup; keep the first edit. - if a < at { - continue; - } - out.push_str(xmp.get(at..a).unwrap_or_default()); - out.push_str(&v); - at = b; - } - out.push_str(xmp.get(at..).unwrap_or_default()); - if out == xmp { Cow::Borrowed(xmp) } else { Cow::Owned(out) } -} - -/// `exif` without its embedded thumbnail, or `None` when it has none (or doesn't parse). -/// -/// EXIF keeps the thumbnail in IFD1, the IFD IFD0's next-IFD pointer names. Finder, Android's -/// gallery and upload pickers show that thumbnail instead of decoding the image, so a copied one -/// keeps showing the photo as it was before it was edited (#2147, #2373). The pointer is cleared; -/// nothing else moves, so every other offset in the block stays valid. -fn exif_without_thumbnail(exif: &[u8]) -> Option> { - let body = tiff_body(exif); - let prefix = exif.len() - body.len(); - let (_, first, count, entry_bytes, big_tiff) = ifd0_entries(body)?; - let next = prefix.checked_add(first)?.checked_add(count.checked_mul(entry_bytes)?)?; - let width = if big_tiff { 8 } else { 4 }; - // In bounds: `ifd0_entries` checked that the whole pointer is present. - if exif.get(next..next.checked_add(width)?)?.iter().all(|b| *b == 0) { - return None; - } - let mut out = exif.to_vec(); - out.get_mut(next..next + width)?.fill(0); - Some(out) -} - -/// The EXIF to write next to upright pixels at resolution `ppi`: Orientation 1 (see -/// [`upright_exif`]), no thumbnail of the source image (see [`exif_without_thumbnail`]) and, -/// when `ppi` is known, the resolution (see [`exif_with_resolution`]). -pub fn export_exif(exif: &[u8], ppi: Option<(f32, f32)>) -> Cow<'_, [u8]> { - export_exif_inner(exif, ppi, false) -} - -/// Export EXIF for a format without its own resolution field, adding missing X/Y resolution -/// entries to valid metadata when necessary. -pub(crate) fn export_exif_adding_missing_resolution(exif: &[u8], ppi: Option<(f32, f32)>) -> Cow<'_, [u8]> { - export_exif_inner(exif, ppi, true) -} - -/// Normalize EXIF orientation and thumbnails, optionally adding missing output resolution tags. -fn export_exif_inner(exif: &[u8], ppi: Option<(f32, f32)>, add_missing: bool) -> Cow<'_, [u8]> { - let up = upright_exif(exif); - let up = match exif_without_thumbnail(&up) { - Some(v) => Cow::Owned(v), - None => up, - }; - let Some(ppi) = ppi else { return up }; - let result = if add_missing { exif_with_resolution_adding_missing(&up, ppi) } else { exif_with_resolution(&up, ppi) }; - if let Cow::Owned(v) = result { - return Cow::Owned(v); - } - up -} - -/// The XMP to write next to upright pixels at resolution `ppi` (see [`upright_xmp`] and -/// [`xmp_with_resolution`]). -pub fn export_xmp(xmp: &str, ppi: Option<(f32, f32)>) -> Cow<'_, str> { - let up = upright_xmp(xmp); - let Some(ppi) = ppi else { return up }; - if let Cow::Owned(v) = xmp_with_resolution(&up, ppi) { - return Cow::Owned(v); - } - up -} - -/// The resolution a decoded file's metadata blocks record, in precedence order: XMP, then -/// EXIF (Photoshop's ResolutionInfo is format-specific and read by the decoder). +/// Resolution used by raster decode, preferring XMP over EXIF as before. pub(crate) fn from_metadata(exif: Option<&[u8]>, xmp: Option<&str>) -> Option<(f32, f32)> { - xmp.and_then(xmp_resolution).or_else(|| exif.and_then(exif_resolution)) + craft_metadata::edit::resolution(exif, xmp) } From 90e76d75720a33d45ec128c9e38dd697d97453f1 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 07:29:45 -0500 Subject: [PATCH 016/382] Use valid scan parameters in JPEG coverage --- crates/image-codecs/src/codecs/jpeg.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/image-codecs/src/codecs/jpeg.rs b/crates/image-codecs/src/codecs/jpeg.rs index e2e854622..23545bcb3 100644 --- a/crates/image-codecs/src/codecs/jpeg.rs +++ b/crates/image-codecs/src/codecs/jpeg.rs @@ -821,7 +821,10 @@ mod tests { fn lossless_and_twelve_bit_progressive_are_unsupported_not_damaged() { for marker in [0xC3, 0xC2] { let mut bytes = vec![0xFF, 0xD8, 0xFF, marker, 0, 11, 12, 0, 8, 0, 8, 1, 1, 0x11, 0]; - bytes.extend_from_slice(&[0xFF, 0xDA, 0, 8, 1, 1, 0, 0, 0x3F, 0, 0x12, 0x34, 0xFF, 0xD9]); + // A progressive frame's first scan is a DC scan (Ss=Se=0); a + // sequential frame uses the full spectral range (Ss=0, Se=63). + let spectral_end = if marker == 0xC2 { 0 } else { 0x3F }; + bytes.extend_from_slice(&[0xFF, 0xDA, 0, 8, 1, 1, 0, 0, spectral_end, 0, 0x12, 0x34, 0xFF, 0xD9]); let e = crate::decode(&bytes).unwrap_err(); assert!(matches!(e, CodecError::Unsupported { .. }), "{marker:#x}: {e:?}"); } From 0153632dfa8c739b96321f4e1009d55dc6deb03f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 07:32:07 -0500 Subject: [PATCH 017/382] Align codec EXIF thumbnail assertion --- crates/image-codecs/tests/it/resolution.rs | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/crates/image-codecs/tests/it/resolution.rs b/crates/image-codecs/tests/it/resolution.rs index eadecbaa3..14c682f8d 100644 --- a/crates/image-codecs/tests/it/resolution.rs +++ b/crates/image-codecs/tests/it/resolution.rs @@ -516,10 +516,13 @@ fn exports_drop_the_source_exif_thumbnail() { assert!(out.windows(6).any(|w| w == b"NIKON\0"), "the rest of the EXIF is kept"); near(exif_resolution(&out), ppi.map_or(300.0, |p| p.0)); } - // Only the pointer changes. + // Only the IFD1 pointer and thumbnail payload change: the pointer is unlinked and the + // stale JPEG bytes are blanked by the shared metadata editor. let out = export_exif(&exif, None); + let thumb_len = b"\xFF\xD8stale thumbnail\xFF\xD9".len(); let differing: Vec = (0..exif.len()).filter(|&i| exif[i] != out[i]).collect(); - assert!(differing.iter().all(|&i| (8 + 2 + 4 * 12..8 + 2 + 4 * 12 + 4).contains(&i)), "{differing:?}"); + assert!(differing.iter().all(|&i| (8 + 2 + 4 * 12..8 + 2 + 4 * 12 + 4).contains(&i) || i >= exif.len() - thumb_len), "{differing:?}"); + assert!(!out.windows(5).any(|w| w == b"stale")); // With a JPEG-style prefix too. let prefixed = [b"Exif\0\0".as_slice(), &exif].concat(); assert_eq!(next_ifd(e, &export_exif(&prefixed, None)[6..]), 0); From 5cbd15a0906e35bdbc01eb028c3a6670f2cffb55 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 07:48:03 -0500 Subject: [PATCH 018/382] Make progressive JPEG fixture valid --- crates/image-codecs/src/codecs/jpeg.rs | 28 +++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/crates/image-codecs/src/codecs/jpeg.rs b/crates/image-codecs/src/codecs/jpeg.rs index 23545bcb3..c2d178a9d 100644 --- a/crates/image-codecs/src/codecs/jpeg.rs +++ b/crates/image-codecs/src/codecs/jpeg.rs @@ -820,11 +820,29 @@ mod tests { #[test] fn lossless_and_twelve_bit_progressive_are_unsupported_not_damaged() { for marker in [0xC3, 0xC2] { - let mut bytes = vec![0xFF, 0xD8, 0xFF, marker, 0, 11, 12, 0, 8, 0, 8, 1, 1, 0x11, 0]; - // A progressive frame's first scan is a DC scan (Ss=Se=0); a - // sequential frame uses the full spectral range (Ss=0, Se=63). - let spectral_end = if marker == 0xC2 { 0 } else { 0x3F }; - bytes.extend_from_slice(&[0xFF, 0xDA, 0, 8, 1, 1, 0, 0, spectral_end, 0, 0x12, 0x34, 0xFF, 0xD9]); + let bytes = if marker == 0xC2 { + // Use a valid progressive DC scan so this exercises unsupported + // precision rather than failing on missing tables or scan syntax. + let mut bytes = vec![0xFF, 0xD8]; + let mut dqt = vec![0]; + dqt.extend([1u8; 64]); + segment(&mut bytes, 0xDB, &dqt); + segment(&mut bytes, marker, &[12, 0, 8, 0, 8, 1, 1, 0x11, 0]); + let mut dht = vec![0x00, 1]; + dht.extend([0u8; 15]); + dht.push(0); + dht.extend([0x10, 1]); + dht.extend([0u8; 15]); + dht.push(0); + segment(&mut bytes, 0xC4, &dht); + segment(&mut bytes, 0xDA, &[1, 1, 0, 0, 0, 0]); + bytes.extend([0x7F, 0xFF, 0xD9]); + bytes + } else { + let mut bytes = vec![0xFF, 0xD8, 0xFF, marker, 0, 11, 12, 0, 8, 0, 8, 1, 1, 0x11, 0]; + bytes.extend_from_slice(&[0xFF, 0xDA, 0, 8, 1, 1, 0, 0, 0x3F, 0, 0x12, 0x34, 0xFF, 0xD9]); + bytes + }; let e = crate::decode(&bytes).unwrap_err(); assert!(matches!(e, CodecError::Unsupported { .. }), "{marker:#x}: {e:?}"); } From 60b0258d27e4a7e695a33c30a62f9c90e0fd5f2f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 09:24:59 -0500 Subject: [PATCH 019/382] Accept supported 12-bit progressive JPEG decoding --- crates/image-codecs/src/codecs/jpeg.rs | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/crates/image-codecs/src/codecs/jpeg.rs b/crates/image-codecs/src/codecs/jpeg.rs index c2d178a9d..3bfdcddb2 100644 --- a/crates/image-codecs/src/codecs/jpeg.rs +++ b/crates/image-codecs/src/codecs/jpeg.rs @@ -818,7 +818,7 @@ mod tests { } #[test] - fn lossless_and_twelve_bit_progressive_are_unsupported_not_damaged() { + fn lossless_is_unsupported_and_twelve_bit_progressive_decodes() { for marker in [0xC3, 0xC2] { let bytes = if marker == 0xC2 { // Use a valid progressive DC scan so this exercises unsupported @@ -843,8 +843,15 @@ mod tests { bytes.extend_from_slice(&[0xFF, 0xDA, 0, 8, 1, 1, 0, 0, 0x3F, 0, 0x12, 0x34, 0xFF, 0xD9]); bytes }; - let e = crate::decode(&bytes).unwrap_err(); - assert!(matches!(e, CodecError::Unsupported { .. }), "{marker:#x}: {e:?}"); + if marker == 0xC2 { + // craft-jpeg supports 12-bit progressive Huffman frames; keep the facade's + // routing contract aligned with the decoder rather than rejecting valid input. + let image = crate::decode(&bytes).unwrap(); + assert_eq!((image.dimensions(), image.sample_type(), image.layout()), ((8, 8), SampleType::U16, ChannelLayout::Gray)); + } else { + let error = crate::decode(&bytes).unwrap_err(); + assert!(matches!(error, CodecError::Unsupported { .. }), "{marker:#x}: {error:?}"); + } } } From 2db7c82705077e0bdffbd388900d511d4949ce27 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 08:40:24 -0500 Subject: [PATCH 020/382] Preserve raster facade encode contracts --- crates/image-codecs/src/codecs/xpm.rs | 10 ++++++++++ crates/image-codecs/src/lib.rs | 5 +---- crates/raster-codecs/src/dds.rs | 11 +++++++++++ crates/raster-codecs/src/fits.rs | 3 +++ crates/raster-codecs/src/iff.rs | 3 +++ crates/raster-codecs/src/pnm.rs | 5 +++++ 6 files changed, 33 insertions(+), 4 deletions(-) diff --git a/crates/image-codecs/src/codecs/xpm.rs b/crates/image-codecs/src/codecs/xpm.rs index 2dbd867c9..c74b5f16b 100644 --- a/crates/image-codecs/src/codecs/xpm.rs +++ b/crates/image-codecs/src/codecs/xpm.rs @@ -114,6 +114,16 @@ pub(crate) fn named(name: &str) -> Option<[u8; 3]> { }) } +/// Exact, normalized X11 lookup for consumers that need table membership rather +/// than XPM's additional aliases and normalization rules. +pub(crate) fn exact_x11_name(name: &str) -> Option<[u8; 3]> { + if name.is_empty() || name.len() > 64 || !name.bytes().all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit()) { + return None; + } + let index = x11_colors::X11_COLORS.binary_search_by_key(&name, |(entry, _)| *entry).ok()?; + Some(x11_colors::X11_COLORS.get(index)?.1) +} + fn color(name: &str) -> Option<[u8; 4]> { if name.eq_ignore_ascii_case("none") { return Some([0, 0, 0, 0]); diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 8085ca44e..e6a54756c 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -218,10 +218,7 @@ pub fn pcx_dimensions(bytes: &[u8]) -> Option<(u32, u32)> { /// The X11 color-name lookup used by XPM files, expressed as normalized sRGB. pub fn xpm_named_color_rgb(name: &str) -> Option<[f32; 3]> { - if name.is_empty() || name.len() > 64 || !name.bytes().all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit()) { - return None; - } - let rgb = codecs::xpm::named(name)?; + let rgb = codecs::xpm::exact_x11_name(name)?; Some(rgb.map(|channel| f32::from(channel) / 255.0)) } diff --git a/crates/raster-codecs/src/dds.rs b/crates/raster-codecs/src/dds.rs index 789028fb4..eb703a074 100644 --- a/crates/raster-codecs/src/dds.rs +++ b/crates/raster-codecs/src/dds.rs @@ -52,6 +52,17 @@ pub fn encode(image: &Image, options: DdsOptions) -> Result, CodecError> if image.sample_type() != SampleType::U8 { return Err(CodecError::encode("DDS", "DDS is written at 8 bits per channel")); } + // BC storage encodes RGBA blocks. The generic image API can plan a + // conversion from other layouts, but this compatibility facade accepts + // only layouts its former writer stored directly. + let allowed = if options.compression.is_block() { + image.layout() == crate::ChannelLayout::Rgba + } else { + matches!(image.layout(), crate::ChannelLayout::Gray | crate::ChannelLayout::GrayA | crate::ChannelLayout::Rgb | crate::ChannelLayout::Rgba) + }; + if !allowed { + return Err(CodecError::encode("DDS", format!("{:?} pixels can't be written as `{}`", image.layout(), options.compression.name()))); + } let compression = match options.compression { DdsCompression::None => craft_image_codecs::DdsCompression::None, DdsCompression::Bc1 => craft_image_codecs::DdsCompression::Bc1, diff --git a/crates/raster-codecs/src/fits.rs b/crates/raster-codecs/src/fits.rs index 4a662ab6e..5b82541c9 100644 --- a/crates/raster-codecs/src/fits.rs +++ b/crates/raster-codecs/src/fits.rs @@ -12,5 +12,8 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result { bridge::format(Format::Fits, bytes, limits) } pub fn encode(image: &Image) -> Result, CodecError> { + if !matches!(image.layout(), crate::ChannelLayout::Gray | crate::ChannelLayout::Rgb) { + return Err(CodecError::encode("FITS", format!("FITS cannot store {:?}", image.layout()))); + } bridge::encode(image, Format::Fits, &Default::default()) } diff --git a/crates/raster-codecs/src/iff.rs b/crates/raster-codecs/src/iff.rs index 282617e21..b2d44b89a 100644 --- a/crates/raster-codecs/src/iff.rs +++ b/crates/raster-codecs/src/iff.rs @@ -9,5 +9,8 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result { bridge::format(Format::Iff, bytes, limits) } pub fn encode(image: &Image) -> Result, CodecError> { + if image.layout() != crate::ChannelLayout::Rgb || image.sample_type() != crate::SampleType::U8 { + return Err(CodecError::encode("IFF", "ILBM writer stores 8-bit RGB pixels")); + } bridge::encode(image, Format::Iff, &Default::default()) } diff --git a/crates/raster-codecs/src/pnm.rs b/crates/raster-codecs/src/pnm.rs index 834e6508a..338938700 100644 --- a/crates/raster-codecs/src/pnm.rs +++ b/crates/raster-codecs/src/pnm.rs @@ -9,5 +9,10 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result { bridge::format(Format::Pnm, bytes, limits) } pub fn encode(image: &Image) -> Result, CodecError> { + // PFM has only gray and RGB tuples. Preserve this facade's contract that + // unsupported layouts are refused instead of silently dropping alpha. + if image.sample_type() == crate::SampleType::F32 && !matches!(image.layout(), crate::ChannelLayout::Gray | crate::ChannelLayout::Rgb) { + return Err(CodecError::encode("PNM", format!("PFM cannot store {:?}", image.layout()))); + } bridge::encode(image, Format::Pnm, &Default::default()) } From 80b55dee5a4a33e5cedd38df16c10f2aebaeeb82 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 09:00:23 -0500 Subject: [PATCH 021/382] Allow alpha in IFF compatibility encoder --- crates/raster-codecs/src/iff.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/raster-codecs/src/iff.rs b/crates/raster-codecs/src/iff.rs index b2d44b89a..95e439a58 100644 --- a/crates/raster-codecs/src/iff.rs +++ b/crates/raster-codecs/src/iff.rs @@ -9,8 +9,8 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result { bridge::format(Format::Iff, bytes, limits) } pub fn encode(image: &Image) -> Result, CodecError> { - if image.layout() != crate::ChannelLayout::Rgb || image.sample_type() != crate::SampleType::U8 { - return Err(CodecError::encode("IFF", "ILBM writer stores 8-bit RGB pixels")); + if !matches!(image.layout(), crate::ChannelLayout::Rgb | crate::ChannelLayout::Rgba) || image.sample_type() != crate::SampleType::U8 { + return Err(CodecError::encode("IFF", "ILBM writer stores 8-bit RGB pixels with optional alpha")); } bridge::encode(image, Format::Iff, &Default::default()) } From 81bd633c7f384e6f964176eb0baa4b271f1c7f8e Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 08:51:23 -0500 Subject: [PATCH 022/382] Expose checked SVG preflight and viewport rewrite --- crates/svg/src/guard.rs | 16 +++++-- crates/svg/src/preflight.rs | 11 ++++- crates/svg/src/tree.rs | 89 ++++++++++++++++++++++++++++++++++--- 3 files changed, 104 insertions(+), 12 deletions(-) diff --git a/crates/svg/src/guard.rs b/crates/svg/src/guard.rs index 073bfe34c..f3573e443 100644 --- a/crates/svg/src/guard.rs +++ b/crates/svg/src/guard.rs @@ -178,6 +178,10 @@ pub fn too_wide(svg: &str, most: usize, most_work: usize) -> bool { pub struct Prescan<'s> { /// Whether the elements nest deeper than the cap. The pass stops there. pub too_deep: bool, + /// Deepest element nesting observed (markup entities count ten times). + pub depth: usize, + /// Deepest stack of unclosed source elements, excluding self-closing leaves. + pub open_depth: usize, /// The text with each data URL in an element's attribute values left out: a `data:` value's /// quotes kept, a `url(…)`'s parentheses and quotes. Borrowed when there is none, and the /// whole text when `too_deep`. An embedded picture is a data URL and most of the text when @@ -250,7 +254,7 @@ pub fn prescan(svg: &str, most: usize) -> Prescan<'_> { (b.len(), false) }; // (now, deepest) of the elements, and of the markup inside the document type. - let (mut elements, mut entities) = ((0usize, 0usize), (0usize, 0usize)); + let (mut elements, mut entities, mut open_depth) = ((0usize, 0usize), (0usize, 0usize), 0usize); let mut doctype_end = 0; let mut i = 0; while let Some(at) = b.get(i..).and_then(|rest| rest.iter().position(|c| *c == b'<')).map(|at| i + at) { @@ -287,8 +291,14 @@ pub fn prescan(svg: &str, most: usize) -> Prescan<'_> { end }; if elements.1.saturating_add(entities.1.saturating_mul(10)) > most { - return Prescan { too_deep: true, markers: Cow::Borrowed(svg) }; + return Prescan { + too_deep: true, + depth: elements.1.saturating_add(entities.1.saturating_mul(10)), + open_depth, + markers: Cow::Borrowed(svg), + }; } + open_depth = open_depth.max(elements.0); } let markers = if data_values.is_empty() { Cow::Borrowed(svg) @@ -303,7 +313,7 @@ pub fn prescan(svg: &str, most: usize) -> Prescan<'_> { text.push_str(svg.get(from..).unwrap_or_default()); Cow::Owned(text) }; - Prescan { too_deep: false, markers } + Prescan { too_deep: false, depth: elements.1.saturating_add(entities.1.saturating_mul(10)), open_depth, markers } } #[cfg(test)] diff --git a/crates/svg/src/preflight.rs b/crates/svg/src/preflight.rs index 3ab381ff3..a11a5d9b7 100644 --- a/crates/svg/src/preflight.rs +++ b/crates/svg/src/preflight.rs @@ -71,6 +71,11 @@ pub fn text<'a>(bytes: &'a [u8], limits: &Limits) -> Result, Error> /// Parses already-decoded SVG text and checks it against `limits`. pub fn parse_text<'a>(svg: &'a str, limits: &Limits) -> Result, Error> { + parse_text_with_depth(svg, limits).map(|(xml, _, _)| xml) +} + +/// Parses and validates SVG text, returning its source nesting depth as well as its XML tree. +pub fn parse_text_with_depth<'a>(svg: &'a str, limits: &Limits) -> Result<(roxmltree::Document<'a>, usize, usize), Error> { if svg.len() > limits.bytes { return Err(Error::Text(crate::svgz::Error::TooLarge(limits.bytes))); } @@ -83,9 +88,11 @@ pub fn parse_text<'a>(svg: &'a str, limits: &Limits) -> Result(bytes: &'a [u8], limits: &Limits) -> Result, Error> { let text = svgz::text(bytes, limits.bytes)?; - checked(&text, limits)?; + preflight(&text, limits)?; Ok(text) } @@ -130,12 +136,30 @@ pub fn parse(bytes: &[u8], limits: &Limits, options: &usvg::Options<'_>) -> Resu /// [`parse`] for SVG text the caller already holds. pub fn parse_text(svg: &str, limits: &Limits, options: &usvg::Options<'_>) -> Result { - let xml = checked(svg, limits)?; - usvg::Tree::from_xmltree(&xml, options).map_err(|e| Error::Parse(e.to_string())) + preflight(svg, limits)?.parse(options) } -/// Every check on SVG text, cheapest first; the XML it parses to on the way. -fn checked<'s>(svg: &'s str, limits: &Limits) -> Result, Error> { +/// SVG text after shared byte, entity, attribute, XML and expansion-depth checks. +/// Keep it opaque so consumers use the same checked tree and don't reparse XML locally. +pub struct Preflight<'s> { + xml: roxmltree::Document<'s>, + depth: usize, +} + +impl Preflight<'_> { + /// Maximum source nesting depth before following references. + pub fn depth(&self) -> usize { + self.depth + } + + /// Converts this already-checked XML into the configured usvg tree. + pub fn parse(self, options: &usvg::Options<'_>) -> Result { + usvg::Tree::from_xmltree(&self.xml, options).map_err(|e| Error::Parse(e.to_string())) + } +} + +/// Checks already-decoded SVG text once, retaining the parsed XML for both depth policy and tree conversion. +pub fn preflight<'s>(svg: &'s str, limits: &Limits) -> Result, Error> { let preflight_limits = crate::preflight::Limits { bytes: limits.bytes, depth: limits.depth, @@ -145,7 +169,7 @@ fn checked<'s>(svg: &'s str, limits: &Limits) -> Result, attribute_work: limits.attribute_work, xml_nodes: limits.xml_nodes, }; - let xml = crate::preflight::parse_text(svg, &preflight_limits).map_err(|e| match e { + let (xml, _depth, depth) = crate::preflight::parse_text_with_depth(svg, &preflight_limits).map_err(|e| match e { crate::preflight::Error::Text(e) => Error::Text(e), crate::preflight::Error::Entities => Error::Entities, crate::preflight::Error::EntityMarkup => Error::EntityMarkup, @@ -156,7 +180,58 @@ fn checked<'s>(svg: &'s str, limits: &Limits) -> Result, if height(&xml, limits.tree_depth)?.is_none() { return Err(Error::TooDeep(limits.tree_depth)); } - Ok(xml) + Ok(Preflight { xml, depth }) +} + +/// Dimensions of an SVG viewport in SVG user units. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Viewport { + pub width: f64, + pub height: f64, +} + +/// Wraps a validated SVG root in a new viewport while preserving the original root as content. +/// The original root must have finite, positive pixel or point dimensions. +pub fn rewrite_root_viewport(svg: &str, target: Viewport, limits: &Limits, output_limit: usize) -> Result { + if !target.width.is_finite() || !target.height.is_finite() || target.width <= 0.0 || target.height <= 0.0 { + return Err(Error::Viewport("target dimensions must be finite and positive".into())); + } + let checked = preflight(svg, limits)?; + let root = checked.xml.root_element(); + if root.tag_name().name() != "svg" { + return Err(Error::Viewport("root element is not svg".into())); + } + let root_dimension = |key: &str| { + let value = root.attribute(key)?; + let (number, scale) = value.strip_suffix("pt").map_or((value, 1.0), |n| (n, 4.0 / 3.0)); + number.parse::().ok().map(|n| n * scale).filter(|n| n.is_finite() && *n > 0.0) + }; + let (width, height) = root_dimension("width") + .zip(root_dimension("height")) + .ok_or_else(|| Error::Viewport("source has no finite pixel or point dimensions".into()))?; + let range = root.range(); + let preamble = svg.get(..range.start).ok_or_else(|| Error::Viewport("invalid XML preamble range".into()))?; + let inner = svg.get(range).ok_or_else(|| Error::Viewport("invalid root element range".into()))?; + let prefix = format!( + r#""#, + target.width, target.height, width, height + ); + let len = preamble + .len() + .checked_add(prefix.len()) + .and_then(|n| n.checked_add(inner.len())) + .and_then(|n| n.checked_add(6)) + .ok_or(Error::OutputTooLarge(output_limit))?; + if len > output_limit { + return Err(Error::OutputTooLarge(output_limit)); + } + let mut output = String::new(); + output.try_reserve_exact(len).map_err(|_| Error::OutputTooLarge(output_limit))?; + output.push_str(preamble); + output.push_str(&prefix); + output.push_str(inner); + output.push_str(""); + Ok(output) } /// Properties whose value an element's descendants use too: the paint server they name is From 330280203ce56ec31b329d2c1fd83394a3e5295d Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 08:58:12 -0500 Subject: [PATCH 023/382] Reuse bounded preflight for embedded SVG --- crates/svg/src/tree.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index f38dbf8d9..088d8bd89 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -509,17 +509,18 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<' } }; used.bytes.fetch_add(text.len(), Ordering::Relaxed); - let xml = match checked(&text, limits) { - Ok(xml) => xml, + let checked = match preflight(&text, limits) { + Ok(checked) => checked, + Err(Error::TooDeep(_)) => { + used.svg_limit.fetch_add(1, Ordering::Relaxed); + return None; + } Err(_) => { used.invalid_svg.fetch_add(1, Ordering::Relaxed); return None; } }; - let Some(xml_depth) = height(&xml, limits.tree_depth).ok().flatten() else { - used.svg_limit.fetch_add(1, Ordering::Relaxed); - return None; - }; + let xml_depth = checked.depth(); let total_depth = used.xml_depth.load(Ordering::Relaxed).checked_add(xml_depth); let Some(total_depth) = total_depth.filter(|depth| *depth <= limits.tree_depth) else { used.svg_limit.fetch_add(1, Ordering::Relaxed); @@ -528,7 +529,7 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<' let previous_depth = used.xml_depth.swap(total_depth, Ordering::Relaxed); let depth = used.depth.fetch_add(1, Ordering::Relaxed).saturating_add(1); used.svg_depth.fetch_max(depth, Ordering::Relaxed); - let tree = usvg::Tree::from_xmltree(&xml, options); + let tree = checked.parse(options); used.xml_depth.store(previous_depth, Ordering::Relaxed); used.depth.fetch_sub(1, Ordering::Relaxed); match tree { From 3eae15e8ecd17c5d02d3182659eee8f21d3b74fd Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 09:02:07 -0500 Subject: [PATCH 024/382] Expose bounded unitless SVG viewport metadata --- crates/svg/src/tree.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index 088d8bd89..fdabc2a50 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -183,6 +183,21 @@ pub fn preflight<'s>(svg: &'s str, limits: &Limits) -> Result, Err Ok(Preflight { xml, depth }) } +/// Reads finite numeric root `width` and `height` values without interpreting physical units. +pub fn root_unitless_size(svg: &str, limits: &Limits) -> Result, Error> { + let checked = preflight(svg, limits)?; + let root = checked.xml.root_element(); + if root.tag_name().name() != "svg" { + return Ok(None); + } + let Some((width, height)) = + root.attribute("width").and_then(|value| value.parse::().ok()).zip(root.attribute("height").and_then(|value| value.parse::().ok())) + else { + return Ok(None); + }; + Ok(Some((width, height))) +} + /// Dimensions of an SVG viewport in SVG user units. #[derive(Clone, Copy, Debug, PartialEq)] pub struct Viewport { From 344dbef231b1791675a01b3ba71e2c41645fbf35 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 13 Nov 2026 09:28:33 -0500 Subject: [PATCH 025/382] Test SVG preflight limits and classify bad embedded SVG --- crates/svg/src/preflight.rs | 26 ++++++++++++++++++++++++++ crates/svg/src/tree.rs | 6 +++++- 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/crates/svg/src/preflight.rs b/crates/svg/src/preflight.rs index a11a5d9b7..463c3ce16 100644 --- a/crates/svg/src/preflight.rs +++ b/crates/svg/src/preflight.rs @@ -96,3 +96,29 @@ pub fn parse_text_with_depth<'a>(svg: &'a str, limits: &Limits) -> Result<(roxml let xml = roxmltree::Document::parse_with_options(svg, options).map_err(|e| Error::Xml(e.to_string()))?; Ok((xml, prescan.depth, prescan.open_depth)) } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parsed_tree_reports_source_nesting_depth() -> Result<(), Error> { + let limits = Limits { depth: 4, ..Default::default() }; + let (document, depth, open_depth) = parse_text_with_depth("", &limits)?; + assert!(document.root_element().has_tag_name("svg")); + assert_eq!(depth, 2); + assert_eq!(open_depth, 0); + let simple = parse_text("", &limits)?; + assert!(simple.root_element().has_tag_name("svg")); + Ok(()) + } + + #[test] + fn source_depth_and_xml_errors_keep_their_specific_kind() { + let shallow = Limits { depth: 1, ..Default::default() }; + assert!(matches!(parse_text_with_depth("", &shallow), Err(Error::TooDeep(1)))); + + let normal = Limits::default(); + assert!(matches!(parse_text_with_depth("", &normal), Err(Error::Xml(_)))); + } +} diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index fdabc2a50..20dcd61cd 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -517,11 +517,15 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<' Ok(text) => text, // What a refused document unpacked before it was refused was work too: it uses up what // is left, so the next image can't repeat it. - Err(_) => { + Err(svgz::Error::TooLarge(_)) => { used.bytes.fetch_add(left, Ordering::Relaxed); used.svg_limit.fetch_add(1, Ordering::Relaxed); return None; } + Err(_) => { + used.invalid_svg.fetch_add(1, Ordering::Relaxed); + return None; + } }; used.bytes.fetch_add(text.len(), Ordering::Relaxed); let checked = match preflight(&text, limits) { From fd8a0dcf22b7e2d59393a5852727700d39fdebce Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Fri, 13 Nov 2026 19:12:02 -0500 Subject: [PATCH 026/382] craft-xlsx: review fixes: a long string chain stays within the depth bound; pending array metadata From the second review round (FredApps): - Strings joined with `&` are printed as one flat chain, which nests one level per string. A balanced tree of 4,096 empty strings fits in 16,383 token bytes and is 13 levels deep, but as a chain it was 4,096 levels, and printing and dropping it recurse: on a 256 KiB stack it overflowed. The chain is now made only up to MAX_DEPTH strings, the bound push keeps on the decoded tree (Excel's 8,192 characters hold at most about 33 full-length constants, so Python code split into constants is unaffected). A longer one prints as its tokens nest, with the parentheses that needs. GridCraft's tree walks a left-deep chain in a loop; the printer copied from craft-xls recurses, which is how the port lost the bound. - The first cell of a shared or array formula whose BrtShrFmla/BrtArrFmla never comes (another cell or the next row follows) loses its cell metadata too, as a formula kept as its value does. The new unit test overflowed its stack without this commit; the extended metadata test fails without it. The Excel-saved workbook still reads with all 33 formulas as in its .xlsx. --- crates/xlsx/src/xlsb.rs | 4 +++ crates/xlsx/src/xlsb/formula.rs | 61 +++++++++++++++++++++++++++++++-- crates/xlsx/tests/xlsb.rs | 16 +++++++-- 3 files changed, 77 insertions(+), 4 deletions(-) diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index d46c2ea20..2fdde59be 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -773,6 +773,10 @@ pub(crate) fn worksheet( } continue; } + // No formula record: the cell stays a value, so its formula's cell metadata goes too. + if let Some(cell) = row.as_mut().and_then(|r| r.cells.last_mut()).filter(|c| c.at == at) { + cell.cell_metadata = None; + } kept(warnings, "a shared or array formula that is missing from the file"); } match id { diff --git a/crates/xlsx/src/xlsb/formula.rs b/crates/xlsx/src/xlsb/formula.rs index 53b02f8a1..327ffcc25 100644 --- a/crates/xlsx/src/xlsb/formula.rs +++ b/crates/xlsx/src/xlsb/formula.rs @@ -477,6 +477,15 @@ fn literal_text(e: &Expr) -> bool { } } +/// How many strings a [`literal_text`] chain joins, or `None` for anything else. +fn literal_texts(e: &Expr) -> Option { + match e { + Expr::Text(_) => Some(1), + Expr::Binary(BinOp::Concat, a, b) => literal_texts(a)?.checked_add(literal_texts(b)?), + _ => None, + } +} + /// How tightly an expression binds when printed, as the formula parser reads it: binary /// operators by [`BinOp::precedence`], prefix `+`/`-` at 60 and `%` at 70 (`-2^2` is `(-2)^2`); /// anything else is one operand. @@ -512,8 +521,13 @@ fn paren(e: Expr) -> Expr { fn grouped(e: Expr, in_args: bool) -> Expr { match e { // Strings joined with `&` are written as one flat chain, however their tokens nest: `&` - // is associative, and `PY("…"&"…")` is read as Python code only in that form. - e @ Expr::Binary(BinOp::Concat, ..) if literal_text(&e) => { + // is associative, and `PY("…"&"…")` is read as Python code only in that form. The chain + // nests one level per string, so it is made only up to `MAX_DEPTH` strings, the bound + // `push` keeps on the decoded tree (Excel's 8,192 characters hold at most about 33 + // full-length constants). A longer one prints as its tokens nest, with the parentheses + // that needs: a balanced tree of thousands of strings is only a few levels deep, and + // printing or dropping a chain of thousands would recurse past the stack. + e @ Expr::Binary(BinOp::Concat, ..) if literal_texts(&e).is_some_and(|n| n <= MAX_DEPTH) => { let mut texts = vec![]; flatten_texts(e, &mut texts); let mut texts = texts.into_iter(); @@ -575,3 +589,46 @@ fn array_constant(b: &mut Bytes<'_>) -> Result { } Ok(Expr::Array(out)) } + +#[cfg(test)] +mod tests { + use super::*; + + /// Postfix tokens for `n` empty strings joined by `&` as a balanced tree. + fn balanced_strings(n: usize, out: &mut Vec) { + if n == 1 { + out.extend([0x17, 0, 0]); + } else { + balanced_strings(n / 2, out); + balanced_strings(n - n / 2, out); + out.push(0x08); + } + } + + #[test] + fn a_long_chain_of_strings_stays_within_the_depth_bound() { + // 4,096 strings and 4,095 `&` fill 16,383 token bytes, 13 levels deep as written. Made + // into one flat chain they would be 4,096 levels deep, past what printing and dropping + // the tree may recurse; on a small stack that overflows. They print as written instead. + let mut rgce = vec![]; + balanced_strings(4096, &mut rgce); + assert!(rgce.len() <= MAX_RGCE); + let text = std::thread::Builder::new() + .stack_size(256 * 1024) + .spawn(move || { + let e = decode(&rgce, &[], &Links::default(), Mode::Cell).unwrap(); + let text = super::super::expr::print(&e); + drop(e); + text + }) + .unwrap() + .join() + .unwrap(); + assert_eq!(text.matches("\"\"").count(), 4096); + // A short chain, such as Python code split into constants, is still one flat chain. + let mut short = vec![]; + balanced_strings(4, &mut short); + let e = decode(&short, &[], &Links::default(), Mode::Cell).unwrap(); + assert_eq!(super::super::expr::print(&e), "\"\"&\"\"&\"\"&\"\""); + } +} diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index 518ca5214..ee9ac3afd 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -909,12 +909,24 @@ fn a_dynamic_array_kept_as_its_value_has_no_cell_metadata() { part(1, (0, 1)), range_formula(426, (0, 1, 1, 1), &[0xFF]), // C1: a value with cell metadata keeps it, as the file has it. - meta, + meta.clone(), cell(5, 2, &1.0f64.to_le_bytes()), + // D1: the first cell of a dynamic array with no BrtArrFmla after it, then a value, E1. + meta.clone(), + part(3, (0, 3)), + cell(5, 4, &1.0f64.to_le_bytes()), + // F1: the same as the last cell of its row. + meta, + part(5, (0, 5)), + row(1), + cell(5, 0, &1.0f64.to_le_bytes()), ] .concat(); let wb = read(&file(&worksheet(&data, &[]))).unwrap(); let sheet = &wb.sheets[0]; - assert_eq!((sheet.formula(at("A1")), sheet.formula(at("B1"))), (None, None)); + for a in ["A1", "B1", "D1", "F1"] { + assert_eq!(sheet.formula(at(a)), None, "{a}"); + } assert_eq!(sheet.cell_metadata.iter().collect::>(), [(&at("C1"), &1)]); + assert!(warned(&wb, "missing from the file"), "{:?}", wb.warnings); } From 3e957e0fd1a9821221154bb151b4debab5f30955 Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Fri, 13 Nov 2026 23:35:18 -0500 Subject: [PATCH 027/382] craft-xlsx: read the styles part of a binary workbook Package::styles() reads styles.bin into the same Styles the XML part gives: number formats, fonts, fills, borders, cell and cell style formats, cell styles, differential formats and indexed colours, spelled as Excel writes them in styles.xml. A damaged part is a warning and no styles; each table holds at most 65,536 entries. Closes #1253. --- crates/xlsx/README.md | 7 +- crates/xlsx/src/document.rs | 4 +- crates/xlsx/src/package.rs | 20 +- crates/xlsx/src/xlsb.rs | 6 +- crates/xlsx/src/xlsb/styles.rs | 471 +++++++++++++++++++++++++++++++++ crates/xlsx/tests/xlsb.rs | 266 ++++++++++++++++++- 6 files changed, 764 insertions(+), 10 deletions(-) create mode 100644 crates/xlsx/src/xlsb/styles.rs diff --git a/crates/xlsx/README.md b/crates/xlsx/README.md index 1dc30574d..b2b581112 100644 --- a/crates/xlsx/README.md +++ b/crates/xlsx/README.md @@ -83,8 +83,11 @@ for new pictures (`vm = i + 1`) and the `XLDAPR` dynamic-array metadata (`cm = 1 The parts this crate writes use the transitional namespaces; a strict file's kept parts stay as they were. A binary workbook is not written. -A binary workbook gives the same `Workbook`, strings, rows and merged cells. Its styles are not -read (each cell keeps its format index). Its cell formulas are decoded from their tokens into the +A binary workbook gives the same `Workbook`, strings, rows and merged cells, and the same +`Styles`: number formats, fonts, fills, borders, cell and cell style formats, cell styles, +differential formats and the indexed colours, as Excel writes them in `styles.xml` (default fill +colours and empty settings left out, a cell style format's `apply*="0"`). Custom table styles and +recent colours are not read; a damaged styles part is a warning and no styles. Its cell formulas are decoded from their tokens into the text an `.xlsx` file holds (`_xlfn.` and `_xlpm.` names as written, no implicit `@`), with `FormulaKind::Shared` or `FormulaKind::Array` and their ranges, and `BrtCellMeta` as the cell metadata index. Every cell of a shared formula gets its own text, decoded at the cell, since the diff --git a/crates/xlsx/src/document.rs b/crates/xlsx/src/document.rs index 26e6a84c6..1be23029e 100644 --- a/crates/xlsx/src/document.rs +++ b/crates/xlsx/src/document.rs @@ -209,8 +209,8 @@ pub struct Document { } impl Document { - /// Reads every part. A binary workbook is refused: its formulas and styles are not read, so - /// it cannot be written back as SpreadsheetML without loss. + /// Reads every part. A binary workbook is refused: only some of its parts are read, so it + /// cannot be written back as SpreadsheetML without loss. pub fn read(bytes: &[u8], limits: &Limits) -> Result { let mut p = Package::open(bytes, limits)?; if p.is_binary() { diff --git a/crates/xlsx/src/package.rs b/crates/xlsx/src/package.rs index 8f2c5efc6..f16b20d57 100644 --- a/crates/xlsx/src/package.rs +++ b/crates/xlsx/src/package.rs @@ -214,16 +214,28 @@ impl<'a> Package<'a> { Ok(items) } - /// The styles part, `None` when the workbook has none (or is binary: its styles are not read). + /// The styles part, `None` when the workbook has none. A damaged one is a warning and `None`; + /// only a limit is an error. pub fn styles(&mut self) -> Result, Error> { - if self.binary.is_some() { - return Ok(None); - } let rels = self.workbook_rels()?; let Some(rel) = rels.first("styles").filter(|r| !r.external) else { self.warn("no styles part"); return Ok(None); }; + if let Some(types) = &self.binary { + let read = xlsb::check_type(types, &rel.target, xlsb::STYLES).and_then(|()| { + let bytes = self.opc.read(&rel.target)?.ok_or_else(|| xlsb::invalid(format!("missing part {}", rel.target)))?; + xlsb::styles(&bytes, &self.limits, &self.budget, &mut self.warnings) + }); + return match read { + Ok(styles) => Ok(Some(styles)), + Err(Error::TooLarge(m)) => Err(Error::TooLarge(m)), + Err(e) => { + self.warn(format!("skipped {}: {e}", rel.target)); + Ok(None) + } + }; + } Ok(self.optional_xml(&rel.target.clone())?.map(Styles::read)) } diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index 2fdde59be..50da6185c 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -1,11 +1,13 @@ //! Binary workbooks ([MS-XLSB]): the workbook part, shared strings and worksheet cells, from //! their records. Cell formulas are decoded from their tokens ([`formula`]) into the text an //! `.xlsx` file holds; one that can't be keeps only its saved result, with a warning saying why. -//! Styles are not read. A record that does not parse fails the read. +//! The styles part is read into the same [`crate::styles::Styles`] ([`styles`]). A record that +//! does not parse fails the read. mod expr; mod formula; mod ftab; +mod styles; use std::collections::HashMap; use std::sync::Arc; @@ -19,11 +21,13 @@ use crate::workbook::{SheetEntry, SheetKind, Workbook}; use crate::{Error, Limits, Warnings}; pub(crate) use formula::Links; use formula::{Book, Mode, Name, Xti}; +pub(crate) use styles::styles; pub(crate) const MAIN: &str = "application/vnd.ms-excel.main"; const BINARY_MAIN: &str = "application/vnd.ms-excel.sheet.binary.macroEnabled.main"; pub(crate) const WORKSHEET: &str = "application/vnd.ms-excel.worksheet"; pub(crate) const STRINGS: &str = "application/vnd.ms-excel.sharedStrings"; +pub(crate) const STYLES: &str = "application/vnd.ms-excel.styles"; /// Most sheets in the workbook. const MAX_SHEETS: usize = 1024; /// Most merged ranges in one worksheet. diff --git a/crates/xlsx/src/xlsb/styles.rs b/crates/xlsx/src/xlsb/styles.rs new file mode 100644 index 000000000..094620a07 --- /dev/null +++ b/crates/xlsx/src/xlsb/styles.rs @@ -0,0 +1,471 @@ +//! The styles part of a binary workbook (`styles.bin`, [MS-XLSB] 2.1.7.50), read into the same +//! [`Styles`] the XML part gives: what Excel writes in `styles.xml` for the same workbook. Table +//! styles, recent colours and future records are not read. + +use craft_sheet::{BorderStyle, HAlign, Pattern, Script, Underline, VAlign}; +use craft_xml::El; + +use super::{Budget, Bytes, Records, invalid}; +use crate::styles::{ + Alignment, Border, BorderEdge, CellStyle, Color, ColorSource, Dxf, Fill, Font, FontScheme, GradientFill, NumFmt, PatternFill, Protection, Styles, + Xf, +}; +use crate::{Error, Limits, Warnings}; + +/// Characters of a font name or number format kept, as the XML side keeps of a font name. +const MAX_NAME_CHARS: usize = 255; +/// Longest string read from the part (Excel's own limits are 31 and 255 characters). +const MAX_STRING_UNITS: u32 = 32_767; +/// Most stops in one gradient fill (Excel writes a handful). +const MAX_STOPS: u32 = 1024; +/// Most entries in one table of the part (Excel allows about 64,000 cell formats). Each entry is +/// an allocation, and the record allowance alone would let a small part hold millions. +const MAX_ENTRIES: usize = 65_536; + +/// `BrtColor` and `XFPropColor`: the same eight bytes. `None` for "not set" (`XFPropColor` type 4). +fn color(b: &mut Bytes<'_>) -> Result, Error> { + let kind = b.u8()? >> 1; + let index = b.u8()?; + let tint = i16::from_le_bytes(<[u8; 2]>::try_from(b.take(2)?).map_err(|_| invalid("truncated colour"))?); + let [r, g, bl, a] = <[u8; 4]>::try_from(b.take(4)?).map_err(|_| invalid("truncated colour"))?; + let source = match kind { + 0 => ColorSource::Auto, + 1 => ColorSource::Indexed(u32::from(index)), + 2 => ColorSource::Rgb(u32::from_be_bytes([a, r, g, bl])), + 3 => ColorSource::Theme(u32::from(index)), + _ => return Ok(None), + }; + Ok(Some(Color { source, tint: (f64::from(tint) / 32767.0).clamp(-1.0, 1.0) })) +} + +fn pattern(fls: u32) -> Result { + const PATTERNS: [Pattern; 19] = [ + Pattern::None, + Pattern::Solid, + Pattern::Gray50, + Pattern::Gray75, + Pattern::Gray25, + Pattern::DarkHorizontal, + Pattern::DarkVertical, + Pattern::DarkDown, + Pattern::DarkUp, + Pattern::DarkGrid, + Pattern::DarkTrellis, + Pattern::LightHorizontal, + Pattern::LightVertical, + Pattern::LightDown, + Pattern::LightUp, + Pattern::LightGrid, + Pattern::LightTrellis, + Pattern::Gray125, + Pattern::Gray0625, + ]; + PATTERNS.get(fls as usize).copied().ok_or_else(|| invalid("unknown fill pattern")) +} + +fn border_style(dg: u16) -> Result { + const STYLES: [BorderStyle; 14] = [ + BorderStyle::None, + BorderStyle::Thin, + BorderStyle::Medium, + BorderStyle::Dashed, + BorderStyle::Dotted, + BorderStyle::Thick, + BorderStyle::Double, + BorderStyle::Hair, + BorderStyle::MediumDashed, + BorderStyle::DashDot, + BorderStyle::MediumDashDot, + BorderStyle::DashDotDot, + BorderStyle::MediumDashDotDot, + BorderStyle::SlantDashDot, + ]; + STYLES.get(usize::from(dg)).copied().ok_or_else(|| invalid("unknown border style")) +} + +fn halign(alc: u32) -> Option { + [HAlign::General, HAlign::Left, HAlign::Center, HAlign::Right, HAlign::Fill, HAlign::Justify, HAlign::CenterAcross, HAlign::Distributed] + .get(alc as usize) + .copied() +} + +fn valign(alcv: u32) -> Option { + [VAlign::Top, VAlign::Center, VAlign::Bottom, VAlign::Justify, VAlign::Distributed].get(alcv as usize).copied() +} + +fn underline(uls: u32) -> Underline { + match uls { + 0 => Underline::None, + 2 => Underline::Double, + 0x21 => Underline::SingleAccounting, + 0x22 => Underline::DoubleAccounting, + _ => Underline::Single, + } +} + +fn script(sss: u32) -> Script { + match sss { + 1 => Script::Superscript, + 2 => Script::Subscript, + _ => Script::Baseline, + } +} + +fn scheme(s: u32) -> Option { + match s { + 0 => Some(FontScheme::None), + 1 => Some(FontScheme::Major), + 2 => Some(FontScheme::Minor), + _ => None, + } +} + +fn name(text: String) -> String { + text.chars().take(MAX_NAME_CHARS).collect() +} + +/// `BrtFont`: only what Excel's `.xlsx` states for the same font (no ``, no scheme +/// `none`, no family or character set 0). +fn font(b: &mut Bytes<'_>) -> Result { + let height = b.u16()?; + let flags = b.u16()?; + let weight = b.u16()?; + let sss = b.u16()?; + let uls = b.u8()?; + let family = b.u8()?; + let charset = b.u8()?; + b.u8()?; + let color = color(b)?; + let font_scheme = b.u8()?; + let font_name = name(b.text(MAX_STRING_UNITS)?); + let on = |bit: u16| (flags & bit != 0).then_some(true); + Ok(Font { + name: Some(font_name), + size: Some(f64::from(height) / 20.0), + bold: (weight >= 0x2BC).then_some(true), + italic: on(0x02), + strike: on(0x08), + outline: on(0x10), + shadow: on(0x20), + condense: on(0x40), + extend: on(0x80), + underline: (uls != 0).then(|| underline(u32::from(uls))), + vert_align: (sss != 0).then(|| script(u32::from(sss))), + color, + family: (family != 0).then_some(u32::from(family)), + charset: (charset != 0).then_some(u32::from(charset)), + scheme: scheme(u32::from(font_scheme)).filter(|s| *s != FontScheme::None), + }) +} + +/// A gradient's angle and inner rectangle, as `BrtFill` and `XFPropGradient` hold them. +fn gradient(b: &mut Bytes<'_>, path: bool) -> Result { + Ok(GradientFill { path, degree: b.f64()?, left: b.f64()?, right: b.f64()?, top: b.f64()?, bottom: b.f64()?, stops: vec![] }) +} + +/// `BrtFill`. Excel's `.xlsx` leaves out the default colours: system foreground (indexed 64) as +/// the pattern colour and system background (indexed 65) as the background. +fn fill(b: &mut Bytes<'_>) -> Result { + let fls = b.u32()?; + let fg = color(b)?; + let bg = color(b)?; + let kind = b.u32()?; + let mut g = gradient(b, kind == 1)?; + let count = b.u32()?; + if fls == 0x28 { + if count > MAX_STOPS { + return Err(invalid("too many gradient stops")); + } + for _ in 0..count { + let c = color(b)?.unwrap_or_default(); + g.stops.push((b.f64()?, c)); + } + return Ok(Fill::Gradient(g)); + } + let system = |c: Color, i: u32| c.source == ColorSource::Indexed(i) && c.tint == 0.0; + Ok(Fill::Pattern(PatternFill { pattern: Some(pattern(fls)?), fg: fg.filter(|c| !system(*c, 64)), bg: bg.filter(|c| !system(*c, 65)) })) +} + +/// `BrtBorder`: the five edges a cell border has, each stated (`` when it has no line). +fn border(b: &mut Bytes<'_>) -> Result { + let flags = b.u8()?; + let mut edge = || -> Result { + let style = border_style(u16::from(b.u8()?))?; + b.u8()?; + let c = color(b)?; + Ok(BorderEdge { style, color: c.filter(|_| style != BorderStyle::None) }) + }; + let (top, bottom, left, right, diagonal) = (edge()?, edge()?, edge()?, edge()?, edge()?); + Ok(Border { + left: Some(left), + right: Some(right), + top: Some(top), + bottom: Some(bottom), + diagonal: Some(diagonal), + vertical: None, + horizontal: None, + diagonal_up: flags & 2 != 0, + diagonal_down: flags & 1 != 0, + outline: true, + }) +} + +/// `BrtXF`. A cell style format (`style`) marks what it leaves out (`apply*="0"`); a cell format +/// marks what it sets apart from its style (`apply*="1"`). +fn xf(b: &mut Bytes<'_>, style: bool) -> Result { + const APPLY: [(u8, &str); 6] = [ + (0x01, "applyNumberFormat"), + (0x02, "applyFont"), + (0x10, "applyFill"), + (0x08, "applyBorder"), + (0x04, "applyAlignment"), + (0x20, "applyProtection"), + ]; + let parent = b.u16()?; + let num_fmt_id = u32::from(b.u16()?); + let font_id = u32::from(b.u16()?); + let fill_id = u32::from(b.u16()?); + let border_id = u32::from(b.u16()?); + let rotation = u32::from(b.u8()?); + let indent = u32::from(b.u8()?); + let flags = u32::from(b.u16()?); + let apply = b.u8()?; + b.u8()?; + let alignment = Alignment { + horizontal: halign(flags & 7).filter(|h| *h != HAlign::General), + vertical: valign((flags >> 3) & 7).filter(|v| *v != VAlign::Bottom), + text_rotation: (rotation != 0).then_some(rotation), + wrap_text: flags & 0x40 != 0, + justify_last_line: flags & 0x80 != 0, + shrink_to_fit: flags & 0x100 != 0, + indent: (indent != 0).then_some(indent), + reading_order: Some((flags >> 10) & 3).filter(|r| *r != 0), + }; + let protection = Protection { locked: (flags & 0x1000 == 0).then_some(false), hidden: (flags & 0x2000 != 0).then_some(true) }; + let mut el = El::new("xf"); + for (bit, attr) in APPLY { + if apply & bit != 0 { + el = el.with_attr(attr, if style { "0" } else { "1" }); + } + } + Ok(Xf { + num_fmt_id, + font_id, + fill_id, + border_id, + xf_id: (!style).then_some(u32::from(parent)), + alignment: (alignment != Alignment::default()).then_some(alignment), + protection: (protection != Protection::default()).then_some(protection), + quote_prefix: flags & 0x8000 != 0, + el, + }) +} + +/// `BrtStyle`. +fn cell_style(b: &mut Bytes<'_>) -> Result { + let xf_id = b.u32()?; + let flags = b.u16()?; + let builtin = b.u8()?; + let level = b.u8()?; + let style_name = b.string(MAX_STRING_UNITS, true)?.map(name).unwrap_or_default(); + let is_builtin = flags & 1 != 0; + Ok(CellStyle { + name: style_name, + xf_id, + builtin_id: is_builtin.then_some(u32::from(builtin)), + level: (is_builtin && matches!(builtin, 1 | 2)).then_some(u32::from(level)), + hidden: flags & 2 != 0, + custom_builtin: flags & 4 != 0, + }) +} + +/// An unsigned integer of the size a property has (1, 2 or 4 bytes). +fn uint(data: &[u8]) -> Result { + match *data { + [a] => Ok(u32::from(a)), + [a, b] => Ok(u32::from(u16::from_le_bytes([a, b]))), + [a, b, c, d] => Ok(u32::from_le_bytes([a, b, c, d])), + _ => Err(invalid("unexpected formatting property size")), + } +} + +/// A string with a 2-byte length (`LPWideString`, and the number format of `XFProp` 0x26). +fn short_string(b: &mut Bytes<'_>) -> Result { + let count = usize::from(b.u16()?); + let mut text = String::new(); + for ch in char::decode_utf16(b.take(count * 2)?.as_chunks::<2>().0.iter().copied().map(u16::from_le_bytes)) { + text.push(ch.map_err(|_| invalid("invalid UTF-16 string"))?); + } + Ok(name(text)) +} + +fn dxf_font(d: &mut Dxf) -> &mut Font { + d.font.get_or_insert_with(Font::default) +} + +/// `BrtDXF`: its `XFProps`, each stating one property. +fn dxf(b: &mut Bytes<'_>) -> Result { + b.u16()?; + b.u16()?; + let count = b.u16()?; + let mut d = Dxf::default(); + let mut gradient_fill: Option = None; + let mut pattern_fill: Option = None; + for _ in 0..count { + let kind = b.u16()?; + let size = usize::from(b.u16()?).checked_sub(4).ok_or_else(|| invalid("formatting property too short"))?; + let data = b.take(size)?; + let mut p = Bytes::new(data); + match kind { + 0x00 => pattern_fill.get_or_insert_with(PatternFill::default).pattern = Some(pattern(uint(data)?)?), + 0x01 => pattern_fill.get_or_insert_with(PatternFill::default).fg = color(&mut p)?, + 0x02 => pattern_fill.get_or_insert_with(PatternFill::default).bg = color(&mut p)?, + 0x03 => { + let path = p.u32()? == 1; + gradient_fill = Some(gradient(&mut p, path)?); + } + 0x04 => { + let g = gradient_fill.as_mut().ok_or_else(|| invalid("gradient stop without a gradient"))?; + if g.stops.len() >= MAX_STOPS as usize { + return Err(invalid("too many gradient stops")); + } + p.u16()?; + let position = p.f64()?; + g.stops.push((position, color(&mut p)?.unwrap_or_default())); + } + 0x05 => dxf_font(&mut d).color = color(&mut p)?, + 0x06..=0x0C => { + let c = color(&mut p)?; + let edge = Some(BorderEdge { style: border_style(p.u16()?)?, color: c }); + let border = d.border.get_or_insert_with(|| Border { outline: true, ..Border::default() }); + match kind { + 0x06 => border.top = edge, + 0x07 => border.bottom = edge, + 0x08 => border.left = edge, + 0x09 => border.right = edge, + 0x0A => border.diagonal = edge, + 0x0B => border.vertical = edge, + _ => border.horizontal = edge, + } + } + 0x0D => d.border.get_or_insert_with(|| Border { outline: true, ..Border::default() }).diagonal_up = uint(data)? != 0, + 0x0E => d.border.get_or_insert_with(|| Border { outline: true, ..Border::default() }).diagonal_down = uint(data)? != 0, + 0x0F..=0x16 => { + let v = uint(data)?; + let a = d.alignment.get_or_insert_with(Alignment::default); + match kind { + 0x0F => a.horizontal = halign(v), + 0x10 => a.vertical = valign(v), + 0x11 => a.text_rotation = Some(v), + 0x12 => a.indent = Some(v), + 0x13 => a.reading_order = Some(v), + 0x14 => a.wrap_text = v != 0, + 0x15 => a.justify_last_line = v != 0, + _ => a.shrink_to_fit = v != 0, + } + } + 0x18 => dxf_font(&mut d).name = Some(short_string(&mut p)?), + 0x19 => dxf_font(&mut d).bold = Some(uint(data)? >= 0x2BC), + 0x1A => dxf_font(&mut d).underline = Some(underline(uint(data)?)), + 0x1B => dxf_font(&mut d).vert_align = Some(script(uint(data)?)), + 0x1C => dxf_font(&mut d).italic = Some(uint(data)? != 0), + 0x1D => dxf_font(&mut d).strike = Some(uint(data)? != 0), + 0x1E => dxf_font(&mut d).outline = Some(uint(data)? != 0), + 0x1F => dxf_font(&mut d).shadow = Some(uint(data)? != 0), + 0x20 => dxf_font(&mut d).condense = Some(uint(data)? != 0), + 0x21 => dxf_font(&mut d).extend = Some(uint(data)? != 0), + 0x22 => dxf_font(&mut d).charset = Some(uint(data)?), + 0x23 => dxf_font(&mut d).family = Some(uint(data)?), + 0x24 => dxf_font(&mut d).size = Some(f64::from(uint(data)?) / 20.0), + 0x25 => dxf_font(&mut d).scheme = scheme(uint(data)?), + 0x26 => d.num_fmt.get_or_insert_with(NumFmt::default).code = Some(short_string(&mut p)?), + 0x29 => d.num_fmt.get_or_insert_with(NumFmt::default).id = Some(uint(data)?), + 0x2B => d.protection.get_or_insert_with(Protection::default).locked = Some(uint(data)? != 0), + 0x2C => d.protection.get_or_insert_with(Protection::default).hidden = Some(uint(data)? != 0), + // Merged cells (0x17) and relative indents (0x2A) have no place in ``. + _ => {} + } + } + d.fill = gradient_fill.map(Fill::Gradient).or(pattern_fill.map(Fill::Pattern)); + Ok(d) +} + +/// The styles part: `BrtBeginStyleSheet` to `BrtEndStyleSheet`. +pub(crate) fn styles(bytes: &[u8], limits: &Limits, budget: &Budget, warnings: &mut Warnings) -> Result { + let mut records = Records::new(bytes, limits, budget); + records.first(278, warnings)?; + let mut s = Styles::default(); + // Inside BrtBeginCellStyleXFs (true) or BrtBeginCellXFs (false). + let mut xfs: Option = None; + let mut palette = false; + while let Some((id, payload)) = records.next(warnings)? { + let mut b = Bytes::new(payload); + let entries = match id { + 44 => s.num_fmts.len(), + 43 => s.fonts.len(), + 45 => s.fills.len(), + 46 => s.borders.len(), + 47 => s.cell_style_xfs.len().max(s.cell_xfs.len()), + 48 => s.cell_styles.len(), + 507 => s.dxfs.len(), + 475 => s.indexed_colors.len(), + _ => 0, + }; + if entries >= MAX_ENTRIES { + return Err(invalid(format!("more than {MAX_ENTRIES} entries in a styles table"))); + } + match id { + 279 => { + records.end(payload, warnings)?; + return Ok(s); + } + 44 => { + let id = u32::from(b.u16()?); + let code = name(b.text(MAX_STRING_UNITS)?); + budget.text(code.len(), limits)?; + s.num_fmts.push((id, code)); + } + 43 => { + let f = font(&mut b)?; + budget.text(f.name.as_ref().map_or(0, String::len), limits)?; + s.fonts.push(f); + } + 45 => s.fills.push(fill(&mut b)?), + 46 => s.borders.push(border(&mut b)?), + 626 => xfs = Some(true), + 617 => xfs = Some(false), + 627 | 618 => xfs = None, + 47 => match xfs { + Some(true) => s.cell_style_xfs.push(xf(&mut b, true)?), + Some(false) => s.cell_xfs.push(xf(&mut b, false)?), + None => return Err(invalid("cell format outside its list")), + }, + 48 => { + let c = cell_style(&mut b)?; + budget.text(c.name.len(), limits)?; + s.cell_styles.push(c); + } + 507 => s.dxfs.push(dxf(&mut b)?), + // BrtBeginIndexedColors, BrtEndIndexedColors. + 565 => palette = true, + 566 => palette = false, + 475 if palette => { + let [r, g, bl, _] = <[u8; 4]>::try_from(b.take(4)?).map_err(|_| invalid("truncated colour"))?; + s.indexed_colors.push(u32::from_be_bytes([0, r, g, bl])); + } + // BrtBeginTableStyles: the count of custom table styles, which are not read. + 508 => { + if b.u32()? > 0 { + warnings.warn("custom table styles in a binary workbook were not read"); + } + continue; + } + _ => continue, + } + // The records read above are read whole; the rest are skipped. + if matches!(id, 44 | 43 | 45 | 46 | 47 | 48 | 507 | 475) { + b.finish()?; + } + } + Err(invalid("missing styles end record")) +} diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index ee9ac3afd..bc1a7f6bd 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -5,7 +5,10 @@ mod common; use common::{read, read_with}; use craft_xlsx::testing::zip; -use craft_xlsx::{CellError, CellRef, Error, FormulaKind, Limits, Range, SheetKind, Value, Visibility, is_xlsb}; +use craft_xlsx::{ + CellError, CellRef, Color, ColorSource, Error, Fill, FormulaKind, Limits, Package, Pattern, PatternFill, Protection, Range, SheetKind, Styles, + Value, Visibility, is_xlsb, +}; const ROOT: &str = r#""#; const RELS: &str = r#""#; @@ -930,3 +933,264 @@ fn a_dynamic_array_kept_as_its_value_has_no_cell_metadata() { assert_eq!(sheet.cell_metadata.iter().collect::>(), [(&at("C1"), &1)]); assert!(warned(&wb, "missing from the file"), "{:?}", wb.warnings); } + +// Styles ([MS-XLSB] 2.1.7.50): a styles part assembled from records, and the `styles.xml` Excel +// writes for the same formats when it saves the workbook as `.xlsx`. + +const STYLES_RELS: &str = r#""#; +const STYLES_TYPES: &str = r#""#; + +fn styled_file(styles: &[u8], types: &str) -> Vec { + let sheet = worksheet(&[row(0), cell(5, 0, &1.0f64.to_le_bytes())].concat(), &[]); + zip(&[ + ("[Content_Types].xml", types.as_bytes()), + ("_rels/.rels", ROOT.as_bytes()), + ("records/book.bin", &book(false)), + ("records/_rels/book.bin.rels", STYLES_RELS.as_bytes()), + ("data/one.bin", &sheet), + ("data/two.bin", &worksheet(&[], &[])), + ("look/styles.bin", styles), + ]) +} + +/// The styles part of a package, and the warnings reading it gave. +fn styles_of(bytes: &[u8]) -> (Option, Vec) { + let mut p = Package::open(bytes, &Limits::default()).unwrap(); + let styles = p.styles().unwrap(); + (styles, p.warnings().to_vec()) +} + +/// `BrtColor`: auto 0, indexed 1, RGB 2, theme 3. +fn color(kind: u8, index: u8, tint: i16, rgba: [u8; 4]) -> Vec { + [&[kind << 1 | 1, index][..], &tint.to_le_bytes(), &rgba].concat() +} +fn indexed(i: u8) -> Vec { + color(1, i, 0, [0, 0, 0, 255]) +} +fn theme(i: u8, tint: i16) -> Vec { + color(3, i, tint, [0, 0, 0, 255]) +} +fn rgb(r: u8, g: u8, b: u8) -> Vec { + color(2, 255, 0, [r, g, b, 255]) +} +#[allow(clippy::too_many_arguments)] +fn font(twips: u16, flags: u16, weight: u16, script: u16, underline: u8, family: u8, charset: u8, c: &[u8], scheme: u8, name: &str) -> Vec { + let head = + [&twips.to_le_bytes()[..], &flags.to_le_bytes(), &weight.to_le_bytes(), &script.to_le_bytes(), &[underline, family, charset, 0]].concat(); + record(43, &[&head[..], c, &[scheme], &wide(name)].concat()) +} +fn pattern_fill(fls: u32, fg: &[u8], bg: &[u8]) -> Vec { + record(45, &[&fls.to_le_bytes()[..], fg, bg, &[0; 48]].concat()) +} +fn edge(dg: u8, c: &[u8]) -> Vec { + [&[dg, 0][..], c].concat() +} +#[allow(clippy::too_many_arguments)] +fn brt_xf(parent: u16, fmt: u16, font: u16, fill: u16, border: u16, rotation: u8, indent: u8, flags: u16, apply: u8) -> Vec { + let ids = [parent, fmt, font, fill, border].map(u16::to_le_bytes).concat(); + record(47, &[&ids[..], &[rotation, indent], &flags.to_le_bytes(), &[apply, 0]].concat()) +} +fn style(xf: u32, flags: u16, builtin: u8, level: u8, name: &str) -> Vec { + record(48, &[&xf.to_le_bytes()[..], &flags.to_le_bytes(), &[builtin, level], &wide(name)].concat()) +} +fn prop(kind: u16, data: &[u8]) -> Vec { + [&kind.to_le_bytes()[..], &(data.len() as u16 + 4).to_le_bytes(), data].concat() +} +fn short(text: &str) -> Vec { + let units: Vec = text.encode_utf16().collect(); + [(units.len() as u16).to_le_bytes().to_vec(), units.iter().flat_map(|u| u.to_le_bytes()).collect()].concat() +} +fn brt_dxf(props: &[Vec]) -> Vec { + record(507, &[&[0, 0x80, 0, 0][..], &(props.len() as u16).to_le_bytes(), &props.concat()].concat()) +} +fn begin(id: u16, count: u32) -> Vec { + record(id, &count.to_le_bytes()) +} + +/// Every kind of record the styles part has, as Excel writes them. +fn styles_bin() -> Vec { + let normal = font(220, 0, 400, 0, 0, 2, 0, &theme(1, 0), 2, "Aptos Narrow"); + // Bold, italic, struck out, superscript, double accounting underline; family and + // character set 0 and scheme "none" are not written in `.xlsx`. + let fancy = font(290, 0x0A, 700, 1, 0x22, 0, 2, &rgb(0, 128, 255), 0, "Wingdings"); + let heading = font(220, 0, 400, 0, 0, 2, 0, &theme(4, 13106), 1, "Aptos Display"); + let gradient = [ + &0x28u32.to_le_bytes()[..], + &indexed(64), + &indexed(65), + &1u32.to_le_bytes(), + &[0.0f64, 0.5, 0.5, 0.5, 0.5].map(f64::to_le_bytes).concat(), + &2u32.to_le_bytes(), + &theme(0, 0), + &0.0f64.to_le_bytes(), + &theme(4, 0), + &1.0f64.to_le_bytes(), + ] + .concat(); + let none = edge(0, &color(0, 0, 0, [0, 0, 0, 0])); + let parts: Vec> = vec![ + record(278, &[]), + begin(615, 1), + record(44, &[&164u16.to_le_bytes()[..], &wide(r"yyyy\-mm\-dd")].concat()), + record(616, &[]), + begin(611, 3), + normal, + fancy, + heading, + record(612, &[]), + begin(603, 5), + pattern_fill(0, &indexed(64), &indexed(65)), + pattern_fill(17, &indexed(64), &indexed(65)), + pattern_fill(1, &rgb(255, 255, 0), &indexed(64)), + pattern_fill(9, &theme(5, -8191), &indexed(65)), + record(45, &gradient), + record(604, &[]), + begin(613, 2), + record(46, &[&[0][..], &none, &none, &none, &none, &none].concat()), + record( + 46, + &[&[3][..], &edge(2, &rgb(200, 0, 0)), &none, &edge(7, &indexed(64)), &edge(13, &color(0, 0, 0, [0, 0, 0, 0])), &edge(1, &theme(4, 0))] + .concat(), + ), + record(614, &[]), + begin(626, 3), + brt_xf(0xFFFF, 0, 0, 0, 0, 0, 0, 0x1010, 0), + brt_xf(0xFFFF, 9, 0, 0, 0, 0, 0, 0x1010, 0x3E), + brt_xf(0xFFFF, 0, 2, 0, 0, 0, 0, 0x1010, 0), + record(627, &[]), + begin(617, 4), + brt_xf(0, 0, 0, 0, 0, 0, 0, 0x1010, 0), + brt_xf(0, 164, 0, 0, 0, 0, 0, 0x1010, 0x01), + // Left, top, wrapped, shrunk, right to left, unlocked, hidden, quote prefix. + brt_xf(0, 0, 0, 0, 0, 180, 2, 0x01 | 0x40 | 0x100 | 0x800 | 0x2000 | 0x8000, 0x24), + brt_xf(1, 0, 1, 4, 1, 0, 0, 0x1010, 0x1A), + record(618, &[]), + begin(619, 3), + style(0, 1, 0, 0, "Normal"), + // Excel wraps each style in alternate content, which is skipped. + record(37, &[1, 0, 2, 0x0e, 0, 0x80]), + record(3072, &[0; 16]), + record(38, &[]), + style(1, 1 | 4, 1, 1, "RowLevel_2"), + style(2, 2, 0, 0, "Probe Style"), + record(620, &[]), + begin(505, 2), + brt_dxf(&[ + prop(0x05, &rgb(0x9C, 0, 6)), + prop(0x19, &700u16.to_le_bytes()), + prop(0x1C, &[0]), + prop(0x1A, &0x21u16.to_le_bytes()), + prop(0x24, &240u32.to_le_bytes()), + prop(0x18, &short("Arial")), + prop(0x29, &170u16.to_le_bytes()), + prop(0x26, &short("0.0")), + prop(0x02, &rgb(0xFF, 0xC7, 0xCE)), + prop(0x0F, &[2]), + prop(0x14, &[1]), + prop(0x2B, &[0]), + prop(0x07, &[&color(0, 0, 0, [0, 0, 0, 0])[..], &1u16.to_le_bytes()].concat()), + ]), + brt_dxf(&[ + prop(0x03, &[&0u32.to_le_bytes()[..], &[90.0f64, 0.0, 0.0, 0.0, 0.0].map(f64::to_le_bytes).concat()].concat()), + prop(0x04, &[&[0, 0][..], &0.0f64.to_le_bytes(), &rgb(255, 255, 255)].concat()), + prop(0x04, &[&[0, 0][..], &1.0f64.to_le_bytes(), &theme(4, 0)].concat()), + ]), + record(506, &[]), + record(508, &[&0u32.to_le_bytes()[..], &wide("TableStyleMedium2"), &wide("PivotStyleLight16")].concat()), + record(509, &[]), + record(473, &[]), + record(565, &[]), + record(475, &[0x11, 0x22, 0x33, 0]), + record(475, &[0xFF, 0xFF, 0xFF, 0]), + record(566, &[]), + record(474, &[]), + record(279, &[]), + ]; + parts.concat() +} + +const STYLES_XML: &str = r#""#; + +/// The same styles from a SpreadsheetML package. +fn xml_styles(xml: &str) -> Styles { + let types = r#""#; + let root = r#""#; + let rels = r#""#; + let bytes = zip(&[ + ("[Content_Types].xml", types.as_bytes()), + ("_rels/.rels", root.as_bytes()), + ("xl/workbook.xml", br#""#), + ("xl/_rels/workbook.xml.rels", rels.as_bytes()), + ("xl/styles.xml", xml.as_bytes()), + ]); + styles_of(&bytes).0.unwrap() +} + +/// What both readers lift out: an ``'s element keeps only its `apply*` flags, and the XML +/// part's own element is dropped. +fn lifted(mut s: Styles) -> Styles { + for xf in s.cell_style_xfs.iter_mut().chain(&mut s.cell_xfs) { + let attrs = xf.el.attrs.iter().filter(|(k, _)| k.starts_with("apply")).cloned().collect(); + xf.el = craft_xml::El::new("xf"); + xf.el.attrs = attrs; + } + s.root = craft_xml::El::default(); + s +} + +#[test] +fn styles_are_read_as_their_xlsx_spelling() { + let (binary, warnings) = styles_of(&styled_file(&styles_bin(), STYLES_TYPES)); + let binary = binary.expect("styles are read"); + assert_eq!(lifted(binary.clone()), lifted(xml_styles(STYLES_XML))); + // A few of the conversions, spelled out. + assert_eq!(binary.fonts[1].size, Some(14.5)); + assert_eq!(binary.fonts[1].family, None); + let solid = Fill::Pattern(PatternFill { + pattern: Some(Pattern::Solid), + fg: Some(Color { source: ColorSource::Rgb(0xFFFF_FF00), tint: 0.0 }), + bg: Some(Color { source: ColorSource::Indexed(64), tint: 0.0 }), + }); + assert_eq!(binary.fills[2], solid); + assert_eq!(binary.cell_xfs[2].protection, Some(Protection { locked: Some(false), hidden: Some(true) })); + assert_eq!(binary.palette()[0], 0x11_2233); + // Written back as SpreadsheetML, a cell style format says what it leaves out, as Excel's does. + let written = String::from_utf8(binary.to_xml()).unwrap(); + assert!(written.contains(r#"applyFont="0" applyFill="0" applyBorder="0" applyAlignment="0" applyProtection="0""#), "{written}"); + assert!(warnings.iter().any(|w| w.contains("alternate-content")), "{warnings:?}"); + assert!(!warnings.iter().any(|w| w.contains("table styles")), "{warnings:?}"); +} + +#[test] +fn damaged_styles_are_a_warning_and_the_workbook_opens() { + let good = styles_bin(); + let end = record(279, &[]); + let body = &good[..good.len() - end.len()]; + let with = |extra: &[u8]| [body, extra, &end].concat(); + let cases: Vec<(&str, Vec, &str)> = vec![ + ("truncated", good[..good.len() - 1].to_vec(), STYLES_TYPES), + ("no end record", body.to_vec(), STYLES_TYPES), + ("unknown fill pattern", with(&pattern_fill(99, &indexed(64), &indexed(65))), STYLES_TYPES), + ("unknown border style", with(&record(46, &[&[0][..], &edge(14, &indexed(64)), &[0; 40]].concat())), STYLES_TYPES), + ("cell format outside its list", with(&brt_xf(0, 0, 0, 0, 0, 0, 0, 0x1010, 0)), STYLES_TYPES), + ("short property", with(&brt_dxf(&[vec![0x19, 0, 2, 0]])), STYLES_TYPES), + ("wrong content type", good.clone(), TYPES), + ]; + for (why, part, types) in cases { + let bytes = styled_file(&part, types); + let (styles, warnings) = styles_of(&bytes); + assert!(styles.is_none(), "{why}"); + assert!(warnings.iter().any(|w| w.contains("look/styles.bin")), "{why}: {warnings:?}"); + assert_eq!(read(&bytes).unwrap().sheets[0].value(CellRef::new(0, 0)), Value::Number(1.0), "{why}"); + } + // A table past 65,536 entries is refused before it is held. + let xfs = brt_xf(0, 0, 0, 0, 0, 0, 0, 0x1010, 0).repeat(65_537); + let (styles, warnings) = styles_of(&styled_file(&with(&[&begin(617, 65_537)[..], &xfs, &record(618, &[])].concat()), STYLES_TYPES)); + assert!(styles.is_none()); + assert!(warnings.iter().any(|w| w.contains("65536 entries")), "{warnings:?}"); + // Custom table styles are not read, and say so. + let table_styles = [body, &record(508, &[&1u32.to_le_bytes()[..], &wide("Probe Table"), &wide("")].concat()), &end].concat(); + let (styles, warnings) = styles_of(&styled_file(&table_styles, STYLES_TYPES)); + assert!(styles.is_some()); + assert!(warnings.iter().any(|w| w.contains("table styles")), "{warnings:?}"); +} From 25f1ac5801dcf687990bdaf1ca2aee0d91934cf5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Legrand?= Date: Sat, 14 Nov 2026 10:39:34 +0100 Subject: [PATCH 028/382] test(prc): validate compressed mesh reconstruction --- crates/prc/README.md | 4 +- crates/prc/src/tess/compressed.rs | 2 + crates/prc/src/tess/compressed/independent.rs | 451 ++++++++++++++++++ 3 files changed, 455 insertions(+), 2 deletions(-) create mode 100644 crates/prc/src/tess/compressed/independent.rs diff --git a/crates/prc/README.md b/crates/prc/README.md index 4d40f0962..c76d0af5b 100644 --- a/crates/prc/README.md +++ b/crates/prc/README.md @@ -30,7 +30,7 @@ BitReader: bit, bits, character, unsigned_integer, integer, integer_vbn, double_ - `Tessellation::Mesh` is a `TriangleMesh`: positions, triangles, one triangle range per face, the stored normals and texture coordinates with each triangle's corner indices into them, and per-triangle line-attribute styles. `Wire` is polylines; `Markup` is read past. -- `Tessellation::Compressed` is read to its end so later entities decode; its triangles are not rebuilt yet. +- `Tessellation::Compressed` is read to its end so later entities decode. Recalculated-normal meshes in the accepted 3T form are rebuilt when their arrays fit; stored-normal meshes and unsupported traversals stay `Compressed`. - A face may carry at most 8 texture-coordinate sets; more is `Malformed`. Optimised vertex colours are `Unsupported`. - The product tree: each drawable tessellation placed by its occurrence path's locations and the item's coordinate systems (a 4x4 `Matrix`), coloured by the style inheritance rules, with occurrences' entity references applied @@ -39,6 +39,6 @@ BitReader: bit, bits, character, unsigned_integer, integer, integer_vbn, double_ came from, its visibility and the range of placements it drew. - Occurrence and prototype cycles are `Malformed`; the walk is capped at depth 64, 2^20 visits and `MAX_PLACEMENTS`. - A tree's markups (PMI), views, scene lights and clipping planes are read past, not modelled; so are textures. -- Not yet in the crate: rebuilding compressed meshes, textures. +- Not yet in the crate: stored-normal or one-status compressed mesh reconstruction, textures. - The `Double` code table's rows come from [prc-rs](https://github.com/ralovich/prc-rs) (MIT); its notice is in `src/acof/table.rs`. A few reading choices also follow prc-rs; each is marked `// prc-rs:` in the source. diff --git a/crates/prc/src/tess/compressed.rs b/crates/prc/src/tess/compressed.rs index 53e082b4d..f6fa70317 100644 --- a/crates/prc/src/tess/compressed.rs +++ b/crates/prc/src/tess/compressed.rs @@ -349,5 +349,7 @@ impl Walk { } } +#[cfg(test)] +mod independent; #[cfg(test)] mod tests; diff --git a/crates/prc/src/tess/compressed/independent.rs b/crates/prc/src/tess/compressed/independent.rs new file mode 100644 index 000000000..209337f78 --- /dev/null +++ b/crates/prc/src/tess/compressed/independent.rs @@ -0,0 +1,451 @@ +#![allow( + clippy::cast_possible_truncation, + clippy::cast_precision_loss, + clippy::expect_used, + clippy::float_cmp, + clippy::many_single_char_names, + clippy::panic, + clippy::unwrap_used +)] + +use super::*; + +const S: f64 = std::f64::consts::SQRT_2; + +#[derive(Clone, Copy)] +enum Slot { + Point(V), + #[allow(dead_code)] + Reference(u32), +} + +#[derive(Clone, Copy)] +enum Recipe { + Seed { slots: [Slot; 3], status: i32, face: u32 }, + Apex { edge: (u32, u32), opposite: u32, slot: Slot, status: i32, face: u32 }, +} + +impl Recipe { + fn status(self) -> i32 { + match self { + Self::Seed { status, .. } | Self::Apex { status, .. } => status, + } + } + + fn face(self) -> u32 { + match self { + Self::Seed { face, .. } | Self::Apex { face, .. } => face, + } + } +} + +#[derive(Clone)] +struct Encoded { + tolerance: f64, + origin: V, + points: Vec, + edge_status: Vec, + face_of: Vec, + is_reference: Vec, + references: Vec, + positions: Vec, + triangles: Vec<[u32; 3]>, +} + +impl Encoded { + fn arrays(&self, limit: usize) -> Arrays<'_> { + Arrays { + tolerance: self.tolerance, + origin: self.origin, + points: &self.points, + edge_status: &self.edge_status, + triangles: self.triangles.len(), + is_reference: &self.is_reference, + references: &self.references, + limit, + } + } + + #[allow(dead_code)] + fn faces(&self) -> usize { + self.face_of.iter().max().map_or(0, |&face| face as usize + 1) + } + + fn push_reference(&mut self, vertex: u32) -> u32 { + let index = usize::try_from(vertex).unwrap(); + assert!(index < self.positions.len(), "a recipe reference must name an earlier vertex"); + self.is_reference.push(true); + self.references.push(vertex); + vertex + } + + fn push_position(&mut self, position: V, point: [i64; 3]) -> u32 { + self.points.extend(point); + self.is_reference.push(false); + self.positions.push(position); + u32::try_from(self.positions.len() - 1).unwrap() + } + + fn push_seed_point(&mut self, index: usize, target: V, triangle: [u32; 3]) -> u32 { + let base = match index { + 0 => self.origin, + 1 => self.positions[usize::try_from(triangle[0]).unwrap()], + 2 => { + let first = self.positions[usize::try_from(triangle[0]).unwrap()]; + let second = self.positions[usize::try_from(triangle[1]).unwrap()]; + p_scale(p_add(first, second), 0.5) + } + _ => panic!("a seed has exactly three slots"), + }; + let point = quantize(p_sub(target, base), self.tolerance); + let position = p_add(base, scaled(point, self.tolerance)); + self.push_position(position, point) + } + + fn push_apex_point(&mut self, edge: (u32, u32), opposite: u32, target: V) -> u32 { + let (p, q) = edge; + let (lo, hi) = if p < q { (p, q) } else { (q, p) }; + let lo = self.positions[usize::try_from(lo).unwrap()]; + let hi = self.positions[usize::try_from(hi).unwrap()]; + let opposite = self.positions[usize::try_from(opposite).unwrap()]; + let (origin, x, y, z) = encoder_frame(lo, hi, opposite); + let offset = p_sub(target, origin); + let point = [ + quantize_component(p_dot(offset, x), self.tolerance), + quantize_component(-p_dot(offset, y), self.tolerance), + quantize_component(-p_dot(offset, z), self.tolerance), + ]; + let delta = scaled(point, self.tolerance); + let position = p_sub(p_sub(p_add(origin, p_scale(x, delta[0])), p_scale(y, delta[1])), p_scale(z, delta[2])); + self.push_position(position, point) + } +} + +fn encode(origin: V, tolerance: f64, recipes: &[Recipe]) -> Encoded { + assert!(tolerance.is_finite() && tolerance > 0.0, "a positive finite tolerance"); + let mut edge_status: Vec = recipes.iter().map(|recipe| recipe.status()).collect(); + edge_status.resize(recipes.len().saturating_mul(3), 0); + let mut encoded = Encoded { + tolerance, + origin, + points: Vec::new(), + edge_status, + face_of: Vec::new(), + is_reference: Vec::new(), + references: Vec::new(), + positions: Vec::new(), + triangles: Vec::new(), + }; + + for &recipe in recipes { + encoded.face_of.push(recipe.face()); + match recipe { + Recipe::Seed { slots, .. } => { + let mut triangle = [0; 3]; + for (index, slot) in slots.into_iter().enumerate() { + triangle[index] = match slot { + Slot::Point(target) => encoded.push_seed_point(index, target, triangle), + Slot::Reference(vertex) => encoded.push_reference(vertex), + }; + } + encoded.triangles.push(triangle); + } + Recipe::Apex { edge: (p, q), opposite, slot, .. } => { + let vertex = match slot { + Slot::Point(target) => encoded.push_apex_point((p, q), opposite, target), + Slot::Reference(vertex) => encoded.push_reference(vertex), + }; + encoded.triangles.push([p, q, vertex]); + } + } + } + encoded +} + +fn p_add(a: V, b: V) -> V { + [a[0] + b[0], a[1] + b[1], a[2] + b[2]] +} + +fn p_sub(a: V, b: V) -> V { + [a[0] - b[0], a[1] - b[1], a[2] - b[2]] +} + +fn p_scale(a: V, factor: f64) -> V { + a.map(|component| component * factor) +} + +fn p_dot(a: V, b: V) -> f64 { + a[0] * b[0] + a[1] * b[1] + a[2] * b[2] +} + +fn p_cross(a: V, b: V) -> V { + [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]] +} + +fn quantize_component(value: f64, tolerance: f64) -> i64 { + let quantized = (value / tolerance).round(); + assert!(quantized.is_finite() && quantized >= i64::MIN as f64 && quantized <= i64::MAX as f64); + quantized as i64 +} + +fn quantize(value: V, tolerance: f64) -> [i64; 3] { + value.map(|component| quantize_component(component, tolerance)) +} + +fn scaled(point: [i64; 3], tolerance: f64) -> V { + point.map(|component| component as f64 * tolerance) +} + +fn encoder_length(value: V) -> Option { + let squared = (value[0] * value[0] + value[1] * value[1] + value[2] * value[2]) as f32; + let bits = squared.to_bits(); + let exponent = (bits >> 23) & 0xff; + let seed = if exponent > 127 { f32::from_bits((bits & !(0xff << 23)) | (((exponent - 127) / 2 + 127) << 23)) } else { squared }; + let squared = f64::from(squared); + let mut current = f64::from(seed); + for _ in 0..100 { + let next = 0.5 * (current + squared / current); + if next == current { + return Some(next); + } + current = next; + } + None +} + +fn encoder_unit(value: V) -> Option { + let length = encoder_length(value).filter(|&length| length >= f64::from(f32::EPSILON))?; + Some([value[0] / length, value[1] / length, value[2] / length]) +} + +fn encoder_ortho_z(x: V) -> Option { + let x = encoder_unit(x)?; + encoder_unit(p_cross(x, [0.0, 1.0, 0.0])).or_else(|| encoder_unit(p_cross(x, [1.0, 0.0, 0.0]))) +} + +fn encoder_frame(lo: V, hi: V, opposite: V) -> (V, V, V, V) { + let origin = p_scale(p_add(lo, hi), 0.5); + let difference = p_sub(lo, hi); + let x = encoder_unit(difference).unwrap_or(difference); + let residue = p_cross(p_sub(opposite, origin), x); + let (y, z) = encoder_unit(residue) + .and_then(|z| Some((encoder_unit(p_cross(z, x))?, z))) + .or_else(|| { + let z = encoder_ortho_z(x)?; + let y = encoder_unit(p_cross(z, x))?; + Some(if p_dot(residue, z) < 0.0 { (p_scale(y, -1.0), p_scale(z, -1.0)) } else { (y, z) }) + }) + .unwrap_or_default(); + (origin, x, y, z) +} + +fn assert_positions(actual: &[V], expected: &[V]) { + assert_eq!(actual.len(), expected.len(), "vertex counts differ"); + for (index, (actual, expected)) in actual.iter().zip(expected).enumerate() { + for component in 0..3 { + assert!( + (actual[component] - expected[component]).abs() < 1e-9, + "vertex {index}, component {component}: actual {actual:?}, expected {expected:?}", + ); + } + } +} + +#[allow(dead_code)] +fn assert_within_tolerance(actual: &[V], source: &[V], tolerance: f64) { + assert_eq!(actual.len(), source.len(), "vertex counts differ"); + let limit = tolerance * 3.0_f64.sqrt() / 2.0; + for (index, (actual, source)) in actual.iter().zip(source).enumerate() { + let difference = p_sub(*actual, *source); + let distance = p_dot(difference, difference).sqrt(); + assert!(distance <= limit + 1e-12, "vertex {index}: distance {distance} exceeds {limit}; actual {actual:?}, source {source:?}"); + } +} + +fn triangle_seed(x: f64, status: i32, face: u32) -> Recipe { + Recipe::Seed { slots: [Slot::Point([x, 0.0, 0.0]), Slot::Point([x + 2.0, 0.0, 0.0]), Slot::Point([x, 2.0, 0.0])], status, face } +} + +fn panel(target: V) -> Encoded { + encode( + [0.0; 3], + 0.5, + &[ + triangle_seed(0.0, 3, 0), + Recipe::Apex { edge: (2, 1), opposite: 0, slot: Slot::Point(target), status: 3, face: 0 }, + Recipe::Apex { edge: (2, 3), opposite: 1, slot: Slot::Reference(0), status: 2, face: 0 }, + Recipe::Apex { edge: (0, 3), opposite: 2, slot: Slot::Reference(1), status: 0, face: 0 }, + ], + ) +} + +#[test] +fn independent_seed_and_apex_match_a_hand_computed_stream() { + let encoded = encode( + [10.0, 0.0, 0.0], + 0.5, + &[ + Recipe::Seed { slots: [Slot::Point([10.0, 0.0, 0.0]), Slot::Point([12.0, 0.0, 0.0]), Slot::Point([10.0, 2.0, 0.0])], status: 2, face: 0 }, + Recipe::Apex { edge: (2, 1), opposite: 0, slot: Slot::Point([11.0 + 2.0 * S, 1.0 + S, -1.0]), status: 0, face: 0 }, + ], + ); + + assert_eq!(encoded.points, [0, 0, 0, 4, 0, 0, -2, 4, 0, 2, -6, 2]); + let rebuilt = rebuild(&encoded.arrays(usize::MAX)).unwrap(); + assert_eq!(rebuilt.triangles, [[0, 1, 2], [2, 1, 3]]); + let expected = [[10.0, 0.0, 0.0], [12.0, 0.0, 0.0], [10.0, 2.0, 0.0], [11.0 + 2.0 * S, 1.0 + S, -1.0]]; + assert_positions(&rebuilt.positions, &expected); +} + +#[test] +fn independent_components_and_a_reference_are_rebuilt() { + let encoded = encode( + [0.0; 3], + 0.5, + &[ + triangle_seed(0.0, 2, 0), + Recipe::Apex { edge: (2, 1), opposite: 0, slot: Slot::Reference(0), status: 0, face: 0 }, + triangle_seed(5.0, 0, 1), + ], + ); + + let rebuilt = rebuild(&encoded.arrays(usize::MAX)).unwrap(); + assert_eq!(rebuilt.triangles, [[0, 1, 2], [2, 1, 0], [3, 4, 5]]); + assert_eq!(encoded.references, [0]); + assert_eq!(encoded.face_of, [0, 0, 1]); + assert_eq!(rebuilt.positions.len(), 6); + let expected = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [5.0, 0.0, 0.0], [7.0, 0.0, 0.0], [5.0, 2.0, 0.0]]; + assert_positions(&rebuilt.positions, &expected); +} + +#[test] +fn independent_fold_and_component_retry_rebuild_the_same_panel() { + let folded = [1.0 - 1.0 / S, 1.0 - S, 0.0]; + let unfolded = [1.0 + S, 1.0 + 1.0 / S, 0.0]; + for target in [folded, unfolded] { + let source = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [0.0, 2.0, 0.0], target]; + let encoded = panel(target); + assert_within_tolerance(&encoded.positions, &source, 0.5); + let rebuilt = rebuild(&encoded.arrays(usize::MAX)).unwrap(); + assert_eq!(rebuilt.triangles, [[0, 1, 2], [2, 1, 3], [2, 3, 0], [0, 3, 1]]); + assert_eq!(rebuilt.positions.len(), 4); + assert_within_tolerance(&rebuilt.positions, &source, 0.5); + } +} + +#[test] +fn independent_closed_continuation_uses_the_open_edge() { + let encoded = encode( + [0.0; 3], + 0.5, + &[ + triangle_seed(0.0, 2, 0), + Recipe::Apex { edge: (2, 1), opposite: 0, slot: Slot::Point([0.0, 0.0, 2.0]), status: 2, face: 0 }, + Recipe::Apex { edge: (3, 1), opposite: 2, slot: Slot::Reference(0), status: 2, face: 0 }, + Recipe::Apex { edge: (3, 0), opposite: 1, slot: Slot::Reference(2), status: 0, face: 0 }, + ], + ); + + let source = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 2.0]]; + assert_within_tolerance(&encoded.positions, &source, 0.5); + let rebuilt = rebuild(&encoded.arrays(usize::MAX)).unwrap(); + assert_eq!(rebuilt.triangles, [[0, 1, 2], [2, 1, 3], [3, 1, 0], [3, 0, 2]]); + assert_within_tolerance(&rebuilt.positions, &source, 0.5); +} + +#[test] +fn independent_non_planar_strip_tracks_the_quantized_working_mesh() { + let source: Vec = (0..16).map(|index| [f64::from(index) * 0.05, f64::from(index % 2) * 2.0, (f64::from(index % 5) - 2.0) * 0.03]).collect(); + let mut recipes = vec![Recipe::Seed { slots: [Slot::Point(source[0]), Slot::Point(source[1]), Slot::Point(source[2])], status: 2, face: 0 }]; + let (mut p, mut q, mut opposite) = (2_u32, 1_u32, 0_u32); + + for index in 1..source.len() - 2 { + let vertex = u32::try_from(index + 2).unwrap(); + let status = if index % 2 == 1 { 1 } else { 2 }; + recipes.push(Recipe::Apex { edge: (p, q), opposite, slot: Slot::Point(source[index + 2]), status, face: 0 }); + if status == 1 { + (p, q, opposite) = (p, vertex, q); + } else { + (p, q, opposite) = (vertex, q, p); + } + } + + let encoded = encode([0.0; 3], 1e-4, &recipes); + assert_within_tolerance(&encoded.positions, &source, 1e-4); + let rebuilt = rebuild(&encoded.arrays(usize::MAX)).unwrap(); + assert_eq!( + rebuilt.triangles, + [ + [0, 1, 2], + [2, 1, 3], + [2, 3, 4], + [4, 3, 5], + [4, 5, 6], + [6, 5, 7], + [6, 7, 8], + [8, 7, 9], + [8, 9, 10], + [10, 9, 11], + [10, 11, 12], + [12, 11, 13], + [12, 13, 14], + [14, 13, 15], + ] + ); + assert_eq!(encoded.points.len(), source.len() * 3); + assert_within_tolerance(&rebuilt.positions, &source, 1e-4); +} + +#[test] +fn independent_near_degenerate_parent_uses_an_orthogonal_frame() { + let encoded = encode( + [0.0; 3], + 1e-8, + &[ + Recipe::Seed { + slots: [Slot::Point([1.0, 1.0 + 1e-8, 0.0]), Slot::Point([2.0, 0.0, 0.0]), Slot::Point([0.0, 2.0, 0.0])], + status: 2, + face: 0, + }, + Recipe::Apex { edge: (2, 1), opposite: 0, slot: Slot::Point([0.3, 0.7, 0.2]), status: 0, face: 0 }, + ], + ); + + let source = [[1.0, 1.0 + 1e-8, 0.0], [2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.3, 0.7, 0.2]]; + assert_within_tolerance(&encoded.positions, &source, 1e-8); + let rebuilt = rebuild(&encoded.arrays(usize::MAX)).unwrap(); + assert_eq!(rebuilt.triangles, [[0, 1, 2], [2, 1, 3]]); + assert_within_tolerance(&rebuilt.positions, &source, 1e-8); +} + +#[test] +fn independent_rebuild_requires_exact_arrays_and_enough_budget() { + let encoded = encode([0.0; 3], 0.5, &[triangle_seed(0.0, 0, 0)]); + assert!(rebuild(&encoded.arrays(usize::MAX)).is_ok()); + + let mut extra_point = encoded.clone(); + extra_point.points.push(0); + assert_eq!(rebuild(&extra_point.arrays(usize::MAX)).unwrap_err(), "the decoded triangles do not use up the stored arrays",); + + let mut extra_slot = encoded.clone(); + extra_slot.is_reference.push(false); + assert_eq!(rebuild(&extra_slot.arrays(usize::MAX)).unwrap_err(), "the decoded triangles do not use up the stored arrays",); + + let mut extra_reference = encoded.clone(); + extra_reference.references.push(0); + assert_eq!(rebuild(&extra_reference.arrays(usize::MAX)).unwrap_err(), "the decoded triangles do not use up the stored arrays",); + + assert_eq!(rebuild(&encoded.arrays(0)).unwrap_err(), "the rebuild needs more than the decoded-element allowance left",); +} + +#[test] +fn independent_faces_group_walk_order_triangles() { + let encoded = encode([0.0; 3], 0.5, &[triangle_seed(0.0, 0, 1), triangle_seed(5.0, 0, 0)]); + let rebuilt = rebuild(&encoded.arrays(usize::MAX)).unwrap(); + let mesh = super::super::by_face(rebuilt, &encoded.face_of, encoded.faces(), &[]); + + assert_eq!(mesh.faces, [0..1, 1..2]); + assert_eq!(mesh.triangles, [[3, 4, 5], [0, 1, 2]]); + let expected = [[0.0, 0.0, 0.0], [2.0, 0.0, 0.0], [0.0, 2.0, 0.0], [5.0, 0.0, 0.0], [7.0, 0.0, 0.0], [5.0, 2.0, 0.0]]; + assert_positions(&mesh.positions, &expected); +} From a528fa7430314b3a0905a5cdc86be39631bf86f8 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 11:23:04 +0100 Subject: [PATCH 029/382] rtf: keep right-to-left paragraph direction Read \rtlpar/\rtldir and \ltrpar/\ltrdir into the paragraph's bidi flag and write \rtlpar for right-to-left paragraphs. The flow paragraph carries the direction between the document and the RTF reader/writer. Co-Authored-By: Claude Sonnet 5.5 --- crates/flow/src/from_doc.rs | 3 +++ crates/flow/src/to_doc.rs | 3 +++ crates/flow/src/types.rs | 2 ++ crates/rtf/src/doc/export.rs | 4 ++++ crates/rtf/src/doc/state.rs | 3 +++ crates/rtf/src/doc/styles.rs | 1 + crates/rtf/src/doc/tests.rs | 30 ++++++++++++++++++++++++++++++ crates/rtf/src/doc/word.rs | 4 ++++ 8 files changed, 50 insertions(+) diff --git a/crates/flow/src/from_doc.rs b/crates/flow/src/from_doc.rs index 341ded449..ea7f6fc92 100644 --- a/crates/flow/src/from_doc.rs +++ b/crates/flow/src/from_doc.rs @@ -493,6 +493,8 @@ fn flow_paras_in(doc: &Document, p: &Paragraph, opts: FlowOpts) -> Vec { kind, list, align: p.props.align, + // Direction can come from the paragraph's style (`w:bidi` in the style's pPr). + rtl: doc.styles.resolve_para(&p.props).bidi, page_break: p.props.page_break_before.unwrap_or(false), keep_next: p.props.keep_next.unwrap_or(false), inlines: Vec::new(), @@ -536,6 +538,7 @@ fn flow_paras_in(doc: &Document, p: &Paragraph, opts: FlowOpts) -> Vec { kind, list: None, align: p.props.align, + rtl: out.rtl, page_break: true, keep_next: p.props.keep_next.unwrap_or(false), inlines: Vec::new(), diff --git a/crates/flow/src/to_doc.rs b/crates/flow/src/to_doc.rs index c10be85c2..ce29a4448 100644 --- a/crates/flow/src/to_doc.rs +++ b/crates/flow/src/to_doc.rs @@ -159,6 +159,9 @@ fn para_props(p: &Para, list_num: Option) -> ParaProps { out.numbering = Some(NumRef { num, level: li.level.min(8) }); } out.align = p.align; + if p.rtl { + out.bidi = Some(true); + } let sp = p.spacing; out.space_before = sp.before; out.space_after = sp.after; diff --git a/crates/flow/src/types.rs b/crates/flow/src/types.rs index e897778f9..f1c281c62 100644 --- a/crates/flow/src/types.rs +++ b/crates/flow/src/types.rs @@ -676,6 +676,8 @@ pub struct Para { pub kind: Kind, pub list: Option, pub align: Option, + /// The paragraph reads right to left (OOXML `w:bidi`, RTF `\rtlpar`). + pub rtl: bool, pub page_break: bool, /// Keep the paragraph on the same page as the next one (ODT `fo:keep-with-next`). pub keep_next: bool, diff --git a/crates/rtf/src/doc/export.rs b/crates/rtf/src/doc/export.rs index 69fab3d76..8f0f1734b 100644 --- a/crates/rtf/src/doc/export.rs +++ b/crates/rtf/src/doc/export.rs @@ -664,6 +664,10 @@ impl Writer { Some(Align::Distribute) => out.push_str("\\qd"), _ => out.push_str("\\ql"), } + // The paragraph's text direction, as Word writes it (`\rtlpar`; `\ltrpar` is the default). + if p.rtl { + out.push_str("\\rtlpar"); + } if p.page_break { out.push_str("\\pagebb"); } diff --git a/crates/rtf/src/doc/state.rs b/crates/rtf/src/doc/state.rs index 486b94a32..1f5d8d2e6 100644 --- a/crates/rtf/src/doc/state.rs +++ b/crates/rtf/src/doc/state.rs @@ -148,6 +148,8 @@ pub(super) struct St { pub(super) hidden: bool, // Paragraph properties. pub(super) align: Option, + /// `\rtlpar`: the paragraph reads right to left. + pub(super) rtldir: bool, pub(super) style: i32, pub(super) intbl: bool, pub(super) ls: Option, @@ -185,6 +187,7 @@ impl Default for St { uc: 1, hidden: false, align: None, + rtldir: false, style: 0, intbl: false, ls: None, diff --git a/crates/rtf/src/doc/styles.rs b/crates/rtf/src/doc/styles.rs index 014a105b4..dd42f3b87 100644 --- a/crates/rtf/src/doc/styles.rs +++ b/crates/rtf/src/doc/styles.rs @@ -87,6 +87,7 @@ impl Reader { pub(super) fn para_props(&self, st: &St) -> Para { let mut p = Para::new(self.para_kind(st)); p.align = st.align; + p.rtl = st.rtldir; p.page_break = st.pagebb; p.spacing = spacing(st); p.borders = st.borders.any_visible().then_some(st.borders); diff --git a/crates/rtf/src/doc/tests.rs b/crates/rtf/src/doc/tests.rs index 7c1075a86..9274104ab 100644 --- a/crates/rtf/src/doc/tests.rs +++ b/crates/rtf/src/doc/tests.rs @@ -38,6 +38,36 @@ fn basic_reader() { assert!(matches!(&l.inlines[0], Inline::Text(_, f) if f.link.as_deref() == Some("http://a.b"))); } +#[test] +fn rtl_paragraphs_read_and_write_their_direction() { + // Word writes an RTL paragraph as `\rtlpar` (`\ltrpar` for LTR); reading it keeps the + // direction as w:bidi on the document paragraph, and export writes it back. + let rtf = br#"{\rtf1\ansi\pard\rtlpar RTL\par\pard\ltrpar LTR\par\pard plain\par}"#; + let flow = parse(rtf).unwrap(); + let paras: Vec<&Para> = flow.blocks.iter().filter_map(|b| if let FBlock::Para(p) = b { Some(p) } else { None }).collect(); + assert!(paras[0].rtl, "rtlpar sets the direction"); + assert!(!paras[1].rtl && !paras[2].rtl, "ltrpar and no word: not RTL"); + // \rtldir and \ltrdir, which some writers used for paragraphs, are read too. + let old = parse(br#"{\rtf1\ansi\pard\rtldir RTL\par\pard\ltrdir LTR\par}"#).unwrap(); + let old: Vec<&Para> = old.blocks.iter().filter_map(|b| if let FBlock::Para(p) = b { Some(p) } else { None }).collect(); + assert!(old[0].rtl && !old[1].rtl, "rtldir and ltrdir are read"); + // \pard resets the direction. + let reset = parse(br#"{\rtf1\ansi\pard\rtlpar A\par\pard B\par}"#).unwrap(); + let reset: Vec<&Para> = reset.blocks.iter().filter_map(|b| if let FBlock::Para(p) = b { Some(p) } else { None }).collect(); + assert!(reset[0].rtl && !reset[1].rtl, "pard resets the direction"); + // Import keeps it as bidi on the document paragraph. + let bidi = |d: &Document| { + d.body.iter().filter_map(|b| if let Block::Para(p) = &**b { Some(p.props.bidi.unwrap_or(false)) } else { None }).collect::>() + }; + let doc = import(rtf).unwrap(); + assert_eq!(bidi(&doc), [true, false, false]); + // Export writes \rtlpar once, and not the \rtldir. + let out = export(&doc); + assert_eq!(out.matches("\\rtlpar").count(), 1, "{out}"); + assert!(!out.contains("rtldir"), "{out}"); + assert_eq!(bidi(&import(out.as_bytes()).unwrap()), [true, false, false]); +} + #[test] fn stylesheet_names_take_unicode_escapes() { // \u116?=t \u105?=i \u116?=t \u108?=l \u101?=e — how Word writes a non-Latin style name. diff --git a/crates/rtf/src/doc/word.rs b/crates/rtf/src/doc/word.rs index 28360c616..bf163db0c 100644 --- a/crates/rtf/src/doc/word.rs +++ b/crates/rtf/src/doc/word.rs @@ -171,6 +171,10 @@ impl Reader { "qr" => self.st.align = Some(Align::Right), "qj" => self.st.align = Some(Align::Justify), "qd" => self.st.align = Some(Align::Distribute), + // `\rtldir`/`\ltrdir` are not paragraph words (they set a table's or section's + // direction in RTF); some writers used them for paragraphs, so they are read too. + "rtlpar" | "rtldir" => self.st.rtldir = true, + "ltrpar" | "ltrdir" => self.st.rtldir = false, "s" => self.st.style = pv, "outlinelevel" => self.st.outline = Some(pv.clamp(0, 9) as u8), "pagebb" => self.st.pagebb = on, From b6a2df0c1d76729c7bca72113000948c49841efe Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 11:27:03 +0100 Subject: [PATCH 030/382] docx: chart axis and series formatting Add the series formatting (fill, line, markers, smooth, labels, number format) and the category/value axis formatting (title, bounds, number format, gridlines, tick labels, axis line) to the chart model, and read and write them in the DOCX chart part. GraphicItem::Text gets an angle for the rotated vertical axis title. With none of the new fields set the chart part is written as before. Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/chart_spec.rs | 399 +++++++++++++++++++---- crates/docx/src/read/chart.rs | 4 +- crates/docx/src/read/chart/canvas.rs | 7 +- crates/docx/src/read/chart/model.rs | 29 +- crates/docx/src/read/chart/parse.rs | 18 +- crates/docx/src/read/chart/plot.rs | 162 +++++++-- crates/docx/src/read/chart/polar.rs | 6 +- crates/docx/src/read/diagram.rs | 11 +- crates/docx/src/write/embed.rs | 3 +- crates/flow/src/from_doc.rs | 2 +- crates/odf/src/text/chart.rs | 7 +- crates/odf/src/text/tests_more/charts.rs | 18 +- crates/odf/src/text/tests_more/groups.rs | 1 + crates/wordmodel/src/chart.rs | 172 +++++++++- crates/wordmodel/src/graphic.rs | 6 +- 15 files changed, 726 insertions(+), 119 deletions(-) diff --git a/crates/docx/src/chart_spec.rs b/crates/docx/src/chart_spec.rs index e31363903..1950b15bf 100644 --- a/crates/docx/src/chart_spec.rs +++ b/crates/docx/src/chart_spec.rs @@ -6,7 +6,7 @@ //! [`spec_of`] turns a chart part back into the model only when writing that model again gives //! the same markup, so a chart with anything the model leaves out stays as it was read. -use craft_wordmodel::chart::{ChartSeries, ChartSpec, ChartType, LegendPos, MAX_POINTS, MAX_SERIES}; +use craft_wordmodel::chart::{ChartAxis, ChartSeries, ChartSpec, ChartType, LegendPos, MAX_POINTS, MAX_SERIES}; use craft_wordmodel::graphic::GraphicItem; use craft_wordmodel::props::Rgb; @@ -102,11 +102,24 @@ fn bounded(spec: &ChartSpec) -> ChartSpec { .series .iter() .take(MAX_SERIES) - .map(|s| ChartSeries { name: s.name.clone(), values: s.values.iter().take(MAX_POINTS).copied().collect() }) + .map(|s| ChartSeries { + name: s.name.clone(), + values: s.values.iter().take(MAX_POINTS).copied().collect(), + fill: s.fill, + no_fill: s.no_fill, + line_w: s.line_w, + no_line: s.no_line, + markers: s.markers, + smooth: s.smooth, + labels: s.labels, + fmt: s.fmt.clone(), + }) .collect(), title: spec.title.clone(), legend: spec.legend, data_labels: spec.data_labels, + cat_axis: spec.cat_axis.clone(), + val_axis: spec.val_axis.clone(), } .sanitized() } @@ -185,17 +198,19 @@ fn plot(w: &mut W, spec: &ChartSpec) { match k { ChartType::Pie | ChartType::Doughnut => {} ChartType::Scatter => { - value_axis(w, CAT_AX, VAL_AX, "b", false, "midCat"); - value_axis(w, VAL_AX, CAT_AX, "l", true, "midCat"); + value_axis(w, CAT_AX, VAL_AX, "b", "midCat", &spec.cat_axis); + value_axis(w, VAL_AX, CAT_AX, "l", "midCat", &spec.val_axis); } _ => { - category_axis(w, if horizontal { "l" } else { "b" }); - value_axis(w, VAL_AX, CAT_AX, if horizontal { "b" } else { "l" }, true, "between"); + category_axis(w, if horizontal { "l" } else { "b" }, &spec.cat_axis); + value_axis(w, VAL_AX, CAT_AX, if horizontal { "b" } else { "l" }, "between", &spec.val_axis); } } } -/// One `c:ser` (ECMA-376 element order: idx, order, tx, spPr, marker, cat/xVal, val/yVal, smooth). +/// One `c:ser` (ECMA-376 element order: idx, order, tx, spPr, marker, invertIfNegative, dLbls, +/// cat/xVal, val/yVal, smooth): the series' formatting (fill, line, markers, its own labels) sits +/// in `c:spPr`, `c:marker` and `c:dLbls`; the values carry their number format. fn series(w: &mut W, spec: &ChartSpec, i: usize, s: &ChartSeries) { let k = spec.kind; let i = i.to_string(); @@ -207,25 +222,26 @@ fn series(w: &mut W, spec: &ChartSpec, i: usize, s: &ChartSeries) { w.leaf("c:v", &[], &s.name); w.close("c:tx"); } - match k { - // Markers only: the series has no line. - ChartType::Scatter => { - w.open("c:spPr", &[]); - w.open("a:ln", &[("w", "19050")]); - w.empty("a:noFill", &[]); - w.close("a:ln"); - w.close("c:spPr"); - } - ChartType::Column | ChartType::ColumnStacked | ChartType::Bar | ChartType::BarStacked => { - w.empty("c:invertIfNegative", &[("val", "0")]); - } - ChartType::Line => { - w.open("c:marker", &[]); - w.empty("c:symbol", &[("val", "none")]); - w.close("c:marker"); - } - _ => {} + series_props(w, s); + series_marker(w, k, s); + if matches!(k, ChartType::Column | ChartType::ColumnStacked | ChartType::Bar | ChartType::BarStacked) { + w.empty("c:invertIfNegative", &[("val", "0")]); } + if let Some(on) = s.labels { + w.open("c:dLbls", &[]); + for (name, show) in [ + ("c:showLegendKey", false), + ("c:showVal", on), + ("c:showCatName", false), + ("c:showSerName", false), + ("c:showPercent", false), + ("c:showBubbleSize", false), + ] { + w.empty(name, &[("val", if show { "1" } else { "0" })]); + } + w.close("c:dLbls"); + } + let code = s.fmt.as_deref().unwrap_or("General"); if k == ChartType::Scatter { let xs: Option>> = spec .categories @@ -234,27 +250,84 @@ fn series(w: &mut W, spec: &ChartSpec, i: usize, s: &ChartSeries) { .collect(); w.open("c:xVal", &[]); match xs { - Some(xs) => num_lit(w, &xs), + Some(xs) => num_lit(w, &xs, "General"), None => str_lit(w, &spec.categories), } w.close("c:xVal"); w.open("c:yVal", &[]); - num_lit(w, &s.values); + num_lit(w, &s.values, code); w.close("c:yVal"); } else { w.open("c:cat", &[]); str_lit(w, &spec.categories); w.close("c:cat"); w.open("c:val", &[]); - num_lit(w, &s.values); + num_lit(w, &s.values, code); w.close("c:val"); } if matches!(k, ChartType::Line | ChartType::Scatter) { - w.empty("c:smooth", &[("val", "0")]); + w.empty("c:smooth", &[("val", if s.smooth { "1" } else { "0" })]); } w.close("c:ser"); } +/// `c:spPr`: the series' fill (`a:solidFill` / `a:noFill`) and line (`a:ln`), written when the +/// model sets them. `a:ln` without `w` is the default width, `w` a fixed one, and `a:noFill` +/// inside it "no line" (a scatter series keeps its markers with no line). +fn series_props(w: &mut W, s: &ChartSeries) { + let fill_set = s.no_fill || s.fill.is_some(); + let ln_set = s.no_line || s.line_w.is_some(); + if !(fill_set || ln_set) { + return; + } + w.open("c:spPr", &[]); + if fill_set { + match &s.fill { + Some(c) => { + w.open("a:solidFill", &[]); + w.empty("a:srgbClr", &[("val", &c.hex())]); + w.close("a:solidFill"); + } + None => w.empty("a:noFill", &[]), + } + } + if ln_set { + let w_attr = s.line_w.map(emu).unwrap_or_default(); + let attrs = [("w", w_attr.as_str())]; + w.open("a:ln", if w_attr.is_empty() { &[] } else { &attrs }); + if s.no_line { + w.empty("a:noFill", &[]); + } + w.close("a:ln"); + } + w.close("c:spPr"); +} + +/// `c:marker`: line and scatter series say which symbol each point gets; other types have none. +fn series_marker(w: &mut W, k: ChartType, s: &ChartSeries) { + match k { + ChartType::Line => { + w.open("c:marker", &[]); + w.empty("c:symbol", &[("val", if s.markers == Some(true) { "circle" } else { "none" })]); + w.close("c:marker"); + } + // Unset: no `c:marker`, so Word picks its automatic symbol for each series. + ChartType::Scatter => { + if let Some(on) = s.markers { + w.open("c:marker", &[]); + w.empty("c:symbol", &[("val", if on { "circle" } else { "none" })]); + w.close("c:marker"); + } + } + _ => {} + } +} + +/// A line width in points as the `w` attribute DrawingML wants (EMU). +fn emu(pt: f32) -> String { + ((pt * 12700.0).round().max(0.0) as i64).to_string() +} + fn str_lit(w: &mut W, items: &[String]) { w.open("c:strLit", &[]); w.empty("c:ptCount", &[("val", &items.len().to_string())]); @@ -266,9 +339,9 @@ fn str_lit(w: &mut W, items: &[String]) { w.close("c:strLit"); } -fn num_lit(w: &mut W, values: &[Option]) { +fn num_lit(w: &mut W, values: &[Option], code: &str) { w.open("c:numLit", &[]); - w.leaf("c:formatCode", &[], "General"); + w.leaf("c:formatCode", &[], code); w.empty("c:ptCount", &[("val", &values.len().to_string())]); for (i, v) in values.iter().enumerate() { if let Some(v) = v.filter(|v| v.is_finite()) { @@ -285,17 +358,21 @@ fn num(v: f64) -> String { if v == 0.0 { "0".to_string() } else { format!("{v}") } } -fn category_axis(w: &mut W, pos: &str) { +fn category_axis(w: &mut W, pos: &str, ax: &ChartAxis) { w.open("c:catAx", &[]); w.empty("c:axId", &[("val", CAT_AX)]); - w.open("c:scaling", &[]); - w.empty("c:orientation", &[("val", "minMax")]); - w.close("c:scaling"); + scaling(w, ax); w.empty("c:delete", &[("val", "0")]); w.empty("c:axPos", &[("val", pos)]); + if ax.gridlines { + w.empty("c:majorGridlines", &[]); + } + axis_title(w, ax); + num_fmt(w, ax); w.empty("c:majorTickMark", &[("val", "none")]); w.empty("c:minorTickMark", &[("val", "none")]); - w.empty("c:tickLblPos", &[("val", "nextTo")]); + w.empty("c:tickLblPos", &[("val", if ax.labels { "nextTo" } else { "none" })]); + axis_line(w, ax); w.empty("c:crossAx", &[("val", VAL_AX)]); w.empty("c:crosses", &[("val", "autoZero")]); w.empty("c:auto", &[("val", "1")]); @@ -305,34 +382,81 @@ fn category_axis(w: &mut W, pos: &str) { w.close("c:catAx"); } -/// A value axis: with gridlines and no axis line (`grid`), else with its line and no gridlines. -fn value_axis(w: &mut W, id: &str, cross: &str, pos: &str, grid: bool, between: &str) { +/// A value axis (scatter x axes included): its scale, gridlines, title, labels and line, as the +/// model sets them. +fn value_axis(w: &mut W, id: &str, cross: &str, pos: &str, between: &str, ax: &ChartAxis) { w.open("c:valAx", &[]); w.empty("c:axId", &[("val", id)]); - w.open("c:scaling", &[]); - w.empty("c:orientation", &[("val", "minMax")]); - w.close("c:scaling"); + scaling(w, ax); w.empty("c:delete", &[("val", "0")]); w.empty("c:axPos", &[("val", pos)]); - if grid { + if ax.gridlines { w.empty("c:majorGridlines", &[]); } + axis_title(w, ax); + num_fmt(w, ax); w.empty("c:majorTickMark", &[("val", "none")]); w.empty("c:minorTickMark", &[("val", "none")]); - w.empty("c:tickLblPos", &[("val", "nextTo")]); - if grid { - w.open("c:spPr", &[]); - w.open("a:ln", &[]); - w.empty("a:noFill", &[]); - w.close("a:ln"); - w.close("c:spPr"); - } + w.empty("c:tickLblPos", &[("val", if ax.labels { "nextTo" } else { "none" })]); + axis_line(w, ax); w.empty("c:crossAx", &[("val", cross)]); w.empty("c:crosses", &[("val", "autoZero")]); w.empty("c:crossBetween", &[("val", between)]); w.close("c:valAx"); } +/// `c:scaling`: the orientation, then the fixed bounds when the model sets them. +fn scaling(w: &mut W, ax: &ChartAxis) { + w.open("c:scaling", &[]); + w.empty("c:orientation", &[("val", "minMax")]); + for (name, v) in [("c:max", ax.max), ("c:min", ax.min)] { + if let Some(v) = v.filter(|v| v.is_finite()) { + w.empty(name, &[("val", &num(v))]); + } + } + w.close("c:scaling"); +} + +/// The axis title, in the same rich-text shape the chart title uses. +fn axis_title(w: &mut W, ax: &ChartAxis) { + let Some(t) = &ax.title else { return }; + w.open("c:title", &[]); + w.open("c:tx", &[]); + w.open("c:rich", &[]); + w.empty("a:bodyPr", &[]); + w.empty("a:lstStyle", &[]); + w.open("a:p", &[]); + w.open("a:r", &[]); + w.leaf("a:t", &[], t); + w.close("a:r"); + w.close("a:p"); + w.close("c:rich"); + w.close("c:tx"); + w.empty("c:overlay", &[("val", "0")]); + w.close("c:title"); +} + +/// Tick-label number format: the model's code, unlinked from the source, else the default. +fn num_fmt(w: &mut W, ax: &ChartAxis) { + match &ax.fmt { + Some(code) => w.empty("c:numFmt", &[("formatCode", code), ("sourceLinked", "0")]), + None => w.empty("c:numFmt", &[("formatCode", "General"), ("sourceLinked", "1")]), + } +} + +/// `c:spPr`: an axis line only when the model keeps it (the default writes nothing, which reads +/// as a line); `a:noFill` when the axis line is off. +fn axis_line(w: &mut W, ax: &ChartAxis) { + if ax.line { + return; + } + w.open("c:spPr", &[]); + w.open("a:ln", &[]); + w.empty("a:noFill", &[]); + w.close("a:ln"); + w.close("c:spPr"); +} + /// The chart a chart part holds, when the part is exactly what [`chart_xml`] writes for it (so /// editing and saving it loses nothing). `None` for any other chart. pub(crate) fn spec_of(space: &El) -> Option { @@ -365,15 +489,40 @@ pub(crate) fn spec_of(space: &El) -> Option { let categories = sers.first().and_then(|s| s.child(if scatter { "c:xVal" } else { "c:cat" })).map(literal).unwrap_or_default(); let series = sers .iter() - .map(|s| ChartSeries { - name: s.child("c:tx").and_then(|t| t.child("c:v")).map(|v| v.text()).unwrap_or_default(), - values: s - .child(if scatter { "c:yVal" } else { "c:val" }) - .map(literal) - .unwrap_or_default() - .iter() - .map(|v| v.parse::().ok().filter(|v| v.is_finite())) - .collect(), + .map(|s| { + let ln = s.child("c:spPr").and_then(|p| p.child("a:ln")); + let symbol = s.child("c:marker").and_then(|m| m.child("c:symbol")).and_then(|m| m.attr("val")); + ChartSeries { + name: s.child("c:tx").and_then(|t| t.child("c:v")).map(|v| v.text()).unwrap_or_default(), + values: s + .child(if scatter { "c:yVal" } else { "c:val" }) + .map(literal) + .unwrap_or_default() + .iter() + .map(|v| v.parse::().ok().filter(|v| v.is_finite())) + .collect(), + fill: s + .child("c:spPr") + .and_then(|p| p.child("a:solidFill")) + .and_then(|f| f.child("a:srgbClr")) + .and_then(|c| c.attr("val")) + .and_then(Rgb::parse), + no_fill: s.child("c:spPr").and_then(|p| p.child("a:noFill")).is_some(), + line_w: ln.and_then(|l| l.attr("w")).and_then(|w| w.parse::().ok()).filter(|w| w.is_finite()).map(|w| (w / 12700.0) as f32), + no_line: ln.and_then(|l| l.child("a:noFill")).is_some(), + // Line series show no markers by default: only a setting that differs from that + // belongs in the model. A scatter series keeps what the file says, so a missing + // `c:marker` (Word's automatic symbols) stays unset and is not written back. + markers: symbol.map(|v| v != "none").filter(|m| scatter || *m), + smooth: s.child("c:smooth").and_then(|v| v.attr("val")).is_some_and(|v| v == "1"), + labels: s.child("c:dLbls").and_then(|d| d.child("c:showVal")).and_then(|v| v.attr("val")).map(|v| v == "1"), + fmt: s + .child(if scatter { "c:yVal" } else { "c:val" }) + .and_then(|v| v.els().find(|e| e.name == "c:numLit")) + .and_then(|l| l.child("c:formatCode")) + .map(|f| f.text()) + .filter(|f| *f != "General"), + } }) .collect(); let title = chart.child("c:title").and_then(|t| t.find("a:t")).map(|t| t.text()); @@ -384,12 +533,48 @@ pub(crate) fn spec_of(space: &El) -> Option { _ => LegendPos::Right, }); let data_labels = ty.child("c:dLbls").and_then(|d| d.child("c:showVal")).and_then(|v| v.attr("val")) == Some("1"); - let spec = ChartSpec { kind, categories, series, title, legend, data_labels }.sanitized(); - // Editable only when nothing would be lost: writing the model again gives the same part. - let again = xml::parse(chart_xml(&spec).as_bytes()).ok()?; + let (cat_a, val_a) = crate::read::chart::chart_axes(plot, scatter); + let axis = |a: crate::read::chart::Axis| ChartAxis { + title: a.title, + min: a.min, + max: a.max, + fmt: a.fmt, + gridlines: a.grid, + labels: a.labels, + line: a.line, + }; + let spec = ChartSpec { kind, categories, series, title, legend, data_labels, cat_axis: axis(cat_a), val_axis: axis(val_a) }.sanitized(); + // Editable only when nothing would be lost: writing the model again gives the same part, as + // this writer or the earlier one wrote it. + let mut again = xml::parse(chart_xml(&spec).as_bytes()).ok()?; + if same(space, &again, 0) { + return Some(spec); + } + as_previous_writer(&mut again); same(space, &again, 0).then_some(spec) } +/// `part` (what [`chart_xml`] writes) as the earlier WordCraft writer wrote the same model: it +/// had no axis `c:numFmt`. Only that element goes, and only with the value its absence reads as +/// (General, linked to the source), so a part that matches still holds nothing the model leaves out. +fn as_previous_writer(part: &mut El) { + fn els_mut(e: &mut El) -> impl Iterator { + e.kids.iter_mut().filter_map(|n| match n { + Node::El(e) => Some(e), + Node::Text(_) => None, + }) + } + fn drop_els(e: &mut El, drop: impl Fn(&El) -> bool) { + e.kids.retain(|n| !matches!(n, Node::El(c) if drop(c))); + } + let Some(plot) = els_mut(part).find(|e| e.name == "c:chart").and_then(|c| els_mut(c).find(|e| e.name == "c:plotArea")) else { return }; + for e in els_mut(plot) { + if matches!(e.name.as_str(), "c:catAx" | "c:valAx") { + drop_els(e, |c| c.name == "c:numFmt" && c.attr("sourceLinked") == Some("1")); + } + } +} + /// The points of a `c:strLit` / `c:numLit` (or a cache) as texts by index, `ptCount` long. fn literal(e: &El) -> Vec { let Some(lit) = e.els().find(|c| matches!(c.name.as_str(), "c:strLit" | "c:numLit")) else { return Vec::new() }; @@ -461,10 +646,11 @@ mod tests { let spec = ChartSpec { kind: ChartType::Column, categories: (0..4500).map(|i| i.to_string()).collect(), - series: (0..300).map(|i| ChartSeries { name: format!("S{i}"), values: vec![Some(1.0); 4500] }).collect(), + series: (0..300).map(|i| ChartSeries { name: format!("S{i}"), values: vec![Some(1.0); 4500], ..Default::default() }).collect(), title: None, legend: None, data_labels: false, + ..Default::default() }; let x = chart_xml(&spec); let series = x.matches("").count(); @@ -500,6 +686,61 @@ mod tests { assert_eq!(spec_of(&xml::parse(x.as_bytes()).unwrap()), None); } + /// Chart parts as the previous WordCraft chart writer saved them (its output for + /// `ChartSpec::sample`): no axis `c:numFmt`, and scatter series with no `c:marker`. + const PREVIOUS_COLUMN: &str = r#"Series 1Q1Q2Q3Q4General3.24.13.65Series 2Q1Q2Q3Q4General22.73.93.3Series 3Q1Q2Q3Q4General1.52.22.43.8"#; + const PREVIOUS_SCATTER: &str = r#"Series 1General1234General2.13.434.6Series 2General1234General1.21.92.83.1"#; + + #[test] + fn charts_saved_by_the_previous_writer_stay_editable() { + for (x, kind) in [(PREVIOUS_COLUMN, ChartType::Column), (PREVIOUS_SCATTER, ChartType::Scatter)] { + let spec = spec_of(&xml::parse(x.as_bytes()).unwrap()).unwrap_or_else(|| panic!("{kind:?}: the earlier part is read-only")); + assert_eq!((spec.kind, spec.series.len()), (kind, if kind == ChartType::Scatter { 2 } else { 3 })); + assert_eq!((spec.cat_axis.fmt.as_deref(), spec.val_axis.fmt.as_deref()), (None, None), "{kind:?}"); + assert!(spec.series.iter().all(|s| s.markers.is_none()), "{kind:?}: markers unset"); + // Saved again, it is in the current shape and still reads back as the same model. + assert_eq!(spec_of(&parse(&spec)).as_ref(), Some(&spec), "{kind:?}"); + } + // What neither writer writes still keeps such a part read-only: an axis format linked to + // the source that isn't General, a scatter marker other than the default, a marker size. + let edited = |x: &str, from: &str, to: &str| { + assert!(x.contains(from), "{from}"); + spec_of(&xml::parse(x.replacen(from, to, 1).as_bytes()).unwrap()) + }; + let ax = r#""#; + assert_eq!(edited(PREVIOUS_COLUMN, ax, &format!(r#"{ax}"#)), None); + let ln = r#""#; + assert_eq!(edited(PREVIOUS_SCATTER, ln, &format!(r#"{ln}"#)), None); + assert_eq!(edited(PREVIOUS_SCATTER, ln, &format!(r#"{ln}"#)), None); + assert_eq!(edited(PREVIOUS_COLUMN, "", ""), None); + } + + /// A scatter series with no `c:marker` (Word's automatic symbols) stays without one after an + /// unrelated edit and a save; an explicit circle or "none" stays explicit. + #[test] + fn scatter_series_without_a_marker_stay_without_after_a_save() { + let marker_of = |x: &El| -> Vec> { + let sc = x.child("c:chart").unwrap().child("c:plotArea").unwrap().child("c:scatterChart").unwrap(); + sc.children("c:ser").map(|s| s.child("c:marker").map(|m| m.child("c:symbol").unwrap().attr("val").unwrap().to_string())).collect() + }; + let mut spec = spec_of(&xml::parse(PREVIOUS_SCATTER.as_bytes()).unwrap()).unwrap(); + assert_eq!(marker_of(&xml::parse(PREVIOUS_SCATTER.as_bytes()).unwrap()), [None, None]); + spec.title = Some("Edited".into()); + spec.series[0].name = "Renamed".into(); + let saved = parse(&spec); + assert_eq!(marker_of(&saved), [None, None]); + let again = spec_of(&saved).unwrap(); + assert_eq!(again, spec); + assert!(again.series.iter().all(|s| s.markers.is_none())); + // Explicit choices are kept as written. + spec.series[0].markers = Some(true); + spec.series[1].markers = Some(false); + let saved = parse(&spec); + assert_eq!(marker_of(&saved), [Some("circle".to_string()), Some("none".to_string())]); + let again = spec_of(&saved).unwrap(); + assert_eq!((again.series[0].markers, again.series[1].markers), (Some(true), Some(false))); + } + #[test] fn elements_come_in_schema_order() { let mut spec = ChartSpec::sample(ChartType::ColumnStacked); @@ -517,6 +758,11 @@ mod tests { ["c:barDir", "c:grouping", "c:varyColors", "c:ser", "c:ser", "c:ser", "c:dLbls", "c:gapWidth", "c:overlap", "c:axId", "c:axId"] ); assert_eq!(names(bar.child("c:ser").unwrap()), ["c:idx", "c:order", "c:tx", "c:invertIfNegative", "c:cat", "c:val"]); + // A series with its own labels keeps `c:invertIfNegative` ahead of `c:dLbls` (CT_BarSer). + spec.series[0].labels = Some(true); + let labelled = parse(&spec); + let ser = labelled.child("c:chart").unwrap().child("c:plotArea").unwrap().child("c:barChart").unwrap().child("c:ser").unwrap(); + assert_eq!(names(ser), ["c:idx", "c:order", "c:tx", "c:invertIfNegative", "c:dLbls", "c:cat", "c:val"]); let val_ax = plot.child("c:valAx").unwrap(); assert_eq!( names(val_ax), @@ -526,6 +772,7 @@ mod tests { "c:delete", "c:axPos", "c:majorGridlines", + "c:numFmt", "c:majorTickMark", "c:minorTickMark", "c:tickLblPos", @@ -535,13 +782,35 @@ mod tests { "c:crossBetween" ] ); + let cat_ax = plot.child("c:catAx").unwrap(); + assert_eq!( + names(cat_ax), + [ + "c:axId", + "c:scaling", + "c:delete", + "c:axPos", + "c:numFmt", + "c:majorTickMark", + "c:minorTickMark", + "c:tickLblPos", + "c:crossAx", + "c:crosses", + "c:auto", + "c:lblAlgn", + "c:lblOffset", + "c:noMultiLvlLbl" + ] + ); let line = parse(&ChartSpec { data_labels: true, ..ChartSpec::sample(ChartType::Line) }); let lc = line.child("c:chart").unwrap().child("c:plotArea").unwrap().child("c:lineChart").unwrap(); assert_eq!(names(lc), ["c:grouping", "c:varyColors", "c:ser", "c:ser", "c:ser", "c:dLbls", "c:marker", "c:axId", "c:axId"]); assert_eq!(names(lc.child("c:ser").unwrap()), ["c:idx", "c:order", "c:tx", "c:marker", "c:cat", "c:val", "c:smooth"]); - let sc = parse(&ChartSpec::sample(ChartType::Scatter)); + let mut scatter = ChartSpec::sample(ChartType::Scatter); + scatter.series.iter_mut().for_each(|s| s.markers = Some(true)); + let sc = parse(&scatter); let sc = sc.child("c:chart").unwrap().child("c:plotArea").unwrap().child("c:scatterChart").unwrap(); - assert_eq!(names(sc.child("c:ser").unwrap()), ["c:idx", "c:order", "c:tx", "c:spPr", "c:xVal", "c:yVal", "c:smooth"]); + assert_eq!(names(sc.child("c:ser").unwrap()), ["c:idx", "c:order", "c:tx", "c:spPr", "c:marker", "c:xVal", "c:yVal", "c:smooth"]); let dn = parse(&ChartSpec::sample(ChartType::Doughnut)); let dn = dn.child("c:chart").unwrap().child("c:plotArea").unwrap(); assert_eq!(names(dn), ["c:layout", "c:doughnutChart"]); diff --git a/crates/docx/src/read/chart.rs b/crates/docx/src/read/chart.rs index a0087a3bb..5b02603d6 100644 --- a/crates/docx/src/read/chart.rs +++ b/crates/docx/src/read/chart.rs @@ -29,7 +29,9 @@ pub(super) use canvas::text_w; use canvas::{Rect, clip_text, legend, text}; #[cfg(test)] use format::{civil, excel_stamp, format_value}; -use model::{Axis, Grouping, Kind, Pos, Series}; +pub(crate) use model::Axis; +use model::{Grouping, Kind, Pos, Series}; +pub(crate) use parse::chart_axes; #[cfg(test)] use parse::{axis, category_text, labels, numbers}; use parse::{read_series, text_size, title_of}; diff --git a/crates/docx/src/read/chart/canvas.rs b/crates/docx/src/read/chart/canvas.rs index a8280e4ba..ab3fbf410 100644 --- a/crates/docx/src/read/chart/canvas.rs +++ b/crates/docx/src/read/chart/canvas.rs @@ -41,8 +41,13 @@ pub(super) fn widest(items: &[String], size: f32) -> f32 { items.iter().map(|s| text_w(s, size)).fold(0.0, f32::max) } +/// Text in `rect`; `angle` degrees clockwise turns it about the rect's centre (axis titles). pub(super) fn text(out: &mut Vec, rect: Rect, s: &str, size: f32, align: TextAlign, bold: bool) { - out.push(GraphicItem::Text { rect: rect.arr(), text: s.to_string(), size, color: TEXT, bold, align, font: None }); + text_angle(out, rect, s, size, align, bold, 0.0); +} + +pub(super) fn text_angle(out: &mut Vec, rect: Rect, s: &str, size: f32, align: TextAlign, bold: bool, angle: f32) { + out.push(GraphicItem::Text { rect: rect.arr(), text: s.to_string(), size, color: TEXT, bold, align, font: None, angle }); } /// Text centred on `cx` with its top at `y`. diff --git a/crates/docx/src/read/chart/model.rs b/crates/docx/src/read/chart/model.rs index 71ee7040f..fd2760db0 100644 --- a/crates/docx/src/read/chart/model.rs +++ b/crates/docx/src/read/chart/model.rs @@ -52,16 +52,21 @@ pub(super) enum Pos { /// One value axis (or category axis) as the file states it. #[derive(Default)] -pub(super) struct Axis { - pub(super) deleted: bool, - pub(super) grid: bool, - pub(super) line: bool, +pub(crate) struct Axis { + pub(crate) deleted: bool, + pub(crate) grid: bool, + pub(crate) line: bool, /// `c:crossBetween val="midCat"`: categories sit on the tick marks, not between them. pub(super) mid: bool, - pub(super) min: Option, - pub(super) max: Option, + pub(crate) min: Option, + pub(crate) max: Option, /// Number format of the tick labels, when not linked to the source data. - pub(super) fmt: Option, + pub(crate) fmt: Option, + /// The axis title, when the file gives it one. + pub(crate) title: Option, + /// Tick labels, as `c:tickLblPos` says (`none` hides them; a file that says nothing shows + /// them, as Word does). + pub(crate) labels: bool, } pub(super) struct Series { @@ -70,9 +75,17 @@ pub(super) struct Series { /// when missing or not a valid number. pub(super) idx: Option, pub(super) color: Option, - pub(super) line_w: f32, + /// Fixed line width in points, `None`: the chart's default. + pub(super) line_w: Option, /// Whether the series is drawn as a line (scatter series without one get markers). pub(super) line: bool, + /// The series' own fill: `Some` colour, `None` colour with `no_fill` set, else the chart's + /// accent for the series. + pub(super) no_fill: bool, + /// Markers on the series' points, when the file says. + pub(super) markers: Option, + /// Draw the series' line as a smooth curve (`c:smooth`). + pub(super) smooth: bool, pub(super) values: Vec>, /// Scatter x values (index + 1 when the file has none). pub(super) xs: Vec>, diff --git a/crates/docx/src/read/chart/parse.rs b/crates/docx/src/read/chart/parse.rs index 3c09fcfe9..45586509b 100644 --- a/crates/docx/src/read/chart/parse.rs +++ b/crates/docx/src/read/chart/parse.rs @@ -1,7 +1,7 @@ use super::format::{date_text, excel_stamp, format_value, is_date_code}; use super::model::{Axis, Grouping, Kind, Pos, Series}; use super::plot::label; -use super::{Chart, El, FONT, LINE_W, MAX_CELLS, MAX_POINTS, MAX_RADAR_SERIES, MAX_SERIES, MAX_SPOKES, Rgb, fill_colour, int, measure, slot}; +use super::{Chart, El, FONT, MAX_CELLS, MAX_POINTS, MAX_RADAR_SERIES, MAX_SERIES, MAX_SPOKES, Rgb, fill_colour, int, measure, slot}; impl Chart { pub(super) fn parse(space: &El, theme: &[Rgb]) -> Option { @@ -149,7 +149,7 @@ fn to_percent(series: &mut [Series], n: usize) { } /// The category axis (scatter: the horizontal value axis) and the value axis of a plot area. -fn chart_axes(plot: &El, scatter: bool) -> (Axis, Axis) { +pub(crate) fn chart_axes(plot: &El, scatter: bool) -> (Axis, Axis) { let vals_ax: Vec<&El> = plot.children("c:valAx").collect(); let horiz_pos = |a: &&El| matches!(a.child("c:axPos").and_then(|p| p.attr("val")), Some("b" | "t")); let (val_el, x_el) = if scatter { @@ -207,8 +207,14 @@ impl Series { let ln = sp.and_then(|p| p.child("a:ln")); let marker = ser.child("c:marker").and_then(|m| m.child("c:spPr")).and_then(|p| fill_colour(p, theme)); let color = sp.and_then(|p| fill_colour(p, theme)).or_else(|| ln.and_then(|l| fill_colour(l, theme))).or(marker); - let line_w = ln.and_then(|l| l.attr("w")).and_then(|v| measure(v, 12_700.0)).map_or(LINE_W, |w| w.clamp(0.0, 20.0)); + let no_fill = sp.and_then(|p| p.child("a:noFill")).is_some(); + let line_w = ln.and_then(|l| l.attr("w")).and_then(|v| measure(v, 12_700.0)).map(|w| w.clamp(0.0, 20.0)); let line = ln.is_none_or(|l| l.child("a:noFill").is_none()); + // `c:marker/c:symbol`: which symbol each point gets (`none` for no markers). Scatter + // series show markers unless the file says not; line series only when it says so. + let symbol = ser.child("c:marker").and_then(|m| m.child("c:symbol")).and_then(|s| s.attr("val")).map(str::to_string); + let markers = symbol.map(|s| s != "none").or_else(|| scatter.then_some(true)); + let smooth = ser.child("c:smooth").and_then(|s| s.attr("val")).is_some_and(truthy); let (values, fmt) = numbers(ser.child(if scatter { "c:yVal" } else { "c:val" }), cap); let (mut xs, x_fmt) = if scatter { numbers(ser.child("c:xVal"), cap) } else { (Vec::new(), None) }; if scatter && xs.is_empty() { @@ -223,7 +229,7 @@ impl Series { } } let labels = show_values(ser.child("c:dLbls")); - Series { name, idx, color, line_w, line, values, xs, points, fmt, x_fmt, labels, raw: Vec::new() } + Series { name, idx, color, line_w, line, no_fill, markers, smooth, values, xs, points, fmt, x_fmt, labels, raw: Vec::new() } } } @@ -290,7 +296,7 @@ fn pts(cache: &El, cap: usize) -> Vec> { } pub(super) fn axis(a: Option<&El>) -> Axis { - let Some(a) = a else { return Axis { deleted: true, ..Default::default() } }; + let Some(a) = a else { return Axis { deleted: true, labels: true, line: true, ..Default::default() } }; let scaling = a.child("c:scaling"); let num = |n: &str| scaling.and_then(|s| s.child(n)).and_then(|e| e.attr("val")).and_then(|v| v.trim().parse::().ok()).filter(|v| v.is_finite()); @@ -307,6 +313,8 @@ pub(super) fn axis(a: Option<&El>) -> Axis { .and_then(|f| f.attr("formatCode")) .filter(|f| f.len() <= MAX_FORMAT_CODE) .map(str::to_string), + title: a.child("c:title").and_then(title_text), + labels: a.child("c:tickLblPos").and_then(|p| p.attr("val")) != Some("none"), } } diff --git a/crates/docx/src/read/chart/plot.rs b/crates/docx/src/read/chart/plot.rs index 652ee79a8..09fe672d0 100644 --- a/crates/docx/src/read/chart/plot.rs +++ b/crates/docx/src/read/chart/plot.rs @@ -1,9 +1,9 @@ -use super::canvas::{Rect, fill, rect_segs, runs, seg, stroke, text, text_at, text_w, widest, wrap}; +use super::canvas::{Rect, clip_text, fill, rect_segs, runs, seg, stroke, text, text_angle, text_at, text_w, widest, wrap}; use super::format::format_value; use super::model::{DataLabel, Grouping, Kind, Series}; use super::parse::category_text; use super::polar::{draw_data_labels, label_of}; -use super::{AXIS, Chart, El, GAP, GRID, GraphicItem, LINE, MAX_LABEL, MAX_TICKS, PathSeg, Rgb, ShapeKind, TextAlign, fill_colour, measure}; +use super::{AXIS, Chart, El, GAP, GRID, GraphicItem, LINE, LINE_W, MAX_LABEL, MAX_TICKS, PathSeg, Rgb, ShapeKind, TextAlign, fill_colour, measure}; pub(super) fn label(s: &str) -> String { s.chars().take(MAX_LABEL).collect() @@ -151,21 +151,23 @@ struct Margins { } /// The margins the axis labels need around the plot in `area`. Category labels under a column -/// chart wrap to the band; labels that still don't fit show every k-th category. +/// chart wrap to the band; labels that still don't fit show every k-th category. Hidden tick +/// labels take no room; an axis title adds one line on its side. fn axis_margins(c: &Chart, ax: &Axes, area: Rect) -> Margins { let fs = c.text_size; let lh = fs * LINE; let scatter = c.kind == Kind::Scatter; let (cat_on, val_on) = (!c.cat.deleted, !c.val.deleted); + let (cat_labels, val_labels) = (cat_on && c.cat.labels, val_on && c.val.labels); let left = if c.horizontal { - if cat_on { widest(&c.cats, fs).min(area.w * 0.4) + GAP } else { 0.0 } - } else if val_on { + if cat_labels { widest(&c.cats, fs).min(area.w * 0.4) + GAP } else { 0.0 } + } else if val_labels { ax.vticks.iter().map(|(_, s)| text_w(s, fs)).fold(0.0, f32::max) + GAP } else { 0.0 - }; + } + title_left(c, cat_on, val_on, lh); let band_w = (area.w - left).max(1.0) / c.n as f32; - let wrapped: Vec> = if cat_on && !scatter { + let wrapped: Vec> = if cat_labels && !scatter { let width = if c.horizontal { left - GAP } else { band_w }; c.cats.iter().map(|s| wrap(s, width, fs)).collect() } else { @@ -174,17 +176,31 @@ fn axis_margins(c: &Chart, ax: &Axes, area: Rect) -> Margins { let widest_line = wrapped.iter().flatten().map(|s| text_w(s, fs)).fold(0.0, f32::max); let skip = ((widest_line / band_w).ceil() as usize).max(1); let label_lines = wrapped.iter().map(Vec::len).max().unwrap_or(1) as f32; - let bottom = if cat_on && !c.horizontal { + let bottom = (if cat_labels && !c.horizontal { if scatter { lh + GAP } else { label_lines * lh + GAP } - } else if c.horizontal && val_on { + } else if c.horizontal && val_labels { lh + GAP } else { 0.0 - }; - let top = if !c.horizontal && val_on { lh / 2.0 } else { 0.0 }; + }) + title_bottom(c, cat_on, val_on, lh); + let top = if !c.horizontal && val_labels { lh / 2.0 } else { 0.0 }; Margins { left, top, bottom, wrapped, skip } } +/// Room for the vertical axis title on the plot's left: one line when the axis that sits there +/// (the value axis for columns, the category axis for bars) has a title. +fn title_left(c: &Chart, cat_on: bool, val_on: bool, lh: f32) -> f32 { + let side = if c.horizontal { cat_on && c.cat.title.is_some() } else { val_on && c.val.title.is_some() }; + if side { lh } else { 0.0 } +} + +/// Room for the horizontal axis title under the plot: one line when the axis that sits there +/// (the category axis for columns, the value axis for bars) has a title. +fn title_bottom(c: &Chart, cat_on: bool, val_on: bool, lh: f32) -> f32 { + let side = if c.horizontal { val_on && c.val.title.is_some() } else { cat_on && c.cat.title.is_some() }; + if side { lh } else { 0.0 } +} + /// A bar, column, line, area or scatter chart in `area`: gridlines, series, axes, then labels. pub(super) fn cartesian(out: &mut Vec, c: &Chart, area: Rect) { if c.n == 0 { @@ -200,6 +216,9 @@ pub(super) fn cartesian(out: &mut Vec, c: &Chart, area: Rect) { if c.val.grid { draw_grid(out, &g, &ax.vticks); } + if c.cat.grid { + draw_cat_grid(out, &g, &ax.xticks, c.kind == Kind::Scatter); + } let mut labels = Vec::new(); match c.kind { Kind::Bar => bars(out, c, &g, &mut labels), @@ -210,12 +229,36 @@ pub(super) fn cartesian(out: &mut Vec, c: &Chart, area: Rect) { } draw_axes(out, c, &g); draw_data_labels(out, &labels, c.text_size, g.horiz && c.kind == Kind::Bar); - if !c.val.deleted { - draw_value_labels(out, c, &g, &ax.vticks, Rect { w: m.left, ..area }); + if !c.val.deleted && c.val.labels { + let room = title_left(c, !c.cat.deleted, true, c.text_size * LINE); + draw_value_labels(out, c, &g, &ax.vticks, Rect { x: area.x + room, w: m.left - room, ..area }); } - if !c.cat.deleted { + if !c.cat.deleted && c.cat.labels { draw_category_labels(out, c, &g, &ax.xticks, &m, area); } + draw_axis_titles(out, c, &g, area); +} + +/// The axis titles, one line: the title of the vertical axis (the value axis for columns, the +/// category axis for bars) is rotated 90° on the plot's left; the horizontal axis's title sits +/// under the plot. +fn draw_axis_titles(out: &mut Vec, c: &Chart, g: &Frame, area: Rect) { + let lh = c.text_size * LINE; + // The axis drawn along the plot's left (the value axis for columns, the category axis for + // bars) gets its title rotated there; the other axis's title sits under the plot. + let (left, bottom) = if c.horizontal { (&c.cat, &c.val) } else { (&c.val, &c.cat) }; + if !left.deleted + && let Some(t) = &left.title + { + let t = clip_text(t, g.plot.h, c.text_size); + text_angle(out, Rect { x: area.x, y: g.plot.y, w: lh, h: g.plot.h }, &t, c.text_size, TextAlign::Center, false, 90.0); + } + if !bottom.deleted + && let Some(t) = &bottom.title + { + let t = clip_text(t, g.plot.w, c.text_size); + text_angle(out, Rect { x: g.plot.x, y: area.bottom() - lh, w: g.plot.w, h: lh }, &t, c.text_size, TextAlign::Center, false, 0.0); + } } /// Major gridlines at the value ticks. @@ -228,6 +271,24 @@ fn draw_grid(out: &mut Vec, g: &Frame, ticks: &[(f64, String)]) { } } +/// Gridlines along the category axis: across the plot at each category's centre, at the x ticks +/// of a scatter chart. +fn draw_cat_grid(out: &mut Vec, g: &Frame, xticks: &[(f64, String)], scatter: bool) { + let plot = g.plot; + if scatter { + for (t, _) in xticks { + let p = g.scat_x(*t); + stroke(out, seg(p, plot.y, p, plot.bottom()), GRID, 0.75); + } + return; + } + for i in 0..g.n { + let p = g.band_start(i) + g.band() / 2.0; + let segs = if g.horiz { seg(plot.x, p, plot.right(), p) } else { seg(p, plot.y, p, plot.bottom()) }; + stroke(out, segs, GRID, 0.75); + } +} + /// The category axis line, the plot area's outline and the value axis line, as the file shows them. fn draw_axes(out: &mut Vec, c: &Chart, g: &Frame) { let plot = g.plot; @@ -361,7 +422,9 @@ fn bars(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec, pts: impl Iterator, colour: Rgb) { + const MARKER: f32 = 6.0; + for (x, y) in pts { + let rect = [x - MARKER / 2.0, y - MARKER / 2.0, MARKER, MARKER]; + out.push(GraphicItem::Shape { rect, kind: ShapeKind::Ellipse, fill: Some(colour), stroke: None, stroke_width: 0.0 }); + } +} + +/// A polyline through `pts`, a smooth curve (Catmull-Rom pieces) when `smooth` and there are at +/// least three points in a row; gaps (`None`) end a run. +fn curve(pts: impl Iterator>, smooth: bool) -> Vec { + if !smooth { + return runs(pts); + } + let pts: Vec> = pts.collect(); + let mut segs = Vec::new(); + let mut i = 0; + while i < pts.len() { + let Some(first) = pts[i] else { + i += 1; + continue; + }; + // Collect one run of points. + let mut run = vec![first]; + while let Some(p) = pts.get(i + 1).copied().flatten() { + run.push(p); + i += 1; + } + i += 1; + if run.len() < 3 { + segs.extend(runs(run.into_iter().map(Some))); + continue; + } + segs.push(PathSeg::Move(run[0].0, run[0].1)); + for k in 0..run.len() - 1 { + // Catmull-Rom: tangent at p1 from p0 to p2 (ends mirror their own tangent). + let p0 = run[k.max(1) - 1]; + let p1 = run[k]; + let p2 = run[k + 1]; + let p3 = run.get(k + 2).copied().unwrap_or(p2); + let c1 = (p1.0 + (p2.0 - p0.0) / 6.0, p1.1 + (p2.1 - p0.1) / 6.0); + let c2 = (p2.0 - (p3.0 - p1.0) / 6.0, p2.1 - (p3.1 - p1.1) / 6.0); + segs.push(PathSeg::Cubic(c1.0, c1.1, c2.0, c2.1, p2.0, p2.1)); + } + } + segs +} + fn areas(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec) { let mut base = vec![0.0f64; g.n]; for (j, s) in c.series.iter().enumerate().filter(|(_, s)| has_values(s)) { @@ -434,7 +551,7 @@ fn areas(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec) { const MARKER: f32 = 6.0; for (j, s) in c.series.iter().enumerate() { @@ -452,12 +569,13 @@ fn draw_scatter(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut V } } if s.line { - stroke(out, runs(pts.iter().copied()), c.series_colour(j), s.line_w); - continue; + stroke(out, curve(pts.iter().copied(), s.smooth), c.series_colour(j), s.line_w.unwrap_or(LINE_W)); } - for (x, y) in pts.iter().flatten() { - let rect = [x - MARKER / 2.0, y - MARKER / 2.0, MARKER, MARKER]; - out.push(GraphicItem::Shape { rect, kind: ShapeKind::Ellipse, fill: Some(c.series_colour(j)), stroke: None, stroke_width: 0.0 }); + if s.markers != Some(false) { + for (x, y) in pts.iter().flatten() { + let rect = [x - MARKER / 2.0, y - MARKER / 2.0, MARKER, MARKER]; + out.push(GraphicItem::Shape { rect, kind: ShapeKind::Ellipse, fill: Some(c.series_colour(j)), stroke: None, stroke_width: 0.0 }); + } } } } diff --git a/crates/docx/src/read/chart/polar.rs b/crates/docx/src/read/chart/polar.rs index 57ad10472..ec7768d5c 100644 --- a/crates/docx/src/read/chart/polar.rs +++ b/crates/docx/src/read/chart/polar.rs @@ -2,7 +2,7 @@ use super::canvas::{Rect, clip_text, fill, stroke, text, text_w, widest}; use super::format::format_value; use super::model::{DataLabel, Kind, Series}; use super::plot::{Axes, has_values}; -use super::{Chart, FRAC_PI_2, GAP, GRID, GraphicItem, LINE, PathSeg, Rgb, ShapeKind, TAU, TEXT, TextAlign}; +use super::{Chart, FRAC_PI_2, GAP, GRID, GraphicItem, LINE, LINE_W, PathSeg, Rgb, ShapeKind, TAU, TEXT, TextAlign}; pub(super) fn pie(out: &mut Vec, c: &Chart, area: Rect) { let Some(s) = c.series.first() else { return }; @@ -92,7 +92,7 @@ pub(super) fn radar(out: &mut Vec, c: &Chart, area: Rect) { if c.radar_fill { fill(out, segs.clone(), col); } - stroke(out, segs, col, s.line_w); + stroke(out, segs, col, s.line_w.unwrap_or(LINE_W)); for (i, p) in ring.iter().enumerate() { if c.radar_marks && s.values.get(i).copied().flatten().is_some() { let rect = [p.0 as f32 - MARKER / 2.0, p.1 as f32 - MARKER / 2.0, MARKER, MARKER]; @@ -171,7 +171,7 @@ pub(super) fn draw_data_labels(out: &mut Vec, labels: &[DataLabel], (Rect { x: l.x - w / 2.0, y: l.y - lh, w, h: lh }, TextAlign::Center) }; let color = if l.inside { Rgb::WHITE } else { TEXT }; - out.push(GraphicItem::Text { rect: rect.arr(), text: l.text.clone(), size: fs, color, bold: false, align, font: None }); + out.push(GraphicItem::Text { rect: rect.arr(), text: l.text.clone(), size: fs, color, bold: false, align, font: None, angle: 0.0 }); } } diff --git a/crates/docx/src/read/diagram.rs b/crates/docx/src/read/diagram.rs index 7f03e8b51..7b7bbeebf 100644 --- a/crates/docx/src/read/diagram.rs +++ b/crates/docx/src/read/diagram.rs @@ -463,7 +463,16 @@ fn text(sp: &El, xf: Xf, b: [f64; 4], theme: &[Rgb], filled: bool, fit: f32, out let mut y = y0 + (th - total) / 2.0; for l in lines { let lh = l.size * LINE; - out.push(GraphicItem::Text { rect: [x0, y, tw, lh], text: l.text, size: l.size, color: l.color, bold: l.bold, align: l.align, font: l.font }); + out.push(GraphicItem::Text { + rect: [x0, y, tw, lh], + text: l.text, + size: l.size, + color: l.color, + bold: l.bold, + align: l.align, + font: l.font, + angle: 0.0, + }); y += lh; } } diff --git a/crates/docx/src/write/embed.rs b/crates/docx/src/write/embed.rs index 9a8051e09..7673a6f26 100644 --- a/crates/docx/src/write/embed.rs +++ b/crates/docx/src/write/embed.rs @@ -884,10 +884,11 @@ mod tests { let spec = ChartSpec { kind: ChartType::Column, categories: vec!["a".into(), "b".into()], - series: (0..series).map(|i| ChartSeries { name: format!("S{i}"), values: vec![Some(1.0); 2] }).collect(), + series: (0..series).map(|i| ChartSeries { name: format!("S{i}"), values: vec![Some(1.0); 2], ..Default::default() }).collect(), title: None, legend: None, data_labels: false, + ..Default::default() }; let graphic = Graphic { kind: GraphicKind::Chart, w: 100.0, h: 100.0, chart: Some(Arc::new(spec)), ..Default::default() }; InlineObject::Graphic { w: 100.0, h: 100.0, alt: String::new(), float: Default::default(), graphic: Arc::new(graphic) } diff --git a/crates/flow/src/from_doc.rs b/crates/flow/src/from_doc.rs index 341ded449..18b287bb5 100644 --- a/crates/flow/src/from_doc.rs +++ b/crates/flow/src/from_doc.rs @@ -749,7 +749,7 @@ fn graphic_group( let inline = Inline::Shape { kind: *kind, w: rect[2] * sx, h: rect[3] * sy, float: None, blocks: Vec::new(), look, path: None }; Some(Member { x: rect[0] * sx, y: rect[1] * sy, inline }) } - GraphicItem::Text { rect, text, size, color, bold, align, font } if finite(rect) && !text.trim().is_empty() => { + GraphicItem::Text { rect, text, size, color, bold, align, font, .. } if finite(rect) && !text.trim().is_empty() => { let size = if size.is_finite() { size.clamp(1.0, 400.0) } else { 11.0 }; // One line, centred vertically in its place as the graphic draws it. let line = size * 1.2; diff --git a/crates/odf/src/text/chart.rs b/crates/odf/src/text/chart.rs index 9d073ecd2..2a79352a1 100644 --- a/crates/odf/src/text/chart.rs +++ b/crates/odf/src/text/chart.rs @@ -229,7 +229,7 @@ impl Reader { }; let name = s.label.as_deref().and_then(|a| cells_of(a).first().copied()).map(|at| label(self.cell(at))).unwrap_or_default(); let name = if name.is_empty() { format!("Series {}", i + 1) } else { name }; - ChartSeries { name, values } + ChartSeries { name, values, ..Default::default() } }) .collect(); // A scatter chart's x values: its first series' domain. @@ -248,7 +248,10 @@ impl Reader { _ => LegendPos::Right, }); let title = self.title.as_deref().map(str::trim).filter(|t| !t.is_empty()).map(str::to_string); - Some(ChartSpec { kind, categories, series, title, legend, data_labels }.sanitized()) + // ODF axis formatting is not read; the value axis keeps the look every chart had before + // axes were formattable (gridlines, no axis line), a round chart has none. + let val_axis = if kind.is_round() { Default::default() } else { craft_wordmodel::chart::value_axis() }; + Some(ChartSpec { kind, categories, series, title, legend, data_labels, val_axis, ..Default::default() }.sanitized()) } } diff --git a/crates/odf/src/text/tests_more/charts.rs b/crates/odf/src/text/tests_more/charts.rs index 9ac0b6b96..5aa892cf4 100644 --- a/crates/odf/src/text/tests_more/charts.rs +++ b/crates/odf/src/text/tests_more/charts.rs @@ -57,8 +57,8 @@ fn spec(chart: &str) -> Option { fn north_south() -> Vec { vec![ - ChartSeries { name: "North".into(), values: vec![Some(10.0), Some(14.0), Some(8.0), Some(16.0)] }, - ChartSeries { name: "South".into(), values: vec![Some(12.0), None, Some(11.0), Some(13.0)] }, + ChartSeries { name: "North".into(), values: vec![Some(10.0), Some(14.0), Some(8.0), Some(16.0)], ..Default::default() }, + ChartSeries { name: "South".into(), values: vec![Some(12.0), None, Some(11.0), Some(13.0)], ..Default::default() }, ] } @@ -78,6 +78,8 @@ fn a_column_chart_reads_its_data_title_and_legend() { title: Some("Sales by quarter".into()), legend: Some(LegendPos::Right), data_labels: false, + val_axis: craft_wordmodel::chart::value_axis(), + ..Default::default() } ); // The frame's size, in points. @@ -135,7 +137,7 @@ fn line_area_pie_doughnut_and_scatter_classes() { let s = spec(&chart_xml("chart:scatter", "", "", "", scatter)).unwrap(); assert_eq!(s.kind, ChartType::Scatter); assert_eq!(s.categories, vec!["10", "14", "8", "16"]); - assert_eq!(s.series, vec![ChartSeries { name: "South".into(), values: vec![Some(12.0), None, Some(11.0), Some(13.0)] }]); + assert_eq!(s.series, vec![ChartSeries { name: "South".into(), values: vec![Some(12.0), None, Some(11.0), Some(13.0)], ..Default::default() }]); } #[test] @@ -249,7 +251,15 @@ fn every_chart_type_is_saved_as_a_chart_object_and_reads_back() { let bytes = crate::text::export(&doc_with(spec.clone(), false)).unwrap(); let back = reread(&bytes); assert_eq!(back.len(), 1, "{kind:?}"); - assert_eq!(*back[0].spec, spec.clone().sanitized(), "{kind:?}"); + // ODF keeps no series or axis formatting here: only the data, the title and the legend + // come back; the value axis has the gridlines every chart had before axes were formattable. + let mut expected = spec.clone().sanitized(); + for s in &mut expected.series { + *s = ChartSeries { name: std::mem::take(&mut s.name), values: std::mem::take(&mut s.values), ..Default::default() }; + } + expected.cat_axis = Default::default(); + expected.val_axis = if kind.is_round() { Default::default() } else { craft_wordmodel::chart::value_axis() }; + assert_eq!(*back[0].spec, expected, "{kind:?}"); assert_eq!((back[0].w, back[0].h, back[0].alt.as_str()), (300.0, 180.0, "Sales chart"), "{kind:?}"); // The package lists the chart object. let z = crate::Package::open(&bytes, &crate::Limits::DEFAULT).unwrap(); diff --git a/crates/odf/src/text/tests_more/groups.rs b/crates/odf/src/text/tests_more/groups.rs index bf1b056a6..4fada68a9 100644 --- a/crates/odf/src/text/tests_more/groups.rs +++ b/crates/odf/src/text/tests_more/groups.rs @@ -130,6 +130,7 @@ fn a_diagram_is_saved_as_a_group_of_its_drawing() { bold: false, align: TextAlign::Center, font: None, + angle: 0.0, }, GraphicItem::Shape { rect: [90.0, 9.0, 18.0, 18.0], kind: ShapeKind::Arrow, fill: Some(blue), stroke: None, stroke_width: 0.0 }, ], diff --git a/crates/wordmodel/src/chart.rs b/crates/wordmodel/src/chart.rs index b0cb6ad60..4744d8b88 100644 --- a/crates/wordmodel/src/chart.rs +++ b/crates/wordmodel/src/chart.rs @@ -11,6 +11,8 @@ use serde::{Deserialize, Serialize}; +use crate::props::Rgb; + /// Most series in a chart. pub const MAX_SERIES: usize = 255; /// Most categories (points per series) in a chart. @@ -123,13 +125,107 @@ impl LegendPos { } } -/// One series: its name and a value per category (`None` = no value, a gap). +/// One series: its name, a value per category (`None` = no value, a gap) and how it is drawn +/// (Chart Design ▸ Format Series): fill, line, markers, smooth lines, its own data labels and +/// number format. Unset fields follow the chart's defaults. #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct ChartSeries { pub name: String, #[serde(default)] pub values: Vec>, + /// Fill colour; `None`: the chart's accent colour for the series. + #[serde(default)] + pub fill: Option, + /// "None" fill: the series draws no fill. + #[serde(default)] + pub no_fill: bool, + /// Line width in points; `None`: the chart's default. + #[serde(default)] + pub line_w: Option, + /// "None" line: the series draws no line. + #[serde(default)] + pub no_line: bool, + /// Markers on points; `None`: unset (scatter charts draw them; a saved scatter series then has no `c:marker`, so Word picks its own symbols). + #[serde(default)] + pub markers: Option, + /// Draw the line as a smooth curve. + #[serde(default)] + pub smooth: bool, + /// Data labels for this series; `None`: follow the chart's setting. + #[serde(default)] + pub labels: Option, + /// Number format of this series's labels and values; `None`: linked to the source. + #[serde(default)] + pub fmt: Option, +} + +/// One chart axis as Word formats it (Format Axis): title, scale bounds, tick-label number +/// format, gridlines, tick labels and the axis line. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ChartAxis { + /// `None`: no axis title; text cut to [`MAX_TEXT`] characters. + #[serde(default)] + pub title: Option, + /// Fixed lower bound; `None`: automatic. + #[serde(default)] + pub min: Option, + /// Fixed upper bound; `None`: automatic. + #[serde(default)] + pub max: Option, + /// Tick-label number format (`#,##0`, `0.00`, `0%`…); `None`: linked to the source data. + #[serde(default)] + pub fmt: Option, + /// Major gridlines drawn along this axis. + #[serde(default)] + pub gridlines: bool, + /// Tick labels; `false` hides the axis the way Word's Axis Labels ▸ None does. + #[serde(default = "the_true")] + pub labels: bool, + /// The axis line. + #[serde(default = "the_true")] + pub line: bool, +} + +fn the_true() -> bool { + true +} + +impl Default for ChartAxis { + fn default() -> Self { + ChartAxis { title: None, min: None, max: None, fmt: None, gridlines: false, labels: true, line: true } + } +} + +/// The value axis as a new chart has it: gridlines, labels, no axis line. +pub fn value_axis() -> ChartAxis { + ChartAxis { gridlines: true, line: false, ..ChartAxis::default() } +} + +impl ChartAxis { + /// Make the axis safe to store: texts cleaned, bounds finite, `min` under `max` (an + /// impossible pair drops both), the format code cut to [`MAX_FMT`] characters. + pub fn sanitize(&mut self) { + self.title = self.title.as_deref().map(clean_text).filter(|t| !t.is_empty()); + self.min = self.min.filter(|v| v.is_finite()); + self.max = self.max.filter(|v| v.is_finite()); + if matches!((self.min, self.max), (Some(lo), Some(hi)) if lo >= hi) { + self.min = None; + self.max = None; + } + self.fmt = self.fmt.as_deref().map(clean_fmt).filter(|f| !f.is_empty()); + } +} + +/// Longest axis number format kept, characters. +pub const MAX_FMT: usize = 128; + +/// A number format code: control characters as spaces, ends trimmed, at most [`MAX_FMT`] +/// characters. +pub fn clean_fmt(s: &str) -> String { + let s: String = s.chars().take(MAX_FMT * 4).map(|c| if c.is_control() { ' ' } else { c }).collect(); + s.trim().chars().take(MAX_FMT).collect::().trim_end().to_string() } /// A chart the app can edit. @@ -151,6 +247,12 @@ pub struct ChartSpec { /// Show each point's value next to it. #[serde(default)] pub data_labels: bool, + /// The category axis (scatter charts: the x axis). + #[serde(default)] + pub cat_axis: ChartAxis, + /// The value axis (scatter charts: the y axis); gridlines on, no axis line, as a new chart has them. + #[serde(default = "value_axis")] + pub val_axis: ChartAxis, } impl ChartSpec { @@ -168,10 +270,23 @@ impl ChartSpec { ChartSpec { kind, categories: categories.into_iter().map(str::to_string).collect(), - series: series.into_iter().map(|(n, v)| ChartSeries { name: n.to_string(), values: v.into_iter().map(Some).collect() }).collect(), + series: series + .into_iter() + .map(|(n, v)| ChartSeries { + name: n.to_string(), + values: v.into_iter().map(Some).collect(), + // Scatter series are drawn as markers without a line. + no_line: kind == ChartType::Scatter, + ..Default::default() + }) + .collect(), title: None, legend: Some(LegendPos::Bottom), data_labels: false, + cat_axis: ChartAxis::default(), + // Pie and doughnut charts have no axes: their axes stay plain, so the chart reads back + // as the same model. + val_axis: if kind.is_round() { ChartAxis::default() } else { value_axis() }, } } @@ -203,8 +318,12 @@ impl ChartSpec { *v = v.filter(|x| x.is_finite()); } s.values.resize(n, None); + s.fmt = s.fmt.as_deref().map(clean_fmt).filter(|f| !f.is_empty()); + s.line_w = s.line_w.filter(|w| w.is_finite()).map(|w| w.clamp(0.0, 20.0)); } self.title = self.title.as_deref().map(clean_text).filter(|t| !t.is_empty()); + self.cat_axis.sanitize(); + self.val_axis.sanitize(); } /// The chart after `sanitize`. @@ -229,7 +348,11 @@ mod tests { let mut c = ChartSpec { categories: vec!["a".into(); MAX_POINTS + 10], series: (0..MAX_SERIES + 5) - .map(|i| ChartSeries { name: format!("{}\n{}", "x".repeat(400), i), values: vec![Some(f64::NAN), Some(f64::INFINITY), Some(1.0)] }) + .map(|i| ChartSeries { + name: format!("{}\n{}", "x".repeat(400), i), + values: vec![Some(f64::NAN), Some(f64::INFINITY), Some(1.0)], + ..Default::default() + }) .collect(), title: Some(" ".into()), ..Default::default() @@ -250,7 +373,7 @@ mod tests { fn short_categories_are_padded_to_the_longest_series() { let c = ChartSpec { categories: vec!["a".into()], - series: vec![ChartSeries { name: "s".into(), values: vec![Some(1.0), Some(2.0)] }], + series: vec![ChartSeries { name: "s".into(), values: vec![Some(1.0), Some(2.0)], ..Default::default() }], ..Default::default() } .sanitized(); @@ -258,4 +381,45 @@ mod tests { assert_eq!(ChartType::from_id("BARSTACKED"), Some(ChartType::BarStacked)); assert_eq!(LegendPos::from_id("top"), Some(LegendPos::Top)); } + + #[test] + fn axis_bounds_and_formats_are_cleaned() { + let mut a = ChartAxis { + title: Some(" Sales\n".into()), + min: Some(f64::NAN), + max: Some(50.0), + fmt: Some("x".repeat(MAX_FMT + 40)), + gridlines: true, + labels: false, + line: true, + }; + a.sanitize(); + assert_eq!(a.title.as_deref(), Some("Sales")); + assert_eq!(a.min, None); + assert_eq!(a.max, Some(50.0)); + assert_eq!(a.fmt.as_deref().map(|f| f.chars().count()), Some(MAX_FMT)); + + // min not under max drops the pair; a format of only spaces is no format. + let mut b = ChartAxis { min: Some(50.0), max: Some(50.0), fmt: Some(" ".into()), ..Default::default() }; + b.sanitize(); + assert_eq!((b.min, b.max), (None, None)); + assert_eq!(b.fmt, None); + + let mut spec = ChartSpec { + series: vec![ChartSeries { name: "s".into(), values: vec![Some(1.0)], ..Default::default() }], + categories: vec!["a".into()], + ..Default::default() + }; + spec.series[0].line_w = Some(f32::NAN); + spec.series[0].fmt = Some("0.00".into()); + spec.sanitize(); + assert_eq!(spec.series[0].line_w, None); + assert_eq!(spec.series[0].fmt.as_deref(), Some("0.00")); + let mut spec = ChartSpec { + series: vec![ChartSeries { name: "s".into(), values: vec![], line_w: Some(100.0), ..Default::default() }], + ..Default::default() + }; + spec.sanitize(); + assert_eq!(spec.series[0].line_w, Some(20.0), "a wild width clamps to 20 pt"); + } } diff --git a/crates/wordmodel/src/graphic.rs b/crates/wordmodel/src/graphic.rs index c77c0e5e7..f4a7bcf2e 100644 --- a/crates/wordmodel/src/graphic.rs +++ b/crates/wordmodel/src/graphic.rs @@ -115,7 +115,9 @@ pub enum GraphicItem { #[serde(default)] stroke_width: f32, }, - /// One line of text in `rect`, aligned horizontally by `align`, centred vertically. + /// One line of text in `rect`, aligned horizontally by `align`, centred vertically; `angle` + /// degrees clockwise turns the text about `rect`'s centre as it is drawn (chart axis titles + /// use 90° for the vertical axis). Text { rect: [f32; 4], text: String, @@ -127,6 +129,8 @@ pub enum GraphicItem { align: TextAlign, #[serde(default)] font: Option, + #[serde(default)] + angle: f32, }, /// A picture (`Document::media` key) stretched into `rect`. Image { rect: [f32; 4], media: String }, From 12656b3d0fad48bb958e42c50a07a0959966fb27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Legrand?= Date: Sat, 14 Nov 2026 17:20:40 +0100 Subject: [PATCH 031/382] docs(dxf): describe configurable tag limit --- crates/dxf/src/lib.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/dxf/src/lib.rs b/crates/dxf/src/lib.rs index 4cf3e46e9..040fe3888 100644 --- a/crates/dxf/src/lib.rs +++ b/crates/dxf/src/lib.rs @@ -195,8 +195,9 @@ pub use codepage::decode_code_page; /// # Errors /// /// Returns an error for empty input, an invalid group code, an incomplete group-code/value pair, -/// truncated binary data, or more than [`MAX_TAGS`] group codes. For ASCII input, invalid numeric -/// text becomes `0.0` for real values or `0` for integer values, and an EOF tag is not required. +/// truncated binary data, or more group codes than the limit returned by [`max_tags()`], which is +/// [`MAX_TAGS`] by default. For ASCII input, invalid numeric text becomes `0.0` for real values or +/// `0` for integer values, and an EOF tag is not required. pub fn parse(bytes: &[u8]) -> Result> { parse_with_limit(bytes, max_tags()) } From d2b6416db9b8358e337ed7472ec52c262593a27c Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Sat, 14 Nov 2026 11:32:34 -0500 Subject: [PATCH 032/382] craft-xlsx: binary styles: legacy number formats, automatic font colours, tinted fills A broader Excel probe found three differences from the styles.xml Excel writes for the same workbook: - A number format with a newer locale tag ([$-ja-JP-x-gannen]) is only in alternate content: the newer spelling in a block for later versions, and the one .xlsx keeps as formatCode in a block listing version 12 onwards. The styles part now reads the alternate content meant for Excel 2007 (version 12), so the format is no longer lost. - A font whose colour is automatic has no in .xlsx. - A pattern fill whose pattern colour has a tint states the system background (bgColor indexed 65), as Excel's .xlsx does for any pattern. --- crates/xlsx/README.md | 3 ++- crates/xlsx/src/xlsb.rs | 29 ++++++++++++++++++++++------- crates/xlsx/src/xlsb/styles.rs | 12 +++++++++--- crates/xlsx/tests/xlsb.rs | 21 +++++++++++++++++---- 4 files changed, 50 insertions(+), 15 deletions(-) diff --git a/crates/xlsx/README.md b/crates/xlsx/README.md index b2b581112..81941fac1 100644 --- a/crates/xlsx/README.md +++ b/crates/xlsx/README.md @@ -86,7 +86,8 @@ they were. A binary workbook is not written. A binary workbook gives the same `Workbook`, strings, rows and merged cells, and the same `Styles`: number formats, fonts, fills, borders, cell and cell style formats, cell styles, differential formats and the indexed colours, as Excel writes them in `styles.xml` (default fill -colours and empty settings left out, a cell style format's `apply*="0"`). Custom table styles and +colours and empty settings left out, a cell style format's `apply*="0"`, a number format with a +newer locale tag in its Excel 2007 spelling, as `formatCode` has it). Custom table styles and recent colours are not read; a damaged styles part is a warning and no styles. Its cell formulas are decoded from their tokens into the text an `.xlsx` file holds (`_xlfn.` and `_xlpm.` names as written, no implicit `@`), with `FormulaKind::Shared` or `FormulaKind::Array` and their ranges, and `BrtCellMeta` as the cell diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index 50da6185c..043b0743b 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -175,12 +175,16 @@ struct Records<'a, 'l> { bytes: Bytes<'a>, limits: &'l Limits, budget: &'l Budget, - blocks: Vec, + /// Each open block's end record, and whether its records are read. + blocks: Vec<(u16, bool)>, + /// Read the alternate content meant for Excel 2007 (version 12), as an `.xlsx` reader sees + /// the main attribute where Excel keeps a newer spelling in an extension. + excel_2007: bool, } impl<'a, 'l> Records<'a, 'l> { fn new(bytes: &'a [u8], limits: &'l Limits, budget: &'l Budget) -> Self { - Self { bytes: Bytes::new(bytes), limits, budget, blocks: vec![] } + Self { bytes: Bytes::new(bytes), limits, budget, blocks: vec![], excel_2007: false } } fn next(&mut self, warnings: &mut Warnings) -> Result, Error> { @@ -209,6 +213,7 @@ impl<'a, 'l> Records<'a, 'l> { // BrtFRTBegin, BrtACBegin. 35 | 37 => { let mut b = Bytes::new(payload); + let mut read = false; if id == 35 { b.take(4)?; } else { @@ -216,22 +221,32 @@ impl<'a, 'l> Records<'a, 'l> { if count == 0 { return Err(invalid("empty alternate-content version list")); } - b.take(usize::from(count) * 4)?; + // ACProductVersion: fileVersion, then fileProduct (15 bits) and + // fileExtension (the version and later). + for _ in 0..count { + let (version, product) = (b.u16()?, b.u16()?); + let later = product & 0x8000 != 0; + read |= self.excel_2007 && product & 0x7FFF == 0 && (version == 12 || later && version <= 12); + } } b.finish()?; if self.blocks.len() >= 64 { return Err(invalid("extension blocks nested too deeply")); } - self.blocks.push(id + 1); - warnings.warn("unsupported XLSB future-record and alternate-content blocks were skipped"); + // Inside a skipped block, everything is skipped. + let read = read && self.blocks.iter().all(|(_, r)| *r); + self.blocks.push((id + 1, read)); + if !read { + warnings.warn("unsupported XLSB future-record and alternate-content blocks were skipped"); + } } // BrtFRTEnd, BrtACEnd. 36 | 38 => { - if self.blocks.pop() != Some(id) || !payload.is_empty() { + if self.blocks.pop().map(|(end, _)| end) != Some(id) || !payload.is_empty() { return Err(invalid("mismatched extension block end")); } } - _ if !self.blocks.is_empty() => {} + _ if self.blocks.iter().any(|(_, read)| !read) => {} _ => return Ok(Some((id, payload))), } } diff --git a/crates/xlsx/src/xlsb/styles.rs b/crates/xlsx/src/xlsb/styles.rs index 094620a07..50673ef28 100644 --- a/crates/xlsx/src/xlsb/styles.rs +++ b/crates/xlsx/src/xlsb/styles.rs @@ -151,10 +151,11 @@ fn font(b: &mut Bytes<'_>) -> Result { extend: on(0x80), underline: (uls != 0).then(|| underline(u32::from(uls))), vert_align: (sss != 0).then(|| script(u32::from(sss))), - color, family: (family != 0).then_some(u32::from(family)), charset: (charset != 0).then_some(u32::from(charset)), scheme: scheme(u32::from(font_scheme)).filter(|s| *s != FontScheme::None), + // An automatic colour is a font with no `` in `.xlsx`. + color: color.filter(|c| c.source != ColorSource::Auto), }) } @@ -164,7 +165,8 @@ fn gradient(b: &mut Bytes<'_>, path: bool) -> Result { } /// `BrtFill`. Excel's `.xlsx` leaves out the default colours: system foreground (indexed 64) as -/// the pattern colour and system background (indexed 65) as the background. +/// the pattern colour and system background (indexed 65) as the background, unless the pattern +/// colour has a tint (as the built-in "20% - Accent1" styles do), when it states the background. fn fill(b: &mut Bytes<'_>) -> Result { let fls = b.u32()?; let fg = color(b)?; @@ -183,7 +185,8 @@ fn fill(b: &mut Bytes<'_>) -> Result { return Ok(Fill::Gradient(g)); } let system = |c: Color, i: u32| c.source == ColorSource::Indexed(i) && c.tint == 0.0; - Ok(Fill::Pattern(PatternFill { pattern: Some(pattern(fls)?), fg: fg.filter(|c| !system(*c, 64)), bg: bg.filter(|c| !system(*c, 65)) })) + let tinted = fg.is_some_and(|c| c.tint != 0.0); + Ok(Fill::Pattern(PatternFill { pattern: Some(pattern(fls)?), fg: fg.filter(|c| !system(*c, 64)), bg: bg.filter(|c| tinted || !system(*c, 65)) })) } /// `BrtBorder`: the five edges a cell border has, each stated (`` when it has no line). @@ -393,6 +396,9 @@ fn dxf(b: &mut Bytes<'_>) -> Result { /// The styles part: `BrtBeginStyleSheet` to `BrtEndStyleSheet`. pub(crate) fn styles(bytes: &[u8], limits: &Limits, budget: &Budget, warnings: &mut Warnings) -> Result { let mut records = Records::new(bytes, limits, budget); + // Excel keeps a number format with a newer locale tag in two alternate-content blocks: the + // newer spelling for itself, and for Excel 2007 the one `.xlsx` has as `formatCode`. + records.excel_2007 = true; records.first(278, warnings)?; let mut s = Styles::default(); // Inside BrtBeginCellStyleXFs (true) or BrtBeginCellXFs (false). diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index bc1a7f6bd..85643b0ee 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -1014,6 +1014,8 @@ fn styles_bin() -> Vec { // character set 0 and scheme "none" are not written in `.xlsx`. let fancy = font(290, 0x0A, 700, 1, 0x22, 0, 2, &rgb(0, 128, 255), 0, "Wingdings"); let heading = font(220, 0, 400, 0, 0, 2, 0, &theme(4, 13106), 1, "Aptos Display"); + // An automatic colour: no `` in `.xlsx`. + let auto = font(220, 0x02, 400, 0, 0, 2, 0, &color(0, 64, 0, [0, 0, 0, 255]), 2, "Aptos Narrow"); let gradient = [ &0x28u32.to_le_bytes()[..], &indexed(64), @@ -1030,20 +1032,31 @@ fn styles_bin() -> Vec { let none = edge(0, &color(0, 0, 0, [0, 0, 0, 0])); let parts: Vec> = vec![ record(278, &[]), - begin(615, 1), + begin(615, 2), record(44, &[&164u16.to_le_bytes()[..], &wide(r"yyyy\-mm\-dd")].concat()), + // A format in two alternate-content blocks: the newer spelling for version 13 and later + // (skipped), and the one for versions 12 and 13, which `.xlsx` has as `formatCode`. + record(37, &[1, 0, 13, 0, 0, 0x80]), + record(44, &[&165u16.to_le_bytes()[..], &wide("[$-ja-JP-x-gannen]ge")].concat()), + record(38, &[]), + record(37, &[2, 0, 12, 0, 0, 0, 13, 0, 0, 0]), + record(44, &[&165u16.to_le_bytes()[..], &wide("[$]ge")].concat()), + record(38, &[]), record(616, &[]), - begin(611, 3), + begin(611, 4), normal, fancy, heading, + auto, record(612, &[]), - begin(603, 5), + begin(603, 6), pattern_fill(0, &indexed(64), &indexed(65)), pattern_fill(17, &indexed(64), &indexed(65)), pattern_fill(1, &rgb(255, 255, 0), &indexed(64)), pattern_fill(9, &theme(5, -8191), &indexed(65)), record(45, &gradient), + // A tinted pattern colour: `.xlsx` states the system background, as for darkGrid above. + pattern_fill(1, &theme(4, 26213), &indexed(65)), record(604, &[]), begin(613, 2), record(46, &[&[0][..], &none, &none, &none, &none, &none].concat()), @@ -1109,7 +1122,7 @@ fn styles_bin() -> Vec { parts.concat() } -const STYLES_XML: &str = r#""#; +const STYLES_XML: &str = r#""#; /// The same styles from a SpreadsheetML package. fn xml_styles(xml: &str) -> Styles { From 99223e1972bbb1682cfa57e7f6ab5d56c4411ca6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Legrand?= Date: Sat, 31 Oct 2026 14:17:41 +0100 Subject: [PATCH 033/382] refactor(i18n): satisfy Clippy pedantic lints --- crates/i18n/src/collate.rs | 2 ++ crates/i18n/src/fold.rs | 14 +++++++++++--- crates/i18n/src/format.rs | 13 +++++++++---- crates/i18n/src/lib.rs | 17 ++++++++++++----- crates/i18n/src/number.rs | 11 +++++++++++ crates/i18n/src/region.rs | 4 ++++ crates/i18n/src/scripts.rs | 28 +++++++++++++++++++++++----- crates/i18n/src/size.rs | 8 ++++++++ 8 files changed, 80 insertions(+), 17 deletions(-) diff --git a/crates/i18n/src/collate.rs b/crates/i18n/src/collate.rs index 06d417897..629b3bf75 100644 --- a/crates/i18n/src/collate.rs +++ b/crates/i18n/src/collate.rs @@ -30,6 +30,7 @@ impl Collator { /// Sorting for `locale`, a language code such as `sv`, `pt-br` or `zh-hant` (any case, `-` /// or `_`, glibc forms such as `sv_SE.UTF-8` and `sr_RS@latin`). A BCP 47 collation type /// picks another order where there is one: `zh-hant-u-co-pinyin`, `zh-hans-u-co-stroke`. + #[must_use] pub fn new(locale: &str) -> Collator { let mut prefs: CollatorPreferences = Locale::try_from_str(&bcp47(locale)).unwrap_or(Locale::UNKNOWN).into(); prefs.numeric_ordering = Some(CollationNumericOrdering::True); @@ -46,6 +47,7 @@ impl Collator { /// the collation counts as equal (`Layer 2` and `Layer 02`) is in code point order, so a sort /// doesn't depend on the input order. Without collation data (never with the embedded data) /// this is code point order. + #[must_use] pub fn compare(&self, a: &str, b: &str) -> Ordering { match &self.0 { Some(c) => c.as_borrowed().compare(a, b).then_with(|| a.cmp(b)), diff --git a/crates/i18n/src/fold.rs b/crates/i18n/src/fold.rs index 959c6425a..dd77b6dfd 100644 --- a/crates/i18n/src/fold.rs +++ b/crates/i18n/src/fold.rs @@ -15,7 +15,7 @@ //! `IRMAK` and `ırmak`. Plain `str::to_lowercase` follows no locale and turns `İ` into `i` plus a //! combining dot, which nothing typed would match. //! -//! The Turkish i handling and sigma folding come from PdfCraft's `fold_case` (snipeTR, +//! The Turkish i handling and sigma folding come from `PdfCraft`'s `fold_case` (snipeTR, //! nevicia2010-hub). use std::ops::Range; @@ -34,6 +34,7 @@ pub struct Folder { impl Folder { /// Case- and accent-insensitive folding for `locale`, a language code such as `tr`, `pt-br` /// or `zh-hant` (any case, `-` or `_`). + #[must_use] pub fn new(locale: &str) -> Folder { let language = locale.split(['-', '_', '.', '@']).next().unwrap_or_default(); Folder { turkic: language.eq_ignore_ascii_case("tr") || language.eq_ignore_ascii_case("az"), accents: false } @@ -41,11 +42,13 @@ impl Folder { /// Accents count: `é` no longer matches `e`, and a match can't end on a letter whose accent it /// leaves out. + #[must_use] pub fn keep_accents(self) -> Folder { Folder { accents: true, ..self } } /// `s` folded, with the map back to `s`. + #[must_use] pub fn fold(&self, s: &str) -> Folded { let nfkd = DecomposingNormalizerBorrowed::new_nfkd(); let extend = CodePointSetData::new::(); @@ -75,17 +78,19 @@ impl Folder { } /// `s` folded, without the map: a key to compare or store. + #[must_use] pub fn key(&self, s: &str) -> String { self.fold(s).text } /// Whether `haystack` contains `needle`, both folded. + #[must_use] pub fn contains(&self, haystack: &str, needle: &str) -> bool { self.fold(haystack).find(&self.fold(needle)).is_some() } /// One cluster, already in NFKD. - fn fold_cluster(&self, cluster: &str, out: &mut String) { + fn fold_cluster(self, cluster: &str, out: &mut String) { let mut chars = cluster.chars().peekable(); while let Some(c) = chars.next() { match c { @@ -219,6 +224,7 @@ pub struct Folded { impl Folded { /// The folded text. + #[must_use] pub fn as_str(&self) -> &str { &self.text } @@ -226,6 +232,7 @@ impl Folded { /// The source byte range that folded bytes `range` came from, widened to whole source /// characters with their accents: `ss` in the folding of `Straße` maps back to `ß`, `e` in /// that of `é` to the whole `é`. An empty range maps to an empty one. + #[must_use] pub fn source_range(&self, range: Range) -> Range { // The last cluster starting at or before `at` is the one holding it: clusters that fold to // nothing share their offset with the next one. @@ -241,6 +248,7 @@ impl Folded { /// The first match of `needle` (folded the same way), as a byte range of the source text. /// An empty needle matches at the start. + #[must_use] pub fn find(&self, needle: &Folded) -> Option> { self.matches(needle).next() } @@ -363,10 +371,10 @@ mod tests { #[test] fn matches_map_back_to_the_source() { - let f = Folder::new("en"); fn find<'a>(f: Folder, haystack: &'a str, needle: &str) -> Option<&'a str> { f.fold(haystack).find(&f.fold(needle)).map(|r| &haystack[r]) } + let f = Folder::new("en"); let find = |haystack, needle| find(f, haystack, needle); assert_eq!(find("Große Straße", "strasse"), Some("Straße")); assert_eq!(find("Große Straße", "SS"), Some("ß")); diff --git a/crates/i18n/src/format.rs b/crates/i18n/src/format.rs index 14eb8c102..badfbdfca 100644 --- a/crates/i18n/src/format.rs +++ b/crates/i18n/src/format.rs @@ -4,7 +4,7 @@ use std::fmt; use fixed_decimal::{Decimal, Sign}; -use icu_decimal::{DecimalFormatter, parts}; +use icu_decimal::{DecimalFormatter, options::DecimalFormatterOptions, parts}; use icu_locale_core::Locale; use icu_locale_core::extensions::unicode::{key, value}; use writeable::{Part, PartsWrite, Writeable}; @@ -46,7 +46,8 @@ impl Format { if digits == Digits::Latin { locale.extensions.unicode.keywords.set(key!("nu"), value!("latn")); } - let decimal = data::provider().and_then(|p| DecimalFormatter::try_new_with_buffer_provider(p, (&locale).into(), Default::default()).ok()); + let decimal = data::provider() + .and_then(|p| DecimalFormatter::try_new_with_buffer_provider(p, (&locale).into(), DecimalFormatterOptions::default()).ok()); let mut format = Format { decimal, group: None, point: None, percent: ("", "%"), marks: Marks::default() }; // The locale's own separators and digits, read from a number that shows them all. let probe = format.parts(&Decimal::try_from_str("-1234567.5").unwrap_or_default()); @@ -81,6 +82,7 @@ impl Format { } /// The format for a locale tag (`de-CH`, `ar-EG`), with the locale's own digits. + #[must_use] pub fn from_tag(tag: &str) -> Format { Format::new(&Region::from_tag(tag), Digits::Locale) } @@ -92,6 +94,7 @@ impl Format { /// `value` rounded to `decimals` digits after the decimal separator; infinities and NaN are /// `∞`, `-∞` and `NaN`. + #[must_use] pub fn number(&self, value: f64, decimals: usize) -> String { match to_decimal(value, decimals) { Some(d) => self.write(&d), @@ -101,6 +104,7 @@ impl Format { /// [`Self::number`] without grouping separators, for values such as pixel sizes and years: /// `1920`, `١٩٢٠`, `1234,5`. + #[must_use] pub fn number_ungrouped(&self, value: f64, decimals: usize) -> String { match to_decimal(value, decimals) { Some(d) => { @@ -113,6 +117,7 @@ impl Format { /// `ratio` as a percentage with `decimals` digits after the decimal separator: `0.5` is /// `50%`, `50 %` (French, German), `%50` (Turkish), `٥٠٪؜` (Egyptian Arabic). + #[must_use] pub fn percent(&self, ratio: f64, decimals: usize) -> String { let Some(d) = to_decimal(ratio * 100.0, decimals) else { return format!("{}{}{}", self.percent.0, non_finite(ratio), self.percent.1); @@ -212,7 +217,7 @@ impl PartsWrite for Sink<'_> { _ => return result, }; if slot.is_empty() { - *slot = written.to_owned(); + written.clone_into(slot); } } result @@ -370,7 +375,7 @@ mod tests { for (tag, want) in [("en", "50%"), ("de", "50\u{a0}%"), ("fr", "12,5\u{a0}%"), ("tr", "%50"), ("ar-EG", "٥٠٪\u{61c}"), ("fa", "۵۰٪"), ("hi", "50%")] { - let decimals = if tag == "fr" { 1 } else { 0 }; + let decimals = usize::from(tag == "fr"); let ratio = if tag == "fr" { 0.125 } else { 0.5 }; assert_eq!(Format::from_tag(tag).percent(ratio, decimals), want, "{tag}"); } diff --git a/crates/i18n/src/lib.rs b/crates/i18n/src/lib.rs index 53bbffe9e..ce473d84f 100644 --- a/crates/i18n/src/lib.rs +++ b/crates/i18n/src/lib.rs @@ -113,7 +113,9 @@ impl Locale { rows.entry(e.context).or_default().insert(e.source, e.translation); } } - problems.iter().for_each(|p| log::warn!("translation catalog: {p}; row skipped")); + for p in &problems { + log::warn!("translation catalog: {p}; row skipped"); + } Parsed { rows, problems } }) } @@ -156,6 +158,7 @@ impl I18n { /// to left, say). Locales that can't be used are skipped and come back as problems for the app /// to log. A locale's bad rows are logged (`log::warn!`) when it is first looked up in, and /// [`I18n::check_all`] lists them all. + #[must_use] pub fn new(embedded: &'static Embedded, offered: &[&str]) -> (I18n, Vec) { let mut problems = Vec::new(); let mut locales = vec![bare("en"), bare("pseudo")]; @@ -417,6 +420,7 @@ impl I18n { /// value that already is one isolate keeps it; pass numbers, paths and codes through [`ltr`]. /// Other text gets no marks, and a value's own isolate is taken off. Unknown placeholders stay as written, /// and inserted values are never read as templates, so a file name containing `{n}` stays intact. +#[must_use] pub fn fmt(template: &str, args: &[(&str, &str)]) -> String { fill(template, args, true) } @@ -424,6 +428,7 @@ pub fn fmt(template: &str, args: &[(&str, &str)]) -> String { /// [`fmt`] without isolates, for text that goes where the marks would get in the way: file /// names, logs, terminals, text compared or parsed later. Every isolate mark is taken off, in /// the template and in the values. +#[must_use] pub fn fmt_plain(template: &str, args: &[(&str, &str)]) -> String { strip_isolates(&fill(template, args, false)) } @@ -444,6 +449,7 @@ const ALM: char = '\u{061C}'; /// `value` as a first-strong isolate (FSI…PDI): it takes the direction of its first strong /// letter and can't reorder the text around it. What [`fmt`] does to each value in text with a /// right-to-left letter. +#[must_use] pub fn isolate(value: &str) -> String { wrap(FSI, value) } @@ -452,12 +458,14 @@ pub fn isolate(value: &str) -> String { /// codes, which read left to right in every language. In an RTL first-strong isolate, the /// segments of `/home/مستخدم/file.txt` would run right to left. [`fmt`] takes the isolate off /// again in text with no right-to-left letter. +#[must_use] pub fn ltr(value: &str) -> String { wrap(LRI, value) } /// `text` without isolate marks (LRI, RLI, FSI, PDI): a [`fmt`] or [`I18n::trn`] result made fit /// for a file name, a log or a comparison. +#[must_use] pub fn strip_isolates(text: &str) -> String { text.chars().filter(|c| !matches!(*c, LRI | RLI | FSI | PDI)).collect() } @@ -483,14 +491,13 @@ fn wrap(initiator: char, value: &str) -> String { PDF if open.last() == Some(&false) => { open.pop(); } - PDF => continue, PDI if isolates > 0 => { while open.pop() == Some(false) { out.push(PDF); } isolates -= 1; } - PDI => continue, + PDF | PDI => continue, _ => {} } out.push(c); @@ -713,11 +720,11 @@ fn plural_rules(code: &str) -> Option<(PluralRules, Vec)> { categories.push(c); } } - categories.sort_by_key(rank); + categories.sort_by_key(|c| rank(*c)); Some((rules, categories)) } -fn rank(c: &PluralCategory) -> u8 { +fn rank(c: PluralCategory) -> u8 { match c { PluralCategory::Zero => 0, PluralCategory::One => 1, diff --git a/crates/i18n/src/number.rs b/crates/i18n/src/number.rs index 1120fbe88..211d9dfe0 100644 --- a/crates/i18n/src/number.rs +++ b/crates/i18n/src/number.rs @@ -80,6 +80,12 @@ impl Format { /// /// Percent signs, units and the space before a unit (`50 %`, `12 px`) are not read; strip them /// first. Anything else is an error rather than a guess. + /// + /// # Errors + /// + /// Returns `NumberError::Empty` for an empty input or one reduced to spaces and a sign, + /// `Unexpected` for an invalid character, `MixedDigits` for mixed digit sets, `Separator` + /// for misplaced marks, and `TooLarge` when the parsed value is not finite. pub fn parse(&self, text: &str) -> Result { let marks = self.marks; let text: String = text.chars().filter(|c| !is_bidi_mark(*c)).collect(); @@ -129,6 +135,11 @@ impl Format { /// The number in `text` as `locale` (a language tag, `de-CH`, `ar_EG.UTF-8`) writes it: /// [`Format::parse`] for [`Format::from_tag`]. Build the [`Format`] once to read many numbers. A /// locale CLDR doesn't know reads as CLDR's root does (`1,234.5`). +/// +/// # Errors +/// +/// Returns the same `NumberError` as [`Format::parse`] for invalid digits, characters, or +/// separators, or when the value is not finite. pub fn parse_number(text: &str, locale: &str) -> Result { Format::from_tag(locale).parse(text) } diff --git a/crates/i18n/src/region.rs b/crates/i18n/src/region.rs index fcdffe8af..205444c25 100644 --- a/crates/i18n/src/region.rs +++ b/crates/i18n/src/region.rs @@ -73,6 +73,7 @@ impl Region { /// `nu` stays in the number and time locales (`ar-EG-u-nu-latn`). `C` and `POSIX` are the C /// locale: English, A4, metric, a `.` decimal and no grouping. An empty or unreadable tag is /// `en-US`; a bare `en` is the United States, any other bare language has no territory. + #[must_use] pub fn from_tag(tag: &str) -> Region { match Tag::parse(tag) { Some(tag) => Region::from_parts(&tag), @@ -85,6 +86,7 @@ impl Region { /// The region for an app's saved region setting: `""` or `auto` (any case) is /// [`Region::system`], anything else a locale tag for [`Region::from_tag`]. + #[must_use] pub fn from_setting(setting: &str) -> Region { let setting = setting.trim(); if setting.is_empty() || setting.eq_ignore_ascii_case("auto") { Region::system() } else { Region::from_tag(setting) } @@ -99,6 +101,7 @@ impl Region { /// - Linux and the BSDs: `LC_ALL`, else each of `LC_NUMERIC`, `LC_TIME`, `LC_MEASUREMENT` and /// `LC_PAPER` on its own, else `LANG`. /// - The web and Android: the preferred language, the only locale they expose. + #[must_use] pub fn system() -> Region { static SYSTEM: OnceLock = OnceLock::new(); SYSTEM.get_or_init(read_system).clone() @@ -298,6 +301,7 @@ fn from_apple(identifier: &str, metric: bool, decimal: &str, grouping: &str, hou /// A grouping separator the system sets: none at all when empty (Windows' `sThousand` the user /// cleared), else one character. #[cfg(any(test, windows, target_vendor = "apple"))] +#[expect(clippy::option_option, reason = "The public setting distinguishes following the locale, no grouping, and a custom separator")] fn grouping(s: &str) -> Option> { if s.is_empty() { Some(None) } else { single_char(s).map(Some) } } diff --git a/crates/i18n/src/scripts.rs b/crates/i18n/src/scripts.rs index 1ae0f29bc..e16342e26 100644 --- a/crates/i18n/src/scripts.rs +++ b/crates/i18n/src/scripts.rs @@ -39,6 +39,7 @@ pub enum Script { impl Script { /// The ISO 15924 code, `Latn`. + #[must_use] pub fn code(self) -> &'static str { match self { Script::Arab => "Arab", @@ -75,6 +76,7 @@ impl Script { } /// Whether text in this script runs right to left. + #[must_use] pub fn rtl(self) -> bool { matches!(self, Script::Arab | Script::Hebr | Script::Syrc | Script::Thaa) } @@ -112,8 +114,12 @@ pub enum Han { /// where it is the language's own script. A language not in the table is taken to be written in /// Latin. // ponytail: the languages a Craft app ships or could plausibly ship; add a row with the locale. +#[must_use] pub fn scripts(tag: &str) -> &'static [Script] { - use Script::*; + use Script::{ + Arab, Armn, Beng, Cyrl, Deva, Ethi, Geor, Grek, Gujr, Guru, Hang, Hani, Hebr, Hira, Kana, Khmr, Knda, Laoo, Latn, Mlym, Mymr, Orya, Sinh, + Syrc, Taml, Telu, Thaa, Thai, Tibt, + }; let tag = Subtags::parse(tag); if let Some(s) = tag.script.as_deref().and_then(subtag_scripts) { return s; @@ -154,6 +160,7 @@ pub fn scripts(tag: &str) -> &'static [Script] { } /// The direction of a language tag's text: right to left when its main script is. +#[must_use] pub fn direction(tag: &str) -> Direction { match scripts(tag).first() { Some(s) if s.rtl() => Direction::Rtl, @@ -165,6 +172,7 @@ pub fn direction(tag: &str) -> Direction { /// P3): the contents of isolates (LRI, RLI or FSI up to the matching PDI) are skipped, and the /// search stops at the first paragraph separator. `None` when the paragraph has no strong /// character; P3 then reads it as left to right, and an app may use the interface direction. +#[must_use] pub fn base_direction(text: &str) -> Option { match unicode_bidi::get_base_direction(text) { unicode_bidi::Direction::Ltr => Some(Direction::Ltr), @@ -175,9 +183,10 @@ pub fn base_direction(text: &str) -> Option { /// The forms a language tag's Han characters take: `zh-CN`, `zh-SG`, `zh-Hans` and plain `zh` → /// Simplified; `zh-TW`, `zh-Hant` and the other regions CLDR writes in Traditional characters -/// (`zh-US`, `zh-AU`) → Traditional; `zh-HK`, `zh-MO`, `zh-Hant-HK` and `yue` → HongKong; `ja` → +/// (`zh-US`, `zh-AU`) → Traditional; `zh-HK`, `zh-MO`, `zh-Hant-HK` and `yue` → `HongKong`; `ja` → /// Japanese; `ko` → Korean. `None` for a language not written with Han, which leaves the choice /// to the font stack. +#[must_use] pub fn han(tag: &str) -> Option { let tag = Subtags::parse(tag); let hong_kong = matches!(tag.region.as_deref(), Some("hk" | "mo")); @@ -202,8 +211,14 @@ pub fn han(tag: &str) -> Option { // ponytail: mn-CN → Mong is left out until vertical Mongolian layout is supported. pub(crate) fn region_script(language: &str, region: &str) -> Option<&'static str> { Some(match (language, region) { - ("az", "iq" | "ir") | ("ha", "cm" | "sd") | ("kk", "af" | "cn" | "ir" | "mn") | ("ku", "iq" | "ir" | "lb") => "arab", - ("ky", "cn") | ("ms", "cc") | ("pa", "pk") | ("tg", "pk") | ("uz", "af") => "arab", + ("az", "iq" | "ir") + | ("ha", "cm" | "sd") + | ("kk", "af" | "cn" | "ir" | "mn") + | ("ku", "iq" | "ir" | "lb") + | ("ky", "cn") + | ("ms", "cc") + | ("pa" | "tg", "pk") + | ("uz", "af") => "arab", ("az", "ru") | ("ku", "am" | "az" | "ge" | "tm") | ("ug", "kz" | "mn") | ("uz", "cn") => "cyrl", ("ky", "tr") | ("sr", "me" | "ro" | "tr") => "latn", ("sd", "in") => "deva", @@ -216,7 +231,10 @@ pub(crate) fn region_script(language: &str, region: &str) -> Option<&'static str /// The scripts a script subtag stands for, including the CLDR unions (`jpan`, `kore`). `None` for /// one not in [`Script`], so the language's own scripts apply. fn subtag_scripts(subtag: &str) -> Option<&'static [Script]> { - use Script::*; + use Script::{ + Arab, Armn, Beng, Cyrl, Deva, Ethi, Geor, Grek, Gujr, Guru, Hang, Hani, Hebr, Hira, Kana, Khmr, Knda, Laoo, Latn, Mlym, Mong, Mymr, Orya, + Sinh, Syrc, Taml, Telu, Thaa, Thai, Tibt, + }; Some(match subtag { "hans" | "hant" | "hani" => &[Hani], "jpan" => &[Hani, Hira, Kana], diff --git a/crates/i18n/src/size.rs b/crates/i18n/src/size.rs index 830c09573..b316360a5 100644 --- a/crates/i18n/src/size.rs +++ b/crates/i18n/src/size.rs @@ -33,6 +33,7 @@ impl SizeUnit { /// // `12 MB`, `3.4 MB`, `640 KB`: decimal steps, whole kilobytes, no decimals from 10 MB. /// let style = FileSize::DECIMAL.smallest(SizeUnit::Kilo).largest(SizeUnit::Mega).unit_decimals(SizeUnit::Kilo, 0).whole_from(10); /// ``` +#[must_use] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct FileSize { step: u64, @@ -104,6 +105,10 @@ impl FileSize { } /// The unit `bytes` is written in, the number in it and its digits after the point. + #[expect( + clippy::cast_precision_loss, + reason = "File sizes are displayed as rounded f64 values; exact u64 arithmetic is not required for presentation" + )] fn parts(&self, bytes: u64) -> (SizeUnit, f64, usize) { let (smallest, largest) = (self.smallest.min(self.largest), self.largest); let mut unit = smallest; @@ -137,6 +142,7 @@ impl FileSize { } } + #[expect(clippy::cast_precision_loss, reason = "Unit scales are displayed as f64 values; exact u64 arithmetic is not required for presentation")] fn scale(&self, unit: SizeUnit) -> f64 { (self.step as f64).powi(unit as i32) } @@ -160,6 +166,7 @@ impl FileSize { impl I18n { /// `bytes` as a file size in `lang`, written the way `style` says (`1.5 MB`, `512 bytes`), the /// number as [`I18n::format`] writes it (`1,5 Mo`). + #[must_use] pub fn file_size(&self, lang: Lang, bytes: u64, style: FileSize) -> String { let (unit, n, decimals) = style.parts(bytes); if unit == SizeUnit::Byte && !style.byte_symbol { @@ -171,6 +178,7 @@ impl I18n { /// `value` with `decimals` digits after the decimal separator in the unit template `unit`, an /// English catalog key with the number as `{n}` (`{n} px`, `{n} dB`), the number as /// [`I18n::format`] writes it. Percentages are [`crate::Format::percent`]. + #[must_use] pub fn measure(&self, lang: Lang, value: f64, decimals: usize, unit: &str) -> String { self.unit_text(lang, unit, &self.format().number(value, decimals)) } From 271a2a7296be4b9ba4a0f7b6e13a09fb5377d83f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Legrand?= Date: Sun, 1 Nov 2026 22:08:57 +0100 Subject: [PATCH 034/382] style: remove review churn --- crates/i18n/src/collate.rs | 2 -- crates/i18n/src/fold.rs | 8 -------- crates/i18n/src/format.rs | 4 ---- crates/i18n/src/lib.rs | 6 ------ crates/i18n/src/region.rs | 3 --- crates/i18n/src/scripts.rs | 6 ------ crates/i18n/src/size.rs | 3 --- 7 files changed, 32 deletions(-) diff --git a/crates/i18n/src/collate.rs b/crates/i18n/src/collate.rs index 629b3bf75..06d417897 100644 --- a/crates/i18n/src/collate.rs +++ b/crates/i18n/src/collate.rs @@ -30,7 +30,6 @@ impl Collator { /// Sorting for `locale`, a language code such as `sv`, `pt-br` or `zh-hant` (any case, `-` /// or `_`, glibc forms such as `sv_SE.UTF-8` and `sr_RS@latin`). A BCP 47 collation type /// picks another order where there is one: `zh-hant-u-co-pinyin`, `zh-hans-u-co-stroke`. - #[must_use] pub fn new(locale: &str) -> Collator { let mut prefs: CollatorPreferences = Locale::try_from_str(&bcp47(locale)).unwrap_or(Locale::UNKNOWN).into(); prefs.numeric_ordering = Some(CollationNumericOrdering::True); @@ -47,7 +46,6 @@ impl Collator { /// the collation counts as equal (`Layer 2` and `Layer 02`) is in code point order, so a sort /// doesn't depend on the input order. Without collation data (never with the embedded data) /// this is code point order. - #[must_use] pub fn compare(&self, a: &str, b: &str) -> Ordering { match &self.0 { Some(c) => c.as_borrowed().compare(a, b).then_with(|| a.cmp(b)), diff --git a/crates/i18n/src/fold.rs b/crates/i18n/src/fold.rs index dd77b6dfd..fb420e1e1 100644 --- a/crates/i18n/src/fold.rs +++ b/crates/i18n/src/fold.rs @@ -34,7 +34,6 @@ pub struct Folder { impl Folder { /// Case- and accent-insensitive folding for `locale`, a language code such as `tr`, `pt-br` /// or `zh-hant` (any case, `-` or `_`). - #[must_use] pub fn new(locale: &str) -> Folder { let language = locale.split(['-', '_', '.', '@']).next().unwrap_or_default(); Folder { turkic: language.eq_ignore_ascii_case("tr") || language.eq_ignore_ascii_case("az"), accents: false } @@ -42,13 +41,11 @@ impl Folder { /// Accents count: `é` no longer matches `e`, and a match can't end on a letter whose accent it /// leaves out. - #[must_use] pub fn keep_accents(self) -> Folder { Folder { accents: true, ..self } } /// `s` folded, with the map back to `s`. - #[must_use] pub fn fold(&self, s: &str) -> Folded { let nfkd = DecomposingNormalizerBorrowed::new_nfkd(); let extend = CodePointSetData::new::(); @@ -78,13 +75,11 @@ impl Folder { } /// `s` folded, without the map: a key to compare or store. - #[must_use] pub fn key(&self, s: &str) -> String { self.fold(s).text } /// Whether `haystack` contains `needle`, both folded. - #[must_use] pub fn contains(&self, haystack: &str, needle: &str) -> bool { self.fold(haystack).find(&self.fold(needle)).is_some() } @@ -224,7 +219,6 @@ pub struct Folded { impl Folded { /// The folded text. - #[must_use] pub fn as_str(&self) -> &str { &self.text } @@ -232,7 +226,6 @@ impl Folded { /// The source byte range that folded bytes `range` came from, widened to whole source /// characters with their accents: `ss` in the folding of `Straße` maps back to `ß`, `e` in /// that of `é` to the whole `é`. An empty range maps to an empty one. - #[must_use] pub fn source_range(&self, range: Range) -> Range { // The last cluster starting at or before `at` is the one holding it: clusters that fold to // nothing share their offset with the next one. @@ -248,7 +241,6 @@ impl Folded { /// The first match of `needle` (folded the same way), as a byte range of the source text. /// An empty needle matches at the start. - #[must_use] pub fn find(&self, needle: &Folded) -> Option> { self.matches(needle).next() } diff --git a/crates/i18n/src/format.rs b/crates/i18n/src/format.rs index badfbdfca..b907b469c 100644 --- a/crates/i18n/src/format.rs +++ b/crates/i18n/src/format.rs @@ -82,7 +82,6 @@ impl Format { } /// The format for a locale tag (`de-CH`, `ar-EG`), with the locale's own digits. - #[must_use] pub fn from_tag(tag: &str) -> Format { Format::new(&Region::from_tag(tag), Digits::Locale) } @@ -94,7 +93,6 @@ impl Format { /// `value` rounded to `decimals` digits after the decimal separator; infinities and NaN are /// `∞`, `-∞` and `NaN`. - #[must_use] pub fn number(&self, value: f64, decimals: usize) -> String { match to_decimal(value, decimals) { Some(d) => self.write(&d), @@ -104,7 +102,6 @@ impl Format { /// [`Self::number`] without grouping separators, for values such as pixel sizes and years: /// `1920`, `١٩٢٠`, `1234,5`. - #[must_use] pub fn number_ungrouped(&self, value: f64, decimals: usize) -> String { match to_decimal(value, decimals) { Some(d) => { @@ -117,7 +114,6 @@ impl Format { /// `ratio` as a percentage with `decimals` digits after the decimal separator: `0.5` is /// `50%`, `50 %` (French, German), `%50` (Turkish), `٥٠٪؜` (Egyptian Arabic). - #[must_use] pub fn percent(&self, ratio: f64, decimals: usize) -> String { let Some(d) = to_decimal(ratio * 100.0, decimals) else { return format!("{}{}{}", self.percent.0, non_finite(ratio), self.percent.1); diff --git a/crates/i18n/src/lib.rs b/crates/i18n/src/lib.rs index ce473d84f..24ce578a6 100644 --- a/crates/i18n/src/lib.rs +++ b/crates/i18n/src/lib.rs @@ -158,7 +158,6 @@ impl I18n { /// to left, say). Locales that can't be used are skipped and come back as problems for the app /// to log. A locale's bad rows are logged (`log::warn!`) when it is first looked up in, and /// [`I18n::check_all`] lists them all. - #[must_use] pub fn new(embedded: &'static Embedded, offered: &[&str]) -> (I18n, Vec) { let mut problems = Vec::new(); let mut locales = vec![bare("en"), bare("pseudo")]; @@ -420,7 +419,6 @@ impl I18n { /// value that already is one isolate keeps it; pass numbers, paths and codes through [`ltr`]. /// Other text gets no marks, and a value's own isolate is taken off. Unknown placeholders stay as written, /// and inserted values are never read as templates, so a file name containing `{n}` stays intact. -#[must_use] pub fn fmt(template: &str, args: &[(&str, &str)]) -> String { fill(template, args, true) } @@ -428,7 +426,6 @@ pub fn fmt(template: &str, args: &[(&str, &str)]) -> String { /// [`fmt`] without isolates, for text that goes where the marks would get in the way: file /// names, logs, terminals, text compared or parsed later. Every isolate mark is taken off, in /// the template and in the values. -#[must_use] pub fn fmt_plain(template: &str, args: &[(&str, &str)]) -> String { strip_isolates(&fill(template, args, false)) } @@ -449,7 +446,6 @@ const ALM: char = '\u{061C}'; /// `value` as a first-strong isolate (FSI…PDI): it takes the direction of its first strong /// letter and can't reorder the text around it. What [`fmt`] does to each value in text with a /// right-to-left letter. -#[must_use] pub fn isolate(value: &str) -> String { wrap(FSI, value) } @@ -458,14 +454,12 @@ pub fn isolate(value: &str) -> String { /// codes, which read left to right in every language. In an RTL first-strong isolate, the /// segments of `/home/مستخدم/file.txt` would run right to left. [`fmt`] takes the isolate off /// again in text with no right-to-left letter. -#[must_use] pub fn ltr(value: &str) -> String { wrap(LRI, value) } /// `text` without isolate marks (LRI, RLI, FSI, PDI): a [`fmt`] or [`I18n::trn`] result made fit /// for a file name, a log or a comparison. -#[must_use] pub fn strip_isolates(text: &str) -> String { text.chars().filter(|c| !matches!(*c, LRI | RLI | FSI | PDI)).collect() } diff --git a/crates/i18n/src/region.rs b/crates/i18n/src/region.rs index 205444c25..15874d67f 100644 --- a/crates/i18n/src/region.rs +++ b/crates/i18n/src/region.rs @@ -73,7 +73,6 @@ impl Region { /// `nu` stays in the number and time locales (`ar-EG-u-nu-latn`). `C` and `POSIX` are the C /// locale: English, A4, metric, a `.` decimal and no grouping. An empty or unreadable tag is /// `en-US`; a bare `en` is the United States, any other bare language has no territory. - #[must_use] pub fn from_tag(tag: &str) -> Region { match Tag::parse(tag) { Some(tag) => Region::from_parts(&tag), @@ -86,7 +85,6 @@ impl Region { /// The region for an app's saved region setting: `""` or `auto` (any case) is /// [`Region::system`], anything else a locale tag for [`Region::from_tag`]. - #[must_use] pub fn from_setting(setting: &str) -> Region { let setting = setting.trim(); if setting.is_empty() || setting.eq_ignore_ascii_case("auto") { Region::system() } else { Region::from_tag(setting) } @@ -101,7 +99,6 @@ impl Region { /// - Linux and the BSDs: `LC_ALL`, else each of `LC_NUMERIC`, `LC_TIME`, `LC_MEASUREMENT` and /// `LC_PAPER` on its own, else `LANG`. /// - The web and Android: the preferred language, the only locale they expose. - #[must_use] pub fn system() -> Region { static SYSTEM: OnceLock = OnceLock::new(); SYSTEM.get_or_init(read_system).clone() diff --git a/crates/i18n/src/scripts.rs b/crates/i18n/src/scripts.rs index e16342e26..aa39d8917 100644 --- a/crates/i18n/src/scripts.rs +++ b/crates/i18n/src/scripts.rs @@ -39,7 +39,6 @@ pub enum Script { impl Script { /// The ISO 15924 code, `Latn`. - #[must_use] pub fn code(self) -> &'static str { match self { Script::Arab => "Arab", @@ -76,7 +75,6 @@ impl Script { } /// Whether text in this script runs right to left. - #[must_use] pub fn rtl(self) -> bool { matches!(self, Script::Arab | Script::Hebr | Script::Syrc | Script::Thaa) } @@ -114,7 +112,6 @@ pub enum Han { /// where it is the language's own script. A language not in the table is taken to be written in /// Latin. // ponytail: the languages a Craft app ships or could plausibly ship; add a row with the locale. -#[must_use] pub fn scripts(tag: &str) -> &'static [Script] { use Script::{ Arab, Armn, Beng, Cyrl, Deva, Ethi, Geor, Grek, Gujr, Guru, Hang, Hani, Hebr, Hira, Kana, Khmr, Knda, Laoo, Latn, Mlym, Mymr, Orya, Sinh, @@ -160,7 +157,6 @@ pub fn scripts(tag: &str) -> &'static [Script] { } /// The direction of a language tag's text: right to left when its main script is. -#[must_use] pub fn direction(tag: &str) -> Direction { match scripts(tag).first() { Some(s) if s.rtl() => Direction::Rtl, @@ -172,7 +168,6 @@ pub fn direction(tag: &str) -> Direction { /// P3): the contents of isolates (LRI, RLI or FSI up to the matching PDI) are skipped, and the /// search stops at the first paragraph separator. `None` when the paragraph has no strong /// character; P3 then reads it as left to right, and an app may use the interface direction. -#[must_use] pub fn base_direction(text: &str) -> Option { match unicode_bidi::get_base_direction(text) { unicode_bidi::Direction::Ltr => Some(Direction::Ltr), @@ -186,7 +181,6 @@ pub fn base_direction(text: &str) -> Option { /// (`zh-US`, `zh-AU`) → Traditional; `zh-HK`, `zh-MO`, `zh-Hant-HK` and `yue` → `HongKong`; `ja` → /// Japanese; `ko` → Korean. `None` for a language not written with Han, which leaves the choice /// to the font stack. -#[must_use] pub fn han(tag: &str) -> Option { let tag = Subtags::parse(tag); let hong_kong = matches!(tag.region.as_deref(), Some("hk" | "mo")); diff --git a/crates/i18n/src/size.rs b/crates/i18n/src/size.rs index b316360a5..e0d45d59d 100644 --- a/crates/i18n/src/size.rs +++ b/crates/i18n/src/size.rs @@ -33,7 +33,6 @@ impl SizeUnit { /// // `12 MB`, `3.4 MB`, `640 KB`: decimal steps, whole kilobytes, no decimals from 10 MB. /// let style = FileSize::DECIMAL.smallest(SizeUnit::Kilo).largest(SizeUnit::Mega).unit_decimals(SizeUnit::Kilo, 0).whole_from(10); /// ``` -#[must_use] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct FileSize { step: u64, @@ -166,7 +165,6 @@ impl FileSize { impl I18n { /// `bytes` as a file size in `lang`, written the way `style` says (`1.5 MB`, `512 bytes`), the /// number as [`I18n::format`] writes it (`1,5 Mo`). - #[must_use] pub fn file_size(&self, lang: Lang, bytes: u64, style: FileSize) -> String { let (unit, n, decimals) = style.parts(bytes); if unit == SizeUnit::Byte && !style.byte_symbol { @@ -178,7 +176,6 @@ impl I18n { /// `value` with `decimals` digits after the decimal separator in the unit template `unit`, an /// English catalog key with the number as `{n}` (`{n} px`, `{n} dB`), the number as /// [`I18n::format`] writes it. Percentages are [`crate::Format::percent`]. - #[must_use] pub fn measure(&self, lang: Lang, value: f64, decimals: usize, unit: &str) -> String { self.unit_text(lang, unit, &self.format().number(value, decimals)) } From abceed3f17c3a17de5680c5bd8d14666804e22f7 Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Sat, 14 Nov 2026 11:56:51 -0500 Subject: [PATCH 035/382] craft-xlsx: binary formulas keep typed spacing and Excel's number spelling Checked against a wider Excel probe (every worksheet function Excel accepts, operators, references, constants, spacing, shared and array formulas), three differences from the .xlsx text are fixed: - PtgAttrSpace: the spaces and line breaks typed in a formula are kept where Excel writes them in .xlsx (before an operand, an operator's symbol or a call, after a parenthesis's or call's opening and before its closing), and the text is trimmed as the .xlsx reader trims it. - Numbers are written out in full when that takes at most 21 characters (100000000000000000000, 0.0000000000000000001), scientific past that (1E+21, 1.5E-19, 1.23456789012345E-06), as Excel spells them. - ISO.CEILING, ECMA.CEILING, NETWORKDAYS.INTL and WORKDAY.INTL are called through hidden _xlfn. names in .xlsb, but .xlsx names them bare. --- crates/xlsx/README.md | 4 +- crates/xlsx/src/xlsb/expr.rs | 64 +++++++++++---- crates/xlsx/src/xlsb/formula.rs | 133 +++++++++++++++++++++++++++++--- crates/xlsx/tests/xlsb.rs | 77 ++++++++++++++++++ 4 files changed, 249 insertions(+), 29 deletions(-) diff --git a/crates/xlsx/README.md b/crates/xlsx/README.md index 1dc30574d..e03128e81 100644 --- a/crates/xlsx/README.md +++ b/crates/xlsx/README.md @@ -85,7 +85,9 @@ they were. A binary workbook is not written. A binary workbook gives the same `Workbook`, strings, rows and merged cells. Its styles are not read (each cell keeps its format index). Its cell formulas are decoded from their tokens into the -text an `.xlsx` file holds (`_xlfn.` and `_xlpm.` names as written, no implicit `@`), with +text an `.xlsx` file holds (`_xlfn.` and `_xlpm.` names as written, apart from the four +ISO/IEC 29500 functions `.xlsx` names bare, no implicit `@`, the spaces and line breaks typed in +the formula, numbers as Excel spells them), with `FormulaKind::Shared` or `FormulaKind::Array` and their ranges, and `BrtCellMeta` as the cell metadata index. Every cell of a shared formula gets its own text, decoded at the cell, since the file keeps the tokens once. A formula whose decoding needs something the reader does not read diff --git a/crates/xlsx/src/xlsb/expr.rs b/crates/xlsx/src/xlsb/expr.rs index 3dd643a6a..197644a33 100644 --- a/crates/xlsx/src/xlsb/expr.rs +++ b/crates/xlsx/src/xlsb/expr.rs @@ -120,6 +120,9 @@ pub(crate) enum Expr { Ref(Reference), /// A defined name. Name(String), + /// Spaces and line breaks typed before and after an expression (`PtgAttrSpace`), which + /// `.xlsx` formula text keeps. + Spaced(String, Box, String), Unary(UnOp, Box), Binary(BinOp, Box, Box), Call(String, Vec), @@ -195,23 +198,33 @@ fn sci_text(n: f64, sig: usize) -> String { format!("{}E{}{:02}", mant, if e < 0 { '-' } else { '+' }, e.abs()) } -/// A number as a formula spells it: up to 15 significant digits, scientific for very large or -/// very small magnitudes. +/// A number as Excel spells it in a formula: rounded to 15 significant digits, written out in +/// full (`100000000000000000000`, `0.0000000000000000001`) when that takes at most 21 characters +/// without the sign, and scientific (`1E+21`, `1.5E-19`, `1.23456789012345E-06`) when it would +/// take more. pub(crate) fn number_to_text(n: f64) -> String { if n == 0.0 || !n.is_finite() { return "0".into(); } - let a = n.abs(); - if !(1e-9..1e15).contains(&a) && a.round() != a || a >= 1e15 { + let s = format!("{:.14e}", n.abs()); + let Some((mant, exp)) = s.split_once('e') else { return s }; + let Ok(e) = exp.parse::() else { return s }; + let digits: String = mant.chars().filter(char::is_ascii_digit).collect(); + let digits = digits.trim_end_matches('0'); + let digits = if digits.is_empty() { "0" } else { digits }; + let k = digits.len() as i32; + let plain_len = if e >= 0 { (e + 1).max(k + i32::from(k > e + 1)) } else { 1 - e + k }; + if plain_len > 21 { return sci_text(n, 15); } - // A value just below 1e15 can round up to 1e15 at 15 significant digits. - if format!("{a:.14e}").parse::().is_ok_and(|r| r >= 1e15) { - return sci_text(n, 15); - } - let mag = a.log10().floor() as i32; - let decimals = (14 - mag).clamp(0, 30) as usize; - trim_decimal(&format!("{n:.decimals$}")) + let sign = if n < 0.0 { "-" } else { "" }; + let plain = if e >= 0 { + let int = (e + 1) as usize; + if digits.len() <= int { format!("{digits}{}", "0".repeat(int - digits.len())) } else { format!("{}.{}", &digits[..int], &digits[int..]) } + } else { + format!("0.{}{digits}", "0".repeat((-e - 1) as usize)) + }; + format!("{sign}{plain}") } fn number(n: f64) -> String { @@ -248,11 +261,14 @@ fn sheet_split(n: &str) -> Option<(&str, &str)> { at.and_then(|i| Some((n.get(..i)?, n.get(i + 1..)?))) } -/// Prints an expression in A1 notation. +/// Prints an expression in A1 notation, trimmed as the `.xlsx` reader trims formula text. pub(crate) fn print(e: &Expr) -> String { let mut s = String::new(); write_expr(&mut s, e); - s + match s.trim() { + t if t.len() == s.len() => s, + t => t.to_string(), + } } fn write_args(s: &mut String, args: &[Expr], sep: char) { @@ -323,6 +339,11 @@ fn write_expr(s: &mut String, e: &Expr) { write_expr(s, x); s.push(')'); } + Expr::Spaced(before, x, after) => { + s.push_str(before); + write_expr(s, x); + s.push_str(after); + } } } @@ -336,10 +357,21 @@ mod tests { assert_eq!(number_to_text(-2.5), "-2.5"); assert_eq!(number_to_text(0.1 + 0.2), "0.3"); assert_eq!(number_to_text(123456789012345.0), "123456789012345"); - assert_eq!(number_to_text(1e15), "1E+15"); - assert_eq!(number_to_text(1234567890123456.0), "1.23456789012346E+15"); + // Written out in full up to 21 characters, as Excel writes them in .xlsx. + assert_eq!(number_to_text(1e15), "1000000000000000"); + assert_eq!(number_to_text(1234567890123456.0), "1234567890123460"); + assert_eq!(number_to_text(-1e20), "-100000000000000000000"); + assert_eq!(number_to_text(1e21), "1E+21"); + assert_eq!(number_to_text(1.5e21), "1.5E+21"); assert_eq!(number_to_text(0.0001), "0.0001"); - assert_eq!(number_to_text(1e-10), "1E-10"); + assert_eq!(number_to_text(1e-10), "0.0000000001"); + assert_eq!(number_to_text(1e-19), "0.0000000000000000001"); + assert_eq!(number_to_text(1e-20), "1E-20"); + assert_eq!(number_to_text(1.5e-19), "1.5E-19"); + assert_eq!(number_to_text(1.23456789012345e-5), "0.0000123456789012345"); + assert_eq!(number_to_text(1.23456789012345e-6), "1.23456789012345E-06"); + assert_eq!(number_to_text(1234567890.12345), "1234567890.12345"); + assert_eq!(number_to_text(1e100), "1E+100"); assert!(number(f64::MAX).parse::().is_ok_and(f64::is_finite)); } } diff --git a/crates/xlsx/src/xlsb/formula.rs b/crates/xlsx/src/xlsb/formula.rs index 327ffcc25..22355b630 100644 --- a/crates/xlsx/src/xlsb/formula.rs +++ b/crates/xlsx/src/xlsb/formula.rs @@ -46,9 +46,10 @@ fn pop_n(stack: &mut Stack, n: usize, kids: &mut usize) -> Result, Uns Ok(popped.into_iter().map(|(e, _)| e).collect()) } -/// Pushes the result of a token one level above the operands it consumed. +/// Pushes the result of a token one level above the operands it consumed (two for one with the +/// spacing typed around it, which prints as a level of its own). fn push(stack: &mut Stack, kids: usize, e: Expr) -> Result<(), Unsupported> { - let depth = kids.saturating_add(1); + let depth = kids.saturating_add(1).saturating_add(usize::from(matches!(e, Expr::Spaced(..)))); if depth > MAX_DEPTH { return Err(Unsupported("formula nested too deeply")); } @@ -56,6 +57,48 @@ fn push(stack: &mut Stack, kids: usize, e: Expr) -> Result<(), Unsupported> { Ok(()) } +/// Spaces and line breaks typed in the formula (`PtgAttrSpace`, [MS-XLSB] 2.5.98.32), waiting +/// for the token they belong to. Excel writes the attribute just before that token: spaces +/// before an operand, an operator's symbol or a function call go in `before`; those before a +/// parenthesis's `(`, or before the `)` of a parenthesis or a call, in `open` and `close`. +#[derive(Default)] +struct Spacing { + before: String, + open: String, + close: String, +} + +/// `e` with `ws` typed before it. +fn spaced_before(e: Expr, ws: String) -> Expr { + match e { + _ if ws.is_empty() => e, + Expr::Spaced(b, x, a) => Expr::Spaced(ws + &b, x, a), + e => Expr::Spaced(ws, Box::new(e), String::new()), + } +} + +/// `e` with `ws` typed after it. +fn spaced_after(e: Expr, ws: String) -> Expr { + match e { + _ if ws.is_empty() => e, + Expr::Spaced(b, x, a) => Expr::Spaced(b, x, a + &ws), + e => Expr::Spaced(String::new(), Box::new(e), ws), + } +} + +/// A call's arguments with the spacing typed before its `)`: after the last argument, or alone +/// between the parentheses (`PI( )`). +fn close_args(mut args: Vec, ws: String) -> Vec { + if ws.is_empty() { + return args; + } + match args.pop() { + Some(last) => args.push(spaced_after(last, ws)), + None => args.push(Expr::Spaced(String::new(), Box::new(Expr::Missing), ws)), + } + args +} + /// An error constant's code ([MS-XLSB] 2.5.98.21, `BErr`). fn error_code(code: u8) -> Option { Some(match code { @@ -261,11 +304,16 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res let mut t = Bytes { b: rgce, pos: 0 }; let mut extra = Bytes { b: rgcb, pos: 0 }; let mut stack: Stack = Vec::new(); + let mut ws = Spacing::default(); while t.pos < rgce.len() { let ptg = t.u8()?; let mut kids = 0usize; // Operand classes (reference / value / array) share one token number. let id = if ptg & 0x60 != 0 { 0x20 | (ptg & 0x1F) } else { ptg }; + // An operand (a constant, reference or name) takes the spacing typed before it; operators, + // calls and parentheses place theirs below, and attribute and cache tokens take none. + let operand = !matches!(id, 0x03..=0x15 | 0x19 | 0x21 | 0x22 | 0x26..=0x29); + let height = stack.len(); match id { 0x03..=0x11 => { let op = match id { @@ -287,6 +335,10 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res }; let b = pop(&mut stack, &mut kids)?; let a = pop(&mut stack, &mut kids)?; + // Spacing before the operator's symbol follows the left operand. + let before = std::mem::take(&mut ws.before); + kids = kids.saturating_add(usize::from(!before.is_empty())); + let a = spaced_after(a, before); push(&mut stack, kids, Expr::Binary(op, Box::new(a), Box::new(b)))?; } 0x12..=0x14 => { @@ -296,11 +348,23 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res _ => UnOp::Percent, }; let x = pop(&mut stack, &mut kids)?; - push(&mut stack, kids, Expr::Unary(op, Box::new(x)))?; + // A sign's spacing comes before it; `%`'s before its symbol, after the operand. + let before = std::mem::take(&mut ws.before); + let e = if op == UnOp::Percent { + kids = kids.saturating_add(usize::from(!before.is_empty())); + Expr::Unary(op, Box::new(spaced_after(x, before))) + } else { + spaced_before(Expr::Unary(op, Box::new(x)), before) + }; + push(&mut stack, kids, e)?; } 0x15 => { let x = pop(&mut stack, &mut kids)?; - push(&mut stack, kids, Expr::Paren(Box::new(x)))?; + let close = std::mem::take(&mut ws.close); + kids = kids.saturating_add(usize::from(!close.is_empty())); + let x = spaced_after(x, close); + let before = std::mem::take(&mut ws.open) + &std::mem::take(&mut ws.before); + push(&mut stack, kids, spaced_before(Expr::Paren(Box::new(x)), before))?; } 0x16 => push(&mut stack, kids, Expr::Missing)?, // PtgStr: cch (u16, at most 255) and always UTF-16, unlike BIFF8. @@ -318,14 +382,27 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res let n = usize::from(t.u16()?) + 1; t.take(n * 2)?; } else { - t.take(2)?; + let data = t.take(2)?; + if kind & 0x40 != 0 { + // PtgAttrSpace / PtgAttrSpaceSemi: PtgAttrSpaceType's `type` and `cch`. + let (kind, n) = (data.first().copied().unwrap_or(0), data.get(1).copied().unwrap_or(0)); + let text = if matches!(kind, 1 | 3 | 5) { "\n" } else { " " }.repeat(usize::from(n)); + match kind { + 0 | 1 | 6 => ws.before.push_str(&text), + 2 | 3 => ws.open.push_str(&text), + 4 | 5 => ws.close.push_str(&text), + _ => return Err(Unsupported("unknown spacing in a formula")), + } + } } if kind & 0x10 != 0 { // PtgAttrSum: SUM of the single operand. let x = pop(&mut stack, &mut kids)?; - push(&mut stack, kids, Expr::Call("SUM".into(), vec![x]))?; + let args = close_args(vec![x], std::mem::take(&mut ws.close)); + let call = spaced_before(Expr::Call("SUM".into(), args), std::mem::take(&mut ws.before)); + push(&mut stack, kids.saturating_add(1), call)?; } - // Semi (volatile), If, Goto, Space, Baxcel: no effect on the expression. + // Semi (volatile), If, Goto, Baxcel: no effect on the expression. } 0x1C => { let e = t.u8()?; @@ -346,8 +423,9 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res let iftab = t.u16()?; let (name, args) = function(iftab).ok_or(Unsupported("unknown function"))?; let n = usize::try_from(args).map_err(|_| Unsupported("unknown function argument count"))?; - let args = pop_n(&mut stack, n, &mut kids)?; - push(&mut stack, kids, Expr::Call(name.to_string(), args))?; + let args = close_args(pop_n(&mut stack, n, &mut kids)?, std::mem::take(&mut ws.close)); + let call = spaced_before(Expr::Call(name.to_string(), args), std::mem::take(&mut ws.before)); + push(&mut stack, kids.saturating_add(1), call)?; } 0x22 => { let n = usize::from(t.u8()?); @@ -362,20 +440,33 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res if args.is_empty() { return Err(Unsupported("malformed function call")); } - let name = match args.remove(0) { + // Spacing typed after the `(` comes before the name's token: it belongs to the + // first argument. + let (lead, first) = match args.remove(0) { + Expr::Spaced(before, x, _) => (before, *x), + e => (String::new(), e), + }; + let name = match first { Expr::Name(n) => n, _ => return Err(Unsupported("function call through an expression")), }; + if let Some(a) = args.first_mut() { + *a = spaced_before(std::mem::replace(a, Expr::Missing), lead); + } // `PY(index, …)` runs a script stored elsewhere in the package, which this // import doesn't read. `PY("code", …)` carries its code and becomes a Python cell. let py = name.rsplit('.').next().is_some_and(|n| n.eq_ignore_ascii_case("PY")); if py && !args.first().is_some_and(literal_text) { return Err(Unsupported("Python code stored outside the cell")); } - push(&mut stack, kids, Expr::Call(name, args))?; + let args = close_args(args, std::mem::take(&mut ws.close)); + let call = spaced_before(Expr::Call(bare_function(name), args), std::mem::take(&mut ws.before)); + push(&mut stack, kids.saturating_add(1), call)?; } else { let (name, _) = function(tab & 0x7FFF).ok_or(Unsupported("unknown function"))?; - push(&mut stack, kids, Expr::Call(name.to_string(), args))?; + let args = close_args(args, std::mem::take(&mut ws.close)); + let call = spaced_before(Expr::Call(name.to_string(), args), std::mem::take(&mut ws.before)); + push(&mut stack, kids.saturating_add(1), call)?; } } 0x23 => { @@ -456,6 +547,10 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res } _ => return Err(Unsupported("unknown formula token")), } + if operand && !ws.before.is_empty() && stack.len() == height + 1 { + let (e, depth) = stack.pop().ok_or(Unsupported("malformed formula (operand missing)"))?; + push(&mut stack, depth, spaced_before(e, std::mem::take(&mut ws.before)))?; + } if stack.len() > MAX_RGCE { return Err(Unsupported("formula too complex")); } @@ -467,11 +562,23 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res Ok(grouped(e, false)) } +/// The name a function called through a hidden name is written with in `.xlsx`: that name +/// (`_xlfn.CONCAT`), except for the four ISO/IEC 29500 functions, which `.xlsx` names without the +/// prefix though `.xlsb` calls them as it calls newer functions. +fn bare_function(name: String) -> String { + const ISO: [&str; 4] = ["ISO.CEILING", "ECMA.CEILING", "NETWORKDAYS.INTL", "WORKDAY.INTL"]; + match name.get(..6).filter(|p| p.eq_ignore_ascii_case("_xlfn.")).and(name.get(6..)) { + Some(bare) if ISO.iter().any(|f| f.eq_ignore_ascii_case(bare)) => bare.to_string(), + _ => name, + } +} + /// Text written out in the formula: a string, or strings joined with `&` (how Python code /// longer than a string constant is written). fn literal_text(e: &Expr) -> bool { match e { Expr::Text(_) => true, + Expr::Spaced(_, x, _) => literal_text(x), Expr::Binary(BinOp::Concat, a, b) => literal_text(a) && literal_text(b), _ => false, } @@ -494,6 +601,7 @@ fn binding(e: &Expr) -> u8 { Expr::Binary(op, ..) => op.precedence(), Expr::Unary(UnOp::Neg | UnOp::Plus, _) => 60, Expr::Unary(UnOp::Percent, _) => 70, + Expr::Spaced(_, x, _) => binding(x), _ => u8::MAX, } } @@ -550,6 +658,7 @@ fn grouped(e: Expr, in_args: bool) -> Expr { Expr::Unary(op, Box::new(if needs { paren(x) } else { x })) } Expr::Paren(x) => paren(grouped(*x, false)), + Expr::Spaced(before, x, after) => Expr::Spaced(before, Box::new(grouped(*x, in_args)), after), Expr::Call(name, args) => Expr::Call(name, args.into_iter().map(|a| grouped(a, true)).collect()), other => other, } diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index ee9ac3afd..1be653c87 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -930,3 +930,80 @@ fn a_dynamic_array_kept_as_its_value_has_no_cell_metadata() { assert_eq!(sheet.cell_metadata.iter().collect::>(), [(&at("C1"), &1)]); assert!(warned(&wb, "missing from the file"), "{:?}", wb.warnings); } + +/// `PtgAttrSpace` ([MS-XLSB] 2.5.98.31): its type (0 spaces before the next token, 1 line breaks +/// before it, 2 spaces before a `(`, 4 spaces before a `)`) and count. +fn space(kind: u8, n: u8) -> Vec { + vec![0x19, 0x40, kind, n] +} + +#[test] +fn typed_spacing_numbers_and_iso_functions_read_as_in_xlsx() { + let a1 = || [&[0x24u8][..], &loc(0, REL)].concat(); + let b1 = || [&[0x24u8][..], &loc(0, 1 | REL)].concat(); + let num = |n: f64| [&[0x1Fu8][..], &n.to_le_bytes()].concat(); + let area = |c: u16| [&[0x25u8][..], &0u32.to_le_bytes(), &1u32.to_le_bytes(), &(c | REL).to_le_bytes(), &(c | REL).to_le_bytes()].concat(); + let goto = [0x19u8, 0x08, 0, 0]; + let cells: Vec> = vec![ + // Spacing goes before the next token: an operand, or an operator's symbol. + [&[0x1Eu8, 1, 0][..], &space(0, 2), &[0x1E, 2, 0], &space(0, 1), &[0x03]].concat(), + // ... or a call's `)`, and inside a call's parentheses. + [space(0, 1), a1(), space(0, 1), b1(), space(4, 1), vec![0x42, 2, 4, 0]].concat(), + // Line breaks. + [ + a1(), + vec![0x1E, 0, 0, 0x0D, 0x19, 0x02, 0, 0], + space(1, 1), + space(0, 2), + vec![0x1E, 1, 0], + goto.to_vec(), + space(1, 1), + space(0, 2), + vec![0x1E, 2, 0], + goto.to_vec(), + vec![0x42, 3, 1, 0], + ] + .concat(), + // Inside and before parentheses. + [space(0, 1), vec![0x1E, 1, 0], space(0, 1), vec![0x1E, 2, 0], space(0, 1), vec![0x03], space(4, 1), vec![0x15]].concat(), + [vec![0x1E, 1, 0, 0x1E, 2, 0], space(2, 1), vec![0x15, 0x03]].concat(), + // A call with no arguments, and one through PtgAttrSum. + [space(4, 1), vec![0x41, 19, 0]].concat(), + [area(0), area(1), space(0, 1), vec![0x0F, 0x19, 0x10, 0, 0]].concat(), + // A sign, `%`, and leading spacing (trimmed, as `.xlsx` text is read). + [space(0, 1), vec![0x1E, 1, 0, 0x13], space(0, 1), vec![0x14]].concat(), + [space(0, 3), a1()].concat(), + // A newer function: spacing before its name's token is the first argument's. + [vec![0x1E, 1, 0], space(0, 1), vec![0x23, 5, 0, 0, 0], num(1.5), space(0, 1), vec![0x42, 2, 0xFF, 0, 0x03]].concat(), + vec![0x23, 1, 0, 0, 0, 0x17, 1, 0, b'a', 0, 0x42, 2, 0xFF, 0], + // Numbers written out up to 21 characters, scientific past them. + [num(1e20), num(1e21), vec![0x03], num(1e-19), vec![0x03], num(1.5e-19), vec![0x03], num(1234567890123456.0), vec![0x03]].concat(), + ]; + let mut data = row(0); + for (i, rgce) in cells.iter().enumerate() { + data.extend(formula_cell(i as u32 + 1, rgce, &[])); + } + // Name 5: the hidden name ISO.CEILING is called through, as Excel writes it. + let mut book = book_with_links(&xti()); + let end = record(132, &[]); + book.truncate(book.len() - end.len()); + book.extend(name(0x0002_000b, "_xlfn.ISO.CEILING")); + book.extend(end); + let wb = read(&package(&book, &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + let got: Vec<_> = (1..=cells.len() as u32).map(|c| wb.sheets[0].formula(CellRef::new(0, c))).collect(); + let want = [ + "1 + 2", + "SUM( A1, B1 )", + "IF(A1>0,\n 1,\n 2)", + "( 1 + 2 )", + "1+ (2)", + "PI( )", + "SUM(A1:A2 B1:B2)", + "- 1 %", + "A1", + "1+ ISO.CEILING( 1.5)", + "_xlfn.CONCAT(\"a\")", + "100000000000000000000+1E+21+0.0000000000000000001+1.5E-19+1234567890123460", + ]; + assert_eq!(got, want.map(Some)); +} From 5742279729a6a9cd0118ccf4cee4b99314e7bb56 Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Sat, 14 Nov 2026 12:01:46 -0500 Subject: [PATCH 036/382] craft-xlsx: binary formulas name macro sheets and span chart sheets An Excel probe showed two references the decoder refused that .xlsx spells: - A reference to an XLM macro sheet (Macro1!$A$1): macro sheets have cells, so the sheet links now name them. - A 3-D span with a chart sheet between its ends ('Data:After Sheet'!$A$1): a span is spelled by its ends, as .xlsx has it. An end with no cells is still refused. --- crates/xlsx/src/xlsb.rs | 5 +++-- crates/xlsx/src/xlsb/formula.rs | 13 +++++-------- crates/xlsx/tests/xlsb.rs | 28 ++++++++++++++++++++++++++++ 3 files changed, 36 insertions(+), 10 deletions(-) diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index 2fdde59be..65aab0eb8 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -351,9 +351,10 @@ pub(crate) fn workbook( if let SheetKind::Other(_) = kind { return Err(invalid("unknown sheet relationship type")); } - // Only a worksheet has cells a formula can refer to. + // Only worksheets and macro sheets have cells a formula can refer to (a macro's + // name refers to its macro sheet: `Macro1!$A$1`). if let Some(l) = links.as_mut() { - l.sheets.push((kind == SheetKind::Worksheet).then(|| name.clone())); + l.sheets.push(matches!(kind, SheetKind::Worksheet | SheetKind::Macrosheet).then(|| name.clone())); } wb.sheets.push(SheetEntry { name, sheet_id, visibility, rel_id, kind, part: Some(rel.target.clone()) }); } diff --git a/crates/xlsx/src/xlsb/formula.rs b/crates/xlsx/src/xlsb/formula.rs index 22355b630..3a6960b39 100644 --- a/crates/xlsx/src/xlsb/formula.rs +++ b/crates/xlsx/src/xlsb/formula.rs @@ -147,8 +147,8 @@ pub(super) struct Name { /// Workbook-level tables formulas refer to. #[derive(Default)] pub(crate) struct Links { - /// Every sheet's name in `BrtBundleSh` order, `None` for sheets the reader skips or that hold - /// no cells (chart, dialog and macro sheets). + /// Every sheet's name in `BrtBundleSh` order, `None` for the sheets that hold no cells (chart, + /// dialog and module sheets). pub(super) sheets: Vec>, /// Every `BrtName`, in order: `PtgName` indexes them from 1. pub(super) names: Vec, @@ -179,14 +179,11 @@ impl Links { let (Ok(first), Ok(last)) = (usize::try_from(x.first), usize::try_from(x.last)) else { return Err(Unsupported("reference to a missing sheet")); }; - // A span takes every sheet between its ends, so a skipped one anywhere in it changes - // what the reference means. + // A span is spelled by its ends. A sheet between them with no cells (a chart sheet) adds + // nothing to it, and `.xlsx` spells the span the same; an end with no cells can't be named. let span = self.sheets.get(first..=last).filter(|s| !s.is_empty()).ok_or(Unsupported("reference to a missing sheet"))?; - if span.iter().any(Option::is_none) { - return Err(Unsupported("references to sheets the reader skips")); - } let (Some(Some(a)), Some(Some(b))) = (span.first(), span.last()) else { - return Err(Unsupported("reference to a missing sheet")); + return Err(Unsupported("references to sheets with no cells")); }; Ok(Some(if first == last { SheetSel::Named(a.clone()) } else { SheetSel::Span(a.clone(), b.clone()) })) } diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index 1be653c87..950dc8847 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -1007,3 +1007,31 @@ fn typed_spacing_numbers_and_iso_functions_read_as_in_xlsx() { ]; assert_eq!(got, want.map(Some)); } + +#[test] +fn references_to_macro_sheets_and_spans_over_chart_sheets_are_named() { + // Sheets Data, a chart sheet, an XLM macro sheet, Hidden; sheet links Macro1, Data:Hidden + // (over the chart sheet) and Chart1 (no cells). + let mut book = record(131, &[]); + book.extend(record(153, &[[0u8; 8].as_slice(), &wide("")].concat())); + book.extend(record(143, &[])); + for (id, rel, name) in [(1u32, "one", "Data"), (3, "c", "Chart1"), (4, "m", "Macro1"), (2, "two", "Hidden")] { + book.extend(record(156, &[&0u32.to_le_bytes()[..], &id.to_le_bytes(), &wide(rel), &wide(name)].concat())); + } + book.extend(record(144, &[])); + let mut xti = 3u32.to_le_bytes().to_vec(); + for (first, last) in [(2i32, 2i32), (0, 3), (1, 1)] { + xti.extend([0u32.to_le_bytes(), first.to_le_bytes(), last.to_le_bytes()].concat()); + } + book.extend([record(353, &[]), record(357, &[]), record(362, &xti), record(354, &[]), record(132, &[])].concat()); + let rels = RELS.replace( + "", + r#""#, + ); + let ref3d = |ixti: u16| [&[0x5Au8][..], &ixti.to_le_bytes(), &loc(0, 0)].concat(); + let data = [row(0), formula_cell(1, &ref3d(0), &[]), formula_cell(2, &ref3d(1), &[]), formula_cell(3, &ref3d(2), &[])].concat(); + let wb = read(&package(&book, &worksheet(&data, &[]), &sst(), ROOT, &rels, TYPES)).unwrap(); + let got: Vec<_> = (1..=3).map(|c| wb.sheets[0].formula(CellRef::new(0, c))).collect(); + assert_eq!(got, [Some("Macro1!$A$1"), Some("Data:Hidden!$A$1"), None]); + assert!(warned(&wb, "references to sheets with no cells"), "{:?}", wb.warnings); +} From 1a4e11926ce8fe6851f881537798299bd629dcb4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Legrand?= Date: Sat, 14 Nov 2026 17:11:58 +0100 Subject: [PATCH 037/382] refactor(dwg): apply behavior-preserving cleanups --- crates/dwg/src/lib.rs | 79 ++++++++++++++++++++++++++++++------------- 1 file changed, 55 insertions(+), 24 deletions(-) diff --git a/crates/dwg/src/lib.rs b/crates/dwg/src/lib.rs index 2db7afeae..de42828c7 100644 --- a/crates/dwg/src/lib.rs +++ b/crates/dwg/src/lib.rs @@ -57,6 +57,10 @@ impl Limits { /// A byte count in megabytes for messages ("9.9 MB", "1024 MB"). #[cfg_attr(no_dwg_bridge, allow(dead_code))] +#[expect( + clippy::cast_precision_loss, + reason = "Megabyte formatting is rounded for display; exact integer precision beyond 2^53 bytes is not meaningful." +)] fn mb(n: u64) -> String { let m = n as f64 / f64::from(1u32 << 20); if m >= 100.0 { format!("{m:.0} MB") } else { format!("{m:.1} MB") } @@ -71,12 +75,17 @@ mod proxy_transport; #[cfg(not(no_dwg_bridge))] mod native { + use std::fmt::Write as _; use std::io::{Cursor, Write}; use std::panic::AssertUnwindSafe; use super::{Limits, mb}; /// Read DWG bytes and return an ASCII DXF rendition, within [`Limits::DEFAULT`]. + /// + /// # Errors + /// + /// Returns an error when the DWG cannot be read or post-processed, or its DXF rendition exceeds the default limits. pub fn dwg_to_dxf(bytes: &[u8]) -> Result, String> { dwg_to_dxf_with(bytes, Limits::DEFAULT) } @@ -84,6 +93,10 @@ mod native { /// [`dwg_to_dxf`] with explicit limits. Both are checked before the expensive step they /// guard: the input size before the DWG reader runs, the DXF size while it is written, so a /// runaway conversion stops at the limit instead of filling memory first. + /// + /// # Errors + /// + /// Returns an error when the input exceeds `limits`, decoding fails, or the DXF output exceeds `limits`. pub fn dwg_to_dxf_with(bytes: &[u8], limits: Limits) -> Result, String> { dwg_to_dxf_noted(bytes, limits).map(|(dxf, _)| dxf) } @@ -92,6 +105,10 @@ mod native { /// failsafe mode: an object record it can't decode is skipped instead of failing the whole /// file, and the notes say how many were skipped and of which types, so a partial read never /// passes for a complete one. + /// + /// # Errors + /// + /// Returns an error when the input exceeds `limits`, decoding fails, or the DXF output exceeds `limits`. pub fn dwg_to_dxf_noted(bytes: &[u8], limits: Limits) -> Result<(Vec, Vec), String> { if bytes.len() > limits.max_dwg_bytes { return Err(format!( @@ -114,13 +131,13 @@ mod native { let mut notes = read_notes(&outcome.stats); let mut doc = outcome.document; notes.extend( - guarded(AssertUnwindSafe(|| application_objects(&mut doc))).map_err(|_| "the DWG application object conversion failed".to_string())?, + guarded(AssertUnwindSafe(|| application_objects(&mut doc))).map_err(|()| "the DWG application object conversion failed".to_string())?, ); // After application_objects, so the proxy objects it makes are numbered as the DXF's. notes.extend( - guarded(AssertUnwindSafe(|| super::proxy_transport::prepare(&mut doc))).map_err(|_| "the DWG proxy conversion failed".to_string())?, + guarded(AssertUnwindSafe(|| super::proxy_transport::prepare(&mut doc))).map_err(|()| "the DWG proxy conversion failed".to_string())?, ); - let orphans = guarded(AssertUnwindSafe(|| post_process(&mut doc))).map_err(|_| "the DWG post-processing failed on this file".to_string())?; + let orphans = guarded(AssertUnwindSafe(|| post_process(&mut doc))).map_err(|()| "the DWG post-processing failed on this file".to_string())?; if orphans > 0 { let (s, were) = if orphans == 1 { ("", "was") } else { ("s", "were") }; notes.push(format!("DWG: {orphans} DGN line style component{s} that no line style definition uses {were} left out")); @@ -624,7 +641,7 @@ mod native { // A real table has at most one merge per cell; more ranges than that come from a // damaged file and would only make this rows × cols × ranges. let max_ranges = rows.saturating_mul(cols).min(1 << 16); - for r in t.merged_ranges.iter().take(max_ranges).cloned().collect::>() { + for r in t.merged_ranges.iter().take(max_ranges).copied().collect::>() { // Clamp to the table: the ranges come from the file. let (bottom, right) = (r.bottom_row.min(rows.saturating_sub(1)), r.right_col.min(cols.saturating_sub(1))); if r.top_row > bottom || r.left_col > right || rows == 0 || cols == 0 || (r.top_row, r.left_col) == (bottom, right) { @@ -707,8 +724,8 @@ mod native { } /// Leave out DGN line style components (`LS*COMPONENT`) that no line style definition uses - /// (#1482). A drawing that once came from MicroStation can carry hundreds of thousands of - /// them, orphaned copies piled up by earlier DGN imports and copy-pastes (AutoCAD's PURGE + /// (#1482). A drawing that once came from `MicroStation` can carry hundreds of thousands of + /// them, orphaned copies piled up by earlier DGN imports and copy-pastes (`AutoCAD`'s PURGE /// removes them as orphaned data): in a real 83 MB site plan they were 888,483 of 889,053 /// components and made its DXF rendition 1.2 GB, over [`Limits::DEFAULT`], so the file /// didn't open at all. No definition that was read refers to them (a definition the reader @@ -838,7 +855,7 @@ mod native { for (name, code, value) in unwritten_header_vars(h) { let written = section.windows(name.len() + 2).any(|w| w.starts_with(name.as_bytes()) && w.ends_with(b"\r\n")); if !written && value.parse::().is_ok_and(f64::is_finite) { - add.push_str(&format!(" 9\r\n{name}\r\n{code:>3}\r\n{value}\r\n")); + let _ = write!(add, " 9\r\n{name}\r\n{code:>3}\r\n{value}\r\n"); } } dxf.splice(end..end, add.into_bytes()); @@ -870,14 +887,22 @@ mod native { /// Oldest DWG version written; older DXF input is written as this version. const MIN_DWG_VERSION: acadrust::DxfVersion = acadrust::DxfVersion::AC1018; - /// Convert DXF bytes into a DWG file of the DXF's version, and at least AutoCAD 2004 + /// Convert DXF bytes into a DWG file of the DXF's version, and at least `AutoCAD` 2004 /// (AC1018). + /// + /// # Errors + /// + /// Returns an error when the DXF cannot be decoded or the DWG cannot be written, including oversized input. pub fn dxf_to_dwg(dxf: &[u8]) -> Result, String> { convert(dxf, None, None).map(|(dwg, _)| dwg) } /// Convert DXF bytes into a DWG file of `version`, a code from [`super::VERSIONS`] ("AC1032"), /// whatever version the DXF declares. + /// + /// # Errors + /// + /// Returns an error for an unsupported version, invalid DXF, oversized input, or a DWG write failure. pub fn dxf_to_dwg_as(dxf: &[u8], version: &str) -> Result, String> { dxf_to_dwg_noted(dxf, version).map(|(dwg, _)| dwg) } @@ -1003,7 +1028,7 @@ mod native { /// The current dimension style (`$DIMSTYLE`) by its name: the DXF gives the name, and the /// handle read with it needn't be the style's in the document, in which case the DWG writer - /// fell back to Standard and AutoCAD opened the drawing with Standard current (#1051). + /// fell back to Standard and `AutoCAD` opened the drawing with Standard current (#1051). fn current_dimstyle(doc: &mut acadrust::CadDocument) { let name = doc.header.current_dimstyle_name.clone(); if let Some(h) = doc.dim_styles.iter().find(|ds| ds.name.eq_ignore_ascii_case(&name)).map(|ds| ds.handle) { @@ -1013,7 +1038,7 @@ mod native { /// The current text style (`$TEXTSTYLE`) by its name, the same way as [`current_dimstyle`]: /// the handle read with the DXF needn't be the style's in the document, in which case the DWG - /// writer fell back to Standard and AutoCAD opened the drawing with Standard current (#1650). + /// writer fell back to Standard and `AutoCAD` opened the drawing with Standard current (#1650). fn current_text_style(doc: &mut acadrust::CadDocument) { let name = doc.header.current_text_style_name.clone(); if let Some(h) = doc.text_styles.iter().find(|ts| ts.name.eq_ignore_ascii_case(&name)).map(|ts| ts.handle) { @@ -1203,7 +1228,7 @@ mod native { }; let (classes, source) = guarded(AssertUnwindSafe(|| (dxf_class_names(&data), super::proxy_transport::source_classes(&data)))) .map_err(|_| "the DXF proxy class conversion failed".to_string())?; - let mut doc = std::panic::catch_unwind(move || acadrust::DxfReader::from_reader(Cursor::new(data)).and_then(|r| r.read())) + let mut doc = std::panic::catch_unwind(move || acadrust::DxfReader::from_reader(Cursor::new(data)).and_then(acadrust::DxfReader::read)) .map_err(|_| "the DXF→DWG conversion failed".to_string())? .map_err(|e| format!("DXF: {e}"))?; match version { @@ -1242,14 +1267,14 @@ mod native { current_layer(&mut doc); unwritten })) - .map_err(|_| "the DXF to DWG conversion failed on this file".to_string())?; + .map_err(|()| "the DXF to DWG conversion failed on this file".to_string())?; let dwg = std::panic::catch_unwind(AssertUnwindSafe(|| acadrust::DwgWriter::write_to_vec(&doc))) .map_err(|_| "the DWG writer failed on this drawing".to_string())? .map_err(|e| format!("DWG write: {e}"))?; Ok((dwg, unwritten)) } - /// AutoCAD's entry name for the drawing variables dictionary (the DXF Reference calls it the + /// `AutoCAD`'s entry name for the drawing variables dictionary (the DXF Reference calls it the /// ACDBVARIABLEDICTIONARY; dictionary keys are case-insensitive). const VARIABLE_DICTIONARY: &str = "AcDbVariableDictionary"; @@ -1265,11 +1290,11 @@ mod native { if valid.contains(&value) { value.to_string() } else { default.to_string() } } - /// Add the drawing variables dictionary AutoCAD always writes into the named object + /// Add the drawing variables dictionary `AutoCAD` always writes into the named object /// dictionary, with the variables it keeps there, when the drawing has none (#1813). /// Vectric Aspire 10.5 reads a 2004 (AC1018) DWG without it as empty ("No data was imported /// from the DXF / DWG file"), though it reads the same drawing as DXF — which has no such - /// dictionary either, as CADCraft's and ezdxf's writers don't make one. AutoCAD's AC1032 DWGs + /// dictionary either, as CADCraft's and ezdxf's writers don't make one. `AutoCAD`'s AC1032 DWGs /// read there without it, so newer output is left as it was, and a dictionary the drawing /// does have keeps its own entries and values. fn add_variable_dictionary(doc: &mut acadrust::CadDocument) { @@ -1318,7 +1343,7 @@ mod native { /// Entities of a layout other than the one in `*Paper_Space` are written owned by their block /// (entity mode 0, with its handle). acadrust writes every paper-space entity with mode 1, - /// "paper space", which AutoCAD reads as the `*Paper_Space` block's: everything drawn on a + /// "paper space", which `AutoCAD` reads as the `*Paper_Space` block's: everything drawn on a /// second layout landed on the first one, and the second stayed empty (#1057). fn other_layout_owners(doc: &mut acadrust::CadDocument) { let others: std::collections::HashSet = doc @@ -1541,11 +1566,11 @@ thread_local! { /// Panics when a test asked for `stage` to fail (see [`PANIC_IN`]); does nothing otherwise. #[cfg(not(no_dwg_bridge))] #[allow(clippy::panic)] -fn fail_in_test(_stage: &str) { +fn fail_in_test(stage: &str) { + #[cfg(not(test))] + let _ = stage; #[cfg(test)] - if PANIC_IN.with(|p| p.get()) == Some(_stage) { - panic!("test-forced panic in {_stage}"); - } + assert!(PANIC_IN.with(std::cell::Cell::get) != Some(stage), "test-forced panic in {stage}"); } /// The error for a DWG version this writer can't create. @@ -1623,6 +1648,8 @@ pub fn dxf_to_dwg_kept_noted(_dxf: &[u8], _version: &str, _kept: &str) -> Result #[cfg(test)] mod tests { + use std::fmt::Write as _; + use super::*; /// The DXF of an empty drawing, enough for the bridge to make a small DWG. @@ -1716,9 +1743,9 @@ mod tests { let mut s = String::from(" 0\nSECTION\n 2\nHEADER\n 9\n$ACADVER\n 1\nAC1032\n 0\nENDSEC\n 0\nSECTION\n 2\nENTITIES\n"); for (text, flags, sub, pts) in dims { s += " 0\nDIMENSION\n 8\n0\n100\nAcDbEntity\n100\nAcDbDimension\n 10\n0\n 20\n0\n 30\n0\n"; - s += &format!(" 11\n50\n 21\n-20\n 31\n0\n 70\n{flags}\n 1\n{text}\n 3\nStandard\n100\n{sub}\n"); - for (code, [x, y]) in pts.iter() { - s += &format!("{code:>3}\n{x}\n{:>3}\n{y}\n{:>3}\n0\n", code + 10, code + 20); + let _ = write!(s, " 11\n50\n 21\n-20\n 31\n0\n 70\n{flags}\n 1\n{text}\n 3\nStandard\n100\n{sub}\n"); + for (code, [x, y]) in *pts { + let _ = write!(s, "{code:>3}\n{x}\n{:>3}\n{y}\n{:>3}\n0\n", code + 10, code + 20); } } s + " 0\nENDSEC\n 0\nEOF\n" @@ -1787,13 +1814,17 @@ mod tests { .collect() } - /// Issue #1482: a DWG that once came from MicroStation can carry hundreds of thousands of DGN + /// Issue #1482: a DWG that once came from `MicroStation` can carry hundreds of thousands of DGN /// line style components no definition uses (a real 83 MB site plan: 888,483 of 889,053, a /// 1.2 GB DXF rendition over the limit, so it didn't open). They're left out with a note, and /// their dictionary entries with them; the definition and every component it reaches — /// through compound and point components, around a cycle — are kept. #[cfg(not(no_dwg_bridge))] #[test] + #[expect( + clippy::too_many_lines, + reason = "This integration test builds and verifies one complete DGN component graph; splitting the fixture would obscure reachability." + )] fn orphaned_dgn_line_style_components_are_left_out() { use acadrust::objects::*; let mut doc = acadrust::CadDocument::new(); From fa5457bed643d167816d9d188c3b1fc4ebd68d2e Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Sat, 14 Nov 2026 12:35:54 -0500 Subject: [PATCH 038/382] craft-xlsx: review fixes: array constants bounded per formula, a spent allowance skips decoding - A formula's array constants share one allowance of 65,536 values, each array charged before its rows are allocated. Before, the cap was per array, so a formula of many arrays could hold gigabytes before the formula text allowance was checked. - Once binary_formula_text is spent, a formula is not decoded only to be dropped: it keeps its saved result straight away. --- crates/xlsx/README.md | 5 +++-- crates/xlsx/src/xlsb.rs | 5 +++++ crates/xlsx/src/xlsb/formula.rs | 15 ++++++++++----- crates/xlsx/tests/xlsb.rs | 27 +++++++++++++++++++++++++++ 4 files changed, 45 insertions(+), 7 deletions(-) diff --git a/crates/xlsx/README.md b/crates/xlsx/README.md index e03128e81..b8669288e 100644 --- a/crates/xlsx/README.md +++ b/crates/xlsx/README.md @@ -104,8 +104,9 @@ other workbooks, Python code stored outside the cell, data tables. The XLSB func (40 million records, 4 million cells and as many shared strings, 256 MiB of text, as `craft-xls` allows). `binary_formula_text`: decoded formula text over the workbook (128 MiB); past it, formulas keep their saved results. A formula's tokens are bounded at 16 KB, its - nesting at 256 levels and an array constant at 65,536 values. Fixed caps: 1024 sheets, 100,000 merged ranges per sheet, 64 nested - extension blocks. + nesting at 256 levels and its array constants at 65,536 values in all, each charged before + it is held; once the formula text allowance is spent, no formula is decoded. Fixed caps: 1024 + sheets, 100,000 merged ranges per sheet, 64 nested extension blocks. - Cells and rows outside the 1,048,576 × 16,384 grid are dropped and counted. SpreadsheetML is read leniently: a damaged optional part is a warning, a damaged worksheet keeps diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index 65aab0eb8..ea37f59ca 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -523,6 +523,11 @@ fn decode_formula( warnings: &mut Warnings, ) -> Option { let links = links?; + // Once the allowance is spent no formula fits it, so none is decoded only to be dropped. + if !budget.formula_text_fits(1, limits) { + kept(warnings, "more formula text than the limits allow"); + return None; + } let text = match formula::decode(rgce, rgcb, links, mode) { Ok(e) => expr::print(&e), Err(formula::Unsupported(why)) => { diff --git a/crates/xlsx/src/xlsb/formula.rs b/crates/xlsx/src/xlsb/formula.rs index 3a6960b39..b62072ad2 100644 --- a/crates/xlsx/src/xlsb/formula.rs +++ b/crates/xlsx/src/xlsb/formula.rs @@ -18,7 +18,8 @@ use super::ftab::function; /// Formula token bytes decoded at most (a cell formula holds at most 16,384). pub(super) const MAX_RGCE: usize = 16 * 1024; -/// Values in one array constant at most. +/// Values in one formula's array constants at most, all of them together: each array is charged +/// before its values are held, so a formula of many arrays can't hold more than this. const MAX_ARRAY: usize = 65_536; /// Why a formula could not be turned back into text. @@ -301,6 +302,7 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res let mut t = Bytes { b: rgce, pos: 0 }; let mut extra = Bytes { b: rgcb, pos: 0 }; let mut stack: Stack = Vec::new(); + let mut array_values = MAX_ARRAY; let mut ws = Spacing::default(); while t.pos < rgce.len() { let ptg = t.u8()?; @@ -414,7 +416,7 @@ pub(super) fn decode(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode) -> Res 0x20 => { // PtgArray: 14 unused bytes (Excel leaves junk in them); the values are in rgcb. t.take(14)?; - push(&mut stack, kids, array_constant(&mut extra)?)?; + push(&mut stack, kids, array_constant(&mut extra, &mut array_values)?)?; } 0x21 => { let iftab = t.u16()?; @@ -663,12 +665,15 @@ fn grouped(e: Expr, in_args: bool) -> Expr { /// PtgExtraArray ([MS-XLSB] 2.5.98.41): row and column counts, then `SerAr` values in row-major /// order. The type codes are not BIFF8's: 0x00 is a number here, not a missing value. -fn array_constant(b: &mut Bytes<'_>) -> Result { +fn array_constant(b: &mut Bytes<'_>, left: &mut usize) -> Result { let rows = usize::try_from(b.u32()?).map_err(|_| TRUNC)?; let cols = usize::try_from(b.u32()?).map_err(|_| TRUNC)?; - if rows == 0 || cols == 0 || rows.saturating_mul(cols) > MAX_ARRAY { - return Err(Unsupported("array constant too large or empty")); + let values = rows.saturating_mul(cols); + if values == 0 { + return Err(Unsupported("empty array constant")); } + // Charged before the rows are allocated, against what the formula's arrays may hold in all. + *left = left.checked_sub(values).ok_or(Unsupported("array constants too large"))?; let mut out = Vec::with_capacity(rows); for _ in 0..rows { let mut row = Vec::with_capacity(cols); diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index 950dc8847..94bb51ba6 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -1035,3 +1035,30 @@ fn references_to_macro_sheets_and_spans_over_chart_sheets_are_named() { assert_eq!(got, [Some("Macro1!$A$1"), Some("Data:Hidden!$A$1"), None]); assert!(warned(&wb, "references to sheets with no cells"), "{:?}", wb.warnings); } + +#[test] +fn a_formulas_array_constants_share_one_allowance() { + // Two arrays of 40,000 Boolean values, each within what one array may hold, added together: + // charged before their values are held, together they pass what a formula's arrays may hold + // (65,536 values), so the cell keeps its saved result. One of them alone decodes. + let array = |n: u32| [&n.to_le_bytes()[..], &1u32.to_le_bytes(), &[2u8, 1].repeat(n as usize)].concat(); + let ptg = [&[0x60u8][..], &[0; 14]].concat(); + let two = [&ptg[..], &ptg, &[0x03]].concat(); + let data = [row(0), formula_cell(0, &two, &[array(40_000), array(40_000)].concat()), formula_cell(1, &ptg, &array(40_000))].concat(); + let wb = read(&package(&book_with_links(&xti()), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), None); + assert_eq!(wb.sheets[0].value(CellRef::new(0, 0)), Value::Number(0.0)); + assert!(wb.sheets[0].formula(CellRef::new(0, 1)).is_some_and(|f| f.starts_with("{TRUE;TRUE"))); + assert!(warned(&wb, "array constants too large"), "{:?}", wb.warnings); +} + +#[test] +fn a_spent_formula_allowance_skips_decoding() { + // With no allowance, a formula is not decoded at all: an unknown token is never reached. + let data = [row(0), formula_cell(0, &[0xFF], &[])].concat(); + let limits = Limits { binary_formula_text: 0, ..Limits::default() }; + let wb = read_with(&package(&book_with_links(&xti()), &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES), &limits).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), None); + assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); + assert!(!warned(&wb, "unknown formula token"), "{:?}", wb.warnings); +} From 88287a6b46e4b7a5e8fab18d07c6ca71791803e9 Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Sat, 14 Nov 2026 12:40:55 -0500 Subject: [PATCH 039/382] craft-xlsx: review fixes: styles caps are too large, differential format strings are charged - A styles table past 65,536 entries, or a gradient past 1,024 stops, is past a fixed cap: Error::TooLarge, as the error's contract and the other caps have it, not a damaged part that is skipped with a warning. - A differential format's font name and number format are charged to binary_text, as the other string-bearing style records are. --- crates/xlsx/README.md | 31 ++++++++++++++++--------------- crates/xlsx/src/xlsb/styles.rs | 15 +++++++++++---- crates/xlsx/tests/xlsb.rs | 18 ++++++++++++++---- 3 files changed, 41 insertions(+), 23 deletions(-) diff --git a/crates/xlsx/README.md b/crates/xlsx/README.md index 088e82e3e..9d8e1b785 100644 --- a/crates/xlsx/README.md +++ b/crates/xlsx/README.md @@ -83,21 +83,22 @@ for new pictures (`vm = i + 1`) and the `XLDAPR` dynamic-array metadata (`cm = 1 The parts this crate writes use the transitional namespaces; a strict file's kept parts stay as they were. A binary workbook is not written. -A binary workbook gives the same `Workbook`, strings, rows and merged cells, and the same -`Styles`: number formats, fonts, fills, borders, cell and cell style formats, cell styles, -differential formats and the indexed colours, as Excel writes them in `styles.xml` (default fill -colours and empty settings left out, a cell style format's `apply*="0"`, a number format with a -newer locale tag in its Excel 2007 spelling, as `formatCode` has it). Custom table styles and -recent colours are not read; a damaged styles part is a warning and no styles. Its cell formulas -are decoded from their tokens into the text an `.xlsx` file holds (`_xlfn.` and `_xlpm.` names as -written, apart from the four ISO/IEC 29500 functions `.xlsx` names bare, no implicit `@`, the -spaces and line breaks typed in the formula, numbers as Excel spells them), with -`FormulaKind::Shared` or `FormulaKind::Array` and their ranges, and `BrtCellMeta` as the cell -metadata index. Every cell of a shared formula gets its own text, decoded at the cell, since the -file keeps the tokens once. A formula whose decoding needs something the reader does not read -keeps only its saved result, with a warning saying why: user defined names, table references, -other workbooks, Python code stored outside the cell, data tables. The XLSB function table -(`xlsb/ftab.rs`) and the expression printer are this crate's own, apart from `craft-xls`'s. +A binary workbook gives the same `Workbook`, strings, rows and merged cells, and the same `Styles`: +number formats, fonts, fills, borders, cell and cell style formats, cell styles, differential +formats and the indexed colours, as Excel writes them in `styles.xml` (default fill colours and +empty settings left out, a cell style format's `apply*="0"`, a number format with a newer locale tag +in its Excel 2007 spelling, as `formatCode` has it). Custom table styles and recent colours are not +read; a damaged styles part is a warning and no styles, while one past a cap (65,536 entries in a +table, 1,024 gradient stops) or past `binary_text` is too large. Its cell formulas are decoded from +their tokens into the text an `.xlsx` file holds (`_xlfn.` and `_xlpm.` names as written, apart from +the four ISO/IEC 29500 functions `.xlsx` names bare, no implicit `@`, the spaces and line breaks +typed in the formula, numbers as Excel spells them), with `FormulaKind::Shared` or +`FormulaKind::Array` and their ranges, and `BrtCellMeta` as the cell metadata index. Every cell of a +shared formula gets its own text, decoded at the cell, since the file keeps the tokens once. A +formula whose decoding needs something the reader does not read keeps only its saved result, with a +warning saying why: user defined names, table references, other workbooks, Python code stored +outside the cell, data tables. The XLSB function table (`xlsb/ftab.rs`) and the expression printer +are this crate's own, apart from `craft-xls`'s. ## Hostile input diff --git a/crates/xlsx/src/xlsb/styles.rs b/crates/xlsx/src/xlsb/styles.rs index 50673ef28..88c6bee51 100644 --- a/crates/xlsx/src/xlsb/styles.rs +++ b/crates/xlsx/src/xlsb/styles.rs @@ -176,7 +176,7 @@ fn fill(b: &mut Bytes<'_>) -> Result { let count = b.u32()?; if fls == 0x28 { if count > MAX_STOPS { - return Err(invalid("too many gradient stops")); + return Err(Error::TooLarge(format!("more than {MAX_STOPS} gradient stops"))); } for _ in 0..count { let c = color(b)?.unwrap_or_default(); @@ -330,7 +330,7 @@ fn dxf(b: &mut Bytes<'_>) -> Result { 0x04 => { let g = gradient_fill.as_mut().ok_or_else(|| invalid("gradient stop without a gradient"))?; if g.stops.len() >= MAX_STOPS as usize { - return Err(invalid("too many gradient stops")); + return Err(Error::TooLarge(format!("more than {MAX_STOPS} gradient stops"))); } p.u16()?; let position = p.f64()?; @@ -418,7 +418,7 @@ pub(crate) fn styles(bytes: &[u8], limits: &Limits, budget: &Budget, warnings: & _ => 0, }; if entries >= MAX_ENTRIES { - return Err(invalid(format!("more than {MAX_ENTRIES} entries in a styles table"))); + return Err(Error::TooLarge(format!("more than {MAX_ENTRIES} entries in a styles table"))); } match id { 279 => { @@ -451,7 +451,14 @@ pub(crate) fn styles(bytes: &[u8], limits: &Limits, budget: &Budget, warnings: & budget.text(c.name.len(), limits)?; s.cell_styles.push(c); } - 507 => s.dxfs.push(dxf(&mut b)?), + 507 => { + let d = dxf(&mut b)?; + // What it keeps of its strings, after a later property has replaced an earlier. + let font = d.font.as_ref().and_then(|f| f.name.as_ref()).map_or(0, String::len); + let format = d.num_fmt.as_ref().and_then(|n| n.code.as_ref()).map_or(0, String::len); + budget.text(font + format, limits)?; + s.dxfs.push(d); + } // BrtBeginIndexedColors, BrtEndIndexedColors. 565 => palette = true, 566 => palette = false, diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index bd8b36176..b72705b9f 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -1196,11 +1196,11 @@ fn damaged_styles_are_a_warning_and_the_workbook_opens() { assert!(warnings.iter().any(|w| w.contains("look/styles.bin")), "{why}: {warnings:?}"); assert_eq!(read(&bytes).unwrap().sheets[0].value(CellRef::new(0, 0)), Value::Number(1.0), "{why}"); } - // A table past 65,536 entries is refused before it is held. + // A table past 65,536 entries is past a fixed cap: refused before it is held, as too large. let xfs = brt_xf(0, 0, 0, 0, 0, 0, 0, 0x1010, 0).repeat(65_537); - let (styles, warnings) = styles_of(&styled_file(&with(&[&begin(617, 65_537)[..], &xfs, &record(618, &[])].concat()), STYLES_TYPES)); - assert!(styles.is_none()); - assert!(warnings.iter().any(|w| w.contains("65536 entries")), "{warnings:?}"); + let bytes = styled_file(&with(&[&begin(617, 65_537)[..], &xfs, &record(618, &[])].concat()), STYLES_TYPES); + let mut p = Package::open(&bytes, &Limits::default()).unwrap(); + assert!(matches!(p.styles(), Err(Error::TooLarge(m)) if m.contains("65536 entries"))); // Custom table styles are not read, and say so. let table_styles = [body, &record(508, &[&1u32.to_le_bytes()[..], &wide("Probe Table"), &wide("")].concat()), &end].concat(); let (styles, warnings) = styles_of(&styled_file(&table_styles, STYLES_TYPES)); @@ -1339,3 +1339,13 @@ fn a_spent_formula_allowance_skips_decoding() { assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); assert!(!warned(&wb, "unknown formula token"), "{:?}", wb.warnings); } + +#[test] +fn differential_format_strings_are_charged_to_the_text_allowance() { + // A DXF's font name and number format are text the styles part keeps, charged like a font's. + let dxf = |name: &str| [record(278, &[]), begin(505, 1), brt_dxf(&[prop(0x18, &short(name))]), record(506, &[]), record(279, &[])].concat(); + let limits = Limits { binary_text: 100, ..Limits::default() }; + let open = |part: &[u8]| Package::open(&styled_file(part, STYLES_TYPES), &limits).unwrap().styles(); + assert!(open(&dxf("Arial")).is_ok_and(|s| s.is_some_and(|s| s.dxfs.len() == 1))); + assert!(matches!(open(&dxf(&"x".repeat(200))), Err(Error::TooLarge(_)))); +} From 4d8273712e80832c4dc36f8d91ca49271acefa9d Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 18:58:38 +0100 Subject: [PATCH 040/382] docx: count chart axis format characters like the model The reader counted UTF-8 bytes against 255 while the model keeps 128 characters, so a CJK axis format was written and then dropped on reading. Use MAX_FMT. Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/chart_spec.rs | 15 +++++++++++++++ crates/docx/src/read/chart/parse.rs | 2 +- crates/docx/src/read/chart/tests.rs | 8 ++++++-- 3 files changed, 22 insertions(+), 3 deletions(-) diff --git a/crates/docx/src/chart_spec.rs b/crates/docx/src/chart_spec.rs index 1950b15bf..167be6b0d 100644 --- a/crates/docx/src/chart_spec.rs +++ b/crates/docx/src/chart_spec.rs @@ -677,6 +677,21 @@ mod tests { assert_eq!(spec_of(&parse(&plain)), Some(plain)); } + #[test] + fn an_axis_format_is_limited_in_characters_not_bytes() { + use craft_wordmodel::chart::MAX_FMT; + let cjk = format!("0\"{}\"", "\u{5143}".repeat(90)); + let ascii = format!("0\"{}\"", "x".repeat(90)); + for fmt in [cjk, ascii] { + assert!(fmt.chars().count() <= MAX_FMT); + let mut spec = ChartSpec::sample(ChartType::Column); + spec.val_axis.fmt = Some(fmt.clone()); + let spec = spec.sanitized(); + assert_eq!(spec.val_axis.fmt.as_deref(), Some(fmt.as_str())); + assert_eq!(spec_of(&parse(&spec)).as_ref(), Some(&spec), "{} chars", fmt.chars().count()); + } + } + #[test] fn a_chart_with_more_than_the_model_stays_read_only() { let spec = ChartSpec::sample(ChartType::Column); diff --git a/crates/docx/src/read/chart/parse.rs b/crates/docx/src/read/chart/parse.rs index 45586509b..6b20879c6 100644 --- a/crates/docx/src/read/chart/parse.rs +++ b/crates/docx/src/read/chart/parse.rs @@ -311,7 +311,7 @@ pub(super) fn axis(a: Option<&El>) -> Axis { .child("c:numFmt") .filter(|f| f.attr("sourceLinked") != Some("1")) .and_then(|f| f.attr("formatCode")) - .filter(|f| f.len() <= MAX_FORMAT_CODE) + .filter(|f| f.chars().count() <= craft_wordmodel::chart::MAX_FMT) .map(str::to_string), title: a.child("c:title").and_then(title_text), labels: a.child("c:tickLblPos").and_then(|p| p.attr("val")) != Some("none"), diff --git a/crates/docx/src/read/chart/tests.rs b/crates/docx/src/read/chart/tests.rs index 6e8bcfd82..8b26f40c4 100644 --- a/crates/docx/src/read/chart/tests.rs +++ b/crates/docx/src/read/chart/tests.rs @@ -386,9 +386,13 @@ fn axis_format_code_length_is_capped() { let x = format!(r#""#); axis(Some(&crate::xml::parse(x.as_bytes()).unwrap())).fmt }; - let ok = format!("{}0", "x".repeat(254)); + use craft_wordmodel::chart::MAX_FMT; + // The limit is the model's, counted in characters (a CJK character is one). + let ok = format!("{}0", "x".repeat(MAX_FMT - 1)); assert_eq!(fmt(&ok), Some(ok.clone())); - assert_eq!(fmt(&format!("{}0", "x".repeat(300))), None); + let cjk = format!("{}0", "\u{5143}".repeat(MAX_FMT - 1)); + assert_eq!(fmt(&cjk), Some(cjk.clone())); + assert_eq!(fmt(&format!("{}0", "x".repeat(MAX_FMT))), None); } #[test] From e1cd8b5e01cd649d1527a8e9d5393f2563c79d94 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 18:58:38 +0100 Subject: [PATCH 041/382] docx: no_fill wins over a stored series colour Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/chart_spec.rs | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/crates/docx/src/chart_spec.rs b/crates/docx/src/chart_spec.rs index 167be6b0d..a090c5c96 100644 --- a/crates/docx/src/chart_spec.rs +++ b/crates/docx/src/chart_spec.rs @@ -282,13 +282,14 @@ fn series_props(w: &mut W, s: &ChartSeries) { } w.open("c:spPr", &[]); if fill_set { + // "No fill" wins over a stored colour, so the pair reads back as it was written. match &s.fill { - Some(c) => { + Some(c) if !s.no_fill => { w.open("a:solidFill", &[]); w.empty("a:srgbClr", &[("val", &c.hex())]); w.close("a:solidFill"); } - None => w.empty("a:noFill", &[]), + _ => w.empty("a:noFill", &[]), } } if ln_set { @@ -677,6 +678,18 @@ mod tests { assert_eq!(spec_of(&parse(&plain)), Some(plain)); } + #[test] + fn no_fill_wins_over_a_stored_colour() { + let mut spec = ChartSpec::sample(ChartType::Column); + spec.series[0].fill = Some(Rgb(255, 0, 0)); + spec.series[0].no_fill = true; + let x = chart_xml(&spec); + assert!(!x.contains("FF0000"), "colour written next to no_fill"); + let back = spec_of(&parse(&spec)).expect("stays editable"); + assert!(back.series[0].no_fill); + assert_eq!(back.series[0].fill, None); + } + #[test] fn an_axis_format_is_limited_in_characters_not_bytes() { use craft_wordmodel::chart::MAX_FMT; From ca3390ec17917d4d4d687233afbc208250d2e59f Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 18:58:38 +0100 Subject: [PATCH 042/382] wordmodel: ChartSpec::default uses the value-axis preset Co-Authored-By: Claude Sonnet 5.5 --- crates/wordmodel/src/chart.rs | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/crates/wordmodel/src/chart.rs b/crates/wordmodel/src/chart.rs index 4744d8b88..6c7296647 100644 --- a/crates/wordmodel/src/chart.rs +++ b/crates/wordmodel/src/chart.rs @@ -229,7 +229,7 @@ pub fn clean_fmt(s: &str) -> String { } /// A chart the app can edit. -#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)] +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct ChartSpec { #[serde(rename = "type")] @@ -255,6 +255,23 @@ pub struct ChartSpec { pub val_axis: ChartAxis, } +impl Default for ChartSpec { + /// An empty chart whose value axis is the one a new chart (and a missing JSON field) has: + /// gridlines on, no axis line. + fn default() -> Self { + ChartSpec { + kind: ChartType::default(), + categories: Vec::new(), + series: Vec::new(), + title: None, + legend: None, + data_labels: false, + cat_axis: ChartAxis::default(), + val_axis: value_axis(), + } + } +} + impl ChartSpec { /// A new chart of type `kind` with the app's sample data: four quarters and three series /// (one for pie and doughnut charts, x values for scatter charts), legend at the bottom. @@ -382,6 +399,14 @@ mod tests { assert_eq!(LegendPos::from_id("top"), Some(LegendPos::Top)); } + #[test] + fn default_and_missing_json_axis_fields_agree() { + let from_json: ChartSpec = serde_json::from_str(r#"{"type":"column"}"#).unwrap(); + let d = ChartSpec::default(); + assert_eq!((d.cat_axis.clone(), d.val_axis.clone()), (from_json.cat_axis, from_json.val_axis)); + assert!(d.val_axis.gridlines && !d.val_axis.line); + } + #[test] fn axis_bounds_and_formats_are_cleaned() { let mut a = ChartAxis { From 40d27e4ededfcb0eb85d0017b129575760721258 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 18:59:56 +0100 Subject: [PATCH 043/382] docx: bar category labels start after the axis title strip Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/read/chart/plot.rs | 11 +++++++---- crates/docx/src/read/chart/tests.rs | 24 ++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/crates/docx/src/read/chart/plot.rs b/crates/docx/src/read/chart/plot.rs index 09fe672d0..50108b8dc 100644 --- a/crates/docx/src/read/chart/plot.rs +++ b/crates/docx/src/read/chart/plot.rs @@ -142,6 +142,8 @@ impl Axes { /// The room around the plot for axis labels, and the category labels as they'll be drawn. struct Margins { left: f32, + /// Part of `left` taken by the rotated category-axis title (bars): the labels start after it. + title: f32, top: f32, bottom: f32, /// Category labels in lines (none for scatter charts or a deleted category axis). @@ -159,16 +161,17 @@ fn axis_margins(c: &Chart, ax: &Axes, area: Rect) -> Margins { let scatter = c.kind == Kind::Scatter; let (cat_on, val_on) = (!c.cat.deleted, !c.val.deleted); let (cat_labels, val_labels) = (cat_on && c.cat.labels, val_on && c.val.labels); + let title = title_left(c, cat_on, val_on, lh); let left = if c.horizontal { if cat_labels { widest(&c.cats, fs).min(area.w * 0.4) + GAP } else { 0.0 } } else if val_labels { ax.vticks.iter().map(|(_, s)| text_w(s, fs)).fold(0.0, f32::max) + GAP } else { 0.0 - } + title_left(c, cat_on, val_on, lh); + } + title; let band_w = (area.w - left).max(1.0) / c.n as f32; let wrapped: Vec> = if cat_labels && !scatter { - let width = if c.horizontal { left - GAP } else { band_w }; + let width = if c.horizontal { left - title - GAP } else { band_w }; c.cats.iter().map(|s| wrap(s, width, fs)).collect() } else { Vec::new() @@ -184,7 +187,7 @@ fn axis_margins(c: &Chart, ax: &Axes, area: Rect) -> Margins { 0.0 }) + title_bottom(c, cat_on, val_on, lh); let top = if !c.horizontal && val_labels { lh / 2.0 } else { 0.0 }; - Margins { left, top, bottom, wrapped, skip } + Margins { left, title, top, bottom, wrapped, skip } } /// Room for the vertical axis title on the plot's left: one line when the axis that sits there @@ -332,7 +335,7 @@ fn draw_category_labels(out: &mut Vec, c: &Chart, g: &Frame, xticks for (i, lines) in m.wrapped.iter().enumerate() { let top = g.band_start(i) + g.band() / 2.0 - lines.len() as f32 * lh / 2.0; for (k, s) in lines.iter().enumerate() { - text(out, Rect { x: area.x, y: top + k as f32 * lh, w: m.left - GAP, h: lh }, s, fs, TextAlign::Right, false); + text(out, Rect { x: area.x + m.title, y: top + k as f32 * lh, w: m.left - m.title - GAP, h: lh }, s, fs, TextAlign::Right, false); } } } else { diff --git a/crates/docx/src/read/chart/tests.rs b/crates/docx/src/read/chart/tests.rs index 8b26f40c4..528f46ee2 100644 --- a/crates/docx/src/read/chart/tests.rs +++ b/crates/docx/src/read/chart/tests.rs @@ -594,3 +594,27 @@ fn series_without_a_usable_c_idx_take_their_place() { let big = [renumbered(&a, &format!(r#""#, u32::MAX))]; assert_eq!(column_colours(&big).0.len(), 1); } + +#[test] +fn bar_category_labels_start_after_the_axis_title() { + let long = "A category label that is much too long for its column"; + let title = r#"Region"#; + let plot = format!( + r#"{}{title}"#, + ser(0, "S", Some("FF0000"), &[long, "Short"], &["4", "8"]), + ); + let items = chart_items(&space(&plot), &theme(), 300.0, 200.0); + let rect_of = |f: &dyn Fn(&str, &TextAlign) -> bool| -> Vec<[f32; 4]> { + items + .iter() + .filter_map(|it| if let GraphicItem::Text { rect, text, align, .. } = it { f(text, align).then_some(*rect) } else { None }) + .collect() + }; + let title_rect = rect_of(&|t, _| t == "Region"); + assert_eq!(title_rect.len(), 1); + let strip_end = title_rect[0][0] + title_rect[0][2]; + let labels = rect_of(&|t, a| matches!(a, TextAlign::Right) && t != "Region" && (long.contains(t) || t == "Short")); + assert!(!labels.is_empty()); + assert!(labels.iter().all(|r| r[0] >= strip_end - 1e-3), "labels {labels:?} overlap the title strip ending at {strip_end}"); + assert!(labels.iter().all(|r| r[2] <= 0.4 * 300.0), "{labels:?}"); +} From 0edccaf1bc46f21bc35cc3b40f85a5a13b5bbae7 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 18:59:56 +0100 Subject: [PATCH 044/382] docx: category gridlines follow line and area points when the axis crosses mid Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/read/chart/plot.rs | 21 ++++++++++------ crates/docx/src/read/chart/tests.rs | 38 +++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 7 deletions(-) diff --git a/crates/docx/src/read/chart/plot.rs b/crates/docx/src/read/chart/plot.rs index 50108b8dc..eae203546 100644 --- a/crates/docx/src/read/chart/plot.rs +++ b/crates/docx/src/read/chart/plot.rs @@ -220,7 +220,7 @@ pub(super) fn cartesian(out: &mut Vec, c: &Chart, area: Rect) { draw_grid(out, &g, &ax.vticks); } if c.cat.grid { - draw_cat_grid(out, &g, &ax.xticks, c.kind == Kind::Scatter); + draw_cat_grid(out, &g, &ax.xticks, c.kind); } let mut labels = Vec::new(); match c.kind { @@ -274,11 +274,12 @@ fn draw_grid(out: &mut Vec, g: &Frame, ticks: &[(f64, String)]) { } } -/// Gridlines along the category axis: across the plot at each category's centre, at the x ticks -/// of a scatter chart. -fn draw_cat_grid(out: &mut Vec, g: &Frame, xticks: &[(f64, String)], scatter: bool) { +/// Gridlines along the category axis: across the plot at each category's centre (where line and +/// area points sit, on the tick marks when the axis crosses "midCat"), at the x ticks of a +/// scatter chart. +fn draw_cat_grid(out: &mut Vec, g: &Frame, xticks: &[(f64, String)], kind: Kind) { let plot = g.plot; - if scatter { + if kind == Kind::Scatter { for (t, _) in xticks { let p = g.scat_x(*t); stroke(out, seg(p, plot.y, p, plot.bottom()), GRID, 0.75); @@ -286,8 +287,14 @@ fn draw_cat_grid(out: &mut Vec, g: &Frame, xticks: &[(f64, String)] return; } for i in 0..g.n { - let p = g.band_start(i) + g.band() / 2.0; - let segs = if g.horiz { seg(plot.x, p, plot.right(), p) } else { seg(p, plot.y, p, plot.bottom()) }; + let segs = if g.horiz { + let p = g.band_start(i) + g.band() / 2.0; + seg(plot.x, p, plot.right(), p) + } else { + // Bars stay in their bands; only line and area points move onto the ticks. + let p = if matches!(kind, Kind::Line | Kind::Area) { g.cat_x(i) } else { g.band_start(i) + g.band() / 2.0 }; + seg(p, plot.y, p, plot.bottom()) + }; stroke(out, segs, GRID, 0.75); } } diff --git a/crates/docx/src/read/chart/tests.rs b/crates/docx/src/read/chart/tests.rs index 528f46ee2..74573b5d8 100644 --- a/crates/docx/src/read/chart/tests.rs +++ b/crates/docx/src/read/chart/tests.rs @@ -618,3 +618,41 @@ fn bar_category_labels_start_after_the_axis_title() { assert!(labels.iter().all(|r| r[0] >= strip_end - 1e-3), "labels {labels:?} overlap the title strip ending at {strip_end}"); assert!(labels.iter().all(|r| r[2] <= 0.4 * 300.0), "{labels:?}"); } + +#[test] +fn category_gridlines_follow_the_points_when_the_axis_crosses_mid() { + let line = |cross: &str| { + let plot = format!( + r#"{}"#, + ser(0, "L", Some("FF0000"), &["Q1", "Q2", "Q3"], &["1", "5", "3"]), + ); + let items = chart_items(&space(&plot), &theme(), 300.0, 200.0); + let grid: Vec = items + .iter() + .filter_map(|it| match it { + GraphicItem::Path { segs, stroke: Some(c), .. } if *c == GRID => match segs.first() { + Some(PathSeg::Move(x, _)) => Some(*x), + _ => None, + }, + _ => None, + }) + .collect(); + let pts: Vec = items + .iter() + .filter_map(|it| match it { + GraphicItem::Path { segs, stroke: Some(c), .. } if *c == Rgb(255, 0, 0) => Some( + segs.iter().filter_map(|s| if let PathSeg::Move(x, _) | PathSeg::Line(x, _) = s { Some(*x) } else { None }).collect::>(), + ), + _ => None, + }) + .next() + .unwrap_or_default(); + (grid, pts) + }; + for cross in ["midCat", "between"] { + let (grid, pts) = line(cross); + assert_eq!(grid.len(), 3, "{cross}"); + assert_eq!(pts.len(), 3, "{cross}"); + assert!(grid.iter().zip(&pts).all(|(g, p)| (g - p).abs() < 1e-3), "{cross}: grid {grid:?} points {pts:?}"); + } +} From 80ed9665e7d27a98cc55e5526a1523327a380784 Mon Sep 17 00:00:00 2001 From: batistalucasv Date: Sat, 14 Nov 2026 15:25:54 -0300 Subject: [PATCH 045/382] craft-docx: preserve w:numberingChange without active list and raise w:original bound --- crates/docx/src/read/story/blocks.rs | 9 +++--- crates/docx/src/write/props.rs | 8 +++-- crates/docx/tests/it/fixtures.rs | 44 ++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+), 7 deletions(-) diff --git a/crates/docx/src/read/story/blocks.rs b/crates/docx/src/read/story/blocks.rs index 38c35a02b..878429454 100644 --- a/crates/docx/src/read/story/blocks.rs +++ b/crates/docx/src/read/story/blocks.rs @@ -249,10 +249,11 @@ impl Reader<'_> { .unwrap_or_default(); para.props.fmt_change = PropChange::boxed(self.revision(RevisionKind::Format, ch), old); } - if para.props.numbering.is_some() - && let Some(ch) = ppr.child("w:numPr").and_then(|n| n.child("w:numberingChange")) - { - let original = ch.attr("w:original").unwrap_or("").chars().take(256).collect(); + if let Some(ch) = ppr.child("w:numPr").and_then(|n| n.child("w:numberingChange")) { + // Multi-level numbering caches (`w:original`) routinely exceed 256 chars while staying + // bounded against hostile attributes. + const MAX_CHANGE_ORIGINAL: usize = 4096; + let original = ch.attr("w:original").unwrap_or("").chars().take(MAX_CHANGE_ORIGINAL).collect(); para.props.num_change = Some(Box::new(NumChange { rev: self.revision(RevisionKind::Format, ch), original })); } if let Some(s) = ppr.child("w:sectPr") { diff --git a/crates/docx/src/write/props.rs b/crates/docx/src/write/props.rs index 0a64fc20a..0b92ce191 100644 --- a/crates/docx/src/write/props.rs +++ b/crates/docx/src/write/props.rs @@ -261,10 +261,12 @@ pub fn ppr_inner(w: &mut W, p: &ParaProps, framed: bool, num_change: Option<&Cha toggle(w, "w:pageBreakBefore", p.page_break_before); write_frame(w, p, framed); toggle(w, "w:widowControl", p.widow_control); - if let Some(nr) = p.numbering { + if p.numbering.is_some() || num_change.is_some() { w.open("w:numPr", &[]); - w.val("w:ilvl", &n(nr.level.min(8) as i64)); - w.val("w:numId", &n(nr.num as i64)); + if let Some(nr) = p.numbering { + w.val("w:ilvl", &n(nr.level.min(8) as i64)); + w.val("w:numId", &n(nr.num as i64)); + } if let Some(a) = num_change { let refs: Vec<(&str, &str)> = a.iter().map(|(k, v)| (*k, v.as_str())).collect(); w.empty("w:numberingChange", &refs); diff --git a/crates/docx/tests/it/fixtures.rs b/crates/docx/tests/it/fixtures.rs index 868e8cbb0..348d6239e 100644 --- a/crates/docx/tests/it/fixtures.rs +++ b/crates/docx/tests/it/fixtures.rs @@ -2197,6 +2197,50 @@ fn formatting_revisions_round_trip() { assert_eq!(again.revisions, d.revisions); } +#[test] +fn numbering_change_without_active_list_roundtrips() { + let body = r#"Removed"#; + let d = read_body(body); + let p = paras(&d); + assert_eq!(p.len(), 1); + assert!(p[0].props.numbering.is_none()); + let nc = p[0].props.num_change.as_deref().expect("numberingChange read back"); + assert_eq!(nc.original, "%1:1:0:."); + + let bytes = craft_docx::write(&d).unwrap(); + let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap(); + let mut xml = String::new(); + std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap(); + assert!(xml.contains(r#""#), "{xml}"); + + let again = craft_docx::read(&bytes).unwrap(); + let ap = paras(&again); + assert!(ap[0].props.numbering.is_none()); + let anc = ap[0].props.num_change.as_deref().expect("numberingChange preserved after save"); + assert_eq!(anc.original, "%1:1:0:."); +} + +#[test] +fn numbering_change_original_preserves_long_values_within_bound() { + let long_orig = "%1:1:0:.".repeat(64); // 512 chars, well past the old 256-char cap + assert!(long_orig.len() > 256 && long_orig.len() < 4096); + let over_cap = "x".repeat(5000); + let body = format!( + r#"Long +Bounded"# + ); + let d = read_body(&body); + let p = paras(&d); + assert_eq!(p[0].props.num_change.as_deref().map(|n| n.original.as_str()), Some(long_orig.as_str())); + assert_eq!(p[1].props.num_change.as_deref().map(|n| n.original.chars().count()), Some(4096)); + + let bytes = craft_docx::write(&d).unwrap(); + let again = craft_docx::read(&bytes).unwrap(); + let ap = paras(&again); + assert_eq!(ap[0].props.num_change.as_deref().map(|n| n.original.as_str()), Some(long_orig.as_str())); +} + /// A package with `styles`, a theme (accent1 4472C4, accent2 ED7D31, major font "Major Face") and, /// when given, `settings`. fn themed_docx(body: &str, styles: &str, settings: Option<&str>) -> Document { From 24e626611985746bebbbdd9c252b8ee705701efd Mon Sep 17 00:00:00 2001 From: kiwi4boy Date: Sat, 14 Nov 2026 13:27:25 -0500 Subject: [PATCH 046/382] craft-xlsx: review fixes: spaced string chains flatten, module sheets and supporting links are capped - literal_texts now accepts a spaced operand as literal_text does, and the chain flattens with the spacing kept on its strings, so a chain the Python check accepts is written flat ("x"& "="&"1", not "x"&( "="&"1")). - Every BrtBundleSh counts toward the 1,024-sheet cap, a skipped module sheet too, since each keeps a place in the sheet links. - Supporting links are capped at 65,536; past it the links aren't read and formulas keep their saved results. --- crates/xlsx/src/xlsb.rs | 12 +++++++++++- crates/xlsx/src/xlsb/formula.rs | 30 ++++++++++++++++++++++++++++-- crates/xlsx/tests/xlsb.rs | 18 ++++++++++++++++++ 3 files changed, 57 insertions(+), 3 deletions(-) diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index ea37f59ca..b3f94b5fa 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -26,6 +26,9 @@ pub(crate) const WORKSHEET: &str = "application/vnd.ms-excel.worksheet"; pub(crate) const STRINGS: &str = "application/vnd.ms-excel.sharedStrings"; /// Most sheets in the workbook. const MAX_SHEETS: usize = 1024; +/// Supporting links (this workbook, add-ins, other workbooks) read at most; past it, formulas +/// keep their saved results. +const MAX_BOOKS: usize = 65_536; /// Most merged ranges in one worksheet. const MAX_MERGES: usize = 100_000; /// Defined names (Excel's hidden ones for newer functions included) read at most; past it, the @@ -268,6 +271,9 @@ pub(crate) fn workbook( let mut links = Some(Links::default()); let mut bundle = false; let mut bundle_seen = false; + // Every BrtBundleSh counts toward the cap, a skipped module sheet too: each keeps a place + // in the sheet links. + let mut bundle_count = 0usize; while let Some((id, payload)) = records.next(warnings)? { let mut b = Bytes::new(payload); match id { @@ -316,9 +322,10 @@ pub(crate) fn workbook( if !bundle { return Err(invalid("worksheet outside the worksheet list")); } - if wb.sheets.len() >= MAX_SHEETS { + if bundle_count >= MAX_SHEETS { return Err(Error::TooLarge(format!("XLSB exceeds {MAX_SHEETS} sheets"))); } + bundle_count += 1; let visibility = match b.u32()? { 0 => Visibility::Visible, 1 => Visibility::Hidden, @@ -368,6 +375,9 @@ pub(crate) fn workbook( /// (`BrtExternSheet`) or a defined name (`BrtName`), added to `links`. fn link_record(id: u16, payload: &[u8], links: &mut Links) -> Result<(), Error> { let mut b = Bytes::new(payload); + if matches!(id, 355 | 357 | 358 | 667) && links.books.len() >= MAX_BOOKS { + return Err(invalid("too many supporting links")); + } match id { 357 | 358 | 667 => { b.finish()?; diff --git a/crates/xlsx/src/xlsb/formula.rs b/crates/xlsx/src/xlsb/formula.rs index b62072ad2..a7293c0df 100644 --- a/crates/xlsx/src/xlsb/formula.rs +++ b/crates/xlsx/src/xlsb/formula.rs @@ -583,10 +583,13 @@ fn literal_text(e: &Expr) -> bool { } } -/// How many strings a [`literal_text`] chain joins, or `None` for anything else. +/// How many strings a [`literal_text`] chain joins, or `None` for anything else. It accepts +/// what [`literal_text`] does, typed spacing included, so a chain the Python check accepts is +/// one that is written flat. fn literal_texts(e: &Expr) -> Option { match e { Expr::Text(_) => Some(1), + Expr::Spaced(_, x, _) => literal_texts(x), Expr::Binary(BinOp::Concat, a, b) => literal_texts(a)?.checked_add(literal_texts(b)?), _ => None, } @@ -605,13 +608,24 @@ fn binding(e: &Expr) -> u8 { } } -/// The strings of a [`literal_text`] chain, left to right. +/// The strings of a [`literal_text`] chain, left to right. Spacing typed around a part of the +/// chain stays with that part's first and last strings, where it is written. fn flatten_texts(e: Expr, out: &mut Vec) { match e { Expr::Binary(BinOp::Concat, a, b) => { flatten_texts(*a, out); flatten_texts(*b, out); } + Expr::Spaced(before, x, after) if matches!(*x, Expr::Binary(BinOp::Concat, ..)) => { + let start = out.len(); + flatten_texts(*x, out); + if let Some(first) = out.get_mut(start) { + *first = spaced_before(std::mem::replace(first, Expr::Missing), before); + } + if let Some(last) = out.last_mut() { + *last = spaced_after(std::mem::replace(last, Expr::Missing), after); + } + } text => out.push(text), } } @@ -716,6 +730,18 @@ mod tests { } } + #[test] + fn a_spaced_part_of_a_string_chain_is_written_flat() { + // `"x"`, then `"="` typed with a space before it joined to `"1"`, then joined: the tokens + // nest to the right, and the space is on the inner chain. Written flat, as Python code + // must be, with the space where it was typed. + let s = |c: u8| [0x17, 1, 0, c, 0]; + let rgce = [&s(b'x')[..], &[0x19, 0x40, 0, 1], &s(b'=')[..], &s(b'1')[..], &[0x08, 0x08]].concat(); + let e = decode(&rgce, &[], &Links::default(), Mode::Cell).unwrap(); + assert_eq!(super::super::expr::print(&e), "\"x\"& \"=\"&\"1\""); + assert!(literal_text(&e) && literal_texts(&e) == Some(3)); + } + #[test] fn a_long_chain_of_strings_stays_within_the_depth_bound() { // 4,096 strings and 4,095 `&` fill 16,383 token bytes, 13 levels deep as written. Made diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index 94bb51ba6..748d1b86d 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -1062,3 +1062,21 @@ fn a_spent_formula_allowance_skips_decoding() { assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); assert!(!warned(&wb, "unknown formula token"), "{:?}", wb.warnings); } + +#[test] +fn module_sheets_and_supporting_links_are_bounded() { + // 1,025 very hidden module sheets (no relationship) before the worksheets: each keeps a place + // in the sheet links, so together they are past the 1,024-sheet cap. + let plain = book(false); + let at = plain.windows(3).position(|w| w == record(143, &[]).as_slice()).unwrap() + 3; + let module = record(156, &[&2u32.to_le_bytes()[..], &9u32.to_le_bytes(), &u32::MAX.to_le_bytes(), &wide("Module")].concat()); + let modules = [&plain[..at], &module.repeat(1025), &plain[at..]].concat(); + assert!(matches!(read(&package(&modules, &worksheet(&[], &[]), &sst(), ROOT, RELS, TYPES)), Err(Error::TooLarge(_)))); + // 65,537 supporting links: past the cap the links aren't read, and formulas keep their values. + let end = record(132, &[]); + let selves = [&plain[..plain.len() - end.len()], &record(353, &[]), &record(357, &[]).repeat(65_537), &record(354, &[]), &end].concat(); + let data = [row(0), formula_cell(0, &[0x1E, 1, 0], &[])].concat(); + let wb = read(&package(&selves, &worksheet(&data, &[]), &sst(), ROOT, RELS, TYPES)).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), None); + assert!(wb.warnings.iter().any(|w| w.contains("sheet links or names could not be read")), "{:?}", wb.warnings); +} From 376fa26e4c4349e95363abf3d21bc76e8ee4d86e Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 22:01:59 +0100 Subject: [PATCH 047/382] rtf: read paragraph direction from stylesheet entries A style's \rtlpar/\ltrpar (and \rtldir/\ltrdir) is stored with the style and found through \sbasedon. A paragraph in the style gets it unless it sets its own direction; \pard drops the direct direction and the style's stays. Co-Authored-By: Claude Sonnet 5.5 --- crates/rtf/src/doc/state.rs | 4 ++-- crates/rtf/src/doc/styles.rs | 6 +++++- crates/rtf/src/doc/tests.rs | 12 ++++++++++++ crates/rtf/src/doc/word.rs | 6 ++++-- 4 files changed, 23 insertions(+), 5 deletions(-) diff --git a/crates/rtf/src/doc/state.rs b/crates/rtf/src/doc/state.rs index 1f5d8d2e6..c27758d05 100644 --- a/crates/rtf/src/doc/state.rs +++ b/crates/rtf/src/doc/state.rs @@ -149,7 +149,7 @@ pub(super) struct St { // Paragraph properties. pub(super) align: Option, /// `\rtlpar`: the paragraph reads right to left. - pub(super) rtldir: bool, + pub(super) rtldir: Option, pub(super) style: i32, pub(super) intbl: bool, pub(super) ls: Option, @@ -187,7 +187,7 @@ impl Default for St { uc: 1, hidden: false, align: None, - rtldir: false, + rtldir: None, style: 0, intbl: false, ls: None, diff --git a/crates/rtf/src/doc/styles.rs b/crates/rtf/src/doc/styles.rs index dd42f3b87..e8eb9904c 100644 --- a/crates/rtf/src/doc/styles.rs +++ b/crates/rtf/src/doc/styles.rs @@ -30,6 +30,7 @@ impl Reader { out.italic = out.italic.or(d.italic); out.size = out.size.or(d.size); out.font = out.font.or(d.font); + out.rtl = out.rtl.or(d.rtl); cur = d.based_on; } out @@ -87,7 +88,8 @@ impl Reader { pub(super) fn para_props(&self, st: &St) -> Para { let mut p = Para::new(self.para_kind(st)); p.align = st.align; - p.rtl = st.rtldir; + // Direct `\rtlpar`/`\ltrpar` wins over the style's direction. + p.rtl = st.rtldir.or_else(|| self.file_style(st.style).rtl).unwrap_or(false); p.page_break = st.pagebb; p.spacing = spacing(st); p.borders = st.borders.any_visible().then_some(st.borders); @@ -136,6 +138,8 @@ pub(super) struct StyleDef { pub(super) size: Option, /// A `\fonttbl` index, named when it's used (the table may follow). pub(super) font: Option, + /// `\rtlpar` (`Some(true)`) or `\ltrpar`: the paragraph direction the style sets. + pub(super) rtl: Option, } /// Clear from `f` the formatting a paragraph of kind `kind` gets from its style, whose diff --git a/crates/rtf/src/doc/tests.rs b/crates/rtf/src/doc/tests.rs index 9274104ab..30fc8127c 100644 --- a/crates/rtf/src/doc/tests.rs +++ b/crates/rtf/src/doc/tests.rs @@ -68,6 +68,18 @@ fn rtl_paragraphs_read_and_write_their_direction() { assert_eq!(bidi(&import(out.as_bytes()).unwrap()), [true, false, false]); } +#[test] +fn rtl_paragraph_styles_carry_their_direction() { + // Word often writes the direction in the style: `{\s1\rtlpar RTL;}` then `\pard\s1`. + let rtf = br#"{\rtf1\ansi{\stylesheet{\s0 Normal;}{\s1\rtlpar RTL;}{\s2\sbasedon1 Child;}{\s3\sbasedon1\ltrpar Back;}} +\pard\s1 A\par\pard\s2 B\par\pard\s3 C\par\pard\s1\ltrpar D\par\pard\s0\rtlpar E\par\pard F\par}"#; + let flow = parse(rtf).unwrap(); + let rtl: Vec = flow.blocks.iter().filter_map(|b| if let FBlock::Para(p) = b { Some(p.rtl) } else { None }).collect(); + // A: style. B: inherited from the base style. C: the style overrides its base. D: direct + // \ltrpar beats the style. E: direct \rtlpar on Normal. F: \pard drops direct formatting. + assert_eq!(rtl, [true, true, false, false, true, false]); +} + #[test] fn stylesheet_names_take_unicode_escapes() { // \u116?=t \u105?=i \u116?=t \u108?=l \u101?=e — how Word writes a non-Latin style name. diff --git a/crates/rtf/src/doc/word.rs b/crates/rtf/src/doc/word.rs index bf163db0c..0a346ef93 100644 --- a/crates/rtf/src/doc/word.rs +++ b/crates/rtf/src/doc/word.rs @@ -173,8 +173,8 @@ impl Reader { "qd" => self.st.align = Some(Align::Distribute), // `\rtldir`/`\ltrdir` are not paragraph words (they set a table's or section's // direction in RTF); some writers used them for paragraphs, so they are read too. - "rtlpar" | "rtldir" => self.st.rtldir = true, - "ltrpar" | "ltrdir" => self.st.rtldir = false, + "rtlpar" | "rtldir" => self.st.rtldir = Some(true), + "ltrpar" | "ltrdir" => self.st.rtldir = Some(false), "s" => self.st.style = pv, "outlinelevel" => self.st.outline = Some(pv.clamp(0, 9) as u8), "pagebb" => self.st.pagebb = on, @@ -421,6 +421,8 @@ impl Reader { "i" => def.italic = Some(on), "fs" => def.size = (value > 0).then(|| (value as f32 / 2.0).clamp(1.0, 1638.0)), "f" => def.font = Some(value), + "rtlpar" | "rtldir" => def.rtl = Some(true), + "ltrpar" | "ltrdir" => def.rtl = Some(false), _ => {} } true From d869560911f5e14914314ebaddd97b8acfa87805 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sat, 14 Nov 2026 22:01:59 +0100 Subject: [PATCH 048/382] rtf: keep direction words in old paragraph formatting \rtlpar, \ltrpar, \rtldir and \ltrdir are paragraph formatting words, so \oldpprops holds them and a tracked direction change keeps the old direction. Co-Authored-By: Claude Sonnet 5.5 --- crates/rtf/src/doc/styles.rs | 4 ++++ crates/rtf/src/doc/tests.rs | 14 ++++++++++++++ 2 files changed, 18 insertions(+) diff --git a/crates/rtf/src/doc/styles.rs b/crates/rtf/src/doc/styles.rs index e8eb9904c..6047bf3c4 100644 --- a/crates/rtf/src/doc/styles.rs +++ b/crates/rtf/src/doc/styles.rs @@ -208,6 +208,10 @@ pub(super) fn is_format_word(w: &str) -> bool { | "s" | "outlinelevel" | "pagebb" + | "rtlpar" + | "ltrpar" + | "rtldir" + | "ltrdir" | "intbl" | "ls" | "ilvl" diff --git a/crates/rtf/src/doc/tests.rs b/crates/rtf/src/doc/tests.rs index 30fc8127c..8ba6294ae 100644 --- a/crates/rtf/src/doc/tests.rs +++ b/crates/rtf/src/doc/tests.rs @@ -80,6 +80,20 @@ fn rtl_paragraph_styles_carry_their_direction() { assert_eq!(rtl, [true, true, false, false, true, false]); } +#[test] +fn oldpprops_keep_the_old_paragraph_direction() { + // A tracked change of direction: now LTR, before RTL (`\rtlpar` in the old properties). + let rtf = br"{\rtf1\ansi{\*\revtbl {Unknown;}{Alice;}} +\pard\ltrpar\prauth1\prdate-2014675576{\*\oldpprops \pard \rtlpar}A\par}"; + let flow = parse(rtf).unwrap(); + let Some(FBlock::Para(p)) = flow.blocks.first() else { panic!("no paragraph") }; + assert!(!p.rtl); + assert!(p.fmt_change.as_deref().expect("paragraph change").old.rtl, "old direction is RTL"); + let doc = import(rtf).unwrap(); + let c = doc_paras(&doc)[0].props.fmt_change.as_deref().expect("change"); + assert_eq!(c.old.bidi, Some(true)); +} + #[test] fn stylesheet_names_take_unicode_escapes() { // \u116?=t \u105?=i \u116?=t \u108?=l \u101?=e — how Word writes a non-Latin style name. From 537d61a60f84a92675b2391a6e912067c810d0b9 Mon Sep 17 00:00:00 2001 From: vangel76 <271991477+vangel76@users.noreply.github.com> Date: Sun, 15 Nov 2026 01:05:40 +0100 Subject: [PATCH 049/382] rtf: read \ql and \qr after \rtlpar as start and end The model's paragraph alignment is logical (start/end) in right-to-left paragraphs, but the reader mapped \ql/\qr straight to left/right. For a \rtlpar paragraph that mirrored the alignment compared to Word. Word reads a side word that follows \rtlpar as start/end, and one that comes before it as plain left/right (checked black-box by saving RTF variants to DOCX). So \rtlpar\qr is start (no explicit alignment), \rtlpar\ql is end, and \qr\rtlpar is end. The writer already puts the alignment before \rtlpar, so its output keeps its meaning and is unchanged. Co-Authored-By: Claude Sonnet 5.5 --- crates/rtf/src/doc/tests.rs | 43 +++++++++++++++++++++++++++++++++++++ crates/rtf/src/doc/word.rs | 16 ++++++++++++-- 2 files changed, 57 insertions(+), 2 deletions(-) diff --git a/crates/rtf/src/doc/tests.rs b/crates/rtf/src/doc/tests.rs index 8ba6294ae..8313ad5b8 100644 --- a/crates/rtf/src/doc/tests.rs +++ b/crates/rtf/src/doc/tests.rs @@ -1886,3 +1886,46 @@ fn compound_borders_round_trip() { let back = import(export(&d).as_bytes()).unwrap(); assert_eq!(tops(&back), want); } + +fn para_aligns(flow: &Flow) -> Vec<(bool, Option)> { + flow.blocks.iter().filter_map(|b| if let FBlock::Para(p) = b { Some((p.rtl, p.align)) } else { None }).collect() +} + +#[test] +fn alignment_words_after_rtlpar_mean_start_and_end() { + // Word reads `\ql`/`\qr` that follow `\rtlpar` as start/end (the model's alignment is + // logical), so `\rtlpar\qr` sits at the right edge and `\rtlpar\ql` at the left edge. + // Words written before `\rtlpar` keep their plain meaning (checked in Word by saving to DOCX: + // `\qr\rtlpar` gives jc=right, i.e. end, in the bidi paragraph; `\ql\rtlpar` gives no jc). + let rtf = br#"{\rtf1\ansi\deff0{\fonttbl{\f0 Arial;}}\pard LTR one.\par \pard\rtlpar\qr A.\par \pard\rtlpar B.\par \pard\ltrpar Back.\par \pard\rtlpar\ql C.\par \pard\rtlpar\qc D.\par \pard\ql\rtlpar E.\par \pard\qr\rtlpar F.\par \pard\rtlpar\ltrpar\qr G.\par}"#; + let got = para_aligns(&parse(rtf).unwrap()); + assert_eq!( + got, + [ + (false, None), + (true, Some(Align::Left)), + (true, None), + (false, None), + (true, Some(Align::Right)), + (true, Some(Align::Center)), + (true, Some(Align::Left)), + (true, Some(Align::Right)), + (false, Some(Align::Right)), + ] + ); +} + +#[test] +fn alignment_survives_an_export_import_round_trip() { + let rtf = br#"{\rtf1\ansi\pard\ql L.\par \pard\qr R.\par \pard\qc C.\par \pard\rtlpar\qr start.\par \pard\rtlpar\ql end.\par \pard\rtlpar\qc mid.\par \pard\rtlpar plain.\par}"#; + let first = para_aligns(&parse(rtf).unwrap()); + let doc = import(rtf).unwrap(); + let out = export(&doc); + let second = para_aligns(&parse(out.as_bytes()).unwrap()); + let norm = |v: Vec<(bool, Option)>| v.into_iter().map(|(r, a)| (r, a.filter(|a| *a != Align::Left))).collect::>(); + assert_eq!(norm(first), norm(second.clone()), "{out}"); + // `\rtlpar\qr` is start (no explicit alignment in the model) and `\rtlpar\ql` is end. + assert_eq!(norm(second)[3..5], [(true, None), (true, Some(Align::Right))], "{out}"); + // The export writes the alignment before the direction, which Word reads as logical start/end. + assert!(out.contains("\\qr\\rtlpar"), "{out}"); +} diff --git a/crates/rtf/src/doc/word.rs b/crates/rtf/src/doc/word.rs index 0a346ef93..2eb86692f 100644 --- a/crates/rtf/src/doc/word.rs +++ b/crates/rtf/src/doc/word.rs @@ -3,6 +3,18 @@ use super::styles::{StyleDef, is_char_format_word, is_format_word}; use super::{Align, Fmt, Reader, VAlign, model}; impl Reader { + /// The logical alignment for a side word (`Left` for `\ql`, `Right` for `\qr`). The model's + /// alignment is logical (start/end), and Word reads a side word that comes after `\rtlpar` as + /// start/end: the sides swap in a paragraph already marked right to left. Before `\rtlpar` + /// the side keeps its plain meaning, which is why the writer puts the alignment first. + fn side_align(&self, side: Align) -> Align { + match (self.st.rtldir, side) { + (Some(true), Align::Left) => Align::Right, + (Some(true), Align::Right) => Align::Left, + _ => side, + } + } + pub(super) fn word(&mut self, w: &str, p: Option, starred: bool, first_in_group: bool) { // Every control word ends a multibyte run: the code page it is read in may change here // (`\f`, `\fcharset`, `\cpg`, `\ansicpg`, `\pard`), and `\par` must see the text before it. @@ -166,9 +178,9 @@ impl Reader { "cf" => self.st.fmt.color = self.colors.get(pv.max(0) as usize).copied().flatten(), "highlight" | "chcbpat" | "cb" => self.st.fmt.background = self.colors.get(pv.max(0) as usize).copied().flatten(), "v" => self.st.hidden = on, - "ql" => self.st.align = Some(Align::Left), + "ql" => self.st.align = Some(self.side_align(Align::Left)), "qc" => self.st.align = Some(Align::Center), - "qr" => self.st.align = Some(Align::Right), + "qr" => self.st.align = Some(self.side_align(Align::Right)), "qj" => self.st.align = Some(Align::Justify), "qd" => self.st.align = Some(Align::Distribute), // `\rtldir`/`\ltrdir` are not paragraph words (they set a table's or section's From 396402940c557fa41e7f9d6bf74cc89cf54d3222 Mon Sep 17 00:00:00 2001 From: vangel76 <271991477+vangel76@users.noreply.github.com> Date: Sun, 15 Nov 2026 01:06:12 +0100 Subject: [PATCH 050/382] docx charts: marker symbols and sizes, data label formats, upward axis titles A chart file carried three things that were read but not drawn like Word: - c:marker/c:symbol was ignored (every marker was a circle): squares, diamonds, triangles, x, plus, star, dash and dot are drawn now, in the series' c:size; unknown names fall back to a circle, sizes are clamped to 2..72 points. - c:dLbls/c:numFmt (not linked to the source) now formats the data labels, on the series or on the chart type; over-long codes are ignored. - The vertical axis title is turned -90 degrees (reading upwards) as Word does, or 90 when the file's bodyPr rot says so. It was always +90. Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/read/chart/model.rs | 41 +++++++++++++ crates/docx/src/read/chart/parse.rs | 53 +++++++++++++++- crates/docx/src/read/chart/plot.rs | 57 ++++++++++++++---- crates/docx/src/read/chart/polar.rs | 4 +- crates/docx/src/read/chart/tests.rs | 93 +++++++++++++++++++++++++++++ crates/wordmodel/src/graphic.rs | 2 +- 6 files changed, 232 insertions(+), 18 deletions(-) diff --git a/crates/docx/src/read/chart/model.rs b/crates/docx/src/read/chart/model.rs index fd2760db0..61d5d32d0 100644 --- a/crates/docx/src/read/chart/model.rs +++ b/crates/docx/src/read/chart/model.rs @@ -64,11 +64,46 @@ pub(crate) struct Axis { pub(crate) fmt: Option, /// The axis title, when the file gives it one. pub(crate) title: Option, + /// The title's `a:bodyPr/@rot` in degrees clockwise (`-5400000` is 90° counter-clockwise), + /// when the file gives one. + pub(crate) title_rot: Option, /// Tick labels, as `c:tickLblPos` says (`none` hides them; a file that says nothing shows /// them, as Word does). pub(crate) labels: bool, } +/// The shape of a series' point markers (`ST_MarkerStyle`, ECMA-376 §21.2.3.28). +#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)] +pub(super) enum Symbol { + #[default] + Circle, + Square, + Diamond, + Triangle, + X, + Plus, + Star, + Dash, + Dot, +} + +impl Symbol { + /// The symbol a `c:symbol` value names; anything unknown (`auto`, `picture`) is a circle. + pub(super) fn parse(name: &str) -> Symbol { + match name { + "square" => Symbol::Square, + "diamond" => Symbol::Diamond, + "triangle" => Symbol::Triangle, + "x" => Symbol::X, + "plus" => Symbol::Plus, + "star" => Symbol::Star, + "dash" => Symbol::Dash, + "dot" => Symbol::Dot, + _ => Symbol::Circle, + } + } +} + pub(super) struct Series { pub(super) name: String, /// The series' `c:idx` (an `xsd:unsignedInt`), which picks its automatic colour; `None` @@ -84,6 +119,10 @@ pub(super) struct Series { pub(super) no_fill: bool, /// Markers on the series' points, when the file says. pub(super) markers: Option, + /// The marker shape (`c:marker/c:symbol`; a circle when missing or unknown) and its size in + /// points (`c:marker/c:size`), when the file gives one. + pub(super) symbol: Symbol, + pub(super) marker_size: Option, /// Draw the series' line as a smooth curve (`c:smooth`). pub(super) smooth: bool, pub(super) values: Vec>, @@ -96,6 +135,8 @@ pub(super) struct Series { pub(super) x_fmt: Option, /// Data labels on or off for this series (`c:dLbls` of its own), when it says. pub(super) labels: Option, + /// The labels' own number format (`c:dLbls/c:numFmt` not linked to the source), if any. + pub(super) label_fmt: Option, /// The values as the file has them, for data labels (`values` become shares in a 100% /// stacked chart); empty when the series shows no labels. pub(super) raw: Vec>, diff --git a/crates/docx/src/read/chart/parse.rs b/crates/docx/src/read/chart/parse.rs index 6b20879c6..ec1508154 100644 --- a/crates/docx/src/read/chart/parse.rs +++ b/crates/docx/src/read/chart/parse.rs @@ -1,5 +1,5 @@ use super::format::{date_text, excel_stamp, format_value, is_date_code}; -use super::model::{Axis, Grouping, Kind, Pos, Series}; +use super::model::{Axis, Grouping, Kind, Pos, Series, Symbol}; use super::plot::label; use super::{Chart, El, FONT, MAX_CELLS, MAX_POINTS, MAX_RADAR_SERIES, MAX_SERIES, MAX_SPOKES, Rgb, fill_colour, int, measure, slot}; @@ -39,10 +39,14 @@ impl Chart { cats.resize(n, String::new()); let radar_style = ty.child("c:radarStyle").and_then(|r| r.attr("val")); let type_labels = show_values(ty.child("c:dLbls")); + let type_fmt = label_format(ty.child("c:dLbls")); for s in &mut series { s.values.resize(n, None); s.xs.resize(n, None); s.labels = Some(s.labels.or(type_labels).unwrap_or(false)); + if s.label_fmt.is_none() { + s.label_fmt.clone_from(&type_fmt); + } if s.labels == Some(true) { s.raw = s.values.clone(); } @@ -180,6 +184,15 @@ fn show_values(d: Option<&El>) -> Option { d.child("c:showVal").map(|v| v.attr("val").is_none_or(truthy)) } +/// The number format of data labels (`c:dLbls/c:numFmt`) when it is not linked to the source. +fn label_format(d: Option<&El>) -> Option { + d?.child("c:numFmt") + .filter(|f| f.attr("sourceLinked") != Some("1")) + .and_then(|f| f.attr("formatCode")) + .filter(|f| f.chars().count() <= craft_wordmodel::chart::MAX_FMT) + .map(str::to_string) +} + fn legend_pos(chart: &El) -> Option { chart.child("c:legend").map(|l| match l.child("c:legendPos").and_then(|p| p.attr("val")).unwrap_or("r") { "l" => Pos::Left, @@ -213,7 +226,15 @@ impl Series { // `c:marker/c:symbol`: which symbol each point gets (`none` for no markers). Scatter // series show markers unless the file says not; line series only when it says so. let symbol = ser.child("c:marker").and_then(|m| m.child("c:symbol")).and_then(|s| s.attr("val")).map(str::to_string); - let markers = symbol.map(|s| s != "none").or_else(|| scatter.then_some(true)); + let markers = symbol.as_deref().map(|s| s != "none").or_else(|| scatter.then_some(true)); + let symbol = symbol.as_deref().map_or(Symbol::Circle, Symbol::parse); + let marker_size = ser + .child("c:marker") + .and_then(|m| m.child("c:size")) + .and_then(|s| s.attr("val")) + .and_then(|v| v.trim().parse::().ok()) + .filter(|v| v.is_finite()) + .map(|v| v.clamp(2.0, 72.0)); let smooth = ser.child("c:smooth").and_then(|s| s.attr("val")).is_some_and(truthy); let (values, fmt) = numbers(ser.child(if scatter { "c:yVal" } else { "c:val" }), cap); let (mut xs, x_fmt) = if scatter { numbers(ser.child("c:xVal"), cap) } else { (Vec::new(), None) }; @@ -229,7 +250,27 @@ impl Series { } } let labels = show_values(ser.child("c:dLbls")); - Series { name, idx, color, line_w, line, no_fill, markers, smooth, values, xs, points, fmt, x_fmt, labels, raw: Vec::new() } + let label_fmt = label_format(ser.child("c:dLbls")); + Series { + name, + idx, + color, + line_w, + line, + no_fill, + markers, + symbol, + marker_size, + smooth, + values, + xs, + points, + fmt, + x_fmt, + labels, + label_fmt, + raw: Vec::new(), + } } } @@ -314,6 +355,12 @@ pub(super) fn axis(a: Option<&El>) -> Axis { .filter(|f| f.chars().count() <= craft_wordmodel::chart::MAX_FMT) .map(str::to_string), title: a.child("c:title").and_then(title_text), + title_rot: a + .child("c:title") + .and_then(|t| t.find("a:bodyPr")) + .and_then(|b| b.attr("rot")) + .and_then(|v| v.trim().parse::().ok()) + .map(|v| (v as f64 / 60_000.0).clamp(-360.0, 360.0) as f32), labels: a.child("c:tickLblPos").and_then(|p| p.attr("val")) != Some("none"), } } diff --git a/crates/docx/src/read/chart/plot.rs b/crates/docx/src/read/chart/plot.rs index eae203546..775d24eb2 100644 --- a/crates/docx/src/read/chart/plot.rs +++ b/crates/docx/src/read/chart/plot.rs @@ -1,10 +1,13 @@ use super::canvas::{Rect, clip_text, fill, rect_segs, runs, seg, stroke, text, text_angle, text_at, text_w, widest, wrap}; use super::format::format_value; -use super::model::{DataLabel, Grouping, Kind, Series}; +use super::model::{DataLabel, Grouping, Kind, Series, Symbol}; use super::parse::category_text; use super::polar::{draw_data_labels, label_of}; use super::{AXIS, Chart, El, GAP, GRID, GraphicItem, LINE, LINE_W, MAX_LABEL, MAX_TICKS, PathSeg, Rgb, ShapeKind, TextAlign, fill_colour, measure}; +/// Line width of the stroked marker symbols (x, plus, star), points. +const MARKER_STROKE: f32 = 1.5; + pub(super) fn label(s: &str) -> String { s.chars().take(MAX_LABEL).collect() } @@ -243,18 +246,21 @@ pub(super) fn cartesian(out: &mut Vec, c: &Chart, area: Rect) { } /// The axis titles, one line: the title of the vertical axis (the value axis for columns, the -/// category axis for bars) is rotated 90° on the plot's left; the horizontal axis's title sits +/// category axis for bars) is turned 90° on the plot's left; the horizontal axis's title sits /// under the plot. fn draw_axis_titles(out: &mut Vec, c: &Chart, g: &Frame, area: Rect) { let lh = c.text_size * LINE; // The axis drawn along the plot's left (the value axis for columns, the category axis for // bars) gets its title rotated there; the other axis's title sits under the plot. let (left, bottom) = if c.horizontal { (&c.cat, &c.val) } else { (&c.val, &c.cat) }; + // Word turns the vertical axis's title counter-clockwise (reading upwards) unless the file + // turns it the other way; a title with any other rotation would not fit the strip. + let up = if left.title_rot.is_some_and(|r| (r.rem_euclid(360.0) - 90.0).abs() < 1.0) { 90.0 } else { -90.0 }; if !left.deleted && let Some(t) = &left.title { let t = clip_text(t, g.plot.h, c.text_size); - text_angle(out, Rect { x: area.x, y: g.plot.y, w: lh, h: g.plot.h }, &t, c.text_size, TextAlign::Center, false, 90.0); + text_angle(out, Rect { x: area.x, y: g.plot.y, w: lh, h: g.plot.h }, &t, c.text_size, TextAlign::Center, false, up); } if !bottom.deleted && let Some(t) = &bottom.title @@ -481,18 +487,48 @@ fn lines(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec, pts: impl Iterator, colour: Rgb) { +/// A series' point markers in the series' symbol and size (`colour` fills or strokes them), for +/// lines and scatter charts. +fn markers(out: &mut Vec, pts: impl Iterator, colour: Rgb, s: &Series) { const MARKER: f32 = 6.0; + let size = s.marker_size.filter(|v| v.is_finite()).unwrap_or(MARKER).clamp(2.0, 72.0); + let h = size / 2.0; + let shape = |out: &mut Vec, rect: [f32; 4], kind: ShapeKind| { + out.push(GraphicItem::Shape { rect, kind, fill: Some(colour), stroke: None, stroke_width: 0.0 }); + }; + let mut strokes = Vec::new(); for (x, y) in pts { - let rect = [x - MARKER / 2.0, y - MARKER / 2.0, MARKER, MARKER]; - out.push(GraphicItem::Shape { rect, kind: ShapeKind::Ellipse, fill: Some(colour), stroke: None, stroke_width: 0.0 }); + match s.symbol { + Symbol::Circle => shape(out, [x - h, y - h, size, size], ShapeKind::Ellipse), + Symbol::Square => shape(out, [x - h, y - h, size, size], ShapeKind::Rectangle), + Symbol::Dot => shape(out, [x - h / 2.0, y - h / 2.0, h, h], ShapeKind::Ellipse), + Symbol::Dash => shape(out, [x - h, y - size / 6.0, size, size / 3.0], ShapeKind::Rectangle), + Symbol::Diamond => fill( + out, + vec![PathSeg::Move(x, y - h), PathSeg::Line(x + h, y), PathSeg::Line(x, y + h), PathSeg::Line(x - h, y), PathSeg::Close], + colour, + ), + Symbol::Triangle => { + fill(out, vec![PathSeg::Move(x, y - h), PathSeg::Line(x + h, y + h), PathSeg::Line(x - h, y + h), PathSeg::Close], colour) + } + Symbol::X | Symbol::Plus | Symbol::Star => { + if s.symbol != Symbol::Plus { + strokes.extend(seg(x - h, y - h, x + h, y + h)); + strokes.extend(seg(x - h, y + h, x + h, y - h)); + } + if s.symbol != Symbol::X { + strokes.extend(seg(x - h, y, x + h, y)); + strokes.extend(seg(x, y - h, x, y + h)); + } + } + } } + stroke(out, strokes, colour, MARKER_STROKE); } /// A polyline through `pts`, a smooth curve (Catmull-Rom pieces) when `smooth` and there are at @@ -582,10 +618,7 @@ fn draw_scatter(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut V stroke(out, curve(pts.iter().copied(), s.smooth), c.series_colour(j), s.line_w.unwrap_or(LINE_W)); } if s.markers != Some(false) { - for (x, y) in pts.iter().flatten() { - let rect = [x - MARKER / 2.0, y - MARKER / 2.0, MARKER, MARKER]; - out.push(GraphicItem::Shape { rect, kind: ShapeKind::Ellipse, fill: Some(c.series_colour(j)), stroke: None, stroke_width: 0.0 }); - } + markers(out, pts.iter().flatten().copied(), c.series_colour(j), s); } } } diff --git a/crates/docx/src/read/chart/polar.rs b/crates/docx/src/read/chart/polar.rs index ec7768d5c..dbbe390db 100644 --- a/crates/docx/src/read/chart/polar.rs +++ b/crates/docx/src/read/chart/polar.rs @@ -134,13 +134,13 @@ pub(super) fn radar(out: &mut Vec, c: &Chart, area: Rect) { } /// The data label of point `i` of series `s`, when it shows one: the value as the file has it, -/// in the series' number format. +/// in the labels' own number format, else the series' one. pub(super) fn label_of(s: &Series, i: usize) -> Option { if s.labels != Some(true) { return None; } let v = s.raw.get(i).copied().flatten()?; - let fmt = s.fmt.as_deref().filter(|f| !f.eq_ignore_ascii_case("General")); + let fmt = s.label_fmt.as_deref().or(s.fmt.as_deref()).filter(|f| !f.eq_ignore_ascii_case("General")); Some(match fmt { Some(f) => format_value(v, f, 1.0), None => general_value(v), diff --git a/crates/docx/src/read/chart/tests.rs b/crates/docx/src/read/chart/tests.rs index 74573b5d8..b156817d2 100644 --- a/crates/docx/src/read/chart/tests.rs +++ b/crates/docx/src/read/chart/tests.rs @@ -656,3 +656,96 @@ fn category_gridlines_follow_the_points_when_the_axis_crosses_mid() { assert!(grid.iter().zip(&pts).all(|(g, p)| (g - p).abs() < 1e-3), "{cross}: grid {grid:?} points {pts:?}"); } } + +/// A line chart with one series; `extra` goes into the series (`c:marker`, `c:dLbls`), `axes` +/// into the value axis. +fn line_with(extra: &str, val_axis: &str) -> Vec { + let s = ser(0, "S", Some("FF0000"), &["Q1", "Q2", "Q3"], &["3.2", "4.1", "5"]).replace("", &format!("{extra}")); + let plot = format!( + r#"{s}{val_axis}"# + ); + chart_items(&space(&plot), &theme(), 300.0, 200.0) +} + +fn marker_xml(symbol: &str, size: u32) -> String { + format!(r#""#) +} + +#[test] +fn marker_symbols_are_drawn_as_their_shape() { + let shapes = |items: &[GraphicItem], kind: ShapeKind| { + items + .iter() + .filter(|it| matches!(it, GraphicItem::Shape { kind: k, rect, .. } if *k == kind && rect[2] > 3.0 && rect[2] < 20.0 && rect[3] > 1.0)) + .count() + }; + let paths = |items: &[GraphicItem], filled: bool| { + items + .iter() + .filter(|it| matches!(it, GraphicItem::Path { fill, segs, .. } if fill.is_some() == filled && segs.len() <= 12 && segs.len() >= 3)) + .count() + }; + // One marker per point, in the series' size. + let circle = line_with(&marker_xml("circle", 9), ""); + assert_eq!(shapes(&circle, ShapeKind::Ellipse), 3); + assert!(circle.iter().any(|it| matches!(it, GraphicItem::Shape { kind: ShapeKind::Ellipse, rect, .. } if (rect[2] - 9.0).abs() < 1e-3))); + let square = line_with(&marker_xml("square", 7), ""); + assert_eq!(shapes(&square, ShapeKind::Rectangle) - shapes(&circle, ShapeKind::Rectangle), 3, "a square per point"); + assert_eq!(shapes(&square, ShapeKind::Ellipse), 0, "no circles"); + // Diamonds and triangles are filled polygons; x, plus and star are strokes. + let base = paths(&line_with("", ""), true); + assert_eq!(paths(&line_with(&marker_xml("diamond", 7), ""), true) - base, 3); + assert_eq!(paths(&line_with(&marker_xml("triangle", 7), ""), true) - base, 3); + for symbol in ["x", "plus", "star"] { + let items = line_with(&marker_xml(symbol, 7), ""); + assert!(items.iter().any(|it| matches!(it, GraphicItem::Path { fill: None, stroke: Some(_), segs, .. } if segs.len() >= 6)), "{symbol}"); + assert_eq!(shapes(&items, ShapeKind::Ellipse), 0, "{symbol} is not a circle"); + } + // Dash and dot are small shapes; `none` and unknown names never crash (unknown: a circle). + assert_eq!(shapes(&line_with(&marker_xml("dash", 7), ""), ShapeKind::Rectangle) - shapes(&circle, ShapeKind::Rectangle), 3); + assert_eq!(shapes(&line_with(&marker_xml("dot", 7), ""), ShapeKind::Ellipse), 3); + assert_eq!(shapes(&line_with(&marker_xml("none", 7), ""), ShapeKind::Ellipse), 0); + assert_eq!(shapes(&line_with(&marker_xml("wibble", 7), ""), ShapeKind::Ellipse), 3); + // Hostile sizes are clamped. + for size in ["0", "99999999999", "-4", "x"] { + let items = line_with(&format!(r#""#), ""); + assert!(items.iter().all(|it| match it { + GraphicItem::Shape { rect, .. } => rect.iter().all(|v| v.is_finite()) && rect[2] <= 300.0, + _ => true, + })); + } +} + +#[test] +fn data_labels_use_their_own_format_code() { + let dl = |num: &str| format!(r#"{num}"#); + let shown = |items: &[GraphicItem]| -> Vec { + items.iter().filter_map(|it| if let GraphicItem::Text { text, .. } = it { Some(text.clone()) } else { None }).collect() + }; + let own = shown(&line_with(&dl(r#""#), "")); + assert!(own.contains(&"3.20".to_string()) && own.contains(&"5.00".to_string()), "{own:?}"); + // Linked to the source: the series' format (General here). + let linked = shown(&line_with(&dl(r#""#), "")); + assert!(linked.contains(&"3.2".to_string()) && linked.contains(&"5".to_string()), "{linked:?}"); + // A format code beyond the cap is ignored, not applied. + let long = "0".repeat(craft_wordmodel::chart::MAX_FMT + 1); + let capped = shown(&line_with(&dl(&format!(r#""#)), "")); + assert!(capped.contains(&"3.2".to_string()), "{capped:?}"); +} + +#[test] +fn value_axis_title_turns_counter_clockwise_like_word() { + let title = |body: &str| format!(r#"{body}Revenue"#); + let angle = |items: &[GraphicItem]| { + items.iter().find_map(|it| if let GraphicItem::Text { text, angle, .. } = it { (text == "Revenue").then_some(*angle) } else { None }) + }; + // The file's rotation (`-5400000` is 90° counter-clockwise), or Word's default when it says none. + assert_eq!(angle(&line_with("", &title(r#""#))), Some(-90.0)); + assert_eq!(angle(&line_with("", &title(""))), Some(-90.0)); + assert_eq!(angle(&line_with("", &title(r#""#))), Some(90.0)); + // A horizontal title has no room beside the plot: it stays turned up. + assert_eq!(angle(&line_with("", &title(r#""#))), Some(-90.0)); + // Hostile values stay finite. + let odd = angle(&line_with("", &title(r#""#))); + assert!(odd.is_some_and(f32::is_finite)); +} diff --git a/crates/wordmodel/src/graphic.rs b/crates/wordmodel/src/graphic.rs index f4a7bcf2e..cba7e766a 100644 --- a/crates/wordmodel/src/graphic.rs +++ b/crates/wordmodel/src/graphic.rs @@ -117,7 +117,7 @@ pub enum GraphicItem { }, /// One line of text in `rect`, aligned horizontally by `align`, centred vertically; `angle` /// degrees clockwise turns the text about `rect`'s centre as it is drawn (chart axis titles - /// use 90° for the vertical axis). + /// turn the vertical axis's title -90°, reading upwards, as Word does). Text { rect: [f32; 4], text: String, From 8761999c9b7c7144f58a1493529a857e31c19287 Mon Sep 17 00:00:00 2001 From: vangel76 <271991477+vangel76@users.noreply.github.com> Date: Sun, 15 Nov 2026 01:19:18 +0100 Subject: [PATCH 051/382] docx charts: automatic marker colour, data label positions, horizontal axis titles Word draws markers without their own fill in the automatic palette colour of the series index, not the explicit line colour. Line and scatter data labels sit to the right of the point unless c:dLblPos says t, b, l, r or ctr. A vertical-axis title with rot="0" stays horizontal, wrapped into a strip of at most a quarter of the chart width, instead of being forced to -90 degrees. Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/read/chart/model.rs | 31 +++++++++++ crates/docx/src/read/chart/parse.rs | 13 ++++- crates/docx/src/read/chart/plot.rs | 73 ++++++++++++++++++++----- crates/docx/src/read/chart/polar.rs | 15 ++++- crates/docx/src/read/chart/tests.rs | 85 ++++++++++++++++++++++++++++- 5 files changed, 198 insertions(+), 19 deletions(-) diff --git a/crates/docx/src/read/chart/model.rs b/crates/docx/src/read/chart/model.rs index 61d5d32d0..37d06e31f 100644 --- a/crates/docx/src/read/chart/model.rs +++ b/crates/docx/src/read/chart/model.rs @@ -7,6 +7,33 @@ pub(super) struct DataLabel { pub(super) y: f32, pub(super) text: String, pub(super) inside: bool, + /// Where a label that is not `inside` sits relative to (`x`, `y`). + pub(super) pos: LabelPos, + /// Distance from (`x`, `y`) to the label for `pos` other than `Center`, points (half the marker). + pub(super) off: f32, +} + +/// Where a data label sits beside its point (`c:dLblPos`: `t`, `b`, `l`, `r`, `ctr`). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(super) enum LabelPos { + Above, + Below, + Left, + Right, + Center, +} + +impl LabelPos { + pub(super) fn parse(v: &str) -> Option { + Some(match v.trim() { + "t" => LabelPos::Above, + "b" => LabelPos::Below, + "l" => LabelPos::Left, + "r" => LabelPos::Right, + "ctr" => LabelPos::Center, + _ => return None, + }) + } } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -137,6 +164,10 @@ pub(super) struct Series { pub(super) labels: Option, /// The labels' own number format (`c:dLbls/c:numFmt` not linked to the source), if any. pub(super) label_fmt: Option, + /// The data labels' `c:dLblPos`, when the file gives a known one. + pub(super) label_pos: Option, + /// The marker's own fill (`c:marker/c:spPr`); without it markers take the automatic colour. + pub(super) marker_color: Option, /// The values as the file has them, for data labels (`values` become shares in a 100% /// stacked chart); empty when the series shows no labels. pub(super) raw: Vec>, diff --git a/crates/docx/src/read/chart/parse.rs b/crates/docx/src/read/chart/parse.rs index ec1508154..67b09d795 100644 --- a/crates/docx/src/read/chart/parse.rs +++ b/crates/docx/src/read/chart/parse.rs @@ -1,5 +1,5 @@ use super::format::{date_text, excel_stamp, format_value, is_date_code}; -use super::model::{Axis, Grouping, Kind, Pos, Series, Symbol}; +use super::model::{Axis, Grouping, Kind, LabelPos, Pos, Series, Symbol}; use super::plot::label; use super::{Chart, El, FONT, MAX_CELLS, MAX_POINTS, MAX_RADAR_SERIES, MAX_SERIES, MAX_SPOKES, Rgb, fill_colour, int, measure, slot}; @@ -102,6 +102,13 @@ impl Chart { s.and_then(|s| s.color).unwrap_or_else(|| self.accent(s.and_then(|s| s.idx).unwrap_or(j))) } + /// Colour of series `j`'s markers: the marker's own fill, else the automatic colour of the + /// series index (not the series' explicit line colour, as Word draws them). + pub(super) fn marker_colour(&self, j: usize) -> Rgb { + let s = self.series.get(j); + s.and_then(|s| s.marker_color).unwrap_or_else(|| self.accent(s.and_then(|s| s.idx).unwrap_or(j))) + } + /// Colour of point `i` of series `j`: its `c:dPt` override, else the varied accent (pie) or /// the series colour. pub(super) fn point_colour(&self, j: usize, i: usize) -> Rgb { @@ -219,6 +226,7 @@ impl Series { let sp = ser.child("c:spPr"); let ln = sp.and_then(|p| p.child("a:ln")); let marker = ser.child("c:marker").and_then(|m| m.child("c:spPr")).and_then(|p| fill_colour(p, theme)); + let marker_color = marker; let color = sp.and_then(|p| fill_colour(p, theme)).or_else(|| ln.and_then(|l| fill_colour(l, theme))).or(marker); let no_fill = sp.and_then(|p| p.child("a:noFill")).is_some(); let line_w = ln.and_then(|l| l.attr("w")).and_then(|v| measure(v, 12_700.0)).map(|w| w.clamp(0.0, 20.0)); @@ -251,6 +259,7 @@ impl Series { } let labels = show_values(ser.child("c:dLbls")); let label_fmt = label_format(ser.child("c:dLbls")); + let label_pos = ser.child("c:dLbls").and_then(|d| d.child("c:dLblPos")).and_then(|p| p.attr("val")).and_then(LabelPos::parse); Series { name, idx, @@ -269,6 +278,8 @@ impl Series { x_fmt, labels, label_fmt, + label_pos, + marker_color, raw: Vec::new(), } } diff --git a/crates/docx/src/read/chart/plot.rs b/crates/docx/src/read/chart/plot.rs index 775d24eb2..f671f1d49 100644 --- a/crates/docx/src/read/chart/plot.rs +++ b/crates/docx/src/read/chart/plot.rs @@ -1,6 +1,6 @@ use super::canvas::{Rect, clip_text, fill, rect_segs, runs, seg, stroke, text, text_angle, text_at, text_w, widest, wrap}; use super::format::format_value; -use super::model::{DataLabel, Grouping, Kind, Series, Symbol}; +use super::model::{DataLabel, Grouping, Kind, LabelPos, Series, Symbol}; use super::parse::category_text; use super::polar::{draw_data_labels, label_of}; use super::{AXIS, Chart, El, GAP, GRID, GraphicItem, LINE, LINE_W, MAX_LABEL, MAX_TICKS, PathSeg, Rgb, ShapeKind, TextAlign, fill_colour, measure}; @@ -164,7 +164,7 @@ fn axis_margins(c: &Chart, ax: &Axes, area: Rect) -> Margins { let scatter = c.kind == Kind::Scatter; let (cat_on, val_on) = (!c.cat.deleted, !c.val.deleted); let (cat_labels, val_labels) = (cat_on && c.cat.labels, val_on && c.val.labels); - let title = title_left(c, cat_on, val_on, lh); + let title = title_left(c, cat_on, val_on, area.w); let left = if c.horizontal { if cat_labels { widest(&c.cats, fs).min(area.w * 0.4) + GAP } else { 0.0 } } else if val_labels { @@ -195,9 +195,28 @@ fn axis_margins(c: &Chart, ax: &Axes, area: Rect) -> Margins { /// Room for the vertical axis title on the plot's left: one line when the axis that sits there /// (the value axis for columns, the category axis for bars) has a title. -fn title_left(c: &Chart, cat_on: bool, val_on: bool, lh: f32) -> f32 { +/// A horizontal title (`rot="0"`) gets a strip as wide as its wrapped lines, at most a quarter of +/// `area_w`, so the plot keeps its room. +fn title_left(c: &Chart, cat_on: bool, val_on: bool, area_w: f32) -> f32 { let side = if c.horizontal { cat_on && c.cat.title.is_some() } else { val_on && c.val.title.is_some() }; - if side { lh } else { 0.0 } + if !side { + return 0.0; + } + match flat_title_lines(c, area_w) { + Some(lines) => widest(&lines, c.text_size).min((area_w * 0.25).max(0.0)) + GAP, + None => c.text_size * LINE, + } +} + +/// The wrapped lines of the left axis's title when the file keeps it horizontal (`rot="0"`). +fn flat_title_lines(c: &Chart, area_w: f32) -> Option> { + let left = if c.horizontal { &c.cat } else { &c.val }; + let r = left.title_rot?.rem_euclid(360.0); + if !(r < 1.0 || r > 359.0) { + return None; + } + let width = if area_w.is_finite() { (area_w * 0.18).max(1.0) } else { 1.0 }; + left.title.as_ref().map(|t| wrap(t, width, c.text_size)) } /// Room for the horizontal axis title under the plot: one line when the axis that sits there @@ -236,7 +255,7 @@ pub(super) fn cartesian(out: &mut Vec, c: &Chart, area: Rect) { draw_axes(out, c, &g); draw_data_labels(out, &labels, c.text_size, g.horiz && c.kind == Kind::Bar); if !c.val.deleted && c.val.labels { - let room = title_left(c, !c.cat.deleted, true, c.text_size * LINE); + let room = title_left(c, !c.cat.deleted, true, area.w); draw_value_labels(out, c, &g, &ax.vticks, Rect { x: area.x + room, w: m.left - room, ..area }); } if !c.cat.deleted && c.cat.labels { @@ -254,9 +273,19 @@ fn draw_axis_titles(out: &mut Vec, c: &Chart, g: &Frame, area: Rect // bars) gets its title rotated there; the other axis's title sits under the plot. let (left, bottom) = if c.horizontal { (&c.cat, &c.val) } else { (&c.val, &c.cat) }; // Word turns the vertical axis's title counter-clockwise (reading upwards) unless the file - // turns it the other way; a title with any other rotation would not fit the strip. + // turns it the other way or keeps it horizontal (`rot="0"`, wrapped in its own strip); any + // other rotation would not fit the strip and is read as counter-clockwise. let up = if left.title_rot.is_some_and(|r| (r.rem_euclid(360.0) - 90.0).abs() < 1.0) { 90.0 } else { -90.0 }; if !left.deleted + && let Some(lines) = flat_title_lines(c, area.w) + { + let strip = (g.plot.x - area.x - GAP).max(1.0); + let top = g.plot.y + g.plot.h / 2.0 - lines.len() as f32 * lh / 2.0; + for (k, l) in lines.iter().enumerate() { + let l = clip_text(l, strip, c.text_size); + text_angle(out, Rect { x: area.x, y: top + k as f32 * lh, w: strip, h: lh }, &l, c.text_size, TextAlign::Center, false, 0.0); + } + } else if !left.deleted && let Some(t) = &left.title { let t = clip_text(t, g.plot.h, c.text_size); @@ -450,7 +479,7 @@ fn bars(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec (if v >= 0.0 { p1 } else { p0 }, mid), (false, false) => (mid, if v >= 0.0 { p0 } else { p1 }), }; - labels.push(DataLabel { x, y, text, inside: stacked }); + labels.push(DataLabel { x, y, text, inside: stacked, pos: LabelPos::Above, off: 0.0 }); } } } @@ -480,20 +509,32 @@ fn lines(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec f32 { + if drawn { s.marker_size.filter(|v| v.is_finite()).unwrap_or(6.0).clamp(2.0, 72.0) / 2.0 } else { 0.0 } +} + fn markers(out: &mut Vec, pts: impl Iterator, colour: Rgb, s: &Series) { const MARKER: f32 = 6.0; let size = s.marker_size.filter(|v| v.is_finite()).unwrap_or(MARKER).clamp(2.0, 72.0); @@ -588,7 +629,7 @@ fn areas(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec) { - const MARKER: f32 = 6.0; for (j, s) in c.series.iter().enumerate() { let pts: Vec> = s.xs.iter() @@ -611,14 +651,21 @@ fn draw_scatter(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut V .collect(); for (i, p) in pts.iter().enumerate() { if let (Some((x, y)), Some(text)) = (p, label_of(s, i)) { - labels.push(DataLabel { x: *x, y: *y - MARKER / 2.0, text, inside: false }); + labels.push(DataLabel { + x: *x, + y: *y, + text, + inside: false, + pos: s.label_pos.unwrap_or(LabelPos::Right), + off: marker_half(s, s.markers != Some(false)) + 2.0, + }); } } if s.line { stroke(out, curve(pts.iter().copied(), s.smooth), c.series_colour(j), s.line_w.unwrap_or(LINE_W)); } if s.markers != Some(false) { - markers(out, pts.iter().flatten().copied(), c.series_colour(j), s); + markers(out, pts.iter().flatten().copied(), c.marker_colour(j), s); } } } diff --git a/crates/docx/src/read/chart/polar.rs b/crates/docx/src/read/chart/polar.rs index dbbe390db..c686e746b 100644 --- a/crates/docx/src/read/chart/polar.rs +++ b/crates/docx/src/read/chart/polar.rs @@ -1,6 +1,6 @@ use super::canvas::{Rect, clip_text, fill, stroke, text, text_w, widest}; use super::format::format_value; -use super::model::{DataLabel, Kind, Series}; +use super::model::{DataLabel, Kind, LabelPos, Series}; use super::plot::{Axes, has_values}; use super::{Chart, FRAC_PI_2, GAP, GRID, GraphicItem, LINE, LINE_W, PathSeg, Rgb, ShapeKind, TAU, TEXT, TextAlign}; @@ -38,7 +38,7 @@ pub(super) fn pie(out: &mut Vec, c: &Chart, area: Rect) { // Halfway across the ring (pie: two thirds out from the centre). let at = if inner > 0.0 { (r + inner) / 2.0 } else { r * 0.65 }; let (x, y) = polar(cx, cy, at, (a + b) / 2.0); - labels.push(DataLabel { x: x as f32, y: y as f32, text, inside: true }); + labels.push(DataLabel { x: x as f32, y: y as f32, text, inside: true, pos: LabelPos::Above, off: 0.0 }); } a = b; } @@ -99,7 +99,7 @@ pub(super) fn radar(out: &mut Vec, c: &Chart, area: Rect) { out.push(GraphicItem::Shape { rect, kind: ShapeKind::Ellipse, fill: Some(col), stroke: None, stroke_width: 0.0 }); } if let Some(text) = label_of(s, i) { - labels.push(DataLabel { x: p.0 as f32, y: p.1 as f32, text, inside: false }); + labels.push(DataLabel { x: p.0 as f32, y: p.1 as f32, text, inside: false, pos: LabelPos::Above, off: 0.0 }); } } } @@ -165,6 +165,15 @@ pub(super) fn draw_data_labels(out: &mut Vec, labels: &[DataLabel], let w = text_w(&l.text, fs) + 4.0; let (rect, align) = if l.inside { (Rect { x: l.x - w / 2.0, y: l.y - lh / 2.0, w, h: lh }, TextAlign::Center) + } else if l.off > 0.0 || l.pos != LabelPos::Above { + let o = l.off; + match l.pos { + LabelPos::Right => (Rect { x: l.x + o, y: l.y - lh / 2.0, w, h: lh }, TextAlign::Left), + LabelPos::Left => (Rect { x: l.x - o - w, y: l.y - lh / 2.0, w, h: lh }, TextAlign::Right), + LabelPos::Below => (Rect { x: l.x - w / 2.0, y: l.y + o, w, h: lh }, TextAlign::Center), + LabelPos::Center => (Rect { x: l.x - w / 2.0, y: l.y - lh / 2.0, w, h: lh }, TextAlign::Center), + LabelPos::Above => (Rect { x: l.x - w / 2.0, y: l.y - o - lh, w, h: lh }, TextAlign::Center), + } } else if beside_right { (Rect { x: l.x + GAP / 2.0, y: l.y - lh / 2.0, w, h: lh }, TextAlign::Left) } else { diff --git a/crates/docx/src/read/chart/tests.rs b/crates/docx/src/read/chart/tests.rs index b156817d2..e5d7e4db6 100644 --- a/crates/docx/src/read/chart/tests.rs +++ b/crates/docx/src/read/chart/tests.rs @@ -743,9 +743,90 @@ fn value_axis_title_turns_counter_clockwise_like_word() { assert_eq!(angle(&line_with("", &title(r#""#))), Some(-90.0)); assert_eq!(angle(&line_with("", &title(""))), Some(-90.0)); assert_eq!(angle(&line_with("", &title(r#""#))), Some(90.0)); - // A horizontal title has no room beside the plot: it stays turned up. - assert_eq!(angle(&line_with("", &title(r#""#))), Some(-90.0)); + // A horizontal title (`rot="0"`) stays horizontal: the plot makes room for it (see below). + assert_eq!(angle(&line_with("", &title(r#""#))), Some(0.0)); // Hostile values stay finite. let odd = angle(&line_with("", &title(r#""#))); assert!(odd.is_some_and(f32::is_finite)); } + +fn first_ellipse(items: &[GraphicItem]) -> Option<([f32; 4], Rgb)> { + items.iter().find_map(|it| match it { + GraphicItem::Shape { kind: ShapeKind::Ellipse, rect, fill: Some(c), .. } if rect[2] > 3.0 && rect[2] < 20.0 => Some((*rect, *c)), + _ => None, + }) +} + +#[test] +fn markers_use_the_automatic_series_colour_not_the_line_colour() { + // The series has an explicit red line/fill but no marker fill: Word draws the markers in the + // palette colour of the series index (accent 1 here). + let items = line_with(&marker_xml("circle", 9), ""); + assert_eq!(first_ellipse(&items).map(|e| e.1), Some(theme()[4])); + // A marker's own fill wins. + let own = + r#""#; + assert_eq!(first_ellipse(&line_with(own, "")).map(|e| e.1), Some(Rgb(0, 0xAA, 0))); +} + +#[test] +fn line_data_labels_default_to_the_right_and_honour_dlblpos() { + let dl = |pos: &str| format!(r#"{}{pos}"#, marker_xml("circle", 9)); + let text_rect = |items: &[GraphicItem]| { + items.iter().find_map(|it| if let GraphicItem::Text { text, rect, .. } = it { (text == "3.2").then_some(*rect) } else { None }) + }; + let at = |pos: &str| { + let items = line_with(&dl(pos), ""); + let (m, _) = first_ellipse(&items).unwrap(); + let t = text_rect(&items).unwrap(); + // Centre of the marker and of the label box. + ((t[0] + t[2] / 2.0) - (m[0] + m[2] / 2.0), (t[1] + t[3] / 2.0) - (m[1] + m[3] / 2.0), t, m) + }; + let (dx, dy, t, m) = at(""); + assert!(t[0] >= m[0] + m[2] && dy.abs() < 1.0, "default is right of the marker: {dx} {dy}"); + let (dx, dy, t, m) = at(r#""#); + assert!(t[0] >= m[0] + m[2] && dy.abs() < 1.0, "{dx} {dy}"); + let (dx, dy, _, _) = at(r#""#); + assert!(dx.abs() < 1.0 && dy < -4.0, "{dx} {dy}"); + let (dx, dy, _, _) = at(r#""#); + assert!(dx.abs() < 1.0 && dy > 4.0, "{dx} {dy}"); + let (dx, dy, t, m) = at(r#""#); + assert!(t[0] + t[2] <= m[0] && dy.abs() < 1.0, "{dx} {dy}"); + let (dx, dy, _, _) = at(r#""#); + assert!(dx.abs() < 1.0 && dy.abs() < 1.0, "{dx} {dy}"); + // Unknown positions fall back to the default. + let (_, _, t, m) = at(r#""#); + assert!(t[0] >= m[0] + m[2]); +} + +#[test] +fn horizontal_value_axis_title_gets_its_own_strip() { + let title = |rot: &str, name: &str| { + format!(r#"{name}"#) + }; + let plot_left = |items: &[GraphicItem]| { + // The first gridline's start is the plot's left edge. + items.iter().find_map(|it| match it { + GraphicItem::Path { segs, stroke: Some(_), fill: None, .. } if segs.len() == 2 => match segs.first() { + Some(PathSeg::Move(x, _)) => Some(*x), + _ => None, + }, + _ => None, + }) + }; + let rect_of = |items: &[GraphicItem], name: &str| { + items.iter().find_map(|it| if let GraphicItem::Text { text, rect, .. } = it { text.starts_with(name).then_some(*rect) } else { None }) + }; + let turned = line_with("", &title(r#" rot="-5400000" vert="horz""#, "Revenue")); + let flat = line_with("", &title(r#" rot="0" vert="horz""#, "Revenue")); + let (a, b) = (plot_left(&turned).unwrap(), plot_left(&flat).unwrap()); + assert!(b > a + 10.0, "a horizontal title takes more room than a turned one: {a} {b}"); + // The title box lies left of the plot and inside the chart. + let r = rect_of(&flat, "Revenue").unwrap(); + assert!(r[0] >= 0.0 && r[0] + r[2] <= b + 0.5, "{r:?} {b}"); + // A hostile title never takes more than a quarter of the width and stays finite. + let long = "Wibble ".repeat(500); + let items = line_with("", &title(r#" rot="0""#, &long)); + let p = plot_left(&items).unwrap(); + assert!(p.is_finite() && p <= 300.0 * 0.3, "{p}"); +} From c0ce0553840d9a57b2349321f98e9d6c26ecc712 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sat, 14 Nov 2026 20:04:36 -0500 Subject: [PATCH 052/382] image-codecs: bound PNG row streaming independently of full output --- crates/image-codecs/src/codecs/png.rs | 65 ++++++++++++++-- crates/image-codecs/tests/it/png_jpeg.rs | 94 ++++++++++++++++++++++++ 2 files changed, 152 insertions(+), 7 deletions(-) diff --git a/crates/image-codecs/src/codecs/png.rs b/crates/image-codecs/src/codecs/png.rs index 4ceb75403..9965dfc30 100644 --- a/crates/image-codecs/src/codecs/png.rs +++ b/crates/image-codecs/src/codecs/png.rs @@ -141,12 +141,12 @@ impl> PngDecodeRows { /// Reads the header and refuses what [`decode`] refuses before any pixel is decoded: sizes /// past `limits`, and a file too small for the image it declares. pub fn new(bytes: B, limits: &Limits) -> Result { - Self::open(bytes, limits, true) + Self::open(bytes, limits, true, false) } /// [`PngDecodeRows::new`], optionally without reserving the whole image: a caller that hands /// the rows on as they come ([`decode_rows`]) never holds them all. - fn open(bytes: B, limits: &Limits, reserve: bool) -> Result { + fn open(bytes: B, limits: &Limits, reserve: bool, bounded_stream: bool) -> Result { let at = std::sync::Arc::new(std::sync::atomic::AtomicU64::new(0)); let bytes = SharedInput(std::sync::Arc::new(bytes)); let input = Tracked { cursor: Cursor::new(bytes.clone()), at: at.clone() }; @@ -187,7 +187,14 @@ impl> PngDecodeRows { let (width, height) = info.frame_control.map_or_else(|| info.size(), |f| (f.width, f.height)); let line = reader.output_line_size(width).ok_or_else(|| err("image too large"))?; // The output layout is known: charge its real bytes per pixel, not RGBA16's worst case. - limits.check(width, height, layout, sample)?; + if bounded_stream { + limits.check_size(width, height)?; + if line > limits.alloc_usize() { + return Err(CodecError::LimitExceeded("one PNG row exceeds max_alloc".into())); + } + } else { + limits.check(width, height, layout, sample)?; + } let height = usize::try_from(height).map_err(|_| err("image too large"))?; if width == 0 || height == 0 { return Err(err("the image is empty")); @@ -234,11 +241,35 @@ impl> PngDecodeRows { /// decode the whole image after all (an interlaced file) calls /// [`PngDecodeRows::reserve_output`] before [`PngDecodeRows::step`]. pub fn new_streaming(bytes: B, limits: &Limits) -> Result { - Self::open(bytes, limits, false) + Self::open(bytes, limits, false, false) + } + + /// Opens a bounded row stream without charging a full image that is never retained. + /// Dimension, pixel-count, plausibility, decoder and metadata limits remain unchanged; + /// `max_alloc` also bounds each row group. It is not a total process-memory limit. + /// Unlike [`Self::new_streaming`], a streamable image may exceed the full-image budget. + /// Non-streamable images still require that budget, as do [`Self::step`] and + /// [`Self::reserve_output`]. The caller must bound any output it retains in its sink. + pub fn new_bounded_streaming(bytes: B, limits: &Limits) -> Result { + let decoder = Self::open(bytes, limits, false, true)?; + if !decoder.streamable() { + decoder.check_full_output()?; + } + Ok(decoder) + } + + fn check_full_output(&self) -> Result<(), CodecError> { + let height = u32::try_from(self.height).map_err(|_| err("image too large"))?; + self.limits.check(self.width, height, self.layout, self.sample)?; + if self.size > self.limits.alloc_usize() { + return Err(CodecError::LimitExceeded("PNG output exceeds max_alloc".into())); + } + Ok(()) } /// Reserves the buffer [`PngDecodeRows::step`] decodes the whole image into. pub fn reserve_output(&mut self) -> Result<(), CodecError> { + self.check_full_output()?; let size = self.size; self.buf.try_reserve_exact(size).map_err(|_| CodecError::LimitExceeded(format!("cannot allocate {size} bytes for the image"))) } @@ -271,6 +302,7 @@ impl> PngDecodeRows { /// Decodes at least one row (the whole image if it is interlaced), then goes on while `more()` /// returns true. `Some` once the image is complete, after which the decoder is spent. pub fn step(&mut self, more: &mut dyn FnMut() -> bool) -> Result, CodecError> { + self.check_full_output()?; if self.done { return Err(err("the image was already decoded")); } @@ -338,7 +370,9 @@ impl> PngDecodeRows { /// `more()` returns true; `Some` with the extras once the file is read to its end, with the /// resolution a format that lacks one takes from its EXIF or XMP. A damaged file fails with /// the error [`decode`] gives, after however many rows were delivered. An orientation (an - /// `eXIf` after the image data may set one) is for the caller to apply. + /// `eXIf` after the image data may set one) is for the caller to apply. A new group size + /// must exceed any partial group retained from an earlier yield; otherwise this returns + /// an error without consuming another row. pub fn step_stream>( &mut self, group: u32, @@ -348,12 +382,29 @@ impl> PngDecodeRows { if self.done { return Err(err("the image was already decoded").into()); } - let group = usize::try_from(group.max(1)).unwrap_or(usize::MAX); + // Tail EXIF may report an orientation after rows have already been delivered; + // that belongs in the returned extras, not a rejection of metadata continuation. + if self.rows == 0 && !self.tail && !self.streamable() { + return Err(err("this PNG requires whole-image decoding").into()); + } + let group = usize::try_from(group.max(1)).unwrap_or(usize::MAX).min(self.height); + if self.rows - self.group_start >= group { + return Err(err("PNG row group is smaller than rows held from the previous step").into()); + } + let group_bytes = group.checked_mul(self.line).ok_or_else(|| err("PNG row group is too large"))?; + if group_bytes > self.limits.alloc_usize() { + return Err(CodecError::LimitExceeded("PNG row group exceeds max_alloc".into()).into()); + } if !self.tail { while self.rows < self.height { let held = self.rows - self.group_start; let at = held.checked_mul(self.line).ok_or_else(|| err("image too large"))?; let end = at.checked_add(self.line).ok_or_else(|| err("image too large"))?; + // A caller may change its group size between yields. Bound the actual held + // bytes as well as the requested group before growing the row buffer. + if end > self.limits.alloc_usize() { + return Err(CodecError::LimitExceeded("PNG row group exceeds max_alloc".into()).into()); + } if self.buf.len() < end { self.buf .try_reserve_exact(end - self.buf.len()) @@ -368,7 +419,7 @@ impl> PngDecodeRows { to_native_endian(row); } self.rows += 1; - if self.rows - self.group_start == group || self.rows == self.height { + if self.rows - self.group_start >= group || self.rows == self.height { let data = self.buf.get(..end).ok_or_else(|| err("invalid PNG row group"))?; sink(u32::try_from(self.group_start).map_err(|_| err("image too large"))?, data)?; self.group_start = self.rows; diff --git a/crates/image-codecs/tests/it/png_jpeg.rs b/crates/image-codecs/tests/it/png_jpeg.rs index 6b213ea83..07c57bf24 100644 --- a/crates/image-codecs/tests/it/png_jpeg.rs +++ b/crates/image-codecs/tests/it/png_jpeg.rs @@ -665,3 +665,97 @@ fn step_stream_gives_the_pixels_and_extras_of_decode() { fn dec_line(w: u32, layout: ChannelLayout, sample: SampleType) -> usize { w as usize * layout.channels() * sample.bytes() } + +#[test] +fn bounded_png_stream_does_not_charge_unretained_full_frame() { + let image = synth(256, 1024, ChannelLayout::Rgba, SampleType::U16, 77, 0.5); + let bytes = encode(&image, Format::Png, &EncodeOptions::default()).unwrap(); + let limits = Limits { max_alloc: 512 * 1024, ..Limits::default() }; + assert!(image.data().len() > limits.max_alloc as usize); + assert!(PngDecodeRows::new(bytes.as_slice(), &limits).is_err()); + assert!(PngDecodeRows::new_streaming(bytes.as_slice(), &limits).is_err()); + let mut decoder = PngDecodeRows::new_bounded_streaming(bytes.as_slice(), &limits).unwrap(); + assert!(decoder.streamable()); + // Opening a stream must not become a way to bypass whole-image allocation guards. + assert!(decoder.reserve_output().is_err()); + assert!(decoder.step(&mut || true).is_err()); + let mut next = 0; + let mut sink = |first: u32, rows: &[u8]| -> Result<(), CodecError> { + assert_eq!(first as usize, next); + assert!(rows.len() <= 3 * 256 * 8); + let start = next * 256 * 8; + assert_eq!(rows, &image.data()[start..start + rows.len()]); + next += rows.len() / (256 * 8); + Ok(()) + }; + while decoder.step_stream(3, &mut || false, &mut sink).unwrap().is_none() {} + assert_eq!(next, 1024); +} + +#[test] +fn bounded_png_stream_keeps_group_dimension_and_fallback_limits() { + let image = synth(256, 1024, ChannelLayout::Rgba, SampleType::U16, 81, 0.5); + let bytes = encode(&image, Format::Png, &EncodeOptions::default()).unwrap(); + let limits = Limits { max_alloc: 512 * 1024, ..Limits::default() }; + let mut decoder = PngDecodeRows::new_bounded_streaming(bytes.as_slice(), &limits).unwrap(); + assert!(decoder.step_stream::(1024, &mut || true, &mut |_, _| panic!("oversized group reached sink")).is_err()); + for strict in [ + Limits { max_width: 255, ..limits }, + Limits { max_height: 1023, ..limits }, + Limits { max_pixels: 256 * 1024 - 1, ..limits }, + Limits { max_alloc: 1024, ..limits }, + ] { + assert!(PngDecodeRows::new_bounded_streaming(bytes.as_slice(), &strict).is_err()); + } + let adam7 = interlaced(&image); + assert!(PngDecodeRows::new_bounded_streaming(adam7.as_slice(), &limits).is_err()); +} + +#[test] +fn bounded_png_stream_rejects_shrinking_below_buffered_rows() { + let image = synth(16, 8, ChannelLayout::Rgba, SampleType::U16, 83, 0.5); + let bytes = encode(&image, Format::Png, &EncodeOptions::default()).unwrap(); + let mut decoder = PngDecodeRows::new_bounded_streaming(bytes.as_slice(), &Limits::default()).unwrap(); + for _ in 0..3 { + assert!(decoder.step_stream::(4, &mut || false, &mut |_, _| panic!("group is incomplete")).unwrap().is_none()); + } + assert!(decoder.step_stream::(1, &mut || true, &mut |_, _| panic!("changed group reached sink")).is_err()); + let mut output = Vec::new(); + decoder + .step_stream::(4, &mut || true, &mut |_, rows| { + output.extend_from_slice(rows); + Ok(()) + }) + .unwrap(); + assert_eq!(output, image.data()); +} + +#[test] +fn bounded_png_stream_preserves_late_exif_across_metadata_yields() { + let image = synth(16, 8, ChannelLayout::Rgba, SampleType::U16, 89, 0.5); + let bytes = encode(&image, Format::Png, &EncodeOptions::default()).unwrap(); + let mut exif = sample_exif(); + exif[18..22].copy_from_slice(&6u32.to_le_bytes()); + let mut chunks = vec![png_chunk(b"eXIf", &exif)]; + for i in 0..150 { + chunks.push(png_chunk(b"tEXt", format!("key{i}\0value").as_bytes())); + } + let bytes = with_chunks_before_iend(&bytes, &chunks); + let mut decoder = PngDecodeRows::new_bounded_streaming(bytes.as_slice(), &Limits::default()).unwrap(); + assert!(decoder.streamable()); + let mut output = Vec::new(); + let extras = loop { + if let Some(extras) = decoder + .step_stream::(2, &mut || false, &mut |_, rows| { + output.extend_from_slice(rows); + Ok(()) + }) + .unwrap() + { + break extras; + } + }; + assert_eq!(output, image.data()); + assert_eq!(extras.orientation, 6); + assert_eq!(extras.meta.text.len(), 150); +} From 6767c7136297160cfca1460943b87f46a236cd8d Mon Sep 17 00:00:00 2001 From: vangel76 <271991477+vangel76@users.noreply.github.com> Date: Sun, 15 Nov 2026 02:26:31 +0100 Subject: [PATCH 053/382] Re-run CI: the Ubuntu gate timed out Co-Authored-By: Claude Sonnet 5.5 From 2e3ff2162bbf0ee24dc225fc54df19eb4e539547 Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 11:44:48 +0100 Subject: [PATCH 054/382] craft-image-codecs: SGI image reader and writer Adds Format::Sgi: 8- and 16-bit gray, gray+alpha, RGB and RGBA, verbatim and run-length encoded on read, run-length encoded on write. Palette-mapped files are reported as unsupported. Closes #1559 --- crates/image-codecs/README.md | 1 + crates/image-codecs/src/codecs.rs | 1 + crates/image-codecs/src/codecs/sgi.rs | 345 ++++++++++++++++++++ crates/image-codecs/src/format.rs | 14 +- crates/image-codecs/src/lib.rs | 4 +- crates/image-codecs/tests/it/detect_caps.rs | 17 + 6 files changed, 379 insertions(+), 3 deletions(-) create mode 100644 crates/image-codecs/src/codecs/sgi.rs diff --git a/crates/image-codecs/README.md b/crates/image-codecs/README.md index 6e9e11617..135853490 100644 --- a/crates/image-codecs/README.md +++ b/crates/image-codecs/README.md @@ -56,6 +56,7 @@ craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "< | Cineon | yes | yes | U16 (10-bit code values read and written exactly through U16) | Gray, RGB | no | no | no | no | no | no | no | built in | | DICOM | yes | **no** | U8, U16 | Gray, RGB | no | no | no | no | no | no | n/a | built in | | Amiga IFF (ILBM/PBM) | yes | yes (24-bit ILBM) | U8 | RGB, RGBA | yes (1-bit mask plane on write) | no | no | no | no | no | no | built in | +| SGI (`.sgi`, `.rgb`, `.bw`) | yes | yes (RLE) | U8, U16 | Gray, Gray+A, RGB, RGBA | yes | no | no | no | no | no | no | built in | | AVIF | **no** | only with feature `avif` | U8 | RGB, RGBA | yes | no | no | no | no | no | yes | `image` + `ravif` | | HEIF/HEIC | with feature `heif` | **no** | U8, U16 (10/12-bit decodes to U16) | RGB, RGBA | yes (auxiliary alpha) | yes (`colr` prof) | yes | yes | no | no | n/a | `heic-rs` | diff --git a/crates/image-codecs/src/codecs.rs b/crates/image-codecs/src/codecs.rs index 0288ae22b..6f070a290 100644 --- a/crates/image-codecs/src/codecs.rs +++ b/crates/image-codecs/src/codecs.rs @@ -17,6 +17,7 @@ pub(crate) mod jxl; pub(crate) mod pcx; pub(crate) mod png; pub(crate) mod pnm; +pub(crate) mod sgi; pub(crate) mod tga; pub(crate) mod tiff; pub(crate) mod tiff_exif; diff --git a/crates/image-codecs/src/codecs/sgi.rs b/crates/image-codecs/src/codecs/sgi.rs new file mode 100644 index 000000000..1e31b5f0a --- /dev/null +++ b/crates/image-codecs/src/codecs/sgi.rs @@ -0,0 +1,345 @@ +//! SGI image files (`.sgi`, `.rgb`, `.rgba`, `.bw`): 8- and 16-bit gray, gray + alpha, RGB and +//! RGBA, verbatim or run-length encoded. +//! +//! Read and write follow the published SGI image file format description: a 512-byte big-endian +//! header, then one plane per channel with the rows stored bottom to top. Palette-mapped files +//! (colormap ID other than 0) are rejected. The writer uses the run-length encoding. + +use crate::error::CodecError; +use crate::fidelity::Plan; +use crate::format::Format; +use crate::image::{ChannelLayout, Image, SampleType}; +use crate::options::Limits; + +const F: Format = Format::Sgi; +const HEADER: usize = 512; +const MAGIC: u16 = 474; + +fn bad(reason: impl std::fmt::Display) -> CodecError { + CodecError::malformed(F, reason) +} + +fn be16(b: &[u8], i: usize) -> u16 { + u16::from_be_bytes([b[i], b[i + 1]]) +} + +fn be32(b: &[u8], i: usize) -> u32 { + u32::from_be_bytes([b[i], b[i + 1], b[i + 2], b[i + 3]]) +} + +/// The fields of the header that decoding needs, already checked for plausibility. +struct Header { + rle: bool, + wide: bool, + width: u32, + height: u32, + planes: usize, +} + +/// Parse the 512-byte header. `None` when the bytes are not a plausible SGI header. +fn header(b: &[u8]) -> Option
                      { + if b.len() < HEADER || be16(b, 0) != MAGIC { + return None; + } + let (storage, bpc, dimension) = (b[2], b[3], be16(b, 4)); + let (width, height, planes) = (u32::from(be16(b, 6)), u32::from(be16(b, 8)), usize::from(be16(b, 10))); + if storage > 1 || !(1..=2).contains(&bpc) || !(1..=3).contains(&dimension) { + return None; + } + // A one-dimensional image has one row, a two-dimensional one a single plane. + let (height, planes) = match dimension { + 1 => (1, 1), + 2 => (height, 1), + _ => (height, planes), + }; + if width == 0 || height == 0 || !(1..=4).contains(&planes) { + return None; + } + Some(Header { rle: storage == 1, wide: bpc == 2, width, height, planes }) +} + +/// Whether `b` starts with a plausible SGI header (the magic number plus consistent fields). +pub(crate) fn looks_like_sgi(b: &[u8]) -> bool { + header(b).is_some() +} + +fn layout_of(planes: usize) -> ChannelLayout { + match planes { + 1 => ChannelLayout::Gray, + 2 => ChannelLayout::GrayA, + 3 => ChannelLayout::Rgb, + _ => ChannelLayout::Rgba, + } +} + +/// Expand one run-length encoded row into exactly `out.len()` samples. +fn read_rle_row(src: &[u8], wide: bool, out: &mut [u16]) -> Result<(), CodecError> { + let step = if wide { 2 } else { 1 }; + let sample = |pos: usize| -> Result { + let s = src.get(pos..pos + step).ok_or_else(|| bad("truncated RLE row"))?; + Ok(if wide { u16::from_be_bytes([s[0], s[1]]) } else { u16::from(s[0]) }) + }; + let (mut pos, mut n) = (0usize, 0usize); + while n < out.len() { + let code = sample(pos)?; + pos += step; + let count = usize::from(code & 0x7f); + if count == 0 { + return Err(bad("RLE row ends before the image width")); + } + if count > out.len() - n { + return Err(bad("RLE packet runs past the end of the row")); + } + if code & 0x80 != 0 { + for slot in &mut out[n..n + count] { + *slot = sample(pos)?; + pos += step; + } + } else { + let value = sample(pos)?; + pos += step; + out[n..n + count].fill(value); + } + n += count; + } + Ok(()) +} + +pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { + let h = header(b).ok_or_else(|| bad("invalid SGI header"))?; + if be32(b, 104) != 0 { + return Err(CodecError::unsupported(F, "palette-mapped SGI files are not supported")); + } + let layout = layout_of(h.planes); + let sample = if h.wide { SampleType::U16 } else { SampleType::U8 }; + limits.check(h.width, h.height, layout, sample)?; + let (w, ht, planes) = (h.width as usize, h.height as usize, h.planes); + let rows = ht.checked_mul(planes).ok_or_else(|| bad("image size overflow"))?; + let bps = if h.wide { 2 } else { 1 }; + let total = w.checked_mul(rows).ok_or_else(|| bad("image size overflow"))?; + // Reject inputs that cannot hold the declared pixels before allocating anything for them. + let table = if h.rle { rows.checked_mul(8).ok_or_else(|| bad("image size overflow"))? } else { 0 }; + let min_len = if h.rle { + // Every row needs at least a packet and a terminator. + HEADER + table + rows * bps + } else { + HEADER + total.checked_mul(bps).ok_or_else(|| bad("image size overflow"))? + }; + if b.len() < min_len { + return Err(bad("the file is too short for the declared image")); + } + let mut out = Vec::new(); + out.try_reserve_exact(total).map_err(|_| bad("pixel buffer is too large"))?; + out.resize(total, 0u16); + let mut row = vec![0u16; w]; + for z in 0..planes { + for y in 0..ht { + let index = y + z * ht; + if h.rle { + let start = be32(b, HEADER + index * 4) as usize; + let len = be32(b, HEADER + rows * 4 + index * 4) as usize; + let end = start.checked_add(len).filter(|&e| e <= b.len() && start >= HEADER).ok_or_else(|| bad("RLE row lies outside the file"))?; + read_rle_row(&b[start..end], h.wide, &mut row)?; + } else { + let start = HEADER + index * w * bps; + let s = &b[start..start + w * bps]; + for (x, v) in row.iter_mut().enumerate() { + *v = if h.wide { u16::from_be_bytes([s[2 * x], s[2 * x + 1]]) } else { u16::from(s[x]) }; + } + } + // Rows are stored bottom to top; planes are separate. + let top_y = ht - 1 - y; + for (x, &v) in row.iter().enumerate() { + out[(top_y * w + x) * planes + z] = v; + } + } + } + if h.wide { + Image::from_u16(h.width, h.height, layout, &out) + } else { + Image::from_u8(h.width, h.height, layout, out.iter().map(|&v| v as u8).collect()) + } +} + +/// Append one run-length encoded row (one packet list and a terminator). +fn write_rle_row(row: &[u16], wide: bool, out: &mut Vec) { + let put = |out: &mut Vec, v: u16| { + if wide { + out.extend_from_slice(&v.to_be_bytes()); + } else { + out.push(v as u8); + } + }; + let mut i = 0; + while i < row.len() { + let mut run = 1; + while i + run < row.len() && run < 127 && row[i + run] == row[i] { + run += 1; + } + if run >= 2 { + put(out, run as u16); + put(out, row[i]); + i += run; + } else { + // A literal packet extends until the next run of two or more. + let mut end = i + 1; + while end < row.len() && end - i < 127 && !(end + 1 < row.len() && row[end] == row[end + 1]) { + end += 1; + } + put(out, 0x80 | (end - i) as u16); + for &v in &row[i..end] { + put(out, v); + } + i = end; + } + } + put(out, 0); +} + +/// Writes a run-length encoded SGI file: 8 or 16 bits per channel, gray, gray + alpha, RGB or RGBA. +pub(crate) fn encode(src: &Image, plan: Plan) -> Result, CodecError> { + let enc = |msg: String| CodecError::encode(F, msg); + let img = src.converted(plan.layout, plan.sample); + let wide = match img.sample_type() { + SampleType::U8 => false, + SampleType::U16 => true, + s => return Err(enc(format!("SGI stores 8 or 16 bits per channel, not {s:?}"))), + }; + let planes = img.layout().channels(); + if !matches!(img.layout(), ChannelLayout::Gray | ChannelLayout::GrayA | ChannelLayout::Rgb | ChannelLayout::Rgba) { + return Err(enc(format!("no SGI layout for {:?}", img.layout()))); + } + let (w, ht) = img.dimensions(); + let (Ok(w16), Ok(h16)) = (u16::try_from(w), u16::try_from(ht)) else { + return Err(enc(format!("dimensions exceed 65535x65535: {w}x{ht}"))); + }; + let (w, ht) = (w as usize, ht as usize); + let bps = if wide { 2 } else { 1 }; + let data = img.data(); + if data.len() != w * ht * planes * bps { + return Err(enc("the image has the wrong number of samples".into())); + } + let sample_at = |i: usize| -> u16 { if wide { u16::from_ne_bytes([data[2 * i], data[2 * i + 1]]) } else { u16::from(data[i]) } }; + let rows = ht * planes; + let table = HEADER; + let mut starts = Vec::with_capacity(rows); + let mut lens = Vec::with_capacity(rows); + let mut body = Vec::new(); + let mut row = vec![0u16; w]; + let base = u32::try_from(HEADER + rows * 8).map_err(|_| enc("image too large".into()))?; + for z in 0..planes { + for y in 0..ht { + let src_y = ht - 1 - y; // stored bottom to top + for (x, v) in row.iter_mut().enumerate() { + *v = sample_at((src_y * w + x) * planes + z); + } + let before = body.len(); + write_rle_row(&row, wide, &mut body); + let start = u32::try_from(base as usize + before).map_err(|_| enc("image too large".into()))?; + starts.push(start); + lens.push((body.len() - before) as u32); + } + } + let mut out = Vec::with_capacity(table + rows * 8 + body.len()); + out.extend_from_slice(&MAGIC.to_be_bytes()); + out.push(1); // RLE + out.push(bps as u8); + out.extend_from_slice(&(if planes > 1 { 3u16 } else { 2u16 }).to_be_bytes()); + out.extend_from_slice(&w16.to_be_bytes()); + out.extend_from_slice(&h16.to_be_bytes()); + out.extend_from_slice(&(planes as u16).to_be_bytes()); + out.extend_from_slice(&0u32.to_be_bytes()); // pixmin + out.extend_from_slice(&(if wide { 65535u32 } else { 255 }).to_be_bytes()); // pixmax + out.resize(HEADER, 0); // dummy, image name, colormap 0, padding + for s in &starts { + out.extend_from_slice(&s.to_be_bytes()); + } + for l in &lens { + out.extend_from_slice(&l.to_be_bytes()); + } + out.extend_from_slice(&body); + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn gradient(w: u32, h: u32, layout: ChannelLayout) -> Image { + let ch = layout.channels(); + let data = (0..w as usize * h as usize * ch).map(|i| ((i * 7 + i / 5) % 251) as u8).collect(); + Image::from_u8(w, h, layout, data).unwrap() + } + + #[test] + fn rle_round_trips_every_layout_in_8_bits() { + for layout in [ChannelLayout::Gray, ChannelLayout::GrayA, ChannelLayout::Rgb, ChannelLayout::Rgba] { + let img = gradient(37, 11, layout); + let plan = Plan { layout, sample: SampleType::U8 }; + let bytes = encode(&img, plan).unwrap(); + assert!(looks_like_sgi(&bytes)); + let back = decode(&bytes, &Limits::default()).unwrap(); + assert_eq!(back.layout(), layout); + assert_eq!(back.data(), img.data()); + } + } + + #[test] + fn rle_round_trips_16_bits_with_long_runs() { + let (w, h) = (300u32, 4u32); + let samples: Vec = (0..w * h * 3).map(|i| if (i / 3) % 200 < 150 { 4242 } else { (i * 31) as u16 }).collect(); + let img = Image::from_u16(w, h, ChannelLayout::Rgb, &samples).unwrap(); + let bytes = encode(&img, Plan { layout: ChannelLayout::Rgb, sample: SampleType::U16 }).unwrap(); + let back = decode(&bytes, &Limits::default()).unwrap(); + assert_eq!(back.sample_type(), SampleType::U16); + assert_eq!(back.data(), img.data()); + } + + /// A hand-built verbatim file: two rows, one plane, stored bottom to top. + #[test] + fn verbatim_files_read_bottom_to_top() { + let mut f = vec![0u8; HEADER]; + f[0..2].copy_from_slice(&MAGIC.to_be_bytes()); + f[2] = 0; // verbatim + f[3] = 1; + f[4..6].copy_from_slice(&2u16.to_be_bytes()); + f[6..8].copy_from_slice(&3u16.to_be_bytes()); // x + f[8..10].copy_from_slice(&2u16.to_be_bytes()); // y + f[10..12].copy_from_slice(&1u16.to_be_bytes()); // z + f.extend_from_slice(&[10, 11, 12, 20, 21, 22]); // bottom row first + let img = decode(&f, &Limits::default()).unwrap(); + assert_eq!(img.layout(), ChannelLayout::Gray); + assert_eq!(img.data(), &[20, 21, 22, 10, 11, 12]); + } + + #[test] + fn hostile_input_is_an_error_not_a_panic() { + let img = gradient(16, 8, ChannelLayout::Rgb); + let good = encode(&img, Plan { layout: ChannelLayout::Rgb, sample: SampleType::U8 }).unwrap(); + // Every truncation fails cleanly. + for len in 0..good.len() { + let _ = decode(&good[..len], &Limits::default()); + } + // A row table pointing outside the file, and a packet that overruns its row. + let mut bad_table = good.clone(); + bad_table[HEADER..HEADER + 4].copy_from_slice(&u32::MAX.to_be_bytes()); + assert!(decode(&bad_table, &Limits::default()).is_err()); + let mut overrun = good.clone(); + let start = be32(&overrun, HEADER) as usize; + overrun[start] = 127; // a run longer than the 16-pixel row + assert!(decode(&overrun, &Limits::default()).is_err()); + // A huge declared size is stopped by the limits or the length check, before allocating. + let mut huge = good; + huge[6..8].copy_from_slice(&u16::MAX.to_be_bytes()); + huge[8..10].copy_from_slice(&u16::MAX.to_be_bytes()); + assert!(decode(&huge, &Limits::default()).is_err()); + } + + #[test] + fn palette_mapped_files_are_unsupported() { + let img = gradient(4, 4, ChannelLayout::Gray); + let mut f = encode(&img, Plan { layout: ChannelLayout::Gray, sample: SampleType::U8 }).unwrap(); + f[104..108].copy_from_slice(&1u32.to_be_bytes()); + assert!(matches!(decode(&f, &Limits::default()), Err(CodecError::Unsupported { .. }))); + } +} diff --git a/crates/image-codecs/src/format.rs b/crates/image-codecs/src/format.rs index ecaf945cd..d0d938bb7 100644 --- a/crates/image-codecs/src/format.rs +++ b/crates/image-codecs/src/format.rs @@ -44,6 +44,8 @@ pub enum Format { Iff, /// JPEG 2000 (JP2 container or raw J2K codestream): read-only; see [`ASYMMETRIC_EXCEPTIONS`]. Jp2, + /// SGI image files (`.sgi`, `.rgb`, `.bw`): 8- and 16-bit gray, gray + alpha, RGB and RGBA. + Sgi, } /// What a format can hold **and** what this crate reads/writes for it. @@ -113,7 +115,7 @@ const TIFF_LAYOUTS: &[ChannelLayout] = &[L::Gray, L::GrayA, L::Rgb, L::Rgba, L:: impl Format { /// Every format known to the crate (enabled or not). - pub const ALL: [Format; 24] = [ + pub const ALL: [Format; 25] = [ Format::Png, Format::Jpeg, Format::Jp2, @@ -138,6 +140,7 @@ impl Format { Format::Cineon, Format::Dicom, Format::Iff, + Format::Sgi, ]; pub fn caps(self) -> FormatCaps { @@ -176,6 +179,7 @@ impl Format { Format::Dicom => "DICOM", Format::Iff => "Amiga IFF", Format::Jp2 => "JPEG 2000", + Format::Sgi => "SGI", } } @@ -207,6 +211,7 @@ impl Format { Format::Dicom => &["dcm", "dicom", "dc3"], Format::Iff => &["iff", "lbm", "ilbm"], Format::Jp2 => &["jp2", "j2k", "j2c", "jpf", "jpx"], + Format::Sgi => &["sgi", "rgb", "rgba", "bw"], } } @@ -236,13 +241,14 @@ impl Format { Format::Dicom => "application/dicom", Format::Iff => "image/x-iff", Format::Jp2 => "image/jp2", + Format::Sgi => "image/x-sgi", } } /// Maximum encodable dimensions, if the format has a hard limit. pub fn max_dimensions(self) -> Option<(u32, u32)> { match self { - Format::Jpeg | Format::Gif | Format::Iff => Some((65535, 65535)), + Format::Jpeg | Format::Gif | Format::Iff | Format::Sgi => Some((65535, 65535)), Format::WebP => Some((16384, 16384)), Format::Ico => Some((256, 256)), _ => None, @@ -310,6 +316,7 @@ pub fn caps(format: Format) -> FormatCaps { Format::Cineon => FormatCaps { depths: &[S::U16], layouts: &[L::Gray, L::Rgb], alpha: false, ..base }, Format::Dicom => FormatCaps { read: true, write: false, depths: &[S::U8, S::U16], layouts: &[L::Gray, L::Rgb], alpha: false, ..base }, Format::Iff => FormatCaps { depths: &[S::U8], layouts: &[L::Rgb, L::Rgba], alpha: true, ..base }, + Format::Sgi => FormatCaps { depths: &[S::U8, S::U16], layouts: RGB_GRAY, alpha: true, ..base }, Format::Jp2 => FormatCaps { read: true, write: false, layouts: &[L::Gray, L::GrayA, L::Rgb, L::Rgba, L::Cmyk, L::CmykA], icc: true, ..base }, } } @@ -388,6 +395,9 @@ pub fn detect(bytes: &[u8]) -> Option { if b.starts_with(b"/* XPM */") || b.starts_with(b"! XPM2\n") || b.starts_with(b"! XPM2\r\n") { return Some(Format::Xpm); } + if crate::codecs::sgi::looks_like_sgi(b) { + return Some(Format::Sgi); + } if crate::codecs::pcx::looks_like_pcx(b) { return Some(Format::Pcx); } diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 21130e392..cad63019d 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -62,7 +62,7 @@ pub use crate::resolution::{exif_resolution, export_exif, export_xmp, photoshop_ pub use crate::source_settings::{WebpEncoding, jpeg_quality, webp_encoding}; pub use half::f16; -use crate::codecs::{dds, dicom, dpx, exr, fits, heif, iff, jp2, jpeg, jxl, pcx, png, pnm, tiff, via_image, webp, xpm}; +use crate::codecs::{dds, dicom, dpx, exr, fits, heif, iff, jp2, jpeg, jxl, pcx, png, pnm, sgi, tiff, via_image, webp, xpm}; /// Detect the format and decode with default [`Limits`]. pub fn decode(bytes: &[u8]) -> Result { @@ -101,6 +101,7 @@ pub fn decode_as_with(format: Format, bytes: &[u8], opts: &DecodeOptions) -> Res Format::Cineon => dpx::decode_cineon(bytes, l), Format::Dicom => dicom::decode(bytes, l), Format::Iff => iff::decode(bytes, l), + Format::Sgi => sgi::decode(bytes, l), Format::OpenExr => exr::decode(bytes, l), Format::Heif => heif::decode(bytes, l, opts.keep_orientation), Format::Jp2 => jp2::decode(bytes, l), @@ -457,6 +458,7 @@ pub fn encode(image: &Image, format: Format, opts: &EncodeOptions) -> Result dpx::encode_cineon(image, plan), Format::Dicom => Err(CodecError::unsupported(format, "DICOM is import-only; save as TIFF or PNG instead")), Format::Iff => iff::encode(image, plan), + Format::Sgi => sgi::encode(image, plan), Format::OpenExr => exr::encode(image, plan, opts), Format::Heif => Err(CodecError::unsupported(format, "encoding is not available in this build")), Format::Jp2 => Err(CodecError::unsupported(format, "JPEG 2000 is import-only; save as PNG or TIFF instead")), diff --git a/crates/image-codecs/tests/it/detect_caps.rs b/crates/image-codecs/tests/it/detect_caps.rs index 640772c83..d7d448388 100644 --- a/crates/image-codecs/tests/it/detect_caps.rs +++ b/crates/image-codecs/tests/it/detect_caps.rs @@ -62,6 +62,7 @@ fn default_build_formats_all_symmetric() { Format::Dpx, Format::Cineon, Format::Iff, + Format::Sgi, ]; for f in expected { assert!(caps(f).read && caps(f).write, "{f:?}"); @@ -218,6 +219,22 @@ fn detect_magic_iff() { assert_eq!(detect(b"FORM\0\0\0\x14AIFF"), None); assert!(decode_as(Format::Iff, b"FORM\0\0\0\x14ILBM").is_err()); } +#[test] +fn detect_magic_sgi() { + use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, encode}; + let img = Image::from_u8(5, 3, ChannelLayout::Rgba, (0..60).collect()).unwrap(); + let bytes = encode(&img, Format::Sgi, &EncodeOptions::default()).unwrap(); + assert_eq!(detect(&bytes), Some(Format::Sgi)); + assert_eq!(from_extension("scan.RGB"), Some(Format::Sgi)); + assert_eq!(from_extension("scan.bw"), Some(Format::Sgi)); + assert_eq!(decode(&bytes).unwrap().data(), img.data()); + assert!(!ASYMMETRIC_EXCEPTIONS.iter().any(|(f, _)| *f == Format::Sgi)); + assert_eq!(Format::Sgi.max_dimensions(), Some((65535, 65535))); + // The magic number alone, without a full header, is not SGI. + assert_eq!(detect(&[0x01, 0xda, 0, 1, 0, 2]), None); + assert!(decode_as(Format::Sgi, &[0x01, 0xda]).is_err()); +} + #[test] fn detect_magic_avif() { assert_eq!(detect(b"\0\0\0\x1cftypavif\0\0\0\0avifmif1miaf"), Some(Format::Avif)); From 5628ad359d8f5bf9778f53edba9b9989b4b61d09 Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 11:49:53 +0100 Subject: [PATCH 055/382] craft-image-codecs: Sun Raster image reader and writer Adds Format::SunRaster: 1-, 8- (gray or colour-mapped), 24- and 32-bit files, uncompressed or byte-encoded (RLE) on read, uncompressed on write. Closes #1560 --- crates/image-codecs/README.md | 1 + crates/image-codecs/src/codecs.rs | 1 + crates/image-codecs/src/codecs/sunraster.rs | 237 ++++++++++++++++++++ crates/image-codecs/src/format.rs | 12 +- crates/image-codecs/src/lib.rs | 4 +- crates/image-codecs/tests/it/detect_caps.rs | 14 ++ 6 files changed, 267 insertions(+), 2 deletions(-) create mode 100644 crates/image-codecs/src/codecs/sunraster.rs diff --git a/crates/image-codecs/README.md b/crates/image-codecs/README.md index 6e9e11617..f9f5f53e6 100644 --- a/crates/image-codecs/README.md +++ b/crates/image-codecs/README.md @@ -56,6 +56,7 @@ craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "< | Cineon | yes | yes | U16 (10-bit code values read and written exactly through U16) | Gray, RGB | no | no | no | no | no | no | no | built in | | DICOM | yes | **no** | U8, U16 | Gray, RGB | no | no | no | no | no | no | n/a | built in | | Amiga IFF (ILBM/PBM) | yes | yes (24-bit ILBM) | U8 | RGB, RGBA | yes (1-bit mask plane on write) | no | no | no | no | no | no | built in | +| Sun Raster (`.ras`) | yes (incl. RLE and colour maps) | yes (uncompressed) | U8 | Gray, Gray+A, RGB, RGBA | yes | no | no | no | no | no | no | built in | | AVIF | **no** | only with feature `avif` | U8 | RGB, RGBA | yes | no | no | no | no | no | yes | `image` + `ravif` | | HEIF/HEIC | with feature `heif` | **no** | U8, U16 (10/12-bit decodes to U16) | RGB, RGBA | yes (auxiliary alpha) | yes (`colr` prof) | yes | yes | no | no | n/a | `heic-rs` | diff --git a/crates/image-codecs/src/codecs.rs b/crates/image-codecs/src/codecs.rs index 0288ae22b..aecf95bbd 100644 --- a/crates/image-codecs/src/codecs.rs +++ b/crates/image-codecs/src/codecs.rs @@ -17,6 +17,7 @@ pub(crate) mod jxl; pub(crate) mod pcx; pub(crate) mod png; pub(crate) mod pnm; +pub(crate) mod sunraster; pub(crate) mod tga; pub(crate) mod tiff; pub(crate) mod tiff_exif; diff --git a/crates/image-codecs/src/codecs/sunraster.rs b/crates/image-codecs/src/codecs/sunraster.rs new file mode 100644 index 000000000..84d60f145 --- /dev/null +++ b/crates/image-codecs/src/codecs/sunraster.rs @@ -0,0 +1,237 @@ +//! Sun Raster files (`.ras`, `.sun`): 1-bit, 8-bit (gray or colour-mapped), 24-bit RGB and 32-bit +//! RGBA, uncompressed or byte-encoded (RLE) on read; uncompressed on write. +//! +//! Follows the published rasterfile format: a 32-byte big-endian header, an optional colour map, +//! then rows padded to an even number of bytes. In the "standard" type (1) 24- and 32-bit pixels +//! are stored blue-first; in the "RGB" type (3) red-first. Other types (TIFF, IFF, experimental) +//! are reported as unsupported. + +use crate::error::CodecError; +use crate::fidelity::Plan; +use crate::format::Format; +use crate::image::{ChannelLayout, Image, SampleType}; +use crate::options::Limits; + +const F: Format = Format::SunRaster; +const HEADER: usize = 32; +const MAGIC: u32 = 0x59a6_6a95; + +fn bad(reason: impl std::fmt::Display) -> CodecError { + CodecError::malformed(F, reason) +} + +fn be32(b: &[u8], i: usize) -> u32 { + u32::from_be_bytes([b[i], b[i + 1], b[i + 2], b[i + 3]]) +} + +/// Whether `b` starts with a Sun rasterfile header. +pub(crate) fn looks_like_sunraster(b: &[u8]) -> bool { + b.len() >= HEADER && be32(b, 0) == MAGIC && matches!(be32(b, 12), 1 | 8 | 24 | 32) +} + +/// Expand byte-encoded data (`0x80` escapes a run) until `want` bytes are produced. +fn unrle(src: &[u8], want: usize) -> Result, CodecError> { + let mut out = Vec::new(); + out.try_reserve_exact(want).map_err(|_| bad("pixel buffer is too large"))?; + let mut i = 0; + while out.len() < want { + let b = *src.get(i).ok_or_else(|| bad("truncated RLE data"))?; + i += 1; + if b != 0x80 { + out.push(b); + continue; + } + let n = *src.get(i).ok_or_else(|| bad("truncated RLE data"))?; + i += 1; + if n == 0 { + out.push(0x80); + continue; + } + let v = *src.get(i).ok_or_else(|| bad("truncated RLE data"))?; + i += 1; + let count = usize::from(n) + 1; + if count > want - out.len() { + return Err(bad("RLE run passes the end of the image")); + } + out.resize(out.len() + count, v); + } + Ok(out) +} + +pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { + if !looks_like_sunraster(b) { + return Err(bad("invalid Sun raster header")); + } + let (w, h, depth, kind, map_type, map_len) = (be32(b, 4), be32(b, 8), be32(b, 12) as usize, be32(b, 20), be32(b, 24), be32(b, 28) as usize); + if !matches!(kind, 0..=3) { + return Err(CodecError::unsupported(F, format!("Sun raster type {kind} is not supported"))); + } + if map_type > 2 { + return Err(CodecError::unsupported(F, format!("Sun raster map type {map_type} is not supported"))); + } + let layout = match depth { + 1 | 8 if map_type != 1 => ChannelLayout::Gray, + 1 | 8 | 24 => ChannelLayout::Rgb, + _ => ChannelLayout::Rgba, + }; + limits.check(w, h, layout, SampleType::U8)?; + let (wu, hu) = (w as usize, h as usize); + let stride = wu.checked_mul(depth).and_then(|n| n.checked_add(15)).ok_or_else(|| bad("image size overflow"))? / 16 * 2; + let want = stride.checked_mul(hu).ok_or_else(|| bad("image size overflow"))?; + let data_at = HEADER.checked_add(map_len).ok_or_else(|| bad("colour map size overflow"))?; + let map = b.get(HEADER..data_at).ok_or_else(|| bad("truncated colour map"))?; + let rest = &b[data_at..]; + let raw; + let rows: &[u8] = if kind == 2 { + raw = unrle(rest, want)?; + &raw + } else { + rest.get(..want).ok_or_else(|| bad("the file is too short for the declared image"))? + }; + let channels = layout.channels(); + let mut out = Vec::new(); + out.try_reserve_exact(wu * hu * channels).map_err(|_| bad("pixel buffer is too large"))?; + let entries = map_len / 3; + for y in 0..hu { + let row = &rows[y * stride..(y + 1) * stride]; + for x in 0..wu { + match depth { + 1 => { + // A set bit is black. + let bit = (row[x / 8] >> (7 - x % 8)) & 1; + out.push(if bit == 1 { 0 } else { 255 }); + } + 8 if map_type == 1 => { + let i = usize::from(row[x]); + if i >= entries { + return Err(bad("pixel index is outside the colour map")); + } + out.extend_from_slice(&[map[i], map[entries + i], map[2 * entries + i]]); + } + 8 => out.push(row[x]), + 24 => { + let p = &row[3 * x..3 * x + 3]; + out.extend_from_slice(&if kind == 3 { [p[0], p[1], p[2]] } else { [p[2], p[1], p[0]] }); + } + _ => { + let p = &row[4 * x..4 * x + 4]; + out.extend_from_slice(&if kind == 3 { [p[1], p[2], p[3], p[0]] } else { [p[3], p[2], p[1], p[0]] }); + } + } + } + } + Image::from_u8(w, h, layout, out) +} + +/// Writes an uncompressed rasterfile: 8-bit gray, 24-bit RGB or 32-bit RGBA, in the RGB-ordered type. +pub(crate) fn encode(src: &Image, plan: Plan) -> Result, CodecError> { + let enc = |msg: String| CodecError::encode(F, msg); + let img = src.converted(plan.layout, plan.sample); + if img.sample_type() != SampleType::U8 { + return Err(enc(format!("Sun raster stores 8 bits per channel, not {:?}", img.sample_type()))); + } + let depth: usize = match img.layout() { + ChannelLayout::Gray => 8, + ChannelLayout::Rgb => 24, + ChannelLayout::Rgba => 32, + l => return Err(enc(format!("no Sun raster layout for {l:?}"))), + }; + let (w, h) = img.dimensions(); + let (wu, hu) = (w as usize, h as usize); + let bytes = depth / 8; + let stride = (wu * bytes).next_multiple_of(2); + let len = stride.checked_mul(hu).and_then(|n| u32::try_from(n).ok()).ok_or_else(|| enc("image too large".into()))?; + let data = img.data(); + if data.len() != wu * hu * bytes { + return Err(enc("the image has the wrong number of samples".into())); + } + let mut out = Vec::with_capacity(HEADER + len as usize); + for v in [MAGIC, w, h, depth as u32, len, 3, 0, 0] { + out.extend_from_slice(&v.to_be_bytes()); + } + for y in 0..hu { + let row = &data[y * wu * bytes..(y + 1) * wu * bytes]; + if depth == 32 { + // Stored alpha first. + for p in row.as_chunks::<4>().0 { + out.extend_from_slice(&[p[3], p[0], p[1], p[2]]); + } + } else { + out.extend_from_slice(row); + } + out.resize(HEADER + (y + 1) * stride, 0); + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn pattern(w: u32, h: u32, layout: ChannelLayout) -> Image { + let n = w as usize * h as usize * layout.channels(); + Image::from_u8(w, h, layout, (0..n).map(|i| ((i * 13 + i / 3) % 253) as u8).collect()).unwrap() + } + + #[test] + fn round_trips_gray_rgb_and_rgba_with_odd_widths() { + for layout in [ChannelLayout::Gray, ChannelLayout::Rgb, ChannelLayout::Rgba] { + let img = pattern(13, 7, layout); + let bytes = encode(&img, Plan { layout, sample: SampleType::U8 }).unwrap(); + assert!(looks_like_sunraster(&bytes)); + let back = decode(&bytes, &Limits::default()).unwrap(); + assert_eq!((back.layout(), back.data()), (layout, img.data())); + } + } + + fn file(depth: u32, kind: u32, map: &[u8], map_type: u32, w: u32, h: u32, data: &[u8]) -> Vec { + let mut f = Vec::new(); + for v in [MAGIC, w, h, depth, data.len() as u32, kind, map_type, map.len() as u32] { + f.extend_from_slice(&v.to_be_bytes()); + } + f.extend_from_slice(map); + f.extend_from_slice(data); + f + } + + #[test] + fn standard_type_is_blue_first_and_rle_expands() { + let f = file(24, 1, &[], 0, 1, 1, &[1, 2, 3, 0]); + assert_eq!(decode(&f, &Limits::default()).unwrap().data(), &[3, 2, 1]); + // 0x80 0x00 is a literal 0x80; 0x80 n v is n + 1 copies of v. The 2x2 image has stride 2. + let f = file(8, 2, &[], 0, 2, 2, &[0x80, 0x00, 0x80, 0x00, 0x80, 0x01, 7]); + assert_eq!(decode(&f, &Limits::default()).unwrap().data(), &[0x80, 0x80, 7, 7]); + // A run that passes the end of the image is an error. + assert!(decode(&file(8, 2, &[], 0, 2, 2, &[0x80, 0x09, 7]), &Limits::default()).is_err()); + } + + #[test] + fn colour_mapped_and_one_bit_files() { + // Two entries: red plane, green plane, blue plane. + let map = [10, 20, 30, 40, 50, 60]; + let f = file(8, 1, &map, 1, 2, 1, &[0, 1]); + let img = decode(&f, &Limits::default()).unwrap(); + assert_eq!((img.layout(), img.data()), (ChannelLayout::Rgb, &[10, 30, 50, 20, 40, 60][..])); + let f = file(8, 1, &map, 1, 1, 1, &[5, 0]); + assert!(decode(&f, &Limits::default()).is_err()); + let f = file(1, 1, &[], 0, 3, 1, &[0b1010_0000, 0]); + assert_eq!(decode(&f, &Limits::default()).unwrap().data(), &[0, 255, 0]); + } + + #[test] + fn hostile_input_is_an_error_not_a_panic() { + let img = pattern(9, 5, ChannelLayout::Rgb); + let good = encode(&img, Plan { layout: ChannelLayout::Rgb, sample: SampleType::U8 }).unwrap(); + for len in 0..good.len() { + let _ = decode(&good[..len], &Limits::default()); + } + let mut huge = good.clone(); + huge[4..8].copy_from_slice(&u32::MAX.to_be_bytes()); + huge[8..12].copy_from_slice(&u32::MAX.to_be_bytes()); + assert!(decode(&huge, &Limits::default()).is_err()); + let mut bad_map = good; + bad_map[28..32].copy_from_slice(&u32::MAX.to_be_bytes()); + assert!(decode(&bad_map, &Limits::default()).is_err()); + assert!(matches!(decode(&file(24, 4, &[], 0, 1, 1, &[0; 4]), &Limits::default()), Err(CodecError::Unsupported { .. }))); + } +} diff --git a/crates/image-codecs/src/format.rs b/crates/image-codecs/src/format.rs index ecaf945cd..d4075cc8e 100644 --- a/crates/image-codecs/src/format.rs +++ b/crates/image-codecs/src/format.rs @@ -44,6 +44,8 @@ pub enum Format { Iff, /// JPEG 2000 (JP2 container or raw J2K codestream): read-only; see [`ASYMMETRIC_EXCEPTIONS`]. Jp2, + /// Sun Raster (`.ras`): 1-, 8-, 24- and 32-bit, uncompressed or RLE. + SunRaster, } /// What a format can hold **and** what this crate reads/writes for it. @@ -113,7 +115,7 @@ const TIFF_LAYOUTS: &[ChannelLayout] = &[L::Gray, L::GrayA, L::Rgb, L::Rgba, L:: impl Format { /// Every format known to the crate (enabled or not). - pub const ALL: [Format; 24] = [ + pub const ALL: [Format; 25] = [ Format::Png, Format::Jpeg, Format::Jp2, @@ -138,6 +140,7 @@ impl Format { Format::Cineon, Format::Dicom, Format::Iff, + Format::SunRaster, ]; pub fn caps(self) -> FormatCaps { @@ -176,6 +179,7 @@ impl Format { Format::Dicom => "DICOM", Format::Iff => "Amiga IFF", Format::Jp2 => "JPEG 2000", + Format::SunRaster => "Sun Raster", } } @@ -207,6 +211,7 @@ impl Format { Format::Dicom => &["dcm", "dicom", "dc3"], Format::Iff => &["iff", "lbm", "ilbm"], Format::Jp2 => &["jp2", "j2k", "j2c", "jpf", "jpx"], + Format::SunRaster => &["ras", "sun"], } } @@ -236,6 +241,7 @@ impl Format { Format::Dicom => "application/dicom", Format::Iff => "image/x-iff", Format::Jp2 => "image/jp2", + Format::SunRaster => "image/x-sun-raster", } } @@ -310,6 +316,7 @@ pub fn caps(format: Format) -> FormatCaps { Format::Cineon => FormatCaps { depths: &[S::U16], layouts: &[L::Gray, L::Rgb], alpha: false, ..base }, Format::Dicom => FormatCaps { read: true, write: false, depths: &[S::U8, S::U16], layouts: &[L::Gray, L::Rgb], alpha: false, ..base }, Format::Iff => FormatCaps { depths: &[S::U8], layouts: &[L::Rgb, L::Rgba], alpha: true, ..base }, + Format::SunRaster => FormatCaps { layouts: &[L::Gray, L::Rgb, L::Rgba], alpha: true, ..base }, Format::Jp2 => FormatCaps { read: true, write: false, layouts: &[L::Gray, L::GrayA, L::Rgb, L::Rgba, L::Cmyk, L::CmykA], icc: true, ..base }, } } @@ -388,6 +395,9 @@ pub fn detect(bytes: &[u8]) -> Option { if b.starts_with(b"/* XPM */") || b.starts_with(b"! XPM2\n") || b.starts_with(b"! XPM2\r\n") { return Some(Format::Xpm); } + if crate::codecs::sunraster::looks_like_sunraster(b) { + return Some(Format::SunRaster); + } if crate::codecs::pcx::looks_like_pcx(b) { return Some(Format::Pcx); } diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 21130e392..ab235d2ab 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -62,7 +62,7 @@ pub use crate::resolution::{exif_resolution, export_exif, export_xmp, photoshop_ pub use crate::source_settings::{WebpEncoding, jpeg_quality, webp_encoding}; pub use half::f16; -use crate::codecs::{dds, dicom, dpx, exr, fits, heif, iff, jp2, jpeg, jxl, pcx, png, pnm, tiff, via_image, webp, xpm}; +use crate::codecs::{dds, dicom, dpx, exr, fits, heif, iff, jp2, jpeg, jxl, pcx, png, pnm, sunraster, tiff, via_image, webp, xpm}; /// Detect the format and decode with default [`Limits`]. pub fn decode(bytes: &[u8]) -> Result { @@ -101,6 +101,7 @@ pub fn decode_as_with(format: Format, bytes: &[u8], opts: &DecodeOptions) -> Res Format::Cineon => dpx::decode_cineon(bytes, l), Format::Dicom => dicom::decode(bytes, l), Format::Iff => iff::decode(bytes, l), + Format::SunRaster => sunraster::decode(bytes, l), Format::OpenExr => exr::decode(bytes, l), Format::Heif => heif::decode(bytes, l, opts.keep_orientation), Format::Jp2 => jp2::decode(bytes, l), @@ -457,6 +458,7 @@ pub fn encode(image: &Image, format: Format, opts: &EncodeOptions) -> Result dpx::encode_cineon(image, plan), Format::Dicom => Err(CodecError::unsupported(format, "DICOM is import-only; save as TIFF or PNG instead")), Format::Iff => iff::encode(image, plan), + Format::SunRaster => sunraster::encode(image, plan), Format::OpenExr => exr::encode(image, plan, opts), Format::Heif => Err(CodecError::unsupported(format, "encoding is not available in this build")), Format::Jp2 => Err(CodecError::unsupported(format, "JPEG 2000 is import-only; save as PNG or TIFF instead")), diff --git a/crates/image-codecs/tests/it/detect_caps.rs b/crates/image-codecs/tests/it/detect_caps.rs index 640772c83..17fb20442 100644 --- a/crates/image-codecs/tests/it/detect_caps.rs +++ b/crates/image-codecs/tests/it/detect_caps.rs @@ -62,6 +62,7 @@ fn default_build_formats_all_symmetric() { Format::Dpx, Format::Cineon, Format::Iff, + Format::SunRaster, ]; for f in expected { assert!(caps(f).read && caps(f).write, "{f:?}"); @@ -218,6 +219,19 @@ fn detect_magic_iff() { assert_eq!(detect(b"FORM\0\0\0\x14AIFF"), None); assert!(decode_as(Format::Iff, b"FORM\0\0\0\x14ILBM").is_err()); } +#[test] +fn detect_magic_sun_raster() { + use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, encode}; + let img = Image::from_u8(5, 3, ChannelLayout::Rgb, (0..45).collect()).unwrap(); + let bytes = encode(&img, Format::SunRaster, &EncodeOptions::default()).unwrap(); + assert_eq!(detect(&bytes), Some(Format::SunRaster)); + assert_eq!(from_extension("scan.RAS"), Some(Format::SunRaster)); + assert_eq!(decode(&bytes).unwrap().data(), img.data()); + assert!(!ASYMMETRIC_EXCEPTIONS.iter().any(|(f, _)| *f == Format::SunRaster)); + assert_eq!(detect(&[0x59, 0xa6, 0x6a, 0x95]), None); + assert!(decode_as(Format::SunRaster, &[0x59, 0xa6, 0x6a, 0x95]).is_err()); +} + #[test] fn detect_magic_avif() { assert_eq!(detect(b"\0\0\0\x1cftypavif\0\0\0\0avifmif1miaf"), Some(Format::Avif)); From ff61266d6337abc59285dd3a6369b23ef0b445a0 Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 12:38:57 +0100 Subject: [PATCH 056/382] craft-audio: QOA (Quite OK Audio) decoder and encoder Adds the qoa module behind the qoa, qoa-decode and qoa-encode features: whole .qoa files, 16-bit, 1 to 8 channels. Streaming files are unsupported. An ffmpeg oracle test checks that ffmpeg decodes our files to exactly the samples our decoder returns. Closes #1541 --- crates/audio/Cargo.toml | 8 + crates/audio/src/lib.rs | 5 +- crates/audio/src/qoa.rs | 411 +++++++++++++++++++++++++++++++ crates/audio/tests/qoa_oracle.rs | 67 +++++ 4 files changed, 490 insertions(+), 1 deletion(-) create mode 100644 crates/audio/src/qoa.rs create mode 100644 crates/audio/tests/qoa_oracle.rs diff --git a/crates/audio/Cargo.toml b/crates/audio/Cargo.toml index c411a0357..645246130 100644 --- a/crates/audio/Cargo.toml +++ b/crates/audio/Cargo.toml @@ -38,6 +38,10 @@ aac-decode = ["craft-media/bitstream"] # The AAC encoder (`aac::Encoder`), and AAC in M4A through `encode` and `FileEncoder`. aac-encode = ["craft-media/bitstream", "craft-media/isobmff"] opus-decode = [] +# QOA (Quite OK Audio) files: decoder and encoder in the `qoa` module, each on its own. +qoa = ["qoa-decode", "qoa-encode"] +qoa-decode = [] +qoa-encode = [] opus-encode = [] ac3-decode = ["craft-media/bitstream"] mpa-decode = ["craft-media/bitstream"] @@ -84,6 +88,10 @@ required-features = ["decode", "lossless-encode", "peaks"] name = "codecs" required-features = ["decode", "encode"] +[[test]] +name = "qoa_oracle" +required-features = ["qoa"] + [[example]] name = "info" required-features = ["decode"] diff --git a/crates/audio/src/lib.rs b/crates/audio/src/lib.rs index 33dcdee3b..d825b4a78 100644 --- a/crates/audio/src/lib.rs +++ b/crates/audio/src/lib.rs @@ -27,7 +27,8 @@ //! - Codec modules for packet-level use, each with its own features: [`aac`] (`aac-decode`, //! `aac-encode`), [`alac`] (`alac-decode`, `alac-encode`), [`opus`] (`opus-decode`, and //! [`opus::encoder`] with `opus-encode`), [`ac3`] (`ac3-decode`), [`mpa`] (`mpa-decode`), [`mp3`] -//! (`mp3-decode`, `mp3-encode`), [`flac`] (`flac-encode`: the packet encoder). +//! (`mp3-decode`, `mp3-encode`), [`flac`] (`flac-encode`: the packet encoder), [`qoa`] +//! (`qoa-decode`, `qoa-encode`: whole QOA files). //! //! The shared types below build with no features. @@ -49,6 +50,8 @@ pub mod opus; mod pcm; #[cfg(feature = "peaks")] pub mod peaks; +#[cfg(any(feature = "qoa-decode", feature = "qoa-encode"))] +pub mod qoa; #[cfg(feature = "decode-native")] mod read; #[cfg(any(feature = "aac-decode", feature = "alac-decode", feature = "opus-decode", feature = "ac3-decode", feature = "mpa-decode"))] diff --git a/crates/audio/src/qoa.rs b/crates/audio/src/qoa.rs new file mode 100644 index 000000000..a04430137 --- /dev/null +++ b/crates/audio/src/qoa.rs @@ -0,0 +1,411 @@ +//! QOA ("Quite OK Audio"): a decoder (feature `qoa-decode`) and an encoder (feature `qoa-encode`) +//! for whole `.qoa` files, 16-bit, 1 to 8 channels. +//! +//! Written from the published QOA specification (qoaformat.org). A file is an 8-byte header (the +//! magic `qoaf` and the number of samples per channel) followed by frames of up to 5120 samples +//! per channel. Each frame starts with its channel count, sample rate, sample count and size, then +//! the state of one 4-tap sign-sign LMS predictor per channel, then 64-bit slices of 20 samples: +//! a 4-bit scale factor and twenty 3-bit quantised residuals, the channels interleaved slice by +//! slice. +//! +//! Streaming files (a sample count of 0 in the header) are not supported. +//! Samples are `i16`, one `Vec` per channel. + +#[cfg(feature = "qoa-decode")] +const MAX_FRAME_SAMPLES: usize = 5120; +const SLICE_SAMPLES: usize = 20; +const LMS_LEN: usize = 4; +const MAGIC: &[u8; 4] = b"qoaf"; +/// The most channels a file may have. +pub const MAX_CHANNELS: usize = 8; + +/// `dequant[scale factor][quantised residual]`: `round(round((sf + 1)^2.75) * [0.75, -0.75, 2.5, +/// -2.5, 4.5, -4.5, 7, -7])`. +const DEQUANT: [[i32; 8]; 16] = [ + [1, -1, 3, -3, 5, -5, 7, -7], + [5, -5, 18, -18, 32, -32, 49, -49], + [16, -16, 53, -53, 95, -95, 147, -147], + [34, -34, 113, -113, 203, -203, 315, -315], + [63, -63, 210, -210, 378, -378, 588, -588], + [104, -104, 345, -345, 621, -621, 966, -966], + [158, -158, 528, -528, 950, -950, 1477, -1477], + [228, -228, 760, -760, 1368, -1368, 2128, -2128], + [316, -316, 1053, -1053, 1895, -1895, 2947, -2947], + [422, -422, 1405, -1405, 2529, -2529, 3934, -3934], + [548, -548, 1828, -1828, 3290, -3290, 5117, -5117], + [696, -696, 2320, -2320, 4176, -4176, 6496, -6496], + [868, -868, 2893, -2893, 5207, -5207, 8099, -8099], + [1064, -1064, 3548, -3548, 6386, -6386, 9933, -9933], + [1286, -1286, 4288, -4288, 7718, -7718, 12005, -12005], + [1536, -1536, 5120, -5120, 9216, -9216, 14336, -14336], +]; + +/// What went wrong reading or writing a QOA file. +#[non_exhaustive] +#[derive(Debug, thiserror::Error, PartialEq, Eq)] +pub enum Error { + /// The input is not a QOA file, or is damaged or truncated. + #[error("malformed QOA: {0}")] + Malformed(&'static str), + /// A valid file this module does not handle (a streaming file). + #[error("unsupported QOA: {0}")] + Unsupported(&'static str), + /// The samples or settings given to the encoder cannot be written as QOA. + #[error("QOA cannot encode: {0}")] + InvalidInput(&'static str), +} + +/// A decoded file. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Audio { + /// Sample rate in Hz (1 to 16 777 215). + pub sample_rate: u32, + /// One `Vec` of samples per channel, all the same length. + pub channels: Vec>, +} + +/// The predictor: the last four samples and four weights. +#[derive(Clone, Copy)] +struct Lms { + history: [i32; LMS_LEN], + weights: [i32; LMS_LEN], +} + +impl Lms { + fn new() -> Self { + Lms { history: [0; LMS_LEN], weights: [0, 0, -(1 << 13), 1 << 14] } + } + + fn predict(&self) -> i32 { + let mut p = 0i32; + for i in 0..LMS_LEN { + p = p.wrapping_add(self.weights[i].wrapping_mul(self.history[i])); + } + p >> 13 + } + + fn update(&mut self, sample: i32, residual: i32) { + let delta = residual >> 4; + for i in 0..LMS_LEN { + self.weights[i] += if self.history[i] < 0 { -delta } else { delta }; + } + self.history.copy_within(1.., 0); + self.history[LMS_LEN - 1] = sample; + } +} + +fn clamp16(v: i32) -> i32 { + v.clamp(-32768, 32767) +} + +#[cfg(feature = "qoa-decode")] +mod decode { + use super::{Audio, DEQUANT, Error, LMS_LEN, Lms, MAGIC, MAX_CHANNELS, MAX_FRAME_SAMPLES, SLICE_SAMPLES, clamp16}; + + fn be16(b: &[u8], i: usize) -> u16 { + u16::from_be_bytes([b[i], b[i + 1]]) + } + + /// Decode a whole `.qoa` file. + /// + /// The declared length is checked against the input before anything is allocated: a slice of + /// 8 bytes holds at most 20 samples, so a file cannot declare more samples than that. + pub fn decode(bytes: &[u8]) -> Result { + if bytes.len() < 8 || &bytes[..4] != MAGIC { + return Err(Error::Malformed("missing the qoaf magic")); + } + let total = u32::from_be_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]) as usize; + if total == 0 { + return Err(Error::Unsupported("streaming files (a sample count of 0)")); + } + if bytes.len() < 16 { + return Err(Error::Malformed("truncated frame header")); + } + let channels = usize::from(bytes[8]); + let sample_rate = u32::from_be_bytes([0, bytes[9], bytes[10], bytes[11]]); + if channels == 0 || channels > MAX_CHANNELS || sample_rate == 0 { + return Err(Error::Malformed("bad channel count or sample rate")); + } + // 8 bytes (20 samples) per channel at the very least, plus the frame headers. + let room = (bytes.len() - 8) / (8 * channels) * SLICE_SAMPLES; + if total > room { + return Err(Error::Malformed("the file is too short for its declared length")); + } + let mut out: Vec> = Vec::new(); + for _ in 0..channels { + let mut v = Vec::new(); + v.try_reserve_exact(total).map_err(|_| Error::Malformed("too many samples"))?; + out.push(v); + } + let mut pos = 8; + let mut done = 0usize; + while done < total { + let head = bytes.get(pos..pos + 8).ok_or(Error::Malformed("truncated frame header"))?; + let rate = u32::from_be_bytes([0, head[1], head[2], head[3]]); + if usize::from(head[0]) != channels || rate != sample_rate { + return Err(Error::Malformed("the channel count or sample rate changes between frames")); + } + let samples = usize::from(be16(head, 4)); + let size = usize::from(be16(head, 6)); + let slices = samples.div_ceil(SLICE_SAMPLES); + if samples == 0 || samples > MAX_FRAME_SAMPLES || samples > total - done { + return Err(Error::Malformed("bad frame sample count")); + } + if size != 8 + 16 * channels + 8 * slices * channels { + return Err(Error::Malformed("frame size does not match its sample count")); + } + let frame = bytes.get(pos..pos + size).ok_or(Error::Malformed("truncated frame"))?; + let mut lms = [Lms::new(); MAX_CHANNELS]; + for (c, state) in lms.iter_mut().take(channels).enumerate() { + let at = 8 + c * 16; + for i in 0..LMS_LEN { + state.history[i] = i32::from(be16(frame, at + 2 * i) as i16); + state.weights[i] = i32::from(be16(frame, at + 8 + 2 * i) as i16); + } + } + let mut at = 8 + 16 * channels; + for s in 0..slices { + let n = (samples - s * SLICE_SAMPLES).min(SLICE_SAMPLES); + for (c, state) in lms.iter_mut().take(channels).enumerate() { + let mut slice = u64::from_be_bytes([ + frame[at], + frame[at + 1], + frame[at + 2], + frame[at + 3], + frame[at + 4], + frame[at + 5], + frame[at + 6], + frame[at + 7], + ]); + at += 8; + let table = &DEQUANT[(slice >> 60) as usize & 15]; + for _ in 0..n { + let dequantised = table[(slice >> 57) as usize & 7]; + slice <<= 3; + let sample = clamp16(state.predict() + dequantised); + out[c].push(sample as i16); + state.update(sample, dequantised); + } + } + } + pos += size; + done += samples; + } + Ok(Audio { sample_rate, channels: out }) + } +} +#[cfg(feature = "qoa-decode")] +pub use decode::decode; + +#[cfg(feature = "qoa-encode")] +mod encode { + use super::{DEQUANT, Error, Lms, MAGIC, MAX_CHANNELS, SLICE_SAMPLES, clamp16}; + + /// The quantised residual (0..8) whose dequantised value is nearest `residual`. + fn quantise(table: &[i32; 8], residual: i32) -> usize { + let mut best = 0; + let mut best_err = i64::MAX; + for (q, &d) in table.iter().enumerate() { + let e = i64::from(residual - d).pow(2); + if e < best_err { + best = q; + best_err = e; + } + } + best + } + + /// Encode one slice of one channel with every scale factor and keep the one with the least + /// squared error. Returns the 64-bit slice; `lms` is advanced to the chosen result. + fn encode_slice(lms: &mut Lms, samples: &[i16]) -> u64 { + let mut best: Option<(i64, u64, Lms)> = None; + for (sf, table) in DEQUANT.iter().enumerate() { + let mut trial = *lms; + let mut slice = sf as u64; + let mut err = 0i64; + for k in 0..SLICE_SAMPLES { + let mut q = 0; + if let Some(&s) = samples.get(k) { + let predicted = trial.predict(); + q = quantise(table, i32::from(s) - predicted); + let sample = clamp16(predicted + table[q]); + err += i64::from(i32::from(s) - sample).pow(2); + trial.update(sample, table[q]); + } + slice = slice << 3 | q as u64; + } + // 4 + 60 bits are in `slice`; the scale factor belongs on top. + let slice = slice & ((1 << 60) - 1) | (sf as u64) << 60; + if best.as_ref().is_none_or(|b| err < b.0) { + best = Some((err, slice, trial)); + } + } + match best { + Some((_, slice, state)) => { + *lms = state; + slice + } + None => 0, + } + } + + /// Encode `channels` (one `Vec` of samples per channel, all the same length) as a `.qoa` file. + pub fn encode(sample_rate: u32, channels: &[Vec]) -> Result, Error> { + let n = channels.len(); + if n == 0 || n > MAX_CHANNELS { + return Err(Error::InvalidInput("QOA stores 1 to 8 channels")); + } + if sample_rate == 0 || sample_rate > 0x00ff_ffff { + return Err(Error::InvalidInput("the sample rate must be 1 to 16777215 Hz")); + } + let total = channels[0].len(); + if channels.iter().any(|c| c.len() != total) { + return Err(Error::InvalidInput("the channels differ in length")); + } + let total32 = u32::try_from(total).map_err(|_| Error::InvalidInput("too many samples"))?; + if total == 0 { + return Err(Error::InvalidInput("QOA cannot store an empty file")); + } + let mut out = Vec::with_capacity(8 + total * n / 2); + out.extend_from_slice(MAGIC); + out.extend_from_slice(&total32.to_be_bytes()); + let mut lms = [Lms::new(); MAX_CHANNELS]; + let mut start = 0; + while start < total { + let len = (total - start).min(5120); + let slices = len.div_ceil(SLICE_SAMPLES); + let size = 8 + 16 * n + 8 * slices * n; + out.push(n as u8); + out.extend_from_slice(&sample_rate.to_be_bytes()[1..]); + out.extend_from_slice(&(len as u16).to_be_bytes()); + out.extend_from_slice(&(size as u16).to_be_bytes()); + // The state a frame starts from is written as 16-bit values, so the predictor + // continues from exactly what a decoder reads. + for state in lms.iter_mut().take(n) { + for v in state.history.iter_mut().chain(state.weights.iter_mut()) { + *v = i32::from(*v as i16); + out.extend_from_slice(&(*v as i16).to_be_bytes()); + } + } + for s in 0..slices { + let from = start + s * SLICE_SAMPLES; + let to = (from + SLICE_SAMPLES).min(start + len); + for (c, state) in lms.iter_mut().take(n).enumerate() { + out.extend_from_slice(&encode_slice(state, &channels[c][from..to]).to_be_bytes()); + } + } + start += len; + } + Ok(out) + } +} +#[cfg(feature = "qoa-encode")] +pub use encode::encode; + +#[cfg(all(test, feature = "qoa-decode", feature = "qoa-encode"))] +mod tests { + use super::*; + + fn tone(frames: usize, ch: usize) -> Vec> { + (0..ch) + .map(|c| (0..frames).map(|i| (((i as f64) * (0.03 + 0.01 * c as f64)).sin() * 12000.0 + ((i * 7919) % 200) as f64) as i16).collect()) + .collect() + } + + fn snr(a: &[i16], b: &[i16]) -> f64 { + let (mut s, mut e) = (0f64, 0f64); + for (&x, &y) in a.iter().zip(b) { + s += f64::from(x).powi(2); + e += (f64::from(x) - f64::from(y)).powi(2); + } + 10.0 * (s / e.max(1.0)).log10() + } + + #[test] + fn dequant_table_matches_its_formula() { + for (sf, row) in DEQUANT.iter().enumerate() { + let scale = ((sf as f64 + 1.0).powf(2.75)).round(); + for (q, base) in [0.75, -0.75, 2.5, -2.5, 4.5, -4.5, 7.0, -7.0].into_iter().enumerate() { + assert_eq!(f64::from(row[q]), (scale * base).round(), "sf {sf} q {q}"); + } + } + } + + #[test] + fn round_trips_with_a_good_signal_to_noise_ratio() { + for (frames, ch) in [(1, 1), (19, 2), (20, 1), (21, 2), (5120, 1), (5121, 2), (12_345, 8)] { + let src = tone(frames, ch); + let bytes = encode(44_100, &src).unwrap(); + let back = decode(&bytes).unwrap(); + assert_eq!((back.sample_rate, back.channels.len(), back.channels[0].len()), (44_100, ch, frames)); + if frames > 1000 { + for (c, (a, b)) in src.iter().zip(&back.channels).enumerate() { + assert!(snr(a, b) > 25.0, "{frames}x{ch} channel {c}"); + } + } + } + } + + #[test] + fn silence_and_full_scale_extremes_survive() { + let silent = vec![vec![0i16; 3000]]; + // No residual value is zero, so silence decodes to a tiny residue, never exactly 0. + let quiet = decode(&encode(8000, &silent).unwrap()).unwrap(); + assert!(quiet.channels[0].iter().all(|&s| s.abs() <= 2), "silence stays within 2 LSB"); + let square: Vec = (0..4000).map(|i| if (i / 50) % 2 == 0 { i16::MAX } else { i16::MIN }).collect(); + let back = decode(&encode(48_000, std::slice::from_ref(&square)).unwrap()).unwrap(); + assert_eq!(back.channels[0].len(), square.len()); + } + + #[test] + fn the_file_has_the_documented_layout() { + let bytes = encode(48_000, &tone(100, 2)).unwrap(); + assert_eq!(&bytes[..4], b"qoaf"); + assert_eq!(u32::from_be_bytes(bytes[4..8].try_into().unwrap()), 100); + assert_eq!(bytes[8], 2); + assert_eq!(&bytes[9..12], &48_000u32.to_be_bytes()[1..]); + assert_eq!(u16::from_be_bytes([bytes[12], bytes[13]]), 100); + // 8 header + 2 channels * 16 state + 5 slices * 2 channels * 8 + assert_eq!(usize::from(u16::from_be_bytes([bytes[14], bytes[15]])), 8 + 32 + 80); + assert_eq!(bytes.len(), 8 + 8 + 32 + 80); + // The first frame starts from the specified predictor state. + assert_eq!(&bytes[16 + 8..16 + 16], &[0, 0, 0, 0, 0xe0, 0, 0x40, 0]); + } + + #[test] + fn invalid_input_to_the_encoder_is_refused() { + assert!(encode(44_100, &[]).is_err()); + assert!(encode(0, &[vec![0; 10]]).is_err()); + assert!(encode(1 << 24, &[vec![0; 10]]).is_err()); + assert!(encode(44_100, &[vec![0; 10], vec![0; 9]]).is_err()); + assert!(encode(44_100, &[vec![]]).is_err()); + assert!(encode(44_100, &vec![vec![0; 10]; 9]).is_err()); + } + + #[test] + fn hostile_input_is_an_error_not_a_panic() { + let good = encode(44_100, &tone(6000, 2)).unwrap(); + for len in 0..good.len().min(600) { + let _ = decode(&good[..len]); + } + assert!(decode(&good[..good.len() - 1]).is_err()); + // A header that declares more samples than the bytes can hold. + let mut huge = good.clone(); + huge[4..8].copy_from_slice(&u32::MAX.to_be_bytes()); + assert!(decode(&huge).is_err()); + // A streaming file, and a frame whose size field lies. + let mut streaming = good.clone(); + streaming[4..8].fill(0); + assert_eq!(decode(&streaming), Err(Error::Unsupported("streaming files (a sample count of 0)"))); + let mut lying = good.clone(); + lying[14] ^= 1; + assert!(decode(&lying).is_err()); + let mut zero_rate = good.clone(); + zero_rate[9..12].fill(0); + assert!(decode(&zero_rate).is_err()); + let mut changed = good; + let second = 8 + usize::from(u16::from_be_bytes([changed[14], changed[15]])); + changed[second] = 1; + assert!(decode(&changed).is_err()); + } +} diff --git a/crates/audio/tests/qoa_oracle.rs b/crates/audio/tests/qoa_oracle.rs new file mode 100644 index 000000000..cf0ed8c37 --- /dev/null +++ b/crates/audio/tests/qoa_oracle.rs @@ -0,0 +1,67 @@ +//! QOA against ffmpeg's decoder as the reference (oracle; skipped when ffmpeg is absent, a failure +//! with `CRAFT_MEDIA_REQUIRE_ORACLES=1`): ffmpeg decodes the files our encoder writes to exactly +//! the samples our decoder returns for them, over several sizes (partial slices, partial frames, +//! several frames), channel counts and rates. + +use craft_audio::qoa::{decode, encode}; +use std::process::Command; + +fn signal(channels: usize, frames: usize) -> Vec> { + let mut seed = 0x2545_F491u32; + (0..channels) + .map(|c| { + (0..frames) + .map(|i| { + seed ^= seed << 13; + seed ^= seed >> 17; + seed ^= seed << 5; + let tone = ((i as f64) * (0.02 + 0.013 * c as f64)).sin() * 9000.0; + // Tones, noise bursts, silence and full-scale peaks. + match (i / 700) % 4 { + 0 => tone as i16, + 1 => (tone + f64::from(seed % 6000) - 3000.0) as i16, + 2 => 0, + _ => { + if i % 2 == 0 { + i16::MAX + } else { + i16::MIN + } + } + } + }) + .collect() + }) + .collect() +} + +#[test] +fn ffmpeg_decodes_our_files_to_the_same_samples() { + let Some(ffmpeg) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("qoa"); + for (rate, channels, frames) in + [(44_100u32, 1usize, 1usize), (8_000, 1, 19), (48_000, 2, 5_121), (22_050, 2, 12_345), (96_000, 1, 20_000), (44_100, 4, 6_000)] + { + let src = signal(channels, frames); + let bytes = encode(rate, &src).expect("encode"); + let ours = decode(&bytes).expect("decode"); + let file = dir.join(format!("ours_{rate}_{channels}_{frames}.qoa")); + std::fs::write(&file, &bytes).expect("write fixture"); + let out = Command::new(&ffmpeg) + .args(["-v", "error", "-y", "-i"]) + .arg(&file) + .args(["-f", "s16le", "-acodec", "pcm_s16le", "-"]) + .output() + .expect("run ffmpeg"); + assert!(out.status.success(), "ffmpeg failed on {}: {}", file.display(), String::from_utf8_lossy(&out.stderr)); + let theirs: Vec = out.stdout.as_chunks::<2>().0.iter().map(|b| i16::from_le_bytes(*b)).collect(); + let mut interleaved = Vec::with_capacity(frames * channels); + for i in 0..frames { + for c in 0..channels { + interleaved.push(ours.channels[c][i]); + } + } + assert_eq!(theirs.len(), interleaved.len(), "{rate} Hz, {channels} ch, {frames} frames: sample count"); + assert!(theirs == interleaved, "{rate} Hz, {channels} ch, {frames} frames: samples differ"); + } +} From 6dfb580c08aeacfb0f30f79900d392394a14e798 Mon Sep 17 00:00:00 2001 From: Trevor Brown Date: Sun, 15 Nov 2026 06:39:11 -0500 Subject: [PATCH 057/382] cms: share annotated CUBE export and integer-depth precision Port header and quantization behavior from PhotoCraft d62728aeae8b331f69ec6d283add3e59fc47924e, retaining compact write_cube behavior. Adaptation and shared tests by Dylan M. Taylor. --- crates/cms/src/lutfile.rs | 71 ++++++++++++++++++++++++++++++++++----- 1 file changed, 63 insertions(+), 8 deletions(-) diff --git a/crates/cms/src/lutfile.rs b/crates/cms/src/lutfile.rs index 404b5a315..ed1207f64 100644 --- a/crates/cms/src/lutfile.rs +++ b/crates/cms/src/lutfile.rs @@ -518,21 +518,47 @@ pub fn parse_look(text: &str) -> Result { LutFile { title: tag("title").unwrap_or_default(), size, data, domain_min: [0.0; 3], domain_max: [1.0; 3] }.check() } +/// Export presentation for a `.cube` table. Compact output preserves the existing writer. +#[derive(Clone, Copy, Debug, Default)] +pub struct CubeWriteOptions<'a> { + /// Add the annotated export header, including the default domain, with this creator. + pub created_by: Option<&'a str>, + /// Clamp to 0..1 and round to 1/32768 steps, for integer-depth export compatibility. + pub quantize_15_bit: bool, +} + /// Writes a `.cube` file (what Photoshop embeds in a Color Lookup layer). pub fn write_cube(l: &LutFile) -> String { + write_cube_with_options(l, CubeWriteOptions::default()) +} + +/// Writes a table with optional annotated headers and integer-depth export quantization. +/// As with [`write_cube`], callers supply a valid table in red-fastest order. +pub fn write_cube_with_options(l: &LutFile, options: CubeWriteOptions<'_>) -> String { let mut s = String::new(); - if !l.title.is_empty() { + if let Some(creator) = options.created_by { + s.push_str(&format!("#Created by: {creator}\n")); + } + if !l.title.is_empty() || options.created_by.is_some() { s.push_str(&format!("TITLE \"{}\"\n", l.title.replace('"', "'"))); } - // The domain is what every row means: a table read with a non-default one must not be - // written back as if it expected inputs in 0..1. `parse_cube` accepts these anywhere. - if !l.domain_is_default() { - s.push_str(&format!("DOMAIN_MIN {} {} {}\n", l.domain_min[0], l.domain_min[1], l.domain_min[2])); - s.push_str(&format!("DOMAIN_MAX {} {} {}\n", l.domain_max[0], l.domain_max[1], l.domain_max[2])); + if options.created_by.is_some() { + s.push_str(&format!("\n#LUT size\nLUT_3D_SIZE {}\n\n#data domain\n", l.size)); + } + // The input domain must survive a write. Annotated exports also spell out the default. + if !l.domain_is_default() || options.created_by.is_some() { + let domain = |v: f32| if options.created_by.is_some() { format!("{v:?}") } else { v.to_string() }; + s.push_str(&format!("DOMAIN_MIN {} {} {}\n", domain(l.domain_min[0]), domain(l.domain_min[1]), domain(l.domain_min[2]))); + s.push_str(&format!("DOMAIN_MAX {} {} {}\n", domain(l.domain_max[0]), domain(l.domain_max[1]), domain(l.domain_max[2]))); + } + if options.created_by.is_some() { + s.push_str("\n#LUT data points\n"); + } else { + s.push_str(&format!("LUT_3D_SIZE {}\n", l.size)); } - s.push_str(&format!("LUT_3D_SIZE {}\n", l.size)); for c in l.data.as_chunks::<3>().0 { - s.push_str(&format!("{:.6} {:.6} {:.6}\n", c[0], c[1], c[2])); + let value = |v: f32| if options.quantize_15_bit { (v.clamp(0.0, 1.0) * 32768.0).round() / 32768.0 } else { v }; + s.push_str(&format!("{:.6} {:.6} {:.6}\n", value(c[0]), value(c[1]), value(c[2]))); } s } @@ -1299,4 +1325,33 @@ LUT_3D_SIZE 2 assert_eq!(back.domain_min, l.domain_min, "the written table must mean the same"); assert_eq!(back.domain_max, l.domain_max); } + #[test] + fn annotated_cube_export_preserves_header_and_integer_precision() { + let mut lut = LutFile::identity(2).unwrap(); + lut.title = "My \"Look\"".into(); + lut.data[..3].copy_from_slice(&[1.0 / 6.0, 5.0 / 6.0, 160.0 / 255.0]); + let output = write_cube_with_options(&lut, CubeWriteOptions { created_by: Some("PhotoCraft"), quantize_15_bit: true }); + assert!(output.starts_with("#Created by: PhotoCraft\nTITLE \"My 'Look'\"\n\n#LUT size\nLUT_3D_SIZE 2\n\n#data domain\nDOMAIN_MIN 0.0 0.0 0.0\nDOMAIN_MAX 1.0 1.0 1.0\n\n#LUT data points\n0.166656 0.833344 0.627441\n")); + assert_eq!(output.lines().count(), 11 + 8); + let parsed = parse_cube(&output).unwrap(); + assert_eq!(parsed.size, 2); + assert_eq!(&parsed.data[3..], &lut.data[3..]); + let float = write_cube_with_options(&lut, CubeWriteOptions { created_by: Some("PhotoCraft"), quantize_15_bit: false }); + assert!(float.contains("0.166667 0.833333 0.627451\n")); + } + + #[test] + fn annotated_domain_and_empty_title_roundtrip() { + let mut lut = LutFile::identity(2).unwrap(); + lut.title.clear(); + lut.domain_min = [-1.0, 0.25, 0.5]; + lut.domain_max = [2.0, 0.75, 1.5]; + let text = write_cube_with_options(&lut, CubeWriteOptions { created_by: Some("Exporter"), ..Default::default() }); + assert!(text.contains("TITLE \"\"\n")); + let back = parse_cube(&text).unwrap(); + assert_eq!(back.domain_min, lut.domain_min); + assert_eq!(back.domain_max, lut.domain_max); + assert_eq!(back.data, lut.data); + assert_eq!(write_cube(&lut), write_cube_with_options(&lut, CubeWriteOptions::default())); + } } From c4ed8d3a84caf683132e51db94293e3aab3b111b Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 06:49:49 -0500 Subject: [PATCH 058/382] cms: stream annotated export rows through the existing CUBE formatter --- crates/cms/src/lutfile.rs | 84 +++++++++++++++++---------------------- 1 file changed, 37 insertions(+), 47 deletions(-) diff --git a/crates/cms/src/lutfile.rs b/crates/cms/src/lutfile.rs index ed1207f64..0e8767dc6 100644 --- a/crates/cms/src/lutfile.rs +++ b/crates/cms/src/lutfile.rs @@ -518,51 +518,48 @@ pub fn parse_look(text: &str) -> Result { LutFile { title: tag("title").unwrap_or_default(), size, data, domain_min: [0.0; 3], domain_max: [1.0; 3] }.check() } -/// Export presentation for a `.cube` table. Compact output preserves the existing writer. -#[derive(Clone, Copy, Debug, Default)] -pub struct CubeWriteOptions<'a> { - /// Add the annotated export header, including the default domain, with this creator. - pub created_by: Option<&'a str>, - /// Clamp to 0..1 and round to 1/32768 steps, for integer-depth export compatibility. - pub quantize_15_bit: bool, -} - /// Writes a `.cube` file (what Photoshop embeds in a Color Lookup layer). pub fn write_cube(l: &LutFile) -> String { - write_cube_with_options(l, CubeWriteOptions::default()) -} - -/// Writes a table with optional annotated headers and integer-depth export quantization. -/// As with [`write_cube`], callers supply a valid table in red-fastest order. -pub fn write_cube_with_options(l: &LutFile, options: CubeWriteOptions<'_>) -> String { let mut s = String::new(); - if let Some(creator) = options.created_by { - s.push_str(&format!("#Created by: {creator}\n")); - } - if !l.title.is_empty() || options.created_by.is_some() { + if !l.title.is_empty() { s.push_str(&format!("TITLE \"{}\"\n", l.title.replace('"', "'"))); } - if options.created_by.is_some() { - s.push_str(&format!("\n#LUT size\nLUT_3D_SIZE {}\n\n#data domain\n", l.size)); + // The domain is what every row means: a table read with a non-default one must not be + // written back as if it expected inputs in 0..1. `parse_cube` accepts these anywhere. + if !l.domain_is_default() { + s.push_str(&format!("DOMAIN_MIN {} {} {}\n", l.domain_min[0], l.domain_min[1], l.domain_min[2])); + s.push_str(&format!("DOMAIN_MAX {} {} {}\n", l.domain_max[0], l.domain_max[1], l.domain_max[2])); } - // The input domain must survive a write. Annotated exports also spell out the default. - if !l.domain_is_default() || options.created_by.is_some() { - let domain = |v: f32| if options.created_by.is_some() { format!("{v:?}") } else { v.to_string() }; - s.push_str(&format!("DOMAIN_MIN {} {} {}\n", domain(l.domain_min[0]), domain(l.domain_min[1]), domain(l.domain_min[2]))); - s.push_str(&format!("DOMAIN_MAX {} {} {}\n", domain(l.domain_max[0]), domain(l.domain_max[1]), domain(l.domain_max[2]))); - } - if options.created_by.is_some() { - s.push_str("\n#LUT data points\n"); - } else { - s.push_str(&format!("LUT_3D_SIZE {}\n", l.size)); - } - for c in l.data.as_chunks::<3>().0 { - let value = |v: f32| if options.quantize_15_bit { (v.clamp(0.0, 1.0) * 32768.0).round() / 32768.0 } else { v }; - s.push_str(&format!("{:.6} {:.6} {:.6}\n", value(c[0]), value(c[1]), value(c[2]))); + s.push_str(&format!("LUT_3D_SIZE {}\n", l.size)); + cube_rows(s, l.data.as_chunks::<3>().0.iter().copied()) +} + +fn cube_rows(mut s: String, rows: impl Iterator) -> String { + for c in rows { + s.push_str(&format!("{:.6} {:.6} {:.6}\n", c[0], c[1], c[2])); } s } +/// Annotated identity-domain CUBE export, streamed in red-fastest order without a table copy. +/// Callers supply exactly `size³` rows for a valid size (2..=[`MAX_SIZE`]), as with [`write_cube`]. +/// Integer-depth exports clamp/round to 1/32768 steps; floating exports clamp without rounding. +pub fn write_cube_export(creator: &str, title: &str, size: usize, integer_depth: bool, rows: impl Iterator) -> String { + let s = format!( + "#Created by: {creator}\nTITLE \"{}\"\n\n#LUT size\nLUT_3D_SIZE {size}\n\n#data domain\nDOMAIN_MIN 0.0 0.0 0.0\nDOMAIN_MAX 1.0 1.0 1.0\n\n#LUT data points\n", + title.replace('"', "'") + ); + cube_rows( + s, + rows.map(|c| { + c.map(|v| { + let v = v.clamp(0.0, 1.0); + if integer_depth { (v * 32768.0).round() / 32768.0 } else { v } + }) + }), + ) +} + fn luma(c: [f32; 3]) -> f32 { 0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2] } @@ -1330,28 +1327,21 @@ LUT_3D_SIZE 2 let mut lut = LutFile::identity(2).unwrap(); lut.title = "My \"Look\"".into(); lut.data[..3].copy_from_slice(&[1.0 / 6.0, 5.0 / 6.0, 160.0 / 255.0]); - let output = write_cube_with_options(&lut, CubeWriteOptions { created_by: Some("PhotoCraft"), quantize_15_bit: true }); + let output = write_cube_export("PhotoCraft", &lut.title, lut.size, true, lut.data.as_chunks::<3>().0.iter().copied()); assert!(output.starts_with("#Created by: PhotoCraft\nTITLE \"My 'Look'\"\n\n#LUT size\nLUT_3D_SIZE 2\n\n#data domain\nDOMAIN_MIN 0.0 0.0 0.0\nDOMAIN_MAX 1.0 1.0 1.0\n\n#LUT data points\n0.166656 0.833344 0.627441\n")); assert_eq!(output.lines().count(), 11 + 8); let parsed = parse_cube(&output).unwrap(); assert_eq!(parsed.size, 2); assert_eq!(&parsed.data[3..], &lut.data[3..]); - let float = write_cube_with_options(&lut, CubeWriteOptions { created_by: Some("PhotoCraft"), quantize_15_bit: false }); + let float = write_cube_export("PhotoCraft", &lut.title, lut.size, false, lut.data.as_chunks::<3>().0.iter().copied()); assert!(float.contains("0.166667 0.833333 0.627451\n")); } #[test] - fn annotated_domain_and_empty_title_roundtrip() { - let mut lut = LutFile::identity(2).unwrap(); - lut.title.clear(); - lut.domain_min = [-1.0, 0.25, 0.5]; - lut.domain_max = [2.0, 0.75, 1.5]; - let text = write_cube_with_options(&lut, CubeWriteOptions { created_by: Some("Exporter"), ..Default::default() }); + fn annotated_empty_title_and_float_clamping() { + let text = write_cube_export("Exporter", "", 2, false, std::iter::repeat_n([-0.5, 0.25, 1.5], 8)); assert!(text.contains("TITLE \"\"\n")); let back = parse_cube(&text).unwrap(); - assert_eq!(back.domain_min, lut.domain_min); - assert_eq!(back.domain_max, lut.domain_max); - assert_eq!(back.data, lut.data); - assert_eq!(write_cube(&lut), write_cube_with_options(&lut, CubeWriteOptions::default())); + assert_eq!(back.data, [0.0, 0.25, 1.0].repeat(8)); } } From 3ce92b332db8fa1f8d33214d299e88096263c007 Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 12:53:20 +0100 Subject: [PATCH 059/382] craft-image-codecs: JPEG-LS (ITU-T T.87) reader and writer Adds Format::JpegLs: lossless and near-lossless gray and RGB, 2 to 16 bits. Reads scans that code one component each; writes lossless 8- and 16-bit gray and RGB. Line- and sample-interleaved scans, mapping tables and colour transforms are reported as unsupported. Closes #1558 --- Cargo.lock | 1 + crates/image-codecs/Cargo.toml | 1 + crates/image-codecs/README.md | 1 + crates/image-codecs/src/codecs.rs | 1 + crates/image-codecs/src/codecs/jpegls.rs | 870 ++++++++++++++++++ crates/image-codecs/src/format.rs | 14 +- crates/image-codecs/src/lib.rs | 4 +- crates/image-codecs/tests/it/detect_caps.rs | 16 + crates/image-codecs/tests/it/jpegls_oracle.rs | 103 +++ crates/image-codecs/tests/it/main.rs | 1 + 10 files changed, 1009 insertions(+), 3 deletions(-) create mode 100644 crates/image-codecs/src/codecs/jpegls.rs create mode 100644 crates/image-codecs/tests/it/jpegls_oracle.rs diff --git a/Cargo.lock b/Cargo.lock index 9a600099d..55ab615b8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1919,6 +1919,7 @@ dependencies = [ "avif-serialize", "craft-heif", "craft-jpeg", + "craft-media-testkit", "craft-metadata", "exr", "flate2", diff --git a/crates/image-codecs/Cargo.toml b/crates/image-codecs/Cargo.toml index dc920f14b..5281fe2cf 100644 --- a/crates/image-codecs/Cargo.toml +++ b/crates/image-codecs/Cargo.toml @@ -46,6 +46,7 @@ exr = { version = "1.73", default-features = false, features = ["rayon"] } proptest = { workspace = true } image = { version = "0.25", default-features = false, features = ["png", "jpeg", "tiff"] } sha2 = { version = "0.10", default-features = false, features = ["std"] } +craft-media-testkit = { workspace = true } [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies] jxl-oxide = { version = "=0.12.6", default-features = false, features = ["rayon"] } diff --git a/crates/image-codecs/README.md b/crates/image-codecs/README.md index 6e9e11617..a67be77c5 100644 --- a/crates/image-codecs/README.md +++ b/crates/image-codecs/README.md @@ -56,6 +56,7 @@ craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "< | Cineon | yes | yes | U16 (10-bit code values read and written exactly through U16) | Gray, RGB | no | no | no | no | no | no | no | built in | | DICOM | yes | **no** | U8, U16 | Gray, RGB | no | no | no | no | no | no | n/a | built in | | Amiga IFF (ILBM/PBM) | yes | yes (24-bit ILBM) | U8 | RGB, RGBA | yes (1-bit mask plane on write) | no | no | no | no | no | no | built in | +| JPEG-LS (`.jls`) | yes (any NEAR; one scan per component) | yes (lossless) | U8, U16 | Gray, RGB | no | no | no | no | no | no | no | built in | | AVIF | **no** | only with feature `avif` | U8 | RGB, RGBA | yes | no | no | no | no | no | yes | `image` + `ravif` | | HEIF/HEIC | with feature `heif` | **no** | U8, U16 (10/12-bit decodes to U16) | RGB, RGBA | yes (auxiliary alpha) | yes (`colr` prof) | yes | yes | no | no | n/a | `heic-rs` | diff --git a/crates/image-codecs/src/codecs.rs b/crates/image-codecs/src/codecs.rs index 0288ae22b..af91aa536 100644 --- a/crates/image-codecs/src/codecs.rs +++ b/crates/image-codecs/src/codecs.rs @@ -13,6 +13,7 @@ pub(crate) mod heif; pub(crate) mod iff; pub(crate) mod jp2; pub(crate) mod jpeg; +pub(crate) mod jpegls; pub(crate) mod jxl; pub(crate) mod pcx; pub(crate) mod png; diff --git a/crates/image-codecs/src/codecs/jpegls.rs b/crates/image-codecs/src/codecs/jpegls.rs new file mode 100644 index 000000000..b405e71ed --- /dev/null +++ b/crates/image-codecs/src/codecs/jpegls.rs @@ -0,0 +1,870 @@ +//! JPEG-LS (ITU-T T.87 | ISO/IEC 14495-1, "LOCO-I"): lossless and near-lossless gray and RGB +//! images, 2 to 16 bits per sample. +//! +//! Read: baseline JPEG-LS with the default or `LSE`-preset coding parameters, any `NEAR`, and +//! scans that code one component each (`ILV` 0), which is also how this module writes. Line- and +//! sample-interleaved scans, colour transforms and mapping tables are reported as unsupported. +//! Write: lossless (`NEAR` 0), 8 or 16 bits, gray or RGB, one scan per component. +//! +//! Samples of 9 to 15 bits are scaled to 16 bits on read (the top bits are repeated into the low +//! ones), so a decoded image always spans the full range of its sample type. + +use crate::error::CodecError; +use crate::fidelity::Plan; +use crate::format::Format; +use crate::image::{ChannelLayout, Image, SampleType}; +use crate::options::Limits; + +const F: Format = Format::JpegLs; +const SOF55: u8 = 0xF7; +const LSE: u8 = 0xF8; +const RESET_DEFAULT: i32 = 64; +const MIN_C: i32 = -128; +const MAX_C: i32 = 127; +/// `J[RUNindex]`: the log2 of the run length a run-index step codes. +const J: [u32; 32] = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 9, 10, 11, 12, 13, 14, 15]; +/// Context slots: the regular contexts (365 of the 405 slots the index below can reach), then the two +/// run-interruption contexts. +const RI_BASE: usize = 405; +const CONTEXTS: usize = RI_BASE + 2; + +fn bad(reason: impl std::fmt::Display) -> CodecError { + CodecError::malformed(F, reason) +} + +/// Whether `b` is a JPEG-LS file: an SOI followed by marker segments up to an SOF55 frame header. +pub(crate) fn looks_like_jpegls(b: &[u8]) -> bool { + if !b.starts_with(&[0xFF, 0xD8]) { + return false; + } + let mut pos = 2; + for _ in 0..64 { + let (Some(&0xFF), Some(&marker)) = (b.get(pos), b.get(pos + 1)) else { return false }; + match marker { + SOF55 => return true, + 0xDA | 0xD9 => return false, + 0xC0..=0xCF | 0xDB..=0xDF => return false, + 0x01 | 0xD0..=0xD7 | 0xFF => pos += if marker == 0xFF { 1 } else { 2 }, + _ => { + let Some(len) = b.get(pos + 2..pos + 4).map(|l| usize::from(u16::from_be_bytes([l[0], l[1]]))) else { return false }; + pos += 2 + len; + } + } + } + false +} + +/// The coding parameters of one scan, derived as T.87 section C.2 specifies. +#[derive(Clone, Copy)] +struct Params { + maxval: i32, + near: i32, + range: i32, + qbpp: u32, + limit: u32, + t1: i32, + t2: i32, + t3: i32, + reset: i32, +} + +fn ceil_log2(v: i32) -> u32 { + let mut n = 0; + while (1i64 << n) < i64::from(v) { + n += 1; + } + n +} + +impl Params { + /// `preset` holds the `LSE` values (`maxval`, `t1`, `t2`, `t3`, `reset`), 0 where absent. + fn new(precision: u32, near: i32, preset: [i32; 5]) -> Result { + let default_max = (1i32 << precision) - 1; + let maxval = if preset[0] == 0 { default_max } else { preset[0] }; + if maxval < 1 || maxval > default_max || near < 0 || near > (maxval / 2).min(255) { + return Err(bad("invalid MAXVAL or NEAR")); + } + let clamp = |v: i32, lo: i32, hi: i32| if v > hi || v < lo { lo } else { v }; + let (d1, d2, d3) = if maxval >= 128 { + let factor = (maxval.min(4095) + 128) / 256; + let t1 = clamp(factor + 2 + 3 * near, near + 1, maxval); + let t2 = clamp(factor * 4 + 3 + 5 * near, t1, maxval); + let t3 = clamp(factor * 17 + 4 + 7 * near, t2, maxval); + (t1, t2, t3) + } else { + let factor = 256 / (maxval + 1); + let t1 = clamp((3 / factor + 3 * near).max(2), near + 1, maxval); + let t2 = clamp((7 / factor + 5 * near).max(3), t1, maxval); + let t3 = clamp((21 / factor + 7 * near).max(4), t2, maxval); + (t1, t2, t3) + }; + let t1 = if preset[1] == 0 { d1 } else { preset[1] }; + let t2 = if preset[2] == 0 { d2 } else { preset[2] }; + let t3 = if preset[3] == 0 { d3 } else { preset[3] }; + let reset = if preset[4] == 0 { RESET_DEFAULT } else { preset[4] }; + if !(near < t1 && t1 <= t2 && t2 <= t3 && t3 <= maxval) || !(3..=255).contains(&reset) { + return Err(bad("invalid threshold or RESET preset")); + } + let range = (maxval + 2 * near) / (2 * near + 1) + 1; + let bpp = ceil_log2(maxval + 1).max(2); + Ok(Params { maxval, near, range, qbpp: ceil_log2(range), limit: 2 * (bpp + bpp.max(8)), t1, t2, t3, reset }) + } +} + +/// Adaptive state of one scan: contexts, bias and the run index. +struct State { + a: [i32; CONTEXTS], + b: [i32; CONTEXTS], + c: [i32; CONTEXTS], + n: [i32; CONTEXTS], + nn: [i32; 2], + run_index: usize, +} + +impl State { + fn new(p: &Params) -> State { + let a0 = ((p.range + 32) / 64).max(2); + State { a: [a0; CONTEXTS], b: [0; CONTEXTS], c: [0; CONTEXTS], n: [1; CONTEXTS], nn: [0; 2], run_index: 0 } + } +} + +fn quantise_gradient(d: i32, p: &Params) -> i32 { + if d <= -p.t3 { + -4 + } else if d <= -p.t2 { + -3 + } else if d <= -p.t1 { + -2 + } else if d < -p.near { + -1 + } else if d <= p.near { + 0 + } else if d < p.t1 { + 1 + } else if d < p.t2 { + 2 + } else if d < p.t3 { + 3 + } else { + 4 + } +} + +fn predict(ra: i32, rb: i32, rc: i32) -> i32 { + if rc >= ra.max(rb) { + ra.min(rb) + } else if rc <= ra.min(rb) { + ra.max(rb) + } else { + ra + rb - rc + } +} + +/// The error quantised for `NEAR` and reduced into the modulo range, as the encoder codes it. +fn reduce(mut e: i32, p: &Params) -> i32 { + if p.near > 0 { + e = if e > 0 { (e + p.near) / (2 * p.near + 1) } else { -(p.near - e) / (2 * p.near + 1) }; + } + if e < 0 { + e += p.range; + } + if e >= (p.range + 1) / 2 { + e -= p.range; + } + e +} + +/// The reconstructed sample for a decoded (sign-adjusted) error. +fn reconstruct(px: i32, sign: i32, e: i32, p: &Params) -> i32 { + let mut r = px + sign * e * (2 * p.near + 1); + if r < -p.near { + r += p.range * (2 * p.near + 1); + } else if r > p.maxval + p.near { + r -= p.range * (2 * p.near + 1); + } + r.clamp(0, p.maxval) +} + +fn golomb_k(n: i32, a: i32) -> u32 { + let mut k = 0; + while (i64::from(n) << k) < i64::from(a) { + k += 1; + } + k +} + +/// Bits of the entropy-coded segment, with T.87's stuffing: after an `0xFF` byte the next byte +/// carries only 7 bits. +struct BitReader<'a> { + data: &'a [u8], + pos: usize, + cur: u32, + left: u32, + prev_ff: bool, +} + +impl<'a> BitReader<'a> { + fn new(data: &'a [u8]) -> Self { + BitReader { data, pos: 0, cur: 0, left: 0, prev_ff: false } + } + + fn bit(&mut self) -> Result { + if self.left == 0 { + let byte = *self.data.get(self.pos).ok_or_else(|| bad("the entropy-coded data ends early"))?; + self.pos += 1; + if self.prev_ff { + if byte & 0x80 != 0 { + return Err(bad("a marker inside entropy-coded data")); + } + self.cur = u32::from(byte); + self.left = 7; + } else { + self.cur = u32::from(byte); + self.left = 8; + } + self.prev_ff = byte == 0xFF; + } + self.left -= 1; + Ok((self.cur >> self.left) & 1) + } + + fn bits(&mut self, n: u32) -> Result { + let mut v = 0; + for _ in 0..n { + v = v << 1 | self.bit()?; + } + Ok(v) + } + + /// A limited-length Golomb code: the mapped error. + fn golomb(&mut self, k: u32, limit: u32, qbpp: u32) -> Result { + let max_zeros = limit.checked_sub(qbpp + 1).ok_or_else(|| bad("invalid LIMIT"))?; + let mut zeros = 0; + while self.bit()? == 0 { + zeros += 1; + if zeros > max_zeros { + return Err(bad("a Golomb code is longer than LIMIT")); + } + } + let v = if zeros < max_zeros { (zeros << k) + self.bits(k)? } else { self.bits(qbpp)? + 1 }; + i32::try_from(v).map_err(|_| bad("mapped error out of range")) + } +} + +/// Decode one component scan of `w` x `h` samples into `out` (row-major). +fn decode_scan(data: &[u8], w: usize, h: usize, p: &Params, out: &mut [u16]) -> Result<(), CodecError> { + let mut r = BitReader::new(data); + let mut st = State::new(p); + let mut prev = vec![0i32; w + 2]; + let mut cur = vec![0i32; w + 2]; + for y in 0..h { + // Ra at the first sample is Rb; the slot at index 0 is Rc there, left over from the line above. + cur[0] = prev[1]; + if y > 0 { + prev[w + 1] = prev[w]; + } + let mut x = 0usize; + while x < w { + let (ra, rb, rc, rd) = (cur[x], prev[x + 1], prev[x], if y == 0 { 0 } else { prev[x + 2] }); + let (q1, q2, q3) = (quantise_gradient(rd - rb, p), quantise_gradient(rb - rc, p), quantise_gradient(rc - ra, p)); + if q1 == 0 && q2 == 0 && q3 == 0 { + x = decode_run(&mut r, &mut st, p, &prev, &mut cur, ra, x, w)?; + continue; + } + let (sign, q1, q2, q3) = if q1 < 0 || (q1 == 0 && (q2 < 0 || (q2 == 0 && q3 < 0))) { (-1, -q1, -q2, -q3) } else { (1, q1, q2, q3) }; + let q = (q1 * 81 + (q2 + 4) * 9 + (q3 + 4)) as usize; + let k = golomb_k(st.n[q], st.a[q]); + let m = r.golomb(k, p.limit, p.qbpp)?; + let swap = p.near == 0 && k == 0 && 2 * st.b[q] <= -st.n[q]; + let e = if swap { + if m & 1 == 1 { (m - 1) >> 1 } else { -(m >> 1) - 1 } + } else if m & 1 == 0 { + m >> 1 + } else { + -((m + 1) >> 1) + }; + let px = (predict(ra, rb, rc) + sign * st.c[q]).clamp(0, p.maxval); + let rx = reconstruct(px, sign, e, p); + update_regular(&mut st, q, e, p); + cur[x + 1] = rx; + x += 1; + } + let row = &mut out[y * w..(y + 1) * w]; + for (o, &v) in row.iter_mut().zip(&cur[1..=w]) { + *o = v as u16; + } + // The line just decoded becomes the line above; its slot 0 is the Rc of the next line's first sample. + std::mem::swap(&mut prev, &mut cur); + } + Ok(()) +} + +fn update_regular(st: &mut State, q: usize, e: i32, p: &Params) { + st.b[q] += e * (2 * p.near + 1); + st.a[q] += e.abs(); + if st.n[q] == p.reset { + st.a[q] >>= 1; + st.b[q] = if st.b[q] >= 0 { st.b[q] >> 1 } else { -((1 - st.b[q]) >> 1) }; + st.n[q] >>= 1; + } + st.n[q] += 1; + if st.b[q] <= -st.n[q] { + if st.c[q] > MIN_C { + st.c[q] -= 1; + } + st.b[q] += st.n[q]; + if st.b[q] <= -st.n[q] { + st.b[q] = -st.n[q] + 1; + } + } else if st.b[q] > 0 { + if st.c[q] < MAX_C { + st.c[q] += 1; + } + st.b[q] -= st.n[q]; + if st.b[q] > 0 { + st.b[q] = 0; + } + } +} + +/// Run-interruption variables update shared by both directions. +fn update_run(st: &mut State, q: usize, e: i32, em: i32, ri_type: i32, p: &Params) { + let i = q - RI_BASE; + if e < 0 { + st.nn[i] += 1; + } + st.a[q] += (em + 1 - ri_type) >> 1; + if st.n[q] == p.reset { + st.a[q] >>= 1; + st.n[q] >>= 1; + st.nn[i] >>= 1; + } + st.n[q] += 1; +} + +/// The run-interruption Golomb parameter and the mapping flag of an error. +fn run_k(st: &State, q: usize, ri_type: i32) -> u32 { + let temp = if ri_type == 1 { st.a[q] + (st.n[q] >> 1) } else { st.a[q] }; + golomb_k(st.n[q], temp) +} + +#[allow(clippy::too_many_arguments)] +fn decode_run( + r: &mut BitReader, + st: &mut State, + p: &Params, + prev: &[i32], + cur: &mut [i32], + ra: i32, + x: usize, + w: usize, +) -> Result { + let remaining = w - x; + let mut run = 0usize; + while r.bit()? == 1 { + let step = 1usize << J[st.run_index]; + let count = step.min(remaining - run); + run += count; + if count == step && st.run_index < 31 { + st.run_index += 1; + } + if run == remaining { + break; + } + } + if run < remaining { + let rest = r.bits(J[st.run_index])? as usize; + run += rest; + if run > remaining { + return Err(bad("a run passes the end of the line")); + } + } + for v in &mut cur[x + 1..x + 1 + run] { + *v = ra; + } + if run == remaining { + return Ok(w); + } + // The sample that ended the run: its own Rb, the sample above it. + let rb = prev[x + run + 1]; + let ri_type = i32::from((ra - rb).abs() <= p.near); + let q = RI_BASE + ri_type as usize; + let k = run_k(st, q, ri_type); + let limit = p.limit - J[st.run_index] - 1; + let em = r.golomb(k, limit, p.qbpp)?; + let tmp = em + ri_type; + let cond = k == 0 && 2 * st.nn[ri_type as usize] < st.n[q]; + let map = tmp & 1; + let mag = (tmp + map) / 2; + let e = if (cond && map == 1) || (!cond && map == 0) { mag } else { -mag }; + let (px, sign) = if ri_type == 1 { (ra, 1) } else { (rb, if ra > rb { -1 } else { 1 }) }; + // The decoder holds the sign-adjusted error; the sign flips the reconstruction. + let rx = reconstruct(px, sign, e, p); + update_run(st, q, e, em, ri_type, p); + if st.run_index > 0 { + st.run_index -= 1; + } + cur[x + run + 1] = rx; + Ok(x + run + 1) +} + +// ---- encoder ---- + +struct BitWriter { + out: Vec, + cur: u32, + used: u32, + cap: u32, +} + +impl BitWriter { + fn new() -> Self { + BitWriter { out: Vec::new(), cur: 0, used: 0, cap: 8 } + } + + fn put(&mut self, value: u32, n: u32) { + for i in (0..n).rev() { + // A run of more than 32 zero bits (a long escape code) has no bits of `value` to shift out. + let bit = if i < 32 { (value >> i) & 1 } else { 0 }; + self.cur = self.cur << 1 | bit; + self.used += 1; + if self.used == self.cap { + let byte = self.cur as u8; + self.out.push(byte); + self.cap = if byte == 0xFF { 7 } else { 8 }; + self.cur = 0; + self.used = 0; + } + } + } + + /// Pad the last byte with zero bits; a closing 0xFF is followed by a zero byte. + fn finish(mut self) -> Vec { + if self.used > 0 { + let pad = self.cap - self.used; + self.put(0, pad); + } + if self.out.last() == Some(&0xFF) { + self.out.push(0); + } + self.out + } + + fn golomb(&mut self, m: i32, k: u32, limit: u32, qbpp: u32) { + let m = m as u32; + let max_zeros = limit - qbpp - 1; + let q = m >> k; + if q < max_zeros { + self.put(0, q); + self.put(1, 1); + self.put(m & ((1 << k) - 1), k); + } else { + self.put(0, max_zeros); + self.put(1, 1); + self.put(m - 1, qbpp); + } + } +} + +fn encode_scan(plane: &[u16], w: usize, h: usize, p: &Params) -> Vec { + let mut wr = BitWriter::new(); + let mut st = State::new(p); + let mut prev = vec![0i32; w + 2]; + let mut cur = vec![0i32; w + 2]; + for y in 0..h { + cur[0] = prev[1]; + if y > 0 { + prev[w + 1] = prev[w]; + } + let line = &plane[y * w..(y + 1) * w]; + let mut x = 0usize; + while x < w { + let (ra, rb, rc, rd) = (cur[x], prev[x + 1], prev[x], if y == 0 { 0 } else { prev[x + 2] }); + let ix = i32::from(line[x]); + let (q1, q2, q3) = (quantise_gradient(rd - rb, p), quantise_gradient(rb - rc, p), quantise_gradient(rc - ra, p)); + if q1 == 0 && q2 == 0 && q3 == 0 { + x = encode_run(&mut wr, &mut st, p, line, &prev, &mut cur, ra, x); + continue; + } + let (sign, q1, q2, q3) = if q1 < 0 || (q1 == 0 && (q2 < 0 || (q2 == 0 && q3 < 0))) { (-1, -q1, -q2, -q3) } else { (1, q1, q2, q3) }; + let q = (q1 * 81 + (q2 + 4) * 9 + (q3 + 4)) as usize; + let px = (predict(ra, rb, rc) + sign * st.c[q]).clamp(0, p.maxval); + let e = reduce(sign * (ix - px), p); + let k = golomb_k(st.n[q], st.a[q]); + let swap = p.near == 0 && k == 0 && 2 * st.b[q] <= -st.n[q]; + let m = if swap { + if e >= 0 { 2 * e + 1 } else { -2 * (e + 1) } + } else if e >= 0 { + 2 * e + } else { + -2 * e - 1 + }; + wr.golomb(m, k, p.limit, p.qbpp); + cur[x + 1] = reconstruct(px, sign, e, p); + update_regular(&mut st, q, e, p); + x += 1; + } + std::mem::swap(&mut prev, &mut cur); + } + wr.finish() +} + +#[allow(clippy::too_many_arguments)] +fn encode_run(wr: &mut BitWriter, st: &mut State, p: &Params, line: &[u16], prev: &[i32], cur: &mut [i32], ra: i32, x: usize) -> usize { + let w = line.len(); + let mut run = 0usize; + while x + run < w && (i32::from(line[x + run]) - ra).abs() <= p.near { + cur[x + run + 1] = ra; + run += 1; + } + let mut count = run; + while count >= 1usize << J[st.run_index] { + wr.put(1, 1); + count -= 1usize << J[st.run_index]; + if st.run_index < 31 { + st.run_index += 1; + } + } + if x + run == w { + if count > 0 { + wr.put(1, 1); + } + return w; + } + wr.put(0, 1); + wr.put(count as u32, J[st.run_index]); + let ix = i32::from(line[x + run]); + let rb = prev[x + run + 1]; + let ri_type = i32::from((ra - rb).abs() <= p.near); + let q = RI_BASE + ri_type as usize; + let (px, sign) = if ri_type == 1 { (ra, 1) } else { (rb, if ra > rb { -1 } else { 1 }) }; + let e = reduce(sign * (ix - px), p); + let k = run_k(st, q, ri_type); + let n_neg = st.nn[ri_type as usize]; + let map = i32::from((k == 0 && e > 0 && 2 * n_neg < st.n[q]) || (e < 0 && 2 * n_neg >= st.n[q]) || (e < 0 && k != 0)); + let em = 2 * e.abs() - ri_type - map; + wr.golomb(em, k, p.limit - J[st.run_index] - 1, p.qbpp); + cur[x + run + 1] = reconstruct(px, sign, e, p); + update_run(st, q, e, em, ri_type, p); + if st.run_index > 0 { + st.run_index -= 1; + } + x + run + 1 +} + +/// Writes a lossless JPEG-LS file: 8 or 16 bits, gray or RGB, one scan per component. +pub(crate) fn encode(src: &Image, plan: Plan) -> Result, CodecError> { + let enc = |msg: String| CodecError::encode(F, msg); + let img = src.converted(plan.layout, plan.sample); + let nc = match img.layout() { + ChannelLayout::Gray => 1, + ChannelLayout::Rgb => 3, + l => return Err(enc(format!("no JPEG-LS layout for {l:?}"))), + }; + let precision: u32 = match img.sample_type() { + SampleType::U8 => 8, + SampleType::U16 => 16, + s => return Err(enc(format!("JPEG-LS stores 8 or 16 bits per sample, not {s:?}"))), + }; + let (w, h) = img.dimensions(); + let (Ok(w16), Ok(h16)) = (u16::try_from(w), u16::try_from(h)) else { + return Err(enc(format!("dimensions exceed 65535x65535: {w}x{h}"))); + }; + let (wu, hu) = (w as usize, h as usize); + let data = img.data(); + if data.len() != wu * hu * nc * (precision as usize / 8) { + return Err(enc("the image has the wrong number of samples".into())); + } + let params = Params::new(precision, 0, [0; 5]).map_err(|_| enc("invalid coding parameters".into()))?; + let mut out = vec![0xFF, 0xD8, 0xFF, SOF55]; + out.extend_from_slice(&((8 + 3 * nc) as u16).to_be_bytes()); + out.push(precision as u8); + out.extend_from_slice(&h16.to_be_bytes()); + out.extend_from_slice(&w16.to_be_bytes()); + out.push(nc as u8); + for c in 0..nc { + out.extend_from_slice(&[c as u8 + 1, 0x11, 0]); + } + let mut plane = vec![0u16; wu * hu]; + for c in 0..nc { + for (i, v) in plane.iter_mut().enumerate() { + let at = i * nc + c; + *v = if precision == 8 { u16::from(data[at]) } else { u16::from_ne_bytes([data[2 * at], data[2 * at + 1]]) }; + } + out.extend_from_slice(&[0xFF, 0xDA, 0, 8, 1, c as u8 + 1, 0, 0, 0, 0]); + out.extend_from_slice(&encode_scan(&plane, wu, hu, ¶ms)); + } + out.extend_from_slice(&[0xFF, 0xD9]); + Ok(out) +} + +struct Frame { + precision: u32, + width: usize, + height: usize, + components: Vec, +} + +fn be16(b: &[u8], i: usize) -> Result { + b.get(i..i + 2).map(|s| usize::from(u16::from_be_bytes([s[0], s[1]]))).ok_or_else(|| bad("truncated header")) +} + +pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { + if !looks_like_jpegls(b) { + return Err(bad("not a JPEG-LS file")); + } + let mut pos = 2; + let mut frame: Option = None; + let mut preset = [0i32; 5]; + let mut planes: Vec> = Vec::new(); + let mut scans_done = 0; + loop { + // Find the next marker. + while b.get(pos) != Some(&0xFF) { + if pos >= b.len() { + return finish(frame, planes, scans_done); + } + pos += 1; + } + while b.get(pos + 1) == Some(&0xFF) { + pos += 1; + } + let Some(&marker) = b.get(pos + 1) else { return finish(frame, planes, scans_done) }; + if marker == 0xD9 { + return finish(frame, planes, scans_done); + } + if marker == 0x00 || (0xD0..=0xD7).contains(&marker) || marker == 0x01 { + pos += 2; + continue; + } + let len = be16(b, pos + 2)?; + let seg = b.get(pos + 4..pos + 2 + len).ok_or_else(|| bad("truncated marker segment"))?; + match marker { + SOF55 => { + if frame.is_some() || seg.len() < 6 { + return Err(bad("bad or repeated frame header")); + } + let (precision, height, width, nf) = (u32::from(seg[0]), be16(seg, 1)?, be16(seg, 3)?, usize::from(seg[5])); + if !(2..=16).contains(&precision) || width == 0 || height == 0 || !matches!(nf, 1 | 3) || seg.len() < 6 + 3 * nf { + return Err(bad("unsupported frame header")); + } + if height == 0 { + return Err(CodecError::unsupported(F, "a frame height set later by a DNL marker")); + } + let layout = if nf == 1 { ChannelLayout::Gray } else { ChannelLayout::Rgb }; + let sample = if precision <= 8 { SampleType::U8 } else { SampleType::U16 }; + limits.check(width as u32, height as u32, layout, sample)?; + let components = (0..nf).map(|i| seg[6 + 3 * i]).collect(); + frame = Some(Frame { precision, width, height, components }); + } + LSE => { + if seg.first() == Some(&1) && seg.len() >= 11 { + for (i, p) in preset.iter_mut().enumerate() { + *p = be16(seg, 1 + 2 * i)? as i32; + } + } else if seg.first() != Some(&1) { + return Err(CodecError::unsupported(F, "mapping tables and colour transforms (LSE)")); + } + } + 0xDA => { + let f = frame.as_ref().ok_or_else(|| bad("a scan before the frame header"))?; + let ns = usize::from(*seg.first().ok_or_else(|| bad("empty scan header"))?); + if seg.len() < 1 + 2 * ns + 3 || ns != 1 { + return Err(CodecError::unsupported(F, "interleaved scans (ILV 1 and 2)")); + } + let (cs, tm, near, ilv) = (seg[1], seg[2], i32::from(seg[3]), seg[4]); + if tm != 0 { + return Err(CodecError::unsupported(F, "mapping tables")); + } + if ilv != 0 && f.components.len() > 1 { + return Err(CodecError::unsupported(F, "interleaved scans (ILV 1 and 2)")); + } + if seg[5] & 0x0f != 0 { + return Err(CodecError::unsupported(F, "a point transform")); + } + let idx = f.components.iter().position(|&c| c == cs).ok_or_else(|| bad("a scan names an unknown component"))?; + if planes.len() <= idx { + planes.resize(f.components.len(), Vec::new()); + } + if !planes[idx].is_empty() { + return Err(bad("a component is coded twice")); + } + let params = Params::new(f.precision, near, preset)?; + let start = pos + 2 + len; + // The scan ends at the next real marker: an 0xFF followed by a byte with its top bit set. + let mut end = start; + while end < b.len() { + if b[end] == 0xFF && b.get(end + 1).is_none_or(|&n| n & 0x80 != 0) { + break; + } + end += 1; + } + let mut samples = Vec::new(); + samples.try_reserve_exact(f.width * f.height).map_err(|_| bad("pixel buffer is too large"))?; + samples.resize(f.width * f.height, 0u16); + decode_scan(&b[start..end], f.width, f.height, ¶ms, &mut samples)?; + planes[idx] = samples; + scans_done += 1; + pos = end; + continue; + } + _ => {} + } + pos += 2 + len; + } +} + +fn finish(frame: Option, planes: Vec>, scans: usize) -> Result { + let f = frame.ok_or_else(|| bad("no frame header"))?; + if scans != f.components.len() || planes.iter().any(Vec::is_empty) || planes.len() != f.components.len() { + return Err(bad("the file ends before every component is coded")); + } + let (w, h, nc) = (f.width, f.height, f.components.len()); + let layout = if nc == 1 { ChannelLayout::Gray } else { ChannelLayout::Rgb }; + let p = f.precision; + let scale = |v: u16| -> u16 { + if p == 16 { + v + } else { + let v = u32::from(v); + ((v << (16 - p)) | (v >> (2 * p).saturating_sub(16).min(15))) as u16 + } + }; + if p <= 8 { + let to8 = |v: u16| -> u8 { if p == 8 { v as u8 } else { (scale(v) >> 8) as u8 } }; + let mut data = Vec::with_capacity(w * h * nc); + for i in 0..w * h { + for plane in &planes { + data.push(to8(plane[i])); + } + } + Image::from_u8(w as u32, h as u32, layout, data) + } else { + let mut data = Vec::with_capacity(w * h * nc); + for i in 0..w * h { + for plane in &planes { + data.push(scale(plane[i])); + } + } + Image::from_u16(w as u32, h as u32, layout, &data) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn noise_u16(n: usize, seed: &mut u32, mask: u32) -> Vec { + (0..n) + .map(|_| { + *seed ^= *seed << 13; + *seed ^= *seed >> 17; + *seed ^= *seed << 5; + (*seed & mask) as u16 + }) + .collect() + } + + fn image(w: u32, h: u32, layout: ChannelLayout, wide: bool, kind: u8) -> Image { + let n = w as usize * h as usize * layout.channels(); + let mut seed = 0x1234_5679u32; + let samples: Vec = match kind { + 0 => noise_u16(n, &mut seed, if wide { 0xFFFF } else { 0xFF }), + 1 => vec![if wide { 40_000 } else { 100 }; n], + _ => (0..n).map(|i| if wide { ((i / 3) * 37 % 65_536) as u16 } else { ((i / 3) % 251) as u16 }).collect(), + }; + if wide { + Image::from_u16(w, h, layout, &samples).unwrap() + } else { + Image::from_u8(w, h, layout, samples.iter().map(|&v| v as u8).collect()).unwrap() + } + } + + fn plan(img: &Image) -> Plan { + Plan { layout: img.layout(), sample: img.sample_type() } + } + + #[test] + fn round_trips_noise_flat_and_smooth_images() { + for layout in [ChannelLayout::Gray, ChannelLayout::Rgb] { + for wide in [false, true] { + for kind in 0..3 { + // Widths around the run-length steps, and single-pixel dimensions. + for (w, h) in [(1, 1), (1, 9), (2, 3), (7, 5), (33, 4), (300, 3), (1025, 2)] { + let img = image(w, h, layout, wide, kind); + let bytes = encode(&img, plan(&img)).unwrap(); + assert!(looks_like_jpegls(&bytes)); + let back = decode(&bytes, &Limits::default()).unwrap_or_else(|e| panic!("{layout:?} wide={wide} kind={kind} {w}x{h}: {e}")); + assert_eq!(back.data(), img.data(), "{layout:?} wide={wide} kind={kind} {w}x{h}"); + } + } + } + } + } + + #[test] + fn default_parameters_follow_the_standard() { + let p = Params::new(8, 0, [0; 5]).unwrap(); + assert_eq!((p.maxval, p.range, p.qbpp, p.limit, p.t1, p.t2, p.t3, p.reset), (255, 256, 8, 32, 3, 7, 21, 64)); + let p = Params::new(16, 0, [0; 5]).unwrap(); + assert_eq!((p.maxval, p.range, p.qbpp, p.limit, p.t1, p.t2, p.t3), (65535, 65536, 16, 64, 18, 67, 276)); + let p = Params::new(8, 3, [0; 5]).unwrap(); + assert_eq!((p.range, p.t1), (38, 12)); // RANGE = floor((255 + 2 * 3) / 7) + 1 + assert!(Params::new(8, 200, [0; 5]).is_err()); + } + + #[test] + fn detection_tells_jpeg_ls_from_jpeg() { + let img = image(4, 4, ChannelLayout::Gray, false, 0); + let ls = encode(&img, plan(&img)).unwrap(); + assert!(looks_like_jpegls(&ls)); + // A baseline JPEG starts SOI, APP0 / DQT, ... SOF0: not JPEG-LS. + assert!(!looks_like_jpegls(&[0xFF, 0xD8, 0xFF, 0xE0, 0, 4, 0, 0, 0xFF, 0xC0, 0, 11])); + assert!(!looks_like_jpegls(&[0xFF, 0xD8, 0xFF, 0xC0, 0, 11])); + // SOF55 after an application segment still is. + assert!(looks_like_jpegls(&[0xFF, 0xD8, 0xFF, 0xE8, 0, 4, 0, 0, 0xFF, 0xF7, 0, 11])); + assert!(!looks_like_jpegls(&[0xFF, 0xD8])); + } + + #[test] + fn interleaved_scans_and_tables_are_unsupported() { + let img = image(8, 4, ChannelLayout::Rgb, false, 2); + let good = encode(&img, plan(&img)).unwrap(); + // The scan header body is Ns, Cs, Tm, NEAR, ILV, point transform, after the marker and length. + let sos = good.windows(2).position(|w| w == [0xFF, 0xDA]).unwrap() + 4; + let mut line = good.clone(); + line[sos + 4] = 1; + assert!(matches!(decode(&line, &Limits::default()), Err(CodecError::Unsupported { .. }))); + let mut mapped = good.clone(); + mapped[sos + 2] = 1; + assert!(matches!(decode(&mapped, &Limits::default()), Err(CodecError::Unsupported { .. }))); + let mut transform = good; + transform[sos + 5] = 1; + assert!(matches!(decode(&transform, &Limits::default()), Err(CodecError::Unsupported { .. }))); + } + + #[test] + fn hostile_input_is_an_error_not_a_panic() { + for (w, h, layout, wide) in [(23, 9, ChannelLayout::Gray, false), (11, 7, ChannelLayout::Rgb, true)] { + let img = image(w, h, layout, wide, 0); + let good = encode(&img, plan(&img)).unwrap(); + for len in 0..good.len() { + let _ = decode(&good[..len], &Limits::default()); + } + // Flip every bit of the entropy-coded data and of the headers, one at a time. + for i in 0..good.len() { + for bit in 0..8 { + let mut c = good.clone(); + c[i] ^= 1 << bit; + let _ = decode(&c, &Limits::default()); + } + } + } + // A huge frame is stopped by the limits or the length check before any allocation. + let img = image(4, 4, ChannelLayout::Gray, false, 0); + let mut huge = encode(&img, plan(&img)).unwrap(); + let sof = huge.windows(2).position(|w| w == [0xFF, 0xF7]).unwrap(); + huge[sof + 5..sof + 9].copy_from_slice(&[0xFF, 0xFF, 0xFF, 0xFF]); + assert!(decode(&huge, &Limits::default()).is_err()); + } +} diff --git a/crates/image-codecs/src/format.rs b/crates/image-codecs/src/format.rs index ecaf945cd..810c1ad48 100644 --- a/crates/image-codecs/src/format.rs +++ b/crates/image-codecs/src/format.rs @@ -44,6 +44,8 @@ pub enum Format { Iff, /// JPEG 2000 (JP2 container or raw J2K codestream): read-only; see [`ASYMMETRIC_EXCEPTIONS`]. Jp2, + /// JPEG-LS (`.jls`): lossless and near-lossless gray and RGB. + JpegLs, } /// What a format can hold **and** what this crate reads/writes for it. @@ -113,7 +115,7 @@ const TIFF_LAYOUTS: &[ChannelLayout] = &[L::Gray, L::GrayA, L::Rgb, L::Rgba, L:: impl Format { /// Every format known to the crate (enabled or not). - pub const ALL: [Format; 24] = [ + pub const ALL: [Format; 25] = [ Format::Png, Format::Jpeg, Format::Jp2, @@ -138,6 +140,7 @@ impl Format { Format::Cineon, Format::Dicom, Format::Iff, + Format::JpegLs, ]; pub fn caps(self) -> FormatCaps { @@ -176,6 +179,7 @@ impl Format { Format::Dicom => "DICOM", Format::Iff => "Amiga IFF", Format::Jp2 => "JPEG 2000", + Format::JpegLs => "JPEG-LS", } } @@ -207,6 +211,7 @@ impl Format { Format::Dicom => &["dcm", "dicom", "dc3"], Format::Iff => &["iff", "lbm", "ilbm"], Format::Jp2 => &["jp2", "j2k", "j2c", "jpf", "jpx"], + Format::JpegLs => &["jls"], } } @@ -236,13 +241,14 @@ impl Format { Format::Dicom => "application/dicom", Format::Iff => "image/x-iff", Format::Jp2 => "image/jp2", + Format::JpegLs => "image/jls", } } /// Maximum encodable dimensions, if the format has a hard limit. pub fn max_dimensions(self) -> Option<(u32, u32)> { match self { - Format::Jpeg | Format::Gif | Format::Iff => Some((65535, 65535)), + Format::Jpeg | Format::Gif | Format::Iff | Format::JpegLs => Some((65535, 65535)), Format::WebP => Some((16384, 16384)), Format::Ico => Some((256, 256)), _ => None, @@ -310,6 +316,7 @@ pub fn caps(format: Format) -> FormatCaps { Format::Cineon => FormatCaps { depths: &[S::U16], layouts: &[L::Gray, L::Rgb], alpha: false, ..base }, Format::Dicom => FormatCaps { read: true, write: false, depths: &[S::U8, S::U16], layouts: &[L::Gray, L::Rgb], alpha: false, ..base }, Format::Iff => FormatCaps { depths: &[S::U8], layouts: &[L::Rgb, L::Rgba], alpha: true, ..base }, + Format::JpegLs => FormatCaps { depths: &[S::U8, S::U16], layouts: &[L::Gray, L::Rgb], alpha: false, ..base }, Format::Jp2 => FormatCaps { read: true, write: false, layouts: &[L::Gray, L::GrayA, L::Rgb, L::Rgba, L::Cmyk, L::CmykA], icc: true, ..base }, } } @@ -321,6 +328,9 @@ pub fn detect(bytes: &[u8]) -> Option { if b.starts_with(b"\x89PNG\r\n\x1a\n") { return Some(Format::Png); } + if crate::codecs::jpegls::looks_like_jpegls(b) { + return Some(Format::JpegLs); + } if b.starts_with(&[0xFF, 0xD8, 0xFF]) { return Some(Format::Jpeg); } diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 21130e392..b60691e83 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -62,7 +62,7 @@ pub use crate::resolution::{exif_resolution, export_exif, export_xmp, photoshop_ pub use crate::source_settings::{WebpEncoding, jpeg_quality, webp_encoding}; pub use half::f16; -use crate::codecs::{dds, dicom, dpx, exr, fits, heif, iff, jp2, jpeg, jxl, pcx, png, pnm, tiff, via_image, webp, xpm}; +use crate::codecs::{dds, dicom, dpx, exr, fits, heif, iff, jp2, jpeg, jpegls, jxl, pcx, png, pnm, tiff, via_image, webp, xpm}; /// Detect the format and decode with default [`Limits`]. pub fn decode(bytes: &[u8]) -> Result { @@ -101,6 +101,7 @@ pub fn decode_as_with(format: Format, bytes: &[u8], opts: &DecodeOptions) -> Res Format::Cineon => dpx::decode_cineon(bytes, l), Format::Dicom => dicom::decode(bytes, l), Format::Iff => iff::decode(bytes, l), + Format::JpegLs => jpegls::decode(bytes, l), Format::OpenExr => exr::decode(bytes, l), Format::Heif => heif::decode(bytes, l, opts.keep_orientation), Format::Jp2 => jp2::decode(bytes, l), @@ -457,6 +458,7 @@ pub fn encode(image: &Image, format: Format, opts: &EncodeOptions) -> Result dpx::encode_cineon(image, plan), Format::Dicom => Err(CodecError::unsupported(format, "DICOM is import-only; save as TIFF or PNG instead")), Format::Iff => iff::encode(image, plan), + Format::JpegLs => jpegls::encode(image, plan), Format::OpenExr => exr::encode(image, plan, opts), Format::Heif => Err(CodecError::unsupported(format, "encoding is not available in this build")), Format::Jp2 => Err(CodecError::unsupported(format, "JPEG 2000 is import-only; save as PNG or TIFF instead")), diff --git a/crates/image-codecs/tests/it/detect_caps.rs b/crates/image-codecs/tests/it/detect_caps.rs index 640772c83..390eaa41f 100644 --- a/crates/image-codecs/tests/it/detect_caps.rs +++ b/crates/image-codecs/tests/it/detect_caps.rs @@ -62,6 +62,7 @@ fn default_build_formats_all_symmetric() { Format::Dpx, Format::Cineon, Format::Iff, + Format::JpegLs, ]; for f in expected { assert!(caps(f).read && caps(f).write, "{f:?}"); @@ -218,6 +219,21 @@ fn detect_magic_iff() { assert_eq!(detect(b"FORM\0\0\0\x14AIFF"), None); assert!(decode_as(Format::Iff, b"FORM\0\0\0\x14ILBM").is_err()); } +#[test] +fn detect_magic_jpeg_ls() { + use craft_image_codecs::{ChannelLayout, EncodeOptions, Image, encode}; + let img = Image::from_u8(5, 3, ChannelLayout::Gray, (0..15).collect()).unwrap(); + let bytes = encode(&img, Format::JpegLs, &EncodeOptions::default()).unwrap(); + assert_eq!(detect(&bytes), Some(Format::JpegLs)); + assert_eq!(from_extension("scan.JLS"), Some(Format::JpegLs)); + assert_eq!(decode(&bytes).unwrap().data(), img.data()); + assert!(!ASYMMETRIC_EXCEPTIONS.iter().any(|(f, _)| *f == Format::JpegLs)); + assert_eq!(Format::JpegLs.max_dimensions(), Some((65535, 65535))); + // Plain JPEG still is JPEG: SOI, then a baseline frame header. + assert_eq!(detect(&[0xFF, 0xD8, 0xFF, 0xC0, 0, 11]), Some(Format::Jpeg)); + assert!(decode_as(Format::JpegLs, &[0xFF, 0xD8, 0xFF, 0xF7]).is_err()); +} + #[test] fn detect_magic_avif() { assert_eq!(detect(b"\0\0\0\x1cftypavif\0\0\0\0avifmif1miaf"), Some(Format::Avif)); diff --git a/crates/image-codecs/tests/it/jpegls_oracle.rs b/crates/image-codecs/tests/it/jpegls_oracle.rs new file mode 100644 index 000000000..aa98609a1 --- /dev/null +++ b/crates/image-codecs/tests/it/jpegls_oracle.rs @@ -0,0 +1,103 @@ +//! JPEG-LS against ffmpeg as the reference (oracle; skipped when ffmpeg is absent, a failure with +//! `CRAFT_MEDIA_REQUIRE_ORACLES=1`): +//! - files ffmpeg's encoder writes (8- and 16-bit gray: smooth, noisy and flat images, which +//! exercise the regular, run and escape-coded paths) decode to the pixels ffmpeg decodes; +//! - files our encoder writes (gray 8 and 16 bits, RGB 8 bits) decode in ffmpeg to our pixels (ffmpeg +//! cannot decode 16-bit RGB JPEG-LS, so that case is only round-tripped through our own decoder); +//! - ffmpeg writes RGB line-interleaved, which is reported as unsupported. + +use craft_image_codecs::{ChannelLayout, CodecError, EncodeOptions, Format, Image, SampleType, decode, encode}; +use std::path::Path; +use std::process::Command; + +const W: u32 = 66; +const H: u32 = 40; + +fn run(ffmpeg: &Path, args: &[&str]) -> Vec { + let out = Command::new(ffmpeg).args(["-v", "error", "-y"]).args(args).output().expect("run ffmpeg"); + assert!(out.status.success(), "ffmpeg {args:?}: {}", String::from_utf8_lossy(&out.stderr)); + out.stdout +} + +/// `(name, lavfi source)`: smooth, noisy and flat pictures of W x H. +fn sources() -> Vec<(&'static str, String)> { + let s = format!("{W}x{H}"); + vec![ + ("testsrc", format!("testsrc2=size={s}:rate=1")), + ("noise", format!("nullsrc=size={s}:rate=1,geq=lum='random(1)*255':cb=128:cr=128")), + ("flat", format!("color=c=0x336699:size={s}:rate=1")), + ("gradient", format!("gradients=size={s}:rate=1:seed=7")), + ] +} + +#[test] +fn ffmpeg_files_decode_to_ffmpegs_pixels() { + let Some(ffmpeg) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("jpegls"); + for (name, src) in sources() { + for (fmt, ext_bits) in [("gray", 8), ("gray16le", 16)] { + let file = dir.join(format!("ffmpeg_{name}_{ext_bits}.jls")); + let f = file.to_str().expect("path"); + run(&ffmpeg, &["-f", "lavfi", "-i", &src, "-frames:v", "1", "-pix_fmt", fmt, f]); + let theirs = run(&ffmpeg, &["-i", f, "-f", "rawvideo", "-pix_fmt", fmt, "-"]); + let ours = decode(&std::fs::read(&file).expect("read")).unwrap_or_else(|e| panic!("{name} {fmt}: {e}")); + assert_eq!((ours.width(), ours.height(), ours.layout()), (W, H, ChannelLayout::Gray), "{name} {fmt}"); + let want_sample = if ext_bits == 8 { SampleType::U8 } else { SampleType::U16 }; + assert_eq!(ours.sample_type(), want_sample); + let ours_bytes: Vec = if ext_bits == 8 { + ours.data().to_vec() + } else { + ours.data().as_chunks::<2>().0.iter().flat_map(|b| u16::from_ne_bytes(*b).to_le_bytes()).collect() + }; + assert!(ours_bytes == theirs, "{name} {fmt}: pixels differ from ffmpeg's decode"); + } + } +} + +#[test] +fn ffmpegs_rgb_is_line_interleaved_and_unsupported() { + let Some(ffmpeg) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("jpegls"); + let file = dir.join("ffmpeg_rgb.jls"); + run( + &ffmpeg, + &["-f", "lavfi", "-i", &format!("testsrc2=size={W}x{H}:rate=1"), "-frames:v", "1", "-pix_fmt", "rgb24", file.to_str().expect("path")], + ); + assert!(matches!(decode(&std::fs::read(&file).expect("read")), Err(CodecError::Unsupported { .. }))); +} + +#[test] +fn ffmpeg_decodes_our_files_to_our_pixels() { + let Some(ffmpeg) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("jpegls"); + for (name, src) in sources() { + for (layout, fmt8, fmt16) in [(ChannelLayout::Gray, "gray", "gray16le"), (ChannelLayout::Rgb, "rgb24", "rgb48le")] { + for bits in [8, 16] { + let fmt = if bits == 8 { fmt8 } else { fmt16 }; + // Source pixels from ffmpeg, so the test image is realistic. + let raw = run(&ffmpeg, &["-f", "lavfi", "-i", &src, "-frames:v", "1", "-pix_fmt", fmt, "-f", "rawvideo", "-"]); + let img = if bits == 8 { + Image::from_u8(W, H, layout, raw).expect("image") + } else { + let samples: Vec = raw.as_chunks::<2>().0.iter().map(|b| u16::from_le_bytes(*b)).collect(); + Image::from_u16(W, H, layout, &samples).expect("image") + }; + let bytes = encode(&img, Format::JpegLs, &EncodeOptions::default()).expect("encode"); + assert_eq!(decode(&bytes).expect("our own file decodes").data(), img.data(), "{name} {fmt}: round trip"); + let file = dir.join(format!("ours_{name}_{fmt}.jls")); + std::fs::write(&file, &bytes).expect("write"); + // ffmpeg's decoder does not implement 16-bit colour ("Not yet implemented"). + if layout == ChannelLayout::Rgb && bits == 16 { + continue; + } + let theirs = run(&ffmpeg, &["-i", file.to_str().expect("path"), "-f", "rawvideo", "-pix_fmt", fmt, "-"]); + let ours_bytes: Vec = if bits == 8 { + img.data().to_vec() + } else { + img.data().as_chunks::<2>().0.iter().flat_map(|b| u16::from_ne_bytes(*b).to_le_bytes()).collect() + }; + assert!(theirs == ours_bytes, "{name} {fmt}: ffmpeg decodes our file to other pixels"); + } + } + } +} diff --git a/crates/image-codecs/tests/it/main.rs b/crates/image-codecs/tests/it/main.rs index f465a0cbb..4eda74a26 100644 --- a/crates/image-codecs/tests/it/main.rs +++ b/crates/image-codecs/tests/it/main.rs @@ -14,6 +14,7 @@ mod exr_stream; mod fidelity; mod gif_frames; mod heif; +mod jpegls_oracle; mod limits; mod malformed; mod metadata; From 5ab7a6035c0ff409cc743978b17d73f414b58524 Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 13:06:49 +0100 Subject: [PATCH 060/382] craft-video: FFV1 lossless video, version 3 range-coder decoder and encoder Adds the ffv1 feature (RFC 9043): YCbCr (any 2^n subsampling, gray, optional transparency) and RGB through the JPEG 2000 reversible colour transform, 8 to 16 bits, any slice raster, slice and configuration record CRCs. Not covered yet: the Golomb-Rice coder, versions 0 and 1, inter frames. Part of #1509 --- crates/video/Cargo.toml | 6 + crates/video/src/ffv1/README.md | 52 ++ crates/video/src/ffv1/mod.rs | 929 ++++++++++++++++++++++++++++++++ crates/video/src/ffv1/rc.rs | 229 ++++++++ crates/video/src/lib.rs | 4 + crates/video/tests/ffv1.rs | 304 +++++++++++ 6 files changed, 1524 insertions(+) create mode 100644 crates/video/src/ffv1/README.md create mode 100644 crates/video/src/ffv1/mod.rs create mode 100644 crates/video/src/ffv1/rc.rs create mode 100644 crates/video/tests/ffv1.rs diff --git a/crates/video/Cargo.toml b/crates/video/Cargo.toml index c3ebfd722..dae21e5b1 100644 --- a/crates/video/Cargo.toml +++ b/crates/video/Cargo.toml @@ -34,6 +34,8 @@ mpeg2-encode = ["mpeg2-decode"] # MPEG-4 Part 2 video (ISO/IEC 14496-2, the Xvid/DivX format): Simple profile encoder. mpeg4 = ["mpeg4-encode"] mpeg4-encode = ["craft-media/bitstream"] +# FFV1 lossless video (RFC 9043): version 3, range coder, decoder and encoder. +ffv1 = [] # Apple ProRes (SMPTE RDD 36): decoder and encoder. prores = ["craft-media/bitstream"] # H.264 / AVC: decoder and encoder; `h264-decode` or `h264-encode` for one of them. @@ -143,6 +145,10 @@ required-features = ["mpeg4-encode"] name = "mpeg2" required-features = ["mpeg2-decode"] +[[test]] +name = "ffv1" +required-features = ["ffv1"] + [[test]] name = "prores" required-features = ["prores"] diff --git a/crates/video/src/ffv1/README.md b/crates/video/src/ffv1/README.md new file mode 100644 index 000000000..90312dbe5 --- /dev/null +++ b/crates/video/src/ffv1/README.md @@ -0,0 +1,52 @@ +# FFV1 + +Clean-room FFV1 lossless video codec, written from RFC 9043. Feature `ffv1`. + +## What is supported + +| | Decoder | Encoder | +|---|---|---| +| Version | 3 (the one with a configuration record) | 3 | +| Coder | range coder, default or custom state transition table | range coder, default table | +| Colour | YCbCr (any 2^n chroma subsampling, gray, optional transparency), RGB through the JPEG 2000 reversible colour transform (optional transparency) | the same, RGB up to 15 bits | +| Depth | 8 to 16 bits per sample | 8 to 16 bits (RGB 8 to 15) | +| Slices | any raster whose boundaries are multiples of the chroma subsampling | the same | +| Frames | keyframes | keyframes only (`intra` 1) | +| Error detection | slice and configuration record CRCs, checked | written | + +Not supported, and reported as `Error::Unsupported`: the Golomb-Rice coder (`coder_type` 0), +versions 0 and 1 (parameters inside each keyframe, no configuration record), inter frames +(`keyframe` 0), and slice rasters whose boundaries fall inside a chroma sample. + +## Using it + +The configuration record goes in the container (Matroska `CodecPrivate`, the AVI `strf` +extension, an MP4 `glbl` box); each frame is one packet. + +```text +let enc = Encoder::new(&template_frame, EncoderConfig::default())?; +let config = enc.config_record(); +let packet = enc.encode(&frame)?; + +let dec = Decoder::new(&config, width, height)?; +let frame = dec.decode(&packet)?; +``` + +## Notes on the format + +- The Parameters in the configuration record are range coded with the *default* state transition + table. A custom table (`coder_type` 2) applies to the slices only. +- Each Quantization Table starts from fresh states; a Quantization Table Set is five of them. +- A slice is one range-coded stream: for the first slice the `keyframe` bit, then the slice header, + then the samples. Cb and Cr share one set of context states; transparency has its own. +- The context is the sum of five quantised differences. With the default tables this encoder + writes 15125 contexts; FFmpeg refuses tables that multiply to more than 32768, so the encoder + stays below that although the RFC's limit (on half the product) is looser. +- The encoder ends a stream with the top of its final range, so bytes after it (a CRC in the + configuration record) cannot change what decodes. + +## Verification + +`tests/ffv1.rs`: round trips over every shape, hostile input (every truncation and bit flip), +and ffmpeg as the oracle in both directions (skipped without ffmpeg, a failure with +`CRAFT_MEDIA_REQUIRE_ORACLES=1`). diff --git a/crates/video/src/ffv1/mod.rs b/crates/video/src/ffv1/mod.rs new file mode 100644 index 000000000..4df60f9a1 --- /dev/null +++ b/crates/video/src/ffv1/mod.rs @@ -0,0 +1,929 @@ +//! FFV1 lossless video codec (RFC 9043): version 3, range coder, intra-only, YCbCr and RGB (JPEG 2000 +//! RCT), 8 to 16 bits per sample, any number of slices. +//! +//! - [`Decoder`]: built from the *configuration record* a container stores (Matroska `CodecPrivate`, +//! AVI `strf` extension, MP4 `glbl`) and the frame size; [`Decoder::decode`] turns one packet into a +//! [`Frame`]. Slice CRCs are checked. +//! - [`Encoder`]: [`Encoder::config_record`] gives the bytes for the container, [`Encoder::encode`] +//! one packet per frame; every frame is a keyframe. +//! +//! Not supported (reported as [`Error::Unsupported`]): the Golomb-Rice coder (`coder_type` 0), +//! versions 0 and 1 (no configuration record, parameters in every keyframe), inter frames +//! (`intra` 0 with `keyframe` 0), and slice rasters whose boundaries are not multiples of the +//! chroma subsampling. See `src/ffv1/README.md`. +//! +//! Implemented from RFC 9043. Frames are planar `u16`: for YCbCr, `[Y, Cb, Cr]` (plus an optional +//! transparency plane); for RGB, `[R, G, B]` (plus transparency), all at full size. + +mod rc; + +use crate::budget::{DECODE_MEMORY_BUDGET, PictureShape}; +use rc::{Decoder as Rac, Encoder as RacEnc, Transitions}; + +const CONTEXT_SIZE: usize = 32; +const MAX_CONTEXT_INPUTS: usize = 5; +const MAX_CONTEXTS: u64 = 32768; + +/// Codec errors. +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum Error { + /// The data ends early or its sizes do not add up. + #[error("truncated FFV1 data")] + Truncated, + /// The data is not valid FFV1. + #[error("invalid FFV1 data: {0}")] + Invalid(&'static str), + /// Valid FFV1 that this module does not decode. + #[error("unsupported FFV1 feature: {0}")] + Unsupported(&'static str), + /// A slice or the configuration record failed its CRC. + #[error("FFV1 CRC mismatch in {0}")] + Crc(&'static str), + /// The encoder was given a frame or settings it cannot encode. + #[error("invalid encoder input: {0}")] + Input(String), +} + +/// `Result` of this module. +pub type Result = std::result::Result; + +/// The colour space coded (RFC 9043 table 8). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Colorspace { + /// YCbCr, coded plane by plane without a pixel transform. + YCbCr, + /// RGB through the JPEG 2000 reversible colour transform, coded line by line. + Rgb, +} + +/// One frame of planar samples. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Frame { + /// Width in pixels. + pub width: u32, + /// Height in pixels. + pub height: u32, + /// Colour space of the planes. + pub colorspace: Colorspace, + /// Bits per sample, 8 to 16. + pub bit_depth: u8, + /// log2 of the horizontal and vertical chroma subsampling (YCbCr only; 0, 0 is 4:4:4). + pub chroma_shift: (u8, u8), + /// The planes, in the order the module doc gives. + pub planes: Vec>, +} + +impl Frame { + /// Whether the planes are Y, Cb, Cr (or R, G, B) rather than Y (gray) alone, or with transparency. + fn plane_count_ok(&self) -> bool { + matches!(self.planes.len(), 1..=4) + } + + fn dims(&self, plane: usize, chroma_planes: bool) -> (usize, usize) { + plane_dims(self.width as usize, self.height as usize, self.colorspace, self.chroma_shift, plane, chroma_planes) + } +} + +/// `(width, height)` of plane `p` for a full frame (or a slice) of `w` x `h`. +fn plane_dims(w: usize, h: usize, cs: Colorspace, shift: (u8, u8), p: usize, chroma_planes: bool) -> (usize, usize) { + if cs == Colorspace::YCbCr && chroma_planes && (p == 1 || p == 2) { (w.div_ceil(1 << shift.0), h.div_ceil(1 << shift.1)) } else { (w, h) } +} + +/// One Quantization Table Set (section 4.1). +#[derive(Clone)] +struct QuantSet { + tables: Vec<[i32; 256]>, + context_count: usize, +} + +/// The parsed "Parameters" of a stream. +#[derive(Clone)] +struct Params { + coder_type: u32, + transitions: Transitions, + colorspace: Colorspace, + bits: u32, + chroma_planes: bool, + shift: (u8, u8), + extra_plane: bool, + num_h: u32, + num_v: u32, + sets: Vec, + initial_states: Vec>>, + ec: bool, + intra: bool, +} + +impl Params { + fn plane_count(&self) -> usize { + 1 + if self.chroma_planes { 2 } else { 0 } + usize::from(self.extra_plane) + } + + /// Quantization Table Set index slot of plane `p` (section 3.6). + fn qset_slot(&self, p: usize) -> usize { + match p { + 0 => 0, + 1 | 2 if self.chroma_planes => 1, + _ => 2, + } + } +} + +fn crc32(data: &[u8]) -> u32 { + // The IEEE polynomial 0x04C11DB7, initial value 0, no reflection, no final inversion. + let mut crc = 0u32; + for &b in data { + crc ^= u32::from(b) << 24; + for _ in 0..8 { + crc = if crc & 0x8000_0000 != 0 { crc << 1 ^ 0x04C1_1DB7 } else { crc << 1 }; + } + } + crc +} + +// ---- Parameters ---- + +fn read_quant_set(rac: &mut Rac, t: &Transitions) -> Result { + let mut scale: u64 = 1; + let mut tables = Vec::with_capacity(MAX_CONTEXT_INPUTS); + for _ in 0..MAX_CONTEXT_INPUTS { + let mut table = [0i32; 256]; + // Each quantization table starts from fresh states. + let mut state = [128u8; CONTEXT_SIZE]; + let mut v: i64 = 0; + let mut k = 0usize; + while k < 128 { + let len = rac.symbol(&mut state, false, t) as usize + 1; + if k + len > 128 { + return Err(Error::Invalid("quantization table run passes its half")); + } + for _ in 0..len { + table[k] = i32::try_from(scale as i64 * v).map_err(|_| Error::Invalid("quantization table overflows"))?; + k += 1; + } + v += 1; + } + for k in 1..128 { + table[256 - k] = -table[k]; + } + table[128] = -table[127]; + tables.push(table); + scale = scale.checked_mul(2 * v as u64 - 1).filter(|&s| s <= 2 * MAX_CONTEXTS).ok_or(Error::Invalid("too many contexts"))?; + } + let context_count = scale.div_ceil(2); + if context_count > MAX_CONTEXTS { + return Err(Error::Invalid("too many contexts")); + } + Ok(QuantSet { tables, context_count: context_count as usize }) +} + +fn parse_params(rac: &mut Rac) -> Result { + let mut state = [128u8; CONTEXT_SIZE]; + // Until the custom table is known, the default table decodes the fields before it. + let t0 = Transitions::default_table(); + let version = rac.symbol(&mut state, false, &t0); + if version != 3 { + return Err(Error::Unsupported("only FFV1 version 3 has a configuration record; versions 0 and 1 are not supported")); + } + let _micro = rac.symbol(&mut state, false, &t0); + let coder_type = rac.symbol(&mut state, false, &t0) as u32; + let mut delta = [0i32; 256]; + if coder_type > 1 { + for d in delta.iter_mut().skip(1) { + *d = rac.symbol(&mut state, true, &t0); + } + } + let transitions = Transitions::new(&delta); + if coder_type == 0 { + return Err(Error::Unsupported("the Golomb-Rice coder (coder_type 0)")); + } + if coder_type > 2 { + return Err(Error::Invalid("unknown coder_type")); + } + let colorspace = match rac.symbol(&mut state, false, &t0) { + 0 => Colorspace::YCbCr, + 1 => Colorspace::Rgb, + _ => return Err(Error::Unsupported("colorspace_type")), + }; + let bits = rac.symbol(&mut state, false, &t0) as u32; + let bits = if bits == 0 { 8 } else { bits }; + let chroma_planes = rac.bit(&mut state[0], &t0); + let (h, v) = (rac.symbol(&mut state, false, &t0), rac.symbol(&mut state, false, &t0)); + let extra_plane = rac.bit(&mut state[0], &t0); + let num_h = rac.symbol(&mut state, false, &t0) as u32 + 1; + let num_v = rac.symbol(&mut state, false, &t0) as u32 + 1; + let set_count = rac.symbol(&mut state, false, &t0); + if !(8..=16).contains(&bits) || h > 3 || v > 3 || h < 0 || v < 0 || num_h > 1024 || num_v > 1024 || !(1..=8).contains(&set_count) { + return Err(Error::Invalid("parameter out of range")); + } + if colorspace == Colorspace::Rgb && (!chroma_planes || h != 0 || v != 0) { + return Err(Error::Unsupported("RGB with chroma_planes 0 or subsampling")); + } + let mut sets = Vec::new(); + for _ in 0..set_count { + // The Parameters are range coded with the default table; the custom one is for the slices. + sets.push(read_quant_set(rac, &t0)?); + } + let mut initial_states = Vec::new(); + for set in &sets { + if rac.bit(&mut state[0], &t0) { + let mut all = Vec::with_capacity(set.context_count); + let mut prev = [128u8; CONTEXT_SIZE]; + for _ in 0..set.context_count { + let mut cur = [0u8; CONTEXT_SIZE]; + for k in 0..CONTEXT_SIZE { + let d = rac.symbol(&mut state, true, &t0); + cur[k] = (i32::from(prev[k]) + d) as u8; + } + prev = cur; + all.push(cur); + } + initial_states.push(Some(all)); + } else { + initial_states.push(None); + } + } + let ec = rac.symbol(&mut state, false, &t0) != 0; + let intra = rac.symbol(&mut state, false, &t0) != 0; + Ok(Params { + coder_type, + transitions, + colorspace, + bits, + chroma_planes, + shift: (h as u8, v as u8), + extra_plane, + num_h, + num_v, + sets, + initial_states, + ec, + intra, + }) +} + +/// The default quantisation tables of this encoder: 11 levels for the two gradients next to the +/// sample and 5 for the other three, which makes 15125 contexts (FFmpeg refuses more than 32768). +fn default_quant_set() -> QuantSet { + // |difference| thresholds: the first |d| of each level above 0 (levels 0..=5 and 0..=2). + let first_of_level: [&[usize]; MAX_CONTEXT_INPUTS] = [&[1, 2, 4, 8, 16], &[1, 2, 4, 8, 16], &[1, 3], &[1, 3], &[1, 3]]; + let mut scale: i32 = 1; + let mut tables = Vec::new(); + let mut counts = [0usize; MAX_CONTEXT_INPUTS]; + for (j, firsts) in first_of_level.iter().enumerate() { + let mut table = [0i32; 256]; + for (k, slot) in table.iter_mut().take(128).enumerate() { + let level = firsts.iter().filter(|&&f| k >= f).count() as i32; + *slot = scale * level; + } + for k in 1..128 { + table[256 - k] = -table[k]; + } + table[128] = -table[127]; + counts[j] = firsts.len() + 1; + scale *= 2 * counts[j] as i32 - 1; + tables.push(table); + } + QuantSet { tables, context_count: (scale as usize).div_ceil(2) } +} + +/// Run lengths (`len - 1` per step) that describe the first half of a table, as written to the stream. +fn quant_runs(table: &[i32; 256]) -> Vec { + let mut runs = Vec::new(); + let mut k = 0usize; + while k < 128 { + let start = k; + while k < 128 && table[k] == table[start] { + k += 1; + } + runs.push((k - start) as i32 - 1); + } + runs +} + +fn write_params(enc: &mut RacEnc, p: &Params) { + let t = Transitions::default_table(); + let mut state = [128u8; CONTEXT_SIZE]; + enc.symbol(&mut state, 3, false, &t); // version + enc.symbol(&mut state, 4, false, &t); // micro_version: first stable variant + enc.symbol(&mut state, p.coder_type as i32, false, &t); + enc.symbol(&mut state, if p.colorspace == Colorspace::YCbCr { 0 } else { 1 }, false, &t); + enc.symbol(&mut state, p.bits as i32, false, &t); + enc.bit(p.chroma_planes, &mut state[0], &t); + enc.symbol(&mut state, i32::from(p.shift.0), false, &t); + enc.symbol(&mut state, i32::from(p.shift.1), false, &t); + enc.bit(p.extra_plane, &mut state[0], &t); + enc.symbol(&mut state, p.num_h as i32 - 1, false, &t); + enc.symbol(&mut state, p.num_v as i32 - 1, false, &t); + enc.symbol(&mut state, p.sets.len() as i32, false, &t); + for set in &p.sets { + for table in &set.tables { + let mut qstate = [128u8; CONTEXT_SIZE]; + for run in quant_runs(table) { + enc.symbol(&mut qstate, run, false, &t); + } + } + } + for _ in &p.sets { + enc.bit(false, &mut state[0], &t); // states_coded + } + enc.symbol(&mut state, i32::from(p.ec), false, &t); + enc.symbol(&mut state, i32::from(p.intra), false, &t); +} + +// ---- slices ---- + +/// A slice's place in the frame, in pixels. +#[derive(Clone, Copy)] +struct SliceRect { + x: usize, + y: usize, + w: usize, + h: usize, +} + +fn slice_rect(p: &Params, width: usize, height: usize, sx: usize, sy: usize, sw: usize, sh: usize) -> Result { + let (nh, nv) = (p.num_h as usize, p.num_v as usize); + if sx + sw > nh || sy + sh > nv || sw == 0 || sh == 0 { + return Err(Error::Invalid("slice outside the slice raster")); + } + let x0 = sx * width / nh; + let x1 = (sx + sw) * width / nh; + let y0 = sy * height / nv; + let y1 = (sy + sh) * height / nv; + if x1 <= x0 || y1 <= y0 { + return Err(Error::Invalid("empty slice")); + } + Ok(SliceRect { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }) +} + +/// The samples of one plane of a slice with the border of RFC 9043 section 3.1 around them: two +/// columns to the left, one to the right, two rows above. +struct Border { + buf: Vec, + stride: usize, + w: usize, +} + +impl Border { + fn new(w: usize, h: usize) -> Border { + let stride = w + 3; + Border { buf: vec![0; stride * (h + 2)], stride, w } + } + + fn at(&self, x: usize, y: usize) -> usize { + (y + 2) * self.stride + x + 2 + } + + /// Set up the left border of row `y` (the column left of it repeats the row above's first sample). + fn start_row(&mut self, y: usize) { + let row = (y + 2) * self.stride; + self.buf[row] = 0; + self.buf[row + 1] = if y > 0 { self.buf[(y + 1) * self.stride + 2] } else { 0 }; + } + + /// The right border of row `y` repeats its last sample. + fn end_row(&mut self, y: usize) { + let row = (y + 2) * self.stride; + self.buf[row + self.w + 2] = self.buf[row + self.w + 1]; + } + + /// `(context, predictor)` for sample `(x, y)`; `context` is signed (section 3.5). + fn context(&self, x: usize, y: usize, tables: &[[i32; 256]], sixteen_bit_ycbcr: bool) -> (i32, i32) { + let i = self.at(x, y); + let (b, s) = (&self.buf, self.stride); + let (l, ll, t, tl, tr, tt) = (b[i - 1], b[i - 2], b[i - s], b[i - s - 1], b[i - s + 1], b[i - 2 * s]); + let ctx = tables[0][((l - tl) & 255) as usize] + + tables[1][((tl - t) & 255) as usize] + + tables[2][((t - tr) & 255) as usize] + + tables[3][((ll - l) & 255) as usize] + + tables[4][((tt - t) & 255) as usize]; + let (pl, pt, ptl) = if sixteen_bit_ycbcr { + let s16 = |v: i32| if v >= 32768 { v - 65536 } else { v }; + (s16(l), s16(t), s16(tl)) + } else { + (l, t, tl) + }; + (ctx, median(pl, pt, pl + pt - ptl)) + } +} + +fn median(a: i32, b: i32, c: i32) -> i32 { + a.max(b).min(a.min(b).max(c)) +} + +/// The reversible colour transform bits: a plane's samples have `bits + 1` bits. +fn rct_swapped(p: &Params) -> bool { + p.colorspace == Colorspace::Rgb && (9..=15).contains(&p.bits) && !p.extra_plane +} + +fn coded_bits(p: &Params) -> u32 { + if p.colorspace == Colorspace::Rgb { p.bits + 1 } else { p.bits } +} + +/// One plane's samples inside a slice, and which class of states codes them. +struct PlaneCoder { + border: Border, + slot: usize, +} + +/// The adaptive states of one plane class: Y, Cb and Cr together, then transparency (section 3.6). +struct ClassStates { + set: usize, + states: Vec<[u8; CONTEXT_SIZE]>, +} + +fn make_coders(p: &Params, rect: SliceRect, set_idx: &[usize]) -> Result<(Vec, Vec)> { + let mut planes = Vec::new(); + for pl in 0..p.plane_count() { + let (w, h) = plane_dims(rect.w, rect.h, p.colorspace, p.shift, pl, p.chroma_planes); + planes.push(PlaneCoder { border: Border::new(w, h), slot: p.qset_slot(pl) }); + } + let mut classes = Vec::new(); + for slot in 0..=planes.iter().map(|c| c.slot).max().unwrap_or(0) { + let set = *set_idx.get(slot).ok_or(Error::Invalid("missing quant table set index"))?; + let q = p.sets.get(set).ok_or(Error::Invalid("quant table set index out of range"))?; + let states = match p.initial_states.get(set) { + Some(Some(init)) => init.clone(), + _ => vec![[128u8; CONTEXT_SIZE]; q.context_count], + }; + classes.push(ClassStates { set, states }); + } + Ok((planes, classes)) +} + +/// The number of Quantization Table Set indexes in a slice header (section 4.6.5, version 3). +fn set_index_count(p: &Params) -> usize { + 2 + usize::from(p.extra_plane) +} + +fn check_frame_size(p: &Params, w: u32, h: u32) -> Result<()> { + if w == 0 || h == 0 { + return Err(Error::Invalid("empty frame")); + } + let shape = PictureShape { + width: u64::from(w), + height: u64::from(h), + shift_x: u32::from(p.shift.0.min(1)), + shift_y: u32::from(p.shift.1.min(1)), + chroma_planes: if p.chroma_planes { 2 } else { 0 }, + bytes_per_sample: 2, + }; + // The decoded planes and, while a slice decodes, its bordered `i32` copy (2 x the samples at most). + if !shape.fits(5, DECODE_MEMORY_BUDGET) { + return Err(Error::Unsupported("frame size above the memory budget")); + } + if p.shift.0 > 1 || p.shift.1 > 1 { + // Subsampling beyond 2:1 is legal FFV1 (e.g. 4:1:1) but the budget model above is for 2:1. + let extra = (w as u64).checked_mul(h as u64).ok_or(Error::Invalid("frame too large"))?; + if extra > 1 << 28 { + return Err(Error::Unsupported("frame size above the memory budget")); + } + } + Ok(()) +} + +/// A decoder for one stream. +pub struct Decoder { + params: Params, + width: u32, + height: u32, +} + +impl Decoder { + /// Build a decoder from the container's configuration record and the frame size. + pub fn new(config_record: &[u8], width: u32, height: u32) -> Result { + if config_record.len() < 5 { + return Err(Error::Truncated); + } + let (body, _crc) = config_record.split_at(config_record.len() - 4); + if crc32(config_record) != 0 { + return Err(Error::Crc("the configuration record")); + } + let mut rac = Rac::new(body); + let params = parse_params(&mut rac)?; + if rac.consumed() > body.len() + 2 { + return Err(Error::Truncated); + } + check_frame_size(¶ms, width, height)?; + Ok(Decoder { params, width, height }) + } + + /// Decode one frame (a packet from the container). + pub fn decode(&self, packet: &[u8]) -> Result { + let p = &self.params; + let (w, h) = (self.width as usize, self.height as usize); + let planes = p.plane_count(); + let mut frame = Frame { + width: self.width, + height: self.height, + colorspace: p.colorspace, + bit_depth: p.bits as u8, + chroma_shift: if p.chroma_planes { p.shift } else { (0, 0) }, + planes: Vec::with_capacity(planes), + }; + for pl in 0..planes { + let (pw, ph) = plane_dims(w, h, p.colorspace, p.shift, pl, p.chroma_planes); + let mut v = Vec::new(); + v.try_reserve_exact(pw * ph).map_err(|_| Error::Unsupported("frame size above the memory budget"))?; + v.resize(pw * ph, 0u16); + frame.planes.push(v); + } + // Slices are found from the end of the packet through their footers (section 4.9). + let trailer = if p.ec { 8 } else { 3 }; + let slice_count = p.num_h as usize * p.num_v as usize; + let mut end = packet.len(); + let mut spans = Vec::with_capacity(slice_count); + for _ in 0..slice_count { + if end < trailer { + return Err(Error::Truncated); + } + let f = end - trailer; + let size = usize::from(packet[f]) << 16 | usize::from(packet[f + 1]) << 8 | usize::from(packet[f + 2]); + let start = f.checked_sub(size).ok_or(Error::Truncated)?; + spans.push((start, end)); + end = start; + } + spans.reverse(); + for (n, &(start, stop)) in spans.iter().enumerate() { + let slice = &packet[start..stop]; + if p.ec && crc32(slice) != 0 { + return Err(Error::Crc("a slice")); + } + self.decode_slice(slice, n == 0, &mut frame)?; + } + Ok(frame) + } + + fn decode_slice(&self, slice: &[u8], first: bool, frame: &mut Frame) -> Result<()> { + let p = &self.params; + let t = &p.transitions; + let data = &slice[..slice.len() - if p.ec { 8 } else { 3 }]; + let mut rac = Rac::new(data); + // The keyframe flag is the first symbol of the first slice. + // The whole slice, header included, is coded with the stream's state transition table. + let t0 = t; + if first { + let mut ks = 128u8; + if !rac.bit(&mut ks, t0) { + return Err(Error::Unsupported("inter frames (keyframe 0)")); + } + } + let mut hs = [128u8; CONTEXT_SIZE]; + let sx = rac.symbol(&mut hs, false, t0) as usize; + let sy = rac.symbol(&mut hs, false, t0) as usize; + let sw = rac.symbol(&mut hs, false, t0) as usize + 1; + let sh = rac.symbol(&mut hs, false, t0) as usize + 1; + let set_idx: Vec = (0..set_index_count(p)).map(|_| rac.symbol(&mut hs, false, t0).max(0) as usize).collect(); + let _picture_structure = rac.symbol(&mut hs, false, t0); + let _sar = (rac.symbol(&mut hs, false, t0), rac.symbol(&mut hs, false, t0)); + let rect = slice_rect(p, self.width as usize, self.height as usize, sx, sy, sw, sh)?; + let (sx_mask, sy_mask) = ((1usize << p.shift.0) - 1, (1usize << p.shift.1) - 1); + if p.colorspace == Colorspace::YCbCr && p.chroma_planes && (rect.x & sx_mask != 0 || rect.y & sy_mask != 0) { + return Err(Error::Unsupported("slice boundaries that are not multiples of the chroma subsampling")); + } + let (mut coders, mut classes) = make_coders(p, rect, &set_idx)?; + let bits = coded_bits(p); + let mask = (1i32 << bits) - 1; + let sixteen = p.colorspace == Colorspace::YCbCr && p.bits == 16; + let read = |rac: &mut Rac, c: &mut PlaneCoder, cls: &mut ClassStates, x: usize, y: usize| -> i32 { + let q = &p.sets[cls.set]; + let (ctx, pred) = c.border.context(x, y, &q.tables, sixteen); + let (idx, neg) = if ctx < 0 { ((-ctx) as usize, true) } else { (ctx as usize, false) }; + let mut d = rac.symbol(&mut cls.states[idx.min(q.context_count - 1)], true, t); + if neg { + d = -d; + } + let v = (pred + d) & mask; + let at = c.border.at(x, y); + c.border.buf[at] = v; + v + }; + match p.colorspace { + Colorspace::YCbCr => { + for (pl, c) in coders.iter_mut().enumerate() { + let (pw, ph) = plane_dims(rect.w, rect.h, p.colorspace, p.shift, pl, p.chroma_planes); + for y in 0..ph { + c.border.start_row(y); + for x in 0..pw { + read(&mut rac, c, &mut classes[c.slot], x, y); + } + c.border.end_row(y); + } + } + } + Colorspace::Rgb => { + for y in 0..rect.h { + for c in coders.iter_mut() { + c.border.start_row(y); + for x in 0..rect.w { + read(&mut rac, c, &mut classes[c.slot], x, y); + } + c.border.end_row(y); + } + } + } + } + self.store(&coders, rect, frame); + Ok(()) + } + + /// Copy a decoded slice into the frame, undoing the colour transform for RGB. + fn store(&self, coders: &[PlaneCoder], rect: SliceRect, frame: &mut Frame) { + let p = &self.params; + if p.colorspace == Colorspace::YCbCr { + for (pl, c) in coders.iter().enumerate() { + let (pw, ph) = plane_dims(rect.w, rect.h, p.colorspace, p.shift, pl, p.chroma_planes); + let (fw, _) = plane_dims(self.width as usize, self.height as usize, p.colorspace, p.shift, pl, p.chroma_planes); + let (ox, oy) = if p.chroma_planes && (pl == 1 || pl == 2) { (rect.x >> p.shift.0, rect.y >> p.shift.1) } else { (rect.x, rect.y) }; + for y in 0..ph { + for x in 0..pw { + frame.planes[pl][(oy + y) * fw + ox + x] = c.border.buf[c.border.at(x, y)] as u16; + } + } + } + return; + } + let swapped = rct_swapped(p); + let off = 1i32 << p.bits; + let fw = self.width as usize; + for y in 0..rect.h { + for x in 0..rect.w { + let get = |i: usize| coders[i].border.buf[coders[i].border.at(x, y)]; + let (yy, cb, cr) = (get(0), get(1) - off, get(2) - off); + let (r, g, b); + if swapped { + let bb = yy - ((cb + cr) >> 2); + r = cr + bb; + g = cb + bb; + b = bb; + } else { + let gg = yy - ((cb + cr) >> 2); + r = cr + gg; + g = gg; + b = cb + gg; + } + let at = (rect.y + y) * fw + rect.x + x; + frame.planes[0][at] = r as u16; + frame.planes[1][at] = g as u16; + frame.planes[2][at] = b as u16; + if coders.len() > 3 { + frame.planes[3][at] = get(3) as u16; + } + } + } + } +} + +/// Encoder settings. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EncoderConfig { + /// Slices across the frame. + pub slices_h: u32, + /// Slices down the frame. + pub slices_v: u32, + /// Write a CRC in every slice (error detection). + pub slice_crc: bool, +} + +impl Default for EncoderConfig { + fn default() -> Self { + EncoderConfig { slices_h: 1, slices_v: 1, slice_crc: true } + } +} + +/// An encoder for frames of one fixed format. +pub struct Encoder { + params: Params, + width: u32, + height: u32, +} + +impl Encoder { + /// An encoder for frames shaped like `template` (its samples are not used). + pub fn new(template: &Frame, cfg: EncoderConfig) -> Result { + if !template.plane_count_ok() || template.width == 0 || template.height == 0 { + return Err(Error::Input("a frame has 1 to 4 planes and a nonzero size".into())); + } + if !(8..=16).contains(&template.bit_depth) { + return Err(Error::Input("bit depth must be 8 to 16".into())); + } + if cfg.slices_h == 0 + || cfg.slices_v == 0 + || cfg.slices_h > 1024 + || cfg.slices_v > 1024 + || cfg.slices_h > template.width + || cfg.slices_v > template.height + { + return Err(Error::Input("invalid slice raster".into())); + } + let n = template.planes.len(); + let (chroma_planes, extra_plane) = match (template.colorspace, n) { + (Colorspace::YCbCr, 1) => (false, false), + (Colorspace::YCbCr, 2) => (false, true), + (Colorspace::YCbCr, 3) => (true, false), + (Colorspace::YCbCr, _) => (true, true), + (Colorspace::Rgb, 3) => (true, false), + (Colorspace::Rgb, 4) => (true, true), + (Colorspace::Rgb, _) => return Err(Error::Input("RGB frames have 3 or 4 planes".into())), + }; + let shift = if template.colorspace == Colorspace::YCbCr && chroma_planes { template.chroma_shift } else { (0, 0) }; + if shift.0 > 3 || shift.1 > 3 { + return Err(Error::Input("chroma subsampling above 8:1".into())); + } + if template.colorspace == Colorspace::Rgb && template.bit_depth > 15 { + return Err(Error::Input("RGB above 15 bits needs 17-bit coded samples".into())); + } + let params = Params { + coder_type: 1, + transitions: Transitions::default_table(), + colorspace: template.colorspace, + bits: u32::from(template.bit_depth), + chroma_planes, + shift, + extra_plane, + num_h: cfg.slices_h, + num_v: cfg.slices_v, + sets: vec![default_quant_set()], + initial_states: vec![None], + ec: cfg.slice_crc, + intra: true, + }; + // Every slice boundary must be a multiple of the chroma subsampling, so the decoder accepts it. + for i in 0..=cfg.slices_h as usize { + if params.chroma_planes && (i * template.width as usize / cfg.slices_h as usize) & ((1 << shift.0) - 1) != 0 && i != cfg.slices_h as usize + { + return Err(Error::Input("slice boundaries must be multiples of the chroma subsampling".into())); + } + } + for i in 0..cfg.slices_v as usize { + if params.chroma_planes && (i * template.height as usize / cfg.slices_v as usize) & ((1 << shift.1) - 1) != 0 { + return Err(Error::Input("slice boundaries must be multiples of the chroma subsampling".into())); + } + } + Ok(Encoder { params, width: template.width, height: template.height }) + } + + /// The configuration record for the container (`CodecPrivate` and the like). + pub fn config_record(&self) -> Vec { + let mut enc = RacEnc::new(); + write_params(&mut enc, &self.params); + let mut out = enc.finish(); + let crc = crc32(&out); + out.extend_from_slice(&crc.to_be_bytes()); + out + } + + /// Encode one frame as a keyframe packet. + pub fn encode(&self, frame: &Frame) -> Result> { + let p = &self.params; + if frame.width != self.width || frame.height != self.height || frame.colorspace != p.colorspace || u32::from(frame.bit_depth) != p.bits { + return Err(Error::Input("the frame does not match the encoder's format".into())); + } + if frame.planes.len() != p.plane_count() { + return Err(Error::Input("the frame has the wrong number of planes".into())); + } + let shift = if p.chroma_planes { p.shift } else { (0, 0) }; + if p.colorspace == Colorspace::YCbCr && p.chroma_planes && frame.chroma_shift != shift { + return Err(Error::Input("the chroma subsampling does not match".into())); + } + for (pl, plane) in frame.planes.iter().enumerate() { + let (w, h) = frame.dims(pl, p.chroma_planes); + if plane.len() != w * h { + return Err(Error::Input(format!("plane {pl} has {} samples, expected {}", plane.len(), w * h))); + } + if plane.iter().any(|&v| u32::from(v) >> p.bits != 0) { + return Err(Error::Input(format!("plane {pl} has a sample above {} bits", p.bits))); + } + } + let mut out = Vec::new(); + for sy in 0..p.num_v as usize { + for sx in 0..p.num_h as usize { + let rect = slice_rect(p, self.width as usize, self.height as usize, sx, sy, 1, 1)?; + let mut slice = self.encode_slice(frame, rect, sx, sy, out.is_empty())?; + let size = slice.len(); + slice.extend_from_slice(&(size as u32).to_be_bytes()[1..]); + if p.ec { + slice.push(0); // error_status + let crc = crc32(&slice); + slice.extend_from_slice(&crc.to_be_bytes()); + } + out.extend_from_slice(&slice); + } + } + Ok(out) + } + + fn encode_slice(&self, frame: &Frame, rect: SliceRect, sx: usize, sy: usize, first: bool) -> Result> { + let p = &self.params; + let t = &p.transitions; + let t0 = t; + let mut rac = RacEnc::new(); + if first { + let mut ks = 128u8; + rac.bit(true, &mut ks, t0); + } + let mut hs = [128u8; CONTEXT_SIZE]; + for v in [sx as i32, sy as i32, 0, 0] { + rac.symbol(&mut hs, v, false, t0); + } + let set_idx = vec![0usize; set_index_count(p)]; + for &s in &set_idx { + rac.symbol(&mut hs, s as i32, false, t0); + } + for v in [0, 0, 0] { + rac.symbol(&mut hs, v, false, t0); // picture_structure, sar_num, sar_den + } + let (mut coders, mut classes) = make_coders(p, rect, &set_idx)?; + let bits = coded_bits(p); + let half = 1i32 << (bits - 1); + let mask = (1i32 << bits) - 1; + let sixteen = p.colorspace == Colorspace::YCbCr && p.bits == 16; + // The samples to code, one bordered plane's worth per coder. + let values = self.slice_values(frame, rect); + let write = |rac: &mut RacEnc, c: &mut PlaneCoder, cls: &mut ClassStates, x: usize, y: usize, sample: i32| { + let q = &p.sets[cls.set]; + let (ctx, pred) = c.border.context(x, y, &q.tables, sixteen); + let mut d = ((sample - pred + half) & mask) - half; + let (idx, neg) = if ctx < 0 { ((-ctx) as usize, true) } else { (ctx as usize, false) }; + if neg { + d = -d; + } + rac.symbol(&mut cls.states[idx.min(q.context_count - 1)], d, true, t); + let at = c.border.at(x, y); + c.border.buf[at] = sample; + }; + match p.colorspace { + Colorspace::YCbCr => { + for (pl, c) in coders.iter_mut().enumerate() { + let (pw, ph) = plane_dims(rect.w, rect.h, p.colorspace, p.shift, pl, p.chroma_planes); + for y in 0..ph { + c.border.start_row(y); + for x in 0..pw { + write(&mut rac, c, &mut classes[c.slot], x, y, values[pl][y * pw + x]); + } + c.border.end_row(y); + } + } + } + Colorspace::Rgb => { + for y in 0..rect.h { + for (pl, c) in coders.iter_mut().enumerate() { + c.border.start_row(y); + for x in 0..rect.w { + write(&mut rac, c, &mut classes[c.slot], x, y, values[pl][y * rect.w + x]); + } + c.border.end_row(y); + } + } + } + } + Ok(rac.finish()) + } + + /// The slice's samples per coded plane (after the colour transform for RGB). + fn slice_values(&self, frame: &Frame, rect: SliceRect) -> Vec> { + let p = &self.params; + let fw = self.width as usize; + if p.colorspace == Colorspace::YCbCr { + return (0..p.plane_count()) + .map(|pl| { + let (pw, ph) = plane_dims(rect.w, rect.h, p.colorspace, p.shift, pl, p.chroma_planes); + let (full_w, _) = plane_dims(fw, self.height as usize, p.colorspace, p.shift, pl, p.chroma_planes); + let (ox, oy) = + if p.chroma_planes && (pl == 1 || pl == 2) { (rect.x >> p.shift.0, rect.y >> p.shift.1) } else { (rect.x, rect.y) }; + let mut v = Vec::with_capacity(pw * ph); + for y in 0..ph { + for x in 0..pw { + v.push(i32::from(frame.planes[pl][(oy + y) * full_w + ox + x])); + } + } + v + }) + .collect(); + } + let swapped = rct_swapped(p); + let off = 1i32 << p.bits; + let mut planes = vec![Vec::with_capacity(rect.w * rect.h); p.plane_count()]; + for y in 0..rect.h { + for x in 0..rect.w { + let at = (rect.y + y) * fw + rect.x + x; + let (r, g, b) = (i32::from(frame.planes[0][at]), i32::from(frame.planes[1][at]), i32::from(frame.planes[2][at])); + let (yy, cb, cr) = if swapped { + let (cb, cr) = (g - b, r - b); + (b + ((cb + cr) >> 2), cb, cr) + } else { + let (cb, cr) = (b - g, r - g); + (g + ((cb + cr) >> 2), cb, cr) + }; + planes[0].push(yy); + planes[1].push(cb + off); + planes[2].push(cr + off); + if p.extra_plane { + planes[3].push(i32::from(frame.planes[3][at])); + } + } + } + planes + } +} diff --git a/crates/video/src/ffv1/rc.rs b/crates/video/src/ffv1/rc.rs new file mode 100644 index 000000000..fa2a16ee4 --- /dev/null +++ b/crates/video/src/ffv1/rc.rs @@ -0,0 +1,229 @@ +//! The FFV1 range coder (RFC 9043 section 3.8.1): binary decisions with adaptive 8-bit states, +//! and the signed/unsigned integer coding built on them. + +/// RFC 9043 Figure 24: the default state transition table for a coded 1. +const DEFAULT_ONE_STATE: [u8; 256] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, + 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, + 0, 0, 0, 0, +]; + +/// The state machine: the next state after a coded 0 or 1. +#[derive(Clone)] +pub(crate) struct Transitions { + one: [u8; 256], + zero: [u8; 256], +} + +impl Transitions { + /// The default table plus `delta` (`state_transition_delta`, indexed 1 to 255). + pub(crate) fn new(delta: &[i32; 256]) -> Transitions { + let mut one = [0u8; 256]; + for (i, o) in one.iter_mut().enumerate() { + *o = (i32::from(DEFAULT_ONE_STATE[i]) + delta[i]) as u8; + } + let mut zero = [0u8; 256]; + for i in 1..256 { + zero[i] = (256 - i32::from(one[256 - i])) as u8; + } + Transitions { one, zero } + } + + pub(crate) fn default_table() -> Transitions { + Transitions::new(&[0; 256]) + } +} + +/// Reads binary decisions from `data`; bytes past its end read as 0 (the "Closed" mode of 3.8.1.1.1). +pub(crate) struct Decoder<'a> { + data: &'a [u8], + pos: usize, + low: u32, + range: u32, +} + +impl<'a> Decoder<'a> { + pub(crate) fn new(data: &'a [u8]) -> Decoder<'a> { + let b0 = u32::from(data.first().copied().unwrap_or(0)); + let b1 = u32::from(data.get(1).copied().unwrap_or(0)); + let mut low = b0 << 8 | b1; + let range = 0xFF00; + if low >= range { + low = range; + } + Decoder { data, pos: 2, low, range } + } + + /// Bytes the coder has read so far. + pub(crate) fn consumed(&self) -> usize { + self.pos + } + + fn refill(&mut self) { + if self.range < 256 { + self.range <<= 8; + self.low <<= 8; + self.low += u32::from(self.data.get(self.pos).copied().unwrap_or(0)); + self.pos += 1; + } + } + + pub(crate) fn bit(&mut self, state: &mut u8, t: &Transitions) -> bool { + let off = (self.range * u32::from(*state)) >> 8; + self.range -= off; + if self.low < self.range { + *state = t.zero[usize::from(*state)]; + self.refill(); + false + } else { + self.low -= self.range; + *state = t.one[usize::from(*state)]; + self.range = off; + self.refill(); + true + } + } + + /// RFC 9043 Figure 21: `get_symbol`. + pub(crate) fn symbol(&mut self, state: &mut [u8; 32], signed: bool, t: &Transitions) -> i32 { + if self.bit(&mut state[0], t) { + return 0; + } + let mut e = 0usize; + while self.bit(&mut state[1 + e.min(9)], t) { + e += 1; + if e > 24 { + // No valid stream codes a magnitude this large; stop instead of spinning on garbage. + return 0; + } + } + let mut a = 1i32; + for i in (0..e).rev() { + a = a * 2 + i32::from(self.bit(&mut state[22 + i.min(9)], t)); + } + if signed && self.bit(&mut state[11 + e.min(10)], t) { -a } else { a } + } +} + +/// Writes binary decisions; the inverse of [`Decoder`]. +pub(crate) struct Encoder { + out: Vec, + low: u32, + range: u32, +} + +impl Encoder { + pub(crate) fn new() -> Encoder { + Encoder { out: Vec::new(), low: 0, range: 0xFF00 } + } + + fn shift(&mut self) { + while self.range < 256 { + // Bits 15..8 of `low` are final once a carry (bit 16) is added to the bytes before them. + let carry = self.low >> 16; + let byte = ((self.low >> 8) & 0xFF) as u8; + if carry != 0 { + for b in self.out.iter_mut().rev() { + let (v, over) = b.overflowing_add(1); + *b = v; + if !over { + break; + } + } + } + self.out.push(byte); + self.low = (self.low & 0xFF) << 8; + self.range <<= 8; + } + } + + pub(crate) fn bit(&mut self, bit: bool, state: &mut u8, t: &Transitions) { + let off = (self.range * u32::from(*state)) >> 8; + if bit { + self.low += self.range - off; + self.range = off; + *state = t.one[usize::from(*state)]; + } else { + self.range -= off; + *state = t.zero[usize::from(*state)]; + } + self.shift(); + } + + pub(crate) fn symbol(&mut self, state: &mut [u8; 32], v: i32, signed: bool, t: &Transitions) { + if v == 0 { + self.bit(true, &mut state[0], t); + return; + } + self.bit(false, &mut state[0], t); + let a = v.unsigned_abs(); + let e = (31 - a.leading_zeros()) as usize; + for i in 0..e { + self.bit(true, &mut state[1 + i.min(9)], t); + } + self.bit(false, &mut state[1 + e.min(9)], t); + for i in (0..e).rev() { + self.bit((a >> i) & 1 == 1, &mut state[22 + i.min(9)], t); + } + if signed { + self.bit(v < 0, &mut state[11 + e.min(10)], t); + } + } + + /// Finish the stream with the two bytes of the *top* of the final range: whatever bytes follow + /// (zeros, or a CRC in a container's configuration record) still decode inside the range. + pub(crate) fn finish(mut self) -> Vec { + self.low += self.range - 1; + let carry = self.low >> 16; + if carry != 0 { + for b in self.out.iter_mut().rev() { + let (v, over) = b.overflowing_add(1); + *b = v; + if !over { + break; + } + } + } + self.out.push(((self.low >> 8) & 0xFF) as u8); + self.out.push((self.low & 0xFF) as u8); + self.out + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn symbols_round_trip_through_the_range_coder() { + let t = Transitions::default_table(); + let values: Vec = (0..4000).map(|i| ((i * 7919) % 2001) - 1000).chain([0, 0, 0, 65535, -65535, 1, -1]).collect(); + let mut enc = Encoder::new(); + let mut st = [128u8; 32]; + for &v in &values { + enc.symbol(&mut st, v, true, &t); + } + let bytes = enc.finish(); + let mut dec = Decoder::new(&bytes); + let mut st = [128u8; 32]; + for &v in &values { + assert_eq!(dec.symbol(&mut st, true, &t), v); + } + } + + #[test] + fn transition_tables_follow_the_rfc() { + let t = Transitions::default_table(); + assert_eq!(t.one[8], 20); + assert_eq!(t.one[247], 248); + // zero_state_i = 256 - one_state_(256 - i) + assert_eq!(t.zero[128], (256 - i32::from(t.one[128])) as u8); + assert_eq!(t.zero[1], (256 - i32::from(t.one[255])) as u8); + } +} diff --git a/crates/video/src/lib.rs b/crates/video/src/lib.rs index 0d8625bbd..8202a93f8 100644 --- a/crates/video/src/lib.rs +++ b/crates/video/src/lib.rs @@ -10,6 +10,7 @@ //! | `vp8` | [`vp8`] | VP8 (RFC 6386): decoder (`vp8-decode`) and key-frame encoder (`vp8-encode`) | //! | `mpeg2` | [`mpeg2`] | MPEG-2 video (ITU-T H.262) and MPEG-1 video: decoder (`mpeg2-decode`) and MPEG-2 I/P/B encoder (`mpeg2-encode`) | //! | `mpeg4` | [`mpeg4`] | MPEG-4 Part 2 video (ISO/IEC 14496-2, Xvid/DivX): Simple profile encoder (`mpeg4-encode`) | +//! | `ffv1` | [`ffv1`] | FFV1 lossless video (RFC 9043): version 3, range coder, decoder and encoder | //! | `prores` | [`prores`] | Apple ProRes (SMPTE RDD 36): decoder and encoder | //! | `h264` | [`h264`] | ITU-T H.264 / AVC: decoder (`h264-decode`) and encoder (`h264-encode`) | //! | `hevc` | [`hevc`] | ITU-T H.265 / HEVC: decoder (`hevc-decode`) and encoder (`hevc-encode`) | @@ -41,6 +42,9 @@ pub mod mpeg2; #[cfg(feature = "mpeg4-encode")] pub mod mpeg4; +#[cfg(feature = "ffv1")] +pub mod ffv1; + #[cfg(feature = "prores")] pub mod prores; diff --git a/crates/video/tests/ffv1.rs b/crates/video/tests/ffv1.rs new file mode 100644 index 000000000..1d5c73c0b --- /dev/null +++ b/crates/video/tests/ffv1.rs @@ -0,0 +1,304 @@ +//! FFV1 tests: round trips, hostile input, and ffmpeg as the reference (oracle; skipped when ffmpeg +//! is absent, a failure with `CRAFT_MEDIA_REQUIRE_ORACLES=1`). +//! +//! - Our packets, in an AVI with our configuration record, decode in ffmpeg to our source pixels. +//! - ffmpeg's FFV1 files (version 3, range coder, several pixel formats and slice counts) decode +//! with our decoder to ffmpeg's pixels. + +use craft_media::avi::{AviWriter, MuxOptions, StreamSpec, VideoSpec}; +use craft_video::ffv1::{Colorspace, Decoder, Encoder, EncoderConfig, Error, Frame}; +use std::path::Path; +use std::process::Command; + +fn noise(seed: &mut u32, mask: u32) -> u16 { + *seed ^= *seed << 13; + *seed ^= *seed >> 17; + *seed ^= *seed << 5; + (*seed & mask) as u16 +} + +/// A frame of smooth gradients, noise bursts and flat areas. +fn frame(w: u32, h: u32, cs: Colorspace, bits: u8, shift: (u8, u8), planes: usize) -> Frame { + let max = (1u32 << bits) - 1; + let mut seed = 0x9E37_79B9u32; + let mut ps = Vec::new(); + for p in 0..planes { + let (pw, ph) = if cs == Colorspace::YCbCr && (p == 1 || p == 2) && planes >= 3 { + ((w as usize).div_ceil(1 << shift.0), (h as usize).div_ceil(1 << shift.1)) + } else { + (w as usize, h as usize) + }; + let mut v = Vec::with_capacity(pw * ph); + for y in 0..ph { + for x in 0..pw { + let s = match (y / 11 + p) % 3 { + 0 => ((x * 5 + y * 3 + p * 40) as u32 * max / 600) % (max + 1), + 1 => noise(&mut seed, max) as u32, + _ => max / 3, + }; + v.push(s as u16); + } + } + ps.push(v); + } + Frame { width: w, height: h, colorspace: cs, bit_depth: bits, chroma_shift: shift, planes: ps } +} + +fn round_trip(f: &Frame, cfg: EncoderConfig) -> Frame { + let enc = Encoder::new(f, cfg).expect("encoder"); + let config = enc.config_record(); + let packet = enc.encode(f).expect("encode"); + let dec = Decoder::new(&config, f.width, f.height).expect("decoder"); + dec.decode(&packet).expect("decode") +} + +#[test] +fn round_trips_every_shape() { + for (cs, bits, shift, planes) in [ + (Colorspace::YCbCr, 8u8, (0u8, 0u8), 1usize), + (Colorspace::YCbCr, 8, (1, 1), 3), + (Colorspace::YCbCr, 8, (1, 0), 3), + (Colorspace::YCbCr, 8, (0, 0), 4), + (Colorspace::YCbCr, 10, (1, 1), 3), + (Colorspace::YCbCr, 12, (0, 0), 3), + (Colorspace::YCbCr, 16, (1, 0), 3), + (Colorspace::YCbCr, 16, (0, 0), 1), + (Colorspace::Rgb, 8, (0, 0), 3), + (Colorspace::Rgb, 8, (0, 0), 4), + (Colorspace::Rgb, 10, (0, 0), 3), + (Colorspace::Rgb, 12, (0, 0), 4), + (Colorspace::Rgb, 15, (0, 0), 3), + ] { + for (w, h) in [(1, 1), (3, 5), (64, 48), (67, 41)] { + let f = frame(w, h, cs, bits, shift, planes); + for crc in [true, false] { + let back = round_trip(&f, EncoderConfig { slice_crc: crc, ..EncoderConfig::default() }); + assert_eq!(back.planes, f.planes, "{cs:?} {bits}-bit {shift:?} {planes} planes {w}x{h} crc={crc}"); + } + } + } +} + +#[test] +fn round_trips_with_several_slices() { + let f = frame(96, 64, Colorspace::YCbCr, 8, (1, 1), 3); + for (sh, sv) in [(2, 1), (1, 2), (3, 2), (4, 4)] { + let back = round_trip(&f, EncoderConfig { slices_h: sh, slices_v: sv, slice_crc: true }); + assert_eq!(back.planes, f.planes, "{sh}x{sv} slices"); + } + let rgb = frame(50, 30, Colorspace::Rgb, 8, (0, 0), 3); + assert_eq!(round_trip(&rgb, EncoderConfig { slices_h: 3, slices_v: 2, slice_crc: true }).planes, rgb.planes); +} + +#[test] +fn encoder_refuses_what_it_cannot_write() { + let f = frame(8, 8, Colorspace::YCbCr, 8, (1, 1), 3); + assert!(Encoder::new(&f, EncoderConfig { slices_h: 0, ..EncoderConfig::default() }).is_err()); + assert!(Encoder::new(&f, EncoderConfig { slices_h: 9, ..EncoderConfig::default() }).is_err()); + let mut bad = f.clone(); + bad.bit_depth = 7; + assert!(Encoder::new(&bad, EncoderConfig::default()).is_err()); + let mut rgb16 = frame(8, 8, Colorspace::Rgb, 8, (0, 0), 3); + rgb16.bit_depth = 16; + assert!(Encoder::new(&rgb16, EncoderConfig::default()).is_err()); + let enc = Encoder::new(&f, EncoderConfig::default()).expect("encoder"); + let mut wrong = f.clone(); + wrong.planes[1].pop(); + assert!(enc.encode(&wrong).is_err()); + let mut over = f; + over.planes[0][0] = 300; + assert!(enc.encode(&over).is_err()); +} + +#[test] +fn hostile_input_is_an_error_not_a_panic() { + let f = frame(24, 18, Colorspace::YCbCr, 8, (1, 1), 3); + let enc = Encoder::new(&f, EncoderConfig { slices_h: 2, slices_v: 1, slice_crc: true }).expect("encoder"); + let config = enc.config_record(); + let packet = enc.encode(&f).expect("encode"); + // Every truncation of the configuration record and of the packet. + for n in 0..config.len() { + let _ = Decoder::new(&config[..n], 24, 18); + } + let dec = Decoder::new(&config, 24, 18).expect("decoder"); + for n in 0..packet.len() { + let _ = dec.decode(&packet[..n]); + } + // Every single-bit flip: the CRCs catch them in a packet, and none panics. + for i in 0..packet.len() { + for bit in 0..8 { + let mut c = packet.clone(); + c[i] ^= 1 << bit; + assert!(dec.decode(&c).is_err(), "bit {bit} of byte {i} went unnoticed"); + } + } + for i in 0..config.len() { + for bit in 0..8 { + let mut c = config.clone(); + c[i] ^= 1 << bit; + assert!(matches!(Decoder::new(&c, 24, 18), Err(Error::Crc(_))), "config bit {bit} of byte {i}"); + } + } + // Without slice CRCs, flips may decode to wrong pixels but must not panic. + let enc = Encoder::new(&f, EncoderConfig { slice_crc: false, ..EncoderConfig::default() }).expect("encoder"); + let (config, packet) = (enc.config_record(), enc.encode(&f).expect("encode")); + let dec = Decoder::new(&config, 24, 18).expect("decoder"); + for i in 0..packet.len() { + for bit in 0..8 { + let mut c = packet.clone(); + c[i] ^= 1 << bit; + let _ = dec.decode(&c); + } + } + // A huge frame size is refused before any allocation. + assert!(Decoder::new(&config, u32::MAX, u32::MAX).is_err()); +} + +// ---- ffmpeg ---- + +fn ffmpeg_run(ff: &Path, args: &[&str]) -> Vec { + let out = Command::new(ff).args(["-v", "error", "-nostdin", "-y"]).args(args).output().expect("run ffmpeg"); + assert!(out.status.success(), "ffmpeg {args:?}: {}", String::from_utf8_lossy(&out.stderr)); + out.stdout +} + +fn raw_bytes(f: &Frame) -> Vec { + let mut out = Vec::new(); + for p in &f.planes { + for &v in p { + if f.bit_depth == 8 { + out.push(v as u8); + } else { + out.extend_from_slice(&v.to_le_bytes()); + } + } + } + out +} + +/// `(ffmpeg pix_fmt, colourspace, bits, chroma shift, planes)`; RGB planes are G, B, R in ffmpeg's gbrp. +type Format = (&'static str, Colorspace, u8, (u8, u8), usize); + +const FORMATS: &[Format] = &[ + ("gray", Colorspace::YCbCr, 8, (0, 0), 1), + ("yuv420p", Colorspace::YCbCr, 8, (1, 1), 3), + ("yuv422p", Colorspace::YCbCr, 8, (1, 0), 3), + ("yuv444p", Colorspace::YCbCr, 8, (0, 0), 3), + ("yuv420p10le", Colorspace::YCbCr, 10, (1, 1), 3), + ("yuv444p12le", Colorspace::YCbCr, 12, (0, 0), 3), + ("gray16le", Colorspace::YCbCr, 16, (0, 0), 1), + ("yuv444p16le", Colorspace::YCbCr, 16, (0, 0), 3), + ("gbrp", Colorspace::Rgb, 8, (0, 0), 3), + ("gbrp10le", Colorspace::Rgb, 10, (0, 0), 3), + ("gbrp12le", Colorspace::Rgb, 12, (0, 0), 3), + ("yuva444p", Colorspace::YCbCr, 8, (0, 0), 4), + ("gbrap", Colorspace::Rgb, 8, (0, 0), 4), + ("gbrap12le", Colorspace::Rgb, 12, (0, 0), 4), +]; + +/// Formats only ffmpeg writes: our encoder stops at 15-bit RGB (the transform needs 17 bits). +const DECODE_ONLY: &[Format] = &[("gbrp16le", Colorspace::Rgb, 16, (0, 0), 3), ("yuv411p", Colorspace::YCbCr, 8, (2, 0), 3)]; + +/// ffmpeg's planar RGB is G, B, R (then alpha); ours is R, G, B (then alpha). +fn gbr_order(planes: &[Vec]) -> Vec> { + let mut v = vec![planes[1].clone(), planes[2].clone(), planes[0].clone()]; + v.extend(planes[3..].iter().cloned()); + v +} + +fn avi_with(frame: &Frame, config: &[u8], packet: &[u8]) -> Vec { + let mut spec = VideoSpec::new(*b"FFV1", frame.width, frame.height, 25, 1); + spec.format.extra = config.to_vec(); + let mut w = AviWriter::new(std::io::Cursor::new(Vec::new()), vec![StreamSpec::Video(spec)], MuxOptions::default()).expect("writer"); + w.write_chunk(0, packet, true).expect("chunk"); + w.finish().expect("finish").into_inner() +} + +#[test] +fn ffmpeg_decodes_our_packets_to_our_pixels() { + let Some(ff) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("ffv1"); + for &(pix_fmt, cs, bits, shift, planes) in FORMATS { + for (slices_h, slices_v) in [(1, 1), (2, 2), (3, 2)] { + let f = frame(96, 48, cs, bits, shift, planes); + let enc = Encoder::new(&f, EncoderConfig { slices_h, slices_v, slice_crc: true }).expect("encoder"); + let avi = avi_with(&f, &enc.config_record(), &enc.encode(&f).expect("encode")); + let path = dir.join(format!("ours_{pix_fmt}_{slices_h}x{slices_v}.avi")); + std::fs::write(&path, avi).expect("write"); + let theirs = ffmpeg_run(&ff, &["-i", path.to_str().expect("path"), "-f", "rawvideo", "-pix_fmt", pix_fmt, "-"]); + // gbrp is planar G, B, R; our RGB planes are R, G, B. + let mut want = f.clone(); + if cs == Colorspace::Rgb { + want.planes = gbr_order(&f.planes); + } + assert!(theirs == raw_bytes(&want), "{pix_fmt} {slices_h}x{slices_v}: ffmpeg's pixels differ from ours"); + } + } +} + +#[test] +fn our_decoder_reads_ffmpegs_files() { + let Some(ff) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("ffv1"); + for &(pix_fmt, cs, bits, shift, planes) in FORMATS.iter().chain(DECODE_ONLY) { + for slices in ["1", "4", "6"] { + for (ctx, extra) in [("0", false), ("1", true)] { + let path = dir.join(format!("ffmpeg_{pix_fmt}_s{slices}_c{ctx}.avi")); + let lavfi = "testsrc2=size=96x48:rate=1"; + ffmpeg_run( + &ff, + &[ + "-f", + "lavfi", + "-i", + lavfi, + "-frames:v", + "1", + "-vf", + &format!("format={pix_fmt}"), + "-c:v", + "ffv1", + "-level", + "3", + "-coder", + "1", + "-context", + ctx, + "-slices", + slices, + "-slicecrc", + "1", + "-g", + "1", + path.to_str().expect("path"), + ], + ); + let _ = extra; + let file = std::fs::read(&path).expect("read"); + let avi = craft_media::avi::open(&file[..]).expect("open avi"); + let stream = &avi.streams[0]; + let config = stream.video.as_ref().expect("video").extra.clone(); + let chunk = stream.chunks[0]; + let packet = file[chunk.offset as usize..chunk.offset as usize + chunk.size as usize].to_vec(); + let dec = Decoder::new(&config, 96, 48).unwrap_or_else(|e| panic!("{pix_fmt} s{slices} c{ctx}: config: {e}")); + let got = dec.decode(&packet).unwrap_or_else(|e| panic!("{pix_fmt} s{slices} c{ctx}: decode: {e}")); + let theirs = ffmpeg_run(&ff, &["-i", path.to_str().expect("path"), "-f", "rawvideo", "-pix_fmt", pix_fmt, "-"]); + let mut want = got.clone(); + if cs == Colorspace::Rgb { + want.planes = gbr_order(&got.planes); + } + assert_eq!((got.colorspace, got.bit_depth, got.chroma_shift, got.planes.len()), (cs, bits, shift, planes), "{pix_fmt}"); + if theirs != raw_bytes(&want) { + let mut off = 0; + for (i, p) in want.planes.iter().enumerate() { + let n = p.len() * if bits == 8 { 1 } else { 2 }; + let same = theirs[off..off + n] == raw_bytes(&Frame { planes: vec![p.clone()], ..want.clone() })[..]; + eprintln!("{pix_fmt} s{slices} c{ctx}: plane {i} {}", if same { "equal" } else { "DIFFERENT" }); + off += n; + } + panic!("{pix_fmt} s{slices} c{ctx}: our pixels differ from ffmpeg's"); + } + } + } + } +} From 6ac9046bd457f09cdb5eb7b229e50584877b8f68 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 12:10:04 +0000 Subject: [PATCH 061/382] Share streaming TextureCraft tile payloads --- Cargo.lock | 8 + Cargo.toml | 1 + crates/tcraft/Cargo.toml | 15 ++ crates/tcraft/README.md | 14 ++ crates/tcraft/src/lib.rs | 342 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 380 insertions(+) create mode 100644 crates/tcraft/Cargo.toml create mode 100644 crates/tcraft/README.md create mode 100644 crates/tcraft/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index d984ac115..b0f05a3b0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2686,6 +2686,14 @@ dependencies = [ "kurbo 0.13.1", ] +[[package]] +name = "craft-tcraft" +version = "0.1.0" +dependencies = [ + "craft-zip", + "thiserror 2.0.21", +] + [[package]] name = "craft-text" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 77b20da79..d60c3469b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -142,6 +142,7 @@ craft-stencilcraft-document = { path = "crates/stencilcraft-document" } craft-svg-paths = { path = "crates/svg-paths" } craft-stream-codecs = { path = "crates/stream-codecs" } craft-text = { path = "crates/text" } +craft-tcraft = { path = "crates/tcraft" } craft-texture = { path = "crates/texture" } craft-tga = { path = "crates/tga" } craft-timeline = { path = "crates/timeline" } diff --git a/crates/tcraft/Cargo.toml b/crates/tcraft/Cargo.toml new file mode 100644 index 000000000..76eeeafb0 --- /dev/null +++ b/crates/tcraft/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "craft-tcraft" +description = "Streaming binary payloads of TextureCraft project archives" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +craft-zip = { workspace = true } +thiserror = { workspace = true } diff --git a/crates/tcraft/README.md b/crates/tcraft/README.md new file mode 100644 index 000000000..e5831ef98 --- /dev/null +++ b/crates/tcraft/README.md @@ -0,0 +1,14 @@ +# craft-tcraft + +Streaming neutral `TCTX` binary payloads used inside TextureCraft `.tcraft` projects. Sparse +paint data stores 64×64 tiles of little-endian `u16` components; baked maps store dense +little-endian `f32` values. This crate does not yet define the project JSON schema or ZIP +envelope and does not depend on TextureCraft's app types. + +`read_tiles` validates the expected dimensions and components, bounds tile count, rejects +out-of-range and repeated tile positions, and delivers one owned tile at a time. `read_baked` +validates dimensions and declared length and decodes in bounded chunks. Both consume the same +caller-owned `craft_zip::Budget` used for the surrounding project and reject trailing data. +`write_tiles` and `write_baked` stream their bodies rather than copying an entire image; a caller +must discard an incomplete output if a write fails. Limits and ownership rules beyond this +binary format remain with the project reader. diff --git a/crates/tcraft/src/lib.rs b/crates/tcraft/src/lib.rs new file mode 100644 index 000000000..50022bb1e --- /dev/null +++ b/crates/tcraft/src/lib.rs @@ -0,0 +1,342 @@ +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +#![forbid(unsafe_code)] +//! Streaming `TCTX` tile and baked-map payloads in TextureCraft `.tcraft` archives. +//! +//! This codec handles the neutral binary payload, not the application's project model or ZIP +//! envelope. Reads use a caller-owned budget shared with other archive entries. No reader opens +//! a file or reserves memory based on a claimed payload before checking it. + +use std::collections::HashSet; +use std::io::{self, Read, Write}; + +use craft_zip::Budget; + +pub const TILE_SIDE: u32 = 64; +pub const TILE_AREA: usize = 64 * 64; +pub const HEADER_BYTES: u64 = 24; +pub const VERSION: u32 = 1; +const MAGIC: &[u8; 4] = b"TCTX"; +const CHUNK: usize = 1 << 16; + +#[derive(Debug, thiserror::Error)] +pub enum Error { + #[error("invalid TCTX payload: {0}")] + Invalid(String), + #[error("TCTX version {0} is newer than supported")] + NewerVersion(u32), + #[error("TCTX limit: {0}")] + Limit(String), + #[error("TCTX I/O: {0}")] + Io(#[from] io::Error), +} + +/// Width, height and number of components expected by the enclosing project schema. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Layout { + pub width: u32, + pub height: u32, + pub components: usize, +} + +#[derive(Clone, Copy, Debug)] +struct Header { + layout: Layout, + count: u32, +} + +fn charge(budget: &mut Budget, n: u64) -> Result<(), Error> { + budget.charge(n).map_err(|e| Error::Limit(e.to_string())) +} + +fn read_header(reader: &mut impl Read, budget: &mut Budget) -> Result { + charge(budget, HEADER_BYTES)?; + let mut bytes = [0u8; HEADER_BYTES as usize]; + reader.read_exact(&mut bytes)?; + if bytes.get(..4) != Some(MAGIC.as_slice()) { + return Err(Error::Invalid("bad magic".into())); + } + let word = |i: usize| bytes.get(i * 4..i * 4 + 4).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]])).unwrap_or(0); + let version = word(1); + if version > VERSION { + return Err(Error::NewerVersion(version)); + } + Ok(Header { layout: Layout { width: word(2), height: word(3), components: word(4) as usize }, count: word(5) }) +} + +fn write_header(writer: &mut impl Write, layout: Layout, count: u32) -> Result<(), Error> { + let components = u32::try_from(layout.components).map_err(|_| Error::Limit("too many components".into()))?; + writer.write_all(MAGIC)?; + for value in [VERSION, layout.width, layout.height, components, count] { + writer.write_all(&value.to_le_bytes())?; + } + Ok(()) +} + +fn expect_end(reader: &mut impl Read) -> Result<(), Error> { + let mut byte = [0u8; 1]; + if reader.read(&mut byte)? != 0 { + return Err(Error::Invalid("trailing data".into())); + } + Ok(()) +} + +fn tile_dimensions(layout: Layout) -> Result<(u32, u32, usize), Error> { + if layout.width == 0 || layout.height == 0 || layout.components == 0 { + return Err(Error::Invalid("empty tile layout".into())); + } + let x = layout.width.div_ceil(TILE_SIDE); + let y = layout.height.div_ceil(TILE_SIDE); + let bytes = TILE_AREA.checked_mul(layout.components).and_then(|n| n.checked_mul(2)).ok_or_else(|| Error::Limit("tile is too large".into()))?; + Ok((x, y, bytes)) +} + +/// Decode tiles one at a time, transferring each tile to the callback. +/// Positions and duplicate tiles are checked before delivery; the entry must end exactly. +pub fn read_tiles( + reader: &mut impl Read, + expected: Layout, + budget: &mut Budget, + mut tile: impl FnMut(u32, u32, Vec) -> Result<(), Error>, +) -> Result<(), Error> { + let header = read_header(reader, budget)?; + if header.layout != expected { + return Err(Error::Invalid("tile layout differs from the project".into())); + } + let (tiles_x, tiles_y, bytes_per_tile) = tile_dimensions(expected)?; + if u64::from(header.count) > u64::from(tiles_x) * u64::from(tiles_y) { + return Err(Error::Invalid("more tiles than the image holds".into())); + } + let mut bytes = Vec::new(); + let mut seen = HashSet::new(); + for _ in 0..header.count { + let payload = u64::try_from(bytes_per_tile).map_err(|_| Error::Limit("tile is too large".into()))?.saturating_add(8); + charge(budget, payload)?; + if bytes.is_empty() { + bytes.try_reserve_exact(bytes_per_tile).map_err(|_| Error::Limit("tile allocation failed".into()))?; + bytes.resize(bytes_per_tile, 0); + } + let mut pos = [0u8; 8]; + reader.read_exact(&mut pos)?; + let x = u32::from_le_bytes([pos[0], pos[1], pos[2], pos[3]]); + let y = u32::from_le_bytes([pos[4], pos[5], pos[6], pos[7]]); + if x >= tiles_x || y >= tiles_y || seen.contains(&(x, y)) { + return Err(Error::Invalid(format!("bad or repeated tile ({x}, {y})"))); + } + seen.try_reserve(1).map_err(|_| Error::Limit("tile index allocation failed".into()))?; + seen.insert((x, y)); + reader.read_exact(&mut bytes)?; + let mut values = Vec::new(); + values.try_reserve_exact(bytes_per_tile / 2).map_err(|_| Error::Limit("tile allocation failed".into()))?; + values.extend(bytes.as_chunks::<2>().0.iter().map(|b| u16::from_le_bytes(*b))); + tile(x, y, values)?; + } + expect_end(reader) +} + +/// Write tiles in caller order, without buffering the image. A failure may leave a partial +/// entry; callers writing a project should discard the incomplete output. +pub fn write_tiles<'a>( + writer: &mut impl Write, + layout: Layout, + count: u32, + tiles: impl IntoIterator, +) -> Result<(), Error> { + let (tiles_x, tiles_y, bytes_per_tile) = tile_dimensions(layout)?; + if u64::from(count) > u64::from(tiles_x) * u64::from(tiles_y) { + return Err(Error::Invalid("more tiles than the image holds".into())); + } + write_header(writer, layout, count)?; + let mut seen = HashSet::new(); + let mut bytes = Vec::new(); + let mut written = 0u32; + for (x, y, values) in tiles { + if written >= count || x >= tiles_x || y >= tiles_y || seen.contains(&(x, y)) || values.len() != bytes_per_tile / 2 { + return Err(Error::Invalid("bad, repeated or incorrectly sized tile".into())); + } + seen.try_reserve(1).map_err(|_| Error::Limit("tile index allocation failed".into()))?; + seen.insert((x, y)); + if bytes.is_empty() { + bytes.try_reserve_exact(bytes_per_tile).map_err(|_| Error::Limit("tile allocation failed".into()))?; + } + bytes.clear(); + bytes.extend(values.iter().flat_map(|v| v.to_le_bytes())); + writer.write_all(&x.to_le_bytes())?; + writer.write_all(&y.to_le_bytes())?; + writer.write_all(&bytes)?; + written += 1; + } + if written != count { + return Err(Error::Invalid("tile count differs from its data".into())); + } + Ok(()) +} + +/// Read a dense f32 map, validating declared size and charging its shared budget first. +pub fn read_baked( + reader: &mut impl Read, + declared_bytes: u64, + components: usize, + max_texels: u64, + budget: &mut Budget, +) -> Result<(Layout, Vec), Error> { + let header = read_header(reader, budget)?; + let layout = header.layout; + let texels = u64::from(layout.width) * u64::from(layout.height); + if texels == 0 || texels > max_texels || layout.components != components || components == 0 { + return Err(Error::Invalid("bad baked-map dimensions or components".into())); + } + let count = texels.checked_mul(components as u64).ok_or_else(|| Error::Limit("too many map values".into()))?; + let payload = count.checked_mul(4).ok_or_else(|| Error::Limit("map is too large".into()))?; + if declared_bytes != HEADER_BYTES.checked_add(payload).ok_or_else(|| Error::Limit("map is too large".into()))? { + return Err(Error::Invalid("declared map size differs from its dimensions".into())); + } + charge(budget, payload)?; + let count = usize::try_from(count).map_err(|_| Error::Limit("too many map values".into()))?; + let mut values = Vec::new(); + let chunk_bytes = CHUNK.min(count) * 4; + let mut bytes = Vec::new(); + bytes.try_reserve_exact(chunk_bytes).map_err(|_| Error::Limit("map chunk allocation failed".into()))?; + bytes.resize(chunk_bytes, 0); + while values.len() < count { + let n = CHUNK.min(count - values.len()); + let chunk = bytes.get_mut(..n * 4).ok_or_else(|| Error::Invalid("bad map chunk".into()))?; + reader.read_exact(chunk)?; + values.try_reserve(n).map_err(|_| Error::Limit("map allocation failed".into()))?; + values.extend(chunk.as_chunks::<4>().0.iter().map(|b| f32::from_le_bytes(*b))); + } + expect_end(reader)?; + Ok((layout, values)) +} + +/// Write a dense f32 map in bounded chunks without constructing a second copy of its payload. +pub fn write_baked(writer: &mut impl Write, layout: Layout, values: &[f32]) -> Result<(), Error> { + let count = u64::from(layout.width).checked_mul(u64::from(layout.height)).and_then(|n| n.checked_mul(layout.components as u64)); + if layout.width == 0 || layout.height == 0 || layout.components == 0 || count != Some(values.len() as u64) { + return Err(Error::Invalid("map dimensions differ from its data".into())); + } + write_header(writer, layout, 0)?; + let mut bytes = Vec::new(); + bytes.try_reserve_exact(CHUNK * 4).map_err(|_| Error::Limit("map chunk allocation failed".into()))?; + for chunk in values.chunks(CHUNK) { + bytes.clear(); + bytes.extend(chunk.iter().flat_map(|v| v.to_le_bytes())); + writer.write_all(&bytes)?; + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Cursor; + + fn header(layout: Layout, count: u32) -> Vec { + let mut bytes = Vec::new(); + write_header(&mut bytes, layout, count).unwrap(); + bytes + } + + #[test] + fn baked_map_matches_the_native_little_endian_wire_layout() { + let layout = Layout { width: 2, height: 1, components: 1 }; + let mut expected = b"TCTX".to_vec(); + for value in [1u32, 2, 1, 1, 0] { + expected.extend_from_slice(&value.to_le_bytes()); + } + expected.extend_from_slice(&1.0f32.to_le_bytes()); + expected.extend_from_slice(&(-0.5f32).to_le_bytes()); + let mut actual = Vec::new(); + write_baked(&mut actual, layout, &[1.0, -0.5]).unwrap(); + assert_eq!(actual, expected); + let (decoded, values) = read_baked(&mut Cursor::new(&expected), expected.len() as u64, 1, 2, &mut Budget::new("project", 32)).unwrap(); + assert_eq!(decoded, layout); + assert_eq!(values, [1.0, -0.5]); + expected[4..8].copy_from_slice(&2u32.to_le_bytes()); + assert!(matches!(read_baked(&mut Cursor::new(&expected), 32, 1, 2, &mut Budget::new("project", 32)), Err(Error::NewerVersion(2)))); + } + + #[test] + fn dense_maps_round_trip_bit_exactly_in_bounded_chunks() { + let layout = Layout { width: 300, height: 300, components: 1 }; + let mut values = vec![0.25; 90_000]; + values[123] = f32::from_bits(0x7fc0_1234); + let mut bytes = Vec::new(); + write_baked(&mut bytes, layout, &values).unwrap(); + let mut budget = Budget::new("project", bytes.len() as u64); + let (decoded_layout, decoded) = read_baked(&mut Cursor::new(&bytes), bytes.len() as u64, 1, 100_000, &mut budget).unwrap(); + assert_eq!(decoded_layout, layout); + assert!(decoded.iter().zip(values.iter()).all(|(a, b)| a.to_bits() == b.to_bits())); + assert_eq!(budget.remaining(), 0); + } + + #[test] + fn dense_maps_refuse_false_lengths_limits_and_trailing_data() { + let layout = Layout { width: 2, height: 2, components: 1 }; + let mut bytes = Vec::new(); + write_baked(&mut bytes, layout, &[1.0; 4]).unwrap(); + let mut budget = Budget::new("project", 100); + assert!(read_baked(&mut Cursor::new(&bytes), 999, 1, 4, &mut budget).is_err()); + let mut budget = Budget::new("project", 39); + assert!(matches!(read_baked(&mut Cursor::new(&bytes), 40, 1, 4, &mut budget), Err(Error::Limit(_)))); + let mut extra = bytes.clone(); + extra.push(0); + let mut budget = Budget::new("project", 100); + assert!(read_baked(&mut Cursor::new(extra), 40, 1, 4, &mut budget).is_err()); + } + + #[test] + fn hostile_headers_and_tiles_are_rejected_without_trusting_counts() { + let layout = Layout { width: 64, height: 64, components: 1 }; + let mut bad_magic = header(layout, 0); + bad_magic[0] = b'X'; + assert!(read_tiles(&mut Cursor::new(bad_magic), layout, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(header(layout, 2)), layout, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + let other = Layout { width: 65, ..layout }; + assert!(read_tiles(&mut Cursor::new(header(layout, 0)), other, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + let mut outside = header(layout, 1); + outside.extend_from_slice(&1u32.to_le_bytes()); + outside.extend_from_slice(&0u32.to_le_bytes()); + assert!(read_tiles(&mut Cursor::new(outside), layout, &mut Budget::new("project", 10_000), |_, _, _| Ok(())).is_err()); + let mut truncated = header(layout, 1); + truncated.extend_from_slice(&[0; 8]); + assert!(read_tiles(&mut Cursor::new(truncated), layout, &mut Budget::new("project", 10_000), |_, _, _| Ok(())).is_err()); + let mut extra = header(layout, 0); + extra.push(1); + assert!(read_tiles(&mut Cursor::new(extra), layout, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + } + + #[test] + fn sparse_tiles_stream_and_reject_duplicates_and_short_budget() { + let layout = Layout { width: 128, height: 64, components: 1 }; + let mut bytes = header(layout, 2); + for x in [0u32, 1] { + bytes.extend_from_slice(&x.to_le_bytes()); + bytes.extend_from_slice(&0u32.to_le_bytes()); + for _ in 0..TILE_AREA { + bytes.extend_from_slice(&(x as u16 + 1).to_le_bytes()); + } + } + let first = vec![1u16; TILE_AREA]; + let second = vec![2u16; TILE_AREA]; + let mut written = Vec::new(); + write_tiles(&mut written, layout, 2, [(0, 0, first.as_slice()), (1, 0, second.as_slice())]).unwrap(); + assert_eq!(written, bytes, "the streamed writer keeps the native wire layout"); + assert!(write_tiles(&mut Vec::new(), layout, 2, [(0, 0, first.as_slice())]).is_err()); + let mut seen = Vec::new(); + let mut budget = Budget::new("project", bytes.len() as u64); + read_tiles(&mut Cursor::new(&bytes), layout, &mut budget, |x, y, tile| { + seen.push((x, y, tile.first().copied())); + Ok(()) + }) + .unwrap(); + assert_eq!(seen, [(0, 0, Some(1)), (1, 0, Some(2))]); + let mut duplicate = bytes.clone(); + let second = HEADER_BYTES as usize + 8 + TILE_AREA * 2; + duplicate[second..second + 4].copy_from_slice(&0u32.to_le_bytes()); + assert!(read_tiles(&mut Cursor::new(duplicate), layout, &mut Budget::new("project", u64::MAX), |_, _, _| Ok(())).is_err()); + assert!(matches!( + read_tiles(&mut Cursor::new(bytes), layout, &mut Budget::new("project", HEADER_BYTES), |_, _, _| Ok(())), + Err(Error::Limit(_)) + )); + } +} From 5f46c0ab25f067f6fdb863c7e1f9ff567712f394 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 12:23:23 +0000 Subject: [PATCH 062/382] Preserve project budget and streaming IO errors --- crates/tcraft/src/lib.rs | 51 ++++++++++++++++++++++++---------------- 1 file changed, 31 insertions(+), 20 deletions(-) diff --git a/crates/tcraft/src/lib.rs b/crates/tcraft/src/lib.rs index 50022bb1e..4646d8717 100644 --- a/crates/tcraft/src/lib.rs +++ b/crates/tcraft/src/lib.rs @@ -24,6 +24,8 @@ pub enum Error { Invalid(String), #[error("TCTX version {0} is newer than supported")] NewerVersion(u32), + #[error("TCTX budget: {0}")] + Budget(#[from] craft_zip::Exceeded), #[error("TCTX limit: {0}")] Limit(String), #[error("TCTX I/O: {0}")] @@ -45,10 +47,10 @@ struct Header { } fn charge(budget: &mut Budget, n: u64) -> Result<(), Error> { - budget.charge(n).map_err(|e| Error::Limit(e.to_string())) + budget.charge(n).map_err(Error::from) } -fn read_header(reader: &mut impl Read, budget: &mut Budget) -> Result { +fn read_header(reader: &mut (impl Read + ?Sized), budget: &mut Budget) -> Result { charge(budget, HEADER_BYTES)?; let mut bytes = [0u8; HEADER_BYTES as usize]; reader.read_exact(&mut bytes)?; @@ -63,7 +65,7 @@ fn read_header(reader: &mut impl Read, budget: &mut Budget) -> Result Result<(), Error> { +fn write_header(writer: &mut (impl Write + ?Sized), layout: Layout, count: u32) -> Result<(), Error> { let components = u32::try_from(layout.components).map_err(|_| Error::Limit("too many components".into()))?; writer.write_all(MAGIC)?; for value in [VERSION, layout.width, layout.height, components, count] { @@ -72,7 +74,7 @@ fn write_header(writer: &mut impl Write, layout: Layout, count: u32) -> Result<( Ok(()) } -fn expect_end(reader: &mut impl Read) -> Result<(), Error> { +fn expect_end(reader: &mut (impl Read + ?Sized)) -> Result<(), Error> { let mut byte = [0u8; 1]; if reader.read(&mut byte)? != 0 { return Err(Error::Invalid("trailing data".into())); @@ -93,12 +95,17 @@ fn tile_dimensions(layout: Layout) -> Result<(u32, u32, usize), Error> { /// Decode tiles one at a time, transferring each tile to the callback. /// Positions and duplicate tiles are checked before delivery; the entry must end exactly. pub fn read_tiles( - reader: &mut impl Read, + reader: &mut (impl Read + ?Sized), expected: Layout, + max_texels: u64, budget: &mut Budget, mut tile: impl FnMut(u32, u32, Vec) -> Result<(), Error>, ) -> Result<(), Error> { let header = read_header(reader, budget)?; + let texels = u64::from(expected.width) * u64::from(expected.height); + if texels == 0 || texels > max_texels { + return Err(Error::Limit("tile image exceeds its texel limit".into())); + } if header.layout != expected { return Err(Error::Invalid("tile layout differs from the project".into())); } @@ -136,7 +143,7 @@ pub fn read_tiles( /// Write tiles in caller order, without buffering the image. A failure may leave a partial /// entry; callers writing a project should discard the incomplete output. pub fn write_tiles<'a>( - writer: &mut impl Write, + writer: &mut (impl Write + ?Sized), layout: Layout, count: u32, tiles: impl IntoIterator, @@ -173,7 +180,7 @@ pub fn write_tiles<'a>( /// Read a dense f32 map, validating declared size and charging its shared budget first. pub fn read_baked( - reader: &mut impl Read, + reader: &mut (impl Read + ?Sized), declared_bytes: u64, components: usize, max_texels: u64, @@ -188,7 +195,7 @@ pub fn read_baked( let count = texels.checked_mul(components as u64).ok_or_else(|| Error::Limit("too many map values".into()))?; let payload = count.checked_mul(4).ok_or_else(|| Error::Limit("map is too large".into()))?; if declared_bytes != HEADER_BYTES.checked_add(payload).ok_or_else(|| Error::Limit("map is too large".into()))? { - return Err(Error::Invalid("declared map size differs from its dimensions".into())); + return Err(Error::Invalid(format!("{declared_bytes} bytes for a {}×{}×{} map", layout.width, layout.height, layout.components))); } charge(budget, payload)?; let count = usize::try_from(count).map_err(|_| Error::Limit("too many map values".into()))?; @@ -209,7 +216,7 @@ pub fn read_baked( } /// Write a dense f32 map in bounded chunks without constructing a second copy of its payload. -pub fn write_baked(writer: &mut impl Write, layout: Layout, values: &[f32]) -> Result<(), Error> { +pub fn write_baked(writer: &mut (impl Write + ?Sized), layout: Layout, values: &[f32]) -> Result<(), Error> { let count = u64::from(layout.width).checked_mul(u64::from(layout.height)).and_then(|n| n.checked_mul(layout.components as u64)); if layout.width == 0 || layout.height == 0 || layout.components == 0 || count != Some(values.len() as u64) { return Err(Error::Invalid("map dimensions differ from its data".into())); @@ -277,7 +284,7 @@ mod tests { let mut budget = Budget::new("project", 100); assert!(read_baked(&mut Cursor::new(&bytes), 999, 1, 4, &mut budget).is_err()); let mut budget = Budget::new("project", 39); - assert!(matches!(read_baked(&mut Cursor::new(&bytes), 40, 1, 4, &mut budget), Err(Error::Limit(_)))); + assert!(matches!(read_baked(&mut Cursor::new(&bytes), 40, 1, 4, &mut budget), Err(Error::Budget(_)))); let mut extra = bytes.clone(); extra.push(0); let mut budget = Budget::new("project", 100); @@ -287,22 +294,26 @@ mod tests { #[test] fn hostile_headers_and_tiles_are_rejected_without_trusting_counts() { let layout = Layout { width: 64, height: 64, components: 1 }; + assert!(matches!( + read_tiles(&mut Cursor::new(header(layout, 0)), layout, 4095, &mut Budget::new("project", 100), |_, _, _| Ok(())), + Err(Error::Limit(_)) + )); let mut bad_magic = header(layout, 0); bad_magic[0] = b'X'; - assert!(read_tiles(&mut Cursor::new(bad_magic), layout, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); - assert!(read_tiles(&mut Cursor::new(header(layout, 2)), layout, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(bad_magic), layout, u64::MAX, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(header(layout, 2)), layout, u64::MAX, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); let other = Layout { width: 65, ..layout }; - assert!(read_tiles(&mut Cursor::new(header(layout, 0)), other, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(header(layout, 0)), other, u64::MAX, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); let mut outside = header(layout, 1); outside.extend_from_slice(&1u32.to_le_bytes()); outside.extend_from_slice(&0u32.to_le_bytes()); - assert!(read_tiles(&mut Cursor::new(outside), layout, &mut Budget::new("project", 10_000), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(outside), layout, u64::MAX, &mut Budget::new("project", 10_000), |_, _, _| Ok(())).is_err()); let mut truncated = header(layout, 1); truncated.extend_from_slice(&[0; 8]); - assert!(read_tiles(&mut Cursor::new(truncated), layout, &mut Budget::new("project", 10_000), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(truncated), layout, u64::MAX, &mut Budget::new("project", 10_000), |_, _, _| Ok(())).is_err()); let mut extra = header(layout, 0); extra.push(1); - assert!(read_tiles(&mut Cursor::new(extra), layout, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(extra), layout, u64::MAX, &mut Budget::new("project", 100), |_, _, _| Ok(())).is_err()); } #[test] @@ -324,7 +335,7 @@ mod tests { assert!(write_tiles(&mut Vec::new(), layout, 2, [(0, 0, first.as_slice())]).is_err()); let mut seen = Vec::new(); let mut budget = Budget::new("project", bytes.len() as u64); - read_tiles(&mut Cursor::new(&bytes), layout, &mut budget, |x, y, tile| { + read_tiles(&mut Cursor::new(&bytes), layout, u64::MAX, &mut budget, |x, y, tile| { seen.push((x, y, tile.first().copied())); Ok(()) }) @@ -333,10 +344,10 @@ mod tests { let mut duplicate = bytes.clone(); let second = HEADER_BYTES as usize + 8 + TILE_AREA * 2; duplicate[second..second + 4].copy_from_slice(&0u32.to_le_bytes()); - assert!(read_tiles(&mut Cursor::new(duplicate), layout, &mut Budget::new("project", u64::MAX), |_, _, _| Ok(())).is_err()); + assert!(read_tiles(&mut Cursor::new(duplicate), layout, u64::MAX, &mut Budget::new("project", u64::MAX), |_, _, _| Ok(())).is_err()); assert!(matches!( - read_tiles(&mut Cursor::new(bytes), layout, &mut Budget::new("project", HEADER_BYTES), |_, _, _| Ok(())), - Err(Error::Limit(_)) + read_tiles(&mut Cursor::new(bytes), layout, u64::MAX, &mut Budget::new("project", HEADER_BYTES), |_, _, _| Ok(())), + Err(Error::Budget(_)) )); } } From 51a35cecb7b3d0416f0195032bbcc7f960731688 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sun, 15 Nov 2026 13:27:34 +0100 Subject: [PATCH 063/382] flow: keep the old paragraph direction in the tracked formatting-change snapshot Co-Authored-By: Claude Sonnet 5.5 --- crates/flow/src/from_doc.rs | 5 ++++- crates/rtf/src/doc/tests.rs | 24 ++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/crates/flow/src/from_doc.rs b/crates/flow/src/from_doc.rs index ea7f6fc92..717283f57 100644 --- a/crates/flow/src/from_doc.rs +++ b/crates/flow/src/from_doc.rs @@ -661,7 +661,10 @@ fn flow_paras_in(doc: &Document, p: &Paragraph, opts: FlowOpts) -> Vec { { (li.list, li.label) = (0, None); } - let old = Para { kind, list, align: c.old.align, page_break: c.old.page_break_before.unwrap_or(false), ..Default::default() }; + // Direction resolved like the current paragraph's: the old properties' own `w:bidi`, else + // the style's. + let rtl = doc.styles.resolve_para(&c.old).bidi; + let old = Para { kind, list, align: c.old.align, rtl, page_break: c.old.page_break_before.unwrap_or(false), ..Default::default() }; Box::new(FmtChange { mark: rev_mark(doc, c.rev), old }) }); } diff --git a/crates/rtf/src/doc/tests.rs b/crates/rtf/src/doc/tests.rs index 8313ad5b8..bf98d190a 100644 --- a/crates/rtf/src/doc/tests.rs +++ b/crates/rtf/src/doc/tests.rs @@ -94,6 +94,30 @@ fn oldpprops_keep_the_old_paragraph_direction() { assert_eq!(c.old.bidi, Some(true)); } +#[test] +fn tracked_rtl_to_ltr_change_from_a_document_keeps_the_old_direction() { + use craft_wordmodel::props::{CharProps, ParaProps, PropChange}; + use craft_wordmodel::{Revision, RevisionKind}; + // Document origin (not RTF): now LTR, before RTL. + let mut p = craft_wordmodel::Paragraph::with_text("A", CharProps::default()); + p.props.bidi = Some(false); + p.props.fmt_change = PropChange::boxed(0, ParaProps { bidi: Some(true), ..Default::default() }); + let doc = doc_with(vec![p], vec![Revision::new(RevisionKind::Format, "Bob", "2025-01-02T08:05:00Z")]); + let flow = model::from_doc_tracked(&doc); + let Some(FBlock::Para(fp)) = flow.blocks.first() else { panic!("no paragraph") }; + assert!(!fp.rtl); + assert!(fp.fmt_change.as_deref().expect("change").old.rtl, "snapshot keeps RTL"); + let rtf = export(&doc); + assert!(rtf.contains("{\\*\\oldpprops"), "{rtf}"); + let back = import(rtf.as_bytes()).unwrap(); + let p = doc_paras(&back)[0]; + assert_ne!(p.props.bidi, Some(true), "current direction is LTR"); + let change = p.props.fmt_change.as_deref().expect("change read back"); + assert_eq!(change.old.bidi, Some(true)); + // Reject restores RTL. + assert_eq!(change.old.formatting().bidi, Some(true)); +} + #[test] fn stylesheet_names_take_unicode_escapes() { // \u116?=t \u105?=i \u116?=t \u108?=l \u101?=e — how Word writes a non-Latin style name. From b4463c620348f649b2907e35aaef901010130842 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sun, 15 Nov 2026 13:30:44 +0100 Subject: [PATCH 064/382] docx charts: outline unfilled bars, honour no-fill areas, keep source-linked label formats Co-Authored-By: Claude Sonnet 5.5 --- crates/docx/src/read/chart/model.rs | 5 ++- crates/docx/src/read/chart/parse.rs | 17 ++++--- crates/docx/src/read/chart/plot.rs | 10 ++++- crates/docx/src/read/chart/polar.rs | 2 +- crates/docx/src/read/chart/tests.rs | 69 +++++++++++++++++++++++++++++ 5 files changed, 91 insertions(+), 12 deletions(-) diff --git a/crates/docx/src/read/chart/model.rs b/crates/docx/src/read/chart/model.rs index 37d06e31f..13da1d654 100644 --- a/crates/docx/src/read/chart/model.rs +++ b/crates/docx/src/read/chart/model.rs @@ -162,8 +162,9 @@ pub(super) struct Series { pub(super) x_fmt: Option, /// Data labels on or off for this series (`c:dLbls` of its own), when it says. pub(super) labels: Option, - /// The labels' own number format (`c:dLbls/c:numFmt` not linked to the source), if any. - pub(super) label_fmt: Option, + /// The labels' number format (`c:dLbls/c:numFmt`): `None` when not given (the chart type's + /// applies), `Some(None)` when linked to the source, else `Some(Some(code))`. + pub(super) label_fmt: Option>, /// The data labels' `c:dLblPos`, when the file gives a known one. pub(super) label_pos: Option, /// The marker's own fill (`c:marker/c:spPr`); without it markers take the automatic colour. diff --git a/crates/docx/src/read/chart/parse.rs b/crates/docx/src/read/chart/parse.rs index 67b09d795..522d50b3b 100644 --- a/crates/docx/src/read/chart/parse.rs +++ b/crates/docx/src/read/chart/parse.rs @@ -44,6 +44,7 @@ impl Chart { s.values.resize(n, None); s.xs.resize(n, None); s.labels = Some(s.labels.or(type_labels).unwrap_or(false)); + // Absent (`None`) inherits the chart type's; explicitly source-linked (`Some(None)`) does not. if s.label_fmt.is_none() { s.label_fmt.clone_from(&type_fmt); } @@ -191,13 +192,15 @@ fn show_values(d: Option<&El>) -> Option { d.child("c:showVal").map(|v| v.attr("val").is_none_or(truthy)) } -/// The number format of data labels (`c:dLbls/c:numFmt`) when it is not linked to the source. -fn label_format(d: Option<&El>) -> Option { - d?.child("c:numFmt") - .filter(|f| f.attr("sourceLinked") != Some("1")) - .and_then(|f| f.attr("formatCode")) - .filter(|f| f.chars().count() <= craft_wordmodel::chart::MAX_FMT) - .map(str::to_string) +/// The number format of data labels (`c:dLbls/c:numFmt`): `None` when the labels say nothing, +/// `Some(None)` when they are linked to the source (so a chart-level format does not apply), +/// `Some(Some(code))` for their own format code. +fn label_format(d: Option<&El>) -> Option> { + let f = d?.child("c:numFmt")?; + if f.attr("sourceLinked").is_some_and(truthy) { + return Some(None); + } + f.attr("formatCode").filter(|f| f.chars().count() <= craft_wordmodel::chart::MAX_FMT).map(|f| Some(f.to_string())) } fn legend_pos(chart: &El) -> Option { diff --git a/crates/docx/src/read/chart/plot.rs b/crates/docx/src/read/chart/plot.rs index f671f1d49..22d05b554 100644 --- a/crates/docx/src/read/chart/plot.rs +++ b/crates/docx/src/read/chart/plot.rs @@ -468,7 +468,11 @@ fn bars(out: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec, c: &Chart, g: &Frame, labels: &mut Vec Option { return None; } let v = s.raw.get(i).copied().flatten()?; - let fmt = s.label_fmt.as_deref().or(s.fmt.as_deref()).filter(|f| !f.eq_ignore_ascii_case("General")); + let fmt = s.label_fmt.as_ref().map_or(s.fmt.as_deref(), |f| f.as_deref().or(s.fmt.as_deref())).filter(|f| !f.eq_ignore_ascii_case("General")); Some(match fmt { Some(f) => format_value(v, f, 1.0), None => general_value(v), diff --git a/crates/docx/src/read/chart/tests.rs b/crates/docx/src/read/chart/tests.rs index e5d7e4db6..ae80c028e 100644 --- a/crates/docx/src/read/chart/tests.rs +++ b/crates/docx/src/read/chart/tests.rs @@ -830,3 +830,72 @@ fn horizontal_value_axis_title_gets_its_own_strip() { let p = plot_left(&items).unwrap(); assert!(p.is_finite() && p <= 300.0 * 0.3, "{p}"); } + +/// A one-series chart whose series carries `sp` as its `c:spPr`. +fn chart_with_sp(kind: &str, sp: &str) -> Vec { + let s = ser(0, "S", None, &["Q1", "Q2"], &["4", "8"]).replace("", &format!("{sp}")); + let plot = match kind { + "area" => format!( + r#"{s}"# + ), + dir => format!( + r#"{s}"# + ), + }; + chart_items(&space(&plot), &theme(), 300.0, 200.0) +} + +/// The series' closed shapes: (filled, stroked with the given width). +fn series_shapes(items: &[GraphicItem], width: f32) -> (usize, usize) { + let closed = |segs: &[PathSeg]| segs.iter().any(|s| matches!(s, PathSeg::Close)); + let fills = items.iter().filter(|it| matches!(it, GraphicItem::Path { segs, fill: Some(_), .. } if closed(segs))).count(); + let strokes = items + .iter() + .filter(|it| matches!(it, GraphicItem::Path { segs, fill: None, stroke: Some(_), stroke_width, .. } if closed(segs) && (*stroke_width - width).abs() < 0.01)) + .count(); + (fills, strokes) +} + +#[test] +fn unfilled_bars_keep_their_explicit_outline() { + let outlined = r#""#; + let no_line = r#""#; + for dir in ["col", "bar"] { + // Two points, two outlines, no fill. + assert_eq!(series_shapes(&chart_with_sp(dir, outlined), 2.0), (0, 2), "{dir}"); + // Control: no fill and no line draws nothing. + assert_eq!(series_shapes(&chart_with_sp(dir, no_line), 2.0), (0, 0), "{dir}"); + } +} + +#[test] +fn no_fill_area_series_is_not_painted() { + let filled = r#""#; + let none = r#""#; + assert_eq!(series_shapes(&chart_with_sp("area", filled), 2.0).0, 1); + assert_eq!(series_shapes(&chart_with_sp("area", none), 2.0).0, 0); +} + +#[test] +fn source_linked_series_labels_do_not_inherit_the_chart_format() { + let dl = |fmt: &str| format!(r#""#); + let shown = |items: &[GraphicItem]| -> Vec { + items.iter().filter_map(|it| if let GraphicItem::Text { text, .. } = it { Some(text.clone()) } else { None }).collect() + }; + // Chart-level 0%; the series' own labels are `linked` (or have no labels element at all). + let run = |series_dl: &str| { + let s = ser(0, "S", Some("FF0000"), &["Q1", "Q2", "Q3"], &["3.2", "4.1", "5"]).replace("", &format!("{series_dl}")); + let chart_dl = dl("0%").replace("{}", "0"); + let plot = format!( + r#"{s}{chart_dl}"# + ); + shown(&chart_items(&space(&plot), &theme(), 300.0, 200.0)) + }; + for linked in ["1", "true"] { + let own = run(&dl("General").replace("{}", linked)); + assert!(own.contains(&"3.2".to_string()) && !own.contains(&"320%".to_string()), "sourceLinked={linked}: {own:?}"); + } + // Control: a series without a label format still takes the chart's. + let inherited = run(r#""#); + assert!(inherited.contains(&"320%".to_string()), "{inherited:?}"); +} From e2e2ce2c889f0fe777e09161c5a0f1c8582246b3 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 12:34:42 +0000 Subject: [PATCH 065/382] Retain IJG and SIMD notices for shared JPEG encoding --- ATTRIBUTION.md | 1 + NOTICE | 123 ++++++++++++ crates/image-codecs/NOTICE | 122 ++++++++++++ crates/image-codecs/README.md | 8 + licenses/jpeg-encoder-0.6.1/IJG-NOTICE.txt | 72 +++++++ licenses/jpeg-encoder-0.6.1/LICENSE-APACHE | 201 ++++++++++++++++++++ licenses/jpeg-encoder-0.6.1/LICENSE-MIT | 25 +++ licenses/jpeg-encoder-0.6.1/SIMD-NOTICE.txt | 8 + licenses/jpeg-encoder-0.6.1/SOURCE.json | 29 +++ 9 files changed, 589 insertions(+) create mode 100644 crates/image-codecs/NOTICE create mode 100644 licenses/jpeg-encoder-0.6.1/IJG-NOTICE.txt create mode 100644 licenses/jpeg-encoder-0.6.1/LICENSE-APACHE create mode 100644 licenses/jpeg-encoder-0.6.1/LICENSE-MIT create mode 100644 licenses/jpeg-encoder-0.6.1/SIMD-NOTICE.txt create mode 100644 licenses/jpeg-encoder-0.6.1/SOURCE.json diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index 77d3578cb..cc808c328 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -6,6 +6,7 @@ author, source and license. Library code and original assets are under the repos | File | Author | Source | License | |---|---|---|---| +| `licenses/jpeg-encoder-0.6.1/`, `crates/image-codecs/NOTICE` | jpeg-encoder contributors and the IJG, libjpeg-turbo and SIMD authors named in the retained notices | [jpeg-encoder 0.6.1](https://crates.io/crates/jpeg-encoder/0.6.1), used unmodified; source checksums in `SOURCE.json` | (MIT OR Apache-2.0) AND IJG | | `crates/smime/testdata/` | MailCraft contributors; RFC 9216 example certificates | [MailCraft at 240d1d42](https://github.com/UCS-Care-Group/mailcraft/tree/240d1d42fe394cf3274402b180663ba9b43ca180/crates/smime/testdata), restored unmodified; provenance in the directory README | MIT OR Apache-2.0 (source repository) | | `licenses/dwg/acadrust-MPL-2.0.txt`, `licenses/dwg/acadrust-THIRD_PARTY_NOTICES.md` | `acadrust` contributors; ACadSharp authors for the noted ported routines | [acadrust 0.6.6](https://github.com/hakanaktt/acadrust), used unmodified as `craft-dwg`'s optional native dependency | MPL-2.0; embedded ACadSharp notice is MIT; see both retained files | | `crates/cms/profiles/photocraft-coated-cmyk.icc` | PhotoCraft contributors; generated by `craft_cms::synth::coated_cmyk` | [PhotoCraft `crates/cms`](https://github.com/storytold/photocraft/tree/b3222ee8e7e6bcb4799c37f904c595f20f9baf5e/crates/cms) | CC0-1.0 | diff --git a/NOTICE b/NOTICE index 4fa5e4754..c3cdbabc8 100644 --- a/NOTICE +++ b/NOTICE @@ -296,3 +296,126 @@ implementation, https://github.com/macosforge/alac at c38887c5c5e64a4b31108733bd (LICENSE-APACHE). The files are modified: translated to Rust, with bounds checks on hostile input, wrapping integer arithmetic, the unrolled predictor and per-width matrix routines folded into one, and the average bit rate filled in. Those files are Apache-2.0 only. + +JPEG encoding dependency: jpeg-encoder 0.6.1 + +Source: https://crates.io/crates/jpeg-encoder/0.6.1 +Declared license: (MIT OR Apache-2.0) AND IJG. +This software is based in part on the work of the Independent JPEG Group. + +The MIT license and unaltered upstream IJG and SIMD notices follow. The Apache-2.0 +alternative is also retained in licenses/jpeg-encoder-0.6.1 at the repository root. +The dependency is used unmodified; no encoder implementation is vendored here. + +LICENSE-MIT + +Copyright (c) 2021 Volker Ströbel + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. +Original src/fdct.rs opening notice + +/* + * Ported from mozjpeg to rust + * + * This file was part of the Independent JPEG Group's software: + * Copyright (C) 1991-1996, Thomas G. Lane. + * libjpeg-turbo Modifications: + * Copyright (C) 2015, 2020, D. R. Commander. + * + * Conditions of distribution and use: + * In plain English: + * + * 1. We don't promise that this software works. (But if you find any bugs, + * please let us know!) + * 2. You can use this software for whatever you want. You don't have to pay us. + * 3. You may not pretend that you wrote this software. If you use it in a + * program, you must acknowledge somewhere in your documentation that + * you've used the IJG code. + * + * In legalese: + * + * The authors make NO WARRANTY or representation, either express or implied, + * with respect to this software, its quality, accuracy, merchantability, or + * fitness for a particular purpose. This software is provided "AS IS", and you, + * its user, assume the entire risk as to its quality and accuracy. + * + * This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding. + * All Rights Reserved except as specified below. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * software (or portions thereof) for any purpose, without fee, subject to these + * conditions: + * (1) If any part of the source code for this software is distributed, then this + * README file must be included, with this copyright and no-warranty notice + * unaltered; and any additions, deletions, or changes to the original files + * must be clearly indicated in accompanying documentation. + * (2) If only executable code is distributed, then the accompanying + * documentation must state that "this software is based in part on the work of + * the Independent JPEG Group". + * (3) Permission for use of this software is granted only if the user accepts + * full responsibility for any undesirable consequences; the authors accept + * NO LIABILITY for damages of any kind. + * + * These conditions apply to any software derived from or based on the IJG code, + * not just to the unmodified library. If you use our work, you ought to + * acknowledge us. + * + * Permission is NOT granted for the use of any IJG author's name or company name + * in advertising or publicity relating to this software or products derived from + * it. This software may be referred to only as "the Independent JPEG Group's + * software". + * + * We specifically permit and encourage the use of this software as the basis of + * commercial products, provided that all warranty or liability claims are + * assumed by the product vendor. + * + * This file contains a slower but more accurate integer implementation of the + * forward DCT (Discrete Cosine Transform). + * + * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT + * on each column. Direct algorithms are also available, but they are + * much more complex and seem not to be any faster when reduced to code. + * + * This implementation is based on an algorithm described in + * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT + * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics, + * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991. + * The primary algorithm described there uses 11 multiplies and 29 adds. + * We use their alternate method with 12 multiplies and 32 adds. + * The advantage of this method is that no data path contains more than one + * multiplication; this allows a very simple and accurate implementation in + * scaled fixed-point arithmetic, with a minimal number of shifts. + */ + +Original src/avx2/fdct.rs opening notice + +/* + * Ported from mozjpeg / jfdctint-avx2.asm to rust + * Copyright 2009 Pierre Ossman for Cendio AB + * Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander. + * + * Based on the x86 SIMD extension for IJG JPEG library + * Copyright (C) 1999-2006, MIYASAKA Masaru. + */ diff --git a/crates/image-codecs/NOTICE b/crates/image-codecs/NOTICE new file mode 100644 index 000000000..83fde3dba --- /dev/null +++ b/crates/image-codecs/NOTICE @@ -0,0 +1,122 @@ +JPEG encoding dependency: jpeg-encoder 0.6.1 + +Source: https://crates.io/crates/jpeg-encoder/0.6.1 +Declared license: (MIT OR Apache-2.0) AND IJG. +This software is based in part on the work of the Independent JPEG Group. + +The MIT license and unaltered upstream IJG and SIMD notices follow. The Apache-2.0 +alternative is also retained in licenses/jpeg-encoder-0.6.1 at the repository root. +The dependency is used unmodified; no encoder implementation is vendored here. + +LICENSE-MIT + +Copyright (c) 2021 Volker Ströbel + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. +Original src/fdct.rs opening notice + +/* + * Ported from mozjpeg to rust + * + * This file was part of the Independent JPEG Group's software: + * Copyright (C) 1991-1996, Thomas G. Lane. + * libjpeg-turbo Modifications: + * Copyright (C) 2015, 2020, D. R. Commander. + * + * Conditions of distribution and use: + * In plain English: + * + * 1. We don't promise that this software works. (But if you find any bugs, + * please let us know!) + * 2. You can use this software for whatever you want. You don't have to pay us. + * 3. You may not pretend that you wrote this software. If you use it in a + * program, you must acknowledge somewhere in your documentation that + * you've used the IJG code. + * + * In legalese: + * + * The authors make NO WARRANTY or representation, either express or implied, + * with respect to this software, its quality, accuracy, merchantability, or + * fitness for a particular purpose. This software is provided "AS IS", and you, + * its user, assume the entire risk as to its quality and accuracy. + * + * This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding. + * All Rights Reserved except as specified below. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * software (or portions thereof) for any purpose, without fee, subject to these + * conditions: + * (1) If any part of the source code for this software is distributed, then this + * README file must be included, with this copyright and no-warranty notice + * unaltered; and any additions, deletions, or changes to the original files + * must be clearly indicated in accompanying documentation. + * (2) If only executable code is distributed, then the accompanying + * documentation must state that "this software is based in part on the work of + * the Independent JPEG Group". + * (3) Permission for use of this software is granted only if the user accepts + * full responsibility for any undesirable consequences; the authors accept + * NO LIABILITY for damages of any kind. + * + * These conditions apply to any software derived from or based on the IJG code, + * not just to the unmodified library. If you use our work, you ought to + * acknowledge us. + * + * Permission is NOT granted for the use of any IJG author's name or company name + * in advertising or publicity relating to this software or products derived from + * it. This software may be referred to only as "the Independent JPEG Group's + * software". + * + * We specifically permit and encourage the use of this software as the basis of + * commercial products, provided that all warranty or liability claims are + * assumed by the product vendor. + * + * This file contains a slower but more accurate integer implementation of the + * forward DCT (Discrete Cosine Transform). + * + * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT + * on each column. Direct algorithms are also available, but they are + * much more complex and seem not to be any faster when reduced to code. + * + * This implementation is based on an algorithm described in + * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT + * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics, + * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991. + * The primary algorithm described there uses 11 multiplies and 29 adds. + * We use their alternate method with 12 multiplies and 32 adds. + * The advantage of this method is that no data path contains more than one + * multiplication; this allows a very simple and accurate implementation in + * scaled fixed-point arithmetic, with a minimal number of shifts. + */ + +Original src/avx2/fdct.rs opening notice + +/* + * Ported from mozjpeg / jfdctint-avx2.asm to rust + * Copyright 2009 Pierre Ossman for Cendio AB + * Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander. + * + * Based on the x86 SIMD extension for IJG JPEG library + * Copyright (C) 1999-2006, MIYASAKA Masaru. + */ diff --git a/crates/image-codecs/README.md b/crates/image-codecs/README.md index 6e9e11617..27bb3c6ba 100644 --- a/crates/image-codecs/README.md +++ b/crates/image-codecs/README.md @@ -339,3 +339,11 @@ folder, copy the five files from that commit into `corpus/exr/`, or run at commit `74330157cb601573ae4523a95bb9132822fc3918` and copy its `corpus/exr/` here, as CI does. The images are not committed here; OpenEXR distributes them under its [license](https://github.com/AcademySoftwareFoundation/openexr/blob/69b2604fc76e370615438bdc8d2cd95b9349c12e/LICENSE.md). + +## Redistribution notices + +JPEG encoding uses `jpeg-encoder` 0.6.1, including work from the Independent JPEG Group. +Retain this crate's [NOTICE](NOTICE) with binary distributions using that encoder. It includes +its MIT license, the IJG acknowledgement and original IJG/SIMD notices. Both upstream license +alternatives and source checksums are retained in +[`licenses/jpeg-encoder-0.6.1`](../../licenses/jpeg-encoder-0.6.1) at the repository root. diff --git a/licenses/jpeg-encoder-0.6.1/IJG-NOTICE.txt b/licenses/jpeg-encoder-0.6.1/IJG-NOTICE.txt new file mode 100644 index 000000000..4fcb9b583 --- /dev/null +++ b/licenses/jpeg-encoder-0.6.1/IJG-NOTICE.txt @@ -0,0 +1,72 @@ +/* + * Ported from mozjpeg to rust + * + * This file was part of the Independent JPEG Group's software: + * Copyright (C) 1991-1996, Thomas G. Lane. + * libjpeg-turbo Modifications: + * Copyright (C) 2015, 2020, D. R. Commander. + * + * Conditions of distribution and use: + * In plain English: + * + * 1. We don't promise that this software works. (But if you find any bugs, + * please let us know!) + * 2. You can use this software for whatever you want. You don't have to pay us. + * 3. You may not pretend that you wrote this software. If you use it in a + * program, you must acknowledge somewhere in your documentation that + * you've used the IJG code. + * + * In legalese: + * + * The authors make NO WARRANTY or representation, either express or implied, + * with respect to this software, its quality, accuracy, merchantability, or + * fitness for a particular purpose. This software is provided "AS IS", and you, + * its user, assume the entire risk as to its quality and accuracy. + * + * This software is copyright (C) 1991-2020, Thomas G. Lane, Guido Vollbeding. + * All Rights Reserved except as specified below. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * software (or portions thereof) for any purpose, without fee, subject to these + * conditions: + * (1) If any part of the source code for this software is distributed, then this + * README file must be included, with this copyright and no-warranty notice + * unaltered; and any additions, deletions, or changes to the original files + * must be clearly indicated in accompanying documentation. + * (2) If only executable code is distributed, then the accompanying + * documentation must state that "this software is based in part on the work of + * the Independent JPEG Group". + * (3) Permission for use of this software is granted only if the user accepts + * full responsibility for any undesirable consequences; the authors accept + * NO LIABILITY for damages of any kind. + * + * These conditions apply to any software derived from or based on the IJG code, + * not just to the unmodified library. If you use our work, you ought to + * acknowledge us. + * + * Permission is NOT granted for the use of any IJG author's name or company name + * in advertising or publicity relating to this software or products derived from + * it. This software may be referred to only as "the Independent JPEG Group's + * software". + * + * We specifically permit and encourage the use of this software as the basis of + * commercial products, provided that all warranty or liability claims are + * assumed by the product vendor. + * + * This file contains a slower but more accurate integer implementation of the + * forward DCT (Discrete Cosine Transform). + * + * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT + * on each column. Direct algorithms are also available, but they are + * much more complex and seem not to be any faster when reduced to code. + * + * This implementation is based on an algorithm described in + * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT + * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics, + * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991. + * The primary algorithm described there uses 11 multiplies and 29 adds. + * We use their alternate method with 12 multiplies and 32 adds. + * The advantage of this method is that no data path contains more than one + * multiplication; this allows a very simple and accurate implementation in + * scaled fixed-point arithmetic, with a minimal number of shifts. + */ diff --git a/licenses/jpeg-encoder-0.6.1/LICENSE-APACHE b/licenses/jpeg-encoder-0.6.1/LICENSE-APACHE new file mode 100644 index 000000000..dae696981 --- /dev/null +++ b/licenses/jpeg-encoder-0.6.1/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. \ No newline at end of file diff --git a/licenses/jpeg-encoder-0.6.1/LICENSE-MIT b/licenses/jpeg-encoder-0.6.1/LICENSE-MIT new file mode 100644 index 000000000..6a4eb8746 --- /dev/null +++ b/licenses/jpeg-encoder-0.6.1/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright (c) 2021 Volker Ströbel + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/licenses/jpeg-encoder-0.6.1/SIMD-NOTICE.txt b/licenses/jpeg-encoder-0.6.1/SIMD-NOTICE.txt new file mode 100644 index 000000000..58e09bf43 --- /dev/null +++ b/licenses/jpeg-encoder-0.6.1/SIMD-NOTICE.txt @@ -0,0 +1,8 @@ +/* + * Ported from mozjpeg / jfdctint-avx2.asm to rust + * Copyright 2009 Pierre Ossman for Cendio AB + * Copyright (C) 2009, 2016, 2018, 2020, D. R. Commander. + * + * Based on the x86 SIMD extension for IJG JPEG library + * Copyright (C) 1999-2006, MIYASAKA Masaru. + */ diff --git a/licenses/jpeg-encoder-0.6.1/SOURCE.json b/licenses/jpeg-encoder-0.6.1/SOURCE.json new file mode 100644 index 000000000..8a7fb7ab2 --- /dev/null +++ b/licenses/jpeg-encoder-0.6.1/SOURCE.json @@ -0,0 +1,29 @@ +{ + "package": "jpeg-encoder", + "version": "0.6.1", + "source": "https://crates.io/crates/jpeg-encoder/0.6.1", + "registry_checksum": "b454d911ac55068f53495488d8ccd0646eaa540c033a28ee15b07838afafb01f", + "license": "(MIT OR Apache-2.0) AND IJG", + "files": { + "LICENSE-MIT": { + "source": "LICENSE-MIT", + "source_sha256": "4d022727ea392ebba2fe5e9a5f78c610a0eae506b491f3db29c78b6d430d6503", + "sha256": "4d022727ea392ebba2fe5e9a5f78c610a0eae506b491f3db29c78b6d430d6503" + }, + "LICENSE-APACHE": { + "source": "LICENSE-APACHE", + "source_sha256": "85a884980abd6032fc6b5439ba918ab16db9ac9051b5cf18db9c27c587df07c0", + "sha256": "85a884980abd6032fc6b5439ba918ab16db9ac9051b5cf18db9c27c587df07c0" + }, + "IJG-NOTICE.txt": { + "source": "src/fdct.rs", + "source_sha256": "0b59244bbd05b2593ded252ecf0d010a8a4c6ec1d4713b3caeb6fb724586e4d6", + "sha256": "432424ca69caaa82565c0491c11cdab311a2e7d39180970b8ba22017996bf678" + }, + "SIMD-NOTICE.txt": { + "source": "src/avx2/fdct.rs", + "source_sha256": "bc362322f568f92c3699f4ca2922b261c12b7dd997120b01fd3cab58d9d2f9ab", + "sha256": "ee36eeaa9df1f7f09c7046f428ce4a848fcf518394e63d3e2125ec261949e8ba" + } + } +} From b85e4b150b7e427b1fd3c88b4ed9e6aba055053c Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 12:34:47 +0000 Subject: [PATCH 066/382] Add neutral project document schema --- Cargo.lock | 2 ++ crates/tcraft/Cargo.toml | 2 ++ crates/tcraft/src/lib.rs | 50 +++++++++++++++++++++++++++++++++++++++- 3 files changed, 53 insertions(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index b0f05a3b0..761575903 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2691,6 +2691,8 @@ name = "craft-tcraft" version = "0.1.0" dependencies = [ "craft-zip", + "serde", + "serde_json", "thiserror 2.0.21", ] diff --git a/crates/tcraft/Cargo.toml b/crates/tcraft/Cargo.toml index 76eeeafb0..3ce35abfb 100644 --- a/crates/tcraft/Cargo.toml +++ b/crates/tcraft/Cargo.toml @@ -12,4 +12,6 @@ workspace = true [dependencies] craft-zip = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } thiserror = { workspace = true } diff --git a/crates/tcraft/src/lib.rs b/crates/tcraft/src/lib.rs index 4646d8717..730ef3b0c 100644 --- a/crates/tcraft/src/lib.rs +++ b/crates/tcraft/src/lib.rs @@ -6,10 +6,12 @@ //! envelope. Reads use a caller-owned budget shared with other archive entries. No reader opens //! a file or reserves memory based on a claimed payload before checking it. -use std::collections::HashSet; +use std::collections::{BTreeMap, HashSet}; use std::io::{self, Read, Write}; use craft_zip::Budget; +use serde::{Deserialize, Serialize}; +use serde_json::Value; pub const TILE_SIDE: u32 = 64; pub const TILE_AREA: usize = 64 * 64; @@ -32,6 +34,34 @@ pub enum Error { Io(#[from] io::Error), } +/// Neutral top-level project schema. Nested app-domain values and unknown fields remain JSON +/// so they round-trip without requiring TextureCraft's in-memory model. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProjectDocument { + pub format_version: u32, + pub name: String, + pub mesh: String, + pub normal_format: Value, + pub texture_sets: Vec, + pub layers: BTreeMap, + pub next_id: u64, + pub display: Value, + #[serde(default)] + pub cameras: Vec, + #[serde(flatten)] + pub extra: BTreeMap, +} + +/// Read only the version before an application applies its own recovery policy. Serde's +/// structured parse rejects a duplicate or invalid version field, like the project reader. +pub fn project_version(bytes: &[u8]) -> Result { + #[derive(Deserialize)] + struct Version { + format_version: u32, + } + Ok(serde_json::from_slice::(bytes)?.format_version) +} + /// Width, height and number of components expected by the enclosing project schema. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Layout { @@ -243,6 +273,24 @@ mod tests { bytes } + #[test] + fn project_schema_keeps_nested_and_future_fields() { + let json = serde_json::json!({ + "format_version": 2, "name": "Stone", "mesh": "mesh.obj", "normal_format": "openGl", + "texture_sets": [{"name": "main", "futureSet": {"keep": true}}], + "layers": {"1": {"kind": "paint", "futureLayer": [1, 2]}}, "next_id": 2, + "display": {"futureDisplay": 4}, "mesh_file": "source.obj", "futureProject": [3] + }); + let bytes = serde_json::to_vec(&json).unwrap(); + assert_eq!(project_version(&bytes).unwrap(), 2); + let document: ProjectDocument = serde_json::from_slice(&bytes).unwrap(); + let mut expected = json; + expected["cameras"] = serde_json::json!([]); + assert_eq!(serde_json::to_value(document).unwrap(), expected); + assert!(project_version(br#"{"format_version":1,"format_version":2}"#).is_err()); + assert!(project_version(br#"{"format_version":-1}"#).is_err()); + } + #[test] fn baked_map_matches_the_native_little_endian_wire_layout() { let layout = Layout { width: 2, height: 1, components: 1 }; From a26ee0616b24fcf7e6d009f1921dc0113694f8e8 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 07:43:18 -0500 Subject: [PATCH 067/382] mime: offer explicit optional Base64 terminal padding --- crates/mime/src/base64.rs | 25 +++++++++++++++----- crates/mime/src/base64_tests.rs | 42 +++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 6 deletions(-) diff --git a/crates/mime/src/base64.rs b/crates/mime/src/base64.rs index a93a6fdfb..ebe077372 100644 --- a/crates/mime/src/base64.rs +++ b/crates/mime/src/base64.rs @@ -8,8 +8,9 @@ //! counts it; an unpadded one refuses `=`), a length that can be, and the unused bits of the last //! symbol zero (so every value has one spelling). A caller that reads mail, where line breaks and //! missing padding are everyday, cleans its input first, as it always has; the strictness is what -//! the signature, key and credential checks want. No input panics, and the output is never longer -//! than three quarters of the input. +//! the signature, key and credential checks want. [`Config::decode_optional_padding`] explicitly +//! permits missing terminal padding without relaxing alphabet, padding placement or unused bits. +//! No input panics, and the output is never longer than three quarters of the input. use std::fmt; @@ -108,9 +109,20 @@ impl Config { /// The bytes of `text`, which must be exactly base64 of this config's kind (see the module). pub fn decode(self, text: impl AsRef<[u8]>) -> Result, DecodeError> { - let text = text.as_ref(); - let (symbols, pad) = if self.padded { - if text.len() % 4 != 0 { + self.decode_inner(text.as_ref(), false) + } + + /// Decode this alphabet with zero, partial or complete terminal padding, regardless of the + /// config's encoding padding. Whitespace, junk, internal/excess padding and nonzero unused + /// bits still fail. Use this only when the calling format permits missing padding; [`Self::decode`] + /// remains strict for signatures and credentials that require one spelling. + pub fn decode_optional_padding(self, text: impl AsRef<[u8]>) -> Result, DecodeError> { + self.decode_inner(text.as_ref(), true) + } + + fn decode_inner(self, text: &[u8], optional_padding: bool) -> Result, DecodeError> { + let (symbols, pad) = if self.padded || optional_padding { + if !optional_padding && text.len() % 4 != 0 { return Err(DecodeError); } let pad = text.iter().rev().take(2).take_while(|c| **c == b'=').count(); @@ -120,7 +132,8 @@ impl Config { }; // A last group of one symbol holds under eight bits; with padding, `=` fills it to four. let rest = symbols.len() % 4; - if rest == 1 || (self.padded && pad != (4 - rest) % 4) { + let needed = (4 - rest) % 4; + if rest == 1 || (optional_padding && pad > needed) || (!optional_padding && self.padded && pad != needed) { return Err(DecodeError); } let mut out = Vec::with_capacity(symbols.len().saturating_mul(3) / 4); diff --git a/crates/mime/src/base64_tests.rs b/crates/mime/src/base64_tests.rs index e3d52794e..07fee89c7 100644 --- a/crates/mime/src/base64_tests.rs +++ b/crates/mime/src/base64_tests.rs @@ -79,3 +79,45 @@ proptest! { } } } + +/// Missing padding is opt-in; other canonical validation stays unchanged. +#[test] +fn optional_padding_keeps_alphabet_placement_and_tail_bit_checks() { + for cfg in CONFIGS { + for (input, expected) in [("", ""), ("Zg", "f"), ("Zg=", "f"), ("Zg==", "f"), ("Zm8", "fo"), ("Zm8=", "fo"), ("Zm9v", "foo")] { + assert_eq!(cfg.decode_optional_padding(input).unwrap(), expected.as_bytes()); + } + for bad in ["=", "====", "Z", "Z===", "Zg===", "Zm8==", "Zm9v=", "QQ==QUJD", "Zm=v", "Zh", "Zh=", "Zh==", "Zm9", "Zm9=", "Zg\n", " Zg", "é"] + { + assert!(cfg.decode_optional_padding(bad).is_err(), "{cfg:?}: {bad:?}"); + } + } + assert_eq!(STANDARD.decode_optional_padding("+/8").unwrap(), [251, 255]); + assert_eq!(URL_SAFE.decode_optional_padding("-_8=").unwrap(), [251, 255]); + assert!(STANDARD.decode_optional_padding("-_8=").is_err()); + assert!(URL_SAFE.decode_optional_padding("+/8=").is_err()); + assert!(STANDARD.decode("Zg=").is_err()); + assert!(STANDARD_NO_PAD.decode("Zg==").is_err()); +} + +proptest! { + #[test] + fn optional_padding_accepts_only_a_suffix_of_required_padding( + data in proptest::collection::vec(any::(), 0..400), + junk in proptest::collection::vec(any::(), 0..128), + ) { + for cfg in [STANDARD, URL_SAFE] { + let encoded = cfg.encode(&data); + let bare = encoded.trim_end_matches('='); + for length in bare.len()..=encoded.len() { + prop_assert_eq!(cfg.decode_optional_padding(&encoded[..length]).ok(), Some(data.clone())); + } + if let Ok(decoded) = cfg.decode_optional_padding(&junk) { + let canonical = cfg.encode(decoded); + let bare = canonical.trim_end_matches('='); + prop_assert!(junk.len() >= bare.len() && junk.len() <= canonical.len()); + prop_assert_eq!(canonical.as_bytes().get(..junk.len()), Some(junk.as_slice())); + } + } + } +} From d7dc95d273fca95e30395c08525da06e47fbb16b Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 07:52:56 -0500 Subject: [PATCH 068/382] fix(mime): use checked divisibility idiom for padding --- crates/mime/src/base64.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/mime/src/base64.rs b/crates/mime/src/base64.rs index ebe077372..856f33398 100644 --- a/crates/mime/src/base64.rs +++ b/crates/mime/src/base64.rs @@ -122,7 +122,7 @@ impl Config { fn decode_inner(self, text: &[u8], optional_padding: bool) -> Result, DecodeError> { let (symbols, pad) = if self.padded || optional_padding { - if !optional_padding && text.len() % 4 != 0 { + if !optional_padding && !text.len().is_multiple_of(4) { return Err(DecodeError); } let pad = text.iter().rev().take(2).take_while(|c| **c == b'=').count(); From 425bcbfaba54a72cce2adb854c758809e7f56b2f Mon Sep 17 00:00:00 2001 From: vangel76 Date: Sun, 15 Nov 2026 14:37:01 +0100 Subject: [PATCH 069/382] MXF README: craft-raw decodes the DNG pictures, it does not develop them Co-Authored-By: Claude Opus 5.5 --- crates/media/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/media/README.md b/crates/media/README.md index 7b5e47c0e..6262976bb 100644 --- a/crates/media/README.md +++ b/crates/media/README.md @@ -700,7 +700,7 @@ let pcm = mxf.read_pcm(&file, a, 48_000, 1920)?; // planar f32, sample-exact MPEG-4 visual, JPEG 2000, DV, uncompressed, CinemaDNG (the CinemaDNG container labels, the registered MXF-GC TIFF/EP container and TIFF/EP picture coding labels, a 42h picture element type, or a TIFF header with the DNGVersion tag at the start of the essence; the DNG pictures - themselves are developed by `craft-raw`). + themselves are decoded by `craft-raw`). - **Sound.** PCM chunks (frame- or clip-wrapped) with sample counts; `read_pcm` decodes little-endian 8/16/24/32-bit PCM (wave / AES3 descriptors) and ST 331 AES3 elements (D-10). - **Timecode.** The material package timecode component (start frame count, rounded base, From d2c1cac0324491bd67f6e3b583a5dffb18bf78eb Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 13:38:46 +0000 Subject: [PATCH 070/382] Reject colliding project extension fields --- crates/tcraft/src/lib.rs | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) diff --git a/crates/tcraft/src/lib.rs b/crates/tcraft/src/lib.rs index 730ef3b0c..d7af3e8a6 100644 --- a/crates/tcraft/src/lib.rs +++ b/crates/tcraft/src/lib.rs @@ -36,7 +36,7 @@ pub enum Error { /// Neutral top-level project schema. Nested app-domain values and unknown fields remain JSON /// so they round-trip without requiring TextureCraft's in-memory model. -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[derive(Clone, Debug, PartialEq, Deserialize)] pub struct ProjectDocument { pub format_version: u32, pub name: String, @@ -52,6 +52,30 @@ pub struct ProjectDocument { pub extra: BTreeMap, } +impl Serialize for ProjectDocument { + fn serialize(&self, serializer: S) -> Result { + use serde::ser::{Error as _, SerializeMap as _}; + const RESERVED: &[&str] = &["format_version", "name", "mesh", "normal_format", "texture_sets", "layers", "next_id", "display", "cameras"]; + if self.extra.keys().any(|key| RESERVED.contains(&key.as_str())) { + return Err(S::Error::custom("an extra project field duplicates a known field")); + } + let mut map = serializer.serialize_map(Some(9 + self.extra.len()))?; + map.serialize_entry("format_version", &self.format_version)?; + map.serialize_entry("name", &self.name)?; + map.serialize_entry("mesh", &self.mesh)?; + map.serialize_entry("normal_format", &self.normal_format)?; + map.serialize_entry("texture_sets", &self.texture_sets)?; + map.serialize_entry("layers", &self.layers)?; + map.serialize_entry("next_id", &self.next_id)?; + map.serialize_entry("display", &self.display)?; + map.serialize_entry("cameras", &self.cameras)?; + for (key, value) in &self.extra { + map.serialize_entry(key, value)?; + } + map.end() + } +} + /// Read only the version before an application applies its own recovery policy. Serde's /// structured parse rejects a duplicate or invalid version field, like the project reader. pub fn project_version(bytes: &[u8]) -> Result { @@ -286,7 +310,10 @@ mod tests { let document: ProjectDocument = serde_json::from_slice(&bytes).unwrap(); let mut expected = json; expected["cameras"] = serde_json::json!([]); - assert_eq!(serde_json::to_value(document).unwrap(), expected); + assert_eq!(serde_json::to_value(&document).unwrap(), expected); + let mut duplicate = document; + duplicate.extra.insert("mesh".into(), serde_json::json!("other.obj")); + assert!(serde_json::to_vec(&duplicate).is_err()); assert!(project_version(br#"{"format_version":1,"format_version":2}"#).is_err()); assert!(project_version(br#"{"format_version":-1}"#).is_err()); } From 533b37bd5627e723f249e00bfefbd0273ad12871 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 13:41:22 +0000 Subject: [PATCH 071/382] Add reusable MCP server session envelopes --- Cargo.lock | 8 ++ Cargo.toml | 1 + crates/mcp/Cargo.toml | 15 +++ crates/mcp/README.md | 17 ++++ crates/mcp/src/lib.rs | 207 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 248 insertions(+) create mode 100644 crates/mcp/Cargo.toml create mode 100644 crates/mcp/README.md create mode 100644 crates/mcp/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 8e12a6995..d140d2ed3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2075,6 +2075,14 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-mcp" +version = "0.1.0" +dependencies = [ + "craft-jsonrpc", + "serde_json", +] + [[package]] name = "craft-media" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 5d0bbbc66..a0141c2cb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -90,6 +90,7 @@ craft-jmap = { path = "crates/jmap" } craft-ical = { path = "crates/ical" } craft-jpeg = { path = "crates/jpeg" } craft-jsonrpc = { path = "crates/jsonrpc" } +craft-mcp = { path = "crates/mcp" } craft-jxl = { path = "crates/jxl" } craft-kiwi = { path = "crates/kiwi" } craft-keymap = { path = "crates/keymap" } diff --git a/crates/mcp/Cargo.toml b/crates/mcp/Cargo.toml new file mode 100644 index 000000000..9aeb746d9 --- /dev/null +++ b/crates/mcp/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "craft-mcp" +description = "Transport-independent MCP server initialization and tool envelopes" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +craft-jsonrpc = { workspace = true } +serde_json = { workspace = true } diff --git a/crates/mcp/README.md b/crates/mcp/README.md new file mode 100644 index 000000000..e84a1a40c --- /dev/null +++ b/crates/mcp/README.md @@ -0,0 +1,17 @@ +# craft-mcp + +Transport-independent MCP 2025-03-26 server initialization and tool result helpers. +Use one `Session` per client connection with `craft-jsonrpc` for message parsing and +batch dispatch. The caller owns transport, tool definitions and execution, response +size limits, and shutdown. Pass the outer envelope's batch status to `Session::request`. + +`Policy::Compatible` retains existing permissive clients: tool calls can precede +initialization, initialization can occur in a batch, and client information needs only +to be an object. `Policy::Strict` requires initialization first (except ping), +rejects batched or repeated initialization, and requires client name and version. +Both respond with the sole supported version, 2025-03-26, even if the client offered +a different version. An initialized notification moves the session to `Ready`. +This crate does not enforce every MCP lifecycle or capability rule; applications +must validate any additional requirements they depend on. + +See the [MCP lifecycle specification](https://modelcontextprotocol.io/specification/2025-03-26/basic/lifecycle). diff --git a/crates/mcp/src/lib.rs b/crates/mcp/src/lib.rs new file mode 100644 index 000000000..96cfdc7ae --- /dev/null +++ b/crates/mcp/src/lib.rs @@ -0,0 +1,207 @@ +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] + +//! MCP 2025-03-26 server initialization and tool envelopes, independent of transport and tools. +//! The caller owns routing, transport and JSON-RPC batching. Compatibility mode preserves servers +//! that accepted calls before initialization and initialize in a batch; strict mode enforces the +//! initialization ordering and batch prohibition. Create one session per connection. + +use craft_jsonrpc::{Request, RpcError}; +use serde_json::{Value, json}; + +pub const PROTOCOL_VERSION: &str = "2025-03-26"; + +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum Policy { + /// Preserve existing permissive servers, including minimal client information. + #[default] + Compatible, + /// Enforce the initialize request and client identity required by MCP. + Strict, +} + +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum State { + #[default] + New, + AwaitingInitialized, + Ready, +} + +/// State for one connection. Unknown requests are left to the caller's router. +pub struct Session { + name: String, + version: String, + policy: Policy, + state: State, + capabilities: Value, +} + +impl Session { + pub fn new(name: impl Into, version: impl Into, policy: Policy) -> Self { + Self { name: name.into(), version: version.into(), policy, state: State::New, capabilities: json!({"tools": {}}) } + } + + /// Set the server capabilities returned at initialization. The value must be an object. + pub fn with_capabilities(mut self, capabilities: Value) -> Result { + if !capabilities.is_object() { + return Err(RpcError::new(-32602, "Capabilities must be an object")); + } + self.capabilities = capabilities; + Ok(self) + } + + pub fn state(&self) -> State { + self.state + } + + /// Handles `initialize` and `ping`. Returns `None` for a request the app should route. + /// `in_batch` must describe the outer JSON-RPC envelope. + pub fn request(&mut self, request: Request<'_>, in_batch: bool) -> Option> { + if request.method == "ping" { + return Some(Ok(json!({}))); + } + if request.method == "initialize" { + if self.policy == Policy::Strict && (in_batch || self.state != State::New) { + return Some(Err(RpcError::new(-32600, "Invalid Request"))); + } + let Some(params) = request.params.and_then(Value::as_object) else { + return Some(Err(invalid_initialize())); + }; + let valid = params.get("protocolVersion").and_then(Value::as_str).is_some() + && params.get("capabilities").is_some_and(Value::is_object) + && params.get("clientInfo").is_some_and(Value::is_object); + let identity = params.get("clientInfo").and_then(Value::as_object); + let strict_identity = identity + .is_some_and(|info| info.get("name").and_then(Value::as_str).is_some() && info.get("version").and_then(Value::as_str).is_some()); + if !valid || (self.policy == Policy::Strict && !strict_identity) { + return Some(Err(invalid_initialize())); + } + self.state = State::AwaitingInitialized; + return Some(Ok( + json!({"protocolVersion": PROTOCOL_VERSION, "capabilities": self.capabilities, "serverInfo": {"name": self.name, "version": self.version}}), + )); + } + if self.policy == Policy::Strict && self.state == State::New { + return Some(Err(RpcError::new(-32600, "Server not initialized"))); + } + None + } + + /// Observe a JSON-RPC notification; notifications never receive replies. + pub fn notification(&mut self, request: Request<'_>) { + if request.method == "notifications/initialized" && self.state == State::AwaitingInitialized { + self.state = State::Ready; + } + } +} + +fn invalid_initialize() -> RpcError { + RpcError::new(-32602, "Invalid initialize parameters") +} + +/// Validate MCP tool-call parameters without owning the application's tool routing. +pub fn tool_call(params: &Value) -> Result<(&str, Value), RpcError> { + let name = params.get("name").and_then(Value::as_str).ok_or_else(|| RpcError::new(-32602, "Missing tool name"))?; + let arguments = params.get("arguments").cloned().unwrap_or_else(|| json!({})); + if !arguments.is_object() { + return Err(RpcError::new(-32602, "Tool arguments must be an object")); + } + Ok((name, arguments)) +} + +/// Wrap an application-provided tool list in the MCP result envelope. +pub fn tool_list(tools: Value) -> Value { + json!({"tools": tools}) +} + +/// Construct the text result currently used by Craft's MCP tools. +pub fn text_tool_result(text: &str, is_error: bool) -> Value { + json!({"content": [{"type": "text", "text": text}], "isError": is_error}) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn call<'a>(method: &'a str, params: Option<&'a Value>) -> Request<'a> { + Request { id: None, method, params } + } + + #[test] + fn compatible_negotiation_preserves_existing_clients() { + let mut s = Session::new("test", "1", Policy::Compatible); + assert!(s.request(call("tools/list", None), false).is_none()); + let p = json!({"protocolVersion":"old", "capabilities":{}, "clientInfo":{}}); + let r = s.request(call("initialize", Some(&p)), true).unwrap().unwrap(); + assert_eq!(r["protocolVersion"], PROTOCOL_VERSION); + assert_eq!(r["serverInfo"]["name"], "test"); + assert_eq!(s.state(), State::AwaitingInitialized); + s.notification(call("notifications/initialized", None)); + assert_eq!(s.state(), State::Ready); + } + + #[test] + fn strict_rejects_batch_and_calls_before_initialization() { + let mut s = Session::new("test", "1", Policy::Strict); + assert_eq!(s.request(call("tools/list", None), false).unwrap().unwrap_err().code, -32600); + assert!(s.request(call("ping", None), false).unwrap().is_ok()); + let p = json!({"protocolVersion":PROTOCOL_VERSION, "capabilities":{}, "clientInfo":{"name":"client", "version":"1"}}); + assert!(s.request(call("initialize", Some(&p)), true).unwrap().is_err()); + assert_eq!(s.state(), State::New); + assert!(s.request(call("initialize", Some(&p)), false).unwrap().is_ok()); + assert!(s.request(call("initialize", Some(&p)), false).unwrap().is_err()); + s.notification(call("notifications/initialized", None)); + assert_eq!(s.state(), State::Ready); + } + + #[test] + fn capabilities_are_configurable_and_must_be_an_object() { + assert!(Session::new("test", "1", Policy::Compatible).with_capabilities(json!([])).is_err()); + let mut session = Session::new("test", "1", Policy::Compatible).with_capabilities(json!({"resources": {"subscribe": true}})).unwrap(); + let params = json!({"protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {}}); + let result = session.request(call("initialize", Some(¶ms)), false).unwrap().unwrap(); + assert_eq!(result["capabilities"], json!({"resources": {"subscribe": true}})); + } + + #[test] + fn malformed_initialize_does_not_change_state() { + let mut s = Session::new("test", "1", Policy::Strict); + for p in [json!({}), json!({"protocolVersion":"x", "capabilities":{}, "clientInfo":{}})] { + assert_eq!(s.request(call("initialize", Some(&p)), false).unwrap().unwrap_err().code, -32602); + assert_eq!(s.state(), State::New); + } + } + + #[test] + fn tool_envelopes_validate_arguments_and_preserve_results() { + let p = json!({"name":"open"}); + assert_eq!(tool_call(&p).unwrap(), ("open", json!({}))); + assert_eq!(tool_call(&json!({"name":"open", "arguments":[]})).unwrap_err().code, -32602); + assert_eq!(tool_call(&json!({})).unwrap_err().code, -32602); + assert_eq!(text_tool_result("bad", true), json!({"content":[{"type":"text", "text":"bad"}], "isError":true})); + } + + #[test] + fn jsonrpc_batch_preserves_ids_and_skips_notifications() { + use std::cell::RefCell; + let session = RefCell::new(Session::new("test", "1", Policy::Compatible)); + let input = json!([ + {"jsonrpc":"2.0", "id":1, "method":"initialize", "params":{"protocolVersion":"2025-03-26", "capabilities":{}, "clientInfo":{}}}, + {"jsonrpc":"2.0", "method":"notifications/initialized"}, + {"jsonrpc":"2.0", "id":"tools", "method":"tools/list"} + ]); + let reply = craft_jsonrpc::process( + &input, + craft_jsonrpc::Limits::default(), + |r| session.borrow_mut().request(r, true).unwrap_or_else(|| Ok(tool_list(json!([])))), + |r| session.borrow_mut().notification(r), + ) + .unwrap() + .unwrap(); + assert_eq!(reply.as_array().unwrap().len(), 2); + assert_eq!(reply[0]["id"], 1); + assert_eq!(reply[1]["id"], "tools"); + assert_eq!(reply[1]["result"]["tools"], json!([])); + assert_eq!(session.borrow().state(), State::Ready); + } +} From b1ecb6776d2d6511405ef41e957c77a9e3bf6d42 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 14:04:03 +0000 Subject: [PATCH 072/382] Guard ZIP64 directory-size sentinel counts --- crates/zip/src/guard.rs | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/crates/zip/src/guard.rs b/crates/zip/src/guard.rs index dd3ebe451..553e1532f 100644 --- a/crates/zip/src/guard.rs +++ b/crates/zip/src/guard.rs @@ -46,7 +46,7 @@ pub fn check_entry_count(bytes: &[u8], max_entries: u64) -> Result<(), Error> { continue; } let (Some(on_disk), Some(total), Some(cd_offset)) = (u16_at(at + 8), u16_at(at + 10), u32_at(at + 16)) else { continue }; - let zip64 = total == u16::MAX || cd_offset == u32::MAX; + let zip64 = total == u16::MAX || u32_at(at + 12) == Some(u32::MAX) || cd_offset == u32::MAX; if zip64 && let Some(locator) = at.checked_sub(20) && bytes.get(locator..locator + 4) == Some(EOCD64_LOCATOR.as_slice()) @@ -155,6 +155,17 @@ mod tests { assert!(check(&prefixed, 20_000).is_err()); } + #[test] + fn zip64_directory_size_sentinel_alone_cannot_bypass_the_count_limit() { + let mut bytes = zip64_entry_count_sample(21); + let eocd = bytes.len() - 22; + // zip recognizes ZIP64 when only the directory size is a sentinel. + bytes[eocd + 8..eocd + 12].copy_from_slice(&[1, 0, 1, 0]); + bytes[eocd + 16..eocd + 20].copy_from_slice(&0u32.to_le_bytes()); + assert!(zip::ZipArchive::new(std::io::Cursor::new(&bytes)).is_ok()); + assert_eq!(check(&bytes, 20), Err(Error::TooManyEntries { declared: 21, limit: 20 })); + } + #[test] fn a_plain_end_record_is_checked_as_zip_reads_it() { assert!(check(&plain(3, b""), 20_000).is_ok()); From 2b724bb168a15a29748672522c61a45d2f28ef43 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Sun, 15 Nov 2026 15:06:50 +0100 Subject: [PATCH 073/382] Link jpeg-encoder licence records by repository URL The relative link and root path do not resolve from a packaged craft-image-codecs. --- crates/image-codecs/NOTICE | 3 ++- crates/image-codecs/README.md | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/crates/image-codecs/NOTICE b/crates/image-codecs/NOTICE index 83fde3dba..b3424a8b7 100644 --- a/crates/image-codecs/NOTICE +++ b/crates/image-codecs/NOTICE @@ -5,7 +5,8 @@ Declared license: (MIT OR Apache-2.0) AND IJG. This software is based in part on the work of the Independent JPEG Group. The MIT license and unaltered upstream IJG and SIMD notices follow. The Apache-2.0 -alternative is also retained in licenses/jpeg-encoder-0.6.1 at the repository root. +alternative is also retained in licenses/jpeg-encoder-0.6.1 at the repository root +(https://github.com/storytold/craft-libs/tree/main/licenses/jpeg-encoder-0.6.1). The dependency is used unmodified; no encoder implementation is vendored here. LICENSE-MIT diff --git a/crates/image-codecs/README.md b/crates/image-codecs/README.md index 27bb3c6ba..aaf7f54b4 100644 --- a/crates/image-codecs/README.md +++ b/crates/image-codecs/README.md @@ -346,4 +346,5 @@ JPEG encoding uses `jpeg-encoder` 0.6.1, including work from the Independent JPE Retain this crate's [NOTICE](NOTICE) with binary distributions using that encoder. It includes its MIT license, the IJG acknowledgement and original IJG/SIMD notices. Both upstream license alternatives and source checksums are retained in -[`licenses/jpeg-encoder-0.6.1`](../../licenses/jpeg-encoder-0.6.1) at the repository root. +[`licenses/jpeg-encoder-0.6.1`](https://github.com/storytold/craft-libs/tree/main/licenses/jpeg-encoder-0.6.1) +at the repository root. From cdf4a2fa6e23f80e6a8210361a79f6e9600a4056 Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 15:11:43 +0100 Subject: [PATCH 074/382] craft-audio: native FLAC decoder (flac-decode) Adds flac::decode for whole files and flac::Decoder for single frames: RFC 9639 subframes (constant, verbatim, fixed, LPC), Rice and escaped partitions, wasted bits, all stereo modes, fixed and variable block sizes, 4 to 32 bits, CRC-8 and CRC-16 checked. Not yet wired into craft_audio::decode, which still uses symphonia for FLAC. Part of #1546 --- crates/audio/Cargo.toml | 6 + crates/audio/README.md | 1 + crates/audio/src/flac_decode.rs | 558 ++++++++++++++++++++++++++++++ crates/audio/src/lib.rs | 9 +- crates/audio/tests/flac_decode.rs | 179 ++++++++++ 5 files changed, 751 insertions(+), 2 deletions(-) create mode 100644 crates/audio/src/flac_decode.rs create mode 100644 crates/audio/tests/flac_decode.rs diff --git a/crates/audio/Cargo.toml b/crates/audio/Cargo.toml index c411a0357..a0d1070bd 100644 --- a/crates/audio/Cargo.toml +++ b/crates/audio/Cargo.toml @@ -29,6 +29,8 @@ encode = ["lossless-encode", "aac-encode", "alac-encode", "ac3-encode", "eac3-en lossless-encode = ["pcm-encode", "flac-encode"] # Encode WAV/BWF/RF64 and AIFF/AIFF-C files. pcm-encode = [] +# Decode FLAC files and frames natively (`flac::decode`, `flac::Decoder`). +flac-decode = [] # Encode FLAC files. flac-encode = ["craft-media/bitstream"] # Encode Ogg Vorbis files (desktop only: builds the reference libvorbis from its C sources). @@ -84,6 +86,10 @@ required-features = ["decode", "lossless-encode", "peaks"] name = "codecs" required-features = ["decode", "encode"] +[[test]] +name = "flac_decode" +required-features = ["flac-decode", "flac-encode"] + [[example]] name = "info" required-features = ["decode"] diff --git a/crates/audio/README.md b/crates/audio/README.md index 63251db8d..c336b4b8e 100644 --- a/crates/audio/README.md +++ b/crates/audio/README.md @@ -32,6 +32,7 @@ No default features. The shared types (`AudioBuffer`, `AudioInfo`, `ChannelLayou | `encode` | every encoder, and every format of `encode` and `FileEncoder` | `lossless-encode`, `aac-encode`, `alac-encode`, `ac3-encode`, `eac3-encode`, `mp3-encode`, `opus-encode` | | `lossless-encode` | WAV, AIFF and FLAC writing | `pcm-encode`, `flac-encode` | | `pcm-encode` | `encode`, `FileEncoder` for WAV and AIFF; `wav_float_header`; `pcm_wav_file`, `pcm_wav_header`, `pcm_aiff_file`, `pcm_aiff_header` (minimal files around integer PCM bytes, for essence embedded in AAF / OMF) | none | +| `flac-decode` | `flac::decode` (whole `.flac` files) and `flac::Decoder` (single frames, for callers that demux FLAC themselves); native, CRC-checked, 4 to 32 bits. `decode` still uses symphonia for FLAC files | none | | `flac-encode` | `encode`, `FileEncoder` for FLAC; `flac::Encoder`, the packet encoder for callers that mux FLAC themselves | craft-media `bitstream` | | `aac-decode`, `aac-encode` | `aac::Decoder`, `aac::Encoder`; with `aac-decode`, `aac::latm_config` / `latm_split` for LOAS / LATM frames (AAC in MPEG transport streams); with `aac-encode`, `encode`, `FileEncoder` for AAC in M4A | craft-media `bitstream`; `aac-encode` also `isobmff` | | `alac-decode` | `alac::Decoder` | none | diff --git a/crates/audio/src/flac_decode.rs b/crates/audio/src/flac_decode.rs new file mode 100644 index 000000000..dfb6f5fc1 --- /dev/null +++ b/crates/audio/src/flac_decode.rs @@ -0,0 +1,558 @@ +//! A native FLAC decoder (RFC 9639): [`decode`] for whole `.flac` files and [`Decoder`] for single +//! frames (the packets of FLAC in MP4, Matroska or Ogg). +//! +//! Every frame is checked against its CRC-8 and CRC-16. Subframe types constant, verbatim, fixed +//! and LPC; Rice partitions with 4- and 5-bit parameters and escaped partitions; wasted bits; +//! left/side, side/right and mid/side stereo; fixed and variable block sizes; 4 to 32 bits per +//! sample. The STREAMINFO MD5 is not verified. +//! +//! Samples come back as `i32`, one `Vec` per channel, in the FLAC channel order. + +/// What went wrong decoding FLAC. +#[non_exhaustive] +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum DecodeError { + /// The data ends early. + #[error("truncated FLAC data")] + Truncated, + /// The data is not valid FLAC. + #[error("invalid FLAC data: {0}")] + Invalid(&'static str), + /// A frame or header failed its CRC. + #[error("FLAC CRC mismatch in {0}")] + Crc(&'static str), + /// Valid FLAC that is not decoded. + #[error("unsupported FLAC feature: {0}")] + Unsupported(&'static str), + /// The stream is longer than the sample limit. + #[error("FLAC stream exceeds the sample limit")] + TooLarge, +} + +/// `Result` of this module. +pub type Result = std::result::Result; + +/// The STREAMINFO metadata block (RFC 9639 section 8.2). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct StreamInfo { + /// Smallest block size in samples. + pub min_block_size: u16, + /// Largest block size in samples. + pub max_block_size: u16, + /// Smallest frame in bytes, 0 if unknown. + pub min_frame_size: u32, + /// Largest frame in bytes, 0 if unknown. + pub max_frame_size: u32, + /// Sample rate in Hz. + pub sample_rate: u32, + /// Channel count, 1 to 8. + pub channels: u8, + /// Bits per sample, 4 to 32. + pub bits_per_sample: u8, + /// Samples per channel in the stream, 0 if unknown. + pub total_samples: u64, + /// MD5 of the unencoded audio, all zero if not set. + pub md5: [u8; 16], +} + +impl StreamInfo { + /// Parse the 34 bytes of a STREAMINFO block body. + pub fn parse(b: &[u8]) -> Result { + let b = b.get(..34).ok_or(DecodeError::Truncated)?; + let packed = u64::from_be_bytes([b[10], b[11], b[12], b[13], b[14], b[15], b[16], b[17]]); + let info = StreamInfo { + min_block_size: u16::from_be_bytes([b[0], b[1]]), + max_block_size: u16::from_be_bytes([b[2], b[3]]), + min_frame_size: u32::from_be_bytes([0, b[4], b[5], b[6]]), + max_frame_size: u32::from_be_bytes([0, b[7], b[8], b[9]]), + sample_rate: (packed >> 44) as u32, + channels: ((packed >> 41) & 7) as u8 + 1, + bits_per_sample: ((packed >> 36) & 31) as u8 + 1, + total_samples: packed & 0xF_FFFF_FFFF, + md5: b[18..34].try_into().map_err(|_| DecodeError::Truncated)?, + }; + if info.bits_per_sample < 4 { + return Err(DecodeError::Invalid("bits per sample below 4")); + } + if info.min_block_size != 0 + && (info.min_block_size < 16 && info.min_block_size != info.max_block_size || info.max_block_size < info.min_block_size) + { + return Err(DecodeError::Invalid("inconsistent block sizes")); + } + Ok(info) + } +} + +/// One decoded frame. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Frame { + /// Sample rate in Hz. + pub sample_rate: u32, + /// Bits per sample. + pub bits_per_sample: u8, + /// `true` when `number` is the first sample's index (variable block size), `false` when it is + /// the frame's index (fixed block size). + pub variable_block_size: bool, + /// The coded number of the frame header. + pub number: u64, + /// Samples per channel in the frame. + pub block_size: usize, + /// One `Vec` per channel, after undoing any stereo decorrelation. + pub channels: Vec>, + /// Bytes the frame took, including the header and CRC footer. + pub size: usize, +} + +// ---- checksums ---- + +fn crc8(data: &[u8]) -> u8 { + let mut crc = 0u8; + for &b in data { + crc ^= b; + for _ in 0..8 { + crc = if crc & 0x80 != 0 { crc << 1 ^ 0x07 } else { crc << 1 }; + } + } + crc +} + +fn crc16(data: &[u8]) -> u16 { + let mut crc = 0u16; + for &b in data { + crc ^= u16::from(b) << 8; + for _ in 0..8 { + crc = if crc & 0x8000 != 0 { crc << 1 ^ 0x8005 } else { crc << 1 }; + } + } + crc +} + +// ---- bits ---- + +struct Bits<'a> { + data: &'a [u8], + /// Position in bits. + pos: usize, +} + +impl<'a> Bits<'a> { + fn new(data: &'a [u8]) -> Self { + Bits { data, pos: 0 } + } + + fn left(&self) -> usize { + self.data.len() * 8 - self.pos + } + + fn bit(&mut self) -> Result { + let byte = *self.data.get(self.pos / 8).ok_or(DecodeError::Truncated)?; + let v = (byte >> (7 - self.pos % 8)) & 1; + self.pos += 1; + Ok(u32::from(v)) + } + + /// `n` bits (0 to 32) as an unsigned number. + fn bits(&mut self, n: u32) -> Result { + if n as usize > self.left() { + return Err(DecodeError::Truncated); + } + let mut v = 0u64; + let mut n = n as usize; + while n > 0 { + let byte = u64::from(self.data[self.pos / 8]); + let avail = 8 - self.pos % 8; + let take = avail.min(n); + v = v << take | (byte >> (avail - take)) & ((1 << take) - 1); + self.pos += take; + n -= take; + } + Ok(v) + } + + /// `n` bits (0 to 33) as a two's complement number. + fn signed(&mut self, n: u32) -> Result { + if n == 0 { + return Ok(0); + } + let v = self.bits(n)? as i64; + Ok(if v >> (n - 1) & 1 == 1 { v - (1 << n) } else { v }) + } + + /// Zero bits up to the next one bit (which is consumed). + fn unary(&mut self) -> Result { + let mut n = 0u64; + loop { + // Skip whole zero bytes when aligned. + if self.pos.is_multiple_of(8) { + while self.data.get(self.pos / 8) == Some(&0) { + self.pos += 8; + n += 8; + } + } + if self.bit()? == 1 { + return Ok(n); + } + n += 1; + } + } + + fn align(&mut self) { + self.pos = self.pos.div_ceil(8) * 8; + } +} + +// ---- frame ---- + +const BLOCK_SIZES: [usize; 16] = [0, 192, 576, 1152, 2304, 4608, 0, 0, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768]; + +/// A frame decoder. `info` supplies what a frame header leaves to the STREAMINFO. +#[derive(Debug, Clone, Copy, Default)] +pub struct Decoder { + info: Option, +} + +impl Decoder { + /// A decoder with the stream's STREAMINFO (needed for frames whose header defers the sample + /// rate or bit depth to it). + pub fn new(info: StreamInfo) -> Decoder { + Decoder { info: Some(info) } + } + + /// A decoder without STREAMINFO: frames that defer to it are an error. + pub fn without_streaminfo() -> Decoder { + Decoder { info: None } + } + + /// Decode the frame at the start of `data`. + pub fn decode_frame(&self, data: &[u8]) -> Result { + let mut r = Bits::new(data); + if r.bits(15)? != 0x7FFC { + return Err(DecodeError::Invalid("missing frame sync code")); + } + let variable = r.bit()? == 1; + let (bs_code, sr_code) = (r.bits(4)? as usize, r.bits(4)? as usize); + let (ch_code, bps_code) = (r.bits(4)? as usize, r.bits(3)? as usize); + if r.bit()? != 0 { + return Err(DecodeError::Invalid("reserved bit set")); + } + let number = coded_number(&mut r)?; + let block_size = match bs_code { + 0 => return Err(DecodeError::Invalid("reserved block size")), + 6 => r.bits(8)? as usize + 1, + 7 => r.bits(16)? as usize + 1, + c => BLOCK_SIZES[c], + }; + let sample_rate = match sr_code { + 0 => self.info.map(|i| i.sample_rate).ok_or(DecodeError::Invalid("sample rate only in STREAMINFO"))?, + 1 => 88_200, + 2 => 176_400, + 3 => 192_000, + 4 => 8_000, + 5 => 16_000, + 6 => 22_050, + 7 => 24_000, + 8 => 32_000, + 9 => 44_100, + 10 => 48_000, + 11 => 96_000, + 12 => r.bits(8)? as u32 * 1000, + 13 => r.bits(16)? as u32, + 14 => r.bits(16)? as u32 * 10, + _ => return Err(DecodeError::Invalid("forbidden sample rate code")), + }; + let header_len = r.pos.div_ceil(8); + let stored_crc = r.bits(8)? as u8; + if crc8(&data[..header_len]) != stored_crc { + return Err(DecodeError::Crc("a frame header")); + } + let bits = match bps_code { + 0 => self.info.map(|i| u32::from(i.bits_per_sample)).ok_or(DecodeError::Invalid("bit depth only in STREAMINFO"))?, + 1 => 8, + 2 => 12, + 4 => 16, + 5 => 20, + 6 => 24, + 7 => 32, + _ => return Err(DecodeError::Invalid("reserved bit depth")), + }; + let (channels, mode) = match ch_code { + 0..=7 => (ch_code + 1, Stereo::Independent), + 8 => (2, Stereo::LeftSide), + 9 => (2, Stereo::SideRight), + 10 => (2, Stereo::MidSide), + _ => return Err(DecodeError::Invalid("reserved channel assignment")), + }; + let mut out: Vec> = Vec::with_capacity(channels); + for c in 0..channels { + let extra = match (mode, c) { + (Stereo::LeftSide, 1) | (Stereo::SideRight, 0) | (Stereo::MidSide, 1) => 1, + _ => 0, + }; + out.push(subframe(&mut r, block_size, bits + extra)?); + } + r.align(); + let size = r.pos / 8; + let crc = r.bits(16)? as u16; + if crc16(&data[..size]) != crc { + return Err(DecodeError::Crc("a frame")); + } + let size = size + 2; + if mode != Stereo::Independent { + let (first, rest) = out.split_at_mut(1); + let (a, b) = (&mut first[0], &mut rest[0]); + for (x, y) in a.iter_mut().zip(b.iter_mut()) { + match mode { + Stereo::LeftSide => *y = x.wrapping_sub(*y), + Stereo::SideRight => *x = x.wrapping_add(*y), + _ => { + let m = x.wrapping_shl(1) | (*y & 1); + let side = *y; + *x = m.wrapping_add(side) >> 1; + *y = m.wrapping_sub(side) >> 1; + } + } + } + } + let mut chans = Vec::with_capacity(channels); + for c in out { + let v: Result> = + c.into_iter().map(|s| i32::try_from(s).map_err(|_| DecodeError::Invalid("sample outside the bit depth"))).collect(); + chans.push(v?); + } + Ok(Frame { sample_rate, bits_per_sample: bits as u8, variable_block_size: variable, number, block_size, channels: chans, size }) + } +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Stereo { + Independent, + LeftSide, + SideRight, + MidSide, +} + +/// The UTF-8-like coded number of a frame header (up to 36 bits, 7 bytes). +fn coded_number(r: &mut Bits) -> Result { + let first = r.bits(8)? as u8; + let extra = match first { + 0x00..=0x7F => return Ok(u64::from(first)), + 0xC0..=0xDF => 1, + 0xE0..=0xEF => 2, + 0xF0..=0xF7 => 3, + 0xF8..=0xFB => 4, + 0xFC..=0xFD => 5, + 0xFE => 6, + _ => return Err(DecodeError::Invalid("bad coded number")), + }; + let mut v = if extra == 6 { 0 } else { u64::from(first & (0x3F >> extra)) }; + for _ in 0..extra { + let b = r.bits(8)?; + if b & 0xC0 != 0x80 { + return Err(DecodeError::Invalid("bad coded number")); + } + v = v << 6 | (b & 0x3F); + } + Ok(v) +} + +/// One subframe: `bits` is the frame bit depth (plus 1 for a side channel). +fn subframe(r: &mut Bits, n: usize, bits: u32) -> Result> { + if r.bit()? != 0 { + return Err(DecodeError::Invalid("subframe header padding bit set")); + } + let kind = r.bits(6)? as u32; + let wasted = if r.bit()? == 1 { r.unary()? as u32 + 1 } else { 0 }; + if wasted >= bits { + return Err(DecodeError::Invalid("wasted bits leave no sample bits")); + } + let bps = bits - wasted; + let mut s = vec![0i64; n]; + match kind { + 0 => { + let v = r.signed(bps)?; + s.fill(v); + } + 1 => { + for v in s.iter_mut() { + *v = r.signed(bps)?; + } + } + 8..=12 => { + let order = (kind - 8) as usize; + warmup(r, &mut s, order, bps)?; + residual(r, &mut s, order)?; + for i in order..n { + let at = |k: usize| s[i - k]; + // Wrapping: hostile residuals can overflow; such samples fail the range check later. + let p = match order { + 0 => 0, + 1 => at(1), + 2 => at(1).wrapping_mul(2).wrapping_sub(at(2)), + 3 => at(1).wrapping_mul(3).wrapping_sub(at(2).wrapping_mul(3)).wrapping_add(at(3)), + _ => at(1).wrapping_mul(4).wrapping_sub(at(2).wrapping_mul(6)).wrapping_add(at(3).wrapping_mul(4)).wrapping_sub(at(4)), + }; + s[i] = s[i].wrapping_add(p); + } + } + 32..=63 => { + let order = (kind - 31) as usize; + warmup(r, &mut s, order, bps)?; + let precision = r.bits(4)? as u32 + 1; + if precision == 16 { + return Err(DecodeError::Invalid("forbidden coefficient precision")); + } + let shift = r.signed(5)?; + if shift < 0 { + return Err(DecodeError::Invalid("negative prediction shift")); + } + let mut coefs = [0i64; 32]; + for c in coefs.iter_mut().take(order) { + *c = r.signed(precision)?; + } + residual(r, &mut s, order)?; + for i in order..n { + let mut sum = 0i64; + for (k, &c) in coefs.iter().take(order).enumerate() { + sum = sum.wrapping_add(c.wrapping_mul(s[i - 1 - k])); + } + s[i] = s[i].wrapping_add(sum >> shift); + } + } + _ => return Err(DecodeError::Invalid("reserved subframe type")), + } + if wasted > 0 { + for v in s.iter_mut() { + *v = v.wrapping_shl(wasted); + } + } + Ok(s) +} + +fn warmup(r: &mut Bits, s: &mut [i64], order: usize, bps: u32) -> Result<()> { + if order > s.len() { + return Err(DecodeError::Invalid("predictor order above the block size")); + } + for v in s.iter_mut().take(order) { + *v = r.signed(bps)?; + } + Ok(()) +} + +/// The coded residual (RFC 9639 section 9.2.7), into `s[order..]`. +fn residual(r: &mut Bits, s: &mut [i64], order: usize) -> Result<()> { + let method = r.bits(2)?; + let (param_bits, escape) = match method { + 0 => (4, 15), + 1 => (5, 31), + _ => return Err(DecodeError::Invalid("reserved residual coding method")), + }; + let part_order = r.bits(4)? as u32; + let n = s.len(); + let parts = 1usize << part_order; + if !n.is_multiple_of(parts) { + return Err(DecodeError::Invalid("partition order does not divide the block size")); + } + let per = n >> part_order; + if per < order { + return Err(DecodeError::Invalid("partition shorter than the predictor order")); + } + let mut i = order; + for p in 0..parts { + let count = if p == 0 { per - order } else { per }; + let k = r.bits(param_bits)? as u32; + if k == escape { + let width = r.bits(5)? as u32; + for v in s[i..i + count].iter_mut() { + *v = r.signed(width)?; + } + } else { + for v in s[i..i + count].iter_mut() { + let q = r.unary()?; + if q > (1 << 32) { + return Err(DecodeError::Invalid("Rice quotient too large")); + } + let low = r.bits(k)?; + let folded = q << k | low; + *v = if folded & 1 == 0 { (folded >> 1) as i64 } else { -((folded >> 1) as i64) - 1 }; + } + } + i += count; + } + Ok(()) +} + +// ---- files ---- + +/// A decoded file. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Decoded { + /// The STREAMINFO block. + pub info: StreamInfo, + /// One `Vec` of samples per channel. + pub channels: Vec>, +} + +/// Most sample values (samples x channels) [`decode`] will produce. +pub const DEFAULT_MAX_VALUES: u64 = 1 << 28; + +/// Decode a whole `.flac` file (an ID3v2 tag in front is skipped). +pub fn decode(bytes: &[u8]) -> Result { + decode_with_limit(bytes, DEFAULT_MAX_VALUES) +} + +/// [`decode`] with a limit on the sample values (samples x channels) produced. +pub fn decode_with_limit(bytes: &[u8], max_values: u64) -> Result { + let mut pos = 0usize; + if bytes.starts_with(b"ID3") { + let size = bytes.get(6..10).ok_or(DecodeError::Truncated)?; + if size.iter().any(|&b| b & 0x80 != 0) { + return Err(DecodeError::Invalid("bad ID3v2 size")); + } + pos = 10 + size.iter().fold(0usize, |a, &b| a << 7 | usize::from(b)); + } + if bytes.get(pos..pos + 4) != Some(b"fLaC") { + return Err(DecodeError::Invalid("missing fLaC marker")); + } + pos += 4; + let mut info: Option = None; + loop { + let head = bytes.get(pos..pos + 4).ok_or(DecodeError::Truncated)?; + let last = head[0] & 0x80 != 0; + let kind = head[0] & 0x7F; + let len = usize::from(head[1]) << 16 | usize::from(head[2]) << 8 | usize::from(head[3]); + let body = bytes.get(pos + 4..pos + 4 + len).ok_or(DecodeError::Truncated)?; + match (kind, &info) { + (0, None) => info = Some(StreamInfo::parse(body)?), + (0, Some(_)) => return Err(DecodeError::Invalid("a second STREAMINFO block")), + (_, None) => return Err(DecodeError::Invalid("STREAMINFO is not the first block")), + (127, _) => return Err(DecodeError::Invalid("forbidden metadata block type")), + _ => {} + } + pos += 4 + len; + if last { + break; + } + } + let info = info.ok_or(DecodeError::Invalid("no STREAMINFO"))?; + let dec = Decoder::new(info); + let mut channels: Vec> = vec![Vec::new(); usize::from(info.channels)]; + let mut total = 0u64; + while pos + 2 <= bytes.len() && bytes[pos] == 0xFF && bytes[pos + 1] & 0xFE == 0xF8 { + let frame = dec.decode_frame(&bytes[pos..])?; + if frame.channels.len() != channels.len() { + return Err(DecodeError::Invalid("the channel count changes inside the stream")); + } + total += frame.block_size as u64; + if total.saturating_mul(channels.len() as u64) > max_values { + return Err(DecodeError::TooLarge); + } + for (dst, src) in channels.iter_mut().zip(frame.channels) { + dst.extend_from_slice(&src); + } + pos += frame.size; + } + if info.total_samples != 0 && total != info.total_samples { + return Err(DecodeError::Truncated); + } + Ok(Decoded { info, channels }) +} diff --git a/crates/audio/src/lib.rs b/crates/audio/src/lib.rs index 33dcdee3b..f14530b26 100644 --- a/crates/audio/src/lib.rs +++ b/crates/audio/src/lib.rs @@ -27,7 +27,7 @@ //! - Codec modules for packet-level use, each with its own features: [`aac`] (`aac-decode`, //! `aac-encode`), [`alac`] (`alac-decode`, `alac-encode`), [`opus`] (`opus-decode`, and //! [`opus::encoder`] with `opus-encode`), [`ac3`] (`ac3-decode`), [`mpa`] (`mpa-decode`), [`mp3`] -//! (`mp3-decode`, `mp3-encode`), [`flac`] (`flac-encode`: the packet encoder). +//! (`mp3-decode`, `mp3-encode`), [`flac`] (`flac-decode`: the frame and file decoder; `flac-encode`: the packet encoder). //! //! The shared types below build with no features. @@ -88,10 +88,15 @@ pub use write::{OGG_BITRATES, encode_ogg}; /// assert!(file.len() < 48_000 * 2 * 2 / 2); // well under half of 16-bit PCM /// # Ok::<(), craft_audio::flac::Error>(()) /// ``` -#[cfg(feature = "flac-encode")] +#[cfg(any(feature = "flac-encode", feature = "flac-decode"))] pub mod flac { + #[cfg(feature = "flac-decode")] + pub use crate::flac_decode::{DEFAULT_MAX_VALUES, DecodeError, Decoded, Decoder, Frame, StreamInfo, decode, decode_with_limit}; + #[cfg(feature = "flac-encode")] pub use crate::write::flac::encoder::{Encoder, EncoderConfig, Error, STREAMINFO_OFFSET}; } +#[cfg(feature = "flac-decode")] +mod flac_decode; pub use buffer::AudioBuffer; /// The craft-media this crate is built with, for its containers: using it rather than a separate diff --git a/crates/audio/tests/flac_decode.rs b/crates/audio/tests/flac_decode.rs new file mode 100644 index 000000000..03d6d678e --- /dev/null +++ b/crates/audio/tests/flac_decode.rs @@ -0,0 +1,179 @@ +//! The native FLAC decoder: round trips through this crate's encoder over bit depths, channel +//! counts, block sizes and effort levels; hostile input; and ffmpeg as the reference (oracle; +//! skipped when ffmpeg is absent, a failure with `CRAFT_MEDIA_REQUIRE_ORACLES=1`) for files +//! ffmpeg's encoder writes at every compression level. + +use craft_audio::flac::{DecodeError, Decoder, Encoder, EncoderConfig, STREAMINFO_OFFSET, StreamInfo, decode}; +use std::process::Command; + +fn signal(channels: usize, frames: usize, bits: u32, seed: u32) -> Vec> { + let max = if bits == 32 { i32::MAX as f64 } else { ((1i64 << (bits - 1)) - 1) as f64 }; + let mut s = seed; + (0..channels) + .map(|c| { + (0..frames) + .map(|i| { + s ^= s << 13; + s ^= s >> 17; + s ^= s << 5; + let t = i as f64; + let v = match (i / 3000) % 4 { + 0 => (t * (0.01 + 0.007 * c as f64)).sin() * 0.6 + (t * 0.31).sin() * 0.1, + 1 => (f64::from(s) / f64::from(u32::MAX) - 0.5) * 1.8, + 2 => 0.0, + _ => { + if (i / 40) % 2 == 0 { + 0.99 + } else { + -0.99 + } + } + }; + (v * max).round() as i32 + }) + .collect() + }) + .collect() +} + +fn encode(channels: &[Vec], rate: u32, bits: u8, block: u16, level: u8) -> Vec { + let mut cfg = EncoderConfig::new(rate, channels.len() as u8, bits); + cfg.block_size = block; + cfg.level = level; + let mut enc = Encoder::new(cfg).expect("encoder"); + let mut file = enc.header(&[]); + let refs: Vec<&[i32]> = channels.iter().map(Vec::as_slice).collect(); + file.extend(enc.encode(&refs).expect("encode")); + file.extend(enc.finish()); + let at = STREAMINFO_OFFSET as usize; + file[at..at + 34].copy_from_slice(&enc.streaminfo()); + file +} + +#[test] +fn round_trips_through_the_encoder() { + for (channels, bits) in [(1usize, 8u8), (2, 8), (1, 12), (2, 16), (2, 20), (3, 24), (6, 24), (8, 16), (2, 32), (1, 32)] { + for (block, level) in [(4096u16, 5u8), (16, 0), (1000, 8), (65535, 3), (576, 1)] { + let frames = 9000 + usize::from(block % 97); + let src = signal(channels, frames, u32::from(bits), 0x1234_5679 + u32::from(bits)); + let file = encode(&src, 44_100, bits, block, level); + let got = decode(&file).unwrap_or_else(|e| panic!("{channels}ch {bits}-bit block {block} level {level}: {e}")); + assert_eq!((got.info.channels as usize, got.info.bits_per_sample, got.info.sample_rate), (channels, bits, 44_100)); + assert_eq!(got.channels, src, "{channels}ch {bits}-bit block {block} level {level}"); + } + } +} + +#[test] +fn frames_decode_one_at_a_time() { + let src = signal(2, 10_000, 16, 7); + let file = encode(&src, 48_000, 16, 4096, 5); + let info = StreamInfo::parse(&file[STREAMINFO_OFFSET as usize..]).expect("streaminfo"); + let dec = Decoder::new(info); + // The first frame follows the metadata blocks; find the first position a frame decodes at. + let at = (42..file.len()).find(|&p| dec.decode_frame(&file[p..]).is_ok()).expect("a frame"); + let first = dec.decode_frame(&file[at..]).expect("frame"); + assert_eq!((first.block_size, first.number, first.sample_rate, first.bits_per_sample), (4096, 0, 48_000, 16)); + assert_eq!(first.channels[0], src[0][..4096]); + // Without the STREAMINFO a frame that spells out its own rate and depth still decodes. + let _ = Decoder::without_streaminfo().decode_frame(&file[at..]); +} + +#[test] +fn hostile_input_is_an_error_not_a_panic() { + let src = signal(2, 6000, 16, 11); + let file = encode(&src, 44_100, 16, 1152, 5); + for n in 0..file.len().min(3000) { + let _ = decode(&file[..n]); + } + // A cut file is truncated, not silently shorter. + assert!(decode(&file[..file.len() - 5]).is_err()); + // Every bit flip in the first frames is caught by a CRC or another check, never a panic. + for i in 0..file.len().min(2500) { + for bit in 0..8 { + let mut c = file.clone(); + c[i] ^= 1 << bit; + let _ = decode(&c); + } + } + // A sample limit stops a stream that claims too much. + assert_eq!(craft_audio::flac::decode_with_limit(&file, 1000), Err(DecodeError::TooLarge)); + assert!(decode(b"nope").is_err()); + assert!(decode(b"fLaC").is_err()); +} + +// ---- ffmpeg ---- + +fn ffmpeg_run(ff: &std::path::Path, args: &[&str]) -> Vec { + let out = Command::new(ff).args(["-v", "error", "-nostdin", "-y"]).args(args).output().expect("run ffmpeg"); + assert!(out.status.success(), "ffmpeg {args:?}: {}", String::from_utf8_lossy(&out.stderr)); + out.stdout +} + +#[test] +fn ffmpeg_files_decode_to_ffmpegs_samples() { + let Some(ff) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("flac_decode"); + let tones = "aevalsrc=exprs=0.4*sin(2*PI*441*t)+0.2*sin(2*PI*3100*t)|0.3*sin(2*PI*660*t)*sin(2*PI*3*t):s=44100:d=1.3"; + let noise = "anoisesrc=d=1.3:c=white:r=44100:a=0.5:s=3"; + for (src, name) in [(tones, "tones"), (noise, "noise")] { + for channels in [1usize, 2, 6] { + for (fmt, bytes, bits) in [("s16", 2usize, 16u32), ("s32", 4, 24)] { + for level in [0, 3, 5, 8, 12] { + let file = dir.join(format!("ffmpeg_{name}_{channels}ch_{bits}_l{level}.flac")); + let f = file.to_str().expect("path"); + let (ch, lv) = (channels.to_string(), level.to_string()); + ffmpeg_run(&ff, &["-f", "lavfi", "-i", src, "-ac", &ch, "-sample_fmt", fmt, "-compression_level", &lv, "-c:a", "flac", f]); + let theirs = ffmpeg_run(&ff, &["-i", f, "-f", if bits == 16 { "s16le" } else { "s32le" }, "-"]); + let got = + decode(&std::fs::read(&file).expect("read")).unwrap_or_else(|e| panic!("{name} {channels}ch {bits}-bit level {level}: {e}")); + assert_eq!(got.info.channels as usize, channels); + let frames = got.channels[0].len(); + assert_eq!(theirs.len(), frames * channels * bytes, "{name} {channels}ch {bits} l{level}: length"); + let mut ok = true; + for i in 0..frames { + for c in 0..channels { + let at = (i * channels + c) * bytes; + let want = if bytes == 2 { + i32::from(i16::from_le_bytes([theirs[at], theirs[at + 1]])) + } else { + i32::from_le_bytes([theirs[at], theirs[at + 1], theirs[at + 2], theirs[at + 3]]) + }; + // ffmpeg returns 24-bit audio left-aligned in 32 bits. + let mine = if bits == 24 { got.channels[c][i] << 8 } else { got.channels[c][i] }; + if mine != want { + ok = false; + } + } + } + assert!(ok, "{name} {channels}ch {bits}-bit level {level}: samples differ from ffmpeg's decode"); + } + } + } + } +} + +#[test] +fn ffmpeg_decodes_our_files_to_our_samples() { + let Some(ff) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("flac_decode"); + for (channels, bits) in [(1usize, 16u8), (2, 16), (2, 24), (6, 16)] { + let src = signal(channels, 20_000, u32::from(bits), 99); + let file = dir.join(format!("ours_{channels}ch_{bits}.flac")); + std::fs::write(&file, encode(&src, 44_100, bits, 4096, 5)).expect("write"); + let theirs = ffmpeg_run(&ff, &["-i", file.to_str().expect("path"), "-f", if bits == 16 { "s16le" } else { "s32le" }, "-"]); + let got = decode(&std::fs::read(&file).expect("read")).expect("decode"); + let bytes = if bits == 16 { 2 } else { 4 }; + for i in 0..20_000 { + for c in 0..channels { + let at = (i * channels + c) * bytes; + let want = if bytes == 2 { + i32::from(i16::from_le_bytes([theirs[at], theirs[at + 1]])) + } else { + i32::from_le_bytes([theirs[at], theirs[at + 1], theirs[at + 2], theirs[at + 3]]) >> 8 + }; + assert_eq!(got.channels[c][i], want, "{channels}ch {bits}-bit sample {i} of channel {c}"); + } + } + } +} From 4f6e49b1ee3e450e5d5e105271465c13be19354f Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Sun, 15 Nov 2026 15:13:06 +0100 Subject: [PATCH 075/382] Test SVG preflight depth and root viewport rewrite; accept px root sizes Correct the source-depth expectations (svg>g>path is 3 levels, 2 open), cover Preflight and every rewrite_root_viewport refusal, and read a root width or height written with px as the pixels the docs promise. --- crates/svg/src/preflight.rs | 8 ++-- crates/svg/src/tree.rs | 9 +++- crates/svg/src/tree/tests.rs | 82 ++++++++++++++++++++++++++++++++++++ 3 files changed, 94 insertions(+), 5 deletions(-) diff --git a/crates/svg/src/preflight.rs b/crates/svg/src/preflight.rs index 463c3ce16..0c2d3a7b1 100644 --- a/crates/svg/src/preflight.rs +++ b/crates/svg/src/preflight.rs @@ -74,7 +74,8 @@ pub fn parse_text<'a>(svg: &'a str, limits: &Limits) -> Result(svg: &'a str, limits: &Limits) -> Result<(roxmltree::Document<'a>, usize, usize), Error> { if svg.len() > limits.bytes { return Err(Error::Text(crate::svgz::Error::TooLarge(limits.bytes))); @@ -106,8 +107,9 @@ mod tests { let limits = Limits { depth: 4, ..Default::default() }; let (document, depth, open_depth) = parse_text_with_depth("", &limits)?; assert!(document.root_element().has_tag_name("svg")); - assert_eq!(depth, 2); - assert_eq!(open_depth, 0); + // Every element is a level (svg, g, path); a self-closing leaf opens none (svg, g). + assert_eq!(depth, 3); + assert_eq!(open_depth, 2); let simple = parse_text("", &limits)?; assert!(simple.root_element().has_tag_name("svg")); Ok(()) diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index 86a6d0ab1..37d956a48 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -167,7 +167,8 @@ pub struct Preflight<'s> { } impl Preflight<'_> { - /// Maximum source nesting depth before following references. + /// The deepest stack of open source elements, before references are followed; a + /// self-closing leaf opens no level (`` is 2). pub fn depth(&self) -> usize { self.depth } @@ -223,7 +224,11 @@ pub fn rewrite_root_viewport(svg: &str, target: Viewport, limits: &Limits, outpu } let root_dimension = |key: &str| { let value = root.attribute(key)?; - let (number, scale) = value.strip_suffix("pt").map_or((value, 1.0), |n| (n, 4.0 / 3.0)); + let value = value.trim(); + let (number, scale) = match value.strip_suffix("pt") { + Some(points) => (points, 4.0 / 3.0), + None => (value.strip_suffix("px").unwrap_or(value), 1.0), + }; number.parse::().ok().map(|n| n * scale).filter(|n| n.is_finite() && *n > 0.0) }; let (width, height) = root_dimension("width") diff --git a/crates/svg/src/tree/tests.rs b/crates/svg/src/tree/tests.rs index 2708ae0f4..99b0c1cab 100644 --- a/crates/svg/src/tree/tests.rs +++ b/crates/svg/src/tree/tests.rs @@ -584,3 +584,85 @@ mod invalid_image_accounting { assert_eq!(report.raster_limit_images, 1); } } + +#[test] +fn preflight_keeps_source_depth_and_parses_the_checked_tree() { + let text = svg(""); + let checked = preflight(&text, &Limits::default()).unwrap(); + // svg and g are open; the self-closing rect opens no level. + assert_eq!(checked.depth(), 2); + let tree = checked.parse(&options()).unwrap(); + assert_eq!(tree.size().width(), 10.0); + assert!(matches!(preflight(&svg(&groups(30)), &shallow()), Err(Error::TooDeep(24)))); +} + +#[test] +fn preflight_matches_parse_text_refusals() { + for text in [""] { + assert!(matches!(preflight(text, &Limits::default()), Err(Error::Xml(_)))); + assert!(matches!(parse_text(text, &Limits::default(), &options()), Err(Error::Xml(_)))); + } +} + +#[test] +fn rewrite_root_viewport_wraps_the_root_and_keeps_the_preamble() { + let source = concat!( + "\n]>\n", + "", + "" + ); + let out = rewrite_root_viewport(source, Viewport { width: 40.0, height: 30.0 }, &Limits::default(), 4096).unwrap(); + assert!(out.starts_with("\n]>\n")); + let tree = parse_text(&out, &Limits::default(), &options()).unwrap(); + assert_eq!((tree.size().width(), tree.size().height()), (40.0, 30.0)); +} + +#[test] +fn rewrite_root_viewport_reads_points_and_pixels() { + let points = rewrite_root_viewport( + "", + Viewport { width: 1.0, height: 1.0 }, + &Limits::default(), + 4096, + ) + .unwrap(); + assert!(points.contains("viewBox=\"0 0 96 48\"")); + let pixels = rewrite_root_viewport( + "", + Viewport { width: 1.0, height: 1.0 }, + &Limits::default(), + 4096, + ) + .unwrap(); + assert!(pixels.contains("viewBox=\"0 0 12 8\"")); +} + +#[test] +fn rewrite_root_viewport_refusals() { + let limits = Limits::default(); + let one = Viewport { width: 1.0, height: 1.0 }; + let sized = ""; + for target in [ + Viewport { width: f64::NAN, height: 1.0 }, + Viewport { width: 1.0, height: f64::INFINITY }, + Viewport { width: 0.0, height: 1.0 }, + Viewport { width: 1.0, height: -2.0 }, + ] { + assert!(matches!(rewrite_root_viewport(sized, target, &limits, 4096), Err(Error::Viewport(_)))); + } + assert!(matches!(rewrite_root_viewport("", one, &limits, 4096), Err(Error::Viewport(_)))); + for source in [ + "", + "", + "", + "", + "", + ] { + assert!(matches!(rewrite_root_viewport(source, one, &limits, 4096), Err(Error::Viewport(_))), "{source}"); + } + assert!(matches!(rewrite_root_viewport(" Date: Sun, 15 Nov 2026 15:18:25 +0100 Subject: [PATCH 076/382] craft-captions: ASS and SSA subtitles (Format::Ass) Reads the [Events] section of ASS v4+ and SSA v4 files and writes a minimal ASS v4+ file. Keeps line breaks, the Name field as the speaker and the \i, \b, \u override tags; other override tags and vector drawings are dropped. Closes #1550 --- Cargo.lock | 1 + crates/captions/Cargo.toml | 2 + crates/captions/README.md | 1 + crates/captions/src/ass.rs | 239 +++++++++++++++++++++++++++++++ crates/captions/src/lib.rs | 17 ++- crates/captions/tests/it/ass.rs | 113 +++++++++++++++ crates/captions/tests/it/main.rs | 1 + 7 files changed, 371 insertions(+), 3 deletions(-) create mode 100644 crates/captions/src/ass.rs create mode 100644 crates/captions/tests/it/ass.rs diff --git a/Cargo.lock b/Cargo.lock index 8e12a6995..55552f9f9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1425,6 +1425,7 @@ version = "0.1.0" name = "craft-captions" version = "0.1.0" dependencies = [ + "craft-media-testkit", "craft-timeline", "craft-xml", "proptest", diff --git a/crates/captions/Cargo.toml b/crates/captions/Cargo.toml index df665336d..cd09f7e16 100644 --- a/crates/captions/Cargo.toml +++ b/crates/captions/Cargo.toml @@ -19,3 +19,5 @@ thiserror = { workspace = true } proptest = { workspace = true } # A second XML reader for the tests: checks of written TTML, and the comparison in tests/it/ttml_xml_views.rs. roxmltree = "0.21" +# ffmpeg as the reference for the ASS tests (tests/it/ass.rs). +craft-media-testkit = { workspace = true } diff --git a/crates/captions/README.md b/crates/captions/README.md index 0676d1d72..7380a3ce4 100644 --- a/crates/captions/README.md +++ b/crates/captions/README.md @@ -55,6 +55,7 @@ lists at most 20 characters per stream. | EBU STL `.stl` | yes | yes | EBU Tech 3264-E: GSI block + 128-byte TTI blocks, `STL25.01` (25 fps) or `STL30.01` (read/written as 29.97 fps, non-drop labels), ISO/IEC 6937 Latin text (accents as diacritic + letter), italics / underline codes as `` / ``, extension blocks for long subtitles, start-of-programme (TCP) subtracted. | | TTML `.ttml` (IMSC1) | yes | yes | Writes the IMSC1 Text profile (TTML2 namespaces) with the document's language as `xml:lang` (read back on import): `

                      ` per cue, `
                      `, styled ``s for `` / `` / ``, `ttm:agent` speakers, exact frame times (`123f`) at the sequence rate. Reads any TTML (TTML1, TTML2, the 2006 `ttaf1` drafts): clock / frame / offset / tick times, `dur`, nested time containers (`body` / `div` begins offset and ends clip their contents; `seq` containers are read as `par` with a warning), timed spans, referenced styles. | | DFXP `.dfxp` | yes | yes | TTML1 with the DFXP presentation profile; clock times in milliseconds (frame-exact after `snap_to_frames`). | +| ASS / SSA `.ass`, `.ssa` | yes | yes (ASS v4+) | The `[Events]` section: `Dialogue:` lines through the file's `Format:` line, `Name` as the speaker, `\N`, `\n`, `\h` and the `\i`, `\b`, `\u` override tags kept (as ``, ``, ``); other override tags and drawing lines are dropped. Times are centiseconds. Written files have one `Default` style. | All cue times are exact `Tick`s. Milliseconds convert exactly (1 ms = 254 016 000 ticks); SCC frames map through `FrameRate::FPS_29_97`. `Document::snap_to_frames` snaps cues to a frame grid and diff --git a/crates/captions/src/ass.rs b/crates/captions/src/ass.rs new file mode 100644 index 000000000..3c907c829 --- /dev/null +++ b/crates/captions/src/ass.rs @@ -0,0 +1,239 @@ +//! Advanced SubStation Alpha and SubStation Alpha (`.ass`, `.ssa`). +//! +//! Reading takes the `[Events]` section: its `Format:` line gives the field order (ASS v4+ and SSA +//! v4 differ in the first field only), each `Dialogue:` line becomes a cue; `Comment:` lines and +//! the other sections are skipped. A cue gets the `Name` field as its speaker. The text keeps what +//! the neutral model can show: `\N` and `\n` become a line break and a space, `\h` a no-break +//! space, and the override tags `\i`, `\b` and `\u` become ``, `` and ``. Every other +//! override tag (colours, fonts, positions, karaoke, animation) is dropped, and a line that draws +//! vector shapes (`\p1`) is skipped with a warning. +//! +//! Writing gives a minimal ASS v4+ file: one `Default` style, one `Dialogue:` line per cue with +//! times to the centisecond. Braces in the text, which ASS reads as override blocks, are written +//! as the full-width `{` and `�`. + +use crate::time::{TICKS_PER_SECOND, Tick}; +use crate::{Cue, Document, Error, Result}; + +const TICKS_PER_CS: i64 = TICKS_PER_SECOND / 100; + +/// `H:MM:SS.cc`, the form SSA and ASS use (any number of fraction digits is read). +fn parse_time(s: &str) -> Option { + let s = s.trim(); + let (hms, frac) = s.split_once('.').unwrap_or((s, "")); + let mut parts = hms.split(':'); + let (h, m, sec) = (parts.next()?, parts.next()?, parts.next()?); + if parts.next().is_some() { + return None; + } + let num = |p: &str| -> Option { (!p.is_empty() && p.len() <= 9 && p.bytes().all(|b| b.is_ascii_digit())).then(|| p.parse().ok()).flatten() }; + let (h, m, sec) = (num(h)?, num(m)?, num(sec)?); + if m >= 60 || sec >= 60 || h > 9999 { + return None; + } + let mut ticks = ((h * 60 + m) * 60 + sec) * TICKS_PER_SECOND; + if !frac.is_empty() { + if frac.len() > 9 || !frac.bytes().all(|b| b.is_ascii_digit()) { + return None; + } + let d: i64 = frac.parse().ok()?; + ticks += (i128::from(d) * i128::from(TICKS_PER_SECOND) / 10i128.pow(frac.len() as u32)) as i64; + } + Some(Tick(ticks)) +} + +fn format_time(t: Tick) -> String { + let cs = (i128::from(t.0.max(0)) + i128::from(TICKS_PER_CS) / 2) / i128::from(TICKS_PER_CS); + let (h, m, s, c) = (cs / 360_000, (cs / 6000) % 60, (cs / 100) % 60, cs % 100); + format!("{h}:{m:02}:{s:02}.{c:02}") +} + +/// The Text field of a Dialogue line as cue text; `None` when the line draws shapes. +fn convert_text(raw: &str) -> Option { + let mut out = String::new(); + // Open ``, ``, `` in the order they were opened. + let mut open: Vec = Vec::new(); + let mut chars = raw.chars().peekable(); + let mut drawing = false; + let mut dropped_drawing = false; + while let Some(c) = chars.next() { + match c { + '{' => { + let mut block = String::new(); + let mut closed = false; + for b in chars.by_ref() { + if b == '}' { + closed = true; + break; + } + block.push(b); + } + if !closed { + // An unterminated block is literal text. + out.push('{'); + out.push_str(&block); + continue; + } + for tag in block.split('\\').skip(1) { + let tag = tag.trim_end(); + let (name, val) = tag.split_at(tag.find(|c: char| !c.is_ascii_alphabetic()).unwrap_or(tag.len())); + match name { + "i" | "b" | "u" => { + let letter = name.chars().next().unwrap_or('i'); + let on = val.trim() != "0"; + if on && !open.contains(&letter) { + open.push(letter); + out.push_str(&format!("<{letter}>")); + } else if !on && open.contains(&letter) { + // Close back to it, reopening what was opened after. + let at = open.iter().position(|&o| o == letter).unwrap_or(0); + let after: Vec = open.split_off(at + 1); + for o in after.iter().rev() { + out.push_str(&format!("")); + } + open.pop(); + out.push_str(&format!("")); + for o in after { + open.push(o); + out.push_str(&format!("<{o}>")); + } + } + } + "p" => drawing = val.trim().parse::().unwrap_or(0) != 0, + _ => {} + } + } + } + '\\' => match chars.peek() { + Some('N') => { + chars.next(); + out.push('\n'); + } + Some('n') => { + chars.next(); + out.push(' '); + } + Some('h') => { + chars.next(); + out.push('\u{a0}'); + } + _ => out.push('\\'), + }, + c => { + if drawing { + dropped_drawing = true; + } else { + out.push(c); + } + } + } + } + if dropped_drawing && out.trim().is_empty() { + return None; + } + while let Some(o) = open.pop() { + out.push_str(&format!("")); + } + Some(out) +} + +pub fn parse(text: &str) -> Result { + let text = text.strip_prefix('\u{feff}').unwrap_or(text); + let mut doc = Document::default(); + let mut in_events = false; + let mut saw_events = false; + // Column of each field in a Dialogue line. + let mut cols: Vec = + ["layer", "start", "end", "style", "name", "marginl", "marginr", "marginv", "effect", "text"].map(String::from).to_vec(); + let mut drawings = 0usize; + for (n, line) in text.lines().enumerate() { + let line = line.trim(); + if line.starts_with('[') && line.ends_with(']') { + in_events = line.eq_ignore_ascii_case("[events]"); + saw_events |= in_events; + continue; + } + if !in_events { + continue; + } + let Some((key, rest)) = line.split_once(':') else { continue }; + let rest = rest.trim_start(); + match key.trim().to_ascii_lowercase().as_str() { + "format" => cols = rest.split(',').map(|f| f.trim().to_ascii_lowercase()).collect(), + "dialogue" => { + // The last column (Text) keeps its commas. + let fields: Vec<&str> = rest.splitn(cols.len(), ',').collect(); + let get = |name: &str| cols.iter().position(|c| c == name).and_then(|i| fields.get(i)).copied(); + let (Some(start), Some(end), Some(raw)) = (get("start").and_then(parse_time), get("end").and_then(parse_time), get("text")) else { + doc.warnings.push(format!("line {}: not a Dialogue line this reader understands", n + 1)); + continue; + }; + let Some(text) = convert_text(raw) else { + drawings += 1; + continue; + }; + let name = get("name").map(str::trim).filter(|s| !s.is_empty()); + doc.cues.push(Cue { start, end, text, speaker: name.map(str::to_string), ..Default::default() }); + } + _ => {} + } + } + if !saw_events { + return Err(Error::NotFormat("ASS")); + } + if drawings > 0 { + doc.warnings.push(format!("{drawings} vector drawing line(s) were skipped")); + } + Ok(doc) +} + +fn escape(text: &str) -> String { + let mut out = String::with_capacity(text.len() + 8); + let mut rest = text; + while !rest.is_empty() { + if let Some(r) = rest.strip_prefix("") { + out.push_str("{\\i1}"); + rest = r; + } else if let Some(r) = rest.strip_prefix("") { + out.push_str("{\\i0}"); + rest = r; + } else if let Some(r) = rest.strip_prefix("") { + out.push_str("{\\b1}"); + rest = r; + } else if let Some(r) = rest.strip_prefix("") { + out.push_str("{\\b0}"); + rest = r; + } else if let Some(r) = rest.strip_prefix("") { + out.push_str("{\\u1}"); + rest = r; + } else if let Some(r) = rest.strip_prefix("") { + out.push_str("{\\u0}"); + rest = r; + } else if let Some(c) = rest.chars().next() { + match c { + '\n' => out.push_str("\\N"), + '{' => out.push('\u{ff5b}'), + '}' => out.push('\u{ff5d}'), + '\u{a0}' => out.push_str("\\h"), + c => out.push(c), + } + rest = &rest[c.len_utf8()..]; + } + } + out +} + +pub fn write(doc: &Document) -> String { + let mut out = String::from( + "[Script Info]\n; Written by craft-captions\nScriptType: v4.00+\nWrapStyle: 0\nScaledBorderAndShadow: yes\nPlayResX: 384\nPlayResY: 288\n\n\ + [V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n\ + Style: Default,Arial,16,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,0,2,10,10,10,1\n\n\ + [Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n", + ); + for c in &doc.cues { + // A comma in the Name field would shift the columns; the other fields are fixed text. + let name = c.speaker.as_deref().unwrap_or("").replace([',', '\n'], " "); + out.push_str(&format!("Dialogue: 0,{},{},Default,{},0,0,0,,{}\n", format_time(c.start), format_time(c.end), name, escape(&c.text))); + } + out +} diff --git a/crates/captions/src/lib.rs b/crates/captions/src/lib.rs index 0ba9f2ba5..e8a492722 100644 --- a/crates/captions/src/lib.rs +++ b/crates/captions/src/lib.rs @@ -4,7 +4,7 @@ //! - **Files:** [SubRip](srt) (`.srt`), [WebVTT](vtt) (`.vtt`), [Scenarist SCC](scc) (`.scc`, //! CEA-608 pop-on, roll-up and paint-on on read; pop-on on write), [MacCaption MCC](mcc) //! (`.mcc`, SMPTE ST 334-2 packets with CEA-608 and CEA-708), [EBU STL](stl) (`.stl`, EBU -//! Tech 3264) and [TTML](ttml) (`.ttml` IMSC1 Text profile, `.dfxp` DFXP) parse into a +//! Tech 3264), [ASS/SSA](ass) (`.ass`, `.ssa`) and [TTML](ttml) (`.ttml` IMSC1 Text profile, `.dfxp` DFXP) parse into a //! [`Document`] of [`Cue`]s and write back. Readers are forgiving (BOM, UTF-16, Windows-1252 //! fallback, CRLF/CR, missing SRT indexes, `,` or `.` milliseconds, missing hours, no blank //! line between cues); writers are strict. WebVTT cue identifiers, cue settings, `` @@ -32,6 +32,7 @@ #[doc = include_str!("../README.md")] struct ReadmeExamples; +pub mod ass; pub mod cea608; pub mod mcc; pub mod scc; @@ -69,10 +70,12 @@ pub enum Format { Ttml, /// DFXP (TTML1). Dfxp, + /// Advanced SubStation Alpha (also reads SubStation Alpha). + Ass, } impl Format { - pub const ALL: [Format; 7] = [Format::Srt, Format::WebVtt, Format::Scc, Format::Mcc, Format::Stl, Format::Ttml, Format::Dfxp]; + pub const ALL: [Format; 8] = [Format::Srt, Format::WebVtt, Format::Scc, Format::Mcc, Format::Stl, Format::Ttml, Format::Dfxp, Format::Ass]; pub fn name(self) -> &'static str { match self { Format::Srt => "SubRip (SRT)", @@ -82,6 +85,7 @@ impl Format { Format::Stl => "EBU STL", Format::Ttml => "TTML (IMSC1)", Format::Dfxp => "DFXP (TTML1)", + Format::Ass => "Advanced SubStation Alpha (ASS)", } } pub fn extension(self) -> &'static str { @@ -93,6 +97,7 @@ impl Format { Format::Stl => "stl", Format::Ttml => "ttml", Format::Dfxp => "dfxp", + Format::Ass => "ass", } } pub fn from_name(s: &str) -> Option { @@ -104,6 +109,7 @@ impl Format { "stl" | "ebu-stl" | "ebustl" | "ebu" => Some(Format::Stl), "ttml" | "imsc" | "imsc1" | "xml" => Some(Format::Ttml), "dfxp" => Some(Format::Dfxp), + "ass" | "ssa" => Some(Format::Ass), _ => None, } } @@ -251,6 +257,9 @@ pub fn detect(bytes: &[u8], ext: Option<&str>) -> Option { if head.starts_with("File Format=MacCaption_MCC") { return Some(Format::Mcc); } + if head.starts_with("[Script Info]") { + return Some(Format::Ass); + } let ext = ext.map(|e| e.trim_start_matches('.').to_ascii_lowercase()); if (head.starts_with('<') && (head.contains("") || head.contains(":tt "))) && (head.contains("ns/ttml") || head.contains("ttaf1")) @@ -262,7 +271,7 @@ pub fn detect(bytes: &[u8], ext: Option<&str>) -> Option { match ext.as_deref() { Some("srt") if has_arrow_timing || head.is_empty() => Some(Format::Srt), Some("vtt") if has_arrow_timing => Some(Format::WebVtt), - Some("srt" | "vtt" | "scc" | "mcc" | "stl" | "ttml" | "dfxp" | "xml") => None, + Some("srt" | "vtt" | "scc" | "mcc" | "stl" | "ttml" | "dfxp" | "xml" | "ass" | "ssa") => None, _ if has_arrow_timing => Some(Format::Srt), _ => None, } @@ -296,6 +305,7 @@ fn parse_unbounded(bytes: &[u8], format: Format) -> Result { Format::Scc => scc::parse(&text), Format::Mcc => mcc::parse(&text), Format::Ttml | Format::Dfxp => ttml::parse(&text), + Format::Ass => ass::parse(&text), Format::Stl => stl::parse(bytes), } } @@ -333,6 +343,7 @@ pub fn write(doc: &Document, format: Format, opts: WriteOptions) -> Vec { Format::Stl => stl::write(doc, opts.rate, opts.program), Format::Ttml => ttml::write(doc, ttml::Flavor::Imsc1, opts.rate, doc.language.as_deref().unwrap_or("")).into_bytes(), Format::Dfxp => ttml::write(doc, ttml::Flavor::Dfxp, opts.rate, doc.language.as_deref().unwrap_or("")).into_bytes(), + Format::Ass => ass::write(doc).into_bytes(), } } diff --git a/crates/captions/tests/it/ass.rs b/crates/captions/tests/it/ass.rs new file mode 100644 index 000000000..de5d43167 --- /dev/null +++ b/crates/captions/tests/it/ass.rs @@ -0,0 +1,113 @@ +//! SubStation Alpha / Advanced SubStation Alpha: reading, writing, and ffmpeg as the reference +//! (oracle; skipped when ffmpeg is absent, a failure with `CRAFT_MEDIA_REQUIRE_ORACLES=1`). + +use craft_captions::{Cue, Document, Format, Tick, WriteOptions, detect, parse, write}; +use std::process::Command; + +const T: i64 = craft_captions::TICKS_PER_SECOND; + +fn cs(n: i64) -> Tick { + Tick(n * (T / 100)) +} + +const SAMPLE: &str = "\u{feff}[Script Info]\n; a comment\nTitle: Test\nScriptType: v4.00+\n\n[V4+ Styles]\nFormat: Name, Fontname\nStyle: Default,Arial\n\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\nComment: 0,0:00:00.00,0:00:01.00,Default,,0,0,0,,not a cue\nDialogue: 0,0:00:01.50,0:00:03.25,Default,Bob,0,0,0,,Hello, {\\i1}world{\\i0}\\Nsecond {\\b1}line{\\b0}\nDialogue: 0,1:02:03.04,1:02:04.5,Default,,0,0,0,,{\\pos(10,20)\\c&H0000FF&}Red\\hspace\\nsoft\nDialogue: 0,0:00:09.00,0:00:10.00,Default,,0,0,0,,{\\p1}m 0 0 l 100 0 100 100{\\p0}\n"; + +#[test] +fn reads_dialogue_lines_with_commas_overrides_and_line_breaks() { + let doc = parse(SAMPLE.as_bytes(), Format::Ass).unwrap(); + assert_eq!(doc.cues.len(), 2); + assert_eq!(doc.cues[0].start, cs(150)); + assert_eq!(doc.cues[0].end, cs(325)); + assert_eq!(doc.cues[0].text, "Hello, world\nsecond line"); + assert_eq!(doc.cues[0].speaker.as_deref(), Some("Bob")); + // 1:02:03.04, a one-digit fraction, an override block dropped, \h and \n. + assert_eq!(doc.cues[1].start, Tick((3600 + 120 + 3) * T + 4 * (T / 100))); + assert_eq!(doc.cues[1].end, Tick((3600 + 120 + 4) * T + T / 2)); + assert_eq!(doc.cues[1].text, "Red\u{a0}space soft"); + assert!(doc.warnings.iter().any(|w| w.contains("vector drawing")), "{:?}", doc.warnings); +} + +#[test] +fn ssa_v4_files_read_through_their_own_format_line() { + let ssa = "[Script Info]\nScriptType: v4.00\n\n[V4 Styles]\nFormat: Name\n\n[Events]\nFormat: Marked, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\nDialogue: Marked=0,0:00:01.00,0:00:02.00,*Default,,0000,0000,0000,,Old style\n"; + let doc = parse(ssa.as_bytes(), Format::Ass).unwrap(); + assert_eq!((doc.cues[0].start, doc.cues[0].end, doc.cues[0].text.as_str()), (cs(100), cs(200), "Old style")); +} + +#[test] +fn write_then_read_keeps_times_text_and_speaker() { + let cues = vec![ + Cue { start: cs(100), end: cs(250), text: "Line one\nline two".into(), speaker: Some("Ann".into()), ..Default::default() }, + Cue { + start: Tick(7200 * T + 99 * (T / 100)), + end: Tick(7203 * T), + text: "bold and under {braces}".into(), + ..Default::default() + }, + ]; + let doc = Document { cues, ..Default::default() }; + let bytes = write(&doc, Format::Ass, WriteOptions::default()); + assert_eq!(detect(&bytes, Some("ass")), Some(Format::Ass)); + let back = parse(&bytes, Format::Ass).unwrap(); + assert_eq!(back.cues[0], doc.cues[0]); + assert_eq!(back.cues[1].start, doc.cues[1].start); + // Braces are written full-width, as ASS reads `{` as the start of an override block. + assert_eq!(back.cues[1].text, "bold and under \u{ff5b}braces\u{ff5d}"); +} + +#[test] +fn files_without_an_events_section_are_not_ass() { + assert!(parse(b"[Script Info]\nTitle: x\n", Format::Ass).is_err()); + assert!(parse(b"hello", Format::Ass).is_err()); + assert_eq!(detect(b"hello", Some("ass")), None); +} + +#[test] +fn bad_lines_are_skipped_with_a_warning() { + let text = "[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\nDialogue: 0,garbage,0:00:02.00,Default,,0,0,0,,x\nDialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,ok\n"; + let doc = parse(text.as_bytes(), Format::Ass).unwrap(); + assert_eq!(doc.cues.len(), 1); + assert_eq!(doc.warnings.len(), 1); +} + +fn ffmpeg_run(ff: &std::path::Path, args: &[&str]) { + let out = Command::new(ff).args(["-v", "error", "-nostdin", "-y"]).args(args).output().expect("run ffmpeg"); + assert!(out.status.success(), "ffmpeg {args:?}: {}", String::from_utf8_lossy(&out.stderr)); +} + +const SRT: &str = "1\n00:00:01,500 --> 00:00:03,250\nHello, world\nsecond line\n\n2\n00:00:04,000 --> 00:00:05,990\nPlain, with a comma\n\n3\n01:00:00,010 --> 01:00:02,999\nUnder and italic both\n"; + +#[test] +fn we_read_what_ffmpeg_writes() { + let Some(ff) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("captions_ass"); + let (srt, ass) = (dir.join("in.srt"), dir.join("ffmpeg.ass")); + std::fs::write(&srt, SRT).expect("write"); + ffmpeg_run(&ff, &["-i", srt.to_str().expect("path"), ass.to_str().expect("path")]); + let from_ass = parse(&std::fs::read(&ass).expect("read"), Format::Ass).expect("parse ass"); + let from_srt = parse(SRT.as_bytes(), Format::Srt).expect("parse srt"); + assert_eq!(from_ass.cues.len(), from_srt.cues.len()); + for (a, s) in from_ass.cues.iter().zip(&from_srt.cues) { + // ASS times are centiseconds; the SRT ones round to them. + assert_eq!(a.start, cs((s.start.0 + T / 200) / (T / 100)), "start of {:?}", s.text); + assert_eq!(a.end, cs((s.end.0 + T / 200) / (T / 100)), "end of {:?}", s.text); + assert_eq!(a.text, s.text); + } +} + +#[test] +fn ffmpeg_reads_what_we_write() { + let Some(ff) = craft_media_testkit::ffmpeg() else { return }; + let dir = craft_media_testkit::fixture_subdir("captions_ass"); + let doc = parse(SRT.as_bytes(), Format::Srt).expect("parse srt"); + let (ass, srt) = (dir.join("ours.ass"), dir.join("back.srt")); + std::fs::write(&ass, write(&doc, Format::Ass, WriteOptions::default())).expect("write"); + ffmpeg_run(&ff, &["-i", ass.to_str().expect("path"), srt.to_str().expect("path")]); + let theirs = parse(&std::fs::read(&srt).expect("read"), Format::Srt).expect("parse back"); + assert_eq!(theirs.cues.len(), doc.cues.len()); + for (t, d) in theirs.cues.iter().zip(&doc.cues) { + assert_eq!(t.start, cs((d.start.0 + T / 200) / (T / 100))); + assert_eq!(t.end, cs((d.end.0 + T / 200) / (T / 100))); + assert_eq!(t.text, d.text, "text of the cue at {:?}", d.start); + } +} diff --git a/crates/captions/tests/it/main.rs b/crates/captions/tests/it/main.rs index 16f8fcbb6..be03d2855 100644 --- a/crates/captions/tests/it/main.rs +++ b/crates/captions/tests/it/main.rs @@ -1,3 +1,4 @@ +mod ass; mod limits; mod literal_roundtrips; mod mcc_708_timing; From ee20ae63fdc314da17362b0e1dc429fa081a686b Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 15:24:46 +0100 Subject: [PATCH 077/382] craft-audio: qoa_oracle test without index loops (CI clippy) --- crates/audio/tests/qoa_oracle.rs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/crates/audio/tests/qoa_oracle.rs b/crates/audio/tests/qoa_oracle.rs index cf0ed8c37..7b5ac2674 100644 --- a/crates/audio/tests/qoa_oracle.rs +++ b/crates/audio/tests/qoa_oracle.rs @@ -55,12 +55,7 @@ fn ffmpeg_decodes_our_files_to_the_same_samples() { .expect("run ffmpeg"); assert!(out.status.success(), "ffmpeg failed on {}: {}", file.display(), String::from_utf8_lossy(&out.stderr)); let theirs: Vec = out.stdout.as_chunks::<2>().0.iter().map(|b| i16::from_le_bytes(*b)).collect(); - let mut interleaved = Vec::with_capacity(frames * channels); - for i in 0..frames { - for c in 0..channels { - interleaved.push(ours.channels[c][i]); - } - } + let interleaved: Vec = (0..frames).flat_map(|i| ours.channels.iter().map(move |ch| ch[i])).collect(); assert_eq!(theirs.len(), interleaved.len(), "{rate} Hz, {channels} ch, {frames} frames: sample count"); assert!(theirs == interleaved, "{rate} Hz, {channels} ch, {frames} frames: samples differ"); } From 2d5f2e4a73eb54326b3192120a7a4457ad79b07f Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 15:25:56 +0100 Subject: [PATCH 078/382] craft-audio: flac_decode tests without index loops (CI clippy) --- crates/audio/tests/flac_decode.rs | 49 ++++++++++++++----------------- 1 file changed, 22 insertions(+), 27 deletions(-) diff --git a/crates/audio/tests/flac_decode.rs b/crates/audio/tests/flac_decode.rs index 03d6d678e..c35267b08 100644 --- a/crates/audio/tests/flac_decode.rs +++ b/crates/audio/tests/flac_decode.rs @@ -104,6 +104,21 @@ fn hostile_input_is_an_error_not_a_panic() { // ---- ffmpeg ---- +/// Little-endian 16- or 32-bit samples of raw PCM. +fn pcm_values(raw: &[u8], bytes: usize) -> Vec { + if bytes == 2 { + raw.as_chunks::<2>().0.iter().map(|b| i32::from(i16::from_le_bytes(*b))).collect() + } else { + raw.as_chunks::<4>().0.iter().map(|b| i32::from_le_bytes(*b)).collect() + } +} + +/// Planar channels as interleaved samples. +fn interleave(channels: &[Vec]) -> Vec { + let frames = channels.first().map_or(0, Vec::len); + (0..frames).flat_map(|i| channels.iter().map(move |c| c[i])).collect() +} + fn ffmpeg_run(ff: &std::path::Path, args: &[&str]) -> Vec { let out = Command::new(ff).args(["-v", "error", "-nostdin", "-y"]).args(args).output().expect("run ffmpeg"); assert!(out.status.success(), "ffmpeg {args:?}: {}", String::from_utf8_lossy(&out.stderr)); @@ -130,22 +145,10 @@ fn ffmpeg_files_decode_to_ffmpegs_samples() { assert_eq!(got.info.channels as usize, channels); let frames = got.channels[0].len(); assert_eq!(theirs.len(), frames * channels * bytes, "{name} {channels}ch {bits} l{level}: length"); - let mut ok = true; - for i in 0..frames { - for c in 0..channels { - let at = (i * channels + c) * bytes; - let want = if bytes == 2 { - i32::from(i16::from_le_bytes([theirs[at], theirs[at + 1]])) - } else { - i32::from_le_bytes([theirs[at], theirs[at + 1], theirs[at + 2], theirs[at + 3]]) - }; - // ffmpeg returns 24-bit audio left-aligned in 32 bits. - let mine = if bits == 24 { got.channels[c][i] << 8 } else { got.channels[c][i] }; - if mine != want { - ok = false; - } - } - } + // ffmpeg returns 24-bit audio left-aligned in 32 bits. + let shift = if bits == 24 { 8 } else { 0 }; + let mine: Vec = interleave(&got.channels).into_iter().map(|v| v << shift).collect(); + let ok = mine == pcm_values(&theirs, bytes); assert!(ok, "{name} {channels}ch {bits}-bit level {level}: samples differ from ffmpeg's decode"); } } @@ -164,16 +167,8 @@ fn ffmpeg_decodes_our_files_to_our_samples() { let theirs = ffmpeg_run(&ff, &["-i", file.to_str().expect("path"), "-f", if bits == 16 { "s16le" } else { "s32le" }, "-"]); let got = decode(&std::fs::read(&file).expect("read")).expect("decode"); let bytes = if bits == 16 { 2 } else { 4 }; - for i in 0..20_000 { - for c in 0..channels { - let at = (i * channels + c) * bytes; - let want = if bytes == 2 { - i32::from(i16::from_le_bytes([theirs[at], theirs[at + 1]])) - } else { - i32::from_le_bytes([theirs[at], theirs[at + 1], theirs[at + 2], theirs[at + 3]]) >> 8 - }; - assert_eq!(got.channels[c][i], want, "{channels}ch {bits}-bit sample {i} of channel {c}"); - } - } + let shift = if bytes == 4 { 8 } else { 0 }; + let want: Vec = pcm_values(&theirs, bytes).into_iter().map(|v| v >> shift).collect(); + assert!(interleave(&got.channels) == want, "{channels}ch {bits}-bit: samples differ from ffmpeg's decode"); } } From 8322a1166c48967d557f549b37d827a07f359bcb Mon Sep 17 00:00:00 2001 From: Scott Macdonald Date: Sun, 15 Nov 2026 09:28:27 -0500 Subject: [PATCH 079/382] Port bounded Displace payload reader from PhotoCraft --- crates/psd/src/displace_map.rs | 37 ++++++++++++++++++++++++++++++++++ crates/psd/src/lib.rs | 1 + 2 files changed, 38 insertions(+) create mode 100644 crates/psd/src/displace_map.rs diff --git a/crates/psd/src/displace_map.rs b/crates/psd/src/displace_map.rs new file mode 100644 index 000000000..ce5193516 --- /dev/null +++ b/crates/psd/src/displace_map.rs @@ -0,0 +1,37 @@ +//! Bounded two-plane PSD Displace (`DspD`) payloads. +//! App filter settings, image conversion and external-path policy belong to the caller. +//! Ported from PhotoCraft `crates/io/src/displace_map.rs` (MIT/Apache-2.0). + +const HEADER: usize = 10; +const MODE_TWO_PLANES: u16 = 3; +/// Maximum supported decoded pixel count (8K by 8K). +pub const MAX_MAP_PIXELS: usize = 1 << 26; + +/// A parsed embedded map: size and the two 8-bit planes (borrowed from the blob). +#[derive(Debug, PartialEq)] +pub struct EmbeddedMap<'a> { + /// Width in pixels. + pub width: usize, + /// Height in pixels. + pub height: usize, + /// Horizontal displacement samples. + pub horizontal: &'a [u8], + /// Vertical displacement samples. + pub vertical: &'a [u8], +} + +/// Parses an embedded displacement map; `None` for any other mode, a zero or oversized map, or a +/// blob shorter than the header plus both planes. +pub fn parse_map(data: &[u8]) -> Option> { + let u32_at = |i: usize| Some(u32::from_le_bytes(data.get(i..i + 4)?.try_into().ok()?)); + let height = usize::try_from(u32_at(0)?).ok()?; + let width = usize::try_from(u32_at(4)?).ok()?; + let mode = u16::from_le_bytes(data.get(8..HEADER)?.try_into().ok()?); + let n = width.checked_mul(height)?; + if mode != MODE_TWO_PLANES || n == 0 || n > MAX_MAP_PIXELS { + return None; + } + let horizontal = data.get(HEADER..HEADER.checked_add(n)?)?; + let vertical = data.get(HEADER + n..HEADER.checked_add(n.checked_mul(2)?)?)?; + Some(EmbeddedMap { width, height, horizontal, vertical }) +} diff --git a/crates/psd/src/lib.rs b/crates/psd/src/lib.rs index 8126437ff..acd3c8853 100644 --- a/crates/psd/src/lib.rs +++ b/crates/psd/src/lib.rs @@ -64,6 +64,7 @@ mod codepage; pub mod compression; pub mod csh; pub mod descriptor; +pub mod displace_map; pub mod engine_data; pub mod error; pub mod file; From 46cd009367b90ee4cd476cb70ffd28b1277b4df3 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:29:01 -0500 Subject: [PATCH 080/382] Add exact-plane payload writer and hostile-input regression tests --- crates/psd/src/displace_map.rs | 56 ++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/crates/psd/src/displace_map.rs b/crates/psd/src/displace_map.rs index ce5193516..8b40eab3f 100644 --- a/crates/psd/src/displace_map.rs +++ b/crates/psd/src/displace_map.rs @@ -35,3 +35,59 @@ pub fn parse_map(data: &[u8]) -> Option> { let vertical = data.get(HEADER + n..HEADER.checked_add(n.checked_mul(2)?)?)?; Some(EmbeddedMap { width, height, horizontal, vertical }) } + +/// Writes a mode-3 payload from exact-sized 8-bit planes, without padding. +/// Returns `None` for empty/oversized dimensions, mismatched planes or allocation failure. +/// Callers retain their own (possibly lower) embedding and image-conversion budgets. +pub fn write_map(width: usize, height: usize, horizontal: &[u8], vertical: &[u8]) -> Option> { + let n = width.checked_mul(height)?; + if n == 0 || n > MAX_MAP_PIXELS || horizontal.len() != n || vertical.len() != n { + return None; + } + let width = u32::try_from(width).ok()?; + let height = u32::try_from(height).ok()?; + let len = HEADER.checked_add(n.checked_mul(2)?)?; + let mut out = Vec::new(); + out.try_reserve_exact(len).ok()?; + out.extend_from_slice(&height.to_le_bytes()); + out.extend_from_slice(&width.to_le_bytes()); + out.extend_from_slice(&MODE_TWO_PLANES.to_le_bytes()); + out.extend_from_slice(horizontal); + out.extend_from_slice(vertical); + Some(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn exact_planes_roundtrip_and_padding_is_ignored() { + let mut bytes = write_map(2, 1, &[0, 255], &[128, 64]).unwrap(); + assert_eq!(bytes, [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 255, 128, 64]); + bytes.extend_from_slice(&[99, 88]); + let m = parse_map(&bytes).unwrap(); + assert_eq!((m.width, m.height), (2, 1)); + assert_eq!(m.horizontal, &[0, 255]); + assert_eq!(m.vertical, &[128, 64]); + } + + #[test] + fn truncated_unsupported_and_overflow_are_rejected() { + let bytes = write_map(2, 1, &[0, 255], &[128, 64]).unwrap(); + for end in 0..bytes.len() { + assert!(parse_map(&bytes[..end]).is_none()); + } + let mut invalid = bytes.clone(); + invalid[8] = 4; + assert!(parse_map(&invalid).is_none()); + invalid[..8].fill(255); + assert!(parse_map(&invalid).is_none()); + invalid[..8].fill(0); + assert!(parse_map(&invalid).is_none()); + assert!(write_map(usize::MAX, 2, &[], &[]).is_none()); + assert!(write_map(MAX_MAP_PIXELS + 1, 1, &[], &[]).is_none()); + assert!(write_map(2, 1, &[0], &[0, 0]).is_none()); + assert!(write_map(2, 1, &[0, 0], &[0, 0, 0]).is_none()); + } +} From b850981f835f39859077cf62ff4e76462e76167c Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Sun, 15 Nov 2026 15:29:08 +0100 Subject: [PATCH 081/382] craft-audio: port EffectCraft's later Opus encoder speed-ups The shared encoder was imported from storytold/effectcraft@c618429. EffectCraft's copy has since gained @vangel76's speed-ups (effectcraft #2394, #2398, #2399, #2402, #2403, #2404) and the strict-Clippy CELT stage refactor. Port them so EffectCraft can drop crates/opusenc without slowing WebM export. Packets are byte-identical to effectcraft-opusenc at d6c9ad66 (2100 packets across SILK, hybrid and CELT, mono and stereo, 10-320 kb/s). The shared Error API is unchanged. Refs #778 --- crates/audio/src/opus/encoder/bands.rs | 341 +++++++++++++++--- crates/audio/src/opus/encoder/energy.rs | 25 +- crates/audio/src/opus/encoder/mdct.rs | 95 ++++- crates/audio/src/opus/encoder/mod.rs | 67 ++-- crates/audio/src/opus/encoder/rate.rs | 88 ++--- crates/audio/src/opus/encoder/resample.rs | 31 +- .../audio/src/opus/encoder/silk/analysis.rs | 112 +++++- crates/audio/src/opus/encoder/silk/mod.rs | 168 ++++++++- 8 files changed, 748 insertions(+), 179 deletions(-) diff --git a/crates/audio/src/opus/encoder/bands.rs b/crates/audio/src/opus/encoder/bands.rs index 604aab595..697332eb2 100644 --- a/crates/audio/src/opus/encoder/bands.rs +++ b/crates/audio/src/opus/encoder/bands.rs @@ -8,7 +8,8 @@ use crate::opus::encoder::range::{BITRES, RangeEncoder, ilog}; use crate::opus::encoder::rate::{Mode, QTHETA_OFFSET, get_pulses}; -use crate::opus::encoder::tables::{EBANDS, NB_EBANDS}; +use crate::opus::encoder::tables::EBANDS; +use crate::opus::encoder::{CeltFrame, rate::Allocation}; pub const SPREAD_NORMAL: usize = 2; @@ -55,7 +56,7 @@ fn exp_rotation1_inv(x: &mut [f32], len: usize, stride: usize, c: f32, s: f32) { if len <= stride { return; } - if len >= 2 * stride + 1 { + if len > 2 * stride { for i in 0..=len - 2 * stride - 1 { let x1 = x[i]; let x2 = x[i + stride]; @@ -96,12 +97,24 @@ pub fn exp_rotation_inv(x: &mut [f32], len: usize, k: usize, spread: usize) { } } +/// Relative slack for the pulse-candidate filter in [`pvq_search`]: far above the f32 rounding of +/// the filter score (a few 1e-7), far below the spread of real scores. +const PVQ_SCORE_SLACK: f32 = 1e-5; + /// Greedy PVQ search: the integer vector `y` with `sum |y| = k` closest in direction to `x`. pub fn pvq_search(x: &[f32], k: usize, y: &mut [i32]) { let n = x.len(); y[..n].fill(0); - let abs: Vec = x.iter().map(|v| v.abs()).collect(); - let sum: f32 = abs.iter().sum(); + // `abs`, `dy` (2 y + 1, infinite in the padding) and the per-pass scores `score`, each padded to + // whole 8-lane chunks. + let np = n.next_multiple_of(8); + let mut buf = vec![0f32; 3 * np]; + let (abs, rest) = buf.split_at_mut(np); + let (dy, score) = rest.split_at_mut(np); + for (a, v) in abs.iter_mut().zip(x) { + *a = v.abs(); + } + let sum: f32 = abs[..n].iter().sum(); if !sum.is_finite() || sum <= 1e-15 { y[0] = k as i32; return; @@ -113,30 +126,69 @@ pub fn pvq_search(x: &[f32], k: usize, y: &mut [i32]) { // Pre-project onto the pyramid (rounding down) and place the rest greedily. let r = (k as f32 - 1.0) / sum; for j in 0..n { - let p = (abs[j] * r).floor() as i32; + // Non-negative and at most k, so the truncating cast is the floor. + let p = (abs[j] * r) as i32; y[j] = p; placed += p as usize; xy += abs[j] * p as f32; yy += (p * p) as f32; } } + for j in 0..np { + dy[j] = if j < n { 2.0 * y[j] as f32 + 1.0 } else { f32::INFINITY }; + } while placed < k { + // Vectorisable scores (xy + |x_j|)^2 / (yy + 2 y_j + 1) and their maximum. + for ((sc, &a), &d) in score.iter_mut().zip(abs.iter()).zip(dy.iter()) { + let t = xy + a; + *sc = t * t / (yy + d); + } + let mut lane_max = [0f32; 8]; + for c in score.as_chunks::<8>().0 { + for i in 0..8 { + lane_max[i] = if c[i] > lane_max[i] { c[i] } else { lane_max[i] }; + } + } + let top = lane_max.iter().fold(0f32, |m, &v| if v > m { v } else { m }); + // The exact cross-multiplied test below, in index order with the first maximum winning, only + // matters for entries within rounding distance of the top score: every other entry is beaten + // by the top one whenever it is reached and never beats it afterwards. Running the test on + // those alone therefore picks the same pulse as running it on all of them. + let filter = top > 1e-30 && top.is_finite(); + let lo = top * (1.0 - PVQ_SCORE_SLACK); + // Usually exactly one entry qualifies; its index falls out of a lane-wise count. + let mut count = [0u32; 8]; + let mut index = [0u32; 8]; + for (ci, c) in score.as_chunks::<8>().0.iter().enumerate() { + for i in 0..8 { + let hit = u32::from(c[i] >= lo); + count[i] += hit; + index[i] += hit * (ci * 8 + i) as u32; + } + } let mut best = 0usize; - let mut best_num = -1f32; - let mut best_den = 1f32; - for j in 0..n { - let num = xy + abs[j]; - let num = num * num; - let den = yy + 2.0 * y[j] as f32 + 1.0; - if num * best_den > best_num * den { - best_num = num; - best_den = den; - best = j; + if filter && count.iter().sum::() == 1 { + best = index.iter().sum::() as usize; + } else { + let mut best_num = -1f32; + let mut best_den = 1f32; + for j in 0..n { + if !filter || score[j] >= lo { + let num = xy + abs[j]; + let num = num * num; + let den = yy + 2.0 * y[j] as f32 + 1.0; + if num * best_den > best_num * den { + best_num = num; + best_den = den; + best = j; + } + } } } xy += abs[best]; yy += 2.0 * y[best] as f32 + 1.0; y[best] += 1; + dy[best] = 2.0 * y[best] as f32 + 1.0; placed += 1; } for j in 0..n { @@ -146,25 +198,45 @@ pub fn pvq_search(x: &[f32], k: usize, y: &mut [i32]) { } } -/// Encodes the PVQ codeword `y` (`sum |y| = k`) as the index the RFC 6716 §4.3.4.2 decoder maps -/// back to `y`. -pub fn encode_pulses(y: &[i32], k: usize, enc: &mut RangeEncoder, v: &mut Vec) { - let n = y.len(); - let w = k + 1; - v.clear(); - v.resize((n + 1) * w, 0); +/// Largest band width and pulse count the encoder codes (176 coefficients, `get_pulses(40)` = 128). +const PVQ_MAX_N: usize = 176; +const PVQ_MAX_K: usize = 128; + +/// Row-major `V(n, k)` for `n <= max_n`, `k <= max_k` with row stride `max_k + 1`, saturated at +/// `u32::MAX` (a codebook that large is never coded, see `rate::fits_in32`). +fn build_pvq_table(max_n: usize, max_k: usize) -> Vec { + let w = max_k + 1; + let mut v = vec![0u32; (max_n + 1) * w]; v[0] = 1; - for nn in 1..=n { + for nn in 1..=max_n { v[nn * w] = 1; - for kk in 1..=k { - let a = v[(nn - 1) * w + kk]; - let b = v[nn * w + kk - 1]; - let c = v[(nn - 1) * w + kk - 1]; - v[nn * w + kk] = a.saturating_add(b).saturating_add(c); + for kk in 1..=max_k { + let sum = v[(nn - 1) * w + kk] as u64 + v[nn * w + kk - 1] as u64 + v[(nn - 1) * w + kk - 1] as u64; + v[nn * w + kk] = sum.min(u32::MAX as u64) as u32; } } - let total = v[n * w + k]; - let vv = |nn: usize, kx: usize| v[nn * w + kx]; + v +} + +fn pvq_table() -> &'static [u32] { + static TABLE: std::sync::OnceLock> = std::sync::OnceLock::new(); + TABLE.get_or_init(|| build_pvq_table(PVQ_MAX_N, PVQ_MAX_K)) +} + +/// Encodes the PVQ codeword `y` (`sum |y| = k`) as the index the RFC 6716 §4.3.4.2 decoder maps +/// back to `y`. +pub fn encode_pulses(y: &[i32], k: usize, enc: &mut RangeEncoder) { + let n = y.len(); + // Shapes outside the coded range (never produced by the band layout) get a local table. + let local; + let (v, w) = if n <= PVQ_MAX_N && k <= PVQ_MAX_K { + (pvq_table(), PVQ_MAX_K + 1) + } else { + local = build_pvq_table(n, k); + (&local[..], k + 1) + }; + let row = |nn: usize| &v[nn * w..(nn + 1) * w]; + let total = row(n)[k] as u64; let mut index = 0u64; let mut kk = k; for j in 0..n { @@ -173,10 +245,11 @@ pub fn encode_pulses(y: &[i32], k: usize, enc: &mut RangeEncoder, v: &mut Vec { pub i: usize, pub spread: usize, pub remaining_bits: i32, - pvq_v: Vec, iy: Vec, tmp: Vec, } @@ -217,7 +289,7 @@ impl BandEnc<'_, '_> { let q = qn as u32; let half = q >> 1; let ft = (half + 1) * (half + 1); - let (fl, fs) = if it <= half { (it * (it + 1) >> 1, it + 1) } else { (ft - ((q + 1 - it) * (q + 2 - it) >> 1), q + 1 - it) }; + let (fl, fs) = if it <= half { ((it * (it + 1)) >> 1, it + 1) } else { (ft - (((q + 1 - it) * (q + 2 - it)) >> 1), q + 1 - it) }; self.enc.encode(fl, fl + fs, ft); itheta = ((it * 16384) / q) as i32; } @@ -287,36 +359,29 @@ impl BandEnc<'_, '_> { iy.clear(); iy.resize(n, 0); pvq_search(&tmp, k, &mut iy); - encode_pulses(&iy, k, self.enc, &mut self.pvq_v); + encode_pulses(&iy, k, self.enc); self.iy = iy; self.tmp = tmp; } } } -/// Codes all band shapes (`quant_all_bands`, encoder side, long blocks). `x` holds `c` channels -/// of `n` normalised MDCT coefficients each. -#[allow(clippy::too_many_arguments)] -pub fn quant_all_bands( - m: &Mode, - start: usize, - end: usize, - x: &[f32], - n_total: usize, - c: usize, - pulses: &[i32; NB_EBANDS], - spread: usize, - dual_stereo: bool, - intensity: usize, - total_bits: i32, - mut balance: i32, - enc: &mut RangeEncoder, - lm: usize, - coded_bands: usize, -) { +/// Shape-coding controls, independent of the selected band allocation. +pub struct BandCoding { + pub spread: usize, + pub total_bits: i32, +} + +/// Codes all band shapes (`quant_all_bands`, encoder side, long blocks). `x` holds +/// `frame.channels` channels of `n_total` normalised MDCT coefficients each. +pub fn quant_all_bands(m: &Mode, frame: CeltFrame, x: &[f32], n_total: usize, allocation: &Allocation, coding: BandCoding, enc: &mut RangeEncoder) { + let CeltFrame { start, end, channels: c, lm } = frame; + let Allocation { pulses, dual_stereo, intensity, coded_bands, balance, .. } = allocation; + let (dual_stereo, intensity, coded_bands, mut balance) = (*dual_stereo, *intensity, *coded_bands, *balance); + let BandCoding { spread, total_bits } = coding; let mm = 1usize << lm; debug_assert!(c == 1 || dual_stereo || intensity <= start, "stereo frames are coded as dual stereo"); - let mut ctx = BandEnc { m, enc, i: 0, spread, remaining_bits: 0, pvq_v: Vec::new(), iy: Vec::new(), tmp: Vec::new() }; + let mut ctx = BandEnc { m, enc, i: 0, spread, remaining_bits: 0, iy: Vec::new(), tmp: Vec::new() }; for i in start..end { ctx.i = i; let xo = mm * EBANDS[i] as usize; @@ -362,7 +427,7 @@ mod tests { x[i + stride] = c * x2 + s * x1; x[i] = c * x1 + ms * x2; } - if len >= 2 * stride + 1 { + if len > 2 * stride { for i in (0..=len - 2 * stride - 1).rev() { let x1 = x[i]; let x2 = x[i + stride]; @@ -466,12 +531,11 @@ mod tests { #[test] fn pvq_index_roundtrip_exhaustive() { - let mut v = Vec::new(); for n in 1..6usize { for k in 1..6usize { for y in all_codewords(n, k) { let mut e = RangeEncoder::new(); - encode_pulses(&y, k, &mut e, &mut v); + encode_pulses(&y, k, &mut e); let buf = e.done(16); let mut d = RangeDecoder::new(&buf); assert_eq!(decode_pulses(n, k, &mut d), y, "n={n} k={k}"); @@ -480,6 +544,165 @@ mod tests { } } + /// The per-call table encoder this module used before the shared table. + fn encode_pulses_reference(y: &[i32], k: usize, enc: &mut RangeEncoder) { + let n = y.len(); + let w = k + 1; + let mut v = vec![0u64; (n + 1) * w]; + v[0] = 1; + for nn in 1..=n { + v[nn * w] = 1; + for kk in 1..=k { + let a = v[(nn - 1) * w + kk]; + let b = v[nn * w + kk - 1]; + let c = v[(nn - 1) * w + kk - 1]; + v[nn * w + kk] = a.saturating_add(b).saturating_add(c); + } + } + let total = v[n * w + k]; + let vv = |nn: usize, kx: usize| v[nn * w + kx]; + let mut index = 0u64; + let mut kk = k; + for j in 0..n { + if kk == 0 { + break; + } + let rem = n - j; + let t = y[j].unsigned_abs() as usize; + let mut base: u64 = (0..kk - t).map(|m| vv(rem - 1, m)).sum(); + if y[j] < 0 { + base += (vv(rem - 1, kk) + vv(rem, kk)) / 2; + } + index += base; + kk -= t; + } + if total >= 2 { + enc.uint(index as u32, total as u32); + } + } + + #[test] + fn pvq_table_encode_matches_per_call_table() { + let mut seed = 0x9E37_79B9_7F4A_7C15u64; + let mut next = move |m: u64| { + seed ^= seed << 13; + seed ^= seed >> 7; + seed ^= seed << 17; + seed % m + }; + let mut checked = 0; + for n in (1..=PVQ_MAX_N).step_by(5).chain([PVQ_MAX_N]) { + for k in (1..=PVQ_MAX_K).step_by(3).chain([PVQ_MAX_K]) { + if crate::opus::encoder::rate::pvq_v(n, k) > u32::MAX as u128 { + continue; + } + for _ in 0..4 { + let mut y = vec![0i32; n]; + for _ in 0..k { + let at = next(n as u64) as usize; + y[at] += if next(2) == 0 { 1 } else { -1 }; + } + // Opposite pulses cancel; top up so that sum |y| = k again. + let mut have: usize = y.iter().map(|v| v.unsigned_abs() as usize).sum(); + while have < k { + let at = next(n as u64) as usize; + y[at] += if y[at] < 0 { -1 } else { 1 }; + have += 1; + } + let (mut a, mut b) = (RangeEncoder::new(), RangeEncoder::new()); + encode_pulses(&y, k, &mut a); + encode_pulses_reference(&y, k, &mut b); + assert_eq!(a.done(16), b.done(16), "n={n} k={k}"); + checked += 1; + } + } + } + assert!(checked > 100, "{checked}"); + } + + /// The scalar greedy search the vectorised one replaced. + fn pvq_search_ref(x: &[f32], k: usize, y: &mut [i32]) { + let n = x.len(); + y[..n].fill(0); + let abs: Vec = x.iter().map(|v| v.abs()).collect(); + let sum: f32 = abs.iter().sum(); + if !sum.is_finite() || sum <= 1e-15 { + y[0] = k as i32; + return; + } + let mut placed = 0usize; + let mut xy = 0f32; + let mut yy = 0f32; + if k > n / 2 { + let r = (k as f32 - 1.0) / sum; + for j in 0..n { + let p = (abs[j] * r).floor() as i32; + y[j] = p; + placed += p as usize; + xy += abs[j] * p as f32; + yy += (p * p) as f32; + } + } + while placed < k { + let mut best = 0usize; + let mut best_num = -1f32; + let mut best_den = 1f32; + for j in 0..n { + let num = xy + abs[j]; + let num = num * num; + let den = yy + 2.0 * y[j] as f32 + 1.0; + if num * best_den > best_num * den { + best_num = num; + best_den = den; + best = j; + } + } + xy += abs[best]; + yy += 2.0 * y[best] as f32 + 1.0; + y[best] += 1; + placed += 1; + } + for j in 0..n { + if x[j] < 0.0 { + y[j] = -y[j]; + } + } + } + + #[test] + fn pvq_search_matches_scalar_reference() { + let mut state = 0x9e3779b97f4a7c15u64; + let mut rnd = move || { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + (state >> 40) as f32 / (1u64 << 24) as f32 * 2.0 - 1.0 + }; + let mut a = vec![0i32; 200]; + let mut b = vec![0i32; 200]; + let mut cases = 0; + for round in 0..6000 { + let n = 1 + (round * 37 + (rnd().abs() * 176.0) as usize) % 176; + let k = 1 + (rnd().abs() * 127.0) as usize; + let scale = [1.0f32, 1e-9, 1e6, 3e-3][round % 4]; + let x: Vec = (0..n) + .map(|_| match round % 6 { + 0 => rnd(), + 1 => if rnd() > 0.8 { rnd() } else { 0.0 }, + 2 => (rnd() * 4.0).round() / 4.0, + 3 => if rnd() > 0.0 { 1.0 } else { -1.0 }, + 4 => rnd().powi(5), + _ => if rnd() > 0.95 { 3.0 * rnd() } else { 1e-4 * rnd() }, + } * scale) + .collect(); + pvq_search(&x, k, &mut a); + pvq_search_ref(&x, k, &mut b); + assert_eq!(a[..n], b[..n], "n={n} k={k} round={round}"); + cases += 1; + } + assert_eq!(cases, 6000); + } + #[test] fn pvq_search_finds_good_direction() { let x: Vec = (0..32).map(|i| ((i as f32) * 0.7).sin()).collect(); diff --git a/crates/audio/src/opus/encoder/energy.rs b/crates/audio/src/opus/encoder/energy.rs index 8d4f357d0..fb5cc5a4b 100644 --- a/crates/audio/src/opus/encoder/energy.rs +++ b/crates/audio/src/opus/encoder/energy.rs @@ -4,8 +4,9 @@ //! The quantised energies are updated with exactly the decoder's arithmetic so the prediction //! state never drifts between encoder and decoder. +use crate::opus::encoder::CeltFrame; use crate::opus::encoder::range::RangeEncoder; -use crate::opus::encoder::rate::MAX_FINE_BITS; +use crate::opus::encoder::rate::{Allocation, MAX_FINE_BITS}; use crate::opus::encoder::tables::{BETA_COEF, BETA_INTRA, E_PROB_MODEL, NB_EBANDS, PRED_COEF, SMALL_ENERGY_ICDF}; const LAPLACE_MINP: u32 = 1; @@ -56,18 +57,15 @@ pub fn laplace_encode(enc: &mut RangeEncoder, value: i32, mut fs: u32, decay: u3 /// `quant_coarse_energy` for one prediction mode. `e` holds the target log2 energies (relative /// to `E_MEANS`), `old_e` the quantised energies, updated in place. `budget` is the frame size in /// bits. -#[allow(clippy::too_many_arguments)] pub fn quant_coarse_energy( - start: usize, - end: usize, + frame: CeltFrame, e: &[f32; 2 * NB_EBANDS], old_e: &mut [f32; 2 * NB_EBANDS], intra: bool, enc: &mut RangeEncoder, - c: usize, - lm: usize, budget: i32, ) { + let CeltFrame { start, end, channels: c, lm } = frame; let prob = &E_PROB_MODEL[lm][intra as usize]; let (coef, beta) = if intra { (0.0, BETA_INTRA) } else { (PRED_COEF[lm], BETA_COEF[lm]) }; let mut prev = [0f32; 2]; @@ -112,14 +110,13 @@ pub fn quant_coarse_energy( /// `quant_fine_energy`: raw bits refining each band's quantised energy. pub fn quant_fine_energy( - start: usize, - end: usize, + frame: CeltFrame, e: &[f32; 2 * NB_EBANDS], old_e: &mut [f32; 2 * NB_EBANDS], fine_quant: &[i32; NB_EBANDS], enc: &mut RangeEncoder, - c: usize, ) { + let CeltFrame { start, end, channels: c, .. } = frame; for i in start..end { let fq = fine_quant[i]; if fq <= 0 { @@ -139,18 +136,16 @@ pub fn quant_fine_energy( /// `quant_energy_finalise`: spends the bits left at the end of the frame on one more bit of /// energy resolution per band, in priority order. -#[allow(clippy::too_many_arguments)] pub fn quant_energy_finalise( - start: usize, - end: usize, + frame: CeltFrame, e: &[f32; 2 * NB_EBANDS], old_e: &mut [f32; 2 * NB_EBANDS], - fine_quant: &[i32; NB_EBANDS], - fine_priority: &[i32; NB_EBANDS], + allocation: &Allocation, mut bits_left: i32, enc: &mut RangeEncoder, - c: usize, ) { + let CeltFrame { start, end, channels: c, .. } = frame; + let Allocation { fine_quant, fine_priority, .. } = allocation; for prio in 0..2 { let mut i = start; while i < end && bits_left >= c as i32 { diff --git a/crates/audio/src/opus/encoder/mdct.rs b/crates/audio/src/opus/encoder/mdct.rs index 6a42cce96..fa5624514 100644 --- a/crates/audio/src/opus/encoder/mdct.rs +++ b/crates/audio/src/opus/encoder/mdct.rs @@ -24,6 +24,10 @@ impl Cpx { fn add(self, o: Cpx) -> Cpx { Cpx { re: self.re + o.re, im: self.im + o.im } } + #[inline] + fn sub(self, o: Cpx) -> Cpx { + Cpx { re: self.re - o.re, im: self.im - o.im } + } } /// Mixed-radix (2, 3, 4, 5) forward complex FFT, unscaled (decimation in time, recursive). @@ -71,18 +75,64 @@ impl Fft { self.rec(&mut out[q * m..(q + 1) * m], &inp[q * in_stride..], in_stride * p, m, fi + 1, tw_stride * p); } } - let big = self.n; - let mut t = [Cpx::default(); 5]; - for k in 0..m { - for (q, tq) in t.iter_mut().enumerate().take(p) { - *tq = out[q * m + k].mul(self.twiddle[(q * k * tw_stride) % big]); + // The twiddle index q * k * tw_stride is always below n, so no modulo is needed. + let tw = &self.twiddle; + match p { + 2 => { + for k in 0..m { + let a0 = out[k]; + let a1 = out[m + k].mul(tw[k * tw_stride]); + out[k] = a0.add(a1); + out[m + k] = a0.sub(a1); + } } - for q2 in 0..p { - let mut acc = Cpx::default(); - for (q, tq) in t.iter().enumerate().take(p) { - acc = acc.add(tq.mul(self.twiddle[((q * q2) % p) * (big / p)])); + 4 => { + for k in 0..m { + let t0 = out[k]; + let t1 = out[m + k].mul(tw[k * tw_stride]); + let t2 = out[2 * m + k].mul(tw[2 * k * tw_stride]); + let t3 = out[3 * m + k].mul(tw[3 * k * tw_stride]); + let (s0, d0) = (t0.add(t2), t0.sub(t2)); + let (s1, d1) = (t1.add(t3), t1.sub(t3)); + out[k] = s0.add(s1); + out[2 * m + k] = s0.sub(s1); + // The odd outputs combine d0 with -j * d1 = (d1.im, -d1.re) and its negative. + out[m + k] = Cpx { re: d0.re + d1.im, im: d0.im - d1.re }; + out[3 * m + k] = Cpx { re: d0.re - d1.im, im: d0.im + d1.re }; + } + } + 3 => { + // Imaginary part of exp(-2 pi i / 3) = -sqrt(3) / 2. + let h = tw[self.n / 3].im; + for k in 0..m { + let t0 = out[k]; + let t1 = out[m + k].mul(tw[k * tw_stride]); + let t2 = out[2 * m + k].mul(tw[2 * k * tw_stride]); + let (s, d) = (t1.add(t2), t1.sub(t2)); + let a = Cpx { re: t0.re - 0.5 * s.re, im: t0.im - 0.5 * s.im }; + out[k] = t0.add(s); + // j * h * d = (-h * d.im, h * d.re) + out[m + k] = Cpx { re: a.re - h * d.im, im: a.im + h * d.re }; + out[2 * m + k] = Cpx { re: a.re + h * d.im, im: a.im - h * d.re }; + } + } + _ => { + // Generic DFT butterfly (radix 5, once per transform). + let roots: [Cpx; 5] = std::array::from_fn(|q| if q < p { tw[q * (self.n / p)] } else { Cpx::default() }); + let mut t = [Cpx::default(); 5]; + for k in 0..m { + t[0] = out[k]; + for q in 1..p { + t[q] = out[q * m + k].mul(tw[q * k * tw_stride]); + } + for q2 in 0..p { + let mut acc = t[0]; + for q in 1..p { + acc = acc.add(t[q].mul(roots[(q * q2) % p])); + } + out[q2 * m + k] = acc; + } } - out[q2 * m + k] = acc; } } } @@ -199,6 +249,31 @@ mod tests { .collect() } + #[test] + fn fft_matches_dft() { + // Every radix combination, including the 480-point size of the 20 ms frame. + for &n in &[2usize, 3, 4, 5, 6, 8, 12, 15, 16, 20, 24, 30, 48, 60, 120, 240, 480] { + let fft = Fft::new(n); + let x: Vec = (0..n).map(|i| Cpx { re: ((i * 37 % 101) as f32 - 50.0) / 7.0, im: ((i * 53 % 89) as f32 - 44.0) / 9.0 }).collect(); + let mut y = x.clone(); + fft.process(&mut y, &mut Vec::new()); + for k in 0..n { + let (mut re, mut im) = (0f64, 0f64); + for (j, v) in x.iter().enumerate() { + let ph = -2.0 * std::f64::consts::PI * ((j * k) % n) as f64 / n as f64; + re += v.re as f64 * ph.cos() - v.im as f64 * ph.sin(); + im += v.re as f64 * ph.sin() + v.im as f64 * ph.cos(); + } + assert!( + (y[k].re as f64 - re).abs() < 2e-3 && (y[k].im as f64 - im).abs() < 2e-3, + "n={n} k={k}: ({}, {}) vs ({re}, {im})", + y[k].re, + y[k].im + ); + } + } + } + #[test] fn matches_direct_formula() { for &n in &[240usize, 960] { diff --git a/crates/audio/src/opus/encoder/mod.rs b/crates/audio/src/opus/encoder/mod.rs index cbb0d7984..a635cce40 100644 --- a/crates/audio/src/opus/encoder/mod.rs +++ b/crates/audio/src/opus/encoder/mod.rs @@ -10,8 +10,9 @@ //! above in the same range-coded frame; constant packet size. //! - **CELT** (fullband): MDCT transform coding; constant packet size. //! -//! From EffectCraft's `effectcraft-opusenc` (storytold/effectcraft@c618429). Public items keep their -//! names, so EffectCraft can re-export this module. +//! From EffectCraft's `effectcraft-opusenc` (storytold/effectcraft@c618429), with its later speed-ups +//! and CELT stage refactor up to storytold/effectcraft@d6c9ad66. Public items keep their names, so +//! EffectCraft can re-export this module. //! //! ``` //! # #[cfg(feature = "opus-encode")] { @@ -26,6 +27,7 @@ //! # } //! ``` +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] // The bit-allocation code mirrors the normative integer arithmetic; keep C-like shift expressions. #![allow(clippy::precedence, clippy::int_plus_one)] @@ -40,15 +42,24 @@ mod tables; use std::sync::OnceLock; -use bands::{SPREAD_NORMAL, quant_all_bands}; +use bands::{BandCoding, SPREAD_NORMAL, quant_all_bands}; use energy::{quant_coarse_energy, quant_energy_finalise, quant_fine_energy}; use mdct::Mdct; use range::{BITRES, RangeEncoder}; -use rate::{Mode as CeltMode, compute_allocation}; +use rate::{AllocationInput, Mode as CeltMode, compute_allocation}; use resample::Downsampler; use silk::SilkEncoder; use tables::{E_MEANS, EBANDS, NB_EBANDS, OVERLAP, PREEMPH, SPREAD_ICDF, TF_SELECT_TABLE, TRIM_ICDF}; +/// Band range, channel count and transform size shared by CELT coding stages. +#[derive(Clone, Copy)] +struct CeltFrame { + start: usize, + end: usize, + channels: usize, + lm: usize, +} + /// Samples per channel in one 20 ms frame at 48 kHz. const N: usize = 960; /// LM of a 20 ms frame (8 short blocks). @@ -338,7 +349,7 @@ impl Encoder { Mode::Celt => { let (log_e, silence) = self.celt_analysis(pcm); let len = self.frame_bytes; - packet.extend_from_slice(&self.encode_celt(RangeEncoder::new(), len, 0, NB_EBANDS, &log_e, silence)); + packet.extend_from_slice(&self.encode_celt(RangeEncoder::new(), len, 0..NB_EBANDS, &log_e, silence)); } Mode::Silk => { let x = self.silk_input(pcm); @@ -368,7 +379,7 @@ impl Encoder { } let (log_e, _) = self.celt_analysis(pcm); let end = if self.bandwidth == Bandwidth::SuperWideband { 19 } else { NB_EBANDS }; - packet.extend_from_slice(&self.encode_celt(enc, len, HYBRID_START_BAND, end, &log_e, false)); + packet.extend_from_slice(&self.encode_celt(enc, len, HYBRID_START_BAND..end, &log_e, false)); } } Ok(packet) @@ -430,10 +441,18 @@ impl Encoder { /// Codes one CELT frame (RFC 6716 §4.3, in bitstream order) of `len` bytes into `enc` /// (which already holds the SILK frame in hybrid mode), coding bands `start..end`, and /// finalises the frame. - #[allow(clippy::too_many_arguments)] - fn encode_celt(&mut self, mut enc: RangeEncoder, len: usize, start: usize, end: usize, log_e: &[f32; 2 * NB_EBANDS], silence: bool) -> Vec { + fn encode_celt( + &mut self, + mut enc: RangeEncoder, + len: usize, + bands: std::ops::Range, + log_e: &[f32; 2 * NB_EBANDS], + silence: bool, + ) -> Vec { let m = celt_mode(); let c = self.channels; + let frame = CeltFrame { start: bands.start, end: bands.end, channels: c, lm: LM }; + let CeltFrame { start, end, .. } = frame; if c == 1 { for i in 0..NB_EBANDS { self.old_band_e[i] = self.old_band_e[i].max(self.old_band_e[NB_EBANDS + i]); @@ -462,10 +481,10 @@ impl Encoder { let mut enc_intra = enc.clone(); let mut old_intra = self.old_band_e; enc_intra.bit_logp(true, 3); - quant_coarse_energy(start, end, log_e, &mut old_intra, true, &mut enc_intra, c, LM, total_bits_raw); + quant_coarse_energy(frame, log_e, &mut old_intra, true, &mut enc_intra, total_bits_raw); enc.bit_logp(false, 3); let mut old_inter = self.old_band_e; - quant_coarse_energy(start, end, log_e, &mut old_inter, false, &mut enc, c, LM, total_bits_raw); + quant_coarse_energy(frame, log_e, &mut old_inter, false, &mut enc, total_bits_raw); if enc_intra.tell_frac() < enc.tell_frac() { enc = enc_intra; self.old_band_e = old_intra; @@ -473,14 +492,14 @@ impl Encoder { self.old_band_e = old_inter; } } else { - quant_coarse_energy(start, end, log_e, &mut self.old_band_e, false, &mut enc, c, LM, total_bits_raw); + quant_coarse_energy(frame, log_e, &mut self.old_band_e, false, &mut enc, total_bits_raw); } // TF resolution: no changes. { let mut budget = total_bits_raw; let mut tell = enc.tell(); let mut logp = 4; - let tf_select_rsv = LM > 0 && tell + logp + 1 <= budget; + let tf_select_rsv = LM > 0 && tell + logp < budget; budget -= tf_select_rsv as i32; for _ in start..end { if tell + logp <= budget { @@ -512,27 +531,11 @@ impl Encoder { enc.icdf(alloc_trim as usize, &TRIM_ICDF, 7); } let bits = (total_bits_raw << BITRES) - enc.tell_frac() - 1; - let alloc = compute_allocation(m, start, end, &offsets, &cap, alloc_trim, bits, c, LM, &mut enc); - quant_fine_energy(start, end, log_e, &mut self.old_band_e, &alloc.fine_quant, &mut enc, c); - quant_all_bands( - m, - start, - end, - &self.freq, - N, - c, - &alloc.pulses, - SPREAD_NORMAL, - alloc.dual_stereo, - alloc.intensity, - total_bits_raw << BITRES, - alloc.balance, - &mut enc, - LM, - alloc.coded_bands, - ); + let alloc = compute_allocation(m, frame, AllocationInput { offsets: &offsets, cap: &cap, trim: alloc_trim, bits }, &mut enc); + quant_fine_energy(frame, log_e, &mut self.old_band_e, &alloc.fine_quant, &mut enc); + quant_all_bands(m, frame, &self.freq, N, &alloc, BandCoding { spread: SPREAD_NORMAL, total_bits: total_bits_raw << BITRES }, &mut enc); let bits_left = total_bits_raw - enc.tell(); - quant_energy_finalise(start, end, log_e, &mut self.old_band_e, &alloc.fine_quant, &alloc.fine_priority, bits_left, &mut enc, c); + quant_energy_finalise(frame, log_e, &mut self.old_band_e, &alloc, bits_left, &mut enc); debug_assert!(enc.tell() <= total_bits_raw, "frame overflow: {} > {}", enc.tell(), total_bits_raw); if c == 1 { let (a, b) = self.old_band_e.split_at_mut(NB_EBANDS); diff --git a/crates/audio/src/opus/encoder/rate.rs b/crates/audio/src/opus/encoder/rate.rs index c360f9da7..58349bbd7 100644 --- a/crates/audio/src/opus/encoder/rate.rs +++ b/crates/audio/src/opus/encoder/rate.rs @@ -4,6 +4,7 @@ //! spec-derived `filmcraft-opus` decoder (first-party, MIT OR Apache-2.0) step by step; the only //! difference is that the encoder *writes* the band-skip, intensity and dual-stereo symbols. +use crate::opus::encoder::CeltFrame; use crate::opus::encoder::range::{BITRES, RangeEncoder, ilog}; use crate::opus::encoder::tables::{ALLOC, EBANDS, LOG2_FRAC_TABLE, MAX_LM, NB_EBANDS}; @@ -127,7 +128,7 @@ impl Mode { let mut cap = [0i32; NB_EBANDS]; for (i, cp) in cap.iter_mut().enumerate() { let n = (EBANDS[i + 1] - EBANDS[i]) << lm; - *cp = (self.caps[NB_EBANDS * (2 * lm + c - 1) + i] as i32 + 64) * c as i32 * n >> 2; + *cp = ((self.caps[NB_EBANDS * (2 * lm + c - 1) + i] as i32 + 64) * c as i32 * n) >> 2; } cap } @@ -200,7 +201,7 @@ fn compute_caps(m: &Mode) -> Vec { let mut n0 = EBANDS[j + 1] - EBANDS[j]; let max_bits = if n0 << i == 1 { - c * (1 + MAX_FINE_BITS) << BITRES + (c * (1 + MAX_FINE_BITS)) << BITRES } else { let mut lm0 = 0; if n0 > 2 { @@ -240,7 +241,7 @@ fn compute_caps(m: &Mode) -> Vec { let num = mb + ndof * offset; let den = (ndof - 1) << BITRES; let qb = ((num + (den >> 1)) / den).min(MAX_FINE_BITS); - mb += c * qb << BITRES; + mb += (c * qb) << BITRES; mb }; let w = c * ((EBANDS[j + 1] - EBANDS[j]) << i); @@ -263,21 +264,19 @@ pub struct Allocation { pub fine_priority: [i32; NB_EBANDS], } +/// Per-band limits, boosts and available budget for the allocation search. +pub struct AllocationInput<'a> { + pub offsets: &'a [i32; NB_EBANDS], + pub cap: &'a [i32; NB_EBANDS], + pub trim: i32, + pub bits: i32, +} + /// `clt_compute_allocation`, encoder side. Stereo frames are always coded as dual (L/R) stereo /// with no intensity bands, and no band is skipped voluntarily. -#[allow(clippy::too_many_arguments)] -pub fn compute_allocation( - m: &Mode, - start: usize, - end: usize, - offsets: &[i32; NB_EBANDS], - cap: &[i32; NB_EBANDS], - alloc_trim: i32, - total: i32, - c: usize, - lm: usize, - enc: &mut RangeEncoder, -) -> Allocation { +pub fn compute_allocation(m: &Mode, frame: CeltFrame, input: AllocationInput<'_>, enc: &mut RangeEncoder) -> Allocation { + let CeltFrame { start, end, channels: c, lm } = frame; + let AllocationInput { offsets, cap, trim: alloc_trim, bits: total } = input; let ci = c as i32; let lmi = lm as i32; let mut total = total.max(0); @@ -302,8 +301,8 @@ pub fn compute_allocation( let mut trim_offset = [0i32; NB_EBANDS]; for j in start..end { let w = EBANDS[j + 1] - EBANDS[j]; - thresh[j] = (ci << BITRES).max((3 * w << lmi << BITRES) >> 4); - trim_offset[j] = ci * w * (alloc_trim - 5 - lmi) * (end as i32 - j as i32 - 1) * (1 << (lmi + BITRES as i32)) >> 6; + thresh[j] = (ci << BITRES).max(((3 * w) << lmi << BITRES) >> 4); + trim_offset[j] = (ci * w * (alloc_trim - 5 - lmi) * (end as i32 - j as i32 - 1) * (1 << (lmi + BITRES as i32))) >> 6; if w << lmi == 1 { trim_offset[j] -= ci << BITRES; } @@ -317,7 +316,7 @@ pub fn compute_allocation( let mid = (lo + hi) >> 1; for j in (start..end).rev() { let n = EBANDS[j + 1] - EBANDS[j]; - let mut bitsj = ci * n * (ALLOC[mid as usize][j] as i32) << lmi >> 2; + let mut bitsj = (ci * n * (ALLOC[mid as usize][j] as i32)) << lmi >> 2; if bitsj > 0 { bitsj = (bitsj + trim_offset[j]).max(0); } @@ -342,8 +341,8 @@ pub fn compute_allocation( lo -= 1; for j in start..end { let n = EBANDS[j + 1] - EBANDS[j]; - let mut bits1j = ci * n * (ALLOC[lo as usize][j] as i32) << lmi >> 2; - let mut bits2j = if hi >= nb_alloc { cap[j] } else { ci * n * (ALLOC[hi as usize][j] as i32) << lmi >> 2 }; + let mut bits1j = (ci * n * (ALLOC[lo as usize][j] as i32)) << lmi >> 2; + let mut bits2j = if hi >= nb_alloc { cap[j] } else { (ci * n * (ALLOC[hi as usize][j] as i32)) << lmi >> 2 }; if bits1j > 0 { bits1j = (bits1j + trim_offset[j]).max(0); } @@ -361,27 +360,28 @@ pub fn compute_allocation( bits1[j] = bits1j; bits2[j] = bits2j; } - interp_bits2pulses(m, start, end, skip_start, &bits1, &bits2, &thresh, cap, total, skip_rsv, intensity_rsv, dual_stereo_rsv, c, lm, enc) + let interpolation = + AllocationInterpolation { skip_start, bits1: &bits1, bits2: &bits2, thresh: &thresh, cap, total, skip_rsv, intensity_rsv, dual_stereo_rsv }; + interp_bits2pulses(m, frame, interpolation, enc) } -#[allow(clippy::too_many_arguments)] -fn interp_bits2pulses( - m: &Mode, - start: usize, - end: usize, +/// Bracketing allocation vectors and signalling reserves for the interpolation stage. +struct AllocationInterpolation<'a> { skip_start: usize, - bits1: &[i32; NB_EBANDS], - bits2: &[i32; NB_EBANDS], - thresh: &[i32; NB_EBANDS], - cap: &[i32; NB_EBANDS], - mut total: i32, + bits1: &'a [i32; NB_EBANDS], + bits2: &'a [i32; NB_EBANDS], + thresh: &'a [i32; NB_EBANDS], + cap: &'a [i32; NB_EBANDS], + total: i32, skip_rsv: i32, - mut intensity_rsv: i32, - mut dual_stereo_rsv: i32, - c: usize, - lm: usize, - enc: &mut RangeEncoder, -) -> Allocation { + intensity_rsv: i32, + dual_stereo_rsv: i32, +} + +fn interp_bits2pulses(m: &Mode, frame: CeltFrame, interpolation: AllocationInterpolation<'_>, enc: &mut RangeEncoder) -> Allocation { + let CeltFrame { start, end, channels: c, lm } = frame; + let AllocationInterpolation { skip_start, bits1, bits2, thresh, cap, mut total, skip_rsv, mut intensity_rsv, mut dual_stereo_rsv } = + interpolation; let ci = c as i32; let alloc_floor = ci << BITRES; let stereo = (c > 1) as i32; @@ -393,7 +393,7 @@ fn interp_bits2pulses( let mut psum = 0; let mut done = false; for j in (start..end).rev() { - let tmp = bits1[j] + (mid * bits2[j] >> ALLOC_STEPS); + let tmp = bits1[j] + ((mid * bits2[j]) >> ALLOC_STEPS); if tmp >= thresh[j] || done { done = true; psum += tmp.min(cap[j]); @@ -411,7 +411,7 @@ fn interp_bits2pulses( let mut psum = 0; let mut done = false; for j in (start..end).rev() { - let mut tmp = bits1[j] + (lo * bits2[j] >> ALLOC_STEPS); + let mut tmp = bits1[j] + ((lo * bits2[j]) >> ALLOC_STEPS); if tmp < thresh[j] && !done { tmp = if tmp >= alloc_floor { alloc_floor } else { 0 }; } else { @@ -500,9 +500,9 @@ fn interp_bits2pulses( if n == 2 { offset += (den << BITRES) >> 2; } - if bits[j] + offset < den * 2 << BITRES { + if bits[j] + offset < (den * 2) << BITRES { offset += nclogn >> 2; - } else if bits[j] + offset < den * 3 << BITRES { + } else if bits[j] + offset < (den * 3) << BITRES { offset += nclogn >> 3; } let mut eb = (bits[j] + offset + (den << (BITRES - 1))).max(0); @@ -513,7 +513,7 @@ fn interp_bits2pulses( eb = eb.min(MAX_FINE_BITS); ebits[j] = eb; fine_priority[j] = (eb * (den << BITRES) >= bits[j] + offset) as i32; - bits[j] -= ci * eb << BITRES; + bits[j] -= (ci * eb) << BITRES; } else { excess = (bit - (ci << BITRES)).max(0); bits[j] = bit - excess; @@ -523,7 +523,7 @@ fn interp_bits2pulses( if excess > 0 { let extra_fine = (excess >> (stereo + BITRES as i32)).min(MAX_FINE_BITS - ebits[j]); ebits[j] += extra_fine; - let extra_bits = extra_fine * ci << BITRES; + let extra_bits = (extra_fine * ci) << BITRES; fine_priority[j] = (extra_bits >= excess - balance) as i32; excess -= extra_bits; } diff --git a/crates/audio/src/opus/encoder/resample.rs b/crates/audio/src/opus/encoder/resample.rs index 9045cb86d..1acc9a4e7 100644 --- a/crates/audio/src/opus/encoder/resample.rs +++ b/crates/audio/src/opus/encoder/resample.rs @@ -45,6 +45,25 @@ fn design(fc: f64, beta: f64, delay: usize) -> Vec { h.iter().map(|&v| v as f32).collect() } +/// Dot product with eight independent partial sums, which the compiler can vectorise (a single +/// running sum is bound by the latency of the float addition). The sums are combined pairwise. +#[inline] +fn dot8(a: &[f32], b: &[f32]) -> f32 { + let mut s = [0f32; 8]; + let (ca, ra) = a.as_chunks::<8>(); + let (cb, rb) = b.as_chunks::<8>(); + for (x, y) in ca.iter().zip(cb) { + for l in 0..8 { + s[l] += x[l] * y[l]; + } + } + let mut acc = ((s[0] + s[4]) + (s[1] + s[5])) + ((s[2] + s[6]) + (s[3] + s[7])); + for (x, y) in ra.iter().zip(rb) { + acc += x * y; + } + acc +} + /// Decimates one channel of 48 kHz audio by 3, 4 or 6. #[derive(Clone)] pub struct Downsampler { @@ -77,7 +96,7 @@ impl Downsampler { let t = taps - 1 + self.factor * j; let win = &self.buf[t + 1 - taps..=t]; // h is symmetric, so the window can be taken in forward order. - out.push(win.iter().zip(&self.h).map(|(a, b)| a * b).sum()); + out.push(dot8(win, &self.h)); } let n = self.buf.len(); self.buf.copy_within(n - (taps - 1).., 0); @@ -97,6 +116,16 @@ mod tests { (x.iter().map(|&v| (v as f64).powi(2)).sum::() / x.len() as f64).sqrt() } + #[test] + fn dot8_matches_sequential_sum() { + for len in [0usize, 1, 7, 8, 9, 63, 167, 251] { + let a: Vec = (0..len).map(|i| ((i * 37 % 101) as f32 - 50.0) / 50.0).collect(); + let b: Vec = (0..len).map(|i| ((i * 53 % 89) as f32 - 44.0) / 44.0).collect(); + let exact: f64 = a.iter().zip(&b).map(|(&x, &y)| x as f64 * y as f64).sum(); + assert!((dot8(&a, &b) as f64 - exact).abs() < 1e-4, "len {len}"); + } + } + #[test] fn passes_band_and_rejects_aliases() { for &(fs, pass, stop) in &[(16_000u32, 6_000.0, 8_600.0), (12_000, 4_500.0, 6_500.0), (8_000, 3_000.0, 4_500.0)] { diff --git a/crates/audio/src/opus/encoder/silk/analysis.rs b/crates/audio/src/opus/encoder/silk/analysis.rs index 439331076..d80052046 100644 --- a/crates/audio/src/opus/encoder/silk/analysis.rs +++ b/crates/audio/src/opus/encoder/silk/analysis.rs @@ -69,28 +69,55 @@ pub fn levinson(r: &[f64], order: usize) -> Vec { } /// Evaluates the symmetric polynomial `p` (length `d + 1`, `d` even) as the cosine series -/// `e^{jωd/2} P(e^{jω})`. -fn cos_series(p: &[f64], w: f64) -> f64 { +/// `e^{jωd/2} P(e^{jω})`, with `cos_m(m)` giving `cos(m ω)`. +#[inline] +fn cos_series_with(p: &[f64], cos_m: impl Fn(usize) -> f64) -> f64 { let h = (p.len() - 1) / 2; let mut s = p[h]; for k in 0..h { - s += 2.0 * p[k] * ((h - k) as f64 * w).cos(); + s += 2.0 * p[k] * cos_m(h - k); } s } +fn cos_series(p: &[f64], w: f64) -> f64 { + cos_series_with(p, |m| (m as f64 * w).cos()) +} + +/// Number of grid intervals the root search scans over `[0, π]`. +const GRID: usize = 1024; +/// Largest multiple of ω in the series (half the LPC order, at most 16 / 2). +const MAX_H: usize = 8; +/// Bisection steps per root: the bracket shrinks to 3e-9 rad, far below one Q15 NLSF step (9.6e-5 rad). +const BISECT_STEPS: usize = 20; + +/// `cos(m · π g / GRID)` for every grid point `g` and `m` in `0..=MAX_H`, computed with the same +/// expression as [`cos_series`], so the table values are bit-identical to calling `cos` there. +fn grid_cos() -> &'static [[f64; MAX_H + 1]] { + static TABLE: std::sync::OnceLock> = std::sync::OnceLock::new(); + TABLE.get_or_init(|| { + (0..=GRID) + .map(|g| { + let w = std::f64::consts::PI * g as f64 / GRID as f64; + std::array::from_fn(|m| (m as f64 * w).cos()) + }) + .collect() + }) +} + fn roots(p: &[f64], out: &mut Vec) { - const GRID: usize = 1024; + let grid = grid_cos(); + let at_grid = |g: usize| cos_series_with(p, |m| grid[g][m]); let mut w0 = 0.0; - let mut f0 = cos_series(p, w0); + let mut f0 = at_grid(0); for g in 1..=GRID { let w1 = std::f64::consts::PI * g as f64 / GRID as f64; - let f1 = cos_series(p, w1); + let f1 = at_grid(g); if f0 == 0.0 { out.push(w0); } else if f0 * f1 < 0.0 { let (mut lo, mut hi, mut flo) = (w0, w1, f0); - for _ in 0..40 { + for _ in 0..BISECT_STEPS { let mid = 0.5 * (lo + hi); let fm = cos_series(p, mid); if fm * flo <= 0.0 { @@ -111,6 +138,9 @@ fn roots(p: &[f64], out: &mut Vec) { /// when the root search fails (unstable or degenerate filter). pub fn a2nlsf(a: &[f64]) -> Option> { let d = a.len(); + if d > 2 * MAX_H { + return None; + } let mut c = vec![0f64; d + 2]; c[0] = 1.0; for k in 0..d { @@ -199,9 +229,20 @@ pub fn pitch_search(x: &[f32], start: usize, len: usize, fs_khz: usize) -> Pitch let score = full[(lag - min_lag) as usize]; // Contour: per-subframe lag offsets around the chosen lag. let cb: &[[i32; 4]] = if fs_khz == 8 { &CB_NB_20 } else { &CB_WB_20 }; + // The contour search revisits the same (subframe, lag) pairs for neighbouring base lags and + // codebook entries, so each correlation is computed once. + let span = (18 * fs - min_lag + 1) as usize; + let memo = std::cell::RefCell::new(vec![f64::NAN; 4 * span]); let sub_score = |k: usize, l: i32| -> f64 { let l = l.clamp(min_lag, 18 * fs); - ncorr(x, start + k * sub..start + (k + 1) * sub, l as usize) + let slot = k * span + (l - min_lag) as usize; + let cached = memo.borrow()[slot]; + if !cached.is_nan() { + return cached; + } + let v = ncorr(x, start + k * sub..start + (k + 1) * sub, l as usize); + memo.borrow_mut()[slot] = v; + v }; let mut best = (f64::MIN, lag, 0usize); for l0 in (lag - 2).max(min_lag)..=(lag + 2).min(max_lag) { @@ -319,4 +360,59 @@ mod tests { } } } + + /// The root search as it was before the grid table: `cos` called for every evaluation. + fn roots_reference(p: &[f64], out: &mut Vec) { + let mut w0 = 0.0; + let mut f0 = cos_series(p, w0); + for g in 1..=GRID { + let w1 = std::f64::consts::PI * g as f64 / GRID as f64; + let f1 = cos_series(p, w1); + if f0 == 0.0 { + out.push(w0); + } else if f0 * f1 < 0.0 { + let (mut lo, mut hi, mut flo) = (w0, w1, f0); + for _ in 0..BISECT_STEPS { + let mid = 0.5 * (lo + hi); + let fm = cos_series(p, mid); + if fm * flo <= 0.0 { + hi = mid; + } else { + lo = mid; + flo = fm; + } + } + out.push(0.5 * (lo + hi)); + } + w0 = w1; + f0 = f1; + } + } + + #[test] + fn grid_table_roots_are_bit_identical_to_direct_cos() { + let mut seed = 7u64; + let mut rnd = move || { + seed ^= seed << 13; + seed ^= seed >> 7; + seed ^= seed << 17; + (seed >> 11) as f64 / (1u64 << 53) as f64 * 2.0 - 1.0 + }; + let mut found = 0; + for len in [11usize, 17] { + for _ in 0..300 { + let mut p = vec![0f64; len]; + for k in 0..len / 2 + 1 { + p[k] = rnd(); + p[len - 1 - k] = p[k]; + } + let (mut a, mut b) = (Vec::new(), Vec::new()); + roots(&p, &mut a); + roots_reference(&p, &mut b); + assert_eq!(a.iter().map(|v| v.to_bits()).collect::>(), b.iter().map(|v| v.to_bits()).collect::>()); + found += a.len(); + } + } + assert!(found > 1000, "{found}"); + } } diff --git a/crates/audio/src/opus/encoder/silk/mod.rs b/crates/audio/src/opus/encoder/silk/mod.rs index d82e537e0..0fda4f59a 100644 --- a/crates/audio/src/opus/encoder/silk/mod.rs +++ b/crates/audio/src/opus/encoder/silk/mod.rs @@ -129,6 +129,48 @@ struct Coded { pulses: Vec, } +/// Noise-feedback history (decoded − input), most recent first, as a double-length ring: each +/// sample is stored at `pos` and `pos + MAX_LPC_ORDER`, so `buf[pos..pos + MAX_LPC_ORDER]` is +/// always the contiguous window and a push costs two stores instead of a shift. +struct NfRing { + buf: [f64; 2 * MAX_LPC_ORDER], + /// Index of the most recent sample, always below `MAX_LPC_ORDER`. + pos: usize, +} + +impl NfRing { + fn new(hist: &[f64; MAX_LPC_ORDER]) -> Self { + let mut buf = [0.0; 2 * MAX_LPC_ORDER]; + buf[..MAX_LPC_ORDER].copy_from_slice(hist); + buf[MAX_LPC_ORDER..].copy_from_slice(hist); + NfRing { buf, pos: 0 } + } + + /// The history, most recent first. + fn window(&self) -> &[f64] { + self.buf.get(self.pos..self.pos + MAX_LPC_ORDER).unwrap_or(&[]) + } + + /// Makes `v` the most recent sample and drops the oldest. + fn push(&mut self, v: f64) { + self.pos = self.pos.checked_sub(1).unwrap_or(MAX_LPC_ORDER - 1); + for i in [self.pos, self.pos + MAX_LPC_ORDER] { + if let Some(slot) = self.buf.get_mut(i) { + *slot = v; + } + } + } + + /// The history as a plain array, most recent first. + fn to_array(&self) -> [f64; MAX_LPC_ORDER] { + let mut out = [0.0; MAX_LPC_ORDER]; + for (o, v) in out.iter_mut().zip(self.window()) { + *o = *v; + } + out + } +} + #[derive(Clone)] struct Channel { fs_khz: usize, @@ -237,7 +279,7 @@ impl Channel { let sub = self.sub; let order = self.order; let st = &mut self.dec; - let nf = &mut self.nf; + let mut ring = NfRing::new(&self.nf); let off = if p.signal_type == 0 { offset + INACTIVE_OFFSET } else { offset }; let gamma = nf_gamma(off); let mut nf_c = [0f64; MAX_LPC_ORDER]; @@ -355,7 +397,7 @@ impl Channel { } let lpc_q14 = lpc_pred.saturating_mul(16); // Target excitation (Q14) for this sample. - let fb: f64 = (0..order).map(|j| nf_c[j] * nf[j]).sum(); + let fb: f64 = nf_c.iter().zip(ring.window()).take(order).map(|(c, e)| c * e).sum(); let tgt = (x[n] as f64 + fb).clamp(-32768.0, 32767.0) * inv_g - lpc_q14 as f64 - ltp_q14 as f64; let sgn = if seed_v < 0 { -1.0 } else { 1.0 }; let u = sgn * tgt; @@ -394,11 +436,11 @@ impl Channel { let v = res.saturating_add(lpc_q14); s_lpc[MAX_LPC_ORDER + i] = v; xq[n] = sat16(rshift_round(smulww(v, gain_q10), 8)) as i16; - nf.copy_within(0..MAX_LPC_ORDER - 1, 1); - nf[0] = xq[n] as f64 - x[n] as f64; + ring.push(xq[n] as f64 - x[n] as f64); } s_lpc.copy_within(sub..sub + MAX_LPC_ORDER, 0); } + self.nf = ring.to_array(); st.s_lpc_q14.copy_from_slice(&s_lpc[..MAX_LPC_ORDER]); st.out_buf[..l].copy_from_slice(&xq); (Coded { gain_ix, gains_q16, seed, pulses }, xq) @@ -485,6 +527,14 @@ struct Prep { pred_q13: [i32; 2], } +/// One rate-loop trial: the frame coded at gain offset `offset`. +struct Trial { + offset: f64, + bits: i32, + state: SilkEncoder, + coder: RangeEncoder, +} + /// SILK encoder for one mono or stereo (mid/side) stream. #[derive(Clone)] pub struct SilkEncoder { @@ -635,11 +685,20 @@ impl SilkEncoder { pub fn encode(&mut self, input: &[Vec], target_bits: f64, max_bits: i32, enc: &mut RangeEncoder) { let prep = self.prepare(input); let start_bits = enc.tell(); - let trial = |s: &Self, o: f64| -> i32 { - let mut t = s.clone(); - let mut e = enc.clone(); - t.code(&prep, o, &mut e); - e.tell() - start_bits + // Every trial codes the frame into a clone of the encoder and the range coder. The result + // is kept per offset: the hard-limit check below hits the memo for the chosen offset, and + // the final step adopts that trial instead of coding the frame once more. + let mut trials: Vec = Vec::new(); + let mut trial = |s: &Self, o: f64| -> i32 { + if let Some(t) = trials.iter().find(|t| t.offset == o) { + return t.bits; + } + let mut state = s.clone(); + let mut coder = enc.clone(); + state.code(&prep, o, &mut coder); + let bits = coder.tell() - start_bits; + trials.push(Trial { offset: o, bits, state, coder }); + bits }; // Bisection on the gain offset: the smallest offset (finest quantisation) within budget. let target = target_bits.min(max_bits as f64); @@ -701,8 +760,20 @@ impl SilkEncoder { while trial(self, o) > max_bits && o < 12.0 { o += 1.0; } + match trials.iter().position(|t| t.offset == o) { + Some(i) => { + let t = trials.swap_remove(i); + *self = t.state; + *enc = t.coder; + } + None => self.code(&prep, o, enc), + } + self.end_frame(&prep, o); + } + + /// Advances the input history and the frame counter after frame `prep` was coded at `o`. + fn end_frame(&mut self, prep: &Prep, o: f64) { self.last_offset = o; - self.code(&prep, o, enc); for ch in 0..self.channels { self.ch[ch].push_history(&prep.x[ch]); } @@ -712,3 +783,80 @@ impl SilkEncoder { self.frame += 1; } } + +#[cfg(test)] +mod tests { + use super::*; + + /// Deterministic speech-like test input: two harmonics with a moving pitch, a syllable + /// envelope, noise and short silences, at the internal rate and 16-bit scale. + fn signal(len: usize, fs_khz: usize, seed: u32) -> Vec { + let mut s = seed; + let fs = (fs_khz * 1000) as f64; + (0..len) + .map(|i| { + s = s.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + let noise = (s >> 8) as f64 / (1u32 << 24) as f64 - 0.5; + let t = i as f64 / fs; + let f0 = 140.0 + 40.0 * (t * 1.3).sin(); + let env = ((t * 4.0).sin().max(0.0)).powf(0.7); + let voiced = (std::f64::consts::TAU * f0 * t).sin() + 0.5 * (std::f64::consts::TAU * 2.0 * f0 * t).sin(); + (8000.0 * env * voiced + 600.0 * noise) as f32 + }) + .collect() + } + + #[test] + fn nf_ring_matches_a_shifted_history() { + let mut hist = [0f64; MAX_LPC_ORDER]; + for (i, h) in hist.iter_mut().enumerate() { + *h = i as f64 * 0.5 - 3.0; + } + let mut ring = NfRing::new(&hist); + assert_eq!(ring.window(), &hist[..]); + for n in 0..100 { + let v = (n as f64 * 0.37).sin() * 100.0; + hist.copy_within(0..MAX_LPC_ORDER - 1, 1); + hist[0] = v; + ring.push(v); + assert_eq!(ring.window(), &hist[..], "after push {n}"); + } + assert_eq!(ring.to_array(), hist); + } + + /// The rate loop adopts the memoised trial for the chosen offset. A second encoder that codes + /// every frame afresh at that offset (what the loop did before the memo) must produce the + /// same bytes, frame after frame, so the adopted encoder and range-coder states are exact. + #[test] + fn adopting_the_memoised_trial_equals_coding_the_frame_again() { + for (fs_khz, channels, target_bits, max_bits) in + [(8, 1, 200.0, 1000), (12, 1, 320.0, 1000), (16, 1, 480.0, 1000), (16, 2, 640.0, 1000), (16, 1, 900.0, 400), (8, 2, 120.0, 160)] + { + let mut memo = SilkEncoder::new(fs_khz, channels); + let mut fresh = memo.clone(); + let l = memo.frame_len(); + let frames = 40; + let left = signal(l * frames, fs_khz, 7); + let right: Vec = signal(l * frames + 37, fs_khz, 11)[37..].iter().map(|v| v * 0.6).collect(); + for f in 0..frames { + let mut input = vec![left[f * l..(f + 1) * l].to_vec()]; + if channels == 2 { + input.push(right[f * l..(f + 1) * l].to_vec()); + } + let mut enc = RangeEncoder::new(); + memo.encode(&input, target_bits, max_bits, &mut enc); + let o = memo.last_offset; + let prep = fresh.prepare(&input); + let mut enc_fresh = RangeEncoder::new(); + fresh.code(&prep, o, &mut enc_fresh); + fresh.end_frame(&prep, o); + assert_eq!(enc.tell(), enc_fresh.tell(), "{fs_khz} kHz {channels} ch frame {f}"); + assert_eq!(enc.done(1275), enc_fresh.done(1275), "{fs_khz} kHz {channels} ch frame {f}"); + for c in 0..channels { + assert_eq!(memo.ch[c].nf, fresh.ch[c].nf, "noise feedback, channel {c}, frame {f}"); + assert_eq!(memo.ch[c].dec.s_lpc_q14, fresh.ch[c].dec.s_lpc_q14, "LPC state, channel {c}, frame {f}"); + } + } + } + } +} From f2106054e0f69b7df628c09235eadadd17906bf7 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:30:28 -0500 Subject: [PATCH 082/382] Support bounded streaming displacement samples without plane copies --- crates/psd/src/displace_map.rs | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/crates/psd/src/displace_map.rs b/crates/psd/src/displace_map.rs index 8b40eab3f..a4df21445 100644 --- a/crates/psd/src/displace_map.rs +++ b/crates/psd/src/displace_map.rs @@ -40,8 +40,20 @@ pub fn parse_map(data: &[u8]) -> Option> { /// Returns `None` for empty/oversized dimensions, mismatched planes or allocation failure. /// Callers retain their own (possibly lower) embedding and image-conversion budgets. pub fn write_map(width: usize, height: usize, horizontal: &[u8], vertical: &[u8]) -> Option> { + write_map_iter(width, height, horizontal.iter().copied(), vertical.iter().copied()) +} + +/// Writes exact-sized sample iterators without allocating intermediate planes. +/// Iterators must terminate after exactly width times height samples; extra or missing +/// samples are rejected. At most that many samples plus one are consumed per plane. +pub fn write_map_iter( + width: usize, + height: usize, + mut horizontal: impl Iterator, + mut vertical: impl Iterator, +) -> Option> { let n = width.checked_mul(height)?; - if n == 0 || n > MAX_MAP_PIXELS || horizontal.len() != n || vertical.len() != n { + if n == 0 || n > MAX_MAP_PIXELS { return None; } let width = u32::try_from(width).ok()?; @@ -52,8 +64,14 @@ pub fn write_map(width: usize, height: usize, horizontal: &[u8], vertical: &[u8] out.extend_from_slice(&height.to_le_bytes()); out.extend_from_slice(&width.to_le_bytes()); out.extend_from_slice(&MODE_TWO_PLANES.to_le_bytes()); - out.extend_from_slice(horizontal); - out.extend_from_slice(vertical); + for samples in [&mut horizontal as &mut dyn Iterator, &mut vertical] { + for _ in 0..n { + out.push(samples.next()?); + } + if samples.next().is_some() { + return None; + } + } Some(out) } From 4d594a1130c78c88e9f9baf28891fc7d76162611 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Sun, 15 Nov 2026 09:30:30 -0500 Subject: [PATCH 083/382] psd: share editable TySh binary envelope from PhotoCraft Preserve transform safety work and compatibility recovery; adapt to shared array geometry and add regression tests. Co-authored-by: David Mann Co-authored-by: Sean Lavery Co-authored-by: Dylan M. Taylor --- crates/psd/src/text.rs | 3 + crates/psd/src/text/envelope.rs | 142 ++++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+) create mode 100644 crates/psd/src/text/envelope.rs diff --git a/crates/psd/src/text.rs b/crates/psd/src/text.rs index 6ba299bca..3a9e14952 100644 --- a/crates/psd/src/text.rs +++ b/crates/psd/src/text.rs @@ -150,3 +150,6 @@ mod tests { assert_eq!(t.style.size, Some(12.0)); } } + +/// Editable type-tool envelope with PhotoCraft-compatible recovery and geometry limits. +pub mod envelope; diff --git a/crates/psd/src/text/envelope.rs b/crates/psd/src/text/envelope.rs new file mode 100644 index 000000000..68664f7d7 --- /dev/null +++ b/crates/psd/src/text/envelope.rs @@ -0,0 +1,142 @@ +//! Editable PSD Type Tool Object Setting (`TySh`) envelope, extracted from PhotoCraft. +//! App-specific text styles, layout, units and editing policy stay with the consumer. +//! Parsing intentionally retains PhotoCraft's optional-warp and partial-bounds recovery. +//! Existing read-only [`super::TypeLayer`] behavior is unchanged. + +use crate::descriptor::{Descriptor, Id, Value as D, VersionedDescriptor}; + +/// Parsed `TySh` contents. +#[derive(Clone, Debug, PartialEq)] +pub struct TySh { + pub transform: [f64; 6], + pub text: Descriptor, + pub warp: Option, + /// The four trailing big-endian f32 values (left, top, right, bottom) after the warp + /// descriptor. Photoshop writes zeros for unwarped type and the text-space bounds (the + /// `bounds` descriptor's rectangle) for warped type. + pub bounds: [f32; 4], +} + +/// Whether a type transform can reach rendering. Pixel coordinates use i32 in the originating PhotoCraft consumer, so non-finite and unrepresentable affine terms are rejected (#4758). +pub fn transform_is_safe(t: &[f64; 6]) -> bool { + t.iter().all(|v| v.is_finite() && v.abs() <= f64::from(i32::MAX)) +} + +/// Parses a `TySh` block. +pub fn parse_tysh(data: &[u8]) -> Option { + let f = |at: usize| data.get(at..at + 8).map(|b| f64::from_be_bytes(b.try_into().unwrap_or([0; 8]))); + let mut m = [0.0; 6]; + for (i, v) in m.iter_mut().enumerate() { + *v = f(2 + i * 8)?; + } + if !transform_is_safe(&m) { + return None; + } + let (text, used) = VersionedDescriptor::parse_prefix(data.get(52..)?).ok()?; + let rest = data.get(52 + used..).unwrap_or(&[]); + let (warp, wused) = match rest.get(2..).and_then(|r| VersionedDescriptor::parse_prefix(r).ok()) { + Some((w, n)) => (Some(w.descriptor), n + 2), + None => (None, 0), + }; + let tail = rest.get(wused..).unwrap_or(&[]); + let mut bounds = [0f32; 4]; + for (i, b) in bounds.iter_mut().enumerate() { + if let Some(x) = tail.get(i * 4..i * 4 + 4) { + *b = f32::from_be_bytes(x.try_into().unwrap_or([0; 4])); + } + } + Some(TySh { transform: m, text: text.descriptor, warp, bounds }) +} + +/// `tysh` moved by (`dx`, `dy`): only the transform's translation changes. The text, its styles, +/// the warp and the trailing bounds (which are in text space) stay byte for byte, so a moved +/// Photoshop type layer keeps everything Photoshop wrote. `None` when the block is too short. +pub fn translate_tysh(tysh: &[u8], dx: f64, dy: f64) -> Option> { + let mut out = tysh.to_vec(); + // Version (2 bytes), then xx, xy, yx, yy, tx, ty as big-endian f64: tx at 34, ty at 42. + for (at, d) in [(34, dx), (42, dy)] { + let b = out.get_mut(at..at + 8)?; + let v = f64::from_be_bytes(b.try_into().ok()?) + d; + b.copy_from_slice(&v.to_be_bytes()); + } + Some(out) +} + +/// Serializes a `TySh` block. +pub fn write_tysh(t: &TySh) -> Vec { + let mut v = 1u16.to_be_bytes().to_vec(); + for x in t.transform { + v.extend_from_slice(&x.to_be_bytes()); + } + v.extend_from_slice(&50u16.to_be_bytes()); + v.extend(VersionedDescriptor::new(t.text.clone()).to_bytes()); + v.extend_from_slice(&1u16.to_be_bytes()); + v.extend(VersionedDescriptor::new(t.warp.clone().unwrap_or_else(default_warp)).to_bytes()); + for b in t.bounds { + v.extend_from_slice(&b.to_be_bytes()); + } + v +} + +fn default_warp() -> Descriptor { + Descriptor::new("warp") + .with("warpStyle", enumv("warpStyle", "warpNone")) + .with("warpValue", D::Double(0.0)) + .with("warpPerspective", D::Double(0.0)) + .with("warpPerspectiveOther", D::Double(0.0)) + .with("warpRotate", enumv("Ornt", "Hrzn")) +} + +fn enumv(t: &str, v: &str) -> D { + D::Enumerated { type_id: Id::new(t), value: Id::new(v) } +} + +#[cfg(test)] +mod tests { + use super::*; + fn sample() -> TySh { + TySh { + transform: [1.0, 0.0, 0.0, 1.0, 25.0, 30.0], + text: Descriptor::new("TxLr").with("EngineData", D::RawData(b"preserved".to_vec())), + warp: Some(default_warp()), + bounds: [-1.0, 2.0, 30.0, 40.0], + } + } + #[test] + fn roundtrip_preserves_descriptors_transform_and_bounds() { + let t = sample(); + let b = write_tysh(&t); + assert_eq!(parse_tysh(&b), Some(t)); + let shifted = translate_tysh(&b, 7.0, -3.0).unwrap(); + assert_eq!(&shifted[..34], &b[..34]); + assert_eq!(&shifted[50..], &b[50..]); + assert_eq!(parse_tysh(&shifted).unwrap().transform, [1.0, 0.0, 0.0, 1.0, 32.0, 27.0]); + } + #[test] + fn truncations_and_unsafe_transforms_preserve_recovery_contract() { + let mut t = sample(); + let bytes = write_tysh(&t); + let (_, n) = VersionedDescriptor::parse_prefix(&bytes[52..]).unwrap(); + for cut in 0..52 + n { + assert!(parse_tysh(&bytes[..cut]).is_none(), "{cut}"); + } + let short = parse_tysh(&bytes[..52 + n]).unwrap(); + assert!(short.warp.is_none()); + assert_eq!(short.bounds, [0.0; 4]); + for cut in 0..50 { + assert!(translate_tysh(&bytes[..cut], 1.0, 2.0).is_none()); + } + for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, f64::from(i32::MAX) + 1.0] { + for i in 0..6 { + t = sample(); + t.transform[i] = bad; + assert!(parse_tysh(&write_tysh(&t)).is_none()); + } + } + t = sample(); + t.warp = None; + assert!(parse_tysh(&write_tysh(&t)).unwrap().warp.is_some()); + let partial = parse_tysh(&bytes[..bytes.len() - 4]).unwrap(); + assert_eq!(partial.bounds, [-1.0, 2.0, 30.0, 0.0]); + } +} From d0feabc6c8c5998f76a68d2b6887660f23563e52 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:30:43 -0500 Subject: [PATCH 084/382] Exercise displacement dimension guards independently of mode --- crates/psd/src/displace_map.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/psd/src/displace_map.rs b/crates/psd/src/displace_map.rs index a4df21445..fbe8a7332 100644 --- a/crates/psd/src/displace_map.rs +++ b/crates/psd/src/displace_map.rs @@ -99,10 +99,15 @@ mod tests { let mut invalid = bytes.clone(); invalid[8] = 4; assert!(parse_map(&invalid).is_none()); + invalid[8] = 3; invalid[..8].fill(255); assert!(parse_map(&invalid).is_none()); invalid[..8].fill(0); assert!(parse_map(&invalid).is_none()); + invalid[..4].copy_from_slice(&1u32.to_le_bytes()); + invalid[4..8].copy_from_slice(&((MAX_MAP_PIXELS + 1) as u32).to_le_bytes()); + assert!(parse_map(&invalid).is_none()); + assert!(write_map_iter(2, 1, std::iter::repeat(0), std::iter::repeat(0)).is_none()); assert!(write_map(usize::MAX, 2, &[], &[]).is_none()); assert!(write_map(MAX_MAP_PIXELS + 1, 1, &[], &[]).is_none()); assert!(write_map(2, 1, &[0], &[0, 0]).is_none()); From 1e204c51dff0d49e528637b16d58f95cfa2b283a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:33:38 -0500 Subject: [PATCH 085/382] psd: bound TySh serialization and reject unsafe geometry --- crates/psd/src/text/envelope.rs | 186 ++++++++++++++++++++++++++++++-- 1 file changed, 175 insertions(+), 11 deletions(-) diff --git a/crates/psd/src/text/envelope.rs b/crates/psd/src/text/envelope.rs index 68664f7d7..e654ed390 100644 --- a/crates/psd/src/text/envelope.rs +++ b/crates/psd/src/text/envelope.rs @@ -3,7 +3,11 @@ //! Parsing intentionally retains PhotoCraft's optional-warp and partial-bounds recovery. //! Existing read-only [`super::TypeLayer`] behavior is unchanged. -use crate::descriptor::{Descriptor, Id, Value as D, VersionedDescriptor}; +use crate::descriptor::{Class, Descriptor, Id, ReferenceItem, UnicodeString, Value as D, VersionedDescriptor}; +use crate::error::{PsdError, Result}; + +/// Maximum encoded envelope size, bounding hostile input and serialized output. +pub const MAX_BYTES: usize = 8 * 1024 * 1024; /// Parsed `TySh` contents. #[derive(Clone, Debug, PartialEq)] @@ -24,6 +28,9 @@ pub fn transform_is_safe(t: &[f64; 6]) -> bool { /// Parses a `TySh` block. pub fn parse_tysh(data: &[u8]) -> Option { + if data.len() > MAX_BYTES { + return None; + } let f = |at: usize| data.get(at..at + 8).map(|b| f64::from_be_bytes(b.try_into().unwrap_or([0; 8]))); let mut m = [0.0; 6]; for (i, v) in m.iter_mut().enumerate() { @@ -45,6 +52,9 @@ pub fn parse_tysh(data: &[u8]) -> Option { *b = f32::from_be_bytes(x.try_into().unwrap_or([0; 4])); } } + if bounds.iter().any(|x| !x.is_finite()) { + return None; + } Some(TySh { transform: m, text: text.descriptor, warp, bounds }) } @@ -52,7 +62,21 @@ pub fn parse_tysh(data: &[u8]) -> Option { /// the warp and the trailing bounds (which are in text space) stay byte for byte, so a moved /// Photoshop type layer keeps everything Photoshop wrote. `None` when the block is too short. pub fn translate_tysh(tysh: &[u8], dx: f64, dy: f64) -> Option> { - let mut out = tysh.to_vec(); + if tysh.len() > MAX_BYTES || tysh.len() < 50 { + return None; + } + let mut transform = [0.0; 6]; + for (i, x) in transform.iter_mut().enumerate() { + *x = f64::from_be_bytes(tysh.get(2 + i * 8..10 + i * 8)?.try_into().ok()?); + } + transform[4] += dx; + transform[5] += dy; + if !transform_is_safe(&transform) { + return None; + } + let mut out = Vec::new(); + out.try_reserve_exact(tysh.len()).ok()?; + out.extend_from_slice(tysh); // Version (2 bytes), then xx, xy, yx, yy, tx, ty as big-endian f64: tx at 34, ty at 42. for (at, d) in [(34, dx), (42, dy)] { let b = out.get_mut(at..at + 8)?; @@ -63,19 +87,136 @@ pub fn translate_tysh(tysh: &[u8], dx: f64, dy: f64) -> Option> { } /// Serializes a `TySh` block. -pub fn write_tysh(t: &TySh) -> Vec { - let mut v = 1u16.to_be_bytes().to_vec(); +pub fn write_tysh(t: &TySh) -> Result> { + if !transform_is_safe(&t.transform) || t.bounds.iter().any(|x| !x.is_finite()) { + return Err(PsdError::LimitExceeded("TySh geometry")); + } + let default; + let warp = match &t.warp { + Some(w) => w, + None => { + default = default_warp(); + &default + } + }; + let mut budget = Budget(78); // versions, transform and trailing bounds + budget.descriptor(&t.text, 0)?; + budget.descriptor(warp, 0)?; + let mut v = Vec::new(); + v.try_reserve_exact(budget.0).map_err(|_| PsdError::OutOfMemory("TySh output"))?; + v.extend_from_slice(&1u16.to_be_bytes()); for x in t.transform { v.extend_from_slice(&x.to_be_bytes()); } v.extend_from_slice(&50u16.to_be_bytes()); - v.extend(VersionedDescriptor::new(t.text.clone()).to_bytes()); + v.extend_from_slice(&16u32.to_be_bytes()); + t.text.write(&mut v); v.extend_from_slice(&1u16.to_be_bytes()); - v.extend(VersionedDescriptor::new(t.warp.clone().unwrap_or_else(default_warp)).to_bytes()); + v.extend_from_slice(&16u32.to_be_bytes()); + warp.write(&mut v); for b in t.bounds { v.extend_from_slice(&b.to_be_bytes()); } - v + Ok(v) +} + +// Count before cloning or serializing: bound both recursive trees and total output. +struct Budget(usize); +impl Budget { + fn add(&mut self, n: usize) -> Result<()> { + self.0 = self.0.checked_add(n).filter(|n| *n <= MAX_BYTES).ok_or(PsdError::LimitExceeded("TySh bytes"))?; + Ok(()) + } + fn unicode(&mut self, s: &UnicodeString) -> Result<()> { + self.add(4)?; + self.add(s.0.len().checked_mul(2).ok_or(PsdError::LimitExceeded("TySh string"))?) + } + fn id(&mut self, id: &Id) -> Result<()> { + self.add(4)?; + self.add(id.as_bytes().len()) + } + fn class(&mut self, c: &Class) -> Result<()> { + self.unicode(&c.name)?; + self.id(&c.class_id) + } + fn descriptor(&mut self, d: &Descriptor, depth: usize) -> Result<()> { + if depth > 32 { + return Err(PsdError::LimitExceeded("TySh depth")); + } + self.unicode(&d.name)?; + self.id(&d.class_id)?; + self.add(4)?; + for (k, v) in &d.items { + self.id(k)?; + self.value(v, depth + 1)?; + } + Ok(()) + } + fn value(&mut self, v: &D, depth: usize) -> Result<()> { + if depth > 32 { + return Err(PsdError::LimitExceeded("TySh depth")); + } + self.add(4)?; + match v { + D::Descriptor(d) | D::GlobalObject(d) => self.descriptor(d, depth), + D::ObjectArray(o) => { + self.add(4)?; + self.descriptor(&o.body, depth) + } + D::List(xs) => { + self.add(4)?; + for x in xs { + self.value(x, depth + 1)?; + } + Ok(()) + } + D::Reference(xs) => { + self.add(4)?; + for x in xs { + self.add(4)?; + match x { + ReferenceItem::Property { class, key } => { + self.class(class)?; + self.id(key)?; + } + ReferenceItem::Class(c) => self.class(c)?, + ReferenceItem::Enumerated { class, type_id, value } => { + self.class(class)?; + self.id(type_id)?; + self.id(value)?; + } + ReferenceItem::Offset { class, .. } | ReferenceItem::Identifier { class, .. } | ReferenceItem::Index { class, .. } => { + self.class(class)?; + self.add(4)?; + } + ReferenceItem::Name { class, name } => { + self.class(class)?; + self.unicode(name)?; + } + } + } + Ok(()) + } + D::Text(x) => self.unicode(x), + D::Class(c) | D::GlobalClass(c) => self.class(c), + D::Enumerated { type_id, value } => { + self.id(type_id)?; + self.id(value) + } + D::UnitFloats { values, .. } => { + self.add(8)?; + self.add(values.len().checked_mul(8).ok_or(PsdError::LimitExceeded("TySh values"))?) + } + D::RawData(x) | D::Alias(x) | D::Path(x) => { + self.add(4)?; + self.add(x.len()) + } + D::Double(_) | D::LargeInteger(_) => self.add(8), + D::UnitFloat { .. } => self.add(12), + D::Integer(_) => self.add(4), + D::Boolean(_) => self.add(1), + } + } } fn default_warp() -> Descriptor { @@ -105,7 +246,7 @@ mod tests { #[test] fn roundtrip_preserves_descriptors_transform_and_bounds() { let t = sample(); - let b = write_tysh(&t); + let b = write_tysh(&t).unwrap(); assert_eq!(parse_tysh(&b), Some(t)); let shifted = translate_tysh(&b, 7.0, -3.0).unwrap(); assert_eq!(&shifted[..34], &b[..34]); @@ -115,7 +256,7 @@ mod tests { #[test] fn truncations_and_unsafe_transforms_preserve_recovery_contract() { let mut t = sample(); - let bytes = write_tysh(&t); + let bytes = write_tysh(&t).unwrap(); let (_, n) = VersionedDescriptor::parse_prefix(&bytes[52..]).unwrap(); for cut in 0..52 + n { assert!(parse_tysh(&bytes[..cut]).is_none(), "{cut}"); @@ -130,13 +271,36 @@ mod tests { for i in 0..6 { t = sample(); t.transform[i] = bad; - assert!(parse_tysh(&write_tysh(&t)).is_none()); + assert!(write_tysh(&t).is_err()); } } t = sample(); t.warp = None; - assert!(parse_tysh(&write_tysh(&t)).unwrap().warp.is_some()); + assert!(parse_tysh(&write_tysh(&t).unwrap()).unwrap().warp.is_some()); let partial = parse_tysh(&bytes[..bytes.len() - 4]).unwrap(); assert_eq!(partial.bounds, [-1.0, 2.0, 30.0, 0.0]); } + #[test] + fn hostile_output_and_translations_are_refused_before_copying() { + let bytes = write_tysh(&sample()).unwrap(); + for bad in [f64::NAN, f64::INFINITY, f64::MAX] { + assert!(translate_tysh(&bytes, bad, 0.0).is_none()); + } + let mut t = sample(); + t.bounds[0] = f32::NAN; + assert!(write_tysh(&t).is_err()); + t = sample(); + t.text = Descriptor::new("TxLr").with("data", D::RawData(vec![0; MAX_BYTES])); + assert!(write_tysh(&t).is_err()); + let oversized = vec![0; MAX_BYTES + 1]; + assert!(translate_tysh(&oversized, 0.0, 0.0).is_none()); + assert!(parse_tysh(&oversized).is_none()); + let mut nested = D::Integer(1); + for _ in 0..34 { + nested = D::List(vec![nested]); + } + t = sample(); + t.text = Descriptor::new("TxLr").with("nest", nested); + assert!(write_tysh(&t).is_err()); + } } From f483f9d6dd0ec9dcaf7697323cfab0b7f6fdc57b Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Sun, 15 Nov 2026 09:39:55 -0500 Subject: [PATCH 086/382] cms: preserve original PDFCraft ICC v2 sRGB generator Extracted unchanged from storytold/pdfcraft e098c5c85, crates/preflight/src/icc.rs; original implementation 4d60af8b1, rename d3db99818. --- crates/cms/src/builtin_v2.rs | 128 +++++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 crates/cms/src/builtin_v2.rs diff --git a/crates/cms/src/builtin_v2.rs b/crates/cms/src/builtin_v2.rs new file mode 100644 index 000000000..935dd105c --- /dev/null +++ b/crates/cms/src/builtin_v2.rs @@ -0,0 +1,128 @@ +//! A small sRGB ICC profile (version 2, display class, matrix/TRC), written from the published +//! sRGB primaries (IEC 61966-2-1) adapted to D50, with the sRGB tone curve sampled at 1024 +//! points. Used as the PDF/A output intent's destination profile. + +fn s15f16(v: f64) -> [u8; 4] { + ((v * 65536.0).round() as i32).to_be_bytes() +} + +fn xyz(x: f64, y: f64, z: f64) -> Vec { + let mut t = b"XYZ \0\0\0\0".to_vec(); + t.extend(s15f16(x)); + t.extend(s15f16(y)); + t.extend(s15f16(z)); + t +} + +fn desc(text: &str) -> Vec { + let mut t = b"desc\0\0\0\0".to_vec(); + let ascii: Vec = text.bytes().chain(std::iter::once(0)).collect(); + t.extend((ascii.len() as u32).to_be_bytes()); + t.extend(&ascii); + // No Unicode or ScriptCode descriptions. + t.extend([0u8; 4 + 4]); + t.extend([0u8; 2 + 1 + 67]); + t +} + +fn text(text: &str) -> Vec { + let mut t = b"text\0\0\0\0".to_vec(); + t.extend(text.bytes()); + t.push(0); + t +} + +fn curve() -> Vec { + const N: usize = 1024; + let mut t = b"curv\0\0\0\0".to_vec(); + t.extend((N as u32).to_be_bytes()); + for i in 0..N { + let v = i as f64 / (N - 1) as f64; + let lin = if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }; + t.extend(((lin * 65535.0).round() as u16).to_be_bytes()); + } + t +} + +/// The profile's bytes. +pub fn srgb() -> Vec { + // sRGB primaries, Bradford-adapted to the D50 profile connection space. + let tags: Vec<(&[u8; 4], Vec)> = vec![ + (b"desc", desc("sRGB (PdfCraft)")), + (b"cprt", text("No copyright, use freely")), + (b"wtpt", xyz(0.9642, 1.0, 0.8249)), + (b"rXYZ", xyz(0.4361, 0.2225, 0.0139)), + (b"gXYZ", xyz(0.3851, 0.7169, 0.0971)), + (b"bXYZ", xyz(0.1431, 0.0606, 0.7141)), + (b"rTRC", curve()), + ]; + // gTRC and bTRC share rTRC's data. + let count = tags.len() + 2; + let table_len = 4 + count * 12; + let mut offset = 128 + table_len; + let mut table = (count as u32).to_be_bytes().to_vec(); + let mut data = Vec::new(); + let mut trc = (0, 0); + for (sig, body) in &tags { + let len = body.len(); + table.extend(*sig); + table.extend((offset as u32).to_be_bytes()); + table.extend((len as u32).to_be_bytes()); + if *sig == b"rTRC" { + trc = (offset, len); + } + data.extend(body); + // Tags start on 4-byte boundaries. + let pad = (4 - len % 4) % 4; + data.extend(std::iter::repeat_n(0u8, pad)); + offset += len + pad; + } + for sig in [b"gTRC", b"bTRC"] { + table.extend(sig); + table.extend((trc.0 as u32).to_be_bytes()); + table.extend((trc.1 as u32).to_be_bytes()); + } + let size = 128 + table.len() + data.len(); + let mut h = Vec::with_capacity(size); + h.extend((size as u32).to_be_bytes()); + h.extend(b"\0\0\0\0"); // preferred CMM + h.extend([2, 0x10, 0, 0]); // version 2.1 + h.extend(b"mntr"); + h.extend(b"RGB "); + h.extend(b"XYZ "); + h.extend([0u8; 12]); // date + h.extend(b"acsp"); + h.extend(b"\0\0\0\0"); // platform + h.extend([0u8; 4]); // flags + h.extend([0u8; 4]); // manufacturer + h.extend([0u8; 4]); // model + h.extend([0u8; 8]); // attributes + h.extend([0, 0, 0, 0]); // perceptual intent + h.extend(s15f16(0.9642)); + h.extend(s15f16(1.0)); + h.extend(s15f16(0.8249)); + h.extend([0u8; 4]); // creator + h.resize(128, 0); + h.extend(table); + h.extend(data); + h +} + +#[cfg(test)] +mod tests { + #[test] + fn profile_is_well_formed() { + let p = super::srgb(); + assert_eq!(u32::from_be_bytes(p[0..4].try_into().unwrap()) as usize, p.len()); + assert_eq!(&p[36..40], b"acsp"); + assert_eq!(&p[12..20], b"mntrRGB "); + let n = u32::from_be_bytes(p[128..132].try_into().unwrap()) as usize; + assert_eq!(n, 9); + for i in 0..n { + let e = 132 + i * 12; + let off = u32::from_be_bytes(p[e + 4..e + 8].try_into().unwrap()) as usize; + let len = u32::from_be_bytes(p[e + 8..e + 12].try_into().unwrap()) as usize; + assert!(off.is_multiple_of(4) && off + len <= p.len(), "tag {i}"); + } + } +} From 7bc5f2a4c8214b97394a5dcf60d01e9f5f5298c3 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:40:37 -0500 Subject: [PATCH 087/382] cms: expose fixed v2 sRGB profile and verify shared parsing --- crates/cms/src/builtin.rs | 12 ++++++++++++ crates/cms/src/builtin_v2.rs | 17 ++++++++++++++++- crates/cms/src/lib.rs | 1 + 3 files changed, 29 insertions(+), 1 deletion(-) diff --git a/crates/cms/src/builtin.rs b/crates/cms/src/builtin.rs index ca7034286..e62faa907 100644 --- a/crates/cms/src/builtin.rs +++ b/crates/cms/src/builtin.rs @@ -450,3 +450,15 @@ mod tests { assert!(cicp_rgb(u16::MAX, u16::MAX, true).is_none()); } } + +/// Generates the compact ICC v2.1 sRGB matrix/TRC profile used by PDFCraft. +/// +/// Unlike [`Builtin::Srgb`]'s v4 profile, this uses a 1024-sample tone curve and +/// v2 `desc`/`text` tags for consumers that require a v2 output intent. The legacy +/// description `sRGB (PdfCraft)` is retained to preserve existing document bytes. +/// The generated profile contains no external assets; callers choose where it is +/// appropriate (including their own PDF/A conformance policy). +/// All sizes are fixed; no input-controlled allocation or recursion is involved. +pub fn srgb_v2() -> Vec { + crate::builtin_v2::srgb() +} diff --git a/crates/cms/src/builtin_v2.rs b/crates/cms/src/builtin_v2.rs index 935dd105c..4a9e2e25b 100644 --- a/crates/cms/src/builtin_v2.rs +++ b/crates/cms/src/builtin_v2.rs @@ -44,7 +44,7 @@ fn curve() -> Vec { t } -/// The profile's bytes. +/// Fixed-size profile bytes; all tag sizes and loop counts are constants. pub fn srgb() -> Vec { // sRGB primaries, Bradford-adapted to the D50 profile connection space. let tags: Vec<(&[u8; 4], Vec)> = vec![ @@ -110,6 +110,21 @@ pub fn srgb() -> Vec { #[cfg(test)] mod tests { + #[test] + fn parses_as_v2_with_shared_rgb_curves() { + let bytes = super::srgb(); + let p = crate::Profile::parse(&bytes).unwrap(); + assert_eq!(p.version, (2, 0x10)); + assert_eq!(p.color_space, crate::ColorSpace::Rgb); + assert_eq!(p.pcs, crate::Pcs::Xyz); + assert_eq!(p.description, "sRGB (PdfCraft)"); + let curves = p.trc.unwrap(); + assert_eq!(curves[0], curves[1]); + assert_eq!(curves[1], curves[2]); + assert!(matches!(&curves[0], crate::Curve::Table(v) if v.len() == 1024 && v[0] == 0.0 && v[1023] == 1.0)); + assert_eq!(bytes, super::srgb()); + } + #[test] fn profile_is_well_formed() { let p = super::srgb(); diff --git a/crates/cms/src/lib.rs b/crates/cms/src/lib.rs index 8d4f99f49..5e8a1e268 100644 --- a/crates/cms/src/lib.rs +++ b/crates/cms/src/lib.rs @@ -20,6 +20,7 @@ #![forbid(unsafe_code)] pub mod builtin; +mod builtin_v2; pub mod clut; pub mod curve; pub mod gamut; From 1985afe943f2088e56697948638d3286260e6db9 Mon Sep 17 00:00:00 2001 From: nuclearspike Date: Sun, 15 Nov 2026 09:40:41 -0500 Subject: [PATCH 088/382] tga: port metadata payload boundaries and regressions from FilmCraft #1932 Source head e7842f76f887005c460c64a8ab51d59d086e6f27; adapt original decoder guard and synthetic regressions to shared Picture/Error API. --- crates/tga/src/lib.rs | 118 ++++++++- crates/tga/src/metadata_tests.rs | 424 +++++++++++++++++++++++++++++++ 2 files changed, 536 insertions(+), 6 deletions(-) create mode 100644 crates/tga/src/metadata_tests.rs diff --git a/crates/tga/src/lib.rs b/crates/tga/src/lib.rs index ac9d21497..88f4efe6c 100644 --- a/crates/tga/src/lib.rs +++ b/crates/tga/src/lib.rs @@ -18,6 +18,8 @@ //! Input is treated as hostile: the picture size is capped by [`Limits`], and a run-length file //! must be long enough to hold the pixels its header declares before anything is allocated. +#[cfg(test)] +mod metadata_tests; #[cfg(test)] mod tests; @@ -180,6 +182,105 @@ impl Stored { } } +fn metadata_offset(body: &[u8], offset: usize, first_pixel: usize) -> Option { + // Optional metadata cannot replace the header, image ID, or colour map. + (offset >= first_pixel && offset < body.len()).then_some(offset) +} + +/// The start of every developer-directory payload with a nonzero length, from the directory at +/// `directory` in `body` (none when that offset holds no readable directory). +fn developer_payload_starts(body: &[u8], directory: usize) -> Vec { + let Some(count) = + body.get(directory..directory.saturating_add(2)).and_then(|v| v.first_chunk::<2>()).map(|v| usize::from(u16::from_le_bytes(*v))) + else { + return Vec::new(); + }; + let Some(fields) = body.get(directory.saturating_add(2)..) else { return Vec::new() }; + fields + .chunks(10) + .take(count) + .filter_map(|field| { + let start = field.get(2..6).and_then(|v| v.first_chunk::<4>()).map(|v| u32::from_le_bytes(*v) as usize)?; + let length = field.get(6..10).and_then(|v| v.first_chunk::<4>()).map(|v| u32::from_le_bytes(*v))?; + (length != 0).then_some(start) + }) + .collect() +} + +fn image_data_end(bytes: &[u8], first_pixel: usize) -> Result { + if !bytes.ends_with(SIGNATURE) { + return Ok(bytes.len()); + } + // A TGA 2.0 footer cannot begin inside the mandatory header. A legacy image + // may end with the same signature as pixel bytes. + let Some(footer) = bytes.len().checked_sub(SIGNATURE.len() + 8).filter(|&at| at >= HEADER) else { + return Ok(bytes.len()); + }; + let offsets = bytes.get(footer..footer + 8).and_then(|b| b.first_chunk::<8>()).ok_or_else(|| Error::Malformed("truncated footer"))?; + let extension = offsets.first_chunk::<4>().map(|v| u32::from_le_bytes(*v) as usize).ok_or_else(|| Error::Malformed("truncated footer"))?; + let directory = offsets + .get(4..) + .and_then(|v| v.first_chunk::<4>()) + .map(|v| u32::from_le_bytes(*v) as usize) + .ok_or_else(|| Error::Malformed("truncated footer"))?; + let body = bytes.get(..footer).ok_or_else(|| Error::Malformed("truncated footer"))?; + let mut end = footer; + + if let Some(offset) = metadata_offset(body, extension, first_pixel) { + // An in-body reference is a conservative image boundary, even if it overlaps + // required pixels. Those bytes cannot be distinguished from a truncated image + // whose missing pixels are supplied by metadata. + end = end.min(offset); + // TGA 2.0 extension fields at byte offsets 482, 486 and 490 point to the colour + // correction, postage-stamp and scan-line tables. The record's first two bytes give + // its size (495 in TGA 2.0); a shorter record has no such fields, and a record never + // reaches into a developer directory that follows it, so those bytes are not read as + // table offsets. Tables may precede the record. + let declared = + body.get(offset..offset.saturating_add(2)).and_then(|v| v.first_chunk::<2>()).map_or(0, |v| usize::from(u16::from_le_bytes(*v))); + let mut record_end = offset.saturating_add(declared.min(495)); + // The developer directory and its payloads may sit anywhere after the pixels, a payload + // before its directory included; whichever starts first after the extension ends it. + // A directory offset of zero means there is none: the header is not read as one. + let payloads = metadata_offset(body, directory, first_pixel).map(|d| developer_payload_starts(body, d)).unwrap_or_default(); + for next in std::iter::once(directory).chain(payloads) { + if next > offset { + record_end = record_end.min(next); + } + } + if let Some(area) = body.get(offset..record_end.min(body.len())) { + for field in [482, 486, 490] { + if let Some(value) = area.get(field..field + 4).and_then(|v| v.first_chunk::<4>()) + && let Some(table) = metadata_offset(body, u32::from_le_bytes(*value) as usize, first_pixel) + { + end = end.min(table); + } + } + } + } + + if let Some(offset) = metadata_offset(body, directory, first_pixel) { + end = end.min(offset); + if let Some(count) = + body.get(offset..offset.saturating_add(2)).and_then(|v| v.first_chunk::<2>()).map(|v| usize::from(u16::from_le_bytes(*v))) + && let Some(fields) = body.get(offset.saturating_add(2)..) + { + // A corrupt count or final entry does not hide earlier payload offsets. Each + // entry has a 2-byte tag followed by a 4-byte offset and 4-byte length. + for field in fields.chunks(10).take(count) { + if let Some(value) = field.get(2..6).and_then(|v| v.first_chunk::<4>()) + && let Some(length) = field.get(6..10).and_then(|v| v.first_chunk::<4>()) + && u32::from_le_bytes(*length) != 0 + && let Some(payload) = metadata_offset(body, u32::from_le_bytes(*value) as usize, first_pixel) + { + end = end.min(payload); + } + } + } + } + Ok(end) +} + /// Decodes a Targa file to straight-alpha RGBA8, top row first. pub fn decode(bytes: &[u8], limits: &Limits) -> Result { let err = Error::Malformed; @@ -208,13 +309,18 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result { } else { None }; - let mut at = HEADER + id_len; - if let Some(l) = map_entry { - let end = at + map_len * l.bytes(); - let map = bytes.get(at..end).ok_or(err("truncated colour map"))?; - palette = map.chunks_exact(l.bytes()).map(|e| l.rgba(e)).collect(); - at = end; + let map_start = HEADER + id_len; + let first_pixel = match map_entry { + Some(layout) => map_start.checked_add(map_len * layout.bytes()).ok_or(err("colour map"))?, + None => map_start, + }; + let end = image_data_end(bytes, first_pixel)?; + let bytes = bytes.get(..end).ok_or(err("truncated image data"))?; + if let Some(layout) = map_entry { + let map = bytes.get(map_start..first_pixel).ok_or(err("truncated colour map"))?; + palette = map.chunks_exact(layout.bytes()).map(|entry| layout.rgba(entry)).collect(); } + let at = first_pixel; let (stored_as, mapped) = match kind & 7 { 1 => { if map_type != 1 || !matches!(depth, 8 | 16) { diff --git a/crates/tga/src/metadata_tests.rs b/crates/tga/src/metadata_tests.rs new file mode 100644 index 000000000..a5c6c0b12 --- /dev/null +++ b/crates/tga/src/metadata_tests.rs @@ -0,0 +1,424 @@ +//! Metadata-boundary regressions ported from FilmCraft #1932 (nuclearspike). +use super::*; +fn header(kind: u8, w: u16, h: u16, depth: u8, descriptor: u8) -> Vec { + let mut b = vec![0, 0, kind, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + b.extend_from_slice(&w.to_le_bytes()); + b.extend_from_slice(&h.to_le_bytes()); + b.extend_from_slice(&[depth, descriptor]); + b +} +fn dec(bytes: &[u8]) -> Result { + decode(bytes, &Limits::default()) +} +#[test] +fn legacy_pixels_that_end_in_signature_are_not_a_footer_before_header() { + for prefix in [0usize, 7] { + let width = (prefix + SIGNATURE.len()) as u16; + let mut file = header(3, width, 1, 8, 0x20); + file.extend(vec![0; prefix]); + file.extend_from_slice(SIGNATURE); + let image = dec(&file).unwrap(); + assert_eq!((image.width, image.height), (u32::from(width), 1)); + let pixels: Vec = std::iter::repeat_n(0, prefix).chain(SIGNATURE.iter().copied()).flat_map(|gray| [gray, gray, gray, 255]).collect(); + assert_eq!(image.rgba, pixels); + let source = dec(&file).unwrap(); + assert_eq!(source.rgba, pixels); + } +} + +#[test] +fn short_extension_followed_by_a_developer_payload_keeps_the_pixels() { + // a 482-byte extension whose size field still says 495, then a developer payload whose + // first bytes land where a full extension keeps its colour-correction offset, then the + // directory that points back at that payload + let mut file = header(2, 1, 1, 24, 0x20); + file.extend_from_slice(&[10, 20, 30]); + let extension = file.len() as u32; + let mut area = vec![0; 482]; + area[..2].copy_from_slice(&495u16.to_le_bytes()); + file.extend_from_slice(&area); + let payload = file.len() as u32; + file.extend_from_slice(&18u32.to_le_bytes()); + file.extend_from_slice(&[0; 14]); + let directory = file.len() as u32; + file.extend_from_slice(&1u16.to_le_bytes()); + file.extend_from_slice(&0u16.to_le_bytes()); + file.extend_from_slice(&payload.to_le_bytes()); + file.extend_from_slice(&18u32.to_le_bytes()); + file.extend_from_slice(&extension.to_le_bytes()); + file.extend_from_slice(&directory.to_le_bytes()); + file.extend_from_slice(SIGNATURE); + let source = dec(&file).expect("the image decodes"); + assert_eq!((source.width, source.height), (1, 1)); + assert_eq!(source.rgba, vec![30, 20, 10, 255]); +} + +#[test] +fn a_footer_without_a_directory_does_not_read_the_header_as_one() { + // no developer directory (offset 0). Read as one, the header's three-byte image ID + // length is an entry count, and the third "entry" is the first words of a colour + // correction table that sits right after a short pixel area; the extension points at + // that table, so the image is incomplete and must stay so. + let mut file = header(2, 2, 1, 24, 0x20); + file[0] = 3; + file.extend_from_slice(&[7, 8, 9]); + file.extend_from_slice(&[0, 0, 255]); + let table = file.len() as u32; + let mut words = vec![0; 2048]; + words[..4].copy_from_slice(&2074u32.to_le_bytes()); + words[4..8].copy_from_slice(&1u32.to_le_bytes()); + file.extend_from_slice(&words); + let extension = file.len() as u32; + let mut area = vec![0; 495]; + area[..2].copy_from_slice(&495u16.to_le_bytes()); + area[482..486].copy_from_slice(&table.to_le_bytes()); + file.extend_from_slice(&area); + file.extend_from_slice(&extension.to_le_bytes()); + file.extend_from_slice(&0u32.to_le_bytes()); + file.extend_from_slice(SIGNATURE); + let decoded = dec(&file); + assert!(decoded.is_err(), "the second pixel is missing"); +} + +#[test] +fn short_extension_followed_by_a_developer_directory_keeps_the_pixels() { + // a complete 1x1 image, a 482-byte extension (its size says so) and right after it a + // developer directory whose entry's length lands where a full extension keeps its + // scan-line table offset; reading it as one would move the image end into the header + let mut file = header(2, 1, 1, 24, 0x20); + file.extend_from_slice(&[10, 20, 30]); + let extension = file.len() as u32; + let mut area = vec![0; 482]; + area[..2].copy_from_slice(&482u16.to_le_bytes()); + file.extend_from_slice(&area); + let directory = file.len() as u32; + let payload = directory + 2 + 10; + file.extend_from_slice(&1u16.to_le_bytes()); + file.extend_from_slice(&0u16.to_le_bytes()); + file.extend_from_slice(&payload.to_le_bytes()); + file.extend_from_slice(&18u32.to_le_bytes()); + file.extend_from_slice(&[0; 18]); + file.extend_from_slice(&extension.to_le_bytes()); + file.extend_from_slice(&directory.to_le_bytes()); + file.extend_from_slice(SIGNATURE); + let source = dec(&file).expect("the image decodes"); + assert_eq!((source.width, source.height), (1, 1)); +} + +#[test] +fn importing_truncated_pixels_does_not_consume_tga_footer() { + for (kind, data) in [(2, vec![0, 0, 255]), (10, vec![0x80, 0, 0, 255])] { + for metadata in [None, Some(0usize), Some(1)] { + let mut file = header(kind, 2, 1, 24, 0x20); + file.extend_from_slice(&data); // only the first of two pixels + let mut offsets = [0u8; 8]; + if let Some(field) = metadata { + let offset = file.len() as u32; + offsets[field * 4..field * 4 + 4].copy_from_slice(&offset.to_le_bytes()); + let mut area = vec![0; 495]; + if field == 0 { + area[..2].copy_from_slice(&495u16.to_le_bytes()); + } + file.extend_from_slice(&area); // optional metadata is not pixel data + } + file.extend_from_slice(&offsets); + file.extend_from_slice(SIGNATURE); + let result = dec(&file); + assert!(matches!(result, Err(_)), "kind {kind}, metadata {metadata:?}: metadata is not a second pixel"); + } + } + for kind in [1, 9] { + let mut file = header(kind, 1, 1, 8, 0x20); + file[1] = 1; + file[5] = 1; + file[7] = 24; + file.extend_from_slice(&[0, 0]); // missing third palette byte and the index + file.extend_from_slice(&[0; 8]); + file.extend_from_slice(SIGNATURE); + let result = dec(&file); + assert!(matches!(result, Err(_)), "kind {kind}: the footer is not colour-map data"); + } +} + +#[test] +fn complete_tga_footer_and_metadata_do_not_change_pixels() { + for metadata in [None, Some(0usize), Some(1)] { + let mut file = header(2, 1, 1, 24, 0x20); + file.extend_from_slice(&[0, 0, 255]); + let mut offsets = [0u8; 8]; + if let Some(field) = metadata { + let offset = file.len() as u32; + offsets[field * 4..field * 4 + 4].copy_from_slice(&offset.to_le_bytes()); + let mut area = vec![0; 495]; + if field == 0 { + area[..2].copy_from_slice(&495u16.to_le_bytes()); + } + file.extend_from_slice(&area); + } + file.extend_from_slice(&offsets); + file.extend_from_slice(SIGNATURE); + let source = dec(&file).unwrap(); + assert_eq!(source.rgba, [255, 0, 0, 255]); + } +} + +fn preceding_metadata(complete: bool, metadata: usize) -> Vec { + let mut file = header(2, if complete { 1 } else { 2 }, 1, 24, 0x20); + file.extend_from_slice(&[0, 0, 255]); + let payload_offset = file.len() as u32; + let mut offsets = [0u8; 8]; + if metadata == 0 { + file.extend_from_slice(&[0, 255, 0]); + let directory_offset = file.len() as u32; + file.extend_from_slice(&1u16.to_le_bytes()); + file.extend_from_slice(&1u16.to_le_bytes()); + file.extend_from_slice(&payload_offset.to_le_bytes()); + file.extend_from_slice(&3u32.to_le_bytes()); + offsets[4..].copy_from_slice(&directory_offset.to_le_bytes()); + } else { + match metadata { + 1 => file.extend_from_slice(&[0; 2048]), + 2 => file.extend_from_slice(&[1, 1, 0, 255, 0]), + 3 => file.extend_from_slice(&18u32.to_le_bytes()), + _ => unreachable!(), + } + let extension_offset = file.len() as u32; + let mut extension = [0; 495]; + extension[..2].copy_from_slice(&495u16.to_le_bytes()); + let field = [0, 482, 486, 490][metadata]; + extension[field..field + 4].copy_from_slice(&payload_offset.to_le_bytes()); + file.extend_from_slice(&extension); + offsets[..4].copy_from_slice(&extension_offset.to_le_bytes()); + } + file.extend_from_slice(&offsets); + file.extend_from_slice(SIGNATURE); + file +} + +#[test] +fn preceding_metadata_cannot_supply_missing_pixels() { + let mut accepted = Vec::new(); + for metadata in 0..4 { + let result = dec(&preceding_metadata(false, metadata)); + if !matches!(result, Err(_)) { + accepted.push(metadata); + } + } + assert!(accepted.is_empty(), "metadata payloads supplied missing pixels: {accepted:?}"); +} + +#[test] +fn complete_pixels_before_metadata_keep_their_colour() { + for metadata in 0..4 { + let source = dec(&preceding_metadata(true, metadata)).unwrap(); + assert_eq!(source.rgba, [255, 0, 0, 255], "metadata {metadata}"); + } + let mut file = preceding_metadata(true, 1); + let footer = file.len() - SIGNATURE.len() - 8; + let extension = u32::from_le_bytes(file[footer..footer + 4].try_into().unwrap()) as usize; + file[extension..extension + 2].copy_from_slice(&496u16.to_le_bytes()); + file.insert(footer, 0); + let source = dec(&file).unwrap(); + assert_eq!(source.rgba, [255, 0, 0, 255], "larger complete extensions preserve pixels"); +} + +#[test] +fn malformed_optional_metadata_keeps_complete_pixels_readable() { + let accept = |file: Vec| { + let source = dec(&file).unwrap(); + assert_eq!(source.rgba, [255, 0, 0, 255]); + }; + for field in [0, 4] { + let mut file = preceding_metadata(true, 0); + let footer = file.len() - SIGNATURE.len() - 8; + file[footer + field..footer + field + 4].copy_from_slice(&u32::MAX.to_le_bytes()); + accept(file); + } + for metadata in 1..4 { + let mut file = preceding_metadata(true, metadata); + let footer = file.len() - SIGNATURE.len() - 8; + let extension = u32::from_le_bytes(file[footer..footer + 4].try_into().unwrap()) as usize; + let field = [0, 482, 486, 490][metadata]; + file[extension + field..extension + field + 4].copy_from_slice(&u32::MAX.to_le_bytes()); + accept(file); + } + let mut file = preceding_metadata(true, 0); + let footer = file.len() - SIGNATURE.len() - 8; + let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; + file.drain(directory + 2..footer); + accept(file); + let mut file = preceding_metadata(true, 0); + let footer = file.len() - SIGNATURE.len() - 8; + let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; + file[directory + 8..directory + 12].copy_from_slice(&u32::MAX.to_le_bytes()); + accept(file); + let mut file = preceding_metadata(true, 0); + let footer = file.len() - SIGNATURE.len() - 8; + let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; + file[directory..directory + 2].copy_from_slice(&2u16.to_le_bytes()); + accept(file); + // A zero-length entry cannot mark a payload boundary, even if its offset overlaps pixels. + let mut file = preceding_metadata(true, 0); + let footer = file.len() - SIGNATURE.len() - 8; + let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; + file[directory + 4..directory + 8].copy_from_slice(&19u32.to_le_bytes()); + file[directory + 8..directory + 12].copy_from_slice(&0u32.to_le_bytes()); + accept(file); + let mut file = preceding_metadata(true, 2); + file[21..23].copy_from_slice(&[255, 255]); + accept(file); + let mut file = preceding_metadata(true, 2); + let footer = file.len() - SIGNATURE.len() - 8; + let extension = u32::from_le_bytes(file[footer..footer + 4].try_into().unwrap()) as usize; + file[extension..extension + 2].copy_from_slice(&494u16.to_le_bytes()); + accept(file); + let mut file = preceding_metadata(true, 2); + let footer = file.len() - SIGNATURE.len() - 8; + file.remove(footer - 1); // extension is physically short, but its postage offset remains + accept(file); +} + +#[test] +fn malformed_metadata_offsets_inside_id_or_palette_keep_complete_pixels() { + let mut file = header(1, 1, 1, 8, 0x20); + file[0] = 4; // image ID length + file[1] = 1; // colour map present + file[5..7].copy_from_slice(&1u16.to_le_bytes()); + file[7] = 24; // one BGR palette entry + file.extend_from_slice(&[7, 8, 9, 10]); // image ID + file.extend_from_slice(&[0, 0, 255]); // red palette entry + file.push(0); // palette index + for (field, offset) in [(0, HEADER + 1), (4, HEADER + 4 + 1)] { + let mut candidate = file.clone(); + let mut footer_offsets = [0u8; 8]; + footer_offsets[field..field + 4].copy_from_slice(&(offset as u32).to_le_bytes()); + candidate.extend_from_slice(&footer_offsets); + candidate.extend_from_slice(SIGNATURE); + let image = dec(&candidate).unwrap(); + assert_eq!(image.rgba, [255, 0, 0, 255], "footer field {field}"); + } +} + +#[test] +fn malformed_optional_metadata_cannot_supply_missing_pixels() { + let mut file = preceding_metadata(false, 0); + let footer = file.len() - SIGNATURE.len() - 8; + let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; + file[directory + 8..directory + 12].copy_from_slice(&u32::MAX.to_le_bytes()); + assert!(matches!(dec(&file), Err(_))); + + // The declared entry count exceeds the bytes before the footer, but the first entry's + // payload still precedes the directory and cannot be used as a second pixel. + let mut file = preceding_metadata(false, 0); + let footer = file.len() - SIGNATURE.len() - 8; + let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; + file[directory..directory + 2].copy_from_slice(&2u16.to_le_bytes()); + assert!(matches!(dec(&file), Err(_))); + + let mut file = preceding_metadata(false, 2); + let footer = file.len() - SIGNATURE.len() - 8; + let extension = u32::from_le_bytes(file[footer..footer + 4].try_into().unwrap()) as usize; + file[extension..extension + 2].copy_from_slice(&494u16.to_le_bytes()); + assert!(matches!(dec(&file), Err(_))); + let mut file = preceding_metadata(false, 2); + let footer = file.len() - SIGNATURE.len() - 8; + file.remove(footer - 1); + assert!(matches!(dec(&file), Err(_))); +} + +#[test] +fn valid_developer_directory_with_overlapping_payload_rejects_pixels() { + let mut file = preceding_metadata(true, 0); + let footer = file.len() - SIGNATURE.len() - 8; + let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; + file[directory..directory + 2].copy_from_slice(&2u16.to_le_bytes()); + let mut extra = [0u8; 10]; + extra[..2].copy_from_slice(&2u16.to_le_bytes()); + extra[2..6].copy_from_slice(&(HEADER as u32).to_le_bytes()); + extra[6..10].copy_from_slice(&1u32.to_le_bytes()); + file.splice(footer..footer, extra); + let moved_footer = file.len() - SIGNATURE.len() - 8; + assert_eq!(u32::from_le_bytes(file[moved_footer + 4..moved_footer + 8].try_into().unwrap()), directory as u32); + assert_eq!(u16::from_le_bytes(file[directory..directory + 2].try_into().unwrap()), 2); + assert_eq!(&file[directory + 12..directory + 22], &extra); + assert!(matches!(dec(&file), Err(_))); +} + +#[test] +fn nonempty_developer_reference_inside_pixels_rejects_the_whole_image() { + let mut file = header(2, 2, 1, 24, 0x20); + file.extend_from_slice(&[0, 0, 255, 0, 255, 0]); + let directory = file.len() as u32; + file.extend_from_slice(&1u16.to_le_bytes()); + file.extend_from_slice(&1u16.to_le_bytes()); + file.extend_from_slice(&(HEADER as u32 + 3).to_le_bytes()); + file.extend_from_slice(&1u32.to_le_bytes()); + file.extend_from_slice(&0u32.to_le_bytes()); + file.extend_from_slice(&directory.to_le_bytes()); + file.extend_from_slice(SIGNATURE); + assert!(matches!(dec(&file), Err(_)), "an overlapping reference must not return a partial image"); +} + +#[test] +fn inflated_developer_count_scans_the_next_chunk_as_an_entry_and_rejects_its_pixel_payload() { + // a directory claiming two entries over one real entry: the ten bytes after it, scanned as + // the second entry, name a payload inside the pixels, which is refused like any other + let mut file = header(2, 2, 1, 24, 0x20); + file.extend_from_slice(&[0, 0, 255, 0, 255, 0]); + let directory = file.len() as u32; + file.extend_from_slice(&2u16.to_le_bytes()); + file.extend_from_slice(&1u16.to_le_bytes()); + file.extend_from_slice(&(directory + 22).to_le_bytes()); + file.extend_from_slice(&0u32.to_le_bytes()); + file.extend_from_slice(&2u16.to_le_bytes()); + file.extend_from_slice(&(HEADER as u32 + 3).to_le_bytes()); + file.extend_from_slice(&1u32.to_le_bytes()); + file.extend_from_slice(&0u32.to_le_bytes()); + file.extend_from_slice(&directory.to_le_bytes()); + file.extend_from_slice(SIGNATURE); + assert!(matches!(dec(&file), Err(_)), "a scanned entry's payload inside the pixels is refused"); +} + +#[test] +fn legacy_pixels_that_end_in_signature_at_or_after_the_header_are_read_as_a_footer() { + // a footerless 36×1 grayscale image whose last 26 bytes happen to be eight zeros and the + // signature: the putative trailer begins at byte 28, so it is taken for a footer and the + // image, left with 10 pixel bytes, is rejected as truncated (the ambiguity the body states) + let prefix = 18usize; + let width = (prefix + SIGNATURE.len()) as u16; + let mut file = header(3, width, 1, 8, 0x20); + file.extend(vec![0; prefix]); + file.extend_from_slice(SIGNATURE); + assert!(matches!(dec(&file), Err(_))); +} + +#[test] +fn mutated_tga_footer_files_never_panic() { + let mut file = header(2, 2, 1, 24, 0x20); + file.extend_from_slice(&[0, 0, 255, 0, 255, 0]); + file.extend_from_slice(&[0; 8]); + file.extend_from_slice(SIGNATURE); + for end in 0..file.len() { + assert!(std::panic::catch_unwind(|| dec(&file[..end])).is_ok(), "truncation at {end}"); + } + for at in 0..file.len() { + let mut mutated = file.clone(); + mutated[at] ^= 0xFF; + assert!(std::panic::catch_unwind(|| dec(&mutated)).is_ok(), "mutation at {at}"); + } + for metadata in 0..4 { + let file = preceding_metadata(true, metadata); + assert!(dec(&file).is_ok()); + let footer = file.len() - SIGNATURE.len() - 8; + for end in 0..footer { + let mut truncated = file[..end].to_vec(); + truncated.extend_from_slice(&file[footer..]); + assert!(std::panic::catch_unwind(|| dec(&truncated)).is_ok(), "metadata {metadata}, footer-preserving truncation at {end}"); + } + for at in 0..file.len() { + let mut mutated = file.clone(); + mutated[at] ^= 0xFF; + assert!(std::panic::catch_unwind(|| dec(&mutated)).is_ok(), "metadata {metadata}, mutation at {at}"); + } + } +} From b6b33b6096a247514f5cbd1741633913e7261e91 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:40:41 -0500 Subject: [PATCH 089/382] tga: record original metadata-boundary source attribution --- ATTRIBUTION.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index c087ecda1..e6f928645 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -99,3 +99,5 @@ and the exact transfer revision are recorded in each vendored crate's SOURCE.jso ## Binary Apple property lists `crates/plist` is extracted from `storytold/craft-anything` (`crates/formats/src/plist.rs` and checked byte reads), at source main `88d1d9cac852aec1c7fd97886db451e005e49d2a`. MIT OR Apache-2.0; source license texts are retained in the crate. Primary import Git authors preserve Brandon Thomas, BFlat, RRFZ and Afloat. Regression imports preserve BFlat. XML, JSON projection, calendar formatting and app policy were not imported into the public API. + +`crates/tga/src/metadata_tests.rs` and metadata-boundary helpers in `crates/tga/src/lib.rs` are adapted from nuclearspike's FilmCraft #1932 at `e7842f76f887005c460c64a8ab51d59d086e6f27` (MIT OR Apache-2.0). Synthetic fixtures are original contributor test data; primary Git author retained. From 424a2dc2be7a90467bca0f62b2f161b6bed57bb0 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 14:41:14 +0000 Subject: [PATCH 090/382] Share streaming gzip writer with stored segments --- Cargo.lock | 21 ++++--- Cargo.toml | 1 + crates/gzip/Cargo.toml | 14 +++++ crates/gzip/src/lib.rs | 119 ++++++++++++++++++++++++++++++++++++ crates/gzip/tests/writer.rs | 77 +++++++++++++++++++++++ 5 files changed, 225 insertions(+), 7 deletions(-) create mode 100644 crates/gzip/Cargo.toml create mode 100644 crates/gzip/src/lib.rs create mode 100644 crates/gzip/tests/writer.rs diff --git a/Cargo.lock b/Cargo.lock index c396f1978..222e4679d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1843,6 +1843,13 @@ dependencies = [ "image", ] +[[package]] +name = "craft-gzip" +version = "0.1.0" +dependencies = [ + "flate2", +] + [[package]] name = "craft-hdr" version = "0.1.0" @@ -2375,13 +2382,6 @@ dependencies = [ "thiserror 2.0.21", ] -[[package]] -name = "craft-plist" -version = "0.1.0" -dependencies = [ - "thiserror 2.0.21", -] - [[package]] name = "craft-platform" version = "0.1.0" @@ -2399,6 +2399,13 @@ dependencies = [ "zbus", ] +[[package]] +name = "craft-plist" +version = "0.1.0" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-plotter" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index 4985d19d0..c3751dacb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,6 +38,7 @@ hayro-syntax = { version = "=0.7.2", default-features = false, features = ["std" bytemuck = "1" kurbo = "0.13" thiserror = "2" +craft-gzip = { path = "crates/gzip" } craft-aaf = { path = "crates/aaf" } craft-atomic = { path = "crates/atomic" } craft-captions = { path = "crates/captions" } diff --git a/crates/gzip/Cargo.toml b/crates/gzip/Cargo.toml new file mode 100644 index 000000000..3d4f04603 --- /dev/null +++ b/crates/gzip/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "craft-gzip" +description = "Streaming gzip writer with stored and compressed segments" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +flate2 = { version = "1", default-features = false, features = ["rust_backend"] } diff --git a/crates/gzip/src/lib.rs b/crates/gzip/src/lib.rs new file mode 100644 index 000000000..33f2a5ac1 --- /dev/null +++ b/crates/gzip/src/lib.rs @@ -0,0 +1,119 @@ +//! Streaming gzip output with optional stored segments. +//! +//! Copyright (c) 2026 ArtCraft Team and the VectorCraft contributors. +//! Extracted from VectorCraft, licensed under MIT OR Apache-2.0. +//! +//! `flush` does not emit a deflate block; call [`Gz::finish`] to complete and flush the +//! stream. After an I/O error, discard the writer: the output may be incomplete. +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] + +use flate2::{Compress, Compression, Crc, FlushCompress, Status}; +use std::io::{self, Write}; + +/// Bytes of compressed output gathered before they go to the writer. +const OUT_CHUNK: usize = 64 << 10; + +/// A gzip stream, written as [`flate2::write::GzEncoder`] at the default level writes it (the +/// same header and the same data; the deflate blocks are the same too where flate2 deflates with +/// miniz_oxide, not with zlib-rs, which writes them by how the data is fed), except that data which +/// is compressed already ([`Gz::packed`]) is stored as it is: the default level spends a second +/// or more per photo on it for next to nothing, and makes it slower to unpack. Where the level +/// changes the deflate blocks so far end with a sync flush and a fresh compressor writes on, +/// which makes one valid deflate stream that every reader unpacks. +pub struct Gz { + out: W, + deflate: Compress, + /// What `deflate` writes: stored blocks (packed data), else the default level. + stored: bool, + crc: Crc, + buf: Vec, + /// Bytes written (unpacked). + total: u64, +} + +impl Gz { + /// Write a gzip header and construct a writer. + pub fn new(mut out: W) -> io::Result { + // flate2's header for the default level: no name, no time, unknown OS. + out.write_all(&[0x1f, 0x8b, 8, 0, 0, 0, 0, 0, 0, 255])?; + Ok(Self { + out, + deflate: Compress::new(Compression::default(), false), + stored: false, + crc: Crc::new(), + buf: Vec::with_capacity(OUT_CHUNK), + total: 0, + }) + } + + /// Run the compressor over `input` with `flush` until it has taken it all (and, flushing, + /// written everything out). + fn deflate(&mut self, mut input: &[u8], flush: FlushCompress) -> io::Result<()> { + loop { + if self.buf.len() == self.buf.capacity() { + self.out.write_all(&self.buf)?; + self.buf.clear(); + } + let (before_in, before_out) = (self.deflate.total_in(), self.deflate.total_out()); + let status = self.deflate.compress_vec(input, &mut self.buf, flush).map_err(io::Error::other)?; + let taken = usize::try_from(self.deflate.total_in() - before_in).unwrap_or(input.len()).min(input.len()); + input = input.get(taken..).unwrap_or_default(); + let made = self.deflate.total_out() - before_out; + let full = self.buf.len() == self.buf.capacity(); + match flush { + FlushCompress::None if input.is_empty() => return Ok(()), + FlushCompress::Finish if status == Status::StreamEnd => return Ok(()), + // A flush is done once it left room in the output. + FlushCompress::Sync if input.is_empty() && !full => return Ok(()), + _ => {} + } + if taken == 0 && made == 0 && !full { + return Err(io::Error::other("the compressor made no progress")); + } + } + } + + /// Return the number of uncompressed bytes supplied. + pub fn written(&self) -> u64 { + self.total + } + + /// What is written next is compressed already (stored as it is), or not (compressed at the + /// default level). + pub fn packed(&mut self, packed: bool) -> io::Result<()> { + if packed == self.stored { + return Ok(()); + } + self.deflate(&[], FlushCompress::Sync)?; + self.deflate = Compress::new(if packed { Compression::none() } else { Compression::default() }, false); + self.stored = packed; + Ok(()) + } + + /// Complete the gzip trailer and flush the underlying writer. + pub fn finish(mut self) -> io::Result<()> { + self.deflate(&[], FlushCompress::Finish)?; + self.out.write_all(&self.buf)?; + self.out.write_all(&self.crc.sum().to_le_bytes())?; + self.out.write_all(&self.crc.amount().to_le_bytes())?; + self.out.flush() + } +} + +impl Write for Gz { + fn write(&mut self, buf: &[u8]) -> io::Result { + self.write_all(buf)?; + Ok(buf.len()) + } + + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + self.total = self.total.checked_add(buf.len() as u64).ok_or_else(|| io::Error::other("uncompressed byte count overflow"))?; + self.crc.update(buf); + self.deflate(buf, FlushCompress::None) + } + + fn flush(&mut self) -> io::Result<()> { + // Flushing would end a deflate block: the stream is flushed when it is finished. + Ok(()) + } +} diff --git a/crates/gzip/tests/writer.rs b/crates/gzip/tests/writer.rs new file mode 100644 index 000000000..38981ad0a --- /dev/null +++ b/crates/gzip/tests/writer.rs @@ -0,0 +1,77 @@ +use std::io::{self, Read, Write}; + +use craft_gzip::Gz; +use flate2::{Compression, read::GzDecoder, write::GzEncoder}; + +fn decode(bytes: &[u8]) -> Vec { + let mut result = Vec::new(); + GzDecoder::new(bytes).read_to_end(&mut result).unwrap(); + result +} + +#[test] +fn matches_flate2_without_mode_changes() { + let data = b"The quick brown fox jumps over the lazy dog. ".repeat(10000); + let mut expected = GzEncoder::new(Vec::new(), Compression::default()); + let mut actual = Vec::new(); + { + let mut gz = Gz::new(&mut actual).unwrap(); + for chunk in data.chunks(131) { + expected.write_all(chunk).unwrap(); + gz.write_all(chunk).unwrap(); + } + assert_eq!(gz.written(), data.len() as u64); + gz.finish().unwrap(); + } + assert_eq!(actual, expected.finish().unwrap()); + assert_eq!(decode(&actual), data); +} + +#[test] +fn mixed_segments_round_trip_and_stored_bytes_remain_uncompressed() { + let plain = b"repeat me ".repeat(20000); + let packed: Vec = (0..200_000).map(|i| (i * 31) as u8).collect(); + let mut bytes = Vec::new(); + { + let mut gz = Gz::new(&mut bytes).unwrap(); + gz.write_all(&plain).unwrap(); + gz.packed(true).unwrap(); + gz.packed(true).unwrap(); + gz.write_all(&packed).unwrap(); + gz.packed(false).unwrap(); + gz.write_all(&plain).unwrap(); + assert_eq!(gz.written(), (plain.len() * 2 + packed.len()) as u64); + gz.finish().unwrap(); + } + let expected = [plain.as_slice(), packed.as_slice(), plain.as_slice()].concat(); + assert_eq!(decode(&bytes), expected); + assert!(bytes.windows(1024).any(|window| window == &packed[..1024])); + assert!(bytes.len() < expected.len()); +} + +struct FailAfter { + remaining: usize, +} +impl Write for FailAfter { + fn write(&mut self, data: &[u8]) -> io::Result { + if self.remaining == 0 { + return Err(io::Error::other("injected failure")); + } + let n = self.remaining.min(data.len()); + self.remaining -= n; + Ok(n) + } + fn flush(&mut self) -> io::Result<()> { + Err(io::Error::other("injected flush failure")) + } +} + +#[test] +fn propagates_header_body_and_flush_failures() { + assert!(Gz::new(FailAfter { remaining: 0 }).is_err()); + let mut body = Gz::new(FailAfter { remaining: 10 }).unwrap(); + body.packed(true).unwrap(); + assert!(body.write_all(&vec![42; 200_000]).is_err()); + let empty = Gz::new(FailAfter { remaining: usize::MAX }).unwrap(); + assert_eq!(empty.finish().unwrap_err().to_string(), "injected flush failure"); +} From cab96afd08c3b68073340d2162657ccc989bd751 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:43:27 -0500 Subject: [PATCH 091/382] cms: keep public v2 helper before test module --- crates/cms/src/builtin.rs | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/crates/cms/src/builtin.rs b/crates/cms/src/builtin.rs index e62faa907..5a8b03228 100644 --- a/crates/cms/src/builtin.rs +++ b/crates/cms/src/builtin.rs @@ -424,6 +424,18 @@ fn shipped_cmyk(bytes: &[u8], b: Builtin) -> Profile { }) } +/// Generates the compact ICC v2.1 sRGB matrix/TRC profile used by PDFCraft. +/// +/// Unlike [`Builtin::Srgb`]'s v4 profile, this uses a 1024-sample tone curve and +/// v2 `desc`/`text` tags for consumers that require a v2 output intent. The legacy +/// description `sRGB (PdfCraft)` is retained to preserve existing document bytes. +/// The generated profile contains no external assets; callers choose where it is +/// appropriate (including their own PDF/A conformance policy). +/// All sizes are fixed; no input-controlled allocation or recursion is involved. +pub fn srgb_v2() -> Vec { + crate::builtin_v2::srgb() +} + #[cfg(test)] mod tests { use super::*; @@ -450,15 +462,3 @@ mod tests { assert!(cicp_rgb(u16::MAX, u16::MAX, true).is_none()); } } - -/// Generates the compact ICC v2.1 sRGB matrix/TRC profile used by PDFCraft. -/// -/// Unlike [`Builtin::Srgb`]'s v4 profile, this uses a 1024-sample tone curve and -/// v2 `desc`/`text` tags for consumers that require a v2 output intent. The legacy -/// description `sRGB (PdfCraft)` is retained to preserve existing document bytes. -/// The generated profile contains no external assets; callers choose where it is -/// appropriate (including their own PDF/A conformance policy). -/// All sizes are fixed; no input-controlled allocation or recursion is involved. -pub fn srgb_v2() -> Vec { - crate::builtin_v2::srgb() -} From 0cdda6e15d274847962bf1cb98a91d1a3a9b5cbf Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 14:44:38 +0000 Subject: [PATCH 092/382] Share VectorCraft streaming envelope helpers --- Cargo.lock | 15 +- crates/vectorcraft-format/Cargo.toml | 3 + crates/vectorcraft-format/src/lib.rs | 13 +- crates/vectorcraft-format/src/stream.rs | 242 ++++++++++++++++++++++ crates/vectorcraft-format/tests/stream.rs | 83 ++++++++ 5 files changed, 348 insertions(+), 8 deletions(-) create mode 100644 crates/vectorcraft-format/src/stream.rs create mode 100644 crates/vectorcraft-format/tests/stream.rs diff --git a/Cargo.lock b/Cargo.lock index c396f1978..759f68168 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2375,13 +2375,6 @@ dependencies = [ "thiserror 2.0.21", ] -[[package]] -name = "craft-plist" -version = "0.1.0" -dependencies = [ - "thiserror 2.0.21", -] - [[package]] name = "craft-platform" version = "0.1.0" @@ -2399,6 +2392,13 @@ dependencies = [ "zbus", ] +[[package]] +name = "craft-plist" +version = "0.1.0" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "craft-plotter" version = "0.1.0" @@ -2841,6 +2841,7 @@ name = "craft-vectorcraft-format" version = "0.1.0" dependencies = [ "flate2", + "proptest", "serde", "serde_json", "thiserror 2.0.21", diff --git a/crates/vectorcraft-format/Cargo.toml b/crates/vectorcraft-format/Cargo.toml index e85d90886..c10435289 100644 --- a/crates/vectorcraft-format/Cargo.toml +++ b/crates/vectorcraft-format/Cargo.toml @@ -15,3 +15,6 @@ flate2 = { version = "1", default-features = false, features = ["rust_backend"] serde = { workspace = true } serde_json = { workspace = true } thiserror = { workspace = true } + +[dev-dependencies] +proptest = { workspace = true } diff --git a/crates/vectorcraft-format/src/lib.rs b/crates/vectorcraft-format/src/lib.rs index 051c31a70..b180c046c 100644 --- a/crates/vectorcraft-format/src/lib.rs +++ b/crates/vectorcraft-format/src/lib.rs @@ -34,6 +34,7 @@ //! [`sniff`] reads: a reader of a compressed file decompresses it with its own limits first. pub mod base64; +pub mod stream; use std::collections::{BTreeMap, HashMap}; use std::fmt; @@ -769,10 +770,20 @@ impl<'a> Tail<'a> { /// Write what follows the JSON: [`BLOB_MAGIC`] and the entries, or nothing when there are none. pub fn write_to(&self, mut w: impl Write) -> io::Result<()> { + self.write_to_with(&mut w, |_, _| Ok(())) + } + + /// Write the marker and parts, calling `before_part` before each payload. A compressed + /// writer can use the MIME type to switch between compressed and stored deflate blocks. + pub fn write_to_with(&self, mut w: W, mut before_part: impl FnMut(&mut W, &str) -> io::Result<()>) -> io::Result<()> { if self.parts.is_empty() { return Ok(()); } w.write_all(BLOB_MAGIC)?; - self.parts.iter().try_for_each(|p| w.write_all(p.bytes)) + for part in &self.parts { + before_part(&mut w, &part.mime)?; + w.write_all(part.bytes)?; + } + Ok(()) } } diff --git a/crates/vectorcraft-format/src/stream.rs b/crates/vectorcraft-format/src/stream.rs new file mode 100644 index 000000000..8f205a15d --- /dev/null +++ b/crates/vectorcraft-format/src/stream.rs @@ -0,0 +1,242 @@ +//! Streaming helpers for the native JSON envelope. +//! +//! Copyright (c) 2026 ArtCraft Team and the VectorCraft contributors. +//! Extracted from VectorCraft, licensed under MIT OR Apache-2.0. + +use serde::Serialize; +use std::collections::HashSet; +use std::io::{self, Write}; + +/// Indents JSON text written through it one level (two spaces after each newline), as a member +/// of the file's top-level object; newlines only occur between tokens, inside strings they are +/// escaped. +pub struct Indent { + pub inner: W, + pub on: bool, +} + +impl Write for Indent { + fn write(&mut self, buf: &[u8]) -> io::Result { + self.write_all(buf)?; + Ok(buf.len()) + } + + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + if !self.on { + return self.inner.write_all(buf); + } + let mut lines = buf.split(|&b| b == b'\n'); + self.inner.write_all(lines.next().unwrap_or_default())?; + for line in lines { + self.inner.write_all(b"\n ")?; + self.inner.write_all(line)?; + } + Ok(()) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.flush() + } +} + +/// The member that names an image. +const TAG: &[u8] = b"\"key\":"; + +/// Passes JSON text through, collecting the string values of every `"key": "…"` member at any +/// depth (what the images a document uses are named by). Quotes inside JSON strings are escaped, +/// so every match is a real member. +pub struct KeyScan { + pub inner: W, + pub keys: HashSet, + /// Looking for keys (else it only passes the text on). + pub active: bool, + /// How much of [`TAG`] the last bytes matched. + matched: usize, + /// Right after a tag: skipping whitespace to its value. + after_tag: bool, + /// The value string so far, quotes included. + value: Option>, + escaped: bool, +} + +impl KeyScan { + pub fn new(inner: W) -> Self { + Self { inner, keys: HashSet::new(), active: true, matched: 0, after_tag: false, value: None, escaped: false } + } + + fn scan(&mut self, buf: &[u8]) { + if !self.active { + return; + } + let mut i = 0; + while let Some(&b) = buf.get(i) { + // Nothing in progress: skip to the next quote. + if self.matched == 0 && !self.after_tag && self.value.is_none() { + match buf.get(i..).and_then(|r| r.iter().position(|&c| c == b'"')) { + Some(at) => i += at, + None => return, + } + self.matched = 1; + i += 1; + continue; + } + self.step(b); + i += 1; + } + } + + fn step(&mut self, b: u8) { + if let Some(v) = self.value.as_mut() { + v.push(b); + if self.escaped { + self.escaped = false; + } else if b == b'\\' { + self.escaped = true; + } else if b == b'"' + && let Some(v) = self.value.take() + && let Ok(s) = serde_json::from_slice::(&v) + { + self.keys.insert(s); + } + } else if self.after_tag && !b.is_ascii_whitespace() { + self.after_tag = false; + if b == b'"' { + self.value = Some(vec![b]); + } + } + if TAG.get(self.matched) == Some(&b) { + self.matched += 1; + if self.matched == TAG.len() { + self.matched = 0; + self.after_tag = true; + self.value = None; + self.escaped = false; + } + } else { + self.matched = usize::from(b == b'"'); + } + } +} + +impl Write for KeyScan { + fn write(&mut self, buf: &[u8]) -> io::Result { + self.write_all(buf)?; + Ok(buf.len()) + } + + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + self.scan(buf); + self.inner.write_all(buf) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.flush() + } +} + +/// The file's top-level object, written member by member (the document is streamed in). +pub struct Envelope { + pretty: bool, + first: bool, +} + +impl Envelope { + /// Start an object with optional indentation. + pub fn new(pretty: bool) -> Self { + Self { pretty, first: true } + } + + /// Serialize a complete member before writing it to the envelope. + pub fn field(&mut self, out: &mut impl Write, key: &str, value: &impl Serialize) -> io::Result<()> { + let json = if self.pretty { serde_json::to_vec_pretty(value) } else { serde_json::to_vec(value) }.map_err(io::Error::other)?; + self.key(out, key)?; + Indent { inner: out, on: self.pretty }.write_all(&json) + } + + /// The start of member `key` (a plain name): its value follows, indented one level when + /// pretty (as serde_json would: see [`Indent`]). + pub fn key(&mut self, out: &mut impl Write, key: &str) -> io::Result<()> { + let sep: &[u8] = if std::mem::take(&mut self.first) { b"{" } else { b"," }; + let indent: &[u8] = if self.pretty { b"\n " } else { b"" }; + out.write_all(sep)?; + out.write_all(indent)?; + serde_json::to_writer(&mut *out, key).map_err(io::Error::other)?; + out.write_all(if self.pretty { b": " } else { b":" }) + } + + /// Close the object. + pub fn finish(self, out: &mut impl Write) -> io::Result<()> { + if self.first { + return out.write_all(b"{}"); + } + out.write_all(if self.pretty { b"\n}" } else { b"}" }) + } +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + + use super::*; + + /// How the keys were found before saves were streamed: in the whole JSON text at once. + fn string_members(json: &[u8]) -> HashSet { + let mut out = HashSet::new(); + let mut rest = json; + while let Some(at) = rest.windows(TAG.len()).position(|w| w == TAG) { + rest = rest.get(at + TAG.len()..).unwrap_or_default(); + let value = rest.trim_ascii_start(); + if value.first() == Some(&b'"') + && let Some(Ok(s)) = serde_json::Deserializer::from_slice(value).into_iter::().next() + { + out.insert(s); + } + } + out + } + + /// The keys `KeyScan` finds in `json` written in pieces of `chunk` bytes. + fn scanned(json: &[u8], chunk: usize) -> HashSet { + let mut scan = KeyScan::new(Vec::new()); + for piece in json.chunks(chunk.max(1)) { + scan.write_all(piece).unwrap(); + } + assert_eq!(scan.inner, json, "the text passes through"); + scan.keys + } + + #[test] + fn finds_the_keys_the_whole_text_search_found() { + let v = serde_json::json!({"key": "a", "x": [{"key": "b \"q\" \\ é"}, {"monkey": "no"}, {"k": "key"}], "s": "\"key\": \"no\"", "key2": "n", "o": {"key": 3}}); + for json in [serde_json::to_vec(&v).unwrap(), serde_json::to_vec_pretty(&v).unwrap()] { + let want = string_members(&json); + assert_eq!(want, HashSet::from(["a".to_string(), "b \"q\" \\ é".to_string()])); + for chunk in [1, 2, 3, 7, 64, json.len()] { + assert_eq!(scanned(&json, chunk), want, "chunk {chunk}"); + } + } + } + + fn arb_json() -> impl Strategy { + let key = prop::sample::select(vec!["key", "k", "kkey", "key ", "x"]).prop_map(str::to_string); + let leaf = prop_oneof![ + Just(serde_json::Value::Null), + any::().prop_map(serde_json::Value::from), + "[a-z\"\\\\: ké\n]{0,8}".prop_map(serde_json::Value::from), + ]; + leaf.prop_recursive(4, 32, 6, move |inner| { + prop_oneof![ + prop::collection::vec(inner.clone(), 0..5).prop_map(serde_json::Value::from), + prop::collection::vec((key.clone(), inner), 0..5).prop_map(|m| serde_json::Value::Object(m.into_iter().collect())), + ] + }) + } + + proptest! { + #[test] + fn scanning_in_pieces_finds_what_the_whole_text_search_found(v in arb_json(), chunk in 1usize..40, pretty in any::()) { + let json = if pretty { serde_json::to_vec_pretty(&v) } else { serde_json::to_vec(&v) }.unwrap(); + prop_assert_eq!(scanned(&json, chunk), string_members(&json)); + } + } +} diff --git a/crates/vectorcraft-format/tests/stream.rs b/crates/vectorcraft-format/tests/stream.rs new file mode 100644 index 000000000..728f533ca --- /dev/null +++ b/crates/vectorcraft-format/tests/stream.rs @@ -0,0 +1,83 @@ +use craft_vectorcraft_format::stream::{Envelope, Indent, KeyScan}; +use std::io::{self, Write}; + +#[test] +fn envelope_streams_nested_json_and_escapes_keys() { + for pretty in [false, true] { + let mut bytes = Vec::new(); + let mut env = Envelope::new(pretty); + env.field(&mut bytes, "quoted\"key", &vec![1, 2]).unwrap(); + env.key(&mut bytes, "document").unwrap(); + let mut output = Indent { inner: &mut bytes, on: pretty }; + if pretty { + serde_json::to_writer_pretty(&mut output, &serde_json::json!({"nested": [3,4]})).unwrap(); + } else { + serde_json::to_writer(&mut output, &serde_json::json!({"nested": [3,4]})).unwrap(); + } + env.finish(&mut bytes).unwrap(); + let value: serde_json::Value = serde_json::from_slice(&bytes).unwrap(); + assert_eq!(value, serde_json::json!({"quoted\"key": [1, 2], "document": {"nested": [3,4]}})); + let mut expected = Vec::new(); + let empty = Envelope::new(pretty); + empty.finish(&mut expected).unwrap(); + assert_eq!(expected, b"{}"); + } +} + +#[test] +fn scan_survives_every_chunk_boundary_and_forwards_data() { + let json = br#"{"key":"one","nested":[{"key":"two \\\"quoted\\\""},{"key":42}],"other":"x"}"#; + for chunk in 1..=json.len() { + let mut scan = KeyScan::new(Vec::new()); + for part in json.chunks(chunk) { + scan.write_all(part).unwrap(); + } + assert_eq!(scan.inner, json); + assert!(scan.keys.contains("one")); + assert_eq!(scan.keys.len(), 2); + } +} + +struct Broken; +impl Write for Broken { + fn write(&mut self, _: &[u8]) -> io::Result { + Err(io::Error::other("failure")) + } + fn flush(&mut self) -> io::Result<()> { + Err(io::Error::other("failure")) + } +} +#[test] +fn forwards_writer_errors() { + assert!(Envelope::new(false).field(&mut Broken, "x", &1).is_err()); + assert!(KeyScan::new(Broken).write_all(b"{}").is_err()); + assert!(Indent { inner: Broken, on: true }.write_all(b"x\ny").is_err()); +} + +#[test] +fn tail_calls_hook_in_order_and_propagates_errors() { + use craft_vectorcraft_format::{BLOB_MAGIC, INLINE_MAX, Tail}; + let first = vec![1; INLINE_MAX]; + let second = vec![2; INLINE_MAX]; + let mut tail = Tail::new(4); + tail.image("image/png", &first, false); + tail.image("application/pdf", &second, false); + let mut out = Vec::new(); + let mut seen = Vec::new(); + tail.write_to_with(&mut out, |_, mime| { + seen.push(mime.to_owned()); + Ok(()) + }) + .unwrap(); + assert_eq!(seen, ["image/png", "application/pdf"]); + assert_eq!(out, [BLOB_MAGIC, &first, &second].concat()); + assert!(tail.write_to_with(Vec::new(), |_, _| Err(io::Error::other("failure"))).is_err()); + let mut called = false; + Tail::new(4) + .write_to_with(Vec::new(), |_, _| { + called = true; + Ok(()) + }) + .unwrap(); + assert!(!called); +} From d1ee17aca44f8425bc01d87969f54343b1e7d8ea Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 14:46:50 +0000 Subject: [PATCH 093/382] Own native JSON schema in streaming writer --- crates/vectorcraft-format/src/stream.rs | 54 ++++++++++++++++++++++- crates/vectorcraft-format/tests/stream.rs | 25 +++++++++++ 2 files changed, 78 insertions(+), 1 deletion(-) diff --git a/crates/vectorcraft-format/src/stream.rs b/crates/vectorcraft-format/src/stream.rs index 8f205a15d..71b6e90eb 100644 --- a/crates/vectorcraft-format/src/stream.rs +++ b/crates/vectorcraft-format/src/stream.rs @@ -4,9 +4,61 @@ //! Extracted from VectorCraft, licensed under MIT OR Apache-2.0. use serde::Serialize; -use std::collections::HashSet; +use std::collections::{BTreeMap, HashSet}; use std::io::{self, Write}; +/// Native file metadata for streaming a JSON envelope. Asset entries should be prepared using +/// the same [`crate::Tail`] whose parts will be written after the JSON. +pub struct FileHeader<'a> { + /// Native format version to write. + pub version: u32, + /// Application generator string. + pub generator: &'a str, + /// Optional saved PDF compatibility preference. + pub pdf_compatible: Option, + /// Optional inline preview. + pub preview: Option<&'a crate::Image>, + /// Embedded profiles keyed by profile name. + pub profiles: &'a BTreeMap<&'a str, crate::Image>, + /// Optional PDF entry. + pub pdf: Option<&'a crate::Image>, +} + +/// Write the native JSON envelope, streaming the document through `document`. The callback +/// returns the image entries after serializing the document, allowing it to collect image keys +/// without keeping a copy of the document JSON. It must write one complete JSON value. +pub fn write_file_json<'a>( + mut out: impl Write, + header: &FileHeader<'a>, + pretty: bool, + document: impl FnOnce(&mut dyn Write) -> io::Result>, +) -> io::Result<()> { + if !(crate::MIN_VERSION..=crate::VERSION).contains(&header.version) { + return Err(io::Error::new(io::ErrorKind::InvalidInput, "unsupported native file version")); + } + let mut env = Envelope::new(pretty); + let format = if header.version < 3 { crate::LEGACY_EXTENSION } else { crate::EXTENSION }; + env.field(&mut out, "format", &format)?; + env.field(&mut out, "version", &header.version)?; + env.field(&mut out, "generator", &header.generator)?; + if let Some(compatible) = header.pdf_compatible { + env.field(&mut out, "pdfCompatible", &compatible)?; + } + if let Some(preview) = header.preview { + env.field(&mut out, "preview", preview)?; + } + if !header.profiles.is_empty() { + env.field(&mut out, "profiles", header.profiles)?; + } + if let Some(pdf) = header.pdf { + env.field(&mut out, "pdf", pdf)?; + } + env.key(&mut out, "document")?; + let images = document(&mut Indent { inner: &mut out, on: pretty })?; + env.field(&mut out, "images", &images)?; + env.finish(&mut out) +} + /// Indents JSON text written through it one level (two spaces after each newline), as a member /// of the file's top-level object; newlines only occur between tokens, inside strings they are /// escaped. diff --git a/crates/vectorcraft-format/tests/stream.rs b/crates/vectorcraft-format/tests/stream.rs index 728f533ca..35347ca2e 100644 --- a/crates/vectorcraft-format/tests/stream.rs +++ b/crates/vectorcraft-format/tests/stream.rs @@ -81,3 +81,28 @@ fn tail_calls_hook_in_order_and_propagates_errors() { .unwrap(); assert!(!called); } + +#[test] +fn native_schema_order_and_versions() { + use craft_vectorcraft_format::stream::{FileHeader, write_file_json}; + let profiles = Default::default(); + for (version, name) in [(1, "drawcraft"), (4, "vectorcraft")] { + for pretty in [false, true] { + let header = FileHeader { version, generator: "test", pdf_compatible: Some(false), preview: None, profiles: &profiles, pdf: None }; + let mut out = Vec::new(); + write_file_json(&mut out, &header, pretty, |w| { + w.write_all(if pretty { b"{\n \"key\": \"image\"\n}" } else { b"{\"key\":\"image\"}" })?; + Ok(Default::default()) + }) + .unwrap(); + let value: serde_json::Value = serde_json::from_slice(&out).unwrap(); + assert_eq!(value["format"], name); + assert_eq!(value["pdfCompatible"], false); + let text = std::str::from_utf8(&out).unwrap(); + assert!(text.find("\"format\"").unwrap() < text.find("\"version\"").unwrap()); + assert!(text.find("\"document\"").unwrap() < text.find("\"images\"").unwrap()); + } + } + let header = FileHeader { version: 0, generator: "test", pdf_compatible: None, preview: None, profiles: &profiles, pdf: None }; + assert!(write_file_json(Vec::new(), &header, false, |_| Ok(Default::default())).is_err()); +} From e555cc0afe12d14a3fed4e369e78d45cf084109a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:48:49 -0500 Subject: [PATCH 094/382] fix(tga): use eager static footer errors --- crates/tga/src/lib.rs | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/crates/tga/src/lib.rs b/crates/tga/src/lib.rs index 88f4efe6c..06a9941a0 100644 --- a/crates/tga/src/lib.rs +++ b/crates/tga/src/lib.rs @@ -216,14 +216,11 @@ fn image_data_end(bytes: &[u8], first_pixel: usize) -> Result { let Some(footer) = bytes.len().checked_sub(SIGNATURE.len() + 8).filter(|&at| at >= HEADER) else { return Ok(bytes.len()); }; - let offsets = bytes.get(footer..footer + 8).and_then(|b| b.first_chunk::<8>()).ok_or_else(|| Error::Malformed("truncated footer"))?; - let extension = offsets.first_chunk::<4>().map(|v| u32::from_le_bytes(*v) as usize).ok_or_else(|| Error::Malformed("truncated footer"))?; - let directory = offsets - .get(4..) - .and_then(|v| v.first_chunk::<4>()) - .map(|v| u32::from_le_bytes(*v) as usize) - .ok_or_else(|| Error::Malformed("truncated footer"))?; - let body = bytes.get(..footer).ok_or_else(|| Error::Malformed("truncated footer"))?; + let offsets = bytes.get(footer..footer + 8).and_then(|b| b.first_chunk::<8>()).ok_or(Error::Malformed("truncated footer"))?; + let extension = offsets.first_chunk::<4>().map(|v| u32::from_le_bytes(*v) as usize).ok_or(Error::Malformed("truncated footer"))?; + let directory = + offsets.get(4..).and_then(|v| v.first_chunk::<4>()).map(|v| u32::from_le_bytes(*v) as usize).ok_or(Error::Malformed("truncated footer"))?; + let body = bytes.get(..footer).ok_or(Error::Malformed("truncated footer"))?; let mut end = footer; if let Some(offset) = metadata_offset(body, extension, first_pixel) { From b5bd10d0d89ab9bc8ff9f36131128d9cf3a01014 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 14:49:04 +0000 Subject: [PATCH 095/382] Stream envelope fields with bounded buffering --- crates/vectorcraft-format/src/stream.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/crates/vectorcraft-format/src/stream.rs b/crates/vectorcraft-format/src/stream.rs index 71b6e90eb..16bc77ee8 100644 --- a/crates/vectorcraft-format/src/stream.rs +++ b/crates/vectorcraft-format/src/stream.rs @@ -198,11 +198,15 @@ impl Envelope { Self { pretty, first: true } } - /// Serialize a complete member before writing it to the envelope. + /// Serialize a member directly to the output without buffering the full value. pub fn field(&mut self, out: &mut impl Write, key: &str, value: &impl Serialize) -> io::Result<()> { - let json = if self.pretty { serde_json::to_vec_pretty(value) } else { serde_json::to_vec(value) }.map_err(io::Error::other)?; self.key(out, key)?; - Indent { inner: out, on: self.pretty }.write_all(&json) + // serde_json emits small writes; keep compression and underlying I/O efficient while + // bounding temporary memory independently of the serialized table size. + let mut buffered = io::BufWriter::with_capacity(64 << 10, out); + let indented = Indent { inner: &mut buffered, on: self.pretty }; + if self.pretty { serde_json::to_writer_pretty(indented, value) } else { serde_json::to_writer(indented, value) }.map_err(io::Error::other)?; + buffered.into_inner().map(|_| ()).map_err(|e| e.into_error()) } /// The start of member `key` (a plain name): its value follows, indented one level when From cec6e24381bb8e15e0a5dcff67e6a33494d3ddd5 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Sun, 15 Nov 2026 15:52:47 +0100 Subject: [PATCH 096/382] Check the rewritten SVG viewport output under the same limits --- crates/svg/src/tree.rs | 6 +++++- crates/svg/src/tree/tests.rs | 19 +++++++++++++++++++ 2 files changed, 24 insertions(+), 1 deletion(-) diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index 37d956a48..9cf85c3bd 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -212,7 +212,8 @@ pub struct Viewport { } /// Wraps a validated SVG root in a new viewport while preserving the original root as content. -/// The original root must have finite, positive pixel or point dimensions. +/// The original root must have finite, positive pixel or point dimensions, and the wrapped +/// output must still pass [`preflight`] under `limits`. pub fn rewrite_root_viewport(svg: &str, target: Viewport, limits: &Limits, output_limit: usize) -> Result { if !target.width.is_finite() || !target.height.is_finite() || target.width <= 0.0 || target.height <= 0.0 { return Err(Error::Viewport("target dimensions must be finite and positive".into())); @@ -256,6 +257,9 @@ pub fn rewrite_root_viewport(svg: &str, target: Viewport, limits: &Limits, outpu output.push_str(&prefix); output.push_str(inner); output.push_str(""); + // The wrapper adds a level, so a source at the depth limit can come out over it: check the + // output under the limits `parse_text` applies rather than return text it would refuse. + preflight(&output, limits)?; Ok(output) } diff --git a/crates/svg/src/tree/tests.rs b/crates/svg/src/tree/tests.rs index 99b0c1cab..35cb13a2e 100644 --- a/crates/svg/src/tree/tests.rs +++ b/crates/svg/src/tree/tests.rs @@ -666,3 +666,22 @@ fn rewrite_root_viewport_refusals() { assert_eq!(rewrite_root_viewport(sized, one, &limits, fits.len()).unwrap(), fits); assert!(matches!(rewrite_root_viewport(sized, one, &limits, fits.len() - 1), Err(Error::OutputTooLarge(n)) if n == fits.len() - 1)); } + +#[test] +fn rewrite_root_viewport_output_stays_within_the_limits() { + let limits = shallow(); + let one = Viewport { width: 1.0, height: 1.0 }; + let mut refused_at_the_limit = false; + for n in 0..limits.depth { + let source = svg(&groups(n)); + if preflight(&source, &limits).is_err() { + break; + } + match rewrite_root_viewport(&source, one, &limits, 1 << 20) { + Ok(out) => assert!(parse_text(&out, &limits, &options()).is_ok(), "{n} groups"), + Err(Error::TooDeep(_)) => refused_at_the_limit = true, + Err(e) => panic!("{n} groups: {e:?}"), + } + } + assert!(refused_at_the_limit, "a source at the depth limit is refused, not wrapped past it"); +} From 38c26217b1f160cc27ac7453d9ad8fb6739c9830 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:01:28 +0000 Subject: [PATCH 097/382] Support fixed-precision SVG scene coordinates --- crates/svg/src/write.rs | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/crates/svg/src/write.rs b/crates/svg/src/write.rs index 469a4f8fa..66cb1d6a0 100644 --- a/crates/svg/src/write.rs +++ b/crates/svg/src/write.rs @@ -86,18 +86,36 @@ impl Attribute { pub fn translate_scale(x: f64, y: f64, scale_x: f64, scale_y: f64) -> Self { Self { name: "transform".into(), value: Value::TranslateScale { x, y, scale_x, scale_y } } } + /// A translate/scale transform with three decimal places for positions and four for scales. + pub fn translate_scale_fixed(x: f64, y: f64, scale_x: f64, scale_y: f64) -> Self { + Self::text("transform", format!("translate({} {}) scale({} {})", num(x, 3), num(y, 3), num(scale_x, 4), num(scale_y, 4))) + } } impl Scene { /// Serialize the scene as an SVG 1.1 document. pub fn write(&self) -> String { + self.write_impl(false) + } + + /// Serialize the root viewBox with three decimal places for stable fixed-width output. + pub fn write_fixed_view_box(&self) -> String { + self.write_impl(true) + } + + fn write_impl(&self, fixed: bool) -> String { let mut writer = SvgWriter::new(); + let view_box = if fixed { + format!("{} {} {} {}", num(self.view_box[0], 3), num(self.view_box[1], 3), num(self.view_box[2], 3), num(self.view_box[3], 3)) + } else { + view_box_data(self.view_box) + }; writer .root() .attr("version", "1.1") .attr("width", format!("{}mm", num(self.width_mm, 3))) .attr("height", format!("{}mm", num(self.height_mm, 3))) - .attr("viewBox", view_box_data(self.view_box)) + .attr("viewBox", view_box) .open(); write_elements(&mut writer, &self.elements, 1); writer.line(0); @@ -307,6 +325,14 @@ mod tests { p } + #[test] + fn scene_can_keep_fixed_view_box_without_changing_default_output() { + let scene = Scene { width_mm: 100.0, height_mm: 150.0, view_box: [0.0, 0.0, 100.0, 150.0], elements: vec![] }; + assert!(scene.write().contains("viewBox=\"0 0 100 150\"")); + assert!(scene.write_fixed_view_box().contains("viewBox=\"0.000 0.000 100.000 150.000\"")); + assert_eq!(Attribute::translate_scale_fixed(6.0, 46.0, 0.5, -0.5).value, Value::Text("translate(6.000 46.000) scale(0.5000 -0.5000)".into())); + } + #[test] fn numbers_have_fixed_decimals_and_are_never_non_finite() { assert_eq!(num(1.5, 3).to_string(), "1.500"); From 560b6f8268e2c5285c161be52dacfe877b08cf1b Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:02:41 +0000 Subject: [PATCH 098/382] Compare streaming native output with previous framing --- crates/vectorcraft-format/src/stream.rs | 4 ++ crates/vectorcraft-format/tests/stream.rs | 74 +++++++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/crates/vectorcraft-format/src/stream.rs b/crates/vectorcraft-format/src/stream.rs index 16bc77ee8..2e8b0695e 100644 --- a/crates/vectorcraft-format/src/stream.rs +++ b/crates/vectorcraft-format/src/stream.rs @@ -1,5 +1,9 @@ //! Streaming helpers for the native JSON envelope. //! +//! Field values are emitted in bounded chunks. The decoded JSON and tail framing stay the same +//! as VectorCraft's previous writer, but compressed bytes can differ when a deflate backend's +//! output depends on input chunking. Gzip readers still validate the CRC and size trailer. +//! //! Copyright (c) 2026 ArtCraft Team and the VectorCraft contributors. //! Extracted from VectorCraft, licensed under MIT OR Apache-2.0. diff --git a/crates/vectorcraft-format/tests/stream.rs b/crates/vectorcraft-format/tests/stream.rs index 35347ca2e..98f4685e2 100644 --- a/crates/vectorcraft-format/tests/stream.rs +++ b/crates/vectorcraft-format/tests/stream.rs @@ -106,3 +106,77 @@ fn native_schema_order_and_versions() { let header = FileHeader { version: 0, generator: "test", pdf_compatible: None, preview: None, profiles: &profiles, pdf: None }; assert!(write_file_json(Vec::new(), &header, false, |_| Ok(Default::default())).is_err()); } + +// Oracle for the previous app writer: each member was first serialized to a Vec, then +// indented and appended. Compare decoded file bytes, not backend-dependent gzip bytes. +#[test] +fn streamed_native_file_matches_previous_framing() { + use craft_vectorcraft_format::{ + Tail, + stream::{FileHeader, write_file_json}, + }; + use flate2::{Compression, read::GzDecoder, write::GzEncoder}; + use std::collections::BTreeMap; + use std::io::Read; + + fn old_field(out: &mut Vec, first: &mut bool, pretty: bool, key: &str, value: &impl serde::Serialize) { + out.extend_from_slice(if std::mem::take(first) { b"{" } else { b"," }); + if pretty { + out.extend_from_slice(b"\n "); + } + out.extend_from_slice(format!("\"{key}\"{}", if pretty { ": " } else { ":" }).as_bytes()); + let json = if pretty { serde_json::to_vec_pretty(value) } else { serde_json::to_vec(value) }.unwrap(); + let mut indent = Indent { inner: out, on: pretty }; + indent.write_all(&json).unwrap(); + } + + let payload = vec![42; craft_vectorcraft_format::INLINE_MAX]; + for version in [1, 3, 4] { + for pretty in [false, true] { + let mut tail = Tail::new(version); + let image = tail.image("image/png", &payload, false); + let profile = tail.image("application/vnd.iccprofile", &payload, false); + let pdf = tail.image("application/pdf", &payload, false); + let profiles = BTreeMap::from([("profile", profile)]); + let images = BTreeMap::from([("image", image)]); + let document = serde_json::json!({"layers": [{"key": "image", "name": "A"}]}); + let header = FileHeader { + version, + generator: "VectorCraft test", + pdf_compatible: Some(true), + preview: None, + profiles: &profiles, + pdf: Some(&pdf), + }; + let mut actual = Vec::new(); + write_file_json(&mut actual, &header, pretty, |w| { + if pretty { serde_json::to_writer_pretty(w, &document) } else { serde_json::to_writer(w, &document) }.map_err(io::Error::other)?; + Ok(images.clone()) + }) + .unwrap(); + tail.write_to(&mut actual).unwrap(); + + let mut old = Vec::new(); + let mut first = true; + let format = if version < 3 { "drawcraft" } else { "vectorcraft" }; + old_field(&mut old, &mut first, pretty, "format", &format); + old_field(&mut old, &mut first, pretty, "version", &version); + old_field(&mut old, &mut first, pretty, "generator", &"VectorCraft test"); + old_field(&mut old, &mut first, pretty, "pdfCompatible", &true); + old_field(&mut old, &mut first, pretty, "profiles", &profiles); + old_field(&mut old, &mut first, pretty, "pdf", &pdf); + old_field(&mut old, &mut first, pretty, "document", &document); + old_field(&mut old, &mut first, pretty, "images", &images); + old.extend_from_slice(if pretty { b"\n}" } else { b"}" }); + tail.write_to(&mut old).unwrap(); + assert_eq!(actual, old, "version {version}, pretty {pretty}"); + for bytes in [&old, &actual] { + let mut gzip = GzEncoder::new(Vec::new(), Compression::default()); + gzip.write_all(bytes).unwrap(); + let mut decoded = Vec::new(); + GzDecoder::new(gzip.finish().unwrap().as_slice()).read_to_end(&mut decoded).unwrap(); + assert_eq!(decoded, old); + } + } + } +} From 2bb5d0344f03a73833576b57847513ea529d3d2c Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 10:10:41 -0500 Subject: [PATCH 099/382] docs(psd): document editable TySh envelope fields --- crates/psd/src/text/envelope.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/psd/src/text/envelope.rs b/crates/psd/src/text/envelope.rs index e654ed390..73345fa83 100644 --- a/crates/psd/src/text/envelope.rs +++ b/crates/psd/src/text/envelope.rs @@ -12,8 +12,11 @@ pub const MAX_BYTES: usize = 8 * 1024 * 1024; /// Parsed `TySh` contents. #[derive(Clone, Debug, PartialEq)] pub struct TySh { + /// Affine transform in PSD order: xx, xy, yx, yy, tx, ty. pub transform: [f64; 6], + /// Text descriptor, including text content and styling data. pub text: Descriptor, + /// Optional warp descriptor retained from the Type Tool block. pub warp: Option, /// The four trailing big-endian f32 values (left, top, right, bottom) after the warp /// descriptor. Photoshop writes zeros for unwarped type and the text-space bounds (the From d2bb64c4ac41c9242479f5e8277580b847151e5a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 10:14:40 -0500 Subject: [PATCH 100/382] fix(tga): bound aggregate decoder storage and reserve fallibly --- crates/tga/src/lib.rs | 36 +++++++++++++++++++++++++------- crates/tga/src/metadata_tests.rs | 22 +++++++++---------- crates/tga/src/tests.rs | 33 +++++++++++++++++++++++++++-- 3 files changed, 70 insertions(+), 21 deletions(-) diff --git a/crates/tga/src/lib.rs b/crates/tga/src/lib.rs index 06a9941a0..5174a8093 100644 --- a/crates/tga/src/lib.rs +++ b/crates/tga/src/lib.rs @@ -59,11 +59,13 @@ pub type Result = std::result::Result; pub struct Limits { /// Most pixels (width × height) a picture may have. Default 2^28 (16384 × 16384). pub max_pixels: u64, + /// Maximum combined palette, stored-pixel and RGBA allocation bytes. Default 256 MiB. + pub max_decoded_bytes: usize, } impl Default for Limits { fn default() -> Self { - Self { max_pixels: 1 << 28 } + Self { max_pixels: 1 << 28, max_decoded_bytes: 256 << 20 } } } @@ -313,10 +315,6 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result { }; let end = image_data_end(bytes, first_pixel)?; let bytes = bytes.get(..end).ok_or(err("truncated image data"))?; - if let Some(layout) = map_entry { - let map = bytes.get(map_start..first_pixel).ok_or(err("truncated colour map"))?; - palette = map.chunks_exact(layout.bytes()).map(|entry| layout.rgba(entry)).collect(); - } let at = first_pixel; let (stored_as, mapped) = match kind & 7 { 1 => { @@ -335,14 +333,35 @@ pub fn decode(bytes: &[u8], limits: &Limits) -> Result { }; let data = bytes.get(at..).unwrap_or_default(); let bpp = stored_as.bytes(); + let stored_bytes = pixels.checked_mul(bpp).ok_or(Error::LimitExceeded("image size"))?; + let rgba_bytes = pixels.checked_mul(4).ok_or(Error::LimitExceeded("image size"))?; + let palette_bytes = if map_entry.is_some() { map_len * 4 } else { 0 }; + let aggregate = + stored_bytes.checked_add(rgba_bytes).and_then(|n| n.checked_add(palette_bytes)).ok_or(Error::LimitExceeded("decode allocation bytes"))?; + if aggregate > limits.max_decoded_bytes { + return Err(Error::LimitExceeded("decode allocation bytes")); + } + if let Some(layout) = map_entry { + let map = bytes.get(map_start..first_pixel).ok_or(err("truncated colour map"))?; + palette.try_reserve_exact(map_len).map_err(|_| Error::LimitExceeded("allocation failed"))?; + palette.extend(map.chunks_exact(layout.bytes()).map(|entry| layout.rgba(entry))); + } // The stored values, in file order. let stored: Vec = if rle { unpack_rle(data, pixels, bpp)? } else { let n = pixels.checked_mul(bpp).ok_or(Error::LimitExceeded("image size"))?; - data.get(..n).ok_or(err("truncated pixel data"))?.to_vec() + { + let source = data.get(..n).ok_or(err("truncated pixel data"))?; + let mut values = Vec::new(); + values.try_reserve_exact(n).map_err(|_| Error::LimitExceeded("allocation failed"))?; + values.extend_from_slice(source); + values + } }; - let mut rgba = vec![0u8; pixels.checked_mul(4).ok_or(Error::LimitExceeded("image size"))?]; + let mut rgba = Vec::new(); + rgba.try_reserve_exact(rgba_bytes).map_err(|_| Error::LimitExceeded("allocation failed"))?; + rgba.resize(rgba_bytes, 0u8); for (i, v) in stored.chunks_exact(bpp).enumerate().take(pixels) { let (x, y) = (i % w, i / w); let x = if right_to_left { w - 1 - x } else { x }; @@ -386,7 +405,8 @@ fn unpack_rle(mut data: &[u8], pixels: usize, bpp: usize) -> Result> { return Err(short); } let total = pixels.checked_mul(bpp).ok_or(Error::LimitExceeded("image size"))?; - let mut out = Vec::with_capacity(total); + let mut out = Vec::new(); + out.try_reserve_exact(total).map_err(|_| Error::LimitExceeded("allocation failed"))?; while out.len() < total { let (&head, rest) = data.split_first().ok_or(short.clone())?; let count = usize::from(head & 0x7F) + 1; diff --git a/crates/tga/src/metadata_tests.rs b/crates/tga/src/metadata_tests.rs index a5c6c0b12..583f5d691 100644 --- a/crates/tga/src/metadata_tests.rs +++ b/crates/tga/src/metadata_tests.rs @@ -124,7 +124,7 @@ fn importing_truncated_pixels_does_not_consume_tga_footer() { file.extend_from_slice(&offsets); file.extend_from_slice(SIGNATURE); let result = dec(&file); - assert!(matches!(result, Err(_)), "kind {kind}, metadata {metadata:?}: metadata is not a second pixel"); + assert!(result.is_err(), "kind {kind}, metadata {metadata:?}: metadata is not a second pixel"); } } for kind in [1, 9] { @@ -136,7 +136,7 @@ fn importing_truncated_pixels_does_not_consume_tga_footer() { file.extend_from_slice(&[0; 8]); file.extend_from_slice(SIGNATURE); let result = dec(&file); - assert!(matches!(result, Err(_)), "kind {kind}: the footer is not colour-map data"); + assert!(result.is_err(), "kind {kind}: the footer is not colour-map data"); } } @@ -200,7 +200,7 @@ fn preceding_metadata_cannot_supply_missing_pixels() { let mut accepted = Vec::new(); for metadata in 0..4 { let result = dec(&preceding_metadata(false, metadata)); - if !matches!(result, Err(_)) { + if result.is_ok() { accepted.push(metadata); } } @@ -305,7 +305,7 @@ fn malformed_optional_metadata_cannot_supply_missing_pixels() { let footer = file.len() - SIGNATURE.len() - 8; let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; file[directory + 8..directory + 12].copy_from_slice(&u32::MAX.to_le_bytes()); - assert!(matches!(dec(&file), Err(_))); + assert!(dec(&file).is_err()); // The declared entry count exceeds the bytes before the footer, but the first entry's // payload still precedes the directory and cannot be used as a second pixel. @@ -313,17 +313,17 @@ fn malformed_optional_metadata_cannot_supply_missing_pixels() { let footer = file.len() - SIGNATURE.len() - 8; let directory = u32::from_le_bytes(file[footer + 4..footer + 8].try_into().unwrap()) as usize; file[directory..directory + 2].copy_from_slice(&2u16.to_le_bytes()); - assert!(matches!(dec(&file), Err(_))); + assert!(dec(&file).is_err()); let mut file = preceding_metadata(false, 2); let footer = file.len() - SIGNATURE.len() - 8; let extension = u32::from_le_bytes(file[footer..footer + 4].try_into().unwrap()) as usize; file[extension..extension + 2].copy_from_slice(&494u16.to_le_bytes()); - assert!(matches!(dec(&file), Err(_))); + assert!(dec(&file).is_err()); let mut file = preceding_metadata(false, 2); let footer = file.len() - SIGNATURE.len() - 8; file.remove(footer - 1); - assert!(matches!(dec(&file), Err(_))); + assert!(dec(&file).is_err()); } #[test] @@ -341,7 +341,7 @@ fn valid_developer_directory_with_overlapping_payload_rejects_pixels() { assert_eq!(u32::from_le_bytes(file[moved_footer + 4..moved_footer + 8].try_into().unwrap()), directory as u32); assert_eq!(u16::from_le_bytes(file[directory..directory + 2].try_into().unwrap()), 2); assert_eq!(&file[directory + 12..directory + 22], &extra); - assert!(matches!(dec(&file), Err(_))); + assert!(dec(&file).is_err()); } #[test] @@ -356,7 +356,7 @@ fn nonempty_developer_reference_inside_pixels_rejects_the_whole_image() { file.extend_from_slice(&0u32.to_le_bytes()); file.extend_from_slice(&directory.to_le_bytes()); file.extend_from_slice(SIGNATURE); - assert!(matches!(dec(&file), Err(_)), "an overlapping reference must not return a partial image"); + assert!(dec(&file).is_err(), "an overlapping reference must not return a partial image"); } #[test] @@ -376,7 +376,7 @@ fn inflated_developer_count_scans_the_next_chunk_as_an_entry_and_rejects_its_pix file.extend_from_slice(&0u32.to_le_bytes()); file.extend_from_slice(&directory.to_le_bytes()); file.extend_from_slice(SIGNATURE); - assert!(matches!(dec(&file), Err(_)), "a scanned entry's payload inside the pixels is refused"); + assert!(dec(&file).is_err(), "a scanned entry's payload inside the pixels is refused"); } #[test] @@ -389,7 +389,7 @@ fn legacy_pixels_that_end_in_signature_at_or_after_the_header_are_read_as_a_foot let mut file = header(3, width, 1, 8, 0x20); file.extend(vec![0; prefix]); file.extend_from_slice(SIGNATURE); - assert!(matches!(dec(&file), Err(_))); + assert!(dec(&file).is_err()); } #[test] diff --git a/crates/tga/src/tests.rs b/crates/tga/src/tests.rs index 06109a179..76472075f 100644 --- a/crates/tga/src/tests.rs +++ b/crates/tga/src/tests.rs @@ -116,8 +116,8 @@ fn hostile_headers_fail_without_allocating() { fn the_pixel_limit_is_checked() { let mut f = header(3, 2, 2, 8, 0); f.extend_from_slice(&[0; 4]); - assert!(decode(&f, &Limits { max_pixels: 4 }).is_ok()); - assert_eq!(decode(&f, &Limits { max_pixels: 3 }), Err(Error::LimitExceeded("pixel count"))); + assert!(decode(&f, &Limits { max_pixels: 4, ..Limits::default() }).is_ok()); + assert_eq!(decode(&f, &Limits { max_pixels: 3, ..Limits::default() }), Err(Error::LimitExceeded("pixel count"))); } #[test] @@ -235,3 +235,32 @@ fn written_files_read_back() { assert_eq!(r.rgba, want, "{layout:?}"); } } + +#[test] +fn aggregate_decode_budget_applies_before_rle_expansion() { + let mut file = header(10, 16, 16, 32, 0x28); + file.extend_from_slice(&[255, 0, 0, 255, 255, 255, 0, 0, 255, 255]); + let mut limits = Limits::default(); + limits.max_decoded_bytes = 2047; + assert_eq!(decode(&file, &limits), Err(Error::LimitExceeded("decode allocation bytes"))); + limits.max_decoded_bytes = 2048; + assert_eq!(decode(&file, &limits).unwrap().rgba.len(), 1024); +} +#[test] +fn default_budget_rejects_large_rle_header_without_large_fixture() { + let file = header(10, 16384, 16384, 32, 0x28); + assert_eq!(decode(&file, &Limits::default()), Err(Error::LimitExceeded("decode allocation bytes"))); +} +#[test] +fn aggregate_decode_budget_counts_raw_and_palette_storage() { + let mut file = header(1, 1, 1, 8, 0x20); + file[1] = 1; + file[5] = 1; + file[7] = 24; + file.extend_from_slice(&[0, 0, 255, 0]); + let mut limits = Limits::default(); + limits.max_decoded_bytes = 8; + assert_eq!(decode(&file, &limits), Err(Error::LimitExceeded("decode allocation bytes"))); + limits.max_decoded_bytes = 9; + assert_eq!(decode(&file, &limits).unwrap().rgba, [255, 0, 0, 255]); +} From a33a81b1f19b348deab1ec5bc3942cb26095e692 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 10:15:49 -0500 Subject: [PATCH 101/382] test(tga): initialize custom decode limits directly --- crates/tga/src/tests.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/crates/tga/src/tests.rs b/crates/tga/src/tests.rs index 76472075f..887c2915a 100644 --- a/crates/tga/src/tests.rs +++ b/crates/tga/src/tests.rs @@ -240,8 +240,7 @@ fn written_files_read_back() { fn aggregate_decode_budget_applies_before_rle_expansion() { let mut file = header(10, 16, 16, 32, 0x28); file.extend_from_slice(&[255, 0, 0, 255, 255, 255, 0, 0, 255, 255]); - let mut limits = Limits::default(); - limits.max_decoded_bytes = 2047; + let mut limits = Limits { max_decoded_bytes: 2047, ..Limits::default() }; assert_eq!(decode(&file, &limits), Err(Error::LimitExceeded("decode allocation bytes"))); limits.max_decoded_bytes = 2048; assert_eq!(decode(&file, &limits).unwrap().rgba.len(), 1024); @@ -258,8 +257,7 @@ fn aggregate_decode_budget_counts_raw_and_palette_storage() { file[5] = 1; file[7] = 24; file.extend_from_slice(&[0, 0, 255, 0]); - let mut limits = Limits::default(); - limits.max_decoded_bytes = 8; + let mut limits = Limits { max_decoded_bytes: 8, ..Limits::default() }; assert_eq!(decode(&file, &limits), Err(Error::LimitExceeded("decode allocation bytes"))); limits.max_decoded_bytes = 9; assert_eq!(decode(&file, &limits).unwrap().rgba, [255, 0, 0, 255]); From 6c22881fc13314cd393846c3b3f23f59ab744a63 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:16:39 +0000 Subject: [PATCH 102/382] Share streaming neutral SVG geometry and output --- Cargo.lock | 1 + crates/svg/Cargo.toml | 1 + crates/svg/src/drawing_write.rs | 56 ++++ crates/svg/src/lib.rs | 3 + crates/svg/src/neutral_document.rs | 406 +++++++++++++++++++++++++ crates/svg/src/path_data.rs | 456 +++++++++++++++++++++++++++++ 6 files changed, 923 insertions(+) create mode 100644 crates/svg/src/drawing_write.rs create mode 100644 crates/svg/src/neutral_document.rs create mode 100644 crates/svg/src/path_data.rs diff --git a/Cargo.lock b/Cargo.lock index c396f1978..6c4aab5dc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2696,6 +2696,7 @@ dependencies = [ "data-url", "flate2", "kurbo 0.13.1", + "quick-xml 0.41.0", "resvg 0.48.1", "roxmltree 0.21.2", "thiserror 2.0.21", diff --git a/crates/svg/Cargo.toml b/crates/svg/Cargo.toml index 3615a719c..3b778da47 100644 --- a/crates/svg/Cargo.toml +++ b/crates/svg/Cargo.toml @@ -12,6 +12,7 @@ workspace = true [dependencies] craft-xml = { workspace = true } +quick-xml = { version = "0.41", default-features = false } craft-image-codecs = { workspace = true } # SVGZ (gzip), pure-Rust backend. flate2 = { version = "1", default-features = false, features = ["rust_backend"] } diff --git a/crates/svg/src/drawing_write.rs b/crates/svg/src/drawing_write.rs new file mode 100644 index 000000000..91b94d790 --- /dev/null +++ b/crates/svg/src/drawing_write.rs @@ -0,0 +1,56 @@ +//! SVG polyline and triangle path attributes for display-list exporters. +use crate::write::num; +use std::fmt::{self, Display}; + +/// A fixed-precision polyline attribute streamed into an SVG writer. +pub struct Points { + iter: I, + decimals: usize, +} +/// Format points without allocating an intermediate attribute string. Precision is capped at 32. +pub fn points + Clone>(iter: I, decimals: usize) -> Points { + Points { iter, decimals: decimals.min(32) } +} +impl + Clone> Display for Points { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for [x, y] in self.iter.clone() { + write!(f, "{},{} ", num(x, self.decimals), num(y, self.decimals))?; + } + Ok(()) + } +} +/// A fixed-precision sequence of closed triangle subpaths. +pub struct Triangles { + iter: I, + decimals: usize, +} +/// Format independent triangles without allocating an intermediate attribute string. Precision is capped at 32. +pub fn triangles + Clone>(iter: I, decimals: usize) -> Triangles { + Triangles { iter, decimals: decimals.min(32) } +} +impl + Clone> Display for Triangles { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for [[ax, ay], [bx, by], [cx, cy]] in self.iter.clone() { + write!( + f, + "M{} {}L{} {}L{} {}Z", + num(ax, self.decimals), + num(ay, self.decimals), + num(bx, self.decimals), + num(by, self.decimals), + num(cx, self.decimals), + num(cy, self.decimals) + )?; + } + Ok(()) + } +} +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn fixed_precision_attributes_keep_independent_triangles() { + assert_eq!(points([[1.0, 2.0], [3.0, 4.0]].into_iter(), 2).to_string(), "1.00,2.00 3.00,4.00 "); + assert_eq!(triangles([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]].into_iter(), 1).to_string(), "M1.0 2.0L3.0 4.0L5.0 6.0Z"); + } +} diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs index 982e4f82b..25bf880cd 100644 --- a/crates/svg/src/lib.rs +++ b/crates/svg/src/lib.rs @@ -18,7 +18,10 @@ #![forbid(unsafe_code)] pub mod color; +pub mod drawing_write; pub mod guard; +pub mod neutral_document; +pub mod path_data; pub mod paths; pub mod preflight; pub mod sniff; diff --git a/crates/svg/src/neutral_document.rs b/crates/svg/src/neutral_document.rs new file mode 100644 index 000000000..24294684a --- /dev/null +++ b/crates/svg/src/neutral_document.rs @@ -0,0 +1,406 @@ +//! A bounded SVG document walk that preserves geometric primitive kinds for CAD import. +//! +//! Coordinates remain in SVG user units. Each shape carries the composed transform into +//! millimetres with the page Y axis pointing up; consumers map shapes into their own model. +use crate::path_data::{self, Point, Subpath}; +use quick_xml::events::{BytesStart, Event as XmlEvent}; +use quick_xml::{Reader, XmlVersion}; +use std::collections::BTreeMap; + +const MAX_DEPTH: usize = 64; +const MAX_SHAPES: usize = 500_000; +const MAX_POINTS: usize = 8_000_000; +const MAX_POLY_POINTS: usize = 100_001; +const SKIP: &[&[u8]] = &[ + b"defs", + b"symbol", + b"clipPath", + b"mask", + b"pattern", + b"marker", + b"linearGradient", + b"radialGradient", + b"filter", + b"style", + b"text", + b"image", + b"title", + b"desc", + b"metadata", +]; +const CONTAINERS: &[&[u8]] = &[b"g", b"svg", b"a", b"switch"]; + +/// Input failure or resource bound. +#[derive(Debug, thiserror::Error)] +#[error("{0}")] +pub struct Error(pub String); +/// A shape's original geometry before its affine transform. +#[derive(Debug, Clone, PartialEq)] +pub enum Primitive { + Rect { x: f64, y: f64, width: f64, height: f64 }, + Circle { center: Point, radius: f64 }, + Ellipse { center: Point, rx: f64, ry: f64 }, + Line { a: Point, b: Point }, + Polyline { points: Vec, closed: bool }, + Path(Vec), +} +/// A primitive with its layer and SVG affine matrix `[a,b,c,d,e,f]`. +#[derive(Debug, Clone, PartialEq)] +pub struct Shape { + pub primitive: Primitive, + pub transform: [f64; 6], + pub layer: String, +} +/// The shapes, encountered layer names, and skipped-feature counts. `visit` streams shapes +/// to its sink, so its returned `shapes` is empty; `import` collects them. +#[derive(Debug, Default, PartialEq)] +pub struct Document { + pub shapes: Vec, + pub layers: Vec, + pub skipped: BTreeMap, +} +/// Features left out by this geometry-only import. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +pub enum Skipped { + Text, + Image, + Use, + Style, + RoundedCorners, +} + +fn attr(e: &BytesStart<'_>, name: &[u8]) -> Option { + for a in e.attributes() { + let Ok(a) = a else { return None }; + if a.key.into_inner() == name { + return a.normalized_value(XmlVersion::Explicit1_0).ok().map(|v| v.into_owned()); + } + } + None +} +fn hidden(e: &BytesStart<'_>) -> bool { + attr(e, b"display").as_deref() == Some("none") || attr(e, b"style").is_some_and(|s| s.replace(' ', "").contains("display:none")) +} +fn length(s: &str) -> Option { + let s = s.trim(); + let cut = s.find(|c: char| !(c.is_ascii_digit() || matches!(c, '.' | '-' | '+' | 'e' | 'E'))).unwrap_or(s.len()); + let (n, unit) = s.split_at(cut); + let v: f64 = n.trim().parse().ok()?; + if !v.is_finite() { + return None; + } + Some( + v * match unit.trim() { + "" | "px" | "mm" => 1.0, + "cm" => 10.0, + "in" => 25.4, + "pt" => 25.4 / 72.0, + "pc" => 25.4 / 6.0, + _ => 25.4 / 96.0, + }, + ) +} +fn num(e: &BytesStart<'_>, name: &[u8], default: f64) -> f64 { + attr(e, name).as_deref().and_then(length).unwrap_or(default) +} +const ID: [f64; 6] = [1., 0., 0., 1., 0., 0.]; +fn mul(a: [f64; 6], b: [f64; 6]) -> [f64; 6] { + [ + a[0] * b[0] + a[2] * b[1], + a[1] * b[0] + a[3] * b[1], + a[0] * b[2] + a[2] * b[3], + a[1] * b[2] + a[3] * b[3], + a[0] * b[4] + a[2] * b[5] + a[4], + a[1] * b[4] + a[3] * b[5] + a[5], + ] +} +fn translate(x: f64, y: f64) -> [f64; 6] { + [1., 0., 0., 1., x, y] +} +fn scale(x: f64, y: f64) -> [f64; 6] { + [x, 0., 0., y, 0., 0.] +} +fn rotate(a: f64) -> [f64; 6] { + let (s, c) = a.to_radians().sin_cos(); + [c, s, -s, c, 0., 0.] +} +fn numbers(s: &str) -> impl Iterator + '_ { + path_data::Numbers::new(s) +} +fn transform(s: &str) -> Option<[f64; 6]> { + let mut out = None; + let mut rest = s.trim(); + while !rest.is_empty() { + let open = rest.find('(')?; + let name = rest[..open].trim(); + let close = rest[open..].find(')')? + open; + // No transform function accepts more than six arguments. + let args: Vec<_> = numbers(&rest[open + 1..close]).take(7).collect(); + let m = match (name, args.as_slice()) { + ("matrix", [a, b, c, d, e, f]) => [*a, *b, *c, *d, *e, *f], + ("translate", [x]) => translate(*x, 0.), + ("translate", [x, y]) => translate(*x, *y), + ("scale", [x]) => scale(*x, *x), + ("scale", [x, y]) => scale(*x, *y), + ("rotate", [a]) => rotate(*a), + ("rotate", [a, x, y]) => mul(mul(translate(*x, *y), rotate(*a)), translate(-x, -y)), + ("skewX", [a]) => [1., 0., a.to_radians().tan(), 1., 0., 0.], + ("skewY", [a]) => [1., a.to_radians().tan(), 0., 1., 0., 0.], + _ => return None, + }; + out = Some(out.map_or(m, |prev| mul(prev, m))); + rest = rest[close + 1..].trim_start_matches(|c: char| c == ',' || c.is_whitespace()); + } + out +} +fn viewport(e: &BytesStart<'_>) -> [f64; 6] { + let vb = attr(e, b"viewBox").and_then(|raw| { + let n: Vec<_> = numbers(&raw).take(5).collect(); + match n.as_slice() { + [x, y, w, h] if *w > 0. && *h > 0. => Some((*x, *y, *w, *h)), + _ => None, + } + }); + let root = |name: &[u8]| { + let raw = attr(e, name)?; + let mm = length(&raw)?; + let unit = raw.trim().trim_start_matches(|c: char| c.is_ascii_digit() || matches!(c, '.' | '-' | '+' | 'e' | 'E')).trim(); + Some(if matches!(unit, "" | "px") { mm * 25.4 / 96. } else { mm }) + }; + let unit = match (vb, root(b"width"), root(b"height")) { + (Some((_, _, w, _)), Some(x), _) if x > 0. => x / w, + (Some((_, _, _, h)), _, Some(y)) if y > 0. => y / h, + _ => 25.4 / 96., + }; + let (x, y, h) = vb.map_or((0., 0., 0.), |(x, y, _, h)| (x, y, h)); + [unit, 0., 0., -unit, -x * unit, (y + h) * unit] +} +fn layer_name(raw: &str) -> String { + let s: String = raw.trim().chars().map(|c| if c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '$') { c } else { '_' }).take(128).collect(); + let s = s.trim_matches('_'); + if s.is_empty() { "SVG".into() } else { s.into() } +} +/// A layer declaration or a drawable primitive in document order. +pub enum Event { + Layer(String), + Shape(Shape), +} + +struct Walker<'a> { + doc: Document, + stack: Vec<[f64; 6]>, + layer: String, + skip: usize, + points: usize, + shapes: usize, + sink: &'a mut dyn FnMut(Event) -> Result<(), Error>, +} +impl Walker<'_> { + fn current(&self) -> [f64; 6] { + self.stack.last().copied().unwrap_or(ID) + } + fn note(&mut self, what: Skipped) { + *self.doc.skipped.entry(what).or_default() += 1; + } + fn skipped(name: &[u8]) -> Option { + match name { + b"text" => Some(Skipped::Text), + b"image" => Some(Skipped::Image), + _ => None, + } + } + fn start(&mut self, name: &[u8], e: &BytesStart<'_>) -> Result<(), Error> { + if name == b"style" { + self.note(Skipped::Style); + } + if self.skip > 0 { + self.skip += 1; + return Ok(()); + } + if hidden(e) { + self.skip = 1; + return Ok(()); + } + if SKIP.contains(&name) { + if let Some(s) = Self::skipped(name) { + self.note(s); + } + self.skip = 1; + return Ok(()); + } + if !CONTAINERS.contains(&name) { + return self.element(name, e); + } + if name == b"svg" && self.stack.len() == 1 { + if let Some(root) = self.stack.first_mut() { + *root = viewport(e); + } + } + if name == b"g" + && attr(e, b"inkscape:groupmode").as_deref() == Some("layer") + && let Some(raw) = attr(e, b"inkscape:label").or_else(|| attr(e, b"id")) + { + let layer = layer_name(&raw); + if layer == "0" || self.doc.layers.contains(&layer) { + self.layer = layer; + } else if self.doc.layers.len() < 255 { + self.doc.layers.push(layer.clone()); + (self.sink)(Event::Layer(layer.clone()))?; + self.layer = layer; + } + } + if self.stack.len() >= MAX_DEPTH { + return Err(Error(format!("SVG: more than {MAX_DEPTH} nested groups"))); + } + let next = attr(e, b"transform").as_deref().and_then(transform).map_or(self.current(), |t| mul(self.current(), t)); + self.stack.push(next); + Ok(()) + } + fn element(&mut self, name: &[u8], e: &BytesStart<'_>) -> Result<(), Error> { + if self.skip > 0 { + return Ok(()); + } + if SKIP.contains(&name) || hidden(e) { + if !hidden(e) + && let Some(s) = Self::skipped(name) + { + self.note(s); + } + return Ok(()); + } + let p = |x, y| Point::new(num(e, x, 0.), num(e, y, 0.)); + let primitive = match name { + b"use" => { + self.note(Skipped::Use); + return Ok(()); + } + b"rect" => { + let (x, y, w, h) = (num(e, b"x", 0.), num(e, b"y", 0.), num(e, b"width", 0.), num(e, b"height", 0.)); + if w <= 0. || h <= 0. { + return Ok(()); + } + if num(e, b"rx", 0.) > 0. || num(e, b"ry", 0.) > 0. { + self.note(Skipped::RoundedCorners); + } + Primitive::Rect { x, y, width: w, height: h } + } + b"circle" => { + let r = num(e, b"r", 0.); + if r <= 0. { + return Ok(()); + } + Primitive::Circle { center: p(b"cx", b"cy"), radius: r } + } + b"ellipse" => { + let (rx, ry) = (num(e, b"rx", 0.), num(e, b"ry", 0.)); + if rx <= 0. || ry <= 0. { + return Ok(()); + } + Primitive::Ellipse { center: p(b"cx", b"cy"), rx, ry } + } + b"line" => Primitive::Line { a: p(b"x1", b"y1"), b: p(b"x2", b"y2") }, + b"polyline" | b"polygon" => { + let Some(raw) = attr(e, b"points") else { return Ok(()) }; + let n: Vec<_> = numbers(&raw).take(MAX_POLY_POINTS * 2).collect(); + let pts: Vec<_> = n.as_chunks::<2>().0.iter().map(|[x, y]| Point::new(*x, *y)).collect(); + if pts.len() < 2 { + return Ok(()); + } + Primitive::Polyline { points: pts, closed: name == b"polygon" } + } + b"path" => { + let Some(raw) = attr(e, b"d") else { return Ok(()) }; + Primitive::Path(path_data::parse_path(&raw).map_err(|e| Error(e.to_string()))?) + } + _ => return Ok(()), + }; + let cost = match &primitive { + Primitive::Polyline { points, .. } => points.len(), + Primitive::Path(paths) => paths.iter().map(|p| p.segs.len()).sum(), + _ => 1, + }; + self.points = self.points.checked_add(cost).filter(|n| *n <= MAX_POINTS).ok_or_else(|| Error("SVG: too much generated geometry".into()))?; + if self.shapes >= MAX_SHAPES { + return Err(Error(format!("SVG: more than {MAX_SHAPES} elements"))); + } + let matrix = attr(e, b"transform").as_deref().and_then(transform).map_or(self.current(), |t| mul(self.current(), t)); + self.shapes += 1; + (self.sink)(Event::Shape(Shape { primitive, transform: matrix, layer: self.layer.clone() })) + } +} +/// Walk supported SVG geometry without retaining a second copy of the document's shapes. +/// The sink receives each layer before its first shape and each shape in input order. +pub fn visit(text: &str, sink: &mut dyn FnMut(Event) -> Result<(), Error>) -> Result { + let mut walker = Walker { doc: Document::default(), stack: vec![ID], layer: "0".into(), skip: 0, points: 0, shapes: 0, sink }; + let mut reader = Reader::from_str(text); + reader.config_mut().trim_text(true); + loop { + match reader.read_event().map_err(|e| Error(format!("SVG: {e}")))? { + XmlEvent::Start(e) => walker.start(e.name().into_inner(), &e)?, + XmlEvent::Empty(e) => walker.element(e.name().into_inner(), &e)?, + XmlEvent::End(e) => { + if walker.skip > 0 { + walker.skip -= 1; + } else if CONTAINERS.contains(&e.name().into_inner()) && walker.stack.len() > 1 { + walker.stack.pop(); + } + } + XmlEvent::Eof => break, + _ => {} + } + } + Ok(walker.doc) +} +/// Read the supported geometry into an owned document. +pub fn import(text: &str) -> Result { + let mut shapes = Vec::new(); + let mut doc = visit(text, &mut |event| { + if let Event::Shape(shape) = event { + shapes.push(shape); + } + Ok(()) + })?; + doc.shapes = shapes; + Ok(doc) +} +#[cfg(test)] +mod tests { + #![allow(clippy::unwrap_used)] + use super::*; + #[test] + fn keeps_primitives_transform_layers_and_skips() { + let svg = r##"x"##; + let d = import(svg).unwrap(); + assert_eq!(d.layers, ["cut"]); + assert_eq!(d.shapes.len(), 3); + assert_eq!(d.shapes[0].primitive, Primitive::Circle { center: Point::new(3., 4.), radius: 2. }); + assert_eq!(d.shapes[0].transform, [1., 0., 0., -1., 2., 9.]); + assert!(matches!(d.shapes[1].primitive, Primitive::Ellipse { .. })); + assert!(matches!(&d.shapes[2].primitive,Primitive::Path(p) if matches!(p[0].segs[0],path_data::Segment::Arc { .. }))); + assert_eq!(d.skipped.get(&Skipped::Text), Some(&1)); + assert_eq!(d.skipped.get(&Skipped::Use), Some(&1)); + } + #[test] + fn streaming_delivers_layers_before_shapes_and_stops_on_error() { + let s = r#""#; + let mut events = Vec::new(); + let result = visit(s, &mut |event| { + match event { + Event::Layer(name) => events.push(name), + Event::Shape(_) => { + events.push("shape".into()); + return Err(Error("stop".into())); + } + } + Ok(()) + }); + assert!(result.is_err()); + assert_eq!(events, ["cut", "shape"]); + } + + #[test] + fn refuses_excessive_nesting() { + let s = format!("{}{}", "".repeat(100), "".repeat(100)); + assert!(import(&s).is_err()); + } +} diff --git a/crates/svg/src/path_data.rs b/crates/svg/src/path_data.rs new file mode 100644 index 000000000..96d0db771 --- /dev/null +++ b/crates/svg/src/path_data.rs @@ -0,0 +1,456 @@ +//! SVG path data as neutral line, cubic and elliptical arc segments. +//! +//! Relative commands and smooth controls are resolved, while arcs remain arcs. +//! The caller chooses how to map the result to its own geometry model. +use std::ops::{Add, Mul, Sub}; + +/// A point in the path's original user coordinate system. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct Point { + /// Horizontal coordinate. + pub x: f64, + /// Vertical coordinate. + pub y: f64, +} +impl Point { + /// The origin. + pub const ZERO: Self = Self { x: 0.0, y: 0.0 }; + /// Construct a point. + pub const fn new(x: f64, y: f64) -> Self { + Self { x, y } + } +} +impl Add for Point { + type Output = Self; + fn add(self, rhs: Self) -> Self { + Self::new(self.x + rhs.x, self.y + rhs.y) + } +} +impl Sub for Point { + type Output = Self; + fn sub(self, rhs: Self) -> Self { + Self::new(self.x - rhs.x, self.y - rhs.y) + } +} +impl Mul for Point { + type Output = Self; + fn mul(self, rhs: f64) -> Self { + Self::new(self.x * rhs, self.y * rhs) + } +} + +/// Invalid or oversized path data. +#[derive(Debug, thiserror::Error)] +#[error("{0}")] +pub struct Error(pub String); +type Result = std::result::Result; +const MAX_PATH_SEGMENTS: usize = 100_000; +const MAX_CURVE_POINTS: usize = 100_001; + +pub(crate) struct Numbers<'a> { + s: &'a [u8], + i: usize, +} + +impl<'a> Numbers<'a> { + pub(crate) fn new(s: &'a str) -> Self { + Self { s: s.as_bytes(), i: 0 } + } + fn skip_seps(&mut self) { + while matches!(self.s.get(self.i), Some(b' ' | b'\t' | b'\r' | b'\n' | b',')) { + self.i += 1; + } + } + + fn next_num(&mut self) -> Option { + self.skip_seps(); + let start = self.i; + if matches!(self.s.get(self.i), Some(b'+' | b'-')) { + self.i += 1; + } + let mut digits = 0; + let mut dot = false; + let mut exp = false; + while let Some(c) = self.s.get(self.i) { + match c { + b'0'..=b'9' => { + digits += 1; + self.i += 1; + } + b'.' if !dot && !exp => { + dot = true; + self.i += 1; + } + b'e' | b'E' if !exp && digits > 0 => { + exp = true; + self.i += 1; + if matches!(self.s.get(self.i), Some(b'+' | b'-')) { + self.i += 1; + } + } + _ => break, + } + } + if digits == 0 { + self.i = start; + return None; + } + std::str::from_utf8(&self.s[start..self.i]).ok()?.parse::().ok().filter(|v| v.is_finite()) + } +} + +impl Iterator for Numbers<'_> { + type Item = f64; + fn next(&mut self) -> Option { + self.next_num() + } +} + +/// One `M …` run of a `d` attribute. +#[derive(Debug, Clone, PartialEq)] +pub struct Subpath { + /// Start point. + pub start: Point, + /// Segments in drawing order. + pub segs: Vec, + /// Whether a close-path command closed this subpath. + pub closed: bool, +} + +/// A path segment; arc values retain the SVG endpoint parameterization. +#[derive(Debug, Clone, PartialEq)] +pub enum Segment { + Line(Point), + Cubic(Point, Point, Point), + Arc { rx: f64, ry: f64, rot: f64, large: bool, sweep: bool, end: Point }, +} + +/// Tokens of a `d` attribute: command letters and numbers, in order. +enum Tok { + Cmd(u8), + Num(f64), +} + +struct Tokenizer<'a> { + s: &'a [u8], + i: usize, + /// Start of the most recently returned token. + tok_start: usize, +} + +impl<'a> Tokenizer<'a> { + fn new(s: &'a str) -> Self { + Tokenizer { s: s.as_bytes(), i: 0, tok_start: 0 } + } + + /// Read an arc flag: a single `0` or `1` character, which needs no separator after it. + fn next_flag(&mut self) -> Option { + let mut nums = Numbers { s: self.s, i: self.i }; + nums.skip_seps(); + let v = match self.s.get(nums.i)? { + b'0' => 0.0, + b'1' => 1.0, + _ => return None, + }; + self.i = nums.i + 1; + Some(v) + } + + fn next_tok(&mut self) -> Option { + let mut nums = Numbers { s: self.s, i: self.i }; + nums.skip_seps(); + self.i = nums.i; + self.tok_start = self.i; + let c = self.s.get(self.i).copied()?; + if c.is_ascii_alphabetic() { + self.i += 1; + return Some(Tok::Cmd(c)); + } + let tok = nums.next_num().map(Tok::Num); + self.i = nums.i; + tok + } +} + +/// Split `d` into subpaths, resolving relative commands and the S/T control reflections. +pub fn parse_path(d: &str) -> Result> { + let mut tk = Tokenizer::new(d); + let mut lookahead: Option = None; + let mut cmd = 0u8; + let mut cur = Point::ZERO; + let mut start = Point::ZERO; + let mut segs: Vec = Vec::new(); + let mut out: Vec = Vec::new(); + let closed = false; + let mut prev_cubic: Option = None; + let mut prev_quad: Option = None; + let mut segments = 0usize; + + let next_num = |tk: &mut Tokenizer, look: &mut Option| -> Result { + match look.take() { + Some(Tok::Num(v)) => Ok(v), + Some(other @ Tok::Cmd(_)) => { + *look = Some(other); + Err(Error("SVG: path command is missing coordinates".into())) + } + None => match tk.next_tok() { + Some(Tok::Num(v)) => Ok(v), + Some(other @ Tok::Cmd(_)) => { + *look = Some(other); + Err(Error("SVG: path command is missing coordinates".into())) + } + None => Err(Error("SVG: path command is missing coordinates".into())), + }, + } + }; + + while let Some(tok) = lookahead.take().or_else(|| tk.next_tok()) { + let rel = match tok { + Tok::Cmd(c) => { + if c.eq_ignore_ascii_case(&b'z') { + if !segs.is_empty() { + out.push(Subpath { start, segs, closed: true }); + segs = Vec::new(); + } + cur = start; + cmd = 0; + continue; + } + cmd = c; + c.is_ascii_lowercase() + } + tok @ Tok::Num(_) => { + if cmd == 0 { + return Err(Error("SVG: path data does not start with a command".into())); + } + lookahead = Some(tok); + cmd.is_ascii_lowercase() + } + }; + let abs = cmd.to_ascii_uppercase(); + let count = match abs { + b'M' | b'L' | b'T' => 2, + b'H' | b'V' => 1, + b'C' => 6, + b'S' | b'Q' => 4, + b'A' => 7, + _ => return Err(Error(format!("SVG: unknown path command `{}`", cmd as char))), + }; + let mut args = [0.0f64; 7]; + for (idx, slot) in args.iter_mut().enumerate().take(count) { + if abs == b'A' && (idx == 3 || idx == 4) { + // Flags are single characters; re-scan a pending number token from its start. + if matches!(lookahead, Some(Tok::Num(_))) { + lookahead = None; + tk.i = tk.tok_start; + } + if lookahead.is_none() { + *slot = tk.next_flag().ok_or_else(|| Error("SVG: path command is missing coordinates".into()))?; + continue; + } + } + *slot = next_num(&mut tk, &mut lookahead)?; + } + let point = |x: f64, y: f64| if rel { cur + Point::new(x, y) } else { Point::new(x, y) }; + match abs { + b'M' => { + if !segs.is_empty() { + out.push(Subpath { start, segs, closed: false }); + segs = Vec::new(); + } + cur = point(args[0], args[1]); + start = cur; + cmd = if rel { b'l' } else { b'L' }; + prev_cubic = None; + prev_quad = None; + } + b'L' => { + cur = point(args[0], args[1]); + segs.push(Segment::Line(cur)); + prev_cubic = None; + prev_quad = None; + } + b'H' => { + cur = Point::new(if rel { cur.x + args[0] } else { args[0] }, cur.y); + segs.push(Segment::Line(cur)); + prev_cubic = None; + prev_quad = None; + } + b'V' => { + cur = Point::new(cur.x, if rel { cur.y + args[0] } else { args[0] }); + segs.push(Segment::Line(cur)); + prev_cubic = None; + prev_quad = None; + } + b'C' => { + let (c1, c2, p) = (point(args[0], args[1]), point(args[2], args[3]), point(args[4], args[5])); + segs.push(Segment::Cubic(c1, c2, p)); + prev_cubic = Some(c2); + prev_quad = None; + cur = p; + } + b'S' => { + let c1 = prev_cubic.map_or(cur, |c2| cur * 2.0 - c2); + let (c2, p) = (point(args[0], args[1]), point(args[2], args[3])); + segs.push(Segment::Cubic(c1, c2, p)); + prev_cubic = Some(c2); + prev_quad = None; + cur = p; + } + b'Q' => { + let (q, p) = (point(args[0], args[1]), point(args[2], args[3])); + segs.push(Segment::Cubic(cur + (q - cur) * (2.0 / 3.0), p + (q - p) * (2.0 / 3.0), p)); + prev_quad = Some(q); + prev_cubic = None; + cur = p; + } + b'T' => { + let reflect = prev_quad.map_or(cur, |q| cur * 2.0 - q); + let p = point(args[0], args[1]); + segs.push(Segment::Cubic(cur + (reflect - cur) * (2.0 / 3.0), p + (reflect - p) * (2.0 / 3.0), p)); + prev_quad = Some(reflect); + prev_cubic = None; + cur = p; + } + b'A' => { + let end = point(args[5], args[6]); + segs.push(Segment::Arc { rx: args[0].abs(), ry: args[1].abs(), rot: args[2], large: args[3] != 0.0, sweep: args[4] != 0.0, end }); + cur = end; + prev_cubic = None; + prev_quad = None; + } + _ => return Err(Error("SVG: unsupported path command".into())), + } + segments += 1; + if segments > MAX_PATH_SEGMENTS { + return Err(Error("SVG: path has too many segments".into())); + } + if segs.len() > MAX_CURVE_POINTS { + return Err(Error("SVG: path has too many segments".into())); + } + } + if !segs.is_empty() { + out.push(Subpath { start, segs, closed }); + } + Ok(out) +} +/// The centre and signed sweep of a circular arc from `p0` to `p1` in a Y-up frame, per the +/// SVG endpoint parameterisation (F.6.5). Radii that cannot span the chord are scaled up, +/// as the specification requires. +pub fn arc_center_circular(p0: Point, p1: Point, r: f64, large: bool, sweep: bool) -> Option<(Point, f64)> { + if r <= 0.0 || !r.is_finite() { + return None; + } + let d = p1 - p0; + let dist = d.x.hypot(d.y); + let r = if dist > 2.0 * r { dist / 2.0 } else { r }; + if dist <= f64::EPSILON { + return None; + } + let mid = (p0 + p1) * 0.5; + let h = (r * r - (dist * dist) / 4.0).max(0.0).sqrt(); + let n = Point::new(-d.y / dist, d.x / dist); + let sign = if large != sweep { 1.0 } else { -1.0 }; + let center = mid + n * (h * sign); + let a0 = (p0.y - center.y).atan2(p0.x - center.x); + let a1 = (p1.y - center.y).atan2(p1.x - center.x); + let ccw = (a1 - a0).rem_euclid(std::f64::consts::TAU); + Some((center, pick_sweep(ccw, large, sweep))) +} + +/// The signed sweep (CCW positive) for a chord sweep `ccw` in `[0, 2π)`: the centre is +/// already chosen so that the magnitude matches `large`, so only the direction is left. +fn pick_sweep(ccw: f64, large: bool, sweep: bool) -> f64 { + let tau = std::f64::consts::TAU; + let eps = f64::EPSILON; + if sweep { + if ccw <= eps { if large { tau } else { eps } } else { ccw } + } else if ccw >= tau - eps { + if large { -tau } else { -eps } + } else { + ccw - tau + } +} + +/// Endpoint → centre parameterisation for a rotated elliptical arc (SVG F.6.5), in the +/// frame the points are given in. Returns the centre, the start parameter and the signed +/// sweep. +pub fn elliptical_params(p0: Point, p1: Point, rx: f64, ry: f64, phi: f64, large: bool, sweep: bool) -> Option<(Point, f64, f64)> { + if rx <= 0.0 || ry <= 0.0 { + return None; + } + let (sphi, cphi) = phi.sin_cos(); + let dx = (p0.x - p1.x) / 2.0; + let dy = (p0.y - p1.y) / 2.0; + let x1 = cphi * dx + sphi * dy; + let y1 = -sphi * dx + cphi * dy; + let (rx, ry) = { + let lambda = x1 * x1 / (rx * rx) + y1 * y1 / (ry * ry); + if lambda > 1.0 { + let s = lambda.sqrt(); + (rx * s, ry * s) + } else { + (rx, ry) + } + }; + let num = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1; + let den = rx * rx * y1 * y1 + ry * ry * x1 * x1; + let coef = if sweep != large { 1.0 } else { -1.0 } * (num.max(0.0) / den.max(f64::MIN_POSITIVE)).sqrt(); + let cxp = coef * rx * y1 / ry; + let cyp = -coef * ry * x1 / rx; + let center = Point::new(cphi * cxp - sphi * cyp + (p0.x + p1.x) / 2.0, sphi * cxp + cphi * cyp + (p0.y + p1.y) / 2.0); + let angle = |ux: f64, uy: f64, vx: f64, vy: f64| { + let dot = ux * vx + uy * vy; + let det = ux * vy - uy * vx; + let denom = (ux.hypot(uy) * vx.hypot(vy)).max(f64::MIN_POSITIVE); + (dot / denom).clamp(-1.0, 1.0).acos().copysign(det) + }; + let (ux, uy) = ((x1 - cxp) / rx, (y1 - cyp) / ry); + let (vx, vy) = ((-x1 - cxp) / rx, (-y1 - cyp) / ry); + let theta = angle(1.0, 0.0, ux, uy); + let ccw = angle(ux, uy, vx, vy).rem_euclid(std::f64::consts::TAU); + Some((center, theta, pick_sweep(ccw, large, sweep))) +} + +#[cfg(test)] +mod tests { + #![allow(clippy::unwrap_used)] + use super::*; + + #[test] + fn resolves_relative_and_smooth_commands_without_flattening_arcs() { + let paths = parse_path("M1 2 l3 4 C5 6 7 8 9 10 s2 3 4 5 A6 7 30 0110 12 z").unwrap(); + assert_eq!(paths.len(), 1); + assert!(paths[0].closed); + assert_eq!(paths[0].start, Point::new(1.0, 2.0)); + assert_eq!(paths[0].segs[0], Segment::Line(Point::new(4.0, 6.0))); + assert_eq!(paths[0].segs[2], Segment::Cubic(Point::new(11.0, 12.0), Point::new(11.0, 13.0), Point::new(13.0, 15.0))); + assert_eq!(paths[0].segs[3], Segment::Arc { rx: 6.0, ry: 7.0, rot: 30.0, large: false, sweep: true, end: Point::new(10.0, 12.0) }); + } + + #[test] + fn smooth_quadratic_consumes_both_coordinates() { + let paths = parse_path("M0 0 Q3 3 6 0 T12 0").unwrap(); + assert_eq!(paths[0].segs[1], Segment::Cubic(Point::new(8.0, -2.0), Point::new(10.0, -2.0), Point::new(12.0, 0.0))); + } + + #[test] + fn arc_centers_keep_radius_correction_and_sweep() { + let (center, delta) = arc_center_circular(Point::new(0.0, 0.0), Point::new(10.0, 0.0), 2.0, false, true).unwrap(); + assert!((center.x - 5.0).abs() < 1e-10); + assert!(center.y.abs() < 1e-10); + assert!((delta - std::f64::consts::PI).abs() < 1e-10); + let (center, start, sweep) = elliptical_params(Point::new(0.0, 0.0), Point::new(10.0, 0.0), 2.0, 1.0, 0.0, false, true).unwrap(); + assert!((center.x - 5.0).abs() < 1e-10); + assert!(center.y.abs() < 1e-10 && start.is_finite()); + assert!((sweep - std::f64::consts::PI).abs() < 1e-10); + } + + #[test] + fn rejects_invalid_flags_and_limits_segments() { + assert!(parse_path("M0 0 A1 1 0 5 1 2 2").is_err()); + assert!(parse_path("M0 0 L").is_err()); + let excessive = format!("M0 0{}", " L1 1".repeat(MAX_PATH_SEGMENTS)); + assert!(parse_path(&excessive).is_err()); + } +} From 373d36ea3f66be15b826c861681147e32314b875 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:18:47 +0000 Subject: [PATCH 103/382] Expose bounded stored image dimensions --- crates/image-codecs/src/allocation.rs | 49 +++++++++++++++++++++++++++ crates/image-codecs/src/lib.rs | 2 +- 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/crates/image-codecs/src/allocation.rs b/crates/image-codecs/src/allocation.rs index fe98122e7..40d55dfc8 100644 --- a/crates/image-codecs/src/allocation.rs +++ b/crates/image-codecs/src/allocation.rs @@ -247,3 +247,52 @@ fn read_le24(bytes: &[u8], at: usize) -> Option { let b = bytes.get(at..at.checked_add(3)?)?; Some(u32::from_le_bytes([b[0], b[1], b[2], 0])) } + +/// Probe the stored dimensions of the first PNG, JPEG, BMP or TIFF image, without decoding +/// pixels or applying orientation. TIFF uses the first directory even if it is a thumbnail. +/// The caller's limits bound both the header decoder and the declared output dimensions. +pub fn probe_stored_size(bytes: &[u8], limits: &crate::Limits) -> Result<(u32, u32), CodecError> { + use std::io::Cursor; + let format = crate::detect(bytes).ok_or(CodecError::UnknownFormat)?; + if !matches!(format, Format::Png | Format::Jpeg | Format::Bmp | Format::Tiff) { + return Err(CodecError::unsupported(format, "stored-size probe is not available for this format")); + } + let mut reader = image::ImageReader::new(Cursor::new(bytes)).with_guessed_format().map_err(|e| CodecError::malformed(format, e))?; + let mut image_limits = image::Limits::default(); + image_limits.max_image_width = Some(limits.max_width); + image_limits.max_image_height = Some(limits.max_height); + image_limits.max_alloc = Some(limits.max_alloc); + reader.limits(image_limits); + let (w, h) = reader.into_dimensions().map_err(|e| CodecError::malformed(format, e))?; + limits.check_size(w, h)?; + Ok((w, h)) +} + +#[cfg(test)] +mod stored_size_tests { + #![allow(clippy::unwrap_used)] + use super::*; + use std::io::Cursor; + + #[test] + fn stored_probe_uses_caller_limits_without_decoding() { + let mut bmp = Cursor::new(Vec::new()); + image::write_buffer_with_format(&mut bmp, &vec![0; 300_000 * 3], 1, 300_000, image::ExtendedColorType::Rgb8, image::ImageFormat::Bmp) + .unwrap(); + let bytes = bmp.into_inner(); + let limits = crate::Limits::new(u32::MAX, u32::MAX, 128_000_000, 2_048_000_000); + assert_eq!(probe_stored_size(&bytes, &limits).unwrap(), (1, 300_000)); + assert!(probe_stored_size(&bytes, &crate::Limits::default()).is_err()); + assert!(probe_stored_size(&bytes[..20], &limits).is_err()); + } + + #[test] + fn common_stored_headers_are_probed() { + let limits = crate::Limits::new(100, 100, 10_000, 1 << 20); + for format in [image::ImageFormat::Png, image::ImageFormat::Jpeg, image::ImageFormat::Bmp, image::ImageFormat::Tiff] { + let mut out = Cursor::new(Vec::new()); + image::write_buffer_with_format(&mut out, &[10; 18], 3, 2, image::ExtendedColorType::Rgb8, format).unwrap(); + assert_eq!(probe_stored_size(&out.into_inner(), &limits).unwrap(), (3, 2), "{format:?}"); + } + } +} diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 6516b9ff2..5cd1b9c60 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -31,7 +31,7 @@ pub mod orientation; pub mod resolution; pub mod source_settings; pub mod web; -pub use crate::allocation::probe_allocation_size; +pub use crate::allocation::{probe_allocation_size, probe_stored_size}; pub use crate::cicp::Cicp; pub use crate::cicp::ContentLightLevel; pub use crate::codecs::avif::{HDR_REFERENCE_WHITE_NITS, HdrTransfer, encode_avif_hdr, encode_avif_with_speed}; From 89cbc41650393266d30344df1af38da858920f78 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:22:39 +0000 Subject: [PATCH 104/382] Satisfy SVG reader clippy gate --- crates/svg/src/neutral_document.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/crates/svg/src/neutral_document.rs b/crates/svg/src/neutral_document.rs index 24294684a..17f352058 100644 --- a/crates/svg/src/neutral_document.rs +++ b/crates/svg/src/neutral_document.rs @@ -231,10 +231,11 @@ impl Walker<'_> { if !CONTAINERS.contains(&name) { return self.element(name, e); } - if name == b"svg" && self.stack.len() == 1 { - if let Some(root) = self.stack.first_mut() { - *root = viewport(e); - } + if name == b"svg" + && self.stack.len() == 1 + && let Some(root) = self.stack.first_mut() + { + *root = viewport(e); } if name == b"g" && attr(e, b"inkscape:groupmode").as_deref() == Some("layer") From ae5020c1ed922cf7976a3a5545f05b07f466be12 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:23:57 +0000 Subject: [PATCH 105/382] Use a BMP size supported by the baseline decoder --- crates/image-codecs/src/allocation.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/crates/image-codecs/src/allocation.rs b/crates/image-codecs/src/allocation.rs index 40d55dfc8..a31684a33 100644 --- a/crates/image-codecs/src/allocation.rs +++ b/crates/image-codecs/src/allocation.rs @@ -277,12 +277,11 @@ mod stored_size_tests { #[test] fn stored_probe_uses_caller_limits_without_decoding() { let mut bmp = Cursor::new(Vec::new()); - image::write_buffer_with_format(&mut bmp, &vec![0; 300_000 * 3], 1, 300_000, image::ExtendedColorType::Rgb8, image::ImageFormat::Bmp) - .unwrap(); + image::write_buffer_with_format(&mut bmp, &vec![0; 60_000 * 3], 1, 60_000, image::ExtendedColorType::Rgb8, image::ImageFormat::Bmp).unwrap(); let bytes = bmp.into_inner(); let limits = crate::Limits::new(u32::MAX, u32::MAX, 128_000_000, 2_048_000_000); - assert_eq!(probe_stored_size(&bytes, &limits).unwrap(), (1, 300_000)); - assert!(probe_stored_size(&bytes, &crate::Limits::default()).is_err()); + assert_eq!(probe_stored_size(&bytes, &limits).unwrap(), (1, 60_000)); + assert!(probe_stored_size(&bytes, &crate::Limits::new(u32::MAX, 50_000, u64::MAX, 2_048_000_000)).is_err()); assert!(probe_stored_size(&bytes[..20], &limits).is_err()); } From 7b51909d40deb15397ec90695dc611bde5d13e34 Mon Sep 17 00:00:00 2001 From: Francesco BV Date: Sun, 15 Nov 2026 10:28:08 -0500 Subject: [PATCH 106/382] shx: preserve CADCraft shape compiler and errors Original source by Francesco BV in cadcraft52c1e6de, copied from main7064a685. App font lookup, text layout and glyph interpretation are not moved. --- crates/shx/src/compile.rs | 313 ++++++++++++++++++++++++++++++++++++++ crates/shx/src/error.rs | 29 ++++ 2 files changed, 342 insertions(+) create mode 100644 crates/shx/src/compile.rs create mode 100644 crates/shx/src/error.rs diff --git a/crates/shx/src/compile.rs b/crates/shx/src/compile.rs new file mode 100644 index 000000000..2e8cb3c25 --- /dev/null +++ b/crates/shx/src/compile.rs @@ -0,0 +1,313 @@ +//! Shape source (`.shp`) to a compiled SHX file, as COMPILE does. +//! +//! A source is a list of definitions: a header line `*number,defbytes,NAME` followed by its +//! specification bytes (on as many lines as needed, ending with 0). Numbers are decimal, or +//! hexadecimal after a leading `0` (`012`, `08cfb`); parentheses only group; `;` starts a +//! comment. A big font starts with `*BIGFONT nchars,nranges,first,last,…` and a Unicode font +//! with `*UNIFONT,6,name` followed by `above,below,modes,encoding,type,0`. Shape 0 is a text +//! font's record (`above,below,modes,0`). +//! +//! Operands are encoded by what they are: a subshape number takes two bytes in a Unicode font +//! (and after `7,0` in a big font), displacements and bulges are two's complement, and an arc's +//! direction byte (`-043`) keeps its sign in the high bit. `defbytes` is not checked: the +//! program's own length is written. + +use super::ShxError; +use super::parse::{BIGFONT, SHAPES_10, UNIFONT}; + +/// Largest source compiled. +const MAX_SOURCE: usize = 8 << 20; + +#[derive(Clone, Copy, PartialEq)] +enum Kind { + Shapes, + Big, + Uni, +} + +struct Shape { + number: u16, + name: String, + program: Vec, +} + +/// A number token: value (sign included). +fn number(tok: &str, line: usize) -> Result { + let t: String = tok.chars().filter(|c| !matches!(c, '(' | ')') && !c.is_whitespace()).collect(); + let (neg, digits) = match t.strip_prefix('-') { + Some(d) => (true, d), + None => (false, t.strip_prefix('+').unwrap_or(&t)), + }; + let err = || ShxError::Source(line, format!("not a number: {tok:?}")); + let v = if digits.len() > 1 && digits.starts_with('0') { + i64::from_str_radix(digits.get(1..).unwrap_or_default(), 16).map_err(|_| err())? + } else { + digits.parse::().map_err(|_| err())? + }; + if v > 0xFFFF { + return Err(err()); + } + Ok(if neg { -v } else { v }) +} + +/// The comma-separated numbers of a line (comment removed, blank fields skipped). +fn numbers(text: &str, line: usize) -> Result, ShxError> { + text.split(',').map(str::trim).filter(|t| !t.is_empty() && *t != "(" && *t != ")").map(|t| number(t, line)).collect() +} + +/// The spec-byte encoder: walks the tokens as the reader walks the bytes. +struct Enc<'a> { + toks: &'a [i64], + i: usize, + out: Vec, + kind: Kind, + line: usize, +} + +impl Enc<'_> { + fn next(&mut self) -> Result { + let v = self.toks.get(self.i).copied().ok_or_else(|| ShxError::Source(self.line, "the shape ends inside a command".into()))?; + self.i += 1; + Ok(v) + } + fn byte(&mut self) -> Result<(), ShxError> { + let v = self.next()?; + let b = u8::try_from(v).map_err(|_| ShxError::Source(self.line, format!("{v} is not a byte")))?; + self.out.push(b); + Ok(()) + } + /// Two's complement −128..127. + fn signed(&mut self) -> Result { + let v = self.next()?; + let b = i8::try_from(v).map_err(|_| ShxError::Source(self.line, format!("{v} is not −128..127")))?; + self.out.extend(b.to_le_bytes()); + Ok(v) + } + /// Sign in the high bit (an arc's direction byte). + fn sign_magnitude(&mut self) -> Result<(), ShxError> { + let v = self.next()?; + let m = u8::try_from(v.unsigned_abs()) + .ok() + .filter(|m| *m < 0x80) + .ok_or_else(|| ShxError::Source(self.line, format!("{v} is not an octant byte")))?; + self.out.push(if v < 0 { m | 0x80 } else { m }); + Ok(()) + } + fn word(&mut self) -> Result<(), ShxError> { + let v = self.next()?; + let w = u16::try_from(v).map_err(|_| ShxError::Source(self.line, format!("{v} is not a shape number")))?; + self.out.extend(w.to_be_bytes()); + Ok(()) + } + + fn program(mut self) -> Result, ShxError> { + while self.i < self.toks.len() { + let code = self.next()?; + let c = u8::try_from(code).map_err(|_| ShxError::Source(self.line, format!("{code} is not a code")))?; + self.out.push(c); + match c { + 0 => break, + 3 | 4 => self.byte()?, + 7 => match self.kind { + Kind::Uni => self.word()?, + Kind::Big => { + let first = self.toks.get(self.i).copied().unwrap_or(0); + if first == 0 { + self.byte()?; + self.word()?; + for _ in 0..4 { + self.byte()?; + } + } else { + self.byte()?; + } + } + Kind::Shapes => self.byte()?, + }, + 8 => { + self.signed()?; + self.signed()?; + } + 9 => loop { + let (x, y) = (self.signed()?, self.signed()?); + if x == 0 && y == 0 { + break; + } + }, + 10 => { + self.byte()?; + self.sign_magnitude()?; + } + 11 => { + for _ in 0..4 { + self.byte()?; + } + self.sign_magnitude()?; + } + 12 => { + for _ in 0..3 { + self.signed()?; + } + } + 13 => loop { + let (x, y) = (self.signed()?, self.signed()?); + if x == 0 && y == 0 { + break; + } + self.signed()?; + }, + _ => {} + } + } + if self.out.last() != Some(&0) { + self.out.push(0); + } + Ok(self.out) + } +} + +/// Compile shape source into an SHX file (a shape file or text font, a big font, or a Unicode +/// font, as its first definition says). +pub fn compile(source: &str) -> Result, ShxError> { + if source.len() > MAX_SOURCE { + return Err(ShxError::TooLarge); + } + let mut kind = Kind::Shapes; + let mut ranges: Vec<(u16, u16)> = Vec::new(); + let mut uni_info: Option<(String, Vec)> = None; + // Definitions: header (number, name, line) and the numbers that follow it. + let mut defs: Vec<(i64, String, usize, Vec)> = Vec::new(); + let mut uni_header_pending = false; + for (no, raw) in source.lines().enumerate() { + let line = no + 1; + let text = raw.split(';').next().unwrap_or_default().trim(); + if text.is_empty() { + continue; + } + if let Some(head) = text.strip_prefix('*') { + let upper = head.trim_start().to_ascii_uppercase(); + if let Some(rest) = upper.strip_prefix("BIGFONT") { + kind = Kind::Big; + let v = numbers(rest, line)?; + let n = usize::try_from(v.get(1).copied().unwrap_or(0)).unwrap_or(0); + for k in 0..n { + let lo = v.get(2 + 2 * k).copied().unwrap_or(0); + let hi = v.get(3 + 2 * k).copied().unwrap_or(lo); + let to = |x: i64| u16::try_from(x).map_err(|_| ShxError::Source(line, "bad escape range".into())); + ranges.push((to(lo)?, to(hi)?)); + } + continue; + } + if upper.starts_with("UNIFONT") { + kind = Kind::Uni; + let name = head.splitn(3, ',').nth(2).unwrap_or_default().trim().to_string(); + uni_info = Some((name, Vec::new())); + uni_header_pending = true; + continue; + } + uni_header_pending = false; + let mut parts = head.splitn(3, ','); + let num = number(parts.next().unwrap_or_default().trim(), line)?; + let _defbytes = parts.next(); + let name = parts.next().unwrap_or_default().trim().to_string(); + defs.push((num, name, line, Vec::new())); + continue; + } + let v = numbers(text, line)?; + if uni_header_pending { + if let Some((_, info)) = uni_info.as_mut() { + for x in v { + info.push(u8::try_from(x).map_err(|_| ShxError::Source(line, "bad font record".into()))?); + } + } + continue; + } + match defs.last_mut() { + Some(d) => d.3.extend(v), + None => return Err(ShxError::Source(line, "specification bytes before any *number,defbytes,NAME line".into())), + } + } + let mut shapes: Vec = Vec::new(); + for (num, name, line, toks) in defs { + let number = u16::try_from(num).map_err(|_| ShxError::Source(line, format!("shape number {num} out of range")))?; + let program = if number == 0 { + // The font record: plain bytes. + toks.iter().map(|x| u8::try_from(*x).map_err(|_| ShxError::Source(line, "bad font record".into()))).collect::, _>>()? + } else { + Enc { toks: &toks, i: 0, out: Vec::new(), kind, line }.program()? + }; + if shapes.iter().any(|s| s.number == number) { + return Err(ShxError::Source(line, format!("shape {number} is defined twice"))); + } + shapes.push(Shape { number, name, program }); + } + if shapes.is_empty() { + return Err(ShxError::Empty); + } + shapes.sort_by_key(|s| s.number); + let record = |s: &Shape| -> Result, ShxError> { + let mut r: Vec = s.name.bytes().filter(|b| *b != 0).collect(); + r.push(0); + r.extend(&s.program); + if r.len() > usize::from(u16::MAX) { Err(ShxError::TooLarge) } else { Ok(r) } + }; + let count = u16::try_from(shapes.len()).map_err(|_| ShxError::TooLarge)?; + let len16 = |r: &[u8]| u16::try_from(r.len()).unwrap_or(u16::MAX); + let mut out = Vec::new(); + match kind { + Kind::Shapes => { + out.extend(SHAPES_10); + out.extend(shapes.first().map_or(0, |s| s.number).to_le_bytes()); + out.extend(shapes.last().map_or(0, |s| s.number).to_le_bytes()); + out.extend(count.to_le_bytes()); + let recs: Vec> = shapes.iter().map(record).collect::>()?; + for (s, r) in shapes.iter().zip(&recs) { + out.extend(s.number.to_le_bytes()); + out.extend(len16(r).to_le_bytes()); + } + for r in &recs { + out.extend(r); + } + out.extend(b"EOF"); + } + Kind::Big => { + out.extend(BIGFONT); + let nranges = u16::try_from(ranges.len()).map_err(|_| ShxError::TooLarge)?; + out.extend(count.to_le_bytes()); + out.extend(count.to_le_bytes()); + out.extend(nranges.to_le_bytes()); + for (lo, hi) in &ranges { + out.extend(lo.to_le_bytes()); + out.extend(hi.to_le_bytes()); + } + let recs: Vec> = shapes.iter().map(record).collect::>()?; + let mut off = out.len() + 8 * recs.len(); + for (s, r) in shapes.iter().zip(&recs) { + out.extend(s.number.to_le_bytes()); + out.extend(len16(r).to_le_bytes()); + out.extend(u32::try_from(off).map_err(|_| ShxError::TooLarge)?.to_le_bytes()); + off += r.len(); + } + for r in &recs { + out.extend(r); + } + } + Kind::Uni => { + out.extend(UNIFONT); + let (name, info) = uni_info.unwrap_or_default(); + out.extend((u32::from(count) + 1).to_le_bytes()); + let mut rec: Vec = name.bytes().filter(|b| *b != 0).collect(); + rec.push(0); + rec.extend(&info); + out.extend(len16(&rec).to_le_bytes()); + out.extend(&rec); + for s in &shapes { + let r = record(s)?; + out.extend(s.number.to_le_bytes()); + out.extend(len16(&r).to_le_bytes()); + out.extend(r); + } + } + } + Ok(out) +} diff --git a/crates/shx/src/error.rs b/crates/shx/src/error.rs new file mode 100644 index 000000000..0addd1c98 --- /dev/null +++ b/crates/shx/src/error.rs @@ -0,0 +1,29 @@ +/// Why a font file can't be read or a shape source can't be compiled. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum ShxError { + /// Not an SHX file (unknown signature). + NotShx, + /// The file ends inside its header or index. + Truncated, + /// The file is larger, or has more of something, than CADCraft reads. + TooLarge, + /// The file is well-formed but holds no shape. + Empty, + /// Shape source error: line and message. + Source(usize, String), +} + +impl std::fmt::Display for ShxError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ShxError::NotShx => f.write_str("not an SHX shape or font file"), + ShxError::Truncated => f.write_str("the SHX file is truncated"), + ShxError::TooLarge => f.write_str("the SHX file is too large"), + ShxError::Empty => f.write_str("the SHX file has no shapes"), + ShxError::Source(line, msg) => write!(f, "line {line}: {msg}"), + } + } +} + +impl std::error::Error for ShxError {} + From 2c9903ca1d892b5446acf3598d8b142f3e64842f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:29:27 +0000 Subject: [PATCH 107/382] Support configurable legacy MCP sessions and envelopes --- crates/jsonrpc/src/lib.rs | 58 ++++++++++++++++++++++++++++++ crates/mcp/src/lib.rs | 74 +++++++++++++++++++++++++++++++++++++-- 2 files changed, 129 insertions(+), 3 deletions(-) diff --git a/crates/jsonrpc/src/lib.rs b/crates/jsonrpc/src/lib.rs index 9f8128d1d..cfb46ef79 100644 --- a/crates/jsonrpc/src/lib.rs +++ b/crates/jsonrpc/src/lib.rs @@ -195,3 +195,61 @@ where let responses: Vec<_> = batch.iter().filter_map(|v| one(v, limits, &mut on_request, &mut on_notification)).collect(); Ok((!responses.is_empty()).then_some(Value::Array(responses))) } +/// Process a permissive legacy JSON-RPC envelope. This mode accepts arbitrary IDs and +/// parameter shapes, ignores response envelopes, and retains legacy diagnostic messages. +/// The caller supplies dispatch and notification callbacks, and should bound transport input. +pub fn process_legacy(value: &Value, mut on_request: F, mut on_notification: N) -> Option +where + F: FnMut(Request<'_>) -> Result, + N: FnMut(Request<'_>), +{ + fn one(value: &Value, on_request: &mut F, on_notification: &mut N) -> Option + where + F: FnMut(Request<'_>) -> Result, + N: FnMut(Request<'_>), + { + let Some(object) = value.as_object() else { return Some(error_response(Value::Null, RpcError::new(-32600, "message must be an object"))) }; + let id = object.get("id"); + let Some(method) = object.get("method").and_then(Value::as_str) else { + if object.contains_key("result") || object.contains_key("error") { + return None; + } + return Some(error_response(id.cloned().unwrap_or(Value::Null), RpcError::new(-32600, "missing `method`"))); + }; + let request = Request { id, method, params: object.get("params") }; + let Some(id) = id else { + on_notification(request); + return None; + }; + Some(match on_request(request) { + Ok(result) => json!({"jsonrpc": "2.0", "id": id, "result": result}), + Err(error) => error_response(id.clone(), error), + }) + } + if let Some(batch) = value.as_array() { + if batch.is_empty() { + return Some(error_response(Value::Null, RpcError::new(-32600, "empty batch"))); + } + let replies: Vec<_> = batch.iter().filter_map(|v| one(v, &mut on_request, &mut on_notification)).collect(); + (!replies.is_empty()).then_some(Value::Array(replies)) + } else { + one(value, &mut on_request, &mut on_notification) + } +} + +#[cfg(test)] +mod legacy_tests { + use super::*; + #[test] + fn preserves_legacy_batch_routing_and_errors() { + let input = json!([{"id": [1], "method":"echo", "params":5}, {"method":"notice"}, {"result":1}, {}, 7]); + let seen = std::cell::Cell::new(false); + let result = process_legacy(&input, |r| Ok(r.params.cloned().unwrap_or(Value::Null)), |_| seen.set(true)).unwrap(); + assert!(seen.get()); + assert_eq!( + result, + json!([{"jsonrpc":"2.0","id":[1],"result":5}, {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"missing `method`"}}, {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"message must be an object"}}]) + ); + assert_eq!(process_legacy(&json!([]), |_| Ok(Value::Null), |_| {}).unwrap()["error"]["message"], "empty batch"); + } +} diff --git a/crates/mcp/src/lib.rs b/crates/mcp/src/lib.rs index 96cfdc7ae..6ca888fc0 100644 --- a/crates/mcp/src/lib.rs +++ b/crates/mcp/src/lib.rs @@ -34,11 +34,27 @@ pub struct Session { policy: Policy, state: State, capabilities: Value, + versions: Vec, + permissive_initialize: bool, + server_info: Option, + instructions: Option, + initialized: bool, } impl Session { pub fn new(name: impl Into, version: impl Into, policy: Policy) -> Self { - Self { name: name.into(), version: version.into(), policy, state: State::New, capabilities: json!({"tools": {}}) } + Self { + name: name.into(), + version: version.into(), + policy, + state: State::New, + capabilities: json!({"tools": {}}), + versions: vec![PROTOCOL_VERSION.into()], + permissive_initialize: false, + server_info: None, + instructions: None, + initialized: false, + } } /// Set the server capabilities returned at initialization. The value must be an object. @@ -50,6 +66,27 @@ impl Session { Ok(self) } + /// Configure a permissive legacy server: absent or malformed initialize parameters are + /// accepted, supported client versions are echoed, and unknown versions use the first entry. + pub fn with_legacy_initialize(mut self, versions: &[&str], server_info: Value) -> Self { + if !versions.is_empty() { + self.versions = versions.iter().map(|v| (*v).to_owned()).collect(); + } + self.permissive_initialize = true; + self.server_info = Some(server_info); + self + } + + /// Update connection-specific instructions returned by subsequent initialize requests. + pub fn set_instructions(&mut self, instructions: String) { + self.instructions = Some(instructions); + } + + /// Whether an initialized notification has been observed, including before initialize. + pub fn is_initialized(&self) -> bool { + self.initialized + } + pub fn state(&self) -> State { self.state } @@ -64,6 +101,18 @@ impl Session { if self.policy == Policy::Strict && (in_batch || self.state != State::New) { return Some(Err(RpcError::new(-32600, "Invalid Request"))); } + if self.permissive_initialize { + let asked = request.params.and_then(|p| p.get("protocolVersion")).and_then(Value::as_str); + let version = asked + .filter(|v| self.versions.iter().any(|supported| supported == v)) + .unwrap_or_else(|| self.versions.first().map(String::as_str).unwrap_or(PROTOCOL_VERSION)); + let mut result = json!({"protocolVersion": version, "capabilities": self.capabilities, "serverInfo": self.server_info}); + if let Some(instructions) = &self.instructions { + result["instructions"] = json!(instructions); + } + self.state = State::AwaitingInitialized; + return Some(Ok(result)); + } let Some(params) = request.params.and_then(Value::as_object) else { return Some(Err(invalid_initialize())); }; @@ -89,8 +138,11 @@ impl Session { /// Observe a JSON-RPC notification; notifications never receive replies. pub fn notification(&mut self, request: Request<'_>) { - if request.method == "notifications/initialized" && self.state == State::AwaitingInitialized { - self.state = State::Ready; + if request.method == "notifications/initialized" { + self.initialized = true; + if self.state == State::AwaitingInitialized { + self.state = State::Ready; + } } } } @@ -127,6 +179,22 @@ mod tests { Request { id: None, method, params } } + #[test] + fn legacy_initialization_negotiates_and_accepts_missing_parameters() { + let mut s = Session::new("test", "1", Policy::Compatible).with_legacy_initialize(&["new", "old"], json!({"name":"custom", "title":"Title"})); + s.notification(call("notifications/initialized", None)); + assert!(s.is_initialized()); + s.set_instructions("help".into()); + for (params, expected) in + [(None, "new"), (Some(json!({"protocolVersion":"old"})), "old"), (Some(json!({"protocolVersion":"unknown"})), "new")] + { + let result = s.request(call("initialize", params.as_ref()), false).unwrap().unwrap(); + assert_eq!(result["protocolVersion"], expected); + assert_eq!(result["serverInfo"]["title"], "Title"); + assert_eq!(result["instructions"], "help"); + } + } + #[test] fn compatible_negotiation_preserves_existing_clients() { let mut s = Session::new("test", "1", Policy::Compatible); From b3307f7814629961841b80ab907116252e41b34d Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 10:30:48 -0500 Subject: [PATCH 108/382] shx: expose shared bounded shape compiler with hostile-source tests --- Cargo.lock | 4 ++++ Cargo.toml | 1 + crates/shx/Cargo.toml | 11 +++++++++++ crates/shx/README.md | 8 ++++++++ crates/shx/src/compile.rs | 20 +++++++++++++++++--- crates/shx/src/error.rs | 1 - crates/shx/src/lib.rs | 8 ++++++++ crates/shx/tests/compiler.rs | 30 ++++++++++++++++++++++++++++++ 8 files changed, 79 insertions(+), 4 deletions(-) create mode 100644 crates/shx/Cargo.toml create mode 100644 crates/shx/README.md create mode 100644 crates/shx/src/lib.rs create mode 100644 crates/shx/tests/compiler.rs diff --git a/Cargo.lock b/Cargo.lock index add90f8c2..3e9aeba59 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2610,6 +2610,10 @@ dependencies = [ name = "craft-sheet" version = "0.1.0" +[[package]] +name = "craft-shx" +version = "0.1.0" + [[package]] name = "craft-silhouette-studio" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index eae758e17..b68880781 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,7 @@ rust-version = "1.95" repository = "https://github.com/storytold/craft-libs" [workspace.dependencies] +craft-shx = { path = "crates/shx" } craft-smime = { path = "crates/smime" } craft-ber = { path = "crates/ber" } craft-proto = { path = "crates/proto" } diff --git a/crates/shx/Cargo.toml b/crates/shx/Cargo.toml new file mode 100644 index 000000000..012f9d2f9 --- /dev/null +++ b/crates/shx/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "craft-shx" +description = "Bounded SHP shape-source compiler for SHX shape, big-font and Unicode containers" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true + +[lints] +workspace = true diff --git a/crates/shx/README.md b/crates/shx/README.md new file mode 100644 index 000000000..691890447 --- /dev/null +++ b/crates/shx/README.md @@ -0,0 +1,8 @@ +# craft-shx + +Compiles SHP shape source into SHX shapes, big-font and Unicode containers. +Extracted from CADCraft by Francesco BV (cadcraft52c1e6de); no font assets are bundled. +App font discovery, text layout and glyph interpretation are not part of this crate. +The original 8 MiB source and u16 record bounds remain; malformed double signs, +excess escape ranges and oversized Unicode font records are refused. Duplicate +shape detection is linear rather than a repeated whole-list scan. diff --git a/crates/shx/src/compile.rs b/crates/shx/src/compile.rs index 2e8cb3c25..0d91a9545 100644 --- a/crates/shx/src/compile.rs +++ b/crates/shx/src/compile.rs @@ -13,7 +13,9 @@ //! program's own length is written. use super::ShxError; -use super::parse::{BIGFONT, SHAPES_10, UNIFONT}; +const SHAPES_10: &[u8] = b"AutoCAD-86 shapes 1.0\r\n\x1a"; +const BIGFONT: &[u8] = b"AutoCAD-86 bigfont 1.0\r\n\x1a"; +const UNIFONT: &[u8] = b"AutoCAD-86 unifont 1.0\r\n\x1a"; /// Largest source compiled. const MAX_SOURCE: usize = 8 << 20; @@ -44,7 +46,7 @@ fn number(tok: &str, line: usize) -> Result { } else { digits.parse::().map_err(|_| err())? }; - if v > 0xFFFF { + if !(0..=0xFFFF).contains(&v) { return Err(err()); } Ok(if neg { -v } else { v }) @@ -190,6 +192,11 @@ pub fn compile(source: &str) -> Result, ShxError> { kind = Kind::Big; let v = numbers(rest, line)?; let n = usize::try_from(v.get(1).copied().unwrap_or(0)).unwrap_or(0); + // A big font has byte-valued lead ranges. Bound repeated headers too, + // so a tiny declaration cannot amplify into millions of ranges. + if n > 256 || ranges.len().saturating_add(n) > 256 { + return Err(ShxError::TooLarge); + } for k in 0..n { let lo = v.get(2 + 2 * k).copied().unwrap_or(0); let hi = v.get(3 + 2 * k).copied().unwrap_or(lo); @@ -210,6 +217,9 @@ pub fn compile(source: &str) -> Result, ShxError> { let num = number(parts.next().unwrap_or_default().trim(), line)?; let _defbytes = parts.next(); let name = parts.next().unwrap_or_default().trim().to_string(); + if defs.len() >= usize::from(u16::MAX) { + return Err(ShxError::TooLarge); + } defs.push((num, name, line, Vec::new())); continue; } @@ -228,6 +238,7 @@ pub fn compile(source: &str) -> Result, ShxError> { } } let mut shapes: Vec = Vec::new(); + let mut seen = std::collections::HashSet::new(); for (num, name, line, toks) in defs { let number = u16::try_from(num).map_err(|_| ShxError::Source(line, format!("shape number {num} out of range")))?; let program = if number == 0 { @@ -236,7 +247,7 @@ pub fn compile(source: &str) -> Result, ShxError> { } else { Enc { toks: &toks, i: 0, out: Vec::new(), kind, line }.program()? }; - if shapes.iter().any(|s| s.number == number) { + if !seen.insert(number) { return Err(ShxError::Source(line, format!("shape {number} is defined twice"))); } shapes.push(Shape { number, name, program }); @@ -296,6 +307,9 @@ pub fn compile(source: &str) -> Result, ShxError> { out.extend(UNIFONT); let (name, info) = uni_info.unwrap_or_default(); out.extend((u32::from(count) + 1).to_le_bytes()); + if name.len().saturating_add(1).saturating_add(info.len()) > usize::from(u16::MAX) { + return Err(ShxError::TooLarge); + } let mut rec: Vec = name.bytes().filter(|b| *b != 0).collect(); rec.push(0); rec.extend(&info); diff --git a/crates/shx/src/error.rs b/crates/shx/src/error.rs index 0addd1c98..135214f54 100644 --- a/crates/shx/src/error.rs +++ b/crates/shx/src/error.rs @@ -26,4 +26,3 @@ impl std::fmt::Display for ShxError { } impl std::error::Error for ShxError {} - diff --git a/crates/shx/src/lib.rs b/crates/shx/src/lib.rs new file mode 100644 index 000000000..e595e90f5 --- /dev/null +++ b/crates/shx/src/lib.rs @@ -0,0 +1,8 @@ +#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] +#![forbid(unsafe_code)] +//! SHP source compilation to SHX containers, extracted from CADCraft. +//! Font discovery, glyph execution and text layout remain consumer responsibilities. +mod compile; +mod error; +pub use compile::compile; +pub use error::ShxError; diff --git a/crates/shx/tests/compiler.rs b/crates/shx/tests/compiler.rs new file mode 100644 index 000000000..f558e185a --- /dev/null +++ b/crates/shx/tests/compiler.rs @@ -0,0 +1,30 @@ +use craft_shx::{ShxError, compile}; + +#[test] +fn fixed_shape_bytes() { + let b = compile("*65,2,A\n010,0\n").unwrap(); + let mut expected = b"AutoCAD-86 shapes 1.0\r\n\x1a".to_vec(); + expected.extend([65, 0, 65, 0, 1, 0, 65, 0, 4, 0, b'A', 0, 0x10, 0]); + expected.extend(b"EOF"); + assert_eq!(b, expected); +} +#[test] +fn hostile_sources_are_refused() { + for src in [ + "*1,2,X\n7\n", + "*1,2,X\n9,(1,1)\n", + "*99999,1,X\n0\n", + "*1,1,X\n300,0\n", + "010,0\n", + "*1,1,X\n1,0zz,0\n", + "*1,1,X\n0\n*1,1,Y\n0\n", + "*--9223372036854775808,1,X\n0", + "*BIGFONT 1,65535\n*1,1,X\n0", + ] { + assert!(compile(src).is_err(), "{src:?}"); + } + assert_eq!(compile(""), Err(ShxError::Empty)); + assert_eq!(compile(&" ".repeat((8 << 20) + 1)), Err(ShxError::TooLarge)); + let oversized_header = format!("*UNIFONT,6,{}\n10,2,0,0,0,0\n*65,1,A\n0", "n".repeat(65536)); + assert_eq!(compile(&oversized_header), Err(ShxError::TooLarge)); +} From 451a390542fbde0519cbb8ade3a3325cf02d97be Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:37:41 +0000 Subject: [PATCH 109/382] Add opt-in legacy Base64 compatibility --- crates/mime/src/base64_compat.rs | 93 ++++++++++++++++++++++++++++++++ crates/mime/src/lib.rs | 1 + 2 files changed, 94 insertions(+) create mode 100644 crates/mime/src/base64_compat.rs diff --git a/crates/mime/src/base64_compat.rs b/crates/mime/src/base64_compat.rs new file mode 100644 index 000000000..452b276f9 --- /dev/null +++ b/crates/mime/src/base64_compat.rs @@ -0,0 +1,93 @@ +//! Compatibility decoding for legacy transports that accepted mixed Base64 alphabets and padding. +//! +//! This is deliberately permissive and must not be used for signatures, credentials or other +//! contexts requiring canonical Base64. Use [`crate::base64`] for strict RFC 4648 decoding. +use crate::base64::DecodeError; + +/// Decode standard or URL-safe Base64, accepting either alphabet even in the same input. +/// Spaces, CR, LF and `=` are ignored wherever they occur; an incomplete final sextet is +/// discarded. Other bytes are errors. Output allocation is bounded by the input length. +pub fn decode(input: impl AsRef<[u8]>) -> Result, DecodeError> { + let input = input.as_ref(); + let mut out = Vec::new(); + let capacity = (input.len() / 4) * 3 + (input.len() % 4) * 3 / 4; + out.try_reserve(capacity).map_err(|_| DecodeError)?; + let (mut acc, mut bits) = (0u32, 0u32); + for c in input { + let v = match c { + b'A'..=b'Z' => c - b'A', + b'a'..=b'z' => c - b'a' + 26, + b'0'..=b'9' => c - b'0' + 52, + b'+' | b'-' => 62, + b'/' | b'_' => 63, + b'=' | b'\n' | b'\r' | b' ' => continue, + _ => return Err(DecodeError), + }; + acc = (acc << 6) | u32::from(v); + bits += 6; + if bits >= 8 { + bits -= 8; + out.push((acc >> bits) as u8); + acc &= (1 << bits) - 1; + } + } + Ok(out) +} +#[cfg(test)] +mod tests { + #![allow(clippy::unwrap_used)] + use super::*; + #[test] + fn accepts_mixed_alphabets_and_ignores_padding_anywhere() { + assert_eq!(decode("+_8=").unwrap(), [251, 255]); + assert_eq!(decode("Z=m 9\nv\r").unwrap(), b"foo"); + assert_eq!(decode("A").unwrap(), b""); + assert_eq!(decode("AB").unwrap(), [0]); + assert!(decode("Zm9v\t").is_err()); + assert!(decode("Zm9v!").is_err()); + assert!(crate::base64::STANDARD.decode("Z=m9v").is_err()); + } + // Differential against CADCraft's pre-cutover decoder, including malformed legacy inputs. + fn legacy(s: &str) -> Option> { + let mut out = Vec::new(); + let (mut acc, mut bits) = (0u32, 0u32); + for c in s.bytes() { + let value = match c { + b'A'..=b'Z' => c - b'A', + b'a'..=b'z' => c - b'a' + 26, + b'0'..=b'9' => c - b'0' + 52, + b'+' | b'-' => 62, + b'/' | b'_' => 63, + b'=' | b'\n' | b'\r' | b' ' => continue, + _ => return None, + }; + acc = (acc << 6) | u32::from(value); + bits += 6; + if bits >= 8 { + bits -= 8; + out.push((acc >> bits) as u8); + } + } + Some(out) + } + #[test] + fn matches_the_legacy_decoder_on_seeded_mixed_inputs() { + let alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/-_= \r\n!\t"; + let mut seed = 0x1234_5678u32; + for n in 0..50_000 { + let mut text = String::new(); + for _ in 0..n % 45 { + seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + text.push(char::from(alphabet[(seed as usize) % alphabet.len()])); + } + assert_eq!(decode(&text).ok(), legacy(&text), "{text:?}"); + } + } + + #[test] + fn round_trip_rfc_vectors_with_the_shared_encoder() { + for data in [&b""[..], b"f", b"fo", b"foo", b"foobar", &[0, 255, 127]] { + assert_eq!(decode(crate::base64::STANDARD.encode(data)).unwrap(), data); + } + } +} diff --git a/crates/mime/src/lib.rs b/crates/mime/src/lib.rs index 72a930b8b..d3ff9f257 100644 --- a/crates/mime/src/lib.rs +++ b/crates/mime/src/lib.rs @@ -28,6 +28,7 @@ //! says) is the caller's: this crate has no notion of a mailbox or a document. pub mod base64; +pub mod base64_compat; pub mod charset; #[cfg(feature = "detect")] pub mod detect; From 32eff39b74661ad121a0aa08a36b69c01defaf58 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:39:23 +0000 Subject: [PATCH 110/382] Share PNG header and color chunk inspection --- crates/image-codecs/src/lib.rs | 1 + crates/image-codecs/src/png_probe.rs | 169 +++++++++++++++++++++++++++ 2 files changed, 170 insertions(+) create mode 100644 crates/image-codecs/src/png_probe.rs diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 6516b9ff2..d8659bf54 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -28,6 +28,7 @@ mod inspection; mod lab; mod options; pub mod orientation; +pub mod png_probe; pub mod resolution; pub mod source_settings; pub mod web; diff --git a/crates/image-codecs/src/png_probe.rs b/crates/image-codecs/src/png_probe.rs new file mode 100644 index 000000000..6ec610c14 --- /dev/null +++ b/crates/image-codecs/src/png_probe.rs @@ -0,0 +1,169 @@ +//! Header-only PNG inspection without inflating image data. +use crate::{CodecError, Format}; +fn err(message: &str) -> CodecError { + CodecError::malformed(Format::Png, message) +} + +/// Stored dimensions and EXIF orientation. This does not validate CRCs or compressed pixels. +pub fn header(b: &[u8]) -> Result<(u32, u32, u16), CodecError> { + if !b.starts_with(b"\x89PNG\r\n\x1a\n") { + return Err(err("bad signature")); + } + let be32 = |p: usize| b.get(p..p.checked_add(4)?).map(|v| u32::from_be_bytes([v[0], v[1], v[2], v[3]])); + if be32(8) != Some(13) || b.get(12..16) != Some(b"IHDR") { + return Err(err("missing IHDR")); + } + let ihdr = b.get(16..29).ok_or_else(|| err("truncated IHDR"))?; + let (w, h) = (u32::from_be_bytes([ihdr[0], ihdr[1], ihdr[2], ihdr[3]]), u32::from_be_bytes([ihdr[4], ihdr[5], ihdr[6], ihdr[7]])); + let (depth, color, compression, filter, interlace) = (ihdr[8], ihdr[9], ihdr[10], ihdr[11], ihdr[12]); + if w > i32::MAX as u32 || h > i32::MAX as u32 { + return Err(err("dimensions out of range")); + } + if w == 0 || h == 0 { + return Err(err("zero dimension")); + } + let depth_ok = match color { + 0 => matches!(depth, 1 | 2 | 4 | 8 | 16), + 3 => matches!(depth, 1 | 2 | 4 | 8), + 2 | 4 | 6 => matches!(depth, 8 | 16), + _ => false, + }; + if !depth_ok || compression != 0 || filter != 0 || interlace > 1 { + return Err(err("invalid IHDR")); + } + let (mut p, mut palette, mut idat, mut after_idat, mut exif) = (8usize, false, false, false, None); + while let Some(len) = be32(p) { + let Some(kind) = p.checked_add(4).and_then(|k| b.get(k..k.checked_add(4)?)) else { break }; + if idat && kind != b"IDAT" { + // a chunk follows the image data: the IDAT run is complete + after_idat = true; + } + if kind == b"IEND" { + break; + } + let start = p.saturating_add(8); + let data = (len <= i32::MAX as u32).then(|| start.checked_add(len as usize).and_then(|end| b.get(start..end))).flatten(); + let Some(data) = data else { + if after_idat { + break; // a damaged chunk after the image data: a decode ignores it too + } + return Err(err("truncated")); + }; + match kind { + b"PLTE" => palette = true, + b"IDAT" if after_idat => {} // a stray IDAT after other chunks: the first run is the image + b"IDAT" => { + if color == 3 && !palette { + return Err(err("indexed image without a palette")); + } + idat = true; + } + b"eXIf" if exif.is_none() => exif = Some(data.strip_prefix(b"Exif\0\0").unwrap_or(data)), + _ => {} + } + p = start.saturating_add(data.len()).saturating_add(4); + } + if !idat { + return Err(err("no image data")); + } + if !after_idat { + return Err(err("truncated image data")); + } + Ok((w, h, exif.map_or(1, crate::exif_orientation))) +} + +/// Container color declarations preceding image data. Raw values leave color policy to callers. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct ColorChunks { + pub srgb: bool, + pub gamma: Option, + pub chromaticities: Option<[f64; 8]>, +} + +/// Read bounded color chunks before image data; malformed tails are ignored. +pub fn color_chunks(b: &[u8]) -> Option { + if !b.starts_with(b"\x89PNG\r\n\x1a\n") { + return None; + } + let mut result = ColorChunks::default(); + let mut p = 8usize; + while let Some(length) = b.get(p..p.checked_add(4)?) { + let len = u32::from_be_bytes(length.try_into().ok()?) as usize; + let start = p.checked_add(8)?; + let Some(kind) = b.get(p.checked_add(4)?..start) else { break }; + let Some(payload) = start.checked_add(len).and_then(|end| b.get(start..end)) else { break }; + match kind { + b"sRGB" => result.srgb = true, + b"gAMA" if payload.len() == 4 => { + let v = u32::from_be_bytes(payload.try_into().ok()?) as f32 / 100_000.0; + if v > 0.0 && v.is_finite() { + result.gamma = Some(v); + } + } + b"cHRM" if payload.len() == 32 => { + let mut vals = [0.0; 8]; + for (i, dst) in vals.iter_mut().enumerate() { + let raw = i32::from_be_bytes(payload[i * 4..i * 4 + 4].try_into().ok()?); + *dst = f64::from(raw) / 100_000.0; + } + result.chromaticities = Some(vals); + } + b"IDAT" | b"IEND" => break, + _ => {} + } + let Some(next) = start.checked_add(len).and_then(|end| end.checked_add(4)) else { break }; + p = next; + } + Some(result) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn chunk(out: &mut Vec, kind: &[u8; 4], data: &[u8]) { + out.extend_from_slice(&(data.len() as u32).to_be_bytes()); + out.extend_from_slice(kind); + out.extend_from_slice(data); + out.extend_from_slice(&[0; 4]); // Header inspection deliberately does not validate CRCs. + } + + fn png(color: u8) -> Vec { + let mut bytes = b"\x89PNG\r\n\x1a\n".to_vec(); + let mut ihdr = Vec::new(); + ihdr.extend_from_slice(&2u32.to_be_bytes()); + ihdr.extend_from_slice(&3u32.to_be_bytes()); + ihdr.extend_from_slice(&[8, color, 0, 0, 0]); + chunk(&mut bytes, b"IHDR", &ihdr); + bytes + } + + #[test] + fn header_checks_structure_and_reads_late_orientation_without_crc_validation() { + let mut bytes = png(2); + chunk(&mut bytes, b"IDAT", &[1]); + let exif = b"II\x2a\x00\x08\x00\x00\x00\x01\x00\x12\x01\x03\x00\x01\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00"; + chunk(&mut bytes, b"eXIf", exif); + chunk(&mut bytes, b"IEND", &[]); + assert_eq!(header(&bytes).ok(), Some((2, 3, 6))); + assert!(header(&bytes[..34]).is_err()); + let mut indexed = png(3); + chunk(&mut indexed, b"IDAT", &[1]); + chunk(&mut indexed, b"IEND", &[]); + assert!(header(&indexed).is_err()); + indexed[25] = 7; + assert!(header(&indexed).is_err()); + } + + #[test] + fn reads_color_chunks_only_before_image_data() { + let mut bytes = png(2); + chunk(&mut bytes, b"gAMA", &45455u32.to_be_bytes()); + chunk(&mut bytes, b"IDAT", &[1]); + chunk(&mut bytes, b"sRGB", &[0]); + let color = color_chunks(&bytes).unwrap(); + assert_eq!(color.gamma, Some(0.45455)); + assert!(!color.srgb); + assert!(color_chunks(b"not png").is_none()); + } +} From 8e394d43faae421541892945cc56f10e47ee3be7 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:39:42 +0000 Subject: [PATCH 111/382] audio: share bounded range-backed WAV PCM access --- crates/audio/src/lib.rs | 3 + crates/audio/src/wav_range.rs | 218 ++++++++++++++++++++++++++++++++++ 2 files changed, 221 insertions(+) create mode 100644 crates/audio/src/wav_range.rs diff --git a/crates/audio/src/lib.rs b/crates/audio/src/lib.rs index 33dcdee3b..8681ce6d8 100644 --- a/crates/audio/src/lib.rs +++ b/crates/audio/src/lib.rs @@ -66,6 +66,9 @@ mod wav; feature = "vorbis-encode" ))] mod write; + +/// Range-backed PCM WAVE access and a 16-bit PCM writer. +pub mod wav_range; #[cfg(feature = "vorbis-encode")] pub use write::{OGG_BITRATES, encode_ogg}; diff --git a/crates/audio/src/wav_range.rs b/crates/audio/src/wav_range.rs new file mode 100644 index 000000000..1ced4fb78 --- /dev/null +++ b/crates/audio/src/wav_range.rs @@ -0,0 +1,218 @@ +//! Range-backed PCM WAVE reader and canonical 16-bit writer. +//! +//! Reads chunk headers and only the requested sample range; it never loads a whole file. + +use crate::{AudioError, Result}; +use craft_media::ByteSource; + +const MAX_CHUNKS: usize = 1 << 16; +const IXML_MAX: u64 = 1 << 20; +/// Maximum sample data returned by a single range read. +pub const MAX_RANGE_BYTES: u64 = 4 << 20; + +fn le16(b: &[u8], o: usize) -> u16 { + b.get(o..o.saturating_add(2)).and_then(|s| s.try_into().ok()).map_or(0, u16::from_le_bytes) +} +fn le32(b: &[u8], o: usize) -> u32 { + b.get(o..o.saturating_add(4)).and_then(|s| s.try_into().ok()).map_or(0, u32::from_le_bytes) +} +fn read_range(source: &impl ByteSource, off: u64, len: usize) -> Result> { + let mut bytes = vec![0; len]; + source.read_at(off, &mut bytes)?; + Ok(bytes) +} + +/// A PCM WAVE file held by an arbitrary random-access source. +pub struct WavRange { + source: S, + /// Number of complete sample frames. + pub frames: u64, + /// Channel count. + pub channels: u16, + /// Sample rate in Hz. + pub rate: u32, + /// Container bits per sample. + pub bits: u16, + /// Whether samples are floating point. + pub float: bool, + /// BWF time reference in samples, from bext or iXML. + pub time_reference: Option, + data_off: u64, +} + +impl WavRange { + /// Open with caller-selected bounds on channel count and sample rate. + pub fn open(source: S, max_channels: u32, max_rate: u32) -> Result { + let len = source.len(); + let mut pos: u64 = 12; + let mut fmt = None; + let mut data = None; + let mut bext_tr = None; + let mut ixml_tr = None; + let mut ds64_data = None; + for _ in 0..MAX_CHUNKS { + let Some(body) = pos.checked_add(8).filter(|&b| b <= len) else { break }; + let mut hdr = [0u8; 8]; + source.read_at(pos, &mut hdr)?; + let id = &hdr[0..4]; + let mut clen = u64::from(le32(&hdr, 4)); + let rest = len - body; + if id == b"data" { + if clen == 0xFFFF_FFFF { + clen = ds64_data.unwrap_or(rest); + } + clen = clen.min(rest); + } + if clen > rest { + break; + } + match id { + b"fmt " if clen >= 16 => { + let b = read_range(&source, body, clen.min(40) as usize)?; + let mut tag = le16(&b, 0); + if tag == 0xFFFE && clen >= 40 { + tag = le16(&b, 24); + } + fmt = Some((tag, le16(&b, 2), le32(&b, 4), le16(&b, 14))); + } + b"ds64" if clen >= 16 => { + let b = read_range(&source, body + 8, 8)?; + ds64_data = Some(u64::from(le32(&b, 0)) | u64::from(le32(&b, 4)) << 32); + } + b"data" => data = Some((body, clen)), + b"bext" if clen >= 346 => { + let b = read_range(&source, body + 338, 8)?; + bext_tr = Some(u64::from(le32(&b, 0)) | u64::from(le32(&b, 4)) << 32); + } + b"iXML" => { + let b = read_range(&source, body, clen.min(IXML_MAX) as usize)?; + ixml_tr = ixml_time_reference(&b); + } + _ => {} + } + pos = body.saturating_add(clen).saturating_add(clen & 1); + } + let (tag, channels, rate, bits) = fmt.ok_or_else(|| AudioError::Malformed("missing fmt chunk".into()))?; + let (data_off, dlen) = data.ok_or_else(|| AudioError::Malformed("missing data chunk".into()))?; + let float = tag == 3; + if !(tag == 1 || float) + || channels == 0 + || rate == 0 + || u32::from(channels) > max_channels + || rate > max_rate + || !matches!(bits, 8 | 16 | 24 | 32 | 64) + { + return Err(AudioError::Unsupported(format!("WAV format tag {tag}, {bits} bits"))); + } + let frames = dlen / (u64::from(channels) * u64::from(bits / 8)); + Ok(Self { source, frames, channels, rate, bits, float, time_reference: bext_tr.or(ixml_tr), data_off }) + } + /// Bytes in one whole frame. + pub fn frame_bytes(&self) -> usize { + usize::from(self.channels) * usize::from(self.bits / 8) + } + /// Read the inclusive range of frames, capped to prevent unbounded allocation. + pub fn read_frames(&self, first: u64, last: u64) -> Result> { + if first > last || last >= self.frames { + return Err(AudioError::Malformed("WAV frame range outside data".into())); + } + let n = (last - first + 1).saturating_mul(self.frame_bytes() as u64); + if n > MAX_RANGE_BYTES { + return Err(AudioError::TooLarge("WAV frame range".into())); + } + let off = self.data_off.saturating_add(first.saturating_mul(self.frame_bytes() as u64)); + read_range(&self.source, off, n as usize) + } + /// Decode a channel from a buffer returned by `read_frames`. + pub fn sample(&self, block: &[u8], frame: usize, ch: usize) -> f32 { + if ch >= usize::from(self.channels) { + return 0.0; + } + let bps = usize::from(self.bits / 8); + let Some(o) = frame.checked_mul(usize::from(self.channels)).and_then(|v| v.checked_add(ch)).and_then(|v| v.checked_mul(bps)) else { + return 0.0; + }; + let Some(b) = block.get(o..o.saturating_add(bps)) else { return 0.0 }; + match (self.bits, self.float, b) { + (8, _, &[a]) => (a as f32 - 128.0) / 128.0, + (16, _, &[a, b]) => i16::from_le_bytes([a, b]) as f32 / 32768.0, + (24, _, &[a, b, c]) => (i32::from_le_bytes([0, a, b, c]) >> 8) as f32 / 8_388_608.0, + (32, false, &[a, b, c, d]) => i32::from_le_bytes([a, b, c, d]) as f32 / 2_147_483_648.0, + (32, true, &[a, b, c, d]) => f32::from_le_bytes([a, b, c, d]), + (64, true, b) => f64::from_le_bytes(b.try_into().unwrap_or([0; 8])) as f32, + _ => 0.0, + } + } +} + +fn ixml_time_reference(x: &[u8]) -> Option { + let text = String::from_utf8_lossy(x); + let field = |tag: &str| -> Option { + let open = format!("<{tag}>"); + let a = text.find(&open)? + open.len(); + let b = a + text[a..].find('<')?; + text[a..b].trim().parse().ok() + }; + let low = field("BWF_TIME_REFERENCE_LOW")?; + Some(low | field("BWF_TIME_REFERENCE_HIGH").unwrap_or(0) << 32) +} + +/// Write interleaved samples as 16-bit PCM WAVE, using symmetric 32767 scaling. +#[cfg(feature = "pcm-encode")] +pub fn write_wav16(samples: &[f32], channels: u16, rate: u32) -> Vec { + let data_len = samples.len().saturating_mul(2); + let mut v = crate::pcm_wav_header(u32::try_from(data_len).unwrap_or(u32::MAX), channels, rate, 16); + v.reserve(data_len); + for s in samples { + v.extend_from_slice(&((s.clamp(-1.0, 1.0) * 32767.0).round() as i16).to_le_bytes()); + } + v +} + +#[cfg(all(test, feature = "pcm-encode"))] +mod tests { + use super::*; + use std::sync::{Arc, Mutex}; + + struct Source { + bytes: Vec, + reads: Arc>>, + } + impl ByteSource for Source { + fn len(&self) -> u64 { + self.bytes.len() as u64 + } + fn read_at(&self, offset: u64, buf: &mut [u8]) -> std::io::Result<()> { + self.reads.lock().unwrap().push((offset, buf.len())); + self.bytes.read_at(offset, buf) + } + } + #[test] + fn bounded_reads_and_pcm_values() { + let bytes = write_wav16(&[-1.0, -0.5, 0.0, 0.5, 1.0], 1, 48_000); + let reads = Arc::new(Mutex::new(Vec::new())); + let wav = WavRange::open(Source { bytes, reads: reads.clone() }, 64, 384_000).unwrap(); + assert_eq!((wav.frames, wav.channels, wav.rate, wav.bits), (5, 1, 48_000, 16)); + assert!(reads.lock().unwrap().iter().all(|(_, n)| *n <= 40)); + let data = wav.read_frames(1, 3).unwrap(); + assert_eq!(wav.sample(&data, 0, 0), -0.5); + assert_eq!(wav.sample(&data, 2, 0), 0.5); + assert!(wav.read_frames(0, 5).is_err()); + assert!(wav.read_frames(3, 1).is_err()); + assert_eq!(reads.lock().unwrap().last(), Some(&(46, 6))); + } + #[test] + fn ixml_fallback_accepts_flat_fields() { + let base = write_wav16(&[0.0], 1, 48_000); + let mut bytes = base[..36].to_vec(); + let xml = b"51"; + bytes.extend_from_slice(b"iXML"); + bytes.extend_from_slice(&(xml.len() as u32).to_le_bytes()); + bytes.extend_from_slice(xml); + if xml.len() % 2 != 0 { + bytes.push(0); + } + bytes.extend_from_slice(&base[36..]); + assert_eq!(WavRange::open(bytes.as_slice(), 64, 384_000).unwrap().time_reference, Some((1 << 32) + 5)); + } +} From 1bce1af0eb5e0fd512226ea1247bef958a87e751 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:39:50 +0000 Subject: [PATCH 112/382] Expose early PNG dimension preflight --- crates/image-codecs/src/png_probe.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/crates/image-codecs/src/png_probe.rs b/crates/image-codecs/src/png_probe.rs index 6ec610c14..9cb40f402 100644 --- a/crates/image-codecs/src/png_probe.rs +++ b/crates/image-codecs/src/png_probe.rs @@ -4,6 +4,17 @@ fn err(message: &str) -> CodecError { CodecError::malformed(Format::Png, message) } +/// Dimensions declared in a PNG IHDR prefix, without checking the rest of the file. +/// Useful only for an early allocation limit; use [`header`] for structural inspection. +pub fn declared_dimensions(b: &[u8]) -> Option<(u32, u32)> { + if !b.starts_with(b"\x89PNG\r\n\x1a\n") || b.get(12..16) != Some(b"IHDR") { + return None; + } + let w = u32::from_be_bytes(b.get(16..20)?.try_into().ok()?); + let h = u32::from_be_bytes(b.get(20..24)?.try_into().ok()?); + Some((w, h)) +} + /// Stored dimensions and EXIF orientation. This does not validate CRCs or compressed pixels. pub fn header(b: &[u8]) -> Result<(u32, u32, u16), CodecError> { if !b.starts_with(b"\x89PNG\r\n\x1a\n") { From badb7904116d518ad84ff1da5a1d99d3cc5e584f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:40:02 +0000 Subject: [PATCH 113/382] audio: expose WAV signature detection --- crates/audio/src/wav_range.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/audio/src/wav_range.rs b/crates/audio/src/wav_range.rs index 1ced4fb78..d8aea0d54 100644 --- a/crates/audio/src/wav_range.rs +++ b/crates/audio/src/wav_range.rs @@ -5,6 +5,11 @@ use crate::{AudioError, Result}; use craft_media::ByteSource; +/// Whether a prefix identifies a RIFF or RF64 WAVE file. +pub fn sniff(b: &[u8]) -> bool { + b.len() >= 12 && (&b[0..4] == b"RIFF" || &b[0..4] == b"RF64") && &b[8..12] == b"WAVE" +} + const MAX_CHUNKS: usize = 1 << 16; const IXML_MAX: u64 = 1 << 20; /// Maximum sample data returned by a single range read. From e4cef773fcf04392df55cb3abf156da92a6f2ce1 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:40:50 +0000 Subject: [PATCH 114/382] Enforce PNG probe pixel limit before chunk scanning --- crates/image-codecs/src/png_probe.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/image-codecs/src/png_probe.rs b/crates/image-codecs/src/png_probe.rs index 9cb40f402..94e308add 100644 --- a/crates/image-codecs/src/png_probe.rs +++ b/crates/image-codecs/src/png_probe.rs @@ -17,6 +17,11 @@ pub fn declared_dimensions(b: &[u8]) -> Option<(u32, u32)> { /// Stored dimensions and EXIF orientation. This does not validate CRCs or compressed pixels. pub fn header(b: &[u8]) -> Result<(u32, u32, u16), CodecError> { + header_with_max_pixels(b, u64::MAX) +} + +/// As [`header`], refusing images over `max_pixels` before scanning their chunks. +pub fn header_with_max_pixels(b: &[u8], max_pixels: u64) -> Result<(u32, u32, u16), CodecError> { if !b.starts_with(b"\x89PNG\r\n\x1a\n") { return Err(err("bad signature")); } @@ -33,6 +38,9 @@ pub fn header(b: &[u8]) -> Result<(u32, u32, u16), CodecError> { if w == 0 || h == 0 { return Err(err("zero dimension")); } + if u64::from(w) * u64::from(h) > max_pixels { + return Err(CodecError::LimitExceeded("PNG pixel count".into())); + } let depth_ok = match color { 0 => matches!(depth, 1 | 2 | 4 | 8 | 16), 3 => matches!(depth, 1 | 2 | 4 | 8), From 188d935887cb1ea2b9f058e8063718b03e1f27ee Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:41:20 +0000 Subject: [PATCH 115/382] Cover bounded PNG header probing --- crates/image-codecs/src/png_probe.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/image-codecs/src/png_probe.rs b/crates/image-codecs/src/png_probe.rs index 94e308add..7edda454d 100644 --- a/crates/image-codecs/src/png_probe.rs +++ b/crates/image-codecs/src/png_probe.rs @@ -165,6 +165,8 @@ mod tests { chunk(&mut bytes, b"eXIf", exif); chunk(&mut bytes, b"IEND", &[]); assert_eq!(header(&bytes).ok(), Some((2, 3, 6))); + assert!(matches!(header_with_max_pixels(&bytes, 5), Err(CodecError::LimitExceeded(_)))); + assert_eq!(declared_dimensions(&bytes), Some((2, 3))); assert!(header(&bytes[..34]).is_err()); let mut indexed = png(3); chunk(&mut indexed, b"IDAT", &[1]); From ac037cd9413e32fd16e0103628485f7eb011abfa Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:46:32 +0000 Subject: [PATCH 116/382] aaf: expose bounded Bento container access --- crates/aaf/src/omf.rs | 2 +- crates/aaf/src/omf/bento.rs | 25 ++++++++++++++++++------- crates/aaf/tests/bento_api.rs | 17 +++++++++++++++++ 3 files changed, 36 insertions(+), 8 deletions(-) create mode 100644 crates/aaf/tests/bento_api.rs diff --git a/crates/aaf/src/omf.rs b/crates/aaf/src/omf.rs index 57e0f756c..bbd2e8571 100644 --- a/crates/aaf/src/omf.rs +++ b/crates/aaf/src/omf.rs @@ -21,7 +21,7 @@ //! transition's name) are not in the specification; they were first written by FilmCraft and keep //! their names so that existing files read back. -pub(crate) mod bento; +pub mod bento; mod read; mod write; diff --git a/crates/aaf/src/omf/bento.rs b/crates/aaf/src/omf/bento.rs index 00a7e2a26..171196fe1 100644 --- a/crates/aaf/src/omf/bento.rs +++ b/crates/aaf/src/omf/bento.rs @@ -35,8 +35,8 @@ use std::collections::{BTreeMap, HashMap}; -pub(crate) const MAGIC: [u8; 8] = [0xA4, b'C', b'M', 0xA5, b'H', b'd', b'r', 0xD7]; -pub(crate) const LABEL_SIZE: usize = 24; +pub const MAGIC: [u8; 8] = [0xA4, b'C', b'M', 0xA5, b'H', b'd', b'r', 0xD7]; +pub const LABEL_SIZE: usize = 24; // standard object ids const TOC_OBJECT: u32 = 1; @@ -82,7 +82,7 @@ const MAX_VALUE_BYTES: usize = 16 << 20; const MAX_NAME_BYTES: usize = 4 << 20; /// Builds a Bento container. -pub(crate) struct Writer { +pub struct Writer { data: Vec, names: HashMap<(u32, String), u32>, next: u32, @@ -90,6 +90,12 @@ pub(crate) struct Writer { entries: Vec<(u32, u32, u32, Vec)>, } +impl Default for Writer { + fn default() -> Self { + Self::new() + } +} + impl Writer { pub fn new() -> Writer { Writer { data: Vec::new(), names: HashMap::new(), next: MIN_USER_ID, entries: Vec::new() } @@ -217,9 +223,9 @@ pub(crate) struct Prop { } /// A parsed Bento container. -pub(crate) struct Container<'a> { +pub struct Container<'a> { data: &'a [u8], - pub objects: BTreeMap>, + pub(crate) objects: BTreeMap>, names: HashMap, by_name: HashMap, } @@ -229,11 +235,16 @@ fn be32(b: &[u8], at: usize) -> Option { } /// Whether `b` ends with a Bento label. -pub(crate) fn sniff(b: &[u8]) -> bool { +pub fn sniff(b: &[u8]) -> bool { b.len() >= LABEL_SIZE && b[b.len() - LABEL_SIZE..b.len() - LABEL_SIZE + 8] == MAGIC } impl<'a> Container<'a> { + /// Object identifiers in ascending order. + pub fn object_ids(&self) -> impl Iterator + '_ { + self.objects.keys().copied() + } + pub fn open(data: &'a [u8]) -> Result, String> { if !sniff(data) { return Err("no Bento label at the end of the file".into()); @@ -324,7 +335,7 @@ impl<'a> Container<'a> { } /// The bytes of a value. - pub fn value(&self, p: &Prop) -> Result, String> { + pub(crate) fn value(&self, p: &Prop) -> Result, String> { let total = p.segs.iter().try_fold(0usize, |total, s| { let len = match s { Seg::Imm(b) => b.len(), diff --git a/crates/aaf/tests/bento_api.rs b/crates/aaf/tests/bento_api.rs new file mode 100644 index 000000000..9df70c661 --- /dev/null +++ b/crates/aaf/tests/bento_api.rs @@ -0,0 +1,17 @@ +use craft_aaf::omf::bento::{Container, Writer, sniff}; + +#[test] +fn external_consumer_reads_named_values_and_references() { + let mut writer = Writer::new(); + let first = writer.new_object(); + let second = writer.new_object(); + writer.set(first, "test:value", "test:type", b"long value"); + writer.set_references(first, &[second]); + let bytes = writer.finish(); + assert!(sniff(&bytes)); + let container = Container::open(&bytes).unwrap(); + assert!(container.object_ids().any(|id| id == first)); + assert_eq!(container.get(first, "test:value").as_deref(), Some(b"long value".as_slice())); + assert_eq!(container.resolve(first, second), second); + assert!(Container::open(&bytes[..bytes.len() - 1]).is_err()); +} From aa398af9dd312523c8a9fcb3b2711b726a40abdd Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:48:01 +0000 Subject: [PATCH 117/382] audio: fix range test lint on workspace gates --- crates/audio/src/wav_range.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/audio/src/wav_range.rs b/crates/audio/src/wav_range.rs index d8aea0d54..33762caf2 100644 --- a/crates/audio/src/wav_range.rs +++ b/crates/audio/src/wav_range.rs @@ -188,7 +188,7 @@ mod tests { self.bytes.len() as u64 } fn read_at(&self, offset: u64, buf: &mut [u8]) -> std::io::Result<()> { - self.reads.lock().unwrap().push((offset, buf.len())); + self.reads.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push((offset, buf.len())); self.bytes.read_at(offset, buf) } } @@ -214,7 +214,7 @@ mod tests { bytes.extend_from_slice(b"iXML"); bytes.extend_from_slice(&(xml.len() as u32).to_le_bytes()); bytes.extend_from_slice(xml); - if xml.len() % 2 != 0 { + if xml.len() & 1 != 0 { bytes.push(0); } bytes.extend_from_slice(&base[36..]); From a2541707240580153c8ea9ef3043ec0257468d0a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:48:40 +0000 Subject: [PATCH 118/382] Share WebP header inspection --- crates/image-codecs/src/lib.rs | 1 + crates/image-codecs/src/webp_probe.rs | 47 +++++++++++++++++++++++++++ 2 files changed, 48 insertions(+) create mode 100644 crates/image-codecs/src/webp_probe.rs diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 6516b9ff2..961a04327 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -31,6 +31,7 @@ pub mod orientation; pub mod resolution; pub mod source_settings; pub mod web; +pub mod webp_probe; pub use crate::allocation::probe_allocation_size; pub use crate::cicp::Cicp; pub use crate::cicp::ContentLightLevel; diff --git a/crates/image-codecs/src/webp_probe.rs b/crates/image-codecs/src/webp_probe.rs new file mode 100644 index 000000000..8376274df --- /dev/null +++ b/crates/image-codecs/src/webp_probe.rs @@ -0,0 +1,47 @@ +//! Header-only WebP inspection with image-chunk completeness checks. + +use crate::{CodecError, Format}; + +/// Stored width, height and EXIF orientation without decoding pixels. The image payload must +/// fit in the input, but its compressed contents are not validated. Uses the default decode limits. +pub fn header(bytes: &[u8]) -> Result<(u32, u32, u16), CodecError> { + let err = |s: &str| CodecError::malformed(Format::WebP, s); + let mut p = 12usize; + let mut has_image = false; + let mut exif = None; + while let Some(h) = bytes.get(p..p.saturating_add(8)) { + let size = u32::from_le_bytes([h[4], h[5], h[6], h[7]]) as usize; + let end = p.saturating_add(8).saturating_add(size); + if matches!(&h[..4], b"VP8 " | b"VP8L" | b"ANMF") { + if end > bytes.len() { + return Err(err("truncated image data")); + } + has_image = true; + } else if &h[..4] == b"EXIF" && end <= bytes.len() && exif.is_none() { + exif = bytes.get(p + 8..end); + } + p = end.saturating_add(size & 1); + } + if !has_image { + return Err(err("no image data")); + } + let (w, h) = crate::probe_size(bytes)?; + let orientation = exif.map_or(1, crate::exif_orientation); + let (w, h) = if (5..=8).contains(&orientation) { (h, w) } else { (w, h) }; + Ok((w, h, orientation)) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_missing_and_truncated_image_chunks() { + let mut bytes = b"RIFF\x00\x00\x00\x00WEBP".to_vec(); + assert!(header(&bytes).is_err()); + bytes.extend_from_slice(b"VP8 "); + bytes.extend_from_slice(&10u32.to_le_bytes()); + bytes.push(0); + assert!(header(&bytes).is_err()); + } +} From 3c5007339754def577b3c5274f523d96384a35c4 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:48:41 +0000 Subject: [PATCH 119/382] Share bounded SHX container reader --- crates/shx/src/lib.rs | 2 + crates/shx/src/parse.rs | 281 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 283 insertions(+) create mode 100644 crates/shx/src/parse.rs diff --git a/crates/shx/src/lib.rs b/crates/shx/src/lib.rs index e595e90f5..ce330450c 100644 --- a/crates/shx/src/lib.rs +++ b/crates/shx/src/lib.rs @@ -4,5 +4,7 @@ //! Font discovery, glyph execution and text layout remain consumer responsibilities. mod compile; mod error; +pub mod parse; pub use compile::compile; pub use error::ShxError; +pub use parse::{ParsedFont, Record, ShxKind}; diff --git a/crates/shx/src/parse.rs b/crates/shx/src/parse.rs new file mode 100644 index 000000000..9cd4a35ad --- /dev/null +++ b/crates/shx/src/parse.rs @@ -0,0 +1,281 @@ +//! Reading the compiled SHX containers (layouts in the module documentation). Every count and +//! offset comes from the file, so each is checked against its length; records that run past +//! the end are dropped and the rest kept. + +use super::ShxError; +use std::collections::HashMap; + +/// The SHX container kind. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ShxKind { + Shapes, + BigFont, + Unifont, +} +/// Byte ranges of one shape name and pen program in [`ParsedFont::data`]. +#[derive(Clone, Copy, Debug)] +pub struct Record { + pub name: (usize, usize), + pub program: (usize, usize), +} +/// Decoded container records and metrics; glyph execution remains a caller concern. +pub struct ParsedFont { + pub kind: ShxKind, + pub name: String, + pub header: bool, + pub above: f64, + pub below: f64, + pub dual: bool, + pub encoding: u8, + pub char_width: f64, + pub ranges: Vec<(u16, u16)>, + pub data: Vec, + pub records: HashMap, +} + +pub const SHAPES_10: &[u8] = b"AutoCAD-86 shapes 1.0\r\n\x1a"; +pub const SHAPES_11: &[u8] = b"AutoCAD-86 shapes 1.1\r\n\x1a"; +pub const BIGFONT: &[u8] = b"AutoCAD-86 bigfont 1.0\r\n\x1a"; +pub const UNIFONT: &[u8] = b"AutoCAD-86 unifont 1.0\r\n\x1a"; + +/// Largest file read (the largest big fonts are a few megabytes). +pub const MAX_FILE_BYTES: usize = 32 << 20; +/// Most escape ranges in a big font (lead bytes: at most 256). +const MAX_RANGES: usize = 256; + +/// A checked little-endian reader. +struct Rd<'a> { + b: &'a [u8], + pos: usize, +} + +impl<'a> Rd<'a> { + fn take(&mut self, n: usize) -> Result<&'a [u8], ShxError> { + let end = self.pos.checked_add(n).ok_or(ShxError::Truncated)?; + let s = self.b.get(self.pos..end).ok_or(ShxError::Truncated)?; + self.pos = end; + Ok(s) + } + fn u16(&mut self) -> Result { + match self.take(2)? { + [a, b] => Ok(u16::from_le_bytes([*a, *b])), + _ => Err(ShxError::Truncated), + } + } + fn u32(&mut self) -> Result { + match self.take(4)? { + [a, b, c, d] => Ok(u32::from_le_bytes([*a, *b, *c, *d])), + _ => Err(ShxError::Truncated), + } + } +} + +/// A font being read. +struct Font { + kind: ShxKind, + name: String, + header: bool, + above: f64, + below: f64, + dual: bool, + encoding: u8, + char_width: f64, + ranges: Vec<(u16, u16)>, + records: HashMap, +} + +impl Font { + fn new(kind: ShxKind) -> Font { + Font { + kind, + name: String::new(), + header: false, + above: 0.0, + below: 0.0, + dual: false, + encoding: 0, + char_width: 0.0, + ranges: Vec::new(), + records: HashMap::new(), + } + } + + /// Add the record of shape `number` at `start..end` of `data`: a NUL-terminated name, then + /// the program. Shape 0 is the font record. A record without a name terminator is dropped; + /// the first record of a number wins. + fn record(&mut self, data: &[u8], number: u16, start: usize, end: usize) { + let Some(bytes) = data.get(start..end) else { return }; + let Some(nul) = bytes.iter().position(|b| *b == 0) else { return }; + let name = (start, start + nul); + let program = (start + nul + 1, end); + if number == 0 { + if !self.header { + self.font_record(data.get(program.0..program.1).unwrap_or_default(), data.get(name.0..name.1).unwrap_or_default()); + } + return; + } + self.records.entry(number).or_insert(Record { name, program }); + } + + /// The font record: above, below, modes (and for a unifont encoding and embedding); an + /// extended big font's is character height, 0, modes, character width. + fn font_record(&mut self, info: &[u8], name: &[u8]) { + self.header = true; + self.name = name.iter().take(255).map(|c| char::from(*c)).collect(); + let byte = |i: usize| info.get(i).copied().unwrap_or(0); + self.above = f64::from(byte(0)); + self.below = f64::from(byte(1)); + self.dual = byte(2) == 2; + if self.kind == ShxKind::Unifont { + self.encoding = byte(3); + } + if self.kind == ShxKind::BigFont && info.len() >= 5 && byte(1) == 0 { + // Extended: height, 0, modes, width, 0. + self.below = 0.0; + self.char_width = f64::from(byte(3)); + } + } + + fn finish(self, data: Vec) -> Result { + if self.records.is_empty() { + return Err(ShxError::Empty); + } + Ok(ParsedFont { + kind: self.kind, + name: self.name, + header: self.header, + above: self.above, + below: self.below, + dual: self.dual, + encoding: self.encoding, + char_width: if self.char_width > 0.0 { self.char_width } else { self.above }, + ranges: self.ranges, + data, + records: self.records, + }) + } +} + +pub fn parse(bytes: &[u8]) -> Result { + if bytes.len() > MAX_FILE_BYTES { + return Err(ShxError::TooLarge); + } + if bytes.starts_with(SHAPES_10) || bytes.starts_with(SHAPES_11) { + shapes(bytes) + } else if bytes.starts_with(BIGFONT) { + bigfont(bytes) + } else if bytes.starts_with(UNIFONT) { + unifont(bytes) + } else { + Err(ShxError::NotShx) + } +} + +fn shapes(bytes: &[u8]) -> Result { + let mut r = Rd { b: bytes, pos: SHAPES_10.len() }; + let _first = r.u16()?; + let _last = r.u16()?; + let count = usize::from(r.u16()?); + // The whole index must be there before anything is read from it. + let index = r.take(count.checked_mul(4).ok_or(ShxError::TooLarge)?)?; + let mut f = Font::new(ShxKind::Shapes); + let mut pos = r.pos; + for [a, b, c, d] in index.as_chunks::<4>().0 { + let (number, len) = (u16::from_le_bytes([*a, *b]), usize::from(u16::from_le_bytes([*c, *d]))); + let Some(end) = pos.checked_add(len).filter(|e| *e <= bytes.len()) else { break }; + f.record(bytes, number, pos, end); + pos = end; + } + f.finish(bytes.to_vec()) +} + +fn bigfont(bytes: &[u8]) -> Result { + let mut r = Rd { b: bytes, pos: BIGFONT.len() }; + let index_size = usize::from(r.u16()?); + let count = usize::from(r.u16()?); + let nranges = usize::from(r.u16()?); + if nranges > MAX_RANGES { + return Err(ShxError::TooLarge); + } + let mut f = Font::new(ShxKind::BigFont); + for _ in 0..nranges { + let (lo, hi) = (r.u16()?, r.u16()?); + f.ranges.push((lo.min(hi), lo.max(hi))); + } + // The index has `count` entries of 8 bytes; a file whose count doesn't fit but whose index + // size does is read by that. + let fits = |n: usize| n.checked_mul(8).and_then(|l| r.pos.checked_add(l)).is_some_and(|e| e <= bytes.len()); + let n = if fits(count) { + count + } else if fits(index_size) { + index_size + } else { + return Err(ShxError::Truncated); + }; + let index = r.take(n.checked_mul(8).ok_or(ShxError::TooLarge)?)?; + for [a, b, c, d, o0, o1, o2, o3] in index.as_chunks::<8>().0 { + let number = u16::from_le_bytes([*a, *b]); + let len = usize::from(u16::from_le_bytes([*c, *d])); + let Ok(off) = usize::try_from(u32::from_le_bytes([*o0, *o1, *o2, *o3])) else { continue }; + if len == 0 { + continue; + } + let Some(end) = off.checked_add(len).filter(|e| *e <= bytes.len()) else { continue }; + f.record(bytes, number, off, end); + } + f.finish(bytes.to_vec()) +} + +fn unifont(bytes: &[u8]) -> Result { + let mut r = Rd { b: bytes, pos: UNIFONT.len() }; + let count = r.u32()?; + let info_len = usize::from(r.u16()?); + let info = r.take(info_len)?; + let mut f = Font::new(ShxKind::Unifont); + let nul = info.iter().position(|b| *b == 0).unwrap_or(info.len()); + f.font_record(info.get(nul.saturating_add(1)..).unwrap_or_default(), info.get(..nul).unwrap_or_default()); + // `count` includes the font record; never trusted beyond the data that is there. + let mut left = count.saturating_sub(1); + while left > 0 { + left -= 1; + let Ok(number) = r.u16() else { break }; + let Ok(len) = r.u16().map(usize::from) else { break }; + let start = r.pos; + let Some(end) = start.checked_add(len).filter(|e| *e <= bytes.len()) else { break }; + r.pos = end; + f.record(bytes, number, start, end); + } + f.finish(bytes.to_vec()) +} + +#[cfg(test)] +mod tests { + #![allow(clippy::unwrap_used)] + use super::*; + #[test] + fn reads_shapes_bigfont_and_unifont_records() { + for (source, kind, shape) in [ + ("*0,4,font\n6,2,2,0\n*65,4,A\n1,064,0\n", ShxKind::Shapes, 65), + ("*BIGFONT 2,1,081,09F\n*0,4,big\n8,0,0,0\n*082A0,4,square\n1,080,0\n", ShxKind::BigFont, 0x82a0), + ("*UNIFONT,6,uni\n6,2,0,0,0,0\n*00041,4,a\n1,064,0\n", ShxKind::Unifont, 65), + ] { + let bytes = crate::compile(source).unwrap(); + let font = parse(&bytes).unwrap(); + assert_eq!(font.kind, kind); + assert!(font.header); + let record = font.records.get(&shape).unwrap(); + assert_eq!(font.data.get(record.program.1 - 1), Some(&0)); + } + } + #[test] + fn truncation_limits_and_unknown_signatures_are_errors() { + assert!(matches!(parse(b"not a font"), Err(ShxError::NotShx))); + assert!(matches!(parse(&vec![0; MAX_FILE_BYTES + 1]), Err(ShxError::TooLarge))); + let mut shapes = SHAPES_10.to_vec(); + shapes.extend([1, 0, 255, 255, 255, 255]); + assert!(matches!(parse(&shapes), Err(ShxError::Truncated))); + let mut big = BIGFONT.to_vec(); + big.extend([255, 255, 255, 255, 255, 255]); + assert!(matches!(parse(&big), Err(ShxError::TooLarge))); + } +} From b919ac40f3873fd3893c7ad97e6351940714c366 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 10:48:46 -0500 Subject: [PATCH 120/382] test(tga): validate metadata fixture selector explicitly --- crates/tga/src/metadata_tests.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/tga/src/metadata_tests.rs b/crates/tga/src/metadata_tests.rs index 583f5d691..85c434bf4 100644 --- a/crates/tga/src/metadata_tests.rs +++ b/crates/tga/src/metadata_tests.rs @@ -163,6 +163,7 @@ fn complete_tga_footer_and_metadata_do_not_change_pixels() { } fn preceding_metadata(complete: bool, metadata: usize) -> Vec { + assert!(metadata <= 3, "test metadata selector must be 0..=3"); let mut file = header(2, if complete { 1 } else { 2 }, 1, 24, 0x20); file.extend_from_slice(&[0, 0, 255]); let payload_offset = file.len() as u32; @@ -180,7 +181,7 @@ fn preceding_metadata(complete: bool, metadata: usize) -> Vec { 1 => file.extend_from_slice(&[0; 2048]), 2 => file.extend_from_slice(&[1, 1, 0, 255, 0]), 3 => file.extend_from_slice(&18u32.to_le_bytes()), - _ => unreachable!(), + _ => {} } let extension_offset = file.len() as u32; let mut extension = [0; 495]; From 8a1bad8c2cc47f71c2a75fb19b67b54762fe8389 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:48:56 +0000 Subject: [PATCH 121/382] Cover WebP stored orientation --- crates/image-codecs/src/webp_probe.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/image-codecs/src/webp_probe.rs b/crates/image-codecs/src/webp_probe.rs index 8376274df..d70fac38d 100644 --- a/crates/image-codecs/src/webp_probe.rs +++ b/crates/image-codecs/src/webp_probe.rs @@ -35,6 +35,14 @@ pub fn header(bytes: &[u8]) -> Result<(u32, u32, u16), CodecError> { mod tests { use super::*; + #[test] + fn preserves_stored_dimensions_with_exif_orientation() { + let mut image = crate::Image::from_u8(2, 3, crate::ChannelLayout::Rgb, vec![42; 18]).unwrap(); + image.meta.exif = Some(b"II\x2a\x00\x08\x00\x00\x00\x01\x00\x12\x01\x03\x00\x01\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00".to_vec()); + let bytes = crate::encode(&image, Format::WebP, &crate::EncodeOptions::default()).unwrap(); + assert_eq!(header(&bytes).unwrap(), (2, 3, 6)); + } + #[test] fn rejects_missing_and_truncated_image_chunks() { let mut bytes = b"RIFF\x00\x00\x00\x00WEBP".to_vec(); From 82e258ab6eae4f4d6cd9dfe463a8640fd20c96d9 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:50:14 +0000 Subject: [PATCH 122/382] Exercise camera orientation in WebP fixture --- crates/image-codecs/src/webp_probe.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/image-codecs/src/webp_probe.rs b/crates/image-codecs/src/webp_probe.rs index d70fac38d..8e33a71cf 100644 --- a/crates/image-codecs/src/webp_probe.rs +++ b/crates/image-codecs/src/webp_probe.rs @@ -39,7 +39,11 @@ mod tests { fn preserves_stored_dimensions_with_exif_orientation() { let mut image = crate::Image::from_u8(2, 3, crate::ChannelLayout::Rgb, vec![42; 18]).unwrap(); image.meta.exif = Some(b"II\x2a\x00\x08\x00\x00\x00\x01\x00\x12\x01\x03\x00\x01\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00".to_vec()); - let bytes = crate::encode(&image, Format::WebP, &crate::EncodeOptions::default()).unwrap(); + let mut bytes = crate::encode(&image, Format::WebP, &crate::EncodeOptions::default()).unwrap(); + // The writer correctly makes exported pixels upright; simulate a camera file carrying orientation 6. + let exif = bytes.windows(4).position(|v| v == b"EXIF").unwrap(); + let tiff = exif + 8; + bytes[tiff + 18] = 6; assert_eq!(header(&bytes).unwrap(), (2, 3, 6)); } From 5ae0c89fdfca73c924db0521e2772e67c6cd49d3 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:50:50 +0000 Subject: [PATCH 123/382] audio: share compatible PCM essence wrappers --- crates/audio/src/essence_pcm.rs | 147 ++++++++++++++++++++++++++++++++ crates/audio/src/lib.rs | 4 + 2 files changed, 151 insertions(+) create mode 100644 crates/audio/src/essence_pcm.rs diff --git a/crates/audio/src/essence_pcm.rs b/crates/audio/src/essence_pcm.rs new file mode 100644 index 000000000..593ebb1c2 --- /dev/null +++ b/crates/audio/src/essence_pcm.rs @@ -0,0 +1,147 @@ +//! Compatibility WAVE and AIFF wrappers for embedded PCM essence in interchange files. +//! PCM inside the model is interleaved little-endian signed integers (8-bit unsigned for WAVE). + +pub use crate::{pcm_aiff_header as aiff_header, pcm_wav_file as wav_file, pcm_wav_header as wav_header}; + +/// PCM, channels, sample rate and bits of a WAVE file (integer PCM only). +pub fn parse_wav(b: &[u8]) -> Option<(Vec, u16, u32, u16)> { + if b.len() < 12 || &b[..4] != b"RIFF" || &b[8..12] != b"WAVE" { + return None; + } + let mut at = 12; + let mut fmt = None; + while at + 8 <= b.len() { + let id = &b[at..at + 4]; + let len = u32::from_le_bytes(b[at + 4..at + 8].try_into().ok()?) as usize; + let body = &b[at + 8..(at + 8).saturating_add(len).min(b.len())]; + if id == b"fmt " && body.len() >= 16 { + let tag = u16::from_le_bytes([body[0], body[1]]); + let ch = u16::from_le_bytes([body[2], body[3]]); + let sr = u32::from_le_bytes(body[4..8].try_into().ok()?); + let bits = u16::from_le_bytes([body[14], body[15]]); + if tag != 1 && tag != 0xFFFE { + return None; + } + if tag == 0xFFFE { + // The first two bytes of the sub-format GUID carry the real format code. + let sub = body.get(24..26)?; + if u16::from_le_bytes([sub[0], sub[1]]) != 1 { + return None; + } + } + fmt = Some((ch, sr, bits)); + } else if id == b"data" { + let (ch, sr, bits) = fmt?; + return Some((body.to_vec(), ch, sr, bits)); + } + at = at.checked_add(8usize.checked_add(len)?.checked_add(len & 1)?)?; + } + None +} + +/// A complete AIFF file (big-endian PCM) from little-endian PCM. +pub fn aiff_file(pcm: &[u8], channels: u16, sample_rate: u32, bits: u16) -> Vec { + let bps = bits.div_ceil(8) as usize; + let frames = pcm.len() / (bps * channels.max(1) as usize).max(1); + let mut v = aiff_header(frames as u32, channels, sample_rate, bits); + for s in pcm.chunks_exact(bps.max(1)) { + if bps == 1 { + v.push(s[0] ^ 0x80); // WAVE 8-bit is unsigned, AIFF signed + } else { + v.extend(s.iter().rev()); + } + } + if (v.len() - 8) & 1 == 1 { + v.push(0); + } + v +} + +/// PCM (converted to little-endian), channels, sample rate and bits of an AIFF / AIFF-C (`NONE` +/// / `twos` / `sowt`) file. +pub fn parse_aiff(b: &[u8]) -> Option<(Vec, u16, u32, u16)> { + if b.len() < 12 || &b[..4] != b"FORM" || !(&b[8..12] == b"AIFF" || &b[8..12] == b"AIFC") { + return None; + } + let mut at = 12; + let mut comm = None; + while at + 8 <= b.len() { + let id = &b[at..at + 4]; + let len = u32::from_be_bytes(b[at + 4..at + 8].try_into().ok()?) as usize; + let body = &b[at + 8..(at + 8).saturating_add(len).min(b.len())]; + if id == b"COMM" && body.len() >= 18 { + let ch = u16::from_be_bytes([body[0], body[1]]); + let bits = u16::from_be_bytes([body[6], body[7]]); + let sr = from_extended(body[8..18].try_into().ok()?).round() as u32; + let little = body.len() >= 22 && &body[18..22] == b"sowt"; + comm = Some((ch, sr, bits, little)); + } else if id == b"SSND" && body.len() >= 8 { + let (ch, sr, bits, little) = comm?; + let off = u32::from_be_bytes(body[..4].try_into().ok()?) as usize; + let data = body.get(8usize.checked_add(off)?..)?; + let bps = bits.div_ceil(8) as usize; + let mut pcm = Vec::with_capacity(data.len()); + for s in data.chunks_exact(bps.max(1)) { + if bps == 1 { + pcm.push(s[0] ^ 0x80); + } else if little { + pcm.extend_from_slice(s); + } else { + pcm.extend(s.iter().rev()); + } + } + return Some((pcm, ch, sr, bits)); + } + at = at.checked_add(8usize.checked_add(len)?.checked_add(len & 1)?)?; + } + None +} + +fn from_extended(b: [u8; 10]) -> f64 { + let e = (u16::from_be_bytes([b[0], b[1]]) & 0x7FFF) as i32; + let m = u64::from_be_bytes(b[2..10].try_into().unwrap_or([0; 8])); + if e == 0 && m == 0 { + return 0.0; + } + m as f64 / (1u64 << 63) as f64 * 2f64.powi(e - 16383) +} + +#[cfg(test)] +mod tests { + /// A mutated EDL whose clip ran for days produced an OMF descriptor for more than 4 GiB of + /// PCM: the RIFF size field overflowed ("attempt to add with overflow"). + #[test] + fn huge_wav_header_saturates() { + let h = super::wav_header(u32::MAX, 2, u32::MAX, 24); + assert_eq!(&h[4..8], &u32::MAX.to_le_bytes()); + } + + use super::*; + + #[test] + fn accepts_truncated_essence_summaries() { + let mut wav = wav_file(&[1, 2, 3, 4], 1, 48_000, 16); + wav.truncate(46); + assert_eq!(parse_wav(&wav), Some((vec![1, 2], 1, 48_000, 16))); + let mut aiff = aiff_file(&[1, 2, 3, 4], 1, 48_000, 16); + aiff.truncate(56); + assert_eq!(parse_aiff(&aiff), Some((vec![1, 2], 1, 48_000, 16))); + } + + #[test] + fn wav_and_aiff_round_trip() { + let pcm: Vec = (0..48u8).collect(); // 8 stereo 24-bit frames + let w = wav_file(&pcm, 2, 48_000, 24); + assert_eq!(parse_wav(&w), Some((pcm.clone(), 2, 48_000, 24))); + let a = aiff_file(&pcm, 2, 44_100, 24); + assert_eq!(parse_aiff(&a), Some((pcm.clone(), 2, 44_100, 24))); + let p16: Vec = (0..32u8).collect(); + assert_eq!(parse_aiff(&aiff_file(&p16, 1, 96_000, 16)), Some((p16, 1, 96_000, 16))); + assert!(parse_wav(b"RIFF").is_none()); + assert!(parse_aiff(&a[..30]).is_none()); + for cut in 0..w.len() { + let _ = parse_wav(&w[..cut]); + let _ = parse_aiff(&a[..cut.min(a.len())]); + } + } +} diff --git a/crates/audio/src/lib.rs b/crates/audio/src/lib.rs index 33dcdee3b..7bbfbbcf5 100644 --- a/crates/audio/src/lib.rs +++ b/crates/audio/src/lib.rs @@ -66,6 +66,10 @@ mod wav; feature = "vorbis-encode" ))] mod write; + +/// PCM WAVE and AIFF wrappers for interchange essence. +#[cfg(feature = "pcm-encode")] +pub mod essence_pcm; #[cfg(feature = "vorbis-encode")] pub use write::{OGG_BITRATES, encode_ogg}; From 2f2d1d84e3a36b3f93e81507aeff3f0da97a7162 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:51:27 +0000 Subject: [PATCH 124/382] Share bounded SHX glyph program interpreter --- crates/shx/src/lib.rs | 1 + crates/shx/src/program.rs | 443 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 444 insertions(+) create mode 100644 crates/shx/src/program.rs diff --git a/crates/shx/src/lib.rs b/crates/shx/src/lib.rs index ce330450c..e330e59fd 100644 --- a/crates/shx/src/lib.rs +++ b/crates/shx/src/lib.rs @@ -5,6 +5,7 @@ mod compile; mod error; pub mod parse; +pub mod program; pub use compile::compile; pub use error::ShxError; pub use parse::{ParsedFont, Record, ShxKind}; diff --git a/crates/shx/src/program.rs b/crates/shx/src/program.rs new file mode 100644 index 000000000..9115d1c6d --- /dev/null +++ b/crates/shx/src/program.rs @@ -0,0 +1,443 @@ +//! The shape pen program: vector length/direction bytes and special codes 0–14, run into +//! polylines. Bounded everywhere: subshape depth, location stack, steps, points, coordinates. +//! +//! - A byte with a non-zero high nibble is a vector: length (high nibble) in one of 16 +//! directions (low nibble, counter-clockwise from east in 22.5° steps; the off-axis ones +//! are half-unit or unit steps on the minor axis). +//! - 0 end, 1 pen down, 2 pen up, 3/4 divide/multiply vector lengths by the next byte, +//! 5/6 push/pop the location, 7 subshape (one byte; two bytes high first in a Unicode font; +//! `0`, a two-byte number, base point, width and height in an extended big font), +//! 8 one X-Y displacement, 9 displacements up to (0,0), 10 octant arc (radius, +//! ±0SC: sign = clockwise, S start octant, C octants, 0 = 8), 11 fractional arc (start +//! offset, end offset, high and low radius, ±0SC; offsets in 1/256 of 45° from the octant +//! boundaries), 12 bulge arc (dx, dy, bulge: ±127 = semicircle), 13 bulge arcs up to (0,0), +//! 14 the next command is for vertical text only (dual-orientation fonts). +//! - Displacements and bulges are two's complement bytes; the arc direction byte keeps its +//! sign in the high bit. + +use std::f64::consts::{FRAC_PI_4, TAU}; + +use super::ShxKind; +use std::ops::{Add, Mul, Neg, Sub}; + +/// A point in SHX font units. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct Point { + pub x: f64, + pub y: f64, +} +impl Point { + pub const ZERO: Self = Self { x: 0.0, y: 0.0 }; + pub const fn new(x: f64, y: f64) -> Self { + Self { x, y } + } + fn is_finite(self) -> bool { + self.x.is_finite() && self.y.is_finite() + } + fn len(self) -> f64 { + self.x.hypot(self.y) + } + fn len2(self) -> f64 { + self.x * self.x + self.y * self.y + } +} +impl Add for Point { + type Output = Self; + fn add(self, rhs: Self) -> Self { + Self::new(self.x + rhs.x, self.y + rhs.y) + } +} +impl Sub for Point { + type Output = Self; + fn sub(self, rhs: Self) -> Self { + Self::new(self.x - rhs.x, self.y - rhs.y) + } +} +impl Mul for Point { + type Output = Self; + fn mul(self, rhs: f64) -> Self { + Self::new(self.x * rhs, self.y * rhs) + } +} +impl Neg for Point { + type Output = Self; + fn neg(self) -> Self { + Self::new(-self.x, -self.y) + } +} + +/// Font records and metrics the bounded shape interpreter needs. +pub trait Font { + fn kind(&self) -> ShxKind; + fn dual(&self) -> bool; + fn above(&self) -> f64; + fn char_width(&self) -> f64; + fn program(&self, number: u16) -> Option<&[u8]>; +} +/// Pen-down strokes and advance in font units. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Glyph { + pub strokes: Vec>, + pub advance: Point, +} + +/// Subshape nesting (a cycle ends here). +const MAX_DEPTH: usize = 16; +/// Location stack (the format promises four). +const MAX_STACK: usize = 64; +/// Bytes run per glyph, subshapes included. +const MAX_STEPS: usize = 200_000; +/// Points per glyph. +const MAX_POINTS: usize = 50_000; +/// Coordinates in font units. +const MAX_COORD: f64 = 1.0e7; +/// Arc segments per full turn. +const ARC_STEPS: f64 = 64.0; + +/// Why a program stops early: the glyph is then not drawn. +#[derive(Debug)] +pub struct Broken; + +type Res = Result<(), Broken>; + +struct Pen<'a> { + font: &'a dyn Font, + vertical: bool, + pos: Point, + down: bool, + /// Vector length factor (codes 3 and 4). + scale: f64, + /// Per-axis factor of an extended big font subshape. + axes: Point, + stack: Vec, + strokes: Vec>, + active: Vec, + steps: usize, + points: usize, +} + +pub fn outline(font: &dyn Font, number: u16, vertical: bool) -> Result { + let mut pen = Pen { + font, + vertical, + pos: Point::ZERO, + down: true, + scale: 1.0, + axes: Point::new(1.0, 1.0), + stack: Vec::new(), + strokes: Vec::new(), + active: Vec::new(), + steps: 0, + points: 0, + }; + pen.run(number, 0)?; + pen.flush(); + Ok(Glyph { strokes: pen.strokes, advance: pen.pos }) +} + +/// The 16 vector directions (unit length on the major axis). +fn direction(d: u8) -> Point { + let (x, y) = match d & 15 { + 0 => (1.0, 0.0), + 1 => (1.0, 0.5), + 2 => (1.0, 1.0), + 3 => (0.5, 1.0), + 4 => (0.0, 1.0), + 5 => (-0.5, 1.0), + 6 => (-1.0, 1.0), + 7 => (-1.0, 0.5), + 8 => (-1.0, 0.0), + 9 => (-1.0, -0.5), + 10 => (-1.0, -1.0), + 11 => (-0.5, -1.0), + 12 => (0.0, -1.0), + 13 => (0.5, -1.0), + 14 => (1.0, -1.0), + _ => (1.0, -0.5), + }; + Point::new(x, y) +} + +/// A two's complement operand byte. +fn signed(b: u8) -> f64 { + f64::from(i8::from_le_bytes([b])) +} + +/// A program being read: its bytes and position. +struct Cur<'p> { + b: &'p [u8], + pos: usize, +} + +impl Cur<'_> { + fn byte(&mut self) -> Result { + let v = self.b.get(self.pos).copied().ok_or(Broken)?; + self.pos += 1; + Ok(v) + } +} + +impl Pen<'_> { + fn step(&mut self) -> Res { + self.steps += 1; + if self.steps > MAX_STEPS { Err(Broken) } else { Ok(()) } + } + + fn flush(&mut self) { + if self.active.len() >= 2 { + self.strokes.push(std::mem::take(&mut self.active)); + } else { + self.active.clear(); + } + } + + /// Move the pen by `d` font units (already scaled), drawing when the pen is down. + fn to(&mut self, target: Point) -> Res { + if !target.is_finite() || target.x.abs().max(target.y.abs()) > MAX_COORD { + return Err(Broken); + } + if self.down { + if self.active.is_empty() { + self.active.push(self.pos); + self.points += 1; + } + self.active.push(target); + self.points += 1; + if self.points > MAX_POINTS { + return Err(Broken); + } + } else { + self.flush(); + } + self.pos = target; + Ok(()) + } + + /// A displacement in vector units (times the length factor and the subshape axes). + fn by(&mut self, d: Point) -> Res { + let k = d * self.scale; + self.to(self.pos + Point::new(k.x * self.axes.x, k.y * self.axes.y)) + } + + /// An arc of `radius` vector units from the pen, starting at angle `start` on its circle + /// and turning `sweep` radians (positive counter-clockwise). + fn arc(&mut self, radius: f64, start: f64, sweep: f64) -> Res { + let r = radius * self.scale; + if !(r.is_finite() && r > 0.0 && sweep.is_finite()) { + return Ok(()); + } + let n = if self.down { (sweep.abs() / TAU * ARC_STEPS).ceil().clamp(1.0, ARC_STEPS) as usize } else { 1 }; + let from = self.pos; + let s0 = Point::new(start.cos(), start.sin()); + for i in 1..=n { + let a = start + sweep * i as f64 / n as f64; + let d = (Point::new(a.cos(), a.sin()) - s0) * r; + self.to(from + Point::new(d.x * self.axes.x, d.y * self.axes.y))?; + } + Ok(()) + } + + /// An arc to the displacement `d` with `bulge` (−127..127, ±127 a semicircle). + fn bulge(&mut self, d: Point, bulge: f64) -> Res { + let b = bulge.clamp(-127.0, 127.0) / 127.0; + if b == 0.0 || !self.down || d.len2() == 0.0 { + return self.by(d); + } + // Centre from the chord midpoint along its left normal; sweep 4·atan(b). + let centre = d * 0.5 + Point::new(-d.y, d.x) * ((1.0 - b * b) / (4.0 * b)); + let rel = -centre; + self.arc(rel.len(), rel.y.atan2(rel.x), 4.0 * b.atan()) + } + + /// The octant byte `±0SC`: (clockwise, start octant, octants with 0 = 8). + fn octants(spec: u8) -> (f64, f64, f64) { + let sign = if spec & 0x80 != 0 { -1.0 } else { 1.0 }; + let s = f64::from((spec >> 4) & 7); + let c = match spec & 7 { + 0 => 8.0, + c => f64::from(c), + }; + (sign, s, c) + } + + /// The vector unit size of an extended big font's subshape cell. + fn cell(&self) -> Point { + let h = if self.font.above() > 0.0 { self.font.above() } else { 1.0 }; + let w = if self.font.char_width() > 0.0 { self.font.char_width() } else { h }; + Point::new(w, h) + } + + fn run(&mut self, number: u16, depth: usize) -> Res { + if depth >= MAX_DEPTH { + return Err(Broken); + } + let program = self.font.program(number).ok_or(Broken)?; + let mut r = Cur { b: program, pos: 0 }; + let mut skip = false; + while r.pos < r.b.len() { + self.step()?; + let code = r.byte()?; + // Code 14: in a dual-orientation font the next command is for vertical text only. + let exec = !skip; + skip = false; + match code { + 0 => return Ok(()), + 1 if exec => self.down = true, + 2 if exec => { + self.down = false; + self.flush(); + } + 3 | 4 => { + let k = f64::from(r.byte()?); + if exec && k > 0.0 { + let s = if code == 3 { self.scale / k } else { self.scale * k }; + if !(1e-9..=MAX_COORD).contains(&s) { + return Err(Broken); + } + self.scale = s; + } + } + 5 if exec => { + if self.stack.len() >= MAX_STACK { + return Err(Broken); + } + self.stack.push(self.pos); + } + 6 if exec => { + self.flush(); + if let Some(p) = self.stack.pop() { + self.pos = p; + } + } + 7 => self.subshape(&mut r, exec, depth)?, + 8 | 9 | 12 | 13 => loop { + self.step()?; + let d = Point::new(signed(r.byte()?), signed(r.byte()?)); + if matches!(code, 9 | 13) && d == Point::ZERO { + break; + } + let bulge = if matches!(code, 12 | 13) { signed(r.byte()?) } else { 0.0 }; + if exec { + self.bulge(d, bulge)?; + } + if matches!(code, 8 | 12) { + break; + } + }, + 10 => { + let radius = f64::from(r.byte()?); + let (sign, s, c) = Self::octants(r.byte()?); + if exec { + self.arc(radius, s * FRAC_PI_4, sign * c * FRAC_PI_4)?; + } + } + 11 => { + let start = f64::from(r.byte()?) / 256.0; + let end = match r.byte()? { + 0 => 1.0, + e => f64::from(e) / 256.0, + }; + let radius = f64::from(u16::from_be_bytes([r.byte()?, r.byte()?])); + let (sign, s, c) = Self::octants(r.byte()?); + if exec { + // From `start` past the first octant boundary to `end` past the last + // octant's. + self.arc(radius, (s + sign * start) * FRAC_PI_4, sign * (c - 1.0 + end - start) * FRAC_PI_4)?; + } + } + 14 => skip = self.font.dual() && !self.vertical && exec, + 1..=15 => {} + v => { + if exec { + self.by(direction(v) * f64::from(v >> 4))?; + } + } + } + } + Ok(()) + } + + /// Code 7 and its operands. + fn subshape(&mut self, r: &mut Cur, exec: bool, depth: usize) -> Res { + match self.font.kind() { + ShxKind::Unifont => { + let n = u16::from_be_bytes([r.byte()?, r.byte()?]); + if exec { + self.run(n, depth + 1)?; + } + } + ShxKind::BigFont => { + let first = r.byte()?; + if first != 0 { + if exec { + self.run(u16::from(first), depth + 1)?; + } + return Ok(()); + } + // Extended: the primitive drawn in the box (x, y, width, height) of the cell. + let n = u16::from_be_bytes([r.byte()?, r.byte()?]); + let (x, y, w, h) = (f64::from(r.byte()?), f64::from(r.byte()?), f64::from(r.byte()?), f64::from(r.byte()?)); + if !exec { + return Ok(()); + } + let (pos, axes, down) = (self.pos, self.axes, self.down); + let cell = self.cell(); + self.flush(); + self.pos = pos + Point::new(x * axes.x, y * axes.y) * self.scale; + self.axes = Point::new(axes.x * w / cell.x, axes.y * h / cell.y); + let res = self.run(n, depth + 1); + self.flush(); + self.axes = axes; + self.pos = pos; + self.down = down; + res?; + } + ShxKind::Shapes => { + let n = u16::from(r.byte()?); + if exec { + self.run(n, depth + 1)?; + } + } + } + Ok(()) + } +} + +impl Font for crate::ParsedFont { + fn kind(&self) -> ShxKind { + self.kind + } + fn dual(&self) -> bool { + self.dual + } + fn above(&self) -> f64 { + self.above + } + fn char_width(&self) -> f64 { + self.char_width + } + fn program(&self, number: u16) -> Option<&[u8]> { + let r = self.records.get(&number)?; + self.data.get(r.program.0..r.program.1) + } +} + +#[cfg(test)] +mod tests { + #![allow(clippy::unwrap_used)] + use super::*; + #[test] + fn executes_shape_vectors_without_app_geometry_types() { + let bytes = crate::compile("*1,3,A\n1,010,0\n").unwrap(); + let font = crate::parse::parse(&bytes).unwrap(); + let glyph = outline(&font, 1, false).unwrap(); + assert_eq!(glyph.strokes, vec![vec![Point::new(0.0, 0.0), Point::new(1.0, 0.0)]]); + assert_eq!(glyph.advance, Point::new(1.0, 0.0)); + } + #[test] + fn recursive_shapes_stop_at_the_depth_bound() { + let bytes = crate::compile("*1,3,A\n7,1,0\n").unwrap(); + let font = crate::parse::parse(&bytes).unwrap(); + assert!(outline(&font, 1, false).is_err()); + } +} From 5a36112af6567a60491c47361a9fdd44ad362979 Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 16:51:49 +0100 Subject: [PATCH 125/382] craft-image-codecs: SGI rows may share compressed data and must start after the offset tables Addresses review findings: the RLE size check no longer demands separate payload space for every row, and a row offset inside the offset tables is refused. A row without its trailing zero count still reads, as in ffmpeg. --- crates/image-codecs/src/codecs/sgi.rs | 56 +++++++++++++++++++++++++-- 1 file changed, 53 insertions(+), 3 deletions(-) diff --git a/crates/image-codecs/src/codecs/sgi.rs b/crates/image-codecs/src/codecs/sgi.rs index 1e31b5f0a..64c80299c 100644 --- a/crates/image-codecs/src/codecs/sgi.rs +++ b/crates/image-codecs/src/codecs/sgi.rs @@ -120,8 +120,9 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { // Reject inputs that cannot hold the declared pixels before allocating anything for them. let table = if h.rle { rows.checked_mul(8).ok_or_else(|| bad("image size overflow"))? } else { 0 }; let min_len = if h.rle { - // Every row needs at least a packet and a terminator. - HEADER + table + rows * bps + // Both offset tables must fit; rows may share compressed data, so the data itself is + // checked row by row against the offsets below. + HEADER + table } else { HEADER + total.checked_mul(bps).ok_or_else(|| bad("image size overflow"))? }; @@ -138,7 +139,10 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { if h.rle { let start = be32(b, HEADER + index * 4) as usize; let len = be32(b, HEADER + rows * 4 + index * 4) as usize; - let end = start.checked_add(len).filter(|&e| e <= b.len() && start >= HEADER).ok_or_else(|| bad("RLE row lies outside the file"))?; + let end = start + .checked_add(len) + .filter(|&e| e <= b.len() && start >= HEADER + table) + .ok_or_else(|| bad("RLE row lies outside the file"))?; read_rle_row(&b[start..end], h.wide, &mut row)?; } else { let start = HEADER + index * w * bps; @@ -335,6 +339,52 @@ mod tests { assert!(decode(&huge, &Limits::default()).is_err()); } + /// A 1-plane, 8-bit RLE file whose `rows` all start where `starts[i]` says, each `len` bytes long. + fn rle_file(w: u16, starts: &[u32], len: u32, payload: &[u8]) -> Vec { + let mut f = vec![0u8; HEADER]; + f[0..2].copy_from_slice(&MAGIC.to_be_bytes()); + f[2] = 1; + f[3] = 1; + f[4..6].copy_from_slice(&2u16.to_be_bytes()); + f[6..8].copy_from_slice(&w.to_be_bytes()); + f[8..10].copy_from_slice(&(starts.len() as u16).to_be_bytes()); + f[10..12].copy_from_slice(&1u16.to_be_bytes()); + for s in starts { + f.extend_from_slice(&s.to_be_bytes()); + } + for _ in starts { + f.extend_from_slice(&len.to_be_bytes()); + } + f.extend_from_slice(payload); + f + } + + /// The format lets table entries share one compressed row: eight rows, one payload. + #[test] + fn rows_may_share_compressed_data() { + let table = HEADER + 8 * 8; + let f = rle_file(1, &[table as u32; 8], 3, &[0x81, 255, 0]); + assert_eq!(f.len(), table + 3); + let img = decode(&f, &Limits::default()).unwrap(); + assert_eq!((img.dimensions(), img.data()), ((1, 8), &[255u8; 8][..])); + } + + /// Compressed rows start after both tables: an offset into a table is refused. + #[test] + fn rows_may_not_start_inside_the_offset_tables() { + // 3x1: the tables end at 520; 515 reads the table's own bytes as a packet list. + let f = rle_file(3, &[515], 3, &[0, 0, 0, 0, 0]); + assert!(decode(&f, &Limits::default()).is_err()); + } + + /// FFmpeg's decoder, run as an oracle, also reads a row that ends with its last packet and no + /// zero terminator; so does this one. + #[test] + fn a_row_without_its_terminator_still_reads() { + let f = rle_file(1, &[520], 2, &[0x81, 42]); + assert_eq!(decode(&f, &Limits::default()).unwrap().data(), &[42]); + } + #[test] fn palette_mapped_files_are_unsupported() { let img = gradient(4, 4, ChannelLayout::Gray); From e9eaaf5641640b4e2735b0af79ef589c5a74a88a Mon Sep 17 00:00:00 2001 From: el-j Date: Sun, 15 Nov 2026 16:52:35 +0100 Subject: [PATCH 126/382] craft-image-codecs: Sun Raster 1-bit colour maps, opaque standard 32-bit pixels, fallible output buffer Addresses review findings: a 1-bit file with an RGB colour map reads as colour; the unused first byte of standard 32-bit pixels is no longer read as alpha; the writer's buffer is reserved with try_reserve_exact. README lists the native layouts correctly. --- crates/image-codecs/README.md | 2 +- crates/image-codecs/src/codecs/sunraster.rs | 52 +++++++++++++++++++-- 2 files changed, 49 insertions(+), 5 deletions(-) diff --git a/crates/image-codecs/README.md b/crates/image-codecs/README.md index f9f5f53e6..a37760d80 100644 --- a/crates/image-codecs/README.md +++ b/crates/image-codecs/README.md @@ -56,7 +56,7 @@ craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "< | Cineon | yes | yes | U16 (10-bit code values read and written exactly through U16) | Gray, RGB | no | no | no | no | no | no | no | built in | | DICOM | yes | **no** | U8, U16 | Gray, RGB | no | no | no | no | no | no | n/a | built in | | Amiga IFF (ILBM/PBM) | yes | yes (24-bit ILBM) | U8 | RGB, RGBA | yes (1-bit mask plane on write) | no | no | no | no | no | no | built in | -| Sun Raster (`.ras`) | yes (incl. RLE and colour maps) | yes (uncompressed) | U8 | Gray, Gray+A, RGB, RGBA | yes | no | no | no | no | no | no | built in | +| Sun Raster (`.ras`) | yes (incl. RLE and colour maps) | yes (uncompressed) | U8 | Gray, RGB, RGBA | yes | no | no | no | no | no | no | built in | | AVIF | **no** | only with feature `avif` | U8 | RGB, RGBA | yes | no | no | no | no | no | yes | `image` + `ravif` | | HEIF/HEIC | with feature `heif` | **no** | U8, U16 (10/12-bit decodes to U16) | RGB, RGBA | yes (auxiliary alpha) | yes (`colr` prof) | yes | yes | no | no | n/a | `heic-rs` | diff --git a/crates/image-codecs/src/codecs/sunraster.rs b/crates/image-codecs/src/codecs/sunraster.rs index 84d60f145..85c24acc5 100644 --- a/crates/image-codecs/src/codecs/sunraster.rs +++ b/crates/image-codecs/src/codecs/sunraster.rs @@ -97,9 +97,18 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { for x in 0..wu { match depth { 1 => { - // A set bit is black. let bit = (row[x / 8] >> (7 - x % 8)) & 1; - out.push(if bit == 1 { 0 } else { 255 }); + if map_type == 1 { + // The bit is an index into the (two-entry or longer) colour map. + let i = usize::from(bit); + if i >= entries { + return Err(bad("pixel index is outside the colour map")); + } + out.extend_from_slice(&[map[i], map[entries + i], map[2 * entries + i]]); + } else { + // A set bit is black. + out.push(if bit == 1 { 0 } else { 255 }); + } } 8 if map_type == 1 => { let i = usize::from(row[x]); @@ -115,7 +124,8 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { } _ => { let p = &row[4 * x..4 * x + 4]; - out.extend_from_slice(&if kind == 3 { [p[1], p[2], p[3], p[0]] } else { [p[3], p[2], p[1], p[0]] }); + // In the standard types the first byte (X in XBGR) is unused, not alpha. + out.extend_from_slice(&if kind == 3 { [p[1], p[2], p[3], p[0]] } else { [p[3], p[2], p[1], 255] }); } } } @@ -123,6 +133,13 @@ pub(crate) fn decode(b: &[u8], limits: &Limits) -> Result { Image::from_u8(w, h, layout, out) } +/// A buffer of `cap` bytes, or an error instead of an abort when the allocation cannot be made. +fn reserve(cap: usize) -> std::result::Result, std::collections::TryReserveError> { + let mut v = Vec::new(); + v.try_reserve_exact(cap)?; + Ok(v) +} + /// Writes an uncompressed rasterfile: 8-bit gray, 24-bit RGB or 32-bit RGBA, in the RGB-ordered type. pub(crate) fn encode(src: &Image, plan: Plan) -> Result, CodecError> { let enc = |msg: String| CodecError::encode(F, msg); @@ -145,7 +162,8 @@ pub(crate) fn encode(src: &Image, plan: Plan) -> Result, CodecError> { if data.len() != wu * hu * bytes { return Err(enc("the image has the wrong number of samples".into())); } - let mut out = Vec::with_capacity(HEADER + len as usize); + let mut out = reserve(HEADER.checked_add(len as usize).ok_or_else(|| enc("image too large".into()))?) + .map_err(|_| enc("the image is too large to encode".into()))?; for v in [MAGIC, w, h, depth as u32, len, 3, 0, 0] { out.extend_from_slice(&v.to_be_bytes()); } @@ -218,6 +236,32 @@ mod tests { assert_eq!(decode(&f, &Limits::default()).unwrap().data(), &[0, 255, 0]); } + #[test] + fn one_bit_files_with_a_colour_map_read_as_colour() { + // Two entries: red plane, green plane, blue plane; bit 0 is entry 0. + let map = [10, 20, 30, 40, 50, 60]; + let f = file(1, 1, &map, 1, 3, 1, &[0b0100_0000, 0]); + let img = decode(&f, &Limits::default()).unwrap(); + assert_eq!((img.layout(), img.data()), (ChannelLayout::Rgb, &[10, 30, 50, 20, 40, 60, 10, 30, 50][..])); + // A one-entry map has no entry for a set bit. + assert!(decode(&file(1, 1, &[1, 2, 3], 1, 1, 1, &[0b1000_0000, 0]), &Limits::default()).is_err()); + } + + #[test] + fn the_unused_first_byte_of_standard_32_bit_pixels_is_not_alpha() { + let img = decode(&file(32, 1, &[], 0, 1, 1, &[0, 30, 20, 10]), &Limits::default()).unwrap(); + assert_eq!((img.layout(), img.data()), (ChannelLayout::Rgba, &[10, 20, 30, 255][..])); + // In the RGB-ordered type the first byte is the alpha the writer stores there. + let img = decode(&file(32, 3, &[], 0, 1, 1, &[7, 10, 20, 30]), &Limits::default()).unwrap(); + assert_eq!(img.data(), &[10, 20, 30, 7]); + } + + #[test] + fn an_output_buffer_too_large_to_allocate_is_an_error() { + assert!(reserve(usize::MAX).is_err()); + assert!(reserve(16).is_ok()); + } + #[test] fn hostile_input_is_an_error_not_a_panic() { let img = pattern(9, 5, ChannelLayout::Rgb); From 8ce5335e8fc93c4e9546286390a0b0d35897585a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:53:30 +0000 Subject: [PATCH 127/382] aaf: preserve bounded FilmCraft OMF traversal --- crates/aaf/src/lib.rs | 4 + crates/aaf/src/omf/read.rs | 255 +++++++++++++++++++++++++++++++++++-- crates/aaf/src/pcm.rs | 5 - 3 files changed, 248 insertions(+), 16 deletions(-) diff --git a/crates/aaf/src/lib.rs b/crates/aaf/src/lib.rs index ee7448bc0..4968c5b39 100644 --- a/crates/aaf/src/lib.rs +++ b/crates/aaf/src/lib.rs @@ -29,7 +29,11 @@ mod roundtrip_tests; #[cfg(test)] mod testdoc; +/// Diagnostic types used by readers and writers. +pub use craft_timeline::report; pub use craft_timeline::report::Report; +/// Exact time types used by the composition model. +pub use craft_timeline::time; /// Error from a reader or writer. Unsupported *features* never error; they go in the [`Report`]. #[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] diff --git a/crates/aaf/src/omf/read.rs b/crates/aaf/src/omf/read.rs index d45b6ff63..b9c3bd9d1 100644 --- a/crates/aaf/src/omf/read.rs +++ b/crates/aaf/src/omf/read.rs @@ -12,6 +12,10 @@ type Uid = [u8; 12]; const MAX_REFERENCE_VISITS: usize = 65_536; +/// A source-clip search stopped at its work limit. +#[derive(Clone, Copy)] +struct SearchLimit; + struct R<'a, 'b> { c: &'b Container<'a>, report: &'b mut Report, @@ -21,15 +25,43 @@ struct R<'a, 'b> { media: HashMap>, doc: Document, sources: HashMap<(Uid, u32, String), usize>, + /// Component visits left for [`R::segment`] over the whole document. + budget: usize, + /// Outcome of the source-clip search under each segment: deterministic, so it is made once. + clip_search: HashMap, SearchLimit>>, } +/// Components one document may expand into timeline items; a small file can reference the same +/// sequence from many places and would otherwise multiply without bound. +const MAX_COMPONENT_VISITS: usize = 1_000_000; + +/// Reported when the shared component budget runs out. +const BUDGET_WARNING: &str = "OMF composition is too large to import completely (the remaining components are dropped)"; +/// Most visited components, and most queued references, one source-clip search may spend. +const MAX_CLIP_SEARCH_VISITS: usize = 100_000; +const MAX_CLIP_SEARCH_PENDING: usize = 1_000_000; + pub(crate) fn read(bytes: &[u8], report: &mut Report) -> Result { + read_with_budget(bytes, report, MAX_COMPONENT_VISITS) +} + +fn read_with_budget(bytes: &[u8], report: &mut Report, budget: usize) -> Result { let perr = |m: String| Error::Parse { format: "OMF", message: m }; let c = Container::open(bytes).map_err(perr)?; let class_of = |o: u32| c.get(o, "OMFI:OOBJ:ObjClass").and_then(|v| v.get(..4).map(|b| [b[0], b[1], b[2], b[3]])); let head = c.objects.keys().copied().find(|&o| class_of(o) == Some(*b"HEAD")).ok_or_else(|| perr("no OMF header object".into()))?; let be = c.get(head, "OMFI:HEAD:ByteOrder").is_none_or(|v| v.first() != Some(&0x49)); - let mut r = R { c: &c, report, be, mobs: HashMap::new(), media: HashMap::new(), doc: Document::default(), sources: HashMap::new() }; + let mut r = R { + c: &c, + report, + be, + mobs: HashMap::new(), + media: HashMap::new(), + doc: Document::default(), + sources: HashMap::new(), + budget, + clip_search: HashMap::new(), + }; let mob_list = r.refs(head, "OMFI:HEAD:Mobs"); let mob_list = if mob_list.is_empty() { c.objects.keys().copied().filter(|&o| matches!(class_of(o).as_ref(), Some(b"CMOB" | b"MMOB" | b"SMOB"))).collect() @@ -66,8 +98,14 @@ pub(crate) fn read(bytes: &[u8], report: &mut Report) -> Result { cmobs.iter().copied().filter(|m| r.uid(*m, "OMFI:MOBJ:MobID").is_none_or(|id| !referenced.contains(&id))).collect() }; for m in top { + // every composition spends from the budget too: a list of up to 65,535 repeated entries must not yield that many + if r.budget == 0 && !r.doc.compositions.is_empty() { + r.report.warn(BUDGET_WARNING); + break; + } let comp = r.composition(m); r.doc.compositions.push(comp); + r.budget = r.budget.saturating_sub(1); } if r.doc.compositions.is_empty() { return Err(Error::Empty); @@ -166,6 +204,13 @@ impl R<'_, '_> { let slots = self.refs(m, "OMFI:MOBJ:Slots"); let mut na = 0; for s in slots { + if self.budget == 0 { + self.report.warn(BUDGET_WARNING); + break; + } + // Every slot spends a unit, skipped ones too: a list of up to 65,535 repeated slots + // must not cost that much work in each of 65,535 repeated compositions. + self.budget -= 1; let Some(seg) = self.r#ref(s, "OMFI:MSLT:Segment") else { continue }; let rate = self.rational(s, "OMFI:MSLT:EditRate").filter(|r| r.0 > 0 && r.1 > 0).unwrap_or((25, 1)); let kind = self.data_kind(seg); @@ -213,9 +258,15 @@ impl R<'_, '_> { fn segment(&mut self, seg: u32, rate: (i64, i64), depth: usize) -> Vec { let len = units_to_ticks(self.len(seg), rate.0, rate.1); - if depth > 32 { + // Depth alone does not bound a graph that references the same component many times at + // every level, so each visit also spends from a per-document budget. + if depth > 32 || self.budget == 0 { + if self.budget == 0 { + self.report.warn(BUDGET_WARNING); + } return vec![CItem::Filler(len)]; } + self.budget -= 1; match &self.class(seg) { b"SEQU" => { let mut out = Vec::new(); @@ -306,12 +357,44 @@ impl R<'_, '_> { .find(|&s| self.r#ref(s, "OMFI:MSLT:TrackDesc").and_then(|t| self.u32(t, "OMFI:TRKD:TrackID")) == Some(track)) } - fn first_clip(&self, seg: u32) -> Option { - match &self.class(seg) { - b"SCLP" => Some(seg), - b"SEQU" => self.refs(seg, "OMFI:SEQU:Components").into_iter().find_map(|c| self.first_clip(c)), - _ => None, + /// First source clip under `seg`, depth-first; a sequence referencing itself (directly or + /// through a cycle) ends the search rather than the stack. `Err` when the search spent its + /// budget of visited components or queued references before finishing (the answer is unknown). + fn first_clip(&mut self, seg: u32) -> std::result::Result, SearchLimit> { + if let Some(found) = self.clip_search.get(&seg) { + return *found; } + let found = self.first_clip_within(seg, MAX_CLIP_SEARCH_VISITS, MAX_CLIP_SEARCH_PENDING); + self.clip_search.insert(seg, found); + found + } + + fn first_clip_within(&self, seg: u32, max_visits: usize, max_pending: usize) -> std::result::Result, SearchLimit> { + let mut visited = HashSet::new(); + let mut todo = vec![seg]; + let mut queued = 1usize; + while let Some(seg) = todo.pop() { + if !visited.insert(seg) { + continue; + } + if visited.len() > max_visits { + return Err(SearchLimit); + } + match &self.class(seg) { + b"SCLP" => return Ok(Some(seg)), + b"SEQU" => { + let comps = self.refs(seg, "OMFI:SEQU:Components"); + // sequences may share one component list, so queued references grow with expansions, not visits + queued = queued.saturating_add(comps.len()); + if queued > max_pending { + return Err(SearchLimit); + } + todo.extend(comps.into_iter().rev()); + } + _ => {} + } + } + Ok(None) } fn resolve(&mut self, id: Uid, track: u32, start: Tick, master: Option, depth: usize) -> Option<(usize, Tick)> { @@ -328,7 +411,13 @@ impl R<'_, '_> { match &self.class(mob) { b"MMOB" => { let key = master.unwrap_or_else(|| id.iter().map(|b| format!("{b:02x}")).collect()); - let clip = self.first_clip(seg)?; + let clip = match self.first_clip(seg) { + Ok(c) => c?, + Err(SearchLimit) => { + self.report.warn("a master mob is too large to search for its source clip (imported as a gap)"); + return None; + } + }; let inner = units_to_ticks(self.i32(clip, "OMFI:SCLP:StartTime").unwrap_or(0), rate.0, rate.1); let next = self.uid(clip, "OMFI:SCLP:SourceID")?; let next_track = self.u32(clip, "OMFI:SCLP:SourceTrackID")?; @@ -353,7 +442,9 @@ impl R<'_, '_> { let file_rate = sr.filter(|r| r.0 > 0 && r.1 > 0).unwrap_or(rate); let length = units_to_ticks(self.i32(desc, "OMFI:MDFL:Length").unwrap_or(0), file_rate.0, file_rate.1); let summary = self.c.get(desc, "OMFI:WAVD:Summary").or_else(|| self.c.get(desc, "OMFI:AIFD:Summary")).unwrap_or_default(); - let fmt = crate::pcm::parse_wav(&summary).or_else(|| crate::pcm::parse_aiff(&summary)).map(|(_, ch, sr, bits)| (ch as u32, sr, bits)); + let fmt = craft_audio::essence_pcm::parse_wav(&summary) + .or_else(|| craft_audio::essence_pcm::parse_aiff(&summary)) + .map(|(_, ch, sr, bits)| (ch as u32, sr, bits)); let mut path = None; for l in self.refs(desc, "OMFI:MDES:Locator") { let p = match &self.class(l) { @@ -373,7 +464,8 @@ impl R<'_, '_> { let (file_channels, sample_rate, bits) = fmt.unwrap_or((1, file_rate.0 as u32, 16)); let channel = (file_channels > 1 && sound_slots > 1).then(|| track.saturating_sub(1).min(file_channels - 1)); // timecode of the physical source - let tc = self.first_clip(seg).and_then(|clip| { + let first = self.first_clip(seg).ok().flatten(); + let tc = first.and_then(|clip| { let tid = self.uid(clip, "OMFI:SCLP:SourceID")?; let tape = *self.mobs.get(&tid)?; let (start_tc, fps, trate) = self.refs(tape, "OMFI:MOBJ:Slots").into_iter().find_map(|s| { @@ -415,7 +507,7 @@ impl R<'_, '_> { nested: None, }; if let Some(d) = self.media.get(&id) { - if let Some((pcm, ch, sr, b)) = crate::pcm::parse_wav(d).or_else(|| crate::pcm::parse_aiff(d)) { + if let Some((pcm, ch, sr, b)) = craft_audio::essence_pcm::parse_wav(d).or_else(|| craft_audio::essence_pcm::parse_aiff(d)) { s.embedded = Some(pcm); s.file_channels = ch as u32; s.channels = if s.channel.is_some() { 1 } else { ch as u32 }; @@ -437,3 +529,144 @@ impl R<'_, '_> { } } } + +#[cfg(test)] +mod tests { + use super::super::bento::Writer; + use super::*; + + fn obj(w: &mut Writer, class: &[u8; 4]) -> u32 { + let id = w.new_object(); + w.set(id, "OMFI:OOBJ:ObjClass", "omfi:ClassID", class); + id + } + fn list(w: &mut Writer, o: u32, p: &str, targets: &[u32]) { + let mut v = (targets.len() as u16).to_be_bytes().to_vec(); + for t in targets { + v.extend_from_slice(&t.to_be_bytes()); + } + w.set(o, p, "omfi:ObjRefArray", &v); + } + + fn search(max_visits: usize, max_pending: usize, build: impl FnOnce(&mut Writer) -> u32) -> std::result::Result, SearchLimit> { + let mut w = Writer::new(); + let root = build(&mut w); + let bytes = w.finish(); + let c = Container::open(&bytes).unwrap(); + let mut report = Report::default(); + let r = R { + c: &c, + report: &mut report, + be: true, + mobs: HashMap::new(), + media: HashMap::new(), + doc: Document::default(), + sources: HashMap::new(), + budget: 0, + clip_search: HashMap::new(), + }; + r.first_clip_within(root, max_visits, max_pending) + } + + #[test] + fn clip_search_reports_its_limits() { + // found within the limits + assert!(matches!( + search(10, 10, |w| { + let (s, c) = (obj(w, b"SEQU"), obj(w, b"SCLP")); + list(w, s, "OMFI:SEQU:Components", &[c]); + s + }), + Ok(Some(_)) + )); + // too many distinct components before any clip + assert!( + search(5, 1000, |w| { + let (s, f) = (obj(w, b"SEQU"), (0..20).map(|_| obj(w, b"FILL")).collect::>()); + list(w, s, "OMFI:SEQU:Components", &f); + s + }) + .is_err() + ); + // few visits, but sequences that each queue a long list of references + assert!( + search(1000, 500, |w| { + let f = obj(w, b"FILL"); + let inner: Vec = (0..20).map(|_| obj(w, b"SEQU")).collect(); + for &i in &inner { + list(w, i, "OMFI:SEQU:Components", &[f; 100]); + } + let s = obj(w, b"SEQU"); + list(w, s, "OMFI:SEQU:Components", &inner); + s + }) + .is_err() + ); + // a search that ends without a clip is not a limit + assert!(matches!(search(10, 10, |w| obj(w, b"FILL")), Ok(None))); + } + + #[test] + fn skipped_slots_spend_the_budget() { + let mut w = Writer::new(); + let head = obj(&mut w, b"HEAD"); + let cm = obj(&mut w, b"CMOB"); + let slot = obj(&mut w, b"MSLT"); + list(&mut w, cm, "OMFI:MOBJ:Slots", &[slot; 200]); + list(&mut w, head, "OMFI:HEAD:Mobs", &[cm]); + list(&mut w, head, "OMFI:HEAD:PrimaryMobs", &[cm]); + let bytes = w.finish(); + let mut report = Report::default(); + read_with_budget(&bytes, &mut report, 50).unwrap(); + assert!(report.mentions(BUDGET_WARNING), "slots with no segment cost nothing before"); + } + + #[test] + fn a_source_clip_search_is_made_once_per_segment() { + let mut w = Writer::new(); + let (s, c) = (obj(&mut w, b"SEQU"), obj(&mut w, b"SCLP")); + list(&mut w, s, "OMFI:SEQU:Components", &[c]); + let bytes = w.finish(); + let c = Container::open(&bytes).unwrap(); + let mut report = Report::default(); + let mut r = R { + c: &c, + report: &mut report, + be: true, + mobs: HashMap::new(), + media: HashMap::new(), + doc: Document::default(), + sources: HashMap::new(), + budget: 0, + clip_search: HashMap::new(), + }; + let first = r.first_clip(s).ok(); + assert!(matches!(first, Some(Some(_)))); + assert_eq!(r.clip_search.len(), 1); + assert_eq!(r.first_clip(s).ok(), first); + assert_eq!(r.clip_search.len(), 1); + } + + #[test] + fn repeated_slots_and_compositions_spend_the_budget() { + let mut w = Writer::new(); + let head = obj(&mut w, b"HEAD"); + let cm = obj(&mut w, b"CMOB"); + let dd = obj(&mut w, b"DDEF"); + w.set(dd, "OMFI:DDEF:DataKindID", "omfi:UniqueName", b"omfi:data:Sound\0"); + let fill = obj(&mut w, b"FILL"); + w.set(fill, "OMFI:CPNT:DataKind", "omfi:ObjRef", &dd.to_be_bytes()); + let slot = obj(&mut w, b"MSLT"); + w.set(slot, "OMFI:MSLT:Segment", "omfi:ObjRef", &fill.to_be_bytes()); + list(&mut w, cm, "OMFI:MOBJ:Slots", &[slot; 200]); + list(&mut w, head, "OMFI:HEAD:Mobs", &[cm]); + list(&mut w, head, "OMFI:HEAD:PrimaryMobs", &[cm; 200]); + let bytes = w.finish(); + let mut report = Report::default(); + let doc = read_with_budget(&bytes, &mut report, 50).unwrap(); + let tracks: usize = doc.compositions.iter().map(|c| c.tracks.len()).sum(); + assert!(tracks <= 50, "{tracks} tracks from a budget of 50"); + assert!(doc.compositions.len() <= 2, "{} compositions", doc.compositions.len()); + assert!(report.has_warnings()); + } +} diff --git a/crates/aaf/src/pcm.rs b/crates/aaf/src/pcm.rs index 789c976a8..9992b2d3b 100644 --- a/crates/aaf/src/pcm.rs +++ b/crates/aaf/src/pcm.rs @@ -4,8 +4,3 @@ pub(crate) fn parse_wav(b: &[u8]) -> Option<(Vec, u16, u32, u16)> { craft_audio::wav_pcm(b).map(|p| (p.data, p.channels, p.sample_rate, p.bits)) } - -/// The same for an AIFF / AIFF-C (`NONE`, `twos`, `sowt`) file. -pub(crate) fn parse_aiff(b: &[u8]) -> Option<(Vec, u16, u32, u16)> { - craft_audio::aiff_pcm(b).map(|p| (p.data, p.channels, p.sample_rate, p.bits)) -} From 52a6dd6aa7aadf7a57f715135ec1dcbc51088515 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:46:32 +0000 Subject: [PATCH 128/382] aaf: expose bounded Bento container access --- crates/aaf/src/omf.rs | 2 +- crates/aaf/src/omf/bento.rs | 25 ++++++++++++++++++------- crates/aaf/tests/bento_api.rs | 17 +++++++++++++++++ 3 files changed, 36 insertions(+), 8 deletions(-) create mode 100644 crates/aaf/tests/bento_api.rs diff --git a/crates/aaf/src/omf.rs b/crates/aaf/src/omf.rs index 57e0f756c..bbd2e8571 100644 --- a/crates/aaf/src/omf.rs +++ b/crates/aaf/src/omf.rs @@ -21,7 +21,7 @@ //! transition's name) are not in the specification; they were first written by FilmCraft and keep //! their names so that existing files read back. -pub(crate) mod bento; +pub mod bento; mod read; mod write; diff --git a/crates/aaf/src/omf/bento.rs b/crates/aaf/src/omf/bento.rs index 00a7e2a26..171196fe1 100644 --- a/crates/aaf/src/omf/bento.rs +++ b/crates/aaf/src/omf/bento.rs @@ -35,8 +35,8 @@ use std::collections::{BTreeMap, HashMap}; -pub(crate) const MAGIC: [u8; 8] = [0xA4, b'C', b'M', 0xA5, b'H', b'd', b'r', 0xD7]; -pub(crate) const LABEL_SIZE: usize = 24; +pub const MAGIC: [u8; 8] = [0xA4, b'C', b'M', 0xA5, b'H', b'd', b'r', 0xD7]; +pub const LABEL_SIZE: usize = 24; // standard object ids const TOC_OBJECT: u32 = 1; @@ -82,7 +82,7 @@ const MAX_VALUE_BYTES: usize = 16 << 20; const MAX_NAME_BYTES: usize = 4 << 20; /// Builds a Bento container. -pub(crate) struct Writer { +pub struct Writer { data: Vec, names: HashMap<(u32, String), u32>, next: u32, @@ -90,6 +90,12 @@ pub(crate) struct Writer { entries: Vec<(u32, u32, u32, Vec)>, } +impl Default for Writer { + fn default() -> Self { + Self::new() + } +} + impl Writer { pub fn new() -> Writer { Writer { data: Vec::new(), names: HashMap::new(), next: MIN_USER_ID, entries: Vec::new() } @@ -217,9 +223,9 @@ pub(crate) struct Prop { } /// A parsed Bento container. -pub(crate) struct Container<'a> { +pub struct Container<'a> { data: &'a [u8], - pub objects: BTreeMap>, + pub(crate) objects: BTreeMap>, names: HashMap, by_name: HashMap, } @@ -229,11 +235,16 @@ fn be32(b: &[u8], at: usize) -> Option { } /// Whether `b` ends with a Bento label. -pub(crate) fn sniff(b: &[u8]) -> bool { +pub fn sniff(b: &[u8]) -> bool { b.len() >= LABEL_SIZE && b[b.len() - LABEL_SIZE..b.len() - LABEL_SIZE + 8] == MAGIC } impl<'a> Container<'a> { + /// Object identifiers in ascending order. + pub fn object_ids(&self) -> impl Iterator + '_ { + self.objects.keys().copied() + } + pub fn open(data: &'a [u8]) -> Result, String> { if !sniff(data) { return Err("no Bento label at the end of the file".into()); @@ -324,7 +335,7 @@ impl<'a> Container<'a> { } /// The bytes of a value. - pub fn value(&self, p: &Prop) -> Result, String> { + pub(crate) fn value(&self, p: &Prop) -> Result, String> { let total = p.segs.iter().try_fold(0usize, |total, s| { let len = match s { Seg::Imm(b) => b.len(), diff --git a/crates/aaf/tests/bento_api.rs b/crates/aaf/tests/bento_api.rs new file mode 100644 index 000000000..9df70c661 --- /dev/null +++ b/crates/aaf/tests/bento_api.rs @@ -0,0 +1,17 @@ +use craft_aaf::omf::bento::{Container, Writer, sniff}; + +#[test] +fn external_consumer_reads_named_values_and_references() { + let mut writer = Writer::new(); + let first = writer.new_object(); + let second = writer.new_object(); + writer.set(first, "test:value", "test:type", b"long value"); + writer.set_references(first, &[second]); + let bytes = writer.finish(); + assert!(sniff(&bytes)); + let container = Container::open(&bytes).unwrap(); + assert!(container.object_ids().any(|id| id == first)); + assert_eq!(container.get(first, "test:value").as_deref(), Some(b"long value".as_slice())); + assert_eq!(container.resolve(first, second), second); + assert!(Container::open(&bytes[..bytes.len() - 1]).is_err()); +} From a88aab72c4620d1956196ec51107c3ca9c241a52 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:58:28 +0000 Subject: [PATCH 129/382] aaf: bound duplicate property detection work --- crates/aaf/src/aaf/hostile_tests.rs | 16 ++++++++++++++++ crates/aaf/src/aaf/store.rs | 4 +++- 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/crates/aaf/src/aaf/hostile_tests.rs b/crates/aaf/src/aaf/hostile_tests.rs index 853b0000c..527e50da8 100644 --- a/crates/aaf/src/aaf/hostile_tests.rs +++ b/crates/aaf/src/aaf/hostile_tests.rs @@ -108,3 +108,19 @@ fn objects_nested_too_deeply_are_an_error() { let e = store::read(&chain(250)).unwrap_err(); assert!(e.contains("nested too deeply"), "{e}"); } + +/// Many distinct property IDs still reject a duplicate without quadratic scanning. +#[test] +fn duplicate_after_many_distinct_properties_is_rejected() { + let mut props = vec![0x4C, 0x20]; + props.extend_from_slice(&8193u16.to_le_bytes()); + for id in (0..8192u16).chain(std::iter::once(7)) { + props.extend_from_slice(&id.to_le_bytes()); + props.extend_from_slice(&0x82u16.to_le_bytes()); + props.extend_from_slice(&0u16.to_le_bytes()); + } + let mut writer = Writer::new(Version::V3); + writer.stream(Writer::ROOT, "properties", props).unwrap(); + let e = store::read(&writer.finish()).unwrap_err(); + assert!(e.contains("duplicate property id"), "{e}"); +} diff --git a/crates/aaf/src/aaf/store.rs b/crates/aaf/src/aaf/store.rs index 69b14fcf2..859c0ea77 100644 --- a/crates/aaf/src/aaf/store.rs +++ b/crates/aaf/src/aaf/store.rs @@ -461,11 +461,13 @@ impl R<'_> { if at > props.len() { return Err(bad("truncated property index")); } + // A properties stream can name tens of thousands of ids: do not rescan all earlier ids. + let mut seen = std::collections::HashSet::with_capacity(n); for i in 0..n { let (Some(pid), Some(sf), Some(len)) = (rd_u16(&props, 4 + i * 6), rd_u16(&props, 6 + i * 6), rd_u16(&props, 8 + i * 6)) else { return Err(bad("truncated property index")); }; - if o.props.iter().any(|(previous, _)| *previous == pid) { + if !seen.insert(pid) { return Err(bad("duplicate property id")); } let v = props.get(at..at + len as usize).ok_or_else(|| bad("truncated property value"))?; From 6345459e1297ee85a7ca62b428a440691bd062c1 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:59:23 +0000 Subject: [PATCH 130/382] Share MTEXT Unicode and MIF escape decoding --- crates/dxf/src/lib.rs | 1 + crates/dxf/src/mtext.rs | 103 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+) create mode 100644 crates/dxf/src/mtext.rs diff --git a/crates/dxf/src/lib.rs b/crates/dxf/src/lib.rs index 4cf3e46e9..9c912613b 100644 --- a/crates/dxf/src/lib.rs +++ b/crates/dxf/src/lib.rs @@ -11,6 +11,7 @@ use std::io::Write as _; pub mod model; +pub mod mtext; pub mod paths; mod version; pub use version::Version; diff --git a/crates/dxf/src/mtext.rs b/crates/dxf/src/mtext.rs new file mode 100644 index 000000000..9b113aa6c --- /dev/null +++ b/crates/dxf/src/mtext.rs @@ -0,0 +1,103 @@ +//! MTEXT inline-escape handling independent of drawing and text layout. +//! +//! Unicode and MIF escapes are decoded to literal characters, with markup-significant +//! characters re-escaped so subsequent MTEXT parsers cannot treat them as commands. + +/// Whether an inline command takes an argument terminated by `;`. +pub fn takes_arg(code: char) -> bool { + matches!(code, 'f' | 'F' | 'H' | 'W' | 'Q' | 'T' | 'A' | 'C' | 'c' | 'p') +} + +/// Four hex digits at `chars[at..at + 4]`. +fn hex4(chars: &[char], at: usize) -> Option { + let digits = chars.get(at..at.checked_add(4)?)?; + digits.iter().try_fold(0u32, |acc, c| Some(acc * 16 + c.to_digit(16)?)) +} + +/// Push a decoded character so that the tokenizers read it as text, never as markup. +fn push_literal(out: &mut String, c: char) { + if matches!(c, '\\' | '{' | '}') { + out.push('\\'); + } + out.push(c); +} + +/// Decode `\U+hhhh` (one UTF-16 unit; a surrogate pair gives one character, a lone surrogate +/// U+FFFD) and `\M+nhhhh` (double-byte East Asian characters) to the characters they stand +/// for. Malformed escapes remain unchanged for the caller to interpret. +/// An escaped backslash (`\\U+0041`) is not an escape. +pub fn unescape_codes(s: &str) -> std::borrow::Cow<'_, str> { + if !s.contains("\\U+") && !s.contains("\\M+") { + return std::borrow::Cow::Borrowed(s); + } + let chars: Vec = s.chars().collect(); + let mut out = String::with_capacity(s.len()); + let mut i = 0; + while let Some(&c) = chars.get(i) { + if c != '\\' { + out.push(c); + i += 1; + continue; + } + let (n, plus) = (chars.get(i + 1).copied(), chars.get(i + 2).copied()); + if n == Some('U') && plus == Some('+') { + if let Some(unit) = hex4(&chars, i + 3) { + i += 7; + let low = |at: usize| { + (chars.get(at) == Some(&'\\') && chars.get(at + 1) == Some(&'U') && chars.get(at + 2) == Some(&'+')) + .then(|| hex4(&chars, at + 3)) + .flatten() + .filter(|u| (0xDC00..0xE000).contains(u)) + }; + let ch = if (0xD800..0xDC00).contains(&unit) { + match low(i) { + Some(lo) => { + i += 7; + char::from_u32(0x10000 + ((unit - 0xD800) << 10) + (lo - 0xDC00)) + } + None => None, + } + } else { + char::from_u32(unit) + }; + push_literal(&mut out, ch.unwrap_or('\u{fffd}')); + continue; + } + } else if n == Some('M') && plus == Some('+') && chars.get(i + 3).is_some_and(char::is_ascii_digit) && hex4(&chars, i + 4).is_some() { + push_literal(&mut out, crate::mif_escape_at(&chars, i).unwrap_or('\u{fffd}')); + i += 8; + continue; + } + // Any other backslash pair stays as it is (and an escaped backslash stays one). + out.push('\\'); + i += 1; + if let Some(&next) = chars.get(i) { + out.push(next); + i += 1; + } + } + std::borrow::Cow::Owned(out) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn unicode_and_mif_escapes_remain_literal_markup() { + assert_eq!(unescape_codes(r"a\U+0041\U+D83D\U+DE00"), "aA😀"); + assert_eq!(unescape_codes(r"\M+5BCFE"), "件"); + assert_eq!(unescape_codes(r"\U+005C\U+007B\U+007D"), r"\\\{\}"); + assert_eq!(unescape_codes(r"\\U+0041"), r"\\U+0041"); + assert_eq!(unescape_codes(r"\U+12"), r"\U+12"); + assert_eq!(unescape_codes(r"\U+D800"), "�"); + } + #[test] + fn parameterized_commands_are_classified_without_relaxing_others() { + for c in "fFHWQTACcp".chars() { + assert!(takes_arg(c)); + } + for c in ['S', 'P', 'Z', '\\'] { + assert!(!takes_arg(c)); + } + } +} From 99e448d9199191e86a7dddc6b39a5a1e29aad24c Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 15:58:28 +0000 Subject: [PATCH 131/382] aaf: bound duplicate property detection work --- crates/aaf/src/aaf/hostile_tests.rs | 16 ++++++++++++++++ crates/aaf/src/aaf/store.rs | 4 +++- 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/crates/aaf/src/aaf/hostile_tests.rs b/crates/aaf/src/aaf/hostile_tests.rs index 853b0000c..527e50da8 100644 --- a/crates/aaf/src/aaf/hostile_tests.rs +++ b/crates/aaf/src/aaf/hostile_tests.rs @@ -108,3 +108,19 @@ fn objects_nested_too_deeply_are_an_error() { let e = store::read(&chain(250)).unwrap_err(); assert!(e.contains("nested too deeply"), "{e}"); } + +/// Many distinct property IDs still reject a duplicate without quadratic scanning. +#[test] +fn duplicate_after_many_distinct_properties_is_rejected() { + let mut props = vec![0x4C, 0x20]; + props.extend_from_slice(&8193u16.to_le_bytes()); + for id in (0..8192u16).chain(std::iter::once(7)) { + props.extend_from_slice(&id.to_le_bytes()); + props.extend_from_slice(&0x82u16.to_le_bytes()); + props.extend_from_slice(&0u16.to_le_bytes()); + } + let mut writer = Writer::new(Version::V3); + writer.stream(Writer::ROOT, "properties", props).unwrap(); + let e = store::read(&writer.finish()).unwrap_err(); + assert!(e.contains("duplicate property id"), "{e}"); +} diff --git a/crates/aaf/src/aaf/store.rs b/crates/aaf/src/aaf/store.rs index 69b14fcf2..859c0ea77 100644 --- a/crates/aaf/src/aaf/store.rs +++ b/crates/aaf/src/aaf/store.rs @@ -461,11 +461,13 @@ impl R<'_> { if at > props.len() { return Err(bad("truncated property index")); } + // A properties stream can name tens of thousands of ids: do not rescan all earlier ids. + let mut seen = std::collections::HashSet::with_capacity(n); for i in 0..n { let (Some(pid), Some(sf), Some(len)) = (rd_u16(&props, 4 + i * 6), rd_u16(&props, 6 + i * 6), rd_u16(&props, 8 + i * 6)) else { return Err(bad("truncated property index")); }; - if o.props.iter().any(|(previous, _)| *previous == pid) { + if !seen.insert(pid) { return Err(bad("duplicate property id")); } let v = props.get(at..at + len as usize).ok_or_else(|| bad("truncated property value"))?; From f751827790237ed116980c3f981f2e2b72d788a1 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:01:42 +0000 Subject: [PATCH 132/382] audio: share streaming PCM export encoding --- crates/audio/src/lib.rs | 3 + crates/audio/src/pcm_export.rs | 264 +++++++++++++++++++++++++++++++++ 2 files changed, 267 insertions(+) create mode 100644 crates/audio/src/pcm_export.rs diff --git a/crates/audio/src/lib.rs b/crates/audio/src/lib.rs index 33dcdee3b..4a5f352d1 100644 --- a/crates/audio/src/lib.rs +++ b/crates/audio/src/lib.rs @@ -66,6 +66,9 @@ mod wav; feature = "vorbis-encode" ))] mod write; + +/// Streaming WAVE and AIFF headers and sample packing. +pub mod pcm_export; #[cfg(feature = "vorbis-encode")] pub use write::{OGG_BITRATES, encode_ogg}; diff --git a/crates/audio/src/pcm_export.rs b/crates/audio/src/pcm_export.rs new file mode 100644 index 000000000..c8456d785 --- /dev/null +++ b/crates/audio/src/pcm_export.rs @@ -0,0 +1,264 @@ +//! Audio-only files: WAV (RIFF, little-endian PCM; RF64 past 4 GiB) and AIFF (big-endian PCM), +//! 16, 24 or 32-bit integer or 32-bit float ([`SampleFormat`]), for streaming export. +//! Float WAV is `WAVE_FORMAT_IEEE_FLOAT` with a `fact` chunk; float AIFF is AIFF-C (`fl32`). +//! +//! The header is written first from the known length ([`header`]), then the samples in chunks +//! ([`encode`]) and the pad byte ([`pad`]), so an export streams to disk instead of building the +//! file in memory. + +/// PCM representation in an exported file. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SampleFormat { + /// 16-bit signed integer. + Int16, + /// 24-bit signed integer. + Int24, + /// 32-bit signed integer. + Int32, + /// 32-bit IEEE float. + Float32, +} + +impl SampleFormat { + /// Bits per sample. + pub fn bits(self) -> u16 { + match self { + Self::Int16 => 16, + Self::Int24 => 24, + Self::Int32 | Self::Float32 => 32, + } + } + /// Bytes per sample. + pub fn bytes(self) -> usize { + usize::from(self.bits() / 8) + } + /// Whether this is a floating point format. + pub fn is_float(self) -> bool { + self == Self::Float32 + } + /// Clip and quantize one sample with symmetric integer full scale; NaN becomes silence. + pub fn quantise(self, s: f32) -> i32 { + let s = s.clamp(-1.0, 1.0); + match self { + Self::Int16 => (s * 32_767.0).round() as i32, + Self::Int24 => (s * 8_388_607.0).round() as i32, + Self::Int32 => (f64::from(s) * 2_147_483_647.0).round() as i32, + Self::Float32 => 0, + } + } + /// Sanitize a floating sample: NaN becomes silence, infinity becomes the largest finite value. + pub fn float(s: f32) -> f32 { + if s.is_nan() { 0.0 } else { s.clamp(f32::MIN, f32::MAX) } + } +} + +/// The container of an audio-only export. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum PcmContainer { + /// RIFF/WAVE or RF64. + Wav, + /// AIFF or AIFF-C. + Aiff, +} + +/// Bytes of sample data for `frames` frames, or None when that does not fit 64 bits. +fn data_len(frames: u64, channels: u16, format: SampleFormat) -> Option { + frames.checked_mul(u64::from(channels))?.checked_mul(format.bytes() as u64) +} + +/// The pad byte after an odd-sized data chunk (RIFF and AIFF chunks are word-aligned). +pub fn pad(frames: u64, channels: u16, format: SampleFormat) -> &'static [u8] { + if data_len(frames, channels, format).is_some_and(|n| n & 1 == 1) { &[0] } else { &[] } +} + +/// `KSDATAFORMAT_SUBTYPE_PCM` / `_IEEE_FLOAT` after their first two bytes (the format tag). +const SUBTYPE_TAIL: [u8; 14] = [0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71]; + +/// AIFF-C format version 1 (`FVER`). +const AIFC_VERSION_1: u32 = 0xA280_5140; + +/// The AIFF-C compression name of `fl32`, as a Pascal string of even length. +const FL32_NAME: &[u8] = b"\x1532-bit floating point"; + +/// Everything before the samples of a file of `frames` frames. A WAV whose RIFF size would not +/// fit 32 bits (4 GiB: 24-bit 5.1 at 96 kHz after about 41 minutes) is written as RF64 (EBU Tech +/// 3306), with the 64-bit sizes in a `ds64` chunk. AIFF has no 64-bit form, so a longer AIFF is +/// an error naming WAV instead. +pub fn header(container: PcmContainer, channels: u16, sample_rate: u32, format: SampleFormat, frames: u64) -> Result, String> { + let too_long = || "the audio is too long to write".to_string(); + let bits = format.bits(); + let bps = bits / 8; + let float = format.is_float(); + let data = data_len(frames, channels, format).ok_or_else(too_long)?; + let block_align = channels.checked_mul(bps).ok_or("too many audio channels")?; + match container { + PcmContainer::Wav => { + let byte_rate = + u32::try_from(u64::from(sample_rate) * u64::from(block_align)).map_err(|_| "the audio sample rate is too high".to_string())?; + let ext = channels > 2; + // plain PCM has no cbSize; IEEE float has an empty one + let fmt_len: u32 = if ext { + 40 + } else if float { + 18 + } else { + 16 + }; + // every format but integer PCM has a `fact` chunk (the frame count; RF64: in `ds64`) + let fact_len: u64 = if float { 12 } else { 0 }; + let padded = data.checked_add(data & 1).ok_or_else(too_long)?; + // "WAVE" + fmt chunk + fact chunk + data chunk header + samples + let riff = (4 + 8 + u64::from(fmt_len) + fact_len + 8).checked_add(padded).ok_or_else(too_long)?; + let rf64 = riff > u64::from(u32::MAX); + let mut v = Vec::with_capacity(100); + if rf64 { + const DS64: u64 = 8 + 28; + v.extend_from_slice(b"RF64"); + v.extend_from_slice(&u32::MAX.to_le_bytes()); + v.extend_from_slice(b"WAVEds64"); + v.extend_from_slice(&28u32.to_le_bytes()); + v.extend_from_slice(&riff.checked_add(DS64).ok_or_else(too_long)?.to_le_bytes()); + v.extend_from_slice(&data.to_le_bytes()); + v.extend_from_slice(&frames.to_le_bytes()); + v.extend_from_slice(&0u32.to_le_bytes()); // no table entries + } else { + v.extend_from_slice(b"RIFF"); + v.extend_from_slice(&(riff as u32).to_le_bytes()); + v.extend_from_slice(b"WAVE"); + } + let tag: u16 = if float { 3 } else { 1 }; + v.extend_from_slice(b"fmt "); + v.extend_from_slice(&fmt_len.to_le_bytes()); + v.extend_from_slice(&(if ext { 0xFFFE } else { tag }).to_le_bytes()); + v.extend_from_slice(&channels.to_le_bytes()); + v.extend_from_slice(&sample_rate.to_le_bytes()); + v.extend_from_slice(&byte_rate.to_le_bytes()); + v.extend_from_slice(&block_align.to_le_bytes()); + v.extend_from_slice(&bits.to_le_bytes()); + if ext { + // cbSize, valid bits, channel mask, KSDATAFORMAT_SUBTYPE_PCM / _IEEE_FLOAT + v.extend_from_slice(&22u16.to_le_bytes()); + v.extend_from_slice(&bits.to_le_bytes()); + let mask: u32 = if channels == 6 { 0x3F } else { 0 }; + v.extend_from_slice(&mask.to_le_bytes()); + v.extend_from_slice(&tag.to_le_bytes()); + v.extend_from_slice(&SUBTYPE_TAIL); + } else if float { + v.extend_from_slice(&0u16.to_le_bytes()); + } + if float { + v.extend_from_slice(b"fact"); + v.extend_from_slice(&4u32.to_le_bytes()); + v.extend_from_slice(&(if rf64 { u32::MAX } else { u32::try_from(frames).unwrap_or(u32::MAX) }).to_le_bytes()); + } + v.extend_from_slice(b"data"); + v.extend_from_slice(&(if rf64 { u32::MAX } else { data as u32 }).to_le_bytes()); + Ok(v) + } + PcmContainer::Aiff => { + let aiff_too_long = || "AIFF holds at most 4 GB of audio: export WAV, which has no such limit".to_string(); + let frames32 = u32::try_from(frames).map_err(|_| aiff_too_long())?; + // SSND: offset + block size + samples + let ssnd = u32::try_from(data.checked_add(8).ok_or_else(aiff_too_long)?).map_err(|_| aiff_too_long())?; + // floats need AIFF-C: a version chunk, and the compression type and name in COMM + let comm: u32 = if float { 18 + 4 + FL32_NAME.len() as u32 } else { 18 }; + let fver: u32 = if float { 8 + 4 } else { 0 }; + let form = (4u32 + fver + (8 + comm)) + .checked_add(8) + .and_then(|n| n.checked_add(ssnd)) + .and_then(|n| n.checked_add(ssnd & 1)) + .ok_or_else(aiff_too_long)?; + let mut v = Vec::with_capacity(90); + v.extend_from_slice(b"FORM"); + v.extend_from_slice(&form.to_be_bytes()); + if float { + v.extend_from_slice(b"AIFCFVER"); + v.extend_from_slice(&4u32.to_be_bytes()); + v.extend_from_slice(&AIFC_VERSION_1.to_be_bytes()); + } else { + v.extend_from_slice(b"AIFF"); + } + v.extend_from_slice(b"COMM"); + v.extend_from_slice(&comm.to_be_bytes()); + v.extend_from_slice(&channels.to_be_bytes()); + v.extend_from_slice(&frames32.to_be_bytes()); + v.extend_from_slice(&bits.to_be_bytes()); + v.extend_from_slice(&extended(sample_rate)); + if float { + v.extend_from_slice(b"fl32"); + v.extend_from_slice(FL32_NAME); + } + v.extend_from_slice(b"SSND"); + v.extend_from_slice(&ssnd.to_be_bytes()); + v.extend_from_slice(&0u32.to_be_bytes()); // offset + v.extend_from_slice(&0u32.to_be_bytes()); // block size + Ok(v) + } + } +} + +/// Append interleaved samples in `format` (little-endian for WAV, big-endian for AIFF). +pub fn encode(container: PcmContainer, interleaved: &[f32], format: SampleFormat, out: &mut Vec) { + let bps = format.bytes(); + out.reserve(interleaved.len().saturating_mul(bps)); + for &s in interleaved { + let q = if format.is_float() { SampleFormat::float(s).to_bits() as i32 } else { format.quantise(s) }; + match container { + PcmContainer::Wav => out.extend_from_slice(q.to_le_bytes().get(..bps).unwrap_or_default()), + PcmContainer::Aiff => out.extend_from_slice(q.to_be_bytes().get(4 - bps..).unwrap_or_default()), + } + } +} + +/// A whole file in memory (short audio; exports stream with [`header`] and [`encode`]). +fn write_whole(container: PcmContainer, interleaved: &[f32], channels: u16, sample_rate: u32, format: SampleFormat) -> Result, String> { + let frames = (interleaved.len() / usize::from(channels.max(1))) as u64; + let mut v = header(container, channels, sample_rate, format, frames)?; + encode(container, interleaved, format, &mut v); + v.extend_from_slice(pad(frames, channels, format)); + Ok(v) +} + +/// A RIFF/WAVE file of interleaved samples. More than two channels are written as +/// `WAVE_FORMAT_EXTENSIBLE` with the speaker mask of the layout (6 channels: L, R, C, LFE, Ls, Rs +/// = `0x3F`). +pub fn write_wav(interleaved: &[f32], channels: u16, sample_rate: u32, format: SampleFormat) -> Result, String> { + write_whole(PcmContainer::Wav, interleaved, channels, sample_rate, format) +} + +/// IEEE 754 80-bit extended encoding of a sample rate (AIFF `COMM`). +pub fn extended(rate: u32) -> [u8; 10] { + let mut out = [0u8; 10]; + if rate == 0 { + return out; + } + let shift = rate.leading_zeros(); + let mant = (rate as u64) << (32 + shift); + let exp = 16383 + 31 - shift as u16; + out[..2].copy_from_slice(&exp.to_be_bytes()); + out[2..].copy_from_slice(&mant.to_be_bytes()); + out +} + +/// An AIFF file (`FORM`/`AIFF`, `COMM` + `SSND`; AIFF-C for floats) of interleaved samples. +pub fn write_aiff(interleaved: &[f32], channels: u16, sample_rate: u32, format: SampleFormat) -> Result, String> { + write_whole(PcmContainer::Aiff, interleaved, channels, sample_rate, format) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn streaming_formats_preserve_samples_and_bounds() { + let samples = [1.0, -1.0, f32::NAN]; + let wav = write_wav(&samples, 1, 48_000, SampleFormat::Int24).unwrap(); + assert_eq!(&wav[..4], b"RIFF"); + assert_eq!(&wav[44..53], &[255, 255, 127, 1, 0, 128, 0, 0, 0]); + let h = header(PcmContainer::Wav, 6, 96_000, SampleFormat::Int24, 96_000 * 3600).unwrap(); + assert_eq!(&h[..4], b"RF64"); + assert!(header(PcmContainer::Aiff, 2, 48_000, SampleFormat::Int24, u64::MAX).is_err()); + let aiff = write_aiff(&[0.25, -3.0], 1, 44_100, SampleFormat::Float32).unwrap(); + assert_eq!(&aiff[8..12], b"AIFC"); + assert_eq!(&aiff[aiff.len() - 8..], [0.25f32.to_be_bytes(), (-3.0f32).to_be_bytes()].concat()); + } +} From b1d4c67196ee7c6b668428c8d211e7d5171dff88 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:02:52 +0000 Subject: [PATCH 133/382] Add streaming MTEXT lexical tokens --- crates/dxf/src/lib.rs | 1 + crates/dxf/src/mtext_tokens.rs | 132 +++++++++++++++++++++++++++++++++ 2 files changed, 133 insertions(+) create mode 100644 crates/dxf/src/mtext_tokens.rs diff --git a/crates/dxf/src/lib.rs b/crates/dxf/src/lib.rs index 9c912613b..7543fb28b 100644 --- a/crates/dxf/src/lib.rs +++ b/crates/dxf/src/lib.rs @@ -12,6 +12,7 @@ use std::io::Write as _; pub mod model; pub mod mtext; +pub mod mtext_tokens; pub mod paths; mod version; pub use version::Version; diff --git a/crates/dxf/src/mtext_tokens.rs b/crates/dxf/src/mtext_tokens.rs new file mode 100644 index 000000000..b07a9c2e0 --- /dev/null +++ b/crates/dxf/src/mtext_tokens.rs @@ -0,0 +1,132 @@ +//! Streaming lexical tokens for MTEXT inline markup. +//! +//! Apply [`crate::mtext::unescape_codes`] first when Unicode/MIF escapes should become literal +//! characters. Tokens borrow their source and scanning allocates no memory. The consumer owns +//! formatting, line layout, paragraph policy and how unknown commands are displayed. + +/// How a stacked-text argument finds its closing semicolon. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum StackMode { + /// The first semicolon ends the stack, as plain-text extraction historically did. + Plain, + /// A backslash quotes the next character, as the structured layout parser does. + Structured, +} +/// One lexical unit. Unknown commands retain their letter so the caller chooses compatibility. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Token<'a> { + Char(char), + OpenGroup, + CloseGroup, + Control(char), + Argument(char, &'a str), + Stack(&'a str), + Unknown(char), +} +/// A bounded-memory walk of UTF-8 MTEXT markup. +pub struct Tokens<'a> { + source: &'a str, + offset: usize, + stack_mode: StackMode, +} +impl<'a> Tokens<'a> { + pub fn new(source: &'a str, stack_mode: StackMode) -> Self { + Self { source, offset: 0, stack_mode } + } + fn next_char(&mut self) -> Option { + let c = self.source.get(self.offset..)?.chars().next()?; + self.offset += c.len_utf8(); + Some(c) + } + fn argument(&mut self, structured: bool) -> &'a str { + let start = self.offset; + let mut end = start; + while let Some(c) = self.next_char() { + if c == ';' { + return self.source.get(start..end).unwrap_or_default(); + } + if structured && c == '\\' { + let _ = self.next_char(); + } + end = self.offset; + } + self.source.get(start..end).unwrap_or_default() + } +} +impl<'a> Iterator for Tokens<'a> { + type Item = Token<'a>; + fn next(&mut self) -> Option { + let c = self.next_char()?; + Some(match c { + '{' => Token::OpenGroup, + '}' => Token::CloseGroup, + '\\' => { + let code = self.next_char()?; + match code { + 'S' => Token::Stack(self.argument(self.stack_mode == StackMode::Structured)), + c if crate::mtext::takes_arg(c) => Token::Argument(c, self.argument(false)), + c @ ('P' | 'N' | '~' | '\\' | '{' | '}' | 'L' | 'l' | 'O' | 'o' | 'K' | 'k') => Token::Control(c), + c => Token::Unknown(c), + } + } + c => Token::Char(c), + }) + } +} +/// Split a structured stack into top, bottom and separator, unquoting escaped characters. +pub fn split_stack(raw: &str) -> (String, String, Option) { + let (mut top, mut bottom, mut separator) = (String::new(), String::new(), None); + let mut chars = raw.chars(); + while let Some(c) = chars.next() { + if c == '\\' { + if let Some(c) = chars.next() { + if separator.is_none() { + top.push(c); + } else { + bottom.push(c); + } + } + } else if separator.is_none() && matches!(c, '/' | '#' | '^') { + separator = Some(c); + } else if separator.is_none() { + top.push(c); + } else { + bottom.push(c); + } + } + (top, bottom, separator) +} +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn tokens_borrow_text_and_preserve_unknown_commands() { + let got: Vec<_> = Tokens::new(r"A\Z\P{\H2x;x}\S1/2;", StackMode::Structured).collect(); + assert_eq!( + got, + [ + Token::Char('A'), + Token::Unknown('Z'), + Token::Control('P'), + Token::OpenGroup, + Token::Argument('H', "2x"), + Token::Char('x'), + Token::CloseGroup, + Token::Stack("1/2") + ] + ); + assert_eq!(split_stack("1/2"), ("1".into(), "2".into(), Some('/'))); + } + #[test] + fn stacked_text_uses_the_requested_terminator_rules() { + let text = r"\Sa\;b/c;X"; + assert_eq!(Tokens::new(text, StackMode::Plain).next(), Some(Token::Stack(r"a\"))); + assert_eq!(Tokens::new(text, StackMode::Structured).next(), Some(Token::Stack(r"a\;b/c"))); + assert_eq!(split_stack(r"a\;b/c"), ("a;b".into(), "c".into(), Some('/'))); + } + #[test] + fn missing_terminator_and_trailing_backslash_are_bounded() { + assert_eq!(Tokens::new("\\H2x", StackMode::Structured).collect::>(), [Token::Argument('H', "2x")]); + assert_eq!(Tokens::new("a\\", StackMode::Structured).collect::>(), [Token::Char('a')]); + } +} From 6b82b6a77c995847084311402d27a6361b6491ed Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:05:22 +0000 Subject: [PATCH 134/382] aaf: support legacy reference and locator conventions --- crates/aaf/src/aaf.rs | 47 +++++++++++++++++++++++++++++++++++-- crates/aaf/src/aaf/read.rs | 32 +++++++++++++++++++------ crates/aaf/src/aaf/tests.rs | 29 +++++++++++++++++++++++ crates/aaf/src/aaf/write.rs | 18 ++++++++++---- 4 files changed, 113 insertions(+), 13 deletions(-) diff --git a/crates/aaf/src/aaf.rs b/crates/aaf/src/aaf.rs index 05894f94e..efa618fb3 100644 --- a/crates/aaf/src/aaf.rs +++ b/crates/aaf/src/aaf.rs @@ -57,13 +57,56 @@ pub struct WriteOptions<'a> { /// reported. pub fn write(doc: &Document, opts: &WriteOptions<'_>, report: &mut Report) -> Result> { let version = if opts.small_sectors { craft_cfb::Version::V3 } else { craft_cfb::Version::V4 }; - write::write(doc, version, &opts.identity, report) + write::write(doc, version, &opts.identity, &ReferenceOptions::default(), report) +} + +/// Optional interpretation choices for applications retaining older interchange behavior. +#[derive(Clone, Copy, Debug)] +pub struct ReadOptions { + /// Interpret a source clip's start using its target slot's edit rate. + pub source_slot_rate: bool, + /// Use the referenced mob name when the clip has no explicit name. + pub infer_clip_name: bool, + /// Decode percent escapes in relative network locators. + pub decode_relative_locator: bool, + /// Report selector and nested-scope flattening. + pub report_flattening: bool, + /// Accept truncated PCM WAVE essence summaries. + pub permissive_pcm: bool, +} +impl Default for ReadOptions { + fn default() -> Self { + Self { source_slot_rate: true, infer_clip_name: true, decode_relative_locator: true, report_flattening: true, permissive_pcm: false } + } +} +/// Read using explicitly selected interpretation choices. +pub fn read_with_options(bytes: &[u8], options: &ReadOptions, report: &mut Report) -> Result { + read::read(bytes, options, report) +} + +/// Optional compatibility choices for writing source references and locators. +#[derive(Clone, Copy, Debug)] +pub struct ReferenceOptions { + /// Write source offsets in target-slot units. + pub source_slot_rate: bool, + /// Percent-encode relative locators. + pub encode_relative_locator: bool, +} +impl Default for ReferenceOptions { + fn default() -> Self { + Self { source_slot_rate: true, encode_relative_locator: true } + } +} +/// Write with explicitly selected reference and locator conventions. +pub fn write_with_references(doc: &Document, opts: &WriteOptions<'_>, references: &ReferenceOptions, report: &mut Report) -> Result> { + let version = if opts.small_sectors { craft_cfb::Version::V3 } else { craft_cfb::Version::V4 }; + write::write(doc, version, &opts.identity, references, report) } /// Read an AAF file: its top-level compositions, the compositions nested in them and their /// sources. What cannot be represented is skipped and named in `report`. pub fn read(bytes: &[u8], report: &mut Report) -> Result { - read::read(bytes, report) + read::read(bytes, &ReadOptions::default(), report) } /// Whether `bytes` look like an AAF file (a compound file whose root has the AAF root class or a diff --git a/crates/aaf/src/aaf/read.rs b/crates/aaf/src/aaf/read.rs index 31c841c5d..9739f87ba 100644 --- a/crates/aaf/src/aaf/read.rs +++ b/crates/aaf/src/aaf/read.rs @@ -67,6 +67,7 @@ fn indirect_f64(d: &[u8]) -> Option { struct R<'a> { report: &'a mut Report, + options: super::ReadOptions, mobs: HashMap, essence: HashMap, doc: Document, @@ -90,7 +91,7 @@ struct NestClip<'a> { /// Compositions nested deeper than this are read as gaps. const MAX_NESTING: usize = 16; -pub(crate) fn read(bytes: &[u8], report: &mut Report) -> Result { +pub(crate) fn read(bytes: &[u8], options: &super::ReadOptions, report: &mut Report) -> Result { let root = store::read(bytes).map_err(|e| Error::Parse { format: "AAF", message: e })?; let header = root.strong(pid::ROOT_HEADER).ok_or_else(|| Error::Parse { format: "AAF", message: "no header object".into() })?; let content = header.strong(pid::CONTENT).ok_or_else(|| Error::Parse { format: "AAF", message: "no content storage".into() })?; @@ -106,7 +107,8 @@ pub(crate) fn read(bytes: &[u8], report: &mut Report) -> Result { essence.insert(id, d); } } - let mut r = R { report, mobs, essence, doc: Document::default(), sources: HashMap::new(), nests: HashMap::new(), open: Vec::new() }; + let mut r = + R { report, options: *options, mobs, essence, doc: Document::default(), sources: HashMap::new(), nests: HashMap::new(), open: Vec::new() }; // Top-level compositions: those no other composition uses, among the ones tagged top-level // when any are. (Premiere Pro tags a nested sequence's composition top-level too; it is still // only a nested sequence.) Compositions that only use each other in a circle all count. The @@ -331,7 +333,9 @@ impl R<'_> { items } x if x == cls::SELECTOR => { - self.report.info("a selector was flattened to its selected input"); + if self.options.report_flattening { + self.report.info("a selector was flattened to its selected input"); + } match c.strong(pid::SELECTED) { Some(s) => { let mut items = self.segment(s, rate, kind, depth); @@ -342,7 +346,9 @@ impl R<'_> { } } x if x == cls::NESTED_SCOPE => { - self.report.info("a nested scope was flattened to its final input"); + if self.options.report_flattening { + self.report.info("a nested scope was flattened to its final input"); + } match c.objs(pid::NESTED_SLOTS).last() { Some(s) => { let mut items = self.segment(s, rate, kind, depth); @@ -388,7 +394,12 @@ impl R<'_> { let len = units_to_ticks(len_of(c), rate.0, rate.1); let tagged_name = tagged_values(c, pid::COMPONENT_USER_COMMENTS).into_iter().find(|(k, _)| k == "Clip Name").map(|(_, v)| v); let (Some(id), Some(slot)) = (c.mob_id(pid::SOURCE_ID), c.u32(pid::SOURCE_MOB_SLOT_ID)) else { return CItem::Filler(len) }; - let name = tagged_name.or_else(|| self.mobs.get(&id).and_then(|mob| mob.string(pid::MOB_NAME))).unwrap_or_default(); + let name = if self.options.infer_clip_name { + tagged_name.or_else(|| self.mobs.get(&id).and_then(|mob| mob.string(pid::MOB_NAME))) + } else { + tagged_name + } + .unwrap_or_default(); if id == [0; 32] { return CItem::Filler(len); } @@ -401,6 +412,7 @@ impl R<'_> { .and_then(|mob| mob.objs(pid::SLOTS).iter().find(|s| s.u32(pid::SLOT_ID) == Some(slot))) .and_then(|s| rate_of(s, pid::EDIT_RATE)) .unwrap_or(rate); + let source_rate = if self.options.source_slot_rate { source_rate } else { rate }; let start = units_to_ticks(c.i64(pid::START_TIME).unwrap_or(0), source_rate.0, source_rate.1); match self.resolve(id, slot, start, kind, master_key, 0) { Some((source, t)) => CItem::Clip(CClip { len, source, start: t, gain: None, name }), @@ -506,6 +518,7 @@ impl R<'_> { .and_then(|m| m.objs(pid::SLOTS).iter().find(|s| s.u32(pid::SLOT_ID) == Some(next_slot))) .and_then(|s| rate_of(s, pid::EDIT_RATE)) .unwrap_or(rate); + let source_rate = if self.options.source_slot_rate { source_rate } else { rate }; let inner = units_to_ticks(clip.i64(pid::START_TIME).unwrap_or(0), source_rate.0, source_rate.1); if next == [0; 32] { return None; @@ -545,7 +558,11 @@ impl R<'_> { DataKind::Sound => CKind::Sound, _ => kind, }; - let path = d.objs(pid::LOCATOR).iter().find_map(|l| l.string(pid::URL_STRING)).map(|u| locator_path(&u)); + let path = d + .objs(pid::LOCATOR) + .iter() + .find_map(|l| l.string(pid::URL_STRING)) + .map(|u| if self.options.decode_relative_locator { locator_path(&u) } else { craft_timeline::path::file_url_to_path(&u) }); let file_rate = rate_of(d, pid::SAMPLE_RATE).unwrap_or(rate); let length = d .i64(pid::FILE_LENGTH) @@ -604,7 +621,8 @@ impl R<'_> { if let Some(data) = self.essence.get(&id) { s.embedded = Some(data.to_vec()); // embedded essence may be a whole WAVE / AIFF file - if let Some((pcm, ch, sr, bits)) = crate::pcm::parse_wav(data) { + let pcm = if self.options.permissive_pcm { craft_audio::essence_pcm::parse_wav(data) } else { crate::pcm::parse_wav(data) }; + if let Some((pcm, ch, sr, bits)) = pcm { s.embedded = Some(pcm); s.file_channels = ch as u32; s.channels = if s.channel.is_some() { 1 } else { ch as u32 }; diff --git a/crates/aaf/src/aaf/tests.rs b/crates/aaf/src/aaf/tests.rs index 3e7794471..34eb2bbb3 100644 --- a/crates/aaf/src/aaf/tests.rs +++ b/crates/aaf/src/aaf/tests.rs @@ -557,3 +557,32 @@ fn relative_media_locator_round_trips_escaped_characters() { let got = read_clean(&bytes); assert!(got.sources.iter().any(|s| s.path.as_deref() == Some("Audio Files/100%20 #1.wav"))); } + +#[test] +fn compatibility_options_keep_relative_paths_and_parent_rate() { + let mut doc = crate::testdoc::sound_only(None); + doc.compositions[0].sample_rate = 44_100; + doc.sources[0].path = Some("Audio Files/100%20 #1.wav".into()); + let mut report = Report::default(); + let references = ReferenceOptions { source_slot_rate: false, encode_relative_locator: false }; + let bytes = write_with_references(&doc, &WriteOptions { identity: IDENTITY, small_sectors: false }, &references, &mut report).unwrap(); + let root = store::read(&bytes).unwrap(); + let mut all = Vec::new(); + walk(&root, &mut all); + assert!( + all.iter().filter(|o| o.class == cls::NETWORK_LOCATOR).any(|o| o.string(pid::URL_STRING).as_deref() == Some("Audio Files/100%20 #1.wav")) + ); + let starts: Vec = all.iter().filter(|o| o.class == cls::SOURCE_CLIP).filter_map(|o| o.i64(pid::START_TIME)).collect(); + assert!(starts.contains(&17_640), "parent rate start: {starts:?}"); + let opts = ReadOptions { + source_slot_rate: false, + infer_clip_name: false, + decode_relative_locator: false, + report_flattening: false, + permissive_pcm: true, + }; + let back = read_with_options(&bytes, &opts, &mut report).unwrap(); + assert!(back.sources.iter().any(|s| s.path.as_deref() == Some("Audio Files/100%20 #1.wav"))); + let clip = back.compositions[0].tracks[0].items.iter().find_map(|i| if let CItem::Clip(c) = i { Some(c) } else { None }).unwrap(); + assert_eq!(clip.start, FrameRate::FPS_25.tick_of(10)); +} diff --git a/crates/aaf/src/aaf/write.rs b/crates/aaf/src/aaf/write.rs index 8c9aae88e..1fcc6a332 100644 --- a/crates/aaf/src/aaf/write.rs +++ b/crates/aaf/src/aaf/write.rs @@ -75,6 +75,7 @@ fn definition(class: Auid, id: Auid, name: &str) -> Obj { struct W<'a> { report: &'a mut Report, inexact: bool, + references: super::ReferenceOptions, } struct IdGen { @@ -350,9 +351,15 @@ fn add_tape_mob(first: &Source, tape_id: [u8; 32], timecode: Option<(i64, FrameR } /// Serialise a composition document. -pub(crate) fn write(doc: &Document, version: craft_cfb::Version, identity: &Identity<'_>, report: &mut Report) -> Result> { +pub(crate) fn write( + doc: &Document, + version: craft_cfb::Version, + identity: &Identity<'_>, + references: &super::ReferenceOptions, + report: &mut Report, +) -> Result> { let comp = doc.compositions.first().ok_or(Error::Empty)?; - let mut w = W { report, inexact: false }; + let mut w = W { report, inexact: false, references: *references }; let mut ids = IdGen::for_document(doc, comp); let MediaOutput { mut mobs, essence, master_ref } = write_media(doc, &mut w, &mut ids); let mut used_ops: Vec = Vec::new(); @@ -360,7 +367,8 @@ pub(crate) fn write(doc: &Document, version: craft_cfb::Version, identity: &Iden // ---- nested compositions: a clip refers to one as it does to a master mob, through the // composition's first track of the clip's kind (a broken-out channel: that channel's track) - let mut refs = Refs { mobs: master_ref, rates: doc.sources.iter().enumerate().map(|(i, s)| (i, source_rate(s))).collect() }; + let rates = if references.source_slot_rate { doc.sources.iter().enumerate().map(|(i, s)| (i, source_rate(s))).collect() } else { HashMap::new() }; + let mut refs = Refs { mobs: master_ref, rates }; let nested_ids: Vec<[u8; 32]> = doc.nested.iter().map(|_| ids.next()).collect(); for (si, s) in doc.sources.iter().enumerate() { let Some((comp, id)) = s.nested.and_then(|n| Some((doc.nested.get(n)?, nested_ids.get(n)?))) else { continue }; @@ -795,8 +803,10 @@ fn descriptor(w: &mut W, s: &Source) -> Obj { if let Some(p) = &s.path { let url = if craft_timeline::path::is_absolute(p) { craft_timeline::path::path_to_file_url(p, false) - } else { + } else if w.references.encode_relative_locator { craft_timeline::path::encode_uri_path(p) + } else { + p.clone() }; d.set(pid::LOCATOR, Value::StrongVec(vec![Obj::new(cls::NETWORK_LOCATOR).data_prop(pid::URL_STRING, utf16z(&url))])); } From ad9850f18fadac54048f680d1da7f50f379cd124 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 11:05:37 -0500 Subject: [PATCH 135/382] fix(audio): validate FLAC stream precision and complete consumption --- crates/audio/src/flac_decode.rs | 49 +++++++++++++++++++++++++++++-- crates/audio/tests/flac_decode.rs | 37 +++++++++++++++++++++++ 2 files changed, 84 insertions(+), 2 deletions(-) diff --git a/crates/audio/src/flac_decode.rs b/crates/audio/src/flac_decode.rs index dfb6f5fc1..bb56e65c5 100644 --- a/crates/audio/src/flac_decode.rs +++ b/crates/audio/src/flac_decode.rs @@ -225,6 +225,11 @@ impl Decoder { /// Decode the frame at the start of `data`. pub fn decode_frame(&self, data: &[u8]) -> Result { + // StreamInfo has public fields: container callers can construct it without + // parse(), so validate before it can control shifts and sample reads. + if self.info.is_some_and(|i| !(4..=32).contains(&i.bits_per_sample) || !(1..=8).contains(&i.channels) || i.sample_rate == 0) { + return Err(DecodeError::Invalid("invalid decoder STREAMINFO")); + } let mut r = Bits::new(data); if r.bits(15)? != 0x7FFC { return Err(DecodeError::Invalid("missing frame sync code")); @@ -315,8 +320,7 @@ impl Decoder { } let mut chans = Vec::with_capacity(channels); for c in out { - let v: Result> = - c.into_iter().map(|s| i32::try_from(s).map_err(|_| DecodeError::Invalid("sample outside the bit depth"))).collect(); + let v: Result> = c.into_iter().map(|s| checked_sample(s, bits)).collect(); chans.push(v?); } Ok(Frame { sample_rate, bits_per_sample: bits as u8, variable_block_size: variable, number, block_size, channels: chans, size }) @@ -542,6 +546,11 @@ pub fn decode_with_limit(bytes: &[u8], max_values: u64) -> Result { if frame.channels.len() != channels.len() { return Err(DecodeError::Invalid("the channel count changes inside the stream")); } + // One file has one sample rate and depth. Otherwise callers would play + // samples under incompatible STREAMINFO metadata. + if frame.sample_rate != info.sample_rate || frame.bits_per_sample != info.bits_per_sample { + return Err(DecodeError::Invalid("frame format differs from STREAMINFO")); + } total += frame.block_size as u64; if total.saturating_mul(channels.len() as u64) > max_values { return Err(DecodeError::TooLarge); @@ -551,8 +560,44 @@ pub fn decode_with_limit(bytes: &[u8], max_values: u64) -> Result { } pos += frame.size; } + // Unknown total_samples must not turn a corrupt/truncated next frame into + // a successfully decoded shorter recording. + if pos != bytes.len() { + return Err(DecodeError::Invalid("trailing data or missing frame sync")); + } if info.total_samples != 0 && total != info.total_samples { return Err(DecodeError::Truncated); } Ok(Decoded { info, channels }) } + +// Validate the advertised precision, not just the storage type. Malformed +// predictors may produce an i32 that is still invalid for 4–24-bit audio. +fn checked_sample(sample: i64, bits: u32) -> Result { + if !(4..=32).contains(&bits) { + return Err(DecodeError::Invalid("invalid sample bit depth")); + } + let bound = 1i64 << (bits - 1); + if !(-bound..bound).contains(&sample) { + return Err(DecodeError::Invalid("sample outside the bit depth")); + } + i32::try_from(sample).map_err(|_| DecodeError::Invalid("sample outside the bit depth")) +} + +#[cfg(test)] +mod sample_bounds_tests { + use super::checked_sample; + + #[test] + fn samples_must_fit_declared_precision() { + for bits in 4..=32 { + let bound = 1i64 << (bits - 1); + assert_eq!(checked_sample(-bound, bits).map(i64::from), Ok(-bound)); + assert_eq!(checked_sample(bound - 1, bits).map(i64::from), Ok(bound - 1)); + assert!(checked_sample(-bound - 1, bits).is_err()); + assert!(checked_sample(bound, bits).is_err()); + } + assert!(checked_sample(0, 0).is_err()); + assert!(checked_sample(0, 255).is_err()); + } +} diff --git a/crates/audio/tests/flac_decode.rs b/crates/audio/tests/flac_decode.rs index c35267b08..a1895789b 100644 --- a/crates/audio/tests/flac_decode.rs +++ b/crates/audio/tests/flac_decode.rs @@ -172,3 +172,40 @@ fn ffmpeg_decodes_our_files_to_our_samples() { assert!(interleave(&got.channels) == want, "{channels}ch {bits}-bit: samples differ from ffmpeg's decode"); } } + +#[test] +fn rejects_unknown_length_corruption_and_streaminfo_format_mismatch() { + let src = signal(1, 100, 16, 7); + let original = encode(&src, 44_100, 16, 4096, 5); + let at = STREAMINFO_OFFSET as usize; + // STREAMINFO is not CRC-covered. Clear only the 36-bit total sample count. + let mut unknown = original.clone(); + unknown[at + 13] &= 0xf0; + unknown[at + 14..at + 18].fill(0); + assert_eq!(decode(&unknown).unwrap().channels, src); + for tail in [vec![0xff], vec![0x00, 0x00]] { + let mut broken = unknown.clone(); + broken.extend(tail); + assert!(decode(&broken).is_err()); + } + // The encoder spells these in frame headers, independent of STREAMINFO. + let mut wrong_rate = original.clone(); + let mut packed = u64::from_be_bytes(wrong_rate[at + 10..at + 18].try_into().unwrap()); + packed = (packed & ((1u64 << 44) - 1)) | (48_000u64 << 44); + wrong_rate[at + 10..at + 18].copy_from_slice(&packed.to_be_bytes()); + assert!(decode(&wrong_rate).is_err()); + let mut wrong_depth = original; + wrong_depth[at + 12] = (wrong_depth[at + 12] & !1) | 1; + wrong_depth[at + 13] = (wrong_depth[at + 13] & 0x0f) | 0x70; + assert!(decode(&wrong_depth).is_err()); +} + +#[test] +fn caller_constructed_streaminfo_is_validated_before_decoding() { + let file = encode(&signal(1, 100, 16, 9), 44_100, 16, 4096, 5); + let info = StreamInfo::parse(&file[STREAMINFO_OFFSET as usize..]).unwrap(); + for bits in [0, 1, 3, 33, 64, 255] { + let invalid = StreamInfo { bits_per_sample: bits, ..info }; + assert!(matches!(Decoder::new(invalid).decode_frame(&[]), Err(DecodeError::Invalid(_)))); + } +} From d3024d0cd5af26edecc04b0a68689436952bd116 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 11:05:39 -0500 Subject: [PATCH 136/382] fix(captions): preserve literal ASS escapes and normalize newlines --- crates/captions/src/ass.rs | 11 ++++++++--- crates/captions/tests/it/ass.rs | 31 ++++++++++++++++++++++++++++++- 2 files changed, 38 insertions(+), 4 deletions(-) diff --git a/crates/captions/src/ass.rs b/crates/captions/src/ass.rs index 3c907c829..2d0a1df55 100644 --- a/crates/captions/src/ass.rs +++ b/crates/captions/src/ass.rs @@ -191,7 +191,10 @@ fn escape(text: &str) -> String { let mut out = String::with_capacity(text.len() + 8); let mut rest = text; while !rest.is_empty() { - if let Some(r) = rest.strip_prefix("") { + if let Some(r) = rest.strip_prefix("\r\n") { + out.push_str("\\N"); + rest = r; + } else if let Some(r) = rest.strip_prefix("") { out.push_str("{\\i1}"); rest = r; } else if let Some(r) = rest.strip_prefix("") { @@ -211,7 +214,9 @@ fn escape(text: &str) -> String { rest = r; } else if let Some(c) = rest.chars().next() { match c { - '\n' => out.push_str("\\N"), + '\n' | '\r' => out.push_str("\\N"), + // Empty override block separates a literal slash from N/n/h. + '\\' => out.push_str("\\{}"), '{' => out.push('\u{ff5b}'), '}' => out.push('\u{ff5d}'), '\u{a0}' => out.push_str("\\h"), @@ -232,7 +237,7 @@ pub fn write(doc: &Document) -> String { ); for c in &doc.cues { // A comma in the Name field would shift the columns; the other fields are fixed text. - let name = c.speaker.as_deref().unwrap_or("").replace([',', '\n'], " "); + let name = c.speaker.as_deref().unwrap_or("").replace([',', '\n', '\r'], " "); out.push_str(&format!("Dialogue: 0,{},{},Default,{},0,0,0,,{}\n", format_time(c.start), format_time(c.end), name, escape(&c.text))); } out diff --git a/crates/captions/tests/it/ass.rs b/crates/captions/tests/it/ass.rs index de5d43167..fb6d4e01e 100644 --- a/crates/captions/tests/it/ass.rs +++ b/crates/captions/tests/it/ass.rs @@ -99,7 +99,8 @@ fn we_read_what_ffmpeg_writes() { fn ffmpeg_reads_what_we_write() { let Some(ff) = craft_media_testkit::ffmpeg() else { return }; let dir = craft_media_testkit::fixture_subdir("captions_ass"); - let doc = parse(SRT.as_bytes(), Format::Srt).expect("parse srt"); + let mut doc = parse(SRT.as_bytes(), Format::Srt).expect("parse srt"); + doc.cues.push(Cue { start: cs(400_000), end: cs(400_100), text: r"C:\New\notes\hello and \N \n \h".into(), ..Default::default() }); let (ass, srt) = (dir.join("ours.ass"), dir.join("back.srt")); std::fs::write(&ass, write(&doc, Format::Ass, WriteOptions::default())).expect("write"); ffmpeg_run(&ff, &["-i", ass.to_str().expect("path"), srt.to_str().expect("path")]); @@ -111,3 +112,31 @@ fn ffmpeg_reads_what_we_write() { assert_eq!(t.text, d.text, "text of the cue at {:?}", d.start); } } + +#[test] +fn literal_backslashes_survive_ass_round_trip() { + let text = r"C:\New\notes\hello and \N \n \h"; + let doc = Document { cues: vec![Cue { start: cs(100), end: cs(200), text: text.into(), ..Default::default() }], ..Default::default() }; + let bytes = write(&doc, Format::Ass, WriteOptions::default()); + assert_eq!(parse(&bytes, Format::Ass).unwrap().cues[0].text, text); +} + +#[test] +fn carriage_returns_cannot_create_dialogue_records() { + let doc = Document { + cues: vec![Cue { + start: cs(100), + end: cs(200), + text: "first\rsecond\r\nthird".into(), + speaker: Some("Ann\rOther".into()), + ..Default::default() + }], + ..Default::default() + }; + let bytes = write(&doc, Format::Ass, WriteOptions::default()); + assert!(!bytes.contains(&b'\r')); + let back = parse(&bytes, Format::Ass).unwrap(); + assert_eq!(back.cues.len(), 1); + assert_eq!(back.cues[0].text, "first\nsecond\nthird"); + assert_eq!(back.cues[0].speaker.as_deref(), Some("Ann Other")); +} From f31e878c6e923748aebae75869e9dd88874d05d3 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:08:57 +0000 Subject: [PATCH 137/382] exr: share ZIP chunk compression --- crates/exr/src/lib.rs | 3 + crates/exr/src/zlib.rs | 796 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 799 insertions(+) create mode 100644 crates/exr/src/zlib.rs diff --git a/crates/exr/src/lib.rs b/crates/exr/src/lib.rs index baaf3d3f1..f1550f8de 100644 --- a/crates/exr/src/lib.rs +++ b/crates/exr/src/lib.rs @@ -18,6 +18,9 @@ //! - [`stream`]: one flat scan-line part read block by block, for pictures larger than memory. //! - [`cryptomatte_samples`]: a file's Cryptomatte layers and their per-pixel (ID, coverage) ranks. +/// RFC 1950/1951 compressor for ZIP-compressed EXR chunks. +pub mod zlib; + pub mod channels; pub mod cryptomatte; #[cfg(feature = "decode")] diff --git a/crates/exr/src/zlib.rs b/crates/exr/src/zlib.rs new file mode 100644 index 000000000..8959a7e89 --- /dev/null +++ b/crates/exr/src/zlib.rs @@ -0,0 +1,796 @@ +//! A small DEFLATE encoder (RFC 1951) in a zlib wrapper (RFC 1950), written from the RFCs for the +//! ZIP-compressed OpenEXR chunks. +//! +//! Greedy LZ77 over a 32 KB window (hash chains of bounded length), then each block of tokens is +//! written as whichever of stored, fixed-Huffman or dynamic-Huffman is smallest. Huffman code +//! lengths are limited (15 bits, 7 for the code-length code) by halving the symbol frequencies +//! until the tree fits. Every code has at least two symbols, so all codes are complete. The +//! output favours simplicity and correctness over ratio; worst-case expansion is the stored-block +//! overhead (5 bytes per 64 KB). + +use std::cmp::Reverse; +use std::collections::BinaryHeap; + +const WINDOW: usize = 32 * 1024; +const MIN_MATCH: usize = 3; +const MAX_MATCH: usize = 258; +/// Hash chain candidates tried per position. +const MAX_CHAIN: usize = 48; +/// Tokens per block (a new set of Huffman codes after this many). +const BLOCK_TOKENS: usize = 1 << 15; +const MAX_STORED: usize = 65_535; + +const LEN_BASE: [u16; 29] = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258]; +const LEN_EXTRA: [u8; 29] = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]; +const DIST_BASE: [u16; 30] = + [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577]; +const DIST_EXTRA: [u8; 30] = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]; +/// Order in which the code-length code's lengths are sent. +const CL_ORDER: [usize; 19] = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; + +/// `data` compressed as a zlib stream (CMF 0x78: deflate, 32 KB window). `tables` are the match +/// finder's hash tables, kept by the caller across the chunks of a picture; the output does not +/// depend on what they held before. +pub fn zlib(data: &[u8], tables: &mut Tables) -> Vec { + let mut w = Bits { out: Vec::with_capacity(data.len() / 2 + 64), acc: 0, n: 0 }; + w.out.extend_from_slice(&[0x78, 0x9C]); // (0x78 << 8 | 0x9C) % 31 == 0 + deflate(data, &mut w, tables); + w.align(); + w.out.extend_from_slice(&adler32(data).to_be_bytes()); + w.out +} + +/// Adler-32 (RFC 1950 §9); 5552 bytes is the longest run that cannot overflow the sums. +fn adler32(data: &[u8]) -> u32 { + let (mut a, mut b) = (1_u32, 0_u32); + for c in data.chunks(5552) { + for &x in c { + a += u32::from(x); + b += a; + } + a %= 65_521; + b %= 65_521; + } + (b << 16) | a +} + +/// LSB-first bit writer. +struct Bits { + out: Vec, + acc: u64, + n: u32, +} + +impl Bits { + /// The low `n` bits of `v` (n ≤ 32). + fn put(&mut self, v: u32, n: u32) { + let mask = (1_u64 << n) - 1; + self.acc |= (u64::from(v) & mask) << self.n; + self.n += n; + while self.n >= 8 { + self.out.push(self.acc as u8); + self.acc >>= 8; + self.n -= 8; + } + } + + fn align(&mut self) { + if self.n > 0 { + self.out.push(self.acc as u8); + } + self.acc = 0; + self.n = 0; + } +} + +#[derive(Clone, Copy)] +enum Tok { + Lit(u8), + Match { len: u16, dist: u16 }, +} + +/// Index into [`LEN_BASE`] of a match length (3..=258). +fn len_code(len: u16) -> usize { + LEN_BASE.partition_point(|&b| b <= len).saturating_sub(1) +} + +/// Index into [`DIST_BASE`] of a distance (1..=32768). +fn dist_code(dist: u16) -> usize { + DIST_BASE.partition_point(|&b| b <= dist).saturating_sub(1) +} + +/// The match finder's hash heads and chains, reused from one input to the next. +/// +/// A slot holds `base + p + 1` for position `p` of the input that wrote it; anything at or below +/// the current input's `base` was left by an earlier input and reads as empty. So the tables are +/// never cleared between inputs: an OpenEXR ZIPS frame is one input per scan line, and zeroing +/// 256 KiB of tables for each 23 KB UHD line cost more memory traffic than the data itself. +#[derive(Default)] +pub struct Tables { + head: Vec, + prev: Vec, + /// Bytes compressed through these tables since they were last cleared. + base: u32, +} + +/// LZ77 match finder: hash heads and chains over the window. +struct Matcher<'a> { + data: &'a [u8], + head: &'a mut [u32], + prev: &'a mut [u32], + bits: u32, + /// `prev` slots used by this input, minus one (a power of two minus one). + mask: usize, + base: u32, +} + +impl<'a> Matcher<'a> { + /// A matcher over `data` (shorter than `u32::MAX` bytes), or None when it is not. + fn new(data: &'a [u8], t: &'a mut Tables) -> Option { + // hash width and chain span follow the input's size, as they did when every input had + // tables of its own (the output depends on them), so short chunks stay cheap to hash + let span = data.len().clamp(256, WINDOW).next_power_of_two(); + let bits = span.trailing_zeros().clamp(8, 15); + let n = u32::try_from(data.len()).ok().filter(|&n| n < u32::MAX)?; + if t.base.checked_add(n).and_then(|b| b.checked_add(1)).is_none() { + // positions would no longer fit after `base`: start over from empty tables + t.head.fill(0); + t.prev.fill(0); + t.base = 0; + } + // grown slots are 0, which is never above `base`, so they read as empty + if t.head.len() < 1 << bits { + t.head.resize(1 << bits, 0); + } + if t.prev.len() < span { + t.prev.resize(span, 0); + } + let base = t.base; + t.base += n; + let (head, prev) = (t.head.get_mut(..1 << bits)?, t.prev.get_mut(..span)?); + Some(Matcher { data, head, prev, bits, mask: span - 1, base }) + } + + /// Position `p` of this input from a stored slot, or None for an empty or earlier input's slot. + fn pos(&self, slot: u32) -> Option { + slot.checked_sub(self.base)?.checked_sub(1).map(|p| p as usize) + } + + fn hash(&self, p: usize) -> Option { + let b = self.data.get(p..p + MIN_MATCH)?; + let v = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]); + Some((v.wrapping_mul(0x9E37_79B1) >> (32 - self.bits)) as usize) + } + + /// Record position `p` (stored as `p + 1`; 0 = empty). + fn insert(&mut self, p: usize) { + let Some(h) = self.hash(p) else { return }; + let (Some(head), Ok(p32)) = (self.head.get(h).copied(), u32::try_from(p)) else { return }; + if let Some(slot) = self.prev.get_mut(p & self.mask) { + *slot = head; + } + if let Some(slot) = self.head.get_mut(h) { + // `new` reserved `base + len + 1` within u32 + *slot = self.base + p32 + 1; + } + } + + /// The longest earlier match at `p`: (length, distance), length 0 if none. + fn longest(&self, p: usize) -> (usize, usize) { + let Some(h) = self.hash(p) else { return (0, 0) }; + let max = self.data.len().saturating_sub(p).min(MAX_MATCH); + let Some(here) = self.data.get(p..p + max) else { return (0, 0) }; + let (mut best, mut best_dist) = (0, 0); + let mut cand = self.head.get(h).and_then(|&s| self.pos(s)); + for _ in 0..MAX_CHAIN { + let Some(c) = cand else { break }; + if c >= p || p - c > WINDOW { + break; + } + // a candidate that differs at `best` cannot be longer than `best`: skip comparing it + if best == 0 || self.data.get(c + best) == here.get(best) { + let l = self.data.get(c..).unwrap_or_default().iter().zip(here).take_while(|(a, b)| a == b).count(); + if l > best { + (best, best_dist) = (l, p - c); + if l == max { + break; + } + } + } + let Some(next) = self.prev.get(c & self.mask).and_then(|&s| self.pos(s)) else { break }; + // chains only go back; anything else is a stale slot + if next >= c { + break; + } + cand = Some(next); + } + (best, best_dist) + } +} + +/// The deflate blocks of `data`, the last one final. +fn deflate(data: &[u8], w: &mut Bits, tables: &mut Tables) { + if data.is_empty() { + // a final fixed-Huffman block holding only end-of-block (code 0000000) + w.put(1, 1); + w.put(1, 2); + w.put(0, 7); + return; + } + // positions are kept in u32; longer inputs (never an OpenEXR chunk) go out stored + let mut m = Matcher::new(data, tables); + let mut toks = Vec::with_capacity(BLOCK_TOKENS.min(data.len()) + 1); + let (mut start, mut i) = (0, 0); + while i < data.len() { + let (len, dist) = m.as_ref().map_or((0, 0), |m| m.longest(i)); + let step = if len >= MIN_MATCH { + toks.push(Tok::Match { len: len as u16, dist: dist as u16 }); + len + } else { + toks.push(Tok::Lit(data[i])); + 1 + }; + if let Some(m) = m.as_mut() { + for p in i..i + step { + m.insert(p); + } + } + i += step; + if toks.len() >= BLOCK_TOKENS || i == data.len() { + block(w, &toks, &data[start..i], i == data.len()); + toks.clear(); + start = i; + } + } +} + +/// Bits the tokens take with the given code lengths (EOB included). +fn data_bits(lf: &[u32], df: &[u32], ll: &[u8], dl: &[u8]) -> u64 { + let mut n = 0_u64; + for (s, (&f, &l)) in lf.iter().zip(ll).enumerate() { + let extra = s.checked_sub(257).and_then(|k| LEN_EXTRA.get(k)).copied().unwrap_or(0); + n += u64::from(f) * u64::from(l + extra); + } + for (d, (&f, &l)) in df.iter().zip(dl).enumerate() { + n += u64::from(f) * u64::from(l + DIST_EXTRA.get(d).copied().unwrap_or(0)); + } + n +} + +/// One block (split into several stored blocks when stored is smallest and `raw` is long). +fn block(w: &mut Bits, toks: &[Tok], raw: &[u8], last: bool) { + let mut lf = [0_u32; 286]; + let mut df = [0_u32; 30]; + for t in toks { + match *t { + Tok::Lit(b) => lf[b as usize] += 1, + Tok::Match { len, dist } => { + lf[257 + len_code(len)] += 1; + df[dist_code(dist)] += 1; + } + } + } + lf[256] += 1; + + // dynamic codes and their header + let ll = lengths(&lf, 15); + let dl = lengths(&df, 15); + let hlit = ll.iter().rposition(|&l| l > 0).map_or(257, |p| (p + 1).max(257)); + let hdist = dl.iter().rposition(|&l| l > 0).map_or(1, |p| p + 1); + let seq = rle_lengths(&[&ll[..hlit], &dl[..hdist]].concat()); + let mut cf = [0_u32; 19]; + for &(s, _) in &seq { + cf[s as usize] += 1; + } + let cl = lengths(&cf, 7); + let hclen = CL_ORDER.iter().rposition(|&s| cl[s] > 0).map_or(4, |p| (p + 1).max(4)); + let seq_bits: u64 = + seq.iter().map(|&(s, _)| u64::from(cl[s as usize]) + [2_u64, 3, 7].get((s as usize).wrapping_sub(16)).copied().unwrap_or(0)).sum(); + let dyn_bits = 3 + 14 + 3 * hclen as u64 + seq_bits + data_bits(&lf, &df, &ll, &dl); + + let (fll, fdl) = fixed_lengths(); + let fixed_bits = 3 + data_bits(&lf, &df, &fll, &fdl); + // per stored piece: header, at most 7 padding bits, LEN and NLEN + let pieces = raw.len().div_ceil(MAX_STORED).max(1) as u64; + let stored_bits = pieces * (3 + 7 + 32) + 8 * raw.len() as u64; + + if stored_bits <= fixed_bits.min(dyn_bits) { + let n = raw.chunks(MAX_STORED).count(); + for (k, piece) in raw.chunks(MAX_STORED).enumerate() { + w.put(u32::from(last && k + 1 == n), 1); + w.put(0, 2); + w.align(); + let len = piece.len() as u16; + w.out.extend_from_slice(&len.to_le_bytes()); + w.out.extend_from_slice(&(!len).to_le_bytes()); + w.out.extend_from_slice(piece); + } + return; + } + w.put(u32::from(last), 1); + if fixed_bits <= dyn_bits { + w.put(1, 2); + write_tokens(w, toks, &fll, &fdl); + return; + } + w.put(2, 2); + w.put((hlit - 257) as u32, 5); + w.put((hdist - 1) as u32, 5); + w.put((hclen - 4) as u32, 4); + for &s in &CL_ORDER[..hclen] { + w.put(u32::from(cl[s]), 3); + } + let cc = codes(&cl); + for &(s, x) in &seq { + w.put(u32::from(cc[s as usize]), u32::from(cl[s as usize])); + match s { + 16 => w.put(u32::from(x), 2), + 17 => w.put(u32::from(x), 3), + 18 => w.put(u32::from(x), 7), + _ => {} + } + } + write_tokens(w, toks, &ll, &dl); +} + +/// The fixed Huffman code lengths (RFC 1951 §3.2.6). +fn fixed_lengths() -> ([u8; 288], [u8; 30]) { + let mut ll = [8_u8; 288]; + ll[144..256].fill(9); + ll[256..280].fill(7); + (ll, [5; 30]) +} + +fn write_tokens(w: &mut Bits, toks: &[Tok], ll: &[u8], dl: &[u8]) { + let lc = codes(ll); + let dc = codes(dl); + let sym = |w: &mut Bits, s: usize| w.put(u32::from(lc[s]), u32::from(ll[s])); + for t in toks { + match *t { + Tok::Lit(b) => sym(w, b as usize), + Tok::Match { len, dist } => { + let k = len_code(len); + sym(w, 257 + k); + w.put(u32::from(len - LEN_BASE[k]), u32::from(LEN_EXTRA[k])); + let d = dist_code(dist); + w.put(u32::from(dc[d]), u32::from(dl[d])); + w.put(u32::from(dist - DIST_BASE[d]), u32::from(DIST_EXTRA[d])); + } + } + } + sym(w, 256); +} + +/// Canonical Huffman codes for `lens`, bit-reversed for the LSB-first writer. +fn codes(lens: &[u8]) -> Vec { + let mut count = [0_u32; 16]; + for &l in lens { + if (1..16).contains(&l) { + count[l as usize] += 1; + } + } + let mut next = [0_u32; 16]; + let mut code = 0; + for bits in 1..16 { + code = (code + count[bits - 1]) << 1; + next[bits] = code; + } + lens.iter() + .map(|&l| { + if !(1..16).contains(&l) { + return 0; + } + let c = next[l as usize]; + next[l as usize] += 1; + (c.reverse_bits() >> (32 - u32::from(l))) as u16 + }) + .collect() +} + +/// Code lengths for `freq`, none longer than `limit`; at least two symbols always get a code. +fn lengths(freq: &[u32], limit: u8) -> Vec { + let mut f: Vec = freq.iter().map(|&x| u64::from(x)).collect(); + let mut used = f.iter().filter(|&&x| x > 0).count(); + for x in f.iter_mut() { + if used >= 2 { + break; + } + if *x == 0 { + *x = 1; + used += 1; + } + } + // halving converges: once every used frequency is 1 the tree is balanced (depth ≤ 9 here) + for _ in 0..66 { + let l = huffman(&f); + if l.iter().all(|&d| d <= limit) { + return l; + } + for x in f.iter_mut().filter(|x| **x > 0) { + *x = (*x >> 1).max(1); + } + } + huffman(&f) +} + +/// Huffman tree depths of the symbols with non-zero frequency (0 for the rest). +fn huffman(f: &[u64]) -> Vec { + let n = f.len(); + let mut heap: BinaryHeap> = f.iter().enumerate().filter(|(_, w)| **w > 0).map(|(i, &w)| Reverse((w, i))).collect(); + let mut parent = vec![usize::MAX; 2 * n]; + let mut next = n; + while heap.len() > 1 { + let (Some(Reverse((wa, a))), Some(Reverse((wb, b)))) = (heap.pop(), heap.pop()) else { break }; + parent[a] = next; + parent[b] = next; + heap.push(Reverse((wa + wb, next))); + next += 1; + } + // parents always come after their children, so walk down from the root + let mut depth = vec![0_u32; next]; + for i in (0..next).rev() { + if let Some(&p) = parent.get(i).filter(|&&p| p < next) { + depth[i] = depth[p].saturating_add(1); + } + } + depth[..n].iter().map(|&d| d.min(u32::from(u8::MAX)) as u8).collect() +} + +/// Code lengths run-length coded with the code-length alphabet: (symbol, extra-bits value). +fn rle_lengths(lens: &[u8]) -> Vec<(u8, u8)> { + let mut out = Vec::new(); + let mut i = 0; + while i < lens.len() { + let l = lens[i]; + let run = lens[i..].iter().take_while(|&&x| x == l).count(); + let mut r = run; + if l == 0 { + while r >= 11 { + let k = r.min(138); + out.push((18, (k - 11) as u8)); + r -= k; + } + if r >= 3 { + out.push((17, (r - 3) as u8)); + r = 0; + } + } else { + out.push((l, 0)); + r -= 1; + while r >= 3 { + let k = r.min(6); + out.push((16, (k - 3) as u8)); + r -= k; + } + } + out.extend(std::iter::repeat_n((l, 0), r)); + i += run; + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + + /// A minimal inflater (RFC 1951), only to check the encoder; returns None on any error. + pub(crate) fn inflate(z: &[u8]) -> Option> { + let (cmf, flg) = (*z.first()?, *z.get(1)?); + if cmf & 0x0F != 8 || (u16::from(cmf) << 8 | u16::from(flg)) % 31 != 0 || flg & 0x20 != 0 { + return None; + } + let mut pos = 16_usize; // bit position + let bit = |pos: &mut usize| -> Option { + let b = (*z.get(*pos / 8)? >> (*pos % 8)) & 1; + *pos += 1; + Some(u32::from(b)) + }; + let bits = |pos: &mut usize, n: u32| -> Option { + let mut v = 0; + for k in 0..n { + v |= bit(pos)? << k; + } + Some(v) + }; + // decode one symbol with canonical lengths (slow but simple) + let decode = |pos: &mut usize, lens: &[u8]| -> Option { + let (mut code, mut first, mut index) = (0_i32, 0_i32, 0_i32); + let mut count = [0_i32; 16]; + for &l in lens { + count[l as usize] += 1; + } + let mut sorted: Vec = (0..lens.len()).filter(|&s| lens[s] > 0).collect(); + sorted.sort_by_key(|&s| (lens[s], s)); + for len in 1..16 { + code |= bit(pos)? as i32; + let c = count[len]; + if code - c < first { + return sorted.get((index + code - first) as usize).copied(); + } + index += c; + first = (first + c) << 1; + code <<= 1; + } + None + }; + let mut out = Vec::new(); + loop { + let last = bit(&mut pos)?; + match bits(&mut pos, 2)? { + 0 => { + pos = pos.div_ceil(8) * 8; + let at = pos / 8; + let len = u16::from_le_bytes([*z.get(at)?, *z.get(at + 1)?]); + let nlen = u16::from_le_bytes([*z.get(at + 2)?, *z.get(at + 3)?]); + if len != !nlen { + return None; + } + out.extend_from_slice(z.get(at + 4..at + 4 + len as usize)?); + pos = (at + 4 + len as usize) * 8; + } + t @ (1 | 2) => { + let (ll, dl) = if t == 1 { + let (a, b) = fixed_lengths(); + (a.to_vec(), b.to_vec()) + } else { + let hlit = bits(&mut pos, 5)? as usize + 257; + let hdist = bits(&mut pos, 5)? as usize + 1; + let hclen = bits(&mut pos, 4)? as usize + 4; + let mut cl = [0_u8; 19]; + for &s in &CL_ORDER[..hclen] { + cl[s] = bits(&mut pos, 3)? as u8; + } + let mut lens = Vec::new(); + while lens.len() < hlit + hdist { + match decode(&mut pos, &cl)? { + s @ 0..=15 => lens.push(s as u8), + 16 => { + let p = *lens.last()?; + lens.extend(std::iter::repeat_n(p, 3 + bits(&mut pos, 2)? as usize)); + } + 17 => lens.extend(std::iter::repeat_n(0, 3 + bits(&mut pos, 3)? as usize)), + _ => lens.extend(std::iter::repeat_n(0, 11 + bits(&mut pos, 7)? as usize)), + } + } + if lens.len() != hlit + hdist { + return None; + } + (lens[..hlit].to_vec(), lens[hlit..].to_vec()) + }; + loop { + let s = decode(&mut pos, &ll)?; + if s < 256 { + out.push(s as u8); + } else if s == 256 { + break; + } else { + let k = s - 257; + let len = *LEN_BASE.get(k)? as usize + bits(&mut pos, u32::from(LEN_EXTRA[k]))? as usize; + let d = decode(&mut pos, &dl)?; + let dist = *DIST_BASE.get(d)? as usize + bits(&mut pos, u32::from(DIST_EXTRA[d]))? as usize; + let from = out.len().checked_sub(dist)?; + for j in 0..len { + out.push(out[from + j]); + } + } + } + } + _ => return None, + } + if last == 1 { + break; + } + } + let at = pos.div_ceil(8); + let sum = u32::from_be_bytes(z.get(at..at + 4)?.try_into().ok()?); + (sum == adler32(&out) && at + 4 == z.len()).then_some(out) + } + + /// A deterministic pseudo-random byte stream. + fn noise(n: usize, seed: u32) -> Vec { + let mut s = seed | 1; + (0..n) + .map(|_| { + s ^= s << 13; + s ^= s >> 17; + s ^= s << 5; + s as u8 + }) + .collect() + } + + #[test] + fn round_trips() { + let mut cases: Vec> = vec![vec![], vec![7], vec![1, 2], vec![0; 1], vec![0; 300_000], b"abcabcabcabcabcabd".to_vec()]; + cases.push(noise(100_000, 9)); // incompressible: stored blocks + cases.push(noise(70_000, 3).iter().map(|b| b % 4).collect()); // few symbols: dynamic + cases.push((0..200_000_u32).map(|i| ((i / 7) % 251) as u8).collect()); // long repeats + // text-like: a small vocabulary repeated at varying distances + let words: [&[u8]; 6] = [b"red ", b"green ", b"blue ", b"alpha ", b"half ", b"linear "]; + cases.push(noise(40_000, 5).iter().flat_map(|b| words[*b as usize % 6].iter().copied()).collect()); + // skewed frequencies: Huffman lengths beyond 15 before limiting + let mut fib = Vec::new(); + let (mut a, mut b) = (1_usize, 1_usize); + for s in 0..25_u8 { + fib.extend(std::iter::repeat_n(s.wrapping_mul(37), a.min(200_000))); + (a, b) = (b, a + b); + } + let r = noise(fib.len() * 4, 11); + for i in (1..fib.len()).rev() { + let j = u32::from_le_bytes(r[i * 4..i * 4 + 4].try_into().unwrap()) as usize % (i + 1); + fib.swap(i, j); + } + cases.push(fib); + for (k, data) in cases.iter().enumerate() { + let z = zlib(data, &mut Tables::default()); + assert_eq!(inflate(&z).as_deref(), Some(data.as_slice()), "case {k}"); + // worst case: stored overhead only + assert!(z.len() <= data.len() + (data.len().div_ceil(BLOCK_TOKENS) + 1) * 5 + 6, "case {k}: {} > {}", z.len(), data.len()); + } + // repetitive data actually compresses + assert!(zlib(&cases[4], &mut Tables::default()).len() < 2_000); + assert!(zlib(&cases[8], &mut Tables::default()).len() < 20_000); + } + + #[test] + fn length_limits_hold() { + // Fibonacci frequencies give the deepest possible Huffman tree + let mut f = vec![0_u32; 286]; + let (mut a, mut b) = (1_u32, 1_u32); + for x in f.iter_mut().take(30) { + *x = a; + (a, b) = (b, a.saturating_add(b)); + } + let l = lengths(&f, 15); + assert!(l.iter().all(|&d| d <= 15)); + // a complete code: Kraft sum exactly 1 + let kraft: f64 = l.iter().filter(|&&d| d > 0).map(|&d| 0.5_f64.powi(i32::from(d))).sum(); + assert!((kraft - 1.0).abs() < 1e-12); + // one used symbol still gets a two-symbol code + let l = lengths(&[0, 5, 0], 7); + assert_eq!(l.iter().filter(|&&d| d == 1).count(), 2); + } + + #[test] + fn adler_matches_rfc_example() { + // the classic test vector for "Wikipedia" + assert_eq!(adler32(b"Wikipedia"), 0x11E6_0398); + assert_eq!(adler32(&[]), 1); + } + + /// The match finder before #4659: tables of its own per input, every chain candidate compared + /// from its first byte. + struct OldMatcher<'a> { + data: &'a [u8], + head: Vec, + prev: Vec, + bits: u32, + } + + impl<'a> OldMatcher<'a> { + /// Tables of its own, sized to `data`. + fn new(data: &'a [u8]) -> Self { + let span = data.len().clamp(256, WINDOW).next_power_of_two(); + let bits = span.trailing_zeros().clamp(8, 15); + OldMatcher { data, head: vec![0; 1 << bits], prev: vec![0; span], bits } + } + + /// The hash of the three bytes at `p`, None near the end. + fn hash(&self, p: usize) -> Option { + let b = self.data.get(p..p + MIN_MATCH)?; + let v = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]); + Some((v.wrapping_mul(0x9E37_79B1) >> (32 - self.bits)) as usize) + } + + /// Record position `p` (stored as `p + 1`; 0 = empty). + fn insert(&mut self, p: usize) { + let Some(h) = self.hash(p) else { return }; + let mask = self.prev.len() - 1; + self.prev[p & mask] = self.head[h]; + self.head[h] = p as u32 + 1; + } + + /// The longest earlier match at `p`: (length, distance), length 0 if none. + fn longest(&self, p: usize) -> (usize, usize) { + let Some(h) = self.hash(p) else { return (0, 0) }; + let max = (self.data.len() - p).min(MAX_MATCH); + let here = &self.data[p..p + max]; + let mask = self.prev.len() - 1; + let (mut best, mut best_dist) = (0, 0); + let mut cand = self.head[h] as usize; + for _ in 0..MAX_CHAIN { + let Some(c) = cand.checked_sub(1) else { break }; + if c >= p || p - c > WINDOW { + break; + } + let l = self.data[c..].iter().zip(here).take_while(|(a, b)| a == b).count(); + if l > best { + (best, best_dist) = (l, p - c); + if l == max { + break; + } + } + let next = self.prev[c & mask] as usize; + if next == 0 || next > c { + break; + } + cand = next; + } + (best, best_dist) + } + } + + /// Inputs shaped like OpenEXR chunks (predicted half-float scan lines, single and 16-line) + /// and the awkward cases: empty, tiny, incompressible, long runs, few symbols. + fn chunk_cases() -> Vec> { + let line: Vec = (0..23_040_u32).map(|i| (128 + ((i / 3) % 7) as i32 - 3 + (i % 5 == 0) as i32) as u8).collect(); + let mut cases = vec![line.clone(), line.iter().rev().copied().collect(), vec![], vec![9], b"abcabcabcabd".to_vec()]; + cases.push(line.iter().cycle().take(16 * 23_040).copied().collect()); // ZIP: 16 lines, longer than the window + cases.push(noise(23_040, 4)); + cases.push(noise(70_000, 3).iter().map(|b| b % 4).collect()); + cases.push(vec![0; 300_000]); + cases.push(line.clone()); + cases.push(noise(300, 7)); + cases + } + + /// The matcher's greedy parse of `data`: what `deflate` codes. + fn parse (usize, usize), G: FnMut(usize)>(data: &[u8], mut longest: F, mut insert: G) -> Vec<(usize, usize)> { + let (mut out, mut i) = (Vec::new(), 0); + while i < data.len() { + let (len, dist) = longest(i); + let step = if len >= MIN_MATCH { len } else { 1 }; + out.push(if len >= MIN_MATCH { (len, dist) } else { (0, 0) }); + for p in i..i + step { + insert(p); + } + i += step; + } + out + } + + /// Shared tables and the candidate skip find exactly the matches the previous matcher found. + #[test] + fn shared_tables_find_the_matches_the_old_per_chunk_tables_found() { + let mut tables = Tables::default(); + for (k, data) in chunk_cases().iter().enumerate() { + let old = std::cell::RefCell::new(OldMatcher::new(data)); + let want = parse(data, |p| old.borrow().longest(p), |p| old.borrow_mut().insert(p)); + let new = std::cell::RefCell::new(Matcher::new(data, &mut tables).expect("fits")); + let got = parse(data, |p| new.borrow().longest(p), |p| new.borrow_mut().insert(p)); + assert!(got == want, "chunk {k}: the parse differs"); + } + } + + /// Shared tables compress to the bytes fresh ones give, also when positions run out and they start over. + #[test] + fn shared_tables_give_the_bytes_of_fresh_ones() { + let mut shared = Tables::default(); + for (k, data) in chunk_cases().iter().enumerate() { + let z = zlib(data, &mut shared); + assert!(z == zlib(data, &mut Tables::default()), "chunk {k}"); + assert_eq!(inflate(&z).as_deref(), Some(data.as_slice()), "chunk {k}"); + } + // positions about to run past u32: the tables start over and the bytes stay the same + for gap in [0_u32, 1, 2, 23_040, 23_041, 1 << 20] { + shared.base = u32::MAX - gap; + for (k, data) in chunk_cases().iter().enumerate() { + assert!(zlib(data, &mut shared) == zlib(data, &mut Tables::default()), "gap {gap}, chunk {k}"); + } + } + } + + /// Later chunks use the same tables instead of allocating new ones. + #[test] + fn the_tables_are_reused_across_chunks() { + let mut tables = Tables::default(); + let line = &chunk_cases()[0]; + zlib(line, &mut tables); + let (head, prev) = (tables.head.as_ptr(), tables.prev.as_ptr()); + for _ in 0..4 { + zlib(line, &mut tables); + assert!(tables.head.as_ptr() == head && tables.prev.as_ptr() == prev, "a chunk allocated new tables"); + } + assert_eq!(tables.base as usize, 5 * line.len()); + } +} From 58854566ed89f6b27f304da15eb8922133fb8924 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 11:10:39 -0500 Subject: [PATCH 138/382] feat: add craft-format (versioned JSON file formats) Port from solidcraft: versioned JSON file format system with: - Format families with hand-written upgrade steps and folded formats - Pending changes that auto-number on release - Container format: content-addressed blobs (SHA-256) in ZIP packages - Newer file handling: read what you can, keep the rest No external dependencies beyond serde_json and craft-zip. Hostile-input bounded reading: sizes, counts, nesting capped. --- crates/format/Cargo.toml | 20 ++ crates/format/src/build.rs | 100 +++++++ crates/format/src/container.rs | 401 +++++++++++++++++++++++++++ crates/format/src/container_tests.rs | 67 +++++ crates/format/src/lib.rs | 252 +++++++++++++++++ crates/format/src/lib_tests.rs | 134 +++++++++ crates/format/src/newer.rs | 401 +++++++++++++++++++++++++++ crates/format/src/newer_tests.rs | 48 ++++ 8 files changed, 1423 insertions(+) create mode 100644 crates/format/Cargo.toml create mode 100644 crates/format/src/build.rs create mode 100644 crates/format/src/container.rs create mode 100644 crates/format/src/container_tests.rs create mode 100644 crates/format/src/lib.rs create mode 100644 crates/format/src/lib_tests.rs create mode 100644 crates/format/src/newer.rs create mode 100644 crates/format/src/newer_tests.rs diff --git a/crates/format/Cargo.toml b/crates/format/Cargo.toml new file mode 100644 index 000000000..943e0b9b6 --- /dev/null +++ b/crates/format/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "craft-format" +description = "Versioned JSON file formats: the format tag, the registry of versions (hand-written steps, then one folder of changes per version, then the pending changes), the upgrade of an older file and the telling of a newer one" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +serde_json = { workspace = true } +# The container: content-addressed blobs (SHA-256) in a ZIP package. +sha2 = { version = "0.10", default-features = false, features = ["std"] } +craft-zip = { workspace = true } + +[dev-dependencies] +proptest = { workspace = true } diff --git a/crates/format/src/build.rs b/crates/format/src/build.rs new file mode 100644 index 000000000..8fb879235 --- /dev/null +++ b/crates/format/src/build.rs @@ -0,0 +1,100 @@ +//! For a build script: the generated lists of a family's changes. Each change is one `.rs` file in +//! the family's folder, in `v/` once a release fixed its number, else in `pending/`; the lists +//! are generated so that a change adds a file and never edits a line another change also edits. +//! +//! The generated code, for the app to `include!`, is per family a `FOLDED` list (each folded +//! format and its parts) and a `PENDING` list, both prefixed by the family's `list_prefix`, then a +//! module per change file. It names the app's `Part` type, which the including module has in scope +//! (`type Part = craft_format::Part;`), and a change file's step as `step` (a +//! `pub fn step(v: &mut Value) -> Result<(), AppError>`, when the file has one). + +use std::fmt::Write as _; +use std::path::{Path, PathBuf}; + +/// A family's change files: their folder (relative to the crate's manifest), the last format +/// before them, and the prefix of the family's lists. +pub struct Family { + pub folder: &'static str, + pub base: u32, + pub list_prefix: &'static str, +} + +/// What [`lists`] made: the code to write, and the folders the build script reruns on. +pub struct Lists { + pub code: String, + pub watch: Vec, +} + +/// The `FOLDED` and `PENDING` lists of every family, and a module for each change file. Refuses +/// versions that are not contiguous from a family's base, a change file not named with lowercase +/// letters, digits and dashes, and one that doesn't start with a `//!` note. +pub fn lists(manifest: &Path, families: &[Family]) -> Result { + let mut code = String::new(); + let mut mods = String::new(); + let mut watch = Vec::new(); + for family in families { + let root = manifest.join(family.folder); + family_lists(family, &root, &mut code, &mut mods)?; + watch.push(root); + } + code.push_str(&mods); + Ok(Lists { code, watch }) +} + +/// A family's `FOLDED` and `PENDING` lists; its folded formats follow on from its base. +fn family_lists(family: &Family, root: &Path, out: &mut String, mods: &mut String) -> Result<(), String> { + let Family { folder, base, list_prefix } = family; + let mut folded: Vec<(u32, PathBuf)> = std::fs::read_dir(root) + .map_err(|e| format!("{}: {e}", root.display()))? + .filter_map(|entry| { + let path = entry.ok()?.path(); + let version = path.file_name()?.to_str()?.strip_prefix('v')?.parse().ok()?; + path.is_dir().then_some((version, path)) + }) + .collect(); + folded.sort(); + for (i, (version, _)) in folded.iter().enumerate() { + let expected = base + 1 + i as u32; + if *version != expected { + return Err(format!("{folder}/: expected v{expected}/ next, found v{version}/ (versions are contiguous)")); + } + } + // Module names start with the family's (`drawing_pending_…`), so two families' changes of one + // name never clash. + let module = list_prefix.to_ascii_lowercase(); + let _ = writeln!( + out, + "/// The changes of each format after the base, oldest first (`{folder}/v/`).\nconst {list_prefix}FOLDED: &[(u32, &[Part])] = &[" + ); + for (version, dir) in &folded { + let _ = writeln!(out, " ({version}, &["); + parts(dir, &format!("{module}v{version}"), out, mods)?; + out.push_str(" ]),\n"); + } + let _ = writeln!(out, "];\n\n/// The changes no release has a number for yet (`{folder}/pending/`).\nconst {list_prefix}PENDING: &[Part] = &["); + parts(&root.join("pending"), &format!("{module}pending"), out, mods)?; + out.push_str("];\n\n"); + Ok(()) +} + +/// The `Part`s of the change files in `dir`, in file-name order, and a module for each. +fn parts(dir: &Path, prefix: &str, out: &mut String, mods: &mut String) -> Result<(), String> { + let Ok(entries) = std::fs::read_dir(dir) else { return Ok(()) }; + let mut files: Vec = entries.filter_map(|e| e.ok().map(|e| e.path())).filter(|p| p.extension().is_some_and(|x| x == "rs")).collect(); + files.sort(); + for path in files { + let name = path.file_stem().and_then(|s| s.to_str()).unwrap_or_default().to_string(); + if name.is_empty() || !name.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-') { + return Err(format!("{}: name a format change file with lowercase letters, digits and dashes", path.display())); + } + let text = std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?; + if !text.trim_start().starts_with("//!") { + return Err(format!("{}: start a format change with a `//!` note", path.display())); + } + let module = format!("{prefix}_{}", name.replace('-', "_")); + let step = if text.contains("fn step(") { format!("Some({module}::step)") } else { "None".into() }; + let _ = writeln!(out, " Part {{ name: {name:?}, step: {step} }},"); + let _ = writeln!(mods, "#[path = {:?}]\nmod {module};", path.display().to_string()); + } + Ok(()) +} diff --git a/crates/format/src/container.rs b/crates/format/src/container.rs new file mode 100644 index 000000000..a987bb1fb --- /dev/null +++ b/crates/format/src/container.rs @@ -0,0 +1,401 @@ +//! The file container: a ZIP package of named parts (the file's JSON, binary payloads, optional +//! caches), never extracted to filesystem paths. Payloads are content-addressed blobs, +//! `blobs/.`, stored once however often they are referred to. Every size is +//! bounded by the app's [`Limits`]: the file, each part, all parts expanded, the payloads resolved, +//! and the number of entries; a part is read no further than its declared size (a decompression +//! bomb stops there). What a part holds, and how a payload is encoded, is the app's. + +use std::collections::{BTreeMap, BTreeSet}; +use std::io::{Cursor, Read, Seek, SeekFrom, Write}; +use std::sync::Arc; + +use serde_json::Value; +use sha2::{Digest, Sha256}; + +use crate::FormatError; + +/// How hard the payloads are compressed: Fast favours interactive file operations; Compact trades +/// CPU time for space. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum Compression { + #[default] + Fast, + Compact, +} + +/// An app's budgets for its containers. The functions are read each time they are needed, so a +/// limit the app lets the user raise takes effect at once. +#[derive(Clone, Copy)] +pub struct Limits { + /// The most entries a container holds. + pub max_entries: usize, + /// The most bytes all parts may expand to, and all payloads may resolve to. + pub max_expanded: fn() -> usize, + /// The most bytes a part of this name may expand to. + pub part_limit: fn(&str) -> usize, + /// The Deflate level of a compressed part of this name and size. + pub level: fn(&str, usize) -> i64, + /// Whether a container of this many bytes may be read, or why not. + pub check_size: fn(u64) -> Result<(), String>, + /// Whether the work is cancelled (a save the person stopped): a long part is written a piece + /// at a time and stops before the next piece when this says so. `None`: it cannot be + /// cancelled here. + pub cancelled: Option bool>, +} + +fn invalid(message: impl std::fmt::Display) -> FormatError { + FormatError::Invalid(message.to_string()) +} + +/// Whether the bytes start as a container does, whatever the file is called. +pub fn is_container(bytes: &[u8]) -> bool { + bytes.starts_with(b"PK\x03\x04") +} + +/// The SHA-256 of the bytes. +pub fn sha256(bytes: &[u8]) -> [u8; 32] { + Sha256::digest(bytes).into() +} + +fn hex(digest: &[u8; 32]) -> String { + use std::fmt::Write as _; + let mut out = String::with_capacity(64); + for byte in digest { + // Writing to a `String` cannot fail. + let _ = write!(&mut out, "{byte:02x}"); + } + out +} + +/// The SHA-256 of the bytes, in lowercase hexadecimal: a blob's name, and how a cache is keyed to +/// the file it was written for. +pub fn digest(bytes: &[u8]) -> String { + hex(&sha256(bytes)) +} + +/// One part a [`Writer`] wrote, with the SHA-256 of its uncompressed content. A caller that signs +/// a container uses these to bind the parts without reading the file back. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct PartDigest { + pub name: String, + pub len: u64, + pub digest: [u8; 32], +} + +/// A container being written. +pub struct Writer { + zip: zip::ZipWriter>>, + names: BTreeSet, + expanded: usize, + resolved: usize, + limits: Limits, + /// Which written parts to record for a signature, and the records so far. + tracked: Option<(fn(&str) -> bool, Vec)>, +} + +impl Writer { + pub fn new(limits: Limits) -> Writer { + Writer { zip: zip::ZipWriter::new(Cursor::new(Vec::new())), names: BTreeSet::new(), expanded: 0, resolved: 0, limits, tracked: None } + } + + /// Record the parts written from now on whose name `include` accepts, with their SHA-256, for + /// [`Writer::take_parts`]. Used by a caller that signs the container. + pub fn track_parts(&mut self, include: fn(&str) -> bool) { + self.tracked = Some((include, Vec::new())); + } + + /// The tracked parts written so far, oldest first, and stop tracking. + pub fn take_parts(&mut self) -> Option> { + self.tracked.take().map(|(_, parts)| parts) + } + + /// The container's bytes. + pub fn finish(self) -> Result, FormatError> { + Ok(self.zip.finish().map_err(invalid)?.into_inner()) + } + + /// Add a part, compressed or stored. A name already written is written once. + pub fn part(&mut self, name: &str, bytes: &[u8], compressed: bool) -> Result<(), FormatError> { + self.part_with_digest(name, bytes, compressed, None) + } + + /// [`Writer::part`] with a digest the caller already worked out (a blob's name is its digest), + /// so a signed save does not hash the same bytes twice. + fn part_with_digest(&mut self, name: &str, bytes: &[u8], compressed: bool, digest: Option<[u8; 32]>) -> Result<(), FormatError> { + if bytes.len() > (self.limits.part_limit)(name) { + return Err(invalid("part too large")); + } + if !self.names.insert(name.to_owned()) { + return Ok(()); + } + self.expanded = self.expanded.checked_add(bytes.len()).ok_or_else(|| invalid("expanded size overflow"))?; + if self.expanded > (self.limits.max_expanded)() || self.names.len() > self.limits.max_entries { + return Err(invalid("package too large")); + } + if let Some((include, parts)) = &mut self.tracked + && include(name) + { + let digest = digest.unwrap_or_else(|| sha256(bytes)); + parts.push(PartDigest { name: name.to_owned(), len: bytes.len() as u64, digest }); + } + let method = if compressed { zip::CompressionMethod::Deflated } else { zip::CompressionMethod::Stored }; + let level = (self.limits.level)(name, bytes.len()); + // A part of 4 GiB or more (only with a raised file limit) needs a ZIP64 entry. + let options = zip::write::SimpleFileOptions::default() + .compression_method(method) + .compression_level(compressed.then_some(level)) + .large_file(bytes.len() as u64 >= u64::from(u32::MAX)); + self.zip.start_file(name, options).map_err(invalid)?; + // A piece at a time: a long compression (a large mesh or model cache) stops on Cancel + // within a piece instead of after the whole part. + for piece in bytes.chunks(1 << 20) { + if self.limits.cancelled.is_some_and(|cancelled| cancelled()) { + return Err(FormatError::Cancelled); + } + self.zip.write_all(piece).map_err(invalid)?; + } + Ok(()) + } + + /// Would `entries` more optional parts of `extra` bytes, stored uncompressed, still keep the + /// file within `budget` and its expanded size within the reader's budget? + pub fn room(&self, entries: usize, extra: usize, budget: usize) -> bool { + self.names.len().saturating_add(entries) <= self.limits.max_entries && extra <= self.space(entries, budget) + } + + /// The bytes `entries` more optional parts may hold together ([`Writer::room`]). + pub fn space(&self, entries: usize, budget: usize) -> usize { + if self.names.len().saturating_add(entries) > self.limits.max_entries { + return 0; + } + // The bytes written so far, plus what the open compressed part may still hold back. + let written = self.zip.get_ref().map_or(usize::MAX, |c| c.get_ref().len()).saturating_add(1 << 20); + let directory = self.names.len().saturating_add(entries).saturating_mul(256).saturating_add(65_536); + budget.saturating_sub(written.saturating_add(directory)).min((self.limits.max_expanded)().saturating_sub(self.expanded)) + } + + /// Add a payload as a blob, `blobs/.`, and say its name, for the JSON that + /// refers to it. + pub fn blob(&mut self, bytes: &[u8], extension: &str, compressed: bool) -> Result { + self.resolved = self + .resolved + .checked_add(bytes.len()) + .filter(|&n| n <= (self.limits.max_expanded)()) + .ok_or_else(|| invalid("resolved payloads too large"))?; + let digest = sha256(bytes); + let name = format!("blobs/{}.{extension}", hex(&digest)); + self.part_with_digest(&name, bytes, compressed, Some(digest))?; + Ok(Value::String(name)) + } +} + +/// A container being read, over a seekable source. Opening checks the directory (the entry count, +/// unique and plain names, every part's declared size), not the parts. +pub struct Reader { + zip: zip::ZipArchive, + blobs: BTreeMap>, + /// The bytes of payloads resolved so far, repeats counted: bounded by the expanded budget. + pub hydrated: usize, + document: Option>, + limits: Limits, +} + +impl Reader { + pub fn new(mut source: R, limits: Limits) -> Result { + let length = source.seek(SeekFrom::End(0)).map_err(invalid)?; + (limits.check_size)(length).map_err(invalid)?; + let tail_length = length.min(65_557) as usize; + source.seek(SeekFrom::Start(length - tail_length as u64)).map_err(invalid)?; + let mut tail = vec![0; tail_length]; + source.read_exact(&mut tail).map_err(invalid)?; + // zip's name index can coalesce duplicate central-directory entries. The bounded format + // does not need ZIP64/multiple disks: verify the declared entry count as well so + // duplicate names cannot silently select a payload. + let eocd = tail.windows(4).rposition(|v| v == b"PK\x05\x06").ok_or_else(|| invalid("missing ZIP directory"))?; + let end = tail.get(eocd..).filter(|v| v.len() >= 22).ok_or_else(|| invalid("truncated ZIP directory"))?; + let u16_at = |offset| -> Result { + let array: [u8; 2] = end.get(offset..offset + 2).ok_or_else(|| invalid("truncated ZIP directory"))?.try_into().map_err(invalid)?; + Ok(u16::from_le_bytes(array)) + }; + let declared = u16_at(10)? as usize; + if declared > limits.max_entries + || u16_at(4)? != 0 + || u16_at(6)? != 0 + || u16_at(8)? as usize != declared + || end.len() != 22 + u16_at(20)? as usize + { + return Err(invalid("too many entries or unsupported ZIP directory")); + } + // A container is a ZIP with nothing in front of it. Saying so skips zip's search for a + // prefix, which reads back through the stored parts and would load a large payload + // before a preview can be shown. + let config = zip::read::Config { archive_offset: zip::read::ArchiveOffset::Known(0) }; + let mut zip = zip::ZipArchive::with_config(config, source).map_err(invalid)?; + if u16_at(4)? != 0 + || u16_at(6)? != 0 + || u16_at(8)? as usize != zip.len() + || u16_at(10)? as usize != zip.len() + || end.len() != 22 + u16_at(20)? as usize + { + return Err(invalid("duplicate entries or unsupported ZIP directory")); + } + let mut names = BTreeSet::new(); + let mut total = 0u64; + for i in 0..zip.len() { + let part = zip.by_index_raw(i).map_err(invalid)?; + let name = part.name().map_err(invalid)?.into_owned(); + if name.is_empty() + || name.contains('\\') + || name.split('/').any(|c| c.is_empty() || c == "." || c == "..") + || !names.insert(name.to_owned()) + { + return Err(invalid("duplicate or invalid archive entry")); + } + total = total.checked_add(part.size()).ok_or_else(|| invalid("expanded size overflow"))?; + let limit = (limits.part_limit)(&name); + if part.size() > limit as u64 || total > (limits.max_expanded)() as u64 { + return Err(invalid("expanded package too large")); + } + } + Ok(Self { zip, blobs: BTreeMap::new(), hydrated: 0, document: None, limits }) + } + + /// The file's own part, `document.json`, read once and kept: provisional caches and the + /// authoritative reading are bound to the same bytes, even if another process overwrites the + /// open file in place. Blobs remain hash-checked. + pub fn document(&mut self, limit: usize) -> Result, FormatError> { + if self.document.is_none() { + self.document = Some(self.limited_part("document.json", limit)?.into()); + } + self.document.as_ref().filter(|d| d.len() <= limit).cloned().ok_or_else(|| invalid("metadata budget")) + } + + /// Whether the container has a part of this name. + pub fn has_part(&self, name: &str) -> bool { + self.zip.index_for_name(name).is_some() + } + + /// The names of every part, in the container's order. + pub fn part_names(&self) -> Vec { + self.zip.file_names().filter_map(|name| name.ok().map(|name| name.into_owned())).collect() + } + + /// The part of this name, at most `limit` bytes. + pub fn limited_part(&mut self, name: &str, limit: usize) -> Result, FormatError> { + let part = self.zip.by_name(name).map_err(|e| invalid(format!("required part `{name}`: {e}")))?; + let expected = part.size(); + if expected > limit as u64 { + return Err(invalid("part too large")); + } + let mut bytes = Vec::new(); + bytes.try_reserve_exact(expected as usize).map_err(|_| invalid("could not reserve required part"))?; + // A compressed part may expand beyond its declared size (a decompression bomb): stop + // one byte past it instead of at the limit. + part.take(expected + 1).read_to_end(&mut bytes).map_err(invalid)?; + if bytes.len() > limit || bytes.len() as u64 != expected { + return Err(invalid("part too large or length mismatch")); + } + Ok(bytes) + } + + /// The blob `value`'s `field` names, of this extension, within its part limit. + pub fn blob(&mut self, value: &Value, field: &str, extension: &str) -> Result<&[u8], FormatError> { + let limit = (self.limits.part_limit)(&format!("blob.{extension}")); + self.limited_blob(value, field, extension, limit) + } + + /// [`Reader::blob`] within `limit` bytes. Its hash is checked when it is first read, and every + /// reference counts against the resolved budget. + pub fn limited_blob(&mut self, value: &Value, field: &str, extension: &str, limit: usize) -> Result<&[u8], FormatError> { + let name = value.get(field).and_then(Value::as_str).ok_or_else(|| invalid(format!("missing `{field}` reference")))?; + let hash = name + .strip_prefix("blobs/") + .and_then(|n| n.strip_suffix(&format!(".{extension}"))) + .filter(|h| h.len() == 64 && h.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))) + .ok_or_else(|| invalid("invalid blob reference"))?; + if !self.blobs.contains_key(name) { + let bytes = self.limited_part(name, limit)?; + if digest(&bytes) != hash { + return Err(invalid(format!("blob hash mismatch: {name}"))); + } + self.blobs.insert(name.to_owned(), bytes); + } + let bytes = self.blobs.get(name).ok_or_else(|| invalid("missing blob"))?; + if bytes.len() > limit { + return Err(invalid("blob exceeds its resource budget")); + } + // Count repeated references too: a tiny archive must not expand into unbounded owned + // strings or arrays when the same blob is referenced repeatedly. + self.hydrated = self + .hydrated + .checked_add(bytes.len()) + .filter(|&n| n <= (self.limits.max_expanded)()) + .ok_or_else(|| invalid("resolved payloads too large"))?; + Ok(bytes) + } +} + +/// A small PNG picture of the file, kept in the container as a disposable cache keyed to the +/// exact file it shows: `cache/thumbnail.json` (its key) and `cache/thumbnail.png`. Reading it +/// never resolves a payload; a picture that isn't one, or is stale, is a miss. +#[derive(Clone, Copy, Debug)] +pub struct Thumbnail { + /// The key's format tag. + pub format: &'static str, + /// The build that wrote it: only the same build reads it back. + pub app: &'static str, + /// Its width and height in pixels. + pub size: [usize; 2], + /// The most bytes it may have. + pub max_bytes: usize, +} + +impl Thumbnail { + /// Whether the bytes start as a PNG of this size within the byte budget (not a decode: a + /// consumer decodes with its own dimension and allocation limits). + pub fn valid(&self, bytes: &[u8]) -> bool { + bytes.len() <= self.max_bytes + && bytes.get(..8) == Some(b"\x89PNG\r\n\x1a\n") + && bytes.get(8..16) == Some(b"\0\0\0\rIHDR") + && bytes.get(16..20) == Some((self.size[0] as u32).to_be_bytes().as_slice()) + && bytes.get(20..24) == Some((self.size[1] as u32).to_be_bytes().as_slice()) + } + + /// Add the picture, keyed to `document` (the file's own part), when it is one and there is + /// room for it within `budget`; otherwise leave it out, never failing the save. + pub fn write(&self, writer: &mut Writer, png: &[u8], document: &[u8], budget: usize) -> Result<(), FormatError> { + if !self.valid(png) { + return Ok(()); + } + let key = + serde_json::to_vec(&serde_json::json!({"format": self.format, "app": self.app, "document": digest(document), "payload": digest(png)})) + .map_err(invalid)?; + if !writer.room(2, key.len().saturating_add(png.len()), budget) { + return Ok(()); + } + writer.part("cache/thumbnail.json", &key, false)?; + writer.part("cache/thumbnail.png", png, false) + } + + /// The picture, when this build wrote it for exactly the file's own part (`document.json`, + /// read within `document_limit`). + pub fn read(&self, reader: &mut Reader, document_limit: usize) -> Result, FormatError> { + let key: Value = serde_json::from_slice(&reader.limited_part("cache/thumbnail.json", 4096)?).map_err(invalid)?; + let document = reader.document(document_limit)?; + if key.get("format").and_then(Value::as_str) != Some(self.format) + || key.get("app").and_then(Value::as_str) != Some(self.app) + || key.get("document").and_then(Value::as_str) != Some(digest(&document).as_str()) + { + return Err(invalid("thumbnail key")); + } + let png = reader.limited_part("cache/thumbnail.png", self.max_bytes)?; + if !self.valid(&png) || key.get("payload").and_then(Value::as_str) != Some(digest(&png).as_str()) { + return Err(invalid("thumbnail payload")); + } + Ok(png) + } +} + +#[cfg(test)] +#[path = "container_tests.rs"] +mod tests; diff --git a/crates/format/src/container_tests.rs b/crates/format/src/container_tests.rs new file mode 100644 index 000000000..bda37d000 --- /dev/null +++ b/crates/format/src/container_tests.rs @@ -0,0 +1,67 @@ +use super::*; + +const LIMITS: Limits = Limits { + max_entries: 8, + max_expanded: || 1 << 20, + part_limit: |name| if name.ends_with(".big") { 1 << 20 } else { 1024 }, + level: |_, _| 1, + check_size: |length| if length <= 1 << 20 { Ok(()) } else { Err("too large".into()) }, + cancelled: None, +}; + +/// Parts and blobs written are read back as they were; a blob is stored once, named by its hash, +/// and checked against it. +#[test] +fn parts_and_blobs_read_back() { + let mut writer = Writer::new(LIMITS); + writer.part("document.json", br#"{"a":1}"#, true).unwrap(); + let first = writer.blob(b"payload", "bin", false).unwrap(); + let again = writer.blob(b"payload", "bin", true).unwrap(); + assert_eq!(first, again, "the same payload is one blob"); + assert_eq!(first, Value::String(format!("blobs/{}.bin", digest(b"payload")))); + let bytes = writer.finish().unwrap(); + assert!(is_container(&bytes)); + let mut reader = Reader::new(Cursor::new(bytes), LIMITS).unwrap(); + assert_eq!(reader.part_names().len(), 2); + assert!(reader.has_part("document.json") && !reader.has_part("other.json")); + assert_eq!(&*reader.document(64).unwrap(), br#"{"a":1}"#); + let reference = serde_json::json!({"blob": first}); + assert_eq!(reader.blob(&reference, "blob", "bin").unwrap(), b"payload"); + assert!(reader.blob(&reference, "blob", "png").is_err(), "another extension"); + assert_eq!(reader.hydrated, 7); + reader.hydrated = (LIMITS.max_expanded)(); + assert!(reader.blob(&reference, "blob", "bin").unwrap_err().to_string().contains("resolved payloads too large")); +} + +/// A part past its limit, or more entries than the limit, are refused as they are written. +#[test] +fn budgets_are_kept_when_writing() { + let mut writer = Writer::new(LIMITS); + assert_eq!(writer.part("small.json", &[0; 1025], false), Err(FormatError::Invalid("part too large".into()))); + assert!(writer.part("large.big", &[0; 1025], true).is_ok()); + for i in 0..7 { + writer.part(&format!("{i}.json"), b"x", false).unwrap(); + } + assert_eq!(writer.part("one-more.json", b"x", false), Err(FormatError::Invalid("package too large".into()))); + assert!(!writer.room(1, 0, 1 << 20), "no room for an entry past the limit"); +} + +/// A thumbnail is kept only for the file it shows. +#[test] +fn a_thumbnail_is_keyed_to_its_file() { + let picture = Thumbnail { format: "app-thumbnail/1", app: "1.0", size: [2, 1], max_bytes: 1024 }; + let mut png = b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR".to_vec(); + png.extend_from_slice(&2u32.to_be_bytes()); + png.extend_from_slice(&1u32.to_be_bytes()); + assert!(picture.valid(&png)); + let mut writer = Writer::new(LIMITS); + writer.part("document.json", b"{}", false).unwrap(); + picture.write(&mut writer, &png, b"{}", 8 << 20).unwrap(); + let mut reader = Reader::new(Cursor::new(writer.finish().unwrap()), LIMITS).unwrap(); + assert_eq!(picture.read(&mut reader, 64).unwrap(), png); + let mut writer = Writer::new(LIMITS); + writer.part("document.json", b"{\"changed\":1}", false).unwrap(); + picture.write(&mut writer, &png, b"{}", 8 << 20).unwrap(); + let mut reader = Reader::new(Cursor::new(writer.finish().unwrap()), LIMITS).unwrap(); + assert!(picture.read(&mut reader, 64).is_err(), "stale"); +} diff --git a/crates/format/src/lib.rs b/crates/format/src/lib.rs new file mode 100644 index 000000000..8eb495417 --- /dev/null +++ b/crates/format/src/lib.rs @@ -0,0 +1,252 @@ +//! Versioned file formats: what an app needs to read every file it ever wrote, and to open a file +//! a newer build of it wrote. +//! +//! A file starts with `"format": "N"`. A [`Family`] is one kind of file (an app's designs, +//! its drawings): its tag, its own numbers, and how a file of an older number is brought up to +//! this build's, step by step (N → N+1 → … → current). The app's code only knows the current +//! format; all translation lives in the steps: +//! - the steps written out by hand for the first formats, one per format ([`Formats::hand`]); +//! - then one folder per format, `v/`, one file per change in it ([`Part`]), each with a step +//! when files from before the change are rewritten as they open ([`Formats::folded`]); +//! - then the changes no release has a number for yet, in `pending/` ([`Formats::pending`]): +//! while there are any, the build writes the next number, with their names in the file's +//! `format_pending`, so a later build runs just the steps a file is missing. A release moves +//! them into the next `v/`. [`build`] lists the folders for a build script. +//! +//! A file a newer build wrote says so by a number past this build's or a change name this build +//! doesn't have ([`Family::newer`]); the app then reads what it can and keeps the rest +//! ([`newer`]). A file is saved as JSON, or in a [`container`] with its binary payloads. +//! +//! Steps are JSON-level (the file's shape) and return the app's own error type; every error this +//! crate makes is a [`FormatError`], which the app's error type takes `From`. + +use serde_json::Value; + +pub mod build; +pub mod container; +pub mod newer; + +/// Why a file is refused: its text says what is wrong, as the user reads it. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum FormatError { + /// The file isn't one of the family's, or it is damaged. + Invalid(String), + /// The work was cancelled (a save the person stopped): nothing more was written. + Cancelled, +} + +impl std::fmt::Display for FormatError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + FormatError::Invalid(why) => f.write_str(why), + FormatError::Cancelled => f.write_str("cancelled"), + } + } +} + +impl std::error::Error for FormatError {} + +/// One JSON-level upgrade step: rewrites a file in place, or says why it can't. +pub type Step = fn(&mut Value) -> Result<(), E>; + +/// One change to a family's file format: a file in its `v/` or `pending/` folder. +pub struct Part { + /// The file's name, which a file written while the change was pending lists. + pub name: &'static str, + /// How a file from before the change is rewritten as it opens, if it is. + pub step: Option>, +} + +/// Another spelling of a change name that a file of one format may carry (a build that named the +/// change otherwise): read as the change it stands for, never written. +#[derive(Clone, Copy, Debug)] +pub struct Alias { + /// The format whose files may say it. + pub format: u32, + /// The spelling in the file. + pub name: &'static str, + /// The change it stands for. + pub known_as: &'static str, +} + +/// A family's upgrade path: the steps written out by hand, the folded formats after them (each a +/// list of changes) and the pending changes, which make the next format. +pub struct Formats<'a, E> { + /// Entry `i` turns format `i + 1` into `i + 2`. + pub hand: &'a [Step], + /// Each format after the hand-written ones, oldest first, and its changes. + pub folded: &'a [(u32, &'a [Part])], + /// The changes no release has a number for yet. + pub pending: &'a [Part], +} + +/// A kind of file whose format is versioned: its own format tag, its own numbers and its own +/// changes. Reading a file's format, telling a file a newer build saved and the upgrade are the +/// same for every family. +pub struct Family<'a, E> { + /// The app, as messages name it. + pub app: &'static str, + /// What a file of the family is called in messages. + pub noun: &'static str, + /// The tag before the number in a file's `format`. + pub prefix: &'static str, + /// The tag files saved under an older name carry: read, never written. + pub legacy_prefix: Option<&'static str>, + /// The format of a file that names none, if such files exist. + pub untagged: Option, + /// Other spellings of change names that files may carry. + pub aliases: &'a [Alias], + /// The upgrade path. + pub formats: Formats<'a, E>, +} + +/// How a file shows a newer build saved it ([`Family::newer`]). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Newer { + /// The number the file says. + pub format: u32, + /// The number this build reads up to. + pub reads_up_to: u32, + /// The changes the file names that this build doesn't have. + pub unknown_changes: Vec, +} + +impl Formats<'_, E> { + /// The format this build writes: the last folded one, or the next while changes are pending. + pub const fn current(&self) -> u32 { + self.hand.len() as u32 + 1 + self.folded.len() as u32 + if self.pending.is_empty() { 0 } else { 1 } + } + + /// The changes format `version` is made of, if it is made of changes. + fn parts(&self, version: u32) -> Option<&[Part]> { + let after = version.checked_sub(self.hand.len() as u32 + 2)? as usize; + match self.folded.get(after) { + Some((_, parts)) => Some(parts), + None if after == self.folded.len() && !self.pending.is_empty() => Some(self.pending), + None => None, + } + } + + /// Whether a change of this name is anywhere in this build's history. + fn knows_part_name(&self, name: &str) -> bool { + self.folded.iter().flat_map(|(_, parts)| *parts).chain(self.pending).any(|part| part.name == name) + } +} + +impl Family<'_, E> { + /// The format this build writes: the last folded one, or the next while changes are pending. + pub const fn current(&self) -> u32 { + self.formats.current() + } + + /// What a file of the family is called in messages. + pub const fn noun(&self) -> &'static str { + self.noun + } + + /// The names of the pending changes this build writes into a file (`format_pending`). + pub fn pending_names(&self) -> Vec { + self.formats.pending.iter().map(|p| p.name.to_string()).collect() + } + + /// The format tag of format `n`. + pub fn format_string(&self, n: u32) -> String { + format!("{}{n}", self.prefix) + } + + /// The version in one of this family's format tags; `None` for any other tag, another + /// family's included. + pub fn version_of(&self, s: &str) -> Option { + s.strip_prefix(self.prefix).or_else(|| self.legacy_prefix.and_then(|p| s.strip_prefix(p)))?.parse().ok() + } + + /// The change a name a file of format `version` lists stands for: its alias's, or itself. + /// An alias counts only while this build has the change it stands for, so recognising it + /// never grants support to another reader. + fn canonical_applied_name<'name>(&self, version: u32, name: &'name str) -> &'name str { + match self.aliases.iter().find(|a| a.format == version && a.name == name) { + Some(alias) if self.formats.knows_part_name(alias.known_as) => alias.known_as, + _ => name, + } + } + + /// What says a file of format `version` with the changes `applied` came from a newer build: + /// a number past this build's, or a change this build doesn't have anywhere in its history + /// (a branch's pending change may have landed at a later number). A list beside a format that + /// isn't made of changes means nothing (a tool or a test set an older number on a newer file). + /// `None` for a file this build fully knows. + pub fn newer(&self, version: u32, applied: Option<&[String]>) -> Option { + let current = self.current(); + let listed = applied.filter(|_| version > current || self.formats.parts(version).is_some()).unwrap_or_default(); + let unknown_changes: Vec = + listed.iter().filter(|name| !self.formats.knows_part_name(self.canonical_applied_name(version, name))).cloned().collect(); + (version > current || !unknown_changes.is_empty()).then_some(Newer { format: version, reads_up_to: current, unknown_changes }) + } +} + +impl> Family<'_, E> { + /// Read a file's format and take its `format_pending` out of its JSON, before anything else + /// in it is read: a file that isn't this family's is refused here. One a newer build saved is + /// not: [`Family::newer`] says so. + pub fn take_version(&self, v: &mut Value) -> Result<(u32, Option>), E> { + let (app, noun) = (self.app, self.noun); + let not_ours = |what: String| E::from(FormatError::Invalid(format!("not a {app} {noun} ({what})"))); + let Some(obj) = v.as_object() else { return Err(not_ours("expected a JSON object".into())) }; + let version = match obj.get("format") { + None => self.untagged.ok_or_else(|| not_ours("no format".into()))?, + Some(Value::String(f)) => self.version_of(f).ok_or_else(|| not_ours(format!("format `{f}`")))?, + Some(_) => return Err(not_ours("format is not a string".into())), + }; + let applied = take_names(v, "format_pending", noun).map_err(E::from)?; + if version == 0 { + return Err(not_ours("format 0".into())); + } + Ok((version, applied)) + } + + /// Bring a file of format `version` up to this build's; `applied` is its `format_pending` + /// (both from [`Family::take_version`]): the changes of its format it already has, when it + /// was written while they were pending. The others' steps run first, and already-applied + /// changes never run again at their later number. A file past this build's number has no + /// steps to run. + pub fn upgrade(&self, v: &mut Value, version: u32, applied: Option<&[String]>) -> Result<(), E> { + let formats = &self.formats; + if version == 0 { + return Err(E::from(FormatError::Invalid(format!("not a {} {} (format 0)", self.app, self.noun)))); + } + // A list beside a format that isn't made of changes is ignored, like any field an upgrade + // drops. + let applied = applied.filter(|_| formats.parts(version).is_some()); + let already_applied = + |part: &Part| applied.is_some_and(|names| names.iter().any(|name| self.canonical_applied_name(version, name) == part.name)); + if applied.is_some() { + for part in formats.parts(version).unwrap_or_default().iter().filter(|part| !already_applied(part)) { + part.step.map_or(Ok(()), |step| step(v))?; + } + } + for from in version..self.current() { + match formats.hand.get(from as usize - 1) { + Some(step) => step(v)?, + None => { + for part in formats.parts(from + 1).unwrap_or_default().iter().filter(|part| !already_applied(part)) { + part.step.map_or(Ok(()), |step| step(v))?; + } + } + } + } + Ok(()) + } +} + +/// Take a short list of names out of a file's JSON: its `format_pending` (the pending changes it +/// has). +fn take_names(v: &mut Value, key: &str, noun: &str) -> Result>, FormatError> { + let Some(list) = v.as_object_mut().and_then(|o| o.remove(key)) else { return Ok(None) }; + let invalid = || FormatError::Invalid(format!("damaged {noun}: `{key}` is not a short list of names")); + let list = list.as_array().filter(|l| l.len() <= 1000).ok_or_else(invalid)?; + list.iter().map(|n| n.as_str().filter(|n| n.len() <= 128).map(str::to_string).ok_or_else(invalid)).collect::>().map(Some) +} + +#[cfg(test)] +#[path = "lib_tests.rs"] +mod tests; diff --git a/crates/format/src/lib_tests.rs b/crates/format/src/lib_tests.rs new file mode 100644 index 000000000..6874ddbf4 --- /dev/null +++ b/crates/format/src/lib_tests.rs @@ -0,0 +1,134 @@ +use super::*; +use serde_json::json; + +/// The app's error, as an app has one. +#[derive(Debug, PartialEq)] +struct AppError(String); + +impl From for AppError { + fn from(e: FormatError) -> Self { + AppError(e.to_string()) + } +} + +/// Each step appends its name to the file's `log`, so the order steps ran in can be read back. +fn log(v: &mut Value, step: &str) { + if let Some(list) = v.get_mut("log").and_then(Value::as_array_mut) { + list.push(json!(step)); + } +} + +const HAND: [Step; 2] = [ + |v| { + log(v, "1to2"); + Ok(()) + }, + |v| { + log(v, "2to3"); + Ok(()) + }, +]; +const V4: [Part; 2] = [ + Part { + name: "a", + step: Some(|v| { + log(v, "a"); + Ok(()) + }), + }, + Part { name: "b", step: None }, +]; +const V5: [Part; 1] = [Part { + name: "c", + step: Some(|v| { + log(v, "c"); + Ok(()) + }), +}]; +const FOLDED: [(u32, &[Part]); 2] = [(4, &V4), (5, &V5)]; +const PENDING: [Part; 2] = [ + Part { + name: "d", + step: Some(|v| { + log(v, "d"); + Ok(()) + }), + }, + Part { + name: "e", + step: Some(|v| { + log(v, "e"); + Ok(()) + }), + }, +]; +const ALIASES: [Alias; 1] = [Alias { format: 5, name: "old-c", known_as: "c" }]; + +/// Format 1 untagged; hand steps to 3; folded 4 and 5; pending changes make 6. +const FAMILY: Family<'static, AppError> = Family { + app: "App", + noun: "design", + prefix: "app/", + legacy_prefix: Some("old/"), + untagged: Some(1), + aliases: &ALIASES, + formats: Formats { hand: &HAND, folded: &FOLDED, pending: &PENDING }, +}; + +fn steps_run(version: u32, applied: Option<&[String]>) -> Vec { + let mut v = json!({"log": []}); + FAMILY.upgrade(&mut v, version, applied).unwrap(); + v["log"].as_array().unwrap().iter().map(|s| s.as_str().unwrap().to_string()).collect() +} + +#[test] +fn tags_and_numbers() { + assert_eq!(FAMILY.current(), 6); + assert_eq!(FAMILY.format_string(6), "app/6"); + assert_eq!(FAMILY.version_of("app/4"), Some(4)); + assert_eq!(FAMILY.version_of("old/3"), Some(3), "the legacy tag is read"); + assert_eq!(FAMILY.version_of("other/3"), None); + assert_eq!(FAMILY.pending_names(), vec!["d".to_string(), "e".to_string()]); +} + +#[test] +fn a_file_is_taken_apart_or_refused_with_the_apps_words() { + let mut v = json!({"format": "app/6", "format_pending": ["d"], "x": 1}); + assert_eq!(FAMILY.take_version(&mut v), Ok((6, Some(vec!["d".to_string()])))); + assert!(v.get("format_pending").is_none(), "taken out"); + assert_eq!(FAMILY.take_version(&mut json!({})), Ok((1, None)), "untagged"); + let refused = |mut v: Value| FAMILY.take_version(&mut v).unwrap_err().0; + assert_eq!(refused(json!([])), "not a App design (expected a JSON object)"); + assert_eq!(refused(json!({"format": "other/2"})), "not a App design (format `other/2`)"); + assert_eq!(refused(json!({"format": 2})), "not a App design (format is not a string)"); + assert_eq!(refused(json!({"format": "app/0"})), "not a App design (format 0)"); + assert_eq!(refused(json!({"format": "app/2", "format_pending": [1]})), "damaged design: `format_pending` is not a short list of names"); +} + +#[test] +fn every_step_runs_once_in_order() { + assert_eq!(steps_run(1, None), ["1to2", "2to3", "a", "c", "d", "e"]); + assert_eq!(steps_run(4, None), ["c", "d", "e"]); + assert_eq!(steps_run(6, None), Vec::::new()); + // A file written while `d` was pending has it: only `e` runs. + assert_eq!(steps_run(6, Some(&["d".to_string()])), ["e"]); + // A file of format 5 written while `c` was still pending, without it: `c` runs first. + assert_eq!(steps_run(5, Some(&[])), ["c", "d", "e"]); + // Under its other spelling `c` counts as had. + assert_eq!(steps_run(5, Some(&["old-c".to_string()])), ["d", "e"]); + // A list beside a hand-written format means nothing. + assert_eq!(steps_run(2, Some(&["d".to_string()])), ["2to3", "a", "c", "d", "e"]); + let mut v = json!({}); + assert_eq!(FAMILY.upgrade(&mut v, 0, None), Err(AppError("not a App design (format 0)".into()))); +} + +#[test] +fn a_newer_file_is_told_by_its_number_or_an_unknown_change() { + assert_eq!(FAMILY.newer(6, None), None); + assert_eq!(FAMILY.newer(6, Some(&["d".to_string()])), None); + assert_eq!(FAMILY.newer(7, None), Some(Newer { format: 7, reads_up_to: 6, unknown_changes: Vec::new() })); + assert_eq!(FAMILY.newer(6, Some(&["z".to_string()])), Some(Newer { format: 6, reads_up_to: 6, unknown_changes: vec!["z".to_string()] })); + assert_eq!(FAMILY.newer(5, Some(&["old-c".to_string()])), None, "an alias of a known change"); + assert_eq!(FAMILY.newer(4, Some(&["old-c".to_string()])), Some(Newer { format: 4, reads_up_to: 6, unknown_changes: vec!["old-c".to_string()] })); + assert_eq!(FAMILY.newer(2, Some(&["z".to_string()])), None, "a list beside a hand-written format means nothing"); +} diff --git a/crates/format/src/newer.rs b/crates/format/src/newer.rs new file mode 100644 index 000000000..e9cb51eb1 --- /dev/null +++ b/crates/format/src/newer.rs @@ -0,0 +1,401 @@ +//! A file a newer build saved: it opens, with a warning, and saving it loses nothing. +//! +//! A newer format number, or a change the file names that this build doesn't have, says a newer +//! build saved the file ([`crate::Family::newer`]). It may use nothing this build lacks, so the app +//! reads it as usual. When part of it can't be read, that part stays out of the way and the rest +//! opens: the app reads the elements of its lists it can ([`NewerFile::keep_element`]), then any +//! other top-level section it can't read is left out whole ([`leave_out_unreadable`], +//! [`read_around`]), and a field it doesn't know, which typed reading would drop, is noticed by +//! comparing the file with what was read ([`NewerFile::compare`]). +//! +//! All of these are named in [`NewerFile::not_understood`] and go back into the file when it is +//! saved ([`NewerFile::restore_into`]), as they came. What can't be put back because the file was +//! changed around it is what `restore_into` returns. + +use std::collections::BTreeMap; +use std::sync::Arc; + +use serde_json::{Map, Value, json}; + +use crate::Newer; + +/// The most sections left out one at a time to find the one a file can't be read with. +const MAX_SECTION_TRIES: usize = 64; + +/// What the file says and holds that this build doesn't read. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct NewerFile { + /// The app, as the notice names it. + pub app: &'static str, + /// The number the file says. + pub format: u32, + /// The number this build reads up to. + pub reads_up_to: u32, + /// The changes the file names that this build doesn't have. + pub unknown_changes: Vec, + /// What this build couldn't read, by name. + pub not_understood: Vec, + /// Fields known records lost in typed reading. + kept: Option, + /// Top-level sections left out whole. + sections: Vec

                      , + /// Elements left out of a top-level list: its key and the element. + elements: Vec<(String, Value)>, + /// The parts of a container this build has no use for: name and bytes. A blob only one of the + /// kept pieces refers to is one of them. + pub parts: Vec<(String, Arc<[u8]>)>, + /// The file's `container.json`, when this build doesn't know what it says. + pub container: Option, +} + +#[derive(Clone, Debug, PartialEq)] +struct Section { + key: String, + value: Value, + /// This build's record of the section, without the file's: while it is unchanged, the file's + /// goes back. + empty: Option, +} + +/// The fields of a record that typed reading dropped. +#[derive(Clone, Debug, PartialEq)] +enum Kept { + Field(Value), + Fields(BTreeMap), + Items(Vec<(Anchor, Kept)>), +} + +/// Which element of a list some kept fields belong to. +#[derive(Clone, Debug, PartialEq)] +enum Anchor { + Id(u64), + Name(String), + /// Its place, good only while the list keeps its length. + Index { + at: usize, + of: usize, + }, +} + +impl NewerFile { + /// A file of `app` that `newer` says a newer build saved, nothing left out of it yet. + pub fn new(app: &'static str, newer: &Newer) -> NewerFile { + NewerFile { + app, + format: newer.format, + reads_up_to: newer.reads_up_to, + unknown_changes: newer.unknown_changes.clone(), + ..NewerFile::default() + } + } + + /// What to tell the user, whatever else is said. + pub fn notice(&self) -> String { + let (app, reads, format) = (self.app, self.reads_up_to, self.format); + match self.unknown_changes.first() { + Some(change) if format <= reads => { + format!("Saved by a newer {app} (format {format} with `{change}`, which this version doesn't know). If something's missing, update.") + } + _ => format!("Saved by a newer {app} (format {format}, this version reads up to {reads}). If something's missing, update."), + } + } + + /// Every line to report: the notice, then what couldn't be read, by name. + pub fn warnings(&self) -> Vec { + let unread = self.not_understood.iter().map(|what| format!("Not read: {what}. Saving keeps it.")); + std::iter::once(self.notice()).chain(unread).collect() + } + + /// What a reply says about it. + pub fn report(&self) -> Value { + json!({ + "format": self.format, + "reads_up_to": self.reads_up_to, + "unknown_changes": self.unknown_changes, + "not_understood": self.not_understood, + "notice": self.notice(), + }) + } + + /// Whether the next save needs a container to keep what the file holds: plain JSON has no room + /// for parts beside the file's own. + pub fn needs_container(&self) -> bool { + !self.parts.is_empty() + } + + /// Whether anything kept back names this text (a blob's name in a container). + pub fn mentions(&self, text: &str) -> bool { + fn kept(k: &Kept, text: &str) -> bool { + match k { + Kept::Field(v) => value_mentions(v, text), + Kept::Fields(m) => m.values().any(|x| kept(x, text)), + Kept::Items(l) => l.iter().any(|(_, x)| kept(x, text)), + } + } + self.kept.as_ref().is_some_and(|k| kept(k, text)) + || self.sections.iter().any(|s| value_mentions(&s.value, text)) + || self.elements.iter().any(|(_, v)| value_mentions(v, text)) + } + + /// Say that a section the reader couldn't finish reading is left out. `empty` is what the + /// app writes for the section while it holds nothing, if anything. + pub fn keep_section(&mut self, key: &str, value: Value, empty: Option, why: &str) { + self.not_understood.push(format!("section `{key}` ({why})")); + self.sections.push(Section { key: key.into(), value, empty }); + } + + /// Say that an element of the top-level list `key` is left out, as `note` names it; it goes + /// back at the end of the list when the file is saved. + pub fn keep_element(&mut self, key: &str, element: Value, note: String) { + self.not_understood.push(note); + self.elements.push((key.into(), element)); + } + + /// Compare the file as it reads (`file`, after the same upgrade as what was read) with what was + /// read of it (`known`, its typed record written out): what `known` lacks is kept and named. + /// An object whose `type` is `placeholder_tag` (an element the app kept whole) and the fields + /// in `container_only` (what a container adds beside the file's own) are not compared; nor + /// are the top level's `format` and `format_pending`. + pub fn compare(&mut self, file: &Value, known: &Value, placeholder_tag: &str, container_only: &[&str]) { + let mut paths = Vec::new(); + self.kept = vanished(file, known, "", &mut paths, placeholder_tag, container_only); + self.not_understood.extend(paths); + for section in &mut self.sections { + section.empty = known.get(§ion.key).cloned(); + } + } + + /// Write back what was kept of the file into `value`, the file as this build writes it. + /// Returns what couldn't go back, because the file was changed around it. + pub fn restore_into(&self, value: &mut Value) -> Vec { + let mut lost = Vec::new(); + if let Some(kept) = &self.kept { + apply(kept, value, "", &mut lost); + } + if let Some(top) = value.as_object_mut() { + for section in &self.sections { + if top.get(§ion.key) == section.empty.as_ref() { + top.insert(section.key.clone(), section.value.clone()); + } else { + lost.push(format!("section `{}`, replaced by what was edited here", section.key)); + } + } + for (key, element) in &self.elements { + let name = element.get("name"); + match top.entry(key.clone()).or_insert_with(|| json!([])) { + Value::Array(list) if name.is_none() || !list.iter().any(|x| x.get("name") == name) => list.push(element.clone()), + _ => lost.push(format!("`{key}` element {}, replaced by what was made here", name.and_then(Value::as_str).unwrap_or("unnamed"))), + } + } + } + lost + } +} + +fn value_mentions(v: &Value, text: &str) -> bool { + match v { + Value::String(s) => s == text, + Value::Array(a) => a.iter().any(|x| value_mentions(x, text)), + Value::Object(o) => o.values().any(|x| value_mentions(x, text)), + _ => false, + } +} + +/// The first line of a reader's error, without the list of every kind it knows, and without the +/// `" file: "` its reader starts it with. +pub fn short<'a>(why: &'a str, noun: &str) -> &'a str { + let why = why.split(", expected").next().unwrap_or(why); + why.strip_prefix(&format!("{noun} file: ")).unwrap_or(why) +} + +/// Leave a section out and keep it. A section the file needs is left empty. +fn move_out(top: &mut Map, key: &str, why: &str, noun: &str, file: &mut NewerFile) { + let Some(value) = top.remove(key) else { return }; + file.not_understood.push(format!("section `{key}` ({})", short(why, noun))); + file.sections.push(Section { key: key.into(), value, empty: None }); +} + +/// Every top-level section of `top` that doesn't read by itself (`piece`, the app's reading of a +/// file holding just that section) is left out and kept in `file`. `noun` is what a file of the +/// app's is called, which its reader's errors start with. +pub fn leave_out_unreadable( + top: &mut Map, + file: &mut NewerFile, + noun: &str, + piece: impl Fn(&str, &Value) -> Result<(), E>, +) { + let keys: Vec = top.keys().cloned().collect(); + for key in &keys { + let value = top.get(key).cloned().unwrap_or_default(); + if let Err(why) = piece(key, &value) { + move_out(top, key, &why.to_string(), noun, file); + } + } +} + +/// Read `top` with `attempt`, leaving out the sections it can't be read with: if it doesn't read, +/// each section but the `core` ones (which the file can't be read without) is tried left out alone, +/// and as a last resort every one of them is. What is left out is kept in `file`. The error is the +/// first attempt's, when even the core alone doesn't read. +pub fn read_around( + top: &mut Map, + file: &mut NewerFile, + core: &[&str], + noun: &str, + attempt: impl Fn(&Map) -> Result, +) -> Result { + let first = match attempt(top) { + Ok(doc) => return Ok(doc), + Err(why) => why.to_string(), + }; + // Sections that are fine by themselves but not together with the rest. + let keys: Vec = top.keys().filter(|k| !core.contains(&k.as_str())).cloned().collect(); + // Each try reads the whole file: a file of many sections goes straight to the last resort. + for key in keys.iter().filter(|_| keys.len() <= MAX_SECTION_TRIES) { + let mut without = top.clone(); + without.remove(key); + if let Ok(doc) = attempt(&without) { + move_out(top, key, &first, noun, file); + return Ok(doc); + } + } + let mut bare = top.clone(); + bare.retain(|key, _| core.contains(&key.as_str())); + match attempt(&bare) { + Ok(doc) => { + for key in &keys { + move_out(top, key, &first, noun, file); + } + Ok(doc) + } + Err(_) => Err(first), + } +} + +/// A value a writer leaves out without losing anything: not worth telling anyone about. +pub fn looks_default(v: &Value) -> bool { + match v { + Value::Null => true, + Value::Bool(b) => !b, + Value::Number(n) => n.as_f64() == Some(0.0), + Value::String(s) => s.is_empty(), + Value::Array(a) => a.is_empty(), + Value::Object(o) => o.is_empty(), + } +} + +/// What `raw` has that `known`, what was read of it, doesn't. `paths` gets those fields' names. +fn vanished(raw: &Value, known: &Value, path: &str, paths: &mut Vec, placeholder_tag: &str, container_only: &[&str]) -> Option { + match (raw, known) { + (Value::Object(raw), Value::Object(known)) => { + if known.get("type").and_then(Value::as_str) == Some(placeholder_tag) { + return None; + } + let mut kept = BTreeMap::new(); + for (key, value) in raw { + if container_only.contains(&key.as_str()) || (path.is_empty() && matches!(key.as_str(), "format" | "format_pending")) { + continue; + } + let inner = if path.is_empty() { key.clone() } else { format!("{path}.{key}") }; + match known.get(key) { + None => { + if !looks_default(value) { + paths.push(format!("field `{inner}`")); + } + kept.insert(key.clone(), Kept::Field(value.clone())); + } + Some(known) => { + if let Some(k) = vanished(value, known, &inner, paths, placeholder_tag, container_only) { + kept.insert(key.clone(), k); + } + } + } + } + (!kept.is_empty()).then_some(Kept::Fields(kept)) + } + (Value::Array(raw), Value::Array(known)) => { + let mut items = Vec::new(); + for (at, element) in raw.iter().enumerate() { + let anchor = anchor_of(element).unwrap_or(Anchor::Index { at, of: raw.len() }); + let Some(partner) = find(known, &anchor) else { continue }; + let label = match (element.get("name").and_then(Value::as_str), &anchor) { + (Some(name), _) => format!("{path}[{name}]"), + (None, Anchor::Id(id)) => format!("{path}[{id}]"), + _ => format!("{path}[{at}]"), + }; + if let Some(k) = vanished(element, partner, &label, paths, placeholder_tag, container_only) { + items.push((anchor, k)); + } + } + (!items.is_empty()).then_some(Kept::Items(items)) + } + _ => None, + } +} + +fn anchor_of(element: &Value) -> Option { + if let Some(id) = element.get("id").and_then(Value::as_u64) { + return Some(Anchor::Id(id)); + } + element.get("name").and_then(Value::as_str).map(|name| Anchor::Name(name.to_string())) +} + +fn find<'a>(list: &'a [Value], anchor: &Anchor) -> Option<&'a Value> { + match anchor { + Anchor::Id(id) => list.iter().find(|x| x.get("id").and_then(Value::as_u64) == Some(*id)), + Anchor::Name(name) => list.iter().find(|x| x.get("name").and_then(Value::as_str) == Some(name)), + Anchor::Index { at, of } => (list.len() == *of).then(|| list.get(*at)).flatten(), + } +} + +fn find_mut<'a>(list: &'a mut [Value], anchor: &Anchor) -> Option<&'a mut Value> { + match anchor { + Anchor::Id(id) => list.iter_mut().find(|x| x.get("id").and_then(Value::as_u64) == Some(*id)), + Anchor::Name(name) => list.iter_mut().find(|x| x.get("name").and_then(Value::as_str) == Some(name)), + Anchor::Index { at, of } => (list.len() == *of).then(|| list.get_mut(*at)).flatten(), + } +} + +/// Put the kept fields back. An element that is gone was deleted here, its fields with it; one +/// whose place can't be told any more, and a field whose record is gone, go into `lost`. +fn apply(kept: &Kept, value: &mut Value, path: &str, lost: &mut Vec) { + match kept { + Kept::Field(_) => {} + Kept::Fields(fields) => { + let Some(object) = value.as_object_mut() else { + lost.push(format!("field `{path}`")); + return; + }; + for (key, sub) in fields { + let inner = if path.is_empty() { key.clone() } else { format!("{path}.{key}") }; + match (sub, object.get_mut(key)) { + (Kept::Field(v), None) => { + object.insert(key.clone(), v.clone()); + } + (Kept::Field(_), Some(_)) => {} + (sub, Some(inner_value)) => apply(sub, inner_value, &inner, lost), + // The list it was in is empty and not written: its elements were deleted. + (Kept::Items(_), None) => {} + (_, None) => lost.push(format!("field `{inner}`")), + } + } + } + Kept::Items(items) => { + let Some(list) = value.as_array_mut() else { + lost.push(format!("field `{path}`")); + return; + }; + for (anchor, sub) in items { + match (find_mut(list, anchor), anchor) { + (Some(element), _) => apply(sub, element, path, lost), + (None, Anchor::Index { at, .. }) => lost.push(format!("element {at} of `{path}`")), + (None, _) => {} + } + } + } + } +} + +#[cfg(test)] +#[path = "newer_tests.rs"] +mod tests; diff --git a/crates/format/src/newer_tests.rs b/crates/format/src/newer_tests.rs new file mode 100644 index 000000000..90e5b0037 --- /dev/null +++ b/crates/format/src/newer_tests.rs @@ -0,0 +1,48 @@ +use super::*; + +fn newer() -> Newer { + Newer { format: 9, reads_up_to: 8, unknown_changes: Vec::new() } +} + +/// What typed reading dropped is named and goes back on saving, where it was. +#[test] +fn dropped_fields_are_named_and_put_back() { + let file = json!({"name": "A", "format": "app/9", "items": [{"id": 1, "size": 2, "colour": "red"}], "extra": {"x": 1}}); + let known = json!({"name": "A", "items": [{"id": 1, "size": 2}]}); + let mut said = NewerFile::new("App", &newer()); + said.compare(&file, &known, "placeholder", &[]); + assert_eq!(said.not_understood, ["field `extra`", "field `items[1].colour`"]); + let mut saved = json!({"name": "A", "items": [{"id": 1, "size": 3}]}); + assert!(said.restore_into(&mut saved).is_empty()); + assert_eq!(saved, json!({"name": "A", "items": [{"id": 1, "size": 3, "colour": "red"}], "extra": {"x": 1}})); + assert_eq!(said.notice(), "Saved by a newer App (format 9, this version reads up to 8). If something's missing, update."); +} + +/// A section that can't be read is left out, kept, and goes back while it is unchanged here. +#[test] +fn unreadable_sections_are_left_out_and_kept() { + let mut top = match json!({"name": "A", "good": 1, "bad": 2}) { + Value::Object(m) => m, + _ => unreachable!(), + }; + let mut said = NewerFile::new("App", &newer()); + leave_out_unreadable(&mut top, &mut said, "design", |key: &str, _: &Value| if key == "bad" { Err("design file: no") } else { Ok(()) }); + assert!(!top.contains_key("bad")); + assert_eq!(said.not_understood, ["section `bad` (no)"]); + let read = + read_around( + &mut top, + &mut said, + &["name"], + "design", + |top: &Map| { + if top.contains_key("good") { Err("design file: clash") } else { Ok(top.len()) } + }, + ); + assert_eq!(read, Ok(1)); + assert_eq!(said.not_understood, ["section `bad` (no)", "section `good` (clash)"]); + let mut saved = json!({"name": "A"}); + said.compare(&saved.clone(), &saved.clone(), "placeholder", &[]); + assert!(said.restore_into(&mut saved).is_empty()); + assert_eq!(saved, json!({"name": "A", "good": 1, "bad": 2})); +} From d55335423a9719102b2c2f3dfa2f6cbf05e915d3 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:11:32 +0000 Subject: [PATCH 139/382] exr: share scanline RGBA writer --- crates/exr/src/lib.rs | 2 + crates/exr/src/rgba8.rs | 235 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 237 insertions(+) create mode 100644 crates/exr/src/rgba8.rs diff --git a/crates/exr/src/lib.rs b/crates/exr/src/lib.rs index f1550f8de..78afd427e 100644 --- a/crates/exr/src/lib.rs +++ b/crates/exr/src/lib.rs @@ -18,6 +18,8 @@ //! - [`stream`]: one flat scan-line part read block by block, for pictures larger than memory. //! - [`cryptomatte_samples`]: a file's Cryptomatte layers and their per-pixel (ID, coverage) ranks. +/// Scanline OpenEXR writer using a caller-supplied linearization table. +pub mod rgba8; /// RFC 1950/1951 compressor for ZIP-compressed EXR chunks. pub mod zlib; diff --git a/crates/exr/src/rgba8.rs b/crates/exr/src/rgba8.rs new file mode 100644 index 000000000..0b26ab8c9 --- /dev/null +++ b/crates/exr/src/rgba8.rs @@ -0,0 +1,235 @@ +//! Single-part scanline OpenEXR output from RGBA8 pixels. + +/// Scanline chunk compression. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Compression { + /// Uncompressed. + None, + /// OpenEXR RLE. + Rle, + /// zlib per scanline. + Zips, + /// zlib per 16 scanlines. + Zip, +} +impl Compression { + fn code(self) -> u8 { + match self { + Self::None => 0, + Self::Rle => 1, + Self::Zips => 2, + Self::Zip => 3, + } + } + fn lines(self) -> usize { + if self == Self::Zip { 16 } else { 1 } + } +} +/// Why a frame cannot be encoded. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Error { + /// Empty, overflowing or mismatched RGBA dimensions. + FrameSize, + /// Dimensions exceed the OpenEXR signed-size fields. + TooLarge, +} +fn checked_len(rgba: &[u8], w: u32, h: u32) -> Result { + let n = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(4)).ok_or(Error::FrameSize)?; + if w == 0 || h == 0 || rgba.len() != n { + return Err(Error::FrameSize); + } + Ok(n) +} + +/// IEEE 754 binary16 bits of `v`, rounded to nearest even (overflow → infinity, NaN → quiet NaN). +pub fn half(v: f32) -> u16 { + let b = v.to_bits(); + let sign = ((b >> 16) & 0x8000) as u16; + let exp = ((b >> 23) & 0xFF) as i32; + let man = b & 0x7F_FFFF; + if exp == 0xFF { + return sign | 0x7C00 | if man != 0 { 0x200 } else { 0 }; + } + // rounds `m >> shift` to nearest, ties to even (`shift` is 1..=24) + let round = |m: u32, shift: u32| { + let (q, rem, mid) = (m >> shift, m & ((1 << shift) - 1), 1 << (shift - 1)); + if rem > mid || (rem == mid && q & 1 == 1) { q + 1 } else { q } + }; + let e = exp - 127 + 15; + if e >= 0x1F { + sign | 0x7C00 + } else if e <= 0 { + if e < -10 { + return sign; + } + // subnormal half: the 24-bit significand scaled by 2^(e - 14); rounding up may carry + // into the smallest normal, which is the right encoding + sign | round(man | 0x80_0000, (14 - e) as u32) as u16 + } else { + // a carry out of the mantissa bumps the exponent (up to infinity), as it should + sign | round(((e as u32) << 23) | man, 13) as u16 + } +} + +/// An OpenEXR file: half-float scene-linear Rec.709 RGB, or RGBA with `alpha` (premultiplied, as +/// EXR defines alpha; the frame's straight alpha is multiplied in after linearisation). +pub fn write_rgba8(rgba: &[u8], w: u32, h: u32, alpha: bool, compression: Compression, linear: &[f32; 256]) -> Result, Error> { + let n = checked_len(rgba, w, h)?; + let too_large = || Error::TooLarge; + let (Ok(x_max), Ok(y_max)) = (i32::try_from(w - 1), i32::try_from(h - 1)) else { + return Err(too_large()); + }; + // channels in the alphabetical order the file layout requires + let names: &[u8] = if alpha { b"ABGR" } else { b"BGR" }; + let line = (w as usize).checked_mul(names.len() * 2).ok_or_else(|| Error::FrameSize)?; + // a chunk's byte count is a signed 32-bit field + let lines = compression.lines(); + if line.checked_mul(lines).and_then(|c| i32::try_from(c).ok()).is_none() { + return Err(too_large()); + } + + let mut hd = Vec::with_capacity(512); + hd.extend_from_slice(&[0x76, 0x2F, 0x31, 0x01]); // magic number 20000630 + hd.extend_from_slice(&[2, 0, 0, 0]); // version 2, single-part scan-line file, short names + let attr = |hd: &mut Vec, name: &str, ty: &str, value: &[u8]| { + for s in [name, ty] { + hd.extend_from_slice(s.as_bytes()); + hd.push(0); + } + hd.extend_from_slice(&(value.len() as i32).to_le_bytes()); + hd.extend_from_slice(value); + }; + let le = |v: &[f32]| v.iter().flat_map(|f| f.to_le_bytes()).collect::>(); + let mut channels = Vec::new(); + for &c in names { + channels.extend_from_slice(&[c, 0]); + channels.extend_from_slice(&1_i32.to_le_bytes()); // pixel type HALF + channels.extend_from_slice(&[0, 0, 0, 0]); // pLinear 0, reserved + channels.extend_from_slice(&1_i32.to_le_bytes()); // x sampling + channels.extend_from_slice(&1_i32.to_le_bytes()); // y sampling + } + channels.push(0); + let window: Vec = [0, 0, x_max, y_max].iter().flat_map(|v| v.to_le_bytes()).collect(); + attr(&mut hd, "channels", "chlist", &channels); + attr(&mut hd, "chromaticities", "chromaticities", &le(&[0.64, 0.33, 0.30, 0.60, 0.15, 0.06, 0.3127, 0.3290])); + attr(&mut hd, "compression", "compression", &[compression.code()]); + attr(&mut hd, "dataWindow", "box2i", &window); + attr(&mut hd, "displayWindow", "box2i", &window); + attr(&mut hd, "lineOrder", "lineOrder", &[0]); // INCREASING_Y + attr(&mut hd, "pixelAspectRatio", "float", &le(&[1.0])); + attr(&mut hd, "screenWindowCenter", "v2f", &le(&[0.0, 0.0])); + attr(&mut hd, "screenWindowWidth", "float", &le(&[1.0])); + hd.push(0); // end of header + + // offset table (one entry per chunk), then the chunks: first y, data size, data + let chunks = (h as usize).div_ceil(lines); + let table = chunks.checked_mul(8); + let body = (h as usize).checked_mul(line + 8); + let size = table.zip(body).and_then(|(t, b)| hd.len().checked_add(t)?.checked_add(b)).ok_or_else(|| Error::FrameSize)?; + // the uncompressed size: compressed chunks only shrink it + let mut out = Vec::with_capacity(size); + out.extend_from_slice(&hd); + let table_at = out.len(); + out.resize(table_at + chunks * 8, 0); + let lin = linear; + let opaque: [u16; 256] = std::array::from_fn(|i| half(lin[i])); + let row = w as usize * 4; + let wn = w as usize; + let mut px = vec![0_u16; wn * names.len()]; + let mut raw = Vec::with_capacity(line * lines); + // the deflate hash tables, shared by the frame's chunks instead of zeroed for each one + let mut tables = crate::zlib::Tables::default(); + for (k, block) in rgba[..n].chunks(row * lines).enumerate() { + raw.clear(); + for src in block.chunks_exact(row) { + // planar per line: every pixel of the first channel, then the next channel … + for (x, &[r, g, b, a]) in src.as_chunks::<4>().0.iter().enumerate() { + let rgb = [b, g, r]; + if alpha { + let k = f32::from(a) / 255.0; + px[x] = half(k); + for (c, &v) in rgb.iter().enumerate() { + px[(c + 1) * wn + x] = if a == 255 { opaque[v as usize] } else { half(lin[v as usize] * k) }; + } + } else { + for (c, &v) in rgb.iter().enumerate() { + px[c * wn + x] = opaque[v as usize]; + } + } + } + raw.extend(px.iter().flat_map(|v| v.to_le_bytes())); + } + let packed = match compression { + Compression::None => None, + Compression::Rle => Some(rle(&predict(&raw))), + Compression::Zips | Compression::Zip => Some(crate::zlib::zlib(&predict(&raw), &mut tables)), + }; + // a chunk that does not shrink is stored as it is (readers compare the sizes) + let data = packed.as_deref().filter(|p| p.len() < raw.len()).unwrap_or(&raw); + let offset = (out.len() as u64).to_le_bytes(); + out[table_at + k * 8..table_at + k * 8 + 8].copy_from_slice(&offset); + out.extend_from_slice(&((k * lines) as i32).to_le_bytes()); + out.extend_from_slice(&(data.len() as i32).to_le_bytes()); + out.extend_from_slice(data); + } + Ok(out) +} + +/// The OpenEXR RLE / ZIP predictor: bytes split into even and odd halves, then each byte replaced +/// by its difference from the previous one, plus 128. +fn predict(raw: &[u8]) -> Vec { + let half = raw.len().div_ceil(2); + let mut t = vec![0_u8; raw.len()]; + for (i, &b) in raw.iter().enumerate() { + t[if i % 2 == 0 { i / 2 } else { half + i / 2 }] = b; + } + let mut p = t.first().copied().unwrap_or(0); + for v in t.iter_mut().skip(1) { + let d = v.wrapping_sub(p).wrapping_add(128); + p = *v; + *v = d; + } + t +} + +/// OpenEXR run-length coding: a signed count byte, then either `count + 1` copies of one byte +/// (count ≥ 0, runs of 3 to 128) or `-count` literal bytes (1 to 127). +pub fn rle(src: &[u8]) -> Vec { + let mut out = Vec::with_capacity(src.len() + src.len() / 127 + 1); + let mut i = 0; + while i < src.len() { + let b = src[i]; + let run = src[i..].iter().take(128).take_while(|&&x| x == b).count(); + if run >= 3 { + out.extend_from_slice(&[(run - 1) as u8, b]); + i += run; + continue; + } + // literals up to the next run of three (or 127 bytes) + let s = i; + while i < src.len() && i - s < 127 { + if src.get(i..i + 3).is_some_and(|t| t[0] == t[1] && t[1] == t[2]) { + break; + } + i += 1; + } + out.push(((i - s) as u8).wrapping_neg()); + out.extend_from_slice(&src[s..i]); + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn writes_all_scanline_compressions() { + let linear = std::array::from_fn(|i| i as f32 / 255.0); + for c in [Compression::None, Compression::Rle, Compression::Zips, Compression::Zip] { + let bytes = write_rgba8(&[128; 16 * 16 * 4], 16, 16, true, c, &linear).unwrap(); + assert_eq!(&bytes[..4], &[0x76, 0x2f, 0x31, 1]); + assert!(bytes.len() > 100); + } + assert_eq!(write_rgba8(&[], 1, 1, false, Compression::None, &linear), Err(Error::FrameSize)); + } +} From ee44af6a45c2d12c4e63058db08a9f417002636d Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:14:00 +0000 Subject: [PATCH 140/382] Share first-directory TIFF inspection --- crates/image-codecs/src/lib.rs | 1 + crates/image-codecs/src/tiff_probe.rs | 68 +++++++++++++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 crates/image-codecs/src/tiff_probe.rs diff --git a/crates/image-codecs/src/lib.rs b/crates/image-codecs/src/lib.rs index 6516b9ff2..b94eb6606 100644 --- a/crates/image-codecs/src/lib.rs +++ b/crates/image-codecs/src/lib.rs @@ -30,6 +30,7 @@ mod options; pub mod orientation; pub mod resolution; pub mod source_settings; +pub mod tiff_probe; pub mod web; pub use crate::allocation::probe_allocation_size; pub use crate::cicp::Cicp; diff --git a/crates/image-codecs/src/tiff_probe.rs b/crates/image-codecs/src/tiff_probe.rs new file mode 100644 index 000000000..1a542e412 --- /dev/null +++ b/crates/image-codecs/src/tiff_probe.rs @@ -0,0 +1,68 @@ +//! First-directory TIFF inspection without decoding pixels. + +/// A header inspection failure, distinguishing caller limits from unsupported decoder layouts. +#[derive(Debug, thiserror::Error)] +pub enum Error { + /// Dimensions exceed the caller's pixel limit. + #[error("TIFF dimensions {width}x{height} exceed the pixel limit")] + TooLarge { + /// Stored width. + width: u32, + /// Stored height. + height: u32, + }, + /// The shared TIFF decoder does not support this layout. + #[error("unsupported TIFF: {0}")] + Unsupported(&'static str), + /// The file's header, directory or image-data bounds are malformed. + #[error("malformed TIFF: {0}")] + Malformed(String), +} + +/// Stored dimensions and orientation of the first directory, after checking the layouts and +/// image-data bounds required by the TIFF decoder. Compressed strips are not decompressed. +pub fn header(bytes: &[u8], max_pixels: u64) -> Result<(u32, u32, u16), Error> { + let (tiff, complete) = craft_tiff::Tiff::parse_with_status(bytes, &Default::default()).map_err(|e| Error::Malformed(e.to_string()))?; + if !complete { + return Err(Error::Malformed("truncated TIFF".into())); + } + let ifd = tiff.ifds.first().ok_or_else(|| Error::Malformed("no IFD".into()))?; + let info = ifd.image().map_err(|e| Error::Malformed(e.to_string()))?; + if info.width == 0 || info.height == 0 { + return Err(Error::Malformed("zero dimension".into())); + } + if u64::from(info.width) * u64::from(info.height) > max_pixels { + return Err(Error::TooLarge { width: info.width, height: info.height }); + } + let bits = info.bits_per_sample.first().copied().unwrap_or(1); + if bits < 8 && info.planar == 2 && info.samples_per_pixel > 1 { + return Err(Error::Unsupported("planar TIFF with samples narrower than a byte")); + } + if !(matches!(info.photometric, 0 | 1 | 2 | 3 | 5) || info.photometric == 6 && info.compression == 7) { + return Err(Error::Unsupported("colour type")); + } + if !matches!(info.compression, 1 | 4 | 5 | 7 | 8 | 32773 | 32946) { + return Err(Error::Unsupported("compression method")); + } + let len = bytes.len() as u64; + if info.offsets.is_empty() + || info.offsets.iter().zip(&info.byte_counts).any(|(&o, &c)| c > 0 && (o >= len || (info.compression == 1 && o.saturating_add(c) > len))) + { + return Err(Error::Malformed("truncated: image data past the end of the file".into())); + } + let orientation = ifd.u16(craft_tiff::tags::ORIENTATION).filter(|o| (1..=8).contains(o)).unwrap_or(1); + Ok((info.width, info.height, orientation)) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn reads_first_directory_and_enforces_limits_and_bounds() { + let image = crate::Image::from_u8(2, 3, crate::ChannelLayout::Rgb, vec![42; 18]).unwrap(); + let bytes = crate::encode(&image, crate::Format::Tiff, &crate::EncodeOptions::default()).unwrap(); + assert_eq!(header(&bytes, 6).unwrap(), (2, 3, 1)); + assert!(matches!(header(&bytes, 5), Err(Error::TooLarge { width: 2, height: 3 }))); + assert!(header(&bytes[..8], 6).is_err()); + } +} From 939146a5b159a268ee5fc67e26b3dc915b4d4094 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:14:11 +0000 Subject: [PATCH 141/382] tga dpx: share uncompressed RGBA8 export --- crates/dpx/src/lib.rs | 3 + crates/dpx/src/rgba8_dpx10.rs | 105 ++++++++++++++++++++++++++++++++++ crates/tga/src/lib.rs | 3 + crates/tga/src/rgba8_raw.rs | 60 +++++++++++++++++++ 4 files changed, 171 insertions(+) create mode 100644 crates/dpx/src/rgba8_dpx10.rs create mode 100644 crates/tga/src/rgba8_raw.rs diff --git a/crates/dpx/src/lib.rs b/crates/dpx/src/lib.rs index a762566f8..26d9e8656 100644 --- a/crates/dpx/src/lib.rs +++ b/crates/dpx/src/lib.rs @@ -34,6 +34,9 @@ //! Input is treated as hostile: every header read is bounds-checked, the picture size is capped //! by [`Limits`] and the image data must be present in full before anything is allocated. +/// RGBA8-to-10-bit DPX encoding. +pub mod rgba8_dpx10; + #[cfg(test)] mod tests; diff --git a/crates/dpx/src/rgba8_dpx10.rs b/crates/dpx/src/rgba8_dpx10.rs new file mode 100644 index 000000000..6ec5e23b4 --- /dev/null +++ b/crates/dpx/src/rgba8_dpx10.rs @@ -0,0 +1,105 @@ +//! Uncompressed RGB(A) output from top-down RGBA8 pixels. +/// Why the supplied frame cannot be encoded. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Rgba8EncodeError { + /// Empty, overflowing, or mismatched dimensions. + FrameSize, + /// A dimension cannot fit the output format. + TooLarge, +} +fn checked_len(rgba: &[u8], w: u32, h: u32) -> std::result::Result { + let n = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(4)).ok_or(Rgba8EncodeError::FrameSize)?; + if w == 0 || h == 0 || rgba.len() != n { + return Err(Rgba8EncodeError::FrameSize); + } + Ok(n) +} +/// Header size of the DPX files we write (file + image + orientation + film + TV headers). +const DPX_HEADER: usize = 2048; + +/// A DPX file: 10-bit RGB (8-bit values widened by bit replication, so 0 → 0 and 255 → 1023). +pub fn encode_rgba8_dpx10(rgba: &[u8], w: u32, h: u32, creator: &str) -> std::result::Result, Rgba8EncodeError> { + let n = checked_len(rgba, w, h)?; + // one 32-bit word per pixel; `n` is already `w * h * 4` + let size = n.checked_add(DPX_HEADER).ok_or_else(|| Rgba8EncodeError::FrameSize)?; + let file_size = u32::try_from(size).map_err(|_| Rgba8EncodeError::TooLarge)?; + // SMPTE ST 268: undefined numeric fields are all ones, undefined text fields are NUL + let mut hd = vec![0xFF_u8; DPX_HEADER]; + for (a, b) in [ + (36, 660), // file name, creation time, creator, project, copyright + (664, 768), // reserved + (1356, 1408), // reserved + (1432, 1620), // source file name, time, input device, serial number + (1644, 1664), // reserved + (1664, 1712), // film manufacturer, type, offset, prefix, count, format + (1732, 1920), // frame id, slate, reserved + (1972, 2048), // reserved + ] { + hd[a..b].fill(0); + } + for e in 0..8 { + let d = 780 + e * 72 + 40; + hd[d..d + 32].fill(0); // element descriptions + } + let put32 = |hd: &mut Vec, at: usize, v: u32| hd[at..at + 4].copy_from_slice(&v.to_be_bytes()); + let put16 = |hd: &mut Vec, at: usize, v: u16| hd[at..at + 2].copy_from_slice(&v.to_be_bytes()); + // file information header + hd[0..4].copy_from_slice(b"SDPX"); + put32(&mut hd, 4, DPX_HEADER as u32); // offset to the image data + hd[8..16].copy_from_slice(b"V2.0\0\0\0\0"); + put32(&mut hd, 16, file_size); + put32(&mut hd, 20, 1); // ditto key: new frame + put32(&mut hd, 24, 1664); // generic header length + put32(&mut hd, 28, 384); // industry header length + put32(&mut hd, 32, 0); // user data length + let creator = creator.as_bytes(); + let n = creator.len().min(100); + hd[160..160 + n].copy_from_slice(&creator[..n]); + // image information header + put16(&mut hd, 768, 0); // orientation: left to right, top to bottom + put16(&mut hd, 770, 1); // one image element + put32(&mut hd, 772, w); + put32(&mut hd, 776, h); + let el = 780; + put32(&mut hd, el, 0); // unsigned + put32(&mut hd, el + 4, 0); // reference low data code + put32(&mut hd, el + 12, 1023); // reference high data code + hd[el + 20] = 50; // descriptor: RGB + hd[el + 21] = 6; // transfer: ITU-R BT.709 + hd[el + 22] = 6; // colorimetric: ITU-R BT.709 + hd[el + 23] = 10; // bit depth + put16(&mut hd, el + 24, 1); // packing: filled to 32-bit words, method A + put16(&mut hd, el + 26, 0); // no encoding (uncompressed) + put32(&mut hd, el + 28, DPX_HEADER as u32); // offset to the element's data + put32(&mut hd, el + 32, 0); // end-of-line padding + put32(&mut hd, el + 36, 0); // end-of-image padding + // image orientation header: no offset, square pixels + put32(&mut hd, 1408, 0); + put32(&mut hd, 1412, 0); + put32(&mut hd, 1424, w); + put32(&mut hd, 1428, h); + put32(&mut hd, 1628, 1); + put32(&mut hd, 1632, 1); + // television header: progressive + hd[1928] = 0; + let mut out = Vec::with_capacity(size); + out.extend_from_slice(&hd); + let ten = |v: u8| (u32::from(v) << 2) | (u32::from(v) >> 6); + for &[r, g, b, _] in rgba.as_chunks::<4>().0 { + out.extend_from_slice(&((ten(r) << 22) | (ten(g) << 12) | (ten(b) << 2)).to_be_bytes()); + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn packed_rgb_and_creator() { + let bytes = encode_rgba8_dpx10(&[255, 0, 128, 255], 1, 1, "FilmCraft").unwrap(); + assert_eq!(&bytes[..4], b"SDPX"); + assert_eq!(&bytes[160..169], b"FilmCraft"); + assert_eq!(&bytes[2048..], &((1023u32 << 22) | (514u32 << 2)).to_be_bytes()); + assert_eq!(encode_rgba8_dpx10(&[], 0, 1, ""), Err(Rgba8EncodeError::FrameSize)); + } +} diff --git a/crates/tga/src/lib.rs b/crates/tga/src/lib.rs index ac9d21497..3a92052ff 100644 --- a/crates/tga/src/lib.rs +++ b/crates/tga/src/lib.rs @@ -18,6 +18,9 @@ //! Input is treated as hostile: the picture size is capped by [`Limits`], and a run-length file //! must be long enough to hold the pixels its header declares before anything is allocated. +/// Uncompressed RGBA8-to-Targa encoding. +pub mod rgba8_raw; + #[cfg(test)] mod tests; diff --git a/crates/tga/src/rgba8_raw.rs b/crates/tga/src/rgba8_raw.rs new file mode 100644 index 000000000..acec4b9bc --- /dev/null +++ b/crates/tga/src/rgba8_raw.rs @@ -0,0 +1,60 @@ +//! Uncompressed RGB(A) output from top-down RGBA8 pixels. +/// Why the supplied frame cannot be encoded. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Rgba8EncodeError { + /// Empty, overflowing, or mismatched dimensions. + FrameSize, + /// A dimension cannot fit the 16-bit Targa header. + Dimensions, +} +fn checked_len(rgba: &[u8], w: u32, h: u32) -> std::result::Result { + let n = (w as usize).checked_mul(h as usize).and_then(|n| n.checked_mul(4)).ok_or(Rgba8EncodeError::FrameSize)?; + if w == 0 || h == 0 || rgba.len() != n { + return Err(Rgba8EncodeError::FrameSize); + } + Ok(n) +} +/// An uncompressed Targa file: 24-bit BGR, or 32-bit BGRA with `alpha` (straight alpha, as the +/// frame carries it). +pub fn encode_rgba8_raw(rgba: &[u8], w: u32, h: u32, alpha: bool) -> std::result::Result, Rgba8EncodeError> { + checked_len(rgba, w, h)?; + let (tw, th) = match (u16::try_from(w), u16::try_from(h)) { + (Ok(tw), Ok(th)) => (tw, th), + _ => return Err(Rgba8EncodeError::Dimensions), + }; + let bpp: usize = if alpha { 4 } else { 3 }; + let row = w as usize * 4; + let mut out = Vec::with_capacity(18 + w as usize * h as usize * bpp + 26); + out.extend_from_slice(&[0, 0, 2]); // no ID, no colour map, uncompressed true-colour + out.extend_from_slice(&[0; 5]); // colour map specification (unused) + out.extend_from_slice(&[0, 0, 0, 0]); // x / y origin + out.extend_from_slice(&tw.to_le_bytes()); + out.extend_from_slice(&th.to_le_bytes()); + out.push(if alpha { 32 } else { 24 }); + out.push(if alpha { 8 } else { 0 }); // attribute bits; bottom-left origin + // bottom-left origin: the last frame row comes first + for line in rgba.chunks_exact(row).rev() { + for &[r, g, b, a] in line.as_chunks::<4>().0 { + out.extend_from_slice(&[b, g, r]); + if alpha { + out.push(a); + } + } + } + // TGA 2.0 footer without extension or developer areas + out.extend_from_slice(&[0; 8]); + out.extend_from_slice(b"TRUEVISION-XFILE.\0"); + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn raw_round_trip() { + let bytes = encode_rgba8_raw(&[1, 2, 3, 4], 1, 1, true).unwrap(); + assert_eq!(&bytes[18..22], &[3, 2, 1, 4]); + assert_eq!(&bytes[bytes.len() - 18..], b"TRUEVISION-XFILE.\0"); + assert_eq!(encode_rgba8_raw(&[], 0, 1, false), Err(Rgba8EncodeError::FrameSize)); + } +} From 553c86719ce9d57f01bcfb6442ac68ac58cd65de Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:14:57 +0000 Subject: [PATCH 142/382] Share catalog face metrics and glyph outlines --- Cargo.lock | 1 + crates/font-catalog/Cargo.toml | 1 + crates/font-catalog/src/lib.rs | 2 + crates/font-catalog/src/outline.rs | 133 +++++++++++++++++++++++++++++ 4 files changed, 137 insertions(+) create mode 100644 crates/font-catalog/src/outline.rs diff --git a/Cargo.lock b/Cargo.lock index 9fb46057c..9424cf3fe 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1761,6 +1761,7 @@ name = "craft-font-catalog" version = "0.1.0" dependencies = [ "fontique", + "kurbo 0.13.1", "skrifa 0.47.0", "thiserror 2.0.21", "windows-registry", diff --git a/crates/font-catalog/Cargo.toml b/crates/font-catalog/Cargo.toml index a95e1c28f..1f0830a63 100644 --- a/crates/font-catalog/Cargo.toml +++ b/crates/font-catalog/Cargo.toml @@ -15,6 +15,7 @@ default = ["system"] system = ["dep:fontique"] [dependencies] +kurbo = { workspace = true } skrifa = { version = "0.47", default-features = false, features = ["std"] } thiserror = { workspace = true } diff --git a/crates/font-catalog/src/lib.rs b/crates/font-catalog/src/lib.rs index c787d3ece..7da4ca310 100644 --- a/crates/font-catalog/src/lib.rs +++ b/crates/font-catalog/src/lib.rs @@ -23,6 +23,7 @@ mod catalog; mod env; mod fontconfig; +mod outline; mod registry; mod scan; mod suitcase; @@ -31,6 +32,7 @@ pub mod system; pub use catalog::{Catalog, FontData, FontFileError, Limits, Lister, LoadedFace, Match, Watch}; pub use env::{FontEnv, Os, font_dirs, font_store_dir, office_font_dirs}; pub use fontconfig::fontconfig_dirs; +pub use outline::{FontOutline, OutlineError}; pub use scan::{FaceInfo, LocalizedName, Source, is_font_file, style_italic, style_weight, style_width}; #[cfg(test)] diff --git a/crates/font-catalog/src/outline.rs b/crates/font-catalog/src/outline.rs new file mode 100644 index 000000000..cd27e0c53 --- /dev/null +++ b/crates/font-catalog/src/outline.rs @@ -0,0 +1,133 @@ +//! Unhinted glyph outlines and metrics for catalog faces. + +use kurbo::BezPath; +use skrifa::instance::{Location, Size}; +use skrifa::outline::{DrawSettings, OutlinePen}; +use skrifa::{FontRef, GlyphId, MetadataProvider, Tag}; + +use crate::{FontData, LoadedFace}; + +/// A parsed face and its variation location. Coordinates use font design units, with y up. +/// The bytes can come from a catalog or any other source, including a collection face. +pub struct FontOutline<'a> { + font: FontRef<'a>, + location: Location, +} + +/// Why a font or glyph outline could not be read. +#[derive(Debug, thiserror::Error)] +pub enum OutlineError { + /// The face index or font data is invalid. + #[error("invalid font face")] + InvalidFace, + /// The glyph has no outline in this face. + #[error("glyph has no outline")] + MissingGlyph, + /// The glyph's outline is malformed. + #[error("cannot draw glyph outline: {0}")] + Draw(#[from] skrifa::outline::DrawError), +} + +impl<'a> FontOutline<'a> { + /// Parse the given face and select axis values in user units. Unknown axes are ignored and + /// values are clamped to their axis ranges by the font parser. + pub fn new(data: &'a FontData, variations: &[([u8; 4], f32)]) -> Result { + Self::from_bytes(&data.bytes, data.index, variations) + } + + /// Parse borrowed bytes and a collection face index without copying the font. + pub fn from_bytes(bytes: &'a [u8], index: u32, variations: &[([u8; 4], f32)]) -> Result { + let font = FontRef::from_index(bytes, index).map_err(|_| OutlineError::InvalidFace)?; + let location = font.axes().location(variations.iter().map(|(tag, value)| (Tag::new(tag), *value))); + Ok(Self { font, location }) + } + + /// Parse a catalog face, retaining the axis settings of a named instance. + pub fn from_loaded(face: &'a LoadedFace) -> Result { + Self::new(&face.data, &face.info.variations) + } + + /// Font-wide metrics in unscaled design units at this variation location. + pub fn metrics(&self) -> skrifa::metrics::Metrics { + self.font.metrics(Size::unscaled(), &self.location) + } + + /// Resolve a Unicode scalar to a glyph identifier. + pub fn glyph_for(&self, character: char) -> Option { + self.font.charmap().map(character).map(|id| id.to_u32()) + } + + /// Draw a glyph in design units. Empty glyphs such as spaces can produce an empty path. + pub fn outline(&self, glyph: u32) -> Result { + let outline = self.font.outline_glyphs().get(GlyphId::new(glyph)).ok_or(OutlineError::MissingGlyph)?; + let mut pen = PathPen(BezPath::new()); + outline.draw(DrawSettings::unhinted(Size::unscaled(), &self.location), &mut pen)?; + Ok(pen.0) + } +} + +struct PathPen(BezPath); +impl OutlinePen for PathPen { + fn move_to(&mut self, x: f32, y: f32) { + self.0.move_to((f64::from(x), f64::from(y))); + } + fn line_to(&mut self, x: f32, y: f32) { + self.0.line_to((f64::from(x), f64::from(y))); + } + fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) { + self.0.quad_to((f64::from(x1), f64::from(y1)), (f64::from(x), f64::from(y))); + } + fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) { + self.0.curve_to((f64::from(x1), f64::from(y1)), (f64::from(x2), f64::from(y2)), (f64::from(x), f64::from(y))); + } + fn close(&mut self) { + self.0.close_path(); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use kurbo::PathEl; + use std::sync::Arc; + + #[test] + fn rejects_invalid_face_and_collection_index() { + let data = FontData { bytes: Arc::from(&b"not a font"[..]), index: 0 }; + assert!(matches!(FontOutline::new(&data, &[]), Err(OutlineError::InvalidFace))); + } + + #[test] + fn pen_preserves_geometry_and_upward_y() { + let mut pen = PathPen(BezPath::new()); + pen.move_to(1.0, 2.0); + pen.line_to(3.0, 4.0); + pen.quad_to(5.0, 6.0, 7.0, 8.0); + pen.curve_to(9.0, 10.0, 11.0, 12.0, 13.0, 14.0); + pen.close(); + assert_eq!( + pen.0.elements(), + &[ + PathEl::MoveTo((1.0, 2.0).into()), + PathEl::LineTo((3.0, 4.0).into()), + PathEl::QuadTo((5.0, 6.0).into(), (7.0, 8.0).into()), + PathEl::CurveTo((9.0, 10.0).into(), (11.0, 12.0).into(), (13.0, 14.0).into()), + PathEl::ClosePath, + ] + ); + } + + #[test] + fn reads_craft_font_when_available() { + let Ok(dir) = std::env::var("CRAFT_FONTS_DIR") else { return }; + let bytes = std::fs::read(std::path::Path::new(&dir).join("fonts/noto-sans-hebrew/NotoSansHebrew-Regular.ttf")).unwrap(); + let data = FontData { bytes: bytes.into(), index: 0 }; + let face = FontOutline::new(&data, &[]).unwrap(); + assert!(face.metrics().units_per_em > 0); + let glyph = face.glyph_for('×�').unwrap(); + assert!(!face.outline(glyph).unwrap().elements().is_empty()); + assert!(matches!(face.outline(u32::MAX), Err(OutlineError::MissingGlyph))); + let invalid_index = FontData { bytes: data.bytes.clone(), index: u32::MAX }; + assert!(matches!(FontOutline::new(&invalid_index, &[]), Err(OutlineError::InvalidFace))); + } +} From fb6cb780061c6744ed6886e7dd1a80ccf449e655 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:15:21 +0000 Subject: [PATCH 143/382] Depend on shared TIFF directory parser --- Cargo.lock | 1 + crates/image-codecs/Cargo.toml | 1 + 2 files changed, 2 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index 9fb46057c..23cdde361 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1927,6 +1927,7 @@ dependencies = [ "craft-heif", "craft-jpeg", "craft-metadata", + "craft-tiff", "craft-video", "crc32fast", "exr", diff --git a/crates/image-codecs/Cargo.toml b/crates/image-codecs/Cargo.toml index df71d9860..f697610a6 100644 --- a/crates/image-codecs/Cargo.toml +++ b/crates/image-codecs/Cargo.toml @@ -32,6 +32,7 @@ zune-core = "0.5" jpeg-encoder = "0.6" craft-jpeg = { workspace = true } craft-metadata = { workspace = true } +craft-tiff = { workspace = true } zune-jpegxl = { version = "=0.5.2", default-features = false, features = ["std"] } craft-heif = { workspace = true, optional = true } ravif = { version = "0.13", default-features = false, optional = true } From b616d590e862d9a2c63d67aaadb59dcae2e6d054 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Sun, 15 Nov 2026 11:15:32 -0500 Subject: [PATCH 144/382] Port XML property-list reader from Craft Anything Source: storytold/craft-anything at 8f3b775157d331dd31cfa4da911e26d8856b8c77, crates/formats/src/plist.rs and bytes.rs. Preserve original contributor fixes for document boundaries, UTF-16, numeric references, quoted attributes and line endings. Co-authored-by: Afloat Co-authored-by: BFlat Co-authored-by: Rahul Co-authored-by: RRFZ <247457381+Plastic-time@users.noreply.github.com> Co-authored-by: NetterSilver <133535268+Silvertree2010@users.noreply.github.com> --- crates/plist/src/xml.rs | 432 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 432 insertions(+) create mode 100644 crates/plist/src/xml.rs diff --git a/crates/plist/src/xml.rs b/crates/plist/src/xml.rs new file mode 100644 index 000000000..7b41ecc91 --- /dev/null +++ b/crates/plist/src/xml.rs @@ -0,0 +1,432 @@ +//! XML property-list reader ported from Craft Anything at 8f3b7751. +use crate::{DateValue, FormatError, Value}; +const MAX_NODES: usize = 100_000; +const MAX_DEPTH: usize = 64; +fn decode_base64(text: &str, url_safe: bool) -> Option> { + let mut out = Vec::with_capacity(text.len() / 4 * 3); + let mut acc = 0u32; + let mut bits = 0u32; + let mut digits = 0usize; + let mut padding = 0usize; + for c in text.bytes() { + match c { + b' ' | b'\t' | b'\r' | b'\n' => continue, + b'=' => { + padding += 1; + if padding > 2 { + return None; + } + continue; + } + _ if padding != 0 => return None, + _ => {} + } + let value = match c { + b'A'..=b'Z' => c - b'A', + b'a'..=b'z' => c - b'a' + 26, + b'0'..=b'9' => c - b'0' + 52, + b'+' => 62, + b'/' => 63, + b'-' if url_safe => 62, + b'_' if url_safe => 63, + _ => return None, + }; + acc = (acc << 6) | u32::from(value); + bits += 6; + digits += 1; + if bits >= 8 { + bits -= 8; + out.push((acc >> bits) as u8); + acc &= (1 << bits) - 1; + } + } + let remainder = digits % 4; + if remainder == 1 || (padding != 0 && !matches!((remainder, padding), (2, 2) | (3, 1))) { + return None; + } + Some(out) +} + +fn base64_decode(s: &str) -> Option> { decode_base64(s, false) } +#[derive(Debug, Clone, PartialEq)] +enum Tok { + Open(String), + Close(String), + Empty(String), + Text(String), +} + +fn decode_entities(s: &str) -> String { + if !s.contains('&') { + return s.to_string(); + } + let mut out = String::with_capacity(s.len()); + let mut rest = s; + while let Some(p) = rest.find('&') { + out.push_str(rest.get(..p).unwrap_or("")); + let after = rest.get(p..).unwrap_or(""); + let Some(end) = after.find(';').filter(|&e| e <= 12) else { + out.push('&'); + rest = after.get(1..).unwrap_or(""); + continue; + }; + let ent = after.get(1..end).unwrap_or(""); + let rep = match ent { + "lt" => Some('<'), + "gt" => Some('>'), + "amp" => Some('&'), + "quot" => Some('"'), + "apos" => Some('\''), + e if e.starts_with("#x") || e.starts_with("#X") => { + let d = e.get(2..).unwrap_or(""); + if d.bytes().all(|b| b.is_ascii_hexdigit()) { u32::from_str_radix(d, 16).ok().and_then(char::from_u32) } else { None } + } + e if e.starts_with('#') => { + let d = e.get(1..).unwrap_or(""); + if d.bytes().all(|b| b.is_ascii_digit()) { d.parse::().ok().and_then(char::from_u32) } else { None } + } + _ => None, + }; + match rep { + Some(c) => { + out.push(c); + rest = after.get(end + 1..).unwrap_or(""); + } + None => { + out.push('&'); + rest = after.get(1..).unwrap_or(""); + } + } + } + out.push_str(rest); + out +} + +/// Skip a declaration without interpreting or fetching any entity. A DOCTYPE's +/// internal subset can itself contain declarations, quoted delimiters, comments and PIs. +fn after_declaration(mut rest: &str) -> Result<&str, FormatError> { + let mut quote = None; + let mut brackets = 0usize; + while let Some(ch) = rest.chars().next() { + if quote.is_none() { + if let Some(comment) = rest.strip_prefix("").ok_or_else(|| FormatError::Truncated("comment in declaration".into()))?.1; + continue; + } + if let Some(pi) = rest.strip_prefix("").ok_or_else(|| FormatError::Truncated("processing instruction in declaration".into()))?.1; + continue; + } + } + rest = rest.get(ch.len_utf8()..).unwrap_or(""); + match (quote, ch) { + (Some(q), c) if q == c => quote = None, + (None, '\'' | '"') => quote = Some(ch), + (None, '[') => brackets += 1, + (None, ']') => brackets = brackets.saturating_sub(1), + (None, '>') if brackets == 0 => return Ok(rest), + _ => {} + } + } + Err(FormatError::Truncated("declaration".into())) +} + +fn tokenize(text: &str) -> Result, FormatError> { + let mut toks = Vec::new(); + let mut rest = text; + while !rest.is_empty() { + if toks.len() > MAX_NODES { + return Err(FormatError::TooLarge("too many XML tokens".into())); + } + match rest.find('<') { + None => { + if !rest.is_empty() { + toks.push(Tok::Text(decode_entities(rest))); + } + break; + } + Some(p) => { + let t = rest.get(..p).unwrap_or(""); + if !t.is_empty() { + toks.push(Tok::Text(decode_entities(t))); + } + rest = rest.get(p..).unwrap_or(""); + } + } + if let Some(r) = rest.strip_prefix("").ok_or_else(|| FormatError::Truncated("comment".into()))?; + rest = r.get(e + 3..).unwrap_or(""); + continue; + } + if let Some(r) = rest.strip_prefix("").ok_or_else(|| FormatError::Truncated("CDATA".into()))?; + toks.push(Tok::Text(r.get(..e).unwrap_or("").to_string())); + rest = r.get(e + 3..).unwrap_or(""); + continue; + } + if let Some(r) = rest.strip_prefix("").ok_or_else(|| FormatError::Truncated("processing instruction".into()))?; + rest = r.get(end + 2..).unwrap_or(""); + continue; + } + if let Some(declaration) = rest.strip_prefix(" { + quote = None; + false + } + (None, '\'' | '"') => { + quote = Some(ch); + false + } + (None, '>') => true, + _ => false, + }) + .ok_or_else(|| FormatError::Truncated("tag".into()))?; + let inner = rest.get(1..e).unwrap_or("").trim(); + rest = rest.get(e + 1..).unwrap_or(""); + if let Some(name) = inner.strip_prefix('/') { + toks.push(Tok::Close(name.trim().to_string())); + } else if let Some(body) = inner.strip_suffix('/') { + toks.push(Tok::Empty(body.split_whitespace().next().unwrap_or("").to_string())); + } else { + toks.push(Tok::Open(inner.split_whitespace().next().unwrap_or("").to_string())); + } + } + Ok(toks) +} + +struct Xml { + toks: Vec, + pos: usize, + nodes: usize, +} + +impl Xml { + fn next(&mut self) -> Option { + let t = self.toks.get(self.pos).cloned(); + self.pos += 1; + t + } + + fn peek(&self) -> Option<&Tok> { + self.toks.get(self.pos) + } + + /// Text up to the closing tag `name`. + fn text_until(&mut self, name: &str) -> Result { + let mut s = String::new(); + loop { + match self.next() { + Some(Tok::Text(t)) => s.push_str(&t), + Some(Tok::Close(n)) if n == name => return Ok(s), + Some(other) => return Err(FormatError::Malformed(format!("unexpected {other:?} inside <{name}>"))), + None => return Err(FormatError::Truncated(format!("<{name}> is not closed"))), + } + } + } + + fn skip_space(&mut self) { + while matches!(self.peek(), Some(Tok::Text(t)) if t.bytes().all(|b| matches!(b, b' ' | b'\t' | b'\r' | b'\n'))) { + self.pos += 1; + } + } + + fn value(&mut self, depth: usize) -> Result { + self.nodes += 1; + if depth > MAX_DEPTH || self.nodes > MAX_NODES { + return Err(FormatError::TooLarge("plist nesting or size limit".into())); + } + self.skip_space(); + match self.next() { + Some(Tok::Empty(n)) => Ok(match n.as_str() { + "true" => Value::Bool(true), + "false" => Value::Bool(false), + "dict" => Value::Dict(Vec::new()), + "array" => Value::Array(Vec::new()), + "string" => Value::String(String::new()), + "data" => Value::Data(Vec::new()), + other => return Err(FormatError::Malformed(format!("unexpected <{other}/>"))), + }), + Some(Tok::Open(n)) => match n.as_str() { + "string" => Ok(Value::String(self.text_until("string")?)), + "integer" => { + let t = self.text_until("integer")?; + let t = t.trim(); + let v = if let Some(h) = t.strip_prefix("0x").or_else(|| t.strip_prefix("0X")) { + i128::from_str_radix(h, 16).ok() + } else { + t.parse::().ok() + }; + v.map(Value::Integer).ok_or_else(|| FormatError::Malformed(format!("bad integer {t:?}"))) + } + "real" => { + let t = self.text_until("real")?; + t.trim().parse::().map(Value::Real).map_err(|_| FormatError::Malformed(format!("bad real {t:?}"))) + } + "date" => Ok(Value::Date(DateValue::Text(self.text_until("date")?.trim().to_string()))), + "data" => { + let t = self.text_until("data")?; + base64_decode(&t).map(Value::Data).ok_or_else(|| FormatError::Malformed("bad base64 in ".into())) + } + "true" | "false" => { + if !self.text_until(&n)?.is_empty() { + return Err(FormatError::Malformed(format!("<{n}> must be empty"))); + } + Ok(Value::Bool(n == "true")) + } + "array" => { + let mut out = Vec::new(); + loop { + self.skip_space(); + if matches!(self.peek(), Some(Tok::Close(c)) if c == "array") { + self.pos += 1; + return Ok(Value::Array(out)); + } + if self.peek().is_none() { + return Err(FormatError::Truncated(" is not closed".into())); + } + out.push(self.value(depth + 1)?); + } + } + "dict" => { + let mut out = Vec::new(); + loop { + self.skip_space(); + match self.next() { + Some(Tok::Close(c)) if c == "dict" => return Ok(Value::Dict(out)), + Some(Tok::Open(k)) if k == "key" => { + let key = self.text_until("key")?; + let v = self.value(depth + 1)?; + out.push((key, v)); + } + Some(Tok::Empty(k)) if k == "key" => { + let v = self.value(depth + 1)?; + out.push((String::new(), v)); + } + Some(other) => return Err(FormatError::Malformed(format!("expected in , found {other:?}"))), + None => return Err(FormatError::Truncated(" is not closed".into())), + } + } + } + other => Err(FormatError::Malformed(format!("unknown plist element <{other}>"))), + }, + Some(other) => Err(FormatError::Malformed(format!("expected a value, found {other:?}"))), + None => Err(FormatError::Truncated("expected a value".into())), + } + } +} + +/// Decode a UTF-16 XML property list after its byte-order mark into UTF-8 text. +/// Surrogate pairs join normally; a lone surrogate fails as malformed rather +/// than turning into replacement characters that tokenize into garbage element +/// names. +fn decode_utf16_xml(data: &[u8], big_endian: bool) -> Result { + if !data.len().is_multiple_of(2) { + return Err(FormatError::Truncated("UTF-16 code unit".into())); + } + let units: Vec = data.chunks_exact(2).map(|b| if big_endian { u16::from_be_bytes([b[0], b[1]]) } else { u16::from_le_bytes([b[0], b[1]]) }).collect(); + String::from_utf16(&units).map_err(|_| FormatError::Malformed("invalid UTF-16 in XML plist".into())) +} + +/// Parse an XML property list. +pub fn parse_xml(data: &[u8]) -> Result { + // Apple's Core Foundation reader accepts XML plists in UTF-16 as well as + // UTF-8: it recognises both byte-order marks. `from_utf8_lossy` turns a + // UTF-16 byte stream into NUL-separated text, so the encoding is settled + // here, before tokenizing. + let text = match data { + [0xFF, 0xFE, rest @ ..] => decode_utf16_xml(rest, false)?, + [0xFE, 0xFF, rest @ ..] => decode_utf16_xml(rest, true)?, + _ => std::str::from_utf8(data.strip_prefix(b"\xef\xbb\xbf").unwrap_or(data)) + .map_err(|_| FormatError::Malformed("invalid UTF-8 in XML plist".into()))? + .to_owned(), + }; + // XML normalizes literal line endings before parsing; character references such as + // must still decode to a carriage return afterwards. + let text = if text.contains('\r') { text.replace("\r\n", "\n").replace('\r', "\n") } else { text }; + let toks = tokenize(&text)?; + let mut x = Xml { toks, pos: 0, nodes: 0 }; + x.skip_space(); + let wrapped = matches!(x.peek(), Some(Tok::Open(n)) if n == "plist"); + if wrapped { + x.pos += 1; + } + let value = x.value(0)?; + x.skip_space(); + if wrapped { + if !matches!(x.next(), Some(Tok::Close(n)) if n == "plist") { + return Err(FormatError::Malformed("expected after its value".into())); + } + x.skip_space(); + } + if x.peek().is_some() { + return Err(FormatError::Malformed("unexpected content after the plist value".into())); + } + Ok(value) +} + + +#[cfg(test)] +mod tests { +use super::*; + #[test] + fn xml_has_one_complete_root_with_only_markup_space_around_values() { + for invalid in [ + "", + "", + "", + "", + "junk", + "text", + "junk", + "xgarbage", + "no", + "yes", + "", + ] { + assert!(parse_xml(invalid.as_bytes()).is_err(), "{invalid}"); + } + let xml = b" ?>\n "; + assert_eq!(parse_xml(xml).unwrap().get("").and_then(Value::as_str), Some(" ")); + assert_eq!(parse_xml(b" ").unwrap(), Value::Bool(true)); + } + + #[test] + fn xml_rejects_partial_code_units_and_preserves_the_utf8_bom() { + assert_eq!(parse_xml(b"\xef\xbb\xbfok").unwrap().as_str(), Some("ok")); + assert!(parse_xml(b"\xff").is_err()); + for be in [false, true] { + let mut bytes = if be { vec![0xfe, 0xff] } else { vec![0xff, 0xfe] }; + for unit in "".encode_utf16() { + bytes.extend(if be { unit.to_be_bytes() } else { unit.to_le_bytes() }); + } + bytes.push(0); + assert!(parse_xml(&bytes).is_err()); + } + } + + #[test] + fn a_doctype_internal_subset_is_skipped_as_one_declaration() { + let doc = br#"y"> ?>]>ok"#; + assert_eq!(parse_xml(doc).unwrap().as_str(), Some("ok")); + assert!(parse_xml(b"").is_err()); + } + + #[test] + fn xml_char_refs_require_plain_digits() { + let text = |s: &str| { + let doc = format!("{s}"); + parse_xml(doc.as_bytes()).unwrap().as_str().map(str::to_string) + }; + assert_eq!(text("a&#+65;b&#x+41;").as_deref(), Some("a&#+65;b&#x+41;")); + assert_eq!(text("AA").as_deref(), Some("AA")); + assert_eq!(text("&#;&#x;").as_deref(), Some("&#;&#x;")); + } + +} From 4c4ad5d20f03b2d566bab89678712b6eb9231194 Mon Sep 17 00:00:00 2001 From: gmrmad1 Date: Sun, 15 Nov 2026 11:15:51 -0500 Subject: [PATCH 145/382] Reject nonfinite XML property-list reals Port storytold/craft-anything#1905 at d85e104f093a334961048881bf003351e1ac4992. Retain typed-value tests; app JSON projection remains outside this codec. --- crates/plist/src/xml.rs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/crates/plist/src/xml.rs b/crates/plist/src/xml.rs index 7b41ecc91..54fd9f895 100644 --- a/crates/plist/src/xml.rs +++ b/crates/plist/src/xml.rs @@ -267,7 +267,7 @@ impl Xml { } "real" => { let t = self.text_until("real")?; - t.trim().parse::().map(Value::Real).map_err(|_| FormatError::Malformed(format!("bad real {t:?}"))) + t.trim().parse::().ok().filter(|v| v.is_finite()).map(Value::Real).ok_or_else(|| FormatError::Malformed(format!("bad real {t:?}"))) } "date" => Ok(Value::Date(DateValue::Text(self.text_until("date")?.trim().to_string()))), "data" => { @@ -429,4 +429,16 @@ use super::*; assert_eq!(text("&#;&#x;").as_deref(), Some("&#;&#x;")); } + #[test] + fn xml_real_must_be_finite() { + for bad in ["NaN", "1e999"] { + let doc = format!("k{bad}"); + assert!(parse_xml(doc.as_bytes()).is_err(), "{bad}"); + } + for (text, want) in [("1.5", 1.5), ("-2", -2.0), ("0", 0.0)] { + let doc = format!("k{text}"); + let v = parse_xml(doc.as_bytes()).unwrap_or_else(|e| panic!("{text} should parse: {e}")); + assert_eq!(v.get("k"), Some(&Value::Real(want)), "{text}"); + } + } } From c714810569eab85751713bea62c5833ae10af9b9 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:15:51 +0000 Subject: [PATCH 146/382] Test outlines at variable font weights --- crates/font-catalog/src/outline.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/crates/font-catalog/src/outline.rs b/crates/font-catalog/src/outline.rs index cd27e0c53..1f550f983 100644 --- a/crates/font-catalog/src/outline.rs +++ b/crates/font-catalog/src/outline.rs @@ -130,4 +130,18 @@ mod tests { let invalid_index = FontData { bytes: data.bytes.clone(), index: u32::MAX }; assert!(matches!(FontOutline::new(&invalid_index, &[]), Err(OutlineError::InvalidFace))); } + + #[test] + fn variation_changes_glyph_geometry() { + let Ok(dir) = std::env::var("CRAFT_FONTS_DIR") else { return }; + let bytes = std::fs::read(std::path::Path::new(&dir).join("fonts/noto-sans-arabic/NotoSansArabic.ttf")).unwrap(); + let data = FontData { bytes: bytes.into(), index: 0 }; + let light = FontOutline::new(&data, &[(*b"wght", 100.0)]).unwrap(); + let bold = FontOutline::new(&data, &[(*b"wght", 900.0)]).unwrap(); + let glyph = light.glyph_for('ب').unwrap(); + let light_path = light.outline(glyph).unwrap(); + let bold_path = bold.outline(glyph).unwrap(); + assert!(!light_path.elements().is_empty()); + assert_ne!(light_path, bold_path); + } } From 9c3c82e1c63e53248f99531a71cb8401f5c76150 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:16:04 +0000 Subject: [PATCH 147/382] audio: fix PCM export module documentation --- crates/audio/src/pcm_export.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/audio/src/pcm_export.rs b/crates/audio/src/pcm_export.rs index c8456d785..14e45783b 100644 --- a/crates/audio/src/pcm_export.rs +++ b/crates/audio/src/pcm_export.rs @@ -2,8 +2,8 @@ //! 16, 24 or 32-bit integer or 32-bit float ([`SampleFormat`]), for streaming export. //! Float WAV is `WAVE_FORMAT_IEEE_FLOAT` with a `fact` chunk; float AIFF is AIFF-C (`fl32`). //! -//! The header is written first from the known length ([`header`]), then the samples in chunks -//! ([`encode`]) and the pad byte ([`pad`]), so an export streams to disk instead of building the +//! The header is written first from the known length (`header`), then the samples in chunks +//! (`encode`) and the pad byte (`pad`), so an export streams to disk instead of building the //! file in memory. /// PCM representation in an exported file. From ab37b756cc86dfc552eeb351b0b407e546ec4d9e Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:16:31 +0000 Subject: [PATCH 148/382] exr: fix compressor test helper lint --- crates/exr/src/zlib.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/exr/src/zlib.rs b/crates/exr/src/zlib.rs index 8959a7e89..a38bd0b46 100644 --- a/crates/exr/src/zlib.rs +++ b/crates/exr/src/zlib.rs @@ -501,9 +501,8 @@ mod tests { } let mut sorted: Vec = (0..lens.len()).filter(|&s| lens[s] > 0).collect(); sorted.sort_by_key(|&s| (lens[s], s)); - for len in 1..16 { + for &c in count.iter().skip(1) { code |= bit(pos)? as i32; - let c = count[len]; if code - c < first { return sorted.get((index + code - first) as usize).copied(); } From b2edb7ed80d8c8fac639050a3ea02f6e0ecaff30 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:16:31 +0000 Subject: [PATCH 149/382] exr: fix compressor test helper lint --- crates/exr/src/zlib.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/exr/src/zlib.rs b/crates/exr/src/zlib.rs index 8959a7e89..a38bd0b46 100644 --- a/crates/exr/src/zlib.rs +++ b/crates/exr/src/zlib.rs @@ -501,9 +501,8 @@ mod tests { } let mut sorted: Vec = (0..lens.len()).filter(|&s| lens[s] > 0).collect(); sorted.sort_by_key(|&s| (lens[s], s)); - for len in 1..16 { + for &c in count.iter().skip(1) { code |= bit(pos)? as i32; - let c = count[len]; if code - c < first { return sorted.get((index + code - first) as usize).copied(); } From c339a9e4715bb0856603de7af897efcb43430f59 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:16:52 +0000 Subject: [PATCH 150/382] Share TIFF decode preflight fields --- crates/image-codecs/src/tiff_probe.rs | 36 +++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/crates/image-codecs/src/tiff_probe.rs b/crates/image-codecs/src/tiff_probe.rs index 1a542e412..05bd1e4db 100644 --- a/crates/image-codecs/src/tiff_probe.rs +++ b/crates/image-codecs/src/tiff_probe.rs @@ -19,6 +19,42 @@ pub enum Error { Malformed(String), } +/// First-directory values needed to preflight decoding. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct DecodeInfo { + /// Stored width. + pub width: u32, + /// Stored height. + pub height: u32, + /// First sample's bit depth, defaulting to eight. + pub bit_depth: u8, + /// Raw orientation tag, if present. + pub orientation: Option, +} + +/// Parse the first directory and enforce the pixel limit before decoding. +/// Unlike [`header`], this does not impose layout or strip checks ahead of the decoder. +pub fn decode_info(bytes: &[u8], max_pixels: u64) -> Result { + let (tiff, complete) = craft_tiff::Tiff::parse_with_status(bytes, &Default::default()).map_err(|e| Error::Malformed(e.to_string()))?; + if !complete { + return Err(Error::Malformed("truncated TIFF".into())); + } + let ifd = tiff.ifds.first().ok_or_else(|| Error::Malformed("no IFD".into()))?; + let info = ifd.image().map_err(|e| Error::Malformed(e.to_string()))?; + if info.width == 0 || info.height == 0 { + return Err(Error::Malformed("zero dimension".into())); + } + if u64::from(info.width) * u64::from(info.height) > max_pixels { + return Err(Error::TooLarge { width: info.width, height: info.height }); + } + Ok(DecodeInfo { + width: info.width, + height: info.height, + bit_depth: info.bits_per_sample.first().copied().unwrap_or(8) as u8, + orientation: ifd.u16(craft_tiff::tags::ORIENTATION), + }) +} + /// Stored dimensions and orientation of the first directory, after checking the layouts and /// image-data bounds required by the TIFF decoder. Compressed strips are not decompressed. pub fn header(bytes: &[u8], max_pixels: u64) -> Result<(u32, u32, u16), Error> { From b16c5908ae777f81fa33a9e9ad0e22b09b37a383 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:17:27 +0000 Subject: [PATCH 151/382] Cover TIFF decode preflight limits --- crates/image-codecs/src/tiff_probe.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/image-codecs/src/tiff_probe.rs b/crates/image-codecs/src/tiff_probe.rs index 05bd1e4db..6aaf5c21a 100644 --- a/crates/image-codecs/src/tiff_probe.rs +++ b/crates/image-codecs/src/tiff_probe.rs @@ -98,6 +98,9 @@ mod tests { let image = crate::Image::from_u8(2, 3, crate::ChannelLayout::Rgb, vec![42; 18]).unwrap(); let bytes = crate::encode(&image, crate::Format::Tiff, &crate::EncodeOptions::default()).unwrap(); assert_eq!(header(&bytes, 6).unwrap(), (2, 3, 1)); + let info = decode_info(&bytes, 6).unwrap(); + assert_eq!((info.width, info.height, info.bit_depth), (2, 3, 8)); + assert!(matches!(decode_info(&bytes, 5), Err(Error::TooLarge { width: 2, height: 3 }))); assert!(matches!(header(&bytes, 5), Err(Error::TooLarge { width: 2, height: 3 }))); assert!(header(&bytes[..8], 6).is_err()); } From ada2188786fd646443c4fb3326e68e52ce84c90d Mon Sep 17 00:00:00 2001 From: RRFZ <247457381+Plastic-time@users.noreply.github.com> Date: Sun, 15 Nov 2026 11:17:46 -0500 Subject: [PATCH 152/382] Preserve XML quoted-attribute and line-ending regression tests Imported from storytold/craft-anything #1738 and #1726 at 8f3b7751, adapted only to shared parse_xml entry point. --- crates/plist/tests/plist_line_endings.rs | 17 ++++++++++++++ crates/plist/tests/plist_quoted_attributes.rs | 22 +++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 crates/plist/tests/plist_line_endings.rs create mode 100644 crates/plist/tests/plist_quoted_attributes.rs diff --git a/crates/plist/tests/plist_line_endings.rs b/crates/plist/tests/plist_line_endings.rs new file mode 100644 index 000000000..3f8f82b50 --- /dev/null +++ b/crates/plist/tests/plist_line_endings.rs @@ -0,0 +1,17 @@ +use craft_plist::{self as plist, Value}; + +/// Literal line endings normalize before entities, including keys and CDATA. +#[test] +fn xml_line_endings_follow_xml_rules() { + let xml = "a\rba\r\nb\rc\nd e"; + for encoding in 0..3 { + let bytes = match encoding { + 1 => [vec![0xff, 0xfe], xml.encode_utf16().flat_map(u16::to_le_bytes).collect()].concat(), + 2 => [vec![0xfe, 0xff], xml.encode_utf16().flat_map(u16::to_be_bytes).collect()].concat(), + _ => xml.as_bytes().to_vec(), + }; + let value = plist::parse_xml(&bytes).unwrap(); + assert_eq!(value.get("a\nb").and_then(Value::as_str), Some("a\nb\nc\nd\ref\ng")); + } + assert!(plist::parse_xml(b"a\r\nb").is_err()); +} diff --git a/crates/plist/tests/plist_quoted_attributes.rs b/crates/plist/tests/plist_quoted_attributes.rs new file mode 100644 index 000000000..54cd042ef --- /dev/null +++ b/crates/plist/tests/plist_quoted_attributes.rs @@ -0,0 +1,22 @@ +use craft_plist::{self as plist, Value}; + +/// Quoted delimiters belong to attributes, including on empty elements. +#[test] +fn quoted_tag_delimiters_preserve_values() { + for quote in ['\'', '"'] { + let xml = format!( + "b{quote}>界{quote}>key/{quote}>valueempty/{quote}/>" + ); + let value = plist::parse_xml(xml.as_bytes()).unwrap(); + assert_eq!(value.get("key").and_then(Value::as_str), Some("value")); + assert_eq!(value.get("empty").and_then(Value::as_str), Some("")); + } +} + +/// A quote that never closes must not turn later markup into a value. +#[test] +fn unterminated_attribute_quotes_are_rejected() { + for xml in ["value", " 0, + b'G' => 1, + b'B' => 2, + 0 => break, + _ => continue, + }; + if depths[index] != 0 || pair[1] == 0 { + return 0; + } + depths[index] = pair[1]; + } + if depths[0] != 0 && depths.iter().all(|&depth| depth == depths[0]) { u32::from(depths[0]) } else { 0 } +} + fn picture_info(d: &Set) -> PictureInfo { let u = |t| d.u(t).unwrap_or(0) as u32; + let rgba = d.kind() == Some(st::RGBA_DESCRIPTOR); PictureInfo { stored_width: u(tag::STORED_WIDTH), stored_height: u(tag::STORED_HEIGHT), @@ -581,13 +605,13 @@ fn picture_info(d: &Set) -> PictureInfo { frame_layout: u(tag::FRAME_LAYOUT) as u8, field_dominance: u(tag::FIELD_DOMINANCE) as u8, aspect_ratio: d.rational(tag::ASPECT_RATIO).unwrap_or_default(), - component_depth: u(tag::COMPONENT_DEPTH), + component_depth: if rgba { d.get(tag::PIXEL_LAYOUT).map_or(0, rgba_component_depth) } else { u(tag::COMPONENT_DEPTH) }, horizontal_subsampling: u(tag::HORIZONTAL_SUBSAMPLING), vertical_subsampling: u(tag::VERTICAL_SUBSAMPLING), - black_ref_level: d.u(tag::BLACK_REF_LEVEL).map(|v| v as u32), - white_ref_level: d.u(tag::WHITE_REF_LEVEL).map(|v| v as u32), + black_ref_level: d.u(if rgba { tag::COMPONENT_MIN_REF } else { tag::BLACK_REF_LEVEL }).map(|v| v as u32), + white_ref_level: d.u(if rgba { tag::COMPONENT_MAX_REF } else { tag::WHITE_REF_LEVEL }).map(|v| v as u32), alpha_depth: u(tag::ALPHA_SAMPLE_DEPTH), - rgba: d.kind() == Some(st::RGBA_DESCRIPTOR), + rgba, picture_coding: d.ul(tag::PICTURE_ESSENCE_CODING), transfer_characteristic: d.ul(tag::TRANSFER_CHARACTERISTIC), coding_equations: d.ul(tag::CODING_EQUATIONS), @@ -1343,3 +1367,24 @@ mod fallback_tracks_tests { assert_eq!(tracks.len(), 1); } } + +#[cfg(test)] +mod rgba_layout_tests { + use super::rgba_component_depth; + + #[test] + fn only_complete_uniform_rgb_layouts_have_one_depth() { + let mut layout = [0; 16]; + layout[..8].copy_from_slice(&[b'B', 16, b'G', 16, b'R', 16, b'A', 8]); + assert_eq!(rgba_component_depth(&layout), 16); + assert_eq!(rgba_component_depth(&layout[..15]), 0); + layout[3] = 8; + assert_eq!(rgba_component_depth(&layout), 0); + layout[3] = 16; + layout[4] = b'G'; + assert_eq!(rgba_component_depth(&layout), 0); + layout[4] = 0; + assert_eq!(rgba_component_depth(&layout), 0); + assert_eq!(rgba_component_depth(&[0; 16]), 0); + } +} diff --git a/crates/media/src/mxf/meta.rs b/crates/media/src/mxf/meta.rs index d02afdd71..2b649d099 100644 --- a/crates/media/src/mxf/meta.rs +++ b/crates/media/src/mxf/meta.rs @@ -204,6 +204,8 @@ pub mod tag { pub const WHITE_REF_LEVEL: u16 = 0x3305; pub const ALPHA_SAMPLE_DEPTH: u16 = 0x3309; pub const PIXEL_LAYOUT: u16 = 0x3401; + pub const COMPONENT_MAX_REF: u16 = 0x3406; + pub const COMPONENT_MIN_REF: u16 = 0x3407; pub const AUDIO_SAMPLING_RATE: u16 = 0x3D03; pub const LOCKED: u16 = 0x3D02; pub const CHANNEL_COUNT: u16 = 0x3D07; diff --git a/crates/media/src/mxf/write/tests.rs b/crates/media/src/mxf/write/tests.rs index eac50a0e9..bc60423e9 100644 --- a/crates/media/src/mxf/write/tests.rs +++ b/crates/media/src/mxf/write/tests.rs @@ -434,6 +434,10 @@ fn cinemadng_op1a_reads_back() { assert_eq!(t.samples.len(), 6); let p = t.picture.as_ref().unwrap(); assert!(p.rgba, "RGBA picture essence descriptor (§7.2.2)"); + assert_eq!(p.component_depth, 16); + assert_eq!(p.black_ref_level, Some(0)); + assert_eq!(p.white_ref_level, Some(65_535)); + assert!(p.full_range()); assert_eq!((p.frame_width(), p.frame_height()), (64, 36)); assert!(p.picture_coding.is_none()); for i in 0..6 { From f78b0ac48439354229827c50c25a50fc19c71ea8 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 11:18:07 -0500 Subject: [PATCH 154/382] Expose bounded XML plist parsing and cap malformed entity scans --- ATTRIBUTION.md | 2 + crates/plist/Cargo.toml | 2 +- crates/plist/README.md | 12 +++++- crates/plist/src/lib.rs | 6 ++- crates/plist/src/xml.rs | 91 ++++++++++++++++++++++++++++++++++------- 5 files changed, 93 insertions(+), 20 deletions(-) diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md index ef3b98f31..43d543062 100644 --- a/ATTRIBUTION.md +++ b/ATTRIBUTION.md @@ -100,3 +100,5 @@ and the exact transfer revision are recorded in each vendored crate's SOURCE.jso ## Binary Apple property lists `crates/plist` is extracted from `storytold/craft-anything` (`crates/formats/src/plist.rs` and checked byte reads), at source main `88d1d9cac852aec1c7fd97886db451e005e49d2a`. MIT OR Apache-2.0; source license texts are retained in the crate. Primary import Git authors preserve Brandon Thomas, BFlat, RRFZ and Afloat. Regression imports preserve BFlat. XML, JSON projection, calendar formatting and app policy were not imported into the public API. + +The XML reader in `crates/plist/src/xml.rs` and its base64 compatibility helper are ported from Craft Anything `8f3b775157d331dd31cfa4da911e26d8856b8c77` (same MIT OR Apache-2.0 source licenses). Brandon Thomas is the primary import author; retained hardening credits include Afloat, BFlat, Rahul, RRFZ and NetterSilver. The finite-real fix preserves gmrmad1 as author from Craft Anything #1905 (`d85e104f`); quoted-attribute/line-ending regressions preserve RRFZ. Bounds/adaptation and bounded entity scanning are subsequent Dylan M. Taylor changes. App-specific JSON projections and keyed-archive interpretation remain outside this crate. diff --git a/crates/plist/Cargo.toml b/crates/plist/Cargo.toml index 7ae95aae0..7ffaf3480 100644 --- a/crates/plist/Cargo.toml +++ b/crates/plist/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "craft-plist" -description = "Bounded cross-platform binary Apple property-list reader" +description = "Bounded cross-platform binary and XML Apple property-list reader" version.workspace = true edition.workspace = true license.workspace = true diff --git a/crates/plist/README.md b/crates/plist/README.md index dc5c52007..5621ef96a 100644 --- a/crates/plist/README.md +++ b/crates/plist/README.md @@ -4,8 +4,16 @@ A cross-platform bounded binary (`bplist00`) reader, extracted from Craft Anythi `parse_binary_with_limits` accepts explicit input, object, expanded-node, nesting and decoded-byte limits. Recursion always has a hard ceiling of 256 even if a caller supplies a larger depth. Counts are checked before container reservation; allocations can return a resource error. Limits are per parse, not a promise of a precise process RSS cap. -This first PR contains reading only. XML parsing/writing and keyed-archive interpretation are not implemented. JSON projection, date formatting, OS file access and preference/locale selection are not part of this crate. Existing updater/Photo streaming `plist` users remain unchanged. +This crate contains reading only. Writing and keyed-archive interpretation are not implemented. JSON projection, date formatting, OS file access and preference/locale selection are not part of this crate. Existing updater/Photo streaming `plist` users remain unchanged. -Initial consumers: PhotoCraft's AppleLanguages binary-reader path; later Craft Anything binary parsing and LightCraft XML presets (after XML support/parity). Photo must retain its 4 MiB input policy and first-language selection. +Initial consumers: PhotoCraft's AppleLanguages binary-reader path; later Craft Anything binary parsing and LightCraft XML presets (after consumer parity). Photo must retain its 4 MiB input policy and first-language selection. Source: `storytold/craft-anything` at `88d1d9cac852aec1c7fd97886db451e005e49d2a`, `crates/formats/src/plist.rs` and checked byte reader. Source license files retained. Imported changes retain Brandon Thomas, BFlat, RRFZ and Afloat as primary Git authors; imported regression tests are BFlat's. No external specification implementation copied. + +## XML reader + +`parse_xml` and `parse_xml_with_limits` now read UTF-8 and BOM-tagged UTF-16 XML into the same `Value` tree. XML input/decoded-text size, tokens, values, nesting and cumulative key/leaf text are bounded. The independent token ceiling is eight times the smaller node/object allowance plus eight; unusually fragmented text can exhaust it before the value limit. This is not a precise RSS limit. The decoded-XML limit also includes markup; `` consumes its encoded text allowance, including whitespace. XML `max_objects` and `max_nodes` both cap values. + +The attributed Craft Anything reader includes its complete-document, declaration-skipping (no external entity fetching), quoted-tag and normalized-line-ending behavior. Nonfinite reals are refused using contributor PR #1905. Unknown or malformed character references retain legacy literal behavior; scanning is bounded before searching for a terminator. Base64 retains that reader's legacy optional-padding/ASCII-whitespace behavior, including unused trailing bits; it is not a signature/key-validation API. No writer, JSON projection, keyed-archive interpretation or app policy is added. + +XML source: Craft Anything `8f3b775157d331dd31cfa4da911e26d8856b8c77`, plus #1905 `d85e104f093a334961048881bf003351e1ac4992`. The import credits Brandon Thomas and the existing hardening contributors; #1905 is authored by gmrmad1 and the quoted-tag/line-ending tests by RRFZ. Consumer cutovers require their own policy/parity tests, especially LightCraft's preset mapping and Craft Anything's projections. diff --git a/crates/plist/src/lib.rs b/crates/plist/src/lib.rs index f3af79ddc..2547e73d8 100644 --- a/crates/plist/src/lib.rs +++ b/crates/plist/src/lib.rs @@ -1,10 +1,12 @@ -//! Bounded binary Apple property lists, independent of operating-system preferences. -//! XML and writing are intentionally not implemented in this first extraction. +//! Bounded binary and XML Apple property lists, independent of operating-system preferences. +//! Writing and application-specific projections remain with callers. //! File discovery, locale selection, bundle validation and application policy stay in callers. #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)] mod binary; mod bytes; +mod xml; pub use binary::{DateValue, Value, first_string_in_array, parse_binary, parse_binary_with_limits}; +pub use xml::{parse_xml, parse_xml_with_limits}; /// Caller-selected resource limits. Zero values refuse the corresponding resource. #[derive(Clone, Copy, Debug)] diff --git a/crates/plist/src/xml.rs b/crates/plist/src/xml.rs index 54fd9f895..52f5c4586 100644 --- a/crates/plist/src/xml.rs +++ b/crates/plist/src/xml.rs @@ -1,7 +1,5 @@ //! XML property-list reader ported from Craft Anything at 8f3b7751. -use crate::{DateValue, FormatError, Value}; -const MAX_NODES: usize = 100_000; -const MAX_DEPTH: usize = 64; +use crate::{DateValue, FormatError, Limits, Value}; fn decode_base64(text: &str, url_safe: bool) -> Option> { let mut out = Vec::with_capacity(text.len() / 4 * 3); let mut acc = 0u32; @@ -47,7 +45,9 @@ fn decode_base64(text: &str, url_safe: bool) -> Option> { Some(out) } -fn base64_decode(s: &str) -> Option> { decode_base64(s, false) } +fn base64_decode(s: &str) -> Option> { + decode_base64(s, false) +} #[derive(Debug, Clone, PartialEq)] enum Tok { Open(String), @@ -65,7 +65,7 @@ fn decode_entities(s: &str) -> String { while let Some(p) = rest.find('&') { out.push_str(rest.get(..p).unwrap_or("")); let after = rest.get(p..).unwrap_or(""); - let Some(end) = after.find(';').filter(|&e| e <= 12) else { + let Some(end) = after.as_bytes().iter().take(13).position(|b| *b == b';') else { out.push('&'); rest = after.get(1..).unwrap_or(""); continue; @@ -131,11 +131,11 @@ fn after_declaration(mut rest: &str) -> Result<&str, FormatError> { Err(FormatError::Truncated("declaration".into())) } -fn tokenize(text: &str) -> Result, FormatError> { +fn tokenize(text: &str, max_tokens: usize) -> Result, FormatError> { let mut toks = Vec::new(); let mut rest = text; while !rest.is_empty() { - if toks.len() > MAX_NODES { + if toks.len() >= max_tokens { return Err(FormatError::TooLarge("too many XML tokens".into())); } match rest.find('<') { @@ -198,6 +198,9 @@ fn tokenize(text: &str) -> Result, FormatError> { toks.push(Tok::Open(inner.split_whitespace().next().unwrap_or("").to_string())); } } + if toks.len() > max_tokens { + return Err(FormatError::TooLarge("too many XML tokens".into())); + } Ok(toks) } @@ -205,6 +208,8 @@ struct Xml { toks: Vec, pos: usize, nodes: usize, + limits: Limits, + bytes_left: usize, } impl Xml { @@ -223,7 +228,10 @@ impl Xml { let mut s = String::new(); loop { match self.next() { - Some(Tok::Text(t)) => s.push_str(&t), + Some(Tok::Text(t)) => { + self.bytes_left = self.bytes_left.checked_sub(t.len()).ok_or_else(|| FormatError::TooLarge("XML text/data bytes".into()))?; + s.push_str(&t); + } Some(Tok::Close(n)) if n == name => return Ok(s), Some(other) => return Err(FormatError::Malformed(format!("unexpected {other:?} inside <{name}>"))), None => return Err(FormatError::Truncated(format!("<{name}> is not closed"))), @@ -239,7 +247,7 @@ impl Xml { fn value(&mut self, depth: usize) -> Result { self.nodes += 1; - if depth > MAX_DEPTH || self.nodes > MAX_NODES { + if depth > self.limits.max_depth.min(256) || self.nodes > self.limits.max_nodes.min(self.limits.max_objects) { return Err(FormatError::TooLarge("plist nesting or size limit".into())); } self.skip_space(); @@ -267,7 +275,12 @@ impl Xml { } "real" => { let t = self.text_until("real")?; - t.trim().parse::().ok().filter(|v| v.is_finite()).map(Value::Real).ok_or_else(|| FormatError::Malformed(format!("bad real {t:?}"))) + t.trim() + .parse::() + .ok() + .filter(|v| v.is_finite()) + .map(Value::Real) + .ok_or_else(|| FormatError::Malformed(format!("bad real {t:?}"))) } "date" => Ok(Value::Date(DateValue::Text(self.text_until("date")?.trim().to_string()))), "data" => { @@ -330,12 +343,24 @@ fn decode_utf16_xml(data: &[u8], big_endian: bool) -> Result = data.chunks_exact(2).map(|b| if big_endian { u16::from_be_bytes([b[0], b[1]]) } else { u16::from_le_bytes([b[0], b[1]]) }).collect(); + let units: Vec = data.as_chunks::<2>().0.iter().map(|b| if big_endian { u16::from_be_bytes(*b) } else { u16::from_le_bytes(*b) }).collect(); String::from_utf16(&units).map_err(|_| FormatError::Malformed("invalid UTF-16 in XML plist".into())) } /// Parse an XML property list. pub fn parse_xml(data: &[u8]) -> Result { + parse_xml_with_limits(data, Limits::default()) +} + +/// Parse UTF-8 or BOM-tagged UTF-16 XML with explicit resource allowances. +/// Input and decoded XML text are bounded before tokenization; token count, value count, +/// nesting and cumulative leaf/key text are bounded separately. `max_objects` and +/// `max_nodes` both cap values. Nesting never exceeds 256 even with a larger caller limit. +/// Data text consumes its encoded size, conservatively including whitespace. +pub fn parse_xml_with_limits(data: &[u8], limits: Limits) -> Result { + if data.len() > limits.max_input_bytes { + return Err(FormatError::TooLarge("input bytes".into())); + } // Apple's Core Foundation reader accepts XML plists in UTF-16 as well as // UTF-8: it recognises both byte-order marks. `from_utf8_lossy` turns a // UTF-16 byte stream into NUL-separated text, so the encoding is settled @@ -347,11 +372,14 @@ pub fn parse_xml(data: &[u8]) -> Result { .map_err(|_| FormatError::Malformed("invalid UTF-8 in XML plist".into()))? .to_owned(), }; + if text.len() > limits.max_expanded_bytes { + return Err(FormatError::TooLarge("decoded XML bytes".into())); + } // XML normalizes literal line endings before parsing; character references such as // must still decode to a carriage return afterwards. let text = if text.contains('\r') { text.replace("\r\n", "\n").replace('\r', "\n") } else { text }; - let toks = tokenize(&text)?; - let mut x = Xml { toks, pos: 0, nodes: 0 }; + let toks = tokenize(&text, limits.max_nodes.min(limits.max_objects).saturating_mul(8).saturating_add(8))?; + let mut x = Xml { toks, pos: 0, nodes: 0, limits, bytes_left: limits.max_expanded_bytes }; x.skip_space(); let wrapped = matches!(x.peek(), Some(Tok::Open(n)) if n == "plist"); if wrapped { @@ -371,10 +399,9 @@ pub fn parse_xml(data: &[u8]) -> Result { Ok(value) } - #[cfg(test)] mod tests { -use super::*; + use super::*; #[test] fn xml_has_one_complete_root_with_only_markup_space_around_values() { for invalid in [ @@ -441,4 +468,38 @@ use super::*; assert_eq!(v.get("k"), Some(&Value::Real(want)), "{text}"); } } + + #[test] + fn malformed_entity_scan_is_bounded_and_preserves_text() { + for n in [4096, 65536, 262144] { + let text = "&".repeat(n); + assert_eq!(decode_entities(&text), text); + assert_eq!(decode_entities(&(text.clone() + ";")), text + ";"); + } + assert_eq!(decode_entities("é&missing; & A"), "é&missing; & \r A"); + } + #[test] + fn caller_limits_refuse_before_unbounded_tree_growth() { + let limits = Limits { max_input_bytes: 3, ..Limits::default() }; + assert!(matches!(parse_xml_with_limits(b"", limits), Err(FormatError::TooLarge(_)))); + let limits = Limits { max_nodes: 1, ..Limits::default() }; + assert!(matches!(parse_xml_with_limits(b"", limits), Err(FormatError::TooLarge(_)))); + let limits = Limits { max_depth: 0, ..Limits::default() }; + assert!(matches!(parse_xml_with_limits(b"", limits), Err(FormatError::TooLarge(_)))); + let limits = Limits { max_expanded_bytes: 8, ..Limits::default() }; + assert!(matches!(parse_xml_with_limits(b"abc", limits), Err(FormatError::TooLarge(_)))); + assert!(parse_xml_with_limits(b"", Limits::default()).is_ok()); + } + #[test] + fn data_preserves_existing_whitespace_padding_and_alphabet_rules() { + for (s, expected) in [(" Z g == ", Some(vec![102])), ("Zg", Some(vec![102])), ("Zg=", None), ("Zg==junk", None), ("_w==", None)] { + let xml = format!("{s}"); + assert_eq!(parse_xml(xml.as_bytes()).ok(), expected.map(Value::Data)); + } + } + #[test] + fn small_node_allowance_accepts_one_dictionary_entry() { + let limits = Limits { max_nodes: 2, max_objects: 2, ..Limits::default() }; + assert!(parse_xml_with_limits(b"kv", limits).is_ok()); + } } From f53ed0c505008412554322fda6d5edba79d9f860 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 11:18:38 -0500 Subject: [PATCH 155/382] Scope imported XML test assertions to test-only lint policy --- crates/plist/src/xml.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/plist/src/xml.rs b/crates/plist/src/xml.rs index 52f5c4586..c6cc4d022 100644 --- a/crates/plist/src/xml.rs +++ b/crates/plist/src/xml.rs @@ -401,6 +401,7 @@ pub fn parse_xml_with_limits(data: &[u8], limits: Limits) -> Result Date: Sun, 15 Nov 2026 16:18:57 +0000 Subject: [PATCH 156/382] Bound and expose partial glyph outlines --- crates/font-catalog/src/outline.rs | 92 ++++++++++++++++++++++++++---- 1 file changed, 81 insertions(+), 11 deletions(-) diff --git a/crates/font-catalog/src/outline.rs b/crates/font-catalog/src/outline.rs index 1f550f983..10a1ae8ab 100644 --- a/crates/font-catalog/src/outline.rs +++ b/crates/font-catalog/src/outline.rs @@ -26,6 +26,12 @@ pub enum OutlineError { /// The glyph's outline is malformed. #[error("cannot draw glyph outline: {0}")] Draw(#[from] skrifa::outline::DrawError), + /// The glyph emitted more path elements than the safety limit. + #[error("glyph outline exceeds the element limit")] + TooComplex, + /// The outline starts without a move command. + #[error("glyph outline has no initial move")] + InvalidPath, } impl<'a> FontOutline<'a> { @@ -58,30 +64,83 @@ impl<'a> FontOutline<'a> { } /// Draw a glyph in design units. Empty glyphs such as spaces can produce an empty path. + /// A malformed or excessively complex glyph returns an error instead of partial geometry. pub fn outline(&self, glyph: u32) -> Result { + let (path, status) = self.outline_recovering(glyph)?; + status.map(|()| path) + } + + /// Draw a glyph while retaining the bounded prefix produced before a draw error. This is + /// useful for consumers preserving existing rendering of damaged fonts. The inner result + /// reports whether the returned path is complete; the outer error means no glyph was found. + /// Paths stop growing at 100,000 elements, even when the font is untrusted. + pub fn outline_recovering(&self, glyph: u32) -> Result<(BezPath, Result<(), OutlineError>), OutlineError> { let outline = self.font.outline_glyphs().get(GlyphId::new(glyph)).ok_or(OutlineError::MissingGlyph)?; - let mut pen = PathPen(BezPath::new()); - outline.draw(DrawSettings::unhinted(Size::unscaled(), &self.location), &mut pen)?; - Ok(pen.0) + let mut pen = PathPen::new(); + let result = outline.draw(DrawSettings::unhinted(Size::unscaled(), &self.location), &mut pen); + let status = if pen.invalid { + Err(OutlineError::InvalidPath) + } else if pen.truncated { + Err(OutlineError::TooComplex) + } else { + result.map(|_| ()).map_err(OutlineError::Draw) + }; + Ok((pen.path, status)) } } -struct PathPen(BezPath); +const MAX_OUTLINE_ELEMENTS: usize = 100_000; +struct PathPen { + path: BezPath, + truncated: bool, + invalid: bool, +} +impl PathPen { + fn new() -> Self { + Self { path: BezPath::new(), truncated: false, invalid: false } + } + fn has_start(&mut self) -> bool { + if self.path.elements().is_empty() { + self.invalid = true; + false + } else { + true + } + } + fn room(&mut self) -> bool { + if self.path.elements().len() >= MAX_OUTLINE_ELEMENTS { + self.truncated = true; + false + } else { + true + } + } +} impl OutlinePen for PathPen { fn move_to(&mut self, x: f32, y: f32) { - self.0.move_to((f64::from(x), f64::from(y))); + if self.room() { + self.path.move_to((f64::from(x), f64::from(y))); + } } fn line_to(&mut self, x: f32, y: f32) { - self.0.line_to((f64::from(x), f64::from(y))); + if self.has_start() && self.room() { + self.path.line_to((f64::from(x), f64::from(y))); + } } fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) { - self.0.quad_to((f64::from(x1), f64::from(y1)), (f64::from(x), f64::from(y))); + if self.has_start() && self.room() { + self.path.quad_to((f64::from(x1), f64::from(y1)), (f64::from(x), f64::from(y))); + } } fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) { - self.0.curve_to((f64::from(x1), f64::from(y1)), (f64::from(x2), f64::from(y2)), (f64::from(x), f64::from(y))); + if self.has_start() && self.room() { + self.path.curve_to((f64::from(x1), f64::from(y1)), (f64::from(x2), f64::from(y2)), (f64::from(x), f64::from(y))); + } } fn close(&mut self) { - self.0.close_path(); + if self.has_start() && self.room() { + self.path.close_path(); + } } } @@ -99,14 +158,14 @@ mod tests { #[test] fn pen_preserves_geometry_and_upward_y() { - let mut pen = PathPen(BezPath::new()); + let mut pen = PathPen::new(); pen.move_to(1.0, 2.0); pen.line_to(3.0, 4.0); pen.quad_to(5.0, 6.0, 7.0, 8.0); pen.curve_to(9.0, 10.0, 11.0, 12.0, 13.0, 14.0); pen.close(); assert_eq!( - pen.0.elements(), + pen.path.elements(), &[ PathEl::MoveTo((1.0, 2.0).into()), PathEl::LineTo((3.0, 4.0).into()), @@ -117,6 +176,17 @@ mod tests { ); } + #[test] + fn pen_caps_path_growth() { + let mut pen = PathPen::new(); + pen.move_to(0.0, 0.0); + for _ in 0..MAX_OUTLINE_ELEMENTS { + pen.line_to(1.0, 2.0); + } + assert_eq!(pen.path.elements().len(), MAX_OUTLINE_ELEMENTS); + assert!(pen.truncated); + } + #[test] fn reads_craft_font_when_available() { let Ok(dir) = std::env::var("CRAFT_FONTS_DIR") else { return }; From c17840e099d7a4237770bca99efb2693f1692a8d Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 11:21:36 -0500 Subject: [PATCH 157/382] Preserve LightCraft zero-padded entities with linear scanning Reuse LightCraft f786b87533e58c6d31c7f9f2897814904448f39a entity_end implementation and regression. XML numeric references are not arbitrarily length limited. --- crates/plist/README.md | 2 +- crates/plist/src/xml.rs | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/crates/plist/README.md b/crates/plist/README.md index 5621ef96a..a7adf6c79 100644 --- a/crates/plist/README.md +++ b/crates/plist/README.md @@ -14,6 +14,6 @@ Source: `storytold/craft-anything` at `88d1d9cac852aec1c7fd97886db451e005e49d2a` `parse_xml` and `parse_xml_with_limits` now read UTF-8 and BOM-tagged UTF-16 XML into the same `Value` tree. XML input/decoded-text size, tokens, values, nesting and cumulative key/leaf text are bounded. The independent token ceiling is eight times the smaller node/object allowance plus eight; unusually fragmented text can exhaust it before the value limit. This is not a precise RSS limit. The decoded-XML limit also includes markup; `` consumes its encoded text allowance, including whitespace. XML `max_objects` and `max_nodes` both cap values. -The attributed Craft Anything reader includes its complete-document, declaration-skipping (no external entity fetching), quoted-tag and normalized-line-ending behavior. Nonfinite reals are refused using contributor PR #1905. Unknown or malformed character references retain legacy literal behavior; scanning is bounded before searching for a terminator. Base64 retains that reader's legacy optional-padding/ASCII-whitespace behavior, including unused trailing bits; it is not a signature/key-validation API. No writer, JSON projection, keyed-archive interpretation or app policy is added. +The attributed Craft Anything reader includes its complete-document, declaration-skipping (no external entity fetching), quoted-tag and normalized-line-ending behavior. Nonfinite reals are refused using contributor PR #1905. Unknown or malformed character references retain legacy literal behavior; scanning stops at the next non-entity byte, preserving LightCraft's valid zero-padded numeric references without suffix rescans. Base64 retains that reader's legacy optional-padding/ASCII-whitespace behavior, including unused trailing bits; it is not a signature/key-validation API. No writer, JSON projection, keyed-archive interpretation or app policy is added. XML source: Craft Anything `8f3b775157d331dd31cfa4da911e26d8856b8c77`, plus #1905 `d85e104f093a334961048881bf003351e1ac4992`. The import credits Brandon Thomas and the existing hardening contributors; #1905 is authored by gmrmad1 and the quoted-tag/line-ending tests by RRFZ. Consumer cutovers require their own policy/parity tests, especially LightCraft's preset mapping and Craft Anything's projections. diff --git a/crates/plist/src/xml.rs b/crates/plist/src/xml.rs index c6cc4d022..be225d3fb 100644 --- a/crates/plist/src/xml.rs +++ b/crates/plist/src/xml.rs @@ -56,6 +56,12 @@ enum Tok { Text(String), } +// Ported from LightCraft f786b875: scan one entity-name run, never the remaining document. +fn entity_end(rest: &str) -> Option { + let n = rest.bytes().skip(1).take_while(|b| b.is_ascii_alphanumeric() || *b == b'#').count(); + (rest.as_bytes().get(n + 1) == Some(&b';')).then_some(n + 1) +} + fn decode_entities(s: &str) -> String { if !s.contains('&') { return s.to_string(); @@ -65,7 +71,7 @@ fn decode_entities(s: &str) -> String { while let Some(p) = rest.find('&') { out.push_str(rest.get(..p).unwrap_or("")); let after = rest.get(p..).unwrap_or(""); - let Some(end) = after.as_bytes().iter().take(13).position(|b| *b == b';') else { + let Some(end) = entity_end(after) else { out.push('&'); rest = after.get(1..).unwrap_or(""); continue; @@ -478,6 +484,7 @@ mod tests { assert_eq!(decode_entities(&(text.clone() + ";")), text + ";"); } assert_eq!(decode_entities("é&missing; & A"), "é&missing; & \r A"); + assert_eq!(decode_entities("Canon A"), "Canon A"); } #[test] fn caller_limits_refuse_before_unbounded_tree_growth() { From 2aa7f7f8d211786650d6cc3a4d3f6be165ddb30a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:22:05 +0000 Subject: [PATCH 158/382] dpx: fix RGBA writer lint --- crates/dpx/src/rgba8_dpx10.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/dpx/src/rgba8_dpx10.rs b/crates/dpx/src/rgba8_dpx10.rs index 6ec5e23b4..05ce20b15 100644 --- a/crates/dpx/src/rgba8_dpx10.rs +++ b/crates/dpx/src/rgba8_dpx10.rs @@ -21,7 +21,7 @@ const DPX_HEADER: usize = 2048; pub fn encode_rgba8_dpx10(rgba: &[u8], w: u32, h: u32, creator: &str) -> std::result::Result, Rgba8EncodeError> { let n = checked_len(rgba, w, h)?; // one 32-bit word per pixel; `n` is already `w * h * 4` - let size = n.checked_add(DPX_HEADER).ok_or_else(|| Rgba8EncodeError::FrameSize)?; + let size = n.checked_add(DPX_HEADER).ok_or(Rgba8EncodeError::FrameSize)?; let file_size = u32::try_from(size).map_err(|_| Rgba8EncodeError::TooLarge)?; // SMPTE ST 268: undefined numeric fields are all ones, undefined text fields are NUL let mut hd = vec![0xFF_u8; DPX_HEADER]; From 4c17e51335192345d8e508287c26f17fead930ac Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:23:03 +0000 Subject: [PATCH 159/382] exr: fix RGBA writer lint --- crates/exr/src/rgba8.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/exr/src/rgba8.rs b/crates/exr/src/rgba8.rs index 0b26ab8c9..6dc4bde4c 100644 --- a/crates/exr/src/rgba8.rs +++ b/crates/exr/src/rgba8.rs @@ -81,7 +81,7 @@ pub fn write_rgba8(rgba: &[u8], w: u32, h: u32, alpha: bool, compression: Compre }; // channels in the alphabetical order the file layout requires let names: &[u8] = if alpha { b"ABGR" } else { b"BGR" }; - let line = (w as usize).checked_mul(names.len() * 2).ok_or_else(|| Error::FrameSize)?; + let line = (w as usize).checked_mul(names.len() * 2).ok_or(Error::FrameSize)?; // a chunk's byte count is a signed 32-bit field let lines = compression.lines(); if line.checked_mul(lines).and_then(|c| i32::try_from(c).ok()).is_none() { @@ -125,7 +125,7 @@ pub fn write_rgba8(rgba: &[u8], w: u32, h: u32, alpha: bool, compression: Compre let chunks = (h as usize).div_ceil(lines); let table = chunks.checked_mul(8); let body = (h as usize).checked_mul(line + 8); - let size = table.zip(body).and_then(|(t, b)| hd.len().checked_add(t)?.checked_add(b)).ok_or_else(|| Error::FrameSize)?; + let size = table.zip(body).and_then(|(t, b)| hd.len().checked_add(t)?.checked_add(b)).ok_or(Error::FrameSize)?; // the uncompressed size: compressed chunks only shrink it let mut out = Vec::with_capacity(size); out.extend_from_slice(&hd); From 0dab3133a2a58d321ade446f23592e7855b79e78 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 11:24:10 -0500 Subject: [PATCH 160/382] Allow consumers to retain opaque XML date text --- crates/plist/src/lib.rs | 2 +- crates/plist/src/xml.rs | 35 +++++++++++++++++++++++++++++++++-- 2 files changed, 34 insertions(+), 3 deletions(-) diff --git a/crates/plist/src/lib.rs b/crates/plist/src/lib.rs index 2547e73d8..d668de277 100644 --- a/crates/plist/src/lib.rs +++ b/crates/plist/src/lib.rs @@ -6,7 +6,7 @@ mod binary; mod bytes; mod xml; pub use binary::{DateValue, Value, first_string_in_array, parse_binary, parse_binary_with_limits}; -pub use xml::{parse_xml, parse_xml_with_limits}; +pub use xml::{XmlOptions, parse_xml, parse_xml_with_limits, parse_xml_with_options}; /// Caller-selected resource limits. Zero values refuse the corresponding resource. #[derive(Clone, Copy, Debug)] diff --git a/crates/plist/src/xml.rs b/crates/plist/src/xml.rs index be225d3fb..d30b938d0 100644 --- a/crates/plist/src/xml.rs +++ b/crates/plist/src/xml.rs @@ -1,5 +1,18 @@ //! XML property-list reader ported from Craft Anything at 8f3b7751. use crate::{DateValue, FormatError, Limits, Value}; + +/// XML-specific representation policy, separate from resource allowances. +#[derive(Clone, Copy, Debug)] +pub struct XmlOptions { + /// Trim surrounding whitespace in date text, as the original Craft Anything reader does. + /// Disable for consumers that retain dates as opaque strings, such as Luminar presets. + pub trim_date_text: bool, +} +impl Default for XmlOptions { + fn default() -> Self { + Self { trim_date_text: true } + } +} fn decode_base64(text: &str, url_safe: bool) -> Option> { let mut out = Vec::with_capacity(text.len() / 4 * 3); let mut acc = 0u32; @@ -216,6 +229,7 @@ struct Xml { nodes: usize, limits: Limits, bytes_left: usize, + options: XmlOptions, } impl Xml { @@ -288,7 +302,10 @@ impl Xml { .map(Value::Real) .ok_or_else(|| FormatError::Malformed(format!("bad real {t:?}"))) } - "date" => Ok(Value::Date(DateValue::Text(self.text_until("date")?.trim().to_string()))), + "date" => { + let text = self.text_until("date")?; + Ok(Value::Date(DateValue::Text(if self.options.trim_date_text { text.trim().to_string() } else { text }))) + } "data" => { let t = self.text_until("data")?; base64_decode(&t).map(Value::Data).ok_or_else(|| FormatError::Malformed("bad base64 in ".into())) @@ -364,6 +381,11 @@ pub fn parse_xml(data: &[u8]) -> Result { /// `max_nodes` both cap values. Nesting never exceeds 256 even with a larger caller limit. /// Data text consumes its encoded size, conservatively including whitespace. pub fn parse_xml_with_limits(data: &[u8], limits: Limits) -> Result { + parse_xml_with_options(data, limits, XmlOptions::default()) +} + +/// Parse bounded XML using an explicit date-text representation policy. +pub fn parse_xml_with_options(data: &[u8], limits: Limits, options: XmlOptions) -> Result { if data.len() > limits.max_input_bytes { return Err(FormatError::TooLarge("input bytes".into())); } @@ -385,7 +407,7 @@ pub fn parse_xml_with_limits(data: &[u8], limits: Limits) -> Resultkv", limits).is_ok()); } + #[test] + fn callers_can_preserve_opaque_date_whitespace() { + let xml = b" 2026-01-01T00:00:00Z "; + assert_eq!(parse_xml(xml).unwrap(), Value::Date(DateValue::Text("2026-01-01T00:00:00Z".into()))); + assert_eq!( + parse_xml_with_options(xml, Limits::default(), XmlOptions { trim_date_text: false }).unwrap(), + Value::Date(DateValue::Text(" 2026-01-01T00:00:00Z ".into())) + ); + } } From 159b942defe3613c91a4beec5fadfcb1593f2600 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 16:24:27 +0000 Subject: [PATCH 161/382] Share contextual directional text shaping --- Cargo.lock | 1 + crates/font-catalog/Cargo.toml | 1 + crates/font-catalog/src/lib.rs | 2 + crates/font-catalog/src/shape.rs | 150 +++++++++++++++++++++++++++++++ 4 files changed, 154 insertions(+) create mode 100644 crates/font-catalog/src/shape.rs diff --git a/Cargo.lock b/Cargo.lock index 9424cf3fe..3e1487dca 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1761,6 +1761,7 @@ name = "craft-font-catalog" version = "0.1.0" dependencies = [ "fontique", + "harfrust 0.13.3", "kurbo 0.13.1", "skrifa 0.47.0", "thiserror 2.0.21", diff --git a/crates/font-catalog/Cargo.toml b/crates/font-catalog/Cargo.toml index 1f0830a63..c53d871b8 100644 --- a/crates/font-catalog/Cargo.toml +++ b/crates/font-catalog/Cargo.toml @@ -15,6 +15,7 @@ default = ["system"] system = ["dep:fontique"] [dependencies] +harfrust = "0.13" kurbo = { workspace = true } skrifa = { version = "0.47", default-features = false, features = ["std"] } thiserror = { workspace = true } diff --git a/crates/font-catalog/src/lib.rs b/crates/font-catalog/src/lib.rs index 7da4ca310..176a38738 100644 --- a/crates/font-catalog/src/lib.rs +++ b/crates/font-catalog/src/lib.rs @@ -26,6 +26,7 @@ mod fontconfig; mod outline; mod registry; mod scan; +mod shape; mod suitcase; pub mod system; @@ -34,6 +35,7 @@ pub use env::{FontEnv, Os, font_dirs, font_store_dir, office_font_dirs}; pub use fontconfig::fontconfig_dirs; pub use outline::{FontOutline, OutlineError}; pub use scan::{FaceInfo, LocalizedName, Source, is_font_file, style_italic, style_weight, style_width}; +pub use shape::{RunGlyph, RunInput, ShapeRunError, shape_run}; #[cfg(test)] mod tests; diff --git a/crates/font-catalog/src/shape.rs b/crates/font-catalog/src/shape.rs new file mode 100644 index 000000000..7fb0814d3 --- /dev/null +++ b/crates/font-catalog/src/shape.rs @@ -0,0 +1,150 @@ +//! Shape a run with its source clusters and surrounding text context. + +use std::sync::Arc; + +use harfrust::{BufferClusterLevel, Direction, Feature, Language, Script, ShapeOptions, ShapePlan, Shaper, UnicodeBuffer}; + +/// Parameters for a single directional run. Text is in logical order and `source_start` is its +/// byte offset in the complete source. Context influences joining but emits no glyphs. +pub struct RunInput<'a> { + /// Text in this run. + pub text: &'a str, + /// Its byte offset in the complete source. + pub source_start: usize, + /// Text before the run, within the same shaping context. + pub pre_context: &'a str, + /// Text after the run, within the same shaping context. + pub post_context: &'a str, + /// Direction of shaping. + pub direction: Direction, + /// Language used for language-specific forms. + pub language: Option<&'a Language>, + /// OpenType features with ranges in source byte coordinates. + pub features: &'a [Feature], + /// Use character-level instead of monotone grapheme clusters. + pub character_clusters: bool, + /// Uppercase each mapped character without losing its source cluster. + pub uppercase: bool, +} + +/// A glyph in design units, with its source-byte cluster and directional advances and offsets. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct RunGlyph { + pub glyph_id: u32, + pub cluster: u32, + pub x_advance: i32, + pub y_advance: i32, + pub x_offset: i32, + pub y_offset: i32, +} + +/// A run's source offsets cannot fit HarfRust's 32-bit clusters. +#[derive(Debug, thiserror::Error)] +#[error("shaping cluster exceeds the 32-bit source offset range")] +pub struct ShapeRunError; + +/// Shape a run using a caller's face-specific plan cache. `map_character` applies digit or other +/// character mapping before case conversion; expansions retain the original byte cluster. +/// The plan callback receives the guessed script, direction, language and feature set so it can +/// reuse plans for the particular shaper and its variable-font instance. +pub fn shape_run( + shaper: &Shaper<'_>, + input: &RunInput<'_>, + mut map_character: impl FnMut(char) -> char, + plan: impl FnOnce(&Shaper<'_>, Direction, Option