LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
refactor(lightcraft-engine): split media.rs into media/
aiongg21304db29b27
diff --git a/crates/engine/src/media.rs b/crates/engine/src/media.rsindex 353825465..7377e23f1 100644--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@ -26,331 +26,23 @@ use lightcraft_preview::{Hash128, Hasher128, Lru, PreviewCache};use lightcraft_raster::{Histogram, Rgb32f, Rgba8};use serde::{Deserialize, Serialize};-const SETTINGS_HASH_ENTRIES: usize = 1024;--#[derive(Default)]-struct SettingsHashes {- entries: HashMap<PhotoId, (Weak<DevelopSettings>, u64)>,- order: VecDeque<PhotoId>,- #[cfg(test)]- computations: usize,-}--impl SettingsHashes {- fn get(&mut self, id: PhotoId, settings: &Arc<DevelopSettings>) -> u64 {- if let Some((old, hash)) = self.entries.get(&id)- && old.as_ptr() == Arc::as_ptr(settings)- {- return *hash;- }- let hash = settings.hash64();- #[cfg(test)]- {- self.computations += 1;- }- if !self.entries.contains_key(&id) {- if self.entries.len() >= SETTINGS_HASH_ENTRIES- && let Some(oldest) = self.order.pop_front()- {- self.entries.remove(&oldest);- }- self.order.push_back(id);- }- self.entries.insert(id, (Arc::downgrade(settings), hash));- hash- }-}--/// Bump when the pipeline's output changes, to invalidate cached thumbnails.-pub const RENDER_CACHE_VERSION: u64 = 70;--/// 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];--/// Face tiles are rendered at a multiple of this many pixels ([`crate::Session::face_job`]): the-/// tile's size follows the thumbnail slider and the screen's scale, and without steps every size-/// in between would render (and cache) every face again.-pub const FACE_EDGE_STEP: usize = 16;--/// The edge a face tile asked to be `edge` pixels across is rendered at: the next-/// [`FACE_EDGE_STEP`], 16..=512.-pub fn face_edge(edge: usize) -> usize {- edge.clamp(16, SourceLevel::Thumb.max_edge()).div_ceil(FACE_EDGE_STEP).saturating_mul(FACE_EDGE_STEP).min(SourceLevel::Thumb.max_edge())-}--pub fn thumb_bucket(long_edge: usize) -> usize {- THUMB_SIZES.iter().copied().find(|s| *s >= long_edge).unwrap_or(512)-}--/// Memory budgets.-const THUMB_SOURCE_BYTES: usize = 384 << 20;-const RENDERED_MEM_BYTES: usize = 128 << 20;-/// Disk budget for the thumbnail cache.-pub const DISK_CACHE_BYTES: u64 = 2 << 30;--#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]-#[serde(rename_all = "lowercase")]-pub enum SourceLevel {- Thumb,- Preview,- /// The original at its native resolution (exports larger than a preview).- Full,-}--impl SourceLevel {- pub fn max_edge(self) -> usize {- match self {- SourceLevel::Thumb => 512,- SourceLevel::Preview => 2560,- SourceLevel::Full => usize::MAX,- }- }- /// Smallest level that can serve an output of `long_edge` pixels.- pub fn for_size(long_edge: usize) -> SourceLevel {- match long_edge {- 0..=520 => SourceLevel::Thumb,- 521..=2560 => SourceLevel::Preview,- _ => SourceLevel::Full,- }- }-}--/// Pixels along the source's long edge that an output `out_long` pixels long needs: a crop shows-/// only part of the photo, so its pixels come from a source that many times larger (the source-/// level is chosen from this, or a tight crop shown at its own pixels would be a stretched preview).-fn source_edge_needed(p: &Photo, settings: &DevelopSettings, apply_crop: bool, out_long: usize) -> usize {- let (w, h) = (f64::from(p.width.max(1)), f64::from(p.height.max(1)));- let r = settings.crop.geometry.rect;- let shown = if apply_crop { (r.width() * w).max(r.height() * h) } else { w.max(h) };- if !shown.is_finite() || shown < 1.0 {- return out_long;- }- let needed = out_long as f64 * w.max(h) / shown;- if needed.is_finite() { needed.min(usize::MAX as f64 / 2.0) as usize } else { out_long }-}--/// Decodes a file into a linear Rec.2020 image no larger than `max_edge` (set by the app).-pub type FileLoader = Arc<dyn Fn(&str, usize) -> Result<(Rgb32f, SourceInfo), String> + Send + Sync>;--/// [`FileLoader`] for a thumbnail: a raw file that keeps smaller copies of its raw image (Lightroom's merged DNGs)-/// develops the smallest that covers `max_edge` (set by the app); the flag says it did. Never used for an export,-/// which must render the full image.-pub type ReducedLoader = Arc<dyn Fn(&str, usize) -> Result<(Rgb32f, SourceInfo, bool), String> + Send + Sync>;--/// A raw file's embedded (camera-rendered) preview as display sRGB, oriented, no larger than-/// `max_edge` (set by the app). `None`: no usable preview.-pub type PreviewLoader = Arc<dyn Fn(&str, usize) -> Option<Rgba8> + Send + Sync>;--/// Makes a photo's denoised picture when it is not cached yet (an export does not wait for the background queue):-/// `Ok(true)` once it is there, `Ok(false)` when denoise does not apply to this photo (render it plain), `Err` when it-/// should have worked and did not.-pub type MakeProduct = Arc<dyn Fn() -> Result<bool, String> + Send + Sync>;--/// A raw photo's cached AI-denoised picture (see [`crate::denoise`]): where the file is and the key it must have been-/// made with. A file that is missing, damaged or made for something else is a cache miss, never an error.-#[derive(Clone)]-pub struct DenoiseSpec {- pub product: std::path::PathBuf,- pub key: String,- /// Run before the picture is read, by a job that must not render without it (an export).- pub make: Option<MakeProduct>,-}--/// Decodes a raw file once and develops it twice: as usual, and from the denoised picture in `spec` when that can be-/// read (`None` when it cannot). Both are at most `max_edge` long and the same size.-pub type PairLoader = Arc<dyn Fn(&str, usize, &DenoiseSpec) -> Result<(Rgb32f, Option<Rgb32f>, SourceInfo), String> + Send + Sync>;--/// A photo's denoised picture next to its plain one, and the last mix of the two that was asked for.-pub struct Twin {- pub image: Arc<Rgb32f>,- /// The Amount (in thousandths) and the picture mixed for it, so dragging other sliders keeps one source picture.- mix: std::sync::Mutex<Option<(u32, Arc<Rgb32f>)>>,-}--impl Twin {- pub fn new(image: Arc<Rgb32f>) -> Twin {- Twin { image, mix: std::sync::Mutex::new(None) }- }-- /// Bytes reserved for the twin and its lazy mix, before either cache cost can grow.- fn bytes(&self) -> usize {- self.image.data.len().saturating_mul(24)- }-}--/// Pixels and the source interpretation learned while decoding; they must be cached together.-#[derive(Clone)]-pub struct DecodedSource {- pub image: Arc<Rgb32f>,- pub info: Option<SourceInfo>,- /// A smart preview's stored camera tone curve: the one decoder fact its pixels need that the- /// catalog's header facts lack (used when `info` is `None`).- pub camera_tone: Option<lightcraft_pipeline::tone::CameraTone>,- /// The same picture developed from the AI-denoised mosaic, when the photo has one cached.- pub denoised: Option<Arc<Twin>>,- /// These pixels came from the photo's smart preview (an offline original), not from its file.- /// A refresh must never rebuild a proxy from itself: that would stamp its older look as current.- pub from_proxy: bool,- /// Developed from a smaller copy of the raw image that the file keeps ([`ReducedLoader`]), not from the image- /// itself: good for a thumbnail, never for an export.- pub reduced: bool,-}--impl DecodedSource {- pub fn new(image: Arc<Rgb32f>, info: Option<SourceInfo>) -> Self {- DecodedSource { image, info, camera_tone: None, denoised: None, from_proxy: false, reduced: false }- }-- /// The picture to develop for a Denoise `amount` (0 to 1, see [`DevelopSettings::denoise_amount`]): the plain one,- /// the denoised one, or a mix of the two. A mix is made once per amount and kept, so the stages after it are- /// reused until the amount changes.- pub fn image_for(&self, amount: f32) -> Arc<Rgb32f> {- let Some(twin) = &self.denoised else { return self.image.clone() };- if amount.is_nan() || amount <= 0.0 || twin.image.width != self.image.width || twin.image.height != self.image.height {- return self.image.clone();- }- if amount >= 1.0 {- return twin.image.clone();- }- let thousandths = (amount * 1000.0).round().clamp(1.0, 999.0) as u32;- let mut memo = twin.mix.lock().unwrap_or_else(std::sync::PoisonError::into_inner);- if let Some((t, img)) = memo.as_ref()- && *t == thousandths- {- return img.clone();- }- let mut mixed = (*self.image).clone();- if !lightcraft_denoise::product::blend(&mut mixed, &twin.image, thousandths as f32 / 1000.0) {- return self.image.clone();- }- let mixed = Arc::new(mixed);- *memo = Some((thousandths, mixed.clone()));- mixed- }-- /// Cache cost: the picture, its segmentation mattes, its denoised twin and room for the lazy mix.- pub fn bytes(&self) -> usize {- let mattes = self.info.as_ref().and_then(|i| i.mattes.as_ref()).map_or(0, |m| m.bytes());- let mattes = mattes + self.info.as_ref().and_then(|i| i.local_tone.as_ref()).map_or(0, |t| t.map.gains.len() * 4);- self.image.data.len() * 12 + 64 + std::mem::size_of::<SourceInfo>() + mattes + self.denoised.as_ref().map_or(0, |t| t.bytes())- }-- /// What to render these pixels against: the decoder's facts, else `header` (the catalog's)- /// with any stored camera tone curve. The original's size comes from `header` either way: the- /// decoder only sees the level it decoded.- pub fn info_or(&self, header: SourceInfo) -> SourceInfo {- match &self.info {- Some(info) => SourceInfo { native_long: info.native_long.or(header.native_long), ..info.clone() },- None => SourceInfo { camera_tone: self.camera_tone.or(header.camera_tone), ..header },- }- }-}--#[derive(Clone)]-pub enum SourceRef {- Loaded(Box<DecodedSource>),- /// A larger decoded source of the photo, fitted to `max_edge` by the worker: the thumbnail of- /// the photo open in the loupe is cut from its preview-level source instead of decoding the- /// file again (a second or more for a 64 MP raw).- Fit {- from: Box<DecodedSource>,- max_edge: usize,- },- Demo {- scene: Box<lightcraft_scenes::Scene>,- max_edge: usize,- },- File {- path: String,- max_edge: usize,- loader: Option<FileLoader>,- /// The photo's smart preview, used when the original can't be read (offline drive). The- /// UI thread never checks whether the original is there; the render worker finds out.- fallback: Option<std::path::PathBuf>,- /// The photo has a cached denoised picture: load it with the plain one (see [`PairLoader`]).- denoise: Option<(DenoiseSpec, PairLoader)>,- /// A thumbnail's loader, used instead of `loader` (see [`ReducedLoader`]); `None` for every other job.- reduced: Option<ReducedLoader>,- },- /// A smart preview standing in for a missing original.- Smart {- path: std::path::PathBuf,- },-}--impl SourceRef {- pub fn load(&self) -> Result<Arc<Rgb32f>, String> {- self.load_source().map(|s| s.image)- }-- pub fn load_source(&self) -> Result<DecodedSource, String> {- let image = match self {- SourceRef::Loaded(a) => return Ok((**a).clone()),- SourceRef::Fit { from, max_edge } => {- if from.image.width.max(from.image.height) <= *max_edge {- return Ok((**from).clone());- }- // Lanczos, not a box average: a box at 2-3:1 halves the contrast of detail near- // the output's resolution limit and aliases what is finer- let image = lightcraft_raster::resample::fit(&from.image, *max_edge, *max_edge, lightcraft_raster::resample::Filter::Lanczos3);- return Ok(DecodedSource { image: Arc::new(image), denoised: None, ..(**from).clone() });- }- SourceRef::Demo { scene, max_edge } => crate::demo::scene_pixels(scene, *max_edge)?,- SourceRef::File { path, max_edge, loader, fallback, denoise, reduced } => {- let plain = || match (reduced, loader) {- (Some(l), _) => {- l(path, *max_edge).map(|(image, info, reduced)| DecodedSource { reduced, ..DecodedSource::new(Arc::new(image), Some(info)) })- }- (None, Some(l)) => l(path, *max_edge).map(|(image, info)| DecodedSource::new(Arc::new(image), Some(info))),- (None, None) => Err(format!("no decoder available for {path}")),- };- // the denoised picture comes with the plain one from a single decode; when it cannot be read the- // pair loader gives the plain picture alone (the cached file is never a reason to fail a render)- let r = match denoise {- Some((spec, pair)) => {- // a job that needs the denoised picture has it made first; if that fails the job fails (no smart- // preview stands in: an export must not quietly come out without the denoise it was asked for)- let made = match &spec.make {- Some(make) => make()?,- None => true,- };- if made {- pair(path, *max_edge, spec).and_then(|(image, twin, info)| {- if spec.make.is_some() && twin.is_none() {- return Err("the cached AI Denoise picture could not be read; clear the denoise cache and retry".into());- }- Ok(DecodedSource {- image: Arc::new(image),- info: Some(info),- camera_tone: None,- denoised: twin.map(|t| Arc::new(Twin::new(Arc::new(t)))),- from_proxy: false,- reduced: false,- })- })- } else {- plain()- }- }- None => plain(),- };- // An offline original renders from its smart preview (no decoder facts: header ones).- return match (r, fallback) {- #[cfg(not(target_arch = "wasm32"))]- (Err(e), Some(sp)) if denoise.as_ref().is_none_or(|(spec, _)| spec.make.is_none()) && crate::smart::is_valid(sp) => {- crate::smart::load(sp).map_err(|e2| format!("{e}; smart preview: {e2}"))- }- (r, _) => r,- };- }- #[cfg(not(target_arch = "wasm32"))]- SourceRef::Smart { path } => return crate::smart::load(path),- #[cfg(target_arch = "wasm32")]- SourceRef::Smart { .. } => return Err("smart previews are not available here".into()),- };- Ok(DecodedSource::new(image, None))- }-}+mod cache;+mod quick;+mod render;+mod session;+mod settings_hash;+mod source;++pub use cache::DenoiseIndex;+pub use quick::{QuickJob, QuickSource, content_key, source_info};+pub use render::{RenderJob, RenderResult, develop, develop_reporting, fit_for_display};+#[cfg(test)]+use settings_hash::SETTINGS_HASH_ENTRIES;+use settings_hash::SettingsHashes;+pub use source::{+ DISK_CACHE_BYTES, DecodedSource, DenoiseSpec, FACE_EDGE_STEP, FileLoader, FileProbe, MakeProduct, PairLoader, PreviewLoader, ProbeInfo,+ RENDER_CACHE_VERSION, ReducedLoader, SourceLevel, SourceRef, THUMB_SIZES, Twin, face_edge, thumb_bucket,+};pub struct MediaCache {settings_hashes: SettingsHashes,@@ -389,1368 +81,6 @@ pub struct MediaCache {pub denoise: DenoiseIndex,}-/// The photos that have a cached denoised picture for the denoise model in use. Only memory: nothing here touches the-/// file system, so it can be asked on the UI thread.-#[derive(Default)]-pub struct DenoiseIndex {- ready: std::collections::HashMap<PhotoId, DenoiseSpec>,- /// Reads the pictures (`None`: this build cannot, and nothing is ever ready).- pub loader: Option<PairLoader>,-}--impl DenoiseIndex {- /// What to load for `id` besides its plain picture, and how.- pub fn get(&self, id: PhotoId) -> Option<(&DenoiseSpec, &PairLoader)> {- self.ready.get(&id).zip(self.loader.as_ref())- }-- pub fn spec(&self, id: PhotoId) -> Option<&DenoiseSpec> {- self.ready.get(&id)- }-- pub fn set(&mut self, id: PhotoId, spec: DenoiseSpec) {- self.ready.insert(id, spec);- }-- pub fn remove(&mut self, id: PhotoId) -> bool {- self.ready.remove(&id).is_some()- }-- pub fn clear(&mut self) {- self.ready.clear();- }-- pub fn len(&self) -> usize {- self.ready.len()- }-- pub fn is_empty(&self) -> bool {- self.ready.is_empty()- }-- pub fn ids(&self) -> Vec<PhotoId> {- let mut v: Vec<PhotoId> = self.ready.keys().copied().collect();- v.sort();- v- }-}--impl Default for MediaCache {- fn default() -> Self {- let budget = crate::memory::cache_share(crate::memory::budget());- MediaCache {- settings_hashes: SettingsHashes::default(),- thumbs: Lru::new(THUMB_SOURCE_BYTES.min(budget)),- previews: Vec::new(),- full: Vec::new(),- full_capacity: 1,- on_screen: None,- preview_capacity: 0,- budget,- file_loader: None,- reduced_loader: None,- file_probe: None,- preview_loader: None,- file_bytes: None,- smart_dir: None,- availability: Default::default(),- scenes: Vec::new(),- rendered: Arc::new(PreviewCache::memory(rendered_budget(budget))),- denoise: DenoiseIndex::default(),- }- }-}--/// Memory for rendered previews out of the cache share.-fn rendered_budget(share: usize) -> usize {- RENDERED_MEM_BYTES.min(share / 4)-}--impl MediaCache {- /// Keep rendered thumbnails on disk in `dir` as well. The cache this replaces is retired- /// (its files stay): render jobs still holding it can't write through it any more, even- /// into a directory a later clear emptied (`dir` may be the same one).- pub fn attach_disk_cache(&mut self, dir: &std::path::Path, disk_bytes: u64) {- self.rendered.retire();- self.rendered = Arc::new(PreviewCache::with_disk(rendered_budget(self.budget), dir, disk_bytes));- }-- /// Change the disk budget of the cache in `dir`: in place when that cache is attached (its- /// thumbnails are keyed by content, so they and the textures shown from them stay valid,- /// and the same cache object keeps its generation), else attach it.- pub fn set_disk_cache_bytes(&mut self, dir: &std::path::Path, disk_bytes: u64) {- match self.rendered.disk().filter(|d| d.dir() == dir) {- Some(d) => d.set_budget(disk_bytes),- None => self.attach_disk_cache(dir, disk_bytes),- }- }-- /// Forget every decoded source (photo ids changed meaning, e.g. another library was opened).- pub fn clear_sources(&mut self) {- self.settings_hashes = SettingsHashes::default();- self.thumbs = Lru::new(THUMB_SOURCE_BYTES.min(self.budget));- self.previews.clear();- self.full.clear();- }-- /// How many full-resolution originals to keep at once (at least one). Compare and Reference- /// views zoomed to 1:1 cut windows from two photos' originals: with room for one, every window- /// render of one side would evict the other side's original and decode its own again. Lowering- /// it drops the least recently used originals at once.- pub fn set_full_capacity(&mut self, n: usize) {- self.full_capacity = n.max(1);- self.trim_full();- }-- /// The photo the loupe shows (the frontend sets it every frame; `None` in other views). Its original stays- /// even over budget: a 64 MP original (797 MB as linear float) alone exceeds the default share, and evicting it- /// made every pan of a zoomed view decode the raw again. Showing another photo lets it go at once.- pub fn set_on_screen(&mut self, id: Option<PhotoId>) {- if self.on_screen != id {- self.on_screen = id;- self.enforce_budget();- }- }-- fn trim_full(&mut self) {- while self.full.len() > self.full_capacity {- let oldest = self.full.iter().enumerate().min_by_key(|(_, e)| e.2).map(|(i, _)| i).unwrap_or(0);- self.full.remove(oldest);- }- }-- /// Bytes the caches may hold together.- pub fn budget(&self) -> usize {- self.budget- }-- /// Change the bytes the caches may hold together, evicting at once if needed.- pub fn set_budget(&mut self, bytes: usize) {- self.budget = bytes;- self.thumbs.set_budget(THUMB_SOURCE_BYTES.min(bytes));- self.rendered.set_mem_budget(rendered_budget(bytes));- self.enforce_budget();- }-- /// Bytes held by decoded sources and rendered previews in memory.- pub fn held(&self) -> usize {- let (t, p, f) = self.usage();- t.bytes + p.bytes + f.bytes + self.rendered.mem_usage().1- }-- /// Evict least recently used entries across the source caches and the rendered previews- /// until they fit the budget. The newest preview-level source (the photo on screen, or the- /// one just decoded) is never evicted here, nor is the original of the photo on screen- /// ([`Self::set_on_screen`]).- pub fn enforce_budget(&mut self) {- // The on-screen original is never evicted here, so it does not count either: counted, a 64 MP original (760 MiB)- // nearly fills the default share (768 MiB) alone and everything else went instead — the photo's preview and- // thumbnail sources and the neighbours' were decoded again from the raw on every edit, zoom-out and step.- let pinned: usize = self.full.iter().filter(|e| Some(e.0) == self.on_screen).map(|e| e.1.bytes()).sum();- let mut held = self.held().saturating_sub(pinned);- while held > self.budget {- let newest_preview = self.previews.iter().map(|e| e.2).max();- let candidates = [- self.thumbs.oldest_tick().map(|t| (t, 0)),- self.previews.iter().filter(|e| Some(e.2) != newest_preview).map(|e| e.2).min().map(|t| (t, 1)),- self.full.iter().filter(|e| Some(e.0) != self.on_screen).map(|e| e.2).min().map(|t| (t, 2)),- self.rendered.oldest_tick().map(|t| (t, 3)),- ];- let Some((tick, which)) = candidates.into_iter().flatten().min() else { break };- let freed = match which {- 0 => self.thumbs.pop_oldest(),- 1 => self.previews.iter().position(|e| e.2 == tick).map(|i| self.previews.remove(i).1.bytes()),- 2 => self.full.iter().position(|e| e.2 == tick).map(|i| self.full.remove(i).1.bytes()),- _ => self.rendered.evict_oldest(),- };- match freed {- Some(b) if b > 0 => held = held.saturating_sub(b),- _ => break,- }- }- }-- pub fn get(&mut self, id: PhotoId, level: SourceLevel) -> Option<Arc<Rgb32f>> {- self.get_source(id, level).map(|s| s.image)- }-- fn get_source(&mut self, id: PhotoId, level: SourceLevel) -> Option<DecodedSource> {- match level {- SourceLevel::Thumb => self.thumbs.get(&id).cloned(),- SourceLevel::Preview => self.previews.iter_mut().find(|e| e.0 == id).map(|e| {- e.2 = lightcraft_preview::next_tick();- e.1.clone()- }),- SourceLevel::Full => self.full.iter_mut().find(|e| e.0 == id).map(|e| {- e.2 = lightcraft_preview::next_tick();- e.1.clone()- }),- }- }-- /// The facts of photo `id`'s cached sources: the decoder's when one has them, else `header`- /// (with a smart preview's stored camera tone curve).- fn source_facts(&self, id: PhotoId, header: SourceInfo) -> SourceInfo {- let cached = || {- self.thumbs- .peek(&id)- .into_iter()- .chain(self.previews.iter().filter(|e| e.0 == id).map(|e| &e.1))- .chain(self.full.iter().filter(|e| e.0 == id).map(|e| &e.1))- };- match cached().find(|s| s.info.is_some()).or_else(|| cached().next()) {- Some(s) => s.info_or(header),- None => header,- }- }-- pub fn insert(&mut self, id: PhotoId, level: SourceLevel, img: Arc<Rgb32f>) {- self.insert_source(id, level, DecodedSource::new(img, None));- }-- fn insert_source(&mut self, id: PhotoId, level: SourceLevel, img: DecodedSource) {- let tick = lightcraft_preview::next_tick();- match level {- SourceLevel::Thumb => {- let cost = img.bytes();- self.thumbs.insert(id, img, cost);- }- SourceLevel::Preview => {- self.previews.retain(|e| e.0 != id);- self.previews.push((id, img, tick));- let cap = if self.preview_capacity == 0 { 4 } else { self.preview_capacity };- while self.previews.len() > cap {- let oldest = self.previews.iter().enumerate().min_by_key(|(_, e)| e.2).map(|(i, _)| i).unwrap_or(0);- self.previews.remove(oldest);- }- }- SourceLevel::Full => {- self.full.retain(|e| e.0 != id);- self.full.push((id, img, tick));- self.trim_full();- }- }- self.enforce_budget();- }-- /// Forget a photo's decoded sources (e.g. after its file changed).- pub fn forget(&mut self, id: PhotoId) {- self.thumbs.remove(&id);- self.previews.retain(|e| e.0 != id);- self.full.retain(|e| e.0 != id);- }-- /// (decoded thumbnail sources, bytes).- pub fn source_usage(&self) -> (usize, usize) {- (self.thumbs.len(), self.thumbs.cost())- }-- /// Whether the decoded source of `id` at `level` is held.- pub fn has_source(&self, id: PhotoId, level: SourceLevel) -> bool {- match level {- SourceLevel::Thumb => self.thumbs.contains(&id),- SourceLevel::Preview => self.previews.iter().any(|e| e.0 == id),- SourceLevel::Full => self.full.iter().any(|e| e.0 == id),- }- }-- /// Decoded sources held: (thumbnail level, preview level, full size).- pub fn usage(&self) -> (crate::memory::Usage, crate::memory::Usage, crate::memory::Usage) {- use crate::memory::Usage;- let previews = Usage::new(self.previews.len(), self.previews.iter().map(|e| e.1.bytes()).sum());- let full = Usage::new(self.full.len(), self.full.iter().map(|e| e.1.bytes()).sum());- (Usage::new(self.thumbs.len(), self.thumbs.cost()), previews, full)- }-- /// What a render of photo `id` with settings `s` adds to its identity for the denoised picture it will use: 0 unless- /// it uses one (the Denoise amount is above 0 and the photo has a cached denoised picture).- pub fn denoise_salt(&self, id: PhotoId, s: &DevelopSettings) -> u64 {- match self.denoise.spec(id) {- Some(spec) if s.denoise_amount() > 0.0 => Hasher128::new().str(&spec.key).finish().0 as u64 | 1,- _ => 0,- }- }-- /// How to load photo `p` at `level`: from the cache when its source is there, else from its file (with its denoised- /// picture beside it when it has one), its smart preview or the demo scene.- pub fn source_ref(&mut self, p: &Photo, level: SourceLevel) -> SourceRef {- self.source_ref_with(p, level, true)- }-- /// [`Self::source_ref`] that never takes a decoded source from memory: for a job that needs something the cached- /// one lacks (an export, whose denoised picture is made when it runs).- pub fn source_ref_uncached(&mut self, p: &Photo, level: SourceLevel) -> SourceRef {- self.source_ref_with(p, level, false)- }-- fn source_ref_with(&mut self, p: &Photo, level: SourceLevel, cached: bool) -> SourceRef {- let mut r = self.source_ref_plain(p, level, cached);- if let (SourceRef::File { denoise, .. }, Some((spec, loader))) = (&mut r, self.denoise.get(p.id)) {- *denoise = Some((spec.clone(), loader.clone()));- }- r- }-- fn source_ref_plain(&mut self, p: &Photo, level: SourceLevel, cached: bool) -> SourceRef {- if cached && let Some(a) = self.get_source(p.id, level) {- return SourceRef::Loaded(Box::new(a));- }- // a thumbnail of a photo whose preview is decoded (the one in the loupe) is cut from it; not- // with a denoised picture, which the thumbnail would lose- if cached- && level == SourceLevel::Thumb- && self.denoise.spec(p.id).is_none()- && let Some(big) = self.get_source(p.id, SourceLevel::Preview)- {- return SourceRef::Fit { from: Box::new(big), max_edge: level.max_edge() };- }- // Procedural scenes have a nominal size: "full" is that size, not unbounded.- let max_edge = level.max_edge().min(match (&p.source, level) {- (Source::Demo { .. }, SourceLevel::Full) => p.width.max(p.height).max(1) as usize,- _ => usize::MAX,- });- // the original is offline: its smart preview, when there is one. Only cached answers are- // used here (no file-system call on the UI thread in the app); an original not known to- // be offline is tried first and its smart preview is the render worker's fallback.- #[cfg(not(target_arch = "wasm32"))]- if let (Source::File { path }, Some(dir)) = (&p.source, &self.smart_dir) {- let sharded = crate::smart::sharded_file_path(dir, p);- let legacy = dir.join(crate::smart::file_name(p));- let sp = if self.availability.exists(&sharded.to_string_lossy()) == Some(true) { sharded } else { legacy };- // (a proxy cut short fails to load, like the offline original; the worker's fallback- // in `SourceRef::load` only uses a proxy that passes `smart::is_valid`)- if self.availability.is_offline(path) && self.availability.exists(&sp.to_string_lossy()) == Some(true) {- return SourceRef::Smart { path: sp };- }- let mut r = self.origin_ref(&p.source, max_edge);- if let SourceRef::File { fallback, .. } = &mut r {- *fallback = Some(sp);- }- return r;- }- self.origin_ref(&p.source, max_edge)- }-- /// How to load `origin` at most `max_edge` pixels long, ignoring decoded sources in memory (a- /// render worker in another wasm instance builds its sources from this).- pub fn origin_ref(&mut self, origin: &Source, max_edge: usize) -> SourceRef {- match origin {- Source::Demo { scene } => {- if self.scenes.is_empty() {- self.scenes = lightcraft_scenes::demo_library();- }- match self.scenes.iter().find(|s| s.id == *scene) {- Some(s) => SourceRef::Demo { scene: Box::new(s.clone()), max_edge },- None => SourceRef::File { path: format!("demo:{scene}"), max_edge, loader: None, fallback: None, denoise: None, reduced: None },- }- }- Source::File { path } => {- SourceRef::File { path: path.clone(), max_edge, loader: self.file_loader.clone(), fallback: None, denoise: None, reduced: None }- }- }- }-}--/// Everything needed to render one photo, detached from the session.-#[derive(Clone)]-pub struct RenderJob {- /// Assigned by a frontend to distinguish late completions, even for an identical render key.- pub request_id: u64,- pub cache_generation: u64,- /// Content identity for validating a decoded source returned after a reload.- pub source_key: Option<Hash128>,- pub photo: PhotoId,- pub level: SourceLevel,- pub source: SourceRef,- /// Where the photo's pixels come from (for executors that can't share `source`, e.g. a web- /// worker).- pub origin: Source,- pub info: SourceInfo,- pub settings: Arc<DevelopSettings>,- pub request: RenderRequest,- /// Identifies the result for caching: hash of settings + request.- pub key: u64,- /// Rendered-thumbnail cache and this job's key in it.- pub cache: Option<(Arc<PreviewCache>, Hash128)>,- /// Intermediate results of this view's previous renders (set by the frontend for the loupe):- /// slider drags then only redo the stages the changed setting feeds.- pub stages: Option<Arc<StageCache>>,- /// Keep a full-quality result here as the photo's view preview ([`crate::Session::loupe_job`]).- pub view_cache: Option<(Arc<PreviewCache>, Hash128)>,- /// Render for this monitor profile ([`Self::with_display`]).- pub display: Option<Arc<crate::display::Display>>,- /// Compose the render into a slideshow slide ([`Self::with_slide`]).- pub slide: Option<Arc<crate::slide::SlideCompose>>,- /// A face tile that can be cut from the raw's embedded preview, tried before `source`- /// ([`crate::Session::face_job`]; `None` for every other job).- pub preview_cut: Option<crate::face_tiles::PreviewCut>,- /// Shrink a full-quality result to fit this size (physical pixels) with a Lanczos filter once- /// it is rendered. The loupe renders a little larger than it is drawn (its edge is rounded up- /// to a 64 px step) and the window would otherwise shrink the texture with 2-tap bilinear sampling, which blurs fine detail at- /// small ratios and aliases it at large ones. The caches keep the full render.- pub display_fit: Option<(usize, usize)>,-}--/// `img` shrunk to fit `max_w × max_h` with a Lanczos filter (see [`RenderJob::display_fit`]).-pub fn fit_for_display(img: &Rgba8, max_w: usize, max_h: usize) -> Rgba8 {- use lightcraft_raster::resample::{Filter, fit};- let f = lightcraft_raster::Image {- width: img.width,- height: img.height,- data: img.data.iter().map(|p| [f32::from(p[0]), f32::from(p[1]), f32::from(p[2]), f32::from(p[3])]).collect(),- };- let small = fit(&f, max_w.max(1), max_h.max(1), Filter::Lanczos3);- let c = |v: f32| v.round().clamp(0.0, 255.0) as u8;- Rgba8 { width: small.width, height: small.height, data: small.data.iter().map(|p| [c(p[0]), c(p[1]), c(p[2]), c(p[3])]).collect() }-}--pub struct RenderResult {- pub request_id: u64,- pub source_key: Option<Hash128>,- pub photo: PhotoId,- pub level: SourceLevel,- pub key: u64,- pub rendered: Result<Rendered, String>,- /// Set when this job's render was tried on the GPU and fell back to the CPU: why- /// ([`lightcraft_gpu::Fallback::Failed`]). The result is the CPU render either way.- pub gpu_fallback: Option<String>,- /// A source that was loaded by this job (to be inserted into the cache).- pub loaded: Option<DecodedSource>,- /// Set for a [`QuickJob`]'s stand-in: where the image came from.- pub quick: Option<QuickSource>,- /// The display profile (id) the image is encoded for; `None`: sRGB (see- /// [`crate::display::present`]).- pub display: Option<u64>,-}--impl RenderJob {- /// Render at draft quality (interactive drags). Gets its own result key.- /// Shrink the full-quality result to fit `w × h` pixels with a Lanczos filter (see- /// [`Self::display_fit`]). Gets its own result key, so a change of drawn size renders again.- pub fn with_display_fit(mut self, w: usize, h: usize) -> Self {- self.display_fit = Some((w, h));- self.key ^= ((w as u64) << 32 | h as u64).wrapping_mul(0x9e37_79b9_7f4a_7c15);- self- }-- pub fn draft(mut self) -> Self {- if self.request.quality != Quality::Draft {- self.request.quality = Quality::Draft;- self.key ^= 0x9e37_79b9_7f4a_7c15;- }- self- }-- /// Draw a diagnostic overlay over the result (e.g. Point Color's visualized range). Gets its- /// own result key.- pub fn with_overlay(mut self, overlay: lightcraft_pipeline::Overlay) -> Self {- if self.request.overlay != overlay {- self.key ^= self.request.overlay.key().wrapping_mul(0x9e37_79b9_7f4a_7c15);- self.request.overlay = overlay;- self.key ^= overlay.key().wrapping_mul(0x9e37_79b9_7f4a_7c15);- }- // a diagnostic view (visualized range / spots) must never become the photo's cached preview- if overlay != lightcraft_pipeline::Overlay::None {- self.view_cache = None;- }- self- }-- /// Soft-proof the result (see [`lightcraft_pipeline::Proof`]). Gets its own result key and is- /// never kept as the photo's cached preview.- pub fn with_proof(mut self, proof: Option<lightcraft_pipeline::Proof>) -> Self {- if self.request.proof != proof {- let k = |p: Option<lightcraft_pipeline::Proof>| p.map_or(0, |p| p.key()).wrapping_mul(0xc2b2_ae3d_27d4_eb4f);- self.key ^= k(self.request.proof) ^ k(proof);- self.request.proof = proof;- }- if proof.is_some() {- self.view_cache = None;- }- self- }-- /// Render with some colour grading wheels (shadows, midtones, highlights) switched off for- /// viewing (the wheel eyes in the Edit panel). The photo's settings are untouched; the result- /// gets its own key and is never cached as the photo's preview or thumbnail.- pub fn with_hidden_grading(mut self, hidden: [bool; 3]) -> Self {- if !hidden.iter().any(|h| *h) {- return self;- }- let mut s = (*self.settings).clone();- let g = &mut s.grading;- for (off, wheel) in hidden.into_iter().zip([&mut g.shadows, &mut g.midtones, &mut g.highlights]) {- if off {- *wheel = lightcraft_develop::Wheel::default();- }- }- let bits = hidden.iter().enumerate().fold(0u64, |b, (i, h)| b | ((*h as u64) << i));- self.key ^= s.hash64() ^ self.settings.hash64() ^ bits.wrapping_mul(0xd6e8_feb8_6659_fd93);- self.settings = Arc::new(s);- self.cache = None;- self.view_cache = None;- self.preview_cut = None;- self- }-- /// Reuse `stages` across this view's renders.- pub fn with_stages(mut self, stages: Arc<StageCache>) -> Self {- self.stages = Some(stages);- self- }-- /// Render for a monitor profile: into the display's primaries (its gamut, not sRGB's), ready- /// to show ([`RenderResult::display`]). The histogram and the cached view preview stay sRGB.- /// Gets its own result key. Thumbnail jobs (rendered-thumbnail cache) are left as they are:- /// [`crate::display::present`] converts their sRGB results.- pub fn with_display(mut self, display: Option<Arc<crate::display::Display>>) -> Self {- // (a slide is composed in sRGB, backdrop colours included; the frontend presents it)- if self.cache.is_some() || self.slide.is_some() || self.request.depth != lightcraft_pipeline::OutputDepth::U8 {- return self;- }- let k = |d: &Option<Arc<crate::display::Display>>| d.as_ref().map_or(0, |d| d.id()).wrapping_mul(0xd6e8_feb8_6659_fd93);- self.key ^= k(&self.display) ^ k(&display);- self.request.display = display.as_ref().map(|d| d.space);- self.display = display;- self- }-- /// Render. A panic inside (a decoder or pipeline bug) is this job's failure: the view waiting- /// for it is told, instead of waiting forever on a worker that died (the pool doesn't replace- /// it, so a few such panics used to stop every render).- pub fn run(self) -> RenderResult {- let failed = self.failed(String::new());- crate::guard::catch("the render", || self.run_unguarded()).unwrap_or_else(|e| RenderResult { rendered: Err(e), ..failed })- }-- /// This job's result when it fails with `e`.- fn failed(&self, e: String) -> RenderResult {- RenderResult {- request_id: self.request_id,- source_key: self.source_key,- photo: self.photo,- level: self.level,- key: self.key,- rendered: Err(e),- gpu_fallback: None,- loaded: None,- quick: None,- display: None,- }- }-- /// Compose the render into a slideshow slide (layout, options, backdrop): the result is the- /// slide, not the photo. Gets its own result key; the photo's cached view preview stays the- /// photo. The slide stays sRGB ([`Self::with_display`] leaves it alone).- pub fn with_slide(mut self, slide: Arc<crate::slide::SlideCompose>) -> Self {- let k = |s: &Option<Arc<crate::slide::SlideCompose>>| s.as_ref().map_or(0, |s| s.key()).wrapping_mul(0xa24b_aed4_963e_e407);- self.key ^= k(&self.slide);- self.key ^= k(&Some(slide.clone()));- self.slide = Some(slide);- self- }-- /// [`Self::run_photo`], composed into its slide when this is a slide job (inside [`Self::run`]'s guard).- fn run_unguarded(self) -> RenderResult {- let slide = self.slide.clone();- let mut r = self.run_photo();- if let (Some(slide), Ok(rendered)) = (slide, r.rendered.as_mut()) {- rendered.image = slide.compose(&rendered.image);- rendered.deep = None;- }- r- }-- /// The photo's render (without slide composition).- fn run_photo(self) -> RenderResult {- if let Some((cache, key)) = &self.cache- && let Some(img) = cache.get_at(self.cache_generation, *key)- {- let image = Arc::unwrap_or_clone(img);- let histogram = Histogram::of_srgb8(&image);- return RenderResult {- request_id: self.request_id,- source_key: self.source_key,- photo: self.photo,- level: self.level,- key: self.key,- rendered: Ok(Rendered { image, histogram, deep: None }),- gpu_fallback: None,- loaded: None,- quick: None,- display: None,- };- }- // a face tile of an unedited raw: cut from the camera's embedded preview when it is big enough- // (the sensor data is never read for it), else rendered from `source` below- if let Some(image) = self.preview_cut.as_ref().and_then(|c| c.cut()) {- if let Some((cache, key)) = &self.cache {- cache.put_at(self.cache_generation, *key, Arc::new(image.clone()));- }- let histogram = Histogram::of_srgb8(&image);- return RenderResult {- request_id: self.request_id,- source_key: self.source_key,- photo: self.photo,- level: self.level,- key: self.key,- rendered: Ok(Rendered { image, histogram, deep: None }),- gpu_fallback: None,- loaded: None,- quick: None,- display: None,- };- }- let was_loaded = matches!(self.source, SourceRef::Loaded(_));- // The app is closing (issue #620): nobody is left to show this, and quitting waits for the- // jobs that are running. Without this, one that lost the GPU mid-way would render on the CPU.- let closing = || lightcraft_gpu::shutting_down().then(|| "LightCraft is closing".to_string());- let source = match closing() {- Some(e) => Err(e),- None => self.source.load_source().and_then(|s| closing().map_or(Ok(s), Err)),- };- match source {- Ok(source) => {- // the plain picture, or (Denoise amount above 0 and a denoised picture cached) the mix the amount asks for- let src = &source.image_for(self.settings.denoise_amount());- let info = source.info_or(self.info);- // Thumbnails (many small jobs side by side) stay on the CPU; views and exports use- // the GPU when there is one.- let gpu = self.cache.is_none();- let (mut rendered, gpu_fallback) = develop_reporting(src, &info, &self.settings, &self.request, self.stages.as_deref(), gpu);- // for a display profile: the image goes to the display's values, the histogram- // and the cached view preview stay sRGB- let mut srgb = None;- let display = match (&self.display, self.request.display) {- (Some(d), Some(_)) => {- let keep = self.view_cache.is_some() && self.request.quality == Quality::Full;- let (s, h) = crate::display::finish_render(&mut rendered.image, d, keep);- // (an HDR edit's HDR histogram stays)- if let Some(h) = h.filter(|_| rendered.histogram.hdr.is_none()) {- rendered.histogram = h;- }- srgb = s;- Some(d.id())- }- _ => None,- };- if let Some((cache, key)) = &self.cache {- cache.put_at(self.cache_generation, *key, Arc::new(rendered.image.clone()));- }- if let Some((cache, key)) = &self.view_cache- && self.request.quality == Quality::Full- && (display.is_none() || srgb.is_some())- {- cache.put_deferred_at(self.cache_generation, *key, Arc::new(srgb.unwrap_or_else(|| rendered.image.clone())));- }- // the display fit, after the caches have the full render- if let Some((fw, fh)) = self.display_fit- && self.request.quality == Quality::Full- {- let (w, h) = (rendered.image.width, rendered.image.height);- if w > fw.max(1) || h > fh.max(1) {- rendered.image = fit_for_display(&rendered.image, fw, fh);- }- }- RenderResult {- request_id: self.request_id,- source_key: self.source_key,- photo: self.photo,- level: self.level,- key: self.key,- rendered: Ok(rendered),- gpu_fallback,- loaded: (!was_loaded).then_some(source),- quick: None,- display,- }- }- Err(e) => self.failed(e),- }- }-}--/// Render `src`: on the GPU when `gpu` is set and a GPU is available (`lightcraft_gpu`), else on-/// the CPU, reusing `stages` either way. Both produce the same image within 1–3 LSB (see-/// `docs/gpu-pipeline.md`); `LIGHTCRAFT_GPU=0` or [`lightcraft_gpu::set_enabled`] forces the CPU.-pub fn develop(src: &Arc<Rgb32f>, info: &SourceInfo, s: &DevelopSettings, req: &RenderRequest, stages: Option<&StageCache>, gpu: bool) -> Rendered {- develop_reporting(src, info, s, req, stages, gpu).0-}--/// [`develop`], also saying why the render fell back from the GPU to the CPU when it did (`None`:-/// it rendered on the GPU, or the GPU was not tried). The reason is this render's own, not the-/// process-wide [`lightcraft_gpu::last_fallback`].-pub fn develop_reporting(- src: &Arc<Rgb32f>,- info: &SourceInfo,- s: &DevelopSettings,- req: &RenderRequest,- stages: Option<&StageCache>,- gpu: bool,-) -> (Rendered, Option<String>) {- let (mut rendered, fallback) = develop_image(src, info, s, req, stages, gpu);- // an HDR edit's preview is its SDR rendition: its histogram shows the HDR range instead- if let Some(h) = lightcraft_pipeline::hdr_histogram(src, info, s, req) {- rendered.histogram = h;- }- (rendered, fallback)-}--fn develop_image(- src: &Arc<Rgb32f>,- info: &SourceInfo,- s: &DevelopSettings,- req: &RenderRequest,- stages: Option<&StageCache>,- gpu: bool,-) -> (Rendered, Option<String>) {- // LUT profiles have no GPU stage: they render on the CPU- let fallback = if gpu- && !lightcraft_pipeline::lut::is_lut_profile(&s.profile.id)- && !s.masks.iter().any(|m| m.visible && m.refine > 0.0)- && req.proof.is_none()- {- match lightcraft_gpu::try_render(src, info, s, req, stages) {- Ok(r) => return (r, None),- Err(lightcraft_gpu::Fallback::Failed(why)) => Some(why),- Err(lightcraft_gpu::Fallback::NotTried) => None,- }- } else {- None- };- let rendered = match stages {- Some(st) => lightcraft_pipeline::render_cached(src, info, s, req, st),- None => lightcraft_pipeline::render(src, info, s, req),- };- (rendered, fallback)-}--/// Where a [`QuickJob`]'s stand-in image came from.-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]-#[serde(rename_all = "camelCase")]-pub enum QuickSource {- /// The photo's own develop render for its current settings (cached view or thumbnail render).- Cached,- /// The camera's embedded JPEG (unedited raws).- Embedded,- /// A thumbnail-level develop render made for the occasion.- Small,-}--/// Something to show *now* for a photo while its real render is prepared. Tried in order: cached-/// renders, the embedded preview of an unedited raw, a thumbnail-level render.-#[derive(Clone)]-pub struct QuickJob {- pub request_id: u64,- pub photo: PhotoId,- pub key: u64,- /// Cached renders to try first, in order: (cache, key).- pub cached: Vec<(Arc<PreviewCache>, Hash128)>,- /// Embedded preview of an unedited raw: (path, loader, max edge).- pub embedded: Option<(String, PreviewLoader, usize)>,- /// Last resort: run this thumbnail job.- pub small: Option<Box<RenderJob>>,-}--impl QuickJob {- /// The stand-in, from the first source that has one. A panic inside is this job's failure- /// (see [`RenderJob::run`]).- pub fn run(self) -> RenderResult {- let (request_id, photo, key) = (self.request_id, self.photo, self.key);- crate::guard::catch("the render", || self.run_unguarded()).unwrap_or_else(|e| RenderResult {- request_id,- source_key: None,- photo,- level: SourceLevel::Thumb,- key,- rendered: Err(e),- gpu_fallback: None,- loaded: None,- quick: None,- display: None,- })- }-- fn run_unguarded(self) -> RenderResult {- let (photo, key) = (self.photo, self.key);- let request_id = self.request_id;- let done = |rendered: Result<Rendered, String>, quick| RenderResult {- request_id,- source_key: None,- photo,- level: SourceLevel::Thumb,- key,- rendered,- gpu_fallback: None,- loaded: None,- quick,- display: None,- };- let rendered = |image: Rgba8| {- let histogram = Histogram::of_srgb8(&image);- Ok(Rendered { image, histogram, deep: None })- };- for (cache, k) in &self.cached {- if let Some(img) = cache.get(*k) {- return done(rendered(Arc::unwrap_or_clone(img)), Some(QuickSource::Cached));- }- }- if let Some((path, loader, edge)) = &self.embedded- && let Some(image) = loader(path, *edge)- {- return done(rendered(image), Some(QuickSource::Embedded));- }- if let Some(job) = self.small {- let r = job.run();- return RenderResult { request_id, key, quick: Some(QuickSource::Small), ..r };- }- done(Err("no quick preview".into()), None)- }-}--/// What identifies a photo's pixels for caching: its content hash, else its source.-pub fn content_key(p: &Photo) -> String {- match (&p.content_hash, &p.source) {- (Some(h), _) => h.clone(),- (None, Source::Demo { scene }) => format!("demo:{scene}"),- (None, Source::File { path }) => format!("file:{path}:{}", p.file_size),- }-}--pub fn source_info(p: &Photo) -> SourceInfo {- // Procedural demo scenes are scene-referred HDR (like raw files): use the filmic tone map.- // (They are drawn afresh at every size, so they have no original size.)- if matches!(p.source, Source::Demo { .. }) {- return SourceInfo { raw: true, ..Default::default() };- }- // the thumbnail and preview levels are smaller copies: noise reduction works in the original's pixels (#960)- let native_long = Some(p.width.max(p.height) as usize).filter(|&n| n > 0);- SourceInfo { native_long, ..header_info(p) }-}--fn header_info(p: &Photo) -> SourceInfo {- // A raw shown from its embedded preview is a rendered (display-referred) JPEG: relative white- // balance and the display tone curve, like any other rendered file.- if p.develops_raw() {- let relative = p.relative_wb();- let (temp, tint) = if relative { (6500.0, 0.0) } else { p.as_shot_wb.unwrap_or((5500.0, 0.0)) };- SourceInfo {- raw: true,- as_shot_temp: temp,- as_shot_tint: tint,- lens: p.embedded_lens,- relative_wb: relative,- // (a fitted-look raw edited in Kelvin: its camera's matrices give the scale, see `files::WbScaleOf`)- legacy_relative_wb: p.fitted_look() && !relative,- ..Default::default()- }- } else {- SourceInfo::default()- }-}--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> {- 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> {- 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)- }-}--/// What an import learns from a file header (set by the app from `lightcraft-codecs`/`-raw`).-#[derive(Clone, Debug, Default)]-pub struct ProbeInfo {- pub width: u32,- pub height: u32,- pub format: String,- pub kind: MediaKind,- pub file_size: u64,- pub captured: Option<String>,- /// The file's modification time (ISO 8601, the clock of [`crate::import::system_clock`]): the- /// capture date of a file whose metadata has none, as Lightroom does (exports saved without- /// metadata would otherwise all land under "Unknown Date").- pub file_modified: Option<String>,- pub meta: lightcraft_catalog::Meta,- pub as_shot_wb: Option<(f64, f64)>,- /// Hash of the file's bytes (hex), for duplicate detection. When it is a 32-digit- /// [`lightcraft_preview::hash_bytes`] of the whole file (as the native probe computes it),- /// Import → Copy verifies each copy against it instead of reading the source again.- pub content_hash: Option<String>,- /// Lens corrections embedded in the file (DNG opcodes).- pub embedded_lens: Option<lightcraft_develop::EmbeddedLens>,- /// The file's embedded XMP packet (raw/DNG files), for develop settings stored inside the file.- pub xmp: Option<String>,- /// A raw variant that can't be decoded yet: why. The file is described (and will be shown and- /// edited) from its embedded preview; see [`lightcraft_catalog::Photo::preview_only`].- pub preview_only: Option<String>,-}--pub type FileProbe = Arc<dyn Fn(&str) -> Result<ProbeInfo, String> + Send + Sync>;-#[cfg(test)]mod thumbnail_hash_tests;diff --git a/crates/engine/src/media/cache.rs b/crates/engine/src/media/cache.rsnew file mode 100644index 000000000..c3d323e38--- /dev/null+++ b/crates/engine/src/media/cache.rs@@ -0,0 +1,365 @@+use super::settings_hash::SettingsHashes;+use super::source::{DecodedSource, DenoiseSpec, PairLoader, RENDERED_MEM_BYTES, SourceLevel, SourceRef, THUMB_SOURCE_BYTES};+use super::*;++/// The photos that have a cached denoised picture for the denoise model in use. Only memory: nothing here touches the+/// file system, so it can be asked on the UI thread.+#[derive(Default)]+pub struct DenoiseIndex {+ ready: std::collections::HashMap<PhotoId, DenoiseSpec>,+ /// Reads the pictures (`None`: this build cannot, and nothing is ever ready).+ pub loader: Option<PairLoader>,+}++impl DenoiseIndex {+ /// What to load for `id` besides its plain picture, and how.+ pub fn get(&self, id: PhotoId) -> Option<(&DenoiseSpec, &PairLoader)> {+ self.ready.get(&id).zip(self.loader.as_ref())+ }++ pub fn spec(&self, id: PhotoId) -> Option<&DenoiseSpec> {+ self.ready.get(&id)+ }++ pub fn set(&mut self, id: PhotoId, spec: DenoiseSpec) {+ self.ready.insert(id, spec);+ }++ pub fn remove(&mut self, id: PhotoId) -> bool {+ self.ready.remove(&id).is_some()+ }++ pub fn clear(&mut self) {+ self.ready.clear();+ }++ pub fn len(&self) -> usize {+ self.ready.len()+ }++ pub fn is_empty(&self) -> bool {+ self.ready.is_empty()+ }++ pub fn ids(&self) -> Vec<PhotoId> {+ let mut v: Vec<PhotoId> = self.ready.keys().copied().collect();+ v.sort();+ v+ }+}++impl Default for MediaCache {+ fn default() -> Self {+ let budget = crate::memory::cache_share(crate::memory::budget());+ MediaCache {+ settings_hashes: SettingsHashes::default(),+ thumbs: Lru::new(THUMB_SOURCE_BYTES.min(budget)),+ previews: Vec::new(),+ full: Vec::new(),+ full_capacity: 1,+ on_screen: None,+ preview_capacity: 0,+ budget,+ file_loader: None,+ reduced_loader: None,+ file_probe: None,+ preview_loader: None,+ file_bytes: None,+ smart_dir: None,+ availability: Default::default(),+ scenes: Vec::new(),+ rendered: Arc::new(PreviewCache::memory(rendered_budget(budget))),+ denoise: DenoiseIndex::default(),+ }+ }+}++/// Memory for rendered previews out of the cache share.+fn rendered_budget(share: usize) -> usize {+ RENDERED_MEM_BYTES.min(share / 4)+}++impl MediaCache {+ /// Keep rendered thumbnails on disk in `dir` as well. The cache this replaces is retired+ /// (its files stay): render jobs still holding it can't write through it any more, even+ /// into a directory a later clear emptied (`dir` may be the same one).+ pub fn attach_disk_cache(&mut self, dir: &std::path::Path, disk_bytes: u64) {+ self.rendered.retire();+ self.rendered = Arc::new(PreviewCache::with_disk(rendered_budget(self.budget), dir, disk_bytes));+ }++ /// Change the disk budget of the cache in `dir`: in place when that cache is attached (its+ /// thumbnails are keyed by content, so they and the textures shown from them stay valid,+ /// and the same cache object keeps its generation), else attach it.+ pub fn set_disk_cache_bytes(&mut self, dir: &std::path::Path, disk_bytes: u64) {+ match self.rendered.disk().filter(|d| d.dir() == dir) {+ Some(d) => d.set_budget(disk_bytes),+ None => self.attach_disk_cache(dir, disk_bytes),+ }+ }++ /// Forget every decoded source (photo ids changed meaning, e.g. another library was opened).+ pub fn clear_sources(&mut self) {+ self.settings_hashes = SettingsHashes::default();+ self.thumbs = Lru::new(THUMB_SOURCE_BYTES.min(self.budget));+ self.previews.clear();+ self.full.clear();+ }++ /// How many full-resolution originals to keep at once (at least one). Compare and Reference+ /// views zoomed to 1:1 cut windows from two photos' originals: with room for one, every window+ /// render of one side would evict the other side's original and decode its own again. Lowering+ /// it drops the least recently used originals at once.+ pub fn set_full_capacity(&mut self, n: usize) {+ self.full_capacity = n.max(1);+ self.trim_full();+ }++ /// The photo the loupe shows (the frontend sets it every frame; `None` in other views). Its original stays+ /// even over budget: a 64 MP original (797 MB as linear float) alone exceeds the default share, and evicting it+ /// made every pan of a zoomed view decode the raw again. Showing another photo lets it go at once.+ pub fn set_on_screen(&mut self, id: Option<PhotoId>) {+ if self.on_screen != id {+ self.on_screen = id;+ self.enforce_budget();+ }+ }++ fn trim_full(&mut self) {+ while self.full.len() > self.full_capacity {+ let oldest = self.full.iter().enumerate().min_by_key(|(_, e)| e.2).map(|(i, _)| i).unwrap_or(0);+ self.full.remove(oldest);+ }+ }++ /// Bytes the caches may hold together.+ pub fn budget(&self) -> usize {+ self.budget+ }++ /// Change the bytes the caches may hold together, evicting at once if needed.+ pub fn set_budget(&mut self, bytes: usize) {+ self.budget = bytes;+ self.thumbs.set_budget(THUMB_SOURCE_BYTES.min(bytes));+ self.rendered.set_mem_budget(rendered_budget(bytes));+ self.enforce_budget();+ }++ /// Bytes held by decoded sources and rendered previews in memory.+ pub fn held(&self) -> usize {+ let (t, p, f) = self.usage();+ t.bytes + p.bytes + f.bytes + self.rendered.mem_usage().1+ }++ /// Evict least recently used entries across the source caches and the rendered previews+ /// until they fit the budget. The newest preview-level source (the photo on screen, or the+ /// one just decoded) is never evicted here, nor is the original of the photo on screen+ /// ([`Self::set_on_screen`]).+ pub fn enforce_budget(&mut self) {+ // The on-screen original is never evicted here, so it does not count either: counted, a 64 MP original (760 MiB)+ // nearly fills the default share (768 MiB) alone and everything else went instead — the photo's preview and+ // thumbnail sources and the neighbours' were decoded again from the raw on every edit, zoom-out and step.+ let pinned: usize = self.full.iter().filter(|e| Some(e.0) == self.on_screen).map(|e| e.1.bytes()).sum();+ let mut held = self.held().saturating_sub(pinned);+ while held > self.budget {+ let newest_preview = self.previews.iter().map(|e| e.2).max();+ let candidates = [+ self.thumbs.oldest_tick().map(|t| (t, 0)),+ self.previews.iter().filter(|e| Some(e.2) != newest_preview).map(|e| e.2).min().map(|t| (t, 1)),+ self.full.iter().filter(|e| Some(e.0) != self.on_screen).map(|e| e.2).min().map(|t| (t, 2)),+ self.rendered.oldest_tick().map(|t| (t, 3)),+ ];+ let Some((tick, which)) = candidates.into_iter().flatten().min() else { break };+ let freed = match which {+ 0 => self.thumbs.pop_oldest(),+ 1 => self.previews.iter().position(|e| e.2 == tick).map(|i| self.previews.remove(i).1.bytes()),+ 2 => self.full.iter().position(|e| e.2 == tick).map(|i| self.full.remove(i).1.bytes()),+ _ => self.rendered.evict_oldest(),+ };+ match freed {+ Some(b) if b > 0 => held = held.saturating_sub(b),+ _ => break,+ }+ }+ }++ pub fn get(&mut self, id: PhotoId, level: SourceLevel) -> Option<Arc<Rgb32f>> {+ self.get_source(id, level).map(|s| s.image)+ }++ pub(super) fn get_source(&mut self, id: PhotoId, level: SourceLevel) -> Option<DecodedSource> {+ match level {+ SourceLevel::Thumb => self.thumbs.get(&id).cloned(),+ SourceLevel::Preview => self.previews.iter_mut().find(|e| e.0 == id).map(|e| {+ e.2 = lightcraft_preview::next_tick();+ e.1.clone()+ }),+ SourceLevel::Full => self.full.iter_mut().find(|e| e.0 == id).map(|e| {+ e.2 = lightcraft_preview::next_tick();+ e.1.clone()+ }),+ }+ }++ /// The facts of photo `id`'s cached sources: the decoder's when one has them, else `header`+ /// (with a smart preview's stored camera tone curve).+ pub(super) fn source_facts(&self, id: PhotoId, header: SourceInfo) -> SourceInfo {+ let cached = || {+ self.thumbs+ .peek(&id)+ .into_iter()+ .chain(self.previews.iter().filter(|e| e.0 == id).map(|e| &e.1))+ .chain(self.full.iter().filter(|e| e.0 == id).map(|e| &e.1))+ };+ match cached().find(|s| s.info.is_some()).or_else(|| cached().next()) {+ Some(s) => s.info_or(header),+ None => header,+ }+ }++ pub fn insert(&mut self, id: PhotoId, level: SourceLevel, img: Arc<Rgb32f>) {+ self.insert_source(id, level, DecodedSource::new(img, None));+ }++ pub(super) fn insert_source(&mut self, id: PhotoId, level: SourceLevel, img: DecodedSource) {+ let tick = lightcraft_preview::next_tick();+ match level {+ SourceLevel::Thumb => {+ let cost = img.bytes();+ self.thumbs.insert(id, img, cost);+ }+ SourceLevel::Preview => {+ self.previews.retain(|e| e.0 != id);+ self.previews.push((id, img, tick));+ let cap = if self.preview_capacity == 0 { 4 } else { self.preview_capacity };+ while self.previews.len() > cap {+ let oldest = self.previews.iter().enumerate().min_by_key(|(_, e)| e.2).map(|(i, _)| i).unwrap_or(0);+ self.previews.remove(oldest);+ }+ }+ SourceLevel::Full => {+ self.full.retain(|e| e.0 != id);+ self.full.push((id, img, tick));+ self.trim_full();+ }+ }+ self.enforce_budget();+ }++ /// Forget a photo's decoded sources (e.g. after its file changed).+ pub fn forget(&mut self, id: PhotoId) {+ self.thumbs.remove(&id);+ self.previews.retain(|e| e.0 != id);+ self.full.retain(|e| e.0 != id);+ }++ /// (decoded thumbnail sources, bytes).+ pub fn source_usage(&self) -> (usize, usize) {+ (self.thumbs.len(), self.thumbs.cost())+ }++ /// Whether the decoded source of `id` at `level` is held.+ pub fn has_source(&self, id: PhotoId, level: SourceLevel) -> bool {+ match level {+ SourceLevel::Thumb => self.thumbs.contains(&id),+ SourceLevel::Preview => self.previews.iter().any(|e| e.0 == id),+ SourceLevel::Full => self.full.iter().any(|e| e.0 == id),+ }+ }++ /// Decoded sources held: (thumbnail level, preview level, full size).+ pub fn usage(&self) -> (crate::memory::Usage, crate::memory::Usage, crate::memory::Usage) {+ use crate::memory::Usage;+ let previews = Usage::new(self.previews.len(), self.previews.iter().map(|e| e.1.bytes()).sum());+ let full = Usage::new(self.full.len(), self.full.iter().map(|e| e.1.bytes()).sum());+ (Usage::new(self.thumbs.len(), self.thumbs.cost()), previews, full)+ }++ /// What a render of photo `id` with settings `s` adds to its identity for the denoised picture it will use: 0 unless+ /// it uses one (the Denoise amount is above 0 and the photo has a cached denoised picture).+ pub fn denoise_salt(&self, id: PhotoId, s: &DevelopSettings) -> u64 {+ match self.denoise.spec(id) {+ Some(spec) if s.denoise_amount() > 0.0 => Hasher128::new().str(&spec.key).finish().0 as u64 | 1,+ _ => 0,+ }+ }++ /// How to load photo `p` at `level`: from the cache when its source is there, else from its file (with its denoised+ /// picture beside it when it has one), its smart preview or the demo scene.+ pub fn source_ref(&mut self, p: &Photo, level: SourceLevel) -> SourceRef {+ self.source_ref_with(p, level, true)+ }++ /// [`Self::source_ref`] that never takes a decoded source from memory: for a job that needs something the cached+ /// one lacks (an export, whose denoised picture is made when it runs).+ pub fn source_ref_uncached(&mut self, p: &Photo, level: SourceLevel) -> SourceRef {+ self.source_ref_with(p, level, false)+ }++ fn source_ref_with(&mut self, p: &Photo, level: SourceLevel, cached: bool) -> SourceRef {+ let mut r = self.source_ref_plain(p, level, cached);+ if let (SourceRef::File { denoise, .. }, Some((spec, loader))) = (&mut r, self.denoise.get(p.id)) {+ *denoise = Some((spec.clone(), loader.clone()));+ }+ r+ }++ fn source_ref_plain(&mut self, p: &Photo, level: SourceLevel, cached: bool) -> SourceRef {+ if cached && let Some(a) = self.get_source(p.id, level) {+ return SourceRef::Loaded(Box::new(a));+ }+ // a thumbnail of a photo whose preview is decoded (the one in the loupe) is cut from it; not+ // with a denoised picture, which the thumbnail would lose+ if cached+ && level == SourceLevel::Thumb+ && self.denoise.spec(p.id).is_none()+ && let Some(big) = self.get_source(p.id, SourceLevel::Preview)+ {+ return SourceRef::Fit { from: Box::new(big), max_edge: level.max_edge() };+ }+ // Procedural scenes have a nominal size: "full" is that size, not unbounded.+ let max_edge = level.max_edge().min(match (&p.source, level) {+ (Source::Demo { .. }, SourceLevel::Full) => p.width.max(p.height).max(1) as usize,+ _ => usize::MAX,+ });+ // the original is offline: its smart preview, when there is one. Only cached answers are+ // used here (no file-system call on the UI thread in the app); an original not known to+ // be offline is tried first and its smart preview is the render worker's fallback.+ #[cfg(not(target_arch = "wasm32"))]+ if let (Source::File { path }, Some(dir)) = (&p.source, &self.smart_dir) {+ let sharded = crate::smart::sharded_file_path(dir, p);+ let legacy = dir.join(crate::smart::file_name(p));+ let sp = if self.availability.exists(&sharded.to_string_lossy()) == Some(true) { sharded } else { legacy };+ // (a proxy cut short fails to load, like the offline original; the worker's fallback+ // in `SourceRef::load` only uses a proxy that passes `smart::is_valid`)+ if self.availability.is_offline(path) && self.availability.exists(&sp.to_string_lossy()) == Some(true) {+ return SourceRef::Smart { path: sp };+ }+ let mut r = self.origin_ref(&p.source, max_edge);+ if let SourceRef::File { fallback, .. } = &mut r {+ *fallback = Some(sp);+ }+ return r;+ }+ self.origin_ref(&p.source, max_edge)+ }++ /// How to load `origin` at most `max_edge` pixels long, ignoring decoded sources in memory (a+ /// render worker in another wasm instance builds its sources from this).+ pub fn origin_ref(&mut self, origin: &Source, max_edge: usize) -> SourceRef {+ match origin {+ Source::Demo { scene } => {+ if self.scenes.is_empty() {+ self.scenes = lightcraft_scenes::demo_library();+ }+ match self.scenes.iter().find(|s| s.id == *scene) {+ Some(s) => SourceRef::Demo { scene: Box::new(s.clone()), max_edge },+ None => SourceRef::File { path: format!("demo:{scene}"), max_edge, loader: None, fallback: None, denoise: None, reduced: None },+ }+ }+ Source::File { path } => {+ SourceRef::File { path: path.clone(), max_edge, loader: self.file_loader.clone(), fallback: None, denoise: None, reduced: None }+ }+ }+ }+}diff --git a/crates/engine/src/media/quick.rs b/crates/engine/src/media/quick.rsnew file mode 100644index 000000000..6098ed4dd--- /dev/null+++ b/crates/engine/src/media/quick.rs@@ -0,0 +1,127 @@+use super::render::{RenderJob, RenderResult};+use super::source::{PreviewLoader, SourceLevel};+use super::*;++/// Where a [`QuickJob`]'s stand-in image came from.+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub enum QuickSource {+ /// The photo's own develop render for its current settings (cached view or thumbnail render).+ Cached,+ /// The camera's embedded JPEG (unedited raws).+ Embedded,+ /// A thumbnail-level develop render made for the occasion.+ Small,+}++/// Something to show *now* for a photo while its real render is prepared. Tried in order: cached+/// renders, the embedded preview of an unedited raw, a thumbnail-level render.+#[derive(Clone)]+pub struct QuickJob {+ pub request_id: u64,+ pub photo: PhotoId,+ pub key: u64,+ /// Cached renders to try first, in order: (cache, key).+ pub cached: Vec<(Arc<PreviewCache>, Hash128)>,+ /// Embedded preview of an unedited raw: (path, loader, max edge).+ pub embedded: Option<(String, PreviewLoader, usize)>,+ /// Last resort: run this thumbnail job.+ pub small: Option<Box<RenderJob>>,+}++impl QuickJob {+ /// The stand-in, from the first source that has one. A panic inside is this job's failure+ /// (see [`RenderJob::run`]).+ pub fn run(self) -> RenderResult {+ let (request_id, photo, key) = (self.request_id, self.photo, self.key);+ crate::guard::catch("the render", || self.run_unguarded()).unwrap_or_else(|e| RenderResult {+ request_id,+ source_key: None,+ photo,+ level: SourceLevel::Thumb,+ key,+ rendered: Err(e),+ gpu_fallback: None,+ loaded: None,+ quick: None,+ display: None,+ })+ }++ fn run_unguarded(self) -> RenderResult {+ let (photo, key) = (self.photo, self.key);+ let request_id = self.request_id;+ let done = |rendered: Result<Rendered, String>, quick| RenderResult {+ request_id,+ source_key: None,+ photo,+ level: SourceLevel::Thumb,+ key,+ rendered,+ gpu_fallback: None,+ loaded: None,+ quick,+ display: None,+ };+ let rendered = |image: Rgba8| {+ let histogram = Histogram::of_srgb8(&image);+ Ok(Rendered { image, histogram, deep: None })+ };+ for (cache, k) in &self.cached {+ if let Some(img) = cache.get(*k) {+ return done(rendered(Arc::unwrap_or_clone(img)), Some(QuickSource::Cached));+ }+ }+ if let Some((path, loader, edge)) = &self.embedded+ && let Some(image) = loader(path, *edge)+ {+ return done(rendered(image), Some(QuickSource::Embedded));+ }+ if let Some(job) = self.small {+ let r = job.run();+ return RenderResult { request_id, key, quick: Some(QuickSource::Small), ..r };+ }+ done(Err("no quick preview".into()), None)+ }+}++/// What identifies a photo's pixels for caching: its content hash, else its source.+pub fn content_key(p: &Photo) -> String {+ match (&p.content_hash, &p.source) {+ (Some(h), _) => h.clone(),+ (None, Source::Demo { scene }) => format!("demo:{scene}"),+ (None, Source::File { path }) => format!("file:{path}:{}", p.file_size),+ }+}++pub fn source_info(p: &Photo) -> SourceInfo {+ // Procedural demo scenes are scene-referred HDR (like raw files): use the filmic tone map.+ // (They are drawn afresh at every size, so they have no original size.)+ if matches!(p.source, Source::Demo { .. }) {+ return SourceInfo { raw: true, ..Default::default() };+ }+ // the thumbnail and preview levels are smaller copies: noise reduction works in the original's pixels (#960)+ let native_long = Some(p.width.max(p.height) as usize).filter(|&n| n > 0);+ SourceInfo { native_long, ..header_info(p) }+}++fn header_info(p: &Photo) -> SourceInfo {+ // A raw shown from its embedded preview is a rendered (display-referred) JPEG: relative white+ // balance and the display tone curve, like any other rendered file.+ if p.develops_raw() {+ let relative = p.relative_wb();+ let (temp, tint) = if relative { (6500.0, 0.0) } else { p.as_shot_wb.unwrap_or((5500.0, 0.0)) };+ SourceInfo {+ raw: true,+ as_shot_temp: temp,+ as_shot_tint: tint,+ lens: p.embedded_lens,+ relative_wb: relative,+ // (a fitted-look raw edited in Kelvin: its camera's matrices give the scale, see `files::WbScaleOf`)+ legacy_relative_wb: p.fitted_look() && !relative,+ ..Default::default()+ }+ } else {+ SourceInfo::default()+ }+}diff --git a/crates/engine/src/media/render.rs b/crates/engine/src/media/render.rsnew file mode 100644index 000000000..1192a98e0--- /dev/null+++ b/crates/engine/src/media/render.rs@@ -0,0 +1,377 @@+use super::quick::QuickSource;+use super::source::{DecodedSource, SourceLevel, SourceRef};+use super::*;++/// Everything needed to render one photo, detached from the session.+#[derive(Clone)]+pub struct RenderJob {+ /// Assigned by a frontend to distinguish late completions, even for an identical render key.+ pub request_id: u64,+ pub cache_generation: u64,+ /// Content identity for validating a decoded source returned after a reload.+ pub source_key: Option<Hash128>,+ pub photo: PhotoId,+ pub level: SourceLevel,+ pub source: SourceRef,+ /// Where the photo's pixels come from (for executors that can't share `source`, e.g. a web+ /// worker).+ pub origin: Source,+ pub info: SourceInfo,+ pub settings: Arc<DevelopSettings>,+ pub request: RenderRequest,+ /// Identifies the result for caching: hash of settings + request.+ pub key: u64,+ /// Rendered-thumbnail cache and this job's key in it.+ pub cache: Option<(Arc<PreviewCache>, Hash128)>,+ /// Intermediate results of this view's previous renders (set by the frontend for the loupe):+ /// slider drags then only redo the stages the changed setting feeds.+ pub stages: Option<Arc<StageCache>>,+ /// Keep a full-quality result here as the photo's view preview ([`crate::Session::loupe_job`]).+ pub view_cache: Option<(Arc<PreviewCache>, Hash128)>,+ /// Render for this monitor profile ([`Self::with_display`]).+ pub display: Option<Arc<crate::display::Display>>,+ /// Compose the render into a slideshow slide ([`Self::with_slide`]).+ pub slide: Option<Arc<crate::slide::SlideCompose>>,+ /// A face tile that can be cut from the raw's embedded preview, tried before `source`+ /// ([`crate::Session::face_job`]; `None` for every other job).+ pub preview_cut: Option<crate::face_tiles::PreviewCut>,+ /// Shrink a full-quality result to fit this size (physical pixels) with a Lanczos filter once+ /// it is rendered. The loupe renders a little larger than it is drawn (its edge is rounded up+ /// to a 64 px step) and the window would otherwise shrink the texture with 2-tap bilinear sampling, which blurs fine detail at+ /// small ratios and aliases it at large ones. The caches keep the full render.+ pub display_fit: Option<(usize, usize)>,+}++/// `img` shrunk to fit `max_w × max_h` with a Lanczos filter (see [`RenderJob::display_fit`]).+pub fn fit_for_display(img: &Rgba8, max_w: usize, max_h: usize) -> Rgba8 {+ use lightcraft_raster::resample::{Filter, fit};+ let f = lightcraft_raster::Image {+ width: img.width,+ height: img.height,+ data: img.data.iter().map(|p| [f32::from(p[0]), f32::from(p[1]), f32::from(p[2]), f32::from(p[3])]).collect(),+ };+ let small = fit(&f, max_w.max(1), max_h.max(1), Filter::Lanczos3);+ let c = |v: f32| v.round().clamp(0.0, 255.0) as u8;+ Rgba8 { width: small.width, height: small.height, data: small.data.iter().map(|p| [c(p[0]), c(p[1]), c(p[2]), c(p[3])]).collect() }+}++pub struct RenderResult {+ pub request_id: u64,+ pub source_key: Option<Hash128>,+ pub photo: PhotoId,+ pub level: SourceLevel,+ pub key: u64,+ pub rendered: Result<Rendered, String>,+ /// Set when this job's render was tried on the GPU and fell back to the CPU: why+ /// ([`lightcraft_gpu::Fallback::Failed`]). The result is the CPU render either way.+ pub gpu_fallback: Option<String>,+ /// A source that was loaded by this job (to be inserted into the cache).+ pub loaded: Option<DecodedSource>,+ /// Set for a [`QuickJob`]'s stand-in: where the image came from.+ pub quick: Option<QuickSource>,+ /// The display profile (id) the image is encoded for; `None`: sRGB (see+ /// [`crate::display::present`]).+ pub display: Option<u64>,+}++impl RenderJob {+ /// Render at draft quality (interactive drags). Gets its own result key.+ /// Shrink the full-quality result to fit `w × h` pixels with a Lanczos filter (see+ /// [`Self::display_fit`]). Gets its own result key, so a change of drawn size renders again.+ pub fn with_display_fit(mut self, w: usize, h: usize) -> Self {+ self.display_fit = Some((w, h));+ self.key ^= ((w as u64) << 32 | h as u64).wrapping_mul(0x9e37_79b9_7f4a_7c15);+ self+ }++ pub fn draft(mut self) -> Self {+ if self.request.quality != Quality::Draft {+ self.request.quality = Quality::Draft;+ self.key ^= 0x9e37_79b9_7f4a_7c15;+ }+ self+ }++ /// Draw a diagnostic overlay over the result (e.g. Point Color's visualized range). Gets its+ /// own result key.+ pub fn with_overlay(mut self, overlay: lightcraft_pipeline::Overlay) -> Self {+ if self.request.overlay != overlay {+ self.key ^= self.request.overlay.key().wrapping_mul(0x9e37_79b9_7f4a_7c15);+ self.request.overlay = overlay;+ self.key ^= overlay.key().wrapping_mul(0x9e37_79b9_7f4a_7c15);+ }+ // a diagnostic view (visualized range / spots) must never become the photo's cached preview+ if overlay != lightcraft_pipeline::Overlay::None {+ self.view_cache = None;+ }+ self+ }++ /// Soft-proof the result (see [`lightcraft_pipeline::Proof`]). Gets its own result key and is+ /// never kept as the photo's cached preview.+ pub fn with_proof(mut self, proof: Option<lightcraft_pipeline::Proof>) -> Self {+ if self.request.proof != proof {+ let k = |p: Option<lightcraft_pipeline::Proof>| p.map_or(0, |p| p.key()).wrapping_mul(0xc2b2_ae3d_27d4_eb4f);+ self.key ^= k(self.request.proof) ^ k(proof);+ self.request.proof = proof;+ }+ if proof.is_some() {+ self.view_cache = None;+ }+ self+ }++ /// Render with some colour grading wheels (shadows, midtones, highlights) switched off for+ /// viewing (the wheel eyes in the Edit panel). The photo's settings are untouched; the result+ /// gets its own key and is never cached as the photo's preview or thumbnail.+ pub fn with_hidden_grading(mut self, hidden: [bool; 3]) -> Self {+ if !hidden.iter().any(|h| *h) {+ return self;+ }+ let mut s = (*self.settings).clone();+ let g = &mut s.grading;+ for (off, wheel) in hidden.into_iter().zip([&mut g.shadows, &mut g.midtones, &mut g.highlights]) {+ if off {+ *wheel = lightcraft_develop::Wheel::default();+ }+ }+ let bits = hidden.iter().enumerate().fold(0u64, |b, (i, h)| b | ((*h as u64) << i));+ self.key ^= s.hash64() ^ self.settings.hash64() ^ bits.wrapping_mul(0xd6e8_feb8_6659_fd93);+ self.settings = Arc::new(s);+ self.cache = None;+ self.view_cache = None;+ self.preview_cut = None;+ self+ }++ /// Reuse `stages` across this view's renders.+ pub fn with_stages(mut self, stages: Arc<StageCache>) -> Self {+ self.stages = Some(stages);+ self+ }++ /// Render for a monitor profile: into the display's primaries (its gamut, not sRGB's), ready+ /// to show ([`RenderResult::display`]). The histogram and the cached view preview stay sRGB.+ /// Gets its own result key. Thumbnail jobs (rendered-thumbnail cache) are left as they are:+ /// [`crate::display::present`] converts their sRGB results.+ pub fn with_display(mut self, display: Option<Arc<crate::display::Display>>) -> Self {+ // (a slide is composed in sRGB, backdrop colours included; the frontend presents it)+ if self.cache.is_some() || self.slide.is_some() || self.request.depth != lightcraft_pipeline::OutputDepth::U8 {+ return self;+ }+ let k = |d: &Option<Arc<crate::display::Display>>| d.as_ref().map_or(0, |d| d.id()).wrapping_mul(0xd6e8_feb8_6659_fd93);+ self.key ^= k(&self.display) ^ k(&display);+ self.request.display = display.as_ref().map(|d| d.space);+ self.display = display;+ self+ }++ /// Render. A panic inside (a decoder or pipeline bug) is this job's failure: the view waiting+ /// for it is told, instead of waiting forever on a worker that died (the pool doesn't replace+ /// it, so a few such panics used to stop every render).+ pub fn run(self) -> RenderResult {+ let failed = self.failed(String::new());+ crate::guard::catch("the render", || self.run_unguarded()).unwrap_or_else(|e| RenderResult { rendered: Err(e), ..failed })+ }++ /// This job's result when it fails with `e`.+ fn failed(&self, e: String) -> RenderResult {+ RenderResult {+ request_id: self.request_id,+ source_key: self.source_key,+ photo: self.photo,+ level: self.level,+ key: self.key,+ rendered: Err(e),+ gpu_fallback: None,+ loaded: None,+ quick: None,+ display: None,+ }+ }++ /// Compose the render into a slideshow slide (layout, options, backdrop): the result is the+ /// slide, not the photo. Gets its own result key; the photo's cached view preview stays the+ /// photo. The slide stays sRGB ([`Self::with_display`] leaves it alone).+ pub fn with_slide(mut self, slide: Arc<crate::slide::SlideCompose>) -> Self {+ let k = |s: &Option<Arc<crate::slide::SlideCompose>>| s.as_ref().map_or(0, |s| s.key()).wrapping_mul(0xa24b_aed4_963e_e407);+ self.key ^= k(&self.slide);+ self.key ^= k(&Some(slide.clone()));+ self.slide = Some(slide);+ self+ }++ /// [`Self::run_photo`], composed into its slide when this is a slide job (inside [`Self::run`]'s guard).+ fn run_unguarded(self) -> RenderResult {+ let slide = self.slide.clone();+ let mut r = self.run_photo();+ if let (Some(slide), Ok(rendered)) = (slide, r.rendered.as_mut()) {+ rendered.image = slide.compose(&rendered.image);+ rendered.deep = None;+ }+ r+ }++ /// The photo's render (without slide composition).+ fn run_photo(self) -> RenderResult {+ if let Some((cache, key)) = &self.cache+ && let Some(img) = cache.get_at(self.cache_generation, *key)+ {+ let image = Arc::unwrap_or_clone(img);+ let histogram = Histogram::of_srgb8(&image);+ return RenderResult {+ request_id: self.request_id,+ source_key: self.source_key,+ photo: self.photo,+ level: self.level,+ key: self.key,+ rendered: Ok(Rendered { image, histogram, deep: None }),+ gpu_fallback: None,+ loaded: None,+ quick: None,+ display: None,+ };+ }+ // a face tile of an unedited raw: cut from the camera's embedded preview when it is big enough+ // (the sensor data is never read for it), else rendered from `source` below+ if let Some(image) = self.preview_cut.as_ref().and_then(|c| c.cut()) {+ if let Some((cache, key)) = &self.cache {+ cache.put_at(self.cache_generation, *key, Arc::new(image.clone()));+ }+ let histogram = Histogram::of_srgb8(&image);+ return RenderResult {+ request_id: self.request_id,+ source_key: self.source_key,+ photo: self.photo,+ level: self.level,+ key: self.key,+ rendered: Ok(Rendered { image, histogram, deep: None }),+ gpu_fallback: None,+ loaded: None,+ quick: None,+ display: None,+ };+ }+ let was_loaded = matches!(self.source, SourceRef::Loaded(_));+ // The app is closing (issue #620): nobody is left to show this, and quitting waits for the+ // jobs that are running. Without this, one that lost the GPU mid-way would render on the CPU.+ let closing = || lightcraft_gpu::shutting_down().then(|| "LightCraft is closing".to_string());+ let source = match closing() {+ Some(e) => Err(e),+ None => self.source.load_source().and_then(|s| closing().map_or(Ok(s), Err)),+ };+ match source {+ Ok(source) => {+ // the plain picture, or (Denoise amount above 0 and a denoised picture cached) the mix the amount asks for+ let src = &source.image_for(self.settings.denoise_amount());+ let info = source.info_or(self.info);+ // Thumbnails (many small jobs side by side) stay on the CPU; views and exports use+ // the GPU when there is one.+ let gpu = self.cache.is_none();+ let (mut rendered, gpu_fallback) = develop_reporting(src, &info, &self.settings, &self.request, self.stages.as_deref(), gpu);+ // for a display profile: the image goes to the display's values, the histogram+ // and the cached view preview stay sRGB+ let mut srgb = None;+ let display = match (&self.display, self.request.display) {+ (Some(d), Some(_)) => {+ let keep = self.view_cache.is_some() && self.request.quality == Quality::Full;+ let (s, h) = crate::display::finish_render(&mut rendered.image, d, keep);+ // (an HDR edit's HDR histogram stays)+ if let Some(h) = h.filter(|_| rendered.histogram.hdr.is_none()) {+ rendered.histogram = h;+ }+ srgb = s;+ Some(d.id())+ }+ _ => None,+ };+ if let Some((cache, key)) = &self.cache {+ cache.put_at(self.cache_generation, *key, Arc::new(rendered.image.clone()));+ }+ if let Some((cache, key)) = &self.view_cache+ && self.request.quality == Quality::Full+ && (display.is_none() || srgb.is_some())+ {+ cache.put_deferred_at(self.cache_generation, *key, Arc::new(srgb.unwrap_or_else(|| rendered.image.clone())));+ }+ // the display fit, after the caches have the full render+ if let Some((fw, fh)) = self.display_fit+ && self.request.quality == Quality::Full+ {+ let (w, h) = (rendered.image.width, rendered.image.height);+ if w > fw.max(1) || h > fh.max(1) {+ rendered.image = fit_for_display(&rendered.image, fw, fh);+ }+ }+ RenderResult {+ request_id: self.request_id,+ source_key: self.source_key,+ photo: self.photo,+ level: self.level,+ key: self.key,+ rendered: Ok(rendered),+ gpu_fallback,+ loaded: (!was_loaded).then_some(source),+ quick: None,+ display,+ }+ }+ Err(e) => self.failed(e),+ }+ }+}++/// Render `src`: on the GPU when `gpu` is set and a GPU is available (`lightcraft_gpu`), else on+/// the CPU, reusing `stages` either way. Both produce the same image within 1–3 LSB (see+/// `docs/gpu-pipeline.md`); `LIGHTCRAFT_GPU=0` or [`lightcraft_gpu::set_enabled`] forces the CPU.+pub fn develop(src: &Arc<Rgb32f>, info: &SourceInfo, s: &DevelopSettings, req: &RenderRequest, stages: Option<&StageCache>, gpu: bool) -> Rendered {+ develop_reporting(src, info, s, req, stages, gpu).0+}++/// [`develop`], also saying why the render fell back from the GPU to the CPU when it did (`None`:+/// it rendered on the GPU, or the GPU was not tried). The reason is this render's own, not the+/// process-wide [`lightcraft_gpu::last_fallback`].+pub fn develop_reporting(+ src: &Arc<Rgb32f>,+ info: &SourceInfo,+ s: &DevelopSettings,+ req: &RenderRequest,+ stages: Option<&StageCache>,+ gpu: bool,+) -> (Rendered, Option<String>) {+ let (mut rendered, fallback) = develop_image(src, info, s, req, stages, gpu);+ // an HDR edit's preview is its SDR rendition: its histogram shows the HDR range instead+ if let Some(h) = lightcraft_pipeline::hdr_histogram(src, info, s, req) {+ rendered.histogram = h;+ }+ (rendered, fallback)+}++fn develop_image(+ src: &Arc<Rgb32f>,+ info: &SourceInfo,+ s: &DevelopSettings,+ req: &RenderRequest,+ stages: Option<&StageCache>,+ gpu: bool,+) -> (Rendered, Option<String>) {+ // LUT profiles have no GPU stage: they render on the CPU+ let fallback = if gpu+ && !lightcraft_pipeline::lut::is_lut_profile(&s.profile.id)+ && !s.masks.iter().any(|m| m.visible && m.refine > 0.0)+ && req.proof.is_none()+ {+ match lightcraft_gpu::try_render(src, info, s, req, stages) {+ Ok(r) => return (r, None),+ Err(lightcraft_gpu::Fallback::Failed(why)) => Some(why),+ Err(lightcraft_gpu::Fallback::NotTried) => None,+ }+ } else {+ None+ };+ let rendered = match stages {+ Some(st) => lightcraft_pipeline::render_cached(src, info, s, req, st),+ None => lightcraft_pipeline::render(src, info, s, req),+ };+ (rendered, fallback)+}diff --git a/crates/engine/src/media/session.rs b/crates/engine/src/media/session.rsnew file mode 100644index 000000000..d160b216d--- /dev/null+++ b/crates/engine/src/media/session.rs@@ -0,0 +1,476 @@+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::*;++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> {+ 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> {+ 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 --git a/crates/engine/src/media/settings_hash.rs b/crates/engine/src/media/settings_hash.rsnew file mode 100644index 000000000..5d9c08b93--- /dev/null+++ b/crates/engine/src/media/settings_hash.rs@@ -0,0 +1,36 @@+use super::*;++pub(super) const SETTINGS_HASH_ENTRIES: usize = 1024;++#[derive(Default)]+pub(super) struct SettingsHashes {+ pub(super) entries: HashMap<PhotoId, (Weak<DevelopSettings>, u64)>,+ pub(super) order: VecDeque<PhotoId>,+ #[cfg(test)]+ pub(super) computations: usize,+}++impl SettingsHashes {+ pub(super) fn get(&mut self, id: PhotoId, settings: &Arc<DevelopSettings>) -> u64 {+ if let Some((old, hash)) = self.entries.get(&id)+ && old.as_ptr() == Arc::as_ptr(settings)+ {+ return *hash;+ }+ let hash = settings.hash64();+ #[cfg(test)]+ {+ self.computations += 1;+ }+ if !self.entries.contains_key(&id) {+ if self.entries.len() >= SETTINGS_HASH_ENTRIES+ && let Some(oldest) = self.order.pop_front()+ {+ self.entries.remove(&oldest);+ }+ self.order.push_back(id);+ }+ self.entries.insert(id, (Arc::downgrade(settings), hash));+ hash+ }+}diff --git a/crates/engine/src/media/source.rs b/crates/engine/src/media/source.rsnew file mode 100644index 000000000..51c54c60a--- /dev/null+++ b/crates/engine/src/media/source.rs@@ -0,0 +1,324 @@+use super::*;++/// Bump when the pipeline's output changes, to invalidate cached thumbnails.+pub const RENDER_CACHE_VERSION: u64 = 70;++/// 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];++/// Face tiles are rendered at a multiple of this many pixels ([`crate::Session::face_job`]): the+/// tile's size follows the thumbnail slider and the screen's scale, and without steps every size+/// in between would render (and cache) every face again.+pub const FACE_EDGE_STEP: usize = 16;++/// The edge a face tile asked to be `edge` pixels across is rendered at: the next+/// [`FACE_EDGE_STEP`], 16..=512.+pub fn face_edge(edge: usize) -> usize {+ edge.clamp(16, SourceLevel::Thumb.max_edge()).div_ceil(FACE_EDGE_STEP).saturating_mul(FACE_EDGE_STEP).min(SourceLevel::Thumb.max_edge())+}++pub fn thumb_bucket(long_edge: usize) -> usize {+ THUMB_SIZES.iter().copied().find(|s| *s >= long_edge).unwrap_or(512)+}++/// Memory budgets.+pub(super) const THUMB_SOURCE_BYTES: usize = 384 << 20;++pub(super) const RENDERED_MEM_BYTES: usize = 128 << 20;++/// Disk budget for the thumbnail cache.+pub const DISK_CACHE_BYTES: u64 = 2 << 30;++#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]+#[serde(rename_all = "lowercase")]+pub enum SourceLevel {+ Thumb,+ Preview,+ /// The original at its native resolution (exports larger than a preview).+ Full,+}++impl SourceLevel {+ pub fn max_edge(self) -> usize {+ match self {+ SourceLevel::Thumb => 512,+ SourceLevel::Preview => 2560,+ SourceLevel::Full => usize::MAX,+ }+ }+ /// Smallest level that can serve an output of `long_edge` pixels.+ pub fn for_size(long_edge: usize) -> SourceLevel {+ match long_edge {+ 0..=520 => SourceLevel::Thumb,+ 521..=2560 => SourceLevel::Preview,+ _ => SourceLevel::Full,+ }+ }+}++/// Pixels along the source's long edge that an output `out_long` pixels long needs: a crop shows+/// only part of the photo, so its pixels come from a source that many times larger (the source+/// level is chosen from this, or a tight crop shown at its own pixels would be a stretched preview).+pub(super) fn source_edge_needed(p: &Photo, settings: &DevelopSettings, apply_crop: bool, out_long: usize) -> usize {+ let (w, h) = (f64::from(p.width.max(1)), f64::from(p.height.max(1)));+ let r = settings.crop.geometry.rect;+ let shown = if apply_crop { (r.width() * w).max(r.height() * h) } else { w.max(h) };+ if !shown.is_finite() || shown < 1.0 {+ return out_long;+ }+ let needed = out_long as f64 * w.max(h) / shown;+ if needed.is_finite() { needed.min(usize::MAX as f64 / 2.0) as usize } else { out_long }+}++/// Decodes a file into a linear Rec.2020 image no larger than `max_edge` (set by the app).+pub type FileLoader = Arc<dyn Fn(&str, usize) -> Result<(Rgb32f, SourceInfo), String> + Send + Sync>;++/// [`FileLoader`] for a thumbnail: a raw file that keeps smaller copies of its raw image (Lightroom's merged DNGs)+/// develops the smallest that covers `max_edge` (set by the app); the flag says it did. Never used for an export,+/// which must render the full image.+pub type ReducedLoader = Arc<dyn Fn(&str, usize) -> Result<(Rgb32f, SourceInfo, bool), String> + Send + Sync>;++/// A raw file's embedded (camera-rendered) preview as display sRGB, oriented, no larger than+/// `max_edge` (set by the app). `None`: no usable preview.+pub type PreviewLoader = Arc<dyn Fn(&str, usize) -> Option<Rgba8> + Send + Sync>;++/// Makes a photo's denoised picture when it is not cached yet (an export does not wait for the background queue):+/// `Ok(true)` once it is there, `Ok(false)` when denoise does not apply to this photo (render it plain), `Err` when it+/// should have worked and did not.+pub type MakeProduct = Arc<dyn Fn() -> Result<bool, String> + Send + Sync>;++/// A raw photo's cached AI-denoised picture (see [`crate::denoise`]): where the file is and the key it must have been+/// made with. A file that is missing, damaged or made for something else is a cache miss, never an error.+#[derive(Clone)]+pub struct DenoiseSpec {+ pub product: std::path::PathBuf,+ pub key: String,+ /// Run before the picture is read, by a job that must not render without it (an export).+ pub make: Option<MakeProduct>,+}++/// Decodes a raw file once and develops it twice: as usual, and from the denoised picture in `spec` when that can be+/// read (`None` when it cannot). Both are at most `max_edge` long and the same size.+pub type PairLoader = Arc<dyn Fn(&str, usize, &DenoiseSpec) -> Result<(Rgb32f, Option<Rgb32f>, SourceInfo), String> + Send + Sync>;++/// A photo's denoised picture next to its plain one, and the last mix of the two that was asked for.+pub struct Twin {+ pub image: Arc<Rgb32f>,+ /// The Amount (in thousandths) and the picture mixed for it, so dragging other sliders keeps one source picture.+ mix: std::sync::Mutex<Option<(u32, Arc<Rgb32f>)>>,+}++impl Twin {+ pub fn new(image: Arc<Rgb32f>) -> Twin {+ Twin { image, mix: std::sync::Mutex::new(None) }+ }++ /// Bytes reserved for the twin and its lazy mix, before either cache cost can grow.+ fn bytes(&self) -> usize {+ self.image.data.len().saturating_mul(24)+ }+}++/// Pixels and the source interpretation learned while decoding; they must be cached together.+#[derive(Clone)]+pub struct DecodedSource {+ pub image: Arc<Rgb32f>,+ pub info: Option<SourceInfo>,+ /// A smart preview's stored camera tone curve: the one decoder fact its pixels need that the+ /// catalog's header facts lack (used when `info` is `None`).+ pub camera_tone: Option<lightcraft_pipeline::tone::CameraTone>,+ /// The same picture developed from the AI-denoised mosaic, when the photo has one cached.+ pub denoised: Option<Arc<Twin>>,+ /// These pixels came from the photo's smart preview (an offline original), not from its file.+ /// A refresh must never rebuild a proxy from itself: that would stamp its older look as current.+ pub from_proxy: bool,+ /// Developed from a smaller copy of the raw image that the file keeps ([`ReducedLoader`]), not from the image+ /// itself: good for a thumbnail, never for an export.+ pub reduced: bool,+}++impl DecodedSource {+ pub fn new(image: Arc<Rgb32f>, info: Option<SourceInfo>) -> Self {+ DecodedSource { image, info, camera_tone: None, denoised: None, from_proxy: false, reduced: false }+ }++ /// The picture to develop for a Denoise `amount` (0 to 1, see [`DevelopSettings::denoise_amount`]): the plain one,+ /// the denoised one, or a mix of the two. A mix is made once per amount and kept, so the stages after it are+ /// reused until the amount changes.+ pub fn image_for(&self, amount: f32) -> Arc<Rgb32f> {+ let Some(twin) = &self.denoised else { return self.image.clone() };+ if amount.is_nan() || amount <= 0.0 || twin.image.width != self.image.width || twin.image.height != self.image.height {+ return self.image.clone();+ }+ if amount >= 1.0 {+ return twin.image.clone();+ }+ let thousandths = (amount * 1000.0).round().clamp(1.0, 999.0) as u32;+ let mut memo = twin.mix.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ if let Some((t, img)) = memo.as_ref()+ && *t == thousandths+ {+ return img.clone();+ }+ let mut mixed = (*self.image).clone();+ if !lightcraft_denoise::product::blend(&mut mixed, &twin.image, thousandths as f32 / 1000.0) {+ return self.image.clone();+ }+ let mixed = Arc::new(mixed);+ *memo = Some((thousandths, mixed.clone()));+ mixed+ }++ /// Cache cost: the picture, its segmentation mattes, its denoised twin and room for the lazy mix.+ pub fn bytes(&self) -> usize {+ let mattes = self.info.as_ref().and_then(|i| i.mattes.as_ref()).map_or(0, |m| m.bytes());+ let mattes = mattes + self.info.as_ref().and_then(|i| i.local_tone.as_ref()).map_or(0, |t| t.map.gains.len() * 4);+ self.image.data.len() * 12 + 64 + std::mem::size_of::<SourceInfo>() + mattes + self.denoised.as_ref().map_or(0, |t| t.bytes())+ }++ /// What to render these pixels against: the decoder's facts, else `header` (the catalog's)+ /// with any stored camera tone curve. The original's size comes from `header` either way: the+ /// decoder only sees the level it decoded.+ pub fn info_or(&self, header: SourceInfo) -> SourceInfo {+ match &self.info {+ Some(info) => SourceInfo { native_long: info.native_long.or(header.native_long), ..info.clone() },+ None => SourceInfo { camera_tone: self.camera_tone.or(header.camera_tone), ..header },+ }+ }+}++#[derive(Clone)]+pub enum SourceRef {+ Loaded(Box<DecodedSource>),+ /// A larger decoded source of the photo, fitted to `max_edge` by the worker: the thumbnail of+ /// the photo open in the loupe is cut from its preview-level source instead of decoding the+ /// file again (a second or more for a 64 MP raw).+ Fit {+ from: Box<DecodedSource>,+ max_edge: usize,+ },+ Demo {+ scene: Box<lightcraft_scenes::Scene>,+ max_edge: usize,+ },+ File {+ path: String,+ max_edge: usize,+ loader: Option<FileLoader>,+ /// The photo's smart preview, used when the original can't be read (offline drive). The+ /// UI thread never checks whether the original is there; the render worker finds out.+ fallback: Option<std::path::PathBuf>,+ /// The photo has a cached denoised picture: load it with the plain one (see [`PairLoader`]).+ denoise: Option<(DenoiseSpec, PairLoader)>,+ /// A thumbnail's loader, used instead of `loader` (see [`ReducedLoader`]); `None` for every other job.+ reduced: Option<ReducedLoader>,+ },+ /// A smart preview standing in for a missing original.+ Smart {+ path: std::path::PathBuf,+ },+}++impl SourceRef {+ pub fn load(&self) -> Result<Arc<Rgb32f>, String> {+ self.load_source().map(|s| s.image)+ }++ pub fn load_source(&self) -> Result<DecodedSource, String> {+ let image = match self {+ SourceRef::Loaded(a) => return Ok((**a).clone()),+ SourceRef::Fit { from, max_edge } => {+ if from.image.width.max(from.image.height) <= *max_edge {+ return Ok((**from).clone());+ }+ // Lanczos, not a box average: a box at 2-3:1 halves the contrast of detail near+ // the output's resolution limit and aliases what is finer+ let image = lightcraft_raster::resample::fit(&from.image, *max_edge, *max_edge, lightcraft_raster::resample::Filter::Lanczos3);+ return Ok(DecodedSource { image: Arc::new(image), denoised: None, ..(**from).clone() });+ }+ SourceRef::Demo { scene, max_edge } => crate::demo::scene_pixels(scene, *max_edge)?,+ SourceRef::File { path, max_edge, loader, fallback, denoise, reduced } => {+ let plain = || match (reduced, loader) {+ (Some(l), _) => {+ l(path, *max_edge).map(|(image, info, reduced)| DecodedSource { reduced, ..DecodedSource::new(Arc::new(image), Some(info)) })+ }+ (None, Some(l)) => l(path, *max_edge).map(|(image, info)| DecodedSource::new(Arc::new(image), Some(info))),+ (None, None) => Err(format!("no decoder available for {path}")),+ };+ // the denoised picture comes with the plain one from a single decode; when it cannot be read the+ // pair loader gives the plain picture alone (the cached file is never a reason to fail a render)+ let r = match denoise {+ Some((spec, pair)) => {+ // a job that needs the denoised picture has it made first; if that fails the job fails (no smart+ // preview stands in: an export must not quietly come out without the denoise it was asked for)+ let made = match &spec.make {+ Some(make) => make()?,+ None => true,+ };+ if made {+ pair(path, *max_edge, spec).and_then(|(image, twin, info)| {+ if spec.make.is_some() && twin.is_none() {+ return Err("the cached AI Denoise picture could not be read; clear the denoise cache and retry".into());+ }+ Ok(DecodedSource {+ image: Arc::new(image),+ info: Some(info),+ camera_tone: None,+ denoised: twin.map(|t| Arc::new(Twin::new(Arc::new(t)))),+ from_proxy: false,+ reduced: false,+ })+ })+ } else {+ plain()+ }+ }+ None => plain(),+ };+ // An offline original renders from its smart preview (no decoder facts: header ones).+ return match (r, fallback) {+ #[cfg(not(target_arch = "wasm32"))]+ (Err(e), Some(sp)) if denoise.as_ref().is_none_or(|(spec, _)| spec.make.is_none()) && crate::smart::is_valid(sp) => {+ crate::smart::load(sp).map_err(|e2| format!("{e}; smart preview: {e2}"))+ }+ (r, _) => r,+ };+ }+ #[cfg(not(target_arch = "wasm32"))]+ SourceRef::Smart { path } => return crate::smart::load(path),+ #[cfg(target_arch = "wasm32")]+ SourceRef::Smart { .. } => return Err("smart previews are not available here".into()),+ };+ Ok(DecodedSource::new(image, None))+ }+}++/// What an import learns from a file header (set by the app from `lightcraft-codecs`/`-raw`).+#[derive(Clone, Debug, Default)]+pub struct ProbeInfo {+ pub width: u32,+ pub height: u32,+ pub format: String,+ pub kind: MediaKind,+ pub file_size: u64,+ pub captured: Option<String>,+ /// The file's modification time (ISO 8601, the clock of [`crate::import::system_clock`]): the+ /// capture date of a file whose metadata has none, as Lightroom does (exports saved without+ /// metadata would otherwise all land under "Unknown Date").+ pub file_modified: Option<String>,+ pub meta: lightcraft_catalog::Meta,+ pub as_shot_wb: Option<(f64, f64)>,+ /// Hash of the file's bytes (hex), for duplicate detection. When it is a 32-digit+ /// [`lightcraft_preview::hash_bytes`] of the whole file (as the native probe computes it),+ /// Import → Copy verifies each copy against it instead of reading the source again.+ pub content_hash: Option<String>,+ /// Lens corrections embedded in the file (DNG opcodes).+ pub embedded_lens: Option<lightcraft_develop::EmbeddedLens>,+ /// The file's embedded XMP packet (raw/DNG files), for develop settings stored inside the file.+ pub xmp: Option<String>,+ /// A raw variant that can't be decoded yet: why. The file is described (and will be shown and+ /// edited) from its embedded preview; see [`lightcraft_catalog::Photo::preview_only`].+ pub preview_only: Option<String>,+}++pub type FileProbe = Arc<dyn Fn(&str) -> Result<ProbeInfo, String> + Send + Sync>;