Merge branch 'master' into RustAudio#145 to include changes from RustAudio#146

Author: linclelinkpart5

dasp_frame/src/lib.rs

@@ -5,6 +5,8 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use core::iter::DoubleEndedIterator;
+
 use dasp_sample::Sample;
 
 /// Represents one sample from each channel at a single discrete instance in time within a
@@ -81,9 +83,34 @@ pub trait Frame: Copy + Clone + PartialEq {
     /// Converts the frame into an iterator yielding the sample for each channel in the frame.
     fn channels(self) -> Self::Channels;
 
+    /// Returns an iterator yielding references to the sample for each channel in the frame.
+    fn channels_ref(&self) -> ChannelsRef<'_, Self>;
+
+    /// Like [`channels_ref()`], but yields mutable references instead.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use dasp_frame::Frame;
+    ///
+    /// fn main() {
+    ///     let mut foo = [1000i32, 2000, 3000];
+    ///     let mut offset = 100i32;
+    ///     for f in foo.channels_mut() {
+    ///         *f = *f + offset;
+    ///         offset += 100;
+    ///     }
+    ///     assert_eq!(foo, [1100i32, 2200, 3300]);
+    /// }
+    /// ```
+    fn channels_mut(&mut self) -> ChannelsMut<'_, Self>;
+
     /// Yields a reference to the `Sample` of the channel at the given index if there is one.
     fn channel(&self, idx: usize) -> Option<&Self::Sample>;
 
+    /// Like [`channel()`], but yields a mutable reference instead.
+    fn channel_mut(&mut self, idx: usize) -> Option<&mut Self::Sample>;
+
     /// Returns a pointer to the sample of the channel at the given index, without doing bounds
     /// checking.
     ///
@@ -92,6 +119,9 @@ pub trait Frame: Copy + Clone + PartialEq {
     /// at *compile-time*.
     unsafe fn channel_unchecked(&self, idx: usize) -> &Self::Sample;
 
+    /// Like [`channel_unchecked()`], but yields a mutable reference instead.
+    unsafe fn channel_unchecked_mut(&mut self, idx: usize) -> &mut Self::Sample;
+
     /// Applies the given function to each sample in the `Frame` in channel order and returns the
     /// result as a new `Frame`.
     ///
@@ -258,6 +288,13 @@ pub struct Channels<F> {
     frame: F,
 }
 
+/// An iterator that yields the sample for each channel in the frame by reference.
+#[derive(Clone)]
+pub struct ChannelsRef<'a, F: Frame>(core::slice::Iter<'a, F::Sample>);
+
+/// Like [`ChannelsRef`], but yields mutable references instead.
+pub struct ChannelsMut<'a, F: Frame>(core::slice::IterMut<'a, F::Sample>);
+
 macro_rules! impl_frame_for_fixed_size_array {
     ($($NChan:ident $N:expr, [$($idx:expr)*],)*) => {
         $(
@@ -286,11 +323,26 @@ macro_rules! impl_frame_for_fixed_size_array {
                     }
                 }
 
+                #[inline]
+                fn channels_ref(&self) -> ChannelsRef<'_, Self> {
+                    ChannelsRef(self.iter())
+                }
+
+                #[inline]
+                fn channels_mut(&mut self) -> ChannelsMut<'_, Self> {
+                    ChannelsMut(self.iter_mut())
+                }
+
                 #[inline]
                 fn channel(&self, idx: usize) -> Option<&Self::Sample> {
                     self.get(idx)
                 }
 
+                #[inline]
+                fn channel_mut(&mut self, idx: usize) -> Option<&mut Self::Sample> {
+                    self.get_mut(idx)
+                }
+
                 #[inline]
                 fn from_fn<F>(mut from: F) -> Self
                 where
@@ -318,6 +370,11 @@ macro_rules! impl_frame_for_fixed_size_array {
                     self.get_unchecked(idx)
                 }
 
