use std::collections::VecDeque;
use std::panic::AssertUnwindSafe;
use std::path::PathBuf;
use std::sync::{Arc, Mutex, MutexGuard};
use crabshell_ui::{Fit, ImageFilters};
use crate::animation::Frames;
pub(crate) struct Job {
pub(crate) path: PathBuf,
pub(crate) size: (u32, u32),
pub(crate) fit: Fit,
pub(crate) filters: ImageFilters,
pub(crate) scale: f32,
pub(crate) room: usize,
}
pub(crate) type Done = (u64, Result<Frames, String>);
type Wake = Box<dyn FnOnce() + Send>;
#[derive(Default)]
struct Queue {
waiting: VecDeque<(u64, Job)>,
done: Vec<Done>,
running: bool,
wake: Option<Wake>,
}
#[derive(Default)]
pub(crate) struct Worker {
queue: Arc<Mutex<Queue>>,
next: u64,
}
impl Worker {
pub(crate) fn send(&mut self, job: Job) -> u64 {
self.next += 1;
let number = self.next;
let start = {
let mut queue = lock(&self.queue);
queue.waiting.push_back((number, job));
!std::mem::replace(&mut queue.running, true)
};
if start {
let queue = Arc::clone(&self.queue);
let spawned = std::thread::Builder::new()
.name(String::from("decode"))
.spawn(move || work(&queue));
if let Err(error) = spawned {
tracing::warn!(%error, "couldn't start the image decoding thread");
work(&self.queue);
}
}
number
}
pub(crate) fn cancel(&mut self, number: u64) -> bool {
let mut queue = lock(&self.queue);
let before = queue.waiting.len();
queue.waiting.retain(|(waiting, _)| *waiting != number);
queue.waiting.len() < before
}
#[cfg(test)]
pub(crate) fn running(&self) -> bool {
lock(&self.queue).running
}
pub(crate) fn take(&mut self) -> Vec<Done> {
std::mem::take(&mut lock(&self.queue).done)
}
pub(crate) fn wake_when_done(&mut self, wake: Wake) {
let now = {
let mut queue = lock(&self.queue);
if queue.done.is_empty() {
queue.wake = Some(wake);
None
} else {
Some(wake)
}
};
if let Some(wake) = now {
wake();
}
}
}
fn work(queue: &Mutex<Queue>) {
loop {
let Some((number, job)) = ({
let mut queue = lock(queue);
let next = queue.waiting.pop_front();
if next.is_none() {
queue.running = false;
}
next
}) else {
return;
};
let Job {
path,
size,
fit,
filters,
scale,
room,
} = job;
let frames = std::panic::catch_unwind(AssertUnwindSafe(|| {
crate::animation::frames(&path, size, fit, &filters, scale, room)
}))
.unwrap_or_else(|_| Err(String::from("the decoder panicked")));
let wake = {
let mut queue = lock(queue);
queue.done.push((number, frames));
queue.wake.take()
};
if let Some(wake) = wake {
wake();
}
}
}
fn lock(queue: &Mutex<Queue>) -> MutexGuard<'_, Queue> {
queue
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}