[*] refactor: video-editor

Author: heng30

lib/video-editor/src/preview/renderer.rs

@@ -233,13 +233,10 @@ impl PreviewRenderer {
                     self.mixer_iter = None;
                 }
             } else {
+                // 视频结束时，暂停播放控制器并清空音频缓冲区
                 self.controller.pause();
                 self.mixer_iter = None;
-                if let Some(sink) = &self.audio_sink
-                    && let Ok(sink) = sink.lock()
-                {
-                    sink.pause();
-                }
+                self.clear_audio_sink();
             }
         }
 
@@ -482,13 +479,10 @@ impl PreviewRenderer {
 
                 self.current_frame = video_frame;
             } else {
+                // 视频结束时，暂停播放控制器并清空音频缓冲区
                 self.controller.pause();
                 self.mixer_iter = None;
-                if let Some(sink) = &self.audio_sink
-                    && let Ok(sink) = sink.lock()
-                {
-                    sink.pause();
-                }
+                self.clear_audio_sink();
             }
         }
 

lib/video-editor/src/tracks.rs

@@ -15,3 +15,4 @@ pub use frame_position::{FramePosition, FrameRange, TimeToFrameConverter};
 pub use manager::Manager;
 pub use track::Track;
 pub use unified_mixer::{UnifiedFrame, UnifiedMixerConfig, UnifiedTracksMixerIterator};
+pub use video_frame_cache::set_global_cache_max_frames;

lib/video-editor/src/tracks/video_frame_cache.rs

@@ -5,9 +5,13 @@ use std::{
     hash::{Hash, Hasher},
     num::NonZeroUsize,
     path::Path,
-    sync::{Mutex, OnceLock},
+    sync::{
+        Mutex, OnceLock,
+        atomic::{AtomicUsize, Ordering},
+    },
 };
 
+static CONFIGURED_MAX_FRAMES: AtomicUsize = AtomicUsize::new(100);
 static GLOBAL_FRAME_CACHE: OnceLock<GlobalFrameCache> = OnceLock::new();
 
 #[derive(Clone, Debug)]
@@ -27,9 +31,15 @@ impl VideoImage {
     }
 }
 
+pub fn set_global_cache_max_frames(max_frames: usize) {
+    CONFIGURED_MAX_FRAMES.store(max_frames, Ordering::SeqCst);
+}
+
 pub(crate) fn get_global_video_cache() -> &'static GlobalFrameCache {
