[*] refactor: video editor

Author: heng30

wayshot/src/logic/video_editor/preview.rs

@@ -1,10 +1,13 @@
 use super::command::with_history_manager;
-use crate::{global_store, logic_cb, logic::toast, slint_generatedAppWindow::AppWindow};
+use crate::{
+    global_store, logic::toast, logic_cb,
+    slint_generatedAppWindow::AppWindow,
+};
 use slint::ComponentHandle;
 use std::{sync::Arc, time::Duration};
 use video_editor::{
-    preview::playback::{PlaybackController, PlaybackState},
     preview::config::PreviewConfig,
+    preview::playback::{PlaybackController, PlaybackState},
     tracks::unified_mixer::UnifiedMixerConfig,
 };
 
@@ -18,98 +21,74 @@ pub fn init(ui: &AppWindow) {
     logic_cb!(video_editor_calc_timeline_offset, ui, index, total_index);
 }
 
-// Get or create the playback controller
-fn get_playback_controller(ui: &AppWindow) -> Arc<std::sync::Mutex<PlaybackController>> {
-    // Get preview config from store
-    let new_project_config = global_store!(ui).get_video_editor_new_project_config();
-    let ui_preview_config = new_project_config.preview_config;
-
-    // Convert UI preview config to UnifiedMixerConfig, then to PreviewConfig
-    let mixer_config: UnifiedMixerConfig = ui_preview_config.into();
-    let preview_config: PreviewConfig = mixer_config.into();
-
-    let manager = with_history_manager(|state| Arc::new(state.tracks_manager.clone()));
-    let fps = preview_config.frame_rate();
-
-    Arc::new(std::sync::Mutex::new(PlaybackController::new(manager, fps)))
-}
-
 fn video_editor_preview_toggle(ui: &AppWindow) {
     let controller = get_playback_controller(ui);
-    let mut controller = controller.lock().unwrap();
+    let mut ctrl = controller.lock().unwrap();
 
-    match controller.state() {
+    match ctrl.state() {
         PlaybackState::Playing => {
-            // Pause
-            controller.pause();
+            ctrl.pause();
             global_store!(ui).set_video_editor_is_previewing(false);
             toast::async_toast_info(ui.as_weak(), "Paused".to_string());
         }
         PlaybackState::Stopped | PlaybackState::Paused => {
-            // Start/resume playing
-            controller.play();
+            ctrl.play();
             global_store!(ui).set_video_editor_is_previewing(true);
             toast::async_toast_info(ui.as_weak(), "Playing".to_string());
 
-            // Start background thread to update UI during playback
-            start_playback_update_thread(ui.as_weak(), get_playback_controller(ui));
+            start_playback_update_thread(ui.as_weak(), controller.clone());
         }
     }
 }
 
 fn video_editor_preview_rewind(ui: &AppWindow) {
     let controller = get_playback_controller(ui);
-    let mut controller = controller.lock().unwrap();
+    let mut ctrl = controller.lock().unwrap();
 
-    // Rewind by 5 seconds
-    let current_position = controller.position();
+    let current_position = ctrl.position();
     let rewind_amount = Duration::from_secs(5);
 
     if current_position >= rewind_amount {
         let new_position = current_position - rewind_amount;
-        controller.set_position(new_position);
+        ctrl.set_position(new_position);
         global_store!(ui).set_video_editor_timeline_offset(new_position.as_millis() as i32);
         toast::async_toast_info(ui.as_weak(), "Rewind".to_string());
     } else {
-        controller.set_position(Duration::ZERO);
+        ctrl.set_position(Duration::ZERO);
         global_store!(ui).set_video_editor_timeline_offset(0);
         toast::async_toast_info(ui.as_weak(), "Already at start".to_string());
     }
 }
 
 fn video_editor_preview_fast_forward(ui: &AppWindow) {
     let controller = get_playback_controller(ui);
-    let mut controller = controller.lock().unwrap();
+    let mut ctrl = controller.lock().unwrap();
 
-    // Fast forward by 5 seconds
-    let current_position = controller.position();
+    let current_position = ctrl.position();
     let total_duration = with_history_manager(|state| state.tracks_manager.duration);
     let forward_amount = Duration::from_secs(5);
 
     let new_position = current_position.saturating_add(forward_amount);
     if new_position < total_duration {
-        controller.set_position(new_position);
+        ctrl.set_position(new_position);
         global_store!(ui).set_video_editor_timeline_offset(new_position.as_millis() as i32);
         toast::async_toast_info(ui.as_weak(), "Fast forward".to_string());
     } else {
-        controller.set_position(total_duration);
+        ctrl.set_position(total_duration);
         global_store!(ui).set_video_editor_timeline_offset(total_duration.as_millis() as i32);
         toast::async_toast_info(ui.as_weak(), "Already at end".to_string());
     }
 }
 
 fn video_editor_preview_jump_previous_segment(ui: &AppWindow) {
-    // Find previous segment end position
     let current_offset = global_store!(ui).get_video_editor_timeline_offset();
     let current_position = Duration::from_millis(current_offset as u64);
 
     let prev_segment_end = with_history_manager(|state| {
         let mut prev_end = Duration::ZERO;
 
-        // Search all tracks for the segment that ends before current position
         for track in state.tracks_manager.iter() {
-            let segments = track.segments();
-            for segment in segments {
+            for segment in track.segments() {
                 let segment_end = segment.timeline_offset + segment.duration;
                 if segment_end < current_position && segment_end > prev_end {
                     prev_end = segment_end;
@@ -129,17 +108,14 @@ fn video_editor_preview_jump_previous_segment(ui: &AppWindow) {
 }
 
 fn video_editor_preview_jump_next_segment(ui: &AppWindow) {
-    // Find next segment start position
     let current_offset = global_store!(ui).get_video_editor_timeline_offset();
     let current_position = Duration::from_millis(current_offset as u64);
 
     let next_segment_start = with_history_manager(|state| {
         let mut next_start = None;
 
-        // Search all tracks for the segment that starts after current position
         for track in state.tracks_manager.iter() {
-            let segments = track.segments();
-            for segment in segments {
+            for segment in track.segments() {
                 if segment.timeline_offset > current_position {
                     if next_start.is_none() || segment.timeline_offset < next_start.unwrap() {
                         next_start = Some(segment.timeline_offset);
@@ -162,24 +138,18 @@ fn video_editor_preview_jump_next_segment(ui: &AppWindow) {
 fn video_editor_preview_change_volume(ui: &AppWindow, value: f32) {
     let value = value.clamp(0.0, 100.0);
 
-    // Update UI state for persistence
-    // Note: volume is stored in UI state as preview_volumn (note the spelling)
     let ui_state = global_store!(ui).get_video_editor_ui_state();
     let mut state: super::common_type::VideoEditorUIState = ui_state.into();
     state.preview_volumn = value;
     let ui_state_new: crate::slint_generatedAppWindow::VideoEditorUIState = state.into();
     global_store!(ui).set_video_editor_ui_state(ui_state_new);
-
-    // Volume control is now persisted in UI state
-    // Actual audio volume control would require:
-    // 1. Adding a GainFilter to audio segments during playback
-    // 2. Or implementing volume control in the UnifiedMixer
-    // 3. Passing the gain value to the audio output pipeline
-    // For now, the volume setting is saved and can be used during export
 }
 
-fn video_editor_calc_timeline_offset(_ui: &AppWindow, index: i32, _total_index: i32) -> slint::SharedString {
-    // Calculate timeline offset in SRT timestamp format: "HH:MM:SS,mmm"
+fn video_editor_calc_timeline_offset(
+    _ui: &AppWindow,
+    index: i32,
+    _total_index: i32,
+) -> slint::SharedString {
     let total_ms = index;
 
     let hours = total_ms / 3600000;
@@ -194,36 +164,39 @@ fn video_editor_calc_timeline_offset(_ui: &AppWindow, index: i32, _total_index:
     .into()
 }
 
-// Background thread to update UI during playback
+// Helper functions
+
+fn get_playback_controller(ui: &AppWindow) -> Arc<std::sync::Mutex<PlaybackController>> {
+    let new_project_config = global_store!(ui).get_video_editor_new_project_config();
+    let ui_preview_config = new_project_config.preview_config;
+
+    let mixer_config: UnifiedMixerConfig = ui_preview_config.into();
+    let preview_config: PreviewConfig = mixer_config.into();
+
+    let manager = with_history_manager(|state| Arc::new(state.tracks_manager.clone()));
+    let fps = preview_config.frame_rate();
+
+    Arc::new(std::sync::Mutex::new(PlaybackController::new(manager, fps)))
+}
+
 fn start_playback_update_thread(
     ui_weak: slint::Weak<AppWindow>,
     controller: Arc<std::sync::Mutex<PlaybackController>>,
 ) {
     std::thread::spawn(move || {
-        // Frame rendering requires implementing:
-        // 1. UnifiedVideoTracksCompositorIterator for video rendering
-        // 2. UnifiedAudioTracksMixerIterator for audio playback
-        // 3. Converting rendered frames to Slint images
-        // 4. Audio output integration
-        //
-        // For now, we update timeline position during playback
-        // Full preview implementation would need a dedicated render pipeline
-
         let frame_rate = controller.lock().unwrap().frame_rate() as f32;
         let frame_duration = Duration::from_secs_f64(1.0 / frame_rate as f64);
 
         loop {
-            // Check if still playing
             let (is_playing, percentage, position) = {
                 let ctrl = controller.lock().unwrap();
-                let state = ctrl.state();
-                let percentage = ctrl.percentage();
-                let position = ctrl.position();
-
-                (state == PlaybackState::Playing, percentage, position)
+                (
+                    ctrl.state() == PlaybackState::Playing,
+                    ctrl.percentage(),
+                    ctrl.position(),
+                )
             };
 
-            // Check if playback is finished (reached 100%)
             if is_playing && percentage >= 1.0 {
                 let _ = ui_weak.upgrade_in_event_loop(move |ui| {
                     global_store!(ui).set_video_editor_is_previewing(false);
@@ -236,15 +209,13 @@ fn start_playback_update_thread(
                 break;
             }
 
-            // Update timeline position
             let position_ms = position.as_millis() as i32;
             let ui_weak_clone = ui_weak.clone();
             let _ = ui_weak_clone.upgrade_in_event_loop(move |ui| {
                 global_store!(ui).set_video_editor_timeline_offset(position_ms);
             });
 
-            // Sleep for frame duration
             std::thread::sleep(frame_duration);
         }
     });
-}
+}