LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M3.7: Sony lossless-compressed ARW tiles (2×2 CFA cells per LJ92 sample)
Christian Bretz5d143cf10827
diff --git a/crates/engine/src/media.rs b/crates/engine/src/media.rsindex bd4b060da..0d57d4cfb 100644--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@ -26,7 +26,7 @@ use lightcraft_raster::{Histogram, Rgb32f, Rgba8};use serde::{Deserialize, Serialize};/// Bump when the pipeline's output changes, to invalidate cached thumbnails.-pub const RENDER_CACHE_VERSION: u64 = 3;+pub const RENDER_CACHE_VERSION: u64 = 4;/// Thumbnails render at one of these long edges (so window/cell size changes reuse the cache).pub const THUMB_SIZES: [usize; 4] = [128, 256, 384, 512];diff --git a/crates/raw/src/vendor/arw.rs b/crates/raw/src/vendor/arw.rsindex 0e82a3810..2cd509abe 100644--- a/crates/raw/src/vendor/arw.rs+++ b/crates/raw/src/vendor/arw.rs@@ -14,12 +14,14 @@//! a 128-bit little-endian block: 11-bit max, 11-bit min, 4-bit index of the max, 4-bit index of the min and 14//! seven-bit deltas above the min, scaled by the smallest shift that fits `max − min` into 7 bits.//!-//! Also: uncompressed 16-bit ARW, and lossless-JPEG tiled ARW through the generic TIFF path.+//! Also: uncompressed 16-bit ARW, and lossless-compressed ARW (Compression 7, ILCE-7M4 and later): LJ92 tiles whose+//! frames hold one 2×2 CFA cell per four-component sample ([`read_quad_tiles`]). Other lossless-JPEG layouts go+//! through the generic TIFF path.-use crate::tiffraw::{Packing, read_image_in};-use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};+use crate::tiffraw::{Packing, check_image, read_image_in};+use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, ljpeg};use lightcraft_geom::Orientation;-use lightcraft_tiff::image::chunk_bytes;+use lightcraft_tiff::image::{Chunk, ImageInfo, Layout, chunk_bytes};use lightcraft_tiff::tags::{self as t, photometric};use lightcraft_tiff::{Ifd, Tiff};use rayon::prelude::*;@@ -87,6 +89,79 @@ pub(crate) fn decode_row(row: &[u8], out: &mut [u16]) {}}+/// Whether `info` holds Sony's lossless-compressed layout: LJ92 tiles whose frames are half the tile in each+/// direction with four components (checked on the first tile).+fn is_quad_tiled(bytes: &[u8], info: &ImageInfo) -> bool {+ let Layout::Tiles { tile_width, tile_height } = info.layout else { return false };+ info.samples_per_pixel == 1+ && info+ .chunks(bytes.len() as u64)+ .first()+ .and_then(|c| chunk_bytes(bytes, c))+ .and_then(|src| ljpeg::frame_info(src).ok())+ .is_some_and(|(fw, fh, nc, _)| nc == 4 && fw * 2 == tile_width as usize && fh * 2 == tile_height as usize)+}++/// Decode Sony's lossless-compressed raw data. Each tile is one LJ92 frame of half the tile's width and height whose+/// four components are the tile's 2×2 CFA cells in raster order (top-left, top-right, bottom-left, bottom-right), so+/// all four colour planes are predicted separately. Observed in the files' own frame headers (512×512 tiles holding+/// 256×256×4 frames) and checked on decoded images; the generic TIFF path reads a frame as a row-major sample stream+/// (DNG's convention), which would interleave each tile's left and right halves row by row.+fn read_quad_tiles(bytes: &[u8], info: &ImageInfo) -> Result<Vec<u16>> {+ let (w, h) = (info.width as usize, info.height as usize);+ let total = check_image(bytes, info)?;+ let chunks = info.chunks(bytes.len() as u64);+ let decoded: Vec<Result<(Chunk, ljpeg::Frame)>> = chunks+ .par_iter()+ .map(|c| {+ let src = chunk_bytes(bytes, c).ok_or_else(|| RawError::Corrupt("tile offset past end of file".into()))?;+ let f = ljpeg::decode(src, (c.width as usize * c.height as usize).max(1 << 16))?;+ if f.components != 4 || f.data.len() < f.width * f.height * 4 {+ return Err(RawError::Corrupt(format!(+ "lossless ARW tile: {} samples in a {}×{}×{} frame",+ f.data.len(),+ f.width,+ f.height,+ f.components+ )));+ }+ Ok((*c, f))+ })+ .collect();+ let mut out = vec![0u16; total];+ let mut ok = 0usize;+ let mut first_err = None;+ for r in decoded {+ let (c, f) = match r {+ Ok(v) => v,+ Err(e) => {+ first_err.get_or_insert(e);+ continue;+ }+ };+ ok += 1;+ let (x0, y0) = (c.x as usize, c.y as usize);+ for fy in 0..f.height {+ for k in 0..4 {+ let y = y0 + 2 * fy + (k >> 1);+ if y >= h {+ continue;+ }+ for fx in 0..f.width {+ let x = x0 + 2 * fx + (k & 1);+ if x < w {+ out[y * w + x] = f.data[(fy * f.width + fx) * 4 + k];+ }+ }+ }+ }+ }+ if ok == 0 {+ return Err(first_err.unwrap_or_else(|| RawError::Corrupt("no decodable tiles".into())));+ }+ Ok(out)+}+fn raw_ifd(tiff: &Tiff) -> Option<&Ifd> {tiff.all_ifds().into_iter()@@ -125,6 +200,13 @@ pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result<RawImage> {(RawData::U16(data), 14)}32767 => return Err(RawError::Unsupported("Sony ARW version 1 / packed compressed variant".into())),+ 7 if is_quad_tiled(bytes, &info) => match mode {+ Mode::Full => (RawData::U16(read_quad_tiles(bytes, &info)?), bits),+ Mode::Header => {+ check_image(bytes, &info)?;+ (RawData::U16(Vec::new()), bits)+ }+ },1 => {let packing = if strip_len >= (w * h * 2) as u64 { Packing::Word16 } else { Packing::Msb };(read_image_in(mode, bytes, &info, tiff.order, packing)?, bits)@@ -245,4 +327,48 @@ mod tests {let _ = code_curve(&[]);let _ = code_curve(&[60000, 1, 0, 0]);}++ #[test]+ fn quad_tiles_place_cfa_cells() {+ // 14×12 mosaic in 8×8 tiles (the right and bottom tiles overhang), each tile a 4×4 frame of 2×2 cells,+ // stored column by column in the file as Sony does while TileOffsets stay in raster order+ let (w, h, tw) = (14usize, 12usize, 8usize);+ let mosaic: Vec<u16> = (0..w * h).map(|i| 100 + (i * 37 % 4000) as u16).collect();+ let at = |x: usize, y: usize| if x < w && y < h { mosaic[y * w + x] } else { 0 };+ let mut file = vec![0u8; 16];+ let mut offsets = vec![0u64; 4];+ let mut counts = vec![0u64; 4];+ for tx in 0..2 {+ for ty in 0..2 {+ let mut frame = Vec::new();+ for fy in 0..tw / 2 {+ for fx in 0..tw / 2 {+ let (x, y) = (tx * tw + 2 * fx, ty * tw + 2 * fy);+ frame.extend([at(x, y), at(x + 1, y), at(x, y + 1), at(x + 1, y + 1)]);+ }+ }+ let enc = ljpeg::encode(&frame, tw / 2, tw / 2, 4, 14, 1, 0);+ offsets[ty * 2 + tx] = file.len() as u64;+ counts[ty * 2 + tx] = enc.len() as u64;+ file.extend(enc);+ }+ }+ let info = ImageInfo {+ width: w as u32,+ height: h as u32,+ bits_per_sample: vec![14],+ samples_per_pixel: 1,+ compression: 7,+ photometric: photometric::CFA,+ planar: 1,+ predictor: 1,+ sample_format: 1,+ new_subfile_type: 0,+ layout: Layout::Tiles { tile_width: tw as u32, tile_height: tw as u32 },+ offsets,+ byte_counts: counts,+ };+ assert!(is_quad_tiled(&file, &info));+ assert_eq!(read_quad_tiles(&file, &info).unwrap(), mosaic);+ }}