[*] update normally

Author: heng30

lib/recorder/src/h264_writer.rs

@@ -9,21 +9,6 @@ use std::{
     time::Duration,
 };
 
-/// Maximum queue size for H.264 writer to prevent memory overflow.
-///
-/// This constant defines the maximum number of encoded frames that can be
-/// queued for writing to disk. If the queue fills up, older frames may be
-/// dropped to maintain real-time performance.
-///
-/// # Examples
-///
-/// ```no_run
-/// use recorder::{H264Writer, MAX_H264_WRITER_QUEUE_SIZE};
-///
-/// let writer = H264Writer::new("output.h264".into(), MAX_H264_WRITER_QUEUE_SIZE);
-/// ```
-pub const MAX_H264_WRITER_QUEUE_SIZE: usize = 64;
-
 /// H.264 file writer that handles frame queuing and file output.
 ///
 /// This struct manages the writing of encoded H.264 frames to disk using
@@ -41,9 +26,9 @@ pub const MAX_H264_WRITER_QUEUE_SIZE: usize = 64;
 /// # Examples
 ///
 /// ```no_run
-/// use recorder::{H264Writer, EncodedFrame, MAX_H264_WRITER_QUEUE_SIZE};
+/// use recorder::{H264Writer, EncodedFrame};
 ///
-/// let writer = H264Writer::new("output.h264".into(), MAX_H264_WRITER_QUEUE_SIZE);
+/// let writer = H264Writer::new("output.h264".into(), 2);
 ///
 /// // Write frames as they become available
 /// // writer.write_frame(encoded_frame);
@@ -70,26 +55,25 @@ impl H264Writer {
     /// # Arguments
     ///
     /// * `output_path` - Path where the H.264 file will be created
-    /// * `queue_size` - Maximum number of frames to queue (must be > 0 and ≤ MAX_H264_WRITER_QUEUE_SIZE)
+    /// * `queue_size` - Maximum number of frames to queue (must be > 0)
     ///
     /// # Returns
     ///
     /// A new `H264Writer` instance ready to receive frames.
     ///
     /// # Panics
     ///
-    /// Panics if `queue_size` is 0 or exceeds `MAX_H264_WRITER_QUEUE_SIZE`.
+    /// Panics if `queue_size` is 0.
     ///
     /// # Examples
     ///
     /// ```no_run
-    /// use recorder::{H264Writer, MAX_H264_WRITER_QUEUE_SIZE};
+    /// use recorder::{H264Writer};
     ///
-    /// let writer = H264Writer::new("recording.h264".into(), 1024);
+    /// let writer = H264Writer::new("recording.h264".into(), 8);
     /// ```
     pub fn new(output_path: PathBuf, queue_size: usize) -> Self {
         assert!(queue_size > 0);
-        assert!(queue_size <= MAX_H264_WRITER_QUEUE_SIZE);
 
         let (frame_sender, frame_receiver) = bounded::<EncodedFrame>(queue_size);
 
@@ -142,6 +126,11 @@ impl H264Writer {
         log::info!("Creating H.264 file: {}", output_path.display());
 
         while let Ok(frame) = frame_receiver.recv() {
+            log::debug!(
+                "h264 writer thread frame receiver remained: {}",
+                frame_receiver.capacity().unwrap_or_default() - frame_receiver.len()
+            );
+
             match frame {
                 EncodedFrame::Frame((_frame_index, frame_data)) => {
                     if let Err(e) = h264_file.write_all(&frame_data) {

lib/recorder/src/lib.rs

@@ -83,7 +83,7 @@ pub use mp4_ffmpeg::{combine_tracks, is_ffmpeg_installed};
 
 pub use audio_level::*;
 pub use crossbeam::channel::{Receiver, Sender, bounded};
-pub use h264_writer::{H264Writer, MAX_H264_WRITER_QUEUE_SIZE};
+pub use h264_writer::H264Writer;
 pub use record_audio::{
     AudioConfig, AudioDeviceInfo, AudioError, AudioFileWriter, AudioRecorder,
     AudioRecordingSession, StreamingAudioRecorder,

lib/recorder/src/recorder.rs

@@ -30,8 +30,8 @@ const SPEAKER_AUDIO_EXTENSION: &str = "speaker.wav";
 const TMP_OUTPUT_VIDEO_EXTENSION: &str = "tmp.mp4";
 
 const USER_CHANNEL_SIZE: usize = 3;
-const RESIZE_WORKER_CHANNEL_SIZE: usize = 16;
-pub const ENCODER_WORKER_CHANNEL_SIZE: usize = 32;
+const RESIZE_WORKER_CHANNEL_SIZE: usize = 8;
+const ENCODER_WORKER_CHANNEL_SIZE: usize = 64;
 
 static CAPTURE_MEAN_TIME: Lazy<Mutex<Option<Duration>>> = Lazy::new(|| Mutex::new(None));
 
@@ -708,6 +708,18 @@ impl RecordingSession {
                             }
                         }
 
+                        {
+                            let mut s = String::default();
+                            for (index, sender) in resize_senders.iter().enumerate() {
+                                s.push_str(&format!(
+                                    "send[{index}] remained: {}. ",
+                                    sender.capacity().unwrap_or_default() - sender.len()
+                                ));
+                            }
+
+                            log::debug!("{s}");
+                        }
+
                         let sender = resize_senders
                             .iter()
                             .min_by(|a, b| a.len().cmp(&b.len()))

lib/recorder/src/video_encoder.rs

@@ -252,7 +252,7 @@ impl VideoEncoder {
         // Calculate timestamp in milliseconds (frame_index * 1000 / fps)
         let timestamp_ms = (self.frame_index * 1000) / self.fps.to_u32() as u64;
 
-        // Encode frame
+        // NOTE: It will eat your memory (about 1G)
         let (data, _) = self
             .encoder
             .encode(timestamp_ms as i64, image)