audio 0.2.1

use std::cmp;
use std::fmt;
use std::hash;
use std::ptr;

use audio_core::{
    Buf, BufMut, ExactSizeBuf, InterleavedBuf, InterleavedBufMut, ResizableBuf, Sample, UniformBuf,
};

use crate::buf::interleaved::{IterChannels, IterChannelsMut};
use crate::channel::{InterleavedChannel, InterleavedChannelMut};
use crate::frame::{InterleavedFrame, InterleavedFramesIter, RawInterleaved};

/// A dynamically sized, multi-channel interleaved audio buffer.
///
/// An audio buffer can only be resized if it contains a type which is
/// sample-apt. For more information of what this means, see [Sample].
///
/// An *interleaved* audio buffer stores all audio data interleaved in memory,
/// one sample from each channel in sequence until we're out of samples. This
/// naturally makes the buffer a bit harder to work with, and we have to rely on
/// iterators to access logical channels.
///
/// Resized regions aren't zeroed, so certain operations might cause stale data
/// to be visible after a resize.
///
/// ```
/// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 4);
///
/// for (c, s) in buf
///     .get_mut(0)
///     .unwrap()
///     .iter_mut()
///     .zip(&[1.0, 2.0, 3.0, 4.0])
/// {
///     *c = *s;
/// }
///
/// for (c, s) in buf
///     .get_mut(1)
///     .unwrap()
///     .iter_mut()
///     .zip(&[5.0, 6.0, 7.0, 8.0])
/// {
///     *c = *s;
/// }
///
/// assert_eq!(buf.as_slice(), &[1.0, 5.0, 2.0, 6.0, 3.0, 7.0, 4.0, 8.0]);
/// ```
#[derive(Default)]
pub struct Interleaved<T> {
    data: Vec<T>,
    channels: usize,
    frames: usize,
}

impl<T> Interleaved<T> {
    /// Construct a new empty audio buffer.
    ///
    /// # Examples
    ///
    /// ```
    /// let buf = audio::buf::Interleaved::<f32>::new();
    ///
    /// assert_eq!(buf.frames(), 0);
    /// ```
    pub fn new() -> Self {
        Self {
            data: Vec::new(),
            channels: 0,
            frames: 0,
        }
    }

    /// Allocate an audio buffer with the given topology. A "topology" is a
    /// given number of `channels` and the corresponding number of `frames` in
    /// their buffers.
    ///
    /// # Examples
    ///
    /// ```
    /// let buf = audio::buf::Interleaved::<f32>::with_topology(4, 256);
    ///
    /// assert_eq!(buf.frames(), 256);
    /// assert_eq!(buf.channels(), 4);
    /// ```
    pub fn with_topology(channels: usize, frames: usize) -> Self
    where
        T: Sample,
    {
        Self {
            data: vec![T::ZERO; channels * frames],
            channels,
            frames,
        }
    }

    /// Allocate an audio buffer from a fixed-size array.
    ///
    /// See [dynamic!].
    ///
    /// # Examples
    ///
    /// ```
    /// let buf = audio::interleaved![[2.0; 256]; 4];
    ///
    /// assert_eq!(buf.frames(), 256);
    /// assert_eq!(buf.channels(), 4);
    ///
    /// for chan in &buf {
    ///     assert!(chan.iter().eq([2.0; 256]));
    /// }
    /// ```
    pub fn from_vec(data: Vec<T>, channels: usize, frames: usize) -> Self {
        Self {
            data,
            channels,
            frames,
        }
    }

    /// Allocate an interleaved audio buffer from a fixed-size array acting as a
    /// template for all the channels.
    ///
    /// See [sequential!].
    ///
    /// # Examples
    ///
    /// ```
    /// let buf = audio::buf::Interleaved::from_frames([1.0, 2.0, 3.0, 4.0], 4);
    ///
    /// assert_eq!(buf.frames(), 4);
    /// assert_eq!(buf.channels(), 4);
    /// ```
    pub fn from_frames<const N: usize>(frames: [T; N], channels: usize) -> Self
    where
        T: Copy,
    {
        return Self {
            data: data_from_frames(frames, channels),
            channels,
            frames: N,
        };

        fn data_from_frames<T, const N: usize>(frames: [T; N], channels: usize) -> Vec<T>
        where
            T: Copy,
        {
            let mut data = Vec::with_capacity(N * channels);

            for f in frames {
                for _ in 0..channels {
                    data.push(f);
                }
            }

            data
        }
    }

