feat(#36): Add framerate cli option

- add a framerate cli argument `-f | --framerate`
- limit the possible framerates to 4 and 8 for now
- introduce new wrapper types for better readability
- adjust the docs

- retyping of u128 to Timecode not everywhere fully clean
- the framedrop mechanism is not thread safe solid

Author: sassman

Cargo.lock

@@ -27,6 +27,7 @@ env_logger = "0.9.0"
 simplerand = "1.3.0"
 humantime = "2.1.0"
 crossbeam-channel = "0.5"
+blockhash = "0.3"
 
 [dependencies.clap]
 version = "3.1.9"

Cargo.toml

@@ -0,0 +1,55 @@
+use anyhow::Context;
+pub use blockhash::Image;
+use image::flat::View;
+use image::ColorType::Rgba8;
+use image::{save_buffer, FlatSamples, GenericImageView, Rgba};
+use tempfile::TempDir;
+
+use crate::capture::Timecode;
+use crate::utils::IMG_EXT;
+use crate::{ImageOnHeap, Result};
+
+pub struct Frame(FlatSamples<Vec<u8>>);
+
+impl Frame {
+    /// saves a frame as a IMG_EXT file
+    pub fn save(
+        &self,
+        tc: &Timecode,
+        tempdir: &TempDir,
+        file_name_for: fn(&Timecode, &str) -> String,
+    ) -> Result<()> {
+        let image = self.as_ref();
+        save_buffer(
+            tempdir.path().join(file_name_for(tc, IMG_EXT)),
+            &image.samples,
+            image.layout.width,
+            image.layout.height,
+            image.color_hint.unwrap_or(Rgba8),
+        )
+        .context("Cannot save frame")
+    }
+}
+
+impl Image for Frame {
+    fn dimensions(&self) -> (u32, u32) {
+        (self.0.layout.width, self.0.layout.height)
+    }
+
+    fn get_pixel(&self, x: u32, y: u32) -> [u8; 4] {
+        let image: View<_, Rgba<u8>> = self.0.as_view().unwrap();
+        image.get_pixel(x, y).0
+    }
+}
+
+impl AsRef<FlatSamples<Vec<u8>>> for Frame {
+    fn as_ref(&self) -> &FlatSamples<Vec<u8>> {
+        &self.0
+    }
+}
+
+impl From<ImageOnHeap> for Frame {
+    fn from(img: ImageOnHeap) -> Self {
+        Self(*img)
+    }
+}

src/capture/frame.rs

@@ -1,5 +1,9 @@
+mod frame;
 mod framerate;
 mod processor;
+mod timecode;
 
+pub use frame::*;
 pub use framerate::*;
 pub use processor::*;
+pub use timecode::*;

src/capture/mod.rs

@@ -1,36 +1,40 @@
-use anyhow::Context;
+use blockhash::{blockhash256, Blockhash256};
 use crossbeam_channel::Receiver;
-use image::save_buffer;
-use image::ColorType::Rgba8;
 use rayon::ThreadPoolBuilder;
 use std::borrow::Borrow;
 use std::ops::Sub;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use tempfile::TempDir;
 
-use crate::capture::Framerate;
-use crate::utils::{file_name_for, IMG_EXT};
-use crate::{ImageOnHeap, PlatformApi, Result, WindowId};
+use crate::capture::{Framerate, Timecode};
+use crate::utils::file_name_for;
+use crate::{Frame, PlatformApi, Result, WindowId};
 
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, Clone)]
 pub enum FrameDropStrategy {
     DoNotDropAny,
     DropIdenticalFrames,
 }
 
 #[derive(Clone)]
-struct FrameComparator<'a> {
-    last_frame: Option<ImageOnHeap>,
-    strategy: &'a FrameDropStrategy,
+struct FrameComparator {
+    last_frames: Vec<(Timecode, Timecode, Blockhash256)>,
+    _strategy: FrameDropStrategy,
 }
 
