Merge pull request #273 from woelper/webp_animation

feat: Allow opening of webp animations

Cargo.toml

@@ -35,7 +35,6 @@ image = "0.24"
 kamadak-exif = "0.5"
 lexical-sort = "0.3"
 libavif-image = {version = "0.11", optional = true}
-libwebp-sys = "0.9.2"
 log = "0.4"
 nalgebra = "0.32"
 notan = {version = "0.11", default-features = false, features = ["backend", "draw", "glsl-to-spirv","drop_files", "egui"]}
@@ -75,6 +74,7 @@ bitflags = "2.4.1"
 flate2 = "1.0.28"
 ruzstd = "0.5.0"
 basis-universal = "0.3.1"
+webp-animation = { version = "0.9.0", features = ["static"] }
 
 [features]
 heif = ["libheif-rs"]

src/image_loader.rs

@@ -1,7 +1,6 @@
 use crate::ktx2_loader::CompressedImageFormats;
 use crate::utils::{fit, Frame, FrameSource};
 use crate::{ktx2_loader, FONT};
-use libwebp_sys::{WebPDecodeRGBA, WebPGetInfo};
 use log::{debug, error, info};
 use psd::Psd;
 
@@ -20,6 +19,7 @@ use std::path::Path;
 use std::sync::mpsc::{channel, Receiver, Sender};
 use tiff::decoder::Limits;
 use usvg::{TreeParsing, TreeTextToPath};
+use webp_animation::prelude::*;
 use zune_png::zune_core::options::DecoderOptions;
 use zune_png::zune_core::result::DecodingResult;
 use zune_png::PngDecoder;
@@ -429,9 +429,57 @@ pub fn open_image(img_location: &Path) -> Result<Receiver<Frame>> {
             return Ok(receiver);
         }
         "webp" => {
-            let contents = std::fs::read(img_location)?;
-            let buf = decode_webp(&contents).context("Can't decode webp")?;
-            _ = sender.send(Frame::new_still(buf));
+            // let contents = std::fs::read(img_location)?;
+            // let buf = decode_webp(&contents).context("Can't decode webp")?;
+            // _ = sender.send(Frame::new_still(buf));
+            // return Ok(receiver);
+
+            let buffer = std::fs::read(img_location)?;
+            let mut decoder = Decoder::new(&buffer)?.into_iter();
+
+            let mut last_timestamp = 0;
+
+            let mut frames = vec![];
+            let mut i = 0;
+
+            loop {
+                if let Some(frame) = decoder.next() {
+                    if frames.len() > 1 {
+                        if let Some(last) = frames.pop() {
+                            _ = sender.send(last);
+                        }
+                    }
+                    let buf = image::ImageBuffer::from_raw(
+                        frame.dimensions().0,
+                        frame.dimensions().1,
+                        frame.data().to_vec(),
+                    )
+                    .context("Can't create imagebuffer from webp")?;
+                    let t = frame.timestamp();
+                    let delay = t - last_timestamp;
+                    debug!("time {t} {delay}");
+                    last_timestamp = t;
+                    frames.push(Frame::new(buf, delay as u16, FrameSource::Animation));
+                    i += 1;
+                } else {
+                    break;
+                }
+            }
+
+            if i == 1 {
+                debug!("This is a still");
+                if let Some(mut last) = frames.pop() {
+                    last.source = FrameSource::Still;
+                    _ = sender.send(last);
+                }
+            } else {
+                for f in frames {
+                    _ = sender.send(f);
+                }
+            }
+
+            // TODO: Use thread for animation and return receiver immediately
+
             return Ok(receiver);
         }
         "png" => {
@@ -631,21 +679,6 @@ fn tonemap_rgb(px: [f32; 3]) -> [u8; 4] {
     tm
 }
 
-// Unsafe webp decoding using webp-sys
-fn decode_webp(buf: &[u8]) -> Option<RgbaImage> {
-    let mut width = 0;
-    let mut height = 0;
-    let len = buf.len();
-    let webp_buffer: Vec<u8>;
-    unsafe {
-        WebPGetInfo(buf.as_ptr(), len, &mut width, &mut height);
-        let out_buf = WebPDecodeRGBA(buf.as_ptr(), len, &mut width, &mut height);
-        let len = width * height * 4;
-        webp_buffer = Vec::from_raw_parts(out_buf, len as usize, len as usize);
-    }
-    image::ImageBuffer::from_raw(width as u32, height as u32, webp_buffer)
-}
-
 fn u16_to_u8(p: u16) -> u8 {
     ((p as f32 / u16::MAX as f32) * u8::MAX as f32) as u8
 }

src/main.rs

@@ -57,7 +57,9 @@ pub const FONT: &[u8; 309828] = include_bytes!("../res/fonts/Inter-Regular.ttf")
 #[notan_main]
 fn main() -> Result<(), String> {
     if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "warning");
+        std::env::set_var("RUST_LOG", "info");
+        let _ = env_logger::try_init();
+
     }
     // on debug builds, override log level
     #[cfg(debug_assertions)]

src/utils.rs

@@ -304,6 +304,9 @@ pub fn send_image_threaded(
                     }
                     // a "normal image (no animation)"
                     if f.source == FrameSource::Still {
+
+                        info!("Received image in {:?}", timer.elapsed());
+
                         let largest_side = f.buffer.dimensions().0.max(f.buffer.dimensions().1);
 
                         // Check if texture is too large to fit on the texture