    /// Allocate an interleaved audio buffer from a fixed-size array.
    ///
    /// See [interleaved!].
    ///
    /// # Examples
    ///
    /// ```
    /// let buf = audio::buf::Interleaved::from_array([[1; 4]; 2]);
    ///
    /// assert_eq!(buf.frames(), 4);
    /// assert_eq!(buf.channels(), 2);
    ///
    /// assert_eq! {
    ///     buf.as_slice(),
    ///     &[1, 1, 1, 1, 1, 1, 1, 1],
    /// }
    /// ```
    ///
    /// Using a specific array topology.
    ///
    /// ```
    /// let buf = audio::buf::Interleaved::from_array([[1, 2, 3, 4], [5, 6, 7, 8]]);
    ///
    /// assert_eq!(buf.frames(), 4);
    /// assert_eq!(buf.channels(), 2);
    ///
    /// assert_eq! {
    ///     buf.as_slice(),
    ///     &[1, 5, 2, 6, 3, 7, 4, 8],
    /// }
    /// ```
    pub fn from_array<const F: usize, const C: usize>(channels: [[T; F]; C]) -> Self
    where
        T: Copy,
    {
        return Self {
            data: data_from_array(channels),
            channels: C,
            frames: F,
        };

        #[inline]
        fn data_from_array<T, const F: usize, const C: usize>(channels: [[T; F]; C]) -> Vec<T> {
            let mut data = Vec::with_capacity(C * F);

            // TODO: It would be nice to avoid this heap allocation! Could be
            // done w/ ArrayVec, but we don't want to pull that dependency.
            let mut vecs: Vec<_> = IntoIterator::into_iter(channels)
                .map(IntoIterator::into_iter)
                .collect();

            for _ in 0..F {
                for v in vecs.iter_mut() {
                    data.extend(v.next());
                }
            }

            data
        }
    }

    /// Take ownership of the backing vector.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 4);
    ///
    /// for (c, s) in buf.get_mut(0).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) {
    ///     *c = *s;
    /// }
    ///
    /// for (c, s) in buf.get_mut(1).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) {
    ///     *c = *s;
    /// }
    ///
    /// buf.resize_frames(3);
    ///
    /// assert_eq!(buf.into_vec(), vec![1.0, 1.0, 2.0, 2.0, 3.0, 3.0])
    /// ```
    pub fn into_vec(self) -> Vec<T> {
        self.data
    }

    /// Access the underlying vector as a slice.
    ///
    /// # Examples
    ///
    /// ```
    /// let buf = audio::buf::Interleaved::<i16>::with_topology(2, 4);
    /// assert_eq!(buf.as_slice(), &[0, 0, 0, 0, 0, 0, 0, 0]);
    /// ```
    pub fn as_slice(&self) -> &[T] {
        &self.data
    }

    /// Access the underlying vector as a mutable slice.
    ///
    /// # Examples
    ///
    /// ```
    /// use audio::{Buf, Channel};
    ///
    /// let mut buf = audio::buf::Interleaved::<u32>::with_topology(2, 4);
    /// buf.as_slice_mut().copy_from_slice(&[1, 1, 2, 2, 3, 3, 4, 4]);
    ///
    /// assert_eq! {
    ///     buf.get_channel(0).unwrap(),
    ///     [1u32, 2, 3, 4],
    /// };
    ///
    /// assert_eq! {
    ///     buf.get_channel(1).unwrap(),
    ///     [1u32, 2, 3, 4],
    /// };
    ///
    /// assert_eq!(buf.as_slice(), &[1, 1, 2, 2, 3, 3, 4, 4]);
    /// ```
    pub fn as_slice_mut(&mut self) -> &mut [T] {
        &mut self.data
    }

