Update audio utilities

src/utilities.rs

@@ -1,33 +1,59 @@
+use crate::WhisperError;
+
 /// Convert an array of 16 bit mono audio samples to a vector of 32 bit floats.
 ///
-/// This variant does not use SIMD instructions.
-///
 /// # Arguments
 /// * `samples` - The array of 16 bit mono audio samples.
+/// * `output` - The vector of 32 bit floats to write the converted samples to.
 ///
-/// # Returns
-/// A vector of 32 bit floats.
-pub fn convert_integer_to_float_audio(samples: &[i16]) -> Vec<f32> {
-    let mut floats = Vec::with_capacity(samples.len());
-    for sample in samples {
-        floats.push(*sample as f32 / 32768.0);
+/// # Panics
+/// * if `samples.len != output.len()`
+///
+/// # Examples
+/// ```
+/// # use whisper_rs::convert_integer_to_float_audio;
+/// let samples = [0i16; 1024];
+/// let mut output = vec![0.0f32; samples.len()];
+/// convert_integer_to_float_audio(&samples, &mut output).expect("input and output lengths should be equal");
+/// ```
+pub fn convert_integer_to_float_audio(
+    samples: &[i16],
+    output: &mut [f32],
+) -> Result<(), WhisperError> {
+    if samples.len() != output.len() {
+        return Err(WhisperError::InputOutputLengthMismatch {
+            input_len: samples.len(),
+            output_len: output.len(),
+        });
     }
-    floats
+
+    for (input, output) in samples.iter().zip(output.iter_mut()) {
+        *output = *input as f32 / 32768.0;
+    }
+
+    Ok(())
 }
 
-/// Convert 32 bit floating point stereo PCM audio to 32 bit floating point mono PCM audio.
-///
-/// This variant does not use SIMD instructions.
+/// Convert 32-bit floating point stereo PCM audio to 32-bit floating point mono PCM audio.
 ///
 /// # Arguments
-/// * `samples` - The array of 32 bit floating point stereo PCM audio samples.
+/// * `samples` - The array of 32-bit floating point stereo PCM audio samples.
+///
+/// # Errors
+/// * if `samples.len()` is odd
 ///
 /// # Returns
-/// A vector of 32 bit floating point mono PCM audio samples.
-pub fn convert_stereo_to_mono_audio(samples: &[f32]) -> Result<Vec<f32>, &'static str> {
+/// A vector of 32-bit floating point mono PCM audio samples.
+///
+/// # Examples
+/// ```
+/// # use whisper_rs::convert_stereo_to_mono_audio;
+/// let samples = [0.0f32; 1024];
+/// let mono = convert_stereo_to_mono_audio(&samples).expect("should be no half samples missing");
+/// ```
+pub fn convert_stereo_to_mono_audio(samples: &[f32]) -> Result<Vec<f32>, WhisperError> {
     if samples.len() & 1 != 0 {
-        return Err("The stereo audio vector has an odd number of samples. \
-            This means a half-sample is missing somewhere");
+        return Err(WhisperError::HalfSampleMissing(samples.len()));
     }
 
     Ok(samples
@@ -36,16 +62,51 @@ pub fn convert_stereo_to_mono_audio(samples: &[f32]) -> Result<Vec<f32>, &'stati
         .collect())
 }
 
-#[cfg(feature = "simd")]
 #[cfg(test)]
 mod test {
     use super::*;
+    use rand::distributions::{Distribution, Standard};
+    use rand::Rng;
+    use std::hint::black_box;
+
+    extern crate test;
+
+    fn random_sample_data<T>() -> Vec<T>
+    where
+        Standard: Distribution<T>,
+    {
+        const SAMPLE_SIZE: usize = 1_048_576;
+
+        let mut rng = rand::thread_rng();
+        let mut samples = Vec::with_capacity(SAMPLE_SIZE);
+        for _ in 0..SAMPLE_SIZE {
+            samples.push(rng.gen::<T>());
+        }
+        samples
+    }
 
     #[test]
     pub fn assert_stereo_to_mono_err() {
-        // fake some sample data
-        let samples = (0u16..1029).map(f32::from).collect::<Vec<f32>>();
+        let samples = random_sample_data::<f32>();
         let mono = convert_stereo_to_mono_audio(&samples);
         assert!(mono.is_err());
     }
+
+    #[bench]
+    pub fn bench_stereo_to_mono(b: &mut test::Bencher) {
+        let samples = random_sample_data::<f32>();
+        b.iter(|| black_box(convert_stereo_to_mono_audio(black_box(&samples))));
+    }
+
+    #[bench]
+    pub fn bench_integer_to_float(b: &mut test::Bencher) {
+        let samples = random_sample_data::<i16>();
+        let mut output = vec![0.0f32; samples.len()];
+        b.iter(|| {
+            black_box(convert_integer_to_float_audio(
+                black_box(&samples),
+                black_box(&mut output),
+            ))
+        });
+    }
 }