perf: various optimizations

Signed-off-by: Maika Namuo <httpworldview@gmail.com>

Author: httpsworldview

src/dsp.rs

@@ -125,6 +125,7 @@ pub struct AudioBlock<'a> {
     pub sample_rate: f32,
     pub positions: [ChannelPosition; MAX_AUDIO_CHANNELS],
     stereo: [[f32; 2]; MAX_AUDIO_CHANNELS],
+    stereo_channels: usize,
 }
 
 fn stereo_indices(channels: usize, positions: [ChannelPosition; MAX_AUDIO_CHANNELS]) -> [usize; 2] {
@@ -207,17 +208,26 @@ impl<'a> AudioBlock<'a> {
         positions: [ChannelPosition; MAX_AUDIO_CHANNELS],
     ) -> Self {
         let channels = channels.clamp(1, MAX_AUDIO_CHANNELS);
+        let stereo_channels = (2..channels.min(samples.len()))
+            .rfind(|&channel| {
+                samples[channel..]
+                    .iter()
+                    .step_by(channels)
+                    .any(|sample| sample.to_bits() != 0)
+            })
+            .map_or(channels.min(2), |channel| channel + 1);
         Self {
             samples,
             channels,
             sample_rate: sanitize_sample_rate(sample_rate),
             positions,
             stereo: stereo_matrix(channels, positions),
+            stereo_channels,
         }
     }
 
-    pub fn stereo_matrix(&self) -> &[[f32; 2]; MAX_AUDIO_CHANNELS] {
-        &self.stereo
+    pub fn stereo_matrix(&self) -> &[[f32; 2]] {
+        &self.stereo[..self.stereo_channels]
     }
 
     pub fn frame_count(&self) -> usize {
@@ -230,83 +240,96 @@ impl<'a> AudioBlock<'a> {
 }
 
 #[derive(Debug, Clone, Copy)]
-struct CompensatedSum {
-    sum: f64,
-    correction: f64,
+struct CompensatedPair {
+    sums: [f64; 2],
+    corrections: [f64; 2],
 }
 
-impl CompensatedSum {
+impl CompensatedPair {
     const ZERO: Self = Self {
-        sum: 0.0,
-        correction: 0.0,
+        sums: [0.0; 2],
+        corrections: [0.0; 2],
     };
 
     // Kahan-Babuska-Neumaier compensated addition.
-    fn add(&mut self, value: f64) {
-        let next = self.sum + value;
-        self.correction += if self.sum.abs() >= value.abs() {
-            (self.sum - next) + value
+    fn add(&mut self, index: usize, value: f64) {
+        let next = self.sums[index] + value;
+        self.corrections[index] += if self.sums[index].abs() >= value.abs() {
+            (self.sums[index] - next) + value
         } else {
-            (value - next) + self.sum
+            (value - next) + self.sums[index]
         };
-        self.sum = next;
+        self.sums[index] = next;
+    }
+
+    fn add_both(&mut self, value: f64) {
+        (0..2).for_each(|index| self.add(index, value));
+    }
+
+    fn refresh(&mut self) {
+        (self.sums, self.corrections) = ([self.sums[1], 0.0], [self.corrections[1], 0.0]);
     }
 
     fn value(self) -> f64 {
-        self.sum + self.correction
+        self.sums[0] + self.corrections[0]
     }
 }
 
 /// Running means for several values over one or more independently sized windows.
 /// All windows share the ring sized for the longest duration.
 #[derive(Debug)]
-pub struct WindowedMeans<const VALUES: usize, const WINDOWS: usize> {
-    buffer: Box<[[f64; VALUES]]>,
+pub struct WindowedMeans<const VALUES: usize, const WINDOWS: usize, T = f64> {
+    buffer: Box<[[T; VALUES]]>,
     capacities: [usize; WINDOWS],
-    sums: [[CompensatedSum; VALUES]; WINDOWS],
-    // Periodic full-window sums bound compensation error without rescanning the ring.
-    refresh_sums: [[CompensatedSum; VALUES]; WINDOWS],
+    sums: [[CompensatedPair; VALUES]; WINDOWS],
     refresh_counts: [usize; WINDOWS],
     head: usize,
     count: usize,
 }
 
-impl<const VALUES: usize, const WINDOWS: usize> WindowedMeans<VALUES, WINDOWS> {
+impl<const VALUES: usize, const WINDOWS: usize, T> WindowedMeans<VALUES, WINDOWS, T>
+where
+    T: Copy + From<f32> + Into<f64>,
+{
     pub fn new(capacities: [usize; WINDOWS]) -> Self {
         let capacities = capacities.map(|capacity| capacity.max(1));
         let len = capacities.iter().copied().max().unwrap_or(1);
         Self {
-            buffer: vec![[0.0; VALUES]; len].into_boxed_slice(),
+            buffer: vec![[T::from(0.0); VALUES]; len].into_boxed_slice(),
             capacities,
-            sums: [[CompensatedSum::ZERO; VALUES]; WINDOWS],
-            refresh_sums: [[CompensatedSum::ZERO; VALUES]; WINDOWS],
+            sums: [[CompensatedPair::ZERO; VALUES]; WINDOWS],
             refresh_counts: [0; WINDOWS],
             head: 0,
             count: 0,
         }
     }
 
-    pub fn push<T: Copy + Into<f64>>(&mut self, values: [T; VALUES]) {
-        let values = values.map(|value| {
-            let value = value.into();
-            if value.is_finite() { value } else { 0.0 }
+    pub fn push(&mut self, mut values: [T; VALUES]) {
+        let mapped: [f64; VALUES] = std::array::from_fn(|index| {
+            let value = values[index].into();
+            if value.is_finite() {
+                value
+            } else {
+                values[index] = T::from(0.0);
+                0.0
+            }
         });
         let len = self.buffer.len();
         for window in 0..WINDOWS {
             let capacity = self.capacities[window];
             let old =
                 (self.count >= capacity).then(|| self.buffer[(self.head + len - capacity) % len]);
             for value in 0..VALUES {
-                self.sums[window][value].add(values[value]);
+                self.sums[window][value].add_both(mapped[value]);
                 if let Some(old) = old {
-                    self.sums[window][value].add(-old[value]);
+                    self.sums[window][value].add(0, -old[value].into());
                 }
-                self.refresh_sums[window][value].add(values[value]);
             }
             self.refresh_counts[window] += 1;
             if self.refresh_counts[window] == capacity {
-                self.sums[window] = self.refresh_sums[window];
-                self.refresh_sums[window] = [CompensatedSum::ZERO; VALUES];
+                self.sums[window]
+                    .iter_mut()
+                    .for_each(CompensatedPair::refresh);
                 self.refresh_counts[window] = 0;
             }
         }
@@ -315,18 +338,18 @@ impl<const VALUES: usize, const WINDOWS: usize> WindowedMeans<VALUES, WINDOWS> {
         self.count = (self.count + 1).min(len);
     }
 
+    pub fn with_leading_zeros(capacities: [usize; WINDOWS], count: usize) -> Self {
+        let mut means = Self::new(capacities);
+        means.head = count % means.buffer.len();
+        means.count = count.min(means.buffer.len());
+        means.refresh_counts = means.capacities.map(|capacity| count % capacity);
+        means
+    }
+
     pub fn mean(&self, window: usize) -> [f64; VALUES] {
         let count = self.count.min(self.capacities[window]).max(1);
         std::array::from_fn(|value| self.sums[window][value].value() / count as f64)
     }
-
-    pub fn clear(&mut self) {
-        self.sums = [[CompensatedSum::ZERO; VALUES]; WINDOWS];
-        self.refresh_sums = [[CompensatedSum::ZERO; VALUES]; WINDOWS];
-        self.refresh_counts = [0; WINDOWS];
-        self.head = 0;
-        self.count = 0;
-    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -584,29 +607,11 @@ mod tests {
         let mut unsupported = [Unknown; MAX_AUDIO_CHANNELS];
         unsupported[..2].copy_from_slice(&[LowFrequency, Aux(0)]);
         assert_eq!(
-            &AudioBlock::with_positions(&[], 2, 48_000.0, unsupported).stereo_matrix()[..2],
+            AudioBlock::with_positions(&[], 8, 48_000.0, unsupported).stereo_matrix(),
             &[[1.0, 0.0], [0.0, 1.0]]
         );
     }
 
-    #[test]
-    fn running_means_clear_without_reallocating_or_replaying_old_values() {
-        let mut means = WindowedMeans::<1, 2>::new([2, 4]);
-        for value in [1.0, 2.0, 3.0, 4.0] {
-            means.push([value]);
-        }
-        let storage = means.buffer.as_ptr();
-        means.clear();
-        assert_eq!(means.mean(0), [0.0]);
-        assert_eq!(means.mean(1), [0.0]);
-        assert_eq!(means.buffer.as_ptr(), storage);
-
-        means.push([10.0]);
-        means.push([20.0]);
-        assert_eq!(means.mean(0), [15.0]);
-        assert_eq!(means.mean(1), [15.0]);
-    }
-
     #[test]
     fn running_means_sanitize_non_finite_values_without_poisoning_state() {
         let mut means = WindowedMeans::<1, 1>::new([1]);
@@ -632,7 +637,7 @@ mod tests {
         }
         assert_eq!(means.mean(0), [1.0]);
 
-        means.clear();
+        let mut means = WindowedMeans::<1, 1>::new([2]);
         for value in [1.0e100, 2.0, 1.0e-100, 1.0e-100] {
             means.push([value]);
         }