    /// Get the capacity of the interleaved buffer in number of frames.
    ///
    /// The underlying buffer over-allocates a bit, so this will report the
    /// exact capacity available in the interleaved buffer.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::new();
    ///
    /// assert_eq!(buf.capacity(), 0);
    ///
    /// buf.resize_frames(11);
    /// assert!(buf.capacity() >= 0);
    ///
    /// buf.resize_channels(2);
    /// assert!(buf.capacity() >= 22);
    ///
    /// buf.resize_frames(12);
    /// assert!(buf.capacity() >= 44);
    ///
    /// buf.resize_frames(24);
    /// assert!(buf.capacity() >= 44);
    /// ```
    pub fn capacity(&self) -> usize {
        self.data.capacity()
    }

    /// Get the number of frames in the buffer.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::new();
    ///
    /// assert_eq!(buf.frames(), 0);
    /// buf.resize_frames(4);
    /// assert_eq!(buf.frames(), 4);
    /// ```
    pub fn frames(&self) -> usize {
        self.frames
    }

    /// Get the number of channels in the buffer.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::new();
    ///
    /// assert_eq!(buf.channels(), 0);
    /// buf.resize_channels(2);
    /// assert_eq!(buf.channels(), 2);
    /// ```
    pub fn channels(&self) -> usize {
        self.channels
    }

    /// Resize to the given number of channels in use.
    ///
    /// If the size of the buffer increases as a result, the new channels will
    /// be zeroed. If the size decreases, the channels that falls outside of the
    /// new size will be dropped.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::new();
    ///
    /// assert_eq!(buf.channels(), 0);
    /// assert_eq!(buf.frames(), 0);
    ///
    /// buf.resize_channels(4);
    /// buf.resize_frames(256);
    ///
    /// assert_eq!(buf.channels(), 4);
    /// assert_eq!(buf.frames(), 256);
    /// ```
    pub fn resize_channels(&mut self, channels: usize)
    where
        T: Sample,
    {
        self.inner_resize(channels, self.frames);
    }

    /// Set the size of the buffer. The size is the size of each channel's
    /// buffer.
    ///
    /// If the size of the buffer increases as a result, the new regions in the
    /// frames will be zeroed. If the size decreases, the region will be left
    /// untouched. So if followed by another increase, the data will be "dirty".
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::new();
    ///
    /// assert_eq!(buf.channels(), 0);
    /// assert_eq!(buf.frames(), 0);
    ///
    /// buf.resize_channels(4);
    /// buf.resize_frames(256);
    ///
    /// assert_eq!(buf.channels(), 4);
    /// assert_eq!(buf.frames(), 256);
    ///
    /// {
    ///     let mut chan = buf.get_mut(1).unwrap();
    ///
    ///     assert_eq!(chan.get(127), Some(0.0));
    ///     *chan.get_mut(127).unwrap() = 42.0;
    ///     assert_eq!(chan.get(127), Some(42.0));
    /// }
    ///
    /// buf.resize_frames(128);
    /// assert_eq!(buf.sample(1, 127), Some(42.0));
    ///
    /// buf.resize_frames(256);
    /// assert_eq!(buf.sample(1, 127), Some(42.0));
    ///
    /// buf.resize_channels(2);
    /// assert_eq!(buf.sample(1, 127), Some(42.0));
    ///
    /// buf.resize_frames(64);
    /// assert_eq!(buf.sample(1, 127), None);
    /// ```
    pub fn resize_frames(&mut self, frames: usize)
    where
        T: Sample,
    {
        self.inner_resize(self.channels, frames);
    }