-impl<'a> FrameComparator<'a> {
-    pub fn drop_frame(&mut self, frame: ImageOnHeap) -> bool {
-        if self.last_frame.is_none() {
-            self.last_frame = Some(frame);
-            false
+impl FrameComparator {
+    pub fn should_drop_frame(&mut self, timecode: &Timecode, frame: &Frame) -> bool {
+        let hash = blockhash256(frame);
+        if let Some((_last_time_code, _other_time_code, last_hash)) = self.last_frames.last() {
+            let last_eq = last_hash == &hash;
+            if !last_eq {
+                self.last_frames.pop();
+                self.last_frames.push((timecode.clone(), hash));
+            }
+            last_eq
         } else {
+            self.last_frames.push((timecode.clone(), hash));
             false
         }
     }
@@ -43,23 +47,23 @@ pub fn capture_thread(
     rx: &Receiver<()>,
     api: impl PlatformApi + Sync,
     win_id: WindowId,
-    time_codes: Arc<Mutex<Vec<u128>>>,
-    tempdir: Arc<Mutex<TempDir>>,
+    time_codes: Arc<Mutex<Vec<Timecode>>>,
+    tempdir: Arc<TempDir>,
     frame_drop_strategy: &FrameDropStrategy,
     framerate: &Framerate,
 ) -> Result<()> {
     let pool = ThreadPoolBuilder::default().build()?;
     let duration = Duration::from_secs(1) / *framerate.as_ref();
     let start = Instant::now();
-    let mut idle_duration = Duration::from_millis(0);
-    let mut last_frame: Option<ImageOnHeap> = None;
-    let mut identical_frames = 0;
+    // let mut idle_duration = Duration::from_millis(0);
+    // let mut last_frame: Option<ImageOnHeap> = None;
+    // let mut identical_frames = 0;
     let mut last_time = Instant::now();
     let api = Arc::new(api);
-    let comp = Arc::new(FrameComparator {
-        last_frame: None,
-        strategy: frame_drop_strategy,
-    });
+    let comp = Arc::new(Mutex::new(FrameComparator {
+        last_frames: Vec::new(),
+        _strategy: frame_drop_strategy.clone(),
+    }));
     // let rx = Arc::new(rx);
     // let mut results: Arc<Mutex<Vec<Result<()>>>> = Arc::new(Mutex::new(Vec::new()));
 
@@ -72,26 +76,32 @@ pub fn capture_thread(
             if rx.recv_timeout(sleep_time).is_ok() {
                 if pool.current_thread_has_pending_tasks().unwrap_or(false) {
                     println!(
-                        "there is a backlog of frames that needs to be persisted, this may take a bit ...",
+                        "there is a backlog of frames that needs to be stored, this may take a bit ...",
                     );
                 }
                 return;
             }
             let now = Instant::now();
-            let timecode = now.saturating_duration_since(start).as_millis();
-            // let effective_now = now.sub(idle_duration);
-            let api = api.clone();
-            let tempdir = tempdir.clone();
-            time_codes.lock().unwrap().push(timecode);
-
-            s.spawn(move |_| {
-                let frame = api.capture_window_screenshot(win_id);
+            s.spawn({
+                let api = api.clone();
+                let tempdir = tempdir.clone();
+                let comp = comp.clone();
+                let time_codes = time_codes.clone();
+                move |_| {
+                    let tc: Timecode = now.saturating_duration_since(start).as_millis().into();
 
-                if let Ok(frame) = frame {
-                    save_frame(&frame, timecode, tempdir.borrow(), file_name_for).unwrap();
-                    // results.borrow_mut().lock().unwrap().push(result);
+                    let frame = api.capture_window_screenshot(win_id);
+                    if let Ok(frame) = frame {
+                        let frame: Frame = frame.into();
+                        if comp.lock().unwrap().should_drop_frame(&tc, &frame) {
+                            return;
+                        }
+                        frame.save(&tc, tempdir.borrow(), file_name_for).unwrap();
+                        time_codes.lock().unwrap().push(tc);
+                        // results.borrow_mut().lock().unwrap().push(result);
+                    }
                 }
-            });
+           });
 
             /*
             let image = api.capture_window_screenshot(win_id)?;
@@ -129,20 +139,3 @@ pub fn capture_thread(
 
     Ok(())
 }
-
-/// saves a frame as a tga file
-pub fn save_frame(
-    image: &ImageOnHeap,
-    time_code: u128,
-    tempdir: &TempDir,
-    file_name_for: fn(&u128, &str) -> String,
-) -> Result<()> {
-    save_buffer(
-        tempdir.path().join(file_name_for(&time_code, IMG_EXT)),
-        &image.samples,
-        image.layout.width,
-        image.layout.height,
-        image.color_hint.unwrap_or(Rgba8),
-    )
-    .context("Cannot save frame")
-}

src/capture/processor.rs

@@ -0,0 +1,14 @@
+#[derive(Clone, Debug)]
+pub struct Timecode(u32);
+
+impl AsRef<u32> for Timecode {
+    fn as_ref(&self) -> &u32 {
+        &self.0
+    }
+}
+
+impl From<u128> for Timecode {
+    fn from(x: u128) -> Self {
+        Self(x as u32)
+    }
+}

src/capture/timecode.rs

@@ -1,17 +1,17 @@
 use crate::common::Margin;
-use crate::{Image, ImageOnHeap, Result};
+use crate::{ImageOnHeap, Result};
 use image::flat::View;
 use image::{imageops, GenericImageView, ImageBuffer, Rgba};
 
 ///
 /// specialized version of crop for [`ImageOnHeap`] and [`Margin`]
 ///
 #[cfg_attr(not(macos), allow(dead_code))]
-pub fn crop(image: Image, margin: &Margin) -> Result<ImageOnHeap> {
+pub fn crop(image: crate::Image, margin: &Margin) -> Result<ImageOnHeap> {
     let mut img2: View<_, Rgba<u8>> = image.as_view()?;
     let (width, height) = (
-        img2.width() - (margin.left + margin.right) as u32,
-        img2.height() - (margin.top + margin.bottom) as u32,
+        img2.dimensions().0 - (margin.left + margin.right) as u32,
+        img2.dimensions().1 - (margin.top + margin.bottom) as u32,
     );
     let image_cropped = imageops::crop(
         &mut img2,

src/common/image.rs

@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 use std::process::Command;
 
+use crate::capture::Timecode;
 use anyhow::Context;
 use rayon::prelude::*;
 use tempfile::TempDir;
@@ -18,7 +19,7 @@ use crate::Result;
 ///     -layers merge \
 ///     t-rec-frame-000000251.tga
 /// ```
-pub fn apply_shadow_effect(time_codes: &[u128], tempdir: &TempDir, bg_color: String) {
+pub fn apply_shadow_effect(time_codes: &[Timecode], tempdir: &TempDir, bg_color: String) {
     apply_effect(
         time_codes,
         tempdir,
@@ -56,7 +57,7 @@ pub fn apply_shadow_effect(time_codes: &[u128], tempdir: &TempDir, bg_color: Str
 ///      \) -alpha off -compose CopyOpacity -composite \
 ///    t-rec-frame-000000251.tga
 /// ```
-pub fn apply_big_sur_corner_effect(time_codes: &[u128], tempdir: &TempDir) {
+pub fn apply_big_sur_corner_effect(time_codes: &[Timecode], tempdir: &TempDir) {
     let radius = 13;
     apply_effect(
         time_codes,
@@ -96,7 +97,7 @@ pub fn apply_big_sur_corner_effect(time_codes: &[u128], tempdir: &TempDir) {
 /// apply a given effect (closure) to all frames
 ///
 fn apply_effect(
-    time_codes: &[u128],
+    time_codes: &[Timecode],
     tempdir: &TempDir,
     effect: Box<dyn Fn(PathBuf) -> Result<()> + Send + Sync>,
 ) {

src/decor_effect.rs

@@ -1,5 +1,6 @@
 use crate::utils::{file_name_for, IMG_EXT};
 
+use crate::capture::Timecode;
 use anyhow::{bail, Context, Result};
 use std::ops::Div;
 use std::process::{Command, Output};
@@ -27,7 +28,7 @@ pub fn check_for_imagemagick() -> Result<Output> {
 ///
 /// generating the final gif with help of convert
 pub fn generate_gif_with_convert(
-    time_codes: &[u128],
+    time_codes: &[Timecode],
     tempdir: &TempDir,
     target: &str,
     start_pause: Option<Duration>,
@@ -43,10 +44,11 @@ pub fn generate_gif_with_convert(
         // houston we have a problem
         bail!("We got no frames :(");
     }
-    let last_frame_i = *last_frame_i.unwrap();
+    let last_frame_i = *last_frame_i.unwrap().as_ref();
     for (i, tc) in time_codes.iter().enumerate() {
+        let tc = tc.as_ref();
         delay = *tc - delay;
-        let frame = temp.join(file_name_for(tc, IMG_EXT));
+        let frame = temp.join(file_name_for(&Timecode::from(*tc as u128), IMG_EXT));
         if !frame.exists() {
             continue;
         }
@@ -55,7 +57,7 @@ pub fn generate_gif_with_convert(
             (0, Some(delay), _) => {
                 frame_delay += delay.as_millis().div(10) as u64;
             }
-            (i, _, Some(delay)) if i as u128 == last_frame_i => {
+            (i, _, Some(delay)) if i as u32 == last_frame_i => {
                 frame_delay += delay.as_millis().div(10) as u64;
             }
             (_, _, _) => {}

src/generators/gif.rs

@@ -1,5 +1,6 @@
 use std::process::Command;
 
+use crate::capture::Timecode;
 use anyhow::{Context, Result};
 use tempfile::TempDir;
 
@@ -37,7 +38,7 @@ pub fn check_for_ffmpeg() -> Result<()> {
 ///
 /// generating the final mp4 with help of ffmpeg
 pub fn generate_mp4_with_ffmpeg(
-    _time_codes: &[u128],
+    _time_codes: &[Timecode],
     tempdir: &TempDir,
     target: &str,
 ) -> Result<()> {