new

jellyfin-kiosk-rs/src/image_cache.rs

@@ -0,0 +1,183 @@
+use std::collections::{HashMap, HashSet};
+use std::sync::{Arc, Mutex};
+use tokio::sync::{mpsc, RwLock, Semaphore};
+use eframe::egui::{ColorImage, Context, TextureHandle, TextureOptions};
+
+#[derive(Clone)]
+pub enum ImageStatus {
+    Loaded(TextureHandle),
+    Loading,
+    Failed,
+}
+
+fn hash_url(url: &str) -> u64 {
+    use std::hash::{Hash, Hasher};
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    url.hash(&mut hasher);
+    hasher.finish()
+}
+
+struct CacheInner {
+    textures: HashMap<String, (u64, TextureHandle)>,
+    in_flight: HashSet<String>,
+    failed: HashSet<String>,
+    access_counter: u64,
+}
+
+pub struct AsyncImageCache {
+    inner: Mutex<CacheInner>,
+    tx: mpsc::UnboundedSender<(String, Option<ColorImage>)>,
+    rx: Mutex<mpsc::UnboundedReceiver<(String, Option<ColorImage>)>>,
+    http_client: reqwest::Client,
+    token: Arc<RwLock<Option<String>>>,
+    semaphore: Arc<Semaphore>,
+}
+
+impl AsyncImageCache {
+    pub fn new(token: Arc<RwLock<Option<String>>>) -> Self {
+        let (tx, rx) = mpsc::unbounded_channel();
+        Self {
+            inner: Mutex::new(CacheInner {
+                textures: HashMap::new(),
+                in_flight: HashSet::new(),
+                failed: HashSet::new(),
+                access_counter: 0,
+            }),
+            tx,
+            rx: Mutex::new(rx),
+            http_client: reqwest::Client::new(),
+            token,
+            semaphore: Arc::new(Semaphore::new(10)),
+        }
+    }
+
+    pub fn update(&self, ctx: &Context) {
+        let mut any_new = false;
+        if let Ok(mut rx_guard) = self.rx.try_lock() {
+            while let Ok((url, opt_img)) = rx_guard.try_recv() {
+                if let Ok(mut inner) = self.inner.lock() {
+                    inner.in_flight.remove(&url);
+                    match opt_img {
+                        Some(color_image) => {
+                            inner.access_counter += 1;
+                            let counter = inner.access_counter;
+                            let handle = ctx.load_texture(&url, color_image, TextureOptions::LINEAR);
+                            inner.textures.insert(url, (counter, handle));
+                            any_new = true;
+                        }
+                        None => {
+                            inner.failed.insert(url);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Limit cached textures to 500
+        if let Ok(mut inner) = self.inner.lock() {
+            if inner.textures.len() > 500 {
+                let mut entries: Vec<(String, u64)> = inner
+                    .textures
+                    .iter()
+                    .map(|(k, (c, _))| (k.clone(), *c))
+                    .collect();
+                entries.sort_by_key(|(_, c)| *c);
+                let to_remove = entries.len() - 400;
+                for (k, _) in entries.into_iter().take(to_remove) {
+                    inner.textures.remove(&k);
+                }
+            }
+        }
+
+        if any_new {
+            ctx.request_repaint();
+        }
+    }
+
+    pub fn get_or_load(&self, ctx: &Context, url: &str) -> ImageStatus {
+        if url.is_empty() {
+            return ImageStatus::Failed;
+        }
+
+        if let Ok(mut inner) = self.inner.lock() {
+            inner.access_counter += 1;
+            let current_count = inner.access_counter;
+            if let Some((counter, handle)) = inner.textures.get_mut(url) {
+                *counter = current_count;
+                return ImageStatus::Loaded(handle.clone());
+            }
+
+            if inner.failed.contains(url) {
+                return ImageStatus::Failed;
+            }
+
+            if inner.in_flight.contains(url) {
+                return ImageStatus::Loading;
+            }
+
+            inner.in_flight.insert(url.to_string());
+        } else {
+            return ImageStatus::Loading;
+        }
+
+        let url_clone = url.to_string();
+        let tx = self.tx.clone();
+        let client = self.http_client.clone();
+        let sem = self.semaphore.clone();
+        let ctx_clone = ctx.clone();
+        let token_opt = self.token.try_read().ok().and_then(|g| g.clone());
+
+        tokio::spawn(async move {
+            let _permit = sem.acquire().await;
+            let cache_dir = std::path::Path::new("/tmp/jellyfin-cache");
+            let file_name = format!("{:016x}.cache", hash_url(&url_clone));
+            let cache_file = cache_dir.join(file_name);
+
+            let mut bytes_opt = if let Ok(data) = std::fs::read(&cache_file) {
+                Some(data)
+            } else {
+                None
+            };
+
+            if bytes_opt.is_none() {
+                let mut req = client.get(&url_clone);
+                if let Some(ref t) = token_opt {
+                    req = req.header("X-Emby-Token", t);
+                    req = req.header("Authorization", format!("MediaBrowser Token=\"{}\"", t));
+                }
+                if let Ok(resp) = req.send().await {
+                    if resp.status().is_success() {
+                        if let Ok(b) = resp.bytes().await {
+                            let vec_bytes = b.to_vec();
+                            let _ = std::fs::create_dir_all(cache_dir);
+                            let _ = std::fs::write(&cache_file, &vec_bytes);
+                            bytes_opt = Some(vec_bytes);
+                        }
+                    }
+                }
+            }
+
+            let color_img = if let Some(bytes) = bytes_opt {
+                tokio::task::spawn_blocking(move || {
+                    if let Ok(dyn_img) = image::load_from_memory(&bytes) {
+                        let rgba = dyn_img.to_rgba8();
+                        let size = [rgba.width() as usize, rgba.height() as usize];
+                        let pixels = rgba.into_raw();
+                        Some(ColorImage::from_rgba_unmultiplied(size, &pixels))
+                    } else {
+                        None
+                    }
+                })
+                .await
+                .unwrap_or(None)
+            } else {
+                None
+            };
+
+            let _ = tx.send((url_clone, color_img));
+            ctx_clone.request_repaint();
+        });
+
+        ImageStatus::Loading
+    }
+}