diff --git a/.gitignore b/.gitignore index 70ad5c3..b0180a6 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ .buildcmd target .git +cache /dist .direnv/ src/camera.rs diff --git a/Makefile b/Makefile index 6c62f05..5b2d86b 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,7 @@ +all: + cargo check + tags: fake find . -type d -name target -prune -o -type f -name '*.rs' -print | xargs ctags diff --git a/src/app.rs b/src/app.rs index f40ada8..638888a 100644 --- a/src/app.rs +++ b/src/app.rs @@ -3,16 +3,18 @@ use crate::error::Error; use crate::fonts::{setup_fonts, NamedFontFamily}; use crate::frame_history::FrameHistory; use crate::images::fetch_img; +use crate::imgcache::ImageCache; use crate::notecache::NoteCache; use crate::timeline; use crate::ui::padding; use crate::Result; use egui::containers::scroll_area::ScrollBarVisibility; +use std::borrow::Cow; use egui::widgets::Spinner; use egui::{ - Color32, Context, Frame, Hyperlink, Image, Label, Margin, RichText, Style, TextureHandle, - Visuals, + Color32, Context, Frame, Hyperlink, Image, Label, Margin, RichText, Sense, Style, + TextureHandle, Vec2, Visuals, }; use enostr::{ClientMessage, Filter, Pubkey, RelayEvent, RelayMessage}; @@ -33,22 +35,6 @@ use enostr::RelayPool; const PURPLE: Color32 = Color32::from_rgb(0xCC, 0x43, 0xC5); const DARK_BG: Color32 = egui::Color32::from_rgb(40, 44, 52); -#[derive(Hash, Eq, PartialEq, Clone, Debug)] -enum UrlKey<'a> { - Orig(&'a str), - Failed(&'a str), -} - -impl UrlKey<'_> { - fn to_u64(&self) -> u64 { - let mut hasher = std::collections::hash_map::DefaultHasher::new(); - self.hash(&mut hasher); - hasher.finish() - } -} - -type ImageCache = HashMap>>; - #[derive(Debug, Eq, PartialEq, Clone)] pub enum DamusState { Initializing, @@ -454,12 +440,15 @@ impl Damus { vec![get_home_filter()] }; + let imgcache_dir = data_path.as_ref().join("cache/img"); + std::fs::create_dir_all(imgcache_dir.clone()); + let mut config = Config::new(); config.set_ingester_threads(2); Self { state: DamusState::Initializing, pool: RelayPool::new(), - img_cache: HashMap::new(), + img_cache: ImageCache::new(imgcache_dir), note_cache: HashMap::new(), initial_filter, n_panels: 1, @@ -477,48 +466,55 @@ impl Damus { } } -fn render_pfp(ui: &mut egui::Ui, img_cache: &mut ImageCache, url: &str) { +fn paint_circle(ui: &mut egui::Ui, size: f32) { + let (rect, _response) = ui.allocate_at_least(Vec2::new(size, size), Sense::hover()); + ui.painter() + .circle_filled(rect.center(), size / 2.0, ui.visuals().weak_text_color()); +} + +fn render_pfp(ui: &mut egui::Ui, damus: &mut Damus, url: &str) { #[cfg(feature = "profiling")] puffin::profile_function!(); - let urlkey = UrlKey::Orig(url).to_u64(); - let m_cached_promise = img_cache.get(&urlkey); + let ui_size = 30.0; + + // We will want to downsample these so it's not blurry on hi res displays + let img_size = (ui_size * 2.0) as u32; + + let m_cached_promise = damus.img_cache.map().get(url); if m_cached_promise.is_none() { - debug!("urlkey: {:?}", &urlkey); - img_cache.insert(urlkey, fetch_img(ui.ctx(), url)); + let res = fetch_img(&damus.img_cache, ui.ctx(), url, img_size); + damus.img_cache.map_mut().insert(url.to_owned(), res); } - let pfp_size = 40.0; - - match img_cache[&urlkey].ready() { + match damus.img_cache.map()[url].ready() { None => { - ui.add(Spinner::new().size(pfp_size)); + ui.add(Spinner::new().size(ui_size)); } + + // Failed to fetch profile! Some(Err(_err)) => { - let failed_key = UrlKey::Failed(url).to_u64(); - //debug!("has failed promise? {}", img_cache.contains_key(&failed_key)); - let m_failed_promise = img_cache.get_mut(&failed_key); + let m_failed_promise = damus.img_cache.map().get(url); if m_failed_promise.is_none() { - warn!("failed key: {:?}", &failed_key); - let no_pfp = fetch_img(ui.ctx(), no_pfp_url()); - img_cache.insert(failed_key, no_pfp); + let no_pfp = fetch_img(&damus.img_cache, ui.ctx(), no_pfp_url(), img_size); + damus.img_cache.map_mut().insert(url.to_owned(), no_pfp); } - match img_cache[&failed_key].ready() { + match damus.img_cache.map().get(url).unwrap().ready() { None => { - ui.add(Spinner::new().size(pfp_size)); + paint_circle(ui, ui_size); } Some(Err(_e)) => { //error!("Image load error: {:?}", e); - ui.label("❌"); + paint_circle(ui, ui_size); } Some(Ok(img)) => { - pfp_image(ui, img, pfp_size); + pfp_image(ui, img, ui_size); } } } Some(Ok(img)) => { - pfp_image(ui, img, pfp_size); + pfp_image(ui, img, ui_size); } } } @@ -744,8 +740,8 @@ fn render_note(ui: &mut egui::Ui, damus: &mut Damus, note_key: NoteKey) -> Resul { // these have different lifetimes and types, // so the calls must be separate - Some(pic) => render_pfp(ui, &mut damus.img_cache, pic), - None => render_pfp(ui, &mut damus.img_cache, no_pfp_url()), + Some(pic) => render_pfp(ui, damus, pic), + None => render_pfp(ui, damus, no_pfp_url()), } ui.with_layout(egui::Layout::top_down(egui::Align::LEFT), |ui| { diff --git a/src/error.rs b/src/error.rs index c70d00c..37f18eb 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,8 +1,10 @@ -use std::fmt; +use std::{fmt, io}; #[derive(Debug)] pub enum Error { NoActiveSubscription, + LoadFailed, + Io(io::Error), Nostr(enostr::Error), Ndb(nostrdb::Error), Image(image::error::ImageError), @@ -15,10 +17,14 @@ impl fmt::Display for Error { Self::NoActiveSubscription => { write!(f, "subscription not active in timeline") } + Self::LoadFailed => { + write!(f, "load failed") + } Self::Nostr(e) => write!(f, "{e}"), Self::Ndb(e) => write!(f, "{e}"), Self::Image(e) => write!(f, "{e}"), Self::Generic(e) => write!(f, "{e}"), + Self::Io(e) => write!(f, "{e}"), } } } @@ -46,3 +52,9 @@ impl From for Error { Error::Nostr(err) } } + +impl From for Error { + fn from(err: io::Error) -> Self { + Error::Io(err) + } +} diff --git a/src/images.rs b/src/images.rs index 964a2c4..699c2cb 100644 --- a/src/images.rs +++ b/src/images.rs @@ -1,8 +1,16 @@ use crate::error::Error; use crate::result::Result; +use crate::imgcache::ImageCache; use egui::{Color32, ColorImage, SizeHint, TextureHandle}; use image::imageops::FilterType; use poll_promise::Promise; +use tokio::fs; +use std::path; +use std::collections::HashMap; + +//pub type ImageCacheKey = String; +//pub type ImageCacheValue = Promise>; +//pub type ImageCache = HashMap; pub fn round_image(image: &mut ColorImage) { #[cfg(feature = "profiling")] @@ -78,12 +86,11 @@ fn process_pfp_bitmap(size: u32, image: &mut image::DynamicImage) -> ColorImage color_image } -fn parse_img_response(response: ehttp::Response) -> Result { +fn parse_img_response(response: ehttp::Response, size: u32) -> Result { #[cfg(feature = "profiling")] puffin::profile_function!(); let content_type = response.content_type().unwrap_or_default(); - let size: u32 = 100; if content_type.starts_with("image/svg") { #[cfg(feature = "profiling")] @@ -105,24 +112,70 @@ fn parse_img_response(response: ehttp::Response) -> Result { } } -pub fn fetch_img(ctx: &egui::Context, url: &str) -> Promise> { - // TODO: fetch image from local cache - fetch_img_from_net(ctx, url) +fn fetch_img_from_disk(ctx: &egui::Context, url: &str, path: &path::Path) -> Promise> { + let ctx = ctx.clone(); + let url = url.to_owned(); + let path = path.to_owned(); + Promise::spawn_async(async move { + let data = fs::read(path).await?; + let image_buffer = image::load_from_memory(&data)?; + + // TODO: remove unwrap here + let flat_samples = image_buffer.as_flat_samples_u8().unwrap(); + let img = ColorImage::from_rgba_unmultiplied( + [ + image_buffer.width() as usize, + image_buffer.height() as usize, + ], + flat_samples.as_slice(), + ); + + Ok(ctx.load_texture(&url, img, Default::default())) + }) } -fn fetch_img_from_net(ctx: &egui::Context, url: &str) -> Promise> { +pub fn fetch_img( + img_cache: &ImageCache, + ctx: &egui::Context, + url: &str, + size: u32, +) -> Promise> { + let key = ImageCache::key(url); + let path = img_cache.cache_dir.join(&key); + + if path.exists() { + fetch_img_from_disk(ctx, url, &path) + } else { + fetch_img_from_net(&img_cache.cache_dir, ctx, url, size) + } + + // TODO: fetch image from local cache +} + +fn fetch_img_from_net(cache_path: &path::Path, ctx: &egui::Context, url: &str, size: u32) -> Promise> { let (sender, promise) = Promise::new(); let request = ehttp::Request::get(url); let ctx = ctx.clone(); let cloned_url = url.to_owned(); + let cache_path = cache_path.to_owned(); ehttp::fetch(request, move |response| { let handle = response .map_err(Error::Generic) - .and_then(parse_img_response) - .map(|img| ctx.load_texture(&cloned_url, img, Default::default())); + .and_then(|resp| parse_img_response(resp, size)) + .map(|img| { + let texture_handle = ctx.load_texture(&cloned_url, img.clone(), Default::default()); + + // write to disk + std::thread::spawn(move || { + ImageCache::write(&cache_path, &cloned_url, img) + }); + + texture_handle + }); sender.send(handle); // send the results back to the UI thread. ctx.request_repaint(); }); + promise } diff --git a/src/imgcache.rs b/src/imgcache.rs new file mode 100644 index 0000000..8114d41 --- /dev/null +++ b/src/imgcache.rs @@ -0,0 +1,57 @@ +use crate::{Error, Result}; +use egui::TextureHandle; +use poll_promise::Promise; + +use egui::ColorImage; +use hex; +use std::borrow::Cow; +use std::collections::hash_map::Entry; +use std::collections::HashMap; +use std::fs::File; +use std::hash::{Hash, Hasher}; +use std::io; +use std::path; +use tokio::fs; + +pub type ImageCacheValue = Promise>; +pub type ImageCacheMap = HashMap; + +pub struct ImageCache { + pub cache_dir: path::PathBuf, + url_imgs: ImageCacheMap, +} + +impl ImageCache { + pub fn new(cache_dir: path::PathBuf) -> Self { + Self { + cache_dir, + url_imgs: HashMap::new(), + } + } + + pub fn write(cache_dir: &path::Path, url: &str, data: ColorImage) -> Result<()> { + let file_path = cache_dir.join(&Self::key(url)); + let file = File::options().write(true).create(true).open(file_path)?; + let encoder = image::codecs::webp::WebPEncoder::new_lossless(file); + encoder.encode( + data.as_raw(), + data.size[0] as u32, + data.size[1] as u32, + image::ColorType::Rgba8, + ); + + Ok(()) + } + + pub fn key(url: &str) -> String { + base32::encode(base32::Alphabet::Crockford, url.as_bytes()) + } + + pub fn map(&self) -> &ImageCacheMap { + &self.url_imgs + } + + pub fn map_mut(&mut self) -> &mut ImageCacheMap { + &mut self.url_imgs + } +} diff --git a/src/lib.rs b/src/lib.rs index 41f1914..0cf8e46 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -7,6 +7,7 @@ mod abbrev; mod fonts; mod images; mod result; +mod imgcache; mod filter; mod ui; mod timecache; diff --git a/src/time.rs b/src/time.rs index 4a30bb3..7fc691a 100644 --- a/src/time.rs +++ b/src/time.rs @@ -1,4 +1,4 @@ -use std::time::{Duration, SystemTime, UNIX_EPOCH}; +use std::time::{SystemTime, UNIX_EPOCH}; /// Show a relative time string based on some timestamp pub fn time_ago_since(timestamp: u64) -> String {