Serve video gifs when requested

src/video/ffmpeg.rs

@@ -156,7 +156,7 @@ impl Ffmpeg {
     }
 
     async fn create_gif_from_frames(&self, frame_base_dir: &str, output_file: &str) -> Result<i32> {
-        Command::new("ffmpeg")
+        let output = Command::new("ffmpeg")
             .arg("-y")
             .args(["-framerate", "4"])
             .args(["-i", &format!("{}/frame_%03d.jpg", frame_base_dir)])
@@ -169,10 +169,20 @@ impl Ffmpeg {
             .args(["-loop", "0"]) // loop forever
             .args(["-final_delay", "75"])
             .arg(output_file)
-            .stderr(Stdio::null())
-            .status()
-            .map_ok(|out| out.code().unwrap_or(-1))
-            .inspect_ok(|output| debug!("ffmpeg gif create exit code: {:?}", output))
-            .await
+            .stderr(Stdio::piped()) // Change this to capture stderr
+            .stdout(Stdio::piped()) // Optionally capture stdout too
+            .output()
+            .await?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            error!("FFmpeg error: {}", stderr);
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            debug!("FFmpeg stdout: {}", stdout);
+        } else {
+            debug!("FFmpeg successful with exit code: {}", output.status);
+        }
+
+        Ok(output.status.code().unwrap_or(-1))
     }
-}
+}

src/video/mod.rs

@@ -1,2 +1,67 @@
+use crate::otel::global_tracer;
+use crate::video::ffmpeg::{Ffmpeg, GifType};
+use crate::{is_video, update_media_counts};
+use log::{info};
+use opentelemetry::trace::{Tracer};
+use std::path::{Path, PathBuf};
+use std::{fs};
+use walkdir::WalkDir;
+
 pub mod actors;
 pub mod ffmpeg;
+
+pub async fn generate_video_gifs() {
+    tokio::spawn(async {
+        info!("Starting to make video gifs");
+
+        let start = std::time::Instant::now();
+        let tracer = global_tracer();
+        let span = tracer.start("creating video gifs");
+
+        let gif_base_path = &dotenv::var("GIFS_DIRECTORY").unwrap_or(String::from("gifs"));
+        let gif_directory: &Path = Path::new(gif_base_path);
+        fs::create_dir_all(gif_base_path).expect("There was an issue creating directory");
+
+        let files = PathBuf::from(dotenv::var("BASE_PATH").unwrap());
+
+        let ffmpeg = Ffmpeg;
+        for file in WalkDir::new(&files)
+            .into_iter()
+            .filter_map(|entry| entry.ok())
+            .filter(|entry| entry.file_type().is_file())
+            .filter(|entry| is_video(entry))
+            .filter(|entry| {
+                let path = entry.path();
+                let relative_path = &path.strip_prefix(&files).unwrap();
+                let thumb_path = Path::new(gif_directory).join(relative_path);
+                let gif_path = thumb_path.with_extension("gif");
+                !gif_path.exists()
+            })
+        {
+            let path = file.path();
+            let relative_path = &path.strip_prefix(&files).unwrap();
+            let gif_path = Path::new(gif_directory).join(relative_path);
+            let gif_path = gif_path.with_extension("gif");
+            if let Some(parent_dir) = gif_path.parent() {
+                fs::create_dir_all(parent_dir).expect(&format!(
+                    "There was an issue creating gif directory {:?}",
+                    gif_path
+                ));
+            }
+            info!("Generating gif for {:?}", path);
+
+            ffmpeg
+                .generate_video_gif(
+                    path.to_str().unwrap(),
+                    gif_path.to_str().unwrap(),
+                    GifType::Overview,
+                )
+                .await
+                .expect("There was an issue generating the gif");
+        }
+
+        info!("Finished making video gifs in {:?}", start.elapsed());
+
+        update_media_counts(&files);
+    });
+}