added new fucntions and improved code

Author: marci1175

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "silence-core"
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 description = "Core audio I/O abstractions for the silence crate."
 license = "Apache-2.0"

Cargo.toml

@@ -1,6 +1,6 @@
 //! Offers audio recording capabilities via being a middleware on [`cpal`].
 
-use std::{sync::Arc, thread::JoinHandle};
+use std::{collections::VecDeque, sync::Arc, thread::{sleep, JoinHandle}, time::Duration};
 
 use cpal::{
     traits::{DeviceTrait, StreamTrait},
@@ -22,8 +22,58 @@ use super::InputDevice;
 /// The `err_callback` callback is called if an error occurs in the [`DeviceTrait::build_input_stream`] whilst recording.
 /// The function returns an error if an error occured outside of the [`DeviceTrait::build_input_stream`] function.
 pub fn record_audio_with_interrupt<E>(
+    input_device: InputDevice,
     interrupt: tokio::sync::oneshot::Receiver<()>,
+    err_callback: E,
+    config: StreamConfig,
+) -> anyhow::Result<Arc<Mutex<VecDeque<f32>>>>
+where
+    E: FnMut(StreamError) + Send + 'static,
+{
+    let buffer_handle: Arc<parking_lot::lock_api::Mutex<parking_lot::RawMutex, VecDeque<f32>>> =
+        Arc::new(parking_lot::Mutex::new(VecDeque::new()));
+    let buffer_handle_clone = buffer_handle.clone();
+
+    let _: JoinHandle<anyhow::Result<()>> = std::thread::spawn(move || {
+        let stream: cpal::Stream = input_device.build_input_stream(
+            &config,
+            move |data: &[f32], _info: &cpal::InputCallbackInfo| {
+                let mut buffer_handle = buffer_handle_clone.lock();
+                for sample in data.iter() {
+                    buffer_handle.push_back(*sample);
+                }
+            },
+            err_callback,
+            None,
+        )?;
+
+        //Start stream
+        stream.play()?;
+
+        //Wait for interrupt
+        interrupt.blocking_recv()?;
+
+        //Return from thread
+        Ok(())
+    });
+
+    Ok(buffer_handle)
+}
+
+///
+/// Records audio until the user interrupts it.
+///
+/// # Behavior
+/// The recording thread is automaticly started at the creation of the (Input)[`cpal::Stream`].
+/// Records audio until (Pushes the samples into the [`Arc<Mutex<Vec<f32>>>`]) the [`tokio::sync::oneshot::Receiver`] receives a message.
+/// The [`Sync`] buffer is returned and can be accessed.
+///
+/// # Error
+/// The `err_callback` callback is called if an error occurs in the [`DeviceTrait::build_input_stream`] whilst recording.
+/// The function returns an error if an error occured outside of the [`DeviceTrait::build_input_stream`] function.
+pub fn record_audio_with_duration<E>(
     input_device: InputDevice,
+    duration: Duration,
     err_callback: E,
     config: StreamConfig,
 ) -> anyhow::Result<Arc<Mutex<Vec<f32>>>>
@@ -50,8 +100,8 @@ where
         //Start stream
         stream.play()?;
 
-        //Wait for interrupt
-        interrupt.blocking_recv()?;
+        //Sleep the thread
+        sleep(duration);
 
         //Return from thread
         Ok(())

src/io/record.rs

@@ -3,7 +3,7 @@
 
 #[cfg(test)]
 mod tests {
-    use std::{fs, thread::sleep, time::Duration};
+    use std::{collections::VecDeque, fs, thread::sleep, time::Duration};
 
     use cpal::traits::{DeviceTrait, StreamTrait};
     use opencv::videoio::{CAP_ANY, CAP_MSMF};
@@ -91,12 +91,12 @@ mod tests {
         sleep(Duration::from_secs(2));
     }
 
-    fn record_audio(input_device: cpal::Device, config: cpal::SupportedStreamConfig) -> Vec<f32> {
+    fn record_audio(input_device: cpal::Device, config: cpal::SupportedStreamConfig) -> VecDeque<f32> {
         let (sender, receiver) = oneshot::channel::<()>();
         let err_callback = |err| eprintln!("an error occurred on stream: {}", err);
 
         let buffer_handle =
-            record_audio_with_interrupt(receiver, input_device, err_callback, config.into())
+            record_audio_with_interrupt(input_device, receiver, err_callback, config.into())
                 .unwrap();
 
         sleep(Duration::from_secs(3));
@@ -125,7 +125,7 @@ mod tests {
         )
         .unwrap();
 
-        let sound_packets = encode_samples_opus(encoder, &sample, 20, channels).unwrap();
+        let sound_packets = encode_samples_opus(encoder, &Into::<Vec<f32>>::into(sample), 20, channels).unwrap();
 
         let decoder = create_opus_decoder(48000).unwrap();