feat: WEBP support

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: sergey3bv

Cargo.lock

@@ -17,7 +17,7 @@ members = [
 
 [workspace.dependencies]
 opener = "0.8.2"
-chrono = "0.4.40" 
+chrono = "0.4.40"
 crossbeam-channel = "0.5"
 crossbeam = "0.8.4"
 base32 = "0.4.0"
@@ -49,13 +49,14 @@ http-body-util = "0.1.3"
 # - Other platforms: aws-lc-rs (better performance)
 rustls = { version = "0.23.28", default-features = false, features = ["std", "tls12", "logging"] }
 ring = "0.17"
-enostr = { path = "crates/enostr" } 
+enostr = { path = "crates/enostr" }
 ewebsock = { version = "0.2.0", features = ["tls"] }
 fluent = "0.17.0"
 fluent-resmgr = "0.0.8"
 fluent-langneg = "0.13"
 hex = { version = "0.4.3", features = ["serde"] }
 image = { version = "0.25", features = ["jpeg", "png", "webp"] }
+webp = "0.3.1"
 indexmap = "2.6.0"
 log = "0.4.17"
 md5 = "0.7.0"

Cargo.toml

@@ -18,6 +18,7 @@ egui = { workspace = true }
 egui_extras = { workspace = true }
 eframe = { workspace = true }
 image = { workspace = true }
+webp = { workspace = true }
 base32 = { workspace = true }
 poll-promise = { workspace = true }
 tracing = { workspace = true }

crates/notedeck/Cargo.toml

@@ -14,6 +14,7 @@ use egui::TextureHandle;
 use image::{Delay, Frame};
 
 use egui::ColorImage;
+use webp::AnimFrame;
 
 use std::collections::HashMap;
 use std::fs::{self, create_dir_all, File};
@@ -31,6 +32,7 @@ pub struct TexturesCache {
     pub static_image: StaticImgTexCache,
     pub blurred: BlurCache,
     pub animated: AnimatedImgTexCache,
+    pub webp: crate::media::webp::WebpTexCache,
 }
 
 impl TexturesCache {
@@ -43,6 +45,9 @@ impl TexturesCache {
             animated: AnimatedImgTexCache::new(
                 base_dir.join(MediaCache::rel_dir(MediaCacheType::Gif)),
             ),
+            webp: crate::media::webp::WebpTexCache::new(
+                base_dir.join(MediaCache::rel_dir(MediaCacheType::Webp)),
+            ),
         }
     }
 }
@@ -53,6 +58,12 @@ pub enum TextureState<T> {
     Loaded(T),
 }
 
