[*] update normally

Author: heng30

lib/recorder/src/recorder.rs

@@ -27,6 +27,7 @@ pub type ResizedImageBuffer = ImageBuffer<Rgb<u8>, Vec<u8>>;
 const RAW_VIDEO_EXTENSION: &str = "h264";
 const INPUT_AUDIO_EXTENSION: &str = "input.wav";
 const SPEAKER_AUDIO_EXTENSION: &str = "speaker.wav";
+const TMP_OUTPUT_VIDEO_EXTENSION: &str = "tmp.mp4";
 
 static CAPTURE_MEAN_TIME: Lazy<Mutex<Option<Duration>>> = Lazy::new(|| Mutex::new(None));
 
@@ -762,34 +763,43 @@ impl RecordingSession {
             writer.finish()?;
         }
 
-        let combine_config = CombineTracksConfig {
-            h264_path: self.config.output_path.with_extension(RAW_VIDEO_EXTENSION),
-            input_wav_path: if self.config.audio_device_name.is_some() {
-                Some(
-                    self.config
-                        .output_path
-                        .with_extension(INPUT_AUDIO_EXTENSION),
-                )
-            } else {
-                None
-            },
-            speaker_wav_path: if self.config.enable_recording_speaker {
-                Some(
-                    self.config
-                        .output_path
-                        .with_extension(SPEAKER_AUDIO_EXTENSION),
-                )
-            } else {
-                None
-            },
-            output_path: self.config.output_path.clone(),
-            fps: self.config.fps,
-            stop_sig: self.stop_sig_combine,
-        };
-
         if !self.config.enable_preview_mode {
+            let tmp_output_file = self
+                .config
+                .output_path
+                .with_extension(TMP_OUTPUT_VIDEO_EXTENSION);
+
+            let combine_config = CombineTracksConfig {
+                h264_path: self.config.output_path.with_extension(RAW_VIDEO_EXTENSION),
+                input_wav_path: if self.config.audio_device_name.is_some() {
+                    Some(
+                        self.config
+                            .output_path
+                            .with_extension(INPUT_AUDIO_EXTENSION),
+                    )
+                } else {
+                    None
+                },
+                speaker_wav_path: if self.config.enable_recording_speaker {
+                    Some(
+                        self.config
+                            .output_path
+                            .with_extension(SPEAKER_AUDIO_EXTENSION),
+                    )
+                } else {
+                    None
+                },
+                output_path: tmp_output_file.clone(),
+                fps: self.config.fps,
+                stop_sig: self.stop_sig_combine,
+            };
+
             combine_tracks(combine_config, combine_progress_cb)?;
 
+            if tmp_output_file.exists() {
+                _ = fs::rename(&tmp_output_file, &self.config.output_path);
+            }
+
             if self.config.output_path.exists() {
                 log::info!(
                     "Successfully save recorded file: {} ",
@@ -802,7 +812,7 @@ impl RecordingSession {
                 )));
             }
 