+                #[inline(always)]
+                unsafe fn channel_unchecked_mut(&mut self, idx: usize) -> &mut Self::Sample {
+                    self.get_unchecked_mut(idx)
+                }
+
                 #[inline]
                 fn to_signed_frame(self) -> Self::Signed {
                     self.map(|s| s.to_sample())
@@ -445,6 +502,16 @@ macro_rules! impl_frame_for_sample {
                     }
                 }
 
+                #[inline]
+                fn channels_ref(&self) -> ChannelsRef<'_, Self> {
+                    ChannelsRef(core::slice::from_ref(self).iter())
+                }
+
+                #[inline]
+                fn channels_mut(&mut self) -> ChannelsMut<'_, Self> {
+                    ChannelsMut(core::slice::from_mut(self).iter_mut())
+                }
+
                 #[inline]
                 fn channel(&self, idx: usize) -> Option<&Self::Sample> {
                     if idx == 0 {
@@ -454,6 +521,15 @@ macro_rules! impl_frame_for_sample {
                     }
                 }
 
+                #[inline]
+                fn channel_mut(&mut self, idx: usize) -> Option<&mut Self::Sample> {
+                    if idx == 0 {
+                        Some(self)
+                    } else {
+                        None
+                    }
+                }
+
                 #[inline]
                 fn from_fn<F>(mut from: F) -> Self
                 where
@@ -475,6 +551,11 @@ macro_rules! impl_frame_for_sample {
                     self
                 }
 
+                #[inline(always)]
+                unsafe fn channel_unchecked_mut(&mut self, _idx: usize) -> &mut Self::Sample {
+                    self
+                }
+
                 #[inline]
                 fn to_signed_frame(self) -> Self::Signed {
                     self.to_signed_sample()
@@ -577,3 +658,59 @@ where
         F::CHANNELS - self.next_idx
     }
 }
+
+impl<'a, F: Frame> Iterator for ChannelsRef<'a, F> {
+    type Item = &'a F::Sample;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+impl<'a, F: Frame> ExactSizeIterator for ChannelsRef<'a, F> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+impl<'a, F: Frame> DoubleEndedIterator for ChannelsRef<'a, F> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.0.next_back()
+    }
+}
+
+impl<'a, F: Frame> Iterator for ChannelsMut<'a, F> {
+    type Item = &'a mut F::Sample;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+impl<'a, F: Frame> ExactSizeIterator for ChannelsMut<'a, F> {
+    #[inline]
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+impl<'a, F: Frame> DoubleEndedIterator for ChannelsMut<'a, F> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.0.next_back()
+    }
+}

dasp_interpolate/src/sinc/mod.rs

@@ -92,8 +92,8 @@ where
             v = {
                 let a = PI * (phil + n as f64);
                 let first = if a == 0.0 { 1.0 } else { sin(a) / a };
-                let second = 0.5 + 0.5 * cos(a / (phil + max_depth as f64));
-                v.zip_map(self.frames[nr - n], |vs, r_lag| {
+                let second = 0.5 + 0.5 * cos(a / depth as f64);
+                v.zip_map(self.frames[nl - n], |vs, r_lag| {
                     vs.add_amp(
                         (first * second * r_lag.to_sample::<f64>())
                             .to_sample::<<Self::Frame as Frame>::Sample>()
@@ -104,8 +104,8 @@ where
 
             let a = PI * (phir + n as f64);
             let first = if a == 0.0 { 1.0 } else { sin(a) / a };
-            let second = 0.5 + 0.5 * cos(a / (phir + max_depth as f64));
-            v.zip_map(self.frames[nl + n], |vs, r_lag| {
+            let second = 0.5 + 0.5 * cos(a / depth as f64);
+            v.zip_map(self.frames[nr + n], |vs, r_lag| {
                 vs.add_amp(
                     (first * second * r_lag.to_sample::<f64>())
                         .to_sample::<<Self::Frame as Frame>::Sample>()