    /// Get a reference to a channel.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 4);
    ///
    /// for (c, s) in buf.get_mut(0).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) {
    ///     *c = *s;
    /// }
    ///
    /// for (c, s) in buf.get_mut(1).unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) {
    ///     *c = *s;
    /// }
    ///
    /// assert_eq!(buf.get_channel(0).unwrap().iter().nth(2), Some(3.0));
    /// assert_eq!(buf.get_channel(1).unwrap().iter().nth(2), Some(7.0));
    /// ```
    pub fn get_channel(&self, channel: usize) -> Option<InterleavedChannel<'_, T>> {
        if channel < self.channels {
            unsafe {
                let ptr = ptr::NonNull::new_unchecked(self.data.as_ptr() as *mut _);
                let len = self.data.len();
                Some(InterleavedChannel::new_unchecked(
                    ptr,
                    len,
                    channel,
                    self.channels,
                ))
            }
        } else {
            None
        }
    }

    /// Helper to access a single frame in a single channel.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 256);
    ///
    /// assert_eq!(buf.sample(1, 128), Some(0.0));
    /// *buf.sample_mut(1, 128).unwrap() = 1.0;
    /// assert_eq!(buf.sample(1, 128), Some(1.0));
    /// ```
    pub fn sample(&self, channel: usize, frame: usize) -> Option<T>
    where
        T: Copy,
    {
        self.get_channel(channel)?.get(frame)
    }

    /// Get a mutable reference to a channel.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 4);
    ///
    /// for (c, s) in buf.get_mut(0).unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) {
    ///     *c = *s;
    /// }
    ///
    /// for (c, s) in buf.get_mut(1).unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) {
    ///     *c = *s;
    /// }
    ///
    /// assert_eq!(buf.as_slice(), &[1.0, 5.0, 2.0, 6.0, 3.0, 7.0, 4.0, 8.0]);
    /// ```
    pub fn get_mut(&mut self, channel: usize) -> Option<InterleavedChannelMut<'_, T>> {
        if channel < self.channels {
            unsafe {
                let ptr = ptr::NonNull::new_unchecked(self.data.as_mut_ptr());
                let len = self.data.len();
                Some(InterleavedChannelMut::new_unchecked(
                    ptr,
                    len,
                    channel,
                    self.channels,
                ))
            }
        } else {
            None
        }
    }

    /// Helper to access a single sample in a single channel mutably.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 256);
    ///
    /// assert_eq!(buf.sample(1, 128), Some(0.0));
    /// *buf.sample_mut(1, 128).unwrap() = 1.0;
    /// assert_eq!(buf.sample(1, 128), Some(1.0));
    /// ```
    #[inline]
    pub fn sample_mut(&mut self, channel: usize, frame: usize) -> Option<&mut T> {
        self.get_mut(channel)?.into_mut(frame)
    }

    /// Access the raw sequential buffer.
    #[inline]
    fn as_raw(&self) -> RawInterleaved<T> {
        // SAFETY: construction of the current buffer ensures this is safe.
        unsafe { RawInterleaved::new(&self.data, self.channels, self.frames) }
    }

    /// The internal resize function for interleaved channel buffers.
    /// Note: this is safe only because of the `T: Sample` bound. DO NOT REMOVE.
    fn inner_resize(&mut self, channels: usize, frames: usize)
    where
        T: Sample,
    {
        if self.channels == channels && self.frames == frames {
            return;
        }

        self.inner_reserve_cap(frames.saturating_mul(channels));

        if self.channels != channels {
            let len = usize::min(self.channels, channels);

            // Safety: We trust the known lengths lengths.
            unsafe {
                if channels < self.channels {
                    self.inner_shuffle_channels(1..frames, len, channels);
                } else {
                    self.inner_shuffle_channels((1..frames).rev(), len, channels);
                }
            }
        }

        self.channels = channels;
        self.frames = frames;
    }

    /// Note: this is safe only because of the `T: Sample` bound. DO NOT REMOVE.
    fn inner_reserve_cap(&mut self, new_cap: usize)
    where
        T: Sample,
    {
        let old_cap = self.data.capacity();

        if new_cap > old_cap {
            self.data.reserve(new_cap - self.data.len());
            let new_cap = self.data.capacity();

            // Safety: capacity is governed by the underlying vector.
            unsafe {
                ptr::write_bytes(self.data.as_mut_ptr().add(old_cap), 0, new_cap - old_cap);
            }
        }

        // Safety: since we're decreasing the number of frames we're sure
        // that the data for them is already allocated.
        unsafe {
            self.data.set_len(new_cap);
        }
    }

    /// Internal function to re-shuffle channels.
    ///
    /// # Safety
    ///
    /// The caller must ensure that the ranges of frames, the length and that
    /// the updates `channels` argument is validly within the buffer.
    #[inline]
    unsafe fn inner_shuffle_channels<F>(&mut self, frames: F, len: usize, channels: usize)
    where
        F: IntoIterator<Item = usize>,
    {
        let base = self.data.as_mut_ptr();

        for f in frames {
            let from = f * self.channels;
            let to = f * channels;
            ptr::copy(base.add(from), base.add(to), len)
        }
    }
}