-            if self.config.remove_cache_files {
+            if self.config.remove_cache_files && self.config.output_path.exists() {
                 if self.config.enable_recording_speaker {
                     _ = fs::remove_file(
                         self.config
@@ -1024,6 +1034,10 @@ impl RecordingSession {
         self.stop_sig_combine.store(true, Ordering::Relaxed);
     }
 
+    pub fn get_stop_combine_tracks(&self) -> Arc<AtomicBool> {
+        self.stop_sig_combine.clone()
+    }
+
     /// Get the user frame receiver if frame channel is enabled.
     ///
     /// This method returns the receiver for the user frame channel, which allows

wayshot/src/logic/recorder.rs

@@ -5,12 +5,18 @@ use crate::{
         tr::tr,
     },
     logic_cb,
-    slint_generatedAppWindow::{AppWindow, Source as UISource, SourceType},
+    slint_generatedAppWindow::{
+        AppWindow, Fps as UIFps, RecordStatus as UIRecordStatus, Resolution as UIResolution,
+        Source as UISource, SourceType,
+    },
     toast_warn,
 };
 use anyhow::{Result, bail};
 use once_cell::sync::Lazy;
-use recorder::{AudioRecorder, SpeakerRecorder, StreamingAudioRecorder, bounded};
+use recorder::{
+    AudioRecorder, FPS, RecorderConfig, RecordingSession, Resolution, SpeakerRecorder,
+    StreamingAudioRecorder, bounded,
+};
 use slint::{ComponentHandle, Model, SharedString, ToSharedString, VecModel, Weak};
 use std::{
     path::PathBuf,
@@ -26,6 +32,9 @@ struct Cache {
     desktop_speaker_amplification: Option<Arc<AtomicI32>>,
     input_audio_amplification: Option<Arc<AtomicI32>>,
     input_streaming_audio_recorder: Option<StreamingAudioRecorder>,
+
+    recorder_stop_sig: Option<Arc<AtomicBool>>,
+    merge_stop_sig: Option<Arc<AtomicBool>>,
 }
 
 static CACHE: Lazy<Mutex<Cache>> = Lazy::new(|| Mutex::new(Cache::default()));
@@ -326,11 +335,156 @@ fn inner_input_audio_changed(ui: &AppWindow, name: SharedString) -> Result<()> {
     Ok(())
 }
 
-fn start_recording(ui: &AppWindow) {}
+fn start_recording(ui: &AppWindow) {
+    let all_config = config::all();
+
+    if all_config.recorder.save_dir.is_empty()
+        || !PathBuf::from(all_config.recorder.save_dir.clone()).exists()
+        || !PathBuf::from(all_config.recorder.save_dir.clone()).is_dir()
+    {
+        let ui_weak = ui.as_weak();
+        tokio::spawn(async move {
+            let Some(dir) = picker_directory(ui_weak.clone(), &tr("Choose save directory"), "")
+            else {
+                return;
+            };
+
+            let mut all = config::all();
+            all.recorder.save_dir = dir.to_string_lossy().to_string();
+            _ = config::save(all);
+        });
+        return;
+    }
+
+    let ui_weak = ui.as_weak();
+    thread::spawn(move || {
+        if let Err(e) = inner_start_recording(ui_weak.clone()) {
+            toast::async_toast_warn(ui_weak, e.to_string());
+        }
+    });
+}
+
+fn inner_start_recording(ui_weak: Weak<AppWindow>) -> Result<()> {
+    log::info!("start recording...");
+    let all_config = config::all();
 
-fn stop_recording(ui: &AppWindow) {}
+    if all_config.control.screen.is_empty() {
+        bail!("available screen no found");
+    }
+
+    let screen_info = capture::available_screens()?
+        .into_iter()
+        .find(|item| item.name == all_config.control.screen);
+
+    if screen_info.is_none() {
+        bail!("no found screen: {}", all_config.control.screen);
+    }
+
+    let screen_info = screen_info.unwrap();
+    log::debug!("screen_info: {screen_info:?}");
+
+    let resolution = if matches!(all_config.recorder.resolution, UIResolution::Original) {
+        Resolution::Original((
+            screen_info.logical_size.width as u32,
+            screen_info.logical_size.height as u32,
+        ))
+    } else {
+        all_config.recorder.resolution.into()
+    };
 
-fn stop_merge_tracks(ui: &AppWindow) {}
+    let input_audio_name = if all_config.control.input_audio.is_empty() {
+        None
+    } else {
+        Some(all_config.control.input_audio)
+    };
+
+    RecordingSession::init()?;
+
+    let config = RecorderConfig::new(
+        all_config.control.screen.clone(),
+        screen_info.logical_size.clone(),
+        RecorderConfig::make_filename(&all_config.recorder.save_dir),
+    )
+    .with_enable_frame_channel_user(true)
+    .with_enable_recording_speaker(true)
+    .with_include_cursor(all_config.recorder.show_cursor)
+    .with_remove_cache_files(all_config.recorder.remove_temporary_files)
+    .with_audio_device_name(input_audio_name)
+    .with_fps(all_config.recorder.fps.clone().into())
+    .with_resolution(resolution);
+
+    config.validate()?;
+    log::info!("Recording configuration: {:#?}", config);
+
+    let mut session = RecordingSession::new(config);
+    session.start()?;
+
+    ui_weak.upgrade_in_event_loop(move |ui| {
+        global_store!(ui).set_record_status(UIRecordStatus::Recording);
+    });
+
+    let stop_sig = session.stop_sig().clone();
+    let stop_sig_merge = session.get_stop_combine_tracks();
+    {
+        let mut cache = CACHE.lock().unwrap();
+        cache.recorder_stop_sig = Some(stop_sig);
+        cache.merge_stop_sig = Some(stop_sig_merge);
+    }
+
+    let frame_receiver_user = session.get_frame_receiver_user();
+    thread::spawn(move || {
+        if let Some(rx) = frame_receiver_user {
+            while let Ok(frame) = rx.recv() {
+                log::debug!(
+                    "frame_receiver_user frame len: {} bytes",
+                    frame.cb_data.data.pixel_data.len()
+                );
+            }
+            log::info!("exit frame_receiver_user");
+        } else {
+            log::info!("frame_receiver_user is none");
+        }
+    });
+
+    let ui_weak_clone = ui_weak.clone();
+    session.wait(move |v| {
+        log::debug!("combine tracks progress: {}%", (v * 100.0) as u32);
+        _ = ui_weak_clone.upgrade_in_event_loop(move |ui| {
+            global_store!(ui).set_record_status(UIRecordStatus::Mergeing);
+            global_store!(ui).set_merge_tracks_progress(v);
+        });
+    })?;
+
+    ui_weak.upgrade_in_event_loop(move |ui| {
+        global_store!(ui).set_record_status(UIRecordStatus::Stopped);
+    });
+
+    log::info!("Recording completed successfully!");
+
+    Ok(())
+}
+
+fn stop_recording(ui: &AppWindow) {
+    let stop_sig = CACHE.lock().unwrap().recorder_stop_sig.take();
+    if let Some(sig) = stop_sig {
+        sig.store(true, Ordering::Relaxed);
+    } else {
+        log::warn!("recorder_stop_sig is None");
+    }
+
+    global_store!(ui).set_record_status(UIRecordStatus::Mergeing);
+}
+
+fn stop_merge_tracks(ui: &AppWindow) {
+    let stop_sig = CACHE.lock().unwrap().merge_stop_sig.take();
+    if let Some(sig) = stop_sig {
+        sig.store(true, Ordering::Relaxed);
+    } else {
+        log::warn!("merge_stop_sig is None");
+    }
+
+    global_store!(ui).set_record_status(UIRecordStatus::Stopped);
+}
 
 pub fn picker_directory(ui: Weak<AppWindow>, title: &str, filename: &str) -> Option<PathBuf> {
     let result = native_dialog::DialogBuilder::file()
@@ -351,3 +505,25 @@ pub fn picker_directory(ui: Weak<AppWindow>, title: &str, filename: &str) -> Opt
         _ => None,
     }
 }
+
+impl From<UIResolution> for Resolution {
+    fn from(entry: UIResolution) -> Self {
+        match entry {
+            UIResolution::P720 => Resolution::P720,
+            UIResolution::P1080 => Resolution::P1080,
+            UIResolution::P2K => Resolution::P2K,
+            UIResolution::P4K => Resolution::P4K,
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl From<UIFps> for FPS {
+    fn from(entry: UIFps) -> Self {
+        match entry {
+            UIFps::Fps24 => FPS::Fps24,
+            UIFps::Fps25 => FPS::Fps25,
+            UIFps::Fps30 => FPS::Fps30,
+        }
+    }
+}

wayshot/ui/panel/desktop/home.slint

@@ -337,9 +337,7 @@ component ControlPanel inherits HorizontalLayout {
                         colorize: Theme.light-text-color;
 
                         clicked => {
-                            Store.record-status = RecordStatus.Stopped;
                             Logic.stop-recording();
-                            Store.record-status = RecordStatus.Mergeing;
                         }
                     }
                 }
@@ -350,7 +348,6 @@ component ControlPanel inherits HorizontalLayout {
                     colorize: Theme.light-text-color;
 
                     clicked => {
-                        Store.record-status = RecordStatus.Recording;
                         Logic.start-recording();
                     }
                 }
@@ -387,7 +384,6 @@ component ControlPanel inherits HorizontalLayout {
 
                     clicked => {
                         Logic.stop-merge-tracks();
-                        Store.record-status = RecordStatus.Stopped;
                     }
                 }
             }