Prepare for user saving of anime sequences

rog-anime/src/anime_diagonal.rs

@@ -1,7 +1,5 @@
 use std::path::Path;
 
-use glam::Vec2;
-
 use crate::{
     anime_data::{AniMeDataBuffer, ANIME_DATA_LEN},
     error::AnimeError,
@@ -28,11 +26,6 @@ impl AniMeDiagonal {
         &mut self.0
     }
 
-    // use with height - y
-    const fn dy(x: usize, y: usize) -> usize {
-        x / 2 + x % 2 + y
-    }
-
     fn get_row(&self, x: usize, y: usize, len: usize) -> Vec<u8> {
         let mut buf = Vec::with_capacity(len);
         for i in 0..len {
@@ -46,8 +39,6 @@ impl AniMeDiagonal {
     /// updated via scale, position, or angle then displayed again after `update()`.
     pub fn from_png(
         path: &Path,
-        scale: Vec2,
-        offset: Vec2,
         bright: f32,
     ) -> Result<Self, AnimeError> {
         use pix::el::Pixel;

rog-anime/src/anime_gif.rs

@@ -0,0 +1,61 @@
+use serde_derive::{Deserialize, Serialize};
+use std::{fs::File, path::{Path}, time::Duration};
+
+use crate::{error::AnimeError, AniMeDataBuffer, AniMeDiagonal};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct AniMeFrame {
+    data: AniMeDataBuffer,
+    delay: Duration,
+}
+
+impl AniMeFrame {
+    pub fn frame(&self) -> &AniMeDataBuffer {
+        &self.data
+    }
+
+    pub fn delay(&self) -> Duration {
+        self.delay
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct AniMeGif(Vec<AniMeFrame>);
+
+impl AniMeGif {
+    pub fn new(file_name: &Path, brightness: f32) -> Result<Self, AnimeError> {
+        let mut frames = Vec::new();
+        let mut matrix = AniMeDiagonal::new();
+
+        let mut decoder = gif::DecodeOptions::new();
+        // Configure the decoder such that it will expand the image to RGBA.
+        decoder.set_color_output(gif::ColorOutput::RGBA);
+        // Read the file header
+        let file = File::open(file_name)?;
+        let mut decoder = decoder.read_info(file)?;
+
+        while let Some(frame) = decoder.read_next_frame()? {
+            let wait = frame.delay * 10;
+            for (y, row) in frame.buffer.chunks(frame.width as usize * 4).enumerate() {
+                for (x, px) in row.chunks(4).enumerate() {
+                    if px[3] != 255 {
+                        // should be t but not in some gifs? What, ASUS, what?
+                        continue;
+                    }
+                    matrix.get_mut()[y + frame.top as usize][x + frame.left as usize] =
+                        (px[0] as f32 * brightness) as u8;
+                }
+            }
+
+            frames.push(AniMeFrame {
+                data: <AniMeDataBuffer>::from(&matrix),
+                delay: Duration::from_millis(wait as u64),
+            });
+        }
+        Ok(Self(frames))
+    }
+
+    pub fn frames(&self) -> &[AniMeFrame] {
+        &self.0
+    }
+}

rog-anime/src/anime_image.rs

@@ -49,7 +49,7 @@ impl Led {
 /// Container of `Led`, each of which specifies a position within the image
 /// The main use of this is to position and sample colours for the final image
 /// to show on AniMe
-pub struct AnimeImage {
+pub struct AniMeImage {
     pub scale: Vec2,
     /// Angle in radians
     pub angle: f32,
@@ -63,7 +63,7 @@ pub struct AnimeImage {
     width: u32,
 }
 
-impl AnimeImage {
+impl AniMeImage {
     const fn new(
         scale: Vec2,
         angle: f32,
@@ -133,11 +133,11 @@ impl AnimeImage {
 
     /// Really only used to generate the output for including as a full const in `LED_IMAGE_POSITIONS`
     pub fn generate() -> Vec<Option<Led>> {
-        (0..AnimeImage::height())
+        (0..AniMeImage::height())
             .flat_map(|y| {
-                (0..AnimeImage::pitch(y)).map(move |l| {
-                    if l < AnimeImage::width(y) {
-                        let x = AnimeImage::first_x(y) + l;
+                (0..AniMeImage::pitch(y)).map(move |l| {
+                    if l < AniMeImage::width(y) {
+                        let x = AniMeImage::first_x(y) + l;
                         Some(Led::new(x as f32 - 0.5 * (y % 2) as f32, y as f32))
                     } else {
                         None
@@ -203,8 +203,8 @@ impl AnimeImage {
         // Center of image
         let center = Mat3::from_translation(Vec2::new(-0.5 * bmp_w, -0.5 * bmp_h));
         // Find the scale required for cleanly showing the image
-        let h = AnimeImage::phys_height() / bmp_h;
-        let mut base_scale = AnimeImage::phys_width() / bmp_w;
+        let h = AniMeImage::phys_height() / bmp_h;
+        let mut base_scale = AniMeImage::phys_width() / bmp_w;
         if base_scale > h {
             base_scale = h;
         }
@@ -212,8 +212,8 @@ impl AnimeImage {
         let cm_from_px = Mat3::from_scale(Vec2::new(base_scale, base_scale));
 
         let led_from_cm = Mat3::from_scale(Vec2::new(
-            1.0 / AnimeImage::scale_x(),
-            1.0 / AnimeImage::scale_y(),
+            1.0 / AniMeImage::scale_x(),
+            1.0 / AniMeImage::scale_y(),
         ));
 
         let transform =
@@ -258,18 +258,18 @@ impl AnimeImage {
             _ => return Err(AnimeError::Format),
         };
 
-        let mut matrix = AnimeImage::new(scale, angle, translation, bright, pixels, width);
+        let mut matrix = AniMeImage::new(scale, angle, translation, bright, pixels, width);
 
         matrix.update();
         Ok(matrix)
     }
 }
 
-impl From<&AnimeImage> for AniMeDataBuffer {
+impl From<&AniMeImage> for AniMeDataBuffer {
     /// Do conversion from the nested Vec in AniMeMatrix to the two required
     /// packets suitable for sending over USB
     #[inline]
-    fn from(leds: &AnimeImage) -> Self {
+    fn from(leds: &AniMeImage) -> Self {
         let mut l: Vec<u8> = leds
             .led_pos
             .iter()
@@ -1540,7 +1540,7 @@ mod tests {
 
     #[test]
     fn led_positions() {
-        let leds = AnimeImage::generate();
+        let leds = AniMeImage::generate();
         assert_eq!(leds[0], Some(Led(0.0, 0.0, 0)));
         assert_eq!(leds[1], Some(Led(1.0, 0.0, 0)));
         assert_eq!(leds[2], Some(Led(2.0, 0.0, 0)));
@@ -1569,7 +1569,7 @@ mod tests {
 
     #[test]
     fn led_positions_const() {
-        let leds = AnimeImage::generate();
+        let leds = AniMeImage::generate();
         assert_eq!(leds[1], LED_IMAGE_POSITIONS[1]);
         assert_eq!(leds[34], LED_IMAGE_POSITIONS[34]);
         assert_eq!(leds[69], LED_IMAGE_POSITIONS[69]);
@@ -1583,44 +1583,44 @@ mod tests {
 
     #[test]
     fn row_starts() {
-        assert_eq!(AnimeImage::first_x(5), 0);
-        assert_eq!(AnimeImage::first_x(6), 0);
-        assert_eq!(AnimeImage::first_x(7), 1);
-        assert_eq!(AnimeImage::first_x(8), 1);
-        assert_eq!(AnimeImage::first_x(9), 2);
-        assert_eq!(AnimeImage::first_x(10), 2);
-        assert_eq!(AnimeImage::first_x(11), 3);
+        assert_eq!(AniMeImage::first_x(5), 0);
+        assert_eq!(AniMeImage::first_x(6), 0);
+        assert_eq!(AniMeImage::first_x(7), 1);
+        assert_eq!(AniMeImage::first_x(8), 1);
+        assert_eq!(AniMeImage::first_x(9), 2);
+        assert_eq!(AniMeImage::first_x(10), 2);
+        assert_eq!(AniMeImage::first_x(11), 3);
     }
 
     #[test]
     fn row_widths() {
-        assert_eq!(AnimeImage::width(5), 33);
-        assert_eq!(AnimeImage::width(6), 33);
-        assert_eq!(AnimeImage::width(7), 32);
-        assert_eq!(AnimeImage::width(8), 32);
-        assert_eq!(AnimeImage::width(9), 31);
-        assert_eq!(AnimeImage::width(10), 31);
-        assert_eq!(AnimeImage::width(11), 30);
-        assert_eq!(AnimeImage::width(12), 30);
-        assert_eq!(AnimeImage::width(13), 29);
-        assert_eq!(AnimeImage::width(14), 29);
-        assert_eq!(AnimeImage::width(15), 28);
-        assert_eq!(AnimeImage::width(16), 28);
-        assert_eq!(AnimeImage::width(17), 27);
-        assert_eq!(AnimeImage::width(18), 27);
+        assert_eq!(AniMeImage::width(5), 33);
+        assert_eq!(AniMeImage::width(6), 33);
+        assert_eq!(AniMeImage::width(7), 32);
+        assert_eq!(AniMeImage::width(8), 32);
+        assert_eq!(AniMeImage::width(9), 31);
+        assert_eq!(AniMeImage::width(10), 31);
+        assert_eq!(AniMeImage::width(11), 30);
+        assert_eq!(AniMeImage::width(12), 30);
+        assert_eq!(AniMeImage::width(13), 29);
+        assert_eq!(AniMeImage::width(14), 29);
+        assert_eq!(AniMeImage::width(15), 28);
+        assert_eq!(AniMeImage::width(16), 28);
+        assert_eq!(AniMeImage::width(17), 27);
+        assert_eq!(AniMeImage::width(18), 27);
     }
 
     #[test]
     fn row_pitch() {
-        assert_eq!(AnimeImage::pitch(5), 34);
-        assert_eq!(AnimeImage::pitch(6), 33);
-        assert_eq!(AnimeImage::pitch(7), 33);
-        assert_eq!(AnimeImage::pitch(8), 32);
-        assert_eq!(AnimeImage::pitch(9), 32);
-        assert_eq!(AnimeImage::pitch(10), 31);
-        assert_eq!(AnimeImage::pitch(11), 31);
-        assert_eq!(AnimeImage::pitch(12), 30);
-        assert_eq!(AnimeImage::pitch(13), 30);
-        assert_eq!(AnimeImage::pitch(14), 29);
+        assert_eq!(AniMeImage::pitch(5), 34);
+        assert_eq!(AniMeImage::pitch(6), 33);
+        assert_eq!(AniMeImage::pitch(7), 33);
+        assert_eq!(AniMeImage::pitch(8), 32);
+        assert_eq!(AniMeImage::pitch(9), 32);
+        assert_eq!(AniMeImage::pitch(10), 31);
+        assert_eq!(AniMeImage::pitch(11), 31);
+        assert_eq!(AniMeImage::pitch(12), 30);
+        assert_eq!(AniMeImage::pitch(13), 30);
+        assert_eq!(AniMeImage::pitch(14), 29);
     }
 }

rog-anime/src/error.rs

@@ -1,5 +1,6 @@
 use std::error::Error;
 use std::fmt;
+use gif::DecodingError;
 use png_pong::decode::Error as PngError;
 
 #[derive(Debug)]
@@ -7,6 +8,7 @@ pub enum AnimeError {
     NoFrames,
     Io(std::io::Error),
     Png(PngError),
+    Gif(DecodingError),
     Format
 }
 
@@ -17,6 +19,7 @@ impl fmt::Display for AnimeError {
             AnimeError::NoFrames => write!(f, "No frames in PNG"),
             AnimeError::Io(e) => write!(f, "Could not open: {}", e),
             AnimeError::Png(e) => write!(f, "PNG error: {}", e),
+            AnimeError::Gif(e) => write!(f, "GIF error: {}", e),
             AnimeError::Format => write!(f, "PNG file is not 8bit greyscale"),
         }
     }
@@ -34,4 +37,10 @@ impl From<PngError> for AnimeError {
     fn from(err: PngError) -> Self {
         AnimeError::Png(err)
     }
+}
+
+impl From<DecodingError> for AnimeError {
+    fn from(err: DecodingError) -> Self {
+        AnimeError::Gif(err)
+    }
 }

rog-anime/src/lib.rs

@@ -1,6 +1,9 @@
+use serde_derive::{Deserialize, Serialize};
 /// The main data conversion for transfering in shortform over dbus or other,
 /// or writing directly to the USB device
 mod anime_data;
+use std::{path::Path, time::Duration};
+
 pub use anime_data::*;
 
 /// Useful for specialised effects that required a grid of data
@@ -14,5 +17,55 @@ pub use anime_image::*;
 mod anime_diagonal;
 pub use anime_diagonal::*;
 
+mod anime_gif;
+pub use anime_gif::*;
+use error::AnimeError;
+
 /// Base errors that are possible
-pub mod error;
+pub mod error;
+
+// TODO: make schema to rebuild the full sequence without requiring saving the actual
+//  packet data
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub enum AniMeSequence {
+    /// Full gif sequence. Immutable.
+    Animation(AniMeGif),
+    /// Basic image, can have properties changed
+    Image(Box<AniMeDataBuffer>),
+    /// A pause to be used between sequences
+    Pause(Duration),
+}
+
+impl AniMeSequence {
+    pub fn gif(file: &Path, brightness: f32) -> Result<Self, AnimeError> {
+        let frames = AniMeGif::new(file, brightness)?;
+        Ok(Self::Animation(frames))
+    }
+
+    pub fn png(
+        file: &Path,
+        scale: Vec2,
+        angle: f32,
+        translation: Vec2,
+        brightness: f32,
+    ) -> Result<Self, AnimeError> {
+        let image = AniMeImage::from_png(file, scale, angle, translation, brightness)?;
+        let data = <AniMeDataBuffer>::from(&image);
+        Ok(Self::Image(Box::new(data)))
+    }
+
+    pub fn get_animation(&self) -> Option<&AniMeGif> {
+        match self {
+            AniMeSequence::Animation(anim) => Some(anim),
+            _ => None,
+        }
+    }
+
+    pub fn get_image(&self) -> Option<&AniMeDataBuffer> {
+        match self {
+            AniMeSequence::Image(image) => Some(image),
+            _ => None,
+        }
+    }
+}