Skip to content

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

Merge storytold/main into fix/2678-failed-thumb-retries

insideTheFlux47289b561e7e
diff --cc crates/ui-egui/src/render/thumbnail_tests.rs
index 000000000,984ce0462..f126bd396
mode 000000,100644..100644
--- a/crates/ui-egui/src/render/thumbnail_tests.rs
+++ b/crates/ui-egui/src/render/thumbnail_tests.rs
@@@ -1,0 -1,768 +1,817 @@@
+ use super::*;
+ use lightcraft_catalog::{Catalog, Op, Photo, Source};
+
+ #[test]
+ fn render_failures_identify_the_file_for_thumbnail_and_view_slots() {
+ let source = Source::File { path: "/photos/trip/IMG_0042.nef".into() };
+ for slot in [Slot::Thumb(PhotoId(42)), Slot::Main, Slot::Before, Slot::Compare(1), Slot::Region] {
+ let message = render_failure_message(slot, PhotoId(42), Some(&source), "unsupported compression");
+ assert!(message.contains("/photos/trip/IMG_0042.nef"), "{message}");
+ assert!(message.contains("PhotoId(42)"), "{message}");
+ assert!(message.ends_with(": unsupported compression"), "{message}");
+ }
+ }
+
+ #[test]
+ fn render_failure_paths_are_escaped_and_missing_sources_still_identified() {
+ let source = Source::File { path: "line\nbreak.nef".into() };
+ let message = render_failure_message(Slot::Main, PhotoId(42), Some(&source), "decode failed");
+ assert!(!message.contains('\n'));
+ assert!(message.contains("line\\nbreak.nef"));
+ assert!(render_failure_message(Slot::Main, PhotoId(42), None, "decode failed").contains("PhotoId(42), source unavailable"));
+ let demo = Source::Demo { scene: 7 };
+ assert!(render_failure_message(Slot::Main, PhotoId(42), Some(&demo), "decode failed").contains("demo scene 7"));
+ }
+
+ struct Blocked;
+ impl RenderOffload for Blocked {
+ fn try_start(&mut self, _: Slot, job: RenderJob) -> Option<RenderJob> {
+ Some(job)
+ }
+ fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {
+ vec![]
+ }
+ }
+ fn photo() -> Arc<Photo> {
+ Arc::new(Photo::new(PhotoId(1), Source::File { path: "audit.jpg".into() }, "audit.jpg", "JPEG", 6000, 4000, "2026-01-01"))
+ }
+ #[test]
+ fn snapshot_tracks_cow_edits_undo_reload_and_replacement() {
+ let mut catalog = Catalog::default();
+ catalog.apply(Op::AddPhoto { photo: Box::new((*photo()).clone()) }).unwrap();
+ let old = catalog.photo(PhotoId(1)).unwrap().clone();
+ let mut r = Renderer::default();
+ r.remember_thumb(&old, 384, 77, false);
+ r.pending.insert(Slot::Thumb(PhotoId(1)), (77, 10));
+ assert!(r.thumb_current(&old, 384, 10));
+ assert!(!r.thumb_current(&old, 512, 10));
+ let mut settings = lightcraft_develop::DevelopSettings::default();
+ settings.light.exposure = 1.0;
+ let undo = catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(settings), label: "edit".into(), edited: None }).unwrap();
+ assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));
+ catalog.apply(undo).unwrap();
+ assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));
+ catalog
+ .apply(Op::SetContent {
+ id: PhotoId(1),
+ width: 6000,
+ height: 4000,
+ file_size: 99,
+ content_hash: Some("changed".into()),
+ preview_only: None,
+ preview_checked: String::new(),
+ })
+ .unwrap();
+ assert!(!r.thumb_current(catalog.photo(PhotoId(1)).unwrap(), 384, 10));
+ assert!(!r.thumb_current(&photo(), 384, 10));
+ r.forget_all();
+ assert!(r.thumb_inputs.is_empty());
+ }
+ #[test]
+ fn queue_promotions_running_work_and_cancellation() {
+ let p = photo();
+ let slot = Slot::Thumb(p.id);
+ let mut session = Session::new();
+ session.catalog.apply(Op::AddPhoto { photo: Box::new((*p).clone()) }).unwrap();
+ let job = session.thumb_job(p.id, 384).unwrap();
+ let key = job.key;
+ let mut r = Renderer::default();
+ r.set_offload(Box::new(Blocked));
+ r.remember_thumb(&p, 384, key, false);
+ r.request(slot, job, 5);
+ assert!(r.thumb_current(&p, 384, 5));
+ assert!(!r.thumb_current(&p, 384, 10));
+ r.request(slot, session.thumb_job(p.id, 384).unwrap(), 10);
+ assert_eq!(r.pending.get(&slot), Some(&(key, 10)));
+ r.queue.clear(); // running work: cannot reprioritize, just as Renderer::request
+ assert!(r.thumb_current(&p, 384, 5));
+ r.pending.clear();
+ assert!(!r.thumb_current(&p, 384, 10));
+ r.evict_thumbs(&Default::default(), 600);
+ assert!(r.thumb_inputs.is_empty());
+ }
+ fn queued_quick_thumbnail(id: PhotoId) -> (Arc<Photo>, QuickJob) {
+ let mut session = Session::new();
+ session.media.preview_loader = Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));
+ let mut raw = (*photo()).clone();
+ raw.id = id;
+ raw.kind = lightcraft_catalog::MediaKind::Raw;
+ raw.develop = Arc::new(raw.camera_defaults());
+ session.catalog.apply(Op::AddPhoto { photo: Box::new(raw) }).unwrap();
+ let p = session.catalog.photo(id).unwrap().clone();
+ let job = session.thumb_job(id, 384).unwrap();
+ (p, session.quick_thumb_job(&job).unwrap())
+ }
+
+ #[test]
+ fn queued_standin_promotes_from_prefetch_to_visible_without_restarting() {
+ let (p, quick) = queued_quick_thumbnail(PhotoId(1));
+ let (_, other) = queued_quick_thumbnail(PhotoId(2));
+ let slot = Slot::ThumbQuick(p.id);
+ // Deterministic queue: no native worker starts.
+ let mut r = Renderer { pool: JobPool::new(0), ..Default::default() };
+ r.remember_thumb(&p, 384, quick.key, true);
+ r.request_quick(slot, quick.clone(), 6); // grid prefetch: 5 + 1
+ r.request_quick(Slot::ThumbQuick(PhotoId(2)), other, 9); // filmstrip: 8 + 1
+ let request_id = r.requests[&slot].id;
+ assert!(r.thumb_current(&p, 384, 5));
+ assert!(!r.thumb_current(&p, 384, 10));
+ r.request_quick(slot, quick.clone(), 11); // visible grid: 10 + 1
+ assert!(r.thumb_current(&p, 384, 10));
+ r.request_quick(slot, quick.clone(), 11);
+ assert_eq!(r.requests[&slot].id, request_id);
+ assert_eq!(r.pool.queued(), 2);
+ r.pool.run_inline(1);
+ let done = r.pool.try_recv().unwrap();
+ assert_eq!(done.slot, slot);
+ assert_eq!(done.result.result.request_id, request_id);
+ assert_eq!(done.result.result.quick, Some(QuickSource::Embedded));
+ // A finished result awaiting collection also must not start another extraction.
+ r.request_quick(slot, quick, 6);
+ assert!(r.thumb_current(&p, 384, 5));
+ assert_eq!(r.pool.queued(), 1);
+ }
+
+ #[test]
+ fn queued_standin_demotes_when_it_leaves_the_visible_grid() {
+ let (p, quick) = queued_quick_thumbnail(PhotoId(1));
+ let (_, other) = queued_quick_thumbnail(PhotoId(2));
+ let slot = Slot::ThumbQuick(p.id);
+ let mut r = Renderer { pool: JobPool::new(0), ..Default::default() };
+ r.remember_thumb(&p, 384, quick.key, true);
+ r.request_quick(slot, quick.clone(), 11);
+ r.request_quick(Slot::ThumbQuick(PhotoId(2)), other, 9);
+ assert!(!r.thumb_current(&p, 384, 5));
+ r.request_quick(slot, quick, 6);
+ assert!(r.thumb_current(&p, 384, 5));
+ r.pool.run_inline(1);
+ assert_eq!(r.pool.try_recv().unwrap().slot, Slot::ThumbQuick(PhotoId(2)));
+ }
+
+ #[test]
+ fn failures_retry_after_revision_and_quick_only_is_not_final() {
+ let p = photo();
+ let slot = Slot::Thumb(p.id);
+ let mut r = Renderer::default();
+ r.remember_thumb(&p, 384, 77, false);
+ r.pending.insert(Slot::ThumbQuick(p.id), (77, 11));
+ assert!(!r.thumb_current(&p, 384, 10));
+ r.failed.insert(slot, (77, "no decoder".into(), 0, p.id));
+ assert!(r.thumb_current(&p, 384, 10));
+ assert_eq!(r.failure_of(slot, p.id), Some("no decoder"));
+ assert_eq!(r.failure_of(slot, PhotoId(p.id.0 + 1)), None, "another photo's error");
+ r.catalog_rev = 1;
+ assert!(!r.thumb_current(&p, 384, 10));
+ }
+
++/// Issue #2682: writes to other photos in the background (faces found, metadata read) moved
++/// the catalog revision on and sent every undecodable file back to the decoder, 37 times each
++/// in 154 s of idle. A failure is tried again only when its own photo changes, when the
++/// catalog can't say which photos did, or, at any change, when its file is known to be missing.
++#[test]
++fn a_failed_thumbnail_is_retried_only_when_its_photo_changes() {
++ use std::sync::atomic::{AtomicBool, Ordering};
++ let mut catalog = Catalog::default();
++ let p = photo();
++ let other = PhotoId(2);
++ catalog.apply(Op::AddPhoto { photo: Box::new((*p).clone()) }).unwrap();
++ let other_photo = Photo::new(other, Source::File { path: "other.jpg".into() }, "other.jpg", "JPEG", 60, 40, "2026-01-01");
++ catalog.apply(Op::AddPhoto { photo: Box::new(other_photo) }).unwrap();
++ // the files are there (an undecodable file is still a file)
++ let here = Arc::new(AtomicBool::new(true));
++ let mut files = lightcraft_engine::availability::Availability::default();
++ let h = here.clone();
++ files.set_probe(Arc::new(move |_| h.load(Ordering::SeqCst)));
++ let slot = Slot::Thumb(p.id);
++ let mut r = Renderer::default();
++ r.follow_catalog(&catalog, &files);
++ r.failed.insert(slot, (77, "unrecognised image format".into(), r.catalog_rev, p.id));
++ assert!(!r.request_needed(slot, 77, 10), "a failure stands");
++ // the other photo changes, op after op, as background work does
++ for rating in 1..=5 {
++ catalog.apply(Op::SetRating { id: other, rating }).unwrap();
++ r.follow_catalog(&catalog, &files);
++ assert!(!r.request_needed(slot, 77, 10), "another photo's change (rating {rating}) retries nothing");
++ }
++ // a change to the photo itself is a reason to try again
++ catalog.apply(Op::SetRating { id: p.id, rating: 2 }).unwrap();
++ r.follow_catalog(&catalog, &files);
++ assert!(r.request_needed(slot, 77, 10), "its own photo changed");
++ // so is a change the catalog can't attribute to photos
++ r.failed.insert(slot, (77, "unrecognised image format".into(), r.catalog_rev, p.id));
++ assert!(!r.request_needed(slot, 77, 10));
++ let album = catalog.alloc_album_id();
++ catalog.apply(Op::AddAlbum { album: lightcraft_catalog::Album::new(album, "Trip") }).unwrap();
++ r.follow_catalog(&catalog, &files);
++ assert!(r.request_needed(slot, 77, 10), "which photos changed is unknown");
++ // a file known to be missing (its drive unplugged) is tried at every change, as before, so
++ // the photo comes back with its drive
++ r.failed.insert(slot, (77, "file not found".into(), r.catalog_rev, p.id));
++ here.store(false, Ordering::SeqCst);
++ catalog.apply(Op::SetRating { id: other, rating: 1 }).unwrap();
++ r.follow_catalog(&catalog, &files);
++ assert!(r.request_needed(slot, 77, 10), "a missing file is tried again");
++}
++
+ #[test]
+ fn a_fast_draft_is_drawn_in_the_frame_that_asked_for_it() {
+ let mut s = Session::new();
+ s.media.file_loader = Some(Arc::new(|_, _| Ok((lightcraft_raster::Rgb32f::new(8, 8), Default::default()))));
+ s.catalog.apply(Op::AddPhoto { photo: Box::new((*photo()).clone()) }).unwrap();
+ let mut r = Renderer::with_worker_threads(1);
+ let ctx = egui::Context::default();
+ let budget = std::time::Duration::from_secs(10);
+ // the last loupe render took longer than the budget (a CPU render): not waited for
+ r.last_main_ms = 1e6;
+ r.request(Slot::Main, s.render_job(PhotoId(1), 64, 64, false, true).unwrap(), 100);
+ r.wait_for_draft(&ctx, &mut s, budget);
+ assert!(r.is_pending(Slot::Main) && !r.textures.contains_key(&Slot::Main));
+ // a fast one (GPU drafts): the texture is the new render when the wait returns
+ r.last_main_ms = 1.0;
+ r.request(Slot::Main, s.render_job(PhotoId(1), 32, 32, false, true).unwrap(), 100);
+ let want = r.wanted(Slot::Main);
+ r.wait_for_draft(&ctx, &mut s, budget);
+ assert!(!r.is_pending(Slot::Main));
+ assert_eq!(r.textures.get(&Slot::Main).map(|t| t.key), want);
+ }
+
+ #[derive(Default)]
+ struct Work {
+ jobs: Vec<(Slot, RenderJob)>,
+ finished: Vec<(Slot, RenderResult, f64)>,
+ }
+ struct Manual(std::rc::Rc<std::cell::RefCell<Work>>);
+ impl RenderOffload for Manual {
+ fn try_start(&mut self, slot: Slot, job: RenderJob) -> Option<RenderJob> {
+ self.0.borrow_mut().jobs.push((slot, job));
+ None
+ }
+ fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {
+ std::mem::take(&mut self.0.borrow_mut().finished)
+ }
+ }
+ fn fixture() -> (crate::LightcraftApp, std::rc::Rc<std::cell::RefCell<Work>>, egui::Context) {
+ fixture_with(Session::new(), (*photo()).clone())
+ }
+ fn fixture_with(mut s: Session, photo: Photo) -> (crate::LightcraftApp, std::rc::Rc<std::cell::RefCell<Work>>, egui::Context) {
+ s.media.file_loader = Some(Arc::new(|_, _| {
+ let mut image = lightcraft_raster::Rgb32f::new(8, 8);
+ image.data.fill([0.3, 0.2, 0.1]);
+ Ok((image, Default::default()))
+ }));
+ // (`with_fs` sets the file system's thumbnail loader, which wins over `file_loader`: thumbnails use the stub too)
+ s.media.reduced_loader = None;
+ s.catalog.apply(Op::AddPhoto { photo: Box::new(photo) }).unwrap();
+ let mut app = crate::LightcraftApp::new(s, crate::Services::default());
+ app.renderer.keep_pixels = true;
+ let work = std::rc::Rc::new(std::cell::RefCell::new(Work::default()));
+ app.renderer.set_offload(Box::new(Manual(work.clone())));
+ let ctx = egui::Context::default();
+ app.renderer.poll(&ctx, &mut app.session);
+ (app, work, ctx)
+ }
+ fn take_job(work: &std::rc::Rc<std::cell::RefCell<Work>>) -> (Slot, RenderJob) {
+ work.borrow_mut().jobs.pop().unwrap()
+ }
+ fn finish(app: &mut crate::LightcraftApp, work: &std::rc::Rc<std::cell::RefCell<Work>>, ctx: &egui::Context, slot: Slot, result: RenderResult) {
+ work.borrow_mut().finished.push((slot, result, 0.0));
+ app.renderer.poll(ctx, &mut app.session);
+ }
+ fn request(app: &mut crate::LightcraftApp) {
+ crate::panels::grid::request_thumb(app, PhotoId(1), 256, 10);
+ }
+
+ fn relink_destination() -> std::path::PathBuf {
+ let path = std::env::temp_dir().join(format!("lc-render-relinked-{}-{}.nef", std::process::id(), lightcraft_preview::next_tick()));
+ std::fs::write(&path, b"replacement source").unwrap();
+ path
+ }
+
+ #[test]
+ fn completed_failure_keeps_requested_source_after_relink() {
+ let replacement = relink_destination();
+ for slot in [Slot::Thumb(PhotoId(1)), Slot::Main, Slot::Before, Slot::Compare(1), Slot::Region] {
+ let (mut app, work, ctx) = fixture();
+ app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));
+ let job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();
+ app.renderer.request(slot, job, 100);
+ let (submitted, job) = take_job(&work);
+ assert_eq!(submitted, slot);
+ let result = job.run();
+ assert!(result.rendered.is_err(), "the old request has already failed");
+ app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();
+ assert!(
+ matches!(&app.session.catalog.photo(PhotoId(1)).unwrap().source, Source::File { path } if path.ends_with(replacement.file_name().unwrap().to_str().unwrap()))
+ );
+ finish(&mut app, &work, &ctx, slot, result);
+ assert_eq!(app.renderer.failure(slot), Some("simulated decode failure"));
+ assert!(!app.renderer.is_pending(slot));
+ let message = app.renderer.failure_messages.last().expect("the collector emitted a diagnostic");
+ assert!(message.contains("audit.jpg"), "{message}");
+ assert!(!message.contains("lc-render-relinked-"), "the failed request did not read the replacement: {message}");
+ assert!(message.ends_with(": simulated decode failure"), "{message}");
+ }
+ std::fs::remove_file(replacement).unwrap();
+ }
+
+ #[test]
+ fn superseded_failure_does_not_take_the_new_requests_source() {
+ let replacement = relink_destination();
+ let (mut app, work, ctx) = fixture();
+ app.session.media.file_loader = Some(Arc::new(|_, _| Err("simulated decode failure".into())));
+ let slot = Slot::Main;
+ let old_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();
+ app.renderer.request(slot, old_job, 100);
+ let (_, old_job) = take_job(&work);
+ let old_result = old_job.run();
+ app.session.execute("photo.relink", &serde_json::json!({"id": 1, "path": replacement})).unwrap();
+ let new_job = app.session.render_job(PhotoId(1), 64, 64, false, true).unwrap();
+ app.renderer.request(slot, new_job, 100);
+ let (_, new_job) = take_job(&work);
+ finish(&mut app, &work, &ctx, slot, old_result);
+ assert!(app.renderer.failure_messages.is_empty(), "obsolete failures stay suppressed");
+ assert!(app.renderer.is_pending(slot));
+ finish(&mut app, &work, &ctx, slot, new_job.run());
+ let message = app.renderer.failure_messages.last().expect("new failure is reported");
+ assert!(message.contains("lc-render-relinked-"), "{message}");
+ assert!(!message.contains("audit.jpg"), "{message}");
+ assert!(app.renderer.requests.is_empty(), "completed request identity is released");
+ std::fs::remove_file(replacement).unwrap();
+ }
+
+ #[test]
+ fn grid_queued_standin_changes_priority_without_restarting() {
+ let mut s = Session::new();
+ s.media.preview_loader = Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));
+ let mut raw = (*photo()).clone();
+ raw.kind = lightcraft_catalog::MediaKind::Raw;
+ raw.develop = Arc::new(raw.camera_defaults());
+ let (mut app, work, ctx) = fixture_with(s, raw);
+ app.renderer.pool = JobPool::new(0); // deterministic: no quick job starts until run_inline
+ let id = PhotoId(1);
+ let slot = Slot::ThumbQuick(id);
+
+ crate::panels::grid::request_thumb(&mut app, id, 384, 5);
+ let request_id = app.renderer.requests[&slot].id;
+ assert_eq!(app.renderer.pending[&slot].1, 6);
+ assert_eq!(app.renderer.pool.queued(), 1);
+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);
+ assert_eq!(app.renderer.pending[&slot].1, 11, "the grid must promote its queued stand-in");
+ assert_eq!(app.renderer.requests[&slot].id, request_id);
+ assert_eq!(app.renderer.pool.queued(), 1);
+
+ crate::panels::grid::request_thumb(&mut app, id, 384, 5);
+ assert_eq!(app.renderer.pending[&slot].1, 6, "the grid must demote its queued stand-in");
+ assert_eq!(app.renderer.requests[&slot].id, request_id);
+ assert_eq!(app.renderer.pool.queued(), 1);
+ let built = app.renderer.thumb_jobs_built;
+ app.renderer.pool.run_inline(1);
+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);
+ assert_eq!(app.renderer.pending[&slot].1, 6, "completed work must not be restarted");
+ assert_eq!(app.renderer.requests[&slot].id, request_id);
+ assert_eq!(app.renderer.pool.queued(), 0);
+ app.renderer.poll(&ctx, &mut app.session);
+ assert_eq!(app.renderer.textures[&slot].quick, Some(QuickSource::Embedded));
+
+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);
+ crate::panels::grid::request_thumb(&mut app, id, 384, 5);
+ assert_eq!(app.renderer.thumb_jobs_built, built);
+ assert_eq!(app.renderer.pool.queued(), 0);
+ assert!(!app.renderer.is_pending(Slot::Thumb(id)));
+ assert!(!app.renderer.textures.contains_key(&Slot::Thumb(id)));
+ assert!(work.borrow().jobs.is_empty(), "the final embedded thumbnail needs no real render");
+ }
+
+ #[test]
+ fn unchanged_ready_and_running_frames_build_no_jobs() {
+ let (mut app, work, ctx) = fixture();
+ request(&mut app);
+ assert_eq!(app.renderer.thumb_jobs_built, 1);
+ for _ in 0..180 {
+ request(&mut app);
+ }
+ assert_eq!(app.renderer.thumb_jobs_built, 1);
+ let (slot, job) = take_job(&work);
+ finish(&mut app, &work, &ctx, slot, job.run());
+ for _ in 0..180 {
+ request(&mut app);
+ }
+ assert_eq!(app.renderer.thumb_jobs_built, 1);
+ assert!(work.borrow().jobs.is_empty());
+ }
+
+ #[test]
+ fn a_slider_drag_leaves_the_edited_photos_thumbnail_until_it_ends() {
+ let (mut app, work, ctx) = fixture();
+ request(&mut app);
+ let (slot, job) = take_job(&work);
+ finish(&mut app, &work, &ctx, slot, job.run());
+ app.session.execute("library.select", &serde_json::json!({"ids": [1], "active": 1})).unwrap();
+ app.session.execute("develop.beginInteraction", &serde_json::json!({"label": "Exposure"})).unwrap();
+ for v in [0.1, 0.2, 0.3] {
+ app.session.execute("develop.set", &serde_json::json!({"control": "light.exposure", "value": v})).unwrap();
+ app.renderer.poll(&ctx, &mut app.session);
+ request(&mut app);
+ }
+ assert_eq!(app.renderer.thumb_jobs_built, 1, "the drag's frames render no thumbnail of the photo");
+ assert!(work.borrow().jobs.is_empty());
+ app.session.execute("develop.endInteraction", &serde_json::json!({})).unwrap();
+ request(&mut app);
+ assert_eq!(app.renderer.thumb_jobs_built, 2, "the thumbnail follows once the drag ends");
+ }
+
+ #[test]
+ fn unchanged_queued_frames_build_no_jobs() {
+ let (mut app, _, _) = fixture();
+ app.renderer.set_offload(Box::new(Blocked));
+ request(&mut app);
+ for _ in 0..180 {
+ request(&mut app);
+ }
+ assert_eq!(app.renderer.thumb_jobs_built, 1);
+ assert_eq!(app.renderer.queue.len(), 1);
+ }
+
+ #[test]
+ fn resizing_the_disk_cache_keeps_textures_and_skips_rebuilds() {
+ let lib = std::env::temp_dir().join(format!("lc-ui-thumb-resize-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&lib);
+ let mut s = Session::new().with_fs();
+ s.open_library(&lib, false).unwrap();
+ let (mut app, work, ctx) = fixture_with(s, (*photo()).clone());
+ request(&mut app);
+ let (slot, job) = take_job(&work);
+ finish(&mut app, &work, &ctx, slot, job.run());
+ assert!(app.renderer.thumb(PhotoId(1)).is_some());
+ let cache = app.session.media.rendered.clone();
+ app.session.execute("library.preferences", &serde_json::json!({"cacheMb": 300})).unwrap();
+ app.renderer.poll(&ctx, &mut app.session);
+ // thumbnails are keyed by content: a new budget leaves them (and the cache) valid
+ assert!(app.renderer.thumb(PhotoId(1)).is_some());
+ assert!(Arc::ptr_eq(&cache, &app.session.media.rendered));
+ for _ in 0..30 {
+ request(&mut app);
+ }
+ assert_eq!(app.renderer.thumb_jobs_built, 1);
+ assert!(work.borrow().jobs.is_empty());
+ // an explicit clear still drops them
+ app.session.execute("library.clearPreviews", &serde_json::json!({})).unwrap();
+ app.renderer.poll(&ctx, &mut app.session);
+ assert!(app.renderer.thumb(PhotoId(1)).is_none());
+ drop(app);
+ let _ = std::fs::remove_dir_all(&lib);
+ }
+
+ /// A render that panics (a decoder bug) is a failure like any other: the slot stops waiting,
+ /// the error is kept (not retried every frame), and the pool's workers live on. Before, the
+ /// worker died without an answer and the slot stayed pending forever.
+ #[test]
+ fn a_panicking_render_is_a_failure_not_a_dead_worker() {
+ let (mut app, _, ctx) = fixture_with(Session::new(), (*photo()).clone());
+ app.session.media.file_loader = Some(Arc::new(|_, _| panic!("decoder bug")));
+ app.renderer.offload = None; // the real job pool
+ let slot = Slot::Thumb(PhotoId(1));
+ let ask = |app: &mut crate::LightcraftApp| {
+ if let Some(job) = app.session.thumb_job(PhotoId(1), 256) {
+ app.renderer.request(slot, job, 30);
+ }
+ app.renderer.poll(&ctx, &mut app.session);
+ };
+ ask(&mut app);
+ let t0 = std::time::Instant::now();
+ while app.renderer.is_pending(slot) {
+ assert!(t0.elapsed() < std::time::Duration::from_secs(20), "the render never answered");
+ std::thread::sleep(std::time::Duration::from_millis(5));
+ app.renderer.poll(&ctx, &mut app.session);
+ }
+ assert_eq!(app.renderer.failure(slot), Some("the render failed unexpectedly: decoder bug"));
+ let workers = app.renderer.live_workers();
+ assert!(workers > 0, "the worker that panicked is still there");
+ let done = app.renderer.completed;
+ for _ in 0..30 {
+ ask(&mut app);
+ }
+ assert!(!app.renderer.is_pending(slot) && app.renderer.completed == done, "no retry loop");
+ assert_eq!(app.renderer.live_workers(), workers);
+ }
+
+ #[test]
+ fn raw_quick_path_frames_build_no_jobs() {
+ // an unedited raw: the grid shows its embedded preview (held here until released) and stops
+ // there — the camera JPEG at 4 416 × 2 944 already covers a 512 px thumbnail, so decoding the
+ // whole raw behind it only costs the file read (45 s a photo on a 1.2 MB/s share)
+ let gate = Arc::new(std::sync::Mutex::new(()));
+ let held = gate.lock().unwrap();
+ let mut s = Session::new();
+ let g = gate.clone();
+ s.media.preview_loader = Some(Arc::new(move |_: &str, _| {
+ drop(g.lock().unwrap_or_else(std::sync::PoisonError::into_inner));
+ Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })
+ }));
+ let mut raw = (*photo()).clone();
+ raw.kind = lightcraft_catalog::MediaKind::Raw;
+ raw.develop = Arc::new(raw.camera_defaults());
+ let (mut app, _, ctx) = fixture_with(s, raw);
+ app.renderer.set_offload(Box::new(Blocked));
+ let quick = Slot::ThumbQuick(PhotoId(1));
+ // the stand-in is running
+ for _ in 0..180 {
+ request(&mut app);
+ }
+ assert!(app.renderer.is_pending(quick));
+ assert_eq!(app.renderer.thumb_jobs_built, 1);
+ drop(held);
+ let t0 = std::time::Instant::now();
+ while !app.renderer.textures.contains_key(&quick) {
+ assert!(t0.elapsed() < std::time::Duration::from_secs(20), "the embedded preview never arrived");
+ std::thread::sleep(std::time::Duration::from_millis(5));
+ app.renderer.poll(&ctx, &mut app.session);
+ }
+ // the embedded preview is the thumbnail: no real render is queued behind it, and the grid
+ // asking every frame neither rebuilds the job nor re-requests the preview
+ for _ in 0..180 {
+ request(&mut app);
+ }
+ assert_eq!(app.renderer.thumb_jobs_built, 1, "an unedited raw's embedded preview is the thumbnail");
+ assert!(app.renderer.queue.is_empty(), "nothing is decoded behind it");
+ assert!(!app.renderer.is_pending(Slot::Thumb(PhotoId(1))));
+
+ // an edit takes the embedded preview out of the picture: the real thumbnail is rendered then
+ let mut edited = (*photo()).clone();
+ edited.kind = lightcraft_catalog::MediaKind::Raw;
+ edited.develop = Arc::new({
+ let mut d = edited.camera_defaults();
+ d.light.exposure = 0.5;
+ d
+ });
+ let (mut app, _, _ctx) = fixture_with(Session::new(), edited);
+ app.renderer.set_offload(Box::new(Blocked));
+ for _ in 0..180 {
+ request(&mut app);
+ }
+ assert_eq!(app.renderer.thumb_jobs_built, 1);
+ assert!(app.renderer.is_pending(Slot::Thumb(PhotoId(1))) || !app.renderer.queue.is_empty(), "an edited raw renders its thumbnail");
+ }
+
+ #[test]
+ fn closing_import_review_cancels_queued_and_running_identities() {
+ let (mut app, work, ctx) = fixture();
+ let job = app.session.thumb_job(PhotoId(1), 256).unwrap();
+ app.renderer.request(Slot::Import(0), job.clone(), 10);
+ let (slot, running) = take_job(&work);
+ app.renderer.set_offload(Box::new(Blocked));
+ app.renderer.request(Slot::Import(1), job, 10);
+ app.renderer.forget_imports();
+ assert!(!app.renderer.is_pending(Slot::Import(0)));
+ assert!(!app.renderer.is_pending(Slot::Import(1)));
+ assert!(app.renderer.queue.is_empty());
+ work.borrow_mut().finished.push((slot, running.run(), 0.0));
+ app.renderer.set_offload(Box::new(Manual(work.clone())));
+ app.renderer.poll(&ctx, &mut app.session);
+ assert!(!app.renderer.textures.contains_key(&slot));
+ assert_eq!(app.session.media.source_usage().0, 0);
+ }
+
+ #[test]
+ fn loupe_shows_superseded_drafts_newer_than_its_pixels_during_a_drag() {
+ let (mut app, work, ctx) = fixture();
+ let mut jobs = Vec::new();
+ for exposure in [0.0, 1.0, 2.0] {
+ let mut edit = lightcraft_develop::DevelopSettings::default();
+ edit.light.exposure = exposure;
+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "drag".into(), edited: None }).unwrap();
+ let job = app.session.loupe_job(PhotoId(1), 8, 8, true).unwrap().draft();
+ app.renderer.request(Slot::Main, job, 100);
+ jobs.push(take_job(&work).1);
+ }
+ let keys: Vec<u64> = jobs.iter().map(|j| j.key).collect();
+ let mut jobs = jobs.into_iter();
+ let (first, second, last) = (jobs.next().unwrap(), jobs.next().unwrap(), jobs.next().unwrap());
+ // the first draft lands while the newest is still rendering: the loupe moves on
+ finish(&mut app, &work, &ctx, Slot::Main, first.run());
+ assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[0]));
+ assert!(app.renderer.is_pending(Slot::Main));
+ finish(&mut app, &work, &ctx, Slot::Main, last.run());
+ assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[2]));
+ // a draft older than the pixels shown never replaces them
+ finish(&mut app, &work, &ctx, Slot::Main, second.run());
+ assert_eq!(app.renderer.textures.get(&Slot::Main).map(|t| t.key), Some(keys[2]));
+ assert!(!app.renderer.is_pending(Slot::Main));
+ }
+
+ #[test]
+ fn a_drag_gets_its_live_hdr_histogram_beside_the_drafts() {
+ let (mut app, work, ctx) = fixture();
+ let mut jobs = Vec::new();
+ for exposure in [1.0, 2.0] {
+ let mut edit = lightcraft_develop::DevelopSettings::default();
+ edit.hdr.enabled = true;
+ edit.light.exposure = exposure;
+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "drag".into(), edited: None }).unwrap();
+ let job = app.session.render_job(PhotoId(1), 32, 32, false, true).unwrap();
+ app.renderer.request(Slot::HdrHistogram, job, 95);
+ jobs.push(take_job(&work).1);
+ }
+ let keys: Vec<u64> = jobs.iter().map(|j| j.key).collect();
+ let mut jobs = jobs.into_iter();
+ let (first, last) = (jobs.next().unwrap(), jobs.next().unwrap());
+ // superseded while the drag goes on, it still lands: the histogram keeps moving
+ finish(&mut app, &work, &ctx, Slot::HdrHistogram, first.run());
+ let live = app.renderer.live_hdr_histogram.clone().expect("a live HDR histogram");
+ assert_eq!((live.0, live.1), (PhotoId(1), keys[0]));
+ assert!(live.2.hdr.is_some(), "HDR bins");
+ finish(&mut app, &work, &ctx, Slot::HdrHistogram, last.run());
+ assert_eq!(app.renderer.live_hdr_histogram.as_ref().map(|l| l.1), Some(keys[1]));
+ // only the histogram is kept: no texture
+ assert!(!app.renderer.textures.contains_key(&Slot::HdrHistogram));
+ }
+
+ #[test]
+ fn library_reset_rejects_old_job_even_when_photo_id_and_key_are_reused() {
+ let (mut app, work, ctx) = fixture();
+ request(&mut app);
+ let (slot, old) = take_job(&work);
+ let old_result = old.run();
+ app.renderer.forget_all();
+ let photo = app.session.catalog.photo(PhotoId(1)).unwrap().as_ref().clone();
+ app.session = lightcraft_engine::Session::new();
+ app.session.catalog.apply(Op::AddPhoto { photo: Box::new(photo) }).unwrap();
+ app.session.media.file_loader = Some(Arc::new(|_, _| {
+ let mut image = lightcraft_raster::Rgb32f::new(8, 8);
+ image.data.fill([0.1, 0.2, 0.9]);
+ Ok((image, Default::default()))
+ }));
+ app.renderer.poll(&ctx, &mut app.session);
+ request(&mut app);
+ let (_, new) = take_job(&work);
+ assert_eq!(old_result.key, new.key);
+ assert_ne!(old_result.request_id, new.request_id);
+ let expected = new.clone().run().rendered.unwrap().image.as_bytes();
+ finish(&mut app, &work, &ctx, slot, new.run());
+ finish(&mut app, &work, &ctx, slot, old_result);
+ assert_eq!(
+ app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),
+ expected
+ );
+ }
+
+ #[test]
+ fn late_results_and_errors_cannot_replace_newest_pixels_or_sources() {
+ for order in [0, 1, 2] {
+ let (mut app, work, ctx) = fixture();
+ request(&mut app);
+ let (slot, old) = take_job(&work);
+ let mut edit = lightcraft_develop::DevelopSettings::default();
+ edit.light.exposure = 1.0;
+ app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "edit".into(), edited: None }).unwrap();
+ request(&mut app);
+ let (_, new) = take_job(&work);
+ let expected = new.clone().run().rendered.unwrap().image.as_bytes();
+ if order != 0 {
+ finish(&mut app, &work, &ctx, slot, new.run());
+ // An obsolete source and error must not poison the current successful request.
+ let mut stale = old.run();
+ if order == 2 {
+ stale.rendered = Err("old failure".into());
+ }
+ finish(&mut app, &work, &ctx, slot, stale);
+ } else {
+ finish(&mut app, &work, &ctx, slot, old.run());
+ assert!(app.renderer.thumb(PhotoId(1)).is_none());
+ assert_eq!(app.session.media.source_usage().0, 0);
+ finish(&mut app, &work, &ctx, slot, new.run());
+ }
+ assert_eq!(
+ app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),
+ expected
+ );
+ assert!(app.renderer.failure(slot).is_none());
+ }
+ }
+
+ #[test]
+ fn undo_to_existing_texture_supersedes_pending_edit() {
+ let (mut app, work, ctx) = fixture();
+ request(&mut app);
+ let (slot, first) = take_job(&work);
+ let key = first.key;
+ finish(&mut app, &work, &ctx, slot, first.run());
+ let original = app.renderer.thumb(PhotoId(1)).unwrap().pixels.clone().unwrap();
+ let mut edit = lightcraft_develop::DevelopSettings::default();
+ edit.light.exposure = 1.0;
+ let undo = app.session.catalog.apply(Op::SetDevelop { id: PhotoId(1), settings: Arc::new(edit), label: "edit".into(), edited: None }).unwrap();
+ request(&mut app);
+ let (_, edited) = take_job(&work);
+ app.session.catalog.apply(undo).unwrap();
+ request(&mut app);
+ let (_, restored) = take_job(&work);
+ assert_eq!(restored.key, key);
+ finish(&mut app, &work, &ctx, slot, restored.run());
+ finish(&mut app, &work, &ctx, slot, edited.run());
+ assert_eq!(app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels, original.pixels);
+ }
+
+ #[test]
+ fn explicit_clear_repairs_same_key_bad_pixels_and_rejects_old_same_key_job() {
+ let (mut app, work, ctx) = fixture();
+ let job = app.session.thumb_job(PhotoId(1), 256).unwrap();
+ let expected = job.clone().run().rendered.unwrap().image;
+ let (cache, key) = job.cache.clone().unwrap();
+ let mut bad = expected.clone();
+ bad.data.fill([255, 0, 255, 255]);
+ cache.put(key, Arc::new(bad.clone()));
+ request(&mut app);
+ let (slot, corrupt) = take_job(&work);
+ finish(&mut app, &work, &ctx, slot, corrupt.run());
+ assert_eq!(app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels[0].to_array(), [255, 0, 255, 255]);
+ // An old job can have the SAME render key and stale decoded pixels.
+ let mut old = job.clone();
+ old.source = lightcraft_engine::media::SourceRef::Loaded(Box::new(lightcraft_engine::media::DecodedSource::new(
+ Arc::new(lightcraft_raster::Rgb32f::new(8, 8)),
+ None,
+ )));
+ app.renderer.textures.clear();
+ app.renderer.request(slot, old, 10);
+ let (_, old) = take_job(&work);
+ app.session.execute("library.clearPreviews", &serde_json::json!({})).unwrap();
+ app.renderer.poll(&ctx, &mut app.session);
+ assert!(app.renderer.thumb(PhotoId(1)).is_none());
+ request(&mut app);
+ let (_, repaired) = take_job(&work);
+ assert_eq!(repaired.key, job.key);
+ finish(&mut app, &work, &ctx, slot, repaired.run());
+ finish(&mut app, &work, &ctx, slot, old.run());
+ assert_eq!(cache.get(key).unwrap().as_bytes(), expected.as_bytes());
+ assert_eq!(
+ app.renderer.thumb(PhotoId(1)).unwrap().pixels.as_ref().unwrap().pixels.iter().flat_map(|c| c.to_array()).collect::<Vec<_>>(),
+ expected.as_bytes()
+ );
+ }
+
+ #[test]
+ fn undo_to_embedded_thumb_rejects_late_full_render() {
+ let mut s = Session::new();
+ s.media.preview_loader = Some(Arc::new(|_, _| Some(lightcraft_raster::Rgba8 { width: 4, height: 4, data: vec![[200, 100, 50, 255]; 16] })));
+ let mut raw = (*photo()).clone();
+ raw.kind = lightcraft_catalog::MediaKind::Raw;
+ raw.develop = Arc::new(raw.camera_defaults());
+ let (mut app, work, ctx) = fixture_with(s, raw);
+ app.renderer.pool = JobPool::new(0);
+ let id = PhotoId(1);
+ let quick_slot = Slot::ThumbQuick(id);
+ let full_slot = Slot::Thumb(id);
+ let settings_a = app.session.catalog.photo(id).unwrap().develop.clone();
+
+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);
+ assert_eq!(app.renderer.pool.run_inline(1), 1);
+ app.renderer.poll(&ctx, &mut app.session);
+ let (key_a, pixels_a) = {
+ let shown = app.renderer.thumb(id).unwrap();
+ assert_eq!(shown.quick, Some(QuickSource::Embedded));
+ (shown.key, shown.pixels.as_ref().unwrap().pixels.clone())
+ };
+ assert!(app.renderer.textures.contains_key(&quick_slot));
+ assert!(!app.renderer.textures.contains_key(&full_slot));
+ assert!(work.borrow().jobs.is_empty());
+
+ let mut settings_b = (*settings_a).clone();
+ settings_b.light.exposure += 0.5;
+ app.session.commit("Exposure", Op::SetDevelop { id, settings: Arc::new(settings_b), label: "Exposure".into(), edited: None }).unwrap();
+ assert!(!app.session.embedded_thumb_is_final(app.session.catalog.photo(id).unwrap()));
+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);
+ // Manual owns dispatched jobs: hold B until the real Undo command restores A.
+ let (slot, held_b) = take_job(&work);
+ assert_eq!(slot, full_slot);
+ let key_b = held_b.key;
+ assert_ne!(key_b, key_a);
+ assert!(app.renderer.is_pending(full_slot));
+
+ app.run("edit.undo", serde_json::json!({})).unwrap();
+ assert_eq!(app.session.catalog.photo(id).unwrap().develop.as_ref(), settings_a.as_ref());
+ assert!(app.session.embedded_thumb_is_final(app.session.catalog.photo(id).unwrap()));
+ crate::panels::grid::request_thumb(&mut app, id, 384, 10);
+ {
+ let restored = app.renderer.thumb(id).unwrap();
+ assert_eq!(restored.key, key_a);
+ assert_eq!(restored.pixels.as_ref().unwrap().pixels, pixels_a);
+ assert_eq!(restored.quick, Some(QuickSource::Embedded));
+ }
+ assert!(work.borrow().jobs.is_empty(), "restoring embedded-final A needs no full render");
+ assert_eq!(app.renderer.pool.queued(), 0);
+
+ let result_b = held_b.run();
+ assert_eq!(result_b.key, key_b);
+ let rendered_b = result_b.rendered.as_ref().expect("held edited thumbnail must render before the stale-result oracle");
+ assert_ne!(color_image(&rendered_b.image).pixels, pixels_a, "the held result must be distinguishable from A");
+ finish(&mut app, &work, &ctx, slot, result_b);
+
+ let shown = app.renderer.thumb(id).unwrap();
+ assert_eq!(shown.key, key_a, "late edited Thumb(B) must not replace restored embedded ThumbQuick(A)");
+ assert_eq!(shown.pixels.as_ref().unwrap().pixels, pixels_a);
+ assert_eq!(shown.quick, Some(QuickSource::Embedded));
+ let quick = app.renderer.textures.get(&quick_slot).expect("the correct embedded thumbnail must remain installed");
+ assert_eq!(quick.key, key_a);
+ assert_eq!(quick.quick, Some(QuickSource::Embedded));
+ assert_eq!(quick.pixels.as_ref().unwrap().pixels, pixels_a);
+ assert!(!app.renderer.is_pending(full_slot));
+ }