impl<T> Interleaved<T>
where
    T: Copy,
{
    /// Construct an iterator over all available channels.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 4);
    ///
    /// let mut it = buf.iter_channels_mut();
    ///
    /// for (c, f) in it.next().unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) {
    ///     *c = *f;
    /// }
    ///
    /// for (c, f) in it.next().unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) {
    ///     *c = *f;
    /// }
    ///
    /// let channels = buf.iter_channels().collect::<Vec<_>>();
    /// let left = channels[0].iter().collect::<Vec<_>>();
    /// let right = channels[1].iter().collect::<Vec<_>>();
    ///
    /// assert_eq!(left, &[1.0, 2.0, 3.0, 4.0]);
    /// assert_eq!(right, &[5.0, 6.0, 7.0, 8.0]);
    /// ```
    pub fn iter_channels(&self) -> IterChannels<'_, T> {
        unsafe {
            IterChannels::new_unchecked(
                ptr::NonNull::new_unchecked(self.data.as_ptr() as *mut _),
                self.data.len(),
                self.channels,
            )
        }
    }

    /// Construct a mutable iterator over all available channels.
    ///
    /// # Examples
    ///
    /// ```
    /// let mut buf = audio::buf::Interleaved::<f32>::with_topology(2, 4);
    ///
    /// let mut it = buf.iter_channels_mut();
    ///
    /// for (c, f) in it.next().unwrap().iter_mut().zip(&[1.0, 2.0, 3.0, 4.0]) {
    ///     *c = *f;
    /// }
    ///
    /// for (c, f) in it.next().unwrap().iter_mut().zip(&[5.0, 6.0, 7.0, 8.0]) {
    ///     *c = *f;
    /// }
    ///
    /// let channels = buf.iter_channels().collect::<Vec<_>>();
    /// let left = channels[0].iter().collect::<Vec<_>>();
    /// let right = channels[1].iter().collect::<Vec<_>>();
    ///
    /// assert_eq!(left, &[1.0, 2.0, 3.0, 4.0]);
    /// assert_eq!(right, &[5.0, 6.0, 7.0, 8.0]);
    /// ```
    pub fn iter_channels_mut(&mut self) -> IterChannelsMut<'_, T> {
        unsafe {
            IterChannelsMut::new_unchecked(
                ptr::NonNull::new_unchecked(self.data.as_mut_ptr()),
                self.data.len(),
                self.channels,
            )
        }
    }
}

impl<T> fmt::Debug for Interleaved<T>
where
    T: Copy + fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_list().entries(self.iter_channels()).finish()
    }
}

impl<T> cmp::PartialEq for Interleaved<T>
where
    T: Copy + cmp::PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        self.iter_channels().eq(other.iter_channels())
    }
}

impl<T> cmp::Eq for Interleaved<T> where T: Copy + cmp::Eq {}

impl<T> cmp::PartialOrd for Interleaved<T>
where
    T: Copy + cmp::PartialOrd,
{
    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
        self.iter_channels().partial_cmp(other.iter_channels())
    }
}

impl<T> cmp::Ord for Interleaved<T>
where
    T: Copy + cmp::Ord,
{
    fn cmp(&self, other: &Self) -> cmp::Ordering {
        self.iter_channels().cmp(other.iter_channels())
    }
}

impl<T> hash::Hash for Interleaved<T>
where
    T: Copy + hash::Hash,
{
    fn hash<H: hash::Hasher>(&self, state: &mut H) {
        for channel in self.iter_channels() {
            for f in channel.iter() {
                f.hash(state);
            }
        }
    }
}

impl<T> ExactSizeBuf for Interleaved<T>
where
    T: Copy,
{
    #[inline]
    fn frames(&self) -> usize {
        (*self).frames()
    }
}

