update dependencies

own_mcp/src/audio/recording.rs

@@ -1,5 +1,5 @@
 use cpal::traits::{DeviceTrait, StreamTrait};
-use cpal::{BuildStreamError, Device, SampleFormat, SizedSample, Stream, SupportedStreamConfig};
+use cpal::{Device, Error, SampleFormat, SizedSample, Stream, SupportedStreamConfig};
 use hound::WavSpec;
 use log::{debug, error, info, trace};
 use std::fmt::Debug;
@@ -38,9 +38,9 @@ fn build_stream<T: SizedSample + Debug + hound::Sample + Send + Into<f64>>(
     device_config: SupportedStreamConfig,
     samples: SampleArc,
     sample_format: SampleFormat,
-) -> Result<Stream, BuildStreamError> {
+) -> Result<Stream, Error> {
     mic.build_input_stream(
-        &device_config.into(),
+        device_config.into(),
         move |input: &[T], _info| stream_callback::<T>(input, samples.clone(), sample_format),
         |e| {
             error!("a stream error occurred while trying to record: {:?}", e);
@@ -70,9 +70,7 @@ pub enum RecordingError {
     #[error("unsupported sample format")]
     UnsupportedSampleFormat(SampleFormat),
     #[error(transparent)]
-    PlayStreamError(#[from] cpal::PlayStreamError),
-    #[error(transparent)]
-    BuildStreamError(#[from] BuildStreamError),
+    StreamError(#[from] cpal::Error),
     #[error("thread poisoned")]
     ThreadPoison,
     #[error("recording was already stopped")]
@@ -81,23 +79,23 @@ pub enum RecordingError {
 
 fn start_recording_blocking_with_parameters(
     mic: &Device,
-    device_config: &SupportedStreamConfig,
+    device_config: SupportedStreamConfig,
     sample_format: SampleFormat,
     samples: SampleArc,
     should_stop: Arc<Mutex<bool>>,
 ) -> Result<(), RecordingError> {
     let stream = match sample_format {
         SampleFormat::I8 => {
-            build_stream::<i8>(mic, device_config.clone(), samples.clone(), sample_format)?
+            build_stream::<i8>(mic, device_config, samples.clone(), sample_format)?
         }
         SampleFormat::I16 => {
-            build_stream::<i16>(mic, device_config.clone(), samples.clone(), sample_format)?
+            build_stream::<i16>(mic, device_config, samples.clone(), sample_format)?
         }
         SampleFormat::I32 => {
-            build_stream::<i32>(mic, device_config.clone(), samples.clone(), sample_format)?
+            build_stream::<i32>(mic, device_config, samples.clone(), sample_format)?
         }
         SampleFormat::F32 => {
-            build_stream::<f32>(mic, device_config.clone(), samples.clone(), sample_format)?
+            build_stream::<f32>(mic, device_config, samples.clone(), sample_format)?
         }
         sample_format => {
             return Err(RecordingError::UnsupportedSampleFormat(sample_format));
@@ -135,11 +133,11 @@ pub fn start(
 
     let thread_samples = samples.clone();
     let thread_recording_stop = recording_should_stop.clone();
-    let thread_device_config = device_config.clone();
+    let thread_device_config = device_config;
     let record_thread_handle = thread::spawn(move || {
         start_recording_blocking_with_parameters(
             &microphone,
-            &thread_device_config,
+            thread_device_config,
             sample_format,
             thread_samples,
             thread_recording_stop,