LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M5.6b: header-only raw probe (lightcraft_raw::probe_info); import no longer decodes pixels
Brandon Thomasc937ff97ee9e
diff --git a/apps/lightcraft-cli/src/main.rs b/apps/lightcraft-cli/src/main.rsindex 2f36513ef..246fd96c7 100644--- a/apps/lightcraft-cli/src/main.rs+++ b/apps/lightcraft-cli/src/main.rs@@ -270,7 +270,10 @@ fn snapshot(args: &[String]) -> Result<(), String> {None => Session::new().with_fs(),};if !files.is_empty() {- session.execute("library.import", &json!({"paths": expand_paths(&files)})).map_err(|e| e.to_string())?;+ let ti = Instant::now();+ let r = session.execute("library.import", &json!({"paths": expand_paths(&files)})).map_err(|e| e.to_string())?;+ let n = r["imported"].as_array().map_or(0, Vec::len);+ eprintln!("lightcraft-cli snapshot: imported {n} files in {:.0} ms", ti.elapsed().as_secs_f64() * 1e3);}let services = lightcraft_ui_egui::Services {write: Some(Box::new(|p: &str, b: &[u8]| {diff --git a/crates/engine/src/files.rs b/crates/engine/src/files.rsindex 884235016..153922c9a 100644--- a/crates/engine/src/files.rs+++ b/crates/engine/src/files.rs@@ -36,7 +36,7 @@ fn meta_of(m: &lightcraft_meta::Metadata) -> (Meta, Option<String>) {/// Lens corrections embedded in a DNG's `OpcodeList3` (`WarpRectilinear`, `FixVignetteRadial`), re-expressed for/// the default-cropped, EXIF-oriented image. These are the only "profile" corrections LightCraft applies.-pub fn embedded_lens(raw: &lightcraft_raw::RawImage) -> Option<lightcraft_develop::EmbeddedLens> {+pub fn embedded_lens(raw: &lightcraft_raw::RawInfo) -> Option<lightcraft_develop::EmbeddedLens> {use lightcraft_develop::{EmbeddedLens, EmbeddedVignette, EmbeddedWarp};use lightcraft_geom::Point;let (aw, ah) = (raw.active_area.width as f64, raw.active_area.height as f64);@@ -86,13 +86,14 @@ fn ext_upper(name: &str) -> String {std::path::Path::new(name).extension().map(|e| e.to_string_lossy().to_uppercase()).unwrap_or_default()}-/// Probe a file's bytes: kind, dimensions (oriented), metadata.+/// Probe a file's bytes: kind, dimensions (oriented), metadata. Raws are described from their+/// headers ([`lightcraft_raw::probe_info`]): no pixel data is decompressed.pub fn probe_bytes(name: &str, bytes: &[u8]) -> Result<ProbeInfo, String> {let content_hash = Some(lightcraft_preview::hash_bytes(bytes).to_string());let m = lightcraft_meta::extract(bytes);let (meta, captured) = meta_of(&m);if lightcraft_raw::probe(bytes).is_some() {- let raw = match lightcraft_raw::decode(bytes) {+ let raw = match lightcraft_raw::probe_info(bytes) {Ok(r) => r,Err(lightcraft_raw::RawError::Unsupported(why)) => {// a raw variant we can't decode yet: describe it from its embedded preview@@ -120,7 +121,7 @@ pub fn probe_bytes(name: &str, bytes: &[u8]) -> Result<ProbeInfo, String> {if raw.orientation.swaps_axes() {std::mem::swap(&mut w, &mut h);}- let (t, tint) = xy_to_temp_tint(lightcraft_raw::color::as_shot_white_xy(&raw));+ let (t, tint) = xy_to_temp_tint(lightcraft_raw::color::as_shot_white_xy_of(&raw));let as_shot_wb = Some((t.round(), tint.round()));let embedded_lens = embedded_lens(&raw);return Ok(ProbeInfo {@@ -204,7 +205,7 @@ fn load_bytes_now(bytes: &[u8], max_edge: usize) -> Result<(Rgb32f, SourceInfo),Err(e) => return Err(e.to_string()),};// Embedded lens corrections are applied by the pipeline ("Enable Profile Corrections"), not baked in.- let lens = embedded_lens(&raw);+ let lens = embedded_lens(&raw.info());raw.opcodes.list3.retain(|op| !is_lens_opcode(op));// Previews and thumbnails bin the mosaic straight to (about) the size they need; only// larger levels (exports, 1:1) demosaic the whole sensor.diff --git a/crates/raw/src/color.rs b/crates/raw/src/color.rsindex 5180745f3..050d21eec 100644--- a/crates/raw/src/color.rs+++ b/crates/raw/src/color.rs@@ -126,14 +126,22 @@ pub fn neutral_to_xy(color: &ColorData, neutral: [f64; 3]) -> Xy {/// The as-shot white point: `AsShotWhiteXY`, `AsShotNeutral`, vendor multipliers, else D65.pub fn as_shot_white_xy(raw: &RawImage) -> Xy {- let c = &raw.color;+ as_shot_white(&raw.color, raw.wb_multipliers)+}++/// [`as_shot_white_xy`] from a header-only [`crate::RawInfo`].+pub fn as_shot_white_xy_of(info: &crate::RawInfo) -> Xy {+ as_shot_white(&info.color, info.wb_multipliers)+}++fn as_shot_white(c: &ColorData, wb_multipliers: Option<[f32; 3]>) -> Xy {if let Some(xy) = c.as_shot_white_xy {return xy;}if let Some(n) = c.as_shot_neutral {return neutral_to_xy(c, n);}- if let Some(m) = raw.wb_multipliers.filter(|m| m.iter().all(|v| *v > 0.0 && v.is_finite())) {+ if let Some(m) = wb_multipliers.filter(|m| m.iter().all(|v| *v > 0.0 && v.is_finite())) {return neutral_to_xy(c, [1.0 / m[0] as f64, 1.0 / m[1] as f64, 1.0 / m[2] as f64]);}D65diff --git a/crates/raw/src/dng.rs b/crates/raw/src/dng.rsindex 4ffb0666c..2b0db2bb9 100644--- a/crates/raw/src/dng.rs+++ b/crates/raw/src/dng.rs@@ -1,8 +1,8 @@//! DNG (Adobe Digital Negative Specification 1.7): raw IFD selection, pixel data (via [`crate::tiffraw`]),//! linearization, black/white levels, active area, default crop, CFA description, colour tags, opcode lists.-use crate::tiffraw::{Packing, read_image};-use crate::{BlackLevel, Cfa, ColorData, Mat3, RawData, RawError, RawFormat, RawImage, Rect, Result, opcodes};+use crate::tiffraw::{Packing, read_image_in};+use crate::{BlackLevel, Cfa, ColorData, Mat3, Mode, RawData, RawError, RawFormat, RawImage, Rect, Result, opcodes};use lightcraft_color::Xy;use lightcraft_geom::Orientation;use lightcraft_tiff::tags::{self as t, photometric};@@ -48,7 +48,7 @@ pub(crate) fn color_data(ifd0: &Ifd, raw: &Ifd) -> ColorData {}}-pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {+pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result<RawImage> {let tiff = Tiff::parse(bytes)?;let ifd0 = &tiff.ifds[0];let raw = raw_ifd(&tiff).ok_or_else(|| RawError::Corrupt("DNG without a raw image IFD".into()))?;@@ -63,7 +63,7 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {if info.compression == t::compression::JPEG_XL {return Err(RawError::Unsupported("JPEG XL DNG".into()));}- let mut data = read_image(bytes, &info, tiff.order, Packing::Msb)?;+ let mut data = read_image_in(mode, bytes, &info, tiff.order, Packing::Msb)?;let bits = info.bits() as u32;// linearization table (integer data only)@@ -162,6 +162,6 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {opcodes,metadata,};- img.validate()?;+ img.validate_for(mode)?;Ok(img)}diff --git a/crates/raw/src/lib.rs b/crates/raw/src/lib.rsindex 453c75231..d61e313b6 100644--- a/crates/raw/src/lib.rs+++ b/crates/raw/src/lib.rs@@ -145,19 +145,75 @@ pub fn probe(bytes: &[u8]) -> Option<RawFormat> {/// Decode a raw file.pub fn decode(bytes: &[u8]) -> Result<RawImage> {+ decode_with(bytes, Mode::Full)+}++/// Everything [`decode`] learns about a raw file except its samples: geometry, orientation, CFA,+/// colour data, as-shot white balance, opcode lists (embedded lens corrections), metadata — read+/// from the headers without decompressing the pixel data, for imports. Equal to+/// [`RawImage::info`] of the decoded image. Black and white levels are not included (some formats+/// measure them from the samples).+///+/// A few uncompressed vendor formats derive part of this from the samples themselves (Nikon+/// NEF: optically masked trailing columns; Olympus ORF: the CFA phase and bit depth; Pentax PEF+/// without crop tags: dark borders); for those the samples are read (unpacked, nothing to+/// decompress) and dropped.+pub fn probe_info(bytes: &[u8]) -> Result<RawInfo> {+ decode_with(bytes, Mode::Header).map(RawImage::into_info)+}++/// How much of a file a decoder reads.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum Mode {+ /// Headers and samples.+ Full,+ /// Headers only: the returned image has no samples, and black/white levels measured from+ /// the samples are placeholders. Only [`RawImage::into_info`] may look at it.+ Header,+}++fn decode_with(bytes: &[u8], mode: Mode) -> Result<RawImage> {match probe(bytes).ok_or(RawError::NotRaw)? {- RawFormat::Dng => dng::decode(bytes),- RawFormat::Cr2 => vendor::cr2::decode(bytes),+ RawFormat::Dng => dng::decode(bytes, mode),+ RawFormat::Cr2 => vendor::cr2::decode(bytes, mode),RawFormat::Nef | RawFormat::Nrw => vendor::nef::decode(bytes),- RawFormat::Arw => vendor::arw::decode(bytes),- RawFormat::Raf => vendor::raf::decode(bytes),- RawFormat::Rw2 => vendor::rw2::decode(bytes),- RawFormat::Pef => vendor::pef::decode(bytes),+ RawFormat::Arw => vendor::arw::decode(bytes, mode),+ RawFormat::Raf => vendor::raf::decode(bytes, mode),+ RawFormat::Rw2 => vendor::rw2::decode(bytes, mode),+ RawFormat::Pef => vendor::pef::decode(bytes, mode),RawFormat::Orf => vendor::orf::decode(bytes),other => Err(RawError::Unsupported(format!("{other:?} files are not decoded yet"))),}}+/// A raw file's description without its samples (see [`probe_info`]).+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+pub struct RawInfo {+ pub format: RawFormat,+ /// Full sensor data dimensions (including masked borders).+ pub width: usize,+ pub height: usize,+ pub cpp: usize,+ pub cfa: Option<Cfa>,+ pub bits: u32,+ pub active_area: Rect,+ /// Default crop relative to the active area.+ pub crop: Rect,+ pub orientation: Orientation,+ pub color: ColorData,+ pub wb_multipliers: Option<[f32; 3]>,+ pub opcodes: OpcodeLists,+ pub metadata: Metadata,+}++impl RawInfo {+ /// Size of the developed image before orientation: the default crop, else the active area.+ pub fn developed_size(&self) -> (usize, usize) {+ let c = self.crop.clipped(self.active_area.width, self.active_area.height);+ if c.width > 1 && c.height > 1 { (c.width, c.height) } else { (self.active_area.width, self.active_area.height) }+ }+}+/// Sensor samples.#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]pub enum RawData {@@ -377,12 +433,59 @@ pub struct Normalized {}impl RawImage {+ /// The description without the samples (what [`probe_info`] returns for the same file).+ pub fn info(&self) -> RawInfo {+ RawInfo {+ format: self.format,+ width: self.width,+ height: self.height,+ cpp: self.cpp,+ cfa: self.cfa.clone(),+ bits: self.bits,+ active_area: self.active_area,+ crop: self.crop,+ orientation: self.orientation,+ color: self.color.clone(),+ wb_multipliers: self.wb_multipliers,+ opcodes: self.opcodes.clone(),+ metadata: self.metadata.clone(),+ }+ }++ /// [`Self::info`], dropping the samples.+ pub fn into_info(self) -> RawInfo {+ RawInfo {+ format: self.format,+ width: self.width,+ height: self.height,+ cpp: self.cpp,+ cfa: self.cfa,+ bits: self.bits,+ active_area: self.active_area,+ crop: self.crop,+ orientation: self.orientation,+ color: self.color,+ wb_multipliers: self.wb_multipliers,+ opcodes: self.opcodes,+ metadata: self.metadata,+ }+ }++ /// Validate what a decoder read in `mode` ([`Mode::Header`]: everything but the samples).+ pub(crate) fn validate_for(&self, mode: Mode) -> Result<()> {+ self.check(mode == Mode::Full)+ }+/// Validate internal consistency (dimensions vs data length, CFA shape, rectangles).pub fn validate(&self) -> Result<()> {+ self.check(true)+ }++ fn check(&self, samples: bool) -> Result<()> {if self.width == 0 || self.height == 0 || !(1..=4).contains(&self.cpp) {return Err(RawError::Corrupt("bad dimensions".into()));}- if self.data.len() != self.width * self.height * self.cpp {+ if samples && self.data.len() != self.width * self.height * self.cpp {return Err(RawError::Corrupt("data length mismatch".into()));}if let Some(c) = &self.cfadiff --git a/crates/raw/src/tiffraw.rs b/crates/raw/src/tiffraw.rsindex fbf7e922e..7da804033 100644--- a/crates/raw/src/tiffraw.rs+++ b/crates/raw/src/tiffraw.rs@@ -23,8 +23,9 @@ enum ChunkPx {F32(Vec<f32>),}-/// Decode all chunks of `info` into one buffer of `width × height × cpp` samples.-pub fn read_image(data: &[u8], info: &ImageInfo, order: ByteOrder, packing: Packing) -> Result<RawData> {+/// The checks [`read_image`] makes before decoding anything (sample format, size limits, data+/// present); returns the number of samples.+pub fn check_image(data: &[u8], info: &ImageInfo) -> Result<usize> {let (w, h) = (info.width as usize, info.height as usize);let cpp = info.samples_per_pixel as usize;let total = w.checked_mul(h).and_then(|v| v.checked_mul(cpp)).ok_or(RawError::Limit("image too large"))?;@@ -49,6 +50,29 @@ pub fn read_image(data: &[u8], info: &ImageInfo, order: ByteOrder, packing: Packif available.saturating_mul(2048) < total as u64 {return Err(RawError::Corrupt(format!("{available} bytes of image data cannot hold {total} samples")));}+ Ok(total)+}++/// Read the samples of `info` in `mode`: [`Mode::Header`] only checks them ([`check_image`]) and+/// returns no samples (floating-point data as an empty `F32`).+pub(crate) fn read_image_in(mode: crate::Mode, data: &[u8], info: &ImageInfo, order: ByteOrder, packing: Packing) -> Result<RawData> {+ match mode {+ crate::Mode::Full => read_image(data, info, order, packing),+ crate::Mode::Header => {+ check_image(data, info)?;+ Ok(if info.sample_format == 3 { RawData::F32(Vec::new()) } else { RawData::U16(Vec::new()) })+ }+ }+}++/// Decode all chunks of `info` into one buffer of `width × height × cpp` samples.+pub fn read_image(data: &[u8], info: &ImageInfo, order: ByteOrder, packing: Packing) -> Result<RawData> {+ let (w, h) = (info.width as usize, info.height as usize);+ let total = check_image(data, info)?;+ let cpp = info.samples_per_pixel as usize;+ let bits = info.bits() as u32;+ let float = info.sample_format == 3;+ let chunks = info.chunks(data.len() as u64);let planar = info.planar == 2 && cpp > 1;let ccpp = if planar { 1 } else { cpp };let decoded: Vec<Result<(Chunk, ChunkPx)>> =diff --git a/crates/raw/src/vendor/arw.rs b/crates/raw/src/vendor/arw.rsindex 890200384..0e82a3810 100644--- a/crates/raw/src/vendor/arw.rs+++ b/crates/raw/src/vendor/arw.rs@@ -16,8 +16,8 @@//!//! Also: uncompressed 16-bit ARW, and lossless-JPEG tiled ARW through the generic TIFF path.-use crate::tiffraw::{Packing, read_image};-use crate::{BlackLevel, Cfa, ColorData, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};+use crate::tiffraw::{Packing, read_image_in};+use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};use lightcraft_geom::Orientation;use lightcraft_tiff::image::chunk_bytes;use lightcraft_tiff::tags::{self as t, photometric};@@ -94,7 +94,7 @@ fn raw_ifd(tiff: &Tiff) -> Option<&Ifd> {.max_by_key(|i| i.u64(t::IMAGE_WIDTH).unwrap_or(0).saturating_mul(i.u64(t::IMAGE_LENGTH).unwrap_or(0)))}-pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {+pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result<RawImage> {let tiff = Tiff::parse(bytes)?;let ifd0 = &tiff.ifds[0];let raw = raw_ifd(&tiff).ok_or_else(|| RawError::Unsupported("ARW without a CFA image IFD (old ARW or SR2)".into()))?;@@ -107,6 +107,10 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {let chunks = info.chunks(bytes.len() as u64);let strip_len: u64 = chunks.iter().map(|c| c.len).sum();let (data, out_bits) = match info.compression {+ 32767 if chunks.len() == 1 && strip_len >= (w * h) as u64 && strip_len < (w * h) as u64 * 5 / 4 && mode == Mode::Header => {+ chunk_bytes(bytes, &chunks[0]).ok_or_else(|| RawError::Corrupt("raw strip outside file".into()))?;+ (RawData::U16(Vec::new()), 14)+ }32767 if chunks.len() == 1 && strip_len >= (w * h) as u64 && strip_len < (w * h) as u64 * 5 / 4 => {let src = chunk_bytes(bytes, &chunks[0]).ok_or_else(|| RawError::Corrupt("raw strip outside file".into()))?;let curve = code_curve(&raw.u64s(TONE_CURVE).unwrap_or_else(|| vec![8000, 10400, 12900, 14100]));@@ -123,9 +127,9 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {32767 => return Err(RawError::Unsupported("Sony ARW version 1 / packed compressed variant".into())),1 => {let packing = if strip_len >= (w * h * 2) as u64 { Packing::Word16 } else { Packing::Msb };- (read_image(bytes, &info, tiff.order, packing)?, bits)+ (read_image_in(mode, bytes, &info, tiff.order, packing)?, bits)}- _ => (read_image(bytes, &info, tiff.order, Packing::Msb)?, bits),+ _ => (read_image_in(mode, bytes, &info, tiff.order, Packing::Msb)?, bits),};let RawData::U16(ref samples) = data else { return Err(RawError::Unsupported("float ARW".into())) };@@ -171,7 +175,7 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {opcodes: OpcodeLists::default(),metadata,};- img.validate()?;+ img.validate_for(mode)?;Ok(img)}diff --git a/crates/raw/src/vendor/cr2.rs b/crates/raw/src/vendor/cr2.rsindex 601666d66..8629f75cf 100644--- a/crates/raw/src/vendor/cr2.rs+++ b/crates/raw/src/vendor/cr2.rs@@ -14,7 +14,7 @@//! - sRAW / mRAW (YCbCr, subsampled) are not supported yet.use super::{black_from_columns, white_from_data};-use crate::{BlackLevel, Cfa, ColorData, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, ljpeg};+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::{Ifd, Tiff, makernote, tags as t};@@ -45,7 +45,7 @@ fn wb_from_color_balance(v: &[u64]) -> Option<[f32; 3]> {None}-pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {+pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result<RawImage> {let tiff = Tiff::parse(bytes)?;let ifd0 = &tiff.ifds[0];let raw = raw_ifd(&tiff).ok_or_else(|| RawError::Corrupt("CR2 without raw IFD".into()))?;@@ -57,8 +57,24 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {let chunk = lightcraft_tiff::image::Chunk { index: 0, x: 0, y: 0, width: 0, height: 0, plane: 0, offset: off, len };let src = chunk_bytes(bytes, &chunk).ok_or_else(|| RawError::Corrupt("raw strip outside file".into()))?;let (fw, fh, nc, prec) = ljpeg::frame_info(src)?;- let frame = ljpeg::decode(src, (fw * fh * nc).min(crate::MAX_SAMPLES))?;- let total = frame.data.len();+ let frame = match mode {+ Mode::Full => Some(ljpeg::decode(src, (fw * fh * nc).min(crate::MAX_SAMPLES))?),+ Mode::Header => None,+ };+ let total = match &frame {+ Some(f) => f.data.len(),+ None => {+ let total = fw+ .checked_mul(fh)+ .and_then(|v| v.checked_mul(nc))+ .filter(|t| *t > 0)+ .ok_or_else(|| RawError::Corrupt("bad CR2 frame size".into()))?;+ if total > crate::MAX_SAMPLES {+ return Err(RawError::Limit("lossless JPEG frame larger than expected"));+ }+ total+ }+ };let slices = raw.u64s(CR2_SLICE).filter(|s| s.len() == 3 && s[1] > 0 && s[2] > 0);let widths: Vec<usize> = match &slices {Some(s) => {@@ -74,16 +90,20 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {return Err(RawError::Corrupt(format!("CR2 slices ({width}) do not divide the frame ({total} samples)")));}let height = total / width;- let mut data = vec![0u16; total];- let mut i = 0;- let mut x0 = 0;- for &sw in &widths {- for y in 0..height {- data[y * width + x0..y * width + x0 + sw].copy_from_slice(&frame.data[i..i + sw]);- i += sw;+ let mut data = Vec::new();+ if let Some(frame) = &frame {+ data = vec![0u16; total];+ let mut i = 0;+ let mut x0 = 0;+ for &sw in &widths {+ for y in 0..height {+ data[y * width + x0..y * width + x0 + sw].copy_from_slice(&frame.data[i..i + sw]);+ i += sw;+ }+ x0 += sw;}- x0 += sw;}+ drop(frame);// maker note: sensor borders and white balancelet make = ifd0.string(t::MAKE).unwrap_or_default();@@ -126,7 +146,7 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {opcodes: OpcodeLists::default(),metadata,};- img.validate()?;+ img.validate_for(mode)?;Ok(img)}@@ -183,6 +203,7 @@ pub(crate) mod tests {assert_eq!(crate::probe(&bytes), Some(RawFormat::Cr2));let r = crate::decode(&bytes).unwrap();assert_eq!((r.width, r.height), (64, 10));+ assert_eq!(crate::probe_info(&bytes).unwrap(), r.info());assert_eq!(r.data, RawData::U16(img));assert_eq!(r.orientation, Orientation::Rotate270);assert_eq!(r.metadata.iso, Some(400));diff --git a/crates/raw/src/vendor/pef.rs b/crates/raw/src/vendor/pef.rsindex 57034d772..a6fb8c579 100644--- a/crates/raw/src/vendor/pef.rs+++ b/crates/raw/src/vendor/pef.rs@@ -17,8 +17,8 @@use super::{black_from_columns, white_from_data};-use crate::tiffraw::{Packing, read_image};-use crate::{BlackLevel, Cfa, ColorData, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};+use crate::tiffraw::{Packing, read_image_in};+use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};use lightcraft_geom::Orientation;use lightcraft_tiff::image::chunk_bytes;use lightcraft_tiff::{ByteOrder, Tiff, makernote, tags as t};@@ -184,7 +184,7 @@ fn dark_trimmed(d: &[u16], w: usize, h: usize) -> Rect {Rect::new(left, 0, (right - left) & !1, h)}-pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {+pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result<RawImage> {let tiff = Tiff::parse(bytes)?;let ifd0 = &tiff.ifds[0];let info = ifd0.image()?;@@ -196,6 +196,13 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {let make = ifd0.string(t::MAKE).unwrap_or_default();let mn =tiff.exif().and_then(|e| e.get(t::MAKER_NOTE)).and_then(|e| makernote::parse_makernote(bytes, e.offset, e.count() as u64, tiff.order, &make));+ let pair = |tag: u16| mn.as_ref().and_then(|m| m.ifd.u64s(tag)).filter(|v| v.len() == 2).map(|v| (v[0] as usize, v[1] as usize));+ let tagged = match (pair(CROP_ORIGIN), pair(CROP_SIZE)) {+ (Some((x, y)), Some((cw, ch))) if cw > 0 && ch > 0 && x + cw <= w && y + ch <= hgt => Some(Rect::new(x, y, cw, ch)),+ _ => None,+ };+ // without crop tags the image area is found from the samples (dark borders)+ let read = if tagged.is_some() { mode } else { Mode::Full };let data = match info.compression {65535 => {let mn = mn.as_ref().ok_or_else(|| RawError::Corrupt("compressed PEF without maker note".into()))?;@@ -208,21 +215,20 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {let src = chunk_bytes(bytes, &c).or_else(|| bytes.get(first.offset as usize..)).ok_or_else(|| RawError::Corrupt("PEF data outside file".into()))?;- RawData::U16(decode_huffman(src, &huff, w, hgt, bits)?)+ if read == Mode::Full { RawData::U16(decode_huffman(src, &huff, w, hgt, bits)?) } else { RawData::U16(Vec::new()) }}1 => {let strip: u64 = info.chunks(bytes.len() as u64).iter().map(|c| c.len).sum();let packing = if strip >= (w * hgt * 2) as u64 { Packing::Word16 } else { Packing::Msb };- read_image(bytes, &info, tiff.order, packing)?+ read_image_in(read, bytes, &info, tiff.order, packing)?}c => return Err(RawError::Unsupported(format!("PEF compression {c}"))),};let RawData::U16(ref samples) = data else { return Err(RawError::Unsupported("float PEF".into())) };- let pair = |tag: u16| mn.as_ref().and_then(|m| m.ifd.u64s(tag)).filter(|v| v.len() == 2).map(|v| (v[0] as usize, v[1] as usize));- let active = match (pair(CROP_ORIGIN), pair(CROP_SIZE)) {- (Some((x, y)), Some((cw, ch))) if cw > 0 && ch > 0 && x + cw <= w && y + ch <= hgt => Rect::new(x, y, cw, ch),- _ => dark_trimmed(samples, w, hgt),+ let active = match tagged {+ Some(r) => r,+ None => dark_trimmed(samples, w, hgt),};let cfa = match (ifd0.u64s(t::CFA_REPEAT_PATTERN_DIM).as_deref(), ifd0.bytes(t::CFA_PATTERN_EP)) {(Some([2, 2]), Some(p)) if p.len() == 4 && p.iter().all(|&c| c <= 2) => Cfa { width: 2, height: 2, pattern: p.to_vec() },@@ -265,7 +271,7 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {opcodes: OpcodeLists::default(),metadata,};- img.validate()?;+ img.validate_for(mode)?;Ok(img)}diff --git a/crates/raw/src/vendor/raf.rs b/crates/raw/src/vendor/raf.rsindex 45dd3e93c..e8ee126e7 100644--- a/crates/raw/src/vendor/raf.rs+++ b/crates/raw/src/vendor/raf.rs@@ -21,7 +21,7 @@use super::white_from_data;use crate::unpack::{unpack_lsb, unpack_msb};-use crate::{BlackLevel, Cfa, ColorData, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};+use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};use lightcraft_geom::Orientation;use lightcraft_tiff::{ByteOrder, Ifd, Tiff};use rayon::prelude::*;@@ -114,7 +114,7 @@ pub(crate) fn unpack_row(src: &[u8], bits: u32, out: &mut [u16]) {}}-pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {+pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result<RawImage> {let h = header(bytes)?;let raw = h.raw.ok_or_else(|| RawError::Corrupt("RAF without raw data".into()))?;let ifd = raw_ifd(raw)?;@@ -137,11 +137,14 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {return Err(RawError::Unsupported(format!("Fujifilm compressed RAF ({len} bytes for {w}x{hgt} {bits}-bit)")));}let src = raw.get(off..off.saturating_add(len).min(raw.len())).ok_or_else(|| RawError::Corrupt("RAF strip outside file".into()))?;- let mut data = vec![0u16; n];- data.par_chunks_mut(w).enumerate().for_each(|(y, row)| {- let s = src.get(y * stride..(y * stride + packed_row).min(src.len())).unwrap_or(&[]);- unpack_row(s, store, row);- });+ let mut data = Vec::new();+ if mode == Mode::Full {+ data = vec![0u16; n];+ data.par_chunks_mut(w).enumerate().for_each(|(y, row)| {+ let s = src.get(y * stride..(y * stride + packed_row).min(src.len())).unwrap_or(&[]);+ unpack_row(s, store, row);+ });+ }let cfa = cfa(&h);let active = match (pair(&h, CROP_TOP_LEFT), pair(&h, CROPPED_SIZE)) {@@ -186,7 +189,7 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {opcodes: OpcodeLists::default(),metadata,};- img.validate()?;+ img.validate_for(mode)?;Ok(img)}@@ -298,6 +301,7 @@ mod tests {let bytes = raf(w, h, bits, pack(&px, store), Some(layout), b"\xff\xd8\xff\xd9");assert_eq!(crate::probe(&bytes), Some(RawFormat::Raf));let r = crate::decode(&bytes).unwrap_or_else(|e| panic!("{bits}: {e}"));+ assert_eq!(crate::probe_info(&bytes).unwrap(), r.info());assert_eq!(r.data, RawData::U16(px), "{bits}-bit");assert_eq!(r.cfa, Some(Cfa::xtrans()));assert_eq!(r.active_area, Rect::new(4, 2, 12, 4));diff --git a/crates/raw/src/vendor/rw2.rs b/crates/raw/src/vendor/rw2.rsindex 47b9e5436..d996d5b21 100644--- a/crates/raw/src/vendor/rw2.rs+++ b/crates/raw/src/vendor/rw2.rs@@ -20,7 +20,7 @@//! reconstruction rule for every scale, and no permissively licensed description exists. Those files report//! [`RawError::Unsupported`]; their embedded preview still works.-use crate::{BlackLevel, Cfa, ColorData, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};+use crate::{BlackLevel, Cfa, ColorData, Mode, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result};use lightcraft_geom::Orientation;use lightcraft_tiff::{Tiff, tags as t};use rayon::prelude::*;@@ -97,7 +97,7 @@ fn cfa(code: u16) -> Cfa {Cfa::bayer(s).expect("static")}-pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {+pub(crate) fn decode(bytes: &[u8], mode: Mode) -> Result<RawImage> {let tiff = Tiff::parse(bytes)?;let ifd0 = &tiff.ifds[0];let get = |tag: u16| ifd0.u64(tag).map(|v| v as usize);@@ -118,9 +118,12 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {if src.len() < need {return Err(RawError::Corrupt(format!("RW2 raw data truncated ({} of {need} bytes)", src.len())));}- let stream = unrotate(&src[..(need.div_ceil(CHUNK) * CHUNK).min(src.len())]);- let mut data = vec![0u16; n];- unpack(&stream, bits, &mut data)?;+ let mut data = Vec::new();+ if mode == Mode::Full {+ let stream = unrotate(&src[..(need.div_ceil(CHUNK) * CHUNK).min(src.len())]);+ data = vec![0u16; n];+ unpack(&stream, bits, &mut data)?;+ }let active = match (get(BORDER_TOP), get(BORDER_LEFT), get(BORDER_BOTTOM), get(BORDER_RIGHT)) {(Some(tp), Some(l), Some(b), Some(r)) if b > tp && r > l => Rect::new(l, tp, r - l, b - tp).clipped(w, h),@@ -167,7 +170,7 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {opcodes: OpcodeLists::default(),metadata,};- img.validate()?;+ img.validate_for(mode)?;Ok(img)}@@ -235,6 +238,7 @@ mod tests {let bytes = rw2(w as u16, h as u16, bits as u16, 5, &encode(&px, bits));assert_eq!(crate::probe(&bytes), Some(RawFormat::Rw2));let r = crate::decode(&bytes).unwrap_or_else(|e| panic!("{bits}: {e}"));+ assert_eq!(crate::probe_info(&bytes).unwrap(), r.info());assert_eq!(r.data, RawData::U16(px), "{bits}-bit");assert_eq!(r.active_area, Rect::new(4, 2, w - 4, h - 2));assert_eq!(r.cfa.as_ref().unwrap().name(), "RGGB");diff --git a/crates/raw/tests/corpus.rs b/crates/raw/tests/corpus.rsindex e8f055cff..af47b84ae 100644--- a/crates/raw/tests/corpus.rs+++ b/crates/raw/tests/corpus.rs@@ -5,7 +5,7 @@//! `Unsupported` for one of the variants we know we don't decode yet. Prints decode times//! (`cargo test -p lightcraft-raw --release --test corpus -- --nocapture`).-use lightcraft_raw::{RawError, RawFormat, decode, embedded_preview, probe};+use lightcraft_raw::{RawError, RawFormat, decode, embedded_preview, probe, probe_info};use std::path::{Path, PathBuf};use std::time::Instant;@@ -55,9 +55,20 @@ fn corpus_raw_decodes() {}let preview_kb = preview.as_ref().map_or(0, |p| p.len() / 1024);let t1 = Instant::now();- match decode(&bytes) {+ let decoded = decode(&bytes);+ let dt = t1.elapsed().as_secs_f64() * 1e3;+ // the header-only probe agrees with the full decode, faster+ let t2 = Instant::now();+ let info = probe_info(&bytes);+ let di = t2.elapsed().as_secs_f64() * 1e3;+ match (&decoded, &info) {+ (Ok(img), Ok(info)) => assert_eq!(&img.info(), info, "{name}: probe_info differs from decode"),+ (Err(RawError::Unsupported(_)), Err(RawError::Unsupported(_))) => {}+ (d, i) => panic!("{name}: decode {:?} but probe_info {:?}", d.as_ref().err(), i.as_ref().err()),+ }+ eprintln!("{name:44} probe_info {di:.1} ms");+ match decoded {Ok(img) => {- let dt = t1.elapsed().as_secs_f64() * 1e3;img.validate().unwrap();assert!(img.white_at(0) > img.black.mean(), "{name}: white {} <= black {}", img.white_at(0), img.black.mean());let mp = (img.width * img.height) as f64 / 1e6;diff --git a/crates/raw/tests/dng.rs b/crates/raw/tests/dng.rsindex 6fa7b6703..654faa995 100644--- a/crates/raw/tests/dng.rs+++ b/crates/raw/tests/dng.rs@@ -100,6 +100,8 @@ fn writer_roundtrip_all_layouts() {assert_eq!(probe(&bytes), Some(RawFormat::Dng));let back = decode(&bytes).unwrap();assert_same(&raw, &back);+ // the header-only probe describes the same image+ assert_eq!(lightcraft_raw::probe_info(&bytes).unwrap(), back.info());}}}