[*] update normally

Author: heng30

Makefile

@@ -36,7 +36,7 @@ desktop-debug-winit:
 	SLINT_BACKEND=winit-femtovg $(desktop-build-env) $(run-env) cargo run --bin ${app-name} --no-default-features --features=desktop
 
 desktop-run-release:
-	$(desktop-build-env) $(run-env) cargo run --release --bin ${app-name} --no-default-features --features=desktop
+	$(desktop-build-env) RUST_LOG=info cargo run --release --bin ${app-name} --no-default-features --features=desktop
 
 
 web-build:

lib/recorder/examples/fps_demo.rs

@@ -0,0 +1,11 @@
+use fps::SimpleFpsCounter;
+
+fn main() {
+    let mut fps_counter = SimpleFpsCounter::new();
+
+    for _ in 0..100 {
+        let fps = fps_counter.add_frame(Instant::now());
+        println!("Current FPS: {:.2}", fps);
+        thread::sleep(Duration::from_millis(20));
+    }
+}

lib/recorder/src/lib.rs

@@ -88,7 +88,7 @@ pub use mp4_builtin::combine_tracks;
 mod mp4_ffmpeg;
 
 #[cfg(feature = "mp4-ffmpeg")]
-pub use mp4_ffmpeg::{combine_tracks, is_installed};
+pub use mp4_ffmpeg::{combine_tracks, is_ffmpeg_installed};
 
 pub use audio_level::*;
 pub use crossbeam::channel::{Receiver, Sender, bounded};
@@ -99,7 +99,7 @@ pub use record_audio::{
 };
 pub use record_speaker::{SpeakerError, SpeakerRecorder};
 pub use recorder::RecordingSession;
-pub use recorder_config::{FPS, RecorderConfig};
+pub use recorder_config::{FPS, RecorderConfig, SimpleFpsCounter};
 pub use recorder_error::RecorderError;
 pub use resolution::Resolution;
 pub use video_encoder::{EncodedFrame, VideoEncoder};
