krec 0.3.1

K-Scale robot action format
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::KRec;
use color_eyre::{eyre::eyre, Result};
use std::path::Path;
use tempfile::NamedTempFile;
use thiserror::Error;
use tracing::{debug, info, instrument, warn};

#[derive(Error, Debug)]
pub enum FFmpegError {
    #[error("FFmpeg error: {0}")]
    FFmpeg(String),
    #[error("Input file not found: {0}")]
    InputNotFound(String),
}

#[instrument(skip(video_path, krec_path, output_path))]
pub fn combine_with_video(
    video_path: impl AsRef<Path>,
    krec_path: impl AsRef<Path>,
    output_path: impl AsRef<Path>,
    verbose: Option<bool>,
) -> Result<()> {
    info!("Combining video with KRec data");
    debug!(
        "Video: {}, KRec: {}, Output: {}",
        video_path.as_ref().display(),
        krec_path.as_ref().display(),
        output_path.as_ref().display()
    );

    // Read the KRec file to get UUID and task
    let krec = KRec::load(
        krec_path
            .as_ref()
            .to_str()
            .ok_or_else(|| eyre!("Invalid KRec path: {}", krec_path.as_ref().display()))?,
    )?;

    if krec.header.uuid.is_empty() {
        return Err(eyre!("KRec file missing UUID"));
    }

    if krec.header.task.is_empty() {
        return Err(eyre!("KRec file missing task"));
    }

    if krec.header.robot_platform.is_empty() {
        return Err(eyre!("KRec file missing robot platform"));
    }

    if krec.header.robot_serial.is_empty() {
        return Err(eyre!("KRec file missing robot serial"));
    }

    let mut command = std::process::Command::new("ffmpeg");
    command.args([
        "-y", // Add -y flag to automatically overwrite files
        "-i",
        &video_path.as_ref().to_string_lossy(),
        "-attach",
        &krec_path.as_ref().to_string_lossy(),
        "-metadata:s:t",
        "mimetype=application/octet-stream",
        "-metadata:s:t",
        &format!("uuid={}", krec.header.uuid),
        "-metadata:s:t",
        &format!("task={}", krec.header.task),
        "-metadata:s:t",
        &format!("robot_platform={}", krec.header.robot_platform),
        "-metadata:s:t",
        &format!("robot_serial={}", krec.header.robot_serial),
        "-c",
        "copy",
        &output_path.as_ref().to_string_lossy(),
    ]);

    // Control ffmpeg output based on verbose flag
    if !verbose.unwrap_or(false) {
        command
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null());
    }

    let status = command
        .status()
        .map_err(|e| eyre!("Failed to execute ffmpeg: {}", e))?;

    if status.success() {
        info!("Successfully combined video with KRec data");
        Ok(())
    } else {
        let err = eyre!("FFmpeg command failed with status: {}", status);
        warn!("{}", err);
        Err(err)
    }
}

pub fn extract_from_video(video_path: &str, verbose: Option<bool>) -> Result<KRec, FFmpegError> {
    info!("Starting extract_from_video");

    // Check if input file exists
    if !Path::new(video_path).exists() {
        return Err(FFmpegError::InputNotFound(video_path.to_string()));
    }

    // Create a temporary file for FFmpeg output
    let temp_file = NamedTempFile::new()
        .map_err(|e| FFmpegError::FFmpeg(format!("Failed to create temporary file: {}", e)))?;
    let temp_path = temp_file.path().to_string_lossy().to_string();

    // Construct ffmpeg command
    let mut command = std::process::Command::new("ffmpeg");
    command.args([
        "-y",
        "-dump_attachment:t:0",
        &temp_path,
        "-i",
        video_path,
        "-f",
        "null",
        "/dev/null",
    ]);

    // Control ffmpeg output based on verbose flag
    if !verbose.unwrap_or(false) {
        command
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null());
    }

    debug!("Constructed ffmpeg command: {:?}", command);

    let status = command.status().map_err(|e| {
        warn!("Failed to execute ffmpeg: {}", e);
        FFmpegError::FFmpeg(e.to_string())
    })?;

    if !status.success() {
        let error_msg = format!("FFmpeg command failed with status: {}", status);
        warn!("{}", error_msg);
        return Err(FFmpegError::FFmpeg(error_msg));
    }

    // Load the KRec from the temporary file
    let krec = KRec::load(&temp_path).map_err(|e| {
        FFmpegError::FFmpeg(format!("Failed to load KRec from temporary file: {}", e))
    })?;

    // The temporary file will be automatically deleted when temp_file goes out of scope
    info!("Successfully extracted KRec from video");
    Ok(krec)
}