Initial commit

src/utilities.rs

@@ -0,0 +1,129 @@
+#[cfg(feature = "simd")]
+use std::simd::{f32x16, i16x16};
+
+/// 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.
+///
+/// # 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);
+    }
+    floats
+}
+
+/// Convert an array of 16 bit mono audio samples to a vector of 32 bit floats.
+///
+/// This variant uses SIMD instructions, and as such is only available on
+/// nightly Rust.
+///
+/// # Arguments
+/// * `samples` - The array of 16 bit mono audio samples.
+///
+/// # Returns
+/// A vector of 32 bit floats.
+#[cfg(feature = "simd")]
+pub fn convert_integer_to_float_audio_simd(samples: &[i16]) -> Vec<f32> {
+    let mut floats = Vec::with_capacity(samples.len());
+
+    let div_arr = f32x16::splat(32768.0);
+
+    let chunks = samples.chunks_exact(16);
+    let remainder = chunks.remainder();
+    for chunk in chunks {
+        let simd = i16x16::from_slice(chunk).cast::<f32>();
+        let simd = simd / div_arr;
+        floats.extend(&simd.to_array()[..]);
+    }
+
+    // Handle the remainder.
+    // do this normally because it's only a few samples and the overhead of
+    // converting to SIMD is not worth it.
+    for sample in remainder {
+        floats.push(*sample as f32 / 32768.0);
+    }
+
+    floats
+}
+
+/// Convert 32 bit floating point stereo PCM audio to 32 bit floating point mono PCM audio.
+///
+/// This variant does not use SIMD instructions.
+///
+/// # Arguments
+/// * `samples` - The array of 32 bit floating point stereo PCM audio samples.
+///
+/// # Returns
+/// A vector of 32 bit floating point mono PCM audio samples.
+pub fn convert_stereo_to_mono_audio(samples: &[f32]) -> Vec<f32> {
+    let mut mono = Vec::with_capacity(samples.len() / 2);
+    for i in (0..samples.len()).step_by(2) {
+        mono.push((samples[i] + samples[i + 1]) / 2.0);
+    }
+    mono
+}
+
+/// Convert 32 bit floating point stereo PCM audio to 32 bit floating point mono PCM audio.
+///
+/// This variant uses SIMD instructions, and as such is only available on
+/// nightly Rust.
+///
+/// # Arguments
+/// * `samples` - The array of 32 bit floating point stereo PCM audio samples.
+///
+/// # Returns
+/// A vector of 32 bit floating point mono PCM audio samples.
+#[cfg(feature = "simd")]
+pub fn convert_stereo_to_mono_audio_simd(samples: &[f32]) -> Vec<f32> {
+    let mut mono = Vec::with_capacity(samples.len() / 2);
+
+    let div_array = f32x16::splat(2.0);
+
+    let chunks = samples.chunks_exact(32);
+    let remainder = chunks.remainder();
+    for chunk in chunks {
+        let [c1, c2] = [0, 1].map(|offset| {
+            let mut arr = [0.0; 16];
+            std::iter::zip(&mut arr, chunk.iter().skip(offset).step_by(2).copied())
+                .for_each(|(a, c)| *a = c);
+            arr
+        });
+
+        let c1 = f32x16::from(c1);
+        let c2 = f32x16::from(c2);
+        let mono_simd = (c1 + c2) / div_array;
+        mono.extend(&mono_simd.to_array()[..]);
+    }
+
+    // Handle the remainder.
+    // do this normally because it's only a few samples and the overhead of
+    // converting to SIMD is not worth it.
+    for i in (0..remainder.len()).step_by(2) {
+        mono.push((remainder[i] + remainder[i + 1]) / 2.0);
+    }
+
+    mono
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    pub fn assert_stereo_to_mono_simd() {
+        // fake some sample data, of 1028 elements
+        let mut samples = Vec::with_capacity(1028);
+        for i in 0..1028 {
+            samples.push(i as f32);
+        }
+        let mono_simd = convert_stereo_to_mono_audio_simd(&samples);
+        let mono = convert_stereo_to_mono_audio(&samples);
+        assert_eq!(mono_simd, mono);
+    }
+}