impl<T> Buf for Interleaved<T>
where
    T: Copy,
{
    type Sample = T;

    type Channel<'this>
        = InterleavedChannel<'this, Self::Sample>
    where
        Self::Sample: 'this;

    type IterChannels<'this>
        = IterChannels<'this, Self::Sample>
    where
        Self::Sample: 'this;

    #[inline]
    fn frames_hint(&self) -> Option<usize> {
        Some(self.frames)
    }

    #[inline]
    fn channels(&self) -> usize {
        self.channels
    }

    #[inline]
    fn get_channel(&self, channel: usize) -> Option<Self::Channel<'_>> {
        InterleavedChannel::from_slice(&self.data, channel, self.channels)
    }

    #[inline]
    fn iter_channels(&self) -> Self::IterChannels<'_> {
        (*self).iter_channels()
    }
}

impl<T> UniformBuf for Interleaved<T>
where
    T: Copy,
{
    type Frame<'this>
        = InterleavedFrame<'this, T>
    where
        Self: 'this;

    type IterFrames<'this>
        = InterleavedFramesIter<'this, T>
    where
        Self: 'this;

    #[inline]
    fn get_frame(&self, frame: usize) -> Option<Self::Frame<'_>> {
        if frame >= self.frames {
            return None;
        }

        Some(InterleavedFrame::new(frame, self.as_raw()))
    }

    #[inline]
    fn iter_frames(&self) -> Self::IterFrames<'_> {
        InterleavedFramesIter::new(0, self.as_raw())
    }
}

impl<T> ResizableBuf for Interleaved<T>
where
    T: Sample,
{
    #[inline]
    fn try_reserve(&mut self, capacity: usize) -> bool {
        self.inner_reserve_cap(capacity);
        true
    }

    #[inline]
    fn resize_frames(&mut self, frames: usize) {
        (*self).resize_frames(frames);
    }

    #[inline]
    fn resize_topology(&mut self, channels: usize, frames: usize) {
        self.inner_resize(channels, frames);
    }
}

impl<T> BufMut for Interleaved<T>
where
    T: Copy,
{
    type ChannelMut<'this>
        = InterleavedChannelMut<'this, Self::Sample>
    where
        Self::Sample: 'this;

    type IterChannelsMut<'this>
        = IterChannelsMut<'this, Self::Sample>
    where
        Self::Sample: 'this;

    #[inline]
    fn get_channel_mut(&mut self, channel: usize) -> Option<Self::ChannelMut<'_>> {
        InterleavedChannelMut::from_slice(&mut self.data, channel, self.channels)
    }

    fn copy_channel(&mut self, from: usize, to: usize) {
        // Safety: We're making sure not to access any mutable buffers which
        // are not initialized.
        unsafe {
            crate::utils::copy_channels_interleaved(
                ptr::NonNull::new_unchecked(self.data.as_mut_ptr()),
                self.channels,
                self.frames,
                from,
                to,
            )
        }
    }

    #[inline]
    fn iter_channels_mut(&mut self) -> Self::IterChannelsMut<'_> {
        (*self).iter_channels_mut()
    }

    #[inline]
    fn fill(&mut self, value: T)
    where
        T: Copy,
    {
        self.data.fill(value);
    }
}

impl<'a, T> IntoIterator for &'a Interleaved<T>
where
    T: Copy,
{
    type IntoIter = IterChannels<'a, T>;
    type Item = <Self::IntoIter as Iterator>::Item;

    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        (*self).iter_channels()
    }
}

impl<T> InterleavedBuf for Interleaved<T>
where
    T: Copy,
{
    type Sample = T;

    #[inline]
    fn as_interleaved(&self) -> &[Self::Sample] {
        self.as_slice()
    }
}

impl<T> InterleavedBufMut for Interleaved<T>
where
    T: Copy,
{
    #[inline]
    fn as_interleaved_mut(&mut self) -> &mut [Self::Sample] {
        self.as_slice_mut()
    }

    #[inline]
    fn as_interleaved_mut_ptr(&mut self) -> ptr::NonNull<Self::Sample> {
        unsafe { ptr::NonNull::new_unchecked(self.data.as_mut_ptr()) }
    }

    #[inline]
    unsafe fn set_interleaved_topology(&mut self, channels: usize, frames: usize) {
        self.channels = channels;
        self.frames = frames;
    }
}