[*] update normally

Author: heng30

lib/recorder/src/recorder.rs

@@ -85,8 +85,7 @@ pub struct RecordingSession {
 
     // statistic
     start_time: Instant,
-    fps_counter: SimpleFpsCounter,
-    total_frame_count: u64,
+    total_frame_count: Arc<AtomicU64>,
     loss_frame_count: Arc<AtomicU64>,
 
     frame_sender: Option<Arc<Sender<Frame>>>,
@@ -181,8 +180,7 @@ impl RecordingSession {
             config,
 
             start_time: std::time::Instant::now(),
-            fps_counter: Default::default(),
-            total_frame_count: 0,
+            total_frame_count: Arc::new(AtomicU64::new(0)),
             loss_frame_count: Arc::new(AtomicU64::new(0)),
 
             frame_sender: Some(Arc::new(frame_sender)),
@@ -319,19 +317,19 @@ impl RecordingSession {
     /// }
     /// ```
     pub fn wait(
-        mut self,
+        self,
         combine_progress_cb: impl FnMut(f32),
     ) -> Result<ProgressState, RecorderError> {
-        let (resize_sender, resize_receiver) =
-            bounded::<ResizeChannelData>(self.config.max_queue_size);
         let (encoder_sender, encoder_receiver) = bounded(self.config.max_queue_size * 2);
 
         let resize_handles = Self::resize_workers(
-            resize_receiver,
+            self.frame_receiver.clone(),
             encoder_sender,
+            self.frame_sender_user.clone(),
             (self.capture_workers.len() / 2).max(2),
             self.start_time,
             self.config.resolution.clone(),
+            self.total_frame_count.clone(),
             self.loss_frame_count.clone(),
             self.config.enable_preview_mode,
         );
@@ -350,86 +348,53 @@ impl RecordingSession {
         };
 
         // Create encoder in main thread since x264 is not thread-safe
-        let mut encoder = VideoEncoder::new(width, height, self.config.fps)?;
+        let mut video_encoder = VideoEncoder::new(width, height, self.config.fps)?;
 
         // Write encoder headers first if we have a writer
         if let Some(ref writer) = h264_writer {
-            let headers = encoder.headers()?;
+            let headers = video_encoder.headers()?;
             let headers_data = headers.entirety().to_vec();
             writer.write_frame(EncodedFrame::Frame((0, headers_data)));
         }
 
         loop {
-            // Use select to handle both frame receiving and encoding
-            crossbeam::select! {
-                recv(self.frame_receiver) -> frame_result => {
-                    match frame_result {
-                        Ok(frame) => {
-                            self.total_frame_count += 1;
-                            let index = frame.thread_id as usize;
-
-                            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),
-                                    },
-                                    frame: frame.clone(),
-                                };
-                                if let Err(e) = sender.try_send(frame_user) {
-                                    log::warn!("try send frame failed: {e}");
-                                }
-                            }
+            match encoder_receiver.recv() {
+                Ok((total_frame_index, img)) => {
+                    let now = std::time::Instant::now();
+                    match video_encoder.encode_frame(img.into()) {
+                        Ok(EncodedFrame::Frame((_, encoded_frame))) => {
+                            log::debug!(
+                                "total encoded frame[{total_frame_index}] {} bytes",
+                                encoded_frame.len()
+                            );
 
-                            if let Err(e) = resize_sender.try_send((self.total_frame_count, frame)) {
-                                self.loss_frame_count.fetch_add(1, Ordering::Relaxed);
-                                log::warn!("try send to handle_worker[{index}] failed: {e}");
+                            if let Some(ref writer) = h264_writer {
+                                writer.write_frame(EncodedFrame::Frame((
+                                    total_frame_index,
+                                    encoded_frame,
+                                )));
                             }
                         }
-                        _ => {
-                            self.stop();
-                            self.wait_stop(
-                                resize_sender,
-                                resize_handles,
-                                None, // No encoder handle since we're encoding in main thread
-                                h264_writer,
-                                Some(encoder), // Pass encoder for flushing
-                                combine_progress_cb,
-                            )?;
-                            break;
-                        }
+                        Err(e) => log::warn!("encode frame failed: {e}"),
+                        _ => unreachable!("invalid EncodedFrame"),
                     }
-                }
-                recv(encoder_receiver) -> encoded_result => {
-                    match encoded_result {
-                        Ok((total_frame_index, img)) => {
-                            let now = std::time::Instant::now();
-
-                            match encoder.encode_frame(img.into()) {
-                                Ok(EncodedFrame::Frame((_, encoded_frame))) => {
-                                    log::debug!(
-                                        "total encoded frame[{total_frame_index}] {} bytes",
-                                        encoded_frame.len()
-                                    );
-
-                                    if let Some(ref writer) = h264_writer {
-                                        writer.write_frame(EncodedFrame::Frame((
-                                            total_frame_index,
-                                            encoded_frame,
-                                        )));
-                                    }
-                                }
-                                Err(e) => log::warn!("encode frame failed: {e}"),
-                                _ => unreachable!("invalid EncodedFrame"),
-                            }
 
-                            log::debug!("frame encoding time: {:.2?}\n", now.elapsed());
-                        }
-                        _ => {
-                            // Encoder channel closed, continue with frame receiving
-                        }
-                    }
+                    log::debug!(
+                        "frame encoding time: {:.2?}. encoder receiver channel remained: {}\n",
+                        now.elapsed(),
+                        encoder_receiver.capacity().unwrap_or_default() - encoder_receiver.len(),
+                    );
+                }
+                _ => {
+                    log::info!("exit encoder receiver channel");
+                    self.stop();
+                    self.wait_stop(
+                        resize_handles,
+                        h264_writer,
+                        Some(video_encoder),
+                        combine_progress_cb,
+                    )?;
+                    break;
                 }
             }
         }
@@ -509,16 +474,18 @@ impl RecordingSession {
     }
 
     fn resize_workers(
-        receiver: Receiver<ResizeChannelData>,
+        capture_receiver: Receiver<Frame>,
         encoder_sender: Sender<EncoderChannelData>,
+        frame_sender_user: Option<Sender<FrameUser>>,
         thread_counts: usize,
         start_time: Instant,
         resolution: Resolution,
+        total_frame_count: Arc<AtomicU64>,
         loss_frame_count: Arc<AtomicU64>,
         enable_previwe_model: bool,
     ) -> Vec<JoinHandle<()>> {
         let mut thread_handles = vec![];
-        let channel_size = receiver.capacity().unwrap_or(256);
+        let channel_size = capture_receiver.capacity().unwrap_or(256);
         let (collect_sender, collect_receiver) = bounded(channel_size);
 
         let (handles, resize_senders) = Self::resize_workers_main(
@@ -539,9 +506,11 @@ impl RecordingSession {
         ));
 
         thread_handles.push(Self::resize_forward_worker(
-            receiver,
+            capture_receiver,
             resize_senders,
+            frame_sender_user,
             start_time,
+            total_frame_count,
             loss_frame_count,
         ));
 
@@ -696,37 +665,56 @@ impl RecordingSession {
     }
 
     fn resize_forward_worker(
-        receiver: Receiver<ResizeChannelData>,
+        capture_receiver: Receiver<Frame>,
         resize_senders: Vec<Sender<ResizeChannelData>>,
+        frame_sender_user: Option<Sender<FrameUser>>,
         start_time: Instant,
+        total_frame_count: Arc<AtomicU64>,
         loss_frame_count: Arc<AtomicU64>,
     ) -> JoinHandle<()> {
-        // forward frame to specified reiszed thread
-        let loss_frame_count_clone = loss_frame_count.clone();
+        let mut fps_counter = SimpleFpsCounter::new();
+
         let handle = thread::spawn(move || {
             loop {
-                match receiver.recv() {
-                    Ok((total_frame_index, frame)) => {
-                        let frame_timestamp = frame.timestamp.duration_since(start_time);
+                match capture_receiver.recv() {
+                    Ok(frame) => {
+                        let total_frame_count =
+                            total_frame_count.fetch_add(1, Ordering::Relaxed) + 1;
+
                         log::debug!(
-                            "total frame[{}] thread[{}] thread_frame[{}] capture time: {:.2?}. thread_fps: {:.2}. timestamp: {:.2?}. chanenel remained: {}",
-                            total_frame_index,
+                            "total frame[{}] thread[{}] thread_frame[{}] capture time: {:.2?}. thread_fps: {:.2}. timestamp: {:.2?}. capture receiver channel remained: {}",
+                            total_frame_count,
                             frame.thread_id,
                             frame.cb_data.frame_index,
                             frame.cb_data.capture_time,
                             (frame.cb_data.frame_index + 1) as f64
                                 / frame.cb_data.elapse.as_secs_f64(),
-                            frame_timestamp,
-                            receiver.capacity().unwrap_or_default() - receiver.len()
+                            frame.timestamp.duration_since(start_time),
+                            capture_receiver.capacity().unwrap_or_default()
+                                - capture_receiver.len()
                         );
 
+                        if let Some(ref sender) = frame_sender_user {
+                            let frame_user = FrameUser {
+                                stats: StatsUser {
+                                    fps: fps_counter.add_frame(frame.timestamp),
+                                    total_frames: total_frame_count,
+                                    loss_frames: loss_frame_count.load(Ordering::Relaxed),
+                                },
+                                frame: frame.clone(),
+                            };
+                            if let Err(e) = sender.try_send(frame_user) {
+                                log::warn!("try send frame failed: {e}");
+                            }
+                        }
+
                         let sender = resize_senders
                             .iter()
                             .min_by(|a, b| a.len().cmp(&b.len()))
                             .unwrap();
 
-                        if let Err(e) = sender.try_send((total_frame_index, frame)) {
-                            loss_frame_count_clone.fetch_add(1, Ordering::Relaxed);
+                        if let Err(e) = sender.try_send((total_frame_count, frame)) {
+                            loss_frame_count.fetch_add(1, Ordering::Relaxed);
                             log::warn!("resize worker try send failed: {e}");
                         }
                     }
@@ -743,9 +731,7 @@ impl RecordingSession {
 
     fn wait_stop(
         mut self,
-        resize_sender: Sender<ResizeChannelData>,
         resize_handles: Vec<JoinHandle<()>>,
-        encoder_handle: Option<JoinHandle<()>>,
         mut h264_writer: Option<H264Writer>,
         encoder: Option<VideoEncoder>,
         combine_progress_cb: impl FnMut(f32),
@@ -778,20 +764,12 @@ impl RecordingSession {
             }
         }
 
-        drop(resize_sender);
-
         for (index, resize_handle) in resize_handles.into_iter().enumerate() {
             if let Err(e) = resize_handle.join() {
                 log::warn!("join resize thread[{index}] failed: {:?}", e);
             }
         }
 
-        if let Some(encoder_handle) = encoder_handle {
-            if let Err(e) = encoder_handle.join() {
-                log::warn!("join encoder thread failed: {:?}", e);
-            }
-        }
-
         // Flush encoder if provided to process any delayed frames
         if let Some(encoder) = encoder
             && let Some(ref writer) = h264_writer
@@ -891,12 +869,11 @@ impl RecordingSession {
         }
 
         log::info!(
-            "Total frame: {}. loss frame: {} ({:.2}%). fps: {:.2}",
-            self.total_frame_count,
+            "Total frame: {}. loss frame: {} ({:.2}%)",
+            self.total_frame_count.load(Ordering::Relaxed),
             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,
+                / self.total_frame_count.load(Ordering::Relaxed).max(1) as f64,
         );
 
         Ok(())

wayshot/src/config.rs

@@ -135,7 +135,7 @@ pub struct Recorder {
     pub resolution: UIResolution,
 }
 
-crate::impl_slint_enum_serde!(UIFps, Fps24, Fps25, Fps30);
+crate::impl_slint_enum_serde!(UIFps, Fps24, Fps25, Fps30, Fps60);
 crate::impl_slint_enum_serde!(UIResolution, Original, P720, P1080, P2K, P4K);
 
 #[derive(Serialize, Deserialize, Debug, Clone, Derivative, SlintFromConvert)]