-    // 100 frames @ 1080p = ~830MB
-    GLOBAL_FRAME_CACHE.get_or_init(|| GlobalFrameCache::new(100))
+    GLOBAL_FRAME_CACHE.get_or_init(|| {
+        let max_frames = CONFIGURED_MAX_FRAMES.load(Ordering::SeqCst);
+        GlobalFrameCache::new(max_frames)
+    })
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
@@ -60,7 +70,7 @@ impl GlobalFrameCache {
     pub(crate) fn new(max_frames: usize) -> Self {
         Self {
             cache: Mutex::new(LruCache::new(
-                NonZeroUsize::new(max_frames).unwrap_or_else(|| NonZeroUsize::new(1000).unwrap()),
+                NonZeroUsize::new(max_frames).unwrap_or_else(|| NonZeroUsize::new(100).unwrap()),
             )),
         }
     }

todo.md

@@ -1,25 +1,16 @@
 ## 问题
-- 预览播放到视频结尾是，有时音频声音会发生明显扭曲
 
 
 ## 待验证
-- 如果将segment分割成每一个1秒左右，播放segment会黑屏
-- 两个相近的segment，中间有gap时，从前一个segment播放，到后一个segment开始部分画面会出现错乱
+- 添加立即缩放到可视范围的按钮，改变缩放值，让所有segment都可见
 
 - 视频轨道分离字幕
 
 
 ## 待实现功能
-- 添加一个快速切换是否显示segment thumbnail的按钮
 - 不同轨道可以使用不同的背景进行区分
-- 支持全局缓存图片数量缓存设置
-- 预览缓存时长设置
 - playlist和library支持编辑移除
-- 添加吸附功能，功能是将选中的segment吸附到上一个segment末尾，和移除左边gap功能一致。需要添加一个图标
-- 按上下按钮能够改变声音大小，按左右能够移动到上一帧和下一帧
-- 添加立即缩放到可视范围的按钮，改变缩放值，让所有segment都可见
 - 添加录音功能，录音文件需要添加到playlist中，有选中音频轨道，就添加到音频轨道，没有就添加新的音频轨道
-- 轨道头中添加：移动到最上层和最下层两个popup action选项
 - view -> metadata弹框需要实现
 
 - 需要重新思考所有轨道联动功能：1. 联动分割

wayshot/src/logic/popup_action.rs

@@ -159,6 +159,14 @@ pub fn init(ui: &AppWindow) {
                     let index = user_data.parse::<i32>().unwrap();
                     global_logic!(ui).invoke_video_editor_track_move_down(index);
                 }
+                "video-editor-track-move-to-top" => {
+                    let index = user_data.parse::<i32>().unwrap();
+                    global_logic!(ui).invoke_video_editor_track_move_to_top(index);
+                }
+                "video-editor-track-move-to-bottom" => {
+                    let index = user_data.parse::<i32>().unwrap();
+                    global_logic!(ui).invoke_video_editor_track_move_to_bottom(index);
+                }
                 "video-editor-insert-video-track" => {
                     let index = user_data.parse::<i32>().unwrap();
                     global_logic!(ui).invoke_video_editor_insert_video_track(index);

wayshot/src/logic/video_editor/common_type.rs

@@ -5,6 +5,7 @@ use crate::slint_generatedAppWindow::{
     Resolution as UIResolution, SubtitleType as UISubtitleType,
     VideoEditorExportAudioConfig as UIVideoEditorExportAudioConfig,
     VideoEditorExportVideoConfig as UIVideoEditorExportVideoConfig,
+    VideoEditorPreferenceCacheConfig as UIVideoEditorPreferenceCacheConfig,
     VideoEditorPreferenceConfig as UIVideoEditorPreferenceConfig,
     VideoEditorPreferenceTrackConfig as UIVideoEditorPreferenceTrackConfig,
     VideoEditorPreviewConfig as UIVideoEditorPreviewConfig,
@@ -86,11 +87,24 @@ pub struct VideoEditorPreferenceTrackConfig {
     pub show_filename: bool,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, Derivative, SlintFromConvert)]
+#[derivative(Default)]
+#[from("UIVideoEditorPreferenceCacheConfig")]
+pub struct VideoEditorPreferenceCacheConfig {
+    #[derivative(Default(value = "100"))]
+    pub max_frames: i32,
+
+    #[derivative(Default(value = "5"))]
+    pub max_cache_duration: i32,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, Derivative, SlintFromConvert)]
 #[derivative(Default)]
 #[from("UIVideoEditorPreferenceConfig")]
+#[serde(default)]
 pub struct VideoEditorPreferenceConfig {
     pub track: VideoEditorPreferenceTrackConfig,
+    pub cache: VideoEditorPreferenceCacheConfig,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Derivative, SlintFromConvert)]

wayshot/src/logic/video_editor/preview.rs

