448 lines
14 KiB
Rust
448 lines
14 KiB
Rust
mod daemon_ipc;
|
||
|
||
use ffmpeg_sidecar::{
|
||
command::{ffmpeg_is_installed, FfmpegCommand},
|
||
download::auto_download,
|
||
event::{FfmpegEvent, LogLevel},
|
||
paths::sidecar_path,
|
||
};
|
||
use serde_json::Value;
|
||
use std::fs;
|
||
use std::path::PathBuf;
|
||
|
||
/// Get the default output directory for recordings.
|
||
/// Uses the same directory structure as the record-daemon.
|
||
fn get_default_output_dir() -> Option<PathBuf> {
|
||
directories::ProjectDirs::from("com", "leaguerecorder", "record-daemon")
|
||
.map(|dirs| dirs.data_dir().join("recordings"))
|
||
}
|
||
|
||
/// Get the timeline storage directory.
|
||
/// Uses the same directory structure as the record-daemon.
|
||
fn get_timeline_dir() -> PathBuf {
|
||
get_default_output_dir()
|
||
.map(|p| p.join("timelines"))
|
||
.unwrap_or_else(|| PathBuf::from("./recordings/timelines"))
|
||
}
|
||
|
||
/// Load all timelines from disk as raw JSON values.
|
||
fn load_timelines() -> Vec<Value> {
|
||
let timeline_dir = get_timeline_dir();
|
||
let mut timelines = Vec::new();
|
||
|
||
if !timeline_dir.exists() {
|
||
return timelines;
|
||
}
|
||
|
||
if let Ok(entries) = fs::read_dir(&timeline_dir) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.extension().map(|e| e == "json").unwrap_or(false) {
|
||
if let Ok(contents) = fs::read_to_string(&path) {
|
||
if let Ok(timeline) = serde_json::from_str::<Value>(&contents) {
|
||
timelines.push(timeline);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Sort by start time, newest first
|
||
timelines.sort_by(|a, b| {
|
||
let a_time = a.get("start_time").and_then(|v| v.as_str()).unwrap_or("");
|
||
let b_time = b.get("start_time").and_then(|v| v.as_str()).unwrap_or("");
|
||
b_time.cmp(a_time)
|
||
});
|
||
timelines
|
||
}
|
||
|
||
/// Get game history - returns full timeline data for each game as raw JSON.
|
||
#[tauri::command]
|
||
fn get_game_history() -> Vec<Value> {
|
||
load_timelines()
|
||
}
|
||
|
||
/// Get a specific timeline by recording ID as raw JSON.
|
||
#[tauri::command]
|
||
fn get_timeline(recording_id: String) -> Option<Value> {
|
||
let timeline_dir = get_timeline_dir();
|
||
let path = timeline_dir.join(format!("{}.json", recording_id));
|
||
|
||
if path.exists() {
|
||
if let Ok(contents) = fs::read_to_string(&path) {
|
||
return serde_json::from_str::<Value>(&contents).ok();
|
||
}
|
||
}
|
||
|
||
None
|
||
}
|
||
|
||
/// Get the recordings directory path.
|
||
#[tauri::command]
|
||
fn get_recordings_dir() -> String {
|
||
get_default_output_dir()
|
||
.map(|p| p.to_string_lossy().to_string())
|
||
.unwrap_or_else(|| "./recordings".to_string())
|
||
}
|
||
|
||
/// Find a video file in the recordings directory.
|
||
/// Searches for exact filename match or pattern match.
|
||
#[tauri::command]
|
||
fn find_video_file(recordings_dir: String, filename: String) -> Option<String> {
|
||
let recordings_path = PathBuf::from(&recordings_dir);
|
||
|
||
if !recordings_path.exists() {
|
||
return None;
|
||
}
|
||
|
||
// Try exact match first
|
||
let exact_path = recordings_path.join(&filename);
|
||
if exact_path.exists() {
|
||
return Some(exact_path.to_string_lossy().to_string());
|
||
}
|
||
|
||
// Try to find by pattern (date_time_*.mp4)
|
||
if let Ok(entries) = fs::read_dir(&recordings_path) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.extension().map(|e| e == "mp4" || e == "mkv" || e == "mov").unwrap_or(false) {
|
||
let file_name = path.file_name()?.to_string_lossy().to_string();
|
||
|
||
// Check if filename starts with the same date/time pattern
|
||
// filename format: "2026-03-27_16-42-52_unknown.mp4"
|
||
// We match the date_time prefix
|
||
if file_name.starts_with(&filename.replace("_unknown.mp4", "")) {
|
||
return Some(path.to_string_lossy().to_string());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
None
|
||
}
|
||
|
||
/// Get list of video files in recordings directory.
|
||
#[tauri::command]
|
||
fn list_video_files(recordings_dir: String) -> Vec<String> {
|
||
let recordings_path = PathBuf::from(&recordings_dir);
|
||
let mut videos = Vec::new();
|
||
|
||
if !recordings_path.exists() {
|
||
return videos;
|
||
}
|
||
|
||
if let Ok(entries) = fs::read_dir(&recordings_path) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.extension().map(|e| e == "mp4" || e == "mkv" || e == "mov").unwrap_or(false) {
|
||
videos.push(path.to_string_lossy().to_string());
|
||
}
|
||
}
|
||
}
|
||
|
||
// Sort by modification time, newest first
|
||
videos.sort_by(|a, b| {
|
||
let a_time = fs::metadata(a).and_then(|m| m.modified()).ok();
|
||
let b_time = fs::metadata(b).and_then(|m| m.modified()).ok();
|
||
b_time.cmp(&a_time)
|
||
});
|
||
|
||
videos
|
||
}
|
||
|
||
/// Ensure ffmpeg is available, downloading if necessary.
|
||
fn ensure_ffmpeg() -> Result<(), String> {
|
||
if ffmpeg_is_installed() {
|
||
return Ok(());
|
||
}
|
||
|
||
// Auto-download ffmpeg for the current platform
|
||
auto_download().map_err(|e| format!("Failed to download ffmpeg: {}", e))?;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// Export a clip from a video using ffmpeg-sidecar (stream copy for speed).
|
||
#[tauri::command]
|
||
fn export_clip(
|
||
video_path: String,
|
||
start_time: f64,
|
||
end_time: f64,
|
||
output_name: String,
|
||
) -> Result<String, String> {
|
||
// Ensure ffmpeg is available
|
||
ensure_ffmpeg()?;
|
||
|
||
// Verify input file exists
|
||
if !PathBuf::from(&video_path).exists() {
|
||
return Err(format!("Video file not found: {}", video_path));
|
||
}
|
||
|
||
// Get output directory
|
||
let output_dir = get_default_output_dir()
|
||
.map(|p| p.join("clips"))
|
||
.unwrap_or_else(|| PathBuf::from("./clips"));
|
||
|
||
// Create clips directory if it doesn't exist
|
||
if !output_dir.exists() {
|
||
fs::create_dir_all(&output_dir)
|
||
.map_err(|e| format!("Failed to create clips directory: {}", e))?;
|
||
}
|
||
|
||
let output_path = output_dir.join(format!("{}.mp4", output_name));
|
||
let duration = end_time - start_time;
|
||
|
||
// Build ffmpeg command with stream copy (fast, no re-encoding)
|
||
// Note: Put -ss before -i for fast seeking (input seeking)
|
||
let iter = FfmpegCommand::new()
|
||
.arg("-y") // Overwrite output file
|
||
.arg("-ss").arg(&format!("{:.3}", start_time))
|
||
.arg("-i").arg(&video_path)
|
||
.arg("-t").arg(&format!("{:.3}", duration))
|
||
.arg("-c").arg("copy") // Stream copy for fast export
|
||
.arg("-avoid_negative_ts").arg("make_zero")
|
||
.arg(&output_path.to_string_lossy().to_string())
|
||
.spawn()
|
||
.map_err(|e| format!("Failed to spawn ffmpeg: {}", e))?
|
||
.iter()
|
||
.map_err(|e| format!("Failed to create ffmpeg iterator: {}", e))?;
|
||
|
||
// Process the ffmpeg command and collect all errors
|
||
let mut errors = Vec::new();
|
||
for event in iter {
|
||
match event {
|
||
FfmpegEvent::Error(e) => {
|
||
errors.push(format!("FFmpeg error: {}", e));
|
||
}
|
||
FfmpegEvent::Log(LogLevel::Error, msg) => {
|
||
errors.push(format!("FFmpeg log error: {}", msg));
|
||
}
|
||
FfmpegEvent::Log(LogLevel::Warning, msg) => {
|
||
// Log warnings but don't fail
|
||
eprintln!("FFmpeg warning: {}", msg);
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
// Check if output file was created
|
||
if !output_path.exists() {
|
||
return Err(format!(
|
||
"Export failed - output file not created. Errors: {}",
|
||
errors.join("; ")
|
||
));
|
||
}
|
||
|
||
// Check if output file has content
|
||
let metadata = fs::metadata(&output_path)
|
||
.map_err(|e| format!("Failed to check output file: {}", e))?;
|
||
if metadata.len() == 0 {
|
||
return Err(format!(
|
||
"Export failed - output file is empty. Errors: {}",
|
||
errors.join("; ")
|
||
));
|
||
}
|
||
|
||
Ok(output_path.to_string_lossy().to_string())
|
||
}
|
||
|
||
/// Export a clip with re-encoding for more precise cuts.
|
||
#[tauri::command]
|
||
fn export_clip_precise(
|
||
video_path: String,
|
||
start_time: f64,
|
||
end_time: f64,
|
||
output_name: String,
|
||
quality: String,
|
||
) -> Result<String, String> {
|
||
// Ensure ffmpeg is available
|
||
ensure_ffmpeg()?;
|
||
|
||
// Verify input file exists
|
||
if !PathBuf::from(&video_path).exists() {
|
||
return Err(format!("Video file not found: {}", video_path));
|
||
}
|
||
|
||
let output_dir = get_default_output_dir()
|
||
.map(|p| p.join("clips"))
|
||
.unwrap_or_else(|| PathBuf::from("./clips"));
|
||
|
||
if !output_dir.exists() {
|
||
fs::create_dir_all(&output_dir)
|
||
.map_err(|e| format!("Failed to create clips directory: {}", e))?;
|
||
}
|
||
|
||
let output_path = output_dir.join(format!("{}.mp4", output_name));
|
||
let duration = end_time - start_time;
|
||
|
||
// Quality presets (CRF values - lower is better quality)
|
||
let crf = match quality.as_str() {
|
||
"low" => "28",
|
||
"medium" => "23",
|
||
"high" => "18",
|
||
_ => "23",
|
||
};
|
||
|
||
// Build ffmpeg command with re-encoding
|
||
let iter = FfmpegCommand::new()
|
||
.arg("-y") // Overwrite output file
|
||
.arg("-ss").arg(&format!("{:.3}", start_time))
|
||
.arg("-i").arg(&video_path)
|
||
.arg("-t").arg(&format!("{:.3}", duration))
|
||
.arg("-c:v").arg("libx264")
|
||
.arg("-crf").arg(crf)
|
||
.arg("-preset").arg("fast")
|
||
.arg("-c:a").arg("aac")
|
||
.arg("-b:a").arg("128k")
|
||
.arg(&output_path.to_string_lossy().to_string())
|
||
.spawn()
|
||
.map_err(|e| format!("Failed to spawn ffmpeg: {}", e))?
|
||
.iter()
|
||
.map_err(|e| format!("Failed to create ffmpeg iterator: {}", e))?;
|
||
|
||
// Process the ffmpeg command and collect all errors
|
||
let mut errors = Vec::new();
|
||
for event in iter {
|
||
match event {
|
||
FfmpegEvent::Error(e) => {
|
||
errors.push(format!("FFmpeg error: {}", e));
|
||
}
|
||
FfmpegEvent::Log(LogLevel::Error, msg) => {
|
||
errors.push(format!("FFmpeg log error: {}", msg));
|
||
}
|
||
FfmpegEvent::Log(LogLevel::Warning, msg) => {
|
||
eprintln!("FFmpeg warning: {}", msg);
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
// Check if output file was created
|
||
if !output_path.exists() {
|
||
return Err(format!(
|
||
"Export failed - output file not created. Errors: {}",
|
||
errors.join("; ")
|
||
));
|
||
}
|
||
|
||
// Check if output file has content
|
||
let metadata = fs::metadata(&output_path)
|
||
.map_err(|e| format!("Failed to check output file: {}", e))?;
|
||
if metadata.len() == 0 {
|
||
return Err(format!(
|
||
"Export failed - output file is empty. Errors: {}",
|
||
errors.join("; ")
|
||
));
|
||
}
|
||
|
||
Ok(output_path.to_string_lossy().to_string())
|
||
}
|
||
|
||
/// Check if ffmpeg is available.
|
||
#[tauri::command]
|
||
fn check_ffmpeg() -> bool {
|
||
ffmpeg_is_installed()
|
||
}
|
||
|
||
/// Download ffmpeg if not already installed.
|
||
#[tauri::command]
|
||
fn download_ffmpeg() -> Result<String, String> {
|
||
ensure_ffmpeg()?;
|
||
Ok(sidecar_path().unwrap_or_default().to_string_lossy().to_string())
|
||
}
|
||
|
||
/// Get video file metadata using ffprobe.
|
||
#[tauri::command]
|
||
fn get_video_metadata(video_path: String) -> Result<Value, String> {
|
||
// Ensure ffmpeg is available
|
||
ensure_ffmpeg()?;
|
||
|
||
// Use ffprobe via ffmpeg-sidecar
|
||
let iter = FfmpegCommand::new()
|
||
.arg("-v").arg("quiet")
|
||
.arg("-print_format").arg("json")
|
||
.arg("-show_format")
|
||
.arg("-show_streams")
|
||
.arg(&video_path)
|
||
.spawn()
|
||
.map_err(|e| format!("Failed to spawn ffprobe: {}", e))?
|
||
.iter()
|
||
.map_err(|e| format!("Failed to create ffprobe iterator: {}", e))?;
|
||
|
||
let mut json_output = String::new();
|
||
|
||
for event in iter {
|
||
match event {
|
||
FfmpegEvent::Log(LogLevel::Info, msg) | FfmpegEvent::Log(LogLevel::Unknown, msg) => {
|
||
// Capture JSON output
|
||
if msg.trim().starts_with('{') || msg.trim().starts_with('[') {
|
||
json_output.push_str(&msg);
|
||
}
|
||
}
|
||
FfmpegEvent::Error(e) => {
|
||
return Err(format!("FFprobe error: {}", e));
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
// Parse the JSON output
|
||
serde_json::from_str(&json_output)
|
||
.map_err(|e| format!("Failed to parse ffprobe output: {}", e))
|
||
}
|
||
|
||
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
||
pub fn run() {
|
||
tauri::Builder::default()
|
||
.plugin(tauri_plugin_opener::init())
|
||
.setup(|app| {
|
||
// Auto-start the record-daemon on app launch.
|
||
// We spawn a background task so the UI isn't blocked while the
|
||
// daemon boots (it can take a few seconds to initialise OBS).
|
||
let handle = app.handle().clone();
|
||
tauri::async_runtime::spawn(async move {
|
||
match daemon_ipc::ensure_daemon_running(30).await {
|
||
Ok(true) => {
|
||
eprintln!("[tauri] record-daemon is running");
|
||
}
|
||
Ok(false) => {
|
||
eprintln!("[tauri] record-daemon did not become ready within the timeout");
|
||
}
|
||
Err(e) => {
|
||
eprintln!("[tauri] failed to start record-daemon: {}", e);
|
||
}
|
||
}
|
||
// Drop the handle – no further use
|
||
drop(handle);
|
||
});
|
||
Ok(())
|
||
})
|
||
.invoke_handler(tauri::generate_handler![
|
||
get_game_history,
|
||
get_timeline,
|
||
get_recordings_dir,
|
||
find_video_file,
|
||
list_video_files,
|
||
export_clip,
|
||
export_clip_precise,
|
||
check_ffmpeg,
|
||
download_ffmpeg,
|
||
get_video_metadata,
|
||
// Daemon IPC commands
|
||
daemon_ipc::daemon_is_running,
|
||
daemon_ipc::daemon_ensure_running,
|
||
daemon_ipc::daemon_get_status,
|
||
daemon_ipc::daemon_get_settings,
|
||
daemon_ipc::daemon_update_settings,
|
||
daemon_ipc::daemon_reset_settings,
|
||
daemon_ipc::daemon_get_encoders,
|
||
daemon_ipc::daemon_start_recording,
|
||
daemon_ipc::daemon_stop_recording,
|
||
daemon_ipc::daemon_shutdown,
|
||
daemon_ipc::daemon_get_log_path,
|
||
daemon_ipc::daemon_read_logs,
|
||
])
|
||
.run(tauri::generate_context!())
|
||
.expect("error while running tauri application");
|
||
}
|