Implement buffer-less true-peak scanning

- Split interp::Frame into utils::FrameAcc based on dasp::Frame and
  utils::Samples::foreach_frame
- Push incoming frame:s directly onto the interpolator, one at a time, and
  check sample-max on resulting frames immediately. This removes the need
  for input and output-buffering.

Author: rawler

src/interp.rs

@@ -19,7 +19,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-trait Interpolator: std::fmt::Debug {
+pub(crate) trait Interpolator: std::fmt::Debug {
     fn process(&mut self, src: &[f32], dst: &mut [f32]);
     fn reset(&mut self);
     fn get_factor(&self) -> usize;
@@ -29,21 +29,8 @@ trait Interpolator: std::fmt::Debug {
 pub struct Interp(Box<dyn Interpolator>);
 
 impl Interp {
-    pub fn new(taps: usize, factor: usize, channels: u32) -> Self {
-        let imp: Box<dyn Interpolator> = match (taps, factor, channels) {
-            (49, 2, 1) => Box::new(specialized::Interp2F::<[f32; 1]>::new()),
-            (49, 2, 2) => Box::new(specialized::Interp2F::<[f32; 2]>::new()),
-            (49, 2, 4) => Box::new(specialized::Interp2F::<[f32; 4]>::new()),
-            (49, 2, 6) => Box::new(specialized::Interp2F::<[f32; 6]>::new()),
-            (49, 2, 8) => Box::new(specialized::Interp2F::<[f32; 8]>::new()),
-            (49, 4, 1) => Box::new(specialized::Interp4F::<[f32; 1]>::new()),
-            (49, 4, 2) => Box::new(specialized::Interp4F::<[f32; 2]>::new()),
-            (49, 4, 4) => Box::new(specialized::Interp4F::<[f32; 4]>::new()),
-            (49, 4, 6) => Box::new(specialized::Interp4F::<[f32; 6]>::new()),
-            (49, 4, 8) => Box::new(specialized::Interp4F::<[f32; 8]>::new()),
-            (taps, factor, channels) => Box::new(generic::Interp::new(taps, factor, channels)),
-        };
-        Self(imp)
+    pub fn new(_taps: usize, _factor: usize, _channels: u32) -> Self {
+        unimplemented!()
     }
 
     pub fn process(&mut self, src: &[f32], dst: &mut [f32]) {
@@ -59,7 +46,7 @@ impl Interp {
     }
 }
 
-mod generic {
+pub mod generic {
     use smallvec::SmallVec;
     use std::f64;
     /// Data structure for polyphase FIR interpolator
@@ -209,161 +196,8 @@ mod generic {
     }
 }
 
-/// A trait to be generic over number of channels in a of frame
-///
-/// TODO: Might want to use dasp-frame instead here, but needs
-/// coordination with `Samples` trait
-trait Frame: Sized + Copy {
-    const CHANNELS: usize;
-
-    fn scale_add(&mut self, other: &Self, coeff: f32);
-    fn from_planar(slice: &[f32], stride: usize) -> Self;
-}
-
-type MonoFrame32 = [f32; 1];
-type StereoFrame32 = [f32; 2];
-type QuadFrame32 = [f32; 4];
-type SurroundFrame32 = [f32; 6];
-type Surround8Frame32 = [f32; 8];
-
-impl Frame for MonoFrame32 {
-    const CHANNELS: usize = 1;
-
-    #[inline(always)]
-    fn scale_add(&mut self, other: &Self, coeff: f32) {
-        for i in 0..Self::CHANNELS {
-            #[cfg(feature = "precision-true-peak")]
-            {
-                self[i] = other[i].mul_add(coeff, self[i]);
-            }
-            #[cfg(not(feature = "precision-true-peak"))]
-            {
-                self[i] += other[i] * coeff;
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn from_planar(slice: &[f32], _stride: usize) -> Self {
-        [slice[0]]
-    }
-}
-
-impl Frame for StereoFrame32 {
-    const CHANNELS: usize = 2;
-
-    #[inline(always)]
-    fn scale_add(&mut self, other: &Self, coeff: f32) {
-        for i in 0..Self::CHANNELS {
-            #[cfg(feature = "precision-true-peak")]
-            {
-                self[i] = other[i].mul_add(coeff, self[i]);
-            }
-            #[cfg(not(feature = "precision-true-peak"))]
-            {
-                self[i] += other[i] * coeff;
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn from_planar(slice: &[f32], stride: usize) -> Self {
-        [slice[0], slice[stride]]
-    }
-}
-
-impl Frame for QuadFrame32 {
-    const CHANNELS: usize = 4;
-
-    #[inline(always)]
-    fn scale_add(&mut self, other: &Self, coeff: f32) {
-        for i in 0..Self::CHANNELS {
-            #[cfg(feature = "precision-true-peak")]
-            {
-                self[i] = other[i].mul_add(coeff, self[i]);
-            }
-            #[cfg(not(feature = "precision-true-peak"))]
-            {
-                self[i] += other[i] * coeff;
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn from_planar(slice: &[f32], stride: usize) -> Self {
-        [
-            slice[0],
-            slice[stride],
-            slice[2 * stride],
-            slice[3 * stride],
-        ]
-    }
-}
-
-impl Frame for SurroundFrame32 {
-    const CHANNELS: usize = 6;
-
-    #[inline(always)]
-    fn scale_add(&mut self, other: &Self, coeff: f32) {
-        for i in 0..Self::CHANNELS {
-            #[cfg(feature = "precision-true-peak")]
-            {
-                self[i] = other[i].mul_add(coeff, self[i]);
-            }
-            #[cfg(not(feature = "precision-true-peak"))]
-            {
-                self[i] += other[i] * coeff;
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn from_planar(slice: &[f32], stride: usize) -> Self {
-        [
-            slice[0],
-            slice[stride],
-            slice[2 * stride],
-            slice[3 * stride],
-            slice[4 * stride],
-            slice[5 * stride],
-        ]
-    }
-}
-
-impl Frame for Surround8Frame32 {
-    const CHANNELS: usize = 8;
-
-    #[inline(always)]
-    fn scale_add(&mut self, other: &Self, coeff: f32) {
-        for i in 0..Self::CHANNELS {
-            #[cfg(feature = "precision-true-peak")]
-            {
-                self[i] = other[i].mul_add(coeff, self[i]);
-            }
-            #[cfg(not(feature = "precision-true-peak"))]
-            {
-                self[i] += other[i] * coeff;
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn from_planar(slice: &[f32], stride: usize) -> Self {
-        [
-            slice[0],
-            slice[stride],
-            slice[2 * stride],
-            slice[3 * stride],
-            slice[4 * stride],
-            slice[5 * stride],
-            slice[6 * stride],
-            slice[7 * stride],
-        ]
-    }
-}
-
-mod specialized {
-    use super::Frame;
+pub mod specialized {
+    use crate::utils::FrameAccumulator;
     use std::f64::consts::PI;
 
     const ALMOST_ZERO: f64 = 0.000001;
@@ -374,18 +208,18 @@ mod specialized {
     const FACTOR2: usize = 2;
     const FACTOR2_INPUT_LENGTH: usize = TAPS / FACTOR2;
 
-    #[derive(Debug)]
-    pub(super) struct Interp4F<F: Frame> {
+    #[derive(Debug, Clone)]
+    pub(crate) struct Interp4F<F: FrameAccumulator> {
         filter: [[f32; FACTOR4]; FACTOR4_INPUT_LENGTH],
         buffer: [F; FACTOR4_INPUT_LENGTH],
         buffer_pos: usize,
     }
 
     impl<F> Interp4F<F>
     where
-        F: Frame + Default,
+        F: FrameAccumulator + Default,
     {
-        pub(super) fn new() -> Self {
+        pub(crate) fn new() -> Self {
             let mut filter: [[_; FACTOR4]; FACTOR4_INPUT_LENGTH] = Default::default();
             for (j, coeff) in filter
                 .iter_mut()
@@ -415,7 +249,7 @@ mod specialized {
             }
         }
 
-        pub(super) fn push(&mut self, frame: &F) -> [F; FACTOR4] {
+        pub(crate) fn push(&mut self, frame: &F) -> [F; FACTOR4] {
             // Write in Frames in reverse, to enable forward-scanning with filter
             self.buffer_pos = (self.buffer_pos + self.buffer.len() - 1) % self.buffer.len();
             self.buffer[self.buffer_pos] = *frame;
@@ -441,48 +275,24 @@ mod specialized {
 
             output
         }
-    }
 
-    impl<F> super::Interpolator for Interp4F<F>
-    where
-        F: Frame + std::fmt::Debug + Default + AsRef<[f32]>,
-    {
-        fn process(&mut self, src: &[f32], dst: &mut [f32]) {
-            assert_eq!(0, src.len() % F::CHANNELS);
-            assert_eq!(src.len() * FACTOR4, dst.len());
-            let frames = src.len() / F::CHANNELS;
-
-            for i in 0..frames {
-                let res = self.push(&F::from_planar(&src[i..], frames));
-                for c in 0..F::CHANNELS {
-                    for (f, frame) in res.iter().enumerate() {
-                        dst[c * frames * FACTOR4 + i * FACTOR4 + f] = frame.as_ref()[c];
-                    }
-                }
-            }
-        }
-
-        fn reset(&mut self) {
+        pub(crate) fn reset(&mut self) {
             self.buffer = Default::default();
         }
-
-        fn get_factor(&self) -> usize {
-            4
-        }
     }
 
-    #[derive(Debug)]
-    pub(super) struct Interp2F<F: Frame> {
+    #[derive(Debug, Clone)]
+    pub(crate) struct Interp2F<F: FrameAccumulator> {
         filter: [[f32; FACTOR2]; FACTOR2_INPUT_LENGTH],
         buffer: [F; FACTOR2_INPUT_LENGTH],
         buffer_pos: usize,
     }
 
     impl<F> Interp2F<F>
     where
-        F: Frame + Default,
+        F: FrameAccumulator + Default,
     {
-        pub(super) fn new() -> Self {
+        pub(crate) fn new() -> Self {
             let mut filter: [[_; FACTOR2]; FACTOR2_INPUT_LENGTH] = Default::default();
             for (j, coeff) in filter
                 .iter_mut()
@@ -512,7 +322,7 @@ mod specialized {
             }
         }
 
-        pub(super) fn push(&mut self, frame: &F) -> [F; FACTOR2] {
+        pub(crate) fn push(&mut self, frame: &F) -> [F; FACTOR2] {
             // Write in Frames in reverse, to enable forward-scanning with filter
             self.buffer_pos = (self.buffer_pos + self.buffer.len() - 1) % self.buffer.len();
             self.buffer[self.buffer_pos] = *frame;
@@ -538,34 +348,10 @@ mod specialized {
 
             output
         }
-    }
-
-    impl<F> super::Interpolator for Interp2F<F>
-    where
-        F: Frame + std::fmt::Debug + Default + AsRef<[f32]>,
-    {
-        fn process(&mut self, src: &[f32], dst: &mut [f32]) {
-            assert_eq!(0, src.len() % F::CHANNELS);
-            assert_eq!(src.len() * FACTOR2, dst.len());
-            let frames = src.len() / F::CHANNELS;
-
-            for i in 0..frames {
-                let res = self.push(&F::from_planar(&src[i..], frames));
-                for c in 0..F::CHANNELS {
-                    for (f, frame) in res.iter().enumerate() {
-                        dst[c * frames * FACTOR2 + i * FACTOR2 + f] = frame.as_ref()[c];
-                    }
-                }
-            }
-        }
 
-        fn reset(&mut self) {
+        pub(crate) fn reset(&mut self) {
             self.buffer = Default::default();
         }
-
-        fn get_factor(&self) -> usize {
-            2
-        }
     }
 }