@@ -224,11 +224,15 @@ fn video_editor_preview_size(
 
 fn create_renderer(ui: &AppWindow, position: Duration, volume: f32) -> Option<PreviewRenderer> {
     let manager = with_history_manager(|state| Arc::new(state.tracks_manager.clone()));
-    let mixer_config: UnifiedMixerConfig = global_store!(ui)
+    let mut mixer_config: UnifiedMixerConfig = global_store!(ui)
         .get_video_editor_new_project_config()
         .preview_config
         .into();
 
+    let cache_config = global_store!(ui).get_video_editor_preference_config().cache;
+    mixer_config.max_cache_duration =
+        Duration::from_secs(cache_config.max_cache_duration.max(3) as u64);
+
     let mut renderer = PreviewRenderer::new(manager, mixer_config.into());
     renderer.set_volume(volume);
 
@@ -261,11 +265,15 @@ pub fn seek_to_position(ui: &AppWindow, position: Duration) {
     let seek_id = PENDING_SEEK_ID.fetch_add(1, Ordering::SeqCst) + 1;
     let thread_id = PLAYBACK_THREAD_ID.fetch_add(1, Ordering::SeqCst) + 1;
     let manager = with_history_manager(|state| Arc::new(state.tracks_manager.clone()));
-    let mixer_config: UnifiedMixerConfig = global_store!(ui)
+    let mut mixer_config: UnifiedMixerConfig = global_store!(ui)
         .get_video_editor_new_project_config()
         .preview_config
         .into();
 
+    let cache_config = global_store!(ui).get_video_editor_preference_config().cache;
+    mixer_config.max_cache_duration =
+        Duration::from_secs(cache_config.max_cache_duration.max(3) as u64);
+
     let ui_state = global_store!(ui).get_video_editor_ui_state();
     let volume = ui_state.preview_volumn.clamp(0.0, 100.0) / 100.0;
 

wayshot/src/logic/video_editor/project.rs

@@ -15,6 +15,7 @@ use crate::{
     slint_generatedAppWindow::{
         AppWindow, VideoEditorNewProjectConfig as UIVideoEditorNewProjectConfig,
         VideoEditorPlaylistItem as UIVideoEditorPlaylistItem,
+        VideoEditorPreferenceCacheConfig as UIVideoEditorPreferenceCacheConfig,
         VideoEditorPreferenceTrackConfig as UIVideoEditorPreferenceTrackConfig,
         VideoEditorRecentEntry as UIVideoEditorRecentEntry,
         VideoEditorRecoveryInfo as UIVideoEditorRecoveryInfo,
@@ -39,7 +40,7 @@ use video_editor::{
         project::{ManagerData, ProjectPreviewConfig},
         recent::RecentFilesManager,
     },
-    tracks::{manager::Manager, track::Track},
+    tracks::{manager::Manager, set_global_cache_max_frames, track::Track},
 };
 
 pub const PROJECT_EXT: &str = "wayshot";
@@ -122,6 +123,7 @@ pub fn init(ui: &AppWindow) {
     logic_cb!(video_editor_quit, ui);
     logic_cb!(video_editor_show_preference_setting_dialog, ui);
     logic_cb!(video_editor_update_preference_track_config, ui, setting);
+    logic_cb!(video_editor_update_preference_cache_config, ui, setting);
     logic_cb!(video_editor_recover_from_autosave, ui);
     logic_cb!(video_editor_ignore_recovery, ui);
     logic_cb!(video_editor_cancel_recovery, ui);
@@ -206,6 +208,8 @@ fn inner_init(ui: &AppWindow) {
                 }
             };
 
+        set_global_cache_max_frames(preference_config.cache.max_frames.max(10) as usize);
+
         _ = ui_weak_for_preference.upgrade_in_event_loop(move |ui| {
             global_store!(ui).set_video_editor_preference_config(preference_config.into());
         });
@@ -531,6 +535,20 @@ fn video_editor_update_preference_track_config(
     crate::toast_success!(ui, "Save config successfully");
 }
 
+fn video_editor_update_preference_cache_config(
+    ui: &AppWindow,
+    setting: UIVideoEditorPreferenceCacheConfig,
+) {
+    let current = global_store!(ui).get_video_editor_preference_config();
+    let config = VideoEditorPreferenceConfig {
+        cache: setting.into(),
+        ..current.into()
+    };
+    global_store!(ui).set_video_editor_preference_config(config.clone().into());
+    db_update_preference_config(ui.as_weak(), config);
+    crate::toast_success!(ui, "Save config successfully");
+}
+
 fn video_editor_recover_from_autosave(ui: &AppWindow) {
     let ui_weak = ui.as_weak();
     let recovery_info: RecoveryInfo = global_store!(ui).get_video_editor_recovery_info().into();

wayshot/src/logic/video_editor/segment.rs

@@ -3,7 +3,7 @@ use super::{
     track::{get_selected_segment_indices, is_track_locked},
 };
 use crate::{
-    global_store, logic_cb,
+    global_logic, global_store, logic_cb,
     slint_generatedAppWindow::{
         AppWindow, SelectedSegmentIndex as UISelectedSegmentIndex,
         VideoEditorTrackSegment as UIVideoEditorTrackSegment,
@@ -56,6 +56,7 @@ pub fn init(ui: &AppWindow) {
     logic_cb!(video_editor_segment_remove_gap, ui, index);
     logic_cb!(video_editor_segment_remove_left_gap, ui, index);
     logic_cb!(video_editor_segment_remove_right_gap, ui, index);
+    logic_cb!(video_editor_segments_snap_to_previous, ui);
     logic_cb!(
         video_editor_video_segment_thumbnail,
         ui,
@@ -900,6 +901,18 @@ fn video_editor_segment_remove_left_gap(ui: &AppWindow, index: UISelectedSegment
     }
 }
 
+fn video_editor_segments_snap_to_previous(ui: &AppWindow) {
+    let idx = store_video_editor_selected_segments_index!(ui).row_count();
+    if idx == 0 {
+        return crate::toast_warn!(ui, "No segments selected");
+    }
+
+    match store_video_editor_selected_segments_index!(ui).row_data(idx - 1) {
+        Some(index) => global_logic!(ui).invoke_video_editor_segment_remove_left_gap(index),
+        _ => crate::toast_warn!(ui, "No segments selected"),
+    }
+}
+
 fn video_editor_segment_remove_right_gap(ui: &AppWindow, index: UISelectedSegmentIndex) {
     let shift_timeline = global_store!(ui)
         .get_video_editor_ui_state()

wayshot/src/logic/video_editor/track.rs

@@ -60,6 +60,8 @@ pub fn init(ui: &AppWindow) {
     logic_cb!(video_editor_remove_tracks, ui);
     logic_cb!(video_editor_track_move_up, ui, index);
     logic_cb!(video_editor_track_move_down, ui, index);
+    logic_cb!(video_editor_track_move_to_top, ui, index);
+    logic_cb!(video_editor_track_move_to_bottom, ui, index);
     logic_cb!(video_editor_insert_video_track, ui, index);
     logic_cb!(video_editor_insert_audio_track, ui, index);
     logic_cb!(video_editor_insert_subtitle_track, ui, index);
@@ -257,6 +259,83 @@ fn video_editor_track_move_down(ui: &AppWindow, index: i32) {
     }
 }
 
+fn video_editor_track_move_to_top(ui: &AppWindow, index: i32) {
+    if index <= 0 {
+        return;
+    }
+
+    if is_track_locked(ui, index) {
+        crate::toast_warn!(ui, "Cannot move a locked track");
+        return;
+    }
+
+    let idx = index as usize;
+
+    let result = with_history_manager(|state| {
+        if idx >= state.tracks_manager.len() {
+            return Err(
+                video_editor::Error::IndexOutOfBounds(idx, state.tracks_manager.len()).into(),
+            );
+        }
+
+        let command = MoveTrackCommand::new(idx, 0);
+        state
+            .history_manager
+            .execute(&mut state.tracks_manager, Box::new(command))
+    });
+
+    match result {
+        Ok(execute_result) => {
+            sync_manager_to_ui(ui);
+            if execute_result.affected_segments.tracks_changed {
+                refresh_preview(ui);
+            }
+            crate::toast_success!(ui, format!("Moved track from {} to top", index));
+        }
+        Err(e) => crate::toast_warn!(ui, e.to_string()),
+    }
+}
+
+fn video_editor_track_move_to_bottom(ui: &AppWindow, index: i32) {
+    if is_track_locked(ui, index) {
+        crate::toast_warn!(ui, "Cannot move a locked track");
+        return;
+    }
+
+    let idx = index as usize;
+
+    let result = with_history_manager(|state| {
+        if idx >= state.tracks_manager.len() {
+            return Err(
+                video_editor::Error::IndexOutOfBounds(idx, state.tracks_manager.len()).into(),
+            );
+        }
+
+        let last_idx = state.tracks_manager.len() - 1;
+        if idx == last_idx {
+            return Ok(ExecuteResult {
+                affected_segments: Default::default(),
+            });
+        }
+
+        let command = MoveTrackCommand::new(idx, last_idx);
+        state
+            .history_manager
+            .execute(&mut state.tracks_manager, Box::new(command))
+    });
+
+    match result {
+        Ok(execute_result) => {
+            sync_manager_to_ui(ui);
+            if execute_result.affected_segments.tracks_changed {
+                refresh_preview(ui);
+            }
+            crate::toast_success!(ui, format!("Moved track from {} to bottom", index));
+        }
+        Err(e) => crate::toast_warn!(ui, e.to_string()),
+    }
+}
+
 fn video_editor_insert_video_track(ui: &AppWindow, index: i32) {
     insert_track_by_type(ui, index, UIVideoEditorTrackType::Video);
 }