use std::{
collections::HashMap,
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
time::Duration,
};
use parking_lot::{Condvar, Mutex};
use super::{ImageDecodeError, ImageKey, ImageLoadState, ImageSizeCap, ImageSource, decode_image, worker::Workers};
use crate::{app::window::WindowWaker, images::ImageData};
pub const DEFAULT_BUDGET_BYTES: usize = 128 * 1024 * 1024;
const WORKER_COUNT: usize = 2;
type CacheKey = (ImageKey, Option<ImageSizeCap>);
struct Entry {
state: ImageLoadState,
bytes: usize,
last_used: u64,
wakers: Vec<WindowWaker>,
}
struct Inner {
entries: HashMap<CacheKey, Entry>,
pending: usize,
budget: usize,
used: usize,
clock: u64,
}
struct FinishOnDrop {
shared: Arc<Shared>,
cache_key: CacheKey,
result: Option<Result<ImageData, ImageDecodeError>>,
}
impl Drop for FinishOnDrop {
fn drop(&mut self) {
let result = self.result.take().unwrap_or_else(|| {
let said = "the image decode did not run: the decoder panicked or no worker took the job";
Err(ImageDecodeError::new(
said,
crate::core::PictureError::Other(Arc::from(said)),
))
});
self.shared.finish(self.cache_key, result);
}
}
pub struct DecodedImages {
shared: Arc<Shared>,
}
struct Shared {
inner: Mutex<Inner>,
idle: Condvar,
workers: Workers,
completed: AtomicU64,
}
impl Default for DecodedImages {
fn default() -> Self {
Self::new()
}
}
impl DecodedImages {
pub fn new() -> Self {
Self {
shared: Arc::new(Shared {
inner: Mutex::new(Inner {
entries: HashMap::new(),
pending: 0,
budget: DEFAULT_BUDGET_BYTES,
used: 0,
clock: 0,
}),
idle: Condvar::new(),
workers: Workers::new(WORKER_COUNT),
completed: AtomicU64::new(0),
}),
}
}
pub fn load(
&self,
key: ImageKey,
cap: Option<ImageSizeCap>,
source: impl FnOnce() -> ImageSource,
wake: Option<WindowWaker>,
) -> ImageLoadState {
#[cfg(target_arch = "wasm32")]
return self.load_in_browser(key, cap, source, wake);
#[cfg(not(target_arch = "wasm32"))]
self.load_with(key, cap, wake, || {
let source = source();
move || decode_image(&source, cap)
})
}
#[cfg(target_arch = "wasm32")]
fn load_in_browser(
&self,
key: ImageKey,
cap: Option<ImageSizeCap>,
source: impl FnOnce() -> ImageSource,
wake: Option<WindowWaker>,
) -> ImageLoadState {
let mut finish = match self.begin(key, cap, wake) {
Ok(finish) => finish,
Err(state) => return state,
};
let source = source();
wasm_bindgen_futures::spawn_local(async move {
let decoded = match &source {
ImageSource::Bytes(bytes) if super::browser_decodes(bytes) => super::web_decode::decode(bytes, cap).await,
_ => None,
};
finish.result = Some(match decoded {
Some(decoded) => Ok(decoded),
None => decode_image(&source, cap),
});
drop(finish);
});
ImageLoadState::Loading
}
pub(super) fn load_with<J>(
&self,
key: ImageKey,
cap: Option<ImageSizeCap>,
wake: Option<WindowWaker>,
decode: impl FnOnce() -> J,
) -> ImageLoadState
where
J: FnOnce() -> Result<ImageData, ImageDecodeError> + Send + 'static,
{
let mut finish = match self.begin(key, cap, wake) {
Ok(finish) => finish,
Err(state) => return state,
};
let job = decode();
self.shared.workers.submit(move || {
finish.result = Some(job());
drop(finish);
});
ImageLoadState::Loading
}
fn begin(
&self,
key: ImageKey,
cap: Option<ImageSizeCap>,
wake: Option<WindowWaker>,
) -> Result<FinishOnDrop, ImageLoadState> {
let cache_key = (key, cap);
let mut inner = self.shared.inner.lock();
inner.clock += 1;
let clock = inner.clock;
if let Some(entry) = inner.entries.get_mut(&cache_key) {
entry.last_used = clock;
if let (ImageLoadState::Loading, Some(wake)) = (&entry.state, wake)
&& !entry.wakers.iter().any(|known| Arc::ptr_eq(known, &wake))
{
entry.wakers.push(wake);
}
return Err(entry.state.clone());
}
inner.entries.insert(
cache_key,
Entry {
state: ImageLoadState::Loading,
bytes: 0,
last_used: clock,
wakers: wake.into_iter().collect(),
},
);
inner.pending += 1;
drop(inner);
Ok(FinishOnDrop {
shared: Arc::clone(&self.shared),
cache_key,
result: None,
})
}
#[cfg(test)]
pub(super) fn without_workers() -> Self {
Self {
shared: Arc::new(Shared {
inner: Mutex::new(Inner {
entries: HashMap::new(),
pending: 0,
budget: DEFAULT_BUDGET_BYTES,
used: 0,
clock: 0,
}),
idle: Condvar::new(),
workers: Workers::closed(),
completed: AtomicU64::new(0),
}),
}
}
pub fn state(&self, key: ImageKey, cap: Option<ImageSizeCap>) -> Option<ImageLoadState> {
self
.shared
.inner
.lock()
.entries
.get(&(key, cap))
.map(|entry| entry.state.clone())
}
pub fn insert(&self, key: ImageKey, cap: Option<ImageSizeCap>, data: ImageData) {
let bytes = rgba_bytes(&data);
let wakers = {
let mut inner = self.shared.inner.lock();
inner.clock += 1;
let last_used = inner.clock;
let mut wakers = Vec::new();
if let Some(old) = inner.entries.insert(
(key, cap),
Entry {
state: ImageLoadState::Ready(data),
bytes,
last_used,
wakers: Vec::new(),
},
) {
inner.used -= old.bytes;
wakers = old.wakers;
}
inner.used += bytes;
evict(&mut inner, Some((key, cap)));
wakers
};
for wake in wakers {
wake();
}
}
pub fn forget(&self, key: ImageKey, cap: Option<ImageSizeCap>) -> bool {
let forgotten = {
let mut inner = self.shared.inner.lock();
match inner.entries.get(&(key, cap)) {
Some(entry) if !entry.state.is_loading() => {
let bytes = entry.bytes;
inner.entries.remove(&(key, cap));
inner.used -= bytes;
true
}
_ => false,
}
};
if forgotten {
crate::app::runtime::note_loading_image_built();
}
forgotten
}
pub fn pending(&self) -> usize {
self.shared.inner.lock().pending
}
pub fn completed(&self) -> u64 {
self.shared.completed.load(Ordering::Acquire)
}
#[cfg(not(target_arch = "wasm32"))]
pub fn wait_idle(&self, timeout: Duration) -> bool {
let deadline = std::time::Instant::now() + timeout;
let mut inner = self.shared.inner.lock();
while inner.pending > 0 {
if self.shared.idle.wait_until(&mut inner, deadline).timed_out() {
return inner.pending == 0;
}
}
true
}
#[cfg(target_arch = "wasm32")]
pub fn wait_idle(&self, _timeout: Duration) -> bool {
self.pending() == 0
}
pub fn budget(&self) -> usize {
self.shared.inner.lock().budget
}
pub fn set_budget(&self, bytes: usize) {
let mut inner = self.shared.inner.lock();
inner.budget = bytes;
evict(&mut inner, None);
}
pub fn used_bytes(&self) -> usize {
self.shared.inner.lock().used
}
pub fn clear(&self) {
let mut inner = self.shared.inner.lock();
inner.entries.retain(|_, entry| entry.state.is_loading());
inner.used = 0;
}
}
impl Shared {
fn finish(&self, cache_key: CacheKey, result: Result<ImageData, ImageDecodeError>) {
let wakers = {
let mut inner = self.inner.lock();
inner.clock += 1;
let clock = inner.clock;
match inner.entries.get_mut(&cache_key) {
Some(entry) if entry.state.is_loading() => {
let bytes = result.as_ref().map(rgba_bytes).unwrap_or(0);
entry.bytes = bytes;
entry.last_used = clock;
entry.state = match result {
Ok(data) => ImageLoadState::Ready(data),
Err(error) => ImageLoadState::Failed(Arc::new(error)),
};
let wakers = std::mem::take(&mut entry.wakers);
inner.used += bytes;
evict(&mut inner, Some(cache_key));
wakers
}
_ => Vec::new(),
}
};
for wake in wakers {
wake();
}
let mut inner = self.inner.lock();
inner.pending = inner.pending.saturating_sub(1);
self.completed.fetch_add(1, Ordering::AcqRel);
self.idle.notify_all();
}
}
fn evict(inner: &mut Inner, keep: Option<CacheKey>) {
while inner.used > inner.budget {
let victim = inner
.entries
.iter()
.filter(|(key, entry)| Some(**key) != keep && matches!(entry.state, ImageLoadState::Ready(_)))
.min_by_key(|(_, entry)| entry.last_used)
.map(|(key, _)| *key);
let Some(victim) = victim else {
return;
};
if let Some(entry) = inner.entries.remove(&victim) {
inner.used -= entry.bytes;
}
}
}
fn rgba_bytes(data: &ImageData) -> usize {
(data.width() as usize) * (data.height() as usize) * 4
}