+impl<T> TextureState<T> {
+    pub fn is_loaded(&self) -> bool {
+        matches!(self, TextureState::Loaded(_))
+    }
+}
+
 impl<T> std::fmt::Debug for TextureState<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -102,6 +113,7 @@ pub struct MediaCache {
 pub enum MediaCacheType {
     Image,
     Gif,
+    Webp,
 }
 
 impl MediaCache {
@@ -136,6 +148,7 @@ impl MediaCache {
         match cache_type {
             MediaCacheType::Image => "img",
             MediaCacheType::Gif => "gif",
+            MediaCacheType::Webp => "webp",
         }
     }
 
@@ -180,6 +193,59 @@ impl MediaCache {
         Ok(())
     }
 
+    pub fn write_webp(cache_dir: &path::Path, url: &str, data: Vec<ImageFrame>) -> Result<()> {
+        if data.is_empty() {
+            return Err(crate::Error::Generic(
+                "No frames provided to write_webp".to_owned(),
+            ));
+        }
+
+        let file_path = cache_dir.join(Self::key(url));
+        if let Some(p) = file_path.parent() {
+            create_dir_all(p)?;
+        }
+
+        // TODO: makes sense to make it static
+        let mut config = webp::WebPConfig::new().or(Err(crate::Error::Generic(
+            "Failed to configure webp encoder".to_owned(),
+        )))?;
+        config.lossless = 1;
+        config.alpha_compression = 0;
+
+        let reference_frame: &ImageFrame = data.first().ok_or(crate::Error::Generic(
+            "No frames provided to write_webp".to_owned(),
+        ))?;
+        let mut encoder = webp::AnimEncoder::new(
+            reference_frame.image.size[0] as u32,
+            reference_frame.image.size[1] as u32,
+            &config,
+        );
+
+        for (index, frame) in data.iter().enumerate() {
+            let [width, height] = frame.image.size;
+            let timestamp = index as i32 * {
+                let delay = frame.delay.as_millis();
+                if delay < i32::MAX as u128 {
+                    delay as i32
+                } else {
+                    // If delay is to big defaulting to 300 ms
+                    300i32
+                }
+            };
+
+            encoder.add_frame(AnimFrame::from_rgba(
+                frame.image.as_raw(),
+                width as u32,
+                height as u32,
+                timestamp,
+            ));
+        }
+
+        let webp = encoder.encode();
+
+        Ok(std::fs::write(file_path, &*webp)?)
+    }
+
     pub fn key(url: &str) -> String {
         let k: String = sha2::Sha256::digest(url.as_bytes()).encode_hex();
         PathBuf::from(&k[0..2])
@@ -272,11 +338,13 @@ pub struct Images {
     pub base_path: path::PathBuf,
     pub static_imgs: MediaCache,
     pub gifs: MediaCache,
+    pub webps: MediaCache,
     pub textures: TexturesCache,
     pub urls: UrlMimes,
     /// cached imeta data
     pub metadata: HashMap<String, ImageMetadata>,
     pub gif_states: GifStateMap,
+    pub webp_states: WebpStateMap,
 }
 
 impl Images {
@@ -286,16 +354,19 @@ impl Images {
             base_path: path.clone(),
             static_imgs: MediaCache::new(&path, MediaCacheType::Image),
             gifs: MediaCache::new(&path, MediaCacheType::Gif),
+            webps: MediaCache::new(&path, MediaCacheType::Webp),
             urls: UrlMimes::new(UrlCache::new(path.join(UrlCache::rel_dir()))),
             gif_states: Default::default(),
+            webp_states: Default::default(),
             metadata: Default::default(),
             textures: TexturesCache::new(path.clone()),
         }
     }
 
     pub fn migrate_v0(&self) -> Result<()> {
         self.static_imgs.migrate_v0()?;
-        self.gifs.migrate_v0()
+        self.gifs.migrate_v0()?;
+        self.webps.migrate_v0()
     }
 
     pub fn get_renderable_media(&mut self, url: &str) -> Option<RenderableMedia> {
@@ -334,7 +405,9 @@ impl Images {
         let mut loader = NoLoadingLatestTex::new(
             &self.textures.static_image,
             &self.textures.animated,
+            &self.textures.webp,
             &mut self.gif_states,
+            &mut self.webp_states,
         );
         loader.latest(jobs, ui.ctx(), url, cache_type, img_type, animation_mode)
     }
@@ -343,13 +416,15 @@ impl Images {
         match cache_type {
             MediaCacheType::Image => &self.static_imgs,
             MediaCacheType::Gif => &self.gifs,
+            MediaCacheType::Webp => &self.webps,
         }
     }
 
     pub fn get_cache_mut(&mut self, cache_type: MediaCacheType) -> &mut MediaCache {
         match cache_type {
             MediaCacheType::Image => &mut self.static_imgs,
             MediaCacheType::Gif => &mut self.gifs,
+            MediaCacheType::Webp => &mut self.webps,
         }
     }
 
@@ -368,7 +443,9 @@ impl Images {
         self.urls.cache.clear();
         self.static_imgs.clear();
         self.gifs.clear();
+        self.webps.clear();
         self.gif_states.clear();
+        self.webp_states.clear();
 
         Ok(())
     }
@@ -378,7 +455,9 @@ impl Images {
             NoLoadingLatestTex::new(
                 &self.textures.static_image,
                 &self.textures.animated,
+                &self.textures.webp,
                 &mut self.gif_states,
+                &mut self.webp_states,
             ),
             &self.textures.blurred,
         )
@@ -392,14 +471,17 @@ impl Images {
         NoLoadingLatestTex::new(
             &self.textures.static_image,
             &self.textures.animated,
+            &self.textures.webp,
             &mut self.gif_states,
+            &mut self.webp_states,
         )
     }
 
     pub fn user_trusts_img(&self, url: &str, media_type: MediaCacheType) -> bool {
         match media_type {
             MediaCacheType::Image => self.textures.static_image.contains(url),
             MediaCacheType::Gif => self.textures.animated.contains(url),
+            MediaCacheType::Webp => self.textures.webp.contains(url),
         }
     }
 }
@@ -413,6 +495,15 @@ pub struct GifState {
     pub last_frame_index: usize,
 }
 
+pub type WebpStateMap = HashMap<String, WebpState>;
+
+pub struct WebpState {
+    pub last_frame_rendered: Instant,
+    pub last_frame_duration: Duration,
+    pub next_frame_time: Option<SystemTime>,
+    pub last_frame_index: usize,
+}
+
 pub struct LatestTexture {
     pub texture: TextureHandle,
     pub request_next_repaint: Option<SystemTime>,

crates/notedeck/src/imgcache.rs

@@ -15,6 +15,7 @@ pub enum MediaJobKind {
     Blurhash,
     StaticImg,
     AnimatedImg,
+    WebpImg,
 }
 
 pub enum MediaJobResult {
@@ -42,7 +43,6 @@ pub fn deliver_completed_media_job(
                 Ok(a) => TextureState::Loaded(a),
                 Err(e) => TextureState::Error(e),
             };
-
             tex_cache.animated.cache.insert(id, r);
         }
         MediaJobResult::Blurhash(texture_handle) => {
@@ -74,5 +74,8 @@ pub fn run_media_job_pre_action(job_id: &JobId<MediaJobKind>, tex_cache: &mut Te
         MediaJobKind::AnimatedImg => {
             tex_cache.animated.cache.insert(id, TextureState::Pending);
         }
+        MediaJobKind::WebpImg => {
+            tex_cache.webp.cache.insert(id, TextureState::Pending);
+        }
     }
 }

crates/notedeck/src/jobs/media.rs

@@ -57,7 +57,7 @@ pub use fonts::NamedFontFamily;
 pub use i18n::{CacheStats, FluentArgs, FluentValue, LanguageIdentifier, Localization};
 pub use imgcache::{
     Animation, GifState, GifStateMap, ImageFrame, Images, LatestTexture, MediaCache,
-    MediaCacheType, TextureFrame, TextureState, TexturesCache,
+    MediaCacheType, TextureFrame, TextureState, TexturesCache, WebpState, WebpStateMap,
 };
 pub use jobs::{
     deliver_completed_media_job, run_media_job_pre_action, JobCache, JobPool, MediaJobSender,

crates/notedeck/src/lib.rs

@@ -116,6 +116,12 @@ impl MediaAction {
                         .animated
                         .request(jobs, ctx, &url, ImageType::Content(None))
                 }
+                MediaCacheType::Webp => {
+                    images
+                        .textures
+                        .webp
+                        .request(jobs, ctx, &url, ImageType::Content(None))
+                }
             },
             MediaAction::DoneLoading { url, cache_type: _ } => {
                 images.textures.blurred.finished_transitioning(&url);