@@ -175,6 +175,7 @@ pub struct Frame {
 
 #[derive(Debug, Clone)]
 pub struct StatsUser {
+    pub fps: f32,
     pub total_frames: u64,
     pub loss_frames: u64,
 }

lib/recorder/src/mp4_ffmpeg.rs

@@ -26,7 +26,7 @@ use std::sync::atomic::Ordering;
 ///     println!("FFmpeg is not available, using built-in MP4 writer");
 /// }
 /// ```
-pub fn is_installed() -> bool {
+pub fn is_ffmpeg_installed() -> bool {
     ffmpeg_sidecar::command::ffmpeg_is_installed()
 }
 

lib/recorder/src/recorder.rs

@@ -1,7 +1,8 @@
 use crate::{
     AudioError, AudioRecorder, CombineTracksConfig, EncodedFrame, Frame, FrameUser, H264Writer,
     MAX_H264_WRITER_QUEUE_SIZE, ProgressState, RecorderConfig, RecorderError, Resolution,
-    SpeakerRecorder, StatsUser, StreamingAudioRecorder, VideoEncoder, combine_tracks,
+    SimpleFpsCounter, SpeakerRecorder, StatsUser, StreamingAudioRecorder, VideoEncoder,
+    combine_tracks,
 };
 use capture::{Capture, CaptureIterConfig, capture_output_iter};
 use crossbeam::channel::{Receiver, Sender, bounded};
@@ -82,7 +83,9 @@ static CAPTURE_MEAN_TIME: Lazy<Mutex<Option<Duration>>> = Lazy::new(|| Mutex::ne
 pub struct RecordingSession {
     config: RecorderConfig,
 
+    // statistic
     start_time: Instant,
+    fps_counter: SimpleFpsCounter,
     total_frame_count: u64,
     loss_frame_count: Arc<AtomicU64>,
 
@@ -177,9 +180,10 @@ impl RecordingSession {
         Self {
             config,
 
+            start_time: std::time::Instant::now(),
+            fps_counter: Default::default(),
             total_frame_count: 0,
             loss_frame_count: Arc::new(AtomicU64::new(0)),
-            start_time: std::time::Instant::now(),
 
             frame_sender: Some(Arc::new(frame_sender)),
             frame_receiver,
@@ -359,6 +363,7 @@ impl RecordingSession {
                     if let Some(ref sender) = self.frame_sender_user {
                         let frame_user = FrameUser {
                             stats: StatsUser {
+                                fps: self.fps_counter.add_frame(frame.timestamp),
                                 total_frames: self.total_frame_count,
                                 loss_frames: self.loss_frame_count.load(Ordering::Relaxed),
                             },
@@ -663,7 +668,7 @@ impl RecordingSession {
                     Ok((total_frame_index, frame)) => {
                         let frame_timestamp = frame.timestamp.duration_since(start_time);
                         log::debug!(
-                            "total frame[{}] thread[{}] thread_frame[{}] capture time: {:.2?}. fps: {:.2}. timestamp: {:.2?}. chanenel remained: {}",
+                            "total frame[{}] thread[{}] thread_frame[{}] capture time: {:.2?}. thread_fps: {:.2}. timestamp: {:.2?}. chanenel remained: {}",
                             total_frame_index,
                             frame.thread_id,
                             frame.cb_data.frame_index,
@@ -859,11 +864,12 @@ impl RecordingSession {
         }
 
         log::info!(
-            "Total frame: {}. loss frame: {} ({:.2}%)",
+            "Total frame: {}. loss frame: {} ({:.2}%). fps: {:.2}",
             self.total_frame_count,
             self.loss_frame_count.load(Ordering::Relaxed),
             self.loss_frame_count.load(Ordering::Relaxed) as f64 * 100.0
                 / self.total_frame_count.max(1) as f64,
+            self.fps_counter.fps,
         );
 
         Ok(())

lib/recorder/src/recorder_config.rs

@@ -3,8 +3,10 @@ use capture::LogicalSize;
 use chrono::Local;
 use derive_setters::Setters;
 use std::{
+    collections::VecDeque,
     path::{Path, PathBuf},
     sync::{Arc, atomic::AtomicI32},
+    time::{Duration, Instant},
 };
 
 /// Supported frame rates for screen recording.
@@ -276,3 +278,42 @@ impl RecorderConfig {
         dir.as_ref().to_path_buf().join(filename)
     }
 }
+
+#[derive(Debug, Default, Clone)]
+pub struct SimpleFpsCounter {
+    pub fps: f32,
+    frames: VecDeque<Instant>,
+}
+
+impl SimpleFpsCounter {
+    pub fn new() -> Self {
+        Self {
+            frames: VecDeque::new(),
+            fps: 0.0,
+        }
+    }
+
+    pub fn add_frame(&mut self, timestamp: Instant) -> f32 {
+        let three_seconds_ago = timestamp - Duration::from_secs(3);
+
+        while let Some(&oldest) = self.frames.front() {
+            if oldest < three_seconds_ago {
+                self.frames.pop_front();
+            } else {
+                break;
+            }
+        }
+
+        self.frames.push_back(timestamp);
+
+        if self.frames.len() >= 2 {
+            let time_span = timestamp.duration_since(*self.frames.front().unwrap());
+            if time_span.as_secs_f64() > 0.0 {
+                self.fps = (self.frames.len() as f64 / time_span.as_secs_f64()) as f32;
+                return self.fps;
+            }
+        }
+
+        0.0
+    }
+}

wayshot/src/config.rs

@@ -123,7 +123,10 @@ pub struct Recorder {
     pub remove_temporary_files: bool,
 
     #[derivative(Default(value = "true"))]
-    pub show_cursor: bool,
+    pub include_cursor: bool,
+
+    #[derivative(Default(value = "true"))]
+    pub enable_preview: bool,
 
     #[derivative(Default(value = "fps_default()"))]
     pub fps: UIFps,

wayshot/src/logic/recorder.rs

@@ -92,6 +92,10 @@ fn inner_init(ui: &AppWindow) {
     store_audio_sources!(ui).set_vec(vec![]);
     store_video_sources!(ui).set_vec(vec![]);
 
+    if !recorder::is_ffmpeg_installed() {
+        global_store!(ui).set_ffmpeg_is_installed(false);
+    }
+
     if let Err(e) = init_input_audio(&ui) {
         toast_warn!(ui, format!("{e}"));
     }
@@ -265,6 +269,12 @@ fn init_video(ui: &AppWindow) -> Result<()> {
         name: name.clone(),
     });
 
+    tokio::spawn(async move {
+        if let Err(e) = RecordingSession::init(name.as_str()) {
+            log::warn!("RecordingSession::init failed in `init_video`: {e}");
+        }
+    });
+
     Ok(())
 }
 
@@ -410,9 +420,9 @@ fn inner_start_recording(ui_weak: Weak<AppWindow>) -> Result<()> {
         screen_info.logical_size.clone(),
         RecorderConfig::make_filename(&all_config.recorder.save_dir),
     )
-    .with_enable_frame_channel_user(true)
+    .with_enable_frame_channel_user(all_config.recorder.enable_preview)
     .with_enable_recording_speaker(all_config.control.enable_desktop_speaker)
-    .with_include_cursor(all_config.recorder.show_cursor)
+    .with_include_cursor(all_config.recorder.include_cursor)
     .with_remove_cache_files(all_config.recorder.remove_temporary_files)
     .with_audio_device_name(input_audio_name)
     .with_audio_amplification(Arc::new(AtomicI32::new(
@@ -462,12 +472,11 @@ fn inner_start_recording(ui_weak: Weak<AppWindow>) -> Result<()> {
                     let img = slint::Image::from_rgba8(buffer);
                     global_store!(ui).set_preview_image(img);
 
-                    // TODO: fps
                     let mut sinfo = global_store!(ui).get_stats_info();
+                    sinfo.fps = frame.stats.fps;
                     sinfo.total = frame.stats.total_frames as i32;
-                    sinfo.loss = (frame.stats.loss_frames as f64 * 100.0
-                        / frame.stats.total_frames.max(1) as f64)
-                        as f32;
+                    sinfo.loss =
+                        frame.stats.loss_frames as f32 / frame.stats.total_frames.max(1) as f32;
                     global_store!(ui).set_stats_info(sinfo);
                 });
             }

wayshot/ui/base/icon.slint

@@ -236,6 +236,7 @@ export global Icons {
     out property <image> monitor-recorder-light: @image-url("../images/icons/monitor-recorder-light.svg");
     out property <image> clear-fill: @image-url("../images/icons/clear-fill.svg");
     out property <image> cursor-light: @image-url("../images/icons/cursor-light.svg");
+    out property <image> preview-light: @image-url("../images/icons/preview-light.svg");
 
     out property <image> landing-account: @image-url("../images/landing/landing-account.svg");
     out property <image> landing-language-switch: @image-url("../images/landing/landing-language-switch.svg");