[*] update normally

Author: heng30

lib/recorder/examples/merge_tracks_demo.rs

@@ -28,6 +28,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         output_path: output_path.clone(),
         fps: FPS::Fps30,
         stop_sig: Arc::new(AtomicBool::new(false)),
+        convert_input_wav_to_mono: false,
     };
 
     let now = std::time::Instant::now();

lib/recorder/src/lib.rs

@@ -84,8 +84,7 @@ pub use crossbeam::channel::{Receiver, Sender, bounded};
 pub use h264_writer::H264Writer;
 pub use mp4_ffmpeg::{is_ffmpeg_installed, merge_tracks};
 pub use record_audio::{
-    AudioDeviceInfo, AudioError, AudioFileWriter, AudioRecorder, AudioRecordingSession,
-    StreamingAudioRecorder,
+    AudioDeviceInfo, AudioError, AudioFileWriter, AudioRecorder, StreamingAudioRecorder,
 };
 pub use record_speaker::{SpeakerError, SpeakerRecorder};
 pub use recorder::RecordingSession;

lib/recorder/src/record_audio.rs

@@ -294,7 +294,7 @@ impl AudioRecorder {
         &self,
         device_name: &str,
         callback: impl FnMut(&[f32], &InputCallbackInfo) + Send + 'static,
-    ) -> Result<AudioRecordingSession, AudioError> {
+    ) -> Result<Arc<Mutex<Option<Stream>>>, AudioError> {
         let (stream_config, _) = self.get_config(device_name)?;
 
         let physical_device = self
@@ -319,54 +319,7 @@ impl AudioRecorder {
             .play()
             .map_err(|e| AudioError::StreamError(e.to_string()))?;
 
-        Ok(AudioRecordingSession {
-            stream: Arc::new(Mutex::new(Some(stream))),
-        })
-    }
-}
-
-/// Active audio recording session
-pub struct AudioRecordingSession {
-    stream: Arc<Mutex<Option<Stream>>>,
-}
-
-impl std::fmt::Debug for AudioRecordingSession {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("AudioRecordingSession")
-            .field("is_active", &self.is_active())
-            .finish()
-    }
-}
-
-impl AudioRecordingSession {
-    /// Stop the audio recording session
-    pub fn stop(&self) -> Result<(), AudioError> {
-        let mut stream_guard = self
-            .stream
-            .lock()
-            .map_err(|_| AudioError::StreamError("Failed to lock stream".to_string()))?;
-
-        if let Some(stream) = stream_guard.take() {
-            drop(stream);
-        }
-
-        Ok(())
-    }
-
-    /// Check if the recording session is active
-    pub fn is_active(&self) -> bool {
-        let stream_guard = match self.stream.lock() {
-            Ok(guard) => guard,
-            Err(_) => return false,
-        };
-
-        stream_guard.is_some()
-    }
-}
-
-impl Drop for AudioRecordingSession {
-    fn drop(&mut self) {
-        _ = self.stop();
+        Ok(Arc::new(Mutex::new(Some(stream))))
     }
 }
 
@@ -375,14 +328,6 @@ pub struct AudioFileWriter {
     writer: Option<WavWriter<BufWriter<File>>>,
 }
 
-impl std::fmt::Debug for AudioFileWriter {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("AudioFileWriter")
-            .field("is_active", &self.writer.is_some())
-            .finish()
-    }
-}
-
 impl AudioFileWriter {
     /// Create a new WAV file writer
     pub fn new<P: AsRef<Path>>(
@@ -437,10 +382,10 @@ impl Drop for AudioFileWriter {
 }
 
 /// Streaming audio recorder that writes to file in real-time
-#[derive(Debug)]
+// #[derive(Debug)]
 pub struct StreamingAudioRecorder {
     file_writer: Arc<Mutex<Option<AudioFileWriter>>>,
-    recording_session: AudioRecordingSession,
+    recording_session: Arc<Mutex<Option<Stream>>>,
     audio_level_receiver: Option<Arc<Receiver<f32>>>,
 }
 
@@ -505,22 +450,19 @@ impl StreamingAudioRecorder {
 
     /// Stop the streaming audio recording
     pub fn stop(self) -> Result<(), AudioError> {
-        self.recording_session.stop()?;
-
-        if let Ok(mut writer) = self.file_writer.lock()
-            && let Some(ref mut writer) = *writer
         {
+            if let Some(stream) = self.recording_session.lock().unwrap().take() {
+                drop(stream);
+            }
+        }
+
+        if let Some(mut writer) = self.file_writer.lock().unwrap().take() {
             writer.finalize()?;
         }
 
         Ok(())
     }
 
-    /// Check if the streaming recorder is active
-    pub fn is_active(&self) -> bool {
-        self.recording_session.is_active()
-    }
-
     pub fn get_audio_level_receiver(&self) -> Option<Arc<Receiver<f32>>> {
         self.audio_level_receiver.clone()
     }

lib/recorder/src/recorder.rs

@@ -83,7 +83,6 @@ static CAPTURE_MEAN_TIME: Lazy<Mutex<Option<Duration>>> = Lazy::new(|| Mutex::ne
 ///     Err(e) => eprintln!("Recording failed: {}", e),
 /// }
 /// ```
-#[derive(Debug)]
 pub struct RecordingSession {
     config: RecorderConfig,