Skip to content

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

Merge branch 'worktree-agent-a69dcec0f0c61bc39'

Brandon Thomas9886d4982365
diff --cc apps/lightcraft-web/src/bench.rs
index 90b85af84,efbb71e9c..b1b976bfa
--- a/apps/lightcraft-web/src/bench.rs
+++ b/apps/lightcraft-web/src/bench.rs
@@@ -65,10 -65,10 +65,10 @@@ impl Bench
if self.first_frame_ms.is_none() && self.frames > 1 {
self.first_frame_ms = Some(now - self.start_ms);
}
- let idle = app.renderer.queued() == 0;
+ let idle = app.renderer.queued() == 0 && app.renderer.in_flight() == 0;
match self.phase {
Phase::Idle => {
- let thumbs = app.renderer.textures.keys().filter(|s| matches!(s, Slot::Thumb(_))).count();
+ let thumbs = app.renderer.textures.keys().filter(|s| matches!(s, Slot::Thumb(_) | Slot::ThumbQuick(_))).count();
if idle && thumbs > 0 && self.frames > 3 {
self.thumbs_done_ms = Some(now - self.start_ms);
let first = app.session.visible().first().copied();
diff --cc apps/lightcraft-web/src/workers.rs
index 27539f23d,000000000..9f282c164
mode 100644,000000..100644
--- a/apps/lightcraft-web/src/workers.rs
+++ b/apps/lightcraft-web/src/workers.rs
@@@ -1,392 -1,0 +1,399 @@@
+//! Render workers: dedicated Web Workers, each running a second instance of this wasm module
+//! (`worker.js` → [`worker_main`]). The main thread compiles the module once and posts the
+//! compiled `WebAssembly.Module` to every worker, so a worker starts in a few milliseconds.
+//!
+//! This doesn't need wasm threads (shared memory, `+atomics`, a nightly `build-std`), only
+//! module workers: the main thread posts a [`WireJob`] as JSON, the worker renders it and
+//! transfers the RGBA bytes back (no copy across the boundary).
+//!
+//! Main side: [`Workers`] implements the UI's [`RenderOffload`]: one job per worker at a time,
+//! with affinity (a photo goes back to the worker that already decoded it), the rendered-
+//! thumbnail memory cache checked before dispatch, and the thumbnail storage index
+//! ([`ThumbIndex`]) kept and pruned here. If no worker comes up, jobs run inline.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use js_sys::{Array, Object, Reflect, Uint8Array, Uint32Array};
+use lightcraft_engine::catalog::PhotoId;
+use lightcraft_engine::media::{DISK_CACHE_BYTES, RenderJob, RenderResult, SourceLevel};
+use lightcraft_engine::pipeline::Rendered;
+use lightcraft_preview::{Hash128, PreviewCache};
+use lightcraft_raster::{Histogram, Rgba8};
+use lightcraft_ui_egui::render::{RenderOffload, Slot};
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+
+use crate::backend::Backend;
+use crate::wire::{ThumbIndex, WireJob, WorkerCore, thumb_storage_key};
+
+/// Storage key of the thumbnail index.
+pub const THUMB_INDEX: &str = "thumbs/index.json";
+
+fn set(o: &Object, k: &str, v: &JsValue) {
+ let _ = Reflect::set(o, &k.into(), v);
+}
+
+fn get(o: &JsValue, k: &str) -> JsValue {
+ Reflect::get(o, &k.into()).unwrap_or(JsValue::UNDEFINED)
+}
+
+fn now() -> f64 {
+ let perf = get(&js_sys::global(), "performance");
+ let f = get(&perf, "now");
+ f.dyn_ref::<js_sys::Function>().and_then(|f| f.call0(&perf).ok()).and_then(|v| v.as_f64()).unwrap_or(0.0)
+}
+
+// ---------------------------------------------------------------------------------------------
+// worker side
+
+thread_local! {
+ static CORE: RefCell<WorkerCore> = RefCell::new(WorkerCore::default());
+}
+
+/// Entry point of a render worker (called by `worker.js` after instantiating the module).
+/// `store` is the backend kind the page uses ("opfs", "idb" or "memory").
+#[wasm_bindgen]
+pub fn worker_main(store: String) {
+ eframe::WebLogger::init(log::LevelFilter::Info).ok();
+ let scope: web_sys::DedicatedWorkerGlobalScope = js_sys::global().unchecked_into();
+ // The main thread sends jobs only after "ready", i.e. once storage is open, and one at a time.
+ wasm_bindgen_futures::spawn_local(async move {
+ let backend = match store.as_str() {
+ "memory" => None,
+ _ => Backend::open(store == "idb").await.map_err(|e| log::warn!("render worker: no storage ({e})")).ok(),
+ };
+ let s = scope.clone();
+ let onmessage = Closure::<dyn FnMut(web_sys::MessageEvent)>::new(move |e: web_sys::MessageEvent| {
+ let (s, b) = (s.clone(), backend.clone());
+ wasm_bindgen_futures::spawn_local(async move { handle(&s, b, e.data()).await });
+ });
+ scope.set_onmessage(Some(onmessage.as_ref().unchecked_ref()));
+ onmessage.forget();
+ let ready = Object::new();
+ set(&ready, "ready", &true.into());
+ let _ = scope.post_message(&ready);
+ });
+}
+
+/// Run one job message and post the result.
+async fn handle(scope: &web_sys::DedicatedWorkerGlobalScope, backend: Option<Backend>, msg: JsValue) {
+ let id = get(&msg, "id");
+ let t0 = now();
+ let out = Object::new();
+ set(&out, "id", &id);
+ let job: Result<WireJob, String> =
+ get(&msg, "job").as_string().ok_or("no job".to_string()).and_then(|j| serde_json::from_str(&j).map_err(|e| e.to_string()));
+ let mut transfer = Array::new();
+ let result: Result<(Rendered, u32), String> = async {
+ let job = job?;
+ let mut cache_miss = false;
+ // cached thumbnail?
+ if job.thumb_cached
+ && let (Some(b), Some(key)) = (&backend, job.thumb_key())
+ {
+ match b.read(&key).await.ok().flatten().and_then(|bytes| lightcraft_preview::decode_jpeg(&bytes)) {
+ Some(image) => {
+ let histogram = Histogram::of_srgb8(&image);
+ return Ok((Rendered { image, histogram }, 0));
+ }
+ None => cache_miss = true,
+ }
+ }
+ set(&out, "cacheMiss", &cache_miss.into());
+ let original = match CORE.with(|c| c.borrow_mut().needs_original(&job)) {
+ Some(hash) => match &backend {
+ Some(b) => b.read(&crate::store::storage_key(&hash)).await?,
+ None => None,
+ },
+ None => None,
+ };
+ let rendered = CORE.with(|c| c.borrow_mut().render(&job, original.as_deref()))?;
+ let mut stored = 0;
+ if let (Some(b), Some(key)) = (&backend, job.thumb_key())
+ && let Some(jpeg) = lightcraft_preview::encode_jpeg(&rendered.image)
+ {
+ match b.write(&key, &jpeg).await {
+ Ok(()) => stored = jpeg.len() as u32,
+ Err(e) => log::warn!("thumbnail cache write: {e}"),
+ }
+ }
+ Ok((rendered, stored))
+ }
+ .await;
+ match result {
+ Ok((r, stored)) => {
+ let rgba = Uint8Array::from(r.image.as_bytes().as_ref());
+ let h = &r.histogram;
+ let hist = Uint32Array::new_with_length(4 * 256 + 1);
+ for (i, ch) in [&h.r, &h.g, &h.b, &h.luma].into_iter().enumerate() {
+ hist.subarray((i * 256) as u32, ((i + 1) * 256) as u32).copy_from(ch);
+ }
+ hist.set_index(1024, h.total);
+ set(&out, "ok", &true.into());
+ set(&out, "w", &(r.image.width as u32).into());
+ set(&out, "h", &(r.image.height as u32).into());
+ set(&out, "rgba", &rgba);
+ set(&out, "hist", &hist);
+ set(&out, "stored", &stored.into());
+ transfer = Array::of2(&rgba.buffer(), &hist.buffer());
+ }
+ Err(e) => {
+ set(&out, "ok", &false.into());
+ set(&out, "err", &e.into());
+ }
+ }
+ set(&out, "ms", &(now() - t0).into());
+ if let Err(e) = scope.post_message_with_transfer(&out, &transfer) {
+ log::error!("render worker: post: {e:?}");
+ }
+}
+
+// ---------------------------------------------------------------------------------------------
+// main side
+
+struct Busy {
+ id: u32,
+ slot: Slot,
+ photo: PhotoId,
+ level: SourceLevel,
+ key: u64,
+ cache: Option<(Arc<PreviewCache>, Hash128)>,
+}
+
+struct W {
+ worker: web_sys::Worker,
+ ready: bool,
+ dead: bool,
+ busy: Option<Busy>,
+}
+
+struct Inner {
+ workers: Vec<W>,
+ done: Vec<(Slot, RenderResult, f64)>,
+ next_id: u32,
+ /// (photo, level) → worker that last decoded it.
+ affinity: HashMap<(PhotoId, SourceLevel), usize>,
+ index: ThumbIndex,
+ backend: Option<Backend>,
+ ctx: egui::Context,
+ /// Jobs finished by workers / inline (for diagnostics).
+ remote_done: u64,
+ inline_done: u64,
+ inline_this_frame: bool,
+}
+
+/// The main thread's handle on the render workers.
+#[derive(Clone)]
+pub struct Workers(Rc<RefCell<Inner>>);
+
+impl Workers {
+ /// Start `n` workers (none: every job runs inline). `store` is the backend kind for workers.
+ pub fn start(n: usize, store: &str, backend: Option<Backend>, index: ThumbIndex, ctx: egui::Context) -> Workers {
+ let w = Workers(Rc::new(RefCell::new(Inner {
+ workers: Vec::new(),
+ done: Vec::new(),
+ next_id: 0,
+ affinity: HashMap::new(),
+ index,
+ backend,
+ ctx,
+ remote_done: 0,
+ inline_done: 0,
+ inline_this_frame: false,
+ })));
+ let module = get(&js_sys::global(), "lightcraftModule");
+ if module.is_undefined() {
+ log::warn!("render workers: no compiled module on the page (window.lightcraftModule); rendering on the main thread");
+ return w;
+ }
+ for i in 0..n {
+ let opts = web_sys::WorkerOptions::new();
+ opts.set_type(web_sys::WorkerType::Module);
+ opts.set_name(&format!("lightcraft-render-{i}"));
+ let worker = match web_sys::Worker::new_with_options("./worker.js", &opts) {
+ Ok(x) => x,
+ Err(e) => {
+ log::warn!("render worker {i}: {e:?}");
+ continue;
+ }
+ };
+ let me = w.clone();
+ let onmessage = Closure::<dyn FnMut(web_sys::MessageEvent)>::new(move |e: web_sys::MessageEvent| me.on_message(i, e.data()));
+ worker.set_onmessage(Some(onmessage.as_ref().unchecked_ref()));
+ onmessage.forget();
+ let me = w.clone();
+ let onerror = Closure::<dyn FnMut(JsValue)>::new(move |e: JsValue| me.on_error(i, e));
+ worker.set_onerror(Some(onerror.as_ref().unchecked_ref()));
+ onerror.forget();
+ let init = Object::new();
+ set(&init, "module", &module);
+ set(&init, "store", &store.into());
+ if let Err(e) = worker.post_message(&init) {
+ log::warn!("render worker {i}: {e:?}");
+ continue;
+ }
+ w.0.borrow_mut().workers.push(W { worker, ready: false, dead: false, busy: None });
+ }
+ w
+ }
+
+ fn on_error(&self, i: usize, e: JsValue) {
+ let msg = get(&e, "message").as_string().unwrap_or_else(|| format!("{e:?}"));
+ log::error!("render worker {i} failed: {msg}");
+ let mut g = self.0.borrow_mut();
+ if let Some(w) = g.workers.get_mut(i) {
+ w.dead = true;
+ w.worker.terminate();
+ if let Some(b) = w.busy.take() {
- let r = RenderResult { photo: b.photo, level: b.level, key: b.key, rendered: Err(msg), loaded: None };
++ let r = RenderResult { photo: b.photo, level: b.level, key: b.key, rendered: Err(msg), loaded: None, quick: None };
+ g.done.push((b.slot, r, 0.0));
+ }
+ }
+ g.ctx.request_repaint();
+ }
+
+ fn on_message(&self, i: usize, data: JsValue) {
+ let mut g = self.0.borrow_mut();
+ let g = &mut *g;
+ g.ctx.request_repaint();
+ let Some(w) = g.workers.get_mut(i) else { return };
+ if get(&data, "ready").is_truthy() {
+ w.ready = true;
+ return;
+ }
+ let id = get(&data, "id").as_f64().unwrap_or(-1.0) as u32;
+ let Some(b) = w.busy.take_if(|b| b.id == id) else { return };
+ let ms = get(&data, "ms").as_f64().unwrap_or(0.0);
+ let rendered = if get(&data, "ok").is_truthy() {
+ let (wd, ht) = (get(&data, "w").as_f64().unwrap_or(0.0) as usize, get(&data, "h").as_f64().unwrap_or(0.0) as usize);
+ let rgba = Uint8Array::new(&get(&data, "rgba")).to_vec();
+ let hist = Uint32Array::new(&get(&data, "hist")).to_vec();
+ match Rgba8::from_bytes(wd, ht, &rgba) {
+ Some(image) if hist.len() == 1025 => {
+ let ch = |k: usize| hist[k * 256..(k + 1) * 256].to_vec();
+ let histogram = Histogram { r: ch(0), g: ch(1), b: ch(2), luma: ch(3), total: hist[1024] };
+ Ok(Rendered { image, histogram })
+ }
+ _ => Err("render worker: bad image".to_string()),
+ }
+ } else {
+ Err(get(&data, "err").as_string().unwrap_or_else(|| "render worker failed".into()))
+ };
+ if let Ok(r) = &rendered
+ && let Some((cache, key)) = &b.cache
+ {
+ cache.put(*key, Arc::new(r.image.clone()));
+ let hex = key.to_string();
+ let stored = get(&data, "stored").as_f64().unwrap_or(0.0) as u64;
+ if get(&data, "cacheMiss").is_truthy() {
+ g.index.remove(&hex);
+ }
+ if stored > 0 {
+ g.index.insert(&hex, stored);
+ let gone = g.index.prune(DISK_CACHE_BYTES);
+ if !gone.is_empty()
+ && let Some(be) = g.backend.clone()
+ {
+ log::info!("thumbnail cache: pruning {} files", gone.len());
+ wasm_bindgen_futures::spawn_local(async move {
+ for k in gone {
+ let _ = be.remove(&thumb_storage_key(&k)).await;
+ }
+ });
+ }
+ }
+ }
+ g.affinity.insert((b.photo, b.level), i);
+ g.remote_done += 1;
- g.done.push((b.slot, RenderResult { photo: b.photo, level: b.level, key: b.key, rendered, loaded: None }, ms));
++ g.done.push((b.slot, RenderResult { photo: b.photo, level: b.level, key: b.key, rendered, loaded: None, quick: None }, ms));
+ }
+
+ /// The thumbnail index as JSON if it changed since the last call (the host saves it).
+ pub fn take_index_if_dirty(&self) -> Option<Vec<u8>> {
+ let mut g = self.0.borrow_mut();
+ if !g.index.dirty {
+ return None;
+ }
+ g.index.dirty = false;
+ Some(g.index.to_json())
+ }
+
+ /// (workers alive, workers ready, jobs done remotely, jobs done inline).
+ pub fn stats(&self) -> (usize, usize, u64, u64) {
+ let g = self.0.borrow();
+ let alive = g.workers.iter().filter(|w| !w.dead).count();
+ let ready = g.workers.iter().filter(|w| w.ready && !w.dead).count();
+ (alive, ready, g.remote_done, g.inline_done)
+ }
+}
+
+impl RenderOffload for Workers {
+ fn try_start(&mut self, slot: Slot, job: RenderJob) -> Option<RenderJob> {
+ let mut g = self.0.borrow_mut();
+ let g = &mut *g;
+ // rendered thumbnail in memory: no worker needed
+ if let Some((cache, key)) = &job.cache
+ && let Some(img) = cache.get(*key)
+ {
+ let image = Arc::unwrap_or_clone(img);
+ let histogram = Histogram::of_srgb8(&image);
- let r = RenderResult { photo: job.photo, level: job.level, key: job.key, rendered: Ok(Rendered { image, histogram }), loaded: None };
++ let r = RenderResult {
++ photo: job.photo,
++ level: job.level,
++ key: job.key,
++ rendered: Ok(Rendered { image, histogram }),
++ loaded: None,
++ quick: None,
++ };
+ g.done.push((slot, r, 0.0));
+ return None;
+ }
+ if g.workers.iter().all(|w| w.dead) {
+ // no workers: render here, one job per frame (as without workers)
+ if g.inline_this_frame {
+ return Some(job);
+ }
+ g.inline_this_frame = true;
+ let t0 = now();
+ let r = job.run();
+ g.inline_done += 1;
+ g.done.push((slot, r, now() - t0));
+ return None;
+ }
+ let free = |w: &W| w.ready && !w.dead && w.busy.is_none();
+ let pick = match g.affinity.get(&(job.photo, job.level)) {
+ // a decoded preview-level source, or the loupe's stage cache, is worth waiting for; a
+ // thumbnail isn't
+ Some(&i) if g.workers.get(i).is_some_and(free) => Some(i),
+ Some(&i) if (job.level == SourceLevel::Preview || job.stages.is_some()) && g.workers.get(i).is_some_and(|w| !w.dead) => None,
+ _ => g.workers.iter().position(free),
+ };
+ let Some(i) = pick else { return Some(job) };
+ // decided here, so the next job for this photo follows even before this one finishes
+ g.affinity.insert((job.photo, job.level), i);
+ let thumb_cached = job.cache.as_ref().is_some_and(|(_, k)| g.index.touch(&k.to_string()));
+ let wire = WireJob::from_job(&job, thumb_cached, &format!("{slot:?}"));
+ let Ok(text) = serde_json::to_string(&wire) else { return Some(job) };
+ g.next_id = g.next_id.wrapping_add(1);
+ let id = g.next_id;
+ let msg = Object::new();
+ set(&msg, "id", &id.into());
+ set(&msg, "job", &text.into());
+ let w = &mut g.workers[i];
+ if let Err(e) = w.worker.post_message(&msg) {
+ log::warn!("render worker {i}: {e:?}");
+ return Some(job);
+ }
+ w.busy = Some(Busy { id, slot, photo: job.photo, level: job.level, key: job.key, cache: job.cache });
+ None
+ }
+
+ fn finished(&mut self) -> Vec<(Slot, RenderResult, f64)> {
+ let mut g = self.0.borrow_mut();
+ g.inline_this_frame = false;
+ std::mem::take(&mut g.done)
+ }
+}
diff --cc crates/engine/src/media.rs
index 1c0a40704,e506c384b..b1b561e70
--- a/crates/engine/src/media.rs
+++ b/crates/engine/src/media.rs
@@@ -325,7 -402,59 +411,71 @@@ impl crate::Session
let k = Hasher128::new().str(&content_key(&p)).u64(settings.hash64()).u64(b as u64).u64(RENDER_CACHE_VERSION).finish();
(self.media.rendered.clone(), k)
});
- Some(RenderJob { photo: id, level, source, origin: p.source.clone(), info: source_info(&p), settings, request, key, cache, stages: None })
- Some(RenderJob { photo: id, level, source, info: source_info(&p), settings, request, key, cache, stages: None, view_cache: None })
++ Some(RenderJob {
++ photo: id,
++ level,
++ source,
++ origin: p.source.clone(),
++ info: source_info(&p),
++ settings,
++ request,
++ key,
++ cache,
++ stages: None,
++ view_cache: None,
++ })
+ }
+
+ /// 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).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)
+ }
+
+ /// 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,
+ }
+ }
+
+ /// 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 { 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. `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 {
+ photo: job.photo,
+ key: job.key,
+ cached: job.cache.clone().into_iter().collect(),
+ embedded: Some((path, l, edge)),
+ small: None,
+ })
}
/// Accept a finished job's loaded source into the cache.
diff --cc crates/ui-egui/src/render.rs
index 99815866d,e7f052f5c..3703dcb82
--- a/crates/ui-egui/src/render.rs
+++ b/crates/ui-egui/src/render.rs
@@@ -4,9 -4,13 +4,15 @@@
//! image…). Requests are deduplicated per slot (a newer request replaces a queued older one) and
//! prioritised (loupe first, then on-screen thumbnails, then prefetch); thumbnails scrolled far
//! out of view are dropped from the queue. Thumbnail jobs hit the engine's preview cache (memory +
-//! disk) before rendering. On wasm the jobs run inline, one per frame.
+//! disk) before rendering. On wasm the jobs run inline, one per frame, unless the host installs a
+//! [`RenderOffload`] (the browser build's Web Workers): then queued jobs are handed to it as it has
+//! room, and its results are collected every frame.
+ //!
+ //! Stand-ins ([`QuickJob`]s, once per photo and settings): [`Slot::Preview`] holds what the loupe
+ //! shows until [`Slot::Main`] has the photo's render (cached view render, embedded camera JPEG or
+ //! a thumbnail render); [`Slot::ThumbQuick`] holds a raw's embedded preview in the grid until its
+ //! rendered thumbnail arrives (a cached thumbnail found by the quick job becomes the
+ //! [`Slot::Thumb`] texture directly).
use std::collections::HashMap;
@@@ -131,20 -109,41 +152,53 @@@ impl Renderer
self.pool.submit(slot, key, priority, Box::new(move || job.run()));
}
+ /// Request a stand-in for `slot` (once per job key).
+ pub fn request_quick(&mut self, slot: Slot, job: QuickJob, priority: u32) {
+ if self.quick_tried.get(&slot) == Some(&job.key) {
+ return;
+ }
+ self.quick_tried.insert(slot, job.key);
+ self.pending.insert(slot, (job.key, priority));
+ let key = job.key;
+ self.pool.submit(slot, key, priority, Box::new(move || job.run()));
+ }
+
+ /// Prepare a photo in the background (a [`Slot::Prefetch`] job runs once per key; a newer one
+ /// replaces it while queued). Memory stays bounded by the engine's source caches.
+ pub fn prefetch(&mut self, slot: Slot, job: RenderJob, priority: u32) {
+ if self.prefetched.get(&slot) == Some(&job.key) {
+ return;
+ }
+ self.prefetched.insert(slot, job.key);
+ self.pending.insert(slot, (job.key, priority));
+ let key = job.key;
+ self.pool.submit(slot, key, priority, Box::new(move || job.run()));
+ }
+
+ /// Is a request for `slot` queued or running?
+ pub fn is_pending(&self, slot: Slot) -> bool {
+ self.pending.contains_key(&slot)
+ }
+
+ /// The texture to show for a grid/filmstrip thumbnail: the rendered one, else its stand-in.
+ pub fn thumb(&self, id: PhotoId) -> Option<&Tex> {
+ self.textures.get(&Slot::Thumb(id)).or_else(|| self.textures.get(&Slot::ThumbQuick(id)))
+ }
+
pub fn queued(&self) -> usize {
- self.pool.queued()
+ self.pool.queued() + self.queue.len()
+ }
+
+ /// Hand queued jobs to the offload (best first) while it has room.
+ fn dispatch(&mut self) {
+ let Some(off) = self.offload.as_mut() else { return };
+ while let Some(i) = self.queue.iter().enumerate().max_by_key(|(_, q)| (q.priority, q.seq)).map(|(i, _)| i) {
+ let q = self.queue.swap_remove(i);
+ if let Some(job) = off.try_start(q.slot, q.job) {
+ self.queue.push(Queued { job, ..q });
+ break;
+ }
+ }
}
/// Requests queued or running.
@@@ -168,16 -167,9 +222,16 @@@
};
#[cfg(not(target_arch = "wasm32"))]
let inline_ms = 0.0;
- let mut changed = false;
+ let mut finished = Vec::new();
while let Some(done) = self.pool.try_recv() {
- let (mut slot, r, ms) = (done.slot, done.result, if done.ms > 0.0 { done.ms } else { inline_ms });
+ finished.push((done.slot, done.result, if done.ms > 0.0 { done.ms } else { inline_ms }));
+ }
+ if let Some(off) = self.offload.as_mut() {
+ finished.extend(off.finished());
+ }
+ self.dispatch();
+ let mut changed = false;
- for (slot, r, ms) in finished {
++ for (mut slot, r, ms) in finished {
session.accept(&r);
self.completed += 1;
if self.pending.get(&slot).is_some_and(|p| p.0 == r.key) {
@@@ -233,16 -250,9 +312,17 @@@
});
for s in dropped {
self.pending.remove(&s);
+ self.quick_tried.remove(&s);
}
+ let pending = &mut self.pending;
+ self.queue.retain(|q| match q.slot {
+ Slot::Thumb(id) if !keep.contains(&id) && q.priority <= 10 => {
+ pending.remove(&q.slot);
+ false
+ }
+ _ => true,
+ });
- let thumbs = self.textures.keys().filter(|s| matches!(s, Slot::Thumb(_))).count();
+ let thumbs = self.thumb_textures();
if thumbs <= max {
return;
}