Skip to main content

vidsage_core/video/
processor.rs

1//! Video processor implementation
2
3use std::path::PathBuf;
4
5use super::metadata::{VideoFormat, VideoQuality};
6use super::VideoMetadata;
7use serde::{Deserialize, Serialize};
8
9/// Compression level settings
10#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
11pub enum CompressionLevel {
12    #[serde(rename = "low")]
13    Low,
14    #[serde(rename = "medium")]
15    Medium,
16    #[serde(rename = "high")]
17    High,
18    #[serde(rename = "ultra")]
19    Ultra,
20    #[serde(rename = "custom")]
21    Custom(f32), // Compression ratio (0.1-1.0)
22}
23
24/// Processing status enumeration
25#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
26pub enum ProcessingStatus {
27    #[serde(rename = "pending")]
28    Pending,
29    #[serde(rename = "processing")]
30    Processing {
31        progress: u8, // 0-100%
32        current_step: String,
33    },
34    #[serde(rename = "completed")]
35    Completed,
36    #[serde(rename = "failed")]
37    Failed { error: String },
38    #[serde(rename = "cancelled")]
39    Cancelled,
40}
41
42/// Video processing options
43#[derive(Debug, Clone, Serialize, Deserialize)]
44pub struct ProcessOptions {
45    /// Output video quality
46    pub quality: VideoQuality,
47
48    /// Output video format
49    pub format: VideoFormat,
50
51    /// Compression level
52    pub compression: CompressionLevel,
53
54    /// Whether to extract audio
55    pub extract_audio: bool,
56
57    /// Whether to extract metadata
58    pub extract_metadata: bool,
59
60    /// Output resolution (optional, defaults to original)
61    pub resolution: Option<(u32, u32)>,
62
63    /// Output frame rate (optional, defaults to original)
64    pub frame_rate: Option<f64>,
65
66    /// Whether to enable hardware acceleration
67    pub hardware_acceleration: bool,
68
69    /// Number of threads to use for processing
70    pub threads: Option<u32>,
71}
72
73impl Default for ProcessOptions {
74    fn default() -> Self {
75        Self {
76            quality: VideoQuality::Medium,
77            format: VideoFormat::MP4,
78            compression: CompressionLevel::Medium,
79            extract_audio: false,
80            extract_metadata: true,
81            resolution: None,
82            frame_rate: None,
83            hardware_acceleration: true,
84            threads: None,
85        }
86    }
87}
88
89/// Video data structure for processing
90#[derive(Debug, Clone, Serialize, Deserialize)]
91pub struct VideoData {
92    /// Video metadata
93    pub metadata: VideoMetadata,
94
95    /// Path to the video file
96    pub path: PathBuf,
97
98    /// Whether the video is processed
99    pub is_processed: bool,
100
101    /// Processing job ID (if any)
102    pub job_id: Option<String>,
103}
104
105/// Video processing output
106#[derive(Debug, Clone, Serialize, Deserialize)]
107pub struct VideoOutput {
108    /// Processed video metadata
109    pub metadata: VideoMetadata,
110
111    /// Path to the processed video file
112    pub processed_path: PathBuf,
113
114    /// Processing status
115    pub status: ProcessingStatus,
116
117    /// Processing time in seconds
118    pub processing_time: f64,
119
120    /// Original file path
121    pub original_path: PathBuf,
122
123    /// Extracted audio path (if requested)
124    pub audio_path: Option<PathBuf>,
125
126    /// Extracted metadata (if requested)
127    pub extracted_metadata: Option<VideoMetadata>,
128}