Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

Merge PR #3015: Never crash: an oversize export size is an error, not a multiply overflow

aiongg06a94d2d7fda
diff --cc crates/engine/src/media/session.rs
index b222739fe,000000000..930e800b1
mode 100644,000000..100644
--- a/crates/engine/src/media/session.rs
+++ b/crates/engine/src/media/session.rs
@@@ -1,476 -1,0 +1,478 @@@
+use super::quick::{QuickJob, content_key, source_info};
+use super::render::{RenderJob, RenderResult};
+use super::source::{PreviewLoader, RENDER_CACHE_VERSION, SourceLevel, SourceRef, THUMB_SIZES, face_edge, source_edge_needed, thumb_bucket};
+use super::{Arc, DevelopSettings, Hash128, Hasher128, MediaKind, Op, Photo, PhotoId, RenderRequest, Rendered, Rgb32f, Source, SourceInfo};
+
+impl crate::Session {
+ /// Build a render job for `id` fitting `max_w × max_h`. `before` renders the unedited look.
+ pub fn render_job(&mut self, id: PhotoId, max_w: usize, max_h: usize, before: bool, apply_crop: bool) -> Option<RenderJob> {
+ self.build_job(id, max_w, max_h, before, apply_crop, None)
+ }
+
+ /// A grid/filmstrip thumbnail job: the long edge is rounded up to one of [`THUMB_SIZES`]
+ /// (≥ `long_edge`) and the result comes from / goes to the thumbnail cache (memory + disk).
+ pub fn thumb_job(&mut self, id: PhotoId, long_edge: usize) -> Option<RenderJob> {
+ let b = thumb_bucket(long_edge);
+ let mut job = self.build_job(id, b, b, false, true, Some(b))?;
+ // (a thumbnail may develop a smaller copy of the raw image that the file keeps)
+ if let SourceRef::File { reduced, .. } = &mut job.source {
+ reduced.clone_from(&self.media.reduced_loader);
+ }
+ Some(job)
+ }
+
+ fn build_job(
+ &mut self,
+ id: PhotoId,
+ max_w: usize,
+ max_h: usize,
+ before: bool,
+ apply_crop: bool,
+ thumb_bucket: Option<usize>,
+ ) -> Option<RenderJob> {
+ let p = self.catalog.photo(id)?.clone();
+ let settings = if before { Arc::new(self.before_settings(&p)) } else { p.develop.clone() };
+ let level = SourceLevel::for_size(if thumb_bucket.is_some() {
+ max_w.max(max_h) // (grid thumbnails of tight crops stay cheap)
+ } else {
+ source_edge_needed(&p, &settings, apply_crop, max_w.max(max_h))
+ });
+ let source = self.media.source_ref(&p, level);
+ let request = RenderRequest { apply_crop, ..RenderRequest::fit(max_w, max_h) };
+ // the photo id is part of the key: two photos with the same settings and size must not
+ // share a result (a view slot showing photo A would otherwise look current for photo B)
+ // …and so is the file's content: a file changed on disk (Reload) renders afresh
+ let content_key = content_key(&p);
+ let source_key = Hasher128::new().str(&content_key).finish();
+ let content = source_key.0 as u64;
+ // Temporary "before" settings must not replace the photo's cached develop hash.
+ let settings_hash = if before { settings.hash64() } else { self.media.settings_hashes.get(id, &settings) };
+ let salt = self.media.denoise_salt(id, &settings);
+ let key = settings_hash
+ ^ ((max_w as u64) << 40)
+ ^ ((max_h as u64) << 20)
+ ^ (apply_crop as u64)
+ ^ (level as u64) << 60
+ ^ id.0.wrapping_mul(0x9e37_79b9_7f4a_7c15)
+ ^ content.rotate_left(17)
+ ^ salt;
+ let cache = thumb_bucket.map(|b| {
+ let mut k = Hasher128::new();
+ k.str(&content_key).u64(settings_hash).u64(b as u64).u64(RENDER_CACHE_VERSION).u64(crate::camera_profiles::cache_key());
+ // (only a render that uses a denoised picture has it in its key, so every other thumbnail stays valid)
+ if salt != 0 {
+ k.u64(salt);
+ }
+ (self.media.rendered.clone(), k.finish())
+ });
+ Some(RenderJob {
+ request_id: 0,
+ cache_generation: self.media.rendered.generation(),
+ source_key: Some(source_key),
+ photo: id,
+ level,
+ source,
+ origin: p.source.clone(),
+ info: source_info(&p),
+ settings,
+ request,
+ key,
+ cache,
+ stages: None,
+ view_cache: None,
+ display: None,
+ slide: None,
+ preview_cut: None,
+ display_fit: None,
+ })
+ }
+
+ /// A render of `id` with `settings` in place of its own, fitting `max_w × max_h` (the loupe's
+ /// temporary preview while hovering a preset or profile; nothing is committed or cached).
+ pub fn preview_job(&mut self, id: PhotoId, max_w: usize, max_h: usize, apply_crop: bool, settings: &DevelopSettings) -> Option<RenderJob> {
+ let mut job = self.render_job(id, max_w, max_h, false, apply_crop)?;
+ job.settings = Arc::new(settings.clone());
+ job.key = settings.hash64() ^ ((max_w as u64) << 40) ^ ((max_h as u64) << 20) ^ (apply_crop as u64) ^ (job.level as u64) << 60;
+ Some(job)
+ }
+
+ /// Cache key of a variant thumbnail ([`Self::variant_job`]).
+ pub fn variant_key(p: &Photo, settings: &DevelopSettings, edge: usize) -> Hash128 {
+ Hasher128::new()
+ .str(&content_key(p))
+ .str("variant")
+ .u64(settings.hash64())
+ .u64(edge as u64)
+ .u64(RENDER_CACHE_VERSION)
+ .u64(crate::camera_profiles::cache_key())
+ .finish()
+ }
+
+ /// A thumbnail of `id` rendered with `settings` instead of its own (profile and preset
+ /// browsers): from the thumbnail-level source, long edge `edge` (≤ 512), cropped. The result
+ /// is cached (memory + the library's disk cache) under the photo's content and the settings
+ /// hash, so a variant renders once; `key` is derived from the same hash, so a frontend can
+ /// keep one texture per variant.
+ pub fn variant_job(&mut self, id: PhotoId, settings: &DevelopSettings, edge: usize) -> Option<RenderJob> {
+ let p = self.catalog.photo(id)?.clone();
+ let edge = edge.clamp(16, SourceLevel::Thumb.max_edge());
+ let level = SourceLevel::Thumb;
+ let source = self.media.source_ref(&p, level);
+ let ck = Self::variant_key(&p, settings, edge);
+ Some(RenderJob {
+ request_id: 0,
+ cache_generation: self.media.rendered.generation(),
+ source_key: Some(Hasher128::new().str(&content_key(&p)).finish()),
+ photo: id,
+ level,
+ source,
+ origin: p.source.clone(),
+ info: source_info(&p),
+ settings: Arc::new(settings.clone()),
+ request: RenderRequest { apply_crop: true, ..RenderRequest::fit(edge, edge) },
+ key: (ck.0 as u64) ^ ((ck.0 >> 64) as u64),
+ cache: Some((self.media.rendered.clone(), ck)),
+ stages: None,
+ view_cache: None,
+ display: None,
+ slide: None,
+ preview_cut: None,
+ display_fit: None,
+ })
+ }
+
+ /// A square close-up of `face` (normalized, in the photo's upright frame) for a People card: the
+ /// photo's own look with its crop replaced by a square around the face (room for hair and chin),
+ /// at least `edge` pixels across (rounded up to [`FACE_EDGE_STEP`], ≤ 512, so a tile size
+ /// between two steps reuses the cached one). An unedited raw's tile is cut from the camera's
+ /// embedded preview when that holds the square at [`crate::face_tiles::SOFT_LIMIT`] of the
+ /// size asked or more ([`crate::face_tiles`]); else, and for every other photo, the source
+ /// level is the smallest that keeps the face sharp, up to the preview. Cached (memory and the
+ /// library's thumbnail cache on disk) like [`Self::variant_job`], and `key` likewise follows
+ /// the content: a later launch shows the tile without reading the original.
+ pub fn face_job(&mut self, id: PhotoId, face: lightcraft_geom::Rect, edge: usize) -> Option<RenderJob> {
+ let p = self.catalog.photo(id)?.clone();
+ // `face` is on the upright (EXIF-oriented) photo; the crop below is in the frame after the
+ // user's Rotate Left/Right, so carry the box (and the photo's size) over to it.
+ let orient = p.develop.orientation;
+ let face = orient.map_norm_rect(face);
+ let (w, h) = (f64::from(p.width.max(1)), f64::from(p.height.max(1)));
+ let (w, h) = if orient.swaps_axes() { (h, w) } else { (w, h) };
+ let side = ((face.x1 - face.x0) * w).max((face.y1 - face.y0) * h) * 1.7;
+ // finite, within the photo, and never wider than its short side (so the clamps below are valid)
+ let side = if side.is_finite() { side.clamp(1.0, w.min(h)) } else { w.min(h) };
+ let (cx, cy) = ((face.x0 + face.x1) / 2.0 * w, (face.y0 + face.y1) / 2.0 * h);
+ let (cx, cy) = (if cx.is_finite() { cx } else { w / 2.0 }, if cy.is_finite() { cy } else { h / 2.0 });
+ let (x0, y0) = (cx.clamp(side / 2.0, w - side / 2.0) - side / 2.0, cy.clamp(side / 2.0, h - side / 2.0) - side / 2.0);
+ let rect = lightcraft_geom::Rect { x0: x0 / w, y0: y0 / h, x1: (x0 + side) / w, y1: (y0 + side) / h };
+ let mut settings = (*p.develop).clone();
+ settings.crop = lightcraft_develop::Crop { geometry: lightcraft_geom::CropGeometry { rect, angle: 0.0 }, ..Default::default() };
+ let edge = face_edge(edge);
+ // pixels along the long edge that leave `edge` across the crop
+ let needed = (edge as f64 * w.max(h) / side).ceil().min(SourceLevel::Preview.max_edge() as f64);
+ let level = SourceLevel::for_size(needed as usize);
+ let source = self.media.source_ref(&p, level);
+ let ck = Self::variant_key(&p, &settings, edge);
+ let preview_cut = self.face_preview_cut(&p, rect, edge, needed as usize);
+ Some(RenderJob {
+ request_id: 0,
+ cache_generation: self.media.rendered.generation(),
+ source_key: Some(Hasher128::new().str(&content_key(&p)).finish()),
+ photo: id,
+ level,
+ source,
+ origin: p.source.clone(),
+ info: source_info(&p),
+ settings: Arc::new(settings),
+ request: RenderRequest { apply_crop: true, ..RenderRequest::fit(edge, edge) },
+ key: (ck.0 as u64) ^ ((ck.0 >> 64) as u64),
+ cache: Some((self.media.rendered.clone(), ck)),
+ stages: None,
+ view_cache: None,
+ display: None,
+ slide: None,
+ preview_cut,
+ display_fit: None,
+ })
+ }
+
+ /// How a face tile of `p` can come from its embedded preview ([`crate::face_tiles`]): only an
+ /// unedited raw (whose grid thumbnail is that preview too) not known to be offline, upright as
+ /// imported, with a preview loader installed. `rect` is the square around the face, `edge` the
+ /// tile, `needed` the source's long edge the develop render would ask for.
+ fn face_preview_cut(&self, p: &Photo, rect: lightcraft_geom::Rect, edge: usize, needed: usize) -> Option<crate::face_tiles::PreviewCut> {
+ let (path, loader) = self.embedded_of(p)?;
+ if p.develop.orientation != lightcraft_geom::Orientation::Normal || self.media.availability.is_offline(&path) || p.width == 0 || p.height == 0
+ {
+ return None;
+ }
+ let want = needed.max(edge).max(1);
+ let min = (want as f64 * crate::face_tiles::SOFT_LIMIT).ceil() as usize;
+ let aspect = f64::from(p.width) / f64::from(p.height);
+ Some(crate::face_tiles::PreviewCut { path, loader, want, min, rect, aspect, edge })
+ }
+
+ /// Size-independent cache key of a photo's view render (loupe) for its current settings.
+ fn view_key(p: &Photo, apply_crop: bool) -> Hash128 {
+ Hasher128::new()
+ .str(&content_key(p))
+ .str("view")
+ .u64(p.develop.hash64())
+ .u64(apply_crop as u64)
+ .u64(RENDER_CACHE_VERSION)
+ .u64(crate::camera_profiles::cache_key())
+ .finish()
+ }
+
+ /// The loupe's render job: like [`Self::render_job`], and a full-quality result is kept as the
+ /// photo's view preview (memory, and disk with a library) for [`Self::quick_view_job`].
+ pub fn loupe_job(&mut self, id: PhotoId, max_w: usize, max_h: usize, apply_crop: bool) -> Option<RenderJob> {
+ let mut job = self.render_job(id, max_w, max_h, false, apply_crop)?;
+ let p = self.catalog.photo(id)?;
+ job.view_cache = Some((self.media.rendered.clone(), Self::view_key(p, apply_crop)));
+ Some(job)
+ }
+
+ /// A render of one window of the loupe's frame, for a view zoomed past what one whole-frame
+ /// render can hold: the frame is `full_w × full_h` (the size the loupe would draw it at) and
+ /// the result is `window`'s pixels of it, at that scale, from the source level that size needs.
+ /// Nothing is cached here (a window is only worth keeping while it is on screen). `None`: no
+ /// such photo, or the window reads (spots, Auto Mask strokes) more than one render can hold.
+ pub fn region_job(
+ &mut self,
+ id: PhotoId,
+ full_w: usize,
+ full_h: usize,
+ window: lightcraft_pipeline::PixelWindow,
+ apply_crop: bool,
+ ) -> Option<RenderJob> {
+ self.region_job_of(id, full_w, full_h, window, apply_crop, false)
+ }
+
+ /// [`Self::region_job`] of the photo without its edits (its crop kept): the Before side.
+ pub fn region_job_before(
+ &mut self,
+ id: PhotoId,
+ full_w: usize,
+ full_h: usize,
+ window: lightcraft_pipeline::PixelWindow,
+ apply_crop: bool,
+ ) -> Option<RenderJob> {
+ self.region_job_of(id, full_w, full_h, window, apply_crop, true)
+ }
+
+ fn region_job_of(
+ &mut self,
+ id: PhotoId,
+ full_w: usize,
+ full_h: usize,
+ window: lightcraft_pipeline::PixelWindow,
+ apply_crop: bool,
+ before: bool,
+ ) -> Option<RenderJob> {
+ let mut job = self.render_job(id, full_w, full_h, before, apply_crop)?;
+ // what the window's spots and Auto Mask strokes read must fit in one render: else the
+ // caller keeps the whole-frame render (a window alone would come out wrong)
+ let p = self.catalog.photo(id)?;
+ let frame = lightcraft_pipeline::geometry::Frame::with_lens(
+ p.width.max(1) as usize,
+ p.height.max(1) as usize,
+ &job.settings,
+ apply_crop,
+ p.embedded_lens.as_ref(),
+ );
+ let ppl = frame.px_per_long(full_w);
+ lightcraft_pipeline::spots::window_for_reads_checked(&job.settings, &frame, full_w, full_h, ppl, window.clamped(full_w, full_h))?;
+ job.request.window = Some(window);
+ job.key = Hasher128::new()
+ .u64(job.key)
+ .str("window")
+ .u64(window.x as u64)
+ .u64(window.y as u64)
+ .u64(window.w as u64)
+ .u64(window.h as u64)
+ .finish()
+ .0 as u64;
+ Some(job)
+ }
+
+ /// The embedded preview of an unedited raw (path, loader), when the app installed a loader.
+ fn embedded_of(&self, p: &Photo) -> Option<(String, PreviewLoader)> {
+ match (&p.source, &self.media.preview_loader) {
+ (Source::File { path }, Some(l)) if p.kind == MediaKind::Raw && crate::import::has_import_look(p) => Some((path.clone(), l.clone())),
+ _ => None,
+ }
+ }
+
+ /// Whether `p`'s thumbnail can be the camera's own JPEG, so a frontend can skip the sensor
+ /// decode behind it.
+ ///
+ /// The grid shows this JPEG first in any case ([`QuickJob`]: "grid thumbnails of unedited raws
+ /// likewise start from the embedded preview"), and then paid for a render of the raw to replace
+ /// it. That render decodes the whole sensor — 50 of a 56 MB Fuji RAF's bytes — for a 512 px
+ /// thumbnail the 4 416 × 2 944 embedded JPEG already covers, and on a share at 1.2 MB/s it is
+ /// 45 s a photo: a 149-photo folder spent 8.3 GB of traffic on thumbnails, and the queue behind
+ /// it delayed the render the user was waiting for.
+ ///
+ /// Only unedited raws answer `true`: any edit must be rendered, and `has_import_look` is what
+ /// says the photo still looks the way it did at import. A photo the user edits re-renders
+ /// through the ordinary path, because its thumbnail key (settings hash) changes.
+ pub fn embedded_thumb_is_final(&self, p: &Photo) -> bool {
+ self.embedded_of(p).is_some()
+ }
+
+ /// The camera's embedded preview of a raw file, for the face scan. Faces are read from the unedited picture, so the
+ /// photo's edits do not matter, and the camera's own JPEG (oriented, display-ready) costs a fraction of decoding the
+ /// raw. `None` for anything else, and where the host installed no loader.
+ #[cfg(not(target_arch = "wasm32"))]
+ pub(crate) fn scan_preview_of(&self, p: &Photo) -> Option<(String, PreviewLoader)> {
+ match (&p.source, &self.media.preview_loader) {
+ (Source::File { path }, Some(l)) if p.kind == MediaKind::Raw => Some((path.clone(), l.clone())),
+ _ => None,
+ }
+ }
+
+ /// Something to show in the loupe right away for `id` (see [`QuickJob`]): its cached view
+ /// render, else the embedded preview of an unedited raw, else a cached or fresh thumbnail.
+ pub fn quick_view_job(&mut self, id: PhotoId, max_edge: usize, apply_crop: bool) -> Option<QuickJob> {
+ let p = self.catalog.photo(id)?.clone();
+ let small = self.thumb_job(id, THUMB_SIZES[THUMB_SIZES.len() - 1])?;
+ // (the thumbnail job itself starts with the cached thumbnail, after the sharper embedded preview)
+ let cached = vec![(self.media.rendered.clone(), Self::view_key(&p, apply_crop))];
+ let h = Hasher128::new().str(&content_key(&p)).str("quick").u64(p.develop.hash64()).u64(apply_crop as u64).finish();
+ let key = h.0 as u64;
+ let embedded = self.embedded_of(&p).map(|(path, l)| (path, l, max_edge.clamp(1, SourceLevel::Preview.max_edge())));
+ Some(QuickJob { request_id: 0, photo: id, key, cached, embedded, small: apply_crop.then(|| Box::new(small)) })
+ }
+
+ /// A first grid thumbnail for an unedited raw: the cached render for `job` (the real
+ /// thumbnail job, from [`Self::thumb_job`]) if there is one — then the result carries
+ /// [`QuickSource::Cached`] and `job.key` and is final — else its embedded preview, else `job`
+ /// itself: the grid queues no render behind an unedited raw's quick thumbnail
+ /// ([`Self::embedded_thumb_is_final`]), so a preview that can't be read must not leave the
+ /// cell empty (issue #1448). `None` for other photos (render them directly).
+ pub fn quick_thumb_job(&mut self, job: &RenderJob) -> Option<QuickJob> {
+ let p = self.catalog.photo(job.photo)?.clone();
+ let (path, l) = self.embedded_of(&p)?;
+ let edge = job.request.max_w.max(job.request.max_h);
+ Some(QuickJob {
+ request_id: 0,
+ photo: job.photo,
+ key: job.key,
+ cached: job.cache.clone().into_iter().collect(),
+ embedded: Some((path, l, edge)),
+ small: Some(Box::new(job.clone())),
+ })
+ }
+
+ /// Accept a finished job's loaded source into the cache. What the decode learnt about the file that the catalog
+ /// has wrong is corrected too ([`Self::learn_as_shot_wb`]).
+ pub fn accept(&mut self, r: &RenderResult) {
+ if let Some(src) = &r.loaded
+ && r.source_key.is_none_or(|key| self.catalog.photo(r.photo).is_some_and(|p| Hasher128::new().str(&content_key(p)).finish() == key))
+ {
+ if let Some(info) = &src.info {
+ self.learn_as_shot_wb(r.photo, info);
+ }
+ self.media.insert_source(r.photo, r.level, src.clone());
+ }
+ }
+
+ /// Record the as-shot white balance a decode of photo `id`'s file read (`info`) when the catalog has another:
+ /// a raw imported before its camera's matrices gave it a Kelvin scale keeps 6500 / 0 (the relative scale's
+ /// reference) until its file is next decoded (issue #730). Bookkeeping, not an undo step; the look does not
+ /// change (the pipeline reads the stored settings against the real as-shot white either way), only what As Shot
+ /// says and what a smart preview renders with. Only for raws edited in Kelvin.
+ fn learn_as_shot_wb(&mut self, id: PhotoId, info: &SourceInfo) {
+ let Some(p) = self.catalog.photo(id) else { return };
+ if !info.raw || info.relative_wb || !p.develops_raw() || p.relative_wb() {
+ return;
+ }
+ let read = (info.as_shot_temp, info.as_shot_tint);
+ if !(read.0.is_finite() && read.1.is_finite()) || p.as_shot_wb == Some(read) {
+ return;
+ }
+ if let Err(e) = self.apply_system(Op::SetAsShotWb { id, wb: Some(read) }) {
+ log::warn!("photo {}: as-shot white balance not recorded: {e}", id.0);
+ }
+ }
+
+ /// Synchronous render (CLI, MCP, tests).
+ pub fn render_now(&mut self, id: PhotoId, max_w: usize, max_h: usize) -> Result<Rendered, String> {
++ lightcraft_pipeline::check_output_size(max_w, max_h)?;
+ let job = self.render_job(id, max_w, max_h, false, true).ok_or("no such photo")?;
+ let r = job.run();
+ self.accept(&r);
+ r.rendered
+ }
+
+ /// Synchronous render for export: like [`Self::render_now`], into colour space `space` with
+ /// sample format `depth`.
+ pub fn render_export(
+ &mut self,
+ id: PhotoId,
+ max_w: usize,
+ max_h: usize,
+ space: lightcraft_pipeline::OutputSpace,
+ depth: lightcraft_pipeline::OutputDepth,
+ ) -> Result<Rendered, String> {
+ let r = self.export_job(id, max_w, max_h, space, depth)?.run();
+ self.accept(&r);
+ r.rendered
+ }
+
+ /// The job [`Self::render_export`] runs, to run elsewhere (e.g. a background export thread).
+ pub fn export_job(
+ &mut self,
+ id: PhotoId,
+ max_w: usize,
+ max_h: usize,
+ space: lightcraft_pipeline::OutputSpace,
+ depth: lightcraft_pipeline::OutputDepth,
+ ) -> Result<RenderJob, String> {
++ lightcraft_pipeline::check_output_size(max_w, max_h)?;
+ let mut job = self.render_job(id, max_w, max_h, false, true).ok_or("no such photo")?;
+ // An export renders the full image: never a thumbnail's source developed from a smaller copy of the raw
+ // image that the file keeps (Lightroom's merged DNGs)
+ let reduced = match &job.source {
+ SourceRef::Loaded(s) => s.reduced,
+ SourceRef::Fit { from, .. } => from.reduced,
+ _ => false,
+ };
+ if reduced {
+ let p = self.catalog.photo(id).ok_or("no such photo")?.clone();
+ job.source = self.media.source_ref_uncached(&p, job.level);
+ }
+ // An export is made from the denoised picture its Denoise amount asks for, made when the job runs if the
+ // background queue has not got to it. (A source kept in memory may lack the picture, so the job reads the file.)
+ if let Some(wanted) = self.denoise_for_export(id, &job.settings)? {
+ let p = self.catalog.photo(id).ok_or("no such photo")?.clone();
+ job.source = self.media.source_ref_uncached(&p, job.level);
+ if let SourceRef::File { denoise, .. } = &mut job.source {
+ *denoise = Some(wanted);
+ }
+ }
+ job.request.space = space;
+ job.request.depth = depth;
+ job.key ^= (space as u64 + 1).wrapping_mul(0xa076_1d64_78bd_642f) ^ (depth as u64 + 1).wrapping_mul(0xe703_7ed1_a0b4_28db);
+ Ok(job)
+ }
+
+ /// Prefer decoder facts to header-only metadata for pixel-statistics commands.
+ pub fn source_info(&self, id: PhotoId) -> SourceInfo {
+ let header = self.catalog.photo(id).map(|p| source_info(p)).unwrap_or_default();
+ self.media.source_facts(id, header)
+ }
+
+ /// The source proxy for pixel-statistics commands (auto tone/WB), loading synchronously.
+ pub fn source_now(&mut self, id: PhotoId, level: SourceLevel) -> Result<Arc<Rgb32f>, String> {
+ let p = self.catalog.photo(id).ok_or("no such photo")?.clone();
+ let r = self.media.source_ref(&p, level).load_source()?;
+ let image = r.image.clone();
+ if let Some(info) = &r.info {
+ self.learn_as_shot_wb(id, info);
+ }
+ self.media.insert_source(id, level, r);
+ Ok(image)
+ }
+}
diff --cc crates/engine/src/tests/export.rs
index 24fc7b4fc,217e68ea1..8a4f5392e
--- a/crates/engine/src/tests/export.rs
+++ b/crates/engine/src/tests/export.rs
@@@ -1374,25 -1204,15 +1374,38 @@@ fn same_folder_as_original_refuses_phot
let _ = std::fs::remove_dir_all(&dir);
}
+/// Issue #2882: the demo photo's 16-bit TIFF export (2000 px long edge) with ZIP (the default) is
+/// never larger than the same export uncompressed.
+#[test]
+fn sixteen_bit_zip_tiff_export_is_never_larger_than_uncompressed() {
+ use crate::export::TiffCompression;
+ let mut s = Session::with_demo();
+ let id = s.active().unwrap();
+ let size = |s: &mut Session, tiff_compression| {
+ let o = ExportOptions {
+ format: ExportFormat::Tiff,
+ bit_depth: Some(16),
+ tiff_compression,
+ ..ExportOptions::from_json(&json!({"longEdge": 2000}))
+ };
+ export_photo(s, id, &o, 1).unwrap().bytes.len()
+ };
+ let none = size(&mut s, TiffCompression::None);
+ let zip = size(&mut s, TiffCompression::Deflate);
+ let lzw = size(&mut s, TiffCompression::Lzw);
+ eprintln!("demo photo, 16-bit TIFF: none {none} B, ZIP {zip} B, LZW {lzw} B");
+ assert!(zip <= none, "16-bit ZIP {zip} B is larger than uncompressed {none} B");
+}
++
+ /// An absurd export size is refused, not a multiply overflow (it panicked before the fix).
+ #[test]
+ fn huge_export_size_is_an_error() {
+ use lightcraft_pipeline::{OutputDepth, OutputSpace};
+ let mut s = Session::with_demo();
+ let id = s.active().unwrap();
+ let huge = usize::MAX >> 8;
+ assert!(s.render_export(id, huge, huge, OutputSpace::Srgb, OutputDepth::U8).is_err());
+ assert!(s.render_export(id, 70_000, 10, OutputSpace::Srgb, OutputDepth::U8).is_err());
+ assert!(s.render_now(id, huge, huge).is_err());
+ assert!(s.render_now(id, 10, 70_000).is_err());
+ }