first version

sam-tool-tauri/src-tauri/src/video.rs

@@ -0,0 +1,106 @@
+use serde::Serialize;
+use std::path::Path;
+use std::process::Command;
+
+#[derive(Serialize, Clone, Debug)]
+pub struct VideoInfo {
+    pub path: String,
+    pub width: u32,
+    pub height: u32,
+    pub fps: f64,
+    pub total_frames: u64,
+    pub duration_s: f64,
+    /// Suggested output folder for this video, derived from the video path so
+    /// the same folder is produced on each re-open. Frontend uses this to
+    /// auto-restore the extracted-frame set without the user re-picking.
+    pub default_output_folder: String,
+}
+
+pub fn default_output_folder(path: &Path) -> String {
+    let stem = path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("video");
+    let parent = path.parent().unwrap_or_else(|| Path::new("."));
+    parent
+        .join(format!("{stem}_extracted"))
+        .display()
+        .to_string()
+}
+
+fn parse_rational(s: &str) -> Option<f64> {
+    let (n, d) = s.split_once('/')?;
+    let n: f64 = n.parse().ok()?;
+    let d: f64 = d.parse().ok()?;
+    if d == 0.0 {
+        None
+    } else {
+        Some(n / d)
+    }
+}
+
+pub fn probe(path: &Path) -> Result<VideoInfo, String> {
+    let path_str = path.to_str().ok_or_else(|| "invalid path".to_string())?;
+    let out = Command::new("ffprobe")
+        .args([
+            "-v",
+            "error",
+            "-select_streams",
+            "v:0",
+            "-show_entries",
+            "stream=width,height,r_frame_rate,avg_frame_rate,nb_frames,duration",
+            "-show_entries",
+            "format=duration",
+            "-of",
+            "json",
+            path_str,
+        ])
+        .output()
+        .map_err(|e| format!("ffprobe spawn failed: {e}"))?;
+    if !out.status.success() {
+        return Err(format!(
+            "ffprobe exited {}: {}",
+            out.status,
+            String::from_utf8_lossy(&out.stderr)
+        ));
+    }
+    let json: serde_json::Value =
+        serde_json::from_slice(&out.stdout).map_err(|e| format!("ffprobe json: {e}"))?;
+    let stream = &json["streams"][0];
+    if stream.is_null() {
+        return Err("no video stream found".into());
+    }
+    let width = stream["width"]
+        .as_u64()
+        .ok_or("stream.width missing")? as u32;
+    let height = stream["height"]
+        .as_u64()
+        .ok_or("stream.height missing")? as u32;
+    let fps = stream["r_frame_rate"]
+        .as_str()
+        .and_then(parse_rational)
+        .or_else(|| stream["avg_frame_rate"].as_str().and_then(parse_rational))
+        .ok_or("cannot parse fps")?;
+    let duration_s = stream["duration"]
+        .as_str()
+        .and_then(|s| s.parse::<f64>().ok())
+        .or_else(|| {
+            json["format"]["duration"]
+                .as_str()
+                .and_then(|s| s.parse::<f64>().ok())
+        })
+        .ok_or("cannot parse duration")?;
+    let total_frames = stream["nb_frames"]
+        .as_str()
+        .and_then(|s| s.parse::<u64>().ok())
+        .unwrap_or_else(|| (fps * duration_s).round() as u64);
+    Ok(VideoInfo {
+        path: path.display().to_string(),
+        width,
+        height,
+        fps,
+        total_frames,
+        duration_s,
+        default_output_folder: default_output_folder(path),
+    })
+}